programmer's documentation
cs_lagr_tracking.h
Go to the documentation of this file.
1 #ifndef __CS_LAGR_TRACKING_H__
2 #define __CS_LAGR_TRACKING_H__
3 
4 /*============================================================================
5  * Functions and types for the Lagrangian module
6  *============================================================================*/
7 
8 /*
9  This file is part of Code_Saturne, a general-purpose CFD tool.
10 
11  Copyright (C) 1998-2015 EDF S.A.
12 
13  This program is free software; you can redistribute it and/or modify it under
14  the terms of the GNU General Public License as published by the Free Software
15  Foundation; either version 2 of the License, or (at your option) any later
16  version.
17 
18  This program is distributed in the hope that it will be useful, but WITHOUT
19  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
20  FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
21  details.
22 
23  You should have received a copy of the GNU General Public License along with
24  this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
25  Street, Fifth Floor, Boston, MA 02110-1301, USA.
26 */
27 
28 /*----------------------------------------------------------------------------*/
29 
30 #include "cs_defs.h"
31 
32 #include "assert.h"
33 
34 /*----------------------------------------------------------------------------*/
35 
37 
38 /*=============================================================================
39  * Macro definitions
40  *============================================================================*/
41 
42 /*============================================================================
43  * Type definitions
44  *============================================================================*/
45 
46 typedef enum {
47 
48  CS_LAGR_CELL_NUM, /* local cell number */
49  CS_LAGR_RANK_ID, /* local parallel rank id */
50 
52 
53  CS_LAGR_RANDOM_VALUE, /* random value associated with the particle */
54 
63 
64  /* Arrays for 2nd order scheme */
65 
66  CS_LAGR_TURB_STATE_1, /* turbulence characteristics of first pass */
67  CS_LAGR_PRED_VELOCITY, /* 1st step prediction for particle velocity */
68  CS_LAGR_PRED_VELOCITY_SEEN, /* 1st step prediction for relative velocity */
69 
70  /* Deposition submodel additional parameters */
71 
77 
78  /* Resuspension model additional parameters */
79 
85 
86  /* Clogging model additional parameters */
87 
92 
93  /* Thermal model additional parameters */
94 
98 
99  /* Coal combustion additional parameters */
100 
104 
107 
110 
111  /* Radiative model additional parameters */
112 
114 
115  /* Statistical class */
116 
118 
119  /* User variables */
120 
122 
123  /* End of attributes */
124 
126 
128 
129 /* Particle structure mapping */
130 /* -------------------------- */
131 
132 typedef struct {
133 
134  size_t extents; /* size (in bytes) of particle
135  structure */
136 
137  int n_time_vals; /* number of time values
138  handled */
139 
140  size_t size[CS_LAGR_N_ATTRIBUTES]; /* size (in bytes) of
141  attributes in particle
142  structure for a given
143  time value */
144  cs_datatype_t datatype[CS_LAGR_N_ATTRIBUTES]; /* datatype of associated
145  attributes */
146  int (*count)[CS_LAGR_N_ATTRIBUTES]; /* number of values for each
147  attribute, per associated
148  time_id */
149  ptrdiff_t (*displ)[CS_LAGR_N_ATTRIBUTES]; /* displacement (in bytes) of
150  attributes in particle data,
151  per associated time_id*/
152 
153  ptrdiff_t *source_term_displ; /* displacement (in bytes) of
154  source term values
155  for second-order scheme,
156  or NULL */
157 
159 
160 /* Linked list */
161 /* ----------- */
162 
163 typedef struct _cs_lagr_tracking_list_t cs_lagr_tracking_list_t;
164 
165 /* Particle set */
166 /* ------------ */
167 
168 typedef struct {
169 
170  int time_id; /* 0 for current time,
171  -1 for previous */
177 
183 
185 
188 
189  const cs_lagr_attribute_map_t *p_am; /* particle attributes maps
190  (p_am + i for time n-i) */
191  unsigned char *p_buffer; /* Particles data buffer */
192 
193  cs_lagr_tracking_list_t *used_id; /* active particles list,
194  or NULL for secondary sets */
195 
197 
198 /* Global parameters for Lagrangian module */
199 /*-----------------------------------------*/
200 
201 typedef struct {
202 
203  int physical_model; /* FIXME: => enum: CS_LAGR_PHYS_STD,
204  CS_LAGR_PHYS_COAL,
205  CS_LAGR_PHYS_HEAT... */
207 
209  int dlvo;
212  int clogging;
213 
216 
217  int t_order; /* Algorithm order in time */
218 
220 
221 /*=============================================================================
222  * Global variables
223  *============================================================================*/
224 
225 extern const char *cs_lagr_attribute_name[];
226 
227 /* Pointer to global Lagragian module parameters */
228 
230 
231 /*============================================================================
232  * Public function prototypes for Fortran API
233  *============================================================================*/
234 
235 /*----------------------------------------------------------------------------
236  * Allocate cs_lagr_particle_set_t structure and initialize useful buffers
237  * and indexes
238  *
239  * parameters:
240  * nordre <-- time algorithm order (1 or 2)
241  * iphyla <-- kind of physics used for the lagrangian approach
242  * nvls <-- number of user-defined variables
243  * nbclst <-- number of stat. class to study sub-set of particles
244  * ...
245  *----------------------------------------------------------------------------*/
246 
247 void
248 CS_PROCF (lagbeg, LAGBEG)(const cs_int_t *nordre,
249  const cs_int_t *nlayer,
250  const cs_int_t *iphyla,
251  const cs_int_t *idepst,
252  const cs_int_t *idlvo,
253  const cs_int_t *irough,
254  const cs_int_t *ireent,
255  const cs_int_t *iclogst,
256  const cs_int_t *nvls,
257  const cs_int_t *nbclst,
258  cs_lnum_t icocel[],
259  cs_lnum_t itycel[],
260  cs_int_t *jisor,
261  cs_int_t *jisora,
262  cs_int_t *jirka,
263  cs_int_t *jord1,
264  cs_int_t *jrval,
265  cs_int_t *jrpoi,
266  cs_int_t *jrtsp,
267  cs_int_t *jdp,
268  cs_int_t *jmp,
269  cs_int_t *jxp,
270  cs_int_t *jyp,
271  cs_int_t *jzp,
272  cs_int_t *jup,
273  cs_int_t *jvp,
274  cs_int_t *jwp,
275  cs_int_t *juf,
276  cs_int_t *jvf,
277  cs_int_t *jwf,
278  cs_int_t *jtaux,
279  cs_int_t jbx1[3],
280  cs_int_t jtsup[3],
281  cs_int_t jtsuf[3],
282  cs_int_t *jryplu,
283  cs_int_t *jrinpf,
284  cs_int_t *jdfac,
285  cs_int_t *jimark,
286  cs_int_t *jtp,
287  cs_int_t jhp[],
288  cs_int_t *jtf,
289  cs_int_t *jmwat,
290  cs_int_t jmch[],
291  cs_int_t jmck[],
292  cs_int_t *jcp,
293  cs_int_t *jrdck,
294  cs_int_t *jrd0p,
295  cs_int_t *jinch,
296  cs_int_t jrhock[],
297  cs_int_t *jreps,
298  cs_int_t *jdepo,
299  cs_int_t *jnbasg,
300  cs_int_t *jnbasp,
301  cs_int_t *jfadh,
302  cs_int_t *jmfadh,
303  cs_int_t *jndisp,
304  cs_int_t *jclst,
305  cs_int_t *jvls,
306  cs_int_t *jdp2,
307  cs_int_t *jnbpoi,
308  cs_int_t *jrtdep,
310  );
311 
312 /*----------------------------------------------------------------------------
313  * Get variables and parameters associated to each particles and keep it in
314  * a new structure
315  *
316  * parameters:
317  * ...
318  *----------------------------------------------------------------------------*/
319 
320 void
321 CS_PROCF (getbdy, GETBDY)(const cs_int_t *nflagm,
322  const cs_int_t *nfrlag,
323  const cs_int_t *injcon,
324  const cs_int_t ilflag[],
325  const cs_int_t iusncl[],
326  const cs_int_t iusclb[],
327  const cs_real_t deblag[],
328  const cs_int_t ifrlag[]);
329 
330 /*----------------------------------------------------------------------------
331  * Displacement of particles.
332  *
333  * parameters:
334  * scheme_order <-- current order of the scheme used for Lagragian
335  *----------------------------------------------------------------------------*/
336 
337 void
338 CS_PROCF (dplprt, DPLPRT)(cs_int_t *p_scheme_order,
339  cs_real_t boundary_stat[],
340  const cs_int_t *iensi3,
341  const cs_int_t *inbr,
342  const cs_int_t *inbrbd,
343  const cs_int_t *iflm,
344  const cs_int_t *iflmbd,
345  const cs_int_t *iang,
346  const cs_int_t *iangbd,
347  const cs_int_t *ivit,
348  const cs_int_t *ivitbd,
349  const cs_int_t *iencnd,
350  const cs_int_t *iencma,
351  const cs_int_t *iencdi,
352  const cs_int_t *iencck,
353  const cs_int_t *iencnbbd,
354  const cs_int_t *iencmabd,
355  const cs_int_t *iencdibd,
356  const cs_int_t *iencckbd,
357  const cs_int_t *inclg,
358  const cs_int_t *inclgt,
359  const cs_int_t *iclogt,
360  const cs_int_t *iclogh,
361  const cs_int_t *iscovc,
362  const cs_int_t *ihdepm,
363  const cs_int_t *ihdepv,
364  const cs_int_t *ihsum,
365  const cs_int_t *nusbor,
366  cs_int_t iusb[],
367  cs_real_t visc_length[],
368  cs_real_t dlgeo[],
369  const cs_real_t tprenc[],
370  const cs_real_t visref[],
371  const cs_real_t enc1[],
372  const cs_real_t enc2[],
373  const cs_real_t *tkelvi);
374 
375 /*============================================================================
376  * Public function prototypes
377  *============================================================================*/
378 
379 /*----------------------------------------------------------------------------
380  * Get data access information for a given particle attribute.
381  *
382  * For attributes not currently present, the displacement and data
383  * size should be -1 and 0 respectively.
384  *
385  * parameters:
386  * particles <-- associated particle set
387  * time_id <-- associated time id (0: current, 1: previous)
388  * attr <-- particle attribute
389  * extents --> size (in bytes) of particle structure, or NULL
390  * size --> size (in bytes) of attribute in particle structure, or NULL
391  * displ --> displacement (in bytes) in particle structure, or NULL
392  * datatype --> associated datatype, or NULL
393  * count --> associated elements count, or NULL
394  *----------------------------------------------------------------------------*/
395 
396 void
398  int time_id,
399  cs_lagr_attribute_t attr,
400  size_t *extents,
401  size_t *size,
402  ptrdiff_t *displ,
403  cs_datatype_t *datatype,
404  int *count);
405 
406 /*----------------------------------------------------------------------------
407  * Return pointer to the main cs_lagr_particle_set_t structure.
408  *
409  * returns:
410  * pointer to current particle set, or NULL
411  *----------------------------------------------------------------------------*/
412 
415 
416 /*----------------------------------------------------------------------------
417  * Delete particle set structure and other useful buffers.
418  *----------------------------------------------------------------------------*/
419 
420 void
421 cs_lagr_destroy(void);
422 
423 /*----------------------------------------------------------------------------*/
433 /*----------------------------------------------------------------------------*/
434 
435 inline static void *
437  cs_lnum_t particle_id,
438  cs_lagr_attribute_t attr)
439 {
440  assert(particle_set->p_am->count[0][attr] > 0);
441 
442  return (unsigned char *)particle_set->p_buffer
443  + particle_set->p_am->extents*particle_id
444  + particle_set->p_am->displ[0][attr];
445 }
446 
447 /*----------------------------------------------------------------------------*/
458 /*----------------------------------------------------------------------------*/
459 
460 inline static const void *
462  cs_lnum_t particle_id,
463  cs_lagr_attribute_t attr)
464 {
465  assert(particle_set->p_am->count[0][attr] > 0);
466 
467  return particle_set->p_buffer
468  + particle_set->p_am->extents*particle_id
469  + particle_set->p_am->displ[0][attr];
470 }
471 
472 /*----------------------------------------------------------------------------*/
484 /*----------------------------------------------------------------------------*/
485 
486 inline static void *
488  cs_lnum_t particle_id,
489  int time_id,
490  cs_lagr_attribute_t attr)
491 {
492  assert(particle_set->p_am->count[time_id][attr] > 0);
493 
494  return particle_set->p_buffer
495  + particle_set->p_am->extents*particle_id
496  + particle_set->p_am->displ[time_id][attr];
497 }
498 
499 /*----------------------------------------------------------------------------*/
511 /*----------------------------------------------------------------------------*/
512 
513 inline static const void *
515  cs_lnum_t particle_id,
516  int time_id,
517  cs_lagr_attribute_t attr)
518 {
519  assert(particle_set->p_am->count[time_id][attr] > 0);
520 
521  return particle_set->p_buffer
522  + particle_set->p_am->extents*particle_id
523  + particle_set->p_am->displ[time_id][attr];
524 }
525 
526 /*----------------------------------------------------------------------------*/
536 /*----------------------------------------------------------------------------*/
537 
538 inline static cs_lnum_t
540  cs_lnum_t particle_id,
541  cs_lagr_attribute_t attr)
542 {
543  assert(particle_set->p_am->count[0][attr] > 0);
544 
545  return *((const cs_lnum_t *)( particle_set->p_buffer
546  + particle_set->p_am->extents*particle_id
547  + particle_set->p_am->displ[0][attr]));
548 }
549 
550 /*----------------------------------------------------------------------------*/
562 /*----------------------------------------------------------------------------*/
563 
564 inline static cs_lnum_t
566  cs_lnum_t particle_id,
567  int time_id,
568  cs_lagr_attribute_t attr)
569 {
570  assert(particle_set->p_am->count[time_id][attr] > 0);
571 
572  return *((const cs_lnum_t *)( particle_set->p_buffer
573  + particle_set->p_am->extents*particle_id
574  + particle_set->p_am->displ[time_id][attr]));
575 }
576 
577 /*----------------------------------------------------------------------------*/
586 /*----------------------------------------------------------------------------*/
587 
588 inline static void
590  cs_lnum_t particle_id,
591  cs_lagr_attribute_t attr,
592  cs_lnum_t value)
593 {
594  assert(particle_set->p_am->count[0][attr] > 0);
595 
596  *((cs_lnum_t *)( particle_set->p_buffer
597  + particle_set->p_am->extents*particle_id
598  + particle_set->p_am->displ[0][attr])) = value;
599 }
600 
601 /*----------------------------------------------------------------------------*/
612 /*----------------------------------------------------------------------------*/
613 
614 inline static void
616  cs_lnum_t particle_id,
617  int time_id,
618  cs_lagr_attribute_t attr,
619  cs_lnum_t value)
620 {
621  assert(particle_set->p_am->count[time_id][attr] > 0);
622 
623  *((cs_lnum_t *)( particle_set->p_buffer
624  + particle_set->p_am->extents*particle_id
625  + particle_set->p_am->displ[time_id][attr])) = value;
626 }
627 
628 /*----------------------------------------------------------------------------*/
638 /*----------------------------------------------------------------------------*/
639 
640 inline static cs_gnum_t
642  cs_lnum_t particle_id,
643  cs_lagr_attribute_t attr)
644 {
645  assert(particle_set->p_am->count[0][attr] > 0);
646 
647  return *((const cs_gnum_t *)( particle_set->p_buffer
648  + particle_set->p_am->extents*particle_id
649  + particle_set->p_am->displ[0][attr]));
650 }
651 
652 /*----------------------------------------------------------------------------*/
664 /*----------------------------------------------------------------------------*/
665 
666 inline static cs_gnum_t
668  cs_lnum_t particle_id,
669  int time_id,
670  cs_lagr_attribute_t attr)
671 {
672  assert(particle_set->p_am->count[time_id][attr] > 0);
673 
674  return *((const cs_gnum_t *)( particle_set->p_buffer
675  + particle_set->p_am->extents*particle_id
676  + particle_set->p_am->displ[time_id][attr]));
677 }
678 
679 /*----------------------------------------------------------------------------*/
688 /*----------------------------------------------------------------------------*/
689 
690 inline static void
692  cs_lnum_t particle_id,
693  cs_lagr_attribute_t attr,
694  cs_gnum_t value)
695 {
696  assert(particle_set->p_am->count[0][attr] > 0);
697 
698  *((cs_gnum_t *)( particle_set->p_buffer
699  + particle_set->p_am->extents*particle_id
700  + particle_set->p_am->displ[0][attr])) = value;
701 }
702 
703 /*----------------------------------------------------------------------------*/
714 /*----------------------------------------------------------------------------*/
715 
716 inline static void
718  cs_lnum_t particle_id,
719  int time_id,
720  cs_lagr_attribute_t attr,
721  cs_gnum_t value)
722 {
723  assert(particle_set->p_am->count[time_id][attr] > 0);
724 
725  *((cs_gnum_t *)( particle_set->p_buffer
726  + particle_set->p_am->extents*particle_id
727  + particle_set->p_am->displ[time_id][attr])) = value;
728 }
729 
730 /*----------------------------------------------------------------------------*/
740 /*----------------------------------------------------------------------------*/
741 
742 inline static cs_real_t
744  cs_lnum_t particle_id,
745  cs_lagr_attribute_t attr)
746 {
747  assert(particle_set->p_am->count[0][attr] > 0);
748 
749  return *((const cs_real_t *)( particle_set->p_buffer
750  + particle_set->p_am->extents*particle_id
751  + particle_set->p_am->displ[0][attr]));
752 }
753 
754 /*----------------------------------------------------------------------------*/
766 /*----------------------------------------------------------------------------*/
767 
768 inline static cs_real_t
770  cs_lnum_t particle_id,
771  int time_id,
772  cs_lagr_attribute_t attr)
773 {
774  assert(particle_set->p_am->count[time_id][attr] > 0);
775 
776  return *((const cs_real_t *)( particle_set->p_buffer
777  + particle_set->p_am->extents*particle_id
778  + particle_set->p_am->displ[time_id][attr]));
779 }
780 
781 /*----------------------------------------------------------------------------*/
790 /*----------------------------------------------------------------------------*/
791 
792 inline static void
794  cs_lnum_t particle_id,
795  cs_lagr_attribute_t attr,
796  cs_real_t value)
797 {
798  assert(particle_set->p_am->count[0][attr] > 0);
799 
800  *((cs_real_t *)( particle_set->p_buffer
801  + particle_set->p_am->extents*particle_id
802  + particle_set->p_am->displ[0][attr])) = value;
803 }
804 
805 /*----------------------------------------------------------------------------*/
816 /*----------------------------------------------------------------------------*/
817 
818 inline static void
820  cs_lnum_t particle_id,
821  int time_id,
822  cs_lagr_attribute_t attr,
823  cs_real_t value)
824 {
825  assert(particle_set->p_am->count[time_id][attr] > 0);
826 
827  *((cs_real_t *)( particle_set->p_buffer
828  + particle_set->p_am->extents*particle_id
829  + particle_set->p_am->displ[time_id][attr])) = value;
830 }
831 
832 /*----------------------------------------------------------------------------*/
843 /*----------------------------------------------------------------------------*/
844 
845 inline static cs_real_t *
847  cs_lnum_t particle_id,
848  cs_lagr_attribute_t attr)
849 {
850  assert(particle_set->p_am->source_term_displ != NULL);
851  assert(particle_set->p_am->source_term_displ[attr] >= 0);
852 
853  return (cs_real_t *)( (unsigned char *)particle_set->p_buffer
854  + particle_set->p_am->extents*particle_id
855  + particle_set->p_am->source_term_displ[attr]);
856 }
857 
858 /*----------------------------------------------------------------------------*/
869 /*----------------------------------------------------------------------------*/
870 
871 inline static const cs_real_t *
873  cs_lnum_t particle_id,
874  cs_lagr_attribute_t attr)
875 {
876  assert(particle_set->p_am->source_term_displ != NULL);
877  assert(particle_set->p_am->source_term_displ[attr] >= 0);
878 
879  return (const cs_real_t *)( (unsigned char *)particle_set->p_buffer
880  + particle_set->p_am->extents*particle_id
881  + particle_set->p_am->source_term_displ[attr]);
882 }
883 
884 /*----------------------------------------------------------------------------*/
894 /*----------------------------------------------------------------------------*/
895 
896 inline static void *
897 cs_lagr_particle_attr(void *particle,
898  const cs_lagr_attribute_map_t *attr_map,
899  cs_lagr_attribute_t attr)
900 {
901  assert(attr_map->count[0][attr] > 0);
902 
903  return (unsigned char *)particle + attr_map->displ[0][attr];
904 }
905 
906 /*----------------------------------------------------------------------------*/
916 /*----------------------------------------------------------------------------*/
917 
918 inline static const void *
919 cs_lagr_particle_attr_const(const void *particle,
920  const cs_lagr_attribute_map_t *attr_map,
921  cs_lagr_attribute_t attr)
922 {
923  assert(attr_map->count[0][attr] > 0);
924 
925  return (const unsigned char *)particle + attr_map->displ[0][attr];
926 }
927 
928 /*----------------------------------------------------------------------------*/
939 /*----------------------------------------------------------------------------*/
940 
941 inline static void *
942 cs_lagr_particle_attr_n(void *particle,
943  const cs_lagr_attribute_map_t *attr_map,
944  int time_id,
945  cs_lagr_attribute_t attr)
946 {
947  assert(attr_map->count[time_id][attr] > 0);
948 
949  return (unsigned char *)particle + attr_map->displ[time_id][attr];
950 }
951 
952 /*----------------------------------------------------------------------------*/
963 /*----------------------------------------------------------------------------*/
964 
965 inline static const void *
966 cs_lagr_particle_attr_n_const(const void *particle,
967  const cs_lagr_attribute_map_t *attr_map,
968  int time_id,
969  cs_lagr_attribute_t attr)
970 {
971  assert(attr_map->count[time_id][attr] > 0);
972 
973  return (const unsigned char *)particle
974  + attr_map->displ[time_id][attr];
975 }
976 
977 /*----------------------------------------------------------------------------*/
987 /*----------------------------------------------------------------------------*/
988 
989 inline static cs_lnum_t
990 cs_lagr_particle_get_lnum(const void *particle,
991  const cs_lagr_attribute_map_t *attr_map,
992  cs_lagr_attribute_t attr)
993 {
994  assert(attr_map->count[0][attr] > 0);
995 
996  return *((const cs_lnum_t *)( (const unsigned char *)particle
997  + attr_map->displ[0][attr]));
998 }
999 
1000 /*----------------------------------------------------------------------------*/
1012 /*----------------------------------------------------------------------------*/
1013 
1014 inline static cs_lnum_t
1015 cs_lagr_particle_get_lnum_n(const void *particle,
1016  const cs_lagr_attribute_map_t *attr_map,
1017  int time_id,
1018  cs_lagr_attribute_t attr)
1019 {
1020  assert(attr_map->count[time_id][attr] > 0);
1021 
1022  return *((const cs_lnum_t *)( (const unsigned char *)particle
1023  + attr_map->displ[time_id][attr]));
1024 }
1025 
1026 /*----------------------------------------------------------------------------*/
1035  /*----------------------------------------------------------------------------*/
1036 
1037 inline static void
1039  const cs_lagr_attribute_map_t *attr_map,
1040  cs_lagr_attribute_t attr,
1041  cs_lnum_t value)
1042 {
1043  assert(attr_map->count[0][attr] > 0);
1044 
1045  *((cs_lnum_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
1046  = value;
1047 }
1048 
1049 /*----------------------------------------------------------------------------*/
1060  /*----------------------------------------------------------------------------*/
1061 
1062 inline static void
1064  const cs_lagr_attribute_map_t *attr_map,
1065  int time_id,
1066  cs_lagr_attribute_t attr,
1067  cs_lnum_t value)
1068 {
1069  assert(attr_map->count[time_id][attr] > 0);
1070 
1071  *((cs_lnum_t *)( (unsigned char *)particle
1072  + attr_map->displ[time_id][attr])) = value;
1073 }
1074 
1075 /*----------------------------------------------------------------------------*/
1085 /*----------------------------------------------------------------------------*/
1086 
1087 inline static cs_gnum_t
1088 cs_lagr_particle_get_gnum(const void *particle,
1089  const cs_lagr_attribute_map_t *attr_map,
1090  cs_lagr_attribute_t attr)
1091 {
1092  assert(attr_map->count[0][attr] > 0);
1093 
1094  return *((const cs_gnum_t *)( (const unsigned char *)particle
1095  + attr_map->displ[0][attr]));
1096 }
1097 
1098 /*----------------------------------------------------------------------------*/
1110 /*----------------------------------------------------------------------------*/
1111 
1112 inline static cs_gnum_t
1113 cs_lagr_particle_get_gnum_n(const void *particle,
1114  const cs_lagr_attribute_map_t *attr_map,
1115  int time_id,
1116  cs_lagr_attribute_t attr)
1117 {
1118  assert(attr_map->count[time_id][attr] > 0);
1119 
1120  return *((const cs_gnum_t *)( (const unsigned char *)particle
1121  + attr_map->displ[time_id][attr]));
1122 }
1123 
1124 /*----------------------------------------------------------------------------*/
1133  /*----------------------------------------------------------------------------*/
1134 
1135 inline static void
1137  const cs_lagr_attribute_map_t *attr_map,
1138  cs_lagr_attribute_t attr,
1139  cs_gnum_t value)
1140 {
1141  assert(attr_map->count[0][attr] > 0);
1142 
1143  *((cs_gnum_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
1144  = value;
1145 }
1146 
1147 /*----------------------------------------------------------------------------*/
1158  /*----------------------------------------------------------------------------*/
1159 
1160 inline static void
1162  const cs_lagr_attribute_map_t *attr_map,
1163  int time_id,
1164  cs_lagr_attribute_t attr,
1165  cs_gnum_t value)
1166 {
1167  assert(attr_map->count[time_id][attr] > 0);
1168 
1169  *((cs_gnum_t *)( (unsigned char *)particle
1170  + attr_map->displ[time_id][attr])) = value;
1171 }
1172 
1173 /*----------------------------------------------------------------------------*/
1183 /*----------------------------------------------------------------------------*/
1184 
1185 inline static cs_real_t
1186 cs_lagr_particle_get_real(const void *particle,
1187  const cs_lagr_attribute_map_t *attr_map,
1188  cs_lagr_attribute_t attr)
1189 {
1190  assert(attr_map->count[0][attr] > 0);
1191 
1192  return *((const cs_real_t *)( (const unsigned char *)particle
1193  + attr_map->displ[0][attr]));
1194 }
1195 
1196 /*----------------------------------------------------------------------------*/
1208 /*----------------------------------------------------------------------------*/
1209 
1210 inline static cs_real_t
1211 cs_lagr_particle_get_real_n(const void *particle,
1212  const cs_lagr_attribute_map_t *attr_map,
1213  int time_id,
1214  cs_lagr_attribute_t attr)
1215 {
1216  assert(attr_map->count[time_id][attr] > 0);
1217 
1218  return *((const cs_real_t *)( (const unsigned char *)particle
1219  + attr_map->displ[time_id][attr]));
1220 }
1221 
1222 /*----------------------------------------------------------------------------*/
1231  /*----------------------------------------------------------------------------*/
1232 
1233 inline static void
1235  const cs_lagr_attribute_map_t *attr_map,
1236  cs_lagr_attribute_t attr,
1237  cs_real_t value)
1238 {
1239  assert(attr_map->count[0][attr] > 0);
1240 
1241  *((cs_real_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
1242  = value;
1243 }
1244 
1245 /*----------------------------------------------------------------------------*/
1256  /*----------------------------------------------------------------------------*/
1257 
1258 inline static void
1260  const cs_lagr_attribute_map_t *attr_map,
1261  int time_id,
1262  cs_lagr_attribute_t attr,
1263  cs_real_t value)
1264 {
1265  assert(attr_map->count[time_id][attr] > 0);
1266 
1267  *((cs_real_t *)( (unsigned char *)particle
1268  + attr_map->displ[time_id][attr])) = value;
1269 }
1270 
1271 /*----------------------------------------------------------------------------*/
1281 /*----------------------------------------------------------------------------*/
1282 
1283 inline static cs_real_t *
1285  const cs_lagr_attribute_map_t *attr_map,
1286  cs_lagr_attribute_t attr)
1287 {
1288  assert(attr_map->source_term_displ != NULL);
1289  assert(attr_map->source_term_displ[attr] >= 0);
1290 
1291  return (cs_real_t *)( (unsigned char *)particle
1292  + attr_map->source_term_displ[attr]);
1293 }
1294 
1295 /*----------------------------------------------------------------------------*/
1305 /*----------------------------------------------------------------------------*/
1306 
1307 inline static const cs_real_t *
1309  const cs_lagr_attribute_map_t *attr_map,
1310  cs_lagr_attribute_t attr)
1311 {
1312  assert(attr_map->source_term_displ != NULL);
1313  assert(attr_map->source_term_displ[attr] >= 0);
1314 
1315  return (const cs_real_t *)( (unsigned char *)particle
1316  + attr_map->source_term_displ[attr]);
1317 }
1318 
1319 /*----------------------------------------------------------------------------
1320  * Resize particle set buffers if needed.
1321  *
1322  * parameters:
1323  * n_particles <-- minumum number of particles required
1324  *
1325  *
1326  * returns:
1327  * 1 if resizing was required, 0 otherwise
1328  *----------------------------------------------------------------------------*/
1329 
1330 int
1331 cs_lagr_resize_particle_set(cs_lnum_t n_min_particles);
1332 
1333 /*----------------------------------------------------------------------------
1334  * Set reallocation factor for particle sets.
1335  *
1336  * This factor determines the multiplier used for reallocations when
1337  * the particle set's buffers are too small to handle the new number of
1338  * particles.
1339  *
1340  * parameters:
1341  * f <-- reallocation size multiplier
1342  *----------------------------------------------------------------------------*/
1343 
1344 void
1346 
1347 /*----------------------------------------------------------------------------
1348  * \brief Set global maximum number of particles.
1349  *
1350  * By default, the number is limited only by local cs_lnum_t and global
1351  * cs_gnum_t data representation limits.
1352  *
1353  * parameters:
1354  * n_g_particles_max <-- global maximum number of particles
1355 *----------------------------------------------------------------------------*/
1356 
1357 void
1358 cs_lagr_set_n_g_particles_max(unsigned long long n_g_particles_max);
1359 
1360 /*----------------------------------------------------------------------------
1361  * Dump a cs_lagr_particle_t structure
1362  *
1363  * parameters:
1364  * particles <-- cs_lagr_particle_t structure to dump
1365  *----------------------------------------------------------------------------*/
1366 
1367 void
1369 
1370 /*----------------------------------------------------------------------------*/
1371 
1373 
1374 #endif /* __CS_LAGR_TRACKING_H__ */
integer, save jdp2
pointer to particle extent for array ettp
Definition: lagran.f90:414
cs_lnum_t n_part_out
Definition: cs_lagr_tracking.h:173
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)
Set attribute value of type cs_gnum_t of a given particle at a given time.
Definition: cs_lagr_tracking.h:1161
cs_datatype_t
Definition: cs_defs.h:255
integer, save iencnbbd
Definition: lagran.f90:1193
Definition: cs_lagr_tracking.h:82
cs_lagr_particle_set_t * cs_lagr_get_particle_set(void)
Return pointer to the main cs_lagr_particle_set_t structure.
Definition: cs_lagr_tracking.c:5307
integer, save iflm
particle mass flow at the boundary faces
Definition: lagran.f90:1205
unsigned long cs_gnum_t
global mesh entity number
Definition: cs_defs.h:280
Definition: cs_lagr_tracking.h:75
integer, save jreps
pointer to particle emissivity for array pepa
Definition: lagran.f90:456
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)
Get attribute value of type cs_real_t of a given particle in a set.
Definition: cs_lagr_tracking.h:1186
cs_lnum_t n_part_fou
Definition: cs_lagr_tracking.h:175
integer, save jwf
pointer to locally undisturbed Z fluid velocity component for pointer eptp
Definition: lagran.f90:408
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)
Set attribute value of type cs_real_t of a given particle in a set.
Definition: cs_lagr_tracking.h:793
Definition: cs_lagr_tracking.h:83
integer, save jord1
Additional pointer in the IPEPA array (contains the particule state)
Definition: lagran.f90:269
integer, save jxp
pointer to particle X coordinate for pointer eptp
Definition: lagran.f90:389
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)
Get attribute value of type cs_real_t of a given particle in a set.
Definition: cs_lagr_tracking.h:743
Definition: cs_lagr_tracking.h:96
integer, save ihdepm
Definition: lagran.f90:1261
integer, save iencck
Definition: lagran.f90:1226
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)
Set attribute value of type cs_gnum_t of a given particle in a set.
Definition: cs_lagr_tracking.h:691
Definition: cs_lagr_tracking.h:109
integer, save jwp
pointer to particle Z velocity component for pointer eptp
Definition: lagran.f90:399
integer, dimension(nlayer), save jmch
pointer to mass of reactive coal of the coal particle for pointer eptp
Definition: lagran.f90:428
integer, save iencmabd
Definition: lagran.f90:1195
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)
Set attribute value of type cs_lnum_t of a given particle at a given time.
Definition: cs_lagr_tracking.h:1063
ptrdiff_t * source_term_displ
Definition: cs_lagr_tracking.h:153
integer, save iencdibd
Definition: lagran.f90:1197
int t_order
Definition: cs_lagr_tracking.h:217
Definition: cs_lagr_tracking.h:74
Definition: cs_lagr_tracking.h:121
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)
Get attribute value of type cs_real_t of a given particle at a given time.
Definition: cs_lagr_tracking.h:1211
Definition: cs_lagr_tracking.h:57
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)
Get attribute value of type cs_real_t of a given particle in a set at a given time.
Definition: cs_lagr_tracking.h:769
integer, save jdfac
Additional pointer in the IPEPA array (contains the particule state)
Definition: lagran.f90:263
integer, save jclst
pointer to class of the particle for ipepa array
Definition: lagran.f90:480
integer, save jisor
pointer to number of the current cell containing the particle for ipepa array; this number is re-actu...
Definition: lagran.f90:470
int physical_model
Definition: cs_lagr_tracking.h:203
Definition: cs_lagr_tracking.h:81
Definition: cs_lagr_tracking.h:113
integer, dimension(:), allocatable ifrlag
Definition: pointe.f90:388
Definition: cs_lagr_tracking.h:125
Definition: cs_lagr_tracking.h:51
integer, save jrd0p
pointer to coal particle initial diameter for array pepa
Definition: lagran.f90:459
integer, save jisora
pointer to number of the previous cell containing the particle for ipepa array
Definition: lagran.f90:473
#define BEGIN_C_DECLS
Definition: cs_defs.h:419
Definition: cs_lagr_tracking.h:84
int cs_int_t
Fortran-compatible integer.
Definition: cs_defs.h:295
Definition: cs_lagr_tracking.h:168
integer, save jzp
pointer to particle Z coordinate for pointer eptp
Definition: lagran.f90:393
integer, save ireent
Definition: lagran.f90:282
integer, save nvls
pointer to number of additional variables related to the particles for ipepa array. The additional variables can be accessed in the arrays eptp and eptpa by means of the pointer jvls: eptp(nbpt,jvls(ii)) and eptpa(nbpt,jvls(ii)) (nbpt is the index-number of the treated particle, and ii an integer between 1 and nvls)
Definition: lagran.f90:490
integer, save iclogh
Definition: lagran.f90:1257
Definition: cs_lagr_tracking.h:105
integer, save jmwat
pointer to water mass (for coal) for pointer eptp
Definition: lagran.f90:426
double precision, dimension(ncharm2), save enc1
encrustation data
Definition: lagran.f90:992
integer, save iphyla
activates (>0) or deactivates (=0) the physical models associated to the particles: ...
Definition: lagran.f90:210
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)
Set attribute value of type cs_gnum_t of a given particle.
Definition: cs_lagr_tracking.h:1136
integer, save jvf
pointer to locally undisturbed Y fluid velocity component for pointer eptp
Definition: lagran.f90:405
Definition: cs_lagr_tracking.h:80
int n_temperature_layers
Definition: cs_lagr_tracking.h:206
const cs_lagr_param_t * cs_glob_lagr_params
integer, save iencma
Definition: lagran.f90:1222
integer, save jrval
pointer to random number associated with a particle for array pepa
Definition: lagran.f90:447
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)
Set attribute value of type cs_gnum_t of a given particle in a set at a given time.
Definition: cs_lagr_tracking.h:717
integer, save jyp
pointer to particle Y coordinate for pointer eptp
Definition: lagran.f90:391
cs_real_t weight_fou
Definition: cs_lagr_tracking.h:181
integer, save idepst
Definition: lagran.f90:250
integer, save iclogst
Definition: lagran.f90:329
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)
Get attribute value of type cs_lnum_t of a given particle in a set.
Definition: cs_lagr_tracking.h:990
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)
Get data extents for a given particle attribute.
Definition: cs_lagr_tracking.c:5276
double precision, dimension(nflagm), save deblag
massic flow rate for a boudary zone
Definition: lagran.f90:603
integer, save jrinpf
Additional pointer in the IPEPA array (contains the particule state)
Definition: lagran.f90:267
integer, save injcon
activates (=1) or not (=0) the continuous injection of particles. this option allows to inject partic...
Definition: lagran.f90:509
const cs_lagr_attribute_map_t * p_am
Definition: cs_lagr_tracking.h:189
integer, save inbr
number of particle/boundary interactions
Definition: lagran.f90:1202
integer, save jrpoi
pointer to particle statistic weight for array pepa
Definition: lagran.f90:453
void getbdy(const cs_int_t *nflagm, const cs_int_t *nfrlag, const cs_int_t *injcon, const cs_int_t ilflag[], const cs_int_t iusncl[], const cs_int_t iusclb[], const cs_real_t deblag[], const cs_int_t ifrlag[])
Definition: cs_lagr_tracking.c:4880
integer, save jvp
pointer to particle Y velocity component for pointer eptp
Definition: lagran.f90:397
integer, save iencdi
Definition: lagran.f90:1224
Definition: cs_lagr_tracking.h:59
integer, save irough
Definition: lagran.f90:286
integer, save jimark
Additional pointer in the IPEPA array (contains the particule state)
Definition: lagran.f90:261
cs_real_t weight_failed
Definition: cs_lagr_tracking.h:182
Definition: cs_lagr_tracking.h:102
double precision tkelvi
Temperature in Kelvin correponding to 0 degrees Celsius (= +273,15)
Definition: cstphy.f90:44
cs_real_t weight_dep
Definition: cs_lagr_tracking.h:180
static void * cs_lagr_particle_attr(void *particle, const cs_lagr_attribute_map_t *attr_map, cs_lagr_attribute_t attr)
Get pointer to current attribute data of a particle.
Definition: cs_lagr_tracking.h:897
static cs_real_t * cs_lagr_particle_source_term(void *particle, const cs_lagr_attribute_map_t *attr_map, cs_lagr_attribute_t attr)
Get pointer to 2nd order scheme attribute source terms of a particle.
Definition: cs_lagr_tracking.h:1284
unsigned char * p_buffer
Definition: cs_lagr_tracking.h:191
void dplprt(cs_int_t *p_scheme_order, cs_real_t boundary_stat[], const cs_int_t *iensi3, const cs_int_t *inbr, const cs_int_t *inbrbd, const cs_int_t *iflm, const cs_int_t *iflmbd, const cs_int_t *iang, const cs_int_t *iangbd, const cs_int_t *ivit, const cs_int_t *ivitbd, const cs_int_t *iencnd, const cs_int_t *iencma, const cs_int_t *iencdi, const cs_int_t *iencck, const cs_int_t *iencnbbd, const cs_int_t *iencmabd, const cs_int_t *iencdibd, const cs_int_t *iencckbd, const cs_int_t *inclg, const cs_int_t *inclgt, const cs_int_t *iclogt, const cs_int_t *iclogh, const cs_int_t *iscovc, const cs_int_t *ihdepm, const cs_int_t *ihdepv, const cs_int_t *ihsum, const cs_int_t *nusbor, cs_int_t iusb[], cs_real_t visc_length[], cs_real_t dlgeo[], const cs_real_t tprenc[], const cs_real_t visref[], const cs_real_t enc1[], const cs_real_t enc2[], const cs_real_t *tkelvi)
Definition: cs_lagr_tracking.c:4949
integer, dimension(nusvar), save jvls
pointer to additional user variable for pointer eptp
Definition: lagran.f90:432
Definition: cs_lagr_tracking.h:90
integer, save nfrlag
number of boundary zones
Definition: lagran.f90:502
Definition: cs_lagr_tracking.h:117
int resuspension
Definition: cs_lagr_tracking.h:211
Definition: cs_lagr_tracking.h:55
Definition: cs_lagr_tracking.h:49
ptrdiff_t(* displ)[CS_LAGR_N_ATTRIBUTES]
Definition: cs_lagr_tracking.h:149
cs_real_t weight_out
Definition: cs_lagr_tracking.h:179
int deposition
Definition: cs_lagr_tracking.h:208
integer, dimension(nflagm), save iusncl
for all the nfrlag boundary zones previously identified, the number of classes nbclas (a class is a s...
Definition: lagran.f90:522
integer, save jcp
pointer to particle specific heat for pointer eptp
Definition: lagran.f90:422
integer, save inbrbd
activation (=1) or not (=0) of the recording of the number of particle/boundary interactions, and of the calculation of the associated boundary statistics. inbrbd = 1 is a compulsory condition to use the particulate average imoybr = 2. Useful if iensi3=1
Definition: lagran.f90:1165
integer, dimension(:), allocatable icocel
Definition: pointe.f90:387
Definition: cs_lagr_tracking.h:53
integer, save iang
mean interaction angle with the boundary faces
Definition: lagran.f90:1208
void cs_lagr_particle_set_dump(const cs_lagr_particle_set_t *particles)
Dump a cs_lagr_particle_t structure.
Definition: cs_lagr_tracking.c:5437
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)
Get pointer to attribute data of a given particle in a set at a given time.
Definition: cs_lagr_tracking.h:487
integer, save inclgt
Definition: lagran.f90:1255
int time_id
Definition: cs_lagr_tracking.h:170
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)
Get const pointer to current attribute data of a given particle in a set.
Definition: cs_lagr_tracking.h:461
integer, save juf
pointer to locally undisturbed X fluid velocity component for pointer eptp
Definition: lagran.f90:402
integer, save iclogt
Definition: lagran.f90:1256
int dlvo
Definition: cs_lagr_tracking.h:209
cs_lnum_t n_part_dep
Definition: cs_lagr_tracking.h:174
cs_lnum_t n_particles_max
Definition: cs_lagr_tracking.h:184
integer, save jtp
pointer to particle and locally undisturbed fluid flow temperature (Celsius) for pointer eptp ...
Definition: lagran.f90:417
integer, dimension(3), save jtsup
pointer to velocity prediction for second order in time for array pepa
Definition: lagran.f90:440
static void * cs_lagr_particles_attr(cs_lagr_particle_set_t *particle_set, cs_lnum_t particle_id, cs_lagr_attribute_t attr)
Get pointer to a current attribute of a given particle in a set.
Definition: cs_lagr_tracking.h:436
integer, save jnbpoi
Additional pointer in ITEPA and TEPA arrays (contains particule state)
Definition: lagran.f90:331
double precision, dimension(ncharm2), save enc2
encrustation data
Definition: lagran.f90:994
integer, dimension(3), save jtsuf
pointer to seen velocity prediction for second order in time for array pepa
Definition: lagran.f90:443
Definition: cs_lagr_tracking.h:67
Definition: cs_lagr_tracking.h:60
integer, dimension(nusbrd), save iusb
supplementary user boundary statistics
Definition: lagran.f90:1229
integer, save inclg
Definition: lagran.f90:1254
const char * cs_lagr_attribute_name[]
cs_lagr_attribute_t
Definition: cs_lagr_tracking.h:46
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)
Get pointer to 2nd order scheme source terms for an attribute of a given particle in a set...
Definition: cs_lagr_tracking.h:846
integer, save jnbasg
Additional pointer in IPEPA and PEPA arrays (contains particule state)
Definition: lagran.f90:295
Definition: cs_lagr_tracking.h:66
static const void * cs_lagr_particle_attr_const(const void *particle, const cs_lagr_attribute_map_t *attr_map, cs_lagr_attribute_t attr)
Get const pointer to current attribute data of a particle.
Definition: cs_lagr_tracking.h:919
void cs_lagr_destroy(void)
Delete particle set structure and other useful buffers.
Definition: cs_lagr_tracking.c:5319
integer, save nbclst
statistic per zone and per class
Definition: lagran.f90:838
integer, save jmfadh
Additional pointer in IPEPA and PEPA arrays (contains particule state)
Definition: lagran.f90:303
Definition: cs_lagr_tracking.h:48
integer, save jrtdep
Additional pointer in ITEPA and TEPA arrays (contains particule state)
Definition: lagran.f90:333
int cs_lagr_resize_particle_set(cs_lnum_t n_min_particles)
Resize particle set buffers if needed.
Definition: cs_lagr_tracking.c:5374
Definition: cs_lagr_tracking.h:101
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)
Set attribute value of type cs_real_t of a given particle at a given time.
Definition: cs_lagr_tracking.h:1259
integer, dimension(3), save jbx1
pointer to turbulence characteristics for second order in time for array pepa
Definition: lagran.f90:438
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)
Get attribute value of type cs_gnum_t of a given particle in a set.
Definition: cs_lagr_tracking.h:641
integer nlayer
maximal number of layer per coal particle
Definition: lagpar.f90:60
cs_lnum_t n_particles
Definition: cs_lagr_tracking.h:172
cs_lnum_t n_failed_part
Definition: cs_lagr_tracking.h:176
double precision, dimension(ncharm2), save visref
ash critical viscosity in , in the fouling model cf J.D. Watt et T. Fereday (J.Inst.Fuel, Vol.42-p99). Useful if iphyla = 2 and iencra = 1
Definition: lagran.f90:1005
integer, save jdp
pointer to particle diameter for pointer eptp
Definition: lagran.f90:412
Definition: cs_lagr_tracking.h:97
integer, save iencckbd
Definition: lagran.f90:1199
integer, save iscovc
Definition: lagran.f90:1259
integer, dimension(nflagm), save iusclb
for all the nfrlag boundary zones previously identified, a particle boundary condition type is given...
Definition: lagran.f90:568
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)
Get attribute value of type cs_lnum_t of a given particle in a set at a given time.
Definition: cs_lagr_tracking.h:565
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)
Get const pointer to attribute data of a particle at a given time.
Definition: cs_lagr_tracking.h:966
integer nflagm
maximal number of boundary zones
Definition: lagpar.f90:73
integer, dimension(nflagm), save ilflag
list of number of boundary zones
Definition: lagran.f90:512
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)
Get pointer to attribute data of a particle at a given time.
Definition: cs_lagr_tracking.h:942
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)
Get attribute value of type cs_gnum_t of a given particle in a set.
Definition: cs_lagr_tracking.h:1088
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:292
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)
Get attribute value of type cs_gnum_t of a given particle in a set at a given time.
Definition: cs_lagr_tracking.h:667
int n_time_vals
Definition: cs_lagr_tracking.h:137
struct _cs_lagr_tracking_list_t cs_lagr_tracking_list_t
Definition: cs_lagr_tracking.h:163
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)
Set attribute value of type cs_lnum_t of a given particle in a set.
Definition: cs_lagr_tracking.h:589
integer, dimension(nlayer), save jhp
pointer to coal particle temperature ( ) for pointer eptp
Definition: lagran.f90:424
integer, save jfadh
Additional pointer in IPEPA and PEPA arrays (contains particule state)
Definition: lagran.f90:301
integer, save jmp
pointer to particle mass for pointer eptp
Definition: lagran.f90:410
integer, save iangbd
activation (=1) or not (=0) of the recording of the angle between a particle trajectory and a boundar...
Definition: lagran.f90:1178
integer, save jtf
pointer to particle and locally undisturbed fluid flow temperature (Celsius) for pointer eptp ...
Definition: lagran.f90:420
Definition: cs_lagr_tracking.h:88
integer, dimension(nlayer), save jrhock
pointer to coal density for array pepa
Definition: lagran.f90:465
Definition: cs_lagr_tracking.h:95
Definition: cs_lagr_tracking.h:106
double precision, dimension(ncharm2), save tprenc
limit temperature (in degree Celsius) below which the coal particles do not cause any fouling (if the...
Definition: lagran.f90:999
#define END_C_DECLS
Definition: cs_defs.h:420
double cs_real_t
Definition: cs_defs.h:296
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)
Set attribute value of type cs_real_t of a given particle.
Definition: cs_lagr_tracking.h:1234
Definition: cs_lagr_tracking.h:76
Definition: cs_lagr_tracking.h:91
Definition: cs_lagr_tracking.h:58
size_t extents
Definition: cs_lagr_tracking.h:134
integer, save jrdck
pointer to coal particle shrinking core diameter for array pepa
Definition: lagran.f90:462
integer, save iflmbd
activation (=1) or not (=0) of the recording of the particulate mass flow related to the particle/bou...
Definition: lagran.f90:1172
Definition: cs_lagr_tracking.h:89
integer, save ihdepv
Definition: lagran.f90:1262
#define CS_PROCF(x, y)
Definition: cs_defs.h:443
int roughness
Definition: cs_lagr_tracking.h:210
integer, save ivitbd
activation (=1) or not (=0) of the recording of the velocity of a particle involved in a particle/bou...
Definition: lagran.f90:1184
integer, save nusbor
number additional user data to record for the calculation of additional boundary statistics in parbor...
Definition: lagran.f90:1131
Definition: cs_lagr_tracking.h:61
integer, save jirka
pointer to number of the previous rank containing the particle for ipepa array
Definition: lagran.f90:476
integer, save jrhcon
Additional pointer in ITEPA and TEPA arrays (contains particule state)
Definition: lagran.f90:335
integer, save jup
pointer to particle X velocity component for pointer eptp
Definition: lagran.f90:395
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)
Get attribute value of type cs_gnum_t of a given particle at a given time.
Definition: cs_lagr_tracking.h:1113
cs_real_t weight
Definition: cs_lagr_tracking.h:178
int n_user_variables
Definition: cs_lagr_tracking.h:215
Definition: cs_lagr_tracking.h:68
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)
Set attribute value of type cs_real_t of a given particle in a set at a given time.
Definition: cs_lagr_tracking.h:819
void cs_lagr_set_reallocation_factor(double f)
Set reallocation factor for particle sets.
Definition: cs_lagr_tracking.c:5405
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)
Get const pointer to attribute data of a given particle in a set at a given time. ...
Definition: cs_lagr_tracking.h:514
integer, save jryplu
Additional pointer in the IPEPA array (contains the particule state)
Definition: lagran.f90:265
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)
Get pointer to 2nd order scheme attribute source terms of a particle.
Definition: cs_lagr_tracking.h:1308
integer, save ivit
mean interaction velocity with the boundary faces
Definition: lagran.f90:1211
Definition: cs_lagr_tracking.h:73
int n_stat_classes
Definition: cs_lagr_tracking.h:214
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)
Get attribute value of type cs_lnum_t of a given particle at a given time.
Definition: cs_lagr_tracking.h:1015
Definition: cs_lagr_tracking.h:56
Definition: cs_lagr_tracking.h:103
Definition: cs_lagr_tracking.h:132
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)
Get attribute value of type cs_lnum_t of a given particle in a set.
Definition: cs_lagr_tracking.h:539
integer, save jdepo
Additional pointer in IPEPA and PEPA arrays (contains particule state)
Definition: lagran.f90:299
void cs_lagr_set_n_g_particles_max(unsigned long long n_g_particles_max)
Set global maximum number of particles.
Definition: cs_lagr_tracking.c:5423
integer, dimension(nlayer), save jmck
pointer to mass of coke of the coal particle for pointer eptp
Definition: lagran.f90:430
Definition: cs_lagr_tracking.h:62
cs_lnum_t first_free_id
Definition: cs_lagr_tracking.h:187
integer, save jndisp
Additional pointer in IPEPA and PEPA arrays (contains particule state)
Definition: lagran.f90:305
integer, save jtaux
pointer to work array for the second order in time for pointer pepa
Definition: lagran.f90:435
integer, dimension(:), allocatable itycel
Definition: pointe.f90:387
integer, save nordre
order of integration for the stochastic differential equations
Definition: lagran.f90:1084
cs_lagr_tracking_list_t * used_id
Definition: cs_lagr_tracking.h:193
integer, save jinch
pointer to number of the coal particle for ipepa array
Definition: lagran.f90:478
Definition: cs_lagr_tracking.h:108
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)
Get const pointer to 2nd order scheme source terms an attribute of a given particle in a set...
Definition: cs_lagr_tracking.h:872
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)
Set attribute value of type cs_lnum_t of a given particle in a set at a given time.
Definition: cs_lagr_tracking.h:615
integer, save iensi3
Definition: lagran.f90:1313
integer, save ihsum
Definition: lagran.f90:1264
cs_lnum_t first_used_id
Definition: cs_lagr_tracking.h:186
integer, save idlvo
Definition: lagran.f90:254
integer, save jnbasp
Additional pointer in IPEPA and PEPA arrays (contains particule state)
Definition: lagran.f90:297
void lagbeg(const cs_int_t *nordre, const cs_int_t *nlayer, const cs_int_t *iphyla, const cs_int_t *idepst, const cs_int_t *idlvo, const cs_int_t *irough, const cs_int_t *ireent, const cs_int_t *iclogst, const cs_int_t *nvls, const cs_int_t *nbclst, cs_lnum_t icocel[], cs_lnum_t itycel[], cs_int_t *jisor, cs_int_t *jisora, cs_int_t *jirka, cs_int_t *jord1, cs_int_t *jrval, cs_int_t *jrpoi, cs_int_t *jrtsp, cs_int_t *jdp, cs_int_t *jmp, cs_int_t *jxp, cs_int_t *jyp, cs_int_t *jzp, cs_int_t *jup, cs_int_t *jvp, cs_int_t *jwp, cs_int_t *juf, cs_int_t *jvf, cs_int_t *jwf, cs_int_t *jtaux, cs_int_t jbx1[3], cs_int_t jtsup[3], cs_int_t jtsuf[3], cs_int_t *jryplu, cs_int_t *jrinpf, cs_int_t *jdfac, cs_int_t *jimark, cs_int_t *jtp, cs_int_t jhp[], cs_int_t *jtf, cs_int_t *jmwat, cs_int_t jmch[], cs_int_t jmck[], cs_int_t *jcp, cs_int_t *jrdck, cs_int_t *jrd0p, cs_int_t *jinch, cs_int_t jrhock[], cs_int_t *jreps, cs_int_t *jdepo, cs_int_t *jnbasg, cs_int_t *jnbasp, cs_int_t *jfadh, cs_int_t *jmfadh, cs_int_t *jndisp, cs_int_t *jclst, cs_int_t *jvls, cs_int_t *jdp2, cs_int_t *jnbpoi, cs_int_t *jrtdep, cs_int_t *jrhcon)
Definition: cs_lagr_tracking.c:4353
Definition: cs_lagr_tracking.h:72
integer, save jrtsp
pointer to particle residence time for array pepa
Definition: lagran.f90:450
double precision, dimension(:,:), pointer dlgeo
Definition: pointe.f90:395
int clogging
Definition: cs_lagr_tracking.h:212
int(* count)[CS_LAGR_N_ATTRIBUTES]
Definition: cs_lagr_tracking.h:146
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)
Set attribute value of type cs_lnum_t of a given particle.
Definition: cs_lagr_tracking.h:1038
Definition: cs_lagr_tracking.h:201