implement WENO limiter for DG method

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;
     /**

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

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:

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;
       /** @} */
 
 

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.")
+    }
+  }
+}

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."));