diff --git a/CDEPS-interface/ufs/shr_assert_mod.F90 b/CDEPS-interface/ufs/shr_assert_mod.F90
new file mode 100644
index 0000000000..487ea6470f
--- /dev/null
+++ b/CDEPS-interface/ufs/shr_assert_mod.F90
@@ -0,0 +1,8603 @@
+#include "dtypes.h"
+!===================================================
+! DO NOT EDIT THIS FILE, it was generated using genf90.pl
+! Any changes you make to this file may be lost
+!===================================================
+module shr_assert_mod
+
+! Assert subroutines for common debugging operations.
+
+use shr_kind_mod, only: &
+     r4 => shr_kind_r4, &
+     r8 => shr_kind_r8, &
+     i4 => shr_kind_i4, &
+     i8 => shr_kind_i8
+
+use shr_sys_mod, only: &
+     shr_sys_abort
+
+use shr_log_mod, only: &
+     shr_log_Unit
+
+use shr_infnan_mod, only: shr_infnan_isnan
+
+use shr_strconvert_mod, only: toString
+
+implicit none
+private
+save
+
+! Assert that a logical is true.
+public :: shr_assert
+public :: shr_assert_all
+public :: shr_assert_any
+
+! Assert that a numerical value satisfies certain constraints.
+public :: shr_assert_in_domain
+
+# 33 "shr_assert_mod.F90.in"
+interface shr_assert_all
+   module procedure shr_assert
+   ! DIMS 1,2,3,4,5,6,7
+   module procedure shr_assert_all_1d
+   ! DIMS 1,2,3,4,5,6,7
+   module procedure shr_assert_all_2d
+   ! DIMS 1,2,3,4,5,6,7
+   module procedure shr_assert_all_3d
+   ! DIMS 1,2,3,4,5,6,7
+   module procedure shr_assert_all_4d
+   ! DIMS 1,2,3,4,5,6,7
+   module procedure shr_assert_all_5d
+   ! DIMS 1,2,3,4,5,6,7
+   module procedure shr_assert_all_6d
+   ! DIMS 1,2,3,4,5,6,7
+   module procedure shr_assert_all_7d
+end interface
+
+# 39 "shr_assert_mod.F90.in"
+interface shr_assert_any
+   module procedure shr_assert
+   ! DIMS 1,2,3,4,5,6,7
+   module procedure shr_assert_any_1d
+   ! DIMS 1,2,3,4,5,6,7
+   module procedure shr_assert_any_2d
+   ! DIMS 1,2,3,4,5,6,7
+   module procedure shr_assert_any_3d
+   ! DIMS 1,2,3,4,5,6,7
+   module procedure shr_assert_any_4d
+   ! DIMS 1,2,3,4,5,6,7
+   module procedure shr_assert_any_5d
+   ! DIMS 1,2,3,4,5,6,7
+   module procedure shr_assert_any_6d
+   ! DIMS 1,2,3,4,5,6,7
+   module procedure shr_assert_any_7d
+end interface
+
+# 45 "shr_assert_mod.F90.in"
+interface shr_assert_in_domain
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_0d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_1d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_2d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_3d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_4d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_5d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_6d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_7d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_0d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_1d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_2d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_3d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_4d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_5d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_6d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_7d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_0d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_1d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_2d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_3d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_4d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_5d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_6d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_7d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_0d_long
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_1d_long
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_2d_long
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_3d_long
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_4d_long
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_5d_long
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_6d_long
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure shr_assert_in_domain_7d_long
+end interface
+
+! Private utilities.
+
+# 53 "shr_assert_mod.F90.in"
+interface print_bad_loc
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_0d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_1d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_2d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_3d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_4d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_5d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_6d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_7d_double
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_0d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_1d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_2d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_3d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_4d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_5d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_6d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_7d_real
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_0d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_1d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_2d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_3d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_4d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_5d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_6d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_7d_int
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_0d_long
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_1d_long
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_2d_long
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_3d_long
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_4d_long
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_5d_long
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_6d_long
+   ! TYPE double,real,int,long
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure print_bad_loc_7d_long
+end interface
+
+# 59 "shr_assert_mod.F90.in"
+interface find_first_loc
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure find_first_loc_0d
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure find_first_loc_1d
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure find_first_loc_2d
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure find_first_loc_3d
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure find_first_loc_4d
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure find_first_loc_5d
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure find_first_loc_6d
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure find_first_loc_7d
+end interface
+
+# 64 "shr_assert_mod.F90.in"
+interface within_tolerance
+   ! TYPE double,real,int,long
+   module procedure within_tolerance_double
+   ! TYPE double,real,int,long
+   module procedure within_tolerance_real
+   ! TYPE double,real,int,long
+   module procedure within_tolerance_int
+   ! TYPE double,real,int,long
+   module procedure within_tolerance_long
+end interface
+
+# 69 "shr_assert_mod.F90.in"
+contains
+
+# 71 "shr_assert_mod.F90.in"
+subroutine shr_assert(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  character(len=:), allocatable :: full_msg
+  
+  full_msg = ''
+  if (.not. var) then
+     full_msg = 'ERROR'
+     if (present(file)) then
+        full_msg = full_msg // ' in ' // trim(file)
+        if (present(line)) then
+           full_msg = full_msg // ' at line ' // toString(line)
+        end if
+     end if
+     if (present(msg)) then
+        full_msg = full_msg // ': ' // msg
+     end if
+     call shr_sys_abort(full_msg)
+  end if
+
+# 99 "shr_assert_mod.F90.in"
+end subroutine shr_assert
+
+! DIMS 1,2,3,4,5,6,7
+# 102 "shr_assert_mod.F90.in"
+subroutine shr_assert_all_1d(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var(:)
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  call shr_assert(all(var), msg=msg, file=file, line=line)
+
+# 115 "shr_assert_mod.F90.in"
+end subroutine shr_assert_all_1d
+! DIMS 1,2,3,4,5,6,7
+# 102 "shr_assert_mod.F90.in"
+subroutine shr_assert_all_2d(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var(:,:)
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  call shr_assert(all(var), msg=msg, file=file, line=line)
+
+# 115 "shr_assert_mod.F90.in"
+end subroutine shr_assert_all_2d
+! DIMS 1,2,3,4,5,6,7
+# 102 "shr_assert_mod.F90.in"
+subroutine shr_assert_all_3d(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var(:,:,:)
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  call shr_assert(all(var), msg=msg, file=file, line=line)
+
+# 115 "shr_assert_mod.F90.in"
+end subroutine shr_assert_all_3d
+! DIMS 1,2,3,4,5,6,7
+# 102 "shr_assert_mod.F90.in"
+subroutine shr_assert_all_4d(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var(:,:,:,:)
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  call shr_assert(all(var), msg=msg, file=file, line=line)
+
+# 115 "shr_assert_mod.F90.in"
+end subroutine shr_assert_all_4d
+! DIMS 1,2,3,4,5,6,7
+# 102 "shr_assert_mod.F90.in"
+subroutine shr_assert_all_5d(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var(:,:,:,:,:)
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  call shr_assert(all(var), msg=msg, file=file, line=line)
+
+# 115 "shr_assert_mod.F90.in"
+end subroutine shr_assert_all_5d
+! DIMS 1,2,3,4,5,6,7
+# 102 "shr_assert_mod.F90.in"
+subroutine shr_assert_all_6d(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var(:,:,:,:,:,:)
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  call shr_assert(all(var), msg=msg, file=file, line=line)
+
+# 115 "shr_assert_mod.F90.in"
+end subroutine shr_assert_all_6d
+! DIMS 1,2,3,4,5,6,7
+# 102 "shr_assert_mod.F90.in"
+subroutine shr_assert_all_7d(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var(:,:,:,:,:,:,:)
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  call shr_assert(all(var), msg=msg, file=file, line=line)
+
+# 115 "shr_assert_mod.F90.in"
+end subroutine shr_assert_all_7d
+
+! DIMS 1,2,3,4,5,6,7
+# 118 "shr_assert_mod.F90.in"
+subroutine shr_assert_any_1d(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var(:)
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  call shr_assert(any(var), msg=msg, file=file, line=line)
+
+# 131 "shr_assert_mod.F90.in"
+end subroutine shr_assert_any_1d
+! DIMS 1,2,3,4,5,6,7
+# 118 "shr_assert_mod.F90.in"
+subroutine shr_assert_any_2d(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var(:,:)
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  call shr_assert(any(var), msg=msg, file=file, line=line)
+
+# 131 "shr_assert_mod.F90.in"
+end subroutine shr_assert_any_2d
+! DIMS 1,2,3,4,5,6,7
+# 118 "shr_assert_mod.F90.in"
+subroutine shr_assert_any_3d(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var(:,:,:)
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  call shr_assert(any(var), msg=msg, file=file, line=line)
+
+# 131 "shr_assert_mod.F90.in"
+end subroutine shr_assert_any_3d
+! DIMS 1,2,3,4,5,6,7
+# 118 "shr_assert_mod.F90.in"
+subroutine shr_assert_any_4d(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var(:,:,:,:)
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  call shr_assert(any(var), msg=msg, file=file, line=line)
+
+# 131 "shr_assert_mod.F90.in"
+end subroutine shr_assert_any_4d
+! DIMS 1,2,3,4,5,6,7
+# 118 "shr_assert_mod.F90.in"
+subroutine shr_assert_any_5d(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var(:,:,:,:,:)
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  call shr_assert(any(var), msg=msg, file=file, line=line)
+
+# 131 "shr_assert_mod.F90.in"
+end subroutine shr_assert_any_5d
+! DIMS 1,2,3,4,5,6,7
+# 118 "shr_assert_mod.F90.in"
+subroutine shr_assert_any_6d(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var(:,:,:,:,:,:)
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  call shr_assert(any(var), msg=msg, file=file, line=line)
+
+# 131 "shr_assert_mod.F90.in"
+end subroutine shr_assert_any_6d
+! DIMS 1,2,3,4,5,6,7
+# 118 "shr_assert_mod.F90.in"
+subroutine shr_assert_any_7d(var, msg, file, line)
+
+  ! Logical being asserted
+  logical, intent(in) :: var(:,:,:,:,:,:,:)
+  ! Optional error message if assert fails
+  character(len=*), intent(in), optional :: msg
+  ! Optional file and line of the caller, written out if given
+  ! (line is ignored if file is absent)
+  character(len=*), intent(in), optional :: file
+  integer         , intent(in), optional :: line
+
+  call shr_assert(any(var), msg=msg, file=file, line=line)
+
+# 131 "shr_assert_mod.F90.in"
+end subroutine shr_assert_any_7d
+
+!--------------------------------------------------------------------------
+!--------------------------------------------------------------------------
+
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_0d_double(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (102 == TYPEREAL) || (102 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (0 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r8), intent(in) :: var
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r8), intent(in), optional :: lt
+  real(r8), intent(in), optional :: gt
+  real(r8), intent(in), optional :: le
+  real(r8), intent(in), optional :: ge
+  real(r8), intent(in), optional :: eq
+  real(r8), intent(in), optional :: ne
+  real(r8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(0)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,0)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_0d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_1d_double(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (102 == TYPEREAL) || (102 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (1 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r8), intent(in) :: var(:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r8), intent(in), optional :: lt
+  real(r8), intent(in), optional :: gt
+  real(r8), intent(in), optional :: le
+  real(r8), intent(in), optional :: ge
+  real(r8), intent(in), optional :: eq
+  real(r8), intent(in), optional :: ne
+  real(r8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(1)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,1)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_1d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_2d_double(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (102 == TYPEREAL) || (102 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (2 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r8), intent(in) :: var(:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r8), intent(in), optional :: lt
+  real(r8), intent(in), optional :: gt
+  real(r8), intent(in), optional :: le
+  real(r8), intent(in), optional :: ge
+  real(r8), intent(in), optional :: eq
+  real(r8), intent(in), optional :: ne
+  real(r8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(2)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,2)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_2d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_3d_double(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (102 == TYPEREAL) || (102 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (3 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r8), intent(in) :: var(:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r8), intent(in), optional :: lt
+  real(r8), intent(in), optional :: gt
+  real(r8), intent(in), optional :: le
+  real(r8), intent(in), optional :: ge
+  real(r8), intent(in), optional :: eq
+  real(r8), intent(in), optional :: ne
+  real(r8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(3)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,3)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_3d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_4d_double(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (102 == TYPEREAL) || (102 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (4 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r8), intent(in) :: var(:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r8), intent(in), optional :: lt
+  real(r8), intent(in), optional :: gt
+  real(r8), intent(in), optional :: le
+  real(r8), intent(in), optional :: ge
+  real(r8), intent(in), optional :: eq
+  real(r8), intent(in), optional :: ne
+  real(r8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(4)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,4)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_4d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_5d_double(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (102 == TYPEREAL) || (102 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (5 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r8), intent(in) :: var(:,:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r8), intent(in), optional :: lt
+  real(r8), intent(in), optional :: gt
+  real(r8), intent(in), optional :: le
+  real(r8), intent(in), optional :: ge
+  real(r8), intent(in), optional :: eq
+  real(r8), intent(in), optional :: ne
+  real(r8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(5)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,5)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_5d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_6d_double(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (102 == TYPEREAL) || (102 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (6 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r8), intent(in) :: var(:,:,:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r8), intent(in), optional :: lt
+  real(r8), intent(in), optional :: gt
+  real(r8), intent(in), optional :: le
+  real(r8), intent(in), optional :: ge
+  real(r8), intent(in), optional :: eq
+  real(r8), intent(in), optional :: ne
+  real(r8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(6)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,6)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_6d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_7d_double(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (102 == TYPEREAL) || (102 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (7 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r8), intent(in) :: var(:,:,:,:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r8), intent(in), optional :: lt
+  real(r8), intent(in), optional :: gt
+  real(r8), intent(in), optional :: le
+  real(r8), intent(in), optional :: ge
+  real(r8), intent(in), optional :: eq
+  real(r8), intent(in), optional :: ne
+  real(r8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(7)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,7)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_7d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_0d_real(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (101 == TYPEREAL) || (101 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (0 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r4), intent(in) :: var
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r4), intent(in), optional :: lt
+  real(r4), intent(in), optional :: gt
+  real(r4), intent(in), optional :: le
+  real(r4), intent(in), optional :: ge
+  real(r4), intent(in), optional :: eq
+  real(r4), intent(in), optional :: ne
+  real(r4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(0)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,0)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_0d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_1d_real(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (101 == TYPEREAL) || (101 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (1 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r4), intent(in) :: var(:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r4), intent(in), optional :: lt
+  real(r4), intent(in), optional :: gt
+  real(r4), intent(in), optional :: le
+  real(r4), intent(in), optional :: ge
+  real(r4), intent(in), optional :: eq
+  real(r4), intent(in), optional :: ne
+  real(r4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(1)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,1)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_1d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_2d_real(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (101 == TYPEREAL) || (101 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (2 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r4), intent(in) :: var(:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r4), intent(in), optional :: lt
+  real(r4), intent(in), optional :: gt
+  real(r4), intent(in), optional :: le
+  real(r4), intent(in), optional :: ge
+  real(r4), intent(in), optional :: eq
+  real(r4), intent(in), optional :: ne
+  real(r4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(2)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,2)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_2d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_3d_real(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (101 == TYPEREAL) || (101 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (3 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r4), intent(in) :: var(:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r4), intent(in), optional :: lt
+  real(r4), intent(in), optional :: gt
+  real(r4), intent(in), optional :: le
+  real(r4), intent(in), optional :: ge
+  real(r4), intent(in), optional :: eq
+  real(r4), intent(in), optional :: ne
+  real(r4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(3)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,3)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_3d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_4d_real(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (101 == TYPEREAL) || (101 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (4 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r4), intent(in) :: var(:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r4), intent(in), optional :: lt
+  real(r4), intent(in), optional :: gt
+  real(r4), intent(in), optional :: le
+  real(r4), intent(in), optional :: ge
+  real(r4), intent(in), optional :: eq
+  real(r4), intent(in), optional :: ne
+  real(r4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(4)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,4)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_4d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_5d_real(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (101 == TYPEREAL) || (101 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (5 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r4), intent(in) :: var(:,:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r4), intent(in), optional :: lt
+  real(r4), intent(in), optional :: gt
+  real(r4), intent(in), optional :: le
+  real(r4), intent(in), optional :: ge
+  real(r4), intent(in), optional :: eq
+  real(r4), intent(in), optional :: ne
+  real(r4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(5)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,5)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_5d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_6d_real(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (101 == TYPEREAL) || (101 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (6 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r4), intent(in) :: var(:,:,:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r4), intent(in), optional :: lt
+  real(r4), intent(in), optional :: gt
+  real(r4), intent(in), optional :: le
+  real(r4), intent(in), optional :: ge
+  real(r4), intent(in), optional :: eq
+  real(r4), intent(in), optional :: ne
+  real(r4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(6)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,6)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_6d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_7d_real(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (101 == TYPEREAL) || (101 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (7 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  real(r4), intent(in) :: var(:,:,:,:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  real(r4), intent(in), optional :: lt
+  real(r4), intent(in), optional :: gt
+  real(r4), intent(in), optional :: le
+  real(r4), intent(in), optional :: ge
+  real(r4), intent(in), optional :: eq
+  real(r4), intent(in), optional :: ne
+  real(r4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(7)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  real(r4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,7)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_7d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_0d_int(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (103 == TYPEREAL) || (103 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (0 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i4), intent(in) :: var
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i4), intent(in), optional :: lt
+  integer(i4), intent(in), optional :: gt
+  integer(i4), intent(in), optional :: le
+  integer(i4), intent(in), optional :: ge
+  integer(i4), intent(in), optional :: eq
+  integer(i4), intent(in), optional :: ne
+  integer(i4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(0)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,0)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_0d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_1d_int(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (103 == TYPEREAL) || (103 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (1 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i4), intent(in) :: var(:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i4), intent(in), optional :: lt
+  integer(i4), intent(in), optional :: gt
+  integer(i4), intent(in), optional :: le
+  integer(i4), intent(in), optional :: ge
+  integer(i4), intent(in), optional :: eq
+  integer(i4), intent(in), optional :: ne
+  integer(i4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(1)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,1)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_1d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_2d_int(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (103 == TYPEREAL) || (103 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (2 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i4), intent(in) :: var(:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i4), intent(in), optional :: lt
+  integer(i4), intent(in), optional :: gt
+  integer(i4), intent(in), optional :: le
+  integer(i4), intent(in), optional :: ge
+  integer(i4), intent(in), optional :: eq
+  integer(i4), intent(in), optional :: ne
+  integer(i4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(2)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,2)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_2d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_3d_int(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (103 == TYPEREAL) || (103 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (3 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i4), intent(in) :: var(:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i4), intent(in), optional :: lt
+  integer(i4), intent(in), optional :: gt
+  integer(i4), intent(in), optional :: le
+  integer(i4), intent(in), optional :: ge
+  integer(i4), intent(in), optional :: eq
+  integer(i4), intent(in), optional :: ne
+  integer(i4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(3)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,3)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_3d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_4d_int(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (103 == TYPEREAL) || (103 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (4 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i4), intent(in) :: var(:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i4), intent(in), optional :: lt
+  integer(i4), intent(in), optional :: gt
+  integer(i4), intent(in), optional :: le
+  integer(i4), intent(in), optional :: ge
+  integer(i4), intent(in), optional :: eq
+  integer(i4), intent(in), optional :: ne
+  integer(i4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(4)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,4)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_4d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_5d_int(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (103 == TYPEREAL) || (103 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (5 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i4), intent(in) :: var(:,:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i4), intent(in), optional :: lt
+  integer(i4), intent(in), optional :: gt
+  integer(i4), intent(in), optional :: le
+  integer(i4), intent(in), optional :: ge
+  integer(i4), intent(in), optional :: eq
+  integer(i4), intent(in), optional :: ne
+  integer(i4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(5)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,5)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_5d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_6d_int(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (103 == TYPEREAL) || (103 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (6 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i4), intent(in) :: var(:,:,:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i4), intent(in), optional :: lt
+  integer(i4), intent(in), optional :: gt
+  integer(i4), intent(in), optional :: le
+  integer(i4), intent(in), optional :: ge
+  integer(i4), intent(in), optional :: eq
+  integer(i4), intent(in), optional :: ne
+  integer(i4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(6)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,6)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_6d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_7d_int(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (103 == TYPEREAL) || (103 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (7 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i4), intent(in) :: var(:,:,:,:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i4), intent(in), optional :: lt
+  integer(i4), intent(in), optional :: gt
+  integer(i4), intent(in), optional :: le
+  integer(i4), intent(in), optional :: ge
+  integer(i4), intent(in), optional :: eq
+  integer(i4), intent(in), optional :: ne
+  integer(i4), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(7)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i4) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,7)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_7d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_0d_long(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (104 == TYPEREAL) || (104 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (0 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i8), intent(in) :: var
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i8), intent(in), optional :: lt
+  integer(i8), intent(in), optional :: gt
+  integer(i8), intent(in), optional :: le
+  integer(i8), intent(in), optional :: ge
+  integer(i8), intent(in), optional :: eq
+  integer(i8), intent(in), optional :: ne
+  integer(i8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(0)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,0)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_0d_long
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_1d_long(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (104 == TYPEREAL) || (104 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (1 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i8), intent(in) :: var(:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i8), intent(in), optional :: lt
+  integer(i8), intent(in), optional :: gt
+  integer(i8), intent(in), optional :: le
+  integer(i8), intent(in), optional :: ge
+  integer(i8), intent(in), optional :: eq
+  integer(i8), intent(in), optional :: ne
+  integer(i8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(1)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,1)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_1d_long
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_2d_long(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (104 == TYPEREAL) || (104 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (2 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i8), intent(in) :: var(:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i8), intent(in), optional :: lt
+  integer(i8), intent(in), optional :: gt
+  integer(i8), intent(in), optional :: le
+  integer(i8), intent(in), optional :: ge
+  integer(i8), intent(in), optional :: eq
+  integer(i8), intent(in), optional :: ne
+  integer(i8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(2)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,2)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_2d_long
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_3d_long(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (104 == TYPEREAL) || (104 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (3 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i8), intent(in) :: var(:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i8), intent(in), optional :: lt
+  integer(i8), intent(in), optional :: gt
+  integer(i8), intent(in), optional :: le
+  integer(i8), intent(in), optional :: ge
+  integer(i8), intent(in), optional :: eq
+  integer(i8), intent(in), optional :: ne
+  integer(i8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(3)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,3)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_3d_long
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_4d_long(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (104 == TYPEREAL) || (104 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (4 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i8), intent(in) :: var(:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i8), intent(in), optional :: lt
+  integer(i8), intent(in), optional :: gt
+  integer(i8), intent(in), optional :: le
+  integer(i8), intent(in), optional :: ge
+  integer(i8), intent(in), optional :: eq
+  integer(i8), intent(in), optional :: ne
+  integer(i8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(4)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,4)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_4d_long
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_5d_long(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (104 == TYPEREAL) || (104 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (5 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i8), intent(in) :: var(:,:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i8), intent(in), optional :: lt
+  integer(i8), intent(in), optional :: gt
+  integer(i8), intent(in), optional :: le
+  integer(i8), intent(in), optional :: ge
+  integer(i8), intent(in), optional :: eq
+  integer(i8), intent(in), optional :: ne
+  integer(i8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(5)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,5)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_5d_long
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_6d_long(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (104 == TYPEREAL) || (104 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (6 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i8), intent(in) :: var(:,:,:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i8), intent(in), optional :: lt
+  integer(i8), intent(in), optional :: gt
+  integer(i8), intent(in), optional :: le
+  integer(i8), intent(in), optional :: ge
+  integer(i8), intent(in), optional :: eq
+  integer(i8), intent(in), optional :: ne
+  integer(i8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(6)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,6)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_6d_long
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 138 "shr_assert_mod.F90.in"
+subroutine shr_assert_in_domain_7d_long(var, varname, msg, &
+     is_nan, lt, gt, le, ge, eq, ne, abs_tol)
+
+!-----------------------------
+! BEGIN defining local macros
+!-----------------------------
+
+! Flag for floating point types.
+
+#if (104 == TYPEREAL) || (104 == TYPEDOUBLE)
+#define TYPEFP
+#else
+#undef TYPEFP
+#endif
+
+! "Generalized" macro functions allow transformational intrinsic functions
+! to handle both scalars and arrays.
+
+#if (7 != 0)
+! When given an array, use the intrinsics.
+#define GEN_SIZE(x) size(x)
+#define GEN_ALL(x) all(x)
+#else
+
+! Scalar extensions:
+!   GEN_SIZE always returns 1 for a scalar.
+!   GEN_ALL (logical reduction) is a no-op for a scalar.
+!   GEN_[MAX,MIN]LOC should return a 1D, size 0 (empty), integer array.
+#define GEN_SIZE(x) 1
+#define GEN_ALL(x) x
+
+#endif
+
+!-----------------------------
+! END macro section
+!-----------------------------
+
+  ! Variable being checked.
+  integer(i8), intent(in) :: var(:,:,:,:,:,:,:)
+  ! Variable name to be used in error messages.
+  character(len=*), intent(in), optional :: varname
+  ! Optional error message if assert fails.
+  character(len=*), intent(in), optional :: msg
+  ! Assert that the variable is not (or is) NaN.
+  logical, intent(in), optional :: is_nan
+  ! Limits for (in)equalities.
+  integer(i8), intent(in), optional :: lt
+  integer(i8), intent(in), optional :: gt
+  integer(i8), intent(in), optional :: le
+  integer(i8), intent(in), optional :: ge
+  integer(i8), intent(in), optional :: eq
+  integer(i8), intent(in), optional :: ne
+  integer(i8), intent(in), optional :: abs_tol
+
+  ! Note that the following array is size 0 for scalars.
+  integer :: loc_vec(7)
+
+  logical :: is_nan_passed
+  logical :: lt_passed
+  logical :: gt_passed
+  logical :: le_passed
+  logical :: ge_passed
+  logical :: eq_passed
+  logical :: ne_passed
+
+  integer(i8) :: abs_tol_loc
+
+  ! Handling of abs_tol makes a couple of fairly safe assumptions.
+  !  1. It is not the most negative integer.
+  !  2. It is finite (not a floating point infinity or NaN).
+  if (present(abs_tol)) then
+     abs_tol_loc = abs(abs_tol)
+  else
+     abs_tol_loc = 0_i4
+  end if
+
+  is_nan_passed = .true.
+  lt_passed = .true.
+  gt_passed = .true.
+  le_passed = .true.
+  ge_passed = .true.
+  eq_passed = .true.
+  ne_passed = .true.
+
+  ! Do one pass just to find out if we can return with no problem.
+
+#ifdef TYPEFP
+  ! Only floating-point values can actually be Inf/NaN.
+  if (present(is_nan)) &
+     is_nan_passed = GEN_ALL(shr_infnan_isnan(var) .eqv. is_nan)
+#else
+  if (present(is_nan)) &
+     is_nan_passed = .not. is_nan .or. GEN_SIZE(var) == 0
+#endif
+
+  if (present(lt)) &
+     lt_passed = GEN_ALL(var < lt)
+
+  if (present(gt)) &
+     gt_passed = GEN_ALL(var > gt)
+
+  if (present(le)) &
+     le_passed = GEN_ALL(var <= le)
+
+  if (present(ge)) &
+     ge_passed = GEN_ALL(var >= ge)
+
+  if (present(eq)) then
+     eq_passed = GEN_ALL(within_tolerance(eq, var, abs_tol_loc))
+  end if
+
+  if (present(ne)) then
+     ne_passed = GEN_ALL(.not. within_tolerance(ne, var, abs_tol_loc))
+  end if
+
+  if ( is_nan_passed .and. &
+       lt_passed .and. &
+       gt_passed .and. &
+       le_passed .and. &
+       ge_passed .and. &
+       eq_passed .and. &
+       ne_passed) &
+       return
+
+  ! If we got here, assert will fail, so find out where so that we
+  ! can try to print something useful.
+
+  if (.not. is_nan_passed) then
+#ifdef TYPEFP
+     loc_vec = find_first_loc(shr_infnan_isnan(var) .neqv. is_nan)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) "Expected value to be NaN."
+     else
+        write(shr_log_Unit,*) "Expected value to be a number."
+     end if
+#else
+     loc_vec = spread(1,1,7)
+     call print_bad_loc(var, loc_vec, varname)
+     if (is_nan) then
+        write(shr_log_Unit,*) &
+             "Asserted NaN, but the variable is not floating-point!"
+     end if
+#endif
+  end if
+
+  if (.not. lt_passed) then
+     loc_vec = find_first_loc(var >= lt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than ",lt
+  end if
+
+  if (.not. gt_passed) then
+     loc_vec = find_first_loc(var <= gt)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than ",gt
+  end if
+
+  if (.not. le_passed) then
+     loc_vec = find_first_loc(var > le)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be less than or &
+          &equal to ",le
+  end if
+
+  if (.not. ge_passed) then
+     loc_vec = find_first_loc(var < ge)
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be greater than or &
+          &equal to ",ge
+  end if
+
+  if (.not. eq_passed) then
+     loc_vec = find_first_loc(.not. within_tolerance(eq, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to be equal to ",eq
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  if (.not. ne_passed) then
+     loc_vec = find_first_loc(within_tolerance(ne, var, abs_tol_loc))
+     call print_bad_loc(var, loc_vec, varname)
+     write(shr_log_Unit,*) "Expected value to never be equal to ",ne
+     if (abs_tol_loc > 0) &
+          write(shr_log_Unit,*) "Asserted with tolerance ", abs_tol_loc
+  end if
+
+  call shr_sys_abort(msg)
+
+! Undefine local macros.
+#undef TYPEFP
+#undef GEN_SIZE
+#undef GEN_ALL
+
+# 333 "shr_assert_mod.F90.in"
+end subroutine shr_assert_in_domain_7d_long
+
+!--------------------------------------------------------------------------
+!--------------------------------------------------------------------------
+
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_0d_double(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r8), intent(in) :: var
+  integer, intent(in) :: loc_vec(0)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (0 != 0)
+       var(), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_0d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_1d_double(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r8), intent(in) :: var(:)
+  integer, intent(in) :: loc_vec(1)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (1 != 0)
+       var(loc_vec(1)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_1d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_2d_double(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r8), intent(in) :: var(:,:)
+  integer, intent(in) :: loc_vec(2)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (2 != 0)
+       var(loc_vec(1),&
+loc_vec(2)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_2d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_3d_double(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r8), intent(in) :: var(:,:,:)
+  integer, intent(in) :: loc_vec(3)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (3 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_3d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_4d_double(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r8), intent(in) :: var(:,:,:,:)
+  integer, intent(in) :: loc_vec(4)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (4 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_4d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_5d_double(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r8), intent(in) :: var(:,:,:,:,:)
+  integer, intent(in) :: loc_vec(5)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (5 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4),&
+loc_vec(5)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_5d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_6d_double(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r8), intent(in) :: var(:,:,:,:,:,:)
+  integer, intent(in) :: loc_vec(6)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (6 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4),&
+loc_vec(5),&
+loc_vec(6)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_6d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_7d_double(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r8), intent(in) :: var(:,:,:,:,:,:,:)
+  integer, intent(in) :: loc_vec(7)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (7 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4),&
+loc_vec(5),&
+loc_vec(6),&
+loc_vec(7)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_7d_double
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_0d_real(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r4), intent(in) :: var
+  integer, intent(in) :: loc_vec(0)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (0 != 0)
+       var(), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_0d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_1d_real(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r4), intent(in) :: var(:)
+  integer, intent(in) :: loc_vec(1)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (1 != 0)
+       var(loc_vec(1)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_1d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_2d_real(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r4), intent(in) :: var(:,:)
+  integer, intent(in) :: loc_vec(2)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (2 != 0)
+       var(loc_vec(1),&
+loc_vec(2)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_2d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_3d_real(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r4), intent(in) :: var(:,:,:)
+  integer, intent(in) :: loc_vec(3)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (3 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_3d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_4d_real(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r4), intent(in) :: var(:,:,:,:)
+  integer, intent(in) :: loc_vec(4)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (4 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_4d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_5d_real(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r4), intent(in) :: var(:,:,:,:,:)
+  integer, intent(in) :: loc_vec(5)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (5 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4),&
+loc_vec(5)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_5d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_6d_real(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r4), intent(in) :: var(:,:,:,:,:,:)
+  integer, intent(in) :: loc_vec(6)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (6 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4),&
+loc_vec(5),&
+loc_vec(6)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_6d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_7d_real(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  real(r4), intent(in) :: var(:,:,:,:,:,:,:)
+  integer, intent(in) :: loc_vec(7)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (7 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4),&
+loc_vec(5),&
+loc_vec(6),&
+loc_vec(7)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_7d_real
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_0d_int(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i4), intent(in) :: var
+  integer, intent(in) :: loc_vec(0)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (0 != 0)
+       var(), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_0d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_1d_int(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i4), intent(in) :: var(:)
+  integer, intent(in) :: loc_vec(1)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (1 != 0)
+       var(loc_vec(1)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_1d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_2d_int(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i4), intent(in) :: var(:,:)
+  integer, intent(in) :: loc_vec(2)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (2 != 0)
+       var(loc_vec(1),&
+loc_vec(2)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_2d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_3d_int(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i4), intent(in) :: var(:,:,:)
+  integer, intent(in) :: loc_vec(3)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (3 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_3d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_4d_int(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i4), intent(in) :: var(:,:,:,:)
+  integer, intent(in) :: loc_vec(4)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (4 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_4d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_5d_int(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i4), intent(in) :: var(:,:,:,:,:)
+  integer, intent(in) :: loc_vec(5)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (5 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4),&
+loc_vec(5)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_5d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_6d_int(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i4), intent(in) :: var(:,:,:,:,:,:)
+  integer, intent(in) :: loc_vec(6)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (6 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4),&
+loc_vec(5),&
+loc_vec(6)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_6d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_7d_int(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i4), intent(in) :: var(:,:,:,:,:,:,:)
+  integer, intent(in) :: loc_vec(7)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (7 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4),&
+loc_vec(5),&
+loc_vec(6),&
+loc_vec(7)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_7d_int
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_0d_long(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i8), intent(in) :: var
+  integer, intent(in) :: loc_vec(0)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (0 != 0)
+       var(), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_0d_long
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_1d_long(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i8), intent(in) :: var(:)
+  integer, intent(in) :: loc_vec(1)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (1 != 0)
+       var(loc_vec(1)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_1d_long
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_2d_long(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i8), intent(in) :: var(:,:)
+  integer, intent(in) :: loc_vec(2)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (2 != 0)
+       var(loc_vec(1),&
+loc_vec(2)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_2d_long
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_3d_long(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i8), intent(in) :: var(:,:,:)
+  integer, intent(in) :: loc_vec(3)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (3 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_3d_long
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_4d_long(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i8), intent(in) :: var(:,:,:,:)
+  integer, intent(in) :: loc_vec(4)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (4 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_4d_long
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_5d_long(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i8), intent(in) :: var(:,:,:,:,:)
+  integer, intent(in) :: loc_vec(5)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (5 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4),&
+loc_vec(5)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_5d_long
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_6d_long(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i8), intent(in) :: var(:,:,:,:,:,:)
+  integer, intent(in) :: loc_vec(6)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (6 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4),&
+loc_vec(5),&
+loc_vec(6)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_6d_long
+! TYPE double,real,int,long
+! DIMS 0,1,2,3,4,5,6,7
+# 340 "shr_assert_mod.F90.in"
+subroutine print_bad_loc_7d_long(var, loc_vec, varname)
+  ! Print information about a bad location in an variable.
+  ! For scalars, just print value.
+
+  integer(i8), intent(in) :: var(:,:,:,:,:,:,:)
+  integer, intent(in) :: loc_vec(7)
+
+  character(len=*), intent(in), optional :: varname
+
+  character(len=:), allocatable :: varname_to_write
+
+  if (present(varname)) then
+     allocate(varname_to_write, source=varname)
+  else
+     allocate(varname_to_write, source="input variable")
+  end if
+
+  write(shr_log_Unit,*) &
+       "ERROR: shr_assert_in_domain: ",trim(varname_to_write), &
+       " has invalid value ", &
+#if (7 != 0)
+       var(loc_vec(1),&
+loc_vec(2),&
+loc_vec(3),&
+loc_vec(4),&
+loc_vec(5),&
+loc_vec(6),&
+loc_vec(7)), &
+       " at location: ",loc_vec
+#else
+       var
+
+  ! Kill compiler spam for unused loc_vec.
+  if (.false.) write(*,*) loc_vec
+#endif
+
+# 370 "shr_assert_mod.F90.in"
+end subroutine print_bad_loc_7d_long
+
+!--------------------------------------------------------------------------
+!--------------------------------------------------------------------------
+
+! DIMS 0,1,2,3,4,5,6,7
+# 376 "shr_assert_mod.F90.in"
+pure function find_first_loc_0d(mask) result (loc_vec)
+  ! Inefficient but simple subroutine for finding the location of
+  ! the first .true. value in an array.
+  ! If no true values, returns first value.
+
+  logical, intent(in) :: mask
+  integer :: loc_vec(0)
+
+#if (0 != 0)
+  integer :: flags()
+
+  where (mask)
+     flags = 1
+  elsewhere
+     flags = 0
+  end where
+
+  loc_vec = maxloc(flags)
+#else
+
+! Remove compiler warnings (statement will be optimized out).
+
+#if (! defined CPRPGI && ! defined CPRCRAY)
+  if (.false. .and. mask) loc_vec = loc_vec
+#endif
+
+#endif
+
+# 404 "shr_assert_mod.F90.in"
+end function find_first_loc_0d
+! DIMS 0,1,2,3,4,5,6,7
+# 376 "shr_assert_mod.F90.in"
+pure function find_first_loc_1d(mask) result (loc_vec)
+  ! Inefficient but simple subroutine for finding the location of
+  ! the first .true. value in an array.
+  ! If no true values, returns first value.
+
+  logical, intent(in) :: mask(:)
+  integer :: loc_vec(1)
+
+#if (1 != 0)
+  integer :: flags(size(mask,1))
+
+  where (mask)
+     flags = 1
+  elsewhere
+     flags = 0
+  end where
+
+  loc_vec = maxloc(flags)
+#else
+
+! Remove compiler warnings (statement will be optimized out).
+
+#if (! defined CPRPGI && ! defined CPRCRAY)
+  if (.false. .and. mask) loc_vec = loc_vec
+#endif
+
+#endif
+
+# 404 "shr_assert_mod.F90.in"
+end function find_first_loc_1d
+! DIMS 0,1,2,3,4,5,6,7
+# 376 "shr_assert_mod.F90.in"
+pure function find_first_loc_2d(mask) result (loc_vec)
+  ! Inefficient but simple subroutine for finding the location of
+  ! the first .true. value in an array.
+  ! If no true values, returns first value.
+
+  logical, intent(in) :: mask(:,:)
+  integer :: loc_vec(2)
+
+#if (2 != 0)
+  integer :: flags(size(mask,1),&
+size(mask,2))
+
+  where (mask)
+     flags = 1
+  elsewhere
+     flags = 0
+  end where
+
+  loc_vec = maxloc(flags)
+#else
+
+! Remove compiler warnings (statement will be optimized out).
+
+#if (! defined CPRPGI && ! defined CPRCRAY)
+  if (.false. .and. mask) loc_vec = loc_vec
+#endif
+
+#endif
+
+# 404 "shr_assert_mod.F90.in"
+end function find_first_loc_2d
+! DIMS 0,1,2,3,4,5,6,7
+# 376 "shr_assert_mod.F90.in"
+pure function find_first_loc_3d(mask) result (loc_vec)
+  ! Inefficient but simple subroutine for finding the location of
+  ! the first .true. value in an array.
+  ! If no true values, returns first value.
+
+  logical, intent(in) :: mask(:,:,:)
+  integer :: loc_vec(3)
+
+#if (3 != 0)
+  integer :: flags(size(mask,1),&
+size(mask,2),&
+size(mask,3))
+
+  where (mask)
+     flags = 1
+  elsewhere
+     flags = 0
+  end where
+
+  loc_vec = maxloc(flags)
+#else
+
+! Remove compiler warnings (statement will be optimized out).
+
+#if (! defined CPRPGI && ! defined CPRCRAY)
+  if (.false. .and. mask) loc_vec = loc_vec
+#endif
+
+#endif
+
+# 404 "shr_assert_mod.F90.in"
+end function find_first_loc_3d
+! DIMS 0,1,2,3,4,5,6,7
+# 376 "shr_assert_mod.F90.in"
+pure function find_first_loc_4d(mask) result (loc_vec)
+  ! Inefficient but simple subroutine for finding the location of
+  ! the first .true. value in an array.
+  ! If no true values, returns first value.
+
+  logical, intent(in) :: mask(:,:,:,:)
+  integer :: loc_vec(4)
+
+#if (4 != 0)
+  integer :: flags(size(mask,1),&
+size(mask,2),&
+size(mask,3),&
+size(mask,4))
+
+  where (mask)
+     flags = 1
+  elsewhere
+     flags = 0
+  end where
+
+  loc_vec = maxloc(flags)
+#else
+
+! Remove compiler warnings (statement will be optimized out).
+
+#if (! defined CPRPGI && ! defined CPRCRAY)
+  if (.false. .and. mask) loc_vec = loc_vec
+#endif
+
+#endif
+
+# 404 "shr_assert_mod.F90.in"
+end function find_first_loc_4d
+! DIMS 0,1,2,3,4,5,6,7
+# 376 "shr_assert_mod.F90.in"
+pure function find_first_loc_5d(mask) result (loc_vec)
+  ! Inefficient but simple subroutine for finding the location of
+  ! the first .true. value in an array.
+  ! If no true values, returns first value.
+
+  logical, intent(in) :: mask(:,:,:,:,:)
+  integer :: loc_vec(5)
+
+#if (5 != 0)
+  integer :: flags(size(mask,1),&
+size(mask,2),&
+size(mask,3),&
+size(mask,4),&
+size(mask,5))
+
+  where (mask)
+     flags = 1
+  elsewhere
+     flags = 0
+  end where
+
+  loc_vec = maxloc(flags)
+#else
+
+! Remove compiler warnings (statement will be optimized out).
+
+#if (! defined CPRPGI && ! defined CPRCRAY)
+  if (.false. .and. mask) loc_vec = loc_vec
+#endif
+
+#endif
+
+# 404 "shr_assert_mod.F90.in"
+end function find_first_loc_5d
+! DIMS 0,1,2,3,4,5,6,7
+# 376 "shr_assert_mod.F90.in"
+pure function find_first_loc_6d(mask) result (loc_vec)
+  ! Inefficient but simple subroutine for finding the location of
+  ! the first .true. value in an array.
+  ! If no true values, returns first value.
+
+  logical, intent(in) :: mask(:,:,:,:,:,:)
+  integer :: loc_vec(6)
+
+#if (6 != 0)
+  integer :: flags(size(mask,1),&
+size(mask,2),&
+size(mask,3),&
+size(mask,4),&
+size(mask,5),&
+size(mask,6))
+
+  where (mask)
+     flags = 1
+  elsewhere
+     flags = 0
+  end where
+
+  loc_vec = maxloc(flags)
+#else
+
+! Remove compiler warnings (statement will be optimized out).
+
+#if (! defined CPRPGI && ! defined CPRCRAY)
+  if (.false. .and. mask) loc_vec = loc_vec
+#endif
+
+#endif
+
+# 404 "shr_assert_mod.F90.in"
+end function find_first_loc_6d
+! DIMS 0,1,2,3,4,5,6,7
+# 376 "shr_assert_mod.F90.in"
+pure function find_first_loc_7d(mask) result (loc_vec)
+  ! Inefficient but simple subroutine for finding the location of
+  ! the first .true. value in an array.
+  ! If no true values, returns first value.
+
+  logical, intent(in) :: mask(:,:,:,:,:,:,:)
+  integer :: loc_vec(7)
+
+#if (7 != 0)
+  integer :: flags(size(mask,1),&
+size(mask,2),&
+size(mask,3),&
+size(mask,4),&
+size(mask,5),&
+size(mask,6),&
+size(mask,7))
+
+  where (mask)
+     flags = 1
+  elsewhere
+     flags = 0
+  end where
+
+  loc_vec = maxloc(flags)
+#else
+
+! Remove compiler warnings (statement will be optimized out).
+
+#if (! defined CPRPGI && ! defined CPRCRAY)
+  if (.false. .and. mask) loc_vec = loc_vec
+#endif
+
+#endif
+
+# 404 "shr_assert_mod.F90.in"
+end function find_first_loc_7d
+
+! TYPE double,real,int,long
+# 407 "shr_assert_mod.F90.in"
+elemental function within_tolerance_double(expected, actual, tolerance) &
+     result(is_in_tol)
+  ! Precondition: tolerance must be >= 0.
+  real(r8), intent(in) :: expected
+  real(r8), intent(in) :: actual
+  real(r8), intent(in) :: tolerance
+  logical :: is_in_tol
+
+  ! The following conditionals are to ensure that we don't overflow.
+
+  ! This takes care of two identical infinities.
+  if (actual == expected) then
+     is_in_tol = .true.
+  else if (actual > expected) then
+     if (expected >= 0) then
+        is_in_tol = (actual - expected) <= tolerance
+     else
+        is_in_tol = actual <= (expected + tolerance)
+     end if
+  else
+     if (expected < 0) then
+        is_in_tol = (expected - actual) <= tolerance
+     else
+        is_in_tol = actual >= (expected - tolerance)
+     end if
+  end if
+
+# 434 "shr_assert_mod.F90.in"
+end function within_tolerance_double
+! TYPE double,real,int,long
+# 407 "shr_assert_mod.F90.in"
+elemental function within_tolerance_real(expected, actual, tolerance) &
+     result(is_in_tol)
+  ! Precondition: tolerance must be >= 0.
+  real(r4), intent(in) :: expected
+  real(r4), intent(in) :: actual
+  real(r4), intent(in) :: tolerance
+  logical :: is_in_tol
+
+  ! The following conditionals are to ensure that we don't overflow.
+
+  ! This takes care of two identical infinities.
+  if (actual == expected) then
+     is_in_tol = .true.
+  else if (actual > expected) then
+     if (expected >= 0) then
+        is_in_tol = (actual - expected) <= tolerance
+     else
+        is_in_tol = actual <= (expected + tolerance)
+     end if
+  else
+     if (expected < 0) then
+        is_in_tol = (expected - actual) <= tolerance
+     else
+        is_in_tol = actual >= (expected - tolerance)
+     end if
+  end if
+
+# 434 "shr_assert_mod.F90.in"
+end function within_tolerance_real
+! TYPE double,real,int,long
+# 407 "shr_assert_mod.F90.in"
+elemental function within_tolerance_int(expected, actual, tolerance) &
+     result(is_in_tol)
+  ! Precondition: tolerance must be >= 0.
+  integer(i4), intent(in) :: expected
+  integer(i4), intent(in) :: actual
+  integer(i4), intent(in) :: tolerance
+  logical :: is_in_tol
+
+  ! The following conditionals are to ensure that we don't overflow.
+
+  ! This takes care of two identical infinities.
+  if (actual == expected) then
+     is_in_tol = .true.
+  else if (actual > expected) then
+     if (expected >= 0) then
+        is_in_tol = (actual - expected) <= tolerance
+     else
+        is_in_tol = actual <= (expected + tolerance)
+     end if
+  else
+     if (expected < 0) then
+        is_in_tol = (expected - actual) <= tolerance
+     else
+        is_in_tol = actual >= (expected - tolerance)
+     end if
+  end if
+
+# 434 "shr_assert_mod.F90.in"
+end function within_tolerance_int
+! TYPE double,real,int,long
+# 407 "shr_assert_mod.F90.in"
+elemental function within_tolerance_long(expected, actual, tolerance) &
+     result(is_in_tol)
+  ! Precondition: tolerance must be >= 0.
+  integer(i8), intent(in) :: expected
+  integer(i8), intent(in) :: actual
+  integer(i8), intent(in) :: tolerance
+  logical :: is_in_tol
+
+  ! The following conditionals are to ensure that we don't overflow.
+
+  ! This takes care of two identical infinities.
+  if (actual == expected) then
+     is_in_tol = .true.
+  else if (actual > expected) then
+     if (expected >= 0) then
+        is_in_tol = (actual - expected) <= tolerance
+     else
+        is_in_tol = actual <= (expected + tolerance)
+     end if
+  else
+     if (expected < 0) then
+        is_in_tol = (expected - actual) <= tolerance
+     else
+        is_in_tol = actual >= (expected - tolerance)
+     end if
+  end if
+
+# 434 "shr_assert_mod.F90.in"
+end function within_tolerance_long
+
+end module shr_assert_mod
diff --git a/CDEPS-interface/ufs/shr_frz_mod.F90 b/CDEPS-interface/ufs/shr_frz_mod.F90
new file mode 100644
index 0000000000..d925c9301b
--- /dev/null
+++ b/CDEPS-interface/ufs/shr_frz_mod.F90
@@ -0,0 +1,215 @@
+!===================================================
+! DO NOT EDIT THIS FILE, it was generated using genf90.pl
+! Any changes you make to this file may be lost
+!===================================================
+module shr_frz_mod
+
+  !===============================================================================
+  !  This is a module used for the freezing point of salt water
+  !===============================================================================
+
+  use shr_kind_mod, only: R8=>SHR_KIND_R8, CS=>SHR_KIND_CS
+  use shr_log_mod, only: s_logunit => shr_log_Unit, shr_log_level
+  use shr_sys_mod, only: shr_sys_abort
+
+  implicit none
+
+  !----------------------------------------------------------------------------
+  ! PUBLIC: Interfaces and global data
+  !----------------------------------------------------------------------------
+  public :: shr_frz_freezetemp, shr_frz_freezetemp_init
+
+# 18 "shr_frz_mod.F90.in"
+  interface shr_frz_freezetemp
+     module procedure shr_frz_freezetemp_0d
+     module procedure shr_frz_freezetemp_1d
+     module procedure shr_frz_freezetemp_2d
+  end interface shr_frz_freezetemp
+
+  integer, public, parameter :: TFREEZE_OPTION_MINUS1P8 = 1
+  integer, public, parameter :: TFREEZE_OPTION_LINEAR_SALT = 2
+  integer, public, parameter :: TFREEZE_OPTION_MUSHY = 3
+  integer, public, parameter :: TFREEZE_OPTION_UNINITIALIZED = -999
+
+  private
+
+  integer :: tfrz_option = TFREEZE_OPTION_UNINITIALIZED
+
+  !===============================================================================
+# 34 "shr_frz_mod.F90.in"
+contains
+  !===============================================================================
+
+# 37 "shr_frz_mod.F90.in"
+  subroutine shr_frz_freezetemp_init(tfreeze_option, mastertask)
+
+    implicit none
+
+    character(len=*),parameter :: subname = "(shr_frz_freezetemp_init) "
+    character(CS),intent(in)  :: tfreeze_option ! option for computing freezing point
+    logical, intent(in)  :: mastertask ! for io
+    ! minus1p8 is constant -1.8C
+    ! linear_salt is linear equation
+    ! mushy for CICE mushy-layer nonlinear equation
+
+    !---------------------------------------------------------------
+    ! Check tfreeze_option
+    !---------------------------------------------------------------
+    if (trim(tfreeze_option) == 'minus1p8') then
+       if (mastertask .and. shr_log_level>0) write(s_logunit,*) ' tfreeze_option is minus1p8'
+       tfrz_option = TFREEZE_OPTION_MINUS1P8
+    elseif (trim(tfreeze_option) == 'linear_salt') then
+       if (mastertask .and. shr_log_level>0) write(s_logunit,*) ' tfreeze_option is linear_salt'
+       tfrz_option = TFREEZE_OPTION_LINEAR_SALT
+    elseif (trim(tfreeze_option) == 'mushy') then
+       if (mastertask .and. shr_log_level>0) write(s_logunit,*) ' tfreeze_option is mushy'
+       tfrz_option = TFREEZE_OPTION_MUSHY
+    else
+       call shr_sys_abort(subname//' ERROR: not a valid tfreeze_option '//trim(tfreeze_option))
+    endif
+
+# 64 "shr_frz_mod.F90.in"
+  end subroutine shr_frz_freezetemp_init
+
+  ! DIMS 0,1,2
+# 67 "shr_frz_mod.F90.in"
+  function shr_frz_freezetemp_0d(s) result(shr_frz_freezetemp)
+
+    !----------------------------------------------------------------------------
+    !
+    ! FUNCTION to return the freezing point of salt water in degrees Celsus
+    !
+    !--------------- Code History -----------------------------------------------
+    !
+    ! Original Author: David Bailey
+    ! Date:            Feb, 2016
+    !----------------------------------------------------------------------------
+
+    implicit none
+
+    character(len=*),parameter :: subname = "(shr_frz_freezetemp_0d) "
+
+    real   (R8),intent(in) :: s ! Salinity in psu
+#if (0==0)
+    real   (R8) :: shr_frz_freezetemp
+#elif (0==1)
+    real   (R8) :: shr_frz_freezetemp(size(s))
+#elif (0==2)
+    real   (R8) :: shr_frz_freezetemp(size(s,1),size(s,2))
+#endif
+
+    !----------------------------------------------------------------------------
+    shr_frz_freezetemp = -274.0_R8
+    if (tfrz_option == TFREEZE_OPTION_MINUS1P8) then
+       shr_frz_freezetemp = -1.8_R8
+    elseif (tfrz_option == TFREEZE_OPTION_LINEAR_SALT) then
+       shr_frz_freezetemp = -0.0544_R8*max(s,0.0_R8)
+    elseif (tfrz_option == TFREEZE_OPTION_MUSHY) then
+       !     This form is the high temperature part of the liquidus relation (Assur 1958)
+       shr_frz_freezetemp = max(s,0.0_R8) &
+            / (-18.48_R8 + (0.01848_R8*max(s,0.0_R8)))
+    else
+       call shr_sys_abort(subname//' ERROR: not intialized correctly with a valid tfreeze_option - &
+            &call shr_frz_freezetemp_init first with a valid tfreeze_option')
+    endif
+
+    shr_frz_freezetemp = max(shr_frz_freezetemp,-2.0_R8)
+
+# 109 "shr_frz_mod.F90.in"
+  end function shr_frz_freezetemp_0d
+  ! DIMS 0,1,2
+# 67 "shr_frz_mod.F90.in"
+  function shr_frz_freezetemp_1d(s) result(shr_frz_freezetemp)
+
+    !----------------------------------------------------------------------------
+    !
+    ! FUNCTION to return the freezing point of salt water in degrees Celsus
+    !
+    !--------------- Code History -----------------------------------------------
+    !
+    ! Original Author: David Bailey
+    ! Date:            Feb, 2016
+    !----------------------------------------------------------------------------
+
+    implicit none
+
+    character(len=*),parameter :: subname = "(shr_frz_freezetemp_1d) "
+
+    real   (R8),intent(in) :: s(:) ! Salinity in psu
+#if (1==0)
+    real   (R8) :: shr_frz_freezetemp
+#elif (1==1)
+    real   (R8) :: shr_frz_freezetemp(size(s))
+#elif (1==2)
+    real   (R8) :: shr_frz_freezetemp(size(s,1),size(s,2))
+#endif
+
+    !----------------------------------------------------------------------------
+    shr_frz_freezetemp = -274.0_R8
+    if (tfrz_option == TFREEZE_OPTION_MINUS1P8) then
+       shr_frz_freezetemp = -1.8_R8
+    elseif (tfrz_option == TFREEZE_OPTION_LINEAR_SALT) then
+       shr_frz_freezetemp = -0.0544_R8*max(s,0.0_R8)
+    elseif (tfrz_option == TFREEZE_OPTION_MUSHY) then
+       !     This form is the high temperature part of the liquidus relation (Assur 1958)
+       shr_frz_freezetemp = max(s,0.0_R8) &
+            / (-18.48_R8 + (0.01848_R8*max(s,0.0_R8)))
+    else
+       call shr_sys_abort(subname//' ERROR: not intialized correctly with a valid tfreeze_option - &
+            &call shr_frz_freezetemp_init first with a valid tfreeze_option')
+    endif
+
+    shr_frz_freezetemp = max(shr_frz_freezetemp,-2.0_R8)
+
+# 109 "shr_frz_mod.F90.in"
+  end function shr_frz_freezetemp_1d
+  ! DIMS 0,1,2
+# 67 "shr_frz_mod.F90.in"
+  function shr_frz_freezetemp_2d(s) result(shr_frz_freezetemp)
+
+    !----------------------------------------------------------------------------
+    !
+    ! FUNCTION to return the freezing point of salt water in degrees Celsus
+    !
+    !--------------- Code History -----------------------------------------------
+    !
+    ! Original Author: David Bailey
+    ! Date:            Feb, 2016
+    !----------------------------------------------------------------------------
+
+    implicit none
+
+    character(len=*),parameter :: subname = "(shr_frz_freezetemp_2d) "
+
+    real   (R8),intent(in) :: s(:,:) ! Salinity in psu
+#if (2==0)
+    real   (R8) :: shr_frz_freezetemp
+#elif (2==1)
+    real   (R8) :: shr_frz_freezetemp(size(s))
+#elif (2==2)
+    real   (R8) :: shr_frz_freezetemp(size(s,1),size(s,2))
+#endif
+
+    !----------------------------------------------------------------------------
+    shr_frz_freezetemp = -274.0_R8
+    if (tfrz_option == TFREEZE_OPTION_MINUS1P8) then
+       shr_frz_freezetemp = -1.8_R8
+    elseif (tfrz_option == TFREEZE_OPTION_LINEAR_SALT) then
+       shr_frz_freezetemp = -0.0544_R8*max(s,0.0_R8)
+    elseif (tfrz_option == TFREEZE_OPTION_MUSHY) then
+       !     This form is the high temperature part of the liquidus relation (Assur 1958)
+       shr_frz_freezetemp = max(s,0.0_R8) &
+            / (-18.48_R8 + (0.01848_R8*max(s,0.0_R8)))
+    else
+       call shr_sys_abort(subname//' ERROR: not intialized correctly with a valid tfreeze_option - &
+            &call shr_frz_freezetemp_init first with a valid tfreeze_option')
+    endif
+
+    shr_frz_freezetemp = max(shr_frz_freezetemp,-2.0_R8)
+
+# 109 "shr_frz_mod.F90.in"
+  end function shr_frz_freezetemp_2d
+
+  !===============================================================================
+
+end module shr_frz_mod
diff --git a/CDEPS-interface/ufs/shr_infnan_mod.F90 b/CDEPS-interface/ufs/shr_infnan_mod.F90
new file mode 100644
index 0000000000..19f1ac824d
--- /dev/null
+++ b/CDEPS-interface/ufs/shr_infnan_mod.F90
@@ -0,0 +1,1910 @@
+#include "dtypes.h"
+!===================================================
+! DO NOT EDIT THIS FILE, it was generated using genf90.pl
+! Any changes you make to this file may be lost
+!===================================================
+#define CPRINTEL 1
+! Flag representing compiler support of Fortran 2003's
+! ieee_arithmetic intrinsic module.
+#if defined CPRIBM || defined CPRPGI || defined CPRINTEL ||  defined CPRCRAY || defined CPRNAG
+#define HAVE_IEEE_ARITHMETIC
+#endif
+
+module shr_infnan_mod
+!---------------------------------------------------------------------
+! Module to test for IEEE Inf and NaN values, which also provides a
+! method of setting +/-Inf and signaling or quiet NaN.
+!
+! All functions are elemental, and thus work on arrays.
+!---------------------------------------------------------------------
+! To test for these values, just call the corresponding function, e.g:
+!
+!   var_is_nan = shr_infnan_isnan(x)
+!
+! You can also use it on arrays:
+!
+!   array_contains_nan = any(shr_infnan_isnan(my_array))
+!
+!---------------------------------------------------------------------
+! To generate these values, assign one of the provided derived-type
+! variables to a real:
+!
+!   use shr_infnan_mod, only: nan => shr_infnan_nan, &
+!                             inf => shr_infnan_inf, &
+!                             assignment(=)
+!   real(r4) :: my_nan
+!   real(r8) :: my_inf_array(2,2)
+!   my_nan = nan
+!   my_inf_array = inf
+!
+! Keep in mind that "shr_infnan_nan" and "shr_infnan_inf" cannot be
+! passed to functions that expect real arguments. To pass a real
+! NaN, you will have to use shr_infnan_nan to set a local real of
+! the correct kind.
+!---------------------------------------------------------------------
+
+use shr_kind_mod, only: &
+     r4 => SHR_KIND_R4, &
+     r8 => SHR_KIND_R8
+
+#ifdef HAVE_IEEE_ARITHMETIC
+
+! If we have IEEE_ARITHMETIC, the NaN test is provided for us.
+use, intrinsic :: ieee_arithmetic, only: &
+     shr_infnan_isnan => ieee_is_nan
+
+#else
+
+! Integers of correct size for bit patterns below.
+use shr_kind_mod, only: i4 => shr_kind_i4, i8 => shr_kind_i8
+
+#endif
+
+implicit none
+private
+save
+
+! Test functions for NaN/Inf values.
+public :: shr_infnan_isnan
+public :: shr_infnan_isinf
+public :: shr_infnan_isposinf
+public :: shr_infnan_isneginf
+
+! Locally defined isnan.
+#ifndef HAVE_IEEE_ARITHMETIC
+# 70 "shr_infnan_mod.F90.in"
+interface shr_infnan_isnan
+   ! TYPE double,real
+   module procedure shr_infnan_isnan_double
+   ! TYPE double,real
+   module procedure shr_infnan_isnan_real
+end interface
+#endif
+
+# 76 "shr_infnan_mod.F90.in"
+interface shr_infnan_isinf
+   ! TYPE double,real
+   module procedure shr_infnan_isinf_double
+   ! TYPE double,real
+   module procedure shr_infnan_isinf_real
+end interface
+
+# 81 "shr_infnan_mod.F90.in"
+interface shr_infnan_isposinf
+   ! TYPE double,real
+   module procedure shr_infnan_isposinf_double
+   ! TYPE double,real
+   module procedure shr_infnan_isposinf_real
+end interface
+
+# 86 "shr_infnan_mod.F90.in"
+interface shr_infnan_isneginf
+   ! TYPE double,real
+   module procedure shr_infnan_isneginf_double
+   ! TYPE double,real
+   module procedure shr_infnan_isneginf_real
+end interface
+
+! Derived types for generation of NaN/Inf
+! Even though there's no reason to "use" the types directly, some compilers
+! might have trouble with an object being used without its type.
+public :: shr_infnan_nan_type
+public :: shr_infnan_inf_type
+public :: assignment(=)
+public :: shr_infnan_to_r4
+public :: shr_infnan_to_r8
+
+! Type representing Not A Number.
+type :: shr_infnan_nan_type
+   logical :: quiet = .false.
+end type shr_infnan_nan_type
+
+! Type representing +/-Infinity.
+type :: shr_infnan_inf_type
+   logical :: positive = .true.
+end type shr_infnan_inf_type
+
+! Allow assigning reals to NaN or Inf.
+# 111 "shr_infnan_mod.F90.in"
+interface assignment(=)
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_0d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_1d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_2d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_3d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_4d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_5d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_6d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_7d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_0d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_1d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_2d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_3d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_4d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_5d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_6d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_nan_7d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_0d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_1d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_2d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_3d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_4d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_5d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_6d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_7d_double
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_0d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_1d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_2d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_3d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_4d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_5d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_6d_real
+   ! TYPE double,real
+   ! DIMS 0,1,2,3,4,5,6,7
+   module procedure set_inf_7d_real
+end interface
+
+! Conversion functions.
+# 121 "shr_infnan_mod.F90.in"
+interface shr_infnan_to_r8
+   module procedure nan_r8
+   module procedure inf_r8
+end interface
+
+# 126 "shr_infnan_mod.F90.in"
+interface shr_infnan_to_r4
+   module procedure nan_r4
+   module procedure inf_r4
+end interface
+
+! Initialize objects of NaN/Inf type for other modules to use.
+
+! Default NaN is signaling, but also provide snan and qnan to choose
+! explicitly.
+type(shr_infnan_nan_type), public, parameter :: shr_infnan_nan = &
+     shr_infnan_nan_type(.false.)
+type(shr_infnan_nan_type), public, parameter :: shr_infnan_snan = &
+     shr_infnan_nan_type(.false.)
+type(shr_infnan_nan_type), public, parameter :: shr_infnan_qnan = &
+     shr_infnan_nan_type(.true.)
+
+! Default Inf is positive, but provide posinf to go with neginf.
+type(shr_infnan_inf_type), public, parameter :: shr_infnan_inf = &
+     shr_infnan_inf_type(.true.)
+type(shr_infnan_inf_type), public, parameter :: shr_infnan_posinf = &
+     shr_infnan_inf_type(.true.)
+type(shr_infnan_inf_type), public, parameter :: shr_infnan_neginf = &
+     shr_infnan_inf_type(.false.)
+
+! Bit patterns for implementation without ieee_arithmetic.
+! Note that in order to satisfy gfortran's range check, we have to use
+! ibset to set the sign bit from a BOZ pattern.
+#ifndef HAVE_IEEE_ARITHMETIC
+! Single precision.
+integer(i4), parameter :: ssnan_pat = int(Z'7FA00000',i4)
+integer(i4), parameter :: sqnan_pat = int(Z'7FC00000',i4)
+integer(i4), parameter :: sposinf_pat = int(Z'7F800000',i4)
+integer(i4), parameter :: sneginf_pat = ibset(sposinf_pat,bit_size(1_i4)-1)
+! Double precision.
+integer(i8), parameter :: dsnan_pat = int(Z'7FF4000000000000',i8)
+integer(i8), parameter :: dqnan_pat = int(Z'7FF8000000000000',i8)
+integer(i8), parameter :: dposinf_pat = int(Z'7FF0000000000000',i8)
+integer(i8), parameter :: dneginf_pat = ibset(dposinf_pat,bit_size(1_i8)-1)
+#endif
+
+# 166 "shr_infnan_mod.F90.in"
+contains
+
+!---------------------------------------------------------------------
+! TEST FUNCTIONS
+!---------------------------------------------------------------------
+! The "isinf" function simply calls "isposinf" and "isneginf".
+!---------------------------------------------------------------------
+
+! TYPE double,real
+# 175 "shr_infnan_mod.F90.in"
+elemental function shr_infnan_isinf_double(x) result(isinf)
+  real(r8), intent(in) :: x
+  logical :: isinf
+
+  isinf = shr_infnan_isposinf(x) .or. shr_infnan_isneginf(x)
+
+# 181 "shr_infnan_mod.F90.in"
+end function shr_infnan_isinf_double
+! TYPE double,real
+# 175 "shr_infnan_mod.F90.in"
+elemental function shr_infnan_isinf_real(x) result(isinf)
+  real(r4), intent(in) :: x
+  logical :: isinf
+
+  isinf = shr_infnan_isposinf(x) .or. shr_infnan_isneginf(x)
+
+# 181 "shr_infnan_mod.F90.in"
+end function shr_infnan_isinf_real
+
+#ifdef HAVE_IEEE_ARITHMETIC
+
+!---------------------------------------------------------------------
+! The "isposinf" and "isneginf" functions get the IEEE class of a
+! real, and test to see if the class is equal to ieee_positive_inf
+! or ieee_negative_inf.
+!---------------------------------------------------------------------
+
+! TYPE double,real
+# 192 "shr_infnan_mod.F90.in"
+elemental function shr_infnan_isposinf_double(x) result(isposinf)
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_class, &
+       ieee_positive_inf, &
+       operator(==)
+  real(r8), intent(in) :: x
+  logical :: isposinf
+
+  isposinf = (ieee_positive_inf == ieee_class(x))
+
+# 202 "shr_infnan_mod.F90.in"
+end function shr_infnan_isposinf_double
+! TYPE double,real
+# 192 "shr_infnan_mod.F90.in"
+elemental function shr_infnan_isposinf_real(x) result(isposinf)
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_class, &
+       ieee_positive_inf, &
+       operator(==)
+  real(r4), intent(in) :: x
+  logical :: isposinf
+
+  isposinf = (ieee_positive_inf == ieee_class(x))
+
+# 202 "shr_infnan_mod.F90.in"
+end function shr_infnan_isposinf_real
+
+! TYPE double,real
+# 205 "shr_infnan_mod.F90.in"
+elemental function shr_infnan_isneginf_double(x) result(isneginf)
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_class, &
+       ieee_negative_inf, &
+       operator(==)
+  real(r8), intent(in) :: x
+  logical :: isneginf
+
+  isneginf = (ieee_negative_inf == ieee_class(x))
+
+# 215 "shr_infnan_mod.F90.in"
+end function shr_infnan_isneginf_double
+! TYPE double,real
+# 205 "shr_infnan_mod.F90.in"
+elemental function shr_infnan_isneginf_real(x) result(isneginf)
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_class, &
+       ieee_negative_inf, &
+       operator(==)
+  real(r4), intent(in) :: x
+  logical :: isneginf
+
+  isneginf = (ieee_negative_inf == ieee_class(x))
+
+# 215 "shr_infnan_mod.F90.in"
+end function shr_infnan_isneginf_real
+
+#else
+! Don't have ieee_arithmetic.
+
+#ifdef CPRGNU
+! NaN testing on gfortran.
+! TYPE double,real
+# 223 "shr_infnan_mod.F90.in"
+elemental function shr_infnan_isnan_double(x) result(is_nan)
+  real(r8), intent(in) :: x
+  logical :: is_nan
+
+  is_nan = isnan(x)
+
+# 229 "shr_infnan_mod.F90.in"
+end function shr_infnan_isnan_double
+! TYPE double,real
+# 223 "shr_infnan_mod.F90.in"
+elemental function shr_infnan_isnan_real(x) result(is_nan)
+  real(r4), intent(in) :: x
+  logical :: is_nan
+
+  is_nan = isnan(x)
+
+# 229 "shr_infnan_mod.F90.in"
+end function shr_infnan_isnan_real
+! End GNU section.
+#endif
+
+!---------------------------------------------------------------------
+! The "isposinf" and "isneginf" functions just test against a known
+! bit pattern if we don't have ieee_arithmetic.
+!---------------------------------------------------------------------
+
+! TYPE double,real
+# 239 "shr_infnan_mod.F90.in"
+elemental function shr_infnan_isposinf_double(x) result(isposinf)
+  real(r8), intent(in) :: x
+  logical :: isposinf
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+#endif
+
+  isposinf = (x == transfer(posinf_pat,x))
+
+# 250 "shr_infnan_mod.F90.in"
+end function shr_infnan_isposinf_double
+! TYPE double,real
+# 239 "shr_infnan_mod.F90.in"
+elemental function shr_infnan_isposinf_real(x) result(isposinf)
+  real(r4), intent(in) :: x
+  logical :: isposinf
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+#endif
+
+  isposinf = (x == transfer(posinf_pat,x))
+
+# 250 "shr_infnan_mod.F90.in"
+end function shr_infnan_isposinf_real
+
+! TYPE double,real
+# 253 "shr_infnan_mod.F90.in"
+elemental function shr_infnan_isneginf_double(x) result(isneginf)
+  real(r8), intent(in) :: x
+  logical :: isneginf
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+
+  isneginf = (x == transfer(neginf_pat,x))
+
+# 264 "shr_infnan_mod.F90.in"
+end function shr_infnan_isneginf_double
+! TYPE double,real
+# 253 "shr_infnan_mod.F90.in"
+elemental function shr_infnan_isneginf_real(x) result(isneginf)
+  real(r4), intent(in) :: x
+  logical :: isneginf
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+
+  isneginf = (x == transfer(neginf_pat,x))
+
+# 264 "shr_infnan_mod.F90.in"
+end function shr_infnan_isneginf_real
+
+! End ieee_arithmetic conditional.
+#endif
+
+!---------------------------------------------------------------------
+! GENERATION FUNCTIONS
+!---------------------------------------------------------------------
+! Two approaches for generation of NaN and Inf values:
+!   1. With Fortran 2003, use the ieee_value intrinsic to get a value
+!      from the corresponding class. These are:
+!       - ieee_signaling_nan
+!       - ieee_quiet_nan
+!       - ieee_positive_inf
+!       - ieee_negative_inf
+!   2. Without Fortran 2003, set the IEEE bit patterns directly.
+!      Use BOZ literals to get an integer with the correct bit
+!      pattern, then use "transfer" to transfer those bits into a
+!      real.
+!---------------------------------------------------------------------
+
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_0d_double(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r8), intent(out) :: output
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_0d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_1d_double(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r8), intent(out) :: output(:)
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_1d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_2d_double(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r8), intent(out) :: output(:,:)
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_2d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_3d_double(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r8), intent(out) :: output(:,:,:)
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_3d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_4d_double(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r8), intent(out) :: output(:,:,:,:)
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_4d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_5d_double(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r8), intent(out) :: output(:,:,:,:,:)
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_5d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_6d_double(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r8), intent(out) :: output(:,:,:,:,:,:)
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_6d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_7d_double(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r8), intent(out) :: output(:,:,:,:,:,:,:)
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_7d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_0d_real(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r4), intent(out) :: output
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_0d_real
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_1d_real(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r4), intent(out) :: output(:)
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_1d_real
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_2d_real(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r4), intent(out) :: output(:,:)
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_2d_real
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_3d_real(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r4), intent(out) :: output(:,:,:)
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_3d_real
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_4d_real(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r4), intent(out) :: output(:,:,:,:)
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_4d_real
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_5d_real(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r4), intent(out) :: output(:,:,:,:,:)
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_5d_real
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_6d_real(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r4), intent(out) :: output(:,:,:,:,:,:)
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_6d_real
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 287 "shr_infnan_mod.F90.in"
+pure subroutine set_nan_7d_real(output, nan)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_signaling_nan, &
+       ieee_quiet_nan, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: snan_pat = ssnan_pat
+  integer(i4), parameter :: qnan_pat = sqnan_pat
+#else
+  integer(i8), parameter :: snan_pat = dsnan_pat
+  integer(i8), parameter :: qnan_pat = dqnan_pat
+#endif
+#endif
+  real(r4), intent(out) :: output(:,:,:,:,:,:,:)
+  type(shr_infnan_nan_type), intent(in) :: nan
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (nan%quiet) then
+     tmp = ieee_value(tmp, ieee_quiet_nan)
+  else
+     tmp = ieee_value(tmp, ieee_signaling_nan)
+  end if
+#else
+  if (nan%quiet) then
+     tmp = transfer(qnan_pat, tmp)
+  else
+     tmp = transfer(snan_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 325 "shr_infnan_mod.F90.in"
+end subroutine set_nan_7d_real
+
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_0d_double(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r8), intent(out) :: output
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_0d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_1d_double(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r8), intent(out) :: output(:)
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_1d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_2d_double(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r8), intent(out) :: output(:,:)
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_2d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_3d_double(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r8), intent(out) :: output(:,:,:)
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_3d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_4d_double(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r8), intent(out) :: output(:,:,:,:)
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_4d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_5d_double(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r8), intent(out) :: output(:,:,:,:,:)
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_5d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_6d_double(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r8), intent(out) :: output(:,:,:,:,:,:)
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_6d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_7d_double(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (102 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r8), intent(out) :: output(:,:,:,:,:,:,:)
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r8) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_7d_double
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_0d_real(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r4), intent(out) :: output
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_0d_real
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_1d_real(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r4), intent(out) :: output(:)
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_1d_real
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_2d_real(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r4), intent(out) :: output(:,:)
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_2d_real
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_3d_real(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r4), intent(out) :: output(:,:,:)
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_3d_real
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_4d_real(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r4), intent(out) :: output(:,:,:,:)
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_4d_real
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_5d_real(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r4), intent(out) :: output(:,:,:,:,:)
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_5d_real
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_6d_real(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r4), intent(out) :: output(:,:,:,:,:,:)
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_6d_real
+! TYPE double,real
+! DIMS 0,1,2,3,4,5,6,7
+# 329 "shr_infnan_mod.F90.in"
+pure subroutine set_inf_7d_real(output, inf)
+#ifdef HAVE_IEEE_ARITHMETIC
+  use, intrinsic :: ieee_arithmetic, only: &
+       ieee_positive_inf, &
+       ieee_negative_inf, &
+       ieee_value
+#else
+#if (101 == TYPEREAL)
+  integer(i4), parameter :: posinf_pat = sposinf_pat
+  integer(i4), parameter :: neginf_pat = sneginf_pat
+#else
+  integer(i8), parameter :: posinf_pat = dposinf_pat
+  integer(i8), parameter :: neginf_pat = dneginf_pat
+#endif
+#endif
+  real(r4), intent(out) :: output(:,:,:,:,:,:,:)
+  type(shr_infnan_inf_type), intent(in) :: inf
+
+  ! Use scalar temporary for performance reasons, to reduce the cost of
+  ! the ieee_value call.
+  real(r4) :: tmp
+
+#ifdef HAVE_IEEE_ARITHMETIC
+  if (inf%positive) then
+     tmp = ieee_value(tmp,ieee_positive_inf)
+  else
+     tmp = ieee_value(tmp,ieee_negative_inf)
+  end if
+#else
+  if (inf%positive) then
+     tmp = transfer(posinf_pat, tmp)
+  else
+     tmp = transfer(neginf_pat, tmp)
+  end if
+#endif
+
+  output = tmp
+
+# 367 "shr_infnan_mod.F90.in"
+end subroutine set_inf_7d_real
+
+!---------------------------------------------------------------------
+! CONVERSION INTERFACES.
+!---------------------------------------------------------------------
+! Function methods to get reals from nan/inf types.
+!---------------------------------------------------------------------
+
+# 375 "shr_infnan_mod.F90.in"
+pure function nan_r8(nan) result(output)
+  class(shr_infnan_nan_type), intent(in) :: nan
+  real(r8) :: output
+
+  output = nan
+
+# 381 "shr_infnan_mod.F90.in"
+end function nan_r8
+
+# 383 "shr_infnan_mod.F90.in"
+pure function nan_r4(nan) result(output)
+  class(shr_infnan_nan_type), intent(in) :: nan
+  real(r4) :: output
+
+  output = nan
+
+# 389 "shr_infnan_mod.F90.in"
+end function nan_r4
+
+# 391 "shr_infnan_mod.F90.in"
+pure function inf_r8(inf) result(output)
+  class(shr_infnan_inf_type), intent(in) :: inf
+  real(r8) :: output
+
+  output = inf
+
+# 397 "shr_infnan_mod.F90.in"
+end function inf_r8
+
+# 399 "shr_infnan_mod.F90.in"
+pure function inf_r4(inf) result(output)
+  class(shr_infnan_inf_type), intent(in) :: inf
+  real(r4) :: output
+
+  output = inf
+
+# 405 "shr_infnan_mod.F90.in"
+end function inf_r4
+
+end module shr_infnan_mod