Explore replacement of CDAT modules with xarray/XCDAT

[tomvothecoder]

The CDAT modules used in the codebase include cdp, cdms2, cdtime, cdutil, genutil, and MV2. We should tackle the replacement of these CDAT modules incrementally and methodically since it is a large dependency in e3sm_diags. I will take a deeper look into how we can port over to xarray/XCDAT in a way to minimize regressions in the behavior of the code.

Using VSCode's search functionality, the list below shows where the CDAT modules are referenced. Directories excluded from the search include analysis_data_preprocess, model_data_preprocess, .mypy_cache, build, and prov.

CDAT Modules as v2.7.0.

• cdp
• cdms2
• cdtime
• cdutil
• genutil
• MV2

cdp

35 results - 20 files

conda-env/ci.yml:
  15    - cartopy_offlinedata
  16:   - cdp
  17    - cdms2

conda-env/dev.yml:
  13    - cartopy_offlinedata=0.2.4
  14:   - cdp=1.7.0
  15    - cdms2=3.1.5

docs/source/index.rst:
  55     diagnostics package through a unifying framework: `Community
  56:    Diagnostics Package (CDP) <https://github.com/CDAT/cdp>`_.
  57  -  is flexible for user-specified diagnostics and configuration for

docs/source/dev_guide/adding-new-diags-sets.rst:
  618          from .default_viewer import create_metadata
  619:         from cdp.cdp_viewer import OutputViewer
  620  

  682  
  683: We use the CDP Viewer to create the webpages.
  684  **This is not needed! Use whatever you want to create the webpages.**

docs/source/dev_guide/index.rst:
  10     adding-new-diags-sets
  11:    using-cdp-output-viewer
  12     releasing-e3sm-diags

docs/source/dev_guide/using-cdp-output-viewer.rst:
    1: How to use the CDP Output Viewer
    2  ================================

    6  - The basic framework of the `ESGF Output Viewer <https://github.com/ESGF/output_viewer>`__, consisting of indices, pages, groups, rows, and columns.
    7: - The process of using the `CDP Output Viewer <https://github.com/CDAT/cdp/blob/master/cdp/cdp_viewer.py>`__ (``cdp_viewer``), including explanations and examples related to the relevant functions.
    8  
    9:   - CDP Output Viewer is based on the ESGF Output Viewer
   10  

   86  
   87: Using CDP Output Viewer (``cdp_viewer``)
   88  ----------------------------------------

  101  
  102:     from cdp.cdp_viewer import OutputViewer
  103  

  124  
  125:     Viewer HTML generated at /Users/shaheen2/github/cdp/jupyter/index.html. Would you like to open in a browser? y/[n]: y
  126  

e3sm_diags/e3sm_diags_driver.py:
   10  
   11: import cdp.cdp_run
   12  

  310      if parameters[0].multiprocessing:
  311:         parameters = cdp.cdp_run.multiprocess(run_diag, parameters, context="fork")
  312      elif parameters[0].distributed:
  313:         parameters = cdp.cdp_run.distribute(run_diag, parameters)
  314      else:
  315:         parameters = cdp.cdp_run.serial(run_diag, parameters)
  316  

e3sm_diags/run.py:
  83              # The select() call in get_parameters() was made for the original
  84:             # command-line way of using CDP.
  85              # We just call it manually with the parameter object param.

e3sm_diags/parameter/core_parameter.py:
  2  
  3: import cdp.cdp_parameter
  4  
  5  
  6: class CoreParameter(cdp.cdp_parameter.CDPParameter):
  7      def __init__(self):

e3sm_diags/parser/core_parser.py:
  1: import cdp.cdp_parser
  2  

  5  
  6: class CoreParser(cdp.cdp_parser.CDPParser):
  7      def __init__(self, *args, **kwargs):

e3sm_diags/viewer/annual_cycle_zonal_mean_viewer.py:
  2  
  3: from cdp.cdp_viewer import OutputViewer
  4  

e3sm_diags/viewer/area_mean_time_series_viewer.py:
  2  
  3: from cdp.cdp_viewer import OutputViewer
  4  

e3sm_diags/viewer/arm_diags_viewer.py:
  2  
  3: from cdp.cdp_viewer import OutputViewer
  4  

e3sm_diags/viewer/default_viewer.py:
  12  import numpy
  13: from cdp.cdp_viewer import OutputViewer
  14  

e3sm_diags/viewer/enso_diags_viewer.py:
  3  
  4: from cdp.cdp_viewer import OutputViewer
  5  

e3sm_diags/viewer/mean_2d_viewer.py:
  2  
  3: from cdp.cdp_viewer import OutputViewer
  4  

e3sm_diags/viewer/qbo_viewer.py:
  2  
  3: from cdp.cdp_viewer import OutputViewer
  4  

e3sm_diags/viewer/streamflow_viewer.py:
  2  
  3: from cdp.cdp_viewer import OutputViewer
  4  

e3sm_diags/viewer/tc_analysis_viewer.py:
  2  
  3: from cdp.cdp_viewer import OutputViewer
  4  

tests/test.sh:
  24  #  - `python -m unittest discover -s tests/integration --pattern "test_*.py"`
  25: # Related lines of code : https://github.com/CDAT/cdp/blob/2917603097112f7db52be0bf7a2e766e14cc2e16/cdp/cdp_parser.py#L498
  26  command='python -m unittest tests/integration/'

cdms2

112 results - 27 files

conda-env/ci.yml:
  16    - cdp
  17:   - cdms2
  18    - cdtime

conda-env/dev.yml:
  14    - cdp=1.7.0
  15:   - cdms2=3.1.5
  16    - cdtime=3.1.4

e3sm_diags/__init__.py:
  6  
  7: # Disable MPI in cdms2, which is not currently supported by E3SM-unified
  8  os.environ["CDMS_NO_MPI"] = "True"

e3sm_diags/e3sm_diags_vars.py:
  11  
  12: import cdms2
  13  

  48          raise RuntimeError(msg)
  49:     with cdms2.open(path) as f:
  50          return f.variables.keys()

e3sm_diags/derivations/acme.py:
  11  if TYPE_CHECKING:
  12:     from cdms2.axis import FileAxis
  13:     from cdms2.fvariable import FileVariable
  14  

e3sm_diags/driver/aerosol_aeronet_driver.py:
  13      from e3sm_diags.parameter.core_parameter import CoreParameter
  14:     from cdms2.tvariable import TransientVariable
  15  

e3sm_diags/driver/annual_cycle_zonal_mean_driver.py:
   6  import MV2
   7: from cdms2 import createAxis
   8  

  18  if TYPE_CHECKING:
  19:     from cdms2.axis import TransientAxis
  20:     from cdms2.tvariable import TransientVariable
  21  

e3sm_diags/driver/area_mean_time_series_driver.py:
   4  
   5: import cdms2
   6  import cdutil

  60          )
  61:         with cdms2.open(mask_path) as f:
  62              land_frac = f("LANDFRAC")

e3sm_diags/driver/arm_diags_driver.py:
    4  
    5: import cdms2
    6  import numpy as np

   96                          ref_file = os.path.join(ref_path, ref_file_name)
   97:                         ref_data = cdms2.open(ref_file)
   98  

  206                      ref_file = os.path.join(ref_path, ref_file_name)
  207:                     ref_data = cdms2.open(ref_file)
  208                      if var == "CLOUD":

  313                          )
  314:                     ref_data = cdms2.open(ref_file)
  315                      vars_funcs = get_vars_funcs_for_derived_var(ref_data, var)

  389              ref_file = os.path.join(ref_path, ref_file_name)
  390:             ref_data = cdms2.open(ref_file)
  391              ref_pr = ref_data("pr")  # mm/hr

e3sm_diags/driver/cosp_histogram_driver.py:
   4  
   5: import cdms2
   6  

  68              )
  69:             with cdms2.open(mask_path) as f:
  70                  land_frac = f("LANDFRAC")

e3sm_diags/driver/diurnal_cycle_driver.py:
   4  
   5: import cdms2
   6  

  40              )
  41:             with cdms2.open(mask_path) as f:
  42                  land_frac = f("LANDFRAC")

e3sm_diags/driver/enso_diags_driver.py:
    6  
    7: import cdms2
    8  import cdutil

  232              )
  233:             with cdms2.open(mask_path) as f:
  234                  land_frac = f("LANDFRAC")

e3sm_diags/driver/lat_lon_driver.py:
    5  
    6: import cdms2
    7  

  135              )
  136:             with cdms2.open(mask_path) as f:
  137                  land_frac = f("LANDFRAC")

e3sm_diags/driver/meridional_mean_2d_driver.py:
    2  
    3: import cdms2
    4  import cdutil

   20      """
   21:     orig_bounds = cdms2.getAutoBounds()
   22:     cdms2.setAutoBounds(1)
   23      lev = ref.getLevel()

   41          lev.setBounds(None)
   42:     cdms2.setAutoBounds(orig_bounds)
   43  

  130                      # in order to use regrid tool we need to have at least two latitude bands, so generate new grid first
  131:                     lat = cdms2.createAxis([0])
  132                      lat.setBounds(numpy.array([-1, 1]))
  133                      lat.designateLatitude()
  134:                     grid = cdms2.createRectGrid(lat, lon_out)
  135  

  153                      # latitude bands, so generate new grid first.
  154:                     lat = cdms2.createAxis([0])
  155                      lat.setBounds(numpy.array([-1, 1]))
  156                      lat.designateLatitude()
  157:                     grid = cdms2.createRectGrid(lat, lon_out)
  158  

e3sm_diags/driver/polar_driver.py:
   4  
   5: import cdms2
   6  import MV2

  69              )
  70:             with cdms2.open(mask_path) as f:
  71                  land_frac = f("LANDFRAC")

  89              if ref_name == "WARREN":
  90:                 # This is cdms2 fix for bad mask, Denis' fix should fix this.
  91                  mv2 = MV2.masked_where(mv2 == -0.9, mv2)

  93              if ref_name == "AIRS":
  94:                 # This is cdms2 fix for bad mask, Denis' fix should fix this.
  95                  mv2 = MV2.masked_where(mv2 > 1e20, mv2)
  96              if ref_name == "WILLMOTT" or ref_name == "CLOUDSAT":
  97:                 # This is cdms2 fix for bad mask, Denis' fix should fix this.
  98                  mv2 = MV2.masked_where(mv2 == -999.0, mv2)

e3sm_diags/driver/streamflow_driver.py:
    5  
    6: import cdms2
    7  import cdutil

  283          logger.info("test_array.shape={}".format(test_array.shape))
  284:     if type(area_upstream) == cdms2.tvariable.TransientVariable:
  285          area_upstream = area_upstream.getValue()

  487  
  488:                 if type(monthly) == cdms2.tvariable.TransientVariable:
  489                      monthly = monthly.getValue()

  513  
  514:             if type(monthly) == cdms2.tvariable.TransientVariable:
  515                  monthly = monthly.getValue()

e3sm_diags/driver/tc_analysis_driver.py:
    7  
    8: import cdms2
    9  import numpy as np

   77      )
   78:     test_cyclones_hist = cdms2.open(test_cyclones_file)(
   79          "density", lat=(-60, 60, "ccb"), squeeze=1

   84      )
   85:     test_aew_hist = cdms2.open(test_aew_file)(
   86          "density", lat=(0, 35, "ccb"), lon=(-180, 0, "ccb"), squeeze=1

  113          )
  114:         ref_cyclones_hist = cdms2.open(ref_cyclones_file)("density", squeeze=1)
  115          ref_aew_file = os.path.join(

  118          )
  119:         ref_aew_hist = cdms2.open(ref_aew_file)("density", squeeze=1)
  120          ref_data["metrics"] = generate_tc_metrics_from_te_stitch_file(ref_te_file)

  133          )
  134:         ref_cyclones_hist = cdms2.open(ref_cyclones_file)(
  135              "density", lat=(-60, 60, "ccb"), squeeze=1

  137          ref_aew_file = os.path.join(reference_data_path, "aew_hist_ERA5_2010_2014.nc")
  138:         ref_aew_hist = cdms2.open(ref_aew_file)(
  139              "density", lat=(0, 35, "ccb"), lon=(180, 360, "ccb"), squeeze=1

  176      mask_path = os.path.join(e3sm_diags.INSTALL_PATH, "acme_ne30_ocean_land_mask.nc")
  177:     ocnfrac = cdms2.open(mask_path)("OCNFRAC", squeeze=1)
  178  

  281      vars: Dict[str, Any],
  282:     ocnfrac: cdms2.dataset.DatasetVariable,
  283      basin_info: BasinInfo,

  290      :type vars: Dict[str, Any]
  291:     :param ocnfrac: Ocnfrac CDMS2 dataset variable
  292:     :type ocnfrac: cdms2.dataset.DatasetVariable
  293      :param basin_info: Basin information

e3sm_diags/driver/zonal_mean_2d_driver.py:
    4  
    5: import cdms2
    6  import cdutil

   21      """Creates the mean, max, min, rmse, corr in a dictionary"""
   22:     orig_bounds = cdms2.getAutoBounds()
   23:     cdms2.setAutoBounds(1)
   24      lev = ref.getLevel()

   42          lev.setBounds(None)
   43:     cdms2.setAutoBounds(orig_bounds)
   44  

   95              )
   96:             with cdms2.open(mask_path) as f:
   97                  land_frac = f("LANDFRAC")

  115              if ref_name == "WARREN":
  116:                 # This is cdms2 fix for bad mask, Denis' fix should fix this.
  117                  mv2 = MV2.masked_where(mv2 == -0.9, mv2)

  119              if ref_name == "AIRS":
  120:                 # This is cdms2 fix for bad mask, Denis' fix should fix this.
  121                  mv2 = MV2.masked_where(mv2 > 1e20, mv2)
  122              if ref_name == "WILLMOTT" or ref_name == "CLOUDSAT":
  123:                 # This is cdms2 fix for bad mask, Denis' fix should fix this.
  124                  mv2 = MV2.masked_where(mv2 == -999.0, mv2)

e3sm_diags/driver/zonal_mean_xy_driver.py:
    2  
    3: import cdms2
    4  import cdutil

   38          )
   39:         mv2_reg = cdms2.createVariable(
   40              b0,

   52          )
   53:         mv1_reg = cdms2.createVariable(
   54              a0,

  126              if ref_name == "WARREN":
  127:                 # This is cdms2 fix for bad mask, Denis' fix should fix this.
  128                  mv2 = MV2.masked_where(mv2 == -0.9, mv2)

  130              if ref_name == "AIRS":
  131:                 # This is cdms2 fix for bad mask, Denis' fix should fix this.
  132                  mv2 = MV2.masked_where(mv2 > 1e20, mv2)
  133              if ref_name == "WILLMOTT" or ref_name == "CLOUDSAT":
  134:                 # This is cdms2 fix for bad mask, Denis' fix should fix this.
  135                  mv2 = MV2.masked_where(mv2 == -999.0, mv2)

e3sm_diags/driver/utils/climo.py:
   1: import cdms2
   2  import numpy as np

  79  
  80:     trans_var = cdms2.createVariable(climo)(squeeze=1)
  81      # Losing the grid after a squeeze is normal, we need to set it again.

e3sm_diags/driver/utils/dataset.py:
   10  
   11: import cdms2
   12  

  181          file_path = self._get_timeseries_file_path(primary_var, data_path)
  182:         fin = cdms2.open(file_path)
  183          result = fin(static_var)

  231  
  232:         with cdms2.open(filename) as f:
  233              return f.getglobal(attr)

  338  
  339:         with cdms2.open(filename) as data_file:
  340              for var in vars_to_get:

  352  
  353:                     # Get the variables as cdms2.TransientVariables.
  354:                     # Ex: variables is [PRECC, PRECL], where both are cdms2.TransientVariables.
  355                      variables = self._get_original_vars_climo(

  416          Given a dictionary in the form {(vars): func}, get the vars
  417:         from the data_file as cdms2.TransientVariables.
  418  

  463              if not extra_vars_only:
  464:                 # Open the files of the variables and get the cdms2.TransientVariables.
  465                  # Ex: [PRECC, PRECL], where both are TransientVariables.

  623          Given a dictionary in the form {(vars): func}, get the vars
  624:         from files in data_path as cdms2.TransientVariables.
  625  

  683          else:
  684:             # with cdms2.open(fnm) as f:
  685              #    var_time = f(var, time=(start_time, end_time, 'ccb'))(squeeze=1)

  687              # For xml files using above with statement won't work because the Dataset object returned doesn't have attribute __enter__ for content management.
  688:             fin = cdms2.open(fnm)
  689              var_time = fin(var, time=(start_time, end_time, slice_flag))(squeeze=1)

e3sm_diags/driver/utils/general.py:
    7  
    8: import cdms2
    9  import cdutil

   46      var_time[:] = 0.5 * (tbounds[:, 0] + tbounds[:, 1])
   47:     time2 = cdms2.createAxis(var_time)
   48      time2.designateTime()

  299              # Set cdms preferences - no compression, no shuffling, no complaining
  300:             cdms2.setNetcdfDeflateFlag(1)
  301              # 1-9, min to max - Comes at heavy IO (read/write time cost)
  302:             cdms2.setNetcdfDeflateLevelFlag(0)
  303:             cdms2.setNetcdfShuffleFlag(0)
  304:             cdms2.setCompressionWarnings(0)  # Turn off warning messages
  305  

  315              test_pth = os.path.join(path, file_name)
  316:             with cdms2.open(test_pth, "w+") as file_test:
  317                  try:

  330          # Set cdms preferences - no compression, no shuffling, no complaining
  331:         cdms2.setNetcdfDeflateFlag(1)
  332          # 1-9, min to max - Comes at heavy IO (read/write time cost)
  333:         cdms2.setNetcdfDeflateLevelFlag(0)
  334:         cdms2.setNetcdfShuffleFlag(0)
  335:         cdms2.setCompressionWarnings(0)  # Turn off warning messages
  336  

  348  
  349:         with cdms2.open(test_pth, cdms_arg) as file_test:
  350              file_test.write(test)

  356              ref_pth = os.path.join(pth, parameter.output_file + "_ref.nc")
  357:             with cdms2.open(ref_pth, cdms_arg) as file_ref:
  358                  file_ref.write(ref)

  364                  diff_pth = os.path.join(pth, parameter.output_file + "_diff.nc")
  365:                 with cdms2.open(diff_pth, cdms_arg) as file_diff:
  366                      file_diff.write(diff)

tests/e3sm_diags/derivations/test_acme.py:
  13  if TYPE_CHECKING:
  14:     from cdms2.axis import FileAxis
  15  

tests/e3sm_diags/drivers/test_annual_cycle_zonal_mean_driver.py:
  4  import numpy as np
  5: from cdms2.axis import TransientAxis
  6: from cdms2.tvariable import TransientVariable
  7  

tests/e3sm_diags/drivers/test_tc_analysis_driver.py:
  21  if TYPE_CHECKING:
  22:     from cdms2.dataset import DatasetVariable
  23  

tests/integration/test_dataset.py:
    2  
    3: import cdms2
    4  

   15      def test_convert_units(self):
   16:         with cdms2.open(f"{TEST_DATA_PATH}/precc.nc") as precc_file:
   17              var = precc_file("PRECC")

   91  
   92:         precc_file = cdms2.open(get_abs_file_path('integration_test_data/precc.nc'))
   93          acme_derivations.process_derived_var('PRECT', derived_var,

  105  
  106:         precc_file = cdms2.open(get_abs_file_path('integration_test_data/precc.nc'))
  107          with self.assertRaises(RuntimeError):

  125          # add derived_var_dict to default_derived_vars
  126:         precc_file = cdms2.open(get_abs_file_path('integration_test_data/precc.nc'))
  127          self.parameter.derived_variables = derived_var_dict

  155          # add derived_var_dict to default_derived_vars
  156:         precc_file = cdms2.open(get_abs_file_path('integration_test_data/precc.nc'))
  157          self.parameter.derived_variables = derived_var_dict

  177  
  178:         precc_file = cdms2.open(get_abs_file_path('integration_test_data/precc.nc'))
  179          self.parameter.derived_variables = derived_var_dict

  187      def test_mask_by(self):
  188:         with cdms2.open(get_abs_file_path('integration_test_data/precc.nc')) as precc_file:
  189              prcc = precc_file('PRECC')
  190:         with cdms2.open(get_abs_file_path('integration_test_data/precl.nc')) as precl_file:
  191              prcl = precl_file('PRECL')

tests/testing_data/create_test_data.py:
    7  
    8: import cdms2
    9  

  128      orig_path = os.path.join(TEMP_DIR, file_name)
  129:     with cdms2.open(orig_path) as orig_file:
  130          if os.path.exists(f_and_v.local_uri):

  132  
  133:         with cdms2.open(f_and_v.local_uri, "w") as new_file:
  134              # Copy over the attributes.

  136  
  137:             # Lat, lon, and time are considered dimensions in cdms2.
  138              # Those are automatically saved.

cdtime

• Related to Remove cdtime as a library dependency #615

3 results - 3 files

conda-env/ci.yml:
  17    - cdms2
  18:   - cdtime
  19    - cdutil

conda-env/dev.yml:
  15    - cdms2=3.1.5
  16:   - cdtime=3.1.4
  17    - cdutil=8.2.1

e3sm_diags/driver/utils/general.py:
  52      time2.setBounds(tbounds)
  53:     # time2.calendar = cdtime.NoLeapCalendar
  54      time2.id = "time"

cdutil

113 results - 19 files

conda-env/ci.yml:
  18    - cdtime
  19:   - cdutil
  20    - genutil

conda-env/dev.yml:
  16    - cdtime=3.1.4
  17:   - cdutil=8.2.1
  18    - genutil=8.2.1

e3sm_diags/derivations/default_regions.py:
    1: import cdutil
    2  
    3  regions_specs = {
    4:     "NHEX": {"domain": cdutil.region.domain(latitude=(30.0, 90, "ccb"))},
    5:     "SHEX": {"domain": cdutil.region.domain(latitude=(-90.0, -30, "ccb"))},
    6:     "TROPICS": {"domain": cdutil.region.domain(latitude=(-30.0, 30, "ccb"))},
    7      "global": {},
    8:     "TRMM_region": {"domain": cdutil.region.domain(latitude=(-38.0, 38, "ccb"))},
    9:     "90S50S": {"domain": cdutil.region.domain(latitude=(-90.0, -50, "ccb"))},
   10:     "50S20S": {"domain": cdutil.region.domain(latitude=(-50.0, -20, "ccb"))},
   11:     "20S20N": {"domain": cdutil.region.domain(latitude=(-20.0, 20, "ccb"))},
   12:     "50S50N": {"domain": cdutil.region.domain(latitude=(-50.0, 50, "ccb"))},
   13:     "5S5N": {"domain": cdutil.region.domain(latitude=(-5.0, 5, "ccb"))},
   14:     "20N50N": {"domain": cdutil.region.domain(latitude=(20.0, 50, "ccb"))},
   15:     "50N90N": {"domain": cdutil.region.domain(latitude=(50.0, 90, "ccb"))},
   16:     "60S90N": {"domain": cdutil.region.domain(latitude=(-60.0, 90, "ccb"))},
   17:     "60S60N": {"domain": cdutil.region.domain(latitude=(-60.0, 60, "ccb"))},
   18:     "75S75N": {"domain": cdutil.region.domain(latitude=(-75.0, 75, "ccb"))},
   19      "ocean": {

   29          "value": 0.65,
   30:         "domain": cdutil.region.domain(latitude=(-60.0, 90, "ccb")),
   31      },

   33          "value": 0.65,
   34:         "domain": cdutil.region.domain(latitude=(-30.0, 30, "ccb")),
   35      },

   37          "value": 0.65,
   38:         "domain": cdutil.region.domain(latitude=(30.0, 90, "ccb")),
   39      },

   41          "value": 0.65,
   42:         "domain": cdutil.region.domain(latitude=(-90.0, -30, "ccb")),
   43      },

   45          "value": 0.65,
   46:         "domain": cdutil.region.domain(latitude=(-30.0, 30, "ccb")),
   47      },

   49          "value": 0.65,
   50:         "domain": cdutil.region.domain(latitude=(30.0, 90, "ccb")),
   51      },

   53          "value": 0.65,
   54:         "domain": cdutil.region.domain(latitude=(-90.0, -30, "ccb")),
   55      },
   56      # follow AMWG polar range,more precise selector
   57:     "polar_N": {"domain": cdutil.region.domain(latitude=(50.0, 90.0, "ccb"))},
   58:     "polar_S": {"domain": cdutil.region.domain(latitude=(-90.0, -55.0, "ccb"))},
   59      # To match AMWG results, the bounds is not as precise in this case

   63      "NAM": {
   64:         "domain": cdutil.region.domain(
   65              latitude=(20.0, 90, "ccb"), longitude=(-180, 180, "ccb")

   68      "NAO": {
   69:         "domain": cdutil.region.domain(
   70              latitude=(20.0, 80, "ccb"), longitude=(-90, 40, "ccb")

   73      "SAM": {
   74:         "domain": cdutil.region.domain(
   75              latitude=(-20.0, -90, "ccb"), longitude=(0, 360, "ccb")

   78      "PNA": {
   79:         "domain": cdutil.region.domain(
   80              latitude=(20.0, 85, "ccb"), longitude=(120, 240, "ccb")

   83      "PDO": {
   84:         "domain": cdutil.region.domain(
   85              latitude=(20.0, 70, "ccb"), longitude=(110, 260, "ccb")

   90      "AllM": {
   91:         "domain": cdutil.region.domain(
   92              latitude=(-45.0, 45.0, "ccb"), longitude=(0.0, 360.0, "ccb")

   96      "NAMM": {
   97:         "domain": cdutil.region.domain(
   98              latitude=(0.0, 45.0, "ccb"), longitude=(210.0, 310.0, "ccb")

  102      "SAMM": {
  103:         "domain": cdutil.region.domain(
  104              latitude=(-45.0, 0.0, "ccb"), longitude=(240.0, 330.0, "ccb")

  108      "NAFM": {
  109:         "domain": cdutil.region.domain(
  110              latitude=(0.0, 45.0, "ccb"), longitude=(310.0, 60.0, "ccb")

  114      "SAFM": {
  115:         "domain": cdutil.region.domain(
  116              latitude=(-45.0, 0.0, "ccb"), longitude=(0.0, 90.0, "ccb")

  120      "ASM": {
  121:         "domain": cdutil.region.domain(
  122              latitude=(0.0, 45.0, "ccb"), longitude=(60.0, 180.0, "ccb")

  126      "AUSM": {
  127:         "domain": cdutil.region.domain(
  128              latitude=(-45.0, 0.0, "ccb"), longitude=(90.0, 160.0, "ccb")

  132      "NINO3": {
  133:         "domain": cdutil.region.domain(
  134              latitude=(-5.0, 5.0, "ccb"), longitude=(210.0, 270.0, "ccb")

  137      "NINO34": {
  138:         "domain": cdutil.region.domain(
  139              latitude=(-5.0, 5.0, "ccb"), longitude=(190.0, 240.0, "ccb")

  142      "NINO4": {
  143:         "domain": cdutil.region.domain(
  144              latitude=(-5.0, 5.0, "ccb"), longitude=(160.0, 210.0, "ccb")

  148      "W_Pacific": {
  149:         "domain": cdutil.region.domain(
  150              latitude=(-20.0, 20.0, "ccb"), longitude=(90.0, 180.0, "ccb")

  153      "CONUS": {
  154:         "domain": cdutil.region.domain(
  155              latitude=(25.0, 50.0, "ccb"), longitude=(-125.0, -65.0, "ccb")

  158      "Amazon": {
  159:         "domain": cdutil.region.domain(
  160              latitude=(-20.0, 5.0, "ccb"), longitude=(-80.0, -45.0, "ccb")

  163      # Below is for RRM(regionally refined model) domains.
  164:     # 'CONUS_RRM': {'domain': cdutil.region.domain(latitude=(20., 50., 'ccb'), longitude=(-125., -65., 'ccb'))},For RRM dataset, negative value won't work
  165      "CONUS_RRM": {
  166:         "domain": cdutil.region.domain(
  167              latitude=(20.0, 50.0, "ccb"), longitude=(235.0, 295.0, "ccb")

  170      # Below is for debugging. A smaller latitude range reduces processing time.
  171:     "DEBUG": {"domain": cdutil.region.domain(latitude=(-2.0, 2, "ccb"))},
  172  }

e3sm_diags/driver/annual_cycle_zonal_mean_driver.py:
   4  
   5: import cdutil
   6  import MV2

  52  
  53:         test_ac_zonal_mean = cdutil.averager(test_ac, axis="x", weights="generate")
  54:         test_ac_reg_zonal_mean = cdutil.averager(
  55              test_ac_reg, axis="x", weights="generate"

  70              else:
  71:                 ref_ac_zonal_mean = cdutil.averager(
  72                      ref_ac, axis="x", weights="generate"
  73                  )
  74:                 ref_ac_reg_zonal_mean = cdutil.averager(
  75                      ref_ac_reg, axis="x", weights="generate"

  78          else:
  79:             ref_ac_zonal_mean = cdutil.averager(ref_ac, axis="x", weights="generate")
  80:             ref_ac_reg_zonal_mean = cdutil.averager(
  81                  ref_ac_reg, axis="x", weights="generate"

  90          # else:
  91:         #    ref_ac_zonal_mean = cdutil.averager(ref_ac, axis="x", weights="generate")
  92:         #    ref_ac_reg_zonal_mean = cdutil.averager(
  93          #        ref_ac_reg, axis="x", weights="generate"

e3sm_diags/driver/area_mean_time_series_driver.py:
    5  import cdms2
    6: import cdutil
    7  

   87              # over months to get the yearly mean.
   88:             test_domain = cdutil.averager(test_domain, axis="xy")
   89:             cdutil.setTimeBoundsMonthly(test_domain)
   90:             test_domain_year = cdutil.YEAR(test_domain)
   91:             # add back attributes since they got lost after applying cdutil.YEAR
   92              test_domain_year.long_name = test.long_name

  113  
  114:                     ref_domain = cdutil.averager(ref_domain, axis="xy")
  115:                     cdutil.setTimeBoundsMonthly(ref_domain)
  116                      logger.info(

  123  
  124:                     ref_domain_year = cdutil.YEAR(ref_domain)
  125                      ref_domain_year.ref_name = ref_name

e3sm_diags/driver/enso_diags_driver.py:
    7  import cdms2
    8: import cdutil
    9  import numpy

   90          # Domain average
   91:         sst_avg = cdutil.averager(sst_nino, axis="xy")
   92          # Get anomaly from annual cycle climatology
   93:         sst_avg_anomaly = cdutil.ANNUALCYCLE.departures(sst_avg)
   94          nino_index = sst_avg_anomaly

  121      # over months to get the yearly mean.
  122:     cdutil.setTimeBoundsMonthly(domain)
  123      # Get anomaly from annual cycle climatology

  125          logger.info("domain.shape: {}".format(domain.shape))
  126:     anomaly = cdutil.ANNUALCYCLE.departures(domain)
  127      nlat = len(anomaly.getLatitude())

  129      reg_coe = anomaly[0, :, :](squeeze=1)
  130:     confidence_levels = cdutil.ANNUALCYCLE.departures(domain)[0, :, :](squeeze=1)
  131      # Neither of the following methods work, so we just set values in confidence_levels

  414              # Domain average
  415:             test_avg = cdutil.averager(test_data_ts_regional, axis="xy")
  416:             ref_avg = cdutil.averager(ref_data_ts_regional, axis="xy")
  417              # Get anomaly from annual cycle climatology
  418:             y["test"] = cdutil.ANNUALCYCLE.departures(test_avg)
  419:             y["ref"] = cdutil.ANNUALCYCLE.departures(ref_avg)
  420              y["units"] = test_avg.units

e3sm_diags/driver/meridional_mean_2d_driver.py:
    3  import cdms2
    4: import cdutil
    5  import MV2

  115  
  116:                 mv1_p = cdutil.averager(mv1_p, axis="y")
  117:                 mv2_p = cdutil.averager(mv2_p, axis="y")
  118  

e3sm_diags/driver/qbo_driver.py:
   5  
   6: import cdutil
   7  import numpy as np

  35      # Average over longitude (i.e., each latitude's average in data_region)
  36:     data_lon_average = cdutil.averager(data_region, axis="x")
  37      # Average over latitude (i.e., average for entire data_region)
  38:     data_lon_lat_average = cdutil.averager(data_lon_average, axis="y")
  39      # Get data by vertical level

  95      # Average over lat and lon
  96:     data_lat_lon_average = cdutil.averager(data_region, axis="xy")
  97      # Average over vertical

e3sm_diags/driver/streamflow_driver.py:
    6  import cdms2
    7: import cdutil
    8  import numpy

  222          ref_data_ts = ref_data.get_timeseries_variable(var)
  223:         var_array = ref_data_ts(cdutil.region.domain(latitude=(-90.0, 90, "ccb")))
  224          if parameter.print_statements:

  265          test_data_ts = test_data.get_timeseries_variable(var)
  266:         var_array = test_data_ts(cdutil.region.domain(latitude=(-90.0, 90, "ccb")))
  267          if parameter.print_statements:

e3sm_diags/driver/zonal_mean_2d_driver.py:
    5  import cdms2
    6: import cdutil
    7  import MV2

  183                  diff_p = mv1_p_reg - mv2_p_reg
  184:                 diff = cdutil.averager(diff_p, axis="x")
  185  
  186:                 mv1_p = cdutil.averager(mv1_p, axis="x")
  187:                 mv2_p = cdutil.averager(mv2_p, axis="x")
  188  

  192  
  193:                 mv1_reg = cdutil.averager(mv1_p_reg, axis="x")
  194:                 mv2_reg = cdutil.averager(mv2_p_reg, axis="x")
  195  

e3sm_diags/driver/zonal_mean_xy_driver.py:
    3  import cdms2
    4: import cdutil
    5  import MV2

  177                          logger.info(f"Selected region: {region}")
  178:                         mv1_zonal = cdutil.averager(mv1, axis="x")
  179:                         mv2_zonal = cdutil.averager(mv2, axis="x")
  180  

  227                      logger.info(f"Selected region: {region}")
  228:                     mv1_zonal = cdutil.averager(mv1, axis="x")
  229:                     mv2_zonal = cdutil.averager(mv2, axis="x")
  230  

e3sm_diags/driver/utils/general.py:
    8  import cdms2
    9: import cdutil
   10  import genutil

   55      var.setAxis(0, time2)
   56:     #    cdutil.setTimeBoundsMonthly(var)
   57  

  137      ps = ps / 100.0  # convert unit from 'Pa' to mb
  138:     levels_orig = cdutil.vertical.reconstructPressureFromHybrid(ps, hyam, hybm, p0)
  139      levels_orig.units = "mb"

  143          levels_orig = levels_orig(lev=slice(-1, None, -1))
  144:     var_p = cdutil.vertical.logLinearInterpolation(
  145          var(squeeze=1), levels_orig(squeeze=1), plev

  168          levels_orig = levels_orig(lev=slice(-1, None, -1))
  169:     var_p = cdutil.vertical.logLinearInterpolation(
  170          var(squeeze=1), levels_orig(squeeze=1), plev

e3sm_diags/metrics/__init__.py:
   1: import cdutil
   2  import genutil

  26  def mean(variable, axis="xy"):
  27:     return cdutil.averager(variable, axis=axis, weights="generate")
  28  

e3sm_diags/plot/cartopy/diurnal_cycle_plot.py:
    6  import cartopy.feature as cfeature
    7: import cdutil
    8  import matplotlib

  110          # Assume global domain
  111:         domain = cdutil.region.domain(latitude=(-90.0, 90, "ccb"))
  112      kargs = domain.components()[0].kargs

e3sm_diags/plot/cartopy/enso_diags_plot.py:
   5  import cartopy.crs as ccrs
   6: import cdutil
   7  import matplotlib

  87          # Assume global domain
  88:         domain = cdutil.region.domain(latitude=(-90.0, 90, "ccb"))
  89      kargs = domain.components()[0].kargs

e3sm_diags/plot/cartopy/lat_lon_plot.py:
   6  import cartopy.feature as cfeature
   7: import cdutil
   8  import matplotlib

  91          # Assume global domain
  92:         domain = cdutil.region.domain(latitude=(-90.0, 90, "ccb"))
  93      kargs = domain.components()[0].kargs

e3sm_diags/plot/cartopy/meridional_mean_2d_plot.py:
  50      #    var_max = float(var.max())
  51:     #    var_mean = cdutil.averager(var, axis='xy', weights='generate')
  52      var = add_cyclic(var)

e3sm_diags/plot/cartopy/streamflow_plot.py:
    6  import cartopy.feature as cfeature
    7: import cdutil
    8  import matplotlib

   80          # Assume global domain
   81:         domain = cdutil.region.domain(latitude=(-90.0, 90, "ccb"))
   82      kargs = domain.components()[0].kargs

  379          # Assume global domain
  380:         domain = cdutil.region.domain(latitude=(-90.0, 90, "ccb"))
  381      kargs = domain.components()[0].kargs

e3sm_diags/plot/cartopy/zonal_mean_2d_plot.py:
  51      #    var_max = float(var.max())
  52:     #    var_mean = cdutil.averager(var, axis='xy', weights='generate')
  53      #    var = add_cyclic(var)

genutil

11 results - 6 files

conda-env/ci.yml:
  19    - cdutil
  20:   - genutil
  21    - lxml

conda-env/dev.yml:
  17    - cdutil=8.2.1
  18:   - genutil=8.2.1
  19    - lxml=4.8.0

e3sm_diags/derivations/acme.py:
  8  import numpy as np
  9: from genutil import udunits
  10  

e3sm_diags/driver/enso_diags_driver.py:
  140              independent_var = nino_index
  141:             # Uncomment the following line to use CDAT/genutil instead
  142              # (You'll also need to set pvalue)
  143:             # slope, intercept = genutil.statistics.linearregression(dependent_var, x=independent_var)
  144              slope, _, _, pvalue, _ = scipy.stats.linregress(

e3sm_diags/driver/utils/general.py:
    9  import cdutil
   10: import genutil
   11  import MV2

  159      # grow 1d levels_orig to mv dimention
  160:     var, levels_orig = genutil.grower(var, levels_orig)
  161      # levels_orig.info()

e3sm_diags/metrics/__init__.py:
   1  import cdutil
   2: import genutil
   3  import numpy

  13          corr = float(
  14:             genutil.statistics.correlation(model, obs, axis=axis, weights="generate")
  15          )

  36      try:
  37:         rmse = float(genutil.statistics.rms(model, obs, axis=axis, weights="generate"))
  38      except Exception as err:

  45      try:
  46:         std = float(genutil.statistics.std(variable, axis=axis, weights="generate"))
  47      except Exception as err:

MV2

121 results - 10 files

e3sm_diags/derivations/acme.py:
    6  
    7: import MV2
    8  import numpy as np

  444  
  445:     cld_bin_sum = MV2.sum(MV2.sum(cld_bin, axis=1), axis=0)
  446  

e3sm_diags/driver/annual_cycle_zonal_mean_driver.py:
    5  import cdutil
    6: import MV2
    7  from cdms2 import createAxis

  146          if month == "01":
  147:             var_ann_cycle: "TransientVariable" = MV2.zeros([12] + list(var.shape))
  148              var_ann_cycle.id = var.id

e3sm_diags/driver/cosp_histogram_driver.py:
  77              mv1 = test_data.get_climo_variable(var, season)
  78:             mv2 = ref_data.get_climo_variable(var, season)
  79  

  92                  mv2_domain = utils.general.select_region(
  93:                     region, mv2, land_frac, ocean_frac, parameter
  94                  )

e3sm_diags/driver/lat_lon_driver.py:
  146              try:
  147:                 mv2 = ref_data.get_climo_variable(var, season)
  148              except (RuntimeError, IOError):
  149:                 mv2 = mv1
  150                  logger.info("Can not process reference data, analyse test data only")

  160              # For variables with a z-axis.
  161:             if mv1.getLevel() and mv2.getLevel():
  162                  plev = parameter.plevs

  168                  mv2_p = utils.general.convert_to_pressure_levels(
  169:                     mv2, plev, ref_data, var, season
  170                  )

  176                      ]
  177:                     mv2 = mv2_p[
  178                          ilev,

  187                          mv2_domain = utils.general.select_region(
  188:                             region, mv2, land_frac, ocean_frac, parameter
  189                          )

  216              # For variables without a z-axis.
  217:             elif mv1.getLevel() is None and mv2.getLevel() is None:
  218                  for region in regions:

  225                      mv2_domain = utils.general.select_region(
  226:                         region, mv2, land_frac, ocean_frac, parameter
  227                      )

e3sm_diags/driver/meridional_mean_2d_driver.py:
    4  import cdutil
    5: import MV2
    6  import numpy

   90              mv1 = test_data.get_climo_variable(var, season)
   91:             mv2 = ref_data.get_climo_variable(var, season)
   92  

   99              # For variables with a z-axis.
  100:             if mv1.getLevel() and mv2.getLevel():
  101                  # Since the default is now stored in MeridionalMean2dParameter,

  112                  mv2_p = utils.general.convert_to_pressure_levels(
  113:                     mv2, plevs, ref_data, var, season
  114                  )

  137                      data_shape.append(1)
  138:                     mv2_reg = MV2.resize(mv2_p, data_shape)
  139                      mv2_reg.setAxis(-1, lat)

  145                      # doesn't preserve the mask.
  146:                     mv2_reg = MV2.masked_where(mv2_reg == mv2_reg.fill_value, mv2_reg)
  147                  elif len(mv1_p.getLongitude()) > len(mv2_p.getLongitude()):

  160                      data_shape.append(1)
  161:                     mv1_reg = MV2.resize(mv1_p, data_shape)
  162                      mv1_reg.setAxis(-1, lat)

  168                      # doesn't preserve the mask.
  169:                     mv1_reg = MV2.masked_where(mv1_reg == mv1_reg.fill_value, mv1_reg)
  170                  else:

  191              # For variables without a z-axis.
  192:             elif mv1.getLevel() is None and mv2.getLevel() is None:
  193                  raise RuntimeError(

e3sm_diags/driver/polar_driver.py:
    5  import cdms2
    6: import MV2
    7  

   78              mv1 = test_data.get_climo_variable(var, season)
   79:             mv2 = ref_data.get_climo_variable(var, season)
   80  

   90                  # This is cdms2 fix for bad mask, Denis' fix should fix this.
   91:                 mv2 = MV2.masked_where(mv2 == -0.9, mv2)
   92              # The following should be moved to a derived variable.

   94                  # This is cdms2 fix for bad mask, Denis' fix should fix this.
   95:                 mv2 = MV2.masked_where(mv2 > 1e20, mv2)
   96              if ref_name == "WILLMOTT" or ref_name == "CLOUDSAT":
   97                  # This is cdms2 fix for bad mask, Denis' fix should fix this.
   98:                 mv2 = MV2.masked_where(mv2 == -999.0, mv2)
   99  

  112                      # unit convert from mm/day to cm.
  113:                     mv2 = (
  114:                         mv2 / days_season[season] / 0.1
  115                      )  # Convert cm to mm/day instead.
  116:                     mv2.units = "mm/day"
  117  
  118              # For variables with a z-axis.
  119:             if mv1.getLevel() and mv2.getLevel():
  120                  plev = parameter.plevs

  126                  mv2_p = utils.general.convert_to_pressure_levels(
  127:                     mv2, plev, ref_data, var, season
  128                  )

  134                      ]
  135:                     mv2 = mv2_p[
  136                          ilev,

  145                          mv2_domain = utils.general.select_region(
  146:                             region, mv2, land_frac, ocean_frac, parameter
  147                          )

  202              # For variables without a z-axis.
  203:             elif mv1.getLevel() is None and mv2.getLevel() is None:
  204                  for region in regions:

  210                      mv2_domain = utils.general.select_region(
  211:                         region, mv2, land_frac, ocean_frac, parameter
  212                      )

  228                          if ref_name == "WILLMOTT":
  229:                             mv2_reg = MV2.masked_where(
  230                                  mv2_reg == mv2_reg.fill_value, mv2_reg

  232  
  233:                         land_mask = MV2.logical_or(mv1_reg.mask, mv2_reg.mask)
  234:                         mv1_reg = MV2.masked_where(land_mask, mv1_reg)
  235:                         mv2_reg = MV2.masked_where(land_mask, mv2_reg)
  236  

e3sm_diags/driver/zonal_mean_2d_driver.py:
    6  import cdutil
    7: import MV2
    8  import numpy

  104              mv1 = test_data.get_climo_variable(var, season)
  105:             mv2 = ref_data.get_climo_variable(var, season)
  106  

  116                  # This is cdms2 fix for bad mask, Denis' fix should fix this.
  117:                 mv2 = MV2.masked_where(mv2 == -0.9, mv2)
  118              # The following should be moved to a derived variable.

  120                  # This is cdms2 fix for bad mask, Denis' fix should fix this.
  121:                 mv2 = MV2.masked_where(mv2 > 1e20, mv2)
  122              if ref_name == "WILLMOTT" or ref_name == "CLOUDSAT":
  123                  # This is cdms2 fix for bad mask, Denis' fix should fix this.
  124:                 mv2 = MV2.masked_where(mv2 == -999.0, mv2)
  125  

  138                      # unit convert from mm/day to cm.
  139:                     mv2 = (
  140:                         mv2 / days_season[season] / 0.1
  141                      )  # Convert cm to mm/day instead.
  142:                     mv2.units = "mm/day"
  143  
  144              # For variables with a z-axis.
  145:             if mv1.getLevel() and mv2.getLevel():
  146                  # Since the default is now stored in `default_plevs`,

  158                  mv2_p = utils.general.convert_to_pressure_levels(
  159:                     mv2, plevs, ref_data, var, season
  160                  )

  219              # For variables without a z-axis.
  220:             elif mv1.getLevel() is None and mv2.getLevel() is None:
  221                  for region in regions:

  227                      mv2_domain = utils.general.select_region(
  228:                         region, mv2, land_frac, ocean_frac, parameter
  229                      )

  245                          if ref_name == "WILLMOTT":
  246:                             mv2_reg = MV2.masked_where(
  247                                  mv2_reg == mv2_reg.fill_value, mv2_reg
  248                              )
  249:                         land_mask = MV2.logical_or(mv1_reg.mask, mv2_reg.mask)
  250:                         mv1_reg = MV2.masked_where(land_mask, mv1_reg)
  251:                         mv2_reg = MV2.masked_where(land_mask, mv2_reg)
  252  

e3sm_diags/driver/zonal_mean_xy_driver.py:
    4  import cdutil
    5: import MV2
    6  import numpy

   15  
   16: def regrid_to_lower_res_1d(mv1, mv2):
   17      """Regrid 1-D transient variable toward lower resolution of two variables."""
   18  
   19:     if mv1 is None or mv2 is None:
   20          return None

   23      axis1 = mv1.getAxisList()[0]
   24:     axis2 = mv2.getAxisList()[0]
   25      if axis1[-1] < axis1[0]:

   27      if axis2[-1] < axis2[0]:
   28:         mv2 = mv2[::-1]
   29      axis1 = mv1.getAxisList()[0]
   30:     axis2 = mv2.getAxisList()[0]
   31  
   32      if len(axis1) <= len(axis2):
   33:         missing = mv2.get_fill_value()
   34          mv1_reg = mv1
   35:         b0 = numpy.interp(axis1[:], axis2[:], mv2[:], left=missing, right=missing)
   36          b0_mask = numpy.interp(
   37:             axis1[:], axis2[:], mv2.mask[:], left=missing, right=missing
   38          )

   60          )
   61:         mv2_reg = mv2
   62  

  115              mv1 = test_data.get_climo_variable(var, season)
  116:             mv2 = ref_data.get_climo_variable(var, season)
  117  

  127                  # This is cdms2 fix for bad mask, Denis' fix should fix this.
  128:                 mv2 = MV2.masked_where(mv2 == -0.9, mv2)
  129              # The following should be moved to a derived variable.

  131                  # This is cdms2 fix for bad mask, Denis' fix should fix this.
  132:                 mv2 = MV2.masked_where(mv2 > 1e20, mv2)
  133              if ref_name == "WILLMOTT" or ref_name == "CLOUDSAT":
  134                  # This is cdms2 fix for bad mask, Denis' fix should fix this.
  135:                 mv2 = MV2.masked_where(mv2 == -999.0, mv2)
  136  

  149                      # unit convert from mm/day to cm.
  150:                     mv2 = (
  151:                         mv2 / days_season[season] / 0.1
  152                      )  # Convert cm to mm/day instead.
  153:                     mv2.units = "mm/day"
  154  
  155              # For variables with a z-axis.
  156:             if mv1.getLevel() and mv2.getLevel():
  157                  plev = parameter.plevs

  163                  mv2_p = utils.general.convert_to_pressure_levels(
  164:                     mv2, plev, test_data, var, season
  165                  )

  171                      ]
  172:                     mv2 = mv2_p[
  173                          ilev,

  178                          mv1_zonal = cdutil.averager(mv1, axis="x")
  179:                         mv2_zonal = cdutil.averager(mv2, axis="x")
  180  

  224              # For variables without a z-axis.
  225:             elif mv1.getLevel() is None and mv2.getLevel() is None:
  226                  for region in regions:

  228                      mv1_zonal = cdutil.averager(mv1, axis="x")
  229:                     mv2_zonal = cdutil.averager(mv2, axis="x")
  230  

e3sm_diags/driver/utils/diurnal_cycle.py:
    1: import MV2
    2  import numpy

  143          # Save phase, amplitude, and mean for the first homonic,
  144:         amplitude = MV2.zeros((nlat, nlon))
  145          amplitude[:, :] = maxvalue[0]

  151  
  152:         maxtime = MV2.zeros((nlat, nlon))
  153          maxtime[:, :] = tmax[0]

  159  
  160:         cmean = MV2.zeros((nlat, nlon))
  161          cmean[:, :] = cycmean

e3sm_diags/driver/utils/general.py:
   10  import genutil
   11: import MV2
   12  

  156          var_plv[:] = var_plv[:] / 100.0  # convert Pa to mb
  157:     levels_orig = MV2.array(var_plv[:])
  158      levels_orig.setAxis(0, var_plv)

  241  
  242: def regrid_to_lower_res(mv1, mv2, regrid_tool, regrid_method):
  243      """Regrid transient variable toward lower resolution of two variables."""

  245      axes1 = mv1.getAxisList()
  246:     axes2 = mv2.getAxisList()
  247  

  252          mv1_reg = mv1
  253:         mv2_reg = mv2.regrid(
  254              mv_grid, regridTool=regrid_tool, regridMethod=regrid_method
  255          )
  256:         mv2_reg.units = mv2.units
  257  
  258      else:
  259:         mv_grid = mv2.getGrid()
  260:         mv2_reg = mv2
  261          mv1_reg = mv1.regrid(

[chengzhuzhang]

Thank you for getting this process started! Starting this exploration early will also inform xcdat development.

[tomvothecoder]

Updated the dependencies search for v2.7.0.

[tomvothecoder]

Here is the related project board for this continuous and iterative effort: https://github.com/E3SM-Project/e3sm_diags/projects/6

[tomvothecoder]

Resuming this as of today