mom_coms Module Reference

Data Types
interface	assignment(=)
type	efp_type
interface	operator(+)
interface	operator(-)
interface	reproducing_sum

Functions/Subroutines
real function	reproducing_sum_2d (array, isr, ier, jsr, jer, EFP_sum, reproducing, overflow_check, err)
real function	reproducing_sum_3d (array, isr, ier, jsr, jer, sums, EFP_sum, err)
integer(kind=8) function, dimension(ni)	real_to_ints (r, prec_error, overflow)
real function	ints_to_real (ints)
subroutine	increment_ints (int_sum, int2, prec_error)
subroutine	increment_ints_faster (int_sum, r, max_mag_term)
subroutine	carry_overflow (int_sum, prec_error)
subroutine	regularize_ints (int_sum)
logical function, public	query_efp_overflow_error ()
subroutine, public	reset_efp_overflow_error ()
type(efp_type) function, public	efp_plus (EFP1, EFP2)
type(efp_type) function, public	efp_minus (EFP1, EFP2)
subroutine	efp_assign (EFP1, EFP2)
real function, public	efp_to_real (EFP1)
real function, public	efp_real_diff (EFP1, EFP2)
type(efp_type) function, public	real_to_efp (val, overflow)
subroutine, public	efp_list_sum_across_pes (EFPs, nval, errors)
subroutine, public	mom_infra_end

Variables
integer(kind=8), parameter	prec =2_8**46
real, parameter	r_prec =2.0**46
real, parameter	i_prec =1.0/(2.0**46)
integer, parameter	max_count_prec =2**(63-46)-1
integer, parameter	ni =6
real, dimension(ni), parameter	pr = (/ r_prec**2, r_prec, 1.0, 1.0/r_prec, 1.0/r_prec**2, 1.0/r_prec**3 /)
real, dimension(ni), parameter	i_pr = (/ 1.0/r_prec**2, 1.0/r_prec, 1.0, r_prec, r_prec**2, r_prec**3 /)
logical	overflow_error = .false.
logical	nan_error = .false.
logical	debug = .false.

Function/Subroutine Documentation

carry_overflow()

subroutine mom_coms::carry_overflow ( integer(kind=8), dimension(ni), intent(inout)  int_sum, integer(kind=8), intent(in)  prec_error  )

private

Definition at line 488 of file MOM_coms.F90.

References i_prec, ni, overflow_error, and prec.

Referenced by efp_list_sum_across_pes(), reproducing_sum_2d(), and reproducing_sum_3d().

  integer(kind=8), dimension(ni), intent(inout) :: int_sum
  integer(kind=8),                intent(in)    :: prec_error

  ! This subroutine handles carrying of the overflow.
  integer :: i, num_carry

  do i=ni,2,-1 ; if (abs(int_sum(i)) > prec) then
    num_carry = int(int_sum(i) * i_prec)
    int_sum(i) = int_sum(i) - num_carry*prec
    int_sum(i-1) = int_sum(i-1) + num_carry
  endif ; enddo
  if (abs(int_sum(1)) > prec_error) then
    overflow_error = .true.
  endif

Here is the caller graph for this function:

efp_assign()

subroutine mom_coms::efp_assign ( type(efp_type), intent(out)  EFP1, type(efp_type), intent(in)  EFP2  )

private

Definition at line 571 of file MOM_coms.F90.

References ni.

  type(efp_type), intent(out) :: efp1
  type(efp_type), intent(in)  :: efp2
  integer i
  ! This subroutine assigns all components of the extended fixed point type
  ! variable on the RHS (EFP2) to the components of the variable on the LHS
  ! (EFP1).

  do i=1,ni ; efp1%v(i) = efp2%v(i) ; enddo

efp_list_sum_across_pes()

subroutine, public mom_coms::efp_list_sum_across_pes	(	type(efp_type), dimension(:), intent(inout)	EFPs,
		integer, intent(in)	nval,
		logical, dimension(:), intent(out), optional	errors
	)

Definition at line 622 of file MOM_coms.F90.

References carry_overflow(), efp_to_real(), max_count_prec, mom_error_handler::mom_error(), ni, and overflow_error.

  type(efp_type), dimension(:), intent(inout) :: efps
  integer, intent(in) :: nval
  logical, dimension(:), optional, intent(out) :: errors

  !   This subroutine does a sum across PEs of a list of EFP variables,
  ! returning the sums in place, with all overflows carried.

  integer(kind=8), dimension(ni,nval) :: ints
  integer(kind=8) :: prec_error
  logical :: error_found
  character(len=256) :: mesg
  integer :: i, n

  if (num_pes() > max_count_prec) call mom_error(fatal, &
    "reproducing_sum: Too many processors are being used for the value of "//&
    "prec.  Reduce prec to (2^63-1)/num_PEs.")

  prec_error = (2_8**62 + (2_8**62 - 1)) / num_pes()
  ! overflow_error is an overflow error flag for the whole module.
  overflow_error = .false. ; error_found = .false.

  do i=1,nval ; do n=1,ni ; ints(n,i) = efps(i)%v(n) ; enddo ; enddo

  call sum_across_pes(ints(:,:), ni*nval)

  if (present(errors)) errors(:) = .false.
  do i=1,nval
    overflow_error = .false.
    call carry_overflow(ints(:,i), prec_error)
    do n=1,ni ; efps(i)%v(n) = ints(n,i) ; enddo
    if (present(errors)) errors(i) = overflow_error
    if (overflow_error) then
      write (mesg,'("EFP_list_sum_across_PEs error at ",i6," val was ",ES12.6, ", prec_error = ",ES12.6)') &
             i, efp_to_real(efps(i)), real(prec_error)
      call mom_error(warning, mesg)
    endif
    error_found = error_found .or. overflow_error
  enddo
  if (error_found .and. .not.(present(errors))) then
    call mom_error(fatal, "Overflow in EFP_list_sum_across_PEs.")
  endif

Here is the call graph for this function:

efp_minus()

type(efp_type) function, public mom_coms::efp_minus	(	type(efp_type), intent(in)	EFP1,
		type(efp_type), intent(in)	EFP2
	)

Definition at line 561 of file MOM_coms.F90.

References increment_ints(), and ni.

  type(efp_type)             :: efp_minus
  type(efp_type), intent(in) :: efp1, efp2
  integer :: i

  do i=1,ni ; efp_minus%v(i) = -1*efp2%v(i) ; enddo

  call increment_ints(efp_minus%v(:), efp1%v(:))

Here is the call graph for this function:

efp_plus()

type(efp_type) function, public mom_coms::efp_plus	(	type(efp_type), intent(in)	EFP1,
		type(efp_type), intent(in)	EFP2
	)

Definition at line 552 of file MOM_coms.F90.

References increment_ints().

  type(efp_type)             :: efp_plus
  type(efp_type), intent(in) :: efp1, efp2

  efp_plus = efp1

  call increment_ints(efp_plus%v(:), efp2%v(:))

Here is the call graph for this function:

efp_real_diff()

real function, public mom_coms::efp_real_diff	(	type(efp_type), intent(in)	EFP1,
		type(efp_type), intent(in)	EFP2
	)

Definition at line 590 of file MOM_coms.F90.

References efp_to_real().

  type(efp_type), intent(in) :: efp1, efp2
  real :: efp_real_diff

  type(efp_type)             :: efp_diff

  efp_diff = efp1 - efp2
  efp_real_diff = efp_to_real(efp_diff)

Here is the call graph for this function:

efp_to_real()

real function, public mom_coms::efp_to_real

(

type(efp_type), intent(inout)

EFP1

)

Definition at line 582 of file MOM_coms.F90.

References ints_to_real(), and regularize_ints().

Referenced by efp_list_sum_across_pes(), efp_real_diff(), and mom_sum_output::write_energy().

  type(efp_type), intent(inout) :: efp1
  real :: efp_to_real

  call regularize_ints(efp1%v)
  efp_to_real = ints_to_real(efp1%v)

Here is the call graph for this function:

Here is the caller graph for this function:

increment_ints()

subroutine mom_coms::increment_ints ( integer(kind=8), dimension(ni), intent(inout)  int_sum, integer(kind=8), dimension(ni), intent(in)  int2, integer(kind=8), intent(in), optional  prec_error  )

private

Definition at line 434 of file MOM_coms.F90.

References ni, overflow_error, and prec.

Referenced by efp_minus(), efp_plus(), reproducing_sum_2d(), and reproducing_sum_3d().

  integer(kind=8), dimension(ni), intent(inout) :: int_sum
  integer(kind=8), dimension(ni), intent(in)    :: int2
  integer(kind=8), optional,      intent(in)    :: prec_error

  ! This subroutine increments a number with another, both using the integer
  ! representation in real_to_ints.
  integer :: i

  do i=ni,2,-1
    int_sum(i) = int_sum(i) + int2(i)
    ! Carry the local overflow.
    if (int_sum(i) > prec) then
      int_sum(i) = int_sum(i) - prec
      int_sum(i-1) = int_sum(i-1) + 1
    elseif (int_sum(i) < -prec) then
      int_sum(i) = int_sum(i) + prec
      int_sum(i-1) = int_sum(i-1) - 1
    endif
  enddo
  int_sum(1) = int_sum(1) + int2(1)
  if (present(prec_error)) then
    if (abs(int_sum(1)) > prec_error) overflow_error = .true.
  else
    if (abs(int_sum(1)) > prec) overflow_error = .true.
  endif

Here is the caller graph for this function:

increment_ints_faster()

subroutine mom_coms::increment_ints_faster ( integer(kind=8), dimension(ni), intent(inout)  int_sum, real, intent(in)  r, real, intent(inout)  max_mag_term  )

private

Definition at line 463 of file MOM_coms.F90.

References i_pr, nan_error, ni, and pr.

Referenced by reproducing_sum_2d(), and reproducing_sum_3d().

  integer(kind=8), dimension(ni), intent(inout) :: int_sum
  real,                           intent(in)    :: r
  real,                           intent(inout) :: max_mag_term

  ! This subroutine increments a number with another, both using the integer
  ! representation in real_to_ints, but without doing any carrying of overflow.
  ! The entire operation is embedded in a single call for greater speed.
  real :: rs
  integer(kind=8) :: ival
  integer :: sgn, i

  if ((r >= 1e30) .eqv. (r < 1e30)) then ; nan_error = .true. ; return ; endif
  sgn = 1 ; if (r<0.0) sgn = -1
  rs = abs(r)
  if (rs > abs(max_mag_term)) max_mag_term = r

  do i=1,ni
    ival = int(rs*i_pr(i), 8)
    rs = rs - ival*pr(i)
    int_sum(i) = int_sum(i) + sgn*ival
  enddo

Here is the caller graph for this function:

ints_to_real()

real function mom_coms::ints_to_real ( integer(kind=8), dimension(ni), intent(in)  ints )

private

Definition at line 423 of file MOM_coms.F90.

References ni, and pr.

Referenced by efp_to_real(), reproducing_sum_2d(), and reproducing_sum_3d().

  integer(kind=8), dimension(ni), intent(in) :: ints
  real :: r
  ! This subroutine reverses the conversion in real_to_ints.

  integer :: i

  r = 0.0
  do i=1,ni ; r = r + pr(i)*ints(i) ; enddo

Here is the caller graph for this function:

mom_infra_end()

subroutine, public mom_coms::mom_infra_end

(

)

Definition at line 667 of file MOM_coms.F90.

  ! This subroutine should contain all of the calls that are required
  ! to close out the infrastructure cleanly.  This should only be called
  ! in ocean-only runs, as the coupler takes care of this in coupled runs.
  call print_memuse_stats( 'Memory HiWaterMark', always=.true. )
  call fms_end

query_efp_overflow_error()

logical function, public mom_coms::query_efp_overflow_error

(

)

Definition at line 543 of file MOM_coms.F90.

References overflow_error.

Referenced by mom_spatial_means::global_i_mean(), and mom_spatial_means::global_j_mean().

  logical :: query_efp_overflow_error
  query_efp_overflow_error = overflow_error

Here is the caller graph for this function:

real_to_efp()

type(efp_type) function, public mom_coms::real_to_efp	(	real, intent(in)	val,
		logical, intent(inout), optional	overflow
	)

Definition at line 601 of file MOM_coms.F90.

References mom_error_handler::mom_error(), and real_to_ints().

Referenced by mom_sum_output::write_energy().

  real,              intent(in)    :: val
  logical, optional, intent(inout) :: overflow
  type(efp_type) :: real_to_efp

  logical :: over
  character(len=80) :: mesg

  if (present(overflow)) then
    real_to_efp%v(:) = real_to_ints(val, overflow=overflow)
  else
    over = .false.
    real_to_efp%v(:) = real_to_ints(val, overflow=over)
    if (over) then
      write(mesg, '(ES13.5)') val
      call mom_error(fatal,"Overflow in real_to_EFP conversion of "//trim(mesg))
    endif
  endif

Here is the call graph for this function:

Here is the caller graph for this function:

real_to_ints()

integer(kind=8) function, dimension(ni) mom_coms::real_to_ints ( real, intent(in)  r, integer(kind=8), intent(in), optional  prec_error, logical, intent(inout), optional  overflow  )

private

Definition at line 387 of file MOM_coms.F90.

References i_pr, mom_error_handler::mom_error(), nan_error, ni, pr, and prec.

Referenced by real_to_efp(), reproducing_sum_2d(), and reproducing_sum_3d().

  real,                      intent(in) :: r
  integer(kind=8), optional, intent(in) :: prec_error
  logical,         optional, intent(inout) :: overflow
  integer(kind=8), dimension(ni)  :: ints
  !   This subroutine converts a real number to an equivalent representation
  ! using several long integers.

  real :: rs
  character(len=80) :: mesg
  integer(kind=8) :: ival, prec_err
  integer :: sgn, i

  prec_err = prec ; if (present(prec_error)) prec_err = prec_error
  ints(:) = 0_8
  if ((r >= 1e30) .eqv. (r < 1e30)) then ; nan_error = .true. ; return ; endif

  sgn = 1 ; if (r<0.0) sgn = -1
  rs = abs(r)

  if (present(overflow)) then
    if (.not.(rs < prec_err*pr(1))) overflow = .true.
    if ((r >= 1e30) .eqv. (r < 1e30)) overflow = .true.
  elseif (.not.(rs < prec_err*pr(1))) then
    write(mesg, '(ES13.5)') r
    call mom_error(fatal,"Overflow in real_to_ints conversion of "//trim(mesg))
  endif

  do i=1,ni
    ival = int(rs*i_pr(i), 8)
    rs = rs - ival*pr(i)
    ints(i) = sgn*ival
  enddo

Here is the call graph for this function:

Here is the caller graph for this function:

regularize_ints()

subroutine mom_coms::regularize_ints ( integer(kind=8), dimension(ni), intent(inout)  int_sum )

private

Definition at line 506 of file MOM_coms.F90.

References i_prec, ni, and prec.

Referenced by efp_to_real(), reproducing_sum_2d(), and reproducing_sum_3d().

  integer(kind=8), dimension(ni), intent(inout) :: int_sum

  ! This subroutine carries the overflow, and then makes sure that
  ! all integers are of the same sign as the overall value.
  logical :: positive
  integer :: i, num_carry

  do i=ni,2,-1 ; if (abs(int_sum(i)) > prec) then
    num_carry = int(int_sum(i) * i_prec)
    int_sum(i) = int_sum(i) - num_carry*prec
    int_sum(i-1) = int_sum(i-1) + num_carry
  endif ; enddo

  ! Determine the sign of the final number.
  positive = .true.
  do i=1,ni
    if (abs(int_sum(i)) > 0) then
      if (int_sum(i) < 0) positive = .false.
      exit
    endif
  enddo

  if (positive) then
    do i=ni,2,-1 ; if (int_sum(i) < 0) then
      int_sum(i) = int_sum(i) + prec
      int_sum(i-1) = int_sum(i-1) - 1
    endif ; enddo
  else
    do i=ni,2,-1 ; if (int_sum(i) > 0) then
      int_sum(i) = int_sum(i) - prec
      int_sum(i-1) = int_sum(i-1) + 1
    endif ; enddo
  endif

Here is the caller graph for this function:

reproducing_sum_2d()

real function mom_coms::reproducing_sum_2d ( real, dimension(:,:), intent(in)  array, integer, intent(in), optional  isr, integer, intent(in), optional  ier, integer, intent(in), optional  jsr, integer, intent(in), optional  jer, type(efp_type), intent(out), optional  EFP_sum, logical, intent(in), optional  reproducing, logical, intent(in), optional  overflow_check, integer, intent(out), optional  err  )

private

Definition at line 80 of file MOM_coms.F90.

References carry_overflow(), debug, i_pr, increment_ints(), increment_ints_faster(), ints_to_real(), max_count_prec, mom_error_handler::mom_error(), mom_error_handler::mom_mesg(), nan_error, ni, overflow_error, pr, real_to_ints(), and regularize_ints().

  real, dimension(:,:),     intent(in) :: array
  integer,        optional, intent(in)  :: isr, ier, jsr, jer
  type(efp_type), optional, intent(out) :: efp_sum
  logical,        optional, intent(in)  :: reproducing
  logical,        optional, intent(in)  :: overflow_check
  integer,        optional, intent(out) :: err
  real                                  :: sum  ! Result

  !   This subroutine uses a conversion to an integer representation
  ! of real numbers to give order-invariant sums that will reproduce
  ! across PE count.  This idea comes from R. Hallberg and A. Adcroft.

  integer(kind=8), dimension(ni)  :: ints_sum
  integer(kind=8) :: ival, prec_error
  real    :: rsum(1), rs
  real    :: max_mag_term
  logical :: repro, over_check
  character(len=256) :: mesg
  integer :: i, j, n, is, ie, js, je, sgn

  if (num_pes() > max_count_prec) call mom_error(fatal, &
    "reproducing_sum: Too many processors are being used for the value of "//&
    "prec.  Reduce prec to (2^63-1)/num_PEs.")

  prec_error = (2_8**62 + (2_8**62 - 1)) / num_pes()

  is = 1 ; ie = size(array,1) ; js = 1 ; je = size(array,2 )
  if (present(isr)) then
    if (isr < is) call mom_error(fatal, &
      "Value of isr too small in reproducing_sum_2d.")
    is = isr
  endif
  if (present(ier)) then
    if (ier > ie) call mom_error(fatal, &
      "Value of ier too large in reproducing_sum_2d.")
    ie = ier
  endif
  if (present(jsr)) then
    if (jsr < js) call mom_error(fatal, &
      "Value of jsr too small in reproducing_sum_2d.")
    js = jsr
  endif
  if (present(jer)) then
    if (jer > je) call mom_error(fatal, &
      "Value of jer too large in reproducing_sum_2d.")
    je = jer
  endif

  repro = .true. ; if (present(reproducing)) repro = reproducing
  over_check = .true. ; if (present(overflow_check)) over_check = overflow_check

  if (repro) then
    overflow_error = .false. ; nan_error = .false. ; max_mag_term = 0.0
    ints_sum(:) = 0
    if (over_check) then
      if ((je+1-js)*(ie+1-is) < max_count_prec) then
        do j=js,je ; do i=is,ie
          call increment_ints_faster(ints_sum, array(i,j), max_mag_term);
        enddo ; enddo
        call carry_overflow(ints_sum, prec_error)
      elseif ((ie+1-is) < max_count_prec) then
        do j=js,je
          do i=is,ie
            call increment_ints_faster(ints_sum, array(i,j), max_mag_term);
          enddo
          call carry_overflow(ints_sum, prec_error)
        enddo
      else
        do j=js,je ; do i=is,ie
          call increment_ints(ints_sum, real_to_ints(array(i,j), prec_error), &
                              prec_error);
        enddo ; enddo
      endif
    else
      do j=js,je ; do i=is,ie
        sgn = 1 ; if (array(i,j)<0.0) sgn = -1
        rs = abs(array(i,j))
        do n=1,ni
          ival = int(rs*i_pr(n), 8)
          rs = rs - ival*pr(n)
          ints_sum(n) = ints_sum(n) + sgn*ival
        enddo
      enddo ; enddo
      call carry_overflow(ints_sum, prec_error)
    endif

    if (present(err)) then
      err = 0
      if (overflow_error) &
        err = err+2
      if (nan_error) &
        err = err+4
      if (err > 0) then ; do n=1,ni ; ints_sum(n) = 0 ; enddo ; endif
    else
      if (nan_error) then
        call mom_error(fatal, "NaN in input field of reproducing_sum(_2d).")
      endif
      if (abs(max_mag_term) >= prec_error*pr(1)) then
        write(mesg, '(ES13.5)') max_mag_term
        call mom_error(fatal,"Overflow in reproducing_sum(_2d) conversion of "//trim(mesg))
      endif
      if (overflow_error) then
        call mom_error(fatal, "Overflow in reproducing_sum(_2d).")
      endif
    endif

    call sum_across_pes(ints_sum, ni)

    call regularize_ints(ints_sum)
    sum = ints_to_real(ints_sum)
  else
    rsum(1) = 0.0
    do j=js,je ; do i=is,ie
      rsum(1) = rsum(1) + array(i,j);
    enddo ; enddo
    call sum_across_pes(rsum,1)
    sum = rsum(1)

    if (present(err)) then ; err = 0 ; endif

    if (debug .or. present(efp_sum)) then
      overflow_error = .false.
      ints_sum = real_to_ints(sum, prec_error, overflow_error)
      if (overflow_error) then
        if (present(err)) then
          err = err + 2
        else
          write(mesg, '(ES13.5)') sum
          call mom_error(fatal,"Repro_sum_2d: Overflow in real_to_ints conversion of "//trim(mesg))
        endif
      endif
    endif
  endif

  if (present(efp_sum)) efp_sum%v(:) = ints_sum(:)

  if (debug) then
    write(mesg,'("2d RS: ", ES24.16, 6 Z17.16)') sum, ints_sum(1:ni)
    call mom_mesg(mesg, 3)
  endif

Here is the call graph for this function:

reproducing_sum_3d()

real function mom_coms::reproducing_sum_3d ( real, dimension(:,:,:), intent(in)  array, integer, intent(in), optional  isr, integer, intent(in), optional  ier, integer, intent(in), optional  jsr, integer, intent(in), optional  jer, real, dimension(:), intent(out), optional  sums, type(efp_type), intent(out), optional  EFP_sum, integer, intent(out), optional  err  )

private

Definition at line 225 of file MOM_coms.F90.

References carry_overflow(), debug, increment_ints(), increment_ints_faster(), ints_to_real(), max_count_prec, mom_error_handler::mom_error(), mom_error_handler::mom_mesg(), nan_error, ni, overflow_error, pr, real_to_ints(), and regularize_ints().

  real, dimension(:,:,:),        intent(in) :: array
  integer,    optional,          intent(in) :: isr, ier, jsr, jer
  real, dimension(:), optional, intent(out) :: sums
  type(efp_type),     optional, intent(out) :: efp_sum
  integer,            optional, intent(out) :: err
  real                                      :: sum  ! Result

  !   This subroutine uses a conversion to an integer representation
  ! of real numbers to give order-invariant sums that will reproduce
  ! across PE count.  This idea comes from R. Hallberg and A. Adcroft.

  real    :: max_mag_term
  integer(kind=8), dimension(ni)  :: ints_sum
  integer(kind=8), dimension(ni,size(array,3))  :: ints_sums
  integer(kind=8) :: prec_error
  character(len=256) :: mesg
  integer :: i, j, k, is, ie, js, je, ke, isz, jsz, n

  if (num_pes() > max_count_prec) call mom_error(fatal, &
    "reproducing_sum: Too many processors are being used for the value of "//&
    "prec.  Reduce prec to (2^63-1)/num_PEs.")

  prec_error = (2_8**62 + (2_8**62 - 1)) / num_pes()
  max_mag_term = 0.0

  is = 1 ; ie = size(array,1) ; js = 1 ; je = size(array,2) ; ke = size(array,3)
  if (present(isr)) then
    if (isr < is) call mom_error(fatal, &
      "Value of isr too small in reproducing_sum(_3d).")
    is = isr
  endif
  if (present(ier)) then
    if (ier > ie) call mom_error(fatal, &
      "Value of ier too large in reproducing_sum(_3d).")
    ie = ier
  endif
  if (present(jsr)) then
    if (jsr < js) call mom_error(fatal, &
      "Value of jsr too small in reproducing_sum(_3d).")
    js = jsr
  endif
  if (present(jer)) then
    if (jer > je) call mom_error(fatal, &
      "Value of jer too large in reproducing_sum(_3d).")
    je = jer
  endif
  jsz = je+1-js; isz = ie+1-is

  if (present(sums)) then
    if (size(sums) > ke) call mom_error(fatal, "Sums is smaller than "//&
      "the vertical extent of array in reproducing_sum(_3d).")
    ints_sums(:,:) = 0
    overflow_error = .false. ; nan_error = .false. ; max_mag_term = 0.0
    if (jsz*isz < max_count_prec) then
      do k=1,ke
        do j=js,je ; do i=is,ie
          call increment_ints_faster(ints_sums(:,k), array(i,j,k), max_mag_term);
        enddo ; enddo
        call carry_overflow(ints_sums(:,k), prec_error)
      enddo
    elseif (isz < max_count_prec) then
      do k=1,ke ; do j=js,je
        do i=is,ie
          call increment_ints_faster(ints_sums(:,k), array(i,j,k), max_mag_term);
        enddo
        call carry_overflow(ints_sums(:,k), prec_error)
      enddo ; enddo
    else
      do k=1,ke ; do j=js,je ; do i=is,ie
        call increment_ints(ints_sums(:,k), &
                            real_to_ints(array(i,j,k), prec_error), prec_error);
      enddo ; enddo ; enddo
    endif
    if (present(err)) then
      err = 0
      if (abs(max_mag_term) >= prec_error*pr(1)) err = err+1
      if (overflow_error) err = err+2
      if (nan_error) err = err+2
      if (err > 0) then ; do k=1,ke ; do n=1,ni ; ints_sums(n,k) = 0 ; enddo ; enddo ; endif
    else
      if (nan_error) call mom_error(fatal, "NaN in input field of reproducing_sum(_3d).")
      if (abs(max_mag_term) >= prec_error*pr(1)) then
        write(mesg, '(ES13.5)') max_mag_term
        call mom_error(fatal,"Overflow in reproducing_sum(_3d) conversion of "//trim(mesg))
      endif
      if (overflow_error) call mom_error(fatal, "Overflow in reproducing_sum(_3d).")
    endif

    call sum_across_pes(ints_sums(:,1:ke), ni*ke)

    sum = 0.0
    do k=1,ke
      call regularize_ints(ints_sums(:,k))
      sums(k) = ints_to_real(ints_sums(:,k))
      sum = sum + sums(k)
    enddo

    if (present(efp_sum)) then
      efp_sum%v(:) = 0
      do k=1,ke ; call increment_ints(efp_sum%v(:), ints_sums(:,k)) ; enddo
    endif

    if (debug) then
      do n=1,ni ; ints_sum(n) = 0 ; enddo
      do k=1,ke ; do n=1,ni ; ints_sum(n) = ints_sum(n) + ints_sums(n,k) ; enddo ; enddo
      write(mesg,'("3D RS: ", ES24.16, 6 Z17.16)') sum, ints_sum(1:ni)
      call mom_mesg(mesg, 3)
    endif
  else
    ints_sum(:) = 0
    overflow_error = .false. ; nan_error = .false. ; max_mag_term = 0.0
    if (jsz*isz < max_count_prec) then
      do k=1,ke
        do j=js,je ; do i=is,ie
          call increment_ints_faster(ints_sum, array(i,j,k), max_mag_term);
        enddo ; enddo
        call carry_overflow(ints_sum, prec_error)
      enddo
    elseif (isz < max_count_prec) then
      do k=1,ke ; do j=js,je
        do i=is,ie
          call increment_ints_faster(ints_sum, array(i,j,k), max_mag_term);
        enddo
        call carry_overflow(ints_sum, prec_error)
      enddo ; enddo
    else
      do k=1,ke ; do j=js,je ; do i=is,ie
        call increment_ints(ints_sum, real_to_ints(array(i,j,k), prec_error), &
                            prec_error);
      enddo ; enddo ; enddo
    endif
    if (present(err)) then
      err = 0
      if (abs(max_mag_term) >= prec_error*pr(1)) err = err+1
      if (overflow_error) err = err+2
      if (nan_error) err = err+2
      if (err > 0) then ; do n=1,ni ; ints_sum(n) = 0 ; enddo ; endif
    else
      if (nan_error) call mom_error(fatal, "NaN in input field of reproducing_sum(_3d).")
      if (abs(max_mag_term) >= prec_error*pr(1)) then
        write(mesg, '(ES13.5)') max_mag_term
        call mom_error(fatal,"Overflow in reproducing_sum(_3d) conversion of "//trim(mesg))
      endif
      if (overflow_error) call mom_error(fatal, "Overflow in reproducing_sum(_3d).")
    endif

    call sum_across_pes(ints_sum, ni)

    call regularize_ints(ints_sum)
    sum = ints_to_real(ints_sum)

    if (present(efp_sum)) efp_sum%v(:) = ints_sum(:)

    if (debug) then
      write(mesg,'("3d RS: ", ES24.16, 6 Z17.16)') sum, ints_sum(1:ni)
      call mom_mesg(mesg, 3)
    endif
  endif

Here is the call graph for this function:

reset_efp_overflow_error()

subroutine, public mom_coms::reset_efp_overflow_error

(

)

Definition at line 548 of file MOM_coms.F90.

References overflow_error.

Referenced by mom_spatial_means::global_i_mean(), and mom_spatial_means::global_j_mean().

  overflow_error = .false.

Here is the caller graph for this function:

Variable Documentation

debug

logical mom_coms::debug = .false.

private

Definition at line 60 of file MOM_coms.F90.

Referenced by reproducing_sum_2d(), and reproducing_sum_3d().

logical :: debug = .false.    ! Making this true enables debugging output.

i_pr

real, dimension(ni), parameter mom_coms::i_pr = (/ 1.0/r_prec**2, 1.0/r_prec, 1.0, r_prec, r_prec**2, r_prec**3 /)

private

Definition at line 56 of file MOM_coms.F90.

Referenced by increment_ints_faster(), real_to_ints(), and reproducing_sum_2d().

real, parameter, dimension(ni) :: &
  i_pr = (/ 1.0/r_prec**2, 1.0/r_prec, 1.0, r_prec, r_prec**2, r_prec**3 /)

i_prec

real, parameter mom_coms::i_prec =1.0/(2.0**46)

private

Definition at line 46 of file MOM_coms.F90.

Referenced by carry_overflow(), and regularize_ints().

real, parameter :: i_prec=1.0/(2.0**46) ! The inverse of prec.

max_count_prec

integer, parameter mom_coms::max_count_prec =2**(63-46)-1

private

Definition at line 47 of file MOM_coms.F90.

Referenced by efp_list_sum_across_pes(), reproducing_sum_2d(), and reproducing_sum_3d().

integer, parameter :: max_count_prec=2**(63-46)-1

nan_error

logical mom_coms::nan_error = .false.

private

Definition at line 59 of file MOM_coms.F90.

Referenced by increment_ints_faster(), real_to_ints(), reproducing_sum_2d(), and reproducing_sum_3d().

ni

integer, parameter mom_coms::ni =6

private

Definition at line 52 of file MOM_coms.F90.

Referenced by carry_overflow(), efp_assign(), efp_list_sum_across_pes(), efp_minus(), increment_ints(), increment_ints_faster(), ints_to_real(), real_to_ints(), regularize_ints(), reproducing_sum_2d(), and reproducing_sum_3d().

integer, parameter :: ni=6    ! The number of long integers to use to represent

overflow_error

logical mom_coms::overflow_error = .false.

private

Definition at line 59 of file MOM_coms.F90.

Referenced by carry_overflow(), efp_list_sum_across_pes(), increment_ints(), query_efp_overflow_error(), reproducing_sum_2d(), reproducing_sum_3d(), and reset_efp_overflow_error().

logical :: overflow_error = .false., nan_error = .false.

pr

real, dimension(ni), parameter mom_coms::pr = (/ r_prec**2, r_prec, 1.0, 1.0/r_prec, 1.0/r_prec**2, 1.0/r_prec**3 /)

private

Definition at line 54 of file MOM_coms.F90.

Referenced by increment_ints_faster(), ints_to_real(), real_to_ints(), reproducing_sum_2d(), and reproducing_sum_3d().

real, parameter, dimension(ni) :: &
  pr = (/ r_prec**2, r_prec, 1.0, 1.0/r_prec, 1.0/r_prec**2, 1.0/r_prec**3 /)

prec

integer(kind=8), parameter mom_coms::prec =2_8**46

private

Definition at line 44 of file MOM_coms.F90.

Referenced by carry_overflow(), increment_ints(), real_to_ints(), and regularize_ints().

integer(kind=8), parameter :: prec=2_8**46 ! The precision of each integer.

r_prec

real, parameter mom_coms::r_prec =2.0**46

private

Definition at line 45 of file MOM_coms.F90.

real, parameter :: r_prec=2.0**46  ! A real version of prec.