cs_equation_param.h

Go to the documentation of this file.

#ifndef CS_EQUATION_PARAM_H
#define CS_EQUATION_PARAM_H
 
/*============================================================================
 * Functions related to the structure cs_equation_param_t storing the settings
 * related to an equation.
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2026 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.
*/
 
/*----------------------------------------------------------------------------
 *  Local headers
 *----------------------------------------------------------------------------*/
 
#include "alge/cs_param_saddle.h"
#include "alge/cs_param_sles.h"
#include "base/cs_runge_kutta_integrator_param.h"
#include "base/cs_time_control.h"
#include "cdo/cs_advection_field.h"
#include "cdo/cs_enforcement.h"
#include "cdo/cs_hodge.h"
#include "cdo/cs_iter_algo.h"
#include "cdo/cs_param_cdo.h"
#include "cdo/cs_property.h"
#include "cdo/cs_xdef.h"
 
/*============================================================================
 * Macro definitions
 *============================================================================*/
 
#define CS_EQUATION_LOCKED         (1 <<  0)  /*    1 */
#define CS_EQUATION_UNSTEADY       (1 <<  1)  /*    2 */
#define CS_EQUATION_CONVECTION     (1 <<  2)  /*    4 */
#define CS_EQUATION_DIFFUSION      (1 <<  3)  /*    8 */
#define CS_EQUATION_CURLCURL       (1 <<  4)  /*   16 */
#define CS_EQUATION_GRADDIV        (1 <<  5)  /*   32 */
#define CS_EQUATION_REACTION       (1 <<  6)  /*   64 */
#define CS_EQUATION_FORCE_VALUES   (1 <<  7)  /*  128 */
#define CS_EQUATION_INSIDE_SYSTEM  (1 <<  8)  /*  256 */
#define CS_EQUATION_BUILD_HOOK     (1 <<  9)  /*  512 */
#define CS_EQUATION_USER_TRIGGERED (1 << 10)  /* 1024 */
 
#define CS_EQUATION_POST_BALANCE     (1 << 0) /* 1 */
#define CS_EQUATION_POST_PECLET      (1 << 1) /* 2 */
#define CS_EQUATION_POST_UPWIND_COEF (1 << 2) /* 4 */
#define CS_EQUATION_POST_NORMAL_FLUX (1 << 3) /* 8 */
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
typedef enum {
 
  CS_EQUATION_TYPE_GROUNDWATER,
  CS_EQUATION_TYPE_MAXWELL,
  CS_EQUATION_TYPE_NAVSTO,
  CS_EQUATION_TYPE_PREDEFINED,
  CS_EQUATION_TYPE_THERMAL,
  CS_EQUATION_TYPE_SOLIDIFICATION,
  CS_EQUATION_TYPE_USER,
 
  CS_EQUATION_N_TYPES
 
} cs_equation_type_t;
 
/*----------------------------------------------------------------------------*/
 
typedef struct {
 
  char *restrict              name;    
  cs_equation_type_t          type;    
  int                         dim;     
  int                         verbosity;
 
  cs_flag_t                   flag;
 
  cs_flag_t                   post_flag;
 
  /* Numerical settings */
 
  cs_param_space_scheme_t     space_scheme;  
  cs_param_dof_reduction_t    dof_reduction; 
  int                         space_poly_degree;
 
  int iconv;
  int istat;
  int idircl;
  int ndircl;
  int idiff;
  int idifft;
  int idften;
  int iswdyn;
  int ischcv;
  int ibdtso;
  int isstpc;
  int nswrgr;
  int nswrsm;
  int imvisf;
  int imrgra;
  int imligr;
  int d_imligr;
  int ircflu;
  int iwgrec;
  int icoupl;
  double theta;
  double blencv;
  double blend_st;
  double epsilo;
  double epsrsm;
  double epsrgr;
  double climgr;
  double d_climgr;
  double rc_clip_factor;
  double b_rc_clip_factor;
  double relaxv;
 
  int  d_gradient_r;
  int  b_rc_gradient;
  int  b_diff_flux_rc;
 
  int  diffusion_limiter_id;
  int  convection_limiter_id;
 
  cs_runge_kutta_def_t rk_def;
 
  cs_param_bc_type_t          default_bc;
  int                         n_bc_defs;
  cs_xdef_t                 **bc_defs;
 
  cs_param_bc_enforce_t       default_enforcement;
  cs_real_t                   strong_pena_bc_coeff;
  cs_real_t                   weak_pena_bc_coeff;
 
  int                         n_ic_defs;
  cs_xdef_t                 **ic_defs;
 
  bool                        do_lumping;
 
  cs_hodge_param_t            time_hodgep;
  cs_property_t              *time_property;
  cs_param_time_scheme_t      time_scheme;
 
  cs_hodge_param_t            diffusion_hodgep;
  cs_property_t              *diffusion_property;
 
  cs_hodge_param_t            curlcurl_hodgep;
  cs_property_t              *curlcurl_property;
 
  cs_hodge_param_t            graddiv_hodgep;
  cs_property_t              *graddiv_property;
 
  cs_param_advection_form_t             adv_formulation;
  cs_param_advection_scheme_t           adv_scheme;
  cs_param_advection_strategy_t         adv_strategy;
  cs_param_advection_extrapol_t         adv_extrapol;
  cs_real_t                             upwind_portion;
  double                                stab_scaling_coef;
 
  cs_adv_field_t                       *adv_field;
  cs_property_t                        *adv_scaling_property;
 
  cs_hodge_param_t            reaction_hodgep;
  int                         n_reaction_terms;
  cs_property_t             **reaction_properties;
 
  int                         n_source_terms;
  cs_xdef_t                 **source_terms;
 
  int                         n_volume_mass_injections;
  cs_xdef_t                 **volume_mass_injections;
 
  int                         n_enforcements;
  cs_enforcement_param_t    **enforcement_params;
 
  cs_param_sles_t            *sles_param;
  cs_param_saddle_t          *saddle_param;
 
  cs_param_nl_algo_t          incremental_algo_type;
  cs_param_convergence_t      incremental_algo_cvg;
  cs_real_t                   incremental_relax_factor;
  cs_iter_algo_param_aac_t    incremental_anderson_param;
 
  bool                        time_control_owner; /* Is this instance owner
                                                     of the pointer. */
  cs_time_control_t          *time_control; /* Time control for equations */
 
} cs_equation_param_t;
 
/*----------------------------------------------------------------------------*/
 
typedef enum {
 
  CS_EQKEY_ADV_STAB_COEF,
  CS_EQKEY_ADV_EXTRAPOL,
  CS_EQKEY_ADV_FORMULATION,
  CS_EQKEY_ADV_SCHEME,
  CS_EQKEY_ADV_STRATEGY,
  CS_EQKEY_ADV_UPWIND_PORTION,
  CS_EQKEY_AMG_TYPE,
  CS_EQKEY_BC_ENFORCEMENT,
  CS_EQKEY_BC_STRONG_PENA_COEFF,
  CS_EQKEY_BC_WEAK_PENA_COEFF,
  CS_EQKEY_DO_LUMPING,
  CS_EQKEY_DOF_REDUCTION,
  CS_EQKEY_EXTRA_OP,
  CS_EQKEY_HODGE_DIFF_ALGO,
  CS_EQKEY_HODGE_DIFF_COEF,
  CS_EQKEY_HODGE_TIME_ALGO,
  CS_EQKEY_HODGE_REAC_ALGO,
  CS_EQKEY_ITSOL [[deprecated("Use CS_EQKEY_SOLVER")]],
  CS_EQKEY_ITSOL_ATOL [[deprecated("Use CS_EQKEY_SOLVER_ATOL")]],
  CS_EQKEY_ITSOL_DTOL [[deprecated("Use CS_EQKEY_SOLVER_DTOL")]],
  CS_EQKEY_ITSOL_EPS [[deprecated("Use CS_EQKEY_SOLVER_RTOL")]],
  CS_EQKEY_ITSOL_MAX_ITER [[deprecated("Use CS_EQKEY_SOLVER_MAX_ITER")]],
  CS_EQKEY_ITSOL_RESNORM_TYPE [[deprecated("Use CS_EQKEY_SOLVER_RESNORM_TYPE")]],
  CS_EQKEY_ITSOL_RESTART [[deprecated("Use CS_EQKEY_SOLVER_RESTART")]],
  CS_EQKEY_ITSOL_RTOL [[deprecated("Use CS_EQKEY_SOLVER_RTOL")]],
  CS_EQKEY_SOLVER,
  CS_EQKEY_SOLVER_ATOL,
  CS_EQKEY_SOLVER_DTOL,
  CS_EQKEY_SOLVER_MAX_ITER,
  CS_EQKEY_SOLVER_NO_OP,
  CS_EQKEY_SOLVER_RESNORM_TYPE,
  CS_EQKEY_SOLVER_RESTART,
  CS_EQKEY_SOLVER_RTOL,
  CS_EQKEY_OMP_ASSEMBLY_STRATEGY,
  CS_EQKEY_PRECOND,
  CS_EQKEY_PRECOND_BLOCK_TYPE,
  CS_EQKEY_SADDLE_ATOL,
  CS_EQKEY_SADDLE_AUGMENT_SCALING,
  CS_EQKEY_SADDLE_DTOL,
  CS_EQKEY_SADDLE_MAX_ITER,
  CS_EQKEY_SADDLE_PRECOND,
  CS_EQKEY_SADDLE_RTOL,
  CS_EQKEY_SADDLE_SCHUR_APPROX,
  CS_EQKEY_SADDLE_SOLVER,
  CS_EQKEY_SADDLE_SOLVER_CLASS,
  CS_EQKEY_SADDLE_SOLVER_RESTART,
  CS_EQKEY_SADDLE_VERBOSITY,
  CS_EQKEY_SLES_VERBOSITY,
  CS_EQKEY_SOLVER_FAMILY,
  CS_EQKEY_SPACE_SCHEME,
  CS_EQKEY_TIME_SCHEME,
  CS_EQKEY_TIME_THETA,
  CS_EQKEY_VERBOSITY,
 
  CS_EQKEY_N_KEYS
 
} cs_equation_key_t;
 
/*============================================================================
 * Static inline public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline void
cs_equation_param_set_flag(cs_equation_param_t *eqp,
                           cs_flag_t            flag)
{
  assert(eqp != NULL);
  eqp->flag |= flag;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_equation_param_has_diffusion(const cs_equation_param_t *eqp)
{
  assert(eqp != NULL);
  if (eqp->flag & CS_EQUATION_DIFFUSION)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_equation_param_has_curlcurl(const cs_equation_param_t *eqp)
{
  assert(eqp != NULL);
  if (eqp->flag & CS_EQUATION_CURLCURL)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_equation_param_has_graddiv(const cs_equation_param_t *eqp)
{
  assert(eqp != NULL);
  if (eqp->flag & CS_EQUATION_GRADDIV)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_equation_param_has_convection(const cs_equation_param_t *eqp)
{
  assert(eqp != NULL);
  if (eqp->flag & CS_EQUATION_CONVECTION)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_equation_param_has_reaction(const cs_equation_param_t *eqp)
{
  assert(eqp != NULL);
  if (eqp->flag & CS_EQUATION_REACTION)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_equation_param_has_time(const cs_equation_param_t *eqp)
{
  assert(eqp != NULL);
  if (eqp->flag & CS_EQUATION_UNSTEADY)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_equation_param_has_sourceterm(const cs_equation_param_t *eqp)
{
  assert(eqp != NULL);
  if (eqp->n_source_terms > 0)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_equation_param_has_internal_enforcement(const cs_equation_param_t *eqp)
{
  assert(eqp != NULL);
  if (eqp->flag & CS_EQUATION_FORCE_VALUES)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_equation_param_has_implicit_advection(const cs_equation_param_t *eqp)
{
  assert(eqp != NULL);
  if (eqp->flag & CS_EQUATION_CONVECTION) {
    if (eqp->adv_strategy == CS_PARAM_ADVECTION_IMPLICIT_FULL ||
        eqp->adv_strategy == CS_PARAM_ADVECTION_IMPLICIT_LINEARIZED)
      return true;
    else
      return false;
  }
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_equation_param_has_user_hook(const cs_equation_param_t *eqp)
{
  assert(eqp != NULL);
  if (eqp->flag & CS_EQUATION_BUILD_HOOK)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_equation_param_has_name(cs_equation_param_t *eqp,
                           const char          *name)
{
  if (eqp == NULL)
    return false;
  if (eqp->name == NULL)
    return false;
  if (strcmp(eqp->name, name) == 0)
    return true;
  else
    return false;
}
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Create a \ref cs_equation_param_t structure
 *
 * \param[in] name        name of the equation
 * \param[in] type        type of equation
 * \param[in] dim         dim of the variable associated to this equation
 * \param[in] default_bc  type of boundary condition set by default
 *
 * \return a pointer to a new allocated \ref cs_equation_param_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_equation_param_t *
cs_equation_param_create(const char         *name,
                         cs_equation_type_t  type,
                         int                 dim,
                         cs_param_bc_type_t  default_bc);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Create a \ref cs_equation_param_t structure
 *
 * \deprecated Renamed to\ref cs_equation_param_create.
 *
 * \param[in] name        name of the equation
 * \param[in] type        type of equation
 * \param[in] dim         dim of the variable associated to this equation
 * \param[in] default_bc  type of boundary condition set by default
 *
 * \return a pointer to a new allocated \ref cs_equation_param_t structure
 */
/*----------------------------------------------------------------------------*/
 
[[deprecated("Use cs_equation_param_create instead")]]
inline cs_equation_param_t *
cs_equation_create_param(const char         *name,
                         cs_equation_type_t  type,
                         int                 dim,
                         cs_param_bc_type_t  default_bc)
{
  return cs_equation_param_create(name, type, dim, default_bc);
}
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Copy the settings from one \ref cs_equation_param_t structure to
 *        another one. The name is not copied.
 *
 * \param[in]      ref          pointer to the reference cs_equation_param_t
 * \param[in, out] dst          pointer to the cs_equation_param_t to update
 * \param[in]      copy_fld_id  copy also the field id or not
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_param_copy_from(const cs_equation_param_t *ref,
                            cs_equation_param_t       *dst,
                            bool                       copy_fld_id);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Copy only the part dedicated to the boundary conditions and the DoF
 *        (degrees of freedom) enforcement from one \ref cs_equation_param_t
 *        structure to another one.
 *
 * \param[in]      ref  pointer to the reference \ref cs_equation_param_t
 * \param[in, out] dst  pointer to the \ref cs_equation_param_t to update
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_param_copy_bc(const cs_equation_param_t *ref,
                          cs_equation_param_t       *dst);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Copy the settings from one \ref cs_equation_param_t structure to
 *        another one. The name is not copied.
 *
 * \deprecated Renamed to\ref cs_equation_param_copy_from.
 *
 * \param[in]      ref       pointer to the reference \ref cs_equation_param_t
 * \param[in, out] dst       pointer to the \ref cs_equation_param_t to update
 * \param[in]      copy_fid  copy also the field id or not
 */
/*----------------------------------------------------------------------------*/
 
[[deprecated("Use cs_equation_param_copy_from instead")]]
inline void
cs_equation_copy_param_from(const cs_equation_param_t *ref,
                            cs_equation_param_t       *dst,
                            bool                       copy_fid)
{
  cs_equation_param_copy_from(ref, dst, copy_fid);
}
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Free the contents of a \ref cs_equation_param_t
 *
 * The cs_equation_param_t structure itself is not freed, but all its
 * sub-structures are freed.
 *
 * This is useful for equation parameters which are accessed through
 * field keywords.
 *
 * \param[in, out] eqp  pointer to a \ref cs_equation_param_t
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_param_clear(cs_equation_param_t *eqp);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Free a \ref cs_equation_param_t
 *
 * \param[in] eqp  pointer to a \ref cs_equation_param_t
 *
 * \return a null pointer
 */
/*----------------------------------------------------------------------------*/
 
cs_equation_param_t *
cs_equation_param_free(cs_equation_param_t *eqp);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Set a parameter attached to a keyname in a \ref cs_equation_param_t
 *        structure
 *
 * \param[in, out] eqp     pointer to a \ref cs_equation_param_t structure
 * \param[in]      key     key related to the member of eq to set
 * \param[in]      keyval  accessor to the value to set
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_param_set(cs_equation_param_t *eqp,
                      cs_equation_key_t    key,
                      const char          *keyval);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Set a parameter attached to a keyname in a \ref cs_equation_param_t
 *        structure
 *
 * \deprecated Renamed to\ref cs_equation_param_set.
 *
 * \param[in, out] eqp     pointer to a \ref cs_equation_param_t structure
 * \param[in]      key     key related to the member of eq to set
 * \param[in]      keyval  accessor to the value to set
 */
/*----------------------------------------------------------------------------*/
 
[[deprecated("Use cs_equation_param_set instead")]]
inline void
cs_equation_set_param(cs_equation_param_t *eqp,
                      cs_equation_key_t    key,
                      const char           *keyval)
{
  cs_equation_param_set(eqp, key, keyval);
}
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Get the pointer to the set of parameters to handle the SLES solver
 *        associated to this set of equation parameters
 *
 * \param[in] eqp  pointer to a \ref cs_equation_param_t structure
 *
 * \return a pointer to a cs_param_sles_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_param_sles_t *
cs_equation_param_get_sles_param(cs_equation_param_t *eqp);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Get the pointer to the set of parameters to handle the SLES solver
 *        associated to this set of equation parameters
 *
 * \param[in] eqp  pointer to a \ref cs_equation_param_t structure
 *
 * \return a pointer to a cs_param_saddle_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_param_saddle_t *
cs_equation_param_get_saddle_param(cs_equation_param_t *eqp);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Set parameters for initializing SLES structures used for the
 *        resolution of the linear system.
 *        Settings are related to this equation.
 *
 * \param[in, out] eqp  pointer to a cs_equation_param_t structure
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_param_set_sles(cs_equation_param_t *eqp);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Apply the given quadrature rule to all existing definitions under the
 *        cs_equation_param_t structure. To get a more detailed control of the
 *        quadrature rule, please consider the function
 *        \ref cs_xdef_set_quadrature
 *
 * \param[in, out] eqp    pointer to a \ref cs_equation_param_t structure
 * \param[in]      qtype  type of quadrature to apply
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_param_set_quadrature_to_all(cs_equation_param_t  *eqp,
                                        cs_quadrature_type_t  qtype);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Lock settings to prevent from unwanted modifications.
 *
 * \param[in, out] eqp  pointer to a \ref cs_equation_param_t structure
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_param_lock_settings(cs_equation_param_t *eqp);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Unlock settings. Be sure that is really wanted (inconsistency between
 *        the setup logging and what is used may appear)
 *
 * \param[in, out] eqp  pointer to a \ref cs_equation_param_t structure
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_param_unlock_settings(cs_equation_param_t *eqp);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief At this stage, the numerical settings should not be modified anymore
 *        by the user. One makes a last set of modifications if needed to
 *        ensure a consistent numerical settings.
 *
 * \param[in, out] eqp  pointer to a \ref cs_equation_param_t structure
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_param_ensure_consistent_settings(cs_equation_param_t *eqp);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Print the detail of a \ref cs_equation_param_t structure
 *
 * \param[in] eqp  pointer to a \ref cs_equation_param_t structure
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_param_log(const cs_equation_param_t *eqp);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Ask if the parameter settings of the equation has requested the
 *        treatment of Robin boundary conditions
 *
 * \param[in] eqp  pointer to a \ref cs_equation_param_t
 *
 * \return true or false
 */
/*----------------------------------------------------------------------------*/
 
bool
cs_equation_param_has_robin_bc(const cs_equation_param_t *eqp);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Define the initial condition for the unknown related to this
 *        equation. This definition applies to a volume zone.
 *        By default, the unknown is set to zero everywhere.
 *        Here a constant value is set to all the unknows belonging to the
 *        given zone with name z_name
 *
 * \param[in, out] eqp     pointer to a cs_equation_param_t structure
 * \param[in]      z_name  name of the associated zone (if nullptr or "" all
 *                         cells are considered)
 * \param[in]      val     pointer to the value
 *
 * \return a pointer to the new \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_ic_by_value(cs_equation_param_t *eqp,
                            const char          *z_name,
                            cs_real_t           *val);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Define the initial condition for the unknown related to this
 *        equation. This definition applies to a volume zone.
 *        By default, the unknown is set to zero everywhere.
 *        Here the value set to each unknown belonging to the given zone with
 *        name z_name is such that the integral over the cells of the zone
 *        returns the requested quantity
 *
 * \param[in, out] eqp       pointer to a cs_equation_param_t structure
 * \param[in]      z_name    name of the associated zone (if null or "" all
 *                           cells are considered)
 * \param[in]      quantity  quantity to distribute over the mesh location
 *
 * \return a pointer to the new \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_ic_by_qov(cs_equation_param_t *eqp,
                          const char          *z_name,
                          double               quantity);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Define the initial condition for the unknown related to this
 *        equation. This definition applies to a volume zone.
 *        By default, the unknown is set to zero everywhere.
 *        Here the initial value for each unknown associated to the zone with
 *        name z_name is set according to an analytical function
 *
 * \param[in, out] eqp       pointer to a cs_equation_param_t structure
 * \param[in]      z_name    name of the associated zone (if null or "" if
 *                           all cells are considered)
 * \param[in]      analytic  pointer to an analytic function
 * \param[in]      input     null or pointer to a structure cast on-the-fly
 *
 * \return a pointer to the new \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_ic_by_analytic(cs_equation_param_t *eqp,
                               const char          *z_name,
                               cs_analytic_func_t  *analytic,
                               void                *input);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Define the initial condition for the unknown related to this
 *        equation. This definition applies to a volume zone.
 *        By default, the unknown is set to zero everywhere.
 *        Case of a definition by a DoF function.
 *
 * \param[in, out] eqp       pointer to a cs_equation_param_t structure
 * \param[in]      z_name    name of the associated zone (if null or "" if
 *                           all cells are considered)
 * \param[in]      loc_flag  where information is computed
 * \param[in]      func      pointer to a DoF function
 * \param[in]      input     null or pointer to a structure cast on-the-fly
 *
 * \return a pointer to the new \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_ic_by_dof_func(cs_equation_param_t *eqp,
                               const char          *z_name,
                               cs_flag_t            loc_flag,
                               cs_dof_func_t       *func,
                               void                *input);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Set a boundary condition from an existing \ref cs_xdef_t structure
 *        The lifecycle of the cs_xdef_t structure is now managed by the
 *        current \ref cs_equation_param_t structure.
 *
 * \param[in, out] eqp   pointer to a cs_equation_param_t structure
 * \param[in]      xdef  pointer to the \ref cs_xdef_t structure to transfer
*/
/*----------------------------------------------------------------------------*/
 
void
cs_equation_add_xdef_bc(cs_equation_param_t *eqp,
                        cs_xdef_t           *xdef);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Define and initialize a new structure to set a boundary condition
 *        related to the given equation structure
 *        z_name corresponds to the name of a pre-existing cs_zone_t
 *
 * \param[in, out] eqp      pointer to a cs_equation_param_t structure
 * \param[in]      bc_type  type of boundary condition to add
 * \param[in]      z_name   name of the related boundary zone
 * \param[in]      values   pointer to a array storing the values
 *
 * \return a pointer to the new \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_bc_by_value(cs_equation_param_t      *eqp,
                            const cs_param_bc_type_t  bc_type,
                            const char               *z_name,
                            cs_real_t                *values);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Define and initialize a new structure to set a boundary condition
 *        related to the given equation structure
 *        z_name corresponds to the name of a pre-existing cs_zone_t
 *
 * \param[in, out] eqp          pointer to a cs_equation_param_t structure
 * \param[in]      bc_type      type of boundary condition to add
 * \param[in]      z_name       name of the related boundary zone
 * \param[in]      loc          information to know where are located values
 * \param[in]      array        pointer to an array
 * \param[in]      is_owner     transfer the lifecycle to the cs_xdef_t struct.
 *                              (true or false)
 * \param[in]      full_length  if true, size of "array" should be allocated
 *                              to the total numbers of entities related to the
 *                              given location. If false, a new list is
 *                              allocated and filled with the related subset
 *                              indirection.
 *
 * \return a pointer to the new allocated \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_bc_by_array(cs_equation_param_t      *eqp,
                            const cs_param_bc_type_t  bc_type,
                            const char               *z_name,
                            cs_flag_t                 loc,
                            cs_real_t                *array,
                            bool                      is_owner,
                            bool                      full_length);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Define and initialize a new structure to set a boundary condition
 *        related to the given equation structure
 *        z_name corresponds to the name of a pre-existing cs_zone_t
 *
 * \param[in, out] eqp      pointer to a cs_equation_param_t structure
 * \param[in]      bc_type  type of boundary condition to add
 * \param[in]      z_name   name of the related boundary zone
 * \param[in]      field    pointer to a cs_field_t structure
 *
 * \return a pointer to the new allocated \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_bc_by_field(cs_equation_param_t      *eqp,
                            const cs_param_bc_type_t  bc_type,
                            const char               *z_name,
                            cs_field_t               *field);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Define and initialize a new structure to set a boundary condition
 *        related to the given equation param structure
 *        ml_name corresponds to the name of a pre-existing cs_mesh_location_t
 *
 * \param[in, out] eqp       pointer to a cs_equation_param_t structure
 * \param[in]      bc_type   type of boundary condition to add
 * \param[in]      z_name    name of the associated zone (if null or "" if
 *                           all cells are considered)
 * \param[in]      analytic  pointer to an analytic function defining the value
 * \param[in]      input     null or pointer to a structure cast on-the-fly
 *
 * \return a pointer to the new \ref cs_xdef_t structure
*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_bc_by_analytic(cs_equation_param_t      *eqp,
                               const cs_param_bc_type_t  bc_type,
                               const char               *z_name,
                               cs_analytic_func_t       *analytic,
                               void                     *input);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Define and initialize a new structure to set a boundary condition
 *        related to the given equation param structure
 *        ml_name corresponds to the name of a pre-existing cs_mesh_location_t
 *        Definition relying on a \ref cs_time_func_t function pointer
 *
 * \param[in, out] eqp      pointer to a cs_equation_param_t structure
 * \param[in]      bc_type  type of boundary condition to add
 * \param[in]      z_name   name of the associated zone (if null or "" if
 *                          all cells are considered)
 * \param[in]      t_func   pointer to an analytic function defining the value
 * \param[in]      input    null or pointer to a structure cast on-the-fly
 *
 * \return a pointer to the new \ref cs_xdef_t structure
*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_bc_by_time_func(cs_equation_param_t      *eqp,
                                const cs_param_bc_type_t  bc_type,
                                const char               *z_name,
                                cs_time_func_t           *t_func,
                                void                     *input);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Define and initialize a new structure to set a boundary condition
 *        related to the given cs_equation_param_t structure
 *        ml_name corresponds to the name of a pre-existing cs_mesh_location_t
 *
 * \param[in, out] eqp       pointer to a cs_equation_param_t structure
 * \param[in]      bc_type   type of boundary condition to add
 * \param[in]      z_name    name of the associated zone (if null or "" if
 *                           all cells are considered)
 * \param[in]      loc_flag  location where values are computed
 * \param[in]      func      pointer to cs_dof_func_t function
 * \param[in]      input     null or pointer to a structure cast on-the-fly
 *
 * \return a pointer to the new \ref cs_xdef_t structure
*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_bc_by_dof_func(cs_equation_param_t      *eqp,
                               const cs_param_bc_type_t  bc_type,
                               const char               *z_name,
                               cs_flag_t                 loc_flag,
                               cs_dof_func_t            *func,
                               void                     *input);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Add a new volume mass injection definition source term by
 *        initializing a cs_xdef_t structure, using an array.
 *
 * \param[in, out] eqp          pointer to a cs_equation_param_t structure
 * \param[in]      bc_type      type of boundary condition to add
 * \param[in]      z_name       name of the related boundary zone
 * \param[in]      loc          information to know where are located values
 * \param[in]      array        pointer to an array
 * \param[in]      is_owner     transfer the lifecycle to the cs_xdef_t struct.
 *                              (true or false)
 * \param[in]      full_length  if true, size of "array" should be allocated
 *                              to the total numbers of entities related to the
 *                              given location. If false, a new list is
 *                              allocated and filled with the related subset
 *                              indirection.
 *
 * \return a pointer to the new allocated \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_volume_mass_injection_by_array(cs_equation_param_t *eqp,
                                               const char          *z_name,
                                               cs_flag_t            loc_flag,
                                               cs_real_t           *array,
                                               bool                 is_owner,
                                               bool                 full_length);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Return pointer to existing boundary condition definition structure
 *        for the given equation param structure and zone.
 *
 * \param[in, out] eqp     pointer to a cs_equation_param_t structure
 * \param[in]      z_name  name of the associated zone (if null or "" if
 *                         all cells are considered)
 *
 * \return a pointer to the \ref cs_xdef_t structure if present, or null
*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_find_bc(cs_equation_param_t *eqp,
                    const char          *z_name);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Remove boundary condition from the given equation param structure
 *        for a given zone.
 *
 * If no matching boundary condition is found, the function returns
 * silently.
 *
 * \param[in, out] eqp     pointer to a cs_equation_param_t structure
 * \param[in]      z_name  name of the associated zone (if null or "" if
 *                         all cells are considered)
*/
/*----------------------------------------------------------------------------*/
 
void
cs_equation_remove_bc(cs_equation_param_t *eqp,
                      const char          *z_name);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Remove initial condition from the given equation param structure
 *        for a given zone.
 *
 * If no matching boundary condition is found, the function returns
 * silently.
 *
 * \param[in, out] eqp     pointer to a cs_equation_param_t structure
 * \param[in]      z_name  name of the associated zone (if null or "" if
 *                         all cells are considered)
*/
/*----------------------------------------------------------------------------*/
 
void
cs_equation_remove_ic(cs_equation_param_t *eqp,
                      const char          *z_name);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Define and initialize a new structure to set a sliding boundary
 *        condition related to the given equation structure
 *        z_name corresponds to the name of a pre-existing cs_zone_t
 *
 * \param[in, out] eqp     pointer to a cs_equation_param_t structure
 * \param[in]      z_name  name of the related boundary zone
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_add_sliding_condition(cs_equation_param_t *eqp,
                                  const char          *z_name);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Associate a new term related to the Laplacian operator for the
 *        equation associated to the given \ref cs_equation_param_t structure
 *        Laplacian means div-grad (either for vector-valued or scalar-valued
 *        equations)
 *
 * \param[in, out] eqp       pointer to a cs_equation_param_t structure
 * \param[in]      property  pointer to a cs_property_t structure
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_add_diffusion(cs_equation_param_t *eqp,
                          cs_property_t       *property);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Associate a new term related to the curl-curl operator for the
 *        equation associated to the given \ref cs_equation_param_t structure
 *
 * \param[in, out] eqp        pointer to a cs_equation_param_t structure
 * \param[in]      property   pointer to a cs_property_t structure
 * \param[in]      inversion  1: true, false otherwise
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_add_curlcurl(cs_equation_param_t *eqp,
                         cs_property_t       *property,
                         int                  inversion);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Associate a new term related to the grad-div operator for the
 *        equation associated to the given \ref cs_equation_param_t structure
 *
 * \param[in, out] eqp       pointer to a cs_equation_param_t structure
 * \param[in]      property  pointer to a cs_property_t structure
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_add_graddiv(cs_equation_param_t *eqp,
                        cs_property_t       *property);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Associate a new term related to the time derivative operator for
 *        the equation associated to the given \ref cs_equation_param_t
 *        structure
 *
 * \param[in, out] eqp       pointer to a cs_equation_param_t structure
 * \param[in]      property  pointer to a cs_property_t structure
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_add_time(cs_equation_param_t *eqp,
                     cs_property_t       *property);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Associate a new term related to the advection operator for the
 *        equation associated to the given \ref cs_equation_param_t structure
 *
 * \param[in, out] eqp        pointer to a cs_equation_param_t structure
 * \param[in]      adv_field  pointer to a cs_adv_field_t structure
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_add_advection(cs_equation_param_t *eqp,
                          cs_adv_field_t      *adv_field);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Associate a scaling property to the advection
 *
 * \param[in, out] eqp       pointer to a cs_equation_param_t structure
 * \param[in]      property  pointer to a cs_property_t structure
 */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_add_advection_scaling_property(cs_equation_param_t *eqp,
                                           cs_property_t       *property);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Associate a new term related to the reaction operator for the
 *        equation associated to the given \ref cs_equation_param_t structure
 *
 * \param[in, out] eqp       pointer to a cs_equation_param_t structure
 * \param[in]      property  pointer to a cs_property_t structure
 *
 * \return the id related to the reaction term
 */
/*----------------------------------------------------------------------------*/
 
int
cs_equation_add_reaction(cs_equation_param_t *eqp,
                         cs_property_t       *property);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Add a new source term by initializing a cs_xdef_t structure.
 *        Case of a definition by a constant value
 *
 * \param[in, out] eqp     pointer to a cs_equation_param_t structure
 * \param[in]      z_name  name of the associated zone (if null or
 *                         "" all cells are considered)
 * \param[in]      val     value to set
 *
 * \return a pointer to the new \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_source_term_by_val(cs_equation_param_t *eqp,
                                   const char          *z_name,
                                   cs_real_t           *val);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Add a new source term by initializing a cs_xdef_t structure.
 *        Case of a definition by an analytical function
 *
 * \param[in, out] eqp     pointer to a cs_equation_param_t structure
 * \param[in]      z_name  name of the associated zone (if null or "" if
 *                         all cells are considered)
 * \param[in]      func    pointer to an analytical function
 * \param[in]      input   null or pointer to a structure cast on-the-fly
 *
 * \return a pointer to the new \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_source_term_by_analytic(cs_equation_param_t *eqp,
                                        const char          *z_name,
                                        cs_analytic_func_t  *func,
                                        void                *input);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Add a new source term by initializing a cs_xdef_t structure.
 *        Case of a definition by a DoF function
 *
 * \param[in, out] eqp       pointer to a cs_equation_param_t structure
 * \param[in]      z_name    name of the associated zone (if null or "" if
 *                           all cells are considered)
 * \param[in]      loc_flag  location of element ids given as parameter
 * \param[in]      func      pointer to a DoF function
 * \param[in]      input     null or pointer to a structure cast on-the-fly
 *
 * \return a pointer to the new \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_source_term_by_dof_func(cs_equation_param_t *eqp,
                                        const char          *z_name,
                                        cs_flag_t            loc_flag,
                                        cs_dof_func_t       *func,
                                        void                *input);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Add a new source term by initializing a cs_xdef_t structure.
 *        Case of a definition by an array.
 *
 * \param[in, out] eqp          pointer to a cs_equation_param_t structure
 * \param[in]      z_name       name of the associated zone (if null or "" if
 *                              all cells are considered)
 * \param[in]      loc          information to know where are located values
 * \param[in]      array        pointer to an array
 * \param[in]      is_owner     transfer the lifecycle to the cs_xdef_t struct.
 *                              (true or false)
 * \param[in]      full_length  if true, the size of "array" should be allocated
 *                              to the total numbers of entities related to the
 *                              given location. If false, a new list is
 *                              allocated and filled with the related subset
 *                              indirection.
 *
 * \return a pointer to the new \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_source_term_by_array(cs_equation_param_t *eqp,
                                     const char          *z_name,
                                     cs_flag_t            loc,
                                     cs_real_t           *array,
                                     bool                 is_owner,
                                     bool                 full_length);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Add a new volume mass injection definition source term by
 *        initializing a cs_xdef_t structure, using a constant value.
 *
 * \param[in, out] eqp     pointer to a cs_equation_param_t structure
 * \param[in]      z_name  name of the associated zone (if null or "" if
 *                         all cells are considered)
 * \param[in]      val     pointer to the value
 *
 * \return a pointer to the new \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_volume_mass_injection_by_value(cs_equation_param_t *eqp,
                                               const char          *z_name,
                                               double              *val);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Add a new volume mass injection definition source term by
 *        initializing a cs_xdef_t structure, using a constant quantity
 *        distributed over the associated zone's volume.
 *
 * \param[in, out] eqp       pointer to a cs_equation_param_t structure
 * \param[in]      z_name    name of the associated zone (if null or "" if
 *                           all cells are considered)
 * \param[in]      quantity  pointer to quantity to distribute over the zone
 *
 * \return a pointer to the new \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_volume_mass_injection_by_qov(cs_equation_param_t *eqp,
                                             const char          *z_name,
                                             double              *quantity);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Add a new volume mass injection definition source term by
 *        initializing a cs_xdef_t structure, using an analytical function.
 *
 * \param[in, out] eqp     pointer to a cs_equation_param_t structure
 * \param[in]      z_name  name of the associated zone (if null or "" if
 *                         all cells are considered)
 * \param[in]      func    pointer to an analytical function
 * \param[in]      input   null or pointer to a structure cast on-the-fly
 *
 * \return a pointer to the new \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_volume_mass_injection_by_analytic(cs_equation_param_t *eqp,
                                                  const char          *z_name,
                                                  cs_analytic_func_t  *func,
                                                  void                *input);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Add a new volume mass injection definition source term by
 *        initializing a cs_xdef_t structure, using a DoF function.
 *
 * \param[in, out] eqp       pointer to a cs_equation_param_t structure
 * \param[in]      z_name    name of the associated zone (if null or "" if
 *                           all cells are considered)
 * \param[in]      loc_flag  where information is computed
 * \param[in]      func      pointer to an analytical function
 * \param[in]      input     null or pointer to a structure cast on-the-fly
 *
 * \return a pointer to the new \ref cs_xdef_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_equation_add_volume_mass_injection_by_dof_func(cs_equation_param_t *eqp,
                                                  const char          *z_name,
                                                  cs_flag_t            loc_flag,
                                                  cs_dof_func_t       *func,
                                                  void                *input);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Add an enforcement of the value of degrees of freedom located at
 *        the mesh vertices.
 *        The spatial discretization scheme for the given equation has to be
 *        CDO vertex-based or CDO vertex+cell-based schemes.
 *
 *        One assumes that values are interlaced if eqp->dim > 1
 *        ref_value or elt_values has to be defined. If both parameters are
 *        defined, one keeps the definition in elt_values
 *
 * \param[in, out] eqp         pointer to a cs_equation_param_t structure
 * \param[in]      n_vertices  number of vertices to enforce
 * \param[in]      vertex_ids  list of vertices
 * \param[in]      ref_value   default values or ignored (may be null)
 * \param[in]      vtx_values  list of associated values, ignored if null
 *
 * \return a pointer to a cs_enforcement_param_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_enforcement_param_t *
cs_equation_add_vertex_dof_enforcement(cs_equation_param_t *eqp,
                                       cs_lnum_t            n_vertices,
                                       const cs_lnum_t      vertex_ids[],
                                       const cs_real_t      ref_value[],
                                       const cs_real_t      vtx_values[]);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Add an enforcement of the value of degrees of freedom located at
 *        the mesh edges.
 *        The spatial discretization scheme for the given equation has to be
 *        CDO edge-based schemes.
 *
 *        One assumes that values are interlaced if eqp->dim > 1
 *        ref_value or elt_values has to be defined. If both parameters are
 *        defined, one keeps the definition in elt_values
 *
 * \param[in, out] eqp          pointer to a cs_equation_param_t structure
 * \param[in]      n_edges      number of edges to enforce
 * \param[in]      edge_ids     list of edges
 * \param[in]      ref_value    default values or ignored (may be null)
 * \param[in]      edge_values  list of associated values, ignored if null
 *
 * \return a pointer to a cs_enforcement_param_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_enforcement_param_t *
cs_equation_add_edge_dof_enforcement(cs_equation_param_t *eqp,
                                     cs_lnum_t            n_edges,
                                     const cs_lnum_t      edge_ids[],
                                     const cs_real_t      ref_value[],
                                     const cs_real_t      edge_values[]);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Add an enforcement of the value of degrees of freedom located at
 *        the mesh faces.
 *        The spatial discretization scheme for the given equation has to be
 *        CDO face-based schemes.
 *
 *        One assumes that values are interlaced if eqp->dim > 1
 *        ref_value or elt_values has to be defined. If both parameters are
 *        defined, one keeps the definition in elt_values
 *
 * \param[in, out] eqp          pointer to a cs_equation_param_t structure
 * \param[in]      n_faces      number of faces to enforce
 * \param[in]      face_ids     list of faces
 * \param[in]      ref_value    default values or ignored (may be null)
 * \param[in]      face_values  list of associated values, ignored if null
 *
 * \return a pointer to a cs_enforcement_param_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_enforcement_param_t *
cs_equation_add_face_dof_enforcement(cs_equation_param_t *eqp,
                                     cs_lnum_t            n_faces,
                                     const cs_lnum_t      face_ids[],
                                     const cs_real_t      ref_value[],
                                     const cs_real_t      face_values[]);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Add an enforcement of the value related to the degrees of freedom
 *        associated to the list of selected cells.
 *
 *        One assumes that values are interlaced if eqp->dim > 1
 *        ref_value or elt_values has to be defined. If both parameters are
 *        defined, one keeps the definition in elt_values
 *
 * \param[in, out] eqp          pointer to a cs_equation_param_t structure
 * \param[in]      n_cells      number of selected cells
 * \param[in]      cell_ids     list of cell ids
 * \param[in]      ref_value    ignored if null
 * \param[in]      cell_values  list of associated values, ignored if null
 *
 * \return a pointer to a cs_enforcement_param_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_enforcement_param_t *
cs_equation_add_cell_enforcement(cs_equation_param_t *eqp,
                                 cs_lnum_t            n_cells,
                                 const cs_lnum_t      elt_ids[],
                                 const cs_real_t      ref_value[],
                                 const cs_real_t      cell_values[]);
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Add a new enforcement if enforcement_id does not exist or replace it
 *        otherwise. Enforcement of the value related to the degrees of freedom
 *        associated to the list of selected cells.
 *
 *        One assumes that values are interlaced if eqp->dim > 1
 *        ref_value or elt_values has to be defined. If both parameters are
 *        defined, one keeps the definition in elt_values
 *
 * \param[in, out] eqp             pointer to a cs_equation_param_t structure
 * \param[in]      enforcement_id  id of the enforcement to handle
 * \param[in]      n_cells         number of selected cells
 * \param[in]      cell_ids        list of cell ids
 * \param[in]      ref_value       ignored if null
 * \param[in]      cell_values     list of associated values, ignored if null
 *
 * \return a pointer to a cs_enforcement_param_t structure
 */
/*----------------------------------------------------------------------------*/
 
cs_enforcement_param_t *
cs_equation_add_or_replace_cell_enforcement(cs_equation_param_t *eqp,
                                            int                  enforcement_id,
                                            cs_lnum_t            n_cells,
                                            const cs_lnum_t      cell_ids[],
                                            const cs_real_t      ref_value[],
                                            const cs_real_t      cell_values[]);
 
/*----------------------------------------------------------------------------*/
/* Clear time control data from equation_param instance. */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_time_control_clear(cs_equation_param_t *eqp);
 
/*----------------------------------------------------------------------------*/
/* Add a time control to an equation_parap structure */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_time_control_add(cs_equation_param_t *eqp,
                             cs_time_control_t   *time_control,
                             bool                 shallow_copy);
 
/*----------------------------------------------------------------------------*/
/* Add a time control to an equation_parap structure based on default values */
/*----------------------------------------------------------------------------*/
 
void
cs_equation_time_control_add_default(cs_equation_param_t *eqp);
 
/*----------------------------------------------------------------------------*/
 
#endif /* CS_EQUATION_PARAM_H */