fdurastante
/
amg4psblas
mirror of https://github.com/sfilippone/amg4psblas.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

mld2p4-2:

Browse Source 
mlprec/impl/mld_c_dec_map_bld.f90
 mlprec/impl/mld_c_hierarchy_bld.f90
 mlprec/impl/mld_c_lev_aggrmap_bld.f90
 mlprec/impl/mld_c_lev_aggrmat_asb.f90
 mlprec/impl/mld_c_smoothers_bld.f90
 mlprec/impl/mld_caggrmap_bld.f90
 mlprec/impl/mld_caggrmat_asb.f90
 mlprec/impl/mld_caggrmat_biz_asb.f90
 mlprec/impl/mld_caggrmat_minnrg_asb.f90
 mlprec/impl/mld_caggrmat_nosmth_asb.f90
 mlprec/impl/mld_caggrmat_smth_asb.f90
 mlprec/impl/mld_cmlprec_bld.f90
 mlprec/impl/mld_d_dec_map_bld.f90
 mlprec/impl/mld_d_hierarchy_bld.f90
 mlprec/impl/mld_d_lev_aggrmap_bld.f90
 mlprec/impl/mld_d_lev_aggrmat_asb.f90
 mlprec/impl/mld_d_smoothers_bld.f90
 mlprec/impl/mld_daggrmap_bld.f90
 mlprec/impl/mld_daggrmat_asb.f90
 mlprec/impl/mld_daggrmat_biz_asb.f90
 mlprec/impl/mld_daggrmat_minnrg_asb.f90
 mlprec/impl/mld_daggrmat_nosmth_asb.f90
 mlprec/impl/mld_daggrmat_smth_asb.f90
 mlprec/impl/mld_dmlprec_bld.f90
 mlprec/impl/mld_s_dec_map_bld.f90
 mlprec/impl/mld_s_hierarchy_bld.f90
 mlprec/impl/mld_s_lev_aggrmap_bld.f90
 mlprec/impl/mld_s_lev_aggrmat_asb.f90
 mlprec/impl/mld_s_smoothers_bld.f90
 mlprec/impl/mld_saggrmap_bld.f90
 mlprec/impl/mld_saggrmat_asb.f90
 mlprec/impl/mld_saggrmat_biz_asb.f90
 mlprec/impl/mld_saggrmat_minnrg_asb.f90
 mlprec/impl/mld_saggrmat_nosmth_asb.f90
 mlprec/impl/mld_saggrmat_smth_asb.f90
 mlprec/impl/mld_smlprec_bld.f90
 mlprec/impl/mld_z_dec_map_bld.f90
 mlprec/impl/mld_z_hierarchy_bld.f90
 mlprec/impl/mld_z_lev_aggrmap_bld.f90
 mlprec/impl/mld_z_lev_aggrmat_asb.f90
 mlprec/impl/mld_z_smoothers_bld.f90
 mlprec/impl/mld_zaggrmap_bld.f90
 mlprec/impl/mld_zaggrmat_asb.f90
 mlprec/impl/mld_zaggrmat_biz_asb.f90
 mlprec/impl/mld_zaggrmat_minnrg_asb.f90
 mlprec/impl/mld_zaggrmat_nosmth_asb.f90
 mlprec/impl/mld_zaggrmat_smth_asb.f90
 mlprec/impl/mld_zmlprec_bld.f90

Updated function prologues
stopcriterion
Salvatore Filippone 8 years ago
parent ed2c5cb898
commit a4cc5661a7
48 changed files with 855 additions and 307 deletions
Show Stats Download Patch File Download Diff File

33
mlprec/impl/mld_c_dec_map_bld.f90
Unescape Escape View File

@ -36,7 +36,38 @@
!!$ POSSIBILITY OF SUCH DAMAGE. !!$ POSSIBILITY OF SUCH DAMAGE.
!!$ !!$
!!$ !!$
!
! File: mld_c_dec_map__bld.f90
!
! Subroutine: mld_c_dec_map_bld
! Version: complex
!
! This routine builds the tentative prolongator based on the
! decoupled aggregation algorithm presented in
!
! M. Brezina and P. Vanek, A black-box iterative solver based on a
! two-level Schwarz method, Computing, 63 (1999), 233-263.
! P. D'Ambra, D. di Serafino and S. Filippone, On the development of
! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math.
! 57 (2007), 1181-1196.
!
! Note: upon exit
!
! Arguments:
! a - type(psb_cspmat_type).
! The sparse matrix structure containing the local part of the
! matrix to be preconditioned.
! desc_a - type(psb_desc_type), input.
! The communication descriptor of a.
! p - type(mld_cprec_type), input/output.
! The preconditioner data structure; upon exit it contains
! the multilevel hierarchy of prolongators, restrictors
! and coarse matrices.
! info - integer, output.
! Error code.
!
!
!
subroutine mld_c_dec_map_bld(iorder,theta,a,desc_a,nlaggr,ilaggr,info) subroutine mld_c_dec_map_bld(iorder,theta,a,desc_a,nlaggr,ilaggr,info)
use psb_base_mod use psb_base_mod

5
mlprec/impl/mld_c_hierarchy_bld.f90
Unescape Escape View File

@ -58,8 +58,9 @@
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
! The communication descriptor of a. ! The communication descriptor of a.
! p - type(mld_cprec_type), input/output. ! p - type(mld_cprec_type), input/output.
! The preconditioner data structure containing the local part ! The preconditioner data structure; upon exit it contains
! of the preconditioner to be built. ! the multilevel hierarchy of prolongators, restrictors
! and coarse matrices.
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

40
mlprec/impl/mld_c_lev_aggrmap_bld.f90
Unescape Escape View File

@ -36,32 +36,40 @@
!!$ POSSIBILITY OF SUCH DAMAGE. !!$ POSSIBILITY OF SUCH DAMAGE.
!!$ !!$
!!$ !!$
! File: mld_ccoarse_bld.f90 ! File: mld_c_lev_aggrmap_bld.f90
! !
! Subroutine: mld_ccoarse_bld ! Subroutine: mld_c_lev_aggrmap_bld
! Version: real ! Version: complex
! !
! This routine builds the matrix associated to the current level of the ! This routine is just an interface to aggrmap_bld where the real work is performed.
! multilevel preconditioner from the matrix associated to the previous level, ! It takes care of some consistency checking though.
! by using a smoothed aggregation technique (therefore, it also builds the !
! prolongation and restriction operators mapping the current level to the ! See mld_caggrmap_bld for constraints on input/oput arguments.
! previous one and vice versa). Then the routine builds the base preconditioner
! at the current level.
! The current level is regarded as the coarse one, while the previous as
! the fine one. This is in agreement with the fact that the routine is called,
! by mld_mlprec_bld, only on levels >=2.
! !
! !
! Arguments: ! Arguments:
! p - type(mld_c_onelev_type), input/output.
! The 'one-level' data structure containing the control
! parameters and (eventually) coarse matrix and prolongator/restrictors.
!
! a - type(psb_cspmat_type). ! a - type(psb_cspmat_type).
! The sparse matrix structure containing the local part of the ! The sparse matrix structure containing the local part of the
! fine-level matrix. ! fine-level matrix.
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
! The communication descriptor of a. ! The communication descriptor of a.
! p - type(mld_c_onelev_type), input/output. ! ilaggr - integer, dimension(:), allocatable, output
! The 'one-level' data structure containing the local part ! The mapping between the row indices of the coarse-level
! of the base preconditioner to be built as well as ! matrix and the row indices of the fine-level matrix.
! information concerning the prolongator and its transpose. ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. Note that on exit the indices
! will be shifted so as to make sure the ranges on the various processes do not
! overlap.
! nlaggr - integer, dimension(:), allocatable, output
! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_cspmat_type), output
! The tentative prolongator, based on ilaggr.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

39
mlprec/impl/mld_c_lev_aggrmat_asb.f90
Unescape Escape View File

@ -36,32 +36,51 @@
!!$ POSSIBILITY OF SUCH DAMAGE. !!$ POSSIBILITY OF SUCH DAMAGE.
!!$ !!$
!!$ !!$
! File: mld_ccoarse_bld.f90 ! File: mld_c_lev_aggrmat_asb.f90
! !
! Subroutine: mld_ccoarse_bld ! Subroutine: mld_c_lev_aggrmat_asb
! Version: real ! Version: complex
! !
! This routine builds the matrix associated to the current level of the ! This routine builds the matrix associated to the current level of the
! multilevel preconditioner from the matrix associated to the previous level, ! multilevel preconditioner from the matrix associated to the previous level,
! by using a smoothed aggregation technique (therefore, it also builds the ! by using the user-specified aggregation technique (therefore, it also builds the
! prolongation and restriction operators mapping the current level to the ! prolongation and restriction operators mapping the current level to the
! previous one and vice versa). Then the routine builds the base preconditioner ! previous one and vice versa).
! at the current level.
! The current level is regarded as the coarse one, while the previous as ! The current level is regarded as the coarse one, while the previous as
! the fine one. This is in agreement with the fact that the routine is called, ! the fine one. This is in agreement with the fact that the routine is called,
! by mld_mlprec_bld, only on levels >=2. ! by mld_mlprec_bld, only on levels >=2.
! The main structure is:
! 1. Perform sanity checks;
! 2. Call mld_Xaggrmat_asb to compute prolongator/restrictor/AC
! 3. According to the choice of DIST/REPL for AC, build a descriptor DESC_AC,
! and adjust the column numbering of AC/OP_PROL/OP_RESTR
! 4. Pack restrictor and prolongator into p%map
! 5. Fix base_a and base_desc pointers.
! !
! !
! Arguments: ! Arguments:
! p - type(mld_c_onelev_type), input/output.
! The 'one-level' data structure containing the control
! parameters and (eventually) coarse matrix and prolongator/restrictors.
!
! a - type(psb_cspmat_type). ! a - type(psb_cspmat_type).
! The sparse matrix structure containing the local part of the ! The sparse matrix structure containing the local part of the
! fine-level matrix. ! fine-level matrix.
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
! The communication descriptor of a. ! The communication descriptor of a.
! p - type(mld_c_onelev_type), input/output. ! ilaggr - integer, dimension(:), input
! The 'one-level' data structure containing the local part ! The mapping between the row indices of the coarse-level
! of the base preconditioner to be built as well as ! matrix and the row indices of the fine-level matrix.
! information concerning the prolongator and its transpose. ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. Note that the indices
! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_cspmat_type), input/output
! The tentative prolongator on input, released on output.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

8
mlprec/impl/mld_c_smoothers_bld.f90
Unescape Escape View File

@ -41,14 +41,18 @@
! Subroutine: mld_c_smoothers_bld ! Subroutine: mld_c_smoothers_bld
! Version: complex ! Version: complex
! !
! This routine builds the preconditioner according to the requirements made by ! This routine performs the final phase of the multilevel preconditioner build process:
! the user trough the subroutines mld_precinit and mld_precset. ! builds the "smoother" objects at each level, based on the matrix hierarchy prepared
! by mld_c_hierarchy_bld.
! !
! A multilevel preconditioner is regarded as an array of 'one-level' data structures, ! A multilevel preconditioner is regarded as an array of 'one-level' data structures,
! each containing the part of the preconditioner associated to a certain level, ! each containing the part of the preconditioner associated to a certain level,
! (for more details see the description of mld_Tonelev_type in mld_prec_type.f90). ! (for more details see the description of mld_Tonelev_type in mld_prec_type.f90).
! The levels are numbered in increasing order starting from the finest one, i.e. ! The levels are numbered in increasing order starting from the finest one, i.e.
! level 1 is the finest level. No transfer operators are associated to level 1. ! level 1 is the finest level. No transfer operators are associated to level 1.
! Each level provides a "build" method; for the base type, the "one-level"
! build procedure simply invokes the build method of the first smoother object,
! and also on the second object if allocated.
! !
! !
! Arguments: ! Arguments:

7
mlprec/impl/mld_caggrmap_bld.f90
Unescape Escape View File

@ -73,9 +73,14 @@
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that on exit the indices
! will be shifted so as to make sure the ranges on the various processes do not
! overlap.
! nlaggr - integer, dimension(:), allocatable. ! nlaggr - integer, dimension(:), allocatable.
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_cspmat_type).
! The tentative prolongator, based on ilaggr.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

30
mlprec/impl/mld_caggrmat_asb.f90
Unescape Escape View File

@ -53,12 +53,16 @@
! The prolongator P_C is built here from this mapping, according to the ! The prolongator P_C is built here from this mapping, according to the
! value of p%iprcparm(mld_aggr_kind_), specified by the user through ! value of p%iprcparm(mld_aggr_kind_), specified by the user through
! mld_cprecinit and mld_zprecset. ! mld_cprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_c_lev_aggrmat_asb.
! !
! Currently three different prolongators are implemented, corresponding to ! Currently four different prolongators are implemented, corresponding to
! three aggregation algorithms: ! four aggregation algorithms:
! 1. non-smoothed aggregation, ! 1. un-smoothed aggregation,
! 2. smoothed aggregation, ! 2. smoothed aggregation,
! 3. "bizarre" aggregation. ! 3. "bizarre" aggregation.
! 4. minimum energy
! 1. The non-smoothed aggregation uses as prolongator the piecewise constant ! 1. The non-smoothed aggregation uses as prolongator the piecewise constant
! interpolation operator corresponding to the fine-to-coarse level mapping built ! interpolation operator corresponding to the fine-to-coarse level mapping built
! by mld_aggrmap_bld. This is called tentative prolongator. ! by mld_aggrmap_bld. This is called tentative prolongator.
@ -67,6 +71,7 @@
! 3. The "bizarre" aggregation uses a prolongator proposed by the authors of MLD2P4. ! 3. The "bizarre" aggregation uses a prolongator proposed by the authors of MLD2P4.
! This prolongator still requires a deep analysis and testing and its use is ! This prolongator still requires a deep analysis and testing and its use is
! not recommended. ! not recommended.
! 4. Minimum energy aggregation: ADD REFERENCE.
! !
! For more details see ! For more details see
! M. Brezina and P. Vanek, A black-box iterative solver based on a two-level ! M. Brezina and P. Vanek, A black-box iterative solver based on a two-level
@ -87,14 +92,27 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_sml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_cspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_cspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_cspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

17
mlprec/impl/mld_caggrmat_biz_asb.f90
Unescape Escape View File

@ -56,6 +56,9 @@
! The coarse-level matrix A_C is distributed among the parallel processes or ! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat, ! replicated on each of them, according to the value of p%parms%coarse_mat,
! specified by the user through mld_cprecinit and mld_zprecset. ! specified by the user through mld_cprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_c_lev_aggrmat_asb.
! !
! Arguments: ! Arguments:
! a - type(psb_cspmat_type), input. ! a - type(psb_cspmat_type), input.
@ -98,7 +101,7 @@ subroutine mld_caggrmat_biz_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr
& naggr, nzl,naggrm1,naggrp1, i, j, k, jd, icolF, nrw, err_act & naggr, nzl,naggrm1,naggrp1, i, j, k, jd, icolF, nrw, err_act
integer(psb_ipk_) ::ictxt, np, me integer(psb_ipk_) ::ictxt, np, me
character(len=20) :: name character(len=20) :: name
type(psb_cspmat_type) :: am3, am4 type(psb_cspmat_type) :: am3, am4,tmp_prol
type(psb_c_coo_sparse_mat) :: tmpcoo type(psb_c_coo_sparse_mat) :: tmpcoo
type(psb_c_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsrf, ptilde type(psb_c_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsrf, ptilde
complex(psb_spk_), allocatable :: adiag(:) complex(psb_spk_), allocatable :: adiag(:)
@ -321,29 +324,29 @@ subroutine mld_caggrmat_biz_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr
call acsr1%set_dupl(psb_dupl_add_) call acsr1%set_dupl(psb_dupl_add_)
call op_prol%mv_from(acsr1) call op_prol%mv_from(acsr1)
call op_prol%clone(tmp_prol,info)
call psb_rwextd(ncol,op_prol,info) call psb_rwextd(ncol,tmp_prol,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_internal_error_,name,a_err='Halo of op_prol') call psb_errpush(psb_err_internal_error_,name,a_err='Halo of op_prol')
goto 9999 goto 9999
end if end if
call psb_symbmm(a,op_prol,am3,info) call psb_symbmm(a,tmp_prol,am3,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_from_subroutine_,name,a_err='symbmm 2') call psb_errpush(psb_err_from_subroutine_,name,a_err='symbmm 2')
goto 9999 goto 9999
end if end if
call psb_numbmm(a,op_prol,am3) call psb_numbmm(a,tmp_prol,am3)
if (debug_level >= psb_debug_outer_) & if (debug_level >= psb_debug_outer_) &
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'Done NUMBMM 2',parms%aggr_kind, mld_smooth_prol_ & 'Done NUMBMM 2',parms%aggr_kind, mld_smooth_prol_
call op_prol%transp(op_restr) call tmp_prol%transp(op_restr)
if (debug_level >= psb_debug_outer_) & if (debug_level >= psb_debug_outer_) &
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'starting sphalo/ rwxtd' & 'starting sphalo/ rwxtd'
call tmp_prol%free()
call psb_rwextd(ncol,am3,info) call psb_rwextd(ncol,am3,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_internal_error_,name,a_err='Extend am3') call psb_errpush(psb_err_internal_error_,name,a_err='Extend am3')

54
mlprec/impl/mld_caggrmat_minnrg_asb.f90
Unescape Escape View File

@ -60,22 +60,19 @@
! radius of D^(-1)A, to be used in the computation of omega, is provided, ! radius of D^(-1)A, to be used in the computation of omega, is provided,
! according to the value of p%parms%aggr_omega_alg, specified by the user ! according to the value of p%parms%aggr_omega_alg, specified by the user
! through mld_cprecinit and mld_cprecset. ! through mld_cprecinit and mld_cprecset.
! 4. Minimum energy aggregation: ADD REFERENCE.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_c_lev_aggrmat_asb.
! !
! This routine can also build A_C according to a "bizarre" aggregation algorithm, ! For more details see
! using a "naive" prolongator proposed by the authors of MLD2P4. However, this ! M. Brezina and P. Vanek, A black-box iterative solver based on a two-level
! prolongator still requires a deep analysis and testing and its use is not ! Schwarz method, Computing, 63 (1999), 233-263.
! recommended. ! P. D'Ambra, D. di Serafino and S. Filippone, On the development of PSBLAS-based
! parallel two-level Schwarz preconditioners, Appl. Num. Math., 57 (2007),
! 1181-1196.
! !
! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat,
! specified by the user through mld_cprecinit and mld_zprecset.
! !
! For more details see
! M. Brezina and P. Vanek, A black-box iterative solver based on a
! two-level Schwarz method, Computing, 63 (1999), 233-263.
! P. D'Ambra, D. di Serafino and S. Filippone, On the development of
! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math.
! 57 (2007), 1181-1196.
! !
! Arguments: ! Arguments:
! a - type(psb_cspmat_type), input. ! a - type(psb_cspmat_type), input.
@ -87,17 +84,31 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_sml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_cspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_cspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_cspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !
!
subroutine mld_caggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info) subroutine mld_caggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info)
use psb_base_mod use psb_base_mod
use mld_c_inner_mod, mld_protect_name => mld_caggrmat_minnrg_asb use mld_c_inner_mod, mld_protect_name => mld_caggrmat_minnrg_asb
@ -121,7 +132,7 @@ subroutine mld_caggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_re
character(len=20) :: name character(len=20) :: name
type(psb_cspmat_type) :: af, ptilde, rtilde, atran, atp, atdatp type(psb_cspmat_type) :: af, ptilde, rtilde, atran, atp, atdatp
type(psb_cspmat_type) :: am3,am4, ap, adap,atmp,rada, ra, atmp2, dap, dadap, da type(psb_cspmat_type) :: am3,am4, ap, adap,atmp,rada, ra, atmp2, dap, dadap, da
type(psb_cspmat_type) :: dat, datp, datdatp, atmp3 type(psb_cspmat_type) :: dat, datp, datdatp, atmp3, tmp_prol
type(psb_c_coo_sparse_mat) :: tmpcoo type(psb_c_coo_sparse_mat) :: tmpcoo
type(psb_c_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsr, acsrf type(psb_c_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsr, acsrf
type(psb_c_csc_sparse_mat) :: csc_dap, csc_dadap, csc_datp, csc_datdatp, acsc type(psb_c_csc_sparse_mat) :: csc_dap, csc_dadap, csc_datp, csc_datdatp, acsc
@ -484,9 +495,10 @@ subroutine mld_caggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_re
! Now we have to gather the halo of op_prol, and add it to itself ! Now we have to gather the halo of op_prol, and add it to itself
! to multiply it by A, ! to multiply it by A,
! !
call psb_sphalo(op_prol,desc_a,am4,info,& call op_prol%clone(tmp_prol,info)
if (info == psb_success_) call psb_sphalo(tmp_prol,desc_a,am4,info,&
& colcnv=.false.,rowscale=.true.) & colcnv=.false.,rowscale=.true.)
if (info == psb_success_) call psb_rwextd(ncol,op_prol,info,b=am4) if (info == psb_success_) call psb_rwextd(ncol,tmp_prol,info,b=am4)
if (info == psb_success_) call am4%free() if (info == psb_success_) call am4%free()
if(info /= psb_success_) then if(info /= psb_success_) then
@ -519,13 +531,13 @@ subroutine mld_caggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_re
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'starting sphalo/ rwxtd' & 'starting sphalo/ rwxtd'
call psb_symbmm(a,op_prol,am3,info) call psb_symbmm(a,tmp_prol,am3,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_from_subroutine_,name,& call psb_errpush(psb_err_from_subroutine_,name,&
& a_err='symbmm 2') & a_err='symbmm 2')
goto 9999 goto 9999
end if end if
call psb_numbmm(a,op_prol,am3) call psb_numbmm(a,tmp_prol,am3)
if (debug_level >= psb_debug_outer_) & if (debug_level >= psb_debug_outer_) &
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'Done NUMBMM 2' & 'Done NUMBMM 2'

24
mlprec/impl/mld_caggrmat_nosmth_asb.f90
Unescape Escape View File

@ -52,6 +52,9 @@
! The coarse-level matrix A_C is distributed among the parallel processes or ! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat ! replicated on each of them, according to the value of p%parms%coarse_mat
! specified by the user through mld_cprecinit and mld_zprecset. ! specified by the user through mld_cprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_c_lev_aggrmat_asb.
! !
! For details see ! For details see
! P. D'Ambra, D. di Serafino and S. Filippone, On the development of ! P. D'Ambra, D. di Serafino and S. Filippone, On the development of
@ -59,7 +62,6 @@
! 57 (2007), 1181-1196. ! 57 (2007), 1181-1196.
! !
! !
!
! Arguments: ! Arguments:
! a - type(psb_cspmat_type), input. ! a - type(psb_cspmat_type), input.
! The sparse matrix structure containing the local part of ! The sparse matrix structure containing the local part of
@ -70,17 +72,31 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_sml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_cspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_cspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_cspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !
!
subroutine mld_caggrmat_nosmth_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info) subroutine mld_caggrmat_nosmth_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info)
use psb_base_mod use psb_base_mod
use mld_c_inner_mod, mld_protect_name => mld_caggrmat_nosmth_asb use mld_c_inner_mod, mld_protect_name => mld_caggrmat_nosmth_asb

23
mlprec/impl/mld_caggrmat_smth_asb.f90
Unescape Escape View File

@ -64,6 +64,9 @@
! The coarse-level matrix A_C is distributed among the parallel processes or ! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat, ! replicated on each of them, according to the value of p%parms%coarse_mat,
! specified by the user through mld_cprecinit and mld_zprecset. ! specified by the user through mld_cprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_c_lev_aggrmat_asb.
! !
! For more details see ! For more details see
! M. Brezina and P. Vanek, A black-box iterative solver based on a ! M. Brezina and P. Vanek, A black-box iterative solver based on a
@ -72,6 +75,7 @@
! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math. ! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math.
! 57 (2007), 1181-1196. ! 57 (2007), 1181-1196.
! !
!
! Arguments: ! Arguments:
! a - type(psb_cspmat_type), input. ! a - type(psb_cspmat_type), input.
! The sparse matrix structure containing the local part of ! The sparse matrix structure containing the local part of
@ -82,14 +86,27 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_sml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_cspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_cspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_cspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

3
mlprec/impl/mld_cmlprec_bld.f90
Unescape Escape View File

@ -50,6 +50,9 @@
! The levels are numbered in increasing order starting from the finest one, i.e. ! The levels are numbered in increasing order starting from the finest one, i.e.
! level 1 is the finest level. No transfer operators are associated to level 1. ! level 1 is the finest level. No transfer operators are associated to level 1.
! !
! This routine simply calls mld_c_hierarchy_bld and mld_c_smoothers_bld; they
! can also be called explicitly from the user.
!
! !
! Arguments: ! Arguments:
! a - type(psb_cspmat_type). ! a - type(psb_cspmat_type).

33
mlprec/impl/mld_d_dec_map_bld.f90
Unescape Escape View File

@ -36,7 +36,38 @@
!!$ POSSIBILITY OF SUCH DAMAGE. !!$ POSSIBILITY OF SUCH DAMAGE.
!!$ !!$
!!$ !!$
!
! File: mld_d_dec_map__bld.f90
!
! Subroutine: mld_d_dec_map_bld
! Version: real
!
! This routine builds the tentative prolongator based on the
! decoupled aggregation algorithm presented in
!
! M. Brezina and P. Vanek, A black-box iterative solver based on a
! two-level Schwarz method, Computing, 63 (1999), 233-263.
! P. D'Ambra, D. di Serafino and S. Filippone, On the development of
! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math.
! 57 (2007), 1181-1196.
!
! Note: upon exit
!
! Arguments:
! a - type(psb_dspmat_type).
! The sparse matrix structure containing the local part of the
! matrix to be preconditioned.
! desc_a - type(psb_desc_type), input.
! The communication descriptor of a.
! p - type(mld_dprec_type), input/output.
! The preconditioner data structure; upon exit it contains
! the multilevel hierarchy of prolongators, restrictors
! and coarse matrices.
! info - integer, output.
! Error code.
!
!
!
subroutine mld_d_dec_map_bld(iorder,theta,a,desc_a,nlaggr,ilaggr,info) subroutine mld_d_dec_map_bld(iorder,theta,a,desc_a,nlaggr,ilaggr,info)
use psb_base_mod use psb_base_mod

5
mlprec/impl/mld_d_hierarchy_bld.f90
Unescape Escape View File

@ -58,8 +58,9 @@
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
! The communication descriptor of a. ! The communication descriptor of a.
! p - type(mld_dprec_type), input/output. ! p - type(mld_dprec_type), input/output.
! The preconditioner data structure containing the local part ! The preconditioner data structure; upon exit it contains
! of the preconditioner to be built. ! the multilevel hierarchy of prolongators, restrictors
! and coarse matrices.
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

38
mlprec/impl/mld_d_lev_aggrmap_bld.f90
Unescape Escape View File

@ -36,32 +36,40 @@
!!$ POSSIBILITY OF SUCH DAMAGE. !!$ POSSIBILITY OF SUCH DAMAGE.
!!$ !!$
!!$ !!$
! File: mld_dcoarse_bld.f90 ! File: mld_d_lev_aggrmap_bld.f90
! !
! Subroutine: mld_dcoarse_bld ! Subroutine: mld_d_lev_aggrmap_bld
! Version: real ! Version: real
! !
! This routine builds the matrix associated to the current level of the ! This routine is just an interface to aggrmap_bld where the real work is performed.
! multilevel preconditioner from the matrix associated to the previous level, ! It takes care of some consistency checking though.
! by using a smoothed aggregation technique (therefore, it also builds the !
! prolongation and restriction operators mapping the current level to the ! See mld_daggrmap_bld for constraints on input/oput arguments.
! previous one and vice versa). Then the routine builds the base preconditioner
! at the current level.
! The current level is regarded as the coarse one, while the previous as
! the fine one. This is in agreement with the fact that the routine is called,
! by mld_mlprec_bld, only on levels >=2.
! !
! !
! Arguments: ! Arguments:
! p - type(mld_d_onelev_type), input/output.
! The 'one-level' data structure containing the control
! parameters and (eventually) coarse matrix and prolongator/restrictors.
!
! a - type(psb_dspmat_type). ! a - type(psb_dspmat_type).
! The sparse matrix structure containing the local part of the ! The sparse matrix structure containing the local part of the
! fine-level matrix. ! fine-level matrix.
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
! The communication descriptor of a. ! The communication descriptor of a.
! p - type(mld_d_onelev_type), input/output. ! ilaggr - integer, dimension(:), allocatable, output
! The 'one-level' data structure containing the local part ! The mapping between the row indices of the coarse-level
! of the base preconditioner to be built as well as ! matrix and the row indices of the fine-level matrix.
! information concerning the prolongator and its transpose. ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. Note that on exit the indices
! will be shifted so as to make sure the ranges on the various processes do not
! overlap.
! nlaggr - integer, dimension(:), allocatable, output
! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_dspmat_type), output
! The tentative prolongator, based on ilaggr.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

37
mlprec/impl/mld_d_lev_aggrmat_asb.f90
Unescape Escape View File

@ -36,32 +36,51 @@
!!$ POSSIBILITY OF SUCH DAMAGE. !!$ POSSIBILITY OF SUCH DAMAGE.
!!$ !!$
!!$ !!$
! File: mld_dcoarse_bld.f90 ! File: mld_d_lev_aggrmat_asb.f90
! !
! Subroutine: mld_dcoarse_bld ! Subroutine: mld_d_lev_aggrmat_asb
! Version: real ! Version: real
! !
! This routine builds the matrix associated to the current level of the ! This routine builds the matrix associated to the current level of the
! multilevel preconditioner from the matrix associated to the previous level, ! multilevel preconditioner from the matrix associated to the previous level,
! by using a smoothed aggregation technique (therefore, it also builds the ! by using the user-specified aggregation technique (therefore, it also builds the
! prolongation and restriction operators mapping the current level to the ! prolongation and restriction operators mapping the current level to the
! previous one and vice versa). Then the routine builds the base preconditioner ! previous one and vice versa).
! at the current level.
! The current level is regarded as the coarse one, while the previous as ! The current level is regarded as the coarse one, while the previous as
! the fine one. This is in agreement with the fact that the routine is called, ! the fine one. This is in agreement with the fact that the routine is called,
! by mld_mlprec_bld, only on levels >=2. ! by mld_mlprec_bld, only on levels >=2.
! The main structure is:
! 1. Perform sanity checks;
! 2. Call mld_Xaggrmat_asb to compute prolongator/restrictor/AC
! 3. According to the choice of DIST/REPL for AC, build a descriptor DESC_AC,
! and adjust the column numbering of AC/OP_PROL/OP_RESTR
! 4. Pack restrictor and prolongator into p%map
! 5. Fix base_a and base_desc pointers.
! !
! !
! Arguments: ! Arguments:
! p - type(mld_d_onelev_type), input/output.
! The 'one-level' data structure containing the control
! parameters and (eventually) coarse matrix and prolongator/restrictors.
!
! a - type(psb_dspmat_type). ! a - type(psb_dspmat_type).
! The sparse matrix structure containing the local part of the ! The sparse matrix structure containing the local part of the
! fine-level matrix. ! fine-level matrix.
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
! The communication descriptor of a. ! The communication descriptor of a.
! p - type(mld_d_onelev_type), input/output. ! ilaggr - integer, dimension(:), input
! The 'one-level' data structure containing the local part ! The mapping between the row indices of the coarse-level
! of the base preconditioner to be built as well as ! matrix and the row indices of the fine-level matrix.
! information concerning the prolongator and its transpose. ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. Note that the indices
! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_dspmat_type), input/output
! The tentative prolongator on input, released on output.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

8
mlprec/impl/mld_d_smoothers_bld.f90
Unescape Escape View File

@ -41,14 +41,18 @@
! Subroutine: mld_d_smoothers_bld ! Subroutine: mld_d_smoothers_bld
! Version: real ! Version: real
! !
! This routine builds the preconditioner according to the requirements made by ! This routine performs the final phase of the multilevel preconditioner build process:
! the user trough the subroutines mld_precinit and mld_precset. ! builds the "smoother" objects at each level, based on the matrix hierarchy prepared
! by mld_d_hierarchy_bld.
! !
! A multilevel preconditioner is regarded as an array of 'one-level' data structures, ! A multilevel preconditioner is regarded as an array of 'one-level' data structures,
! each containing the part of the preconditioner associated to a certain level, ! each containing the part of the preconditioner associated to a certain level,
! (for more details see the description of mld_Tonelev_type in mld_prec_type.f90). ! (for more details see the description of mld_Tonelev_type in mld_prec_type.f90).
! The levels are numbered in increasing order starting from the finest one, i.e. ! The levels are numbered in increasing order starting from the finest one, i.e.
! level 1 is the finest level. No transfer operators are associated to level 1. ! level 1 is the finest level. No transfer operators are associated to level 1.
! Each level provides a "build" method; for the base type, the "one-level"
! build procedure simply invokes the build method of the first smoother object,
! and also on the second object if allocated.
! !
! !
! Arguments: ! Arguments:

7
mlprec/impl/mld_daggrmap_bld.f90
Unescape Escape View File

@ -73,9 +73,14 @@
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that on exit the indices
! will be shifted so as to make sure the ranges on the various processes do not
! overlap.
! nlaggr - integer, dimension(:), allocatable. ! nlaggr - integer, dimension(:), allocatable.
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_dspmat_type).
! The tentative prolongator, based on ilaggr.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

32
mlprec/impl/mld_daggrmat_asb.f90
Unescape Escape View File

@ -53,12 +53,16 @@
! The prolongator P_C is built here from this mapping, according to the ! The prolongator P_C is built here from this mapping, according to the
! value of p%iprcparm(mld_aggr_kind_), specified by the user through ! value of p%iprcparm(mld_aggr_kind_), specified by the user through
! mld_dprecinit and mld_zprecset. ! mld_dprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_d_lev_aggrmat_asb.
! !
! Currently three different prolongators are implemented, corresponding to ! Currently four different prolongators are implemented, corresponding to
! three aggregation algorithms: ! four aggregation algorithms:
! 1. non-smoothed aggregation, ! 1. un-smoothed aggregation,
! 2. smoothed aggregation, ! 2. smoothed aggregation,
! 3. "bizarre" aggregation. ! 3. "bizarre" aggregation.
! 4. minimum energy
! 1. The non-smoothed aggregation uses as prolongator the piecewise constant ! 1. The non-smoothed aggregation uses as prolongator the piecewise constant
! interpolation operator corresponding to the fine-to-coarse level mapping built ! interpolation operator corresponding to the fine-to-coarse level mapping built
! by mld_aggrmap_bld. This is called tentative prolongator. ! by mld_aggrmap_bld. This is called tentative prolongator.
@ -67,6 +71,7 @@
! 3. The "bizarre" aggregation uses a prolongator proposed by the authors of MLD2P4. ! 3. The "bizarre" aggregation uses a prolongator proposed by the authors of MLD2P4.
! This prolongator still requires a deep analysis and testing and its use is ! This prolongator still requires a deep analysis and testing and its use is
! not recommended. ! not recommended.
! 4. Minimum energy aggregation: ADD REFERENCE.
! !
! For more details see ! For more details see
! M. Brezina and P. Vanek, A black-box iterative solver based on a two-level ! M. Brezina and P. Vanek, A black-box iterative solver based on a two-level
@ -78,7 +83,7 @@
! !
! !
! Arguments: ! Arguments:
! a - type(psb_cspmat_type), input. ! a - type(psb_dspmat_type), input.
! The sparse matrix structure containing the local part of ! The sparse matrix structure containing the local part of
! the fine-level matrix. ! the fine-level matrix.
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
@ -87,14 +92,27 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_dml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_dspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_dspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_dspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

17
mlprec/impl/mld_daggrmat_biz_asb.f90
Unescape Escape View File

@ -56,6 +56,9 @@
! The coarse-level matrix A_C is distributed among the parallel processes or ! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat, ! replicated on each of them, according to the value of p%parms%coarse_mat,
! specified by the user through mld_dprecinit and mld_zprecset. ! specified by the user through mld_dprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_d_lev_aggrmat_asb.
! !
! Arguments: ! Arguments:
! a - type(psb_dspmat_type), input. ! a - type(psb_dspmat_type), input.
@ -98,7 +101,7 @@ subroutine mld_daggrmat_biz_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr
& naggr, nzl,naggrm1,naggrp1, i, j, k, jd, icolF, nrw, err_act & naggr, nzl,naggrm1,naggrp1, i, j, k, jd, icolF, nrw, err_act
integer(psb_ipk_) ::ictxt, np, me integer(psb_ipk_) ::ictxt, np, me
character(len=20) :: name character(len=20) :: name
type(psb_dspmat_type) :: am3, am4 type(psb_dspmat_type) :: am3, am4,tmp_prol
type(psb_d_coo_sparse_mat) :: tmpcoo type(psb_d_coo_sparse_mat) :: tmpcoo
type(psb_d_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsrf, ptilde type(psb_d_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsrf, ptilde
real(psb_dpk_), allocatable :: adiag(:) real(psb_dpk_), allocatable :: adiag(:)
@ -321,29 +324,29 @@ subroutine mld_daggrmat_biz_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr
call acsr1%set_dupl(psb_dupl_add_) call acsr1%set_dupl(psb_dupl_add_)
call op_prol%mv_from(acsr1) call op_prol%mv_from(acsr1)
call op_prol%clone(tmp_prol,info)
call psb_rwextd(ncol,op_prol,info) call psb_rwextd(ncol,tmp_prol,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_internal_error_,name,a_err='Halo of op_prol') call psb_errpush(psb_err_internal_error_,name,a_err='Halo of op_prol')
goto 9999 goto 9999
end if end if
call psb_symbmm(a,op_prol,am3,info) call psb_symbmm(a,tmp_prol,am3,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_from_subroutine_,name,a_err='symbmm 2') call psb_errpush(psb_err_from_subroutine_,name,a_err='symbmm 2')
goto 9999 goto 9999
end if end if
call psb_numbmm(a,op_prol,am3) call psb_numbmm(a,tmp_prol,am3)
if (debug_level >= psb_debug_outer_) & if (debug_level >= psb_debug_outer_) &
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'Done NUMBMM 2',parms%aggr_kind, mld_smooth_prol_ & 'Done NUMBMM 2',parms%aggr_kind, mld_smooth_prol_
call op_prol%transp(op_restr) call tmp_prol%transp(op_restr)
if (debug_level >= psb_debug_outer_) & if (debug_level >= psb_debug_outer_) &
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'starting sphalo/ rwxtd' & 'starting sphalo/ rwxtd'
call tmp_prol%free()
call psb_rwextd(ncol,am3,info) call psb_rwextd(ncol,am3,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_internal_error_,name,a_err='Extend am3') call psb_errpush(psb_err_internal_error_,name,a_err='Extend am3')

54
mlprec/impl/mld_daggrmat_minnrg_asb.f90
Unescape Escape View File

@ -60,22 +60,19 @@
! radius of D^(-1)A, to be used in the computation of omega, is provided, ! radius of D^(-1)A, to be used in the computation of omega, is provided,
! according to the value of p%parms%aggr_omega_alg, specified by the user ! according to the value of p%parms%aggr_omega_alg, specified by the user
! through mld_dprecinit and mld_dprecset. ! through mld_dprecinit and mld_dprecset.
! 4. Minimum energy aggregation: ADD REFERENCE.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_d_lev_aggrmat_asb.
! !
! This routine can also build A_C according to a "bizarre" aggregation algorithm, ! For more details see
! using a "naive" prolongator proposed by the authors of MLD2P4. However, this ! M. Brezina and P. Vanek, A black-box iterative solver based on a two-level
! prolongator still requires a deep analysis and testing and its use is not ! Schwarz method, Computing, 63 (1999), 233-263.
! recommended. ! P. D'Ambra, D. di Serafino and S. Filippone, On the development of PSBLAS-based
! parallel two-level Schwarz preconditioners, Appl. Num. Math., 57 (2007),
! 1181-1196.
! !
! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat,
! specified by the user through mld_dprecinit and mld_zprecset.
! !
! For more details see
! M. Brezina and P. Vanek, A black-box iterative solver based on a
! two-level Schwarz method, Computing, 63 (1999), 233-263.
! P. D'Ambra, D. di Serafino and S. Filippone, On the development of
! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math.
! 57 (2007), 1181-1196.
! !
! Arguments: ! Arguments:
! a - type(psb_dspmat_type), input. ! a - type(psb_dspmat_type), input.
@ -87,17 +84,31 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_dml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_dspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_dspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_dspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !
!
subroutine mld_daggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info) subroutine mld_daggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info)
use psb_base_mod use psb_base_mod
use mld_d_inner_mod, mld_protect_name => mld_daggrmat_minnrg_asb use mld_d_inner_mod, mld_protect_name => mld_daggrmat_minnrg_asb
@ -121,7 +132,7 @@ subroutine mld_daggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_re
character(len=20) :: name character(len=20) :: name
type(psb_dspmat_type) :: af, ptilde, rtilde, atran, atp, atdatp type(psb_dspmat_type) :: af, ptilde, rtilde, atran, atp, atdatp
type(psb_dspmat_type) :: am3,am4, ap, adap,atmp,rada, ra, atmp2, dap, dadap, da type(psb_dspmat_type) :: am3,am4, ap, adap,atmp,rada, ra, atmp2, dap, dadap, da
type(psb_dspmat_type) :: dat, datp, datdatp, atmp3 type(psb_dspmat_type) :: dat, datp, datdatp, atmp3, tmp_prol
type(psb_d_coo_sparse_mat) :: tmpcoo type(psb_d_coo_sparse_mat) :: tmpcoo
type(psb_d_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsr, acsrf type(psb_d_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsr, acsrf
type(psb_d_csc_sparse_mat) :: csc_dap, csc_dadap, csc_datp, csc_datdatp, acsc type(psb_d_csc_sparse_mat) :: csc_dap, csc_dadap, csc_datp, csc_datdatp, acsc
@ -484,9 +495,10 @@ subroutine mld_daggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_re
! Now we have to gather the halo of op_prol, and add it to itself ! Now we have to gather the halo of op_prol, and add it to itself
! to multiply it by A, ! to multiply it by A,
! !
call psb_sphalo(op_prol,desc_a,am4,info,& call op_prol%clone(tmp_prol,info)
if (info == psb_success_) call psb_sphalo(tmp_prol,desc_a,am4,info,&
& colcnv=.false.,rowscale=.true.) & colcnv=.false.,rowscale=.true.)
if (info == psb_success_) call psb_rwextd(ncol,op_prol,info,b=am4) if (info == psb_success_) call psb_rwextd(ncol,tmp_prol,info,b=am4)
if (info == psb_success_) call am4%free() if (info == psb_success_) call am4%free()
if(info /= psb_success_) then if(info /= psb_success_) then
@ -519,13 +531,13 @@ subroutine mld_daggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_re
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'starting sphalo/ rwxtd' & 'starting sphalo/ rwxtd'
call psb_symbmm(a,op_prol,am3,info) call psb_symbmm(a,tmp_prol,am3,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_from_subroutine_,name,& call psb_errpush(psb_err_from_subroutine_,name,&
& a_err='symbmm 2') & a_err='symbmm 2')
goto 9999 goto 9999
end if end if
call psb_numbmm(a,op_prol,am3) call psb_numbmm(a,tmp_prol,am3)
if (debug_level >= psb_debug_outer_) & if (debug_level >= psb_debug_outer_) &
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'Done NUMBMM 2' & 'Done NUMBMM 2'

24
mlprec/impl/mld_daggrmat_nosmth_asb.f90
Unescape Escape View File

@ -52,6 +52,9 @@
! The coarse-level matrix A_C is distributed among the parallel processes or ! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat ! replicated on each of them, according to the value of p%parms%coarse_mat
! specified by the user through mld_dprecinit and mld_zprecset. ! specified by the user through mld_dprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_d_lev_aggrmat_asb.
! !
! For details see ! For details see
! P. D'Ambra, D. di Serafino and S. Filippone, On the development of ! P. D'Ambra, D. di Serafino and S. Filippone, On the development of
@ -59,7 +62,6 @@
! 57 (2007), 1181-1196. ! 57 (2007), 1181-1196.
! !
! !
!
! Arguments: ! Arguments:
! a - type(psb_dspmat_type), input. ! a - type(psb_dspmat_type), input.
! The sparse matrix structure containing the local part of ! The sparse matrix structure containing the local part of
@ -70,17 +72,31 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_dml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_dspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_dspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_dspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !
!
subroutine mld_daggrmat_nosmth_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info) subroutine mld_daggrmat_nosmth_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info)
use psb_base_mod use psb_base_mod
use mld_d_inner_mod, mld_protect_name => mld_daggrmat_nosmth_asb use mld_d_inner_mod, mld_protect_name => mld_daggrmat_nosmth_asb

23
mlprec/impl/mld_daggrmat_smth_asb.f90
Unescape Escape View File

@ -64,6 +64,9 @@
! The coarse-level matrix A_C is distributed among the parallel processes or ! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat, ! replicated on each of them, according to the value of p%parms%coarse_mat,
! specified by the user through mld_dprecinit and mld_zprecset. ! specified by the user through mld_dprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_d_lev_aggrmat_asb.
! !
! For more details see ! For more details see
! M. Brezina and P. Vanek, A black-box iterative solver based on a ! M. Brezina and P. Vanek, A black-box iterative solver based on a
@ -72,6 +75,7 @@
! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math. ! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math.
! 57 (2007), 1181-1196. ! 57 (2007), 1181-1196.
! !
!
! Arguments: ! Arguments:
! a - type(psb_dspmat_type), input. ! a - type(psb_dspmat_type), input.
! The sparse matrix structure containing the local part of ! The sparse matrix structure containing the local part of
@ -82,14 +86,27 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_dml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_dspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_dspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_dspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

3
mlprec/impl/mld_dmlprec_bld.f90
Unescape Escape View File

@ -50,6 +50,9 @@
! The levels are numbered in increasing order starting from the finest one, i.e. ! The levels are numbered in increasing order starting from the finest one, i.e.
! level 1 is the finest level. No transfer operators are associated to level 1. ! level 1 is the finest level. No transfer operators are associated to level 1.
! !
! This routine simply calls mld_d_hierarchy_bld and mld_d_smoothers_bld; they
! can also be called explicitly from the user.
!
! !
! Arguments: ! Arguments:
! a - type(psb_dspmat_type). ! a - type(psb_dspmat_type).

33
mlprec/impl/mld_s_dec_map_bld.f90
Unescape Escape View File

@ -36,7 +36,38 @@
!!$ POSSIBILITY OF SUCH DAMAGE. !!$ POSSIBILITY OF SUCH DAMAGE.
!!$ !!$
!!$ !!$
!
! File: mld_s_dec_map__bld.f90
!
! Subroutine: mld_s_dec_map_bld
! Version: real
!
! This routine builds the tentative prolongator based on the
! decoupled aggregation algorithm presented in
!
! M. Brezina and P. Vanek, A black-box iterative solver based on a
! two-level Schwarz method, Computing, 63 (1999), 233-263.
! P. D'Ambra, D. di Serafino and S. Filippone, On the development of
! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math.
! 57 (2007), 1181-1196.
!
! Note: upon exit
!
! Arguments:
! a - type(psb_sspmat_type).
! The sparse matrix structure containing the local part of the
! matrix to be preconditioned.
! desc_a - type(psb_desc_type), input.
! The communication descriptor of a.
! p - type(mld_sprec_type), input/output.
! The preconditioner data structure; upon exit it contains
! the multilevel hierarchy of prolongators, restrictors
! and coarse matrices.
! info - integer, output.
! Error code.
!
!
!
subroutine mld_s_dec_map_bld(iorder,theta,a,desc_a,nlaggr,ilaggr,info) subroutine mld_s_dec_map_bld(iorder,theta,a,desc_a,nlaggr,ilaggr,info)
use psb_base_mod use psb_base_mod

5
mlprec/impl/mld_s_hierarchy_bld.f90
Unescape Escape View File

@ -58,8 +58,9 @@
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
! The communication descriptor of a. ! The communication descriptor of a.
! p - type(mld_sprec_type), input/output. ! p - type(mld_sprec_type), input/output.
! The preconditioner data structure containing the local part ! The preconditioner data structure; upon exit it contains
! of the preconditioner to be built. ! the multilevel hierarchy of prolongators, restrictors
! and coarse matrices.
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

38
mlprec/impl/mld_s_lev_aggrmap_bld.f90
Unescape Escape View File

@ -36,32 +36,40 @@
!!$ POSSIBILITY OF SUCH DAMAGE. !!$ POSSIBILITY OF SUCH DAMAGE.
!!$ !!$
!!$ !!$
! File: mld_scoarse_bld.f90 ! File: mld_s_lev_aggrmap_bld.f90
! !
! Subroutine: mld_scoarse_bld ! Subroutine: mld_s_lev_aggrmap_bld
! Version: real ! Version: real
! !
! This routine builds the matrix associated to the current level of the ! This routine is just an interface to aggrmap_bld where the real work is performed.
! multilevel preconditioner from the matrix associated to the previous level, ! It takes care of some consistency checking though.
! by using a smoothed aggregation technique (therefore, it also builds the !
! prolongation and restriction operators mapping the current level to the ! See mld_saggrmap_bld for constraints on input/oput arguments.
! previous one and vice versa). Then the routine builds the base preconditioner
! at the current level.
! The current level is regarded as the coarse one, while the previous as
! the fine one. This is in agreement with the fact that the routine is called,
! by mld_mlprec_bld, only on levels >=2.
! !
! !
! Arguments: ! Arguments:
! p - type(mld_s_onelev_type), input/output.
! The 'one-level' data structure containing the control
! parameters and (eventually) coarse matrix and prolongator/restrictors.
!
! a - type(psb_sspmat_type). ! a - type(psb_sspmat_type).
! The sparse matrix structure containing the local part of the ! The sparse matrix structure containing the local part of the
! fine-level matrix. ! fine-level matrix.
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
! The communication descriptor of a. ! The communication descriptor of a.
! p - type(mld_s_onelev_type), input/output. ! ilaggr - integer, dimension(:), allocatable, output
! The 'one-level' data structure containing the local part ! The mapping between the row indices of the coarse-level
! of the base preconditioner to be built as well as ! matrix and the row indices of the fine-level matrix.
! information concerning the prolongator and its transpose. ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. Note that on exit the indices
! will be shifted so as to make sure the ranges on the various processes do not
! overlap.
! nlaggr - integer, dimension(:), allocatable, output
! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_sspmat_type), output
! The tentative prolongator, based on ilaggr.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

37
mlprec/impl/mld_s_lev_aggrmat_asb.f90
Unescape Escape View File

@ -36,32 +36,51 @@
!!$ POSSIBILITY OF SUCH DAMAGE. !!$ POSSIBILITY OF SUCH DAMAGE.
!!$ !!$
!!$ !!$
! File: mld_scoarse_bld.f90 ! File: mld_s_lev_aggrmat_asb.f90
! !
! Subroutine: mld_scoarse_bld ! Subroutine: mld_s_lev_aggrmat_asb
! Version: real ! Version: real
! !
! This routine builds the matrix associated to the current level of the ! This routine builds the matrix associated to the current level of the
! multilevel preconditioner from the matrix associated to the previous level, ! multilevel preconditioner from the matrix associated to the previous level,
! by using a smoothed aggregation technique (therefore, it also builds the ! by using the user-specified aggregation technique (therefore, it also builds the
! prolongation and restriction operators mapping the current level to the ! prolongation and restriction operators mapping the current level to the
! previous one and vice versa). Then the routine builds the base preconditioner ! previous one and vice versa).
! at the current level.
! The current level is regarded as the coarse one, while the previous as ! The current level is regarded as the coarse one, while the previous as
! the fine one. This is in agreement with the fact that the routine is called, ! the fine one. This is in agreement with the fact that the routine is called,
! by mld_mlprec_bld, only on levels >=2. ! by mld_mlprec_bld, only on levels >=2.
! The main structure is:
! 1. Perform sanity checks;
! 2. Call mld_Xaggrmat_asb to compute prolongator/restrictor/AC
! 3. According to the choice of DIST/REPL for AC, build a descriptor DESC_AC,
! and adjust the column numbering of AC/OP_PROL/OP_RESTR
! 4. Pack restrictor and prolongator into p%map
! 5. Fix base_a and base_desc pointers.
! !
! !
! Arguments: ! Arguments:
! p - type(mld_s_onelev_type), input/output.
! The 'one-level' data structure containing the control
! parameters and (eventually) coarse matrix and prolongator/restrictors.
!
! a - type(psb_sspmat_type). ! a - type(psb_sspmat_type).
! The sparse matrix structure containing the local part of the ! The sparse matrix structure containing the local part of the
! fine-level matrix. ! fine-level matrix.
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
! The communication descriptor of a. ! The communication descriptor of a.
! p - type(mld_s_onelev_type), input/output. ! ilaggr - integer, dimension(:), input
! The 'one-level' data structure containing the local part ! The mapping between the row indices of the coarse-level
! of the base preconditioner to be built as well as ! matrix and the row indices of the fine-level matrix.
! information concerning the prolongator and its transpose. ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. Note that the indices
! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_sspmat_type), input/output
! The tentative prolongator on input, released on output.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

8
mlprec/impl/mld_s_smoothers_bld.f90
Unescape Escape View File

@ -41,14 +41,18 @@
! Subroutine: mld_s_smoothers_bld ! Subroutine: mld_s_smoothers_bld
! Version: real ! Version: real
! !
! This routine builds the preconditioner according to the requirements made by ! This routine performs the final phase of the multilevel preconditioner build process:
! the user trough the subroutines mld_precinit and mld_precset. ! builds the "smoother" objects at each level, based on the matrix hierarchy prepared
! by mld_s_hierarchy_bld.
! !
! A multilevel preconditioner is regarded as an array of 'one-level' data structures, ! A multilevel preconditioner is regarded as an array of 'one-level' data structures,
! each containing the part of the preconditioner associated to a certain level, ! each containing the part of the preconditioner associated to a certain level,
! (for more details see the description of mld_Tonelev_type in mld_prec_type.f90). ! (for more details see the description of mld_Tonelev_type in mld_prec_type.f90).
! The levels are numbered in increasing order starting from the finest one, i.e. ! The levels are numbered in increasing order starting from the finest one, i.e.
! level 1 is the finest level. No transfer operators are associated to level 1. ! level 1 is the finest level. No transfer operators are associated to level 1.
! Each level provides a "build" method; for the base type, the "one-level"
! build procedure simply invokes the build method of the first smoother object,
! and also on the second object if allocated.
! !
! !
! Arguments: ! Arguments:

7
mlprec/impl/mld_saggrmap_bld.f90
Unescape Escape View File

@ -73,9 +73,14 @@
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that on exit the indices
! will be shifted so as to make sure the ranges on the various processes do not
! overlap.
! nlaggr - integer, dimension(:), allocatable. ! nlaggr - integer, dimension(:), allocatable.
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_sspmat_type).
! The tentative prolongator, based on ilaggr.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

32
mlprec/impl/mld_saggrmat_asb.f90
Unescape Escape View File

@ -53,12 +53,16 @@
! The prolongator P_C is built here from this mapping, according to the ! The prolongator P_C is built here from this mapping, according to the
! value of p%iprcparm(mld_aggr_kind_), specified by the user through ! value of p%iprcparm(mld_aggr_kind_), specified by the user through
! mld_sprecinit and mld_zprecset. ! mld_sprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_s_lev_aggrmat_asb.
! !
! Currently three different prolongators are implemented, corresponding to ! Currently four different prolongators are implemented, corresponding to
! three aggregation algorithms: ! four aggregation algorithms:
! 1. non-smoothed aggregation, ! 1. un-smoothed aggregation,
! 2. smoothed aggregation, ! 2. smoothed aggregation,
! 3. "bizarre" aggregation. ! 3. "bizarre" aggregation.
! 4. minimum energy
! 1. The non-smoothed aggregation uses as prolongator the piecewise constant ! 1. The non-smoothed aggregation uses as prolongator the piecewise constant
! interpolation operator corresponding to the fine-to-coarse level mapping built ! interpolation operator corresponding to the fine-to-coarse level mapping built
! by mld_aggrmap_bld. This is called tentative prolongator. ! by mld_aggrmap_bld. This is called tentative prolongator.
@ -67,6 +71,7 @@
! 3. The "bizarre" aggregation uses a prolongator proposed by the authors of MLD2P4. ! 3. The "bizarre" aggregation uses a prolongator proposed by the authors of MLD2P4.
! This prolongator still requires a deep analysis and testing and its use is ! This prolongator still requires a deep analysis and testing and its use is
! not recommended. ! not recommended.
! 4. Minimum energy aggregation: ADD REFERENCE.
! !
! For more details see ! For more details see
! M. Brezina and P. Vanek, A black-box iterative solver based on a two-level ! M. Brezina and P. Vanek, A black-box iterative solver based on a two-level
@ -78,7 +83,7 @@
! !
! !
! Arguments: ! Arguments:
! a - type(psb_cspmat_type), input. ! a - type(psb_sspmat_type), input.
! The sparse matrix structure containing the local part of ! The sparse matrix structure containing the local part of
! the fine-level matrix. ! the fine-level matrix.
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
@ -87,14 +92,27 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_sml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_sspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_sspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_sspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

17
mlprec/impl/mld_saggrmat_biz_asb.f90
Unescape Escape View File

@ -56,6 +56,9 @@
! The coarse-level matrix A_C is distributed among the parallel processes or ! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat, ! replicated on each of them, according to the value of p%parms%coarse_mat,
! specified by the user through mld_sprecinit and mld_zprecset. ! specified by the user through mld_sprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_s_lev_aggrmat_asb.
! !
! Arguments: ! Arguments:
! a - type(psb_sspmat_type), input. ! a - type(psb_sspmat_type), input.
@ -98,7 +101,7 @@ subroutine mld_saggrmat_biz_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr
& naggr, nzl,naggrm1,naggrp1, i, j, k, jd, icolF, nrw, err_act & naggr, nzl,naggrm1,naggrp1, i, j, k, jd, icolF, nrw, err_act
integer(psb_ipk_) ::ictxt, np, me integer(psb_ipk_) ::ictxt, np, me
character(len=20) :: name character(len=20) :: name
type(psb_sspmat_type) :: am3, am4 type(psb_sspmat_type) :: am3, am4,tmp_prol
type(psb_s_coo_sparse_mat) :: tmpcoo type(psb_s_coo_sparse_mat) :: tmpcoo
type(psb_s_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsrf, ptilde type(psb_s_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsrf, ptilde
real(psb_spk_), allocatable :: adiag(:) real(psb_spk_), allocatable :: adiag(:)
@ -321,29 +324,29 @@ subroutine mld_saggrmat_biz_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr
call acsr1%set_dupl(psb_dupl_add_) call acsr1%set_dupl(psb_dupl_add_)
call op_prol%mv_from(acsr1) call op_prol%mv_from(acsr1)
call op_prol%clone(tmp_prol,info)
call psb_rwextd(ncol,op_prol,info) call psb_rwextd(ncol,tmp_prol,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_internal_error_,name,a_err='Halo of op_prol') call psb_errpush(psb_err_internal_error_,name,a_err='Halo of op_prol')
goto 9999 goto 9999
end if end if
call psb_symbmm(a,op_prol,am3,info) call psb_symbmm(a,tmp_prol,am3,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_from_subroutine_,name,a_err='symbmm 2') call psb_errpush(psb_err_from_subroutine_,name,a_err='symbmm 2')
goto 9999 goto 9999
end if end if
call psb_numbmm(a,op_prol,am3) call psb_numbmm(a,tmp_prol,am3)
if (debug_level >= psb_debug_outer_) & if (debug_level >= psb_debug_outer_) &
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'Done NUMBMM 2',parms%aggr_kind, mld_smooth_prol_ & 'Done NUMBMM 2',parms%aggr_kind, mld_smooth_prol_
call op_prol%transp(op_restr) call tmp_prol%transp(op_restr)
if (debug_level >= psb_debug_outer_) & if (debug_level >= psb_debug_outer_) &
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'starting sphalo/ rwxtd' & 'starting sphalo/ rwxtd'
call tmp_prol%free()
call psb_rwextd(ncol,am3,info) call psb_rwextd(ncol,am3,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_internal_error_,name,a_err='Extend am3') call psb_errpush(psb_err_internal_error_,name,a_err='Extend am3')

54
mlprec/impl/mld_saggrmat_minnrg_asb.f90
Unescape Escape View File

@ -60,22 +60,19 @@
! radius of D^(-1)A, to be used in the computation of omega, is provided, ! radius of D^(-1)A, to be used in the computation of omega, is provided,
! according to the value of p%parms%aggr_omega_alg, specified by the user ! according to the value of p%parms%aggr_omega_alg, specified by the user
! through mld_sprecinit and mld_sprecset. ! through mld_sprecinit and mld_sprecset.
! 4. Minimum energy aggregation: ADD REFERENCE.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_s_lev_aggrmat_asb.
! !
! This routine can also build A_C according to a "bizarre" aggregation algorithm, ! For more details see
! using a "naive" prolongator proposed by the authors of MLD2P4. However, this ! M. Brezina and P. Vanek, A black-box iterative solver based on a two-level
! prolongator still requires a deep analysis and testing and its use is not ! Schwarz method, Computing, 63 (1999), 233-263.
! recommended. ! P. D'Ambra, D. di Serafino and S. Filippone, On the development of PSBLAS-based
! parallel two-level Schwarz preconditioners, Appl. Num. Math., 57 (2007),
! 1181-1196.
! !
! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat,
! specified by the user through mld_sprecinit and mld_zprecset.
! !
! For more details see
! M. Brezina and P. Vanek, A black-box iterative solver based on a
! two-level Schwarz method, Computing, 63 (1999), 233-263.
! P. D'Ambra, D. di Serafino and S. Filippone, On the development of
! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math.
! 57 (2007), 1181-1196.
! !
! Arguments: ! Arguments:
! a - type(psb_sspmat_type), input. ! a - type(psb_sspmat_type), input.
@ -87,17 +84,31 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_sml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_sspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_sspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_sspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !
!
subroutine mld_saggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info) subroutine mld_saggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info)
use psb_base_mod use psb_base_mod
use mld_s_inner_mod, mld_protect_name => mld_saggrmat_minnrg_asb use mld_s_inner_mod, mld_protect_name => mld_saggrmat_minnrg_asb
@ -121,7 +132,7 @@ subroutine mld_saggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_re
character(len=20) :: name character(len=20) :: name
type(psb_sspmat_type) :: af, ptilde, rtilde, atran, atp, atdatp type(psb_sspmat_type) :: af, ptilde, rtilde, atran, atp, atdatp
type(psb_sspmat_type) :: am3,am4, ap, adap,atmp,rada, ra, atmp2, dap, dadap, da type(psb_sspmat_type) :: am3,am4, ap, adap,atmp,rada, ra, atmp2, dap, dadap, da
type(psb_sspmat_type) :: dat, datp, datdatp, atmp3 type(psb_sspmat_type) :: dat, datp, datdatp, atmp3, tmp_prol
type(psb_s_coo_sparse_mat) :: tmpcoo type(psb_s_coo_sparse_mat) :: tmpcoo
type(psb_s_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsr, acsrf type(psb_s_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsr, acsrf
type(psb_s_csc_sparse_mat) :: csc_dap, csc_dadap, csc_datp, csc_datdatp, acsc type(psb_s_csc_sparse_mat) :: csc_dap, csc_dadap, csc_datp, csc_datdatp, acsc
@ -484,9 +495,10 @@ subroutine mld_saggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_re
! Now we have to gather the halo of op_prol, and add it to itself ! Now we have to gather the halo of op_prol, and add it to itself
! to multiply it by A, ! to multiply it by A,
! !
call psb_sphalo(op_prol,desc_a,am4,info,& call op_prol%clone(tmp_prol,info)
if (info == psb_success_) call psb_sphalo(tmp_prol,desc_a,am4,info,&
& colcnv=.false.,rowscale=.true.) & colcnv=.false.,rowscale=.true.)
if (info == psb_success_) call psb_rwextd(ncol,op_prol,info,b=am4) if (info == psb_success_) call psb_rwextd(ncol,tmp_prol,info,b=am4)
if (info == psb_success_) call am4%free() if (info == psb_success_) call am4%free()
if(info /= psb_success_) then if(info /= psb_success_) then
@ -519,13 +531,13 @@ subroutine mld_saggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_re
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'starting sphalo/ rwxtd' & 'starting sphalo/ rwxtd'
call psb_symbmm(a,op_prol,am3,info) call psb_symbmm(a,tmp_prol,am3,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_from_subroutine_,name,& call psb_errpush(psb_err_from_subroutine_,name,&
& a_err='symbmm 2') & a_err='symbmm 2')
goto 9999 goto 9999
end if end if
call psb_numbmm(a,op_prol,am3) call psb_numbmm(a,tmp_prol,am3)
if (debug_level >= psb_debug_outer_) & if (debug_level >= psb_debug_outer_) &
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'Done NUMBMM 2' & 'Done NUMBMM 2'

24
mlprec/impl/mld_saggrmat_nosmth_asb.f90
Unescape Escape View File

@ -52,6 +52,9 @@
! The coarse-level matrix A_C is distributed among the parallel processes or ! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat ! replicated on each of them, according to the value of p%parms%coarse_mat
! specified by the user through mld_sprecinit and mld_zprecset. ! specified by the user through mld_sprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_s_lev_aggrmat_asb.
! !
! For details see ! For details see
! P. D'Ambra, D. di Serafino and S. Filippone, On the development of ! P. D'Ambra, D. di Serafino and S. Filippone, On the development of
@ -59,7 +62,6 @@
! 57 (2007), 1181-1196. ! 57 (2007), 1181-1196.
! !
! !
!
! Arguments: ! Arguments:
! a - type(psb_sspmat_type), input. ! a - type(psb_sspmat_type), input.
! The sparse matrix structure containing the local part of ! The sparse matrix structure containing the local part of
@ -70,17 +72,31 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_sml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_sspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_sspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_sspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !
!
subroutine mld_saggrmat_nosmth_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info) subroutine mld_saggrmat_nosmth_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info)
use psb_base_mod use psb_base_mod
use mld_s_inner_mod, mld_protect_name => mld_saggrmat_nosmth_asb use mld_s_inner_mod, mld_protect_name => mld_saggrmat_nosmth_asb

23
mlprec/impl/mld_saggrmat_smth_asb.f90
Unescape Escape View File

@ -64,6 +64,9 @@
! The coarse-level matrix A_C is distributed among the parallel processes or ! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat, ! replicated on each of them, according to the value of p%parms%coarse_mat,
! specified by the user through mld_sprecinit and mld_zprecset. ! specified by the user through mld_sprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_s_lev_aggrmat_asb.
! !
! For more details see ! For more details see
! M. Brezina and P. Vanek, A black-box iterative solver based on a ! M. Brezina and P. Vanek, A black-box iterative solver based on a
@ -72,6 +75,7 @@
! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math. ! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math.
! 57 (2007), 1181-1196. ! 57 (2007), 1181-1196.
! !
!
! Arguments: ! Arguments:
! a - type(psb_sspmat_type), input. ! a - type(psb_sspmat_type), input.
! The sparse matrix structure containing the local part of ! The sparse matrix structure containing the local part of
@ -82,14 +86,27 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_sml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_sspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_sspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_sspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

3
mlprec/impl/mld_smlprec_bld.f90
Unescape Escape View File

@ -50,6 +50,9 @@
! The levels are numbered in increasing order starting from the finest one, i.e. ! The levels are numbered in increasing order starting from the finest one, i.e.
! level 1 is the finest level. No transfer operators are associated to level 1. ! level 1 is the finest level. No transfer operators are associated to level 1.
! !
! This routine simply calls mld_s_hierarchy_bld and mld_s_smoothers_bld; they
! can also be called explicitly from the user.
!
! !
! Arguments: ! Arguments:
! a - type(psb_sspmat_type). ! a - type(psb_sspmat_type).

33
mlprec/impl/mld_z_dec_map_bld.f90
Unescape Escape View File

@ -36,7 +36,38 @@
!!$ POSSIBILITY OF SUCH DAMAGE. !!$ POSSIBILITY OF SUCH DAMAGE.
!!$ !!$
!!$ !!$
!
! File: mld_z_dec_map__bld.f90
!
! Subroutine: mld_z_dec_map_bld
! Version: complex
!
! This routine builds the tentative prolongator based on the
! decoupled aggregation algorithm presented in
!
! M. Brezina and P. Vanek, A black-box iterative solver based on a
! two-level Schwarz method, Computing, 63 (1999), 233-263.
! P. D'Ambra, D. di Serafino and S. Filippone, On the development of
! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math.
! 57 (2007), 1181-1196.
!
! Note: upon exit
!
! Arguments:
! a - type(psb_zspmat_type).
! The sparse matrix structure containing the local part of the
! matrix to be preconditioned.
! desc_a - type(psb_desc_type), input.
! The communication descriptor of a.
! p - type(mld_zprec_type), input/output.
! The preconditioner data structure; upon exit it contains
! the multilevel hierarchy of prolongators, restrictors
! and coarse matrices.
! info - integer, output.
! Error code.
!
!
!
subroutine mld_z_dec_map_bld(iorder,theta,a,desc_a,nlaggr,ilaggr,info) subroutine mld_z_dec_map_bld(iorder,theta,a,desc_a,nlaggr,ilaggr,info)
use psb_base_mod use psb_base_mod

5
mlprec/impl/mld_z_hierarchy_bld.f90
Unescape Escape View File

@ -58,8 +58,9 @@
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
! The communication descriptor of a. ! The communication descriptor of a.
! p - type(mld_zprec_type), input/output. ! p - type(mld_zprec_type), input/output.
! The preconditioner data structure containing the local part ! The preconditioner data structure; upon exit it contains
! of the preconditioner to be built. ! the multilevel hierarchy of prolongators, restrictors
! and coarse matrices.
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

40
mlprec/impl/mld_z_lev_aggrmap_bld.f90
Unescape Escape View File

@ -36,32 +36,40 @@
!!$ POSSIBILITY OF SUCH DAMAGE. !!$ POSSIBILITY OF SUCH DAMAGE.
!!$ !!$
!!$ !!$
! File: mld_zcoarse_bld.f90 ! File: mld_z_lev_aggrmap_bld.f90
! !
! Subroutine: mld_zcoarse_bld ! Subroutine: mld_z_lev_aggrmap_bld
! Version: real ! Version: complex
! !
! This routine builds the matrix associated to the current level of the ! This routine is just an interface to aggrmap_bld where the real work is performed.
! multilevel preconditioner from the matrix associated to the previous level, ! It takes care of some consistency checking though.
! by using a smoothed aggregation technique (therefore, it also builds the !
! prolongation and restriction operators mapping the current level to the ! See mld_zaggrmap_bld for constraints on input/oput arguments.
! previous one and vice versa). Then the routine builds the base preconditioner
! at the current level.
! The current level is regarded as the coarse one, while the previous as
! the fine one. This is in agreement with the fact that the routine is called,
! by mld_mlprec_bld, only on levels >=2.
! !
! !
! Arguments: ! Arguments:
! p - type(mld_z_onelev_type), input/output.
! The 'one-level' data structure containing the control
! parameters and (eventually) coarse matrix and prolongator/restrictors.
!
! a - type(psb_zspmat_type). ! a - type(psb_zspmat_type).
! The sparse matrix structure containing the local part of the ! The sparse matrix structure containing the local part of the
! fine-level matrix. ! fine-level matrix.
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
! The communication descriptor of a. ! The communication descriptor of a.
! p - type(mld_z_onelev_type), input/output. ! ilaggr - integer, dimension(:), allocatable, output
! The 'one-level' data structure containing the local part ! The mapping between the row indices of the coarse-level
! of the base preconditioner to be built as well as ! matrix and the row indices of the fine-level matrix.
! information concerning the prolongator and its transpose. ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. Note that on exit the indices
! will be shifted so as to make sure the ranges on the various processes do not
! overlap.
! nlaggr - integer, dimension(:), allocatable, output
! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_zspmat_type), output
! The tentative prolongator, based on ilaggr.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

39
mlprec/impl/mld_z_lev_aggrmat_asb.f90
Unescape Escape View File

@ -36,32 +36,51 @@
!!$ POSSIBILITY OF SUCH DAMAGE. !!$ POSSIBILITY OF SUCH DAMAGE.
!!$ !!$
!!$ !!$
! File: mld_zcoarse_bld.f90 ! File: mld_z_lev_aggrmat_asb.f90
! !
! Subroutine: mld_zcoarse_bld ! Subroutine: mld_z_lev_aggrmat_asb
! Version: real ! Version: complex
! !
! This routine builds the matrix associated to the current level of the ! This routine builds the matrix associated to the current level of the
! multilevel preconditioner from the matrix associated to the previous level, ! multilevel preconditioner from the matrix associated to the previous level,
! by using a smoothed aggregation technique (therefore, it also builds the ! by using the user-specified aggregation technique (therefore, it also builds the
! prolongation and restriction operators mapping the current level to the ! prolongation and restriction operators mapping the current level to the
! previous one and vice versa). Then the routine builds the base preconditioner ! previous one and vice versa).
! at the current level.
! The current level is regarded as the coarse one, while the previous as ! The current level is regarded as the coarse one, while the previous as
! the fine one. This is in agreement with the fact that the routine is called, ! the fine one. This is in agreement with the fact that the routine is called,
! by mld_mlprec_bld, only on levels >=2. ! by mld_mlprec_bld, only on levels >=2.
! The main structure is:
! 1. Perform sanity checks;
! 2. Call mld_Xaggrmat_asb to compute prolongator/restrictor/AC
! 3. According to the choice of DIST/REPL for AC, build a descriptor DESC_AC,
! and adjust the column numbering of AC/OP_PROL/OP_RESTR
! 4. Pack restrictor and prolongator into p%map
! 5. Fix base_a and base_desc pointers.
! !
! !
! Arguments: ! Arguments:
! p - type(mld_z_onelev_type), input/output.
! The 'one-level' data structure containing the control
! parameters and (eventually) coarse matrix and prolongator/restrictors.
!
! a - type(psb_zspmat_type). ! a - type(psb_zspmat_type).
! The sparse matrix structure containing the local part of the ! The sparse matrix structure containing the local part of the
! fine-level matrix. ! fine-level matrix.
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
! The communication descriptor of a. ! The communication descriptor of a.
! p - type(mld_z_onelev_type), input/output. ! ilaggr - integer, dimension(:), input
! The 'one-level' data structure containing the local part ! The mapping between the row indices of the coarse-level
! of the base preconditioner to be built as well as ! matrix and the row indices of the fine-level matrix.
! information concerning the prolongator and its transpose. ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. Note that the indices
! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_zspmat_type), input/output
! The tentative prolongator on input, released on output.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

8
mlprec/impl/mld_z_smoothers_bld.f90
Unescape Escape View File

@ -41,14 +41,18 @@
! Subroutine: mld_z_smoothers_bld ! Subroutine: mld_z_smoothers_bld
! Version: complex ! Version: complex
! !
! This routine builds the preconditioner according to the requirements made by ! This routine performs the final phase of the multilevel preconditioner build process:
! the user trough the subroutines mld_precinit and mld_precset. ! builds the "smoother" objects at each level, based on the matrix hierarchy prepared
! by mld_z_hierarchy_bld.
! !
! A multilevel preconditioner is regarded as an array of 'one-level' data structures, ! A multilevel preconditioner is regarded as an array of 'one-level' data structures,
! each containing the part of the preconditioner associated to a certain level, ! each containing the part of the preconditioner associated to a certain level,
! (for more details see the description of mld_Tonelev_type in mld_prec_type.f90). ! (for more details see the description of mld_Tonelev_type in mld_prec_type.f90).
! The levels are numbered in increasing order starting from the finest one, i.e. ! The levels are numbered in increasing order starting from the finest one, i.e.
! level 1 is the finest level. No transfer operators are associated to level 1. ! level 1 is the finest level. No transfer operators are associated to level 1.
! Each level provides a "build" method; for the base type, the "one-level"
! build procedure simply invokes the build method of the first smoother object,
! and also on the second object if allocated.
! !
! !
! Arguments: ! Arguments:

7
mlprec/impl/mld_zaggrmap_bld.f90
Unescape Escape View File

@ -73,9 +73,14 @@
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that on exit the indices
! will be shifted so as to make sure the ranges on the various processes do not
! overlap.
! nlaggr - integer, dimension(:), allocatable. ! nlaggr - integer, dimension(:), allocatable.
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_zspmat_type).
! The tentative prolongator, based on ilaggr.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

32
mlprec/impl/mld_zaggrmat_asb.f90
Unescape Escape View File

@ -53,12 +53,16 @@
! The prolongator P_C is built here from this mapping, according to the ! The prolongator P_C is built here from this mapping, according to the
! value of p%iprcparm(mld_aggr_kind_), specified by the user through ! value of p%iprcparm(mld_aggr_kind_), specified by the user through
! mld_zprecinit and mld_zprecset. ! mld_zprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_z_lev_aggrmat_asb.
! !
! Currently three different prolongators are implemented, corresponding to ! Currently four different prolongators are implemented, corresponding to
! three aggregation algorithms: ! four aggregation algorithms:
! 1. non-smoothed aggregation, ! 1. un-smoothed aggregation,
! 2. smoothed aggregation, ! 2. smoothed aggregation,
! 3. "bizarre" aggregation. ! 3. "bizarre" aggregation.
! 4. minimum energy
! 1. The non-smoothed aggregation uses as prolongator the piecewise constant ! 1. The non-smoothed aggregation uses as prolongator the piecewise constant
! interpolation operator corresponding to the fine-to-coarse level mapping built ! interpolation operator corresponding to the fine-to-coarse level mapping built
! by mld_aggrmap_bld. This is called tentative prolongator. ! by mld_aggrmap_bld. This is called tentative prolongator.
@ -67,6 +71,7 @@
! 3. The "bizarre" aggregation uses a prolongator proposed by the authors of MLD2P4. ! 3. The "bizarre" aggregation uses a prolongator proposed by the authors of MLD2P4.
! This prolongator still requires a deep analysis and testing and its use is ! This prolongator still requires a deep analysis and testing and its use is
! not recommended. ! not recommended.
! 4. Minimum energy aggregation: ADD REFERENCE.
! !
! For more details see ! For more details see
! M. Brezina and P. Vanek, A black-box iterative solver based on a two-level ! M. Brezina and P. Vanek, A black-box iterative solver based on a two-level
@ -78,7 +83,7 @@
! !
! !
! Arguments: ! Arguments:
! a - type(psb_cspmat_type), input. ! a - type(psb_zspmat_type), input.
! The sparse matrix structure containing the local part of ! The sparse matrix structure containing the local part of
! the fine-level matrix. ! the fine-level matrix.
! desc_a - type(psb_desc_type), input. ! desc_a - type(psb_desc_type), input.
@ -87,14 +92,27 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_dml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_zspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_zspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_zspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

17
mlprec/impl/mld_zaggrmat_biz_asb.f90
Unescape Escape View File

@ -56,6 +56,9 @@
! The coarse-level matrix A_C is distributed among the parallel processes or ! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat, ! replicated on each of them, according to the value of p%parms%coarse_mat,
! specified by the user through mld_zprecinit and mld_zprecset. ! specified by the user through mld_zprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_z_lev_aggrmat_asb.
! !
! Arguments: ! Arguments:
! a - type(psb_zspmat_type), input. ! a - type(psb_zspmat_type), input.
@ -98,7 +101,7 @@ subroutine mld_zaggrmat_biz_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr
& naggr, nzl,naggrm1,naggrp1, i, j, k, jd, icolF, nrw, err_act & naggr, nzl,naggrm1,naggrp1, i, j, k, jd, icolF, nrw, err_act
integer(psb_ipk_) ::ictxt, np, me integer(psb_ipk_) ::ictxt, np, me
character(len=20) :: name character(len=20) :: name
type(psb_zspmat_type) :: am3, am4 type(psb_zspmat_type) :: am3, am4,tmp_prol
type(psb_z_coo_sparse_mat) :: tmpcoo type(psb_z_coo_sparse_mat) :: tmpcoo
type(psb_z_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsrf, ptilde type(psb_z_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsrf, ptilde
complex(psb_dpk_), allocatable :: adiag(:) complex(psb_dpk_), allocatable :: adiag(:)
@ -321,29 +324,29 @@ subroutine mld_zaggrmat_biz_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr
call acsr1%set_dupl(psb_dupl_add_) call acsr1%set_dupl(psb_dupl_add_)
call op_prol%mv_from(acsr1) call op_prol%mv_from(acsr1)
call op_prol%clone(tmp_prol,info)
call psb_rwextd(ncol,op_prol,info) call psb_rwextd(ncol,tmp_prol,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_internal_error_,name,a_err='Halo of op_prol') call psb_errpush(psb_err_internal_error_,name,a_err='Halo of op_prol')
goto 9999 goto 9999
end if end if
call psb_symbmm(a,op_prol,am3,info) call psb_symbmm(a,tmp_prol,am3,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_from_subroutine_,name,a_err='symbmm 2') call psb_errpush(psb_err_from_subroutine_,name,a_err='symbmm 2')
goto 9999 goto 9999
end if end if
call psb_numbmm(a,op_prol,am3) call psb_numbmm(a,tmp_prol,am3)
if (debug_level >= psb_debug_outer_) & if (debug_level >= psb_debug_outer_) &
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'Done NUMBMM 2',parms%aggr_kind, mld_smooth_prol_ & 'Done NUMBMM 2',parms%aggr_kind, mld_smooth_prol_
call op_prol%transp(op_restr) call tmp_prol%transp(op_restr)
if (debug_level >= psb_debug_outer_) & if (debug_level >= psb_debug_outer_) &
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'starting sphalo/ rwxtd' & 'starting sphalo/ rwxtd'
call tmp_prol%free()
call psb_rwextd(ncol,am3,info) call psb_rwextd(ncol,am3,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_internal_error_,name,a_err='Extend am3') call psb_errpush(psb_err_internal_error_,name,a_err='Extend am3')

54
mlprec/impl/mld_zaggrmat_minnrg_asb.f90
Unescape Escape View File

@ -60,22 +60,19 @@
! radius of D^(-1)A, to be used in the computation of omega, is provided, ! radius of D^(-1)A, to be used in the computation of omega, is provided,
! according to the value of p%parms%aggr_omega_alg, specified by the user ! according to the value of p%parms%aggr_omega_alg, specified by the user
! through mld_zprecinit and mld_zprecset. ! through mld_zprecinit and mld_zprecset.
! 4. Minimum energy aggregation: ADD REFERENCE.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_z_lev_aggrmat_asb.
! !
! This routine can also build A_C according to a "bizarre" aggregation algorithm, ! For more details see
! using a "naive" prolongator proposed by the authors of MLD2P4. However, this ! M. Brezina and P. Vanek, A black-box iterative solver based on a two-level
! prolongator still requires a deep analysis and testing and its use is not ! Schwarz method, Computing, 63 (1999), 233-263.
! recommended. ! P. D'Ambra, D. di Serafino and S. Filippone, On the development of PSBLAS-based
! parallel two-level Schwarz preconditioners, Appl. Num. Math., 57 (2007),
! 1181-1196.
! !
! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat,
! specified by the user through mld_zprecinit and mld_zprecset.
! !
! For more details see
! M. Brezina and P. Vanek, A black-box iterative solver based on a
! two-level Schwarz method, Computing, 63 (1999), 233-263.
! P. D'Ambra, D. di Serafino and S. Filippone, On the development of
! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math.
! 57 (2007), 1181-1196.
! !
! Arguments: ! Arguments:
! a - type(psb_zspmat_type), input. ! a - type(psb_zspmat_type), input.
@ -87,17 +84,31 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_dml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_zspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_zspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_zspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !
!
subroutine mld_zaggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info) subroutine mld_zaggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info)
use psb_base_mod use psb_base_mod
use mld_z_inner_mod, mld_protect_name => mld_zaggrmat_minnrg_asb use mld_z_inner_mod, mld_protect_name => mld_zaggrmat_minnrg_asb
@ -121,7 +132,7 @@ subroutine mld_zaggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_re
character(len=20) :: name character(len=20) :: name
type(psb_zspmat_type) :: af, ptilde, rtilde, atran, atp, atdatp type(psb_zspmat_type) :: af, ptilde, rtilde, atran, atp, atdatp
type(psb_zspmat_type) :: am3,am4, ap, adap,atmp,rada, ra, atmp2, dap, dadap, da type(psb_zspmat_type) :: am3,am4, ap, adap,atmp,rada, ra, atmp2, dap, dadap, da
type(psb_zspmat_type) :: dat, datp, datdatp, atmp3 type(psb_zspmat_type) :: dat, datp, datdatp, atmp3, tmp_prol
type(psb_z_coo_sparse_mat) :: tmpcoo type(psb_z_coo_sparse_mat) :: tmpcoo
type(psb_z_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsr, acsrf type(psb_z_csr_sparse_mat) :: acsr1, acsr2, acsr3, acsr, acsrf
type(psb_z_csc_sparse_mat) :: csc_dap, csc_dadap, csc_datp, csc_datdatp, acsc type(psb_z_csc_sparse_mat) :: csc_dap, csc_dadap, csc_datp, csc_datdatp, acsc
@ -484,9 +495,10 @@ subroutine mld_zaggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_re
! Now we have to gather the halo of op_prol, and add it to itself ! Now we have to gather the halo of op_prol, and add it to itself
! to multiply it by A, ! to multiply it by A,
! !
call psb_sphalo(op_prol,desc_a,am4,info,& call op_prol%clone(tmp_prol,info)
if (info == psb_success_) call psb_sphalo(tmp_prol,desc_a,am4,info,&
& colcnv=.false.,rowscale=.true.) & colcnv=.false.,rowscale=.true.)
if (info == psb_success_) call psb_rwextd(ncol,op_prol,info,b=am4) if (info == psb_success_) call psb_rwextd(ncol,tmp_prol,info,b=am4)
if (info == psb_success_) call am4%free() if (info == psb_success_) call am4%free()
if(info /= psb_success_) then if(info /= psb_success_) then
@ -519,13 +531,13 @@ subroutine mld_zaggrmat_minnrg_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_re
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'starting sphalo/ rwxtd' & 'starting sphalo/ rwxtd'
call psb_symbmm(a,op_prol,am3,info) call psb_symbmm(a,tmp_prol,am3,info)
if(info /= psb_success_) then if(info /= psb_success_) then
call psb_errpush(psb_err_from_subroutine_,name,& call psb_errpush(psb_err_from_subroutine_,name,&
& a_err='symbmm 2') & a_err='symbmm 2')
goto 9999 goto 9999
end if end if
call psb_numbmm(a,op_prol,am3) call psb_numbmm(a,tmp_prol,am3)
if (debug_level >= psb_debug_outer_) & if (debug_level >= psb_debug_outer_) &
& write(debug_unit,*) me,' ',trim(name),& & write(debug_unit,*) me,' ',trim(name),&
& 'Done NUMBMM 2' & 'Done NUMBMM 2'

24
mlprec/impl/mld_zaggrmat_nosmth_asb.f90
Unescape Escape View File

@ -52,6 +52,9 @@
! The coarse-level matrix A_C is distributed among the parallel processes or ! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat ! replicated on each of them, according to the value of p%parms%coarse_mat
! specified by the user through mld_zprecinit and mld_zprecset. ! specified by the user through mld_zprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_z_lev_aggrmat_asb.
! !
! For details see ! For details see
! P. D'Ambra, D. di Serafino and S. Filippone, On the development of ! P. D'Ambra, D. di Serafino and S. Filippone, On the development of
@ -59,7 +62,6 @@
! 57 (2007), 1181-1196. ! 57 (2007), 1181-1196.
! !
! !
!
! Arguments: ! Arguments:
! a - type(psb_zspmat_type), input. ! a - type(psb_zspmat_type), input.
! The sparse matrix structure containing the local part of ! The sparse matrix structure containing the local part of
@ -70,17 +72,31 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_dml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_zspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_zspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_zspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !
!
subroutine mld_zaggrmat_nosmth_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info) subroutine mld_zaggrmat_nosmth_asb(a,desc_a,ilaggr,nlaggr,parms,ac,op_prol,op_restr,info)
use psb_base_mod use psb_base_mod
use mld_z_inner_mod, mld_protect_name => mld_zaggrmat_nosmth_asb use mld_z_inner_mod, mld_protect_name => mld_zaggrmat_nosmth_asb

23
mlprec/impl/mld_zaggrmat_smth_asb.f90
Unescape Escape View File

@ -64,6 +64,9 @@
! The coarse-level matrix A_C is distributed among the parallel processes or ! The coarse-level matrix A_C is distributed among the parallel processes or
! replicated on each of them, according to the value of p%parms%coarse_mat, ! replicated on each of them, according to the value of p%parms%coarse_mat,
! specified by the user through mld_zprecinit and mld_zprecset. ! specified by the user through mld_zprecinit and mld_zprecset.
! On output from this routine the entries of AC, op_prol, op_restr
! are still in "global numbering" mode; this is fixed in the calling routine
! mld_z_lev_aggrmat_asb.
! !
! For more details see ! For more details see
! M. Brezina and P. Vanek, A black-box iterative solver based on a ! M. Brezina and P. Vanek, A black-box iterative solver based on a
@ -72,6 +75,7 @@
! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math. ! PSBLAS-based parallel two-level Schwarz preconditioners, Appl. Num. Math.
! 57 (2007), 1181-1196. ! 57 (2007), 1181-1196.
! !
!
! Arguments: ! Arguments:
! a - type(psb_zspmat_type), input. ! a - type(psb_zspmat_type), input.
! The sparse matrix structure containing the local part of ! The sparse matrix structure containing the local part of
@ -82,14 +86,27 @@
! The 'one-level' data structure that will contain the local ! The 'one-level' data structure that will contain the local
! part of the matrix to be built as well as the information ! part of the matrix to be built as well as the information
! concerning the prolongator and its transpose. ! concerning the prolongator and its transpose.
! ilaggr - integer, dimension(:), allocatable. ! parms - type(mld_dml_parms), input
! Parameters controlling the choice of algorithm
! ac - type(psb_zspmat_type), output
! The coarse matrix on output
!
! ilaggr - integer, dimension(:), input
! The mapping between the row indices of the coarse-level ! The mapping between the row indices of the coarse-level
! matrix and the row indices of the fine-level matrix. ! matrix and the row indices of the fine-level matrix.
! ilaggr(i)=j means that node i in the adjacency graph ! ilaggr(i)=j means that node i in the adjacency graph
! of the fine-level matrix is mapped onto node j in the ! of the fine-level matrix is mapped onto node j in the
! adjacency graph of the coarse-level matrix. ! adjacency graph of the coarse-level matrix. Note that the indices
! nlaggr - integer, dimension(:), allocatable. ! are assumed to be shifted so as to make sure the ranges on
! the various processes do not overlap.
! nlaggr - integer, dimension(:) input
! nlaggr(i) contains the aggregates held by process i. ! nlaggr(i) contains the aggregates held by process i.
! op_prol - type(psb_zspmat_type), input/output
! The tentative prolongator on input, the computed prolongator on output
!
! op_restr - type(psb_zspmat_type), output
! The restrictor operator; normally, it is the transpose of the prolongator.
!
! info - integer, output. ! info - integer, output.
! Error code. ! Error code.
! !

3
mlprec/impl/mld_zmlprec_bld.f90
Unescape Escape View File

@ -50,6 +50,9 @@
! The levels are numbered in increasing order starting from the finest one, i.e. ! The levels are numbered in increasing order starting from the finest one, i.e.
! level 1 is the finest level. No transfer operators are associated to level 1. ! level 1 is the finest level. No transfer operators are associated to level 1.
! !
! This routine simply calls mld_z_hierarchy_bld and mld_z_smoothers_bld; they
! can also be called explicitly from the user.
!
! !
! Arguments: ! Arguments:
! a - type(psb_zspmat_type). ! a - type(psb_zspmat_type).

Write Preview
Loading…
Cancel
Save