PosterioriLimitingAbstract.template.cpp

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              ***
// **********************************************************************************************
#include "{{CLASSNAME}}.h"
 
#include <algorithm>
 
#include "Constants.h"
 
#include "tarch/multicore/Lock.h"
 
#include "repositories/SolverRepository.h"
 
tarch::logging::Log {{NAMESPACE | join("::")}}::{{CLASSNAME}}::{{CLASSNAME}}::_log("{{NAMESPACE | join("::")}}::{{CLASSNAME}}::{{CLASSNAME}}");
 
{{NAMESPACE | join("::")}}::{{CLASSNAME}}::{{CLASSNAME}}():
  _solverState(SolverState::GridConstruction),
  _cellUpdates(0),
  _numberOfTroubledCellsThisTimeStep(0) {
  {{CONSTRUCTOR_IMPLEMENTATION}}
 
  kernels::{{SOLVER_NAME}}::Quadrature<double>::initQuadratureNodesAndWeights();
}
 
{{NAMESPACE | join("::")}}::{{CLASSNAME}}::~{{CLASSNAME}}(){
  kernels::{{SOLVER_NAME}}::Quadrature<double>::freeQuadratureNodesAndWeights();
}
 
double {{NAMESPACE | join("::")}}::{{CLASSNAME}}::getMinTimeStamp(bool ofCurrentlyRunningGridSweep) const {
  return repositories::{{REGULAR_SOLVER_INSTANCE}}.getMinTimeStamp();
}
 
double {{NAMESPACE | join("::")}}::{{CLASSNAME}}::getMaxTimeStamp(bool ofCurrentlyRunningGridSweep) const {
  return repositories::{{REGULAR_SOLVER_INSTANCE}}.getMaxTimeStamp();
}
 
double {{NAMESPACE | join("::")}}::{{CLASSNAME}}::getMinTimeStepSize() const {
  return repositories::{{REGULAR_SOLVER_INSTANCE}}.getMinTimeStepSize();
}
 
double {{NAMESPACE | join("::")}}::{{CLASSNAME}}::getMaxTimeStepSize() const {
  return repositories::{{REGULAR_SOLVER_INSTANCE}}.getMaxTimeStepSize();
}
 
double {{NAMESPACE | join("::")}}::{{CLASSNAME}}::getMaxMeshSize() const {
  return repositories::{{REGULAR_SOLVER_INSTANCE}}.getMaxMeshSize();
}
 
double {{NAMESPACE | join("::")}}::{{CLASSNAME}}::getMinMeshSize() const {
  return repositories::{{REGULAR_SOLVER_INSTANCE}}.getMinMeshSize();
}
 
{{NAMESPACE | join("::")}}::{{CLASSNAME}}::SolverState {{NAMESPACE | join("::")}}::{{CLASSNAME}}::getSolverState() const {
  return _solverState;
}
 
void {{NAMESPACE | join("::")}}::{{CLASSNAME}}::startGridConstructionStep() {
  assertion( _solverState == SolverState::GridConstruction );
}
 
void {{NAMESPACE | join("::")}}::{{CLASSNAME}}::finishGridConstructionStep() {}
 
void {{NAMESPACE | join("::")}}::{{CLASSNAME}}::startGridInitialisationStep() {
  _solverState = SolverState::GridInitialisation;
}
 
void {{NAMESPACE | join("::")}}::{{CLASSNAME}}::finishGridInitialisationStep() {}
 
void {{NAMESPACE | join("::")}}::{{CLASSNAME}}::suspendSolversForOneGridSweep() {
  _solverState = SolverState::Suspended;
}
 
void {{NAMESPACE | join("::")}}::{{CLASSNAME}}::startTimeStep(
  double globalMinTimeStamp,
  double globalMaxTimeStamp,
  double globalMinTimeStepSize,
  double globalMaxTimeStepSize
) {
  switch (_solverState) {
    case SolverState::GridConstruction:
      _solverState = SolverState::GridInitialisation;
      break;
    case SolverState::GridInitialisation:
    case SolverState::Suspended:
    case SolverState::Plotting:
    case SolverState::RegularSolver:
      _solverState = (_numberOfTroubledCellsThisTimeStep == 0 ?
        SolverState::RegularSolver : SolverState::LimiterStatusSpreadingToNeighbours);
      break;
    case SolverState::LimiterStatusSpreadingToNeighbours:
      _solverState = SolverState::LimiterStatusSpreadingToSecondNeighbours;
      break;
    case SolverState::LimiterStatusSpreadingToSecondNeighbours:
      _solverState = SolverState::LimiterSolver;
      break;
    case SolverState::LimiterSolver:
      _solverState = SolverState::RegularSolver;
      break;
  }
 
  if (_solverState==SolverState::RegularSolver) {
    _cellUpdates    = 0;
    _numberOfTroubledCellsThisTimeStep = 0;
  }
 
  {{START_TIME_STEP_IMPLEMENTATION}}
 
  if (_solverState==SolverState::RegularSolver) {
    repositories::{{LIMITER_SOLVER_INSTANCE}}.suspendSolversForOneGridSweep();
 
    _cellUpdates    = 0;
    _numberOfTroubledCellsThisTimeStep = 0;
  }
 
  if (_solverState==SolverState::LimiterSolver) {
    repositories::{{REGULAR_SOLVER_INSTANCE}}.suspendSolversForOneGridSweep();
  }
 
  if(_solverState==SolverState::LimiterStatusSpreadingToNeighbours
    or _solverState==SolverState::LimiterStatusSpreadingToSecondNeighbours
    ) {
    repositories::{{LIMITER_SOLVER_INSTANCE}}.suspendSolversForOneGridSweep();
    repositories::{{REGULAR_SOLVER_INSTANCE}}.suspendSolversForOneGridSweep();
  }
 
  if (
    ::tarch::mpi::Rank::getInstance().isGlobalMaster()
//    and ( _solverState==SolverState::RegularSolver or _solverState==SolverState::LimiterSolver )
  ) {
 
    logInfo("startTimeStep(...)", "Solver {{SOLVER_NAME}}:");
    logInfo("startTimeStep(...)", "total number of troubled cells: " << _numberOfTroubledCellsThisTimeStep);
    logInfo("startTimeStep(...)", "phase " + toString(_solverState));
  }
}
 
void {{NAMESPACE | join("::")}}::{{CLASSNAME}}::finishTimeStep() {
  if (isLastGridSweepOfTimeStep()) {
    #ifdef Parallel
    int newCellUpdates = _cellUpdates;
    int newNumberOfTroubleCells = _numberOfTroubledCellsThisTimeStep;
 
    tarch::mpi::Rank::getInstance().allReduce(
        &newCellUpdates,
        &_cellUpdates,
        1, MPI_INT,
        MPI_SUM,
        [&]() -> void { tarch::services::ServiceRepository::getInstance().receiveDanglingMessages(); }
        );
 
    tarch::mpi::Rank::getInstance().allReduce(
        &newNumberOfTroubleCells,
        &_numberOfTroubledCellsThisTimeStep,
        1, MPI_INT,
        MPI_SUM,
        [&]() -> void { tarch::services::ServiceRepository::getInstance().receiveDanglingMessages(); }
        );
    #endif
 
    {{FINISH_TIME_STEP_IMPLEMENTATION}}
  }
}
 
void {{NAMESPACE | join("::")}}::{{CLASSNAME}}::startPlottingStep(
  double globalMinTimeStamp,
  double globalMaxTimeStamp,
  double globalMinTimeStepSize,
  double globalMaxTimeStepSize
) {
  assertion( mayPlot() );
  _solverState = SolverState::Plotting;
}
 
 
void {{NAMESPACE | join("::")}}::{{CLASSNAME}}::finishPlottingStep() {
}
 
 
std::string {{NAMESPACE | join("::")}}::{{CLASSNAME}}::toString(SolverState state) {
  switch (state) {
    case SolverState::GridConstruction:
      return "grid-construction";
    case SolverState::GridInitialisation:
      return "grid-initialisation";
    case SolverState::RegularSolver:
      return "regular-(non-limiting)-solver";
    case SolverState::LimiterStatusSpreadingToNeighbours:
      return "limiter-status-spreading-to-neighbours";
    case SolverState::LimiterStatusSpreadingToSecondNeighbours:
      return "limiter-status-spreading-to-second-neighbours";
    case SolverState::LimiterSolver:
      return "limiting-solver";
    case SolverState::Plotting:
      return "plotting";
    case SolverState::Suspended:
      return "suspended";
  }
  return "<undef>";
}
 
 
bool {{NAMESPACE | join("::")}}::{{CLASSNAME}}::mayPlot() const {
  return
    (
        (
          _solverState==SolverState::GridInitialisation
        or
          _solverState==SolverState::RegularSolver
          and repositories::{{REGULAR_SOLVER_INSTANCE}}.mayPlot()
          and _numberOfTroubledCellsThisTimeStep==0
        )
      or
        (
          _solverState==SolverState::LimiterSolver and
          repositories::{{LIMITER_SOLVER_INSTANCE}}.mayPlot()
        )
    );
}
 
 
bool {{NAMESPACE | join("::")}}::{{CLASSNAME}}::isFirstGridSweepOfTimeStep() const {
  return (
    ( _solverState==SolverState::RegularSolver and repositories::{{REGULAR_SOLVER_INSTANCE}}.isFirstGridSweepOfTimeStep() )
    or
    ( _solverState==SolverState::LimiterSolver and repositories::{{LIMITER_SOLVER_INSTANCE}}.isFirstGridSweepOfTimeStep() )
  );
 
}
 
 
bool {{NAMESPACE | join("::")}}::{{CLASSNAME}}::isLastGridSweepOfTimeStep() const {
  return (
    ( _solverState==SolverState::RegularSolver and repositories::{{REGULAR_SOLVER_INSTANCE}}.isLastGridSweepOfTimeStep() )
    or
    ( _solverState==SolverState::LimiterSolver and repositories::{{LIMITER_SOLVER_INSTANCE}}.isLastGridSweepOfTimeStep() )
  );
}
 
 
void {{NAMESPACE | join("::")}}::{{CLASSNAME}}::startSimulation() {
 
}
 
 
void {{NAMESPACE | join("::")}}::{{CLASSNAME}}::finishSimulation() {
 
}
 
 
void {{FULL_QUALIFIED_NAMESPACE}}::{{CLASSNAME}}::addTroubledCell(){
  _numberOfTroubledCellsThisTimeStep += 1;
}
int {{FULL_QUALIFIED_NAMESPACE}}::{{CLASSNAME}}::getNumberOfTroubledCells() const {
  return _numberOfTroubledCellsThisTimeStep;  
}
 
 
{% if ADMISSIBILITY_IMPLEMENTATION!="<empty>" and ADMISSIBILITY_IMPLEMENTATION!="<user-defined>" %}
bool {{FULL_QUALIFIED_NAMESPACE}}::{{CLASSNAME}}::isPhysicallyAdmissible(
  const double* const                         Q,
  const tarch::la::Vector<Dimensions,double>& x,
  const tarch::la::Vector<Dimensions,double>& h,
  const double timeStamp
){
  {% if ADMISSIBILITY_IMPLEMENTATION!="<none>"%}
  {{ADMISSIBILITY_IMPLEMENTATION}}
  {% else %}
  return true;
  {% endif %}
 
}
{% endif %}
 
{{SOLVER_USER_DEFINITIONS}}