8.2
general documentation
Loading...
Searching...
No Matches
cs_matrix.h
Go to the documentation of this file.
1#ifndef __CS_MATRIX_H__
2#define __CS_MATRIX_H__
3
4/*============================================================================
5 * Sparse Matrix Representation and Operations.
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/*----------------------------------------------------------------------------
31 * Local headers
32 *----------------------------------------------------------------------------*/
33
34#include "cs_defs.h"
35
36#include "cs_halo.h"
37#include "cs_numbering.h"
38#include "cs_matrix_assembler.h"
39
40/*----------------------------------------------------------------------------*/
41
43
44/*============================================================================
45 * Macro definitions
46 *============================================================================*/
47
48/*============================================================================
49 * Type definitions
50 *============================================================================*/
51
52/* Matrix structure representation types */
53
69
70/* Matrix fill types (for tuning) */
71
72typedef enum {
73
74 CS_MATRIX_SCALAR, /* Simple scalar matrix */
75 CS_MATRIX_SCALAR_SYM, /* Simple scalar symmetric matrix */
76 CS_MATRIX_BLOCK_D, /* Matrix with diagonal blocks
77 (and m.I extradiagonal blocks) */
78 CS_MATRIX_BLOCK_D_66, /* Matrix with 6x6 diagonal blocks
79 (and 6.I extradiagonal blocks;
80 subcase of CS_MATRIX_BLOCK_D, allows
81 separate tuning) */
82 CS_MATRIX_BLOCK_D_SYM, /* Symmetric matrix with diagonal blocks
83 (and m.I extradiagonal blocks) */
84 CS_MATRIX_BLOCK, /* Block matrix */
85 CS_MATRIX_N_FILL_TYPES /* Number of possible matrix fill types */
86
88
94
103
104/* Structure associated with opaque matrix structure object */
105
106typedef struct _cs_matrix_structure_t cs_matrix_structure_t;
107
108/* Structure associated with opaque matrix object */
109
110typedef struct _cs_matrix_t cs_matrix_t;
111
112/* Structure associated with opaque matrix tuning results object */
113
114typedef struct _cs_matrix_variant_t cs_matrix_variant_t;
115
116/* Information structure for extraction of matrix row */
117
118typedef struct {
119
120 cs_lnum_t row_size; /*< Row size from last call */
121 cs_lnum_t buffer_size; /*< Allocated buffer size */
122 const cs_lnum_t *col_id; /*< Pointer to local column ids */
123 cs_lnum_t *_col_id; /*< Pointer to local column ids copy */
124 const cs_real_t *vals; /*< Pointer to local row values */
125 cs_real_t *_vals; /*< Pointer to local row values copy */
126
128
129/*============================================================================
130 * Global variables
131 *============================================================================*/
132
134
135extern const char *cs_matrix_fill_type_name[];
136
138
139extern const char *cs_matrix_spmv_type_name[];
140
141/*=============================================================================
142 * Public function prototypes
143 *============================================================================*/
144
145/*----------------------------------------------------------------------------
146 * Create a matrix structure.
147 *
148 * Note that the structure created usually maps to the given existing
149 * cell global number, face -> cell connectivity arrays, and cell halo
150 * structure, so it must be destroyed before they are freed
151 * (usually along with the code's main face -> cell structure).
152 *
153 * Note that the resulting matrix structure will contain a full main
154 * main diagonal, and that the extra-diagonal structure is always
155 * symmetric (though the coefficients my not be, and we may choose a
156 * matrix format that does not exploit this symmetry). If the edges
157 * connectivity argument is NULL, the matrix will be purely diagonal.
158 *
159 * parameters:
160 * type <-- type of matrix considered
161 * n_rows <-- local number of rows
162 * n_cols_ext <-- number of columns + ghosts
163 * n_edges <-- local number of (undirected) graph edges
164 * edges <-- edges (symmetric row <-> column) connectivity
165 * halo <-- halo structure associated with cells, or NULL
166 * numbering <-- vectorization or thread-related numbering info, or NULL
167 *
168 * returns:
169 * pointer to created matrix structure;
170 *----------------------------------------------------------------------------*/
171
174 cs_lnum_t n_rows,
175 cs_lnum_t n_cols_ext,
176 cs_lnum_t n_edges,
177 const cs_lnum_2_t *edges,
178 const cs_halo_t *halo,
179 const cs_numbering_t *numbering);
180
181/*----------------------------------------------------------------------------
182 * Create a matrix structure based on a MSR connectivity definition.
183 *
184 * Only CSR and MSR formats are handled.
185 *
186 * col_id is sorted row by row during the creation of this structure.
187 *
188 * In case the property of the row index and col_id arrays are transferred
189 * to the structure, the arrays pointers passed as arguments are set to NULL,
190 * to help ensure the caller does not use the original arrays directly after
191 * this call.
192 *
193 * parameters:
194 * type <-- type of matrix considered
195 * transfer <-- transfer property of row_index and col_id
196 * if true, map them otherwise
197 * have_diag <-- indicates if the structure includes the
198 * diagonal (should be the same for all rows)
199 * n_rows <-- local number of rows
200 * n_cols_ext <-- local number of columns + ghosts
201 * row_index <-> pointer to index on rows
202 * col_id <-> pointer to array of colum ids related to the row index
203 * halo <-- halo structure for synchronization, or NULL
204 * numbering <-- vectorization or thread-related numbering info, or NULL
205 *
206 * returns:
207 * a pointer to a created matrix structure
208 *----------------------------------------------------------------------------*/
209
212 bool transfer,
213 bool have_diag,
214 cs_lnum_t n_rows,
215 cs_lnum_t n_cols_ext,
216 cs_lnum_t **row_index,
217 cs_lnum_t **col_id,
218 const cs_halo_t *halo,
219 const cs_numbering_t *numbering);
220
221/*----------------------------------------------------------------------------
222 * Create an MSR matrix structure sharing an existing connectivity definition.
223 *
224 * Note that as the structure created maps to the given existing
225 * cell global number, face -> cell connectivity arrays, and cell halo
226 * structure, it must be destroyed before they are freed
227 * (usually along with the code's main face -> cell structure).
228 *
229 * parameters:
230 * direct_assembly <-- true if each value corresponds to a unique face
231 * n_rows <-- local number of rows
232 * n_cols_ext <-- local number of columns + ghosts
233 * row_index <-- pointer to index on rows
234 * col_id <-- pointer to array of colum ids related to the row index
235 * halo <-- halo structure for synchronization, or NULL
236 * numbering <-- vectorization or thread-related numbering
237 * info, or NULL
238 *
239 * returns:
240 * a pointer to a created matrix structure
241 *----------------------------------------------------------------------------*/
242
244cs_matrix_structure_create_msr_shared(bool direct_assmbly,
245 cs_lnum_t n_rows,
246 cs_lnum_t n_cols_ext,
247 const cs_lnum_t *row_index,
248 const cs_lnum_t *col_id,
249 const cs_halo_t *halo,
250 const cs_numbering_t *numbering);
251
252/*----------------------------------------------------------------------------*/
263/*----------------------------------------------------------------------------*/
264
268
269/*----------------------------------------------------------------------------
270 * Destroy a matrix structure.
271 *
272 * parameters:
273 * ms <-> pointer to matrix structure pointer
274 *----------------------------------------------------------------------------*/
275
276void
278
279/*----------------------------------------------------------------------------
280 * Create a matrix container using a given structure.
281 *
282 * Note that the matrix container maps to the assigned structure,
283 * so it must be destroyed before that structure.
284 *
285 * parameters:
286 * ms <-- associated matrix structure
287 *
288 * returns:
289 * pointer to created matrix structure;
290 *----------------------------------------------------------------------------*/
291
294
295/*----------------------------------------------------------------------------*/
306/*----------------------------------------------------------------------------*/
307
311
312/*----------------------------------------------------------------------------*/
325/*----------------------------------------------------------------------------*/
326
329
330/*----------------------------------------------------------------------------*/
342/*----------------------------------------------------------------------------*/
343
346
347/*----------------------------------------------------------------------------
348 * Destroy a matrix structure.
349 *
350 * In the case of a compoud matrix, sub-matrices are not destroyed.
351 *
352 * parameters:
353 * matrix <-> pointer to matrix structure pointer
354 *----------------------------------------------------------------------------*/
355
356void
358
359/*----------------------------------------------------------------------------
360 * Return type of matrix.
361 *
362 * parameters:
363 * matrix --> pointer to matrix structure
364 *----------------------------------------------------------------------------*/
365
368
369/*----------------------------------------------------------------------------
370 * Return matrix type name.
371 *
372 * parameters:
373 * matrix --> pointer to matrix structure
374 *----------------------------------------------------------------------------*/
375
376const char *
378
379/*----------------------------------------------------------------------------
380 * Return matrix type full name.
381 *
382 * parameters:
383 * matrix --> pointer to matrix structure
384 *----------------------------------------------------------------------------*/
385
386const char *
388
389/*----------------------------------------------------------------------------*/
397/*----------------------------------------------------------------------------*/
398
401
402/*----------------------------------------------------------------------------*/
410/*----------------------------------------------------------------------------*/
411
414
415/*----------------------------------------------------------------------------*/
426/*----------------------------------------------------------------------------*/
427
430
431/*----------------------------------------------------------------------------*/
439/*----------------------------------------------------------------------------*/
440
443
444/*----------------------------------------------------------------------------*/
452/*----------------------------------------------------------------------------*/
453
456
457/*----------------------------------------------------------------------------*/
465/*----------------------------------------------------------------------------*/
466
467const cs_halo_t *
469
470/*----------------------------------------------------------------------------*/
479/*----------------------------------------------------------------------------*/
480
481const cs_gnum_t *
483
484/*----------------------------------------------------------------------------*/
492/*----------------------------------------------------------------------------*/
493
496
497/*----------------------------------------------------------------------------*/
504/*----------------------------------------------------------------------------*/
505
506void
508 cs_alloc_mode_t alloc_mode);
509
510/*----------------------------------------------------------------------------
511 * Get matrix fill type, depending on block sizes.
512 *
513 * parameters:
514 * symmetric <-- indicates if matrix coefficients are symmetric
515 * diag_block_size <-- block sizes for diagonal
516 * extra_diag_block_size <-- block sizes for extra diagonal
517 *
518 * returns:
519 * matrix fill type
520 *----------------------------------------------------------------------------*/
521
523cs_matrix_get_fill_type(bool symmetric,
524 cs_lnum_t diag_block_size,
525 cs_lnum_t extra_diag_block_size);
526
527/*----------------------------------------------------------------------------
528 * Set matrix coefficients defined relative to a "native" edge graph,
529 * sharing arrays with the caller when possible.
530 *
531 * With shared arrays, the matrix becomes unusable if the arrays passed as
532 * arguments are not be modified (its coefficients should be unset first
533 * to mark this).
534 *
535 * Depending on current options and initialization, values will be copied
536 * or simply mapped.
537 *
538 * parameters:
539 * matrix <-> pointer to matrix structure
540 * symmetric <-- indicates if matrix coefficients are symmetric
541 * diag_block_size <-- block sizes for diagonal
542 * extra_diag_block_size <-- block sizes for extra diagonal
543 * n_edges <-- local number of graph edges
544 * edges <-- edges (row <-> column) connectivity
545 * da <-- diagonal values (NULL if zero)
546 * xa <-- extradiagonal values (NULL if zero)
547 * casts as:
548 * xa[n_edges] if symmetric,
549 * xa[n_edges][2] if non symmetric
550 *----------------------------------------------------------------------------*/
551
552void
554 bool symmetric,
555 cs_lnum_t diag_block_size,
556 cs_lnum_t extra_diag_block_size,
557 const cs_lnum_t n_edges,
558 const cs_lnum_2_t edges[],
559 const cs_real_t *da,
560 const cs_real_t *xa);
561
562/*----------------------------------------------------------------------------
563 * Set matrix coefficients, copying values to private arrays.
564 *
565 * With private arrays, the matrix becomes independant from the
566 * arrays passed as arguments.
567 *
568 * parameters:
569 * matrix <-> pointer to matrix structure
570 * symmetric <-- indicates if matrix coefficients are symmetric
571 * diag_block_size <-- block sizes for diagonal
572 * extra_diag_block_size <-- block sizes for extra diagonal
573 * n_edges <-- local number of graph edges
574 * edges <-- edges (row <-> column) connectivity
575 * da <-- diagonal values (NULL if zero)
576 * xa <-- extradiagonal values (NULL if zero)
577 * casts as:
578 * xa[n_edges] if symmetric,
579 * xa[n_edges][2] if non symmetric
580 *----------------------------------------------------------------------------*/
581
582void
584 bool symmetric,
585 cs_lnum_t diag_block_size,
586 cs_lnum_t extra_diag_block_size,
587 const cs_lnum_t n_edges,
588 const cs_lnum_2_t edges[],
589 const cs_real_t *da,
590 const cs_real_t *xa);
591
592/*----------------------------------------------------------------------------
593 * Set matrix coefficients in an MSR format, transferring the
594 * property of those arrays to the matrix.
595 *
596 * If the matrix is also in MSR format, this avoids an extra copy.
597 * If it is in a different format, values are copied to the structure,
598 * and the original arrays freed. In any case, the arrays pointers passed as
599 * arguments are set to NULL, to help ensure the caller does not use the
600 * original arrays directly after this call.
601 *
602 * parameters:
603 * matrix <-> pointer to matrix structure
604 * symmetric <-- indicates if matrix coefficients are symmetric
605 * diag_block_size <-- block sizes for diagonal
606 * extra_diag_block_size <-- block sizes for extra diagonal
607 * row_index <-- MSR row index (0 to n-1)
608 * col_id <-- MSR column id (0 to n-1)
609 * d_val <-> diagonal values (NULL if zero)
610 * x_val <-> extradiagonal values (NULL if zero)
611 *----------------------------------------------------------------------------*/
612
613void
615 bool symmetric,
616 cs_lnum_t diag_block_size,
617 cs_lnum_t extra_diag_block_size,
618 const cs_lnum_t row_index[],
619 const cs_lnum_t col_id[],
620 cs_real_t **d_val,
621 cs_real_t **x_val);
622
623/*----------------------------------------------------------------------------*/
636/*----------------------------------------------------------------------------*/
637
640 cs_lnum_t diag_block_size,
641 cs_lnum_t extra_diag_block_size);
642
643/*----------------------------------------------------------------------------
644 * Release shared matrix coefficients.
645 *
646 * Pointers to mapped coefficients are set to NULL, while
647 * coefficient copies owned by the matrix are not modified.
648 *
649 * This simply ensures the matrix does not maintain pointers
650 * to nonexistant data.
651 *
652 * parameters:
653 * matrix <-> pointer to matrix structure
654 *----------------------------------------------------------------------------*/
655
656void
658
659/*----------------------------------------------------------------------------
660 * Copy matrix diagonal values.
661 *
662 * In case of matrixes with block diagonal coefficients, only the true
663 * diagonal values are copied.
664 *
665 * parameters:
666 * matrix --> pointer to matrix structure
667 * da --> diagonal (pre-allocated, size: n_rows*block_size
668 *----------------------------------------------------------------------------*/
669
670void
672 cs_real_t *restrict da);
673
674/*----------------------------------------------------------------------------
675 * Query matrix coefficients symmetry
676 *
677 * parameters:
678 * matrix <-- pointer to matrix structure
679 *
680 * returns:
681 * true if coefficients are symmetric, false otherwise
682 *----------------------------------------------------------------------------*/
683
684bool
686
687/*----------------------------------------------------------------------------*/
700/*----------------------------------------------------------------------------*/
701
702bool
704
705/*----------------------------------------------------------------------------
706 * Get matrix diagonal values.
707 *
708 * In case of matrixes with block diagonal coefficients, a pointer to
709 * the complete block diagonal is returned.
710 *
711 * parameters:
712 * matrix --> pointer to matrix structure
713 *
714 * returns:
715 * pointer to matrix diagonal array
716 *----------------------------------------------------------------------------*/
717
718const cs_real_t *
720
721/*----------------------------------------------------------------------------
722 * Get pointer to matrix extra-diagonal values in "native" format
723 *
724 * This function currently only functions if the matrix is in "native"
725 * format or the coefficients were mapped from native coefficients using
726 * cs_matrix_set_coefficients(), in which case the pointer returned is
727 * the same as the one passed to that function.
728 *
729 * parameters:
730 * matrix --> pointer to matrix structure
731 *
732 * returns:
733 * pointer to matrix diagonal array
734 *----------------------------------------------------------------------------*/
735
736const cs_real_t *
738
739/*----------------------------------------------------------------------------
740 * Initialize row info for a given matrix.
741 *
742 * parameters:
743 * r --> row info structure
744 *----------------------------------------------------------------------------*/
745
746void
748
749/*----------------------------------------------------------------------------
750 * Finalize row info for a given matrix.
751 *
752 * parameters:
753 * r <-> row info structure
754 *----------------------------------------------------------------------------*/
755
756void
758
759/*----------------------------------------------------------------------------
760 * Get row values for a given matrix.
761 *
762 * This function may not work for all matrix types.
763 *
764 * In the case of blocked matrixes, the true (non-blocked)
765 * values are returned.
766 *
767 * The row information structure must have been previously initialized
768 * using cs_matrix_row_init(), and should be finalized using
769 * using cs_matrix_row_finalize(), so as to free buffers it may have
770 * built for certain matrix formats.
771 *
772 * parameters:
773 * matrix <-- pointer to matrix structure
774 * row_id <-- id of row to query
775 * r <-> row info structure
776 *----------------------------------------------------------------------------*/
777
778void
780 const cs_lnum_t row_id,
782
783/*----------------------------------------------------------------------------
784 * Get arrays describing a matrix in native format.
785 *
786 * This function works for matrix in native format.
787 *
788 * Matrix block sizes can be obtained by cs_matrix_get_diag_block_size()
789 * and cs_matrix_get_extra_diag_block_size().
790 *
791 * parameters:
792 * matrix <-- pointer to matrix structure
793 * symmetric --> true if symmetric
794 * n_edges --> number of associated faces
795 * edges --> edges (symmetric row <-> column) connectivity
796 * d_val --> diagonal values
797 * x_val --> extra-diagonal values
798 *----------------------------------------------------------------------------*/
799
800void
802 bool *symmetric,
803 cs_lnum_t *n_edges,
804 const cs_lnum_2_t **edges,
805 const cs_real_t **d_val,
806 const cs_real_t **x_val);
807
808/*----------------------------------------------------------------------------
809 * Get arrays describing a matrix in CSR format.
810 *
811 * This function only works for an CSR matrix (i.e. there is
812 * no automatic conversion from another matrix type).
813 *
814 * Matrix block sizes can be obtained by cs_matrix_get_diag_block_size()
815 * and cs_matrix_get_extra_diag_block_size().
816 *
817 * parameters:
818 * matrix <-- pointer to matrix structure
819 * row_index --> CSR row index
820 * col_id --> CSR column id
821 * val --> values
822 *----------------------------------------------------------------------------*/
823
824void
826 const cs_lnum_t **row_index,
827 const cs_lnum_t **col_id,
828 const cs_real_t **val);
829
830/*----------------------------------------------------------------------------
831 * Get arrays describing a matrix in MSR format.
832 *
833 * This function only works for an MSR matrix (i.e. there is
834 * no automatic conversion from another matrix type).
835 *
836 * Matrix block sizes can be obtained by cs_matrix_get_diag_block_size()
837 * and cs_matrix_get_extra_diag_block_size().
838 *
839 * parameters:
840 * matrix <-- pointer to matrix structure
841 * row_index --> MSR row index
842 * col_id --> MSR column id
843 * d_val --> diagonal values
844 * x_val --> extra-diagonal values
845 *----------------------------------------------------------------------------*/
846
847void
849 const cs_lnum_t **row_index,
850 const cs_lnum_t **col_id,
851 const cs_real_t **d_val,
852 const cs_real_t **x_val);
853
854/*----------------------------------------------------------------------------*/
877/*----------------------------------------------------------------------------*/
878
879void
881 const cs_lnum_t *c2f_idx,
882 const cs_lnum_t *c2f,
883 const short int *c2f_sgn,
884 const cs_real_3_t *cell_cen,
885 const cs_real_t *cell_vol,
886 const cs_real_3_t *face_normal);
887
888/*----------------------------------------------------------------------------*/
902/*----------------------------------------------------------------------------*/
903
904void
906 const cs_lnum_t **c2f_idx,
907 const cs_lnum_t **c2f,
908 const short int **c2f_sgn,
909 const cs_real_3_t **cell_cen,
910 const cs_real_t **cell_vol,
911 const cs_real_3_t **face_normal);
912
913/*----------------------------------------------------------------------------
914 * Assign functions based on a variant to a given matrix.
915 *
916 * If the matrix variant is incompatible with the structure, it is ignored,
917 * and defaults for that structure are used instead.
918 *
919 * parameters:
920 * m <-> associated matrix structure
921 * mv <-- associated matrix variant
922 *
923 * returns:
924 * pointer to created matrix structure;
925 *----------------------------------------------------------------------------*/
926
927void
929 const cs_matrix_variant_t *mv);
930
931/*----------------------------------------------------------------------------
932 * Matrix.vector product y = A.x
933 *
934 * This function includes a halo update of x prior to multiplication by A.
935 *
936 * parameters:
937 * matrix --> pointer to matrix structure
938 * x <-> multipliying vector values (ghost values updated)
939 * y --> resulting vector
940 *----------------------------------------------------------------------------*/
941
942void
946
947#if defined(HAVE_ACCEL)
948
949/*----------------------------------------------------------------------------*/
960/*----------------------------------------------------------------------------*/
961
962void
963cs_matrix_vector_multiply_d(const cs_matrix_t *matrix,
966
967#endif /* defined(HAVE_ACCEL) */
968
969/*----------------------------------------------------------------------------
970 * Matrix.vector product y = A.x with no prior halo update of x.
971 *
972 * This function does not include a halo update of x prior to multiplication
973 * by A, so it should be called only when the halo of x is known to already
974 * be up to date (in which case we avoid the performance penalty of a
975 * redundant update by using this variant of the matrix.vector product).
976 *
977 * parameters:
978 * matrix --> pointer to matrix structure
979 * x --> multipliying vector values
980 * y <-- resulting vector
981 *----------------------------------------------------------------------------*/
982
983void
987
988/*----------------------------------------------------------------------------
989 * Partial matrix.vector product.
990 *
991 * This function includes a halo update of x prior to multiplication,
992 * except for the CS_MATRIX_SPMV_L operation type, which does not require it,
993 * as halo adjacencies are only present and useful in the upper-diagonal part..
994 *
995 * parameters:
996 * matrix <-- pointer to matrix structure
997 * op_type <-- SpMV operation type
998 * x <-> multipliying vector values (ghost values updated)
999 * y --> resulting vector
1000 *----------------------------------------------------------------------------*/
1001
1002void
1004 cs_matrix_spmv_type_t op_type,
1006 cs_real_t *restrict y);
1007
1008#if defined(HAVE_ACCEL)
1009
1010/*----------------------------------------------------------------------------*/
1024/*----------------------------------------------------------------------------*/
1025
1026void
1027cs_matrix_vector_multiply_partial_d(const cs_matrix_t *matrix,
1028 cs_matrix_spmv_type_t op_type,
1030 cs_real_t *restrict y);
1031
1032#endif /* defined(HAVE_ACCEL) */
1033
1034/*----------------------------------------------------------------------------
1035 * Synchronize ghost values prior to matrix.vector product
1036 *
1037 * parameters:
1038 * matrix <-- pointer to matrix structure
1039 * x <-> multipliying vector values (ghost values updated)
1040 *----------------------------------------------------------------------------*/
1041
1042void
1044 cs_real_t *x);
1045
1046/*----------------------------------------------------------------------------*/
1057/*----------------------------------------------------------------------------*/
1058
1059void
1061 int *n_variants,
1062 cs_matrix_variant_t **m_variant);
1063
1064/*----------------------------------------------------------------------------*/
1073/*----------------------------------------------------------------------------*/
1074
1077
1078/*----------------------------------------------------------------------------
1079 * Destroy a matrix variant structure.
1080 *
1081 * parameters:
1082 * mv <-> Pointer to matrix variant pointer
1083 *----------------------------------------------------------------------------*/
1084
1085void
1087
1088/*----------------------------------------------------------------------------*/
1095/*----------------------------------------------------------------------------*/
1096
1097void
1100
1101/*----------------------------------------------------------------------------*/
1108/*----------------------------------------------------------------------------*/
1109
1110void
1113
1114/*----------------------------------------------------------------------------
1115 * Select the sparse matrix-vector product function to be used by a
1116 * matrix variant for a given fill type.
1117 *
1118 * Currently, possible variant functions are:
1119 *
1120 * CS_MATRIX_NATIVE (all fill types)
1121 * default
1122 * baseline
1123 * omp (for OpenMP with compatible numbering)
1124 * omp_atomic (for OpenMP with atomics)
1125 * vector (For vector machine with compatible numbering)
1126 *
1127 * CS_MATRIX_CSR (for CS_MATRIX_SCALAR or CS_MATRIX_SCALAR_SYM)
1128 * default
1129 * mkl (with MKL)
1130 *
1131 * CS_MATRIX_MSR (all fill types)
1132 * default
1133 * mkl (with MKL, for CS_MATRIX_SCALAR or CS_MATRIX_SCALAR_SYM)
1134 * omp_sched (For OpenMP with scheduling)
1135 *
1136 * parameters:
1137 * mv <-> pointer to matrix variant
1138 * numbering <-- mesh numbering info, or NULL
1139 * fill type <-- matrix fill type to merge from
1140 * spmv_type <-- SpMV operation type (full or sub-matrix)
1141 * (all types if CS_MATRIX_SPMV_N_TYPES)
1142 * func_name <-- function type name
1143 *----------------------------------------------------------------------------*/
1144
1145void
1147 cs_matrix_fill_type_t fill_type,
1148 cs_matrix_spmv_type_t spmv_type,
1149 const cs_numbering_t *numbering,
1150 const char *func_name);
1151
1152/*----------------------------------------------------------------------------*/
1160/*----------------------------------------------------------------------------*/
1161
1164
1165/*----------------------------------------------------------------------------*/
1166
1168
1169#endif /* __CS_MATRIX_H__ */
cs_alloc_mode_t
Definition bft_mem.h:50
#define restrict
Definition cs_defs.h:141
#define BEGIN_C_DECLS
Definition cs_defs.h:528
double cs_real_t
Floating-point value.
Definition cs_defs.h:332
cs_lnum_t cs_lnum_2_t[2]
vector of 2 local mesh-entity ids
Definition cs_defs.h:340
#define END_C_DECLS
Definition cs_defs.h:529
int cs_lnum_t
local mesh entity id
Definition cs_defs.h:325
cs_real_t cs_real_3_t[3]
vector of 3 floating-point values
Definition cs_defs.h:347
void cs_matrix_row_finalize(cs_matrix_row_info_t *r)
Finalize row info for a given matrix.
Definition cs_matrix.c:5499
struct _cs_matrix_variant_t cs_matrix_variant_t
Definition cs_matrix.h:114
bool cs_matrix_is_symmetric(const cs_matrix_t *matrix)
Query matrix coefficients symmetry.
Definition cs_matrix.c:5376
cs_matrix_t * cs_matrix_create_by_copy(cs_matrix_t *src)
Create a matrix container by copying another.
Definition cs_matrix.c:4610
void cs_matrix_copy_coefficients(cs_matrix_t *matrix, bool symmetric, cs_lnum_t diag_block_size, cs_lnum_t extra_diag_block_size, const cs_lnum_t n_edges, const cs_lnum_2_t edges[], const cs_real_t *da, const cs_real_t *xa)
Set matrix coefficients, copying values to private arrays.
Definition cs_matrix.c:5144
void cs_matrix_set_coefficients(cs_matrix_t *matrix, bool symmetric, cs_lnum_t diag_block_size, cs_lnum_t extra_diag_block_size, const cs_lnum_t n_edges, const cs_lnum_2_t edges[], const cs_real_t *da, const cs_real_t *xa)
Set matrix coefficients defined relative to a "native" edge graph, sharing arrays with the caller whe...
Definition cs_matrix.c:5085
const cs_real_t * cs_matrix_get_diagonal(const cs_matrix_t *matrix)
Get matrix diagonal values.
Definition cs_matrix.c:5421
cs_matrix_structure_t * cs_matrix_structure_create_msr_shared(bool direct_assmbly, cs_lnum_t n_rows, cs_lnum_t n_cols_ext, const cs_lnum_t *row_index, const cs_lnum_t *col_id, const cs_halo_t *halo, const cs_numbering_t *numbering)
Create an MSR matrix structure sharing an existing connectivity definition.
Definition cs_matrix.c:4410
void cs_matrix_vector_multiply_nosync(const cs_matrix_t *matrix, cs_real_t *restrict x, cs_real_t *restrict y)
Matrix.vector product y = A.x with no prior halo update of x.
Definition cs_matrix.c:6097
const char * cs_matrix_spmv_type_name[]
void cs_matrix_copy_diagonal(const cs_matrix_t *matrix, cs_real_t *restrict da)
Copy matrix diagonal values.
Definition cs_matrix.c:5353
cs_matrix_structure_t * cs_matrix_structure_create_from_assembler(cs_matrix_type_t type, cs_matrix_assembler_t *ma)
Create a matrix structure using a matrix assembler.
Definition cs_matrix.c:4460
const char * cs_matrix_get_type_name(const cs_matrix_t *matrix)
Definition cs_matrix.c:4779
cs_matrix_variant_t * cs_matrix_variant_create(cs_matrix_t *m)
Build matrix variant.
Definition cs_matrix.c:6248
struct _cs_matrix_structure_t cs_matrix_structure_t
Definition cs_matrix.h:106
cs_lnum_t cs_matrix_get_extra_diag_block_size(const cs_matrix_t *matrix)
Return the size of the extra-diagonal block for the given matrix.
Definition cs_matrix.c:4927
cs_matrix_spmv_type_t
Definition cs_matrix.h:95
@ CS_MATRIX_SPMV_N_TYPES
Definition cs_matrix.h:100
@ CS_MATRIX_SPMV
Definition cs_matrix.h:97
@ CS_MATRIX_SPMV_E
Definition cs_matrix.h:98
void cs_matrix_vector_multiply_partial(const cs_matrix_t *matrix, cs_matrix_spmv_type_t op_type, cs_real_t *restrict x, cs_real_t *restrict y)
Partial matrix.vector product.
Definition cs_matrix.c:6153
cs_matrix_type_t cs_matrix_variant_type(const cs_matrix_variant_t *mv)
Get the type associated with a matrix variant.
Definition cs_matrix.c:6651
void cs_matrix_variant_apply_tuned(cs_matrix_t *m, cs_matrix_variant_t *mv)
Apply variants defined by tuning to a given matrix.
Definition cs_matrix.c:6539
struct _cs_matrix_t cs_matrix_t
Definition cs_matrix.h:110
cs_lnum_t cs_matrix_get_n_entries(const cs_matrix_t *matrix)
Return the number of entries in matrix.
Definition cs_matrix.c:4855
void cs_matrix_destroy(cs_matrix_t **matrix)
Definition cs_matrix.c:4730
void cs_matrix_variant_apply(cs_matrix_t *m, cs_matrix_variant_t *mv)
Apply a variant to a given matrix.
Definition cs_matrix.c:6502
const cs_gnum_t * cs_matrix_get_l_range(const cs_matrix_t *matrix)
Return a pointer to local global row range associated with a matrix, if available.
Definition cs_matrix.c:4966
cs_matrix_fill_type_t cs_matrix_get_fill_type(bool symmetric, cs_lnum_t diag_block_size, cs_lnum_t extra_diag_block_size)
Get matrix fill type, depending on block sizes.
Definition cs_matrix.c:5024
cs_matrix_t * cs_matrix_create(const cs_matrix_structure_t *ms)
Create a matrix container using a given structure.
Definition cs_matrix.c:4529
void cs_matrix_variant_set_func(cs_matrix_variant_t *mv, cs_matrix_fill_type_t fill_type, cs_matrix_spmv_type_t spmv_type, const cs_numbering_t *numbering, const char *func_name)
Select the sparse matrix-vector product function to be used by a matrix variant for a given fill type...
Definition cs_matrix.c:6605
void cs_matrix_vector_multiply(const cs_matrix_t *matrix, cs_real_t *restrict x, cs_real_t *restrict y)
Matrix.vector product y = A.x.
Definition cs_matrix.c:6007
void cs_matrix_transfer_coefficients_msr(cs_matrix_t *matrix, bool symmetric, cs_lnum_t diag_block_size, cs_lnum_t extra_diag_block_size, const cs_lnum_t row_index[], const cs_lnum_t col_id[], cs_real_t **d_val, cs_real_t **x_val)
Set matrix coefficients in an MSR format, transferring the property of those arrays to the matrix.
Definition cs_matrix.c:5198
cs_matrix_t * cs_matrix_create_from_assembler(cs_matrix_type_t type, cs_matrix_assembler_t *ma)
Create a matrix directly from assembler.
Definition cs_matrix.c:4563
const char * cs_matrix_get_type_fullname(const cs_matrix_t *matrix)
Definition cs_matrix.c:4795
void cs_matrix_apply_variant(cs_matrix_t *m, const cs_matrix_variant_t *mv)
void cs_matrix_set_alloc_mode(cs_matrix_t *matrix, cs_alloc_mode_t alloc_mode)
Set matrix allocation mode.
Definition cs_matrix.c:5004
void cs_matrix_get_csr_arrays(const cs_matrix_t *matrix, const cs_lnum_t **row_index, const cs_lnum_t **col_id, const cs_real_t **val)
Get arrays describing a matrix in CSR format.
Definition cs_matrix.c:5830
cs_alloc_mode_t cs_matrix_get_alloc_mode(const cs_matrix_t *matrix)
Query matrix allocation mode.
Definition cs_matrix.c:4989
cs_matrix_t * cs_matrix_create_by_local_restrict(const cs_matrix_t *src)
Create a matrix based on the local restriction of a base matrix.
Definition cs_matrix.c:4661
void cs_matrix_set_mesh_association(cs_matrix_t *matrix, const cs_lnum_t *c2f_idx, const cs_lnum_t *c2f, const short int *c2f_sgn, const cs_real_3_t *cell_cen, const cs_real_t *cell_vol, const cs_real_3_t *face_normal)
Associate mesh information with a matrix.
Definition cs_matrix.c:5936
void cs_matrix_get_mesh_association(const cs_matrix_t *matrix, const cs_lnum_t **c2f_idx, const cs_lnum_t **c2f, const short int **c2f_sgn, const cs_real_3_t **cell_cen, const cs_real_t **cell_vol, const cs_real_3_t **face_normal)
Query mesh information that me be associated with a matrix.
Definition cs_matrix.c:5970
void cs_matrix_row_init(cs_matrix_row_info_t *r)
Initialize row info for a given matrix.
Definition cs_matrix.c:5480
void cs_matrix_get_msr_arrays(const cs_matrix_t *matrix, const cs_lnum_t **row_index, const cs_lnum_t **col_id, const cs_real_t **d_val, const cs_real_t **x_val)
Get arrays describing a matrix in MSR format.
Definition cs_matrix.c:5874
cs_matrix_fill_type_t
Definition cs_matrix.h:72
@ CS_MATRIX_BLOCK_D_66
Definition cs_matrix.h:78
@ CS_MATRIX_N_FILL_TYPES
Definition cs_matrix.h:85
@ CS_MATRIX_SCALAR
Definition cs_matrix.h:74
@ CS_MATRIX_BLOCK_D
Definition cs_matrix.h:76
@ CS_MATRIX_BLOCK
Definition cs_matrix.h:84
@ CS_MATRIX_SCALAR_SYM
Definition cs_matrix.h:75
@ CS_MATRIX_BLOCK_D_SYM
Definition cs_matrix.h:82
const char * cs_matrix_fill_type_name[]
const cs_halo_t * cs_matrix_get_halo(const cs_matrix_t *matrix)
Return the pointer to the halo structure for the given matrix.
Definition cs_matrix.c:4946
cs_matrix_structure_t * cs_matrix_structure_create_msr(cs_matrix_type_t type, bool transfer, bool have_diag, cs_lnum_t n_rows, cs_lnum_t n_cols_ext, cs_lnum_t **row_index, cs_lnum_t **col_id, const cs_halo_t *halo, const cs_numbering_t *numbering)
Create a matrix structure based on a MSR connectivity definition.
Definition cs_matrix.c:4320
cs_lnum_t cs_matrix_get_diag_block_size(const cs_matrix_t *matrix)
Return the size of the diagonal block for the given matrix.
Definition cs_matrix.c:4908
void cs_matrix_variant_destroy(cs_matrix_variant_t **mv)
Destroy a matrix variant structure.
Definition cs_matrix.c:6486
void cs_matrix_pre_vector_multiply_sync(const cs_matrix_t *matrix, cs_real_t *x)
cs_matrix_assembler_values_t * cs_matrix_assembler_values_init(cs_matrix_t *matrix, cs_lnum_t diag_block_size, cs_lnum_t extra_diag_block_size)
Create and initialize a CSR matrix assembler values structure.
Definition cs_matrix.c:5311
cs_matrix_type_t
Definition cs_matrix.h:54
@ CS_MATRIX_CSR
Definition cs_matrix.h:57
@ CS_MATRIX_MSR
Definition cs_matrix.h:58
@ CS_MATRIX_N_TYPES
Definition cs_matrix.h:66
@ CS_MATRIX_NATIVE
Definition cs_matrix.h:56
@ CS_MATRIX_DIST
Definition cs_matrix.h:60
@ CS_MATRIX_N_BUILTIN_TYPES
Definition cs_matrix.h:64
void cs_matrix_variant_build_list(const cs_matrix_t *m, int *n_variants, cs_matrix_variant_t **m_variant)
Build list of variants for tuning or testing.
Definition cs_matrix.c:6293
bool cs_matrix_is_mapped_from_native(const cs_matrix_t *matrix)
Indicate whether coefficients were mapped from native face-based arrays.
Definition cs_matrix.c:5397
void cs_matrix_release_coefficients(cs_matrix_t *matrix)
Release shared matrix coefficients.
Definition cs_matrix.c:5268
void cs_matrix_get_row(const cs_matrix_t *matrix, const cs_lnum_t row_id, cs_matrix_row_info_t *r)
Get row values for a given matrix.
Definition cs_matrix.c:5530
cs_matrix_type_t cs_matrix_get_type(const cs_matrix_t *matrix)
Return matrix type.
Definition cs_matrix.c:4764
cs_lnum_t cs_matrix_get_n_rows(const cs_matrix_t *matrix)
Return the number of rows in matrix.
Definition cs_matrix.c:4833
void cs_matrix_structure_destroy(cs_matrix_structure_t **ms)
Destroy a matrix structure.
Definition cs_matrix.c:4501
cs_lnum_t cs_matrix_get_n_columns(const cs_matrix_t *matrix)
Return number of columns in a matrix.
Definition cs_matrix.c:4814
void cs_matrix_get_native_arrays(const cs_matrix_t *matrix, bool *symmetric, cs_lnum_t *n_edges, const cs_lnum_2_t **edges, const cs_real_t **d_val, const cs_real_t **x_val)
Get arrays describing a matrix in native format.
Definition cs_matrix.c:5776
const cs_real_t * cs_matrix_get_extra_diagonal(const cs_matrix_t *matrix)
Get pointer to matrix extra-diagonal values in "native" format.
Definition cs_matrix.c:5456
cs_matrix_structure_t * cs_matrix_structure_create(cs_matrix_type_t type, cs_lnum_t n_rows, cs_lnum_t n_cols_ext, cs_lnum_t n_edges, const cs_lnum_2_t *edges, const cs_halo_t *halo, const cs_numbering_t *numbering)
Create a matrix structure.
Definition cs_matrix.c:4222
struct _cs_matrix_assembler_t cs_matrix_assembler_t
Definition cs_matrix_assembler.h:61
struct _cs_matrix_assembler_values_t cs_matrix_assembler_values_t
Definition cs_matrix_assembler.h:65
void matrix(const int *iconvp, const int *idiffp, const int *ndircp, const int *isym, const cs_real_t *thetap, const int *imucpp, const cs_real_t coefbp[], const cs_real_t cofbfp[], const cs_real_t rovsdt[], const cs_real_t i_massflux[], const cs_real_t b_massflux[], const cs_real_t i_visc[], const cs_real_t b_visc[], const cs_real_t xcpp[], cs_real_t da[], cs_real_t xa[])
Definition cs_halo.h:77
Definition cs_matrix.h:118
cs_lnum_t buffer_size
Definition cs_matrix.h:121
cs_real_t * _vals
Definition cs_matrix.h:125
const cs_lnum_t * col_id
Definition cs_matrix.h:122
cs_lnum_t * _col_id
Definition cs_matrix.h:123
cs_lnum_t row_size
Definition cs_matrix.h:120
const cs_real_t * vals
Definition cs_matrix.h:124
Definition cs_numbering.h:87