Fast Auxiliary Space Preconditioning 2.7.7 Aug/28/2022
AuxParam.c
Go to the documentation of this file.
1
14#include <stdio.h>
15
16#include "fasp.h"
17#include "fasp_functs.h"
18
19#if DEBUG_MODE > 1
20unsigned long total_alloc_mem;
21unsigned long total_alloc_count;
22#endif
23
24/*---------------------------------*/
25/*-- Public Functions --*/
26/*---------------------------------*/
27
41void fasp_param_set (const int argc,
42 const char *argv[],
43 input_param *iniparam)
44{
45 int arg_index = 1;
46 int print_usage = FALSE;
47 SHORT status = FASP_SUCCESS;
48
49 // Option 1. set default input parameters
50 fasp_param_input_init(iniparam);
51
52 while ( arg_index < argc ) {
53
54 if ( strcmp(argv[arg_index], "-help") == 0 ) {
55 print_usage = TRUE; break;
56 }
57
58 // Option 2. Get parameters from an ini file
59 else if ( strcmp(argv[arg_index], "-ini") == 0 ) {
60 arg_index++;
61 if ( arg_index >= argc ) {
62 printf("### ERROR: Missing ini filename! [%s]\n", __FUNCTION__);
63 print_usage = TRUE; break;
64 }
65 strcpy(iniparam->inifile, argv[arg_index]);
66 fasp_param_input(iniparam->inifile,iniparam);
67 if ( ++arg_index >= argc ) break;
68 }
69
70 // Option 3. Get parameters from command line input
71 else if ( strcmp(argv[arg_index], "-print") == 0 ) {
72 arg_index++;
73 if ( arg_index >= argc ) {
74 printf("### ERROR: Expecting print level (from 0 to 10).\n");
75 print_usage = TRUE; break;
76 }
77 iniparam->print_level = atoi(argv[arg_index]);
78 if ( ++arg_index >= argc ) break;
79 }
80
81 else if ( strcmp(argv[arg_index], "-output") == 0 ) {
82 arg_index++;
83 if ( arg_index >= argc ) {
84 printf("### ERROR: Expecting output type (0 or 1).\n");
85 print_usage = TRUE; break;
86 }
87 iniparam->output_type = atoi(argv[arg_index]);
88 if ( ++arg_index >= argc ) break;
89 }
90
91 else if ( strcmp(argv[arg_index], "-solver") == 0 ) {
92 arg_index++;
93 if ( arg_index >= argc ) {
94 printf("### ERROR: Expecting solver type.\n");
95 print_usage = TRUE; break;
96 }
97 iniparam->solver_type = atoi(argv[arg_index]);
98 if ( ++arg_index >= argc ) break;
99 }
100
101 else if ( strcmp(argv[arg_index], "-precond") == 0 ) {
102 arg_index++;
103 if ( arg_index >= argc ) {
104 printf("### ERROR: Expecting preconditioner type.\n");
105 print_usage = TRUE; break;
106 }
107 iniparam->precond_type = atoi(argv[arg_index]);
108 if ( ++arg_index >= argc ) break;
109 }
110
111 else if ( strcmp(argv[arg_index], "-maxit") == 0 ) {
112 arg_index++;
113 if ( arg_index >= argc ) {
114 printf("### ERROR: Expecting max number of iterations.\n");
115 print_usage = TRUE; break;
116 }
117 iniparam->itsolver_maxit = atoi(argv[arg_index]);
118 if ( ++arg_index >= argc ) break;
119 }
120
121 else if ( strcmp(argv[arg_index], "-tol") == 0 ) {
122 arg_index++;
123 if ( arg_index >= argc ) {
124 printf("### ERROR: Expecting tolerance for itsolver.\n");
125 print_usage = TRUE; break;
126 }
127 iniparam->itsolver_tol = atof(argv[arg_index]);
128 if ( ++arg_index >= argc ) break;
129 }
130
131 else if ( strcmp(argv[arg_index], "-amgmaxit") == 0 ) {
132 arg_index++;
133 if ( arg_index >= argc ) {
134 printf("### ERROR: Expecting max num of iterations for AMG.\n");
135 print_usage = TRUE; break;
136 }
137 iniparam->AMG_maxit = atoi(argv[arg_index]);
138 if ( ++arg_index >= argc ) break;
139 }
140
141 else if ( strcmp(argv[arg_index], "-amgtol") == 0 ) {
142 arg_index++;
143 if ( arg_index >= argc ) {
144 printf("### ERROR: Expecting tolerance for AMG.\n");
145 print_usage = TRUE; break;
146 }
147 iniparam->AMG_tol = atof(argv[arg_index]);
148 if ( ++arg_index >= argc ) break;
149 }
150
151 else if ( strcmp(argv[arg_index], "-amgtype") == 0 ) {
152 arg_index++;
153 if ( arg_index >= argc ) {
154 printf("### ERROR: Expecting AMG type (1, 2, 3).\n");
155 print_usage = TRUE; break;
156 }
157 iniparam->AMG_type = atoi(argv[arg_index]);
158 if ( ++arg_index >= argc ) break;
159 }
160
161 else if ( strcmp(argv[arg_index], "-amgcycle") == 0 ) {
162 arg_index++;
163 if ( arg_index >= argc ) {
164 printf("### ERROR: Expecting AMG cycle type (1, 2, 3, 12, 21).\n");
165 print_usage = TRUE; break;
166 }
167 iniparam->AMG_cycle_type = atoi(argv[arg_index]);
168 if ( ++arg_index >= argc ) break;
169 }
170
171 else if ( strcmp(argv[arg_index], "-amgcoarsening") == 0 ) {
172 arg_index++;
173 if ( arg_index >= argc ) {
174 printf("### ERROR: Expecting AMG coarsening type.\n");
175 print_usage = TRUE; break;
176 }
177 iniparam->AMG_coarsening_type = atoi(argv[arg_index]);
178 if ( ++arg_index >= argc ) break;
179 }
180
181 else if ( strcmp(argv[arg_index], "-amginterplation") == 0 ) {
182 arg_index++;
183 if ( arg_index >= argc ) {
184 printf("### ERROR: Expecting AMG interpolation type.\n");
185 print_usage = TRUE; break;
186 }
187 iniparam->AMG_interpolation_type = atoi(argv[arg_index]);
188 if ( ++arg_index >= argc ) break;
189 }
190
191 else if ( strcmp(argv[arg_index], "-amgsmoother") == 0 ) {
192 arg_index++;
193 if ( arg_index >= argc ) {
194 printf("### ERROR: Expecting AMG smoother type.\n");
195 print_usage = TRUE; break;
196 }
197 iniparam->AMG_smoother = atoi(argv[arg_index]);
198 if ( ++arg_index >= argc ) break;
199 }
200
201 else if ( strcmp(argv[arg_index], "-amgsthreshold") == 0 ) {
202 arg_index++;
203 if ( arg_index >= argc ) {
204 printf("### ERROR: Expecting AMG strong threshold.\n");
205 print_usage = TRUE; break;
206 }
207 iniparam->AMG_strong_threshold = atof(argv[arg_index]);
208 if ( ++arg_index >= argc ) break;
209 }
210
211 else if ( strcmp(argv[arg_index], "-amgscouple") == 0 ) {
212 arg_index++;
213 if ( arg_index >= argc ) {
214 printf("### ERROR: Expecting AMG strong coupled threshold.\n");
215 print_usage = TRUE; break;
216 }
217 iniparam->AMG_strong_coupled = atof(argv[arg_index]);
218 if ( ++arg_index >= argc ) break;
219 }
220
221 else {
222 print_usage = TRUE;
223 break;
224 }
225
226 }
227
228 if ( print_usage ) {
229
230 printf("FASP command line options:\n");
231
232 printf("================================================================\n");
233 printf(" -ini [CharValue] : Ini file name\n");
234 printf(" -print [IntValue] : Print level\n");
235 printf(" -output [IntValue] : Output to screen or a log file\n");
236 printf(" -solver [IntValue] : Solver type\n");
237 printf(" -precond [IntValue] : Preconditioner type\n");
238 printf(" -maxit [IntValue] : Max number of iterations\n");
239 printf(" -tol [RealValue] : Tolerance for iterative solvers\n");
240 printf(" -amgmaxit [IntValue] : Max number of AMG iterations\n");
241 printf(" -amgtol [RealValue] : Tolerance for AMG methods\n");
242 printf(" -amgtype [IntValue] : AMG type\n");
243 printf(" -amgcycle [IntValue] : AMG cycle type\n");
244 printf(" -amgcoarsening [IntValue] : AMG coarsening type\n");
245 printf(" -amginterpolation [IntValue] : AMG interpolation type\n");
246 printf(" -amgsmoother [IntValue] : AMG smoother type\n");
247 printf(" -amgsthreshold [RealValue] : AMG strong threshold\n");
248 printf(" -amgscoupled [RealValue] : AMG strong coupled threshold\n");
249 printf(" -help : Brief help messages\n");
250
251 exit(ERROR_INPUT_PAR);
252
253 }
254
255 // sanity checks
256 status = fasp_param_check(iniparam);
257
258 // if meet unexpected input, stop the program
259 fasp_chkerr(status, __FUNCTION__);
260
261}
262
283void fasp_param_init (const input_param *iniparam,
284 ITS_param *itsparam,
285 AMG_param *amgparam,
286 ILU_param *iluparam,
287 SWZ_param *swzparam)
288{
289#if DEBUG_MODE > 1
290 total_alloc_mem = 0; // initialize total memeory amount
291 total_alloc_count = 0; // initialize alloc count
292#endif
293
294 if (itsparam) fasp_param_solver_init(itsparam);
295 if (amgparam) fasp_param_amg_init(amgparam);
296 if (iluparam) fasp_param_ilu_init(iluparam);
297 if (swzparam) fasp_param_swz_init(swzparam);
298
299 if (iniparam) {
300 if (itsparam) fasp_param_solver_set(itsparam,iniparam);
301 if (amgparam) fasp_param_amg_set(amgparam,iniparam);
302 if (iluparam) fasp_param_ilu_set(iluparam,iniparam);
303 if (swzparam) fasp_param_swz_set(swzparam,iniparam);
304 }
305 else {
306 printf("### WARNING: No input given! Use default values instead.\n");
307 }
308
309 // if using AMG as a solver, set min num of iterations = 50
310 if ( (itsparam == NULL) && (amgparam != NULL) ) {
311 amgparam->maxit = MAX(amgparam->maxit, 50);
312 }
313}
314
326{
327 strcpy(iniparam->workdir,"../data/");
328
329 // Input/output
330 iniparam->print_level = PRINT_SOME;
331 iniparam->output_type = 0;
332
333 // Problem information
334 iniparam->problem_num = 10;
335 iniparam->solver_type = SOLVER_CG;
336 iniparam->decoup_type = 1;
337 iniparam->precond_type = PREC_AMG;
338 iniparam->stop_type = STOP_REL_RES;
339
340 // Solver parameters
341 iniparam->itsolver_tol = 1e-6;
342 iniparam->itsolver_maxit = 500;
343 iniparam->restart = 25;
344
345 // ILU method parameters
346 iniparam->ILU_type = ILUk;
347 iniparam->ILU_lfil = 0;
348 iniparam->ILU_droptol = 0.001;
349 iniparam->ILU_relax = 0;
350 iniparam->ILU_permtol = 0.0;
351
352 // Schwarz method parameters
353 iniparam->SWZ_mmsize = 200;
354 iniparam->SWZ_maxlvl = 2;
355 iniparam->SWZ_type = 1;
356 iniparam->SWZ_blksolver = SOLVER_DEFAULT;
357
358 // AMG method parameters
359 iniparam->AMG_type = CLASSIC_AMG;
360 iniparam->AMG_levels = 20;
361 iniparam->AMG_cycle_type = V_CYCLE;
362 iniparam->AMG_smoother = SMOOTHER_GS;
363 iniparam->AMG_smooth_order = CF_ORDER;
364 iniparam->AMG_presmooth_iter = 1;
365 iniparam->AMG_postsmooth_iter = 1;
366 iniparam->AMG_relaxation = 1.0;
367 iniparam->AMG_coarse_dof = 500;
368 iniparam->AMG_coarse_solver = 0;
369 iniparam->AMG_tol = 1e-6;
370 iniparam->AMG_maxit = 1;
371 iniparam->AMG_ILU_levels = 0;
372 iniparam->AMG_SWZ_levels = 0;
373 iniparam->AMG_coarse_scaling = OFF; // Require investigation --Chensong
374 iniparam->AMG_amli_degree = 1;
375 iniparam->AMG_nl_amli_krylov_type = 2;
376
377 // Classical AMG specific
378 iniparam->AMG_coarsening_type = 1;
379 iniparam->AMG_interpolation_type = 1;
380 iniparam->AMG_max_row_sum = 0.9;
381 iniparam->AMG_strong_threshold = 0.3;
382 iniparam->AMG_truncation_threshold = 0.2;
383 iniparam->AMG_aggressive_level = 0;
384 iniparam->AMG_aggressive_path = 1;
385
386 // Aggregation AMG specific
387 iniparam->AMG_aggregation_type = PAIRWISE;
388 iniparam->AMG_quality_bound = 8.0;
389 iniparam->AMG_pair_number = 2;
390 iniparam->AMG_strong_coupled = 0.25;
391 iniparam->AMG_max_aggregation = 9;
392 iniparam->AMG_tentative_smooth = 0.67;
393 iniparam->AMG_smooth_filter = ON;
394 iniparam->AMG_smooth_restriction = ON;
395}
396
408{
409 // General AMG parameters
410 amgparam->AMG_type = CLASSIC_AMG;
411 amgparam->print_level = PRINT_NONE;
412 amgparam->maxit = 1;
413 amgparam->tol = 1e-6;
414 amgparam->max_levels = 20;
415 amgparam->coarse_dof = 500;
416 amgparam->cycle_type = V_CYCLE;
417 amgparam->smoother = SMOOTHER_GS;
418 amgparam->smooth_order = CF_ORDER;
419 amgparam->presmooth_iter = 1;
420 amgparam->postsmooth_iter = 1;
421 amgparam->coarse_solver = SOLVER_DEFAULT;
422 amgparam->relaxation = 1.0;
423 amgparam->polynomial_degree = 3;
424 amgparam->coarse_scaling = OFF;
425 amgparam->amli_degree = 2;
426 amgparam->amli_coef = NULL;
428
429 // Classical AMG specific
430 amgparam->coarsening_type = COARSE_RS;
431 amgparam->interpolation_type = INTERP_DIR;
432 amgparam->max_row_sum = 0.9;
433 amgparam->strong_threshold = 0.3;
434 amgparam->truncation_threshold = 0.2;
435 amgparam->aggressive_level = 0;
436 amgparam->aggressive_path = 1;
437
438 // Aggregation AMG specific
439 amgparam->aggregation_type = PAIRWISE;
440 amgparam->quality_bound = 10.0;
441 amgparam->pair_number = 2;
442 amgparam->strong_coupled = 0.08;
443 amgparam->max_aggregation = 20;
444 amgparam->tentative_smooth = 0.67;
445 amgparam->smooth_filter = ON;
446 amgparam->smooth_restriction = ON;
447
448 // ILU smoother parameters
449 amgparam->ILU_type = ILUk;
450 amgparam->ILU_levels = 0;
451 amgparam->ILU_lfil = 0;
452 amgparam->ILU_droptol = 0.001;
453 amgparam->ILU_relax = 0;
454
455 // Schwarz smoother parameters
456 amgparam->SWZ_levels = 0; // levels will use Schwarz smoother
457 amgparam->SWZ_mmsize = 200;
458 amgparam->SWZ_maxlvl = 3; // vertices with smaller distance
459 amgparam->SWZ_type = 1;
460 amgparam->SWZ_blksolver = SOLVER_DEFAULT;
461}
462
474{
475 itsparam->print_level = PRINT_NONE;
476 itsparam->itsolver_type = SOLVER_CG;
477 itsparam->decoup_type = 1;
478 itsparam->precond_type = PREC_AMG;
479 itsparam->stop_type = STOP_REL_RES;
480 itsparam->maxit = 500;
481 itsparam->restart = 25;
482 itsparam->tol = 1e-6;
483}
484
496{
497 iluparam->print_level = PRINT_NONE;
498 iluparam->ILU_type = ILUk;
499 iluparam->ILU_lfil = 2;
500 iluparam->ILU_droptol = 0.001;
501 iluparam->ILU_relax = 0;
502 iluparam->ILU_permtol = 0.01;
503}
504
518{
519 swzparam->print_level = PRINT_NONE;
520 swzparam->SWZ_type = 3;
521 swzparam->SWZ_maxlvl = 2;
522 swzparam->SWZ_mmsize = 200;
523 swzparam->SWZ_blksolver = 0;
524}
525
538 const input_param *iniparam)
539{
540 param->AMG_type = iniparam->AMG_type;
541 param->print_level = iniparam->print_level;
542
543 if (iniparam->solver_type == SOLVER_AMG) {
544 param->maxit = iniparam->itsolver_maxit;
545 param->tol = iniparam->itsolver_tol;
546 }
547 else if (iniparam->solver_type == SOLVER_FMG) {
548 param->maxit = iniparam->itsolver_maxit;
549 param->tol = iniparam->itsolver_tol;
550 }
551 else {
552 param->maxit = iniparam->AMG_maxit;
553 param->tol = iniparam->AMG_tol;
554 }
555
556 param->max_levels = iniparam->AMG_levels;
557 param->cycle_type = iniparam->AMG_cycle_type;
558 param->smoother = iniparam->AMG_smoother;
559 param->smooth_order = iniparam->AMG_smooth_order;
560 param->relaxation = iniparam->AMG_relaxation;
561 param->coarse_solver = iniparam->AMG_coarse_solver;
562 param->polynomial_degree = iniparam->AMG_polynomial_degree;
563 param->presmooth_iter = iniparam->AMG_presmooth_iter;
564 param->postsmooth_iter = iniparam->AMG_postsmooth_iter;
565 param->coarse_dof = iniparam->AMG_coarse_dof;
566 param->coarse_scaling = iniparam->AMG_coarse_scaling;
567 param->amli_degree = iniparam->AMG_amli_degree;
568 param->amli_coef = NULL;
570
571 param->coarsening_type = iniparam->AMG_coarsening_type;
573 param->strong_threshold = iniparam->AMG_strong_threshold;
575 param->max_row_sum = iniparam->AMG_max_row_sum;
576 param->aggressive_level = iniparam->AMG_aggressive_level;
577 param->aggressive_path = iniparam->AMG_aggressive_path;
578
579 param->aggregation_type = iniparam->AMG_aggregation_type;
580 param->pair_number = iniparam->AMG_pair_number;
581 param->quality_bound = iniparam->AMG_quality_bound;
582 param->strong_coupled = iniparam->AMG_strong_coupled;
583 param->max_aggregation = iniparam->AMG_max_aggregation;
584 param->tentative_smooth = iniparam->AMG_tentative_smooth;
585 param->smooth_filter = iniparam->AMG_smooth_filter;
587
588 param->ILU_levels = iniparam->AMG_ILU_levels;
589 param->ILU_type = iniparam->ILU_type;
590 param->ILU_lfil = iniparam->ILU_lfil;
591 param->ILU_droptol = iniparam->ILU_droptol;
592 param->ILU_relax = iniparam->ILU_relax;
593 param->ILU_permtol = iniparam->ILU_permtol;
594
595 param->SWZ_levels = iniparam->AMG_SWZ_levels;
596 param->SWZ_mmsize = iniparam->SWZ_mmsize;
597 param->SWZ_maxlvl = iniparam->SWZ_maxlvl;
598 param->SWZ_type = iniparam->SWZ_type;
599}
600
613 const input_param *iniparam)
614{
615 iluparam->print_level = iniparam->print_level;
616 iluparam->ILU_type = iniparam->ILU_type;
617 iluparam->ILU_lfil = iniparam->ILU_lfil;
618 iluparam->ILU_droptol = iniparam->ILU_droptol;
619 iluparam->ILU_relax = iniparam->ILU_relax;
620 iluparam->ILU_permtol = iniparam->ILU_permtol;
621}
622
635 const input_param *iniparam)
636{
637 swzparam->print_level = iniparam->print_level;
638 swzparam->SWZ_type = iniparam->SWZ_type;
639 swzparam->SWZ_maxlvl = iniparam->SWZ_maxlvl;
640 swzparam->SWZ_mmsize = iniparam->SWZ_mmsize;
641 swzparam->SWZ_blksolver = iniparam->SWZ_blksolver;
642}
643
657 const input_param *iniparam)
658{
659 itsparam->print_level = iniparam->print_level;
660 itsparam->itsolver_type = iniparam->solver_type;
661 itsparam->decoup_type = iniparam->decoup_type;
662 itsparam->precond_type = iniparam->precond_type;
663 itsparam->stop_type = iniparam->stop_type;
664 itsparam->restart = iniparam->restart;
665
666 if ( itsparam->itsolver_type == SOLVER_AMG ) {
667 itsparam->tol = iniparam->AMG_tol;
668 itsparam->maxit = iniparam->AMG_maxit;
669 }
670 else {
671 itsparam->tol = iniparam->itsolver_tol;
672 itsparam->maxit = iniparam->itsolver_maxit;
673 }
674}
675
688 const AMG_param *amgparam)
689{
690 pcdata->AMG_type = amgparam->AMG_type;
691 pcdata->print_level = amgparam->print_level;
692 pcdata->maxit = amgparam->maxit;
693 pcdata->max_levels = amgparam->max_levels;
694 pcdata->tol = amgparam->tol;
695 pcdata->cycle_type = amgparam->cycle_type;
696 pcdata->smoother = amgparam->smoother;
697 pcdata->smooth_order = amgparam->smooth_order;
698 pcdata->presmooth_iter = amgparam->presmooth_iter;
699 pcdata->postsmooth_iter = amgparam->postsmooth_iter;
700 pcdata->coarsening_type = amgparam->coarsening_type;
701 pcdata->coarse_solver = amgparam->coarse_solver;
702 pcdata->relaxation = amgparam->relaxation;
703 pcdata->polynomial_degree = amgparam->polynomial_degree;
704 pcdata->coarse_scaling = amgparam->coarse_scaling;
705 pcdata->amli_degree = amgparam->amli_degree;
706 pcdata->amli_coef = amgparam->amli_coef;
707 pcdata->nl_amli_krylov_type = amgparam->nl_amli_krylov_type;
708 pcdata->tentative_smooth = amgparam->tentative_smooth;
709}
710
723 const precond_data *pcdata)
724{
725 amgparam->AMG_type = pcdata->AMG_type;
726 amgparam->print_level = pcdata->print_level;
727 amgparam->cycle_type = pcdata->cycle_type;
728 amgparam->smoother = pcdata->smoother;
729 amgparam->smooth_order = pcdata->smooth_order;
730 amgparam->presmooth_iter = pcdata->presmooth_iter;
731 amgparam->postsmooth_iter = pcdata->postsmooth_iter;
732 amgparam->relaxation = pcdata->relaxation;
733 amgparam->polynomial_degree = pcdata->polynomial_degree;
734 amgparam->coarse_solver = pcdata->coarse_solver;
735 amgparam->coarse_scaling = pcdata->coarse_scaling;
736 amgparam->amli_degree = pcdata->amli_degree;
737 amgparam->amli_coef = pcdata->amli_coef;
738 amgparam->nl_amli_krylov_type = pcdata->nl_amli_krylov_type;
739 amgparam->tentative_smooth = pcdata->tentative_smooth;
740 amgparam->ILU_levels = pcdata->mgl_data->ILU_levels;
741}
742
756 const AMG_param *amgparam)
757{
758 pcdata->AMG_type = amgparam->AMG_type;
759 pcdata->print_level = amgparam->print_level;
760 pcdata->maxit = amgparam->maxit;
761 pcdata->max_levels = amgparam->max_levels;
762 pcdata->tol = amgparam->tol;
763 pcdata->cycle_type = amgparam->cycle_type;
764 pcdata->smoother = amgparam->smoother;
765 pcdata->smooth_order = amgparam->smooth_order;
766 pcdata->presmooth_iter = amgparam->presmooth_iter;
767 pcdata->postsmooth_iter = amgparam->postsmooth_iter;
768 pcdata->coarse_solver = amgparam->coarse_solver;
769 pcdata->coarsening_type = amgparam->coarsening_type;
770 pcdata->relaxation = amgparam->relaxation;
771 pcdata->coarse_scaling = amgparam->coarse_scaling;
772 pcdata->amli_degree = amgparam->amli_degree;
773 pcdata->amli_coef = amgparam->amli_coef;
774 pcdata->nl_amli_krylov_type = amgparam->nl_amli_krylov_type;
775 pcdata->tentative_smooth = amgparam->tentative_smooth;
776}
777
791 const precond_data_bsr *pcdata)
792{
793 amgparam->AMG_type = pcdata->AMG_type;
794 amgparam->print_level = pcdata->print_level;
795 amgparam->cycle_type = pcdata->cycle_type;
796 amgparam->smoother = pcdata->smoother;
797 amgparam->smooth_order = pcdata->smooth_order;
798 amgparam->presmooth_iter = pcdata->presmooth_iter;
799 amgparam->postsmooth_iter = pcdata->postsmooth_iter;
800 amgparam->relaxation = pcdata->relaxation;
801 amgparam->coarse_solver = pcdata->coarse_solver;
802 amgparam->coarse_scaling = pcdata->coarse_scaling;
803 amgparam->amli_degree = pcdata->amli_degree;
804 amgparam->amli_coef = pcdata->amli_coef;
805 amgparam->nl_amli_krylov_type = pcdata->nl_amli_krylov_type;
806 amgparam->tentative_smooth = pcdata->tentative_smooth;
807 amgparam->ILU_levels = pcdata->mgl_data->ILU_levels;
808}
809
821{
822
823 if ( param ) {
824
825 printf("\n Parameters in AMG_param\n");
826 printf("-----------------------------------------------\n");
827
828 printf("AMG print level: %d\n", param->print_level);
829 printf("AMG max num of iter: %d\n", param->maxit);
830 printf("AMG type: %d\n", param->AMG_type);
831 printf("AMG tolerance: %.2e\n", param->tol);
832 printf("AMG max levels: %d\n", param->max_levels);
833 printf("AMG cycle type: %d\n", param->cycle_type);
834 printf("AMG coarse solver type: %d\n", param->coarse_solver);
835 printf("AMG scaling of coarse correction: %d\n", param->coarse_scaling);
836 printf("AMG smoother type: %d\n", param->smoother);
837 printf("AMG smoother order: %d\n", param->smooth_order);
838 printf("AMG num of presmoothing: %d\n", param->presmooth_iter);
839 printf("AMG num of postsmoothing: %d\n", param->postsmooth_iter);
840
841 if ( param->smoother == SMOOTHER_SOR ||
842 param->smoother == SMOOTHER_SSOR ||
843 param->smoother == SMOOTHER_GSOR ||
844 param->smoother == SMOOTHER_SGSOR ) {
845 printf("AMG relax factor: %.4f\n",
846 param->relaxation);
847 }
848
849 if ( param->smoother == SMOOTHER_POLY ) {
850 printf("AMG polynomial smoother degree: %d\n",
851 param->polynomial_degree);
852 }
853
854 if ( param->cycle_type == AMLI_CYCLE ) {
855 printf("AMG AMLI degree of polynomial: %d\n",
856 param->amli_degree);
857 }
858
859 if ( param->cycle_type == NL_AMLI_CYCLE ) {
860 printf("AMG Nonlinear AMLI Krylov type: %d\n",
861 param->nl_amli_krylov_type);
862 }
863
864 switch (param->AMG_type) {
865 case CLASSIC_AMG:
866 printf("AMG coarsening type: %d\n",
867 param->coarsening_type);
868 printf("AMG interpolation type: %d\n",
869 param->interpolation_type);
870 printf("AMG dof on coarsest grid: %d\n",
871 param->coarse_dof);
872 printf("AMG strong threshold: %.4f\n",
873 param->strong_threshold);
874 printf("AMG truncation threshold: %.4f\n",
875 param->truncation_threshold);
876 printf("AMG max row sum: %.4f\n",
877 param->max_row_sum);
878 printf("AMG aggressive levels: %d\n",
879 param->aggressive_level);
880 printf("AMG aggressive path: %d\n",
881 param->aggressive_path);
882 break;
883
884 default: // SA_AMG or UA_AMG
885 printf("Aggregation type: %d\n",
886 param->aggregation_type);
887 if ( param->aggregation_type == PAIRWISE ) {
888 printf("Aggregation number of pairs: %d\n",
889 param->pair_number);
890 printf("Aggregation quality bound: %.2f\n",
891 param->quality_bound);
892 }
893 if ( param->aggregation_type == VMB ) {
894 printf("Aggregation strong coupling: %.4f\n",
895 param->strong_coupled);
896 printf("Aggregation max aggregation: %d\n",
897 param->max_aggregation);
898 printf("Aggregation tentative smooth: %.4f\n",
899 param->tentative_smooth);
900 printf("Aggregation smooth filter: %d\n",
901 param->smooth_filter);
902 printf("Aggregation smooth restriction: %d\n",
903 param->smooth_restriction);
904
905 }
906 break;
907 }
908
909 if (param->ILU_levels>0) {
910 printf("AMG ILU smoother level: %d\n", param->ILU_levels);
911 printf("AMG ILU type: %d\n", param->ILU_type);
912 printf("AMG ILU level of fill-in: %d\n", param->ILU_lfil);
913 printf("AMG ILU drop tol: %e\n", param->ILU_droptol);
914 printf("AMG ILU relaxation: %f\n", param->ILU_relax);
915 }
916
917 if (param->SWZ_levels>0){
918 printf("AMG Schwarz smoother level: %d\n", param->SWZ_levels);
919 printf("AMG Schwarz type: %d\n", param->SWZ_type);
920 printf("AMG Schwarz forming block level: %d\n", param->SWZ_maxlvl);
921 printf("AMG Schwarz maximal block size: %d\n", param->SWZ_mmsize);
922 }
923
924 printf("-----------------------------------------------\n\n");
925
926 }
927 else {
928 printf("### WARNING: AMG_param has not been set!\n");
929 } // end if (param)
930
931}
932
944{
945 if ( param ) {
946
947 printf("\n Parameters in ILU_param\n");
948 printf("-----------------------------------------------\n");
949 printf("ILU print level: %d\n", param->print_level);
950 printf("ILU type: %d\n", param->ILU_type);
951 printf("ILU level of fill-in: %d\n", param->ILU_lfil);
952 printf("ILU relaxation factor: %.4f\n", param->ILU_relax);
953 printf("ILU drop tolerance: %.2e\n", param->ILU_droptol);
954 printf("ILU permutation tolerance: %.2e\n", param->ILU_permtol);
955 printf("-----------------------------------------------\n\n");
956
957 }
958 else {
959 printf("### WARNING: ILU_param has not been set!\n");
960 }
961}
962
974{
975 if ( param ) {
976
977 printf("\n Parameters in SWZ_param\n");
978 printf("-----------------------------------------------\n");
979 printf("Schwarz print level: %d\n", param->print_level);
980 printf("Schwarz type: %d\n", param->SWZ_type);
981 printf("Schwarz forming block level: %d\n", param->SWZ_maxlvl);
982 printf("Schwarz maximal block size: %d\n", param->SWZ_mmsize);
983 printf("Schwarz block solver type: %d\n", param->SWZ_blksolver);
984 printf("-----------------------------------------------\n\n");
985
986 }
987 else {
988 printf("### WARNING: SWZ_param has not been set!\n");
989 }
990}
991
1003{
1004 if ( param ) {
1005
1006 printf("\n Parameters in ITS_param\n");
1007 printf("-----------------------------------------------\n");
1008
1009 printf("Solver print level: %d\n", param->print_level);
1010 printf("Solver type: %d\n", param->itsolver_type);
1011 printf("Solver precond type: %d\n", param->precond_type);
1012 printf("Solver max num of iter: %d\n", param->maxit);
1013 printf("Solver tolerance: %.2e\n", param->tol);
1014 printf("Solver stopping type: %d\n", param->stop_type);
1015
1016 if (param->itsolver_type==SOLVER_GMRES ||
1017 param->itsolver_type==SOLVER_VGMRES) {
1018 printf("Solver restart number: %d\n", param->restart);
1019 }
1020
1021 printf("-----------------------------------------------\n\n");
1022
1023 }
1024 else {
1025 printf("### WARNING: ITS_param has not been set!\n");
1026 }
1027}
1028
1029/*---------------------------------*/
1030/*-- End of File --*/
1031/*---------------------------------*/
SHORT fasp_param_check(input_param *inparam)
Simple check on input parameters.
Definition: AuxInput.c:33
void fasp_param_input(const char *fname, input_param *inparam)
Read input parameters from disk file.
Definition: AuxInput.c:112
void fasp_chkerr(const SHORT status, const char *fctname)
Check error status and print out error messages before quit.
Definition: AuxMessage.c:213
void fasp_param_ilu_init(ILU_param *iluparam)
Initialize ILU parameters.
Definition: AuxParam.c:495
void fasp_param_init(const input_param *iniparam, ITS_param *itsparam, AMG_param *amgparam, ILU_param *iluparam, SWZ_param *swzparam)
Initialize parameters, global variables, etc.
Definition: AuxParam.c:283
void fasp_param_amg_to_prec(precond_data *pcdata, const AMG_param *amgparam)
Set precond_data with AMG_param.
Definition: AuxParam.c:687
void fasp_param_precbsr_to_amg(AMG_param *amgparam, const precond_data_bsr *pcdata)
Set AMG_param with precond_data.
Definition: AuxParam.c:790
void fasp_param_amg_set(AMG_param *param, const input_param *iniparam)
Set AMG_param from INPUT.
Definition: AuxParam.c:537
void fasp_param_amg_to_precbsr(precond_data_bsr *pcdata, const AMG_param *amgparam)
Set precond_data_bsr with AMG_param.
Definition: AuxParam.c:755
void fasp_param_swz_init(SWZ_param *swzparam)
Initialize Schwarz parameters.
Definition: AuxParam.c:517
void fasp_param_solver_print(const ITS_param *param)
Print out itsolver parameters.
Definition: AuxParam.c:1002
void fasp_param_swz_set(SWZ_param *swzparam, const input_param *iniparam)
Set SWZ_param with INPUT.
Definition: AuxParam.c:634
void fasp_param_ilu_set(ILU_param *iluparam, const input_param *iniparam)
Set ILU_param with INPUT.
Definition: AuxParam.c:612
void fasp_param_input_init(input_param *iniparam)
Initialize input parameters.
Definition: AuxParam.c:325
void fasp_param_amg_print(const AMG_param *param)
Print out AMG parameters.
Definition: AuxParam.c:820
void fasp_param_solver_init(ITS_param *itsparam)
Initialize ITS_param.
Definition: AuxParam.c:473
void fasp_param_amg_init(AMG_param *amgparam)
Initialize AMG parameters.
Definition: AuxParam.c:407
void fasp_param_ilu_print(const ILU_param *param)
Print out ILU parameters.
Definition: AuxParam.c:943
void fasp_param_prec_to_amg(AMG_param *amgparam, const precond_data *pcdata)
Set AMG_param with precond_data.
Definition: AuxParam.c:722
void fasp_param_swz_print(const SWZ_param *param)
Print out Schwarz parameters.
Definition: AuxParam.c:973
void fasp_param_set(const int argc, const char *argv[], input_param *iniparam)
Read input from command-line arguments.
Definition: AuxParam.c:41
void fasp_param_solver_set(ITS_param *itsparam, const input_param *iniparam)
Set ITS_param with INPUT.
Definition: AuxParam.c:656
unsigned long total_alloc_mem
unsigned long total_alloc_count
Main header file for the FASP project.
#define SHORT
FASP integer and floating point numbers.
Definition: fasp.h:63
#define MAX(a, b)
Definition of max, min, abs.
Definition: fasp.h:74
#define AMLI_CYCLE
Definition: fasp_const.h:179
#define SMOOTHER_SOR
Definition: fasp_const.h:191
#define COARSE_RS
Definition of coarsening types.
Definition: fasp_const.h:207
#define SOLVER_FMG
Definition: fasp_const.h:121
#define NL_AMLI_CYCLE
Definition: fasp_const.h:180
#define SOLVER_GMRES
Definition: fasp_const.h:106
#define OFF
Definition: fasp_const.h:68
#define SMOOTHER_GSOR
Definition: fasp_const.h:193
#define FASP_SUCCESS
Definition of return status and error messages.
Definition: fasp_const.h:19
#define STOP_REL_RES
Definition of iterative solver stopping criteria types.
Definition: fasp_const.h:131
#define PAIRWISE
Definition of aggregation types.
Definition: fasp_const.h:169
#define SOLVER_VGMRES
Definition: fasp_const.h:107
#define V_CYCLE
Definition of cycle types.
Definition: fasp_const.h:177
#define SMOOTHER_SGSOR
Definition: fasp_const.h:194
#define PREC_AMG
Definition: fasp_const.h:140
#define SMOOTHER_GS
Definition: fasp_const.h:188
#define INTERP_DIR
Definition of interpolation types.
Definition: fasp_const.h:216
#define SOLVER_DEFAULT
Definition of solver types for iterative methods.
Definition: fasp_const.h:101
#define PRINT_SOME
Definition: fasp_const.h:75
#define VMB
Definition: fasp_const.h:170
#define CF_ORDER
Definition: fasp_const.h:234
#define TRUE
Definition of logic type.
Definition: fasp_const.h:61
#define FALSE
Definition: fasp_const.h:62
#define ERROR_INPUT_PAR
Definition: fasp_const.h:24
#define SOLVER_CG
Definition: fasp_const.h:103
#define SMOOTHER_POLY
Definition: fasp_const.h:195
#define CLASSIC_AMG
Definition of AMG types.
Definition: fasp_const.h:162
#define ON
Definition of switch.
Definition: fasp_const.h:67
#define ILUk
Type of ILU methods.
Definition: fasp_const.h:148
#define PRINT_NONE
Print level for all subroutines – not including DEBUG output.
Definition: fasp_const.h:73
#define SMOOTHER_SSOR
Definition: fasp_const.h:192
#define SOLVER_AMG
Definition: fasp_const.h:120
#define SOLVER_GCG
Definition: fasp_const.h:109
INT ILU_levels
number of levels use ILU smoother
Definition: fasp_block.h:203
INT ILU_levels
number of levels use ILU smoother
Definition: fasp.h:829
Parameters for AMG methods.
Definition: fasp.h:447
INT ILU_lfil
level of fill-in for ILUs and ILUk
Definition: fasp.h:555
INT aggressive_level
number of levels use aggressive coarsening
Definition: fasp.h:525
REAL ILU_relax
relaxation for ILUs
Definition: fasp.h:561
REAL strong_threshold
strong connection threshold for coarsening
Definition: fasp.h:516
INT SWZ_mmsize
maximal block size
Definition: fasp.h:570
INT aggressive_path
number of paths use to determine strongly coupled C points
Definition: fasp.h:528
SHORT interpolation_type
interpolation type
Definition: fasp.h:513
SHORT print_level
print level for AMG
Definition: fasp.h:453
SHORT polynomial_degree
degree of the polynomial smoother
Definition: fasp.h:489
INT SWZ_maxlvl
maximal levels
Definition: fasp.h:573
SHORT aggregation_type
aggregation type
Definition: fasp.h:510
SHORT coarsening_type
coarsening type
Definition: fasp.h:507
SHORT nl_amli_krylov_type
type of Krylov method used by Nonlinear AMLI cycle
Definition: fasp.h:504
SHORT coarse_scaling
switch of scaling of the coarse grid correction
Definition: fasp.h:495
SHORT smooth_filter
switch for filtered matrix used for smoothing the tentative prolongation
Definition: fasp.h:543
REAL * amli_coef
coefficients of the polynomial used by AMLI cycle
Definition: fasp.h:501
SHORT ILU_levels
number of levels use ILU smoother
Definition: fasp.h:549
SHORT AMG_type
type of AMG method
Definition: fasp.h:450
REAL tol
stopping tolerance for AMG solver
Definition: fasp.h:459
SHORT coarse_solver
coarse solver type
Definition: fasp.h:492
REAL strong_coupled
strong coupled threshold for aggregate
Definition: fasp.h:534
REAL relaxation
relaxation parameter for Jacobi and SOR smoother
Definition: fasp.h:486
SHORT smoother
smoother type
Definition: fasp.h:474
SHORT cycle_type
type of AMG cycle
Definition: fasp.h:468
SHORT amli_degree
degree of the polynomial used by AMLI cycle
Definition: fasp.h:498
SHORT ILU_type
ILU type for smoothing.
Definition: fasp.h:552
INT SWZ_blksolver
type of Schwarz block solver
Definition: fasp.h:579
INT SWZ_type
type of Schwarz method
Definition: fasp.h:576
REAL quality_bound
quality threshold for pairwise aggregation
Definition: fasp.h:471
INT coarse_dof
max number of coarsest level DOF
Definition: fasp.h:465
REAL ILU_droptol
drop tolerance for ILUt
Definition: fasp.h:558
REAL tentative_smooth
relaxation parameter for smoothing the tentative prolongation
Definition: fasp.h:540
SHORT postsmooth_iter
number of postsmoothers
Definition: fasp.h:483
INT SWZ_levels
number of levels use Schwarz smoother
Definition: fasp.h:567
INT pair_number
number of pairwise matchings
Definition: fasp.h:531
SHORT max_levels
max number of levels of AMG
Definition: fasp.h:462
SHORT presmooth_iter
number of presmoothers
Definition: fasp.h:480
REAL truncation_threshold
truncation threshold
Definition: fasp.h:522
INT max_aggregation
max size of each aggregate
Definition: fasp.h:537
REAL ILU_permtol
permuted if permtol*|a(i,j)| > |a(i,i)|
Definition: fasp.h:564
REAL max_row_sum
maximal row sum parameter
Definition: fasp.h:519
INT maxit
max number of iterations of AMG
Definition: fasp.h:456
SHORT smooth_restriction
smooth the restriction for SA methods or not
Definition: fasp.h:546
SHORT smooth_order
smoother order
Definition: fasp.h:477
Parameters for ILU.
Definition: fasp.h:396
INT ILU_lfil
level of fill-in for ILUk
Definition: fasp.h:405
REAL ILU_relax
add the sum of dropped elements to diagonal element in proportion relax
Definition: fasp.h:411
SHORT print_level
print level
Definition: fasp.h:399
SHORT ILU_type
ILU type for decomposition.
Definition: fasp.h:402
REAL ILU_droptol
drop tolerance for ILUt
Definition: fasp.h:408
REAL ILU_permtol
permuted if permtol*|a(i,j)| > |a(i,i)|
Definition: fasp.h:414
Parameters for iterative solvers.
Definition: fasp.h:379
SHORT itsolver_type
Definition: fasp.h:382
SHORT print_level
Definition: fasp.h:381
SHORT precond_type
Definition: fasp.h:384
REAL tol
Definition: fasp.h:388
SHORT decoup_type
Definition: fasp.h:383
INT restart
Definition: fasp.h:386
SHORT stop_type
Definition: fasp.h:385
INT maxit
Definition: fasp.h:387
Parameters for Schwarz method.
Definition: fasp.h:422
INT SWZ_mmsize
maximal size of blocks
Definition: fasp.h:434
SHORT print_level
print leve
Definition: fasp.h:425
INT SWZ_maxlvl
maximal level for constructing the blocks
Definition: fasp.h:431
INT SWZ_blksolver
type of Schwarz block solver
Definition: fasp.h:437
SHORT SWZ_type
type for Schwarz method
Definition: fasp.h:428
Input parameters.
Definition: fasp.h:1111
INT AMG_coarse_dof
Definition: fasp.h:1155
INT ILU_lfil
Definition: fasp.h:1133
REAL ILU_relax
Definition: fasp.h:1135
INT SWZ_mmsize
Definition: fasp.h:1139
SHORT AMG_smooth_order
Definition: fasp.h:1149
SHORT print_level
Definition: fasp.h:1114
REAL AMG_quality_bound
Definition: fasp.h:1174
INT SWZ_maxlvl
Definition: fasp.h:1140
INT AMG_SWZ_levels
Definition: fasp.h:1162
SHORT AMG_levels
Definition: fasp.h:1146
SHORT AMG_coarsening_type
Definition: fasp.h:1165
SHORT AMG_cycle_type
Definition: fasp.h:1147
INT AMG_pair_number
Definition: fasp.h:1173
REAL AMG_strong_threshold
Definition: fasp.h:1168
char inifile[STRLEN]
Definition: fasp.h:1118
REAL AMG_truncation_threshold
Definition: fasp.h:1169
SHORT AMG_polynomial_degree
Definition: fasp.h:1151
SHORT AMG_coarse_solver
Definition: fasp.h:1158
SHORT precond_type
Definition: fasp.h:1125
SHORT AMG_type
Definition: fasp.h:1145
SHORT AMG_smooth_filter
Definition: fasp.h:1180
char workdir[STRLEN]
Definition: fasp.h:1119
SHORT output_type
Definition: fasp.h:1115
REAL AMG_tentative_smooth
Definition: fasp.h:1179
SHORT AMG_smoother
Definition: fasp.h:1148
REAL AMG_strong_coupled
Definition: fasp.h:1177
INT AMG_max_aggregation
Definition: fasp.h:1178
SHORT decoup_type
Definition: fasp.h:1124
SHORT ILU_type
Definition: fasp.h:1132
SHORT AMG_amli_degree
Definition: fasp.h:1160
INT restart
Definition: fasp.h:1129
SHORT AMG_smooth_restriction
Definition: fasp.h:1181
INT SWZ_blksolver
Definition: fasp.h:1142
INT SWZ_type
Definition: fasp.h:1141
REAL ILU_droptol
Definition: fasp.h:1134
INT AMG_aggressive_path
Definition: fasp.h:1172
SHORT AMG_nl_amli_krylov_type
Definition: fasp.h:1161
SHORT AMG_postsmooth_iter
Definition: fasp.h:1153
INT AMG_aggressive_level
Definition: fasp.h:1171
REAL AMG_max_row_sum
Definition: fasp.h:1170
SHORT AMG_presmooth_iter
Definition: fasp.h:1152
INT itsolver_maxit
Definition: fasp.h:1128
REAL AMG_tol
Definition: fasp.h:1154
SHORT stop_type
Definition: fasp.h:1126
INT problem_num
Definition: fasp.h:1120
SHORT AMG_interpolation_type
Definition: fasp.h:1167
SHORT AMG_ILU_levels
Definition: fasp.h:1157
REAL ILU_permtol
Definition: fasp.h:1136
REAL itsolver_tol
Definition: fasp.h:1127
INT AMG_maxit
Definition: fasp.h:1156
SHORT AMG_coarse_scaling
Definition: fasp.h:1159
REAL AMG_relaxation
Definition: fasp.h:1150
SHORT solver_type
Definition: fasp.h:1123
SHORT AMG_aggregation_type
Definition: fasp.h:1166
Data for preconditioners in dBSRmat format.
Definition: fasp_block.h:257
SHORT print_level
print level in AMG preconditioner
Definition: fasp_block.h:263
SHORT coarsening_type
coarsening type
Definition: fasp_block.h:290
SHORT nl_amli_krylov_type
type of krylov method used by Nonlinear AMLI cycle
Definition: fasp_block.h:311
SHORT coarse_scaling
switch of scaling of the coarse grid correction
Definition: fasp_block.h:299
REAL * amli_coef
coefficients of the polynomial used by AMLI cycle
Definition: fasp_block.h:305
SHORT AMG_type
type of AMG method
Definition: fasp_block.h:260
REAL tol
tolerance for AMG preconditioner
Definition: fasp_block.h:272
SHORT coarse_solver
coarse solver type for AMG
Definition: fasp_block.h:296
REAL relaxation
relaxation parameter for SOR smoother
Definition: fasp_block.h:293
SHORT smoother
AMG smoother type.
Definition: fasp_block.h:278
SHORT cycle_type
AMG cycle type.
Definition: fasp_block.h:275
SHORT amli_degree
degree of the polynomial used by AMLI cycle
Definition: fasp_block.h:302
REAL tentative_smooth
smooth factor for smoothing the tentative prolongation
Definition: fasp_block.h:308
SHORT postsmooth_iter
number of postsmoothing
Definition: fasp_block.h:287
AMG_data_bsr * mgl_data
AMG preconditioner data.
Definition: fasp_block.h:314
INT max_levels
max number of AMG levels
Definition: fasp_block.h:269
SHORT presmooth_iter
number of presmoothing
Definition: fasp_block.h:284
INT maxit
max number of iterations of AMG preconditioner
Definition: fasp_block.h:266
SHORT smooth_order
AMG smoother ordering.
Definition: fasp_block.h:281
Data for preconditioners.
Definition: fasp.h:880
SHORT print_level
print level in AMG preconditioner
Definition: fasp.h:886
SHORT polynomial_degree
degree of the polynomial smoother
Definition: fasp.h:916
SHORT coarsening_type
switch of scaling of the coarse grid correction
Definition: fasp.h:919
SHORT nl_amli_krylov_type
type of Krylov method used by Nonlinear AMLI cycle
Definition: fasp.h:931
SHORT coarse_scaling
switch of scaling of the coarse grid correction
Definition: fasp.h:925
AMG_data * mgl_data
AMG preconditioner data.
Definition: fasp.h:940
REAL * amli_coef
coefficients of the polynomial used by AMLI cycle
Definition: fasp.h:937
SHORT AMG_type
type of AMG method
Definition: fasp.h:883
REAL tol
tolerance for AMG preconditioner
Definition: fasp.h:895
SHORT coarse_solver
coarse solver type for AMG
Definition: fasp.h:922
REAL relaxation
relaxation parameter for SOR smoother
Definition: fasp.h:913
SHORT smoother
AMG smoother type.
Definition: fasp.h:901
SHORT cycle_type
AMG cycle type.
Definition: fasp.h:898
SHORT amli_degree
degree of the polynomial used by AMLI cycle
Definition: fasp.h:928
REAL tentative_smooth
smooth factor for smoothing the tentative prolongation
Definition: fasp.h:934
SHORT postsmooth_iter
number of postsmoothing
Definition: fasp.h:910
SHORT max_levels
max number of AMG levels
Definition: fasp.h:892
SHORT presmooth_iter
number of presmoothing
Definition: fasp.h:907
INT maxit
max number of iterations of AMG preconditioner
Definition: fasp.h:889
SHORT smooth_order
AMG smoother ordering.
Definition: fasp.h:904