mom_domains::pass_var Interface Reference

Detailed Description

Do a halo update on an array.

Definition at line 49 of file MOM_domains.F90.

Private functions
subroutine	pass_var_3d (array, MOM_dom, sideflag, complete, position, halo, clock)
	pass_var_3d does a halo update for a three-dimensional array. More...
subroutine	pass_var_2d (array, MOM_dom, sideflag, complete, position, halo, inner_halo, clock)
	pass_var_2d does a halo update for a two-dimensional array. More...

Functions and subroutines

pass_var_2d()

subroutine mom_domains::pass_var::pass_var_2d ( real, dimension(:,:), intent(inout)  array, type(mom_domain_type), intent(inout)  MOM_dom, integer, intent(in), optional  sideflag, logical, intent(in), optional  complete, integer, intent(in), optional  position, integer, intent(in), optional  halo, integer, intent(in), optional  inner_halo, integer, intent(in), optional  clock  )

private

pass_var_2d does a halo update for a two-dimensional array.

Parameters

[in,out]	array	The array which is having its halos points exchanged.
[in,out]	mom_dom	The MOM_domain_type containing the mpp_domain needed to determine where data should be sent.
[in]	sideflag	An optional integer indicating which directions the data should be sent. It is TO_ALL or the sum of any of TO_EAST, TO_WEST, TO_NORTH, and TO_SOUTH. For example, TO_EAST sends the data to the processor to the east, so the halos on the western side are filled. TO_ALL is the default if sideflag is omitted.
[in]	complete	An optional argument indicating whether the halo updates should be completed before progress resumes. Omitting complete is the same as setting complete to .true.
[in]	position	An optional argument indicating the position. This is usally CORNER, but is CENTER by default.
[in]	halo	The size of the halo to update - the full halo by default.
[in]	inner_halo	The size of an inner halo to avoid updating, or 0 to avoid updating symmetric memory computational domain points. Setting this >=0 also enforces that complete=.true.
[in]	clock	The handle for a cpu time clock that should be started then stopped to time this routine.

Definition at line 185 of file MOM_domains.F90.

  real, dimension(:,:),  intent(inout) :: array    !< The array which is having its halos points
                                                   !! exchanged.
  type(MOM_domain_type), intent(inout) :: MOM_dom  !< The MOM_domain_type containing the mpp_domain
                                                   !! needed to determine where data should be sent.
  integer,     optional, intent(in)    :: sideflag !< An optional integer indicating which
      !! directions the data should be sent. It is TO_ALL or the sum of any of TO_EAST, TO_WEST,
      !! TO_NORTH, and TO_SOUTH.  For example, TO_EAST sends the data to the processor to the east,
      !! so the halos on the western side are filled.  TO_ALL is the default if sideflag is omitted.
  logical,     optional, intent(in)    :: complete !< An optional argument indicating whether the
                                                   !! halo updates should be completed before
                                                   !! progress resumes.  Omitting complete is the
                                                   !! same as setting complete to .true.
  integer,     optional, intent(in)    :: position !< An optional argument indicating the position.
                                                   !!  This is usally CORNER, but is CENTER
                                                   !! by default.
  integer,     optional, intent(in)    :: halo     !< The size of the halo to update - the full halo
                                                   !! by default.
  integer,     optional, intent(in)    :: inner_halo !< The size of an inner halo to avoid updating,
                                                   !! or 0 to avoid updating symmetric memory
                                                   !! computational domain points.  Setting this >=0
                                                   !! also enforces that complete=.true.
  integer,     optional, intent(in)    :: clock    !< The handle for a cpu time clock that should be
                                                   !! started then stopped to time this routine.
 
  ! Local variables
  real, allocatable, dimension(:,:) :: tmp
  integer :: pos, i_halo, j_halo
  integer :: isc, iec, jsc, jec, isd, ied, jsd, jed, IscB, IecB, JscB, JecB
  integer :: inner, i, j, isfw, iefw, isfe, iefe, jsfs, jefs, jsfn, jefn
  integer :: dirflag
  logical :: block_til_complete
 
  if (present(clock)) then ; if (clock>0) call cpu_clock_begin(clock) ; endif
 
  dirflag = to_all ! 60
  if (present(sideflag)) then ; if (sideflag > 0) dirflag = sideflag ; endif
  block_til_complete = .true. ; if (present(complete)) block_til_complete = complete
  pos = center ; if (present(position)) pos = position
 
  if (present(inner_halo)) then ; if (inner_halo >= 0) then
    ! Store the original values.
    allocate(tmp(size(array,1), size(array,2)))
    tmp(:,:) = array(:,:)
    block_til_complete = .true.
  endif ; endif
 
  if (present(halo) .and. mom_dom%thin_halo_updates) then
    call mpp_update_domains(array, mom_dom%mpp_domain, flags=dirflag, &
                        complete=block_til_complete, position=position, &
                        whalo=halo, ehalo=halo, shalo=halo, nhalo=halo)
  else
    call mpp_update_domains(array, mom_dom%mpp_domain, flags=dirflag, &
                        complete=block_til_complete, position=position)
  endif
 
  if (present(inner_halo)) then ; if (inner_halo >= 0) then
    call mpp_get_compute_domain(mom_dom%mpp_domain, isc, iec, jsc, jec)
    call mpp_get_data_domain(mom_dom%mpp_domain, isd, ied, jsd, jed)
    ! Convert to local indices for arrays starting at 1.
    isc = isc - (isd-1) ; iec = iec - (isd-1) ; ied = ied - (isd-1) ; isd = 1
    jsc = jsc - (jsd-1) ; jec = jec - (jsd-1) ; jed = jed - (jsd-1) ; jsd = 1
    i_halo = min(inner_halo, isc-1) ; j_halo = min(inner_halo, jsc-1)
 
    ! Figure out the array index extents of the eastern, western, northern and southern regions to copy.
    if (pos == center) then
      if (size(array,1) == ied) then
        isfw = isc - i_halo ; iefw = isc ; isfe = iec ; iefe = iec + i_halo
      else ; call mom_error(fatal, "pass_var_2d: wrong i-size for CENTER array.") ; endif
      if (size(array,2) == jed) then
        isfw = isc - i_halo ; iefw = isc ; isfe = iec ; iefe = iec + i_halo
      else ; call mom_error(fatal, "pass_var_2d: wrong j-size for CENTER array.") ; endif
    elseif (pos == corner) then
      if (size(array,1) == ied) then
        isfw = max(isc - (i_halo+1), 1) ; iefw = isc ; isfe = iec ; iefe = iec + i_halo
      elseif (size(array,1) == ied+1) then
        isfw = isc - i_halo ; iefw = isc+1 ; isfe = iec+1 ; iefe = min(iec + 1 + i_halo, ied+1)
      else ; call mom_error(fatal, "pass_var_2d: wrong i-size for CORNER array.") ; endif
      if (size(array,2) == jed) then
        jsfs = max(jsc - (j_halo+1), 1) ; jefs = jsc ; jsfn = jec ; jefn = jec + j_halo
      elseif (size(array,2) == jed+1) then
        jsfs = jsc - j_halo ; jefs = jsc+1 ; jsfn = jec+1 ; jefn = min(jec + 1 + j_halo, jed+1)
      else ; call mom_error(fatal, "pass_var_2d: wrong j-size for CORNER array.") ; endif
    else
      call mom_error(fatal, "pass_var_2d: Unrecognized position")
    endif
 
    ! Copy back the stored inner halo points
    do j=jsfs,jefn ; do i=isfw,iefw ; array(i,j) = tmp(i,j) ; enddo ; enddo
    do j=jsfs,jefn ; do i=isfe,iefe ; array(i,j) = tmp(i,j) ; enddo ; enddo
    do j=jsfs,jefs ; do i=isfw,iefe ; array(i,j) = tmp(i,j) ; enddo ; enddo
    do j=jsfn,jefn ; do i=isfw,iefe ; array(i,j) = tmp(i,j) ; enddo ; enddo
 
    deallocate(tmp)
  endif ; endif
 
  if (present(clock)) then ; if (clock>0) call cpu_clock_end(clock) ; endif
 

pass_var_3d()

subroutine mom_domains::pass_var::pass_var_3d ( real, dimension(:,:,:), intent(inout)  array, type(mom_domain_type), intent(inout)  MOM_dom, integer, intent(in), optional  sideflag, logical, intent(in), optional  complete, integer, intent(in), optional  position, integer, intent(in), optional  halo, integer, intent(in), optional  clock  )

private

pass_var_3d does a halo update for a three-dimensional array.

Parameters

[in,out]	array	The array which is having its halos points exchanged.
[in,out]	mom_dom	The MOM_domain_type containing the mpp_domain needed to determine where data should be sent.
[in]	sideflag	An optional integer indicating which directions the data should be sent. It is TO_ALL or the sum of any of TO_EAST, TO_WEST, TO_NORTH, and TO_SOUTH. For example, TO_EAST sends the data to the processor to the east, sothe halos on the western side are filled. TO_ALL is the default if sideflag is omitted.
[in]	complete	An optional argument indicating whether the halo updates should be completed before progress resumes. Omitting complete is the same as setting complete to .true.
[in]	position	An optional argument indicating the position. This is usally CORNER, but is CENTER by default.
[in]	halo	The size of the halo to update - the full halo by default.
[in]	clock	The handle for a cpu time clock that should be started then stopped to time this routine.

Definition at line 139 of file MOM_domains.F90.

  real, dimension(:,:,:), intent(inout) :: array    !< The array which is having its halos points
                                                    !! exchanged.
  type(MOM_domain_type),  intent(inout) :: MOM_dom  !< The MOM_domain_type containing the mpp_domain
                                                    !! needed to determine where data should be
                                                    !! sent.
  integer,      optional, intent(in)    :: sideflag !< An optional integer indicating which
      !! directions the data should be sent.  It is TO_ALL or the sum of any of TO_EAST, TO_WEST,
      !! TO_NORTH, and TO_SOUTH.  For example, TO_EAST sends the data to the processor to the east,
      !! sothe halos on the western side are filled.  TO_ALL is the default if sideflag is omitted.
  logical,      optional, intent(in)    :: complete !< An optional argument indicating whether the
                                                    !! halo updates should be completed before
                                                    !! progress resumes. Omitting complete is the
                                                    !! same as setting complete to .true.
  integer,      optional, intent(in)    :: position !< An optional argument indicating the position.
                                                    !! This is usally CORNER, but is CENTER by
                                                    !! default.
  integer,      optional, intent(in)    :: halo     !< The size of the halo to update - the full
                                                    !! halo by default.
  integer,      optional, intent(in)    :: clock    !< The handle for a cpu time clock that should be
                                                    !! started then stopped to time this routine.
 
  integer :: dirflag
  logical :: block_til_complete
 
  if (present(clock)) then ; if (clock>0) call cpu_clock_begin(clock) ; endif
 
  dirflag = to_all ! 60
  if (present(sideflag)) then ; if (sideflag > 0) dirflag = sideflag ; endif
  block_til_complete = .true.
  if (present(complete)) block_til_complete = complete
 
  if (present(halo) .and. mom_dom%thin_halo_updates) then
    call mpp_update_domains(array, mom_dom%mpp_domain, flags=dirflag, &
                        complete=block_til_complete, position=position, &
                        whalo=halo, ehalo=halo, shalo=halo, nhalo=halo)
  else
    call mpp_update_domains(array, mom_dom%mpp_domain, flags=dirflag, &
                          complete=block_til_complete, position=position)
  endif
 
  if (present(clock)) then ; if (clock>0) call cpu_clock_end(clock) ; endif
 

---

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

• /glade/work/altuntas/cesm.sandboxes/cesm2_2_alpha_X_mom/components/mom/MOM6/src/framework/MOM_domains.F90