8.3
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-2024 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#include "string.h"
34
35/*----------------------------------------------------------------------------*/
36
38
39/*=============================================================================
40 * Macro definitions
41 *============================================================================*/
42
43/*=============================================================================
44 * Macro definitions
45 *============================================================================*/
46
52#define CS_LAGR_PART_TO_DELETE (1 << 0)
53
55#define CS_LAGR_PART_FIXED (1 << 1)
56
58#define CS_LAGR_PART_DEPOSITED (1 << 2)
59
61#define CS_LAGR_PART_ROLLING (1 << 3)
62
64#define CS_LAGR_PART_IMPOSED_MOTION (1 << 4)
65
69#define CS_LAGR_PART_DEPOSITION_FLAGS \
70 ( CS_LAGR_PART_TO_DELETE | CS_LAGR_PART_FIXED | CS_LAGR_PART_DEPOSITED \
71 | CS_LAGR_PART_ROLLING | CS_LAGR_PART_IMPOSED_MOTION)
72
73/*============================================================================
74 * Type definitions
75 *============================================================================*/
76
78/* ------------------------------- */
79
80typedef enum {
81
99
105 /* Arrays for 2nd order scheme */
106
107 CS_LAGR_TURB_STATE_1, /* turbulence characteristics of first pass */
108 CS_LAGR_PRED_VELOCITY, /* 1st step prediction for particle velocity */
109 CS_LAGR_PRED_VELOCITY_SEEN, /* 1st step prediction for relative velocity */
110 CS_LAGR_V_GAUSS, /* 1st step Gaussian variable */
111 CS_LAGR_BR_GAUSS, /* 1st step Brownian motion Gaussian variable */
112
113 /* Non-spherical particles submodel additoinal parameters */
114
123 /* Deposition submodel additional parameters */
124
130
131 /* Resuspension model additional parameters */
132
138
139 /* Clogging model additional parameters */
140
145
146 /* Thermal model additional parameters */
147
151
152 /* Coal combustion additional parameters */
153
157
160
163
164 /* Radiative model additional parameters */
165
167
168 /* Statistical class */
169
171
172 /* Agglomeration/fragmentation model parameters */
175
176 /* User attributes */
177
179
180 /* End of attributes */
181
183
185
187/* ------------------------------------- */
188
189typedef struct {
190
191 size_t extents; /* size (in bytes) of particle
192 structure */
193 size_t lb; /* size (in bytes) of lower
194 bounds of particle data
195 (work area before) */
196
197 int n_time_vals; /* number of time values
198 handled */
199
200 size_t size[CS_LAGR_N_ATTRIBUTES]; /* size (in bytes) of
201 attributes in particle
202 structure for a given
203 time value */
204 cs_datatype_t datatype[CS_LAGR_N_ATTRIBUTES]; /* datatype of associated
205 attributes */
206 int (*count)[CS_LAGR_N_ATTRIBUTES]; /* number of values for each
207 attribute, per associated
208 time_id */
209 ptrdiff_t (*displ)[CS_LAGR_N_ATTRIBUTES]; /* displacement (in bytes) of
210 attributes in particle data,
211 per associated time_id*/
212
213 ptrdiff_t *source_term_displ; /* displacement (in bytes) of
214 source term values
215 for second-order scheme,
216 or NULL */
217
219
220/* Particle set */
221/* ------------ */
222
223typedef struct {
224
225 cs_lnum_t n_particles; /* number of particle in domain */
228 cs_lnum_t n_part_merged; /* number of merged particles */
233
242
244
247 unsigned char *p_buffer;
250
251/*=============================================================================
252 * Global variables
253 *============================================================================*/
254
257extern const char *cs_lagr_attribute_name[];
258
262
263/*============================================================================
264 * Public function prototypes for Fortran API
265 *============================================================================*/
266
267/*============================================================================
268 * Public function prototypes
269 *============================================================================*/
270
271/*----------------------------------------------------------------------------*/
275/*----------------------------------------------------------------------------*/
276
277void
279
280/*----------------------------------------------------------------------------*/
286/*----------------------------------------------------------------------------*/
287
290
291/*----------------------------------------------------------------------------*/
295/*----------------------------------------------------------------------------*/
296
297void
299
300/*----------------------------------------------------------------------------*/
304/*----------------------------------------------------------------------------*/
305
306void
308
309/*----------------------------------------------------------------------------*/
318/*----------------------------------------------------------------------------*/
319
320void
322 cs_lnum_t src);
323
324/*----------------------------------------------------------------------------*/
343/*----------------------------------------------------------------------------*/
344
345void
347 int time_id,
349 size_t *extents,
350 size_t *size,
351 ptrdiff_t *displ,
352 cs_datatype_t *datatype,
353 int *count);
354
355/*----------------------------------------------------------------------------*/
368/*----------------------------------------------------------------------------*/
369
370int
373 cs_datatype_t datatype,
374 int stride,
375 int component_id);
376
377/*----------------------------------------------------------------------------*/
385/*----------------------------------------------------------------------------*/
386
387void
389
390/*----------------------------------------------------------------------------
391 * Return pointer to the main cs_lagr_particle_set_t structure.
392 *
393 * returns:
394 * pointer to current particle set, or NULL
395 *----------------------------------------------------------------------------*/
396
399
400/*----------------------------------------------------------------------------*/
410/*----------------------------------------------------------------------------*/
411
412inline static void *
414 cs_lnum_t particle_id,
416{
417 assert(particle_set->p_am->count[0][attr] > 0);
418
419 return (unsigned char *)particle_set->p_buffer
420 + particle_set->p_am->extents*particle_id
421 + particle_set->p_am->displ[0][attr];
422}
423
424/*----------------------------------------------------------------------------*/
435/*----------------------------------------------------------------------------*/
436
437inline static const void *
439 cs_lnum_t particle_id,
441{
442 assert(particle_set->p_am->count[0][attr] > 0);
443
444 return particle_set->p_buffer
445 + particle_set->p_am->extents*particle_id
446 + particle_set->p_am->displ[0][attr];
447}
448
449/*----------------------------------------------------------------------------*/
461/*----------------------------------------------------------------------------*/
462
463inline static void *
465 cs_lnum_t particle_id,
466 int time_id,
468{
469 assert(particle_set->p_am->count[time_id][attr] > 0);
470
471 return particle_set->p_buffer
472 + particle_set->p_am->extents*particle_id
473 + particle_set->p_am->displ[time_id][attr];
474}
475
476/*----------------------------------------------------------------------------*/
488/*----------------------------------------------------------------------------*/
489
490inline static const void *
492 cs_lnum_t particle_id,
493 int time_id,
495{
496 assert(particle_set->p_am->count[time_id][attr] > 0);
497
498 return particle_set->p_buffer
499 + particle_set->p_am->extents*particle_id
500 + particle_set->p_am->displ[time_id][attr];
501}
502
503/*----------------------------------------------------------------------------*/
513/*----------------------------------------------------------------------------*/
514
515inline static int
517 cs_lnum_t particle_id,
518 int mask)
519{
520 int flag
521 = *((const cs_lnum_t *)( particle_set->p_buffer
522 + particle_set->p_am->extents*particle_id
523 + particle_set->p_am->displ[0][CS_LAGR_P_FLAG]));
524
525 return (flag & mask);
526}
527
528/*----------------------------------------------------------------------------*/
536/*----------------------------------------------------------------------------*/
537
538inline static void
540 cs_lnum_t particle_id,
541 int mask)
542{
543 int flag
544 = *((const cs_lnum_t *)( particle_set->p_buffer
545 + particle_set->p_am->extents*particle_id
546 + particle_set->p_am->displ[0][CS_LAGR_P_FLAG]));
547
548 flag = flag | mask;
549
550 *((cs_lnum_t *)( particle_set->p_buffer
551 + particle_set->p_am->extents*particle_id
552 + particle_set->p_am->displ[0][CS_LAGR_P_FLAG])) = flag;
553}
554
555/*----------------------------------------------------------------------------*/
563/*----------------------------------------------------------------------------*/
564
565inline static void
567 cs_lnum_t particle_id,
568 int mask)
569{
570 int flag
571 = *((const cs_lnum_t *)( particle_set->p_buffer
572 + particle_set->p_am->extents*particle_id
573 + particle_set->p_am->displ[0][CS_LAGR_P_FLAG]));
574
575 flag = (flag | mask) - mask;
576
577 *((cs_lnum_t *)( particle_set->p_buffer
578 + particle_set->p_am->extents*particle_id
579 + particle_set->p_am->displ[0][CS_LAGR_P_FLAG])) = flag;
580}
581
582/*----------------------------------------------------------------------------*/
592/*----------------------------------------------------------------------------*/
593
594inline static cs_lnum_t
596 cs_lnum_t particle_id,
598{
599 assert(particle_set->p_am->count[0][attr] > 0);
600
601 return *((const cs_lnum_t *)( particle_set->p_buffer
602 + particle_set->p_am->extents*particle_id
603 + particle_set->p_am->displ[0][attr]));
604}
605
606/*----------------------------------------------------------------------------*/
618/*----------------------------------------------------------------------------*/
619
620inline static cs_lnum_t
622 cs_lnum_t particle_id,
623 int time_id,
625{
626 assert(particle_set->p_am->count[time_id][attr] > 0);
627
628 return *((const cs_lnum_t *)( particle_set->p_buffer
629 + particle_set->p_am->extents*particle_id
630 + particle_set->p_am->displ[time_id][attr]));
631}
632
633/*----------------------------------------------------------------------------*/
642/*----------------------------------------------------------------------------*/
643
644inline static void
646 cs_lnum_t particle_id,
648 cs_lnum_t value)
649{
650 assert(particle_set->p_am->count[0][attr] > 0);
651
652 *((cs_lnum_t *)( particle_set->p_buffer
653 + particle_set->p_am->extents*particle_id
654 + particle_set->p_am->displ[0][attr])) = value;
655}
656
657/*----------------------------------------------------------------------------*/
668/*----------------------------------------------------------------------------*/
669
670inline static void
672 cs_lnum_t particle_id,
673 int time_id,
675 cs_lnum_t value)
676{
677 assert(particle_set->p_am->count[time_id][attr] > 0);
678
679 *((cs_lnum_t *)( particle_set->p_buffer
680 + particle_set->p_am->extents*particle_id
681 + particle_set->p_am->displ[time_id][attr])) = value;
682}
683
684/*----------------------------------------------------------------------------*/
694/*----------------------------------------------------------------------------*/
695
696inline static cs_gnum_t
698 cs_lnum_t particle_id,
700{
701 assert(particle_set->p_am->count[0][attr] > 0);
702
703 return *((const cs_gnum_t *)( particle_set->p_buffer
704 + particle_set->p_am->extents*particle_id
705 + particle_set->p_am->displ[0][attr]));
706}
707
708/*----------------------------------------------------------------------------*/
720/*----------------------------------------------------------------------------*/
721
722inline static cs_gnum_t
724 cs_lnum_t particle_id,
725 int time_id,
727{
728 assert(particle_set->p_am->count[time_id][attr] > 0);
729
730 return *((const cs_gnum_t *)( particle_set->p_buffer
731 + particle_set->p_am->extents*particle_id
732 + particle_set->p_am->displ[time_id][attr]));
733}
734
735/*----------------------------------------------------------------------------*/
744/*----------------------------------------------------------------------------*/
745
746inline static void
748 cs_lnum_t particle_id,
750 cs_gnum_t value)
751{
752 assert(particle_set->p_am->count[0][attr] > 0);
753
754 *((cs_gnum_t *)( particle_set->p_buffer
755 + particle_set->p_am->extents*particle_id
756 + particle_set->p_am->displ[0][attr])) = value;
757}
758
759/*----------------------------------------------------------------------------*/
770/*----------------------------------------------------------------------------*/
771
772inline static void
774 cs_lnum_t particle_id,
775 int time_id,
777 cs_gnum_t value)
778{
779 assert(particle_set->p_am->count[time_id][attr] > 0);
780
781 *((cs_gnum_t *)( particle_set->p_buffer
782 + particle_set->p_am->extents*particle_id
783 + particle_set->p_am->displ[time_id][attr])) = value;
784}
785
786/*----------------------------------------------------------------------------*/
796/*----------------------------------------------------------------------------*/
797
798inline static cs_real_t
800 cs_lnum_t particle_id,
802{
803 assert(particle_set->p_am->count[0][attr] > 0);
804
805 return *((const cs_real_t *)( particle_set->p_buffer
806 + particle_set->p_am->extents*particle_id
807 + particle_set->p_am->displ[0][attr]));
808}
809
810/*----------------------------------------------------------------------------*/
822/*----------------------------------------------------------------------------*/
823
824inline static cs_real_t
826 cs_lnum_t particle_id,
827 int time_id,
829{
830 assert(particle_set->p_am->count[time_id][attr] > 0);
831
832 return *((const cs_real_t *)( particle_set->p_buffer
833 + particle_set->p_am->extents*particle_id
834 + particle_set->p_am->displ[time_id][attr]));
835}
836
837/*----------------------------------------------------------------------------*/
846/*----------------------------------------------------------------------------*/
847
848inline static void
850 cs_lnum_t particle_id,
852 cs_real_t value)
853{
854 assert(particle_set->p_am->count[0][attr] > 0);
855
856 *((cs_real_t *)( particle_set->p_buffer
857 + particle_set->p_am->extents*particle_id
858 + particle_set->p_am->displ[0][attr])) = value;
859}
860
861/*----------------------------------------------------------------------------*/
872/*----------------------------------------------------------------------------*/
873
874inline static void
876 cs_lnum_t particle_id,
877 int time_id,
879 cs_real_t value)
880{
881 assert(particle_set->p_am->count[time_id][attr] > 0);
882
883 *((cs_real_t *)( particle_set->p_buffer
884 + particle_set->p_am->extents*particle_id
885 + particle_set->p_am->displ[time_id][attr])) = value;
886}
887
888/*----------------------------------------------------------------------------*/
899/*----------------------------------------------------------------------------*/
900
901inline static void
903 cs_lnum_t p_id)
904{
905 memset(p_set->p_buffer + p_set->p_am->extents * p_id,
906 0,
907 p_set->p_am->extents);
908}
909
910/*----------------------------------------------------------------------------*/
921/*----------------------------------------------------------------------------*/
922
923inline static cs_real_t *
925 cs_lnum_t particle_id,
927{
928 assert(particle_set->p_am->source_term_displ != NULL);
929 assert(particle_set->p_am->source_term_displ[attr] >= 0);
930
931 return (cs_real_t *)( (unsigned char *)particle_set->p_buffer
932 + particle_set->p_am->extents*particle_id
933 + particle_set->p_am->source_term_displ[attr]);
934}
935
936/*----------------------------------------------------------------------------*/
947/*----------------------------------------------------------------------------*/
948
949inline static const cs_real_t *
951 cs_lnum_t particle_id,
953{
954 assert(particle_set->p_am->source_term_displ != NULL);
955 assert(particle_set->p_am->source_term_displ[attr] >= 0);
956
957 return (const cs_real_t *)( (unsigned char *)particle_set->p_buffer
958 + particle_set->p_am->extents*particle_id
959 + particle_set->p_am->source_term_displ[attr]);
960}
961
962/*----------------------------------------------------------------------------*/
972/*----------------------------------------------------------------------------*/
973
974inline static void *
976 const cs_lagr_attribute_map_t *attr_map,
978{
979 assert(attr_map->count[0][attr] > 0);
980
981 return (unsigned char *)particle + attr_map->displ[0][attr];
982}
983
984/*----------------------------------------------------------------------------*/
994/*----------------------------------------------------------------------------*/
995
996inline static const void *
997cs_lagr_particle_attr_const(const void *particle,
998 const cs_lagr_attribute_map_t *attr_map,
1000{
1001 assert(attr_map->count[0][attr] > 0);
1002
1003 return (const unsigned char *)particle + attr_map->displ[0][attr];
1004}
1005
1006/*----------------------------------------------------------------------------*/
1017/*----------------------------------------------------------------------------*/
1018
1019inline static void *
1021 const cs_lagr_attribute_map_t *attr_map,
1022 int time_id,
1024{
1025 assert(attr_map->count[time_id][attr] > 0);
1026
1027 return (unsigned char *)particle + attr_map->displ[time_id][attr];
1028}
1029
1030/*----------------------------------------------------------------------------*/
1041/*----------------------------------------------------------------------------*/
1042
1043inline static const void *
1045 const cs_lagr_attribute_map_t *attr_map,
1046 int time_id,
1048{
1049 assert(attr_map->count[time_id][attr] > 0);
1050
1051 return (const unsigned char *)particle
1052 + attr_map->displ[time_id][attr];
1053}
1054
1055/*----------------------------------------------------------------------------*/
1065/*----------------------------------------------------------------------------*/
1066
1067inline static cs_lnum_t
1068cs_lagr_particle_get_lnum(const void *particle,
1069 const cs_lagr_attribute_map_t *attr_map,
1071{
1072 assert(attr_map->count[0][attr] > 0);
1073
1074 return *((const cs_lnum_t *)( (const unsigned char *)particle
1075 + attr_map->displ[0][attr]));
1076}
1077
1078/*----------------------------------------------------------------------------*/
1090/*----------------------------------------------------------------------------*/
1091
1092inline static cs_lnum_t
1093cs_lagr_particle_get_lnum_n(const void *particle,
1094 const cs_lagr_attribute_map_t *attr_map,
1095 int time_id,
1097{
1098 assert(attr_map->count[time_id][attr] > 0);
1099
1100 return *((const cs_lnum_t *)( (const unsigned char *)particle
1101 + attr_map->displ[time_id][attr]));
1102}
1103
1104/*----------------------------------------------------------------------------*/
1113 /*----------------------------------------------------------------------------*/
1114
1115inline static void
1117 const cs_lagr_attribute_map_t *attr_map,
1119 cs_lnum_t value)
1120{
1121 assert(attr_map->count[0][attr] > 0);
1122
1123 *((cs_lnum_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
1124 = value;
1125}
1126
1127/*----------------------------------------------------------------------------*/
1138 /*----------------------------------------------------------------------------*/
1139
1140inline static void
1142 const cs_lagr_attribute_map_t *attr_map,
1143 int time_id,
1145 cs_lnum_t value)
1146{
1147 assert(attr_map->count[time_id][attr] > 0);
1148
1149 *((cs_lnum_t *)( (unsigned char *)particle
1150 + attr_map->displ[time_id][attr])) = value;
1151}
1152
1153/*----------------------------------------------------------------------------*/
1163/*----------------------------------------------------------------------------*/
1164
1165inline static cs_gnum_t
1166cs_lagr_particle_get_gnum(const void *particle,
1167 const cs_lagr_attribute_map_t *attr_map,
1169{
1170 assert(attr_map->count[0][attr] > 0);
1171
1172 return *((const cs_gnum_t *)( (const unsigned char *)particle
1173 + attr_map->displ[0][attr]));
1174}
1175
1176/*----------------------------------------------------------------------------*/
1188/*----------------------------------------------------------------------------*/
1189
1190inline static cs_gnum_t
1191cs_lagr_particle_get_gnum_n(const void *particle,
1192 const cs_lagr_attribute_map_t *attr_map,
1193 int time_id,
1195{
1196 assert(attr_map->count[time_id][attr] > 0);
1197
1198 return *((const cs_gnum_t *)( (const unsigned char *)particle
1199 + attr_map->displ[time_id][attr]));
1200}
1201
1202/*----------------------------------------------------------------------------*/
1211 /*----------------------------------------------------------------------------*/
1212
1213inline static void
1215 const cs_lagr_attribute_map_t *attr_map,
1217 cs_gnum_t value)
1218{
1219 assert(attr_map->count[0][attr] > 0);
1220
1221 *((cs_gnum_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
1222 = value;
1223}
1224
1225/*----------------------------------------------------------------------------*/
1236 /*----------------------------------------------------------------------------*/
1237
1238inline static void
1240 const cs_lagr_attribute_map_t *attr_map,
1241 int time_id,
1243 cs_gnum_t value)
1244{
1245 assert(attr_map->count[time_id][attr] > 0);
1246
1247 *((cs_gnum_t *)( (unsigned char *)particle
1248 + attr_map->displ[time_id][attr])) = value;
1249}
1250
1251/*----------------------------------------------------------------------------*/
1261/*----------------------------------------------------------------------------*/
1262
1263inline static cs_real_t
1264cs_lagr_particle_get_real(const void *particle,
1265 const cs_lagr_attribute_map_t *attr_map,
1267{
1268 assert(attr_map->count[0][attr] > 0);
1269
1270 return *((const cs_real_t *)( (const unsigned char *)particle
1271 + attr_map->displ[0][attr]));
1272}
1273
1274/*----------------------------------------------------------------------------*/
1286/*----------------------------------------------------------------------------*/
1287
1288inline static cs_real_t
1289cs_lagr_particle_get_real_n(const void *particle,
1290 const cs_lagr_attribute_map_t *attr_map,
1291 int time_id,
1293{
1294 assert(attr_map->count[time_id][attr] > 0);
1295
1296 return *((const cs_real_t *)( (const unsigned char *)particle
1297 + attr_map->displ[time_id][attr]));
1298}
1299
1300/*----------------------------------------------------------------------------*/
1309 /*----------------------------------------------------------------------------*/
1310
1311inline static void
1313 const cs_lagr_attribute_map_t *attr_map,
1315 cs_real_t value)
1316{
1317 assert(attr_map->count[0][attr] > 0);
1318
1319 *((cs_real_t *)((unsigned char *)particle + attr_map->displ[0][attr]))
1320 = value;
1321}
1322
1323/*----------------------------------------------------------------------------*/
1334 /*----------------------------------------------------------------------------*/
1335
1336inline static void
1338 const cs_lagr_attribute_map_t *attr_map,
1339 int time_id,
1341 cs_real_t value)
1342{
1343 assert(attr_map->count[time_id][attr] > 0);
1344
1345 *((cs_real_t *)( (unsigned char *)particle
1346 + attr_map->displ[time_id][attr])) = value;
1347}
1348
1349/*----------------------------------------------------------------------------*/
1359/*----------------------------------------------------------------------------*/
1360
1361inline static cs_real_t *
1363 const cs_lagr_attribute_map_t *attr_map,
1365{
1366 assert(attr_map->source_term_displ != NULL);
1367 assert(attr_map->source_term_displ[attr] >= 0);
1368
1369 return (cs_real_t *)( (unsigned char *)particle
1370 + attr_map->source_term_displ[attr]);
1371}
1372
1373/*----------------------------------------------------------------------------*/
1383/*----------------------------------------------------------------------------*/
1384
1385inline static const cs_real_t *
1387 const cs_lagr_attribute_map_t *attr_map,
1389{
1390 assert(attr_map->source_term_displ != NULL);
1391 assert(attr_map->source_term_displ[attr] >= 0);
1392
1393 return (const cs_real_t *)( (unsigned char *)particle
1394 + attr_map->source_term_displ[attr]);
1395}
1396
1397/*----------------------------------------------------------------------------
1398 * Resize particle set buffers if needed.
1399 *
1400 * parameters:
1401 * n_particles <-- minumum number of particles required
1402 *
1403 *
1404 * returns:
1405 * 1 if resizing was required, 0 otherwise
1406 *----------------------------------------------------------------------------*/
1407
1408int
1409cs_lagr_particle_set_resize(cs_lnum_t n_min_particles);
1410
1411/*----------------------------------------------------------------------------
1412 * Set reallocation factor for particle sets.
1413 *
1414 * This factor determines the multiplier used for reallocations when
1415 * the particle set's buffers are too small to handle the new number of
1416 * particles.
1417 *
1418 * parameters:
1419 * f <-- reallocation size multiplier
1420 *----------------------------------------------------------------------------*/
1421
1422void
1424
1425/*----------------------------------------------------------------------------*/
1434/*----------------------------------------------------------------------------*/
1435
1436unsigned long long
1438
1439/*----------------------------------------------------------------------------*/
1448/*----------------------------------------------------------------------------*/
1449
1450void
1451cs_lagr_set_n_g_particles_max(unsigned long long n_g_particles_max);
1452
1453/*----------------------------------------------------------------------------*/
1460/*----------------------------------------------------------------------------*/
1461
1462void
1464 cs_lnum_t particle_id);
1465
1466/*----------------------------------------------------------------------------*/
1472/*----------------------------------------------------------------------------*/
1473
1474void
1476
1477/*----------------------------------------------------------------------------*/
1483/*----------------------------------------------------------------------------*/
1484
1485void
1486cs_lagr_set_n_user_variables(int n_user_variables);
1487
1488/*----------------------------------------------------------------------------*/
1489
1491
1492/*============================================================================
1493 * Public C++ templates
1494 *============================================================================*/
1495
1496#if defined(__cplusplus)
1497
1498template <typename T>
1499T *
1500cs_lagr_particles_attr_get_ptr(cs_lagr_particle_set_t *particle_set,
1501 cs_lnum_t particle_id,
1503{
1504 assert(particle_set->p_am->count[0][attr] > 0);
1505
1506 return (T *)( particle_set->p_buffer
1507 + particle_set->p_am->extents*particle_id
1508 + particle_set->p_am->displ[0][attr]);
1509}
1510
1511template <typename T>
1512const T *
1513cs_lagr_particles_attr_get_const_ptr(const cs_lagr_particle_set_t *particle_set,
1514 cs_lnum_t particle_id,
1516{
1517 assert(particle_set->p_am->count[0][attr] > 0);
1518
1519 return (const T *)( particle_set->p_buffer
1520 + particle_set->p_am->extents*particle_id
1521 + particle_set->p_am->displ[0][attr]);
1522}
1523
1524template <typename T>
1525T *
1526cs_lagr_particles_attr_n_get_ptr(cs_lagr_particle_set_t *particle_set,
1527 cs_lnum_t particle_id,
1528 int time_id,
1530{
1531 assert(particle_set->p_am->count[time_id][attr] > 0);
1532
1533 return (T *)( particle_set->p_buffer
1534 + particle_set->p_am->extents*particle_id
1535 + particle_set->p_am->displ[time_id][attr]);
1536}
1537
1538template <typename T>
1539const T *
1540cs_lagr_particles_attr_n_get_const_ptr(const cs_lagr_particle_set_t *particle_set,
1541 cs_lnum_t particle_id,
1542 int time_id,
1544{
1545 assert(particle_set->p_am->count[time_id][attr] > 0);
1546
1547 return (const T *)( particle_set->p_buffer
1548 + particle_set->p_am->extents*particle_id
1549 + particle_set->p_am->displ[time_id][attr]);
1550}
1551
1552template <typename T>
1553T
1554cs_lagr_particles_attr_get_val(const cs_lagr_particle_set_t *particle_set,
1555 cs_lnum_t particle_id,
1557{
1558 assert(particle_set->p_am->count[0][attr] > 0);
1559
1560 return *(T *)( particle_set->p_buffer
1561 + particle_set->p_am->extents*particle_id
1562 + particle_set->p_am->displ[0][attr]);
1563}
1564
1565template <typename T>
1566void
1567cs_lagr_particles_attr_set_val(cs_lagr_particle_set_t *particle_set,
1568 cs_lnum_t particle_id,
1570 T value)
1571{
1572 assert(particle_set->p_am->count[0][attr] > 0);
1573
1574 *(T *)( particle_set->p_buffer
1575 + particle_set->p_am->extents*particle_id
1576 + particle_set->p_am->displ[0][attr]) = value;
1577}
1578
1579template <typename T>
1580T
1581cs_lagr_particles_attr_n_get_val(const cs_lagr_particle_set_t *particle_set,
1582 cs_lnum_t particle_id,
1583 int time_id,
1585{
1586 assert(particle_set->p_am->count[time_id][attr] > 0);
1587
1588 return *(T *)( particle_set->p_buffer
1589 + particle_set->p_am->extents*particle_id
1590 + particle_set->p_am->displ[time_id][attr]);
1591}
1592
1593template <typename T>
1594void
1595cs_lagr_particles_attr_n_set_val(cs_lagr_particle_set_t *particle_set,
1596 cs_lnum_t particle_id,
1597 int time_id,
1599 T value)
1600{
1601 assert(particle_set->p_am->count[time_id][attr] > 0);
1602
1603 *(T *)( particle_set->p_buffer
1604 + particle_set->p_am->extents*particle_id
1605 + particle_set->p_am->displ[time_id][attr]) = value;
1606}
1607
1608template <typename T>
1609T *
1610cs_lagr_particle_attr_get_ptr(void *particle,
1611 const cs_lagr_attribute_map_t *attr_map,
1613{
1614 assert(attr_map->count[0][attr] > 0);
1615
1616 return (T *)((unsigned char *)particle + attr_map->displ[0][attr]);
1617}
1618
1619template <typename T>
1620const T *
1621cs_lagr_particle_attr_get_const_ptr(const void *particle,
1622 const cs_lagr_attribute_map_t *attr_map,
1624{
1625 assert(attr_map->count[0][attr] > 0);
1626
1627 return (const T *)( (const unsigned char *)particle
1628 + attr_map->displ[0][attr]);
1629}
1630
1631template <typename T>
1632T *
1633cs_lagr_particle_attr_n_get_ptr(void *particle,
1634 const cs_lagr_attribute_map_t *attr_map,
1635 int time_id,
1637{
1638 assert(attr_map->count[time_id][attr] > 0);
1639
1640 return (T *)((unsigned char *)particle + attr_map->displ[time_id][attr]);
1641}
1642
1643template <typename T>
1644const T *
1645cs_lagr_particle_attr_n_get_const_ptr(const void *particle,
1646 const cs_lagr_attribute_map_t *attr_map,
1647 int time_id,
1649{
1650 assert(attr_map->count[time_id][attr] > 0);
1651
1652 return (const T *)( (const unsigned char *)particle
1653 + attr_map->displ[time_id][attr]);
1654}
1655
1656template <typename T>
1657T
1658cs_lagr_particle_attr_get_val(const void *particle,
1659 const cs_lagr_attribute_map_t *attr_map,
1661{
1662 assert(attr_map->count[0][attr] > 0);
1663
1664 return *((const T *)( (const unsigned char *)particle
1665 + attr_map->displ[0][attr]));
1666}
1667
1668template <typename T>
1669void
1670cs_lagr_particle_attr_set_val(void *particle,
1671 const cs_lagr_attribute_map_t *attr_map,
1673 T value)
1674{
1675 assert(attr_map->count[0][attr] > 0);
1676
1677 *((T *)((unsigned char *)particle + attr_map->displ[0][attr]))
1678 = value;
1679}
1680
1681template <typename T>
1682T
1683cs_lagr_particle_attr_n_get_val(const void *particle,
1684 const cs_lagr_attribute_map_t *attr_map,
1685 int time_id,
1687{
1688 assert(attr_map->count[time_id][attr] > 0);
1689
1690 return *((const T *)( (const unsigned char *)particle
1691 + attr_map->displ[time_id][attr]));
1692}
1693
1694template <typename T>
1695void
1696cs_lagr_particle_attr_n_set_val(void *particle,
1697 const cs_lagr_attribute_map_t *attr_map,
1698 int time_id,
1700 T value)
1701{
1702 assert(attr_map->count[time_id][attr] > 0);
1703
1704 *((T *)( (unsigned char *)particle
1705 + attr_map->displ[time_id][attr])) = value;
1706}
1707
1708#endif
1709
1710/*----------------------------------------------------------------------------*/
1711
1712#endif /* __CS_LAGR_PARTICLE_H__ */
cs_datatype_t
Definition: cs_defs.h:300
#define BEGIN_C_DECLS
Definition: cs_defs.h:542
double cs_real_t
Floating-point value.
Definition: cs_defs.h:342
uint64_t cs_gnum_t
global mesh entity number
Definition: cs_defs.h:325
#define END_C_DECLS
Definition: cs_defs.h:543
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:335
void cs_lagr_particle_attr_in_range(int attr)
Check if a particle attribute is in a valid range.
Definition: cs_lagr_particle.cpp:1177
unsigned long long cs_lagr_get_n_g_particles_max(void)
Get global maximum number of particles.
Definition: cs_lagr_particle.cpp:1263
cs_lagr_attribute_t
Definition: cs_lagr_particle.h:80
@ CS_LAGR_DEPO_TIME
Definition: cs_lagr_particle.h:143
@ CS_LAGR_QUATERNION
Definition: cs_lagr_particle.h:117
@ CS_LAGR_FLUID_TEMPERATURE
Definition: cs_lagr_particle.h:149
@ CS_LAGR_HEIGHT
Definition: cs_lagr_particle.h:141
@ CS_LAGR_FOULING_INDEX
Definition: cs_lagr_particle.h:129
@ CS_LAGR_COAL_DENSITY
Definition: cs_lagr_particle.h:162
@ CS_LAGR_MASS
Definition: cs_lagr_particle.h:93
@ CS_LAGR_PRED_VELOCITY
Definition: cs_lagr_particle.h:108
@ CS_LAGR_EMISSIVITY
Definition: cs_lagr_particle.h:166
@ CS_LAGR_AGGLO_CLASS_ID
Definition: cs_lagr_particle.h:173
@ CS_LAGR_NEIGHBOR_FACE_ID
Definition: cs_lagr_particle.h:127
@ CS_LAGR_PRED_VELOCITY_SEEN
Definition: cs_lagr_particle.h:109
@ CS_LAGR_CLUSTER_NB_PART
Definition: cs_lagr_particle.h:142
@ CS_LAGR_RADII
Definition: cs_lagr_particle.h:118
@ CS_LAGR_ORIENTATION
Definition: cs_lagr_particle.h:116
@ CS_LAGR_TR_TRUNCATE
Definition: cs_lagr_particle.h:100
@ CS_LAGR_USER
Definition: cs_lagr_particle.h:178
@ CS_LAGR_DISPLACEMENT_NORM
Definition: cs_lagr_particle.h:137
@ CS_LAGR_COAL_MASS
Definition: cs_lagr_particle.h:155
@ CS_LAGR_VELOCITY
Definition: cs_lagr_particle.h:97
@ CS_LAGR_BR_GAUSS
Definition: cs_lagr_particle.h:111
@ CS_LAGR_INTERF
Definition: cs_lagr_particle.h:126
@ CS_LAGR_MARKO_VALUE
Definition: cs_lagr_particle.h:128
@ CS_LAGR_COKE_MASS
Definition: cs_lagr_particle.h:156
@ CS_LAGR_CELL_ID
Definition: cs_lagr_particle.h:84
@ CS_LAGR_REBOUND_ID
Definition: cs_lagr_particle.h:87
@ CS_LAGR_TAUP_AUX
Definition: cs_lagr_particle.h:95
@ CS_LAGR_RESIDENCE_TIME
Definition: cs_lagr_particle.h:92
@ CS_LAGR_TURB_STATE_1
Definition: cs_lagr_particle.h:107
@ CS_LAGR_TEMPERATURE
Definition: cs_lagr_particle.h:148
@ CS_LAGR_TR_REPOSITION
Definition: cs_lagr_particle.h:101
@ CS_LAGR_CP
Definition: cs_lagr_particle.h:150
@ CS_LAGR_RANDOM_VALUE
Definition: cs_lagr_particle.h:89
@ CS_LAGR_SHAPE_PARAM
Definition: cs_lagr_particle.h:121
@ CS_LAGR_RANK_ID
Definition: cs_lagr_particle.h:85
@ CS_LAGR_COAL_ID
Definition: cs_lagr_particle.h:161
@ CS_LAGR_INITIAL_DIAMETER
Definition: cs_lagr_particle.h:159
@ CS_LAGR_ADHESION_FORCE
Definition: cs_lagr_particle.h:135
@ CS_LAGR_STAT_WEIGHT
Definition: cs_lagr_particle.h:91
@ CS_LAGR_N_SMALL_ASPERITIES
Definition: cs_lagr_particle.h:134
@ CS_LAGR_N_ATTRIBUTES
Definition: cs_lagr_particle.h:182
@ CS_LAGR_ADHESION_TORQUE
Definition: cs_lagr_particle.h:136
@ CS_LAGR_ANGULAR_VEL
Definition: cs_lagr_particle.h:119
@ CS_LAGR_VELOCITY_SEEN
Definition: cs_lagr_particle.h:98
@ CS_LAGR_STAT_CLASS
Definition: cs_lagr_particle.h:170
@ CS_LAGR_N_LARGE_ASPERITIES
Definition: cs_lagr_particle.h:133
@ CS_LAGR_P_FLAG
Definition: cs_lagr_particle.h:82
@ CS_LAGR_SHRINKING_DIAMETER
Definition: cs_lagr_particle.h:158
@ CS_LAGR_V_GAUSS
Definition: cs_lagr_particle.h:110
@ CS_LAGR_SHAPE
Definition: cs_lagr_particle.h:115
@ CS_LAGR_AGGLO_FRACTAL_DIM
Definition: cs_lagr_particle.h:174
@ CS_LAGR_YPLUS
Definition: cs_lagr_particle.h:125
@ CS_LAGR_WATER_MASS
Definition: cs_lagr_particle.h:154
@ CS_LAGR_CONSOL_HEIGHT
Definition: cs_lagr_particle.h:144
@ CS_LAGR_DIAMETER
Definition: cs_lagr_particle.h:94
@ CS_LAGR_COORDS
Definition: cs_lagr_particle.h:96
@ CS_LAGR_EULER
Definition: cs_lagr_particle.h:120
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_particle.h:1191
static void cs_lagr_particles_set_flag(const cs_lagr_particle_set_t *particle_set, cs_lnum_t particle_id, int mask)
Set flag value with a selected mask for a given particle in a set.
Definition: cs_lagr_particle.h:539
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_particle.h:975
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_particle.h:849
static void cs_lagr_particles_unset_flag(const cs_lagr_particle_set_t *particle_set, cs_lnum_t particle_id, int mask)
Unset flag value with a selected mask for a given particle in a set.
Definition: cs_lagr_particle.h:566
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_particle.h:1116
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.cpp:1323
static int cs_lagr_particles_get_flag(const cs_lagr_particle_set_t *particle_set, cs_lnum_t particle_id, int mask)
Get flag value with a selected mask for a given particle in a set.
Definition: cs_lagr_particle.h:516
void cs_lagr_particle_attr_initialize(void)
Define particle map based on defined options.
Definition: cs_lagr_particle.cpp:678
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_particle.h:671
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.cpp:1295
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_particle.h:1166
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_particle.h:438
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_particle.h:747
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_particle.h:997
cs_lagr_particle_set_t * cs_glob_lagr_particle_set
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_particle.h:1386
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_particle.h:621
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_particle.h:825
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_particle.h:413
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_particle.h:1020
void cs_lagr_set_reallocation_factor(double f)
Set reallocation factor for particle sets.
Definition: cs_lagr_particle.cpp:1245
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_particle.h:1264
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_particle.h:1362
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_particle.h:1044
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_particle.h:1312
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_particle.h:723
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_particle.h:875
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_particle.h:697
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.cpp:1194
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_particle.h:1093
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_particle.h:1337
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_particle.h:464
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_particle.h:773
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_particle.h:645
static void cs_lagr_particles_attributes_fill_zero(cs_lagr_particle_set_t *p_set, cs_lnum_t p_id)
Set attribute value of type cs_real_t of a given particle in a set at a given time.
Definition: cs_lagr_particle.h:902
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_particle.h:924
void cs_lagr_set_n_user_variables(int n_user_variables)
Set number of user particle variables.
Definition: cs_lagr_particle.cpp:1351
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_particle.h:950
void cs_lagr_particle_finalize(void)
Destroy main particle set and map if they exist.
Definition: cs_lagr_particle.cpp:1021
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_particle.h:491
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.cpp:1280
void cs_lagr_part_copy(cs_lnum_t dest, cs_lnum_t src)
Copy attributes from one particle to another.
Definition: cs_lagr_particle.cpp:1040
int cs_lagr_particle_set_resize(cs_lnum_t n_min_particles)
Resize particle set buffers if needed.
Definition: cs_lagr_particle.cpp:1214
void cs_lagr_particle_set_create(void)
Definition: cs_lagr_particle.cpp:1004
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_particle.h:1239
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.cpp:1112
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_particle.h:1141
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_particle.h:1289
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_particle.h:1068
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.cpp:1075
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_particle.h:1214
const char * cs_lagr_attribute_name[]
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.cpp:991
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_particle.h:799
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_particle.h:595
Definition: cs_lagr_particle.h:189
ptrdiff_t(* displ)[CS_LAGR_N_ATTRIBUTES]
Definition: cs_lagr_particle.h:209
int(* count)[CS_LAGR_N_ATTRIBUTES]
Definition: cs_lagr_particle.h:206
size_t lb
Definition: cs_lagr_particle.h:193
ptrdiff_t * source_term_displ
Definition: cs_lagr_particle.h:213
int n_time_vals
Definition: cs_lagr_particle.h:197
size_t extents
Definition: cs_lagr_particle.h:191
Definition: cs_lagr_particle.h:223
cs_real_t weight_merged
Definition: cs_lagr_particle.h:237
cs_lnum_t n_part_merged
Definition: cs_lagr_particle.h:228
cs_real_t weight
Definition: cs_lagr_particle.h:234
cs_lnum_t n_particles
Definition: cs_lagr_particle.h:225
cs_lnum_t n_part_new
Definition: cs_lagr_particle.h:226
cs_real_t weight_out
Definition: cs_lagr_particle.h:236
cs_real_t weight_failed
Definition: cs_lagr_particle.h:241
cs_real_t weight_dep
Definition: cs_lagr_particle.h:238
unsigned char * p_buffer
Definition: cs_lagr_particle.h:247
cs_lnum_t n_failed_part
Definition: cs_lagr_particle.h:232
cs_real_t weight_fou
Definition: cs_lagr_particle.h:239
cs_lnum_t n_part_resusp
Definition: cs_lagr_particle.h:231
cs_real_t weight_new
Definition: cs_lagr_particle.h:235
cs_lnum_t n_part_out
Definition: cs_lagr_particle.h:227
const cs_lagr_attribute_map_t * p_am
Definition: cs_lagr_particle.h:245
cs_lnum_t n_part_fou
Definition: cs_lagr_particle.h:230
cs_lnum_t n_part_dep
Definition: cs_lagr_particle.h:229
cs_lnum_t n_particles_max
Definition: cs_lagr_particle.h:243
cs_real_t weight_resusp
Definition: cs_lagr_particle.h:240