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-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 "string.h"
 
/*=============================================================================
 * 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 cs_lagr_attribute_map_t {
 
  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 */
 
#if defined(__cplusplus)
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  cs_lagr_attribute_map_t();
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST
  cs_lagr_attribute_map_t
  (
    cs_lnum_t attr_keys[CS_LAGR_N_ATTRIBUTES][3] 
  );
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  cs_lagr_attribute_map_t
  (
    const cs_lagr_attribute_map_t& other
  );
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  cs_lagr_attribute_map_t
  (
    cs_lagr_attribute_map_t&& other 
  );
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  ~cs_lagr_attribute_map_t();
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  cs_lagr_attribute_map_t& operator=(cs_lagr_attribute_map_t other);
 
  /* Define particle set as a friend which can access private members */
  friend struct cs_lagr_particle_set_t;
private:
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  void
  swap_members_
  (
    cs_lagr_attribute_map_t& first,
    cs_lagr_attribute_map_t& second
  );
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  void
  private_to_public_();
 
  /* Private members */
 
  cs_array_2d<int>       _count;
  cs_array_2d<ptrdiff_t> _displ;
  cs_array<ptrdiff_t>    _source_term_displ;
 
#endif
} cs_lagr_attribute_map_t;
 
 
/* Particle set */
/* ------------ */
 
typedef struct cs_lagr_particle_set_t {
 
  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;   
#if defined(__cplusplus)
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  cs_lagr_particle_set_t();
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  cs_lagr_particle_set_t
  (
    cs_lnum_t                      n_part_max, 
    const cs_lagr_attribute_map_t *map         
  );
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  cs_lagr_particle_set_t
  (
    const cs_lagr_particle_set_t& other 
  );
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  cs_lagr_particle_set_t
  (
    cs_lagr_particle_set_t&& other 
  );
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  ~cs_lagr_particle_set_t();
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  cs_lagr_particle_set_t& operator=(cs_lagr_particle_set_t other);
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST
  int
  resize
  (
    const cs_lnum_t n_particles_max_min
  );
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  template <typename T>
  CS_F_HOST_DEVICE
  inline
  T&
  attr
  (
    cs_lnum_t           particle_id, 
    cs_lagr_attribute_t attr         
  )
  {
    assert(_p_am._count(0,attr) > 0);
    return get_ptr_<T>(particle_id, 0, attr)[0];
  }
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  template <typename T>
  CS_F_HOST_DEVICE
  inline
  T&
  attr
  (
    cs_lnum_t           particle_id, 
    cs_lagr_attribute_t attr         
  ) const
  {
    assert(_p_am._count(0,attr) > 0);
    return get_ptr_<T>(particle_id, 0, attr)[0];
  }
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  template <typename T>
  CS_F_HOST_DEVICE
  inline
  T&
  attr_n
  (
    cs_lnum_t           particle_id, 
    int                 time_id,     
    cs_lagr_attribute_t attr         
  )
  {
    assert(_p_am._count(time_id,attr) > 0);
    return get_ptr_<T>(particle_id, time_id, attr)[0];
  }
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  template <typename T>
  CS_F_HOST_DEVICE
  inline
  T&
  attr_n
  (
    cs_lnum_t           p_id,     
    int                 time_id,  
    cs_lagr_attribute_t attr      
  ) const
  {
    assert(_p_am._count(time_id,attr) > 0);
    return get_ptr_<T>(p_id, time_id, attr)[0];
  }
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  template <typename T>
  CS_F_HOST_DEVICE
  inline
  T *
  attr_get_ptr
  (
    cs_lnum_t                p_id, 
    cs_lagr_attribute_t      attr  
  )
  {
    assert(_p_am._count(0,attr) > 0);
 
    return reinterpret_cast<T*>( _p_buffer.data()
                               + _p_am.extents * p_id
                               + _p_am._displ(0, attr));
 
 
  }
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  template <typename T>
  CS_F_HOST_DEVICE
  inline
  const T *
  attr_get_const_ptr
  (
    cs_lnum_t                p_id,  
    cs_lagr_attribute_t      attr   
  )
  {
    assert(_p_am._count(0,attr) > 0);
 
    return reinterpret_cast<const T*>( _p_buffer.data()
                                     + _p_am.extents * p_id
                                     + _p_am._displ(0, attr));
  }
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  template <typename T>
  CS_F_HOST_DEVICE
  inline
  T *
  attr_n_get_ptr
  (
    cs_lnum_t                p_id,     
    int                      time_id,  
    cs_lagr_attribute_t      attr      
  )
  {
    assert(_p_am._count(time_id, attr) > 0);
 
    return reinterpret_cast<T*>( _p_buffer.data()
                               + _p_am.extents * p_id
                               + _p_am._displ(time_id, attr));
 
  }
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  template <typename T>
  CS_F_HOST_DEVICE
  inline
  const T *
  attr_n_get_const_ptr
  (
    cs_lnum_t                p_id,     
    int                      time_id,  
    cs_lagr_attribute_t      attr      
  )
  {
    assert(_p_am._count(time_id, attr) > 0);
 
    return reinterpret_cast<const T*>( _p_buffer.data()
                                     + _p_am.extents * p_id
                                     + _p_am._displ(time_id, attr));
 
  }
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  inline
  int
  flag
  (
    cs_lnum_t p_id,  
    int       mask   
  )
  {
    int flag = get_const_ptr_<cs_lnum_t>(p_id, 0, CS_LAGR_P_FLAG)[0];
 
    return (flag & mask);
  }
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  inline
  void
  set_flag
  (
    cs_lnum_t p_id,        
    int       mask         
  )
  {
    int flag = get_const_ptr_<cs_lnum_t>(p_id, 0, CS_LAGR_P_FLAG)[0];
    flag = flag | mask;
    get_ptr_<cs_lnum_t>(p_id, 0, CS_LAGR_P_FLAG)[0] = flag;
  }
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  inline
  void
  unset_flag
  (
    cs_lnum_t p_id, 
    int       mask  
  )
  {
    int flag = get_const_ptr_<cs_lnum_t>(p_id, 0, CS_LAGR_P_FLAG)[0];
    flag = (flag | mask) - mask;
    get_ptr_<cs_lnum_t>(p_id, 0, CS_LAGR_P_FLAG)[0] = flag;
  }
 
  /*----------------------------------------------------------------------------*/
  /*----------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  inline
  cs_real_t *
  source_terms
  (
    cs_lnum_t                p_id,
    cs_lagr_attribute_t      attr
  )
  {
    assert(_p_am._source_term_displ(attr) >= 0);
 
    return (cs_real_t *)(  _p_buffer.data()
                         + _p_am.extents*p_id
                         + _p_am._source_term_displ(attr));
  }
 
  /*----------------------------------------------------------------------------*/
  /*----------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  inline
  const cs_real_t *
  source_terms_const
  (
    cs_lnum_t                p_id,
    cs_lagr_attribute_t      attr
  )
  {
    assert(_p_am._source_term_displ(attr) >= 0);
 
    return (const cs_real_t *)(  _p_buffer.data()
                              + _p_am.extents*p_id
                              + _p_am._source_term_displ(attr));
  }
 
  /*--------------------------------------------------------------------------*/
  /* Aliases to templated methods for shorter names used in code */
  /*--------------------------------------------------------------------------*/
 
  template<typename... Args>
  inline auto
  attr_real(Args&&... args) ->
  decltype(attr<cs_real_t>(std::forward<Args>(args)...))
  {
    return attr<cs_real_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_lnum(Args&&... args) ->
  decltype(attr<cs_lnum_t>(std::forward<Args>(args)...))
  {
    return attr<cs_lnum_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_gnum(Args&&... args) ->
  decltype(attr<cs_gnum_t>(std::forward<Args>(args)...))
  {
    return attr<cs_gnum_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_n_real(Args&&... args) ->
  decltype(attr_n<cs_real_t>(std::forward<Args>(args)...))
  {
    return attr_n<cs_real_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_n_lnum(Args&&... args) ->
  decltype(attr_n<cs_lnum_t>(std::forward<Args>(args)...))
  {
    return attr_n<cs_lnum_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_n_gnum(Args&&... args) ->
  decltype(attr_n<cs_gnum_t>(std::forward<Args>(args)...))
  {
    return attr_n<cs_gnum_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_real_ptr(Args&&... args) ->
  decltype(attr_get_ptr<cs_real_t>(std::forward<Args>(args)...))
  {
    return attr_get_ptr<cs_real_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_lnum_ptr(Args&&... args) ->
  decltype(attr_get_ptr<cs_lnum_t>(std::forward<Args>(args)...))
  {
    return attr_get_ptr<cs_lnum_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_gnum_ptr(Args&&... args) ->
  decltype(attr_get_ptr<cs_gnum_t>(std::forward<Args>(args)...))
  {
    return attr_get_ptr<cs_gnum_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_real_const_ptr(Args&&... args) ->
  decltype(attr_get_const_ptr<cs_real_t>(std::forward<Args>(args)...))
  {
    return attr_get_const_ptr<cs_real_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_lnum_const_ptr(Args&&... args) ->
  decltype(attr_get_const_ptr<cs_lnum_t>(std::forward<Args>(args)...))
  {
    return attr_get_const_ptr<cs_lnum_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_gnum_const_ptr(Args&&... args) ->
  decltype(attr_get_const_ptr<cs_gnum_t>(std::forward<Args>(args)...))
  {
    return attr_get_const_ptr<cs_gnum_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_n_real_ptr(Args&&... args) ->
  decltype(attr_n_get_ptr<cs_real_t>(std::forward<Args>(args)...))
  {
    return attr_n_get_ptr<cs_real_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_n_lnum_ptr(Args&&... args) ->
  decltype(attr_n_get_ptr<cs_lnum_t>(std::forward<Args>(args)...))
  {
    return attr_n_get_ptr<cs_lnum_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_n_gnum_ptr(Args&&... args) ->
  decltype(attr_n_get_ptr<cs_gnum_t>(std::forward<Args>(args)...))
  {
    return attr_n_get_ptr<cs_gnum_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_n_real_const_ptr(Args&&... args) ->
  decltype(attr_n_get_const_ptr<cs_real_t>(std::forward<Args>(args)...))
  {
    return attr_n_get_const_ptr<cs_real_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_n_lnum_const_ptr(Args&&... args) ->
  decltype(attr_n_get_const_ptr<cs_lnum_t>(std::forward<Args>(args)...))
  {
    return attr_n_get_const_ptr<cs_lnum_t>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  inline auto
  attr_n_gnum_const_ptr(Args&&... args) ->
  decltype(attr_n_get_const_ptr<cs_gnum_t>(std::forward<Args>(args)...))
  {
    return attr_n_get_const_ptr<cs_gnum_t>(std::forward<Args>(args)...);
  }
 
private:
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  void
  swap_members_
  (
    cs_lagr_particle_set_t& first,
    cs_lagr_particle_set_t& second
  );
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  CS_F_HOST_DEVICE
  void
  private_to_public_();
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  template <typename T>
  CS_F_HOST_DEVICE
  inline
  T *
  get_ptr_
  (
    cs_lnum_t           p_id,     
    int                 time_id,  
    cs_lagr_attribute_t attr      
  )
  {
    return reinterpret_cast<T*>( _p_buffer.data()
                               + _p_am.extents * p_id
                               + _p_am._displ(time_id, attr));
  }
 
  /*--------------------------------------------------------------------------*/
  /*--------------------------------------------------------------------------*/
 
  template <typename T>
  CS_F_HOST_DEVICE
  inline
  const T *
  get_const_ptr_
  (
    cs_lnum_t           p_id,    
    int                 time_id, 
    cs_lagr_attribute_t attr     
  )
  {
    return reinterpret_cast<const T*>( _p_buffer.data()
                                     + _p_am.extents * p_id
                                     + _p_am._displ(time_id, attr));
  }
 
  /* Private members */
 
  cs_array<unsigned char> _p_buffer;
  cs_lagr_attribute_map_t _p_am;
 
#endif
} 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);
 
/*----------------------------------------------------------------------------
 * Return reference to the main cs_lagr_particle_set_t structure.
 *
 * returns:
 *   reference to current particle set, or NULL
 *----------------------------------------------------------------------------*/
 
#if defined(__cplusplus)
cs_lagr_particle_set_t&
cs_lagr_get_particle_set_ref(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,//TODO C++ by ref
                                       cs_lnum_t                p_id)
{
  memset(p_set->p_buffer + p_set->p_am->extents * p_id,
         0,
         p_set->p_am->extents);
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------
 * 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  &p_set,
                                      cs_lnum_t                p_id);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_particle_set_dump(const cs_lagr_particle_set_t  *p_set);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_lagr_set_n_user_variables(int  n_user_variables);
 
/*----------------------------------------------------------------------------*/
 
/*============================================================================
 * Public C++ templates
 *============================================================================*/
 
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;
}
 
#endif
 
/*----------------------------------------------------------------------------*/
 
#endif /* CS_LAGR_PARTICLE_H */