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 * ParAMG functions
11 *
12 *****************************************************************************/
13
14 #include "_hypre_parcsr_ls.h"
15 #include "par_amg.h"
16 #ifdef HYPRE_USING_DSUPERLU
17 #include <math.h>
18 #include "superlu_ddefs.h"
19 #endif
20 /*--------------------------------------------------------------------------
21 * hypre_BoomerAMGCreate
22 *--------------------------------------------------------------------------*/
23
24 void *
hypre_BoomerAMGCreate()25 hypre_BoomerAMGCreate()
26 {
27 hypre_ParAMGData *amg_data;
28
29 /* setup params */
30 HYPRE_Int max_levels;
31 HYPRE_Int max_coarse_size;
32 HYPRE_Int min_coarse_size;
33 HYPRE_Int coarsen_cut_factor;
34 HYPRE_Real strong_threshold;
35 HYPRE_Real strong_threshold_R;
36 HYPRE_Real filter_threshold_R;
37 HYPRE_Int Sabs;
38 HYPRE_Real max_row_sum;
39 HYPRE_Real trunc_factor;
40 HYPRE_Real agg_trunc_factor;
41 HYPRE_Real agg_P12_trunc_factor;
42 HYPRE_Real jacobi_trunc_threshold;
43 HYPRE_Real CR_rate;
44 HYPRE_Real CR_strong_th;
45 HYPRE_Real A_drop_tol;
46 HYPRE_Int A_drop_type;
47 HYPRE_Int interp_type;
48 HYPRE_Int sep_weight;
49 HYPRE_Int coarsen_type;
50 HYPRE_Int measure_type;
51 HYPRE_Int setup_type;
52 HYPRE_Int P_max_elmts;
53 HYPRE_Int num_functions;
54 HYPRE_Int nodal, nodal_levels, nodal_diag;
55 HYPRE_Int keep_same_sign;
56 HYPRE_Int num_paths;
57 HYPRE_Int agg_num_levels;
58 HYPRE_Int agg_interp_type;
59 HYPRE_Int agg_P_max_elmts;
60 HYPRE_Int agg_P12_max_elmts;
61 HYPRE_Int post_interp_type;
62 HYPRE_Int num_CR_relax_steps;
63 HYPRE_Int IS_type;
64 HYPRE_Int CR_use_CG;
65 HYPRE_Int cgc_its;
66 HYPRE_Int seq_threshold;
67 HYPRE_Int redundant;
68 HYPRE_Int rap2;
69 HYPRE_Int keepT;
70 HYPRE_Int modu_rap;
71
72 /* solve params */
73 HYPRE_Int min_iter;
74 HYPRE_Int max_iter;
75 HYPRE_Int fcycle;
76 HYPRE_Int cycle_type;
77
78 HYPRE_Int converge_type;
79 HYPRE_Real tol;
80
81 HYPRE_Int num_sweeps;
82 HYPRE_Int relax_down;
83 HYPRE_Int relax_up;
84 HYPRE_Int relax_coarse;
85 HYPRE_Int relax_order;
86 HYPRE_Real relax_wt;
87 HYPRE_Real outer_wt;
88 HYPRE_Real nongalerkin_tol;
89 HYPRE_Int smooth_type;
90 HYPRE_Int smooth_num_levels;
91 HYPRE_Int smooth_num_sweeps;
92
93 HYPRE_Int variant, overlap, domain_type, schwarz_use_nonsymm;
94 HYPRE_Real schwarz_rlx_weight;
95 HYPRE_Int level, sym;
96 HYPRE_Int eu_level, eu_bj;
97 HYPRE_Int max_nz_per_row;
98 HYPRE_Real thresh, filter;
99 HYPRE_Real drop_tol;
100 HYPRE_Real eu_sparse_A;
101 char *euclidfile;
102 HYPRE_Int ilu_lfil;
103 HYPRE_Int ilu_type;
104 HYPRE_Int ilu_max_row_nnz;
105 HYPRE_Int ilu_max_iter;
106 HYPRE_Real ilu_droptol;
107 HYPRE_Int ilu_reordering_type;
108
109 HYPRE_Int cheby_order;
110 HYPRE_Int cheby_eig_est;
111 HYPRE_Int cheby_variant;
112 HYPRE_Int cheby_scale;
113 HYPRE_Real cheby_eig_ratio;
114
115 HYPRE_Int block_mode;
116
117 HYPRE_Int additive;
118 HYPRE_Int mult_additive;
119 HYPRE_Int simple;
120 HYPRE_Int add_last_lvl;
121 HYPRE_Real add_trunc_factor;
122 HYPRE_Int add_P_max_elmts;
123 HYPRE_Int add_rlx_type;
124 HYPRE_Real add_rlx_wt;
125
126 /* log info */
127 HYPRE_Int num_iterations;
128 HYPRE_Int cum_num_iterations;
129
130 /* output params */
131 HYPRE_Int print_level;
132 HYPRE_Int logging;
133 /* HYPRE_Int cycle_op_count; */
134 char log_file_name[256];
135 HYPRE_Int debug_flag;
136
137 char plot_file_name[251] = {0};
138
139 /*-----------------------------------------------------------------------
140 * Setup default values for parameters
141 *-----------------------------------------------------------------------*/
142
143 /* setup params */
144 max_levels = 25;
145 max_coarse_size = 9;
146 min_coarse_size = 0;
147 seq_threshold = 0;
148 redundant = 0;
149 coarsen_cut_factor = 0;
150 strong_threshold = 0.25;
151 strong_threshold_R = 0.25;
152 filter_threshold_R = 0.0;
153 Sabs = 0;
154 max_row_sum = 0.9;
155 trunc_factor = 0.0;
156 agg_trunc_factor = 0.0;
157 agg_P12_trunc_factor = 0.0;
158 jacobi_trunc_threshold = 0.01;
159 sep_weight = 0;
160 coarsen_type = 10;
161 interp_type = 6;
162 measure_type = 0;
163 setup_type = 1;
164 P_max_elmts = 4;
165 agg_P_max_elmts = 0;
166 agg_P12_max_elmts = 0;
167 num_functions = 1;
168 nodal = 0;
169 nodal_levels = max_levels;
170 nodal_diag = 0;
171 keep_same_sign = 0;
172 num_paths = 1;
173 agg_num_levels = 0;
174 post_interp_type = 0;
175 agg_interp_type = 4;
176 num_CR_relax_steps = 2;
177 CR_rate = 0.7;
178 CR_strong_th = 0;
179 A_drop_tol = 0.0;
180 A_drop_type = -1;
181 IS_type = 1;
182 CR_use_CG = 0;
183 cgc_its = 1;
184
185 variant = 0;
186 overlap = 1;
187 domain_type = 2;
188 schwarz_rlx_weight = 1.0;
189 smooth_num_sweeps = 1;
190 smooth_num_levels = 0;
191 smooth_type = 6;
192 schwarz_use_nonsymm = 0;
193
194 level = 1;
195 sym = 0;
196 thresh = 0.1;
197 filter = 0.05;
198 drop_tol = 0.0001;
199 max_nz_per_row = 20;
200 euclidfile = NULL;
201 eu_level = 0;
202 eu_sparse_A = 0.0;
203 eu_bj = 0;
204 ilu_lfil = 0;
205 ilu_type = 0;
206 ilu_max_row_nnz = 20;
207 ilu_max_iter = 1;
208 ilu_droptol = 0.01;
209 ilu_reordering_type = 1;
210
211 /* solve params */
212 min_iter = 0;
213 max_iter = 20;
214 fcycle = 0;
215 cycle_type = 1;
216 converge_type = 0;
217 tol = 1.0e-6;
218
219 num_sweeps = 1;
220 relax_down = 13;
221 relax_up = 14;
222 relax_coarse = 9;
223 relax_order = 0;
224 relax_wt = 1.0;
225 outer_wt = 1.0;
226
227 cheby_order = 2;
228 cheby_variant = 0;
229 cheby_scale = 1;
230 cheby_eig_est = 10;
231 cheby_eig_ratio = .3;
232
233 block_mode = 0;
234
235 additive = -1;
236 mult_additive = -1;
237 simple = -1;
238 add_last_lvl = -1;
239 add_trunc_factor = 0.0;
240 add_P_max_elmts = 0;
241 add_rlx_type = 18;
242 add_rlx_wt = 1.0;
243
244 /* log info */
245 num_iterations = 0;
246 cum_num_iterations = 0;
247
248 /* output params */
249 print_level = 0;
250 logging = 0;
251 hypre_sprintf(log_file_name, "%s", "amg.out.log");
252 /* cycle_op_count = 0; */
253 debug_flag = 0;
254
255 nongalerkin_tol = 0.0;
256
257 rap2 = 0;
258 keepT = 0;
259 modu_rap = 0;
260
261 #if defined(HYPRE_USING_GPU)
262 keepT = 1;
263 modu_rap = 1;
264 coarsen_type = 8;
265 relax_down = 18;
266 relax_up = 18;
267 agg_interp_type = 7;
268 #endif
269
270 HYPRE_ANNOTATE_FUNC_BEGIN;
271
272 /*-----------------------------------------------------------------------
273 * Create the hypre_ParAMGData structure and return
274 *-----------------------------------------------------------------------*/
275
276 amg_data = hypre_CTAlloc(hypre_ParAMGData, 1, HYPRE_MEMORY_HOST);
277
278 hypre_ParAMGDataMemoryLocation(amg_data) = HYPRE_MEMORY_UNDEFINED;
279
280 hypre_ParAMGDataPartialCycleCoarsestLevel(amg_data) = -1;
281 hypre_ParAMGDataPartialCycleControl(amg_data) = -1;
282 hypre_ParAMGDataMaxLevels(amg_data) = max_levels;
283 hypre_ParAMGDataUserCoarseRelaxType(amg_data) = 9;
284 hypre_ParAMGDataUserRelaxType(amg_data) = -1;
285 hypre_ParAMGDataUserNumSweeps(amg_data) = -1;
286 hypre_ParAMGDataUserRelaxWeight(amg_data) = relax_wt;
287 hypre_ParAMGDataOuterWt(amg_data) = outer_wt;
288 hypre_BoomerAMGSetMaxCoarseSize(amg_data, max_coarse_size);
289 hypre_BoomerAMGSetMinCoarseSize(amg_data, min_coarse_size);
290 hypre_BoomerAMGSetCoarsenCutFactor(amg_data, coarsen_cut_factor);
291 hypre_BoomerAMGSetStrongThreshold(amg_data, strong_threshold);
292 hypre_BoomerAMGSetStrongThresholdR(amg_data, strong_threshold_R);
293 hypre_BoomerAMGSetFilterThresholdR(amg_data, filter_threshold_R);
294 hypre_BoomerAMGSetSabs(amg_data, Sabs);
295 hypre_BoomerAMGSetMaxRowSum(amg_data, max_row_sum);
296 hypre_BoomerAMGSetTruncFactor(amg_data, trunc_factor);
297 hypre_BoomerAMGSetAggTruncFactor(amg_data, agg_trunc_factor);
298 hypre_BoomerAMGSetAggP12TruncFactor(amg_data, agg_P12_trunc_factor);
299 hypre_BoomerAMGSetJacobiTruncThreshold(amg_data, jacobi_trunc_threshold);
300 hypre_BoomerAMGSetSepWeight(amg_data, sep_weight);
301 hypre_BoomerAMGSetMeasureType(amg_data, measure_type);
302 hypre_BoomerAMGSetCoarsenType(amg_data, coarsen_type);
303 hypre_BoomerAMGSetInterpType(amg_data, interp_type);
304 hypre_BoomerAMGSetSetupType(amg_data, setup_type);
305 hypre_BoomerAMGSetPMaxElmts(amg_data, P_max_elmts);
306 hypre_BoomerAMGSetAggPMaxElmts(amg_data, agg_P_max_elmts);
307 hypre_BoomerAMGSetAggP12MaxElmts(amg_data, agg_P12_max_elmts);
308 hypre_BoomerAMGSetNumFunctions(amg_data, num_functions);
309 hypre_BoomerAMGSetNodal(amg_data, nodal);
310 hypre_BoomerAMGSetNodalLevels(amg_data, nodal_levels);
311 hypre_BoomerAMGSetNodal(amg_data, nodal_diag);
312 hypre_BoomerAMGSetKeepSameSign(amg_data, keep_same_sign);
313 hypre_BoomerAMGSetNumPaths(amg_data, num_paths);
314 hypre_BoomerAMGSetAggNumLevels(amg_data, agg_num_levels);
315 hypre_BoomerAMGSetAggInterpType(amg_data, agg_interp_type);
316 hypre_BoomerAMGSetPostInterpType(amg_data, post_interp_type);
317 hypre_BoomerAMGSetNumCRRelaxSteps(amg_data, num_CR_relax_steps);
318 hypre_BoomerAMGSetCRRate(amg_data, CR_rate);
319 hypre_BoomerAMGSetCRStrongTh(amg_data, CR_strong_th);
320 hypre_BoomerAMGSetADropTol(amg_data, A_drop_tol);
321 hypre_BoomerAMGSetADropType(amg_data, A_drop_type);
322 hypre_BoomerAMGSetISType(amg_data, IS_type);
323 hypre_BoomerAMGSetCRUseCG(amg_data, CR_use_CG);
324 hypre_BoomerAMGSetCGCIts(amg_data, cgc_its);
325 hypre_BoomerAMGSetVariant(amg_data, variant);
326 hypre_BoomerAMGSetOverlap(amg_data, overlap);
327 hypre_BoomerAMGSetSchwarzRlxWeight(amg_data, schwarz_rlx_weight);
328 hypre_BoomerAMGSetSchwarzUseNonSymm(amg_data, schwarz_use_nonsymm);
329 hypre_BoomerAMGSetDomainType(amg_data, domain_type);
330 hypre_BoomerAMGSetSym(amg_data, sym);
331 hypre_BoomerAMGSetLevel(amg_data, level);
332 hypre_BoomerAMGSetThreshold(amg_data, thresh);
333 hypre_BoomerAMGSetFilter(amg_data, filter);
334 hypre_BoomerAMGSetDropTol(amg_data, drop_tol);
335 hypre_BoomerAMGSetMaxNzPerRow(amg_data, max_nz_per_row);
336 hypre_BoomerAMGSetEuclidFile(amg_data, euclidfile);
337 hypre_BoomerAMGSetEuLevel(amg_data, eu_level);
338 hypre_BoomerAMGSetEuSparseA(amg_data, eu_sparse_A);
339 hypre_BoomerAMGSetEuBJ(amg_data, eu_bj);
340 hypre_BoomerAMGSetILUType(amg_data, ilu_type);
341 hypre_BoomerAMGSetILULevel(amg_data, ilu_lfil);
342 hypre_BoomerAMGSetILUMaxRowNnz(amg_data, ilu_max_row_nnz);
343 hypre_BoomerAMGSetILUDroptol(amg_data, ilu_droptol);
344 hypre_BoomerAMGSetILUMaxIter(amg_data, ilu_max_iter);
345 hypre_BoomerAMGSetILULocalReordering(amg_data, ilu_reordering_type);
346
347 hypre_BoomerAMGSetMinIter(amg_data, min_iter);
348 hypre_BoomerAMGSetMaxIter(amg_data, max_iter);
349 hypre_BoomerAMGSetCycleType(amg_data, cycle_type);
350 hypre_BoomerAMGSetFCycle(amg_data, fcycle);
351 hypre_BoomerAMGSetConvergeType(amg_data, converge_type);
352 hypre_BoomerAMGSetTol(amg_data, tol);
353 hypre_BoomerAMGSetNumSweeps(amg_data, num_sweeps);
354 hypre_BoomerAMGSetCycleRelaxType(amg_data, relax_down, 1);
355 hypre_BoomerAMGSetCycleRelaxType(amg_data, relax_up, 2);
356 hypre_BoomerAMGSetCycleRelaxType(amg_data, relax_coarse, 3);
357 hypre_BoomerAMGSetRelaxOrder(amg_data, relax_order);
358 hypre_BoomerAMGSetRelaxWt(amg_data, relax_wt);
359 hypre_BoomerAMGSetOuterWt(amg_data, outer_wt);
360 hypre_BoomerAMGSetSmoothType(amg_data, smooth_type);
361 hypre_BoomerAMGSetSmoothNumLevels(amg_data, smooth_num_levels);
362 hypre_BoomerAMGSetSmoothNumSweeps(amg_data, smooth_num_sweeps);
363
364 hypre_BoomerAMGSetChebyOrder(amg_data, cheby_order);
365 hypre_BoomerAMGSetChebyFraction(amg_data, cheby_eig_ratio);
366 hypre_BoomerAMGSetChebyEigEst(amg_data, cheby_eig_est);
367 hypre_BoomerAMGSetChebyVariant(amg_data, cheby_variant);
368 hypre_BoomerAMGSetChebyScale(amg_data, cheby_scale);
369
370 hypre_BoomerAMGSetNumIterations(amg_data, num_iterations);
371
372 hypre_BoomerAMGSetAdditive(amg_data, additive);
373 hypre_BoomerAMGSetMultAdditive(amg_data, mult_additive);
374 hypre_BoomerAMGSetSimple(amg_data, simple);
375 hypre_BoomerAMGSetMultAddPMaxElmts(amg_data, add_P_max_elmts);
376 hypre_BoomerAMGSetMultAddTruncFactor(amg_data, add_trunc_factor);
377 hypre_BoomerAMGSetAddRelaxType(amg_data, add_rlx_type);
378 hypre_BoomerAMGSetAddRelaxWt(amg_data, add_rlx_wt);
379 hypre_ParAMGDataAddLastLvl(amg_data) = add_last_lvl;
380 hypre_ParAMGDataLambda(amg_data) = NULL;
381 hypre_ParAMGDataXtilde(amg_data) = NULL;
382 hypre_ParAMGDataRtilde(amg_data) = NULL;
383 hypre_ParAMGDataDinv(amg_data) = NULL;
384
385 #ifdef CUMNUMIT
386 hypre_ParAMGDataCumNumIterations(amg_data) = cum_num_iterations;
387 #endif
388 hypre_BoomerAMGSetPrintLevel(amg_data, print_level);
389 hypre_BoomerAMGSetLogging(amg_data, logging);
390 hypre_BoomerAMGSetPrintFileName(amg_data, log_file_name);
391 hypre_BoomerAMGSetDebugFlag(amg_data, debug_flag);
392 hypre_BoomerAMGSetRestriction(amg_data, 0);
393 hypre_BoomerAMGSetIsTriangular(amg_data, 0);
394 hypre_BoomerAMGSetGMRESSwitchR(amg_data, 64);
395
396 hypre_BoomerAMGSetGSMG(amg_data, 0);
397 hypre_BoomerAMGSetNumSamples(amg_data, 0);
398
399 hypre_ParAMGDataAArray(amg_data) = NULL;
400 hypre_ParAMGDataPArray(amg_data) = NULL;
401 hypre_ParAMGDataRArray(amg_data) = NULL;
402 hypre_ParAMGDataCFMarkerArray(amg_data) = NULL;
403 hypre_ParAMGDataVtemp(amg_data) = NULL;
404 hypre_ParAMGDataRtemp(amg_data) = NULL;
405 hypre_ParAMGDataPtemp(amg_data) = NULL;
406 hypre_ParAMGDataZtemp(amg_data) = NULL;
407 hypre_ParAMGDataFArray(amg_data) = NULL;
408 hypre_ParAMGDataUArray(amg_data) = NULL;
409 hypre_ParAMGDataDofFunc(amg_data) = NULL;
410 hypre_ParAMGDataDofFuncArray(amg_data) = NULL;
411 hypre_ParAMGDataDofPointArray(amg_data) = NULL;
412 hypre_ParAMGDataDofPointArray(amg_data) = NULL;
413 hypre_ParAMGDataPointDofMapArray(amg_data) = NULL;
414 hypre_ParAMGDataSmoother(amg_data) = NULL;
415 hypre_ParAMGDataL1Norms(amg_data) = NULL;
416
417 hypre_ParAMGDataABlockArray(amg_data) = NULL;
418 hypre_ParAMGDataPBlockArray(amg_data) = NULL;
419 hypre_ParAMGDataRBlockArray(amg_data) = NULL;
420
421 /* this can not be set by the user currently */
422 hypre_ParAMGDataBlockMode(amg_data) = block_mode;
423
424 /* Stuff for Chebyshev smoothing */
425 hypre_ParAMGDataMaxEigEst(amg_data) = NULL;
426 hypre_ParAMGDataMinEigEst(amg_data) = NULL;
427 hypre_ParAMGDataChebyDS(amg_data) = NULL;
428 hypre_ParAMGDataChebyCoefs(amg_data) = NULL;
429
430 /* BM Oct 22, 2006 */
431 hypre_ParAMGDataPlotGrids(amg_data) = 0;
432 hypre_BoomerAMGSetPlotFileName (amg_data, plot_file_name);
433
434 /* BM Oct 17, 2006 */
435 hypre_ParAMGDataCoordDim(amg_data) = 0;
436 hypre_ParAMGDataCoordinates(amg_data) = NULL;
437
438 /* for fitting vectors for interp */
439 hypre_BoomerAMGSetInterpVecVariant(amg_data, 0);
440 hypre_BoomerAMGSetInterpVectors(amg_data, 0, NULL);
441 hypre_ParAMGNumLevelsInterpVectors(amg_data) = max_levels;
442 hypre_ParAMGInterpVectorsArray(amg_data) = NULL;
443 hypre_ParAMGInterpVecQMax(amg_data) = 0;
444 hypre_ParAMGInterpVecAbsQTrunc(amg_data) = 0.0;
445 hypre_ParAMGInterpRefine(amg_data) = 0;
446 hypre_ParAMGInterpVecFirstLevel(amg_data) = 0;
447 hypre_ParAMGNumInterpVectors(amg_data) = 0;
448 hypre_ParAMGSmoothInterpVectors(amg_data) = 0;
449 hypre_ParAMGDataExpandPWeights(amg_data) = NULL;
450
451 /* for redundant coarse grid solve */
452 hypre_ParAMGDataSeqThreshold(amg_data) = seq_threshold;
453 hypre_ParAMGDataRedundant(amg_data) = redundant;
454 hypre_ParAMGDataCoarseSolver(amg_data) = NULL;
455 hypre_ParAMGDataACoarse(amg_data) = NULL;
456 hypre_ParAMGDataFCoarse(amg_data) = NULL;
457 hypre_ParAMGDataUCoarse(amg_data) = NULL;
458 hypre_ParAMGDataNewComm(amg_data) = hypre_MPI_COMM_NULL;
459
460 /* for Gaussian elimination coarse grid solve */
461 hypre_ParAMGDataGSSetup(amg_data) = 0;
462 hypre_ParAMGDataAMat(amg_data) = NULL;
463 hypre_ParAMGDataAInv(amg_data) = NULL;
464 hypre_ParAMGDataBVec(amg_data) = NULL;
465 hypre_ParAMGDataCommInfo(amg_data) = NULL;
466
467 hypre_ParAMGDataNonGalerkinTol(amg_data) = nongalerkin_tol;
468 hypre_ParAMGDataNonGalTolArray(amg_data) = NULL;
469
470 hypre_ParAMGDataRAP2(amg_data) = rap2;
471 hypre_ParAMGDataKeepTranspose(amg_data) = keepT;
472 hypre_ParAMGDataModularizedMatMat(amg_data) = modu_rap;
473
474 /* information for preserving indices as coarse grid points */
475 hypre_ParAMGDataCPointsMarker(amg_data) = NULL;
476 hypre_ParAMGDataCPointsLocalMarker(amg_data) = NULL;
477 hypre_ParAMGDataCPointsLevel(amg_data) = 0;
478 hypre_ParAMGDataNumCPoints(amg_data) = 0;
479
480 /* information for preserving indices as special fine grid points */
481 hypre_ParAMGDataIsolatedFPointsMarker(amg_data) = NULL;
482 hypre_ParAMGDataNumIsolatedFPoints(amg_data) = 0;
483
484 #ifdef HYPRE_USING_DSUPERLU
485 hypre_ParAMGDataDSLUThreshold(amg_data) = 0;
486 hypre_ParAMGDataDSLUSolver(amg_data) = NULL;
487 #endif
488
489 HYPRE_ANNOTATE_FUNC_END;
490
491 return (void *) amg_data;
492 }
493
494 /*--------------------------------------------------------------------------
495 * hypre_BoomerAMGDestroy
496 *--------------------------------------------------------------------------*/
497
498 HYPRE_Int
hypre_BoomerAMGDestroy(void * data)499 hypre_BoomerAMGDestroy( void *data )
500 {
501 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
502 HYPRE_Int num_levels = hypre_ParAMGDataNumLevels(amg_data);
503 HYPRE_Int smooth_num_levels = hypre_ParAMGDataSmoothNumLevels(amg_data);
504 HYPRE_Solver *smoother = hypre_ParAMGDataSmoother(amg_data);
505 void *amg = hypre_ParAMGDataCoarseSolver(amg_data);
506 MPI_Comm new_comm = hypre_ParAMGDataNewComm(amg_data);
507 HYPRE_Int i;
508 HYPRE_Int *grid_relax_type = hypre_ParAMGDataGridRelaxType(amg_data);
509
510 HYPRE_ANNOTATE_FUNC_BEGIN;
511
512 #ifdef HYPRE_USING_DSUPERLU
513 // if (hypre_ParAMGDataDSLUThreshold(amg_data) > 0)
514 if (hypre_ParAMGDataDSLUSolver(amg_data) != NULL)
515 {
516 hypre_SLUDistDestroy(hypre_ParAMGDataDSLUSolver(amg_data));
517 hypre_ParAMGDataDSLUSolver(amg_data) = NULL;
518 }
519 #endif
520
521 if (hypre_ParAMGDataMaxEigEst(amg_data))
522 {
523 hypre_TFree(hypre_ParAMGDataMaxEigEst(amg_data), HYPRE_MEMORY_HOST);
524 hypre_ParAMGDataMaxEigEst(amg_data) = NULL;
525 }
526 if (hypre_ParAMGDataMinEigEst(amg_data))
527 {
528 hypre_TFree(hypre_ParAMGDataMinEigEst(amg_data), HYPRE_MEMORY_HOST);
529 hypre_ParAMGDataMinEigEst(amg_data) = NULL;
530 }
531 if (hypre_ParAMGDataNumGridSweeps(amg_data))
532 {
533 hypre_TFree(hypre_ParAMGDataNumGridSweeps(amg_data), HYPRE_MEMORY_HOST);
534 hypre_ParAMGDataNumGridSweeps(amg_data) = NULL;
535 }
536 if (grid_relax_type)
537 {
538 HYPRE_Int num_levels = hypre_ParAMGDataNumLevels(amg_data);
539 if (grid_relax_type[1] == 15 || grid_relax_type[3] == 15 )
540 {
541 if (grid_relax_type[1] == 15)
542 for (i=0; i < num_levels; i++)
543 HYPRE_ParCSRPCGDestroy(smoother[i]);
544 if (grid_relax_type[3] == 15 && grid_relax_type[1] != 15)
545 HYPRE_ParCSRPCGDestroy(smoother[num_levels-1]);
546 hypre_TFree(smoother, HYPRE_MEMORY_HOST);
547 }
548
549 hypre_TFree(hypre_ParAMGDataGridRelaxType(amg_data), HYPRE_MEMORY_HOST);
550 hypre_ParAMGDataGridRelaxType(amg_data) = NULL;
551 }
552 if (hypre_ParAMGDataRelaxWeight(amg_data))
553 {
554 hypre_TFree(hypre_ParAMGDataRelaxWeight(amg_data), HYPRE_MEMORY_HOST);
555 hypre_ParAMGDataRelaxWeight(amg_data) = NULL;
556 }
557 if (hypre_ParAMGDataOmega(amg_data))
558 {
559 hypre_TFree(hypre_ParAMGDataOmega(amg_data), HYPRE_MEMORY_HOST);
560 hypre_ParAMGDataOmega(amg_data) = NULL;
561 }
562 if (hypre_ParAMGDataNonGalTolArray(amg_data))
563 {
564 hypre_TFree(hypre_ParAMGDataNonGalTolArray(amg_data), HYPRE_MEMORY_HOST);
565 hypre_ParAMGDataNonGalTolArray(amg_data) = NULL;
566 }
567 if (hypre_ParAMGDataDofFunc(amg_data))
568 {
569 hypre_IntArrayDestroy(hypre_ParAMGDataDofFunc(amg_data));
570 hypre_ParAMGDataDofFunc(amg_data) = NULL;
571 }
572 for (i=1; i < num_levels; i++)
573 {
574 hypre_ParVectorDestroy(hypre_ParAMGDataFArray(amg_data)[i]);
575 hypre_ParVectorDestroy(hypre_ParAMGDataUArray(amg_data)[i]);
576
577 if (hypre_ParAMGDataAArray(amg_data)[i])
578 hypre_ParCSRMatrixDestroy(hypre_ParAMGDataAArray(amg_data)[i]);
579
580 if (hypre_ParAMGDataPArray(amg_data)[i-1])
581 hypre_ParCSRMatrixDestroy(hypre_ParAMGDataPArray(amg_data)[i-1]);
582
583 if (hypre_ParAMGDataRestriction(amg_data))
584 {
585 if (hypre_ParAMGDataRArray(amg_data)[i-1])
586 {
587 hypre_ParCSRMatrixDestroy(hypre_ParAMGDataRArray(amg_data)[i-1]);
588 }
589 }
590
591 hypre_IntArrayDestroy(hypre_ParAMGDataCFMarkerArray(amg_data)[i-1]);
592
593 /* get rid of any block structures */
594 if (hypre_ParAMGDataABlockArray(amg_data)[i])
595 hypre_ParCSRBlockMatrixDestroy(hypre_ParAMGDataABlockArray(amg_data)[i]);
596
597 if (hypre_ParAMGDataPBlockArray(amg_data)[i-1])
598 hypre_ParCSRBlockMatrixDestroy(hypre_ParAMGDataPBlockArray(amg_data)[i-1]);
599
600 /* RL */
601 if (hypre_ParAMGDataRestriction(amg_data))
602 {
603 if (hypre_ParAMGDataRBlockArray(amg_data)[i-1])
604 {
605 hypre_ParCSRBlockMatrixDestroy(hypre_ParAMGDataRBlockArray(amg_data)[i-1]);
606 }
607 }
608 }
609 if (hypre_ParAMGDataGridRelaxPoints(amg_data))
610 {
611 for (i=0; i < 4; i++)
612 hypre_TFree(hypre_ParAMGDataGridRelaxPoints(amg_data)[i], HYPRE_MEMORY_HOST);
613 hypre_TFree(hypre_ParAMGDataGridRelaxPoints(amg_data), HYPRE_MEMORY_HOST);
614 hypre_ParAMGDataGridRelaxPoints(amg_data) = NULL;
615 }
616
617 if (hypre_ParAMGDataLambda(amg_data))
618 {
619 hypre_ParCSRMatrixDestroy(hypre_ParAMGDataLambda(amg_data));
620 }
621
622 if (hypre_ParAMGDataAtilde(amg_data))
623 {
624 hypre_ParCSRMatrix *Atilde = hypre_ParAMGDataAtilde(amg_data);
625 hypre_CSRMatrixDestroy(hypre_ParCSRMatrixDiag(Atilde));
626 hypre_CSRMatrixDestroy(hypre_ParCSRMatrixOffd(Atilde));
627 hypre_TFree(Atilde, HYPRE_MEMORY_HOST);
628 }
629
630 if (hypre_ParAMGDataXtilde(amg_data))
631 hypre_ParVectorDestroy(hypre_ParAMGDataXtilde(amg_data));
632
633 if (hypre_ParAMGDataRtilde(amg_data))
634 hypre_ParVectorDestroy(hypre_ParAMGDataRtilde(amg_data));
635
636 if (hypre_ParAMGDataL1Norms(amg_data))
637 {
638 for (i = 0; i < num_levels; i++)
639 {
640 hypre_SeqVectorDestroy(hypre_ParAMGDataL1Norms(amg_data)[i]);
641 }
642 hypre_TFree(hypre_ParAMGDataL1Norms(amg_data), HYPRE_MEMORY_HOST);
643 }
644
645 if (hypre_ParAMGDataChebyCoefs(amg_data))
646 {
647 for (i=0; i < num_levels; i++)
648 if (hypre_ParAMGDataChebyCoefs(amg_data)[i])
649 hypre_TFree(hypre_ParAMGDataChebyCoefs(amg_data)[i], HYPRE_MEMORY_HOST);
650 hypre_TFree(hypre_ParAMGDataChebyCoefs(amg_data), HYPRE_MEMORY_HOST);
651 }
652
653 if (hypre_ParAMGDataChebyDS(amg_data))
654 {
655 for (i=0; i < num_levels; i++)
656 hypre_SeqVectorDestroy(hypre_ParAMGDataChebyDS(amg_data)[i]);
657 hypre_TFree(hypre_ParAMGDataChebyDS(amg_data), HYPRE_MEMORY_HOST);
658 }
659
660 if (hypre_ParAMGDataDinv(amg_data))
661 hypre_TFree(hypre_ParAMGDataDinv(amg_data), HYPRE_MEMORY_HOST);
662
663 /* get rid of a fine level block matrix */
664 if (hypre_ParAMGDataABlockArray(amg_data))
665 if (hypre_ParAMGDataABlockArray(amg_data)[0])
666 hypre_ParCSRBlockMatrixDestroy(hypre_ParAMGDataABlockArray(amg_data)[0]);
667
668
669 /* see comments in par_coarsen.c regarding special case for CF_marker */
670 if (num_levels == 1)
671 {
672 hypre_IntArrayDestroy(hypre_ParAMGDataCFMarkerArray(amg_data)[0]);
673 }
674 hypre_ParVectorDestroy(hypre_ParAMGDataVtemp(amg_data));
675 hypre_TFree(hypre_ParAMGDataFArray(amg_data), HYPRE_MEMORY_HOST);
676 hypre_TFree(hypre_ParAMGDataUArray(amg_data), HYPRE_MEMORY_HOST);
677 hypre_TFree(hypre_ParAMGDataAArray(amg_data), HYPRE_MEMORY_HOST);
678 hypre_TFree(hypre_ParAMGDataABlockArray(amg_data), HYPRE_MEMORY_HOST);
679 hypre_TFree(hypre_ParAMGDataPBlockArray(amg_data), HYPRE_MEMORY_HOST);
680 hypre_TFree(hypre_ParAMGDataPArray(amg_data), HYPRE_MEMORY_HOST);
681 hypre_TFree(hypre_ParAMGDataCFMarkerArray(amg_data), HYPRE_MEMORY_HOST);
682
683 if (hypre_ParAMGDataRtemp(amg_data))
684 hypre_ParVectorDestroy(hypre_ParAMGDataRtemp(amg_data));
685 if (hypre_ParAMGDataPtemp(amg_data))
686 hypre_ParVectorDestroy(hypre_ParAMGDataPtemp(amg_data));
687 if (hypre_ParAMGDataZtemp(amg_data))
688 hypre_ParVectorDestroy(hypre_ParAMGDataZtemp(amg_data));
689
690 if (hypre_ParAMGDataDofFuncArray(amg_data))
691 {
692 for (i=1; i < num_levels; i++)
693 hypre_IntArrayDestroy(hypre_ParAMGDataDofFuncArray(amg_data)[i]);
694 hypre_TFree(hypre_ParAMGDataDofFuncArray(amg_data), HYPRE_MEMORY_HOST);
695 hypre_ParAMGDataDofFuncArray(amg_data) = NULL;
696 }
697 if (hypre_ParAMGDataRestriction(amg_data))
698 {
699 hypre_TFree(hypre_ParAMGDataRBlockArray(amg_data),HYPRE_MEMORY_HOST);
700 hypre_TFree(hypre_ParAMGDataRArray(amg_data),HYPRE_MEMORY_HOST);
701 hypre_ParAMGDataRArray(amg_data) = NULL;
702 }
703 if (hypre_ParAMGDataDofPointArray(amg_data))
704 {
705 for (i=0; i < num_levels; i++)
706 hypre_TFree(hypre_ParAMGDataDofPointArray(amg_data)[i], HYPRE_MEMORY_HOST);
707 hypre_TFree(hypre_ParAMGDataDofPointArray(amg_data), HYPRE_MEMORY_HOST);
708 hypre_ParAMGDataDofPointArray(amg_data) = NULL;
709 }
710 if (hypre_ParAMGDataPointDofMapArray(amg_data))
711 {
712 for (i=0; i < num_levels; i++)
713 hypre_TFree(hypre_ParAMGDataPointDofMapArray(amg_data)[i], HYPRE_MEMORY_HOST);
714 hypre_TFree(hypre_ParAMGDataPointDofMapArray(amg_data), HYPRE_MEMORY_HOST);
715 hypre_ParAMGDataPointDofMapArray(amg_data) = NULL;
716 }
717
718 if (smooth_num_levels)
719 {
720 if (hypre_ParAMGDataSmoothType(amg_data) == 7 || hypre_ParAMGDataSmoothType(amg_data) == 17)
721 {
722 for (i=0; i < smooth_num_levels; i++)
723 {
724 HYPRE_ParCSRPilutDestroy(smoother[i]);
725 }
726 }
727 else if (hypre_ParAMGDataSmoothType(amg_data) == 8 || hypre_ParAMGDataSmoothType(amg_data) == 18)
728 {
729 for (i=0; i < smooth_num_levels; i++)
730 {
731 HYPRE_ParCSRParaSailsDestroy(smoother[i]);
732 }
733 }
734 else if (hypre_ParAMGDataSmoothType(amg_data) == 9 || hypre_ParAMGDataSmoothType(amg_data) == 19 )
735 {
736 for (i=0; i < smooth_num_levels; i++)
737 {
738 HYPRE_EuclidDestroy(smoother[i]);
739 }
740 }
741 else if (hypre_ParAMGDataSmoothType(amg_data) == 5 || hypre_ParAMGDataSmoothType(amg_data) == 15 )
742 {
743 for (i=0; i < smooth_num_levels; i++)
744 {
745 HYPRE_ILUDestroy(smoother[i]);
746 }
747 }
748 else if (hypre_ParAMGDataSmoothType(amg_data) == 6 || hypre_ParAMGDataSmoothType(amg_data) == 16)
749 {
750 for (i=0; i < smooth_num_levels; i++)
751 {
752 HYPRE_SchwarzDestroy(smoother[i]);
753 }
754 }
755 hypre_TFree(hypre_ParAMGDataSmoother(amg_data), HYPRE_MEMORY_HOST);
756 }
757 if ( hypre_ParAMGDataResidual(amg_data) ) {
758 /* jfp: was... hypre_TFree( hypre_ParAMGDataResidual(amg_data) );*/
759 hypre_ParVectorDestroy( hypre_ParAMGDataResidual(amg_data) );
760 hypre_ParAMGDataResidual(amg_data) = NULL;
761 }
762
763
764 if (hypre_ParAMGInterpVecVariant(amg_data) > 0
765 && hypre_ParAMGNumInterpVectors(amg_data) > 0)
766 {
767
768 HYPRE_Int j;
769 HYPRE_Int num_vecs = hypre_ParAMGNumInterpVectors(amg_data);
770 hypre_ParVector **sm_vecs;
771 HYPRE_Int num_il;
772 num_il = hypre_min(hypre_ParAMGNumLevelsInterpVectors(amg_data),num_levels);
773
774 /* don't destroy lev = 0 - this was user input */
775 for (i = 1; i< num_il; i++)
776 {
777 sm_vecs = hypre_ParAMGInterpVectorsArray(amg_data)[i];
778 for (j = 0; j< num_vecs; j++)
779 {
780 hypre_ParVectorDestroy(sm_vecs[j]);
781 }
782 hypre_TFree(sm_vecs, HYPRE_MEMORY_HOST);
783 }
784 hypre_TFree( hypre_ParAMGInterpVectorsArray(amg_data), HYPRE_MEMORY_HOST);
785
786 }
787
788 if (amg) hypre_BoomerAMGDestroy(amg);
789
790 if (hypre_ParAMGDataACoarse(amg_data))
791 hypre_ParCSRMatrixDestroy(hypre_ParAMGDataACoarse(amg_data));
792
793 if (hypre_ParAMGDataUCoarse(amg_data))
794 hypre_ParVectorDestroy(hypre_ParAMGDataUCoarse(amg_data));
795
796 if (hypre_ParAMGDataFCoarse(amg_data))
797 hypre_ParVectorDestroy(hypre_ParAMGDataFCoarse(amg_data));
798
799 /* destroy input CF_marker data */
800 if (hypre_ParAMGDataCPointsMarker(amg_data))
801 {
802 hypre_TFree(hypre_ParAMGDataCPointsMarker(amg_data), HYPRE_MEMORY_HOST);
803 }
804 if (hypre_ParAMGDataCPointsLocalMarker(amg_data))
805 {
806 hypre_TFree(hypre_ParAMGDataCPointsLocalMarker(amg_data), HYPRE_MEMORY_HOST);
807 }
808 if (hypre_ParAMGDataFPointsMarker(amg_data))
809 {
810 hypre_TFree(hypre_ParAMGDataFPointsMarker(amg_data), HYPRE_MEMORY_HOST);
811 }
812 if (hypre_ParAMGDataIsolatedFPointsMarker(amg_data))
813 {
814 hypre_TFree(hypre_ParAMGDataIsolatedFPointsMarker(amg_data), HYPRE_MEMORY_HOST);
815 }
816
817 if (hypre_ParAMGDataAMat(amg_data)) hypre_TFree(hypre_ParAMGDataAMat(amg_data), HYPRE_MEMORY_HOST);
818 if (hypre_ParAMGDataAInv(amg_data)) hypre_TFree(hypre_ParAMGDataAInv(amg_data), HYPRE_MEMORY_HOST);
819 if (hypre_ParAMGDataBVec(amg_data)) hypre_TFree(hypre_ParAMGDataBVec(amg_data), HYPRE_MEMORY_HOST);
820 if (hypre_ParAMGDataCommInfo(amg_data)) hypre_TFree(hypre_ParAMGDataCommInfo(amg_data), HYPRE_MEMORY_HOST);
821
822 if (new_comm != hypre_MPI_COMM_NULL)
823 {
824 hypre_MPI_Comm_free (&new_comm);
825 }
826
827 hypre_TFree(amg_data, HYPRE_MEMORY_HOST);
828
829 HYPRE_ANNOTATE_FUNC_END;
830
831 return hypre_error_flag;
832 }
833
834 /*--------------------------------------------------------------------------
835 * Routines to set the setup phase parameters
836 *--------------------------------------------------------------------------*/
837
838 HYPRE_Int
hypre_BoomerAMGSetRestriction(void * data,HYPRE_Int restr_par)839 hypre_BoomerAMGSetRestriction( void *data,
840 HYPRE_Int restr_par )
841 {
842 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
843
844 if (!amg_data)
845 {
846 hypre_error_in_arg(1);
847 return hypre_error_flag;
848 }
849
850 /* RL: currently, only 0: R = P^T
851 * 1: AIR
852 * 2: AIR-2
853 * 15: a special version of AIR-2 with less communication cost
854 * k(k>=3,k!=15): Neumann AIR of degree k-3
855 */
856 if (restr_par < 0)
857 {
858 hypre_error_in_arg(2);
859 return hypre_error_flag;
860 }
861
862 hypre_ParAMGDataRestriction(amg_data) = restr_par;
863
864 return hypre_error_flag;
865 }
866
867 HYPRE_Int
hypre_BoomerAMGSetIsTriangular(void * data,HYPRE_Int is_triangular)868 hypre_BoomerAMGSetIsTriangular(void *data,
869 HYPRE_Int is_triangular )
870 {
871 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
872
873 if (!amg_data)
874 {
875 hypre_error_in_arg(1);
876 return hypre_error_flag;
877 }
878
879 hypre_ParAMGDataIsTriangular(amg_data) = is_triangular;
880
881 return hypre_error_flag;
882 }
883
884 HYPRE_Int
hypre_BoomerAMGSetGMRESSwitchR(void * data,HYPRE_Int gmres_switch)885 hypre_BoomerAMGSetGMRESSwitchR(void *data,
886 HYPRE_Int gmres_switch )
887 {
888 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
889
890 if (!amg_data)
891 {
892 hypre_error_in_arg(1);
893 return hypre_error_flag;
894 }
895
896 hypre_ParAMGDataGMRESSwitchR(amg_data) = gmres_switch;
897
898 return hypre_error_flag;
899 }
900
901 HYPRE_Int
hypre_BoomerAMGSetMaxLevels(void * data,HYPRE_Int max_levels)902 hypre_BoomerAMGSetMaxLevels( void *data,
903 HYPRE_Int max_levels )
904 {
905 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
906 HYPRE_Int old_max_levels;
907 if (!amg_data)
908 {
909 hypre_error_in_arg(1);
910 return hypre_error_flag;
911 }
912
913 if (max_levels < 1)
914 {
915 hypre_error_in_arg(2);
916 return hypre_error_flag;
917 }
918
919 old_max_levels = hypre_ParAMGDataMaxLevels(amg_data);
920 if (old_max_levels < max_levels)
921 {
922 HYPRE_Real *relax_weight, *omega, *nongal_tol_array;
923 HYPRE_Real relax_wt, outer_wt, nongalerkin_tol;
924 HYPRE_Int i;
925 relax_weight = hypre_ParAMGDataRelaxWeight(amg_data);
926 if (relax_weight)
927 {
928 relax_wt = hypre_ParAMGDataUserRelaxWeight(amg_data);
929 relax_weight = hypre_TReAlloc(relax_weight, HYPRE_Real, max_levels, HYPRE_MEMORY_HOST);
930 for (i=old_max_levels; i < max_levels; i++)
931 relax_weight[i] = relax_wt;
932 hypre_ParAMGDataRelaxWeight(amg_data) = relax_weight;
933 }
934 omega = hypre_ParAMGDataOmega(amg_data);
935 if (omega)
936 {
937 outer_wt = hypre_ParAMGDataOuterWt(amg_data);
938 omega = hypre_TReAlloc(omega, HYPRE_Real, max_levels, HYPRE_MEMORY_HOST);
939 for (i=old_max_levels; i < max_levels; i++)
940 omega[i] = outer_wt;
941 hypre_ParAMGDataOmega(amg_data) = omega;
942 }
943 nongal_tol_array = hypre_ParAMGDataNonGalTolArray(amg_data);
944 if (nongal_tol_array)
945 {
946 nongalerkin_tol = hypre_ParAMGDataNonGalerkinTol(amg_data);
947 nongal_tol_array = hypre_TReAlloc(nongal_tol_array, HYPRE_Real, max_levels, HYPRE_MEMORY_HOST);
948 for (i=old_max_levels; i < max_levels; i++)
949 nongal_tol_array[i] = nongalerkin_tol;
950 hypre_ParAMGDataNonGalTolArray(amg_data) = nongal_tol_array;
951 }
952 }
953 hypre_ParAMGDataMaxLevels(amg_data) = max_levels;
954
955 return hypre_error_flag;
956 }
957
958 HYPRE_Int
hypre_BoomerAMGGetMaxLevels(void * data,HYPRE_Int * max_levels)959 hypre_BoomerAMGGetMaxLevels( void *data,
960 HYPRE_Int * max_levels )
961 {
962 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
963
964 if (!amg_data)
965 {
966 hypre_error_in_arg(1);
967 return hypre_error_flag;
968 }
969
970 *max_levels = hypre_ParAMGDataMaxLevels(amg_data);
971
972 return hypre_error_flag;
973 }
974
975 HYPRE_Int
hypre_BoomerAMGSetMaxCoarseSize(void * data,HYPRE_Int max_coarse_size)976 hypre_BoomerAMGSetMaxCoarseSize( void *data,
977 HYPRE_Int max_coarse_size )
978 {
979 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
980
981 if (!amg_data)
982 {
983 hypre_error_in_arg(1);
984 return hypre_error_flag;
985 }
986
987 if (max_coarse_size < 1)
988 {
989 hypre_error_in_arg(2);
990 return hypre_error_flag;
991 }
992
993 hypre_ParAMGDataMaxCoarseSize(amg_data) = max_coarse_size;
994
995 return hypre_error_flag;
996 }
997
998 HYPRE_Int
hypre_BoomerAMGGetMaxCoarseSize(void * data,HYPRE_Int * max_coarse_size)999 hypre_BoomerAMGGetMaxCoarseSize( void *data,
1000 HYPRE_Int * max_coarse_size )
1001 {
1002 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1003
1004 if (!amg_data)
1005 {
1006 hypre_error_in_arg(1);
1007 return hypre_error_flag;
1008 }
1009
1010 *max_coarse_size = hypre_ParAMGDataMaxCoarseSize(amg_data);
1011
1012 return hypre_error_flag;
1013 }
1014
1015 HYPRE_Int
hypre_BoomerAMGSetMinCoarseSize(void * data,HYPRE_Int min_coarse_size)1016 hypre_BoomerAMGSetMinCoarseSize( void *data,
1017 HYPRE_Int min_coarse_size )
1018 {
1019 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1020
1021 if (!amg_data)
1022 {
1023 hypre_error_in_arg(1);
1024 return hypre_error_flag;
1025 }
1026
1027 if (min_coarse_size < 0)
1028 {
1029 hypre_error_in_arg(2);
1030 return hypre_error_flag;
1031 }
1032
1033 hypre_ParAMGDataMinCoarseSize(amg_data) = min_coarse_size;
1034
1035 return hypre_error_flag;
1036 }
1037
1038 HYPRE_Int
hypre_BoomerAMGGetMinCoarseSize(void * data,HYPRE_Int * min_coarse_size)1039 hypre_BoomerAMGGetMinCoarseSize( void *data,
1040 HYPRE_Int * min_coarse_size )
1041 {
1042 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1043
1044 if (!amg_data)
1045 {
1046 hypre_error_in_arg(1);
1047 return hypre_error_flag;
1048 }
1049
1050 *min_coarse_size = hypre_ParAMGDataMinCoarseSize(amg_data);
1051
1052 return hypre_error_flag;
1053 }
1054
1055 HYPRE_Int
hypre_BoomerAMGSetSeqThreshold(void * data,HYPRE_Int seq_threshold)1056 hypre_BoomerAMGSetSeqThreshold( void *data,
1057 HYPRE_Int seq_threshold )
1058 {
1059 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1060
1061 if (!amg_data)
1062 {
1063 hypre_error_in_arg(1);
1064 return hypre_error_flag;
1065 }
1066
1067 if (seq_threshold < 0)
1068 {
1069 hypre_error_in_arg(2);
1070 return hypre_error_flag;
1071 }
1072
1073 hypre_ParAMGDataSeqThreshold(amg_data) = seq_threshold;
1074
1075 return hypre_error_flag;
1076 }
1077
1078 HYPRE_Int
hypre_BoomerAMGGetSeqThreshold(void * data,HYPRE_Int * seq_threshold)1079 hypre_BoomerAMGGetSeqThreshold( void *data,
1080 HYPRE_Int * seq_threshold )
1081 {
1082 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1083
1084 if (!amg_data)
1085 {
1086 hypre_error_in_arg(1);
1087 return hypre_error_flag;
1088 }
1089
1090 *seq_threshold = hypre_ParAMGDataSeqThreshold(amg_data);
1091
1092 return hypre_error_flag;
1093 }
1094
1095 HYPRE_Int
hypre_BoomerAMGSetRedundant(void * data,HYPRE_Int redundant)1096 hypre_BoomerAMGSetRedundant( void *data,
1097 HYPRE_Int redundant )
1098 {
1099 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1100
1101 if (!amg_data)
1102 {
1103 hypre_error_in_arg(1);
1104 return hypre_error_flag;
1105 }
1106
1107 if (redundant < 0)
1108 {
1109 hypre_error_in_arg(2);
1110 return hypre_error_flag;
1111 }
1112
1113 hypre_ParAMGDataRedundant(amg_data) = redundant;
1114
1115 return hypre_error_flag;
1116 }
1117
1118 HYPRE_Int
hypre_BoomerAMGGetRedundant(void * data,HYPRE_Int * redundant)1119 hypre_BoomerAMGGetRedundant( void *data,
1120 HYPRE_Int * redundant )
1121 {
1122 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1123
1124 if (!amg_data)
1125 {
1126 hypre_error_in_arg(1);
1127 return hypre_error_flag;
1128 }
1129
1130 *redundant = hypre_ParAMGDataRedundant(amg_data);
1131
1132 return hypre_error_flag;
1133 }
1134
1135 HYPRE_Int
hypre_BoomerAMGSetCoarsenCutFactor(void * data,HYPRE_Int coarsen_cut_factor)1136 hypre_BoomerAMGSetCoarsenCutFactor( void *data,
1137 HYPRE_Int coarsen_cut_factor )
1138 {
1139 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1140
1141 if (!amg_data)
1142 {
1143 hypre_error_in_arg(1);
1144 return hypre_error_flag;
1145 }
1146
1147 if (coarsen_cut_factor < 0)
1148 {
1149 hypre_error_in_arg(2);
1150 return hypre_error_flag;
1151 }
1152
1153 hypre_ParAMGDataCoarsenCutFactor(amg_data) = coarsen_cut_factor;
1154
1155 return hypre_error_flag;
1156 }
1157
1158 HYPRE_Int
hypre_BoomerAMGGetCoarsenCutFactor(void * data,HYPRE_Int * coarsen_cut_factor)1159 hypre_BoomerAMGGetCoarsenCutFactor( void *data,
1160 HYPRE_Int *coarsen_cut_factor )
1161 {
1162 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1163
1164 if (!amg_data)
1165 {
1166 hypre_error_in_arg(1);
1167 return hypre_error_flag;
1168 }
1169
1170 *coarsen_cut_factor = hypre_ParAMGDataCoarsenCutFactor(amg_data);
1171
1172 return hypre_error_flag;
1173 }
1174
1175 HYPRE_Int
hypre_BoomerAMGSetStrongThreshold(void * data,HYPRE_Real strong_threshold)1176 hypre_BoomerAMGSetStrongThreshold( void *data,
1177 HYPRE_Real strong_threshold )
1178 {
1179 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1180
1181 if (!amg_data)
1182 {
1183 hypre_error_in_arg(1);
1184 return hypre_error_flag;
1185 }
1186
1187 if (strong_threshold < 0 || strong_threshold > 1)
1188 {
1189 hypre_error_in_arg(2);
1190 return hypre_error_flag;
1191 }
1192
1193 hypre_ParAMGDataStrongThreshold(amg_data) = strong_threshold;
1194
1195 return hypre_error_flag;
1196 }
1197
1198 HYPRE_Int
hypre_BoomerAMGGetStrongThreshold(void * data,HYPRE_Real * strong_threshold)1199 hypre_BoomerAMGGetStrongThreshold( void *data,
1200 HYPRE_Real * strong_threshold )
1201 {
1202 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1203
1204 if (!amg_data)
1205 {
1206 hypre_error_in_arg(1);
1207 return hypre_error_flag;
1208 }
1209
1210 *strong_threshold = hypre_ParAMGDataStrongThreshold(amg_data);
1211
1212 return hypre_error_flag;
1213 }
1214
1215 HYPRE_Int
hypre_BoomerAMGSetStrongThresholdR(void * data,HYPRE_Real strong_threshold)1216 hypre_BoomerAMGSetStrongThresholdR( void *data,
1217 HYPRE_Real strong_threshold )
1218 {
1219 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1220
1221 if (!amg_data)
1222 {
1223 hypre_error_in_arg(1);
1224 return hypre_error_flag;
1225 }
1226
1227 if (strong_threshold < 0 || strong_threshold > 1)
1228 {
1229 hypre_error_in_arg(2);
1230 return hypre_error_flag;
1231 }
1232
1233 hypre_ParAMGDataStrongThresholdR(amg_data) = strong_threshold;
1234
1235 return hypre_error_flag;
1236 }
1237
1238 HYPRE_Int
hypre_BoomerAMGGetStrongThresholdR(void * data,HYPRE_Real * strong_threshold)1239 hypre_BoomerAMGGetStrongThresholdR( void *data,
1240 HYPRE_Real *strong_threshold )
1241 {
1242 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1243
1244 if (!amg_data)
1245 {
1246 hypre_error_in_arg(1);
1247 return hypre_error_flag;
1248 }
1249
1250 *strong_threshold = hypre_ParAMGDataStrongThresholdR(amg_data);
1251
1252 return hypre_error_flag;
1253 }
1254
1255 HYPRE_Int
hypre_BoomerAMGSetFilterThresholdR(void * data,HYPRE_Real filter_threshold)1256 hypre_BoomerAMGSetFilterThresholdR( void *data,
1257 HYPRE_Real filter_threshold )
1258 {
1259 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1260
1261 if (!amg_data)
1262 {
1263 hypre_error_in_arg(1);
1264 return hypre_error_flag;
1265 }
1266
1267 if (filter_threshold < 0 || filter_threshold > 1)
1268 {
1269 hypre_error_in_arg(2);
1270 return hypre_error_flag;
1271 }
1272
1273 hypre_ParAMGDataFilterThresholdR(amg_data) = filter_threshold;
1274
1275 return hypre_error_flag;
1276 }
1277
1278 HYPRE_Int
hypre_BoomerAMGGetFilterThresholdR(void * data,HYPRE_Real * filter_threshold)1279 hypre_BoomerAMGGetFilterThresholdR( void *data,
1280 HYPRE_Real *filter_threshold )
1281 {
1282 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1283
1284 if (!amg_data)
1285 {
1286 hypre_error_in_arg(1);
1287 return hypre_error_flag;
1288 }
1289
1290 *filter_threshold = hypre_ParAMGDataFilterThresholdR(amg_data);
1291
1292 return hypre_error_flag;
1293 }
1294
1295 HYPRE_Int
hypre_BoomerAMGSetSabs(void * data,HYPRE_Int Sabs)1296 hypre_BoomerAMGSetSabs( void *data,
1297 HYPRE_Int Sabs )
1298 {
1299 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1300
1301 if (!amg_data)
1302 {
1303 hypre_error_in_arg(1);
1304 return hypre_error_flag;
1305 }
1306
1307 hypre_ParAMGDataSabs(amg_data) = Sabs != 0;
1308
1309 return hypre_error_flag;
1310 }
1311
1312 HYPRE_Int
hypre_BoomerAMGSetMaxRowSum(void * data,HYPRE_Real max_row_sum)1313 hypre_BoomerAMGSetMaxRowSum( void *data,
1314 HYPRE_Real max_row_sum )
1315 {
1316 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1317
1318 if (!amg_data)
1319 {
1320 hypre_error_in_arg(1);
1321 return hypre_error_flag;
1322 }
1323
1324 if (max_row_sum <= 0 || max_row_sum > 1)
1325 {
1326 hypre_error_in_arg(2);
1327 return hypre_error_flag;
1328 }
1329
1330 hypre_ParAMGDataMaxRowSum(amg_data) = max_row_sum;
1331
1332 return hypre_error_flag;
1333 }
1334
1335 HYPRE_Int
hypre_BoomerAMGGetMaxRowSum(void * data,HYPRE_Real * max_row_sum)1336 hypre_BoomerAMGGetMaxRowSum( void *data,
1337 HYPRE_Real * max_row_sum )
1338 {
1339 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1340
1341 if (!amg_data)
1342 {
1343 hypre_error_in_arg(1);
1344 return hypre_error_flag;
1345 }
1346
1347 *max_row_sum = hypre_ParAMGDataMaxRowSum(amg_data);
1348
1349 return hypre_error_flag;
1350 }
1351
1352 HYPRE_Int
hypre_BoomerAMGSetTruncFactor(void * data,HYPRE_Real trunc_factor)1353 hypre_BoomerAMGSetTruncFactor( void *data,
1354 HYPRE_Real trunc_factor )
1355 {
1356 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1357
1358 if (!amg_data)
1359 {
1360 hypre_error_in_arg(1);
1361 return hypre_error_flag;
1362 }
1363
1364 if (trunc_factor < 0 || trunc_factor >= 1)
1365 {
1366 hypre_error_in_arg(2);
1367 return hypre_error_flag;
1368 }
1369
1370 hypre_ParAMGDataTruncFactor(amg_data) = trunc_factor;
1371
1372 return hypre_error_flag;
1373 }
1374
1375 HYPRE_Int
hypre_BoomerAMGGetTruncFactor(void * data,HYPRE_Real * trunc_factor)1376 hypre_BoomerAMGGetTruncFactor( void *data,
1377 HYPRE_Real * trunc_factor )
1378 {
1379 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1380
1381 if (!amg_data)
1382 {
1383 hypre_error_in_arg(1);
1384 return hypre_error_flag;
1385 }
1386
1387 *trunc_factor = hypre_ParAMGDataTruncFactor(amg_data);
1388
1389 return hypre_error_flag;
1390 }
1391
1392 HYPRE_Int
hypre_BoomerAMGSetPMaxElmts(void * data,HYPRE_Int P_max_elmts)1393 hypre_BoomerAMGSetPMaxElmts( void *data,
1394 HYPRE_Int P_max_elmts )
1395 {
1396 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1397
1398 if (!amg_data)
1399 {
1400 hypre_error_in_arg(1);
1401 return hypre_error_flag;
1402 }
1403
1404 if (P_max_elmts < 0)
1405 {
1406 hypre_error_in_arg(2);
1407 return hypre_error_flag;
1408 }
1409
1410 hypre_ParAMGDataPMaxElmts(amg_data) = P_max_elmts;
1411
1412 return hypre_error_flag;
1413 }
1414
1415 HYPRE_Int
hypre_BoomerAMGGetPMaxElmts(void * data,HYPRE_Int * P_max_elmts)1416 hypre_BoomerAMGGetPMaxElmts( void *data,
1417 HYPRE_Int * P_max_elmts )
1418 {
1419 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1420
1421 if (!amg_data)
1422 {
1423 hypre_error_in_arg(1);
1424 return hypre_error_flag;
1425 }
1426
1427 *P_max_elmts = hypre_ParAMGDataPMaxElmts(amg_data);
1428
1429 return hypre_error_flag;
1430 }
1431
1432 HYPRE_Int
hypre_BoomerAMGSetJacobiTruncThreshold(void * data,HYPRE_Real jacobi_trunc_threshold)1433 hypre_BoomerAMGSetJacobiTruncThreshold( void *data,
1434 HYPRE_Real jacobi_trunc_threshold )
1435 {
1436 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1437
1438 if (!amg_data)
1439 {
1440 hypre_error_in_arg(1);
1441 return hypre_error_flag;
1442 }
1443
1444 if (jacobi_trunc_threshold < 0 || jacobi_trunc_threshold >= 1)
1445 {
1446 hypre_error_in_arg(2);
1447 return hypre_error_flag;
1448 }
1449
1450 hypre_ParAMGDataJacobiTruncThreshold(amg_data) = jacobi_trunc_threshold;
1451
1452 return hypre_error_flag;
1453 }
1454
1455 HYPRE_Int
hypre_BoomerAMGGetJacobiTruncThreshold(void * data,HYPRE_Real * jacobi_trunc_threshold)1456 hypre_BoomerAMGGetJacobiTruncThreshold( void *data,
1457 HYPRE_Real * jacobi_trunc_threshold )
1458 {
1459 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1460
1461 if (!amg_data)
1462 {
1463 hypre_error_in_arg(1);
1464 return hypre_error_flag;
1465 }
1466
1467 *jacobi_trunc_threshold = hypre_ParAMGDataJacobiTruncThreshold(amg_data);
1468
1469 return hypre_error_flag;
1470 }
1471
1472 HYPRE_Int
hypre_BoomerAMGSetPostInterpType(void * data,HYPRE_Int post_interp_type)1473 hypre_BoomerAMGSetPostInterpType( void *data,
1474 HYPRE_Int post_interp_type )
1475 {
1476 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1477
1478 if (!amg_data)
1479 {
1480 hypre_error_in_arg(1);
1481 return hypre_error_flag;
1482 }
1483
1484 if (post_interp_type < 0)
1485 {
1486 hypre_error_in_arg(2);
1487 return hypre_error_flag;
1488 }
1489
1490 hypre_ParAMGDataPostInterpType(amg_data) = post_interp_type;
1491
1492 return hypre_error_flag;
1493 }
1494
1495 HYPRE_Int
hypre_BoomerAMGGetPostInterpType(void * data,HYPRE_Int * post_interp_type)1496 hypre_BoomerAMGGetPostInterpType( void *data,
1497 HYPRE_Int * post_interp_type )
1498 {
1499 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1500
1501 if (!amg_data)
1502 {
1503 hypre_error_in_arg(1);
1504 return hypre_error_flag;
1505 }
1506
1507 *post_interp_type = hypre_ParAMGDataPostInterpType(amg_data);
1508
1509 return hypre_error_flag;
1510 }
1511
1512 HYPRE_Int
hypre_BoomerAMGSetInterpType(void * data,HYPRE_Int interp_type)1513 hypre_BoomerAMGSetInterpType( void *data,
1514 HYPRE_Int interp_type )
1515 {
1516 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1517
1518 if (!amg_data)
1519 {
1520 hypre_error_in_arg(1);
1521 return hypre_error_flag;
1522 }
1523
1524
1525 if ((interp_type < 0 || interp_type > 25) && interp_type != 100)
1526
1527 {
1528 hypre_error_in_arg(2);
1529 return hypre_error_flag;
1530 }
1531
1532 hypre_ParAMGDataInterpType(amg_data) = interp_type;
1533
1534 return hypre_error_flag;
1535 }
1536
1537 HYPRE_Int
hypre_BoomerAMGGetInterpType(void * data,HYPRE_Int * interp_type)1538 hypre_BoomerAMGGetInterpType( void *data,
1539 HYPRE_Int * interp_type )
1540 {
1541 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1542
1543 if (!amg_data)
1544 {
1545 hypre_error_in_arg(1);
1546 return hypre_error_flag;
1547 }
1548
1549 *interp_type = hypre_ParAMGDataInterpType(amg_data);
1550
1551 return hypre_error_flag;
1552 }
1553
1554 HYPRE_Int
hypre_BoomerAMGSetSepWeight(void * data,HYPRE_Int sep_weight)1555 hypre_BoomerAMGSetSepWeight( void *data,
1556 HYPRE_Int sep_weight )
1557 {
1558 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1559
1560 if (!amg_data)
1561 {
1562 hypre_error_in_arg(1);
1563 return hypre_error_flag;
1564 }
1565
1566 hypre_ParAMGDataSepWeight(amg_data) = sep_weight;
1567
1568 return hypre_error_flag;
1569 }
1570
1571 HYPRE_Int
hypre_BoomerAMGSetMinIter(void * data,HYPRE_Int min_iter)1572 hypre_BoomerAMGSetMinIter( void *data,
1573 HYPRE_Int min_iter )
1574 {
1575 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1576
1577 if (!amg_data)
1578 {
1579 hypre_error_in_arg(1);
1580 return hypre_error_flag;
1581 }
1582
1583 hypre_ParAMGDataMinIter(amg_data) = min_iter;
1584
1585 return hypre_error_flag;
1586 }
1587
1588 HYPRE_Int
hypre_BoomerAMGGetMinIter(void * data,HYPRE_Int * min_iter)1589 hypre_BoomerAMGGetMinIter( void *data,
1590 HYPRE_Int * min_iter )
1591 {
1592 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1593
1594 if (!amg_data)
1595 {
1596 hypre_error_in_arg(1);
1597 return hypre_error_flag;
1598 }
1599
1600 *min_iter = hypre_ParAMGDataMinIter(amg_data);
1601
1602 return hypre_error_flag;
1603 }
1604
1605 HYPRE_Int
hypre_BoomerAMGSetMaxIter(void * data,HYPRE_Int max_iter)1606 hypre_BoomerAMGSetMaxIter( void *data,
1607 HYPRE_Int max_iter )
1608 {
1609 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1610
1611 if (!amg_data)
1612 {
1613 hypre_error_in_arg(1);
1614 return hypre_error_flag;
1615 }
1616
1617 if (max_iter < 0)
1618 {
1619 hypre_error_in_arg(2);
1620 return hypre_error_flag;
1621 }
1622
1623 hypre_ParAMGDataMaxIter(amg_data) = max_iter;
1624
1625 return hypre_error_flag;
1626 }
1627
1628 HYPRE_Int
hypre_BoomerAMGGetMaxIter(void * data,HYPRE_Int * max_iter)1629 hypre_BoomerAMGGetMaxIter( void *data,
1630 HYPRE_Int * max_iter )
1631 {
1632 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1633
1634 if (!amg_data)
1635 {
1636 hypre_error_in_arg(1);
1637 return hypre_error_flag;
1638 }
1639
1640 *max_iter = hypre_ParAMGDataMaxIter(amg_data);
1641
1642 return hypre_error_flag;
1643 }
1644
1645 HYPRE_Int
hypre_BoomerAMGSetCoarsenType(void * data,HYPRE_Int coarsen_type)1646 hypre_BoomerAMGSetCoarsenType( void *data,
1647 HYPRE_Int coarsen_type )
1648 {
1649 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1650
1651 if (!amg_data)
1652 {
1653 hypre_error_in_arg(1);
1654 return hypre_error_flag;
1655 }
1656
1657 hypre_ParAMGDataCoarsenType(amg_data) = coarsen_type;
1658
1659 return hypre_error_flag;
1660 }
1661
1662 HYPRE_Int
hypre_BoomerAMGGetCoarsenType(void * data,HYPRE_Int * coarsen_type)1663 hypre_BoomerAMGGetCoarsenType( void *data,
1664 HYPRE_Int * coarsen_type )
1665 {
1666 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1667
1668 if (!amg_data)
1669 {
1670 hypre_error_in_arg(1);
1671 return hypre_error_flag;
1672 }
1673
1674 *coarsen_type = hypre_ParAMGDataCoarsenType(amg_data);
1675
1676 return hypre_error_flag;
1677 }
1678
1679 HYPRE_Int
hypre_BoomerAMGSetMeasureType(void * data,HYPRE_Int measure_type)1680 hypre_BoomerAMGSetMeasureType( void *data,
1681 HYPRE_Int measure_type )
1682 {
1683 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1684
1685 if (!amg_data)
1686 {
1687 hypre_error_in_arg(1);
1688 return hypre_error_flag;
1689 }
1690
1691 hypre_ParAMGDataMeasureType(amg_data) = measure_type;
1692
1693 return hypre_error_flag;
1694 }
1695
1696 HYPRE_Int
hypre_BoomerAMGGetMeasureType(void * data,HYPRE_Int * measure_type)1697 hypre_BoomerAMGGetMeasureType( void *data,
1698 HYPRE_Int * measure_type )
1699 {
1700 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1701
1702 if (!amg_data)
1703 {
1704 hypre_error_in_arg(1);
1705 return hypre_error_flag;
1706 }
1707
1708 *measure_type = hypre_ParAMGDataMeasureType(amg_data);
1709
1710 return hypre_error_flag;
1711 }
1712
1713 HYPRE_Int
hypre_BoomerAMGSetSetupType(void * data,HYPRE_Int setup_type)1714 hypre_BoomerAMGSetSetupType( void *data,
1715 HYPRE_Int setup_type )
1716 {
1717 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1718
1719 if (!amg_data)
1720 {
1721 hypre_error_in_arg(1);
1722 return hypre_error_flag;
1723 }
1724
1725 hypre_ParAMGDataSetupType(amg_data) = setup_type;
1726
1727 return hypre_error_flag;
1728 }
1729
1730 HYPRE_Int
hypre_BoomerAMGGetSetupType(void * data,HYPRE_Int * setup_type)1731 hypre_BoomerAMGGetSetupType( void *data,
1732 HYPRE_Int * setup_type )
1733 {
1734 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1735
1736 if (!amg_data)
1737 {
1738 hypre_error_in_arg(1);
1739 return hypre_error_flag;
1740 }
1741
1742 *setup_type = hypre_ParAMGDataSetupType(amg_data);
1743
1744 return hypre_error_flag;
1745 }
1746
1747 HYPRE_Int
hypre_BoomerAMGSetCycleType(void * data,HYPRE_Int cycle_type)1748 hypre_BoomerAMGSetCycleType( void *data,
1749 HYPRE_Int cycle_type )
1750 {
1751 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1752
1753 if (!amg_data)
1754 {
1755 hypre_error_in_arg(1);
1756 return hypre_error_flag;
1757 }
1758
1759 if (cycle_type < 0 || cycle_type > 2)
1760 {
1761 hypre_error_in_arg(2);
1762 return hypre_error_flag;
1763 }
1764
1765 hypre_ParAMGDataCycleType(amg_data) = cycle_type;
1766
1767 return hypre_error_flag;
1768 }
1769
1770 HYPRE_Int
hypre_BoomerAMGGetCycleType(void * data,HYPRE_Int * cycle_type)1771 hypre_BoomerAMGGetCycleType( void *data,
1772 HYPRE_Int * cycle_type )
1773 {
1774 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1775
1776 if (!amg_data)
1777 {
1778 hypre_error_in_arg(1);
1779 return hypre_error_flag;
1780 }
1781
1782 *cycle_type = hypre_ParAMGDataCycleType(amg_data);
1783
1784 return hypre_error_flag;
1785 }
1786
1787 HYPRE_Int
hypre_BoomerAMGSetFCycle(void * data,HYPRE_Int fcycle)1788 hypre_BoomerAMGSetFCycle( void *data,
1789 HYPRE_Int fcycle )
1790 {
1791 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1792
1793 if (!amg_data)
1794 {
1795 hypre_error_in_arg(1);
1796 return hypre_error_flag;
1797 }
1798
1799 hypre_ParAMGDataFCycle(amg_data) = fcycle != 0;
1800
1801 return hypre_error_flag;
1802 }
1803
1804 HYPRE_Int
hypre_BoomerAMGGetFCycle(void * data,HYPRE_Int * fcycle)1805 hypre_BoomerAMGGetFCycle( void *data,
1806 HYPRE_Int *fcycle )
1807 {
1808 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1809
1810 if (!amg_data)
1811 {
1812 hypre_error_in_arg(1);
1813 return hypre_error_flag;
1814 }
1815
1816 *fcycle = hypre_ParAMGDataFCycle(amg_data);
1817
1818 return hypre_error_flag;
1819 }
1820
1821 HYPRE_Int
hypre_BoomerAMGSetConvergeType(void * data,HYPRE_Int type)1822 hypre_BoomerAMGSetConvergeType( void *data,
1823 HYPRE_Int type )
1824 {
1825 /* type 0: default. relative over ||b||
1826 * 1: relative over ||r0||
1827 */
1828 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1829
1830 if (!amg_data)
1831 {
1832 hypre_error_in_arg(1);
1833 return hypre_error_flag;
1834 }
1835
1836 /*
1837 if ()
1838 {
1839 hypre_error_in_arg(2);
1840 return hypre_error_flag;
1841 }
1842 */
1843
1844 hypre_ParAMGDataConvergeType(amg_data) = type;
1845
1846 return hypre_error_flag;
1847 }
1848
1849 HYPRE_Int
hypre_BoomerAMGGetConvergeType(void * data,HYPRE_Int * type)1850 hypre_BoomerAMGGetConvergeType( void *data,
1851 HYPRE_Int *type )
1852 {
1853 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1854
1855 if (!amg_data)
1856 {
1857 hypre_error_in_arg(1);
1858 return hypre_error_flag;
1859 }
1860
1861 *type = hypre_ParAMGDataConvergeType(amg_data);
1862
1863 return hypre_error_flag;
1864 }
1865
1866 HYPRE_Int
hypre_BoomerAMGSetTol(void * data,HYPRE_Real tol)1867 hypre_BoomerAMGSetTol( void *data,
1868 HYPRE_Real tol )
1869 {
1870 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1871
1872 if (!amg_data)
1873 {
1874 hypre_error_in_arg(1);
1875 return hypre_error_flag;
1876 }
1877
1878 if (tol < 0 || tol > 1)
1879 {
1880 hypre_error_in_arg(2);
1881 return hypre_error_flag;
1882 }
1883
1884 hypre_ParAMGDataTol(amg_data) = tol;
1885
1886 return hypre_error_flag;
1887 }
1888
1889 HYPRE_Int
hypre_BoomerAMGGetTol(void * data,HYPRE_Real * tol)1890 hypre_BoomerAMGGetTol( void *data,
1891 HYPRE_Real * tol )
1892 {
1893 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1894
1895 if (!amg_data)
1896 {
1897 hypre_error_in_arg(1);
1898 return hypre_error_flag;
1899 }
1900
1901 *tol = hypre_ParAMGDataTol(amg_data);
1902
1903 return hypre_error_flag;
1904 }
1905
1906 /* The "Get" function for SetNumSweeps is GetCycleNumSweeps. */
1907 HYPRE_Int
hypre_BoomerAMGSetNumSweeps(void * data,HYPRE_Int num_sweeps)1908 hypre_BoomerAMGSetNumSweeps( void *data,
1909 HYPRE_Int num_sweeps )
1910 {
1911 HYPRE_Int i;
1912 HYPRE_Int *num_grid_sweeps;
1913 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1914
1915 if (!amg_data)
1916 {
1917 hypre_error_in_arg(1);
1918 return hypre_error_flag;
1919 }
1920
1921 if (num_sweeps < 1)
1922 {
1923 hypre_error_in_arg(2);
1924 return hypre_error_flag;
1925 }
1926
1927 if (hypre_ParAMGDataNumGridSweeps(amg_data) == NULL)
1928 hypre_ParAMGDataNumGridSweeps(amg_data) = hypre_CTAlloc(HYPRE_Int, 4, HYPRE_MEMORY_HOST);
1929
1930 num_grid_sweeps = hypre_ParAMGDataNumGridSweeps(amg_data);
1931
1932 for (i=0; i < 3; i++)
1933 num_grid_sweeps[i] = num_sweeps;
1934 num_grid_sweeps[3] = 1;
1935
1936 hypre_ParAMGDataUserNumSweeps(amg_data) = num_sweeps;
1937
1938 return hypre_error_flag;
1939 }
1940
1941 HYPRE_Int
hypre_BoomerAMGSetCycleNumSweeps(void * data,HYPRE_Int num_sweeps,HYPRE_Int k)1942 hypre_BoomerAMGSetCycleNumSweeps( void *data,
1943 HYPRE_Int num_sweeps,
1944 HYPRE_Int k )
1945 {
1946 HYPRE_Int i;
1947 HYPRE_Int *num_grid_sweeps;
1948 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1949
1950 if (!amg_data)
1951 {
1952 hypre_error_in_arg(1);
1953 return hypre_error_flag;
1954 }
1955
1956 if (num_sweeps < 0)
1957 {
1958 hypre_error_in_arg(2);
1959 return hypre_error_flag;
1960 }
1961
1962 if (k < 1 || k > 3)
1963 {
1964 hypre_error_in_arg(3);
1965 return hypre_error_flag;
1966 }
1967
1968 if (hypre_ParAMGDataNumGridSweeps(amg_data) == NULL)
1969 {
1970 num_grid_sweeps = hypre_CTAlloc(HYPRE_Int, 4, HYPRE_MEMORY_HOST);
1971 for (i=0; i < 4; i++)
1972 num_grid_sweeps[i] = 1;
1973 hypre_ParAMGDataNumGridSweeps(amg_data) = num_grid_sweeps;
1974 }
1975
1976 hypre_ParAMGDataNumGridSweeps(amg_data)[k] = num_sweeps;
1977
1978 return hypre_error_flag;
1979 }
1980
1981 HYPRE_Int
hypre_BoomerAMGGetCycleNumSweeps(void * data,HYPRE_Int * num_sweeps,HYPRE_Int k)1982 hypre_BoomerAMGGetCycleNumSweeps( void *data,
1983 HYPRE_Int * num_sweeps,
1984 HYPRE_Int k )
1985 {
1986 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
1987
1988 if (!amg_data)
1989 {
1990 hypre_error_in_arg(1);
1991 return hypre_error_flag;
1992 }
1993 if (k < 1 || k > 3)
1994 {
1995 hypre_error_in_arg(3);
1996 return hypre_error_flag;
1997 }
1998
1999 if (hypre_ParAMGDataNumGridSweeps(amg_data) == NULL)
2000 {
2001 hypre_error_in_arg(1);
2002 return hypre_error_flag;
2003 }
2004
2005 *num_sweeps = hypre_ParAMGDataNumGridSweeps(amg_data)[k];
2006
2007 return hypre_error_flag;
2008 }
2009
2010 HYPRE_Int
hypre_BoomerAMGSetNumGridSweeps(void * data,HYPRE_Int * num_grid_sweeps)2011 hypre_BoomerAMGSetNumGridSweeps( void *data,
2012 HYPRE_Int *num_grid_sweeps )
2013 {
2014 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2015
2016 if (!amg_data)
2017 {
2018 hypre_error_in_arg(1);
2019 return hypre_error_flag;
2020 }
2021 if (!num_grid_sweeps)
2022 {
2023 hypre_error_in_arg(2);
2024 return hypre_error_flag;
2025 }
2026
2027 if (hypre_ParAMGDataNumGridSweeps(amg_data))
2028 hypre_TFree(hypre_ParAMGDataNumGridSweeps(amg_data), HYPRE_MEMORY_HOST);
2029 hypre_ParAMGDataNumGridSweeps(amg_data) = num_grid_sweeps;
2030
2031 return hypre_error_flag;
2032 }
2033
2034 HYPRE_Int
hypre_BoomerAMGGetNumGridSweeps(void * data,HYPRE_Int ** num_grid_sweeps)2035 hypre_BoomerAMGGetNumGridSweeps( void *data,
2036 HYPRE_Int ** num_grid_sweeps )
2037 {
2038 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2039
2040 if (!amg_data)
2041 {
2042 hypre_error_in_arg(1);
2043 return hypre_error_flag;
2044 }
2045 *num_grid_sweeps = hypre_ParAMGDataNumGridSweeps(amg_data);
2046
2047 return hypre_error_flag;
2048 }
2049
2050 /* The "Get" function for SetRelaxType is GetCycleRelaxType. */
2051 HYPRE_Int
hypre_BoomerAMGSetRelaxType(void * data,HYPRE_Int relax_type)2052 hypre_BoomerAMGSetRelaxType( void *data,
2053 HYPRE_Int relax_type )
2054 {
2055 HYPRE_Int i;
2056 HYPRE_Int *grid_relax_type;
2057 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2058
2059 if (!amg_data)
2060 {
2061 hypre_error_in_arg(1);
2062 return hypre_error_flag;
2063 }
2064 if (relax_type < 0)
2065 {
2066 hypre_error_in_arg(2);
2067 return hypre_error_flag;
2068 }
2069
2070 if (hypre_ParAMGDataGridRelaxType(amg_data) == NULL)
2071 hypre_ParAMGDataGridRelaxType(amg_data) = hypre_CTAlloc(HYPRE_Int, 4, HYPRE_MEMORY_HOST);
2072 grid_relax_type = hypre_ParAMGDataGridRelaxType(amg_data);
2073
2074 for (i=0; i < 3; i++)
2075 grid_relax_type[i] = relax_type;
2076 grid_relax_type[3] = 9;
2077 hypre_ParAMGDataUserCoarseRelaxType(amg_data) = 9;
2078 hypre_ParAMGDataUserRelaxType(amg_data) = relax_type;
2079
2080 return hypre_error_flag;
2081 }
2082
2083 HYPRE_Int
hypre_BoomerAMGSetCycleRelaxType(void * data,HYPRE_Int relax_type,HYPRE_Int k)2084 hypre_BoomerAMGSetCycleRelaxType( void *data,
2085 HYPRE_Int relax_type,
2086 HYPRE_Int k )
2087 {
2088 HYPRE_Int i;
2089 HYPRE_Int *grid_relax_type;
2090 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2091
2092 if (!amg_data)
2093 {
2094 hypre_error_in_arg(1);
2095 return hypre_error_flag;
2096 }
2097 if (k < 1 || k > 3)
2098 {
2099 hypre_error_in_arg(3);
2100 return hypre_error_flag;
2101 }
2102 if (relax_type < 0)
2103 {
2104 hypre_error_in_arg(2);
2105 return hypre_error_flag;
2106 }
2107
2108 if (hypre_ParAMGDataGridRelaxType(amg_data) == NULL)
2109 {
2110 grid_relax_type = hypre_CTAlloc(HYPRE_Int, 4, HYPRE_MEMORY_HOST);
2111 for (i=0; i < 3; i++)
2112 {
2113 grid_relax_type[i] = 3;
2114 }
2115 grid_relax_type[3] = 9;
2116 hypre_ParAMGDataGridRelaxType(amg_data) = grid_relax_type;
2117 }
2118
2119 hypre_ParAMGDataGridRelaxType(amg_data)[k] = relax_type;
2120 if (k == 3)
2121 {
2122 hypre_ParAMGDataUserCoarseRelaxType(amg_data) = relax_type;
2123 }
2124
2125 return hypre_error_flag;
2126 }
2127
2128 HYPRE_Int
hypre_BoomerAMGGetCycleRelaxType(void * data,HYPRE_Int * relax_type,HYPRE_Int k)2129 hypre_BoomerAMGGetCycleRelaxType( void *data,
2130 HYPRE_Int * relax_type,
2131 HYPRE_Int k )
2132 {
2133 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2134
2135 if (!amg_data)
2136 {
2137 hypre_error_in_arg(1);
2138 return hypre_error_flag;
2139 }
2140 if (k < 1 || k > 3)
2141 {
2142 hypre_error_in_arg(3);
2143 return hypre_error_flag;
2144 }
2145
2146 if (hypre_ParAMGDataGridRelaxType(amg_data) == NULL)
2147 {
2148 hypre_error_in_arg(1);
2149 return hypre_error_flag;
2150 }
2151
2152 *relax_type = hypre_ParAMGDataGridRelaxType(amg_data)[k];
2153
2154 return hypre_error_flag;
2155 }
2156
2157 HYPRE_Int
hypre_BoomerAMGSetRelaxOrder(void * data,HYPRE_Int relax_order)2158 hypre_BoomerAMGSetRelaxOrder( void *data,
2159 HYPRE_Int relax_order)
2160 {
2161 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2162
2163 if (!amg_data)
2164 {
2165 hypre_error_in_arg(1);
2166 return hypre_error_flag;
2167 }
2168 hypre_ParAMGDataRelaxOrder(amg_data) = relax_order;
2169
2170 return hypre_error_flag;
2171 }
2172
2173 HYPRE_Int
hypre_BoomerAMGGetRelaxOrder(void * data,HYPRE_Int * relax_order)2174 hypre_BoomerAMGGetRelaxOrder( void *data,
2175 HYPRE_Int * relax_order)
2176 {
2177 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2178
2179 if (!amg_data)
2180 {
2181 hypre_error_in_arg(1);
2182 return hypre_error_flag;
2183 }
2184 *relax_order = hypre_ParAMGDataRelaxOrder(amg_data);
2185
2186 return hypre_error_flag;
2187 }
2188
2189 HYPRE_Int
hypre_BoomerAMGSetGridRelaxType(void * data,HYPRE_Int * grid_relax_type)2190 hypre_BoomerAMGSetGridRelaxType( void *data,
2191 HYPRE_Int *grid_relax_type )
2192 {
2193 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2194
2195 if (!amg_data)
2196 {
2197 hypre_error_in_arg(1);
2198 return hypre_error_flag;
2199 }
2200 if (!grid_relax_type)
2201 {
2202 hypre_error_in_arg(2);
2203 return hypre_error_flag;
2204 }
2205
2206 if (hypre_ParAMGDataGridRelaxType(amg_data))
2207 hypre_TFree(hypre_ParAMGDataGridRelaxType(amg_data), HYPRE_MEMORY_HOST);
2208 hypre_ParAMGDataGridRelaxType(amg_data) = grid_relax_type;
2209 hypre_ParAMGDataUserCoarseRelaxType(amg_data) = grid_relax_type[3];
2210
2211 return hypre_error_flag;
2212 }
2213
2214 HYPRE_Int
hypre_BoomerAMGGetGridRelaxType(void * data,HYPRE_Int ** grid_relax_type)2215 hypre_BoomerAMGGetGridRelaxType( void *data,
2216 HYPRE_Int ** grid_relax_type )
2217 {
2218 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2219
2220 if (!amg_data)
2221 {
2222 hypre_error_in_arg(1);
2223 return hypre_error_flag;
2224 }
2225 *grid_relax_type = hypre_ParAMGDataGridRelaxType(amg_data);
2226
2227 return hypre_error_flag;
2228 }
2229
2230 HYPRE_Int
hypre_BoomerAMGSetGridRelaxPoints(void * data,HYPRE_Int ** grid_relax_points)2231 hypre_BoomerAMGSetGridRelaxPoints( void *data,
2232 HYPRE_Int **grid_relax_points )
2233 {
2234 HYPRE_Int i;
2235 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2236
2237 if (!amg_data)
2238 {
2239 hypre_error_in_arg(1);
2240 return hypre_error_flag;
2241 }
2242 if (!grid_relax_points)
2243 {
2244 hypre_error_in_arg(2);
2245 return hypre_error_flag;
2246 }
2247
2248 if (hypre_ParAMGDataGridRelaxPoints(amg_data))
2249 {
2250 for (i=0; i < 4; i++)
2251 hypre_TFree(hypre_ParAMGDataGridRelaxPoints(amg_data)[i], HYPRE_MEMORY_HOST);
2252 hypre_TFree(hypre_ParAMGDataGridRelaxPoints(amg_data), HYPRE_MEMORY_HOST);
2253 }
2254 hypre_ParAMGDataGridRelaxPoints(amg_data) = grid_relax_points;
2255
2256 return hypre_error_flag;
2257 }
2258
2259 HYPRE_Int
hypre_BoomerAMGGetGridRelaxPoints(void * data,HYPRE_Int *** grid_relax_points)2260 hypre_BoomerAMGGetGridRelaxPoints( void *data,
2261 HYPRE_Int *** grid_relax_points )
2262 {
2263 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2264
2265 if (!amg_data)
2266 {
2267 hypre_error_in_arg(1);
2268 return hypre_error_flag;
2269 }
2270 *grid_relax_points = hypre_ParAMGDataGridRelaxPoints(amg_data);
2271
2272 return hypre_error_flag;
2273 }
2274
2275 HYPRE_Int
hypre_BoomerAMGSetRelaxWeight(void * data,HYPRE_Real * relax_weight)2276 hypre_BoomerAMGSetRelaxWeight( void *data,
2277 HYPRE_Real *relax_weight )
2278 {
2279 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2280
2281 if (!amg_data)
2282 {
2283 hypre_error_in_arg(1);
2284 return hypre_error_flag;
2285 }
2286 if (!relax_weight)
2287 {
2288 hypre_error_in_arg(2);
2289 return hypre_error_flag;
2290 }
2291
2292 if (hypre_ParAMGDataRelaxWeight(amg_data))
2293 hypre_TFree(hypre_ParAMGDataRelaxWeight(amg_data), HYPRE_MEMORY_HOST);
2294 hypre_ParAMGDataRelaxWeight(amg_data) = relax_weight;
2295
2296 return hypre_error_flag;
2297 }
2298
2299 HYPRE_Int
hypre_BoomerAMGGetRelaxWeight(void * data,HYPRE_Real ** relax_weight)2300 hypre_BoomerAMGGetRelaxWeight( void *data,
2301 HYPRE_Real ** relax_weight )
2302 {
2303 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2304
2305 if (!amg_data)
2306 {
2307 hypre_error_in_arg(1);
2308 return hypre_error_flag;
2309 }
2310 *relax_weight = hypre_ParAMGDataRelaxWeight(amg_data);
2311
2312 return hypre_error_flag;
2313 }
2314
2315 HYPRE_Int
hypre_BoomerAMGSetRelaxWt(void * data,HYPRE_Real relax_weight)2316 hypre_BoomerAMGSetRelaxWt( void *data,
2317 HYPRE_Real relax_weight )
2318 {
2319 HYPRE_Int i, num_levels;
2320 HYPRE_Real *relax_weight_array;
2321 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2322
2323 if (!amg_data)
2324 {
2325 hypre_error_in_arg(1);
2326 return hypre_error_flag;
2327 }
2328 num_levels = hypre_ParAMGDataMaxLevels(amg_data);
2329 if (hypre_ParAMGDataRelaxWeight(amg_data) == NULL)
2330 hypre_ParAMGDataRelaxWeight(amg_data) = hypre_CTAlloc(HYPRE_Real, num_levels, HYPRE_MEMORY_HOST);
2331
2332 relax_weight_array = hypre_ParAMGDataRelaxWeight(amg_data);
2333 for (i=0; i < num_levels; i++)
2334 relax_weight_array[i] = relax_weight;
2335
2336 hypre_ParAMGDataUserRelaxWeight(amg_data) = relax_weight;
2337
2338 return hypre_error_flag;
2339 }
2340
2341 HYPRE_Int
hypre_BoomerAMGSetLevelRelaxWt(void * data,HYPRE_Real relax_weight,HYPRE_Int level)2342 hypre_BoomerAMGSetLevelRelaxWt( void *data,
2343 HYPRE_Real relax_weight,
2344 HYPRE_Int level )
2345 {
2346 HYPRE_Int i, num_levels;
2347 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2348 if (!amg_data)
2349 {
2350 hypre_error_in_arg(1);
2351 return hypre_error_flag;
2352 }
2353 num_levels = hypre_ParAMGDataMaxLevels(amg_data);
2354 if (level > num_levels-1 || level < 0)
2355 {
2356 hypre_error_in_arg(3);
2357 return hypre_error_flag;
2358 }
2359 if (hypre_ParAMGDataRelaxWeight(amg_data) == NULL)
2360 {
2361 hypre_ParAMGDataRelaxWeight(amg_data) = hypre_CTAlloc(HYPRE_Real, num_levels, HYPRE_MEMORY_HOST);
2362 for (i=0; i < num_levels; i++)
2363 hypre_ParAMGDataRelaxWeight(amg_data)[i] = 1.0;
2364 }
2365
2366 hypre_ParAMGDataRelaxWeight(amg_data)[level] = relax_weight;
2367
2368 return hypre_error_flag;
2369 }
2370
2371 HYPRE_Int
hypre_BoomerAMGGetLevelRelaxWt(void * data,HYPRE_Real * relax_weight,HYPRE_Int level)2372 hypre_BoomerAMGGetLevelRelaxWt( void *data,
2373 HYPRE_Real * relax_weight,
2374 HYPRE_Int level )
2375 {
2376 HYPRE_Int num_levels;
2377 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2378 if (!amg_data)
2379 {
2380 hypre_error_in_arg(1);
2381 return hypre_error_flag;
2382 }
2383 num_levels = hypre_ParAMGDataMaxLevels(amg_data);
2384 if (level > num_levels-1 || level < 0)
2385 {
2386 hypre_error_in_arg(3);
2387 return hypre_error_flag;
2388 }
2389 if (hypre_ParAMGDataRelaxWeight(amg_data) == NULL)
2390 {
2391 hypre_error_in_arg(1);
2392 return hypre_error_flag;
2393 }
2394
2395 *relax_weight = hypre_ParAMGDataRelaxWeight(amg_data)[level];
2396
2397 return hypre_error_flag;
2398 }
2399
2400 HYPRE_Int
hypre_BoomerAMGSetOmega(void * data,HYPRE_Real * omega)2401 hypre_BoomerAMGSetOmega( void *data,
2402 HYPRE_Real *omega )
2403 {
2404 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2405
2406 if (!amg_data)
2407 {
2408 hypre_error_in_arg(1);
2409 return hypre_error_flag;
2410 }
2411 if (!omega)
2412 {
2413 hypre_error_in_arg(2);
2414 return hypre_error_flag;
2415 }
2416 if (hypre_ParAMGDataOmega(amg_data))
2417 hypre_TFree(hypre_ParAMGDataOmega(amg_data), HYPRE_MEMORY_HOST);
2418 hypre_ParAMGDataOmega(amg_data) = omega;
2419
2420 return hypre_error_flag;
2421 }
2422
2423 HYPRE_Int
hypre_BoomerAMGGetOmega(void * data,HYPRE_Real ** omega)2424 hypre_BoomerAMGGetOmega( void *data,
2425 HYPRE_Real ** omega )
2426 {
2427 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2428
2429 if (!amg_data)
2430 {
2431 hypre_error_in_arg(1);
2432 return hypre_error_flag;
2433 }
2434 *omega = hypre_ParAMGDataOmega(amg_data);
2435
2436 return hypre_error_flag;
2437 }
2438
2439 HYPRE_Int
hypre_BoomerAMGSetOuterWt(void * data,HYPRE_Real omega)2440 hypre_BoomerAMGSetOuterWt( void *data,
2441 HYPRE_Real omega )
2442 {
2443 HYPRE_Int i, num_levels;
2444 HYPRE_Real *omega_array;
2445 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2446
2447 if (!amg_data)
2448 {
2449 hypre_error_in_arg(1);
2450 return hypre_error_flag;
2451 }
2452 num_levels = hypre_ParAMGDataMaxLevels(amg_data);
2453 if (hypre_ParAMGDataOmega(amg_data) == NULL)
2454 hypre_ParAMGDataOmega(amg_data) = hypre_CTAlloc(HYPRE_Real, num_levels, HYPRE_MEMORY_HOST);
2455
2456 omega_array = hypre_ParAMGDataOmega(amg_data);
2457 for (i=0; i < num_levels; i++)
2458 omega_array[i] = omega;
2459 hypre_ParAMGDataOuterWt(amg_data) = omega;
2460
2461 return hypre_error_flag;
2462 }
2463
2464 HYPRE_Int
hypre_BoomerAMGSetLevelOuterWt(void * data,HYPRE_Real omega,HYPRE_Int level)2465 hypre_BoomerAMGSetLevelOuterWt( void *data,
2466 HYPRE_Real omega,
2467 HYPRE_Int level )
2468 {
2469 HYPRE_Int i, num_levels;
2470 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2471 if (!amg_data)
2472 {
2473 hypre_error_in_arg(1);
2474 return hypre_error_flag;
2475 }
2476 num_levels = hypre_ParAMGDataMaxLevels(amg_data);
2477 if (level > num_levels-1)
2478 {
2479 hypre_error_in_arg(3);
2480 return hypre_error_flag;
2481 }
2482 if (hypre_ParAMGDataOmega(amg_data) == NULL)
2483 {
2484 hypre_ParAMGDataOmega(amg_data) = hypre_CTAlloc(HYPRE_Real, num_levels, HYPRE_MEMORY_HOST);
2485 for (i=0; i < num_levels; i++)
2486 hypre_ParAMGDataOmega(amg_data)[i] = 1.0;
2487 }
2488
2489 hypre_ParAMGDataOmega(amg_data)[level] = omega;
2490
2491 return hypre_error_flag;
2492 }
2493
2494 HYPRE_Int
hypre_BoomerAMGGetLevelOuterWt(void * data,HYPRE_Real * omega,HYPRE_Int level)2495 hypre_BoomerAMGGetLevelOuterWt( void *data,
2496 HYPRE_Real * omega,
2497 HYPRE_Int level )
2498 {
2499 HYPRE_Int num_levels;
2500 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2501 if (!amg_data)
2502 {
2503 hypre_error_in_arg(1);
2504 return hypre_error_flag;
2505 }
2506 num_levels = hypre_ParAMGDataMaxLevels(amg_data);
2507 if (level > num_levels-1)
2508 {
2509 hypre_error_in_arg(3);
2510 return hypre_error_flag;
2511 }
2512 if (hypre_ParAMGDataOmega(amg_data) == NULL)
2513 {
2514 hypre_error_in_arg(1);
2515 return hypre_error_flag;
2516 }
2517
2518 *omega = hypre_ParAMGDataOmega(amg_data)[level];
2519
2520 return hypre_error_flag;
2521 }
2522
2523 HYPRE_Int
hypre_BoomerAMGSetSmoothType(void * data,HYPRE_Int smooth_type)2524 hypre_BoomerAMGSetSmoothType( void *data,
2525 HYPRE_Int smooth_type )
2526 {
2527 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2528 if (!amg_data)
2529 {
2530 hypre_error_in_arg(1);
2531 return hypre_error_flag;
2532 }
2533
2534 hypre_ParAMGDataSmoothType(amg_data) = smooth_type;
2535
2536 return hypre_error_flag;
2537 }
2538
2539 HYPRE_Int
hypre_BoomerAMGGetSmoothType(void * data,HYPRE_Int * smooth_type)2540 hypre_BoomerAMGGetSmoothType( void *data,
2541 HYPRE_Int * smooth_type )
2542 {
2543 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2544
2545 if (!amg_data)
2546 {
2547 hypre_error_in_arg(1);
2548 return hypre_error_flag;
2549 }
2550 *smooth_type = hypre_ParAMGDataSmoothType(amg_data);
2551
2552 return hypre_error_flag;
2553 }
2554
2555 HYPRE_Int
hypre_BoomerAMGSetSmoothNumLevels(void * data,HYPRE_Int smooth_num_levels)2556 hypre_BoomerAMGSetSmoothNumLevels( void *data,
2557 HYPRE_Int smooth_num_levels )
2558 {
2559 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2560
2561 if (!amg_data)
2562 {
2563 hypre_error_in_arg(1);
2564 return hypre_error_flag;
2565 }
2566 if (smooth_num_levels < 0)
2567 {
2568 hypre_error_in_arg(2);
2569 return hypre_error_flag;
2570 }
2571 hypre_ParAMGDataSmoothNumLevels(amg_data) = smooth_num_levels;
2572
2573 return hypre_error_flag;
2574 }
2575
2576 HYPRE_Int
hypre_BoomerAMGGetSmoothNumLevels(void * data,HYPRE_Int * smooth_num_levels)2577 hypre_BoomerAMGGetSmoothNumLevels( void *data,
2578 HYPRE_Int * smooth_num_levels )
2579 {
2580 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2581
2582 if (!amg_data)
2583 {
2584 hypre_error_in_arg(1);
2585 return hypre_error_flag;
2586 }
2587 *smooth_num_levels = hypre_ParAMGDataSmoothNumLevels(amg_data);
2588
2589 return hypre_error_flag;
2590 }
2591
2592 HYPRE_Int
hypre_BoomerAMGSetSmoothNumSweeps(void * data,HYPRE_Int smooth_num_sweeps)2593 hypre_BoomerAMGSetSmoothNumSweeps( void *data,
2594 HYPRE_Int smooth_num_sweeps )
2595 {
2596 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2597
2598 if (!amg_data)
2599 {
2600 hypre_error_in_arg(1);
2601 return hypre_error_flag;
2602 }
2603 if (smooth_num_sweeps < 0)
2604 {
2605 hypre_error_in_arg(2);
2606 return hypre_error_flag;
2607 }
2608 hypre_ParAMGDataSmoothNumSweeps(amg_data) = smooth_num_sweeps;
2609
2610 return hypre_error_flag;
2611 }
2612
2613 HYPRE_Int
hypre_BoomerAMGGetSmoothNumSweeps(void * data,HYPRE_Int * smooth_num_sweeps)2614 hypre_BoomerAMGGetSmoothNumSweeps( void *data,
2615 HYPRE_Int * smooth_num_sweeps )
2616 {
2617 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2618
2619 if (!amg_data)
2620 {
2621 hypre_error_in_arg(1);
2622 return hypre_error_flag;
2623 }
2624 *smooth_num_sweeps = hypre_ParAMGDataSmoothNumSweeps(amg_data);
2625
2626 return hypre_error_flag;
2627 }
2628
2629 HYPRE_Int
hypre_BoomerAMGSetLogging(void * data,HYPRE_Int logging)2630 hypre_BoomerAMGSetLogging( void *data,
2631 HYPRE_Int logging )
2632 {
2633 /* This function should be called before Setup. Logging changes
2634 may require allocation or freeing of arrays, which is presently
2635 only done there.
2636 It may be possible to support logging changes at other times,
2637 but there is little need.
2638 */
2639 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2640
2641 if (!amg_data)
2642 {
2643 hypre_error_in_arg(1);
2644 return hypre_error_flag;
2645 }
2646 hypre_ParAMGDataLogging(amg_data) = logging;
2647
2648 return hypre_error_flag;
2649 }
2650
2651 HYPRE_Int
hypre_BoomerAMGGetLogging(void * data,HYPRE_Int * logging)2652 hypre_BoomerAMGGetLogging( void *data,
2653 HYPRE_Int * logging )
2654 {
2655 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2656
2657 if (!amg_data)
2658 {
2659 hypre_error_in_arg(1);
2660 return hypre_error_flag;
2661 }
2662 *logging = hypre_ParAMGDataLogging(amg_data);
2663
2664 return hypre_error_flag;
2665 }
2666
2667 HYPRE_Int
hypre_BoomerAMGSetPrintLevel(void * data,HYPRE_Int print_level)2668 hypre_BoomerAMGSetPrintLevel( void *data,
2669 HYPRE_Int print_level )
2670 {
2671 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2672
2673 if (!amg_data)
2674 {
2675 hypre_error_in_arg(1);
2676 return hypre_error_flag;
2677 }
2678 hypre_ParAMGDataPrintLevel(amg_data) = print_level;
2679
2680 return hypre_error_flag;
2681 }
2682
2683 HYPRE_Int
hypre_BoomerAMGGetPrintLevel(void * data,HYPRE_Int * print_level)2684 hypre_BoomerAMGGetPrintLevel( void *data,
2685 HYPRE_Int * print_level )
2686 {
2687 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2688
2689 if (!amg_data)
2690 {
2691 hypre_error_in_arg(1);
2692 return hypre_error_flag;
2693 }
2694 *print_level = hypre_ParAMGDataPrintLevel(amg_data);
2695
2696 return hypre_error_flag;
2697 }
2698
2699 HYPRE_Int
hypre_BoomerAMGSetPrintFileName(void * data,const char * print_file_name)2700 hypre_BoomerAMGSetPrintFileName( void *data,
2701 const char *print_file_name )
2702 {
2703 hypre_ParAMGData *amg_data = (hypre_ParAMGData*)data;
2704 if (!amg_data)
2705 {
2706 hypre_error_in_arg(1);
2707 return hypre_error_flag;
2708 }
2709 if ( strlen(print_file_name) > 256 )
2710 {
2711 hypre_error_in_arg(2);
2712 return hypre_error_flag;
2713 }
2714
2715 hypre_sprintf(hypre_ParAMGDataLogFileName(amg_data), "%s", print_file_name);
2716
2717 return hypre_error_flag;
2718 }
2719
2720 HYPRE_Int
hypre_BoomerAMGGetPrintFileName(void * data,char ** print_file_name)2721 hypre_BoomerAMGGetPrintFileName( void *data,
2722 char ** print_file_name )
2723 {
2724 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2725
2726 if (!amg_data)
2727 {
2728 hypre_error_in_arg(1);
2729 return hypre_error_flag;
2730 }
2731 hypre_sprintf( *print_file_name, "%s", hypre_ParAMGDataLogFileName(amg_data) );
2732
2733 return hypre_error_flag;
2734 }
2735
2736 HYPRE_Int
hypre_BoomerAMGSetNumIterations(void * data,HYPRE_Int num_iterations)2737 hypre_BoomerAMGSetNumIterations( void *data,
2738 HYPRE_Int num_iterations )
2739 {
2740 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2741
2742 if (!amg_data)
2743 {
2744 hypre_error_in_arg(1);
2745 return hypre_error_flag;
2746 }
2747 hypre_ParAMGDataNumIterations(amg_data) = num_iterations;
2748
2749 return hypre_error_flag;
2750 }
2751
2752 HYPRE_Int
hypre_BoomerAMGSetDebugFlag(void * data,HYPRE_Int debug_flag)2753 hypre_BoomerAMGSetDebugFlag( void *data,
2754 HYPRE_Int debug_flag )
2755 {
2756 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2757
2758 if (!amg_data)
2759 {
2760 hypre_error_in_arg(1);
2761 return hypre_error_flag;
2762 }
2763 hypre_ParAMGDataDebugFlag(amg_data) = debug_flag;
2764
2765 return hypre_error_flag;
2766 }
2767
2768 HYPRE_Int
hypre_BoomerAMGGetDebugFlag(void * data,HYPRE_Int * debug_flag)2769 hypre_BoomerAMGGetDebugFlag( void *data,
2770 HYPRE_Int * debug_flag )
2771 {
2772 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2773
2774 if (!amg_data)
2775 {
2776 hypre_error_in_arg(1);
2777 return hypre_error_flag;
2778 }
2779 *debug_flag = hypre_ParAMGDataDebugFlag(amg_data);
2780
2781 return hypre_error_flag;
2782 }
2783
2784 /*--------------------------------------------------------------------------
2785 * hypre_BoomerAMGSetGSMG
2786 *--------------------------------------------------------------------------*/
2787
2788 HYPRE_Int
hypre_BoomerAMGSetGSMG(void * data,HYPRE_Int par)2789 hypre_BoomerAMGSetGSMG( void *data,
2790 HYPRE_Int par )
2791 {
2792 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2793
2794 if (!amg_data)
2795 {
2796 hypre_error_in_arg(1);
2797 return hypre_error_flag;
2798 }
2799 amg_data->gsmg = par;
2800
2801 return hypre_error_flag;
2802 }
2803
2804 /*--------------------------------------------------------------------------
2805 * hypre_BoomerAMGSetNumSamples
2806 *--------------------------------------------------------------------------*/
2807
2808 HYPRE_Int
hypre_BoomerAMGSetNumSamples(void * data,HYPRE_Int par)2809 hypre_BoomerAMGSetNumSamples( void *data,
2810 HYPRE_Int par )
2811 {
2812 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2813
2814 if (!amg_data)
2815 {
2816 hypre_error_in_arg(1);
2817 return hypre_error_flag;
2818 }
2819 amg_data->num_samples = par;
2820
2821 return hypre_error_flag;
2822 }
2823
2824 /* BM Aug 25, 2006 */
2825
2826 HYPRE_Int
hypre_BoomerAMGSetCGCIts(void * data,HYPRE_Int its)2827 hypre_BoomerAMGSetCGCIts( void *data,
2828 HYPRE_Int its)
2829 {
2830 HYPRE_Int ierr = 0;
2831 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2832
2833 hypre_ParAMGDataCGCIts(amg_data) = its;
2834 return (ierr);
2835 }
2836
2837 /* BM Oct 22, 2006 */
2838 HYPRE_Int
hypre_BoomerAMGSetPlotGrids(void * data,HYPRE_Int plotgrids)2839 hypre_BoomerAMGSetPlotGrids( void *data,
2840 HYPRE_Int plotgrids)
2841 {
2842 HYPRE_Int ierr = 0;
2843 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2844
2845 hypre_ParAMGDataPlotGrids(amg_data) = plotgrids;
2846 return (ierr);
2847 }
2848
2849 HYPRE_Int
hypre_BoomerAMGSetPlotFileName(void * data,const char * plot_file_name)2850 hypre_BoomerAMGSetPlotFileName( void *data,
2851 const char *plot_file_name )
2852 {
2853 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2854 if (!amg_data)
2855 {
2856 hypre_error_in_arg(1);
2857 return hypre_error_flag;
2858 }
2859 if ( strlen(plot_file_name)>251 )
2860 {
2861 hypre_error_in_arg(2);
2862 return hypre_error_flag;
2863 }
2864 if (strlen(plot_file_name)==0 )
2865 hypre_sprintf(hypre_ParAMGDataPlotFileName(amg_data), "%s", "AMGgrids.CF.dat");
2866 else
2867 hypre_sprintf(hypre_ParAMGDataPlotFileName(amg_data), "%s", plot_file_name);
2868
2869 return hypre_error_flag;
2870 }
2871 /* Get the coarse grid hierarchy. Assumes cgrid is preallocated to the size of the local matrix.
2872 * Adapted from par_amg_setup.c, and simplified by ignoring printing in block mode.
2873 * We do a memcpy on the final grid hierarchy to avoid modifying user allocated data.
2874 */
2875 HYPRE_Int
hypre_BoomerAMGGetGridHierarchy(void * data,HYPRE_Int * cgrid)2876 hypre_BoomerAMGGetGridHierarchy( void *data,
2877 HYPRE_Int *cgrid )
2878 {
2879 HYPRE_Int *ibuff = NULL;
2880 HYPRE_Int *wbuff, *cbuff, *tmp;
2881 HYPRE_Int local_size, lev_size, i, j, level, num_levels, block_mode;
2882 hypre_IntArray *CF_marker_array;
2883 hypre_IntArray *CF_marker_array_host;
2884 HYPRE_Int *CF_marker;
2885
2886 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
2887 if (!amg_data)
2888 {
2889 hypre_error_in_arg(1);
2890 return hypre_error_flag;
2891 }
2892 if (!cgrid)
2893 {
2894 hypre_error_in_arg(2);
2895 return hypre_error_flag;
2896 }
2897
2898 block_mode = hypre_ParAMGDataBlockMode(amg_data);
2899
2900 if( block_mode)
2901 {
2902 hypre_ParCSRBlockMatrix **A_block_array;
2903 A_block_array = hypre_ParAMGDataABlockArray(amg_data);
2904 if(A_block_array == NULL)
2905 {
2906 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"Invalid AMG data. AMG setup has not been called!!\n");
2907 return hypre_error_flag;
2908 }
2909
2910 // get local size and allocate some memory
2911 local_size = hypre_CSRMatrixNumRows(hypre_ParCSRBlockMatrixDiag(A_block_array[0]));
2912 ibuff = hypre_CTAlloc(HYPRE_Int, (2 * local_size), HYPRE_MEMORY_HOST);
2913 wbuff = ibuff;
2914 cbuff = ibuff + local_size;
2915
2916 num_levels = hypre_ParAMGDataNumLevels(amg_data);
2917 for (level = (num_levels - 2); level >= 0; level--)
2918 {
2919 /* get the CF marker array on the host */
2920 CF_marker_array = hypre_ParAMGDataCFMarkerArray(amg_data)[level];
2921 if (hypre_GetActualMemLocation(hypre_IntArrayMemoryLocation(CF_marker_array)) == hypre_MEMORY_DEVICE)
2922 {
2923 CF_marker_array_host = hypre_IntArrayCloneDeep_v2(CF_marker_array, HYPRE_MEMORY_HOST);
2924 }
2925 else
2926 {
2927 CF_marker_array_host = CF_marker_array;
2928 }
2929 CF_marker = hypre_IntArrayData(CF_marker_array_host);
2930
2931 /* swap pointers */
2932 tmp = wbuff;
2933 wbuff = cbuff;
2934 cbuff = tmp;
2935
2936 lev_size = hypre_CSRMatrixNumRows(hypre_ParCSRBlockMatrixDiag(A_block_array[level]));
2937
2938 for (i = 0, j = 0; i < lev_size; i++)
2939 {
2940 /* if a C-point */
2941 cbuff[i] = 0;
2942 if (CF_marker[i] > -1)
2943 {
2944 cbuff[i] = wbuff[j] + 1;
2945 j++;
2946 }
2947 }
2948
2949 /* destroy copy host copy if necessary */
2950 if (hypre_GetActualMemLocation(hypre_IntArrayMemoryLocation(CF_marker_array)) == hypre_MEMORY_DEVICE)
2951 {
2952 hypre_IntArrayDestroy(CF_marker_array_host);
2953 }
2954 }
2955 }
2956 else
2957 {
2958 hypre_ParCSRMatrix **A_array;
2959 A_array = hypre_ParAMGDataAArray(amg_data);
2960 if(A_array == NULL)
2961 {
2962 hypre_error_w_msg(HYPRE_ERROR_GENERIC,"Invalid AMG data. AMG setup has not been called!!\n");
2963 return hypre_error_flag;
2964 }
2965
2966 // get local size and allocate some memory
2967 local_size = hypre_CSRMatrixNumRows(hypre_ParCSRMatrixDiag(A_array[0]));
2968 wbuff = hypre_CTAlloc(HYPRE_Int, (2 * local_size), HYPRE_MEMORY_HOST);
2969 cbuff = wbuff + local_size;
2970
2971 num_levels = hypre_ParAMGDataNumLevels(amg_data);
2972 for (level = (num_levels - 2); level >= 0; level--)
2973 {
2974 /* get the CF marker array on the host */
2975 CF_marker_array = hypre_ParAMGDataCFMarkerArray(amg_data)[level];
2976 if (hypre_GetActualMemLocation(hypre_IntArrayMemoryLocation(CF_marker_array)) == hypre_MEMORY_DEVICE)
2977 {
2978 CF_marker_array_host = hypre_IntArrayCloneDeep_v2(CF_marker_array, HYPRE_MEMORY_HOST);
2979 }
2980 else
2981 {
2982 CF_marker_array_host = CF_marker_array;
2983 }
2984 CF_marker = hypre_IntArrayData(CF_marker_array_host);
2985 /* swap pointers */
2986 tmp = wbuff;
2987 wbuff = cbuff;
2988 cbuff = tmp;
2989
2990 lev_size = hypre_CSRMatrixNumRows(hypre_ParCSRMatrixDiag(A_array[level]));
2991
2992 for (i = 0, j = 0; i < lev_size; i++)
2993 {
2994 /* if a C-point */
2995 cbuff[i] = 0;
2996 if (CF_marker[i] > -1)
2997 {
2998 cbuff[i] = wbuff[j] + 1;
2999 j++;
3000 }
3001 }
3002 /* destroy copy host copy if necessary */
3003 if (hypre_GetActualMemLocation(hypre_IntArrayMemoryLocation(CF_marker_array)) == hypre_MEMORY_DEVICE)
3004 {
3005 hypre_IntArrayDestroy(CF_marker_array_host);
3006 }
3007 }
3008 }
3009 // copy hierarchy into user provided array
3010 hypre_TMemcpy(cgrid, cbuff, HYPRE_Int, local_size, HYPRE_MEMORY_HOST, HYPRE_MEMORY_HOST);
3011 // free memory
3012 hypre_TFree(ibuff, HYPRE_MEMORY_HOST);
3013
3014 return hypre_error_flag;
3015 }
3016
3017 /* BM Oct 17, 2006 */
3018 HYPRE_Int
hypre_BoomerAMGSetCoordDim(void * data,HYPRE_Int coorddim)3019 hypre_BoomerAMGSetCoordDim( void *data,
3020 HYPRE_Int coorddim)
3021 {
3022 HYPRE_Int ierr = 0;
3023 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3024
3025 hypre_ParAMGDataCoordDim(amg_data) = coorddim;
3026 return (ierr);
3027 }
3028
3029 HYPRE_Int
hypre_BoomerAMGSetCoordinates(void * data,float * coordinates)3030 hypre_BoomerAMGSetCoordinates( void *data,
3031 float *coordinates)
3032 {
3033 HYPRE_Int ierr = 0;
3034 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3035
3036 hypre_ParAMGDataCoordinates(amg_data) = coordinates;
3037 return (ierr);
3038 }
3039
3040 /*--------------------------------------------------------------------------
3041 * Routines to set the problem data parameters
3042 *--------------------------------------------------------------------------*/
3043
3044 HYPRE_Int
hypre_BoomerAMGSetNumFunctions(void * data,HYPRE_Int num_functions)3045 hypre_BoomerAMGSetNumFunctions( void *data,
3046 HYPRE_Int num_functions )
3047 {
3048 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3049
3050 if (!amg_data)
3051 {
3052 hypre_error_in_arg(1);
3053 return hypre_error_flag;
3054 }
3055 if (num_functions < 1)
3056 {
3057 hypre_error_in_arg(2);
3058 return hypre_error_flag;
3059 }
3060 hypre_ParAMGDataNumFunctions(amg_data) = num_functions;
3061
3062 return hypre_error_flag;
3063 }
3064
3065 HYPRE_Int
hypre_BoomerAMGGetNumFunctions(void * data,HYPRE_Int * num_functions)3066 hypre_BoomerAMGGetNumFunctions( void *data,
3067 HYPRE_Int * num_functions )
3068 {
3069 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3070
3071 if (!amg_data)
3072 {
3073 hypre_error_in_arg(1);
3074 return hypre_error_flag;
3075 }
3076 *num_functions = hypre_ParAMGDataNumFunctions(amg_data);
3077
3078 return hypre_error_flag;
3079 }
3080
3081 /*--------------------------------------------------------------------------
3082 * Indicate whether to use nodal systems function
3083 *--------------------------------------------------------------------------*/
3084
3085 HYPRE_Int
hypre_BoomerAMGSetNodal(void * data,HYPRE_Int nodal)3086 hypre_BoomerAMGSetNodal( void *data,
3087 HYPRE_Int nodal )
3088 {
3089 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3090
3091 if (!amg_data)
3092 {
3093 hypre_error_in_arg(1);
3094 return hypre_error_flag;
3095 }
3096 hypre_ParAMGDataNodal(amg_data) = nodal;
3097
3098 return hypre_error_flag;
3099 }
3100 /*--------------------------------------------------------------------------
3101 * Indicate number of levels for nodal coarsening
3102 *--------------------------------------------------------------------------*/
3103
3104 HYPRE_Int
hypre_BoomerAMGSetNodalLevels(void * data,HYPRE_Int nodal_levels)3105 hypre_BoomerAMGSetNodalLevels( void *data,
3106 HYPRE_Int nodal_levels )
3107 {
3108 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3109
3110 if (!amg_data)
3111 {
3112 hypre_error_in_arg(1);
3113 return hypre_error_flag;
3114 }
3115 hypre_ParAMGDataNodalLevels(amg_data) = nodal_levels;
3116
3117 return hypre_error_flag;
3118 }
3119
3120
3121 /*--------------------------------------------------------------------------
3122 * Indicate how to treat diag for primary matrix with nodal systems function
3123 *--------------------------------------------------------------------------*/
3124
3125 HYPRE_Int
hypre_BoomerAMGSetNodalDiag(void * data,HYPRE_Int nodal)3126 hypre_BoomerAMGSetNodalDiag( void *data,
3127 HYPRE_Int nodal )
3128 {
3129 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3130
3131 if (!amg_data)
3132 {
3133 hypre_error_in_arg(1);
3134 return hypre_error_flag;
3135 }
3136 hypre_ParAMGDataNodalDiag(amg_data) = nodal;
3137
3138 return hypre_error_flag;
3139 }
3140 /*--------------------------------------------------------------------------
3141 * Indicate whether to discard same sign coefficients in S for nodal>0
3142 *--------------------------------------------------------------------------*/
3143
3144 HYPRE_Int
hypre_BoomerAMGSetKeepSameSign(void * data,HYPRE_Int keep_same_sign)3145 hypre_BoomerAMGSetKeepSameSign( void *data,
3146 HYPRE_Int keep_same_sign )
3147 {
3148 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3149
3150 if (!amg_data)
3151 {
3152 hypre_error_in_arg(1);
3153 return hypre_error_flag;
3154 }
3155 hypre_ParAMGDataKeepSameSign(amg_data) = keep_same_sign;
3156
3157 return hypre_error_flag;
3158 }
3159 /*--------------------------------------------------------------------------
3160 * Indicate the degree of aggressive coarsening
3161 *--------------------------------------------------------------------------*/
3162
3163 HYPRE_Int
hypre_BoomerAMGSetNumPaths(void * data,HYPRE_Int num_paths)3164 hypre_BoomerAMGSetNumPaths( void *data,
3165 HYPRE_Int num_paths )
3166 {
3167 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3168
3169 if (!amg_data)
3170 {
3171 hypre_error_in_arg(1);
3172 return hypre_error_flag;
3173 }
3174 if (num_paths < 1)
3175 {
3176 hypre_error_in_arg(2);
3177 return hypre_error_flag;
3178 }
3179 hypre_ParAMGDataNumPaths(amg_data) = num_paths;
3180
3181 return hypre_error_flag;
3182 }
3183
3184 /*--------------------------------------------------------------------------
3185 * Indicates the number of levels of aggressive coarsening
3186 *--------------------------------------------------------------------------*/
3187
3188 HYPRE_Int
hypre_BoomerAMGSetAggNumLevels(void * data,HYPRE_Int agg_num_levels)3189 hypre_BoomerAMGSetAggNumLevels( void *data,
3190 HYPRE_Int agg_num_levels )
3191 {
3192 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3193
3194 if (!amg_data)
3195 {
3196 hypre_error_in_arg(1);
3197 return hypre_error_flag;
3198 }
3199 if (agg_num_levels < 0)
3200 {
3201 hypre_error_in_arg(2);
3202 return hypre_error_flag;
3203 }
3204 hypre_ParAMGDataAggNumLevels(amg_data) = agg_num_levels;
3205
3206 return hypre_error_flag;
3207 }
3208
3209 /*--------------------------------------------------------------------------
3210 * Indicates the interpolation used with aggressive coarsening
3211 *--------------------------------------------------------------------------*/
3212
3213 HYPRE_Int
hypre_BoomerAMGSetAggInterpType(void * data,HYPRE_Int agg_interp_type)3214 hypre_BoomerAMGSetAggInterpType( void *data,
3215 HYPRE_Int agg_interp_type )
3216 {
3217 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3218
3219 if (!amg_data)
3220 {
3221 hypre_error_in_arg(1);
3222 return hypre_error_flag;
3223 }
3224 if (agg_interp_type < 0 || agg_interp_type > 9)
3225 {
3226 hypre_error_in_arg(2);
3227 return hypre_error_flag;
3228 }
3229 hypre_ParAMGDataAggInterpType(amg_data) = agg_interp_type;
3230
3231 return hypre_error_flag;
3232 }
3233
3234 /*--------------------------------------------------------------------------
3235 * Indicates max number of elements per row for aggressive coarsening
3236 * interpolation
3237 *--------------------------------------------------------------------------*/
3238
3239 HYPRE_Int
hypre_BoomerAMGSetAggPMaxElmts(void * data,HYPRE_Int agg_P_max_elmts)3240 hypre_BoomerAMGSetAggPMaxElmts( void *data,
3241 HYPRE_Int agg_P_max_elmts )
3242 {
3243 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3244
3245 if (!amg_data)
3246 {
3247 hypre_error_in_arg(1);
3248 return hypre_error_flag;
3249 }
3250 if (agg_P_max_elmts < 0)
3251 {
3252 hypre_error_in_arg(2);
3253 return hypre_error_flag;
3254 }
3255 hypre_ParAMGDataAggPMaxElmts(amg_data) = agg_P_max_elmts;
3256
3257 return hypre_error_flag;
3258 }
3259
3260 /*--------------------------------------------------------------------------
3261 * Indicates max number of elements per row for smoothed
3262 * interpolation in mult-additive or simple method
3263 *--------------------------------------------------------------------------*/
3264
3265 HYPRE_Int
hypre_BoomerAMGSetMultAddPMaxElmts(void * data,HYPRE_Int add_P_max_elmts)3266 hypre_BoomerAMGSetMultAddPMaxElmts( void *data,
3267 HYPRE_Int add_P_max_elmts )
3268 {
3269 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3270
3271 if (!amg_data)
3272 {
3273 hypre_error_in_arg(1);
3274 return hypre_error_flag;
3275 }
3276 if (add_P_max_elmts < 0)
3277 {
3278 hypre_error_in_arg(2);
3279 return hypre_error_flag;
3280 }
3281 hypre_ParAMGDataMultAddPMaxElmts(amg_data) = add_P_max_elmts;
3282
3283 return hypre_error_flag;
3284 }
3285
3286 /*--------------------------------------------------------------------------
3287 * Indicates Relaxtion Type for Additive Cycle
3288 *--------------------------------------------------------------------------*/
3289
3290 HYPRE_Int
hypre_BoomerAMGSetAddRelaxType(void * data,HYPRE_Int add_rlx_type)3291 hypre_BoomerAMGSetAddRelaxType( void *data,
3292 HYPRE_Int add_rlx_type )
3293 {
3294 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3295
3296 if (!amg_data)
3297 {
3298 hypre_error_in_arg(1);
3299 return hypre_error_flag;
3300 }
3301 hypre_ParAMGDataAddRelaxType(amg_data) = add_rlx_type;
3302
3303 return hypre_error_flag;
3304 }
3305
3306 /*--------------------------------------------------------------------------
3307 * Indicates Relaxation Weight for Additive Cycle
3308 *--------------------------------------------------------------------------*/
3309
3310 HYPRE_Int
hypre_BoomerAMGSetAddRelaxWt(void * data,HYPRE_Real add_rlx_wt)3311 hypre_BoomerAMGSetAddRelaxWt( void *data,
3312 HYPRE_Real add_rlx_wt )
3313 {
3314 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3315
3316 if (!amg_data)
3317 {
3318 hypre_error_in_arg(1);
3319 return hypre_error_flag;
3320 }
3321 hypre_ParAMGDataAddRelaxWt(amg_data) = add_rlx_wt;
3322
3323 return hypre_error_flag;
3324 }
3325
3326 /*--------------------------------------------------------------------------
3327 * Indicates max number of elements per row for 1st stage of aggressive
3328 * coarsening two-stage interpolation
3329 *--------------------------------------------------------------------------*/
3330
3331 HYPRE_Int
hypre_BoomerAMGSetAggP12MaxElmts(void * data,HYPRE_Int agg_P12_max_elmts)3332 hypre_BoomerAMGSetAggP12MaxElmts( void *data,
3333 HYPRE_Int agg_P12_max_elmts )
3334 {
3335 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3336
3337 if (!amg_data)
3338 {
3339 hypre_error_in_arg(1);
3340 return hypre_error_flag;
3341 }
3342 if (agg_P12_max_elmts < 0)
3343 {
3344 hypre_error_in_arg(2);
3345 return hypre_error_flag;
3346 }
3347 hypre_ParAMGDataAggP12MaxElmts(amg_data) = agg_P12_max_elmts;
3348
3349 return hypre_error_flag;
3350 }
3351
3352 /*--------------------------------------------------------------------------
3353 * Indicates truncation factor for aggressive coarsening interpolation
3354 *--------------------------------------------------------------------------*/
3355
3356 HYPRE_Int
hypre_BoomerAMGSetAggTruncFactor(void * data,HYPRE_Real agg_trunc_factor)3357 hypre_BoomerAMGSetAggTruncFactor( void *data,
3358 HYPRE_Real agg_trunc_factor )
3359 {
3360 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3361
3362 if (!amg_data)
3363 {
3364 hypre_error_in_arg(1);
3365 return hypre_error_flag;
3366 }
3367 if (agg_trunc_factor < 0)
3368 {
3369 hypre_error_in_arg(2);
3370 return hypre_error_flag;
3371 }
3372 hypre_ParAMGDataAggTruncFactor(amg_data) = agg_trunc_factor;
3373
3374 return hypre_error_flag;
3375 }
3376
3377 /*--------------------------------------------------------------------------
3378 * Indicates the truncation factor for smoothed interpolation when using
3379 * mult-additive or simple method
3380 *--------------------------------------------------------------------------*/
3381
3382 HYPRE_Int
hypre_BoomerAMGSetMultAddTruncFactor(void * data,HYPRE_Real add_trunc_factor)3383 hypre_BoomerAMGSetMultAddTruncFactor( void *data,
3384 HYPRE_Real add_trunc_factor )
3385 {
3386 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3387
3388 if (!amg_data)
3389 {
3390 hypre_error_in_arg(1);
3391 return hypre_error_flag;
3392 }
3393 if (add_trunc_factor < 0)
3394 {
3395 hypre_error_in_arg(2);
3396 return hypre_error_flag;
3397 }
3398 hypre_ParAMGDataMultAddTruncFactor(amg_data) = add_trunc_factor;
3399
3400 return hypre_error_flag;
3401 }
3402
3403 /*--------------------------------------------------------------------------
3404 * Indicates truncation factor for 1 stage of aggressive coarsening
3405 * two stage interpolation
3406 *--------------------------------------------------------------------------*/
3407
3408 HYPRE_Int
hypre_BoomerAMGSetAggP12TruncFactor(void * data,HYPRE_Real agg_P12_trunc_factor)3409 hypre_BoomerAMGSetAggP12TruncFactor( void *data,
3410 HYPRE_Real agg_P12_trunc_factor )
3411 {
3412 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3413
3414 if (!amg_data)
3415 {
3416 hypre_error_in_arg(1);
3417 return hypre_error_flag;
3418 }
3419 if (agg_P12_trunc_factor < 0)
3420 {
3421 hypre_error_in_arg(2);
3422 return hypre_error_flag;
3423 }
3424 hypre_ParAMGDataAggP12TruncFactor(amg_data) = agg_P12_trunc_factor;
3425
3426 return hypre_error_flag;
3427 }
3428
3429 /*--------------------------------------------------------------------------
3430 * Indicates the number of relaxation steps for Compatible relaxation
3431 *--------------------------------------------------------------------------*/
3432
3433 HYPRE_Int
hypre_BoomerAMGSetNumCRRelaxSteps(void * data,HYPRE_Int num_CR_relax_steps)3434 hypre_BoomerAMGSetNumCRRelaxSteps( void *data,
3435 HYPRE_Int num_CR_relax_steps )
3436 {
3437 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3438
3439 if (!amg_data)
3440 {
3441 hypre_error_in_arg(1);
3442 return hypre_error_flag;
3443 }
3444 if (num_CR_relax_steps < 1)
3445 {
3446 hypre_error_in_arg(2);
3447 return hypre_error_flag;
3448 }
3449 hypre_ParAMGDataNumCRRelaxSteps(amg_data) = num_CR_relax_steps;
3450
3451 return hypre_error_flag;
3452 }
3453
3454 /*--------------------------------------------------------------------------
3455 * Indicates the desired convergence rate for Compatible relaxation
3456 *--------------------------------------------------------------------------*/
3457
3458 HYPRE_Int
hypre_BoomerAMGSetCRRate(void * data,HYPRE_Real CR_rate)3459 hypre_BoomerAMGSetCRRate( void *data,
3460 HYPRE_Real CR_rate )
3461 {
3462 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3463
3464 if (!amg_data)
3465 {
3466 hypre_error_in_arg(1);
3467 return hypre_error_flag;
3468 }
3469 hypre_ParAMGDataCRRate(amg_data) = CR_rate;
3470
3471 return hypre_error_flag;
3472 }
3473
3474 /*--------------------------------------------------------------------------
3475 * Indicates the desired convergence rate for Compatible relaxation
3476 *--------------------------------------------------------------------------*/
3477
3478 HYPRE_Int
hypre_BoomerAMGSetCRStrongTh(void * data,HYPRE_Real CR_strong_th)3479 hypre_BoomerAMGSetCRStrongTh( void *data,
3480 HYPRE_Real CR_strong_th )
3481 {
3482 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3483
3484 if (!amg_data)
3485 {
3486 hypre_error_in_arg(1);
3487 return hypre_error_flag;
3488 }
3489 hypre_ParAMGDataCRStrongTh(amg_data) = CR_strong_th;
3490
3491 return hypre_error_flag;
3492 }
3493
3494 /*--------------------------------------------------------------------------
3495 * Indicates the drop tolerance for A-matrices from the 2nd level of AMG
3496 *--------------------------------------------------------------------------*/
3497
3498 HYPRE_Int
hypre_BoomerAMGSetADropTol(void * data,HYPRE_Real A_drop_tol)3499 hypre_BoomerAMGSetADropTol( void *data,
3500 HYPRE_Real A_drop_tol )
3501 {
3502 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3503
3504 if (!amg_data)
3505 {
3506 hypre_error_in_arg(1);
3507 return hypre_error_flag;
3508 }
3509 hypre_ParAMGDataADropTol(amg_data) = A_drop_tol;
3510
3511 return hypre_error_flag;
3512 }
3513
3514 HYPRE_Int
hypre_BoomerAMGSetADropType(void * data,HYPRE_Int A_drop_type)3515 hypre_BoomerAMGSetADropType( void *data,
3516 HYPRE_Int A_drop_type )
3517 {
3518 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3519
3520 if (!amg_data)
3521 {
3522 hypre_error_in_arg(1);
3523 return hypre_error_flag;
3524 }
3525 hypre_ParAMGDataADropType(amg_data) = A_drop_type;
3526
3527 return hypre_error_flag;
3528 }
3529 /*--------------------------------------------------------------------------
3530 * Indicates which independent set algorithm is used for CR
3531 *--------------------------------------------------------------------------*/
3532
3533 HYPRE_Int
hypre_BoomerAMGSetISType(void * data,HYPRE_Int IS_type)3534 hypre_BoomerAMGSetISType( void *data,
3535 HYPRE_Int IS_type )
3536 {
3537 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3538
3539 if (!amg_data)
3540 {
3541 hypre_error_in_arg(1);
3542 return hypre_error_flag;
3543 }
3544 if (IS_type < 0)
3545 {
3546 hypre_error_in_arg(2);
3547 return hypre_error_flag;
3548 }
3549 hypre_ParAMGDataISType(amg_data) = IS_type;
3550
3551 return hypre_error_flag;
3552 }
3553
3554 /*--------------------------------------------------------------------------
3555 * Indicates whether to use CG for compatible relaxation
3556 *--------------------------------------------------------------------------*/
3557
3558 HYPRE_Int
hypre_BoomerAMGSetCRUseCG(void * data,HYPRE_Int CR_use_CG)3559 hypre_BoomerAMGSetCRUseCG( void *data,
3560 HYPRE_Int CR_use_CG )
3561 {
3562 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3563
3564 if (!amg_data)
3565 {
3566 hypre_error_in_arg(1);
3567 return hypre_error_flag;
3568 }
3569 hypre_ParAMGDataCRUseCG(amg_data) = CR_use_CG;
3570
3571 return hypre_error_flag;
3572 }
3573
3574 HYPRE_Int
hypre_BoomerAMGSetNumPoints(void * data,HYPRE_Int num_points)3575 hypre_BoomerAMGSetNumPoints( void *data,
3576 HYPRE_Int num_points )
3577 {
3578 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3579
3580 if (!amg_data)
3581 {
3582 hypre_error_in_arg(1);
3583 return hypre_error_flag;
3584 }
3585 hypre_ParAMGDataNumPoints(amg_data) = num_points;
3586
3587 return hypre_error_flag;
3588 }
3589
3590 HYPRE_Int
hypre_BoomerAMGSetDofFunc(void * data,HYPRE_Int * dof_func)3591 hypre_BoomerAMGSetDofFunc( void *data,
3592 HYPRE_Int *dof_func)
3593 {
3594 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3595
3596 if (!amg_data)
3597 {
3598 hypre_error_in_arg(1);
3599 return hypre_error_flag;
3600 }
3601 hypre_IntArrayDestroy(hypre_ParAMGDataDofFunc(amg_data));
3602 /* NOTE: size of hypre_IntArray will be set during AMG setup
3603 * the memory location is assumed to be host */
3604 if (dof_func == NULL)
3605 {
3606 hypre_ParAMGDataDofFunc(amg_data) = NULL;
3607 }
3608 else
3609 {
3610 hypre_ParAMGDataDofFunc(amg_data) = hypre_IntArrayCreate(-1);
3611 hypre_IntArrayMemoryLocation(hypre_ParAMGDataDofFunc(amg_data)) = HYPRE_MEMORY_DEVICE;
3612 hypre_IntArrayData(hypre_ParAMGDataDofFunc(amg_data)) = dof_func;
3613 }
3614
3615 return hypre_error_flag;
3616 }
3617
3618 HYPRE_Int
hypre_BoomerAMGSetPointDofMap(void * data,HYPRE_Int * point_dof_map)3619 hypre_BoomerAMGSetPointDofMap( void *data,
3620 HYPRE_Int *point_dof_map )
3621 {
3622 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3623
3624 if (!amg_data)
3625 {
3626 hypre_error_in_arg(1);
3627 return hypre_error_flag;
3628 }
3629 hypre_TFree(hypre_ParAMGDataPointDofMap(amg_data), HYPRE_MEMORY_HOST);
3630 hypre_ParAMGDataPointDofMap(amg_data) = point_dof_map;
3631
3632 return hypre_error_flag;
3633 }
3634
3635 HYPRE_Int
hypre_BoomerAMGSetDofPoint(void * data,HYPRE_Int * dof_point)3636 hypre_BoomerAMGSetDofPoint( void *data,
3637 HYPRE_Int *dof_point )
3638 {
3639 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3640
3641 if (!amg_data)
3642 {
3643 hypre_error_in_arg(1);
3644 return hypre_error_flag;
3645 }
3646 hypre_TFree(hypre_ParAMGDataDofPoint(amg_data), HYPRE_MEMORY_HOST);
3647 hypre_ParAMGDataDofPoint(amg_data) = dof_point;
3648
3649 return hypre_error_flag;
3650 }
3651
3652 HYPRE_Int
hypre_BoomerAMGGetNumIterations(void * data,HYPRE_Int * num_iterations)3653 hypre_BoomerAMGGetNumIterations( void *data,
3654 HYPRE_Int *num_iterations )
3655 {
3656 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3657
3658 if (!amg_data)
3659 {
3660 hypre_error_in_arg(1);
3661 return hypre_error_flag;
3662 }
3663 *num_iterations = hypre_ParAMGDataNumIterations(amg_data);
3664
3665 return hypre_error_flag;
3666 }
3667
3668 HYPRE_Int
hypre_BoomerAMGGetCumNumIterations(void * data,HYPRE_Int * cum_num_iterations)3669 hypre_BoomerAMGGetCumNumIterations( void *data,
3670 HYPRE_Int *cum_num_iterations )
3671 {
3672 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3673
3674 if (!amg_data)
3675 {
3676 hypre_error_in_arg(1);
3677 return hypre_error_flag;
3678 }
3679 #ifdef CUMNUMIT
3680 *cum_num_iterations = hypre_ParAMGDataCumNumIterations(amg_data);
3681 #endif
3682
3683 return hypre_error_flag;
3684 }
3685
3686 HYPRE_Int
hypre_BoomerAMGGetResidual(void * data,hypre_ParVector ** resid)3687 hypre_BoomerAMGGetResidual( void * data, hypre_ParVector ** resid )
3688 {
3689 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3690 if (!amg_data)
3691 {
3692 hypre_error_in_arg(1);
3693 return hypre_error_flag;
3694 }
3695 *resid = hypre_ParAMGDataResidual( amg_data );
3696 return hypre_error_flag;
3697 }
3698
3699
3700 HYPRE_Int
hypre_BoomerAMGGetRelResidualNorm(void * data,HYPRE_Real * rel_resid_norm)3701 hypre_BoomerAMGGetRelResidualNorm( void *data,
3702 HYPRE_Real *rel_resid_norm )
3703 {
3704 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3705
3706 if (!amg_data)
3707 {
3708 hypre_error_in_arg(1);
3709 return hypre_error_flag;
3710 }
3711 *rel_resid_norm = hypre_ParAMGDataRelativeResidualNorm(amg_data);
3712
3713 return hypre_error_flag;
3714 }
3715
3716 HYPRE_Int
hypre_BoomerAMGSetVariant(void * data,HYPRE_Int variant)3717 hypre_BoomerAMGSetVariant( void *data,
3718 HYPRE_Int variant)
3719 {
3720 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3721
3722 if (!amg_data)
3723 {
3724 hypre_error_in_arg(1);
3725 return hypre_error_flag;
3726 }
3727 if (variant < 0)
3728 {
3729 hypre_error_in_arg(2);
3730 return hypre_error_flag;
3731 }
3732 hypre_ParAMGDataVariant(amg_data) = variant;
3733
3734 return hypre_error_flag;
3735 }
3736
3737 HYPRE_Int
hypre_BoomerAMGGetVariant(void * data,HYPRE_Int * variant)3738 hypre_BoomerAMGGetVariant( void *data,
3739 HYPRE_Int * variant)
3740 {
3741 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3742
3743 if (!amg_data)
3744 {
3745 hypre_error_in_arg(1);
3746 return hypre_error_flag;
3747 }
3748 *variant = hypre_ParAMGDataVariant(amg_data);
3749
3750 return hypre_error_flag;
3751 }
3752
3753 HYPRE_Int
hypre_BoomerAMGSetOverlap(void * data,HYPRE_Int overlap)3754 hypre_BoomerAMGSetOverlap( void *data,
3755 HYPRE_Int overlap)
3756 {
3757 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3758
3759 if (!amg_data)
3760 {
3761 hypre_error_in_arg(1);
3762 return hypre_error_flag;
3763 }
3764 if (overlap < 0)
3765 {
3766 hypre_error_in_arg(2);
3767 return hypre_error_flag;
3768 }
3769 hypre_ParAMGDataOverlap(amg_data) = overlap;
3770
3771 return hypre_error_flag;
3772 }
3773
3774 HYPRE_Int
hypre_BoomerAMGGetOverlap(void * data,HYPRE_Int * overlap)3775 hypre_BoomerAMGGetOverlap( void *data,
3776 HYPRE_Int * overlap)
3777 {
3778 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3779
3780 if (!amg_data)
3781 {
3782 hypre_error_in_arg(1);
3783 return hypre_error_flag;
3784 }
3785 *overlap = hypre_ParAMGDataOverlap(amg_data);
3786
3787 return hypre_error_flag;
3788 }
3789
3790 HYPRE_Int
hypre_BoomerAMGSetDomainType(void * data,HYPRE_Int domain_type)3791 hypre_BoomerAMGSetDomainType( void *data,
3792 HYPRE_Int domain_type)
3793 {
3794 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3795
3796 if (!amg_data)
3797 {
3798 hypre_error_in_arg(1);
3799 return hypre_error_flag;
3800 }
3801 if (domain_type < 0)
3802 {
3803 hypre_error_in_arg(2);
3804 return hypre_error_flag;
3805 }
3806 hypre_ParAMGDataDomainType(amg_data) = domain_type;
3807
3808 return hypre_error_flag;
3809 }
3810
3811 HYPRE_Int
hypre_BoomerAMGGetDomainType(void * data,HYPRE_Int * domain_type)3812 hypre_BoomerAMGGetDomainType( void *data,
3813 HYPRE_Int * domain_type)
3814 {
3815 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3816
3817 if (!amg_data)
3818 {
3819 hypre_error_in_arg(1);
3820 return hypre_error_flag;
3821 }
3822 *domain_type = hypre_ParAMGDataDomainType(amg_data);
3823
3824 return hypre_error_flag;
3825 }
3826
3827 HYPRE_Int
hypre_BoomerAMGSetSchwarzRlxWeight(void * data,HYPRE_Real schwarz_rlx_weight)3828 hypre_BoomerAMGSetSchwarzRlxWeight( void *data,
3829 HYPRE_Real schwarz_rlx_weight)
3830 {
3831 hypre_ParAMGData *amg_data = (hypre_ParAMGData*)data;
3832
3833 if (!amg_data)
3834 {
3835 hypre_error_in_arg(1);
3836 return hypre_error_flag;
3837 }
3838 hypre_ParAMGDataSchwarzRlxWeight(amg_data) = schwarz_rlx_weight;
3839
3840 return hypre_error_flag;
3841 }
3842
3843 HYPRE_Int
hypre_BoomerAMGGetSchwarzRlxWeight(void * data,HYPRE_Real * schwarz_rlx_weight)3844 hypre_BoomerAMGGetSchwarzRlxWeight( void *data,
3845 HYPRE_Real * schwarz_rlx_weight)
3846 {
3847 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3848
3849 if (!amg_data)
3850 {
3851 hypre_error_in_arg(1);
3852 return hypre_error_flag;
3853 }
3854 *schwarz_rlx_weight = hypre_ParAMGDataSchwarzRlxWeight(amg_data);
3855
3856 return hypre_error_flag;
3857 }
3858
3859 HYPRE_Int
hypre_BoomerAMGSetSchwarzUseNonSymm(void * data,HYPRE_Int use_nonsymm)3860 hypre_BoomerAMGSetSchwarzUseNonSymm( void *data,
3861 HYPRE_Int use_nonsymm)
3862 {
3863 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3864
3865 if (!amg_data)
3866 {
3867 hypre_error_in_arg(1);
3868 return hypre_error_flag;
3869 }
3870 hypre_ParAMGDataSchwarzUseNonSymm(amg_data) = use_nonsymm;
3871
3872 return hypre_error_flag;
3873 }
3874
3875 HYPRE_Int
hypre_BoomerAMGSetSym(void * data,HYPRE_Int sym)3876 hypre_BoomerAMGSetSym( void *data,
3877 HYPRE_Int sym)
3878 {
3879 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3880
3881 if (!amg_data)
3882 {
3883 hypre_error_in_arg(1);
3884 return hypre_error_flag;
3885 }
3886 hypre_ParAMGDataSym(amg_data) = sym;
3887
3888 return hypre_error_flag;
3889 }
3890
3891 HYPRE_Int
hypre_BoomerAMGSetLevel(void * data,HYPRE_Int level)3892 hypre_BoomerAMGSetLevel( void *data,
3893 HYPRE_Int level)
3894 {
3895 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3896
3897 if (!amg_data)
3898 {
3899 hypre_error_in_arg(1);
3900 return hypre_error_flag;
3901 }
3902 hypre_ParAMGDataLevel(amg_data) = level;
3903
3904 return hypre_error_flag;
3905 }
3906
3907 HYPRE_Int
hypre_BoomerAMGSetThreshold(void * data,HYPRE_Real thresh)3908 hypre_BoomerAMGSetThreshold( void *data,
3909 HYPRE_Real thresh)
3910 {
3911 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3912
3913 if (!amg_data)
3914 {
3915 hypre_error_in_arg(1);
3916 return hypre_error_flag;
3917 }
3918 hypre_ParAMGDataThreshold(amg_data) = thresh;
3919
3920 return hypre_error_flag;
3921 }
3922
3923 HYPRE_Int
hypre_BoomerAMGSetFilter(void * data,HYPRE_Real filter)3924 hypre_BoomerAMGSetFilter( void *data,
3925 HYPRE_Real filter)
3926 {
3927 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3928
3929 if (!amg_data)
3930 {
3931 hypre_error_in_arg(1);
3932 return hypre_error_flag;
3933 }
3934 hypre_ParAMGDataFilter(amg_data) = filter;
3935
3936 return hypre_error_flag;
3937 }
3938
3939 HYPRE_Int
hypre_BoomerAMGSetDropTol(void * data,HYPRE_Real drop_tol)3940 hypre_BoomerAMGSetDropTol( void *data,
3941 HYPRE_Real drop_tol)
3942 {
3943 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3944
3945 if (!amg_data)
3946 {
3947 hypre_error_in_arg(1);
3948 return hypre_error_flag;
3949 }
3950 hypre_ParAMGDataDropTol(amg_data) = drop_tol;
3951
3952 return hypre_error_flag;
3953 }
3954
3955 HYPRE_Int
hypre_BoomerAMGSetMaxNzPerRow(void * data,HYPRE_Int max_nz_per_row)3956 hypre_BoomerAMGSetMaxNzPerRow( void *data,
3957 HYPRE_Int max_nz_per_row)
3958 {
3959 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3960
3961 if (!amg_data)
3962 {
3963 hypre_error_in_arg(1);
3964 return hypre_error_flag;
3965 }
3966 if (max_nz_per_row < 0)
3967 {
3968 hypre_error_in_arg(2);
3969 return hypre_error_flag;
3970 }
3971 hypre_ParAMGDataMaxNzPerRow(amg_data) = max_nz_per_row;
3972
3973 return hypre_error_flag;
3974 }
3975
3976 HYPRE_Int
hypre_BoomerAMGSetEuclidFile(void * data,char * euclidfile)3977 hypre_BoomerAMGSetEuclidFile( void *data,
3978 char *euclidfile)
3979 {
3980 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3981
3982 if (!amg_data)
3983 {
3984 hypre_error_in_arg(1);
3985 return hypre_error_flag;
3986 }
3987 hypre_ParAMGDataEuclidFile(amg_data) = euclidfile;
3988
3989 return hypre_error_flag;
3990 }
3991
3992 HYPRE_Int
hypre_BoomerAMGSetEuLevel(void * data,HYPRE_Int eu_level)3993 hypre_BoomerAMGSetEuLevel( void *data,
3994 HYPRE_Int eu_level)
3995 {
3996 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
3997
3998 if (!amg_data)
3999 {
4000 hypre_error_in_arg(1);
4001 return hypre_error_flag;
4002 }
4003 hypre_ParAMGDataEuLevel(amg_data) = eu_level;
4004
4005 return hypre_error_flag;
4006 }
4007
4008 HYPRE_Int
hypre_BoomerAMGSetEuSparseA(void * data,HYPRE_Real eu_sparse_A)4009 hypre_BoomerAMGSetEuSparseA( void *data,
4010 HYPRE_Real eu_sparse_A)
4011 {
4012 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4013
4014 if (!amg_data)
4015 {
4016 hypre_error_in_arg(1);
4017 return hypre_error_flag;
4018 }
4019 hypre_ParAMGDataEuSparseA(amg_data) = eu_sparse_A;
4020
4021 return hypre_error_flag;
4022 }
4023
4024 HYPRE_Int
hypre_BoomerAMGSetEuBJ(void * data,HYPRE_Int eu_bj)4025 hypre_BoomerAMGSetEuBJ( void *data,
4026 HYPRE_Int eu_bj)
4027 {
4028 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4029
4030 if (!amg_data)
4031 {
4032 hypre_error_in_arg(1);
4033 return hypre_error_flag;
4034 }
4035 hypre_ParAMGDataEuBJ(amg_data) = eu_bj;
4036
4037 return hypre_error_flag;
4038 }
4039 HYPRE_Int
hypre_BoomerAMGSetILUType(void * data,HYPRE_Int ilu_type)4040 hypre_BoomerAMGSetILUType( void *data,
4041 HYPRE_Int ilu_type)
4042 {
4043 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4044
4045 if (!amg_data)
4046 {
4047 hypre_error_in_arg(1);
4048 return hypre_error_flag;
4049 }
4050 hypre_ParAMGDataILUType(amg_data) = ilu_type;
4051
4052 return hypre_error_flag;
4053 }
4054 HYPRE_Int
hypre_BoomerAMGSetILULevel(void * data,HYPRE_Int ilu_lfil)4055 hypre_BoomerAMGSetILULevel( void *data,
4056 HYPRE_Int ilu_lfil)
4057 {
4058 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4059
4060 if (!amg_data)
4061 {
4062 hypre_error_in_arg(1);
4063 return hypre_error_flag;
4064 }
4065 hypre_ParAMGDataILULevel(amg_data) = ilu_lfil;
4066
4067 return hypre_error_flag;
4068 }
4069 HYPRE_Int
hypre_BoomerAMGSetILUDroptol(void * data,HYPRE_Real ilu_droptol)4070 hypre_BoomerAMGSetILUDroptol( void *data,
4071 HYPRE_Real ilu_droptol)
4072 {
4073 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4074
4075 if (!amg_data)
4076 {
4077 hypre_error_in_arg(1);
4078 return hypre_error_flag;
4079 }
4080 hypre_ParAMGDataILUDroptol(amg_data) = ilu_droptol;
4081
4082 return hypre_error_flag;
4083 }
4084 HYPRE_Int
hypre_BoomerAMGSetILUMaxIter(void * data,HYPRE_Int ilu_max_iter)4085 hypre_BoomerAMGSetILUMaxIter( void *data,
4086 HYPRE_Int ilu_max_iter)
4087 {
4088 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4089
4090 if (!amg_data)
4091 {
4092 hypre_error_in_arg(1);
4093 return hypre_error_flag;
4094 }
4095 hypre_ParAMGDataILUMaxIter(amg_data) = ilu_max_iter;
4096
4097 return hypre_error_flag;
4098 }
4099 HYPRE_Int
hypre_BoomerAMGSetILUMaxRowNnz(void * data,HYPRE_Int ilu_max_row_nnz)4100 hypre_BoomerAMGSetILUMaxRowNnz( void *data,
4101 HYPRE_Int ilu_max_row_nnz)
4102 {
4103 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4104
4105 if (!amg_data)
4106 {
4107 hypre_error_in_arg(1);
4108 return hypre_error_flag;
4109 }
4110 hypre_ParAMGDataILUMaxRowNnz(amg_data) = ilu_max_row_nnz;
4111
4112 return hypre_error_flag;
4113 }
4114 HYPRE_Int
hypre_BoomerAMGSetILULocalReordering(void * data,HYPRE_Int ilu_reordering_type)4115 hypre_BoomerAMGSetILULocalReordering( void *data,
4116 HYPRE_Int ilu_reordering_type)
4117 {
4118 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4119
4120 if (!amg_data)
4121 {
4122 hypre_error_in_arg(1);
4123 return hypre_error_flag;
4124 }
4125 hypre_ParAMGDataILULocalReordering(amg_data) = ilu_reordering_type;
4126
4127 return hypre_error_flag;
4128 }
4129 HYPRE_Int
hypre_BoomerAMGSetChebyOrder(void * data,HYPRE_Int order)4130 hypre_BoomerAMGSetChebyOrder( void *data,
4131 HYPRE_Int order)
4132 {
4133 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4134
4135 if (!amg_data)
4136 {
4137 hypre_error_in_arg(1);
4138 return hypre_error_flag;
4139 }
4140 if (order < 1)
4141 {
4142 hypre_error_in_arg(2);
4143 return hypre_error_flag;
4144 }
4145 hypre_ParAMGDataChebyOrder(amg_data) = order;
4146
4147 return hypre_error_flag;
4148 }
4149 HYPRE_Int
hypre_BoomerAMGSetChebyFraction(void * data,HYPRE_Real ratio)4150 hypre_BoomerAMGSetChebyFraction( void *data,
4151 HYPRE_Real ratio)
4152 {
4153 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4154
4155 if (!amg_data)
4156 {
4157 hypre_error_in_arg(1);
4158 return hypre_error_flag;
4159 }
4160 if (ratio <= 0.0 || ratio > 1.0 )
4161 {
4162 hypre_error_in_arg(2);
4163 return hypre_error_flag;
4164 }
4165 hypre_ParAMGDataChebyFraction(amg_data) = ratio;
4166
4167 return hypre_error_flag;
4168 }
4169 HYPRE_Int
hypre_BoomerAMGSetChebyEigEst(void * data,HYPRE_Int cheby_eig_est)4170 hypre_BoomerAMGSetChebyEigEst( void *data,
4171 HYPRE_Int cheby_eig_est)
4172 {
4173 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4174
4175 if (!amg_data)
4176 {
4177 hypre_error_in_arg(1);
4178 return hypre_error_flag;
4179 }
4180 if (cheby_eig_est < 0)
4181 {
4182 hypre_error_in_arg(2);
4183 return hypre_error_flag;
4184 }
4185 hypre_ParAMGDataChebyEigEst(amg_data) = cheby_eig_est;
4186
4187 return hypre_error_flag;
4188 }
4189 HYPRE_Int
hypre_BoomerAMGSetChebyVariant(void * data,HYPRE_Int cheby_variant)4190 hypre_BoomerAMGSetChebyVariant( void *data,
4191 HYPRE_Int cheby_variant)
4192 {
4193 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4194
4195 if (!amg_data)
4196 {
4197 hypre_error_in_arg(1);
4198 return hypre_error_flag;
4199 }
4200 hypre_ParAMGDataChebyVariant(amg_data) = cheby_variant;
4201
4202 return hypre_error_flag;
4203 }
4204 HYPRE_Int
hypre_BoomerAMGSetChebyScale(void * data,HYPRE_Int cheby_scale)4205 hypre_BoomerAMGSetChebyScale( void *data,
4206 HYPRE_Int cheby_scale)
4207 {
4208 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4209
4210 if (!amg_data)
4211 {
4212 hypre_error_in_arg(1);
4213 return hypre_error_flag;
4214 }
4215 hypre_ParAMGDataChebyScale(amg_data) = cheby_scale;
4216
4217 return hypre_error_flag;
4218 }
4219
4220
4221 /*--------------------------------------------------------------------------
4222 * hypre_BoomerAMGSetInterpVectors
4223 * -used for post-interpolation fitting of smooth vectors
4224 *--------------------------------------------------------------------------*/
4225
hypre_BoomerAMGSetInterpVectors(void * solver,HYPRE_Int num_vectors,hypre_ParVector ** interp_vectors)4226 HYPRE_Int hypre_BoomerAMGSetInterpVectors(void *solver,
4227 HYPRE_Int num_vectors,
4228 hypre_ParVector **interp_vectors)
4229
4230 {
4231 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) solver;
4232 if (!amg_data)
4233 {
4234 hypre_error_in_arg(1);
4235 return hypre_error_flag;
4236 }
4237
4238 hypre_ParAMGInterpVectors(amg_data) = interp_vectors;
4239 hypre_ParAMGNumInterpVectors(amg_data) = num_vectors;
4240
4241 return hypre_error_flag;
4242 }
4243
4244 /*--------------------------------------------------------------------------
4245 * hypre_BoomerAMGSetInterpVectorValues
4246 * -used for post-interpolation fitting of smooth vectors
4247 *--------------------------------------------------------------------------*/
4248
4249 /*HYPRE_Int hypre_BoomerAMGSetInterpVectorValues(void *solver,
4250 HYPRE_Int num_vectors,
4251 HYPRE_Complex *interp_vector_values)
4252
4253 {
4254 hypre_ParAMGData *amg_data = solver;
4255 if (!amg_data)
4256 {
4257 hypre_error_in_arg(1);
4258 return hypre_error_flag;
4259 }
4260
4261 hypre_ParAMGInterpVectors(amg_data) = interp_vectors;
4262 hypre_ParAMGNumInterpVectors(amg_data) = num_vectors;
4263
4264 return hypre_error_flag;
4265 }*/
4266
hypre_BoomerAMGSetInterpVecVariant(void * solver,HYPRE_Int var)4267 HYPRE_Int hypre_BoomerAMGSetInterpVecVariant(void *solver,
4268 HYPRE_Int var)
4269
4270
4271 {
4272 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) solver;
4273 if (!amg_data)
4274 {
4275 hypre_error_in_arg(1);
4276 return hypre_error_flag;
4277 }
4278
4279 if (var < 1)
4280 var = 0;
4281 if (var > 3)
4282 var = 3;
4283
4284 hypre_ParAMGInterpVecVariant(amg_data) = var;
4285
4286 return hypre_error_flag;
4287
4288 }
4289
4290 HYPRE_Int
hypre_BoomerAMGSetInterpVecQMax(void * data,HYPRE_Int q_max)4291 hypre_BoomerAMGSetInterpVecQMax( void *data,
4292 HYPRE_Int q_max)
4293 {
4294 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4295
4296 if (!amg_data)
4297 {
4298 hypre_error_in_arg(1);
4299 return hypre_error_flag;
4300 }
4301 hypre_ParAMGInterpVecQMax(amg_data) = q_max;
4302
4303 return hypre_error_flag;
4304 }
4305
4306 HYPRE_Int
hypre_BoomerAMGSetInterpVecAbsQTrunc(void * data,HYPRE_Real q_trunc)4307 hypre_BoomerAMGSetInterpVecAbsQTrunc( void *data,
4308 HYPRE_Real q_trunc)
4309 {
4310 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4311
4312 if (!amg_data)
4313 {
4314 hypre_error_in_arg(1);
4315 return hypre_error_flag;
4316 }
4317 hypre_ParAMGInterpVecAbsQTrunc(amg_data) = q_trunc;
4318
4319 return hypre_error_flag;
4320 }
4321
hypre_BoomerAMGSetSmoothInterpVectors(void * solver,HYPRE_Int smooth_interp_vectors)4322 HYPRE_Int hypre_BoomerAMGSetSmoothInterpVectors(void *solver,
4323 HYPRE_Int smooth_interp_vectors)
4324
4325 {
4326 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) solver;
4327 if (!amg_data)
4328 {
4329 hypre_error_in_arg(1);
4330 return hypre_error_flag;
4331 }
4332
4333 hypre_ParAMGSmoothInterpVectors(amg_data) = smooth_interp_vectors;
4334
4335 return hypre_error_flag;
4336 }
4337
4338 HYPRE_Int
hypre_BoomerAMGSetInterpRefine(void * data,HYPRE_Int num_refine)4339 hypre_BoomerAMGSetInterpRefine( void *data,
4340 HYPRE_Int num_refine )
4341 {
4342 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4343
4344 if (!amg_data)
4345 {
4346 hypre_error_in_arg(1);
4347 return hypre_error_flag;
4348 }
4349
4350 hypre_ParAMGInterpRefine(amg_data) = num_refine;
4351
4352 return hypre_error_flag;
4353 }
4354
4355 HYPRE_Int
hypre_BoomerAMGSetInterpVecFirstLevel(void * data,HYPRE_Int level)4356 hypre_BoomerAMGSetInterpVecFirstLevel( void *data,
4357 HYPRE_Int level )
4358 {
4359 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4360
4361 if (!amg_data)
4362 {
4363 hypre_error_in_arg(1);
4364 return hypre_error_flag;
4365 }
4366
4367 hypre_ParAMGInterpVecFirstLevel(amg_data) = level;
4368
4369 return hypre_error_flag;
4370 }
4371
4372 HYPRE_Int
hypre_BoomerAMGSetAdditive(void * data,HYPRE_Int additive)4373 hypre_BoomerAMGSetAdditive( void *data,
4374 HYPRE_Int additive )
4375 {
4376 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4377
4378 if (!amg_data)
4379 {
4380 hypre_error_in_arg(1);
4381 return hypre_error_flag;
4382 }
4383
4384 hypre_ParAMGDataAdditive(amg_data) = additive;
4385
4386 return hypre_error_flag;
4387 }
4388
4389 HYPRE_Int
hypre_BoomerAMGGetAdditive(void * data,HYPRE_Int * additive)4390 hypre_BoomerAMGGetAdditive( void *data,
4391 HYPRE_Int * additive )
4392 {
4393 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4394
4395 if (!amg_data)
4396 {
4397 hypre_error_in_arg(1);
4398 return hypre_error_flag;
4399 }
4400
4401 *additive = hypre_ParAMGDataAdditive(amg_data);
4402
4403 return hypre_error_flag;
4404 }
4405
4406 HYPRE_Int
hypre_BoomerAMGSetMultAdditive(void * data,HYPRE_Int mult_additive)4407 hypre_BoomerAMGSetMultAdditive( void *data,
4408 HYPRE_Int mult_additive )
4409 {
4410 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4411
4412 if (!amg_data)
4413 {
4414 hypre_error_in_arg(1);
4415 return hypre_error_flag;
4416 }
4417
4418 hypre_ParAMGDataMultAdditive(amg_data) = mult_additive;
4419
4420 return hypre_error_flag;
4421 }
4422
4423 HYPRE_Int
hypre_BoomerAMGGetMultAdditive(void * data,HYPRE_Int * mult_additive)4424 hypre_BoomerAMGGetMultAdditive( void *data,
4425 HYPRE_Int * mult_additive )
4426 {
4427 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4428
4429 if (!amg_data)
4430 {
4431 hypre_error_in_arg(1);
4432 return hypre_error_flag;
4433 }
4434
4435 *mult_additive = hypre_ParAMGDataMultAdditive(amg_data);
4436
4437 return hypre_error_flag;
4438 }
4439
4440 HYPRE_Int
hypre_BoomerAMGSetSimple(void * data,HYPRE_Int simple)4441 hypre_BoomerAMGSetSimple( void *data,
4442 HYPRE_Int simple )
4443 {
4444 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4445
4446 if (!amg_data)
4447 {
4448 hypre_error_in_arg(1);
4449 return hypre_error_flag;
4450 }
4451
4452 hypre_ParAMGDataSimple(amg_data) = simple;
4453
4454 return hypre_error_flag;
4455 }
4456
4457 HYPRE_Int
hypre_BoomerAMGGetSimple(void * data,HYPRE_Int * simple)4458 hypre_BoomerAMGGetSimple( void *data,
4459 HYPRE_Int * simple )
4460 {
4461 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4462
4463 if (!amg_data)
4464 {
4465 hypre_error_in_arg(1);
4466 return hypre_error_flag;
4467 }
4468
4469 *simple = hypre_ParAMGDataSimple(amg_data);
4470
4471 return hypre_error_flag;
4472 }
4473
4474 HYPRE_Int
hypre_BoomerAMGSetAddLastLvl(void * data,HYPRE_Int add_last_lvl)4475 hypre_BoomerAMGSetAddLastLvl( void *data,
4476 HYPRE_Int add_last_lvl )
4477 {
4478 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4479
4480 if (!amg_data)
4481 {
4482 hypre_error_in_arg(1);
4483 return hypre_error_flag;
4484 }
4485
4486 hypre_ParAMGDataAddLastLvl(amg_data) = add_last_lvl;
4487
4488 return hypre_error_flag;
4489 }
4490
4491 HYPRE_Int
hypre_BoomerAMGSetNonGalerkinTol(void * data,HYPRE_Real nongalerkin_tol)4492 hypre_BoomerAMGSetNonGalerkinTol( void *data,
4493 HYPRE_Real nongalerkin_tol)
4494 {
4495 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4496 HYPRE_Int i, max_num_levels;
4497 HYPRE_Real *nongal_tol_array;
4498
4499 if (!amg_data)
4500 {
4501 hypre_error_in_arg(1);
4502 return hypre_error_flag;
4503 }
4504 if (nongalerkin_tol < 0)
4505 {
4506 hypre_error_in_arg(2);
4507 return hypre_error_flag;
4508 }
4509 max_num_levels = hypre_ParAMGDataMaxLevels(amg_data);
4510 nongal_tol_array = hypre_ParAMGDataNonGalTolArray(amg_data);
4511
4512 if (nongal_tol_array == NULL)
4513 {
4514 nongal_tol_array = hypre_CTAlloc(HYPRE_Real, max_num_levels, HYPRE_MEMORY_HOST);
4515 hypre_ParAMGDataNonGalTolArray(amg_data) = nongal_tol_array;
4516 }
4517 hypre_ParAMGDataNonGalerkinTol(amg_data) = nongalerkin_tol;
4518
4519 for (i=0; i < max_num_levels; i++)
4520 nongal_tol_array[i] = nongalerkin_tol;
4521
4522 return hypre_error_flag;
4523 }
4524
4525 HYPRE_Int
hypre_BoomerAMGSetLevelNonGalerkinTol(void * data,HYPRE_Real nongalerkin_tol,HYPRE_Int level)4526 hypre_BoomerAMGSetLevelNonGalerkinTol( void *data,
4527 HYPRE_Real nongalerkin_tol,
4528 HYPRE_Int level)
4529 {
4530 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4531 HYPRE_Real *nongal_tol_array;
4532 HYPRE_Int max_num_levels;
4533
4534 if (!amg_data)
4535 {
4536 hypre_error_in_arg(1);
4537 return hypre_error_flag;
4538 }
4539
4540 if (nongalerkin_tol < 0)
4541 {
4542 hypre_error_in_arg(2);
4543 return hypre_error_flag;
4544 }
4545
4546 nongal_tol_array = hypre_ParAMGDataNonGalTolArray(amg_data);
4547 max_num_levels = hypre_ParAMGDataMaxLevels(amg_data);
4548
4549 if (nongal_tol_array == NULL)
4550 {
4551 nongal_tol_array = hypre_CTAlloc(HYPRE_Real, max_num_levels, HYPRE_MEMORY_HOST);
4552 hypre_ParAMGDataNonGalTolArray(amg_data) = nongal_tol_array;
4553 }
4554
4555 if (level+1 > max_num_levels)
4556 {
4557 hypre_error_in_arg(3);
4558 return hypre_error_flag;
4559 }
4560
4561 nongal_tol_array[level] = nongalerkin_tol;
4562 return hypre_error_flag;
4563 }
4564
4565 HYPRE_Int
hypre_BoomerAMGSetNonGalerkTol(void * data,HYPRE_Int nongalerk_num_tol,HYPRE_Real * nongalerk_tol)4566 hypre_BoomerAMGSetNonGalerkTol( void *data,
4567 HYPRE_Int nongalerk_num_tol,
4568 HYPRE_Real *nongalerk_tol)
4569 {
4570 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4571
4572 hypre_ParAMGDataNonGalerkNumTol(amg_data) = nongalerk_num_tol;
4573 hypre_ParAMGDataNonGalerkTol(amg_data) = nongalerk_tol;
4574 return hypre_error_flag;
4575 }
4576
4577 HYPRE_Int
hypre_BoomerAMGSetRAP2(void * data,HYPRE_Int rap2)4578 hypre_BoomerAMGSetRAP2( void *data,
4579 HYPRE_Int rap2 )
4580 {
4581 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4582
4583 hypre_ParAMGDataRAP2(amg_data) = rap2;
4584 return hypre_error_flag;
4585 }
4586
4587
4588 HYPRE_Int
hypre_BoomerAMGSetModuleRAP2(void * data,HYPRE_Int mod_rap2)4589 hypre_BoomerAMGSetModuleRAP2( void *data,
4590 HYPRE_Int mod_rap2 )
4591 {
4592 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4593
4594 hypre_ParAMGDataModularizedMatMat(amg_data) = mod_rap2;
4595 return hypre_error_flag;
4596 }
4597
4598 HYPRE_Int
hypre_BoomerAMGSetKeepTranspose(void * data,HYPRE_Int keepTranspose)4599 hypre_BoomerAMGSetKeepTranspose( void *data,
4600 HYPRE_Int keepTranspose)
4601 {
4602 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4603
4604 hypre_ParAMGDataKeepTranspose(amg_data) = keepTranspose;
4605 return hypre_error_flag;
4606 }
4607
4608 #ifdef HYPRE_USING_DSUPERLU
4609 HYPRE_Int
hypre_BoomerAMGSetDSLUThreshold(void * data,HYPRE_Int dslu_threshold)4610 hypre_BoomerAMGSetDSLUThreshold( void *data,
4611 HYPRE_Int dslu_threshold)
4612 {
4613 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4614
4615 hypre_ParAMGDataDSLUThreshold(amg_data) = dslu_threshold;
4616 return hypre_error_flag;
4617 }
4618 #endif
4619
4620 HYPRE_Int
hypre_BoomerAMGSetCPoints(void * data,HYPRE_Int cpt_coarse_level,HYPRE_Int num_cpt_coarse,HYPRE_BigInt * cpt_coarse_index)4621 hypre_BoomerAMGSetCPoints(void *data,
4622 HYPRE_Int cpt_coarse_level,
4623 HYPRE_Int num_cpt_coarse,
4624 HYPRE_BigInt *cpt_coarse_index)
4625 {
4626 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4627
4628 HYPRE_BigInt *C_points_marker = NULL;
4629 HYPRE_Int *C_points_local_marker = NULL;
4630 HYPRE_Int cpt_level;
4631 HYPRE_Int i;
4632
4633 if (!amg_data)
4634 {
4635 hypre_error_w_msg(HYPRE_ERROR_GENERIC, "Warning! AMG object empty!\n");
4636 hypre_error_in_arg(1);
4637 return hypre_error_flag;
4638 }
4639 if (cpt_coarse_level < 0)
4640 {
4641 hypre_error_w_msg(HYPRE_ERROR_GENERIC, "Warning! cpt_coarse_level < 0 !\n");
4642 hypre_error_in_arg(2);
4643 return hypre_error_flag;
4644 }
4645 if (num_cpt_coarse < 0)
4646 {
4647 hypre_error_w_msg(HYPRE_ERROR_GENERIC, "Warning! num_cpt_coarse < 0 !\n");
4648 hypre_error_in_arg(3);
4649 return hypre_error_flag;
4650 }
4651
4652 /* free data not previously destroyed */
4653 if (hypre_ParAMGDataCPointsLevel(amg_data))
4654 {
4655 hypre_TFree(hypre_ParAMGDataCPointsMarker(amg_data), HYPRE_MEMORY_HOST);
4656 hypre_TFree(hypre_ParAMGDataCPointsLocalMarker(amg_data), HYPRE_MEMORY_HOST);
4657 hypre_ParAMGDataCPointsMarker(amg_data) = NULL;
4658 hypre_ParAMGDataCPointsLocalMarker(amg_data) = NULL;
4659 }
4660
4661 /* set Cpoint data */
4662 if (hypre_ParAMGDataMaxLevels(amg_data) < cpt_coarse_level)
4663 {
4664 cpt_level = hypre_ParAMGDataNumLevels(amg_data);
4665 }
4666 else
4667 {
4668 cpt_level = cpt_coarse_level;
4669 }
4670
4671 if (cpt_level)
4672 {
4673 C_points_marker = hypre_CTAlloc(HYPRE_BigInt, num_cpt_coarse, HYPRE_MEMORY_HOST);
4674 C_points_local_marker = hypre_CTAlloc(HYPRE_Int, num_cpt_coarse, HYPRE_MEMORY_HOST);
4675
4676 /* copy Cpoints indexes */
4677 for (i = 0; i < num_cpt_coarse; i++)
4678 {
4679 C_points_marker[i] = cpt_coarse_index[i];
4680 }
4681 }
4682 hypre_ParAMGDataCPointsMarker(amg_data) = C_points_marker;
4683 hypre_ParAMGDataCPointsLocalMarker(amg_data) = C_points_local_marker;
4684 hypre_ParAMGDataNumCPoints(amg_data) = num_cpt_coarse;
4685 hypre_ParAMGDataCPointsLevel(amg_data) = cpt_level;
4686
4687 return hypre_error_flag;
4688 }
4689
4690 HYPRE_Int
hypre_BoomerAMGSetFPoints(void * data,HYPRE_Int isolated,HYPRE_Int num_points,HYPRE_BigInt * indices)4691 hypre_BoomerAMGSetFPoints(void *data,
4692 HYPRE_Int isolated,
4693 HYPRE_Int num_points,
4694 HYPRE_BigInt *indices)
4695 {
4696 hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
4697 HYPRE_BigInt *marker = NULL;
4698 HYPRE_Int i;
4699
4700 if (!amg_data)
4701 {
4702 hypre_error_w_msg(HYPRE_ERROR_GENERIC, "AMG object empty!\n");
4703 hypre_error_in_arg(1);
4704 return hypre_error_flag;
4705 }
4706
4707 if (num_points < 0)
4708 {
4709 hypre_error_w_msg(HYPRE_ERROR_GENERIC, "Warning! negative number of points!\n");
4710 hypre_error_in_arg(2);
4711 return hypre_error_flag;
4712 }
4713
4714
4715 if ((num_points > 0) && (!indices))
4716 {
4717 hypre_error_w_msg(HYPRE_ERROR_GENERIC, "Warning! indices not given!\n");
4718 hypre_error_in_arg(4);
4719 return hypre_error_flag;
4720 }
4721
4722 /* Set marker data */
4723 if (num_points > 0)
4724 {
4725 marker = hypre_CTAlloc(HYPRE_BigInt, num_points, HYPRE_MEMORY_HOST);
4726 for (i = 0; i < num_points; i++)
4727 {
4728 marker[i] = indices[i];
4729 }
4730 }
4731
4732 if (isolated)
4733 {
4734 /* Free data not previously destroyed */
4735 if (hypre_ParAMGDataIsolatedFPointsMarker(amg_data))
4736 {
4737 hypre_TFree(hypre_ParAMGDataIsolatedFPointsMarker(amg_data), HYPRE_MEMORY_HOST);
4738 hypre_ParAMGDataIsolatedFPointsMarker(amg_data) = NULL;
4739 }
4740
4741 hypre_ParAMGDataNumIsolatedFPoints(amg_data) = num_points;
4742 hypre_ParAMGDataIsolatedFPointsMarker(amg_data) = marker;
4743 }
4744 else
4745 {
4746 /* Free data not previously destroyed */
4747 if (hypre_ParAMGDataFPointsMarker(amg_data))
4748 {
4749 hypre_TFree(hypre_ParAMGDataFPointsMarker(amg_data), HYPRE_MEMORY_HOST);
4750 hypre_ParAMGDataFPointsMarker(amg_data) = NULL;
4751 }
4752
4753 hypre_ParAMGDataNumFPoints(amg_data) = num_points;
4754 hypre_ParAMGDataFPointsMarker(amg_data) = marker;
4755 }
4756
4757 return hypre_error_flag;
4758 }
4759