d_bplus_utilities Module Reference

Functions/Subroutines
subroutine	d_bplus_delete (bplus)
subroutine	d_bplus_copy (bplus_i, bplus_o, memory)
subroutine	d_bplus_copy_delete (bplus_i, bplus_o, memory)
subroutine	d_bplus_extract_partial (bplus_i, ll_s, row_group, agent_bplus, msh)
subroutine	d_bplus_computememory (bplus_i, memory, rank)
logical function	d_bplus_checknan (bplus_i)
subroutine	d_hmat_parallelblock_mvp_dat (blocks_1, chara, M, N, Nrnd, random1, ldi, random2, ldo, a, b, ptree, stats)
subroutine	d_bp_mult (BP, chara, xin, xout, Ninloc, Noutloc, Ncol, ptree, stats)
subroutine	d_bplus_block_mvp_dat (bplus, chara, M, N, Nrnd, random1, ldi, random2, ldo, a, b, ptree, stats, level_start, level_end)
subroutine	d_bplus_md_block_mvp_dat (Ndim, bplus, chara, M, N, Nrnd, random1, ldi, random2, ldo, a, b, ptree, stats, msh, option, level_start, level_end)
subroutine	d_bplus_redistribute_inplace (bplus_o, stats, ptree, msh)
subroutine	d_bf_redistribute_inplace (blocks, pgno_new, stats, ptree, msh)
subroutine	d_bf_changepattern (blocks, pat_i, pat_o, stats, ptree)
subroutine	d_bf_delete (blocks, allflag)
subroutine	d_bf_copy (trans, block_i, block_o, memory)
subroutine	d_bf_delete_ker_onelevel (ker_o)
subroutine	d_bf_copy_ker_onelevel (ker_i, ker_o)
subroutine	d_bf_copy_delete (block_i, block_o, memory)
subroutine	d_bf_computememory (block_i, memory)
subroutine	d_bf_md_computememory (Ndim, blocks, memory_dense, memory_comp)
subroutine	d_bf_md_delete (Ndim, blocks, allflag)
integer function	d_bf_switchlevel (level_butterfly, pat_comp)
logical function	d_bf_checknan (block_i)
subroutine	d_bf_print_size (block_i)
subroutine	d_bf_print_size_rank (block_i, tolerance)
subroutine	d_bf_extract_partial (block_o, level_butterfly_loc, ij_loc, head, group, LR, agent_block, pgno, ptree)
subroutine	d_bf_copyback_partial (block_o, level_butterfly_loc, ij_loc, LR, agent_block, pgno, ptree)
subroutine	d_bf_copy_partial (block_i, block_o, level_butterfly_loc, ij_loc, LR, memory)
subroutine	d_bf_partial_mvp_half (block_rand, chara, level_start, level_end, random, num_vect_sub, nth_s, nth_e, Ng)
subroutine	d_bf_exchange_extraction (blocks, kerls, stats, ptree, level, collect)
subroutine	d_bf_exchange_matvec (blocks, kerls, stats, ptree, level, mode, collect)
subroutine	d_bf_all2all_sizes (blocks, sizes, ptree, level, mode, mode_new)
	*********** all to all communication of sizes of one butterfly level from row-wise ordering to column-wise ordering or the reverse More...
subroutine	d_bf_all2all_extraction (blocks, kerls, kerls1, stats, ptree, level, mode, mode_new)
	*********** all to all communication of extraction results of one butterfly level from row-wise ordering to column-wise ordering or the reverse More...
subroutine	d_bf_all2all_vec_n_ker (blocks, kerls, stats, ptree, nproc, level, mode, mode_new, kerflag)
	***** switching the matvecs/temporary buffer/kernels from row/col distributions to col/row distributions, kerflag=1: kernels, kerflag=0: matvecs and buffer More...
subroutine	d_bf_all2all_ker (block_i, pgno_i, kerls_i, level_i, offset_r, offset_c, block_o, pgno_o, kerls_o, level_o, stats, ptree)
	*********** all to all communication of one level of a butterfly from an old process pgno_i to an new process group pgno_o More...
subroutine	d_bf_all2all_ker_pattern (block_i, kerls_i, pat_i, block_o, kerls_o, pat_o, level, pgno, stats, ptree)
	*********** all to all communication of one level of a butterfly from an old pattern pat_i to an new pattern pat_o More...
subroutine	d_bf_convert_to_smallbf (block_i, block_o, stats, ptree)
	*********** convert blocks in block_isons to block_osons, this is a local function without MPI communication, it is assumed block_isons has L levels, and block_osons will have max(L-2,0) levels More...
subroutine	d_bf_all2all_ker_split (block_i, pgno_i, level_i, block_o, pgnos_o, level_o, stats, ptree)
	*********** all to all communication of one level of a butterfly into four children butterflies from an old process pgno_i to an new process group pgno_o More...
subroutine	d_bf_all2all_uv (block_i, pgno_i, kerls_i, level_i, offset, block_o, pgno_o, kerls_o, level_o, stats, ptree)
	*********** all to all communication of one level of a butterfly from an old process pgno_i to an new process group pgno_o More...
subroutine	d_bf_all2all_u_split (block_i, pgno_i, level_i, block_o, pgnos_o, level_o, stats, ptree)
	*********** all to all communication of one level of a butterfly to four children butterflies from an old process pgno_i to an new process group pgno_o More...
subroutine	d_bf_all2all_v_split (block_i, pgno_i, level_i, block_o, pgnos_o, level_o, stats, ptree)
	*********** all to all communication of one level of a butterfly to four children butterflies from an old process pgno_i to an new process group pgno_o More...
subroutine	d_bplus_vec_1dto1d (BP, rowcol, one2all, level_s, level_e, ld1, dat_1, Nrnd, vecs, ptree, nproc)
	***** redistribute the input and output vectors in d_Bplus_block_MVP_dat between layout of bplusLL(1)matrices_block(1) to the layout of bplusLL(xx)matrices_block(yy) More...
subroutine	d_bplus_md_vec_1dto1d (Ndim, BP, rowcol, one2all, level_s, level_e, ld1, dat_1, Nrnd, vecs, ptree, nproc)
	***** redistribute the input and output vectors in d_Bplus_MD_block_MVP_dat between layout of bplusLL(1)matrices_block(1) to the layout of bplusLL(xx)matrices_block(yy) More...
subroutine	d_bf_mult (chara, xin, xout, Ninloc, Noutloc, Ncol, blocks, option, stats, ptree)
subroutine	d_bf_block_mvp_dat (blocks, chara, M, N, Nrnd, random1, ldi, random2, ldo, a, b, ptree, stats)
subroutine	d_bf_block_mvp_dat_nonbatch (blocks, chara, M, N, Nrnd, random1, ldi, random2, ldo, a, b, ptree, stats)
subroutine	d_bf_block_mvp_partial (blocks, chara, num_vectors, VectIn, BFvec, level_end, ptree, stats)
	**** Matvec of partial levels of BF with vectors More...
subroutine	d_full_block_extraction (blocks, inters, ptree, msh, stats, option)
subroutine	d_lr_block_extraction (blocks, inters, ptree, msh, stats)
subroutine	d_lr_all2all_extraction (blocks, inters, Vpartial, rank, ncol, stats, ptree, msh)
	*********** all to all communication of columns in the V factor from the 1D block column layout to that needed by the 1D block row layout More...
subroutine	d_bf_md_block_extraction (blocks, Ndim, Ninter, inters, ptree, msh, stats)
subroutine	d_bf_md_all2all_extraction (Ndim, blocks, Ninter, inters, BFvec, BFvec_transposed, stats, msh, ptree)
	*********** all to all communication of matvec results at the middle butterfly level from row-wise ordering to column-wise ordering More...
subroutine	d_bf_md_all2all_mvp (Ndim, blocks, BFvec, BFvec_transposed, stats, msh, ptree)
	*********** all to all communication of matvec results at the middle butterfly level from row-wise ordering to column-wise ordering More...
subroutine	d_bf_md_block_mvp (chara, xin, Ninloc, xout, Noutloc, Nvec, blocks, Ndim, ptree, stats, msh, option)
subroutine	d_bf_block_extraction (blocks, inters, ptree, msh, stats)
subroutine	d_bf_block_extraction_multiply_oneblock_right (blocks, BFvec, level, nn, ptree, stats)
subroutine	d_bf_md_block_extraction_multiply_oneblock_right (blocks, bb_m, Ndim, BFvec, idx_r_m, level, dim_i, ptree, stats)
subroutine	d_bf_block_extraction_multiply_oneblock_left (blocks, BFvec, level, nn, ptree, stats)
subroutine	d_bf_md_block_mvp_multiply_right (blocks, bb_m, Ndim, BFvec, Nvec, level, ptree, stats)
subroutine	d_bf_md_block_mvp_multiply_left (blocks, bb_m, Ndim, BFvec, Nvec, level, ptree, stats)
subroutine	d_bf_md_block_extraction_multiply_oneblock_left (blocks, bb_m, Ndim, BFvec, idx_c_m, level, dim_i, ptree, stats)
subroutine	d_bf_block_extraction_sort_oneblock (blocks, BFvec, level, nn, ptree)
subroutine	d_bf_block_extraction_multiply_oneblock_last (blocks, BFvec, inters, level, nn, ptree, msh, stats)
integer function	d_findgroup (idx, msh, level, group)
	*** Find the group index of point idx at the (grouplevel+level) level More...
integer function	d_findpggroup (idx, msh, ptree, group, pgno)
	*** Find the process group index of point idx in a group More...
subroutine	d_bf_value (mi, nj, blocks, value)
subroutine	d_bf_get_rank (block_i, ptree, level_o)
subroutine	d_bf_md_get_rank (Ndim, blocks, ptree)
subroutine	d_bf_sym2asym (blocks)
subroutine	d_bf_movesingular_ker (blocks, chara, level_start, level_end, ptree, stats, tolerance)
subroutine	d_bf_movesingulartoleft (blocks)
subroutine	d_bf_movesingulartoright (blocks)
subroutine	d_bf_init_blocks (level_butterfly, groupm, groupn, pgno, block_rand, msh, ptree)
recursive subroutine	d_hmat_block_copy (trans, block2, block1, memory)
recursive subroutine	d_hmat_block_delete (blocks)
recursive subroutine	d_hmat_block_computememory (blocks, memory)
recursive subroutine	d_hmat_lsolve (blocks_l, trans, idx_start, nvec, Vinout, ld, ptree, stats)
recursive subroutine	d_hmat_usolve (blocks_u, trans, idx_start, nvec, Vinout, ld, ptree, stats)
recursive subroutine	d_hmat_block_mvp_dat (blocks, trans, idx_start_m, idx_start_n, Nrnd, Vin, ldi, Vout, ldo, a, ptree, stats, level_start, level_end)
subroutine	d_full_block_mvp_dat (blocks, chara, M, num_vectors, random1, ldi, random2, ldo, a, b)
	**** Multiply with dense blocks. More...
subroutine	d_full_block_md_mvp_dat (blocks, chara, M, num_vectors, random1, ldi, random2, ldo, a, b)
	**** Multiply with dense blocks (as tensor). This is the same as d_Full_block_MVP_dat, except that blocks needs to be type(d_matrixblock_MD) More...
subroutine	d_computeparallelindices_md (block, pgno, Ndim, ptree, msh)
subroutine	d_computeparallelindices (block, pgno, ptree, msh)
subroutine	d_computeparallelindicessub (base_group, pgno, ptree, msh, MN_p)
real(kind=8) function	d_node_score_block_ptr_row (this)
real(kind=8) function	d_nod_score_ipair (this)
subroutine	d_element_zmn_block_user (nrow, ncol, mrange, nrange, values, msh, option, ker, myflag, passflag, ptree, stats)
subroutine	d_element_zmn_blocklist_user (submats, Nsub, msh, option, ker, myflag, passflag, ptree, stats, alldat_loc_in)
subroutine	d_element_zmn_tensorlist_user (Ndim, subtensors, Nsub, msh, option, ker, myflag, passflag, ptree, stats, zfpquants)

Function/Subroutine Documentation

d_bf_all2all_extraction()

subroutine d_bplus_utilities::d_bf_all2all_extraction	(	type(d_matrixblock)	blocks,
		type(d_butterfly_kerl)	kerls,
		type(d_butterfly_kerl)	kerls1,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		integer	level,
		character	mode,
		character	mode_new
	)

*********** all to all communication of extraction results of one butterfly level from row-wise ordering to column-wise ordering or the reverse

Here is the call graph for this function:

d_bf_all2all_ker()

subroutine d_bplus_utilities::d_bf_all2all_ker	(	type(d_matrixblock)	block_i,
		integer	pgno_i,
		type(d_butterfly_kerl)	kerls_i,
		integer	level_i,
		integer	offset_r,
		integer	offset_c,
		type(d_matrixblock)	block_o,
		integer	pgno_o,
		type(d_butterfly_kerl)	kerls_o,
		integer	level_o,
		type(d_hstat)	stats,
		type(d_proctree)	ptree
	)

*********** all to all communication of one level of a butterfly from an old process pgno_i to an new process group pgno_o

Here is the call graph for this function:

d_bf_all2all_ker_pattern()

subroutine d_bplus_utilities::d_bf_all2all_ker_pattern	(	type(d_matrixblock)	block_i,
		type(d_butterfly_kerl)	kerls_i,
		integer	pat_i,
		type(d_matrixblock)	block_o,
		type(d_butterfly_kerl)	kerls_o,
		integer	pat_o,
		integer	level,
		integer	pgno,
		type(d_hstat)	stats,
		type(d_proctree)	ptree
	)

*********** all to all communication of one level of a butterfly from an old pattern pat_i to an new pattern pat_o

Here is the call graph for this function:

d_bf_all2all_ker_split()

subroutine d_bplus_utilities::d_bf_all2all_ker_split	(	type(d_matrixblock)	block_i,
		integer	pgno_i,
		integer	level_i,
		type(d_matrixblock)	block_o,
		integer, dimension(2,2)	pgnos_o,
		integer	level_o,
		type(d_hstat)	stats,
		type(d_proctree)	ptree
	)

*********** all to all communication of one level of a butterfly into four children butterflies from an old process pgno_i to an new process group pgno_o

Here is the call graph for this function:

d_bf_all2all_sizes()

subroutine d_bplus_utilities::d_bf_all2all_sizes	(	type(d_matrixblock)	blocks,
		type(d_butterfly_skel)	sizes,
		type(d_proctree)	ptree,
		integer	level,
		character	mode,
		character	mode_new
	)

*********** all to all communication of sizes of one butterfly level from row-wise ordering to column-wise ordering or the reverse

Here is the call graph for this function:

d_bf_all2all_u_split()

subroutine d_bplus_utilities::d_bf_all2all_u_split	(	type(d_matrixblock)	block_i,
		integer	pgno_i,
		integer	level_i,
		type(d_matrixblock)	block_o,
		integer, dimension(2,2)	pgnos_o,
		integer	level_o,
		type(d_hstat)	stats,
		type(d_proctree)	ptree
	)

*********** all to all communication of one level of a butterfly to four children butterflies from an old process pgno_i to an new process group pgno_o

Here is the call graph for this function:

d_bf_all2all_uv()

subroutine d_bplus_utilities::d_bf_all2all_uv	(	type(d_matrixblock)	block_i,
		integer	pgno_i,
		type(d_butterfly_uv)	kerls_i,
		integer	level_i,
		integer	offset,
		type(d_matrixblock)	block_o,
		integer	pgno_o,
		type(d_butterfly_uv)	kerls_o,
		integer	level_o,
		type(d_hstat)	stats,
		type(d_proctree)	ptree
	)

*********** all to all communication of one level of a butterfly from an old process pgno_i to an new process group pgno_o

Here is the call graph for this function:

d_bf_all2all_v_split()

subroutine d_bplus_utilities::d_bf_all2all_v_split	(	type(d_matrixblock)	block_i,
		integer	pgno_i,
		integer	level_i,
		type(d_matrixblock)	block_o,
		integer, dimension(2,2)	pgnos_o,
		integer	level_o,
		type(d_hstat)	stats,
		type(d_proctree)	ptree
	)

*********** all to all communication of one level of a butterfly to four children butterflies from an old process pgno_i to an new process group pgno_o

Here is the call graph for this function:

d_bf_all2all_vec_n_ker()

subroutine d_bplus_utilities::d_bf_all2all_vec_n_ker	(	type(d_matrixblock)	blocks,
		type(d_butterfly_kerl)	kerls,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		integer	nproc,
		integer	level,
		character	mode,
		character	mode_new,
		integer	kerflag
	)

***** switching the matvecs/temporary buffer/kernels from row/col distributions to col/row distributions, kerflag=1: kernels, kerflag=0: matvecs and buffer

Here is the call graph for this function:

d_bf_block_extraction()

subroutine d_bplus_utilities::d_bf_block_extraction	(	type(d_matrixblock)	blocks,
		type(d_intersect), dimension(:)	inters,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		type(d_hstat)	stats
	)

******* preallocate BFvec and BFvec1, number of blocks are exactly those in d_BF_block_MVP_dat, BFvec for the first 0:level_half+1 levels and BFvec for the next level_half+1 to level_butterfly+2 levels,note that level level_half+1 is duplicated for all2all communication

**** compute group_ms and group_ns which stores the leaf block number (from 1 to 2^L) of each index. group_ms1 and group_ns1 are used to track the block number in each butterfly level.

**** compute g_idx_m and g_idx_n which stores the local (with halo) blocks for the block rows and columns

*** for each index in each intersection, traverse the row and column tree

**** construct BFvecvec(level)lst for active BF blocks and BFvecvec(level)blocks(index_i_loc_s,index_j_loc_s)lst for d_list of intersection::s

**** copy *lst to *index

**** compute g_idx_m and g_idx_n which stores the local (with halo) blocks for the block rows and columns

**** compute g_idx_m and g_idx_n which stores the local (with halo) blocks for the block rows and columns

*** for each index in each intersection, traverse the row and column tree

**** construct BFvec1vec(level)lst for active BF blocks and BFvec1vec(level)blocks(index_i_loc_s,index_j_loc_s)lst for d_list of intersection::s

**** copy *lst to *index

**** create a d_list of row_loc indices for each block of BFvec1vec(level_butterfly+2),note that BFvec1vec(level)blocks(index_i_loc_s,1)lst and BFvec1vec(level)blocks(index_i_loc_s,1)index are used at this level compared to other levels

*** for each index in each intersection, traverse the row and column tree

**** copy *lst to *index

**** generate data in BFvecvec(0)

**** multiply BF with BFvec

**** multiply BF with BFvec1

Here is the call graph for this function:

d_bf_block_extraction_multiply_oneblock_last()

subroutine d_bplus_utilities::d_bf_block_extraction_multiply_oneblock_last	(	type(d_matrixblock)	blocks,
		type(d_butterfly_vec)	BFvec,
		type(d_intersect), dimension(:)	inters,
		integer	level,
		integer	nn,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_bf_block_extraction_multiply_oneblock_left()

subroutine d_bplus_utilities::d_bf_block_extraction_multiply_oneblock_left	(	type(d_matrixblock)	blocks,
		type(d_butterfly_vec)	BFvec,
		integer	level,
		integer	nn,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_bf_block_extraction_multiply_oneblock_right()

subroutine d_bplus_utilities::d_bf_block_extraction_multiply_oneblock_right	(	type(d_matrixblock)	blocks,
		type(d_butterfly_vec)	BFvec,
		integer	level,
		integer	nn,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

**** filter out the columns of mat1 and mat2 that are not specified by BFvecvec(level)blocks(index_i_loc_s,index_j_loc_s)index

Here is the call graph for this function:

d_bf_block_extraction_sort_oneblock()

subroutine d_bplus_utilities::d_bf_block_extraction_sort_oneblock	(	type(d_matrixblock)	blocks,
		type(d_butterfly_vec)	BFvec,
		integer	level,
		integer	nn,
		type(d_proctree)	ptree
	)

**** filter out the columns of mat1 and mat2 that are not specified by BFvecvec(level)blocks(index_i_loc_s,index_j_loc_s)index

d_bf_block_mvp_dat()

subroutine d_bplus_utilities::d_bf_block_mvp_dat	(	type(d_matrixblock)	blocks,
		character	chara,
		integer	M,
		integer	N,
		integer	Nrnd,
		real(kind=8), dimension(ldi, *)	random1,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	random2,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_bf_block_mvp_dat_nonbatch()

subroutine d_bplus_utilities::d_bf_block_mvp_dat_nonbatch	(	type(d_matrixblock)	blocks,
		character	chara,
		integer	M,
		integer	N,
		integer	Nrnd,
		real(kind=8), dimension(ldi, *)	random1,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	random2,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_bf_block_mvp_partial()

subroutine d_bplus_utilities::d_bf_block_mvp_partial	(	type(d_matrixblock)	blocks,
		character	chara,
		integer	num_vectors,
		real(kind=8), dimension(:, :)	VectIn,
		type(d_butterfly_vec)	BFvec,
		integer	level_end,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

**** Matvec of partial levels of BF with vectors

Here is the call graph for this function:

d_bf_changepattern()

subroutine d_bplus_utilities::d_bf_changepattern	(	type(d_matrixblock)	blocks,
		integer	pat_i,
		integer	pat_o,
		type(d_hstat)	stats,
		type(d_proctree)	ptree
	)

*** make sure every process has blocksButterflyKerl allocated

*** delete dummy blocksButterflyKerl if I don't share the output butterfly

Here is the call graph for this function:

d_bf_checknan()

logical function d_bplus_utilities::d_bf_checknan

(

type(d_matrixblock)

block_i

)

Here is the call graph for this function:

d_bf_computememory()

subroutine d_bplus_utilities::d_bf_computememory	(	type(d_matrixblock)	block_i,
		real(kind=8)	memory
	)

d_bf_convert_to_smallbf()

subroutine d_bplus_utilities::d_bf_convert_to_smallbf	(	type(d_matrixblock)	block_i,
		type(d_matrixblock)	block_o,
		type(d_hstat)	stats,
		type(d_proctree)	ptree
	)

*********** convert blocks in block_isons to block_osons, this is a local function without MPI communication, it is assumed block_isons has L levels, and block_osons will have max(L-2,0) levels

Here is the call graph for this function:

d_bf_copy()

subroutine d_bplus_utilities::d_bf_copy	(	character	trans,
		type(d_matrixblock)	block_i,
		type(d_matrixblock)	block_o,
		real(kind=8), optional	memory
	)

Here is the call graph for this function:

d_bf_copy_delete()

subroutine d_bplus_utilities::d_bf_copy_delete	(	type(d_matrixblock)	block_i,
		type(d_matrixblock)	block_o,
		real(kind=8), optional	memory
	)

Here is the call graph for this function:

d_bf_copy_ker_onelevel()

subroutine d_bplus_utilities::d_bf_copy_ker_onelevel	(	type(d_butterfly_kerl)	ker_i,
		type(d_butterfly_kerl)	ker_o
	)

d_bf_copy_partial()

subroutine d_bplus_utilities::d_bf_copy_partial	(	type(d_matrixblock)	block_i,
		type(d_matrixblock)	block_o,
		integer	level_butterfly_loc,
		integer	ij_loc,
		character	LR,
		real(kind=8), optional	memory
	)

Here is the call graph for this function:

d_bf_copyback_partial()

subroutine d_bplus_utilities::d_bf_copyback_partial	(	type(d_matrixblock)	block_o,
		integer	level_butterfly_loc,
		integer	ij_loc,
		character	LR,
		type(d_matrixblock)	agent_block,
		integer	pgno,
		type(d_proctree)	ptree
	)

Here is the call graph for this function:

d_bf_delete()

subroutine d_bplus_utilities::d_bf_delete	(	type(d_matrixblock)	blocks,
		integer	allflag
	)

Here is the call graph for this function:

d_bf_delete_ker_onelevel()

subroutine d_bplus_utilities::d_bf_delete_ker_onelevel

(

type(d_butterfly_kerl)

ker_o

)

d_bf_exchange_extraction()

subroutine d_bplus_utilities::d_bf_exchange_extraction	(	type(d_matrixblock)	blocks,
		type(d_butterfly_kerl)	kerls,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		integer	level,
		character	collect
	)

Here is the call graph for this function:

d_bf_exchange_matvec()

subroutine d_bplus_utilities::d_bf_exchange_matvec	(	type(d_matrixblock)	blocks,
		type(d_butterfly_kerl)	kerls,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		integer	level,
		character	mode,
		character	collect
	)

Here is the call graph for this function:

d_bf_extract_partial()

subroutine d_bplus_utilities::d_bf_extract_partial	(	type(d_matrixblock)	block_o,
		integer	level_butterfly_loc,
		integer	ij_loc,
		integer	head,
		integer	group,
		character	LR,
		type(d_matrixblock)	agent_block,
		integer	pgno,
		type(d_proctree)	ptree
	)

*********** compute M_p, N_p, ms, ns, M and N

Here is the call graph for this function:

d_bf_get_rank()

subroutine d_bplus_utilities::d_bf_get_rank	(	type(d_matrixblock)	block_i,
		type(d_proctree)	ptree,
		integer, optional	level_o
	)

Here is the call graph for this function:

d_bf_init_blocks()

subroutine d_bplus_utilities::d_bf_init_blocks	(	integer	level_butterfly,
		integer	groupm,
		integer	groupn,
		integer	pgno,
		type(d_matrixblock)	block_rand,
		type(d_mesh)	msh,
		type(d_proctree)	ptree
	)

****** row-wise ordering from right side

****** column-wise ordering from left side

Here is the call graph for this function:

d_bf_md_all2all_extraction()

subroutine d_bplus_utilities::d_bf_md_all2all_extraction	(	integer	Ndim,
		type(d_matrixblock_md)	blocks,
		integer	Ninter,
		type(d_intersect_md), dimension(ninter)	inters,
		type(d_butterfly_vec), dimension(:,:)	BFvec,
		type(d_butterfly_vec), dimension(:,:)	BFvec_transposed,
		type(d_hstat)	stats,
		type(d_mesh), dimension(ndim)	msh,
		type(d_proctree)	ptree
	)

*********** all to all communication of matvec results at the middle butterfly level from row-wise ordering to column-wise ordering

Here is the call graph for this function:

d_bf_md_all2all_mvp()

subroutine d_bplus_utilities::d_bf_md_all2all_mvp	(	integer	Ndim,
		type(d_matrixblock_md)	blocks,
		type(d_butterfly_vec), dimension(:)	BFvec,
		type(d_butterfly_vec), dimension(:)	BFvec_transposed,
		type(d_hstat)	stats,
		type(d_mesh), dimension(ndim)	msh,
		type(d_proctree)	ptree
	)

*********** all to all communication of matvec results at the middle butterfly level from row-wise ordering to column-wise ordering

Here is the call graph for this function:

d_bf_md_block_extraction()

subroutine d_bplus_utilities::d_bf_md_block_extraction	(	type(d_matrixblock_md)	blocks,
		integer	Ndim,
		integer	Ninter,
		type(d_intersect_md), dimension(ninter)	inters,
		type(d_proctree)	ptree,
		type(d_mesh), dimension(ndim)	msh,
		type(d_hstat)	stats
	)

**** Step 1: multiply the factor matrices out from outtermost to middle level along each dimension ******* preallocate BFvec and BFvec1, number of blocks are exactly those in d_BF_block_MVP_dat, BFvec for the first 0:level_half+1 levels and BFvec for the next level_half+1 to level_butterfly+2 levels,note that level level_half+1 is duplicated for all2all communication

**** multiply BF with BFvec

**** multiply BF with BFvec1

**** Step 2: all to all communication of the right multiplication results

**** Step 3: tensor matrix contraction

Here is the call graph for this function:

d_bf_md_block_extraction_multiply_oneblock_left()

subroutine d_bplus_utilities::d_bf_md_block_extraction_multiply_oneblock_left	(	type(d_matrixblock_md)	blocks,
		integer	bb_m,
		integer	Ndim,
		type(d_butterfly_vec)	BFvec,
		integer, dimension(ndim)	idx_c_m,
		integer	level,
		integer	dim_i,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_bf_md_block_extraction_multiply_oneblock_right()

subroutine d_bplus_utilities::d_bf_md_block_extraction_multiply_oneblock_right	(	type(d_matrixblock_md)	blocks,
		integer	bb_m,
		integer	Ndim,
		type(d_butterfly_vec)	BFvec,
		integer, dimension(ndim)	idx_r_m,
		integer	level,
		integer	dim_i,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_bf_md_block_mvp()

subroutine d_bplus_utilities::d_bf_md_block_mvp	(	character	chara,
		real(kind=8), dimension(:, :)	xin,
		integer, dimension(ndim)	Ninloc,
		real(kind=8), dimension(:, :)	xout,
		integer, dimension(ndim)	Noutloc,
		integer	Nvec,
		type(d_matrixblock_md)	blocks,
		integer	Ndim,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		type(d_mesh), dimension(ndim)	msh,
		type(d_hoption)	option
	)

******* preallocate BFvec and BFvec1, number of blocks are exactly those in d_BF_block_MVP_dat, BFvec for the first 0:level_half+1 levels and BFvec for the next level_half+1 to level_butterfly+2 levels,note that level level_half+1 is duplicated for all2all communication

**** Step 1: multiply the factor matrices out from outtermost to middle level along each dimension

**** Step 2: all to all communication of the right multiplication results

**** Step 3: contraction with the middle level core tensors

**** Step 4: multiply the factor matrices out from middle level to the outtermost level along each dimension

Here is the call graph for this function:

d_bf_md_block_mvp_multiply_left()

subroutine d_bplus_utilities::d_bf_md_block_mvp_multiply_left	(	type(d_matrixblock_md)	blocks,
		integer	bb_m,
		integer	Ndim,
		type(d_butterfly_vec)	BFvec,
		integer	Nvec,
		integer	level,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_bf_md_block_mvp_multiply_right()

subroutine d_bplus_utilities::d_bf_md_block_mvp_multiply_right	(	type(d_matrixblock_md)	blocks,
		integer	bb_m,
		integer	Ndim,
		type(d_butterfly_vec)	BFvec,
		integer	Nvec,
		integer	level,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_bf_md_computememory()

subroutine d_bplus_utilities::d_bf_md_computememory	(	integer	Ndim,
		type(d_matrixblock_md)	blocks,
		real(kind=8)	memory_dense,
		real(kind=8)	memory_comp
	)

Here is the call graph for this function:

d_bf_md_delete()

subroutine d_bplus_utilities::d_bf_md_delete	(	integer	Ndim,
		type(d_matrixblock_md)	blocks,
		integer	allflag
	)

d_bf_md_get_rank()

subroutine d_bplus_utilities::d_bf_md_get_rank	(	integer	Ndim,
		type(d_matrixblock_md)	blocks,
		type(d_proctree)	ptree
	)

Here is the call graph for this function:

d_bf_movesingular_ker()

subroutine d_bplus_utilities::d_bf_movesingular_ker	(	type(d_matrixblock)	blocks,
		character	chara,
		integer	level_start,
		integer	level_end,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		real(kind=8)	tolerance
	)

Here is the call graph for this function:

d_bf_movesingulartoleft()

subroutine d_bplus_utilities::d_bf_movesingulartoleft

(

type(d_matrixblock)

blocks

)

Here is the call graph for this function:

d_bf_movesingulartoright()

subroutine d_bplus_utilities::d_bf_movesingulartoright

(

type(d_matrixblock)

blocks

)

Here is the call graph for this function:

d_bf_mult()

subroutine d_bplus_utilities::d_bf_mult	(	character	chara,
		real(kind=8), dimension(ninloc, ncol)	xin,
		real(kind=8), dimension(noutloc, ncol)	xout,
		integer	Ninloc,
		integer	Noutloc,
		integer	Ncol,
		type(d_matrixblock)	blocks,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree
	)

Here is the call graph for this function:

d_bf_partial_mvp_half()

subroutine d_bplus_utilities::d_bf_partial_mvp_half	(	type(d_matrixblock)	block_rand,
		character	chara,
		integer	level_start,
		integer	level_end,
		type(d_randomblock)	random,
		integer	num_vect_sub,
		integer	nth_s,
		integer	nth_e,
		integer	Ng
	)

d_bf_print_size()

subroutine d_bplus_utilities::d_bf_print_size

(

type(d_matrixblock)

block_i

)

d_bf_print_size_rank()

subroutine d_bplus_utilities::d_bf_print_size_rank	(	type(d_matrixblock)	block_i,
		real(kind=8)	tolerance
	)

Here is the call graph for this function:

d_bf_redistribute_inplace()

subroutine d_bplus_utilities::d_bf_redistribute_inplace	(	type(d_matrixblock)	blocks,
		integer	pgno_new,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh
	)

*** make sure every process has blocksButterflyKerl allocated

*** delete dummy blocksButterflyKerl if I don't share the output butterfly

Here is the call graph for this function:

d_bf_switchlevel()

integer function d_bplus_utilities::d_bf_switchlevel	(	integer	level_butterfly,
		integer	pat_comp
	)

Here is the call graph for this function:

d_bf_sym2asym()

subroutine d_bplus_utilities::d_bf_sym2asym

(

type(d_matrixblock)

blocks

)

Here is the call graph for this function:

d_bf_value()

subroutine d_bplus_utilities::d_bf_value	(	integer	mi,
		integer	nj,
		type(d_matrixblock)	blocks,
		real(kind=8)	value
	)

d_bp_mult()

subroutine d_bplus_utilities::d_bp_mult	(	type(d_blockplus)	BP,
		character	chara,
		real(kind=8), dimension(ninloc, ncol)	xin,
		real(kind=8), dimension(noutloc, ncol)	xout,
		integer	Ninloc,
		integer	Noutloc,
		integer	Ncol,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_bplus_block_mvp_dat()

subroutine d_bplus_utilities::d_bplus_block_mvp_dat	(	type(d_blockplus)	bplus,
		character	chara,
		integer	M,
		integer	N,
		integer	Nrnd,
		real(kind=8), dimension(ldi, *)	random1,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	random2,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		integer, optional	level_start,
		integer, optional	level_end
	)

Here is the call graph for this function:

d_bplus_checknan()

logical function d_bplus_utilities::d_bplus_checknan

(

type(d_blockplus)

bplus_i

)

Here is the call graph for this function:

d_bplus_computememory()

subroutine d_bplus_utilities::d_bplus_computememory	(	type(d_blockplus)	bplus_i,
		real(kind=8)	memory,
		integer	rank
	)

Here is the call graph for this function:

d_bplus_copy()

subroutine d_bplus_utilities::d_bplus_copy	(	type(d_blockplus)	bplus_i,
		type(d_blockplus)	bplus_o,
		real(kind=8), optional	memory
	)

Here is the call graph for this function:

d_bplus_copy_delete()

subroutine d_bplus_utilities::d_bplus_copy_delete	(	type(d_blockplus)	bplus_i,
		type(d_blockplus)	bplus_o,
		real(kind=8), optional	memory
	)

Here is the call graph for this function:

d_bplus_delete()

subroutine d_bplus_utilities::d_bplus_delete

(

type(d_blockplus)

bplus

)

Here is the call graph for this function:

d_bplus_extract_partial()

subroutine d_bplus_utilities::d_bplus_extract_partial	(	type(d_blockplus)	bplus_i,
		integer	ll_s,
		integer	row_group,
		type(d_blockplus)	agent_bplus,
		type(d_mesh)	msh
	)

Here is the call graph for this function:

d_bplus_md_block_mvp_dat()

subroutine d_bplus_utilities::d_bplus_md_block_mvp_dat	(	integer	Ndim,
		type(d_blockplus_md)	bplus,
		character	chara,
		integer, dimension(ndim)	M,
		integer, dimension(ndim)	N,
		integer	Nrnd,
		real(kind=8), dimension(product(ldi), *)	random1,
		integer, dimension(ndim)	ldi,
		real(kind=8), dimension(product(ldo), *)	random2,
		integer, dimension(ndim)	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		type(d_mesh), dimension(ndim)	msh,
		type(d_hoption)	option,
		integer, optional	level_start,
		integer, optional	level_end
	)

Here is the call graph for this function:

d_bplus_md_vec_1dto1d()

subroutine d_bplus_utilities::d_bplus_md_vec_1dto1d	(	integer	Ndim,
		type(d_blockplus_md)	BP,
		integer	rowcol,
		integer	one2all,
		integer	level_s,
		integer	level_e,
		integer, dimension(ndim)	ld1,
		real(kind=8), dimension(product(ld1), *)	dat_1,
		integer	Nrnd,
		type(d_vectorsblock_onel), dimension(level_s:level_e)	vecs,
		type(d_proctree)	ptree,
		integer	nproc
	)

***** redistribute the input and output vectors in d_Bplus_MD_block_MVP_dat between layout of bplusLL(1)matrices_block(1) to the layout of bplusLL(xx)matrices_block(yy)

Here is the call graph for this function:

d_bplus_redistribute_inplace()

subroutine d_bplus_utilities::d_bplus_redistribute_inplace	(	type(d_blockplus)	bplus_o,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh
	)

Here is the call graph for this function:

d_bplus_vec_1dto1d()

subroutine d_bplus_utilities::d_bplus_vec_1dto1d	(	type(d_blockplus)	BP,
		integer	rowcol,
		integer	one2all,
		integer	level_s,
		integer	level_e,
		integer	ld1,
		real(kind=8), dimension(ld1, *)	dat_1,
		integer	Nrnd,
		type(d_vectorsblock_onel), dimension(level_s:level_e)	vecs,
		type(d_proctree)	ptree,
		integer	nproc
	)

***** redistribute the input and output vectors in d_Bplus_block_MVP_dat between layout of bplusLL(1)matrices_block(1) to the layout of bplusLL(xx)matrices_block(yy)

Here is the call graph for this function:

d_computeparallelindices()

subroutine d_bplus_utilities::d_computeparallelindices	(	type(d_matrixblock)	block,
		integer	pgno,
		type(d_proctree)	ptree,
		type(d_mesh)	msh
	)

Here is the call graph for this function:

d_computeparallelindices_md()

subroutine d_bplus_utilities::d_computeparallelindices_md	(	type(d_matrixblock_md)	block,
		integer	pgno,
		integer	Ndim,
		type(d_proctree)	ptree,
		type(d_mesh), dimension(ndim)	msh
	)

Here is the call graph for this function:

d_computeparallelindicessub()

subroutine d_bplus_utilities::d_computeparallelindicessub	(	integer	base_group,
		integer	pgno,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		integer, dimension(:, :)	MN_p
	)

Here is the call graph for this function:

d_element_zmn_block_user()

subroutine d_bplus_utilities::d_element_zmn_block_user	(	integer	nrow,
		integer	ncol,
		integer, dimension(nrow)	mrange,
		integer, dimension(ncol)	nrange,
		real(kind=8), dimension(nrow, ncol)	values,
		type(d_mesh)	msh,
		type(d_hoption)	option,
		type(d_kernelquant)	ker,
		integer	myflag,
		integer	passflag,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

***** Count number of active intersections Ninter

***** count number of local data

***** Broadcast mrange and nrange for each intersection

Here is the call graph for this function:

d_element_zmn_blocklist_user()

subroutine d_bplus_utilities::d_element_zmn_blocklist_user	(	type(d_intersect), dimension(*)	submats,
		integer	Nsub,
		type(d_mesh)	msh,
		type(d_hoption)	option,
		type(d_kernelquant)	ker,
		integer	myflag,
		integer	passflag,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		real(kind=8), dimension(:), optional, target	alldat_loc_in
	)

***** Generate pmaps and pgidx for all intersections

***** count number of local data

***** Broadcast mrange and nrange for each intersection

***** Generate pmaps and pgidx for all intersections

***** count number of local data

Here is the call graph for this function:

d_element_zmn_tensorlist_user()

subroutine d_bplus_utilities::d_element_zmn_tensorlist_user	(	integer	Ndim,
		type(d_intersect_md), dimension(*)	subtensors,
		integer	Nsub,
		type(d_mesh), dimension(ndim)	msh,
		type(d_hoption)	option,
		type(d_kernelquant)	ker,
		integer	myflag,
		integer	passflag,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		type(d_zfpquant), dimension(*), optional	zfpquants
	)

Here is the call graph for this function:

d_findgroup()

integer function d_bplus_utilities::d_findgroup	(	integer	idx,
		type(d_mesh)	msh,
		integer	level,
		integer	group
	)

*** Find the group index of point idx at the (grouplevel+level) level

d_findpggroup()

integer function d_bplus_utilities::d_findpggroup	(	integer	idx,
		type(d_mesh)	msh,
		type(d_proctree)	ptree,
		integer	group,
		integer	pgno
	)

*** Find the process group index of point idx in a group

Here is the call graph for this function:

d_full_block_extraction()

subroutine d_bplus_utilities::d_full_block_extraction	(	type(d_matrixblock)	blocks,
		type(d_intersect), dimension(:)	inters,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		type(d_hstat)	stats,
		type(d_hoption)	option
	)

d_full_block_md_mvp_dat()

subroutine d_bplus_utilities::d_full_block_md_mvp_dat	(	type(d_matrixblock_md)	blocks,
		character	chara,
		integer	M,
		integer	num_vectors,
		real(kind=8), dimension(ldi, *)	random1,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	random2,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b
	)

**** Multiply with dense blocks (as tensor). This is the same as d_Full_block_MVP_dat, except that blocks needs to be type(d_matrixblock_MD)

Here is the call graph for this function:

d_full_block_mvp_dat()

subroutine d_bplus_utilities::d_full_block_mvp_dat	(	type(d_matrixblock)	blocks,
		character	chara,
		integer	M,
		integer	num_vectors,
		real(kind=8), dimension(ldi, *)	random1,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	random2,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b
	)

**** Multiply with dense blocks.

Here is the call graph for this function:

d_hmat_block_computememory()

recursive subroutine d_bplus_utilities::d_hmat_block_computememory	(	type(d_matrixblock)	blocks,
		real*8	memory
	)

Here is the call graph for this function:

d_hmat_block_copy()

recursive subroutine d_bplus_utilities::d_hmat_block_copy	(	character	trans,
		type(d_matrixblock), pointer	block2,
		type(d_matrixblock), pointer	block1,
		real(kind=8), optional	memory
	)

Here is the call graph for this function:

d_hmat_block_delete()

recursive subroutine d_bplus_utilities::d_hmat_block_delete

(

type(d_matrixblock)

blocks

)

Here is the call graph for this function:

d_hmat_block_mvp_dat()

recursive subroutine d_bplus_utilities::d_hmat_block_mvp_dat	(	type(d_matrixblock)	blocks,
		character	trans,
		integer	idx_start_m,
		integer	idx_start_n,
		integer	Nrnd,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		integer, optional	level_start,
		integer, optional	level_end
	)

Here is the call graph for this function:

d_hmat_lsolve()

recursive subroutine d_bplus_utilities::d_hmat_lsolve	(	type(d_matrixblock)	blocks_l,
		character	trans,
		integer	idx_start,
		integer	nvec,
		real(kind=8), dimension(ld, *)	Vinout,
		integer	ld,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_hmat_parallelblock_mvp_dat()

subroutine d_bplus_utilities::d_hmat_parallelblock_mvp_dat	(	type(d_matrixblock)	blocks_1,
		character	chara,
		integer	M,
		integer	N,
		integer	Nrnd,
		real(kind=8), dimension(ldi, *)	random1,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	random2,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_hmat_usolve()

recursive subroutine d_bplus_utilities::d_hmat_usolve	(	type(d_matrixblock)	blocks_u,
		character	trans,
		integer	idx_start,
		integer	nvec,
		real(kind=8), dimension(ld, *)	Vinout,
		integer	ld,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_lr_all2all_extraction()

subroutine d_bplus_utilities::d_lr_all2all_extraction	(	type(d_matrixblock)	blocks,
		type(d_intersect), dimension(:)	inters,
		real(kind=8), dimension(rank, ncol)	Vpartial,
		integer	rank,
		integer	ncol,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh
	)

*********** all to all communication of columns in the V factor from the 1D block column layout to that needed by the 1D block row layout

Here is the call graph for this function:

d_lr_block_extraction()

subroutine d_bplus_utilities::d_lr_block_extraction	(	type(d_matrixblock)	blocks,
		type(d_intersect), dimension(:)	inters,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_nod_score_ipair()

real(kind=8) function d_bplus_utilities::d_nod_score_ipair

(

type(d_nod)

this

)

d_node_score_block_ptr_row()

real(kind=8) function d_bplus_utilities::d_node_score_block_ptr_row

(

type(d_nod)

this

)