cs_array_reduce.h

Go to the documentation of this file.

#ifndef CS_ARRAY_REDUCE_H
#define CS_ARRAY_REDUCE_H
 
/*============================================================================
 * Common array reduction operations.
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2025 EDF S.A.
 
  This program is free software; you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
  Foundation; either version 2 of the License, or (at your option) any later
  version.
 
  This program is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  details.
 
  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
  Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
 
/*----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------
 *  Local headers
 *----------------------------------------------------------------------------*/
 
#include "base/cs_defs.h"
#include "base/cs_dispatch.h"
#include "base/cs_reducers.h"
 
/*----------------------------------------------------------------------------*/
 
/*=============================================================================
 * Macro definitions
 *============================================================================*/
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
#ifdef __cplusplus
 
/*=============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*
 * \brief  Compute the min./max. of a 1-dimensional array.
 *
 * \param[in]   n        local number of elements
 * \param[in]   v        pointer to values (size: n)
 * \param[out]  vmin     minimum value
 * \param[out]  vmax     maximum value
 */
/*----------------------------------------------------------------------------*/
 
void
cs_array_reduce_minmax(cs_lnum_t          n,
                       const cs_real_t    v[],
                       cs_real_t         &vmin,
                       cs_real_t         &vmax);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
template <size_t stride>
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[])
{
  struct cs_double_n<stride> rd;
  struct cs_reduce_sum_nr<stride> reducer;
 
  /* If all values are defined on same list */
  if (v_elt_list == nullptr) {
    ctx.parallel_for_reduce(n_elts, rd, reducer,
      [=] CS_F_HOST_DEVICE (cs_lnum_t i, cs_double_n<stride> &res) {
      for (size_t k = 0; k < stride; k++)
        res.r[k] = v[stride*i + k];
    });
  }
  /* If values are defined on parent list */
  else {
    ctx.parallel_for_reduce(n_elts, rd, reducer,
      [=] CS_F_HOST_DEVICE (cs_lnum_t i, cs_double_n<stride> &res) {
      for (size_t k = 0; k < stride; k++)
        res.r[k] = v[stride*v_elt_list[i] + k];
    });
  }
  ctx.wait();
 
  for (size_t k = 0; k < stride; k++)
    vsum[k] = rd.r[k];
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
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[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
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[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
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[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
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[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
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[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
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[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
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[]);
 
/*----------------------------------------------------------------------------*/
 
#endif // __cplusplus
 
#endif /*CS_ARRAY_REDUCE_H */