Merge remote-tracking branch 'upstream/development' into hplin/fhist_c4

Author: hplin-ucar

cime_config/namelist_definition_cam.xml

@@ -236,6 +236,38 @@
       <value>.false.</value>
     </values>
   </entry>
+  <entry id="ncdata_check_exclude">
+    <type>char*256(200)</type>
+    <category>initial_conditions</category>
+    <group>physics_nl</group>
+    <desc>
+      Ordered list of glob patterns ('*' matches any run of characters)
+      excluding variables from the `{{ hilight }}ncdata_check{{ closehilight }}`
+      comparison.  These case-insensitive patterns are matched against
+      the name reported in the physics check output.
+
+      For constituent-dimensioned variables, the per-constituent
+      file variable name is used.
+
+      A gitignore-style keep is also supported:
+      A pattern with a leading '!' keeps (still compares) the name,
+      any other pattern excludes it; names matching no pattern are compared.
+      The first pattern that matches a name decides.
+
+      Example: '!aerochem_vmr_post*', 'aerochem_vmr_*' excludes the aerochem_vmr rows except the aerochem_vmr_post* ones.
+               'aerochem_vmr_*', '!aerochem_vmr_post*' excludes ALL aerochem_vmr rows, including the aerochem_vmr_post* ones.
+
+      Excluded rows are listed in the check output and are not silently dropped.
+
+      This is intended to be used in conjunction with ncdata_check_err=.true.
+      in testmods to exclude any expected differences.
+
+      Default: '' (no exclusions)
+    </desc>
+    <values>
+      <value>''</value>
+    </values>
+  </entry>
   <entry id="min_difference">
     <type>real</type>
     <category>diagnostics</category>

src/core_utils/string_core_utils.F90

@@ -7,11 +7,13 @@ module string_core_utils
     public :: core_int_date_to_yyyymmdd  ! Convert encoded date integer to "yyyy-mm-dd" format
     public :: core_int_seconds_to_hhmmss ! Convert integer seconds past midnight to "hh:mm:ss" format
     public :: split                      ! Parse a string into tokens, one at a time
-    public :: stringify                  ! Convert one or more values of any intrinsic data types to a character string for pretty printing
+    public :: stringify                  ! Convert one or more values of any intrinsic data types to a character string.
     public :: tokenize                   ! Parse a string into tokens
     public :: increment_string           ! Increment a string whose ending characters are digits.
     public :: last_non_digit             ! Get position of last non-digit in the input string.
     public :: get_last_significant_char  ! Get position of last significant (non-blank, non-null) character in string.
+    public :: core_glob_match            ! Match a string against a '*'-wildcard glob pattern.
+    public :: core_glob_list_excluded    ! First-match-wins exclusion decision over an ordered glob pattern list ('!' keeps).
 
     interface tokenize
         module procedure tokenize_into_first_last
@@ -20,16 +22,16 @@ module string_core_utils
 
 contains
 
-    character(len=10) pure function core_to_str(n)
+    character(len=10) pure function core_to_str(n) result(str)
         ! return default integer as a left justified string
 
         integer, intent(in) :: n
-    
-        write(core_to_str,'(i0)') n
-    
+
+        write(str,'(i0)') n
+
     end function core_to_str
 
-    character(len=10) pure function core_int_date_to_yyyymmdd (date)
+    character(len=10) pure function core_int_date_to_yyyymmdd (date) result(date_str)
         ! Undefined behavior if date <= 0
 
         ! Input arguments
@@ -44,12 +46,12 @@ character(len=10) pure function core_int_date_to_yyyymmdd (date)
         month = (date - year*10000) / 100
         day   = date - year*10000 - month*100
 
-        write(core_int_date_to_yyyymmdd, '(i4.4,A,i2.2,A,i2.2)') &
-                                           year,'-',month,'-',day
+        write(date_str, '(i4.4,A,i2.2,A,i2.2)') &
+                          year,'-',month,'-',day
 
     end function core_int_date_to_yyyymmdd
 
-    character(len=8) pure function core_int_seconds_to_hhmmss (seconds)
+    character(len=8) pure function core_int_seconds_to_hhmmss (seconds) result(time_str)
         ! Undefined behavior if seconds outside [0, 86400]
 
         ! Input arguments
@@ -64,8 +66,8 @@ character(len=8) pure function core_int_seconds_to_hhmmss (seconds)
         minutes = (seconds - hours*3600) / 60
         secs    = (seconds - hours*3600 - minutes*60)
 
-        write(core_int_seconds_to_hhmmss,'(i2.2,A,i2.2,A,i2.2)') &
-                                        hours,':',minutes,':',secs
+        write(time_str,'(i2.2,A,i2.2,A,i2.2)') &
+                      hours,':',minutes,':',secs
 
     end function core_int_seconds_to_hhmmss
 
@@ -116,12 +118,12 @@ end subroutine split
     !> If `value` contains zero element or is of unsupported data types, an empty character string is produced.
     !> If `separator` is not supplied, it defaults to ", " (i.e., a comma and a space).
     !> (KCW, 2024-02-04)
-    pure function stringify(value, separator)
+    pure function stringify(value, separator) result(str)
         use, intrinsic :: iso_fortran_env, only: int32, int64, real32, real64
 
         class(*), intent(in) :: value(:)
         character(*), optional, intent(in) :: separator
-        character(:), allocatable :: stringify
+        character(:), allocatable :: str
 
         integer, parameter :: sizelimit = 1024
 
@@ -138,7 +140,7 @@ pure function stringify(value, separator)
         n = min(size(value), sizelimit)
 
         if (n == 0) then
-            stringify = ''
+            str = ''
 
             return
         end if
@@ -220,12 +222,12 @@ pure function stringify(value, separator)
 
                 write(buffer, format) value
             class default
-                stringify = ''
+                str = ''
 
                 return
         end select
 
-        stringify = trim(buffer)
+        str = trim(buffer)
     end function stringify
 
     !> Parse a string into tokens. Each character in `set` is a token delimiter.
@@ -305,7 +307,7 @@ end subroutine tokenize_into_tokens_separator
     !  0 success
     ! -1 error: no trailing digits in string
     ! -2 error: incremented integer is out of range
-    integer function increment_string(s, inc)
+    integer function increment_string(s, inc) result(status)
         integer,          intent(in)    :: inc ! value to increment string (may be negative)
         character(len=*), intent(inout) :: s   ! string with trailing digits
 
@@ -323,7 +325,7 @@ integer function increment_string(s, inc)
         ndigit = lstr - lnd
 
         if(ndigit == 0) then
-            increment_string = -1
+            status = -1
             return
         end if
 
@@ -338,46 +340,46 @@ integer function increment_string(s, inc)
 
         ! Increment the integer
         ival = ival + inc
-        if( ival < 0 .or. ival > 10**ndigit-1 ) then
-            increment_string = -2
+        if(ival < 0 .or. ival > 10**ndigit-1) then
+            status = -2
             return
         end if
 
         ! Overwrite trailing digits
         pow = ndigit
         do i = lnd+1,lstr
-            digit  = MOD( ival,10**pow ) / 10**(pow-1)
-            s(i:i) = CHAR( ICHAR('0') + digit )
+            digit  = MOD(ival,10**pow) / 10**(pow-1)
+            s(i:i) = CHAR(ICHAR('0') + digit)
             pow    = pow - 1
         end do
 
-        increment_string = 0
+        status = 0
 
     end function increment_string
 
     ! Get position of last non-digit in the input string.
     ! Return values:
     !     > 0  => position of last non-digit
     !     = 0  => token is all digits (or empty)
-    integer pure function last_non_digit(s)
+    integer pure function last_non_digit(s) result(pos)
         character(len=*), intent(in) :: s
         integer :: n, nn, digit
 
         n = get_last_significant_char(s)
         if(n == 0) then     ! empty string
-            last_non_digit = 0
+            pos = 0
             return
         end if
 
         do nn = n,1,-1
             digit = ICHAR(s(nn:nn)) - ICHAR('0')
             if( digit < 0 .or. digit > 9 ) then
-                last_non_digit = nn
+                pos = nn
             return
             end if
         end do
 
-        last_non_digit = 0    ! all characters are digits
+        pos = 0    ! all characters are digits
 
     end function last_non_digit
 
@@ -386,13 +388,13 @@ end function last_non_digit
     !   Return values:
     !       > 0  => position of last significant character
     !       = 0  => no significant characters in string
-    integer pure function get_last_significant_char(cs)
+    integer pure function get_last_significant_char(cs) result(pos)
         character(len=*), intent(in) :: cs       !  Input character string
         integer :: l, n
 
         l = LEN(cs)
         if( l == 0 ) then
-            get_last_significant_char = 0
+            pos = 0
             return
         end if
 
@@ -401,8 +403,97 @@ integer pure function get_last_significant_char(cs)
                 exit
             end if
         end do
-        get_last_significant_char = n
+        pos = n
 
     end function get_last_significant_char
 
+    !> Match `string` against a glob `pattern` in which `*` matches any run of
+    !> characters, including an empty one; every other character, including `?`,
+    !> matches only itself. Trailing blanks in both arguments are not significant
+    !> (leading and embedded blanks are). An empty pattern matches only an empty
+    !> string.
+    pure logical function core_glob_match(string, pattern) result(is_match)
+        character(len=*), intent(in) :: string
+        character(len=*), intent(in) :: pattern
+
+        integer :: ls, lp   ! significant lengths of string/pattern
+        integer :: s, p     ! current positions in string/pattern
+        integer :: star_p   ! position of the most recent '*' in pattern (0 = none seen)
+        integer :: star_s   ! string position currently tried as that star's first unmatched character
+
+        ls = len_trim(string)
+        lp = len_trim(pattern)
+
+        s = 1
+        p = 1
+        star_p = 0
+        star_s = 0
+
+        do while (s <= ls)
+            if (p <= lp) then
+                if (pattern(p:p) == '*') then
+                    ! Record the star and first try matching it to nothing
+                    star_p = p
+                    star_s = s
+                    p = p + 1
+                    cycle
+                else if (pattern(p:p) == string(s:s)) then
+                    p = p + 1
+                    s = s + 1
+                    cycle
+                end if
+            end if
+            ! Mismatch: backtrack to the most recent star and extend its match
+            ! by one character; with no star to extend, the match fails.
+            if (star_p > 0) then
+                star_s = star_s + 1
+                s = star_s
+                p = star_p + 1
+            else
+                is_match = .false.
+                return
+            end if
+        end do
+
+        ! String fully consumed; the pattern matches if only stars remain
+        do while (p <= lp)
+            if (pattern(p:p) /= '*') exit
+            p = p + 1
+        end do
+        is_match = (p > lp)
+
+    end function core_glob_match
+
+    !> Decide whether `name` is excluded by an ordered list of glob `patterns`
+    !> (see `core_glob_match`). Patterns are evaluated in order and the FIRST
+    !> pattern whose glob matches decides: a pattern with a leading `!` keeps
+    !> the name (not excluded), any other pattern excludes it. A name matching
+    !> no pattern is not excluded; blank patterns are skipped, so fixed-size
+    !> namelist arrays can be passed directly. This enables gitignore-style
+    !> lists such as ['!aero_post*', 'aero_*'], which excludes the `aero_`
+    !> names except those beginning with `aero_post`.
+    pure logical function core_glob_list_excluded(name, patterns) result(excluded)
+        character(len=*), intent(in) :: name
+        character(len=*), intent(in) :: patterns(:)
+
+        integer :: i
+
+        excluded = .false.
+        do i = 1, size(patterns)
+            if (len_trim(patterns(i)) == 0) cycle
+            if (patterns(i)(1:1) == '!') then
+                if (core_glob_match(name, patterns(i)(2:))) then
+                    ! Keep-verb: a match means the name stays compared
+                    return
+                end if
+            else
+                if (core_glob_match(name, patterns(i))) then
+                    excluded = .true.
+                    return
+                end if
+            end if
+        end do
+
+    end function core_glob_list_excluded
+
 end module string_core_utils

src/data/registry.xml

@@ -633,7 +633,7 @@
               units="kg kg-1" type="real" constituent="true">
       <long_name>Water vapor mass mixing ratio with respect to moist air plus all airborne condensates</long_name>
       <dimensions>horizontal_dimension vertical_layer_dimension</dimensions>
-      <ic_file_input_names>Q cnst_Q</ic_file_input_names>
+      <ic_file_input_names>Q cnst_Q qv</ic_file_input_names>
     </variable>
     <variable local_name="cldliq"
               standard_name="cloud_liquid_water_mixing_ratio_wrt_moist_air_and_condensed_water"