EnclaveTaskingAbstract.template.h

Go to the documentation of this file.

// This file is part of the ExaHyPE2 project. For conditions of distribution and
// use, please see the copyright notice at 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 "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,
      Primary,
      Secondary,
      PlottingInitialCondition,
      PrimaryAfterGridInitialisation,
      Plotting,
      Suspended
    };
 
    static std::string toString(SolverState);
 
    static constexpr int  NumberOfFiniteVolumesPerAxisPerPatch = {{NUMBER_OF_VOLUMES_PER_AXIS}};
 
    static constexpr double MaxAdmissiblePatchH  = {{MAX_VOLUME_H}} * NumberOfFiniteVolumesPerAxisPerPatch;
    static constexpr double MaxAdmissibleVolumeH = {{MAX_VOLUME_H}};
    static constexpr double MaxAdmissibleCellH   = MaxAdmissiblePatchH;
 
    static constexpr double MinAdmissiblePatchH  = {{MIN_VOLUME_H}} * NumberOfFiniteVolumesPerAxisPerPatch;
    static constexpr double MinAdmissibleVolumeH = {{MIN_VOLUME_H}};
    static constexpr double MinAdmissibleCellH   = MinAdmissiblePatchH;
 
    {{CLASSNAME}}();
 
    static std::bitset<Dimensions> PeriodicBC;
 
    double getMinTimeStamp() const final;
    double getMaxTimeStamp() const final;
    double getMinTimeStepSize() const final;
    double getMaxTimeStepSize() const final;
 
    virtual ::exahype2::RefinementCommand refinementCriterion(
      [[maybe_unused]] const double* __restrict__                   Q, // Q[{{NUMBER_OF_UNKNOWNS}}+{{NUMBER_OF_AUXILIARY_VARIABLES}}]
      [[maybe_unused]] const tarch::la::Vector<Dimensions, double>& volumeCentre,
      [[maybe_unused]] const tarch::la::Vector<Dimensions, double>& volumeH,
      [[maybe_unused]] double                                       t
    ) {% if REFINEMENT_CRITERION_IMPLEMENTATION=="<user-defined>" %}= 0{% else %} final {% endif %};
 
    virtual void initialCondition(
      [[maybe_unused]] double* __restrict__                         Q, // Q[{{NUMBER_OF_UNKNOWNS}}+{{NUMBER_OF_AUXILIARY_VARIABLES}}]
      [[maybe_unused]] const tarch::la::Vector<Dimensions, double>& volumeCentre,
      [[maybe_unused]] const tarch::la::Vector<Dimensions, double>& volumeH,
      [[maybe_unused]] bool                                         gridIsConstructed
    ) {% if INITIAL_CONDITIONS_IMPLEMENTATION=="<user-defined>" %}= 0{% else %} final {% endif %};
 
    {% if BOUNDARY_CONDITIONS_IMPLEMENTATION!="<none>" %}
 
    virtual void boundaryConditions(
      [[maybe_unused]] const double* __restrict__                   Qinside, // Qinside[{{NUMBER_OF_UNKNOWNS}}+{{NUMBER_OF_AUXILIARY_VARIABLES}}]
      [[maybe_unused]] double* __restrict__                         Qoutside, // Qoutside[{{NUMBER_OF_UNKNOWNS}}+{{NUMBER_OF_AUXILIARY_VARIABLES}}]
      [[maybe_unused]] const tarch::la::Vector<Dimensions, double>& faceCentre,
      [[maybe_unused]] const tarch::la::Vector<Dimensions, double>& volumeH,
      [[maybe_unused]] double                                       t,
      [[maybe_unused]] 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 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 void suspendSolversForOneGridSweep() override;
 
    double getMaxPatchSize() const;
    double getMinPatchSize() const;
    double getMaxVolumeSize() const;
    double getMinVolumeSize() 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) // HS: note there is a compiler bug in llvm until that is resolved 
    //#pragma omp declare target       // we need to keep these declarations outside the declare target construct and instead
    //#endif                           // map them explicitly in Rusanov.h
    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;
 
    {% 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;
 
    virtual void startSimulation() override;
 
    virtual void finishSimulation() override;
 
  protected:
    static tarch::logging::Log  _log;
 
    SolverState  _solverState;
 
    double     _minTimeStamp;
    double     _maxTimeStamp;
 
    double     _minTimeStampThisTimeStep;
    double     _maxTimeStampThisTimeStep;
 
    double     _localMinTimeStampThisTimeStep;
    double     _localMaxTimeStampThisTimeStep;
 
    double     _minVolumeH;
    double     _maxVolumeH;
 
    double     _minVolumeHThisTimeStep;
    double     _maxVolumeHThisTimeStep;
 
    double     _minTimeStepSize;
    double     _maxTimeStepSize;
 
    double     _minTimeStepSizeThisTimeStep;
    double     _maxTimeStepSizeThisTimeStep;
 
    int        _patchUpdates;
 
    tarch::multicore::BooleanSemaphore  _semaphore;
 
  {{ABSTRACT_SOLVER_USER_DECLARATIONS}}
};
 
{# Empty line here #}