Data Types
type	parallelsolutiontype

Functions/Subroutines
logical(lgp) function	par_has_converged (this, max_dvc)
	Check global convergence. The local maximum dependent variable change is reduced over MPI with all other processes. More...

integer(i4b) function	par_package_convergence (this, dpak, cpakout, iend)

integer(i4b) function	par_sync_newtonur_flag (this, inewtonur)

logical(lgp) function	par_nur_has_converged (this, dxold_max, hncg)

subroutine	par_calc_ptc (this, iptc, ptcf)
	Calculate pseudo-transient continuation factor. More...

subroutine	par_underrelax (this, kiter, bigch, neq, active, x, xtemp)
	apply under-relaxation in sync over all processes More...

subroutine	par_backtracking_xupdate (this, bt_flag)
	synchronize backtracking flag over processes More...

integer(i4b) function	par_get_idvscale (this)
	synchronize idvscale flag over processes More...

subroutine	par_maxval (this, nsize, v, vmax)
	synchronize maxval over processes More...

Function/Subroutine Documentation

◆ par_backtracking_xupdate()

subroutine parallelsolutionmodule::par_backtracking_xupdate	(	class(parallelsolutiontype), intent(inout)	this,
		integer(i4b), intent(inout)	bt_flag
	)

private

Parameters

[in,out]	this	ParallelSolutionType instance
[in,out]	bt_flag	global backtracking flag (1) backtracking performed (0) backtracking not performed

Definition at line 220 of file ParallelSolution.f90.

     ! -- dummy variables
     class(ParallelSolutionType), intent(inout) :: this !< ParallelSolutionType instance
     integer(I4B), intent(inout) :: bt_flag !< global backtracking flag (1) backtracking performed (0) backtracking not performed
     ! -- local variables
     integer(I4B) :: btflag_local
     type(MpiWorldType), pointer :: mpi_world
     integer :: ierr
  
     call g_prof%start("Parallel Solution (backtrack)", this%tmr_backtracking)
  
     mpi_world => get_mpi_world()
  
     ! get local bt flag
     btflag_local = this%NumericalSolutionType%get_backtracking_flag()
  
     ! reduce into global decision (if any, then all)
     call mpi_allreduce(btflag_local, bt_flag, 1, mpi_integer, &
                        mpi_max, mpi_world%comm, ierr)
     call check_mpi(ierr)
  
     ! perform backtracking if ...
     if (bt_flag > 0) then
       call this%NumericalSolutionType%apply_backtracking()
     end if
  
     call g_prof%stop(this%tmr_backtracking)
  

Here is the call graph for this function:

◆ par_calc_ptc()

subroutine parallelsolutionmodule::par_calc_ptc	(	class(parallelsolutiontype)	this,
		integer(i4b)	iptc,
		real(dp)	ptcf
	)

private

Parameters

this	parallel solution
iptc	PTC (1) or not (0)
ptcf	the (global) PTC factor calculated

Definition at line 147 of file ParallelSolution.f90.

     class(ParallelSolutionType) :: this !< parallel solution
     integer(I4B) :: iptc !< PTC (1) or not (0)
     real(DP) :: ptcf !< the (global) PTC factor calculated
     ! local
     integer(I4B) :: iptc_loc
     real(DP) :: ptcf_loc, ptcf_glo_max
     integer :: ierr
     type(MpiWorldType), pointer :: mpi_world
  
     call g_prof%start("Parallel Solution (PTC calc)", this%tmr_calcptc)
  
     mpi_world => get_mpi_world()
     call this%NumericalSolutionType%sln_calc_ptc(iptc_loc, ptcf_loc)
     if (iptc_loc == 0) ptcf_loc = dzero
  
     ! now reduce
     call mpi_allreduce(ptcf_loc, ptcf_glo_max, 1, mpi_double_precision, &
                        mpi_max, mpi_world%comm, ierr)
     call check_mpi(ierr)
  
     iptc = 0
     ptcf = dzero
     if (ptcf_glo_max > dzero) then
       iptc = 1
       ptcf = ptcf_glo_max
     end if
  
     call g_prof%stop(this%tmr_calcptc)
  

Here is the call graph for this function:

◆ par_get_idvscale()

integer(i4b) function parallelsolutionmodule::par_get_idvscale ( class(parallelsolutiontype) this )

private

Parameters

this	ParallelSolutionType instance

Returns: global idv_scale flag (1) dv_scaling performed (0) dv_scaling not performed (-1) error

Definition at line 252 of file ParallelSolution.f90.

     ! -- dummy variables
     class(ParallelSolutionType) :: this !< ParallelSolutionType instance
     integer(I4B) :: idv_scale_global !< global idv_scale flag (1) dv_scaling performed (0) dv_scaling not performed (-1) error
     ! -- local variables
     integer(I4B) :: idv_scale_local
     type(MpiWorldType), pointer :: mpi_world
     integer :: ierr
  
     mpi_world => get_mpi_world()
  
     ! get local idvscale flag
     idv_scale_local = this%NumericalSolutionType%sln_get_idvscale()
  
     ! reduce into global decision (if any, then all)
     call mpi_allreduce(idv_scale_local, idv_scale_global, 1, mpi_integer, &
                        mpi_min, mpi_world%comm, ierr)
     call check_mpi(ierr)
  

Here is the call graph for this function:

◆ par_has_converged()

logical(lgp) function parallelsolutionmodule::par_has_converged	(	class(parallelsolutiontype)	this,
		real(dp)	max_dvc
	)

private

Parameters

this	parallel solution
max_dvc	the LOCAL maximum dependent variable change

Returns: True, when GLOBALLY converged

Definition at line 40 of file ParallelSolution.f90.

     class(ParallelSolutionType) :: this !< parallel solution
     real(DP) :: max_dvc !< the LOCAL maximum dependent variable change
     logical(LGP) :: has_converged !< True, when GLOBALLY converged
     ! local
     real(DP) :: global_max_dvc
     real(DP) :: abs_max_dvc
     integer :: ierr
     type(MpiWorldType), pointer :: mpi_world
  
     call g_prof%start("Parallel Solution (cnvg check)", this%tmr_convergence)
  
     mpi_world => get_mpi_world()
  
     has_converged = .false.
     abs_max_dvc = abs(max_dvc)
     call mpi_allreduce(abs_max_dvc, global_max_dvc, 1, mpi_double_precision, &
                        mpi_max, mpi_world%comm, ierr)
     call check_mpi(ierr)
     if (global_max_dvc <= this%dvclose) then
       has_converged = .true.
     end if
  
     call g_prof%stop(this%tmr_convergence)
  

Here is the call graph for this function:

◆ par_maxval()

subroutine parallelsolutionmodule::par_maxval	(	class(parallelsolutiontype)	this,
		integer(i4b), intent(in)	nsize,
		real(dp), dimension(nsize), intent(in)	v,
		real(dp), intent(inout)	vmax
	)

private

Parameters

	this	ParallelSolutionType instance
[in]	nsize	length of vector
[in]	v	input vector
[in,out]	vmax	maximum value

Definition at line 275 of file ParallelSolution.f90.

     ! -- dummy variables
     class(ParallelSolutionType) :: this !< ParallelSolutionType instance
     integer(I4B), intent(in) :: nsize !< length of vector
     real(DP), dimension(nsize), intent(in) :: v !< input vector
     real(DP), intent(inout) :: vmax !< maximum value
     ! -- local variables
     real(DP) :: vmax_local
     real(DP) :: vmin_global
     type(MpiWorldType), pointer :: mpi_world
     integer :: ierr
  
     mpi_world => get_mpi_world()
  
     ! determine local vmax
     call this%NumericalSolutionType%sln_maxval(nsize, v, vmax_local)
  
     ! reduce into global decision (if any, then all)
     call mpi_allreduce(vmax_local, vmax, 1, mpi_double_precision, &
                        mpi_max, mpi_world%comm, ierr)
     call check_mpi(ierr)
  
     call mpi_allreduce(vmax_local, vmin_global, 1, mpi_double_precision, &
                        mpi_min, mpi_world%comm, ierr)
     call check_mpi(ierr)
  
     if (abs(vmin_global) > abs(vmax)) then
       vmax = vmin_global
     end if
  

Here is the call graph for this function:

◆ par_nur_has_converged()

logical(lgp) function parallelsolutionmodule::par_nur_has_converged	(	class(parallelsolutiontype)	this,
		real(dp), intent(in)	dxold_max,
		real(dp), intent(in)	hncg
	)

private

Parameters

	this	parallel solution instance
[in]	dxold_max	the maximum dependent variable change for cells not adjusted by NUR
[in]	hncg	largest dep. var. change at end of Picard iter.

Returns: True, when converged

Definition at line 113 of file ParallelSolution.f90.

     class(ParallelSolutionType) :: this !< parallel solution instance
     real(DP), intent(in) :: dxold_max !< the maximum dependent variable change for cells not adjusted by NUR
     real(DP), intent(in) :: hncg !< largest dep. var. change at end of Picard iter.
     logical(LGP) :: has_converged !< True, when converged
     ! local
     integer(I4B) :: icnvg_local
     integer(I4B) :: icnvg_global
     integer :: ierr
     type(MpiWorldType), pointer :: mpi_world
  
     call g_prof%start("Parallel Solution (NUR cnvg)", this%tmr_nur_cnvg)
  
     mpi_world => get_mpi_world()
  
     has_converged = .false.
     icnvg_local = 0
     if (this%NumericalSolutionType%sln_nur_has_converged( &
         dxold_max, hncg)) then
       icnvg_local = 1
     end if
  
     call mpi_allreduce(icnvg_local, icnvg_global, 1, mpi_integer, &
                        mpi_min, mpi_world%comm, ierr)
     call check_mpi(ierr)
     if (icnvg_global == 1) has_converged = .true.
  
     call g_prof%stop(this%tmr_nur_cnvg)
  

Here is the call graph for this function:

◆ par_package_convergence()

integer(i4b) function parallelsolutionmodule::par_package_convergence	(	class(parallelsolutiontype)	this,
		real(dp), intent(in)	dpak,
		character(len=lenpakloc), intent(in)	cpakout,
		integer(i4b), intent(in)	iend
	)

private

Parameters

	this	parallel solution instance
[in]	dpak	Newton Under-relaxation flag

Definition at line 67 of file ParallelSolution.f90.

     class(ParallelSolutionType) :: this !< parallel solution instance
     real(DP), intent(in) :: dpak !< Newton Under-relaxation flag
     character(len=LENPAKLOC), intent(in) :: cpakout
     integer(I4B), intent(in) :: iend
     ! local
     integer(I4B) :: icnvg_global
     integer(I4B) :: icnvg_local
     integer :: ierr
     type(MpiWorldType), pointer :: mpi_world
  
     call g_prof%start("Parallel Solution (package cnvg)", this%tmr_pkg_cnvg)
  
     mpi_world => get_mpi_world()
  
     icnvg_local = &
       this%NumericalSolutionType%sln_package_convergence(dpak, cpakout, iend)
  
     call mpi_allreduce(icnvg_local, icnvg_global, 1, mpi_integer, &
                        mpi_min, mpi_world%comm, ierr)
     call check_mpi(ierr)
  
     call g_prof%stop(this%tmr_pkg_cnvg)
  

Here is the call graph for this function:

◆ par_sync_newtonur_flag()

integer(i4b) function parallelsolutionmodule::par_sync_newtonur_flag	(	class(parallelsolutiontype)	this,
		integer(i4b), intent(in)	inewtonur
	)

private

Parameters

	this	parallel solution instance
[in]	inewtonur	local Newton Under-relaxation flag

Returns: Maximum of all local values (1 = under-relaxation applied)

Definition at line 94 of file ParallelSolution.f90.

     class(ParallelSolutionType) :: this !< parallel solution instance
     integer(I4B), intent(in) :: inewtonur !< local Newton Under-relaxation flag
     ! local
     integer(I4B) :: ivalue !< Maximum of all local values (1 = under-relaxation applied)
     integer :: ierr
     type(MpiWorldType), pointer :: mpi_world
  
     call g_prof%start("Parallel Solution (NUR)", this%tmr_sync_nur)
  
     mpi_world => get_mpi_world()
     call mpi_allreduce(inewtonur, ivalue, 1, mpi_integer, &
                        mpi_max, mpi_world%comm, ierr)
     call check_mpi(ierr)
  
     call g_prof%stop(this%tmr_sync_nur)
  

Here is the call graph for this function:

◆ par_underrelax()

subroutine parallelsolutionmodule::par_underrelax	(	class(parallelsolutiontype)	this,
		integer(i4b), intent(in)	kiter,
		real(dp), intent(in)	bigch,
		integer(i4b), intent(in)	neq,
		integer(i4b), dimension(neq), intent(in)	active,
		real(dp), dimension(neq), intent(inout)	x,
		real(dp), dimension(neq), intent(in)	xtemp
	)

private

Parameters

	this	parallel instance
[in]	kiter	Picard iteration number
[in]	bigch	maximum dependent-variable change
[in]	neq	number of equations
[in]	active	active cell flag (1)
[in,out]	x	current dependent-variable
[in]	xtemp	previous dependent-variable

Definition at line 181 of file ParallelSolution.f90.

     class(ParallelSolutionType) :: this !< parallel instance
     integer(I4B), intent(in) :: kiter !< Picard iteration number
     real(DP), intent(in) :: bigch !< maximum dependent-variable change
     integer(I4B), intent(in) :: neq !< number of equations
     integer(I4B), dimension(neq), intent(in) :: active !< active cell flag (1)
     real(DP), dimension(neq), intent(inout) :: x !< current dependent-variable
     real(DP), dimension(neq), intent(in) :: xtemp !< previous dependent-variable
     ! local
     real(DP) :: dvc_global_max, dvc_global_min
     integer :: ierr
     type(MpiWorldType), pointer :: mpi_world
  
     call g_prof%start("Parallel Solution (underrelax)", this%tmr_underrelax)
  
     mpi_world => get_mpi_world()
  
     ! first reduce largest change over all processes
     call mpi_allreduce(bigch, dvc_global_max, 1, mpi_double_precision, &
                        mpi_max, mpi_world%comm, ierr)
     call check_mpi(ierr)
     call mpi_allreduce(bigch, dvc_global_min, 1, mpi_double_precision, &
                        mpi_min, mpi_world%comm, ierr)
     call check_mpi(ierr)
  
     if (abs(dvc_global_min) > abs(dvc_global_max)) then
       dvc_global_max = dvc_global_min
     end if
  
     ! call local underrelax routine
     call this%NumericalSolutionType%sln_underrelax(kiter, dvc_global_max, &
                                                    neq, active, x, xtemp)
  
     call g_prof%stop(this%tmr_underrelax)
  

Here is the call graph for this function:

Data Types

Functions/Subroutines

Function/Subroutine Documentation

◆ par_backtracking_xupdate()

◆ par_calc_ptc()

◆ par_get_idvscale()

◆ par_has_converged()

◆ par_maxval()

◆ par_nur_has_converged()

◆ par_package_convergence()

◆ par_sync_newtonur_flag()

◆ par_underrelax()