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-2019 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 "cs_defs.h"
 
/*----------------------------------------------------------------------------
 * Standard C library headers
 *----------------------------------------------------------------------------*/
 
#include "assert.h"
 
/*----------------------------------------------------------------------------
 *  Local headers
 *----------------------------------------------------------------------------*/
 
#include "cs_base.h"
#include "cs_field.h"
 
#include "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_t;
 
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 struct {
 
  int nusbrd;  
  int ndlaim;  
  int ncharm2; 
  int nlayer;  
} cs_lagr_const_dim_t;
 
/*---------------------*/
 
typedef struct {
 
  int   ntersl;  
  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 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     modcpl;
 
  int     idirla;
 
  int     idistu;
 
  int     idiffl;
 
  int     ilapoi;
 
  int     iadded_mass;
 
  cs_real_t        added_mass_const;
 
} cs_lagr_time_scheme_t;
 
/*-----------------------------------------------------------*/
 
typedef struct {
 
  int  physical_model;  /* FIXME: => enum: CS_LAGR_PHYS_STD,
                                           CS_LAGR_PHYS_COAL,
                                           CS_LAGR_PHYS_HEAT... */
  int  n_temperature_layers;
 
  int  deposition;
  int  dlvo;
 
  int  roughness;
 
  int  resuspension;
 
  /* - 0: no clogging model
     - 1: clogging model */
  int  clogging;
 
  /* - 0: no consolidation model
     - 1: consolidation model */
  int  consolidation;
 
  int  precipitation;
  int  fouling;
 
  int agglomeration;
 
  int fragmentation;
 
  int  n_stat_classes;
 
  int n_particle_aggregates;
 
  int  n_user_variables;
 
} 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 (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          scalar_kernel;
  cs_real_t          base_diameter;
  cs_real_t          (*function_kernel)(cs_lnum_t, cs_lnum_t);
 
} 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         particle_aggregate;
 
  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   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  itsli;
 
  /*  explicit source term for the turbulent dissipation and the
   turbulent energy if the \f$k-\varepsilon\f$ turbulence model is used
   for the continuous phase */
  int  itske;
 
  int  itste;
 
  int  itsti;
 
  int  itsmas;
 
  /*  source term for the light volatile matters */
  int  *itsmv1;  //ncharm2
 
  /*  source term for the heavy volatile matters */
  int  *itsmv2;  //ncharm2
 
  int  itsco;
 
  int  itsfp4;
 
  int  nstits;
 
  int  npts;
 
  int  ntxerr;
 
  cs_real_t      vmax;
 
  cs_real_t      tmamax;
 
  cs_real_t     *st_val;
 
} 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 {
 
  /* Turbulence model */
  int iturb;
  int itytur;
 
  /* cpincl */
  int ncharb;
 
  /* ppppar */
  int ncharm;
 
  /* radiation */
  int radiative_model;
 
  /* icp */
  int icp;
 
  /* diftl0 */
  cs_real_t diftl0;
 
  /* cmu */
  cs_real_t cmu;
 
  /* visls0 */
  cs_real_t visls0;
 
  /* Referenced fields
     ----------------- */
 
  /* wall ustar */
  cs_field_t *ustar;
 
  /* Fluid density */
  cs_field_t *cromf;
 
  /* Fluid pressure */
  cs_field_t *pressure;
 
  /* Fluid temparature */
  cs_field_t *scal_t;
  cs_field_t *temperature;
  cs_field_t *t_gaz;
 
  /* 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;
 
  /* Radiat.       */
  cs_field_t *luminance;
 
  /* Combustion    */
  cs_field_t *x_oxyd;
  cs_field_t *x_eau;
  cs_field_t *x_m;
 
  /* Turbulence */
  /* Turbulent intensity */
  cs_field_t *cvar_k;
 
  /* Turbulent dissipation */
  cs_field_t *cvar_ep;
 
  /* Omega from k-omega SST model*/
  cs_field_t *cvar_omg;
 
  /* Reynolds stress component Rxx */
  cs_field_t *cvar_r11;
  /* Reynolds stress component Ryy */
  cs_field_t *cvar_r22;
  /* Reynolds stress component Rzz */
  cs_field_t *cvar_r33;
 
  /* Reynolds Stress Tensor */
  cs_field_t *cvar_rij;
 
  /* Total pressure gradient */
  cs_real_3_t *grad_pr;
 
  /* velocity gradient */
  cs_real_33_t *grad_vel;
 
} cs_lagr_extra_module_t;
 
/*--------------------------------------------*/
 
typedef struct {
 
  int         ih2o;   // cpincl
  int         io2;    // cpincl
  int         ico;    // cpincl
 
  int         iatc;   // ppthch
  cs_real_t   prefth; // ppthch
  cs_real_t   trefth; // ppthch
 
  int         natom;  // = 5;
  cs_real_t  *wmolat; // dim = natom
 
  int         ngazem; // = 20;
  cs_real_t  *wmole;  // ngazem
  int        *iym1;
 
  int         ncharm;  // cpincl
  cs_real_t  *a1ch;   // ncharm
  cs_real_t  *h02ch;
  cs_real_t  *e1ch;   //
  cs_real_t  *a2ch;   //
  cs_real_t  *e2ch;   //
  cs_real_t  *y1ch;   //
  cs_real_t  *y2ch;   //
  cs_real_t  *cp2ch;  //
  cs_real_t  *ahetch; //
  cs_real_t  *ehetch; //
  cs_real_t  *rho0ch; //
  cs_real_t  *xwatch; //
  cs_real_t  *xashch; //
  cs_real_t  *thcdch; //
 
} cs_lagr_coal_comb_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_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 cs_lagr_coal_comb_t                   *cs_glob_lagr_coal_comb;
 
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
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
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_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);
 
/*--------------------------------------------------------------------
 * 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);
 
/*----------------------------------------------------------------------------
 * Return pointers to lagrangian arrays
 *
 * This function is intended for use by Fortran wrappers.
 *
 * parameters:
 *   dim_bound_stat   --> dimensions for bound_stat pointer
 *   p_bound_stat     --> bound_stat pointer
 *----------------------------------------------------------------------------*/
 
void
cs_lagr_init_c_arrays(int          dim_cs_glob_lagr_source_terms[2],
                      cs_real_t  **p_cs_glob_lagr_source_terms);
 
/*----------------------------------------------------------------------------
 * Free lagrangian arrays
 *
 * This function is intended for use by Fortran wrappers.
 *----------------------------------------------------------------------------*/
 
void
cs_lagr_finalize(void);
 
/*----------------------------------------------------------------------------*/
 
END_C_DECLS
 
#endif /* __CS_LAGR_H__ */