1 /******************************************************************************
2 * Copyright 1998-2019 Lawrence Livermore National Security, LLC and other
3 * HYPRE Project Developers. See the top-level COPYRIGHT file for details.
4 *
5 * SPDX-License-Identifier: (Apache-2.0 OR MIT)
6 ******************************************************************************/
7
8 /******************************************************************************
9 *
10 * HYPRE_ParCSRParaSails interface
11 *
12 *****************************************************************************/
13
14 #include <stdlib.h>
15 #include <stdio.h>
16 #include <math.h>
17
18 #include "./HYPRE_parcsr_ls.h"
19 #include "./_hypre_parcsr_ls.h"
20
21 #include "../distributed_matrix/HYPRE_distributed_matrix_types.h"
22 #include "../distributed_matrix/HYPRE_distributed_matrix_protos.h"
23
24 #include "../matrix_matrix/HYPRE_matrix_matrix_protos.h"
25
26 #include "../distributed_ls/ParaSails/hypre_ParaSails.h"
27
28 /* these includes required for HYPRE_ParaSailsBuildIJMatrix */
29 #include "../IJ_mv/HYPRE_IJ_mv.h"
30
31 /* Must include implementation definition for ParVector since no data access
32 functions are publically provided. AJC, 5/99 */
33 /* Likewise for Vector. AJC, 5/99 */
34 #include "../seq_mv/vector.h"
35 /* AB 8/06 - replace header file */
36 /* #include "../parcsr_mv/par_vector.h" */
37 #include "../parcsr_mv/_hypre_parcsr_mv.h"
38
39 /* If code is more mysterious, then it must be good */
40 typedef struct
41 {
42 hypre_ParaSails obj;
43 HYPRE_Int sym;
44 HYPRE_Real thresh;
45 HYPRE_Int nlevels;
46 HYPRE_Real filter;
47 HYPRE_Real loadbal;
48 HYPRE_Int reuse; /* reuse pattern */
49 MPI_Comm comm;
50 HYPRE_Int logging;
51 }
52 Secret;
53
54 /*--------------------------------------------------------------------------
55 * HYPRE_ParCSRParaSailsCreate - Return a ParaSails preconditioner object
56 * "solver". The default parameters for the preconditioner are also set,
57 * so a call to HYPRE_ParCSRParaSailsSetParams is not absolutely necessary.
58 *--------------------------------------------------------------------------*/
59
60 HYPRE_Int
HYPRE_ParCSRParaSailsCreate(MPI_Comm comm,HYPRE_Solver * solver)61 HYPRE_ParCSRParaSailsCreate( MPI_Comm comm, HYPRE_Solver *solver )
62 {
63 #ifdef HYPRE_MIXEDINT
64 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
65 return hypre_error_flag;
66 #else
67
68 Secret *secret;
69
70 secret = hypre_TAlloc(Secret, 1, HYPRE_MEMORY_HOST);
71
72 if (secret == NULL)
73 {
74 hypre_error(HYPRE_ERROR_MEMORY);
75 return hypre_error_flag;
76 }
77
78 secret->sym = 1;
79 secret->thresh = 0.1;
80 secret->nlevels = 1;
81 secret->filter = 0.1;
82 secret->loadbal = 0.0;
83 secret->reuse = 0;
84 secret->comm = comm;
85 secret->logging = 0;
86
87 hypre_ParaSailsCreate(comm, &secret->obj);
88
89 *solver = (HYPRE_Solver) secret;
90
91 return hypre_error_flag;
92 #endif
93 }
94
95 /*--------------------------------------------------------------------------
96 * HYPRE_ParCSRParaSailsDestroy - Destroy a ParaSails object.
97 *--------------------------------------------------------------------------*/
98
99 HYPRE_Int
HYPRE_ParCSRParaSailsDestroy(HYPRE_Solver solver)100 HYPRE_ParCSRParaSailsDestroy( HYPRE_Solver solver )
101 {
102 #ifdef HYPRE_MIXEDINT
103 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
104 return hypre_error_flag;
105 #else
106
107 Secret *secret;
108
109 secret = (Secret *) solver;
110 hypre_ParaSailsDestroy(secret->obj);
111
112 hypre_TFree(secret,HYPRE_MEMORY_HOST);
113
114 return hypre_error_flag;
115 #endif
116 }
117
118 /*--------------------------------------------------------------------------
119 * HYPRE_ParCSRParaSailsSetup - Set up function for ParaSails.
120 * This function is not called on subsequent times if the preconditioner is
121 * being reused.
122 *--------------------------------------------------------------------------*/
123
124 HYPRE_Int
HYPRE_ParCSRParaSailsSetup(HYPRE_Solver solver,HYPRE_ParCSRMatrix A,HYPRE_ParVector b,HYPRE_ParVector x)125 HYPRE_ParCSRParaSailsSetup( HYPRE_Solver solver,
126 HYPRE_ParCSRMatrix A,
127 HYPRE_ParVector b,
128 HYPRE_ParVector x )
129 {
130 #ifdef HYPRE_MIXEDINT
131 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
132 return hypre_error_flag;
133 #else
134
135 static HYPRE_Int virgin = 1;
136 HYPRE_DistributedMatrix mat;
137 Secret *secret = (Secret *) solver;
138
139 /* The following call will also create the distributed matrix */
140
141 HYPRE_ConvertParCSRMatrixToDistributedMatrix( A, &mat );
142 if (hypre_error_flag) return hypre_error_flag;
143
144 if (virgin || secret->reuse == 0) /* call set up at least once */
145 {
146 virgin = 0;
147 hypre_ParaSailsSetup(
148 secret->obj, mat, secret->sym, secret->thresh, secret->nlevels,
149 secret->filter, secret->loadbal, secret->logging);
150 if (hypre_error_flag) return hypre_error_flag;
151 }
152 else /* reuse is true; this is a subsequent call */
153 {
154 /* reuse pattern: always use filter value of 0 and loadbal of 0 */
155 hypre_ParaSailsSetupValues(secret->obj, mat,
156 0.0, 0.0, secret->logging);
157 if (hypre_error_flag) return hypre_error_flag;
158 }
159
160 HYPRE_DistributedMatrixDestroy(mat);
161
162 return hypre_error_flag;
163 #endif
164 }
165
166 /*--------------------------------------------------------------------------
167 * HYPRE_ParCSRParaSailsSolve - Solve function for ParaSails.
168 *--------------------------------------------------------------------------*/
169
170 HYPRE_Int
HYPRE_ParCSRParaSailsSolve(HYPRE_Solver solver,HYPRE_ParCSRMatrix A,HYPRE_ParVector b,HYPRE_ParVector x)171 HYPRE_ParCSRParaSailsSolve( HYPRE_Solver solver,
172 HYPRE_ParCSRMatrix A,
173 HYPRE_ParVector b,
174 HYPRE_ParVector x )
175 {
176 #ifdef HYPRE_MIXEDINT
177 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
178 return hypre_error_flag;
179 #else
180
181 HYPRE_Real *rhs, *soln;
182 Secret *secret = (Secret *) solver;
183
184 rhs = hypre_VectorData(hypre_ParVectorLocalVector((hypre_ParVector *) b));
185 soln = hypre_VectorData(hypre_ParVectorLocalVector((hypre_ParVector *) x));
186
187 hypre_ParaSailsApply(secret->obj, rhs, soln);
188
189 return hypre_error_flag;
190 #endif
191 }
192
193 /*--------------------------------------------------------------------------
194 * HYPRE_ParCSRParaSailsSetParams - Set the parameters "thresh" and "nlevels"
195 * for a ParaSails object.
196 *--------------------------------------------------------------------------*/
197
198 HYPRE_Int
HYPRE_ParCSRParaSailsSetParams(HYPRE_Solver solver,HYPRE_Real thresh,HYPRE_Int nlevels)199 HYPRE_ParCSRParaSailsSetParams(HYPRE_Solver solver,
200 HYPRE_Real thresh,
201 HYPRE_Int nlevels )
202 {
203 #ifdef HYPRE_MIXEDINT
204 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
205 return hypre_error_flag;
206 #else
207
208 Secret *secret = (Secret *) solver;
209
210 secret->thresh = thresh;
211 secret->nlevels = nlevels;
212
213 return hypre_error_flag;
214 #endif
215 }
216
217 /*--------------------------------------------------------------------------
218 * HYPRE_ParCSRParaSailsSetFilter - Set the filter parameter,
219 * HYPRE_ParCSRParaSailsGetFilter
220 *--------------------------------------------------------------------------*/
221
222 HYPRE_Int
HYPRE_ParCSRParaSailsSetFilter(HYPRE_Solver solver,HYPRE_Real filter)223 HYPRE_ParCSRParaSailsSetFilter(HYPRE_Solver solver,
224 HYPRE_Real filter )
225 {
226 #ifdef HYPRE_MIXEDINT
227 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
228 return hypre_error_flag;
229 #else
230
231 Secret *secret = (Secret *) solver;
232
233 secret->filter = filter;
234
235 return hypre_error_flag;
236 #endif
237 }
238
239 HYPRE_Int
HYPRE_ParCSRParaSailsGetFilter(HYPRE_Solver solver,HYPRE_Real * filter)240 HYPRE_ParCSRParaSailsGetFilter(HYPRE_Solver solver,
241 HYPRE_Real * filter )
242 {
243 #ifdef HYPRE_MIXEDINT
244 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
245 return hypre_error_flag;
246 #else
247
248 Secret *secret = (Secret *) solver;
249
250 *filter = secret->filter;
251
252 return hypre_error_flag;
253 #endif
254 }
255
256 /*--------------------------------------------------------------------------
257 * HYPRE_ParCSRParaSailsSetSym - Set whether the matrix is symmetric:
258 * nonzero = symmetric, 0 = nonsymmetric.
259 *--------------------------------------------------------------------------*/
260
261 HYPRE_Int
HYPRE_ParCSRParaSailsSetSym(HYPRE_Solver solver,HYPRE_Int sym)262 HYPRE_ParCSRParaSailsSetSym(HYPRE_Solver solver,
263 HYPRE_Int sym )
264 {
265 #ifdef HYPRE_MIXEDINT
266 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
267 return hypre_error_flag;
268 #else
269
270 Secret *secret = (Secret *) solver;
271
272 secret->sym = sym;
273
274 return hypre_error_flag;
275 #endif
276 }
277
278 /*--------------------------------------------------------------------------
279 * HYPRE_ParCSRParaSailsSetLoadbal, HYPRE_ParCSRParaSailsGetLoadbal
280 *--------------------------------------------------------------------------*/
281
282 HYPRE_Int
HYPRE_ParCSRParaSailsSetLoadbal(HYPRE_Solver solver,HYPRE_Real loadbal)283 HYPRE_ParCSRParaSailsSetLoadbal(HYPRE_Solver solver,
284 HYPRE_Real loadbal )
285 {
286 #ifdef HYPRE_MIXEDINT
287 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
288 return hypre_error_flag;
289 #else
290
291 Secret *secret = (Secret *) solver;
292
293 secret->loadbal = loadbal;
294
295 return hypre_error_flag;
296 #endif
297 }
298
299 HYPRE_Int
HYPRE_ParCSRParaSailsGetLoadbal(HYPRE_Solver solver,HYPRE_Real * loadbal)300 HYPRE_ParCSRParaSailsGetLoadbal(HYPRE_Solver solver,
301 HYPRE_Real * loadbal )
302 {
303 #ifdef HYPRE_MIXEDINT
304 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
305 return hypre_error_flag;
306 #else
307
308 Secret *secret = (Secret *) solver;
309
310 *loadbal = secret->loadbal;
311
312 return hypre_error_flag;
313 #endif
314 }
315
316 /*--------------------------------------------------------------------------
317 * HYPRE_ParCSRParaSailsSetReuse - reuse pattern if "reuse" if nonzero
318 *--------------------------------------------------------------------------*/
319
320 HYPRE_Int
HYPRE_ParCSRParaSailsSetReuse(HYPRE_Solver solver,HYPRE_Int reuse)321 HYPRE_ParCSRParaSailsSetReuse(HYPRE_Solver solver,
322 HYPRE_Int reuse )
323 {
324 #ifdef HYPRE_MIXEDINT
325 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
326 return hypre_error_flag;
327 #else
328
329 Secret *secret = (Secret *) solver;
330
331 secret->reuse = reuse;
332
333 return hypre_error_flag;
334 #endif
335 }
336
337 /*--------------------------------------------------------------------------
338 * HYPRE_ParCSRParaSailsSetLogging -
339 *--------------------------------------------------------------------------*/
340
341 HYPRE_Int
HYPRE_ParCSRParaSailsSetLogging(HYPRE_Solver solver,HYPRE_Int logging)342 HYPRE_ParCSRParaSailsSetLogging(HYPRE_Solver solver,
343 HYPRE_Int logging )
344 {
345 #ifdef HYPRE_MIXEDINT
346 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
347 return hypre_error_flag;
348 #else
349
350 Secret *secret = (Secret *) solver;
351
352 secret->logging = logging;
353
354 return hypre_error_flag;
355 #endif
356 }
357
358 /******************************************************************************
359 *
360 * HYPRE_ParaSails interface
361 *
362 *****************************************************************************/
363
364 /*--------------------------------------------------------------------------
365 * HYPRE_ParaSailsCreate - Return a ParaSails preconditioner object
366 * "solver". The default parameters for the preconditioner are also set,
367 * so a call to HYPRE_ParaSailsSetParams is not absolutely necessary.
368 *--------------------------------------------------------------------------*/
369
370 HYPRE_Int
HYPRE_ParaSailsCreate(MPI_Comm comm,HYPRE_Solver * solver)371 HYPRE_ParaSailsCreate( MPI_Comm comm, HYPRE_Solver *solver )
372 {
373 #ifdef HYPRE_MIXEDINT
374 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
375 return hypre_error_flag;
376 #else
377
378 Secret *secret;
379
380 secret = hypre_TAlloc(Secret, 1, HYPRE_MEMORY_HOST);
381
382 if (secret == NULL)
383 {
384 hypre_error(HYPRE_ERROR_MEMORY);
385 return hypre_error_flag;
386 }
387
388 secret->sym = 1;
389 secret->thresh = 0.1;
390 secret->nlevels = 1;
391 secret->filter = 0.1;
392 secret->loadbal = 0.0;
393 secret->reuse = 0;
394 secret->comm = comm;
395 secret->logging = 0;
396
397 hypre_ParaSailsCreate(comm, &secret->obj);
398
399 *solver = (HYPRE_Solver) secret;
400
401 return hypre_error_flag;
402 #endif
403 }
404
405 /*--------------------------------------------------------------------------
406 * HYPRE_ParaSailsDestroy - Destroy a ParaSails object.
407 *--------------------------------------------------------------------------*/
408
409 HYPRE_Int
HYPRE_ParaSailsDestroy(HYPRE_Solver solver)410 HYPRE_ParaSailsDestroy( HYPRE_Solver solver )
411 {
412 #ifdef HYPRE_MIXEDINT
413 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
414 return hypre_error_flag;
415 #else
416
417 Secret *secret;
418
419 secret = (Secret *) solver;
420 hypre_ParaSailsDestroy(secret->obj);
421
422 hypre_TFree(secret,HYPRE_MEMORY_HOST);
423
424 return hypre_error_flag;
425 #endif
426 }
427
428 /*--------------------------------------------------------------------------
429 * HYPRE_ParaSailsSetup - Set up function for ParaSails.
430 * This function is not called on subsequent times if the preconditioner is
431 * being reused.
432 *--------------------------------------------------------------------------*/
433
434 HYPRE_Int
HYPRE_ParaSailsSetup(HYPRE_Solver solver,HYPRE_ParCSRMatrix A,HYPRE_ParVector b,HYPRE_ParVector x)435 HYPRE_ParaSailsSetup( HYPRE_Solver solver,
436 HYPRE_ParCSRMatrix A,
437 HYPRE_ParVector b,
438 HYPRE_ParVector x )
439 {
440 #ifdef HYPRE_MIXEDINT
441 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
442 return hypre_error_flag;
443 #else
444
445 static HYPRE_Int virgin = 1;
446 HYPRE_DistributedMatrix mat;
447 Secret *secret = (Secret *) solver;
448 HYPRE_Int ierr;
449
450 /* The following call will also create the distributed matrix */
451
452 ierr = HYPRE_GetError(); HYPRE_ClearAllErrors();
453 HYPRE_ConvertParCSRMatrixToDistributedMatrix( A, &mat );
454 if (hypre_error_flag) return hypre_error_flag |= ierr;
455
456 if (virgin || secret->reuse == 0) /* call set up at least once */
457 {
458 virgin = 0;
459 hypre_ParaSailsSetup(
460 secret->obj, mat, secret->sym, secret->thresh, secret->nlevels,
461 secret->filter, secret->loadbal, secret->logging);
462 if (hypre_error_flag) return hypre_error_flag |= ierr;
463 }
464 else /* reuse is true; this is a subsequent call */
465 {
466 /* reuse pattern: always use filter value of 0 and loadbal of 0 */
467 hypre_ParaSailsSetupValues(secret->obj, mat,
468 0.0, 0.0, secret->logging);
469 if (hypre_error_flag) return hypre_error_flag |= ierr;
470 }
471
472 HYPRE_DistributedMatrixDestroy(mat);
473
474 return hypre_error_flag;
475 #endif
476 }
477 /*--------------------------------------------------------------------------
478 * HYPRE_ParaSailsSolve - Solve function for ParaSails.
479 *--------------------------------------------------------------------------*/
480
481 HYPRE_Int
HYPRE_ParaSailsSolve(HYPRE_Solver solver,HYPRE_ParCSRMatrix A,HYPRE_ParVector b,HYPRE_ParVector x)482 HYPRE_ParaSailsSolve( HYPRE_Solver solver,
483 HYPRE_ParCSRMatrix A,
484 HYPRE_ParVector b,
485 HYPRE_ParVector x )
486 {
487 #ifdef HYPRE_MIXEDINT
488 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
489 return hypre_error_flag;
490 #else
491
492 HYPRE_Real *rhs, *soln;
493 Secret *secret = (Secret *) solver;
494
495 rhs = hypre_VectorData(hypre_ParVectorLocalVector((hypre_ParVector *) b));
496 soln = hypre_VectorData(hypre_ParVectorLocalVector((hypre_ParVector *) x));
497
498 hypre_ParaSailsApply(secret->obj, rhs, soln);
499
500 return hypre_error_flag;
501 #endif
502 }
503
504 /*--------------------------------------------------------------------------
505 * HYPRE_ParaSailsSetParams - Set the parameters "thresh" and "nlevels"
506 * for a ParaSails object.
507 *--------------------------------------------------------------------------*/
508
509 HYPRE_Int
HYPRE_ParaSailsSetParams(HYPRE_Solver solver,HYPRE_Real thresh,HYPRE_Int nlevels)510 HYPRE_ParaSailsSetParams(HYPRE_Solver solver,
511 HYPRE_Real thresh,
512 HYPRE_Int nlevels )
513 {
514 #ifdef HYPRE_MIXEDINT
515 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
516 return hypre_error_flag;
517 #else
518
519 Secret *secret = (Secret *) solver;
520
521 secret->thresh = thresh;
522 secret->nlevels = nlevels;
523
524 return hypre_error_flag;
525 #endif
526 }
527
528 /*--------------------------------------------------------------------------
529 * HYPRE_ParaSailsSetThresh - Set the "thresh" parameter only
530 * for a ParaSails object.
531 * HYPRE_ParaSailsGetThresh
532 *--------------------------------------------------------------------------*/
533
534 HYPRE_Int
HYPRE_ParaSailsSetThresh(HYPRE_Solver solver,HYPRE_Real thresh)535 HYPRE_ParaSailsSetThresh( HYPRE_Solver solver,
536 HYPRE_Real thresh )
537 {
538 #ifdef HYPRE_MIXEDINT
539 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
540 return hypre_error_flag;
541 #else
542
543 Secret *secret = (Secret *) solver;
544
545 secret->thresh = thresh;
546
547 return hypre_error_flag;
548 #endif
549 }
550
551 HYPRE_Int
HYPRE_ParaSailsGetThresh(HYPRE_Solver solver,HYPRE_Real * thresh)552 HYPRE_ParaSailsGetThresh( HYPRE_Solver solver,
553 HYPRE_Real * thresh )
554 {
555 #ifdef HYPRE_MIXEDINT
556 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
557 return hypre_error_flag;
558 #else
559
560 Secret *secret = (Secret *) solver;
561
562 *thresh = secret->thresh;
563
564 return hypre_error_flag;
565 #endif
566 }
567
568 /*--------------------------------------------------------------------------
569 * HYPRE_ParaSailsSetNlevels - Set the "nlevels" parameter only
570 * for a ParaSails object.
571 * HYPRE_ParaSailsGetNlevels
572 *--------------------------------------------------------------------------*/
573
574 HYPRE_Int
HYPRE_ParaSailsSetNlevels(HYPRE_Solver solver,HYPRE_Int nlevels)575 HYPRE_ParaSailsSetNlevels( HYPRE_Solver solver,
576 HYPRE_Int nlevels )
577 {
578 #ifdef HYPRE_MIXEDINT
579 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
580 return hypre_error_flag;
581 #else
582
583 Secret *secret = (Secret *) solver;
584
585 secret->nlevels = nlevels;
586
587 return hypre_error_flag;
588 #endif
589 }
590
591 HYPRE_Int
HYPRE_ParaSailsGetNlevels(HYPRE_Solver solver,HYPRE_Int * nlevels)592 HYPRE_ParaSailsGetNlevels( HYPRE_Solver solver,
593 HYPRE_Int * nlevels )
594 {
595 #ifdef HYPRE_MIXEDINT
596 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
597 return hypre_error_flag;
598 #else
599
600 Secret *secret = (Secret *) solver;
601
602 *nlevels = secret->nlevels;
603
604 return hypre_error_flag;
605 #endif
606 }
607
608 /*--------------------------------------------------------------------------
609 * HYPRE_ParaSailsSetFilter - Set the filter parameter.
610 * HYPRE_ParaSailsGetFilter
611 *--------------------------------------------------------------------------*/
612
613 HYPRE_Int
HYPRE_ParaSailsSetFilter(HYPRE_Solver solver,HYPRE_Real filter)614 HYPRE_ParaSailsSetFilter(HYPRE_Solver solver,
615 HYPRE_Real filter )
616 {
617 #ifdef HYPRE_MIXEDINT
618 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
619 return hypre_error_flag;
620 #else
621
622 Secret *secret = (Secret *) solver;
623
624 secret->filter = filter;
625
626 return hypre_error_flag;
627 #endif
628 }
629
630 HYPRE_Int
HYPRE_ParaSailsGetFilter(HYPRE_Solver solver,HYPRE_Real * filter)631 HYPRE_ParaSailsGetFilter(HYPRE_Solver solver,
632 HYPRE_Real * filter )
633 {
634 #ifdef HYPRE_MIXEDINT
635 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
636 return hypre_error_flag;
637 #else
638
639 Secret *secret = (Secret *) solver;
640
641 *filter = secret->filter;
642
643 return hypre_error_flag;
644 #endif
645 }
646
647 /*--------------------------------------------------------------------------
648 * HYPRE_ParaSailsSetSym - Set whether the matrix is symmetric:
649 * nonzero = symmetric, 0 = nonsymmetric.
650 * HYPRE_ParaSailsGetSym
651 *--------------------------------------------------------------------------*/
652
653 HYPRE_Int
HYPRE_ParaSailsSetSym(HYPRE_Solver solver,HYPRE_Int sym)654 HYPRE_ParaSailsSetSym(HYPRE_Solver solver,
655 HYPRE_Int sym )
656 {
657 #ifdef HYPRE_MIXEDINT
658 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
659 return hypre_error_flag;
660 #else
661
662 Secret *secret = (Secret *) solver;
663
664 secret->sym = sym;
665
666 return hypre_error_flag;
667 #endif
668 }
669
670 HYPRE_Int
HYPRE_ParaSailsGetSym(HYPRE_Solver solver,HYPRE_Int * sym)671 HYPRE_ParaSailsGetSym(HYPRE_Solver solver,
672 HYPRE_Int * sym )
673 {
674 #ifdef HYPRE_MIXEDINT
675 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
676 return hypre_error_flag;
677 #else
678
679 Secret *secret = (Secret *) solver;
680
681 *sym = secret->sym;
682
683 return hypre_error_flag;
684 #endif
685 }
686
687 /*--------------------------------------------------------------------------
688 * HYPRE_ParaSailsSetLoadbal, HYPRE_ParaSailsGetLoadbal
689 *--------------------------------------------------------------------------*/
690
691 HYPRE_Int
HYPRE_ParaSailsSetLoadbal(HYPRE_Solver solver,HYPRE_Real loadbal)692 HYPRE_ParaSailsSetLoadbal(HYPRE_Solver solver,
693 HYPRE_Real loadbal )
694 {
695 #ifdef HYPRE_MIXEDINT
696 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
697 return hypre_error_flag;
698 #else
699
700 Secret *secret = (Secret *) solver;
701
702 secret->loadbal = loadbal;
703
704 return hypre_error_flag;
705 #endif
706 }
707
708 HYPRE_Int
HYPRE_ParaSailsGetLoadbal(HYPRE_Solver solver,HYPRE_Real * loadbal)709 HYPRE_ParaSailsGetLoadbal(HYPRE_Solver solver,
710 HYPRE_Real * loadbal )
711 {
712 #ifdef HYPRE_MIXEDINT
713 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
714 return hypre_error_flag;
715 #else
716
717 Secret *secret = (Secret *) solver;
718
719 *loadbal = secret->loadbal;
720
721 return hypre_error_flag;
722 #endif
723 }
724
725 /*--------------------------------------------------------------------------
726 * HYPRE_ParaSailsSetReuse - reuse pattern if "reuse" if nonzero
727 * HYPRE_ParaSailsGetReuse
728 *--------------------------------------------------------------------------*/
729
730 HYPRE_Int
HYPRE_ParaSailsSetReuse(HYPRE_Solver solver,HYPRE_Int reuse)731 HYPRE_ParaSailsSetReuse(HYPRE_Solver solver,
732 HYPRE_Int reuse )
733 {
734 #ifdef HYPRE_MIXEDINT
735 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
736 return hypre_error_flag;
737 #else
738
739 Secret *secret = (Secret *) solver;
740
741 secret->reuse = reuse;
742
743 return hypre_error_flag;
744 #endif
745 }
746
747 HYPRE_Int
HYPRE_ParaSailsGetReuse(HYPRE_Solver solver,HYPRE_Int * reuse)748 HYPRE_ParaSailsGetReuse(HYPRE_Solver solver,
749 HYPRE_Int * reuse )
750 {
751 #ifdef HYPRE_MIXEDINT
752 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
753 return hypre_error_flag;
754 #else
755
756 Secret *secret = (Secret *) solver;
757
758 *reuse = secret->reuse;
759
760 return hypre_error_flag;
761 #endif
762 }
763
764 /*--------------------------------------------------------------------------
765 * HYPRE_ParaSailsSetLogging, HYPRE_ParaSailsGetLogging
766 *--------------------------------------------------------------------------*/
767
768 HYPRE_Int
HYPRE_ParaSailsSetLogging(HYPRE_Solver solver,HYPRE_Int logging)769 HYPRE_ParaSailsSetLogging(HYPRE_Solver solver,
770 HYPRE_Int logging )
771 {
772 #ifdef HYPRE_MIXEDINT
773 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
774 return hypre_error_flag;
775 #else
776
777 Secret *secret = (Secret *) solver;
778
779 secret->logging = logging;
780
781 return hypre_error_flag;
782 #endif
783 }
784
785 HYPRE_Int
HYPRE_ParaSailsGetLogging(HYPRE_Solver solver,HYPRE_Int * logging)786 HYPRE_ParaSailsGetLogging(HYPRE_Solver solver,
787 HYPRE_Int * logging )
788 {
789 #ifdef HYPRE_MIXEDINT
790 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
791 return hypre_error_flag;
792 #else
793
794 Secret *secret = (Secret *) solver;
795
796 *logging = secret->logging;
797
798 return hypre_error_flag;
799 #endif
800 }
801
802 /*--------------------------------------------------------------------------
803 * HYPRE_ParaSailsBuildIJMatrix -
804 *--------------------------------------------------------------------------*/
805 HYPRE_Int
HYPRE_ParaSailsBuildIJMatrix(HYPRE_Solver solver,HYPRE_IJMatrix * pij_A)806 HYPRE_ParaSailsBuildIJMatrix(HYPRE_Solver solver, HYPRE_IJMatrix *pij_A)
807 {
808 #ifdef HYPRE_MIXEDINT
809 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"ParaSails not usable in mixedint mode!");
810 return hypre_error_flag;
811 #else
812
813 Secret *secret = (Secret *) solver;
814
815 hypre_ParaSailsBuildIJMatrix(secret->obj, pij_A);
816
817 return hypre_error_flag;
818 #endif
819 }
820