PetscErrorCode PCSetUp_ML(PC pc)
{
PetscErrorCode ierr;
PetscMPIInt size;
FineGridCtx *PetscMLdata;
ML *ml_object;
ML_Aggregate *agg_object;
ML_Operator *mlmat;
PetscInt nlocal_allcols,Nlevels,mllevel,level,level1,m,fine_level,bs;
Mat A,Aloc;
GridCtx *gridctx;
PC_MG *mg = (PC_MG*)pc->data;
PC_ML *pc_ml = (PC_ML*)mg->innerctx;
PetscBool isSeq, isMPI;
KSP smoother;
PC subpc;
PetscInt mesh_level, old_mesh_level;
PetscFunctionBegin;
A = pc->pmat;
ierr = MPI_Comm_size(((PetscObject)A)->comm,&size);CHKERRQ(ierr);
if (pc->setupcalled) {
if (pc->flag == SAME_NONZERO_PATTERN && pc_ml->reuse_interpolation) {
/*
Reuse interpolaton instead of recomputing aggregates and updating the whole hierarchy. This is less expensive for
multiple solves in which the matrix is not changing too quickly.
*/
ml_object = pc_ml->ml_object;
gridctx = pc_ml->gridctx;
Nlevels = pc_ml->Nlevels;
fine_level = Nlevels - 1;
gridctx[fine_level].A = A;
ierr = PetscObjectTypeCompare((PetscObject) A, MATSEQAIJ, &isSeq);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject) A, MATMPIAIJ, &isMPI);CHKERRQ(ierr);
if (isMPI){
ierr = MatConvert_MPIAIJ_ML(A,PETSC_NULL,MAT_INITIAL_MATRIX,&Aloc);CHKERRQ(ierr);
} else if (isSeq) {
Aloc = A;
ierr = PetscObjectReference((PetscObject)Aloc);CHKERRQ(ierr);
} else SETERRQ1(((PetscObject)pc)->comm,PETSC_ERR_ARG_WRONG, "Matrix type '%s' cannot be used with ML. ML can only handle AIJ matrices.",((PetscObject)A)->type_name);
ierr = MatGetSize(Aloc,&m,&nlocal_allcols);CHKERRQ(ierr);
PetscMLdata = pc_ml->PetscMLdata;
ierr = MatDestroy(&PetscMLdata->Aloc);CHKERRQ(ierr);
PetscMLdata->A = A;
PetscMLdata->Aloc = Aloc;
ML_Init_Amatrix(ml_object,0,m,m,PetscMLdata);
ML_Set_Amatrix_Matvec(ml_object,0,PetscML_matvec);
mesh_level = ml_object->ML_finest_level;
while (ml_object->SingleLevel[mesh_level].Rmat->to) {
old_mesh_level = mesh_level;
mesh_level = ml_object->SingleLevel[mesh_level].Rmat->to->levelnum;
/* clean and regenerate A */
mlmat = &(ml_object->Amat[mesh_level]);
ML_Operator_Clean(mlmat);
ML_Operator_Init(mlmat,ml_object->comm);
ML_Gen_AmatrixRAP(ml_object, old_mesh_level, mesh_level);
}
level = fine_level - 1;
if (size == 1) { /* convert ML P, R and A into seqaij format */
for (mllevel=1; mllevel<Nlevels; mllevel++){
mlmat = &(ml_object->Amat[mllevel]);
ierr = MatWrapML_SeqAIJ(mlmat,MAT_REUSE_MATRIX,&gridctx[level].A);CHKERRQ(ierr);
level--;
}
} else { /* convert ML P and R into shell format, ML A into mpiaij format */
for (mllevel=1; mllevel<Nlevels; mllevel++){
mlmat = &(ml_object->Amat[mllevel]);
ierr = MatWrapML_MPIAIJ(mlmat,MAT_REUSE_MATRIX,&gridctx[level].A);CHKERRQ(ierr);
level--;
}
}
for (level=0; level<fine_level; level++) {
if (level > 0){
ierr = PCMGSetResidual(pc,level,PCMGDefaultResidual,gridctx[level].A);CHKERRQ(ierr);
}
ierr = KSPSetOperators(gridctx[level].ksp,gridctx[level].A,gridctx[level].A,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
}
ierr = PCMGSetResidual(pc,fine_level,PCMGDefaultResidual,gridctx[fine_level].A);CHKERRQ(ierr);
ierr = KSPSetOperators(gridctx[fine_level].ksp,gridctx[level].A,gridctx[fine_level].A,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = PCSetUp_MG(pc);CHKERRQ(ierr);
PetscFunctionReturn(0);
} else {
/* since ML can change the size of vectors/matrices at any level we must destroy everything */
ierr = PCReset_ML(pc);CHKERRQ(ierr);
ierr = PCReset_MG(pc);CHKERRQ(ierr);
}
}
/* setup special features of PCML */
/*--------------------------------*/
/* covert A to Aloc to be used by ML at fine grid */
pc_ml->size = size;
ierr = PetscObjectTypeCompare((PetscObject) A, MATSEQAIJ, &isSeq);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject) A, MATMPIAIJ, &isMPI);CHKERRQ(ierr);
if (isMPI){
ierr = MatConvert_MPIAIJ_ML(A,PETSC_NULL,MAT_INITIAL_MATRIX,&Aloc);CHKERRQ(ierr);
} else if (isSeq) {
Aloc = A;
ierr = PetscObjectReference((PetscObject)Aloc);CHKERRQ(ierr);
} else SETERRQ1(((PetscObject)pc)->comm,PETSC_ERR_ARG_WRONG, "Matrix type '%s' cannot be used with ML. ML can only handle AIJ matrices.",((PetscObject)A)->type_name);
/* create and initialize struct 'PetscMLdata' */
ierr = PetscNewLog(pc,FineGridCtx,&PetscMLdata);CHKERRQ(ierr);
pc_ml->PetscMLdata = PetscMLdata;
ierr = PetscMalloc((Aloc->cmap->n+1)*sizeof(PetscScalar),&PetscMLdata->pwork);CHKERRQ(ierr);
ierr = VecCreate(PETSC_COMM_SELF,&PetscMLdata->x);CHKERRQ(ierr);
ierr = VecSetSizes(PetscMLdata->x,Aloc->cmap->n,Aloc->cmap->n);CHKERRQ(ierr);
ierr = VecSetType(PetscMLdata->x,VECSEQ);CHKERRQ(ierr);
ierr = VecCreate(PETSC_COMM_SELF,&PetscMLdata->y);CHKERRQ(ierr);
ierr = VecSetSizes(PetscMLdata->y,A->rmap->n,PETSC_DECIDE);CHKERRQ(ierr);
ierr = VecSetType(PetscMLdata->y,VECSEQ);CHKERRQ(ierr);
PetscMLdata->A = A;
PetscMLdata->Aloc = Aloc;
/* create ML discretization matrix at fine grid */
/* ML requires input of fine-grid matrix. It determines nlevels. */
ierr = MatGetSize(Aloc,&m,&nlocal_allcols);CHKERRQ(ierr);
ierr = MatGetBlockSize(A,&bs);CHKERRQ(ierr);
ML_Create(&ml_object,pc_ml->MaxNlevels);
ML_Comm_Set_UsrComm(ml_object->comm,((PetscObject)A)->comm);
pc_ml->ml_object = ml_object;
ML_Init_Amatrix(ml_object,0,m,m,PetscMLdata);
ML_Set_Amatrix_Getrow(ml_object,0,PetscML_getrow,PetscML_comm,nlocal_allcols);
ML_Set_Amatrix_Matvec(ml_object,0,PetscML_matvec);
ML_Set_Symmetrize(ml_object,pc_ml->Symmetrize ? ML_YES : ML_NO);
/* aggregation */
ML_Aggregate_Create(&agg_object);
pc_ml->agg_object = agg_object;
{
MatNullSpace mnull;
ierr = MatGetNearNullSpace(A,&mnull);CHKERRQ(ierr);
if (pc_ml->nulltype == PCML_NULLSPACE_AUTO) {
if (mnull) pc_ml->nulltype = PCML_NULLSPACE_USER;
else if (bs > 1) pc_ml->nulltype = PCML_NULLSPACE_BLOCK;
else pc_ml->nulltype = PCML_NULLSPACE_SCALAR;
}
switch (pc_ml->nulltype) {
case PCML_NULLSPACE_USER: {
PetscScalar *nullvec;
const PetscScalar *v;
PetscBool has_const;
PetscInt i,j,mlocal,nvec,M;
const Vec *vecs;
if (!mnull) SETERRQ(((PetscObject)pc)->comm,PETSC_ERR_USER,"Must provide explicit null space using MatSetNearNullSpace() to use user-specified null space");
ierr = MatGetSize(A,&M,PETSC_NULL);CHKERRQ(ierr);
ierr = MatGetLocalSize(Aloc,&mlocal,PETSC_NULL);CHKERRQ(ierr);
ierr = MatNullSpaceGetVecs(mnull,&has_const,&nvec,&vecs);CHKERRQ(ierr);
ierr = PetscMalloc((nvec+!!has_const)*mlocal*sizeof *nullvec,&nullvec);CHKERRQ(ierr);
if (has_const) for (i=0; i<mlocal; i++) nullvec[i] = 1.0/M;
for (i=0; i<nvec; i++) {
ierr = VecGetArrayRead(vecs[i],&v);CHKERRQ(ierr);
for (j=0; j<mlocal; j++) nullvec[(i+!!has_const)*mlocal + j] = v[j];
ierr = VecRestoreArrayRead(vecs[i],&v);CHKERRQ(ierr);
}
ierr = ML_Aggregate_Set_NullSpace(agg_object,bs,nvec+!!has_const,nullvec,mlocal);CHKERRQ(ierr);
ierr = PetscFree(nullvec);CHKERRQ(ierr);
} break;
case PCML_NULLSPACE_BLOCK:
ierr = ML_Aggregate_Set_NullSpace(agg_object,bs,bs,0,0);CHKERRQ(ierr);
break;
case PCML_NULLSPACE_SCALAR:
break;
default: SETERRQ(((PetscObject)pc)->comm,PETSC_ERR_SUP,"Unknown null space type");
}
}
ML_Aggregate_Set_MaxCoarseSize(agg_object,pc_ml->MaxCoarseSize);
/* set options */
switch (pc_ml->CoarsenScheme) {
case 1:
ML_Aggregate_Set_CoarsenScheme_Coupled(agg_object);break;
case 2:
ML_Aggregate_Set_CoarsenScheme_MIS(agg_object);break;
case 3:
ML_Aggregate_Set_CoarsenScheme_METIS(agg_object);break;
}
ML_Aggregate_Set_Threshold(agg_object,pc_ml->Threshold);
ML_Aggregate_Set_DampingFactor(agg_object,pc_ml->DampingFactor);
if (pc_ml->SpectralNormScheme_Anorm){
ML_Set_SpectralNormScheme_Anorm(ml_object);
}
agg_object->keep_agg_information = (int)pc_ml->KeepAggInfo;
agg_object->keep_P_tentative = (int)pc_ml->Reusable;
agg_object->block_scaled_SA = (int)pc_ml->BlockScaling;
agg_object->minimizing_energy = (int)pc_ml->EnergyMinimization;
agg_object->minimizing_energy_droptol = (double)pc_ml->EnergyMinimizationDropTol;
agg_object->cheap_minimizing_energy = (int)pc_ml->EnergyMinimizationCheap;
if (pc_ml->OldHierarchy) {
Nlevels = ML_Gen_MGHierarchy_UsingAggregation(ml_object,0,ML_INCREASING,agg_object);
} else {
Nlevels = ML_Gen_MultiLevelHierarchy_UsingAggregation(ml_object,0,ML_INCREASING,agg_object);
}
if (Nlevels<=0) SETERRQ1(((PetscObject)pc)->comm,PETSC_ERR_ARG_OUTOFRANGE,"Nlevels %d must > 0",Nlevels);
pc_ml->Nlevels = Nlevels;
fine_level = Nlevels - 1;
ierr = PCMGSetLevels(pc,Nlevels,PETSC_NULL);CHKERRQ(ierr);
/* set default smoothers */
for (level=1; level<=fine_level; level++){
if (size == 1){
ierr = PCMGGetSmoother(pc,level,&smoother);CHKERRQ(ierr);
ierr = KSPSetType(smoother,KSPRICHARDSON);CHKERRQ(ierr);
ierr = KSPGetPC(smoother,&subpc);CHKERRQ(ierr);
ierr = PCSetType(subpc,PCSOR);CHKERRQ(ierr);
} else {
ierr = PCMGGetSmoother(pc,level,&smoother);CHKERRQ(ierr);
ierr = KSPSetType(smoother,KSPRICHARDSON);CHKERRQ(ierr);
ierr = KSPGetPC(smoother,&subpc);CHKERRQ(ierr);
ierr = PCSetType(subpc,PCSOR);CHKERRQ(ierr);
}
}
ierr = PetscObjectOptionsBegin((PetscObject)pc);CHKERRQ(ierr);
ierr = PCSetFromOptions_MG(pc);CHKERRQ(ierr); /* should be called in PCSetFromOptions_ML(), but cannot be called prior to PCMGSetLevels() */
ierr = PetscOptionsEnd();CHKERRQ(ierr);
ierr = PetscMalloc(Nlevels*sizeof(GridCtx),&gridctx);CHKERRQ(ierr);
pc_ml->gridctx = gridctx;
/* wrap ML matrices by PETSc shell matrices at coarsened grids.
Level 0 is the finest grid for ML, but coarsest for PETSc! */
gridctx[fine_level].A = A;
level = fine_level - 1;
if (size == 1){ /* convert ML P, R and A into seqaij format */
for (mllevel=1; mllevel<Nlevels; mllevel++){
mlmat = &(ml_object->Pmat[mllevel]);
ierr = MatWrapML_SeqAIJ(mlmat,MAT_INITIAL_MATRIX,&gridctx[level].P);CHKERRQ(ierr);
mlmat = &(ml_object->Rmat[mllevel-1]);
ierr = MatWrapML_SeqAIJ(mlmat,MAT_INITIAL_MATRIX,&gridctx[level].R);CHKERRQ(ierr);
mlmat = &(ml_object->Amat[mllevel]);
ierr = MatWrapML_SeqAIJ(mlmat,MAT_INITIAL_MATRIX,&gridctx[level].A);CHKERRQ(ierr);
level--;
}
} else { /* convert ML P and R into shell format, ML A into mpiaij format */
for (mllevel=1; mllevel<Nlevels; mllevel++){
mlmat = &(ml_object->Pmat[mllevel]);
ierr = MatWrapML_SHELL(mlmat,MAT_INITIAL_MATRIX,&gridctx[level].P);CHKERRQ(ierr);
mlmat = &(ml_object->Rmat[mllevel-1]);
ierr = MatWrapML_SHELL(mlmat,MAT_INITIAL_MATRIX,&gridctx[level].R);CHKERRQ(ierr);
mlmat = &(ml_object->Amat[mllevel]);
ierr = MatWrapML_MPIAIJ(mlmat,MAT_INITIAL_MATRIX,&gridctx[level].A);CHKERRQ(ierr);
level--;
}
}
/* create vectors and ksp at all levels */
for (level=0; level<fine_level; level++){
level1 = level + 1;
ierr = VecCreate(((PetscObject)gridctx[level].A)->comm,&gridctx[level].x);CHKERRQ(ierr);
ierr = VecSetSizes(gridctx[level].x,gridctx[level].A->cmap->n,PETSC_DECIDE);CHKERRQ(ierr);
ierr = VecSetType(gridctx[level].x,VECMPI);CHKERRQ(ierr);
ierr = PCMGSetX(pc,level,gridctx[level].x);CHKERRQ(ierr);
ierr = VecCreate(((PetscObject)gridctx[level].A)->comm,&gridctx[level].b);CHKERRQ(ierr);
ierr = VecSetSizes(gridctx[level].b,gridctx[level].A->rmap->n,PETSC_DECIDE);CHKERRQ(ierr);
ierr = VecSetType(gridctx[level].b,VECMPI);CHKERRQ(ierr);
ierr = PCMGSetRhs(pc,level,gridctx[level].b);CHKERRQ(ierr);
ierr = VecCreate(((PetscObject)gridctx[level1].A)->comm,&gridctx[level1].r);CHKERRQ(ierr);
ierr = VecSetSizes(gridctx[level1].r,gridctx[level1].A->rmap->n,PETSC_DECIDE);CHKERRQ(ierr);
ierr = VecSetType(gridctx[level1].r,VECMPI);CHKERRQ(ierr);
ierr = PCMGSetR(pc,level1,gridctx[level1].r);CHKERRQ(ierr);
if (level == 0){
ierr = PCMGGetCoarseSolve(pc,&gridctx[level].ksp);CHKERRQ(ierr);
} else {
ierr = PCMGGetSmoother(pc,level,&gridctx[level].ksp);CHKERRQ(ierr);
}
}
ierr = PCMGGetSmoother(pc,fine_level,&gridctx[fine_level].ksp);CHKERRQ(ierr);
/* create coarse level and the interpolation between the levels */
for (level=0; level<fine_level; level++){
level1 = level + 1;
ierr = PCMGSetInterpolation(pc,level1,gridctx[level].P);CHKERRQ(ierr);
ierr = PCMGSetRestriction(pc,level1,gridctx[level].R);CHKERRQ(ierr);
if (level > 0){
ierr = PCMGSetResidual(pc,level,PCMGDefaultResidual,gridctx[level].A);CHKERRQ(ierr);
}
ierr = KSPSetOperators(gridctx[level].ksp,gridctx[level].A,gridctx[level].A,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
}
ierr = PCMGSetResidual(pc,fine_level,PCMGDefaultResidual,gridctx[fine_level].A);CHKERRQ(ierr);
ierr = KSPSetOperators(gridctx[fine_level].ksp,gridctx[level].A,gridctx[fine_level].A,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
/* setupcalled is set to 0 so that MG is setup from scratch */
pc->setupcalled = 0;
ierr = PCSetUp_MG(pc);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int main(int argc, char *argv[])
{
int num_PDE_eqns=5, N_levels=3;
/* int nsmooth=1; */
int leng, level, N_grid_pts, coarsest_level;
/* See Aztec User's Guide for more information on the */
/* variables that follow. */
int proc_config[AZ_PROC_SIZE], options[AZ_OPTIONS_SIZE];
double params[AZ_PARAMS_SIZE], status[AZ_STATUS_SIZE];
/* data structure for matrix corresponding to the fine grid */
int *data_org = NULL, *update = NULL, *external = NULL;
int *update_index = NULL, *extern_index = NULL;
int *cpntr = NULL;
int *bindx = NULL, N_update, iii;
double *val = NULL;
double *xxx, *rhs;
AZ_MATRIX *Amat;
AZ_PRECOND *Pmat = NULL;
ML *ml;
FILE *fp;
int ch,i;
struct AZ_SCALING *scaling;
double solve_time, setup_time, start_time;
ML_Aggregate *ag;
int *ivec;
#ifdef VBR_VERSION
ML_Operator *B, *C, *D;
int *vbr_cnptr, *vbr_rnptr, *vbr_indx, *vbr_bindx, *vbr_bnptr, total_blk_rows;
int total_blk_cols, blk_space, nz_space;
double *vbr_val;
struct ML_CSR_MSRdata *csr_data;
#endif
#ifdef ML_MPI
MPI_Init(&argc,&argv);
/* get number of processors and the name of this processor */
AZ_set_proc_config(proc_config, MPI_COMM_WORLD);
#else
AZ_set_proc_config(proc_config, AZ_NOT_MPI);
#endif
#ifdef binary
fp=fopen(".data","rb");
#else
fp=fopen(".data","r");
#endif
if (fp==NULL)
{
printf("couldn't open file .data\n");
exit(1);
}
#ifdef binary
fread(&leng, sizeof(int), 1, fp);
#else
fscanf(fp,"%d",&leng);
#endif
fclose(fp);
N_grid_pts=leng/num_PDE_eqns;
/* initialize the list of global indices. NOTE: the list of global */
/* indices must be in ascending order so that subsequent calls to */
/* AZ_find_index() will function properly. */
AZ_read_update(&N_update, &update, proc_config, N_grid_pts, num_PDE_eqns,
AZ_linear);
AZ_read_msr_matrix(update, &val, &bindx, N_update, proc_config);
/* This code is to fix things up so that we are sure we have */
/* all block (including the ghost nodes the same size. */
AZ_block_MSR(&bindx, &val, N_update, num_PDE_eqns, update);
AZ_transform(proc_config, &external, bindx, val, update, &update_index,
&extern_index, &data_org, N_update, 0, 0, 0, &cpntr,
AZ_MSR_MATRIX);
Amat = AZ_matrix_create( leng );
#ifndef VBR_VERSION
AZ_set_MSR(Amat, bindx, val, data_org, 0, NULL, AZ_LOCAL);
Amat->matrix_type = data_org[AZ_matrix_type];
data_org[AZ_N_rows] = data_org[AZ_N_internal] + data_org[AZ_N_border];
#else
total_blk_rows = N_update/num_PDE_eqns;
total_blk_cols = total_blk_rows;
blk_space = total_blk_rows*20;
nz_space = blk_space*num_PDE_eqns*num_PDE_eqns;
vbr_cnptr = (int *) ML_allocate(sizeof(int )*(total_blk_cols+1));
vbr_rnptr = (int *) ML_allocate(sizeof(int )*(total_blk_cols+1));
vbr_bnptr = (int *) ML_allocate(sizeof(int )*(total_blk_cols+2));
vbr_indx = (int *) ML_allocate(sizeof(int )*(blk_space+1));
vbr_bindx = (int *) ML_allocate(sizeof(int )*(blk_space+1));
vbr_val = (double *) ML_allocate(sizeof(double)*(nz_space+1));
for (i = 0; i <= total_blk_cols; i++) vbr_cnptr[i] = num_PDE_eqns;
AZ_msr2vbr(vbr_val, vbr_indx, vbr_rnptr, vbr_cnptr, vbr_bnptr,
vbr_bindx, bindx, val,
total_blk_rows, total_blk_cols, blk_space,
nz_space, -1);
data_org[AZ_N_rows] = data_org[AZ_N_internal] + data_org[AZ_N_border];
data_org[AZ_N_int_blk] = data_org[AZ_N_internal]/num_PDE_eqns;
data_org[AZ_N_bord_blk] = data_org[AZ_N_bord_blk]/num_PDE_eqns;
data_org[AZ_N_ext_blk] = data_org[AZ_N_ext_blk]/num_PDE_eqns;
data_org[AZ_matrix_type] = AZ_VBR_MATRIX;
AZ_set_VBR(Amat, vbr_rnptr, vbr_cnptr, vbr_bnptr, vbr_indx, vbr_bindx,
vbr_val, data_org, 0, NULL, AZ_LOCAL);
Amat->matrix_type = data_org[AZ_matrix_type];
#endif
start_time = AZ_second();
ML_Create(&ml, N_levels);
ML_Set_PrintLevel(3);
/* set up discretization matrix and matrix vector function */
AZ_ML_Set_Amat(ml, N_levels-1, N_update, N_update, Amat, proc_config);
ML_Aggregate_Create( &ag );
ML_Aggregate_Set_Threshold(ag,0.0);
ML_Set_SpectralNormScheme_PowerMethod(ml);
/*
To run SA:
a) set damping factor to 1 and use power method
ML_Aggregate_Set_DampingFactor(ag, 4./3.);
To run NSA:
a) set damping factor to 0
ML_Aggregate_Set_DampingFactor(ag, 0.);
To run NSR
a) set damping factor to 1 and use power method
ML_Aggregate_Set_DampingFactor(ag, 1.);
ag->Restriction_smoothagg_transpose = ML_FALSE;
ag->keep_agg_information=1;
ag->keep_P_tentative=1;
b) hack code so it calls the energy minimizing restriction
line 2973 of ml_agg_genP.c
c) turn on the NSR flag in ml_agg_energy_min.cpp
To run Emin
a) set min_eneryg = 2 and keep_agg_info = 1;
ag->minimizing_energy=2;
ag->keep_agg_information=1;
ag->cheap_minimizing_energy = 0;
ag->block_scaled_SA = 1;
*/
ag->minimizing_energy=2;
ag->keep_agg_information=1;
ag->block_scaled_SA = 1;
ML_Aggregate_Set_NullSpace(ag, num_PDE_eqns, num_PDE_eqns, NULL, N_update);
ML_Aggregate_Set_MaxCoarseSize( ag, 20);
/*
ML_Aggregate_Set_RandomOrdering( ag );
ML_Aggregate_Set_DampingFactor(ag, .1);
ag->drop_tol_for_smoothing = 1.0e-3;
ML_Aggregate_Set_Threshold(ag, 1.0e-3);
ML_Aggregate_Set_MaxCoarseSize( ag, 300);
*/
coarsest_level = ML_Gen_MultiLevelHierarchy_UsingAggregation(ml, N_levels-1, ML_DECREASING, ag);
coarsest_level = N_levels - coarsest_level;
if ( proc_config[AZ_node] == 0 )
printf("Coarse level = %d \n", coarsest_level);
/* set up smoothers */
AZ_defaults(options, params);
for (level = N_levels-1; level > coarsest_level; level--) {
/* This is the Aztec domain decomp/ilu smoother that we */
/* usually use for this problem. */
/*
options[AZ_precond] = AZ_dom_decomp;
options[AZ_subdomain_solve] = AZ_ilut;
params[AZ_ilut_fill] = 1.0;
options[AZ_reorder] = 1;
ML_Gen_SmootherAztec(ml, level, options, params,
proc_config, status, AZ_ONLY_PRECONDITIONER,
ML_PRESMOOTHER,NULL);
*/
/* Sparse approximate inverse smoother that acutally does both */
/* pre and post smoothing. */
/*
ML_Gen_Smoother_ParaSails(ml , level, ML_PRESMOOTHER, nsmooth,
parasails_sym, parasails_thresh,
parasails_nlevels, parasails_filter,
parasails_loadbal, parasails_factorized);
parasails_thresh /= 4.;
*/
/* This is the symmetric Gauss-Seidel smoothing. In parallel, */
/* it is not a true Gauss-Seidel in that each processor */
/* does a Gauss-Seidel on its local submatrix independent of the */
/* other processors. */
/*
ML_Gen_Smoother_SymGaussSeidel(ml,level,ML_PRESMOOTHER, nsmooth,1.);
ML_Gen_Smoother_SymGaussSeidel(ml,level,ML_POSTSMOOTHER,nsmooth,1.);
*/
/* Block Gauss-Seidel with block size equal to #DOF per node. */
/* Not a true Gauss-Seidel in that each processor does a */
/* Gauss-Seidel on its local submatrix independent of the other */
/* processors. */
/*
ML_Gen_Smoother_BlockGaussSeidel(ml,level,ML_PRESMOOTHER,
nsmooth,0.67, num_PDE_eqns);
ML_Gen_Smoother_BlockGaussSeidel(ml,level,ML_POSTSMOOTHER,
nsmooth, 0.67, num_PDE_eqns);
*/
ML_Gen_Smoother_SymBlockGaussSeidel(ml,level,ML_POSTSMOOTHER,
1, 1.0, num_PDE_eqns);
}
ML_Gen_CoarseSolverSuperLU( ml, coarsest_level);
ML_Gen_Solver(ml, ML_MGW, N_levels-1, coarsest_level);
AZ_defaults(options, params);
options[AZ_solver] = AZ_gmres;
options[AZ_scaling] = AZ_none;
options[AZ_precond] = AZ_user_precond;
/*
options[AZ_conv] = AZ_r0;
*/
options[AZ_output] = 1;
options[AZ_max_iter] = 1500;
options[AZ_poly_ord] = 5;
options[AZ_kspace] = 130;
params[AZ_tol] = 1.0e-8;
/*
options[AZ_precond] = AZ_dom_decomp;
options[AZ_subdomain_solve] = AZ_ilut;
params[AZ_ilut_fill] = 2.0;
*/
AZ_set_ML_preconditioner(&Pmat, Amat, ml, options);
setup_time = AZ_second() - start_time;
xxx = (double *) malloc( leng*sizeof(double));
rhs=(double *)malloc(leng*sizeof(double));
for (iii = 0; iii < leng; iii++) xxx[iii] = 0.0;
/* Set rhs */
fp = fopen("AZ_capture_rhs.mat","r");
if (fp == NULL) {
if (proc_config[AZ_node] == 0) printf("taking random vector for rhs\n");
AZ_random_vector(rhs, data_org, proc_config);
AZ_reorder_vec(rhs, data_org, update_index, NULL);
}
else {
fclose(fp);
ivec =(int *)malloc((leng+1)*sizeof(int));
AZ_input_msr_matrix("AZ_capture_rhs.mat", update, &rhs, &ivec,
N_update, proc_config);
free(ivec);
AZ_reorder_vec(rhs, data_org, update_index, NULL);
}
/* Set x */
fp = fopen("AZ_capture_init_guess.mat","r");
if (fp != NULL) {
fclose(fp);
ivec =(int *)malloc((leng+1)*sizeof(int));
AZ_input_msr_matrix("AZ_capture_init_guess.mat",update, &xxx, &ivec,
N_update, proc_config);
free(ivec);
AZ_reorder_vec(xxx, data_org, update_index, NULL);
}
/* if Dirichlet BC ... put the answer in */
for (i = 0; i < data_org[AZ_N_internal]+data_org[AZ_N_border]; i++) {
if ( (val[i] > .99999999) && (val[i] < 1.0000001))
xxx[i] = rhs[i];
}
fp = fopen("AZ_no_multilevel.dat","r");
scaling = AZ_scaling_create();
start_time = AZ_second();
if (fp != NULL) {
fclose(fp);
options[AZ_precond] = AZ_none;
options[AZ_scaling] = AZ_sym_diag;
options[AZ_ignore_scaling] = AZ_TRUE;
options[AZ_keep_info] = 1;
AZ_iterate(xxx, rhs, options, params, status, proc_config, Amat, NULL, scaling);
/*
options[AZ_pre_calc] = AZ_reuse;
options[AZ_conv] = AZ_expected_values;
if (proc_config[AZ_node] == 0)
printf("\n-------- Second solve with improved convergence test -----\n");
AZ_iterate(xxx, rhs, options, params, status, proc_config, Amat, NULL, scaling);
if (proc_config[AZ_node] == 0)
printf("\n-------- Third solve with improved convergence test -----\n");
AZ_iterate(xxx, rhs, options, params, status, proc_config, Amat, NULL, scaling);
*/
}
else {
options[AZ_keep_info] = 1;
AZ_iterate(xxx, rhs, options, params, status, proc_config, Amat, Pmat, scaling);
options[AZ_pre_calc] = AZ_reuse;
options[AZ_conv] = AZ_expected_values;
/*
if (proc_config[AZ_node] == 0)
printf("\n-------- Second solve with improved convergence test -----\n");
AZ_iterate(xxx, rhs, options, params, status, proc_config, Amat, Pmat, scaling);
if (proc_config[AZ_node] == 0)
printf("\n-------- Third solve with improved convergence test -----\n");
AZ_iterate(xxx, rhs, options, params, status, proc_config, Amat, Pmat, scaling);
*/
}
solve_time = AZ_second() - start_time;
if (proc_config[AZ_node] == 0)
printf("Solve time = %e, MG Setup time = %e\n", solve_time, setup_time);
ML_Aggregate_Destroy(&ag);
ML_Destroy(&ml);
AZ_free((void *) Amat->data_org);
AZ_free((void *) Amat->val);
AZ_free((void *) Amat->bindx);
AZ_free((void *) update);
AZ_free((void *) external);
AZ_free((void *) extern_index);
AZ_free((void *) update_index);
AZ_scaling_destroy(&scaling);
if (Amat != NULL) AZ_matrix_destroy(&Amat);
if (Pmat != NULL) AZ_precond_destroy(&Pmat);
free(xxx);
free(rhs);
#ifdef ML_MPI
MPI_Finalize();
#endif
return 0;
}
