8.0
general documentation
Loading...
Searching...
No Matches
cs_order.h
Go to the documentation of this file.
1#ifndef __CS_ORDER_H__
2#define __CS_ORDER_H__
3
4/*============================================================================
5 * Functions related to the ordering of local arrays.
6 *============================================================================*/
7
8/*
9 This file is part of code_saturne, a general-purpose CFD tool.
10
11 Copyright (C) 1998-2023 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 "cs_defs.h"
35
36/*----------------------------------------------------------------------------*/
37
39
40/*=============================================================================
41 * Macro definitions
42 *============================================================================*/
43
44/*============================================================================
45 * Type definitions
46 *============================================================================*/
47
48/*=============================================================================
49 * Static global variables
50 *============================================================================*/
51
52/*=============================================================================
53 * Public function prototypes
54 *============================================================================*/
55
56/*----------------------------------------------------------------------------
57 * Test if an array of global numbers is ordered.
58 *
59 * parameters:
60 * list <-- optional list (0 to n-1 numbering) of selected entities
61 * (or NULL if all nb_ent are selected). This list may
62 * contain element numbers in any order
63 * number <-- array of all entity numbers (number of entity i
64 * given by number[i] or number[list[i]] if list exists
65 * (if NULL, a default 0 to n-1 numbering is considered)
66 * nb_ent <-- number of entities considered
67 *
68 * returns:
69 * 1 if ordered, 0 otherwise.
70 *----------------------------------------------------------------------------*/
71
72int
73cs_order_gnum_test(const cs_lnum_t list[],
74 const cs_gnum_t number[],
75 size_t nb_ent);
76
77/*----------------------------------------------------------------------------
78 * Return an ordering table associated with an array of global numbers.
79 *
80 * parameters:
81 * list <-- optional list (0 to n-1 numbering) of selected entities
82 * (or NULL if all nb_ent are selected). This list may
83 * contain element numbers in any order
84 * number <-- array of all entity numbers (number of entity i
85 * given by number[i] or number[list[i]]) if list exists
86 * (if NULL, a default 0 to n-1 numbering is considered)
87 * nb_ent <-- number of entities considered
88 *
89 * returns:
90 * pointer to list of nb_ent entities (0 to n-1 numbering) ordered by
91 * increasing associated number. The calling code is responsible for
92 * freeing this array when it is not needed anymore
93 *----------------------------------------------------------------------------*/
94
96cs_order_gnum(const cs_lnum_t list[],
97 const cs_gnum_t number[],
98 size_t nb_ent);
99
100/*----------------------------------------------------------------------------
101 * Return a lexicographical ordering table associated with a strided array
102 * of global numbers.
103 *
104 * parameters:
105 * list <-- optional list (0 to n-1 numbering) of selected entities
106 * (or NULL if all nb_ent are selected). This list may
107 * contain element numbers in any order
108 * number <-- array of all entity numbers (number of entity i
109 * given by number[i] or number[list[i]]) if list exists
110 * (if NULL, a default 0 to n-1 numbering is considered)
111 * stride <-- stride of number array (number of values to compare)
112 * nb_ent <-- number of entities considered
113 *
114 * returns:
115 * pointer to list of nb_ent entities (0 to n-1 numbering) ordered by
116 * increasing associated number. The calling code is responsible for
117 * freeing this array when it is not needed anymore.
118 *----------------------------------------------------------------------------*/
119
120cs_lnum_t *
121cs_order_gnum_s(const cs_lnum_t list[],
122 const cs_gnum_t number[],
123 size_t stride,
124 size_t nb_ent);
125
126/*----------------------------------------------------------------------------
127 * Return a lexicographical ordering table associated with an indexed array
128 * of global numbers.
129 *
130 * parameters:
131 * list <-- optional list (0 to n-1 numbering) of selected entities
132 * (or NULL if all nb_ent are selected). This list may
133 * contain element numbers in any order
134 * number <-- array of all entity numbers (numbers of entity i start
135 * at index[i] or _index[i] (reduced index) if list exists).
136 * If list = NULL, a default 0 to n-1 numbering is considered)
137 * index <-- number of values to compare for each entity
138 * nb_ent <-- number of entities considered
139 *
140 * returns:
141 * pointer to list of nb_ent entities (0 to n-1 numbering) ordered by
142 * increasing associated number. The calling code is responsible for
143 * freeing this array when it is not needed anymore.
144 *----------------------------------------------------------------------------*/
145
146cs_lnum_t *
147cs_order_gnum_i(const cs_lnum_t list[],
148 const cs_gnum_t number[],
149 const cs_lnum_t index[],
150 size_t nb_ent);
151
152/*----------------------------------------------------------------------------
153 * Compute an ordering table associated with an array of global numbers.
154 *
155 * parameters:
156 * list <-- optional list (0 to n-1 numbering) of selected entities
157 * (or NULL if all nb_ent are selected). This list may
158 * contain element numbers in any order
159 * number <-- array of all entity numbers (number of entity i
160 * given by number[i] or number[list[i]]) if list exists
161 * (if NULL, a default 0 to n-1 numbering is considered)
162 * order --> pointer to pre-allocated ordering table
163 * nb_ent <-- number of entities considered
164 *----------------------------------------------------------------------------*/
165
166void
168 const cs_gnum_t number[],
169 cs_lnum_t order[],
170 size_t nb_ent);
171
172/*----------------------------------------------------------------------------
173 * Compute a lexicographical ordering table associated with an array of
174 * strided global numbers.
175 *
176 * parameters:
177 * list <-- optional list (0 to n-1 numbering) of selected entities
178 * (or NULL if all nb_ent are selected). This list may
179 * contain element numbers in any order
180 * number <-- array of all entity numbers (numbers of entity i start
181 * at number[i*stride] or number[list[i]*stride]) if
182 * list exists (if NULL, a default 0 to n-1 numbering is
183 * considered)
184 * stride <-- stride of number array (number of values to compare)
185 * order --> pointer to pre-allocated ordering table
186 * nb_ent <-- number of entities considered
187 *----------------------------------------------------------------------------*/
188
189void
191 const cs_gnum_t number[],
192 size_t stride,
193 cs_lnum_t order[],
194 size_t nb_ent);
195
196/*----------------------------------------------------------------------------
197 * Compute a lexicographical ordering table associated with an indexed array
198 * of global numbers.
199 *
200 * parameters:
201 * list <-- optional list (0 to n-1 numbering) of selected entities
202 * (or NULL if all nb_ent are selected). This list may
203 * contain element numbers in any order
204 * number <-- array of all entity numbers (numbers of entity i start
205 * at index[i] or _index[i] (reduced index) if list exists).
206 * If list = NULL, a default 0 to n-1 numbering is considered)
207 * index <-- number of values to compare for each entity (from 0)
208 * order --> pointer to pre-allocated ordering table
209 * nb_ent <-- number of entities considered
210 *----------------------------------------------------------------------------*/
211
212void
214 const cs_gnum_t number[],
215 const cs_lnum_t index[],
216 cs_lnum_t order[],
217 size_t nb_ent);
218
219/*----------------------------------------------------------------------------
220 * Compute an ordering table associated with an array of local numbers.
221 *
222 * parameters:
223 * list <-- optional list (0 to n-1 numbering) of selected entities
224 * (or NULL if all nb_ent are selected). This list may
225 * contain element numbers in any order
226 * number <-- array of all entity numbers (number of entity i
227 * given by number[i] or number[list[i]]) if list exists
228 * (if NULL, a default 0 to n-1 numbering is considered)
229 * order --> pointer to pre-allocated ordering table
230 * nb_ent <-- number of entities considered
231 *----------------------------------------------------------------------------*/
232
233void
235 const cs_lnum_t number[],
236 cs_lnum_t order[],
237 size_t nb_ent);
238
239/*----------------------------------------------------------------------------*/
252/*----------------------------------------------------------------------------*/
253
254void
256 const cs_real_t val[],
257 cs_lnum_t order[],
258 size_t nb_ent);
259
260/*----------------------------------------------------------------------------
261 * Compute a lexicographical ordering table associated with an array of
262 * strided local numbers.
263 *
264 * parameters:
265 * list <-- optional list (0 to n-1 numbering) of selected entities
266 * (or NULL if all nb_ent are selected). This list may
267 * contain element numbers in any order
268 * number <-- array of all entity numbers (numbers of entity i start
269 * at number[i*stride] or number[list[i]*stride]) if
270 * list exists (if NULL, a default 0 to n-1 numbering is
271 * considered)
272 * stride <-- stride of number array (number of values to compare)
273 * order --> pointer to pre-allocated ordering table
274 * nb_ent <-- number of entities considered
275 *----------------------------------------------------------------------------*/
276
277void
279 const cs_lnum_t number[],
280 size_t stride,
281 cs_lnum_t order[],
282 size_t nb_ent);
283
284/*----------------------------------------------------------------------------
285 * Build local renumbering array based on ordering of entities.
286 *
287 * parameters:
288 * order <-- 0 to n-1 ordering of entities by increasing attribute
289 * nb_ent <-- number of entities considered
290 *
291 * returns:
292 * pointer to renumbering array (0 to n-1 numbering) indicating the new
293 * index of renumbered entities; The calling code is responsible for
294 * freeing this array when it is not needed anymore
295 *----------------------------------------------------------------------------*/
296
297cs_lnum_t *
298cs_order_renumbering(const cs_lnum_t order[],
299 size_t nb_ent);
300
301/*----------------------------------------------------------------------------
302 * Reorder data based on ordering array.
303 *
304 * parameters:
305 * n_elts <-- number of elements
306 * elt_size <-- element size
307 * order <-- reordering array
308 * data <-> data
309 *----------------------------------------------------------------------------*/
310
311void
313 size_t elt_size,
314 const cs_lnum_t order[],
315 void *data);
316
317/*----------------------------------------------------------------------------*/
332/*----------------------------------------------------------------------------*/
333
334void
335cs_order_single_gnum(size_t n_ent,
336 const cs_gnum_t base,
337 const cs_gnum_t number[],
338 size_t *n_single,
339 cs_gnum_t *single[]);
340
341/*----------------------------------------------------------------------------*/
342
344
345#endif /* __CS_ORDER_H__ */
#define BEGIN_C_DECLS
Definition cs_defs.h:509
double cs_real_t
Floating-point value.
Definition cs_defs.h:319
#define END_C_DECLS
Definition cs_defs.h:510
int cs_lnum_t
local mesh entity id
Definition cs_defs.h:313
void cs_order_lnum_allocated(const cs_lnum_t list[], const cs_lnum_t number[], cs_lnum_t order[], size_t nb_ent)
Compute an ordering table associated with an array of local numbers.
Definition cs_order.c:1165
void cs_order_gnum_allocated_i(const cs_lnum_t list[], const cs_gnum_t number[], const cs_lnum_t index[], cs_lnum_t order[], size_t nb_ent)
Compute a lexicographical ordering table associated with an indexed array of global numbers.
Definition cs_order.c:1080
cs_lnum_t * cs_order_gnum_i(const cs_lnum_t list[], const cs_gnum_t number[], const cs_lnum_t index[], size_t nb_ent)
Return a lexicographical ordering table associated with an indexed array of global numbers.
Definition cs_order.c:931
cs_lnum_t * cs_order_gnum(const cs_lnum_t list[], const cs_gnum_t number[], size_t nb_ent)
Return an ordering table associated with an array of global numbers.
Definition cs_order.c:854
void cs_order_reorder_data(cs_lnum_t n_elts, size_t elt_size, const cs_lnum_t order[], void *data)
Reorder data based on ordering array.
Definition cs_order.c:1382
void cs_order_real_allocated(const cs_lnum_t list[], const cs_real_t val[], cs_lnum_t order[], size_t nb_ent)
Compute an ordering table associated with an array of local values.
Definition cs_order.c:1293
void cs_order_single_gnum(size_t n_ent, const cs_gnum_t base, const cs_gnum_t number[], size_t *n_single, cs_gnum_t *single[])
Build a sorted array containing a single occurence of each global number in a given array.
Definition cs_order.c:1422
void cs_order_gnum_allocated_s(const cs_lnum_t list[], const cs_gnum_t number[], size_t stride, cs_lnum_t order[], size_t nb_ent)
Compute a lexicographical ordering table associated with an array of strided global numbers.
Definition cs_order.c:1026
int cs_order_gnum_test(const cs_lnum_t list[], const cs_gnum_t number[], size_t nb_ent)
Test if an array of global numbers is ordered.
Definition cs_order.c:791
void cs_order_lnum_allocated_s(const cs_lnum_t list[], const cs_lnum_t number[], size_t stride, cs_lnum_t order[], size_t nb_ent)
Compute a lexicographical ordering table associated with an array of strided local numbers.
Definition cs_order.c:1234
cs_lnum_t * cs_order_gnum_s(const cs_lnum_t list[], const cs_gnum_t number[], size_t stride, size_t nb_ent)
Return a lexicographical ordering table associated with a strided array of global numbers.
Definition cs_order.c:892
cs_lnum_t * cs_order_renumbering(const cs_lnum_t order[], size_t nb_ent)
Build local renumbering array based on ordering of entities.
Definition cs_order.c:1333
void cs_order_gnum_allocated(const cs_lnum_t list[], const cs_gnum_t number[], cs_lnum_t order[], size_t nb_ent)
Compute an ordering table associated with an array of global numbers.
Definition cs_order.c:961