SingleSweepAbstract.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 <algorithm>
 
#include "Constants.h"
 
#include "exahype2/Solver.h"
#include "exahype2/RefinementControl.h"
#include "exahype2/PrecisionControl.h"
 
#include "tarch/NonCriticalAssertions.h"
#include "tarch/la/Vector.h"
#include "tarch/multicore/BooleanSemaphore.h"
 
#include "peano4/utils/Globals.h"
 
#include "kernels/{{SOLVER_NAME}}/Quadrature.h"
#include "kernels/{{SOLVER_NAME}}/DGMatrices.h"
 
{% if USE_HALF_PRECISION==True %}
#include <stdfloat>
{% endif %}
 
{% 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,
      InitialPrediction,
      PredictionOnHangingCells,
      TimeStep,
      Plotting,
      Suspended
    };
 
    static std::string toString(SolverState);
 
    static constexpr int    Order                      = {{ORDER}};
    static constexpr int    NumberOfUnknowns           = {{NUMBER_OF_UNKNOWNS}};
    static constexpr int    NumberOfAuxiliaryVariables = {{NUMBER_OF_AUXILIARY_VARIABLES}};
    //static constexpr int    MaxPicardIterations        = {{ORDER}} + 1; // TODO: Not used (maybe use in nonlinear FSTPVI?)
    //static constexpr bool   UseMaxPicardIterations     = true; // TODO: Not used (maybe use in nonlinear FSTPVI?)
    //static constexpr bool   UseLobattoBasis            = {{USE_GAUSS_LOBATTO}}; // TODO: Not used
    static constexpr double CFL                        = {{CFL_SAFETY_FACTOR}};
    static constexpr double PNPM                       = {{CFL_ADER}};
 
    // User-defined solver constants
    {{SOLVER_CONSTANTS}}
 
    {% if USE_POINT_SOURCE %}
    static constexpr int NumberOfPointSources     = {{NUMBER_OF_POINT_SOURCES}};
    double pointSourceLocation[NumberOfPointSources][Dimensions];
    {% endif %}
 
    static constexpr double MaxAdmissibleCellH  = {{MAX_CELL_H}};
 
    static constexpr double MinAdmissibleCellH  = {{MIN_CELL_H}};
 
    {{CLASSNAME}}();
    ~{{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(
      const {{SOLUTION_STORAGE_PRECISION}} * __restrict__                  Q,    // Q[{{NUMBER_OF_UNKNOWNS}}+{{NUMBER_OF_AUXILIARY_VARIABLES}}]
      const tarch::la::Vector<Dimensions,double>&  x,
      const tarch::la::Vector<Dimensions,double>&  h,
      double                                       t
    ) {% if REFINEMENT_CRITERION_IMPLEMENTATION=="<user-defined>" %}= 0{% else %} final {% endif %};
 
    virtual void initialCondition(
      {{SOLUTION_STORAGE_PRECISION}}* __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 %};
 
    virtual void boundaryConditions(
      const {{CORRECTOR_COMPUTATION_PRECISION}} * __restrict__                  Qinside, // Qinside[{{NUMBER_OF_UNKNOWNS}}+{{NUMBER_OF_AUXILIARY_VARIABLES}}]
      {{CORRECTOR_COMPUTATION_PRECISION}} * __restrict__                        Qoutside, // Qoutside[{{NUMBER_OF_UNKNOWNS}}+{{NUMBER_OF_AUXILIARY_VARIABLES}}]
      const tarch::la::Vector<Dimensions,double>&  x,
      const tarch::la::Vector<Dimensions,double>&  h,
      double                                       t,
      int                                          normal
    ){% if BOUNDARY_CONDITIONS_IMPLEMENTATION=="<user-defined>" %}= 0{% else %} final{% endif %};
 
    {% if ADAPTIVE_PRECISION_IMPLEMENTATION!="<none>" %}
    virtual ::exahype2::PrecisionCommand precisionCriterion(
      const {{SOLUTION_STORAGE_PRECISION}} * __restrict__ Q, // Q[{{NUMBER_OF_UNKNOWNS}}+{{NUMBER_OF_AUXILIARY_VARIABLES}}]
      const tarch::la::Vector<Dimensions,double>&         x,
      const tarch::la::Vector<Dimensions,double>&         h,
      double                                              t,
      SolverState                                         currentState
    ) {% if ADAPTIVE_PRECISION_IMPLEMENTATION=="<user-defined>" %} = 0{% else %} final {% endif %};
    {% endif %}
 
    {% if RIEMANN_SOLVER_IMPLEMENTATION!="<none>" %}
    virtual void riemannSolver(
      {{CORRECTOR_COMPUTATION_PRECISION}}* const FL, // FL[{{NUMBER_OF_UNKNOWNS}}
      {{CORRECTOR_COMPUTATION_PRECISION}}* const FR, // FR[{{NUMBER_OF_UNKNOWNS}}
      const {{CORRECTOR_COMPUTATION_PRECISION}}* const QL, // QL[{{NUMBER_OF_UNKNOWNS}}+{{NUMBER_OF_AUXILIARY_VARIABLES}}]
      const {{CORRECTOR_COMPUTATION_PRECISION}}* const QR, // QR[{{NUMBER_OF_UNKNOWNS}}+{{NUMBER_OF_AUXILIARY_VARIABLES}}]
      const double t,
      const double dt, 
      const tarch::la::Vector<Dimensions, double>& x,
      const tarch::la::Vector<Dimensions, double>& h,
      const int direction, 
      bool isBoundaryFace, 
      int faceIndex) {% if RIEMANN_SOLVER_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 getMaxCellSize() const;
    double getMinCellSize() 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;
 
    {{ABSTRACT_SOLVER_USER_DECLARATIONS}}
 
  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;
};