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 /* Particle set */
161 /* ------------ */
162 
163 typedef struct {
164 
165  int time_id; /* 0 for current time,
166  -1 for previous */
172 
178 
180 
181  const cs_lagr_attribute_map_t *p_am; /* particle attributes maps
182  (p_am + i for time n-i) */
183  unsigned char *p_buffer; /* Particles data buffer */
184 
186 
187 /* Global parameters for Lagrangian module */
188 /*-----------------------------------------*/
189 
190 typedef struct {
191 
192  int physical_model; /* FIXME: => enum: CS_LAGR_PHYS_STD,
193  CS_LAGR_PHYS_COAL,
194  CS_LAGR_PHYS_HEAT... */
196 
198  int dlvo;
201  int clogging;
202 
205 
206  int t_order; /* Algorithm order in time */
207 
209 
210 /*=============================================================================
211  * Global variables
212  *============================================================================*/
213 
214 extern const char *cs_lagr_attribute_name[];
215 
216 /* Pointer to global Lagragian module parameters */
217 
219 
220 /*============================================================================
221  * Public function prototypes for Fortran API
222  *============================================================================*/
223 
224 /*----------------------------------------------------------------------------
225  * Allocate cs_lagr_particle_set_t structure and initialize useful buffers
226  * and indexes
227  *
228  * parameters:
229  * nordre <-- time algorithm order (1 or 2)
230  * iphyla <-- kind of physics used for the lagrangian approach
231  * nvls <-- number of user-defined variables
232  * nbclst <-- number of stat. class to study sub-set of particles
233  * ...
234  *----------------------------------------------------------------------------*/
235 
236 void
237 CS_PROCF (lagbeg, LAGBEG)(const cs_int_t *nordre,
238  const cs_int_t *nlayer,
239  const cs_int_t *iphyla,
240  const cs_int_t *idepst,
241  const cs_int_t *idlvo,
242  const cs_int_t *irough,
243  const cs_int_t *ireent,
244  const cs_int_t *iclogst,
245  const cs_int_t *nvls,
246  const cs_int_t *nbclst,
247  cs_lnum_t icocel[],
248  cs_lnum_t itycel[],
249  cs_int_t *jisor,
250  cs_int_t *jisora,
251  cs_int_t *jirka,
252  cs_int_t *jord1,
253  cs_int_t *jrval,
254  cs_int_t *jrpoi,
255  cs_int_t *jrtsp,
256  cs_int_t *jdp,
257  cs_int_t *jmp,
258  cs_int_t *jxp,
259  cs_int_t *jyp,
260  cs_int_t *jzp,
261  cs_int_t *jup,
262  cs_int_t *jvp,
263  cs_int_t *jwp,
264  cs_int_t *juf,
265  cs_int_t *jvf,
266  cs_int_t *jwf,
267  cs_int_t *jtaux,
268  cs_int_t jbx1[3],
269  cs_int_t jtsup[3],
270  cs_int_t jtsuf[3],
271  cs_int_t *jryplu,
272  cs_int_t *jrinpf,
273  cs_int_t *jdfac,
274  cs_int_t *jimark,
275  cs_int_t *jtp,
276  cs_int_t jhp[],
277  cs_int_t *jtf,
278  cs_int_t *jmwat,
279  cs_int_t jmch[],
280  cs_int_t jmck[],
281  cs_int_t *jcp,
282  cs_int_t *jrdck,
283  cs_int_t *jrd0p,
284  cs_int_t *jinch,
285  cs_int_t jrhock[],
286  cs_int_t *jreps,
287  cs_int_t *jdepo,
288  cs_int_t *jnbasg,
289  cs_int_t *jnbasp,
290  cs_int_t *jfadh,
291  cs_int_t *jmfadh,
292  cs_int_t *jndisp,
293  cs_int_t *jclst,
294  cs_int_t *jvls,
295  cs_int_t *jdp2,
296  cs_int_t *jnbpoi,
297  cs_int_t *jrtdep,
299  );
300 
301 /*----------------------------------------------------------------------------
302  * Get variables and parameters associated to each particles and keep it in
303  * a new structure
304  *
305  * parameters:
306  * ...
307  *----------------------------------------------------------------------------*/
308 
309 void
310 CS_PROCF (getbdy, GETBDY)(const cs_int_t *nflagm,
311  const cs_int_t *nfrlag,
312  const cs_int_t *injcon,
313  const cs_int_t ilflag[],
314  const cs_int_t iusncl[],
315  const cs_int_t iusclb[],
316  const cs_real_t deblag[],
317  const cs_int_t ifrlag[]);
318 
319 /*----------------------------------------------------------------------------
320  * Displacement of particles.
321  *
322  * parameters:
323  * scheme_order <-- current order of the scheme used for Lagragian
324  *----------------------------------------------------------------------------*/
325 
326 void
327 CS_PROCF (dplprt, DPLPRT)(cs_int_t *p_scheme_order,
328  cs_real_t boundary_stat[],
329  const cs_int_t *iensi3,
330  const cs_int_t *inbr,
331  const cs_int_t *inbrbd,
332  const cs_int_t *iflm,
333  const cs_int_t *iflmbd,
334  const cs_int_t *iang,
335  const cs_int_t *iangbd,
336  const cs_int_t *ivit,
337  const cs_int_t *ivitbd,
338  const cs_int_t *iencnd,
339  const cs_int_t *iencma,
340  const cs_int_t *iencdi,
341  const cs_int_t *iencck,
342  const cs_int_t *iencnbbd,
343  const cs_int_t *iencmabd,
344  const cs_int_t *iencdibd,
345  const cs_int_t *iencckbd,
346  const cs_int_t *inclg,
347  const cs_int_t *inclgt,
348  const cs_int_t *iscovc,
349  const cs_int_t *ihdepm,
350  const cs_int_t *ihdepv,
351  const cs_int_t *ihsum,
352  const cs_int_t *nusbor,
353  cs_int_t iusb[],
354  cs_real_t visc_length[],
355  cs_real_t dlgeo[],
356  const cs_real_t tprenc[],
357  const cs_real_t visref[],
358  const cs_real_t enc1[],
359  const cs_real_t enc2[],
360  const cs_real_t *tkelvi);
361 
362 /*============================================================================
363  * Public function prototypes
364  *============================================================================*/
365 
366 /*----------------------------------------------------------------------------
367  * Get data access information for a given particle attribute.
368  *
369  * For attributes not currently present, the displacement and data
370  * size should be -1 and 0 respectively.
371  *
372  * parameters:
373  * particles <-- associated particle set
374  * time_id <-- associated time id (0: current, 1: previous)
375  * attr <-- particle attribute
376  * extents --> size (in bytes) of particle structure, or NULL
377  * size --> size (in bytes) of attribute in particle structure, or NULL
378  * displ --> displacement (in bytes) in particle structure, or NULL
379  * datatype --> associated datatype, or NULL
380  * count --> associated elements count, or NULL
381  *----------------------------------------------------------------------------*/
382 
383 void
385  int time_id,
386  cs_lagr_attribute_t attr,
387  size_t *extents,
388  size_t *size,
389  ptrdiff_t *displ,
390  cs_datatype_t *datatype,
391  int *count);
392 
393 /*----------------------------------------------------------------------------
394  * Return pointer to the main cs_lagr_particle_set_t structure.
395  *
396  * returns:
397  * pointer to current particle set, or NULL
398  *----------------------------------------------------------------------------*/
399 
402 
403 /*----------------------------------------------------------------------------
404  * Delete particle set structure and other useful buffers.
405  *----------------------------------------------------------------------------*/
406 
407 void
408 cs_lagr_destroy(void);
409 
410 /*----------------------------------------------------------------------------*/
420 /*----------------------------------------------------------------------------*/
421 
422 inline static void *
424  cs_lnum_t particle_id,
425  cs_lagr_attribute_t attr)
426 {
427  assert(particle_set->p_am->count[0][attr] > 0);
428 
429  return (unsigned char *)particle_set->p_buffer
430  + particle_set->p_am->extents*particle_id
431  + particle_set->p_am->displ[0][attr];
432 }
433 
434 /*----------------------------------------------------------------------------*/
445 /*----------------------------------------------------------------------------*/
446 
447 inline static const void *
449  cs_lnum_t particle_id,
450  cs_lagr_attribute_t attr)
451 {
452  assert(particle_set->p_am->count[0][attr] > 0);
453 
454  return particle_set->p_buffer
455  + particle_set->p_am->extents*particle_id
456  + particle_set->p_am->displ[0][attr];
457 }
458 
459 /*----------------------------------------------------------------------------*/
471 /*----------------------------------------------------------------------------*/
472 
473 inline static void *
475  cs_lnum_t particle_id,
476  int time_id,
477  cs_lagr_attribute_t attr)
478 {
479  assert(particle_set->p_am->count[time_id][attr] > 0);
480 
481  return particle_set->p_buffer
482  + particle_set->p_am->extents*particle_id
483  + particle_set->p_am->displ[time_id][attr];
484 }
485 
486 /*----------------------------------------------------------------------------*/
498 /*----------------------------------------------------------------------------*/
499 
500 inline static const void *
502  cs_lnum_t particle_id,
503  int time_id,
504  cs_lagr_attribute_t attr)
505 {
506  assert(particle_set->p_am->count[time_id][attr] > 0);
507 
508  return particle_set->p_buffer
509  + particle_set->p_am->extents*particle_id
510  + particle_set->p_am->displ[time_id][attr];
511 }
512 
513 /*----------------------------------------------------------------------------*/
523 /*----------------------------------------------------------------------------*/
524 
525 inline static cs_lnum_t
527  cs_lnum_t particle_id,
528  cs_lagr_attribute_t attr)
529 {
530  assert(particle_set->p_am->count[0][attr] > 0);
531 
532  return *((const cs_lnum_t *)( particle_set->p_buffer
533  + particle_set->p_am->extents*particle_id
534  + particle_set->p_am->displ[0][attr]));
535 }
536 
537 /*----------------------------------------------------------------------------*/
549 /*----------------------------------------------------------------------------*/
550 
551 inline static cs_lnum_t
553  cs_lnum_t particle_id,
554  int time_id,
555  cs_lagr_attribute_t attr)
556 {
557  assert(particle_set->p_am->count[time_id][attr] > 0);
558 
559  return *((const cs_lnum_t *)( particle_set->p_buffer
560  + particle_set->p_am->extents*particle_id
561  + particle_set->p_am->displ[time_id][attr]));
562 }
563 
564 /*----------------------------------------------------------------------------*/
573 /*----------------------------------------------------------------------------*/
574 
575 inline static void
577  cs_lnum_t particle_id,
578  cs_lagr_attribute_t attr,
579  cs_lnum_t value)
580 {
581  assert(particle_set->p_am->count[0][attr] > 0);
582 
583  *((cs_lnum_t *)( particle_set->p_buffer
584  + particle_set->p_am->extents*particle_id
585  + particle_set->p_am->displ[0][attr])) = value;
586 }
587 
588 /*----------------------------------------------------------------------------*/
599 /*----------------------------------------------------------------------------*/
600 
601 inline static void
603  cs_lnum_t particle_id,
604  int time_id,
605  cs_lagr_attribute_t attr,
606  cs_lnum_t value)
607 {
608  assert(particle_set->p_am->count[time_id][attr] > 0);
609 
610  *((cs_lnum_t *)( particle_set->p_buffer
611  + particle_set->p_am->extents*particle_id
612  + particle_set->p_am->displ[time_id][attr])) = value;
613 }
614 
615 /*----------------------------------------------------------------------------*/
625 /*----------------------------------------------------------------------------*/
626 
627 inline static cs_gnum_t
629  cs_lnum_t particle_id,
630  cs_lagr_attribute_t attr)
631 {
632  assert(particle_set->p_am->count[0][attr] > 0);
633 
634  return *((const cs_gnum_t *)( particle_set->p_buffer
635  + particle_set->p_am->extents*particle_id
636  + particle_set->p_am->displ[0][attr]));
637 }
638 
639 /*----------------------------------------------------------------------------*/
651 /*----------------------------------------------------------------------------*/
652 
653 inline static cs_gnum_t
655  cs_lnum_t particle_id,
656  int time_id,
657  cs_lagr_attribute_t attr)
658 {
659  assert(particle_set->p_am->count[time_id][attr] > 0);
660 
661  return *((const cs_gnum_t *)( particle_set->p_buffer
662  + particle_set->p_am->extents*particle_id
663  + particle_set->p_am->displ[time_id][attr]));
664 }
665 
666 /*----------------------------------------------------------------------------*/
675 /*----------------------------------------------------------------------------*/
676 
677 inline static void
679  cs_lnum_t particle_id,
680  cs_lagr_attribute_t attr,
681  cs_gnum_t value)
682 {
683  assert(particle_set->p_am->count[0][attr] > 0);
684 
685  *((cs_gnum_t *)( particle_set->p_buffer
686  + particle_set->p_am->extents*particle_id
687  + particle_set->p_am->displ[0][attr])) = value;
688 }
689 
690 /*----------------------------------------------------------------------------*/
701 /*----------------------------------------------------------------------------*/
702 
703 inline static void
705  cs_lnum_t particle_id,
706  int time_id,
707  cs_lagr_attribute_t attr,
708  cs_gnum_t value)
709 {
710  assert(particle_set->p_am->count[time_id][attr] > 0);
711 
712  *((cs_gnum_t *)( particle_set->p_buffer
713  + particle_set->p_am->extents*particle_id
714  + particle_set->p_am->displ[time_id][attr])) = value;
715 }
716 
717 /*----------------------------------------------------------------------------*/
727 /*----------------------------------------------------------------------------*/
728 
729 inline static cs_real_t
731  cs_lnum_t particle_id,
732  cs_lagr_attribute_t attr)
733 {
734  assert(particle_set->p_am->count[0][attr] > 0);
735 
736  return *((const cs_real_t *)( particle_set->p_buffer
737  + particle_set->p_am->extents*particle_id
738  + particle_set->p_am->displ[0][attr]));
739 }
740 
741 /*----------------------------------------------------------------------------*/
753 /*----------------------------------------------------------------------------*/
754 
755 inline static cs_real_t
757  cs_lnum_t particle_id,
758  int time_id,
759  cs_lagr_attribute_t attr)
760 {
761  assert(particle_set->p_am->count[time_id][attr] > 0);
762 
763  return *((const cs_real_t *)( particle_set->p_buffer
764  + particle_set->p_am->extents*particle_id
765  + particle_set->p_am->displ[time_id][attr]));
766 }
767 
768 /*----------------------------------------------------------------------------*/
777 /*----------------------------------------------------------------------------*/
778 
779 inline static void
781  cs_lnum_t particle_id,
782  cs_lagr_attribute_t attr,
783  cs_real_t value)
784 {
785  assert(particle_set->p_am->count[0][attr] > 0);
786 
787  *((cs_real_t *)( particle_set->p_buffer
788  + particle_set->p_am->extents*particle_id
789  + particle_set->p_am->displ[0][attr])) = value;
790 }
791 
792 /*----------------------------------------------------------------------------*/
803 /*----------------------------------------------------------------------------*/
804 
805 inline static void
807  cs_lnum_t particle_id,
808  int time_id,
809  cs_lagr_attribute_t attr,
810  cs_real_t value)
811 {
812  assert(particle_set->p_am->count[time_id][attr] > 0);
813 
814  *((cs_real_t *)( particle_set->p_buffer
815  + particle_set->p_am->extents*particle_id
816  + particle_set->p_am->displ[time_id][attr])) = value;
817 }
818 
819 /*----------------------------------------------------------------------------*/
830 /*----------------------------------------------------------------------------*/
831 
832 inline static cs_real_t *
834  cs_lnum_t particle_id,
835  cs_lagr_attribute_t attr)
836 {
837  assert(particle_set->p_am->source_term_displ != NULL);
838  assert(particle_set->p_am->source_term_displ[attr] >= 0);
839 
840  return (cs_real_t *)( (unsigned char *)particle_set->p_buffer
841  + particle_set->p_am->extents*particle_id
842  + particle_set->p_am->source_term_displ[attr]);
843 }
844 
845 /*----------------------------------------------------------------------------*/
856 /*----------------------------------------------------------------------------*/
857 
858 inline static const cs_real_t *
860  cs_lnum_t particle_id,
861  cs_lagr_attribute_t attr)
862 {
863  assert(particle_set->p_am->source_term_displ != NULL);
864  assert(particle_set->p_am->source_term_displ[attr] >= 0);
865 
866  return (const cs_real_t *)( (unsigned char *)particle_set->p_buffer
867  + particle_set->p_am->extents*particle_id
868  + particle_set->p_am->source_term_displ[attr]);
869 }
870 
871 /*----------------------------------------------------------------------------*/
881 /*----------------------------------------------------------------------------*/
882 
883 inline static void *
884 cs_lagr_particle_attr(void *particle,
885  const cs_lagr_attribute_map_t *attr_map,
886  cs_lagr_attribute_t attr)
887 {
888  assert(attr_map->count[0][attr] > 0);
889 
890  return (unsigned char *)particle + attr_map->displ[0][attr];
891 }
892 
893 /*----------------------------------------------------------------------------*/
903 /*----------------------------------------------------------------------------*/
904 
905 inline static const void *
906 cs_lagr_particle_attr_const(const void *particle,
907  const cs_lagr_attribute_map_t *attr_map,
908  cs_lagr_attribute_t attr)
909 {
910  assert(attr_map->count[0][attr] > 0);
911 
912  return (const unsigned char *)particle + attr_map->displ[0][attr];
913 }
914 
915 /*----------------------------------------------------------------------------*/
926 /*----------------------------------------------------------------------------*/
927 
928 inline static void *
929 cs_lagr_particle_attr_n(void *particle,
930  const cs_lagr_attribute_map_t *attr_map,
931  int time_id,
932  cs_lagr_attribute_t attr)
933 {
934  assert(attr_map->count[time_id][attr] > 0);
935 
936  return (unsigned char *)particle + attr_map->displ[time_id][attr];
937 }
938 
939 /*----------------------------------------------------------------------------*/
950 /*----------------------------------------------------------------------------*/
951 
952 inline static const void *
953 cs_lagr_particle_attr_n_const(const void *particle,
954  const cs_lagr_attribute_map_t *attr_map,
955  int time_id,
956  cs_lagr_attribute_t attr)
957 {
958  assert(attr_map->count[time_id][attr] > 0);
959 
960  return (const unsigned char *)particle
961  + attr_map->displ[time_id][attr];
962 }
963 
964 /*----------------------------------------------------------------------------*/
974 /*----------------------------------------------------------------------------*/
975 
976 inline static cs_lnum_t
977 cs_lagr_particle_get_lnum(const void *particle,
978  const cs_lagr_attribute_map_t *attr_map,
979  cs_lagr_attribute_t attr)
980 {
981  assert(attr_map->count[0][attr] > 0);
982 
983  return *((const cs_lnum_t *)( (const unsigned char *)particle
984  + attr_map->displ[0][attr]));
985 }
986 
987 /*----------------------------------------------------------------------------*/
999 /*----------------------------------------------------------------------------*/
1000 
1001 inline static cs_lnum_t
1002 cs_lagr_particle_get_lnum_n(const void *particle,
1003  const cs_lagr_attribute_map_t *attr_map,
1004  int time_id,
1005  cs_lagr_attribute_t attr)
1006 {
1007  assert(attr_map->count[time_id][attr] > 0);
1008 
1009  return *((const cs_lnum_t *)( (const unsigned char *)particle
1010  + attr_map->displ[time_id][attr]));
1011 }
1012 
1013 /*----------------------------------------------------------------------------*/
1022  /*----------------------------------------------------------------------------*/
1023 
1024 inline static void
1026  const cs_lagr_attribute_map_t *attr_map,
1027  cs_lagr_attribute_t attr,
1028  cs_lnum_t value)
1029 {
1030  assert(attr_map->count[0][attr] > 0);
1031 
1032  *((cs_lnum_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
1033  = value;
1034 }
1035 
1036 /*----------------------------------------------------------------------------*/
1047  /*----------------------------------------------------------------------------*/
1048 
1049 inline static void
1051  const cs_lagr_attribute_map_t *attr_map,
1052  int time_id,
1053  cs_lagr_attribute_t attr,
1054  cs_lnum_t value)
1055 {
1056  assert(attr_map->count[time_id][attr] > 0);
1057 
1058  *((cs_lnum_t *)( (unsigned char *)particle
1059  + attr_map->displ[time_id][attr])) = value;
1060 }
1061 
1062 /*----------------------------------------------------------------------------*/
1072 /*----------------------------------------------------------------------------*/
1073 
1074 inline static cs_gnum_t
1075 cs_lagr_particle_get_gnum(const void *particle,
1076  const cs_lagr_attribute_map_t *attr_map,
1077  cs_lagr_attribute_t attr)
1078 {
1079  assert(attr_map->count[0][attr] > 0);
1080 
1081  return *((const cs_gnum_t *)( (const unsigned char *)particle
1082  + attr_map->displ[0][attr]));
1083 }
1084 
1085 /*----------------------------------------------------------------------------*/
1097 /*----------------------------------------------------------------------------*/
1098 
1099 inline static cs_gnum_t
1100 cs_lagr_particle_get_gnum_n(const void *particle,
1101  const cs_lagr_attribute_map_t *attr_map,
1102  int time_id,
1103  cs_lagr_attribute_t attr)
1104 {
1105  assert(attr_map->count[time_id][attr] > 0);
1106 
1107  return *((const cs_gnum_t *)( (const unsigned char *)particle
1108  + attr_map->displ[time_id][attr]));
1109 }
1110 
1111 /*----------------------------------------------------------------------------*/
1120  /*----------------------------------------------------------------------------*/
1121 
1122 inline static void
1124  const cs_lagr_attribute_map_t *attr_map,
1125  cs_lagr_attribute_t attr,
1126  cs_gnum_t value)
1127 {
1128  assert(attr_map->count[0][attr] > 0);
1129 
1130  *((cs_gnum_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
1131  = value;
1132 }
1133 
1134 /*----------------------------------------------------------------------------*/
1145  /*----------------------------------------------------------------------------*/
1146 
1147 inline static void
1149  const cs_lagr_attribute_map_t *attr_map,
1150  int time_id,
1151  cs_lagr_attribute_t attr,
1152  cs_gnum_t value)
1153 {
1154  assert(attr_map->count[time_id][attr] > 0);
1155 
1156  *((cs_gnum_t *)( (unsigned char *)particle
1157  + attr_map->displ[time_id][attr])) = value;
1158 }
1159 
1160 /*----------------------------------------------------------------------------*/
1170 /*----------------------------------------------------------------------------*/
1171 
1172 inline static cs_real_t
1173 cs_lagr_particle_get_real(const void *particle,
1174  const cs_lagr_attribute_map_t *attr_map,
1175  cs_lagr_attribute_t attr)
1176 {
1177  assert(attr_map->count[0][attr] > 0);
1178 
1179  return *((const cs_real_t *)( (const unsigned char *)particle
1180  + attr_map->displ[0][attr]));
1181 }
1182 
1183 /*----------------------------------------------------------------------------*/
1195 /*----------------------------------------------------------------------------*/
1196 
1197 inline static cs_real_t
1198 cs_lagr_particle_get_real_n(const void *particle,
1199  const cs_lagr_attribute_map_t *attr_map,
1200  int time_id,
1201  cs_lagr_attribute_t attr)
1202 {
1203  assert(attr_map->count[time_id][attr] > 0);
1204 
1205  return *((const cs_real_t *)( (const unsigned char *)particle
1206  + attr_map->displ[time_id][attr]));
1207 }
1208 
1209 /*----------------------------------------------------------------------------*/
1218  /*----------------------------------------------------------------------------*/
1219 
1220 inline static void
1222  const cs_lagr_attribute_map_t *attr_map,
1223  cs_lagr_attribute_t attr,
1224  cs_real_t value)
1225 {
1226  assert(attr_map->count[0][attr] > 0);
1227 
1228  *((cs_real_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
1229  = value;
1230 }
1231 
1232 /*----------------------------------------------------------------------------*/
1243  /*----------------------------------------------------------------------------*/
1244 
1245 inline static void
1247  const cs_lagr_attribute_map_t *attr_map,
1248  int time_id,
1249  cs_lagr_attribute_t attr,
1250  cs_real_t value)
1251 {
1252  assert(attr_map->count[time_id][attr] > 0);
1253 
1254  *((cs_real_t *)( (unsigned char *)particle
1255  + attr_map->displ[time_id][attr])) = value;
1256 }
1257 
1258 /*----------------------------------------------------------------------------*/
1268 /*----------------------------------------------------------------------------*/
1269 
1270 inline static cs_real_t *
1272  const cs_lagr_attribute_map_t *attr_map,
1273  cs_lagr_attribute_t attr)
1274 {
1275  assert(attr_map->source_term_displ != NULL);
1276  assert(attr_map->source_term_displ[attr] >= 0);
1277 
1278  return (cs_real_t *)( (unsigned char *)particle
1279  + attr_map->source_term_displ[attr]);
1280 }
1281 
1282 /*----------------------------------------------------------------------------*/
1292 /*----------------------------------------------------------------------------*/
1293 
1294 inline static const cs_real_t *
1296  const cs_lagr_attribute_map_t *attr_map,
1297  cs_lagr_attribute_t attr)
1298 {
1299  assert(attr_map->source_term_displ != NULL);
1300  assert(attr_map->source_term_displ[attr] >= 0);
1301 
1302  return (const cs_real_t *)( (unsigned char *)particle
1303  + attr_map->source_term_displ[attr]);
1304 }
1305 
1306 /*----------------------------------------------------------------------------
1307  * Resize particle set buffers if needed.
1308  *
1309  * parameters:
1310  * n_particles <-- minumum number of particles required
1311  *
1312  *
1313  * returns:
1314  * 1 if resizing was required, 0 otherwise
1315  *----------------------------------------------------------------------------*/
1316 
1317 int
1318 cs_lagr_resize_particle_set(cs_lnum_t n_min_particles);
1319 
1320 /*----------------------------------------------------------------------------
1321  * Set reallocation factor for particle sets.
1322  *
1323  * This factor determines the multiplier used for reallocations when
1324  * the particle set's buffers are too small to handle the new number of
1325  * particles.
1326  *
1327  * parameters:
1328  * f <-- reallocation size multiplier
1329  *----------------------------------------------------------------------------*/
1330 
1331 void
1333 
1334 /*----------------------------------------------------------------------------
1335  * \brief Set global maximum number of particles.
1336  *
1337  * By default, the number is limited only by local cs_lnum_t and global
1338  * cs_gnum_t data representation limits.
1339  *
1340  * parameters:
1341  * n_g_particles_max <-- global maximum number of particles
1342 *----------------------------------------------------------------------------*/
1343 
1344 void
1345 cs_lagr_set_n_g_particles_max(unsigned long long n_g_particles_max);
1346 
1347 /*----------------------------------------------------------------------------
1348  * Dump a cs_lagr_particle_t structure
1349  *
1350  * parameters:
1351  * particles <-- cs_lagr_particle_t structure to dump
1352  *----------------------------------------------------------------------------*/
1353 
1354 void
1356 
1357 /*----------------------------------------------------------------------------*/
1358 
1360 
1361 #endif /* __CS_LAGR_TRACKING_H__ */
integer, save jdp2
pointer to particle extent for array eptp
Definition: lagran.f90:444
cs_lnum_t n_part_out
Definition: cs_lagr_tracking.h:168
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 *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:4813
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:1148
cs_datatype_t
Definition: cs_defs.h:255
integer, save iencnbbd
Definition: lagran.f90:1243
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:5095
integer, save iflm
particle mass flow at the boundary faces
Definition: lagran.f90:1255
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:486
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:1173
cs_lnum_t n_part_fou
Definition: cs_lagr_tracking.h:170
integer, save jwf
pointer to locally undisturbed Z fluid velocity component for pointer eptp
Definition: lagran.f90:438
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:780
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:419
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:730
Definition: cs_lagr_tracking.h:96
integer, save ihdepm
Definition: lagran.f90:1311
integer, save iencck
Definition: lagran.f90:1276
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:678
Definition: cs_lagr_tracking.h:109
integer, save jwp
pointer to particle Z velocity component for pointer eptp
Definition: lagran.f90:429
integer, dimension(nlayer), save jmch
pointer to mass of reactive coal of the coal particle for pointer eptp
Definition: lagran.f90:458
integer, save iencmabd
Definition: lagran.f90:1245
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:1050
ptrdiff_t * source_term_displ
Definition: cs_lagr_tracking.h:153
integer, save iencdibd
Definition: lagran.f90:1247
int t_order
Definition: cs_lagr_tracking.h:206
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:1198
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:756
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:510
integer, save jisor
pointer to number of the current cell containing the particle for ipepa array; this number is re-actu...
Definition: lagran.f90:500
int physical_model
Definition: cs_lagr_tracking.h:192
Definition: cs_lagr_tracking.h:81
Definition: cs_lagr_tracking.h:113
integer, dimension(:), allocatable ifrlag
Definition: pointe.f90:378
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:489
integer, save jisora
pointer to number of the previous cell containing the particle for ipepa array
Definition: lagran.f90:503
#define BEGIN_C_DECLS
Definition: cs_defs.h:429
Definition: cs_lagr_tracking.h:84
int cs_int_t
Fortran-compatible integer.
Definition: cs_defs.h:295
Definition: cs_lagr_tracking.h:163
integer, save jzp
pointer to particle Z coordinate for pointer eptp
Definition: lagran.f90:423
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:520
Definition: cs_lagr_tracking.h:105
integer, save jmwat
pointer to water mass (for coal) for pointer eptp
Definition: lagran.f90:456
double precision, dimension(ncharm2), save enc1
encrustation data
Definition: lagran.f90:1022
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:1123
integer, save jvf
pointer to locally undisturbed Y fluid velocity component for pointer eptp
Definition: lagran.f90:435
Definition: cs_lagr_tracking.h:80
int n_temperature_layers
Definition: cs_lagr_tracking.h:195
const cs_lagr_param_t * cs_glob_lagr_params
integer, save iencma
Definition: lagran.f90:1272
integer, save jrval
pointer to random number associated with a particle for array pepa
Definition: lagran.f90:477
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:704
integer, save jyp
pointer to particle Y coordinate for pointer eptp
Definition: lagran.f90:421
cs_real_t weight_fou
Definition: cs_lagr_tracking.h:176
integer, save idepst
Definition: lagran.f90:250
integer, save iclogst
Definition: lagran.f90:346
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:977
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:5064
double precision, dimension(nflagm), save deblag
massic flow rate for a boudary zone
Definition: lagran.f90:633
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:539
const cs_lagr_attribute_map_t * p_am
Definition: cs_lagr_tracking.h:181
integer, save inbr
number of particle/boundary interactions
Definition: lagran.f90:1252
integer, save jrpoi
pointer to particle statistic weight for array pepa
Definition: lagran.f90:483
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:4744
integer, save jvp
pointer to particle Y velocity component for pointer eptp
Definition: lagran.f90:427
integer, save iencdi
Definition: lagran.f90:1274
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:177
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:175
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:884
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:1271
unsigned char * p_buffer
Definition: cs_lagr_tracking.h:183
integer, dimension(nusvar), save jvls
pointer to additional user variable for pointer eptp
Definition: lagran.f90:462
Definition: cs_lagr_tracking.h:90
integer, save nfrlag
number of boundary zones
Definition: lagran.f90:532
Definition: cs_lagr_tracking.h:117
int resuspension
Definition: cs_lagr_tracking.h:200
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:174
int deposition
Definition: cs_lagr_tracking.h:197
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:552
integer, save jcp
pointer to particle specific heat for pointer eptp
Definition: lagran.f90:452
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:1215
integer, dimension(:), allocatable icocel
Definition: pointe.f90:377
Definition: cs_lagr_tracking.h:53
integer, save iang
mean interaction angle with the boundary faces
Definition: lagran.f90:1258
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:5225
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:474
integer, save inclgt
Definition: lagran.f90:1305
int time_id
Definition: cs_lagr_tracking.h:165
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:448
integer, save juf
pointer to locally undisturbed X fluid velocity component for pointer eptp
Definition: lagran.f90:432
int dlvo
Definition: cs_lagr_tracking.h:198
cs_lnum_t n_part_dep
Definition: cs_lagr_tracking.h:169
cs_lnum_t n_particles_max
Definition: cs_lagr_tracking.h:179
integer, save jtp
pointer to particle and locally undisturbed fluid flow temperature (Celsius) for pointer eptp ...
Definition: lagran.f90:447
integer, dimension(3), save jtsup
pointer to velocity prediction for second order in time for array pepa
Definition: lagran.f90:470
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:423
integer, save jnbpoi
Additional pointer in ITEPA and TEPA arrays (contains particule state)
Definition: lagran.f90:348
double precision, dimension(ncharm2), save enc2
encrustation data
Definition: lagran.f90:1024
integer, dimension(3), save jtsuf
pointer to seen velocity prediction for second order in time for array pepa
Definition: lagran.f90:473
Definition: cs_lagr_tracking.h:67
Definition: cs_lagr_tracking.h:60
integer, dimension(nusbrd), save iusb
supplementary user boundary statistics
Definition: lagran.f90:1279
integer, save inclg
Definition: lagran.f90:1304
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:833
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:906
void cs_lagr_destroy(void)
Delete particle set structure and other useful buffers.
Definition: cs_lagr_tracking.c:5107
integer, save nbclst
statistic per zone and per class
Definition: lagran.f90:868
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:350
int cs_lagr_resize_particle_set(cs_lnum_t n_min_particles)
Resize particle set buffers if needed.
Definition: cs_lagr_tracking.c:5162
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:1246
integer, dimension(3), save jbx1
pointer to turbulence characteristics for second order in time for array pepa
Definition: lagran.f90:468
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:628
integer nlayer
maximal number of layer per coal particle
Definition: lagpar.f90:60
cs_lnum_t n_particles
Definition: cs_lagr_tracking.h:167
cs_lnum_t n_failed_part
Definition: cs_lagr_tracking.h:171
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:1035
integer, save jdp
pointer to particle diameter for pointer eptp
Definition: lagran.f90:442
Definition: cs_lagr_tracking.h:97
integer, save iencckbd
Definition: lagran.f90:1249
integer, save iscovc
Definition: lagran.f90:1309
integer, dimension(nflagm), save iusclb
for all the nfrlag boundary zones previously identified, a particle boundary condition type is given...
Definition: lagran.f90:598
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:552
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:953
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:542
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:929
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:1075
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:654
int n_time_vals
Definition: cs_lagr_tracking.h:137
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:576
integer, dimension(nlayer), save jhp
pointer to coal particle temperature ( ) for pointer eptp
Definition: lagran.f90:454
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:440
integer, save iangbd
activation (=1) or not (=0) of the recording of the angle between a particle trajectory and a boundar...
Definition: lagran.f90:1228
integer, save jtf
pointer to particle and locally undisturbed fluid flow temperature (Celsius) for pointer eptp ...
Definition: lagran.f90:450
Definition: cs_lagr_tracking.h:88
integer, dimension(nlayer), save jrhock
pointer to coal density for array pepa
Definition: lagran.f90:495
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:1029
#define END_C_DECLS
Definition: cs_defs.h:430
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:1221
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:492
integer, save iflmbd
activation (=1) or not (=0) of the recording of the particulate mass flow related to the particle/bou...
Definition: lagran.f90:1222
Definition: cs_lagr_tracking.h:89
integer, save ihdepv
Definition: lagran.f90:1312
#define CS_PROCF(x, y)
Definition: cs_defs.h:453
int roughness
Definition: cs_lagr_tracking.h:199
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:1234
integer, save nusbor
number additional user data to record for the calculation of additional boundary statistics in parbor...
Definition: lagran.f90:1181
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:506
integer, save jrhcon
Additional pointer in ITEPA and TEPA arrays (contains particule state)
Definition: lagran.f90:352
integer, save jup
pointer to particle X velocity component for pointer eptp
Definition: lagran.f90:425
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:1100
cs_real_t weight
Definition: cs_lagr_tracking.h:173
int n_user_variables
Definition: cs_lagr_tracking.h:204
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:806
void cs_lagr_set_reallocation_factor(double f)
Set reallocation factor for particle sets.
Definition: cs_lagr_tracking.c:5193
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:501
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:1295
integer, save ivit
mean interaction velocity with the boundary faces
Definition: lagran.f90:1261
Definition: cs_lagr_tracking.h:73
int n_stat_classes
Definition: cs_lagr_tracking.h:203
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:1002
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:526
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:5211
integer, dimension(nlayer), save jmck
pointer to mass of coke of the coal particle for pointer eptp
Definition: lagran.f90:460
Definition: cs_lagr_tracking.h:62
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:465
integer, dimension(:), allocatable itycel
Definition: pointe.f90:377
integer, save nordre
order of integration for the stochastic differential equations
Definition: lagran.f90:1114
integer, save jinch
pointer to number of the coal particle for ipepa array
Definition: lagran.f90:508
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:859
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:602
integer, save iensi3
Definition: lagran.f90:1363
integer, save ihsum
Definition: lagran.f90:1314
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:4217
Definition: cs_lagr_tracking.h:72
integer, save jrtsp
pointer to particle residence time for array pepa
Definition: lagran.f90:480
double precision, dimension(:,:), pointer dlgeo
Definition: pointe.f90:385
int clogging
Definition: cs_lagr_tracking.h:201
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:1025
Definition: cs_lagr_tracking.h:190