PosterioriLimitingAbstract.template.h

Go to the documentation of this file.

// **********************************************************************************************
// ***                                     !!!WARNING!!!                                      ***
// *** WARNING: AUTO GENERATED FILE! DO NOT MODIFY BY HAND! YOUR CHANGES WILL BE OVERWRITTEN! ***
// ***                                     !!!WARNING!!!                                      ***
// ***                  Generated by Peano's Python API: www.peano-framework.org              ***
// **********************************************************************************************
#pragma once
 
#include "Constants.h"
 
#include "exahype2/Solver.h"
 
#include "tarch/NonCriticalAssertions.h"
#include "tarch/la/Vector.h"
#include "tarch/logging/Log.h"
#include "tarch/mpi/Rank.h"
#include "tarch/multicore/BooleanSemaphore.h"
 
#include "peano4/utils/Globals.h"
 
#include "kernels/{{SOLVER_NAME}}/Quadrature.h"
 
{{SOLVER_INCLUDES}}
 
{% for item in NAMESPACE -%}
  namespace {{ item }} {
 
{%- endfor %}
  class {{CLASSNAME}};
 
{% for item in NAMESPACE -%}
  }
{%- endfor %}
 
class {{NAMESPACE | join("::")}}::{{CLASSNAME}}: public ::exahype2::Solver {
  public:
    enum class SolverState {
      GridConstruction,
      GridInitialisation,
      RegularSolver,
      LimiterStatusSpreadingToNeighbours,
      LimiterStatusSpreadingToSecondNeighbours,
      LimiterSolver,
      Plotting,
      Suspended
    };
 
    static std::string toString(SolverState);
 
    {{CLASSNAME}}();
    ~{{CLASSNAME}}();
 
    SolverState  getSolverState() const;
 
    double getMinTimeStamp(bool ofCurrentlyRunningGridSweep=false) const final;
    double getMaxTimeStamp(bool ofCurrentlyRunningGridSweep=false) const final;
    double getMinTimeStepSize() const final;
    double getMaxTimeStepSize() const final;
 
    virtual double getMaxMeshSize() const override final;
    virtual double getMinMeshSize() const override final;
 
    //TODO: link these to the max and min of the other solvers
    static constexpr double MaxAdmissibleCellH  = 1000.;
    static constexpr double MinAdmissibleCellH  = 0.;
 
    virtual void startGridConstructionStep() override;
 
    virtual void finishGridConstructionStep() override;
 
 
    virtual void startGridInitialisationStep() override;
 
    virtual void finishGridInitialisationStep() override;
 
 
    virtual void suspendSolversForOneGridSweep() override;
 
 
    virtual void startTimeStep(
      double globalMinTimeStamp,
      double globalMaxTimeStamp,
      double globalMinTimeStepSize,
      double globalMaxTimeStepSize
    ) override;
 
    virtual void finishTimeStep() override;
 
 
    virtual void startPlottingStep(
      double globalMinTimeStamp,
      double globalMaxTimeStamp,
      double globalMinTimeStepSize,
      double globalMaxTimeStepSize
    ) override;
 
    virtual void finishPlottingStep() override;
 
    virtual bool mayPlot() const override;
 
    bool isFirstGridSweepOfTimeStep() const;
    bool isLastGridSweepOfTimeStep() const;
 
    virtual void startSimulation() override;
 
    virtual void finishSimulation() override;
 
 
    public:
        static constexpr int NumberOfDMPObservables    = {{NUMBER_OF_DMP_OBSERVABLES}};
        static constexpr double RelaxationParameter    = {{DMP_RELAXATION_PARAMETER}};
        static constexpr double DifferencesScaling     = {{DMP_DIFFERENCES_SCALING}};
 
        void addTroubledCell();
        int getNumberOfTroubledCells() const;
 
        void mapDiscreteMaximumPrincipleObservables(double* const observables, const double* const Q) const {
          if (NumberOfDMPObservables>0) {
            std::copy_n(Q,NumberOfDMPObservables,observables);
          }
        }
 
        double getDiscreteMaximumPrincipleRelaxationParameter(
            const double& specifiedRelaxationParameter,
            const int&    observable,
            const double& localMin,
            const double& localMax,
            const double& boundaryMinPerObservable,
            const double& previousMax) const {
          return specifiedRelaxationParameter;
        }
 
{% if ADMISSIBILITY_IMPLEMENTATION!="<none>" %}
    virtual bool isPhysicallyAdmissible(
        const double* const                         Q,
        const tarch::la::Vector<Dimensions,double>& x,
        const tarch::la::Vector<Dimensions,double>& h,
        const double timeStamp) {% if ADMISSIBILITY_IMPLEMENTATION=="<user-defined>" %} = 0 {% else %} final {% endif %};
{% endif %}
 
  protected:
    static tarch::logging::Log  _log;
 
    SolverState  _solverState;
 
    int        _cellUpdates;
 
    int        _numberOfTroubledCellsThisTimeStep;
 
    tarch::multicore::BooleanSemaphore  _semaphore;
 
  {{SOLVER_USER_DECLARATIONS}}
};