fasp.h

Go to the documentation of this file.

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "fasp_const.h"
 
#if WITH_MUMPS
#include "dmumps_c.h"
#endif
 
#if WITH_PARDISO
#include "mkl_pardiso.h"
#include "mkl_types.h"
#endif
 
#ifndef __FASP_HEADER__ /*-- allow multiple inclusions --*/
#define __FASP_HEADER__ 
/*---------------------------*/
/*---  Macros definition  ---*/
/*---------------------------*/
 
#define FASP_VERSION 2.0 
#ifdef _OPENMP
#define MULTI_COLOR_ORDER                                                              \
    ON 
#else
#define MULTI_COLOR_ORDER                                                              \
    OFF 
#endif
 
#define DLMALLOC  OFF 
#define NEDMALLOC OFF 
// When this flag is OFF, do not force C1 criterion for the classical AMG method
#define RS_C1 ON 
// When this flag is ON, the matrix rows will be reordered as diagonal entries first
#define DIAGONAL_PREF OFF 
#define SHORT    short       
#define INT      int         
#define LONG     long        
#define LONGLONG long long   
#define REAL     double      
#define LONGREAL long double 
#define STRLEN   256         
#define MAX(a, b) (((a) > (b)) ? (a) : (b))   
#define MIN(a, b) (((a) < (b)) ? (a) : (b))   
#define ABS(a)    (((a) >= 0.0) ? (a) : -(a)) 
#define GT(a, b) (((a) > (b)) ? (TRUE) : (FALSE))  
#define GE(a, b) (((a) >= (b)) ? (TRUE) : (FALSE)) 
#define LS(a, b) (((a) < (b)) ? (TRUE) : (FALSE))  
#define LE(a, b) (((a) <= (b)) ? (TRUE) : (FALSE)) 
#define ISNAN(a) (((a) != (a)) ? (TRUE) : (FALSE)) 
#define PUT_INT(A)  printf("### DEBUG: %s = %d\n", #A, (A)) 
#define PUT_REAL(A) printf("### DEBUG: %s = %e\n", #A, (A)) 
/*---------------------------*/
/*---  Matrix and vector  ---*/
/*---------------------------*/
 
typedef struct ddenmat {
 
    INT row;
 
    INT col;
 
    REAL** val;
 
} ddenmat; 
typedef struct idenmat {
 
    INT row;
 
    INT col;
 
    INT** val;
 
} idenmat; 
typedef struct dCSRmat {
 
    INT row;
 
    INT col;
 
    INT nnz;
 
    INT* IA;
 
    INT* JA;
 
    REAL* val;
 
#if MULTI_COLOR_ORDER
    INT color;
    INT* IC;
    INT* ICMAP;
#endif
 
} dCSRmat; 
typedef struct iCSRmat {
 
    INT row;
 
    INT col;
 
    INT nnz;
 
    INT* IA;
 
    INT* JA;
 
    INT* val;
 
} iCSRmat; 
typedef struct dCOOmat {
 
    INT row;
 
    INT col;
 
    INT nnz;
 
    INT* rowind;
 
    INT* colind;
 
    REAL* val;
 
} dCOOmat; 
typedef struct iCOOmat {
 
    INT row;
 
    INT col;
 
    INT nnz;
 
    INT* I;
 
    INT* J;
 
    INT* val;
 
} iCOOmat; 
typedef struct dCSRLmat {
 
    INT row;
 
    INT col;
 
    INT nnz;
 
    INT dif;
 
    INT* nz_diff;
 
    INT* index;
 
    INT* start;
 
    INT* ja;
 
    REAL* val;
 
} dCSRLmat; 
typedef struct dSTRmat {
 
    INT nx;
 
    INT ny;
 
    INT nz;
 
    INT nxy;
 
    INT nc;
 
    INT ngrid;
 
    REAL* diag;
 
    INT nband;
 
    INT* offsets;
 
    REAL** offdiag;
 
} dSTRmat; 
typedef struct dvector {
 
    INT row;
 
    REAL* val;
 
} dvector; 
typedef struct ivector {
 
    INT row;
 
    INT* val;
 
} ivector; 
/*---------------------------*/
/*--- Parameter structures --*/
/*---------------------------*/
 
typedef struct {
 
    SHORT print_level;   
    SHORT itsolver_type; 
    SHORT decoup_type;   
    SHORT precond_type;  
    SHORT stop_type;     
    INT   restart;       
    INT   maxit;         
    REAL  tol;           
    REAL  abstol;        
} ITS_param;             
typedef struct {
 
    SHORT print_level;
 
    SHORT ILU_type;
 
    INT ILU_lfil;
 
    REAL ILU_droptol;
 
    REAL ILU_relax;
 
    REAL ILU_permtol;
 
} ILU_param; 
typedef struct {
 
    SHORT print_level;
 
    SHORT SWZ_type;
 
    INT SWZ_maxlvl;
 
    INT SWZ_mmsize;
 
    INT SWZ_blksolver;
 
} SWZ_param; 
typedef struct {
 
    SHORT AMG_type;
 
    SHORT print_level;
 
    INT maxit;
 
    REAL tol;
 
    SHORT max_levels;
 
    INT coarse_dof;
 
    SHORT cycle_type;
 
    REAL quality_bound;
 
    SHORT smoother;
 
    SHORT smooth_order; // 1: nature order 2: C/F order (both are symmetric)
 
    SHORT presmooth_iter;
 
    SHORT postsmooth_iter;
 
    REAL relaxation;
 
    SHORT polynomial_degree;
 
    SHORT coarse_solver;
 
    SHORT coarse_scaling;
 
    SHORT amli_degree;
 
    REAL* amli_coef;
 
    SHORT nl_amli_krylov_type;
 
    SHORT coarsening_type;
 
    SHORT aggregation_type;
 
    SHORT aggregation_norm_type;
 
    SHORT interpolation_type;
 
    REAL strong_threshold;
 
    REAL max_row_sum;
 
    REAL truncation_threshold;
 
    INT aggressive_level;
 
    INT aggressive_path;
 
    INT pair_number;
 
    REAL strong_coupled;
 
    INT max_aggregation;
 
    REAL tentative_smooth;
 
    SHORT smooth_filter;
 
    SHORT smooth_restriction;
 
    SHORT ILU_levels;
 
    SHORT ILU_type;
 
    INT ILU_lfil;
 
    REAL ILU_droptol;
 
    REAL ILU_relax;
 
    REAL ILU_permtol;
 
    INT SWZ_levels;
 
    INT SWZ_mmsize;
 
    INT SWZ_maxlvl;
 
    INT SWZ_type;
 
    INT SWZ_blksolver;
 
    REAL theta;
 
} AMG_param; 
/*---------------------------*/
/*--- Work data structures --*/
/*---------------------------*/
 
typedef struct {
 
#if WITH_MUMPS
    DMUMPS_STRUC_C id;
#endif
 
    INT job;
 
} Mumps_data; 
typedef struct {
 
    void* pt[64];
 
#if WITH_PARDISO
    MKL_INT iparm[64];
 
    MKL_INT mtype;
 
    MKL_INT maxfct;
 
    MKL_INT mnum;
 
#endif
 
} Pardiso_data; 
typedef struct {
 
    dCSRmat* A;
 
    INT type;
 
    INT row;
 
    INT col;
 
    INT nzlu;
 
    INT* ijlu;
 
    REAL* luval;
 
    INT nb;
 
    INT nwork;
 
    REAL* work;
 
    INT* iperm;
    // iperm[0:n-1]   = old indices of unknowns
    // iperm[n:2*n-1] = reverse permutation = new indices.
 
    INT ncolors;
 
    INT* ic;
 
    INT* icmap;
 
    INT* uptr;
 
    INT nlevL;
 
    INT nlevU;
 
    INT* ilevL;
 
    INT* ilevU;
 
    INT* jlevL;
 
    INT* jlevU;
 
} ILU_data; 
typedef struct {
 
    /* matrix information */
 
    dCSRmat A; // note: must start from 1!! Change later
 
    /* blocks information */
 
    INT nblk;
 
    INT* iblock;
 
    INT* jblock;
 
    REAL* rhsloc;
 
    dvector rhsloc1;
 
    dvector xloc1;
 
    REAL* au;
 
    REAL* al;
 
    INT SWZ_type;
 
    INT blk_solver;
 
    INT memt;
 
    INT* mask;
 
    INT maxbs;
 
    INT* maxa;
 
    dCSRmat* blk_data;
 
#if WITH_UMFPACK
    void** numeric;
#endif
 
#if WITH_MUMPS
    DMUMPS_STRUC_C* id;
#endif
 
    Mumps_data* mumps;
 
    SWZ_param* swzparam;
 
} SWZ_data; 
typedef struct {
 
    /* Level information */
 
    SHORT max_levels;
 
    SHORT num_levels;
 
    /* Problem information */
 
    dCSRmat A;
 
    dCSRmat R;
 
    dCSRmat P;
 
    dvector b;
 
    dvector x;
 
    /* Extra information */
 
    void* Numeric;
 
    Pardiso_data pdata;
 
    ivector cfmark;
 
    INT ILU_levels;
 
    ILU_data LU;
 
    INT near_kernel_dim;
 
    REAL** near_kernel_basis;
 
    // Smoother order information
 
    INT SWZ_levels;
 
    SWZ_data Schwarz;
 
    dvector w;
 
    Mumps_data mumps;
 
    INT cycle_type;
 
    INT* ic;
 
    INT* icmap;
 
    INT colors;
 
    REAL weight;
 
#if MULTI_COLOR_ORDER
    REAL GS_Theta;
#endif
 
} AMG_data; 
typedef struct {
 
    SHORT AMG_type;
 
    SHORT print_level;
 
    INT maxit;
 
    SHORT max_levels;
 
    REAL tol;
 
    SHORT cycle_type;
 
    SHORT smoother;
 
    SHORT smooth_order;
 
    SHORT presmooth_iter;
 
    SHORT postsmooth_iter;
 
    REAL relaxation;
 
    SHORT polynomial_degree;
 
    SHORT coarsening_type;
 
    SHORT coarse_solver;
 
    SHORT coarse_scaling;
 
    SHORT amli_degree;
 
    SHORT nl_amli_krylov_type;
 
    REAL tentative_smooth;
 
    REAL* amli_coef;
 
    AMG_data* mgl_data;
 
    ILU_data* LU;
 
    dCSRmat* A;
 
    // extra near kernel space
 
    dCSRmat* A_nk;
 
    dCSRmat* P_nk;
 
    dCSRmat* R_nk;
 
    // temporary work space
 
    dvector r;
 
    REAL* w;
 
} precond_data; 
typedef struct {
 
    SHORT AMG_type;
 
    SHORT print_level;
 
    INT maxit;
 
    SHORT max_levels;
 
    REAL tol;
 
    SHORT cycle_type;
 
    SHORT smoother;
 
    SHORT presmooth_iter;
 
    SHORT postsmooth_iter;
 
    SHORT coarsening_type;
 
    REAL relaxation;
 
    SHORT coarse_scaling;
 
    AMG_data* mgl_data;
 
    ILU_data* LU;
 
    SHORT scaled;
 
    dCSRmat* A;
 
    dSTRmat* A_str;
 
    dSTRmat* SS_str;
 
    // data for GS/block GS smoothers (STR format)
 
    dvector* diaginv;
 
    ivector* pivot;
 
    dvector* diaginvS;
 
    ivector* pivotS;
 
    ivector* order;
 
    ivector* neigh;
 
    // temporary work space
 
    dvector r;
 
    REAL* w;
 
} precond_data_str; 
typedef struct {
 
    INT nc;
 
    dvector diag;
 
} precond_diag_str; 
typedef struct {
 
    void* data;
 
    void (*fct)(REAL*, REAL*, void*);
 
} precond; 
typedef struct {
 
    void* data;
 
    void (*fct)(const void*, const REAL*, REAL*);
 
} mxv_matfree; 
typedef struct {
 
    // output flags
    SHORT print_level; 
    SHORT output_type; 
    // problem parameters
    char inifile[STRLEN]; 
    char workdir[STRLEN]; 
    INT  problem_num;     
    // parameters for iterative solvers
    SHORT solver_type;     
    SHORT decoup_type;     
    SHORT precond_type;    
    SHORT stop_type;       
    REAL  itsolver_tol;    
    REAL  itsolver_abstol; 
    INT   itsolver_maxit;  
    INT   restart;         
    // parameters for ILU
    SHORT ILU_type;    
    INT   ILU_lfil;    
    REAL  ILU_droptol; 
    REAL  ILU_relax;   
    REAL  ILU_permtol; 
    // parameter for Schwarz
    INT SWZ_mmsize;    
    INT SWZ_maxlvl;    
    INT SWZ_type;      
    INT SWZ_blksolver; 
    // parameters for AMG
    SHORT AMG_type;                
    SHORT AMG_levels;              
    SHORT AMG_cycle_type;          
    SHORT AMG_smoother;            
    SHORT AMG_smooth_order;        
    REAL  AMG_relaxation;          
    SHORT AMG_polynomial_degree;   
    SHORT AMG_presmooth_iter;      
    SHORT AMG_postsmooth_iter;     
    REAL  AMG_tol;                 
    INT   AMG_coarse_dof;          
    INT   AMG_maxit;               
    SHORT AMG_ILU_levels;          
    SHORT AMG_coarse_solver;       
    SHORT AMG_coarse_scaling;      
    SHORT AMG_amli_degree;         
    SHORT AMG_nl_amli_krylov_type; 
    INT   AMG_SWZ_levels;          
    // parameters for classical AMG
    SHORT AMG_coarsening_type;      
    SHORT AMG_aggregation_type;     
    SHORT AMG_interpolation_type;   
    REAL  AMG_strong_threshold;     
    REAL  AMG_truncation_threshold; 
    REAL  AMG_max_row_sum;          
    INT   AMG_aggressive_level;     
    INT   AMG_aggressive_path;      
    INT   AMG_pair_number;          
    REAL  AMG_quality_bound;        
    //  parameters for smoothed aggregation AMG
    REAL  AMG_strong_coupled;     
    INT   AMG_max_aggregation;    
    REAL  AMG_tentative_smooth;   
    SHORT AMG_smooth_filter;      
    SHORT AMG_smooth_restriction; 
    SHORT AMG_aggregation_norm_type; 
} input_param;                       
/*
 * OpenMP definitions and declarations
 */
#ifdef _OPENMP
 
#include "omp.h"
 
#define ILU_MC_OMP OFF 
// extern INT omp_count;   /**< Counter for multiple calls: Remove later!!! --Chensong
// */
 
extern INT THDs_AMG_GS;        
extern INT THDs_CPR_lGS;       
extern INT THDs_CPR_gGS;       
#ifdef DETAILTIME
extern REAL total_linear_time; 
extern REAL total_start_time;  
extern REAL total_setup_time;  
extern INT  total_iter;        
extern INT  fasp_called_times; 
#endif
 
#endif /* end if for _OPENMP */
 
extern double PreSmoother_time_zl;
extern double PostSmoother_time_zl;
extern double Krylov_time_zl;
extern double Coarsen_time_zl;
extern double AMLI_cycle_time_zl;
 
#endif /* end if for __FASP_HEADER__ */
 
/*---------------------------------*/
/*--        End of File          --*/
/*---------------------------------*/