CFD/hypre
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

added some changes, fixed some bugs regarding using Euclid as a smoother in AMG

Browse Source
This commit is contained in:
ulrikey 2007-11-30 21:35:35 +00:00
parent 0d018249e8
commit 2c206fd354
7 changed files with 162 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
parcsr_ls/HYPRE_parcsr_Euclid.c
View File

@ -358,7 +358,7 @@ int
HYPRE_EuclidSetLevel(HYPRE_Solver solver,
int level)
{
char *str_level;
char str_level[8];
START_FUNC_DH
sprintf(str_level,"%d",level);
Parser_dhInsert(parser_dh, "-level", str_level); HYPRE_EUCLID_ERRCHKA;
@ -369,7 +369,7 @@ int
HYPRE_EuclidSetBJ(HYPRE_Solver solver,
int bj)
{
char *str_bj;
char str_bj[8];
START_FUNC_DH
sprintf(str_bj,"%d",bj);
Parser_dhInsert(parser_dh, "-bj", str_bj); HYPRE_EUCLID_ERRCHKA;
@ -380,7 +380,7 @@ int
HYPRE_EuclidSetStats(HYPRE_Solver solver,
int eu_stats)
{
char *str_eu_stats;
char str_eu_stats[8];
START_FUNC_DH
sprintf(str_eu_stats,"%d",eu_stats);
Parser_dhInsert(parser_dh, "-eu_stats", str_eu_stats); HYPRE_EUCLID_ERRCHKA;
@ -391,7 +391,7 @@ int
HYPRE_EuclidSetMem(HYPRE_Solver solver,
int eu_mem)
{
char *str_eu_mem;
char str_eu_mem[8];
START_FUNC_DH
sprintf(str_eu_mem,"%d",eu_mem);
Parser_dhInsert(parser_dh, "-eu_mem", str_eu_mem); HYPRE_EUCLID_ERRCHKA;
@ -402,30 +402,18 @@ int
HYPRE_EuclidSetILUT(HYPRE_Solver solver,
double ilut)
{
char *str_ilut;
char str_ilut[256];
START_FUNC_DH
sprintf(str_ilut,"%f",ilut);
Parser_dhInsert(parser_dh, "-ilut", str_ilut); HYPRE_EUCLID_ERRCHKA;
END_FUNC_VAL(0)
}
int
HYPRE_EuclidSetMaxNzPerRow(HYPRE_Solver solver,
int max_nz_per_row)
{
char *str_max_nz_per_row;
START_FUNC_DH
sprintf(str_max_nz_per_row,"%d",max_nz_per_row);
Parser_dhInsert(parser_dh, "-maxNzPerRow", str_max_nz_per_row);
HYPRE_EUCLID_ERRCHKA;
END_FUNC_VAL(0)
}
int
HYPRE_EuclidSetSparseA(HYPRE_Solver solver,
double sparse_A)
{
char *str_sparse_A;
char str_sparse_A[256];
START_FUNC_DH
sprintf(str_sparse_A,"%f",sparse_A);
Parser_dhInsert(parser_dh, "-sparseA", str_sparse_A);
@ -437,7 +425,7 @@ int
HYPRE_EuclidSetRowScale(HYPRE_Solver solver,
int row_scale)
{
char *str_row_scale;
char str_row_scale[8];
START_FUNC_DH
sprintf(str_row_scale,"%d",row_scale);
Parser_dhInsert(parser_dh, "-rowScale", str_row_scale);

33
parcsr_ls/HYPRE_parcsr_amg.c
View File

@ -992,6 +992,39 @@ HYPRE_BoomerAMGSetEuclidFile( HYPRE_Solver solver,
return( hypre_BoomerAMGSetEuclidFile( (void *) solver, euclidfile ) );
}
/*--------------------------------------------------------------------------
* HYPRE_BoomerAMGSetEuLevel
*--------------------------------------------------------------------------*/
int
HYPRE_BoomerAMGSetEuLevel( HYPRE_Solver solver,
int eu_level)
{
return( hypre_BoomerAMGSetEuLevel( (void *) solver, eu_level ) );
}
/*--------------------------------------------------------------------------
* HYPRE_BoomerAMGSetEuSparseA
*--------------------------------------------------------------------------*/
int
HYPRE_BoomerAMGSetEuSparseA( HYPRE_Solver solver,
double eu_sparse_A )
{
return( hypre_BoomerAMGSetEuSparseA( (void *) solver, eu_sparse_A ) );
}
/*--------------------------------------------------------------------------
* HYPRE_BoomerAMGSetEuBJ
*--------------------------------------------------------------------------*/
int
HYPRE_BoomerAMGSetEuBJ( HYPRE_Solver solver,
int eu_bj)
{
return( hypre_BoomerAMGSetEuBJ( (void *) solver, eu_bj ) );
}
/*--------------------------------------------------------------------------
* HYPRE_BoomerAMGSetNumFunctions, HYPRE_BoomerAMGGetNumFunctions
*--------------------------------------------------------------------------*/

29
parcsr_ls/HYPRE_parcsr_ls.h
View File

@ -739,6 +739,27 @@ int HYPRE_BoomerAMGSetMaxNzPerRow(HYPRE_Solver solver,
int HYPRE_BoomerAMGSetEuclidFile(HYPRE_Solver solver,
char *euclidfile);
/**
* (Optional) Defines number of levels for ILU(k) in Euclid.
* For further explanation see description of Euclid.
**/
int HYPRE_BoomerAMGSetEuLevel(HYPRE_Solver solver,
int eu_level);
/**
* (Optional) Defines filter for ILU(k) for Euclid.
* For further explanation see description of Euclid.
**/
int HYPRE_BoomerAMGSetEuSparseA(HYPRE_Solver solver,
double eu_sparse_A);
/**
* (Optional) Defines use of block jacobi ILUT for Euclid.
* For further explanation see description of Euclid.
**/
int HYPRE_BoomerAMGSetEuBJ(HYPRE_Solver solver,
int eu_bj);
/**
* (Optional) Specifies the use of GSMG - geometrically smooth
* coarsening and interpolation. Currently any nonzero value for
@ -1087,14 +1108,6 @@ int HYPRE_EuclidSetRowScale(HYPRE_Solver solver, int row_scale);
**/
int HYPRE_EuclidSetILUT(HYPRE_Solver solver, double drop_tol);
/**
* Sets the maximum number of nonzeros that is permitted in any
* row of L+U-I in addition to the number that would result from
* an ILU(0) factorziation. A negative value indicates no limit.
* Default: no limit for ILU(k), 5 for ILUT.
**/
int HYPRE_EuclidSetMaxNzPerRow(HYPRE_Solver solver, int max_nz_per_row);
/*@}*/
/*--------------------------------------------------------------------------
*--------------------------------------------------------------------------*/

7
parcsr_ls/_hypre_parcsr_ls.h
View File

@ -306,6 +306,9 @@ int HYPRE_BoomerAMGSetFilter ( HYPRE_Solver solver , double filter );
int HYPRE_BoomerAMGSetDropTol ( HYPRE_Solver solver , double drop_tol );
int HYPRE_BoomerAMGSetMaxNzPerRow ( HYPRE_Solver solver , int max_nz_per_row );
int HYPRE_BoomerAMGSetEuclidFile ( HYPRE_Solver solver , char *euclidfile );
int HYPRE_BoomerAMGSetEuLevel ( HYPRE_Solver solver , int eu_level );
int HYPRE_BoomerAMGSetEuSparseA ( HYPRE_Solver solver , double eu_sparse_A );
int HYPRE_BoomerAMGSetEuBJ ( HYPRE_Solver solver , int eu_bj );
int HYPRE_BoomerAMGSetNumFunctions ( HYPRE_Solver solver , int num_functions );
int HYPRE_BoomerAMGGetNumFunctions ( HYPRE_Solver solver , int *num_functions );
int HYPRE_BoomerAMGSetNodal ( HYPRE_Solver solver , int nodal );
@ -382,7 +385,6 @@ int HYPRE_EuclidSetMem ( HYPRE_Solver solver , int eu_mem );
int HYPRE_EuclidSetSparseA ( HYPRE_Solver solver , double sparse_A );
int HYPRE_EuclidSetRowScale ( HYPRE_Solver solver , int row_scale );
int HYPRE_EuclidSetILUT ( HYPRE_Solver solver , double ilut );
int HYPRE_EuclidSetMaxNzPerRow ( HYPRE_Solver solver , int max_nz_per_row );
/* HYPRE_parcsr_gmres.c */
int HYPRE_ParCSRGMRESCreate ( MPI_Comm comm , HYPRE_Solver *solver );
@ -656,6 +658,9 @@ int hypre_BoomerAMGSetFilter ( void *data , double filter );
int hypre_BoomerAMGSetDropTol ( void *data , double drop_tol );
int hypre_BoomerAMGSetMaxNzPerRow ( void *data , int max_nz_per_row );
int hypre_BoomerAMGSetEuclidFile ( void *data , char *euclidfile );
int hypre_BoomerAMGSetEuLevel ( void *data , int eu_level );
int hypre_BoomerAMGSetEuSparseA ( void *data , double eu_sparse_A );
int hypre_BoomerAMGSetEuBJ ( void *data , int eu_bj );
/* par_amg_setup.c */
int hypre_BoomerAMGSetup ( void *amg_vdata , hypre_ParCSRMatrix *A , hypre_ParVector *f , hypre_ParVector *u );

61
parcsr_ls/par_amg.c
View File

@ -90,9 +90,11 @@ hypre_BoomerAMGCreate()
int variant, overlap, domain_type;
double schwarz_rlx_weight;
int level, sym;
int eu_level, eu_bj;
int max_nz_per_row;
double thresh, filter;
double drop_tol;
int max_nz_per_row;
double eu_sparse_A;
char *euclidfile;
int block_mode;
@ -155,6 +157,9 @@ hypre_BoomerAMGCreate()
drop_tol = 0.0001;
max_nz_per_row = 20;
euclidfile = NULL;
eu_level = 0;
eu_sparse_A = 0.0;
eu_bj = 0;
/* solve params */
min_iter = 0;
@ -222,6 +227,9 @@ hypre_BoomerAMGCreate()
hypre_BoomerAMGSetDropTol(amg_data, drop_tol);
hypre_BoomerAMGSetMaxNzPerRow(amg_data, max_nz_per_row);
hypre_BoomerAMGSetEuclidFile(amg_data, euclidfile);
hypre_BoomerAMGSetEuLevel(amg_data, eu_level);
hypre_BoomerAMGSetEuSparseA(amg_data, eu_sparse_A);
hypre_BoomerAMGSetEuBJ(amg_data, eu_bj);
hypre_BoomerAMGSetMinIter(amg_data, min_iter);
hypre_BoomerAMGSetMaxIter(amg_data, max_iter);
@ -2821,3 +2829,54 @@ hypre_BoomerAMGSetEuclidFile( void *data,
return hypre_error_flag;
}
int
hypre_BoomerAMGSetEuLevel( void *data,
int eu_level)
{
hypre_ParAMGData *amg_data = data;
if (!amg_data)
{
printf("Warning! BoomerAMG object empty!\n");
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataEuLevel(amg_data) = eu_level;
return hypre_error_flag;
}
int
hypre_BoomerAMGSetEuSparseA( void *data,
double eu_sparse_A)
{
hypre_ParAMGData *amg_data = data;
if (!amg_data)
{
printf("Warning! BoomerAMG object empty!\n");
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataEuSparseA(amg_data) = eu_sparse_A;
return hypre_error_flag;
}
int
hypre_BoomerAMGSetEuBJ( void *data,
int eu_bj)
{
hypre_ParAMGData *amg_data = data;
if (!amg_data)
{
printf("Warning! BoomerAMG object empty!\n");
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataEuBJ(amg_data) = eu_bj;
return hypre_error_flag;
}

42
parcsr_ls/par_amg.h
View File

@ -116,16 +116,19 @@ typedef struct
int smooth_type;
HYPRE_Solver *smoother;
int smooth_num_sweeps;
int variant;
int overlap;
int domain_type;
int schw_variant;
int schw_overlap;
int schw_domain_type;
double schwarz_rlx_weight;
int sym;
int level;
int max_nz_per_row;
double threshold;
double filter;
double drop_tol;
int ps_sym;
int ps_level;
int pi_max_nz_per_row;
int eu_level;
int eu_bj;
double ps_threshold;
double ps_filter;
double pi_drop_tol;
double eu_sparse_A;
char *euclidfile;
/* data generated in the solve phase */
@ -238,18 +241,21 @@ typedef struct
#define hypre_ParAMGDataSmoothNumSweeps(amg_data) \
((amg_data)->smooth_num_sweeps)
#define hypre_ParAMGDataSmoother(amg_data) ((amg_data)->smoother)
#define hypre_ParAMGDataVariant(amg_data) ((amg_data)->variant)
#define hypre_ParAMGDataOverlap(amg_data) ((amg_data)->overlap)
#define hypre_ParAMGDataDomainType(amg_data) ((amg_data)->domain_type)
#define hypre_ParAMGDataVariant(amg_data) ((amg_data)->schw_variant)
#define hypre_ParAMGDataOverlap(amg_data) ((amg_data)->schw_overlap)
#define hypre_ParAMGDataDomainType(amg_data) ((amg_data)->schw_domain_type)
#define hypre_ParAMGDataSchwarzRlxWeight(amg_data) \
((amg_data)->schwarz_rlx_weight)
#define hypre_ParAMGDataSym(amg_data) ((amg_data)->sym)
#define hypre_ParAMGDataLevel(amg_data) ((amg_data)->level)
#define hypre_ParAMGDataMaxNzPerRow(amg_data) ((amg_data)->max_nz_per_row)
#define hypre_ParAMGDataThreshold(amg_data) ((amg_data)->threshold)
#define hypre_ParAMGDataFilter(amg_data) ((amg_data)->filter)
#define hypre_ParAMGDataDropTol(amg_data) ((amg_data)->drop_tol)
#define hypre_ParAMGDataSym(amg_data) ((amg_data)->ps_sym)
#define hypre_ParAMGDataLevel(amg_data) ((amg_data)->ps_level)
#define hypre_ParAMGDataMaxNzPerRow(amg_data) ((amg_data)->pi_max_nz_per_row)
#define hypre_ParAMGDataThreshold(amg_data) ((amg_data)->ps_threshold)
#define hypre_ParAMGDataFilter(amg_data) ((amg_data)->ps_filter)
#define hypre_ParAMGDataDropTol(amg_data) ((amg_data)->pi_drop_tol)
#define hypre_ParAMGDataEuclidFile(amg_data) ((amg_data)->euclidfile)
#define hypre_ParAMGDataEuLevel(amg_data) ((amg_data)->eu_level)
#define hypre_ParAMGDataEuSparseA(amg_data) ((amg_data)->eu_sparse_A)
#define hypre_ParAMGDataEuBJ(amg_data) ((amg_data)->eu_bj)
/* block */
#define hypre_ParAMGDataABlockArray(amg_data) ((amg_data)->A_block_array)

19
parcsr_ls/par_amg_setup.c
View File

@ -147,6 +147,9 @@ hypre_BoomerAMGSetup( void *amg_vdata,
double drop_tol;
int max_nz_per_row;
char *euclidfile;
int eu_level;
int eu_bj;
double eu_sparse_A;
int interp_type;
int post_interp_type; /* what to do after computing the interpolation matrix
@ -180,6 +183,9 @@ hypre_BoomerAMGSetup( void *amg_vdata,
drop_tol = hypre_ParAMGDataDropTol(amg_data);
max_nz_per_row = hypre_ParAMGDataMaxNzPerRow(amg_data);
euclidfile = hypre_ParAMGDataEuclidFile(amg_data);
eu_level = hypre_ParAMGDataEuLevel(amg_data);
eu_sparse_A = hypre_ParAMGDataEuSparseA(amg_data);
eu_bj = hypre_ParAMGDataEuBJ(amg_data);
interp_type = hypre_ParAMGDataInterpType(amg_data);
post_interp_type = hypre_ParAMGDataPostInterpType(amg_data);
IS_type = hypre_ParAMGDataISType(amg_data);
@ -1986,14 +1992,11 @@ hypre_BoomerAMGSetup( void *amg_vdata,
HYPRE_EuclidCreate(comm, &smoother[j]);
if (euclidfile)
HYPRE_EuclidSetParamsFromFile(smoother[j],euclidfile);
if (nlevel)
HYPRE_EuclidSetLevel(smoother[j],nlevel);
else
HYPRE_EuclidSetLevel(smoother[j],0);
if (drop_tol)
HYPRE_EuclidSetILUT(smoother[j],drop_tol);
if (max_nz_per_row)
HYPRE_EuclidSetMaxNzPerRow(smoother[j],max_nz_per_row);
HYPRE_EuclidSetLevel(smoother[j],eu_level);
if (eu_bj)
HYPRE_EuclidSetBJ(smoother[j],eu_bj);
if (eu_sparse_A)
HYPRE_EuclidSetSparseA(smoother[j],eu_sparse_A);
HYPRE_EuclidSetup(smoother[j],
(HYPRE_ParCSRMatrix) A_array[j],
(HYPRE_ParVector) F_array[j],