cs_lagr_particle.h

Go to the documentation of this file.

#ifndef __CS_LAGR_PARTICLE_H__
#define __CS_LAGR_PARTICLE_H__
 
/*============================================================================
 * Lagrangian module particle model
 *============================================================================*/
 
/*
  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"
 
#include "assert.h"
#include "string.h"
 
/*----------------------------------------------------------------------------*/
 
BEGIN_C_DECLS
 
/*=============================================================================
 * Macro definitions
 *============================================================================*/
 
/*=============================================================================
 * Macro definitions
 *============================================================================*/
 
#define CS_LAGR_PART_TO_DELETE         (1 << 0)
 
#define CS_LAGR_PART_FIXED             (1 << 1)
 
#define CS_LAGR_PART_DEPOSITED         (1 << 2)
 
#define CS_LAGR_PART_ROLLING           (1 << 3)
 
#define CS_LAGR_PART_IMPOSED_MOTION    (1 << 4)
 
#define CS_LAGR_PART_DEPOSITION_FLAGS \
  (  CS_LAGR_PART_TO_DELETE | CS_LAGR_PART_FIXED | CS_LAGR_PART_DEPOSITED \
   | CS_LAGR_PART_ROLLING | CS_LAGR_PART_IMPOSED_MOTION)
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
/* ------------------------------- */
 
typedef enum {
 
  CS_LAGR_P_FLAG,             
  CS_LAGR_CELL_ID,             
  CS_LAGR_RANK_ID,             
  CS_LAGR_REBOUND_ID,          
  CS_LAGR_RANDOM_VALUE,        
  CS_LAGR_STAT_WEIGHT,         
  CS_LAGR_RESIDENCE_TIME,      
  CS_LAGR_MASS,
  CS_LAGR_DIAMETER,
  CS_LAGR_TAUP_AUX,
  CS_LAGR_COORDS,
  CS_LAGR_VELOCITY,
  CS_LAGR_VELOCITY_SEEN,
  CS_LAGR_VELOCITY_SEEN_VELOCITY_COV, 
  CS_LAGR_TR_TRUNCATE,         
  CS_LAGR_TR_REPOSITION,       
  /* Arrays for 2nd order scheme */
 
  CS_LAGR_TURB_STATE_1,        /* turbulence characteristics of first pass */
  CS_LAGR_BROWN_STATE_1,       /* Brownian characteristics of first pass */
  CS_LAGR_PRED_VELOCITY,       /* 1st step prediction for particle velocity */
  CS_LAGR_PRED_VELOCITY_SEEN,  /* 1st step prediction for relative velocity */
  CS_LAGR_V_GAUSS,             /* 1st step Gaussian variable */
  CS_LAGR_BR_GAUSS,            /* 1st step Brownian motion Gaussian variable */
 
  /* Non-spherical particles submodel additoinal parameters */
 
  CS_LAGR_SHAPE,               
  CS_LAGR_ORIENTATION,         
  CS_LAGR_QUATERNION,          
  CS_LAGR_RADII,               
  CS_LAGR_ANGULAR_VEL,         
  CS_LAGR_EULER,               
  CS_LAGR_SHAPE_PARAM,         
  /* Deposition submodel additional parameters */
 
  CS_LAGR_YPLUS,
  CS_LAGR_INTERF,
  CS_LAGR_NEIGHBOR_FACE_ID,
  CS_LAGR_MARKO_VALUE,
  CS_LAGR_FOULING_INDEX,
 
  /* Resuspension model additional parameters */
 
  CS_LAGR_N_LARGE_ASPERITIES,
  CS_LAGR_N_SMALL_ASPERITIES,
  CS_LAGR_ADHESION_FORCE,
  CS_LAGR_ADHESION_TORQUE,
  CS_LAGR_DISPLACEMENT_NORM,
 
  /* Clogging model additional parameters */
 
  CS_LAGR_HEIGHT,
  CS_LAGR_CLUSTER_NB_PART,
  CS_LAGR_DEPO_TIME,
  CS_LAGR_CONSOL_HEIGHT,
 
  /* Thermal model additional parameters */
 
  CS_LAGR_TEMPERATURE,
  CS_LAGR_TEMPERATURE_SEEN,
  CS_LAGR_CP,
 
  /* Coal combustion additional parameters */
 
  CS_LAGR_WATER_MASS,
  CS_LAGR_COAL_MASS,
  CS_LAGR_COKE_MASS,
 
  CS_LAGR_SHRINKING_DIAMETER,
  CS_LAGR_INITIAL_DIAMETER,
 
  CS_LAGR_COAL_ID,
  CS_LAGR_COAL_DENSITY,
 
  /* Radiative model additional parameters */
 
  CS_LAGR_EMISSIVITY,
 
  /* Statistical class */
 
  CS_LAGR_STAT_CLASS,
 
  /* Agglomeration/fragmentation model parameters */
  CS_LAGR_AGGLO_CLASS_ID,
  CS_LAGR_AGGLO_FRACTAL_DIM,
 
  CS_LAGR_REMAINING_INTEG_TIME,
  /* User attributes */
 
  CS_LAGR_USER,
 
  /* End of attributes */
 
  CS_LAGR_N_ATTRIBUTES
 
} cs_lagr_attribute_t;
 
/* ------------------------------------- */
 
typedef struct {
 
  size_t          extents;                         /* size (in bytes) of particle
                                                      structure */
  size_t          lb;                              /* size (in bytes) of lower
                                                      bounds of particle data
                                                      (work area before) */
 
  int             n_time_vals;                     /* number of time values
                                                      handled */
 
  size_t          size[CS_LAGR_N_ATTRIBUTES];      /* size (in bytes) of
                                                      attributes in particle
                                                      structure for a given
                                                      time value */
  cs_datatype_t   datatype[CS_LAGR_N_ATTRIBUTES];  /* datatype of associated
                                                      attributes */
  int            (*count)[CS_LAGR_N_ATTRIBUTES];   /* number of values for each
                                                      attribute, per associated
                                                      time_id */
  ptrdiff_t      (*displ)[CS_LAGR_N_ATTRIBUTES];   /* displacement (in bytes) of
                                                      attributes in particle data,
                                                      per associated time_id*/
 
  ptrdiff_t      *source_term_displ;               /* displacement (in bytes) of
                                                      source term values
                                                      for second-order scheme,
                                                      or NULL */
 
} cs_lagr_attribute_map_t;
 
/* Particle set */
/* ------------ */
 
typedef struct {
 
  cs_lnum_t  n_particles;                     /* number of particle in domain */
  cs_lnum_t  n_part_new;
  cs_lnum_t  n_part_out;
  cs_lnum_t  n_part_merged;                   /* number of merged particles */
  cs_lnum_t  n_part_dep;
  cs_lnum_t  n_part_fou;
  cs_lnum_t  n_part_resusp;
  cs_lnum_t  n_failed_part;
 
  cs_real_t  weight;
  cs_real_t  weight_new;
  cs_real_t  weight_out;
  cs_real_t  weight_merged;
  cs_real_t  weight_dep;
  cs_real_t  weight_fou;
  cs_real_t  weight_resusp;
  cs_real_t  weight_failed;
 
  cs_lnum_t  n_particles_max;
 
  const cs_lagr_attribute_map_t  *p_am;       
  unsigned char                  *p_buffer;   
} cs_lagr_particle_set_t;
 
/*=============================================================================
 * Global variables
 *============================================================================*/
 
extern const char *cs_lagr_attribute_name[];
 
extern cs_lagr_particle_set_t  *cs_glob_lagr_particle_set;
 
/*============================================================================
 * Public function prototypes for Fortran API
 *============================================================================*/
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_particle_attr_initialize(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const cs_lagr_attribute_map_t *
cs_lagr_particle_get_attr_map(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_particle_set_create(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_particle_finalize(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_part_copy(cs_lnum_t  dest,
                  cs_lnum_t  src);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_get_attr_info(const cs_lagr_particle_set_t  *particles,
                      int                            time_id,
                      cs_lagr_attribute_t            attr,
                      size_t                        *extents,
                      size_t                        *size,
                      ptrdiff_t                     *displ,
                      cs_datatype_t                 *datatype,
                      int                           *count);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_lagr_check_attr_query(const cs_lagr_particle_set_t  *particles,
                         cs_lagr_attribute_t            attr,
                         cs_datatype_t                  datatype,
                         int                            stride,
                         int                            component_id);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_particle_attr_in_range(int  attr);
 
/*----------------------------------------------------------------------------
 * Return pointer to the main cs_lagr_particle_set_t structure.
 *
 * returns:
 *   pointer to current particle set, or NULL
 *----------------------------------------------------------------------------*/
 
cs_lagr_particle_set_t  *
cs_lagr_get_particle_set(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static void *
cs_lagr_particles_attr(cs_lagr_particle_set_t  *particle_set,
                       cs_lnum_t                particle_id,
                       cs_lagr_attribute_t      attr)
{
  assert(particle_set->p_am->count[0][attr] > 0);
 
  return   (unsigned char *)particle_set->p_buffer
         + particle_set->p_am->extents*particle_id
         + particle_set->p_am->displ[0][attr];
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static const void *
cs_lagr_particles_attr_const(const cs_lagr_particle_set_t  *particle_set,
                             cs_lnum_t                      particle_id,
                             cs_lagr_attribute_t            attr)
{
  assert(particle_set->p_am->count[0][attr] > 0);
 
  return   particle_set->p_buffer
         + particle_set->p_am->extents*particle_id
         + particle_set->p_am->displ[0][attr];
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static void *
cs_lagr_particles_attr_n(cs_lagr_particle_set_t  *particle_set,
                         cs_lnum_t                particle_id,
                         int                      time_id,
                         cs_lagr_attribute_t      attr)
{
  assert(particle_set->p_am->count[time_id][attr] > 0);
 
  return   particle_set->p_buffer
         + particle_set->p_am->extents*particle_id
         + particle_set->p_am->displ[time_id][attr];
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static const void *
cs_lagr_particles_attr_n_const(const cs_lagr_particle_set_t  *particle_set,
                               cs_lnum_t                      particle_id,
                               int                            time_id,
                               cs_lagr_attribute_t            attr)
{
  assert(particle_set->p_am->count[time_id][attr] > 0);
 
  return   particle_set->p_buffer
         + particle_set->p_am->extents*particle_id
         + particle_set->p_am->displ[time_id][attr];
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static int
cs_lagr_particles_get_flag(const cs_lagr_particle_set_t  *particle_set,
                           cs_lnum_t                      particle_id,
                           int                            mask)
{
  int flag
    = *((const cs_lnum_t *)(  particle_set->p_buffer
                            + particle_set->p_am->extents*particle_id
                            + particle_set->p_am->displ[0][CS_LAGR_P_FLAG]));
 
  return (flag & mask);
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particles_set_flag(const cs_lagr_particle_set_t  *particle_set,
                           cs_lnum_t                      particle_id,
                           int                            mask)
{
  int flag
    = *((const cs_lnum_t *)(  particle_set->p_buffer
                            + particle_set->p_am->extents*particle_id
                            + particle_set->p_am->displ[0][CS_LAGR_P_FLAG]));
 
  flag = flag | mask;
 
  *((cs_lnum_t *)(  particle_set->p_buffer
                  + particle_set->p_am->extents*particle_id
                  + particle_set->p_am->displ[0][CS_LAGR_P_FLAG])) = flag;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particles_unset_flag(const cs_lagr_particle_set_t  *particle_set,
                             cs_lnum_t                      particle_id,
                             int                            mask)
{
  int flag
    = *((const cs_lnum_t *)(  particle_set->p_buffer
                            + particle_set->p_am->extents*particle_id
                            + particle_set->p_am->displ[0][CS_LAGR_P_FLAG]));
 
  flag = (flag | mask) - mask;
 
  *((cs_lnum_t *)(  particle_set->p_buffer
                  + particle_set->p_am->extents*particle_id
                  + particle_set->p_am->displ[0][CS_LAGR_P_FLAG])) = flag;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static cs_lnum_t
cs_lagr_particles_get_lnum(const cs_lagr_particle_set_t  *particle_set,
                           cs_lnum_t                      particle_id,
                           cs_lagr_attribute_t            attr)
{
  assert(particle_set->p_am->count[0][attr] > 0);
 
  return *((const cs_lnum_t *)(  particle_set->p_buffer
                               + particle_set->p_am->extents*particle_id
                               + particle_set->p_am->displ[0][attr]));
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static cs_lnum_t
cs_lagr_particles_get_lnum_n(const cs_lagr_particle_set_t  *particle_set,
                             cs_lnum_t                      particle_id,
                             int                            time_id,
                             cs_lagr_attribute_t            attr)
{
  assert(particle_set->p_am->count[time_id][attr] > 0);
 
  return *((const cs_lnum_t *)(  particle_set->p_buffer
                               + particle_set->p_am->extents*particle_id
                               + particle_set->p_am->displ[time_id][attr]));
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particles_set_lnum(cs_lagr_particle_set_t  *particle_set,
                           cs_lnum_t                particle_id,
                           cs_lagr_attribute_t      attr,
                           cs_lnum_t                value)
{
  assert(particle_set->p_am->count[0][attr] > 0);
 
  *((cs_lnum_t *)(  particle_set->p_buffer
                  + particle_set->p_am->extents*particle_id
                  + particle_set->p_am->displ[0][attr])) = value;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particles_set_lnum_n(cs_lagr_particle_set_t  *particle_set,
                             cs_lnum_t                particle_id,
                             int                      time_id,
                             cs_lagr_attribute_t      attr,
                             cs_lnum_t                value)
{
  assert(particle_set->p_am->count[time_id][attr] > 0);
 
  *((cs_lnum_t *)(  particle_set->p_buffer
                  + particle_set->p_am->extents*particle_id
                  + particle_set->p_am->displ[time_id][attr])) = value;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static cs_gnum_t
cs_lagr_particles_get_gnum(const cs_lagr_particle_set_t  *particle_set,
                           cs_lnum_t                      particle_id,
                           cs_lagr_attribute_t            attr)
{
  assert(particle_set->p_am->count[0][attr] > 0);
 
  return *((const cs_gnum_t *)(  particle_set->p_buffer
                               + particle_set->p_am->extents*particle_id
                               + particle_set->p_am->displ[0][attr]));
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static cs_gnum_t
cs_lagr_particles_get_gnum_n(const cs_lagr_particle_set_t  *particle_set,
                             cs_lnum_t                      particle_id,
                             int                            time_id,
                             cs_lagr_attribute_t            attr)
{
  assert(particle_set->p_am->count[time_id][attr] > 0);
 
  return *((const cs_gnum_t *)(  particle_set->p_buffer
                               + particle_set->p_am->extents*particle_id
                               + particle_set->p_am->displ[time_id][attr]));
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particles_set_gnum(cs_lagr_particle_set_t  *particle_set,
                           cs_lnum_t                particle_id,
                           cs_lagr_attribute_t      attr,
                           cs_gnum_t                value)
{
  assert(particle_set->p_am->count[0][attr] > 0);
 
  *((cs_gnum_t *)(  particle_set->p_buffer
                  + particle_set->p_am->extents*particle_id
                  + particle_set->p_am->displ[0][attr])) = value;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particles_set_gnum_n(cs_lagr_particle_set_t  *particle_set,
                             cs_lnum_t                particle_id,
                             int                      time_id,
                             cs_lagr_attribute_t      attr,
                             cs_gnum_t                value)
{
  assert(particle_set->p_am->count[time_id][attr] > 0);
 
  *((cs_gnum_t *)(  particle_set->p_buffer
                  + particle_set->p_am->extents*particle_id
                  + particle_set->p_am->displ[time_id][attr])) = value;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static cs_real_t
cs_lagr_particles_get_real(const cs_lagr_particle_set_t  *particle_set,
                           cs_lnum_t                      particle_id,
                           cs_lagr_attribute_t            attr)
{
  assert(particle_set->p_am->count[0][attr] > 0);
 
  return *((const cs_real_t *)(  particle_set->p_buffer
                               + particle_set->p_am->extents*particle_id
                               + particle_set->p_am->displ[0][attr]));
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static cs_real_t
cs_lagr_particles_get_real_n(const cs_lagr_particle_set_t  *particle_set,
                             cs_lnum_t                      particle_id,
                             int                            time_id,
                             cs_lagr_attribute_t            attr)
{
  assert(particle_set->p_am->count[time_id][attr] > 0);
 
  return *((const cs_real_t *)(  particle_set->p_buffer
                               + particle_set->p_am->extents*particle_id
                               + particle_set->p_am->displ[time_id][attr]));
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particles_set_real(cs_lagr_particle_set_t  *particle_set,
                           cs_lnum_t                particle_id,
                           cs_lagr_attribute_t      attr,
                           cs_real_t                value)
{
  assert(particle_set->p_am->count[0][attr] > 0);
 
  *((cs_real_t *)(  particle_set->p_buffer
                  + particle_set->p_am->extents*particle_id
                  + particle_set->p_am->displ[0][attr])) = value;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particles_set_real_n(cs_lagr_particle_set_t  *particle_set,
                             cs_lnum_t                particle_id,
                             int                      time_id,
                             cs_lagr_attribute_t      attr,
                             cs_real_t                value)
{
  assert(particle_set->p_am->count[time_id][attr] > 0);
 
  *((cs_real_t *)(  particle_set->p_buffer
                  + particle_set->p_am->extents*particle_id
                  + particle_set->p_am->displ[time_id][attr])) = value;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particles_attributes_fill_zero(cs_lagr_particle_set_t  *p_set,
                                       cs_lnum_t                p_id)
{
  memset(p_set->p_buffer + p_set->p_am->extents * p_id,
         0,
         p_set->p_am->extents);
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static cs_real_t *
cs_lagr_particles_source_terms(cs_lagr_particle_set_t  *particle_set,
                               cs_lnum_t                particle_id,
                               cs_lagr_attribute_t      attr)
{
  assert(particle_set->p_am->source_term_displ != NULL);
  assert(particle_set->p_am->source_term_displ[attr] >= 0);
 
  return (cs_real_t *)(  (unsigned char *)particle_set->p_buffer
                       + particle_set->p_am->extents*particle_id
                       + particle_set->p_am->source_term_displ[attr]);
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static const cs_real_t *
cs_lagr_particles_source_terms_const(cs_lagr_particle_set_t  *particle_set,
                                     cs_lnum_t                particle_id,
                                     cs_lagr_attribute_t      attr)
{
  assert(particle_set->p_am->source_term_displ != NULL);
  assert(particle_set->p_am->source_term_displ[attr] >= 0);
 
  return (const cs_real_t *)(  (unsigned char *)particle_set->p_buffer
                             + particle_set->p_am->extents*particle_id
                             + particle_set->p_am->source_term_displ[attr]);
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static void *
cs_lagr_particle_attr(void                           *particle,
                      const cs_lagr_attribute_map_t  *attr_map,
                      cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[0][attr] > 0);
 
  return  (unsigned char *)particle + attr_map->displ[0][attr];
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static const void *
cs_lagr_particle_attr_const(const void                     *particle,
                            const cs_lagr_attribute_map_t  *attr_map,
                            cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[0][attr] > 0);
 
  return  (const unsigned char *)particle + attr_map->displ[0][attr];
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static void *
cs_lagr_particle_attr_n(void                           *particle,
                        const cs_lagr_attribute_map_t  *attr_map,
                        int                             time_id,
                        cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[time_id][attr] > 0);
 
  return  (unsigned char *)particle + attr_map->displ[time_id][attr];
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static const void *
cs_lagr_particle_attr_n_const(const void                     *particle,
                              const cs_lagr_attribute_map_t  *attr_map,
                              int                             time_id,
                              cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[time_id][attr] > 0);
 
  return    (const unsigned char *)particle
          + attr_map->displ[time_id][attr];
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static cs_lnum_t
cs_lagr_particle_get_lnum(const void                     *particle,
                          const cs_lagr_attribute_map_t  *attr_map,
                          cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[0][attr] > 0);
 
  return  *((const cs_lnum_t *)(  (const unsigned char *)particle
                                + attr_map->displ[0][attr]));
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static cs_lnum_t
cs_lagr_particle_get_lnum_n(const void                     *particle,
                            const cs_lagr_attribute_map_t  *attr_map,
                            int                             time_id,
                            cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[time_id][attr] > 0);
 
  return  *((const cs_lnum_t *)(  (const unsigned char *)particle
                                + attr_map->displ[time_id][attr]));
}
 
/*----------------------------------------------------------------------------*/
 /*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particle_set_lnum(void                           *particle,
                          const cs_lagr_attribute_map_t  *attr_map,
                          cs_lagr_attribute_t             attr,
                          cs_lnum_t                       value)
{
  assert(attr_map->count[0][attr] > 0);
 
  *((cs_lnum_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
    = value;
}
 
/*----------------------------------------------------------------------------*/
 /*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particle_set_lnum_n(void                           *particle,
                            const cs_lagr_attribute_map_t  *attr_map,
                            int                             time_id,
                            cs_lagr_attribute_t             attr,
                            cs_lnum_t                       value)
{
  assert(attr_map->count[time_id][attr] > 0);
 
  *((cs_lnum_t *)(  (unsigned char *)particle
                  + attr_map->displ[time_id][attr])) = value;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static cs_gnum_t
cs_lagr_particle_get_gnum(const void                     *particle,
                          const cs_lagr_attribute_map_t  *attr_map,
                          cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[0][attr] > 0);
 
  return  *((const cs_gnum_t *)(  (const unsigned char *)particle
                                + attr_map->displ[0][attr]));
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static cs_gnum_t
cs_lagr_particle_get_gnum_n(const void                     *particle,
                            const cs_lagr_attribute_map_t  *attr_map,
                            int                             time_id,
                            cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[time_id][attr] > 0);
 
  return  *((const cs_gnum_t *)(  (const unsigned char *)particle
                                + attr_map->displ[time_id][attr]));
}
 
/*----------------------------------------------------------------------------*/
 /*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particle_set_gnum(void                           *particle,
                          const cs_lagr_attribute_map_t  *attr_map,
                          cs_lagr_attribute_t             attr,
                          cs_gnum_t                       value)
{
  assert(attr_map->count[0][attr] > 0);
 
  *((cs_gnum_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
    = value;
}
 
/*----------------------------------------------------------------------------*/
 /*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particle_set_gnum_n(void                           *particle,
                            const cs_lagr_attribute_map_t  *attr_map,
                            int                             time_id,
                            cs_lagr_attribute_t             attr,
                            cs_gnum_t                       value)
{
  assert(attr_map->count[time_id][attr] > 0);
 
  *((cs_gnum_t *)(  (unsigned char *)particle
                  + attr_map->displ[time_id][attr])) = value;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static cs_real_t
cs_lagr_particle_get_real(const void                     *particle,
                          const cs_lagr_attribute_map_t  *attr_map,
                          cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[0][attr] > 0);
 
  return  *((const cs_real_t *)(  (const unsigned char *)particle
                                + attr_map->displ[0][attr]));
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static cs_real_t
cs_lagr_particle_get_real_n(const void                     *particle,
                            const cs_lagr_attribute_map_t  *attr_map,
                            int                             time_id,
                            cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[time_id][attr] > 0);
 
  return  *((const cs_real_t *)(  (const unsigned char *)particle
                                + attr_map->displ[time_id][attr]));
}
 
/*----------------------------------------------------------------------------*/
 /*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particle_set_real(void                           *particle,
                          const cs_lagr_attribute_map_t  *attr_map,
                          cs_lagr_attribute_t             attr,
                          cs_real_t                       value)
{
  assert(attr_map->count[0][attr] > 0);
 
  *((cs_real_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
    = value;
}
 
/*----------------------------------------------------------------------------*/
 /*----------------------------------------------------------------------------*/
 
inline static void
cs_lagr_particle_set_real_n(void                           *particle,
                            const cs_lagr_attribute_map_t  *attr_map,
                            int                             time_id,
                            cs_lagr_attribute_t             attr,
                            cs_real_t                       value)
{
  assert(attr_map->count[time_id][attr] > 0);
 
  *((cs_real_t *)(  (unsigned char *)particle
                  + attr_map->displ[time_id][attr])) = value;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static cs_real_t *
cs_lagr_particle_source_term(void                           *particle,
                             const cs_lagr_attribute_map_t  *attr_map,
                             cs_lagr_attribute_t             attr)
{
  assert(attr_map->source_term_displ != NULL);
  assert(attr_map->source_term_displ[attr] >= 0);
 
  return  (cs_real_t *)(  (unsigned char *)particle
                        + attr_map->source_term_displ[attr]);
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static const cs_real_t *
cs_lagr_particle_source_term_const(void                           *particle,
                                   const cs_lagr_attribute_map_t  *attr_map,
                                   cs_lagr_attribute_t             attr)
{
  assert(attr_map->source_term_displ != NULL);
  assert(attr_map->source_term_displ[attr] >= 0);
 
  return  (const cs_real_t *)(  (unsigned char *)particle
                              + attr_map->source_term_displ[attr]);
}
 
/*----------------------------------------------------------------------------
 * Resize particle set buffers if needed.
 *
 * parameters:
 *   n_particles <-- minumum number of particles required
 *
 *
 * returns:
 *   1 if resizing was required, 0 otherwise
 *----------------------------------------------------------------------------*/
 
int
cs_lagr_particle_set_resize(cs_lnum_t  n_min_particles);
 
/*----------------------------------------------------------------------------
 * Set reallocation factor for particle sets.
 *
 * This factor determines the multiplier used for reallocations when
 * the particle set's buffers are too small to handle the new number of
 * particles.
 *
 * parameters:
 *  f <-- reallocation size multiplier
 *----------------------------------------------------------------------------*/
 
void
cs_lagr_set_reallocation_factor(double f);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
unsigned long long
cs_lagr_get_n_g_particles_max(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_set_n_g_particles_max(unsigned long long  n_g_particles_max);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_particles_current_to_previous(cs_lagr_particle_set_t  *particles,
                                      cs_lnum_t                particle_id);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_particle_set_dump(const cs_lagr_particle_set_t  *particles);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_set_n_user_variables(int  n_user_variables);
 
/*----------------------------------------------------------------------------*/
 
END_C_DECLS
 
/*============================================================================
 * Public C++ templates
 *============================================================================*/
 
#if defined(__cplusplus)
 
template <typename T>
T *
cs_lagr_particles_attr_get_ptr(cs_lagr_particle_set_t  *particle_set,
                               cs_lnum_t                particle_id,
                               cs_lagr_attribute_t      attr)
{
  assert(particle_set->p_am->count[0][attr] > 0);
 
  return   (T *)( particle_set->p_buffer
                           + particle_set->p_am->extents*particle_id
                           + particle_set->p_am->displ[0][attr]);
}
 
template <typename T>
const T *
cs_lagr_particles_attr_get_const_ptr(const cs_lagr_particle_set_t  *particle_set,
                                     cs_lnum_t                      particle_id,
                                     cs_lagr_attribute_t            attr)
{
  assert(particle_set->p_am->count[0][attr] > 0);
 
  return   (const T *)( particle_set->p_buffer
                                 + particle_set->p_am->extents*particle_id
                                 + particle_set->p_am->displ[0][attr]);
}
 
template <typename T>
T *
cs_lagr_particles_attr_n_get_ptr(cs_lagr_particle_set_t  *particle_set,
                                 cs_lnum_t                particle_id,
                                 int                      time_id,
                                 cs_lagr_attribute_t      attr)
{
  assert(particle_set->p_am->count[time_id][attr] > 0);
 
  return (T *)( particle_set->p_buffer
                         + particle_set->p_am->extents*particle_id
                         + particle_set->p_am->displ[time_id][attr]);
}
 
template <typename T>
const T *
cs_lagr_particles_attr_n_get_const_ptr(const cs_lagr_particle_set_t *particle_set,
                                       cs_lnum_t                     particle_id,
                                       int                           time_id,
                                       cs_lagr_attribute_t           attr)
{
  assert(particle_set->p_am->count[time_id][attr] > 0);
 
  return (const T *)( particle_set->p_buffer
                               + particle_set->p_am->extents*particle_id
                               + particle_set->p_am->displ[time_id][attr]);
}
 
template <typename T>
T
cs_lagr_particles_attr_get_val(const cs_lagr_particle_set_t  *particle_set,
                               cs_lnum_t                      particle_id,
                               cs_lagr_attribute_t            attr)
{
  assert(particle_set->p_am->count[0][attr] > 0);
 
  return *(T *)( particle_set->p_buffer
                         + particle_set->p_am->extents*particle_id
                         + particle_set->p_am->displ[0][attr]);
}
 
template <typename T>
void
cs_lagr_particles_attr_set_val(cs_lagr_particle_set_t  *particle_set,
                               cs_lnum_t                particle_id,
                               cs_lagr_attribute_t      attr,
                               T                        value)
{
  assert(particle_set->p_am->count[0][attr] > 0);
 
  *(T *)( particle_set->p_buffer
                  + particle_set->p_am->extents*particle_id
                  + particle_set->p_am->displ[0][attr]) = value;
}
 
template <typename T>
T
cs_lagr_particles_attr_n_get_val(const cs_lagr_particle_set_t  *particle_set,
                                 cs_lnum_t                      particle_id,
                                 int                            time_id,
                                 cs_lagr_attribute_t            attr)
{
  assert(particle_set->p_am->count[time_id][attr] > 0);
 
  return *(T *)( particle_set->p_buffer
                         + particle_set->p_am->extents*particle_id
                         + particle_set->p_am->displ[time_id][attr]);
}
 
template <typename T>
void
cs_lagr_particles_attr_n_set_val(cs_lagr_particle_set_t  *particle_set,
                                 cs_lnum_t                particle_id,
                                 int                      time_id,
                                 cs_lagr_attribute_t      attr,
                                 T                        value)
{
  assert(particle_set->p_am->count[time_id][attr] > 0);
 
  *(T *)( particle_set->p_buffer
        + particle_set->p_am->extents*particle_id
        + particle_set->p_am->displ[time_id][attr]) = value;
}
 
template <typename T>
T *
cs_lagr_particle_attr_get_ptr(void                           *particle,
                              const cs_lagr_attribute_map_t  *attr_map,
                              cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[0][attr] > 0);
 
  return  (T *)((unsigned char *)particle + attr_map->displ[0][attr]);
}
 
template <typename T>
const T *
cs_lagr_particle_attr_get_const_ptr(const void                     *particle,
                                    const cs_lagr_attribute_map_t  *attr_map,
                                    cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[0][attr] > 0);
 
  return  (const T *)(  (const unsigned char *)particle
                      + attr_map->displ[0][attr]);
}
 
template <typename T>
T *
cs_lagr_particle_attr_n_get_ptr(void                           *particle,
                                const cs_lagr_attribute_map_t  *attr_map,
                                int                             time_id,
                                cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[time_id][attr] > 0);
 
  return  (T *)((unsigned char *)particle + attr_map->displ[time_id][attr]);
}
 
template <typename T>
const T *
cs_lagr_particle_attr_n_get_const_ptr(const void                     *particle,
                                      const cs_lagr_attribute_map_t  *attr_map,
                                      int                             time_id,
                                      cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[time_id][attr] > 0);
 
  return  (const T *)(  (const unsigned char *)particle
                      + attr_map->displ[time_id][attr]);
}
 
template <typename T>
T
cs_lagr_particle_attr_get_val(const void                     *particle,
                              const cs_lagr_attribute_map_t  *attr_map,
                              cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[0][attr] > 0);
 
  return  *((const T *)(  (const unsigned char *)particle
                        + attr_map->displ[0][attr]));
}
 
template <typename T>
void
cs_lagr_particle_attr_set_val(void                           *particle,
                              const cs_lagr_attribute_map_t  *attr_map,
                              cs_lagr_attribute_t             attr,
                              T                               value)
{
  assert(attr_map->count[0][attr] > 0);
 
  *((T *)((unsigned char *)particle + attr_map->displ[0][attr]))
    = value;
}
 
template <typename T>
T
cs_lagr_particle_attr_n_get_val(const void                     *particle,
                                const cs_lagr_attribute_map_t  *attr_map,
                                int                             time_id,
                                cs_lagr_attribute_t             attr)
{
  assert(attr_map->count[time_id][attr] > 0);
 
  return  *((const T *)(  (const unsigned char *)particle
                        + attr_map->displ[time_id][attr]));
}
 
template <typename T>
void
cs_lagr_particle_attr_n_set_val(void                           *particle,
                                const cs_lagr_attribute_map_t  *attr_map,
                                int                             time_id,
                                cs_lagr_attribute_t             attr,
                                T                               value)
{
  assert(attr_map->count[time_id][attr] > 0);
 
  *((T *)(  (unsigned char *)particle
          + attr_map->displ[time_id][attr])) = value;
}
 
#endif
 
/*----------------------------------------------------------------------------*/
 
#endif /* __CS_LAGR_PARTICLE_H__ */