cs_lagr_stat.h

Go to the documentation of this file.

#ifndef CS_LAGR_STAT_H
#define CS_LAGR_STAT_H
 
/*============================================================================
 * Functions and types for the Lagrangian module
 *============================================================================*/
 
/*
  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.
*/
 
/*----------------------------------------------------------------------------*/
 
#include "base/cs_defs.h"
 
#include "assert.h"
#include "base/cs_base.h"
#include "base/cs_field.h"
#include "base/cs_restart.h"
 
#include "lagr/cs_lagr.h"
#include "lagr/cs_lagr_event.h"
#include "lagr/cs_lagr_particle.h"
 
/*----------------------------------------------------------------------------*/
 
/*=============================================================================
 * Macro definitions
 *============================================================================*/
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
typedef enum {
 
  CS_LAGR_MOMENT_MEAN,
  CS_LAGR_MOMENT_VARIANCE
 
} cs_lagr_stat_moment_t;
 
typedef enum {
 
  CS_LAGR_STAT_GROUP_PARTICLE,
  CS_LAGR_STAT_GROUP_TRACKING_EVENT,
 
  CS_LAGR_STAT_GROUP_N_GROUPS
 
} cs_lagr_stat_group_t;
 
typedef enum {
 
  CS_LAGR_MOMENT_RESTART_RESET,
  CS_LAGR_MOMENT_RESTART_AUTO,
  CS_LAGR_MOMENT_RESTART_EXACT
 
} cs_lagr_stat_restart_t;
 
/* ----------------------------------------- */
 
typedef enum {
 
  /* Volume statistics */
 
  CS_LAGR_STAT_CUMULATIVE_WEIGHT,        
  CS_LAGR_STAT_VOLUME_FRACTION,          
  /* Boundary statistics */
 
  CS_LAGR_STAT_E_CUMULATIVE_WEIGHT,
 
  CS_LAGR_STAT_RESUSPENSION_CUMULATIVE_WEIGHT,
 
  CS_LAGR_STAT_FOULING_CUMULATIVE_WEIGHT,
 
  CS_LAGR_STAT_MASS_FLUX,                
  CS_LAGR_STAT_RESUSPENSION_MASS_FLUX,   
  CS_LAGR_STAT_FOULING_MASS_FLUX,        
  CS_LAGR_STAT_IMPACT_ANGLE,             
  CS_LAGR_STAT_IMPACT_VELOCITY,          
  CS_LAGR_STAT_FOULING_DIAMETER,         
  CS_LAGR_STAT_FOULING_COKE_FRACTION,    
  /* Particle or event-based attributes */
 
  CS_LAGR_STAT_ATTR                      
} cs_lagr_stat_type_t;
 
/*----------------------------------------------------------------------------
 * Function pointer for computation of particle data values for
 * Lagrangian statistics.
 *
 * Note: if the input pointer is non-null, it must point to valid data
 * when the selection function is called, so that value or structure should
 * not be temporary (i.e. local);
 *
 * parameters:
 *   input    <-- pointer to optional (untyped) value or structure.
 *   particle <-- pointer to particle data
 *   p_am     <-- pointer to particle attribute map
 *   vals     --> pointer to values
 *----------------------------------------------------------------------------*/
 
typedef void
(cs_lagr_moment_p_data_t) (const void                     *input,
                           const void                     *particle,
                           const cs_lagr_attribute_map_t  *p_am,
                           cs_real_t                       vals[]);
 
/*----------------------------------------------------------------------------
 * Function pointer for computation of event data values for
 * Lagrangian statistics.
 *
 * Note: if the input pointer is non-null, it must point to valid data
 * when the selection function is called, so that value or structure should
 * not be temporary (i.e. local);
 *
 * parameters:
 *   input     <-- pointer to optional (untyped) value or structure.
 *   events    <-- pointer to events
 *   event_id  <-- event id range (first to past-last)
 *   vals      --> pointer to values
 *----------------------------------------------------------------------------*/
 
typedef void
(cs_lagr_moment_e_data_t) (const void                 *input,
                           const cs_lagr_event_set_t  *events,
                           cs_lnum_t                   id_range[2],
                           cs_real_t                   vals[]);
 
/*----------------------------------------------------------------------------
 * Function pointer for computation of data values for particle statistics
 * based on mesh
 *
 * If the matching values are multidimensional, they must be interleaved.
 *
 * Note: if the input pointer is non-null, it must point to valid data
 * when the selection function is called, so that value or structure should
 * not be temporary (i.e. local);
 *
 * parameters:
 *   input       <-- pointer to optional value or structure, or NULL
 *   events      <-- pointer to optional events set, or NULL.
 *   location_id <-- associated mesh location id
 *   class_id    <-- associated particle class id (0 for all)
 *   vals        --> pointer to values (size: n_local elements*dimension)
 *----------------------------------------------------------------------------*/
 
typedef void
(cs_lagr_moment_m_data_t) (const void                 *input,
                           const cs_lagr_event_set_t  *events,
                           int                         location_id,
                           int                         class_id,
                           cs_real_t                   vals[]);
 
typedef struct {
 
  int  isuist;
 
  int  idstnt;
 
  int  nstist;
 
  cs_real_t  threshold;
 
} cs_lagr_stat_options_t;
 
/*============================================================================
 * Global variables
 *============================================================================*/
 
/* Pointer to global statistic options structure */
 
extern cs_lagr_stat_options_t   *cs_glob_lagr_stat_options;
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_lagr_stat_particle_define(const char                *name,
                             int                        location_id,
                             int                        stat_type,
                             cs_lagr_stat_moment_t      m_type,
                             int                        class_id,
                             int                        dim,
                             int                        component_id,
                             cs_lagr_moment_p_data_t   *data_func,
                             void                      *data_input,
                             cs_lagr_moment_p_data_t   *w_data_func,
                             void                      *w_data_input,
                             int                        nt_start,
                             double                     t_start,
                             cs_lagr_stat_restart_t     restart_mode);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_lagr_stat_event_define(const char                *name,
                          int                        location_id,
                          int                        stat_type,
                          cs_lagr_stat_group_t       stat_group,
                          cs_lagr_stat_moment_t      m_type,
                          int                        class_id,
                          int                        dim,
                          int                        component_id,
                          cs_lagr_moment_e_data_t   *data_func,
                          void                      *data_input,
                          cs_lagr_moment_e_data_t   *w_data_func,
                          void                      *w_data_input,
                          int                        nt_start,
                          double                     t_start,
                          cs_lagr_stat_restart_t     restart_mode);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_lagr_stat_accumulator_define(const char                *name,
                                int                        location_id,
                                cs_lagr_stat_group_t       stat_group,
                                int                        class_id,
                                cs_lagr_moment_p_data_t   *p_data_func,
                                cs_lagr_moment_e_data_t   *e_data_func,
                                void                      *data_input,
                                int                        nt_start,
                                double                     t_start,
                                cs_lagr_stat_restart_t     restart_mode);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_lagr_stat_mesh_define(const char                *name,
                         int                        location_id,
                         cs_lagr_stat_group_t       stat_group,
                         int                        class_id,
                         int                        dim,
                         cs_lagr_moment_m_data_t   *data_func,
                         void                      *data_input,
                         int                        nt_start,
                         double                     t_start);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_lagr_stat_time_moment_define(const char                *name,
                                int                        location_id,
                                int                        stat_type,
                                cs_lagr_stat_moment_t      m_type,
                                int                        class_id,
                                int                        dim,
                                int                        component_id,
                                cs_lagr_moment_m_data_t   *data_func,
                                void                      *data_input,
                                int                        nt_start,
                                double                     t_start,
                                cs_lagr_stat_restart_t     restart_mode);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_activate(int  stat_type);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_activate_time_moment(int                    stat_type,
                                  cs_lagr_stat_moment_t  moment);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_deactivate(int  stat_type);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_activate_attr(int  attr_id);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_deactivate_attr(int  attr_id);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
int
cs_lagr_stat_type_from_attr_id(int attr_id);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
int
cs_lagr_stat_type_to_attr_id(int  stat_type);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_lagr_stat_type_by_name(const char  *name);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_map_cell_dt(const cs_real_t  *dt);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_initialize(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
bool
cs_lagr_stat_is_active( cs_lagr_stat_group_t   group);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_restart_read(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_prepare(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(__cplusplus)
void
cs_lagr_stat_update_all_incr(cs_lagr_particle_set_t &p_set,
                             const cs_lnum_t         p_id,
                             const cs_real_t         rel_time);
#endif /* __cplusplus */
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_update(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_update_event(cs_lagr_event_set_t   *events,
                          cs_lagr_stat_group_t   group);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_finalize(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_log_setup(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_log_iteration(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_stat_restart_write(cs_restart_t  *restart);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_field_t *
cs_lagr_stat_get_moment(int                    stat_type,
                        cs_lagr_stat_group_t   stat_group,
                        cs_lagr_stat_moment_t  m_type,
                        int                    class_id,
                        int                    component_id);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_field_t *
cs_lagr_stat_get_stat_weight(int  class_id);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_real_t
cs_lagr_stat_get_age(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_real_t
cs_lagr_stat_get_moment_age(cs_field_t  *f);
 
/*----------------------------------------------------------------------------*/
 
#endif /* CS_LAGR_STAT_H */