cs_lagr.h

Go to the documentation of this file.

#ifndef __CS_LAGR_H__
#define __CS_LAGR_H__
 
/*============================================================================
 * Functions and types for the Lagrangian module
 *============================================================================*/
 
/*
  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"
 
/*----------------------------------------------------------------------------
 *  Local headers
 *----------------------------------------------------------------------------*/
 
#include "base/cs_base.h"
#include "base/cs_field.h"
 
#include "lagr/cs_lagr_injection.h"
 
/*----------------------------------------------------------------------------*/
 
BEGIN_C_DECLS
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
typedef void
(cs_lagr_injection_profile_compute_t) (int               zone_id,
                                       int               location_id,
                                       const void       *input,
                                       cs_lnum_t         n_elts,
                                       const cs_lnum_t   elt_ids[],
                                       cs_real_t         profile[]);

/*--------------------------------------*/
 
typedef enum {
 
  CS_LAGR_BC_UNDEFINED,  
  CS_LAGR_SYM,           
  CS_LAGR_INLET,         
  CS_LAGR_OUTLET,        
  CS_LAGR_REBOUND,       
  CS_LAGR_DEPO1,         
  CS_LAGR_DEPO2,         
  CS_LAGR_DEPO_DLVO,     
  CS_LAGR_FOULING,       
  CS_LAGR_BC_USER        
 
} cs_lagr_bc_type;

/*---------------------------------------*/
 
enum {
  CS_LAGR_IN_IMPOSED_FLUID_VALUE = -1,  
  CS_LAGR_IN_IMPOSED_NORM = 0,          
  CS_LAGR_IN_IMPOSED_COMPONENTS = 1     
};

 
typedef enum {
  CS_LAGR_OFF = 0,
  CS_LAGR_ONEWAY_COUPLING = 1,
  CS_LAGR_TWOWAY_COUPLING = 2,
  CS_LAGR_FROZEN_CONTINUOUS_PHASE = 3
} cs_lagr_module_status_t;

/*---------------------------------*/
 
typedef enum {

  CS_LAGR_SHAPE_SPHERE_MODEL = 0,

  CS_LAGR_SHAPE_SPHEROID_STOC_MODEL = 1,
 
  /*< Impose spheroids (Jeffery equations for transport) */
  CS_LAGR_SHAPE_SPHEROID_JEFFERY_MODEL = 2,
 
} cs_lagr_module_shape_t;

/*---------------------------------------*/
 
enum {
  CS_LAGR_PHYS_OFF = 0,
  CS_LAGR_PHYS_HEAT = 1,
  CS_LAGR_PHYS_COAL = 2,
  CS_LAGR_PHYS_CTWR = 3
};

/*----------------------*/
 
typedef struct {
 
  int nusbrd;  
 
  int ndlaim;  
 
  int ncharm2; 
  int nlayer;  
 
} cs_lagr_const_dim_t;

/*---------------------*/
 
typedef struct {
 
  int   n_boundary_stats;  
 
} cs_lagr_dim_t;

/*-----------------------------------------------------*/
 
typedef struct {

  int  iilagr;
 
  /*  indicates the steady (=1) or unsteady (=0) state of the
      continuous phase flow
      in particular, \ref isttio = 1 is needed in order to:
      calculate steady statistics in the volume or at the boundaries
      (starting respectively from the iterations
      \ref cs_lagr_stat_options_t::nstist "nstist")
      and calculate time-averaged two-way coupling source terms (from the
      time step \ref nstits).
      Useful if \ref iilagr = CS_LAGR_ONEWAY_COUPLING
      or \ref iilagr = CS_LAGR_TWOWAY_COUPLING
      (if \ref iilagr = CS_LAGR_FROZEN_CONTINUOUS_PHASE,
      then \ref isttio=1 automatically) */
  int  isttio;

  int  isuila;

  int  t_order;

  int  extended_t_scheme;

  int interpol_field;

  int     ilapoi;

  int     iadded_mass;

  cs_real_t        added_mass_const;
 
} cs_lagr_time_scheme_t;

/*-----------------------------------------------------------*/
 
typedef struct {

  int  physical_model;
  int  n_temperature_layers;

  int cs_used;

  int modcpl;

  int idistu;

  int idiffl;

  int  deposition;
 
  int  dlvo;

  int  roughness;

  int  resuspension;

  int  clogging;

  int  shape;

  int  consolidation;
 
  int  precipitation;
  int  fouling;

  int agglomeration;

  int fragmentation;
 
  int  n_stat_classes;
 
  int  n_user_variables;

  bool viscous_terms;
 
} cs_lagr_model_t;

/*----------------------------------------------*/
 
typedef struct {

  cs_gnum_t   n_g_cumulative_total;

  cs_gnum_t   n_g_cumulative_failed;

  cs_gnum_t   n_g_total;

  cs_gnum_t   n_g_new;

  cs_gnum_t   n_g_exit;

  cs_gnum_t   n_g_merged;

  cs_gnum_t   n_g_deposited;

  cs_gnum_t   n_g_fouling;

  cs_gnum_t   n_g_resuspended;

  cs_gnum_t   n_g_failed;

  cs_real_t   w_total;

  cs_real_t   w_new;

  cs_real_t   w_exit;

  cs_real_t   w_merged;

  cs_real_t   w_deposited;

  cs_real_t   w_fouling;

  cs_real_t   w_resuspended;
 
} cs_lagr_particle_counter_t;

/* ---------------------------------------------------------- */
 
typedef struct {
 
  /*  activation (=1) or not (=0) of an evolution equation on the particle
      temperature seen (in degrees Celsius).
      Useful if \ref physical_model=1 and if there is a thermal scalar
      associated with the continuous phase.
  */
  int   solve_temperature_seen;
 
  /*  activation (=1) or not (=0) of an evolution equation on the particle
      temperature (in degrees Celsius).
      Useful if \ref physical_model=1 and if there is a thermal scalar
      associated with the continuous phase.
  */
  int   itpvar;
 
  /*  activation (=1) or not (=0) of an evolution equation on the particle
      diameter. Useful if \ref physical_model = 1.
  */
  int   idpvar;
 
  /*  activation (=1) or not (=0) of an evolution equation on the particle mass
      Useful if \ref physical_model = 1
  */
  int   impvar;
 
  /*  initialization temperature (in degree Celsius) for the particles already
      present in the calculation domain when an evolution equation on
      the particle temperature is activated during a calculation
      (\ref physical_model = 1 and \ref itpvar = 1).
      Useful if \ref isuila = 1 and \ref itpvar = 0 in the previous calculation.
  */
  cs_real_t          tpart;
 
  /* initialization value for the specific heat (\f$ J.kg^{-1}.K^{-1} \f$)
     of the particles already present
     in the calculation domain when an evolution equation
     on the particle temperature is activated during a calculation
     (\ref physical_model = 1 and \ref itpvar = 1).
     Useful if \ref isuila = 1 and \ref itpvar = 0 in the previous calculation
  */
  cs_real_t          cppart;
 
} cs_lagr_specific_physics_t;

/* -------------------------------------- */
 
typedef struct {
 
  /* - 0: no resuspension model
     - 1: resuspension model */
  int   ireent;
 
  /*  - 0: no head losses calculation for influence of the deposit on the flow
      - 1: head losses calculation for influence of the deposit on the flow */
  int   iflow;
 
  /* Parameters of the particle resuspension model*/
  cs_real_t          espasg;
  cs_real_t          denasp;
  cs_real_t          modyeq;
  cs_real_t          rayasp;
  cs_real_t          rayasg;
 
} cs_lagr_reentrained_model_t;

/* -------------------------------------- */
 
typedef struct {
 
  /* number of particle classes*/
  int   nbrclas;
  /* diameter of particles formed by precipitation*/
  cs_real_t          diameter;
  /* density of particles formed by precipitation*/
  cs_real_t          rho;
  /* number of precipitated particles */
  int   *nbprec;
  /*  */
  cs_real_t          *solub;
  /* number of precipitated particles */
  cs_real_t          *mp_diss;
 
} cs_lagr_precipitation_model_t;

/* ------------------------------------------ */
 
typedef struct {
 
  cs_real_t          jamlim;
  cs_real_t          mporos;
  cs_real_t          csthpp;
  cs_real_t          diam_mean;
 
} cs_lagr_clogging_model_t;

/* ------------------------------------------------ */
 
typedef struct {
 
  cs_real_t          param_chmb;
 
} cs_lagr_shape_model_t;

/* ------------------------------------------ */
 
typedef struct {
 
  cs_lnum_t          n_max_classes;
  cs_real_t          min_stat_weight;
  cs_real_t          max_stat_weight;
  cs_real_t          scalar_kernel;
  cs_real_t          base_diameter;
 
} cs_lagr_agglomeration_model_t;

/* ------------------------------------------ */
 
typedef struct {
 
  cs_real_t          scalar_kernel;
  cs_real_t          base_diameter;
  cs_real_t          (*function_kernel)(cs_lnum_t);
 
} cs_lagr_fragmentation_model_t;

/* ----------------------------------------------- */
 
typedef struct {
 
  cs_lnum_t          iconsol;
  cs_real_t          rate_consol;
  cs_real_t          slope_consol;
  cs_real_t          force_consol;
 
} cs_lagr_consolidation_model_t;

/*----------------------------------*/
 
typedef struct {
 
  /* current step id (for 2nd order scheme) */
  int    nor;
 
  /* duration of a Lagrangian iteration */
  cs_real_t          dtp;
 
  /* physical time of the Lagrangian simulation */
  cs_real_t          ttclag;
 
} cs_lagr_time_step_t;

/*------------------------------------------------------------------*/
 
typedef struct {
 
  int         zone_id;               
  int         set_id;                
  int         location_id;           
 
  cs_gnum_t   n_inject;              
 
  int         injection_frequency;   

  cs_lagr_injection_profile_compute_t  *injection_profile_func;

  void                                 *injection_profile_input;

  int         velocity_profile;

  int         temperature_profile;
 
  int         coal_number;          
 
  int         cluster;              
 
  int         aggregat_class_id;    
  cs_real_t   aggregat_fractal_dim; 
 
  cs_real_t   velocity_magnitude;   
  cs_real_t   velocity[3];          
 
  cs_real_t   temperature;          
 
  cs_real_t   diameter;             
  cs_real_t   diameter_variance;    
 
  cs_real_t   shape;                
  cs_real_t   orientation[3];       
  cs_real_t   radii[3];             
  cs_real_t   angular_vel[3];       
 
  cs_real_t   euler[4];             
  cs_real_t   shape_param[4];       
  cs_real_t   density;              
 
  cs_real_t   fouling_index;        
 
  cs_real_t   cp;                   
 
  cs_real_t   stat_weight;          
 
  cs_real_t   flow_rate;            
 
  cs_real_t   emissivity;           
 
} cs_lagr_injection_set_t;

/*----------------------------------------------*/
 
typedef struct {

  int  ltsdyn;

  int  ltsmas;
 
  /*  if \ref physical_model = 1 and \ref itpvar = 1, \ref ltsthe
   activates (=1) or not (=0) the two-way coupling on temperature.
   if \ref physical_model = 2, \ref ltsthe activates (=1) or not (=0) the
   two-way coupling on the eulerian variables related to pulverised
   coal combustion.
   Useful if \ref iilagr = CS_LAGR_TWOWAY_COUPLING */
  int  ltsthe;

  int  nstits;

  int  npts;

  int  ntxerr;

  cs_real_t      vmax;

  cs_real_t      tmamax;
 
} cs_lagr_source_terms_t;

/*----------------------------------------------------*/
 
typedef struct {
 
  int                         location_id;         
 
  int                         n_zones;             
  int                        *zone_type;           
 
  int                        *n_injection_sets;    
  cs_lagr_injection_set_t   **injection_set;       
 
  char                       *elt_type;            
 
  cs_real_t                  *particle_flow_rate;  
 
} cs_lagr_zone_data_t;

/*---------------------------------------*/
 
typedef struct {
 
  int  *i_face_zone_id;
 
} cs_lagr_internal_condition_t;

/*--------------------------------*/
 
typedef struct {
 
  /* Activates (=1) or not (=0) the option of coal particle fouling.
     It then is necessary to specify the domain boundaries
     on which fouling may take place. Useful if \ref physical_model = 2*/
  int  iencra;
 
  /* encrustation data*/
  int  npencr;
  // TODO cf particles->n_part_fou in cs_lagr_tracking.c
 
  /* encrustation data*/
  cs_real_t  *enc1;  // size: ncharm2
  /* encrustation data*/
  cs_real_t  *enc2;  // size: ncharm2
 
  /* Limit temperature (in degree Celsius) below which the coal particles do
     not cause any fouling (if the fouling model is activated).
     Useful if \ref physical_model = 2 and \ref iencra = 1*/
  cs_real_t  *tprenc; // size: ncharm2
 
  /* Ash critical viscosity in \f$ kg.m^{-1}.s^{-1} \f$, in the fouling model
     cf J.D. Watt et T. Fereday (J.Inst.Fuel, Vol.42-p99).
     Useful if \ref physical_model = 2 and \ref iencra = 1*/
  cs_real_t  *visref;  // size: ncharm2
 
  /* encrustation data */
  cs_real_t  dnpenc;
 
} cs_lagr_encrustation_t;

/*-----------------------------------------*/
 
typedef struct {

  cs_real_t  cstham;

  cs_real_t  lambda_vdw;

  cs_real_t  epseau;

  cs_real_t  phi_p;

  cs_real_t  phi_s;

  cs_real_t  valen;

  cs_real_t  fion;
 
} cs_lagr_physico_chemical_t;

/*-------------------------------*/
 
typedef struct {
 
  int  lamvbr;  
 
} cs_lagr_brownian_t;

/*----------------------------------------------*/
 
typedef struct {

  int  npstf;

  int  npstft;

  int  has_part_impact_nbr;

  int  iclgst;

  int  inbr;

  int  inclg;

  int  inclgt;

  int  iclogt;

  int  iclogh;

  int  iscovc;
 
  /* id for mean of particle deposition height */
  int  ihdepm;
 
  /* id for variance of particle deposition height */
  int  ihdepv;
 
  /* id for mean diameter of deposited particles */
  int  ihdiam;
 
  /* id for sum of deposited particle diameters */
  int  ihsum;

  cs_real_t tstatp;

  char  **nombrd;
 
} cs_lagr_boundary_interactions_t;

/*-----------------------------------------------*/
 
typedef struct {
  /* number of carrier phases */
  int n_phases;
 
  /* Turbulence model */
  int iturb;
  int itytur;
  int turb_model;
 
  /* cpincl */
  int ncharb;
 
  /* ppppar */
  int ncharm;
 
  /* radiation */
  int radiative_model;
 
  /* icp */
  int icp;
 
  /* cmu */
  cs_real_t cmu;
 
  /* visls0 */
  cs_real_t visls0;
 
  /* Referenced fields
     ----------------- */
 
  /* wall ustar */
  cs_field_t *ustar;
 
  /* alpha: fluid volume fraction */
  cs_field_t *alpha;
 
  /* wall tstar */
  cs_field_t *tstar;
 
  /* Fluid density */
  cs_field_t *cromf;
 
  /* Fluid pressure */
  cs_field_t *pressure;
 
  /* Fluid temperature */
  cs_field_t *scal_t;
  cs_field_t *temperature;
 
  /* Fluid temperature variance */
  cs_field_t *temperature_variance;
 
  /* Turbulent heat flux */
  cs_field_t *temperature_turbulent_flux;
 
  /* Fluid velocity */
  cs_field_t *vel;
 
  /* Fluid viscosity */
  cs_field_t *viscl;
 
  /* Fluid viscosity */
  cs_field_t *cpro_viscls;
 
  /* Fluid specific heat capacity */
  cs_field_t *cpro_cp;
 
  /* Radiative energy */
  cs_field_t *rad_energy;
 
  /* Combustion    */
  cs_field_t *x_oxyd;
  cs_field_t *x_eau;
  cs_field_t *x_m;
 
  /* Turbulence */
  /* Turbulent intensity */
  cs_field_t *cvar_k;
 
  /* gradient turbulent intensity */
  cs_field_t *cvar_gradk;
 
  /* Turbulent dissipation */
  cs_field_t *cvar_ep;
 
  /* Omega from k-omega SST model*/
  cs_field_t *cvar_omg;
 
  /* Reynolds Stress Tensor */
  cs_field_t *cvar_rij;
 
  /* Reynolds gradient Stress Tensor */
  cs_field_t *cvar_gradrij;
 
  /* Total pressure gradient */
  cs_real_3_t *grad_pr;
 
  /* velocity gradient */
  cs_real_33_t *grad_vel;
 
  /* fluid temperature gradient */
  cs_real_3_t *grad_tempf;
 
  /* Lagrangian time field */
  cs_field_t *lagr_time;
 
  /* Lagrangian time gradient */
  cs_real_3_t *grad_lagr_time;
 
  /* fluid seen/fluid seen covariance gradient */
  cs_real_3_t *grad_cov_skp[9];
 
  /* fluid seen/particle velocity covariance gradient */
  cs_real_3_t *grad_cov_sk[6];
 
} cs_lagr_extra_module_t;
 
/*============================================================================
 * Global variables
 *============================================================================*/

 
extern const cs_lagr_const_dim_t          *cs_glob_lagr_const_dim;

 
extern cs_lagr_dim_t                      *cs_glob_lagr_dim;

extern cs_lagr_time_scheme_t              *cs_glob_lagr_time_scheme;

extern cs_lagr_model_t                    *cs_glob_lagr_model;

extern const cs_lagr_particle_counter_t   *cs_glob_lagr_particle_counter;
 
/* Lagrangian log output every frequency_n time steps */
 
extern int cs_glob_lagr_log_frequency_n;
 
/* Statisics on boundaries */
 
extern cs_real_t *bound_stat;
 
extern cs_lagr_specific_physics_t            *cs_glob_lagr_specific_physics;
extern cs_lagr_reentrained_model_t           *cs_glob_lagr_reentrained_model;
extern cs_lagr_precipitation_model_t         *cs_glob_lagr_precipitation_model;
extern cs_lagr_clogging_model_t              *cs_glob_lagr_clogging_model;
extern cs_lagr_shape_model_t                 *cs_glob_lagr_shape_model;
 
extern cs_lagr_agglomeration_model_t         *cs_glob_lagr_agglomeration_model;
extern cs_lagr_fragmentation_model_t         *cs_glob_lagr_fragmentation_model;
 
extern cs_lagr_consolidation_model_t         *cs_glob_lagr_consolidation_model;
extern cs_lagr_time_step_t                   *cs_glob_lagr_time_step;
extern cs_lagr_source_terms_t                *cs_glob_lagr_source_terms;
extern cs_lagr_encrustation_t                *cs_glob_lagr_encrustation;
extern cs_lagr_physico_chemical_t            *cs_glob_lagr_physico_chemical;
extern cs_lagr_brownian_t                    *cs_glob_lagr_brownian;
extern cs_lagr_boundary_interactions_t       *cs_glob_lagr_boundary_interactions;
 
extern cs_lagr_extra_module_t                *cs_glob_lagr_extra_module;
 
extern const cs_lagr_zone_data_t             *cs_glob_lagr_boundary_conditions;
extern const cs_lagr_zone_data_t             *cs_glob_lagr_volume_conditions;
extern cs_lagr_internal_condition_t          *cs_glob_lagr_internal_conditions;
 
/* Projection matrices for global to local coordinates on boundary faces */
extern cs_real_33_t  *cs_glob_lagr_b_face_proj;
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_map_specific_physics(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_lagr_injection_set_t *
cs_lagr_get_injection_set(cs_lagr_zone_data_t  *zone_data,
                          int                   zone_id,
                          int                   set_id);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_injection_set_default(cs_lagr_injection_set_t  *zis);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_lagr_particle_counter_t *
cs_lagr_get_particle_counter(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_lagr_particle_counter_t *
cs_lagr_update_particle_counter(void);
 
/*----------------------------------------------------------------------------
 * Provide access to cs_lagr_particle_counter_t
 *
 * needed to initialize structure with GUI
 *----------------------------------------------------------------------------*/
 
cs_lagr_specific_physics_t *
cs_get_lagr_specific_physics(void);
 
/*----------------------------------------------------------------------------
 * Provide access to cs_lagr_reentrained_model_t
 *
 * needed to initialize structure with GUI
 *----------------------------------------------------------------------------*/
 
cs_lagr_reentrained_model_t *
cs_get_lagr_reentrained_model(void);
 
/*----------------------------------------------------------------------------
 * Provide access to cs_lagr_precipitation_model_t
 *
 * needed to initialize structure with GUI
 *----------------------------------------------------------------------------*/
 
cs_lagr_precipitation_model_t *
cs_get_lagr_precipitation_model(void);
 
/*----------------------------------------------------------------------------
 * Provide access to cs_lagr_clogging_model_t
 *
 * needed to initialize structure with GUI
 *----------------------------------------------------------------------------*/
 
cs_lagr_clogging_model_t *
cs_get_lagr_clogging_model(void);
 
/*----------------------------------------------------------------------------
 * Provide access to cs_lagr_shape_model_t
 *
 * needed to initialize structure with GUI
 *----------------------------------------------------------------------------*/
 
cs_lagr_shape_model_t *
cs_get_lagr_shape_model(void);
 
/*----------------------------------------------------------------------------
 * Provide access to cs_lagr_agglomeration_model_t
 *
 * needed to initialize structure with GUI
 *----------------------------------------------------------------------------*/
 
cs_lagr_agglomeration_model_t *
cs_get_lagr_agglomeration_model(void);
 
/*----------------------------------------------------------------------------
 * Provide access to cs_lagr_consolidation_model_t
 *
 * needed to initialize structure with GUI
 *----------------------------------------------------------------------------*/
 
cs_lagr_consolidation_model_t *
cs_get_lagr_consolidation_model(void);
 
/*----------------------------------------------------------------------------
 * Provide access to cs_lagr_time_step_t
 *
 * needed to initialize structure with GUI
 *----------------------------------------------------------------------------*/
 
cs_lagr_time_step_t *
cs_get_lagr_time_step(void);
 
/*----------------------------------------------------------------------------
 * Provide access to cs_lagr_source_terms_t
 *
 * needed to initialize structure with GUI
 *----------------------------------------------------------------------------*/
 
cs_lagr_source_terms_t *
cs_get_lagr_source_terms(void);
 
/*----------------------------------------------------------------------------
 * Provide access to cs_lagr_encrustation_t
 *
 * needed to initialize structure with GUI
 *----------------------------------------------------------------------------*/
 
cs_lagr_encrustation_t *
cs_get_lagr_encrustation(void);
 
/*----------------------------------------------------------------------------
 * Provide access to cs_lagr_physico_chemical_t
 *
 * needed to initialize structure with GUI
 *----------------------------------------------------------------------------*/
 
cs_lagr_physico_chemical_t *
cs_get_lagr_physico_chemical(void);
 
/*----------------------------------------------------------------------------
 * Provide access to cs_lagr_brownian_t
 *
 * needed to initialize structure with GUI
 *----------------------------------------------------------------------------*/
 
cs_lagr_brownian_t *
cs_get_lagr_brownian(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_lagr_zone_data_t  *
cs_lagr_get_boundary_conditions(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_lagr_zone_data_t  *
cs_lagr_get_volume_conditions(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_lagr_internal_condition_t  *
cs_lagr_get_internal_conditions(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_finalize_zone_conditions(void);
 
/*----------------------------------------------------------------------------
 * Destroy finalize the global cs_lagr_internal_condition_t structure.
 *----------------------------------------------------------------------------*/
 
void
cs_lagr_finalize_internal_cond(void);
 
/*----------------------------------------------------------------------------
 * Provide access to cs_lagr_boundary_interactions_t
 *
 * needed to initialize structure with GUI
 *----------------------------------------------------------------------------*/
 
cs_lagr_boundary_interactions_t *
cs_get_lagr_boundary_interactions(void);
 
/*----------------------------------------------------------------------------
 * Provide access to cs_lagr_extra_module_t
 *----------------------------------------------------------------------------*/
 
cs_lagr_extra_module_t *
cs_get_lagr_extra_module(void);
 
/*----------------------------------------------------------------------------
 * Prepare for execution of the Lagrangian model.
 *
 * This should be called before the fist call to cs_lagr_solve_time_step.
 *
 *  parameters:
 *    dt     <-- time step (per cell)
 *----------------------------------------------------------------------------*/
 
void
cs_lagr_solve_initialize(const cs_real_t  *dt);
 
/*----------------------------------------------------------------------------
 * Initialize lagrangian arrays
 *----------------------------------------------------------------------------*/
 
void
cs_lagr_init_arrays(void);
 
/*----------------------------------------------------------------------------
 * Free lagrangian arrays
 *----------------------------------------------------------------------------*/
 
void
cs_lagr_finalize(void);
 
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_initialize_extra(cs_lnum_t n_continuous_phases);

/*----------------------------------------------------------------------------*/
 
void
cs_lagr_add_fields(void);
 
/*--------------------------------------------------------------------
 * Execute one time step of the Lagrangian model.
 *
 * This is the main function for that model.
 *
 *  parameters:
 *    itypfb <-- boundary face types
 *    dt     <-- time step (per cell)
 *-------------------------------------------------------------------- */
 
void
cs_lagr_solve_time_step(const int         itypfb[],
                        const cs_real_t  *dt);
 
/*----------------------------------------------------------------------------*/
 
END_C_DECLS
 
#endif /* __CS_LAGR_H__ */