cs_array_reduce.h File Reference

#include "cs_defs.h"
#include "cs_mesh.h"

Include dependency graph for cs_array_reduce.h:

Go to the source code of this file.

Functions
void	cs_array_reduce_sum_l (cs_lnum_t n_elts, int dim, 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. More...
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. More...
void	cs_array_reduce_simple_stats_l (cs_lnum_t n_elts, 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. More...
void	cs_array_reduce_simple_stats_l_w (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 components for a given mesh location. More...
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, sum of squared values and weighted sum of squared values) of an n-dimensional cs_real_t array's components. More...
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 weight array is mandatory. More...

Function Documentation

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.

The maximum allowed dimension is 3. The array is interleaved.

For arrays of dimension 3, the statistics relative to the norm are also computed, and added at the end of the statistics arrays (which must be size dim+1).

The algorithm here is similar to that used for BLAS.

Parameters

[in]	n_elts	number of local elements
[in]	dim	local array dimension (max: 9)
[in]	v_elt_list	optional list of parent elements on which values are defined, or NULL
[in]	v	pointer to array values
[out]	vmin	resulting min array (size: dim, or 4 if dim = 3)
[out]	vmax	resulting max array (size: dim, or 4 if dim = 3)

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, sum of squared values and weighted sum of squared values) of an n-dimensional cs_real_t array's components.

The maximum allowed dimension is 3. The array is interleaved.

For arrays of dimension 3, the statistics relative to the norm are also computed, and added at the end of the statistics arrays (which must be size dim+1).

The algorithm here is similar to that used for BLAS, but computes several quantities simultaneously for better cache behavior

parameters: n_elts <– number of local elements dim <– local array dimension (max: 3) v_elt_list <– optional list of parent elements on which values are defined, or NULL w_elt_list <– optional list of parent elements on which weights are defined, or NULL; if v_elt_list is defined (ie. non-NULL),then w_elt_list = v_elt_list is assumed, so this parameter is ignored v <– pointer to array values w <– pointer to weights vmin --> resulting min array (size: dim, or 4 if dim = 3) vmax --> resulting max array (same size as vmin) vsum --> resulting sum array (same size as vmin) wsum --> resulting weighted sum array (same size as vmin) asum --> resulting sum of absolute values (same size as vmin) ssum --> resulting weighted sum array (same size as vmin) wssum --> resulting weighted sum of squared values (same size as vmin)

cs_array_reduce_simple_stats_l()

void cs_array_reduce_simple_stats_l	(	cs_lnum_t	n_elts,
		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.

The maximum allowed dimension is 9 (allowing for a rank-2 tensor). The array is interleaved.

For arrays of dimension 3, the statistics relative to the norm are also computed, and added at the end of the statistics arrays (which must be size dim+1).

The algorithm here is similar to that used for BLAS, but computes several quantities simultaneously for better cache behavior

Parameters

[in]	n_elts	number of local elements
[in]	dim	local array dimension (max: 9)
[in]	v_elt_list	optional list of parent elements on which values are defined, or NULL
[in]	v	pointer to array values
[out]	vmin	resulting min array (size: dim, or 4 if dim = 3)
[out]	vmax	resulting max array (size: dim, or 4 if dim = 3)
[out]	vsum	resulting sum array (size: dim, or 4 if dim = 3)

cs_array_reduce_simple_stats_l_w()

void cs_array_reduce_simple_stats_l_w	(	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 components for a given mesh location.

The maximum allowed dimension is 9 (allowing for a rank-2 tensor). The array is interleaved.

For arrays of dimension 3, the statistics relative to the norm are also computed, and added at the end of the statistics arrays (which must be size dim+1).

The algorithm here is similar to that used for BLAS, but computes several quantities simultaneously for better cache behavior

parameters: n_elts <– number of local elements dim <– local array dimension (max: 9) v_elt_list <– optional list of parent elements on which values are defined, or NULL w_elt_list <– optional list of parent elements on which weights are defined, or NULL; if v_elt_list is defined (ie. non-NULL),then w_elt_list = v_elt_list is assumed, so this parameter is ignored v <– pointer to array values w <– pointer to weights vmin --> resulting min array (size: dim, or 4 if dim = 3) vmax --> resulting max array (size: dim, or 4 if dim = 3) vsum --> resulting sum array (size: dim, or 4 if dim = 3) wsum --> resulting weighted sum array (size: dim, or 4 if dim = 3)

The maximum allowed dimension is 9 (allowing for a rank-2 tensor). The array is interleaved.

For arrays of dimension 3, the statistics relative to the norm are also computed, and added at the end of the statistics arrays (which must be size dim+1).

The algorithm here is similar to that used for BLAS, but computes several quantities simultaneously for better cache behavior

Parameters

[in]	n_elts	number of local elements
[in]	dim	local array dimension (max: 9)
[in]	v_elt_list	optional list of parent elements on which values are defined, or NULL
[in]	w_elt_list	optional list of parent elements on which weights are defined, or NULL; if v_elt_list is defined (ie. non-NULL),then w_elt_list = v_elt_list is assumed, so this parameter is ignored
[in]	v	pointer to array values
[in]	w	pointer to weights
[out]	vmin	resulting min array (size: dim, or 4 if dim = 3)
[out]	vmax	resulting max array (size: dim, or 4 if dim = 3)
[out]	vsum	resulting sum array (size: dim, or 4 if dim = 3)
[out]	wsum	resulting weighted sum array (size: dim, or 4 if dim = 3)

cs_array_reduce_sum_l()

void cs_array_reduce_sum_l	(	cs_lnum_t	n_elts,
		int	dim,
		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.

The maximum allowed dimension is 9 (allowing for a rank-2 tensor). The array is interleaved.

For arrays of dimension 3, the statistics relative to the norm are also computed, and added at the end of the statistics arrays (which must be size dim+1).

The algorithm here is similar to that used for BLAS.

Parameters

[in]	n_elts	number of local elements
[in]	dim	local array dimension (max: 9)
[in]	v_elt_list	optional list of parent elements on which values are defined, or NULL
[in]	v	pointer to array values
[out]	vsum	resulting sum array (size: dim, or 4 if dim = 3)

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 weight array is mandatory.

The maximum allowed dimension is 3. The array is interleaved.

For arrays of dimension 3, the statistics relative to the norm are also computed, and added at the end of the statistics arrays (which must be size dim+1).

The algorithm here is similar to that used for BLAS, but computes several quantities simultaneously for better cache behavior

parameters: n_src_elts <– number of source elements src2v_idx <– index array between source elements and local elements src2v_ids <– list of ids of local elements filter_list <– optional list of source elements on which values are defined, or NULL dim <– local array dimension (max: 3) n_v_elts <– number of local elements in the array of values v <– pointer to array values w <– pointer to weights (size = src2v_idx[n_src_elts]) vsum --> (weighted) sum array (size: dim, or 4 if dim = 3) asum --> (weighted) sum of absolute values (same size as vsum) ssum --> (weighted) sum of squared values (same size as vsum)