PaStiX Handbook  6.2.1
symbol_io.c
Go to the documentation of this file.
1 /**
2  *
3  * @file symbol_io.c
4  *
5  * PaStiX symbol structure IO functions.
6  *
7  * @copyright 2004-2021 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
8  * Univ. Bordeaux. All rights reserved.
9  *
10  * @version 6.2.0
11  * @author David Goudin
12  * @author Pascal Henon
13  * @author Francois Pellegrini
14  * @author Pierre Ramet
15  * @author Mathieu Faverge
16  * @date 2021-01-03
17  *
18  * Dates:
19  * Version 0.0 - from 23 aug 1998 to 07 oct 1998
20  * Version 0.1 - from 21 mar 2002 to 21 mar 2002
21  * Version 1.0 - from 03 jun 2002 to 08 sep 2003
22  * Version 3.0 - from 29 feb 2004 to 29 feb 2004
23  *
24  * @addtogroup pastix_symbol
25  * @{
26  *
27  */
28 #include "common.h"
29 #include "symbol/symbol.h"
30 
31 /**
32  *******************************************************************************
33  *
34  * @brief Load the given block matrix structure from the given stream.
35  *
36  *******************************************************************************
37  *
38  * @param[inout] symbptr
39  * The symbolic matrix structure to fill in.
40  *
41  * @param[inout] stream
42  * The stream from which to read the structure.
43  *
44  *******************************************************************************
45  *
46  * @retval 0 on success.
47  * @retval !0 on failure.
48  *
49  *******************************************************************************/
50 int
52  FILE * const stream )
53 {
54  pastix_int_t versval;
55  pastix_int_t baseval;
56  pastix_int_t nodenbr;
57  pastix_int_t cblknbr;
58  pastix_int_t cblknum;
59  pastix_int_t bloknbr;
60  pastix_int_t bloknum;
61 
62  if ((intLoad (stream, &versval) + /* Read header */
63  intLoad (stream, &cblknbr) +
64  intLoad (stream, &bloknbr) +
65  intLoad (stream, &nodenbr) +
66  intLoad (stream, &baseval) != 5) ||
67  (versval < 0) || /* Version should be 0 or 1 */
68  (versval > 1) ||
69  (bloknbr < cblknbr) ||
70  (nodenbr < cblknbr)) {
71  pastix_print_error( "symbolLoad: bad input (1)" );
72  return (1);
73  }
74 
75  if (((symbptr->cblktab = (symbol_cblk_t *) memAlloc ((cblknbr + 1) * sizeof (symbol_cblk_t))) == NULL) ||
76  ((symbptr->bloktab = (symbol_blok_t *) memAlloc ( bloknbr * sizeof (symbol_blok_t))) == NULL)) {
77  pastix_print_error( "symbolLoad: out of memory" );
78  pastixSymbolExit (symbptr);
79  return (1);
80  }
81  symbptr->baseval = baseval;
82  symbptr->cblknbr = cblknbr;
83  symbptr->bloknbr = bloknbr;
84  symbptr->nodenbr = nodenbr;
85 
86  for (cblknum = 0; cblknum < cblknbr; cblknum ++) {
87  if ((intLoad (stream, &symbptr->cblktab[cblknum].fcolnum) + /* Read column blocks */
88  intLoad (stream, &symbptr->cblktab[cblknum].lcolnum) +
89  intLoad (stream, &symbptr->cblktab[cblknum].bloknum) != 3) ||
90  (symbptr->cblktab[cblknum].fcolnum > symbptr->cblktab[cblknum].lcolnum)) {
91  pastix_print_error( "symbolLoad: bad input (2)" );
92  pastixSymbolExit (symbptr);
93  return (1);
94  }
95  }
96  symbptr->cblktab[cblknbr].fcolnum = /* Set last column block */
97  symbptr->cblktab[cblknbr].lcolnum = nodenbr + baseval;
98  symbptr->cblktab[cblknbr].bloknum = bloknbr + baseval;
99 
100  for (bloknum = 0; bloknum < bloknbr; bloknum ++) {
101  if ((intLoad (stream, &symbptr->bloktab[bloknum].frownum) + /* Read column blocks */
102  intLoad (stream, &symbptr->bloktab[bloknum].lrownum) +
103  intLoad (stream, &symbptr->bloktab[bloknum].fcblknm) != 3) ||
104  (symbptr->bloktab[bloknum].frownum > symbptr->bloktab[bloknum].lrownum)) {
105  pastix_print_error( "symbolLoad: bad input (3)" );
106  pastixSymbolExit (symbptr);
107  return (1);
108  }
109 
110  /* This block is required for old file compatibility: will be removed */
111  if (0)
112  {
113  pastix_int_t tmp;
114  if ((versval > 0) && (intLoad (stream, &tmp) != 1)) {
115  pastix_print_error( "symbolLoad: bad input (4)" );
116  pastixSymbolExit (symbptr);
117  return (1);
118  }
119  }
120  }
121 
122  // TODO: store the value and read it
123  symbptr->dof = 1;
124  return (0);
125 }
126 
127 /**
128  *******************************************************************************
129  *
130  * @brief Save the given block matrix structure to the given stream.
131  *
132  *******************************************************************************
133  *
134  * @param[inout] symbptr
135  * The symbolic matrix structure to write.
136  *
137  * @param[inout] stream
138  * The stream to which to write the structure.
139  *
140  *******************************************************************************
141  *
142  * @retval 0 on success.
143  * @retval !0 on failure.
144  *
145  *******************************************************************************/
146 int
147 pastixSymbolSave( const symbol_matrix_t * const symbptr,
148  FILE * const stream )
149 {
150  const symbol_cblk_t *cblktnd;
151  const symbol_cblk_t *cblkptr;
152  const symbol_blok_t *bloktnd;
153  const symbol_blok_t *blokptr;
154  int o;
155 
156  o = (fprintf (stream, "1\n%ld\t%ld\t%ld\t%ld\n", /* Write file header */
157  (long) symbptr->cblknbr,
158  (long) symbptr->bloknbr,
159  (long) symbptr->nodenbr,
160  (long) symbptr->baseval) == EOF);
161  for (cblkptr = symbptr->cblktab, cblktnd = cblkptr + symbptr->cblknbr;
162  (cblkptr < cblktnd) && (o == 0); cblkptr ++) {
163  o = (fprintf (stream, "%ld\t%ld\t%ld\n",
164  (long) cblkptr->fcolnum,
165  (long) cblkptr->lcolnum,
166  (long) cblkptr->bloknum) == EOF);
167  }
168  for (blokptr = symbptr->bloktab, bloktnd = blokptr + symbptr->bloknbr;
169  (blokptr < bloktnd) && (o == 0); blokptr ++) {
170  o = (fprintf (stream, "%ld\t%ld\t%ld\n",
171  (long) blokptr->frownum,
172  (long) blokptr->lrownum,
173  (long) blokptr->fcblknm ) == EOF);
174  }
175 
176  return (o);
177 }
178 
179 /**
180  *******************************************************************************
181  *
182  * @brief Print the given block matrix structure in human readable format.
183  *
184  *******************************************************************************
185  *
186  * @param[inout] symbptr
187  * The symbolic matrix structure to write.
188  *
189  * @param[inout] file
190  * The file stream to which to write the structure.
191  *
192  *******************************************************************************/
193 void
195  FILE *file )
196 {
197  pastix_int_t i, j;
198  for(i=0;i<symbptr->cblknbr;i++)
199  {
200  fprintf(file, "CBLK %ld [%ld : %ld ] \n",
201  (long)i,
202  (long)symbptr->cblktab[i].fcolnum,
203  (long)symbptr->cblktab[i].lcolnum );
204  for(j=symbptr->cblktab[i].bloknum;
205  j<symbptr->cblktab[i+1].bloknum;j++) {
206  fprintf(file, "--BLOK %ld [%ld : %ld ]\n",
207  (long)j,
208  (long)symbptr->bloktab[j].frownum,
209  (long)symbptr->bloktab[j].lrownum );
210  }
211  fprintf(file, "\n");
212  }
213 }
214 
215 /**
216  * @}
217  */
symbol_matrix_s
Symbol matrix structure.
Definition: symbol.h:75
pastixSymbolLoad
int pastixSymbolLoad(symbol_matrix_t *symbptr, FILE *stream)
Load the given block matrix structure from the given stream.
Definition: symbol_io.c:51
pastixSymbolSave
int pastixSymbolSave(const symbol_matrix_t *symbptr, FILE *stream)
Save the given block matrix structure to the given stream.
Definition: symbol_io.c:147
symbol_matrix_s::bloktab
symbol_blok_t * bloktab
Definition: symbol.h:82
pastixSymbolExit
void pastixSymbolExit(symbol_matrix_t *symbptr)
Free the content of symbolic matrix.
Definition: symbol.c:140
symbol_cblk_s::fcolnum
pastix_int_t fcolnum
Definition: symbol.h:44
symbol_matrix_s::nodenbr
pastix_int_t nodenbr
Definition: symbol.h:79
symbol_matrix_s::cblknbr
pastix_int_t cblknbr
Definition: symbol.h:77
symbol_matrix_s::baseval
pastix_int_t baseval
Definition: symbol.h:76
symbol_matrix_s::dof
pastix_int_t dof
Definition: symbol.h:85
symbol_matrix_s::bloknbr
pastix_int_t bloknbr
Definition: symbol.h:78
symbol_blok_s::fcblknm
pastix_int_t fcblknm
Definition: symbol.h:61
symbol_cblk_s::bloknum
pastix_int_t bloknum
Definition: symbol.h:46
symbol.h
symbol_cblk_s::lcolnum
pastix_int_t lcolnum
Definition: symbol.h:45
symbol_blok_s::frownum
pastix_int_t frownum
Definition: symbol.h:58
symbol_matrix_s::cblktab
symbol_cblk_t * cblktab
Definition: symbol.h:81
symbol_blok_s
Symbol block structure.
Definition: symbol.h:57
symbol_cblk_s
Symbol column block structure.
Definition: symbol.h:43
pastixSymbolPrint
void pastixSymbolPrint(const symbol_matrix_t *symbptr, FILE *file)
Print the given block matrix structure in human readable format.
Definition: symbol_io.c:194
symbol_blok_s::lrownum
pastix_int_t lrownum
Definition: symbol.h:59