ryujin 2.1.1 revision 336b16a72e829721302c626ec7071b92032b8248
List of all members
ryujin::NavierStokes::ParabolicSolver< Description, dim, Number > Class Template Referencefinal
The Compressible Navier Stokes Equations

#include <source/navier_stokes/parabolic_solver.h>

Inheritance diagram for ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >:
Inheritance graph
[legend]
Collaboration diagram for ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >:
Collaboration graph
[legend]

Public Member Functions

Constructor and setup
 ParabolicSolver (const MPI_Comm &mpi_communicator, std::map< std::string, dealii::Timer > &computing_timer, const HyperbolicSystem &hyperbolic_system, const ParabolicSystem &parabolic_system, const OfflineData< dim, Number > &offline_data, const InitialValues< Description, dim, Number > &initial_values, const std::string &subsection="ParabolicSolver")
 
void prepare ()
 
Functions for performing implicit time steps
void backward_euler_step (const StateVector &old_state_vector, const Number old_t, StateVector &new_state_vector, Number tau, const IDViolationStrategy id_violation_strategy, const bool reinitialize_gmg) const
 
void print_solver_statistics (std::ostream &output) const
 

Typedefs and constexpr constants

using HyperbolicSystem = typename Description::HyperbolicSystem
 
using View = typename Description::template HyperbolicSystemView< dim, Number >
 
using ParabolicSystem = typename Description::ParabolicSystem
 
using ScalarNumber = typename View::ScalarNumber
 
using state_type = typename View::state_type
 
using StateVector = typename View::StateVector
 
using ScalarVector = Vectors::ScalarVector< Number >
 
using BlockVector = Vectors::BlockVector< Number >
 
static constexpr auto problem_dimension = View::problem_dimension
 

Detailed Description

template<typename Description, int dim, typename Number = double>
class ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >

Implicit backward-Euler time stepping for the parabolic limiting equation [11], Eq. 3.3:

\begin{align} \newcommand{\bbm}{{\boldsymbol m}} \newcommand{\bef}{{\boldsymbol f}} \newcommand{\bk}{{\boldsymbol k}} \newcommand{\bu}{{\boldsymbol u}} \newcommand{\bv}{{\boldsymbol v}} \newcommand{\bn}{{\boldsymbol n}} \newcommand{\pols}{{\mathbb s}} \newcommand{\Hflux}{\bk} &\partial_t \rho = 0, \\ &\partial_t \bbm - \nabla\cdot(\pols(\bv)) = \bef, \\ &\partial_t E + \nabla\cdot(\Hflux(\bu)- \pols(\bv) \bv) = \bef\cdot\bv, \\ &\bv_{|\partial D}=\boldsymbol 0, \qquad \Hflux(\bu)\cdot\bn_{|\partial D}=0 . \end{align}

Internally, the module first performs an implicit backward Euler step updating the velocity (see [11], Eq. 5.5):

\begin{align} \begin{cases} \newcommand\bsfV{{\textbf V}} \newcommand{\polB}{{\mathbb B}} \newcommand{\calI}{{\mathcal I}} \newcommand\bsfF{{\textbf F}} \newcommand\bsfM{{\textbf M}} \newcommand{\upint}{^\circ} \newcommand{\upbnd}{^\partial} \newcommand{\dt}{{\tau}} \newcommand{\calV}{{\mathcal V}} \varrho^{n}_i m_i \bsfV^{n+1} + \dt\sum_{j\in\calI(i)} \polB_{ij} \bsfV^{n+1} = m_i \bsfM_i^{n} + \dt m_i \bsfF_i^{n+1}, & \forall i\in \calV\upint \\[0.3em] \bsfV_i^{n+1} = \boldsymbol 0, & \forall i\in \calV\upbnd, \end{cases} \end{align}

We then postprocess and compute an internal energy update with an additional backward Euler step, (cf. [11], Eq. 5.13)

\begin{align} \newcommand\bsfV{{\textbf V}} \newcommand\sfe{{\mathsf e}} \newcommand{\upHnph}{^{\text{H},n+1}} \newcommand{\calI}{{\mathcal I}} \newcommand\sfK{{\mathsf K}} \newcommand{\calV}{{\mathcal V}} m_i \varrho_i^{n}(\sfe_i{\upHnph} - \sfe_i^{n})+\dt \sum_{j\in\calI(i)} \beta_{ij}\sfe_i{\upHnph} = \tfrac12 m_i\|\bsfV^{n+1}-\bsfV^{n}\|^2 + \dt m_i\sfK_i^{n+1}, \qquad \forall i\in \calV. \end{align}

The result is then transformed back into conserved quantities and written to the output vector.

Note
The backward Euler scheme is a fundamental building block for higher-order time stepping, including the well-known Crank-Nicolson scheme. The latter can be expressed algebraically as a backward Euler step (from time \(t\) to \(t+\tau\) followed by an extrapolation step \(U^{n+2}=2U^{n+1}-U^{n}\) from time \(t+\tau\) to \(t+2\tau\)). This approach differs from the Crank-Nicolson scheme discussed in [11] where the extrapolation step is performed on the primitive quantities (velocity and internal energy) instead of the conserved quantities.

Definition at line 112 of file parabolic_solver.h.

Member Typedef Documentation

◆ HyperbolicSystem

template<typename Description , int dim, typename Number = double>
using ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >::HyperbolicSystem = typename Description::HyperbolicSystem

Definition at line 120 of file parabolic_solver.h.

◆ View

template<typename Description , int dim, typename Number = double>
using ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >::View = typename Description::template HyperbolicSystemView<dim, Number>

Definition at line 122 of file parabolic_solver.h.

◆ ParabolicSystem

template<typename Description , int dim, typename Number = double>
using ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >::ParabolicSystem = typename Description::ParabolicSystem

Definition at line 125 of file parabolic_solver.h.

◆ ScalarNumber

template<typename Description , int dim, typename Number = double>
using ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >::ScalarNumber = typename View::ScalarNumber

Definition at line 127 of file parabolic_solver.h.

◆ state_type

template<typename Description , int dim, typename Number = double>
using ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >::state_type = typename View::state_type

Definition at line 131 of file parabolic_solver.h.

◆ StateVector

template<typename Description , int dim, typename Number = double>
using ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >::StateVector = typename View::StateVector

Definition at line 133 of file parabolic_solver.h.

◆ ScalarVector

template<typename Description , int dim, typename Number = double>
using ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >::ScalarVector = Vectors::ScalarVector<Number>

Definition at line 135 of file parabolic_solver.h.

◆ BlockVector

template<typename Description , int dim, typename Number = double>
using ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >::BlockVector = Vectors::BlockVector<Number>

Definition at line 137 of file parabolic_solver.h.

Constructor & Destructor Documentation

◆ ParabolicSolver()

template<typename Description , int dim, typename Number >
ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >::ParabolicSolver ( const MPI_Comm &  mpi_communicator,
std::map< std::string, dealii::Timer > &  computing_timer,
const HyperbolicSystem &  hyperbolic_system,
const ParabolicSystem &  parabolic_system,
const OfflineData< dim, Number > &  offline_data,
const InitialValues< Description, dim, Number > &  initial_values,
const std::string &  subsection = "ParabolicSolver< Description, dim, Number >" 
)

Constructor.

Definition at line 34 of file parabolic_solver.template.h.

Member Function Documentation

◆ prepare()

template<typename Description , int dim, typename Number >
void ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >::prepare

Prepare time stepping. A call to prepare() allocates temporary storage and is necessary before any of the following time-stepping functions can be called.

Definition at line 125 of file parabolic_solver.template.h.

References ryujin::cg_q1, ryujin::dirichlet, and ryujin::no_slip.

◆ backward_euler_step()

template<typename Description , int dim, typename Number >
void ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >::backward_euler_step ( const StateVector &  old_state_vector,
const Number  old_t,
StateVector &  new_state_vector,
Number  tau,
const IDViolationStrategy  id_violation_strategy,
const bool  reinitialize_gmg 
) const

Given a reference to a previous state vector old_state_vector at time old_t and a time-step size tau perform an implicit backward Euler step (and store the result in new_state_vector).

Definition at line 212 of file parabolic_solver.template.h.

References CALLGRIND_START_INSTRUMENTATION, CALLGRIND_STOP_INSTRUMENTATION, ryujin::dirichlet, ryujin::NavierStokes::EnergyMatrix< dim, Number, Number2 >::initialize(), ryujin::NavierStokes::VelocityMatrix< dim, Number, Number2 >::initialize(), LIKWID_MARKER_START, LIKWID_MARKER_STOP, ryujin::negative_part(), ryujin::no_slip, ryujin::raise_exception, ryujin::NavierStokes::DiagonalMatrix< dim, Number >::reinit(), RYUJIN_OMP_FOR, RYUJIN_PARALLEL_REGION_BEGIN, RYUJIN_PARALLEL_REGION_END, ryujin::slip, and ryujin::warn.

◆ print_solver_statistics()

template<typename Description , int dim, typename Number >
void ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >::print_solver_statistics ( std::ostream &  output) const

Print a status line with solver statistics. This function is used for constructing the status message displayed periodically in the TimeLoop.

Definition at line 840 of file parabolic_solver.template.h.

Member Data Documentation

◆ problem_dimension

template<typename Description , int dim, typename Number = double>
constexpr auto ryujin::NavierStokes::ParabolicSolver< Description, dim, Number >::problem_dimension = View::problem_dimension
staticconstexpr

Definition at line 129 of file parabolic_solver.h.

The documentation for this class was generated from the following files:
Generated by doxygen 1.9.4