source: CIVL/examples/mpi-omp/AMG2013/parcsr_ls/par_amg.c

main
Last change on this file was ea777aa, checked in by Alex Wilton <awilton@…>, 3 years ago

Moved examples, include, build_default.properties, common.xml, and README out from dev.civl.com into the root of the repo.

git-svn-id: ​svn://vsl.cis.udel.edu/civl/trunk@5704 fb995dde-84ed-4084-dfe6-e5aef3e2452c
  • Property mode set to 100644
File size: 69.0 KB
RevLine 
[2aa6644]1/*BHEADER**********************************************************************
2 * Copyright (c) 2008, Lawrence Livermore National Security, LLC.
3 * Produced at the Lawrence Livermore National Laboratory.
4 * This file is part of HYPRE. See file COPYRIGHT for details.
5 *
6 * HYPRE is free software; you can redistribute it and/or modify it under the
7 * terms of the GNU Lesser General Public License (as published by the Free
8 * Software Foundation) version 2.1 dated February 1999.
9 *
10 * $Revision: 2.4 $
11 ***********************************************************************EHEADER*/
12
13
14
15
16/******************************************************************************
17 *
18 * ParAMG functions
19 *
20 *****************************************************************************/
21
22#include "headers.h"
23#include "par_amg.h"
24#include <assert.h>
25#include "seq_mv.h"
26
27/*--------------------------------------------------------------------------
28 * hypre_BoomerAMGCreate
29 *--------------------------------------------------------------------------*/
30
31void *
32hypre_BoomerAMGCreate()
33{
34 hypre_ParAMGData *amg_data;
35
36 /* setup params */
37 int max_levels;
38 double strong_threshold;
39 double max_row_sum;
40 double trunc_factor;
41 double agg_trunc_factor;
42 double jacobi_trunc_threshold;
43 double S_commpkg_switch;
44 double CR_rate;
45 int interp_type;
46 int coarsen_type;
47 int measure_type;
48 int setup_type;
49 int P_max_elmts;
50 int P_max1;
51 int P_max2;
52 int num_functions;
53 int nodal;
54 int num_paths;
55 int agg_interp_type;
56 int agg_P_max_elmts;
57 int agg_num_levels;
58 int post_interp_type;
59 int num_CR_relax_steps;
60 int IS_type;
61 int CR_use_CG;
62 int seq_threshold;
63 int coarse_threshold;
64
65 /* solve params */
66 int min_iter;
67 int max_iter;
68 int cycle_type;
69
70 double tol;
71
72 int num_sweeps;
73 int relax_type;
74 int relax_order;
75 double relax_wt;
76 double outer_wt;
77 int smooth_type;
78 int smooth_num_levels;
79 int smooth_num_sweeps;
80
81 int variant, overlap, domain_type;
82 double schwarz_rlx_weight;
83 int level, sym;
84 double thresh, filter;
85 double drop_tol;
86 int max_nz_per_row;
87 char *euclidfile;
88
89 int cheby_order;
90 double cheby_eig_ratio;
91
92
93 int block_mode;
94
95
96 /* log info */
97 int num_iterations;
98 int cum_num_iterations;
99
100 /* output params */
101 int print_level;
102 int logging;
103 /* int cycle_op_count; */
104 char log_file_name[256];
105 int debug_flag;
106
107 /*-----------------------------------------------------------------------
108 * Setup default values for parameters
109 *-----------------------------------------------------------------------*/
110
111 /* setup params */
112 max_levels = 25;
113 strong_threshold = 0.25;
114 max_row_sum = 0.9;
115 trunc_factor = 0.0;
116 agg_trunc_factor = 0.0;
117 jacobi_trunc_threshold = 0.01;
118 S_commpkg_switch = 1.0;
119 interp_type = 0;
120 coarsen_type = 6;
121 measure_type = 0;
122 setup_type = 1;
123 P_max_elmts = 0;
124 P_max1 = 0;
125 P_max2 = 0;
126 num_functions = 1;
127 nodal = 0;
128 agg_interp_type = 4;
129 agg_P_max_elmts = 0;
130 num_paths = 1;
131 agg_num_levels = 0;
132 post_interp_type = 0;
133 num_CR_relax_steps = 2;
134 CR_rate = 0.7;
135 IS_type = 1;
136 CR_use_CG = 0;
137 seq_threshold = 0;
138 coarse_threshold = 9;
139
140 variant = 0;
141 overlap = 1;
142 domain_type = 2;
143 schwarz_rlx_weight = 1.0;
144 smooth_num_sweeps = 1;
145 smooth_num_levels = 0;
146 smooth_type = 6;
147
148 level = 1;
149 sym = 0;
150 thresh = 0.1;
151 filter = 0.05;
152 drop_tol = 0.0001;
153 max_nz_per_row = 20;
154 euclidfile = NULL;
155
156 /* solve params */
157 min_iter = 0;
158 max_iter = 20;
159 cycle_type = 1;
160 tol = 1.0e-7;
161
162 num_sweeps = 1;
163 relax_type = 3;
164 relax_order = 1;
165 relax_wt = 1.0;
166 outer_wt = 1.0;
167
168 cheby_order = 2;
169 cheby_eig_ratio = .3;
170
171
172 block_mode = 0;
173
174 /* log info */
175 num_iterations = 0;
176 cum_num_iterations = 0;
177
178 /* output params */
179 print_level = 0;
180 logging = 0;
181 sprintf(log_file_name, "%s", "amg.out.log");
182 /* cycle_op_count = 0; */
183 debug_flag = 0;
184
185 /*-----------------------------------------------------------------------
186 * Create the hypre_ParAMGData structure and return
187 *-----------------------------------------------------------------------*/
188
189 amg_data = hypre_CTAlloc(hypre_ParAMGData, 1);
190
191 hypre_ParAMGDataSeqThreshold(amg_data) = seq_threshold;
192 hypre_ParAMGDataMaxCoarseSize(amg_data) = coarse_threshold;
193 hypre_ParAMGDataSeqData(amg_data) = NULL;
194
195 hypre_ParAMGDataUserCoarseRelaxType(amg_data) = 9;
196 hypre_BoomerAMGSetMaxLevels(amg_data, max_levels);
197 hypre_BoomerAMGSetStrongThreshold(amg_data, strong_threshold);
198 hypre_BoomerAMGSetMaxRowSum(amg_data, max_row_sum);
199 hypre_BoomerAMGSetTruncFactor(amg_data, trunc_factor);
200 hypre_BoomerAMGSetAggTruncFactor(amg_data, agg_trunc_factor);
201 hypre_BoomerAMGSetJacobiTruncThreshold(amg_data, jacobi_trunc_threshold);
202 hypre_BoomerAMGSetSCommPkgSwitch(amg_data, S_commpkg_switch);
203 hypre_BoomerAMGSetInterpType(amg_data, interp_type);
204 hypre_BoomerAMGSetMeasureType(amg_data, measure_type);
205 hypre_BoomerAMGSetCoarsenType(amg_data, coarsen_type);
206 hypre_BoomerAMGSetSetupType(amg_data, setup_type);
207 hypre_BoomerAMGSetPMaxElmts(amg_data, P_max_elmts);
208 hypre_BoomerAMGSetPMax1(amg_data, P_max1);
209 hypre_BoomerAMGSetPMax2(amg_data, P_max2);
210 hypre_BoomerAMGSetNumFunctions(amg_data, num_functions);
211 hypre_BoomerAMGSetNodal(amg_data, nodal);
212 hypre_BoomerAMGSetAggInterpType(amg_data, agg_interp_type);
213 hypre_BoomerAMGSetAggPMaxElmts(amg_data, agg_P_max_elmts);
214 hypre_BoomerAMGSetNumPaths(amg_data, num_paths);
215 hypre_BoomerAMGSetAggNumLevels(amg_data, agg_num_levels);
216 hypre_BoomerAMGSetPostInterpType(amg_data, post_interp_type);
217 hypre_BoomerAMGSetNumCRRelaxSteps(amg_data, num_CR_relax_steps);
218 hypre_BoomerAMGSetCRRate(amg_data, CR_rate);
219 hypre_BoomerAMGSetISType(amg_data, IS_type);
220 hypre_BoomerAMGSetCRUseCG(amg_data, CR_use_CG);
221 hypre_BoomerAMGSetVariant(amg_data, variant);
222 hypre_BoomerAMGSetOverlap(amg_data, overlap);
223 /*hypre_BoomerAMGSetSchwarzRlxWeight(amg_data, schwarz_rlx_weight);
224 hypre_BoomerAMGSetDomainType(amg_data, domain_type);
225 hypre_BoomerAMGSetSym(amg_data, sym);
226 hypre_BoomerAMGSetLevel(amg_data, level);
227 hypre_BoomerAMGSetThreshold(amg_data, thresh);
228 hypre_BoomerAMGSetFilter(amg_data, filter);
229 hypre_BoomerAMGSetDropTol(amg_data, drop_tol);
230 hypre_BoomerAMGSetMaxNzPerRow(amg_data, max_nz_per_row);*/
231
232 hypre_BoomerAMGSetMinIter(amg_data, min_iter);
233 hypre_BoomerAMGSetMaxIter(amg_data, max_iter);
234 hypre_BoomerAMGSetCycleType(amg_data, cycle_type);
235 hypre_BoomerAMGSetTol(amg_data, tol);
236 hypre_BoomerAMGSetNumSweeps(amg_data, num_sweeps);
237 hypre_BoomerAMGSetRelaxType(amg_data, relax_type);
238 hypre_BoomerAMGSetRelaxOrder(amg_data, relax_order);
239 hypre_BoomerAMGSetRelaxWt(amg_data, relax_wt);
240 hypre_BoomerAMGSetOuterWt(amg_data, outer_wt);
241 hypre_BoomerAMGSetSmoothType(amg_data, smooth_type);
242 hypre_BoomerAMGSetSmoothNumLevels(amg_data, smooth_num_levels);
243 hypre_BoomerAMGSetSmoothNumSweeps(amg_data, smooth_num_sweeps);
244
245 hypre_BoomerAMGSetChebyOrder(amg_data, cheby_order);
246 hypre_BoomerAMGSetChebyEigRatio(amg_data, cheby_eig_ratio);
247
248 hypre_BoomerAMGSetNumIterations(amg_data, num_iterations);
249#ifdef CUMNUMIT
250 hypre_ParAMGDataCumNumIterations(amg_data) = cum_num_iterations;
251#endif
252 hypre_BoomerAMGSetPrintLevel(amg_data, print_level);
253 hypre_BoomerAMGSetLogging(amg_data, logging);
254 hypre_BoomerAMGSetPrintFileName(amg_data, log_file_name);
255 hypre_BoomerAMGSetDebugFlag(amg_data, debug_flag);
256
257 hypre_BoomerAMGSetRestriction(amg_data, 0);
258
259 hypre_BoomerAMGSetGSMG(amg_data, 0);
260 hypre_BoomerAMGSetNumSamples(amg_data, 0);
261
262 hypre_ParAMGDataAArray(amg_data) = NULL;
263 hypre_ParAMGDataPArray(amg_data) = NULL;
264 hypre_ParAMGDataRArray(amg_data) = NULL;
265 hypre_ParAMGDataCFMarkerArray(amg_data) = NULL;
266 hypre_ParAMGDataVtemp(amg_data) = NULL;
267 hypre_ParAMGDataRtemp(amg_data) = NULL;
268 hypre_ParAMGDataPtemp(amg_data) = NULL;
269 hypre_ParAMGDataZtemp(amg_data) = NULL;
270 hypre_ParAMGDataFArray(amg_data) = NULL;
271 hypre_ParAMGDataUArray(amg_data) = NULL;
272 hypre_ParAMGDataDofFunc(amg_data) = NULL;
273 hypre_ParAMGDataDofFuncArray(amg_data) = NULL;
274 hypre_ParAMGDataDofPointArray(amg_data) = NULL;
275 hypre_ParAMGDataDofPointArray(amg_data) = NULL;
276 hypre_ParAMGDataPointDofMapArray(amg_data) = NULL;
277 hypre_ParAMGDataSmoother(amg_data) = NULL;
278 hypre_ParAMGDataSmootherPrec(amg_data) = NULL;
279 /*hypre_ParAMGDataABlockArray(amg_data) = NULL;
280 hypre_ParAMGDataPBlockArray(amg_data) = NULL;
281 hypre_ParAMGDataRBlockArray(amg_data) = NULL;*/
282
283 /* this can not be set by the user currently */
284 hypre_ParAMGDataBlockMode(amg_data) = block_mode;
285
286 hypre_ParAMGDataMaxEigEst(amg_data) = NULL;
287 hypre_ParAMGDataMinEigEst(amg_data) = NULL;
288 hypre_ParAMGDataThetaEst(amg_data) = NULL;
289
290
291 return (void *) amg_data;
292}
293
294/*--------------------------------------------------------------------------
295 * hypre_BoomerAMGDestroy
296 *--------------------------------------------------------------------------*/
297
298int
299hypre_BoomerAMGDestroy( void *data )
300{
301 hypre_ParAMGData *amg_data = data;
302 int num_levels = hypre_ParAMGDataNumLevels(amg_data);
303 int i;
304 HYPRE_Solver *smoother = hypre_ParAMGDataSmoother(amg_data);
305 HYPRE_Solver *smoother_prec = hypre_ParAMGDataSmootherPrec(amg_data);
306
307 //seq solver?
308 if (hypre_ParAMGDataSeqData(amg_data))
309 {
310 hypre_SeqAMGData *seq_data = hypre_ParAMGDataSeqData(amg_data);
311 int tot_levels = hypre_SeqAMGDataNumLevels(seq_data);
312 if (hypre_SeqAMGDataParticipate(seq_data))
313 {
314 for (i=num_levels-1; i < tot_levels; i++)
315 {
316 hypre_SeqVectorDestroy(hypre_SeqAMGDataFArray(seq_data)[i]);
317 hypre_SeqVectorDestroy(hypre_SeqAMGDataUArray(seq_data)[i]);
318 hypre_CSRMatrixDestroy(hypre_SeqAMGDataAArray(seq_data)[i]);
319 }
320 for (i=num_levels-1; i < tot_levels-1; i++)
321 {
322 hypre_CSRMatrixDestroy(hypre_SeqAMGDataPArray(seq_data)[i]);
323 }
324 for (i=num_levels-1; i < tot_levels-1; i++)
325 {
326 hypre_TFree(hypre_ParAMGDataCFMarkerArray(amg_data)[i]);
327 }
328 for (i=num_levels; i < tot_levels; i++)
329 hypre_TFree(hypre_ParAMGDataDofFuncArray(amg_data)[i]);
330
331
332 hypre_TFree(hypre_SeqAMGDataFArray(seq_data));
333 hypre_TFree(hypre_SeqAMGDataUArray(seq_data));
334 hypre_TFree(hypre_SeqAMGDataAArray(seq_data));
335 hypre_TFree(hypre_SeqAMGDataPArray(seq_data));
336
337 hypre_SeqVectorDestroy(hypre_SeqAMGDataVtemp(seq_data));
338 }
339
340
341 hypre_TFree(seq_data);
342
343
344 }
345
346
347
348 if (hypre_ParAMGDataGridRelaxType(amg_data))
349 {
350 int *grid_relax_type = hypre_ParAMGDataGridRelaxType(amg_data);
351 if (grid_relax_type[1] == 13 || grid_relax_type[3] == 13 )
352 {
353 if (grid_relax_type[1] == 13)
354 {
355 for (i=0; i < num_levels; i++)
356 {
357 HYPRE_ParCSRPCGDestroy(smoother[i]);
358 }
359 }
360 else if (grid_relax_type[3] == 13)
361 {
362 HYPRE_ParCSRPCGDestroy(smoother[num_levels -1]);
363 }
364 hypre_TFree (hypre_ParAMGDataSmoother(amg_data));
365 hypre_ParAMGDataSmoother(amg_data) = NULL;
366 }
367 else if (grid_relax_type[1] == 14 || grid_relax_type[3] == 14 )
368 {
369 if (grid_relax_type[1] == 14)
370 {
371 for (i=0; i < num_levels; i++)
372 {
373 HYPRE_ParCSRPCGDestroy(smoother[i]);
374 HYPRE_BoomerAMGDestroy(smoother_prec[i]);
375 }
376 }
377 else if (grid_relax_type[3] == 14)
378 {
379 HYPRE_ParCSRPCGDestroy(smoother[num_levels -1]);
380 HYPRE_BoomerAMGDestroy(smoother_prec[num_levels -1]);
381 }
382 hypre_TFree (hypre_ParAMGDataSmoother(amg_data));
383 hypre_ParAMGDataSmoother(amg_data) = NULL;
384 hypre_TFree (hypre_ParAMGDataSmootherPrec(amg_data));
385 hypre_ParAMGDataSmootherPrec(amg_data) = NULL;
386
387
388
389 }
390 }
391 if (hypre_ParAMGDataThetaEst(amg_data))
392 {
393 hypre_TFree(hypre_ParAMGDataThetaEst(amg_data));
394 hypre_ParAMGDataThetaEst(amg_data) = NULL;
395 }
396 if (hypre_ParAMGDataMaxEigEst(amg_data))
397 {
398 hypre_TFree(hypre_ParAMGDataMaxEigEst(amg_data));
399 hypre_ParAMGDataMaxEigEst(amg_data) = NULL;
400 }
401 if (hypre_ParAMGDataMinEigEst(amg_data))
402 {
403 hypre_TFree(hypre_ParAMGDataMinEigEst(amg_data));
404 hypre_ParAMGDataMinEigEst(amg_data) = NULL;
405 }
406 if (hypre_ParAMGDataNumGridSweeps(amg_data))
407 {
408 hypre_TFree (hypre_ParAMGDataNumGridSweeps(amg_data));
409 hypre_ParAMGDataNumGridSweeps(amg_data) = NULL;
410 }
411 if (hypre_ParAMGDataGridRelaxType(amg_data))
412 {
413 hypre_TFree (hypre_ParAMGDataGridRelaxType(amg_data));
414 hypre_ParAMGDataGridRelaxType(amg_data) = NULL;
415 }
416 if (hypre_ParAMGDataRelaxWeight(amg_data))
417 {
418 hypre_TFree (hypre_ParAMGDataRelaxWeight(amg_data));
419 hypre_ParAMGDataRelaxWeight(amg_data) = NULL;
420 }
421 if (hypre_ParAMGDataOmega(amg_data))
422 {
423 hypre_TFree (hypre_ParAMGDataOmega(amg_data));
424 hypre_ParAMGDataOmega(amg_data) = NULL;
425 }
426 if (hypre_ParAMGDataDofFunc(amg_data))
427 {
428 hypre_TFree (hypre_ParAMGDataDofFunc(amg_data));
429 hypre_ParAMGDataDofFunc(amg_data) = NULL;
430 }
431 if (hypre_ParAMGDataGridRelaxPoints(amg_data))
432 {
433 for (i=0; i < 4; i++)
434 hypre_TFree (hypre_ParAMGDataGridRelaxPoints(amg_data)[i]);
435 hypre_TFree (hypre_ParAMGDataGridRelaxPoints(amg_data));
436 hypre_ParAMGDataGridRelaxPoints(amg_data) = NULL;
437 }
438 for (i=1; i < num_levels; i++)
439 {
440 hypre_ParVectorDestroy(hypre_ParAMGDataFArray(amg_data)[i]);
441 hypre_ParVectorDestroy(hypre_ParAMGDataUArray(amg_data)[i]);
442
443 if (hypre_ParAMGDataAArray(amg_data)[i])
444 hypre_ParCSRMatrixDestroy(hypre_ParAMGDataAArray(amg_data)[i]);
445
446 if (hypre_ParAMGDataPArray(amg_data)[i-1])
447 hypre_ParCSRMatrixDestroy(hypre_ParAMGDataPArray(amg_data)[i-1]);
448
449 hypre_TFree(hypre_ParAMGDataCFMarkerArray(amg_data)[i-1]);
450
451 /* get rid of any block structures */
452 /*if (hypre_ParAMGDataABlockArray(amg_data)[i])
453 hypre_ParCSRBlockMatrixDestroy(hypre_ParAMGDataABlockArray(amg_data)[i]);
454
455 if (hypre_ParAMGDataPBlockArray(amg_data)[i-1])
456 hypre_ParCSRBlockMatrixDestroy(hypre_ParAMGDataPBlockArray(amg_data)[i-1]);*/
457
458 }
459
460 /* get rid of a fine level block matrix */
461 /*if (hypre_ParAMGDataABlockArray(amg_data))
462 if (hypre_ParAMGDataABlockArray(amg_data)[0])
463 hypre_ParCSRBlockMatrixDestroy(hypre_ParAMGDataABlockArray(amg_data)[0]);*/
464
465
466 /* see comments in par_coarsen.c regarding special case for CF_marker */
467 if (num_levels == 1)
468 {
469 hypre_TFree(hypre_ParAMGDataCFMarkerArray(amg_data)[0]);
470 }
471 hypre_ParVectorDestroy(hypre_ParAMGDataVtemp(amg_data));
472 hypre_TFree(hypre_ParAMGDataFArray(amg_data));
473 hypre_TFree(hypre_ParAMGDataUArray(amg_data));
474 hypre_TFree(hypre_ParAMGDataAArray(amg_data));
475 /*hypre_TFree(hypre_ParAMGDataABlockArray(amg_data));
476 hypre_TFree(hypre_ParAMGDataPBlockArray(amg_data));*/
477 hypre_TFree(hypre_ParAMGDataPArray(amg_data));
478 hypre_TFree(hypre_ParAMGDataCFMarkerArray(amg_data));
479 if (hypre_ParAMGDataRtemp(amg_data))
480 hypre_ParVectorDestroy(hypre_ParAMGDataRtemp(amg_data));
481 if (hypre_ParAMGDataPtemp(amg_data))
482 hypre_ParVectorDestroy(hypre_ParAMGDataPtemp(amg_data));
483 if (hypre_ParAMGDataZtemp(amg_data))
484 hypre_ParVectorDestroy(hypre_ParAMGDataZtemp(amg_data));
485
486 if (hypre_ParAMGDataDofFuncArray(amg_data))
487 {
488 for (i=1; i < num_levels; i++)
489 hypre_TFree(hypre_ParAMGDataDofFuncArray(amg_data)[i]);
490 hypre_TFree(hypre_ParAMGDataDofFuncArray(amg_data));
491 hypre_ParAMGDataDofFuncArray(amg_data) = NULL;
492 }
493 if (hypre_ParAMGDataRestriction(amg_data))
494 {
495 hypre_TFree(hypre_ParAMGDataRArray(amg_data));
496 hypre_ParAMGDataRArray(amg_data) = NULL;
497 }
498 if (hypre_ParAMGDataDofPointArray(amg_data))
499 {
500 for (i=0; i < num_levels; i++)
501 hypre_TFree(hypre_ParAMGDataDofPointArray(amg_data)[i]);
502 hypre_TFree(hypre_ParAMGDataDofPointArray(amg_data));
503 hypre_ParAMGDataDofPointArray(amg_data) = NULL;
504 }
505 if (hypre_ParAMGDataPointDofMapArray(amg_data))
506 {
507 for (i=0; i < num_levels; i++)
508 hypre_TFree(hypre_ParAMGDataPointDofMapArray(amg_data)[i]);
509 hypre_TFree(hypre_ParAMGDataPointDofMapArray(amg_data));
510 hypre_ParAMGDataPointDofMapArray(amg_data) = NULL;
511 }
512
513 /*if (smooth_num_levels)
514 {
515 if (hypre_ParAMGDataSmoothType(amg_data) == 6)
516 {
517 for (i=0; i < smooth_num_levels; i++)
518 {
519 HYPRE_SchwarzDestroy(smoother[i]);
520 }
521 }
522 hypre_TFree (hypre_ParAMGDataSmoother(amg_data));
523 }*/
524 if ( hypre_ParAMGDataResidual(amg_data) ) {
525 /* jfp: was... hypre_TFree( hypre_ParAMGDataResidual(amg_data) );*/
526 hypre_ParVectorDestroy( hypre_ParAMGDataResidual(amg_data) );
527 hypre_ParAMGDataResidual(amg_data) = NULL;
528 }
529
530
531
532
533 hypre_TFree(amg_data);
534 return hypre_error_flag;
535}
536
537/*--------------------------------------------------------------------------
538 * Routines to set the setup phase parameters
539 *--------------------------------------------------------------------------*/
540
541int
542hypre_BoomerAMGSetRestriction( void *data,
543 int restr_par )
544{
545 hypre_ParAMGData *amg_data = data;
546
547 if (!amg_data)
548 {
549 printf("Warning! BoomerAMG object empty!\n");
550 hypre_error_in_arg(1);
551 return hypre_error_flag;
552 }
553
554 hypre_ParAMGDataRestriction(amg_data) = restr_par;
555
556 return hypre_error_flag;
557}
558
559int
560hypre_BoomerAMGSetMaxLevels( void *data,
561 int max_levels )
562{
563 hypre_ParAMGData *amg_data = data;
564
565 if (!amg_data)
566 {
567 printf("Warning! BoomerAMG object empty!\n");
568 hypre_error_in_arg(1);
569 return hypre_error_flag;
570 }
571
572 if (max_levels < 1)
573 {
574 hypre_error_in_arg(2);
575 return hypre_error_flag;
576 }
577
578 hypre_ParAMGDataMaxLevels(amg_data) = max_levels;
579
580 return hypre_error_flag;
581}
582
583int
584hypre_BoomerAMGGetMaxLevels( void *data,
585 int * max_levels )
586{
587 hypre_ParAMGData *amg_data = data;
588
589 if (!amg_data)
590 {
591 printf("Warning! BoomerAMG object empty!\n");
592 hypre_error_in_arg(1);
593 return hypre_error_flag;
594 }
595
596 *max_levels = hypre_ParAMGDataMaxLevels(amg_data);
597
598 return hypre_error_flag;
599}
600
601int
602hypre_BoomerAMGSetStrongThreshold( void *data,
603 double strong_threshold )
604{
605 hypre_ParAMGData *amg_data = data;
606
607 if (!amg_data)
608 {
609 printf("Warning! BoomerAMG object empty!\n");
610 hypre_error_in_arg(1);
611 return hypre_error_flag;
612 }
613
614 if (strong_threshold < 0 || strong_threshold > 1)
615 {
616 hypre_error_in_arg(2);
617 return hypre_error_flag;
618 }
619
620 hypre_ParAMGDataStrongThreshold(amg_data) = strong_threshold;
621
622 return hypre_error_flag;
623}
624
625int
626hypre_BoomerAMGGetStrongThreshold( void *data,
627 double * strong_threshold )
628{
629 hypre_ParAMGData *amg_data = data;
630
631 if (!amg_data)
632 {
633 printf("Warning! BoomerAMG object empty!\n");
634 hypre_error_in_arg(1);
635 return hypre_error_flag;
636 }
637
638 *strong_threshold = hypre_ParAMGDataStrongThreshold(amg_data);
639
640 return hypre_error_flag;
641}
642
643int
644hypre_BoomerAMGSetMaxRowSum( void *data,
645 double max_row_sum )
646{
647 hypre_ParAMGData *amg_data = data;
648
649 if (!amg_data)
650 {
651 printf("Warning! BoomerAMG object empty!\n");
652 hypre_error_in_arg(1);
653 return hypre_error_flag;
654 }
655
656 if (max_row_sum <= 0 || max_row_sum > 1)
657 {
658 hypre_error_in_arg(2);
659 return hypre_error_flag;
660 }
661
662 hypre_ParAMGDataMaxRowSum(amg_data) = max_row_sum;
663
664 return hypre_error_flag;
665}
666
667int
668hypre_BoomerAMGGetMaxRowSum( void *data,
669 double * max_row_sum )
670{
671 hypre_ParAMGData *amg_data = data;
672
673 if (!amg_data)
674 {
675 printf("Warning! BoomerAMG object empty!\n");
676 hypre_error_in_arg(1);
677 return hypre_error_flag;
678 }
679
680 *max_row_sum = hypre_ParAMGDataMaxRowSum(amg_data);
681
682 return hypre_error_flag;
683}
684
685int
686hypre_BoomerAMGSetTruncFactor( void *data,
687 double trunc_factor )
688{
689 hypre_ParAMGData *amg_data = data;
690
691 if (!amg_data)
692 {
693 printf("Warning! BoomerAMG object empty!\n");
694 hypre_error_in_arg(1);
695 return hypre_error_flag;
696 }
697
698 if (trunc_factor < 0 || trunc_factor >= 1)
699 {
700 hypre_error_in_arg(2);
701 return hypre_error_flag;
702 }
703
704 hypre_ParAMGDataTruncFactor(amg_data) = trunc_factor;
705
706 return hypre_error_flag;
707}
708
709int
710hypre_BoomerAMGSetAggTruncFactor( void *data,
711 double agg_trunc_factor )
712{
713 hypre_ParAMGData *amg_data = data;
714
715 if (!amg_data)
716 {
717 printf("Warning! BoomerAMG object empty!\n");
718 hypre_error_in_arg(1);
719 return hypre_error_flag;
720 }
721
722 if (agg_trunc_factor < 0 || agg_trunc_factor >= 1)
723 {
724 hypre_error_in_arg(2);
725 return hypre_error_flag;
726 }
727
728 hypre_ParAMGDataAggTruncFactor(amg_data) = agg_trunc_factor;
729
730 return hypre_error_flag;
731}
732
733int
734hypre_BoomerAMGGetTruncFactor( void *data,
735 double * trunc_factor )
736{
737 hypre_ParAMGData *amg_data = data;
738
739 if (!amg_data)
740 {
741 printf("Warning! BoomerAMG object empty!\n");
742 hypre_error_in_arg(1);
743 return hypre_error_flag;
744 }
745
746 *trunc_factor = hypre_ParAMGDataTruncFactor(amg_data);
747
748 return hypre_error_flag;
749}
750
751int
752hypre_BoomerAMGSetPMaxElmts( void *data,
753 int P_max_elmts )
754{
755 hypre_ParAMGData *amg_data = data;
756
757 if (!amg_data)
758 {
759 printf("Warning! BoomerAMG object empty!\n");
760 hypre_error_in_arg(1);
761 return hypre_error_flag;
762 }
763
764 if (P_max_elmts < 0)
765 {
766 hypre_error_in_arg(2);
767 return hypre_error_flag;
768 }
769
770 hypre_ParAMGDataPMaxElmts(amg_data) = P_max_elmts;
771
772 return hypre_error_flag;
773}
774
775int
776hypre_BoomerAMGSetPMax1( void *data,
777 int P_max1 )
778{
779 hypre_ParAMGData *amg_data = data;
780
781 if (!amg_data)
782 {
783 printf("Warning! BoomerAMG object empty!\n");
784 hypre_error_in_arg(1);
785 return hypre_error_flag;
786 }
787
788 if (P_max1 < 0)
789 {
790 hypre_error_in_arg(2);
791 return hypre_error_flag;
792 }
793
794 hypre_ParAMGDataPMax1(amg_data) = P_max1;
795
796 return hypre_error_flag;
797}
798
799int
800hypre_BoomerAMGSetPMax2( void *data,
801 int P_max2 )
802{
803 hypre_ParAMGData *amg_data = data;
804
805 if (!amg_data)
806 {
807 printf("Warning! BoomerAMG object empty!\n");
808 hypre_error_in_arg(2);
809 return hypre_error_flag;
810 }
811
812 if (P_max2 < 0)
813 {
814 hypre_error_in_arg(2);
815 return hypre_error_flag;
816 }
817
818 hypre_ParAMGDataPMax2(amg_data) = P_max2;
819
820 return hypre_error_flag;
821}
822
823int
824hypre_BoomerAMGSetAggPMaxElmts( void *data,
825 int agg_P_max_elmts )
826{
827 hypre_ParAMGData *amg_data = data;
828
829 if (!amg_data)
830 {
831 printf("Warning! BoomerAMG object empty!\n");
832 hypre_error_in_arg(1);
833 return hypre_error_flag;
834 }
835
836 if (agg_P_max_elmts < 0)
837 {
838 hypre_error_in_arg(2);
839 return hypre_error_flag;
840 }
841
842 hypre_ParAMGDataAggPMaxElmts(amg_data) = agg_P_max_elmts;
843
844 return hypre_error_flag;
845}
846
847int
848hypre_BoomerAMGGetPMaxElmts( void *data,
849 int * P_max_elmts )
850{
851 hypre_ParAMGData *amg_data = data;
852
853 if (!amg_data)
854 {
855 printf("Warning! BoomerAMG object empty!\n");
856 hypre_error_in_arg(1);
857 return hypre_error_flag;
858 }
859
860 *P_max_elmts = hypre_ParAMGDataPMaxElmts(amg_data);
861
862 return hypre_error_flag;
863}
864
865int
866hypre_BoomerAMGSetJacobiTruncThreshold( void *data,
867 double jacobi_trunc_threshold )
868{
869 hypre_ParAMGData *amg_data = data;
870
871 if (!amg_data)
872 {
873 printf("Warning! BoomerAMG object empty!\n");
874 hypre_error_in_arg(1);
875 return hypre_error_flag;
876 }
877
878 if (jacobi_trunc_threshold < 0 || jacobi_trunc_threshold >= 1)
879 {
880 hypre_error_in_arg(2);
881 return hypre_error_flag;
882 }
883
884 hypre_ParAMGDataJacobiTruncThreshold(amg_data) = jacobi_trunc_threshold;
885
886 return hypre_error_flag;
887}
888
889int
890hypre_BoomerAMGGetJacobiTruncThreshold( void *data,
891 double * jacobi_trunc_threshold )
892{
893 hypre_ParAMGData *amg_data = data;
894
895 if (!amg_data)
896 {
897 printf("Warning! BoomerAMG object empty!\n");
898 hypre_error_in_arg(1);
899 return hypre_error_flag;
900 }
901
902 *jacobi_trunc_threshold = hypre_ParAMGDataJacobiTruncThreshold(amg_data);
903
904 return hypre_error_flag;
905}
906
907int
908hypre_BoomerAMGSetPostInterpType( void *data,
909 int post_interp_type )
910{
911 hypre_ParAMGData *amg_data = data;
912
913 if (!amg_data)
914 {
915 printf("Warning! BoomerAMG object empty!\n");
916 hypre_error_in_arg(1);
917 return hypre_error_flag;
918 }
919
920 if (post_interp_type < 0)
921 {
922 hypre_error_in_arg(2);
923 return hypre_error_flag;
924 }
925
926 hypre_ParAMGDataPostInterpType(amg_data) = post_interp_type;
927
928 return hypre_error_flag;
929}
930
931int
932hypre_BoomerAMGGetPostInterpType( void *data,
933 int * post_interp_type )
934{
935 hypre_ParAMGData *amg_data = data;
936
937 if (!amg_data)
938 {
939 printf("Warning! BoomerAMG object empty!\n");
940 hypre_error_in_arg(1);
941 return hypre_error_flag;
942 }
943
944 *post_interp_type = hypre_ParAMGDataPostInterpType(amg_data);
945
946 return hypre_error_flag;
947}
948
949int
950hypre_BoomerAMGSetSCommPkgSwitch( void *data,
951 double S_commpkg_switch )
952{
953 hypre_ParAMGData *amg_data = data;
954
955 if (!amg_data)
956 {
957 printf("Warning! BoomerAMG object empty!\n");
958 hypre_error_in_arg(1);
959 return hypre_error_flag;
960 }
961
962 hypre_ParAMGDataSCommPkgSwitch(amg_data) = S_commpkg_switch;
963
964 return hypre_error_flag;
965}
966
967int
968hypre_BoomerAMGGetSCommPkgSwitch( void *data,
969 double * S_commpkg_switch )
970{
971 hypre_ParAMGData *amg_data = data;
972
973 if (!amg_data)
974 {
975 printf("Warning! BoomerAMG object empty!\n");
976 hypre_error_in_arg(1);
977 return hypre_error_flag;
978 }
979
980 *S_commpkg_switch = hypre_ParAMGDataSCommPkgSwitch(amg_data);
981
982 return hypre_error_flag;
983}
984
985int
986hypre_BoomerAMGSetInterpType( void *data,
987 int interp_type )
988{
989 hypre_ParAMGData *amg_data = data;
990
991 if (!amg_data)
992 {
993 printf("Warning! BoomerAMG object empty!\n");
994 hypre_error_in_arg(1);
995 return hypre_error_flag;
996 }
997
998 if (interp_type < 0 || interp_type > 35)
999 {
1000 hypre_error_in_arg(2);
1001 return hypre_error_flag;
1002 }
1003
1004 hypre_ParAMGDataInterpType(amg_data) = interp_type;
1005
1006 return hypre_error_flag;
1007}
1008
1009int
1010hypre_BoomerAMGSetAggInterpType( void *data,
1011 int agg_interp_type )
1012{
1013 hypre_ParAMGData *amg_data = data;
1014
1015 if (!amg_data)
1016 {
1017 printf("Warning! BoomerAMG object empty!\n");
1018 hypre_error_in_arg(1);
1019 return hypre_error_flag;
1020 }
1021
1022 if (agg_interp_type < 0 || agg_interp_type > 35)
1023 {
1024 hypre_error_in_arg(2);
1025 return hypre_error_flag;
1026 }
1027
1028 hypre_ParAMGDataAggInterpType(amg_data) = agg_interp_type;
1029
1030 return hypre_error_flag;
1031}
1032
1033int
1034hypre_BoomerAMGGetInterpType( void *data,
1035 int * interp_type )
1036{
1037 hypre_ParAMGData *amg_data = data;
1038
1039 if (!amg_data)
1040 {
1041 printf("Warning! BoomerAMG object empty!\n");
1042 hypre_error_in_arg(1);
1043 return hypre_error_flag;
1044 }
1045
1046 *interp_type = hypre_ParAMGDataInterpType(amg_data);
1047
1048 return hypre_error_flag;
1049}
1050
1051int
1052hypre_BoomerAMGSetMinIter( void *data,
1053 int min_iter )
1054{
1055 hypre_ParAMGData *amg_data = data;
1056
1057 if (!amg_data)
1058 {
1059 printf("Warning! BoomerAMG object empty!\n");
1060 hypre_error_in_arg(1);
1061 return hypre_error_flag;
1062 }
1063
1064 hypre_ParAMGDataMinIter(amg_data) = min_iter;
1065
1066 return hypre_error_flag;
1067}
1068
1069int
1070hypre_BoomerAMGGetMinIter( void *data,
1071 int * min_iter )
1072{
1073 hypre_ParAMGData *amg_data = data;
1074
1075 if (!amg_data)
1076 {
1077 printf("Warning! BoomerAMG object empty!\n");
1078 hypre_error_in_arg(1);
1079 return hypre_error_flag;
1080 }
1081
1082 *min_iter = hypre_ParAMGDataMinIter(amg_data);
1083
1084 return hypre_error_flag;
1085}
1086
1087int
1088hypre_BoomerAMGSetMaxIter( void *data,
1089 int max_iter )
1090{
1091 hypre_ParAMGData *amg_data = data;
1092
1093 if (!amg_data)
1094 {
1095 printf("Warning! BoomerAMG object empty!\n");
1096 hypre_error_in_arg(1);
1097 return hypre_error_flag;
1098 }
1099
1100 if (max_iter < 0)
1101 {
1102 hypre_error_in_arg(2);
1103 return hypre_error_flag;
1104 }
1105
1106 hypre_ParAMGDataMaxIter(amg_data) = max_iter;
1107
1108 return hypre_error_flag;
1109}
1110
1111int
1112hypre_BoomerAMGGetMaxIter( void *data,
1113 int * max_iter )
1114{
1115 hypre_ParAMGData *amg_data = data;
1116
1117 if (!amg_data)
1118 {
1119 printf("Warning! BoomerAMG object empty!\n");
1120 hypre_error_in_arg(1);
1121 return hypre_error_flag;
1122 }
1123
1124 *max_iter = hypre_ParAMGDataMaxIter(amg_data);
1125
1126 return hypre_error_flag;
1127}
1128
1129int
1130hypre_BoomerAMGSetCoarsenType( void *data,
1131 int coarsen_type )
1132{
1133 hypre_ParAMGData *amg_data = data;
1134
1135 if (!amg_data)
1136 {
1137 printf("Warning! BoomerAMG object empty!\n");
1138 hypre_error_in_arg(1);
1139 return hypre_error_flag;
1140 }
1141
1142 hypre_ParAMGDataCoarsenType(amg_data) = coarsen_type;
1143
1144 return hypre_error_flag;
1145}
1146
1147int
1148hypre_BoomerAMGGetCoarsenType( void *data,
1149 int * coarsen_type )
1150{
1151 hypre_ParAMGData *amg_data = data;
1152
1153 if (!amg_data)
1154 {
1155 printf("Warning! BoomerAMG object empty!\n");
1156 hypre_error_in_arg(1);
1157 return hypre_error_flag;
1158 }
1159
1160 *coarsen_type = hypre_ParAMGDataCoarsenType(amg_data);
1161
1162 return hypre_error_flag;
1163}
1164
1165int
1166hypre_BoomerAMGSetMeasureType( void *data,
1167 int measure_type )
1168{
1169 hypre_ParAMGData *amg_data = data;
1170
1171 if (!amg_data)
1172 {
1173 printf("Warning! BoomerAMG object empty!\n");
1174 hypre_error_in_arg(1);
1175 return hypre_error_flag;
1176 }
1177
1178 hypre_ParAMGDataMeasureType(amg_data) = measure_type;
1179
1180 return hypre_error_flag;
1181}
1182
1183int
1184hypre_BoomerAMGGetMeasureType( void *data,
1185 int * measure_type )
1186{
1187 hypre_ParAMGData *amg_data = data;
1188
1189 if (!amg_data)
1190 {
1191 printf("Warning! BoomerAMG object empty!\n");
1192 hypre_error_in_arg(1);
1193 return hypre_error_flag;
1194 }
1195
1196 *measure_type = hypre_ParAMGDataMeasureType(amg_data);
1197
1198 return hypre_error_flag;
1199}
1200
1201int
1202hypre_BoomerAMGSetSetupType( void *data,
1203 int setup_type )
1204{
1205 hypre_ParAMGData *amg_data = data;
1206
1207 if (!amg_data)
1208 {
1209 printf("Warning! BoomerAMG object empty!\n");
1210 hypre_error_in_arg(1);
1211 return hypre_error_flag;
1212 }
1213
1214 hypre_ParAMGDataSetupType(amg_data) = setup_type;
1215
1216 return hypre_error_flag;
1217}
1218
1219int
1220hypre_BoomerAMGGetSetupType( void *data,
1221 int * setup_type )
1222{
1223 hypre_ParAMGData *amg_data = data;
1224
1225 if (!amg_data)
1226 {
1227 printf("Warning! BoomerAMG object empty!\n");
1228 hypre_error_in_arg(1);
1229 return hypre_error_flag;
1230 }
1231
1232 *setup_type = hypre_ParAMGDataSetupType(amg_data);
1233
1234 return hypre_error_flag;
1235}
1236
1237int
1238hypre_BoomerAMGSetCycleType( void *data,
1239 int cycle_type )
1240{
1241 hypre_ParAMGData *amg_data = data;
1242
1243 if (!amg_data)
1244 {
1245 printf("Warning! BoomerAMG object empty!\n");
1246 hypre_error_in_arg(1);
1247 return hypre_error_flag;
1248 }
1249
1250 if (cycle_type < 0 || cycle_type > 2)
1251 {
1252 hypre_error_in_arg(2);
1253 return hypre_error_flag;
1254 }
1255
1256 hypre_ParAMGDataCycleType(amg_data) = cycle_type;
1257
1258 return hypre_error_flag;
1259}
1260
1261int
1262hypre_BoomerAMGGetCycleType( void *data,
1263 int * cycle_type )
1264{
1265 hypre_ParAMGData *amg_data = data;
1266
1267 if (!amg_data)
1268 {
1269 printf("Warning! BoomerAMG object empty!\n");
1270 hypre_error_in_arg(1);
1271 return hypre_error_flag;
1272 }
1273
1274 *cycle_type = hypre_ParAMGDataCycleType(amg_data);
1275
1276 return hypre_error_flag;
1277}
1278
1279int
1280hypre_BoomerAMGSetTol( void *data,
1281 double tol )
1282{
1283 hypre_ParAMGData *amg_data = data;
1284
1285 if (!amg_data)
1286 {
1287 printf("Warning! BoomerAMG object empty!\n");
1288 hypre_error_in_arg(1);
1289 return hypre_error_flag;
1290 }
1291
1292 if (tol < 0 || tol > 1)
1293 {
1294 hypre_error_in_arg(2);
1295 return hypre_error_flag;
1296 }
1297
1298 hypre_ParAMGDataTol(amg_data) = tol;
1299
1300 return hypre_error_flag;
1301}
1302
1303int
1304hypre_BoomerAMGGetTol( void *data,
1305 double * tol )
1306{
1307 hypre_ParAMGData *amg_data = data;
1308
1309 if (!amg_data)
1310 {
1311 printf("Warning! BoomerAMG object empty!\n");
1312 hypre_error_in_arg(1);
1313 return hypre_error_flag;
1314 }
1315
1316 *tol = hypre_ParAMGDataTol(amg_data);
1317
1318 return hypre_error_flag;
1319}
1320
1321/* The "Get" function for SetNumSweeps is GetCycleNumSweeps. */
1322int
1323hypre_BoomerAMGSetNumSweeps( void *data,
1324 int num_sweeps )
1325{
1326 int i;
1327 int *num_grid_sweeps;
1328 hypre_ParAMGData *amg_data = data;
1329
1330 if (!amg_data)
1331 {
1332 printf("Warning! BoomerAMG object empty!\n");
1333 hypre_error_in_arg(1);
1334 return hypre_error_flag;
1335 }
1336
1337 if (num_sweeps < 1)
1338 {
1339 hypre_error_in_arg(2);
1340 return hypre_error_flag;
1341 }
1342
1343 if (hypre_ParAMGDataNumGridSweeps(amg_data) == NULL)
1344 hypre_ParAMGDataNumGridSweeps(amg_data) = hypre_CTAlloc(int,4);
1345
1346 num_grid_sweeps = hypre_ParAMGDataNumGridSweeps(amg_data);
1347
1348 for (i=0; i < 3; i++)
1349 num_grid_sweeps[i] = num_sweeps;
1350 num_grid_sweeps[3] = 1;
1351
1352 return hypre_error_flag;
1353}
1354
1355int
1356hypre_BoomerAMGSetCycleNumSweeps( void *data,
1357 int num_sweeps,
1358 int k )
1359{
1360 int i;
1361 int *num_grid_sweeps;
1362 hypre_ParAMGData *amg_data = data;
1363
1364 if (!amg_data)
1365 {
1366 printf("Warning! BoomerAMG object empty!\n");
1367 hypre_error_in_arg(1);
1368 return hypre_error_flag;
1369 }
1370
1371 if (num_sweeps < 1)
1372 {
1373 hypre_error_in_arg(2);
1374 return hypre_error_flag;
1375 }
1376
1377 if (k < 1 || k > 3)
1378 {
1379 printf (" Warning! Invalid cycle! num_sweeps not set!\n");
1380 hypre_error_in_arg(3);
1381 return hypre_error_flag;
1382 }
1383
1384 if (hypre_ParAMGDataNumGridSweeps(amg_data) == NULL)
1385 {
1386 num_grid_sweeps = hypre_CTAlloc(int,4);
1387 for (i=0; i < 4; i++)
1388 num_grid_sweeps[i] = 1;
1389 hypre_ParAMGDataNumGridSweeps(amg_data) = num_grid_sweeps;
1390 }
1391
1392 hypre_ParAMGDataNumGridSweeps(amg_data)[k] = num_sweeps;
1393
1394 return hypre_error_flag;
1395}
1396
1397int
1398hypre_BoomerAMGGetCycleNumSweeps( void *data,
1399 int * num_sweeps,
1400 int k )
1401{
1402 hypre_ParAMGData *amg_data = data;
1403
1404 if (!amg_data)
1405 {
1406 printf("Warning! BoomerAMG object empty!\n");
1407 hypre_error_in_arg(1);
1408 return hypre_error_flag;
1409 }
1410 if (k < 1 || k > 3)
1411 {
1412 printf (" Warning! Invalid cycle! No num_sweeps to get!\n");
1413 hypre_error_in_arg(3);
1414 return hypre_error_flag;
1415 }
1416
1417 if (hypre_ParAMGDataNumGridSweeps(amg_data) == NULL)
1418 {
1419 hypre_error_in_arg(1);
1420 return hypre_error_flag;
1421 }
1422
1423 *num_sweeps = hypre_ParAMGDataNumGridSweeps(amg_data)[k];
1424
1425 return hypre_error_flag;
1426}
1427
1428int
1429hypre_BoomerAMGSetNumGridSweeps( void *data,
1430 int *num_grid_sweeps )
1431{
1432 hypre_ParAMGData *amg_data = data;
1433
1434 if (!amg_data)
1435 {
1436 printf("Warning! BoomerAMG object empty!\n");
1437 hypre_error_in_arg(1);
1438 return hypre_error_flag;
1439 }
1440 if (!num_grid_sweeps)
1441 {
1442 hypre_error_in_arg(2);
1443 return hypre_error_flag;
1444 }
1445
1446 if (hypre_ParAMGDataNumGridSweeps(amg_data))
1447 hypre_TFree(hypre_ParAMGDataNumGridSweeps(amg_data));
1448 hypre_ParAMGDataNumGridSweeps(amg_data) = num_grid_sweeps;
1449
1450 return hypre_error_flag;
1451}
1452
1453int
1454hypre_BoomerAMGGetNumGridSweeps( void *data,
1455 int ** num_grid_sweeps )
1456{
1457 hypre_ParAMGData *amg_data = data;
1458
1459 if (!amg_data)
1460 {
1461 printf("Warning! BoomerAMG object empty!\n");
1462 hypre_error_in_arg(1);
1463 return hypre_error_flag;
1464 }
1465 *num_grid_sweeps = hypre_ParAMGDataNumGridSweeps(amg_data);
1466
1467 return hypre_error_flag;
1468}
1469
1470/* The "Get" function for SetRelaxType is GetCycleRelaxType. */
1471int
1472hypre_BoomerAMGSetRelaxType( void *data,
1473 int relax_type )
1474{
1475 int i;
1476 int *grid_relax_type;
1477 hypre_ParAMGData *amg_data = data;
1478
1479 if (!amg_data)
1480 {
1481 printf("Warning! BoomerAMG object empty!\n");
1482 hypre_error_in_arg(1);
1483 return hypre_error_flag;
1484 }
1485 if (relax_type < 0)
1486 {
1487 hypre_error_in_arg(2);
1488 return hypre_error_flag;
1489 }
1490
1491 if (hypre_ParAMGDataGridRelaxType(amg_data) == NULL)
1492 hypre_ParAMGDataGridRelaxType(amg_data) = hypre_CTAlloc(int,4);
1493 grid_relax_type = hypre_ParAMGDataGridRelaxType(amg_data);
1494
1495 for (i=0; i < 3; i++)
1496 grid_relax_type[i] = relax_type;
1497 grid_relax_type[3] = 9;
1498 hypre_ParAMGDataUserCoarseRelaxType(amg_data) = 9;
1499
1500 return hypre_error_flag;
1501}
1502
1503int
1504hypre_BoomerAMGSetCycleRelaxType( void *data,
1505 int relax_type,
1506 int k )
1507{
1508 int i;
1509 int *grid_relax_type;
1510 hypre_ParAMGData *amg_data = data;
1511
1512 if (!amg_data)
1513 {
1514 printf("Warning! BoomerAMG object empty!\n");
1515 hypre_error_in_arg(1);
1516 return hypre_error_flag;
1517 }
1518 if (k < 1 || k > 3)
1519 {
1520 printf (" Warning! Invalid cycle! relax_type not set!\n");
1521 hypre_error_in_arg(3);
1522 return hypre_error_flag;
1523 }
1524 if (relax_type < 0)
1525 {
1526 hypre_error_in_arg(2);
1527 return hypre_error_flag;
1528 }
1529
1530 if (hypre_ParAMGDataGridRelaxType(amg_data) == NULL)
1531 {
1532 grid_relax_type = hypre_CTAlloc(int,4);
1533 for (i=0; i < 3; i++)
1534 grid_relax_type[i] = 3;
1535 grid_relax_type[3] = 9;
1536 hypre_ParAMGDataGridRelaxType(amg_data) = grid_relax_type;
1537 }
1538
1539 hypre_ParAMGDataGridRelaxType(amg_data)[k] = relax_type;
1540 if (k == 3)
1541 hypre_ParAMGDataUserCoarseRelaxType(amg_data) = relax_type;
1542
1543 return hypre_error_flag;
1544}
1545
1546int
1547hypre_BoomerAMGGetCycleRelaxType( void *data,
1548 int * relax_type,
1549 int k )
1550{
1551 hypre_ParAMGData *amg_data = data;
1552
1553 if (!amg_data)
1554 {
1555 printf("Warning! BoomerAMG object empty!\n");
1556 hypre_error_in_arg(1);
1557 return hypre_error_flag;
1558 }
1559 if (k < 1 || k > 3)
1560 {
1561 printf (" Warning! Invalid cycle! relax_type not set!\n");
1562 hypre_error_in_arg(3);
1563 return hypre_error_flag;
1564 }
1565
1566 if (hypre_ParAMGDataGridRelaxType(amg_data) == NULL)
1567 {
1568 hypre_error_in_arg(1);
1569 return hypre_error_flag;
1570 }
1571
1572 *relax_type = hypre_ParAMGDataGridRelaxType(amg_data)[k];
1573
1574 return hypre_error_flag;
1575}
1576
1577int
1578hypre_BoomerAMGSetRelaxOrder( void *data,
1579 int relax_order)
1580{
1581 hypre_ParAMGData *amg_data = data;
1582
1583 if (!amg_data)
1584 {
1585 printf("Warning! BoomerAMG object empty!\n");
1586 hypre_error_in_arg(1);
1587 return hypre_error_flag;
1588 }
1589 hypre_ParAMGDataRelaxOrder(amg_data) = relax_order;
1590
1591 return hypre_error_flag;
1592}
1593
1594int
1595hypre_BoomerAMGGetRelaxOrder( void *data,
1596 int * relax_order)
1597{
1598 hypre_ParAMGData *amg_data = data;
1599
1600 if (!amg_data)
1601 {
1602 printf("Warning! BoomerAMG object empty!\n");
1603 hypre_error_in_arg(1);
1604 return hypre_error_flag;
1605 }
1606 *relax_order = hypre_ParAMGDataRelaxOrder(amg_data);
1607
1608 return hypre_error_flag;
1609}
1610
1611int
1612hypre_BoomerAMGSetGridRelaxType( void *data,
1613 int *grid_relax_type )
1614{
1615 hypre_ParAMGData *amg_data = data;
1616
1617 if (!amg_data)
1618 {
1619 printf("Warning! BoomerAMG object empty!\n");
1620 hypre_error_in_arg(1);
1621 return hypre_error_flag;
1622 }
1623 if (!grid_relax_type)
1624 {
1625 hypre_error_in_arg(2);
1626 return hypre_error_flag;
1627 }
1628
1629 if (hypre_ParAMGDataGridRelaxType(amg_data))
1630 hypre_TFree(hypre_ParAMGDataGridRelaxType(amg_data));
1631 hypre_ParAMGDataGridRelaxType(amg_data) = grid_relax_type;
1632 hypre_ParAMGDataUserCoarseRelaxType(amg_data) = grid_relax_type[3];
1633
1634 return hypre_error_flag;
1635}
1636
1637int
1638hypre_BoomerAMGGetGridRelaxType( void *data,
1639 int ** grid_relax_type )
1640{
1641 hypre_ParAMGData *amg_data = data;
1642
1643 if (!amg_data)
1644 {
1645 printf("Warning! BoomerAMG object empty!\n");
1646 hypre_error_in_arg(1);
1647 return hypre_error_flag;
1648 }
1649 *grid_relax_type = hypre_ParAMGDataGridRelaxType(amg_data);
1650
1651 return hypre_error_flag;
1652}
1653
1654int
1655hypre_BoomerAMGSetGridRelaxPoints( void *data,
1656 int **grid_relax_points )
1657{
1658 int i;
1659 hypre_ParAMGData *amg_data = data;
1660
1661 if (!amg_data)
1662 {
1663 printf("Warning! BoomerAMG object empty!\n");
1664 hypre_error_in_arg(1);
1665 return hypre_error_flag;
1666 }
1667 if (!grid_relax_points)
1668 {
1669 hypre_error_in_arg(2);
1670 return hypre_error_flag;
1671 }
1672
1673 if (hypre_ParAMGDataGridRelaxPoints(amg_data))
1674 {
1675 for (i=0; i < 4; i++)
1676 hypre_TFree (hypre_ParAMGDataGridRelaxPoints(amg_data)[i]);
1677 hypre_TFree(hypre_ParAMGDataGridRelaxPoints(amg_data));
1678 }
1679 hypre_ParAMGDataGridRelaxPoints(amg_data) = grid_relax_points;
1680
1681 return hypre_error_flag;
1682}
1683
1684int
1685hypre_BoomerAMGGetGridRelaxPoints( void *data,
1686 int *** grid_relax_points )
1687{
1688 hypre_ParAMGData *amg_data = data;
1689
1690 if (!amg_data)
1691 {
1692 printf("Warning! BoomerAMG object empty!\n");
1693 hypre_error_in_arg(1);
1694 return hypre_error_flag;
1695 }
1696 *grid_relax_points = hypre_ParAMGDataGridRelaxPoints(amg_data);
1697
1698 return hypre_error_flag;
1699}
1700
1701int
1702hypre_BoomerAMGSetRelaxWeight( void *data,
1703 double *relax_weight )
1704{
1705 hypre_ParAMGData *amg_data = data;
1706
1707 if (!amg_data)
1708 {
1709 printf("Warning! BoomerAMG object empty!\n");
1710 hypre_error_in_arg(1);
1711 return hypre_error_flag;
1712 }
1713 if (!relax_weight)
1714 {
1715 hypre_error_in_arg(2);
1716 return hypre_error_flag;
1717 }
1718
1719 if (hypre_ParAMGDataRelaxWeight(amg_data))
1720 hypre_TFree(hypre_ParAMGDataRelaxWeight(amg_data));
1721 hypre_ParAMGDataRelaxWeight(amg_data) = relax_weight;
1722
1723 return hypre_error_flag;
1724}
1725
1726int
1727hypre_BoomerAMGGetRelaxWeight( void *data,
1728 double ** relax_weight )
1729{
1730 hypre_ParAMGData *amg_data = data;
1731
1732 if (!amg_data)
1733 {
1734 printf("Warning! BoomerAMG object empty!\n");
1735 hypre_error_in_arg(1);
1736 return hypre_error_flag;
1737 }
1738 *relax_weight = hypre_ParAMGDataRelaxWeight(amg_data);
1739
1740 return hypre_error_flag;
1741}
1742
1743int
1744hypre_BoomerAMGSetRelaxWt( void *data,
1745 double relax_weight )
1746{
1747 int i, num_levels;
1748 double *relax_weight_array;
1749 hypre_ParAMGData *amg_data = data;
1750
1751 if (!amg_data)
1752 {
1753 printf("Warning! BoomerAMG object empty!\n");
1754 hypre_error_in_arg(1);
1755 return hypre_error_flag;
1756 }
1757 num_levels = hypre_ParAMGDataMaxLevels(amg_data);
1758 if (hypre_ParAMGDataRelaxWeight(amg_data) == NULL)
1759 hypre_ParAMGDataRelaxWeight(amg_data) = hypre_CTAlloc(double,num_levels);
1760
1761 relax_weight_array = hypre_ParAMGDataRelaxWeight(amg_data);
1762 for (i=0; i < num_levels; i++)
1763 relax_weight_array[i] = relax_weight;
1764
1765 return hypre_error_flag;
1766}
1767
1768int
1769hypre_BoomerAMGSetLevelRelaxWt( void *data,
1770 double relax_weight,
1771 int level )
1772{
1773 int i, num_levels;
1774 hypre_ParAMGData *amg_data = data;
1775 num_levels = hypre_ParAMGDataMaxLevels(amg_data);
1776 if (!amg_data)
1777 {
1778 printf("Warning! BoomerAMG object empty!\n");
1779 hypre_error_in_arg(1);
1780 return hypre_error_flag;
1781 }
1782 if (level > num_levels-1 || level < 0)
1783 {
1784 printf (" Warning! Invalid level! Relax weight not set!\n");
1785 hypre_error_in_arg(3);
1786 return hypre_error_flag;
1787 }
1788 if (hypre_ParAMGDataRelaxWeight(amg_data) == NULL)
1789 {
1790 hypre_ParAMGDataRelaxWeight(amg_data) = hypre_CTAlloc(double,num_levels);
1791 for (i=0; i < num_levels; i++)
1792 hypre_ParAMGDataRelaxWeight(amg_data)[i] = 1.0;
1793 }
1794
1795 hypre_ParAMGDataRelaxWeight(amg_data)[level] = relax_weight;
1796
1797 return hypre_error_flag;
1798}
1799
1800int
1801hypre_BoomerAMGGetLevelRelaxWt( void *data,
1802 double * relax_weight,
1803 int level )
1804{
1805 int num_levels;
1806 hypre_ParAMGData *amg_data = data;
1807 if (!amg_data)
1808 {
1809 printf("Warning! BoomerAMG object empty!\n");
1810 hypre_error_in_arg(1);
1811 return hypre_error_flag;
1812 }
1813 num_levels = hypre_ParAMGDataMaxLevels(amg_data);
1814 if (level > num_levels-1 || level < 0)
1815 {
1816 printf (" Warning! Invalid level! Relax weight not set!\n");
1817 hypre_error_in_arg(3);
1818 return hypre_error_flag;
1819 }
1820 if (hypre_ParAMGDataRelaxWeight(amg_data) == NULL)
1821 {
1822 hypre_error_in_arg(1);
1823 return hypre_error_flag;
1824 }
1825
1826 *relax_weight = hypre_ParAMGDataRelaxWeight(amg_data)[level];
1827
1828 return hypre_error_flag;
1829}
1830
1831int
1832hypre_BoomerAMGSetOmega( void *data,
1833 double *omega )
1834{
1835 hypre_ParAMGData *amg_data = data;
1836
1837 if (!amg_data)
1838 {
1839 printf("Warning! BoomerAMG object empty!\n");
1840 hypre_error_in_arg(1);
1841 return hypre_error_flag;
1842 }
1843 if (!omega)
1844 {
1845 hypre_error_in_arg(2);
1846 return hypre_error_flag;
1847 }
1848 if (hypre_ParAMGDataOmega(amg_data))
1849 hypre_TFree(hypre_ParAMGDataOmega(amg_data));
1850 hypre_ParAMGDataOmega(amg_data) = omega;
1851
1852 return hypre_error_flag;
1853}
1854
1855int
1856hypre_BoomerAMGGetOmega( void *data,
1857 double ** omega )
1858{
1859 hypre_ParAMGData *amg_data = data;
1860
1861 if (!amg_data)
1862 {
1863 printf("Warning! BoomerAMG object empty!\n");
1864 hypre_error_in_arg(1);
1865 return hypre_error_flag;
1866 }
1867 *omega = hypre_ParAMGDataOmega(amg_data);
1868
1869 return hypre_error_flag;
1870}
1871
1872int
1873hypre_BoomerAMGSetOuterWt( void *data,
1874 double omega )
1875{
1876 int i, num_levels;
1877 double *omega_array;
1878 hypre_ParAMGData *amg_data = data;
1879
1880 if (!amg_data)
1881 {
1882 printf("Warning! BoomerAMG object empty!\n");
1883 hypre_error_in_arg(1);
1884 return hypre_error_flag;
1885 }
1886 num_levels = hypre_ParAMGDataMaxLevels(amg_data);
1887 if (hypre_ParAMGDataOmega(amg_data) == NULL)
1888 hypre_ParAMGDataOmega(amg_data) = hypre_CTAlloc(double,num_levels);
1889
1890 omega_array = hypre_ParAMGDataOmega(amg_data);
1891 for (i=0; i < num_levels; i++)
1892 omega_array[i] = omega;
1893
1894 return hypre_error_flag;
1895}
1896
1897int
1898hypre_BoomerAMGSetLevelOuterWt( void *data,
1899 double omega,
1900 int level )
1901{
1902 int i, num_levels;
1903 hypre_ParAMGData *amg_data = data;
1904 if (!amg_data)
1905 {
1906 printf("Warning! BoomerAMG object empty!\n");
1907 hypre_error_in_arg(1);
1908 return hypre_error_flag;
1909 }
1910 num_levels = hypre_ParAMGDataMaxLevels(amg_data);
1911 if (level > num_levels-1)
1912 {
1913 printf (" Warning! Invalid level! Outer weight not set!\n");
1914 hypre_error_in_arg(3);
1915 return hypre_error_flag;
1916 }
1917 if (hypre_ParAMGDataOmega(amg_data) == NULL)
1918 {
1919 hypre_ParAMGDataOmega(amg_data) = hypre_CTAlloc(double,num_levels);
1920 for (i=0; i < num_levels; i++)
1921 hypre_ParAMGDataOmega(amg_data)[i] = 1.0;
1922 }
1923
1924 hypre_ParAMGDataOmega(amg_data)[level] = omega;
1925
1926 return hypre_error_flag;
1927}
1928
1929int
1930hypre_BoomerAMGGetLevelOuterWt( void *data,
1931 double * omega,
1932 int level )
1933{
1934 int num_levels;
1935 hypre_ParAMGData *amg_data = data;
1936 if (!amg_data)
1937 {
1938 printf("Warning! BoomerAMG object empty!\n");
1939 hypre_error_in_arg(1);
1940 return hypre_error_flag;
1941 }
1942 num_levels = hypre_ParAMGDataMaxLevels(amg_data);
1943 if (level > num_levels-1)
1944 {
1945 printf (" Warning! Invalid level! Outer weight not set!\n");
1946 hypre_error_in_arg(3);
1947 return hypre_error_flag;
1948 }
1949 if (hypre_ParAMGDataOmega(amg_data) == NULL)
1950 {
1951 hypre_error_in_arg(1);
1952 return hypre_error_flag;
1953 }
1954
1955 *omega = hypre_ParAMGDataOmega(amg_data)[level];
1956
1957 return hypre_error_flag;
1958}
1959
1960int
1961hypre_BoomerAMGSetSmoothType( void *data,
1962 int smooth_type )
1963{
1964 hypre_ParAMGData *amg_data = data;
1965 if (!amg_data)
1966 {
1967 printf("Warning! BoomerAMG object empty!\n");
1968 hypre_error_in_arg(1);
1969 return hypre_error_flag;
1970 }
1971
1972 hypre_ParAMGDataSmoothType(amg_data) = smooth_type;
1973
1974 return hypre_error_flag;
1975}
1976
1977int
1978hypre_BoomerAMGGetSmoothType( void *data,
1979 int * smooth_type )
1980{
1981 hypre_ParAMGData *amg_data = data;
1982
1983 if (!amg_data)
1984 {
1985 printf("Warning! BoomerAMG object empty!\n");
1986 hypre_error_in_arg(1);
1987 return hypre_error_flag;
1988 }
1989 *smooth_type = hypre_ParAMGDataSmoothType(amg_data);
1990
1991 return hypre_error_flag;
1992}
1993
1994int
1995hypre_BoomerAMGSetSmoothNumLevels( void *data,
1996 int smooth_num_levels )
1997{
1998 hypre_ParAMGData *amg_data = data;
1999
2000 if (!amg_data)
2001 {
2002 printf("Warning! BoomerAMG object empty!\n");
2003 hypre_error_in_arg(1);
2004 return hypre_error_flag;
2005 }
2006 if (smooth_num_levels < 0)
2007 {
2008 hypre_error_in_arg(2);
2009 return hypre_error_flag;
2010 }
2011 hypre_ParAMGDataSmoothNumLevels(amg_data) = smooth_num_levels;
2012
2013 return hypre_error_flag;
2014}
2015
2016int
2017hypre_BoomerAMGGetSmoothNumLevels( void *data,
2018 int * smooth_num_levels )
2019{
2020 hypre_ParAMGData *amg_data = data;
2021
2022 if (!amg_data)
2023 {
2024 printf("Warning! BoomerAMG object empty!\n");
2025 hypre_error_in_arg(1);
2026 return hypre_error_flag;
2027 }
2028 *smooth_num_levels = hypre_ParAMGDataSmoothNumLevels(amg_data);
2029
2030 return hypre_error_flag;
2031}
2032
2033int
2034hypre_BoomerAMGSetSmoothNumSweeps( void *data,
2035 int smooth_num_sweeps )
2036{
2037 hypre_ParAMGData *amg_data = data;
2038
2039 if (!amg_data)
2040 {
2041 printf("Warning! BoomerAMG object empty!\n");
2042 hypre_error_in_arg(1);
2043 return hypre_error_flag;
2044 }
2045 if (smooth_num_sweeps < 0)
2046 {
2047 hypre_error_in_arg(2);
2048 return hypre_error_flag;
2049 }
2050 hypre_ParAMGDataSmoothNumSweeps(amg_data) = smooth_num_sweeps;
2051
2052 return hypre_error_flag;
2053}
2054
2055int
2056hypre_BoomerAMGGetSmoothNumSweeps( void *data,
2057 int * smooth_num_sweeps )
2058{
2059 hypre_ParAMGData *amg_data = data;
2060
2061 if (!amg_data)
2062 {
2063 printf("Warning! BoomerAMG object empty!\n");
2064 hypre_error_in_arg(1);
2065 return hypre_error_flag;
2066 }
2067 *smooth_num_sweeps = hypre_ParAMGDataSmoothNumSweeps(amg_data);
2068
2069 return hypre_error_flag;
2070}
2071
2072int
2073hypre_BoomerAMGSetLogging( void *data,
2074 int logging )
2075{
2076 /* This function should be called before Setup. Logging changes
2077 may require allocation or freeing of arrays, which is presently
2078 only done there.
2079 It may be possible to support logging changes at other times,
2080 but there is little need.
2081 */
2082 hypre_ParAMGData *amg_data = data;
2083
2084 if (!amg_data)
2085 {
2086 printf("Warning! BoomerAMG object empty!\n");
2087 hypre_error_in_arg(1);
2088 return hypre_error_flag;
2089 }
2090 hypre_ParAMGDataLogging(amg_data) = logging;
2091
2092 return hypre_error_flag;
2093}
2094
2095int
2096hypre_BoomerAMGGetLogging( void *data,
2097 int * logging )
2098{
2099 hypre_ParAMGData *amg_data = data;
2100
2101 if (!amg_data)
2102 {
2103 printf("Warning! BoomerAMG object empty!\n");
2104 hypre_error_in_arg(1);
2105 return hypre_error_flag;
2106 }
2107 *logging = hypre_ParAMGDataLogging(amg_data);
2108
2109 return hypre_error_flag;
2110}
2111
2112int
2113hypre_BoomerAMGSetPrintLevel( void *data,
2114 int print_level )
2115{
2116 hypre_ParAMGData *amg_data = data;
2117
2118 if (!amg_data)
2119 {
2120 printf("Warning! BoomerAMG object empty!\n");
2121 hypre_error_in_arg(1);
2122 return hypre_error_flag;
2123 }
2124 hypre_ParAMGDataPrintLevel(amg_data) = print_level;
2125
2126 return hypre_error_flag;
2127}
2128
2129int
2130hypre_BoomerAMGGetPrintLevel( void *data,
2131 int * print_level )
2132{
2133 hypre_ParAMGData *amg_data = data;
2134
2135 if (!amg_data)
2136 {
2137 printf("Warning! BoomerAMG object empty!\n");
2138 hypre_error_in_arg(1);
2139 return hypre_error_flag;
2140 }
2141 *print_level = hypre_ParAMGDataPrintLevel(amg_data);
2142
2143 return hypre_error_flag;
2144}
2145
2146int
2147hypre_BoomerAMGSetPrintFileName( void *data,
2148 const char *print_file_name )
2149{
2150 hypre_ParAMGData *amg_data = data;
2151 if (!amg_data)
2152 {
2153 printf("Warning! BoomerAMG object empty!\n");
2154 hypre_error_in_arg(1);
2155 return hypre_error_flag;
2156 }
2157 if( strlen(print_file_name) > 256 )
2158 {
2159 hypre_error_in_arg(2);
2160 return hypre_error_flag;
2161 }
2162
2163 sprintf(hypre_ParAMGDataLogFileName(amg_data), "%s", print_file_name);
2164
2165 return hypre_error_flag;
2166}
2167
2168int
2169hypre_BoomerAMGGetPrintFileName( void *data,
2170 char ** print_file_name )
2171{
2172 hypre_ParAMGData *amg_data = data;
2173
2174 if (!amg_data)
2175 {
2176 printf("Warning! BoomerAMG object empty!\n");
2177 hypre_error_in_arg(1);
2178 return hypre_error_flag;
2179 }
2180 sprintf( *print_file_name, "%s", hypre_ParAMGDataLogFileName(amg_data) );
2181
2182 return hypre_error_flag;
2183}
2184
2185int
2186hypre_BoomerAMGSetNumIterations( void *data,
2187 int num_iterations )
2188{
2189 hypre_ParAMGData *amg_data = data;
2190
2191 if (!amg_data)
2192 {
2193 printf("Warning! BoomerAMG object empty!\n");
2194 hypre_error_in_arg(1);
2195 return hypre_error_flag;
2196 }
2197 hypre_ParAMGDataNumIterations(amg_data) = num_iterations;
2198
2199 return hypre_error_flag;
2200}
2201
2202int
2203hypre_BoomerAMGSetDebugFlag( void *data,
2204 int debug_flag )
2205{
2206 hypre_ParAMGData *amg_data = data;
2207
2208 if (!amg_data)
2209 {
2210 printf("Warning! BoomerAMG object empty!\n");
2211 hypre_error_in_arg(1);
2212 return hypre_error_flag;
2213 }
2214 hypre_ParAMGDataDebugFlag(amg_data) = debug_flag;
2215
2216 return hypre_error_flag;
2217}
2218
2219int
2220hypre_BoomerAMGGetDebugFlag( void *data,
2221 int * debug_flag )
2222{
2223 hypre_ParAMGData *amg_data = data;
2224
2225 if (!amg_data)
2226 {
2227 printf("Warning! BoomerAMG object empty!\n");
2228 hypre_error_in_arg(1);
2229 return hypre_error_flag;
2230 }
2231 *debug_flag = hypre_ParAMGDataDebugFlag(amg_data);
2232
2233 return hypre_error_flag;
2234}
2235
2236/*--------------------------------------------------------------------------
2237 * hypre_BoomerAMGSetGSMG
2238 *--------------------------------------------------------------------------*/
2239
2240int
2241hypre_BoomerAMGSetGSMG( void *data,
2242 int par )
2243{
2244 hypre_ParAMGData *amg_data = data;
2245
2246 if (!amg_data)
2247 {
2248 printf("Warning! BoomerAMG object empty!\n");
2249 hypre_error_in_arg(1);
2250 return hypre_error_flag;
2251 }
2252 amg_data->gsmg = par;
2253
2254 return hypre_error_flag;
2255}
2256
2257/*--------------------------------------------------------------------------
2258 * hypre_BoomerAMGSetNumSamples
2259 *--------------------------------------------------------------------------*/
2260
2261int
2262hypre_BoomerAMGSetNumSamples( void *data,
2263 int par )
2264{
2265 hypre_ParAMGData *amg_data = data;
2266
2267 if (!amg_data)
2268 {
2269 printf("Warning! BoomerAMG object empty!\n");
2270 hypre_error_in_arg(1);
2271 return hypre_error_flag;
2272 }
2273 amg_data->num_samples = par;
2274
2275 return hypre_error_flag;
2276}
2277
2278/*--------------------------------------------------------------------------
2279 * Routines to set the problem data parameters
2280 *--------------------------------------------------------------------------*/
2281
2282int
2283hypre_BoomerAMGSetNumFunctions( void *data,
2284 int num_functions )
2285{
2286 hypre_ParAMGData *amg_data = data;
2287
2288 if (!amg_data)
2289 {
2290 printf("Warning! BoomerAMG object empty!\n");
2291 hypre_error_in_arg(1);
2292 return hypre_error_flag;
2293 }
2294 if (num_functions < 1)
2295 {
2296 hypre_error_in_arg(2);
2297 return hypre_error_flag;
2298 }
2299 hypre_ParAMGDataNumFunctions(amg_data) = num_functions;
2300
2301 return hypre_error_flag;
2302}
2303
2304int
2305hypre_BoomerAMGGetNumFunctions( void *data,
2306 int * num_functions )
2307{
2308 hypre_ParAMGData *amg_data = data;
2309
2310 if (!amg_data)
2311 {
2312 printf("Warning! BoomerAMG object empty!\n");
2313 hypre_error_in_arg(1);
2314 return hypre_error_flag;
2315 }
2316 *num_functions = hypre_ParAMGDataNumFunctions(amg_data);
2317
2318 return hypre_error_flag;
2319}
2320
2321/*--------------------------------------------------------------------------
2322 * Indicate whether to use nodal systems function
2323 *--------------------------------------------------------------------------*/
2324
2325int
2326hypre_BoomerAMGSetNodal( void *data,
2327 int nodal )
2328{
2329 hypre_ParAMGData *amg_data = data;
2330
2331 if (!amg_data)
2332 {
2333 printf("Warning! BoomerAMG object empty!\n");
2334 hypre_error_in_arg(1);
2335 return hypre_error_flag;
2336 }
2337 hypre_ParAMGDataNodal(amg_data) = nodal;
2338
2339 return hypre_error_flag;
2340}
2341
2342/*--------------------------------------------------------------------------
2343 * Indicate the degree of aggressive coarsening
2344 *--------------------------------------------------------------------------*/
2345
2346int
2347hypre_BoomerAMGSetNumPaths( void *data,
2348 int num_paths )
2349{
2350 hypre_ParAMGData *amg_data = data;
2351
2352 if (!amg_data)
2353 {
2354 printf("Warning! BoomerAMG object empty!\n");
2355 hypre_error_in_arg(1);
2356 return hypre_error_flag;
2357 }
2358 if (num_paths < 1)
2359 {
2360 hypre_error_in_arg(2);
2361 return hypre_error_flag;
2362 }
2363 hypre_ParAMGDataNumPaths(amg_data) = num_paths;
2364
2365 return hypre_error_flag;
2366}
2367
2368/*--------------------------------------------------------------------------
2369 * Indicates the number of levels of aggressive coarsening
2370 *--------------------------------------------------------------------------*/
2371
2372int
2373hypre_BoomerAMGSetAggNumLevels( void *data,
2374 int agg_num_levels )
2375{
2376 hypre_ParAMGData *amg_data = data;
2377
2378 if (!amg_data)
2379 {
2380 printf("Warning! BoomerAMG object empty!\n");
2381 hypre_error_in_arg(1);
2382 return hypre_error_flag;
2383 }
2384 if (agg_num_levels < 0)
2385 {
2386 hypre_error_in_arg(2);
2387 return hypre_error_flag;
2388 }
2389 hypre_ParAMGDataAggNumLevels(amg_data) = agg_num_levels;
2390
2391 return hypre_error_flag;
2392}
2393
2394/*--------------------------------------------------------------------------
2395 * Indicates the number of relaxation steps for Compatible relaxation
2396 *--------------------------------------------------------------------------*/
2397
2398int
2399hypre_BoomerAMGSetNumCRRelaxSteps( void *data,
2400 int num_CR_relax_steps )
2401{
2402 hypre_ParAMGData *amg_data = data;
2403
2404 if (!amg_data)
2405 {
2406 printf("Warning! BoomerAMG object empty!\n");
2407 hypre_error_in_arg(1);
2408 return hypre_error_flag;
2409 }
2410 if (num_CR_relax_steps < 1)
2411 {
2412 hypre_error_in_arg(2);
2413 return hypre_error_flag;
2414 }
2415 hypre_ParAMGDataNumCRRelaxSteps(amg_data) = num_CR_relax_steps;
2416
2417 return hypre_error_flag;
2418}
2419
2420/*--------------------------------------------------------------------------
2421 * Indicates the desired convergence rate for Compatible relaxation
2422 *--------------------------------------------------------------------------*/
2423
2424int
2425hypre_BoomerAMGSetCRRate( void *data,
2426 double CR_rate )
2427{
2428 hypre_ParAMGData *amg_data = data;
2429
2430 if (!amg_data)
2431 {
2432 printf("Warning! BoomerAMG object empty!\n");
2433 hypre_error_in_arg(1);
2434 return hypre_error_flag;
2435 }
2436 hypre_ParAMGDataCRRate(amg_data) = CR_rate;
2437
2438 return hypre_error_flag;
2439}
2440
2441/*--------------------------------------------------------------------------
2442 * Indicates which independent set algorithm is used for CR
2443 *--------------------------------------------------------------------------*/
2444
2445int
2446hypre_BoomerAMGSetISType( void *data,
2447 int IS_type )
2448{
2449 hypre_ParAMGData *amg_data = data;
2450
2451 if (!amg_data)
2452 {
2453 printf("Warning! BoomerAMG object empty!\n");
2454 hypre_error_in_arg(1);
2455 return hypre_error_flag;
2456 }
2457 if (IS_type < 0)
2458 {
2459 hypre_error_in_arg(2);
2460 return hypre_error_flag;
2461 }
2462 hypre_ParAMGDataISType(amg_data) = IS_type;
2463
2464 return hypre_error_flag;
2465}
2466
2467/*--------------------------------------------------------------------------
2468 * Indicates whether to use CG for compatible relaxation
2469 *--------------------------------------------------------------------------*/
2470
2471int
2472hypre_BoomerAMGSetCRUseCG( void *data,
2473 int CR_use_CG )
2474{
2475 hypre_ParAMGData *amg_data = data;
2476
2477 if (!amg_data)
2478 {
2479 printf("Warning! BoomerAMG object empty!\n");
2480 hypre_error_in_arg(1);
2481 return hypre_error_flag;
2482 }
2483 hypre_ParAMGDataCRUseCG(amg_data) = CR_use_CG;
2484
2485 return hypre_error_flag;
2486}
2487
2488int
2489hypre_BoomerAMGSetNumPoints( void *data,
2490 int num_points )
2491{
2492 hypre_ParAMGData *amg_data = data;
2493
2494 if (!amg_data)
2495 {
2496 printf("Warning! BoomerAMG object empty!\n");
2497 hypre_error_in_arg(1);
2498 return hypre_error_flag;
2499 }
2500 hypre_ParAMGDataNumPoints(amg_data) = num_points;
2501
2502 return hypre_error_flag;
2503}
2504
2505int
2506hypre_BoomerAMGSetDofFunc( void *data,
2507 int *dof_func )
2508{
2509 hypre_ParAMGData *amg_data = data;
2510
2511 if (!amg_data)
2512 {
2513 printf("Warning! BoomerAMG object empty!\n");
2514 hypre_error_in_arg(1);
2515 return hypre_error_flag;
2516 }
2517 if (!dof_func)
2518 {
2519 hypre_error_in_arg(2);
2520 return hypre_error_flag;
2521 }
2522 hypre_TFree(hypre_ParAMGDataDofFunc(amg_data));
2523 hypre_ParAMGDataDofFunc(amg_data) = dof_func;
2524
2525 return hypre_error_flag;
2526}
2527
2528int
2529hypre_BoomerAMGSetPointDofMap( void *data,
2530 int *point_dof_map )
2531{
2532 hypre_ParAMGData *amg_data = data;
2533
2534 if (!amg_data)
2535 {
2536 printf("Warning! BoomerAMG object empty!\n");
2537 hypre_error_in_arg(1);
2538 return hypre_error_flag;
2539 }
2540 hypre_TFree(hypre_ParAMGDataPointDofMap(amg_data));
2541 hypre_ParAMGDataPointDofMap(amg_data) = point_dof_map;
2542
2543 return hypre_error_flag;
2544}
2545
2546int
2547hypre_BoomerAMGSetDofPoint( void *data,
2548 int *dof_point )
2549{
2550 hypre_ParAMGData *amg_data = data;
2551
2552 if (!amg_data)
2553 {
2554 printf("Warning! BoomerAMG object empty!\n");
2555 hypre_error_in_arg(1);
2556 return hypre_error_flag;
2557 }
2558 hypre_TFree(hypre_ParAMGDataDofPoint(amg_data));
2559 hypre_ParAMGDataDofPoint(amg_data) = dof_point;
2560
2561 return hypre_error_flag;
2562}
2563
2564int
2565hypre_BoomerAMGGetNumIterations( void *data,
2566 int *num_iterations )
2567{
2568 hypre_ParAMGData *amg_data = data;
2569
2570 if (!amg_data)
2571 {
2572 printf("Warning! BoomerAMG object empty!\n");
2573 hypre_error_in_arg(1);
2574 return hypre_error_flag;
2575 }
2576 *num_iterations = hypre_ParAMGDataNumIterations(amg_data);
2577
2578 return hypre_error_flag;
2579}
2580
2581int
2582hypre_BoomerAMGGetCumNumIterations( void *data,
2583 int *cum_num_iterations )
2584{
2585 hypre_ParAMGData *amg_data = data;
2586
2587 if (!amg_data)
2588 {
2589 printf("Warning! BoomerAMG object empty!\n");
2590 hypre_error_in_arg(1);
2591 return hypre_error_flag;
2592 }
2593#ifdef CUMNUMIT
2594 *cum_num_iterations = hypre_ParAMGDataCumNumIterations(amg_data);
2595#endif
2596
2597 return hypre_error_flag;
2598}
2599
2600int
2601hypre_BoomerAMGGetResidual( void * data, hypre_ParVector ** resid )
2602{
2603 hypre_ParAMGData *amg_data = data;
2604 if (!amg_data)
2605 {
2606 printf("Warning! BoomerAMG object empty!\n");
2607 hypre_error_in_arg(1);
2608 return hypre_error_flag;
2609 }
2610 *resid = hypre_ParAMGDataResidual( amg_data );
2611 return hypre_error_flag;
2612}
2613
2614
2615int
2616hypre_BoomerAMGGetRelResidualNorm( void *data,
2617 double *rel_resid_norm )
2618{
2619 hypre_ParAMGData *amg_data = data;
2620
2621 if (!amg_data)
2622 {
2623 printf("Warning! BoomerAMG object empty!\n");
2624 hypre_error_in_arg(1);
2625 return hypre_error_flag;
2626 }
2627 *rel_resid_norm = hypre_ParAMGDataRelativeResidualNorm(amg_data);
2628
2629 return hypre_error_flag;
2630}
2631
2632int
2633hypre_BoomerAMGSetVariant( void *data,
2634 int variant)
2635{
2636 hypre_ParAMGData *amg_data = data;
2637
2638 if (!amg_data)
2639 {
2640 printf("Warning! BoomerAMG object empty!\n");
2641 hypre_error_in_arg(1);
2642 return hypre_error_flag;
2643 }
2644 if (variant < 0)
2645 {
2646 hypre_error_in_arg(2);
2647 return hypre_error_flag;
2648 }
2649 hypre_ParAMGDataVariant(amg_data) = variant;
2650
2651 return hypre_error_flag;
2652}
2653
2654int
2655hypre_BoomerAMGGetVariant( void *data,
2656 int * variant)
2657{
2658 hypre_ParAMGData *amg_data = data;
2659
2660 if (!amg_data)
2661 {
2662 printf("Warning! BoomerAMG object empty!\n");
2663 hypre_error_in_arg(1);
2664 return hypre_error_flag;
2665 }
2666 *variant = hypre_ParAMGDataVariant(amg_data);
2667
2668 return hypre_error_flag;
2669}
2670
2671int
2672hypre_BoomerAMGSetOverlap( void *data,
2673 int overlap)
2674{
2675 hypre_ParAMGData *amg_data = data;
2676
2677 if (!amg_data)
2678 {
2679 printf("Warning! BoomerAMG object empty!\n");
2680 hypre_error_in_arg(1);
2681 return hypre_error_flag;
2682 }
2683 if (overlap < 0)
2684 {
2685 hypre_error_in_arg(2);
2686 return hypre_error_flag;
2687 }
2688 hypre_ParAMGDataOverlap(amg_data) = overlap;
2689
2690 return hypre_error_flag;
2691}
2692
2693int
2694hypre_BoomerAMGGetOverlap( void *data,
2695 int * overlap)
2696{
2697 hypre_ParAMGData *amg_data = data;
2698
2699 if (!amg_data)
2700 {
2701 printf("Warning! BoomerAMG object empty!\n");
2702 hypre_error_in_arg(1);
2703 return hypre_error_flag;
2704 }
2705 *overlap = hypre_ParAMGDataOverlap(amg_data);
2706
2707 return hypre_error_flag;
2708}
2709
2710int
2711hypre_BoomerAMGSetDomainType( void *data,
2712 int domain_type)
2713{
2714 hypre_ParAMGData *amg_data = data;
2715
2716 if (!amg_data)
2717 {
2718 printf("Warning! BoomerAMG object empty!\n");
2719 hypre_error_in_arg(1);
2720 return hypre_error_flag;
2721 }
2722 if (domain_type < 0)
2723 {
2724 hypre_error_in_arg(2);
2725 return hypre_error_flag;
2726 }
2727 hypre_ParAMGDataDomainType(amg_data) = domain_type;
2728
2729 return hypre_error_flag;
2730}
2731
2732int
2733hypre_BoomerAMGGetDomainType( void *data,
2734 int * domain_type)
2735{
2736 hypre_ParAMGData *amg_data = data;
2737
2738 if (!amg_data)
2739 {
2740 printf("Warning! BoomerAMG object empty!\n");
2741 hypre_error_in_arg(1);
2742 return hypre_error_flag;
2743 }
2744 *domain_type = hypre_ParAMGDataDomainType(amg_data);
2745
2746 return hypre_error_flag;
2747}
2748
2749int
2750hypre_BoomerAMGSetSchwarzRlxWeight( void *data,
2751 double schwarz_rlx_weight)
2752{
2753 hypre_ParAMGData *amg_data = data;
2754
2755 if (!amg_data)
2756 {
2757 printf("Warning! BoomerAMG object empty!\n");
2758 hypre_error_in_arg(1);
2759 return hypre_error_flag;
2760 }
2761 hypre_ParAMGDataSchwarzRlxWeight(amg_data) = schwarz_rlx_weight;
2762
2763 return hypre_error_flag;
2764}
2765
2766int
2767hypre_BoomerAMGGetSchwarzRlxWeight( void *data,
2768 double * schwarz_rlx_weight)
2769{
2770 hypre_ParAMGData *amg_data = data;
2771
2772 if (!amg_data)
2773 {
2774 printf("Warning! BoomerAMG object empty!\n");
2775 hypre_error_in_arg(1);
2776 return hypre_error_flag;
2777 }
2778 *schwarz_rlx_weight = hypre_ParAMGDataSchwarzRlxWeight(amg_data);
2779
2780 return hypre_error_flag;
2781}
2782int
2783hypre_BoomerAMGSetChebyOrder( void *data,
2784 int order)
2785{
2786 hypre_ParAMGData *amg_data = data;
2787
2788 if (!amg_data)
2789 {
2790 printf("Warning! BoomerAMG object empty!\n");
2791 hypre_error_in_arg(1);
2792 return hypre_error_flag;
2793 }
2794 if (order < 1)
2795 {
2796 hypre_error_in_arg(2);
2797 return hypre_error_flag;
2798 }
2799 hypre_ParAMGDataChebyOrder(amg_data) = order;
2800
2801 return hypre_error_flag;
2802}
2803int
2804hypre_BoomerAMGSetChebyEigRatio( void *data,
2805 double ratio)
2806{
2807 hypre_ParAMGData *amg_data = data;
2808
2809 if (!amg_data)
2810 {
2811 printf("Warning! BoomerAMG object empty!\n");
2812 hypre_error_in_arg(1);
2813 return hypre_error_flag;
2814 }
2815 if (ratio <= 0.0 || ratio > 1.0 )
2816 {
2817 hypre_error_in_arg(2);
2818 return hypre_error_flag;
2819 }
2820 hypre_ParAMGDataChebyEigRatio(amg_data) = ratio;
2821
2822 return hypre_error_flag;
2823}
2824int
2825hypre_BoomerAMGSetMaxCoarseSize( void *data,
2826 int thresh)
2827{
2828 hypre_ParAMGData *amg_data = data;
2829
2830 if (!amg_data)
2831 {
2832 printf("Warning! BoomerAMG object empty!\n");
2833 hypre_error_in_arg(1);
2834 return hypre_error_flag;
2835 }
2836 if (thresh < 0 )
2837 {
2838 hypre_error_in_arg(2);
2839 return hypre_error_flag;
2840 }
2841 hypre_ParAMGDataMaxCoarseSize(amg_data) = thresh;
2842
2843 return hypre_error_flag;
2844}
2845int
2846hypre_BoomerAMGSetSeqThreshold( void *data,
2847 int thresh)
2848{
2849 hypre_ParAMGData *amg_data = data;
2850
2851 if (!amg_data)
2852 {
2853 printf("Warning! BoomerAMG object empty!\n");
2854 hypre_error_in_arg(1);
2855 return hypre_error_flag;
2856 }
2857 if (thresh < 0 )
2858 {
2859 hypre_error_in_arg(2);
2860 return hypre_error_flag;
2861 }
2862 hypre_ParAMGDataSeqThreshold(amg_data) = thresh;
2863
2864 return hypre_error_flag;
2865}
Note: See TracBrowser for help on using the repository browser.