SeparateSweepsAbstract.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 "exahype2/RefinementControl.h"
#include "exahype2/Solver.h"
#include "tarch/la/Vector.h"
#include "tarch/multicore/BooleanSemaphore.h"
#include "tarch/NonCriticalAssertions.h"
 
#include "peano4/utils/Globals.h"
 
#include "Constants.h"
 
{% if USE_VARIABLE_SHORTCUT is sameas True %}
#include "VariableShortcuts.h"
{% endif %}
 
{{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,
      Suspended,
      Plotting {% for item in range(RK_STEPS) -%}
      ,
      ProjectOnFacesAndComputeVolumeIntegralOfStep{{item}},
      SolveRiemannProblemAndAddToVolumeIntegralOfStep{{item}}
      {%- endfor %}
    };
 
    static std::string toString(SolverState);
 
    static constexpr int  DGOrder = {{DG_ORDER}};
 
    static constexpr double MaxAdmissibleCellH  = {{MAX_CELL_H}};
 
    static constexpr int    NumberOfUnknowns           = {{NUMBER_OF_UNKNOWNS}};
    static constexpr int    NumberOfAuxiliaryVariables = {{NUMBER_OF_AUXILIARY_VARIABLES}};
 
    static constexpr double MinAdmissibleCellH  = {{MIN_CELL_H}};
 
{{BASIS_DECLARATIONS | indent(4,True) }}
 
    {{SOLVER_CONSTANTS}}
 
    {{CLASSNAME}}();
 
    static std::bitset<Dimensions> PeriodicBC;
 
    double getMinTimeStamp(bool ofCurrentlyRunningGridSweep=false) const final;
    double getMaxTimeStamp(bool ofCurrentlyRunningGridSweep=false) const final;
    double getMinTimeStepSize() const final;
    double getMaxTimeStepSize() const final;
 
    virtual ::exahype2::RefinementCommand refinementCriterion(
      const double * __restrict__                  Q,    // Q[{{NUMBER_OF_UNKNOWNS}}+{{NUMBER_OF_AUXILIARY_VARIABLES}}]
      const tarch::la::Vector<Dimensions,double>&  volumeCentre,
      const tarch::la::Vector<Dimensions,double>&  volumeH,
      double                                       t
    ) {% if REFINEMENT_CRITERION_IMPLEMENTATION=="<user-defined>" %}= 0{% else %} final {% endif %};
 
    virtual void initialCondition(
      double * __restrict__                        Q,     // Q[{{NUMBER_OF_UNKNOWNS}}+{{NUMBER_OF_AUXILIARY_VARIABLES}}]
      const tarch::la::Vector<Dimensions,double>&  x,
      const tarch::la::Vector<Dimensions,double>&  h,
      const tarch::la::Vector<Dimensions,int>&     index,
      bool                                         gridIsConstructed
    ) {% if INITIAL_CONDITIONS_IMPLEMENTATION=="<user-defined>" %}= 0{% else %} final {% endif %};
 
    {% if BOUNDARY_CONDITIONS_IMPLEMENTATION=="<none>" %}
    {% else %}
    virtual void boundaryConditions(
      const double * __restrict__                  Qinside, // Qinside[{{NUMBER_OF_UNKNOWNS}}+{{NUMBER_OF_AUXILIARY_VARIABLES}}]
      double * __restrict__                        Qoutside, // Qoutside[{{NUMBER_OF_UNKNOWNS}}+{{NUMBER_OF_AUXILIARY_VARIABLES}}]
      const tarch::la::Vector<Dimensions,double>&  faceCentre,
      double                                       t,
      int                                          normal
    ) {% if BOUNDARY_CONDITIONS_IMPLEMENTATION=="<user-defined>" %}= 0{% else %} final{% endif %};
    {% endif %}
 
 
    virtual void suspendSolversForOneGridSweep() override;
 
    virtual void startGridConstructionStep() override;
 
    virtual void finishGridConstructionStep() override;
 
    virtual void startGridInitialisationStep() override;
 
    virtual void finishGridInitialisationStep() 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;
 
    double getMaxCellSize(bool currentTimeStep = true) const;
    double getMinCellSize(bool currentTimeStep = true) const;
 
    virtual double getMaxMeshSize() const override final;
    virtual double getMinMeshSize() const override final;
 
    void update(double timeStepSize, double timeStamp, double cellSize);
 
    SolverState  getSolverState() const;
 
    virtual bool mayPlot() const override;
 
    bool isFirstGridSweepOfTimeStep() const;
    bool isLastGridSweepOfTimeStep() const;
 
    virtual void startSimulation() override;
 
    virtual void finishSimulation() override;
 
    {% if STATELESS_PDE_TERMS %}
    {% else %}
    {% endif %}
    virtual bool cellCanUseStatelessPDETerms(
      const tarch::la::Vector<Dimensions,double>&  cellCentre,
      const tarch::la::Vector<Dimensions,double>&  cellH,
      double                                       t,
      double                                       dt
    ) const;
 
  protected:
    static tarch::logging::Log  _log;
 
    SolverState  _solverState;
 
    double     _minTimeStamp;
    double     _maxTimeStamp;
 
    double     _minTimeStampThisTimeStep;
    double     _maxTimeStampThisTimeStep;
 
    double     _localMinTimeStampThisTimeStep;
    double     _localMaxTimeStampThisTimeStep;
 
    double     _minCellH;
    double     _maxCellH;
 
    double     _minCellHThisTimeStep;
    double     _maxCellHThisTimeStep;
 
    double     _minTimeStepSize;
    double     _maxTimeStepSize;
 
    double     _minTimeStepSizeThisTimeStep;
    double     _maxTimeStepSizeThisTimeStep;
 
    int        _cellUpdates;
 
    tarch::multicore::BooleanSemaphore  _semaphore;
 
  {{ABSTRACT_SOLVER_USER_DECLARATIONS}}
};