From 6361d330dd27ce403162ac7284b96a621f4f6a5b Mon Sep 17 00:00:00 2001 From: Salvatore Filippone Date: Tue, 24 May 2016 11:57:51 +0000 Subject: [PATCH] mld2p4-2; tests/pdegen/Makefile tests/pdegen/ppde2d.f90 tests/pdegen/ppde3d-gs.f90 tests/pdegen/ppde3d.f90 tests/pdegen/runs/ppde.inp tests/pdegen/spde2d.f90 tests/pdegen/spde3d.f90 Reworked PDEGEN examples and cleanup. --- tests/pdegen/Makefile | 13 +- tests/pdegen/ppde2d.f90 | 107 ++++---- tests/pdegen/ppde3d-gs.f90 | 497 ------------------------------------- tests/pdegen/ppde3d.f90 | 109 ++++---- tests/pdegen/runs/ppde.inp | 36 +-- tests/pdegen/spde2d.f90 | 107 ++++---- tests/pdegen/spde3d.f90 | 107 ++++---- 7 files changed, 256 insertions(+), 720 deletions(-) delete mode 100644 tests/pdegen/ppde3d-gs.f90 diff --git a/tests/pdegen/Makefile b/tests/pdegen/Makefile index 66a0b906..96819ca6 100644 --- a/tests/pdegen/Makefile +++ b/tests/pdegen/Makefile @@ -11,21 +11,16 @@ FINCLUDES=$(FMFLAG). $(FMFLAG)$(MLDINCDIR) $(FMFLAG)$(PSBINCDIR) $(FIFLAG). EXEDIR=./runs -all: spde3d ppde3d spde2d ppde2d ppde3d-gs +all: spde3d ppde3d spde2d ppde2d ppde3d: ppde3d.o data_input.o $(F90LINK) ppde3d.o data_input.o -o ppde3d $(MLD_LIB) $(PSBLAS_LIB) $(LDLIBS) /bin/mv ppde3d $(EXEDIR) -ppde3d-gs: ppde3d-gs.o data_input.o - $(F90LINK) ppde3d-gs.o data_input.o -o ppde3d-gs $(MLD_LIB) $(PSBLAS_LIB) $(LDLIBS) - /bin/mv ppde3d-gs $(EXEDIR) - spde3d: spde3d.o data_input.o $(F90LINK) spde3d.o data_input.o -o spde3d $(MLD_LIB) $(PSBLAS_LIB) $(LDLIBS) /bin/mv spde3d $(EXEDIR) - ppde2d: ppde2d.o data_input.o $(F90LINK) -g ppde2d.o data_input.o -o ppde2d $(MLD_LIB) $(PSBLAS_LIB) $(LDLIBS) /bin/mv ppde2d $(EXEDIR) @@ -34,15 +29,15 @@ spde2d: spde2d.o data_input.o $(F90LINK) spde2d.o data_input.o -o spde2d $(MLD_LIB) $(PSBLAS_LIB) $(LDLIBS) /bin/mv spde2d $(EXEDIR) -ppde3d-gs.o ppde3d.o spde3d.o ppde2d.o spde2d.o: data_input.o +ppde3d.o spde3d.o ppde2d.o spde2d.o: data_input.o check: all cd runs && ./ppde2d 0) & - & call mld_precset(prec,'n_prec_levs', prectype%nlev, info) + if (prectype%nlevs > 0) then + ! Force number of levels, so disregard the other related arguments. + call mld_precset(prec,'n_prec_levs', prectype%nlevs, info) + else + if (prectype%csize>0)& + & call mld_precset(prec,'coarse_aggr_size', prectype%csize, info) + if (prectype%maxlevs>0)& + & call mld_precset(prec,'max_prec_levs', prectype%maxlevs, info) + if (prectype%mnaggratio>0)& + & call mld_precset(prec,'min_aggr_ratio', prectype%mnaggratio, info) + end if + if (prectype%athres >= dzero) & + & call mld_precset(prec,'aggr_thresh', prectype%athres, info) call mld_precset(prec,'smoother_type', prectype%smther, info) call mld_precset(prec,'smoother_sweeps', prectype%jsweeps, info) call mld_precset(prec,'sub_ovr', prectype%novr, info) @@ -246,18 +259,15 @@ program ppde2d call mld_precset(prec,'aggr_ord', prectype%aggr_ord,info) call mld_precset(prec,'ml_type', prectype%mltype, info) call mld_precset(prec,'smoother_pos', prectype%smthpos, info) - if (prectype%athres >= dzero) & - & call mld_precset(prec,'aggr_thresh', prectype%athres, info) call mld_precset(prec,'coarse_solve', prectype%csolve, info) call mld_precset(prec,'coarse_subsolve', prectype%csbsolve,info) call mld_precset(prec,'coarse_mat', prectype%cmat, info) call mld_precset(prec,'coarse_fillin', prectype%cfill, info) call mld_precset(prec,'coarse_iluthrs', prectype%cthres, info) call mld_precset(prec,'coarse_sweeps', prectype%cjswp, info) - call mld_precset(prec,'coarse_aggr_size', prectype%csize, info) else nlv = 1 - call mld_precinit(prec,prectype%prec, info, nlev=nlv) + call mld_precinit(prec,prectype%prec, info) call mld_precset(prec,'smoother_sweeps', prectype%jsweeps, info) call mld_precset(prec,'sub_ovr', prectype%novr, info) call mld_precset(prec,'sub_restr', prectype%restr, info) @@ -373,31 +383,31 @@ contains call read_data(eps,psb_inp_unit) call read_data(prectype%descr,psb_inp_unit) ! verbose description of the prec call read_data(prectype%prec,psb_inp_unit) ! overall prectype + call read_data(prectype%nlevs,psb_inp_unit) ! Prescribed number of levels + call read_data(prectype%csize,psb_inp_unit) ! coarse size + call read_data(prectype%mnaggratio,psb_inp_unit) ! Minimum aggregation ratio + call read_data(prectype%athres,psb_inp_unit) ! smoother aggr thresh + call read_data(prectype%maxlevs,psb_inp_unit) ! Maximum number of levels + call read_data(prectype%aggrkind,psb_inp_unit) ! smoothed/nonsmoothed/minenergy aggregatin + call read_data(prectype%aggr_alg,psb_inp_unit) ! decoupled or sym. decoupled aggregation + call read_data(prectype%aggr_ord,psb_inp_unit) ! aggregation ordering: natural, node degree + call read_data(prectype%mltype,psb_inp_unit) ! additive or multiplicative 2nd level prec + call read_data(prectype%smthpos,psb_inp_unit) ! side: pre, post, both smoothing + call read_data(prectype%jsweeps,psb_inp_unit) ! Smoother sweeps + call read_data(prectype%smther,psb_inp_unit) ! Smoother type. call read_data(prectype%novr,psb_inp_unit) ! number of overlap layers call read_data(prectype%restr,psb_inp_unit) ! restriction over application of as call read_data(prectype%prol,psb_inp_unit) ! prolongation over application of as - call read_data(prectype%solve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%svsweeps,psb_inp_unit) ! Solver sweeps + call read_data(prectype%solve,psb_inp_unit) ! Subdomain solver: DSCALE ILU MILU ILUT FWGS BWGS MUMPS UMF SLU + call read_data(prectype%svsweeps,psb_inp_unit) ! Solver sweeps (GS) call read_data(prectype%fill1,psb_inp_unit) ! Fill-in for factorization 1 call read_data(prectype%thr1,psb_inp_unit) ! Threshold for fact. 1 ILU(T) - call read_data(prectype%jsweeps,psb_inp_unit) ! Jacobi sweeps for PJAC - if (psb_toupper(prectype%prec) == 'ML') then - call read_data(prectype%smther,psb_inp_unit) ! Smoother type. - call read_data(prectype%nlev,psb_inp_unit) ! Number of levels in multilevel prec. - call read_data(prectype%aggrkind,psb_inp_unit) ! smoothed/raw aggregatin - call read_data(prectype%aggr_alg,psb_inp_unit) ! local or global aggregation - call read_data(prectype%aggr_ord,psb_inp_unit) ! aggregation ordering - call read_data(prectype%mltype,psb_inp_unit) ! additive or multiplicative 2nd level prec - call read_data(prectype%smthpos,psb_inp_unit) ! side: pre, post, both smoothing - call read_data(prectype%cmat,psb_inp_unit) ! coarse mat - call read_data(prectype%csolve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%csbsolve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%cfill,psb_inp_unit) ! Fill-in for factorization 1 - call read_data(prectype%cthres,psb_inp_unit) ! Threshold for fact. 1 ILU(T) - call read_data(prectype%cjswp,psb_inp_unit) ! Jacobi sweeps - call read_data(prectype%athres,psb_inp_unit) ! smoother aggr thresh - call read_data(prectype%csize,psb_inp_unit) ! coarse size - end if + call read_data(prectype%cmat,psb_inp_unit) ! coarse mat + call read_data(prectype%csolve,psb_inp_unit) ! Coarse solver: JACOBI BJAC UMF SLU SLUDIST MUMPS + call read_data(prectype%csbsolve,psb_inp_unit) ! subsolver: DSCALE GS BWGS ILU UMF SLU SLUDIST MUMPS + call read_data(prectype%cfill,psb_inp_unit) ! Fill-in for factorization 1 + call read_data(prectype%cthres,psb_inp_unit) ! Threshold for fact. 1 ILU(T) + call read_data(prectype%cjswp,psb_inp_unit) ! Jacobi sweeps end if ! broadcast parameters to all processors @@ -409,35 +419,34 @@ contains call psb_bcast(ictxt,itrace) call psb_bcast(ictxt,irst) call psb_bcast(ictxt,eps) - - call psb_bcast(ictxt,prectype%descr) ! verbose description of the prec call psb_bcast(ictxt,prectype%prec) ! overall prectype + call psb_bcast(ictxt,prectype%nlevs) ! Prescribed number of levels + call psb_bcast(ictxt,prectype%csize) ! coarse size + call psb_bcast(ictxt,prectype%mnaggratio) ! Minimum aggregation ratio + call psb_bcast(ictxt,prectype%athres) ! smoother aggr thresh + call psb_bcast(ictxt,prectype%maxlevs) ! Maximum number of levels + call psb_bcast(ictxt,prectype%aggrkind) ! smoothed/nonsmoothed/minenergy aggregatin + call psb_bcast(ictxt,prectype%aggr_alg) ! decoupled or sym. decoupled aggregation + call psb_bcast(ictxt,prectype%aggr_ord) ! aggregation ordering: natural, node degree + call psb_bcast(ictxt,prectype%mltype) ! additive or multiplicative 2nd level prec + call psb_bcast(ictxt,prectype%smthpos) ! side: pre, post, both smoothing + call psb_bcast(ictxt,prectype%jsweeps) ! Smoother sweeps + call psb_bcast(ictxt,prectype%smther) ! Smoother type. call psb_bcast(ictxt,prectype%novr) ! number of overlap layers call psb_bcast(ictxt,prectype%restr) ! restriction over application of as call psb_bcast(ictxt,prectype%prol) ! prolongation over application of as - call psb_bcast(ictxt,prectype%solve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%svsweeps) ! Sweeps for inner GS solver + call psb_bcast(ictxt,prectype%solve) ! Subdomain solver: DSCALE ILU MILU ILUT FWGS BWGS MUMPS UMF SLU + call psb_bcast(ictxt,prectype%svsweeps) ! Solver sweeps (GS) call psb_bcast(ictxt,prectype%fill1) ! Fill-in for factorization 1 call psb_bcast(ictxt,prectype%thr1) ! Threshold for fact. 1 ILU(T) - call psb_bcast(ictxt,prectype%jsweeps) ! Jacobi sweeps - if (psb_toupper(prectype%prec) == 'ML') then - call psb_bcast(ictxt,prectype%smther) ! Smoother type. - call psb_bcast(ictxt,prectype%nlev) ! Number of levels in multilevel prec. - call psb_bcast(ictxt,prectype%aggrkind) ! smoothed/raw aggregatin - call psb_bcast(ictxt,prectype%aggr_alg) ! local or global aggregation - call psb_bcast(ictxt,prectype%aggr_ord) ! aggregation ordering - call psb_bcast(ictxt,prectype%mltype) ! additive or multiplicative 2nd level prec - call psb_bcast(ictxt,prectype%smthpos) ! side: pre, post, both smoothing - call psb_bcast(ictxt,prectype%cmat) ! coarse mat - call psb_bcast(ictxt,prectype%csolve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%csbsolve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%cfill) ! Fill-in for factorization 1 - call psb_bcast(ictxt,prectype%cthres) ! Threshold for fact. 1 ILU(T) - call psb_bcast(ictxt,prectype%cjswp) ! Jacobi sweeps - call psb_bcast(ictxt,prectype%athres) ! smoother aggr thresh - call psb_bcast(ictxt,prectype%csize) ! coarse size - end if + call psb_bcast(ictxt,prectype%cmat) ! coarse mat + call psb_bcast(ictxt,prectype%csolve) ! Coarse solver: JACOBI BJAC UMF SLU SLUDIST MUMPS + call psb_bcast(ictxt,prectype%csbsolve) ! subsolver: DSCALE GS BWGS ILU UMF SLU SLUDIST MUMPS + call psb_bcast(ictxt,prectype%cfill) ! Fill-in for factorization 1 + call psb_bcast(ictxt,prectype%cthres) ! Threshold for fact. 1 ILU(T) + call psb_bcast(ictxt,prectype%cjswp) ! Jacobi sweeps + if (iam == psb_root_) then write(psb_out_unit,'("Solving matrix : ell1")') diff --git a/tests/pdegen/ppde3d-gs.f90 b/tests/pdegen/ppde3d-gs.f90 deleted file mode 100644 index f7edf8d9..00000000 --- a/tests/pdegen/ppde3d-gs.f90 +++ /dev/null @@ -1,497 +0,0 @@ -!!$ -!!$ -!!$ MLD2P4 version 2.0 -!!$ MultiLevel Domain Decomposition Parallel Preconditioners Package -!!$ based on PSBLAS (Parallel Sparse BLAS version 3.3) -!!$ -!!$ (C) Copyright 2008, 2010, 2012, 2015 -!!$ -!!$ Salvatore Filippone University of Rome Tor Vergata -!!$ Alfredo Buttari CNRS-IRIT, Toulouse -!!$ Pasqua D'Ambra ICAR-CNR, Naples -!!$ Daniela di Serafino Second University of Naples -!!$ -!!$ Redistribution and use in source and binary forms, with or without -!!$ modification, are permitted provided that the following conditions -!!$ are met: -!!$ 1. Redistributions of source code must retain the above copyright -!!$ notice, this list of conditions and the following disclaimer. -!!$ 2. Redistributions in binary form must reproduce the above copyright -!!$ notice, this list of conditions, and the following disclaimer in the -!!$ documentation and/or other materials provided with the distribution. -!!$ 3. The name of the MLD2P4 group or the names of its contributors may -!!$ not be used to endorse or promote products derived from this -!!$ software without specific written permission. -!!$ -!!$ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -!!$ ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -!!$ TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -!!$ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE MLD2P4 GROUP OR ITS CONTRIBUTORS -!!$ BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -!!$ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -!!$ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -!!$ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -!!$ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -!!$ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -!!$ POSSIBILITY OF SUCH DAMAGE. -!!$ -!!$ -! -! File: ppde3d.f90 -! -! Program: ppde3d -! This sample program solves a linear system obtained by discretizing a -! PDE with Dirichlet BCs. -! -! -! The PDE is a general second order equation in 3d -! -! a1 dd(u) a2 dd(u) a3 dd(u) b1 d(u) b2 d(u) b3 d(u) -! - ------ - ------ - ------ + ----- + ------ + ------ + c u = f -! dxdx dydy dzdz dx dy dz -! -! with Dirichlet boundary conditions -! u = g -! -! on the unit cube 0<=x,y,z<=1. -! -! -! Note that if b1=b2=b3=c=0., the PDE is the Laplace equation. -! -! In this sample program the index space of the discretized -! computational domain is first numbered sequentially in a standard way, -! then the corresponding vector is distributed according to a BLOCK -! data distribution. -! -module ppde3d_mod -contains - ! - ! functions parametrizing the differential equation - ! - function b1(x,y,z) - use psb_base_mod, only : psb_dpk_ - real(psb_dpk_) :: b1 - real(psb_dpk_), intent(in) :: x,y,z - b1=0.d0/sqrt(3.d0) - end function b1 - function b2(x,y,z) - use psb_base_mod, only : psb_dpk_ - real(psb_dpk_) :: b2 - real(psb_dpk_), intent(in) :: x,y,z - b2=0.d0/sqrt(3.d0) - end function b2 - function b3(x,y,z) - use psb_base_mod, only : psb_dpk_ - real(psb_dpk_) :: b3 - real(psb_dpk_), intent(in) :: x,y,z - b3=0.d0/sqrt(3.d0) - end function b3 - function c(x,y,z) - use psb_base_mod, only : psb_dpk_ - real(psb_dpk_) :: c - real(psb_dpk_), intent(in) :: x,y,z - c=0.d0 - end function c - function a1(x,y,z) - use psb_base_mod, only : psb_dpk_ - real(psb_dpk_) :: a1 - real(psb_dpk_), intent(in) :: x,y,z - a1=1.d0!/80 - end function a1 - function a2(x,y,z) - use psb_base_mod, only : psb_dpk_ - real(psb_dpk_) :: a2 - real(psb_dpk_), intent(in) :: x,y,z - a2=1.d0!/80 - end function a2 - function a3(x,y,z) - use psb_base_mod, only : psb_dpk_ - real(psb_dpk_) :: a3 - real(psb_dpk_), intent(in) :: x,y,z - a3=1.d0!/80 - end function a3 - function g(x,y,z) - use psb_base_mod, only : psb_dpk_, done, dzero - real(psb_dpk_) :: g - real(psb_dpk_), intent(in) :: x,y,z - g = dzero - if (x == done) then - g = done - else if (x == dzero) then - g = exp(y**2-z**2) - end if - end function g -end module ppde3d_mod - -program ppde3d - use psb_base_mod - use mld_prec_mod - use psb_krylov_mod - use psb_util_mod - use data_input - use ppde3d_mod - implicit none - - ! input parameters - character(len=20) :: kmethd, ptype - character(len=5) :: afmt - integer(psb_ipk_) :: idim - - ! miscellaneous - real(psb_dpk_), parameter :: one = 1.d0 - real(psb_dpk_) :: t1, t2, tprec - - ! sparse matrix and preconditioner - type(psb_dspmat_type) :: a - type(mld_dprec_type) :: prec - ! descriptor - type(psb_desc_type) :: desc_a - ! dense vectors - type(psb_d_vect_type) :: x,b - ! parallel environment - integer(psb_ipk_) :: ictxt, iam, np - - ! solver parameters - integer(psb_ipk_) :: iter, itmax,itrace, istopc, irst, nlv - integer(psb_long_int_k_) :: amatsize, precsize, descsize - real(psb_dpk_) :: err, eps - - type precdata - character(len=20) :: descr ! verbose description of the prec - character(len=10) :: prec ! overall prectype - integer(psb_ipk_) :: novr ! number of overlap layers - integer(psb_ipk_) :: jsweeps ! Jacobi/smoother sweeps - character(len=16) :: restr ! restriction over application of as - character(len=16) :: prol ! prolongation over application of as - character(len=16) :: solve ! Solver type: ILU, SuperLU, UMFPACK. - integer(psb_ipk_) :: fill1 ! Fill-in for factorization 1 - integer(psb_ipk_) :: svsweeps ! Solver sweeps for GS - real(psb_dpk_) :: thr1 ! Threshold for fact. 1 ILU(T) - character(len=16) :: smther ! Smoother - integer(psb_ipk_) :: nlev ! Number of levels in multilevel prec. - character(len=16) :: aggrkind ! smoothed/raw aggregatin - character(len=16) :: aggr_alg ! local or global aggregation - character(len=16) :: aggr_ord ! Ordering for aggregation - character(len=16) :: mltype ! additive or multiplicative 2nd level prec - character(len=16) :: smthpos ! side: pre, post, both smoothing - integer(psb_ipk_) :: csize ! aggregation size at which to stop. - character(len=16) :: cmat ! coarse mat - character(len=16) :: csolve ! Coarse solver: bjac, umf, slu, sludist - character(len=16) :: csbsolve ! Coarse subsolver: ILU, ILU(T), SuperLU, UMFPACK. - integer(psb_ipk_) :: cfill ! Fill-in for factorization 1 - real(psb_dpk_) :: cthres ! Threshold for fact. 1 ILU(T) - integer(psb_ipk_) :: cjswp ! Jacobi sweeps - real(psb_dpk_) :: athres ! smoother aggregation threshold - end type precdata - type(precdata) :: prectype - type(psb_d_coo_sparse_mat) :: acoo - type(mld_d_jac_smoother_type) :: dbsmth - type(mld_d_bwgs_solver_type) :: dbwgs - ! other variables - integer(psb_ipk_) :: info, i - character(len=20) :: name,ch_err - - info=psb_success_ - - - call psb_init(ictxt) - call psb_info(ictxt,iam,np) - - if (iam < 0) then - ! This should not happen, but just in case - call psb_exit(ictxt) - stop - endif - if(psb_get_errstatus() /= 0) goto 9999 - name='pde90' - call psb_set_errverbosity(itwo) - ! - ! Hello world - ! - if (iam == psb_root_) then - write(*,*) 'Welcome to MLD2P4 version: ',mld_version_string_ - write(*,*) 'This is the ',trim(name),' sample program' - end if - - ! - ! get parameters - ! - call get_parms(ictxt,kmethd,prectype,afmt,idim,istopc,itmax,itrace,irst,eps) - - ! - ! allocate and fill in the coefficient matrix, rhs and initial guess - ! - - call psb_barrier(ictxt) - t1 = psb_wtime() - call psb_gen_pde3d(ictxt,idim,a,b,x,desc_a,afmt,& - & a1,a2,a3,b1,b2,b3,c,g,info) - call psb_barrier(ictxt) - t2 = psb_wtime() - t1 - if(info /= psb_success_) then - info=psb_err_from_subroutine_ - ch_err='create_matrix' - call psb_errpush(info,name,a_err=ch_err) - goto 9999 - end if - - if (iam == psb_root_) & - & write(psb_out_unit,'("Overall matrix creation time : ",es12.5)')t2 - if (iam == psb_root_) & - & write(psb_out_unit,'(" ")') - ! - ! prepare the preconditioner. - ! - if (psb_toupper(prectype%prec) == 'ML') then - nlv = prectype%nlev - call mld_precinit(prec,prectype%prec, info, nlev=nlv) - call mld_precset(prec,'smoother_type', prectype%smther, info) - call mld_precset(prec,'smoother_sweeps', prectype%jsweeps, info) - call mld_precset(prec,'sub_ovr', prectype%novr, info) - call mld_precset(prec,'sub_restr', prectype%restr, info) - call mld_precset(prec,'sub_prol', prectype%prol, info) - call mld_precset(prec,'sub_solve', prectype%solve, info) - call mld_precset(prec,'sub_fillin', prectype%fill1, info) - call mld_precset(prec,'solver_sweeps', prectype%svsweeps, info) - call mld_precset(prec,'sub_iluthrs', prectype%thr1, info) - call mld_precset(prec,'aggr_kind', prectype%aggrkind,info) - call mld_precset(prec,'aggr_alg', prectype%aggr_alg,info) - call mld_precset(prec,'aggr_ord', prectype%aggr_ord,info) - call mld_precset(prec,'ml_type', prectype%mltype, info) - call mld_precset(prec,'smoother_pos', prectype%smthpos, info) - if (prectype%athres >= dzero) & - & call mld_precset(prec,'aggr_thresh', prectype%athres, info) - call mld_precset(prec,'coarse_solve', prectype%csolve, info) - call mld_precset(prec,'coarse_subsolve', prectype%csbsolve,info) - call mld_precset(prec,'coarse_mat', prectype%cmat, info) - call mld_precset(prec,'coarse_fillin', prectype%cfill, info) - call mld_precset(prec,'coarse_iluthrs', prectype%cthres, info) - call mld_precset(prec,'coarse_sweeps', prectype%cjswp, info) - call mld_precset(prec,'coarse_aggr_size', prectype%csize, info) - call prec%set(dbsmth,info,pos='post') - call prec%set(dbwgs,info,pos='post') - call mld_precset(prec,'solver_sweeps', prectype%svsweeps, info, pos='post') - else - nlv = 1 - call mld_precinit(prec,prectype%prec, info, nlev=nlv) - call mld_precset(prec,'smoother_sweeps', prectype%jsweeps, info) - call mld_precset(prec,'sub_ovr', prectype%novr, info) - call mld_precset(prec,'sub_restr', prectype%restr, info) - call mld_precset(prec,'sub_prol', prectype%prol, info) - call mld_precset(prec,'sub_solve', prectype%solve, info) - call mld_precset(prec,'sub_fillin', prectype%fill1, info) - call mld_precset(prec,'solver_sweeps', prectype%svsweeps, info) - call mld_precset(prec,'sub_iluthrs', prectype%thr1, info) - call prec%set(dbsmth,info,pos='post') - call prec%set(dbwgs,info,pos='post') - call mld_precset(prec,'solver_sweeps', prectype%svsweeps, info, pos='post') - end if - - call psb_barrier(ictxt) - t1 = psb_wtime() - call mld_precbld(a,desc_a,prec,info) - if(info /= psb_success_) then - info=psb_err_from_subroutine_ - ch_err='psb_precbld' - call psb_errpush(info,name,a_err=ch_err) - goto 9999 - end if - - tprec = psb_wtime()-t1 -!!$ call prec%dump(info,prefix='test-ml',ac=.true.,solver=.true.,smoother=.true.) - - call psb_amx(ictxt,tprec) - - if (iam == psb_root_) & - & write(psb_out_unit,'("Preconditioner time : ",es12.5)')tprec - if (iam == psb_root_) call mld_precdescr(prec,info) - if (iam == psb_root_) & - & write(psb_out_unit,'(" ")') - - ! - ! iterative method parameters - ! - if(iam == psb_root_) & - & write(psb_out_unit,'("Calling iterative method ",a)')kmethd - call psb_barrier(ictxt) - t1 = psb_wtime() - call psb_krylov(kmethd,a,prec,b,x,eps,desc_a,info,& - & itmax=itmax,iter=iter,err=err,itrace=itrace,istop=istopc,irst=irst) - - if(info /= psb_success_) then - info=psb_err_from_subroutine_ - ch_err='solver routine' - call psb_errpush(info,name,a_err=ch_err) - goto 9999 - end if - - call psb_barrier(ictxt) - t2 = psb_wtime() - t1 - call psb_amx(ictxt,t2) - - amatsize = a%sizeof() - descsize = desc_a%sizeof() - precsize = prec%sizeof() - call psb_sum(ictxt,amatsize) - call psb_sum(ictxt,descsize) - call psb_sum(ictxt,precsize) - if (iam == psb_root_) then - write(psb_out_unit,'(" ")') - write(psb_out_unit,'("Time to solve matrix : ",es12.5)') t2 - write(psb_out_unit,'("Time per iteration : ",es12.5)') t2/iter - write(psb_out_unit,'("Number of iterations : ",i0)') iter - write(psb_out_unit,'("Convergence indicator on exit : ",es12.5)') err - write(psb_out_unit,'("Info on exit : ",i0)') info - write(psb_out_unit,'("Total memory occupation for A: ",i12)') amatsize - write(psb_out_unit,'("Total memory occupation for DESC_A: ",i12)') descsize - write(psb_out_unit,'("Total memory occupation for PREC: ",i12)') precsize - end if - - ! - ! cleanup storage and exit - ! - call psb_gefree(b,desc_a,info) - call psb_gefree(x,desc_a,info) - call psb_spfree(a,desc_a,info) - call mld_precfree(prec,info) - call psb_cdfree(desc_a,info) - if(info /= psb_success_) then - info=psb_err_from_subroutine_ - ch_err='free routine' - call psb_errpush(info,name,a_err=ch_err) - goto 9999 - end if - call psb_exit(ictxt) - stop - -9999 continue - call psb_error(ictxt) - -contains - ! - ! get iteration parameters from standard input - ! - subroutine get_parms(ictxt,kmethd,prectype,afmt,idim,istopc,itmax,itrace,irst,eps) - integer(psb_ipk_) :: ictxt - type(precdata) :: prectype - character(len=*) :: kmethd, afmt - integer(psb_ipk_) :: idim, istopc,itmax,itrace,irst - integer(psb_ipk_) :: np, iam, info - real(psb_dpk_) :: eps - character(len=20) :: buffer - - call psb_info(ictxt, iam, np) - - if (iam == psb_root_) then - call read_data(kmethd,psb_inp_unit) - call read_data(afmt,psb_inp_unit) - call read_data(idim,psb_inp_unit) - call read_data(istopc,psb_inp_unit) - call read_data(itmax,psb_inp_unit) - call read_data(itrace,psb_inp_unit) - call read_data(irst,psb_inp_unit) - call read_data(eps,psb_inp_unit) - call read_data(prectype%descr,psb_inp_unit) ! verbose description of the prec - call read_data(prectype%prec,psb_inp_unit) ! overall prectype - call read_data(prectype%novr,psb_inp_unit) ! number of overlap layers - call read_data(prectype%restr,psb_inp_unit) ! restriction over application of as - call read_data(prectype%prol,psb_inp_unit) ! prolongation over application of as - call read_data(prectype%solve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%svsweeps,psb_inp_unit) ! Solver sweeps - call read_data(prectype%fill1,psb_inp_unit) ! Fill-in for factorization 1 - call read_data(prectype%thr1,psb_inp_unit) ! Threshold for fact. 1 ILU(T) - call read_data(prectype%jsweeps,psb_inp_unit) ! Jacobi sweeps for PJAC - if (psb_toupper(prectype%prec) == 'ML') then - call read_data(prectype%smther,psb_inp_unit) ! Smoother type. - call read_data(prectype%nlev,psb_inp_unit) ! Number of levels in multilevel prec. - call read_data(prectype%aggrkind,psb_inp_unit) ! smoothed/raw aggregatin - call read_data(prectype%aggr_alg,psb_inp_unit) ! local or global aggregation - call read_data(prectype%aggr_ord,psb_inp_unit) ! aggregation ordering - call read_data(prectype%mltype,psb_inp_unit) ! additive or multiplicative 2nd level prec - call read_data(prectype%smthpos,psb_inp_unit) ! side: pre, post, both smoothing - call read_data(prectype%cmat,psb_inp_unit) ! coarse mat - call read_data(prectype%csolve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%csbsolve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%cfill,psb_inp_unit) ! Fill-in for factorization 1 - call read_data(prectype%cthres,psb_inp_unit) ! Threshold for fact. 1 ILU(T) - call read_data(prectype%cjswp,psb_inp_unit) ! Jacobi sweeps - call read_data(prectype%athres,psb_inp_unit) ! smoother aggr thresh - call read_data(prectype%csize,psb_inp_unit) ! coarse size - end if - end if - - ! broadcast parameters to all processors - call psb_bcast(ictxt,kmethd) - call psb_bcast(ictxt,afmt) - call psb_bcast(ictxt,idim) - call psb_bcast(ictxt,istopc) - call psb_bcast(ictxt,itmax) - call psb_bcast(ictxt,itrace) - call psb_bcast(ictxt,irst) - call psb_bcast(ictxt,eps) - - - call psb_bcast(ictxt,prectype%descr) ! verbose description of the prec - call psb_bcast(ictxt,prectype%prec) ! overall prectype - call psb_bcast(ictxt,prectype%novr) ! number of overlap layers - call psb_bcast(ictxt,prectype%restr) ! restriction over application of as - call psb_bcast(ictxt,prectype%prol) ! prolongation over application of as - call psb_bcast(ictxt,prectype%solve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%svsweeps) ! Sweeps for inner GS solver - call psb_bcast(ictxt,prectype%fill1) ! Fill-in for factorization 1 - call psb_bcast(ictxt,prectype%thr1) ! Threshold for fact. 1 ILU(T) - call psb_bcast(ictxt,prectype%jsweeps) ! Jacobi sweeps - if (psb_toupper(prectype%prec) == 'ML') then - call psb_bcast(ictxt,prectype%smther) ! Smoother type. - call psb_bcast(ictxt,prectype%nlev) ! Number of levels in multilevel prec. - call psb_bcast(ictxt,prectype%aggrkind) ! smoothed/raw aggregatin - call psb_bcast(ictxt,prectype%aggr_alg) ! local or global aggregation - call psb_bcast(ictxt,prectype%aggr_ord) ! aggregation ordering - call psb_bcast(ictxt,prectype%mltype) ! additive or multiplicative 2nd level prec - call psb_bcast(ictxt,prectype%smthpos) ! side: pre, post, both smoothing - call psb_bcast(ictxt,prectype%cmat) ! coarse mat - call psb_bcast(ictxt,prectype%csolve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%csbsolve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%cfill) ! Fill-in for factorization 1 - call psb_bcast(ictxt,prectype%cthres) ! Threshold for fact. 1 ILU(T) - call psb_bcast(ictxt,prectype%cjswp) ! Jacobi sweeps - call psb_bcast(ictxt,prectype%athres) ! smoother aggr thresh - call psb_bcast(ictxt,prectype%csize) ! coarse size - end if - - if (iam == psb_root_) then - write(psb_out_unit,'("Solving matrix : ell1")') - write(psb_out_unit,'("Grid dimensions : ",i4,"x",i4,"x",i4)')idim,idim,idim - write(psb_out_unit,'("Number of processors : ",i0)') np - write(psb_out_unit,'("Data distribution : BLOCK")') - write(psb_out_unit,'("Preconditioner : ",a)') prectype%descr - write(psb_out_unit,'("Iterative method : ",a)') kmethd - write(psb_out_unit,'(" ")') - endif - - return - - end subroutine get_parms - ! - ! print an error message - ! - subroutine pr_usage(iout) - integer(psb_ipk_) :: iout - write(iout,*)'incorrect parameter(s) found' - write(iout,*)' usage: pde90 methd prec dim & - &[istop itmax itrace]' - write(iout,*)' where:' - write(iout,*)' methd: cgstab cgs rgmres bicgstabl' - write(iout,*)' prec : bjac diag none' - write(iout,*)' dim number of points along each axis' - write(iout,*)' the size of the resulting linear ' - write(iout,*)' system is dim**3' - write(iout,*)' istop stopping criterion 1, 2 ' - write(iout,*)' itmax maximum number of iterations [500] ' - write(iout,*)' itrace <=0 (no tracing, default) or ' - write(iout,*)' >= 1 do tracing every itrace' - write(iout,*)' iterations ' - end subroutine pr_usage - -end program ppde3d - diff --git a/tests/pdegen/ppde3d.f90 b/tests/pdegen/ppde3d.f90 index 5f2c2b63..da30dc3c 100644 --- a/tests/pdegen/ppde3d.f90 +++ b/tests/pdegen/ppde3d.f90 @@ -168,7 +168,8 @@ program ppde3d integer(psb_ipk_) :: svsweeps ! Solver sweeps for GS real(psb_dpk_) :: thr1 ! Threshold for fact. 1 ILU(T) character(len=16) :: smther ! Smoother - integer(psb_ipk_) :: nlev ! Number of levels in multilevel prec. + integer(psb_ipk_) :: nlevs ! Number of levels in multilevel prec. + integer(psb_ipk_) :: maxlevs ! Maximum number of levels in multilevel prec. character(len=16) :: aggrkind ! smoothed/raw aggregatin character(len=16) :: aggr_alg ! local or global aggregation character(len=16) :: aggr_ord ! Ordering for aggregation @@ -182,6 +183,7 @@ program ppde3d real(psb_dpk_) :: cthres ! Threshold for fact. 1 ILU(T) integer(psb_ipk_) :: cjswp ! Jacobi sweeps real(psb_dpk_) :: athres ! smoother aggregation threshold + real(psb_dpk_) :: mnaggratio ! Minimum aggregation ratio end type precdata type(precdata) :: prectype type(psb_d_coo_sparse_mat) :: acoo @@ -242,8 +244,19 @@ program ppde3d ! if (psb_toupper(prectype%prec) == 'ML') then call mld_precinit(prec,prectype%prec, info) - if (prectype%nlev > 0) & - & call mld_precset(prec,'n_prec_levs', prectype%nlev, info) + if (prectype%nlevs > 0) then + ! Force number of levels, so disregard the other related arguments. + call mld_precset(prec,'n_prec_levs', prectype%nlevs, info) + else + if (prectype%csize>0)& + & call mld_precset(prec,'coarse_aggr_size', prectype%csize, info) + if (prectype%maxlevs>0)& + & call mld_precset(prec,'max_prec_levs', prectype%maxlevs, info) + if (prectype%mnaggratio>0)& + & call mld_precset(prec,'min_aggr_ratio', prectype%mnaggratio, info) + end if + if (prectype%athres >= dzero) & + & call mld_precset(prec,'aggr_thresh', prectype%athres, info) call mld_precset(prec,'smoother_type', prectype%smther, info) call mld_precset(prec,'smoother_sweeps', prectype%jsweeps, info) call mld_precset(prec,'sub_ovr', prectype%novr, info) @@ -258,18 +271,15 @@ program ppde3d call mld_precset(prec,'aggr_ord', prectype%aggr_ord,info) call mld_precset(prec,'ml_type', prectype%mltype, info) call mld_precset(prec,'smoother_pos', prectype%smthpos, info) - if (prectype%athres >= dzero) & - & call mld_precset(prec,'aggr_thresh', prectype%athres, info) call mld_precset(prec,'coarse_solve', prectype%csolve, info) call mld_precset(prec,'coarse_subsolve', prectype%csbsolve,info) call mld_precset(prec,'coarse_mat', prectype%cmat, info) call mld_precset(prec,'coarse_fillin', prectype%cfill, info) call mld_precset(prec,'coarse_iluthrs', prectype%cthres, info) call mld_precset(prec,'coarse_sweeps', prectype%cjswp, info) - if (prectype%csize>0) call mld_precset(prec,'coarse_aggr_size', prectype%csize, info) else nlv = 1 - call mld_precinit(prec,prectype%prec, info, nlev=nlv) + call mld_precinit(prec,prectype%prec, info) call mld_precset(prec,'smoother_sweeps', prectype%jsweeps, info) call mld_precset(prec,'sub_ovr', prectype%novr, info) call mld_precset(prec,'sub_restr', prectype%restr, info) @@ -278,7 +288,7 @@ program ppde3d call mld_precset(prec,'sub_fillin', prectype%fill1, info) call mld_precset(prec,'solver_sweeps', prectype%svsweeps, info) call mld_precset(prec,'sub_iluthrs', prectype%thr1, info) - end if + end if call psb_barrier(ictxt) t1 = psb_wtime() @@ -386,31 +396,31 @@ contains call read_data(eps,psb_inp_unit) call read_data(prectype%descr,psb_inp_unit) ! verbose description of the prec call read_data(prectype%prec,psb_inp_unit) ! overall prectype + call read_data(prectype%nlevs,psb_inp_unit) ! Prescribed number of levels + call read_data(prectype%csize,psb_inp_unit) ! coarse size + call read_data(prectype%mnaggratio,psb_inp_unit) ! Minimum aggregation ratio + call read_data(prectype%athres,psb_inp_unit) ! smoother aggr thresh + call read_data(prectype%maxlevs,psb_inp_unit) ! Maximum number of levels + call read_data(prectype%aggrkind,psb_inp_unit) ! smoothed/nonsmoothed/minenergy aggregatin + call read_data(prectype%aggr_alg,psb_inp_unit) ! decoupled or sym. decoupled aggregation + call read_data(prectype%aggr_ord,psb_inp_unit) ! aggregation ordering: natural, node degree + call read_data(prectype%mltype,psb_inp_unit) ! additive or multiplicative 2nd level prec + call read_data(prectype%smthpos,psb_inp_unit) ! side: pre, post, both smoothing + call read_data(prectype%jsweeps,psb_inp_unit) ! Smoother sweeps + call read_data(prectype%smther,psb_inp_unit) ! Smoother type. call read_data(prectype%novr,psb_inp_unit) ! number of overlap layers call read_data(prectype%restr,psb_inp_unit) ! restriction over application of as call read_data(prectype%prol,psb_inp_unit) ! prolongation over application of as - call read_data(prectype%solve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%svsweeps,psb_inp_unit) ! Solver sweeps + call read_data(prectype%solve,psb_inp_unit) ! Subdomain solver: DSCALE ILU MILU ILUT FWGS BWGS MUMPS UMF SLU + call read_data(prectype%svsweeps,psb_inp_unit) ! Solver sweeps (GS) call read_data(prectype%fill1,psb_inp_unit) ! Fill-in for factorization 1 call read_data(prectype%thr1,psb_inp_unit) ! Threshold for fact. 1 ILU(T) - call read_data(prectype%jsweeps,psb_inp_unit) ! Jacobi sweeps for PJAC - if (psb_toupper(prectype%prec) == 'ML') then - call read_data(prectype%smther,psb_inp_unit) ! Smoother type. - call read_data(prectype%nlev,psb_inp_unit) ! Number of levels in multilevel prec. - call read_data(prectype%aggrkind,psb_inp_unit) ! smoothed/raw aggregatin - call read_data(prectype%aggr_alg,psb_inp_unit) ! local or global aggregation - call read_data(prectype%aggr_ord,psb_inp_unit) ! aggregation ordering - call read_data(prectype%mltype,psb_inp_unit) ! additive or multiplicative 2nd level prec - call read_data(prectype%smthpos,psb_inp_unit) ! side: pre, post, both smoothing - call read_data(prectype%cmat,psb_inp_unit) ! coarse mat - call read_data(prectype%csolve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%csbsolve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%cfill,psb_inp_unit) ! Fill-in for factorization 1 - call read_data(prectype%cthres,psb_inp_unit) ! Threshold for fact. 1 ILU(T) - call read_data(prectype%cjswp,psb_inp_unit) ! Jacobi sweeps - call read_data(prectype%athres,psb_inp_unit) ! smoother aggr thresh - call read_data(prectype%csize,psb_inp_unit) ! coarse size - end if + call read_data(prectype%cmat,psb_inp_unit) ! coarse mat + call read_data(prectype%csolve,psb_inp_unit) ! Coarse solver: JACOBI BJAC UMF SLU SLUDIST MUMPS + call read_data(prectype%csbsolve,psb_inp_unit) ! subsolver: DSCALE GS BWGS ILU UMF SLU SLUDIST MUMPS + call read_data(prectype%cfill,psb_inp_unit) ! Fill-in for factorization 1 + call read_data(prectype%cthres,psb_inp_unit) ! Threshold for fact. 1 ILU(T) + call read_data(prectype%cjswp,psb_inp_unit) ! Jacobi sweeps end if ! broadcast parameters to all processors @@ -422,35 +432,34 @@ contains call psb_bcast(ictxt,itrace) call psb_bcast(ictxt,irst) call psb_bcast(ictxt,eps) - - call psb_bcast(ictxt,prectype%descr) ! verbose description of the prec call psb_bcast(ictxt,prectype%prec) ! overall prectype + call psb_bcast(ictxt,prectype%nlevs) ! Prescribed number of levels + call psb_bcast(ictxt,prectype%csize) ! coarse size + call psb_bcast(ictxt,prectype%mnaggratio) ! Minimum aggregation ratio + call psb_bcast(ictxt,prectype%athres) ! smoother aggr thresh + call psb_bcast(ictxt,prectype%maxlevs) ! Maximum number of levels + call psb_bcast(ictxt,prectype%aggrkind) ! smoothed/nonsmoothed/minenergy aggregatin + call psb_bcast(ictxt,prectype%aggr_alg) ! decoupled or sym. decoupled aggregation + call psb_bcast(ictxt,prectype%aggr_ord) ! aggregation ordering: natural, node degree + call psb_bcast(ictxt,prectype%mltype) ! additive or multiplicative 2nd level prec + call psb_bcast(ictxt,prectype%smthpos) ! side: pre, post, both smoothing + call psb_bcast(ictxt,prectype%jsweeps) ! Smoother sweeps + call psb_bcast(ictxt,prectype%smther) ! Smoother type. call psb_bcast(ictxt,prectype%novr) ! number of overlap layers call psb_bcast(ictxt,prectype%restr) ! restriction over application of as call psb_bcast(ictxt,prectype%prol) ! prolongation over application of as - call psb_bcast(ictxt,prectype%solve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%svsweeps) ! Sweeps for inner GS solver + call psb_bcast(ictxt,prectype%solve) ! Subdomain solver: DSCALE ILU MILU ILUT FWGS BWGS MUMPS UMF SLU + call psb_bcast(ictxt,prectype%svsweeps) ! Solver sweeps (GS) call psb_bcast(ictxt,prectype%fill1) ! Fill-in for factorization 1 call psb_bcast(ictxt,prectype%thr1) ! Threshold for fact. 1 ILU(T) - call psb_bcast(ictxt,prectype%jsweeps) ! Jacobi sweeps - if (psb_toupper(prectype%prec) == 'ML') then - call psb_bcast(ictxt,prectype%smther) ! Smoother type. - call psb_bcast(ictxt,prectype%nlev) ! Number of levels in multilevel prec. - call psb_bcast(ictxt,prectype%aggrkind) ! smoothed/raw aggregatin - call psb_bcast(ictxt,prectype%aggr_alg) ! local or global aggregation - call psb_bcast(ictxt,prectype%aggr_ord) ! aggregation ordering - call psb_bcast(ictxt,prectype%mltype) ! additive or multiplicative 2nd level prec - call psb_bcast(ictxt,prectype%smthpos) ! side: pre, post, both smoothing - call psb_bcast(ictxt,prectype%cmat) ! coarse mat - call psb_bcast(ictxt,prectype%csolve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%csbsolve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%cfill) ! Fill-in for factorization 1 - call psb_bcast(ictxt,prectype%cthres) ! Threshold for fact. 1 ILU(T) - call psb_bcast(ictxt,prectype%cjswp) ! Jacobi sweeps - call psb_bcast(ictxt,prectype%athres) ! smoother aggr thresh - call psb_bcast(ictxt,prectype%csize) ! coarse size - end if + call psb_bcast(ictxt,prectype%cmat) ! coarse mat + call psb_bcast(ictxt,prectype%csolve) ! Coarse solver: JACOBI BJAC UMF SLU SLUDIST MUMPS + call psb_bcast(ictxt,prectype%csbsolve) ! subsolver: DSCALE GS BWGS ILU UMF SLU SLUDIST MUMPS + call psb_bcast(ictxt,prectype%cfill) ! Fill-in for factorization 1 + call psb_bcast(ictxt,prectype%cthres) ! Threshold for fact. 1 ILU(T) + call psb_bcast(ictxt,prectype%cjswp) ! Jacobi sweeps + if (iam == psb_root_) then write(psb_out_unit,'("Solving matrix : ell1")') diff --git a/tests/pdegen/runs/ppde.inp b/tests/pdegen/runs/ppde.inp index 04c345e9..99fa7a98 100644 --- a/tests/pdegen/runs/ppde.inp +++ b/tests/pdegen/runs/ppde.inp @@ -1,33 +1,35 @@ -CGR ! Iterative method: BiCGSTAB BiCG CGS RGMRES BiCGSTABL CG +CGR ! Iterative method: BiCGSTAB BiCG CGS RGMRES BiCGSTABL CG CSR ! Storage format CSR COO JAD -0030 ! IDIM; domain size is idim**3 +0080 ! IDIM; domain size is idim**3 2 ! ISTOPC 2000 ! ITMAX 10 ! ITRACE 30 ! IRST (restart for RGMRES and BiCGSTABL) 1.d-6 ! EPS -3L-MUL-RAS-ILU ! Descriptive name for preconditioner (up to 40 chars) +ML-MUL-RAS-ILU ! Descriptive name for preconditioner (up to 40 chars) ML ! Preconditioner NONE JACOBI BJAC AS ML -0 ! Number of overlap layers for AS preconditioner at finest level -HALO ! Restriction operator NONE HALO -NONE ! Prolongation operator NONE SUM AVG -GS ! Subdomain solver DSCALE ILU MILU ILUT UMF SLU GS BWGS MUMPS +-1 ! If ML: Prescribed number of levels; if <0, ignore it and use coarse size. +-010 ! If ML: Target coarse size. If <0, then use library default +-1.5d0 ! If ML: Minimum aggregation ratio; if <0 use library default +-0.10d0 ! If ML: Smoother Aggregation Threshold: >= 0.0 default if <0 +-20 ! If ML: Maximum acceptable number of levels; if <0 use library default +SMOOTHED ! Type of aggregation: SMOOTHED, NONSMOOTHED, MINENERGY +SYMDEC ! Type of aggregation: DEC SYMDEC +NATURAL ! Ordering of aggregation: NATURAL DEGREE +KCYCLE ! Type of multilevel correction: ADD MULT KCYCLE VCYCLE WCYCLE KCYCLESYM +TWOSIDE ! Side of correction: PRE POST TWOSIDE (ignored for ADD) +4 ! Smoother sweeps +BJAC ! Smoother type JACOBI BJAC AS; ignored for non-ML +0 ! Number of overlap layers for AS preconditioner (at finest level) +HALO ! AS Restriction operator NONE HALO +NONE ! AS Prolongation operator NONE SUM AVG +GS ! Subdomain solver DSCALE ILU MILU ILUT FWGS BWGS MUMPS UMF SLU 4 ! Solver sweeps for GS 0 ! Level-set N for ILU(N), and P for ILUT 1.d-4 ! Threshold T for ILU(T,P) -4 ! Smoother/Jacobi sweeps -BJAC ! Smoother type JACOBI BJAC AS; ignored for non-ML --1 ! Number of levels in a multilevel preconditioner; if <0, lib default. -SMOOTHED ! Kind of aggregation: SMOOTHED, NONSMOOTHED, MINENERGY -SYMDEC ! Type of aggregation DEC SYMDEC -NATURAL ! Ordering of aggregation NATURAL DEGREE -KCYCLE ! Type of multilevel correction: ADD MULT KCYCLE VCYCLE WCYCLE KCYCLESYM -TWOSIDE ! Side of correction PRE POST TWOSIDE (ignored for ADD) DIST ! Coarse level: matrix distribution DIST REPL BJAC ! Coarse level: solver JACOBI BJAC UMF SLU SLUDIST MUMPS ILU ! Coarse level: subsolver DSCALE GS BWGS ILU UMF SLU SLUDIST MUMPS 1 ! Coarse level: Level-set N for ILU(N) 1.d-4 ! Coarse level: Threshold T for ILU(T,P) 4 ! Coarse level: Number of Jacobi sweeps --0.10d0 ! Smoother Aggregation Threshold: >= 0.0 default if <0 --010 ! Coarse size limit to determine levels. If <0, then use NL diff --git a/tests/pdegen/spde2d.f90 b/tests/pdegen/spde2d.f90 index 3513aa2e..e3166b9c 100644 --- a/tests/pdegen/spde2d.f90 +++ b/tests/pdegen/spde2d.f90 @@ -156,7 +156,8 @@ program spde2d integer(psb_ipk_) :: svsweeps ! Solver sweeps for GS real(psb_spk_) :: thr1 ! Threshold for fact. 1 ILU(T) character(len=16) :: smther ! Smoother - integer(psb_ipk_) :: nlev ! Number of levels in multilevel prec. + integer(psb_ipk_) :: nlevs ! Number of levels in multilevel prec. + integer(psb_ipk_) :: maxlevs ! Maximum number of levels in multilevel prec. character(len=16) :: aggrkind ! smoothed/raw aggregatin character(len=16) :: aggr_alg ! local or global aggregation character(len=16) :: aggr_ord ! Ordering for aggregation @@ -170,6 +171,7 @@ program spde2d real(psb_spk_) :: cthres ! Threshold for fact. 1 ILU(T) integer(psb_ipk_) :: cjswp ! Jacobi sweeps real(psb_spk_) :: athres ! smoother aggregation threshold + real(psb_spk_) :: mnaggratio ! Minimum aggregation ratio end type precdata type(precdata) :: prectype type(psb_s_coo_sparse_mat) :: acoo @@ -230,8 +232,19 @@ program spde2d if (psb_toupper(prectype%prec) == 'ML') then call mld_precinit(prec,prectype%prec, info) - if (prectype%nlev > 0) & - & call mld_precset(prec,'n_prec_levs', prectype%nlev, info) + if (prectype%nlevs > 0) then + ! Force number of levels, so disregard the other related arguments. + call mld_precset(prec,'n_prec_levs', prectype%nlevs, info) + else + if (prectype%csize>0)& + & call mld_precset(prec,'coarse_aggr_size', prectype%csize, info) + if (prectype%maxlevs>0)& + & call mld_precset(prec,'max_prec_levs', prectype%maxlevs, info) + if (prectype%mnaggratio>0)& + & call mld_precset(prec,'min_aggr_ratio', prectype%mnaggratio, info) + end if + if (prectype%athres >= dzero) & + & call mld_precset(prec,'aggr_thresh', prectype%athres, info) call mld_precset(prec,'smoother_type', prectype%smther, info) call mld_precset(prec,'smoother_sweeps', prectype%jsweeps, info) call mld_precset(prec,'sub_ovr', prectype%novr, info) @@ -246,18 +259,15 @@ program spde2d call mld_precset(prec,'aggr_ord', prectype%aggr_ord,info) call mld_precset(prec,'ml_type', prectype%mltype, info) call mld_precset(prec,'smoother_pos', prectype%smthpos, info) - if (prectype%athres >= dzero) & - & call mld_precset(prec,'aggr_thresh', prectype%athres, info) call mld_precset(prec,'coarse_solve', prectype%csolve, info) call mld_precset(prec,'coarse_subsolve', prectype%csbsolve,info) call mld_precset(prec,'coarse_mat', prectype%cmat, info) call mld_precset(prec,'coarse_fillin', prectype%cfill, info) call mld_precset(prec,'coarse_iluthrs', prectype%cthres, info) call mld_precset(prec,'coarse_sweeps', prectype%cjswp, info) - call mld_precset(prec,'coarse_aggr_size', prectype%csize, info) else nlv = 1 - call mld_precinit(prec,prectype%prec, info, nlev=nlv) + call mld_precinit(prec,prectype%prec, info) call mld_precset(prec,'smoother_sweeps', prectype%jsweeps, info) call mld_precset(prec,'sub_ovr', prectype%novr, info) call mld_precset(prec,'sub_restr', prectype%restr, info) @@ -374,31 +384,31 @@ contains call read_data(eps,psb_inp_unit) call read_data(prectype%descr,psb_inp_unit) ! verbose description of the prec call read_data(prectype%prec,psb_inp_unit) ! overall prectype + call read_data(prectype%nlevs,psb_inp_unit) ! Prescribed number of levels + call read_data(prectype%csize,psb_inp_unit) ! coarse size + call read_data(prectype%mnaggratio,psb_inp_unit) ! Minimum aggregation ratio + call read_data(prectype%athres,psb_inp_unit) ! smoother aggr thresh + call read_data(prectype%maxlevs,psb_inp_unit) ! Maximum number of levels + call read_data(prectype%aggrkind,psb_inp_unit) ! smoothed/nonsmoothed/minenergy aggregatin + call read_data(prectype%aggr_alg,psb_inp_unit) ! decoupled or sym. decoupled aggregation + call read_data(prectype%aggr_ord,psb_inp_unit) ! aggregation ordering: natural, node degree + call read_data(prectype%mltype,psb_inp_unit) ! additive or multiplicative 2nd level prec + call read_data(prectype%smthpos,psb_inp_unit) ! side: pre, post, both smoothing + call read_data(prectype%jsweeps,psb_inp_unit) ! Smoother sweeps + call read_data(prectype%smther,psb_inp_unit) ! Smoother type. call read_data(prectype%novr,psb_inp_unit) ! number of overlap layers call read_data(prectype%restr,psb_inp_unit) ! restriction over application of as call read_data(prectype%prol,psb_inp_unit) ! prolongation over application of as - call read_data(prectype%solve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%svsweeps,psb_inp_unit) ! Solver sweeps + call read_data(prectype%solve,psb_inp_unit) ! Subdomain solver: DSCALE ILU MILU ILUT FWGS BWGS MUMPS UMF SLU + call read_data(prectype%svsweeps,psb_inp_unit) ! Solver sweeps (GS) call read_data(prectype%fill1,psb_inp_unit) ! Fill-in for factorization 1 call read_data(prectype%thr1,psb_inp_unit) ! Threshold for fact. 1 ILU(T) - call read_data(prectype%jsweeps,psb_inp_unit) ! Jacobi sweeps for PJAC - if (psb_toupper(prectype%prec) == 'ML') then - call read_data(prectype%smther,psb_inp_unit) ! Smoother type. - call read_data(prectype%nlev,psb_inp_unit) ! Number of levels in multilevel prec. - call read_data(prectype%aggrkind,psb_inp_unit) ! smoothed/raw aggregatin - call read_data(prectype%aggr_alg,psb_inp_unit) ! local or global aggregation - call read_data(prectype%aggr_ord,psb_inp_unit) ! aggregation ordering - call read_data(prectype%mltype,psb_inp_unit) ! additive or multiplicative 2nd level prec - call read_data(prectype%smthpos,psb_inp_unit) ! side: pre, post, both smoothing - call read_data(prectype%cmat,psb_inp_unit) ! coarse mat - call read_data(prectype%csolve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%csbsolve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%cfill,psb_inp_unit) ! Fill-in for factorization 1 - call read_data(prectype%cthres,psb_inp_unit) ! Threshold for fact. 1 ILU(T) - call read_data(prectype%cjswp,psb_inp_unit) ! Jacobi sweeps - call read_data(prectype%athres,psb_inp_unit) ! smoother aggr thresh - call read_data(prectype%csize,psb_inp_unit) ! coarse size - end if + call read_data(prectype%cmat,psb_inp_unit) ! coarse mat + call read_data(prectype%csolve,psb_inp_unit) ! Coarse solver: JACOBI BJAC UMF SLU SLUDIST MUMPS + call read_data(prectype%csbsolve,psb_inp_unit) ! subsolver: DSCALE GS BWGS ILU UMF SLU SLUDIST MUMPS + call read_data(prectype%cfill,psb_inp_unit) ! Fill-in for factorization 1 + call read_data(prectype%cthres,psb_inp_unit) ! Threshold for fact. 1 ILU(T) + call read_data(prectype%cjswp,psb_inp_unit) ! Jacobi sweeps end if ! broadcast parameters to all processors @@ -410,35 +420,34 @@ contains call psb_bcast(ictxt,itrace) call psb_bcast(ictxt,irst) call psb_bcast(ictxt,eps) - - call psb_bcast(ictxt,prectype%descr) ! verbose description of the prec call psb_bcast(ictxt,prectype%prec) ! overall prectype + call psb_bcast(ictxt,prectype%nlevs) ! Prescribed number of levels + call psb_bcast(ictxt,prectype%csize) ! coarse size + call psb_bcast(ictxt,prectype%mnaggratio) ! Minimum aggregation ratio + call psb_bcast(ictxt,prectype%athres) ! smoother aggr thresh + call psb_bcast(ictxt,prectype%maxlevs) ! Maximum number of levels + call psb_bcast(ictxt,prectype%aggrkind) ! smoothed/nonsmoothed/minenergy aggregatin + call psb_bcast(ictxt,prectype%aggr_alg) ! decoupled or sym. decoupled aggregation + call psb_bcast(ictxt,prectype%aggr_ord) ! aggregation ordering: natural, node degree + call psb_bcast(ictxt,prectype%mltype) ! additive or multiplicative 2nd level prec + call psb_bcast(ictxt,prectype%smthpos) ! side: pre, post, both smoothing + call psb_bcast(ictxt,prectype%jsweeps) ! Smoother sweeps + call psb_bcast(ictxt,prectype%smther) ! Smoother type. call psb_bcast(ictxt,prectype%novr) ! number of overlap layers call psb_bcast(ictxt,prectype%restr) ! restriction over application of as call psb_bcast(ictxt,prectype%prol) ! prolongation over application of as - call psb_bcast(ictxt,prectype%solve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%svsweeps) ! Sweeps for inner GS solver + call psb_bcast(ictxt,prectype%solve) ! Subdomain solver: DSCALE ILU MILU ILUT FWGS BWGS MUMPS UMF SLU + call psb_bcast(ictxt,prectype%svsweeps) ! Solver sweeps (GS) call psb_bcast(ictxt,prectype%fill1) ! Fill-in for factorization 1 call psb_bcast(ictxt,prectype%thr1) ! Threshold for fact. 1 ILU(T) - call psb_bcast(ictxt,prectype%jsweeps) ! Jacobi sweeps - if (psb_toupper(prectype%prec) == 'ML') then - call psb_bcast(ictxt,prectype%smther) ! Smoother type. - call psb_bcast(ictxt,prectype%nlev) ! Number of levels in multilevel prec. - call psb_bcast(ictxt,prectype%aggrkind) ! smoothed/raw aggregatin - call psb_bcast(ictxt,prectype%aggr_alg) ! local or global aggregation - call psb_bcast(ictxt,prectype%aggr_ord) ! aggregation ordering - call psb_bcast(ictxt,prectype%mltype) ! additive or multiplicative 2nd level prec - call psb_bcast(ictxt,prectype%smthpos) ! side: pre, post, both smoothing - call psb_bcast(ictxt,prectype%cmat) ! coarse mat - call psb_bcast(ictxt,prectype%csolve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%csbsolve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%cfill) ! Fill-in for factorization 1 - call psb_bcast(ictxt,prectype%cthres) ! Threshold for fact. 1 ILU(T) - call psb_bcast(ictxt,prectype%cjswp) ! Jacobi sweeps - call psb_bcast(ictxt,prectype%athres) ! smoother aggr thresh - call psb_bcast(ictxt,prectype%csize) ! coarse size - end if + call psb_bcast(ictxt,prectype%cmat) ! coarse mat + call psb_bcast(ictxt,prectype%csolve) ! Coarse solver: JACOBI BJAC UMF SLU SLUDIST MUMPS + call psb_bcast(ictxt,prectype%csbsolve) ! subsolver: DSCALE GS BWGS ILU UMF SLU SLUDIST MUMPS + call psb_bcast(ictxt,prectype%cfill) ! Fill-in for factorization 1 + call psb_bcast(ictxt,prectype%cthres) ! Threshold for fact. 1 ILU(T) + call psb_bcast(ictxt,prectype%cjswp) ! Jacobi sweeps + if (iam == psb_root_) then write(psb_out_unit,'("Solving matrix : ell1")') diff --git a/tests/pdegen/spde3d.f90 b/tests/pdegen/spde3d.f90 index 453095cc..6a135c87 100644 --- a/tests/pdegen/spde3d.f90 +++ b/tests/pdegen/spde3d.f90 @@ -168,7 +168,8 @@ program spde3d integer(psb_ipk_) :: svsweeps ! Solver sweeps for GS real(psb_spk_) :: thr1 ! Threshold for fact. 1 ILU(T) character(len=16) :: smther ! Smoother - integer(psb_ipk_) :: nlev ! Number of levels in multilevel prec. + integer(psb_ipk_) :: nlevs ! Number of levels in multilevel prec. + integer(psb_ipk_) :: maxlevs ! Maximum number of levels in multilevel prec. character(len=16) :: aggrkind ! smoothed/raw aggregatin character(len=16) :: aggr_alg ! local or global aggregation character(len=16) :: aggr_ord ! Ordering for aggregation @@ -182,6 +183,7 @@ program spde3d real(psb_spk_) :: cthres ! Threshold for fact. 1 ILU(T) integer(psb_ipk_) :: cjswp ! Jacobi sweeps real(psb_spk_) :: athres ! smoother aggregation threshold + real(psb_spk_) :: mnaggratio ! Minimum aggregation ratio end type precdata type(precdata) :: prectype type(psb_s_coo_sparse_mat) :: acoo @@ -243,8 +245,19 @@ program spde3d if (psb_toupper(prectype%prec) == 'ML') then call mld_precinit(prec,prectype%prec, info) - if (prectype%nlev > 0) & - & call mld_precset(prec,'n_prec_levs', prectype%nlev, info) + if (prectype%nlevs > 0) then + ! Force number of levels, so disregard the other related arguments. + call mld_precset(prec,'n_prec_levs', prectype%nlevs, info) + else + if (prectype%csize>0)& + & call mld_precset(prec,'coarse_aggr_size', prectype%csize, info) + if (prectype%maxlevs>0)& + & call mld_precset(prec,'max_prec_levs', prectype%maxlevs, info) + if (prectype%mnaggratio>0)& + & call mld_precset(prec,'min_aggr_ratio', prectype%mnaggratio, info) + end if + if (prectype%athres >= dzero) & + & call mld_precset(prec,'aggr_thresh', prectype%athres, info) call mld_precset(prec,'smoother_type', prectype%smther, info) call mld_precset(prec,'smoother_sweeps', prectype%jsweeps, info) call mld_precset(prec,'sub_ovr', prectype%novr, info) @@ -259,18 +272,15 @@ program spde3d call mld_precset(prec,'aggr_ord', prectype%aggr_ord,info) call mld_precset(prec,'ml_type', prectype%mltype, info) call mld_precset(prec,'smoother_pos', prectype%smthpos, info) - if (prectype%athres >= dzero) & - & call mld_precset(prec,'aggr_thresh', prectype%athres, info) call mld_precset(prec,'coarse_solve', prectype%csolve, info) call mld_precset(prec,'coarse_subsolve', prectype%csbsolve,info) call mld_precset(prec,'coarse_mat', prectype%cmat, info) call mld_precset(prec,'coarse_fillin', prectype%cfill, info) call mld_precset(prec,'coarse_iluthrs', prectype%cthres, info) call mld_precset(prec,'coarse_sweeps', prectype%cjswp, info) - call mld_precset(prec,'coarse_aggr_size', prectype%csize, info) else nlv = 1 - call mld_precinit(prec,prectype%prec, info, nlev=nlv) + call mld_precinit(prec,prectype%prec, info) call mld_precset(prec,'smoother_sweeps', prectype%jsweeps, info) call mld_precset(prec,'sub_ovr', prectype%novr, info) call mld_precset(prec,'sub_restr', prectype%restr, info) @@ -387,31 +397,31 @@ contains call read_data(eps,psb_inp_unit) call read_data(prectype%descr,psb_inp_unit) ! verbose description of the prec call read_data(prectype%prec,psb_inp_unit) ! overall prectype + call read_data(prectype%nlevs,psb_inp_unit) ! Prescribed number of levels + call read_data(prectype%csize,psb_inp_unit) ! coarse size + call read_data(prectype%mnaggratio,psb_inp_unit) ! Minimum aggregation ratio + call read_data(prectype%athres,psb_inp_unit) ! smoother aggr thresh + call read_data(prectype%maxlevs,psb_inp_unit) ! Maximum number of levels + call read_data(prectype%aggrkind,psb_inp_unit) ! smoothed/nonsmoothed/minenergy aggregatin + call read_data(prectype%aggr_alg,psb_inp_unit) ! decoupled or sym. decoupled aggregation + call read_data(prectype%aggr_ord,psb_inp_unit) ! aggregation ordering: natural, node degree + call read_data(prectype%mltype,psb_inp_unit) ! additive or multiplicative 2nd level prec + call read_data(prectype%smthpos,psb_inp_unit) ! side: pre, post, both smoothing + call read_data(prectype%jsweeps,psb_inp_unit) ! Smoother sweeps + call read_data(prectype%smther,psb_inp_unit) ! Smoother type. call read_data(prectype%novr,psb_inp_unit) ! number of overlap layers call read_data(prectype%restr,psb_inp_unit) ! restriction over application of as call read_data(prectype%prol,psb_inp_unit) ! prolongation over application of as - call read_data(prectype%solve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%svsweeps,psb_inp_unit) ! Solver sweeps + call read_data(prectype%solve,psb_inp_unit) ! Subdomain solver: DSCALE ILU MILU ILUT FWGS BWGS MUMPS UMF SLU + call read_data(prectype%svsweeps,psb_inp_unit) ! Solver sweeps (GS) call read_data(prectype%fill1,psb_inp_unit) ! Fill-in for factorization 1 call read_data(prectype%thr1,psb_inp_unit) ! Threshold for fact. 1 ILU(T) - call read_data(prectype%jsweeps,psb_inp_unit) ! Jacobi sweeps for PJAC - if (psb_toupper(prectype%prec) == 'ML') then - call read_data(prectype%smther,psb_inp_unit) ! Smoother type. - call read_data(prectype%nlev,psb_inp_unit) ! Number of levels in multilevel prec. - call read_data(prectype%aggrkind,psb_inp_unit) ! smoothed/raw aggregatin - call read_data(prectype%aggr_alg,psb_inp_unit) ! local or global aggregation - call read_data(prectype%aggr_ord,psb_inp_unit) ! aggregation ordering - call read_data(prectype%mltype,psb_inp_unit) ! additive or multiplicative 2nd level prec - call read_data(prectype%smthpos,psb_inp_unit) ! side: pre, post, both smoothing - call read_data(prectype%cmat,psb_inp_unit) ! coarse mat - call read_data(prectype%csolve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%csbsolve,psb_inp_unit) ! Factorization type: ILU, SuperLU, UMFPACK. - call read_data(prectype%cfill,psb_inp_unit) ! Fill-in for factorization 1 - call read_data(prectype%cthres,psb_inp_unit) ! Threshold for fact. 1 ILU(T) - call read_data(prectype%cjswp,psb_inp_unit) ! Jacobi sweeps - call read_data(prectype%athres,psb_inp_unit) ! smoother aggr thresh - call read_data(prectype%csize,psb_inp_unit) ! coarse size - end if + call read_data(prectype%cmat,psb_inp_unit) ! coarse mat + call read_data(prectype%csolve,psb_inp_unit) ! Coarse solver: JACOBI BJAC UMF SLU SLUDIST MUMPS + call read_data(prectype%csbsolve,psb_inp_unit) ! subsolver: DSCALE GS BWGS ILU UMF SLU SLUDIST MUMPS + call read_data(prectype%cfill,psb_inp_unit) ! Fill-in for factorization 1 + call read_data(prectype%cthres,psb_inp_unit) ! Threshold for fact. 1 ILU(T) + call read_data(prectype%cjswp,psb_inp_unit) ! Jacobi sweeps end if ! broadcast parameters to all processors @@ -423,35 +433,34 @@ contains call psb_bcast(ictxt,itrace) call psb_bcast(ictxt,irst) call psb_bcast(ictxt,eps) - - call psb_bcast(ictxt,prectype%descr) ! verbose description of the prec call psb_bcast(ictxt,prectype%prec) ! overall prectype + call psb_bcast(ictxt,prectype%nlevs) ! Prescribed number of levels + call psb_bcast(ictxt,prectype%csize) ! coarse size + call psb_bcast(ictxt,prectype%mnaggratio) ! Minimum aggregation ratio + call psb_bcast(ictxt,prectype%athres) ! smoother aggr thresh + call psb_bcast(ictxt,prectype%maxlevs) ! Maximum number of levels + call psb_bcast(ictxt,prectype%aggrkind) ! smoothed/nonsmoothed/minenergy aggregatin + call psb_bcast(ictxt,prectype%aggr_alg) ! decoupled or sym. decoupled aggregation + call psb_bcast(ictxt,prectype%aggr_ord) ! aggregation ordering: natural, node degree + call psb_bcast(ictxt,prectype%mltype) ! additive or multiplicative 2nd level prec + call psb_bcast(ictxt,prectype%smthpos) ! side: pre, post, both smoothing + call psb_bcast(ictxt,prectype%jsweeps) ! Smoother sweeps + call psb_bcast(ictxt,prectype%smther) ! Smoother type. call psb_bcast(ictxt,prectype%novr) ! number of overlap layers call psb_bcast(ictxt,prectype%restr) ! restriction over application of as call psb_bcast(ictxt,prectype%prol) ! prolongation over application of as - call psb_bcast(ictxt,prectype%solve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%svsweeps) ! Sweeps for inner GS solver + call psb_bcast(ictxt,prectype%solve) ! Subdomain solver: DSCALE ILU MILU ILUT FWGS BWGS MUMPS UMF SLU + call psb_bcast(ictxt,prectype%svsweeps) ! Solver sweeps (GS) call psb_bcast(ictxt,prectype%fill1) ! Fill-in for factorization 1 call psb_bcast(ictxt,prectype%thr1) ! Threshold for fact. 1 ILU(T) - call psb_bcast(ictxt,prectype%jsweeps) ! Jacobi sweeps - if (psb_toupper(prectype%prec) == 'ML') then - call psb_bcast(ictxt,prectype%smther) ! Smoother type. - call psb_bcast(ictxt,prectype%nlev) ! Number of levels in multilevel prec. - call psb_bcast(ictxt,prectype%aggrkind) ! smoothed/raw aggregatin - call psb_bcast(ictxt,prectype%aggr_alg) ! local or global aggregation - call psb_bcast(ictxt,prectype%aggr_ord) ! aggregation ordering - call psb_bcast(ictxt,prectype%mltype) ! additive or multiplicative 2nd level prec - call psb_bcast(ictxt,prectype%smthpos) ! side: pre, post, both smoothing - call psb_bcast(ictxt,prectype%cmat) ! coarse mat - call psb_bcast(ictxt,prectype%csolve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%csbsolve) ! Factorization type: ILU, SuperLU, UMFPACK. - call psb_bcast(ictxt,prectype%cfill) ! Fill-in for factorization 1 - call psb_bcast(ictxt,prectype%cthres) ! Threshold for fact. 1 ILU(T) - call psb_bcast(ictxt,prectype%cjswp) ! Jacobi sweeps - call psb_bcast(ictxt,prectype%athres) ! smoother aggr thresh - call psb_bcast(ictxt,prectype%csize) ! coarse size - end if + call psb_bcast(ictxt,prectype%cmat) ! coarse mat + call psb_bcast(ictxt,prectype%csolve) ! Coarse solver: JACOBI BJAC UMF SLU SLUDIST MUMPS + call psb_bcast(ictxt,prectype%csbsolve) ! subsolver: DSCALE GS BWGS ILU UMF SLU SLUDIST MUMPS + call psb_bcast(ictxt,prectype%cfill) ! Fill-in for factorization 1 + call psb_bcast(ictxt,prectype%cthres) ! Threshold for fact. 1 ILU(T) + call psb_bcast(ictxt,prectype%cjswp) ! Jacobi sweeps + if (iam == psb_root_) then write(psb_out_unit,'("Solving matrix : ell1")')