SingleSweep.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 "Abstract{{CLASSNAME}}.h"
 
#include "tarch/logging/Log.h"
 
{% for item in NAMESPACE -%}
namespace {{ item }} {
{%- endfor %}
 
  class {{CLASSNAME}};
 
{% for item in NAMESPACE -%}
}
{%- endfor %}
 
 
class {{NAMESPACE | join("::")}}::{{CLASSNAME}}: public Abstract{{CLASSNAME}} {
  private:
    static tarch::logging::Log _log;
 
  public:
    {% if REFINEMENT_CRITERION_IMPLEMENTATION=="<user-defined>" %}
    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
    ) override;
    {% endif %}
 
    {% if ADAPTIVE_PRECISION_IMPLEMENTATION=="<user-defined>" %}
    ::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
    ) override;
    {% endif %}
 
    {% if INITIAL_CONDITIONS_IMPLEMENTATION=="<user-defined>" %}
    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
    ) override;
    {% endif %}
 
    {% if BOUNDARY_CONDITIONS_IMPLEMENTATION=="<user-defined>" %}
    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
    ) final override;
    {% endif %}
 
    {% if RIEMANN_SOLVER_IMPLEMENTATION=="<user-defined>" %}
    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
    ) final override;
    {% endif %}
 
    {{SOLVER_USER_DECLARATIONS}}
};