SeparateSweepsWithEnclaveTaskingAbstract.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/accelerator/accelerator.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,
      PlottingAfterGridInitialisation,
      RungeKuttaPrimarySubStep0AfterGridInitialisation,
      Plotting {% for item in range(RK_STEPS) -%}
      ,
      RungeKuttaPrimarySubStep{{item}},
      RungeKuttaSecondarySubStep{{item}}
      {%- endfor %}
    };
 
    static std::string toString(SolverState);
 
    static constexpr int  NumberOfGridCellsPerPatchPerAxis = {{NUMBER_OF_GRID_CELLS_PER_PATCH_PER_AXIS}};
 
    static constexpr double MaxAdmissiblePatchH    = {{MAX_GRID_CELL_H}} * NumberOfGridCellsPerPatchPerAxis;
    static constexpr double MaxAdmissibleGridCellH = {{MAX_GRID_CELL_H}};
    static constexpr double MaxAdmissibleCellH     = MaxAdmissiblePatchH;
 
    static constexpr double MinAdmissiblePatchH    = {{MIN_GRID_CELL_H}} * NumberOfGridCellsPerPatchPerAxis;
    static constexpr double MinAdmissibleGridCellH = {{MIN_GRID_CELL_H}};
    static constexpr double MinAdmissibleCellH     = MinAdmissiblePatchH;
 
 
    {{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>&  meshCellCentre,
      const tarch::la::Vector<Dimensions,double>&  meshCellH,
      double                                       t
    ) {% if REFINEMENT_CRITERION_IMPLEMENTATION=="<user-defined>" %}= 0{% else %} final {% endif %};
 
 
    virtual void initialCondition(
      double * __restrict__ Q,
      const tarch::la::Vector<Dimensions,double>&  meshCellCentre,
      const tarch::la::Vector<Dimensions,double>&  meshCellH,
      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,
      const tarch::la::Vector<Dimensions,double>&  meshCellH,
      double                                       t,
      int                                          normal
    ) {% if BOUNDARY_CONDITIONS_IMPLEMENTATION=="<user-defined>" %}= 0{% else %} final{% endif %};
    {% endif %}
 
 
 
 
    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;
 
 
    double getMaxPatchSize(bool currentTimeStep = true) const;
    double getMinPatchSize(bool currentTimeStep = true) const;
    double getMaxGridCellSize(bool currentTimeStep = true) const;
    double getMinGridCellSize(bool currentTimeStep = true) const;
 
    virtual double getMaxMeshSize() const override final;
    virtual double getMinMeshSize() const override final;
 
    void update(double timeStepSize, double timeStamp, double patchSize);
 
    SolverState  getSolverState() const;
 
    #if defined(GPUOffloadingOMP)
    #pragma omp declare target
    #endif
    static constexpr int    NumberOfUnknowns           = {{NUMBER_OF_UNKNOWNS}};
    static constexpr int    NumberOfAuxiliaryVariables = {{NUMBER_OF_AUXILIARY_VARIABLES}};
    {{SOLVER_CONSTANTS}}
    #if defined(GPUOffloadingOMP)
    #pragma omp end declare target
    #endif
 
    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 patchCanUseStatelessPDETerms(
      const tarch::la::Vector<Dimensions,double>&  patchCentre,
      const tarch::la::Vector<Dimensions,double>&  patchH,
      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     _minGridCellH;
    double     _maxGridCellH;
 
    double     _minGridCellHThisTimeStep;
    double     _maxGridCellHThisTimeStep;
 
    double     _minTimeStepSize;
    double     _maxTimeStepSize;
 
    double     _minTimeStepSizeThisTimeStep;
    double     _maxTimeStepSizeThisTimeStep;
 
    int        _patchUpdates;
 
    tarch::multicore::BooleanSemaphore  _semaphore;
 
  {{ABSTRACT_SOLVER_USER_DECLARATIONS}}
};
 
 
 
{# Empty line here #}