Check intent(out) and intent(inout) variables during physics_check_data (#413)

Tag name (required for release branches):
Originator(s): peverwhee

Description (include the issue title, and the keyword ['closes',
'fixes', 'resolves'] followed by the issue number):

Updates so that:
1. Variable set in `physics_read_data` is only intent(in) and
intent(inout) variables (no changes, this is the prior behavior)
2. Variable set in `physics_check_data` is only intent(inout) and
intent(out) variables (new behavior)
- Also changed the logic in `physics_check_data` to not rely on
is_read_from_file (because that's set during read_data which is not
necessarily done for these variables!) and to not error when a variable
cannot be read from file.
 
closes #411 

Describe any changes made to build system: n/a

Describe any changes made to the namelist: n/a

List any changes to the defaults for the input datasets (e.g. boundary
datasets): n/a

List all files eliminated and why: n/a

List all files added and what they do: n/a

List all existing files that have been modified, and describe the
changes:
(Helpful git command: `git diff --name-status
development...<your_branch_name>`)

M    src/data/write_init_files.py
- mods to grab two lists of variables - intent(in)/intent(inout) and
intent(inout)/intent(out)
- don't error if variable has weird dimensions/cannot be read from file
- still check all constituents

M    test/unit/python/sample_files/write_init_files/simple_reg.xml
M    test/unit/python/sample_files/write_init_files/temp_adjust.F90
- add new output-only variable to make sure the code is generated to
check it

M
test/unit/python/sample_files/write_init_files/phys_vars_init_check_*.F90
M    test/unit/python/sample_files/write_init_files/physics_inputs_*.F90
- update expected files to account for new check_data logic in generated
code

If there are new failures (compared to the
`test/existing-test-failures.txt` file),
have them OK'd by the gatekeeper, note them here, and add them to the
file.
If there are baseline differences, include the test and the reason for
the
diff. What is the nature of the change? Roundoff?

derecho/intel/aux_sima: all PASS

derecho/gnu/aux_sima: all PASS

If this changes climate describe any run(s) done to evaluate the new
climate in enough detail that it(they) could be reproduced:

CAM-SIMA date used for the baseline comparison tests if different than
latest:

Author: peverwhee

src/data/write_init_files.py

@@ -33,6 +33,7 @@
                           'number_of_mpi_tasks'}
 # Variable input types
 _INPUT_TYPES = set(['in', 'inout'])
+_OUTPUT_TYPES = set(['out', 'inout'])
 
 # Include files to insert in the module preamble
 _PHYS_VARS_PREAMBLE_INCS = ["cam_var_init_marks_decl.inc"]
@@ -131,7 +132,7 @@ def write_init_files(cap_database, ic_names, registry_constituents, vars_init_va
 
     # Gather all the host model variables that are required by
     #    any of the compiled CCPP physics suites.
-    host_vars, constituent_set, retmsg = gather_ccpp_req_vars(cap_database, registry_constituents)
+    in_vars, out_vars, constituent_set, retmsg = gather_ccpp_req_vars(cap_database, registry_constituents)
 
     # Quit now if there are missing variables
     if retmsg:
@@ -173,13 +174,17 @@ def write_init_files(cap_database, ic_names, registry_constituents, vars_init_va
             outfile.include(filepath)
         # end for
 
+        all_req_vars = in_vars + out_vars
+        # Remove duplicates but preserve order for testing
+        unique_req_vars = list(OrderedDict.fromkeys(all_req_vars))
+
         # Write public parameters:
-        retvals = write_ic_params(outfile, host_vars, ic_names, registry_constituents)
+        retvals = write_ic_params(outfile, unique_req_vars, ic_names, registry_constituents)
         ic_names, ic_max_len, stdname_max_len = retvals
 
         # Write initial condition arrays:
         write_ic_arrays(outfile, ic_names, ic_max_len,
-                        stdname_max_len, host_vars, registry_constituents)
+                        stdname_max_len, unique_req_vars, registry_constituents)
 
         # Add "contains" statement:
         outfile.end_module_header()
@@ -234,18 +239,19 @@ def write_init_files(cap_database, ic_names, registry_constituents, vars_init_va
         # Grab the host dictionary from the database
         host_dict = cap_database.host_model_dict()
 
-        # Collect imported host variables
-        host_imports = collect_host_var_imports(host_vars, host_dict, constituent_set)
-
+        # Collect imported host variables for physics read
+        host_imports = collect_host_var_imports(in_vars, host_dict, constituent_set)
         # Write physics_read_data subroutine:
-        write_phys_read_subroutine(outfile, host_dict, host_vars, host_imports,
+        write_phys_read_subroutine(outfile, host_dict, in_vars, host_imports,
                                    phys_check_fname_str, constituent_set,
                                    vars_init_value)
 
         outfile.blank_line()
 
+        # Collect imported host variables for physics check
+        host_imports = collect_host_var_imports(out_vars, host_dict, constituent_set)
         # Write physics_check_data subroutine:
-        write_phys_check_subroutine(outfile, host_dict, host_vars, host_imports,
+        write_phys_check_subroutine(outfile, host_dict, out_vars, host_imports,
                                     phys_check_fname_str, constituent_set)
 
     # --------------------------------------
@@ -315,7 +321,8 @@ def gather_ccpp_req_vars(cap_database, registry_constituents):
 
     # Dictionary of all 'in' and 'inout' suite variables.
     # Key is standard name, value is host-model or constituent variable
-    req_vars = {}
+    in_vars = {}
+    out_vars = {}
     missing_vars = set()
     constituent_vars = set()
     retmsg = ""
@@ -330,22 +337,31 @@ def gather_ccpp_req_vars(cap_database, registry_constituents):
             intent = cvar.get_prop_value('intent')
             is_const = cvar.get_prop_value('advected') or cvar.get_prop_value('constituent')
             if ((intent in _INPUT_TYPES) and
-                (stdname not in req_vars) and
+                (stdname not in in_vars) and
                 (stdname not in _EXCLUDED_STDNAMES)):
                 if is_const:
                     #Add variable to constituent set:
                     constituent_vars.add(stdname)
                     #Add variable to required variable list if it's not a registry constituent
                     if stdname not in registry_constituents:
-                        req_vars[stdname] = cvar
+                        in_vars[stdname] = cvar
                     # end if
                 else:
                     # We need to work with the host model version of this variable
                     missing = _find_and_add_host_variable(stdname, host_dict,
-                                                          req_vars)
+                                                          in_vars)
                     missing_vars.update(missing)
                 # end if
-            # end if (do not include output variables)
+            # end if (only input variables)
+            if ((intent in _OUTPUT_TYPES) and
+                  (stdname not in out_vars) and
+                  (stdname not in _EXCLUDED_STDNAMES)):
+                if not is_const:
+                    missing = _find_and_add_host_variable(stdname, host_dict,
+                                                          out_vars)
+                    # do nothing with missing variables
+                # end if
+            # end if (only output variables)
         # end for (loop over call list)
     # end for (loop over phases)
 
@@ -354,7 +370,7 @@ def gather_ccpp_req_vars(cap_database, registry_constituents):
         retmsg = f"Error: Missing required host variables: {mvlist}"
     # end if
     # Return the required variables as a list
-    return list(req_vars.values()), constituent_vars, retmsg
+    return list(in_vars.values()), list(out_vars.values()), constituent_vars, retmsg
 
 ##########################
 #FORTRAN WRITING FUNCTIONS
@@ -1178,8 +1194,6 @@ def write_phys_read_subroutine(outfile, host_dict, host_vars, host_imports,
     outfile.write("end do", 2)
     outfile.blank_line()
 
-    # start default case steps:
-
     # End subroutine:
     outfile.write("end subroutine physics_read_data", 1)
 
@@ -1240,8 +1254,8 @@ def write_phys_check_subroutine(outfile, host_dict, host_vars, host_imports,
             call_str += f"timestep, {var_locname}, '{var_stdname}', "
             call_str += "min_difference, min_relative_value, is_first, diff_found)"
         else:
-            call_str = f"call endrun('Cannot check status of {var_locname}'" + \
-                f"//', {reason}')"
+            # For check field, don't endrun
+            call_str = f"! do nothing - '{var_locname}' can't be checked against a file because {reason}"
         # end if
         # Add string to dictionary:
         call_string_dict[call_string_key] = call_str
@@ -1376,7 +1390,7 @@ def write_phys_check_subroutine(outfile, host_dict, host_vars, host_imports,
                     "that they can be read from input file if need be:", 3)
     outfile.write("call ccpp_physics_suite_variables(suite_names" +           \
                   "(suite_idx), ccpp_required_data, errmsg, errflg, " +       \
-                  "input_vars=.true., output_vars=.false.)", 4)
+                  "input_vars=.false., output_vars=.true.)", 4)
     outfile.blank_line()
 
     # Loop over required variables:
@@ -1385,37 +1399,48 @@ def write_phys_check_subroutine(outfile, host_dict, host_vars, host_imports,
     outfile.write("do req_idx = 1, size(ccpp_required_data, 1)", 3)
     outfile.blank_line()
 
-    # First check if the required variable is a constituent
-    outfile.comment("First check if the required variable is a constituent:", 4)
-    outfile.write("call const_get_index(ccpp_required_data(req_idx), constituent_idx, abort=.false., warning=.false.)", 4)
-    outfile.write("if (constituent_idx > -1) then", 4)
-    outfile.write("cycle", 5)
-    outfile.write("else", 4)
-    outfile.comment("The required variable is not a constituent. Check if the variable was read from a file", 5)
-
     # Call input name search function:
-    outfile.comment("Find IC file input name array index for required variable:", 5)
-    outfile.write("call is_read_from_file(ccpp_required_data(req_idx), " +    \
-                  "is_read, stdnam_idx_out=name_idx)", 5)
-    outfile.write("if (.not. is_read) then", 5)
-    outfile.write("cycle", 6)
-    outfile.write("end if", 5)
+    outfile.comment("Find IC file input name array index for required variable:", 4)
+    outfile.write("name_idx = find_input_name_idx(ccpp_required_data(req_idx), .true., constituent_idx)", 4)
+
+    # Start select-case statement:
+    outfile.blank_line()
+    outfile.comment("Check for special index values:", 4)
+    outfile.write("select case (name_idx)", 4)
+    outfile.blank_line()
+
+    # Skip constituent variables:
+    outfile.write("case (const_idx)", 5)
+    outfile.blank_line()
+    outfile.comment("If variable is a constituent, then do nothing. We'll handle these later", 6)
+    outfile.blank_line()
+
+    # Generate error message if required variable isn't found:
+    outfile.write("case (no_exist_idx)", 5)
+    outfile.blank_line()
+    outfile.comment("If the index for an output variable was not found, then do nothing. We won't try to check these.", 6)
+    outfile.blank_line()
+
+    # start default case steps:
+    outfile.write("case default", 5)
+    outfile.blank_line()
 
     # Generate "check_field" calls:
-    outfile.comment("Check variable vs input check file:", 5)
+    outfile.comment("Check variable vs input check file:", 6)
     outfile.blank_line()
-    outfile.write("select case (trim(phys_var_stdnames(name_idx)))", 5)
+    outfile.write("select case (trim(phys_var_stdnames(name_idx)))", 6)
     for case_call, read_call in call_string_dict.items():
-        outfile.write(case_call, 5)
-        outfile.write(read_call, 6)
+        outfile.write(case_call, 6)
+        outfile.write(read_call, 7)
         outfile.blank_line()
-    outfile.write("end select !check variables", 5)
-    outfile.write("if (diff_found) then", 5)
-    outfile.write("overall_diff_found = .true.", 6)
-    outfile.write("end if", 5)
-    outfile.write("end if !check if constituent", 4)
+    outfile.write("end select !check variables", 6)
+    outfile.write("if (diff_found) then", 6)
+    outfile.write("overall_diff_found = .true.", 7)
+    outfile.write("end if", 6)
 
     # End select case and required variables loop:
+    outfile.write("end select !special indices", 4)
+    outfile.blank_line()
     outfile.write("end do !Suite-required variables", 3)
     outfile.blank_line()
 

test/unit/python/sample_files/write_init_files/phys_vars_init_check_simple.F90

@@ -33,19 +33,21 @@ module phys_vars_init_check_simple
    integer, public, parameter ::          PARAM = 2
    integer, public, parameter :: READ_FROM_FILE = 3
    ! Total number of physics-related variables:
-   integer, public, parameter :: phys_var_num = 2
+   integer, public, parameter :: phys_var_num = 4
    integer, public, parameter :: phys_const_num = 16
 
    !Max length of physics-related variable standard names:
    integer, public, parameter :: std_name_len = 25
 
    ! Max length of input (IC) file variable names:
-   integer, public, parameter :: ic_name_len = 5
+   integer, public, parameter :: ic_name_len = 9
 
    ! Physics-related input variable standard names:
    character(len=25), public, protected :: phys_var_stdnames(phys_var_num) = (/ &
       'potential_temperature    ', &
-      'air_pressure_at_sea_level' /)
+      'air_pressure_at_sea_level', &
+      'tendency_of_peverwhee    ', &
+      'scalar_variable_llama    ' /)
 
    character(len=36), public, protected :: phys_const_stdnames(phys_const_num) = (/ &
       "ccpp_constituent_minimum_values     ", &
@@ -65,17 +67,23 @@ module phys_vars_init_check_simple
       "suite_name                          ", &
       "suite_part                          " /)
    !Array storing all registered IC file input names for each variable:
-   character(len=5), public, protected :: input_var_names(1, phys_var_num) = reshape((/ &
-      'theta', &
-      'slp  ' /), (/1, phys_var_num/))
+   character(len=9), public, protected :: input_var_names(1, phys_var_num) = reshape((/ &
+      'theta    ', &
+      'slp      ', &
+      'ptend    ', &
+      'var_nodim' /), (/1, phys_var_num/))
 
    ! Array indicating whether or not variable is protected:
    logical, public, protected :: protected_vars(phys_var_num)= (/ &
+      .false., &
+      .false., &
       .false., &
       .false. /)
 
    ! Variable state (UNINITIALIZED, INTIIALIZED, PARAM or READ_FROM_FILE):
    integer, public, protected :: initialized_vars(phys_var_num)= (/ &
+      UNINITIALIZED, &
+      UNINITIALIZED, &
       UNINITIALIZED, &
       UNINITIALIZED /)
 

test/unit/python/sample_files/write_init_files/physics_inputs_4D.F90

@@ -235,7 +235,7 @@ subroutine physics_check_data(file_name, suite_names, timestep, min_difference,
       use cam_pio_utils,             only: cam_pio_openfile, cam_pio_closefile
       use ccpp_constituent_prop_mod, only: ccpp_constituent_prop_ptr_t
       use phys_vars_init_check_4D,   only: phys_var_num, phys_var_stdnames, input_var_names, std_name_len
-      use physics_types_4D,          only: slp, theta
+      use physics_types_4D,          only: theta
 
       ! Dummy arguments
       character(len=SHR_KIND_CL), intent(in) :: file_name
@@ -304,37 +304,40 @@ subroutine physics_check_data(file_name, suite_names, timestep, min_difference,
       do suite_idx = 1, size(suite_names, 1)
 
          ! Search for all needed CCPP input variables, so that they can be read from input file if need be:
-            call ccpp_physics_suite_variables(suite_names(suite_idx), ccpp_required_data, errmsg, errflg, input_vars=.true., output_vars=.false.)
+            call ccpp_physics_suite_variables(suite_names(suite_idx), ccpp_required_data, errmsg, errflg, input_vars=.false., output_vars=.true.)
 
          ! Loop over all required variables as specified by CCPP suite:
          do req_idx = 1, size(ccpp_required_data, 1)
 
-            ! First check if the required variable is a constituent:
-            call const_get_index(ccpp_required_data(req_idx), constituent_idx, abort=.false., warning=.false.)
-            if (constituent_idx > -1) then
-               cycle
-            else
-               ! The required variable is not a constituent. Check if the variable was read from a file
-               ! Find IC file input name array index for required variable:
-               call is_read_from_file(ccpp_required_data(req_idx), is_read, stdnam_idx_out=name_idx)
-               if (.not. is_read) then
-                  cycle
-               end if
-               ! Check variable vs input check file:
+            ! Find IC file input name array index for required variable:
+            name_idx = find_input_name_idx(ccpp_required_data(req_idx), .true., constituent_idx)
 
-               select case (trim(phys_var_stdnames(name_idx)))
-               case ('potential_temperature')
-                  call check_field(file, input_var_names(:,name_idx), 'lev', timestep, theta, 'potential_temperature', min_difference,                 &
-                       min_relative_value, is_first, diff_found)
+            ! Check for special index values:
+            select case (name_idx)
 
-               case ('air_pressure_at_sea_level')
-                  call endrun('Cannot check status of slp'//', slp has unsupported dimension, timestep_for_physics.')
+               case (const_idx)
+
+                  ! If variable is a constituent, then do nothing. We'll handle these later
+
+               case (no_exist_idx)
+
+                  ! If the index for an output variable was not found, then do nothing. We won't try to check these.
+
+               case default
+
+                  ! Check variable vs input check file:
+
+                  select case (trim(phys_var_stdnames(name_idx)))
+                  case ('potential_temperature')
+                     call check_field(file, input_var_names(:,name_idx), 'lev', timestep, theta, 'potential_temperature', min_difference,              &
+                          min_relative_value, is_first, diff_found)
+
+                  end select !check variables
+                  if (diff_found) then
+                     overall_diff_found = .true.
+                  end if
+            end select !special indices
 
-               end select !check variables
-               if (diff_found) then
-                  overall_diff_found = .true.
-               end if
-            end if !check if constituent
          end do !Suite-required variables
 
          ! Deallocate required variables array for use in next suite: