mom_coms::reproducing_sum_efp Interface Reference

Detailed Description

Find an accurate and order-invariant sum of a distributed 2d field, returning the result in the form of an extended fixed point value that can be converted back with EFP_to_real.

Definition at line 59 of file MOM_coms.F90.

Private functions
type(efp_type) function	reproducing_efp_sum_2d (array, isr, ier, jsr, jer, overflow_check, err, only_on_PE)
	This subroutine uses a conversion to an integer representation of real numbers to give an order-invariant sum of distributed 2-D arrays that reproduces across domain decomposition, with the result returned as an extended fixed point type that can be converted back to a real number using EFP_to_real. This technique is described in Hallberg & Adcroft, 2014, Parallel Computing, doi:10.1016/j.parco.2014.04.007. More...

Detailed Description

Find an accurate and order-invariant sum of a distributed 2d field, returning the result in the form of an extended fixed point value that can be converted back with EFP_to_real.

Definition at line 59 of file MOM_coms.F90.

Functions and subroutines

reproducing_efp_sum_2d()

type(efp_type) function mom_coms::reproducing_sum_efp::reproducing_efp_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, logical, intent(in), optional  overflow_check, integer, intent(out), optional  err, logical, intent(in), optional  only_on_PE  )

private

This subroutine uses a conversion to an integer representation of real numbers to give an order-invariant sum of distributed 2-D arrays that reproduces across domain decomposition, with the result returned as an extended fixed point type that can be converted back to a real number using EFP_to_real. This technique is described in Hallberg & Adcroft, 2014, Parallel Computing, doi:10.1016/j.parco.2014.04.007.

Parameters

[in]	array	The array to be summed
[in]	isr	The starting i-index of the sum, noting that the array indices starts at 1
[in]	ier	The ending i-index of the sum, noting that the array indices starts at 1
[in]	jsr	The starting j-index of the sum, noting that the array indices starts at 1
[in]	jer	The ending j-index of the sum, noting that the array indices starts at 1
[in]	overflow_check	If present and false, disable checking for overflows in incremental results. This can speed up calculations if the number of values being summed is small enough
[out]	err	If present, return an error code instead of triggering any fatal errors directly from this routine.
[in]	only_on_pe	If present and true, do not do the sum across processors, only reporting the local sum

Returns

The result in extended fixed point format

Definition at line 93 of file MOM_coms.F90.

  real, dimension(:,:),     intent(in)  :: array   !< The array to be summed
  integer,        optional, intent(in)  :: isr     !< The starting i-index of the sum, noting
                                                   !! that the array indices starts at 1
  integer,        optional, intent(in)  :: ier     !< The ending i-index of the sum, noting
                                                   !! that the array indices starts at 1
  integer,        optional, intent(in)  :: jsr     !< The starting j-index of the sum, noting
                                                   !! that the array indices starts at 1
  integer,        optional, intent(in)  :: jer     !< The ending j-index of the sum, noting
                                                   !! that the array indices starts at 1
  logical,        optional, intent(in)  :: overflow_check !< If present and false, disable
                                                !! checking for overflows in incremental results.
                                                !! This can speed up calculations if the number
                                                !! of values being summed is small enough
  integer,        optional, intent(out) :: err  !< If present, return an error code instead of
                                                !! triggering any fatal errors directly from
                                                !! this routine.
  logical,        optional, intent(in)  :: only_on_PE !< If present and true, do not do the sum
                                                !! across processors, only reporting the local sum
  type(EFP_type)                        :: EFP_sum  !< The result in extended fixed point format

  !   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    :: rs
  real    :: max_mag_term
  logical :: over_check, do_sum_across_PEs
  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_EFP_sum_2d.")
    is = isr
  endif
  if (present(ier)) then
    if (ier > ie) call mom_error(fatal, "Value of ier too large in reproducing_EFP_sum_2d.")
    ie = ier
  endif
  if (present(jsr)) then
    if (jsr < js) call mom_error(fatal, "Value of jsr too small in reproducing_EFP_sum_2d.")
    js = jsr
  endif
  if (present(jer)) then
    if (jer > je) call mom_error(fatal, "Value of jer too large in reproducing_EFP_sum_2d.")
    je = jer
  endif

  over_check = .true. ; if (present(overflow_check)) over_check = overflow_check
  do_sum_across_pes = .true. ; if (present(only_on_pe)) do_sum_across_pes = .not.only_on_pe

  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_EFP_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_EFP_sum(_2d) conversion of "//trim(mesg))
    endif
    if (overflow_error) then
      call mom_error(fatal, "Overflow in reproducing_EFP_sum(_2d).")
    endif
  endif

  if (do_sum_across_pes) call sum_across_pes(ints_sum, ni)

  call regularize_ints(ints_sum)

  efp_sum%v(:) = ints_sum(:)

---

The documentation for this interface was generated from the following file:

• /home/cermak/src/MOM6.devrob/src/framework/MOM_coms.F90