mom_debugging::check_redundant_b Interface Reference

Detailed Description

Check for consistency between the duplicated points of a B-grid vector or scalar.

Definition at line 41 of file MOM_debugging.F90.

Private functions
subroutine	check_redundant_vb3d (mesg, u_comp, v_comp, G, is, ie, js, je, direction)
	Check for consistency between the duplicated points of a 3-D B-grid vector. More...
subroutine	check_redundant_vb2d (mesg, u_comp, v_comp, G, is, ie, js, je, direction)
	Check for consistency between the duplicated points of a 2-D B-grid vector. More...
subroutine	check_redundant_sb3d (mesg, array, G, is, ie, js, je)
	Check for consistency between the duplicated points of a 3-D scalar at corner points. More...
subroutine	check_redundant_sb2d (mesg, array, G, is, ie, js, je)
	Check for consistency between the duplicated points of a 2-D scalar at corner points. More...

Functions and subroutines

check_redundant_sb2d()

subroutine mom_debugging::check_redundant_b::check_redundant_sb2d ( character(len=*), intent(in)  mesg, real, dimension(g%isdb:,g%jsdb:), intent(in)  array, type(ocean_grid_type), intent(inout)  G, integer, intent(in), optional  is, integer, intent(in), optional  ie, integer, intent(in), optional  js, integer, intent(in), optional  je  )

private

Check for consistency between the duplicated points of a 2-D scalar at corner points.

Parameters

[in]	mesg	An identifying message
[in,out]	g	The ocean's grid structure
[in]	array	The array to be checked for consistency
[in]	is	The starting i-index to check
[in]	ie	The ending i-index to check
[in]	js	The starting j-index to check
[in]	je	The ending j-index to check

Definition at line 236 of file MOM_debugging.F90.

  character(len=*),                 intent(in)    :: mesg  !< An identifying message
  type(ocean_grid_type),            intent(inout) :: G     !< The ocean's grid structure
  real, dimension(G%IsdB:,G%JsdB:), intent(in)    :: array !< The array to be checked for consistency
  integer,                optional, intent(in)    :: is    !< The starting i-index to check
  integer,                optional, intent(in)    :: ie    !< The ending i-index to check
  integer,                optional, intent(in)    :: js    !< The starting j-index to check
  integer,                optional, intent(in)    :: je    !< The ending j-index to check
  ! Local variables
  real :: a_nonsym(G%isd:G%ied,G%jsd:G%jed)
  real :: a_resym(G%IsdB:G%IedB,G%JsdB:G%JedB)
  character(len=128) :: mesg2
  integer :: i, j, is_ch, ie_ch, js_ch, je_ch
  integer :: Isq, Ieq, Jsq, Jeq, isd, ied, jsd, jed, IsdB, IedB, JsdB, JedB
 
  isq = g%IscB ; ieq = g%IecB ; jsq = g%JscB ; jeq = g%JecB
  isd = g%isd ; ied = g%ied ; jsd = g%jsd ; jed = g%jed
  isdb = g%IsdB ; iedb = g%IedB ; jsdb = g%JsdB ; jedb = g%JedB
 
  if (.not.(present(is) .or. present(ie) .or. present(js) .or. present(je))) then
    ! This only works with symmetric memory, so otherwise return.
    if ((isd == isdb) .and. (jsd == jsdb)) return
  endif
 
  do i=isd,ied ; do j=jsd,jed
    a_nonsym(i,j) = array(i,j)
  enddo ; enddo
 
  if (.not.associated(g%Domain_aux)) call mom_error(fatal," check_redundant"//&
    " called with a non-associated auxiliary domain the grid type.")
  call pass_vector(a_nonsym, a_nonsym, g%Domain_aux, &
                   direction=to_all+scalar_pair, stagger=bgrid_ne)
 
  do i=isdb,iedb ; do j=jsdb,jedb ; a_resym(i,j) = array(i,j) ; enddo ; enddo
  do i=isd,ied ; do j=jsd,jed
    a_resym(i,j) = a_nonsym(i,j)
  enddo ; enddo
  call pass_vector(a_resym, a_resym, g%Domain, direction=to_all+scalar_pair, &
                   stagger=bgrid_ne)
 
  is_ch = isq ; ie_ch = ieq ; js_ch = jsq ; je_ch = jeq
  if (present(is)) is_ch = is ; if (present(ie)) ie_ch = ie
  if (present(js)) js_ch = js ; if (present(js)) je_ch = je
 
  do i=is_ch,ie_ch ; do j=js_ch,je_ch
    if (a_resym(i,j) /= array(i,j) .and. &
        redundant_prints(2) < max_redundant_prints) then
      write(mesg2,'(" Redundant points",2(1pe12.4)," differ by ", &
                    & 1pe12.4," at i,j = ",2i4," on pe ",i4)') &
           array(i,j), a_resym(i,j),array(i,j)-a_resym(i,j),i,j,pe_here()
      write(0,'(A130)') trim(mesg)//trim(mesg2)
      redundant_prints(2) = redundant_prints(2) + 1
    endif
  enddo ; enddo
 

check_redundant_sb3d()

subroutine mom_debugging::check_redundant_b::check_redundant_sb3d ( character(len=*), intent(in)  mesg, real, dimension(g%isdb:,g%jsdb:,:), intent(in)  array, type(ocean_grid_type), intent(inout)  G, integer, intent(in), optional  is, integer, intent(in), optional  ie, integer, intent(in), optional  js, integer, intent(in), optional  je  )

private

Check for consistency between the duplicated points of a 3-D scalar at corner points.

Parameters

[in]	mesg	An identifying message
[in,out]	g	The ocean's grid structure
[in]	array	The array to be checked for consistency
[in]	is	The starting i-index to check
[in]	ie	The ending i-index to check
[in]	js	The starting j-index to check
[in]	je	The ending j-index to check

Definition at line 211 of file MOM_debugging.F90.

  character(len=*),                     intent(in)    :: mesg  !< An identifying message
  type(ocean_grid_type),                intent(inout) :: G     !< The ocean's grid structure
  real, dimension(G%IsdB:,G%JsdB:,:),   intent(in)    :: array !< The array to be checked for consistency
  integer,                    optional, intent(in)    :: is    !< The starting i-index to check
  integer,                    optional, intent(in)    :: ie    !< The ending i-index to check
  integer,                    optional, intent(in)    :: js    !< The starting j-index to check
  integer,                    optional, intent(in)    :: je    !< The ending j-index to check
 
  ! Local variables
  character(len=24) :: mesg_k
  integer :: k
 
  do k=1,size(array,3)
    if (k < 10) then ; write(mesg_k,'(" Layer",i2," ")') k
    elseif (k < 100) then ; write(mesg_k,'(" Layer",i3," ")') k
    elseif (k < 1000) then ; write(mesg_k,'(" Layer",i4," ")') k
    else ; write(mesg_k,'(" Layer",i9," ")') k ; endif
 
    call check_redundant_sb2d(trim(mesg)//trim(mesg_k), array(:,:,k), &
                              g, is, ie, js, je)
  enddo

check_redundant_vb2d()

subroutine mom_debugging::check_redundant_b::check_redundant_vb2d ( character(len=*), intent(in)  mesg, real, dimension(g%isdb:,g%jsdb:), intent(in)  u_comp, real, dimension(g%isdb:,g%jsdb:), intent(in)  v_comp, type(ocean_grid_type), intent(inout)  G, integer, intent(in), optional  is, integer, intent(in), optional  ie, integer, intent(in), optional  js, integer, intent(in), optional  je, integer, intent(in), optional  direction  )

private

Check for consistency between the duplicated points of a 2-D B-grid vector.

Parameters

[in]	mesg	An identifying message
[in,out]	g	The ocean's grid structure
[in]	u_comp	The u-component of the vector to be checked for consistency
[in]	v_comp	The v-component of the vector to be checked for consistency
[in]	is	The starting i-index to check
[in]	ie	The ending i-index to check
[in]	js	The starting j-index to check
[in]	je	The ending j-index to check
[in]	direction	the direction flag to be passed to pass_vector

Definition at line 325 of file MOM_debugging.F90.

  character(len=*),                 intent(in)    :: mesg   !< An identifying message
  type(ocean_grid_type),            intent(inout) :: G      !< The ocean's grid structure
  real, dimension(G%IsdB:,G%JsdB:), intent(in)    :: u_comp !< The u-component of the vector
                                                            !! to be checked for consistency
  real, dimension(G%IsdB:,G%JsdB:), intent(in)    :: v_comp !< The v-component of the vector
                                                            !! to be checked for consistency
  integer,                optional, intent(in)    :: is     !< The starting i-index to check
  integer,                optional, intent(in)    :: ie     !< The ending i-index to check
  integer,                optional, intent(in)    :: js     !< The starting j-index to check
  integer,                optional, intent(in)    :: je     !< The ending j-index to check
  integer,                optional, intent(in)    :: direction !< the direction flag to be
                                                            !! passed to pass_vector
  ! Local variables
  real :: u_nonsym(G%isd:G%ied,G%jsd:G%jed)
  real :: v_nonsym(G%isd:G%ied,G%jsd:G%jed)
  real :: u_resym(G%IsdB:G%IedB,G%JsdB:G%JedB)
  real :: v_resym(G%IsdB:G%IedB,G%JsdB:G%JedB)
  character(len=128) :: mesg2
  integer :: i, j, is_ch, ie_ch, js_ch, je_ch
  integer :: Isq, Ieq, Jsq, Jeq, isd, ied, jsd, jed, IsdB, IedB, JsdB, JedB
 
  isq = g%IscB ; ieq = g%IecB ; jsq = g%JscB ; jeq = g%JecB
  isd = g%isd ; ied = g%ied ; jsd = g%jsd ; jed = g%jed
  isdb = g%IsdB ; iedb = g%IedB ; jsdb = g%JsdB ; jedb = g%JedB
 
  if (.not.(present(is) .or. present(ie) .or. present(js) .or. present(je))) then
    ! This only works with symmetric memory, so otherwise return.
    if ((isd == isdb) .and. (jsd == jsdb)) return
  endif
 
  do i=isd,ied ; do j=jsd,jed
    u_nonsym(i,j) = u_comp(i,j) ; v_nonsym(i,j) = v_comp(i,j)
  enddo ; enddo
 
  if (.not.associated(g%Domain_aux)) call mom_error(fatal," check_redundant"//&
    " called with a non-associated auxiliary domain the grid type.")
  call pass_vector(u_nonsym, v_nonsym, g%Domain_aux, direction, stagger=bgrid_ne)
 
  do i=isdb,iedb ; do j=jsdb,jedb
    u_resym(i,j) = u_comp(i,j) ; v_resym(i,j) = v_comp(i,j)
  enddo ; enddo
  do i=isd,ied ; do j=jsd,jed
    u_resym(i,j) = u_nonsym(i,j) ; v_resym(i,j) = v_nonsym(i,j)
  enddo ; enddo
  call pass_vector(u_resym, v_resym, g%Domain, direction, stagger=bgrid_ne)
 
  is_ch = isq ; ie_ch = ieq ; js_ch = jsq ; je_ch = jeq
  if (present(is)) is_ch = is ; if (present(ie)) ie_ch = ie
  if (present(js)) js_ch = js ; if (present(js)) je_ch = je
 
  do i=is_ch,ie_ch ; do j=js_ch,je_ch
    if (u_resym(i,j) /= u_comp(i,j) .and. &
        redundant_prints(2) < max_redundant_prints) then
      write(mesg2,'(" redundant u-components",2(1pe12.4)," differ by ", &
                    & 1pe12.4," at i,j = ",2i4," on pe ",i4)') &
           u_comp(i,j), u_resym(i,j),u_comp(i,j)-u_resym(i,j),i,j,pe_here()
      write(0,'(A130)') trim(mesg)//trim(mesg2)
      redundant_prints(2) = redundant_prints(2) + 1
    endif
  enddo ; enddo
  do i=is_ch,ie_ch ; do j=js_ch,je_ch
    if (v_resym(i,j) /= v_comp(i,j) .and. &
        redundant_prints(2) < max_redundant_prints) then
      write(mesg2,'(" redundant v-comps",2(1pe12.4)," differ by ", &
                    & 1pe12.4," at i,j = ",2i4," x,y = ",2(1pe12.4)" on pe ",i4)') &
           v_comp(i,j), v_resym(i,j),v_comp(i,j)-v_resym(i,j),i,j, &
           g%geoLonBu(i,j), g%geoLatBu(i,j), pe_here()
      write(0,'(A155)') trim(mesg)//trim(mesg2)
      redundant_prints(2) = redundant_prints(2) + 1
    endif
  enddo ; enddo
 

check_redundant_vb3d()

subroutine mom_debugging::check_redundant_b::check_redundant_vb3d ( character(len=*), intent(in)  mesg, real, dimension(g%isdb:,g%jsdb:,:), intent(in)  u_comp, real, dimension(g%isdb:,g%jsdb:,:), intent(in)  v_comp, type(ocean_grid_type), intent(inout)  G, integer, intent(in), optional  is, integer, intent(in), optional  ie, integer, intent(in), optional  js, integer, intent(in), optional  je, integer, intent(in), optional  direction  )

private

Check for consistency between the duplicated points of a 3-D B-grid vector.

Parameters

[in]	mesg	An identifying message
[in,out]	g	The ocean's grid structure
[in]	u_comp	The u-component of the vector to be checked for consistency
[in]	v_comp	The v-component of the vector to be checked for consistency
[in]	is	The starting i-index to check
[in]	ie	The ending i-index to check
[in]	js	The starting j-index to check
[in]	je	The ending j-index to check
[in]	direction	the direction flag to be passed to pass_vector

Definition at line 295 of file MOM_debugging.F90.

  character(len=*),                    intent(in)    :: mesg   !< An identifying message
  type(ocean_grid_type),               intent(inout) :: G      !< The ocean's grid structure
  real, dimension(G%IsdB:,G%JsdB:,:),  intent(in)    :: u_comp !< The u-component of the vector
                                                           !! to be checked for consistency
  real, dimension(G%IsdB:,G%JsdB:,:),  intent(in)    :: v_comp !< The v-component of the vector
                                                           !! to be checked for consistency
  integer,                   optional, intent(in)    :: is     !< The starting i-index to check
  integer,                   optional, intent(in)    :: ie     !< The ending i-index to check
  integer,                   optional, intent(in)    :: js     !< The starting j-index to check
  integer,                   optional, intent(in)    :: je     !< The ending j-index to check
  integer,                   optional, intent(in)    :: direction !< the direction flag to be
                                                               !! passed to pass_vector
  ! Local variables
  character(len=24) :: mesg_k
  integer :: k
 
  do k=1,size(u_comp,3)
    if (k < 10) then ; write(mesg_k,'(" Layer",i2," ")') k
    elseif (k < 100) then ; write(mesg_k,'(" Layer",i3," ")') k
    elseif (k < 1000) then ; write(mesg_k,'(" Layer",i4," ")') k
    else ; write(mesg_k,'(" Layer",i9," ")') k ; endif
 
    call check_redundant_vb2d(trim(mesg)//trim(mesg_k), u_comp(:,:,k), &
             v_comp(:,:,k), g, is, ie, js, je, direction)
  enddo

---

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/diagnostics/MOM_debugging.F90