6.2
general documentation
cs_lagr_particle.h
Go to the documentation of this file.
1 #ifndef __CS_LAGR_PARTICLE_H__
2 #define __CS_LAGR_PARTICLE_H__
3 
4 /*============================================================================
5  * Lagrangian module particle model
6  *============================================================================*/
7 
8 /*
9  This file is part of Code_Saturne, a general-purpose CFD tool.
10 
11  Copyright (C) 1998-2020 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  * Macro definitions
44  *============================================================================*/
45 
51 #define CS_LAGR_PART_TO_DELETE (1 << 0)
52 
54 #define CS_LAGR_PART_FIXED (1 << 1)
55 
57 #define CS_LAGR_PART_DEPOSITED (1 << 2)
58 
60 #define CS_LAGR_PART_ROLLING (1 << 3)
61 
63 #define CS_LAGR_PART_IMPOSED_MOTION (1 << 4)
64 
68 #define CS_LAGR_PART_DEPOSITION_FLAGS \
69  ( CS_LAGR_PART_TO_DELETE | CS_LAGR_PART_FIXED | CS_LAGR_PART_DEPOSITED \
70  | CS_LAGR_PART_ROLLING | CS_LAGR_PART_IMPOSED_MOTION)
71 
72 /*============================================================================
73  * Type definitions
74  *============================================================================*/
75 
77 /* ------------------------------- */
78 
79 typedef enum {
80 
98 
104  /* Arrays for 2nd order scheme */
105 
106  CS_LAGR_TURB_STATE_1, /* turbulence characteristics of first pass */
107  CS_LAGR_PRED_VELOCITY, /* 1st step prediction for particle velocity */
108  CS_LAGR_PRED_VELOCITY_SEEN, /* 1st step prediction for relative velocity */
109  CS_LAGR_V_GAUSS, /* 1st step Gaussian variable */
110  CS_LAGR_BR_GAUSS, /* 1st step Brownian motion Gaussian variable */
111 
112  /* Non-spherical particles submodel additoinal parameters */
113 
121  /* Deposition submodel additional parameters */
122 
128 
129  /* Resuspension model additional parameters */
130 
136 
137  /* Clogging model additional parameters */
138 
143 
144  /* Thermal model additional parameters */
145 
149 
150  /* Coal combustion additional parameters */
151 
155 
158 
161 
162  /* Radiative model additional parameters */
163 
165 
166  /* Statistical class */
167 
169 
170  /* Agglomeration/fragmentation model parameters */
173 
174  /* User attributes */
175 
177 
178  /* End of attributes */
179 
181 
183 
185 /* ------------------------------------- */
186 
187 typedef struct {
188 
189  size_t extents; /* size (in bytes) of particle
190  structure */
191  size_t lb; /* size (in bytes) of lower
192  bounds of particle data
193  (work area before) */
194 
195  int n_time_vals; /* number of time values
196  handled */
197 
198  size_t size[CS_LAGR_N_ATTRIBUTES]; /* size (in bytes) of
199  attributes in particle
200  structure for a given
201  time value */
202  cs_datatype_t datatype[CS_LAGR_N_ATTRIBUTES]; /* datatype of associated
203  attributes */
204  int (*count)[CS_LAGR_N_ATTRIBUTES]; /* number of values for each
205  attribute, per associated
206  time_id */
207  ptrdiff_t (*displ)[CS_LAGR_N_ATTRIBUTES]; /* displacement (in bytes) of
208  attributes in particle data,
209  per associated time_id*/
210 
211  ptrdiff_t *source_term_displ; /* displacement (in bytes) of
212  source term values
213  for second-order scheme,
214  or NULL */
215 
217 
218 /* Particle set */
219 /* ------------ */
220 
221 typedef struct {
222 
223  cs_lnum_t n_particles; /* number of particle in domain */
226  cs_lnum_t n_part_merged; /* number of merged particles */
231 
240 
242 
245  unsigned char *p_buffer;
248 
249 /*=============================================================================
250  * Global variables
251  *============================================================================*/
252 
255 extern const char *cs_lagr_attribute_name[];
256 
260 
261 /*============================================================================
262  * Public function prototypes for Fortran API
263  *============================================================================*/
264 
265 /*============================================================================
266  * Public function prototypes
267  *============================================================================*/
268 
269 /*----------------------------------------------------------------------------*/
273 /*----------------------------------------------------------------------------*/
274 
275 void
277 
278 /*----------------------------------------------------------------------------*/
284 /*----------------------------------------------------------------------------*/
285 
288 
289 /*----------------------------------------------------------------------------*/
293 /*----------------------------------------------------------------------------*/
294 
295 void
297 
298 /*----------------------------------------------------------------------------*/
302 /*----------------------------------------------------------------------------*/
303 
304 void
306 
307 /*----------------------------------------------------------------------------*/
316 /*----------------------------------------------------------------------------*/
317 
318 void
320  cs_lnum_t src);
321 
322 /*----------------------------------------------------------------------------*/
341 /*----------------------------------------------------------------------------*/
342 
343 void
345  int time_id,
346  cs_lagr_attribute_t attr,
347  size_t *extents,
348  size_t *size,
349  ptrdiff_t *displ,
350  cs_datatype_t *datatype,
351  int *count);
352 
353 /*----------------------------------------------------------------------------*/
366 /*----------------------------------------------------------------------------*/
367 
368 int
370  cs_lagr_attribute_t attr,
371  cs_datatype_t datatype,
372  int stride,
373  int component_id);
374 
375 /*----------------------------------------------------------------------------*/
383 /*----------------------------------------------------------------------------*/
384 
385 void
387 
388 /*----------------------------------------------------------------------------
389  * Return pointer to the main cs_lagr_particle_set_t structure.
390  *
391  * returns:
392  * pointer to current particle set, or NULL
393  *----------------------------------------------------------------------------*/
394 
397 
398 /*----------------------------------------------------------------------------*/
408 /*----------------------------------------------------------------------------*/
409 
410 inline static void *
411 cs_lagr_particles_attr(cs_lagr_particle_set_t *particle_set,
412  cs_lnum_t particle_id,
413  cs_lagr_attribute_t attr)
414 {
415  assert(particle_set->p_am->count[0][attr] > 0);
416 
417  return (unsigned char *)particle_set->p_buffer
418  + particle_set->p_am->extents*particle_id
419  + particle_set->p_am->displ[0][attr];
420 }
421 
422 /*----------------------------------------------------------------------------*/
433 /*----------------------------------------------------------------------------*/
434 
435 inline static const void *
436 cs_lagr_particles_attr_const(const cs_lagr_particle_set_t *particle_set,
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 particle_set->p_buffer
443  + particle_set->p_am->extents*particle_id
444  + particle_set->p_am->displ[0][attr];
445 }
446 
447 /*----------------------------------------------------------------------------*/
459 /*----------------------------------------------------------------------------*/
460 
461 inline static void *
462 cs_lagr_particles_attr_n(cs_lagr_particle_set_t *particle_set,
463  cs_lnum_t particle_id,
464  int time_id,
465  cs_lagr_attribute_t attr)
466 {
467  assert(particle_set->p_am->count[time_id][attr] > 0);
468 
469  return particle_set->p_buffer
470  + particle_set->p_am->extents*particle_id
471  + particle_set->p_am->displ[time_id][attr];
472 }
473 
474 /*----------------------------------------------------------------------------*/
486 /*----------------------------------------------------------------------------*/
487 
488 inline static const void *
489 cs_lagr_particles_attr_n_const(const cs_lagr_particle_set_t *particle_set,
490  cs_lnum_t particle_id,
491  int time_id,
492  cs_lagr_attribute_t attr)
493 {
494  assert(particle_set->p_am->count[time_id][attr] > 0);
495 
496  return particle_set->p_buffer
497  + particle_set->p_am->extents*particle_id
498  + particle_set->p_am->displ[time_id][attr];
499 }
500 
501 /*----------------------------------------------------------------------------*/
511 /*----------------------------------------------------------------------------*/
512 
513 inline static int
514 cs_lagr_particles_get_flag(const cs_lagr_particle_set_t *particle_set,
515  cs_lnum_t particle_id,
516  int mask)
517 {
518  int flag
519  = *((const cs_lnum_t *)( particle_set->p_buffer
520  + particle_set->p_am->extents*particle_id
521  + particle_set->p_am->displ[0][CS_LAGR_P_FLAG]));
522 
523  return (flag & mask);
524 }
525 
526 /*----------------------------------------------------------------------------*/
534 /*----------------------------------------------------------------------------*/
535 
536 inline static void
537 cs_lagr_particles_set_flag(const cs_lagr_particle_set_t *particle_set,
538  cs_lnum_t particle_id,
539  int mask)
540 {
541  int flag
542  = *((const cs_lnum_t *)( particle_set->p_buffer
543  + particle_set->p_am->extents*particle_id
544  + particle_set->p_am->displ[0][CS_LAGR_P_FLAG]));
545 
546  flag = flag | mask;
547 
548  *((cs_lnum_t *)( particle_set->p_buffer
549  + particle_set->p_am->extents*particle_id
550  + particle_set->p_am->displ[0][CS_LAGR_P_FLAG])) = flag;
551 }
552 
553 /*----------------------------------------------------------------------------*/
561 /*----------------------------------------------------------------------------*/
562 
563 inline static void
564 cs_lagr_particles_unset_flag(const cs_lagr_particle_set_t *particle_set,
565  cs_lnum_t particle_id,
566  int mask)
567 {
568  int flag
569  = *((const cs_lnum_t *)( particle_set->p_buffer
570  + particle_set->p_am->extents*particle_id
571  + particle_set->p_am->displ[0][CS_LAGR_P_FLAG]));
572 
573  flag = (flag | mask) - mask;
574 
575  *((cs_lnum_t *)( particle_set->p_buffer
576  + particle_set->p_am->extents*particle_id
577  + particle_set->p_am->displ[0][CS_LAGR_P_FLAG])) = flag;
578 }
579 
580 /*----------------------------------------------------------------------------*/
590 /*----------------------------------------------------------------------------*/
591 
592 inline static cs_lnum_t
593 cs_lagr_particles_get_lnum(const cs_lagr_particle_set_t *particle_set,
594  cs_lnum_t particle_id,
595  cs_lagr_attribute_t attr)
596 {
597  assert(particle_set->p_am->count[0][attr] > 0);
598 
599  return *((const cs_lnum_t *)( particle_set->p_buffer
600  + particle_set->p_am->extents*particle_id
601  + particle_set->p_am->displ[0][attr]));
602 }
603 
604 /*----------------------------------------------------------------------------*/
616 /*----------------------------------------------------------------------------*/
617 
618 inline static cs_lnum_t
619 cs_lagr_particles_get_lnum_n(const cs_lagr_particle_set_t *particle_set,
620  cs_lnum_t particle_id,
621  int time_id,
622  cs_lagr_attribute_t attr)
623 {
624  assert(particle_set->p_am->count[time_id][attr] > 0);
625 
626  return *((const cs_lnum_t *)( particle_set->p_buffer
627  + particle_set->p_am->extents*particle_id
628  + particle_set->p_am->displ[time_id][attr]));
629 }
630 
631 /*----------------------------------------------------------------------------*/
640 /*----------------------------------------------------------------------------*/
641 
642 inline static void
643 cs_lagr_particles_set_lnum(cs_lagr_particle_set_t *particle_set,
644  cs_lnum_t particle_id,
645  cs_lagr_attribute_t attr,
646  cs_lnum_t value)
647 {
648  assert(particle_set->p_am->count[0][attr] > 0);
649 
650  *((cs_lnum_t *)( particle_set->p_buffer
651  + particle_set->p_am->extents*particle_id
652  + particle_set->p_am->displ[0][attr])) = value;
653 }
654 
655 /*----------------------------------------------------------------------------*/
666 /*----------------------------------------------------------------------------*/
667 
668 inline static void
669 cs_lagr_particles_set_lnum_n(cs_lagr_particle_set_t *particle_set,
670  cs_lnum_t particle_id,
671  int time_id,
672  cs_lagr_attribute_t attr,
673  cs_lnum_t value)
674 {
675  assert(particle_set->p_am->count[time_id][attr] > 0);
676 
677  *((cs_lnum_t *)( particle_set->p_buffer
678  + particle_set->p_am->extents*particle_id
679  + particle_set->p_am->displ[time_id][attr])) = value;
680 }
681 
682 /*----------------------------------------------------------------------------*/
692 /*----------------------------------------------------------------------------*/
693 
694 inline static cs_gnum_t
695 cs_lagr_particles_get_gnum(const cs_lagr_particle_set_t *particle_set,
696  cs_lnum_t particle_id,
697  cs_lagr_attribute_t attr)
698 {
699  assert(particle_set->p_am->count[0][attr] > 0);
700 
701  return *((const cs_gnum_t *)( particle_set->p_buffer
702  + particle_set->p_am->extents*particle_id
703  + particle_set->p_am->displ[0][attr]));
704 }
705 
706 /*----------------------------------------------------------------------------*/
718 /*----------------------------------------------------------------------------*/
719 
720 inline static cs_gnum_t
721 cs_lagr_particles_get_gnum_n(const cs_lagr_particle_set_t *particle_set,
722  cs_lnum_t particle_id,
723  int time_id,
724  cs_lagr_attribute_t attr)
725 {
726  assert(particle_set->p_am->count[time_id][attr] > 0);
727 
728  return *((const cs_gnum_t *)( particle_set->p_buffer
729  + particle_set->p_am->extents*particle_id
730  + particle_set->p_am->displ[time_id][attr]));
731 }
732 
733 /*----------------------------------------------------------------------------*/
742 /*----------------------------------------------------------------------------*/
743 
744 inline static void
745 cs_lagr_particles_set_gnum(cs_lagr_particle_set_t *particle_set,
746  cs_lnum_t particle_id,
747  cs_lagr_attribute_t attr,
748  cs_gnum_t value)
749 {
750  assert(particle_set->p_am->count[0][attr] > 0);
751 
752  *((cs_gnum_t *)( particle_set->p_buffer
753  + particle_set->p_am->extents*particle_id
754  + particle_set->p_am->displ[0][attr])) = value;
755 }
756 
757 /*----------------------------------------------------------------------------*/
768 /*----------------------------------------------------------------------------*/
769 
770 inline static void
771 cs_lagr_particles_set_gnum_n(cs_lagr_particle_set_t *particle_set,
772  cs_lnum_t particle_id,
773  int time_id,
774  cs_lagr_attribute_t attr,
775  cs_gnum_t value)
776 {
777  assert(particle_set->p_am->count[time_id][attr] > 0);
778 
779  *((cs_gnum_t *)( particle_set->p_buffer
780  + particle_set->p_am->extents*particle_id
781  + particle_set->p_am->displ[time_id][attr])) = value;
782 }
783 
784 /*----------------------------------------------------------------------------*/
794 /*----------------------------------------------------------------------------*/
795 
796 inline static cs_real_t
797 cs_lagr_particles_get_real(const cs_lagr_particle_set_t *particle_set,
798  cs_lnum_t particle_id,
799  cs_lagr_attribute_t attr)
800 {
801  assert(particle_set->p_am->count[0][attr] > 0);
802 
803  return *((const cs_real_t *)( particle_set->p_buffer
804  + particle_set->p_am->extents*particle_id
805  + particle_set->p_am->displ[0][attr]));
806 }
807 
808 /*----------------------------------------------------------------------------*/
820 /*----------------------------------------------------------------------------*/
821 
822 inline static cs_real_t
823 cs_lagr_particles_get_real_n(const cs_lagr_particle_set_t *particle_set,
824  cs_lnum_t particle_id,
825  int time_id,
826  cs_lagr_attribute_t attr)
827 {
828  assert(particle_set->p_am->count[time_id][attr] > 0);
829 
830  return *((const cs_real_t *)( particle_set->p_buffer
831  + particle_set->p_am->extents*particle_id
832  + particle_set->p_am->displ[time_id][attr]));
833 }
834 
835 /*----------------------------------------------------------------------------*/
844 /*----------------------------------------------------------------------------*/
845 
846 inline static void
847 cs_lagr_particles_set_real(cs_lagr_particle_set_t *particle_set,
848  cs_lnum_t particle_id,
849  cs_lagr_attribute_t attr,
850  cs_real_t value)
851 {
852  assert(particle_set->p_am->count[0][attr] > 0);
853 
854  *((cs_real_t *)( particle_set->p_buffer
855  + particle_set->p_am->extents*particle_id
856  + particle_set->p_am->displ[0][attr])) = value;
857 }
858 
859 /*----------------------------------------------------------------------------*/
870 /*----------------------------------------------------------------------------*/
871 
872 inline static void
873 cs_lagr_particles_set_real_n(cs_lagr_particle_set_t *particle_set,
874  cs_lnum_t particle_id,
875  int time_id,
876  cs_lagr_attribute_t attr,
877  cs_real_t value)
878 {
879  assert(particle_set->p_am->count[time_id][attr] > 0);
880 
881  *((cs_real_t *)( particle_set->p_buffer
882  + particle_set->p_am->extents*particle_id
883  + particle_set->p_am->displ[time_id][attr])) = value;
884 }
885 
886 /*----------------------------------------------------------------------------*/
897 /*----------------------------------------------------------------------------*/
898 
899 inline static cs_real_t *
900 cs_lagr_particles_source_terms(cs_lagr_particle_set_t *particle_set,
901  cs_lnum_t particle_id,
902  cs_lagr_attribute_t attr)
903 {
904  assert(particle_set->p_am->source_term_displ != NULL);
905  assert(particle_set->p_am->source_term_displ[attr] >= 0);
906 
907  return (cs_real_t *)( (unsigned char *)particle_set->p_buffer
908  + particle_set->p_am->extents*particle_id
909  + particle_set->p_am->source_term_displ[attr]);
910 }
911 
912 /*----------------------------------------------------------------------------*/
923 /*----------------------------------------------------------------------------*/
924 
925 inline static const cs_real_t *
926 cs_lagr_particles_source_terms_const(cs_lagr_particle_set_t *particle_set,
927  cs_lnum_t particle_id,
928  cs_lagr_attribute_t attr)
929 {
930  assert(particle_set->p_am->source_term_displ != NULL);
931  assert(particle_set->p_am->source_term_displ[attr] >= 0);
932 
933  return (const cs_real_t *)( (unsigned char *)particle_set->p_buffer
934  + particle_set->p_am->extents*particle_id
935  + particle_set->p_am->source_term_displ[attr]);
936 }
937 
938 /*----------------------------------------------------------------------------*/
948 /*----------------------------------------------------------------------------*/
949 
950 inline static void *
951 cs_lagr_particle_attr(void *particle,
952  const cs_lagr_attribute_map_t *attr_map,
953  cs_lagr_attribute_t attr)
954 {
955  assert(attr_map->count[0][attr] > 0);
956 
957  return (unsigned char *)particle + attr_map->displ[0][attr];
958 }
959 
960 /*----------------------------------------------------------------------------*/
970 /*----------------------------------------------------------------------------*/
971 
972 inline static const void *
973 cs_lagr_particle_attr_const(const void *particle,
974  const cs_lagr_attribute_map_t *attr_map,
975  cs_lagr_attribute_t attr)
976 {
977  assert(attr_map->count[0][attr] > 0);
978 
979  return (const unsigned char *)particle + attr_map->displ[0][attr];
980 }
981 
982 /*----------------------------------------------------------------------------*/
993 /*----------------------------------------------------------------------------*/
994 
995 inline static void *
996 cs_lagr_particle_attr_n(void *particle,
997  const cs_lagr_attribute_map_t *attr_map,
998  int time_id,
999  cs_lagr_attribute_t attr)
1000 {
1001  assert(attr_map->count[time_id][attr] > 0);
1002 
1003  return (unsigned char *)particle + attr_map->displ[time_id][attr];
1004 }
1005 
1006 /*----------------------------------------------------------------------------*/
1017 /*----------------------------------------------------------------------------*/
1018 
1019 inline static const void *
1020 cs_lagr_particle_attr_n_const(const void *particle,
1021  const cs_lagr_attribute_map_t *attr_map,
1022  int time_id,
1023  cs_lagr_attribute_t attr)
1024 {
1025  assert(attr_map->count[time_id][attr] > 0);
1026 
1027  return (const unsigned char *)particle
1028  + attr_map->displ[time_id][attr];
1029 }
1030 
1031 /*----------------------------------------------------------------------------*/
1041 /*----------------------------------------------------------------------------*/
1042 
1043 inline static cs_lnum_t
1044 cs_lagr_particle_get_lnum(const void *particle,
1045  const cs_lagr_attribute_map_t *attr_map,
1046  cs_lagr_attribute_t attr)
1047 {
1048  assert(attr_map->count[0][attr] > 0);
1049 
1050  return *((const cs_lnum_t *)( (const unsigned char *)particle
1051  + attr_map->displ[0][attr]));
1052 }
1053 
1054 /*----------------------------------------------------------------------------*/
1066 /*----------------------------------------------------------------------------*/
1067 
1068 inline static cs_lnum_t
1069 cs_lagr_particle_get_lnum_n(const void *particle,
1070  const cs_lagr_attribute_map_t *attr_map,
1071  int time_id,
1072  cs_lagr_attribute_t attr)
1073 {
1074  assert(attr_map->count[time_id][attr] > 0);
1075 
1076  return *((const cs_lnum_t *)( (const unsigned char *)particle
1077  + attr_map->displ[time_id][attr]));
1078 }
1079 
1080 /*----------------------------------------------------------------------------*/
1089  /*----------------------------------------------------------------------------*/
1090 
1091 inline static void
1092 cs_lagr_particle_set_lnum(void *particle,
1093  const cs_lagr_attribute_map_t *attr_map,
1094  cs_lagr_attribute_t attr,
1095  cs_lnum_t value)
1096 {
1097  assert(attr_map->count[0][attr] > 0);
1098 
1099  *((cs_lnum_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
1100  = value;
1101 }
1102 
1103 /*----------------------------------------------------------------------------*/
1114  /*----------------------------------------------------------------------------*/
1115 
1116 inline static void
1117 cs_lagr_particle_set_lnum_n(void *particle,
1118  const cs_lagr_attribute_map_t *attr_map,
1119  int time_id,
1120  cs_lagr_attribute_t attr,
1121  cs_lnum_t value)
1122 {
1123  assert(attr_map->count[time_id][attr] > 0);
1124 
1125  *((cs_lnum_t *)( (unsigned char *)particle
1126  + attr_map->displ[time_id][attr])) = value;
1127 }
1128 
1129 /*----------------------------------------------------------------------------*/
1139 /*----------------------------------------------------------------------------*/
1140 
1141 inline static cs_gnum_t
1142 cs_lagr_particle_get_gnum(const void *particle,
1143  const cs_lagr_attribute_map_t *attr_map,
1144  cs_lagr_attribute_t attr)
1145 {
1146  assert(attr_map->count[0][attr] > 0);
1147 
1148  return *((const cs_gnum_t *)( (const unsigned char *)particle
1149  + attr_map->displ[0][attr]));
1150 }
1151 
1152 /*----------------------------------------------------------------------------*/
1164 /*----------------------------------------------------------------------------*/
1165 
1166 inline static cs_gnum_t
1167 cs_lagr_particle_get_gnum_n(const void *particle,
1168  const cs_lagr_attribute_map_t *attr_map,
1169  int time_id,
1170  cs_lagr_attribute_t attr)
1171 {
1172  assert(attr_map->count[time_id][attr] > 0);
1173 
1174  return *((const cs_gnum_t *)( (const unsigned char *)particle
1175  + attr_map->displ[time_id][attr]));
1176 }
1177 
1178 /*----------------------------------------------------------------------------*/
1187  /*----------------------------------------------------------------------------*/
1188 
1189 inline static void
1190 cs_lagr_particle_set_gnum(void *particle,
1191  const cs_lagr_attribute_map_t *attr_map,
1192  cs_lagr_attribute_t attr,
1193  cs_gnum_t value)
1194 {
1195  assert(attr_map->count[0][attr] > 0);
1196 
1197  *((cs_gnum_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
1198  = value;
1199 }
1200 
1201 /*----------------------------------------------------------------------------*/
1212  /*----------------------------------------------------------------------------*/
1213 
1214 inline static void
1215 cs_lagr_particle_set_gnum_n(void *particle,
1216  const cs_lagr_attribute_map_t *attr_map,
1217  int time_id,
1218  cs_lagr_attribute_t attr,
1219  cs_gnum_t value)
1220 {
1221  assert(attr_map->count[time_id][attr] > 0);
1222 
1223  *((cs_gnum_t *)( (unsigned char *)particle
1224  + attr_map->displ[time_id][attr])) = value;
1225 }
1226 
1227 /*----------------------------------------------------------------------------*/
1237 /*----------------------------------------------------------------------------*/
1238 
1239 inline static cs_real_t
1240 cs_lagr_particle_get_real(const void *particle,
1241  const cs_lagr_attribute_map_t *attr_map,
1242  cs_lagr_attribute_t attr)
1243 {
1244  assert(attr_map->count[0][attr] > 0);
1245 
1246  return *((const cs_real_t *)( (const unsigned char *)particle
1247  + attr_map->displ[0][attr]));
1248 }
1249 
1250 /*----------------------------------------------------------------------------*/
1262 /*----------------------------------------------------------------------------*/
1263 
1264 inline static cs_real_t
1265 cs_lagr_particle_get_real_n(const void *particle,
1266  const cs_lagr_attribute_map_t *attr_map,
1267  int time_id,
1268  cs_lagr_attribute_t attr)
1269 {
1270  assert(attr_map->count[time_id][attr] > 0);
1271 
1272  return *((const cs_real_t *)( (const unsigned char *)particle
1273  + attr_map->displ[time_id][attr]));
1274 }
1275 
1276 /*----------------------------------------------------------------------------*/
1285  /*----------------------------------------------------------------------------*/
1286 
1287 inline static void
1288 cs_lagr_particle_set_real(void *particle,
1289  const cs_lagr_attribute_map_t *attr_map,
1290  cs_lagr_attribute_t attr,
1291  cs_real_t value)
1292 {
1293  assert(attr_map->count[0][attr] > 0);
1294 
1295  *((cs_real_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
1296  = value;
1297 }
1298 
1299 /*----------------------------------------------------------------------------*/
1310  /*----------------------------------------------------------------------------*/
1311 
1312 inline static void
1313 cs_lagr_particle_set_real_n(void *particle,
1314  const cs_lagr_attribute_map_t *attr_map,
1315  int time_id,
1316  cs_lagr_attribute_t attr,
1317  cs_real_t value)
1318 {
1319  assert(attr_map->count[time_id][attr] > 0);
1320 
1321  *((cs_real_t *)( (unsigned char *)particle
1322  + attr_map->displ[time_id][attr])) = value;
1323 }
1324 
1325 /*----------------------------------------------------------------------------*/
1335 /*----------------------------------------------------------------------------*/
1336 
1337 inline static cs_real_t *
1338 cs_lagr_particle_source_term(void *particle,
1339  const cs_lagr_attribute_map_t *attr_map,
1340  cs_lagr_attribute_t attr)
1341 {
1342  assert(attr_map->source_term_displ != NULL);
1343  assert(attr_map->source_term_displ[attr] >= 0);
1344 
1345  return (cs_real_t *)( (unsigned char *)particle
1346  + attr_map->source_term_displ[attr]);
1347 }
1348 
1349 /*----------------------------------------------------------------------------*/
1359 /*----------------------------------------------------------------------------*/
1360 
1361 inline static const cs_real_t *
1362 cs_lagr_particle_source_term_const(void *particle,
1363  const cs_lagr_attribute_map_t *attr_map,
1364  cs_lagr_attribute_t attr)
1365 {
1366  assert(attr_map->source_term_displ != NULL);
1367  assert(attr_map->source_term_displ[attr] >= 0);
1368 
1369  return (const cs_real_t *)( (unsigned char *)particle
1370  + attr_map->source_term_displ[attr]);
1371 }
1372 
1373 /*----------------------------------------------------------------------------
1374  * Resize particle set buffers if needed.
1375  *
1376  * parameters:
1377  * n_particles <-- minumum number of particles required
1378  *
1379  *
1380  * returns:
1381  * 1 if resizing was required, 0 otherwise
1382  *----------------------------------------------------------------------------*/
1383 
1384 int
1385 cs_lagr_particle_set_resize(cs_lnum_t n_min_particles);
1386 
1387 /*----------------------------------------------------------------------------
1388  * Set reallocation factor for particle sets.
1389  *
1390  * This factor determines the multiplier used for reallocations when
1391  * the particle set's buffers are too small to handle the new number of
1392  * particles.
1393  *
1394  * parameters:
1395  * f <-- reallocation size multiplier
1396  *----------------------------------------------------------------------------*/
1397 
1398 void
1400 
1401 /*----------------------------------------------------------------------------*/
1410 /*----------------------------------------------------------------------------*/
1411 
1412 unsigned long long
1414 
1415 /*----------------------------------------------------------------------------*/
1424 /*----------------------------------------------------------------------------*/
1425 
1426 void
1427 cs_lagr_set_n_g_particles_max(unsigned long long n_g_particles_max);
1428 
1429 /*----------------------------------------------------------------------------*/
1436 /*----------------------------------------------------------------------------*/
1437 
1438 void
1440  cs_lnum_t particle_id);
1441 
1442 /*----------------------------------------------------------------------------*/
1448 /*----------------------------------------------------------------------------*/
1449 
1450 void
1452 
1453 /*----------------------------------------------------------------------------*/
1459 /*----------------------------------------------------------------------------*/
1460 
1461 void
1462 cs_lagr_set_n_user_variables(int n_user_variables);
1463 
1464 /*----------------------------------------------------------------------------*/
1465 
1467 
1468 #endif /* __CS_LAGR_PARTICLE_H__ */
Definition: cs_lagr_particle.h:116
Definition: cs_lagr_particle.h:97
cs_lnum_t n_part_out
Definition: cs_lagr_particle.h:225
void cs_lagr_particle_finalize(void)
Destroy main particle set and map if they exist.
Definition: cs_lagr_particle.c:977
cs_datatype_t
Definition: cs_defs.h:260
unsigned long cs_gnum_t
global mesh entity number
Definition: cs_defs.h:286
Definition: cs_lagr_particle.h:131
cs_lagr_particle_set_t * cs_glob_lagr_particle_set
cs_lnum_t n_part_fou
Definition: cs_lagr_particle.h:228
void cs_lagr_particle_attr_initialize(void)
Define particle map based on defined options.
Definition: cs_lagr_particle.c:661
Definition: cs_lagr_particle.h:171
Definition: cs_lagr_particle.h:139
Definition: cs_lagr_particle.h:168
ptrdiff_t * source_term_displ
Definition: cs_lagr_particle.h:211
Definition: cs_lagr_particle.h:141
Definition: cs_lagr_particle.h:157
cs_lnum_t n_part_resusp
Definition: cs_lagr_particle.h:229
Definition: cs_lagr_particle.h:100
#define BEGIN_C_DECLS
Definition: cs_defs.h:495
Definition: cs_lagr_particle.h:154
cs_real_t weight_new
Definition: cs_lagr_particle.h:233
Definition: cs_lagr_particle.h:221
cs_lagr_attribute_t
Definition: cs_lagr_particle.h:79
Definition: cs_lagr_particle.h:119
cs_real_t weight_resusp
Definition: cs_lagr_particle.h:238
void cs_lagr_particles_current_to_previous(cs_lagr_particle_set_t *particles, cs_lnum_t particle_id)
Copy current attributes to previous attributes.
Definition: cs_lagr_particle.c:1251
Definition: cs_lagr_particle.h:108
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_particle.c:1150
cs_real_t weight_fou
Definition: cs_lagr_particle.h:237
Definition: cs_lagr_particle.h:164
Definition: cs_lagr_particle.h:99
Definition: cs_lagr_particle.h:90
Definition: cs_lagr_particle.h:114
int cs_lagr_particle_set_resize(cs_lnum_t n_min_particles)
Resize particle set buffers if needed.
Definition: cs_lagr_particle.c:1170
const cs_lagr_attribute_map_t * p_am
Definition: cs_lagr_particle.h:243
cs_real_t weight_failed
Definition: cs_lagr_particle.h:239
Definition: cs_lagr_particle.h:96
Definition: cs_lagr_particle.h:86
cs_real_t weight_dep
Definition: cs_lagr_particle.h:236
double cs_real_t
Floating-point value.
Definition: cs_defs.h:307
Definition: cs_lagr_particle.h:84
Definition: cs_lagr_particle.h:126
unsigned char * p_buffer
Definition: cs_lagr_particle.h:245
Definition: cs_lagr_particle.h:83
void cs_lagr_set_reallocation_factor(double f)
Set reallocation factor for particle sets.
Definition: cs_lagr_particle.c:1201
ptrdiff_t(* displ)[CS_LAGR_N_ATTRIBUTES]
Definition: cs_lagr_particle.h:207
Definition: cs_lagr_particle.h:124
cs_real_t weight_out
Definition: cs_lagr_particle.h:234
Definition: cs_lagr_particle.h:147
Definition: cs_lagr_particle.h:94
Definition: cs_lagr_particle.h:132
const char * cs_lagr_attribute_name[]
void cs_lagr_particle_attr_in_range(int attr)
Check if a particle attribute is in a valid range.
Definition: cs_lagr_particle.c:1133
cs_lnum_t n_part_merged
Definition: cs_lagr_particle.h:226
cs_lnum_t n_part_dep
Definition: cs_lagr_particle.h:227
cs_lnum_t n_particles_max
Definition: cs_lagr_particle.h:241
Definition: cs_lagr_particle.h:107
void cs_lagr_set_n_user_variables(int n_user_variables)
Set number of user particle variables.
Definition: cs_lagr_particle.c:1306
Definition: cs_lagr_particle.h:152
Definition: cs_lagr_particle.h:148
Definition: cs_lagr_particle.h:127
Definition: cs_lagr_particle.h:160
Definition: cs_lagr_particle.h:109
Definition: cs_lagr_particle.h:118
Definition: cs_lagr_particle.h:91
cs_lnum_t n_part_new
Definition: cs_lagr_particle.h:224
cs_lnum_t n_particles
Definition: cs_lagr_particle.h:223
Definition: cs_lagr_particle.h:115
cs_lnum_t n_failed_part
Definition: cs_lagr_particle.h:230
Definition: cs_lagr_particle.h:159
Definition: cs_lagr_particle.h:117
void cs_lagr_particle_set_create(void)
Definition: cs_lagr_particle.c:960
int cs_lagr_check_attr_query(const cs_lagr_particle_set_t *particles, cs_lagr_attribute_t attr, cs_datatype_t datatype, int stride, int component_id)
Check that query for a given particle attribute is valid.
Definition: cs_lagr_particle.c:1068
Definition: cs_lagr_particle.h:134
Definition: cs_lagr_particle.h:93
unsigned long long cs_lagr_get_n_g_particles_max(void)
Get global maximum number of particles.
Definition: cs_lagr_particle.c:1219
Definition: cs_lagr_particle.h:156
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:301
int n_time_vals
Definition: cs_lagr_particle.h:195
Definition: cs_lagr_particle.h:110
Definition: cs_lagr_particle.h:142
Definition: cs_lagr_particle.h:125
size_t lb
Definition: cs_lagr_particle.h:191
#define END_C_DECLS
Definition: cs_defs.h:496
size_t extents
Definition: cs_lagr_particle.h:189
Definition: cs_lagr_particle.h:146
Definition: cs_lagr_particle.h:81
Definition: cs_lagr_particle.h:153
const cs_lagr_attribute_map_t * cs_lagr_particle_get_attr_map(void)
Return const pointer to the main particle attribute map structure.
Definition: cs_lagr_particle.c:947
void cs_lagr_set_n_g_particles_max(unsigned long long n_g_particles_max)
Set global maximum number of particles.
Definition: cs_lagr_particle.c:1236
Definition: cs_lagr_particle.h:95
cs_real_t weight
Definition: cs_lagr_particle.h:232
cs_real_t weight_merged
Definition: cs_lagr_particle.h:235
void cs_lagr_part_copy(cs_lnum_t dest, cs_lnum_t src)
Copy attributes from one particle to another.
Definition: cs_lagr_particle.c:996
Definition: cs_lagr_particle.h:176
Definition: cs_lagr_particle.h:92
void cs_lagr_particle_set_dump(const cs_lagr_particle_set_t *particles)
Dump a cs_lagr_particle_set_t structure.
Definition: cs_lagr_particle.c:1278
Definition: cs_lagr_particle.h:187
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_particle.c:1031
Definition: cs_lagr_particle.h:135
Definition: cs_lagr_particle.h:172
Definition: cs_lagr_particle.h:133
Definition: cs_lagr_particle.h:106
Definition: cs_lagr_particle.h:123
Definition: cs_lagr_particle.h:88
int(* count)[CS_LAGR_N_ATTRIBUTES]
Definition: cs_lagr_particle.h:204
Definition: cs_lagr_particle.h:140
Definition: cs_lagr_particle.h:180