cs_runge_kutta_integrator.h

Go to the documentation of this file.

#ifndef RK_INTEGRATOR_H
#define RK_INTEGRATOR_H
 
/*============================================================================
 * Explicit Runge-Kutta integrator utilities.
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2025 EDF S.A.
 
  This program is free software; you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
  Foundation; either version 2 of the License, or (at your option) any later
  version.
 
  This program is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  details.
 
  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
  Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
 
/*----------------------------------------------------------------------------*/
 
#include "base/cs_defs.h"
 
/*----------------------------------------------------------------------------
 * Standard C library headers
 *----------------------------------------------------------------------------*/
 
#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
/*----------------------------------------------------------------------------
 * Local headers
 *----------------------------------------------------------------------------*/
 
#include "alge/cs_balance.h"
#include "alge/cs_blas.h"
 
#include "base/cs_array.h"
#include "base/cs_base_accel.h"
#include "base/cs_boundary_conditions_set_coeffs.h"
#include "base/cs_dispatch.h"
#include "mesh/cs_mesh.h"
 
/*----------------------------------------------------------------------------
 * Header for the current file
 *----------------------------------------------------------------------------*/
 
#include "base/cs_runge_kutta_integrator_priv.h"
 
/*----------------------------------------------------------------------------*/
 
/*============================================================================
 * Global variables
 *============================================================================*/
 
/*=============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_runge_kutta_integrator_create(cs_runge_kutta_scheme_t   scheme,
                                 const char               *name,
                                 const cs_real_t          *dt,
                                 int                       dim,
                                 cs_lnum_t                 n_elts);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_runge_kutta_integrators_initialize();
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
template<cs_lnum_t stride>
void
cs_runge_kutta_init_state(cs_dispatch_context          &ctx,
                          cs_runge_kutta_integrator_t  *rk,
                          const cs_real_t              *rho,
                          const cs_real_t              *vol,
                          cs_real_t                    *pvara)
{
  if (rk == nullptr)
    return;
 
  rk->i_stage = 0;
 
  const cs_lnum_t n_elts = rk->n_elts;
 
  cs_real_t *mass = rk->mass;
  cs_real_t *u_old = rk->u_old;
 
  ctx.parallel_for(n_elts, [=] CS_F_HOST_DEVICE (cs_lnum_t i_elt) {
    mass[i_elt] = rho[i_elt]*vol[i_elt];
    for (cs_lnum_t k = 0; k < stride; k++)
      u_old[stride*i_elt + k] = pvara[stride*i_elt + k];
  });
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
template<cs_lnum_t stride>
void
cs_runge_kutta_staging(cs_dispatch_context          &ctx,
                       cs_runge_kutta_integrator_t  *rk,
                       cs_real_t                    *pvar_stage)
{
  assert(rk != nullptr);
 
  const int n_elts = rk->n_elts;
  const cs_real_t *dt = rk->dt;
  const cs_real_t *mass = rk->mass;
 
  // get the current stage index
  const int i_stg = rk->i_stage;
 
  cs_real_t *u0    = rk->u_old;
  cs_real_t *u_new = rk->u_new;
  cs_real_t *rhs_stages = rk->rhs_stages;
 
  const cs_real_t *a = rk->rk_coeff.a + RK_HIGHEST_ORDER*i_stg;
 
  ctx.parallel_for (n_elts, [=] CS_F_HOST_DEVICE (cs_lnum_t i_elt) {
    for (cs_lnum_t k = 0; k < stride; k++)
      u_new[stride*i_elt + k] = u0[stride*i_elt + k];
 
    for (int j_stg = 0; j_stg <= i_stg; j_stg++) {
      cs_real_t *rhs  = rhs_stages + j_stg*stride*n_elts;
      for (cs_lnum_t k = 0; k < stride; k++)
        u_new[stride*i_elt + k] += dt[i_elt]/mass[i_elt]*a[j_stg]
                                 * rhs[i_elt*stride + k];
    }
 
    for (cs_lnum_t k = 0; k < stride; k++)
      pvar_stage[stride*i_elt + k] = u_new[stride*i_elt + k];
  });
 
  ctx.wait();
 
  rk->i_stage++;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
template<int stride>
void
cs_runge_kutta_stage_set_initial_rhs(cs_dispatch_context         &ctx,
                                     cs_runge_kutta_integrator_t *rk,
                                     cs_real_t                   *rhs_pvar)
{
  assert(rk != nullptr);
  const int n_elts = rk->n_elts;
  // get the current stage index
  const int i_stg = rk->i_stage;
 
  cs_real_t *rhs  = rk->rhs_stages + i_stg*stride*n_elts;
  ctx.parallel_for (n_elts, [=] CS_F_HOST_DEVICE (cs_lnum_t i_elt) {
    for (cs_lnum_t k = 0; k < stride; k++)
      rhs[stride*i_elt + k] = rhs_pvar[stride*i_elt + k];
  });
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_runge_kutta_stage_complete_scalar_rhs
  (cs_dispatch_context         &ctx,
   cs_runge_kutta_integrator_t *rk,
   int                          idtvar,
   int                          f_id,
   int                          imucpp,
   cs_equation_param_t         *eqp,
   cs_field_bc_coeffs_t        *bc_coeffs,
   const cs_real_t              i_massflux[],
   const cs_real_t              b_massflux[],
   const cs_real_t              i_visc[],
   const cs_real_t              b_visc[],
   cs_real_t                    viscel[][6],
   const cs_real_t              weighf[][2],
   const cs_real_t              weighb[],
   int                          icvflb,
   const int                    icvfli[],
   cs_real_t                    pvar[],
   const cs_real_t              xcpp[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
template<int stride>
void
cs_runge_kutta_stage_complete_rhs(cs_dispatch_context         &ctx,
                                  cs_runge_kutta_integrator_t *rk,
                                  int                          idtvar,
                                  int                          f_id,
                                  int                          ivisep,
                                  cs_equation_param_t         *eqp,
                                  cs_field_bc_coeffs_t        *bc_coeffs,
                                  const cs_real_t              i_massflux[],
                                  const cs_real_t              b_massflux[],
                                  const cs_real_t              i_visc[],
                                  const cs_real_t              b_visc[],
                                  const cs_real_t              i_secvis[],
                                  const cs_real_t              b_secvis[],
                                  cs_real_t                    viscel[][6],
                                  const cs_real_t              weighf[][2],
                                  const cs_real_t              weighb[],
                                  int                          icvflb,
                                  const int                    icvfli[],
                                  cs_real_t                    pvar[][stride])
{
  assert(rk != nullptr);
  const int n_elts = rk->n_elts;
  // get the current stage index
  const int i_stg = rk->i_stage;
 
  const cs_lnum_t n_b_faces = cs_glob_mesh->n_b_faces;
 
  cs_real_t *rhs = rk->rhs_stages + i_stg*stride*n_elts;
 
  cs_alloc_mode_t amode = ctx.alloc_mode(false);
 
  /* Allocate non reconstructed face value only if presence of limiter */
 
  int df_limiter_id = -1;
  cs_field_t *f = nullptr;
  if (f_id > -1) {
    f = cs_field_by_id(f_id);
    df_limiter_id
      = cs_field_get_key_int(f, cs_field_key_id("diffusion_limiter_id"));
  }
 
  const int ircflp = eqp->ircflu;
  const int ircflb = (ircflp > 0) ? eqp->b_diff_flux_rc : 0;
 
  cs_bc_coeffs_solve_t bc_coeffs_solve;
  cs_init_bc_coeffs_solve(bc_coeffs_solve,
                          n_b_faces,
                          stride,
                          amode,
                          (df_limiter_id > -1 || ircflb != 1));
 
  using var_t = cs_real_t[stride];
 
  var_t *val_ip = (var_t *)bc_coeffs_solve.val_ip;
  var_t *val_f = (var_t *)bc_coeffs_solve.val_f;
  var_t *flux =  (var_t *)bc_coeffs_solve.flux;
  var_t *flux_lim =  (var_t *)bc_coeffs_solve.flux_lim;
 
  /* We compute the total explicit balance. */
 
  int  inc = 1;
 
    /* The added convective scalar mass flux is:
     *      (thetex*Y_\face-imasac*Y_\celli)*mf.
     * When building the explicit part of the rhs, one
     * has to impose 0 on mass accumulation. */
  int  imasac = 0;
 
  eqp->theta = 1;
 
  cs_boundary_conditions_update_bc_coeff_face_values_strided<stride>
    (ctx, f, bc_coeffs, inc, eqp, pvar,
     val_ip, val_f, flux, flux_lim);
 
  if (stride == 3)
    cs_balance_vector(idtvar,
                      f_id,
                      imasac,
                      inc,       /* inc */
                      ivisep,
                      eqp,
                      nullptr, /* pvar == pvara */
                      (const cs_real_3_t *)pvar,
                      bc_coeffs,
                      (const cs_real_3_t *)val_f,
                      (const cs_real_3_t *)flux_lim,
                      i_massflux,
                      b_massflux,
                      i_visc,
                      b_visc,
                      i_secvis,
                      b_secvis,
                      viscel,
                      weighf,
                      weighb,
                      icvflb,
                      icvfli,
                      nullptr,
                      nullptr,
                      (cs_real_3_t *)rhs);
 
  else if (stride == 6)
    cs_balance_tensor(idtvar,
                      f_id,
                      imasac,
                      inc,       /* inc */
                      eqp,
                      nullptr, /* pvar == pvara */
                      (const cs_real_6_t *)pvar,
                      bc_coeffs,
                      (const cs_real_6_t *)val_f,
                      (const cs_real_6_t *)flux_lim,
                      i_massflux,
                      b_massflux,
                      i_visc,
                      b_visc,
                      viscel,
                      weighf,
                      weighb,
                      icvflb,
                      icvfli,
                      (cs_real_6_t *)rhs);
 
  eqp->theta = 0;
 
  cs_clear_bc_coeffs_solve(bc_coeffs_solve);
  ctx.wait();
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline bool
cs_runge_kutta_is_active(cs_runge_kutta_integrator_t  *rk)
{
  if (rk == nullptr)
    return false;
  else
    return (rk->scheme > CS_RK_NONE);
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline cs_real_t *
cs_runge_kutta_get_projection_time_scale_by_stage
(
  cs_dispatch_context           &ctx,
  cs_runge_kutta_integrator_t  *rk
)
{
  assert(rk != nullptr);
  assert(rk->i_stage > 0);
 
  const cs_lnum_t n_elts = rk->n_elts;
  // get the current stage index
  const int i_stg = rk->i_stage;
  const cs_real_t *dt = rk->dt;
 
  const cs_real_t scaling_factor = rk->rk_coeff.c[i_stg - 1];
  cs_real_t *scaled_dt = rk->scaled_dt;
 
  ctx.parallel_for(n_elts, [=] CS_F_HOST_DEVICE (cs_lnum_t i) {
    scaled_dt[i] = dt[i] * scaling_factor;
  });
  ctx.wait();
 
  return rk->scaled_dt;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline bool
cs_runge_kutta_is_staging(cs_runge_kutta_integrator_t  *rk)
{
  if (rk == nullptr)
    return false;
 
  return (rk->i_stage < rk->n_stages);
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_runge_kutta_integrator_t *
cs_runge_kutta_integrator_by_id(int  rk_id);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_runge_kutta_integrators_destroy();
 
/*----------------------------------------------------------------------------*/
 
#endif /* __RK_INTEGRATOR_H__ */