StaticLimitingAbstract.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,
      LimiterStatusSpreadingToNeighbours,
      TimeStep,
      Plotting,
      PlottingAfterGridInitialisation,
      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:
        void addTroubledCell();
        int getNumberOfTroubledCells() const;
 
        void mapDiscreteMaximumPrincipleObservables(double* const observables, const double* const Q) const {
          ::tarch::triggerNonCriticalAssertion( __FILE__, __LINE__, "map discrete maximum principle observables was called, it should never be.", "" );
        }
 
        double getDiscreteMaximumPrincipleRelaxationParameter(
          const double& specifiedRelaxationParameter,
          const int&    observable,
          const double& localMin,
          const double& localMax,
          const double& boundaryMinPerObservable,
          const double& previousMax) const {
            ::tarch::triggerNonCriticalAssertion( __FILE__, __LINE__, "get discrete maximum principle relaxation parameter was called, it should never be.", "" );
            return 0.0;
        }
 
{% 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        _totalNumberOfTroubledCells;
 
    tarch::multicore::BooleanSemaphore  _semaphore;
 
  {{SOLVER_USER_DECLARATIONS}}
};