9.2
general documentation
cs_array_reduce.h
Go to the documentation of this file.
1#ifndef CS_ARRAY_REDUCE_H
2#define CS_ARRAY_REDUCE_H
3
4/*============================================================================
5 * Common array reduction operations.
6 *============================================================================*/
7
8/*
9 This file is part of code_saturne, a general-purpose CFD tool.
10
11 Copyright (C) 1998-2026 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/*----------------------------------------------------------------------------
31 * Local headers
32 *----------------------------------------------------------------------------*/
33
34#include "base/cs_defs.h"
35#include "base/cs_dispatch.h"
36#include "base/cs_reducers.h"
37
38/*----------------------------------------------------------------------------*/
39
40/*=============================================================================
41 * Macro definitions
42 *============================================================================*/
43
44/*============================================================================
45 * Type definitions
46 *============================================================================*/
47
48/*=============================================================================
49 * Public function prototypes
50 *============================================================================*/
51
52/*----------------------------------------------------------------------------*/
53/*
54 * \brief Compute the min./max. of a 1-dimensional array.
55 *
56 * \param[in] n local number of elements
57 * \param[in] v pointer to values (size: n)
58 * \param[out] vmin minimum value
59 * \param[out] vmax maximum value
60 */
61/*----------------------------------------------------------------------------*/
62
63void
64cs_array_reduce_minmax(cs_lnum_t n,
65 const cs_real_t v[],
66 cs_real_t &vmin,
67 cs_real_t &vmax);
68
69/*----------------------------------------------------------------------------*/
87/*----------------------------------------------------------------------------*/
88
89template <size_t stride>
90void
91cs_array_reduce_sum_l(cs_dispatch_context ctx,
92 cs_lnum_t n_elts,
93 const cs_lnum_t *v_elt_list,
94 const cs_real_t v[],
95 double vsum[])
96{
97 struct cs_double_n<stride> rd;
98 struct cs_reduce_sum_nr<stride> reducer;
99
100 /* If all values are defined on same list */
101 if (v_elt_list == nullptr) {
102 ctx.parallel_for_reduce(n_elts, rd, reducer,
103 [=] CS_F_HOST_DEVICE (cs_lnum_t i, cs_double_n<stride> &res) {
104 for (size_t k = 0; k < stride; k++)
105 res.r[k] = v[stride*i + k];
106 });
107 }
108 /* If values are defined on parent list */
109 else {
110 ctx.parallel_for_reduce(n_elts, rd, reducer,
111 [=] CS_F_HOST_DEVICE (cs_lnum_t i, cs_double_n<stride> &res) {
112 for (size_t k = 0; k < stride; k++)
113 res.r[k] = v[stride*v_elt_list[i] + k];
114 });
115 }
116 ctx.wait();
117
118 for (size_t k = 0; k < stride; k++)
119 vsum[k] = rd.r[k];
120}
121
122/*----------------------------------------------------------------------------*/
146/*----------------------------------------------------------------------------*/
147
148void
149cs_array_reduce_simple_stats_l(cs_dispatch_context ctx,
150 const cs_lnum_t n_elts,
151 const int dim,
152 const cs_lnum_t *v_elt_list,
153 const cs_real_t v[],
154 double vmin[],
155 double vmax[],
156 double vsum[]);
157
158/*----------------------------------------------------------------------------*/
185/*----------------------------------------------------------------------------*/
186
187void
188cs_array_reduce_wsum_l(cs_lnum_t n_elts,
189 int dim,
190 const cs_lnum_t *v_elt_list,
191 const cs_lnum_t *w_elt_list,
192 const cs_real_t v[],
193 const cs_real_t w[],
194 double wsum[]);
195
196/*----------------------------------------------------------------------------*/
226/*----------------------------------------------------------------------------*/
227
228void
229cs_array_reduce_wsum_components_l(cs_lnum_t n_elts,
230 int dim,
231 const cs_lnum_t *v_elt_list,
232 const cs_lnum_t *w_elt_list,
233 const cs_real_t v[],
234 const cs_real_t w[],
235 double wsum[],
236 double wtot[]);
237
238/*----------------------------------------------------------------------------*/
258/*----------------------------------------------------------------------------*/
259
260void
261cs_array_reduce_minmax_l(cs_lnum_t n_elts,
262 int dim,
263 const cs_lnum_t *v_elt_list,
264 const cs_real_t v[],
265 cs_real_t vmin[],
266 cs_real_t vmax[]);
267
268/*----------------------------------------------------------------------------*/
300/*----------------------------------------------------------------------------*/
301
302void
303cs_array_reduce_simple_stats_l_w(cs_dispatch_context ctx,
304 cs_lnum_t n_elts,
305 int dim,
306 const cs_lnum_t *v_elt_list,
307 const cs_lnum_t *w_elt_list,
308 const cs_real_t v[],
309 const cs_real_t w[],
310 double vmin[],
311 double vmax[],
312 double vsum[],
313 double wsum[]);
314
315/*----------------------------------------------------------------------------*/
350/*----------------------------------------------------------------------------*/
351
352void
353cs_array_reduce_simple_norms_l(cs_lnum_t n_elts,
354 int dim,
355 const cs_lnum_t *v_elt_list,
356 const cs_lnum_t *w_elt_list,
357 const cs_real_t v[],
358 const cs_real_t w[],
359 double vmin[],
360 double vmax[],
361 double vsum[],
362 double wsum[],
363 double asum[],
364 double ssum[],
365 double wssum[]);
366
367/*----------------------------------------------------------------------------*/
397/*----------------------------------------------------------------------------*/
398
399void
400cs_array_scatter_reduce_norms_l(cs_lnum_t n_src_elts,
401 const cs_lnum_t *src2v_idx,
402 const cs_lnum_t *src2v_ids,
403 const cs_lnum_t *filter_list,
404 int dim,
405 cs_lnum_t n_v_elts,
406 const cs_real_t v[],
407 const cs_real_t w[],
408 double vsum[],
409 double asum[],
410 double ssum[]);
411
412/*----------------------------------------------------------------------------*/
413
414#endif /* CS_ARRAY_REDUCE_H */
cs_combined_context::parallel_for_reduce
auto parallel_for_reduce(cs_lnum_t n, T &result, R &reducer, F &&f, Args &&... args)
Definition: cs_dispatch.h:2195
cs_combined_context::wait
void wait(void)
Wait (synchronize) until launched computations have finished.
Definition: cs_dispatch.h:2211
cs_dispatch_context
Definition: cs_dispatch.h:2288
cs_array_reduce_sum_l
void cs_array_reduce_sum_l(cs_dispatch_context ctx, cs_lnum_t n_elts, const cs_lnum_t *v_elt_list, const cs_real_t v[], double vsum[])
Compute sums of an n-dimensional cs_real_t array's components.
Definition: cs_array_reduce.h:91
cs_array_reduce_minmax
void cs_array_reduce_minmax(cs_lnum_t n, const cs_real_t v[], cs_real_t &vmin, cs_real_t &vmax)
Compute the min./max. of a 1-dimensional array.
Definition: cs_array_reduce.cpp:2672
cs_array_reduce_simple_norms_l
void cs_array_reduce_simple_norms_l(cs_lnum_t n_elts, int dim, const cs_lnum_t *v_elt_list, const cs_lnum_t *w_elt_list, const cs_real_t v[], const cs_real_t w[], double vmin[], double vmax[], double vsum[], double wsum[], double asum[], double ssum[], double wssum[])
Compute simple local stats and norms (minima, maxima, sum, weighted sum, sum of absolute values,...
Definition: cs_array_reduce.cpp:3125
cs_array_reduce_wsum_components_l
void cs_array_reduce_wsum_components_l(cs_lnum_t n_elts, int dim, const cs_lnum_t *v_elt_list, const cs_lnum_t *w_elt_list, const cs_real_t v[], const cs_real_t w[], double wsum[], double wtot[])
Compute weighted sums of an n-dimensional cs_real_t array's components. Output is both weighted sum a...
Definition: cs_array_reduce.cpp:2884
cs_array_reduce_simple_stats_l
void cs_array_reduce_simple_stats_l(cs_dispatch_context ctx, const cs_lnum_t n_elts, const int dim, const cs_lnum_t *v_elt_list, const cs_real_t v[], double vmin[], double vmax[], double vsum[])
Compute simple local stats (minima, maxima, sum) of an n-dimensional cs_real_t array's components.
Definition: cs_array_reduce.cpp:2735
cs_array_reduce_simple_stats_l_w
void cs_array_reduce_simple_stats_l_w(cs_dispatch_context ctx, cs_lnum_t n_elts, int dim, const cs_lnum_t *v_elt_list, const cs_lnum_t *w_elt_list, const cs_real_t v[], const cs_real_t w[], double vmin[], double vmax[], double vsum[], double wsum[])
Compute simple local stats (minima, maxima, sum, weighted sum) of an n-dimensional cs_real_t array's ...
Definition: cs_array_reduce.cpp:3024
cs_array_reduce_minmax_l
void cs_array_reduce_minmax_l(cs_lnum_t n_elts, int dim, const cs_lnum_t *v_elt_list, const cs_real_t v[], cs_real_t vmin[], cs_real_t vmax[])
Compute sums of an n-dimensional cs_real_t array's components.
Definition: cs_array_reduce.cpp:2956
cs_array_reduce_wsum_l
void cs_array_reduce_wsum_l(cs_lnum_t n_elts, int dim, const cs_lnum_t *v_elt_list, const cs_lnum_t *w_elt_list, const cs_real_t v[], const cs_real_t w[], double wsum[])
Compute weighted sums of an n-dimensional cs_real_t array's components.
Definition: cs_array_reduce.cpp:2803
cs_array_scatter_reduce_norms_l
void cs_array_scatter_reduce_norms_l(cs_lnum_t n_src_elts, const cs_lnum_t *src2v_idx, const cs_lnum_t *src2v_ids, const cs_lnum_t *filter_list, int dim, cs_lnum_t n_v_elts, const cs_real_t v[], const cs_real_t w[], double vsum[], double asum[], double ssum[])
Compute simple local weighted norms (l1, l2) of an n-dimensional cs_real_t array's components The wei...
Definition: cs_array_reduce.cpp:3215
cs_defs.h
CS_F_HOST_DEVICE
#define CS_F_HOST_DEVICE
Definition: cs_defs.h:555
cs_real_t
double cs_real_t
Floating-point value.
Definition: cs_defs.h:332
cs_lnum_t
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:325
cs_dispatch.h
k
@ k
Definition: cs_field_pointer.h:68
cs_reducers.h
cs_double_n
Definition: cs_reducers.h:62
cs_double_n::r
double r[stride]
Definition: cs_reducers.h:63
cs_reduce_sum_nr
Definition: cs_reducers.h:217