From 70b2948b2c88ddf011c6ace9e4f22d2ad440a354 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:16:42 -0600 Subject: [PATCH 001/126] Create config_clm_baseline_example.yaml --- config_clm_baseline_example.yaml | 507 +++++++++++++++++++++++++++++++ 1 file changed, 507 insertions(+) create mode 100644 config_clm_baseline_example.yaml diff --git a/config_clm_baseline_example.yaml b/config_clm_baseline_example.yaml new file mode 100644 index 000000000..15ec91fe8 --- /dev/null +++ b/config_clm_baseline_example.yaml @@ -0,0 +1,507 @@ +#============================== +#config_clm_baseline_example.yaml + +#This is the main CAM/CLM diagnostics config file +#for doing comparisons of a CAM or CLM run against +#another run, or baseline simulation. + +#Currently, if one is on NCAR's Casper or +#Cheyenne machine, then only the diagnostic output +#paths are needed, at least to perform a quick test +#run (these are indicated with "MUST EDIT" comments). +#Running these diagnostics on a different machine, +#or with a different, non-example simulation, will +#require additional modifications. +# +#Config file Keywords: +#-------------------- +# +#1. Using ${xxx} will substitute that text with the +# variable referenced by xxx. For example: +# +# cam_case_name: cool_run +# cam_climo_loc: /some/where/${cam_case_name} +# +# will set "cam_climo_loc" in the diagnostics package to: +# /some/where/cool_run +# +# Please note that currently this will only work if the +# variable only exists in one location in the file. +# +#2. Using ${.xxx} will do the same as +# keyword 1 above, but specifies which sub-section the +# variable is coming from, which is necessary for variables +# that are repeated in different subsections. For example: +# +# diag_basic_info: +# cam_climo_loc: /some/where/${diag_cam_climo.start_year} +# +# diag_cam_climo: +# start_year: 1850 +# +# will set "cam_climo_loc" in the diagnostics package to: +# /some/where/1850 +# +#Finally, please note that for both 1 and 2 the keywords must be lowercase. +#This is because future developments will hopefully use other keywords +#that are uppercase. Also please avoid using periods (".") in variable +#names, as this will likely cause issues with the current file parsing +#system. +#-------------------- +# +##============================== +# +# This file doesn't (yet) read environment variables, so the user must +# set this themselves. It is also a good idea to search the doc for 'user' +# to see what default paths are being set for output/working files. +# +# Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script +# to check for a failure to customize +# +user: 'wwieder' + + +#This first set of variables specify basic info used by all diagnostic runs: +diag_basic_info: + + #Is this a model vs observations comparison? + #If "false" or missing, then a model-model comparison is assumed: + compare_obs: false + + #Generate HTML website (assumed false if missing): + #Note: The website files themselves will be located in the path + #specified by "cam_diag_plot_loc", under the "/website" subdirectory, + #where "" is the subdirectory created for this particular diagnostics run + #(usually "case_vs_obs_XXX" or "case_vs_baseline_XXX"). + create_html: true + + #Location of observational datasets: + #Note: this only matters if "compare_obs" is true and the path + #isn't specified in the variable defaults file. + obs_data_loc: /glade/campaign/cgd/amp/amwg/ADF_obs + + #Location where CAM climatology files are stored: + cam_climo_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/climo + + #Location where re-gridded and interpolated CAM climatology files are stored: + cam_climo_regrid_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/climo/regrid + + #Location where re-gridded and interpolated timeseries files are stored: + cam_ts_regrid_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/ts/regrid + + + #Overwrite CAM re-gridded files? + #If false, or missing, then regridding will be skipped for regridded variables + #that already exist in "cam_climo_regrid_loc" or "cam_ts_regrid_loc": + cam_overwrite_climo_regrid: false + cam_overwrite_ts_regrid: false + + #Location where diagnostic plots are stored: + cam_diag_plot_loc: /glade/derecho/scratch/${user}/ADF/plots + + #Location of ADF variable plotting defaults YAML file: + #If left blank or missing, ADF/lib/adf_variable_defaults.yaml will be used + #Uncomment and change path for custom variable defaults file + #TODO, make a land default path + defaults_file: /glade/u/home/wwieder/python/adf/lib/ldf_variable_defaults.yaml + + #Vertical pressure levels (in hPa) on which to plot 3-D variables + #when using horizontal (e.g. lat/lon) map projections. + #If this config option is missing, then no 3-D variables will be plotted on + #horizontal maps. Please note too that pressure levels must currently match + #what is available in the observations file in order to be plotted in a + #model vs obs run: + plot_press_levels: [200,850] + + #Longitude line on which to center all lat/lon maps. + #If this config option is missing then the central + #longitude will default to 180 degrees E. + central_longitude: 0 + + #Number of processors on which to run the ADF. + #If this config variable isn't present then + #the ADF defaults to one processor. Also, if + #you set it to "*" then it will default + #to all of the processors available on a + #single node/machine: + num_procs: 8 + + #If set to true, then redo all plots even if they already exist. + #If set to false, then if a plot is found it will be skipped: + redo_plot: false + # TODO, seems to redo plots anyway "NOTE: redo_plot is set to False" plotting continues... + +#This second set of variables provides info for the CAM simulation(s) being diagnosed: +diag_cam_climo: + + # History file list of strings to match + # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] + # Only affects timeseries as everything else uses the created timeseries + # Default: + hist_str: clm2.h0 + + #Name of CAM case (or CAM run name): + cam_case_name: b.e30_beta05.BLT1850.ne30_t232_wgx3.123 + + #Case nickname + #NOTE: if nickname starts with '0' - nickname must be in quotes! + # ie '026a' as opposed to 026a + #If missing or left blank, will default to cam_case_name + case_nickname: '123' + + #Location of CAM history (h0) files: + #Example test files + cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_climo.cam_case_name}/lnd/hist + + # SE to FV regridding options + # Leave these blank if not on the native grid + #----------------------------- + # Weights file: + weights_file: /glade/work/wwieder/map_ne30pg3_to_fv0.9x1.25_scripgrids_conserve_nomask_c250108.nc + # Regridding method: + regrid_method: 'coservative' #xesmf bug, missing 'n'! + # File with appropriate lat/lon values for regridding native to FV : + latlon_file: /glade/derecho/scratch/wwieder/ctsm5.3.018_SP_f09_t232_mask/run/ctsm5.3.018_SP_f09_t232_mask.clm2.h0.0001-01.nc + + #Calculate climatologies? + #If false, the climatology files will not be created: + calc_cam_climo: true + + #Overwrite CAM climatology files? + #If false, or not prsent, then already existing climatology files will be skipped: + cam_overwrite_climo: false + + #Location of CAM climatologies (to be created and then used by this script) + cam_climo_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/climo + + # TODO, should we be able to define ts_start_year and climo_start_year independently + #model year when time series files should start: + #Note: Leaving this entry blank will make time series + # start at earliest available year. + start_year: 25 + + #model year when time series files should end: + #Note: Leaving this entry blank will make time series + # end at latest available year. + end_year: 44 + + #Do time series files exist? + #If True, then diagnostics assumes that model files are already time series. + #If False, or if simply not present, then diagnostics will attempt to create + #time series files from history (time-slice) files: + cam_ts_done: false + + #Save interim time series files? + #WARNING: This can take up a significant amount of space, + # but will save processing time the next time + cam_ts_save: true + + #Overwrite time series files, if found? + #If set to false, then time series creation will be skipped if files are found: + cam_overwrite_ts: false + + #Location where time series files are (or will be) stored: + cam_ts_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/ts + + + #---------------------- + + #You can alternatively provide a list of cases, which will make the ADF + #apply the same diagnostics to each case separately in a single ADF session. + #All of the config variables below show how it is done, and are the only ones + #that need to be lists. This also automatically enables the generation of + #a "main_website" in "cam_diag_plot_loc" that brings all of the different cases + #together under a single website. + + #Also please note that config keywords cannot currently be used in list mode. + + #cam_case_name: + # - b.e23_alpha17f.BLT1850.ne30_t232.098 + # - b.e23_alpha17f.BLT1850.ne30_t232.095 + + #Case nickname + #NOTE: if nickname starts with '0' - nickname must be in quotes! + # ie '026a' as opposed to 026a + #If missing or left blank, will default to cam_case_name + #case_nickname: + # - cool nickname + # - cool nickname 2 + + #calc_cam_climo: + # - true + # - true + + #cam_overwrite_climo: + # - false + # - false + + #cam_hist_loc: + # - /glade/campaign/cgd/amp/amwg/ADF_test_cases/b.e23_alpha17f.BLT1850.ne30_t232.098 + # - /glade/campaign/cgd/amp/amwg/ADF_test_cases/b.e23_alpha17f.BLT1850.ne30_t232.095 + + #cam_climo_loc: + # - /some/where/you/want/to/have/climo_files/ #MUST EDIT! + # - /the/same/or/some/other/climo/files/location + + #start_year: + # - 10 + # - 10 + + #end_year: + # - 14 + # - 14 + + #cam_ts_done: + # - false + # - false + + #cam_ts_save: + # - true + # - true + + #cam_overwrite_ts: + # - false + # - false + + #cam_ts_loc: + # - /some/where/you/want/to/have/time_series_files + # - /same/or/different/place/you/want/files + + #---------------------- + + +#This third set of variables provide info for the CAM baseline climatologies. +#This only matters if "compare_obs" is false: +diag_cam_baseline_climo: + + # History file list of strings to match + # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] + # Only affects timeseries as everything else uses the created timeseries + # Default: + hist_str: clm2.h0 + + #Name of CAM baseline case: + cam_case_name: b.e30_beta05.BLT1850.ne30_t232_wgx3.122 + + #Baseline case nickname + #NOTE: if nickname starts with '0' - nickname must be in quotes! + # ie '026a' as opposed to 026a + #If missing or left blank, will default to cam_case_name + case_nickname: '122' + + #Location of CAM baseline history (h0) files: + #Example test files + cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist + + # SE to FV regridding options + # Leave these blank if not on the native grid + #----------------------------- + # Weights file: + weights_file: /glade/work/wwieder/map_ne30pg3_to_fv0.9x1.25_scripgrids_conserve_nomask_c250108.nc + # Regridding method: + regrid_method: 'coservative' #xesmf bug, missing 'n'! + # File with appropriate lat/lon values for regridding native to FV : + latlon_file: /glade/derecho/scratch/wwieder/ctsm5.3.018_SP_f09_t232_mask/run/ctsm5.3.018_SP_f09_t232_mask.clm2.h0.0001-01.nc + + #Calculate cam baseline climatologies? + #If false, the climatology files will not be created: + calc_cam_climo: true + + #Overwrite CAM climatology files? + #If false, or not present, then already existing climatology files will be skipped: + cam_overwrite_climo: false + + #Location of baseline CAM climatologies: + cam_climo_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_baseline_climo.cam_case_name}/climo + + #model year when time series files should start: + #Note: Leaving this entry blank will make time series + # start at earliest available year. + start_year: 25 + + #model year when time series files should end: + #Note: Leaving this entry blank will make time series + # end at latest available year. + end_year: 44 + + #Do time series files need to be generated? + #If True, then diagnostics assumes that model files are already time series. + #If False, or if simply not present, then diagnostics will attempt to create + #time series files from history (time-slice) files: + cam_ts_done: false + + #Save interim time series files for baseline run? + #WARNING: This can take up a significant amount of space: + cam_ts_save: true + + #Overwrite baseline time series files, if found? + #If set to false, then time series creation will be skipped if files are found: + cam_overwrite_ts: false + + #Location where time series files are (or will be) stored: + cam_ts_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_baseline_climo.cam_case_name}/ts + + +#This fourth set of variables provides settings for calling the Climate Variability +# Diagnostics Package (CVDP). If cvdp_run is set to true the CVDP will be set up and +# run in background mode, likely completing after the ADF has completed. +# If CVDP is to be run PSL, TREFHT, TS and PRECT (or PRECC and PRECL) should be listed +# in the diag_var_list variable listing. +# For more CVDP information: https://www.cesm.ucar.edu/working_groups/CVC/cvdp/ +diag_cvdp_info: + + # Run the CVDP on the listed run(s)? + cvdp_run: false + + # CVDP code path, sets the location of the CVDP codebase + # CGD systems path = /home/asphilli/CESM-diagnostics/CVDP/Release/v5.2.0/ + # CISL systems path = /glade/u/home/asphilli/CESM-diagnostics/CVDP/Release/v5.2.0/ + # github location = https://github.com/NCAR/CVDP-ncl + cvdp_codebase_loc: /glade/u/home/asphilli/CESM-diagnostics/CVDP/Release/v5.2.0/ + + # Location where cvdp codebase will be copied to and diagnostic plots will be stored + cvdp_loc: /glade/derecho/scratch/${user}/ADF/cvdp/ + + # tar up CVDP results? + cvdp_tar: false + +# This set of variables provides settings for calling NOAA's +# Model Diagnostic Task Force (MDTF) diagnostic package. +# https://github.com/NOAA-GFDL/MDTF-diagnostics +# +# If mdtf_run: true, the MDTF will be set up and +# run in background mode, likely completing after the ADF has completed. +# +# WARNING: This currently only runs on CASPER (not derecho) +# +# The variables required depend on the diagnostics (PODs) selected. +# AMWG-developed PODS and their required variables: +# (Note that PRECT can be computed from PRECC & PRECL) +# - MJO_suite: daily PRECT, FLUT, U850, U200, V200 (all required) +# - Wheeler-Kiladis Wavenumber Frequency Spectra: daily PRECT, FLUT, U200, U850, OMEGA500 +# (will use what is available) +# - Blocking (Rich Neale): daily OMEGA500 +# - Precip Diurnal Cycle (Rich Neale): 3-hrly PRECT +# +# Many other diagnostics are available; see +# https://mdtf-diagnostics.readthedocs.io/en/main/sphinx/start_overview.html + +# +diag_mdtf_info: + # Run the MDTF on the model cases + mdtf_run: false + + # The file that will be written by ADF to input to MDTF. Call this whatever you want. + mdtf_input_settings_filename : mdtf_input.json + + ## MDTF code path, sets the location of the MDTF codebase and pre-compiled conda envs + # CHANGE if you have any: your own MDTF code, installed conda envs and/or obs_data + + mdtf_codebase_path : /glade/campaign/cgd/amp/amwg/mdtf + mdtf_codebase_loc : ${mdtf_codebase_path}/MDTF-diagnostics.v3.1.20230817.ADF + conda_root : /glade/u/apps/opt/conda + conda_env_root : ${mdtf_codebase_path}/miniconda2/envs.MDTFv3.1.20230412/ + OBS_DATA_ROOT : ${mdtf_codebase_path}/obs_data + + # SET this to a writable dir. The ADF will place ts files here for the MDTF to read (adds the casename) + MODEL_DATA_ROOT : ${diag_cam_climo.cam_ts_loc}/mdtf/inputdata/model + + # Choose diagnostics (PODs). Full list of available PODs: https://github.com/NOAA-GFDL/MDTF-diagnostics + pod_list : [ "MJO_suite" ] + + # Intermediate/output file settings + make_variab_tar: false # tar up MDTF results + save_ps : false # save postscript figures in addition to bitmaps + save_nc : false # save netCDF files of processed data (recommend true when starting with new model data) + overwrite: true # overwrite results in OUTPUT_DIR; otherwise results will be saved under a unique name + + # Settings used in debugging: + verbose : 3 # Log verbosity level. + test_mode: false # Set to true for framework test. Data is fetched but PODs are not run. + dry_run : false # Framework test. No external commands are run and no remote data is copied. Implies test_mode. + + # Settings that shouldn't change in ADF implementation for now + data_type : single_run # single_run or multi_run (only works with single right now) + data_manager : Local_File # Fetch data or it is local? + environment_manager : Conda # Manage dependencies + + + +#+++++++++++++++++++++++++++++++++++++++++++++++++++ +#These variables below only matter if you are using +#a non-standard method, or are adding your own +#diagnostic scripts. +#+++++++++++++++++++++++++++++++++++++++++++++++++++ + +#Note: If you want to pass arguments to a particular script, you can +#do it like so (using the "averaging_example" script in this case): +# - {create_climo_files: {kwargs: {clobber: true}}} + +#Name of time-averaging scripts being used to generate climatologies. +#These scripts must be located in "scripts/averaging": +time_averaging_scripts: + - create_climo_files + +#Name of regridding scripts being used. +#These scripts must be located in "scripts/regridding": +regridding_scripts: + - regrid_and_vert_interp + +#List of analysis scripts being used. +#These scripts must be located in "scripts/analysis": +analysis_scripts: + - lmwg_table + +#List of plotting scripts being used. +#These scripts must be located in "scripts/plotting": +plotting_scripts: + - global_latlon_map + #- global_mean_timeseries + #- global_latlon_vect_map + #- zonal_mean + #- meridional_mean + - polar_map + #- cam_taylor_diagram + #- regional_map_multicase #To use this please un-comment and fill-out + #the "region_multicase" section below + +#List of CAM variables that will be processesd: +#If CVDP is to be run PSL, TREFHT, TS and PRECT (or PRECC and PRECL) should be listed +#TODO, round this out with more variables for alpha land diags +diag_var_list: + - TSA + - PREC + - ELAI + - GPP +# - NPP +# - FSDS +# - ALTMAX + - ET + - TOTRUNOFF + - DSTFLXT + - MEG_isoprene +# +# MDTF recommended variables +# - FLUT +# - OMEGA500 +# - PRECT +# - PS +# - PSL +# - U200 +# - U850 +# - V200 +# - V850 + +# Options for multi-case regional contour plots (./plotting/regional_map_multicase.py) +# region_multicase: +# region_spec: [slat, nlat, wlon, elon] +# region_time_option: # If calendar, will look for specified years. If zeroanchor will use a nyears starting from year_offset from the beginning of timeseries +# region_start_year: +# region_end_year: +# region_nyear: +# region_year_offset: +# region_month: +# region_season: +# region_variables: + +#END OF FILE From 4912f5a24990efea84ed00eeeb24accf4862dc7b Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:19:08 -0600 Subject: [PATCH 002/126] Create ldf_variable_defaults.yaml --- ldf_variable_defaults.yaml | 342 +++++++++++++++++++++++++++++++++++++ 1 file changed, 342 insertions(+) create mode 100644 ldf_variable_defaults.yaml diff --git a/ldf_variable_defaults.yaml b/ldf_variable_defaults.yaml new file mode 100644 index 000000000..2b7e04641 --- /dev/null +++ b/ldf_variable_defaults.yaml @@ -0,0 +1,342 @@ + +#This file lists out variable-specific defaults +#for plotting and observations. These defaults +#are: +# +# PLOTTING: +# +# colormap -> The colormap that will be used for filled contour plots. +# contour_levels -> A list of the specific contour values that will be used for contour plots. +# Cannot be used with "contour_levels_range". +# contour_levels_range -> The contour range that will be used for plots. +# Values are min, max, and stride. Cannot be used with "contour_levels". +# diff_colormap -> The colormap that will be used for filled contour different plots +# diff_contour_levels -> A list of the specific contour values thta will be used for difference plots. +# Cannot be used with "diff_contour_range". +# diff_contour_range -> The contour range that will be used for difference plots. +# Values are min, max, and stride. Cannot be used with "diff_contour_levels". +# scale_factor -> Amount to scale the variable (relative to its "raw" model values). +# add_offset -> Amount of offset to add to the variable (relatie to its "raw" model values). +# new_unit -> Variable units (if not using the "raw" model units). +# mpl -> Dictionary that contains keyword arguments explicitly for matplotlib +# +# mask -> Setting that specifies whether the variable should be masked. +# Currently only accepts "landmask", which means the variable will be masked +# everywhere that isn't land. +# +# +# OBSERVATIONS: +# +# obs_file -> Path to observations file. If only the file name is given, then the file is assumed to +# exist in the path specified by "obs_data_loc" in the config file. +# obs_name -> Name of the observational dataset (mostly used for plotting and generated file naming). +# If this isn't present then the obs_file name is used. +# obs_var_name -> Variable in the observations file to compare against. If this isn't present then the +# variable name is assumed to be the same as the model variable name. +# +# +# +# WEBSITE: +# +# category -> The website category the variable will be placed under. +# +# +# DERIVING: +# +# derivable_from -> If not present in the available output files, the variable can be derived from +# other variables that are present (e.g. PRECT can be derived from PRECC and PRECL), +# which are specified in this list +# NOTE: this is not very flexible at the moment! It can only handle variables that +# are sums of the constituents. Futher flexibility is being explored. +# +# +# Final Note: Please do not modify this file unless you plan to push your changes back to the ADF repo. +# If you would like to modify this file for your personal ADF runs then it is recommended +# to make a copy of this file, make modifications in that copy, and then point the ADF to +# it using the "defaults_file" config variable. +# +#+++++++++++ + +#+++++++++++++ +# Available Land Default Plot Types +#+++++++++++++ +default_ptypes: ["Tables","LatLon","TimeSeries", + "Arctic","RegionalClimo","RegionalTimeSeries","Special"] + +#+++++++++++++ +# Constants +#+++++++++++++ + +#seconds per day : +spd: 86400 +diff_levs: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + +#+++++++++++++ +# Category: Atmosphere +#+++++++++++++ + +TSA: # 2m air temperature + category: "Atmosphere" + colormap: "coolwarm" + contour_levels_range: [250, 310, 10] + +PREC: # RAIN + SNOW + category: "Atmosphere" + colormap: "managua" + derivable_from: ["RAIN","SNOW"] + scale_factor: 86400 + add_offset: 0 + new_unit: "mm d$^{-1}$" + mpl: + colorbar: + label : "mm d$^{-1}$" + diff_colormap: "BrBG" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + +FLDS: # atmospheric longwave radiation + category: "Atmosphere" + colormap: "Oranges" + contour_levels_range: [100, 500, 25] + diff_colormap: "BrBG" + diff_contour_range: [-20, 20, 2] + scale_factor: 1 + add_offset: 0 + new_unit: "Wm$^{-2}$" + mpl: + colorbar: + label : "Wm$^{-2}$" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + +FSDS: # atmospheric incident solar radiation + category: "Atmosphere" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + +WIND: # atmospheric air temperature + category: "Atmosphere" + +QBOT: # atmospheric specific humidity + category: "Atmosphere" + +TBOT: + category: "Atmosphere" + colormap: "coolwarm" + contour_levels_range: [250, 310, 10] + +TREFMNAV: # daily minimum of average 2m temperature + category: "Atmosphere" + colormap: "coolwarm" + contour_levels_range: [250, 310, 10] + + +TREFMXAV: # daily maximum of average 2m temperature + category: "Atmosphere" + colormap: "cool warm" + contour_levels_range: [250, 310, 10] + + +#+++++++++++ +# Category: Surface fluxes +#+++++++++++ + +ASA: # all-sky albedo:FSR/FSDS + category: "Surface fluxes" + colormap: "RdBu_r" + diff_colormap: "BrBG" + derivable_from: ["FSR", "FSDS"] + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + +FSA: # absorbed solar radiation + category: "Surface fluxes" + +FSH: # sensible heat + category: "Surface fluxes" + + +ET: # latent heat: FCTR+FCEV+FGEV + category: "Surface fluxes" + derivable_from: ["FCTR","FCEV","FGEV"] + colormap: "Blues" + contour_levels_range: [0, 220, 10] + diff_colormap: "BrBG" + diff_contour_range: [-45, 45, 5] + scale_factor: 1 + add_offset: 0 + new_unit: "Wm$^{-2}$" + mpl: + colorbar: + label : "Wm$^{-2}$" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + +DSTFLXT: # total surface dust emission + category: "Surface fluxes" + colormap: "Browns" + diff_colormap: "BrBG_r" + scale_factor: 86400 + add_offset: 0 + new_unit: "kg m$^{-2}$ d$^{-1}" + mpl: + colorbar: + label : "kg m$^{-2}$ d$^{-1}" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + scale_factor_table: 0.000365 #days to years, kg/m2 to Pg globally + avg_method: 'sum' + table_unit: "Pg y$^{-1}" + +MEG_isoprene: # total surface dust emission + category: "Surface fluxes" + colormap: "Browns" + diff_colormap: "BrBG_r" + scale_factor: 86400 + add_offset: 0 + new_unit: "kg m$^{-2}$ d$^{-1}" + mpl: + colorbar: + label : "kg m$^{-2}$ d$^{-1}" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + scale_factor_table: 0.365 #days to years, kg/m2 to Tg globally + avg_method: 'sum' + table_unit: "Tg y$^{-1}" + + +#+++++++++++ +# Category: Hydrology +#+++++++++++ +FSNO: # fraction of ground covered by snow + category: "Hydrology" + + +H2OSNO: # SNOWICE + SNOWLIQ + category: "Hydrology" + + +SNOWDP: # snow height + category: "Hydrology" + + +TOTRUNOFF: # total liquid runoff + category: "Hydrology" + derivable_from: ["QOVER","QDRAI","QRGWL"] #TODO, check accuracy + colormap: "Blues" + scale_factor: 86400 + add_offset: 0 + new_unit: "mm d$^{-1}$" + mpl: + colorbar: + label : "mm d$^{-1}$" + +#+++++++++++ +# Category: Vegetation +#+++++++++++ +BTRANMN: # Transpiration beta factor + category: "Vegetation" # Or hydrology? + +ELAI: # exposed one-sided leaf area index + category: "Vegetation" + colormap: "gist_earth_r" + contour_levels_range: [0., 7., 1.0] + diff_colormap: "PuOr_r" + diff_contour_range: [-3.,3.,0.5] + + +HTOP: # canopy top height + category: "Vegetation" + + +TSAI: # total one-sided stem area index + category: "Vegetation" + + +#+++++++++++ +# Category: Carbon +#+++++++++++ +GPP: # Gross Primary Production + category: "Carbon" + colormap: "gist_earth_r" + contour_levels_range: [0., 8., 0.5] + diff_colormap: "BrBG" + diff_contour_range: [-4.,4.,0.5] + scale_factor: 86400 + add_offset: 0 + new_unit: "gC m$^{-2} d$^{-1}" + mpl: + colorbar: #TODO make this print correctly + label : "gC ${m^-2 d^-1}" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally + avg_method: 'sum' + table_unit: "PgC y$^{-1}" + +AR: # Autotrophic Respiration + category: "Carbon" + colormap: "gist_earth_r" + contour_levels_range: [0., 3., 0.25] + diff_colormap: "BrBG" + diff_contour_range: [-1.5, 1.5, 0.25] + scale_factor: 86400 + add_offset: 0 + new_unit: "gC m$^{-2} d$^{-1}" + mpl: + colorbar: + label : "gC m$^{-2} d$^{-1}" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally + avg_method: 'sum' + table_unit: "PgC y$^{-1}" + +NPP: # Net Primary Production + category: "Carbon" + colormap: "gist_earth_r" + contour_levels_range: [0., 3., 0.25] + diff_colormap: "PuOr_r" + diff_contour_range: [-1.5, 1.5, 0.25] + scale_factor: 86400 + add_offset: 0 + new_unit: "gC m$^{-2} d$^{-1}" + mpl: + colorbar: + label : "gC m$^{-2} d$^{-1}" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally + avg_method: 'sum' + table_unit: "PgC y$^{-1}" + +TOTECOSYSC_1m: + category: "Carbon" + scale_factor_table: 0.000000001 #g/m2 to Pg globally + avg_method: 'sum' + table_unit: "PgC" + +TOTSOMC_1m: + category: "Carbon" + + +TOTVEGC: + category: "Carbon" + + +#+++++++++++ +# Category: Soils +#+++++++++++ +ALTMAX: # Active Layer Thickness + category: "Soils" + + +SOILWATER_10CM: # soil liquid water + ice in top 10cm of soil + category: "Soils" # or hydrology? + +TSOI_10CM: # Soil temperature, 0-10 cm + category: "Soils" + + + +#End of File From 34ddccd95c858343ad0698b6599bd805adcb7cb8 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:21:03 -0600 Subject: [PATCH 003/126] Update adf_dataset.py --- lib/adf_dataset.py | 83 +++++++++++++++++++++++++++++----------------- 1 file changed, 53 insertions(+), 30 deletions(-) diff --git a/lib/adf_dataset.py b/lib/adf_dataset.py index eb89dfaf2..ba1bacf50 100644 --- a/lib/adf_dataset.py +++ b/lib/adf_dataset.py @@ -1,5 +1,6 @@ from pathlib import Path import xarray as xr +import uxarray as ux import warnings # use to warn user about missing files @@ -47,7 +48,8 @@ class AdfData: def __init__(self, adfobj): self.adf = adfobj # provides quick access to the AdfDiag object # paths - self.model_rgrid_loc = adfobj.get_basic_info("cam_regrid_loc", required=True) + #self.model_rgrid_loc = adfobj.get_basic_info("cam_climo_regrid_loc", required=True) + #self.model_rgrid_loc = adfobj.get_cam_info("cam_climo_regrid_loc") # variables (and info for unit transform) # use self.adf.diag_var_list and self.adf.self.adf.variable_defaults @@ -95,8 +97,9 @@ def set_ref_var_loc(self): # Test case(s) def get_timeseries_file(self, case, field): """Return list of test time series files""" - ts_locs = self.adf.get_cam_info("cam_ts_loc", required=True) # list of paths (could be multiple cases) caseindex = (self.case_names).index(case) + ts_locs = self.adf.get_cam_info("cam_ts_loc") + ts_loc = Path(ts_locs[caseindex]) ts_filenames = f'{case}.*.{field}.*nc' ts_files = sorted(ts_loc.glob(ts_filenames)) @@ -109,7 +112,7 @@ def get_ref_timeseries_file(self, field): warnings.warn("\t WARNING: ADF does not currently expect observational time series files.") return None else: - ts_loc = Path(self.adf.get_baseline_info("cam_ts_loc", required=True)) + ts_loc = Path(self.adf.get_baseline_info("cam_ts_loc")) ts_filenames = f'{self.ref_case_label}.*.{field}.*nc' ts_files = sorted(ts_loc.glob(ts_filenames)) return ts_files @@ -181,36 +184,43 @@ def load_reference_timeseries_da(self, field): #------------------ # Test case(s) - def load_climo_da(self, case, variablename): + def load_climo_da(self, case, variablename, **kwargs): """Return DataArray from climo file""" add_offset, scale_factor = self.get_value_converters(case, variablename) fils = self.get_climo_file(case, variablename) - return self.load_da(fils, variablename, add_offset=add_offset, scale_factor=scale_factor) + return self.load_da(fils, variablename, add_offset=add_offset, scale_factor=scale_factor, **kwargs) - def load_climo_file(self, case, variablename): - """Return Dataset for climo of variablename""" - fils = self.get_climo_file(case, variablename) + def load_climo_dataset(self, case, field, **kwargs): + """Return a data set to be used as reference (aka baseline) for variable field.""" + fils = self.get_climo_file(case, field) if not fils: - warnings.warn(f"\t WARNING: Did not find climo file for variable: {variablename}. Will try to skip.") return None - return self.load_dataset(fils) - + return self.load_dataset(fils, **kwargs) + def get_climo_file(self, case, variablename): """Retrieve the climo file path(s) for variablename for a specific case.""" - a = self.adf.get_cam_info("cam_climo_loc", required=True) # list of paths (could be multiple cases) caseindex = (self.case_names).index(case) # the entry for specified case + a = self.adf.get_cam_info("cam_climo_loc", required=True) # list of paths (could be multiple cases) model_cl_loc = Path(a[caseindex]) return sorted(model_cl_loc.glob(f"{case}_{variablename}_climo.nc")) # Reference case (baseline/obs) - def load_reference_climo_da(self, case, variablename): + def load_reference_climo_da(self, case, variablename, **kwargs): """Return DataArray from reference (aka baseline) climo file""" add_offset, scale_factor = self.get_value_converters(case, variablename) fils = self.get_reference_climo_file(variablename) - return self.load_da(fils, variablename, add_offset=add_offset, scale_factor=scale_factor) + return self.load_da(fils, variablename, add_offset=add_offset, scale_factor=scale_factor, **kwargs) + + def load_reference_climo_dataset(self, case, field, **kwargs): + """Return a data set to be used as reference (aka baseline) for variable field.""" + fils = self.get_reference_climo_file(field) + if not fils: + return None + return self.load_dataset(fils, **kwargs) + def get_reference_climo_file(self, var): """Return a list of files to be used as reference (aka baseline) for variable var.""" @@ -226,7 +236,6 @@ def get_reference_climo_file(self, var): #------------------ - # Regridded files #------------------ @@ -238,23 +247,23 @@ def get_regrid_file(self, case, field): return sorted(model_rg_loc.glob(f"{rlbl}_{case}_{field}_regridded.nc")) - def load_regrid_dataset(self, case, field): + def load_regrid_dataset(self, case, field, **kwargs): """Return a data set to be used as reference (aka baseline) for variable field.""" fils = self.get_regrid_file(case, field) if not fils: warnings.warn(f"\t WARNING: Did not find regrid file(s) for case: {case}, variable: {field}") return None - return self.load_dataset(fils) + return self.load_dataset(fils, **kwargs) - def load_regrid_da(self, case, field): + def load_regrid_da(self, case, field, **kwargs): """Return a data array to be used as reference (aka baseline) for variable field.""" add_offset, scale_factor = self.get_value_converters(case, field) fils = self.get_regrid_file(case, field) if not fils: warnings.warn(f"\t WARNING: Did not find regrid file(s) for case: {case}, variable: {field}") return None - return self.load_da(fils, field, add_offset=add_offset, scale_factor=scale_factor) + return self.load_da(fils, field, add_offset=add_offset, scale_factor=scale_factor, **kwargs) # Reference case (baseline/obs) @@ -272,38 +281,43 @@ def get_ref_regrid_file(self, case, field): return fils - def load_reference_regrid_dataset(self, case, field): + def load_reference_regrid_dataset(self, case, field, **kwargs): """Return a data set to be used as reference (aka baseline) for variable field.""" fils = self.get_ref_regrid_file(case, field) if not fils: - warnings.warn(f"\t WARNING: Did not find regridded file(s) for case: {case}, variable: {field}") + warnings.warn(f"\t DATASET WARNING: Did not find regridded file(s) for case: {case}, variable: {field}") return None - return self.load_dataset(fils) + return self.load_dataset(fils, **kwargs) - def load_reference_regrid_da(self, case, field): + def load_reference_regrid_da(self, case, field, **kwargs): """Return a data array to be used as reference (aka baseline) for variable field.""" add_offset, scale_factor = self.get_value_converters(case, field) fils = self.get_ref_regrid_file(case, field) if not fils: - warnings.warn(f"\t WARNING: Did not find regridded file(s) for case: {case}, variable: {field}") + warnings.warn(f"\t DATAARRAY WARNING: Did not find regridded file(s) for case: {case}, variable: {field}") return None #Change the variable name from CAM standard to what is # listed in variable defaults for this observation field if self.adf.compare_obs: field = self.ref_var_nam[field] - return self.load_da(fils, field, add_offset=add_offset, scale_factor=scale_factor) + return self.load_da(fils, field, add_offset=add_offset, scale_factor=scale_factor, **kwargs) #------------------ # DataSet and DataArray load #--------------------------- + # TODO, make uxarray options fo all of these fuctions. + # What's the most robust way to handle this? # Load DataSet - def load_dataset(self, fils): + def load_dataset(self, fils, **kwargs): """Return xarray DataSet from file(s)""" - if (len(fils) == 0): + + unstructured_plotting = kwargs.get("unstructured_plotting",False) + + if not fils: warnings.warn("\t WARNING: Input file list is empty.") return None elif (len(fils) > 1): @@ -313,7 +327,16 @@ def load_dataset(self, fils): if not Path(sfil).is_file(): warnings.warn(f"\t WARNING: Expecting to find file: {sfil}") return None - ds = xr.open_dataset(sfil) + if unstructured_plotting: + if "mesh_file" not in kwargs: + msg = "\t WARNING: Unstructured plotting is requested, but no available mesh file." + msg += " Please make sure 'mesh_file' is declared in 'diag_basic_info' in config file" + print(msg) + ds = None + mesh = kwargs["mesh_file"] + ds = ux.open_dataset(mesh, sfil) + else: + ds = xr.open_dataset(sfil) if ds is None: warnings.warn(f"\t WARNING: invalid data on load_dataset") return ds @@ -321,7 +344,7 @@ def load_dataset(self, fils): # Load DataArray def load_da(self, fils, variablename, **kwargs): """Return xarray DataArray from files(s) w/ optional scale factor, offset, and/or new units""" - ds = self.load_dataset(fils) + ds = self.load_dataset(fils, **kwargs) if ds is None: warnings.warn(f"\t WARNING: Load failed for {variablename}") return None @@ -366,4 +389,4 @@ def get_value_converters(self, case, variablename): - \ No newline at end of file + From 82aba0a1bf96d06e72c6c7ba135c202b8e4518e6 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:22:39 -0600 Subject: [PATCH 004/126] Update adf_diag.py --- lib/adf_diag.py | 163 +++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 156 insertions(+), 7 deletions(-) diff --git a/lib/adf_diag.py b/lib/adf_diag.py index cb611376f..b9b918271 100644 --- a/lib/adf_diag.py +++ b/lib/adf_diag.py @@ -26,6 +26,8 @@ from pathlib import Path from typing import Optional +import utils as adf_utils + # Check if "PyYAML" is present in python path: # pylint: disable=unused-import try: @@ -67,6 +69,30 @@ print("Please install module, e.g. 'pip install Cartopy'.") sys.exit(1) +# Check if "uxarray" is present in python path: +#try: +# import uxarray as ux +#except ImportError: +# print("uxarray module does not exist in python path.") +# print("Please install module, e.g. 'pip install uxarray'.") +# sys.exit(1) + +# Check if "esmpy" is present in python path: +try: + import esmpy as esmpy +except ImportError: + print("xesmf module does not exist in python path.") + print("Please install module, e.g. 'pip install esmpy'.") + sys.exit(1) + +# Check if "xesmf" is present in python path: +try: + import xesmf as xesmf +except ImportError: + print("xesmf module does not exist in python path.") + print("Please install module, e.g. 'pip install xesmf'.") + sys.exit(1) + # pylint: enable=unused-import # +++++++++++++++++++++++++++++ @@ -358,6 +384,9 @@ def call_ncrcat(cmd): case_type_string = "baseline" hist_str_list = [self.hist_string["base_hist_str"]] + overwrite_regrid_locs = [self.get_baseline_info("cam_overwrite_ts_regrid")] + test_output_loc = [self.get_baseline_info("cam_ts_regrid_loc")] + else: # Use test case settings, which are already lists: case_names = self.get_cam_info("cam_case_name", required=True) @@ -367,8 +396,11 @@ def call_ncrcat(cmd): overwrite_ts = self.get_cam_info("cam_overwrite_ts") start_years = self.climo_yrs["syears"] end_years = self.climo_yrs["eyears"] - case_type_string="case" + case_type_string = "test" hist_str_list = self.hist_string["test_hist_str"] + + overwrite_regrid_locs = self.get_cam_info("cam_overwrite_ts_regrid") + test_output_loc = self.get_cam_info("cam_ts_regrid_loc") # End if # Read hist_str (component.hist_num) from the yaml file, or set to default @@ -378,6 +410,8 @@ def call_ncrcat(cmd): # get info about variable defaults res = self.variable_defaults + comp = self.model_component + # Loop over cases: for case_idx, case_name in enumerate(case_names): # Check if particular case should be processed: @@ -395,9 +429,11 @@ def call_ncrcat(cmd): # Create path object for the CAM history file(s) location: starting_location = Path(cam_hist_locs[case_idx]) + #unstruct = unstructed[case_idx] + # Check that path actually exists: if not starting_location.is_dir(): - emsg = f"Provided {case_type_string} 'cam_hist_loc' directory" + emsg = f"Provided {case_type_string} case 'cam_hist_loc' directory" emsg += f" '{starting_location}' not found. Script is ending here." self.end_diag_fail(emsg) # End if @@ -409,7 +445,7 @@ def call_ncrcat(cmd): hist_str_case = hist_str_list[case_idx] for hist_str in hist_str_case: - print(f"\t Processing time series for {case_type_string} {case_name}, {hist_str} files:") + print(f"\t Processing time series for {case_type_string} case '{case_name}', {hist_str} files:") if not list(starting_location.glob("*" + hist_str + ".*.nc")): emsg = ( f"No history *{hist_str}.*.nc files found in '{starting_location}'." @@ -727,21 +763,44 @@ def call_ncrcat(cmd): ts_outfil_str ] - # Step 3: Create the ncatted command to remove the history attribute + if "clm" in hist_str: + # Step 3a: Optional, add additional variables to clm2.h0 files + if "h0" in hist_str: + cmd_add_clm_h0_fields = [ + "ncks", "-A", "-v", "area,landfrac,landmask", + hist_files[0], + ts_outfil_str + ] + # add time invariant information to clm2.h0 fields + list_of_hist_commands.append(cmd_add_clm_h0_fields) + + # Step 3b: Optional, add additional variables to clm2.h1 files + if "h1" in hist_str: + cmd_add_clm_h1_fields = [ + "ncrcat", "-A", "-v", "pfts1d_ixy,pfts1d_jxy,pfts1d_itype_veg,lat,lon", + hist_files, + ts_outfil_str + ] + # add time varrying information to clm2.h1 fields + list_of_hist_commands.append(cmd_add_clm_h1_fields) + + # Step 3c: Create the ncatted command to remove the history attribute cmd_remove_history = [ "ncatted", "-O", "-h", "-a", "history,global,d,,", ts_outfil_str ] - + + # Add to command list for use in multi-processing pool: # ----------------------------------------------------- # generate time series files list_of_commands.append(cmd) # Add global attributes: user, original hist file loc(s) and all filenames list_of_ncattend_commands.append(cmd_ncatted) + # Remove the `history` attr that gets tacked on (for clean up) - # NOTE: this may not be best practice, but it the history attr repeats + # NOTE: this may not be best practice, but if the history attr repeats # the files attrs so the global attrs become obtrusive... list_of_hist_commands.append(cmd_remove_history) @@ -760,12 +819,82 @@ def call_ncrcat(cmd): with mp.Pool(processes=self.num_procs) as mpool: _ = mpool.map(call_ncrcat, list_of_hist_commands) + # Loop over the created time series files again and fix the time if necessary + #NOTE: There is no solution to do this with NCO operators, but there is with CDO operators. + # We can switch to using CDO, but it would require the user to have/load CDO as well. + fils = glob.glob(f"{ts_dir}/*{time_string}.nc") + for fil in fils: + ts_ds = xr.open_dataset(fil, decode_times=False) + if ('time_bnds' in ts_ds) or ('time_bounds' in ts_ds): + if comp == "atm": + if ('time_bnds' in ts_ds): + ts_ds.time_bnds.attrs['units'] = ts_ds.time.attrs['units'] + ts_ds.time_bnds.attrs['calendar'] = ts_ds.time.attrs['calendar'] + if ('time_bounds' in ts_ds): + ts_ds.time_bounds.attrs['units'] = ts_ds.time.attrs['units'] + ts_ds.time_bounds.attrs['calendar'] = ts_ds.time.attrs['calendar'] + if comp == "lnd": + ts_ds.time_bounds.attrs['units'] = ts_ds.time.attrs['units'] + ts_ds.time_bounds.attrs['calendar'] = ts_ds.time.attrs['calendar'] + time = ts_ds['time'] + + if comp == "atm": + if ('time_bnds' in ts_ds): + time = xr.DataArray(ts_ds['time_bnds'].load().mean(dim='nbnd').values, dims=time.dims, attrs=time.attrs) + if ('time_bounds' in ts_ds): + time = xr.DataArray(ts_ds['time_bounds'].load().mean(dim='nbnd').values, dims=time.dims, attrs=time.attrs) + if comp == "lnd": + time = xr.DataArray(ts_ds['time_bounds'].load().mean(dim='hist_interval').values, dims=time.dims, attrs=time.attrs) + ts_ds['time'] = time + ts_ds.assign_coords(time=time) + ts_ds_fixed = xr.decode_cf(ts_ds) + + # Add attribute note of time change + attrs_dict = { + "adf_timeseries_info": "Time series files have been computed using 'ncrcat'", + "adf_note": "The time values have been modified to middle of month" + } + ts_ds_fixed = ts_ds_fixed.assign_attrs(attrs_dict) + + # Save to a temporary file + temp_file_path = fil + ".tmp" + ts_ds_fixed.to_netcdf(temp_file_path) + # Replace the original file with the modified file + os.replace(temp_file_path, fil) + if vars_to_derive: self.derive_variables( res=res, hist_str=hist_str, vars_to_derive=vars_to_derive, constit_dict=constit_dict, ts_dir=ts_dir ) # End with + + # DOES NOT WORK CORRECTLY! + grid_ts = False + if grid_ts: + # TEMPORARY: do a quick check if this on native grid and regrid + ts_0 = sorted(Path(ts_dir).glob("*.nc"))[0] + ts_file_ds = xr.open_dataset(ts_0) + + if adf_utils.check_unstructured(ts_file_ds, case_name): + print() + latlon_file = self.latlon_files[f"{case_type_string}_latlon_file"] + print("latlon_file",latlon_file,"\n") + #latlon_file = ts_0 + time_file = ts_file_ds + wgts_file = self.latlon_wgt_files[f"{case_type_string}_wgts_file"] + method = self.latlon_regrid_method[f"{case_type_string}_regrid_method"] + if not baseline: + wgts_file = wgts_file[case_idx] + method = method[case_idx] + latlon_file = latlon_file[case_idx] + + kwargs = {"ts_dir":ts_dir, "latlon_file":latlon_file, "wgts_file":wgts_file, + "method":method, "diag_var_list":self.diag_var_list, "case_name":case_name, + "hist_str":hist_str, "time_string":time_string, "comp":comp,"time_file":time_file + } + adf_utils.grid_timeseries(**kwargs) + # End for hist_str # End cases loop @@ -1542,4 +1671,24 @@ def my_formatwarning(msg, *args, **kwargs): return xr.open_dataset(fils[0]) #End if # End def -######## \ No newline at end of file + +def save_to_nc(tosave, outname, attrs=None, proc=None): + """Saves xarray variable to new netCDF file""" + + xo = tosave # used to have more stuff here. + # deal with getting non-nan fill values. + if isinstance(xo, xr.Dataset): + enc_dv = {xname: {'_FillValue': None} for xname in xo.data_vars} + else: + enc_dv = {} + #End if + enc_c = {xname: {'_FillValue': None} for xname in xo.coords} + enc = {**enc_c, **enc_dv} + if attrs is not None: + xo.attrs = attrs + if proc is not None: + xo.attrs['Processing_info'] = f"Start from file {origname}. " + proc + xo.to_netcdf(outname, format='NETCDF4', encoding=enc) + +##### +######## From 7382f4799f2dc50df68ba0dbe399d71327599fc0 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:24:06 -0600 Subject: [PATCH 005/126] Update adf_info.py --- lib/adf_info.py | 227 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 222 insertions(+), 5 deletions(-) diff --git a/lib/adf_info.py b/lib/adf_info.py index 41ebde606..44e6d4102 100644 --- a/lib/adf_info.py +++ b/lib/adf_info.py @@ -45,6 +45,7 @@ #ADF modules: from adf_config import AdfConfig from adf_base import AdfError +import utils #+++++++++++++++++++ #Define Obs class @@ -197,10 +198,36 @@ def __init__(self, config_file, debug=False): # Read hist_str (component.hist_num, eg cam.h0) from the yaml file baseline_hist_str = self.get_baseline_info("hist_str") + if "cam" in baseline_hist_str: + base_comp = "atm" + if "clm" in baseline_hist_str: + base_comp = "lnd" + + #self.__base_comp = base_comp #Check if any time series files are pre-made baseline_ts_done = self.get_baseline_info("cam_ts_done") + baseline_mesh_file = self.get_baseline_info("mesh_file") + self.__baseline_mesh_file = baseline_mesh_file + + #Check if any a FV file exists if using native grid + baseline_latlon_file = self.get_baseline_info("latlon_file") + self.__baseline_latlon_file = baseline_latlon_file + + #Check if any a weights file exists if using native grid, OPTIONAL + baseline_wgts_file = self.get_baseline_info("weights_file") + self.__baseline_wgts_file = baseline_wgts_file + + baseline_regrid_method = self.get_baseline_info("regrid_method") + if baseline_regrid_method == 'conservative': + print("user defined 'conservative', but xesmf has a typo, changing to 'coservative'") + baseline_regrid_method = 'coservative' + self.__baseline_regrid_method = baseline_regrid_method + + baseline_native_grid = self.get_baseline_info("native_grid") + self.__baseline_native_grid = baseline_native_grid + #Check if time series files already exist, #if so don't rely on climo years from history location if baseline_ts_done: @@ -238,7 +265,7 @@ def __init__(self, config_file, debug=False): msg += f"{data_name}, using first found year: {found_eyear_baseline}" print(msg) eyear_baseline = found_eyear_baseline - # End if + # End if baseline time series done # Check if history file path exists: if any(baseline_hist_locs): @@ -267,7 +294,6 @@ def __init__(self, config_file, debug=False): emsg += "\tTry checking the path 'cam_hist_loc' in 'diag_cam_baseline_climo' " emsg += "section in your config file is correct..." self.end_diag_fail(emsg) - file_list = sorted(starting_location.glob("*" + base_hist_str + ".*.nc")) #Check if there are any history files if len(file_list) == 0: @@ -280,6 +306,7 @@ def __init__(self, config_file, debug=False): emsg += " in 'diag_cam_baseline_climo' " emsg += "section in your config file are correct..." self.end_diag_fail(emsg) + base_ds = xr.open_dataset(file_list[0], decode_times=True) # Partition string to find exactly where h-number is # This cuts the string before and after the `{hist_str}.` sub-string @@ -326,6 +353,16 @@ def __init__(self, config_file, debug=False): base_nickname = self.get_baseline_info('case_nickname') if base_nickname is None: base_nickname = data_name + if 'ncols' in base_ds.dims: + print('\t Looks like this is an atmosphere unstructured grid, yeah') + unstruct = True + elif 'lndgrid' in base_ds.dims: + print('\t Looks like this is a land unstructured grid, yeah') + unstruct = True + else: + print('\t Looks like this is a structured lat/lon grid?') + unstruct = False + self.__unstruct_base = unstruct #End if #Grab baseline nickname @@ -357,6 +394,16 @@ def __init__(self, config_file, debug=False): #Plot directory: plot_dir = self.get_basic_info('cam_diag_plot_loc', required=True) + #Unstructured plotting: + unstructured_plotting = self.get_basic_info('unstructured_plotting') + if not unstructured_plotting: + unstructured_plotting = False + self.__unstructured_plotting = unstructured_plotting + + #Mesh file + mesh_file = self.get_basic_info('mesh_file') + self.__mesh_file = mesh_file + #Case names: case_names = self.get_cam_info('cam_case_name', required=True) @@ -392,12 +439,51 @@ def __init__(self, config_file, debug=False): #Check if using pre-made ts files cam_ts_done = self.get_cam_info("cam_ts_done") + #Check if any a FV file exists if using native grid + cam_mesh_files = self.get_cam_info("mesh_file") + if cam_mesh_files is None: + cam_mesh_files = [None]*len(case_names) + self.__cam_mesh_files = cam_mesh_files + + #Check if any a FV file exists if using native grid + cam_latlon_files = self.get_cam_info("latlon_file") + if cam_latlon_files is None: + cam_latlon_files = [None]*len(case_names) + self.__cam_latlon_files = cam_latlon_files + + #Check if any a weights file exists if using native grid, OPTIONAL + cam_wgts_files = self.get_cam_info("weights_file") + if cam_wgts_files is None: + cam_wgts_files = [None]*len(case_names) + self.__cam_wgts_files = cam_wgts_files + + cam_regrid_method = self.get_cam_info("regrid_method") + if cam_regrid_method: + cam_regrid_methods = [] + for regr_method in cam_regrid_method: + if regr_method == 'conservative': + print("user defined 'conservative', but xesmf has a typo, changing to 'coservative'") + cam_regrid_methods.append('coservative') + if regr_method is None: + cam_regrid_methods.append('coservative') + else: + cam_regrid_methods.append(regr_method) + if cam_regrid_method is None: + cam_regrid_method = [None]*len(case_names) + self.__cam_regrid_method = cam_regrid_method + + cam_native_grid = self.get_cam_info("native_grid") + if cam_native_grid is None: + cam_native_grid = [None]*len(case_names) + self.__test_native_grid = cam_native_grid + #Grab case time series file location(s) input_ts_locs = self.get_cam_info("cam_ts_loc", required=True) #Loop over cases: syears_fixed = [] eyears_fixed = [] + unstructs = [] for case_idx, case_name in enumerate(case_names): syear = syears[case_idx] @@ -443,6 +529,13 @@ def __init__(self, config_file, debug=False): #Check if history file path exists: hist_str_case = hist_str[case_idx] + case_comps = [] + if "cam" in hist_str_case: + case_comp = "atm" + case_comps.append("atm") + if "clm" in hist_str_case: + case_comp = "lnd" + case_comps.append("lnd") if any(cam_hist_locs): #Grab first possible hist string, just looking for years of run hist_str = hist_str_case[0] @@ -451,8 +544,6 @@ def __init__(self, config_file, debug=False): starting_location = Path(cam_hist_locs[case_idx]) print(f"\tChecking history files in '{starting_location}'") - file_list = sorted(starting_location.glob('*'+hist_str+'.*.nc')) - #Check if the history file location exists if not starting_location.is_dir(): msg = "Checking history file location:\n" @@ -475,6 +566,18 @@ def __init__(self, config_file, debug=False): emsg += "in 'diag_cam_climo' " emsg += "section in your config file are correct..." self.end_diag_fail(emsg) + + case_ds = xr.open_dataset(file_list[0], decode_times=True) + if 'ncols' in case_ds.dims: + print('\t Looks like this is an atmosphere unstructured grid, yeah') + unstruct = True + if 'lndgrid' in case_ds.dims: + print('\t Looks like this is a land unstructured grid, yeah') + unstruct = True + else: + print('\t Looks like this is a structured lat/lon grid, eh?') + unstruct = False + unstructs.append(unstruct) #Partition string to find exactly where h-number is #This cuts the string before and after the `{hist_str}.` sub-string @@ -549,6 +652,18 @@ def __init__(self, config_file, debug=False): self.__syears = syears_fixed self.__eyears = eyears_fixed + self.__unstruct_test = unstructs + #self.__case_comps = case_comps + + if all(item == base_comp for item in case_comps): + print("All values in the list are the same as the string variable") + self.__model_component = base_comp + else: + msg = "\t ERROR: Looks like the model components are not the same:" + msg += f"\t - Test case(s): {case_comps}; Baseline case: {base_comp}" + raise AdfError(msg) + + #Finally add baseline case (if applicable) for use by the website table #generator. These files will be stored in the same location as the first #listed case. @@ -650,6 +765,13 @@ def num_cases(self): """Return the "num_cases" integer value to the user if requested.""" return self.__num_cases + # Create property needed to return the case nicknames to user: + @property + def model_component(self): + """Return the assumed model component to the user if requested, ie atm or lnd""" + return self.__model_component + + # Create property needed to return "diag_var_list" list to user: @property def diag_var_list(self): @@ -682,6 +804,34 @@ def baseline_climo_dict(self): #modify this variable, as it is mutable and thus passed by reference: return copy.copy(self.__cam_bl_climo_info) + # Create property needed to return "num_procs" to user: + @property + def unstructured_plotting(self): + """Return the "unstructured_plotting" logical to the user if requested.""" + return self.__unstructured_plotting + + # Create property needed to return "num_procs" to user: + @property + def mesh_file(self): + """Return the "unstructured_plotting" logical to the user if requested.""" + return self.__mesh_file + + + # Create property needed to return the case nicknames to user: + @property + def mesh_files(self): + """Return the test case and baseline nicknames to the user if requested.""" + + #Note that copies are needed in order to avoid having a script mistakenly + #modify these variables, as they are mutable and thus passed by reference: + cam_mesh_files = copy.copy(self.__cam_mesh_files) + + baseline_mesh_file = self.__baseline_mesh_file + + return {"test_mesh_file":cam_mesh_files,"baseline_mesh_file":baseline_mesh_file} + + + # Create property needed to return "num_procs" to user: @property def num_procs(self): @@ -696,6 +846,73 @@ def plot_location(self): #modify this variable: return copy.copy(self.__plot_location) + + # Create property needed to return the case nicknames to user: + @property + def latlon_files(self): + """Return the test case and baseline nicknames to the user if requested.""" + + #Note that copies are needed in order to avoid having a script mistakenly + #modify these variables, as they are mutable and thus passed by reference: + cam_latlon_files = copy.copy(self.__cam_latlon_files) + + baseline_latlon_file = self.__baseline_latlon_file + + return {"test_latlon_file":cam_latlon_files,"baseline_latlon_file":baseline_latlon_file} + + # Create property needed to return the case nicknames to user: + @property + def latlon_wgt_files(self): + """Return the test case and baseline nicknames to the user if requested.""" + + #Note that copies are needed in order to avoid having a script mistakenly + #modify these variables, as they are mutable and thus passed by reference: + cam_wgts_files = copy.copy(self.__cam_wgts_files) + + baseline_wgts_file = self.__baseline_wgts_file + + return {"test_wgts_file":cam_wgts_files,"baseline_wgts_file":baseline_wgts_file} + + # Create property needed to return the case nicknames to user: + @property + def latlon_regrid_method(self): + """Return the test case and baseline nicknames to the user if requested.""" + + #Note that copies are needed in order to avoid having a script mistakenly + #modify these variables, as they are mutable and thus passed by reference: + cam_regrid_method = copy.copy(self.__cam_regrid_method) + + baseline_regrid_method = self.__baseline_regrid_method + + return {"test_regrid_method":cam_regrid_method,"baseline_regrid_method":baseline_regrid_method} + + + + # Create property needed to return the case nicknames to user: + @property + def unstructs(self): + """Return the test case and baseline nicknames to the user if requested.""" + + #Note that copies are needed in order to avoid having a script mistakenly + #modify these variables, as they are mutable and thus passed by reference: + unstruct_tests = copy.copy(self.__unstruct_test) + unstruct_base = self.__unstruct_base + + return {"unstruct_tests":unstruct_tests,"unstruct_base":unstruct_base} + + + # Create property needed to return the case nicknames to user: + @property + def native_grid(self): + """Return the test case and baseline nicknames to the user if requested.""" + + #Note that copies are needed in order to avoid having a script mistakenly + #modify these variables, as they are mutable and thus passed by reference: + test_native_grid = self.__test_native_grid + base_native_grid = self.__baseline_native_grid + + return {"test_native_grid":test_native_grid,"baseline_native_grid":base_native_grid} + # Create property needed to return the climo start (syear) and end (eyear) years to user: @property def climo_yrs(self): @@ -901,4 +1118,4 @@ def get_climo_yrs_from_ts(self, input_ts_loc, case_name): #++++++++++++++++++++ #End Class definition -#++++++++++++++++++++ \ No newline at end of file +#++++++++++++++++++++ From bd105448c52b96ca91cc94ec2bd6a3701da86180 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:27:23 -0600 Subject: [PATCH 006/126] Update plotting_functions.py --- lib/plotting_functions.py | 831 ++++++++++++++++++++++++++++---------- 1 file changed, 609 insertions(+), 222 deletions(-) diff --git a/lib/plotting_functions.py b/lib/plotting_functions.py index 08de58860..5718f6512 100644 --- a/lib/plotting_functions.py +++ b/lib/plotting_functions.py @@ -99,6 +99,7 @@ from mpl_toolkits.axes_grid1.inset_locator import inset_axes from matplotlib.lines import Line2D import matplotlib.cm as cm +import uxarray as ux #need npl 2024a or later from adf_diag import AdfDiag from adf_base import AdfError @@ -161,6 +162,38 @@ def load_dataset(fils): #End if #End def +def load_ux_dataset(fils, mesh=None): + """ + This method exists to get an uxarray Dataset from input file information that can be passed into the plotting methods. + + Parameters + ---------- + fils : list + strings or paths to input file(s) + + Returns + ------- + ux.UxDataArray + + Notes + ----- + When just one entry is provided, use `open_dataset`, otherwise `open_mfdatset` + """ + if mesh == None: + mesh = '/glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc' + warnings.warn(f"No mesh file provided, using defaults ne30pg3 mesh file") + + if len(fils) == 0: + warnings.warn(f"Input file list is empty.") + return None + elif len(fils) > 1: + return ux.open_mfdataset(mesh, fils) + else: + return ux.open_dataset(mesh, fils[0]) + #End if +#End def + + def use_this_norm(): """Just use the right normalization; avoids a deprecation warning.""" @@ -408,6 +441,57 @@ def spatial_average(indata, weights=None, spatial_dims=None): return weighted.mean(dim=spatial_dims, keep_attrs=True) +# TODO, maybe just adapt the spatial average above? +# TODO, should there be some unit conversions for this defined in a variable dictionary? +def spatial_average_lnd(indata, weights, spatial_dims=None): + """Compute spatial average. + + Parameters + ---------- + indata : xr.DataArray + input data + weights xr.DataArray + weights (area * landfrac) + spatial_dims : list, optional + list of dimensions to average, see Notes for default behavior + + Returns + ------- + xr.DataArray + weighted average of `indata` + + Notes + ----- + weights are required + + Makes an attempt to identify the spatial variables when `spatial_dims` is None. + Will average over `ncol` if present, and then will check for `lat` and `lon`. + When none of those three are found, raise an AdfError. + """ + import warnings + + #Apply weights to input data: + weighted = indata*weights + + # we want to average over all non-time dimensions + if spatial_dims is None: + if 'lndgrid' in indata.dims: + spatial_dims = ['lndgrid'] + else: + spatial_dims = [dimname for dimname in indata.dims if (('lat' in dimname.lower()) or + ('lon' in dimname.lower()))] + if not spatial_dims: + #Scripts using this function likely expect the horizontal dimensions + #to be removed via the application of the mean. So in order to avoid + #possibly unexpected behavior due to arrays being incorrectly dimensioned + #(which could be difficult to debug) the ADF should die here: + emsg = "spatial_average: No spatial dimensions were identified," + emsg += " so can not perform average." + raise AdfError(emsg) + + + return weighted.sum(dim=spatial_dims, keep_attrs=True) + def wgt_rmse(fld1, fld2, wgt): """Calculate the area-weighted RMSE. @@ -429,7 +513,8 @@ def wgt_rmse(fld1, fld2, wgt): Notes: ```rmse = sqrt( mean( (fld1 - fld2)**2 ) )``` """ - assert len(fld1.shape) == 2, "Input fields must have exactly two dimensions." + wgt.fillna(0) + assert len(fld1.shape) <= 2, "Input fields must have less than two dimensions." assert fld1.shape == fld2.shape, "Input fields must have the same array shape." # in case these fields are in dask arrays, compute them now. if hasattr(fld1, "compute"): @@ -453,7 +538,7 @@ def wgt_rmse(fld1, fld2, wgt): ####### # Time-weighted averaging -def annual_mean(data, whole_years=False, time_name='time'): +def annual_mean(data, whole_years=False, time_name='time', use_ux=False): """Calculate annual averages from monthly time series data. Parameters @@ -490,7 +575,36 @@ def annual_mean(data, whole_years=False, time_name='time'): # this provides the normalized monthly weights in each year # -- do it for each year to allow for non-standard calendars (360-day) # -- and also to provision for data with leap years - days_gb = data_to_avg.time.dt.daysinmonth.groupby('time.year').map(lambda x: x / x.sum()) + days_in_month = data_to_avg.time.dt.daysinmonth + #print("days_in_month",days_in_month,'\n') + if not use_ux: + days_gb = data_to_avg.time.dt.daysinmonth.groupby('time.year').map(lambda x: x / x.sum()) + else: + # Group by the 'year' dimension + grouped_by_year = days_in_month.groupby('time.year') + + # Initialize a list to store the normalized days for each year + normalized_days = [] + + # Loop over each group and normalize the values (divide by the sum of the group) + for i, (year, group) in enumerate(grouped_by_year): + # Compute the sum of days in the month for the current year + print(group) + year_sum = group[12*i:12*i+12].sum() + + # Normalize the group by dividing each value by the sum of the group + normalized_group = group[12*i:12*i+12] / year_sum + + # Append the normalized values to the list + normalized_days.append(normalized_group) + + # Concatenate the normalized days back together (align them with the original data) + days_gb = xr.concat(normalized_days, dim='time') + + # Alternatively, if you want to make sure the result has the same coordinates as the original + days_gb = days_in_month.copy(data=np.concatenate([g.values for g in normalized_days])) + days_gb.coords['time'] = days_in_month.coords['time'] # Reassign the correct time coordinates + # weighted average with normalized weights: = SUM x_i * w_i (implied division by SUM w_i) result = (data_to_avg * days_gb).groupby('time.year').sum(dim='time') result.attrs['averaging_period'] = date_range_string @@ -545,6 +659,12 @@ def seasonal_mean(data, season=None, is_climo=None): if "month" in data.dims: data = data.rename({"month":"time"}) has_time = True + if isinstance(data, ux.UxDataset): + has_time = 'time' in data.dims + if not has_time: + if "month" in data.dims: + data = data.rename({"month":"time"}) + has_time = True if not has_time: # this might happen if a pure numpy array gets passed in # --> assumes ordered January to December. @@ -567,7 +687,7 @@ def seasonal_mean(data, season=None, is_climo=None): #Polar Plot functions -def domain_stats(data, domain): +def domain_stats(data, domain, unstructured=False): """Provides statistics in specified region. Parameters @@ -597,16 +717,22 @@ def domain_stats(data, domain): spatial_average """ - x_region = data.sel(lat=slice(domain[2],domain[3]), lon=slice(domain[0],domain[1])) - x_region_mean = x_region.weighted(np.cos(np.deg2rad(x_region['lat']))).mean().item() + if not unstructured: + x_region = data.sel(lat=slice(domain[2],domain[3]), lon=slice(domain[0],domain[1])) + x_region_mean = x_region.weighted(np.cos(np.deg2rad(x_region['lat']))).mean().item() + else: + x_region = data + x_region_mean = data.mean().item() x_region_min = x_region.min().item() x_region_max = x_region.max().item() return x_region_mean, x_region_max, x_region_min + + def make_polar_plot(wks, case_nickname, base_nickname, case_climo_yrs, baseline_climo_yrs, - d1:xr.DataArray, d2:xr.DataArray, difference:Optional[xr.DataArray]=None,pctchange:Optional[xr.DataArray]=None, - domain:Optional[list]=None, hemisphere:Optional[str]=None, obs=False, **kwargs): + d1, d2, difference=None,pctchange=None, + domain:Optional[list]=None, hemisphere:Optional[str]=None, obs=False, unstructured=False, **kwargs): """Make a stereographic polar plot for the given data and hemisphere. @@ -659,10 +785,16 @@ def make_polar_plot(wks, case_nickname, base_nickname, pct = pctchange #check if pct has NaN's or Inf values and if so set them to 0 to prevent plotting errors - pct = pct.where(np.isfinite(pct), np.nan) - pct = pct.fillna(0.0) + pct_grid = pct.uxgrid + pct_0 = pct.where(np.isfinite(pct), np.nan) + pct_0 = pct_0.fillna(0.0) + if isinstance(pct, ux.UxDataArray): + pct = ux.UxDataArray(pct_0,uxgrid=pct_grid) + else: + pct = pct_0 + print("What type is this!?!?!?!?",type(pct),"\n") - if hemisphere.upper() == "NH": + if (hemisphere.upper() == "NH") or (hemisphere == "Arctic"): proj = ccrs.NorthPolarStereo() elif hemisphere.upper() == "SH": proj = ccrs.SouthPolarStereo() @@ -672,26 +804,54 @@ def make_polar_plot(wks, case_nickname, base_nickname, if domain is None: if hemisphere.upper() == "NH": domain = [-180, 180, 45, 90] + if hemisphere == "Arctic": + domain = [-180, 180, 50, 90] else: domain = [-180, 180, -90, -45] - # statistics for annotation (these are scalars): + """# statistics for annotation (these are scalars): d1_region_mean, d1_region_max, d1_region_min = domain_stats(d1, domain) d2_region_mean, d2_region_max, d2_region_min = domain_stats(d2, domain) dif_region_mean, dif_region_max, dif_region_min = domain_stats(dif, domain) - pct_region_mean, pct_region_max, pct_region_min = domain_stats(pct, domain) + pct_region_mean, pct_region_max, pct_region_min = domain_stats(pct, domain)""" + means = [] + mins = [] + maxs = [] + if not unstructured: + # statistics for annotation (these are scalars): + d1_region_mean, d1_region_max, d1_region_min = domain_stats(d1, domain) + d2_region_mean, d2_region_max, d2_region_min = domain_stats(d2, domain) + dif_region_mean, dif_region_max, dif_region_min = domain_stats(dif, domain) + pct_region_mean, pct_region_max, pct_region_min = domain_stats(pct, domain) + #downsize to the specified region; makes plotting/rendering/saving much faster + d1 = d1.sel(lat=slice(domain[2],domain[3])) + d2 = d2.sel(lat=slice(domain[2],domain[3])) + dif = dif.sel(lat=slice(domain[2],domain[3])) + pct = pct.sel(lat=slice(domain[2],domain[3])) + + # add cyclic point to the data for better-looking plot + d1_cyclic, lon_cyclic = add_cyclic_point(d1, coord=d1.lon) + d2_cyclic, _ = add_cyclic_point(d2, coord=d2.lon) # since we can take difference, assume same longitude coord. + dif_cyclic, _ = add_cyclic_point(dif, coord=dif.lon) + pct_cyclic, _ = add_cyclic_point(pct, coord=pct.lon) + #wrap_fields = (d1_cyclic, d2_cyclic, dif_cyclic, pct_cyclic) + wrap_fields = (d1_cyclic, d2_cyclic, pct_cyclic, dif_cyclic) + lons, lats = np.meshgrid(lon_cyclic, d1.lat) + else: + wgt = kwargs["wgt"] + #wrap_fields = (d1, d2, dif, pct) + wrap_fields = (d1, d2, pct, dif) + area_avg = [global_average(x, wgt) for x in wrap_fields] + + d1_region_mean, d1_region_max, d1_region_min = domain_stats(d1, domain, unstructured) + d2_region_mean, d2_region_max, d2_region_min = domain_stats(d2, domain, unstructured) + dif_region_mean, dif_region_max, dif_region_min = domain_stats(dif, domain, unstructured) + pct_region_mean, pct_region_max, pct_region_min = domain_stats(pct, domain, unstructured) - #downsize to the specified region; makes plotting/rendering/saving much faster - d1 = d1.sel(lat=slice(domain[2],domain[3])) - d2 = d2.sel(lat=slice(domain[2],domain[3])) - dif = dif.sel(lat=slice(domain[2],domain[3])) - pct = pct.sel(lat=slice(domain[2],domain[3])) - # add cyclic point to the data for better-looking plot - d1_cyclic, lon_cyclic = add_cyclic_point(d1, coord=d1.lon) - d2_cyclic, _ = add_cyclic_point(d2, coord=d2.lon) # since we can take difference, assume same longitude coord. - dif_cyclic, _ = add_cyclic_point(dif, coord=dif.lon) - pct_cyclic, _ = add_cyclic_point(pct, coord=pct.lon) + # TODO Check this is correct, weighted rmse uses xarray weighted function + #d_rmse = wgt_rmse(a, b, wgt) + d_rmse = (np.sqrt(((dif**2)*wgt).sum())).values.item() # -- deal with optional plotting arguments that might provide variable-dependent choices @@ -701,86 +861,13 @@ def make_polar_plot(wks, case_nickname, base_nickname, absmaxdif = np.max(np.abs(dif)) absmaxpct = np.max(np.abs(pct)) - if 'colormap' in kwargs: - cmap1 = kwargs['colormap'] - else: - cmap1 = 'coolwarm' - - if 'contour_levels' in kwargs: - levels1 = kwargs['contour_levels'] - norm1 = mpl.colors.Normalize(vmin=min(levels1), vmax=max(levels1)) - elif 'contour_levels_range' in kwargs: - assert len(kwargs['contour_levels_range']) == 3, "contour_levels_range must have exactly three entries: min, max, step" - levels1 = np.arange(*kwargs['contour_levels_range']) - norm1 = mpl.colors.Normalize(vmin=min(levels1), vmax=max(levels1)) - else: - levels1 = np.linspace(minval, maxval, 12) - norm1 = mpl.colors.Normalize(vmin=minval, vmax=maxval) - - if ('colormap' not in kwargs) and ('contour_levels' not in kwargs): - norm1, cmap1 = get_difference_colors(levels1) # maybe these are better defaults if nothing else is known. - - if "diff_contour_levels" in kwargs: - levelsdiff = kwargs["diff_contour_levels"] # a list of explicit contour levels - elif "diff_contour_range" in kwargs: - assert len(kwargs['diff_contour_range']) == 3, "diff_contour_range must have exactly three entries: min, max, step" - levelsdiff = np.arange(*kwargs['diff_contour_range']) - else: - # set levels for difference plot (with a symmetric color bar): - levelsdiff = np.linspace(-1*absmaxdif, absmaxdif, 12) - #End if - - if "pct_diff_contour_levels" in kwargs: - levelspctdiff = kwargs["pct_diff_contour_levels"] # a list of explicit contour levels - elif "pct_diff_contour_range" in kwargs: - assert len(kwargs['pct_diff_contour_range']) == 3, "pct_diff_contour_range must have exactly three entries: min, max, step" - levelspctdiff = np.arange(*kwargs['pct_diff_contour_range']) - else: - levelspctdiff = [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pctnorm = mpl.colors.BoundaryNorm(levelspctdiff,256) - - #NOTE: Sometimes the contour levels chosen in the defaults file - #can result in the "contourf" software stack generating a - #'TypologyException', which should manifest itself as a - #"PredicateError", but due to bugs in the stack itself - #will also sometimes raise an AttributeError. - - #To prevent this from happening, the polar max and min values - #are calculated, and if the default contour values are significantly - #larger then the min-max values, then the min-max values are used instead: - #------------------------------- - if max(levels1) > 10*maxval: - levels1 = np.linspace(minval, maxval, 12) - norm1 = mpl.colors.Normalize(vmin=minval, vmax=maxval) - elif minval < 0 and min(levels1) < 10*minval: - levels1 = np.linspace(minval, maxval, 12) - norm1 = mpl.colors.Normalize(vmin=minval, vmax=maxval) - #End if - - if max(np.abs(levelsdiff)) > 10*absmaxdif: - levelsdiff = np.linspace(-1*absmaxdif, absmaxdif, 12) - - - #End if - #------------------------------- - - # Difference options -- Check in kwargs for colormap and levels - if "diff_colormap" in kwargs: - cmapdiff = kwargs["diff_colormap"] - dnorm, _ = get_difference_colors(levelsdiff) # color map output ignored - else: - dnorm, cmapdiff = get_difference_colors(levelsdiff) - - # Pct Difference options -- Check in kwargs for colormap and levels - if "pct_diff_colormap" in kwargs: - cmappct = kwargs["pct_diff_colormap"] - else: - cmappct = "PuOr_r" - #End if + means.extend([d1_region_mean,d2_region_mean, pct_region_mean, dif_region_mean]) + mins.extend([d1_region_min,d2_region_min, pct_region_min, dif_region_min]) + maxs.extend([d1_region_max,d2_region_max, pct_region_max, dif_region_max]) # -- end options - lons, lats = np.meshgrid(lon_cyclic, d1.lat) + #lons, lats = np.meshgrid(lon_cyclic, d1.lat) fig = plt.figure(figsize=(10,10)) gs = mpl.gridspec.GridSpec(2, 4, wspace=0.9) @@ -789,112 +876,135 @@ def make_polar_plot(wks, case_nickname, base_nickname, ax2 = plt.subplot(gs[0, 2:], projection=proj) ax3 = plt.subplot(gs[1, :2], projection=proj) ax4 = plt.subplot(gs[1, 2:], projection=proj) + axs = [ax1,ax2,ax3,ax4] - levs = np.unique(np.array(levels1)) - levs_diff = np.unique(np.array(levelsdiff)) - levs_pctdiff = np.unique(np.array(levelspctdiff)) + #generate a dictionary of contour plot settings: + cp_info = prep_contour_plot(d1, d2, pct, dif, **kwargs) - if len(levs) < 2: - img1 = ax1.contourf(lons, lats, d1_cyclic, transform=ccrs.PlateCarree(), colors="w", norm=norm1) - ax1.text(0.4, 0.4, empty_message, transform=ax1.transAxes, bbox=props) + imgs = [] - img2 = ax2.contourf(lons, lats, d2_cyclic, transform=ccrs.PlateCarree(), colors="w", norm=norm1) - ax2.text(0.4, 0.4, empty_message, transform=ax2.transAxes, bbox=props) - else: - img1 = ax1.contourf(lons, lats, d1_cyclic, transform=ccrs.PlateCarree(), cmap=cmap1, norm=norm1, levels=levels1) - img2 = ax2.contourf(lons, lats, d2_cyclic, transform=ccrs.PlateCarree(), cmap=cmap1, norm=norm1, levels=levels1) - - if len(levs_pctdiff) < 2: - img3 = ax3.contourf(lons, lats, pct_cyclic, transform=ccrs.PlateCarree(), colors="w", norm=pctnorm, transform_first=True) - ax3.text(0.4, 0.4, empty_message, transform=ax3.transAxes, bbox=props) - else: - img3 = ax3.contourf(lons, lats, pct_cyclic, transform=ccrs.PlateCarree(), cmap=cmappct, norm=pctnorm, levels=levelspctdiff, transform_first=True) - - if len(levs_diff) < 2: - img4 = ax4.contourf(lons, lats, dif_cyclic, transform=ccrs.PlateCarree(), colors="w", norm=dnorm) - ax4.text(0.4, 0.4, empty_message, transform=ax4.transAxes, bbox=props) - else: - img4 = ax4.contourf(lons, lats, dif_cyclic, transform=ccrs.PlateCarree(), cmap=cmapdiff, norm=dnorm, levels=levelsdiff) - + # Loop over data arrays to make plots + for i, a in enumerate(wrap_fields): + if i == len(wrap_fields)-1: + levels = cp_info['levelsdiff'] + cmap = cp_info['cmapdiff'] + norm = cp_info['normdiff'] + elif i == len(wrap_fields)-2: + levels = cp_info['levelspctdiff'] + cmap = cp_info['cmappct'] + norm = cp_info['pctnorm'] + else: + levels = cp_info['levels1'] + cmap = cp_info['cmap1'] + norm = cp_info['norm1'] + if unstructured: + #configure for polycollection plotting + #TODO, would be nice to have levels set from the info, above + print("AHHHHHH2",i,type(a), type(a.uxgrid)) + ac = a.to_polycollection(projection=proj) + #ac.norm(norms[i]) + ac.set_cmap(cmap) + ac.set_antialiased(False) + ac.set_transform(proj) + ac.set_clim(vmin=levels[0],vmax=levels[-1]) + axs[i].add_collection(ac) + imgs.append(ac) + else: + + levs = np.unique(np.array(levels)) + if len(levs) < 2: + imgs.append(axs[i].contourf(lons,lats,a,colors="w",transform=ccrs.PlateCarree(),transform_first=True)) + axs[i].text(0.4, 0.4, empty_message, transform=axs[i].transAxes, bbox=props) + else: + imgs.append(axs[i].contourf(lons, lats, a, levels=levels, cmap=cmap, norm=norm, + transform=ccrs.PlateCarree(), #transform_first=True, + **cp_info['contourf_opt'])) + #End if + #End if unstructured + + # Set stats for title + stat_mean = f"Mean: {means[i]:5.2f}" + stat_max = f"Max: {maxs[i]:5.2f}" + stat_min = f"Min: {mins[i]:5.2f}" + stats = f"{stat_mean}\n{stat_max}\n{stat_min}" + axs[i].set_title(stats, loc='right', fontsize=8) + #End for + #Set Main title for subplots: st = fig.suptitle(wks.stem[:-5].replace("_"," - "), fontsize=18) st.set_y(0.95) #Set plot titles case_title = "$\mathbf{Test}:$"+f"{case_nickname}\nyears: {case_climo_yrs[0]}-{case_climo_yrs[-1]}" - ax1.set_title(case_title, loc='left', fontsize=6) #fontsize=tiFontSize + axs[0].set_title(case_title, loc='left', fontsize=8) #fontsize=tiFontSize if obs: obs_var = kwargs["obs_var_name"] obs_title = kwargs["obs_file"][:-3] base_title = "$\mathbf{Baseline}:$"+obs_title+"\n"+"$\mathbf{Variable}:$"+f"{obs_var}" - ax2.set_title(base_title, loc='left', fontsize=6) #fontsize=tiFontSize + axs[1].set_title(base_title, loc='left', fontsize=8) #fontsize=tiFontSize else: base_title = "$\mathbf{Baseline}:$"+f"{base_nickname}\nyears: {baseline_climo_yrs[0]}-{baseline_climo_yrs[-1]}" - ax2.set_title(base_title, loc='left', fontsize=6) - - ax1.text(-0.2, -0.10, f"Mean: {d1_region_mean:5.2f}\nMax: {d1_region_max:5.2f}\nMin: {d1_region_min:5.2f}", transform=ax1.transAxes) + axs[1].set_title(base_title, loc='left', fontsize=8) - ax2.text(-0.2, -0.10, f"Mean: {d2_region_mean:5.2f}\nMax: {d2_region_max:5.2f}\nMin: {d2_region_min:5.2f}", transform=ax2.transAxes) - - ax3.text(-0.2, -0.10, f"Mean: {pct_region_mean:5.2f}\nMax: {pct_region_max:5.2f}\nMin: {pct_region_min:5.2f}", transform=ax3.transAxes) - ax3.set_title("Test % diff Baseline", loc='left', fontsize=8) - - ax4.text(-0.2, -0.10, f"Mean: {dif_region_mean:5.2f}\nMax: {dif_region_max:5.2f}\nMin: {dif_region_min:5.2f}", transform=ax4.transAxes) - ax4.set_title("$\mathbf{Test} - \mathbf{Baseline}$", loc='left', fontsize=8) + axs[2].set_title("Test % Diff Baseline", loc='left', fontsize=8,fontweight="bold") + axs[3].set_title("$\mathbf{Test} - \mathbf{Baseline}$", loc='left', fontsize=8) if "units" in kwargs: - ax2.set_ylabel(kwargs["units"]) - ax4.set_ylabel(kwargs["units"]) + axs[1].set_ylabel(kwargs["units"]) + axs[3].set_ylabel(kwargs["units"]) else: - ax2.set_ylabel(f"{d1.units}") - ax4.set_ylabel(f"{d1.units}") - - [a.set_extent(domain, ccrs.PlateCarree()) for a in [ax1, ax2, ax3, ax4]] - [a.coastlines() for a in [ax1, ax2, ax3, ax4]] - - # __Follow the cartopy gallery example to make circular__: - # Compute a circle in axes coordinates, which we can use as a boundary - # for the map. We can pan/zoom as much as we like - the boundary will be - # permanently circular. - theta = np.linspace(0, 2*np.pi, 100) - center, radius = [0.5, 0.5], 0.5 - verts = np.vstack([np.sin(theta), np.cos(theta)]).T - circle = mpl.path.Path(verts * radius + center) - [a.set_boundary(circle, transform=a.transAxes) for a in [ax1, ax2, ax3, ax4]] + axs[1].set_ylabel(f"{d1.units}") + axs[3].set_ylabel(f"{d1.units}") + + for a in axs: + a.coastlines() + a.set_extent(domain, ccrs.PlateCarree()) + # __Follow the cartopy gallery example to make circular__: + # Compute a circle in axes coordinates, which we can use as a boundary + # for the map. We can pan/zoom as much as we like - the boundary will be + # permanently circular. + theta = np.linspace(0, 2*np.pi, 100) + center, radius = [0.5, 0.5], 0.5 + verts = np.vstack([np.sin(theta), np.cos(theta)]).T + circle = mpl.path.Path(verts * radius + center) + a.set_boundary(circle, transform=a.transAxes) + a.gridlines(draw_labels=False, crs=ccrs.PlateCarree(), + lw=1, color="gray",y_inline=True, + xlocs=range(-180,180,90), ylocs=range(0,90,10)) # __COLORBARS__ - cb_mean_ax = inset_axes(ax2, + cb_mean_ax = inset_axes(axs[1], width="5%", # width = 5% of parent_bbox width height="90%", # height : 90% loc='lower left', bbox_to_anchor=(1.05, 0.05, 1, 1), - bbox_transform=ax2.transAxes, + bbox_transform=axs[1].transAxes, borderpad=0, ) - fig.colorbar(img1, cax=cb_mean_ax) + fig.colorbar(imgs[0], cax=cb_mean_ax) - cb_pct_ax = inset_axes(ax3, + cb_pct_ax = inset_axes(axs[3], width="5%", # width = 5% of parent_bbox width height="90%", # height : 90% loc='lower left', bbox_to_anchor=(1.05, 0.05, 1, 1), - bbox_transform=ax3.transAxes, + bbox_transform=axs[3].transAxes, borderpad=0, ) - cb_diff_ax = inset_axes(ax4, + cb_diff_ax = inset_axes(axs[2], width="5%", # width = 5% of parent_bbox width height="90%", # height : 90% loc='lower left', bbox_to_anchor=(1.05, 0.05, 1, 1), - bbox_transform=ax4.transAxes, + bbox_transform=axs[2].transAxes, borderpad=0, ) - fig.colorbar(img3, cax=cb_pct_ax) + fig.colorbar(imgs[3], cax=cb_pct_ax) - fig.colorbar(img4, cax=cb_diff_ax) + fig.colorbar(imgs[2], cax=cb_diff_ax) # Save files fig.savefig(wks, bbox_inches='tight', dpi=300) @@ -904,6 +1014,7 @@ def make_polar_plot(wks, case_nickname, base_nickname, ####### + def plot_map_vect_and_save(wks, case_nickname, base_nickname, case_climo_yrs, baseline_climo_yrs, plev, umdlfld_nowrap, vmdlfld_nowrap, @@ -1143,9 +1254,11 @@ def plot_map_vect_and_save(wks, case_nickname, base_nickname, ####### + def plot_map_and_save(wks, case_nickname, base_nickname, case_climo_yrs, baseline_climo_yrs, - mdlfld, obsfld, diffld, pctld, obs=False, **kwargs): + mdlfld, obsfld, diffld, pctld, unstructured=False, + obs=False, **kwargs): """This plots mdlfld, obsfld, diffld in a 3-row panel plot of maps. Parameters @@ -1203,24 +1316,35 @@ def plot_map_and_save(wks, case_nickname, base_nickname, from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter # preprocess - # - assume all three fields have same lat/lon - lat = obsfld['lat'] - wgt = np.cos(np.radians(lat)) - mwrap, lon = add_cyclic_point(mdlfld, coord=mdlfld['lon']) - owrap, _ = add_cyclic_point(obsfld, coord=obsfld['lon']) - dwrap, _ = add_cyclic_point(diffld, coord=diffld['lon']) - pwrap, _ = add_cyclic_point(pctld, coord=pctld['lon']) - wrap_fields = (mwrap, owrap, pwrap, dwrap) - # mesh for plots: - lons, lats = np.meshgrid(lon, lat) - # Note: using wrapped data makes spurious lines across plot (maybe coordinate dependent) - lon2, lat2 = np.meshgrid(mdlfld['lon'], mdlfld['lat']) - - # get statistics (from non-wrapped) - fields = (mdlfld, obsfld, diffld, pctld) - area_avg = [spatial_average(x, weights=wgt, spatial_dims=None) for x in fields] + if not unstructured: + # - assume all three fields have same lat/lon + lat = obsfld['lat'] + wgt = np.cos(np.radians(lat)) + mwrap, lon = add_cyclic_point(mdlfld, coord=mdlfld['lon']) + owrap, _ = add_cyclic_point(obsfld, coord=obsfld['lon']) + dwrap, _ = add_cyclic_point(diffld, coord=diffld['lon']) + pwrap, _ = add_cyclic_point(pctld, coord=pctld['lon']) + wrap_fields = (mwrap, owrap, pwrap, dwrap) + # mesh for plots: + lons, lats = np.meshgrid(lon, lat) + # Note: using wrapped data makes spurious lines across plot (maybe coordinate dependent) + lon2, lat2 = np.meshgrid(mdlfld['lon'], mdlfld['lat']) + + # get statistics (from non-wrapped) + fields = (mdlfld, obsfld, pctld, diffld) + area_avg = [spatial_average(x, weights=wgt, spatial_dims=None) for x in fields] + + d_rmse = wgt_rmse(mdlfld, obsfld, wgt) # correct weighted RMSE for (lat,lon) fields. + # specify the central longitude for the plot + central_longitude = kwargs.get('central_longitude', 180) + else: + wgt = kwargs["wgt"] + wrap_fields = (mdlfld, obsfld, pctld, diffld) + area_avg = [global_average(x, wgt) for x in wrap_fields] - d_rmse = wgt_rmse(mdlfld, obsfld, wgt) # correct weighted RMSE for (lat,lon) fields. + # TODO Check this is correct, weighted rmse uses xarray weighted function + #d_rmse = wgt_rmse(a, b, wgt) + d_rmse = (np.sqrt(((diffld**2)*wgt).sum())).values.item() # We should think about how to do plot customization and defaults. # Here I'll just pop off a few custom ones, and then pass the rest into mpl. @@ -1236,12 +1360,11 @@ def plot_map_and_save(wks, case_nickname, base_nickname, tiFontSize = 8 #End if + central_longitude = kwargs.get('central_longitude', 180) + # generate dictionary of contour plot settings: cp_info = prep_contour_plot(mdlfld, obsfld, diffld, pctld, **kwargs) - # specify the central longitude for the plot - central_longitude = kwargs.get('central_longitude', 180) - # create figure object fig = plt.figure(figsize=(14,10)) @@ -1279,15 +1402,37 @@ def plot_map_and_save(wks, case_nickname, base_nickname, levels = cp_info['levels1'] cmap = cp_info['cmap1'] norm = cp_info['norm1'] - - levs = np.unique(np.array(levels)) - if len(levs) < 2: - img.append(ax[i].contourf(lons,lats,a,colors="w",transform=ccrs.PlateCarree(),transform_first=True)) - ax[i].text(0.4, 0.4, empty_message, transform=ax[i].transAxes, bbox=props) + + # Unstructured grid check + if not unstructured: + levs = np.unique(np.array(levels)) + if len(levs) < 2: + img.append(ax[i].contourf(lons,lats,a,colors="w",transform=ccrs.PlateCarree(),transform_first=True)) + ax[i].text(0.4, 0.4, empty_message, transform=ax[i].transAxes, bbox=props) + else: + img.append(ax[i].contourf(lons, lats, a, levels=levels, cmap=cmap, norm=norm, transform=ccrs.PlateCarree(), transform_first=True, **cp_info['contourf_opt'])) + #End if else: - img.append(ax[i].contourf(lons, lats, a, levels=levels, cmap=cmap, norm=norm, transform=ccrs.PlateCarree(), transform_first=True, **cp_info['contourf_opt'])) - #End if - ax[i].set_title("AVG: {0:.3f}".format(area_avg[i]), loc='right', fontsize=11) + #configure for polycollection plotting + #TODO, would be nice to have levels set from the info, above + ac = a.to_polycollection(projection=proj) + img.append(ac) + #ac.norm(norm) + ac.set_cmap(cmap) + ac.set_antialiased(False) + ac.set_transform(proj) + ac.set_clim(vmin=levels[0],vmax=levels[-1]) + ax[i].add_collection(ac) + """if i > 0: + cbar = plt.colorbar(ac, ax=ax[i], orientation='vertical', + pad=0.05, shrink=0.8, **cp_info['colorbar_opt']) + #TODO keep variable attributes on dataarrays + #cbar.set_label(wrap_fields[i].attrs['units'])""" + # End if unstructured grid + + #ax[i].set_title("AVG: {0:.3f}".format(area_avg[i]), loc='right', fontsize=11) + ax[i].set_title(f"Mean: {area_avg[i].item():5.2f}\nMax: {wrap_fields[i].max().item():5.2f}\nMin: {wrap_fields[i].min().item():5.2f}", + loc='right', fontsize=tiFontSize) # add contour lines <- Unused for now -JN # TODO: add an option to turn this on -BM @@ -1296,6 +1441,19 @@ def plot_map_and_save(wks, case_nickname, base_nickname, #ax[i].text( 10, -140, "CONTOUR FROM {} to {} by {}".format(min(cs[i].levels), max(cs[i].levels), cs[i].levels[1]-cs[i].levels[0]), #bbox=dict(facecolor='none', edgecolor='black'), fontsize=tiFontSize-2) + # Custom setting for each subplot + for a in ax: + a.coastlines() + #if projection=='global': + a.set_global() + a.spines['geo'].set_linewidth(1.5) #cartopy's recommended method + a.set_xticks(np.linspace(-180, 120, 6), crs=proj) + a.set_yticks(np.linspace(-90, 90, 7), crs=proj) + a.tick_params('both', length=5, width=1.5, which='major') + a.tick_params('both', length=5, width=1.5, which='minor') + a.xaxis.set_major_formatter(lon_formatter) + a.yaxis.set_major_formatter(lat_formatter) + st = fig.suptitle(wks.stem[:-5].replace("_"," - "), fontsize=18) st.set_y(0.85) @@ -1312,31 +1470,11 @@ def plot_map_and_save(wks, case_nickname, base_nickname, base_title = "$\mathbf{Baseline}:$"+f"{base_nickname}\nyears: {baseline_climo_yrs[0]}-{baseline_climo_yrs[-1]}" ax[1].set_title(base_title, loc='left', fontsize=tiFontSize) - #Set stats: area_avg - ax[0].set_title(f"Mean: {mdlfld.weighted(wgt).mean().item():5.2f}\nMax: {mdlfld.max():5.2f}\nMin: {mdlfld.min():5.2f}", loc='right', - fontsize=tiFontSize) - ax[1].set_title(f"Mean: {obsfld.weighted(wgt).mean().item():5.2f}\nMax: {obsfld.max():5.2f}\nMin: {obsfld.min():5.2f}", loc='right', - fontsize=tiFontSize) - ax[2].set_title(f"Mean: {pctld.weighted(wgt).mean().item():5.2f}\nMax: {pctld.max():5.2f}\nMin: {pctld.min():5.2f}", loc='right', - fontsize=tiFontSize) - ax[3].set_title(f"Mean: {diffld.weighted(wgt).mean().item():5.2f}\nMax: {diffld.max():5.2f}\nMin: {diffld.min():5.2f}", loc='right', - fontsize=tiFontSize) - # set rmse title: ax[3].set_title(f"RMSE: {d_rmse:.3f}", fontsize=tiFontSize) ax[3].set_title("$\mathbf{Test} - \mathbf{Baseline}$", loc='left', fontsize=tiFontSize) ax[2].set_title("Test % Diff Baseline", loc='left', fontsize=tiFontSize,fontweight="bold") - for a in ax: - a.spines['geo'].set_linewidth(1.5) #cartopy's recommended method - a.coastlines() - a.set_xticks(np.linspace(-180, 120, 6), crs=ccrs.PlateCarree()) - a.set_yticks(np.linspace(-90, 90, 7), crs=ccrs.PlateCarree()) - a.tick_params('both', length=5, width=1.5, which='major') - a.tick_params('both', length=5, width=1.5, which='minor') - a.xaxis.set_major_formatter(lon_formatter) - a.yaxis.set_major_formatter(lat_formatter) - # __COLORBARS__ cb_mean_ax = inset_axes(ax2, width="5%", # width = 5% of parent_bbox width @@ -1377,7 +1515,206 @@ def plot_map_and_save(wks, case_nickname, base_nickname, plt.close() -# +### + + +def plot_unstructured_map_and_save(wks, case_nickname, base_nickname, + case_climo_yrs, baseline_climo_yrs, + mdlfld, obsfld, diffld, pctld, wgt, + obs=False, projection='global',**kwargs): + + """This plots mdlfld, obsfld, diffld in a 3-row panel plot of maps. + + Parameters + ---------- + wks : str or Path + output file path + case_nickname : str + short name for case + base_nickname : str + short name for base case + case_climo_yrs : list + list of years in case climatology, used for annotation + baseline_climo_yrs : list + list of years in base case climatology, used for annotation + mdlfld : uxarray.DataArray + input data for case, needs units and long name attrubutes + obsfld : uxarray.DataArray + input data for base case, needs units and long name attrubutes + diffld : uxarray.DataArray + input difference data, needs units and long name attrubutes + pctld : uxarray.DataArray + input percent difference data, needs units and long name attrubutes + wgt : uxarray.DataArray + weights assumed to be (area*landfrac)/(area*landfrac).sum() + kwargs : dict, optional + variable-specific options, See Notes + + Notes + ----- + kwargs expected to be a variable-specific section, + possibly provided by an ADF Variable Defaults YAML file. + Currently it is inspected for: + - colormap -> str, name of matplotlib colormap + - contour_levels -> list of explict values or a tuple: (min, max, step) + - diff_colormap + - diff_contour_levels + - tiString -> str, Title String + - tiFontSize -> int, Title Font Size + - mpl -> dict, This should be any matplotlib kwargs that should be passed along. Keep reading: + + Organize these by the mpl function. In this function (`plot_map_and_save`) + we will check for an entry called `subplots`, `contourf`, and `colorbar`. So the YAML might looks something like: + ``` + mpl: + subplots: + figsize: (3, 9) + contourf: + levels: 15 + cmap: Blues + colorbar: + shrink: 0.4 + ``` + + This is experimental, and if you find yourself doing much with this, you probably should write a new plotting script that does not rely on this module. + When these are not provided, colormap is set to 'coolwarm' and limits/levels are set by data range. + """ + + # prepare info for plotting + wrap_fields = (mdlfld, obsfld, diffld, pctld) + area_avg = [global_average(x, wgt) for x in wrap_fields] + + # TODO Check this is correct, weighted rmse uses xarray weighted function + #d_rmse = wgt_rmse(a, b, wgt) + d_rmse = (np.sqrt(((diffld**2)*wgt).sum())).values.item() + + # We should think about how to do plot customization and defaults. + # Here I'll just pop off a few custom ones, and then pass the rest into mpl. + if 'tiString' in kwargs: + tiString = kwargs.pop("tiString") + else: + tiString = '' + + if 'tiFontSize' in kwargs: + tiFontSize = kwargs.pop('tiFontSize') + else: + tiFontSize = 8 + + #generate a dictionary of contour plot settings: + cp_info = prep_contour_plot(mdlfld, obsfld, diffld, pctld, **kwargs) + + if projection == 'global': + transform = ccrs.PlateCarree() + proj = ccrs.PlateCarree() + figsize= (14, 7) + elif projection == 'arctic': + transform = ccrs.NorthPolarStereo() + proj = ccrs.NorthPolarStereo() + figsize = (8, 8) + + #nice formatting for tick labels + from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter + lon_formatter = LongitudeFormatter(number_format='0.0f', + degree_symbol='', + dateline_direction_label=False) + lat_formatter = LatitudeFormatter(number_format='0.0f', + degree_symbol='') + + # create figure object + fig, axs = plt.subplots(2,2, + figsize=figsize, + facecolor="w", + constrained_layout=True, + subplot_kw=dict(projection=proj), + **cp_info['subplots_opt'] + ) + axs=axs.flatten() + + # Loop over data arrays to make plots + for i, a in enumerate(wrap_fields): + if i == len(wrap_fields)-2: + levels = cp_info['levelsdiff'] + cmap = cp_info['cmapdiff'] + norm = cp_info['normdiff'] + elif i == len(wrap_fields)-1: + levels = cp_info['levelspctdiff'] + cmap = cp_info['cmappct'] + norm = cp_info['pctnorm'] + else: + levels = cp_info['levels1'] + cmap = cp_info['cmap1'] + norm = cp_info['norm1'] + + levs = np.unique(np.array(levels)) + + #configure for polycollection plotting + #TODO, would be nice to have levels set from the info, above + ac = a.to_polycollection(projection=proj) + #ac.norm(norm) + ac.set_cmap(cmap) + ac.set_antialiased(False) + ac.set_transform(transform) + ac.set_clim(vmin=levels[0],vmax=levels[-1]) + axs[i].add_collection(ac) + if i > 0: + cbar = plt.colorbar(ac, ax=axs[i], orientation='vertical', + pad=0.05, shrink=0.8, **cp_info['colorbar_opt']) + #TODO keep variable attributes on dataarrays + #cbar.set_label(wrap_fields[i].attrs['units']) + #Set stats: area_avg + axs[i].set_title(f"Mean: {area_avg[i].item():5.2f}\nMax: {wrap_fields[i].max().item():5.2f}\nMin: {wrap_fields[i].min().item():5.2f}", + loc='right', fontsize=tiFontSize) + + # Custom setting for each subplot + for a in axs: + a.coastlines() + if projection=='global': + a.set_global() + a.spines['geo'].set_linewidth(1.5) #cartopy's recommended method + a.set_xticks(np.linspace(-180, 120, 6), crs=proj) + a.set_yticks(np.linspace(-90, 90, 7), crs=proj) + a.tick_params('both', length=5, width=1.5, which='major') + a.tick_params('both', length=5, width=1.5, which='minor') + a.xaxis.set_major_formatter(lon_formatter) + a.yaxis.set_major_formatter(lat_formatter) + elif projection == 'arctic': + a.set_extent([-180, 180, 50, 90], ccrs.PlateCarree()) + # __Follow the cartopy gallery example to make circular__: + # Compute a circle in axes coordinates, which we can use as a boundary + # for the map. We can pan/zoom as much as we like - the boundary will be + # permanently circular. + theta = np.linspace(0, 2*np.pi, 100) + center, radius = [0.5, 0.5], 0.5 + verts = np.vstack([np.sin(theta), np.cos(theta)]).T + circle = mpl.path.Path(verts * radius + center) + a.set_boundary(circle, transform=a.transAxes) + a.gridlines(draw_labels=False, crs=ccrs.PlateCarree(), + lw=1, color="gray",y_inline=True, + xlocs=range(-180,180,90), ylocs=range(0,90,10)) + + st = fig.suptitle(wks.stem[:-5].replace("_"," - "), fontsize=18) + st.set_y(0.85) + + #Set plot titles + case_title = "$\mathbf{Test}:$"+f"{case_nickname}\nyears: {case_climo_yrs[0]}-{case_climo_yrs[-1]}" + axs[0].set_title(case_title, loc='left', fontsize=tiFontSize) + if obs: + obs_var = kwargs["obs_var_name"] + obs_title = kwargs["obs_file"][:-3] + base_title = "$\mathbf{Baseline}:$"+obs_title+"\n"+"$\mathbf{Variable}:$"+f"{obs_var}" + axs[1].set_title(base_title, loc='left', fontsize=tiFontSize) + else: + base_title = "$\mathbf{Baseline}:$"+f"{base_nickname}\nyears: {baseline_climo_yrs[0]}-{baseline_climo_yrs[-1]}" + axs[1].set_title(base_title, loc='left', fontsize=tiFontSize) + axs[2].set_title("$\mathbf{Test} - \mathbf{Baseline}$", loc='left', fontsize=tiFontSize) + axs[2].set_title(f"RMSE: {d_rmse:.3f}", fontsize=tiFontSize) + axs[3].set_title("Test % Diff Baseline", loc='left', fontsize=tiFontSize,fontweight="bold") + + fig.savefig(wks, bbox_inches='tight', dpi=300) + + #Close plots: + plt.close() + +## End of plot_unstructured_map_and_save + # -- vertical interpolation code -- # @@ -1835,6 +2172,12 @@ def prep_contour_plot(adata, bdata, diffdata, pctdata, **kwargs): minval = np.min([np.min(adata), np.min(bdata)]) maxval = np.max([np.max(adata), np.max(bdata)]) + # determine levels & color normalization: + minval = np.min([np.min(adata), np.min(bdata)]) + maxval = np.max([np.max(adata), np.max(bdata)]) + absmaxdif = np.max(np.abs(diffdata)) + absmaxpct = np.max(np.abs(pctdata)) + # determine norm to use (deprecate this once minimum MPL version is high enough) normfunc, mplv = use_this_norm() @@ -1933,6 +2276,30 @@ def prep_contour_plot(adata, bdata, diffdata, pctdata, **kwargs): else: normdiff = mpl.colors.Normalize(vmin=np.min(levelsdiff), vmax=np.max(levelsdiff)) + #NOTE: Sometimes the contour levels chosen in the defaults file + #can result in the "contourf" software stack generating a + #'TypologyException', which should manifest itself as a + #"PredicateError", but due to bugs in the stack itself + #will also sometimes raise an AttributeError. + + #To prevent this from happening, the polar max and min values + #are calculated, and if the default contour values are significantly + #larger then the min-max values, then the min-max values are used instead: + #------------------------------- + if max(levels1) > 10*maxval: + levels1 = np.linspace(minval, maxval, 12) + norm1 = mpl.colors.Normalize(vmin=minval, vmax=maxval) + elif minval < 0 and min(levels1) < 10*minval: + levels1 = np.linspace(minval, maxval, 12) + norm1 = mpl.colors.Normalize(vmin=minval, vmax=maxval) + #End if + + if max(np.abs(levelsdiff)) > 10*absmaxdif: + levelsdiff = np.linspace(-1*absmaxdif, absmaxdif, 12) + + #End if + #------------------------------- + subplots_opt = {} contourf_opt = {} colorbar_opt = {} @@ -2035,8 +2402,12 @@ def plot_zonal_mean_and_save(wks, case_nickname, base_nickname, # calculate the percent change pct = (azm - bzm) / np.abs(bzm) * 100.0 #check if pct has NaN's or Inf values and if so set them to 0 to prevent plotting errors - pct = pct.where(np.isfinite(pct), np.nan) - pct = pct.fillna(0.0) + pct_0 = pct.where(np.isfinite(pct), np.nan) + pct_0 = pct_0.fillna(0.0) + if isinstance(pct, ux.UxDataArray): + pct = ux.UxDataArray(pct_0) + else: + pct = pct_0 # generate dictionary of contour plot settings: cp_info = prep_contour_plot(azm, bzm, diff, pct, **kwargs) @@ -2104,8 +2475,12 @@ def plot_zonal_mean_and_save(wks, case_nickname, base_nickname, # calculate the percent change pct = (azm - bzm) / np.abs(bzm) * 100.0 #check if pct has NaN's or Inf values and if so set them to 0 to prevent plotting errors - pct = pct.where(np.isfinite(pct), np.nan) - pct = pct.fillna(0.0) + pct_0 = pct.where(np.isfinite(pct), np.nan) + pct_0 = pct_0.fillna(0.0) + if isinstance(pct, ux.UxDataArray): + pct = ux.UxDataArray(pct_0) + else: + pct = pct_0 fig, ax = plt.subplots(nrows=3) ax = [ax[0],ax[1],ax[2]] @@ -2145,7 +2520,7 @@ def plot_zonal_mean_and_save(wks, case_nickname, base_nickname, def plot_meridional_mean_and_save(wks, case_nickname, base_nickname, case_climo_yrs, baseline_climo_yrs, - adata, bdata, has_lev, latbounds=None, obs=False, **kwargs): + adata, bdata, has_lev, log_p, latbounds=None, obs=False, **kwargs): """Default meridional mean plot @@ -2255,8 +2630,12 @@ def plot_meridional_mean_and_save(wks, case_nickname, base_nickname, # calculate the percent change pct = (adata - bdata) / np.abs(bdata) * 100.0 #check if pct has NaN's or Inf values and if so set them to 0 to prevent plotting errors - pct = pct.where(np.isfinite(pct), np.nan) - pct = pct.fillna(0.0) + pct_0 = pct.where(np.isfinite(pct), np.nan) + pct_0 = pct_0.fillna(0.0) + if isinstance(pct, ux.UxDataArray): + pct = ux.UxDataArray(pct_0) + else: + pct = pct_0 # plot-controlling parameters: xdim = 'lon' # the name used for the x-axis dimension @@ -2318,8 +2697,12 @@ def plot_meridional_mean_and_save(wks, case_nickname, base_nickname, st = fig.suptitle(wks.stem[:-5].replace("_"," - "), fontsize=15) st.set_y(0.85) ax[-1].set_xlabel("LONGITUDE") - if cp_info['plot_log_p']: + #if cp_info['plot_log_p']: + # [a.set_yscale("log") for a in ax] + + if log_p: [a.set_yscale("log") for a in ax] + fig.text(-0.03, 0.5, 'PRESSURE [hPa]', va='center', rotation='vertical') else: @@ -2467,8 +2850,12 @@ def square_contour_difference(fld1, fld2, **kwargs): pct = (fld1 - fld2) / np.abs(fld2) * 100.0 #check if pct has NaN's or Inf values and if so set them to 0 to prevent plotting errors - pct = pct.where(np.isfinite(pct), np.nan) - pct = pct.fillna(0.0) + pct_0 = pct.where(np.isfinite(pct), np.nan) + pct_0 = pct_0.fillna(0.0) + if isinstance(pct, ux.UxDataArray): + pct = ux.UxDataArray(pct_0) + else: + pct = pct_0 ## USE A DIVERGING COLORMAP CENTERED AT ZERO ## Special case is when min > 0 or max < 0 From aceff02dd0e2a51d9131a7637329e7feb8516d63 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:27:57 -0600 Subject: [PATCH 007/126] Create utils.py --- lib/utils.py | 338 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 338 insertions(+) create mode 100644 lib/utils.py diff --git a/lib/utils.py b/lib/utils.py new file mode 100644 index 000000000..70987365a --- /dev/null +++ b/lib/utils.py @@ -0,0 +1,338 @@ +# utils.py + +def check_unstructured(ds, case): + """ + Check if a dataset is unstructured based on its dimensions. + """ + if ('lat' not in ds.dims) and ('lon' not in ds.dims): + if ('ncol' in ds.dims) or ('lndgrid' in ds.dims): + message = f"Looks like the case '{case}' is unstructured, eh!" + print(message) + return True + return False + + +from pathlib import Path +import os +from adf_base import AdfError + +def grid_timeseries(**kwargs): + #regrd_ts_loc = Path(test_output_loc[case_idx]) + # Check if time series directory exists, and if not, then create it: + # Use pathlib to create parent directories, if necessary. + + ts_dir = Path(kwargs["ts_dir"]) + method = kwargs["method"] + weight_file = kwargs["wgts_file"] + latlon_file = kwargs["latlon_file"] + time_file = kwargs["time_file"] + comp = kwargs["comp"] + diag_var_list = kwargs["diag_var_list"] + case_name = kwargs["case_name"] + hist_str = kwargs["hist_str"] + time_string = kwargs["time_string"] + + regrd_ts_loc = ts_dir / "regrid" + Path(regrd_ts_loc).mkdir(parents=True, exist_ok=True) + # Check that path actually exists: + if not regrd_ts_loc.is_dir(): + print(f" {regrd_ts_loc} not found, making new directory") + regrd_ts_loc.mkdir(parents=True) + + #Check if any a weights file exists if using native grid, OPTIONAL + if not latlon_file: + msg = "WARNING: This looks like an unstructured case, but missing weights file, can't continue." + raise AdfError(msg) + + for var in diag_var_list: + print("VAR",var,"\n") + ts_ds = xr.open_dataset(sorted(ts_dir.glob(f"*.{var}.*nc"))[0]) + + # Store the original cftime time values + #print("ts_ds['time']",ts_ds['time'],"\n\n") + original_time = ts_ds['time'].values + + rgdata = unstructure_regrid(ts_ds, var, comp=comp, + wgt_file=weight_file, + latlon_file=latlon_file, + time_file=time_file, + method=method) + # Copy global attributes + rgdata.attrs = ts_ds.attrs.copy() + attrs_dict = { + #"adf_user": adf.user, + #"climo_yrs": f"{case_name}: {syear}-{eyear}", + #"climatology_files": climatology_files_str, + "native_grid_to_latlon":f"xesmf Regridder; method: {method}" + } + ts_outfil_str = (str(ts_dir) + + os.sep + + ".".join([case_name, hist_str, var, time_string, "nc"]) + ) + regridded_file_loc = regrd_ts_loc / Path(ts_outfil_str).parts[-1].replace(".nc","_gridded.nc") + #rgdata = rgdata.assign_attrs(attrs_dict) + # Restore the original cftime time values + rgdata = rgdata.assign_coords(time=('time', original_time)) + #print("regridded_file_loc",rgdata.time,"\n\n") + save_to_nc(rgdata, regridded_file_loc) + #self.adf.native_grid[f"{case_type_string}_native_grid"] = False + + #file_path = os.path.join(dir_path, file_name) + #os.remove(ts_outfil_str) + #print("ts_outfil_str before death: ",ts_outfil_str,"\n") + #sorted(ts_dir.glob(f"*.{var}.*nc"))[0].unlink() + + + + +# Regrids unstructured SE grid to regular lat-lon +# Shamelessly borrowed from @maritsandstad with NorESM who deserves credit for this work +# https://github.com/NorESMhub/xesmf_clm_fates_diagnostic/blob/main/src/xesmf_clm_fates_diagnostic/plotting_methods.py + +import xarray as xr +import xesmf +import numpy as np + +def make_se_ts_regridder(weight_file,s_data,d_data, + Method='coservative' + ): + # Intialize dict for xesmf.Regridder + #regridder_kwargs = {} + + if weight_file: + weights = xr.open_dataset(weight_file) + #regridder_kwargs['weights'] = weights + else: + print("No weights file given!") + # regridder_kwargs['method'] = 'coservative' + + in_shape = weights.src_grid_dims.load().data + + # Since xESMF expects 2D vars, we'll insert a dummy dimension of size-1 + if len(in_shape) == 1: + in_shape = [1, in_shape.item()] + + # output variable shape + out_shape = weights.dst_grid_dims.load().data.tolist()[::-1] + + dummy_in = xr.Dataset( + { + "lat": ("lat", np.empty((in_shape[0],))), + "lon": ("lon", np.empty((in_shape[1],))), + } + ) + dummy_out = xr.Dataset( + { + "lat": ("lat", weights.yc_b.data.reshape(out_shape)[:, 0]), + "lon": ("lon", weights.xc_b.data.reshape(out_shape)[0, :]), + } + ) + + if isinstance(s_data, xr.DataArray): + s_mask = xr.DataArray(s_data.data.reshape(in_shape[0],in_shape[1]), dims=("lat", "lon")) + dummy_in['mask']= s_mask + if isinstance(d_data, xr.DataArray): + d_mask = xr.DataArray(d_data.values, dims=("lat", "lon")) + dummy_out['mask']= d_mask + + # do source and destination grids need masks here? + # See xesmf docs https://xesmf.readthedocs.io/en/stable/notebooks/Masking.html#Regridding-with-a-mask + regridder = xesmf.Regridder( + dummy_in, + dummy_out, + weights=weight_file, + # results seem insensitive to this method choice + # choices are coservative_normed, coservative, and bilinear + method=Method, + reuse_weights=True, + periodic=True, + ) + return regridder + +import xarray as xr +import xesmf +import numpy as np + +#def unstructure_regrid(model_dataset, var_name, comp, weight_file, latlon_file, method): +#def unstructure_regrid(model_dataset, var_name, comp, wgt_file, method, latlon_file=None): +def unstructure_regrid(model_dataset, var_name, comp, wgt_file, method, latlon_file, time_file, **kwargs): + """ + Function that takes a variable from a model xarray + dataset, regrids it to another dataset's lat/lon + coordinates (if applicable) + ---------- + model_dataset -> The xarray dataset which contains the model variable data + var_name -> The name of the variable to be regridded/interpolated. + comp -> + wgt_file -> + method -> + latlon_file -> + + Optional inputs: + + kwargs -> Keyword arguments that contain paths to THE REST IS NOT APPLICABLE: surface pressure + and mid-level pressure files, which are necessary for + certain types of vertical interpolation. + This function returns a new xarray dataset that contains the gridded + model variable. + """ + + #Import ADF-specific functions: + from regrid_se_to_fv import make_se_regridder, regrid_se_data_conservative, regrid_se_data_bilinear, regrid_atm_se_data_conservative, regrid_atm_se_data_bilinear + + if comp == "atm": + comp_grid = "ncol" + if comp == "lnd": + comp_grid = "lndgrid" + if latlon_file: + latlon_ds = xr.open_dataset(latlon_file) + else: + print("Looks like no lat lon file is supplied. God speed!") + + model_dataset[var_name] = model_dataset[var_name].fillna(0) + #mdata = model_dataset[var_name] + + if comp == "lnd": + model_dataset['landfrac'] = model_dataset['landfrac'].fillna(0) + #mdata = mdata * model_dataset.landfrac # weight flux by land frac + model_dataset[var_name] = model_dataset[var_name] * model_dataset.landfrac # weight flux by land frac + s_data = model_dataset.landmask#.isel(time=0) + d_data = latlon_ds.landmask + + """# Combine dimensions from both datasets while keeping ds2 attributes + d_data = xr.Dataset( + coords={"lat": latlon_ds["lat"], "lon": latlon_ds["lon"], "time": time_file["time"]}, + attrs=latlon_ds.attrs # Copy attributes from ds2 + ) + print("AHHHHHH",d_data,"\n\n") + # Add the 'temperature' variable from ds2 to new_ds + d_data["landmask"] = time_file["landmask"] + print("AHHHHHH2",d_data,"\n\n") + d_data = d_data.landmask""" + else: + s_data = None #mdata.isel(time=0) + d_data = None #latlon_ds[var_name] + print("AHHHHHH3",d_data,"\n\n") + #Grid model data to match target grid lat/lon: + regridder = make_se_ts_regridder(weight_file=wgt_file, + s_data = s_data, + d_data = d_data, + Method = method, + ) + + if comp == "lnd": + if method == 'coservative': + rgdata = regrid_se_data_conservative(regridder, model_dataset, comp_grid) + if method == 'bilinear': + rgdata = regrid_se_data_bilinear(regridder, model_dataset, comp_grid) + rgdata[var_name] = (rgdata[var_name] / rgdata.landfrac) + + if comp == "atm": + if method == 'coservative': + rgdata = regrid_atm_se_data_conservative(regridder, model_dataset, comp_grid) + if method == 'bilinear': + rgdata = regrid_atm_se_data_bilinear(regridder, model_dataset, comp_grid) + + + #rgdata['lat'] = latlon_ds.lat #??? + if comp == "lnd": + rgdata['landmask'] = latlon_ds.landmask + rgdata['landfrac'] = rgdata.landfrac#.isel(time=0) + + """new_ds = xr.Dataset( + coords={"lat": ds1["lat"], "lon": ds1["lon"], "time": ds2["time"]}, + attrs=ds2.attrs # Copy attributes from ds2 + ) + """ + # calculate area + rgdata = _calc_area(rgdata) + + #Return dataset: + return rgdata + + +def regrid_atm_se_data_bilinear(regridder, data_to_regrid, comp_grid='ncol'): + if isinstance(data_to_regrid, xr.Dataset): + vars_with_ncol = [name for name in data_to_regrid.variables if comp_grid in data_to_regrid[name].dims] + updated = data_to_regrid.copy().update(data_to_regrid[vars_with_ncol].transpose(..., comp_grid).expand_dims("dummy", axis=-2)) + elif isinstance(data_to_regrid, xr.DataArray): + updated = data_to_regrid.transpose(...,comp_grid).expand_dims("dummy",axis=-2) + else: + raise ValueError(f"Something is wrong because the data to regrid isn't xarray: {type(data_to_regrid)}") + regridded = regridder(updated) + return regridded + + +def regrid_atm_se_data_conservative(regridder, data_to_regrid, comp_grid='ncol'): + if isinstance(data_to_regrid, xr.Dataset): + vars_with_ncol = [name for name in data_to_regrid.variables if comp_grid in data_to_regrid[name].dims] + updated = data_to_regrid.copy().update(data_to_regrid[vars_with_ncol].transpose(..., comp_grid).expand_dims("dummy", axis=-2)) + elif isinstance(data_to_regrid, xr.DataArray): + updated = data_to_regrid.transpose(...,comp_grid).expand_dims("dummy",axis=-2) + else: + raise ValueError(f"Something is wrong because the data to regrid isn't xarray: {type(data_to_regrid)}") + regridded = regridder(updated,skipna=True, na_thres=1) + return regridded + + +def regrid_lnd_se_data_bilinear(regridder, data_to_regrid, comp_grid): + updated = data_to_regrid.copy().transpose(..., comp_grid).expand_dims("dummy", axis=-2) + regridded = regridder(updated.rename({"dummy": "lat", comp_grid: "lon"}), + skipna=True, na_thres=1, + ) + return regridded + + +def regrid_lnd_se_data_conservative(regridder, data_to_regrid, comp_grid): + updated = data_to_regrid.copy().transpose(..., comp_grid).expand_dims("dummy", axis=-2) + regridded = regridder(updated.rename({"dummy": "lat", comp_grid: "lon"}) ) + return regridded + + + +def save_to_nc(tosave, outname, attrs=None, proc=None): + """Saves xarray variable to new netCDF file""" + + xo = tosave # used to have more stuff here. + # deal with getting non-nan fill values. + if isinstance(xo, xr.Dataset): + enc_dv = {xname: {'_FillValue': None} for xname in xo.data_vars} + else: + enc_dv = {} + #End if + enc_c = {xname: {'_FillValue': None} for xname in xo.coords} + enc = {**enc_c, **enc_dv} + if attrs is not None: + xo.attrs = attrs + if proc is not None: + xo.attrs['Processing_info'] = f"Start from file {origname}. " + proc + xo.to_netcdf(outname, format='NETCDF4', encoding=enc) + + + +def _calc_area(rgdata): + # calculate area + area_km2 = np.zeros(shape=(len(rgdata['lat']), len(rgdata['lon']))) + earth_radius_km = 6.37122e3 # in meters + + yres_degN = np.abs(np.diff(rgdata['lat'].data)) # distances between gridcell centers... + xres_degE = np.abs(np.diff(rgdata['lon'])) # ...end up with one less element, so... + yres_degN = np.append(yres_degN, yres_degN[-1]) # shift left (edges <-- centers); assume... + xres_degE = np.append(xres_degE, xres_degE[-1]) # ...last 2 distances bet. edges are equal + + dy_km = yres_degN * earth_radius_km * np.pi / 180 # distance in m + phi_rad = rgdata['lat'].data * np.pi / 180 # degrees to radians + + # grid cell area + for j in range(len(rgdata['lat'])): + for i in range(len(rgdata['lon'])): + dx_km = xres_degE[i] * np.cos(phi_rad[j]) * earth_radius_km * np.pi / 180 # distance in m + area_km2[j,i] = dy_km[j] * dx_km + + rgdata['area'] = xr.DataArray(area_km2, + coords={'lat': rgdata.lat, 'lon': rgdata.lon}, + dims=["lat", "lon"]) + rgdata['area'].attrs['units'] = 'km2' + rgdata['area'].attrs['long_name'] = 'Grid cell area' + + return rgdata From 3043ecce300191b1a80ae554da8f7adb3915450b Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:28:50 -0600 Subject: [PATCH 008/126] Create lmwg_table.py --- scripts/analysis/lmwg_table.py | 411 +++++++++++++++++++++++++++++++++ 1 file changed, 411 insertions(+) create mode 100644 scripts/analysis/lmwg_table.py diff --git a/scripts/analysis/lmwg_table.py b/scripts/analysis/lmwg_table.py new file mode 100644 index 000000000..9d7d814b1 --- /dev/null +++ b/scripts/analysis/lmwg_table.py @@ -0,0 +1,411 @@ +import numpy as np +import xarray as xr +import sys +from pathlib import Path +import warnings # use to warn user about missing files. + +#Import "special" modules: +try: + import scipy.stats as stats # for easy linear regression and testing +except ImportError: + print("Scipy module does not exist in python path, but is needed for lmwg_table.") + print("Please install module, e.g. 'pip install scipy'.") + sys.exit(1) +#End except + +try: + import pandas as pd +except ImportError: + print("Pandas module does not exist in python path, but is needed for lmwg_table.") + print("Please install module, e.g. 'pip install pandas'.") + sys.exit(1) +#End except + +#Import ADF-specific modules: +import plotting_functions as pf + +def lmwg_table(adf): + + """ + Main function goes through series of steps: + - load the variable data + - Determine whether there are spatial dims; if yes, do global average (TODO: regional option) + - Apply annual average (TODO: add seasonal here) + - calculates the statistics + + mean + + sample size + + standard deviation + + standard error of the mean + + 5/95% confidence interval of the mean + + linear trend + + p-value of linear trend + - puts statistics into a CSV file + - generates simple HTML that can display the data + + Description of needed inputs from ADF: + + case_names -> Name(s) of CAM case provided by "cam_case_name" + input_ts_locs -> Location(s) of CAM time series files provided by "cam_ts_loc" + output_loc -> Location to write AMWG table files to, provided by "cam_diag_plot_loc" + var_list -> List of CAM output variables provided by "diag_var_list" + var_defaults -> Dict that has keys that are variable names and values that are plotting preferences/defaults. + + and if doing a CAM baseline comparison: + + baseline_name -> Name of CAM baseline case provided by "cam_case_name" + input_ts_baseline -> Location of CAM baseline time series files provied by "cam_ts_loc" + + """ + + #Import necessary modules: + from adf_base import AdfError + + #Additional information: + #---------------------- + + # GOAL: replace the "Tables" set in AMWG + # Set Description + # 1 Tables of ANN, DJF, JJA, global and regional means and RMSE. + # + # STRATEGY: + # I think the right solution is to generate one CSV (or other?) file that + # contains all of the data. + # So we need: + # - a function that would produces the data, and + # - then call a function that adds the data to a file + # - another function(module?) that uses the file to produce a "web page" + + # IMPLEMENTATION: + # - assume that we will have time series of global averages already ... that should be done ahead of time + # - given a variable or file for a variable (equivalent), we will calculate the all-time, DJF, JJA, MAM, SON + # + mean + # + standard error of the mean + # -- 95% confidence interval for the mean, estimated by: + # ---- CI95 = mean + (SE * 1.96) + # ---- CI05 = mean - (SE * 1.96) + # + standard deviation + # AMWG also includes the RMSE b/c it is comparing two things, but I will put that off for now. + + # DETAIL: we use python's type hinting as much as possible + + # in future, provide option to do multiple domains + # They use 4 pre-defined domains: + # NOTE, this is likely not as critical for LMWG_table, and won't work we'll with unstructured data + domains = {"global": (0, 360, -90, 90), + "tropics": (0, 360, -20, 20), + "southern": (0, 360, -90, -20), + "northern": (0, 360, 20, 90)} + + # and then in time it is DJF JJA ANN + + # within each domain and season + # the result is just a table of + # VARIABLE-NAME, RUN VALUE, OBS VALUE, RUN-OBS, RMSE + #---------------------- + + #Extract needed quantities from ADF object: + #----------------------------------------- + var_list = adf.diag_var_list + var_defaults = adf.variable_defaults + + #Check if ocean or land fraction exist + #in the variable list: + for var in ["OCNFRAC", "LANDFRAC"]: + if var in var_list: + #If so, then move them to the front of variable list so + #that they can be used to mask or vertically interpolate + #other model variables if need be: + var_idx = var_list.index(var) + var_list.pop(var_idx) + var_list.insert(0,var) + #End if + #End if + + #Special ADF variable which contains the output paths for + #all generated plots and tables for each case: + output_locs = adf.plot_location + + #CAM simulation variables (these quantities are always lists): + case_names = adf.get_cam_info("cam_case_name", required=True) + input_ts_locs = adf.get_cam_info("cam_ts_loc", required=True) + + #Check if a baseline simulation is also being used: + if not adf.get_basic_info("compare_obs"): + #Extract CAM baseline variaables: + baseline_name = adf.get_baseline_info("cam_case_name", required=True) + input_ts_baseline = adf.get_baseline_info("cam_ts_loc", required=True) + + case_names.append(baseline_name) + input_ts_locs.append(input_ts_baseline) + + #Save the baseline to the first case's plots directory: + output_locs.append(output_locs[0]) + else: + print("AMWG table doesn't currently work with obs, so obs table won't be created.") + #End if + + #----------------------------------------- + + #Loop over CAM cases: + #Initialize list of case name csv files for case comparison check later + csv_list = [] + for case_idx, case_name in enumerate(case_names): + + #Convert output location string to a Path object: + output_location = Path(output_locs[case_idx]) + + #Generate input file path: + input_location = Path(input_ts_locs[case_idx]) + + #Check that time series input directory actually exists: + if not input_location.is_dir(): + errmsg = f"Time series directory '{input_location}' not found. Script is exiting." + raise AdfError(errmsg) + #Write to debug log if enabled: + adf.debug_log(f"DEBUG: location of files is {str(input_location)}") + + #Notify user that script has started: + print(f"\n Calculating AMWG variable table for '{case_name}'...") + + #Create output file name: + output_csv_file = output_location / f"amwg_table_{case_name}.csv" + + #Given that this is a final, user-facing analysis, go ahead and re-do it every time: + if Path(output_csv_file).is_file(): + Path.unlink(output_csv_file) + #End if + + #Create/reset new variable that potentially stores the re-gridded + #ocean fraction xarray data-array: + ocn_frc_da = None + + #Loop over CAM output variables: + for var in var_list: + + #Notify users of variable being added to table: + print(f"\t - Variable '{var}' being added to table") + + #Create list of time series files present for variable: + ts_filenames = f'{case_name}.*.{var}.*nc' + ts_files = sorted(input_location.glob(ts_filenames)) + + # If no files exist, try to move to next variable. --> Means we can not proceed with this variable, and it'll be problematic later. + if not ts_files: + errmsg = f"Time series files for variable '{var}' not found. Script will continue to next variable." + warnings.warn(errmsg) + continue + #End if + + #TEMPORARY: For now, make sure only one file exists: + if len(ts_files) != 1: + errmsg = "Currently the AMWG table script can only handle one time series file per variable." + errmsg += f" Multiple files were found for the variable '{var}', so it will be skipped." + print(errmsg) + continue + #End if + + #Load model variable data from file: + ds = pf.load_dataset(ts_files) + weights = ds.landfrac * ds.area + data = ds[var] + + #Extract defaults for variable: + var_default_dict = var_defaults.get(var, {}) + scale_factor = var_default_dict.get('scale_factor', 1) + scale_factor_table = var_default_dict.get('scale_factor_table', 1) + add_offset = var_default_dict.get('add_offset', 0) + # could require this for each variable? + avg_method = var_default_dict.get('avg_method', 'mean') + if avg_method == 'mean': + weights = weights/weights.sum() + + # get units for variable (do this before doing math) + data.attrs['units'] = var_default_dict.get("new_unit", data.attrs.get('units', 'none')) + data.attrs['units'] = var_default_dict.get("table_unit", data.attrs.get('units', 'none')) + if hasattr(data, 'units'): + unit_str = data.attrs['units'] + else: + unit_str = '--' + + data = data * scale_factor * scale_factor_table + #Check if variable has a vertical coordinate: + if 'lev' in data.coords or 'ilev' in data.coords: + print(f"\t ** Variable '{var}' has a vertical dimension, "+\ + "which is currently not supported for the AMWG Table. Skipping...") + #Skip this variable and move to the next variable in var_list: + continue + #End if + + #Check if variable should be masked: + if 'mask' in var_default_dict: + if var_default_dict['mask'].lower() == 'ocean': + #Check if the ocean fraction has already been regridded + #and saved: + if ocn_frc_da is not None: + ofrac = ocn_frc_da + # set the bounds of regridded ocnfrac to 0 to 1 + ofrac = xr.where(ofrac>1,1,ofrac) + ofrac = xr.where(ofrac<0,0,ofrac) + + # apply ocean fraction mask to variable + data = pf.mask_land_or_ocean(data, ofrac, use_nan=True) + #data = var_tmp + else: + print(f"OCNFRAC not found, unable to apply mask to '{var}'") + #End if + else: + #Currently only an ocean mask is supported, so print warning here: + wmsg = "Currently the only variable mask option is 'ocean'," + wmsg += f"not '{var_default_dict['mask'].lower()}'" + print(wmsg) + #End if + #End if + + #If the variable is ocean fraction, then save the dataset for use later: + if var == 'OCNFRAC': + ocn_frc_da = data + #End if + + # we should check if we need to do area averaging: + if len(data.dims) > 1: + # flags that we have spatial dimensions + # Note: that could be 'lev' which should trigger different behavior + # Note: we should be able to handle (lat, lon) or (ncol,) cases, at least + # data = pf.spatial_average(data) # changes data "in place" + data = pf.spatial_average_lnd(data,weights) # hard code for land + # TODO, make this optional for lmwg_tables of amwg_table + # In order to get correct statistics, average to annual or seasonal + data = pf.annual_mean(data, whole_years=True, time_name='time') + + # create a dataframe: + cols = ['variable', 'unit', 'mean', 'sample size', 'standard dev.', + 'standard error', '95% CI', 'trend', 'trend p-value'] + + # These get written to our output file: + stats_list = _get_row_vals(data) + row_values = [var, unit_str] + stats_list + + # Format entries: + dfentries = {c:[row_values[i]] for i,c in enumerate(cols)} + + # Add entries to Pandas structure: + df = pd.DataFrame(dfentries) + + # Check if the output CSV file exists, + # if so, then append to it: + if output_csv_file.is_file(): + df.to_csv(output_csv_file, mode='a', header=False, index=False) + else: + df.to_csv(output_csv_file, header=cols, index=False) + + #End of var_list loop + #-------------------- + + # Move RESTOM to top of table (if applicable) + #-------------------------------------------- + try: + table_df = pd.read_csv(output_csv_file) + if 'RESTOM' in table_df['variable'].values: + table_df = pd.concat([table_df[table_df['variable'] == 'RESTOM'], table_df]).reset_index(drop = True) + table_df = table_df.drop_duplicates() + table_df.to_csv(output_csv_file, header=cols, index=False) + + # last step is to add table dataframe to website (if enabled): + adf.add_website_data(table_df, case_name, case_name, plot_type="Tables") + except FileNotFoundError: + print(f"\n\tAMWG table for '{case_name}' not created.\n") + #End try/except + + #Keep track of case csv files for comparison table check later + csv_list.extend(sorted(output_location.glob(f"amwg_table_{case_name}.csv"))) + + #End of model case loop + #---------------------- + + #Start case comparison tables + #---------------------------- + #Check if observations are being compared to, if so skip table comparison... + if not adf.get_basic_info("compare_obs"): + #Check if all tables were created to compare against, if not, skip table comparison... + if len(csv_list) != len(case_names): + print("\tNot enough cases to compare, skipping comparison table...") + else: + #Create comparison table for both cases + print("\n Making comparison table...") + _df_comp_table(adf, output_location, case_names) + print(" ... Comparison table has been generated successfully") + #End if + else: + print(" No comparison table will be generated due to running against obs.") + #End if + + #Notify user that script has ended: + print(" ...AMWG variable table(s) have been generated successfully.") + + +################## +# Helper functions +################## + +def _get_row_vals(data): + # Now that data is (time,), we can do our simple stats: + + data_mean = data.data.mean() + #Conditional Formatting depending on type of float + if np.abs(data_mean) < 1: + formatter = ".3g" + else: + formatter = ".3f" + + data_sample = len(data) + data_std = data.std() + data_sem = data_std / data_sample + data_ci = data_sem * 1.96 # https://en.wikipedia.org/wiki/Standard_error + data_trend = stats.linregress(data.year, data.values) + + stdev = f'{data_std.data.item() : {formatter}}' + sem = f'{data_sem.data.item() : {formatter}}' + ci = f'{data_ci.data.item() : {formatter}}' + slope_int = f'{data_trend.intercept : {formatter}} + {data_trend.slope : {formatter}} t' + pval = f'{data_trend.pvalue : {formatter}}' + + return [f'{data_mean:{formatter}}', data_sample, stdev, sem, ci, slope_int, pval] + +##### + +def _df_comp_table(adf, output_location, case_names): + import pandas as pd + # TODO, make this output an option for LMWG or AMWG table + output_csv_file_comp = output_location / "amwg_table_comp.csv" + + # * * * * * * * * * * * * * * * * * * * * * * * * * * * * + #This will be for single-case for now (case_names[0]), + #will need to change to loop as multi-case is introduced + case = output_location/f"amwg_table_{case_names[0]}.csv" + baseline = output_location/f"amwg_table_{case_names[-1]}.csv" + + #Read in test case and baseline dataframes: + df_case = pd.read_csv(case) + df_base = pd.read_csv(baseline) + + #Create a merged dataframe that contains only the variables + #contained within both the test case and the baseline: + df_merge = pd.merge(df_case, df_base, how='inner', on=['variable']) + + #Create the "comparison" dataframe: + df_comp = pd.DataFrame(dtype=object) + df_comp[['variable','unit','case']] = df_merge[['variable','unit_x','mean_x']] + df_comp['baseline'] = df_merge[['mean_y']] + + diffs = df_comp['case'].values-df_comp['baseline'].values + df_comp['diff'] = [f'{i:.3g}' if np.abs(i) < 1 else f'{i:.3f}' for i in diffs] + + #Write the comparison dataframe to a new CSV file: + cols_comp = ['variable', 'unit', 'test', 'control', 'diff'] + df_comp.to_csv(output_csv_file_comp, header=cols_comp, index=False) + + #Add comparison table dataframe to website (if enabled): + adf.add_website_data(df_comp, "Case Comparison", case_names[0], plot_type="Tables") + +############## +#END OF SCRIPT From 1c3736ac680f20cfb81cd3ba54ebf4cec40bea53 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:29:42 -0600 Subject: [PATCH 009/126] Update create_climo_files.py --- scripts/averaging/create_climo_files.py | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/scripts/averaging/create_climo_files.py b/scripts/averaging/create_climo_files.py index f9f05454c..841ce04f8 100644 --- a/scripts/averaging/create_climo_files.py +++ b/scripts/averaging/create_climo_files.py @@ -57,6 +57,7 @@ def create_climo_files(adf, clobber=False, search=None): #Import necessary modules: from pathlib import Path from adf_base import AdfError + import utils as adf_utils #Notify user that script has started: msg = "\n Calculating CAM climatologies..." @@ -80,6 +81,9 @@ def create_climo_files(adf, clobber=False, search=None): start_year = adf.climo_yrs["syears"] end_year = adf.climo_yrs["eyears"] + comp = adf.model_component + print("\ncomp",comp,"\n") + #If variables weren't provided in config file, then make them a list #containing only None-type entries: if not calc_climos: @@ -136,6 +140,8 @@ def create_climo_files(adf, clobber=False, search=None): input_location = Path(input_ts_locs[case_idx]) output_location = Path(output_locs[case_idx]) + regrid_output_loc = output_location / "regrid" + #Whether to overwrite existing climo files clobber = overwrite[case_idx] @@ -192,8 +198,8 @@ def create_climo_files(adf, clobber=False, search=None): adf.debug_log(logmsg) # end_diag_script(errmsg) # Previously we would kill the run here. continue - - list_of_arguments.append((adf, ts_files, syr, eyr, output_file)) + #print("\n\nts_files",ts_files,"\n\n") + list_of_arguments.append((adf, ts_files, syr, eyr, output_file, comp)) #End of var_list loop @@ -213,7 +219,7 @@ def create_climo_files(adf, clobber=False, search=None): # # Local functions # -def process_variable(adf, ts_files, syr, eyr, output_file): +def process_variable(adf, ts_files, syr, eyr, output_file, comp): ''' Compute and save the climatology file. ''' @@ -230,6 +236,18 @@ def process_variable(adf, ts_files, syr, eyr, output_file): cam_ts_data['time'] = time cam_ts_data.assign_coords(time=time) cam_ts_data = xr.decode_cf(cam_ts_data) + elif 'time_bounds' in cam_ts_data: + time = cam_ts_data['time'] + if comp == "lnd": + dim = 'hist_interval' + if comp == "atm": + dim = 'nbnd' + # NOTE: force `load` here b/c if dask & time is cftime, throws a NotImplementedError: + time = xr.DataArray(cam_ts_data['time_bounds'].load().mean(dim=dim).values, + dims=time.dims, attrs=time.attrs) + cam_ts_data['time'] = time + cam_ts_data.assign_coords(time=time) + cam_ts_data = xr.decode_cf(cam_ts_data) #Extract data subset using provided year bounds: tslice = get_time_slice_by_year(cam_ts_data.time, int(syr), int(eyr)) cam_ts_data = cam_ts_data.isel(time=tslice) From 4e30fa2511c435d64ce9081a2629bbab3c8ed891 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:32:23 -0600 Subject: [PATCH 010/126] Update global_latlon_map.py --- scripts/plotting/global_latlon_map.py | 118 +++++++++++++++++++++----- 1 file changed, 95 insertions(+), 23 deletions(-) diff --git a/scripts/plotting/global_latlon_map.py b/scripts/plotting/global_latlon_map.py index ab37eb274..ebed009df 100644 --- a/scripts/plotting/global_latlon_map.py +++ b/scripts/plotting/global_latlon_map.py @@ -104,6 +104,18 @@ def global_latlon_map(adfobj): #all generated plots and tables for each case: plot_locations = adfobj.plot_location + kwargs = {} + + # + unstruct_plotting = adfobj.unstructured_plotting + print("unstruct_plotting", unstruct_plotting) + if unstruct_plotting: + kwargs["unstructured_plotting"] = unstruct_plotting + #mesh_file = '/glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc'#adfobj.mesh_file + #kwargs["mesh_file"] = mesh_file + else: + unstructured=False + print("kwargs", kwargs) #Grab case years syear_cases = adfobj.climo_yrs["syears"] eyear_cases = adfobj.climo_yrs["eyears"] @@ -125,6 +137,9 @@ def global_latlon_map(adfobj): # check if existing plots need to be redone redo_plot = adfobj.get_basic_info('redo_plot') print(f"\t NOTE: redo_plot is set to {redo_plot}") + + comp = adfobj.model_component + unstructured = False #----------------------------------------- #Determine if user wants to plot 3-D variables on @@ -177,17 +192,35 @@ def global_latlon_map(adfobj): else: base_name = adfobj.data.ref_labels[var] - # Gather reference variable data - odata = adfobj.data.load_reference_regrid_da(base_name, var) + if unstruct_plotting: + mesh_file = adfobj.mesh_files["baseline_mesh_file"] + kwargs["mesh_file"] = mesh_file + odata = adfobj.data.load_reference_climo_da(base_name, var, **kwargs) + + unstruct_base = True + odataset = adfobj.data.load_reference_climo_dataset(base_name, var, **kwargs) + area = odataset.area.isel(time=0) + landfrac = odataset.landfrac.isel(time=0) + # calculate weights + wgt_base = area * landfrac / (area * landfrac).sum() + else: + #odata = adfobj.data.load_reference_regrid_da(base_name, var, **kwargs) + odata = adfobj.data.load_reference_regrid_da(base_name, var) + if odata is None: + + dmsg = f"\t WARNING: No regridded baseline file for {base_name} for variable `{var}`, global lat/lon mean plotting skipped." + adfobj.debug_log(dmsg) + continue + o_has_dims = pf.validate_dims(odata, ["lat", "lon", "lev"]) # T iff dims are (lat,lon) -- can't plot unless we have both + if (not o_has_dims['has_lat']) or (not o_has_dims['has_lon']): + print(f"\t WARNING: skipping global map for {var} as REFERENCE does not have both lat and lon") + continue if odata is None: - dmsg = f"\t WARNING: No regridded test file for {base_name} for variable `{var}`, global lat/lon mean plotting skipped." + dmsg = f"\t WARNING: No baseline file for {base_name} for variable `{var}`, global lat/lon mean plotting skipped." + #dmsg = f"\t WARNING: No regridded baseline file for {base_name} for variable `{var}`, will" adfobj.debug_log(dmsg) - continue - - o_has_dims = pf.validate_dims(odata, ["lat", "lon", "lev"]) # T iff dims are (lat,lon) -- can't plot unless we have both - if (not o_has_dims['has_lat']) or (not o_has_dims['has_lon']): - print(f"\t WARNING: skipping global map for {var} as REFERENCE does not have both lat and lon") + print(dmsg) continue #Loop over model cases: @@ -204,25 +237,64 @@ def global_latlon_map(adfobj): print(f" {plot_loc} not found, making new directory") plot_loc.mkdir(parents=True) - #Load re-gridded model files: - mdata = adfobj.data.load_regrid_da(case_name, var) - + if unstruct_plotting: + mesh_file = adfobj.mesh_files["test_mesh_file"][case_idx] + kwargs["mesh_file"] = mesh_file + mdata = adfobj.data.load_climo_da(case_name, var, **kwargs) + + unstruct_case = True + mdataset = adfobj.data.load_climo_dataset(case_name, var, **kwargs) + area = mdataset.area.isel(time=0) + landfrac = mdataset.landfrac.isel(time=0) + # calculate weights + wgt = area * landfrac / (area * landfrac).sum() + else: + mdata = adfobj.data.load_regrid_da(case_name, var) + #Skip this variable/case if the regridded climo file doesn't exist: + if mdata is None: + dmsg = f"\t WARNING: No regridded test file for {case_name} for variable `{var}`, global lat/lon mean plotting skipped." + adfobj.debug_log(dmsg) + continue + #Determine dimensions of variable: + has_dims = pf.validate_dims(mdata, ["lat", "lon", "lev"]) + if (not has_dims['has_lat']) or (not has_dims['has_lon']): + print(f"\t WARNING: skipping global map for {var} for case {case_name} as it does not have both lat and lon") + continue + else: # i.e., has lat&lon + if (has_dims['has_lev']) and (not pres_levs): + print(f"\t WARNING: skipping global map for {var} as it has more than lev dimension, but no pressure levels were provided") + continue #Skip this variable/case if the regridded climo file doesn't exist: if mdata is None: - dmsg = f"\t WARNING: No regridded test file for {case_name} for variable `{var}`, global lat/lon mean plotting skipped." + dmsg = f"\t WARNING: No test file for {case_name} for variable `{var}`, global lat/lon mean plotting skipped." adfobj.debug_log(dmsg) continue - - #Determine dimensions of variable: has_dims = pf.validate_dims(mdata, ["lat", "lon", "lev"]) - if (not has_dims['has_lat']) or (not has_dims['has_lon']): - print(f"\t WARNING: skipping global map for {var} for case {case_name} as it does not have both lat and lon") + if (has_dims['has_lev']) and (not pres_levs): + print(f"\t WARNING: skipping global map for {var} as it has more than lev dimension, but no pressure levels were provided") continue - else: # i.e., has lat&lon - if (has_dims['has_lev']) and (not pres_levs): - print(f"\t WARNING: skipping global map for {var} as it has more than lev dimension, but no pressure levels were provided") - continue + #Determine dimensions of variable: + if unstruct_plotting: + has_dims = {} + if len(wgt.n_face) == len(wgt_base.n_face): + vres["wgt"] = wgt + has_dims = {} + has_dims['has_lev'] = False + else: + print("The weights are different between test and baseline. Won't continue, eh.") + return + + if (not unstruct_case) and (unstruct_base): + print("Base is unstructured but Test is lat/lon. Can't continue?") + return + if (unstruct_case) and (not unstruct_base): + print("Base is lat/lon but Test is unstructured. Can't continue?") + return + if (unstruct_case) and (unstruct_base): + unstructured=True + if (not unstruct_case) and (not unstruct_base): + unstructured=False # Check output file. If file does not exist, proceed. # If file exists: # if redo_plot is true: delete it now and make plot @@ -275,7 +347,7 @@ def global_latlon_map(adfobj): [syear_cases[case_idx],eyear_cases[case_idx]], [syear_baseline,eyear_baseline], mseasons[s], oseasons[s], dseasons[s], pseasons[s], - obs=adfobj.compare_obs, **vres) + obs=adfobj.compare_obs, unstructured=unstructured, **vres) #Add plot to website (if enabled): adfobj.add_website_data(plot_name, var, case_name, category=web_category, @@ -319,7 +391,7 @@ def global_latlon_map(adfobj): [syear_baseline,eyear_baseline], mseasons[s].sel(lev=pres), oseasons[s].sel(lev=pres), dseasons[s].sel(lev=pres), pseasons[s].sel(lev=pres), - obs=adfobj.compare_obs, **vres) + obs=adfobj.compare_obs, unstructured=unstructured, **vres) #Add plot to website (if enabled): adfobj.add_website_data(plot_name, f"{var}_{pres}hpa", case_name, category=web_category, @@ -921,4 +993,4 @@ def regrid_to_obs(adfobj, model_arr, obs_arr): ####### ############## -#END OF SCRIPT \ No newline at end of file +#END OF SCRIPT From 55dc6ec3aeee8d37f3e66e7573444b7ae53f2b56 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:33:53 -0600 Subject: [PATCH 011/126] Update polar_map.py --- scripts/plotting/polar_map.py | 176 ++++++++++++++++++++++------------ 1 file changed, 117 insertions(+), 59 deletions(-) diff --git a/scripts/plotting/polar_map.py b/scripts/plotting/polar_map.py index dbcfcff70..719862cc3 100644 --- a/scripts/plotting/polar_map.py +++ b/scripts/plotting/polar_map.py @@ -25,11 +25,25 @@ def polar_map(adfobj): # var_list = adfobj.diag_var_list model_rgrid_loc = adfobj.get_basic_info("cam_regrid_loc", required=True) + #model_rgrid_locs = adfobj.get_cam_info("cam_climo_regrid_loc", required=True) #Special ADF variable which contains the output paths for #all generated plots and tables for each case: plot_locations = adfobj.plot_location + kwargs = {} + + # + unstruct_plotting = adfobj.unstructured_plotting + print("unstruct_plotting", unstruct_plotting) + if unstruct_plotting: + kwargs["unstructured_plotting"] = unstruct_plotting + #mesh_file = '/glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc'#adfobj.mesh_file + #kwargs["mesh_file"] = mesh_file + else: + unstructured=False + print("kwargs", kwargs) + #CAM simulation variables (this is always assumed to be a list): case_names = adfobj.get_cam_info("cam_case_name", required=True) @@ -58,6 +72,7 @@ def polar_map(adfobj): data_name = adfobj.get_baseline_info("cam_case_name", required=True) # does not get used, is just here as a placemarker data_list = [data_name] # gets used as just the name to search for climo files HAS TO BE LIST data_loc = model_rgrid_loc #Just use the re-gridded model data path + #data_loc = Path(adfobj.get_baseline_info("cam_climo_regrid_loc", required=True)) #End if #Grab baseline years (which may be empty strings if using Obs): @@ -68,6 +83,12 @@ def polar_map(adfobj): test_nicknames = adfobj.case_nicknames["test_nicknames"] base_nickname = adfobj.case_nicknames["base_nickname"] + comp = adfobj.model_component + if comp == "atm": + hemis = ["NHPolar", "SHPolar"] + if comp == "lnd": + hemis = ["Arctic"] + res = adfobj.variable_defaults # will be dict of variable-specific plot preferences # or an empty dictionary if use_defaults was not specified in YAML. @@ -152,22 +173,32 @@ def polar_map(adfobj): # load data (observational) commparison files (we should explore intake as an alternative to having this kind of repeated code): if adfobj.compare_obs: - #For now, only grab one file (but convert to list for use below) - oclim_fils = [dclimo_loc] #Set data name: data_name = data_src + + if unstruct_plotting: + mesh_file = adfobj.mesh_files["baseline_mesh_file"] + kwargs["mesh_file"] = mesh_file + odata = adfobj.data.load_reference_climo_da(data_name, data_var, **kwargs) + #if ('ncol' in odata.dims) or ('lndgrid' in odata.dims): + if 1==1: + unstruct_base = True + odataset = adfobj.data.load_reference_climo_dataset(data_name, data_var, **kwargs) + area = odataset.area.isel(time=0) + landfrac = odataset.landfrac.isel(time=0) + # calculate weights + wgt_base = area * landfrac / (area * landfrac).sum() else: - oclim_fils = sorted(dclimo_loc.glob(f"{data_src}_{var}_baseline.nc")) - - oclim_ds = pf.load_dataset(oclim_fils) - if oclim_ds is None: + odata = adfobj.data.load_reference_regrid_da(data_name, data_var, **kwargs) + if odata is None: print("\t WARNING: Did not find any regridded reference climo files. Will try to skip.") print(f"\t INFO: Data Location, dclimo_loc is {dclimo_loc}") - print(f"\t The glob is: {data_src}_{var}_*.nc") + print(f"\t The glob is: {data_src}_{data_var}_*.nc") continue #Loop over model cases: for case_idx, case_name in enumerate(case_names): + #mclimo_rg_loc = Path(model_rgrid_locs[case_idx]) #Set case nickname: case_nickname = test_nicknames[case_idx] @@ -180,40 +211,55 @@ def polar_map(adfobj): print(f" {plot_loc} not found, making new directory") plot_loc.mkdir(parents=True) - # load re-gridded model files: - mclim_fils = sorted(mclimo_rg_loc.glob(f"{data_src}_{case_name}_{var}_*.nc")) + if unstruct_plotting: + mesh_file = adfobj.mesh_files["test_mesh_file"][case_idx] + kwargs["mesh_file"] = mesh_file + mdata = adfobj.data.load_climo_da(case_name, var, **kwargs) + #if ('ncol' in mdata.dims) or ('lndgrid' in mdata.dims): + if 1==1: + unstruct_case = True + mdataset = adfobj.data.load_climo_dataset(case_name, var, **kwargs) + area = mdataset.area.isel(time=0) + landfrac = mdataset.landfrac.isel(time=0) + # calculate weights + wgt = area * landfrac / (area * landfrac).sum() + else: + mdata = adfobj.data.load_regrid_da(case_name, var, **kwargs) - mclim_ds = pf.load_dataset(mclim_fils) - if mclim_ds is None: + if mdata is None: print("\t WARNING: Did not find any regridded test climo files. Will try to skip.") print(f"\t INFO: Data Location, mclimo_rg_loc, is {mclimo_rg_loc}") print(f"\t The glob is: {data_src}_{case_name}_{var}_*.nc") continue #End if - #Extract variable of interest - odata = oclim_ds[data_var].squeeze() # squeeze in case of degenerate dimensions - mdata = mclim_ds[var].squeeze() - - # APPLY UNITS TRANSFORMATION IF SPECIFIED: - # NOTE: looks like our climo files don't have all their metadata - mdata = mdata * vres.get("scale_factor",1) + vres.get("add_offset", 0) - # update units - mdata.attrs['units'] = vres.get("new_unit", mdata.attrs.get('units', 'none')) - - # Do the same for the baseline case if need be: - if not adfobj.compare_obs: - odata = odata * vres.get("scale_factor",1) + vres.get("add_offset", 0) - # update units - odata.attrs['units'] = vres.get("new_unit", odata.attrs.get('units', 'none')) - # or for observations. - else: - odata = odata * vres.get("obs_scale_factor",1) + vres.get("obs_add_offset", 0) - # Note: assume obs are set to have same untis as model. + if unstruct_plotting: + has_dims = {} + if len(wgt.n_face) == len(wgt_base.n_face): + vres["wgt"] = wgt + has_dims = {} + has_dims['has_lev'] = False + else: + print("The weights are different between test and baseline. Won't continue, eh.") + return + + if (not unstruct_case) and (unstruct_base): + print("Base is unstructured but Test is lat/lon. Can't continue?") + return + if (unstruct_case) and (not unstruct_base): + print("Base is lat/lon but Test is unstructured. Can't continue?") + return + if (unstruct_case) and (unstruct_base): + unstructured=True + if (not unstruct_case) and (not unstruct_base): + unstructured=False #Determine dimensions of variable: has_dims = pf.lat_lon_validate_dims(odata) - if has_dims: + has_lat_ref, has_lev_ref = pf.zm_validate_dims(odata) + has_lat, has_lev = pf.zm_validate_dims(mdata) + #if has_dims: + if (not has_lev) and (not has_lev_ref): #If observations/baseline CAM have the correct #dimensions, does the input CAM run have correct #dimensions as well? @@ -221,7 +267,8 @@ def polar_map(adfobj): #If both fields have the required dimensions, then #proceed with plotting: - if has_dims_cam: + #if has_dims_cam: + if 2==2: # # Seasonal Averages @@ -247,12 +294,9 @@ def polar_map(adfobj): # percent change pseasons[s] = (mseasons[s] - oseasons[s]) / np.abs(oseasons[s]) * 100.0 # relative change pseasons[s].attrs['units'] = '%' - #check if pct has NaN's or Inf values and if so set them to 0 to prevent plotting errors - pseasons[s] = pseasons[s].where(np.isfinite(pseasons[s]), np.nan) - pseasons[s] = pseasons[s].fillna(0.0) # make plots: northern and southern hemisphere separately: - for hemi_type in ["NHPolar", "SHPolar"]: + for hemi_type in hemis: #Create plot name and path: plot_name = plot_loc / f"{var}_{s}_{hemi_type}_Mean.{plot_type}" @@ -278,17 +322,22 @@ def polar_map(adfobj): # *Any other entries will be ignored. # NOTE: If we were doing all the plotting here, we could use whatever we want from the provided YAML file. - #Determine hemisphere to plot based on plot file name: - if hemi_type == "NHPolar": - hemi = "NH" - else: - hemi = "SH" - #End if + if comp == "atm": + #Determine hemisphere to plot based on plot file name: + if hemi_type == "NHPolar": + hemi = "NH" + else: + hemi = "SH" + #End if + if comp == "lnd": + hemi = hemi_type pf.make_polar_plot(plot_name, case_nickname, base_nickname, [syear_cases[case_idx],eyear_cases[case_idx]], [syear_baseline,eyear_baseline], - mseasons[s], oseasons[s], dseasons[s], pseasons[s], hemisphere=hemi, obs=obs, **vres) + mseasons[s], oseasons[s], dseasons[s], pseasons[s], + hemisphere=hemi, obs=obs, unstructured=unstructured, + **vres) #Add plot to website (if enabled): adfobj.add_website_data(plot_name, var, case_name, category=web_category, @@ -303,23 +352,23 @@ def polar_map(adfobj): #Check that case inputs have the correct dimensions (including "lev"): has_lat, has_lev = pf.zm_validate_dims(mdata) # assumes will work for both mdata & odata - # check if there is a lat dimension: + """# check if there is a lat dimension: if not has_lat: print( f"\t WARNING: Variable {var} is missing a lat dimension for '{case_name}', cannot continue to plot." ) continue - # End if + # End if""" #Check that case inputs have the correct dimensions (including "lev"): has_lat_ref, has_lev_ref = pf.zm_validate_dims(odata) - # check if there is a lat dimension: + """# check if there is a lat dimension: if not has_lat_ref: print( f"\t WARNING: Variable {var} is missing a lat dimension for '{data_name}', cannot continue to plot." ) - continue + continue""" #Check if both cases have vertical levels to continue if (has_lev) and (has_lev_ref): @@ -331,7 +380,7 @@ def polar_map(adfobj): #exists in the model data, which should already #have been interpolated to the standard reference #pressure levels: - if not (pres in mclim_ds['lev']): + if not (pres in mdata['lev']): #Move on to the next pressure level: print(f"\t WARNING: plot_press_levels value '{pres}' not a standard reference pressure, so skipping.") continue @@ -355,11 +404,15 @@ def polar_map(adfobj): pseasons[s] = (mseasons[s] - oseasons[s]) / abs(oseasons[s]) * 100.0 # relative change pseasons[s].attrs['units'] = '%' #check if pct has NaN's or Inf values and if so set them to 0 to prevent plotting errors - pseasons[s] = pseasons[s].where(np.isfinite(pseasons[s]), np.nan) - pseasons[s] = pseasons[s].fillna(0.0) + #pseasons[s] = pseasons[s].where(np.isfinite(pseasons[s]), np.nan) + #pseasons[s] = pseasons[s].fillna(0.0) # make plots: northern and southern hemisphere separately: - for hemi_type in ["NHPolar", "SHPolar"]: + for hemi_type in hemis: + print("mseasons[s].shape",mseasons[s].shape) + print("oseasons[s].shape",oseasons[s].shape) + print("dseasons[s].shape",dseasons[s].shape) + print("pseasons[s].shape",pseasons[s].shape) #Create plot name and path: plot_name = plot_loc / f"{var}_{pres}hpa_{s}_{hemi_type}_Mean.{plot_type}" @@ -386,17 +439,22 @@ def polar_map(adfobj): # *Any other entries will be ignored. # NOTE: If we were doing all the plotting here, we could use whatever we want from the provided YAML file. - #Determine hemisphere to plot based on plot file name: - if hemi_type == "NHPolar": - hemi = "NH" - else: - hemi = "SH" - #End if + if comp == "atm": + #Determine hemisphere to plot based on plot file name: + if hemi_type == "NHPolar": + hemi = "NH" + else: + hemi = "SH" + #End if + if comp == "lnd": + hemi = hemi_type pf.make_polar_plot(plot_name, case_nickname, base_nickname, [syear_cases[case_idx],eyear_cases[case_idx]], [syear_baseline,eyear_baseline], - mseasons[s], oseasons[s], dseasons[s], pseasons[s], hemisphere=hemi, obs=obs, **vres) + mseasons[s], oseasons[s], dseasons[s], pseasons[s], + hemisphere=hemi, obs=obs, unstructured=unstructured, + **vres) #Add plot to website (if enabled): adfobj.add_website_data(plot_name, f"{var}_{pres}hpa", @@ -423,4 +481,4 @@ def polar_map(adfobj): #END OF `polar_map` function ############## -# END OF FILE \ No newline at end of file +# END OF FILE From bf4ce5d84a551f9b600168c74d36cc7f93ebf6da Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:36:54 -0600 Subject: [PATCH 012/126] Update regrid_and_vert_interp.py --- scripts/regridding/regrid_and_vert_interp.py | 424 ++++++++++++++----- 1 file changed, 324 insertions(+), 100 deletions(-) diff --git a/scripts/regridding/regrid_and_vert_interp.py b/scripts/regridding/regrid_and_vert_interp.py index 8316cb3f1..44695d8a2 100644 --- a/scripts/regridding/regrid_and_vert_interp.py +++ b/scripts/regridding/regrid_and_vert_interp.py @@ -1,4 +1,5 @@ #Import standard modules: +from pdb import lasti2lineno import xarray as xr def regrid_and_vert_interp(adf): @@ -36,6 +37,8 @@ def regrid_and_vert_interp(adf): from pathlib import Path + from adf_base import AdfError + # regridding # Try just using the xarray method # import xesmf as xe # This package is for regridding, and is just one potential solution. @@ -56,9 +59,24 @@ def regrid_and_vert_interp(adf): var_list = adf.diag_var_list var_defaults = adf.variable_defaults + comp = adf.model_component + if comp == "atm": + spec_vars = ["PMID", "OCNFRAC", "LANDFRAC"] + mask_var = "OCNFRAC" + mask_name = "ocean" + if comp == "lnd": + spec_vars = ["LANDFRAC"] + mask_var = "LANDFRAC" + mask_name = "land" + #CAM simulation variables (these quantities are always lists): case_names = adf.get_cam_info("cam_case_name", required=True) - input_climo_locs = adf.get_cam_info("cam_climo_loc", required=True) + output_climo_locs = adf.get_cam_info("cam_climo_loc", required=True) + + # SE to FV options + case_latlon_files = adf.latlon_files["test_latlon_file"] + case_wgts_files = adf.latlon_wgt_files["test_wgts_file"] + case_methods = adf.latlon_regrid_method["test_regrid_method"] #Grab case years syear_cases = adf.climo_yrs["syears"] @@ -66,7 +84,7 @@ def regrid_and_vert_interp(adf): #Check if mid-level pressure, ocean fraction or land fraction exist #in the variable list: - for var in ["PMID", "OCNFRAC", "LANDFRAC"]: + for var in spec_vars: if var in var_list: #If so, then move them to the front of variable list so #that they can be used to mask or vertically interpolate @@ -79,8 +97,8 @@ def regrid_and_vert_interp(adf): #Create new variables that potentially stores the re-gridded #ocean/land fraction dataset: - ocn_frc_ds = None - tgt_ocn_frc_ds = None + frc_ds = None + tgt_frc_ds = None #Check if surface pressure exists in variable list: if "PS" in var_list: @@ -128,15 +146,15 @@ def regrid_and_vert_interp(adf): #Set output/target data path variables: #------------------------------------ rgclimo_loc = Path(output_loc) - if not adf.compare_obs: - tclimo_loc = Path(target_loc) - #------------------------------------ - #Check if re-gridded directory exists, and if not, then create it: if not rgclimo_loc.is_dir(): print(f" {rgclimo_loc} not found, making new directory") rgclimo_loc.mkdir(parents=True) #End if + if not adf.compare_obs: + tclimo_loc = Path(target_loc) + #------------------------------------ + #Loop over CAM cases: for case_idx, case_name in enumerate(case_names): @@ -144,11 +162,8 @@ def regrid_and_vert_interp(adf): #Notify user of model case being processed: print(f"\t Regridding case '{case_name}' :") - #Set case climo data path: - mclimo_loc = Path(input_climo_locs[case_idx]) - #Create empty dictionaries which store the locations of regridded surface - #pressure and mid-level pressure fields: + #pressure and mid-level pressure fields if needed: ps_loc_dict = {} pmid_loc_dict = {} @@ -187,12 +202,13 @@ def regrid_and_vert_interp(adf): #Determine regridded variable file name: regridded_file_loc = rgclimo_loc / f'{target}_{case_name}_{var}_regridded.nc' - #If surface or mid-level pressure, then save for potential use by other variables: - if var == "PS": - ps_loc_dict[target] = regridded_file_loc - elif var == "PMID": - pmid_loc_dict[target] = regridded_file_loc - #End if + if comp == "atm": + #If surface or mid-level pressure, then save for potential use by other variables: + if var == "PS": + ps_loc_dict[target] = regridded_file_loc + elif var == "PMID": + pmid_loc_dict[target] = regridded_file_loc + #End if #Check if re-gridded file already exists and over-writing is allowed: if regridded_file_loc.is_file() and overwrite_regrid: @@ -209,16 +225,14 @@ def regrid_and_vert_interp(adf): #For now, only grab one file (but convert to list for use below): tclim_fils = [tclimo_loc] else: - tclim_fils = sorted(tclimo_loc.glob(f"{target}*_{var}_climo.nc")) + tclim_fils = adf.data.get_reference_climo_file(var) #End if #Write to debug log if enabled: - adf.debug_log(f"regrid_example: tclim_fils (n={len(tclim_fils)}): {tclim_fils}") - - if len(tclim_fils) > 1: - #Combine all target files together into a single data set: - tclim_ds = xr.open_mfdataset(tclim_fils, combine='by_coords') - elif len(tclim_fils) == 0: + #adf.debug_log(f"regrid_example: tclim_fils (n={len(tclim_fils)}): {tclim_fils}") + + tclim_ds = adf.data.load_reference_climo_dataset(target, var) + if tclim_ds is None: print(f"\t WARNING: regridding {var} failed, no climo file for case '{target}'. Continuing to next variable.") continue else: @@ -226,75 +240,105 @@ def regrid_and_vert_interp(adf): tclim_ds = xr.open_dataset(tclim_fils[0]) #End if - #Generate CAM climatology (climo) file list: - mclim_fils = sorted(mclimo_loc.glob(f"{case_name}_{var}_*.nc")) - - if len(mclim_fils) > 1: - #Combine all cam files together into a single data set: - mclim_ds = xr.open_mfdataset(mclim_fils, combine='by_coords') - elif len(mclim_fils) == 0: - #wmsg = f"\t WARNING: Unable to find climo file for '{var}'." - #wmsg += " Continuing to next variable." - wmsg= f"\t WARNING: regridding {var} failed, no climo file for case '{case_name}'. Continuing to next variable." - print(wmsg) + mclim_ds = adf.data.load_climo_dataset(case_name, var) + if mclim_ds is None: + print(f"\t WARNING: regridding {var} failed, no climo file for case '{target}'. Continuing to next variable.") continue - else: - #Open single file as new xarray dataset: - mclim_ds = xr.open_dataset(mclim_fils[0]) - #End if #Create keyword arguments dictionary for regridding function: regrid_kwargs = {} - #Check if target in relevant pressure variable dictionaries: - if target in ps_loc_dict: - regrid_kwargs.update({'ps_file': ps_loc_dict[target]}) - #End if - if target in pmid_loc_dict: - regrid_kwargs.update({'pmid_file': pmid_loc_dict[target]}) - #End if + if comp == "atm": + #Check if target in relevant pressure variable dictionaries: + if target in ps_loc_dict: + regrid_kwargs.update({'ps_file': ps_loc_dict[target]}) + #End if + if target in pmid_loc_dict: + regrid_kwargs.update({'pmid_file': pmid_loc_dict[target]}) + #End if + + if ('lat' not in mclim_ds.dims) and ('lat' not in mclim_ds.dims): + if ('ncol' in mclim_ds.dims) or ('lndgrid' in mclim_ds.dims): + print(f"\t INFO: Looks like test case '{case_name}' is unstructured, eh?") + + #Check if any a FV file exists if using native grid + case_latlon_file = case_latlon_files[case_idx] + if not case_latlon_file: + msg = "WARNING: This looks like an unstructured case, but missing lat/lon file" + print(msg) + case_latlon_file = None + #raise AdfError(msg) + + #Check if any a weights file exists if using native grid + case_wgts_file = case_wgts_files[case_idx] + if not case_wgts_file: + msg = "WARNING: This looks like an unstructured case, but missing weights file, can't continue." + raise AdfError(msg) + + case_method = case_methods[case_idx] + + # Grid unstructured climo if applicable before regridding + rgdata_interp = _regrid(mclim_ds, var, + comp=comp, + wgt_file=case_wgts_file, + latlon_file=case_latlon_file, + method=case_method, + ) + + output_test_loc = Path(output_climo_locs[case_idx]) + rgridded_output_loc = output_test_loc / "gridded" + if not rgridded_output_loc.is_dir(): + print(f" {rgridded_output_loc} not found, making new directory") + rgridded_output_loc.mkdir(parents=True) + save_to_nc(rgdata_interp, rgridded_output_loc / f'{case_name}_{var}_gridded_climo.nc') - #Perform regridding and interpolation of variable: - rgdata_interp = _regrid_and_interpolate_levs(mclim_ds, var, + else: + msg = "WARNING: No lat/lons but no grid info either. I guess this really is a problem!" + msg += "\n You might want to look at the files. Only CAM and CLM (ncol) and CLM (lndgrd) native grids are acceptable." + raise AdfError(msg) + else: + rgdata_interp = mclim_ds + #else: + rgdata_interp = _regrid_and_interpolate_levs(rgdata_interp, var, regrid_dataset=tclim_ds, **regrid_kwargs) - #Extract defaults for variable: var_default_dict = var_defaults.get(var, {}) if 'mask' in var_default_dict: - if var_default_dict['mask'].lower() == 'ocean': + if var_default_dict['mask'].lower() == mask_name: #Check if the ocean fraction has already been regridded #and saved: - if ocn_frc_ds: - ofrac = ocn_frc_ds['OCNFRAC'] + if frc_ds: + frac = frc_ds[mask_var] # set the bounds of regridded ocnfrac to 0 to 1 - ofrac = xr.where(ofrac>1,1,ofrac) - ofrac = xr.where(ofrac<0,0,ofrac) + frac = xr.where(frac>1,1,frac) + frac = xr.where(frac<0,0,frac) # apply ocean fraction mask to variable - rgdata_interp['OCNFRAC'] = ofrac + rgdata_interp[mask_var] = frac var_tmp = rgdata_interp[var] - var_tmp = pf.mask_land_or_ocean(var_tmp,ofrac) + var_tmp = pf.mask_land_or_ocean(var_tmp,frac) rgdata_interp[var] = var_tmp else: - print(f"\t WARNING: OCNFRAC not found, unable to apply mask to '{var}'") + print(f"\t WARNING: {mask_var} not found, unable to apply mask to '{var}'") #End if else: - #Currently only an ocean mask is supported, so print warning here: - wmsg = "\t WARNING: Currently the only variable mask option is 'ocean'," + #Currently only ocean or land masks are supported, so print warning here: + wmsg = f"\t WARNING: Currently the only variable mask option is '{mask_name}'," wmsg += f"not '{var_default_dict['mask'].lower()}'" print(wmsg) #End if #End if - #If the variable is ocean fraction, then save the dataset for use later: - if var == 'OCNFRAC': - ocn_frc_ds = rgdata_interp + #If the variable is the mask fraction, then save the dataset for use later: + if var == mask_var: + frc_ds = rgdata_interp #End if #Finally, write re-gridded data to output file: #Convert the list of Path objects to a list of strings + mclim_fils = adf.data.get_climo_file(case_name, var) climatology_files_str = [str(path) for path in mclim_fils] climatology_files_str = ', '.join(climatology_files_str) test_attrs_dict = { @@ -310,31 +354,71 @@ def regrid_and_vert_interp(adf): #if applicable: #Set interpolated baseline file name: + #interp_bl_file = trgclimo_loc / f'{target}_{var}_baseline.nc' interp_bl_file = rgclimo_loc / f'{target}_{var}_baseline.nc' if not adf.compare_obs and not interp_bl_file.is_file(): + if comp == "atm": + #Look for a baseline climo file for surface pressure (PS): + bl_ps_fil = tclimo_loc / f'{target}_PS_climo.nc' - #Look for a baseline climo file for surface pressure (PS): - bl_ps_fil = tclimo_loc / f'{target}_PS_climo.nc' + #Also look for a baseline climo file for mid-level pressure (PMID): + bl_pmid_fil = tclimo_loc / f'{target}_PMID_climo.nc' - #Also look for a baseline climo file for mid-level pressure (PMID): - bl_pmid_fil = tclimo_loc / f'{target}_PMID_climo.nc' + #Create new keyword arguments dictionary for regridding function: + regrid_kwargs = {} - #Create new keyword arguments dictionary for regridding function: - regrid_kwargs = {} - - #Check if PS and PMID files exist: - if bl_ps_fil.is_file(): - regrid_kwargs.update({'ps_file': bl_ps_fil}) - #End if - if bl_pmid_fil.is_file(): - regrid_kwargs.update({'pmid_file': bl_pmid_fil}) - #End if - - #Generate vertically-interpolated baseline dataset: - tgdata_interp = _regrid_and_interpolate_levs(tclim_ds, var, - **regrid_kwargs) + #Check if PS and PMID files exist: + if bl_ps_fil.is_file(): + regrid_kwargs.update({'ps_file': bl_ps_fil}) + #End if + if bl_pmid_fil.is_file(): + regrid_kwargs.update({'pmid_file': bl_pmid_fil}) + #End if + + #if unstruct_base: + if ('lat' not in tclim_ds.dims) and ('lat' not in tclim_ds.dims): + if ('ncol' in tclim_ds.dims) or ('lndgrid' in tclim_ds.dims): + print(f"\t INFO: Looks like baseline case '{target}' is unstructured, eh?") + + #Check if any a FV file exists if using native grid + baseline_latlon_file = adf.latlon_files["baseline_latlon_file"] + if not baseline_latlon_file: + msg = "WARNING: This looks like an unstructured case, but missing lat/lon file" + print(msg) + baseline_latlon_file = None + #raise AdfError(msg) + + #Check if any a weights file exists if using native grid + baseline_wgts_file = adf.latlon_wgt_files["baseline_wgts_file"] + if not baseline_wgts_file: + msg = "WARNING: This looks like an unstructured case, but missing weights file, can't continue." + raise AdfError(msg) + + base_method = adf.latlon_regrid_method["baseline_regrid_method"] + + # Grid unstructured climo if applicable before regridding + tgdata_interp = _regrid(tclim_ds, var, + comp=comp, + wgt_file=baseline_wgts_file, + latlon_file=baseline_latlon_file, + method=base_method, + ) + tgridded_output_loc = Path(target_loc) / "gridded" + if not tgridded_output_loc.is_dir(): + print(f" {tgridded_output_loc} not found, making new directory") + tgridded_output_loc.mkdir(parents=True) + save_to_nc(tgdata_interp, tgridded_output_loc / f'{target}_{var}_gridded_climo.nc') + else: + msg = "WARNING: No lat/lons but no grid info either. I guess this really is a problem!" + msg += "\n You might want to look at the files. Only CAM (ncol) and CLM (lndgrd) native grids are acceptable." + raise AdfError(msg) + else: + tgdata_interp = tclim_ds + tgdata_interp = _regrid_and_interpolate_levs(tgdata_interp, var, + regrid_dataset=tclim_ds, + **regrid_kwargs) if tgdata_interp is None: #Something went wrong during interpolation, so just cycle through #for now: @@ -342,29 +426,32 @@ def regrid_and_vert_interp(adf): #End if #If the variable is ocean fraction, then save the dataset for use later: - if var == 'OCNFRAC': - tgt_ocn_frc_ds = tgdata_interp + if var == mask_var: + frc_ds = tgdata_interp #End if - if 'mask' in var_default_dict: - if var_default_dict['mask'].lower() == 'ocean': + if var_default_dict['mask'].lower() == mask_name: #Check if the ocean fraction has already been regridded #and saved: - if tgt_ocn_frc_ds: - ofrac = tgt_ocn_frc_ds['OCNFRAC'] + if frc_ds: + frac = frc_ds[mask_var] # set the bounds of regridded ocnfrac to 0 to 1 - ofrac = xr.where(ofrac>1,1,ofrac) - ofrac = xr.where(ofrac<0,0,ofrac) - # mask the land in TS for global means - tgdata_interp['OCNFRAC'] = ofrac - ts_tmp = tgdata_interp[var] - ts_tmp = pf.mask_land_or_ocean(ts_tmp,ofrac) - tgdata_interp[var] = ts_tmp + frac = xr.where(frac>1,1,frac) + frac = xr.where(frac<0,0,frac) + + # apply ocean fraction mask to variable + rgdata_interp[mask_var] = frac + var_tmp = rgdata_interp[var] + var_tmp = pf.mask_land_or_ocean(var_tmp,frac) + rgdata_interp[var] = var_tmp else: - wmsg = "\t WARNING: OCNFRAC not found in target," - wmsg += f" unable to apply mask to '{var}'" - print(wmsg) + print(f"\t WARNING: {mask_var} not found, unable to apply mask to '{var}'") #End if + else: + #Currently only ocean or land masks are supported, so print warning here: + wmsg = f"\t WARNING: Currently the only variable mask option is '{mask_name}'," + wmsg += f"not '{var_default_dict['mask'].lower()}'" + print(wmsg) #End if #End if @@ -494,7 +581,6 @@ def _regrid_and_interpolate_levs(model_dataset, var_name, regrid_dataset=None, r #Check if variable has a vertical levels dimension: if has_lev: - if vert_coord_type == "hybrid": # Need hyam, hybm, and P0 for vertical interpolation of hybrid levels: if 'lev' in mdata.dims: @@ -616,7 +702,6 @@ def _regrid_and_interpolate_levs(model_dataset, var_name, regrid_dataset=None, r #Interpolate variable to default pressure levels: if has_lev: - if vert_coord_type == "hybrid": #Interpolate from hybrid sigma-pressure to the standard pressure levels: rgdata_interp = pf.lev_to_plev(rgdata, rg_ps, mhya, mhyb, P0=P0, \ @@ -709,4 +794,143 @@ def regrid_data(fromthis, tothis, method=1): return result #End if -##### \ No newline at end of file +##### + + +import numpy as np + +def _regrid(model_dataset, var_name, comp, wgt_file, method, latlon_file, **kwargs): + + """ + Function that takes a variable from a model xarray + dataset, regrids it to another dataset's lat/lon + coordinates (if applicable) + ---------- + model_dataset -> The xarray dataset which contains the model variable data + var_name -> The name of the variable to be regridded/interpolated. + comp -> + wgt_file -> + method -> + latlon_file -> + + Optional inputs: + + kwargs -> Keyword arguments that contain paths to THE REST IS NOT APPLICABLE: surface pressure + and mid-level pressure files, which are necessary for + certain types of vertical interpolation. + This function returns a new xarray dataset that contains the gridded + model variable. + """ + + #Import ADF-specific functions: + from regrid_se_to_fv import make_se_regridder, regrid_se_data_conservative, regrid_se_data_bilinear, regrid_atm_se_data_conservative, regrid_atm_se_data_bilinear + + if comp == "atm": + comp_grid = "ncol" + if comp == "lnd": + comp_grid = "lndgrid" + if latlon_file: + latlon_ds = xr.open_dataset(latlon_file) + else: + print("Looks like no lat lon file is supplied. God speed!") + + model_dataset[var_name] = model_dataset[var_name].fillna(0) + + if comp == "lnd": + model_dataset['landfrac'] = model_dataset['landfrac'].fillna(0) + #mdata = mdata * model_dataset.landfrac # weight flux by land frac + model_dataset[var_name] = model_dataset[var_name] * model_dataset.landfrac # weight flux by land frac + s_data = model_dataset.landmask.isel(time=0) + d_data = latlon_ds.landmask + else: + s_data = None + d_data = None + + #Grid model data to match target grid lat/lon: + regridder = make_se_regridder(weight_file=wgt_file, + s_data = s_data, + d_data = d_data, + Method = method, + ) + + if comp == "lnd": + if method == 'coservative': + rgdata = regrid_se_data_conservative(regridder, model_dataset, comp_grid) + if method == 'bilinear': + rgdata = regrid_se_data_bilinear(regridder, model_dataset, comp_grid) + rgdata[var_name] = (rgdata[var_name] / rgdata.landfrac) + + if comp == "atm": + if method == 'coservative': + rgdata = regrid_atm_se_data_conservative(regridder, model_dataset, comp_grid) + if method == 'bilinear': + rgdata = regrid_atm_se_data_bilinear(regridder, model_dataset, comp_grid) + + + #rgdata['lat'] = latlon_ds.lat #??? + if comp == "lnd": + rgdata['landmask'] = latlon_ds.landmask + rgdata['landfrac'] = rgdata.landfrac.isel(time=0) + + # calculate area + rgdata = _calc_area(rgdata) + + #Return dataset: + return rgdata + + +def _calc_area(rgdata): + # calculate area + area_km2 = np.zeros(shape=(len(rgdata['lat']), len(rgdata['lon']))) + earth_radius_km = 6.37122e3 # in meters + + yres_degN = np.abs(np.diff(rgdata['lat'].data)) # distances between gridcell centers... + xres_degE = np.abs(np.diff(rgdata['lon'])) # ...end up with one less element, so... + yres_degN = np.append(yres_degN, yres_degN[-1]) # shift left (edges <-- centers); assume... + xres_degE = np.append(xres_degE, xres_degE[-1]) # ...last 2 distances bet. edges are equal + + dy_km = yres_degN * earth_radius_km * np.pi / 180 # distance in m + phi_rad = rgdata['lat'].data * np.pi / 180 # degrees to radians + + # grid cell area + for j in range(len(rgdata['lat'])): + for i in range(len(rgdata['lon'])): + dx_km = xres_degE[i] * np.cos(phi_rad[j]) * earth_radius_km * np.pi / 180 # distance in m + area_km2[j,i] = dy_km[j] * dx_km + + rgdata['area'] = xr.DataArray(area_km2, + coords={'lat': rgdata.lat, 'lon': rgdata.lon}, + dims=["lat", "lon"]) + rgdata['area'].attrs['units'] = 'km2' + rgdata['area'].attrs['long_name'] = 'Grid cell area' + + return rgdata + + +def _calculate_area(rgdata): + """ + Compute grid cell area for regridded dataset. + """ + area_km2 = np.zeros((len(rgdata['lat']), len(rgdata['lon']))) + earth_radius_km = 6.37122e3 + + yres_degN = np.abs(np.diff(rgdata['lat'].data)) + xres_degE = np.abs(np.diff(rgdata['lon'])) + + yres_degN = np.append(yres_degN, yres_degN[-1]) + xres_degE = np.append(xres_degE, xres_degE[-1]) + + dy_km = yres_degN * earth_radius_km * np.pi / 180 + phi_rad = rgdata['lat'].data * np.pi / 180 + + for j in range(len(rgdata['lat'])): + for i in range(len(rgdata['lon'])): + dx_km = xres_degE[i] * np.cos(phi_rad[j]) * earth_radius_km * np.pi / 180 + area_km2[j, i] = dy_km[j] * dx_km + + return xr.DataArray(area_km2, coords={'lat': rgdata.lat, 'lon': rgdata.lon}, dims=["lat", "lon"], attrs={'units': 'km2', 'long_name': 'Grid cell area'}) + + + + + From 7f205d1229fadcf88348b58873f1690135af2379 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:37:40 -0600 Subject: [PATCH 013/126] Create global_mean_timeseries_lnd.py --- .../plotting/global_mean_timeseries_lnd.py | 316 ++++++++++++++++++ 1 file changed, 316 insertions(+) create mode 100644 scripts/plotting/global_mean_timeseries_lnd.py diff --git a/scripts/plotting/global_mean_timeseries_lnd.py b/scripts/plotting/global_mean_timeseries_lnd.py new file mode 100644 index 000000000..d19f86fde --- /dev/null +++ b/scripts/plotting/global_mean_timeseries_lnd.py @@ -0,0 +1,316 @@ +"""Use time series files to produce global mean time series plots for ADF web site. + +Includes a minimal Class for bringing CESM2 LENS data +from I. Simpson's directory (to be generalized). + +""" + +from pathlib import Path +from types import NoneType +import warnings # use to warn user about missing files. +import xarray as xr +import matplotlib.pyplot as plt +import plotting_functions as pf + + +def my_formatwarning(msg, *args, **kwargs): + """custom warning""" + # ignore everything except the message + return str(msg) + "\n" + + +warnings.formatwarning = my_formatwarning + + +def global_mean_timeseries_lnd(adfobj): + """ + load time series file, calculate global mean, annual mean + for each case + Make a combined plot, save it, add it to website. + Include the CESM2 LENS result if it can be found. + """ + + #Notify user that script has started: + print("\n Generating global mean time series plots...") + + # Gather ADF configurations + plot_loc = get_plot_loc(adfobj) + plot_type = adfobj.read_config_var("diag_basic_info").get("plot_type", "png") + res = adfobj.variable_defaults # will be dict of variable-specific plot preferences + # or an empty dictionary if use_defaults was not specified in YAML. + + # Loop over variables + for field in adfobj.diag_var_list: + + # Check res for any variable specific options that need to be used BEFORE going to the plot: + if field in res: + vres = res[field] + #If found then notify user, assuming debug log is enabled: + adfobj.debug_log(f"global_mean_timeseries: Found variable defaults for {field}") + else: + vres = {} + + # Extract variables: + # including a simpler way to get a dataset timeseries + baseline_name = adfobj.get_baseline_info("cam_case_name", required=True) + input_ts_baseline = Path(adfobj.get_baseline_info("cam_ts_loc", required=True)) + # TODO hard wired for single case name: + case_name = adfobj.get_cam_info("cam_case_name", required=True)[0] + input_ts_case = Path(adfobj.get_cam_info("cam_ts_loc", required=True)[0]) + + #Create list of time series files present for variable: + baseline_ts_filenames = f'{baseline_name}.*.{field}.*nc' + baseline_ts_files = sorted(input_ts_baseline.glob(baseline_ts_filenames)) + case_ts_filenames = f'{case_name}.*.{field}.*nc' + case_ts_files = sorted(input_ts_case.glob(case_ts_filenames)) + + ref_ts_ds = pf.load_dataset(baseline_ts_files) + weights = ref_ts_ds.landfrac * ref_ts_ds.area + ref_ts_da= ref_ts_ds[field] + + c_ts_ds = pf.load_dataset(case_ts_files) + c_weights = c_ts_ds.landfrac * c_ts_ds.area + c_ts_da= c_ts_ds[field] + + #Extract category (if available): + web_category = vres.get("category", None) + + # get variable defaults + scale_factor = vres.get('scale_factor', 1) + scale_factor_table = vres.get('scale_factor_table', 1) + add_offset = vres.get('add_offset', 0) + avg_method = vres.get('avg_method', 'mean') + if avg_method == 'mean': + weights = weights/weights.sum() + c_weights = c_weights/c_weights.sum() + # get units for variable + ref_ts_da.attrs['units'] = vres.get("new_unit", ref_ts_da.attrs.get('units', 'none')) + ref_ts_da.attrs['units'] = vres.get("table_unit", ref_ts_da.attrs.get('units', 'none')) + units = ref_ts_da.attrs['units'] + + # scale for plotting, if needed + ref_ts_da = ref_ts_da * scale_factor * scale_factor_table + ref_ts_da.attrs['units'] = units + c_ts_da = c_ts_da * scale_factor * scale_factor_table + c_ts_da.attrs['units'] = units + + # Check to see if this field is available + if ref_ts_da is None: + print( + f"\t Variable named {field} provides Nonetype. Skipping this variable" + ) + validate_dims = True + else: + validate_dims = False + # reference time series global average + # TODO, make this more general for land? + ref_ts_da_ga = pf.spatial_average_lnd(ref_ts_da, weights=weights) + c_ts_da_ga = pf.spatial_average_lnd(c_ts_da, weights=c_weights) + + # annually averaged + ref_ts_da = pf.annual_mean(ref_ts_da_ga, whole_years=True, time_name="time") + c_ts_da = pf.annual_mean(c_ts_da_ga, whole_years=True, time_name="time") + + # check if this is a "2-d" varaible: + has_lev_ref = pf.zm_validate_dims(ref_ts_da) + if has_lev_ref: + print( + f"Variable named {field} has a lev dimension, which does not work with this script." + ) + continue + + ## SPECIAL SECTION -- CESM2 LENS DATA: + lens2_data = Lens2Data( + field + ) # Provides access to LENS2 dataset when available (class defined below) + + # Loop over model cases: + case_ts = {} # dictionary of annual mean, global mean time series + # use case nicknames instead of full case names if supplied: + labels = { + case_name: nickname if nickname else case_name + for nickname, case_name in zip( + adfobj.data.test_nicknames, adfobj.data.case_names + ) + } + ref_label = ( + adfobj.data.ref_nickname + if adfobj.data.ref_nickname + else adfobj.data.ref_case_label + ) + + skip_var = False + for case_name in adfobj.data.case_names: + #c_ts_da = adfobj.data.load_timeseries_da(case_name, field) + + if c_ts_da is None: + print( + f"\t Variable named {field} provides Nonetype. Skipping this variable" + ) + skip_var = True + continue + + # If no reference, we still need to check if this is a "2-d" varaible: + if validate_dims: + has_lat_ref, has_lev_ref = pf.zm_validate_dims(c_ts_da) + # End if + + # If 3-d variable, notify user, flag and move to next test case + if has_lev_ref: + print( + f"Variable named {field} has a lev dimension for '{case_name}', which does not work with this script." + ) + + skip_var = True + continue + # End if + + # Gather spatial avg for test case + case_ts[labels[case_name]] = pf.annual_mean(c_ts_da_ga, whole_years=True, time_name="time") + + # If this case is 3-d or missing variable, then break the loop and go to next variable + if skip_var: + continue + + # Plot the timeseries + fig, ax = make_plot( + case_ts, lens2_data, label=adfobj.data.ref_nickname, ref_ts_da=ref_ts_da + ) + + ax.set_ylabel(getattr(ref_ts_da,"unit", units)) # add units + plot_name = plot_loc / f"{field}_GlobalMean_ANN_TimeSeries_Mean.{plot_type}" + + conditional_save(adfobj, plot_name, fig) + + adfobj.add_website_data( + plot_name, + f"{field}_GlobalMean", + None, + season="ANN", + multi_case=True, + plot_type="TimeSeries", + ) + + #Notify user that script has ended: + print(" ... global mean time series plots have been generated successfully.") + + +# Helper/plotting functions +########################### + +def conditional_save(adfobj, plot_name, fig, verbose=None): + """Determines whether to save figure""" + # double check this + if adfobj.get_basic_info("redo_plot") and plot_name.is_file(): + # Case 1: Delete old plot, save new plot + plot_name.unlink() + fig.savefig(plot_name) + elif (adfobj.get_basic_info("redo_plot") and not plot_name.is_file()) or ( + not adfobj.get_basic_info("redo_plot") and not plot_name.is_file() + ): + # Save new plot + fig.savefig(plot_name) + elif not adfobj.get_basic_info("redo_plot") and plot_name.is_file(): + # Case 2: Keep old plot, do not save new plot + if verbose: + print("plot file detected, redo is false, so keep existing file.") + else: + warnings.warn( + f"Conditional save found unknown condition. File will not be written: {plot_name}" + ) + plt.close(fig) +###### + + +def get_plot_loc(adfobj, verbose=None): + """Return the path for plot files. + Contains side-effect: will make the directory and parents if needed. + """ + plot_location = adfobj.plot_location + if not plot_location: + plot_location = adfobj.get_basic_info("cam_diag_plot_loc") + if isinstance(plot_location, list): + for pl in plot_location: + plpth = Path(pl) + # Check if plot output directory exists, and if not, then create it: + if not plpth.is_dir(): + if verbose: + print(f"\t {pl} not found, making new directory") + plpth.mkdir(parents=True) + if len(plot_location) == 1: + plot_loc = Path(plot_location[0]) + else: + if verbose: + print( + f"Ambiguous plotting location since all cases go on same plot. Will put them in first location: {plot_location[0]}" + ) + plot_loc = Path(plot_location[0]) + else: + plot_loc = Path(plot_location) + print(f"Determined plot location: {plot_loc}") + return plot_loc +###### + + +class Lens2Data: + """Access Isla's LENS2 data to get annual means.""" + + def __init__(self, field): + self.field = field + self.has_lens, self.lens2 = self._include_lens() + + def _include_lens(self): + lens2_fil = Path( + f"/glade/campaign/cgd/cas/islas/CESM_DATA/LENS2/global_means/annualmeans/{self.field}_am_LENS2_first50.nc" + ) + if lens2_fil.is_file(): + lens2 = xr.open_mfdataset(lens2_fil) + has_lens = True + else: + warnings.warn(f"Time Series: Did not find LENS2 file for {self.field}.") + has_lens = False + lens2 = None + return has_lens, lens2 +###### + + +def make_plot(case_ts, lens2, label=None, ref_ts_da=None): + """plot yearly values of ref_ts_da""" + field = lens2.field # this will be defined even if no LENS2 data + fig, ax = plt.subplots() + + # Plot reference/baseline if available + if type(ref_ts_da) != NoneType: + ax.plot(ref_ts_da.year, ref_ts_da, label=label) + for c, cdata in case_ts.items(): + ax.plot(cdata.year, cdata, label=c) + if lens2.has_lens: + lensmin = lens2.lens2[field].min("M") # note: "M" is the member dimension + lensmax = lens2.lens2[field].max("M") + ax.fill_between(lensmin.year, lensmin, lensmax, color="lightgray", alpha=0.5) + ax.plot( + lens2.lens2[field].year, + lens2.lens2[field].mean("M"), + color="darkgray", + linewidth=2, + label="LENS2", + ) + # Get the current y-axis limits + ymin, ymax = ax.get_ylim() + # Check if the y-axis crosses zero + if ymin < 0 < ymax: + ax.axhline(y=0, color="lightgray", linestyle="-", linewidth=1) + ax.set_title(field, loc="left") + ax.set_xlabel("YEAR") + # Place the legend + ax.legend( + bbox_to_anchor=(0.5, -0.15), loc="upper center", ncol=min(len(case_ts), 3) + ) + plt.tight_layout(pad=2, w_pad=1.0, h_pad=1.0) + + return fig, ax +###### + + +############## +#END OF SCRIPT From a5b0bcff465bc501fb3375601389da267c2ba72a Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:39:03 -0600 Subject: [PATCH 014/126] Create ldf_variable_defaults.yaml --- lib/ldf_variable_defaults.yaml | 342 +++++++++++++++++++++++++++++++++ 1 file changed, 342 insertions(+) create mode 100644 lib/ldf_variable_defaults.yaml diff --git a/lib/ldf_variable_defaults.yaml b/lib/ldf_variable_defaults.yaml new file mode 100644 index 000000000..2b7e04641 --- /dev/null +++ b/lib/ldf_variable_defaults.yaml @@ -0,0 +1,342 @@ + +#This file lists out variable-specific defaults +#for plotting and observations. These defaults +#are: +# +# PLOTTING: +# +# colormap -> The colormap that will be used for filled contour plots. +# contour_levels -> A list of the specific contour values that will be used for contour plots. +# Cannot be used with "contour_levels_range". +# contour_levels_range -> The contour range that will be used for plots. +# Values are min, max, and stride. Cannot be used with "contour_levels". +# diff_colormap -> The colormap that will be used for filled contour different plots +# diff_contour_levels -> A list of the specific contour values thta will be used for difference plots. +# Cannot be used with "diff_contour_range". +# diff_contour_range -> The contour range that will be used for difference plots. +# Values are min, max, and stride. Cannot be used with "diff_contour_levels". +# scale_factor -> Amount to scale the variable (relative to its "raw" model values). +# add_offset -> Amount of offset to add to the variable (relatie to its "raw" model values). +# new_unit -> Variable units (if not using the "raw" model units). +# mpl -> Dictionary that contains keyword arguments explicitly for matplotlib +# +# mask -> Setting that specifies whether the variable should be masked. +# Currently only accepts "landmask", which means the variable will be masked +# everywhere that isn't land. +# +# +# OBSERVATIONS: +# +# obs_file -> Path to observations file. If only the file name is given, then the file is assumed to +# exist in the path specified by "obs_data_loc" in the config file. +# obs_name -> Name of the observational dataset (mostly used for plotting and generated file naming). +# If this isn't present then the obs_file name is used. +# obs_var_name -> Variable in the observations file to compare against. If this isn't present then the +# variable name is assumed to be the same as the model variable name. +# +# +# +# WEBSITE: +# +# category -> The website category the variable will be placed under. +# +# +# DERIVING: +# +# derivable_from -> If not present in the available output files, the variable can be derived from +# other variables that are present (e.g. PRECT can be derived from PRECC and PRECL), +# which are specified in this list +# NOTE: this is not very flexible at the moment! It can only handle variables that +# are sums of the constituents. Futher flexibility is being explored. +# +# +# Final Note: Please do not modify this file unless you plan to push your changes back to the ADF repo. +# If you would like to modify this file for your personal ADF runs then it is recommended +# to make a copy of this file, make modifications in that copy, and then point the ADF to +# it using the "defaults_file" config variable. +# +#+++++++++++ + +#+++++++++++++ +# Available Land Default Plot Types +#+++++++++++++ +default_ptypes: ["Tables","LatLon","TimeSeries", + "Arctic","RegionalClimo","RegionalTimeSeries","Special"] + +#+++++++++++++ +# Constants +#+++++++++++++ + +#seconds per day : +spd: 86400 +diff_levs: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + +#+++++++++++++ +# Category: Atmosphere +#+++++++++++++ + +TSA: # 2m air temperature + category: "Atmosphere" + colormap: "coolwarm" + contour_levels_range: [250, 310, 10] + +PREC: # RAIN + SNOW + category: "Atmosphere" + colormap: "managua" + derivable_from: ["RAIN","SNOW"] + scale_factor: 86400 + add_offset: 0 + new_unit: "mm d$^{-1}$" + mpl: + colorbar: + label : "mm d$^{-1}$" + diff_colormap: "BrBG" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + +FLDS: # atmospheric longwave radiation + category: "Atmosphere" + colormap: "Oranges" + contour_levels_range: [100, 500, 25] + diff_colormap: "BrBG" + diff_contour_range: [-20, 20, 2] + scale_factor: 1 + add_offset: 0 + new_unit: "Wm$^{-2}$" + mpl: + colorbar: + label : "Wm$^{-2}$" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + +FSDS: # atmospheric incident solar radiation + category: "Atmosphere" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + +WIND: # atmospheric air temperature + category: "Atmosphere" + +QBOT: # atmospheric specific humidity + category: "Atmosphere" + +TBOT: + category: "Atmosphere" + colormap: "coolwarm" + contour_levels_range: [250, 310, 10] + +TREFMNAV: # daily minimum of average 2m temperature + category: "Atmosphere" + colormap: "coolwarm" + contour_levels_range: [250, 310, 10] + + +TREFMXAV: # daily maximum of average 2m temperature + category: "Atmosphere" + colormap: "cool warm" + contour_levels_range: [250, 310, 10] + + +#+++++++++++ +# Category: Surface fluxes +#+++++++++++ + +ASA: # all-sky albedo:FSR/FSDS + category: "Surface fluxes" + colormap: "RdBu_r" + diff_colormap: "BrBG" + derivable_from: ["FSR", "FSDS"] + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + +FSA: # absorbed solar radiation + category: "Surface fluxes" + +FSH: # sensible heat + category: "Surface fluxes" + + +ET: # latent heat: FCTR+FCEV+FGEV + category: "Surface fluxes" + derivable_from: ["FCTR","FCEV","FGEV"] + colormap: "Blues" + contour_levels_range: [0, 220, 10] + diff_colormap: "BrBG" + diff_contour_range: [-45, 45, 5] + scale_factor: 1 + add_offset: 0 + new_unit: "Wm$^{-2}$" + mpl: + colorbar: + label : "Wm$^{-2}$" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + +DSTFLXT: # total surface dust emission + category: "Surface fluxes" + colormap: "Browns" + diff_colormap: "BrBG_r" + scale_factor: 86400 + add_offset: 0 + new_unit: "kg m$^{-2}$ d$^{-1}" + mpl: + colorbar: + label : "kg m$^{-2}$ d$^{-1}" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + scale_factor_table: 0.000365 #days to years, kg/m2 to Pg globally + avg_method: 'sum' + table_unit: "Pg y$^{-1}" + +MEG_isoprene: # total surface dust emission + category: "Surface fluxes" + colormap: "Browns" + diff_colormap: "BrBG_r" + scale_factor: 86400 + add_offset: 0 + new_unit: "kg m$^{-2}$ d$^{-1}" + mpl: + colorbar: + label : "kg m$^{-2}$ d$^{-1}" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + scale_factor_table: 0.365 #days to years, kg/m2 to Tg globally + avg_method: 'sum' + table_unit: "Tg y$^{-1}" + + +#+++++++++++ +# Category: Hydrology +#+++++++++++ +FSNO: # fraction of ground covered by snow + category: "Hydrology" + + +H2OSNO: # SNOWICE + SNOWLIQ + category: "Hydrology" + + +SNOWDP: # snow height + category: "Hydrology" + + +TOTRUNOFF: # total liquid runoff + category: "Hydrology" + derivable_from: ["QOVER","QDRAI","QRGWL"] #TODO, check accuracy + colormap: "Blues" + scale_factor: 86400 + add_offset: 0 + new_unit: "mm d$^{-1}$" + mpl: + colorbar: + label : "mm d$^{-1}$" + +#+++++++++++ +# Category: Vegetation +#+++++++++++ +BTRANMN: # Transpiration beta factor + category: "Vegetation" # Or hydrology? + +ELAI: # exposed one-sided leaf area index + category: "Vegetation" + colormap: "gist_earth_r" + contour_levels_range: [0., 7., 1.0] + diff_colormap: "PuOr_r" + diff_contour_range: [-3.,3.,0.5] + + +HTOP: # canopy top height + category: "Vegetation" + + +TSAI: # total one-sided stem area index + category: "Vegetation" + + +#+++++++++++ +# Category: Carbon +#+++++++++++ +GPP: # Gross Primary Production + category: "Carbon" + colormap: "gist_earth_r" + contour_levels_range: [0., 8., 0.5] + diff_colormap: "BrBG" + diff_contour_range: [-4.,4.,0.5] + scale_factor: 86400 + add_offset: 0 + new_unit: "gC m$^{-2} d$^{-1}" + mpl: + colorbar: #TODO make this print correctly + label : "gC ${m^-2 d^-1}" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally + avg_method: 'sum' + table_unit: "PgC y$^{-1}" + +AR: # Autotrophic Respiration + category: "Carbon" + colormap: "gist_earth_r" + contour_levels_range: [0., 3., 0.25] + diff_colormap: "BrBG" + diff_contour_range: [-1.5, 1.5, 0.25] + scale_factor: 86400 + add_offset: 0 + new_unit: "gC m$^{-2} d$^{-1}" + mpl: + colorbar: + label : "gC m$^{-2} d$^{-1}" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally + avg_method: 'sum' + table_unit: "PgC y$^{-1}" + +NPP: # Net Primary Production + category: "Carbon" + colormap: "gist_earth_r" + contour_levels_range: [0., 3., 0.25] + diff_colormap: "PuOr_r" + diff_contour_range: [-1.5, 1.5, 0.25] + scale_factor: 86400 + add_offset: 0 + new_unit: "gC m$^{-2} d$^{-1}" + mpl: + colorbar: + label : "gC m$^{-2} d$^{-1}" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PuOr_r" + scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally + avg_method: 'sum' + table_unit: "PgC y$^{-1}" + +TOTECOSYSC_1m: + category: "Carbon" + scale_factor_table: 0.000000001 #g/m2 to Pg globally + avg_method: 'sum' + table_unit: "PgC" + +TOTSOMC_1m: + category: "Carbon" + + +TOTVEGC: + category: "Carbon" + + +#+++++++++++ +# Category: Soils +#+++++++++++ +ALTMAX: # Active Layer Thickness + category: "Soils" + + +SOILWATER_10CM: # soil liquid water + ice in top 10cm of soil + category: "Soils" # or hydrology? + +TSOI_10CM: # Soil temperature, 0-10 cm + category: "Soils" + + + +#End of File From 59024ce800408585f277d6dd9032892dad81fb04 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:47:00 -0600 Subject: [PATCH 015/126] Delete ldf_variable_defaults.yaml --- ldf_variable_defaults.yaml | 342 ------------------------------------- 1 file changed, 342 deletions(-) delete mode 100644 ldf_variable_defaults.yaml diff --git a/ldf_variable_defaults.yaml b/ldf_variable_defaults.yaml deleted file mode 100644 index 2b7e04641..000000000 --- a/ldf_variable_defaults.yaml +++ /dev/null @@ -1,342 +0,0 @@ - -#This file lists out variable-specific defaults -#for plotting and observations. These defaults -#are: -# -# PLOTTING: -# -# colormap -> The colormap that will be used for filled contour plots. -# contour_levels -> A list of the specific contour values that will be used for contour plots. -# Cannot be used with "contour_levels_range". -# contour_levels_range -> The contour range that will be used for plots. -# Values are min, max, and stride. Cannot be used with "contour_levels". -# diff_colormap -> The colormap that will be used for filled contour different plots -# diff_contour_levels -> A list of the specific contour values thta will be used for difference plots. -# Cannot be used with "diff_contour_range". -# diff_contour_range -> The contour range that will be used for difference plots. -# Values are min, max, and stride. Cannot be used with "diff_contour_levels". -# scale_factor -> Amount to scale the variable (relative to its "raw" model values). -# add_offset -> Amount of offset to add to the variable (relatie to its "raw" model values). -# new_unit -> Variable units (if not using the "raw" model units). -# mpl -> Dictionary that contains keyword arguments explicitly for matplotlib -# -# mask -> Setting that specifies whether the variable should be masked. -# Currently only accepts "landmask", which means the variable will be masked -# everywhere that isn't land. -# -# -# OBSERVATIONS: -# -# obs_file -> Path to observations file. If only the file name is given, then the file is assumed to -# exist in the path specified by "obs_data_loc" in the config file. -# obs_name -> Name of the observational dataset (mostly used for plotting and generated file naming). -# If this isn't present then the obs_file name is used. -# obs_var_name -> Variable in the observations file to compare against. If this isn't present then the -# variable name is assumed to be the same as the model variable name. -# -# -# -# WEBSITE: -# -# category -> The website category the variable will be placed under. -# -# -# DERIVING: -# -# derivable_from -> If not present in the available output files, the variable can be derived from -# other variables that are present (e.g. PRECT can be derived from PRECC and PRECL), -# which are specified in this list -# NOTE: this is not very flexible at the moment! It can only handle variables that -# are sums of the constituents. Futher flexibility is being explored. -# -# -# Final Note: Please do not modify this file unless you plan to push your changes back to the ADF repo. -# If you would like to modify this file for your personal ADF runs then it is recommended -# to make a copy of this file, make modifications in that copy, and then point the ADF to -# it using the "defaults_file" config variable. -# -#+++++++++++ - -#+++++++++++++ -# Available Land Default Plot Types -#+++++++++++++ -default_ptypes: ["Tables","LatLon","TimeSeries", - "Arctic","RegionalClimo","RegionalTimeSeries","Special"] - -#+++++++++++++ -# Constants -#+++++++++++++ - -#seconds per day : -spd: 86400 -diff_levs: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - -#+++++++++++++ -# Category: Atmosphere -#+++++++++++++ - -TSA: # 2m air temperature - category: "Atmosphere" - colormap: "coolwarm" - contour_levels_range: [250, 310, 10] - -PREC: # RAIN + SNOW - category: "Atmosphere" - colormap: "managua" - derivable_from: ["RAIN","SNOW"] - scale_factor: 86400 - add_offset: 0 - new_unit: "mm d$^{-1}$" - mpl: - colorbar: - label : "mm d$^{-1}$" - diff_colormap: "BrBG" - pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pct_diff_colormap: "PuOr_r" - -FLDS: # atmospheric longwave radiation - category: "Atmosphere" - colormap: "Oranges" - contour_levels_range: [100, 500, 25] - diff_colormap: "BrBG" - diff_contour_range: [-20, 20, 2] - scale_factor: 1 - add_offset: 0 - new_unit: "Wm$^{-2}$" - mpl: - colorbar: - label : "Wm$^{-2}$" - pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pct_diff_colormap: "PuOr_r" - -FSDS: # atmospheric incident solar radiation - category: "Atmosphere" - pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pct_diff_colormap: "PuOr_r" - -WIND: # atmospheric air temperature - category: "Atmosphere" - -QBOT: # atmospheric specific humidity - category: "Atmosphere" - -TBOT: - category: "Atmosphere" - colormap: "coolwarm" - contour_levels_range: [250, 310, 10] - -TREFMNAV: # daily minimum of average 2m temperature - category: "Atmosphere" - colormap: "coolwarm" - contour_levels_range: [250, 310, 10] - - -TREFMXAV: # daily maximum of average 2m temperature - category: "Atmosphere" - colormap: "cool warm" - contour_levels_range: [250, 310, 10] - - -#+++++++++++ -# Category: Surface fluxes -#+++++++++++ - -ASA: # all-sky albedo:FSR/FSDS - category: "Surface fluxes" - colormap: "RdBu_r" - diff_colormap: "BrBG" - derivable_from: ["FSR", "FSDS"] - pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pct_diff_colormap: "PuOr_r" - -FSA: # absorbed solar radiation - category: "Surface fluxes" - -FSH: # sensible heat - category: "Surface fluxes" - - -ET: # latent heat: FCTR+FCEV+FGEV - category: "Surface fluxes" - derivable_from: ["FCTR","FCEV","FGEV"] - colormap: "Blues" - contour_levels_range: [0, 220, 10] - diff_colormap: "BrBG" - diff_contour_range: [-45, 45, 5] - scale_factor: 1 - add_offset: 0 - new_unit: "Wm$^{-2}$" - mpl: - colorbar: - label : "Wm$^{-2}$" - pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pct_diff_colormap: "PuOr_r" - -DSTFLXT: # total surface dust emission - category: "Surface fluxes" - colormap: "Browns" - diff_colormap: "BrBG_r" - scale_factor: 86400 - add_offset: 0 - new_unit: "kg m$^{-2}$ d$^{-1}" - mpl: - colorbar: - label : "kg m$^{-2}$ d$^{-1}" - pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pct_diff_colormap: "PuOr_r" - scale_factor_table: 0.000365 #days to years, kg/m2 to Pg globally - avg_method: 'sum' - table_unit: "Pg y$^{-1}" - -MEG_isoprene: # total surface dust emission - category: "Surface fluxes" - colormap: "Browns" - diff_colormap: "BrBG_r" - scale_factor: 86400 - add_offset: 0 - new_unit: "kg m$^{-2}$ d$^{-1}" - mpl: - colorbar: - label : "kg m$^{-2}$ d$^{-1}" - pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pct_diff_colormap: "PuOr_r" - scale_factor_table: 0.365 #days to years, kg/m2 to Tg globally - avg_method: 'sum' - table_unit: "Tg y$^{-1}" - - -#+++++++++++ -# Category: Hydrology -#+++++++++++ -FSNO: # fraction of ground covered by snow - category: "Hydrology" - - -H2OSNO: # SNOWICE + SNOWLIQ - category: "Hydrology" - - -SNOWDP: # snow height - category: "Hydrology" - - -TOTRUNOFF: # total liquid runoff - category: "Hydrology" - derivable_from: ["QOVER","QDRAI","QRGWL"] #TODO, check accuracy - colormap: "Blues" - scale_factor: 86400 - add_offset: 0 - new_unit: "mm d$^{-1}$" - mpl: - colorbar: - label : "mm d$^{-1}$" - -#+++++++++++ -# Category: Vegetation -#+++++++++++ -BTRANMN: # Transpiration beta factor - category: "Vegetation" # Or hydrology? - -ELAI: # exposed one-sided leaf area index - category: "Vegetation" - colormap: "gist_earth_r" - contour_levels_range: [0., 7., 1.0] - diff_colormap: "PuOr_r" - diff_contour_range: [-3.,3.,0.5] - - -HTOP: # canopy top height - category: "Vegetation" - - -TSAI: # total one-sided stem area index - category: "Vegetation" - - -#+++++++++++ -# Category: Carbon -#+++++++++++ -GPP: # Gross Primary Production - category: "Carbon" - colormap: "gist_earth_r" - contour_levels_range: [0., 8., 0.5] - diff_colormap: "BrBG" - diff_contour_range: [-4.,4.,0.5] - scale_factor: 86400 - add_offset: 0 - new_unit: "gC m$^{-2} d$^{-1}" - mpl: - colorbar: #TODO make this print correctly - label : "gC ${m^-2 d^-1}" - pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pct_diff_colormap: "PuOr_r" - scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally - avg_method: 'sum' - table_unit: "PgC y$^{-1}" - -AR: # Autotrophic Respiration - category: "Carbon" - colormap: "gist_earth_r" - contour_levels_range: [0., 3., 0.25] - diff_colormap: "BrBG" - diff_contour_range: [-1.5, 1.5, 0.25] - scale_factor: 86400 - add_offset: 0 - new_unit: "gC m$^{-2} d$^{-1}" - mpl: - colorbar: - label : "gC m$^{-2} d$^{-1}" - pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pct_diff_colormap: "PuOr_r" - scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally - avg_method: 'sum' - table_unit: "PgC y$^{-1}" - -NPP: # Net Primary Production - category: "Carbon" - colormap: "gist_earth_r" - contour_levels_range: [0., 3., 0.25] - diff_colormap: "PuOr_r" - diff_contour_range: [-1.5, 1.5, 0.25] - scale_factor: 86400 - add_offset: 0 - new_unit: "gC m$^{-2} d$^{-1}" - mpl: - colorbar: - label : "gC m$^{-2} d$^{-1}" - pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pct_diff_colormap: "PuOr_r" - scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally - avg_method: 'sum' - table_unit: "PgC y$^{-1}" - -TOTECOSYSC_1m: - category: "Carbon" - scale_factor_table: 0.000000001 #g/m2 to Pg globally - avg_method: 'sum' - table_unit: "PgC" - -TOTSOMC_1m: - category: "Carbon" - - -TOTVEGC: - category: "Carbon" - - -#+++++++++++ -# Category: Soils -#+++++++++++ -ALTMAX: # Active Layer Thickness - category: "Soils" - - -SOILWATER_10CM: # soil liquid water + ice in top 10cm of soil - category: "Soils" # or hydrology? - -TSOI_10CM: # Soil temperature, 0-10 cm - category: "Soils" - - - -#End of File From 5ba90ff6277c87f38db00afb1c69ad6e7cce18e3 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 14:48:20 -0600 Subject: [PATCH 016/126] Create LAND-DIAGS_README.md --- LAND-DIAGS_README.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 LAND-DIAGS_README.md diff --git a/LAND-DIAGS_README.md b/LAND-DIAGS_README.md new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/LAND-DIAGS_README.md @@ -0,0 +1 @@ + From 5b7c883b263ac78cf343d9895d454518cc2445a1 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 15:04:41 -0600 Subject: [PATCH 017/126] Create config_unstructured_plots.yaml Template for plotting unstructured grids --- config_unstructured_plots.yaml | 296 +++++++++++++++++++++++++++++++++ 1 file changed, 296 insertions(+) create mode 100644 config_unstructured_plots.yaml diff --git a/config_unstructured_plots.yaml b/config_unstructured_plots.yaml new file mode 100644 index 000000000..cdffdeebd --- /dev/null +++ b/config_unstructured_plots.yaml @@ -0,0 +1,296 @@ +#============================== +#config_cam_baseline_example.yaml + +#This is the main CAM diagnostics config file +#for doing comparisons of a CAM run against +#another CAM run, or a CAM baseline simulation. + +#Currently, if one is on NCAR's Casper or +#Cheyenne machine, then only the diagnostic output +#paths are needed, at least to perform a quick test +#run (these are indicated with "MUST EDIT" comments). +#Running these diagnostics on a different machine, +#or with a different, non-example simulation, will +#require additional modifications. +# +#Config file Keywords: +#-------------------- +# +#1. Using ${xxx} will substitute that text with the +# variable referenced by xxx. For example: +# +# cam_case_name: cool_run +# cam_climo_loc: /some/where/${cam_case_name} +# +# will set "cam_climo_loc" in the diagnostics package to: +# /some/where/cool_run +# +# Please note that currently this will only work if the +# variable only exists in one location in the file. +# +#2. Using ${.xxx} will do the same as +# keyword 1 above, but specifies which sub-section the +# variable is coming from, which is necessary for variables +# that are repeated in different subsections. For example: +# +# diag_basic_info: +# cam_climo_loc: /some/where/${diag_cam_climo.start_year} +# +# diag_cam_climo: +# start_year: 1850 +# +# will set "cam_climo_loc" in the diagnostics package to: +# /some/where/1850 +# +#Finally, please note that for both 1 and 2 the keywords must be lowercase. +#This is because future developments will hopefully use other keywords +#that are uppercase. Also please avoid using periods (".") in variable +#names, as this will likely cause issues with the current file parsing +#system. +#-------------------- +# +##============================== +# +# This file doesn't (yet) read environment variables, so the user must +# set this themselves. It is also a good idea to search the doc for 'user' +# to see what default paths are being set for output/working files. +# +# Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script +# to check for a failure to customize +# +user: '' + +#This first set of variables specify basic info used by all diagnostic runs: +diag_basic_info: + + #Does the user want plotting of unstructured (native) grid? + #If "false" or missing, then the ADF expects ALL cases to be on lat/lon grids: + unstructured_plotting: true + + #Is this a model vs observations comparison? + #If "false" or missing, then a model-model comparison is assumed: + compare_obs: false + + #Generate HTML website (assumed false if missing): + #Note: The website files themselves will be located in the path + #specified by "cam_diag_plot_loc", under the "/website" subdirectory, + #where "" is the subdirectory created for this particular diagnostics run + #(usually "case_vs_obs_XXX" or "case_vs_baseline_XXX"). + create_html: true + + #Location of observational datasets: + #Note: this only matters if "compare_obs" is true and the path + #isn't specified in the variable defaults file. + obs_data_loc: /glade/campaign/cgd/amp/amwg/ADF_obs + + #Location where re-gridded and interpolated CAM climatology files are stored: + cam_regrid_loc: ${diag_loc}regrid/ + + #Overwrite CAM re-gridded files? + #If false, or missing, then regridding will be skipped for regridded variables + #that already exist in "cam_regrid_loc": + cam_overwrite_regrid: false + + #Location where diagnostic plots are stored: + cam_diag_plot_loc: ${diag_loc}diag-plot/ + + #Location of ADF variable plotting defaults YAML file: + #If left blank or missing, ADF/lib/adf_variable_defaults.yaml will be used + #Uncomment and change path for custom variable defaults file + defaults_file: ldf_variable_defaults.yaml + + #Longitude line on which to center all lat/lon maps. + #If this config option is missing then the central + #longitude will default to 180 degrees E. + central_longitude: 0 + + #Number of processors on which to run the ADF. + #If this config variable isn't present then + #the ADF defaults to one processor. Also, if + #you set it to "*" then it will default + #to all of the processors available on a + #single node/machine: + num_procs: 8 + + #If set to true, then redo all plots even if they already exist. + #If set to false, then if a plot is found it will be skipped: + redo_plot: true + +#This second set of variables provides info for the CAM simulation(s) being diagnosed: +diag_cam_climo: + + # History file list of strings to match + # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] + # Only affects timeseries as everything else uses the created timeseries + # Default: + hist_str: clm2.h0 + + #Calculate climatologies? + #If false, the climatology files will not be created: + calc_cam_climo: true + + #Location of CAM climatologies (to be created and then used by this script) + cam_climo_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/climo + + #Overwrite CAM climatology files? + #If false, or not prsent, then already existing climatology files will be skipped: + cam_overwrite_climo: false + + #Name of CAM case (or CAM run name): + cam_case_name: b.e30_beta05.BLT1850.ne30_t232_wgx3.123 + + #Case nickname + #NOTE: if nickname starts with '0' - nickname must be in quotes! + # ie '026a' as opposed to 026a + #If missing or left blank, will default to cam_case_name + case_nickname: '123' + + #Location of CAM history (h0) files: + cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ + + # If unstructured_plotting, a mesh file is required! + mesh_file: /glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc + + #model year when time series files should start: + #Note: Leaving this entry blank will make time series + # start at earliest available year. + start_year: 25 + + #model year when time series files should end: + #Note: Leaving this entry blank will make time series + # end at latest available year. + end_year: 35 + + #Do time series files exist? + #If True, then diagnostics assumes that model files are already time series. + #If False, or if simply not present, then diagnostics will attempt to create + #time series files from history (time-slice) files: + cam_ts_done: false + + #Save interim time series files? + #WARNING: This can take up a significant amount of space, + # but will save processing time the next time + cam_ts_save: false + + #Overwrite time series files, if found? + #If set to false, then time series creation will be skipped if files are found: + cam_overwrite_ts: false + + #Location where time series files are (or will be) stored: + cam_ts_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/ts + + +#This third set of variables provide info for the CAM baseline climatologies. +#This only matters if "compare_obs" is false: +diag_cam_baseline_climo: + + # History file list of strings to match + # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] + # Only affects timeseries as everything else uses the created timeseries + # Default: + hist_str: clm2.h0 + + #Calculate cam baseline climatologies? + #If false, the climatology files will not be created: + calc_cam_climo: true + + #Overwrite CAM climatology files? + #If false, or not present, then already existing climatology files will be skipped: + cam_overwrite_climo: false + + #Name of CAM baseline case: + cam_case_name: b.e30_beta05.BLT1850.ne30_t232_wgx3.122 + + #Baseline case nickname + #NOTE: if nickname starts with '0' - nickname must be in quotes! + # ie '026a' as opposed to 026a + #If missing or left blank, will default to cam_case_name + case_nickname: '122' + + #Location of CAM baseline history (h0) files: + #Example test files + cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist/ + + # If unstructured_plotting, a mesh file is required! + mesh_file: /glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc + + #Location of baseline CAM climatologies: + cam_climo_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_baseline_climo.cam_case_name}/climo + + #model year when time series files should start: + #Note: Leaving this entry blank will make time series + # start at earliest available year. + start_year: 25 + + #model year when time series files should end: + #Note: Leaving this entry blank will make time series + # end at latest available year. + end_year: 35 + + #Do time series files need to be generated? + #If True, then diagnostics assumes that model files are already time series. + #If False, or if simply not present, then diagnostics will attempt to create + #time series files from history (time-slice) files: + cam_ts_done: false + + #Save interim time series files for baseline run? + #WARNING: This can take up a significant amount of space: + cam_ts_save: true + + #Overwrite baseline time series files, if found? + #If set to false, then time series creation will be skipped if files are found: + cam_overwrite_ts: false + + #Location where time series files are (or will be) stored: + cam_ts_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_baseline_climo.cam_case_name}/ts + + + +#+++++++++++++++++++++++++++++++++++++++++++++++++++ +#These variables below only matter if you are using +#a non-standard method, or are adding your own +#diagnostic scripts. +#+++++++++++++++++++++++++++++++++++++++++++++++++++ + +#Note: If you want to pass arguments to a particular script, you can +#do it like so (using the "averaging_example" script in this case): +# - {create_climo_files: {kwargs: {clobber: true}}} + +#Name of time-averaging scripts being used to generate climatologies. +#These scripts must be located in "scripts/averaging": +time_averaging_scripts: + - create_climo_files + +#Name of regridding scripts being used. +#These scripts must be located in "scripts/regridding": +regridding_scripts: + #- regrid_and_vert_interp + +#List of analysis scripts being used. +#These scripts must be located in "scripts/analysis": +analysis_scripts: + - lmwg_table + +#List of plotting scripts being used. +#These scripts must be located in "scripts/plotting": +plotting_scripts: + - global_latlon_map + - global_mean_timeseries_lnd + - polar_map + +#List of CAM variables that will be processesd: +#If CVDP is to be run PSL, TREFHT, TS and PRECT (or PRECC and PRECL) should be listed +diag_var_list: + #- TSA + - PREC + - ELAI + - GPP +# - NPP +# - FSDS +# - ALTMAX + - ET + - TOTRUNOFF + - DSTFLXT + - MEG_isoprene + +#END OF FILE From 9320791d7bd0dc67da2bcc8a357bee1be6c03ce4 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 15:24:51 -0600 Subject: [PATCH 018/126] Update config_unstructured_plots.yaml --- config_unstructured_plots.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config_unstructured_plots.yaml b/config_unstructured_plots.yaml index cdffdeebd..8b6365350 100644 --- a/config_unstructured_plots.yaml +++ b/config_unstructured_plots.yaml @@ -58,7 +58,7 @@ # Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script # to check for a failure to customize # -user: '' +user: 'USER-NAME-NOT-SET' #This first set of variables specify basic info used by all diagnostic runs: diag_basic_info: From 679c0bd9fe6295dcf2d19a6280638910f10f5fbc Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 15:26:13 -0600 Subject: [PATCH 019/126] Update config_unstructured_plots.yaml --- config_unstructured_plots.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/config_unstructured_plots.yaml b/config_unstructured_plots.yaml index 8b6365350..d37721e73 100644 --- a/config_unstructured_plots.yaml +++ b/config_unstructured_plots.yaml @@ -84,7 +84,7 @@ diag_basic_info: obs_data_loc: /glade/campaign/cgd/amp/amwg/ADF_obs #Location where re-gridded and interpolated CAM climatology files are stored: - cam_regrid_loc: ${diag_loc}regrid/ + cam_regrid_loc: /glade/derecho/scratch/${user}/ADF/regrid #Overwrite CAM re-gridded files? #If false, or missing, then regridding will be skipped for regridded variables @@ -92,7 +92,7 @@ diag_basic_info: cam_overwrite_regrid: false #Location where diagnostic plots are stored: - cam_diag_plot_loc: ${diag_loc}diag-plot/ + cam_diag_plot_loc: /glade/derecho/scratch/${user}/ADF/plots #Location of ADF variable plotting defaults YAML file: #If left blank or missing, ADF/lib/adf_variable_defaults.yaml will be used From 1e11e6c022bb95dca3930eac25e054bda7ef73ea Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 15:29:33 -0600 Subject: [PATCH 020/126] Update config_clm_baseline_example.yaml --- config_clm_baseline_example.yaml | 42 ++++---------------------------- 1 file changed, 5 insertions(+), 37 deletions(-) diff --git a/config_clm_baseline_example.yaml b/config_clm_baseline_example.yaml index 15ec91fe8..0759c2e7a 100644 --- a/config_clm_baseline_example.yaml +++ b/config_clm_baseline_example.yaml @@ -58,7 +58,7 @@ # Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script # to check for a failure to customize # -user: 'wwieder' +user: 'USER-NAME-NOT-SET' #This first set of variables specify basic info used by all diagnostic runs: @@ -80,21 +80,13 @@ diag_basic_info: #isn't specified in the variable defaults file. obs_data_loc: /glade/campaign/cgd/amp/amwg/ADF_obs - #Location where CAM climatology files are stored: - cam_climo_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/climo - #Location where re-gridded and interpolated CAM climatology files are stored: - cam_climo_regrid_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/climo/regrid - - #Location where re-gridded and interpolated timeseries files are stored: - cam_ts_regrid_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/ts/regrid - + cam_regrid_loc: /glade/derecho/scratch/${user}/ADF/regrid #Overwrite CAM re-gridded files? #If false, or missing, then regridding will be skipped for regridded variables - #that already exist in "cam_climo_regrid_loc" or "cam_ts_regrid_loc": - cam_overwrite_climo_regrid: false - cam_overwrite_ts_regrid: false + #that already exist in "cam_regrid_loc": + cam_overwrite_regrid: false #Location where diagnostic plots are stored: cam_diag_plot_loc: /glade/derecho/scratch/${user}/ADF/plots @@ -153,16 +145,6 @@ diag_cam_climo: #Example test files cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_climo.cam_case_name}/lnd/hist - # SE to FV regridding options - # Leave these blank if not on the native grid - #----------------------------- - # Weights file: - weights_file: /glade/work/wwieder/map_ne30pg3_to_fv0.9x1.25_scripgrids_conserve_nomask_c250108.nc - # Regridding method: - regrid_method: 'coservative' #xesmf bug, missing 'n'! - # File with appropriate lat/lon values for regridding native to FV : - latlon_file: /glade/derecho/scratch/wwieder/ctsm5.3.018_SP_f09_t232_mask/run/ctsm5.3.018_SP_f09_t232_mask.clm2.h0.0001-01.nc - #Calculate climatologies? #If false, the climatology files will not be created: calc_cam_climo: true @@ -293,16 +275,6 @@ diag_cam_baseline_climo: #Example test files cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist - # SE to FV regridding options - # Leave these blank if not on the native grid - #----------------------------- - # Weights file: - weights_file: /glade/work/wwieder/map_ne30pg3_to_fv0.9x1.25_scripgrids_conserve_nomask_c250108.nc - # Regridding method: - regrid_method: 'coservative' #xesmf bug, missing 'n'! - # File with appropriate lat/lon values for regridding native to FV : - latlon_file: /glade/derecho/scratch/wwieder/ctsm5.3.018_SP_f09_t232_mask/run/ctsm5.3.018_SP_f09_t232_mask.clm2.h0.0001-01.nc - #Calculate cam baseline climatologies? #If false, the climatology files will not be created: calc_cam_climo: true @@ -456,12 +428,8 @@ analysis_scripts: #These scripts must be located in "scripts/plotting": plotting_scripts: - global_latlon_map - #- global_mean_timeseries - #- global_latlon_vect_map - #- zonal_mean - #- meridional_mean + - global_mean_timeseries_lnd - polar_map - #- cam_taylor_diagram #- regional_map_multicase #To use this please un-comment and fill-out #the "region_multicase" section below From 5fb050d511d848acbf590799246f8167b77504e5 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 15:29:42 -0600 Subject: [PATCH 021/126] Create config_ldf_native_grid_to_latlon.yaml --- config_ldf_native_grid_to_latlon.yaml | 311 ++++++++++++++++++++++++++ 1 file changed, 311 insertions(+) create mode 100644 config_ldf_native_grid_to_latlon.yaml diff --git a/config_ldf_native_grid_to_latlon.yaml b/config_ldf_native_grid_to_latlon.yaml new file mode 100644 index 000000000..0d108138e --- /dev/null +++ b/config_ldf_native_grid_to_latlon.yaml @@ -0,0 +1,311 @@ +#============================== +#config_cam_baseline_example.yaml + +#This is the main CAM diagnostics config file +#for doing comparisons of a CAM run against +#another CAM run, or a CAM baseline simulation. + +#Currently, if one is on NCAR's Casper or +#Cheyenne machine, then only the diagnostic output +#paths are needed, at least to perform a quick test +#run (these are indicated with "MUST EDIT" comments). +#Running these diagnostics on a different machine, +#or with a different, non-example simulation, will +#require additional modifications. +# +#Config file Keywords: +#-------------------- +# +#1. Using ${xxx} will substitute that text with the +# variable referenced by xxx. For example: +# +# cam_case_name: cool_run +# cam_climo_loc: /some/where/${cam_case_name} +# +# will set "cam_climo_loc" in the diagnostics package to: +# /some/where/cool_run +# +# Please note that currently this will only work if the +# variable only exists in one location in the file. +# +#2. Using ${.xxx} will do the same as +# keyword 1 above, but specifies which sub-section the +# variable is coming from, which is necessary for variables +# that are repeated in different subsections. For example: +# +# diag_basic_info: +# cam_climo_loc: /some/where/${diag_cam_climo.start_year} +# +# diag_cam_climo: +# start_year: 1850 +# +# will set "cam_climo_loc" in the diagnostics package to: +# /some/where/1850 +# +#Finally, please note that for both 1 and 2 the keywords must be lowercase. +#This is because future developments will hopefully use other keywords +#that are uppercase. Also please avoid using periods (".") in variable +#names, as this will likely cause issues with the current file parsing +#system. +#-------------------- +# +##============================== +# +# This file doesn't (yet) read environment variables, so the user must +# set this themselves. It is also a good idea to search the doc for 'user' +# to see what default paths are being set for output/working files. +# +# Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script +# to check for a failure to customize +# +user: 'USER-NAME-NOT-SET' + +#This first set of variables specify basic info used by all diagnostic runs: +diag_basic_info: + + #Does the user want plotting of unstructured (native) grid? + #If "false" or missing, then the ADF expects ALL cases to be on lat/lon grids: + unstructured_plotting: false + + #Is this a model vs observations comparison? + #If "false" or missing, then a model-model comparison is assumed: + compare_obs: false + + #Generate HTML website (assumed false if missing): + #Note: The website files themselves will be located in the path + #specified by "cam_diag_plot_loc", under the "/website" subdirectory, + #where "" is the subdirectory created for this particular diagnostics run + #(usually "case_vs_obs_XXX" or "case_vs_baseline_XXX"). + create_html: true + + #Location of observational datasets: + #Note: this only matters if "compare_obs" is true and the path + #isn't specified in the variable defaults file. + obs_data_loc: /glade/campaign/cgd/amp/amwg/ADF_obs + + #Location where re-gridded and interpolated CAM climatology files are stored: + cam_regrid_loc: /glade/derecho/scratch/${user}/ADF/regrid + + #Overwrite CAM re-gridded files? + #If false, or missing, then regridding will be skipped for regridded variables + #that already exist in "cam_regrid_loc": + cam_overwrite_regrid: false + + #Location where diagnostic plots are stored: + cam_diag_plot_loc: /glade/derecho/scratch/${user}/ADF/plots + + #Location of ADF variable plotting defaults YAML file: + #If left blank or missing, ADF/lib/adf_variable_defaults.yaml will be used + #Uncomment and change path for custom variable defaults file + defaults_file: ldf_variable_defaults.yaml + + #Longitude line on which to center all lat/lon maps. + #If this config option is missing then the central + #longitude will default to 180 degrees E. + central_longitude: 180 + + #Number of processors on which to run the ADF. + #If this config variable isn't present then + #the ADF defaults to one processor. Also, if + #you set it to "*" then it will default + #to all of the processors available on a + #single node/machine: + num_procs: 8 + + #If set to true, then redo all plots even if they already exist. + #If set to false, then if a plot is found it will be skipped: + redo_plot: true + +#This second set of variables provides info for the CAM simulation(s) being diagnosed: +diag_cam_climo: + + # History file list of strings to match + # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] + # Only affects timeseries as everything else uses the created timeseries + # Default: + hist_str: clm2.h0 + + #Calculate climatologies? + #If false, the climatology files will not be created: + calc_cam_climo: true + + #Overwrite CAM climatology files? + #If false, or not prsent, then already existing climatology files will be skipped: + cam_overwrite_climo: false + + #Location of CAM climatologies (to be created and then used by this script) + cam_climo_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/climo + + #Name of CAM case (or CAM run name): + cam_case_name: b.e30_beta05.BLT1850.ne30_t232_wgx3.123 + + #Case nickname + #NOTE: if nickname starts with '0' - nickname must be in quotes! + # ie '026a' as opposed to 026a + #If missing or left blank, will default to cam_case_name + case_nickname: '123' + + #Location of CAM history (h0) files: + cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ + + # SE to FV regridding options + # Leave these blank if not on the native grid + #----------------------------- + native_grid: true + # Weights file: + weights_file: /glade/work/wwieder/map_ne30pg3_to_fv0.9x1.25_scripgrids_conserve_nomask_c250108.nc + # Regridding method: + regrid_method: 'conservative' + # Lat/lon file: + latlon_file: /glade/derecho/scratch/wwieder/ctsm5.3.018_SP_f09_t232_mask/run/ctsm5.3.018_SP_f09_t232_mask.clm2.h0.0001-01.nc + + #model year when time series files should start: + #Note: Leaving this entry blank will make time series + # start at earliest available year. + start_year: 25 + + #model year when time series files should end: + #Note: Leaving this entry blank will make time series + # end at latest available year. + end_year: 35 + + #Do time series files exist? + #If True, then diagnostics assumes that model files are already time series. + #If False, or if simply not present, then diagnostics will attempt to create + #time series files from history (time-slice) files: + cam_ts_done: false + + #Save interim time series files? + #WARNING: This can take up a significant amount of space, + # but will save processing time the next time + cam_ts_save: false + + #Overwrite time series files, if found? + #If set to false, then time series creation will be skipped if files are found: + cam_overwrite_ts: false + + #Location where time series files are (or will be) stored: + cam_ts_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/ts + + +#This third set of variables provide info for the CAM baseline climatologies. +#This only matters if "compare_obs" is false: +diag_cam_baseline_climo: + + # History file list of strings to match + # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] + # Only affects timeseries as everything else uses the created timeseries + # Default: + hist_str: clm2.h0 + + #Calculate cam baseline climatologies? + #If false, the climatology files will not be created: + calc_cam_climo: true + + #Overwrite CAM climatology files? + #If false, or not present, then already existing climatology files will be skipped: + cam_overwrite_climo: false + + #Location of CAM climatologies (to be created and then used by this script) + cam_climo_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_baseline_climo.cam_case_name}/climo + + #Name of CAM baseline case: + cam_case_name: b.e30_beta05.BLT1850.ne30_t232_wgx3.122 + + #Baseline case nickname + #NOTE: if nickname starts with '0' - nickname must be in quotes! + # ie '026a' as opposed to 026a + #If missing or left blank, will default to cam_case_name + case_nickname: '122' + + #Location of CAM baseline history (h0) files: + #Example test files + cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist/ + + # SE to FV regridding options + # Leave these blank if not on the native grid + #----------------------------- + native_grid: true + # Weights file: + weights_file: /glade/work/wwieder/map_ne30pg3_to_fv0.9x1.25_scripgrids_conserve_nomask_c250108.nc + # Regridding method: + regrid_method: 'conservative' + # Lat/lon file: + latlon_file: /glade/derecho/scratch/wwieder/ctsm5.3.018_SP_f09_t232_mask/run/ctsm5.3.018_SP_f09_t232_mask.clm2.h0.0001-01.nc + + #model year when time series files should start: + #Note: Leaving this entry blank will make time series + # start at earliest available year. + start_year: 25 + + #model year when time series files should end: + #Note: Leaving this entry blank will make time series + # end at latest available year. + end_year: 35 + + #Do time series files need to be generated? + #If True, then diagnostics assumes that model files are already time series. + #If False, or if simply not present, then diagnostics will attempt to create + #time series files from history (time-slice) files: + cam_ts_done: false + + #Save interim time series files for baseline run? + #WARNING: This can take up a significant amount of space: + cam_ts_save: true + + #Overwrite baseline time series files, if found? + #If set to false, then time series creation will be skipped if files are found: + cam_overwrite_ts: false + + #Location where time series files are (or will be) stored: + cam_ts_loc: ${ts_loc}${diag_cam_baseline_climo.cam_case_name}/${diag_cam_baseline_climo.yrs}/ + + +#+++++++++++++++++++++++++++++++++++++++++++++++++++ +#These variables below only matter if you are using +#a non-standard method, or are adding your own +#diagnostic scripts. +#+++++++++++++++++++++++++++++++++++++++++++++++++++ + +#Note: If you want to pass arguments to a particular script, you can +#do it like so (using the "averaging_example" script in this case): +# - {create_climo_files: {kwargs: {clobber: true}}} + +#Name of time-averaging scripts being used to generate climatologies. +#These scripts must be located in "scripts/averaging": +time_averaging_scripts: + - create_climo_files + +#Name of regridding scripts being used. +#These scripts must be located in "scripts/regridding": +regridding_scripts: + - regrid_and_vert_interp + +#List of analysis scripts being used. +#These scripts must be located in "scripts/analysis": +analysis_scripts: + - lmwg_table + +#List of plotting scripts being used. +#These scripts must be located in "scripts/plotting": +plotting_scripts: + - global_latlon_map + - global_mean_timeseries_lnd + - polar_map + +#List of CAM variables that will be processesd: +#If CVDP is to be run PSL, TREFHT, TS and PRECT (or PRECC and PRECL) should be listed +diag_var_list: + #- TSA + - PREC + - ELAI + - GPP +# - NPP +# - FSDS +# - ALTMAX + - ET + - TOTRUNOFF + - DSTFLXT + - MEG_isoprene + +#END OF FILE From 0019d9b7c7b536f257e136a2b060520f2ee6459c Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 15:30:58 -0600 Subject: [PATCH 022/126] Rename config_ldf_native_grid_to_latlon.yaml to config_clm_native_grid_to_latlon.yaml --- ...e_grid_to_latlon.yaml => config_clm_native_grid_to_latlon.yaml | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename config_ldf_native_grid_to_latlon.yaml => config_clm_native_grid_to_latlon.yaml (100%) diff --git a/config_ldf_native_grid_to_latlon.yaml b/config_clm_native_grid_to_latlon.yaml similarity index 100% rename from config_ldf_native_grid_to_latlon.yaml rename to config_clm_native_grid_to_latlon.yaml From 1ada52fd945c1f8e1c757891a9ca37cf3bf6f264 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 15:32:47 -0600 Subject: [PATCH 023/126] Update config_clm_native_grid_to_latlon.yaml --- config_clm_native_grid_to_latlon.yaml | 2 -- 1 file changed, 2 deletions(-) diff --git a/config_clm_native_grid_to_latlon.yaml b/config_clm_native_grid_to_latlon.yaml index 0d108138e..bf8571d7e 100644 --- a/config_clm_native_grid_to_latlon.yaml +++ b/config_clm_native_grid_to_latlon.yaml @@ -151,7 +151,6 @@ diag_cam_climo: # SE to FV regridding options # Leave these blank if not on the native grid #----------------------------- - native_grid: true # Weights file: weights_file: /glade/work/wwieder/map_ne30pg3_to_fv0.9x1.25_scripgrids_conserve_nomask_c250108.nc # Regridding method: @@ -225,7 +224,6 @@ diag_cam_baseline_climo: # SE to FV regridding options # Leave these blank if not on the native grid #----------------------------- - native_grid: true # Weights file: weights_file: /glade/work/wwieder/map_ne30pg3_to_fv0.9x1.25_scripgrids_conserve_nomask_c250108.nc # Regridding method: From 9cbbf4fc85dd67304f040c4df59aa78e96c9e737 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 15:59:08 -0600 Subject: [PATCH 024/126] Update LAND-DIAGS_README.md --- LAND-DIAGS_README.md | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/LAND-DIAGS_README.md b/LAND-DIAGS_README.md index 8b1378917..7f682b223 100644 --- a/LAND-DIAGS_README.md +++ b/LAND-DIAGS_README.md @@ -1 +1,34 @@ +## TEST for Land Diags: +For this branch there are (3) ways to run the ADF: + +1) On native grid with unstructured plotting via Uxarray +2) On native grid but gridded to lat/lon +3) On already lat/lon gridded input files (hist, ts, or climo) + +For (1), the config yaml file will be essentially the same, but with a couple of additional arguments: + - in `diag_basic_info` set the `unstructured_plotting` argument to `true` + - in each of the test and baseline section supply a mesh file in the `mesh_file` argument + + Example yaml file: `config_unstructured_plots.yaml` + +For (2), the config yaml file will need some additional arguments: + - in each of the test and baseline sections, supply the following arguments: + + Weights file: + + `weights_file: /glade/work/wwieder/map_ne30pg3_to_fv0.9x1.25_scripgrids_conserve_nomask_c250108.nc` + + Regridding method: + + `regrid_method: 'conservative'` + + Lat/lon file: + + `latlon_file: /glade/derecho/scratch/wwieder/ctsm5.3.018_SP_f09_t232_mask/run/ctsm5.3.018_SP_f09_t232_mask.clm2.h0.0001-01.nc` + + NOTE: The regridding method set in `regrid_method` MUST match the method in the weights file + + Example yaml file: `config_ldf_native_grid_to_latlon.yaml` + + From 8399bc73ebc75595b27b08442f0e2f8e8935e11f Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Thu, 3 Apr 2025 16:02:49 -0600 Subject: [PATCH 025/126] Create regrid_se_to_fv.py --- scripts/regridding/regrid_se_to_fv.py | 107 ++++++++++++++++++++++++++ 1 file changed, 107 insertions(+) create mode 100644 scripts/regridding/regrid_se_to_fv.py diff --git a/scripts/regridding/regrid_se_to_fv.py b/scripts/regridding/regrid_se_to_fv.py new file mode 100644 index 000000000..098188104 --- /dev/null +++ b/scripts/regridding/regrid_se_to_fv.py @@ -0,0 +1,107 @@ +# Regrids unstructured SE grid to regular lat-lon +# Shamelessly borrowed from @maritsandstad with NorESM who deserves credit for this work +# https://github.com/NorESMhub/xesmf_clm_fates_diagnostic/blob/main/src/xesmf_clm_fates_diagnostic/plotting_methods.py + +import xarray as xr +import xesmf +import numpy as np + +def make_se_regridder(weight_file, s_data, d_data, + Method='coservative' + ): + weights = xr.open_dataset(weight_file) + in_shape = weights.src_grid_dims.load().data + + # Since xESMF expects 2D vars, we'll insert a dummy dimension of size-1 + if len(in_shape) == 1: + in_shape = [1, in_shape.item()] + + # output variable shape + out_shape = weights.dst_grid_dims.load().data.tolist()[::-1] + + dummy_in = xr.Dataset( + { + "lat": ("lat", np.empty((in_shape[0],))), + "lon": ("lon", np.empty((in_shape[1],))), + } + ) + dummy_out = xr.Dataset( + { + "lat": ("lat", weights.yc_b.data.reshape(out_shape)[:, 0]), + "lon": ("lon", weights.xc_b.data.reshape(out_shape)[0, :]), + } + ) + # Hard code masks for now, not sure this does anything? + if isinstance(s_data, xr.DataArray): + s_mask = xr.DataArray(s_data.data.reshape(in_shape[0],in_shape[1]), dims=("lat", "lon")) + dummy_in['mask']= s_mask + if isinstance(d_data, xr.DataArray): + d_mask = xr.DataArray(d_data.values, dims=("lat", "lon")) + dummy_out['mask']= d_mask + + # do source and destination grids need masks here? + # See xesmf docs https://xesmf.readthedocs.io/en/stable/notebooks/Masking.html#Regridding-with-a-mask + regridder = xesmf.Regridder( + dummy_in, + dummy_out, + weights=weight_file, + # results seem insensitive to this method choice + # choices are coservative_normed, coservative, and bilinear + method=Method, + reuse_weights=True, + periodic=True, + ) + return regridder + +def regrid_se_data_bilinear(regridder, data_to_regrid, comp_grid): + updated = data_to_regrid.copy().transpose(..., comp_grid).expand_dims("dummy", axis=-2) + regridded = regridder(updated.rename({"dummy": "lat", comp_grid: "lon"}), + skipna=True, na_thres=1, + ) + return regridded + +def regrid_se_data_conservative(regridder, data_to_regrid, comp_grid): + updated = data_to_regrid.copy().transpose(..., comp_grid).expand_dims("dummy", axis=-2) + regridded = regridder(updated.rename({"dummy": "lat", comp_grid: "lon"}) ) + return regridded + + + +def regrid_atm_se_data_bilinear(regridder, data_to_regrid, comp_grid='ncol'): + if isinstance(data_to_regrid, xr.Dataset): + vars_with_ncol = [name for name in data_to_regrid.variables if comp_grid in data_to_regrid[name].dims] + updated = data_to_regrid.copy().update(data_to_regrid[vars_with_ncol].transpose(..., comp_grid).expand_dims("dummy", axis=-2)) + elif isinstance(data_to_regrid, xr.DataArray): + updated = data_to_regrid.transpose(...,comp_grid).expand_dims("dummy",axis=-2) + else: + raise ValueError(f"Something is wrong because the data to regrid isn't xarray: {type(data_to_regrid)}") + regridded = regridder(updated) + return regridded + + +def regrid_atm_se_data_conservative(regridder, data_to_regrid, comp_grid='ncol'): + if isinstance(data_to_regrid, xr.Dataset): + vars_with_ncol = [name for name in data_to_regrid.variables if comp_grid in data_to_regrid[name].dims] + updated = data_to_regrid.copy().update(data_to_regrid[vars_with_ncol].transpose(..., comp_grid).expand_dims("dummy", axis=-2)) + elif isinstance(data_to_regrid, xr.DataArray): + updated = data_to_regrid.transpose(...,comp_grid).expand_dims("dummy",axis=-2) + else: + raise ValueError(f"Something is wrong because the data to regrid isn't xarray: {type(data_to_regrid)}") + regridded = regridder(updated,skipna=True, na_thres=1) + return regridded + + + +""" +def regrid_lnd_se_data_bilinear(regridder, data_to_regrid, comp_grid): + updated = data_to_regrid.copy().transpose(..., comp_grid).expand_dims("dummy", axis=-2) + regridded = regridder(updated.rename({"dummy": "lat", comp_grid: "lon"}), + skipna=True, na_thres=1, + ) + return regridded + + +def regrid_lnd_se_data_conservative(regridder, data_to_regrid, comp_grid): + updated = data_to_regrid.copy().transpose(..., comp_grid).expand_dims("dummy", axis=-2) + regridded = regridder(updated.rename({"dummy": "lat", comp_grid: "lon"}) ) + return regridded""" From 2d24d4f209c308b6d44a28f9acbf880eb45766fa Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Fri, 4 Apr 2025 09:40:02 -0600 Subject: [PATCH 026/126] Update plotting_functions.py --- lib/plotting_functions.py | 7 ------- 1 file changed, 7 deletions(-) diff --git a/lib/plotting_functions.py b/lib/plotting_functions.py index 5718f6512..e520dc2bf 100644 --- a/lib/plotting_functions.py +++ b/lib/plotting_functions.py @@ -900,7 +900,6 @@ def make_polar_plot(wks, case_nickname, base_nickname, if unstructured: #configure for polycollection plotting #TODO, would be nice to have levels set from the info, above - print("AHHHHHH2",i,type(a), type(a.uxgrid)) ac = a.to_polycollection(projection=proj) #ac.norm(norms[i]) ac.set_cmap(cmap) @@ -1423,11 +1422,6 @@ def plot_map_and_save(wks, case_nickname, base_nickname, ac.set_transform(proj) ac.set_clim(vmin=levels[0],vmax=levels[-1]) ax[i].add_collection(ac) - """if i > 0: - cbar = plt.colorbar(ac, ax=ax[i], orientation='vertical', - pad=0.05, shrink=0.8, **cp_info['colorbar_opt']) - #TODO keep variable attributes on dataarrays - #cbar.set_label(wrap_fields[i].attrs['units'])""" # End if unstructured grid #ax[i].set_title("AVG: {0:.3f}".format(area_avg[i]), loc='right', fontsize=11) @@ -1444,7 +1438,6 @@ def plot_map_and_save(wks, case_nickname, base_nickname, # Custom setting for each subplot for a in ax: a.coastlines() - #if projection=='global': a.set_global() a.spines['geo'].set_linewidth(1.5) #cartopy's recommended method a.set_xticks(np.linspace(-180, 120, 6), crs=proj) From 33b675cf2f24a6b2a5c4c1be49871c4df52ccf91 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Fri, 4 Apr 2025 10:34:47 -0600 Subject: [PATCH 027/126] Fix uxgrid check for Uxarray data array --- lib/plotting_functions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/plotting_functions.py b/lib/plotting_functions.py index e520dc2bf..39f8dbf49 100644 --- a/lib/plotting_functions.py +++ b/lib/plotting_functions.py @@ -785,10 +785,10 @@ def make_polar_plot(wks, case_nickname, base_nickname, pct = pctchange #check if pct has NaN's or Inf values and if so set them to 0 to prevent plotting errors - pct_grid = pct.uxgrid pct_0 = pct.where(np.isfinite(pct), np.nan) pct_0 = pct_0.fillna(0.0) if isinstance(pct, ux.UxDataArray): + pct_grid = pct.uxgrid pct = ux.UxDataArray(pct_0,uxgrid=pct_grid) else: pct = pct_0 From ca6bf7907c0e67f7f101deb6b0014ba5b01a60ed Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Fri, 4 Apr 2025 10:52:27 -0600 Subject: [PATCH 028/126] Update plotting_functions.py --- lib/plotting_functions.py | 1 - 1 file changed, 1 deletion(-) diff --git a/lib/plotting_functions.py b/lib/plotting_functions.py index 39f8dbf49..c980f9ab5 100644 --- a/lib/plotting_functions.py +++ b/lib/plotting_functions.py @@ -792,7 +792,6 @@ def make_polar_plot(wks, case_nickname, base_nickname, pct = ux.UxDataArray(pct_0,uxgrid=pct_grid) else: pct = pct_0 - print("What type is this!?!?!?!?",type(pct),"\n") if (hemisphere.upper() == "NH") or (hemisphere == "Arctic"): proj = ccrs.NorthPolarStereo() From d79f6203fce8f04abc011042841f4bdeb3a46131 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Fri, 4 Apr 2025 13:07:43 -0600 Subject: [PATCH 029/126] Update config_clm_native_grid_to_latlon.yaml --- config_clm_native_grid_to_latlon.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config_clm_native_grid_to_latlon.yaml b/config_clm_native_grid_to_latlon.yaml index bf8571d7e..ec135ae03 100644 --- a/config_clm_native_grid_to_latlon.yaml +++ b/config_clm_native_grid_to_latlon.yaml @@ -256,7 +256,7 @@ diag_cam_baseline_climo: cam_overwrite_ts: false #Location where time series files are (or will be) stored: - cam_ts_loc: ${ts_loc}${diag_cam_baseline_climo.cam_case_name}/${diag_cam_baseline_climo.yrs}/ + cam_ts_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_baseline_climo.cam_case_name}/ts #+++++++++++++++++++++++++++++++++++++++++++++++++++ From f635f9c1f77ef6b47d87a284efd403cd84eca931 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Fri, 4 Apr 2025 13:38:59 -0600 Subject: [PATCH 030/126] Update regrid method Xesmf has typo for conservative -> coservative --- config_clm_native_grid_to_latlon.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/config_clm_native_grid_to_latlon.yaml b/config_clm_native_grid_to_latlon.yaml index ec135ae03..f573063af 100644 --- a/config_clm_native_grid_to_latlon.yaml +++ b/config_clm_native_grid_to_latlon.yaml @@ -154,7 +154,7 @@ diag_cam_climo: # Weights file: weights_file: /glade/work/wwieder/map_ne30pg3_to_fv0.9x1.25_scripgrids_conserve_nomask_c250108.nc # Regridding method: - regrid_method: 'conservative' + regrid_method: 'coservative' # Lat/lon file: latlon_file: /glade/derecho/scratch/wwieder/ctsm5.3.018_SP_f09_t232_mask/run/ctsm5.3.018_SP_f09_t232_mask.clm2.h0.0001-01.nc @@ -227,7 +227,7 @@ diag_cam_baseline_climo: # Weights file: weights_file: /glade/work/wwieder/map_ne30pg3_to_fv0.9x1.25_scripgrids_conserve_nomask_c250108.nc # Regridding method: - regrid_method: 'conservative' + regrid_method: 'coservative' # Lat/lon file: latlon_file: /glade/derecho/scratch/wwieder/ctsm5.3.018_SP_f09_t232_mask/run/ctsm5.3.018_SP_f09_t232_mask.clm2.h0.0001-01.nc From 1c9ab6f56936a9085b3369b541bdae1157ac31a3 Mon Sep 17 00:00:00 2001 From: justin-richling <56696811+justin-richling@users.noreply.github.com> Date: Fri, 4 Apr 2025 13:43:24 -0600 Subject: [PATCH 031/126] Update ldf_variable_defaults.yaml --- lib/ldf_variable_defaults.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/ldf_variable_defaults.yaml b/lib/ldf_variable_defaults.yaml index 2b7e04641..982cfc76f 100644 --- a/lib/ldf_variable_defaults.yaml +++ b/lib/ldf_variable_defaults.yaml @@ -82,7 +82,7 @@ TSA: # 2m air temperature PREC: # RAIN + SNOW category: "Atmosphere" - colormap: "managua" + colormap: "coolwarm" derivable_from: ["RAIN","SNOW"] scale_factor: 86400 add_offset: 0 @@ -174,7 +174,7 @@ ET: # latent heat: FCTR+FCEV+FGEV DSTFLXT: # total surface dust emission category: "Surface fluxes" - colormap: "Browns" + colormap: "Blues" diff_colormap: "BrBG_r" scale_factor: 86400 add_offset: 0 @@ -190,7 +190,7 @@ DSTFLXT: # total surface dust emission MEG_isoprene: # total surface dust emission category: "Surface fluxes" - colormap: "Browns" + colormap: "Blues" diff_colormap: "BrBG_r" scale_factor: 86400 add_offset: 0 From 3846bf2aeadd12b23cf214e49a79390d40d46d3b Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 3 Apr 2025 15:08:06 -0600 Subject: [PATCH 032/126] lmwg_wish_list --- lmwg_wish_list.md | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 lmwg_wish_list.md diff --git a/lmwg_wish_list.md b/lmwg_wish_list.md new file mode 100644 index 000000000..5f8af5cac --- /dev/null +++ b/lmwg_wish_list.md @@ -0,0 +1,20 @@ +# List of ideas for LDF hackathon: +### Simple tasks work +-[] Expand list of default variables in `config_clm_baseline_example.yml` +-[] Improve plotting aesthetics: expand list of variables in `adf/lib/ldf_variable_defaults.yml` +-[] Identify list of regions and bounding boxes where we want to make timeseries or climo plots + +### Integration +-[x] Integrate `regrid_se_to_fv` regridding script into ADF workflow. +-[x] Integrate `plot_unstructured_map_and_save` function into `/scripts/plotting/global_unstructured_latlon_map` +-[x] Develop coherent way to handled structured vs. unstructured input data (maybe adapt all to uxarray)? + +### Development +-[] Seperate time bounds for time series and climo generation. +-[] Write python function to make regional timeseries or climo plots +-[] Check applicaiton of adf timeseries plots for land +-[x] Handle h1 files for PFT specific results +-[] Integrate observations! + +# + From 09c0694b99236119f27ce86e9d1ced2171c5c3b1 Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 3 Apr 2025 15:10:00 -0600 Subject: [PATCH 033/126] lmwg_wish_listv2 --- lmwg_wish_list.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/lmwg_wish_list.md b/lmwg_wish_list.md index 5f8af5cac..b7ee846ce 100644 --- a/lmwg_wish_list.md +++ b/lmwg_wish_list.md @@ -1,8 +1,8 @@ # List of ideas for LDF hackathon: ### Simple tasks work --[] Expand list of default variables in `config_clm_baseline_example.yml` --[] Improve plotting aesthetics: expand list of variables in `adf/lib/ldf_variable_defaults.yml` --[] Identify list of regions and bounding boxes where we want to make timeseries or climo plots +-[ ] Expand list of default variables in `config_clm_baseline_example.yml` +-[ ] Improve plotting aesthetics: expand list of variables in `adf/lib/ldf_variable_defaults.yml` +-[ ] Identify list of regions and bounding boxes where we want to make timeseries or climo plots ### Integration -[x] Integrate `regrid_se_to_fv` regridding script into ADF workflow. @@ -10,11 +10,11 @@ -[x] Develop coherent way to handled structured vs. unstructured input data (maybe adapt all to uxarray)? ### Development --[] Seperate time bounds for time series and climo generation. --[] Write python function to make regional timeseries or climo plots --[] Check applicaiton of adf timeseries plots for land +-[ ] Seperate time bounds for time series and climo generation. +-[ ] Write python function to make regional timeseries or climo plots +-[ ] Check applicaiton of adf timeseries plots for land -[x] Handle h1 files for PFT specific results --[] Integrate observations! +-[ ] Integrate observations! # From 87afc310517e9df2ea52de1a49a63ac08adac72a Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 3 Apr 2025 15:35:00 -0600 Subject: [PATCH 034/126] formatting2 --- lmwg_wish_list.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/lmwg_wish_list.md b/lmwg_wish_list.md index b7ee846ce..3f99b0ce4 100644 --- a/lmwg_wish_list.md +++ b/lmwg_wish_list.md @@ -1,4 +1,4 @@ -# List of ideas for LDF hackathon: +# List of ideas for LDF Codefest: ### Simple tasks work -[ ] Expand list of default variables in `config_clm_baseline_example.yml` -[ ] Improve plotting aesthetics: expand list of variables in `adf/lib/ldf_variable_defaults.yml` @@ -6,13 +6,15 @@ ### Integration -[x] Integrate `regrid_se_to_fv` regridding script into ADF workflow. + - check how this is working in revised -[x] Integrate `plot_unstructured_map_and_save` function into `/scripts/plotting/global_unstructured_latlon_map` -[x] Develop coherent way to handled structured vs. unstructured input data (maybe adapt all to uxarray)? ### Development --[ ] Seperate time bounds for time series and climo generation. +-[ ] Separate time bounds for time series and climo generation. -[ ] Write python function to make regional timeseries or climo plots --[ ] Check applicaiton of adf timeseries plots for land +-[ ] Check applicaiton of adf timeseries plots for land, + - this was working on wwieder/clm-test branch -[x] Handle h1 files for PFT specific results -[ ] Integrate observations! From c37cca8862b6d020744f6af82f531942f41c6766 Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 4 Apr 2025 08:50:42 -0600 Subject: [PATCH 035/126] remove path to ldf_variable_defaults, #362 --- config_clm_baseline_example.yaml | 3 +- env/ldf_environment.yaml | 28 + lib/plot_uxarray_h1.ipynb | 5190 ++++++++++++++++++++++++++++++ lmwg_wish_list.md | 11 +- 4 files changed, 5227 insertions(+), 5 deletions(-) create mode 100644 env/ldf_environment.yaml create mode 100644 lib/plot_uxarray_h1.ipynb diff --git a/config_clm_baseline_example.yaml b/config_clm_baseline_example.yaml index 0759c2e7a..2e9d31df3 100644 --- a/config_clm_baseline_example.yaml +++ b/config_clm_baseline_example.yaml @@ -94,8 +94,7 @@ diag_basic_info: #Location of ADF variable plotting defaults YAML file: #If left blank or missing, ADF/lib/adf_variable_defaults.yaml will be used #Uncomment and change path for custom variable defaults file - #TODO, make a land default path - defaults_file: /glade/u/home/wwieder/python/adf/lib/ldf_variable_defaults.yaml + defaults_file: ldf_variable_defaults.yaml #Vertical pressure levels (in hPa) on which to plot 3-D variables #when using horizontal (e.g. lat/lon) map projections. diff --git a/env/ldf_environment.yaml b/env/ldf_environment.yaml new file mode 100644 index 000000000..297ec643c --- /dev/null +++ b/env/ldf_environment.yaml @@ -0,0 +1,28 @@ +name: ldf_v0.01 +channels: + - conda-forge + - nodefaults +dependencies: + - cartopy + - cftime + - dask + - distributed + - geocat-comp + - geopandas + - intake + - intake-esm + - intake-xarray + - ipykernel + - matplotlib + - nc-time-axis + - ncar-jobqueue + - netcdf4 + - numpy + - pip + - python==3.11.4 + - uxarray + - xarray + - xesmf + - yaml + - zarr + diff --git a/lib/plot_uxarray_h1.ipynb b/lib/plot_uxarray_h1.ipynb new file mode 100644 index 000000000..21dbe623b --- /dev/null +++ b/lib/plot_uxarray_h1.ipynb @@ -0,0 +1,5190 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "39545902-0870-4a3f-93f1-493e56403d38", + "metadata": {}, + "source": [ + "### test for plotting pft level data on h1 files\n", + "Created by Will Wieder\n", + "Improved by Orhan Eroglu\n", + "March 2025" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b75e38a9-54ff-438b-91cd-2f72ef3abd95", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " const force = true;\n", + " const py_version = '3.6.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " const reloading = false;\n", + " const Bokeh = root.Bokeh;\n", + "\n", + " // Set a timeout for this load but only if we are not already initializing\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks;\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + " if (js_exports == null) js_exports = {};\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + "\n", + " if (root._bokeh_is_loading > 0) {\n", + " // Don't load bokeh if it is still initializing\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " // There is nothing to load\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + " window._bokeh_on_load = on_load\n", + "\n", + " function on_error(e) {\n", + " const src_el = e.srcElement\n", + " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", + " }\n", + "\n", + " const skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", + " root._bokeh_is_loading = css_urls.length + 0;\n", + " } else {\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", + " }\n", + "\n", + " const existing_stylesheets = []\n", + " const links = document.getElementsByTagName('link')\n", + " for (let i = 0; i < links.length; i++) {\n", + " const link = links[i]\n", + " if (link.href != null) {\n", + " existing_stylesheets.push(link.href)\n", + " }\n", + " }\n", + " for (let i = 0; i < css_urls.length; i++) {\n", + " const url = css_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", + " on_load()\n", + " continue;\n", + " }\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " } var existing_scripts = []\n", + " const scripts = document.getElementsByTagName('script')\n", + " for (let i = 0; i < scripts.length; i++) {\n", + " var script = scripts[i]\n", + " if (script.src != null) {\n", + " existing_scripts.push(script.src)\n", + " }\n", + " }\n", + " for (let i = 0; i < js_urls.length; i++) {\n", + " const url = js_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " const element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (let i = 0; i < js_modules.length; i++) {\n", + " const url = js_modules[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (const name in js_exports) {\n", + " const url = js_exports[name];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " element.textContent = `\n", + " import ${name} from \"${url}\"\n", + " window.${name} = ${name}\n", + " window._bokeh_on_load()\n", + " `\n", + " document.head.appendChild(element);\n", + " }\n", + " if (!js_urls.length && !js_modules.length) {\n", + " on_load()\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " const js_urls = [\"https://cdn.holoviz.org/panel/1.5.4/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.6.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.4/dist/panel.min.js\"];\n", + " const js_modules = [];\n", + " const js_exports = {};\n", + " const css_urls = [];\n", + " const inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {} // ensure no trailing comma for IE\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if ((root.Bokeh !== undefined) || (force === true)) {\n", + " for (let i = 0; i < inline_js.length; i++) {\n", + " try {\n", + " inline_js[i].call(root, root.Bokeh);\n", + " } catch(e) {\n", + " if (!reloading) {\n", + " throw e;\n", + " }\n", + " }\n", + " }\n", + " // Cache old bokeh versions\n", + " if (Bokeh != undefined && !reloading) {\n", + " var NewBokeh = root.Bokeh;\n", + " if (Bokeh.versions === undefined) {\n", + " Bokeh.versions = new Map();\n", + " }\n", + " if (NewBokeh.version !== Bokeh.version) {\n", + " Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", + " }\n", + " root.Bokeh = Bokeh;\n", + " }\n", + " } else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " }\n", + " root._bokeh_is_initializing = false\n", + " }\n", + "\n", + " function load_or_wait() {\n", + " // Implement a backoff loop that tries to ensure we do not load multiple\n", + " // versions of Bokeh and its dependencies at the same time.\n", + " // In recent versions we use the root._bokeh_is_initializing flag\n", + " // to determine whether there is an ongoing attempt to initialize\n", + " // bokeh, however for backward compatibility we also try to ensure\n", + " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", + " // before older versions are fully initialized.\n", + " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", + " // If the timeout and bokeh was not successfully loaded we reset\n", + " // everything and try loading again\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_is_initializing = false;\n", + " root._bokeh_onload_callbacks = undefined;\n", + " root._bokeh_is_loading = 0\n", + " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", + " load_or_wait();\n", + " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", + " setTimeout(load_or_wait, 100);\n", + " } else {\n", + " root._bokeh_is_initializing = true\n", + " root._bokeh_onload_callbacks = []\n", + " const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n", + " if (!reloading && !bokeh_loaded) {\n", + " if (root.Bokeh) {\n", + " root.Bokeh = undefined;\n", + " }\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " }\n", + " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", + " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + " run_inline_js();\n", + " });\n", + " }\n", + " }\n", + " // Give older versions of the autoload script a head-start to ensure\n", + " // they initialize before we start loading newer version.\n", + " setTimeout(load_or_wait, 100)\n", + "}(window));" + ], + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n const py_version = '3.6.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = false;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.5.4/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.6.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.4/dist/panel.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", + " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", + "}\n", + "\n", + "\n", + " function JupyterCommManager() {\n", + " }\n", + "\n", + " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", + " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " comm_manager.register_target(comm_id, function(comm) {\n", + " comm.on_msg(msg_handler);\n", + " });\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", + " comm.onMsg = msg_handler;\n", + " });\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " console.log(message)\n", + " var content = {data: message.data, comm_id};\n", + " var buffers = []\n", + " for (var buffer of message.buffers || []) {\n", + " buffers.push(new DataView(buffer))\n", + " }\n", + " var metadata = message.metadata || {};\n", + " var msg = {content, buffers, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " })\n", + " }\n", + " }\n", + "\n", + " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", + " if (comm_id in window.PyViz.comms) {\n", + " return window.PyViz.comms[comm_id];\n", + " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", + " if (msg_handler) {\n", + " comm.on_msg(msg_handler);\n", + " }\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", + " comm.open();\n", + " if (msg_handler) {\n", + " comm.onMsg = msg_handler;\n", + " }\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", + " comm_promise.then((comm) => {\n", + " window.PyViz.comms[comm_id] = comm;\n", + " if (msg_handler) {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " var content = {data: message.data};\n", + " var metadata = message.metadata || {comm_id};\n", + " var msg = {content, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " }) \n", + " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", + " return comm_promise.then((comm) => {\n", + " comm.send(data, metadata, buffers, disposeOnDone);\n", + " });\n", + " };\n", + " var comm = {\n", + " send: sendClosure\n", + " };\n", + " }\n", + " window.PyViz.comms[comm_id] = comm;\n", + " return comm;\n", + " }\n", + " window.PyViz.comm_manager = new JupyterCommManager();\n", + " \n", + "\n", + "\n", + "var JS_MIME_TYPE = 'application/javascript';\n", + "var HTML_MIME_TYPE = 'text/html';\n", + "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", + "var CLASS_NAME = 'output';\n", + "\n", + "/**\n", + " * Render data to the DOM node\n", + " */\n", + "function render(props, node) {\n", + " var div = document.createElement(\"div\");\n", + " var script = document.createElement(\"script\");\n", + " node.appendChild(div);\n", + " node.appendChild(script);\n", + "}\n", + "\n", + "/**\n", + " * Handle when a new output is added\n", + " */\n", + "function handle_add_output(event, handle) {\n", + " var output_area = handle.output_area;\n", + " var output = handle.output;\n", + " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + " if (id !== undefined) {\n", + " var nchildren = toinsert.length;\n", + " var html_node = toinsert[nchildren-1].children[0];\n", + " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var scripts = [];\n", + " var nodelist = html_node.querySelectorAll(\"script\");\n", + " for (var i in nodelist) {\n", + " if (nodelist.hasOwnProperty(i)) {\n", + " scripts.push(nodelist[i])\n", + " }\n", + " }\n", + "\n", + " scripts.forEach( function (oldScript) {\n", + " var newScript = document.createElement(\"script\");\n", + " var attrs = [];\n", + " var nodemap = oldScript.attributes;\n", + " for (var j in nodemap) {\n", + " if (nodemap.hasOwnProperty(j)) {\n", + " attrs.push(nodemap[j])\n", + " }\n", + " }\n", + " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", + " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", + " oldScript.parentNode.replaceChild(newScript, oldScript);\n", + " });\n", + " if (JS_MIME_TYPE in output.data) {\n", + " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", + " }\n", + " output_area._hv_plot_id = id;\n", + " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", + " window.PyViz.plot_index[id] = Bokeh.index[id];\n", + " } else {\n", + " window.PyViz.plot_index[id] = null;\n", + " }\n", + " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " var bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var script_attrs = bk_div.children[0].attributes;\n", + " for (var i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + "function handle_clear_output(event, handle) {\n", + " var id = handle.cell.output_area._hv_plot_id;\n", + " var server_id = handle.cell.output_area._bokeh_server_id;\n", + " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", + " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", + " if (server_id !== null) {\n", + " comm.send({event_type: 'server_delete', 'id': server_id});\n", + " return;\n", + " } else if (comm !== null) {\n", + " comm.send({event_type: 'delete', 'id': id});\n", + " }\n", + " delete PyViz.plot_index[id];\n", + " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", + " var doc = window.Bokeh.index[id].model.document\n", + " doc.clear();\n", + " const i = window.Bokeh.documents.indexOf(doc);\n", + " if (i > -1) {\n", + " window.Bokeh.documents.splice(i, 1);\n", + " }\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle kernel restart event\n", + " */\n", + "function handle_kernel_cleanup(event, handle) {\n", + " delete PyViz.comms[\"hv-extension-comm\"];\n", + " window.PyViz.plot_index = {}\n", + "}\n", + "\n", + "/**\n", + " * Handle update_display_data messages\n", + " */\n", + "function handle_update_output(event, handle) {\n", + " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", + " handle_add_output(event, handle)\n", + "}\n", + "\n", + "function register_renderer(events, OutputArea) {\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " var toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[0]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " events.on('output_added.OutputArea', handle_add_output);\n", + " events.on('output_updated.OutputArea', handle_update_output);\n", + " events.on('clear_output.CodeCell', handle_clear_output);\n", + " events.on('delete.Cell', handle_clear_output);\n", + " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", + "\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " safe: true,\n", + " index: 0\n", + " });\n", + "}\n", + "\n", + "if (window.Jupyter !== undefined) {\n", + " try {\n", + " var events = require('base/js/events');\n", + " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " } catch(err) {\n", + " }\n", + "}\n" + ], + "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "43449c4e-d004-4192-af2d-5e7c000cc8fb" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " const force = false;\n", + " const py_version = '3.6.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " const reloading = true;\n", + " const Bokeh = root.Bokeh;\n", + "\n", + " // Set a timeout for this load but only if we are not already initializing\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks;\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + " if (js_exports == null) js_exports = {};\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + "\n", + " if (root._bokeh_is_loading > 0) {\n", + " // Don't load bokeh if it is still initializing\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " // There is nothing to load\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + " window._bokeh_on_load = on_load\n", + "\n", + " function on_error(e) {\n", + " const src_el = e.srcElement\n", + " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", + " }\n", + "\n", + " const skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", + " root._bokeh_is_loading = css_urls.length + 0;\n", + " } else {\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", + " }\n", + "\n", + " const existing_stylesheets = []\n", + " const links = document.getElementsByTagName('link')\n", + " for (let i = 0; i < links.length; i++) {\n", + " const link = links[i]\n", + " if (link.href != null) {\n", + " existing_stylesheets.push(link.href)\n", + " }\n", + " }\n", + " for (let i = 0; i < css_urls.length; i++) {\n", + " const url = css_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", + " on_load()\n", + " continue;\n", + " }\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " } var existing_scripts = []\n", + " const scripts = document.getElementsByTagName('script')\n", + " for (let i = 0; i < scripts.length; i++) {\n", + " var script = scripts[i]\n", + " if (script.src != null) {\n", + " existing_scripts.push(script.src)\n", + " }\n", + " }\n", + " for (let i = 0; i < js_urls.length; i++) {\n", + " const url = js_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " const element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (let i = 0; i < js_modules.length; i++) {\n", + " const url = js_modules[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (const name in js_exports) {\n", + " const url = js_exports[name];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " element.textContent = `\n", + " import ${name} from \"${url}\"\n", + " window.${name} = ${name}\n", + " window._bokeh_on_load()\n", + " `\n", + " document.head.appendChild(element);\n", + " }\n", + " if (!js_urls.length && !js_modules.length) {\n", + " on_load()\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " const js_urls = [\"https://cdn.holoviz.org/panel/1.5.4/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\"];\n", + " const js_modules = [];\n", + " const js_exports = {};\n", + " const css_urls = [];\n", + " const inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {} // ensure no trailing comma for IE\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if ((root.Bokeh !== undefined) || (force === true)) {\n", + " for (let i = 0; i < inline_js.length; i++) {\n", + " try {\n", + " inline_js[i].call(root, root.Bokeh);\n", + " } catch(e) {\n", + " if (!reloading) {\n", + " throw e;\n", + " }\n", + " }\n", + " }\n", + " // Cache old bokeh versions\n", + " if (Bokeh != undefined && !reloading) {\n", + " var NewBokeh = root.Bokeh;\n", + " if (Bokeh.versions === undefined) {\n", + " Bokeh.versions = new Map();\n", + " }\n", + " if (NewBokeh.version !== Bokeh.version) {\n", + " Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", + " }\n", + " root.Bokeh = Bokeh;\n", + " }\n", + " } else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " }\n", + " root._bokeh_is_initializing = false\n", + " }\n", + "\n", + " function load_or_wait() {\n", + " // Implement a backoff loop that tries to ensure we do not load multiple\n", + " // versions of Bokeh and its dependencies at the same time.\n", + " // In recent versions we use the root._bokeh_is_initializing flag\n", + " // to determine whether there is an ongoing attempt to initialize\n", + " // bokeh, however for backward compatibility we also try to ensure\n", + " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", + " // before older versions are fully initialized.\n", + " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", + " // If the timeout and bokeh was not successfully loaded we reset\n", + " // everything and try loading again\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_is_initializing = false;\n", + " root._bokeh_onload_callbacks = undefined;\n", + " root._bokeh_is_loading = 0\n", + " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", + " load_or_wait();\n", + " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", + " setTimeout(load_or_wait, 100);\n", + " } else {\n", + " root._bokeh_is_initializing = true\n", + " root._bokeh_onload_callbacks = []\n", + " const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n", + " if (!reloading && !bokeh_loaded) {\n", + " if (root.Bokeh) {\n", + " root.Bokeh = undefined;\n", + " }\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " }\n", + " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", + " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + " run_inline_js();\n", + " });\n", + " }\n", + " }\n", + " // Give older versions of the autoload script a head-start to ensure\n", + " // they initialize before we start loading newer version.\n", + " setTimeout(load_or_wait, 100)\n", + "}(window));" + ], + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = false;\n const py_version = '3.6.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = true;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.5.4/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", + " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", + "}\n", + "\n", + "\n", + " function JupyterCommManager() {\n", + " }\n", + "\n", + " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", + " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " comm_manager.register_target(comm_id, function(comm) {\n", + " comm.on_msg(msg_handler);\n", + " });\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", + " comm.onMsg = msg_handler;\n", + " });\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " console.log(message)\n", + " var content = {data: message.data, comm_id};\n", + " var buffers = []\n", + " for (var buffer of message.buffers || []) {\n", + " buffers.push(new DataView(buffer))\n", + " }\n", + " var metadata = message.metadata || {};\n", + " var msg = {content, buffers, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " })\n", + " }\n", + " }\n", + "\n", + " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", + " if (comm_id in window.PyViz.comms) {\n", + " return window.PyViz.comms[comm_id];\n", + " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", + " if (msg_handler) {\n", + " comm.on_msg(msg_handler);\n", + " }\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", + " comm.open();\n", + " if (msg_handler) {\n", + " comm.onMsg = msg_handler;\n", + " }\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", + " comm_promise.then((comm) => {\n", + " window.PyViz.comms[comm_id] = comm;\n", + " if (msg_handler) {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " var content = {data: message.data};\n", + " var metadata = message.metadata || {comm_id};\n", + " var msg = {content, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " }) \n", + " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", + " return comm_promise.then((comm) => {\n", + " comm.send(data, metadata, buffers, disposeOnDone);\n", + " });\n", + " };\n", + " var comm = {\n", + " send: sendClosure\n", + " };\n", + " }\n", + " window.PyViz.comms[comm_id] = comm;\n", + " return comm;\n", + " }\n", + " window.PyViz.comm_manager = new JupyterCommManager();\n", + " \n", + "\n", + "\n", + "var JS_MIME_TYPE = 'application/javascript';\n", + "var HTML_MIME_TYPE = 'text/html';\n", + "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", + "var CLASS_NAME = 'output';\n", + "\n", + "/**\n", + " * Render data to the DOM node\n", + " */\n", + "function render(props, node) {\n", + " var div = document.createElement(\"div\");\n", + " var script = document.createElement(\"script\");\n", + " node.appendChild(div);\n", + " node.appendChild(script);\n", + "}\n", + "\n", + "/**\n", + " * Handle when a new output is added\n", + " */\n", + "function handle_add_output(event, handle) {\n", + " var output_area = handle.output_area;\n", + " var output = handle.output;\n", + " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + " if (id !== undefined) {\n", + " var nchildren = toinsert.length;\n", + " var html_node = toinsert[nchildren-1].children[0];\n", + " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var scripts = [];\n", + " var nodelist = html_node.querySelectorAll(\"script\");\n", + " for (var i in nodelist) {\n", + " if (nodelist.hasOwnProperty(i)) {\n", + " scripts.push(nodelist[i])\n", + " }\n", + " }\n", + "\n", + " scripts.forEach( function (oldScript) {\n", + " var newScript = document.createElement(\"script\");\n", + " var attrs = [];\n", + " var nodemap = oldScript.attributes;\n", + " for (var j in nodemap) {\n", + " if (nodemap.hasOwnProperty(j)) {\n", + " attrs.push(nodemap[j])\n", + " }\n", + " }\n", + " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", + " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", + " oldScript.parentNode.replaceChild(newScript, oldScript);\n", + " });\n", + " if (JS_MIME_TYPE in output.data) {\n", + " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", + " }\n", + " output_area._hv_plot_id = id;\n", + " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", + " window.PyViz.plot_index[id] = Bokeh.index[id];\n", + " } else {\n", + " window.PyViz.plot_index[id] = null;\n", + " }\n", + " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " var bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var script_attrs = bk_div.children[0].attributes;\n", + " for (var i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + "function handle_clear_output(event, handle) {\n", + " var id = handle.cell.output_area._hv_plot_id;\n", + " var server_id = handle.cell.output_area._bokeh_server_id;\n", + " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", + " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", + " if (server_id !== null) {\n", + " comm.send({event_type: 'server_delete', 'id': server_id});\n", + " return;\n", + " } else if (comm !== null) {\n", + " comm.send({event_type: 'delete', 'id': id});\n", + " }\n", + " delete PyViz.plot_index[id];\n", + " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", + " var doc = window.Bokeh.index[id].model.document\n", + " doc.clear();\n", + " const i = window.Bokeh.documents.indexOf(doc);\n", + " if (i > -1) {\n", + " window.Bokeh.documents.splice(i, 1);\n", + " }\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle kernel restart event\n", + " */\n", + "function handle_kernel_cleanup(event, handle) {\n", + " delete PyViz.comms[\"hv-extension-comm\"];\n", + " window.PyViz.plot_index = {}\n", + "}\n", + "\n", + "/**\n", + " * Handle update_display_data messages\n", + " */\n", + "function handle_update_output(event, handle) {\n", + " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", + " handle_add_output(event, handle)\n", + "}\n", + "\n", + "function register_renderer(events, OutputArea) {\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " var toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[0]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " events.on('output_added.OutputArea', handle_add_output);\n", + " events.on('output_updated.OutputArea', handle_update_output);\n", + " events.on('clear_output.CodeCell', handle_clear_output);\n", + " events.on('delete.Cell', handle_clear_output);\n", + " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", + "\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " safe: true,\n", + " index: 0\n", + " });\n", + "}\n", + "\n", + "if (window.Jupyter !== undefined) {\n", + " try {\n", + " var events = require('base/js/events');\n", + " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " } catch(err) {\n", + " }\n", + "}\n" + ], + "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import os, sys\n", + "import shutil\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "import numpy as np\n", + "import xarray as xr\n", + "import xesmf as xe\n", + "\n", + "# Helpful for plotting only\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "import cartopy\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "import uxarray as ux #need npl 2024a or later\n", + "import geoviews.feature as gf\n", + "\n", + "#sys.path.append('/glade/u/home/wwieder/python/adf/lib/plotting_functions.py')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "07650a02-db90-4ee9-8880-e3f4ac140871", + "metadata": {}, + "outputs": [], + "source": [ + "# Load datataset \n", + "# TODO, develop function for this too\n", + "gppfile='/glade/derecho/scratch/wwieder/ADF/b.e30_beta04.BLT1850.ne30_t232_wgx3.121/climo/b.e30_beta04.BLT1850.ne30_t232_wgx3.121_GPP_climo.nc'\n", + "laih1file='/glade/derecho/scratch/wwieder/ctsm53n04ctsm52028_ne30pg3t232_hist.clm2.h1.TLAI.1860s.nc'\n", + "case = 'ctsm53n04ctsm52028_ne30pg3t232_hist'\n", + "\n", + "mesh0 = '/glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc'\n", + "\n", + "#ux file for plotting\n", + "uxds0 = ux.open_dataset(mesh0, gppfile).max('time')\n", + "uxds1 = ux.open_dataset(mesh0, laih1file).max('time')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3500cb23-f87f-44a1-a204-e8d5c2f22c85", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "starting pft 1\n", + "starting pft 2\n", + "starting pft 3\n", + "starting pft 4\n", + "starting pft 5\n", + "starting pft 6\n", + "starting pft 7\n", + "starting pft 8\n", + "starting pft 9\n", + "starting pft 10\n", + "starting pft 11\n", + "starting pft 12\n", + "starting pft 13\n", + "starting pft 14\n", + "starting pft 15\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.UxDataset> Size: 32MB\n",
+       "Dimensions:             (npft: 15, hist_interval: 2, n_face: 15962)\n",
+       "Coordinates:\n",
+       "  * n_face              (n_face) int64 128kB 737 738 745 ... 48598 48599 48600\n",
+       "Dimensions without coordinates: npft, hist_interval\n",
+       "Data variables: (12/16)\n",
+       "    time_bounds         (npft, hist_interval, n_face) object 4MB 1869-12-01 0...\n",
+       "    pfts1d_lon          (npft, n_face) float64 2MB 19.5 20.5 ... 136.0 135.0\n",
+       "    pfts1d_lat          (npft, n_face) float64 2MB -34.9 -34.73 ... 36.2 35.74\n",
+       "    pfts1d_ixy          (npft, n_face) float64 2MB 737.0 738.0 ... 4.86e+04\n",
+       "    pfts1d_jxy          (npft, n_face) float64 2MB 1.0 1.0 1.0 ... 1.0 1.0 1.0\n",
+       "    pfts1d_gi           (npft, n_face) float64 2MB 1.0 2.0 ... 1.596e+04\n",
+       "    ...                  ...\n",
+       "    pfts1d_wtcol        (npft, n_face) float64 2MB 0.0 0.0 0.0 ... 1.0 1.0 1.0\n",
+       "    pfts1d_itype_veg    (npft, n_face) float64 2MB 1.0 1.0 1.0 ... 15.0 15.0\n",
+       "    pfts1d_itype_col    (npft, n_face) float64 2MB 1.0 1.0 1.0 ... 215.0 215.0\n",
+       "    pfts1d_itype_lunit  (npft, n_face) float64 2MB 1.0 1.0 1.0 ... 2.0 2.0 2.0\n",
+       "    pfts1d_active       (npft, n_face) float64 2MB nan nan nan ... nan nan nan\n",
+       "    TLAI                (npft, n_face) float32 958kB nan nan nan ... nan nan nan
" + ], + "text/plain": [ + " Size: 32MB\n", + "Dimensions: (npft: 15, hist_interval: 2, n_face: 15962)\n", + "Coordinates:\n", + " * n_face (n_face) int64 128kB 737 738 745 ... 48598 48599 48600\n", + "Dimensions without coordinates: npft, hist_interval\n", + "Data variables: (12/16)\n", + " time_bounds (npft, hist_interval, n_face) object 4MB 1869-12-01 0...\n", + " pfts1d_lon (npft, n_face) float64 2MB 19.5 20.5 ... 136.0 135.0\n", + " pfts1d_lat (npft, n_face) float64 2MB -34.9 -34.73 ... 36.2 35.74\n", + " pfts1d_ixy (npft, n_face) float64 2MB 737.0 738.0 ... 4.86e+04\n", + " pfts1d_jxy (npft, n_face) float64 2MB 1.0 1.0 1.0 ... 1.0 1.0 1.0\n", + " pfts1d_gi (npft, n_face) float64 2MB 1.0 2.0 ... 1.596e+04\n", + " ... ...\n", + " pfts1d_wtcol (npft, n_face) float64 2MB 0.0 0.0 0.0 ... 1.0 1.0 1.0\n", + " pfts1d_itype_veg (npft, n_face) float64 2MB 1.0 1.0 1.0 ... 15.0 15.0\n", + " pfts1d_itype_col (npft, n_face) float64 2MB 1.0 1.0 1.0 ... 215.0 215.0\n", + " pfts1d_itype_lunit (npft, n_face) float64 2MB 1.0 1.0 1.0 ... 2.0 2.0 2.0\n", + " pfts1d_active (npft, n_face) float64 2MB nan nan nan ... nan nan nan\n", + " TLAI (npft, n_face) float32 958kB nan nan nan ... nan nan nan" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# select a single PFT\n", + "## TODO this step is kind of a memory hog\n", + "## OERO NOTE: Almost no memory increase after this code's execution in this UXarray's case\n", + "npft=16\n", + "var='TLAI'\n", + "\n", + "for i in range(1, npft):\n", + " print('starting pft ' + str(i))\n", + " ## OERO NOTE: UxDataset.where() below had an issue that we've fixed last week and the fixed \n", + " ## version is scheduled for release v2025.03.0 today. If you want to check this code out sooner\n", + " ## than the release, run the following command in your conda environment to install UXarray from \n", + " ## the GitHub repository:\n", + " ## pip install git+https://github.com/UXARRAY/uxarray.git\n", + " temp = uxds1.where(uxds1.pfts1d_itype_veg==i, drop=True)\n", + " # TODO, this should be time evolving, but not currently doen\n", + " # Rename coord, since the pft dimension is not meaningful\n", + " temp= temp.rename({'pft': 'n_face'})\n", + " \n", + " # assign values from pfts1d_ixy to n_face\n", + " temp['n_face'] = temp.pfts1d_ixy.astype(int)\n", + " temp.assign_coords({\"npft\": i})\n", + " # combine along PFT variable\n", + " if i == 1:\n", + " uxdsOut = temp\n", + " else:\n", + " uxdsOut = xr.concat([uxdsOut, temp], dim=\"npft\")\n", + "\n", + "## UXARRAY TODO: After Xarray.concatenate call on UXarray objects, the Grid object, ``uxgrid``\n", + "## is being dropped. To get it back, I had to reassign. While being able to run Xarray's builtin \n", + "## function on UXarray objects directly was convenient, and adding this Grid back is not a big deal\n", + "## we may still want to explore an UXarray solution for concatenate\n", + "uxdsOut.uxgrid = temp.uxgrid\n", + "uxdsOut" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1a00407c-d4bd-4925-9eb3-8c23701b729d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.UxDataArray 'GPP' (n_face: 48600)> Size: 194kB\n",
+       "array([          nan,           nan,           nan, ..., 7.3058734e-05,\n",
+       "       7.4361727e-05, 8.8926041e-05], dtype=float32)\n",
+       "Coordinates:\n",
+       "  * n_face   (n_face) int64 389kB 1 2 3 4 5 6 ... 48596 48597 48598 48599 48600
" + ], + "text/plain": [ + " Size: 194kB\n", + "array([ nan, nan, nan, ..., 7.3058734e-05,\n", + " 7.4361727e-05, 8.8926041e-05], dtype=float32)\n", + "Coordinates:\n", + " * n_face (n_face) int64 389kB 1 2 3 4 5 6 ... 48596 48597 48598 48599 48600" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# align subset pft output with plotting data array\n", + "target = uxds0.GPP\n", + "n_face_coords = np.arange(1,(uxds1.pfts1d_ixy.max().astype(int)+1))\n", + "target = target.assign_coords({'n_face': ('n_face', n_face_coords)})\n", + "target" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7c32ae56-de87-4255-8688-82d2bfeee9b3", + "metadata": {}, + "outputs": [], + "source": [ + "# Now align the land only output on the target (full) grid\n", + "uxdsOut_align, target = xr.align(uxdsOut, target, join=\"right\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "56e648bf-ca0e-4e72-82b9-96d177800489", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.UxDataset> Size: 10MB\n",
+       "Dimensions:         (n_face: 48600, npft: 15)\n",
+       "Coordinates:\n",
+       "  * n_face          (n_face) int64 389kB 1 2 3 4 5 ... 48597 48598 48599 48600\n",
+       "Dimensions without coordinates: npft\n",
+       "Data variables:\n",
+       "    GPP             (n_face) float32 194kB nan nan nan ... 7.436e-05 8.893e-05\n",
+       "    area            (n_face) float32 194kB nan nan nan ... 9.519e+03 9.519e+03\n",
+       "    landfrac        (n_face) float32 194kB nan nan nan ... 0.6608 0.2991 0.07713\n",
+       "    landmask        (n_face) float64 389kB nan nan nan nan ... nan 1.0 1.0 1.0\n",
+       "    TLAI            (npft, n_face) float32 3MB nan nan nan nan ... nan nan nan\n",
+       "    pfts1d_wtgcell  (npft, n_face) float64 6MB nan nan nan nan ... 0.0 0.0 0.0
" + ], + "text/plain": [ + " Size: 10MB\n", + "Dimensions: (n_face: 48600, npft: 15)\n", + "Coordinates:\n", + " * n_face (n_face) int64 389kB 1 2 3 4 5 ... 48597 48598 48599 48600\n", + "Dimensions without coordinates: npft\n", + "Data variables:\n", + " GPP (n_face) float32 194kB nan nan nan ... 7.436e-05 8.893e-05\n", + " area (n_face) float32 194kB nan nan nan ... 9.519e+03 9.519e+03\n", + " landfrac (n_face) float32 194kB nan nan nan ... 0.6608 0.2991 0.07713\n", + " landmask (n_face) float64 389kB nan nan nan nan ... nan 1.0 1.0 1.0\n", + " TLAI (npft, n_face) float32 3MB nan nan nan nan ... nan nan nan\n", + " pfts1d_wtgcell (npft, n_face) float64 6MB nan nan nan nan ... 0.0 0.0 0.0" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Copy pft indexed data back to the h0 file\n", + "# This allows us to use area and landfrac on the same dataset \n", + "# Used to calculate weighted sums of LAI and livefrac\n", + "uxds0_plot = uxds0\n", + "uxds0_plot[var] = uxdsOut_align[var]\n", + "uxds0_plot['pfts1d_wtgcell'] = uxdsOut_align['pfts1d_wtgcell']\n", + "uxds0_plot\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f847e56b-d807-4dab-8be1-e3d1cfeb5b71", + "metadata": {}, + "outputs": [], + "source": [ + "pft_names = ['NET Temperate', 'NET Boreal', 'NDT Boreal',\n", + " 'BET Tropical', 'BET Temperate', 'BDT Tropical',\n", + " 'BDT Temperate', 'BDT Boreal', 'BES Temperate',\n", + " 'BDS Temperate', 'BDS Boreal', 'C3 Grass Arctic',\n", + " 'C3 Grass', 'C4 Grass', 'UCrop UIrr']" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "55ceea85-e3e2-4e2e-a88c-03c1313acf31", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-- wrote pft TLAI figure --\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transform = ccrs.PlateCarree()\n", + "proj = ccrs.PlateCarree()\n", + "cmap = plt.cm.viridis_r\n", + "cmap.set_under(color='deeppink')\n", + "cmap = cmap.resampled(7)\n", + "levels = [0.1, 1, 2, 3, 4, 5, 6,7]\n", + "\n", + "# create figure object\n", + "fig, axs = plt.subplots(5,3,\n", + " facecolor=\"w\",\n", + " constrained_layout=True,\n", + " subplot_kw=dict(projection=proj) )\n", + "\n", + "axs=axs.flatten()\n", + "\n", + "# Loop over pfts\n", + "for i in range((npft-1)):\n", + " ac = uxds0_plot[var].isel(npft=i).to_polycollection(projection=proj)\n", + " ac.set_cmap(cmap)\n", + " ac.set_antialiased(False)\n", + " ac.set_transform(transform)\n", + " ac.set_clim(vmin=0.1,vmax=6.9)\n", + " axs[i].add_collection(ac)\n", + "\n", + " #Titles, statistics\n", + " wgts = uxds0_plot.area * uxds0_plot.landfrac * uxds0_plot.pfts1d_wtgcell.isel(npft=i)\n", + " wgts = wgts / wgts.sum()\n", + " mean = str(np.round((uxds0_plot[var].isel(npft=i)*wgts).sum().values,2))\n", + " dead = ((uxds0_plot[var].isel(npft=i)<0.1)*wgts).sum()\n", + " live = ((uxds0_plot[var].isel(npft=i)>0.1)*wgts).sum()\n", + " livefrac = str(np.round((live/(live+dead)).values,2))\n", + " axs[i].set_title(pft_names[i], loc='left',size=6)\n", + " axs[i].text(-30, -45,'mean = '+ mean, fontsize=5)\n", + " axs[i].text(-45, -60,'live frac = '+livefrac,fontsize=5)\n", + "\n", + "for a in axs:\n", + " a.coastlines()\n", + " a.set_global()\n", + " a.spines['geo'].set_linewidth(0.1) #cartopy's recommended method\n", + " a.set_extent([-180, 180, -65, 86])\n", + "\n", + "#fig.subplots_adjust(right=0.97)\n", + "cbar_ax = fig.add_axes([0.92, 0.05, 0.02, 0.8])\n", + "fig.colorbar(ac, cax=cbar_ax, pad=0.05, shrink=0.8, aspect=40,\n", + " extend='both')\n", + "fig.suptitle(\"max LAI \"+ case,size='medium')\n", + "fig.set_layout_engine(\"compressed\")\n", + "\n", + "fig.savefig('h1_test', bbox_inches='tight', dpi=300)\n", + "print('-- wrote pft '+var+' figure --')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1d2c3658-48a9-4ca9-931d-a592c46e1c60", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:cupid-analysis]", + "language": "python", + "name": "conda-env-cupid-analysis-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/lmwg_wish_list.md b/lmwg_wish_list.md index 3f99b0ce4..ba5ad25b4 100644 --- a/lmwg_wish_list.md +++ b/lmwg_wish_list.md @@ -12,11 +12,16 @@ ### Development -[ ] Separate time bounds for time series and climo generation. --[ ] Write python function to make regional timeseries or climo plots --[ ] Check applicaiton of adf timeseries plots for land, +-[ ] *Top need* Write python function to make regional timeseries or climo plots +-[ ] Check application of adf timeseries plots for land, - this was working on wwieder/clm-test branch --[x] Handle h1 files for PFT specific results +-[ ] Handle h1 files for PFT specific results + - Need to convert notebook for unstructured data in to python fuction that uses upstream ADF workflow & adds plots to website + - also need unstructured example -[ ] Integrate observations! + - Populate datasets in central location (e.g. `/glade/campaign/cgd/amp/amwg/ADF_obs`), maybe this lives in a CUPiD observations home? + - Regrid to standard resolution(s), start with f09_t232 + # From 3b639c8e6d633d4824bdbc87f9987ccbdd0ef9e4 Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 4 Apr 2025 10:24:16 -0600 Subject: [PATCH 036/126] remove bad color options --- lib/ldf_variable_defaults.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/ldf_variable_defaults.yaml b/lib/ldf_variable_defaults.yaml index 982cfc76f..65b0b9ea4 100644 --- a/lib/ldf_variable_defaults.yaml +++ b/lib/ldf_variable_defaults.yaml @@ -188,7 +188,7 @@ DSTFLXT: # total surface dust emission avg_method: 'sum' table_unit: "Pg y$^{-1}" -MEG_isoprene: # total surface dust emission +MEG_isoprene: category: "Surface fluxes" colormap: "Blues" diff_colormap: "BrBG_r" From 98f51d9657e14e64e953fe4a0fdf6bce03503626 Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 4 Apr 2025 10:25:35 -0600 Subject: [PATCH 037/126] correct path to ldf_defaults --- config_unstructured_plots.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config_unstructured_plots.yaml b/config_unstructured_plots.yaml index d37721e73..194e47618 100644 --- a/config_unstructured_plots.yaml +++ b/config_unstructured_plots.yaml @@ -97,7 +97,7 @@ diag_basic_info: #Location of ADF variable plotting defaults YAML file: #If left blank or missing, ADF/lib/adf_variable_defaults.yaml will be used #Uncomment and change path for custom variable defaults file - defaults_file: ldf_variable_defaults.yaml + defaults_file: lib/ldf_variable_defaults.yaml #Longitude line on which to center all lat/lon maps. #If this config option is missing then the central From bf28eec8711bca36ccefbeb3adcc471181dfdb05 Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 4 Apr 2025 14:41:47 -0600 Subject: [PATCH 038/126] correct path to cam_ts_loc --- config_clm_native_grid_to_latlon.yaml | 37 +++++++++++++-------------- 1 file changed, 18 insertions(+), 19 deletions(-) diff --git a/config_clm_native_grid_to_latlon.yaml b/config_clm_native_grid_to_latlon.yaml index f573063af..83f710f67 100644 --- a/config_clm_native_grid_to_latlon.yaml +++ b/config_clm_native_grid_to_latlon.yaml @@ -58,7 +58,7 @@ # Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script # to check for a failure to customize # -user: 'USER-NAME-NOT-SET' +user: wwieder #'USER-NAME-NOT-SET' #This first set of variables specify basic info used by all diagnostic runs: diag_basic_info: @@ -84,7 +84,7 @@ diag_basic_info: obs_data_loc: /glade/campaign/cgd/amp/amwg/ADF_obs #Location where re-gridded and interpolated CAM climatology files are stored: - cam_regrid_loc: /glade/derecho/scratch/${user}/ADF/regrid + cam_regrid_loc: /glade/derecho/scratch/${user}/ADF_LatLon/regrid #Overwrite CAM re-gridded files? #If false, or missing, then regridding will be skipped for regridded variables @@ -92,7 +92,7 @@ diag_basic_info: cam_overwrite_regrid: false #Location where diagnostic plots are stored: - cam_diag_plot_loc: /glade/derecho/scratch/${user}/ADF/plots + cam_diag_plot_loc: /glade/derecho/scratch/${user}/ADF_LatLon/plots #Location of ADF variable plotting defaults YAML file: #If left blank or missing, ADF/lib/adf_variable_defaults.yaml will be used @@ -134,16 +134,16 @@ diag_cam_climo: cam_overwrite_climo: false #Location of CAM climatologies (to be created and then used by this script) - cam_climo_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/climo + cam_climo_loc: /glade/derecho/scratch/${user}/ADF_LatLon/${diag_cam_climo.cam_case_name}/climo #Name of CAM case (or CAM run name): - cam_case_name: b.e30_beta05.BLT1850.ne30_t232_wgx3.123 + cam_case_name: b.e30_alpha06b.B1850C_LTso.ne30_t232_wgx3.143 #Case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '123' + case_nickname: '143' #Location of CAM history (h0) files: cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ @@ -161,12 +161,12 @@ diag_cam_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 25 + start_year: 30 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 35 + end_year: 40 #Do time series files exist? #If True, then diagnostics assumes that model files are already time series. @@ -184,7 +184,7 @@ diag_cam_climo: cam_overwrite_ts: false #Location where time series files are (or will be) stored: - cam_ts_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/ts + cam_ts_loc: /glade/derecho/scratch/${user}/ADF_LatLon/${diag_cam_climo.cam_case_name}/ts #This third set of variables provide info for the CAM baseline climatologies. @@ -206,16 +206,16 @@ diag_cam_baseline_climo: cam_overwrite_climo: false #Location of CAM climatologies (to be created and then used by this script) - cam_climo_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_baseline_climo.cam_case_name}/climo + cam_climo_loc: /glade/derecho/scratch/${user}/ADF_LatLon/${diag_cam_baseline_climo.cam_case_name}/climo #Name of CAM baseline case: - cam_case_name: b.e30_beta05.BLT1850.ne30_t232_wgx3.122 + cam_case_name: b.e30_alpha06b.B1850C_LTso.ne30_t232_wgx3.139 #Baseline case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '122' + case_nickname: '139' #Location of CAM baseline history (h0) files: #Example test files @@ -234,12 +234,12 @@ diag_cam_baseline_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 25 + start_year: 30 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 35 + end_year: 40 #Do time series files need to be generated? #If True, then diagnostics assumes that model files are already time series. @@ -258,7 +258,6 @@ diag_cam_baseline_climo: #Location where time series files are (or will be) stored: cam_ts_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_baseline_climo.cam_case_name}/ts - #+++++++++++++++++++++++++++++++++++++++++++++++++++ #These variables below only matter if you are using #a non-standard method, or are adding your own @@ -294,13 +293,13 @@ plotting_scripts: #List of CAM variables that will be processesd: #If CVDP is to be run PSL, TREFHT, TS and PRECT (or PRECC and PRECL) should be listed diag_var_list: - #- TSA + - TSA - PREC - ELAI - GPP -# - NPP -# - FSDS -# - ALTMAX + - NPP + - FSDS + - ALTMAX - ET - TOTRUNOFF - DSTFLXT From edec3a680d4168a73661e6ee500a562f4274ac85 Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 4 Apr 2025 14:43:40 -0600 Subject: [PATCH 039/126] updading conda envs --- env/ldf_environment.yaml | 28 --- env/ldf_v0.0.yaml | 439 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 439 insertions(+), 28 deletions(-) delete mode 100644 env/ldf_environment.yaml create mode 100644 env/ldf_v0.0.yaml diff --git a/env/ldf_environment.yaml b/env/ldf_environment.yaml deleted file mode 100644 index 297ec643c..000000000 --- a/env/ldf_environment.yaml +++ /dev/null @@ -1,28 +0,0 @@ -name: ldf_v0.01 -channels: - - conda-forge - - nodefaults -dependencies: - - cartopy - - cftime - - dask - - distributed - - geocat-comp - - geopandas - - intake - - intake-esm - - intake-xarray - - ipykernel - - matplotlib - - nc-time-axis - - ncar-jobqueue - - netcdf4 - - numpy - - pip - - python==3.11.4 - - uxarray - - xarray - - xesmf - - yaml - - zarr - diff --git a/env/ldf_v0.0.yaml b/env/ldf_v0.0.yaml new file mode 100644 index 000000000..c2de80bc8 --- /dev/null +++ b/env/ldf_v0.0.yaml @@ -0,0 +1,439 @@ +name: ldf_v0.0 +channels: + - conda-forge + - defaults + - r +dependencies: + - _libgcc_mutex=0.1=conda_forge + - _openmp_mutex=4.5=2_gnu + - alsa-lib=1.2.13=hb9d3cd8_0 + - annotated-types=0.7.0=pyhd8ed1ab_0 + - antimeridian=0.3.11=pyhd8ed1ab_0 + - aom=3.9.1=hac33072_0 + - asciitree=0.3.3=py_2 + - asttokens=2.4.1=pyhd8ed1ab_0 + - aws-c-auth=0.8.0=hb88c0a9_10 + - aws-c-cal=0.8.0=hecf86a2_2 + - aws-c-common=0.10.3=hb9d3cd8_0 + - aws-c-compression=0.3.0=hf42f96a_2 + - aws-c-event-stream=0.5.0=h1ffe551_7 + - aws-c-http=0.9.1=hab05fe4_2 + - aws-c-io=0.15.2=hdeadb07_2 + - aws-c-mqtt=0.11.0=h7bd072d_8 + - aws-c-s3=0.7.1=h3a84f74_3 + - aws-c-sdkutils=0.2.1=hf42f96a_1 + - aws-checksums=0.2.2=hf42f96a_1 + - aws-crt-cpp=0.29.4=h21d7256_1 + - aws-sdk-cpp=1.11.449=h1a02111_2 + - azure-core-cpp=1.14.0=h5cfcd09_0 + - azure-identity-cpp=1.10.0=h113e628_0 + - azure-storage-blobs-cpp=12.13.0=h3cf044e_1 + - azure-storage-common-cpp=12.8.0=h736e048_1 + - azure-storage-files-datalake-cpp=12.12.0=ha633028_1 + - bleach=6.2.0=pyhd8ed1ab_0 + - blosc=1.21.6=hef167b5_0 + - bokeh=3.5.2=pyhd8ed1ab_0 + - bottleneck=1.4.2=py311h9f3472d_0 + - branca=0.7.2=pyhd8ed1ab_0 + - brotli=1.1.0=hb9d3cd8_2 + - brotli-bin=1.1.0=hb9d3cd8_2 + - brotli-python=1.1.0=py311hfdbb021_2 + - bzip2=1.0.8=h4bc722e_7 + - c-ares=1.34.3=heb4867d_0 + - ca-certificates=2025.1.31=hbcca054_0 + - cairo=1.18.0=hebfffa5_3 + - cartopy=0.24.0=py311h7db5c69_0 + - certifi=2025.1.31=pyhd8ed1ab_0 + - cf_xarray=0.10.0=pyhd8ed1ab_0 + - cffi=1.17.1=py311hf29c0ef_0 + - cftime=1.6.4=py311h9f3472d_1 + - charset-normalizer=3.4.0=pyhd8ed1ab_0 + - click=8.1.7=unix_pyh707e725_0 + - cloudpickle=3.1.0=pyhd8ed1ab_1 + - colorama=0.4.6=pyhd8ed1ab_0 + - colorcet=3.1.0=pyhd8ed1ab_0 + - comm=0.2.2=pyhd8ed1ab_0 + - contourpy=1.3.1=py311hd18a35c_0 + - cycler=0.12.1=pyhd8ed1ab_0 + - cyrus-sasl=2.1.27=h54b06d7_7 + - cytoolz=1.0.0=py311h9ecbd09_1 + - dask=2024.11.2=pyhff2d567_1 + - dask-core=2024.11.2=pyhff2d567_1 + - dask-expr=1.1.19=pyhd8ed1ab_0 + - dask-jobqueue=0.9.0=pyhd8ed1ab_0 + - datashader=0.16.3=pyhd8ed1ab_0 + - dav1d=1.2.1=hd590300_0 + - dbus=1.13.6=h5008d03_3 + - debugpy=1.8.8=py311hfdbb021_0 + - decorator=5.1.1=pyhd8ed1ab_0 + - distributed=2024.11.2=pyhff2d567_1 + - double-conversion=3.3.0=h59595ed_0 + - eofs=2.0.0=pyhff2d567_0 + - esmf=8.8.0=nompi_h4441c20_0 + - esmpy=8.8.0=pyhecae5ae_0 + - exceptiongroup=1.2.2=pyhd8ed1ab_0 + - executing=2.1.0=pyhd8ed1ab_0 + - expat=2.6.4=h5888daf_0 + - fasteners=0.17.3=pyhd8ed1ab_0 + - fastprogress=1.0.3=pyhd8ed1ab_0 + - flexcache=0.3=pyhd8ed1ab_0 + - flexparser=0.4=pyhd8ed1ab_0 + - folium=0.18.0=pyhd8ed1ab_0 + - font-ttf-dejavu-sans-mono=2.37=hab24e00_0 + - font-ttf-inconsolata=3.000=h77eed37_0 + - font-ttf-source-code-pro=2.038=h77eed37_0 + - font-ttf-ubuntu=0.83=h77eed37_3 + - fontconfig=2.15.0=h7e30c49_1 + - fonts-conda-ecosystem=1=0 + - fonts-conda-forge=1=0 + - fonttools=4.55.0=py311h2dc5d0c_0 + - freetype=2.12.1=h267a509_2 + - freexl=2.0.0=h743c826_0 + - fsspec=2024.10.0=pyhff2d567_0 + - geocat-comp=2024.04.0=pyha770c72_0 + - geopandas=1.0.1=pyhd8ed1ab_1 + - geopandas-base=1.0.1=pyha770c72_1 + - geos=3.13.0=h5888daf_0 + - geotiff=1.7.3=h77b800c_3 + - geoviews=1.13.0=hd8ed1ab_0 + - geoviews-core=1.13.0=pyha770c72_0 + - gflags=2.2.2=h5888daf_1005 + - giflib=5.2.2=hd590300_0 + - glog=0.7.1=hbabe93e_0 + - graphite2=1.3.13=h59595ed_1003 + - h2=4.1.0=pyhd8ed1ab_0 + - harfbuzz=9.0.0=hda332d3_1 + - hdf4=4.2.15=h2a13503_7 + - hdf5=1.14.3=nompi_h2d575fe_108 + - holoviews=1.20.0=pyhd8ed1ab_0 + - hpack=4.0.0=pyh9f0ad1d_0 + - hvplot=0.11.1=pyhd8ed1ab_0 + - hyperframe=6.0.1=pyhd8ed1ab_0 + - icu=75.1=he02047a_0 + - idna=3.10=pyhd8ed1ab_0 + - importlib-metadata=8.5.0=pyha770c72_0 + - intake=2.0.7=pyhd8ed1ab_0 + - intake-esm=2023.11.10=pyhd8ed1ab_0 + - intake-xarray=0.7.0=pyhd8ed1ab_0 + - ipykernel=6.29.5=pyh3099207_0 + - ipython=8.29.0=pyh707e725_0 + - jedi=0.19.2=pyhff2d567_0 + - jinja2=3.1.4=pyhd8ed1ab_0 + - joblib=1.4.2=pyhd8ed1ab_0 + - json-c=0.18=h6688a6e_0 + - jupyter_client=8.6.3=pyhd8ed1ab_0 + - jupyter_core=5.7.2=pyh31011fe_1 + - keyutils=1.6.1=h166bdaf_0 + - kiwisolver=1.4.7=py311hd18a35c_0 + - krb5=1.21.3=h659f571_0 + - lcms2=2.16=hb7c19ff_0 + - ld_impl_linux-64=2.43=h712a8e2_2 + - lerc=4.0.0=h27087fc_0 + - libabseil=20240722.0=cxx17_h5888daf_1 + - libaec=1.1.3=h59595ed_0 + - libarchive=3.7.4=hfca40fe_0 + - libarrow=18.0.0=h3b997a5_7_cpu + - libarrow-acero=18.0.0=h5888daf_7_cpu + - libarrow-dataset=18.0.0=h5888daf_7_cpu + - libarrow-substrait=18.0.0=h5c8f2c3_7_cpu + - libavif16=1.1.1=h1909e37_2 + - libblas=3.9.0=25_linux64_openblas + - libbrotlicommon=1.1.0=hb9d3cd8_2 + - libbrotlidec=1.1.0=hb9d3cd8_2 + - libbrotlienc=1.1.0=hb9d3cd8_2 + - libcblas=3.9.0=25_linux64_openblas + - libclang-cpp19.1=19.1.4=default_hb5137d0_0 + - libclang13=19.1.4=default_h9c6a7e4_0 + - libcrc32c=1.1.2=h9c3ff4c_0 + - libcups=2.3.3=h4637d8d_4 + - libcurl=8.10.1=hbbe4b11_0 + - libde265=1.0.15=h00ab1b0_0 + - libdeflate=1.22=hb9d3cd8_0 + - libdrm=2.4.123=hb9d3cd8_0 + - libedit=3.1.20191231=he28a2e2_2 + - libegl=1.7.0=ha4b6fd6_2 + - libev=4.33=hd590300_2 + - libevent=2.1.12=hf998b51_1 + - libexpat=2.6.4=h5888daf_0 + - libffi=3.4.2=h7f98852_5 + - libgcc=14.2.0=h77fa898_1 + - libgcc-ng=14.2.0=h69a702a_1 + - libgdal-core=3.10.0=hef9eae6_1 + - libgfortran=14.2.0=h69a702a_1 + - libgfortran5=14.2.0=hd5240d6_1 + - libgl=1.7.0=ha4b6fd6_2 + - libglib=2.82.2=h2ff4ddf_0 + - libglvnd=1.7.0=ha4b6fd6_2 + - libglx=1.7.0=ha4b6fd6_2 + - libgomp=14.2.0=h77fa898_1 + - libgoogle-cloud=2.31.0=h804f50b_0 + - libgoogle-cloud-storage=2.31.0=h0121fbd_0 + - libgrpc=1.67.1=hc2c308b_0 + - libheif=1.18.2=gpl_hffcb242_100 + - libiconv=1.17=hd590300_2 + - libjpeg-turbo=3.0.0=hd590300_1 + - libkml=1.3.0=hf539b9f_1021 + - liblapack=3.9.0=25_linux64_openblas + - libllvm14=14.0.6=hcd5def8_4 + - libllvm19=19.1.4=ha7bfdaf_0 + - libnetcdf=4.9.2=nompi_h00e09a9_116 + - libnghttp2=1.64.0=h161d5f1_0 + - libnsl=2.0.1=hd590300_0 + - libntlm=1.4=h7f98852_1002 + - libopenblas=0.3.28=pthreads_h94d23a6_1 + - libopengl=1.7.0=ha4b6fd6_2 + - libparquet=18.0.0=h6bd9018_7_cpu + - libpciaccess=0.18=hd590300_0 + - libpng=1.6.44=hadc24fc_0 + - libpq=17.1=h04577a9_0 + - libprotobuf=5.28.2=h5b01275_0 + - libre2-11=2024.07.02=hbbce691_1 + - librttopo=1.1.0=h97f6797_17 + - libsodium=1.0.20=h4ab18f5_0 + - libspatialite=5.1.0=h1b4f908_11 + - libsqlite=3.47.0=hadc24fc_1 + - libssh2=1.11.0=h0841786_0 + - libstdcxx=14.2.0=hc0a3c3a_1 + - libstdcxx-ng=14.2.0=h4852527_1 + - libthrift=0.21.0=h0e7cc3e_0 + - libtiff=4.7.0=he137b08_1 + - libutf8proc=2.8.0=h166bdaf_0 + - libuuid=2.38.1=h0b41bf4_0 + - libwebp-base=1.4.0=hd590300_0 + - libxcb=1.17.0=h8a09558_0 + - libxkbcommon=1.7.0=h2c5496b_1 + - libxml2=2.13.5=hb346dea_0 + - libxslt=1.1.39=h76b75d6_0 + - libzip=1.11.2=h6991a6a_0 + - libzlib=1.3.1=hb9d3cd8_2 + - linkify-it-py=2.0.3=pyhd8ed1ab_0 + - llvmlite=0.43.0=py311h9c9ff8c_1 + - locket=1.0.0=pyhd8ed1ab_0 + - lz4=4.3.3=py311h2cbdf9a_1 + - lz4-c=1.9.4=hcb278e6_0 + - lzo=2.10=hd590300_1001 + - mapclassify=2.8.1=pyhd8ed1ab_0 + - markdown=3.6=pyhd8ed1ab_0 + - markdown-it-py=3.0.0=pyhd8ed1ab_0 + - markupsafe=3.0.2=py311h2dc5d0c_0 + - matplotlib=3.9.2=py311h38be061_2 + - matplotlib-base=3.9.2=py311h2b939e6_2 + - matplotlib-inline=0.1.7=pyhd8ed1ab_0 + - mdit-py-plugins=0.4.2=pyhd8ed1ab_0 + - mdurl=0.1.2=pyhd8ed1ab_0 + - metpy=1.6.3=pyhd8ed1ab_0 + - minizip=4.0.7=h401b404_0 + - msgpack-python=1.1.0=py311hd18a35c_0 + - multipledispatch=0.6.0=pyhd8ed1ab_1 + - munkres=1.1.4=pyh9f0ad1d_0 + - mysql-common=9.0.1=h266115a_2 + - mysql-libs=9.0.1=he0572af_2 + - nc-time-axis=1.4.1=pyhd8ed1ab_0 + - ncar-jobqueue=2021.4.14=pyh44b312d_0 + - ncurses=6.5=he02047a_1 + - nest-asyncio=1.6.0=pyhd8ed1ab_0 + - netcdf-fortran=4.6.1=nompi_h22f9119_108 + - netcdf4=1.7.2=nompi_py311hae66bec_101 + - networkx=3.4.2=pyh267e887_2 + - numba=0.60.0=py311h4bc866e_0 + - numcodecs=0.14.0=py311h7db5c69_0 + - numpy=1.26.4=py311h64a7726_0 + - openjpeg=2.5.2=h488ebb8_0 + - openldap=2.6.8=hedd0468_0 + - openssl=3.4.1=h7b32b05_0 + - orc=2.0.3=he039a57_0 + - packaging=24.2=pyhff2d567_1 + - pandas=2.2.3=py311h7db5c69_1 + - panel=1.5.4=pyhd8ed1ab_0 + - param=2.1.1=pyhff2d567_0 + - parso=0.8.4=pyhd8ed1ab_0 + - partd=1.4.2=pyhd8ed1ab_0 + - patsy=1.0.1=pyhff2d567_0 + - pcre2=10.44=hba22ea6_2 + - pexpect=4.9.0=pyhd8ed1ab_0 + - pickleshare=0.7.5=py_1003 + - pillow=11.0.0=py311h49e9ac3_0 + - pint=0.24.4=pyhd8ed1ab_0 + - pip=24.3.1=pyh8b19718_0 + - pixman=0.43.2=h59595ed_0 + - platformdirs=4.3.6=pyhd8ed1ab_0 + - pooch=1.8.2=pyhd8ed1ab_0 + - proj=9.5.0=h12925eb_0 + - prompt-toolkit=3.0.48=pyha770c72_0 + - properscoring=0.1=py_0 + - psutil=6.1.0=py311h9ecbd09_0 + - pthread-stubs=0.4=hb9d3cd8_1002 + - ptyprocess=0.7.0=pyhd3deb0d_0 + - pure_eval=0.2.3=pyhd8ed1ab_0 + - pyarrow=18.0.0=py311h38be061_1 + - pyarrow-core=18.0.0=py311h4854187_1_cpu + - pycparser=2.22=pyhd8ed1ab_0 + - pyct=0.5.0=pyhd8ed1ab_0 + - pydantic=2.9.2=pyhd8ed1ab_0 + - pydantic-core=2.23.4=py311h9e33e62_0 + - pygments=2.18.0=pyhd8ed1ab_0 + - pyogrio=0.10.0=py311hf6089d3_1 + - pyparsing=3.2.0=pyhd8ed1ab_1 + - pyproj=3.7.0=py311h0f98d5a_0 + - pyshp=2.3.1=pyhd8ed1ab_0 + - pyside6=6.8.0.2=py311h9053184_0 + - pysocks=1.7.1=pyha2e5f31_6 + - python=3.11.4=hab00c5b_0_cpython + - python-dateutil=2.9.0.post0=pyhff2d567_0 + - python-tzdata=2024.2=pyhd8ed1ab_0 + - python_abi=3.11=5_cp311 + - pytz=2024.1=pyhd8ed1ab_0 + - pyviz_comms=3.0.3=pyhd8ed1ab_0 + - pyyaml=6.0.2=py311h9ecbd09_1 + - pyzmq=26.2.0=py311h7deb3e3_3 + - qhull=2020.2=h434a139_5 + - qt6-main=6.8.0=h6e8976b_0 + - rav1e=0.6.6=he8a937b_2 + - re2=2024.07.02=h77b4e00_1 + - readline=8.2=h8228510_1 + - requests=2.32.3=pyhd8ed1ab_0 + - retrying=1.3.3=pyhd8ed1ab_3 + - s2n=1.5.9=h0fd0ee4_0 + - scikit-learn=1.5.2=py311h57cc02b_1 + - scipy=1.14.1=py311he9a78e4_1 + - setuptools=75.5.0=pyhff2d567_0 + - shapely=2.0.6=py311h2fdb869_2 + - six=1.16.0=pyh6c4a22f_0 + - snappy=1.2.1=ha2e4443_0 + - sortedcontainers=2.4.0=pyhd8ed1ab_0 + - sparse=0.15.5=pyh72ffeb9_0 + - spatialpandas=0.4.10=pyhd8ed1ab_1 + - sqlite=3.47.0=h9eae976_1 + - stack_data=0.6.2=pyhd8ed1ab_0 + - statsmodels=0.14.4=py311h9f3472d_0 + - svt-av1=2.3.0=h5888daf_0 + - tblib=3.0.0=pyhd8ed1ab_0 + - threadpoolctl=3.5.0=pyhc1e730c_0 + - tk=8.6.13=noxft_h4845f30_101 + - toolz=1.0.0=pyhd8ed1ab_0 + - tornado=6.4.1=py311h9ecbd09_1 + - tqdm=4.67.0=pyhd8ed1ab_0 + - traitlets=5.14.3=pyhd8ed1ab_0 + - typing-extensions=4.12.2=hd8ed1ab_0 + - typing_extensions=4.12.2=pyha770c72_0 + - tzdata=2024b=hc8b5060_0 + - uc-micro-py=1.0.3=pyhd8ed1ab_0 + - unicodedata2=15.1.0=py311h9ecbd09_1 + - uriparser=0.9.8=hac33072_0 + - urllib3=2.2.3=pyhd8ed1ab_0 + - uxarray=2024.11.0=pyhd8ed1ab_0 + - wayland=1.23.1=h3e06ad9_0 + - wcwidth=0.2.13=pyhd8ed1ab_0 + - webencodings=0.5.1=pyhd8ed1ab_2 + - wheel=0.45.0=pyhd8ed1ab_0 + - x265=3.5=h924138e_3 + - xarray=2024.10.0=pyhd8ed1ab_0 + - xcb-util=0.4.1=hb711507_2 + - xcb-util-cursor=0.1.5=hb9d3cd8_0 + - xcb-util-image=0.4.0=hb711507_2 + - xcb-util-keysyms=0.4.1=hb711507_0 + - xcb-util-renderutil=0.3.10=hb711507_0 + - xcb-util-wm=0.4.2=hb711507_0 + - xerces-c=3.2.5=h988505b_2 + - xesmf=0.8.8=pyhd8ed1ab_1 + - xhistogram=0.3.2=pyhd8ed1ab_0 + - xkeyboard-config=2.43=hb9d3cd8_0 + - xorg-libice=1.1.1=hb9d3cd8_1 + - xorg-libsm=1.2.4=he73a12e_1 + - xorg-libx11=1.8.10=h4f16b4b_0 + - xorg-libxau=1.0.11=hb9d3cd8_1 + - xorg-libxcomposite=0.4.6=hb9d3cd8_2 + - xorg-libxcursor=1.2.3=hb9d3cd8_0 + - xorg-libxdamage=1.1.6=hb9d3cd8_0 + - xorg-libxdmcp=1.1.5=hb9d3cd8_0 + - xorg-libxext=1.3.6=hb9d3cd8_0 + - xorg-libxfixes=6.0.1=hb9d3cd8_0 + - xorg-libxi=1.8.2=hb9d3cd8_0 + - xorg-libxrandr=1.5.4=hb9d3cd8_0 + - xorg-libxrender=0.9.11=hb9d3cd8_1 + - xorg-libxtst=1.2.5=hb9d3cd8_3 + - xorg-libxxf86vm=1.1.5=hb9d3cd8_4 + - xorg-xorgproto=2024.1=hb9d3cd8_1 + - xskillscore=0.0.26=pyhd8ed1ab_0 + - xyzservices=2024.9.0=pyhd8ed1ab_0 + - xz=5.2.6=h166bdaf_0 + - yaml=0.2.5=h7f98852_2 + - zarr=2.18.3=pyhd8ed1ab_0 + - zeromq=4.3.5=h3b0a872_7 + - zict=3.0.0=pyhd8ed1ab_0 + - zipp=3.21.0=pyhd8ed1ab_0 + - zlib=1.3.1=hb9d3cd8_2 + - zstandard=0.23.0=py311hbc35293_1 + - zstd=1.5.6=ha6fb4c9_0 + - pip: + - alabaster==1.0.0 + - anyio==4.6.2.post1 + - argon2-cffi==23.1.0 + - argon2-cffi-bindings==21.2.0 + - arrow==1.3.0 + - async-lru==2.0.4 + - attrs==24.2.0 + - babel==2.16.0 + - beautifulsoup4==4.12.3 + - cmocean==4.0.3 + - defusedxml==0.7.1 + - docutils==0.21.2 + - fastjsonschema==2.20.0 + - fqdn==1.5.1 + - h11==0.14.0 + - httpcore==1.0.7 + - httpx==0.27.2 + - imagesize==1.4.1 + - iniconfig==2.0.0 + - ipywidgets==8.1.5 + - isoduration==20.11.0 + - json5==0.9.28 + - jsonpointer==3.0.0 + - jsonschema==4.23.0 + - jsonschema-specifications==2024.10.1 + - jupyter==1.1.1 + - jupyter-console==6.6.3 + - jupyter-events==0.10.0 + - jupyter-lsp==2.2.5 + - jupyter-server==2.14.2 + - jupyter-server-terminals==0.5.3 + - jupyterlab==4.2.6 + - jupyterlab-pygments==0.3.0 + - jupyterlab-server==2.27.3 + - jupyterlab-widgets==3.0.13 + - mistune==3.0.2 + - nbclient==0.10.0 + - nbconvert==7.16.4 + - nbformat==5.10.4 + - nbsphinx==0.9.5 + - notebook==7.2.2 + - notebook-shim==0.2.4 + - overrides==7.7.0 + - pandocfilters==1.5.1 + - pluggy==1.5.0 + - prometheus-client==0.21.0 + - pytest==8.3.3 + - python-json-logger==2.0.7 + - referencing==0.35.1 + - rfc3339-validator==0.1.4 + - rfc3986-validator==0.1.1 + - rpds-py==0.21.0 + - send2trash==1.8.3 + - sniffio==1.3.1 + - snowballstemmer==2.2.0 + - soupsieve==2.6 + - sphinx==8.1.3 + - sphinxcontrib-applehelp==2.0.0 + - sphinxcontrib-devhelp==2.0.0 + - sphinxcontrib-htmlhelp==2.1.0 + - sphinxcontrib-jsmath==1.0.1 + - sphinxcontrib-qthelp==2.0.0 + - sphinxcontrib-serializinghtml==2.0.0 + - terminado==0.18.1 + - tinycss2==1.4.0 + - types-python-dateutil==2.9.0.20241003 + - uri-template==1.3.0 + - webcolors==24.11.1 + - websocket-client==1.8.0 + - widgetsnbextension==4.0.13 +prefix: /glade/work/wwieder/conda-envs/cupid-analysis-justin From dd31d9843f71cc27e8f94dfe9dba42706ef48d2c Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 4 Apr 2025 17:02:45 -0600 Subject: [PATCH 040/126] working LatLon config file! --- config_clm_native_grid_to_latlon.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/config_clm_native_grid_to_latlon.yaml b/config_clm_native_grid_to_latlon.yaml index 83f710f67..ddcf7e16f 100644 --- a/config_clm_native_grid_to_latlon.yaml +++ b/config_clm_native_grid_to_latlon.yaml @@ -97,7 +97,7 @@ diag_basic_info: #Location of ADF variable plotting defaults YAML file: #If left blank or missing, ADF/lib/adf_variable_defaults.yaml will be used #Uncomment and change path for custom variable defaults file - defaults_file: ldf_variable_defaults.yaml + defaults_file: lib/ldf_variable_defaults.yaml #Longitude line on which to center all lat/lon maps. #If this config option is missing then the central @@ -256,7 +256,7 @@ diag_cam_baseline_climo: cam_overwrite_ts: false #Location where time series files are (or will be) stored: - cam_ts_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_baseline_climo.cam_case_name}/ts + cam_ts_loc: /glade/derecho/scratch/${user}/ADF_LatLon/${diag_cam_baseline_climo.cam_case_name}/ts #+++++++++++++++++++++++++++++++++++++++++++++++++++ #These variables below only matter if you are using From 0255585e6b17bca58109342836822339967dc0af Mon Sep 17 00:00:00 2001 From: wwieder Date: Sat, 5 Apr 2025 07:54:13 -0600 Subject: [PATCH 041/126] clean up config files --- config_clm_baseline_example.yaml | 474 ------------------ ...yaml => config_clm_unstructured_plots.yaml | 38 +- lib/adf_diag.py | 7 +- scripts/averaging/create_climo_files.py | 5 +- 4 files changed, 29 insertions(+), 495 deletions(-) delete mode 100644 config_clm_baseline_example.yaml rename config_unstructured_plots.yaml => config_clm_unstructured_plots.yaml (91%) diff --git a/config_clm_baseline_example.yaml b/config_clm_baseline_example.yaml deleted file mode 100644 index 2e9d31df3..000000000 --- a/config_clm_baseline_example.yaml +++ /dev/null @@ -1,474 +0,0 @@ -#============================== -#config_clm_baseline_example.yaml - -#This is the main CAM/CLM diagnostics config file -#for doing comparisons of a CAM or CLM run against -#another run, or baseline simulation. - -#Currently, if one is on NCAR's Casper or -#Cheyenne machine, then only the diagnostic output -#paths are needed, at least to perform a quick test -#run (these are indicated with "MUST EDIT" comments). -#Running these diagnostics on a different machine, -#or with a different, non-example simulation, will -#require additional modifications. -# -#Config file Keywords: -#-------------------- -# -#1. Using ${xxx} will substitute that text with the -# variable referenced by xxx. For example: -# -# cam_case_name: cool_run -# cam_climo_loc: /some/where/${cam_case_name} -# -# will set "cam_climo_loc" in the diagnostics package to: -# /some/where/cool_run -# -# Please note that currently this will only work if the -# variable only exists in one location in the file. -# -#2. Using ${.xxx} will do the same as -# keyword 1 above, but specifies which sub-section the -# variable is coming from, which is necessary for variables -# that are repeated in different subsections. For example: -# -# diag_basic_info: -# cam_climo_loc: /some/where/${diag_cam_climo.start_year} -# -# diag_cam_climo: -# start_year: 1850 -# -# will set "cam_climo_loc" in the diagnostics package to: -# /some/where/1850 -# -#Finally, please note that for both 1 and 2 the keywords must be lowercase. -#This is because future developments will hopefully use other keywords -#that are uppercase. Also please avoid using periods (".") in variable -#names, as this will likely cause issues with the current file parsing -#system. -#-------------------- -# -##============================== -# -# This file doesn't (yet) read environment variables, so the user must -# set this themselves. It is also a good idea to search the doc for 'user' -# to see what default paths are being set for output/working files. -# -# Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script -# to check for a failure to customize -# -user: 'USER-NAME-NOT-SET' - - -#This first set of variables specify basic info used by all diagnostic runs: -diag_basic_info: - - #Is this a model vs observations comparison? - #If "false" or missing, then a model-model comparison is assumed: - compare_obs: false - - #Generate HTML website (assumed false if missing): - #Note: The website files themselves will be located in the path - #specified by "cam_diag_plot_loc", under the "/website" subdirectory, - #where "" is the subdirectory created for this particular diagnostics run - #(usually "case_vs_obs_XXX" or "case_vs_baseline_XXX"). - create_html: true - - #Location of observational datasets: - #Note: this only matters if "compare_obs" is true and the path - #isn't specified in the variable defaults file. - obs_data_loc: /glade/campaign/cgd/amp/amwg/ADF_obs - - #Location where re-gridded and interpolated CAM climatology files are stored: - cam_regrid_loc: /glade/derecho/scratch/${user}/ADF/regrid - - #Overwrite CAM re-gridded files? - #If false, or missing, then regridding will be skipped for regridded variables - #that already exist in "cam_regrid_loc": - cam_overwrite_regrid: false - - #Location where diagnostic plots are stored: - cam_diag_plot_loc: /glade/derecho/scratch/${user}/ADF/plots - - #Location of ADF variable plotting defaults YAML file: - #If left blank or missing, ADF/lib/adf_variable_defaults.yaml will be used - #Uncomment and change path for custom variable defaults file - defaults_file: ldf_variable_defaults.yaml - - #Vertical pressure levels (in hPa) on which to plot 3-D variables - #when using horizontal (e.g. lat/lon) map projections. - #If this config option is missing, then no 3-D variables will be plotted on - #horizontal maps. Please note too that pressure levels must currently match - #what is available in the observations file in order to be plotted in a - #model vs obs run: - plot_press_levels: [200,850] - - #Longitude line on which to center all lat/lon maps. - #If this config option is missing then the central - #longitude will default to 180 degrees E. - central_longitude: 0 - - #Number of processors on which to run the ADF. - #If this config variable isn't present then - #the ADF defaults to one processor. Also, if - #you set it to "*" then it will default - #to all of the processors available on a - #single node/machine: - num_procs: 8 - - #If set to true, then redo all plots even if they already exist. - #If set to false, then if a plot is found it will be skipped: - redo_plot: false - # TODO, seems to redo plots anyway "NOTE: redo_plot is set to False" plotting continues... - -#This second set of variables provides info for the CAM simulation(s) being diagnosed: -diag_cam_climo: - - # History file list of strings to match - # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] - # Only affects timeseries as everything else uses the created timeseries - # Default: - hist_str: clm2.h0 - - #Name of CAM case (or CAM run name): - cam_case_name: b.e30_beta05.BLT1850.ne30_t232_wgx3.123 - - #Case nickname - #NOTE: if nickname starts with '0' - nickname must be in quotes! - # ie '026a' as opposed to 026a - #If missing or left blank, will default to cam_case_name - case_nickname: '123' - - #Location of CAM history (h0) files: - #Example test files - cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_climo.cam_case_name}/lnd/hist - - #Calculate climatologies? - #If false, the climatology files will not be created: - calc_cam_climo: true - - #Overwrite CAM climatology files? - #If false, or not prsent, then already existing climatology files will be skipped: - cam_overwrite_climo: false - - #Location of CAM climatologies (to be created and then used by this script) - cam_climo_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/climo - - # TODO, should we be able to define ts_start_year and climo_start_year independently - #model year when time series files should start: - #Note: Leaving this entry blank will make time series - # start at earliest available year. - start_year: 25 - - #model year when time series files should end: - #Note: Leaving this entry blank will make time series - # end at latest available year. - end_year: 44 - - #Do time series files exist? - #If True, then diagnostics assumes that model files are already time series. - #If False, or if simply not present, then diagnostics will attempt to create - #time series files from history (time-slice) files: - cam_ts_done: false - - #Save interim time series files? - #WARNING: This can take up a significant amount of space, - # but will save processing time the next time - cam_ts_save: true - - #Overwrite time series files, if found? - #If set to false, then time series creation will be skipped if files are found: - cam_overwrite_ts: false - - #Location where time series files are (or will be) stored: - cam_ts_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/ts - - - #---------------------- - - #You can alternatively provide a list of cases, which will make the ADF - #apply the same diagnostics to each case separately in a single ADF session. - #All of the config variables below show how it is done, and are the only ones - #that need to be lists. This also automatically enables the generation of - #a "main_website" in "cam_diag_plot_loc" that brings all of the different cases - #together under a single website. - - #Also please note that config keywords cannot currently be used in list mode. - - #cam_case_name: - # - b.e23_alpha17f.BLT1850.ne30_t232.098 - # - b.e23_alpha17f.BLT1850.ne30_t232.095 - - #Case nickname - #NOTE: if nickname starts with '0' - nickname must be in quotes! - # ie '026a' as opposed to 026a - #If missing or left blank, will default to cam_case_name - #case_nickname: - # - cool nickname - # - cool nickname 2 - - #calc_cam_climo: - # - true - # - true - - #cam_overwrite_climo: - # - false - # - false - - #cam_hist_loc: - # - /glade/campaign/cgd/amp/amwg/ADF_test_cases/b.e23_alpha17f.BLT1850.ne30_t232.098 - # - /glade/campaign/cgd/amp/amwg/ADF_test_cases/b.e23_alpha17f.BLT1850.ne30_t232.095 - - #cam_climo_loc: - # - /some/where/you/want/to/have/climo_files/ #MUST EDIT! - # - /the/same/or/some/other/climo/files/location - - #start_year: - # - 10 - # - 10 - - #end_year: - # - 14 - # - 14 - - #cam_ts_done: - # - false - # - false - - #cam_ts_save: - # - true - # - true - - #cam_overwrite_ts: - # - false - # - false - - #cam_ts_loc: - # - /some/where/you/want/to/have/time_series_files - # - /same/or/different/place/you/want/files - - #---------------------- - - -#This third set of variables provide info for the CAM baseline climatologies. -#This only matters if "compare_obs" is false: -diag_cam_baseline_climo: - - # History file list of strings to match - # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] - # Only affects timeseries as everything else uses the created timeseries - # Default: - hist_str: clm2.h0 - - #Name of CAM baseline case: - cam_case_name: b.e30_beta05.BLT1850.ne30_t232_wgx3.122 - - #Baseline case nickname - #NOTE: if nickname starts with '0' - nickname must be in quotes! - # ie '026a' as opposed to 026a - #If missing or left blank, will default to cam_case_name - case_nickname: '122' - - #Location of CAM baseline history (h0) files: - #Example test files - cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist - - #Calculate cam baseline climatologies? - #If false, the climatology files will not be created: - calc_cam_climo: true - - #Overwrite CAM climatology files? - #If false, or not present, then already existing climatology files will be skipped: - cam_overwrite_climo: false - - #Location of baseline CAM climatologies: - cam_climo_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_baseline_climo.cam_case_name}/climo - - #model year when time series files should start: - #Note: Leaving this entry blank will make time series - # start at earliest available year. - start_year: 25 - - #model year when time series files should end: - #Note: Leaving this entry blank will make time series - # end at latest available year. - end_year: 44 - - #Do time series files need to be generated? - #If True, then diagnostics assumes that model files are already time series. - #If False, or if simply not present, then diagnostics will attempt to create - #time series files from history (time-slice) files: - cam_ts_done: false - - #Save interim time series files for baseline run? - #WARNING: This can take up a significant amount of space: - cam_ts_save: true - - #Overwrite baseline time series files, if found? - #If set to false, then time series creation will be skipped if files are found: - cam_overwrite_ts: false - - #Location where time series files are (or will be) stored: - cam_ts_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_baseline_climo.cam_case_name}/ts - - -#This fourth set of variables provides settings for calling the Climate Variability -# Diagnostics Package (CVDP). If cvdp_run is set to true the CVDP will be set up and -# run in background mode, likely completing after the ADF has completed. -# If CVDP is to be run PSL, TREFHT, TS and PRECT (or PRECC and PRECL) should be listed -# in the diag_var_list variable listing. -# For more CVDP information: https://www.cesm.ucar.edu/working_groups/CVC/cvdp/ -diag_cvdp_info: - - # Run the CVDP on the listed run(s)? - cvdp_run: false - - # CVDP code path, sets the location of the CVDP codebase - # CGD systems path = /home/asphilli/CESM-diagnostics/CVDP/Release/v5.2.0/ - # CISL systems path = /glade/u/home/asphilli/CESM-diagnostics/CVDP/Release/v5.2.0/ - # github location = https://github.com/NCAR/CVDP-ncl - cvdp_codebase_loc: /glade/u/home/asphilli/CESM-diagnostics/CVDP/Release/v5.2.0/ - - # Location where cvdp codebase will be copied to and diagnostic plots will be stored - cvdp_loc: /glade/derecho/scratch/${user}/ADF/cvdp/ - - # tar up CVDP results? - cvdp_tar: false - -# This set of variables provides settings for calling NOAA's -# Model Diagnostic Task Force (MDTF) diagnostic package. -# https://github.com/NOAA-GFDL/MDTF-diagnostics -# -# If mdtf_run: true, the MDTF will be set up and -# run in background mode, likely completing after the ADF has completed. -# -# WARNING: This currently only runs on CASPER (not derecho) -# -# The variables required depend on the diagnostics (PODs) selected. -# AMWG-developed PODS and their required variables: -# (Note that PRECT can be computed from PRECC & PRECL) -# - MJO_suite: daily PRECT, FLUT, U850, U200, V200 (all required) -# - Wheeler-Kiladis Wavenumber Frequency Spectra: daily PRECT, FLUT, U200, U850, OMEGA500 -# (will use what is available) -# - Blocking (Rich Neale): daily OMEGA500 -# - Precip Diurnal Cycle (Rich Neale): 3-hrly PRECT -# -# Many other diagnostics are available; see -# https://mdtf-diagnostics.readthedocs.io/en/main/sphinx/start_overview.html - -# -diag_mdtf_info: - # Run the MDTF on the model cases - mdtf_run: false - - # The file that will be written by ADF to input to MDTF. Call this whatever you want. - mdtf_input_settings_filename : mdtf_input.json - - ## MDTF code path, sets the location of the MDTF codebase and pre-compiled conda envs - # CHANGE if you have any: your own MDTF code, installed conda envs and/or obs_data - - mdtf_codebase_path : /glade/campaign/cgd/amp/amwg/mdtf - mdtf_codebase_loc : ${mdtf_codebase_path}/MDTF-diagnostics.v3.1.20230817.ADF - conda_root : /glade/u/apps/opt/conda - conda_env_root : ${mdtf_codebase_path}/miniconda2/envs.MDTFv3.1.20230412/ - OBS_DATA_ROOT : ${mdtf_codebase_path}/obs_data - - # SET this to a writable dir. The ADF will place ts files here for the MDTF to read (adds the casename) - MODEL_DATA_ROOT : ${diag_cam_climo.cam_ts_loc}/mdtf/inputdata/model - - # Choose diagnostics (PODs). Full list of available PODs: https://github.com/NOAA-GFDL/MDTF-diagnostics - pod_list : [ "MJO_suite" ] - - # Intermediate/output file settings - make_variab_tar: false # tar up MDTF results - save_ps : false # save postscript figures in addition to bitmaps - save_nc : false # save netCDF files of processed data (recommend true when starting with new model data) - overwrite: true # overwrite results in OUTPUT_DIR; otherwise results will be saved under a unique name - - # Settings used in debugging: - verbose : 3 # Log verbosity level. - test_mode: false # Set to true for framework test. Data is fetched but PODs are not run. - dry_run : false # Framework test. No external commands are run and no remote data is copied. Implies test_mode. - - # Settings that shouldn't change in ADF implementation for now - data_type : single_run # single_run or multi_run (only works with single right now) - data_manager : Local_File # Fetch data or it is local? - environment_manager : Conda # Manage dependencies - - - -#+++++++++++++++++++++++++++++++++++++++++++++++++++ -#These variables below only matter if you are using -#a non-standard method, or are adding your own -#diagnostic scripts. -#+++++++++++++++++++++++++++++++++++++++++++++++++++ - -#Note: If you want to pass arguments to a particular script, you can -#do it like so (using the "averaging_example" script in this case): -# - {create_climo_files: {kwargs: {clobber: true}}} - -#Name of time-averaging scripts being used to generate climatologies. -#These scripts must be located in "scripts/averaging": -time_averaging_scripts: - - create_climo_files - -#Name of regridding scripts being used. -#These scripts must be located in "scripts/regridding": -regridding_scripts: - - regrid_and_vert_interp - -#List of analysis scripts being used. -#These scripts must be located in "scripts/analysis": -analysis_scripts: - - lmwg_table - -#List of plotting scripts being used. -#These scripts must be located in "scripts/plotting": -plotting_scripts: - - global_latlon_map - - global_mean_timeseries_lnd - - polar_map - #- regional_map_multicase #To use this please un-comment and fill-out - #the "region_multicase" section below - -#List of CAM variables that will be processesd: -#If CVDP is to be run PSL, TREFHT, TS and PRECT (or PRECC and PRECL) should be listed -#TODO, round this out with more variables for alpha land diags -diag_var_list: - - TSA - - PREC - - ELAI - - GPP -# - NPP -# - FSDS -# - ALTMAX - - ET - - TOTRUNOFF - - DSTFLXT - - MEG_isoprene -# -# MDTF recommended variables -# - FLUT -# - OMEGA500 -# - PRECT -# - PS -# - PSL -# - U200 -# - U850 -# - V200 -# - V850 - -# Options for multi-case regional contour plots (./plotting/regional_map_multicase.py) -# region_multicase: -# region_spec: [slat, nlat, wlon, elon] -# region_time_option: # If calendar, will look for specified years. If zeroanchor will use a nyears starting from year_offset from the beginning of timeseries -# region_start_year: -# region_end_year: -# region_nyear: -# region_year_offset: -# region_month: -# region_season: -# region_variables: - -#END OF FILE diff --git a/config_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml similarity index 91% rename from config_unstructured_plots.yaml rename to config_clm_unstructured_plots.yaml index 194e47618..d35106e2c 100644 --- a/config_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -58,7 +58,7 @@ # Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script # to check for a failure to customize # -user: 'USER-NAME-NOT-SET' +user: wwieder #'USER-NAME-NOT-SET' #This first set of variables specify basic info used by all diagnostic runs: diag_basic_info: @@ -84,7 +84,7 @@ diag_basic_info: obs_data_loc: /glade/campaign/cgd/amp/amwg/ADF_obs #Location where re-gridded and interpolated CAM climatology files are stored: - cam_regrid_loc: /glade/derecho/scratch/${user}/ADF/regrid + cam_regrid_loc: /glade/derecho/scratch/${user}/ADF_unstruct/regrid #Overwrite CAM re-gridded files? #If false, or missing, then regridding will be skipped for regridded variables @@ -92,7 +92,7 @@ diag_basic_info: cam_overwrite_regrid: false #Location where diagnostic plots are stored: - cam_diag_plot_loc: /glade/derecho/scratch/${user}/ADF/plots + cam_diag_plot_loc: /glade/derecho/scratch/${user}/ADF_unstruct/plots #Location of ADF variable plotting defaults YAML file: #If left blank or missing, ADF/lib/adf_variable_defaults.yaml will be used @@ -130,20 +130,20 @@ diag_cam_climo: calc_cam_climo: true #Location of CAM climatologies (to be created and then used by this script) - cam_climo_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/climo + cam_climo_loc: /glade/derecho/scratch/${user}/ADF_unstruct/${diag_cam_climo.cam_case_name}/climo #Overwrite CAM climatology files? #If false, or not prsent, then already existing climatology files will be skipped: cam_overwrite_climo: false #Name of CAM case (or CAM run name): - cam_case_name: b.e30_beta05.BLT1850.ne30_t232_wgx3.123 + cam_case_name: b.e30_alpha06b.B1850C_LTso.ne30_t232_wgx3.143 #Case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '123' + case_nickname: '143' #Location of CAM history (h0) files: cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ @@ -154,12 +154,12 @@ diag_cam_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 25 + start_year: 30 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 35 + end_year: 40 #Do time series files exist? #If True, then diagnostics assumes that model files are already time series. @@ -177,7 +177,7 @@ diag_cam_climo: cam_overwrite_ts: false #Location where time series files are (or will be) stored: - cam_ts_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_climo.cam_case_name}/ts + cam_ts_loc: /glade/derecho/scratch/${user}/ADF_unstruct/${diag_cam_climo.cam_case_name}/ts #This third set of variables provide info for the CAM baseline climatologies. @@ -199,13 +199,13 @@ diag_cam_baseline_climo: cam_overwrite_climo: false #Name of CAM baseline case: - cam_case_name: b.e30_beta05.BLT1850.ne30_t232_wgx3.122 + cam_case_name: b.e30_alpha06b.B1850C_LTso.ne30_t232_wgx3.139 #Baseline case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '122' + case_nickname: '139' #Location of CAM baseline history (h0) files: #Example test files @@ -215,17 +215,17 @@ diag_cam_baseline_climo: mesh_file: /glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc #Location of baseline CAM climatologies: - cam_climo_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_baseline_climo.cam_case_name}/climo + cam_climo_loc: /glade/derecho/scratch/${user}/ADF_unstruct/${diag_cam_baseline_climo.cam_case_name}/climo #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 25 + start_year: 30 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 35 + end_year: 40 #Do time series files need to be generated? #If True, then diagnostics assumes that model files are already time series. @@ -242,7 +242,7 @@ diag_cam_baseline_climo: cam_overwrite_ts: false #Location where time series files are (or will be) stored: - cam_ts_loc: /glade/derecho/scratch/${user}/ADF/${diag_cam_baseline_climo.cam_case_name}/ts + cam_ts_loc: /glade/derecho/scratch/${user}/ADF_unstruct/${diag_cam_baseline_climo.cam_case_name}/ts @@ -281,13 +281,13 @@ plotting_scripts: #List of CAM variables that will be processesd: #If CVDP is to be run PSL, TREFHT, TS and PRECT (or PRECC and PRECL) should be listed diag_var_list: - #- TSA + - TSA - PREC - ELAI - GPP -# - NPP -# - FSDS -# - ALTMAX + - NPP + - FSDS + - ALTMAX - ET - TOTRUNOFF - DSTFLXT diff --git a/lib/adf_diag.py b/lib/adf_diag.py index b9b918271..4fe50d061 100644 --- a/lib/adf_diag.py +++ b/lib/adf_diag.py @@ -844,7 +844,12 @@ def call_ncrcat(cmd): if ('time_bounds' in ts_ds): time = xr.DataArray(ts_ds['time_bounds'].load().mean(dim='nbnd').values, dims=time.dims, attrs=time.attrs) if comp == "lnd": - time = xr.DataArray(ts_ds['time_bounds'].load().mean(dim='hist_interval').values, dims=time.dims, attrs=time.attrs) + # need greater flexibility given changes in clm history files over time + if ('hist_interval' in ts_ds['time_bounds'].dims): + time = xr.DataArray(ts_ds['time_bounds'].load().mean(dim='hist_interval').values, dims=time.dims, attrs=time.attrs) + else: + time = xr.DataArray(ts_ds['time_bounds'].load().mean(dim='nbnd').values, dims=time.dims, attrs=time.attrs) + ts_ds['time'] = time ts_ds.assign_coords(time=time) ts_ds_fixed = xr.decode_cf(ts_ds) diff --git a/scripts/averaging/create_climo_files.py b/scripts/averaging/create_climo_files.py index 841ce04f8..1f68747a8 100644 --- a/scripts/averaging/create_climo_files.py +++ b/scripts/averaging/create_climo_files.py @@ -239,7 +239,10 @@ def process_variable(adf, ts_files, syr, eyr, output_file, comp): elif 'time_bounds' in cam_ts_data: time = cam_ts_data['time'] if comp == "lnd": - dim = 'hist_interval' + if ('hist_interval' in ts_ds['time_bounds'].dims): + dim = 'hist_interval' + else: + dim = 'nbnd' if comp == "atm": dim = 'nbnd' # NOTE: force `load` here b/c if dask & time is cftime, throws a NotImplementedError: From 52355a3dc2c0f81a4db2ed58374629077bf8044c Mon Sep 17 00:00:00 2001 From: wwieder Date: Sat, 5 Apr 2025 07:55:53 -0600 Subject: [PATCH 042/126] handles updates to time bounds on clm history files --- scripts/averaging/create_climo_files.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/averaging/create_climo_files.py b/scripts/averaging/create_climo_files.py index 1f68747a8..8ae8f8d7d 100644 --- a/scripts/averaging/create_climo_files.py +++ b/scripts/averaging/create_climo_files.py @@ -239,7 +239,7 @@ def process_variable(adf, ts_files, syr, eyr, output_file, comp): elif 'time_bounds' in cam_ts_data: time = cam_ts_data['time'] if comp == "lnd": - if ('hist_interval' in ts_ds['time_bounds'].dims): + if ('hist_interval' in cam_ts_data['time_bounds'].dims): dim = 'hist_interval' else: dim = 'nbnd' From c9e188478c885613508273125646a060dc6cbe24 Mon Sep 17 00:00:00 2001 From: wwieder Date: Sat, 5 Apr 2025 08:05:11 -0600 Subject: [PATCH 043/126] clean up docs and speed testing --- LAND-DIAGS_README.md | 51 +++++++++++++++++++++++++++--- config_clm_unstructured_plots.yaml | 14 ++++---- 2 files changed, 54 insertions(+), 11 deletions(-) diff --git a/LAND-DIAGS_README.md b/LAND-DIAGS_README.md index 7f682b223..cae76b4fe 100644 --- a/LAND-DIAGS_README.md +++ b/LAND-DIAGS_README.md @@ -1,3 +1,45 @@ +### Here's a quick start that you can use for Land Diagnostics +#### Download the adf repo +On casper: +1. Navigate to the directory where you want the adf (e.g., `cd ~`) +2. Clone the ADF +`git clone https://github.com/NCAR/ADF.git` +3. Set your personal repository as the upstream repo +``` +cd ADF +git remote add upstream https://github.com//ADF.git +``` +4. Switch to the clm-diags branch +`git switch -c clm-diags origin/clm-diags` + +#### Set up your computing environment +1. Create a conda environment. On NCAR's CISL machines (derecho and casper), these can be loaded by running the following on the command line: +``` +module load conda +conda env create -f env/ldf_v0.0.yaml +conda activate ldf_v0.0 +``` + +**Note** This is somewhat redundant, as it's a clone of cupid-analysis, but land diagnostics need the latest version of uxarray (25.3.0), and this will prevent overwriting your other conda environments. + +Also, along with these python requirements, the `ncrcat` NetCDF Operator (NCO) is also needed. On the CISL machines this can be loaded by simply running: +``` +module load nco/5.2.4 +``` +on the command line. +_Note_, I'm not sure specifying the nco version is critical, but it does seem to help get around an issues where nco errors seemed to prevent additiof area and landfrac onto timeseries files when using the default 5.3.1 version of NCO on casper. + +## Running ADF diagnostics + +Detailed instructions for users and developers are availabe on this repository's [wiki](https://github.com/NCAR/ADF/wiki). + +`./run_adf_diag config_clm_unstructured_plots.yaml` + +This should generate a collection of time series files, climatology (climo) files, re-gridded climo files, and example ADF diagnostic figures, all in their respective directories. + +When additional memory is needed sometimes need to run interactive session on casper: +`execcasper -A P93300041 -l select=1:ncpus=4:mem=64GB` + ## TEST for Land Diags: For this branch there are (3) ways to run the ADF: @@ -10,7 +52,7 @@ For (1), the config yaml file will be essentially the same, but with a couple of - in `diag_basic_info` set the `unstructured_plotting` argument to `true` - in each of the test and baseline section supply a mesh file in the `mesh_file` argument - Example yaml file: `config_unstructured_plots.yaml` + Example yaml file: `config_clm_unstructured_plots.yaml` For (2), the config yaml file will need some additional arguments: - in each of the test and baseline sections, supply the following arguments: @@ -21,14 +63,15 @@ For (2), the config yaml file will need some additional arguments: Regridding method: - `regrid_method: 'conservative'` - + `regrid_method: 'coservative'` + (Yes, spelled incorectly for a bug in xESMF) + Lat/lon file: `latlon_file: /glade/derecho/scratch/wwieder/ctsm5.3.018_SP_f09_t232_mask/run/ctsm5.3.018_SP_f09_t232_mask.clm2.h0.0001-01.nc` NOTE: The regridding method set in `regrid_method` MUST match the method in the weights file - Example yaml file: `config_ldf_native_grid_to_latlon.yaml` + Example yaml file: `config_clm_native_grid_to_latlon.yaml` diff --git a/config_clm_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml index d35106e2c..640c4dab2 100644 --- a/config_clm_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -278,18 +278,18 @@ plotting_scripts: - global_mean_timeseries_lnd - polar_map -#List of CAM variables that will be processesd: -#If CVDP is to be run PSL, TREFHT, TS and PRECT (or PRECC and PRECL) should be listed +#List of variables that will be processesd: +#Shorter list here, for efficiency of testing diag_var_list: - - TSA + #- TSA - PREC - ELAI - GPP - - NPP - - FSDS - - ALTMAX + #- NPP + #- FSDS + #- ALTMAX - ET - - TOTRUNOFF + #- TOTRUNOFF - DSTFLXT - MEG_isoprene From 328f7bd0d62e3e5441400bca412d25ea012b9183 Mon Sep 17 00:00:00 2001 From: wwieder Date: Sat, 5 Apr 2025 09:29:26 -0600 Subject: [PATCH 044/126] get global timeseries working --- scripts/plotting/global_mean_timeseries_lnd.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/plotting/global_mean_timeseries_lnd.py b/scripts/plotting/global_mean_timeseries_lnd.py index d19f86fde..7a1436df2 100644 --- a/scripts/plotting/global_mean_timeseries_lnd.py +++ b/scripts/plotting/global_mean_timeseries_lnd.py @@ -111,8 +111,8 @@ def global_mean_timeseries_lnd(adfobj): ref_ts_da = pf.annual_mean(ref_ts_da_ga, whole_years=True, time_name="time") c_ts_da = pf.annual_mean(c_ts_da_ga, whole_years=True, time_name="time") - # check if this is a "2-d" varaible: - has_lev_ref = pf.zm_validate_dims(ref_ts_da) + # check if variable has a lev dimension + has_lev_ref = pf.zm_validate_dims(ref_ts_da)[1] if has_lev_ref: print( f"Variable named {field} has a lev dimension, which does not work with this script." From 558fc5c90936038833a2bac0c5f71f08ea449776 Mon Sep 17 00:00:00 2001 From: wwieder Date: Sun, 6 Apr 2025 07:44:26 -0600 Subject: [PATCH 045/126] unsucessfully tried to get nco working --- lib/adf_diag.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/adf_diag.py b/lib/adf_diag.py index 4fe50d061..c9580693d 100644 --- a/lib/adf_diag.py +++ b/lib/adf_diag.py @@ -767,7 +767,7 @@ def call_ncrcat(cmd): # Step 3a: Optional, add additional variables to clm2.h0 files if "h0" in hist_str: cmd_add_clm_h0_fields = [ - "ncks", "-A", "-v", "area,landfrac,landmask", + "ncks", "-A", "-C", "-v", "area,landfrac,landmask", hist_files[0], ts_outfil_str ] From b0559f9b8746e3e84c14d5887829c9ddf003256b Mon Sep 17 00:00:00 2001 From: wwieder Date: Sun, 6 Apr 2025 10:37:18 -0600 Subject: [PATCH 046/126] removing user_name from config files --- config_clm_native_grid_to_latlon.yaml | 10 +++++----- config_clm_unstructured_plots.yaml | 2 +- lmwg_wish_list.md | 27 --------------------------- 3 files changed, 6 insertions(+), 33 deletions(-) delete mode 100644 lmwg_wish_list.md diff --git a/config_clm_native_grid_to_latlon.yaml b/config_clm_native_grid_to_latlon.yaml index ddcf7e16f..05840bb68 100644 --- a/config_clm_native_grid_to_latlon.yaml +++ b/config_clm_native_grid_to_latlon.yaml @@ -58,7 +58,7 @@ # Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script # to check for a failure to customize # -user: wwieder #'USER-NAME-NOT-SET' +user: 'USER-NAME-NOT-SET' #This first set of variables specify basic info used by all diagnostic runs: diag_basic_info: @@ -293,13 +293,13 @@ plotting_scripts: #List of CAM variables that will be processesd: #If CVDP is to be run PSL, TREFHT, TS and PRECT (or PRECC and PRECL) should be listed diag_var_list: - - TSA + #- TSA - PREC - ELAI - GPP - - NPP - - FSDS - - ALTMAX + #- NPP + #- FSDS + #- ALTMAX - ET - TOTRUNOFF - DSTFLXT diff --git a/config_clm_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml index 640c4dab2..2643bff6c 100644 --- a/config_clm_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -58,7 +58,7 @@ # Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script # to check for a failure to customize # -user: wwieder #'USER-NAME-NOT-SET' +user: 'USER-NAME-NOT-SET' #This first set of variables specify basic info used by all diagnostic runs: diag_basic_info: diff --git a/lmwg_wish_list.md b/lmwg_wish_list.md deleted file mode 100644 index ba5ad25b4..000000000 --- a/lmwg_wish_list.md +++ /dev/null @@ -1,27 +0,0 @@ -# List of ideas for LDF Codefest: -### Simple tasks work --[ ] Expand list of default variables in `config_clm_baseline_example.yml` --[ ] Improve plotting aesthetics: expand list of variables in `adf/lib/ldf_variable_defaults.yml` --[ ] Identify list of regions and bounding boxes where we want to make timeseries or climo plots - -### Integration --[x] Integrate `regrid_se_to_fv` regridding script into ADF workflow. - - check how this is working in revised --[x] Integrate `plot_unstructured_map_and_save` function into `/scripts/plotting/global_unstructured_latlon_map` --[x] Develop coherent way to handled structured vs. unstructured input data (maybe adapt all to uxarray)? - -### Development --[ ] Separate time bounds for time series and climo generation. --[ ] *Top need* Write python function to make regional timeseries or climo plots --[ ] Check application of adf timeseries plots for land, - - this was working on wwieder/clm-test branch --[ ] Handle h1 files for PFT specific results - - Need to convert notebook for unstructured data in to python fuction that uses upstream ADF workflow & adds plots to website - - also need unstructured example --[ ] Integrate observations! - - Populate datasets in central location (e.g. `/glade/campaign/cgd/amp/amwg/ADF_obs`), maybe this lives in a CUPiD observations home? - - Regrid to standard resolution(s), start with f09_t232 - - -# - From 619c82f4961b6fe3163d41ec1fe6129e8fcf06a9 Mon Sep 17 00:00:00 2001 From: wwieder Date: Mon, 7 Apr 2025 07:43:59 -0600 Subject: [PATCH 047/126] add error note --- LAND-DIAGS_README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/LAND-DIAGS_README.md b/LAND-DIAGS_README.md index cae76b4fe..98b593038 100644 --- a/LAND-DIAGS_README.md +++ b/LAND-DIAGS_README.md @@ -37,6 +37,8 @@ Detailed instructions for users and developers are availabe on this repository's This should generate a collection of time series files, climatology (climo) files, re-gridded climo files, and example ADF diagnostic figures, all in their respective directories. +If you get NCO failures at the generate timeseries stage that end up causing LDF to fail, see issue [#365](https://github.com/NCAR/ADF/issues/365) + When additional memory is needed sometimes need to run interactive session on casper: `execcasper -A P93300041 -l select=1:ncpus=4:mem=64GB` From 60cb077a83ee6248bc7c75a041a4673cf6ddf303 Mon Sep 17 00:00:00 2001 From: wwieder Date: Mon, 7 Apr 2025 07:44:29 -0600 Subject: [PATCH 048/126] update ux version --- env/ldf_v0.0.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/env/ldf_v0.0.yaml b/env/ldf_v0.0.yaml index c2de80bc8..26040ee7f 100644 --- a/env/ldf_v0.0.yaml +++ b/env/ldf_v0.0.yaml @@ -321,7 +321,7 @@ dependencies: - unicodedata2=15.1.0=py311h9ecbd09_1 - uriparser=0.9.8=hac33072_0 - urllib3=2.2.3=pyhd8ed1ab_0 - - uxarray=2024.11.0=pyhd8ed1ab_0 + - uxarray=2025.3.0 - wayland=1.23.1=h3e06ad9_0 - wcwidth=0.2.13=pyhd8ed1ab_0 - webencodings=0.5.1=pyhd8ed1ab_2 From cd7ba747cdfa9d201315f38dafe1df9a90addde8 Mon Sep 17 00:00:00 2001 From: wwieder Date: Mon, 7 Apr 2025 09:48:24 -0600 Subject: [PATCH 049/126] get pylint score > 9.5 --- lib/adf_diag.py | 85 +++++++++++++++++++++++++++++-------------------- 1 file changed, 50 insertions(+), 35 deletions(-) diff --git a/lib/adf_diag.py b/lib/adf_diag.py index c9580693d..6bf889b92 100644 --- a/lib/adf_diag.py +++ b/lib/adf_diag.py @@ -79,7 +79,7 @@ # Check if "esmpy" is present in python path: try: - import esmpy as esmpy + import esmpy except ImportError: print("xesmf module does not exist in python path.") print("Please install module, e.g. 'pip install esmpy'.") @@ -87,7 +87,7 @@ # Check if "xesmf" is present in python path: try: - import xesmf as xesmf + import xesmf except ImportError: print("xesmf module does not exist in python path.") print("Please install module, e.g. 'pip install xesmf'.") @@ -416,7 +416,7 @@ def call_ncrcat(cmd): for case_idx, case_name in enumerate(case_names): # Check if particular case should be processed: if cam_ts_done[case_idx]: - emsg = "\tNOTE: Configuration file indicates time series files have been pre-computed" + emsg = "\tNOTE: Config. file indicates time series files have been pre-computed" emsg += f" for case '{case_name}'. Will rely on those files directly." print(emsg) continue @@ -677,8 +677,9 @@ def call_ncrcat(cmd): # Lastly, raise error if the variable is not a derived quanitity # but is also not in the history file(s) else: - msg = f"\t WARNING: {var} is not in the history file for case '{case_name}' " - msg += "nor can it be derived. Script will continue to next variable." + msg = f"\t WARNING: {var} is not in the history file for case " + msg += "'{case_name}' nor can it be derived. Script will continue " + msg += " to the text variable." print(msg) logmsg = f"create time series for {case_name}:" logmsg += f"\n {var} is not in the file {hist_files[0]} " @@ -688,7 +689,8 @@ def call_ncrcat(cmd): # End if (var in var_diag_list) # Check if variable has a "lev" dimension according to first file: - has_lev = bool("lev" in hist_file_ds[var].dims or "ilev" in hist_file_ds[var].dims) + has_lev = bool("lev" in hist_file_ds[var].dims or \ + "ilev" in hist_file_ds[var].dims) # Check if files already exist in time series directory: ts_file_list = glob.glob(ts_outfil_str) @@ -748,9 +750,12 @@ def call_ncrcat(cmd): + ["-o", ts_outfil_str] ) - # Example ncatted command (you can modify it with the specific attribute changes you need) - #cmd_ncatted = ["ncatted", "-O", "-a", f"adf_user,global,a,c,{self.user}", ts_outfil_str] - # Step 1: Convert Path objects to strings and concatenate the list of historical files into a single string + # Example ncatted command + # (you can modify it with the specific attribute changes you need) + # cmd_ncatted = ["ncatted", "-O", "-a", "f" adf_user,global,a,c,{self.user}", + # ts_outfil_str] + # Step 1: Convert Path objects to strings and concatenate the list of + # historical files into a single string hist_files_str = ', '.join(str(f.name) for f in hist_files) hist_locs_str = ', '.join(str(loc) for loc in cam_hist_locs) @@ -774,10 +779,11 @@ def call_ncrcat(cmd): # add time invariant information to clm2.h0 fields list_of_hist_commands.append(cmd_add_clm_h0_fields) - # Step 3b: Optional, add additional variables to clm2.h1 files + # Step 3b: Optional, add additional variables to clm2.h1 files if "h1" in hist_str: cmd_add_clm_h1_fields = [ - "ncrcat", "-A", "-v", "pfts1d_ixy,pfts1d_jxy,pfts1d_itype_veg,lat,lon", + "ncrcat", "-A", "-v", + "pfts1d_ixy,pfts1d_jxy,pfts1d_itype_veg,lat,lon", hist_files, ts_outfil_str ] @@ -790,8 +796,8 @@ def call_ncrcat(cmd): "-a", "history,global,d,,", ts_outfil_str ] - - + + # Add to command list for use in multi-processing pool: # ----------------------------------------------------- # generate time series files @@ -815,22 +821,24 @@ def call_ncrcat(cmd): with mp.Pool(processes=self.num_procs) as mpool: _ = mpool.map(call_ncrcat, list_of_ncattend_commands) - # Run ncatted command to remove history attribute after the global attributes are set + # Run ncatted command to remove history attribute after + # the global attributes are set with mp.Pool(processes=self.num_procs) as mpool: _ = mpool.map(call_ncrcat, list_of_hist_commands) # Loop over the created time series files again and fix the time if necessary - #NOTE: There is no solution to do this with NCO operators, but there is with CDO operators. - # We can switch to using CDO, but it would require the user to have/load CDO as well. + #NOTE: There is no solution to do this with NCO operators, + # but there is with CDO operators. We can switch to using CDO, + # but it would require the user to have/load CDO as well. fils = glob.glob(f"{ts_dir}/*{time_string}.nc") for fil in fils: ts_ds = xr.open_dataset(fil, decode_times=False) if ('time_bnds' in ts_ds) or ('time_bounds' in ts_ds): if comp == "atm": - if ('time_bnds' in ts_ds): + if 'time_bnds' in ts_ds: ts_ds.time_bnds.attrs['units'] = ts_ds.time.attrs['units'] ts_ds.time_bnds.attrs['calendar'] = ts_ds.time.attrs['calendar'] - if ('time_bounds' in ts_ds): + if 'time_bounds' in ts_ds: ts_ds.time_bounds.attrs['units'] = ts_ds.time.attrs['units'] ts_ds.time_bounds.attrs['calendar'] = ts_ds.time.attrs['calendar'] if comp == "lnd": @@ -839,24 +847,28 @@ def call_ncrcat(cmd): time = ts_ds['time'] if comp == "atm": - if ('time_bnds' in ts_ds): - time = xr.DataArray(ts_ds['time_bnds'].load().mean(dim='nbnd').values, dims=time.dims, attrs=time.attrs) - if ('time_bounds' in ts_ds): - time = xr.DataArray(ts_ds['time_bounds'].load().mean(dim='nbnd').values, dims=time.dims, attrs=time.attrs) + if 'time_bnds' in ts_ds: + time = xr.DataArray(ts_ds['time_bnds'].load().mean(dim='nbnd').values, + dims=time.dims, attrs=time.attrs) + if 'time_bounds' in ts_ds: + time = xr.DataArray(ts_ds['time_bounds'].load().mean(dim='nbnd').values, + dims=time.dims, attrs=time.attrs) if comp == "lnd": # need greater flexibility given changes in clm history files over time - if ('hist_interval' in ts_ds['time_bounds'].dims): - time = xr.DataArray(ts_ds['time_bounds'].load().mean(dim='hist_interval').values, dims=time.dims, attrs=time.attrs) + if 'hist_interval' in ts_ds['time_bounds'].dims: + time = xr.DataArray(ts_ds['time_bounds'].load().mean(dim='hist_interval').values, + dims=time.dims, attrs=time.attrs) else: - time = xr.DataArray(ts_ds['time_bounds'].load().mean(dim='nbnd').values, dims=time.dims, attrs=time.attrs) - + time = xr.DataArray(ts_ds['time_bounds'].load().mean(dim='nbnd').values, + dims=time.dims, attrs=time.attrs) + ts_ds['time'] = time ts_ds.assign_coords(time=time) ts_ds_fixed = xr.decode_cf(ts_ds) # Add attribute note of time change attrs_dict = { - "adf_timeseries_info": "Time series files have been computed using 'ncrcat'", + "adf_timeseries_info": "Time series files have been computed using ncrcat'", "adf_note": "The time values have been modified to middle of month" } ts_ds_fixed = ts_ds_fixed.assign_attrs(attrs_dict) @@ -895,11 +907,12 @@ def call_ncrcat(cmd): latlon_file = latlon_file[case_idx] kwargs = {"ts_dir":ts_dir, "latlon_file":latlon_file, "wgts_file":wgts_file, - "method":method, "diag_var_list":self.diag_var_list, "case_name":case_name, - "hist_str":hist_str, "time_string":time_string, "comp":comp,"time_file":time_file + "method":method, "diag_var_list":self.diag_var_list, + "case_name":case_name, "hist_str":hist_str, + "time_string":time_string, "comp":comp,"time_file":time_file } adf_utils.grid_timeseries(**kwargs) - + # End for hist_str # End cases loop @@ -1313,7 +1326,8 @@ def derive_variables(self, res=None, hist_str=None, vars_to_derive=None, ts_dir= # Check if all the necessary constituent files were found if len(constit_files) != len(constit_list): - ermsg = f"\t WARNING: Not all constituent files present; {var} cannot be calculated." + ermsg = f"\t WARNING: Not all constituent files present;" + ermsg += f" {var} cannot be calculated." ermsg += f" Please remove {var} from 'diag_var_list' or find the " ermsg += "relevant CAM files.\n" print(ermsg) @@ -1431,8 +1445,9 @@ def setup_run_mdtf(self): # # Create a dict with all the case info needed for MDTF case_list - # Note that model and convention are hard-coded to CESM because that's all we expect here - # This could be changed by inputing them into ADF with other MDTF-specific variables + # Note that model and convention are hard-coded to CESM + # because that's all we expect here. This could be changed + # by inputing them into ADF with other MDTF-specific variables # case_list_keys = ["CASENAME", "FIRSTYR", "LASTYR", "model", "convention"] @@ -1487,8 +1502,8 @@ def setup_run_mdtf(self): # # Submit the MDTF script in background mode, send output to mdtf.out file - # - mdtf_log = "mdtf.out" # maybe set this to cam_diag_plot_loc: /glade/scratch/${user}/ADF/plots + # maybe set this to cam_diag_plot_loc: /glade/scratch/${user}/ADF/plots + mdtf_log = "mdtf.out" mdtf_exe = mdtf_codebase + os.sep + "mdtf -f " + mdtf_input_settings_filename if copy_files_only: print("\t ...Copy files only. NOT Running MDTF") From 5bb46d7f59798e8547031221c572aa0514adacd8 Mon Sep 17 00:00:00 2001 From: will wieder Date: Mon, 7 Apr 2025 10:02:09 -0600 Subject: [PATCH 050/126] Update LAND-DIAGS_README.md Quick fix on readme --- LAND-DIAGS_README.md | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/LAND-DIAGS_README.md b/LAND-DIAGS_README.md index 98b593038..1bafaaf39 100644 --- a/LAND-DIAGS_README.md +++ b/LAND-DIAGS_README.md @@ -13,7 +13,7 @@ git remote add upstream https://github.com//ADF.git `git switch -c clm-diags origin/clm-diags` #### Set up your computing environment -1. Create a conda environment. On NCAR's CISL machines (derecho and casper), these can be loaded by running the following on the command line: +5. Create a conda environment. On NCAR's CISL machines (derecho and casper), these can be loaded by running the following on the command line: ``` module load conda conda env create -f env/ldf_v0.0.yaml @@ -22,22 +22,23 @@ conda activate ldf_v0.0 **Note** This is somewhat redundant, as it's a clone of cupid-analysis, but land diagnostics need the latest version of uxarray (25.3.0), and this will prevent overwriting your other conda environments. -Also, along with these python requirements, the `ncrcat` NetCDF Operator (NCO) is also needed. On the CISL machines this can be loaded by simply running: +Also, along with these python requirements, the `ncrcat` NetCDF Operator (NCO) is also needed. On the CISL machines this can be loaded by simply running the following on the command line: + ``` -module load nco/5.2.4 +module load nco ``` -on the command line. -_Note_, I'm not sure specifying the nco version is critical, but it does seem to help get around an issues where nco errors seemed to prevent additiof area and landfrac onto timeseries files when using the default 5.3.1 version of NCO on casper. ## Running ADF diagnostics -Detailed instructions for users and developers are availabe on this repository's [wiki](https://github.com/NCAR/ADF/wiki). +Detailed instructions for users and developers are availabe on this repository's [wiki](https://github.com/NCAR/ADF/wiki). + +You'll have to add your username to the appropriate config file, but after that, for a quick try of land diagnostics `./run_adf_diag config_clm_unstructured_plots.yaml` This should generate a collection of time series files, climatology (climo) files, re-gridded climo files, and example ADF diagnostic figures, all in their respective directories. -If you get NCO failures at the generate timeseries stage that end up causing LDF to fail, see issue [#365](https://github.com/NCAR/ADF/issues/365) +**NOTE:** If you get NCO failures at the generate timeseries stage that end up causing LDF to fail, see issue [#365](https://github.com/NCAR/ADF/issues/365) When additional memory is needed sometimes need to run interactive session on casper: `execcasper -A P93300041 -l select=1:ncpus=4:mem=64GB` @@ -77,3 +78,4 @@ For (2), the config yaml file will need some additional arguments: Example yaml file: `config_clm_native_grid_to_latlon.yaml` +: From 06f705ac15b7fc98be661ac4d42030a8a711071c Mon Sep 17 00:00:00 2001 From: will wieder Date: Mon, 7 Apr 2025 11:10:36 -0600 Subject: [PATCH 051/126] Update config_clm_native_grid_to_latlon.yaml Avoid crashes related to #365, but runs slowly --- config_clm_native_grid_to_latlon.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config_clm_native_grid_to_latlon.yaml b/config_clm_native_grid_to_latlon.yaml index 05840bb68..7bfeac4de 100644 --- a/config_clm_native_grid_to_latlon.yaml +++ b/config_clm_native_grid_to_latlon.yaml @@ -110,7 +110,7 @@ diag_basic_info: #you set it to "*" then it will default #to all of the processors available on a #single node/machine: - num_procs: 8 + num_procs: 1 #If set to true, then redo all plots even if they already exist. #If set to false, then if a plot is found it will be skipped: From bf84611be9394df9a21025edea9d362c8240d1e7 Mon Sep 17 00:00:00 2001 From: will wieder Date: Mon, 7 Apr 2025 11:11:37 -0600 Subject: [PATCH 052/126] Update config_clm_unstructured_plots.yaml Avoid crashes related to #365, but runs slowly --- config_clm_unstructured_plots.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config_clm_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml index 2643bff6c..2786071ec 100644 --- a/config_clm_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -110,7 +110,7 @@ diag_basic_info: #you set it to "*" then it will default #to all of the processors available on a #single node/machine: - num_procs: 8 + num_procs: 1 #If set to true, then redo all plots even if they already exist. #If set to false, then if a plot is found it will be skipped: From 7c6566367986afb87ee1b13812f9f72cab9ffa0f Mon Sep 17 00:00:00 2001 From: Aya Lahlou Date: Thu, 10 Apr 2025 14:59:41 -0600 Subject: [PATCH 053/126] fixed log_p bug in plotting_functions --- lib/plotting_functions.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/plotting_functions.py b/lib/plotting_functions.py index c980f9ab5..64ea1ecff 100644 --- a/lib/plotting_functions.py +++ b/lib/plotting_functions.py @@ -2326,7 +2326,7 @@ def prep_contour_plot(adata, bdata, diffdata, pctdata, **kwargs): def plot_zonal_mean_and_save(wks, case_nickname, base_nickname, case_climo_yrs, baseline_climo_yrs, - adata, bdata, has_lev, log_p, obs=False, **kwargs): + adata, bdata, has_lev, log_p=False, obs=False, **kwargs): """This is the default zonal mean plot @@ -2512,7 +2512,7 @@ def plot_zonal_mean_and_save(wks, case_nickname, base_nickname, def plot_meridional_mean_and_save(wks, case_nickname, base_nickname, case_climo_yrs, baseline_climo_yrs, - adata, bdata, has_lev, log_p, latbounds=None, obs=False, **kwargs): + adata, bdata, has_lev, log_p=False, latbounds=None, obs=False, **kwargs): """Default meridional mean plot From 727a63b78c2f5756bb4b53a3d34436ce7bc8589e Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 10 Apr 2025 15:52:31 -0600 Subject: [PATCH 054/126] example for I-case, #370 --- config_clm_structured_plots.yaml | 296 +++++++++++++++++++++++++++++++ 1 file changed, 296 insertions(+) create mode 100644 config_clm_structured_plots.yaml diff --git a/config_clm_structured_plots.yaml b/config_clm_structured_plots.yaml new file mode 100644 index 000000000..9601c7e42 --- /dev/null +++ b/config_clm_structured_plots.yaml @@ -0,0 +1,296 @@ +#============================== +#config_cam_baseline_example.yaml + +#This is the main CAM diagnostics config file +#for doing comparisons of a CAM run against +#another CAM run, or a CAM baseline simulation. + +#Currently, if one is on NCAR's Casper or +#Cheyenne machine, then only the diagnostic output +#paths are needed, at least to perform a quick test +#run (these are indicated with "MUST EDIT" comments). +#Running these diagnostics on a different machine, +#or with a different, non-example simulation, will +#require additional modifications. +# +#Config file Keywords: +#-------------------- +# +#1. Using ${xxx} will substitute that text with the +# variable referenced by xxx. For example: +# +# cam_case_name: cool_run +# cam_climo_loc: /some/where/${cam_case_name} +# +# will set "cam_climo_loc" in the diagnostics package to: +# /some/where/cool_run +# +# Please note that currently this will only work if the +# variable only exists in one location in the file. +# +#2. Using ${.xxx} will do the same as +# keyword 1 above, but specifies which sub-section the +# variable is coming from, which is necessary for variables +# that are repeated in different subsections. For example: +# +# diag_basic_info: +# cam_climo_loc: /some/where/${diag_cam_climo.start_year} +# +# diag_cam_climo: +# start_year: 1850 +# +# will set "cam_climo_loc" in the diagnostics package to: +# /some/where/1850 +# +#Finally, please note that for both 1 and 2 the keywords must be lowercase. +#This is because future developments will hopefully use other keywords +#that are uppercase. Also please avoid using periods (".") in variable +#names, as this will likely cause issues with the current file parsing +#system. +#-------------------- +# +##============================== +# +# This file doesn't (yet) read environment variables, so the user must +# set this themselves. It is also a good idea to search the doc for 'user' +# to see what default paths are being set for output/working files. +# +# Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script +# to check for a failure to customize +# +user: 'USER-NAME-NOT-SET' + +#This first set of variables specify basic info used by all diagnostic runs: +diag_basic_info: + + #Does the user want plotting of unstructured (native) grid? + #If "false" or missing, then the ADF expects ALL cases to be on lat/lon grids: + unstructured_plotting: false + + #Is this a model vs observations comparison? + #If "false" or missing, then a model-model comparison is assumed: + compare_obs: false + + #Generate HTML website (assumed false if missing): + #Note: The website files themselves will be located in the path + #specified by "cam_diag_plot_loc", under the "/website" subdirectory, + #where "" is the subdirectory created for this particular diagnostics run + #(usually "case_vs_obs_XXX" or "case_vs_baseline_XXX"). + create_html: true + + #Location of observational datasets: + #Note: this only matters if "compare_obs" is true and the path + #isn't specified in the variable defaults file. + obs_data_loc: /glade/campaign/cgd/amp/amwg/ADF_obs + + #Location where re-gridded and interpolated CAM climatology files are stored: + cam_regrid_loc: /glade/derecho/scratch/${user}/ADF_unstruct/regrid + + #Overwrite CAM re-gridded files? + #If false, or missing, then regridding will be skipped for regridded variables + #that already exist in "cam_regrid_loc": + cam_overwrite_regrid: false + + #Location where diagnostic plots are stored: + cam_diag_plot_loc: /glade/derecho/scratch/${user}/ADF_unstruct/plots + + #Location of ADF variable plotting defaults YAML file: + #If left blank or missing, ADF/lib/adf_variable_defaults.yaml will be used + #Uncomment and change path for custom variable defaults file + defaults_file: lib/ldf_variable_defaults.yaml + + #Longitude line on which to center all lat/lon maps. + #If this config option is missing then the central + #longitude will default to 180 degrees E. + central_longitude: 0 + + #Number of processors on which to run the ADF. + #If this config variable isn't present then + #the ADF defaults to one processor. Also, if + #you set it to "*" then it will default + #to all of the processors available on a + #single node/machine: + num_procs: 1 + + #If set to true, then redo all plots even if they already exist. + #If set to false, then if a plot is found it will be skipped: + redo_plot: true + +#This second set of variables provides info for the CAM simulation(s) being diagnosed: +diag_cam_climo: + + # History file list of strings to match + # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] + # Only affects timeseries as everything else uses the created timeseries + # Default: + hist_str: clm2.h0 + + #Calculate climatologies? + #If false, the climatology files will not be created: + calc_cam_climo: true + + #Location of CAM climatologies (to be created and then used by this script) + cam_climo_loc: /glade/derecho/scratch/${user}/ADF_unstruct/${diag_cam_climo.cam_case_name}/climo + + #Overwrite CAM climatology files? + #If false, or not prsent, then already existing climatology files will be skipped: + cam_overwrite_climo: false + + #Name of CAM case (or CAM run name): + cam_case_name: ctsm53026_BNF_hist + + #Case nickname + #NOTE: if nickname starts with '0' - nickname must be in quotes! + # ie '026a' as opposed to 026a + #If missing or left blank, will default to cam_case_name + case_nickname: '5.3.026_BNF' + + #Location of CAM history (h0) files: + cam_hist_loc: /glade/derecho/scratch/slevis/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ + + # If unstructured_plotting, a mesh file is required! + mesh_file: /glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc + + #model year when time series files should start: + #Note: Leaving this entry blank will make time series + # start at earliest available year. + start_year: 2000 + + #model year when time series files should end: + #Note: Leaving this entry blank will make time series + # end at latest available year. + end_year: 2023 + + #Do time series files exist? + #If True, then diagnostics assumes that model files are already time series. + #If False, or if simply not present, then diagnostics will attempt to create + #time series files from history (time-slice) files: + cam_ts_done: false + + #Save interim time series files? + #WARNING: This can take up a significant amount of space, + # but will save processing time the next time + cam_ts_save: false + + #Overwrite time series files, if found? + #If set to false, then time series creation will be skipped if files are found: + cam_overwrite_ts: false + + #Location where time series files are (or will be) stored: + cam_ts_loc: /glade/derecho/scratch/${user}/ADF_unstruct/${diag_cam_climo.cam_case_name}/ts + + +#This third set of variables provide info for the CAM baseline climatologies. +#This only matters if "compare_obs" is false: +diag_cam_baseline_climo: + + # History file list of strings to match + # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] + # Only affects timeseries as everything else uses the created timeseries + # Default: + hist_str: clm2.h0 + + #Calculate cam baseline climatologies? + #If false, the climatology files will not be created: + calc_cam_climo: true + + #Overwrite CAM climatology files? + #If false, or not present, then already existing climatology files will be skipped: + cam_overwrite_climo: false + + #Name of CAM baseline case: + cam_case_name: ctsm53019_f09_BNF_hist + + #Baseline case nickname + #NOTE: if nickname starts with '0' - nickname must be in quotes! + # ie '026a' as opposed to 026a + #If missing or left blank, will default to cam_case_name + case_nickname: '5.3.019_BNF' + + #Location of CAM baseline history (h0) files: + #Example test files + cam_hist_loc: /glade/derecho/scratch/slevis/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist/ + + # If unstructured_plotting, a mesh file is required! + mesh_file: /glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc + + #Location of baseline CAM climatologies: + cam_climo_loc: /glade/derecho/scratch/${user}/ADF_unstruct/${diag_cam_baseline_climo.cam_case_name}/climo + + #model year when time series files should start: + #Note: Leaving this entry blank will make time series + # start at earliest available year. + start_year: 2000 + + #model year when time series files should end: + #Note: Leaving this entry blank will make time series + # end at latest available year. + end_year: 2023 + + #Do time series files need to be generated? + #If True, then diagnostics assumes that model files are already time series. + #If False, or if simply not present, then diagnostics will attempt to create + #time series files from history (time-slice) files: + cam_ts_done: false + + #Save interim time series files for baseline run? + #WARNING: This can take up a significant amount of space: + cam_ts_save: true + + #Overwrite baseline time series files, if found? + #If set to false, then time series creation will be skipped if files are found: + cam_overwrite_ts: false + + #Location where time series files are (or will be) stored: + cam_ts_loc: /glade/derecho/scratch/${user}/ADF_unstruct/${diag_cam_baseline_climo.cam_case_name}/ts + + + +#+++++++++++++++++++++++++++++++++++++++++++++++++++ +#These variables below only matter if you are using +#a non-standard method, or are adding your own +#diagnostic scripts. +#+++++++++++++++++++++++++++++++++++++++++++++++++++ + +#Note: If you want to pass arguments to a particular script, you can +#do it like so (using the "averaging_example" script in this case): +# - {create_climo_files: {kwargs: {clobber: true}}} + +#Name of time-averaging scripts being used to generate climatologies. +#These scripts must be located in "scripts/averaging": +time_averaging_scripts: + - create_climo_files + +#Name of regridding scripts being used. +#These scripts must be located in "scripts/regridding": +regridding_scripts: + - regrid_and_vert_interp + +#List of analysis scripts being used. +#These scripts must be located in "scripts/analysis": +analysis_scripts: + - lmwg_table + +#List of plotting scripts being used. +#These scripts must be located in "scripts/plotting": +plotting_scripts: + - global_latlon_map + - global_mean_timeseries_lnd + - polar_map + +#List of variables that will be processesd: +#Shorter list here, for efficiency of testing +diag_var_list: + #- TSA + - PREC + - ELAI + - GPP + #- NPP + #- FSDS + #- ALTMAX + - ET + #- TOTRUNOFF + - DSTFLXT + - MEG_isoprene + +#END OF FILE From 0d21760507cb82eb09f05e89e6c15e30816062cb Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 10 Apr 2025 16:13:45 -0600 Subject: [PATCH 055/126] config for B vs I case --- config_clm_BvsI.yml | 298 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 298 insertions(+) create mode 100644 config_clm_BvsI.yml diff --git a/config_clm_BvsI.yml b/config_clm_BvsI.yml new file mode 100644 index 000000000..1de2603f0 --- /dev/null +++ b/config_clm_BvsI.yml @@ -0,0 +1,298 @@ +#============================== +#config_cam_baseline_example.yaml + +#This is the main CAM diagnostics config file +#for doing comparisons of a CAM run against +#another CAM run, or a CAM baseline simulation. + +#Currently, if one is on NCAR's Casper or +#Cheyenne machine, then only the diagnostic output +#paths are needed, at least to perform a quick test +#run (these are indicated with "MUST EDIT" comments). +#Running these diagnostics on a different machine, +#or with a different, non-example simulation, will +#require additional modifications. +# +#Config file Keywords: +#-------------------- +# +#1. Using ${xxx} will substitute that text with the +# variable referenced by xxx. For example: +# +# cam_case_name: cool_run +# cam_climo_loc: /some/where/${cam_case_name} +# +# will set "cam_climo_loc" in the diagnostics package to: +# /some/where/cool_run +# +# Please note that currently this will only work if the +# variable only exists in one location in the file. +# +#2. Using ${.xxx} will do the same as +# keyword 1 above, but specifies which sub-section the +# variable is coming from, which is necessary for variables +# that are repeated in different subsections. For example: +# +# diag_basic_info: +# cam_climo_loc: /some/where/${diag_cam_climo.start_year} +# +# diag_cam_climo: +# start_year: 1850 +# +# will set "cam_climo_loc" in the diagnostics package to: +# /some/where/1850 +# +#Finally, please note that for both 1 and 2 the keywords must be lowercase. +#This is because future developments will hopefully use other keywords +#that are uppercase. Also please avoid using periods (".") in variable +#names, as this will likely cause issues with the current file parsing +#system. +#-------------------- +# +##============================== +# +# This file doesn't (yet) read environment variables, so the user must +# set this themselves. It is also a good idea to search the doc for 'user' +# to see what default paths are being set for output/working files. +# +# Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script +# to check for a failure to customize +# +user: 'wwieder' #'USER-NAME-NOT-SET' + +#This first set of variables specify basic info used by all diagnostic runs: +diag_basic_info: + + #Does the user want plotting of unstructured (native) grid? + #If "false" or missing, then the ADF expects ALL cases to be on lat/lon grids: + unstructured_plotting: false + + #Is this a model vs observations comparison? + #If "false" or missing, then a model-model comparison is assumed: + compare_obs: false + + #Generate HTML website (assumed false if missing): + #Note: The website files themselves will be located in the path + #specified by "cam_diag_plot_loc", under the "/website" subdirectory, + #where "" is the subdirectory created for this particular diagnostics run + #(usually "case_vs_obs_XXX" or "case_vs_baseline_XXX"). + create_html: true + + #Location of observational datasets: + #Note: this only matters if "compare_obs" is true and the path + #isn't specified in the variable defaults file. + obs_data_loc: /glade/campaign/cgd/amp/amwg/ADF_obs + + #Location where re-gridded and interpolated CAM climatology files are stored: + cam_regrid_loc: /glade/derecho/scratch/${user}/ADF_LatLon/regrid + + #Overwrite CAM re-gridded files? + #If false, or missing, then regridding will be skipped for regridded variables + #that already exist in "cam_regrid_loc": + cam_overwrite_regrid: false + + #Location where diagnostic plots are stored: + cam_diag_plot_loc: /glade/derecho/scratch/${user}/ADF_LatLon/plots + + #Location of ADF variable plotting defaults YAML file: + #If left blank or missing, ADF/lib/adf_variable_defaults.yaml will be used + #Uncomment and change path for custom variable defaults file + defaults_file: lib/ldf_variable_defaults.yaml + + #Longitude line on which to center all lat/lon maps. + #If this config option is missing then the central + #longitude will default to 180 degrees E. + central_longitude: 180 + + #Number of processors on which to run the ADF. + #If this config variable isn't present then + #the ADF defaults to one processor. Also, if + #you set it to "*" then it will default + #to all of the processors available on a + #single node/machine: + num_procs: 1 + + #If set to true, then redo all plots even if they already exist. + #If set to false, then if a plot is found it will be skipped: + redo_plot: true + +#This second set of variables provides info for the CAM simulation(s) being diagnosed: +diag_cam_climo: + + # History file list of strings to match + # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] + # Only affects timeseries as everything else uses the created timeseries + # Default: + hist_str: clm2.h0 + + #Calculate climatologies? + #If false, the climatology files will not be created: + calc_cam_climo: true + + #Overwrite CAM climatology files? + #If false, or not prsent, then already existing climatology files will be skipped: + cam_overwrite_climo: false + + #Location of CAM climatologies (to be created and then used by this script) + cam_climo_loc: /glade/derecho/scratch/${user}/ADF_LatLon/${diag_cam_climo.cam_case_name}/climo + + #Name of CAM case (or CAM run name): + cam_case_name: b.e30_alpha06b.B1850C_LTso.ne30_t232_wgx3.143 + + #Case nickname + #NOTE: if nickname starts with '0' - nickname must be in quotes! + # ie '026a' as opposed to 026a + #If missing or left blank, will default to cam_case_name + case_nickname: '143' + + #Location of CAM history (h0) files: + cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ + + # SE to FV regridding options + # Leave these blank if not on the native grid + #----------------------------- + # Weights file: + weights_file: /glade/work/wwieder/map_ne30pg3_to_fv0.9x1.25_scripgrids_conserve_nomask_c250108.nc + # Regridding method: + regrid_method: 'coservative' + # Lat/lon file: + latlon_file: /glade/derecho/scratch/wwieder/ctsm5.3.018_SP_f09_t232_mask/run/ctsm5.3.018_SP_f09_t232_mask.clm2.h0.0001-01.nc + + #model year when time series files should start: + #Note: Leaving this entry blank will make time series + # start at earliest available year. + start_year: 30 + + #model year when time series files should end: + #Note: Leaving this entry blank will make time series + # end at latest available year. + end_year: 40 + + #Do time series files exist? + #If True, then diagnostics assumes that model files are already time series. + #If False, or if simply not present, then diagnostics will attempt to create + #time series files from history (time-slice) files: + cam_ts_done: false + + #Save interim time series files? + #WARNING: This can take up a significant amount of space, + # but will save processing time the next time + cam_ts_save: false + + #Overwrite time series files, if found? + #If set to false, then time series creation will be skipped if files are found: + cam_overwrite_ts: false + + #Location where time series files are (or will be) stored: + cam_ts_loc: /glade/derecho/scratch/${user}/ADF_LatLon/${diag_cam_climo.cam_case_name}/ts + + +#This third set of variables provide info for the CAM baseline climatologies. +#This only matters if "compare_obs" is false: +diag_cam_baseline_climo: + + # History file list of strings to match + # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] + # Only affects timeseries as everything else uses the created timeseries + # Default: + hist_str: clm2.h0 + + #Calculate cam baseline climatologies? + #If false, the climatology files will not be created: + calc_cam_climo: true + + #Overwrite CAM climatology files? + #If false, or not present, then already existing climatology files will be skipped: + cam_overwrite_climo: false + + #Name of CAM baseline case: + cam_case_name: ctsm53019_f09_BNF_hist + + #Baseline case nickname + #NOTE: if nickname starts with '0' - nickname must be in quotes! + # ie '026a' as opposed to 026a + #If missing or left blank, will default to cam_case_name + case_nickname: '5.3.019_BNF' + + #Location of CAM baseline history (h0) files: + #Example test files + cam_hist_loc: /glade/derecho/scratch/slevis/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist/ + + #Location of CAM climatologies (to be created and then used by this script) + cam_climo_loc: /glade/derecho/scratch/${user}/ADF_LatLon/${diag_cam_baseline_climo.cam_case_name}/climo + + #model year when time series files should start: + #Note: Leaving this entry blank will make time series + # start at earliest available year. + start_year: 1850 + + #model year when time series files should end: + #Note: Leaving this entry blank will make time series + # end at latest available year. + end_year: 1860 + + #Do time series files need to be generated? + #If True, then diagnostics assumes that model files are already time series. + #If False, or if simply not present, then diagnostics will attempt to create + #time series files from history (time-slice) files: + cam_ts_done: false + + #Save interim time series files for baseline run? + #WARNING: This can take up a significant amount of space: + cam_ts_save: true + + #Overwrite baseline time series files, if found? + #If set to false, then time series creation will be skipped if files are found: + cam_overwrite_ts: false + + #Location where time series files are (or will be) stored: + cam_ts_loc: /glade/derecho/scratch/${user}/ADF_LatLon/${diag_cam_baseline_climo.cam_case_name}/ts + +#+++++++++++++++++++++++++++++++++++++++++++++++++++ +#These variables below only matter if you are using +#a non-standard method, or are adding your own +#diagnostic scripts. +#+++++++++++++++++++++++++++++++++++++++++++++++++++ + +#Note: If you want to pass arguments to a particular script, you can +#do it like so (using the "averaging_example" script in this case): +# - {create_climo_files: {kwargs: {clobber: true}}} + +#Name of time-averaging scripts being used to generate climatologies. +#These scripts must be located in "scripts/averaging": +time_averaging_scripts: + - create_climo_files + +#Name of regridding scripts being used. +#These scripts must be located in "scripts/regridding": +regridding_scripts: + - regrid_and_vert_interp + +#List of analysis scripts being used. +#These scripts must be located in "scripts/analysis": +analysis_scripts: + - lmwg_table + +#List of plotting scripts being used. +#These scripts must be located in "scripts/plotting": +plotting_scripts: + - global_latlon_map + - global_mean_timeseries_lnd + - polar_map + +#List of CAM variables that will be processesd: +#If CVDP is to be run PSL, TREFHT, TS and PRECT (or PRECC and PRECL) should be listed +diag_var_list: + - TSA + - PREC + - ELAI + - GPP + #- NPP + - FSDS + #- ALTMAX + - ET + #- TOTRUNOFF + #- DSTFLXT + #- MEG_isoprene + +#END OF FILE From 74ca8cf648db07f9e171bd3e5f4205441b414e95 Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 10 Apr 2025 16:20:52 -0600 Subject: [PATCH 056/126] remove user name --- config_clm_BvsI.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config_clm_BvsI.yml b/config_clm_BvsI.yml index 1de2603f0..7abb9b8a7 100644 --- a/config_clm_BvsI.yml +++ b/config_clm_BvsI.yml @@ -58,7 +58,7 @@ # Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script # to check for a failure to customize # -user: 'wwieder' #'USER-NAME-NOT-SET' +user: 'USER-NAME-NOT-SET' #This first set of variables specify basic info used by all diagnostic runs: diag_basic_info: From fe1946303c0a55054c4d533bb8faf791d63d064f Mon Sep 17 00:00:00 2001 From: Katie Rocci Date: Thu, 10 Apr 2025 16:27:24 -0600 Subject: [PATCH 057/126] changed color bars and units labels --- lib/ldf_variable_defaults.yaml | 77 ++++++++++++++++++---------------- 1 file changed, 40 insertions(+), 37 deletions(-) diff --git a/lib/ldf_variable_defaults.yaml b/lib/ldf_variable_defaults.yaml index 65b0b9ea4..c8a408d6d 100644 --- a/lib/ldf_variable_defaults.yaml +++ b/lib/ldf_variable_defaults.yaml @@ -77,12 +77,15 @@ diff_levs: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75 TSA: # 2m air temperature category: "Atmosphere" - colormap: "coolwarm" + colormap: "OrRd" contour_levels_range: [250, 310, 10] + diff_colormap: "coolwarm" + pct_diff_colormap: "coolwarm" + PREC: # RAIN + SNOW category: "Atmosphere" - colormap: "coolwarm" + colormap: "cubehelix_r" derivable_from: ["RAIN","SNOW"] scale_factor: 86400 add_offset: 0 @@ -102,10 +105,10 @@ FLDS: # atmospheric longwave radiation diff_contour_range: [-20, 20, 2] scale_factor: 1 add_offset: 0 - new_unit: "Wm$^{-2}$" + new_unit: "W m$^{-2}$" mpl: colorbar: - label : "Wm$^{-2}$" + label : "W m$^{-2}$" pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] pct_diff_colormap: "PuOr_r" @@ -122,18 +125,18 @@ QBOT: # atmospheric specific humidity TBOT: category: "Atmosphere" - colormap: "coolwarm" + colormap: "OrRd" contour_levels_range: [250, 310, 10] TREFMNAV: # daily minimum of average 2m temperature category: "Atmosphere" - colormap: "coolwarm" + colormap: "OrRd" contour_levels_range: [250, 310, 10] TREFMXAV: # daily maximum of average 2m temperature category: "Atmosphere" - colormap: "cool warm" + colormap: "OrRd" contour_levels_range: [250, 310, 10] @@ -159,34 +162,34 @@ FSH: # sensible heat ET: # latent heat: FCTR+FCEV+FGEV category: "Surface fluxes" derivable_from: ["FCTR","FCEV","FGEV"] - colormap: "Blues" + colormap: "Purples" contour_levels_range: [0, 220, 10] diff_colormap: "BrBG" diff_contour_range: [-45, 45, 5] scale_factor: 1 add_offset: 0 - new_unit: "Wm$^{-2}$" + new_unit: "W m$^{-2}$" mpl: colorbar: - label : "Wm$^{-2}$" + label : "W m$^{-2}$" pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pct_diff_colormap: "PuOr_r" + pct_diff_colormap: "BrBG" DSTFLXT: # total surface dust emission category: "Surface fluxes" - colormap: "Blues" + colormap: "copper_r" diff_colormap: "BrBG_r" scale_factor: 86400 add_offset: 0 - new_unit: "kg m$^{-2}$ d$^{-1}" + new_unit: "kg m$^{-2}$ d$^{-1}$" mpl: colorbar: - label : "kg m$^{-2}$ d$^{-1}" + label : "kg m$^{-2}$ d$^{-1}$" pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] pct_diff_colormap: "PuOr_r" scale_factor_table: 0.000365 #days to years, kg/m2 to Pg globally avg_method: 'sum' - table_unit: "Pg y$^{-1}" + table_unit: "Pg y$^{-1}$" MEG_isoprene: category: "Surface fluxes" @@ -194,15 +197,15 @@ MEG_isoprene: diff_colormap: "BrBG_r" scale_factor: 86400 add_offset: 0 - new_unit: "kg m$^{-2}$ d$^{-1}" + new_unit: "kg m$^{-2}$ d$^{-1}$" mpl: colorbar: - label : "kg m$^{-2}$ d$^{-1}" + label : "kg m$^{-2}$ d$^{-1}$" pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] pct_diff_colormap: "PuOr_r" scale_factor_table: 0.365 #days to years, kg/m2 to Tg globally avg_method: 'sum' - table_unit: "Tg y$^{-1}" + table_unit: "Tg y$^{-1}$" #+++++++++++ @@ -240,8 +243,8 @@ BTRANMN: # Transpiration beta factor ELAI: # exposed one-sided leaf area index category: "Vegetation" colormap: "gist_earth_r" - contour_levels_range: [0., 7., 1.0] - diff_colormap: "PuOr_r" + contour_levels_range: [0., 9., 1.0] + diff_colormap: "PiYG" diff_contour_range: [-3.,3.,0.5] @@ -259,56 +262,56 @@ TSAI: # total one-sided stem area index GPP: # Gross Primary Production category: "Carbon" colormap: "gist_earth_r" - contour_levels_range: [0., 8., 0.5] - diff_colormap: "BrBG" + contour_levels_range: [0., 12., 0.5] + diff_colormap: "PiYG" diff_contour_range: [-4.,4.,0.5] scale_factor: 86400 add_offset: 0 - new_unit: "gC m$^{-2} d$^{-1}" + new_unit: "gC m$^{-2}$ d$^{-1}$" mpl: - colorbar: #TODO make this print correctly - label : "gC ${m^-2 d^-1}" + colorbar: + label : "gC m$^{-2}$ d$^{-1}$" pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pct_diff_colormap: "PuOr_r" + pct_diff_colormap: "PiYG" scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally avg_method: 'sum' - table_unit: "PgC y$^{-1}" + table_unit: "PgC y$^{-1}$" AR: # Autotrophic Respiration category: "Carbon" colormap: "gist_earth_r" contour_levels_range: [0., 3., 0.25] - diff_colormap: "BrBG" + diff_colormap: "PiYG" diff_contour_range: [-1.5, 1.5, 0.25] scale_factor: 86400 add_offset: 0 - new_unit: "gC m$^{-2} d$^{-1}" + new_unit: "gC m$^{-2}$ d$^{-1}$" mpl: colorbar: - label : "gC m$^{-2} d$^{-1}" + label : "gC m$^{-2}$ d$^{-1}$" pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pct_diff_colormap: "PuOr_r" + pct_diff_colormap: "PiYG" scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally avg_method: 'sum' - table_unit: "PgC y$^{-1}" + table_unit: "PgC y$^{-1}$" NPP: # Net Primary Production category: "Carbon" colormap: "gist_earth_r" contour_levels_range: [0., 3., 0.25] - diff_colormap: "PuOr_r" + diff_colormap: "PiYG" diff_contour_range: [-1.5, 1.5, 0.25] scale_factor: 86400 add_offset: 0 - new_unit: "gC m$^{-2} d$^{-1}" + new_unit: "gC m$^{-2}$ d$^{-1}$" mpl: colorbar: - label : "gC m$^{-2} d$^{-1}" + label : "gC m$^{-2}$ d$^{-1}$" pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] - pct_diff_colormap: "PuOr_r" + pct_diff_colormap: "PiYG" scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally avg_method: 'sum' - table_unit: "PgC y$^{-1}" + table_unit: "PgC y$^{-1}$" TOTECOSYSC_1m: category: "Carbon" From 47b031fb82c340cf6f596fbd3cd7882fe803e73b Mon Sep 17 00:00:00 2001 From: Meg Fowler Date: Thu, 17 Apr 2025 16:00:57 -0600 Subject: [PATCH 058/126] Add regional plot climatology capability --- config_clm_unstructured_plots.yaml | 72 +++++- lib/adf_info.py | 13 ++ scripts/plotting/regional_climatology.py | 265 +++++++++++++++++++++++ 3 files changed, 342 insertions(+), 8 deletions(-) create mode 100644 scripts/plotting/regional_climatology.py diff --git a/config_clm_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml index 2786071ec..4f612d4f3 100644 --- a/config_clm_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -58,7 +58,7 @@ # Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script # to check for a failure to customize # -user: 'USER-NAME-NOT-SET' +user: 'mdfowler' #This first set of variables specify basic info used by all diagnostic runs: diag_basic_info: @@ -274,23 +274,79 @@ analysis_scripts: #List of plotting scripts being used. #These scripts must be located in "scripts/plotting": plotting_scripts: - - global_latlon_map - - global_mean_timeseries_lnd - - polar_map + # - global_latlon_map + # - global_mean_timeseries_lnd + # - polar_map + - regional_climatology #List of variables that will be processesd: #Shorter list here, for efficiency of testing diag_var_list: - #- TSA + - TSA - PREC - ELAI - GPP #- NPP #- FSDS #- ALTMAX + - ALBD - ET - #- TOTRUNOFF - - DSTFLXT - - MEG_isoprene + - RAIN + - SNOW + - TOTRUNOFF + - QOVER + - QDRAI + - QRGWL + - QSNOFRZ + - QSNOMELT + - QSNWCPICE + # - DSTFLXT + # - MEG_isoprene + +region_list: + - Alaskan Arctic + - Canadian Arctic + - Greenland + - Russian Arctic + - Antarctica + - Alaska + - Northwest Canada + - Central Canada + - Eastern Canada + - Northern Europe + - Western Siberia + - Eastern Siberia + - Western U.S. + - Central U.S. + - Eastern U.S. + - Europe + - Mediterranean + - Central America + - Amazonia + - Central Africa + - Indonesia + - Brazil + - Sahel + - Southern Africa + - India + - Indochina + - Sahara Desert + - Arabian Peninsula + - Australia + # - Central Asia ## Broken... probably because there are two? + - Mongolia + - Tibetan Plateau + # - Central Asia + # - NE China # But why did this one break? + # - Eastern China + # - Southern Asia + # - Sahara and Arabia + # - MedSea and MidEast + # - Tigris Euphrates + # - Polar + # - Lost Boreal Forest + + + #END OF FILE diff --git a/lib/adf_info.py b/lib/adf_info.py index 44e6d4102..bb55132e6 100644 --- a/lib/adf_info.py +++ b/lib/adf_info.py @@ -78,6 +78,8 @@ def __init__(self, config_file, debug=False): #Add CAM climatology info to object: self.__cam_climo_info = self.read_config_var('diag_cam_climo', required=True) + + #Expand CAM climo info variable strings: self.expand_references(self.__cam_climo_info) @@ -134,6 +136,9 @@ def __init__(self, config_file, debug=False): #Initialize ADF variable list: self.__diag_var_list = self.read_config_var('diag_var_list', required=True) + #Initialize ADF variable list: + self.__region_list = self.read_config_var('region_list', required=True) + #Case names: case_names = self.get_cam_info('cam_case_name', required=True) @@ -779,6 +784,14 @@ def diag_var_list(self): #Note that a copy is needed in order to avoid having a script mistakenly #modify this variable, as it is mutable and thus passed by reference: return copy.copy(self.__diag_var_list) + + # Create property needed to return "region_list" list to user: + @property + def region_list(self): + """Return a copy of the "region_list" list to the user if requested.""" + #Note that a copy is needed in order to avoid having a script mistakenly + #modify this variable, as it is mutable and thus passed by reference: + return copy.copy(self.__region_list) # Create property needed to return "basic_info" expanded dictionary to user: @property diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py new file mode 100644 index 000000000..9f63276bb --- /dev/null +++ b/scripts/plotting/regional_climatology.py @@ -0,0 +1,265 @@ +from pathlib import Path +import numpy as np +import xarray as xr +import uxarray as ux +import matplotlib.pyplot as plt +import cartopy.crs as ccrs +# import plotting_functions as pf +import warnings # use to warn user about missing files. + +def my_formatwarning(msg, *args, **kwargs): + """custom warning""" + # ignore everything except the message + return str(msg) + "\n" + + +warnings.formatwarning = my_formatwarning + + +def regional_climatology(adfobj): + + """ + load climo file, subset for each region and each var + Make a combined plot, save it, add it to website. + + NOTES (from Meg): There are still a lot of to-do's with this script! + - convert region defintion netCDF file to a yml, read that in instead + - increase number of variables that have a climo plotted; i've just + added two, but left room for more in the subplots + - check that all varaibles have climo files; likely to break otherwise + - add option so that this works with a structured grid too + - make sure that climo's are being plotted with the preferred units + - add in observations (need to regrid/area weight) + - need to figure out how to display the figures on the website + + """ + + #Notify user that script has started: + print("\n Generating global mean time series plots...") + + # Gather ADF configurations + # plot_loc = adfobj.get_basic_info('cam_diag_plot_loc') + # plot_type = adfobj.read_config_var("diag_basic_info").get("plot_type", "png") + plot_locations = adfobj.plot_location + plot_type = adfobj.get_basic_info('plot_type') + if not plot_type: + plot_type = 'png' + # res = adfobj.variable_defaults # will be dict of variable-specific plot preferences + # or an empty dictionary if use_defaults was not specified in YAML. + + # check if existing plots need to be redone + redo_plot = adfobj.get_basic_info('redo_plot') + print(f"\t NOTE: redo_plot is set to {redo_plot}") + + unstruct_plotting = adfobj.unstructured_plotting + print("unstruct_plotting", unstruct_plotting) + + case_nickname = adfobj.get_cam_info('case_nickname') + base_nickname = adfobj.get_baseline_info('case_nickname') + + region_list = adfobj.region_list + regional_climo_var_list = ['GPP','ELAI','TSA','PREC','RAIN','SNOW', 'TOTRUNOFF', + 'QOVER', 'QDRAI','QRGWL','QSNOFRZ','QSNOMELT', + 'QSNWCPICE','ALBD'] + + ## Open file containing regions of interest + nc_reg_file = '/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/code/resources/region_definitions.nc' + regionDS = xr.open_dataset(nc_reg_file) + region_names = [str(item).split('b')[1] for item in regionDS.PTITSTR.values] + + ## Open observations YML here? + + # I want to get the indices that match the reqeusted regions now... + region_indexList = [] + cleaned_candidates = [s.strip("'\"") for s in region_names] + cleaned_candidates = [s.strip(" ") for s in cleaned_candidates] + + # Fix some region names I've broken + cleaned_candidates = rename_region(cleaned_candidates, 'Western Si', 'Western Siberia') + cleaned_candidates = rename_region(cleaned_candidates, 'Eastern Si', 'Eastern Siberia') + cleaned_candidates = rename_region(cleaned_candidates, 'Ara', 'Arabian Peninsula') + cleaned_candidates = rename_region(cleaned_candidates, 'Sahara and Ara', 'Sahara and Arabia') + cleaned_candidates = rename_region(cleaned_candidates, 'Ti', 'Tibetan Plateau') + + for iReg in region_list: + match_indices = [i for i, region in enumerate(cleaned_candidates) if iReg == region] + region_indexList = np.append(region_indexList, match_indices) + region_indexList =region_indexList.astype('int') + + + # Extract variables: + baseline_name = adfobj.get_baseline_info("cam_case_name", required=True) + input_climo_baseline = Path(adfobj.get_baseline_info("cam_climo_loc", required=True)) + # TODO hard wired for single case name: + case_name = adfobj.get_cam_info("cam_case_name", required=True)[0] + input_climo_case = Path(adfobj.get_cam_info("cam_climo_loc", required=True)[0]) + + # Get grid file + mesh_file = adfobj.mesh_files["baseline_mesh_file"] + uxgrid = ux.open_grid(mesh_file) + + # Set keywords + kwargs = {} + kwargs["mesh_file"] = mesh_file + kwargs["unstructured_plotting"] = unstruct_plotting + + base_data = {} + case_data = {} + # First, load all variable data once (instead of inside nested loops) + for field in regional_climo_var_list: + # Load the global climatology for this variable + base_data[field] = adfobj.data.load_reference_climo_da(baseline_name, field, **kwargs) + case_data[field] = adfobj.data.load_climo_da(case_name, field, **kwargs) + + if type(base_data[field]) is type(None): + print('Missing file for ', field) + continue + else: + mdataset = adfobj.data.load_climo_dataset(case_name, field, **kwargs) + area = mdataset.area + landfrac = mdataset.landfrac + # calculate weights + wgt = area * landfrac / (area * landfrac).sum() + + # Loop over regions for selected variable + for iReg in range(len(region_indexList)): + regionDS_thisRg = regionDS.isel(region=region_indexList[iReg]) + + ## Set up figure + fig,axs = plt.subplots(4,5, figsize=(15,10)) + axs = axs.ravel() + + plt_counter = 1 + for field in regional_climo_var_list: + mdataset = adfobj.data.load_climo_dataset(case_name, field, **kwargs) + + if type(base_data[field]) is type(None): + continue + else: + # TODO: handle regular gridded case + base_var,wgt_sub = getRegion_uxarray(uxgrid, base_data, field, wgt, + regionDS_thisRg.BOX_W.values, regionDS_thisRg.BOX_E.values, + regionDS_thisRg.BOX_S.values, regionDS_thisRg.BOX_N.values) + base_var_wgtd = np.sum(base_var * wgt_sub, axis=-1) / np.sum(wgt_sub) + + case_var,wgt_sub = getRegion_uxarray(uxgrid, case_data, field, wgt, + regionDS_thisRg.BOX_W.values, regionDS_thisRg.BOX_E.values, + regionDS_thisRg.BOX_S.values, regionDS_thisRg.BOX_N.values) + case_var_wgtd = np.sum(case_var * wgt_sub, axis=-1) / np.sum(wgt_sub) + + ## Plot the map: + if plt_counter==1: + ## Define region in first subplot + fig.delaxes(axs[0]) + + transform = ccrs.PlateCarree() + projection = ccrs.PlateCarree() + base_var_mask = base_var.isel(time=0) + base_var_mask[np.isfinite(base_var_mask)]=1 + collection = base_var_mask.to_polycollection() + + collection.set_transform(transform) + collection.set_cmap('rainbow_r') + collection.set_antialiased(False) + map_ax = fig.add_subplot(4, 4, 1, projection=ccrs.PlateCarree()) + + map_ax.coastlines() + map_ax.add_collection(collection) + map_ax.set_global() + map_ax.set_title(region_names[iReg]+'\n'+str(regionDS["BOXSTR"].values[iReg])) + # Add map extent selection + if ((regionDS_thisRg.BOX_S.values >= 30) & (regionDS_thisRg.BOX_E.values<=-5) ): + map_ax.set_extent([-180, -5, 30, 90],crs=ccrs.PlateCarree()) + elif ((regionDS_thisRg.BOX_S.values >= 30) & (regionDS_thisRg.BOX_E.values>=-5) ): + map_ax.set_extent([-5, 179, 30, 90],crs=ccrs.PlateCarree()) + elif ((regionDS_thisRg.BOX_S.values <= 30) & (regionDS_thisRg.BOX_S.values >= -30) & + (regionDS_thisRg.BOX_E.values<=-5) ): + map_ax.set_extent([-180, -5, -30, 30],crs=ccrs.PlateCarree()) + elif ((regionDS_thisRg.BOX_S.values <= 30) & (regionDS_thisRg.BOX_S.values >= -30) & + (regionDS_thisRg.BOX_E.values>=-5) ): + map_ax.set_extent([-5, 179, -30, 30],crs=ccrs.PlateCarree()) + elif ((regionDS_thisRg.BOX_S.values <= -30) & (regionDS_thisRg.BOX_S.values >= -60) & + (regionDS_thisRg.BOX_E.values>=-5) ): + map_ax.set_extent([-5, 179, -89, -30],crs=ccrs.PlateCarree()) + elif ((regionDS_thisRg.BOX_S.values <= -30) & (regionDS_thisRg.BOX_S.values >= -60) & + (regionDS_thisRg.BOX_E.values<=-5) ): + map_ax.set_extent([-180, -5, -89, -30],crs=ccrs.PlateCarree()) + elif ((regionDS_thisRg.BOX_S.values <= -60)): + map_ax.set_extent([-180, 179, -89, -60],crs=ccrs.PlateCarree()) + + + ## Plot the timeseries + if type(base_data[field]) is type(None): + # print('Missing file for ', field) + continue + else: + axs[plt_counter].plot(np.arange(12)+1, case_var_wgtd,label=case_nickname) + axs[plt_counter].plot(np.arange(12)+1, base_var_wgtd,label=base_nickname) + axs[plt_counter].set_title(field) + axs[plt_counter].set_ylabel(base_data[field].units) + axs[plt_counter].legend() + + + plt_counter = plt_counter+1 + + # Save out figure + # fileFriendlyRegionName = + plot_loc = Path(plot_locations[0]) / f'RegionalClimo_{region_list[iReg]}_RegionalClimo_Mean.{plot_type}' + #Set path for variance figures: + # plot_loc = Path(plot_locations[0]) / f'RegionalClimo_{region_list[iReg]}.{plot_type}' + # print(plot_loc) + # plot_name = plot_loc+'RegionalClimo_'+region_names[iReg]+'.png' + +# Check redo_plot. If set to True: remove old plots, if they already exist: + if (not redo_plot) and plot_loc.is_file(): + #Add already-existing plot to website (if enabled): + adfobj.debug_log(f"'{plot_loc}' exists and clobber is false.") + adfobj.add_website_data(plot_loc, "RegionalClimo", None, season=region_list[iReg], multi_case=True, non_season=True, plot_type = "RegionalClimo") + + #Continue to next iteration: + return + elif (redo_plot): + if plot_loc.is_file(): + plot_loc.unlink() + + fig.savefig(plot_loc, bbox_inches='tight', facecolor='white') + plt.close() + + #Add plot to website (if enabled): + adfobj.add_website_data(plot_loc, "RegionalClimo", None, season=region_list[iReg], multi_case=True, non_season=True, plot_type = "RegionalClimo") + + return + +def getRegion_uxarray(gridDS, varDS, varName, wgt, BOX_W, BOX_E, BOX_S, BOX_N): + # Method 2: Filter mesh nodes based on coordinates + node_lons = gridDS.face_lon + node_lats = gridDS.face_lat + + # Create a boolean mask for nodes within your domain + in_domain = ((node_lons >= BOX_W) & (node_lons <= BOX_E) & + (node_lats >= BOX_S) & (node_lats <= BOX_N)) + + # Get the indices of nodes within your domain + node_indices = np.where(in_domain)[0] + + # Subset the dataset using these node indices + domain_subset = varDS[varName].isel(n_face=node_indices) + wgt_subset = wgt.isel(n_face=node_indices) + # area_subset = varDS['area'].isel(n_face=node_indices) + # lf_subset = varDS['landfrac'].isel(n_face=node_indices) + + return domain_subset,wgt_subset + +def rename_region(DS, searchStr, replaceStr): + iReplace = np.where(np.asarray(DS)==searchStr)[0] + if len(iReplace)==1: + DS[int(iReplace)] = replaceStr + elif len(iReplace>1): + # This happens with Tibetan Plateau; there are two defined + # Indices 31 and 35 + # Same values, but Box_W and Box_E are swapped.. going to keep the first + DS[int(iReplace[0])] = replaceStr + # print('Found more than one match for ',searchStr) + # print(iReplace) + + return DS \ No newline at end of file From a778f32c3a1561261c8133666c673adcfdcac335 Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 17 Apr 2025 16:47:12 -0600 Subject: [PATCH 059/126] potential yaml for regions --- lib/regions_lnd.yaml | 137 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 137 insertions(+) create mode 100644 lib/regions_lnd.yaml diff --git a/lib/regions_lnd.yaml b/lib/regions_lnd.yaml new file mode 100644 index 000000000..93dc825af --- /dev/null +++ b/lib/regions_lnd.yaml @@ -0,0 +1,137 @@ +# Define regions with lists for boundaries of +# - lat (-90 to 90) +# - lon (-180 to 180) + +Region: +- "Global" + - [-90, 90] + - [-180, 180] +- "N. Hemisphere Land" + - [0, 90] + - [-180, 180] +- "S. Hemisphere Land" + - [-90, 0] + - [-180, 180] +- "Polar" + - [60, 90] + - [-180, 180] +- "Alaskan Arctic" + - [66.5, 72] + - [-170, -140] +- "Canadian Arctic" + - [66.5, 90] + - [-120, -60] +- "Greenland" + - [60, 90] + - [-60, -20] +- "Russian Arctic" + - [66.5, 90] + - [70, 170] +- "Antarctica" + - [-90, -65] + - [-180, 180] +- "Alaska" + - [59, 66.5] + - [-170, -140] +- "Northwest Canada" + - [55, 66.5] + - [-125, -100] +- "Central Canada" + - [50, 62] + - [-100, -80] +- "Eastern Canada" + - [50, 60] + - [-80, -55] +- "Northern Europe" + - [60, 70] + - [5, 45] +- "Western Siberia" + - [55, 66.5] + - [60, 90] +- "Eastern Siberia" + - [50, 66.5] + - [90, 140] +- "Lost Boreal Forest" + - [48, 56] + - [95, 103] +- "Western U.S." + - [30, 50] + - [-130, -105] +- "Central U.S." + - [30, 50] + - [-105, -90] +- "Eastern U.S.” + - [30, 50] + - [-90, -70] +- "Europe" + - [45, 60] + - [-10, 30] +- "Mediterranean" + - [34, 45] + - [-10, 30] +- "Central America" + - [5, 16] + - [-95, -75] +- "Amazonia" + - [-10, 0] + - [-70, -50] +- "Central Africa" + - [-5, 5] + - [10, 30] +- "Indonesia" + - [-10, 10] + - [90, 150] +- "Brazil" + - [-23.5, -10] + - [-65, -30] +- "Sahel" + - [6, 16] + - [-5, 15] +- "Southern Africa" + - [-23.5, -5] + - [10, 40] +- "India" + - [10, 23.5] + - [70, 90] +- "Indochina" + - [10, 23.5] + - [90, 120] +- "Sahara Desert" + - [16, 30] + - [-20, 30] +- "Arabian Peninsula" + - [16, 30] + - [35, 60] +- "Australia" + - [-30, -20] + - [110, 145] +- "Central Asia" + - [35, 50] + - [55, 70] +- "Mongolia" + - [40, 50] + - [85, 120] +- "Tibetan Plateau" + - [30, 40] + - [80, 100] +- "Central Asia" + - [40, 50] + - [40, 100] +- "NE China" + - [40, 50] + - [100, 130] +- "Eastern China" + - [30, 40] + - [100, 120] +- "Southern Asia" + - [20, 30] + - [60, 120] +- "Sahara and Arabia" + - [15, 30] + - [-15, 60] +- "MedSea and MidEast" + - [30, 45] + - [-10, 60] +- "Tigris Euphrates" + - [30, 40] + - [37, 50] From e9b309f512df18d6d5696e037244d2536bbfa808 Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 17 Apr 2025 17:02:47 -0600 Subject: [PATCH 060/126] alternative python format --- lib/regions_lnd.py | 49 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) create mode 100644 lib/regions_lnd.py diff --git a/lib/regions_lnd.py b/lib/regions_lnd.py new file mode 100644 index 000000000..7704118af --- /dev/null +++ b/lib/regions_lnd.py @@ -0,0 +1,49 @@ +# Define regions with lists for boundaries of +# - lat (-90 to 90) +# - lon (-180 to 180) + +regions = { + "Global": [[-90, 90], [-180, 180]], + "N. Hemisphere Land": [[0, 90], [-180, 180]], + "S. Hemisphere Land": [[-90, 0], [-180, 180]], + "Polar": [[60, 90], [-180, 180]], + "Alaskan Arctic": [[66.5, 72], [-170, -140]], + "Canadian Arctic": [[66.5, 90], [-120, -60]], + "Greenland": [[60, 90], [-60, -20]], + "Russian Arctic": [[66.5, 90], [70, 170]], + "Antarctica": [[-90, -65], [-180, 180]], + "Alaska": [[59, 66.5], [-170, -140]], + "Northwest Canada": [[55, 66.5], [-125, -100]], + "Central Canada": [[50, 62], [-100, -80]], + "Eastern Canada": [[50, 60], [-80, -55]], + "Northern Europe": [[60, 70], [5, 45]], + "Western Siberia": [[55, 66.5], [60, 90]], + "Eastern Siberia": [[50, 66.5], [90, 140]], + "Lost Boreal Forest": [[48, 56], [95, 103]], + "Western U.S.": [[30, 50], [-130, -105]], + "Central U.S.": [[30, 50], [-105, -90]], + "Eastern U.S.": [[30, 50], [-90, -70]], + "Europe": [[45, 60], [-10, 30]], + "Mediterranean": [[34, 45], [-10, 30]], + "Central America": [[5, 16], [-95, -75]], + "Amazonia": [[-10, 0], [-70, -50]], + "Central Africa": [[-5, 5], [10, 30]], + "Indonesia": [[-10, 10], [90, 150]], + "Brazil": [[-23.5, -10], [-65, -30]], + "Sahel": [[6, 16], [-5, 15]], + "Southern Africa": [[-23.5, -5], [10, 40]], + "India": [[10, 23.5], [70, 90]], + "Indochina": [[10, 23.5], [90, 120]], + "Sahara Desert": [[16, 30], [-20, 30]], + "Arabian Peninsula": [[16, 30], [35, 60]], + "Australia": [[-30, -20], [110, 145]], + "Central Asia": [[35, 50], [55, 70]], + "Mongolia": [[40, 50], [85, 120]], + "Tibetan Plateau": [[30, 40], [80, 100]], + "NE China": [[40, 50], [100, 130]], + "Eastern China": [[30, 40], [100, 120]], + "Southern Asia": [[20, 30], [60, 120]], + "Sahara and Arabia": [[15, 30], [-15, 60]], + "MedSea and MidEast": [[30, 45], [-10, 60]], + "Tigris Euphrates": [[30, 40], [37, 50]], +} From 5928dcf3ae2fd626c862fb43df99960974f60783 Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 18 Apr 2025 13:36:22 -0600 Subject: [PATCH 061/126] unwanted .py option --- lib/regions_lnd.py | 49 ---------------------------------------------- 1 file changed, 49 deletions(-) delete mode 100644 lib/regions_lnd.py diff --git a/lib/regions_lnd.py b/lib/regions_lnd.py deleted file mode 100644 index 7704118af..000000000 --- a/lib/regions_lnd.py +++ /dev/null @@ -1,49 +0,0 @@ -# Define regions with lists for boundaries of -# - lat (-90 to 90) -# - lon (-180 to 180) - -regions = { - "Global": [[-90, 90], [-180, 180]], - "N. Hemisphere Land": [[0, 90], [-180, 180]], - "S. Hemisphere Land": [[-90, 0], [-180, 180]], - "Polar": [[60, 90], [-180, 180]], - "Alaskan Arctic": [[66.5, 72], [-170, -140]], - "Canadian Arctic": [[66.5, 90], [-120, -60]], - "Greenland": [[60, 90], [-60, -20]], - "Russian Arctic": [[66.5, 90], [70, 170]], - "Antarctica": [[-90, -65], [-180, 180]], - "Alaska": [[59, 66.5], [-170, -140]], - "Northwest Canada": [[55, 66.5], [-125, -100]], - "Central Canada": [[50, 62], [-100, -80]], - "Eastern Canada": [[50, 60], [-80, -55]], - "Northern Europe": [[60, 70], [5, 45]], - "Western Siberia": [[55, 66.5], [60, 90]], - "Eastern Siberia": [[50, 66.5], [90, 140]], - "Lost Boreal Forest": [[48, 56], [95, 103]], - "Western U.S.": [[30, 50], [-130, -105]], - "Central U.S.": [[30, 50], [-105, -90]], - "Eastern U.S.": [[30, 50], [-90, -70]], - "Europe": [[45, 60], [-10, 30]], - "Mediterranean": [[34, 45], [-10, 30]], - "Central America": [[5, 16], [-95, -75]], - "Amazonia": [[-10, 0], [-70, -50]], - "Central Africa": [[-5, 5], [10, 30]], - "Indonesia": [[-10, 10], [90, 150]], - "Brazil": [[-23.5, -10], [-65, -30]], - "Sahel": [[6, 16], [-5, 15]], - "Southern Africa": [[-23.5, -5], [10, 40]], - "India": [[10, 23.5], [70, 90]], - "Indochina": [[10, 23.5], [90, 120]], - "Sahara Desert": [[16, 30], [-20, 30]], - "Arabian Peninsula": [[16, 30], [35, 60]], - "Australia": [[-30, -20], [110, 145]], - "Central Asia": [[35, 50], [55, 70]], - "Mongolia": [[40, 50], [85, 120]], - "Tibetan Plateau": [[30, 40], [80, 100]], - "NE China": [[40, 50], [100, 130]], - "Eastern China": [[30, 40], [100, 120]], - "Southern Asia": [[20, 30], [60, 120]], - "Sahara and Arabia": [[15, 30], [-15, 60]], - "MedSea and MidEast": [[30, 45], [-10, 60]], - "Tigris Euphrates": [[30, 40], [37, 50]], -} From 764c06d45df6bcea40bddd8061ec0b7ef3012bdd Mon Sep 17 00:00:00 2001 From: Naoki Mizukami Date: Mon, 21 Apr 2025 17:27:11 -0600 Subject: [PATCH 062/126] separate syr and eyr from ts period for climatology --- config_clm_native_grid_to_latlon.yaml | 20 ++++++++++++++++++++ scripts/averaging/create_climo_files.py | 15 ++++++++++++++- 2 files changed, 34 insertions(+), 1 deletion(-) diff --git a/config_clm_native_grid_to_latlon.yaml b/config_clm_native_grid_to_latlon.yaml index 7bfeac4de..658bd674f 100644 --- a/config_clm_native_grid_to_latlon.yaml +++ b/config_clm_native_grid_to_latlon.yaml @@ -168,6 +168,16 @@ diag_cam_climo: # end at latest available year. end_year: 40 + #model year when climatology should start: + #Note: Leaving this entry blank will make time series + # end at latest available year. + #climo_start_year: 35 + + #model year when climatology should end: + #Note: Leaving this entry blank will make time series + # end at latest available year. + #climo_end_year: 40 + #Do time series files exist? #If True, then diagnostics assumes that model files are already time series. #If False, or if simply not present, then diagnostics will attempt to create @@ -241,6 +251,16 @@ diag_cam_baseline_climo: # end at latest available year. end_year: 40 + #model year when climatology should start: + #Note: Leaving this entry blank will make time series + # end at latest available year. + #climo_start_year: 35 + + #model year when time series files should end: + #Note: Leaving this entry blank will make time series + # end at latest available year. + #climo_end_year: 40 + #Do time series files need to be generated? #If True, then diagnostics assumes that model files are already time series. #If False, or if simply not present, then diagnostics will attempt to create diff --git a/scripts/averaging/create_climo_files.py b/scripts/averaging/create_climo_files.py index 8ae8f8d7d..d5c1f75e4 100644 --- a/scripts/averaging/create_climo_files.py +++ b/scripts/averaging/create_climo_files.py @@ -76,10 +76,17 @@ def create_climo_files(adf, clobber=False, search=None): output_locs = adf.get_cam_info("cam_climo_loc", required=True) calc_climos = adf.get_cam_info("calc_cam_climo") overwrite = adf.get_cam_info("cam_overwrite_climo") + # Get start and end year for climatology computation + climo_start_year = adf.get_cam_info("climo_start_year") + climo_end_year = adf.get_cam_info("climo_end_year") #Extract simulation years: start_year = adf.climo_yrs["syears"] end_year = adf.climo_yrs["eyears"] + if climo_start_year: + start_year = climo_start_year + if climo_end_year: + end_year = climo_end_year comp = adf.model_component print("\ncomp",comp,"\n") @@ -100,10 +107,16 @@ def create_climo_files(adf, clobber=False, search=None): output_bl_loc = adf.get_baseline_info("cam_climo_loc", required=True) calc_bl_climos = adf.get_baseline_info("calc_cam_climo") ovr_bl = adf.get_baseline_info("cam_overwrite_climo") + climo_baseline_start_year = adf.get_baseline_info("climo_start_year") + climo_baseline_end_year = adf.get_baseline_info("climo_end_year") #Extract baseline years: bl_syr = adf.climo_yrs["syear_baseline"] bl_eyr = adf.climo_yrs["eyear_baseline"] + if climo_baseline_start_year: + bl_syr = climo_baseline_start_year + if climo_baseline_end_year: + bl_eyr = climo_baseline_end_year #Append to case lists: case_names.append(baseline_name) @@ -246,7 +259,7 @@ def process_variable(adf, ts_files, syr, eyr, output_file, comp): if comp == "atm": dim = 'nbnd' # NOTE: force `load` here b/c if dask & time is cftime, throws a NotImplementedError: - time = xr.DataArray(cam_ts_data['time_bounds'].load().mean(dim=dim).values, + time = xr.DataArray(cam_ts_data['time_bounds'].load().mean(dim=dim).values, dims=time.dims, attrs=time.attrs) cam_ts_data['time'] = time cam_ts_data.assign_coords(time=time) From 890e7dec2b8cdcbcce765234c6a23308c2d4b6cd Mon Sep 17 00:00:00 2001 From: Naoki Mizukami Date: Sat, 26 Apr 2025 05:37:12 -0600 Subject: [PATCH 063/126] added some check on climo_start_year and climo_end_year --- scripts/averaging/create_climo_files.py | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/scripts/averaging/create_climo_files.py b/scripts/averaging/create_climo_files.py index d5c1f75e4..ac88e08c2 100644 --- a/scripts/averaging/create_climo_files.py +++ b/scripts/averaging/create_climo_files.py @@ -84,9 +84,13 @@ def create_climo_files(adf, clobber=False, search=None): start_year = adf.climo_yrs["syears"] end_year = adf.climo_yrs["eyears"] if climo_start_year: - start_year = climo_start_year + if climo_start_year > end_year: + raise ValueError('Sorry, climo_start_year must be earlier than ts end year.') + start_year = max(climo_start_year, start_year) if climo_end_year: - end_year = climo_end_year + if climo_end_year < start_year: + raise ValueError('Sorry, climo_end_year must be later than ts start year.') + end_year = min(climo_end_year, end_year) comp = adf.model_component print("\ncomp",comp,"\n") @@ -114,9 +118,13 @@ def create_climo_files(adf, clobber=False, search=None): bl_syr = adf.climo_yrs["syear_baseline"] bl_eyr = adf.climo_yrs["eyear_baseline"] if climo_baseline_start_year: - bl_syr = climo_baseline_start_year + if climo_baseline_start_year > bl_eyr: + raise ValueError('Sorry, climo_end_year must be later than ts start year.') + bl_syr = max(climo_baseline_start_year, bl_syr) if climo_baseline_end_year: - bl_eyr = climo_baseline_end_year + if climo_baseline_end_year < bl_syr: + raise ValueError('Sorry, climo_end_year must be later than ts start year.') + bl_eyr = min(climo_baseline_end_year, bl_eyr) #Append to case lists: case_names.append(baseline_name) From b036003b12c36996602e6a41261effc3b20b02d0 Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 2 May 2025 13:20:38 -0600 Subject: [PATCH 064/126] add crop category --- lib/ldf_variable_defaults.yaml | 30 +++++++++++++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-) diff --git a/lib/ldf_variable_defaults.yaml b/lib/ldf_variable_defaults.yaml index c8a408d6d..2a43b6cef 100644 --- a/lib/ldf_variable_defaults.yaml +++ b/lib/ldf_variable_defaults.yaml @@ -60,8 +60,9 @@ #+++++++++++++ # Available Land Default Plot Types #+++++++++++++ + default_ptypes: ["Tables","LatLon","TimeSeries", - "Arctic","RegionalClimo","RegionalTimeSeries","Special"] + "Arctic","RegionalClimo","RegionalTimeSeries","Special"] #+++++++++++++ # Constants @@ -213,14 +214,18 @@ MEG_isoprene: #+++++++++++ FSNO: # fraction of ground covered by snow category: "Hydrology" + diff_contour_range: [-50,50,10] H2OSNO: # SNOWICE + SNOWLIQ category: "Hydrology" + diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] SNOWDP: # snow height category: "Hydrology" + contour_levels: [-15.,-10.,-5.,-1.,-0.5,-0.1,0.,0.1,0.5,1.,5.,10.,15.] + diff_contour_levels: [-10.,-5.,-1.,-0.5,-0.1,0.,0.1,0.5,1.,5.,10.] TOTRUNOFF: # total liquid runoff @@ -230,6 +235,8 @@ TOTRUNOFF: # total liquid runoff scale_factor: 86400 add_offset: 0 new_unit: "mm d$^{-1}$" + contour_levels: [-0.1,0.,0.1,0.2,0.3,1.,2.,3.,] + diff_contour_range: [-1.,1.,0.1] mpl: colorbar: label : "mm d$^{-1}$" @@ -327,6 +334,27 @@ TOTVEGC: category: "Carbon" +#+++++++++++ +# Category: CROP +#+++++++++++ +GRAINC_TO_FOOD: + category: "Crop" + #contour_levels_range: [0., 3., 0.25] + diff_colormap: "PiYG" + #diff_contour_range: [-1.5, 1.5, 0.25] + scale_factor: 86400 + add_offset: 0 + new_unit: "gC m$^{-2}$ d$^{-1}$" + mpl: + colorbar: + label : "gC m$^{-2}$ d$^{-1}$" + #pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PiYG" + scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally + avg_method: 'sum' + table_unit: "PgC y$^{-1}$" + + #+++++++++++ # Category: Soils #+++++++++++ From 65cb9dafd59c0ee62ec6ea16dbb0f0b8dcb98f7e Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 2 May 2025 13:21:27 -0600 Subject: [PATCH 065/126] exclude crops from polar maps --- scripts/plotting/polar_map.py | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/scripts/plotting/polar_map.py b/scripts/plotting/polar_map.py index 719862cc3..bbc16b247 100644 --- a/scripts/plotting/polar_map.py +++ b/scripts/plotting/polar_map.py @@ -331,17 +331,18 @@ def polar_map(adfobj): #End if if comp == "lnd": hemi = hemi_type + # Exclude certain plots, this may get difficult + if var != 'GRAINC_TO_FOOD': + pf.make_polar_plot(plot_name, case_nickname, base_nickname, + [syear_cases[case_idx],eyear_cases[case_idx]], + [syear_baseline,eyear_baseline], + mseasons[s], oseasons[s], dseasons[s], pseasons[s], + hemisphere=hemi, obs=obs, unstructured=unstructured, + **vres) - pf.make_polar_plot(plot_name, case_nickname, base_nickname, - [syear_cases[case_idx],eyear_cases[case_idx]], - [syear_baseline,eyear_baseline], - mseasons[s], oseasons[s], dseasons[s], pseasons[s], - hemisphere=hemi, obs=obs, unstructured=unstructured, - **vres) - - #Add plot to website (if enabled): - adfobj.add_website_data(plot_name, var, case_name, category=web_category, - season=s, plot_type=hemi_type) + #Add plot to website (if enabled): + adfobj.add_website_data(plot_name, var, case_name, category=web_category, + season=s, plot_type=hemi_type) else: #mdata dimensions check print(f"\t WARNING: skipping polar map for {var} as it doesn't have only lat/lon dims.") From 30c7b8ed0273493e792433ad26a003ff70c2102e Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 2 May 2025 13:22:10 -0600 Subject: [PATCH 066/126] allow for multi procs in land diags --- lib/adf_diag.py | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/lib/adf_diag.py b/lib/adf_diag.py index 6bf889b92..cbd827372 100644 --- a/lib/adf_diag.py +++ b/lib/adf_diag.py @@ -769,16 +769,6 @@ def call_ncrcat(cmd): ] if "clm" in hist_str: - # Step 3a: Optional, add additional variables to clm2.h0 files - if "h0" in hist_str: - cmd_add_clm_h0_fields = [ - "ncks", "-A", "-C", "-v", "area,landfrac,landmask", - hist_files[0], - ts_outfil_str - ] - # add time invariant information to clm2.h0 fields - list_of_hist_commands.append(cmd_add_clm_h0_fields) - # Step 3b: Optional, add additional variables to clm2.h1 files if "h1" in hist_str: cmd_add_clm_h1_fields = [ @@ -862,6 +852,13 @@ def call_ncrcat(cmd): time = xr.DataArray(ts_ds['time_bounds'].load().mean(dim='nbnd').values, dims=time.dims, attrs=time.attrs) + # Optional, add additional variables to clm2.h0 files + if "h0" in hist_str: + ds = xr.open_dataset(hist_files[0], decode_times=False) + ts_ds['area'] = ds.area + ts_ds['landfrac'] = ds.landfrac + ts_ds['landmask'] = ds.landmask + ts_ds['time'] = time ts_ds.assign_coords(time=time) ts_ds_fixed = xr.decode_cf(ts_ds) From ad8534a92cb9179c3d59375c0a07dd6079d2c1a1 Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 8 May 2025 14:34:50 -0600 Subject: [PATCH 067/126] corrected yml file for Meg --- lib/regions_lnd.yaml | 265 +++++++++++++++++++++---------------------- 1 file changed, 132 insertions(+), 133 deletions(-) diff --git a/lib/regions_lnd.yaml b/lib/regions_lnd.yaml index 93dc825af..7aaf3983e 100644 --- a/lib/regions_lnd.yaml +++ b/lib/regions_lnd.yaml @@ -2,136 +2,135 @@ # - lat (-90 to 90) # - lon (-180 to 180) -Region: -- "Global" - - [-90, 90] - - [-180, 180] -- "N. Hemisphere Land" - - [0, 90] - - [-180, 180] -- "S. Hemisphere Land" - - [-90, 0] - - [-180, 180] -- "Polar" - - [60, 90] - - [-180, 180] -- "Alaskan Arctic" - - [66.5, 72] - - [-170, -140] -- "Canadian Arctic" - - [66.5, 90] - - [-120, -60] -- "Greenland" - - [60, 90] - - [-60, -20] -- "Russian Arctic" - - [66.5, 90] - - [70, 170] -- "Antarctica" - - [-90, -65] - - [-180, 180] -- "Alaska" - - [59, 66.5] - - [-170, -140] -- "Northwest Canada" - - [55, 66.5] - - [-125, -100] -- "Central Canada" - - [50, 62] - - [-100, -80] -- "Eastern Canada" - - [50, 60] - - [-80, -55] -- "Northern Europe" - - [60, 70] - - [5, 45] -- "Western Siberia" - - [55, 66.5] - - [60, 90] -- "Eastern Siberia" - - [50, 66.5] - - [90, 140] -- "Lost Boreal Forest" - - [48, 56] - - [95, 103] -- "Western U.S." - - [30, 50] - - [-130, -105] -- "Central U.S." - - [30, 50] - - [-105, -90] -- "Eastern U.S.” - - [30, 50] - - [-90, -70] -- "Europe" - - [45, 60] - - [-10, 30] -- "Mediterranean" - - [34, 45] - - [-10, 30] -- "Central America" - - [5, 16] - - [-95, -75] -- "Amazonia" - - [-10, 0] - - [-70, -50] -- "Central Africa" - - [-5, 5] - - [10, 30] -- "Indonesia" - - [-10, 10] - - [90, 150] -- "Brazil" - - [-23.5, -10] - - [-65, -30] -- "Sahel" - - [6, 16] - - [-5, 15] -- "Southern Africa" - - [-23.5, -5] - - [10, 40] -- "India" - - [10, 23.5] - - [70, 90] -- "Indochina" - - [10, 23.5] - - [90, 120] -- "Sahara Desert" - - [16, 30] - - [-20, 30] -- "Arabian Peninsula" - - [16, 30] - - [35, 60] -- "Australia" - - [-30, -20] - - [110, 145] -- "Central Asia" - - [35, 50] - - [55, 70] -- "Mongolia" - - [40, 50] - - [85, 120] -- "Tibetan Plateau" - - [30, 40] - - [80, 100] -- "Central Asia" - - [40, 50] - - [40, 100] -- "NE China" - - [40, 50] - - [100, 130] -- "Eastern China" - - [30, 40] - - [100, 120] -- "Southern Asia" - - [20, 30] - - [60, 120] -- "Sahara and Arabia" - - [15, 30] - - [-15, 60] -- "MedSea and MidEast" - - [30, 45] - - [-10, 60] -- "Tigris Euphrates" - - [30, 40] - - [37, 50] +Global: + lat_bounds: [-90, 90] + lon_bounds: [-180, 180] +N Hemisphere Land: + lat_bounds: [0, 90] + lon_bounds: [-180, 180] +S Hemisphere Land: + lat_bounds: [-90, 0] + lon_bounds: [-180, 180] +Polar: + lat_bounds: [60, 90] + lon_bounds: [-180, 180] +Alaskan Arctic: + lat_bounds: [66.5, 72] + lon_bounds: [-170, -140] +Canadian Arctic: + lat_bounds: [66.5, 90] + lon_bounds: [-120, -60] +Greenland: + lat_bounds: [60, 90] + lon_bounds: [-60, -20] +Russian Arctic: + lat_bounds: [66.5, 90] + lon_bounds: [70, 170] +Antarctica: + lat_bounds: [-90, -65] + lon_bounds: [-180, 180] +Alaska: + lat_bounds: [59, 66.5] + lon_bounds: [-170, -140] +Northwest Canada: + lat_bounds: [55, 66.5] + lon_bounds: [-125, -100] +Central Canada: + lat_bounds: [50, 62] + lon_bounds: [-100, -80] +Eastern Canada: + lat_bounds: [50, 60] + lon_bounds: [-80, -55] +Northern Europe: + lat_bounds: [60, 70] + lon_bounds: [5, 45] +Western Siberia: + lat_bounds: [55, 66.5] + lon_bounds: [60, 90] +Eastern Siberia: + lat_bounds: [50, 66.5] + lon_bounds: [90, 140] +Lost Boreal Forest: + lat_bounds: [48, 56] + lon_bounds: [95, 103] +Western U.S.: + lat_bounds: [30, 50] + lon_bounds: [-130, -105] +Central U.S.: + lat_bounds: [30, 50] + lon_bounds: [-105, -90] +Eastern U.S.” + lat_bounds: [30, 50] + lon_bounds: [-90, -70] +Europe: + lat_bounds: [45, 60] + lon_bounds: [-10, 30] +Mediterranean: + lat_bounds: [34, 45] + lon_bounds: [-10, 30] +Central America: + lat_bounds: [5, 16] + lon_bounds: [-95, -75] +Amazonia: + lat_bounds: [-10, 0] + lon_bounds: [-70, -50] +Central Africa: + lat_bounds: [-5, 5] + lon_bounds: [10, 30] +Indonesia: + lat_bounds: [-10, 10] + lon_bounds: [90, 150] +Brazil: + lat_bounds: [-23.5, -10] + lon_bounds: [-65, -30] +Sahel: + lat_bounds: [6, 16] + lon_bounds: [-5, 15] +Southern Africa: + lat_bounds: [-23.5, -5] + lon_bounds: [10, 40] +India: + lat_bounds: [10, 23.5] + lon_bounds: [70, 90] +Indochina: + lat_bounds: [10, 23.5] + lon_bounds: [90, 120] +Sahara Desert: + lat_bounds: [16, 30] + lon_bounds: [-20, 30] +Arabian Peninsula: + lat_bounds: [16, 30] + lon_bounds: [35, 60] +Australia: + lat_bounds: [-30, -20] + lon_bounds: [110, 145] +Central Asia: + lat_bounds: [35, 50] + lon_bounds: [55, 70] +Mongolia: + lat_bounds: [40, 50] + lon_bounds: [85, 120] +Tibetan Plateau: + lat_bounds: [30, 40] + lon_bounds: [80, 100] +Central Asia: + lat_bounds: [40, 50] + lon_bounds: [40, 100] +NE China: + lat_bounds: [40, 50] + lon_bounds: [100, 130] +Eastern China: + lat_bounds: [30, 40] + lon_bounds: [100, 120] +Southern Asia: + lat_bounds: [20, 30] + lon_bounds: [60, 120] +Sahara and Arabia: + lat_bounds: [15, 30] + lon_bounds: [-15, 60] +MedSea and MidEast: + lat_bounds: [30, 45] + lon_bounds: [-10, 60] +Tigris Euphrates: + lat_bounds: [30, 40] + lon_bounds: [37, 50] From 57b4df13598a9074a7071822d342614478151447 Mon Sep 17 00:00:00 2001 From: Meg Fowler Date: Thu, 8 May 2025 15:33:19 -0600 Subject: [PATCH 068/126] Update to use yml and improve plots --- config_clm_unstructured_plots.yaml | 25 +-- lib/regions_lnd.yaml | 265 +++++++++++------------ scripts/plotting/regional_climatology.py | 144 +++++++----- 3 files changed, 227 insertions(+), 207 deletions(-) diff --git a/config_clm_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml index 4f612d4f3..339571ac6 100644 --- a/config_clm_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -269,7 +269,7 @@ regridding_scripts: #List of analysis scripts being used. #These scripts must be located in "scripts/analysis": analysis_scripts: - - lmwg_table + # - lmwg_table #List of plotting scripts being used. #These scripts must be located in "scripts/plotting": @@ -289,7 +289,7 @@ diag_var_list: #- NPP #- FSDS #- ALTMAX - - ALBD + # - ALBD - ET - RAIN - SNOW @@ -304,6 +304,10 @@ diag_var_list: # - MEG_isoprene region_list: + - Global + - N Hemisphere Land + - S Hemisphere Land + - Polar - Alaskan Arctic - Canadian Arctic - Greenland @@ -316,9 +320,9 @@ region_list: - Northern Europe - Western Siberia - Eastern Siberia - - Western U.S. - - Central U.S. - - Eastern U.S. + - Western US + - Central US + - Eastern US - Europe - Mediterranean - Central America @@ -333,18 +337,9 @@ region_list: - Sahara Desert - Arabian Peninsula - Australia - # - Central Asia ## Broken... probably because there are two? + - Central Asia ## Was Broken... probably because there were two? - Mongolia - Tibetan Plateau - # - Central Asia - # - NE China # But why did this one break? - # - Eastern China - # - Southern Asia - # - Sahara and Arabia - # - MedSea and MidEast - # - Tigris Euphrates - # - Polar - # - Lost Boreal Forest diff --git a/lib/regions_lnd.yaml b/lib/regions_lnd.yaml index 93dc825af..31cdd99f9 100644 --- a/lib/regions_lnd.yaml +++ b/lib/regions_lnd.yaml @@ -2,136 +2,135 @@ # - lat (-90 to 90) # - lon (-180 to 180) -Region: -- "Global" - - [-90, 90] - - [-180, 180] -- "N. Hemisphere Land" - - [0, 90] - - [-180, 180] -- "S. Hemisphere Land" - - [-90, 0] - - [-180, 180] -- "Polar" - - [60, 90] - - [-180, 180] -- "Alaskan Arctic" - - [66.5, 72] - - [-170, -140] -- "Canadian Arctic" - - [66.5, 90] - - [-120, -60] -- "Greenland" - - [60, 90] - - [-60, -20] -- "Russian Arctic" - - [66.5, 90] - - [70, 170] -- "Antarctica" - - [-90, -65] - - [-180, 180] -- "Alaska" - - [59, 66.5] - - [-170, -140] -- "Northwest Canada" - - [55, 66.5] - - [-125, -100] -- "Central Canada" - - [50, 62] - - [-100, -80] -- "Eastern Canada" - - [50, 60] - - [-80, -55] -- "Northern Europe" - - [60, 70] - - [5, 45] -- "Western Siberia" - - [55, 66.5] - - [60, 90] -- "Eastern Siberia" - - [50, 66.5] - - [90, 140] -- "Lost Boreal Forest" - - [48, 56] - - [95, 103] -- "Western U.S." - - [30, 50] - - [-130, -105] -- "Central U.S." - - [30, 50] - - [-105, -90] -- "Eastern U.S.” - - [30, 50] - - [-90, -70] -- "Europe" - - [45, 60] - - [-10, 30] -- "Mediterranean" - - [34, 45] - - [-10, 30] -- "Central America" - - [5, 16] - - [-95, -75] -- "Amazonia" - - [-10, 0] - - [-70, -50] -- "Central Africa" - - [-5, 5] - - [10, 30] -- "Indonesia" - - [-10, 10] - - [90, 150] -- "Brazil" - - [-23.5, -10] - - [-65, -30] -- "Sahel" - - [6, 16] - - [-5, 15] -- "Southern Africa" - - [-23.5, -5] - - [10, 40] -- "India" - - [10, 23.5] - - [70, 90] -- "Indochina" - - [10, 23.5] - - [90, 120] -- "Sahara Desert" - - [16, 30] - - [-20, 30] -- "Arabian Peninsula" - - [16, 30] - - [35, 60] -- "Australia" - - [-30, -20] - - [110, 145] -- "Central Asia" - - [35, 50] - - [55, 70] -- "Mongolia" - - [40, 50] - - [85, 120] -- "Tibetan Plateau" - - [30, 40] - - [80, 100] -- "Central Asia" - - [40, 50] - - [40, 100] -- "NE China" - - [40, 50] - - [100, 130] -- "Eastern China" - - [30, 40] - - [100, 120] -- "Southern Asia" - - [20, 30] - - [60, 120] -- "Sahara and Arabia" - - [15, 30] - - [-15, 60] -- "MedSea and MidEast" - - [30, 45] - - [-10, 60] -- "Tigris Euphrates" - - [30, 40] - - [37, 50] +Global: + lat_bounds: [-90, 90] + lon_bounds: [-180, 180] +N Hemisphere Land: + lat_bounds: [0, 90] + lon_bounds: [-180, 180] +S Hemisphere Land: + lat_bounds: [-90, 0] + lon_bounds: [-180, 180] +Polar: + lat_bounds: [60, 90] + lon_bounds: [-180, 180] +Alaskan Arctic: + lat_bounds: [66.5, 72] + lon_bounds: [-170, -140] +Canadian Arctic: + lat_bounds: [66.5, 90] + lon_bounds: [-120, -60] +Greenland: + lat_bounds: [60, 90] + lon_bounds: [-60, -20] +Russian Arctic: + lat_bounds: [66.5, 90] + lon_bounds: [70, 170] +Antarctica: + lat_bounds: [-90, -65] + lon_bounds: [-180, 180] +Alaska: + lat_bounds: [59, 66.5] + lon_bounds: [-170, -140] +Northwest Canada: + lat_bounds: [55, 66.5] + lon_bounds: [-125, -100] +Central Canada: + lat_bounds: [50, 62] + lon_bounds: [-100, -80] +Eastern Canada: + lat_bounds: [50, 60] + lon_bounds: [-80, -55] +Northern Europe: + lat_bounds: [60, 70] + lon_bounds: [5, 45] +Western Siberia: + lat_bounds: [55, 66.5] + lon_bounds: [60, 90] +Eastern Siberia: + lat_bounds: [50, 66.5] + lon_bounds: [90, 140] +Lost Boreal Forest: + lat_bounds: [48, 56] + lon_bounds: [95, 103] +Western US: + lat_bounds: [30, 50] + lon_bounds: [-130, -105] +Central US: + lat_bounds: [30, 50] + lon_bounds: [-105, -90] +Eastern US: + lat_bounds: [30, 50] + lon_bounds: [-90, -70] +Europe: + lat_bounds: [45, 60] + lon_bounds: [-10, 30] +Mediterranean: + lat_bounds: [34, 45] + lon_bounds: [-10, 30] +Central America: + lat_bounds: [5, 16] + lon_bounds: [-95, -75] +Amazonia: + lat_bounds: [-10, 0] + lon_bounds: [-70, -50] +Central Africa: + lat_bounds: [-5, 5] + lon_bounds: [10, 30] +Indonesia: + lat_bounds: [-10, 10] + lon_bounds: [90, 150] +Brazil: + lat_bounds: [-23.5, -10] + lon_bounds: [-65, -30] +Sahel: + lat_bounds: [6, 16] + lon_bounds: [-5, 15] +Southern Africa: + lat_bounds: [-23.5, -5] + lon_bounds: [10, 40] +India: + lat_bounds: [10, 23.5] + lon_bounds: [70, 90] +Indochina: + lat_bounds: [10, 23.5] + lon_bounds: [90, 120] +Sahara Desert: + lat_bounds: [16, 30] + lon_bounds: [-20, 30] +Arabian Peninsula: + lat_bounds: [16, 30] + lon_bounds: [35, 60] +Australia: + lat_bounds: [-30, -20] + lon_bounds: [110, 145] +Central Asia: + lat_bounds: [35, 50] + lon_bounds: [55, 70] +Mongolia: + lat_bounds: [40, 50] + lon_bounds: [85, 120] +Tibetan Plateau: + lat_bounds: [30, 40] + lon_bounds: [80, 100] +Central Asia 2: + lat_bounds: [40, 50] + lon_bounds: [40, 100] +NE China: + lat_bounds: [40, 50] + lon_bounds: [100, 130] +Eastern China: + lat_bounds: [30, 40] + lon_bounds: [100, 120] +Southern Asia: + lat_bounds: [20, 30] + lon_bounds: [60, 120] +Sahara and Arabia: + lat_bounds: [15, 30] + lon_bounds: [-15, 60] +MedSea and MidEast: + lat_bounds: [30, 45] + lon_bounds: [-10, 60] +Tigris Euphrates: + lat_bounds: [30, 40] + lon_bounds: [37, 50] \ No newline at end of file diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 9f63276bb..9822b321d 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -1,5 +1,6 @@ from pathlib import Path import numpy as np +import yaml import xarray as xr import uxarray as ux import matplotlib.pyplot as plt @@ -62,29 +63,34 @@ def regional_climatology(adfobj): 'QOVER', 'QDRAI','QRGWL','QSNOFRZ','QSNOMELT', 'QSNWCPICE','ALBD'] - ## Open file containing regions of interest - nc_reg_file = '/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/code/resources/region_definitions.nc' - regionDS = xr.open_dataset(nc_reg_file) - region_names = [str(item).split('b')[1] for item in regionDS.PTITSTR.values] + # ## Open file containing regions of interest + # nc_reg_file = '/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/code/resources/region_definitions.nc' + # regionDS = xr.open_dataset(nc_reg_file) + # region_names = [str(item).split('b')[1] for item in regionDS.PTITSTR.values] ## Open observations YML here? - # I want to get the indices that match the reqeusted regions now... - region_indexList = [] - cleaned_candidates = [s.strip("'\"") for s in region_names] - cleaned_candidates = [s.strip(" ") for s in cleaned_candidates] - - # Fix some region names I've broken - cleaned_candidates = rename_region(cleaned_candidates, 'Western Si', 'Western Siberia') - cleaned_candidates = rename_region(cleaned_candidates, 'Eastern Si', 'Eastern Siberia') - cleaned_candidates = rename_region(cleaned_candidates, 'Ara', 'Arabian Peninsula') - cleaned_candidates = rename_region(cleaned_candidates, 'Sahara and Ara', 'Sahara and Arabia') - cleaned_candidates = rename_region(cleaned_candidates, 'Ti', 'Tibetan Plateau') - - for iReg in region_list: - match_indices = [i for i, region in enumerate(cleaned_candidates) if iReg == region] - region_indexList = np.append(region_indexList, match_indices) - region_indexList =region_indexList.astype('int') + ## Read regions from yml file: + ymlFilename = 'lib/regions_lnd.yaml' + with open(ymlFilename, 'r') as file: + regions = yaml.safe_load(file) + + # # I want to get the indices that match the reqeusted regions now... + # region_indexList = [] + # cleaned_candidates = [s.strip("'\"") for s in region_names] + # cleaned_candidates = [s.strip(" ") for s in cleaned_candidates] + + # # Fix some region names I've broken + # cleaned_candidates = rename_region(cleaned_candidates, 'Western Si', 'Western Siberia') + # cleaned_candidates = rename_region(cleaned_candidates, 'Eastern Si', 'Eastern Siberia') + # cleaned_candidates = rename_region(cleaned_candidates, 'Ara', 'Arabian Peninsula') + # cleaned_candidates = rename_region(cleaned_candidates, 'Sahara and Ara', 'Sahara and Arabia') + # cleaned_candidates = rename_region(cleaned_candidates, 'Ti', 'Tibetan Plateau') + + # for iReg in region_list: + # match_indices = [i for i, region in enumerate(cleaned_candidates) if iReg == region] + # region_indexList = np.append(region_indexList, match_indices) + # region_indexList =region_indexList.astype('int') # Extract variables: @@ -122,11 +128,13 @@ def regional_climatology(adfobj): wgt = area * landfrac / (area * landfrac).sum() # Loop over regions for selected variable - for iReg in range(len(region_indexList)): - regionDS_thisRg = regionDS.isel(region=region_indexList[iReg]) - + for iReg in range(len(region_list)): + # regionDS_thisRg = regionDS.isel(region=region_indexList[iReg]) + box_west, box_east, box_south, box_north = get_region_boundaries(regions, region_list[iReg]) ## Set up figure - fig,axs = plt.subplots(4,5, figsize=(15,10)) + # fig,axs = plt.subplots(4,5, figsize=(15,10)) + ## TODO: Make the plot size/number of subplots resopnsive to number of fields specified + fig,axs = plt.subplots(4,4, figsize=(18,12)) axs = axs.ravel() plt_counter = 1 @@ -138,13 +146,13 @@ def regional_climatology(adfobj): else: # TODO: handle regular gridded case base_var,wgt_sub = getRegion_uxarray(uxgrid, base_data, field, wgt, - regionDS_thisRg.BOX_W.values, regionDS_thisRg.BOX_E.values, - regionDS_thisRg.BOX_S.values, regionDS_thisRg.BOX_N.values) + box_west, box_east, + box_south, box_north) base_var_wgtd = np.sum(base_var * wgt_sub, axis=-1) / np.sum(wgt_sub) case_var,wgt_sub = getRegion_uxarray(uxgrid, case_data, field, wgt, - regionDS_thisRg.BOX_W.values, regionDS_thisRg.BOX_E.values, - regionDS_thisRg.BOX_S.values, regionDS_thisRg.BOX_N.values) + box_west, box_east, + box_south, box_north) case_var_wgtd = np.sum(case_var * wgt_sub, axis=-1) / np.sum(wgt_sub) ## Plot the map: @@ -166,26 +174,32 @@ def regional_climatology(adfobj): map_ax.coastlines() map_ax.add_collection(collection) map_ax.set_global() - map_ax.set_title(region_names[iReg]+'\n'+str(regionDS["BOXSTR"].values[iReg])) # Add map extent selection - if ((regionDS_thisRg.BOX_S.values >= 30) & (regionDS_thisRg.BOX_E.values<=-5) ): - map_ax.set_extent([-180, -5, 30, 90],crs=ccrs.PlateCarree()) - elif ((regionDS_thisRg.BOX_S.values >= 30) & (regionDS_thisRg.BOX_E.values>=-5) ): - map_ax.set_extent([-5, 179, 30, 90],crs=ccrs.PlateCarree()) - elif ((regionDS_thisRg.BOX_S.values <= 30) & (regionDS_thisRg.BOX_S.values >= -30) & - (regionDS_thisRg.BOX_E.values<=-5) ): - map_ax.set_extent([-180, -5, -30, 30],crs=ccrs.PlateCarree()) - elif ((regionDS_thisRg.BOX_S.values <= 30) & (regionDS_thisRg.BOX_S.values >= -30) & - (regionDS_thisRg.BOX_E.values>=-5) ): - map_ax.set_extent([-5, 179, -30, 30],crs=ccrs.PlateCarree()) - elif ((regionDS_thisRg.BOX_S.values <= -30) & (regionDS_thisRg.BOX_S.values >= -60) & - (regionDS_thisRg.BOX_E.values>=-5) ): - map_ax.set_extent([-5, 179, -89, -30],crs=ccrs.PlateCarree()) - elif ((regionDS_thisRg.BOX_S.values <= -30) & (regionDS_thisRg.BOX_S.values >= -60) & - (regionDS_thisRg.BOX_E.values<=-5) ): - map_ax.set_extent([-180, -5, -89, -30],crs=ccrs.PlateCarree()) - elif ((regionDS_thisRg.BOX_S.values <= -60)): - map_ax.set_extent([-180, 179, -89, -60],crs=ccrs.PlateCarree()) + if region_list[iReg]=='N Hemisphere Land': + map_ax.set_extent([-180, -3, 179, 90],crs=ccrs.PlateCarree()) + elif region_list[iReg]=='Global': + map_ax.set_extent([-180, -90, 179, 90],crs=ccrs.PlateCarree()) + elif region_list[iReg]=='S Hemisphere Land': + map_ax.set_extent([-180, -90, 179, 3],crs=ccrs.PlateCarree()) + else: + if ((box_south >= 30) & (box_east<=-5) ): + map_ax.set_extent([-180, -5, 30, 90],crs=ccrs.PlateCarree()) + elif ((box_south >= 30) & (box_east>=-5) ): + map_ax.set_extent([-5, 179, 30, 90],crs=ccrs.PlateCarree()) + elif ((box_south <= 30) & (box_south >= -30) & + (box_east<=-5) ): + map_ax.set_extent([-180, -5, -30, 30],crs=ccrs.PlateCarree()) + elif ((box_south <= 30) & (box_south >= -30) & + (box_east>=-5) ): + map_ax.set_extent([-5, 179, -30, 30],crs=ccrs.PlateCarree()) + elif ((box_south <= -30) & (box_south >= -60) & + (box_east>=-5) ): + map_ax.set_extent([-5, 179, -89, -30],crs=ccrs.PlateCarree()) + elif ((box_south <= -30) & (box_south >= -60) & + (box_east<=-5) ): + map_ax.set_extent([-180, -5, -89, -30],crs=ccrs.PlateCarree()) + elif ((box_south <= -60)): + map_ax.set_extent([-180, 179, -89, -60],crs=ccrs.PlateCarree()) ## Plot the timeseries @@ -202,6 +216,8 @@ def regional_climatology(adfobj): plt_counter = plt_counter+1 + fig.subplots_adjust(hspace=0.3, wspace=0.3) + # Save out figure # fileFriendlyRegionName = plot_loc = Path(plot_locations[0]) / f'RegionalClimo_{region_list[iReg]}_RegionalClimo_Mean.{plot_type}' @@ -250,16 +266,26 @@ def getRegion_uxarray(gridDS, varDS, varName, wgt, BOX_W, BOX_E, BOX_S, BOX_N): return domain_subset,wgt_subset -def rename_region(DS, searchStr, replaceStr): - iReplace = np.where(np.asarray(DS)==searchStr)[0] - if len(iReplace)==1: - DS[int(iReplace)] = replaceStr - elif len(iReplace>1): - # This happens with Tibetan Plateau; there are two defined - # Indices 31 and 35 - # Same values, but Box_W and Box_E are swapped.. going to keep the first - DS[int(iReplace[0])] = replaceStr - # print('Found more than one match for ',searchStr) - # print(iReplace) +def get_region_boundaries(regions, region_name): + """Get the boundaries of a specific region.""" + if region_name not in regions: + raise ValueError(f"Region '{region_name}' not found in regions dictionary") + + region = regions[region_name] + south, north = region['lat_bounds'] + west, east = region['lon_bounds'] + + return west, east, south, north +# def rename_region(DS, searchStr, replaceStr): +# iReplace = np.where(np.asarray(DS)==searchStr)[0] +# if len(iReplace)==1: +# DS[int(iReplace)] = replaceStr +# elif len(iReplace>1): +# # This happens with Tibetan Plateau; there are two defined +# # Indices 31 and 35 +# # Same values, but Box_W and Box_E are swapped.. going to keep the first +# DS[int(iReplace[0])] = replaceStr +# # print('Found more than one match for ',searchStr) +# # print(iReplace) - return DS \ No newline at end of file +# return DS \ No newline at end of file From f1f1612a240c6159eea86b23768af4cfc8ef68d8 Mon Sep 17 00:00:00 2001 From: Meg Fowler Date: Thu, 8 May 2025 15:33:47 -0600 Subject: [PATCH 069/126] Update to yml file --- scripts/plotting/regional_climatology.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 9822b321d..1f5732c35 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -176,11 +176,11 @@ def regional_climatology(adfobj): map_ax.set_global() # Add map extent selection if region_list[iReg]=='N Hemisphere Land': - map_ax.set_extent([-180, -3, 179, 90],crs=ccrs.PlateCarree()) + map_ax.set_extent([-180, 179, -3, 90],crs=ccrs.PlateCarree()) elif region_list[iReg]=='Global': - map_ax.set_extent([-180, -90, 179, 90],crs=ccrs.PlateCarree()) + map_ax.set_extent([-180, 179, -89, 90],crs=ccrs.PlateCarree()) elif region_list[iReg]=='S Hemisphere Land': - map_ax.set_extent([-180, -90, 179, 3],crs=ccrs.PlateCarree()) + map_ax.set_extent([-180, 179, -89, 3],crs=ccrs.PlateCarree()) else: if ((box_south >= 30) & (box_east<=-5) ): map_ax.set_extent([-180, -5, 30, 90],crs=ccrs.PlateCarree()) From 40e716d55e136d1e11db0f00eb2467eab3b1c7cc Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 8 May 2025 15:42:23 -0600 Subject: [PATCH 070/126] turn on climo years --- config_clm_native_grid_to_latlon.yaml | 28 +++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/config_clm_native_grid_to_latlon.yaml b/config_clm_native_grid_to_latlon.yaml index 658bd674f..960041000 100644 --- a/config_clm_native_grid_to_latlon.yaml +++ b/config_clm_native_grid_to_latlon.yaml @@ -170,13 +170,13 @@ diag_cam_climo: #model year when climatology should start: #Note: Leaving this entry blank will make time series - # end at latest available year. - #climo_start_year: 35 + # start at the first available year + climo_start_year: 35 #model year when climatology should end: #Note: Leaving this entry blank will make time series # end at latest available year. - #climo_end_year: 40 + climo_end_year: 40 #Do time series files exist? #If True, then diagnostics assumes that model files are already time series. @@ -253,13 +253,13 @@ diag_cam_baseline_climo: #model year when climatology should start: #Note: Leaving this entry blank will make time series - # end at latest available year. - #climo_start_year: 35 + # start at first available year. + climo_start_year: 35 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - #climo_end_year: 40 + climo_end_year: 40 #Do time series files need to be generated? #If True, then diagnostics assumes that model files are already time series. @@ -313,16 +313,16 @@ plotting_scripts: #List of CAM variables that will be processesd: #If CVDP is to be run PSL, TREFHT, TS and PRECT (or PRECC and PRECL) should be listed diag_var_list: - #- TSA - - PREC - - ELAI - - GPP + - TSA + #- PREC + #- ELAI + #- GPP #- NPP #- FSDS #- ALTMAX - - ET - - TOTRUNOFF - - DSTFLXT - - MEG_isoprene + #- ET + #- TOTRUNOFF + #- DSTFLXT + #- MEG_isoprene #END OF FILE From 10aa5caaa01a47a6958d7eb66f308a1ce22d63ac Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 23 Jul 2025 15:21:14 -0600 Subject: [PATCH 071/126] fix xarray np plotting issue, as in 399 --- config_clm_BvsI.yml | 15 ++++--- config_clm_native_grid_to_latlon.yaml | 18 ++++---- config_clm_structured_plots.yaml | 34 ++++++++------- config_clm_unstructured_plots.yaml | 63 +++++++++++++-------------- lib/plotting_functions.py | 4 +- 5 files changed, 69 insertions(+), 65 deletions(-) diff --git a/config_clm_BvsI.yml b/config_clm_BvsI.yml index 7abb9b8a7..bab3f2c0c 100644 --- a/config_clm_BvsI.yml +++ b/config_clm_BvsI.yml @@ -58,7 +58,7 @@ # Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script # to check for a failure to customize # -user: 'USER-NAME-NOT-SET' +user: wwieder #'USER-NAME-NOT-SET' #This first set of variables specify basic info used by all diagnostic runs: diag_basic_info: @@ -102,7 +102,7 @@ diag_basic_info: #Longitude line on which to center all lat/lon maps. #If this config option is missing then the central #longitude will default to 180 degrees E. - central_longitude: 180 + central_longitude: 0 #Number of processors on which to run the ADF. #If this config variable isn't present then @@ -287,12 +287,13 @@ diag_var_list: - PREC - ELAI - GPP - #- NPP + - NPP - FSDS - #- ALTMAX + - ALTMAX - ET - #- TOTRUNOFF - #- DSTFLXT - #- MEG_isoprene + - GRAINC_TO_FOOD + - TOTRUNOFF + - DSTFLXT + - MEG_isoprene #END OF FILE diff --git a/config_clm_native_grid_to_latlon.yaml b/config_clm_native_grid_to_latlon.yaml index 960041000..fb19eed08 100644 --- a/config_clm_native_grid_to_latlon.yaml +++ b/config_clm_native_grid_to_latlon.yaml @@ -58,7 +58,7 @@ # Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script # to check for a failure to customize # -user: 'USER-NAME-NOT-SET' +user: 'wwieder' #'USER-NAME-NOT-SET' #This first set of variables specify basic info used by all diagnostic runs: diag_basic_info: @@ -84,7 +84,7 @@ diag_basic_info: obs_data_loc: /glade/campaign/cgd/amp/amwg/ADF_obs #Location where re-gridded and interpolated CAM climatology files are stored: - cam_regrid_loc: /glade/derecho/scratch/${user}/ADF_LatLon/regrid + cam_regrid_loc: /glade/derecho/scratch/${user}/ADF_LatLon2/regrid #Overwrite CAM re-gridded files? #If false, or missing, then regridding will be skipped for regridded variables @@ -92,7 +92,7 @@ diag_basic_info: cam_overwrite_regrid: false #Location where diagnostic plots are stored: - cam_diag_plot_loc: /glade/derecho/scratch/${user}/ADF_LatLon/plots + cam_diag_plot_loc: /glade/derecho/scratch/${user}/ADF_LatLon2/plots #Location of ADF variable plotting defaults YAML file: #If left blank or missing, ADF/lib/adf_variable_defaults.yaml will be used @@ -134,7 +134,7 @@ diag_cam_climo: cam_overwrite_climo: false #Location of CAM climatologies (to be created and then used by this script) - cam_climo_loc: /glade/derecho/scratch/${user}/ADF_LatLon/${diag_cam_climo.cam_case_name}/climo + cam_climo_loc: /glade/derecho/scratch/${user}/ADF_LatLon2/${diag_cam_climo.cam_case_name}/climo #Name of CAM case (or CAM run name): cam_case_name: b.e30_alpha06b.B1850C_LTso.ne30_t232_wgx3.143 @@ -194,7 +194,7 @@ diag_cam_climo: cam_overwrite_ts: false #Location where time series files are (or will be) stored: - cam_ts_loc: /glade/derecho/scratch/${user}/ADF_LatLon/${diag_cam_climo.cam_case_name}/ts + cam_ts_loc: /glade/derecho/scratch/${user}/ADF_LatLon2/${diag_cam_climo.cam_case_name}/ts #This third set of variables provide info for the CAM baseline climatologies. @@ -216,7 +216,7 @@ diag_cam_baseline_climo: cam_overwrite_climo: false #Location of CAM climatologies (to be created and then used by this script) - cam_climo_loc: /glade/derecho/scratch/${user}/ADF_LatLon/${diag_cam_baseline_climo.cam_case_name}/climo + cam_climo_loc: /glade/derecho/scratch/${user}/ADF_LatLon2/${diag_cam_baseline_climo.cam_case_name}/climo #Name of CAM baseline case: cam_case_name: b.e30_alpha06b.B1850C_LTso.ne30_t232_wgx3.139 @@ -276,7 +276,7 @@ diag_cam_baseline_climo: cam_overwrite_ts: false #Location where time series files are (or will be) stored: - cam_ts_loc: /glade/derecho/scratch/${user}/ADF_LatLon/${diag_cam_baseline_climo.cam_case_name}/ts + cam_ts_loc: /glade/derecho/scratch/${user}/ADF_LatLon2/${diag_cam_baseline_climo.cam_case_name}/ts #+++++++++++++++++++++++++++++++++++++++++++++++++++ #These variables below only matter if you are using @@ -318,9 +318,9 @@ diag_var_list: #- ELAI #- GPP #- NPP - #- FSDS + - FSDS #- ALTMAX - #- ET + - ET #- TOTRUNOFF #- DSTFLXT #- MEG_isoprene diff --git a/config_clm_structured_plots.yaml b/config_clm_structured_plots.yaml index 9601c7e42..5f5af8e62 100644 --- a/config_clm_structured_plots.yaml +++ b/config_clm_structured_plots.yaml @@ -58,7 +58,7 @@ # Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script # to check for a failure to customize # -user: 'USER-NAME-NOT-SET' +user: wwieder #'USER-NAME-NOT-SET' #This first set of variables specify basic info used by all diagnostic runs: diag_basic_info: @@ -137,16 +137,16 @@ diag_cam_climo: cam_overwrite_climo: false #Name of CAM case (or CAM run name): - cam_case_name: ctsm53026_BNF_hist + cam_case_name: ctsm53026_UpLimDestMet_sturm_pSASU_test #Case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '5.3.026_BNF' + case_nickname: 'Jordan + uldm=250' #Location of CAM history (h0) files: - cam_hist_loc: /glade/derecho/scratch/slevis/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ + cam_hist_loc: /glade/derecho/scratch/wwieder/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ # If unstructured_plotting, a mesh file is required! mesh_file: /glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc @@ -154,12 +154,12 @@ diag_cam_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 2000 + start_year: 140 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 2023 + end_year: 160 #Do time series files exist? #If True, then diagnostics assumes that model files are already time series. @@ -199,13 +199,13 @@ diag_cam_baseline_climo: cam_overwrite_climo: false #Name of CAM baseline case: - cam_case_name: ctsm53019_f09_BNF_hist + cam_case_name: ctsm53026_BNF_pSASU #Baseline case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '5.3.019_BNF' + case_nickname: 'ctsm53026_BNF_pSASU' #Location of CAM baseline history (h0) files: #Example test files @@ -220,12 +220,12 @@ diag_cam_baseline_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 2000 + start_year: 140 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 2023 + end_year: 160 #Do time series files need to be generated? #If True, then diagnostics assumes that model files are already time series. @@ -281,15 +281,19 @@ plotting_scripts: #List of variables that will be processesd: #Shorter list here, for efficiency of testing diag_var_list: - #- TSA + - TSA - PREC - ELAI - GPP - #- NPP - #- FSDS - #- ALTMAX + - NPP + - FSDS + - ALTMAX - ET - #- TOTRUNOFF + - TOTRUNOFF + - SNOWDP + - H2OSNO + - FSNO + - GRAINC_TO_FOOD - DSTFLXT - MEG_isoprene diff --git a/config_clm_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml index 339571ac6..42b45e4f9 100644 --- a/config_clm_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -58,7 +58,7 @@ # Note that the string 'USER-NAME-NOT-SET' is used in the jupyter script # to check for a failure to customize # -user: 'mdfowler' +user: wwieder #'USER-NAME-NOT-SET' #This first set of variables specify basic info used by all diagnostic runs: diag_basic_info: @@ -110,7 +110,7 @@ diag_basic_info: #you set it to "*" then it will default #to all of the processors available on a #single node/machine: - num_procs: 1 + num_procs: 8 #If set to true, then redo all plots even if they already exist. #If set to false, then if a plot is found it will be skipped: @@ -137,13 +137,13 @@ diag_cam_climo: cam_overwrite_climo: false #Name of CAM case (or CAM run name): - cam_case_name: b.e30_alpha06b.B1850C_LTso.ne30_t232_wgx3.143 + cam_case_name: b.e30_alpha06e.B1850C_LTso.ne30_t232_wgx3.156 #Case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '143' + case_nickname: '156' #Location of CAM history (h0) files: cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ @@ -154,12 +154,12 @@ diag_cam_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 30 + start_year: 122 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 40 + end_year: 152 #Do time series files exist? #If True, then diagnostics assumes that model files are already time series. @@ -199,13 +199,13 @@ diag_cam_baseline_climo: cam_overwrite_climo: false #Name of CAM baseline case: - cam_case_name: b.e30_alpha06b.B1850C_LTso.ne30_t232_wgx3.139 + cam_case_name: b.e30_alpha06e.B1850C_LTso.ne30_t232_wgx3.155 #Baseline case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '139' + case_nickname: '155' #Location of CAM baseline history (h0) files: #Example test files @@ -220,12 +220,12 @@ diag_cam_baseline_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 30 + start_year: 122 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 40 + end_year: 152 #Do time series files need to be generated? #If True, then diagnostics assumes that model files are already time series. @@ -259,25 +259,25 @@ diag_cam_baseline_climo: #Name of time-averaging scripts being used to generate climatologies. #These scripts must be located in "scripts/averaging": time_averaging_scripts: - - create_climo_files + - create_climo_files #Name of regridding scripts being used. #These scripts must be located in "scripts/regridding": regridding_scripts: - #- regrid_and_vert_interp + - regrid_and_vert_interp #List of analysis scripts being used. #These scripts must be located in "scripts/analysis": analysis_scripts: - # - lmwg_table + - lmwg_table #List of plotting scripts being used. #These scripts must be located in "scripts/plotting": plotting_scripts: - # - global_latlon_map - # - global_mean_timeseries_lnd - # - polar_map - - regional_climatology + - global_latlon_map + - global_mean_timeseries_lnd + - polar_map + - regional_climatology #List of variables that will be processesd: #Shorter list here, for efficiency of testing @@ -294,25 +294,26 @@ diag_var_list: - RAIN - SNOW - TOTRUNOFF - - QOVER - - QDRAI + - TOTVEGC + #- QOVER + #- QDRAI - QRGWL - - QSNOFRZ + #- QSNOFRZ - QSNOMELT - - QSNWCPICE + #- QSNWCPICE # - DSTFLXT # - MEG_isoprene region_list: - Global - - N Hemisphere Land - - S Hemisphere Land + #- N Hemisphere Land + #- S Hemisphere Land - Polar - Alaskan Arctic - Canadian Arctic - Greenland - Russian Arctic - - Antarctica + #- Antarctica - Alaska - Northwest Canada - Central Canada @@ -334,14 +335,12 @@ region_list: - Southern Africa - India - Indochina - - Sahara Desert - - Arabian Peninsula - - Australia - - Central Asia ## Was Broken... probably because there were two? - - Mongolia - - Tibetan Plateau - - + #- Sahara Desert + #- Arabian Peninsula + #- Australia + #- Central Asia ## Was Broken... probably because there were two? + #- Mongolia + #- Tibetan Plateau #END OF FILE diff --git a/lib/plotting_functions.py b/lib/plotting_functions.py index c980f9ab5..b9ef7c885 100644 --- a/lib/plotting_functions.py +++ b/lib/plotting_functions.py @@ -2167,7 +2167,7 @@ def prep_contour_plot(adata, bdata, diffdata, pctdata, **kwargs): # determine levels & color normalization: minval = np.min([np.min(adata), np.min(bdata)]) maxval = np.max([np.max(adata), np.max(bdata)]) - absmaxdif = np.max(np.abs(diffdata)) + absmaxdif = np.max(np.abs(diffdata.data)) absmaxpct = np.max(np.abs(pctdata)) # determine norm to use (deprecate this once minimum MPL version is high enough) @@ -2237,7 +2237,7 @@ def prep_contour_plot(adata, bdata, diffdata, pctdata, **kwargs): levelsdiff = np.arange(*kwargs['diff_contour_range']) else: # set a symmetric color bar for diff: - absmaxdif = np.max(np.abs(diffdata)) + absmaxdif = np.max(np.abs(diffdata.data)) # set levels for difference plot: levelsdiff = np.linspace(-1*absmaxdif, absmaxdif, 12) From 6e92d88d646610c41639bf72f59e1511674d5465 Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 23 Jul 2025 15:22:03 -0600 Subject: [PATCH 072/126] enable albedo calculations --- lib/adf_diag.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/lib/adf_diag.py b/lib/adf_diag.py index cbd827372..dc352996f 100644 --- a/lib/adf_diag.py +++ b/lib/adf_diag.py @@ -1366,6 +1366,8 @@ def derive_variables(self, res=None, hist_str=None, vars_to_derive=None, ts_dir= # NOTE: this will need to be changed when derived equations are more complex! - JR if var == "RESTOM": der_val = ds["FSNT"]-ds["FLNT"] + elif var == "ASA": + der_val = ds["FSR"]/ds["FSDS"].where(ds["FSDS"]>0) else: # Loop through all constituents and sum der_val = 0 From 92e7020657feb8182983e9564855938fe2bb1238 Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 23 Jul 2025 15:23:17 -0600 Subject: [PATCH 073/126] soil plotting controls --- lib/ldf_variable_defaults.yaml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/lib/ldf_variable_defaults.yaml b/lib/ldf_variable_defaults.yaml index 2a43b6cef..ea73579dd 100644 --- a/lib/ldf_variable_defaults.yaml +++ b/lib/ldf_variable_defaults.yaml @@ -328,10 +328,16 @@ TOTECOSYSC_1m: TOTSOMC_1m: category: "Carbon" + scale_factor_table: 0.000000001 #g/m2 to Pg globally + avg_method: 'sum' + table_unit: "PgC" TOTVEGC: category: "Carbon" + scale_factor_table: 0.000000001 #g/m2 to Pg globally + avg_method: 'sum' + table_unit: "PgC" #+++++++++++ From dc8e288b35a14fe4f48478fe160a8c56043d4aa3 Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 23 Jul 2025 15:49:25 -0600 Subject: [PATCH 074/126] resolved conflicts --- config_clm_structured_plots.yaml | 47 +++++++++++++++++++++++++------- 1 file changed, 37 insertions(+), 10 deletions(-) diff --git a/config_clm_structured_plots.yaml b/config_clm_structured_plots.yaml index 5f5af8e62..f519b3d13 100644 --- a/config_clm_structured_plots.yaml +++ b/config_clm_structured_plots.yaml @@ -123,7 +123,7 @@ diag_cam_climo: # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] # Only affects timeseries as everything else uses the created timeseries # Default: - hist_str: clm2.h0 + hist_str: clm2.h0a #Calculate climatologies? #If false, the climatology files will not be created: @@ -137,13 +137,13 @@ diag_cam_climo: cam_overwrite_climo: false #Name of CAM case (or CAM run name): - cam_case_name: ctsm53026_UpLimDestMet_sturm_pSASU_test + cam_case_name: ctsm53062_f09_1850 #Case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: 'Jordan + uldm=250' + case_nickname: '5.3.062_h0a' #Location of CAM history (h0) files: cam_hist_loc: /glade/derecho/scratch/wwieder/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ @@ -154,12 +154,12 @@ diag_cam_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 140 + start_year: 1 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 160 + end_year: 20 #Do time series files exist? #If True, then diagnostics assumes that model files are already time series. @@ -199,13 +199,13 @@ diag_cam_baseline_climo: cam_overwrite_climo: false #Name of CAM baseline case: - cam_case_name: ctsm53026_BNF_pSASU + cam_case_name: ctsm53061_f09_1850 #Baseline case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: 'ctsm53026_BNF_pSASU' + case_nickname: '5.3.061_h0' #Location of CAM baseline history (h0) files: #Example test files @@ -220,12 +220,12 @@ diag_cam_baseline_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 140 + start_year: 1 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 160 + end_year: 20 #Do time series files need to be generated? #If True, then diagnostics assumes that model files are already time series. @@ -297,4 +297,31 @@ diag_var_list: - DSTFLXT - MEG_isoprene -#END OF FILE +region_list: + #- Global + # - N Hemisphere Land + # - S Hemisphere Land + # - Polar + # - Alaskan Arctic + # - Canadian Arctic + # - Greenland + - Russian Arctic + # - Antarctica + # - Alaska + # - Northwest Canada + # - Central Canada + # - Eastern Canada + # - Northern Europe + # - Western Siberia + # - Eastern Siberia + # - Western US + # - Central US + # - Eastern US + # - Europe + # - Mediterranean + # - Central America + # - Amazonia + # - Central Africa + # - Indonesia + # - Brazil + From 4451e6f0c26da252ca3f4c7021d92397a38dc05f Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 6 Aug 2025 12:03:42 -0600 Subject: [PATCH 075/126] updates for regional plotting and variable defaults --- config_clm_unstructured_plots.yaml | 56 ++++++++++++------------ lib/adf_diag.py | 2 + lib/ldf_variable_defaults.yaml | 56 +++++++++++++++++++++--- scripts/plotting/regional_climatology.py | 34 +++----------- 4 files changed, 87 insertions(+), 61 deletions(-) diff --git a/config_clm_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml index 42b45e4f9..bb9a061bd 100644 --- a/config_clm_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -114,7 +114,7 @@ diag_basic_info: #If set to true, then redo all plots even if they already exist. #If set to false, then if a plot is found it will be skipped: - redo_plot: true + redo_plot: false #This second set of variables provides info for the CAM simulation(s) being diagnosed: diag_cam_climo: @@ -137,16 +137,16 @@ diag_cam_climo: cam_overwrite_climo: false #Name of CAM case (or CAM run name): - cam_case_name: b.e30_alpha06e.B1850C_LTso.ne30_t232_wgx3.156 + cam_case_name: b.e30_beta06.B1850C_LTso.ne30_t232_wgx3.188 #Case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '156' + # case_nickname: '188' #Location of CAM history (h0) files: - cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ + cam_hist_loc: /glade/derecho/scratch/gmarques/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ # If unstructured_plotting, a mesh file is required! mesh_file: /glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc @@ -154,12 +154,12 @@ diag_cam_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 122 + start_year: 76 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 152 + end_year: 95 #Do time series files exist? #If True, then diagnostics assumes that model files are already time series. @@ -199,17 +199,17 @@ diag_cam_baseline_climo: cam_overwrite_climo: false #Name of CAM baseline case: - cam_case_name: b.e30_alpha06e.B1850C_LTso.ne30_t232_wgx3.155 + cam_case_name: b.e30_beta06.B1850C_LTso.ne30_t232_wgx3.179 #Baseline case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '155' + # case_nickname: '179' #Location of CAM baseline history (h0) files: #Example test files - cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist/ + cam_hist_loc: /glade/derecho/scratch/gmarques/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist/ # If unstructured_plotting, a mesh file is required! mesh_file: /glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc @@ -220,12 +220,12 @@ diag_cam_baseline_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 122 + start_year: 76 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 152 + end_year: 95 #Do time series files need to be generated? #If True, then diagnostics assumes that model files are already time series. @@ -264,7 +264,7 @@ time_averaging_scripts: #Name of regridding scripts being used. #These scripts must be located in "scripts/regridding": regridding_scripts: - - regrid_and_vert_interp + # - regrid_and_vert_interp #List of analysis scripts being used. #These scripts must be located in "scripts/analysis": @@ -285,25 +285,25 @@ diag_var_list: - TSA - PREC - ELAI - - GPP - #- NPP - #- FSDS - #- ALTMAX - # - ALBD + - FSDS + - FLDS + - ASA + - RNET + - FSH - ET - - RAIN - - SNOW - TOTRUNOFF + - SNOWDP - TOTVEGC - #- QOVER - #- QDRAI - - QRGWL - #- QSNOFRZ - - QSNOMELT - #- QSNWCPICE - # - DSTFLXT - # - MEG_isoprene - + - GPP + - NEE + - NPP + - NBP + - BTRANMN + - TOTECOSYSC + - TOTSOMC_1m + - ALTMAX + - FAREA_BURNED + region_list: - Global #- N Hemisphere Land diff --git a/lib/adf_diag.py b/lib/adf_diag.py index dc352996f..1d846a066 100644 --- a/lib/adf_diag.py +++ b/lib/adf_diag.py @@ -1368,6 +1368,8 @@ def derive_variables(self, res=None, hist_str=None, vars_to_derive=None, ts_dir= der_val = ds["FSNT"]-ds["FLNT"] elif var == "ASA": der_val = ds["FSR"]/ds["FSDS"].where(ds["FSDS"]>0) + elif var == "RNET": + der_val = ds["FSA"]-ds["FIRA"] else: # Loop through all constituents and sum der_val = 0 diff --git a/lib/ldf_variable_defaults.yaml b/lib/ldf_variable_defaults.yaml index ea73579dd..19a84179c 100644 --- a/lib/ldf_variable_defaults.yaml +++ b/lib/ldf_variable_defaults.yaml @@ -150,16 +150,31 @@ ASA: # all-sky albedo:FSR/FSDS colormap: "RdBu_r" diff_colormap: "BrBG" derivable_from: ["FSR", "FSDS"] + new_unit: "% reflected" pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] pct_diff_colormap: "PuOr_r" +FSDS: # Incoming shortwave radiation + category: "Surface fluxes" + new_unit: "W m$^{-2}$" + +FLDS: # Incoming longwave radiation + category: "Surface fluxes" + new_unit: "W m$^{-2}$" + FSA: # absorbed solar radiation category: "Surface fluxes" + new_unit: "W m$^{-2}$" FSH: # sensible heat category: "Surface fluxes" + new_unit: "W m$^{-2}$" - +RNET: # Net Radiation: FSA-FIRA + category: "Surface fluxes" + derivable_from: ["FSA", "FIRA"] + new_unit: "W m$^{-2}$" + ET: # latent heat: FCTR+FCEV+FGEV category: "Surface fluxes" derivable_from: ["FCTR","FCEV","FGEV"] @@ -216,7 +231,6 @@ FSNO: # fraction of ground covered by snow category: "Hydrology" diff_contour_range: [-50,50,10] - H2OSNO: # SNOWICE + SNOWLIQ category: "Hydrology" diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] @@ -226,7 +240,7 @@ SNOWDP: # snow height category: "Hydrology" contour_levels: [-15.,-10.,-5.,-1.,-0.5,-0.1,0.,0.1,0.5,1.,5.,10.,15.] diff_contour_levels: [-10.,-5.,-1.,-0.5,-0.1,0.,0.1,0.5,1.,5.,10.] - + new_unit: "m" TOTRUNOFF: # total liquid runoff category: "Hydrology" @@ -250,9 +264,9 @@ BTRANMN: # Transpiration beta factor ELAI: # exposed one-sided leaf area index category: "Vegetation" colormap: "gist_earth_r" - contour_levels_range: [0., 9., 1.0] + contour_levels_range: [0., 8., 1.0] diff_colormap: "PiYG" - diff_contour_range: [-3.,3.,0.5] + diff_contour_range: [-2.,2.,0.25] HTOP: # canopy top height @@ -320,6 +334,37 @@ NPP: # Net Primary Production avg_method: 'sum' table_unit: "PgC y$^{-1}$" +NEE: # Net Ecosystem Eschange + category: "Carbon" + diff_colormap: "PiYG" + scale_factor: 86400 + add_offset: 0 + new_unit: "gC m$^{-2}$ d$^{-1}$" + mpl: + colorbar: + label : "gC m$^{-2}$ d$^{-1}$" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PiYG" + scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally + avg_method: 'sum' + table_unit: "PgC y$^{-1}$" + +NBP: # Net Biome Production + category: "Carbon" + colormap: "gist_earth_r" + diff_colormap: "PiYG" + scale_factor: 86400 + add_offset: 0 + new_unit: "gC m$^{-2}$ d$^{-1}$" + mpl: + colorbar: + label : "gC m$^{-2}$ d$^{-1}$" + pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] + pct_diff_colormap: "PiYG" + scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally + avg_method: 'sum' + table_unit: "PgC y$^{-1}$" + TOTECOSYSC_1m: category: "Carbon" scale_factor_table: 0.000000001 #g/m2 to Pg globally @@ -332,7 +377,6 @@ TOTSOMC_1m: avg_method: 'sum' table_unit: "PgC" - TOTVEGC: category: "Carbon" scale_factor_table: 0.000000001 #g/m2 to Pg globally diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 1f5732c35..b48fcd84b 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -59,14 +59,12 @@ def regional_climatology(adfobj): base_nickname = adfobj.get_baseline_info('case_nickname') region_list = adfobj.region_list - regional_climo_var_list = ['GPP','ELAI','TSA','PREC','RAIN','SNOW', 'TOTRUNOFF', - 'QOVER', 'QDRAI','QRGWL','QSNOFRZ','QSNOMELT', - 'QSNWCPICE','ALBD'] - - # ## Open file containing regions of interest - # nc_reg_file = '/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/code/resources/region_definitions.nc' - # regionDS = xr.open_dataset(nc_reg_file) - # region_names = [str(item).split('b')[1] for item in regionDS.PTITSTR.values] + #TODO, make it easier for users decide on these? + regional_climo_var_list = ['TSA','PREC','ELAI', + 'FSDS','FLDS','ASA','RNET', + 'FSH','TOTRUNOFF','ET','SNOWDP', + 'TOTVEGC','GPP','NEE','BTRANMN', + ] ## Open observations YML here? @@ -75,24 +73,6 @@ def regional_climatology(adfobj): with open(ymlFilename, 'r') as file: regions = yaml.safe_load(file) - # # I want to get the indices that match the reqeusted regions now... - # region_indexList = [] - # cleaned_candidates = [s.strip("'\"") for s in region_names] - # cleaned_candidates = [s.strip(" ") for s in cleaned_candidates] - - # # Fix some region names I've broken - # cleaned_candidates = rename_region(cleaned_candidates, 'Western Si', 'Western Siberia') - # cleaned_candidates = rename_region(cleaned_candidates, 'Eastern Si', 'Eastern Siberia') - # cleaned_candidates = rename_region(cleaned_candidates, 'Ara', 'Arabian Peninsula') - # cleaned_candidates = rename_region(cleaned_candidates, 'Sahara and Ara', 'Sahara and Arabia') - # cleaned_candidates = rename_region(cleaned_candidates, 'Ti', 'Tibetan Plateau') - - # for iReg in region_list: - # match_indices = [i for i, region in enumerate(cleaned_candidates) if iReg == region] - # region_indexList = np.append(region_indexList, match_indices) - # region_indexList =region_indexList.astype('int') - - # Extract variables: baseline_name = adfobj.get_baseline_info("cam_case_name", required=True) input_climo_baseline = Path(adfobj.get_baseline_info("cam_climo_loc", required=True)) @@ -288,4 +268,4 @@ def get_region_boundaries(regions, region_name): # # print('Found more than one match for ',searchStr) # # print(iReplace) -# return DS \ No newline at end of file +# return DS From 615ca7f25925d7234721b3655ca995fc2c0f98fe Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 6 Aug 2025 13:41:52 -0600 Subject: [PATCH 076/126] removing duplicate vars --- lib/ldf_variable_defaults.yaml | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/lib/ldf_variable_defaults.yaml b/lib/ldf_variable_defaults.yaml index 19a84179c..87e0e487b 100644 --- a/lib/ldf_variable_defaults.yaml +++ b/lib/ldf_variable_defaults.yaml @@ -117,6 +117,7 @@ FSDS: # atmospheric incident solar radiation category: "Atmosphere" pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] pct_diff_colormap: "PuOr_r" + new_unit: "W m$^{-2}$" WIND: # atmospheric air temperature category: "Atmosphere" @@ -154,14 +155,6 @@ ASA: # all-sky albedo:FSR/FSDS pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] pct_diff_colormap: "PuOr_r" -FSDS: # Incoming shortwave radiation - category: "Surface fluxes" - new_unit: "W m$^{-2}$" - -FLDS: # Incoming longwave radiation - category: "Surface fluxes" - new_unit: "W m$^{-2}$" - FSA: # absorbed solar radiation category: "Surface fluxes" new_unit: "W m$^{-2}$" From 24bac17d34c32f19d8e19c7cb02fbb710d1cab78 Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 7 Aug 2025 12:04:13 -0600 Subject: [PATCH 077/126] fix regional plot landing page --- scripts/plotting/regional_climatology.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index b48fcd84b..f251edf33 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -200,7 +200,7 @@ def regional_climatology(adfobj): # Save out figure # fileFriendlyRegionName = - plot_loc = Path(plot_locations[0]) / f'RegionalClimo_{region_list[iReg]}_RegionalClimo_Mean.{plot_type}' + plot_loc = Path(plot_locations[0]) / f'{region_list[iReg]}_plot_RegionalClimo_Mean.{plot_type}' #Set path for variance figures: # plot_loc = Path(plot_locations[0]) / f'RegionalClimo_{region_list[iReg]}.{plot_type}' # print(plot_loc) @@ -210,7 +210,7 @@ def regional_climatology(adfobj): if (not redo_plot) and plot_loc.is_file(): #Add already-existing plot to website (if enabled): adfobj.debug_log(f"'{plot_loc}' exists and clobber is false.") - adfobj.add_website_data(plot_loc, "RegionalClimo", None, season=region_list[iReg], multi_case=True, non_season=True, plot_type = "RegionalClimo") + adfobj.add_website_data(plot_loc, region_list[iReg], None, season=None, multi_case=True, non_season=True, plot_type = "RegionalClimo") #Continue to next iteration: return @@ -222,7 +222,7 @@ def regional_climatology(adfobj): plt.close() #Add plot to website (if enabled): - adfobj.add_website_data(plot_loc, "RegionalClimo", None, season=region_list[iReg], multi_case=True, non_season=True, plot_type = "RegionalClimo") + adfobj.add_website_data(plot_loc, region_list[iReg], None, season=None, multi_case=True, non_season=True, plot_type = "RegionalClimo") return From bdad45f79c5350e379296a020ae09122a1ac3f83 Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 7 Aug 2025 14:54:48 -0600 Subject: [PATCH 078/126] correct polar map --- scripts/plotting/regional_climatology.py | 15 ++------------- 1 file changed, 2 insertions(+), 13 deletions(-) diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index f251edf33..23cbe8253 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -161,6 +161,8 @@ def regional_climatology(adfobj): map_ax.set_extent([-180, 179, -89, 90],crs=ccrs.PlateCarree()) elif region_list[iReg]=='S Hemisphere Land': map_ax.set_extent([-180, 179, -89, 3],crs=ccrs.PlateCarree()) + elif region_list[iReg]=='Polar': + map_ax.set_extent([-180, 179, 45, 90],crs=ccrs.PlateCarree()) else: if ((box_south >= 30) & (box_east<=-5) ): map_ax.set_extent([-180, -5, 30, 90],crs=ccrs.PlateCarree()) @@ -256,16 +258,3 @@ def get_region_boundaries(regions, region_name): west, east = region['lon_bounds'] return west, east, south, north -# def rename_region(DS, searchStr, replaceStr): -# iReplace = np.where(np.asarray(DS)==searchStr)[0] -# if len(iReplace)==1: -# DS[int(iReplace)] = replaceStr -# elif len(iReplace>1): -# # This happens with Tibetan Plateau; there are two defined -# # Indices 31 and 35 -# # Same values, but Box_W and Box_E are swapped.. going to keep the first -# DS[int(iReplace[0])] = replaceStr -# # print('Found more than one match for ',searchStr) -# # print(iReplace) - -# return DS From 370e39860d0011d32ab04cf69cfe8337a69ab625 Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 7 Aug 2025 16:31:20 -0600 Subject: [PATCH 079/126] start reading in obs --- config_clm_unstructured_plots.yaml | 6 +- scripts/plotting/regional_climatology.py | 92 ++++++++++++++++++++++++ 2 files changed, 95 insertions(+), 3 deletions(-) diff --git a/config_clm_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml index bb9a061bd..627d51a3f 100644 --- a/config_clm_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -81,7 +81,7 @@ diag_basic_info: #Location of observational datasets: #Note: this only matters if "compare_obs" is true and the path #isn't specified in the variable defaults file. - obs_data_loc: /glade/campaign/cgd/amp/amwg/ADF_obs + obs_data_loc: /glade/campaign/cgd/tss/people/oleson/lnd_diag_data/obs_data #Location where re-gridded and interpolated CAM climatology files are stored: cam_regrid_loc: /glade/derecho/scratch/${user}/ADF_unstruct/regrid @@ -143,7 +143,7 @@ diag_cam_climo: #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - # case_nickname: '188' + case_nickname: '188' #Location of CAM history (h0) files: cam_hist_loc: /glade/derecho/scratch/gmarques/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ @@ -205,7 +205,7 @@ diag_cam_baseline_climo: #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - # case_nickname: '179' + case_nickname: '179' #Location of CAM baseline history (h0) files: #Example test files diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 23cbe8253..93b78b53b 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -89,13 +89,105 @@ def regional_climatology(adfobj): kwargs["mesh_file"] = mesh_file kwargs["unstructured_plotting"] = unstruct_plotting + #Determine local directory: + _adf_lib_dir = adfobj.get_basic_info("obs_data_loc") + + #Determine whether to use adf defaults or custom: + _defaults_file = adfobj.get_basic_info('defaults_file') + if _defaults_file is None: + _defaults_file = _adf_lib_dir/'adf_variable_defaults.yaml' + else: + print(f"\n\t Not using ADF default variables yaml file, instead using {_defaults_file}\n") + #End if + + #Open YAML file: + with open(_defaults_file, encoding='UTF-8') as dfil: + adfobj.__variable_defaults = yaml.load(dfil, Loader=yaml.SafeLoader) + + _variable_defaults = adfobj.__variable_defaults + + #----------------------------------------- + #Extract the "obs_data_loc" default observational data location: + obs_data_loc = adfobj.get_basic_info("obs_data_loc") + base_data = {} case_data = {} + obs_data = {} + + var_obs_dict = adfobj.var_obs_dict + # First, load all variable data once (instead of inside nested loops) for field in regional_climo_var_list: # Load the global climatology for this variable base_data[field] = adfobj.data.load_reference_climo_da(baseline_name, field, **kwargs) case_data[field] = adfobj.data.load_climo_da(case_name, field, **kwargs) + + if field in _variable_defaults: + # Extract variable-obs dictionary + default_var_dict = _variable_defaults[field] + + #Check if an observations file is specified: + if "obs_file" in default_var_dict: + #Set found variable: + found = False + + #Extract path/filename: + obs_file_path = Path(default_var_dict["obs_file"]) + + #Check if file exists: + if not obs_file_path.is_file(): + #If not, then check if it is in "obs_data_loc" + if obs_data_loc: + obs_file_path = Path(obs_data_loc)/obs_file_path + + if obs_file_path.is_file(): + found = True + + else: + #File was found: + found = True + #End if + + #If found, then set observations dataset and variable names: + if found: + #Check if observations dataset name is specified: + if "obs_name" in default_var_dict: + obs_name = default_var_dict["obs_name"] + else: + #If not, then just use obs file name: + obs_name = obs_file_path.name + + #Check if observations variable name is specified: + if "obs_var_name" in default_var_dict: + #If so, then set obs_var_name variable: + obs_var_name = default_var_dict["obs_var_name"] + else: + #Assume observation variable name is the same ad model variable: + obs_var_name = field + #End if + #Finally read in the obs! + print(default_var_dict) + obs_data = xr.open_mfdataset([default_var_dict["obs_file"]], combine="by_coords") + print(obs_data) + + else: + #If not found, then print to log and skip variable: + msg = f'''Unable to find obs file '{default_var_dict["obs_file"]}' ''' + msg += f"for variable '{field}'." + adfobj.debug_log(msg) + continue + #End if + + else: + #No observation file was specified, so print + #to log and skip variable: + adfobj.debug_log(f"No observations file was listed for variable '{field}'.") + continue + else: + #Variable not in defaults file, so print to log and skip variable: + msg = f"Variable '{field}' not found in variable defaults file: `{_defaults_file}`" + adfobj.debug_log(msg) + #End if if type(base_data[field]) is type(None): print('Missing file for ', field) From 679894f72b867234b62920a031d45f8b9cd6ea22 Mon Sep 17 00:00:00 2001 From: wwieder Date: Tue, 12 Aug 2025 17:04:47 -0600 Subject: [PATCH 080/126] update for config files --- config_clm_structured_plots.yaml | 111 +++++++++++++++++------------ config_clm_unstructured_plots.yaml | 2 +- 2 files changed, 68 insertions(+), 45 deletions(-) diff --git a/config_clm_structured_plots.yaml b/config_clm_structured_plots.yaml index f519b3d13..59fbac8f6 100644 --- a/config_clm_structured_plots.yaml +++ b/config_clm_structured_plots.yaml @@ -110,11 +110,11 @@ diag_basic_info: #you set it to "*" then it will default #to all of the processors available on a #single node/machine: - num_procs: 1 + num_procs: 8 #If set to true, then redo all plots even if they already exist. #If set to false, then if a plot is found it will be skipped: - redo_plot: true + redo_plot: false #This second set of variables provides info for the CAM simulation(s) being diagnosed: diag_cam_climo: @@ -137,13 +137,13 @@ diag_cam_climo: cam_overwrite_climo: false #Name of CAM case (or CAM run name): - cam_case_name: ctsm53062_f09_1850 + cam_case_name: ctsm53065_54surfdata_PPEcal115_115_HIST #Case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '5.3.062_h0a' + case_nickname: 'PPE_115_HIST' #Location of CAM history (h0) files: cam_hist_loc: /glade/derecho/scratch/wwieder/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ @@ -154,12 +154,14 @@ diag_cam_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 1 + start_year: 1850 + climo_start_year: 2004 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 20 + end_year: 2023 + climo_end_year: 2023 #Do time series files exist? #If True, then diagnostics assumes that model files are already time series. @@ -199,17 +201,17 @@ diag_cam_baseline_climo: cam_overwrite_climo: false #Name of CAM baseline case: - cam_case_name: ctsm53061_f09_1850 + cam_case_name: ctsm53041_54surfdata_PPEbaseline_101_HIST #Baseline case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '5.3.061_h0' + case_nickname: 'PPE_101_HIST' #Location of CAM baseline history (h0) files: #Example test files - cam_hist_loc: /glade/derecho/scratch/slevis/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist/ + cam_hist_loc: /glade/derecho/scratch/wwieder/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist/ # If unstructured_plotting, a mesh file is required! mesh_file: /glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc @@ -220,12 +222,14 @@ diag_cam_baseline_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 1 + start_year: 1850 + climo_start_year: 2004 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 20 + end_year: 2023 + climo_end_year: 2023 #Do time series files need to be generated? #If True, then diagnostics assumes that model files are already time series. @@ -277,6 +281,7 @@ plotting_scripts: - global_latlon_map - global_mean_timeseries_lnd - polar_map + - regional_climatology #List of variables that will be processesd: #Shorter list here, for efficiency of testing @@ -284,44 +289,62 @@ diag_var_list: - TSA - PREC - ELAI - - GPP - - NPP - FSDS - - ALTMAX + - FLDS + - ASA + - RNET + - FSH - ET - - TOTRUNOFF + - QRUNOFF_TO_COUPLER - SNOWDP - - H2OSNO - - FSNO - - GRAINC_TO_FOOD + - TOTVEGC + - GPP + - NEE + - NPP + - NBP + - BTRANMN + - TOTECOSYSC + - TOTSOMC_1m + - ALTMAX + - FAREA_BURNED - DSTFLXT - MEG_isoprene - + region_list: - #- Global - # - N Hemisphere Land - # - S Hemisphere Land - # - Polar - # - Alaskan Arctic - # - Canadian Arctic - # - Greenland + - Global + - N Hemisphere Land + #- S Hemisphere Land + - Polar + - Alaskan Arctic + - Canadian Arctic + #- Greenland - Russian Arctic - # - Antarctica - # - Alaska - # - Northwest Canada - # - Central Canada - # - Eastern Canada - # - Northern Europe - # - Western Siberia - # - Eastern Siberia - # - Western US - # - Central US - # - Eastern US - # - Europe - # - Mediterranean - # - Central America - # - Amazonia - # - Central Africa - # - Indonesia - # - Brazil + #- Antarctica + - Alaska + #- Northwest Canada + #- Central Canada + - Eastern Canada + - Northern Europe + - Western Siberia + - Eastern Siberia + - Western US + #- Central US + #- Eastern US + #- Europe + #- Mediterranean + #- Central America + - Amazonia + - Central Africa + - Indonesia + - Brazil + - Sahel + - Southern Africa + - India + #- Indochina + #- Sahara Desert + #- Arabian Peninsula + #- Australia + #- Central Asia ## Was Broken... probably because there were two? + #- Mongolia + #- Tibetan Plateau diff --git a/config_clm_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml index 627d51a3f..c0c299531 100644 --- a/config_clm_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -291,7 +291,7 @@ diag_var_list: - RNET - FSH - ET - - TOTRUNOFF + - QRUNOFF_TO_COUPLER - SNOWDP - TOTVEGC - GPP From 66c131bf907531b6ee31a7d9373c07dd79d1f68e Mon Sep 17 00:00:00 2001 From: wwieder Date: Tue, 12 Aug 2025 17:05:27 -0600 Subject: [PATCH 081/126] minor cleaning --- lib/adf_obs.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/adf_obs.py b/lib/adf_obs.py index 2f7be03b2..ddf561cdd 100644 --- a/lib/adf_obs.py +++ b/lib/adf_obs.py @@ -114,7 +114,7 @@ def __init__(self, config_file, debug=False): #Extract the "obs_data_loc" default observational data location: obs_data_loc = self.get_basic_info("obs_data_loc") - + print(obs_data_loc) #Loop over variable list: for var in self.diag_var_list: From 633a5f3224b364525416317a756e0fad99ed5841 Mon Sep 17 00:00:00 2001 From: wwieder Date: Tue, 12 Aug 2025 17:06:06 -0600 Subject: [PATCH 082/126] improve regional plots --- lib/ldf_variable_defaults.yaml | 48 ++++- scripts/plotting/regional_climatology.py | 219 +++++++++++++++++------ 2 files changed, 214 insertions(+), 53 deletions(-) diff --git a/lib/ldf_variable_defaults.yaml b/lib/ldf_variable_defaults.yaml index 87e0e487b..b00cc06d1 100644 --- a/lib/ldf_variable_defaults.yaml +++ b/lib/ldf_variable_defaults.yaml @@ -82,7 +82,12 @@ TSA: # 2m air temperature contour_levels_range: [250, 310, 10] diff_colormap: "coolwarm" pct_diff_colormap: "coolwarm" - + scale_factor: 1 + add_offset: 0 + new_unit: "K" + obs_file: "/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/obs_data/WILLMOTT_ALLMONS_climo.nc" + obs_name: "WILMONT" + obs_var_name: "TSA" # K PREC: # RAIN + SNOW category: "Atmosphere" @@ -91,6 +96,9 @@ PREC: # RAIN + SNOW scale_factor: 86400 add_offset: 0 new_unit: "mm d$^{-1}$" + obs_file: "/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/obs_data/GPCPv2.3_ALLMONS_climo.nc" + obs_name: "GCPCv2.3" + obs_var_name: "PREC" #mm/d mpl: colorbar: label : "mm d$^{-1}$" @@ -154,6 +162,12 @@ ASA: # all-sky albedo:FSR/FSDS new_unit: "% reflected" pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] pct_diff_colormap: "PuOr_r" + # TODO, Keith will clarify what obs to use and we'll also have to figure out grid weights for regional averaging + ## First file has weights, but no clear variable for ASA + # obs_file: "/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/obs_data/T42_MODIS_ALLMONS_climo.070523.nc" + # obs_file: "/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/obs_data/modisradweighted.nc" + # obs_data: "MODIS" + # obs_var_name: "BRDALB" #TODO FSA: # absorbed solar radiation category: "Surface fluxes" @@ -183,6 +197,9 @@ ET: # latent heat: FCTR+FCEV+FGEV label : "W m$^{-2}$" pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] pct_diff_colormap: "BrBG" + obs_file: "/glade/campaign/cgd/tss/people/oleson/lnd_diag_data/obs_data/MR_LHF_0.9x1.25_ALLMONS_climo.nc" + obs_name: "FLUXNET" + obs_var_name: "LHF" #W m$^{-2}$ DSTFLXT: # total surface dust emission category: "Surface fluxes" @@ -248,6 +265,21 @@ TOTRUNOFF: # total liquid runoff colorbar: label : "mm d$^{-1}$" +QRUNOFF_TO_COUPLER: # runoff to coupler + category: "Hydrology" + colormap: "Blues" + scale_factor: 86400 + add_offset: 0 + new_unit: "mm d$^{-1}$" + contour_levels: [-0.1,0.,0.1,0.2,0.3,1.,2.,3.,] + diff_contour_range: [-1.,1.,0.1] + mpl: + colorbar: + label : "mm d$^{-1}$" + obs_file: "/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/obs_data/GRUN_ALLMONS_climo.nc" + obs_name: "GRUN" + obs_var_name: "RUNOFF" #mm/d + #+++++++++++ # Category: Vegetation #+++++++++++ @@ -260,7 +292,11 @@ ELAI: # exposed one-sided leaf area index contour_levels_range: [0., 8., 1.0] diff_colormap: "PiYG" diff_contour_range: [-2.,2.,0.25] - + new_unit: "m${-2}$ m${-2}$" + obs_file: "/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/obs_data/MODIS_LAI_ALLMONS_climo.nc" + obs_name: "MODIS" + obs_var_name: "TLAI" + HTOP: # canopy top height category: "Vegetation" @@ -268,7 +304,10 @@ HTOP: # canopy top height TSAI: # total one-sided stem area index category: "Vegetation" - + new_unit: "m${-2}$ m${-2}$" + obs_file: "/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/obs_data/MODIS_LAI_ALLMONS_climo.nc" + obs_name: "MODIS" + obs_var_name: "TSAI" #+++++++++++ # Category: Carbon @@ -290,6 +329,9 @@ GPP: # Gross Primary Production scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally avg_method: 'sum' table_unit: "PgC y$^{-1}$" + obs_file: "/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/obs_data/MR_GPP_0.9x1.25_ALLMONS_climo.nc" + obs_name: "FLUXNET" + obs_var_name: "GPP" #gC m$^{-2}$ d$^{-1}$ AR: # Autotrophic Respiration category: "Carbon" diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 93b78b53b..409847d5f 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -28,7 +28,23 @@ def regional_climatology(adfobj): - increase number of variables that have a climo plotted; i've just added two, but left room for more in the subplots - check that all varaibles have climo files; likely to break otherwise - - add option so that this works with a structured grid too + - add option so that this works with a structured grid too # ...existing code... + if found: + #Check if observations dataset name is specified: + if "obs_name" in default_var_dict: + obs_name = default_var_dict["obs_name"] + else: + obs_name = obs_file_path.name + + if "obs_var_name" in default_var_dict: + obs_var_name = default_var_dict["obs_var_name"] + else: + obs_var_name = field + + # Use the resolved obs_file_path, not the original string + obs_data[field] = xr.open_mfdataset([str(obs_file_path)], combine="by_coords") + plot_obs[field] = True + # ...existing code... - make sure that climo's are being plotted with the preferred units - add in observations (need to regrid/area weight) - need to figure out how to display the figures on the website @@ -36,7 +52,7 @@ def regional_climatology(adfobj): """ #Notify user that script has started: - print("\n Generating global mean time series plots...") + print("\n --- Generating regional climatology plots... ---") # Gather ADF configurations # plot_loc = adfobj.get_basic_info('cam_diag_plot_loc') @@ -45,7 +61,7 @@ def regional_climatology(adfobj): plot_type = adfobj.get_basic_info('plot_type') if not plot_type: plot_type = 'png' - # res = adfobj.variable_defaults # will be dict of variable-specific plot preferences + #res = adfobj.variable_defaults # will be dict of variable-specific plot preferences # or an empty dictionary if use_defaults was not specified in YAML. # check if existing plots need to be redone @@ -53,7 +69,7 @@ def regional_climatology(adfobj): print(f"\t NOTE: redo_plot is set to {redo_plot}") unstruct_plotting = adfobj.unstructured_plotting - print("unstruct_plotting", unstruct_plotting) + print(f"\t unstruct_plotting", unstruct_plotting) case_nickname = adfobj.get_cam_info('case_nickname') base_nickname = adfobj.get_baseline_info('case_nickname') @@ -62,7 +78,7 @@ def regional_climatology(adfobj): #TODO, make it easier for users decide on these? regional_climo_var_list = ['TSA','PREC','ELAI', 'FSDS','FLDS','ASA','RNET', - 'FSH','TOTRUNOFF','ET','SNOWDP', + 'FSH','QRUNOFF_TO_COUPLER','ET','SNOWDP', 'TOTVEGC','GPP','NEE','BTRANMN', ] @@ -113,15 +129,40 @@ def regional_climatology(adfobj): base_data = {} case_data = {} obs_data = {} + obs_name = {} + obs_var_name = {} + plot_obs = {} var_obs_dict = adfobj.var_obs_dict # First, load all variable data once (instead of inside nested loops) for field in regional_climo_var_list: # Load the global climatology for this variable + # TODO unit conversions are not handled consistently here base_data[field] = adfobj.data.load_reference_climo_da(baseline_name, field, **kwargs) case_data[field] = adfobj.data.load_climo_da(case_name, field, **kwargs) - + + if type(base_data[field]) is type(None): + print('Missing file for ', field) + continue + else: + mdataset = adfobj.data.load_climo_dataset(case_name, field, **kwargs) + area = mdataset.area.isel(time=0) # drop time dimension to avoid confusion + landfrac = mdataset.landfrac.isel(time=0) + # Redundant, but we'll do this for consistency: + # TODO, won't handle loadling the basecase this way + #mdataset_base = adfobj.data.load_climo_dataset(baseline_name, field, **kwargs) + #area_base = mdataset_base.area.isel(time=0) + #landfrac_base = mdataset_base.landfrac.isel(time=0) + + # calculate weights + # WW: 1) should actual weight calculation be done after subsetting to region? + # 2) Does this work as intended for different resolutions? + # wgt = area * landfrac # / (area * landfrac).sum() + + #----------------------------------------- + # Now, check if observations are to be plotted for this variable + plot_obs[field] = False if field in _variable_defaults: # Extract variable-obs dictionary default_var_dict = _variable_defaults[field] @@ -152,23 +193,22 @@ def regional_climatology(adfobj): if found: #Check if observations dataset name is specified: if "obs_name" in default_var_dict: - obs_name = default_var_dict["obs_name"] + obs_name[field] = default_var_dict["obs_name"] else: #If not, then just use obs file name: - obs_name = obs_file_path.name + obs_name[field] = obs_file_path.name #Check if observations variable name is specified: if "obs_var_name" in default_var_dict: #If so, then set obs_var_name variable: - obs_var_name = default_var_dict["obs_var_name"] + obs_var_name[field] = default_var_dict["obs_var_name"] else: - #Assume observation variable name is the same ad model variable: - obs_var_name = field + #Assume observation variable name is the same as model variable: + obs_var_name[field] = field #End if #Finally read in the obs! - print(default_var_dict) - obs_data = xr.open_mfdataset([default_var_dict["obs_file"]], combine="by_coords") - print(obs_data) + obs_data[field] = xr.open_mfdataset([default_var_dict["obs_file"]], combine="by_coords") + plot_obs[field] = True else: #If not found, then print to log and skip variable: @@ -176,59 +216,77 @@ def regional_climatology(adfobj): msg += f"for variable '{field}'." adfobj.debug_log(msg) continue - #End if + # End if else: - #No observation file was specified, so print - #to log and skip variable: + #No observation file was specified, so print to log and skip variable: adfobj.debug_log(f"No observations file was listed for variable '{field}'.") continue else: #Variable not in defaults file, so print to log and skip variable: msg = f"Variable '{field}' not found in variable defaults file: `{_defaults_file}`" adfobj.debug_log(msg) - #End if - - if type(base_data[field]) is type(None): - print('Missing file for ', field) - continue - else: - mdataset = adfobj.data.load_climo_dataset(case_name, field, **kwargs) - area = mdataset.area - landfrac = mdataset.landfrac - # calculate weights - wgt = area * landfrac / (area * landfrac).sum() + # End if + # End of observation loading + #----------------------------------------- + #----------------------------------------- # Loop over regions for selected variable - for iReg in range(len(region_list)): + for iReg in range(len(region_list)): + print(f"\n\t - Plotting regional climatology for: {region_list[iReg]}") # regionDS_thisRg = regionDS.isel(region=region_indexList[iReg]) box_west, box_east, box_south, box_north = get_region_boundaries(regions, region_list[iReg]) ## Set up figure - # fig,axs = plt.subplots(4,5, figsize=(15,10)) ## TODO: Make the plot size/number of subplots resopnsive to number of fields specified fig,axs = plt.subplots(4,4, figsize=(18,12)) axs = axs.ravel() plt_counter = 1 for field in regional_climo_var_list: - mdataset = adfobj.data.load_climo_dataset(case_name, field, **kwargs) + mdataset = adfobj.data.load_climo_dataset(case_name, field, **kwargs) if type(base_data[field]) is type(None): continue else: # TODO: handle regular gridded case - base_var,wgt_sub = getRegion_uxarray(uxgrid, base_data, field, wgt, - box_west, box_east, - box_south, box_north) - base_var_wgtd = np.sum(base_var * wgt_sub, axis=-1) / np.sum(wgt_sub) + if unstruct_plotting == True: + # uxarray output is time*nface, sum over nface + base_var,wgt_sub = getRegion_uxarray(uxgrid, base_data, field, area, landfrac, + box_west, box_east, + box_south, box_north) + base_var_wgtd = np.sum(base_var * wgt_sub, axis=-1) # WW not needed?/ np.sum(wgt_sub) + + case_var,wgt_sub = getRegion_uxarray(uxgrid, case_data, field, area, landfrac, + box_west, box_east, + box_south, box_north) + case_var_wgtd = np.sum(case_var * wgt_sub, axis=-1) #/ np.sum(wgt_sub) - case_var,wgt_sub = getRegion_uxarray(uxgrid, case_data, field, wgt, - box_west, box_east, - box_south, box_north) - case_var_wgtd = np.sum(case_var * wgt_sub, axis=-1) / np.sum(wgt_sub) + else: # regular lat/lon grid + # xarray output is time*lat*lon, sum over lat/lon + base_var, wgt_sub = getRegion_xarray(base_data[field], field, + box_west, box_east, + box_south, box_north, + area, landfrac) + base_var_wgtd = np.sum(base_var * wgt_sub, axis=(1,2)) + + case_var, wgt_sub = getRegion_xarray(case_data[field], field, + box_west, box_east, + box_south, box_north, + area, landfrac) + case_var_wgtd = np.sum(case_var * wgt_sub, axis=(1,2)) + + # Read in observations, if available + if plot_obs[field] == True: + # obs output is time*lat*lon, sum over lat/lon + obs_var, wgt_sub = getRegion_xarray(obs_data[field], field, + box_west, box_east, + box_south, box_north, + obs_var_name=obs_var_name[field]) + obs_var_wgtd = np.sum(obs_var * wgt_sub, axis=(1,2)) #/ np.sum(wgt_sub) ## Plot the map: - if plt_counter==1: + if plt_counter==1 and unstruct_plotting == True: + ## this only works for unstructured plotting: ## Define region in first subplot fig.delaxes(axs[0]) @@ -274,15 +332,25 @@ def regional_climatology(adfobj): map_ax.set_extent([-180, -5, -89, -30],crs=ccrs.PlateCarree()) elif ((box_south <= -60)): map_ax.set_extent([-180, 179, -89, -60],crs=ccrs.PlateCarree()) - + # End if for plotting map extent - ## Plot the timeseries + ## Plot the climatology: if type(base_data[field]) is type(None): # print('Missing file for ', field) continue else: - axs[plt_counter].plot(np.arange(12)+1, case_var_wgtd,label=case_nickname) - axs[plt_counter].plot(np.arange(12)+1, base_var_wgtd,label=base_nickname) + # TODO handle unit conversions correctly + if field == 'GPP': + case_var_wgtd = case_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day + base_var_wgtd = base_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day + + axs[plt_counter].plot(np.arange(12)+1, case_var_wgtd, + label=case_nickname, linewidth=2) + axs[plt_counter].plot(np.arange(12)+1, base_var_wgtd, + label=base_nickname, linewidth=2) + if plot_obs[field] == True: + axs[plt_counter].plot(np.arange(12)+1, obs_var_wgtd, + label=obs_name[field], color='black', linewidth=2) axs[plt_counter].set_title(field) axs[plt_counter].set_ylabel(base_data[field].units) axs[plt_counter].legend() @@ -304,7 +372,8 @@ def regional_climatology(adfobj): if (not redo_plot) and plot_loc.is_file(): #Add already-existing plot to website (if enabled): adfobj.debug_log(f"'{plot_loc}' exists and clobber is false.") - adfobj.add_website_data(plot_loc, region_list[iReg], None, season=None, multi_case=True, non_season=True, plot_type = "RegionalClimo") + adfobj.add_website_data(plot_loc, region_list[iReg], None, season=None, multi_case=True, + non_season=True, plot_type = "RegionalClimo") #Continue to next iteration: return @@ -316,11 +385,14 @@ def regional_climatology(adfobj): plt.close() #Add plot to website (if enabled): - adfobj.add_website_data(plot_loc, region_list[iReg], None, season=None, multi_case=True, non_season=True, plot_type = "RegionalClimo") + adfobj.add_website_data(plot_loc, region_list[iReg], None, season=None, multi_case=True, + non_season=True, plot_type = "RegionalClimo") return -def getRegion_uxarray(gridDS, varDS, varName, wgt, BOX_W, BOX_E, BOX_S, BOX_N): +print("\n --- Regional climatology plots generated successfully! ---") + +def getRegion_uxarray(gridDS, varDS, varName, area, landfrac, BOX_W, BOX_E, BOX_S, BOX_N): # Method 2: Filter mesh nodes based on coordinates node_lons = gridDS.face_lon node_lats = gridDS.face_lat @@ -334,9 +406,56 @@ def getRegion_uxarray(gridDS, varDS, varName, wgt, BOX_W, BOX_E, BOX_S, BOX_N): # Subset the dataset using these node indices domain_subset = varDS[varName].isel(n_face=node_indices) - wgt_subset = wgt.isel(n_face=node_indices) + area_subset = area.isel(n_face=node_indices) + landfrac_subset = landfrac.isel(n_face=node_indices) + wgt_subset = area_subset * landfrac_subset / (area_subset* landfrac_subset).sum() # area_subset = varDS['area'].isel(n_face=node_indices) - # lf_subset = varDS['landfrac'].isel(n_face=node_indices) + # lf_subset = varDS['landfrac'].isel(n_face=node_indices) + return domain_subset,wgt_subset + +def getRegion_xarray(varDS, varName, + BOX_W, BOX_E, BOX_S, BOX_N, + area=None, landfrac=None, + obs_var_name=None): + # Assumes regular lat/lon grid in xarray Dataset + # Assumes varDS has 'lon' and 'lat' coordinates w/ lon in [0,360] + # Convert BOX_W and BOX_E to [0,360] if necessary + # Also assumes global weights have already been calculated & masked appropriately + if (BOX_W == -180) & (BOX_E == 180): + BOX_W, BOX_E = 0, 360 # Special case for global domain + if BOX_W < 0: BOX_W = BOX_W + 360 + if BOX_E < 0: BOX_E = BOX_E + 360 + + if varName not in varDS: + varName = obs_var_name + #if varName == 'ELAI': varName = 'TLAI' + #if varName == 'ET': varName = 'LHF' + + # TODO is there a less brittle way to do this? + if (area is not None) and (landfrac is not None): + weight = area * landfrac + elif 'weight' in varDS: + weight = varDS['weight'] * varDS['datamask'] + elif 'area' in varDS and 'landfrac' in varDS: + weight = varDS['area'] * varDS['landfrac'] + elif 'area' in varDS and 'landmask' in varDS: + weight = varDS['area'] * varDS['landmask'] + # Fluxnet data also has a datamask + if 'datamask' in varDS: + weight = weight * varDS['datamask'] + else: + raise ValueError("No valid weight, area, or landmask found in {varName} dataset.") + + # check we have a data array for the variable + if isinstance(varDS, xr.Dataset): + varDS = varDS[varName] + + # Subset the dataarray using the specified box + domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N), + lon=slice(BOX_W, BOX_E)) + weight_subset = weight.sel(lat=slice(BOX_S, BOX_N), + lon=slice(BOX_W, BOX_E)) + wgt_subset = weight_subset / weight_subset.sum() return domain_subset,wgt_subset @@ -349,4 +468,4 @@ def get_region_boundaries(regions, region_name): south, north = region['lat_bounds'] west, east = region['lon_bounds'] - return west, east, south, north + return west, east, south, north \ No newline at end of file From 9ba561fa60bd601859ddf084f308aa82a8f4477a Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 13 Aug 2025 16:17:10 -0600 Subject: [PATCH 083/126] correct albedo calculation --- lib/adf_diag.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/adf_diag.py b/lib/adf_diag.py index 1d846a066..f78161b80 100644 --- a/lib/adf_diag.py +++ b/lib/adf_diag.py @@ -1367,7 +1367,7 @@ def derive_variables(self, res=None, hist_str=None, vars_to_derive=None, ts_dir= if var == "RESTOM": der_val = ds["FSNT"]-ds["FLNT"] elif var == "ASA": - der_val = ds["FSR"]/ds["FSDS"].where(ds["FSDS"]>0) + der_val = 100*ds["FSR"]/ds["FSDS"].where(ds["FSDS"]>0) elif var == "RNET": der_val = ds["FSA"]-ds["FIRA"] else: From 2533ededb335a157ae63585672ffc0f09b63e609 Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 13 Aug 2025 16:34:59 -0600 Subject: [PATCH 084/126] bring in albedo obs --- config_clm_structured_plots.yaml | 4 +++ config_clm_unstructured_plots.yaml | 3 ++ lib/ldf_variable_defaults.yaml | 36 ++++++++++++++++++++++-- scripts/plotting/regional_climatology.py | 26 +++++++++++------ 4 files changed, 57 insertions(+), 12 deletions(-) diff --git a/config_clm_structured_plots.yaml b/config_clm_structured_plots.yaml index 59fbac8f6..4e9a577d4 100644 --- a/config_clm_structured_plots.yaml +++ b/config_clm_structured_plots.yaml @@ -292,9 +292,13 @@ diag_var_list: - FSDS - FLDS - ASA + - QBOT - RNET - FSH - ET + - FCTR + - FGEV + - FCEV - QRUNOFF_TO_COUPLER - SNOWDP - TOTVEGC diff --git a/config_clm_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml index c0c299531..75061eef7 100644 --- a/config_clm_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -291,6 +291,9 @@ diag_var_list: - RNET - FSH - ET + - FCTR + - FGEV + - FCEV - QRUNOFF_TO_COUPLER - SNOWDP - TOTVEGC diff --git a/lib/ldf_variable_defaults.yaml b/lib/ldf_variable_defaults.yaml index b00cc06d1..682ec9686 100644 --- a/lib/ldf_variable_defaults.yaml +++ b/lib/ldf_variable_defaults.yaml @@ -132,6 +132,9 @@ WIND: # atmospheric air temperature QBOT: # atmospheric specific humidity category: "Atmosphere" + scale_factor: 1 + add_offset: 0 + #new_unit: "W m$^{-2}$" TBOT: category: "Atmosphere" @@ -165,9 +168,9 @@ ASA: # all-sky albedo:FSR/FSDS # TODO, Keith will clarify what obs to use and we'll also have to figure out grid weights for regional averaging ## First file has weights, but no clear variable for ASA # obs_file: "/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/obs_data/T42_MODIS_ALLMONS_climo.070523.nc" - # obs_file: "/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/obs_data/modisradweighted.nc" - # obs_data: "MODIS" - # obs_var_name: "BRDALB" #TODO + obs_file: "/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/obs_data/modisradweighted.nc" + obs_data: "MODIS" + obs_var_name: "BRDALB" FSA: # absorbed solar radiation category: "Surface fluxes" @@ -201,6 +204,33 @@ ET: # latent heat: FCTR+FCEV+FGEV obs_name: "FLUXNET" obs_var_name: "LHF" #W m$^{-2}$ +FCTR: # Canopy transpiration latent heat flux + category: "Surface fluxes" + scale_factor: 1 + add_offset: 0 + new_unit: "W m$^{-2}$" + mpl: + colorbar: + label : "W m$^{-2}$" + +FCEV: # Canopy evaporation of latent heat flux + category: "Surface fluxes" + scale_factor: 1 + add_offset: 0 + new_unit: "W m$^{-2}$" + mpl: + colorbar: + label : "W m$^{-2}$" + +FGEV: # Ground evaporation latent heat flux + category: "Surface fluxes" + scale_factor: 1 + add_offset: 0 + new_unit: "W m$^{-2}$" + mpl: + colorbar: + label : "W m$^{-2}$" + DSTFLXT: # total surface dust emission category: "Surface fluxes" colormap: "copper_r" diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 409847d5f..0f3825af0 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -5,7 +5,6 @@ import uxarray as ux import matplotlib.pyplot as plt import cartopy.crs as ccrs -# import plotting_functions as pf import warnings # use to warn user about missing files. def my_formatwarning(msg, *args, **kwargs): @@ -77,9 +76,9 @@ def regional_climatology(adfobj): region_list = adfobj.region_list #TODO, make it easier for users decide on these? regional_climo_var_list = ['TSA','PREC','ELAI', - 'FSDS','FLDS','ASA','RNET', - 'FSH','QRUNOFF_TO_COUPLER','ET','SNOWDP', - 'TOTVEGC','GPP','NEE','BTRANMN', + 'FSDS','FLDS','QBOT','ASA', + 'FSH','QRUNOFF_TO_COUPLER','ET','FCTR', + 'GPP','BTRANMN','FCEV','FGEV', ] ## Open observations YML here? @@ -209,6 +208,10 @@ def regional_climatology(adfobj): #Finally read in the obs! obs_data[field] = xr.open_mfdataset([default_var_dict["obs_file"]], combine="by_coords") plot_obs[field] = True + # Special handling for some variables:, NOT A GOOD HACK! + # TODO: improve this! + if (field == 'ASA') and ('BRDALB' in obs_data[field].variables): + obs_data[field]['BRDALB'] = obs_data[field]['BRDALB'].swap_dims({'lsmlat':'lat','lsmlon':'lon'}) else: #If not found, then print to log and skip variable: @@ -339,10 +342,11 @@ def regional_climatology(adfobj): # print('Missing file for ', field) continue else: - # TODO handle unit conversions correctly - if field == 'GPP': - case_var_wgtd = case_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day - base_var_wgtd = base_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day + # TODO handle unit conversions correctly, working for structured, but not unstructured yet + if unstruct_plotting == True: + if (field == 'GPP') or (field == 'NEE') or (field == 'NBP'): + case_var_wgtd = case_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day + base_var_wgtd = base_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day axs[plt_counter].plot(np.arange(12)+1, case_var_wgtd, label=case_nickname, linewidth=2) @@ -353,6 +357,7 @@ def regional_climatology(adfobj): label=obs_name[field], color='black', linewidth=2) axs[plt_counter].set_title(field) axs[plt_counter].set_ylabel(base_data[field].units) + axs[plt_counter].set_xticks(np.arange(1, 13, 2)) axs[plt_counter].legend() @@ -434,8 +439,11 @@ def getRegion_xarray(varDS, varName, # TODO is there a less brittle way to do this? if (area is not None) and (landfrac is not None): weight = area * landfrac - elif 'weight' in varDS: + elif ('weight' in varDS) and ('datamask' in varDS): weight = varDS['weight'] * varDS['datamask'] + elif ('weight' in varDS) and ('LANDFRAC' in varDS): + #used for MODIS albedo product + weight = varDS['weight'] * varDS['LANDFRAC'] elif 'area' in varDS and 'landfrac' in varDS: weight = varDS['area'] * varDS['landfrac'] elif 'area' in varDS and 'landmask' in varDS: From 5c83af7c46d87b114a1dccb76d704ca8e14b8aa6 Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 13 Aug 2025 16:38:16 -0600 Subject: [PATCH 085/126] calculate cum NBP --- scripts/plotting/global_mean_timeseries_lnd.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/scripts/plotting/global_mean_timeseries_lnd.py b/scripts/plotting/global_mean_timeseries_lnd.py index 7a1436df2..d5be517e1 100644 --- a/scripts/plotting/global_mean_timeseries_lnd.py +++ b/scripts/plotting/global_mean_timeseries_lnd.py @@ -93,7 +93,7 @@ def global_mean_timeseries_lnd(adfobj): ref_ts_da.attrs['units'] = units c_ts_da = c_ts_da * scale_factor * scale_factor_table c_ts_da.attrs['units'] = units - + # Check to see if this field is available if ref_ts_da is None: print( @@ -111,6 +111,12 @@ def global_mean_timeseries_lnd(adfobj): ref_ts_da = pf.annual_mean(ref_ts_da_ga, whole_years=True, time_name="time") c_ts_da = pf.annual_mean(c_ts_da_ga, whole_years=True, time_name="time") + # make cumulative sum plots for NBP + if field == 'NBP': + print(ref_ts_da) + ref_ts_da = ref_ts_da.cumsum() + c_ts_da = c_ts_da.cumsum() + # check if variable has a lev dimension has_lev_ref = pf.zm_validate_dims(ref_ts_da)[1] if has_lev_ref: From 1b3c54367f8f258474a19f80e4b64f2c172e138b Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 13 Aug 2025 16:39:00 -0600 Subject: [PATCH 086/126] exclude vars causing polar plot failures --- scripts/plotting/polar_map.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/plotting/polar_map.py b/scripts/plotting/polar_map.py index bbc16b247..61de7a7d2 100644 --- a/scripts/plotting/polar_map.py +++ b/scripts/plotting/polar_map.py @@ -332,7 +332,7 @@ def polar_map(adfobj): if comp == "lnd": hemi = hemi_type # Exclude certain plots, this may get difficult - if var != 'GRAINC_TO_FOOD': + if (var != 'GRAINC_TO_FOOD') or (var != 'DSTFLXT') or (var != 'MEG_isoprene') or (var != 'FAREA_BURNED'): pf.make_polar_plot(plot_name, case_nickname, base_nickname, [syear_cases[case_idx],eyear_cases[case_idx]], [syear_baseline,eyear_baseline], From b46ed6f250ca187455cfa691fd7e8dee972231fb Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 13 Aug 2025 16:48:31 -0600 Subject: [PATCH 087/126] comment out cumsum NBP --- scripts/plotting/global_mean_timeseries_lnd.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/scripts/plotting/global_mean_timeseries_lnd.py b/scripts/plotting/global_mean_timeseries_lnd.py index d5be517e1..6f3249e52 100644 --- a/scripts/plotting/global_mean_timeseries_lnd.py +++ b/scripts/plotting/global_mean_timeseries_lnd.py @@ -112,10 +112,11 @@ def global_mean_timeseries_lnd(adfobj): c_ts_da = pf.annual_mean(c_ts_da_ga, whole_years=True, time_name="time") # make cumulative sum plots for NBP - if field == 'NBP': - print(ref_ts_da) - ref_ts_da = ref_ts_da.cumsum() - c_ts_da = c_ts_da.cumsum() + #TODO, check this is working as expected + #if field == 'NBP': + # print(ref_ts_da) + # ref_ts_da = ref_ts_da.cumsum() + # c_ts_da = c_ts_da.cumsum() # check if variable has a lev dimension has_lev_ref = pf.zm_validate_dims(ref_ts_da)[1] From 56e043703f8fbe2d037b6c5e55ecb83f2d24c050 Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 14 Aug 2025 06:14:41 -0600 Subject: [PATCH 088/126] exclude broken plots --- scripts/plotting/polar_map.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/scripts/plotting/polar_map.py b/scripts/plotting/polar_map.py index 61de7a7d2..ff7343709 100644 --- a/scripts/plotting/polar_map.py +++ b/scripts/plotting/polar_map.py @@ -331,8 +331,15 @@ def polar_map(adfobj): #End if if comp == "lnd": hemi = hemi_type + # Exclude certain plots, this may get difficult - if (var != 'GRAINC_TO_FOOD') or (var != 'DSTFLXT') or (var != 'MEG_isoprene') or (var != 'FAREA_BURNED'): + if (var == 'GRAINC_TO_FOOD'): + print("\t\t Skipping 'GRAINC_TO_FOOD' polar plots") + continue + elif (var == 'FAREA_BURNED') and (s == 'SON'): + print("\t\t Skipping FAREA_BURNED in SON plot") + continue + else: pf.make_polar_plot(plot_name, case_nickname, base_nickname, [syear_cases[case_idx],eyear_cases[case_idx]], [syear_baseline,eyear_baseline], From 095f5b983a2980956fa868dfbc11f8feb9be64f1 Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 15 Aug 2025 05:40:30 -0600 Subject: [PATCH 089/126] correct cum NPB plotting --- lib/ldf_variable_defaults.yaml | 3 ++- .../plotting/global_mean_timeseries_lnd.py | 20 +++++++++++-------- 2 files changed, 14 insertions(+), 9 deletions(-) diff --git a/lib/ldf_variable_defaults.yaml b/lib/ldf_variable_defaults.yaml index 682ec9686..bc048fb80 100644 --- a/lib/ldf_variable_defaults.yaml +++ b/lib/ldf_variable_defaults.yaml @@ -427,8 +427,9 @@ NBP: # Net Biome Production pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] pct_diff_colormap: "PiYG" scale_factor_table: 0.000000365 #days to years, g/m2 to Pg globally - avg_method: 'sum' + avg_method: 'cumsum' # in TS NBP is cum sum, table just uses sum implicitly (not mean) table_unit: "PgC y$^{-1}$" + ts_unit: "PgC" #global TS uses cumulative NBP in PgC TOTECOSYSC_1m: category: "Carbon" diff --git a/scripts/plotting/global_mean_timeseries_lnd.py b/scripts/plotting/global_mean_timeseries_lnd.py index 6f3249e52..a413257ba 100644 --- a/scripts/plotting/global_mean_timeseries_lnd.py +++ b/scripts/plotting/global_mean_timeseries_lnd.py @@ -80,12 +80,15 @@ def global_mean_timeseries_lnd(adfobj): scale_factor_table = vres.get('scale_factor_table', 1) add_offset = vres.get('add_offset', 0) avg_method = vres.get('avg_method', 'mean') + if avg_method == 'mean': weights = weights/weights.sum() c_weights = c_weights/c_weights.sum() + # get units for variable ref_ts_da.attrs['units'] = vres.get("new_unit", ref_ts_da.attrs.get('units', 'none')) ref_ts_da.attrs['units'] = vres.get("table_unit", ref_ts_da.attrs.get('units', 'none')) + ref_ts_da.attrs['units'] = vres.get("ts_unit", ref_ts_da.attrs.get('units', 'none')) #only used for NBP units = ref_ts_da.attrs['units'] # scale for plotting, if needed @@ -93,7 +96,7 @@ def global_mean_timeseries_lnd(adfobj): ref_ts_da.attrs['units'] = units c_ts_da = c_ts_da * scale_factor * scale_factor_table c_ts_da.attrs['units'] = units - + # Check to see if this field is available if ref_ts_da is None: print( @@ -112,11 +115,9 @@ def global_mean_timeseries_lnd(adfobj): c_ts_da = pf.annual_mean(c_ts_da_ga, whole_years=True, time_name="time") # make cumulative sum plots for NBP - #TODO, check this is working as expected - #if field == 'NBP': - # print(ref_ts_da) - # ref_ts_da = ref_ts_da.cumsum() - # c_ts_da = c_ts_da.cumsum() + if avg_method == 'cumsum': + c_ts_da = c_ts_da.cumsum() + ref_ts_da = ref_ts_da.cumsum() # check if variable has a lev dimension has_lev_ref = pf.zm_validate_dims(ref_ts_da)[1] @@ -172,9 +173,11 @@ def global_mean_timeseries_lnd(adfobj): continue # End if - # Gather spatial avg for test case - case_ts[labels[case_name]] = pf.annual_mean(c_ts_da_ga, whole_years=True, time_name="time") + # Gather spatial avg for test case This seems redundant, since it was done above? + # Just try using c_ts_da directly, instead of doing the calculation again... + case_ts[labels[case_name]] = c_ts_da + # End loop over cases # If this case is 3-d or missing variable, then break the loop and go to next variable if skip_var: continue @@ -283,6 +286,7 @@ def _include_lens(self): def make_plot(case_ts, lens2, label=None, ref_ts_da=None): """plot yearly values of ref_ts_da""" + print(label) field = lens2.field # this will be defined even if no LENS2 data fig, ax = plt.subplots() From cf8009e6643d9b1f1671adb5194c3d5549882fa2 Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 15 Aug 2025 05:47:01 -0600 Subject: [PATCH 090/126] fix errors --- scripts/plotting/global_mean_timeseries_lnd.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/scripts/plotting/global_mean_timeseries_lnd.py b/scripts/plotting/global_mean_timeseries_lnd.py index a413257ba..8725b758e 100644 --- a/scripts/plotting/global_mean_timeseries_lnd.py +++ b/scripts/plotting/global_mean_timeseries_lnd.py @@ -88,7 +88,7 @@ def global_mean_timeseries_lnd(adfobj): # get units for variable ref_ts_da.attrs['units'] = vres.get("new_unit", ref_ts_da.attrs.get('units', 'none')) ref_ts_da.attrs['units'] = vres.get("table_unit", ref_ts_da.attrs.get('units', 'none')) - ref_ts_da.attrs['units'] = vres.get("ts_unit", ref_ts_da.attrs.get('units', 'none')) #only used for NBP + ref_ts_da.attrs['units'] = vres.get("ts_unit", ref_ts_da.attrs.get('units', 'none')) units = ref_ts_da.attrs['units'] # scale for plotting, if needed @@ -286,7 +286,6 @@ def _include_lens(self): def make_plot(case_ts, lens2, label=None, ref_ts_da=None): """plot yearly values of ref_ts_da""" - print(label) field = lens2.field # this will be defined even if no LENS2 data fig, ax = plt.subplots() From 53a4d78492121e38993ae91e07dd797bc57537f2 Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 20 Aug 2025 16:41:19 -0600 Subject: [PATCH 091/126] add pft vars to TS for clm2.h1 files --- lib/adf_diag.py | 32 ++++++++++++++++++-------------- 1 file changed, 18 insertions(+), 14 deletions(-) diff --git a/lib/adf_diag.py b/lib/adf_diag.py index f78161b80..4119d2dd1 100644 --- a/lib/adf_diag.py +++ b/lib/adf_diag.py @@ -744,6 +744,10 @@ def call_ncrcat(cmd): # End if cam # End if has_lev + # Optional, add additional time varying variables to clm2.h1 files + if ("clm" in hist_str) and ("h1" in hist_str): + ncrcat_var_list = ncrcat_var_list + ",pfts1d_wtgcell,pfts1d_wtlunit,pfts1d_wtcol" + cmd = ( ["ncrcat", "-O", "-4", "-h", "--no_cll_mth", "-v", ncrcat_var_list] + hist_files @@ -768,19 +772,7 @@ def call_ncrcat(cmd): ts_outfil_str ] - if "clm" in hist_str: - # Step 3b: Optional, add additional variables to clm2.h1 files - if "h1" in hist_str: - cmd_add_clm_h1_fields = [ - "ncrcat", "-A", "-v", - "pfts1d_ixy,pfts1d_jxy,pfts1d_itype_veg,lat,lon", - hist_files, - ts_outfil_str - ] - # add time varrying information to clm2.h1 fields - list_of_hist_commands.append(cmd_add_clm_h1_fields) - - # Step 3c: Create the ncatted command to remove the history attribute + # Step 3c: Create the ncatted command to remove the history attribute cmd_remove_history = [ "ncatted", "-O", "-h", "-a", "history,global,d,,", @@ -858,7 +850,19 @@ def call_ncrcat(cmd): ts_ds['area'] = ds.area ts_ds['landfrac'] = ds.landfrac ts_ds['landmask'] = ds.landmask - + # Optional, add additional variables to clm2.h1 files + # Note: this is currently set up for PFT output + if "h1" in hist_str: + ds = xr.open_dataset(hist_files[0], decode_times=False) + ts_ds['pfts1d_ixy'] = ds.pfts1d_ixy + ts_ds['pfts1d_jxy'] = ds.pfts1d_jxy + ts_ds['pfts1d_gi'] = ds.pfts1d_gi + ts_ds['pfts1d_li'] = ds.pfts1d_li + ts_ds['pfts1d_ci'] = ds.pfts1d_li + ts_ds['pfts1d_itype_veg'] = ds.pfts1d_itype_veg + ts_ds['pfts1d_itype_col'] = ds.pfts1d_itype_col + ts_ds['pfts1d_itype_lunit'] = ds.pfts1d_itype_lunit + ts_ds['pfts1d_active'] = ds.pfts1d_active ts_ds['time'] = time ts_ds.assign_coords(time=time) ts_ds_fixed = xr.decode_cf(ts_ds) From 9573f9f84eabc7bbabc117c572b34b8b8941f33b Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 21 Aug 2025 12:49:14 -0600 Subject: [PATCH 092/126] correct error from ux.plot, adds line to plots --- lib/plotting_functions.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/plotting_functions.py b/lib/plotting_functions.py index 147d1bb85..b8b354aa2 100644 --- a/lib/plotting_functions.py +++ b/lib/plotting_functions.py @@ -899,7 +899,7 @@ def make_polar_plot(wks, case_nickname, base_nickname, if unstructured: #configure for polycollection plotting #TODO, would be nice to have levels set from the info, above - ac = a.to_polycollection(projection=proj) + ac = a.to_polycollection() #ac.norm(norms[i]) ac.set_cmap(cmap) ac.set_antialiased(False) @@ -1413,7 +1413,7 @@ def plot_map_and_save(wks, case_nickname, base_nickname, else: #configure for polycollection plotting #TODO, would be nice to have levels set from the info, above - ac = a.to_polycollection(projection=proj) + ac = a.to_polycollection() img.append(ac) #ac.norm(norm) ac.set_cmap(cmap) From 0063f85f3a408f7b9525726daf898b59d4fa3472 Mon Sep 17 00:00:00 2001 From: wwieder Date: Sun, 24 Aug 2025 14:42:47 -0600 Subject: [PATCH 093/126] draft notebook for ux_survival --- lib/plot_uxarray_h1.ipynb | 3097 ++++--------------------------------- 1 file changed, 339 insertions(+), 2758 deletions(-) diff --git a/lib/plot_uxarray_h1.ipynb b/lib/plot_uxarray_h1.ipynb index 21dbe623b..15ea65906 100644 --- a/lib/plot_uxarray_h1.ipynb +++ b/lib/plot_uxarray_h1.ipynb @@ -50,7 +50,7 @@ " }\n", "\n", " const force = true;\n", - " const py_version = '3.6.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", " const reloading = false;\n", " const Bokeh = root.Bokeh;\n", "\n", @@ -210,7 +210,7 @@ " document.body.appendChild(element);\n", " }\n", "\n", - " const js_urls = [\"https://cdn.holoviz.org/panel/1.5.4/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.6.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.4/dist/panel.min.js\"];\n", + " const js_urls = [\"https://cdn.holoviz.org/panel/1.5.4/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.5.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.4/dist/panel.min.js\"];\n", " const js_modules = [];\n", " const js_exports = {};\n", " const css_urls = [];\n", @@ -291,7 +291,7 @@ " setTimeout(load_or_wait, 100)\n", "}(window));" ], - "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n const py_version = '3.6.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = false;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.5.4/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.6.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.6.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.4/dist/panel.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = false;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.5.4/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.5.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.4/dist/panel.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" }, "metadata": {}, "output_type": "display_data" @@ -548,12 +548,12 @@ "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ - "
\n", - "
\n", + "
\n", + "
\n", "
\n", "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1009" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import holoviews as hv\n", + "plot_opts = {\"width\": 700, \"height\": 350}\n", + "hv.extension(\"bokeh\")\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "bccb5c83-1bbe-4e57-9a71-a9a9e0c735ad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(0.0, 0.0001671932)\n" + ] + } + ], + "source": [ + "plot_opts = {\"width\": 700, \"height\": 400}\n", + "clim = (np.nanmin(ds0[\"GPP\"].values), np.nanmax(ds0[\"GPP\"].values))\n", + "print(clim)\n", + "features = gf.coastline(\n", + " projection=ccrs.PlateCarree(), line_width=1, scale=\"110m\"\n", + ") #* gf.states(projection=ccrs.PlateCarree(), line_width=1, scale=\"110m\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "1563ce17-1d11-47bf-9ee1-56f3612b6dfd", + "metadata": {}, + "outputs": [], + "source": [ + "# This takes a long time to plot, we'll skip it for now\n", + "#ds0[\"test\"][0].plot.polygons(\n", + "# title=\"Global Grid\", **plot_opts\n", + "#) * features" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "c1a7ce6e-cdd0-4e3d-b0e9-41777d834241", + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " var force = true;\n", + " var py_version = '3.4.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " var reloading = false;\n", + " var Bokeh = root.Bokeh;\n", + "\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks;\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + " if (js_exports == null) js_exports = {};\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + "\n", + " if (root._bokeh_is_loading > 0) {\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " }\n", + " if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + " if (!reloading) {\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " }\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + " window._bokeh_on_load = on_load\n", + "\n", + " function on_error() {\n", + " console.error(\"failed to load \" + url);\n", + " }\n", + "\n", + " var skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", + " root._bokeh_is_loading = css_urls.length + 0;\n", + " } else {\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", + " }\n", + "\n", + " var existing_stylesheets = []\n", + " var links = document.getElementsByTagName('link')\n", + " for (var i = 0; i < links.length; i++) {\n", + " var link = links[i]\n", + " if (link.href != null) {\n", + "\texisting_stylesheets.push(link.href)\n", + " }\n", + " }\n", + " for (var i = 0; i < css_urls.length; i++) {\n", + " var url = css_urls[i];\n", + " if (existing_stylesheets.indexOf(url) !== -1) {\n", + "\ton_load()\n", + "\tcontinue;\n", + " }\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " } var existing_scripts = []\n", + " var scripts = document.getElementsByTagName('script')\n", + " for (var i = 0; i < scripts.length; i++) {\n", + " var script = scripts[i]\n", + " if (script.src != null) {\n", + "\texisting_scripts.push(script.src)\n", + " }\n", + " }\n", + " for (var i = 0; i < js_urls.length; i++) {\n", + " var url = js_urls[i];\n", + " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", + "\tif (!window.requirejs) {\n", + "\t on_load();\n", + "\t}\n", + "\tcontinue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (var i = 0; i < js_modules.length; i++) {\n", + " var url = js_modules[i];\n", + " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", + "\tif (!window.requirejs) {\n", + "\t on_load();\n", + "\t}\n", + "\tcontinue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (const name in js_exports) {\n", + " var url = js_exports[name];\n", + " if (skip.indexOf(url) >= 0 || root[name] != null) {\n", + "\tif (!window.requirejs) {\n", + "\t on_load();\n", + "\t}\n", + "\tcontinue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " element.textContent = `\n", + " import ${name} from \"${url}\"\n", + " window.${name} = ${name}\n", + " window._bokeh_on_load()\n", + " `\n", + " document.head.appendChild(element);\n", + " }\n", + " if (!js_urls.length && !js_modules.length) {\n", + " on_load()\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.4.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.4.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.4.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.4.2.min.js\", \"https://cdn.holoviz.org/panel/1.4.4/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.12.0/dist/geoviews.min.js\"];\n", + " var js_modules = [];\n", + " var js_exports = {};\n", + " var css_urls = [];\n", + " var inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {} // ensure no trailing comma for IE\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if ((root.Bokeh !== undefined) || (force === true)) {\n", + " for (var i = 0; i < inline_js.length; i++) {\n", + "\ttry {\n", + " inline_js[i].call(root, root.Bokeh);\n", + "\t} catch(e) {\n", + "\t if (!reloading) {\n", + "\t throw e;\n", + "\t }\n", + "\t}\n", + " }\n", + " // Cache old bokeh versions\n", + " if (Bokeh != undefined && !reloading) {\n", + "\tvar NewBokeh = root.Bokeh;\n", + "\tif (Bokeh.versions === undefined) {\n", + "\t Bokeh.versions = new Map();\n", + "\t}\n", + "\tif (NewBokeh.version !== Bokeh.version) {\n", + "\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", + "\t}\n", + "\troot.Bokeh = Bokeh;\n", + " }} else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " }\n", + " root._bokeh_is_initializing = false\n", + " }\n", + "\n", + " function load_or_wait() {\n", + " // Implement a backoff loop that tries to ensure we do not load multiple\n", + " // versions of Bokeh and its dependencies at the same time.\n", + " // In recent versions we use the root._bokeh_is_initializing flag\n", + " // to determine whether there is an ongoing attempt to initialize\n", + " // bokeh, however for backward compatibility we also try to ensure\n", + " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", + " // before older versions are fully initialized.\n", + " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", + " root._bokeh_is_initializing = false;\n", + " root._bokeh_onload_callbacks = undefined;\n", + " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", + " load_or_wait();\n", + " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", + " setTimeout(load_or_wait, 100);\n", + " } else {\n", + " root._bokeh_is_initializing = true\n", + " root._bokeh_onload_callbacks = []\n", + " var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n", + " if (!reloading && !bokeh_loaded) {\n", + "\troot.Bokeh = undefined;\n", + " }\n", + " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", + "\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + "\trun_inline_js();\n", + " });\n", + " }\n", + " }\n", + " // Give older versions of the autoload script a head-start to ensure\n", + " // they initialize before we start loading newer version.\n", + " setTimeout(load_or_wait, 100)\n", + "}(window));" + ], + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.4.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var reloading = false;\n var Bokeh = root.Bokeh;\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.4.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.4.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.4.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.4.2.min.js\", \"https://cdn.holoviz.org/panel/1.4.4/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.12.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n\ttry {\n inline_js[i].call(root, root.Bokeh);\n\t} catch(e) {\n\t if (!reloading) {\n\t throw e;\n\t }\n\t}\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", + " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", + "}\n", + "\n", + "\n", + " function JupyterCommManager() {\n", + " }\n", + "\n", + " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", + " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " comm_manager.register_target(comm_id, function(comm) {\n", + " comm.on_msg(msg_handler);\n", + " });\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", + " comm.onMsg = msg_handler;\n", + " });\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " console.log(message)\n", + " var content = {data: message.data, comm_id};\n", + " var buffers = []\n", + " for (var buffer of message.buffers || []) {\n", + " buffers.push(new DataView(buffer))\n", + " }\n", + " var metadata = message.metadata || {};\n", + " var msg = {content, buffers, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " })\n", + " }\n", + " }\n", + "\n", + " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", + " if (comm_id in window.PyViz.comms) {\n", + " return window.PyViz.comms[comm_id];\n", + " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", + " if (msg_handler) {\n", + " comm.on_msg(msg_handler);\n", + " }\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", + " comm.open();\n", + " if (msg_handler) {\n", + " comm.onMsg = msg_handler;\n", + " }\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", + " comm_promise.then((comm) => {\n", + " window.PyViz.comms[comm_id] = comm;\n", + " if (msg_handler) {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " var content = {data: message.data};\n", + " var metadata = message.metadata || {comm_id};\n", + " var msg = {content, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " }) \n", + " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", + " return comm_promise.then((comm) => {\n", + " comm.send(data, metadata, buffers, disposeOnDone);\n", + " });\n", + " };\n", + " var comm = {\n", + " send: sendClosure\n", + " };\n", + " }\n", + " window.PyViz.comms[comm_id] = comm;\n", + " return comm;\n", + " }\n", + " window.PyViz.comm_manager = new JupyterCommManager();\n", + " \n", + "\n", + "\n", + "var JS_MIME_TYPE = 'application/javascript';\n", + "var HTML_MIME_TYPE = 'text/html';\n", + "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", + "var CLASS_NAME = 'output';\n", + "\n", + "/**\n", + " * Render data to the DOM node\n", + " */\n", + "function render(props, node) {\n", + " var div = document.createElement(\"div\");\n", + " var script = document.createElement(\"script\");\n", + " node.appendChild(div);\n", + " node.appendChild(script);\n", + "}\n", + "\n", + "/**\n", + " * Handle when a new output is added\n", + " */\n", + "function handle_add_output(event, handle) {\n", + " var output_area = handle.output_area;\n", + " var output = handle.output;\n", + " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + " if (id !== undefined) {\n", + " var nchildren = toinsert.length;\n", + " var html_node = toinsert[nchildren-1].children[0];\n", + " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var scripts = [];\n", + " var nodelist = html_node.querySelectorAll(\"script\");\n", + " for (var i in nodelist) {\n", + " if (nodelist.hasOwnProperty(i)) {\n", + " scripts.push(nodelist[i])\n", + " }\n", + " }\n", + "\n", + " scripts.forEach( function (oldScript) {\n", + " var newScript = document.createElement(\"script\");\n", + " var attrs = [];\n", + " var nodemap = oldScript.attributes;\n", + " for (var j in nodemap) {\n", + " if (nodemap.hasOwnProperty(j)) {\n", + " attrs.push(nodemap[j])\n", + " }\n", + " }\n", + " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", + " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", + " oldScript.parentNode.replaceChild(newScript, oldScript);\n", + " });\n", + " if (JS_MIME_TYPE in output.data) {\n", + " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", + " }\n", + " output_area._hv_plot_id = id;\n", + " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", + " window.PyViz.plot_index[id] = Bokeh.index[id];\n", + " } else {\n", + " window.PyViz.plot_index[id] = null;\n", + " }\n", + " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " var bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var script_attrs = bk_div.children[0].attributes;\n", + " for (var i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + "function handle_clear_output(event, handle) {\n", + " var id = handle.cell.output_area._hv_plot_id;\n", + " var server_id = handle.cell.output_area._bokeh_server_id;\n", + " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", + " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", + " if (server_id !== null) {\n", + " comm.send({event_type: 'server_delete', 'id': server_id});\n", + " return;\n", + " } else if (comm !== null) {\n", + " comm.send({event_type: 'delete', 'id': id});\n", + " }\n", + " delete PyViz.plot_index[id];\n", + " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", + " var doc = window.Bokeh.index[id].model.document\n", + " doc.clear();\n", + " const i = window.Bokeh.documents.indexOf(doc);\n", + " if (i > -1) {\n", + " window.Bokeh.documents.splice(i, 1);\n", + " }\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle kernel restart event\n", + " */\n", + "function handle_kernel_cleanup(event, handle) {\n", + " delete PyViz.comms[\"hv-extension-comm\"];\n", + " window.PyViz.plot_index = {}\n", + "}\n", + "\n", + "/**\n", + " * Handle update_display_data messages\n", + " */\n", + "function handle_update_output(event, handle) {\n", + " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", + " handle_add_output(event, handle)\n", + "}\n", + "\n", + "function register_renderer(events, OutputArea) {\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " var toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[0]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " events.on('output_added.OutputArea', handle_add_output);\n", + " events.on('output_updated.OutputArea', handle_update_output);\n", + " events.on('clear_output.CodeCell', handle_clear_output);\n", + " events.on('delete.Cell', handle_clear_output);\n", + " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", + "\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " safe: true,\n", + " index: 0\n", + " });\n", + "}\n", + "\n", + "if (window.Jupyter !== undefined) {\n", + " try {\n", + " var events = require('base/js/events');\n", + " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " } catch(err) {\n", + " }\n", + "}\n" + ], + "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1011" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + ":Overlay\n", + " .Polygons.I :Polygons [x,y] (test)\n", + " .Coastline.I :Feature [Longitude,Latitude]" + ] + }, + "execution_count": 22, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1013" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "# set the bounding box\n", + "lon_bounds = (105, 145)\n", + "lat_bounds = (25, 58)\n", + "# elements include nodes, edge centers, or face centers) \n", + "element = 'face centers'\n", + "\n", + "bbox_subset_nodes = ds0[\"test\"][5].subset.bounding_box(\n", + " lon_bounds, lat_bounds, element=element\n", + ")\n", + "bbox_subset_nodes.plot.polygons(\n", + " cmap='viridis',\n", + " title=\"Bounding Box Subset (\"+element+\")\",\n", + " **plot_opts,\n", + ") * features" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "87fb2283-e414-4c5b-99a0-d337f2f40b99", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(nrows=2,ncols=2,\n", + " subplot_kw=dict(projection=ccrs.PlateCarree()),\n", + " figsize=(12,8))\n", + "axs=axs.flatten()\n", + "# These differences around the coast seem pretty tiny, again within rounding error?\n", + "ds_out_con.test.isel(time=0)\\\n", + " .sel(lon=slice(lon_bounds[0],lon_bounds[1]),lat=slice(lat_bounds[0],lat_bounds[1]))\\\n", + " .plot(vmin=1-1e-8, vmax=1+1e-8, ax=axs[0])\n", + "\n", + "ds_out_bilin.test.isel(time=0)\\\n", + " .sel(lon=slice(lon_bounds[0],lon_bounds[1]),lat=slice(lat_bounds[0],lat_bounds[1]))\\\n", + " .plot(vmin=1-1e-8, vmax=1+1e-8, ax=axs[1]) ;\n", + "\n", + "ds_out_con.test.isel(time=0).where(fv_t232.landfrac>0)\\\n", + " .sel(lon=slice(lon_bounds[0],lon_bounds[1]),lat=slice(lat_bounds[0],lat_bounds[1]))\\\n", + " .plot(vmin=1-1e-8, vmax=1+1e-8, ax=axs[2])\n", + "\n", + "axs[0].set_title('conservative test, no mask')\n", + "axs[1].set_title('bilinear test') ;\n", + "axs[2].set_title('conservative test, destination mask') ;" + ] + }, + { + "cell_type": "markdown", + "id": "7dd34b5d-bd99-405a-a988-5b561bf3d0b0", + "metadata": {}, + "source": [ + "#### Now look at regional fluxes\n", + "- Not sure if bounding boxes are necessarily identical in unstructured and regular grid.\n", + "- Fluxes still don't look the same when focusing on a few islands, but overall not unreasonable\n", + "- What level of difference are we OK tolerating?" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "d94d7a9a-994a-4c0a-ab57-db7bebcc479f", + "metadata": {}, + "outputs": [], + "source": [ + "# elements include nodes, edge centers, or face centers) \n", + "element = 'face centers'\n", + "region = 'Hawaii'\n", + "month = 6\n", + "# set the bounding box\n", + "plot_opts = {\"width\": 700, \"height\": 400}\n", + "\n", + "if region == 'Global':\n", + " lat_bounds = (-90, 90)\n", + " lon_bounds = (-180, 180)\n", + " lon_bounds2 = (0, 360)\n", + "elif region == 'East Asia':\n", + " lat_bounds = (23, 58)\n", + " lon_bounds = (110, 150)\n", + " lon_bounds2 = (110, 150)\n", + "elif region == 'Polar':\n", + " lat_bounds = (60, 90)\n", + " lon_bounds = (-180, 180)\n", + " lon_bounds2 = (0, 360)\n", + "elif region == 'Hawaii':\n", + " lat_bounds = (17, 25)\n", + " lon_bounds = (-162, -153)\n", + " lon_bounds2 = ((360-162), (360-153)) \n", + "elif region == 'Amazon':\n", + " lat_bounds = (-10, 0)\n", + " lon_bounds = (-70, -50)\n", + " lon_bounds2 = ((290), (310)) \n", + "elif region == 'New Zeland':\n", + " lat_bounds = (-50, -33)\n", + " lon_bounds = (160, 179)\n", + " lon_bounds2 = (160, 180)\n", + "elif region == 'South America':\n", + " lat_bounds = (-57, 13)\n", + " lon_bounds = (-85, -30)\n", + " lon_bounds2 = ((360-85), (360-30))\n", + " plot_opts = {\"width\": 700, \"height\": 700} \n", + "\n", + "\n", + "bbox_subset_nodes = ds0[\"GPP\"][month].subset.bounding_box(\n", + " lon_bounds, lat_bounds, element=element\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "e3c6a535-a39a-4c84-8044-3184d5e94a2d", + "metadata": {}, + "outputs": [ + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + ":Overlay\n", + " .Polygons.I :Polygons [x,y] (GPP)\n", + " .Coastline.I :Feature [Longitude,Latitude]" + ] + }, + "execution_count": 25, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p3823" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "#if region != \"New Zeland\" comment out features below \n", + "bbox_subset_nodes.plot.polygons(\n", + " clim=clim, \n", + " cmap='viridis',\n", + " title=region + \" Bounding Box Subset (\"+element+\" Query)\",\n", + " **plot_opts,\n", + ") * features" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "d7fbcc60-32a2-4fef-afad-06e520c47635", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if region == \"New Zeland\":\n", + " fig, axs = plt.subplots(nrows=2,ncols=2,\n", + " figsize=(12,8))\n", + "else:\n", + " fig, axs = plt.subplots(nrows=2,ncols=2,\n", + " subplot_kw=dict(projection=ccrs.PlateCarree()),\n", + " figsize=(12,8))\n", + "axs=axs.flatten()\n", + "ds_out_con.GPP.isel(time=month)\\\n", + " .sel(lon=slice(lon_bounds2[0],lon_bounds2[1]),lat=slice(lat_bounds[0],lat_bounds[1]))\\\n", + " .plot(vmin=clim[0],vmax=clim[1], ax=axs[0]) \n", + "axs[0].set_title(region + ' conservaitve, no mask')\n", + "\n", + "ds_out_con.GPP.isel(time=month).where(fv_t232.landfrac>0)\\\n", + " .sel(lon=slice(lon_bounds2[0],lon_bounds2[1]),lat=slice(lat_bounds[0],lat_bounds[1]))\\\n", + " .plot(vmin=clim[0],vmax=clim[1], ax=axs[1]) \n", + "axs[1].set_title(region + ' conservaitve, destination mask')\n", + "\n", + "\n", + "ds_out_bilin.GPP.isel(time=month)\\\n", + " .sel(lon=slice(lon_bounds2[0],lon_bounds2[1]),lat=slice(lat_bounds[0],lat_bounds[1]))\\\n", + " .plot(vmin=clim[0],vmax=clim[1], ax=axs[2]) \n", + "axs[2].set_title(region + ' bilinear') ;\n", + "\n", + "if region != \"New Zeland\":\n", + " for a in axs:\n", + " a.coastlines()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "4659783e-c119-4031-9988-61e43f659583", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAHACAYAAABwEmgAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC/oUlEQVR4nOzddXgUxxvA8e9d5O7ibhDBCcGlOMFdChVqyA9KgVKgpRRKoVhbrFipQJFCkVLa4lKcAMUtRRICCSFBEoKEuN3d/P4IuXIkgSTIEZjP89wDmZ3dfXfP3puZnVUIIQSSJEmSJEkmojR1AJIkSZIkvdxkMiJJkiRJkknJZESSJEmSJJOSyYgkSZIkSSYlkxFJkiRJkkxKJiOSJEmSJJmUTEYkSZIkSTIpmYxIkiRJkmRSMhmRJEmSJMmkZDLyGJYsWYJCoeD48eN5Lu/YsSN+fn7PNqgCatq0KU2bNjUqUygUjB8//ols38/Pj969exv+vnz5MgqFgiVLljyR7RfWpEmTWLduXZHXN3X8UragoCAUCgVBQUGmDsXIk3zvPK6cz6XLly8/kXp5uX79OuPHjyc4OLhIMZpC7969C/V53KJFCwYMGFDk/en1epYtW0bLli1xcXHBwsICNzc3OnbsyMaNG9Hr9bnW6datG126dCnUfnr06MGrr75a5DifF+amDkAyjZ9++ilX2aFDhyhZsuRT2Z+npyeHDh2iTJkyT2X7jzJp0iRef/31F+JNKz1/nuZ752np0KEDhw4dwtPTs9DrXr9+nQkTJuDn50f16tWffHAmtn79eg4cOMDSpUuLtH56ejqvvvoq27dv56233mLu3Ll4eHhw8+ZNtm7dyhtvvMGqVauMEo+UlBS2bt3KvHnzCrWv8ePHU7FiRXbv3k3z5s2LFO/zQCYjL6lKlSrlKqtXr95T259KpXqq25ekR0lLS0OtVqNQKJ74tovja9vV1RVXV1dTh1FkaWlpaDSap7LtSZMm0bVrV0qUKFGk9YcNG8a2bdv49ddf6dmzp9Gybt268dlnn5GWlmZUvmXLFrRaLZ06dSrUvsqUKUPbtm2ZMmVKsU5GZDfNM/bjjz/SpEkT3NzcsLa2pkqVKkybNo2srCyjOkqlkri4OEPZjBkzUCgUDBo0yFCm1+txdHTk008/NZRNmDCBunXr4uTkhJ2dHTVr1mTRokU8eD/Ex+mmycjIYOLEifj7+6NWq3F2dqZZs2YcPHgw33Xy6uYYP348CoWC06dP88Ybb2Bvb4+TkxPDhg1Dq9USFhZG27ZtsbW1xc/Pj2nTphltMz09nU8//ZTq1asb1q1fvz7r16/PdVwpKSn8+uuvKBQKFAqF0bGfPXuWLl264OjoiFqtpnr16vz666+PPA8A//zzDy1atMDW1hYrKysaNGjA5s2b86xXv3591Go1JUqU4Msvv2ThwoVGzeR9+/bFycmJ1NTUXOs3b96cgICAAsV0v5s3b/Lhhx9SqVIlbGxscHNzo3nz5uzfv9+oXs7zM336dGbOnEmpUqWwsbGhfv36HD582Khu7969sbGxITw8nPbt22NjY4O3tzeffvopGRkZhnr5dank9Vo4fvw4b731Fn5+fmg0Gvz8/Hj77beJiooq9DHDf10Q27dvp0+fPri6umJlZWWIb9WqVdSvXx9ra2tsbGxo06YNp06dyrWdBQsWUL58eVQqFZUqVeK3337Ls7k/r/dOQV5XOedo5cqVjB49Gi8vL+zs7GjZsiVhYWFGdXfs2EGXLl0oWbIkarWasmXL0r9/f27duvVY5+j+bpqmTZtSuXJljh07RuPGjbGysqJ06dJMmTLF0K0QFBREnTp1APjf//5neE/df/zHjx+nc+fOODk5oVarqVGjBn/88UeuGAryvoDsbt+OHTuyZs0aatSogVqtZsKECUDBPlML49SpUxw9epQePXoUKd7Y2FgWLlxImzZtciUiOcqVK0fVqlWNylavXk3z5s1xdHRk2bJlKBQKDh06lGvdiRMnYmFhwfXr1w1lPXr0YOfOnURERBTpmJ8HMhl5AnQ6HVqtNtcjrxsiR0RE8M4777Bs2TI2bdpE3759+fbbb+nfv7+hTsuWLRFCsGvXLkPZzp070Wg07Nixw1B2/Phx7t69S8uWLQ1lly9fpn///vzxxx+sWbOGbt26MXjwYL766qsncqxarZZ27drx1Vdf0bFjR9auXcuSJUto0KAB0dHRRdrmm2++SbVq1Vi9ejX9+vVj1qxZfPLJJ7z66qt06NCBtWvX0rx5c0aOHMmaNWsM62VkZHDnzh2GDx/OunXrWLlyJY0aNaJbt25GzauHDh1Co9HQvn17Dh06xKFDhwzdVGFhYTRo0IBz584xZ84c1qxZQ6VKlejdu3eu5OdBe/fupXnz5iQkJLBo0SJWrlyJra0tnTp1YtWqVYZ6p0+fplWrVqSmpvLrr78yb948Tp48yTfffGO0vaFDhxIfH89vv/1mVB4SEsKePXuMEtGCunPnDgDjxo1j8+bNLF68mNKlS9O0adM8x138+OOP7Nixg9mzZ7NixQpSUlJo3749CQkJRvWysrLo3LkzLVq0YP369fTp04dZs2YxderUQscI2a/bChUqMHv2bLZt28bUqVOJiYmhTp06Rf6yBejTpw8WFhYsW7aMv/76CwsLCyZNmsTbb79NpUqV+OOPP1i2bBlJSUk0btyYkJAQw7rz58/ngw8+oGrVqqxZs4YxY8YwYcKEAo1XKezr6osvviAqKoqFCxcyf/58Ll68SKdOndDpdIY6ERER1K9fn7lz57J9+3bGjh3LkSNHaNSoUZG/ePMSGxvLu+++y3vvvceGDRto164do0aNYvny5QDUrFmTxYsXAzBmzBjDe+r9998HYM+ePTRs2JC7d+8yb9481q9fT/Xq1enevbtRAlrQ90WOkydP8tlnnzFkyBC2bt3Ka6+9Zjgvj/pMLYxNmzZhZmZGkyZNjMoLGu+ePXvIysoqVJdweno6mzdvNhxT9+7d8fDw4McffzSqp9Vq+fnnn+natSteXl6G8qZNmyKEYMuWLYU82ueIkIps8eLFAnjow9fXN9/1dTqdyMrKEkuXLhVmZmbizp07hmUlS5YUffr0EUIIkZGRIaytrcXIkSMFIKKiooQQQnzzzTfCwsJCJCcnP3T7EydOFM7OzkKv1xuWBQYGisDAQKP6gBg3btxDj3np0qUCEAsWLHhoPV9fX9GrVy/D35GRkQIQixcvNpSNGzdOAGLGjBlG61avXl0AYs2aNYayrKws4erqKrp165bvPrVarcjKyhJ9+/YVNWrUMFpmbW1tFE+Ot956S6hUKhEdHW1U3q5dO2FlZSXu3r2bb/z16tUTbm5uIikpySiGypUri5IlSxrO9xtvvCGsra3FzZs3DfV0Op2oVKmSAERkZKShPDAwUFSvXt0oloEDBwo7Ozuj/RRVzjlq0aKF6Nq1q6E85/iqVKkitFqtofzo0aMCECtXrjSU9erVSwDijz/+MNp2+/btRYUKFQx/79mzRwBiz549RvXyOpd5xZmcnCysra3Fd99998htPijnvdmzZ0+j8ujoaGFubi4GDx5sVJ6UlCQ8PDzEm2++KYTIfn48PDxE3bp1jepFRUUJCwuLXO/rB987BX1d5RxP+/btjer98ccfAhCHDh3K8/j0er3IysoSUVFRAhDr16/Pdez3v67ykle9wMBAAYgjR44Y1a1UqZJo06aN4e9jx47l+xxWrFhR1KhRQ2RlZRmVd+zYUXh6egqdTieEKNz7wtfXV5iZmYmwsLCHHtPDPlN79er10M/jHO3atRMVK1bMVV7QeKdMmSIAsXXr1kfuK8e6deuEmZmZiIuLM5SNGzdOWFpaihs3bhjKVq1aJQCxd+/eXNsoUaKE6N69e4H3+byRLSNPwNKlSzl27FiuR6NGjXLVPXXqFJ07d8bZ2RkzMzMsLCzo2bMnOp2OCxcuGOq1aNGCnTt3AnDw4EFSU1MZNmwYLi4uhtaRnTt3Gpqac+zevZuWLVtib29v2P7YsWO5ffu2UbdPUf3999+o1Wr69Onz2NvK0bFjR6O//f39USgUtGvXzlBmbm5O2bJlczXb//nnnzRs2BAbGxvMzc2xsLBg0aJFhIaGFmjfu3fvpkWLFnh7exuV9+7dm9TU1DybSSF7sNmRI0d4/fXXsbGxMZSbmZnRo0cPrl69amhmz2lBcXFxMdRTKpW8+eabubY7dOhQgoODOXDgAACJiYksW7aMXr16Ge2nMObNm0fNmjVRq9WGc7Rr1648z1GHDh0wMzMz/J3TlPzgeVcoFLn6tqtWrVrkbpXk5GRGjhxJ2bJlMTc3x9zcHBsbG1JSUgr8XOYl55dmjm3btqHVaunZs6dRK6ZarSYwMNDQ6hEWFkZsbGyu58jHx4eGDRs+cr+FfV117tzZ6O+8zntcXBwDBgzA29vb8Dz6+voCPNY5epCHhwevvPJKrngK8tyGh4dz/vx53n33XQCjc9y+fXtiYmKK9L7IiaF8+fK5ygv6mVpQ169fx83NLVd5YeMtjNWrV9O4cWOjMTwDBw4EsrsKc/zwww9UqVIlV6sNgJubG9euXXvsWExFJiNPgL+/P7Vr1871sLe3N6oXHR1N48aNuXbtGt999x379+/n2LFjhqa4+wc0tWzZkujoaC5evMjOnTupUaOGob9/586dpKWlcfDgQaMumqNHj9K6dWsg+wV84MABjh07xujRo3Ntv6hu3ryJl5cXSuWTe+k4OTkZ/W1paYmVlRVqtTpXeXp6uuHvNWvW8Oabb1KiRAmWL1/OoUOHOHbsGH369DGq9zC3b9/O82qCnCbQ27dv57lefHw8QogCrXv79m3c3d1z1currEuXLvj5+RleE0uWLCElJaVIXTQAM2fOZODAgdStW5fVq1dz+PBhjh07Rtu2bfN8PTg7Oxv9rVKpgNyvnbyeH5VKVeDz/qB33nmHH374gffff59t27Zx9OhRjh07hqur62O9bh98fm7cuAFAnTp1sLCwMHqsWrXK0CWU89wV9Hl7UGFfV48673q9ntatW7NmzRpGjBjBrl27OHr0qGE8z5N4b+cXS048BdlHzvkdPnx4rvP74YcfAhid48Kc37zOZ2E+UwsqZ6Dzgwoar4+PDwCRkZEF2l9WVhYbN27MlTi7u7vTvXt3fv75Z3Q6HadPn2b//v189NFHeW5HrVY/0dfBsyavpnmG1q1bR0pKCmvWrDH8ogHyvFa/RYsWQHbrx44dO2jVqpWhfMyYMezbt4+MjAyjZOT333/HwsKCTZs2Gb2ZHmd+jQe5urryzz//oNfrn2hCUhTLly+nVKlSrFq1yugKifsHUT6Ks7MzMTExucpzBofd/yvofo6OjiiVygKt6+zsbPiQvl9sbGyuMqVSyaBBg/jiiy+YMWMGP/30Ey1atKBChQoFPqb7LV++nKZNmzJ37lyj8qSkpCJtrzByXoMPPh8PjgFJSEhg06ZNjBs3js8//9xQnjMm6HE8eOVMznPy119/Gb0HH5TzhVzQ5y2v9YvyusrP2bNn+ffff1myZAm9evUylIeHhxdqO09bznGNGjWKbt265Vkn57VcmPcF5H4uoXCfqQXl4uKS5+uuoPE2a9YMCwsL1q1bV6B5Snbu3ElCQgJdu3bNtWzo0KEsW7aM9evXs3XrVhwcHAytTg+6c+fOczuvVUHIlpFnKOfNlPOrB0AIYdQMl8PT05NKlSqxevVqTpw4YUhGWrVqxc2bN5k5cyZ2dnaGUe052zc3NzdqZk9LS2PZsmVP7BjatWtHenr6czH5l0KhwNLS0uhDKjY2NtfVNJD/L7sWLVqwe/duo5HpkN31ZmVlle8lm9bW1tStW5c1a9YYbVev17N8+XJKlixpaFIODAxk9+7dRl/Cer2eP//8M89tv//++1haWvLuu+8SFhaW7y+hglAoFEavN8geiJdf99OTlPPBePr0aaPyDRs2GP2tUCgQQuSKc+HChUYDOJ+ENm3aYG5uTkRERJ6tmbVr1wayvzA9PDxyXQESHR390KvGchT1dZWfvD47AH7++edCbedJya/FrEKFCpQrV45///033/Nra2sLFP59kZfCfKYWVMWKFbl06VKu8oLG6+HhYWjhy2+ekoiICMP7YvXq1dSrVy/Py4hr1apFgwYNmDp1KitWrKB3795G3fI5tFotV65cyXPKhuJCtow8Q61atcLS0pK3336bESNGkJ6ezty5c4mPj8+zfosWLfj+++/RaDSGfupSpUpRqlQptm/fTufOnTE3/+8p7NChAzNnzuSdd97hgw8+4Pbt20yfPj3XB9jjePvtt1m8eDEDBgwgLCyMZs2aodfrOXLkCP7+/rz11ltPbF+PknOp34cffsjrr7/OlStX+Oqrr/D09OTixYtGdatUqUJQUBAbN27E09MTW1tbKlSowLhx49i0aRPNmjVj7NixODk5sWLFCjZv3sy0adNydbXdb/LkybRq1YpmzZoxfPhwLC0t+emnnzh79iwrV640fFCOHj2ajRs30qJFC0aPHo1Go2HevHmkpKQA5GphcnBwoGfPnsydOxdfX9885x0YP348EyZMYM+ePbku0X7wHH311VeMGzeOwMBAwsLCmDhxIqVKlUKr1Rb0VBeJh4cHLVu2ZPLkyTg6OuLr68uuXbuMrogCsLOzo0mTJnz77be4uLjg5+fH3r17WbRoEQ4ODk80Jj8/PyZOnMjo0aO5dOkSbdu2xdHRkRs3bnD06FGsra2ZMGECSqWSCRMm0L9/f15//XX69OnD3bt3mTBhAp6eno9sFXyc11VeKlasSJkyZfj8888RQuDk5MTGjRuNrq57lsqUKYNGo2HFihX4+/tjY2ODl5cXXl5e/Pzzz7Rr1442bdrQu3dvSpQowZ07dwgNDeXkyZOGL+/Cvi/yUtjP1IJo2rQpv/zyCxcuXDAao1KYeGfOnMmlS5fo3bs327Zto2vXrri7u3Pr1i127NjB4sWL+f333wkICGD9+vVGLYIPGjp0KN27d0ehUBi6uh50+vRpUlNTadasWZGP2+RMOny2mMsZjX7s2LE8l3fo0CHX6O2NGzeKatWqCbVaLUqUKCE+++wz8ffff+d5hcD69esFIFq1amVU3q9fPwGIOXPm5NrnL7/8IipUqCBUKpUoXbq0mDx5sli0aFGeo+aLcjWNEEKkpaWJsWPHinLlyglLS0vh7OwsmjdvLg4ePGioU5irae4fnS5E9qh3a2vrXPsNDAwUAQEBRmVTpkwRfn5+QqVSCX9/f7FgwQLDdu8XHBwsGjZsKKysrARgdOxnzpwRnTp1Evb29sLS0lJUq1Yt11UC+V0Bsn//ftG8eXNhbW0tNBqNqFevnti4cWOu2Pfv3y/q1q0rVCqV8PDwEJ999pmYOnWqAAxXVtwvKChIAGLKlCm5lgkhxKeffioUCoUIDQ3Nc3mOjIwMMXz4cFGiRAmhVqtFzZo1xbp163JdWZBzfN9++22ubTz4usjv+cnrvMfExIjXX39dODk5CXt7e/Hee++J48eP5zqXV69eFa+99ppwdHQUtra2om3btuLs2bO5XkeFvZomv/fmunXrRLNmzYSdnZ1QqVTC19dXvP7662Lnzp1G9ebPny/Kli0rLC0tRfny5cUvv/wiunTpkutqrbzeOwV5XeUcz59//mlUntfrLSQkRLRq1UrY2toKR0dH8cYbb4jo6Ohc+37cq2kefI8JkfeVKCtXrhQVK1YUFhYWuWL4999/xZtvvinc3NyEhYWF8PDwEM2bNxfz5s0z2kZB3xe+vr6iQ4cOeR5HQT9TC3o1TUJCgrCxsRHTpk3Ltaww72OtVit+/fVX0bx5c+Hk5CTMzc2Fq6uraNeunfjtt9+ETqcTO3fuFIC4dOlSvvFkZGQIlUol2rZtm2+dL7/8Uri4uIj09PRHHt/zSiYjkmQirVq1EuXKlctz2bBhw4RGoxG3bt3Kc3mdOnXE66+//jTDk/IQHx8vXF1dRb9+/UwdygvrYe+LZ+Wjjz4S/v7+RtMh5Odx4h04cKCoWbPmQ+ts2LBBAGLz5s15LtdqtcLPz0988cUXRYrheSG7aSTpGRg2bBg1atTA29ubO3fusGLFCnbs2MGiRYuM6h0+fJgLFy7w008/0b9//zyvbEhMTOTff/8t8CyxUtHExsbyzTff0KxZM5ydnYmKimLWrFkkJSUxdOhQU4f3Qijo++JZGzNmDEuXLmX16tW8/vrrhvInHW9e9wjLERISQlRUlGGW6funOrjf8uXLSU5O5rPPPitSDM8LmYxI0jOg0+kYO3YssbGxKBQKKlWqxLJly3jvvfeM6tWvXx8rKys6duzI119/nee27OzsCnXFkFQ0KpWKy5cv8+GHH3Lnzh3DwNN58+YVaWp+KbeCvi+eNXd3d1asWJFr7MmzjPfDDz/kwIED1KxZ03Ari7zo9XpWrFjxxMdXPWsKIfKYs1ySJEmSJOkZkZf2SpIkSZJkUjIZkSRJkiTJpGQyIkmSJEmSSclkRJIkSZIkk5LJiCRJkiRJJlWskpF9+/bRqVMnvLy8UCgUT/QGcHkZP348CoXC6OHh4fFU9ylJkiRJL5tilYykpKRQrVo1fvjhh2e2z4CAAGJiYgyPM2fOPLN9S5IkSdLLoFhNetauXbt8Z6EDyMzMZMyYMaxYsYK7d+9SuXJlpk6d+tAbiT2Kubm5bA2RJEmSpKeoWLWMPMr//vc/Dhw4wO+//87p06d54403aNu2ba47uBbGxYsX8fLyolSpUrz11lt53lpakiRJkqSiK7YzsCoUCtauXcurr74KQEREBOXKlePq1at4eXkZ6rVs2ZJXXnmFSZMmFXoff//9N6mpqZQvX54bN27w9ddfc/78ec6dO5fnPUMkSZIkSSq8F6Zl5OTJkwghKF++PDY2NobH3r17iYiIAODy5cu5BqQ++Pjoo48M22zXrh2vvfYaVapUoWXLlmzevBlA3qBMkiRJkp6gYjVm5GH0ej1mZmacOHECMzMzo2U2NjYAlChRgtDQ0Idux9HRMd9l1tbWVKlS5bG6fSRJkiRJMvbCJCM1atRAp9MRFxdH48aN86xjYWFBxYoVi7yPjIwMQkND892+JEmSJEmFV6ySkeTkZMLDww1/R0ZGEhwcjJOTE+XLl+fdd9+lZ8+ezJgxgxo1anDr1i12795NlSpVaN++faH3N3z4cDp16oSPjw9xcXF8/fXXJCYm0qtXryd5WJIkSZL0UitWA1iDgoJo1qxZrvJevXqxZMkSsrKy+Prrr1m6dCnXrl3D2dmZ+vXrM2HCBKpUqVLo/b311lvs27ePW7du4erqSr169fjqq6+oVKnSkzgcSZIkSZIoZsmIJEmSJEkvnhfmahpJkiRJkoonmYxIkiRJkmRSxWIAq16v5/r169ja2qJQKEwdjiRJkiRJBSCEICkpCS8vL5TK/Ns/ikUycv36dby9vU0dhiRJkiRJRXDlyhVKliyZ7/JikYzY2toC2QdjZ2dn4mgkSZIkSSqIxMREvL29Dd/j+SkWyUhO14ydnZ1MRiRJkiSpmHnUEAs5gFWSJEmSJJOSyYgkSZIkSSYlkxFJkiRJkkxKJiOSJEmSJJmUTEYkSZIkSTIpmYxIkiRJkmRSMhmRJEmSJMmkZDIiSZIkSZJJyWREkiRJkiSTksmIJEmSJEkmJZMRSZIkSZJMSiYjkiRJkiSZlExGJEkqGG0G+uC/yFr/DWgzTR2NJEkvkGJx115JkkxECLh6DHFiBXfXbeJWsBnadDO8b6Vg03eSqaOTJOkFIZMRSZJyi78Mp/9AnPqNhFOx3DprS1aKpWFx0s4gbPqaLjxJkl4sMhmRJClbegKcWwenVyEuHyDpqpqbZ2zJTHQEQG9vxSV/O8oejiUx/Dae2gwwV5k2ZkmSXggyGZGkl5lOCxG74d+VELYFkZVOSqyKm6ddSI/PbgnJtLZkUwML1lRLx0x/k1+OAElKso5vwaJeV9PGL0nSC0EmI5L0shECYs/Av7/DmT8hJQ6A1JuW3Az1JvW6DoB0SwWb6sDGV3SkqfU4qpwo61iWCM9DlL8OKTvX4SCTEUmSngCZjEjSyyIxJjv5+Pd3iDtnKE5Pc+FKmBfa87cAHZlmsK2WgnX1lWjtrGjh04L2pdpTz6se8enxLFjVlPLXBXdP/IuDyQ5GkqQXiUxGJOlFlpkC5zdnd8NcCgKhzy43s+SmYxPCDyXicOIqcAudAnZXU7C+sSUB/k0YW6o9gd6BaMw1hs25WbkR7+8JB6+TFJWGSL6JwsbVJIcmSdKLQyYjkvSi0esh6p/sFpCQ9ZCZbFiU4v0K+2zLk7r5LBWPhuAgQA8cCFAQ1rU6DV55jTW+LbFX2ee7ec8GLclashSLVCVZB9dg2br/MzgoSZJeZDIZkV4eej0oX+B5/m5egNO/w7+rIPGqoTjL0Zd/yjZmT3oaLmuP0+zkVczvNZCcD7Ajq+/rdAnsibu1e4F2U8+vCRdKLCUgGpL3bMFJJiOSJD0mmYxIL7bbERCyDkLWo485jdLWExz9sh9Opf77v2MpsHYBhcKk4RZaym04uzq7G+b6SUOxXmXPiQpN2Wxjw8Grp2j61x66HROotNnL4yt74/HJMLo2bFvoXdZ0r8l0X3MCorXcPH0BJyGK33mTJOm5IpMR6cVzK/xeArKOiNuh7LC2YqeVFRf8SuKp1VEq4yKlr4RQ+lIWpTO1lM7KwkGvBwvrvJMURz9w8AFzy4fu9pnRZsCFbdndMBe3gT47wxAKM0LLNmKLsyd/J4aTeOsk7bcKJh/RY5WRvaoIKI/P8M/xr1+/yLvXmGvQ1qgI+8+ScU2PuBmGwq3ikzgySZJeUjIZkV4Mty7CuXWIkLWExV9g+70EJLKkl1G16xbmXLcw5wAao3InnY5SmVmUzrpOmetRlLqcnaS463Rk/+ZXgH3J+5IUv/sSl1KgcXy6rQNCwNXj2S0gZ1dD+l3DoiivymzxqsCWjBguJ0dice0SrU4Kuh0S2KUKACzLl8Pt40+wadYUxROIs1T9NqTPPYs6XUnGvr9Qvz7msbcpSdLLSyGEEKYO4lESExOxt7cnISEBOzs7U4cjPS9uhhkSkDMJEey0smKHtYarFhaGKhZKC+p71aelT0vqeNThRuoNLiVc4tLdS0QmRHIp4RIxKTH57sJaQKmsLEpnZFAqKztBKZ2ZRUmt1jiTV9mDo2/eLSv2JcHMIs/tP1J8FJxeld0KcifCUBxn78VWvxpsUaRyLiG73EwnaHXWnDcPKbCJT88+fl8fXIcMwa5dOxRPcLxM2J0wTr7bleqRApfWnrjO2f3Eti1J0oujoN/fsmVEKl7iQuHcOnQhawlOvMxOaw07ra2I9fIwVFGbqWhYohEtfVsSWDIQW0tbw7KStiWp5V7LaJOpWamGxCQnUbmUcIkrSVdIQcdZSwvOWhonExYo8BVmlMrMpHRqEqWzsihzJxTfG2dQP5jfK8yyExJDklLKuGVF/cCVK+kJ2VfB/Ps7RB0wFCdYWrOr9CtsUZtxNOEiIvEMAOYo6Xm9DM13xGF5/XZ2mYcHLoM+xOHVV1FYFDEReohyjuVYXVpD9chUYs9fwVVODS9J0mOQyYj0fBMC4kIgZD3ac2s5nhzFTmsrdllZccvmv6s/rMw1BJZsSkvfljQq0QgrC6sC78LKwooAlwACXAKMyrN0WUQnRRslKJEJkUQmRJKuSydcoSVcpcxuFblHAZRQWlFaKCmdkU7p5DuUSk+ldGI0dnej8g5A4/hfgiJ02eNBtNktG+kKJXv9arLFzoH9yZFkZUTAvfEfNVyr89atspT78xjai6EAmDk54TKgPw7du6NUPb3kQKlQYlm3Nuzah4g1Q1w+jKJs4FPbnyRJLzaZjEjPHyHgxjkIWUfWubUcTr3KTmsrdltpuGv7XwJia2FDM5/mtPRpSYMSDVCZPdkvXwszC8o4lKGMQxnw/a9cL/TEpMQYJSiXEi4RcTeCxMxErupTuQrsswSc7IDspkkXc2tKm1lTSq+gdHoqpRNvUzrpJq5p8SjS4g1Xw2iBI+5l2eLmw870a6Rq4yAxe8r2co7laF+qPa1uuqOft5z007+jBZS2tjj37YNTjx4ora2f6HnIT4V67UhR7cM6Q0H63jVoZDIiSVIRyTEj0vMh534pIetIP7eWg+kx7LC2Yq9GQ5LZf2MdHFUONPdpQUvfltT1qItFUcdiPAVCCG6n385OTu4lKjmPuNS4fNezNbeilMqZ0mZWmOt17M64wZ2sJMPyEjYlaF+qPe1KtaNkVApxs78j9fBhABQaDU49euDc53+YOTg87UM0cjP1JlvfDKR2uMC2sTUlFxx/pvuXJOn5J8eMSM8/ISDmXwhZR2rIOvanx7LD2op9thrS7P+bYtxF7UwL35a08m1FLfdamCsL/7LVp6eTefkyShtbzJ0cUVoVvBunoBQKBS4aF1w0LtTxqGO0LDkz2Xhcyr0WlStJV0jSpnJam8rp++o7qZ1o49eG9qXaU821GhkXLnDzi1lc3rMnu4KFBY7du+PS/wPMXU0zHburlSs3KjhD+C3iIu9SMuU2WDubJBZJkoo3mYxIz5YQcP0UhKwnKWQtQZk32WltxQFbNRn3JSCeVu608G1Fa7/WVHOthlJR+CtB9CkpJO/fT+K2bSTv3YdITTUsU2g0mDs6YubkhJmTI+aOTv/93yn7/zn/mjk6obS2eqxLYm0sbajiWoUqrlWMyjN1mUQlRhkSlMSMRBqVaERdz7qYK83JvHyZ68M/I3HLluxzp1Ri3/VVXD/8EIsSJYocz5Ni26AxbF6L+Q1zxIWdKGp0N3VIkiQVQ4VKRubOncvcuXO5fPkyAAEBAYwdO5Z27drlWT8oKIhmzZrlKg8NDaViRTlJ0ktDiOzxEOfWcTd0HXuybrPD2opD9mq0ChdDNR+bkrT0a00r31YEOAcU6ctfl5REclAQidu2kbL/H0RGhmGZ0t4ekZ6OyMhApKWRlZZG1vXrBdquwtLyvmTFOe8ExtEJcydHzJydUdrYFCh+SzNLyjmWo5xjOaPyrJgYYn76ibtr1oJOB4Btu7a4Dh6MqnTpQpyRp6vKK+1J1KzFLk1B6t71WMtkRJKkIihUMlKyZEmmTJlC2bJlAfj111/p0qULp06dIiAgIN/1wsLCjPqKXE3UrCw9Q0LAtRNwbi23QjewW3eH7dZWHLdXoVP815Rfxq6UIQEp71i+SAmINj6e5N17SNy+jdSDhxBZWYZlFr4+2LVujW3rNqgrZ79GRWoq2jt30N25c+/feHTxd9DeiUd3+zba+Htld+6gjY9HpKUhMjPRxsaijY0lI79A7mdhYWh5MXdyxOxe4mLu7HTv/8YJjNLODoVSifb2bW7Pn0/8bysNx2ETGIjr0CGoK1Uq9Ll52mp61uZ3XyV1z+u5diKY8nJqeEmSiqBQyUinTp2M/v7mm2+YO3cuhw8ffmgy4ubmhsMzHlwnmYBeD9eOw7l1xJ5fzy79XbZbW3HKQYVQOBmqVXQob0hASjsU7Ve+9tYtknbuImn7dlKOHDG0HgBYli1zLwFpjapChVwJjsLaGktra/D2LthhpaZmJyrxOQlMdqKii7+D9vYdQ9Kiu5fg6FNTISsLbVwc2ri4giUvZmaYOTqiT05GpGdf1mtVuzauwz7BqmbNgp6WZ05tria5ih+cv0T8tazsmXBdy5s6LEmSipkijxnR6XT8+eefpKSkUP8R97moUaMG6enpVKpUiTFjxuTZdXO/jIwMMu5rXk9MTCxqmNKzkHgdDn7PlfPr2SkS2WllxWlHFfBfAlLFOSA7AfFphbddwZKAB2XduEHS9h0kbd9O6okT2cnPPaqKFbFrcy8BKVPmcY/IiNLKCksrKyhZsDEa+vT0/5KWBxIYbfwddA8kMPrkZNDp0N26BYC6cmVcP/4Y64YNnsjU7U+bS6Pm8OclrG6YoQ/djlImI5IkFVKhk5EzZ85Qv3590tPTsbGxYe3atVTKp/nY09OT+fPnU6tWLTIyMli2bBktWrQgKCiIJk2a5LuPyZMnM2HChMKGJplC0g2OLG3DDMtMQh0tAUcAFCio4VqNVn5taOnbEg9rj4dvJx+ZV6+RtGMHSdu2kRYcbLRMXaUKtq1bYde6NZa+vnlvwASUajVKLy8svLweXRnQZ2aii8/uIhJCoK5UqVgkITmq1+7AbZuFOCUrSNy7CYcmH5k6JEmSiplCzzOSmZlJdHQ0d+/eZfXq1SxcuJC9e/fmm5A8qFOnTigUCjZs2JBvnbxaRry9veU8I8+b9ARO/9qGvpZJpCuVmKGktnstWvm1oYVvC1w0Lo/eRh4yL18mcXt2ApJ+7pzRMk3NmtkJSKtWz8XVJFL2/Cq/dq9O3dOZZFTPpPry0OfnDseSJJnUU5tnxNLS0jCAtXbt2hw7dozvvvuOn3/+uUDr16tXj+XLlz+0jkqlQvUUp7KWngBtBlG/v8lHFomkK81o6FqTyc1n46h2LNLmMsLDSdy2jaTtO8gIC/tvgVKJVe3a2LZpjW3LVli4uz2hA5CeFIVCga5mAJw+RWqMGVw9Cn6NTB2WJEnFyGPPMyKEMGrFeJRTp07h6en5uLuVTEmv49bq3gzQRhFvYUElu1LMbDW3UPeDEUKQcf68IQHJvHTpv4Xm5ljXrZudgLRogbmznEjreefVpA0sOYXdTSW6c9swk8mIJEmFUKhk5IsvvqBdu3Z4e3uTlJTE77//TlBQEFu3bgVg1KhRXLt2jaVLlwIwe/Zs/Pz8CAgIIDMzk+XLl7N69WpWr1795I9EejaEIHXLp3yUcIKrKhUl1M782PaXAiUiQgjSz5wxJCBZV64YliksLLBu2BDb1q2xbd7smU9tLj2eOjU6cNZhCu53FcT9sx3PDl+ZOiRJkoqRQiUjN27coEePHsTExGBvb0/VqlXZunUrrVq1AiAmJobo6GhD/czMTIYPH861a9fQaDQEBASwefNm2rdv/2SPQnpmtHunMfzKJs5ZaXAws2Je2yUPHRsi9HrSTp0iaft2ErfvQBsTY1imUKuxadwY29atsWnWFDMbm2dwBNLT4KJx4UpZO9yPJ3I5/CaeqXfAyunRK0qSJCFvlCcVgji+mPGHJ7LG1ga1wpyF7ZZQzbVa7npaLanHj2cnIDt2oLt5y7BMaWWFTdNAbFu3waZJ46dyjxjJNFbO+ZDqP+3htqueRnMnQ+Vupg5JkiQTkzfKk56s0E3MPTCeNQ52KFEwrelMo0REZGaScuQoSdu3kbRzF7r4eMMypa0tts2bYdumDdYNG6KUg5NfSKWadYKf9uB4U4n29FbMZTIiSVIByWREerTLB1j99yDmOmdntaPrjaGZz38T191dvYYbU6eiv29yOjMHB2xatsCuTRus69ZFYSkv9XzR1ajUnP3OCkrcFlw6+g/l35ZTw0uSVDAyGZEe7sY59q3pwVdOtgB8UPl93qzwpmFx4t9/EzNmDAiBmYsLtq1aYte6NVZ16qAwly+vl4nKTMUtfw9K/BPD9SsZlL8dDi7lHr2iJEkvPfltIeUvPoozK19juKMGnUJBl9Id+ajmEMPilIMHuTZiJAiBw9tv4TFmDAozMxMGLJmaVb268M86zGItIGK3TEYkSSoQpakDkJ5TKbeJXtGVQXZK0pRKGnq8wriGEw3TlKedOcOVjwZDVha2bdvKREQCoGLL1wFwua0gJXiriaORJKm4kMmIlFtGMrd/e40B6lTizczwdyjLzObfY6G0yF58KZIrH/RHpKZiVb8eXtOmykREAqCcb02ueGS/Fs4HB4M207QBSZJULMhkRDKmyyJ11Xt8JK5zxcKCEho3fmq9wDCpWdaNG0S/3xddfDzqgABKfv8DSjk4VbpHoVCQXLkUALdvmMHVYyaOSJKk4kAmI9J/9Hq06z5keMpZzqpUOFjYMLfNQsOkZrq7d7ny/vtor8dg6eeH94L5mNlYmzho6Xnj2DD7jtxW182zx41IkiQ9gkxGJAOxfQxfx+xkv5UGldKc71vOpZR99q9cfVoaVwYMJONiOOZubngvXIi5k5xhU8qtcsvu6BTgfFdB3Kltpg5HkqRiQCYjUrYDc5h3fhmrbW2yJzULnEF1t+oAiKwsrn78MWnBwSjt7PBeuADLkiVMG6/03HJ19eF6STUAoReuQOodE0ckSdLzTiYjEvz7O2sOTeEnRwcge1Kz5j7Ngex7y8SMGUPK3n0o1Gq8581FXb68CYOVioOs6hUBSIpTQeReE0cjSdLzTiYjL7uLO9i3bRgTXbK7XPpV6WeY1EwIQdy0b0lYvwHMzCgxexZWNWuaMlqpmHBv0hIAx2tm6C/uNHE0kiQ972Qy8jK7epyza/sw3NURnUJB59KdGVxjsGHxnUWLuLNkCQCe33yNbdOmpolTKnYCmr2GVglOSRB+Jgie//txSpJkQjIZeVndvED0728yyMWWNKWSBp71GN9wvGFSs7urVxM3fQYAbiNH4vDqqyYMVipuNDYOxJbKvpdReHQq3A43cUSSJD3PZDLyMkq8zp0V3RjoYMkdMzP8Hcszs9lsw6RmSbt3E/PlWACc+72P8/96mzBYqbhS1K4KQOYNS4jYY+JoJEl6nslk5GWTFk/q8m58pMkk2sKCElYe/NTqZ6wtsucLST12jGufDAO9HvvXuuE6bJiJA5aKK5/ADgB4XFWSfnGHiaORJOl5JpORl0lWGtqVb/GZ4hZn1CrsLWyZ23q+YVKz9PPnufLhIERGBjbNm+M5YYKh20aSCqtMw3ZkmoN9KvwbekxODS9JUr5kMvKy0GkRf/6Pr1MusM9Kg0ppwQ8tfzJMapZ55QrR/fqhT0pCU7sWJWbOQGEub+osFZ2ZSsXt8m4AXJVTw0uS9BAyGXkZCAGbP2Fe3AFW22VPajY18FvDpGbaW7eI7vs+upu3UFWogPdPP6FUq00bs/RCUL1SO/s/MRZwSY4bkSQpbzIZeRns+Ya1F1YbJjX7ou5oWvi0AECXlER0vw/Iio7GomTJ7PvN2NmZMFjpRVK2RVcAfK4puCnHjUiSlA+ZjLzojsxn37HvmXBvUrP3q7xP94rdAdBnZHB10EdkhIZi5uyMz6KFWLi5mTJa6QXjVqMe6SolNulw6lKEnBpekqQ8yWTkRXZ2Ded2jWa4m0v2pGZlOjOkxhAAhE7H9eHDST16FKW1NT4L5mPp62vigKUXjcLcnMRKJQGIu6mRU8NLkpQnmYy8qC4FcWXDQD70cCVNqaS+Z33G18+e1EwIQez4CSTt2InCwoKSP/2EulIlU0csvaDs6jcEQBVjjgjfbeJoJEl6Hslk5EV0PZg7f/RggJtj9qRmThWZ1WwWFmbZk5rdnDOHu3/+CUolXjOmY133FRMHLL3IcsaNlL0KYZf2yKnhJUnKRSYjL5o7l0hd8TofOWqItrDAy9qTH1v8ZJjU7M7SZdyeOw8Aj3HjsGvd2pTRSi8BG/8A0qzNUWfB2ZhEuB1h6pAkSXrOyGTkRZIch3ZZV0bYkD2pmaUdc1vNw9XKFYCEjZu4MWkSAK4fD8Wx+5umjFZ6SSiUStKrlAXg7i01RMiuGkmSjMlk5EWRnohY3o2vlYnstdKgUlryQ4sfKW1fGoDk/fu5PmoUAI49euDcv78po5VeMq6NmgHgcM2M9IhdJo5GkqTnjUxGXgTaDFj1Hj+nR92b1EzJ1MBphknN0v79l6tDhoJWi12HDriP+lxO8y49U97Nsu9TU+4qnLxyGHRZJo5IkqTniUxGiju9Htb2Z+3N4/x4b1KzUXVHGSY1y4iI4MoH/RFpaVg3aoTX5EkolPJpl54tVenSpNqrsdRB2B2lnBpekiQj8lupOBMCto5k/6W/DZOa9a3cl7cqvgVAVkxM9jTvCQmoq1Wl5JzvUFhamjJi6SWlUCgQNbIvH0+9oZLjRiRJMiKTkeJs/wzOBS/h03uTmnUq3YmhNYcCoI2PJ7rv+2hjY7EsUwbvefNQWlmZOGDpZeYZ2AYAr6sKbkbsNHE0kiQ9T2QyUlyd+JUr+yYZJjWr51mPCQ0moFAo0KekcGXAADIvXcLcwwOfhQswd3Q0dcTSS861cXMAyl6HI7cuyqnhJUkykMlIcXR+C3e2DGOghxt3zMyo6FSRWU2zJzUTmZlcHfox6f+exszePvt+M56epo5YkrAsWZI0V1vM9RAZr4bIfaYOSZKk54RMRoqbqEOkrf4fg92cibKwwMvai59a/ISNpQ1Cr+f6qC9I+ecfFBoN3vN/RlWmjKkjliQD8zo1ANDHWKIPl5f4SpKUTSYjxcmNELQruzPC0YbTahX2lvbMbTUXVytXhBDcmDyFxM2bwdycknPmoKlWzdQRS5KRkk3aAlD6ClyMCpJTw0uSBBQyGZk7dy5Vq1bFzs4OOzs76tevz99///3Qdfbu3UutWrVQq9WULl2aefPmPVbAL6270Yjl3fjGWkmQtRUqMxXft/jeMKnZ7Z/nE79sGQBeU6Zg07iRKaOVpDzZ1m8AQOkbcCQ1Hu5cMnFEkiQ9DwqVjJQsWZIpU6Zw/Phxjh8/TvPmzenSpQvnzp3Ls35kZCTt27encePGnDp1ii+++IIhQ4awevXqJxL8SyPlNizrxnyzFP6ys0WBgqmNp1LDLbvJO/6PP7g5ezYA7l98gX3HDiYMVpLyZ+HuTnoJZ5QCrt/WyEt8JUkCwLwwlTt16mT09zfffMPcuXM5fPgwAQEBuerPmzcPHx8fZt/7ovT39+f48eNMnz6d1157Ld/9ZGRkkJGRYfg7MTGxMGG+WDJT4Lc3WZdxnR9cnQH4/JXPaeGbPalZ4vbtxI6fAIDzwAE49exhslAlqSCs6tVFv3oL6usWpIXvRPNKP1OHJEmSiRV5zIhOp+P3338nJSWF+vXr51nn0KFDtH7grrBt2rTh+PHjZGXlPx305MmTsbe3Nzy8vb2LGmbxJgSsG8g/d84y/t6kZn0q9+Ed/3cASDl8hOufDge9Hoc338R1yBBTRitJBeLRuBUA/tGCkzFH5NTwkiQVPhk5c+YMNjY2qFQqBgwYwNq1a6lUqVKedWNjY3F3dzcqc3d3R6vVcuvWrXz3MWrUKBISEgyPK1euFDbMF8OxhYSEb2HYvUnNOpbuaJjULD0khKuDBiGysrBt1QqPcWPl/WakYsG6bl0AfG7C8SwBV4+bOCJJkkyt0MlIhQoVCA4O5vDhwwwcOJBevXoREhKSb/0HvyDFvdHzD/viVKlUhkGyOY+XTsxpErePZpjbf5OaTWwwEaVCSWZUFNH9PkCfkoJV3bp4Tf8WhZmZqSOWpAIxd3Qks5QXALdvqeW4EUmSCp+MWFpaUrZsWWrXrs3kyZOpVq0a3333XZ51PTw8iI2NNSqLi4vD3NwcZ2fnokX8MshIQvzZi/FOtlyzMKekTUlmNp2JhZkFWXFx2febuX0bVSV/Sv74A0qVytQRS1KhODZoDIDLNTPiInaYOBpJkkztsecZEUIYDTa9X/369dmxw/iDZvv27dSuXRsLC4vH3fWLSQjY+DF/ZsWxw9oKc4UZ3wZ+i62lLbrERK70+4Csq1ex8PXBZ/58zGxsTB2xJBWaY8NAAAIuCw4lXIS0eBNHJEmSKRUqGfniiy/Yv38/ly9f5syZM4wePZqgoCDeffddIHusR8+ePQ31BwwYQFRUFMOGDSM0NJRffvmFRYsWMXz48Cd7FC+SU8u4ELaeaU7Z95L5uNYnVHapjD49nSsffkhGWBhmri74LFqEuYuLiYOVpKKxqlMboVDgFQ/BOpWcGl6SXnKFSkZu3LhBjx49qFChAi1atODIkSNs3bqVVq2yR8fHxMQQHR1tqF+qVCm2bNlCUFAQ1atX56uvvmLOnDkPvaz3pXYjhNS/R/CZmwsZSgWNSzSmR6UeCK2Wa8M+Je34CZS2tvgsXIhlyZKmjlaSiszM1hZ9hVIApMSp5NTwkvSSUwjx/M/HnJiYiL29PQkJCS/uYNbMFFjQnLEijrW2NrhpXPmz8184qhyJGT2GhDVrUKhU+CxaiFXt2qaOVpIeW8y333J30S/sqaKgWWMz/AefBnlFmCS9UAr6/S3vTfO8+HsEm1OjWWtrgwIFU5pMxUntxK3vvydhzRowM6PErJkyEZFeGDlTw1eOEhzUyqnhJellJpOR58G/q4g+8zsT701s1r9af+p41CFx+3Zu/TQXAM+JE7Bt3tyUUUrSE2VVswZ6cyWuiRCSKaeGl6SXmUxGTO1WOJmbPmG4mwupSiW13GvRv2p/MsLDifl8FABOvXvjIMfZSC8YpZUV5gH+2X/EWpAqx41I0ktLJiOmlJUOf/Zmlq0FoSpLHFQOTGk8BUVyKlcHfYQ+NRWrevVwG/6pqSOVpKfCsWETACpGw4mYw3JqeEl6SclkxJS2fUFQYjjL7bMH9Xzd8GvcNW5c/2wEmVFRWHh5UWLWTBTmhbqfoSQVG9b16gH3xo2Yy6nhJellJZMRUzm3lthTSxjjmj1O5D3/9wj0DuTWDz+QvHcvCpWKEt/PwdzR0cSBStLTo6leHb2lBQ4pEJGmhkt7TB2SJEkmIJMRU7gTiXbDEEa6OZNgZkYl50p8UusTknbu/G/A6lcT0QQEmDhQSXq6lJaWqGtWB8Dumjmxcmp4SXopyWTkWdNmwl//42eNgpNqNdYW1nzb5FvE5StcHzESAKdePbHv3NnEgUrSs2FfryGQ3VVzKOGCnBpekl5CMhl51naO5+idEH52yB4nMrbeWEooHP8bsPrKK7jJ6fKll4h1vboABEQLDqnk1PCS9DKSycizdH4Ld47O5XNXZ4RCQdeyXWnn1zZ7wOrly5h7elJi9iwU8iaC0ktEXbkywkqNTTpcS1KhD5fzjUjSy0YmI8/K3Svo1w1ktKszN83NKW1fms9f+ZxbP/5EclAQCpWKkt9/j7mTk6kjlaRnSmFujnWdVwDwuaLkfNTu7LtXS5L00pDJyLOgy4LVfVlmqeMfKw0qMxXfBn6Lbt8hbv34I5A9w6qmshywKr2cbOrVB3Kmhr8rp4aXpJeMTEaehT3fcPbGKWY7OQAwos4IfOPNDQNWHXv0wL5LFxMGKEmmZV03u2XE/4rgiKVaTg0vSS8ZmYw8beE7STowm+FuLmgVClr5tqKbV7vsAaspKVjVqYP7iM9MHaUkmZSqYkWws0GTCXfvWpIqkxFJeqnIZORpSoxBrOnPBBcnrlmYU8KmBOPqjSVm5OdkRkZi7uEhB6xKEqBQKrGpm91V4x8Nx+XU8JL0UpHJyNOi18Gafqw2S2ObjTXmCjOmNZlG5qIVJO/ejcLSkpLfz8Hc2dnUkUrSc8FwiW+U4JC5Hq6dMHFEkiQ9KzIZeVr2fUv4tcNMcc6+OmZIzaGUOnObW9//AIDH+PFoqlQxZYSS9FzJuU9NxauCIxYaOW5Ekl4iMhl5GiL3kbZ3KsPdnMlQKGjo1ZC3rZpwfcQIABzffReHbl1NHKQkPV8sS5dG6eKMpRbMb5kTG7HT1CFJkvSMyGTkSUu+Cav7MdXJgQhLS1w0LnxV/QuufTQEfXIymtq1cP98pKmjlKTnjkKhwKbuvbv4XtZzKCEM0u6aNihJkp4JmYw8SXo9rO3PVpHIajsbFCiY3PAb0idMI/PSJczd3Sk5e7YcsCpJ+bC6N26kcpTgoFpODS9JLwuZjDxJB7/jSlQQ412yx4n0q9qPshv+JXnnLhQWFtkDVl1cTBykJD2/csaNlLsOJ8xU6MJ3mTgiSZKeBZmMPCnRh8na9RWfubmQolRS060mPe8GcHPO9wB4jB+HpmpVEwcpSc83i5IlMff0xFwPXjFKzkfvMXVIkiQ9AzIZeRJS78BfffnO0ZZzKhV2lnZM8v2I2M9GghA4vvM2Dq+9ZuooJem5p1AoDK0jAVGCg1nxcmp4SXoJyGTkcQkB6z5kX9YtfrW3A+CbGmNIHzEhe8BqrVq4f/65iYOUpOLD+v5xIxo5NbwkvQxkMvK4Ds/lRsR2xrhmjwV5t8I7lP1xC5nhEZi7uVFy9iwUlpYmDlKSig+rutnJSOlYuIAlKeHyEl9JetHJZORxXDuBbsdYRrk6E2+mxN/Jn/+dsidpx87sAatzvsPc1dXUUUpSsWLh4YGlnx9KAeWuwvGYI6DTmjosSZKeIpmMFFV6Avz5P+bbaTimUWNlbsUU8ze4Myd7hlX3sV+iqV7dtDFKUjGV0zpS+bLgoLmQU8NL0gtOJiNFIQRsGMzx9FjmOTgAMMFnAFljvwUhcHirO45vvGHaGCWpGDPcpyZajhuRpJeBTEaK4vgvxJ/fyEhXF/QKeK1Ee8pPW4M+KQlNjRp4fPGFqSOUpGLN6pVXAPCLg9tac65H7DBxRJIkPU0yGSms2DOIraP40tWZOHMz/Gx9+d/6FDIuhmPu6kqJ72bLAauS9JjMnZ1RlS8P3LuLb8IFOTW8JL3AZDJSGBlJ8GdvlltbstdKg6XSkm+j65O6YxdYWFBizndYuLmZOkpJeiEYTw1vCZf3mzgiSZKeFpmMFJQQsGkY55KimOnkAMBEs66In1cA4DFmDFY1apgwQEl6sVjX/S8ZOaxRy6nhJekFJpORggpeQfLZP/nMzRWtQkFXTQPKzt6YPWD1zTdx7P6mqSOUpBeKVZ06oFTidQfMUpWERMlBrJL0opLJSEHEnUdsHs5EFyeuWJjjZ+5Bj6XX0CcmoqleHfcxo00doSS9cMzs7FBXqgRkt44cklPDS9ILq1DJyOTJk6lTpw62tra4ubnx6quvEhYW9tB1goKCUCgUuR7nz59/rMCfmcxU+LM369RK/raxxgwlk/8pgTY8AjNXF0p89x1KOWBVkp6K3FPDyxvnSdKLqFDJyN69exk0aBCHDx9mx44daLVaWrduTUpKyiPXDQsLIyYmxvAoV65ckYN+praO5NLdi0xycQJgcnRdzPYcAQsLSn73HRbucsCqJD0tVnX/u2nev2oVKeHyEl9JehGZF6by1q1bjf5evHgxbm5unDhxgiZNmjx0XTc3NxzuTRBWbJz+k/RTy/jUy510hYK37lbE77d/APAY/QVWNWuaOEBJerFZ1awB5ua4JWhxTIBjuiM01WnBrFAfXZIkPecea8xIQkICAE5OTo+sW6NGDTw9PWnRogV79jy8qTUjI4PExESjxzN3OwI2fcy3Tg6EW1pSIdWe11ZEZQ9YfeN1HLp3f/YxSdJLRmltjaZqVeBeV425gOsnTRyVJElPWpGTESEEw4YNo1GjRlSuXDnfep6ensyfP5/Vq1ezZs0aKlSoQIsWLdi3b1++60yePBl7e3vDw9vbu6hhFk1WOvzZi23mOv6ws0WdCeM3ahCJSairVcX9yy9RKBTPNiZJekkZxo1cFhySU8NL0gtJIYQQRVlx0KBBbN68mX/++YeSJUsWat1OnTqhUCjYsGFDnsszMjLIyMgw/J2YmIi3tzcJCQnY2dkVJdzC2Tycq6d+4c0SXiQp4LsgPzwPR2Dm4kKp1X9h4e7+9GOQJAmAlCNHie7Vi3hr6D/YjK06N0r0lQmJJBUHiYmJ2NvbP/L7u0gtI4MHD2bDhg3s2bOn0IkIQL169bh48WK+y1UqFXZ2dkaPZyZkPVnHFjDS1YUkpYL+Zz3xPBwB5uaU/G62TEQk6RnTVK+GwtISxxQocRsO3b2QfddsSZJeGIVKRoQQfPTRR6xZs4bdu3dTqlSpIu301KlTeHp6Fmndpyr+MqwfzPeODpxWq6h7RU2LLdcBcP9iFFa1apk2Pkl6CSlVKjT3BosHRAkOalQQKaeGl6QXSaGGpA8aNIjffvuN9evXY2trS2xsLAD29vZoNBoARo0axbVr11i6dCkAs2fPxs/Pj4CAADIzM1m+fDmrV69m9erVT/hQHpM2E/7qwz/KDBY7uOF6V/DJej3o9di/1g3Ht982dYSS9NKyrleX1MOHqRwlWFA9e2p4M/+Opg5LkqQnpFDJyNy5cwFo2rSpUfnixYvp3bs3ADExMURHRxuWZWZmMnz4cK5du4ZGoyEgIIDNmzfTvn37x4v8Sds1gZuxpxhdwgtVpuCbTbYok+6irloVj7Fj5YBVSTIhq5z71EQLkpVKzkXtpqqJY5Ik6ckp8gDWZ6mgA2CKLGwrupXd6e/hxhG1ijF/W1P130TMnJ2zB6x6eDz5fUqSVGAiK4sLdeuhT03lsz5mdLRMYEDPfeBUtK5iSZKejac6gPWFknAN1g1gkb0dRzRquh43p+q/idkDVmfPkomIJD0HFBYWaGpnj9mqHHXvEt9Lcmp4SXpRvNzJiE4Lq/tyUp/Kj44OVInU89buTADcP/88+66hkiQ9F6zvTQ1fOUrwr0pFspwaXpJeGC93MhI0mYSrRxjh5opzguCzTeYo9AL7rl1xfPcdU0cnSdJ9rO5NfhZwBYSAozFHsn9QSJJU7L28N3jQ6xG3Ixjj4kS8UDB1nRnq5EzUlSvjMX5csRywKoRAq9Wi0+lMHYokPXl+flC+PJZJSdRJNONf21QaRJ8ETzmUVTINMzMzzM3Ni+X3xfPm5U1GlEp+q9yKoKPHGboRSsRkYubkRMnv56BUqUwdXaFlZmYSExNDamqqqUORpKdGO3IEIj2dvirItITIu3pIjzR1WNJLzMrKCk9PTywtLU0dSrH20iYjeqFnz5U9dDgmaHhOD2ZmlJg9C4vncTK2R9Dr9URGRmJmZoaXlxeWlpYyU5deSFoHB7Q3b5JuATcdFJQQ5ljKK2okExBCkJmZyc2bN4mMjKRcuXIolS/3yIfH8dImI0qFkpm2/+PqnkMAuI8cifUrr5g4qqLJzMxEr9fj7e2NlZWVqcORpKdG7+hIxu3bWOrhjrkCrS4TO0tzUL60H2WSCWk0GiwsLIiKiiIzMxO1Wm3qkIqtlzaNE3o9t6ZMQ6HXY9+lC4493jN1SI9NZuXSi06hUqEwN0chQJUFKUolZCSbOizpJSY/d5+Ml/YsKpRKvBcswOHNN/GYMF52a0hSMaBQKFBaWwOgyRQkKxWIjCQTRyVJ0uN6aZMRAAt3NzwnTkApm9YkqdjISUasMhXoUZCWmWjiiCRJelwvdTIiSVLxk5OMqDIFCgHJQgfaDBNHJUnS45DJiCQVUVhYGM2aNcPd3R21Wk3p0qUZM2YMWVlZRvX27t1LrVq1DHXmzZtX6H317t0bhUJh9KhXr55RnYiICLp27Yqrqyt2dna8+eab3Lhx46Hb9fPzy7VdhULBoEGDCh3js6KwtERhYQGAOiu7qwbZVSNJxZpMRqTnSmZmpqlDKDALCwt69uzJ9u3bCQsLY/bs2SxYsIBx48YZ6kRGRtK+fXsaN27MqVOn+OKLLxgyZAirV68u9P7atm1LTEyM4bFlyxbDspSUFFq3bo1CoWD37t0cOHCAzMxMOnXqhF6vz3ebx44dM9rmjh3ZU6y/8cYbhY7vWTEaN5IBaQolugzZVSNJxZm8Hu4FJYQgLevZz8SqsTAr1GDgpk2bUrlyZSwtLVm6dCkBAQHs3buXmTNnsnjxYi5duoSTkxOdOnVi2rRp2NjYIITAzc2NefPm8dprrwFQvXp1rl+/TlxcHACHDh2iSZMmxMfHY2Njk2u/vXv35u7duzRq1IgZM2aQmZnJW2+9xezZs7G496s7MzOTMWPGsGLFCu7evUvlypWZOnUqTZs2BaB06dKULl3asE1fX1+CgoLYv3+/oWzevHn4+Pgwe/ZsAPz9/Tl+/DjTp083xF5QKpUKj3xu3HjgwAEuX77MqVOnDHfGXLx4MU5OTuzevZuWLVvmuZ6rq6vR31OmTKFMmTIEBgYWKrZnTWltje7uXawyFdwBUrJSsBMC5EB0SSqWZDLygkrL0lFp7LZnvt+QiW2wsizcy+rXX39l4MCBHDhwACEEkH253Jw5c/Dz8yMyMpIPP/yQESNG8NNPP6FQKGjSpAlBQUG89tprxMfHExISgrW1NSEhIVSqVImgoCBq1aqVZyKSY8+ePXh6erJnzx7Cw8Pp3r071atXp1+/fgD873//4/Lly/z+++94eXmxdu1a2rZty5kzZyhXrlyu7YWHh7N161a6detmKDt06BCtW7c2qtemTRsWLVpEVlaWIfEpiKCgINzc3HBwcCAwMJBvvvkGNzc3ADIyMlAoFKjumz1YrVajVCr5559/8k1G7peZmcny5csZNmzYc391WU7LiGWWQCkUJCOwy0oFS2sTRyZJUlHIbhrJ5MqWLcu0adOoUKECFStWBODjjz+mWbNmlCpViubNm/PVV1/xxx9/GNZp2rQpQUFBAOzbt49q1arRvHlzQ1lQUJChBSM/jo6O/PDDD1SsWJGOHTvSoUMHdu3aBWSPv1i5ciV//vknjRs3pkyZMgwfPpxGjRqxePFio+00aNAAtVpNuXLlaNy4MRMnTjQsi42Nxd3d3ai+u7s7Wq2WW7duFfgctWvXjhUrVrB7925mzJjBsWPHaN68ORkZ2QM369Wrh7W1NSNHjiQ1NZWUlBQ+++wz9Ho9MTExBdrHunXruHv3Lr179y5wXKaitLREcW/6bXWmuDffiOyqkaTiSraMvKA0FmaETGxjkv0WVu3atXOV7dmzh0mTJhESEkJiYiJarZb09HRSUlKwtramadOmDB06lFu3brF3716aNm2Kj48Pe/fu5YMPPuDgwYN8/PHHD91vQEAAZmb/xevp6cmZM2cAOHnyJEIIypcvb7RORkYGzs7ORmWrVq0iKSmJf//9l88++4zp06czYsQIw/IHWxlyWn8K0/rQvXt3w/8rV65M7dq18fX1ZfPmzXTr1g1XV1f+/PNPBg4cyJw5c1Aqlbz99tvUrFnT6BgfZtGiRbRr1w4vL68Cx2VKSmtrdJmZaDLhtkpBZkYilrbF73YOkiTJZOSFpVAoCt1dYirW1sZN61FRUbRv354BAwbw1Vdf4eTkxD///EPfvn0NV6pUrlwZZ2dn9u7dy969e5k4cSLe3t588803HDt2jLS0NBo1avTQ/T7YRaJQKAyDPfV6PWZmZpw4cSLXl/mDXT/e3t4AVKpUCZ1OxwcffMCnn36KmZkZHh4exMbGGtWPi4vD3Nw8V1JTGJ6envj6+nLx4kVDWevWrYmIiODWrVuYm5vj4OCAh4cHpUo9+t4tUVFR7Ny5kzVr1hQ5pmfNzMYGXXw81plKbiNI1qbjpNeBsvAJsSRJplU8vq2kl8rx48fRarXMmDHDMNXy/V00gGHcyPr16zl79iyNGzfG1taWrKws5s2bR82aNbG1tS1yDDVq1ECn0xEXF0fjxo0LvJ4QgqysLEPrR/369dm4caNRne3bt1O7du1CjRd50O3bt7ly5QqeedzY0cXFBYDdu3cTFxdH586dH7m9xYsX4+bmRocOHYoc07OmvHcfJvMsPUq9gmSlEqeMJNA4mDYwSZIKTY4ZkZ47ZcqUQavV8v3333Pp0iWWLVuW59wcTZs25bfffqNq1arY2dkZEpQVK1Y8crzIo5QvX553332Xnj17smbNGiIjIzl27BhTp041XFK7YsUK/vjjD0JDQ7l06RJ//vkno0aNonv37pibZ+f5AwYMICoqimHDhhEaGsovv/zCokWLGD58eIFjSU5OZvjw4Rw6dIjLly8TFBREp06dcHFxoWvXroZ6ixcv5vDhw0RERLB8+XLeeOMNPvnkEypUqGCo06JFC3744Qej7ev1ehYvXkyvXr0McRcHCgsLlPcG7GoyBSlyanhJKrZkMiI9d6pXr87MmTOZOnUqlStXZsWKFUyePDlXvWbNmqHT6YwSj8DAQHQ63RO5NHXx4sX07NmTTz/9lAoVKtC5c2eOHDli6JYxNzdn6tSpvPLKK1StWpXx48czaNAgFi5caNhGqVKl2LJlC0FBQVSvXp2vvvqKOXPmGF3WGxQUhEKh4PLly3nGYWZmxpkzZ+jSpQvly5enV69elC9fnkOHDhm1/oSFhfHqq6/i7+/PxIkTGT16NNOnTzfaVk43zv127txJdHQ0ffr0edxT9swprbO7zOTU8JJUvClETnvycywxMRF7e3sSEhIMcyhI/0lPTycyMpJSpUrJW1gXQ0uWLOGbb74hJCTksbpuXka6xEQyo6PRmSuJchG46nS4OVcAc9WjV5akJ0B+/j5cQb+/ZcuIJJnY1q1bmTRpkkxEiiBn3IiZVo+ZHjk1vCQVU8Wng1iSXlC///67qUMothTm5ijVGvTpaWgyBMma7KnhzaxdTB2aJEmFIFtGJEkq1pQ22ZeGW2dlf5ylZKXA89/7LEnSfWQyIklSsWa4ad69eywmIyAr1YQRSZJUWDIZkSSpWFNaWYFCgVKrx1wHyUolQk4NL0nFikxGJEkq1hRmZig1GiC7dSRLkT01vCRJxYdMRiRJKvZyumpsc8aNaDNArzNlSJIkFYJMRiRJKvZykhFVRvbAVXmJryQVLzIZkSSp2MsZN6LQ6bHQQopSgT49wdRhSZJUQDIZkaRHWLJkCQ4ODsV+Hzl69+7Nq6+++kz29awolEqUVlZUbNOGlXOXZU8Nn5EIQv/U9pkzjf/du3ef2j5yKBQK1q1bZ/j7/Pnz1KtXD7VaTfXq1Z/6/iXpaZPJiCQ9Y35+fsyePduorHv37ly4cOGJ7ufy5csoFAqCg4ONyr/77juWLFnyRPf1PMjpqrHUZ3+sJSkEZCQ/cr20tDTef/99XF1dsbGx4ZVXXuHgwYNPNdbHNW7cOKytrQkLC2PXrl0mjWX8+PEoFIpcD+t7zwfAmjVraNWqFa6urtjZ2VG/fn22bdtmtJ1z587x2muv4efnh0KhyPUeyUt6ejq9e/emSpUqmJubv3BJ9stEJiOS9BzQaDS4ubk9k33Z29s/s1aYZyknGTHXZreGJCqViPS7j1zv22+/5a+//mL58uWcPn2aL7/88rm/e3FERASNGjXC19cXZ2fnPOtkZWU9k1iGDx9OTEyM0aNSpUq88cYbhjr79u2jVatWbNmyhRMnTtCsWTM6derEqVOnDHVSU1MpXbo0U6ZMwcPDo0D71ul0aDQahgwZQsuWLZ/4sUnPkCgGEhISBCASEhJMHcpzKS0tTYSEhIi0tLT/CvV6ITKSn/1Dry9U7DqdTkyZMkWUKVNGWFpaCm9vb/H1118blp8+fVo0a9ZMqNVq4eTkJPr16yeSkpIMy3v16iW6dOkivv32W+Hh4SGcnJzEhx9+KDIzMw11fvzxR1G2bFmhUqmEm5ubeO211x4a0+LFi4W3t7fQaDTi1VdfFdOnTxf29vZGdTZs2CBq1qwpVCqVKFWqlBg/frzIysoyLB83bpzw9vYWlpaWwtPTUwwePFgIIURgYKAAjB45+7x/H+PGjRPVqlUTS5cuFb6+vsLOzk50795dJCYmGur8/fffomHDhsLe3l44OTmJDh06iPDwcMPyB/cTGBhodM5ypKeni8GDBwtXV1ehUqlEw4YNxdGjRw3L9+zZIwCxc+dOUatWLaHRaET9+vXF+fPn8z2HkZGRAhCrVq0SjRo1Emq1WtSuXVuEhYWJo0ePilq1aglra2vRpk0bERcXZ1jv6NGjomXLlsLZ2VnY2dmJJk2aiBMnThhtO79zq9fphI+Xl5g2YoS4GHNOnL15VsybNVHY2dmJ7du35xvrV199JerXr5/v8vzknJf4+HghhBC3bt0Sb731lihRooTQaDSicuXK4rfffjNaJzAwUAwePFh89tlnwtHRUbi7u4tx48YZ1blw4YJo3LixUKlUwt/fX2zfvl0AYu3atUKI3M/ruHHjjM53YGCgUKlU4pdffilQTI96DxZWcHCwAMS+ffseWq9SpUpiwoQJeS7z9fUVs2bNKtR+H3xdPyt5fv5KBgX9/i5U+j958mTWrFnD+fPn0Wg0NGjQgKlTp1KhQoWHrrd3716GDRvGuXPn8PLyYsSIEQwYMKAwu5YKKysVJnk9+/1+cR0srR9d755Ro0axYMECZs2aRaNGjYiJieH8+fNA9i+ltm3bUq9ePY4dO0ZcXBzvv/8+H330kVE3w549e/D09GTPnj2Eh4fTvXt3qlevTr9+/Th+/DhDhgxh2bJlNGjQgDt37rB///584zly5Ah9+vRh0qRJdOvWja1btzJu3DijOtu2beO9995jzpw5NG7cmIiICD744AMgu/n8r7/+YtasWfz+++8EBAQQGxvLv//+C2Q3V1erVo0PPviAfv36PfTcREREsG7dOjZt2kR8fDxvvvkmU6ZM4ZtvvgEgJSWFYcOGUaVKFVJSUhg7dixdu3YlODgYpVLJ0aNHeeWVV9i5cycBAQFYWlrmuZ8RI0awevVqfv31V3x9fZk2bRpt2rQhPDwcJycnQ73Ro0czY8YMXF1dGTBgAH369OHAgQMPPYZx48Yxe/ZsfHx86NOnD2+//TZ2dnZ89913WFlZ8eabbzJ27Fjmzp0LQFJSEr169WLOnDkAzJgxg/bt23Px4kVsbW0fem4VSiUoFAA46CyZ8vM8fvluIds2rqVek+b5xtipUyfGjRvHokWL6Nu370OP52HS09OpVasWI0eOxM7Ojs2bN9OjRw9Kly5N3bp1DfV+/fVXhg0bxpEjRzh06BC9e/emYcOGtGrVCr1eT7du3XBxceHw4cMkJiby8ccfG+0nJiaGli1b0rZtW4YPH46NjQ23bt0CYOTIkcyYMYPFixejUqkKFNPD3oNFsXDhQsqXL0/jxo3zraPX60lKSjJ6fUkvucJkOG3atBGLFy8WZ8+eFcHBwaJDhw7Cx8dHJCcn57vOpUuXhJWVlRg6dKgICQkRCxYsEBYWFuKvv/4q8H5ly8jD5ZmZZyQLMc7u2T8y8n8tPCgxMVGoVCqxYMGCPJfPnz9fODo6Gr2+Nm/eLJRKpYiNjRVCZP8a8vX1FVqt1lDnjTfeEN27dxdCCLF69WphZ2dn1KLwMG+//bZo27atUVn37t2NWi0aN24sJk2aZFRn2bJlwtPTUwghxIwZM0T58uWNWmful9evvrxaRqysrIzi/uyzz0TdunXzjT0uLk4A4syZM0KI/1onTp06ZVTv/l+QycnJwsLCQqxYscKwPDMzU3h5eYlp06YJIYxbRnJs3rxZAPn+GszZ98KFCw1lK1euFIDYtWuXoWzy5MmiQoUK+R6TVqsVtra2YuPGjUKIApxbb28xbcQI8emA/sLV3VVsDFot9Hev5Lv92NhY4eHhIUaNGiXKlStn9LzcunVLAOL48eN5rvtgy0he2rdvLz799FPD34GBgaJRo0ZGderUqSNGjhwphBBi27ZtwszMTFy58l/Mf//9t1HLiBBCVKtWzahFJed8z549O99Y8orpUe/BwkpPTxeOjo5i6tSpD603bdo04eTkJG7cuJHnctky8uJ4Ki0jW7duNfp78eLFuLm5ceLECZo0aZLnOvPmzcPHx8cwGMnf35/jx48zffp0XnvttTzXycjIICMjw/B3YqKcTbHQLKyyWylMsd8CCg0NJSMjgxYtWuS7vFq1akYD4Ro2bIherycsLAx3d3cAAgICMDMzM9Tx9PTkzJkzALRq1QpfX19Kly5N27Ztadu2LV27dsXKKu84Q0ND6dq1q1FZ/fr1jV77J06c4NixY4YWCsjuu05PTyc1NZU33niD2bNnG/bZvn17OnXqVOhxCH5+ftja2hodV1xcnOHviIgIvvzySw4fPsytW7fQ67PHSkRHR1O5cuUC7SMiIoKsrCwaNmxoKLOwsOCVV14hNDTUqG7VqlWNYgGIi4vDx8cn3+3fv07O81WlShWjsvuPKS4ujrFjx7J7925u3LiBTqcjNTWV6OhogEefW4WC7379ldS0NH7ftYoSft5kpN9FbVfC0GpyvxkzZuDt7c2kSZPo378/jRs35ubNm3zzzTecOXMGW1tbo3gfRqfTMWXKFFatWsW1a9cMn2P3v34fPCdg/LyGhobi4+NDyZIlDcvr169foP0D1K5du1AxPeo9WFhr1qwhKSmJnj175ltn5cqVjB8/nvXr1z+zcVLS8++xBrAmJGRfx/+wprZDhw7RunVro7I2bdpw/PjxfAdYTZ48GXt7e8PD29v7ccJ8OSkU2d0lz/qRxwd+fjT3pvDOjxACRT7bu7/cwsIi17KcL2ZbW1tOnjzJypUr8fT0ZOzYsVSrVi3fyzFFAe72qtfrmTBhAsHBwYbHmTNnuHjxImq1Gm9vb8LCwvjxxx/RaDR8+OGHNGnSpNADCh92XJDdvXD79m0WLFjAkSNHOHLkCACZmZkF3kfO8T54nvM69/fHk7Ps/ngedQw56zxYdv82evfuzYkTJ5g9ezYHDx4kODgYZ2dnwzE98twqFDSsXRudXk/Q+t0AJKLP98Z5p0+fpkaNGgD4+vqyc+dOFi5cSP/+/Zk3bx7vvfdevt1bD5oxYwazZs1ixIgR7N69m+DgYNq0aZPr+XjY85rX6y+/90BeHkx8HhXTo96DhbVw4UI6duyY7wDUVatW0bdvX/744w854FQyUuRkRAjBsGHDaNSo0UN/hcXGxhp+EeVwd3dHq9Ua+jkfNGrUKBISEgyPK1euFDVM6TlWrlw5NBpNvpcmVqpUieDgYFJSUgxlBw4cQKlUUr58+QLvx9zcnJYtWzJt2jROnz7N5cuX2b17d777PHz4sFHZg3/XrFmTsLAwypYtm+uhVGa/pTQaDZ07d2bOnDkEBQVx6NAhQ2uNpaUlOt3jTVV++/ZtQkNDGTNmDC1atMDf35/4+HijOjlfog/bV9myZbG0tOSff/4xlGVlZXH8+HH8/f0fK8ai2L9/P0OGDKF9+/YEBASgUqlyfU487NwC1KlVi/Vz5/LD7Ln88sMvJCqVkM9VNSVKlODgwYOGc1S+fHm2b9/OH3/8wbp16/jyyy8LFXuXLl147733qFatGqVLl+bixYuFOv5KlSoRHR3N9ev/tWoeOnSoUNsoTEyPeg8WRmRkJHv27Ml33M3KlSvp3bs3v/32Gx06dHjs/UkvliJfv/bRRx9x+vRpow+x/OT1qyuv8hwqlQqVSlXU0KRiQq1WM3LkSEaMGIGlpSUNGzbk5s2bnDt3jr59+/Luu+8ybtw4evXqxfjx47l58yaDBw+mR48euRLc/GzatIlLly7RpEkTHB0d2bJlC3q9Pt9B10OGDKFBgwZMmzaNV199le3bt+fqnhw7diwdO3bE29ubN954A6VSyenTpzlz5gxff/01S5YsQafTUbduXaysrFi2bBkajQZfX18gu/tl3759vPXWW6hUKlxcXAp97hwdHXF2dmb+/Pl4enoSHR3N559/blTHzc0NjUbD1q1bKVmyJGq1Gnt7e6M61tbWDBw4kM8++wwnJyd8fHyYNm0aqampjzWYs6jKli3LsmXLqF27NomJiXz22WdGv94fdW4BFGo1datXZ938+XTq9z7m5uZM+KAnaluvXC13Q4YMoV69erz11luMGjUKlUrFpk2bDC0Hy5YtY8SIEQWOffXq1Rw8eBBHR0dmzpxJbGxsoZK6li1bUqFCBXr27MmMGTNITExk9OjRBV6/sDE96j1YGL/88guenp60a9cu17KVK1fSs2dPvvvuO+rVq0dsbCyQnVjmvCYzMzMJCQkx/P/atWsEBwdjY2ND2bJlAfjhhx9Yu3atUfIUEhJCZmYmd+7cISkpyTCvjpwMrngpUsvI4MGD2bBhA3v27DHq28yLh4eH4YWXIy4uDnNz83yvj5deHl9++SWffvopY8eOxd/fn+7duxv6z62srNi2bRt37tyhTp06vP7667Ro0YIffvihwNt3cHBgzZo1NG/eHH9/f+bNm8fKlSsJCAjIs369evVYuHAh33//PdWrV2f79u2MGTPGqE6bNm3YtGkTO3bsoE6dOtSrV4+ZM2cavhAdHBxYsGABDRs2pGrVquzatYuNGzcaXu8TJ07k8uXLlClTBldX16KcNpRKJb///jsnTpygcuXKfPLJJ3z77bdGdczNzZkzZw4///wzXl5edOnSJc9tTZkyhddee40ePXpQs2ZNwsPD2bZtG46OjkWK7XH88ssvxMfHU6NGDXr06MGQIUOMxhU86twCKFUqUCioX6UKS39bxPeTv2fGgqWgTc+1v2rVqnHw4EGSkpJo1aoV9erV459//jF014waNYrVq1cXKPYvv/ySmjVr0qZNG5o2bYqHh0ehJ+FSKpWsXbuWjIwMXnnlFd5//32jsUmFVZCYHvYeBGjatCm9e/d+6H70ej1Lliyhd+/eRuO3cvz8889otVoGDRqEp6en4TF06FBDnevXr1OjRg1q1KhBTEwM06dPp0aNGrz//vuGOrdu3SIiIsJo2+3bt6dGjRps3LiRoKAgwzak4kUhCtJJfo8QgsGDB7N27VqCgoIoV67cI9cZOXIkGzduNGS8AAMHDiQ4OLjAzY+JiYnY29uTkJCAnZ1dQcN9aaSnpxMZGUmpUqVQq9WmDkeSTC4zKgpdUhJaJ1uiLZNRCUFZlTPYeZo6tGLHz8+P8ePHPzIheVnJz9+HK+j3d6FaRgYNGsTy5cv57bffsLW1JTY2ltjYWNLS0gx1Ro0aZTSSesCAAURFRTFs2DBCQ0P55ZdfWLRoEcOHDy/CYUmSJD2a8l7Tv0VyBgogQ6EgowCzsUrGzp8/j62t7UOvjpGkJ6FQycjcuXNJSEigadOmRk1tq1atMtSJiYkxXIYHUKpUKbZs2UJQUBDVq1fnq6++Ys6cOfle1itJkvS4zGxtQaFAZGZiT/aYk0SRBVm5u2qk/FWsWJEzZ84YBmZL0tNSqAGsBenRyesGXIGBgZw8ebIwu5IkSSoyhZkZZja26JISscsw464q+141rul3waJg9z2RJOnZkemuJEkvJKV9dv+0RUr2BIrpCgWZsqtGkp5LMhmRJOmFZNRVI7IHFibqM0Cb8Yg1JUl61mQyIknSC0lhZpadkAD2mdk90tkToCWYMixJkvIgkxFJkl5YSjvjrpo0hZLMtPiHrSJJkgnIZESSpBeWcVdN9qzOibp00BXuPkGSJD1dMhmRJOmFdX9XjV1OV41Z/veqkSTJNGQyIkkvicuXL6NQKAz37nheKRQK1q1bl+/yghxHUFAQCoWCu3fvGrpqLO/rqskqYFeNn58fs2fPznd57969Cz3le1EsWbIEBwcHo7L58+fj7e2NUql8aIySVBzIZESSpOdKTExMnjdbK6r/umqysNNn38k4UZsOOu0T28ezlpiYyEcffcTIkSO5du0aH3zwwTPbd06il9fj2LFjhnpDhw6lVq1aqFSqfG9aJ4Rg+vTplC9fHpVKhbe3N5MmTXro/v38/HLt98GbRErFT5Hv2itJ0ssnMzMTS0vLp7ptD48nOylZTleNLjER+0wLEtWZJJopcE5PAOviebPO6OhosrKy6NChA56eed9vJysrCwsLiye+7wYNGhATE2NU9uWXX7Jz505q165tKBNC0KdPH44cOcLp06fz3NbQoUPZvn0706dPp0qVKiQkJHDr1q1HxjBx4kT69etn+NvGxqaIRyM9L2TLyAtKCEFqVuozfxTivotA9t0+p06dStmyZVGpVPj4+BjdpfTMmTM0b94cjUaDs7MzH3zwAcnJyYblOc3k06dPx9PTE2dnZwYNGkRW1n8DFH/66SfKlSuHWq3G3d2d119/vVAxKhQKFi5cSNeuXbGysqJcuXJs2LDBqM7evXt55ZVXUKlUeHp68vnnn6PV5v/LO6fZfdOmTVSoUAErKytef/11UlJS+PXXX/Hz88PR0ZHBgwej0+kM6y1fvpzatWtja2uLh4cH77zzjtEdVuPj43n33XdxdXVFo9FQrlw5Fi9enGcMer2efv36Ub58eaKiovKsk3N+J0+ejJeXF+XLlwfg2rVrdO/eHUdHR5ydnenSpQuXL182rKfVahkyZAgODg44OzszcuRIevXqZdSl0bRpUz766COGDRuGi4sLrVq1Mpzv+7tpjh49So0aNVCr1dSuXZtTp07linPLli2UL18ejUZDs2bNjGKB7KtqDgcH077rG9TyrkX96q346JNPSElJMdSJi4ujU6dOaDQaSpUqxYoVK/I8Jw+zdetWGjVqZDjujh07Gt1lNqeLac2aNTRr1gwrKyuqVauW66ahS5YswcfHBysrK7p27crt27eNllWpUgWA0qVLo1AouHz5MuPHj6d69er88ssvlC5dGpVKhRDikTEBXL16lbfeegsnJyesra2pXbs2R44cyfMYcxLGnIezszMbNmygT58+KBQKQ705c+YwaNAgSpcuned2QkNDmTt3LuvXr6dz586UKlWK6tWr07Jly0ee55zXf85DJiPFn2wZeUGladOo+1vdZ77fI+8cwcrCqsD1R40axYIFC5g1axaNGjUiJiaG8+fPA5Camkrbtm2pV68ex44dIy4ujvfff5+PPvrI6LYDe/bswdPTkz179hAeHk737t2pXr06/fr14/jx4wwZMoRly5bRoEED7ty5w/79+wt9XBMmTGDatGl8++23fP/997z77rtERUXh5OTEtWvXaN++Pb1792bp0qWcP3+efv36oVarGT9+fL7bTE1NZc6cOfz+++8kJSXRrVs3unXrhoODA1u2bOHSpUu89tprNGrUiO7duwPZrQdfffUVFSpUIC4ujk8++YTevXuzZcsWIPsXakhICH///TcuLi6Eh4cb3cgyR2ZmJu+88w4RERH8888/uLm55Rvnrl27sLOzY8eOHdlJbmoqzZo1o3Hjxuzbtw9zc3O+/vpr2rZty+nTp7G0tGTq1KmsWLGCxYsX4+/vz3fffce6deto1qyZ0bZ//fVXBg4cyIEDB/JMZFNSUujYsSPNmzdn+fLlREZGGt12HuDKlSt069aNAQMGMHDgQI4fP86nn35qVCfk8mU69+/P2I8+YtL3k4i+c4NvR37DR4M+ZPGSX4HsxOvKlSvs3r0bS0tLhgwZYpToFURKSgrDhg2jSpUqpKSkMHbsWLp27UpwcLDR/V1Gjx7N9OnTKVeuHKNHj+btt98mPDwcc3Nzjhw5Qp8+fZg0aRLdunVj69atjBs3zrBu9+7d8fb2pmXLlhw9ehRvb29cXV0BCA8P548//mD16tWYmZkVKKbk5GQCAwMpUaIEGzZswMPDg5MnT6LX6wt0zBs2bODWrVuFvqvvxo0bKV26NJs2baJt27YIIWjZsiXTpk3DycnpoetOnTqVr776Cm9vb9544w0+++yzp9Zi9zJIXP0rCZv+xHPGUswfce6fGlEMJCQkCEAkJCSYOpTnUlpamggJCRFpaWmGspTMFFF5SeVn/kjJTClw3ImJiUKlUokFCxbkuXz+/PnC0dFRJCcnG8o2b94slEqliI2NFUII0atXL+Hr6yu0Wq2hzhtvvCG6d+8uhBBi9erVws7OTiQmJhbqnN4PEGPGjDH8nZycLBQKhfj777+FEEJ88cUXokKFCkKv1xvq/Pjjj8LGxkbodLo8t7l48WIBiPDwcENZ//79hZWVlUhKSjKUtWnTRvTv3z/f2I4ePSoAwzqdOnUS//vf//KsGxkZKQCxf/9+0bJlS9GwYUNx9+7dhx57r169hLu7u8jIyDCULVq0KNfxZmRkCI1GI7Zt2yaEEMLd3V18++23huVarVb4+PiILl26GMoCAwNF9erVc+0TEGvXrhVCCPHzzz8LJycnkZLy3+tq7ty5AhCnTp0SQggxatQo4e/vbxTPyJEjBSDi4+OFEEL06NFD9H3nHZF65oxIuHJJnL15VvyxYYlQKpUiLS1NhIWFCUAcPnzYsI3Q0FABiFmzZj30/Nx/TA+Ki4sTgDhz5owQ4r/nYOHChYY6586dE4AIDQ0VQgjx9ttvi7Zt2xptp3v37sLe3t7w96lTpwQgIiMjDWXjxo0TFhYWIi4uLt948orp559/Fra2tuL27dsPXS8/7dq1E+3atct3+bhx40S1atVylffv31+oVCpRt25dsW/fPrFnzx5RvXp10axZs4fub+bMmSIoKEj8+++/YsGCBcLFxUX07du3SLE/CXl9/hYn2luxIrhmRRFSoaIIHdLpiW+/oN/fsmXkBaUx13DknbybWZ/2fgsqNDSUjIwMWrRoke/yatWqYW1tbShr2LAher2esLAw3N3dAQgICDD8CgTw9PTkzJkzALRq1QpfX19Kly5N27Ztadu2raG7pTCqVq1q+L+1tTW2traGX82hoaHUr1/fqIm6YcOGJCcnc/XqVXx8fPLcppWVFWXKlDH87e7ujp+fn1GTs7u7u9Gv81OnTjF+/HiCg4O5c+eO4ddrdHQ0lSpVYuDAgbz22mucPHmS1q1b8+qrr9KgQQOj/b799tuULFmSXbt2Feg8VKlSxehX54kTJwgPD8f23iWzOdLT04mIiCAhIYEbN27wyiuvGJaZmZlRq1atXL+27x9jkJec18D9cdavXz9XnXr16hmd/wfr5MT8+9q1oFCgJ7sVRq/XExkZyYULFzA3NzeKp2LFirmuYHmUiIgIvvzySw4fPsytW7eMnp/KlSsb6t3/esoZ8xEXF0fFihUJDQ2la9euRtutX78+W7dufeT+fX19Da0kBY0pODiYGjVqPLI1Ii9Xr15l27Zt/PHHH4VeV6/Xk5GRwdKlSw3df4sWLaJWrVqEhYVRoUKFPNf75JNPDP+vWrUqjo6OvP7660ydOhVn5+I5BshkhCDsk9exTIEYR4h9tw0VTRSKTEZeUAqFolDdJaag0Tw8cRFCGH3B3O/+8gcH6SkUCsMHrq2tLSdPniQoKIjt27czduxYxo8fz7Fjxwr1RfOwfeQVp7jX5ZBf/Plt82H7SUlJoXXr1rRu3Zrly5fj6upKdHQ0bdq0ITMzE4B27doRFRXF5s2b2blzJy1atGDQoEFMnz7dsM327duzfPlyDh8+TPPmzR957Pcng5D9JVKrVq08x1Tc/0WY3zl52LYflNc6Ramj1+v54IMP6N++PQjBHWcLUhRaXPU6ypTyIywsLM+YC6tTp054e3uzYMECvLy80Ov1VK5c2fD85Lj/ec7Z5/2vp6LK63w+KqZHvQ8fZvHixTg7O9O5c+dCr+vp6Ym5ubkhEQHw9/cHshOl/JKRB9WrVw/I7qKSyUjh3FoxAcXR7AHDx98qz2d1PjRZLHIAq2Qy5cqVQ6PRsGvXrjyXV6pUieDgYKNBhgcOHECpVBp9gD2Kubm5oS/69OnTXL58md27dz92/PfHefDgQaMvkYMHD2Jra0uJEiWe2H7Onz/PrVu3mDJlCo0bN6ZixYp5jmlwdXWld+/eLF++nNmzZzN//nyj5QMHDmTKlCl07tyZvXv3FjqOmjVrcvHiRdzc3ChbtqzRw97eHnt7e9zd3Tl69KhhHZ1Ol+fA00epVKkS//77r9G4l8OHD+eq82DZg3/XrFmTkJAQygcEUMbHh+olyuJT2geX0r5Yigz8/f3RarUcP37csE5YWBh3794tcKy3b98mNDSUMWPG0KJFC/z9/YmPL/zU8wU5nicZU9WqVQ0tbYUhhGDx4sX07NmzSFftNGzYEK1WazSY9sKFC0B2C09B5byu8ruqSMqbLuokF3/8HYDD1S3pP2DpYyfjj0MmI5LJqNVqRo4cyYgRI1i6dCkREREcPnyYRYsWAfDuu++iVqvp1asXZ8+eZc+ePQwePJgePXoYumgeZdOmTcyZM4fg4GCioqJYunQper3e8Kvrhx9+yLebqKA+/PBDrly5wuDBgzl//jzr169n3LhxDBs2zGjQ4uPy8fHB0tKS77//nkuXLrFhwwa++uorozpjx45l/fr1hIeHc+7cOTZt2mT4tXm/wYMH8/XXX9OxY0f++eefQsXx7rvv4uLiQpcuXdi/fz+RkZHs3buXoUOHcvXqVcP2J0+ezPr16wkLC2Po0KHEx8cX+sPunXfeQalU0rdvX0JCQtiyZYtRKw/AgAEDiIiIYNiwYYSFhfHbb78ZDXAGGDlyJIcOHeLjr77i3/PniTp3gT1b9zD6iylo0+KpUKECbdu2pV+/fhw5coQTJ07w/vvvF6rVIOfKovnz5xMeHs7u3bsZNmxYoY4XYMiQIWzdupVp06Zx4cIFfvjhhwJ10RQ1prfffhsPDw9effVVDhw4wKVLl1i9enWuK3wetHv3biIjI+nbt2+ey8PDwwkODiY2Npa0tDSCg4MJDg42tMi0bNmSmjVr0qdPH06dOsWJEyfo378/rVq1MvzYOHr0KBUrVuTatWsAHDp0iFmzZhEcHExkZCR//PEH/fv3p3Pnzvl2h0p5yEhi/9ieOMQruGsNtb7+EXuVvUlDksmIZFJffvkln376KWPHjsXf35/u3bsbfu1bWVmxbds27ty5Q506dXj99ddp0aIFP/zwQ4G37+DgwJo1a2jevDn+/v7MmzePlStXEhAQAMCtW7dyXeZYWCVKlGDLli0cPXqUatWqMWDAAPr27cuYMWMea7sPcnV1ZcmSJfz5559UqlSJKVOm5PpitrS0ZNSoUVStWpUmTZpgZmbG77//nuf2Pv74YyZMmED79u05ePBggeOwsrJi3759+Pj40K1bN/z9/enTpw9paWnY3ZvtdOTIkbz99tv07NmT+vXrY2NjQ5s2bVCr1YU6ZhsbGzZu3EhISAg1atRg9OjRTJ061aiOj48Pq1evZuPGjVSrVo158+blmjiratWq7N27l/DLl2nVqxf1u3blp8k/4OLuQlJWMgg9ixcvxtvbm8DAQLp168YHH3zw0KuMHqRUKvn99985ceIElStX5pNPPuHbb78t1PFCdrfDwoUL+f7776levTrbt28v8mupIDFZWlqyfft23NzcaN++PVWqVGHKlClG47DysmjRIho0aJBnsgvw/vvvU6NGDX7++WcuXLhAjRo1qFGjBtevXzfEtnHjRlxcXGjSpAkdOnTA39/f6PWamppKWFiY4VJ9lUrFqlWraNq0KZUqVWLs2LH069ePlStXFun8vJSEIHR+D5yPZU8ZcLNfO6qWbWTioEAhHqeD8hlJTEzE3t6ehIQEw4ed9J/09HQiIyMpVapUoT/sJelZ0Ov1+Pv78+abb+ZqzXnWMqOvoEtMINPBiqvqNGz0enztfEBt2l+GUvFU3D5/kw/P459Rs/GNUXApwJ52fx58oi24Dyro97ccwCpJ0hMXFRXF9u3bCQwMJCMjgx9++IHIyEjeeecdU4eGmb0dusQELFOyQA0pSiXatHjMZTIiveBEzGn+/GUm9WLMSFNB/VnLnmoiUhjPRxSSJL1QlEolS5YsoU6dOjRs2JAzZ86wc+fOfJv0n2lsNjagVEJWFrY6cwSQnJkEomCTfElSsZSeyIalPah+KLv7zfzD/+HkU87EQf1HtoxIkvTEeXt7c+DAAVOHkSfDvWoSErDPtCBJoyVRAQ4ZyaCW3cDSC0gIzq97n9S9maizILGCJ6/0G27qqIzIlhFJkl46Zvf6ri1Ts6/sSFYq0aXfNWFEkvT0pB6dy4qjp6l+CXRmCqrOnI/iOemeyfF8RSNJkvQMKG1t73XVaLHRmSGApIxEeP7H80tSoYhrp/j2n5l03JN9Wb19//fRlClr4qhyk8mIJEkvHYVSidm96ewdMrMn7EpUCMhMedhqklS8pCewbkMv3A9ZYpcGer8SlBzwkamjypNMRiRJein911WTPYdFslKBLr3wM6ZK0nNJCMLX9mVDjJbAswKhgNJTpqN4Tu9uLJMRSZJeSkZdNVolAgXJsqtGekGkHv6RUfFn6L0t+/Xs+N57aKpXN21QDyGTEUmSXkpGXTVZ2b8WE9FDVqopw5Kkx3ftBJNPzqLOYTPcEkDp4Y7b0I9NHdVDyWREMqmmTZvy8ccfP7SOn58fs2fPNvytUChYt24dAJcvX0ahUBAcHPzUYnzSgoKCUCgUhboJ2/O4jxzjx4+n+nP8i+thDF01Kf911ejT7hqWF+T1+aQ8y9fyg++p2NhYWrVqhbW1daHuZi09h9LusnF9b04naehwLLtVpMTEiZjZPPwO2aYmkxHpuXfs2DE++OCDPJd5e3sTExND5cqVn3FUz4+8vjAbNGhATEwM9vZPdlbR+xPBHMOHD8/3zsvPO0NXjVaLtVaJHgXJGXcfq6tGr9czcuRIvLy80Gg0VK1alfXr1z+5oJ+CWbNmERMTQ3BwsOHOuaayZMkSFApFno/771J95swZAgMD0Wg0lChRgokTJxrdOTsmJoZ33nmHChUqoFQqC5xUHjt2jBYtWuDg4ICjoyOtW7cuPj92hODS2r5MstQxYIsOpQC7jh2xadLE1JE9kkxGpOeeq6srVlZWeS4zMzPDw8MDc3PTzt+n0+nQ65+fGTwtLS3x8PB4JrcEt7GxwdnZ+anv52nI86oa9KBNL/I2ly9fzqxZs5g5cyahoaHMnDkTa+vn+1dpREQEtWrVoly5cvneHDDnZnVPW/fu3YmJiTF6tGnThsDAQENsiYmJtGrVCi8vL44dO8b333/P9OnTmTlzpmE7GRkZuLq6Mnr0aKpVq1agfSclJdGmTRt8fHw4cuQI//zzD3Z2drRp0+aZHf/jSD/4PcNTztLiuAK/OFDa2+M+6nNTh1UwohhISEgQgEhISDB1KM+ltLQ0ERISItLS0gxler1e6FJSnvlDr9cXKvbAwEAxaNAgMWjQIGFvby+cnJzE6NGjjbbj6+srZs2aZfgbEGvXrhVCCBEZGSkAcerUKSGEEHv27BGA2Llzp6hVq5bQaDSifv364vz580b73bBhg6hZs6ZQqVSiVKlSYvz48SIrK8uwfMaMGaJy5crCyspKlCxZUgwcOFAkJSUZli9evFjY29uLjRs3Cn9/f2FmZiYuXbqU5zFu3rxZlCtXTqjVatG0aVOxePFiAYj4+HhDnQMHDojGjRsLtVotSpYsKQYPHiySk5MNy3/88UdRtmxZoVKphJubm3jttdeEEEL06tVLAEaPyMhIw3nI2UdOvFu3bhUVK1YU1tbWok2bNuL69euGfRw9elS0bNlSODs7Czs7O9GkSRNx4sQJo+fh/v34+voKIYQYN26cqFatmqGeTqcTEyZMECVKlBCWlpaiWrVq4u+//zYsz3nOVq9eLZo2bSo0Go2oWrWqOHjwYJ7nLwcg5s2bJzp06CA0Go2oWLGiOHjwoLh48aIIDAwUVlZWol69eiI8PNywTnh4uOjcubNwc3MT1tbWonbt2mLHjh1G2/1++nRRxsdHqCwthZOrk2jdsZXQJWSfl8DAQDF06FBD3b///lvY2dmJX3/9Nd84ly1bJry8vB56LHl58LWs1WpFnz59hJ+fn1Cr1aJ8+fJi9uzZRuv06tVLdOnSRXz77bfCw8NDODk5iQ8//FBkZmYa6ty4cUN07NhRqNVq4efnJ5YvX270nnrwee3Vq5cQIvt8z507V3Tu3FlYWVmJsWPHFigmIYRYtGiRqFSpkrC0tBQeHh5i0KBBhT4fOeLi4oSFhYVYunSpoeynn34S9vb2Ij093VA2efJk4eXlledn0IPPY36OHTsmABEdHW0oO336tACMXlf3y+vz1ySuHBPjvi8lWs4MEP9WqihCKlQU8fc+J02poN/fMhl5AeT1ZtClpIiQChWf+UOXklKo2AMDA4WNjY0YOnSoOH/+vFi+fLmwsrIS8+fPN9QpSjJSt25dERQUJM6dOycaN24sGjRoYFh/69atws7OTixZskRERESI7du3Cz8/PzF+/HhDnVmzZondu3eLS5cuiV27dokKFSqIgQMHGpYvXrxYWFhYiAYNGogDBw6I8+fPGyUPOaKjo4VKpTI6Pnd3d6NE4fTp08LGxkbMmjVLXLhwQRw4cEDUqFFD9O7dWwiR/QFpZmYmfvvtN3H58mVx8uRJ8d133wkhhLh7966oX7++6Nevn4iJiRExMTFCq9XmmYxYWFiIli1bimPHjokTJ04If39/8c477xhi3bVrl1i2bJkICQkRISEhom/fvsLd3V0kJiYKIbK/FACxePFiERMTI+Li4oQQuZORmTNnCjs7O7Fy5Upx/vx5MWLECGFhYSEuXLhg9JxVrFhRbNq0SYSFhYnXX39d+Pr6GiWEDwJEiRIlxKpVq0RYWJh49dVXhZ+fn2jevLnYunWrCAkJEfXq1RNt27Y1rBMcHCzmzZsnTp8+LS5cuCBGjx4t1Gq1iIqKMjq3S6ZNE+e3bRObtv8lPv/mc5EQFyKEMP4SW7lypbC1tRXr1q3LN0YhhLh+/bqwtrYWY8aMeWi9Bz34Ws7MzBRjx44VR48eFZcuXTK8N1atWmVYp1evXsLOzk4MGDBAhIaGio0bN+Z6/7Rr105UrlxZHDx4UBw/flw0aNBAaDQaw3sqLi5OtG3bVrz55psiJiZG3L1713C+3dzcxKJFi0RERIS4fPlygWL66aefhFqtFrNnzxZhYWHi6NGjRu/fwpo+fbqwt7cXqamphrIePXqIzp07G9U7efKkAPL8UVDQZCQxMVG4uLiIcePGiYyMDJGamiqGDh0qAgIC8n1tPhfJSMptsfmHAFFlcYD4s1X2Z3HU//oU+sfh0yCTkZdIcU9G/P39jd40I0eOFP7+/oa/i9oykmPz5s0CMJyfxo0bi0mTJhnFsWzZMuHp6ZlvnH/88YdwdnY2/J3TuhEcHPzQ4xs1alSex3d/otCjRw/xwQcfGK23f/9+oVQqRVpamli9erWws7MzJAUPyuuDNq9k5MFfdz/++KNwd3fPN3atVitsbW3Fxo0bDWX3n/scDyYjXl5e4ptvvjGqU6dOHfHhhx8KIf57zhYuXGhYfu7cOQGI0NDQfOMBjL7gDx06JACxaNEiQ9nKlSuFWq3OdxtCCFGpUiXx/fffCyGE4dzeCgkRqWfOiPioi+LszbPiyo3TQmSlGc7tjz/+KOzt7cXu3bsfuu2UlBQREBAg+vXrJ+rWrSuGDRtm9Nzb2tqKv/76K891H3wt5+XDDz80tIoJkZ2M+Pr6Cq1Wayh74403RPfu3YUQQoSFhQlAHD582LA8NDRUAEbvqS5duhhaRHIA4uOPP37o8eYVk5eXlxg9evQj1yuoSpUqGf0QEEKIVq1aiX79+hmVXbt2TQB5trAVNBkRQoizZ8+KMmXKCKVSKZRKpahYsaIhec2LyZMRvV5ELn9VvPJLJTHk40oipEJFEVq9hsi4csU08TygoN/f8kZ5LyiFRkOFkydMst/CqlevntHYhvr16zNjxgx0Oh1mZmZFiqNq1aqG/3t6egIQFxeHj48PJ06c4NixY3zzzTeGOjqdjvT0dFJTU7GysmLPnj1MmjSJkJAQEhMT0Wq1pKenk5KSYuj/t7S0NNpPXkJDQ/M8vvudOHGC8PBwVqxYYSgTQqDX64mMjKRVq1b4+vpSunRp2rZtS9u2benatWu+42jyY2VlRZkyZYzOy/0DAuPi4hg7diy7d+/mxo0b6HQ6UlNTiY6OLvA+EhMTuX79Og0bNjQqb9iwIf/++69RWX7PUcWKFfPd/v3ruLu7A1ClShWjsvT0dBITE7GzsyMlJYUJEyawadMmrl+/jlarJS0tzXBMOee2YuPGtKpfn1ZN/t/encdFVe9/HH+d2QHZUZbcQM0Fd61csix3y35li93KFrvda1lmtpiWpS3aZtdbZl7LFivNfhctW25XXFL7aeaGmiKiIiKCiLJvw8yc3x8DIyOogMBh6PN8POYxzFnmfOZYzJvv93u+5zq6jbsBnbfFdVVNTEwMp06d4tdff+Xqq6++6Of/7LPPyM7OZsGCBRQUFDB48GAefPBBlixZwokTJ8jPz2fAgAEXfY+KFi1axMcff0xycjJFRUVYrdZKVy5FR0e7/X8SHh7Ovn37AOd/fwaDgb59+7rWd+rUqdpXzFTcrzo1ZWRkcPLkSYYMGVLtz3gxW7du5cCBAyxdurTSuvPHQ6llg1cvZ5xUUVEREyZMYODAgSxfvhy73c4777zD6NGj2b59O161+P1W30p+/QfPFBzAVGrkwQ3Oc9B88mRMLVtqXFnN1HgA66ZNmxgzZgwRERFVjqw/X/klhuc/Dh48WNuaRTUoioLO27vBHw0xYLI6jEaj6+fymsoHmDocDmbPnk1cXJzrsW/fPhITE7FYLCQnJzN69Gi6du1KTEwMO3fu5IMPPgDcB/F5eXld8vOW/4K8GIfDwd///ne3evbs2UNiYiLt2rXD19eXXbt2sXz5csLDw3nppZfo0aNHjS/brXhOwHleKtb34IMPsnPnTubPn8+WLVuIi4sjODgYq9Vao+OUv3dFqqpWWnaxf6PqfIbyfS72Ps8++ywxMTG8/vrrbN68mbi4OLp16+b6TOXndtmyZYQ1b86r773HnYNvJzsnj4KyG+f17NmT5s2b8+mnn17y33Pv3r1ER0djMpkIDAwkNjaW3377jdtuu4333nuPkSNHuoLXpXzzzTc89dRTTJgwgTVr1hAXF8dDDz1U6d+jqn/X8s9/uV/Q5w+8vVRNdf1l/fHHH9OzZ0/69OnjtjwsLIz09HS3ZeXBujyk1sayZcs4duwYn376KVdddRX9+vVj2bJlJCUlNc4roo5v4+2490kwm/j7WgVLsQNL164Ejb9P68pqrMYtIwUFBfTo0YOHHnqI22+/vdr7JSQk4Od37vbczZs3r+mhRRP122+/VXrdoUOHWreKXErv3r1JSEigffuqbxa1Y8cObDYb8+bNQ1d2Z8tvvvmmVsfq0qVLpcB+/uft3bs3+/fvv2A9AAaDgaFDhzJ06FBefvllAgICWL9+PWPHjsVkMmG322tVX0WbN29m4cKFjB49GoCUlBQyMzPdtjEajRc9lp+fHxEREfz6669cV+Fywi1btlyyVaE+bN68mQcffJDbbrsNgPz8fI4dO+a2jcFgYNjw4VzfuTMzJk4kfOBAtm3eRuvRN4Kq0q5dO+bNm8fgwYPR6/UsWLDggse74oorWLVqFXl5efj6+tKiRQvWrl3LoEGD+OGHH9i5s/qtlZs3b2bAgAE89thjrmVHjhyp0efv3LkzNpuNHTt2uM5/QkJCreefuVRNvr6+tG3blnXr1nHDDTfU6hjl8vPz+eabb5g7d26ldf3792fGjBlYrVZMZdObr1mzhoiICNq2bVvrYxYWFqLT6dzCW/nrxnS1HAAFZ/h59QRW+DXjqkMO+sQ7QK8n/LVXUTS+urA2atwyMmrUKF577TXGjh1bo/1atGhBWFiY61FfXzTC86SkpDB16lQSEhJYvnw577//Pk8++WS9He+ll15i6dKlzJo1i/379xMfH8+KFSt48cUXAWjXrh02m43333+fo0eP8sUXX7Bo0aJaHWvixIkcOXLE9fmWLVvGZ5995rbNtGnT2Lp1K5MmTSIuLo7ExERWr17NE088AcAPP/zAe++9R1xcHMnJySxduhSHw0HHjh0B5wRW27Zt49ixY2RmZtb6l2b79u354osviI+PZ9u2bdx7772V/tIt/6JJT08nK6vq+7g8++yzvPnmm6xYsYKEhASef/554uLi6vXf9ELat2/PypUrXa1N99xzj9v5qXhuT+Tk8NX33+NwOIhsH0meTgcOZ0vYlVdeyYYNG4iJibnofBUPP/wwdrudW265hS1btpCQkMDq1avJzs7G29ubjz/+uEa179ixg//+978cOnSImTNnsn379hp9/o4dOzJy5EgeeeQRtm3bxs6dO/nrX/9a6xaM6tQ0a9Ys5s2bx3vvvUdiYiK7du3i/fffr/GxVqxYgc1m495776207p577sFsNvPggw/yxx9/sGrVKubMmcPUqVPdgkR5S2N+fj6nT58mLi6OAwcOuNavWrXKrVtw2LBhZGVlMWnSJOLj49m/fz8PPfQQBoPhssNVnXI4SFn5ELN8wKtY5Yn1FgCCH34Yy0W6ORuzBptnpFevXoSHhzNkyBA2bNhw0W1LSkrIzc11e4im6/7776eoqIirr76aSZMm8cQTT1xwkrO6MGLECH744QdiY2NdTbHvvvsubdq0AZzN8u+++y5vvvkmXbt25auvvqryr7PqaN26NTExMXz//ff06NGDRYsWMWfOHLdtunfvzsaNG0lMTGTQoEH06tWLmTNnuprzAwICWLlyJTfeeCOdO3dm0aJFLF++nOjoaMA56Zher6dLly40b968RmM8Kvrkk0/IysqiV69ejB8/nsmTJ1eac2LevHnExsbSqlUrevXqVeX7TJ48maeffpqnn36abt268fPPP7N69Wo6dOhQq7ouxz/+8Q8CAwMZMGAAY8aMYcSIEfTu3du1vuK57Xr11Sz55hs+f/NNurfrgB0Fu8Pm2rZjx46sX7+e5cuX8/TTT1d5vIiICH7//XdCQkIYO3YsvXr14uuvv2bZsmX8+OOPfPTRR25zYVzMxIkTGTt2LOPGjeOaa67hzJkzbi0S1fXpp5/SqlUrrr/+esaOHcvf/va3C84lUhc1PfDAA8yfP5+FCxcSHR3NzTffTGJiomv9gw8+yODBgy95rCVLljB27FgCAwMrrfP39yc2NpYTJ07Qt29fHnvsMaZOncrUqVPdtuvVqxe9evVi586dLFu2jF69erla/gBycnJISEhwve7UqRPff/89e/fupX///gwaNIiTJ0/y888/V7t7rSFYf53H00UJFOh0PLnVD0tWIcY2rQl57FGtS6s1Ra1Op/aFdlYUVq1axa233nrBbRISEti0aRN9+vShpKTE9VfmL7/84taMW9GsWbOYPXt2peU5OTluXT3Cqbi4mKSkJCIjI7FYLFqXI4THsqacwJ6TTYmvmVQfK4F2OxEhnUFvvPTOoloGDx7M4MGDmTVrltal1IkG//2bvIW5q+9lmV8z+qYaeW5pEQCtP/sMn37X1P/xayg3Nxd/f/9Lfn/Xe8dSx44dXc3J4OzrS0lJ4Z133rlgGJk+fbpbws3NzaVVq1b1XaoQ4k9O7++HPScbc5ENfCBXryO8OBvFR8a41YW8vDyOHDnCDz/8oHUpnqkgk7WrH2aZXzOMNpWpG/yAIgLuvKNRBpGa0GQ6+H79+rk1253PbDbj5+fn9hBCiPqma9YMRacDmx3vUgU7CgVFVY+NETXn6+tLSkoKzZo107oUz+NwcCLmIV7ycX5tz06IxpByCn3zEFo884zGxV0+TcLI7t27G1X/mxBCgPNeNbqyP34CrM6G41x7MdhtF9tNiHpXuvktni1OIE+vY2hRa9r/5ByIG/biTPR1fENMLdS4myY/P5/Dhw+7XiclJREXF0dQUBCtW7dm+vTppKamuiapmT9/Pm3btiU6Ohqr1cqXX35JTEwMMTExdfcphBCijuj9/LBnZ2MpsoMP5Ol0qMXZKD4hWpcm/qySNvOPPYv4w98Xf8XMo2vN2G02mg0dgu/wYVpXVydqHEZ27NjhdolT+diOBx54gM8++4y0tDS30fxWq5VnnnmG1NRUvLy8iI6O5scff3Qb0SzqRqO7Dl4ID1TeVaOWddUUGhUKi7PwkTAiqlDvv3fzM9jw/SN84e+8u/S8rNHY//hfdM2aETZzZqOZaPJyXdbVNA2luqNx/6wcDgeJiYno9XqaN2+OyWRqMv+BCqEFa3o6jtxcSnyMZHjb8HeotAhsBzqZH0k4qaqK1Wrl9OnT2O12OnTo4Joksc447Jz84mbutCeTq9fzt+CbGfbSGtTCQsJmvUzg3XfX7fHqQaO5mkbUP51OR2RkJGlpaZw8eVLrcoTweI7iYuxnz6KeUchspnIGyM+0oph8Lrmv+HPx9vamdevWdR9EgNKNb/Js8RFyLWa6+bXjlu8yKSwsxKtPHwLuuqvOj6clCSNNhMlkonXr1thstjqZGlyIPzOH1UryzJdwFBTw3f8YORiq8qaxDZ1vrvlMoqLp0uv1GAyG+mmJPvoL7+/9F3sD/PDVmXndNpbCzXNRjEbCX33FedVXEyJhpAlRFAWj0VjpxllCiBqyWPCPjibnu+8YfCCCDYEZxJ45Si+dA0w1u1uyEDWWl86m7//GpwHObo3Xe8yk9O9vAhDy2KOYo6K0rK5eNK1oJYQQdcR31EgArvwjH0VVWetlRD28VuOqRJNnt5Ee8yAv+DrbCu658i46frUVe1YW5g4dCH74YY0LrB8SRoQQogrNBgxA5+uL/mwu3U/oSDMY2P/Hcq3LEk2c7Zc5TCs5QrZeT2e/KB4tHUTOd9+BojjvyFt2l+KmRsKIEEJUQTGZ8B0yBIDbjgUDsCZjB9hKtCxLNGWH1/HBH0vYZbHgozPx9oC3yZz9GgCB4+/Dq0cPjQusPxJGhBDiAvzKumo67i9EcajEWvSoR37RtijRNOWm8X8/TOTjsnEiswa9juXTVZSmpmKICKfFk09qXGD9kjAihBAX4NO/Pzo/P/RZuXQ/oXDCaOTgH8u0Lks0NXYbGf9+gBl+zosP7mp/O9fnXcHZspnMw2fNQufTtC8rlzAihBAXULGr5takQABi03+Te9WIOmVf/xrPW5M4q9fT0a8tz/Z5hrQXZ4LDgd/NN9PsAne4b0okjAghxEW4umrii1EcKmvMCuqxXzWuSjQZibEs2v8J270seOtMvHPj++QvXU5JQgL6gABCZ0zXusIGIWFECCEuwqdfP3T+/hiy8uh2ApKNRhKlq0bUhZwT/PbDo/yrbJzISwNfISILMhcsACB0+vMYgoK0rLDBSBgRQoiLcOuqORoAQGzqryA3phSXw15K5r8f4Hk/E6qicHu7WxnddhRpM19CtVrxGTgQv1tu0brKBiNhRAghLqG8q6ZTfInzqhqjHU5s17gq4cnsa2fzfOlxzhj0tPdtw7R+M8iOiaFw+3YULy/CZs/6U93wVMKIEEJcgqurJjufrilwxGTiyL6vtC5LeKqEn/ko/nO2eVnw0hmZd+N7GM7mkfHW2wA0f3IyppYtNS6yYUkYEUKIS1CMRnyHlnfVOPv3Y49vAFXVsizhibKPs/3Hx/gwwB+AFwfMIiogilOvvY4jLw9Lt24EjR+vcZENT8KIEEJUg9/IUQB0jrc6u2r0Vkjbo3FVwqPYrJz53weY5m/GoSj8T9QYbml3C3lr15K3Zg3o9c478ur1Wlfa4CSMCCFENfj0uwa9vz+GnAK6pagcMps4tle6akT1OdbOYoYthdMGA+18WzOj34vY8/JIf+VVAIIffhhLp04aV6kNCSNCCFENitFIs2FDAbjliC8Aa5NjpatGVM/BH/kk/gu2eHth0Rl554Z/4m30JmPePGwZGZjatCHksUe1rlIzEkaEEKKayrtquhy0oXOorFGK4PRBjasSjV7WMXb9+DgLAp3jRGb0m0n7wPYU7thB9tcrAAh79RV0FouWVWpKwogQQlSTzzVXu7pquh5XiTebSNkjXTXiImxWsv73AZ4NsGBXFG6OHM2t7W/FUVJC2syXAAi48058rr5a40K1JWFECCGqSTEa8R0+DIAxh5sBsPbYf7UsSTRmRdk4Yh7mBXsqGQYDbZu1ZGb/l1EUhcxFi7AmJaFvHkKLZ5/RulLNSRgRQoga8B3pnAAtOsHZVRPryIGzRzWuSjQ6SZso/XAg757axGZvL8yKgXdumI+30ZvihEOc+ehjAMJmzkTv56dxsdqTMCKEEDXgc8016AMCMOQWEn1cZZ/FzEnpqhHlSovh5xkkLbuN+5uV8rm/M2g83+8FOgZ1RLXbSZs5E2w2mg0dgt/w4RoX3DhIGBFCiBpQDAZ8h5V31XgDsPboj1qWJBqLtL04Fl/PVwc+566IMP4wm/E1+vLGoDe448o7AMj6ahnFe/eia9aMsJkzNS648ZAwIoQQNVR+r5rog3ZnV43tLOSc0LgqoRmHHTa/S/onQ/m7/gxvBAdRrNPRP7w/K/9nJTdF3QRAaWoqGfPnA9DimWcwhoZqWHTjYtC6ACGE8DTeV1+NPjAQsrKITtYRF2nm1N6vCR0kAxH/dM4moa76Oz+e3cec8Obk6XVY9Gam9n2acR3HoVOcf/Orqkra7NmohYV49e1DwF13alx44yItI0IIUUMVu2puTvQCYO3h77QsSTQ0VYVdS8lePIinS44wvUUIeXod3UK68r9j/s1fOv3FFUQAcn/4kYJNm1GMRsJfeRVFJ1+/FcnZEEKIWijvqumaUNZVU5IO+RkaVyUaRP5p+PoeNsU+y23N/Yj18cag6JnUcxJLR31BW/+2bpvbsrI4NWcOACGTHsMcFalB0Y2bhBEhhKgF76uuQh8YiDG/mOhklV0WM5n7VmhdlqhvB3+i8MN+zM7cyqSwFmQa9ET5R/HlTV8xscdEDLrKox8y3ngDe1YW5iuvJHjCBA2KbvwkjAghRC0oBgO+ZZdl3nTIjKoorEtcpXFVot6U5MHqJ9i96gFuDzTybz/n/YnGdxnPiptXEB0cXeVueevWkfPdalAUwl97FcVkasiqPYaEESGEqKXyrppuhxzo7SqxhSegKEvjqkSdO/4b1kUDmZ/0HQ+Gh3LCaCTcO4wlw5fw3FXPYTFUvqdM6akMTk6bxolJjwMQOP4+vLp3b+jKPYZcTSOEELXk3bcv+qAgOHuW6GQd2yNNnN0fQ1Dfv2pdmqgLNiv8MpdDvy9gekgQh8zOG93d0u4Wnr/6eXxNvpV2cZSUcPbTz8hcvBi1sBAA/9vH0mLq1AYt3dNIGBFCiFpydtUMI/vrFYw6ZGJvlI31B7/hDgkjni8jHvvKv/J5UTILIkIpVRQCzQG83H8WQ9oMqbS5qqrkxcaS8eZblKamAuDVsyehL8zAq1u3hq7e40g3jRBCXAa/kaMA6F7eVZN/zDm+QHgmhwO2LiTl4xuZoGTwj6BAShWFwS0Hs/J/VlUZRIoTDnH8oQmkTn6S0tRUDKGhRLz9Nm2WL5MgUk3SMiKEEJfB+6q+6IOD4cwZuibr2BZpIjv+WwJ6jte6NFFTOSdQv53IytO7eCs8iEKdDm+DF89fPZ1b29+Koihum9uyssh8/32yvl4BDgeKyUTQwxMIeeQRdN7eGn0Iz1TjlpFNmzYxZswYIiIiUBSFb7/99pL7bNy4kT59+mCxWIiKimLRokW1qVUIIRodRa/Hd7hzArQRCUbsisKGA3KJr0dRVdj7DZmLBvJE4UFmNQ+mUKejT2gfYm5ZyW0dbnMLImppKWe/+JIjI0eRtWw5OBz4jhhB1E8/0eLJJyWI1EKNw0hBQQE9evRgwYIF1do+KSmJ0aNHM2jQIHbv3s2MGTOYPHkyMTExNS5WCCEao/Kumh6JqrOrJjcRSos0rkpUS+FZ+PdDxP48mdua+7DR2wujzsAzfZ9hyfAltPRt6bZ5wZYtHL3tNk69/jqOnBzMHTvS+vPPafnP+ZhaXqHRh/B8Ne6mGTVqFKNGjar29osWLaJ169bML7s5UOfOndmxYwfvvPMOt99+e00PL4QQjY533z7oQ0IgM5OuyTq2RhrJPfgDft3k/iON2uG15K5+nDdMVr4PbQ5Ap8COzBk0lw6BHdw2tR4/zqk33yJ/3ToA9AEBNJ8yhYA770DR6xu89Kam3gewbt26leFlEwOVGzFiBDt27KC0tLTKfUpKSsjNzXV7CCFEY6Xo9fiVddUMP2jApihsPLBM46rEBVkL4adn+e3f93C7v8L3vj7oUHik2yMsu2m5WxCx5xeQMW8eR2+62RlE9HoC7x9Pu//+TODd4ySI1JF6H8Canp5O6Hm3SQ4NDcVms5GZmUl4eHilfebOncvs2bPruzQhhKgzviNGkrVsOT3LumrWZMUzxmYFg8y42aik7qR45d/4p5rJl+HO76ZWzVoyZ9Bcerbo6dpMdTjI+W41Ge/Ow346EwCfgQMJnf485vbttai8SWuQS3vPH4GsqmqVy8tNnz6dnJwc1yMlJaXeaxRCiMtR3lVjLCyl6zGVLWYD+YlrtC5LlLPb4Jc32b90NHdZCvjS3w+AcR3H8e9bYtyCSFFcHMfG3U3a9OnYT2dibNOalgsX0urjjySI1JN6bxkJCwsjPT3dbVlGRgYGg4Hg4OAq9zGbzZjN5vouTQgh6oyzq2Y4WcuWMfygnj3tVDbtX8rozjdrXZrIPEzpqr/xcUEi/wpvjl1RaG4J5pVrX+PaK651bVZ66hQZ8+aRu/p7AHQ+PoQ89iiB48ejk3vK1Kt6DyP9+/fn+++/d1u2Zs0a+vbti9ForO/DCyFEg/EdOYKsZctcXTWxZ/Yx2mEHnQeOK8hKRk3eiuJ/BQS3A99wuEBrdqOlqrDjE46uf5kXAr35IzAAgBFtRvBivxcJsDhfV5rCXVHwH3sbLaZMwdC8uXb1/4nUOIzk5+dz+PBh1+ukpCTi4uIICgqidevWTJ8+ndTUVJYuXQrAxIkTWbBgAVOnTuWRRx5h69atLFmyhOXLl9fdpxBCiEbAu08f9M1D4HQm3Y7p2Bypo/DoerzbD9O6tOoryOTgupnMP7mW7WYz4XYbkdZSIh0QaQoiyrcVkUEd8WveGYLaOYNKs9DGF1Ty0nF8O4nlp3/jHy0CKNHp8DU248V+MxkdNRq4wBTuvXoROmMGXt26aln9n06Nw8iOHTu44YYbXK+nlt3854EHHuCzzz4jLS2N48ePu9ZHRkby008/8dRTT/HBBx8QERHBe++9J5f1CiGaHGdXzQiyvvqKoQd1xLWDzfuWMsITwkhJPqmb3+T9xBX8bDZx0x4TzyY5SA3RkRhh4YcrFE6bisCaCOmJBJ/4jqjSUiJLS4l06Ijyak6kXxShIZ3QBbd3hpSgduAT0vBB5cB3pP/4FDN9dfwWHATAgPD+vDLwVUJ9nINWixMSODVnLoXbtgFgCA2lxTPP4HfzTRcczyjqj6KWjyZtxHJzc/H39ycnJwc/Pz+tyxFCiAsq3L6d5PH3U+pl4P4nVIbaVN756z7QNdJbgdlLydr2IYv3fMgKLz1RqfDIf+y0zqy8aUEzPYcjFP6IcHDoCoWjYVBicv/i9nI4aFtqI7K01BlWVCORPuG0CWiPKaTDudaUoHbgHVS3QaU4B/Wn5/jhyGrmBgeRp9dh0Zl4+qpnGddxHIqiyBTuDay6399ybxohhKhDXr17O8cZnD5N9yQdm6Kg6PgWvNpee+mdG5LDQeG+FXz52xt8YrKBouehnx0MjXP+faoPDCRowkPYMk5TtGcPxfHx+OSX0uMQ9DjkfAtVpyOvVQApVxjZH1bMbyEFnAhSiDebiDdXHPCZi65wJy2PbiPqYCmRZWElUjET6dsa/+CykBIUVRZUopxBpSaSNpP13aO8aioitkUIAN2Du/L6oLm09W/rnML96xWcXrAAR04OAL4jRtDi2Wdl5tRGQMKIEELUIUWvx3fECLK+/JIbDyrsbq+wZe8nDGlEYaT08DpW/TKDD5U8Ms06Bh6Ah9epNCtwBhH/O26nxdNPYwgMdO3jKCmheP8BivbscT7i4rClp+OXfIboZIgG7gLw86W4YysyogI5FO5gd8AZ4m2p5NtLOG40ctxo5Be3as4SlLOFqNMbnQGl1OZsUdF5ExYQ6ezycbWmlIUVi3+FD1MM619lU9wSXg4JItPgjUHR82jPx5jQdQIGnYH8//s/Ts2di/XwEQDMHTsSOmMGPtdcXb8nWlSbdNMIIUQdK9yxg+T7xlNq0fPAEzDcrvDmI3s1H+Spnoxj7dpnea8khWMmI6FZKo+vUeh41AaAqV07wmfPwrtv32q9X2l6OkV79rrCSfH+/aglJe4bKQqmqCiUbp3Iad+C5FYW4v3ySMo9ytHsw5wqPnvB9y/v8mlb3uVjdYaVNkZ/zGXBpDAtjrft6fzbzxeAdn6RzLnuDboEd8GanOycwn39ekCmcNdCdb+/JYwIIUQdUx0ODl8/GNvp08y9U8ehKNg47DPMLa/SpqCzSWxfO435WXHstZjR21XGbdNxyxYHulI7islEyGOPEjxhAsplzKehWq0UJxxyhZOiPXsorWLSSp2PD149umPp0QNd106cauvHUTJJykniWO4xjmYdJjnvODbVXuVxdKrKFTYbkaU2jhoNnDAaUVAY32U8k3tPxlBk48y/FnH2s89RS0udU7jfew/NJ01C7+9f5XuK+iFhRAghNJT++hyyvviCbV31zBuj8H7wtQy++cOGLSL/NAnrZ/LP1HVs9rYA0CMFpqz3weekc9yEz4D+hL38MqY2beqlBNuZM87Wk7JwUrRvn3Muj/OY2rTBq2cPLD164NWjB4YO7UgtSicpJ4mk3CSOZh8lKTeJpOyj5JXmu+0b7t2C1we9Qd8Wfcj59jsy/vGuTOHeSEgYEUIIDRXu3Enyvfe5umpGqwZe/2tcwxy8JJ+0zW+x4NDXfO9tQlUU/ItUZmwPJ/L/TgCgDwoidPrz+N18c4Neyqra7ZQcPkzR7jjX+BPr0aOVtlO8vPCKjnYFFO+ePTE0b46qqpwpPuMMKTlJlDpKuaXdLej3H+bUnLkU79sHgLFNa0Kff55mgwfLpboakjAihBAaUh0ODg++AVtGBm/coSMxCjbetAJjaD1OpmWzkv37Ij7es5DlFgNWnQKqymPHWzP4P2chy9kaEnDnnbR4eir6gID6q6UG7NnZFO3bR1HcHldAceTlVdrOGBGBV09ny4lXz56YO3fGnpUlU7g3YhJGhBBCY+lz5pC19Au2ddUxb4yOhS2GMGjU/Lo/kMNB0R8r+GrLXD4x2cnTO+c0GV5yBQ9v9EXZ+QcApvbtCJ89G+8+feq+hjqkOhxYk5LOhZO4OEoSE53Tu1egGI2g0zkHzcoU7o2SzDMihBAa8xs5kqylX9D7sILBphJ7chOD6vgYtiPr+G7DDBYquWR4GQAdXfTBPHfiGnyW/YxqTUYxmwl59FGCJzx0WQNUG4qi02Fu1w5zu3YE3D4WAHt+AcV/lLWelI0/sWdlATKFe1MgYUQIIeqJV8+eGEJD4dQpeiTpWB9VzMzMRIwhHS77vdXU3WxY+xz/tKZw1GQEDETofXjG+w6ilmzAemQ1Ks4BnGEvv4SpdevLPqaW9M188OnXD59+/QDnfWVKU1Kw5+Ri6Rot40I8nIQRIYSoJ4pOh9/IEZz9fCnXx8PODnq27/6IAcPeqv2bnk1iV+w0/pEdR5zFDCYjAYqRRyPHc91/MshbuQQroA8OJnT6dPxuGt0kv6gVRfH4gCXOkTAihBD1yHfESM5+vpTeh8FoU4lN+YUBtXmj/NMcWf8S81PX8ou3BSxmLOgY3/527krvSO5z/ySvrNsi4K67nANUZU4N4SEkjAghRD3y6tkDQ1gYpKfTPUnH+qh8Xsg6jiGwmn/Vl+SRvvltFh76mu+8TTi8LeiBsS1v5JGI+7G+uYCs35YDYO7QnrDZs/Hu3bv+PpAQ9aCR3kZSCCGaBkWnw2/ECACuj1c5q9eza/dHl97RZiVn6/u8u+Qqbk6JYZWPGYeiMCy4JytHx/BoQkdyxk2g8LffUMxmmk+dSmRMjAQR4ZGkZUQIIeqZ78gRnP38c/ocVjDaVNYcX8vVvFr1xg4HJfu+YfnWOXxkspHrYwSgT7M2PDXoNdofs5J+/xQyk5IA8Ln2WucA1VatGurjCFHnJIwIIUQ98+rRA0N4OKSl0eOojnVROUzPP4W+WajbdvbD6/j+lxl8oOSS7mUA9LQ3B/NU/5cY4NuLjHfe4fjKlQDoQ0KcM6iObpoDVMWfi3TTCCFEPavYVXNdvEqmQU/crnNdNWrqbjZ+Pow7NjzGTGMh6QYDYXpvXrvmRf73zrV035XL0ZtuIqcsiATcPY52P/2I/003SRARTYK0jAghRAPwGzmCs599Rp/DYCxViU36L3263kNc7PP8I3s3uywWMJnwU4z8rdtfubv7w5B8ktSHHqbw998BMHfoUDZAtZfGn0aIuiVhRAghGoClRw8MEeFwMo2eSSpros5w6uvhrPXxAosFMwr3tb+dCVc9RTMsnPnwI87861+opaUoFgshkx4j+MEHnVOgC9HESBgRQogGoCgKfiNGcvbTTxkUr7L9Sj1rDV7ogNuuGMzE/i8Q5hNGwbbfSXr5ZazHjgHgM2iQc4Bqy5aa1i9EfZIwIoQQDcRv5AjOfvopfY/oMJaqXBvWgynXvkpUQBS2rCxOvjqdnG+/BUDfPISwGTPwHTlSxoWIJk/CiBBCNBBL9+6urpqfIt4gbPT/oKoq2StXkfHWW9izs0FRCPzL3TSfMgW93KVc/ElIGBFCiAZSsavGvm4zJZ26kf7yLAq3bwfA3LEj4bNn4dWzp7aFCtHAFFVVVa2LuJTc3Fz8/f3JycnBT/5SEEJ4sKK9ezl21zgUkwlU1TVAtfkTjxN0//0yQFU0KdX9/paWESGEaECWbt0wRkRQevIkAD7XX0fYzJcwtbxC48qE0I6EESGEaECKotDiuefI+vJLAu+7D98Rw2WAqvjTkzAihBANzG/kCPxGjtC6DCEaDZkOXgghhBCakjAihBBCCE1JGBFCCCGEpiSMCCGEEEJTEkaEEEIIoSkJI0IIIYTQlIQRIYQQQmhKwogQQgghNFWrMLJw4UIiIyOxWCz06dOHzZs3X3DbX375BUVRKj0OHjxY66KFEEII0XTUOIysWLGCKVOm8MILL7B7924GDRrEqFGjOH78+EX3S0hIIC0tzfXo0KFDrYsWQgghRNNR47v2XnPNNfTu3ZsPP/zQtaxz587ceuutzJ07t9L2v/zyCzfccANZWVkEBARU6xglJSWUlJS4Xufm5tKqVSu5a68QQgjhQap7194atYxYrVZ27tzJ8OHD3ZYPHz6cLVu2XHTfXr16ER4ezpAhQ9iwYcNFt507dy7+/v6uR6tWrWpSphBCCCE8SI3CSGZmJna7ndDQULfloaGhpKenV7lPeHg4ixcvJiYmhpUrV9KxY0eGDBnCpk2bLnic6dOnk5OT43qkpKTUpEwhhBBCeJBa3bX3/Ntdq6p6wVtgd+zYkY4dO7pe9+/fn5SUFN555x2uu+66Kvcxm82YzebalCaEEEIID1OjlpGQkBD0en2lVpCMjIxKrSUX069fPxITE2tyaCGEEEI0UTUKIyaTiT59+hAbG+u2PDY2lgEDBlT7fXbv3k14eHhNDi2EEEKIJqrG3TRTp05l/Pjx9O3bl/79+7N48WKOHz/OxIkTAed4j9TUVJYuXQrA/Pnzadu2LdHR0VitVr788ktiYmKIiYmp208ihBBCCI9U4zAybtw4zpw5wyuvvEJaWhpdu3blp59+ok2bNgCkpaW5zTlitVp55plnSE1NxcvLi+joaH788UdGjx5dd59CCCGEEB6rxvOMaKG61ykLIYQQovGol3lGhBBCCCHqmoQRIYQQQmhKwogQQgghNCVhRAghhBCakjAihBBCCE1JGBFCCCGEpiSMCCGEEEJTEkaEEEIIoala3bVXCOG5bHYHJTYHVlvFZzsl5712X+/AWraNQa9jYPtgOob6XvBu3UIIURMSRkSDUlUVm0PFWvYlV1r+xWh3uJZV/LnSOpvdfb393Pucv3/Jea/tDhVFUTDoFHQ6Bb0CBp0Ona782blMr9Ohr7DMoFPQKQp63Xnrzlum1+nQV7kM9PoLrXNfpihKpZBw8dcXChPnwsP52znqaM7lVkFeDO0cyrDOoVwVGYRRLw2tQojakengRbWoqkp2YSmn80s4nVfhUfb6bIHV9UXpHh6crysGg8b/X9yfh0GnYDboMJU9zAZ92bOuwrPe7XVWgZUtR85QYnO43sfXYuCGji0Y2iWU669sjr+XUcNPJYRoLKr7/S0tI39yhVZbleHi/NeZ+SWU2us+Reh1Cia9DqNecfvSM+nPfUG6/WzQYa5inVGvc/sSrWp/o16H3aFiV1UcDmcLjetZVbHZz1tXtsyhqtir2r7stf0Cy8qP5bZf2TK7w/09y5c5VNUZCPQ6zEZd2fP5r53noKrlJr3+vCDhHjDMFV6bDDr0utp1sxRZ7fx6OJO1B06x7uApMvOtrN5zktV7TmLQKVwTFcTQzqEM7RxKqyDvOv6vRgjR1EjLSBNUandwJt9aFiaKLxo2Cqz2Gr13oLeR5r5m56OZ2fVzoLcJi1FfdWA4LxyY9Zf/ZSgaD7tDJS4lm7Xxp1h74BSJGflu6zuF+TqDSZdQul/hj07+zYX406ju97eEEQ9xqW6Siq/PFlhr9N5eRj0t/NzDhdvPZY9gHzMmg4wLEBd3LLPAGUziT7H9WBb2CoNUmvuaGdq5BUM7hzKwfQgWo17DSoUQ9U3CiAdxOFRO55dwMruItJxi13N6TjEnc4pIzymucTeJQacQcolwUb7Mxyy9daJ+ZBda+SXhNLEHTrHx0GnyS2yudV5GPYM6hDC0Syg3dmpBSDOzhpUKIeqDhJFGQlVVzhZY3ULGyZwi0rKLScsp4mR2Madyi7FV8xKHC3WTOF9bXD8HeBmlOVw0KiU2O9uOnnV155zMKXatUxTo3TrQeXVOlxa0a95MLhsWogmQMNIAVFUlt9hGWlm4OHnec1qOM3xUvOrgQnQKhPpZCPe3EB7gRYS/hXB/LyICLIT5exHqJ90koulQVZUDabmsPZDB2vhT7EvNcVvfNtjbNc6kb5tADHLZsBAeScJIHSi02jhZHirODxs5xaRlF1V7AGhIMzMRAWVhoyxkVHxu4WuWX7jiTystp4h18c5gsuXwGaz2cwHe38vIjZ2c40yuuzIEX4tcNiyEp5AwUg0ns4tIPlPoasE4f8xGTlFptd4n0NvoFizCAyxE+Hu5gkeovxmzQQbqCVEd+SU2Nh86TWz8KTYczCCr8Nz/h0a9Qr+oYIZ1CWVI51CuCPDSsFIhxKVIGKmGv36+g7Xxpy66ja/ZQPh5rRjh/hYiAs6FDS+TBA0h6oPN7mDXcedlw7EHTpGUWeC2vku4H8O6hDKsSyjREX4yzkSIRkbCSDXM+SmetQdOnQsbZeM1KoYNaRIWovE4cjqftQeclw3vTM5ym9o+zM/C0C7O7pz+7YKlNVKIRkDCiBCiSTuTX8KGhNOsPXCKTYmnKawwfsvbpKdv2yD6RwXTv10wXSP8ZEyWEBqQMCKE+NMoLrWz9cgZYssuG87IK3Fb72s2cFXkuXDSOdxPZv8VogFIGBFC/Ck5HCoJp/LYeuQMW4+e4bejZ8grtrlt4+9l5OoK4aRjqK/MyyOavPwSG2llF2ikua4KPTe55qu3dqVfVHCdHlPCiBBC4Lx3zoGTuWw9msnWI2fYfizLbSZYgCAfE9dEBtG/XTD9o4Jp30ImXROepaDEVilkuH4uez4/lJ/vrTu6c1ffVnVal4QRIYSogs3uYF9qDluPnmHrkTPsOJZFUan7fEEhzcz0izoXTiJDfCScCM0UWe2u1ouTrpYNZ8goX5Z7iaBRzs9icE1BUX5FaJi/czqKzuG+BNfxbRkkjAghRDVYbQ72nsh2devsTM6qNGtymJ/FFU4GtAuhVZC3RtWKpqbIaj8XKnKKSc8p4mTZpJrloaO6c16VT0UR5n9uFm/nrN7O4BHm70WzBr4XmYQRIYSoheJSO3Ep58JJ3PFstxlhAa4I8HK1mvRvF0yETL4mKrA7VPKLbeQWl5JfYiOr0Ep6WbA4me0ePCpO6ncxzcyGskDhbMUI87e4zX0V1kinopAwIoQQdaDIamfX8SxXONmTkl3pxpZtgr1dwaR/VDAt/CwaVSsuV3GpnbxiG/klNvKKS8krrvhsK1t37nV54CjfLr/YVu3bhJTzNund5rcqb9kIK1sW5m/BrxEGjeqQMCKEEPWgoMTGjuRz4WTfiWzOv+l2VHMfVzjpFxVMSB33w9cFm91BYamdIqudghIbhVZ72ePczyU2OzpFQa9T0Jc/lz10ioKh/Ged82edomDQK659ypdV3M9Qtr3b+ykKer3zWacDg06HTqFG43QcDpUCq80tSOSWh4cKgSK/xBkgXMsrBIv8YlulVrDLYTbo8LUY8fcyVBib4Qwb5bcNcQYNQ5MdkyRhRAghGkBecSnbj511hZP9J3M5/7fqlaHNXOHkmshgAn1M1X5/q81RISA4nwtK7BSV2pzPVjsF560vLLFTWGqnsMRWKWAUWp1/uVurcTdxrZUHlYoBxRlgdOjLljlUZ5dIvtVW6bzXlqJAM5MBX4sBX4uRZpYKP5sN+J33uvxn3/OWy13WJYwIIYQmcgpL2ZZ0xnW1zsH0PLf1igKdwvzo0dIfm0O9cJgo+/n8LqG6ptcpeJv0eJv0+JgMeJU9e5v1mPQ6HCo4VBW747zHecscqorNoeIoW2ezV15mt5+3n6rWWYAoZ9QrrmBQKSiYz/3crMJyP4uBZuZzYcLHZJB5Z+qIhBEhhGgEzhZY2XbUGU62HDnD4Yz8Wr2PSa8rCwp657PZUBYiDK4wUf6zj9mAl1GPj1mPl8lwbp/ybc0GvI16V+DQsovAcX6wUZ3h5VLBpnwZUBY6nGHCbND28wh31f3+bthrfIQQ4k8myMfEqG7hjOoWDkBGXjHbjp4lMSMfi1Hn3hpRMVSY3QOGsYneW0enU9ChYJT7Gv6p1SqMLFy4kLfffpu0tDSio6OZP38+gwYNuuD2GzduZOrUqezfv5+IiAiee+45Jk6cWOuihRDCU7XwtTCmR4TWZQjRqNQ4aq9YsYIpU6bwwgsvsHv3bgYNGsSoUaM4fvx4ldsnJSUxevRoBg0axO7du5kxYwaTJ08mJibmsosXQgghhOer8ZiRa665ht69e/Phhx+6lnXu3Jlbb72VuXPnVtp+2rRprF69mvj4eNeyiRMnsmfPHrZu3VqtY8qYESGEEMLzVPf7u0YtI1arlZ07dzJ8+HC35cOHD2fLli1V7rN169ZK248YMYIdO3ZQWlr1zHMlJSXk5ua6PYQQQgjRNNUojGRmZmK32wkNDXVbHhoaSnp6epX7pKenV7m9zWYjMzOzyn3mzp2Lv7+/69GqVd3eRVAIIYQQjUethmeff9mUqqoXvZSqqu2rWl5u+vTp5OTkuB4pKSm1KVMIIYQQHqBGV9OEhISg1+srtYJkZGRUav0oFxYWVuX2BoOB4ODgKvcxm82YzY1v+mQhhBBC1L0atYyYTCb69OlDbGys2/LY2FgGDBhQ5T79+/evtP2aNWvo27cvRqNn3vhHCCGEEHWnxt00U6dO5eOPP+aTTz4hPj6ep556iuPHj7vmDZk+fTr333+/a/uJEyeSnJzM1KlTiY+P55NPPmHJkiU888wzdfcphBBCCOGxajzp2bhx4zhz5gyvvPIKaWlpdO3alZ9++ok2bdoAkJaW5jbnSGRkJD/99BNPPfUUH3zwAREREbz33nvcfvvtdfcphBBCCOGx5N40QgghhKgX9TLPiBBCCCFEXZMwIoQQQghNSRgRQgghhKZqddfehlY+rEWmhRdCCCE8R/n39qWGp3pEGMnLywOQaeGFEEIID5SXl4e/v/8F13vE1TQOh4OTJ0/i6+t70Wnnm6Lc3FxatWpFSkqKXEl0GeQ81g05j3VDzmPdkPNYN+rzPKqqSl5eHhEREeh0Fx4Z4hEtIzqdjpYtW2pdhqb8/Pzkf7Y6IOexbsh5rBtyHuuGnMe6UV/n8WItIuVkAKsQQgghNCVhRAghhBCakjDSyJnNZl5++WW5i/FlkvNYN+Q81g05j3VDzmPdaAzn0SMGsAohhBCi6ZKWESGEEEJoSsKIEEIIITQlYUQIIYQQmpIwIoQQQghNSRgRQgghhKYkjDRSc+fO5aqrrsLX15cWLVpw6623kpCQoHVZHm/u3LkoisKUKVO0LsXjpKamct999xEcHIy3tzc9e/Zk586dWpflUWw2Gy+++CKRkZF4eXkRFRXFK6+8gsPh0Lq0Rm3Tpk2MGTOGiIgIFEXh22+/dVuvqiqzZs0iIiICLy8vBg8ezP79+7UpthG72HksLS1l2rRpdOvWDR8fHyIiIrj//vs5efJkg9QmYaSR2rhxI5MmTeK3334jNjYWm83G8OHDKSgo0Lo0j7V9+3YWL15M9+7dtS7F42RlZTFw4ECMRiP/+c9/OHDgAPPmzSMgIEDr0jzKm2++yaJFi1iwYAHx8fG89dZbvP3227z//vtal9aoFRQU0KNHDxYsWFDl+rfeeot3332XBQsWsH37dsLCwhg2bJjrJqvC6WLnsbCwkF27djFz5kx27drFypUrOXToELfcckvDFKcKj5CRkaEC6saNG7UuxSPl5eWpHTp0UGNjY9Xrr79effLJJ7UuyaNMmzZNvfbaa7Uuw+PddNNN6oQJE9yWjR07Vr3vvvs0qsjzAOqqVatcrx0OhxoWFqa+8cYbrmXFxcWqv7+/umjRIg0q9Aznn8eq/P777yqgJicn13s90jLiIXJycgAICgrSuBLPNGnSJG666SaGDh2qdSkeafXq1fTt25c777yTFi1a0KtXLz766COty/I41157LevWrePQoUMA7Nmzh19//ZXRo0drXJnnSkpKIj09neHDh7uWmc1mrr/+erZs2aJhZZ4vJycHRVEapAXUI+7a+2enqipTp07l2muvpWvXrlqX43G+/vprdu3axfbt27UuxWMdPXqUDz/8kKlTpzJjxgx+//13Jk+ejNls5v7779e6PI8xbdo0cnJy6NSpE3q9Hrvdzuuvv85f/vIXrUvzWOnp6QCEhoa6LQ8NDSU5OVmLkpqE4uJinn/+ee65554GuSOyhBEP8Pjjj7N3715+/fVXrUvxOCkpKTz55JOsWbMGi8WidTkey+Fw0LdvX+bMmQNAr1692L9/Px9++KGEkRpYsWIFX375JcuWLSM6Opq4uDimTJlCREQEDzzwgNbleTRFUdxeq6paaZmontLSUu6++24cDgcLFy5skGNKGGnknnjiCVavXs2mTZto2bKl1uV4nJ07d5KRkUGfPn1cy+x2O5s2bWLBggWUlJSg1+s1rNAzhIeH06VLF7dlnTt3JiYmRqOKPNOzzz7L888/z9133w1At27dSE5OZu7cuRJGaiksLAxwtpCEh4e7lmdkZFRqLRGXVlpayl133UVSUhLr169vkFYRkKtpGi1VVXn88cdZuXIl69evJzIyUuuSPNKQIUPYt28fcXFxrkffvn259957iYuLkyBSTQMHDqx0afmhQ4do06aNRhV5psLCQnQ691+7er1eLu29DJGRkYSFhREbG+taZrVa2bhxIwMGDNCwMs9THkQSExNZu3YtwcHBDXZsaRlppCZNmsSyZcv47rvv8PX1dfWL+vv74+XlpXF1nsPX17fSOBsfHx+Cg4Nl/E0NPPXUUwwYMIA5c+Zw11138fvvv7N48WIWL16sdWkeZcyYMbz++uu0bt2a6Ohodu/ezbvvvsuECRO0Lq1Ry8/P5/Dhw67XSUlJxMXFERQUROvWrZkyZQpz5syhQ4cOdOjQgTlz5uDt7c0999yjYdWNz8XOY0REBHfccQe7du3ihx9+wG63u753goKCMJlM9VtcvV+vI2oFqPLx6aefal2ax5NLe2vn+++/V7t27aqazWa1U6dO6uLFi7UuyePk5uaqTz75pNq6dWvVYrGoUVFR6gsvvKCWlJRoXVqjtmHDhip/Hz7wwAOqqjov73355ZfVsLAw1Ww2q9ddd526b98+bYtuhC52HpOSki74vbNhw4Z6r01RVVWt37gjhBBCCHFhMmZECCGEEJqSMCKEEEIITUkYEUIIIYSmJIwIIYQQQlMSRoQQQgihKQkjQgghhNCUhBEhhBBCaErCiBBCCCE0JWFECCGEEJqSMCKEEEIITUkYEUIIIYSm/h+mdwV7puWl1AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "59.7\n", + "721.1\n", + "716.506\n", + "717.332\n", + "701.8\n" + ] + } + ], + "source": [ + "# elements include nodes, edge centers, or face centers) \n", + "element = 'face centers'\n", + "element = 'nodes'\n", + "\n", + "var = 'GPP'\n", + "bbox_var = ds0[var].subset.bounding_box(\n", + " lon_bounds, lat_bounds, element=element)\n", + "\n", + "bbox_area = ds0[\"area\"].subset.bounding_box(\n", + " lon_bounds, lat_bounds, element=element)\n", + "\n", + "bbox_landfrac = ds0[\"landfrac\"].subset.bounding_box(\n", + " lon_bounds, lat_bounds, element=element)\n", + "\n", + "# Area weighting\n", + "bbox_wgt = bbox_area * bbox_landfrac / ((bbox_area * bbox_landfrac).sum())\n", + "y = (bbox_var * bbox_wgt).sum('n_face').values\n", + "x = bbox_var['time'].values\n", + "\n", + "plt.plot(x, y, label = 'raw ne30, ' + str(np.round(y.mean() * spy, 1))) \n", + "\n", + "#repeat for regridded climo\n", + "bbox_area_r = fv_t232['area'].sel(lon=slice(lon_bounds2[0],lon_bounds2[1]),lat=slice(lat_bounds[0],lat_bounds[1])) \n", + "bbox_landfrac_r = fv_t232['landfrac'].sel(lon=slice(lon_bounds2[0],lon_bounds2[1]),lat=slice(lat_bounds[0],lat_bounds[1])) \n", + "bbox_wgt_r = bbox_area_r * bbox_landfrac_r / ((bbox_area_r * bbox_landfrac_r).sum())\n", + "\n", + "# Better with destination area\n", + "bbox_area_rB = ds_out_con['area'].sel(lon=slice(lon_bounds2[0],lon_bounds2[1]),lat=slice(lat_bounds[0],lat_bounds[1])) \n", + "bbox_landfrac_rB = ds_out_con['landfrac'].sel(lon=slice(lon_bounds2[0],lon_bounds2[1]),lat=slice(lat_bounds[0],lat_bounds[1])) \n", + "bbox_landfrac_rC = ds_out_con['landfrac'].where(fv_t232['landmask']==1).sel(lon=slice(lon_bounds2[0],lon_bounds2[1]),lat=slice(lat_bounds[0],lat_bounds[1])) \n", + "bbox_wgt_rB = bbox_area_r * bbox_landfrac_rB / ((bbox_area_r * bbox_landfrac_rB).sum())\n", + "bbox_wgt_rC = bbox_area_r * bbox_landfrac_rC / ((bbox_area_r * bbox_landfrac_rC).sum())\n", + "\n", + "bbox_var_r = ds_out_con[var].sel(lon=slice(lon_bounds2[0],lon_bounds2[1]),lat=slice(lat_bounds[0],lat_bounds[1])) \n", + "y_r = (bbox_var_r * bbox_wgt_r).sum(['lat','lon']).values\n", + "y_rB = (bbox_var_r * bbox_wgt_rB).sum(['lat','lon']).values\n", + "y_rC = (bbox_var_r * bbox_wgt_rC).sum(['lat','lon']).values\n", + "plt.plot(x, y_r, label = 'cons destination mask & landfrac, ' + str(np.round(y_r.mean()* spy,1))) \n", + "plt.plot(x, y_rB, label = 'cons. no mask regridded landfrac ' + str(np.round(y_rB.mean()* spy,1))) \n", + "\n", + "bbox_var_r2 = ds_out_bilin[var].sel(lon=slice(lon_bounds2[0],lon_bounds2[1]),lat=slice(lat_bounds[0],lat_bounds[1])) \n", + "y_r2 = (bbox_var_r2 * bbox_wgt_r).sum(['lat','lon']).values\n", + "plt.plot(x, y_r2,\n", + " label= 'bilinear destination mask & landfrac, ' + str(np.round(y_r2.mean()* spy,1))) \n", + "\n", + "plt.title(region + ' climatology, annual regional integral (gC/y)')\n", + "plt.legend()\n", + "plt.show();\n", + "# Print mean annual flux from region (not time weighted correctly)\n", + "print(np.round(y.mean()* spy,1))\n", + "print(np.round(y_r.mean()* spy,1))\n", + "print(np.round(y_rB.mean()* spy,3))\n", + "print(np.round(y_rC.mean()* spy,3))\n", + "print(np.round(y_r2.mean()* spy,1))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "537d79e9-58a4-4c50-a251-a15e1ab56852", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Size: 4B\n", + "array(1.7618376, dtype=float32)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'landfrac' ()> Size: 4B\n",
+       "array(1.762814, dtype=float32)
" + ], + "text/plain": [ + " Size: 4B\n", + "array(1.762814, dtype=float32)" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(bbox_landfrac_r.sum()) #destination land frac sum\n", + "\n", + "bbox_landfrac_rB.sum() #regridded land frac sum\n", + "#bbox_wgt_rC.plot(vmax=0.18,vmin=0.04)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "293363a0-ffd0-4a02-a503-ba1681e3eb20", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bbox_wgt_rB.plot(vmax=0.18,vmin=0.04)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "3158b3ed-a0d4-436e-95ed-c0ebedfbee56", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(bbox_landfrac_rC*bbox_var_r).sum(['lat','lon']).plot(label='dest mask')\n", + "(bbox_landfrac_rB*bbox_var_r).sum(['lat','lon']).plot(label='no mask')\n", + "plt.legend();" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "5fa74a76-d239-4155-a123-3deadd3cbec5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "24003.926\n", + "288054.2\n" + ] + } + ], + "source": [ + " print((bbox_area_r * bbox_landfrac_r).sum().values)\n", + " print((bbox_area * bbox_landfrac).sum().values)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "db8184cd-e3a6-4585-9eec-ead1704ec0f6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'/glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc'" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mesh0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a8b6931-dfd1-4c10-aace-fa24f93edf4f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "NPL 2024b", + "language": "python", + "name": "npl-2024b" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 90505177c9922b36831ababa48e3043ef91ce331 Mon Sep 17 00:00:00 2001 From: wwieder Date: Tue, 30 Sep 2025 08:06:54 -0600 Subject: [PATCH 103/126] may not be needed --- scripts/plotting/polar_map.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/scripts/plotting/polar_map.py b/scripts/plotting/polar_map.py index ff7343709..8aa1f5b7a 100644 --- a/scripts/plotting/polar_map.py +++ b/scripts/plotting/polar_map.py @@ -339,6 +339,10 @@ def polar_map(adfobj): elif (var == 'FAREA_BURNED') and (s == 'SON'): print("\t\t Skipping FAREA_BURNED in SON plot") continue + # not working for regular grids? + elif (var == 'NPP'): + print("\t\t Skipping NPP polar plot") + continue else: pf.make_polar_plot(plot_name, case_nickname, base_nickname, [syear_cases[case_idx],eyear_cases[case_idx]], From 29110eed1675514360a77ee3ff533b349173e9e9 Mon Sep 17 00:00:00 2001 From: wwieder Date: Tue, 30 Sep 2025 08:08:16 -0600 Subject: [PATCH 104/126] config example for B-case --- config_clm_unstructured_plots.yaml | 37 +++++++++++++++++------------- 1 file changed, 21 insertions(+), 16 deletions(-) diff --git a/config_clm_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml index 75061eef7..e8de42aa1 100644 --- a/config_clm_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -137,16 +137,16 @@ diag_cam_climo: cam_overwrite_climo: false #Name of CAM case (or CAM run name): - cam_case_name: b.e30_beta06.B1850C_LTso.ne30_t232_wgx3.188 + cam_case_name: b.e30_alpha07b_dev.B1850C_LTso.ne30_t232_wgx3.213 #Case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '188' + case_nickname: '213' #Location of CAM history (h0) files: - cam_hist_loc: /glade/derecho/scratch/gmarques/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ + cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ # If unstructured_plotting, a mesh file is required! mesh_file: /glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc @@ -154,12 +154,12 @@ diag_cam_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 76 - + start_year: 01 + climo_start_year: 68 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 95 + end_year: 88 #Do time series files exist? #If True, then diagnostics assumes that model files are already time series. @@ -199,13 +199,13 @@ diag_cam_baseline_climo: cam_overwrite_climo: false #Name of CAM baseline case: - cam_case_name: b.e30_beta06.B1850C_LTso.ne30_t232_wgx3.179 + cam_case_name: b.e30_alpha07b_dev.B1850C_LTso.ne30_t232_wgx3.198 #Baseline case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '179' + case_nickname: '198' #Location of CAM baseline history (h0) files: #Example test files @@ -220,12 +220,13 @@ diag_cam_baseline_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 76 + start_year: 01 + climo_start_year: 128 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 95 + end_year: 148 #Do time series files need to be generated? #If True, then diagnostics assumes that model files are already time series. @@ -264,7 +265,7 @@ time_averaging_scripts: #Name of regridding scripts being used. #These scripts must be located in "scripts/regridding": regridding_scripts: - # - regrid_and_vert_interp + # - regrid_and_vert_interp #List of analysis scripts being used. #These scripts must be located in "scripts/analysis": @@ -287,6 +288,7 @@ diag_var_list: - ELAI - FSDS - FLDS + - QBOT - ASA - RNET - FSH @@ -296,27 +298,30 @@ diag_var_list: - FCEV - QRUNOFF_TO_COUPLER - SNOWDP + - FPSN - TOTVEGC - GPP - NEE - NPP - NBP + - NPP_NUPTAKE - BTRANMN - TOTECOSYSC - TOTSOMC_1m - ALTMAX - FAREA_BURNED - + - TWS + - GRAINC_TO_FOOD region_list: - Global - #- N Hemisphere Land - #- S Hemisphere Land + - N Hemisphere Land + - S Hemisphere Land - Polar - Alaskan Arctic - Canadian Arctic - Greenland - Russian Arctic - #- Antarctica + # - Antarctica - Alaska - Northwest Canada - Central Canada @@ -340,7 +345,7 @@ region_list: - Indochina #- Sahara Desert #- Arabian Peninsula - #- Australia + - Australia #- Central Asia ## Was Broken... probably because there were two? #- Mongolia #- Tibetan Plateau From bb243011df390b5f92b22723c9cd6b9695dbac7a Mon Sep 17 00:00:00 2001 From: Meg Fowler Date: Fri, 3 Oct 2025 08:41:38 -0600 Subject: [PATCH 105/126] Add regional map for structured grids --- scripts/plotting/regional_climatology.py | 54 +++++++++++++++++------- 1 file changed, 38 insertions(+), 16 deletions(-) diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 0f3825af0..7de80c94a 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -288,24 +288,39 @@ def regional_climatology(adfobj): obs_var_wgtd = np.sum(obs_var * wgt_sub, axis=(1,2)) #/ np.sum(wgt_sub) ## Plot the map: - if plt_counter==1 and unstruct_plotting == True: - ## this only works for unstructured plotting: + if plt_counter==1: ## Define region in first subplot fig.delaxes(axs[0]) transform = ccrs.PlateCarree() projection = ccrs.PlateCarree() base_var_mask = base_var.isel(time=0) - base_var_mask[np.isfinite(base_var_mask)]=1 - collection = base_var_mask.to_polycollection() - - collection.set_transform(transform) - collection.set_cmap('rainbow_r') - collection.set_antialiased(False) - map_ax = fig.add_subplot(4, 4, 1, projection=ccrs.PlateCarree()) - - map_ax.coastlines() - map_ax.add_collection(collection) + + if unstruct_plotting == True: + base_var_mask[np.isfinite(base_var_mask)]=1 + collection = base_var_mask.to_polycollection() + + collection.set_transform(transform) + collection.set_cmap('rainbow_r') + collection.set_antialiased(False) + map_ax = fig.add_subplot(4, 4, 1, projection=ccrs.PlateCarree()) + + map_ax.coastlines() + map_ax.add_collection(collection) + elif unstruct_plotting == False: + base_var_mask = base_var_mask.copy() + base_var_mask.values[np.isfinite(base_var_mask.values)] = 1 + + map_ax = fig.add_subplot(4, 4, 1, projection=ccrs.PlateCarree()) + map_ax.coastlines() + + # Plot using pcolormesh for structured grids + im = map_ax.pcolormesh(base_var_mask.lon, base_var_mask.lat, + base_var_mask.values, + transform=transform, + cmap='rainbow_r', + shading='auto') + map_ax.set_global() # Add map extent selection if region_list[iReg]=='N Hemisphere Land': @@ -459,12 +474,19 @@ def getRegion_xarray(varDS, varName, varDS = varDS[varName] # Subset the dataarray using the specified box - domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N), - lon=slice(BOX_W, BOX_E)) - weight_subset = weight.sel(lat=slice(BOX_S, BOX_N), - lon=slice(BOX_W, BOX_E)) + if BOX_W>BOX_E: + iLons = np.where((varDS.lon.values>=BOX_W) | (varDS.lon.values<=BOX_E) )[0] + domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N)).isel(lon=iLons) + + weight_subset = weight.sel(lat=slice(BOX_S, BOX_N)).isel(lon=iLons) + else: + domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N), + lon=slice(BOX_W, BOX_E)) + weight_subset = weight.sel(lat=slice(BOX_S, BOX_N), + lon=slice(BOX_W, BOX_E)) wgt_subset = weight_subset / weight_subset.sum() + return domain_subset,wgt_subset def get_region_boundaries(regions, region_name): From 99ee584b0c6c1a749d991844fa67e4580a48aef9 Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 10 Oct 2025 07:28:31 -0600 Subject: [PATCH 106/126] initial C isotope results --- lib/adf_diag.py | 28 ++++++++++++++++++++++++++++ lib/ldf_variable_defaults.yaml | 20 ++++++++++++++++++++ 2 files changed, 48 insertions(+) diff --git a/lib/adf_diag.py b/lib/adf_diag.py index 4119d2dd1..da26dff08 100644 --- a/lib/adf_diag.py +++ b/lib/adf_diag.py @@ -1374,6 +1374,34 @@ def derive_variables(self, res=None, hist_str=None, vars_to_derive=None, ts_dir= der_val = 100*ds["FSR"]/ds["FSDS"].where(ds["FSDS"]>0) elif var == "RNET": der_val = ds["FSA"]-ds["FIRA"] + elif var == "WUE": + der_val = ds["GPP"]/ds["FCTR"].where(ds["FCTR"]>0) + + # ---------------------------------------------------------------------------------- + # Isotope-specific derived variables + # ---------------------------------------------------------------------------------- + # NOTE: del13C : valid range = -40 to 0 per mil PDB + # formulas similar to Jain et al 1996 Tellus B 48B: 583-600 + # as applied in land_diags /glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/code/shared/lnd_func.ncl + # TODO, this would be nice to avoid repeating for all isotopes enables variables + # TODO, check for accuracy of equations, neither as as in Jain et al 1996... + + elif var == "C13_GPP_pm": + der_val = (((ds["C13_GPP"]/ds["GPP"].where(ds["GPP"]>0)) / 0.01112) - 1.) * 1000. + # Still getting wacky values in DJF when GPP is low + # mask out values where der_val < -40 + der_val = der_val.where(der_val>-40.) + + elif var == "C14_GPP_pm": + der_val = (((ds["C14_GPP"]/ds["GPP"].where(ds["GPP"]>0)) / 1.176e-12) - 1.) + + elif var == "C14_TOTVEGC_pm": + der_val = (((ds["C14_TOTVEGC"]/ds["TOTVEGC"].where(ds["TOTVEGC"]>0)) / 1.176e-12) - 1.) + + elif var == "C13_TOTVEGC_pm": + der_val = (((ds["C13_TOTVEGC"]/ds["TOTVEGC"].where(ds["TOTVEGC"]>0)) / 0.01112) - 1.) * 1000. + der_val = der_val.where(der_val>-40.) + else: # Loop through all constituents and sum der_val = 0 diff --git a/lib/ldf_variable_defaults.yaml b/lib/ldf_variable_defaults.yaml index 4a2994828..3a649c2c6 100644 --- a/lib/ldf_variable_defaults.yaml +++ b/lib/ldf_variable_defaults.yaml @@ -474,6 +474,26 @@ TOTVEGC: avg_method: 'sum' table_unit: "PgC" +# C Isotopes +C13_GPP_pm: + category: "Carbon" + derivable_from: ["C13_GPP","GPP"] + new_unit: "per mil PDB" + +C14_GPP_pm: #TODO, check that calculations are correct + category: "Carbon" + derivable_from: ["C14_GPP","GPP"] + new_unit: "per mil PDB" + +C13_TOTVEGC_pm: #TODO, check that calculations are correct + category: "Carbon" + derivable_from: ["C13_TOTVEGC","TOTVEGC"] + new_unit: "per mil PDB" + +C14_TOTVEGC_pm: #TODO, check that calculations are correct + category: "Carbon" + derivable_from: ["C14_TOTVEGC","TOTVEGC"] + new_unit: "per mil PDB" #+++++++++++ # Category: CROP From 898c9c31fcd842132d6bbaf8a5ffabf5d4f5e1ae Mon Sep 17 00:00:00 2001 From: wwieder Date: Tue, 14 Oct 2025 11:18:29 -0600 Subject: [PATCH 107/126] more Ciso processing --- lib/adf_diag.py | 46 +++++++--- lib/ldf_variable_defaults.yaml | 39 ++++++++- scripts/plotting/regional_climatology.py | 102 +++++++++++++---------- 3 files changed, 128 insertions(+), 59 deletions(-) diff --git a/lib/adf_diag.py b/lib/adf_diag.py index da26dff08..2f6520b18 100644 --- a/lib/adf_diag.py +++ b/lib/adf_diag.py @@ -768,7 +768,8 @@ def call_ncrcat(cmd): "ncatted", "-O", "-a", "adf_user,global,a,c," + f"{self.user}", "-a", "hist_file_locs,global,a,c," + f"{hist_locs_str}", - "-a", "hist_file_list,global,a,c," + f"{hist_files_str}", + # This list is too long and fails + # "-a", "hist_file_list,global,a,c," + f"{hist_files_str}", ts_outfil_str ] @@ -1357,6 +1358,10 @@ def derive_variables(self, res=None, hist_str=None, vars_to_derive=None, ts_dir= # create new file name for derived variable derived_file = constit_files[0].replace(constit_list[0], var) + clmPDB = 0.0112372 # ratio of 13C/12C in Pee Dee Belemnite (C isotope standard) + clm14C = 1e-12 # not accepted value of 1.176 x 10-12 + min13C = -40. # prevent wacky values when 12C stock or fluxes are very small + min14C = -400. # arbitrary # Check if clobber is true for file if Path(derived_file).is_file(): if overwrite: @@ -1384,23 +1389,40 @@ def derive_variables(self, res=None, hist_str=None, vars_to_derive=None, ts_dir= # formulas similar to Jain et al 1996 Tellus B 48B: 583-600 # as applied in land_diags /glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/code/shared/lnd_func.ncl # TODO, this would be nice to avoid repeating for all isotopes enables variables - # TODO, check for accuracy of equations, neither as as in Jain et al 1996... - + # TODO, check for accuracy of equations, neither as as in Jain et al 1996... + # Should they just be ((ratio sample - ratio standard) / ratio standard) * 1000 ? + elif var == "C13_GPP_pm": - der_val = (((ds["C13_GPP"]/ds["GPP"].where(ds["GPP"]>0)) / 0.01112) - 1.) * 1000. - # Still getting wacky values in DJF when GPP is low - # mask out values where der_val < -40 - der_val = der_val.where(der_val>-40.) + der_val = (((ds["C13_GPP"]/ds["GPP"].where(ds["GPP"]>0)) / clmPDB) - 1.) * 1e3 + der_val = der_val.where(der_val > min13C) elif var == "C14_GPP_pm": - der_val = (((ds["C14_GPP"]/ds["GPP"].where(ds["GPP"]>0)) / 1.176e-12) - 1.) + der_val = (((ds["C14_GPP"]/ds["GPP"].where(ds["GPP"]>0)) / clm14C) - 1.) * 1e3 + der_val = der_val.where(der_val > min14C) - elif var == "C14_TOTVEGC_pm": - der_val = (((ds["C14_TOTVEGC"]/ds["TOTVEGC"].where(ds["TOTVEGC"]>0)) / 1.176e-12) - 1.) + elif var == "C13_NPP_pm": + der_val = (((ds["C13_NPP"]/ds["NPP"].where(ds["NPP"]>0)) / clmPDB) - 1.) * 1e3 + der_val = der_val.where(der_val > min13C) + + elif var == "C14_NPP_pm": + der_val = (((ds["C14_NPP"]/ds["NPP"].where(ds["NPP"]>0)) / clm14C) - 1.) * 1e3 + der_val = der_val.where(der_val > min14C) elif var == "C13_TOTVEGC_pm": - der_val = (((ds["C13_TOTVEGC"]/ds["TOTVEGC"].where(ds["TOTVEGC"]>0)) / 0.01112) - 1.) * 1000. - der_val = der_val.where(der_val>-40.) + der_val = (((ds["C13_TOTVEGC"]/ds["TOTVEGC"].where(ds["TOTVEGC"]>0)) / clmPDB) - 1.) * 1e3 + der_val = der_val.where(der_val > min13C) + + elif var == "C14_TOTVEGC_pm": + der_val = (((ds["C14_TOTVEGC"]/ds["TOTVEGC"].where(ds["TOTVEGC"]>0)) / clm14C) - 1.) * 1e3 + der_val = der_val.where(der_val > min14C) + + elif var == "C13_TOTECOSYSC_pm": + der_val = (((ds["C13_TOTECOSYSC"]/ds["TOTECOSYSC"].where(ds["TOTECOSYSC"]>0)) / clmPDB) - 1.) * 1e3 + der_val = der_val.where(der_val > min13C) + + elif var == "C14_TOTECOSYSC_pm": + der_val = (((ds["C14_TOTECOSYSC"]/ds["TOTECOSYSC"].where(ds["TOTECOSYSC"]>0)) / clm14C) - 1.) * 1e3 + #der_val = der_val.where(der_val > min14C) else: # Loop through all constituents and sum diff --git a/lib/ldf_variable_defaults.yaml b/lib/ldf_variable_defaults.yaml index 3a649c2c6..3f6bcd620 100644 --- a/lib/ldf_variable_defaults.yaml +++ b/lib/ldf_variable_defaults.yaml @@ -478,22 +478,53 @@ TOTVEGC: C13_GPP_pm: category: "Carbon" derivable_from: ["C13_GPP","GPP"] - new_unit: "per mil PDB" + new_unit: "per mile PDB" C14_GPP_pm: #TODO, check that calculations are correct category: "Carbon" derivable_from: ["C14_GPP","GPP"] - new_unit: "per mil PDB" + new_unit: "per mile" C13_TOTVEGC_pm: #TODO, check that calculations are correct category: "Carbon" derivable_from: ["C13_TOTVEGC","TOTVEGC"] - new_unit: "per mil PDB" + new_unit: "per mile PDB" C14_TOTVEGC_pm: #TODO, check that calculations are correct category: "Carbon" derivable_from: ["C14_TOTVEGC","TOTVEGC"] - new_unit: "per mil PDB" + new_unit: "per mile" + +C13_TOTSOMC_pm: #TODO, check that calculations are correct + category: "Carbon" + derivable_from: ["C13_TOTSOMC","TOTSOMC"] + new_unit: "per mile PDB" + +C14_TOTSOMC_pm: #TODO, check that calculations are correct + category: "Carbon" + derivable_from: ["C14_TOTSOMC","TOTSOMC"] + new_unit: "per mile" + +C13_TOTECOSYSC_pm: #TODO, check that calculations are correct + category: "Carbon" + derivable_from: ["C13_TOTECOSYSC","TOTECOSYSC"] + new_unit: "per mile PDB" + +C14_TOTECOSYSC_pm: #TODO, check that calculations are correct + category: "Carbon" + derivable_from: ["C14_TOTECOSYSC","TOTECOSYSC"] + new_unit: "per mile" + +C13_TOTLITC_pm: #TODO, check that calculations are correct + category: "Carbon" + derivable_from: ["C13_TOTLITC","TOTLITC"] + new_unit: "per mile PDB" + +C14_TOTLITC_pm: #TODO, check that calculations are correct + category: "Carbon" + derivable_from: ["C14_TOTLITC","TOTLITC"] + new_unit: "per mile" + #+++++++++++ # Category: CROP diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 8c8d63eec..7de80c94a 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -76,9 +76,9 @@ def regional_climatology(adfobj): region_list = adfobj.region_list #TODO, make it easier for users decide on these? regional_climo_var_list = ['TSA','PREC','ELAI', - 'FSDS','FLDS','SNOWDP','ASA', + 'FSDS','FLDS','QBOT','ASA', 'FSH','QRUNOFF_TO_COUPLER','ET','FCTR', - 'GPP','TWS','FCEV','FGEV', + 'GPP','BTRANMN','FCEV','FGEV', ] ## Open observations YML here? @@ -145,18 +145,14 @@ def regional_climatology(adfobj): print('Missing file for ', field) continue else: - # get area and landfrac for base and case climo datasets mdataset = adfobj.data.load_climo_dataset(case_name, field, **kwargs) - area_c = mdataset.area.isel(time=0) # drop time dimension to avoid confusion - landfrac_c = mdataset.landfrac.isel(time=0) + area = mdataset.area.isel(time=0) # drop time dimension to avoid confusion + landfrac = mdataset.landfrac.isel(time=0) # Redundant, but we'll do this for consistency: # TODO, won't handle loadling the basecase this way - #area_b = adfobj.data.load_reference_climo_da(baseline_name, 'area', **kwargs) - #landfrac_b = adfobj.data.load_reference_climo_da(baseline_name, 'landfrac', **kwargs) - - mdataset_base = adfobj.data.load_reference_climo_dataset(baseline_name, field, **kwargs) - area_b = mdataset_base.area.isel(time=0) - landfrac_b = mdataset_base.landfrac.isel(time=0) + #mdataset_base = adfobj.data.load_climo_dataset(baseline_name, field, **kwargs) + #area_base = mdataset_base.area.isel(time=0) + #landfrac_base = mdataset_base.landfrac.isel(time=0) # calculate weights # WW: 1) should actual weight calculation be done after subsetting to region? @@ -242,7 +238,7 @@ def regional_climatology(adfobj): for iReg in range(len(region_list)): print(f"\n\t - Plotting regional climatology for: {region_list[iReg]}") # regionDS_thisRg = regionDS.isel(region=region_indexList[iReg]) - box_west, box_east, box_south, box_north, region_category = get_region_boundaries(regions, region_list[iReg]) + box_west, box_east, box_south, box_north = get_region_boundaries(regions, region_list[iReg]) ## Set up figure ## TODO: Make the plot size/number of subplots resopnsive to number of fields specified fig,axs = plt.subplots(4,4, figsize=(18,12)) @@ -258,12 +254,12 @@ def regional_climatology(adfobj): # TODO: handle regular gridded case if unstruct_plotting == True: # uxarray output is time*nface, sum over nface - base_var,wgt_sub = getRegion_uxarray(uxgrid, base_data, field, area_b, landfrac_b, + base_var,wgt_sub = getRegion_uxarray(uxgrid, base_data, field, area, landfrac, box_west, box_east, box_south, box_north) base_var_wgtd = np.sum(base_var * wgt_sub, axis=-1) # WW not needed?/ np.sum(wgt_sub) - case_var,wgt_sub = getRegion_uxarray(uxgrid, case_data, field, area_c, landfrac_c, + case_var,wgt_sub = getRegion_uxarray(uxgrid, case_data, field, area, landfrac, box_west, box_east, box_south, box_north) case_var_wgtd = np.sum(case_var * wgt_sub, axis=-1) #/ np.sum(wgt_sub) @@ -273,13 +269,13 @@ def regional_climatology(adfobj): base_var, wgt_sub = getRegion_xarray(base_data[field], field, box_west, box_east, box_south, box_north, - area_b, landfrac_b) + area, landfrac) base_var_wgtd = np.sum(base_var * wgt_sub, axis=(1,2)) case_var, wgt_sub = getRegion_xarray(case_data[field], field, box_west, box_east, box_south, box_north, - area_c, landfrac_c) + area, landfrac) case_var_wgtd = np.sum(case_var * wgt_sub, axis=(1,2)) # Read in observations, if available @@ -292,24 +288,39 @@ def regional_climatology(adfobj): obs_var_wgtd = np.sum(obs_var * wgt_sub, axis=(1,2)) #/ np.sum(wgt_sub) ## Plot the map: - if plt_counter==1 and unstruct_plotting == True: - ## this only works for unstructured plotting: + if plt_counter==1: ## Define region in first subplot fig.delaxes(axs[0]) transform = ccrs.PlateCarree() projection = ccrs.PlateCarree() base_var_mask = base_var.isel(time=0) - base_var_mask[np.isfinite(base_var_mask)]=1 - collection = base_var_mask.to_polycollection() - - collection.set_transform(transform) - collection.set_cmap('rainbow_r') - collection.set_antialiased(False) - map_ax = fig.add_subplot(4, 4, 1, projection=ccrs.PlateCarree()) - - map_ax.coastlines() - map_ax.add_collection(collection) + + if unstruct_plotting == True: + base_var_mask[np.isfinite(base_var_mask)]=1 + collection = base_var_mask.to_polycollection() + + collection.set_transform(transform) + collection.set_cmap('rainbow_r') + collection.set_antialiased(False) + map_ax = fig.add_subplot(4, 4, 1, projection=ccrs.PlateCarree()) + + map_ax.coastlines() + map_ax.add_collection(collection) + elif unstruct_plotting == False: + base_var_mask = base_var_mask.copy() + base_var_mask.values[np.isfinite(base_var_mask.values)] = 1 + + map_ax = fig.add_subplot(4, 4, 1, projection=ccrs.PlateCarree()) + map_ax.coastlines() + + # Plot using pcolormesh for structured grids + im = map_ax.pcolormesh(base_var_mask.lon, base_var_mask.lat, + base_var_mask.values, + transform=transform, + cmap='rainbow_r', + shading='auto') + map_ax.set_global() # Add map extent selection if region_list[iReg]=='N Hemisphere Land': @@ -347,12 +358,10 @@ def regional_climatology(adfobj): continue else: # TODO handle unit conversions correctly, working for structured, but not unstructured yet - # using ldf_v0.0 and uxarray 2025.03.0 this seems to be working as expected, - # TODO check results with updated uxarray 2025.06? - #if unstruct_plotting == True: - # if (field == 'GPP') or (field == 'NEE') or (field == 'NBP'): - # case_var_wgtd = case_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day - # base_var_wgtd = base_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day + if unstruct_plotting == True: + if (field == 'GPP') or (field == 'NEE') or (field == 'NBP'): + case_var_wgtd = case_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day + base_var_wgtd = base_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day axs[plt_counter].plot(np.arange(12)+1, case_var_wgtd, label=case_nickname, linewidth=2) @@ -384,7 +393,7 @@ def regional_climatology(adfobj): #Add already-existing plot to website (if enabled): adfobj.debug_log(f"'{plot_loc}' exists and clobber is false.") adfobj.add_website_data(plot_loc, region_list[iReg], None, season=None, multi_case=True, - category=region_category, non_season=True, plot_type = "RegionalClimo") + non_season=True, plot_type = "RegionalClimo") #Continue to next iteration: return @@ -397,7 +406,7 @@ def regional_climatology(adfobj): #Add plot to website (if enabled): adfobj.add_website_data(plot_loc, region_list[iReg], None, season=None, multi_case=True, - non_season=True, category=region_category, plot_type = "RegionalClimo") + non_season=True, plot_type = "RegionalClimo") return @@ -420,7 +429,8 @@ def getRegion_uxarray(gridDS, varDS, varName, area, landfrac, BOX_W, BOX_E, BOX_ area_subset = area.isel(n_face=node_indices) landfrac_subset = landfrac.isel(n_face=node_indices) wgt_subset = area_subset * landfrac_subset / (area_subset* landfrac_subset).sum() - + # area_subset = varDS['area'].isel(n_face=node_indices) + # lf_subset = varDS['landfrac'].isel(n_face=node_indices) return domain_subset,wgt_subset def getRegion_xarray(varDS, varName, @@ -464,12 +474,19 @@ def getRegion_xarray(varDS, varName, varDS = varDS[varName] # Subset the dataarray using the specified box - domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N), - lon=slice(BOX_W, BOX_E)) - weight_subset = weight.sel(lat=slice(BOX_S, BOX_N), - lon=slice(BOX_W, BOX_E)) + if BOX_W>BOX_E: + iLons = np.where((varDS.lon.values>=BOX_W) | (varDS.lon.values<=BOX_E) )[0] + domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N)).isel(lon=iLons) + + weight_subset = weight.sel(lat=slice(BOX_S, BOX_N)).isel(lon=iLons) + else: + domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N), + lon=slice(BOX_W, BOX_E)) + weight_subset = weight.sel(lat=slice(BOX_S, BOX_N), + lon=slice(BOX_W, BOX_E)) wgt_subset = weight_subset / weight_subset.sum() + return domain_subset,wgt_subset def get_region_boundaries(regions, region_name): @@ -480,6 +497,5 @@ def get_region_boundaries(regions, region_name): region = regions[region_name] south, north = region['lat_bounds'] west, east = region['lon_bounds'] - region_category = region['region_category'] if 'region_category' in region else None - return west, east, south, north, region_category + return west, east, south, north \ No newline at end of file From cb5720d13703acecad4a81ac22e3107ce24c6d91 Mon Sep 17 00:00:00 2001 From: wwieder Date: Tue, 14 Oct 2025 20:49:46 -0600 Subject: [PATCH 108/126] fixes #409, partially --- scripts/plotting/aod_latlon.py | 495 ++++++++++++++++++++++++++ scripts/plotting/global_latlon_map.py | 32 +- 2 files changed, 518 insertions(+), 9 deletions(-) create mode 100644 scripts/plotting/aod_latlon.py diff --git a/scripts/plotting/aod_latlon.py b/scripts/plotting/aod_latlon.py new file mode 100644 index 000000000..462242037 --- /dev/null +++ b/scripts/plotting/aod_latlon.py @@ -0,0 +1,495 @@ +"""Module for AOD-specific plotting functionality""" + +from pathlib import Path +import numpy as np +import xarray as xr +import xesmf as xe + + +import matplotlib as mpl +import matplotlib.pyplot as plt +from matplotlib import gridspec +import cartopy.crs as ccrs +from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter +from cartopy.util import add_cyclic_point + +import plotting_functions as pf + +from dataclasses import dataclass, field + +@dataclass +class AODPlotConfig: + """Configuration for AOD plots.""" + seasons: list = ('DJF', 'MAM', 'JJA', 'SON') + season_names: dict = field(default_factory=lambda: { + 'DJF': 'Dec-Jan-Feb', + 'MAM': 'Mar-Apr-May', + 'JJA': 'Jun-Jul-Aug', + 'SON': 'Sep-Oct-Nov' + }) + obs_sources: list = ('TERRA MODIS', 'MERRA2') + var_name: str = 'AODVISdn' + + +def aod_latlon(adfobj): + """Generate AOD comparison plots.""" + config = AODPlotConfig() + + # Load observations + obs_data = load_observations(adfobj) + if not obs_data: + return + + # Process model data + model_data = process_model_cases(adfobj, config.var_name, obs_data) + if not model_data: + return + + # Generate plots + for obs_source, obs_dataset in obs_data.items(): + for season in config.seasons: + create_aod_panel(adfobj, model_data, obs_dataset, + season, obs_source) + + +def load_observations(adfobj): + """Load MERRA2 and MODIS observation datasets. + + Parameters + ---------- + adfobj : AdfDiag + The diagnostics object containing configuration + + Returns + ------- + dict + Dictionary of observation datasets keyed by source name + """ + obs_dir = adfobj.get_basic_info("obs_data_loc") + obs_files = { + 'TERRA MODIS': 'MOD08_M3_192x288_AOD_2001-2020_climo.nc', + 'MERRA2': 'MERRA2_192x288_AOD_2001-2020_climo.nc' + } + + obs_data = {} + for source, filename in obs_files.items(): + ds = load_obs_data(obs_dir, filename) + if ds is None: + print(f"\t WARNING: AOD Panel plots not made, missing {source} file") + return None + + # Extract correct variable based on source + if source == 'MERRA2': + ds = ds['TOTEXTTAU'] + else: # MODIS + ds = ds['AOD_550_Dark_Target_Deep_Blue_Combined_Mean_Mean'] + + # Calculate seasonal means + ds_seasonal = monthly_to_seasonal(ds, obs=True) + obs_data[source] = ds_seasonal + + return obs_data + + +def load_obs_data(obs_dir, file_name): + """Load and prepare observational dataset.""" + file_path = Path(obs_dir) / file_name + if not file_path.is_file(): + return None + + ds = xr.open_dataset(file_path) + # Round coordinates for consistency + ds['lon'] = ds['lon'].round(5) + ds['lat'] = ds['lat'].round(5) + return ds + + +def process_model_cases(adfobj, var, obs_data): + """Process model cases and regrid if necessary. + + Parameters + ---------- + adfobj : AdfDiag + The diagnostics object containing configuration + var : str + Variable name to process + obs_data : dict + Dictionary of observation datasets with their grids + + Returns + ------- + list + List of processed model datasets, one per case + """ + # Get case information + cases = adfobj.get_cam_info('cam_case_name', required=True) + if not adfobj.compare_obs: + cases = cases + [adfobj.data.ref_case_label] # ref case added to cases + + # Get reference grid from first observation dataset + ref_obs = next(iter(obs_data.values())) + + # Process each case + processed_data = [] + for case_name in cases: + # Load and process model data + case_data = process_model_data(adfobj, case_name, var, ref_obs) + if case_data is not None: + processed_data.append((case_data, case_name)) + + return processed_data if processed_data else None + + +def process_model_data(adfobj, case_name, var, obs_shape): + """Process model data and check grid compatibility.""" + if case_name == adfobj.data.ref_case_label: + ds_case = adfobj.data.load_reference_climo_da(case_name, var) + else: + ds_case = adfobj.data.load_climo_da(case_name, var) + if ds_case is None: + print(f"\t WARNING: No climo file for {case_name} variable {var}") + return None + + ds_case['lon'] = ds_case['lon'].round(5) + ds_case['lat'] = ds_case['lat'].round(5) + + # Check grid compatibility + needs_regrid = check_grid_compatibility(ds_case, obs_shape) + if needs_regrid: + ds_case = regrid_to_obs(ds_case, obs_shape) + + return monthly_to_seasonal(ds_case) + + +def check_grid_compatibility(model_arr, obs_arr): + """Check if model grid matches observation grid. + + Parameters + ---------- + model_arr : xarray.DataArray + Model data array with lat/lon coordinates + obs_arr : xarray.DataArray + Observation data array with lat/lon coordinates + + Returns + ------- + bool + True if grids don't match and regridding is needed + """ + test_lons = model_arr.lon + test_lats = model_arr.lat + obs_lons = obs_arr.lon + obs_lats = obs_arr.lat + + # Check if shapes match first + if obs_lons.shape != test_lons.shape: + return True + + # Check exact coordinate matches + try: + xr.testing.assert_equal(test_lons, obs_lons) + xr.testing.assert_equal(test_lats, obs_lats) + return False + except AssertionError: + return True + +def create_aod_panel(adfobj, data_sets, obs_dataset, season, obs_name): + """Create AOD panel plot with differences and percent differences.""" + plot_data = [] + plot_titles = [] + plot_params = [] + case_names = [] + types = [] + + # Get plot parameters from configuration + plot_config = get_plot_params(adfobj) + + for case_data, case_name in data_sets: + # Calculate differences + diff = calculate_differences(case_data, obs_dataset, season) + plot_data.append(diff) + plot_titles.append(make_plot_config(diff, case_name, obs_name, season, "Diff")) + plot_params.append(plot_config['default']) + case_names.append(case_name) + types.append("Diff") + + # Calculate percent differences + pdiff = calculate_percent_diff(case_data, obs_dataset, season) + plot_data.append(pdiff) + plot_titles.append(make_plot_config(pdiff, case_name, obs_name, season, "Percent Diff")) + plot_params.append(plot_config['relerr']) + case_names.append(case_name) + types.append("Percent Diff") + + return aod_panel_latlon(adfobj, plot_titles, plot_params, plot_data, + season, obs_name, case_names, len(data_sets), + types, symmetric=True) + + +def validate_obs_data(merra_data, modis_data): + """Validate observation datasets.""" + if merra_data is None or modis_data is None: + raise ValueError("Missing observation data") + + if not np.array_equal(merra_data.lat, modis_data.lat): + raise ValueError("Observation grids do not match") + + +def regrid_to_obs(model_arr, obs_arr): + """Regrid model data to match observation grid using bilinear interpolation. + + Parameters + ---------- + model_arr : xarray.DataArray + Model data array to be regridded + obs_arr : xarray.DataArray + Observation data array with target grid + + Returns + ------- + xarray.DataArray + Regridded model data, or None if grids already match + """ + # Create target grid specification + ds_out = xr.Dataset({ + "lat": (["lat"], obs_arr.lat.values, {"units": "degrees_north"}), + "lon": (["lon"], obs_arr.lon.values, {"units": "degrees_east"}) + }) + + # Perform regridding + regridder = xe.Regridder(model_arr, ds_out, "bilinear", periodic=True) + model_regrid = regridder(model_arr, keep_attrs=True) + + return model_regrid + +def calculate_differences(case_data, obs_data, season): + """Calculate differences between case and observation data for a given season. + + Parameters + ---------- + case_data : xarray.DataArray + Model case data + obs_data : xarray.DataArray + Observation data + season : str + Season to calculate difference for + + Returns + ------- + xarray.DataArray + Difference between case and observation data + """ + return case_data.sel(season=season) - obs_data.sel(season=season) + + +def calculate_percent_diff(case_data, obs_data, season): + """Calculate percent difference between case and observation data. + + Parameters + ---------- + case_data : xarray.DataArray + Model case data + obs_data : xarray.DataArray + Observation data + season : str + Season to calculate difference for + + Returns + ------- + xarray.DataArray + Percent difference, clipped to [-100, 100] + """ + diff = calculate_differences(case_data, obs_data, season) + pdiff = 100 * diff / obs_data.sel(season=season) + return np.clip(pdiff, -100, 100) + + +def make_plot_config(data, case_name, obs_name, season, plot_type): + """Create plot configuration dictionary. + + Parameters + ---------- + data : xarray.DataArray + Data to plot + case_name : str + Name of case being plotted + obs_name : str + Name of observation dataset + season : str + Season being plotted + plot_type : str + Type of plot ('Diff' or 'Percent Diff') + + Returns + ------- + dict + Plot configuration including data and metadata + """ + config = AODPlotConfig() + return { + 'data': data, + 'title': f'{case_name} - {obs_name}\nAOD 550 nm - {config.season_names[season]}', + 'case_name': case_name, + 'plot_type': plot_type, + 'season': season + } + + +def get_plot_params(adfobj): + """Get AOD plot parameters from ADF configuration.""" + res = adfobj.variable_defaults + res_aod_diags = res.get("aod_diags", {}) + return { + 'default': res_aod_diags.get("plot_params", {}), + 'relerr': res_aod_diags.get("plot_params_relerr", {}) + } + +### refactored aod_panel_latlon: +def aod_panel_latlon(adfobj, plot_titles, plot_params, data, season, obs_name, case_names, case_num, types, symmetric=False): + """Create AOD panel plot with model vs observation differences. + + Parameters + ---------- + adfobj : AdfDiag + The diagnostics object containing configuration + plot_titles : list + List of titles for each panel + plot_params : list + List of plotting parameters for each panel + data : list + List of xarray DataArrays to plot + season : str + Current season being plotted + obs_name : str + Name of observation dataset + case_names : list + List of case names + case_num : int + Number of cases + types : list + List of plot types ('Diff' or 'Percent Diff') + symmetric : bool, optional + Whether to use symmetric colormap, by default False + """ + # Get plot configuration + file_type = adfobj.read_config_var("diag_basic_info").get('plot_type', 'png') + plot_dir = adfobj.plot_location[0] + plotfile = Path(plot_dir) / f'AOD_diff_{obs_name.replace(" ","_")}_{season}_LatLon_Mean.{file_type}' + + # Check if plot should be regenerated + if plotfile.is_file() and not adfobj.get_basic_info('redo_plot'): + adfobj.add_website_data(plotfile, f'AOD_diff_{obs_name.replace(" ","_")}', None, + season=season, multi_case=True, plot_type="LatLon", + category="4-Panel AOD Diags") + return + + # Create figure and axes + fig = plt.figure(figsize=(7*case_num, 10)) + gs = mpl.gridspec.GridSpec(2*case_num, int(3*case_num), wspace=0.5, hspace=0.0) + gs.tight_layout(fig) + + axs = [] + for i in range(case_num): + start = i * 3 + end = (i + 1) * 3 + axs.append(plt.subplot(gs[0:case_num, start:end], projection=ccrs.PlateCarree())) + axs.append(plt.subplot(gs[case_num:, start:end], projection=ccrs.PlateCarree())) + + # Generate each panel + for i, dataField in enumerate(data): + # Create individual plot + ind_fig, ind_ax = plt.subplots(1, 1, figsize=((7*case_num)/2, 10/2), + subplot_kw={'projection': ccrs.PlateCarree()}) + + # Prepare data + # field_values = field.values[:,:] + # lon_values = field.lon.values + lat_values = dataField.lat + field_values, lon_values = add_cyclic_point(dataField, coord=dataField.lon) + lon_mesh, lat_mesh = np.meshgrid(lon_values, lat_values) + + field_mean = np.nanmean(field_values) ## THIS IS PROBABLY THE INCORRECT AVERAGE TO USE + # field_mean = pf.spatial_average(dataField) + + # Set plot parameters + plot_param = plot_params[i] + levels = np.linspace(plot_param['range_min'], plot_param['range_max'], + plot_param['nlevel'], endpoint=True) + if 'augment_levels' in plot_param: + levels = sorted(np.append(levels, np.array(plot_param['augment_levels']))) + + plot_config = plot_titles[i] + title = f"{plot_config['title']} Mean {field_mean:.2g}" + + # Create plots + cmap_option = (plot_param.get('colormap', plt.cm.bwr) if symmetric + else plot_param.get('colormap', plt.cm.turbo)) + extend_option = 'both' if symmetric else 'max' + + for ax, is_panel in [(axs[i], True), (ind_ax, False)]: + img = ax.contourf(lon_mesh, lat_mesh, field_values, + levels, cmap=cmap_option, extend=extend_option, + transform=ccrs.PlateCarree(), + transform_first=True) + ax.set_facecolor('gray') + ax.coastlines() + ax.set_title(title, fontsize=10) + + fig_to_use = ind_fig if not is_panel else fig + cbar = fig_to_use.colorbar(img, ax=ax, orientation='horizontal', pad=0.05) + if 'ticks' in plot_param: + cbar.set_ticks(plot_param['ticks']) + if 'tick_labels' in plot_param: + cbar.ax.set_xticklabels(plot_param['tick_labels']) + cbar.ax.tick_params(labelsize=6) + + # Save individual plot + pbase = f'AOD_{case_names[i]}_vs_{obs_name.replace(" ","_")}_{types[i].replace(" ","_")}' + ind_plotfile = Path(plot_dir) / f'{pbase}_{season}_LatLon_Mean.{file_type}' + ind_fig.savefig(ind_plotfile, bbox_inches='tight', dpi=300) + plt.close(ind_fig) + + # Save panel plot + fig.savefig(plotfile, bbox_inches='tight', dpi=300) + adfobj.add_website_data(plotfile, f'AOD_diff_{obs_name.replace(" ","_")}', None, + season=season, multi_case=True, plot_type="LatLon", + category="4-Panel AOD Diags") + plt.close(fig) + + +def monthly_to_seasonal(ds, obs=False): + """Convert monthly data to seasonal means. + + Parameters + ---------- + ds : xarray.Dataset or xarray.DataArray + Input data with monthly time dimension + obs : bool, optional + Whether input is observation data, by default False + + Returns + ------- + xarray.DataArray + Data array with new season dimension + """ + seasons = ['DJF', 'MAM', 'JJA', 'SON'] + dataarrays = [] + + if obs and isinstance(ds, xr.Dataset): + # Handle observation dataset with multiple variables + for varname in ds.data_vars: + if '_n' not in varname: # Skip count variables + var_data = ds[varname] + for s in seasons: + dataarrays.append(pf.seasonal_mean(var_data, season=s, is_climo=True)) + else: + # Handle single DataArray + for s in seasons: + dataarrays.append(pf.seasonal_mean(ds, season=s, is_climo=True)) + + # Combine seasonal means + ds_seasonal = xr.concat(dataarrays, dim='season') + ds_seasonal['season'] = seasons + ds_seasonal = ds_seasonal.transpose('lat', 'lon', 'season') + + return ds_seasonal \ No newline at end of file diff --git a/scripts/plotting/global_latlon_map.py b/scripts/plotting/global_latlon_map.py index ebed009df..0bb4b2a9b 100644 --- a/scripts/plotting/global_latlon_map.py +++ b/scripts/plotting/global_latlon_map.py @@ -339,19 +339,33 @@ def global_latlon_map(adfobj): # difference: each entry should be (lat, lon) dseasons[s] = mseasons[s] - oseasons[s] - + # percent change pseasons[s] = (mseasons[s] - oseasons[s]) / np.abs(oseasons[s]) * 100.0 #relative change - pf.plot_map_and_save(plot_name, case_nickname, adfobj.data.ref_nickname, - [syear_cases[case_idx],eyear_cases[case_idx]], - [syear_baseline,eyear_baseline], - mseasons[s], oseasons[s], dseasons[s], pseasons[s], - obs=adfobj.compare_obs, unstructured=unstructured, **vres) + # If redo_plot set to True: remove old plot, if it already exists: + if (not redo_plot) and plot_name.is_file(): + #Add already-existing plot to website (if enabled): + adfobj.debug_log(f"'{plot_name}' exists and clobber is false.") + adfobj.add_website_data(plot_name, var, case_name, category=web_category, + season=s, plot_type="LatLon") + + #Continue to next iteration: + continue + else: + if plot_name.is_file(): + plot_name.unlink() - #Add plot to website (if enabled): - adfobj.add_website_data(plot_name, var, case_name, category=web_category, - season=s, plot_type="LatLon") + pf.plot_map_and_save(plot_name, case_nickname, adfobj.data.ref_nickname, + [syear_cases[case_idx],eyear_cases[case_idx]], + [syear_baseline,eyear_baseline], + mseasons[s], oseasons[s], dseasons[s], pseasons[s], + obs=adfobj.compare_obs, unstructured=unstructured, **vres) + + #Add plot to website (if enabled): + adfobj.add_website_data(plot_name, var, case_name, category=web_category, + season=s, plot_type="LatLon") + # end if redo_plot else: # => pres_levs has values, & we already checked that lev is in mdata (has_lev) From cf1c2c7f5d3c1120e1ea7baf3d81ef16f6fda1ef Mon Sep 17 00:00:00 2001 From: wwieder Date: Tue, 14 Oct 2025 22:11:45 -0600 Subject: [PATCH 109/126] trying to bring in Meg's changes --- scripts/plotting/regional_climatology.py | 72 +++++++++++++----------- 1 file changed, 40 insertions(+), 32 deletions(-) diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 7de80c94a..f32629fe4 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -76,9 +76,9 @@ def regional_climatology(adfobj): region_list = adfobj.region_list #TODO, make it easier for users decide on these? regional_climo_var_list = ['TSA','PREC','ELAI', - 'FSDS','FLDS','QBOT','ASA', + 'FSDS','FLDS','SNOWDP','ASA', 'FSH','QRUNOFF_TO_COUPLER','ET','FCTR', - 'GPP','BTRANMN','FCEV','FGEV', + 'GPP','TWS','FCEV','FGEV', ] ## Open observations YML here? @@ -145,14 +145,18 @@ def regional_climatology(adfobj): print('Missing file for ', field) continue else: + # get area and landfrac for base and case climo datasets mdataset = adfobj.data.load_climo_dataset(case_name, field, **kwargs) - area = mdataset.area.isel(time=0) # drop time dimension to avoid confusion - landfrac = mdataset.landfrac.isel(time=0) + area_c = mdataset.area.isel(time=0) # drop time dimension to avoid confusion + landfrac_c = mdataset.landfrac.isel(time=0) # Redundant, but we'll do this for consistency: # TODO, won't handle loadling the basecase this way - #mdataset_base = adfobj.data.load_climo_dataset(baseline_name, field, **kwargs) - #area_base = mdataset_base.area.isel(time=0) - #landfrac_base = mdataset_base.landfrac.isel(time=0) + #area_b = adfobj.data.load_reference_climo_da(baseline_name, 'area', **kwargs) + #landfrac_b = adfobj.data.load_reference_climo_da(baseline_name, 'landfrac', **kwargs) + + mdataset_base = adfobj.data.load_reference_climo_dataset(baseline_name, field, **kwargs) + area_b = mdataset_base.area.isel(time=0) + landfrac_b = mdataset_base.landfrac.isel(time=0) # calculate weights # WW: 1) should actual weight calculation be done after subsetting to region? @@ -238,7 +242,7 @@ def regional_climatology(adfobj): for iReg in range(len(region_list)): print(f"\n\t - Plotting regional climatology for: {region_list[iReg]}") # regionDS_thisRg = regionDS.isel(region=region_indexList[iReg]) - box_west, box_east, box_south, box_north = get_region_boundaries(regions, region_list[iReg]) + box_west, box_east, box_south, box_north, region_category = get_region_boundaries(regions, region_list[iReg]) ## Set up figure ## TODO: Make the plot size/number of subplots resopnsive to number of fields specified fig,axs = plt.subplots(4,4, figsize=(18,12)) @@ -254,12 +258,12 @@ def regional_climatology(adfobj): # TODO: handle regular gridded case if unstruct_plotting == True: # uxarray output is time*nface, sum over nface - base_var,wgt_sub = getRegion_uxarray(uxgrid, base_data, field, area, landfrac, + base_var,wgt_sub = getRegion_uxarray(uxgrid, base_data, field, area_b, landfrac_b, box_west, box_east, box_south, box_north) base_var_wgtd = np.sum(base_var * wgt_sub, axis=-1) # WW not needed?/ np.sum(wgt_sub) - case_var,wgt_sub = getRegion_uxarray(uxgrid, case_data, field, area, landfrac, + case_var,wgt_sub = getRegion_uxarray(uxgrid, case_data, field, area_c, landfrac_c, box_west, box_east, box_south, box_north) case_var_wgtd = np.sum(case_var * wgt_sub, axis=-1) #/ np.sum(wgt_sub) @@ -269,13 +273,13 @@ def regional_climatology(adfobj): base_var, wgt_sub = getRegion_xarray(base_data[field], field, box_west, box_east, box_south, box_north, - area, landfrac) + area_b, landfrac_b) base_var_wgtd = np.sum(base_var * wgt_sub, axis=(1,2)) case_var, wgt_sub = getRegion_xarray(case_data[field], field, box_west, box_east, box_south, box_north, - area, landfrac) + area_c, landfrac_c) case_var_wgtd = np.sum(case_var * wgt_sub, axis=(1,2)) # Read in observations, if available @@ -295,6 +299,7 @@ def regional_climatology(adfobj): transform = ccrs.PlateCarree() projection = ccrs.PlateCarree() base_var_mask = base_var.isel(time=0) + base_var_mask[np.isfinite(base_var_mask)]=1 if unstruct_plotting == True: base_var_mask[np.isfinite(base_var_mask)]=1 @@ -321,6 +326,14 @@ def regional_climatology(adfobj): cmap='rainbow_r', shading='auto') + collection = base_var_mask.to_polycollection() + collection.set_transform(transform) + collection.set_cmap('rainbow_r') + collection.set_antialiased(False) + map_ax = fig.add_subplot(4, 4, 1, projection=ccrs.PlateCarree()) + + map_ax.coastlines() + map_ax.add_collection(collection) map_ax.set_global() # Add map extent selection if region_list[iReg]=='N Hemisphere Land': @@ -358,10 +371,12 @@ def regional_climatology(adfobj): continue else: # TODO handle unit conversions correctly, working for structured, but not unstructured yet - if unstruct_plotting == True: - if (field == 'GPP') or (field == 'NEE') or (field == 'NBP'): - case_var_wgtd = case_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day - base_var_wgtd = base_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day + # using ldf_v0.0 and uxarray 2025.03.0 this seems to be working as expected, + # TODO check results with updated uxarray 2025.06? + #if unstruct_plotting == True: + # if (field == 'GPP') or (field == 'NEE') or (field == 'NBP'): + # case_var_wgtd = case_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day + # base_var_wgtd = base_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day axs[plt_counter].plot(np.arange(12)+1, case_var_wgtd, label=case_nickname, linewidth=2) @@ -393,7 +408,7 @@ def regional_climatology(adfobj): #Add already-existing plot to website (if enabled): adfobj.debug_log(f"'{plot_loc}' exists and clobber is false.") adfobj.add_website_data(plot_loc, region_list[iReg], None, season=None, multi_case=True, - non_season=True, plot_type = "RegionalClimo") + category=region_category, non_season=True, plot_type = "RegionalClimo") #Continue to next iteration: return @@ -406,7 +421,7 @@ def regional_climatology(adfobj): #Add plot to website (if enabled): adfobj.add_website_data(plot_loc, region_list[iReg], None, season=None, multi_case=True, - non_season=True, plot_type = "RegionalClimo") + non_season=True, category=region_category, plot_type = "RegionalClimo") return @@ -429,8 +444,7 @@ def getRegion_uxarray(gridDS, varDS, varName, area, landfrac, BOX_W, BOX_E, BOX_ area_subset = area.isel(n_face=node_indices) landfrac_subset = landfrac.isel(n_face=node_indices) wgt_subset = area_subset * landfrac_subset / (area_subset* landfrac_subset).sum() - # area_subset = varDS['area'].isel(n_face=node_indices) - # lf_subset = varDS['landfrac'].isel(n_face=node_indices) + return domain_subset,wgt_subset def getRegion_xarray(varDS, varName, @@ -474,19 +488,12 @@ def getRegion_xarray(varDS, varName, varDS = varDS[varName] # Subset the dataarray using the specified box - if BOX_W>BOX_E: - iLons = np.where((varDS.lon.values>=BOX_W) | (varDS.lon.values<=BOX_E) )[0] - domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N)).isel(lon=iLons) - - weight_subset = weight.sel(lat=slice(BOX_S, BOX_N)).isel(lon=iLons) - else: - domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N), - lon=slice(BOX_W, BOX_E)) - weight_subset = weight.sel(lat=slice(BOX_S, BOX_N), - lon=slice(BOX_W, BOX_E)) + domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N), + lon=slice(BOX_W, BOX_E)) + weight_subset = weight.sel(lat=slice(BOX_S, BOX_N), + lon=slice(BOX_W, BOX_E)) wgt_subset = weight_subset / weight_subset.sum() - return domain_subset,wgt_subset def get_region_boundaries(regions, region_name): @@ -497,5 +504,6 @@ def get_region_boundaries(regions, region_name): region = regions[region_name] south, north = region['lat_bounds'] west, east = region['lon_bounds'] + region_category = region['region_category'] if 'region_category' in region else None - return west, east, south, north \ No newline at end of file + return west, east, south, north, region_category From 8323fe15488df0c5535aa3696da71a724632dd0a Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 16 Oct 2025 16:11:13 -0600 Subject: [PATCH 110/126] fix regional for structured grids --- scripts/plotting/regional_climatology.py | 59 ++++++++++-------------- 1 file changed, 25 insertions(+), 34 deletions(-) diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index f32629fe4..1023270be 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -255,7 +255,6 @@ def regional_climatology(adfobj): if type(base_data[field]) is type(None): continue else: - # TODO: handle regular gridded case if unstruct_plotting == True: # uxarray output is time*nface, sum over nface base_var,wgt_sub = getRegion_uxarray(uxgrid, base_data, field, area_b, landfrac_b, @@ -299,7 +298,6 @@ def regional_climatology(adfobj): transform = ccrs.PlateCarree() projection = ccrs.PlateCarree() base_var_mask = base_var.isel(time=0) - base_var_mask[np.isfinite(base_var_mask)]=1 if unstruct_plotting == True: base_var_mask[np.isfinite(base_var_mask)]=1 @@ -315,10 +313,15 @@ def regional_climatology(adfobj): elif unstruct_plotting == False: base_var_mask = base_var_mask.copy() base_var_mask.values[np.isfinite(base_var_mask.values)] = 1 - + print(base_var_mask) map_ax = fig.add_subplot(4, 4, 1, projection=ccrs.PlateCarree()) map_ax.coastlines() + #print('debug mask.lon') + #print(base_var_mask.lon) + #print('debug mask.lat') + #print(base_var_mask.lat) + # Plot using pcolormesh for structured grids im = map_ax.pcolormesh(base_var_mask.lon, base_var_mask.lat, base_var_mask.values, @@ -326,15 +329,6 @@ def regional_climatology(adfobj): cmap='rainbow_r', shading='auto') - collection = base_var_mask.to_polycollection() - collection.set_transform(transform) - collection.set_cmap('rainbow_r') - collection.set_antialiased(False) - map_ax = fig.add_subplot(4, 4, 1, projection=ccrs.PlateCarree()) - - map_ax.coastlines() - map_ax.add_collection(collection) - map_ax.set_global() # Add map extent selection if region_list[iReg]=='N Hemisphere Land': map_ax.set_extent([-180, 179, -3, 90],crs=ccrs.PlateCarree()) @@ -367,17 +361,9 @@ def regional_climatology(adfobj): ## Plot the climatology: if type(base_data[field]) is type(None): - # print('Missing file for ', field) + print('Missing file for ', field) continue else: - # TODO handle unit conversions correctly, working for structured, but not unstructured yet - # using ldf_v0.0 and uxarray 2025.03.0 this seems to be working as expected, - # TODO check results with updated uxarray 2025.06? - #if unstruct_plotting == True: - # if (field == 'GPP') or (field == 'NEE') or (field == 'NBP'): - # case_var_wgtd = case_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day - # base_var_wgtd = base_var_wgtd * 3600 * 24 #convert gC/m2/s to gC/m2/day - axs[plt_counter].plot(np.arange(12)+1, case_var_wgtd, label=case_nickname, linewidth=2) axs[plt_counter].plot(np.arange(12)+1, base_var_wgtd, @@ -396,14 +382,9 @@ def regional_climatology(adfobj): fig.subplots_adjust(hspace=0.3, wspace=0.3) # Save out figure - # fileFriendlyRegionName = plot_loc = Path(plot_locations[0]) / f'{region_list[iReg]}_plot_RegionalClimo_Mean.{plot_type}' - #Set path for variance figures: - # plot_loc = Path(plot_locations[0]) / f'RegionalClimo_{region_list[iReg]}.{plot_type}' - # print(plot_loc) - # plot_name = plot_loc+'RegionalClimo_'+region_names[iReg]+'.png' -# Check redo_plot. If set to True: remove old plots, if they already exist: + # Check redo_plot. If set to True: remove old plots, if they already exist: if (not redo_plot) and plot_loc.is_file(): #Add already-existing plot to website (if enabled): adfobj.debug_log(f"'{plot_loc}' exists and clobber is false.") @@ -462,8 +443,6 @@ def getRegion_xarray(varDS, varName, if varName not in varDS: varName = obs_var_name - #if varName == 'ELAI': varName = 'TLAI' - #if varName == 'ET': varName = 'LHF' # TODO is there a less brittle way to do this? if (area is not None) and (landfrac is not None): @@ -488,12 +467,24 @@ def getRegion_xarray(varDS, varName, varDS = varDS[varName] # Subset the dataarray using the specified box - domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N), - lon=slice(BOX_W, BOX_E)) - weight_subset = weight.sel(lat=slice(BOX_S, BOX_N), - lon=slice(BOX_W, BOX_E)) + if BOX_W < BOX_E: + domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N), + lon=slice(BOX_W, BOX_E)) + weight_subset = weight.sel(lat=slice(BOX_S, BOX_N), + lon=slice(BOX_W, BOX_E)) + + else: + # Use boolean indexing to select the region + # The parentheses are important due to operator precedence + west_of_0 = varDS.lon >= BOX_W + east_of_0 = varDS.lon <= BOX_E + domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N), + lon=(west_of_0 | east_of_0)) + weight_subset = weight.sel(lat=slice(BOX_S, BOX_N), + lon=(west_of_0 | east_of_0)) + wgt_subset = weight_subset / weight_subset.sum() - + weight_subset = weight.sel return domain_subset,wgt_subset def get_region_boundaries(regions, region_name): From 7d9c0759d4ecffecd3cb4a35d8f193909e62e803 Mon Sep 17 00:00:00 2001 From: wwieder Date: Mon, 20 Oct 2025 11:49:32 -0600 Subject: [PATCH 111/126] remove debug print statement --- scripts/plotting/aod_latlon.py | 495 ----------------------- scripts/plotting/regional_climatology.py | 1 - 2 files changed, 496 deletions(-) delete mode 100644 scripts/plotting/aod_latlon.py diff --git a/scripts/plotting/aod_latlon.py b/scripts/plotting/aod_latlon.py deleted file mode 100644 index 462242037..000000000 --- a/scripts/plotting/aod_latlon.py +++ /dev/null @@ -1,495 +0,0 @@ -"""Module for AOD-specific plotting functionality""" - -from pathlib import Path -import numpy as np -import xarray as xr -import xesmf as xe - - -import matplotlib as mpl -import matplotlib.pyplot as plt -from matplotlib import gridspec -import cartopy.crs as ccrs -from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter -from cartopy.util import add_cyclic_point - -import plotting_functions as pf - -from dataclasses import dataclass, field - -@dataclass -class AODPlotConfig: - """Configuration for AOD plots.""" - seasons: list = ('DJF', 'MAM', 'JJA', 'SON') - season_names: dict = field(default_factory=lambda: { - 'DJF': 'Dec-Jan-Feb', - 'MAM': 'Mar-Apr-May', - 'JJA': 'Jun-Jul-Aug', - 'SON': 'Sep-Oct-Nov' - }) - obs_sources: list = ('TERRA MODIS', 'MERRA2') - var_name: str = 'AODVISdn' - - -def aod_latlon(adfobj): - """Generate AOD comparison plots.""" - config = AODPlotConfig() - - # Load observations - obs_data = load_observations(adfobj) - if not obs_data: - return - - # Process model data - model_data = process_model_cases(adfobj, config.var_name, obs_data) - if not model_data: - return - - # Generate plots - for obs_source, obs_dataset in obs_data.items(): - for season in config.seasons: - create_aod_panel(adfobj, model_data, obs_dataset, - season, obs_source) - - -def load_observations(adfobj): - """Load MERRA2 and MODIS observation datasets. - - Parameters - ---------- - adfobj : AdfDiag - The diagnostics object containing configuration - - Returns - ------- - dict - Dictionary of observation datasets keyed by source name - """ - obs_dir = adfobj.get_basic_info("obs_data_loc") - obs_files = { - 'TERRA MODIS': 'MOD08_M3_192x288_AOD_2001-2020_climo.nc', - 'MERRA2': 'MERRA2_192x288_AOD_2001-2020_climo.nc' - } - - obs_data = {} - for source, filename in obs_files.items(): - ds = load_obs_data(obs_dir, filename) - if ds is None: - print(f"\t WARNING: AOD Panel plots not made, missing {source} file") - return None - - # Extract correct variable based on source - if source == 'MERRA2': - ds = ds['TOTEXTTAU'] - else: # MODIS - ds = ds['AOD_550_Dark_Target_Deep_Blue_Combined_Mean_Mean'] - - # Calculate seasonal means - ds_seasonal = monthly_to_seasonal(ds, obs=True) - obs_data[source] = ds_seasonal - - return obs_data - - -def load_obs_data(obs_dir, file_name): - """Load and prepare observational dataset.""" - file_path = Path(obs_dir) / file_name - if not file_path.is_file(): - return None - - ds = xr.open_dataset(file_path) - # Round coordinates for consistency - ds['lon'] = ds['lon'].round(5) - ds['lat'] = ds['lat'].round(5) - return ds - - -def process_model_cases(adfobj, var, obs_data): - """Process model cases and regrid if necessary. - - Parameters - ---------- - adfobj : AdfDiag - The diagnostics object containing configuration - var : str - Variable name to process - obs_data : dict - Dictionary of observation datasets with their grids - - Returns - ------- - list - List of processed model datasets, one per case - """ - # Get case information - cases = adfobj.get_cam_info('cam_case_name', required=True) - if not adfobj.compare_obs: - cases = cases + [adfobj.data.ref_case_label] # ref case added to cases - - # Get reference grid from first observation dataset - ref_obs = next(iter(obs_data.values())) - - # Process each case - processed_data = [] - for case_name in cases: - # Load and process model data - case_data = process_model_data(adfobj, case_name, var, ref_obs) - if case_data is not None: - processed_data.append((case_data, case_name)) - - return processed_data if processed_data else None - - -def process_model_data(adfobj, case_name, var, obs_shape): - """Process model data and check grid compatibility.""" - if case_name == adfobj.data.ref_case_label: - ds_case = adfobj.data.load_reference_climo_da(case_name, var) - else: - ds_case = adfobj.data.load_climo_da(case_name, var) - if ds_case is None: - print(f"\t WARNING: No climo file for {case_name} variable {var}") - return None - - ds_case['lon'] = ds_case['lon'].round(5) - ds_case['lat'] = ds_case['lat'].round(5) - - # Check grid compatibility - needs_regrid = check_grid_compatibility(ds_case, obs_shape) - if needs_regrid: - ds_case = regrid_to_obs(ds_case, obs_shape) - - return monthly_to_seasonal(ds_case) - - -def check_grid_compatibility(model_arr, obs_arr): - """Check if model grid matches observation grid. - - Parameters - ---------- - model_arr : xarray.DataArray - Model data array with lat/lon coordinates - obs_arr : xarray.DataArray - Observation data array with lat/lon coordinates - - Returns - ------- - bool - True if grids don't match and regridding is needed - """ - test_lons = model_arr.lon - test_lats = model_arr.lat - obs_lons = obs_arr.lon - obs_lats = obs_arr.lat - - # Check if shapes match first - if obs_lons.shape != test_lons.shape: - return True - - # Check exact coordinate matches - try: - xr.testing.assert_equal(test_lons, obs_lons) - xr.testing.assert_equal(test_lats, obs_lats) - return False - except AssertionError: - return True - -def create_aod_panel(adfobj, data_sets, obs_dataset, season, obs_name): - """Create AOD panel plot with differences and percent differences.""" - plot_data = [] - plot_titles = [] - plot_params = [] - case_names = [] - types = [] - - # Get plot parameters from configuration - plot_config = get_plot_params(adfobj) - - for case_data, case_name in data_sets: - # Calculate differences - diff = calculate_differences(case_data, obs_dataset, season) - plot_data.append(diff) - plot_titles.append(make_plot_config(diff, case_name, obs_name, season, "Diff")) - plot_params.append(plot_config['default']) - case_names.append(case_name) - types.append("Diff") - - # Calculate percent differences - pdiff = calculate_percent_diff(case_data, obs_dataset, season) - plot_data.append(pdiff) - plot_titles.append(make_plot_config(pdiff, case_name, obs_name, season, "Percent Diff")) - plot_params.append(plot_config['relerr']) - case_names.append(case_name) - types.append("Percent Diff") - - return aod_panel_latlon(adfobj, plot_titles, plot_params, plot_data, - season, obs_name, case_names, len(data_sets), - types, symmetric=True) - - -def validate_obs_data(merra_data, modis_data): - """Validate observation datasets.""" - if merra_data is None or modis_data is None: - raise ValueError("Missing observation data") - - if not np.array_equal(merra_data.lat, modis_data.lat): - raise ValueError("Observation grids do not match") - - -def regrid_to_obs(model_arr, obs_arr): - """Regrid model data to match observation grid using bilinear interpolation. - - Parameters - ---------- - model_arr : xarray.DataArray - Model data array to be regridded - obs_arr : xarray.DataArray - Observation data array with target grid - - Returns - ------- - xarray.DataArray - Regridded model data, or None if grids already match - """ - # Create target grid specification - ds_out = xr.Dataset({ - "lat": (["lat"], obs_arr.lat.values, {"units": "degrees_north"}), - "lon": (["lon"], obs_arr.lon.values, {"units": "degrees_east"}) - }) - - # Perform regridding - regridder = xe.Regridder(model_arr, ds_out, "bilinear", periodic=True) - model_regrid = regridder(model_arr, keep_attrs=True) - - return model_regrid - -def calculate_differences(case_data, obs_data, season): - """Calculate differences between case and observation data for a given season. - - Parameters - ---------- - case_data : xarray.DataArray - Model case data - obs_data : xarray.DataArray - Observation data - season : str - Season to calculate difference for - - Returns - ------- - xarray.DataArray - Difference between case and observation data - """ - return case_data.sel(season=season) - obs_data.sel(season=season) - - -def calculate_percent_diff(case_data, obs_data, season): - """Calculate percent difference between case and observation data. - - Parameters - ---------- - case_data : xarray.DataArray - Model case data - obs_data : xarray.DataArray - Observation data - season : str - Season to calculate difference for - - Returns - ------- - xarray.DataArray - Percent difference, clipped to [-100, 100] - """ - diff = calculate_differences(case_data, obs_data, season) - pdiff = 100 * diff / obs_data.sel(season=season) - return np.clip(pdiff, -100, 100) - - -def make_plot_config(data, case_name, obs_name, season, plot_type): - """Create plot configuration dictionary. - - Parameters - ---------- - data : xarray.DataArray - Data to plot - case_name : str - Name of case being plotted - obs_name : str - Name of observation dataset - season : str - Season being plotted - plot_type : str - Type of plot ('Diff' or 'Percent Diff') - - Returns - ------- - dict - Plot configuration including data and metadata - """ - config = AODPlotConfig() - return { - 'data': data, - 'title': f'{case_name} - {obs_name}\nAOD 550 nm - {config.season_names[season]}', - 'case_name': case_name, - 'plot_type': plot_type, - 'season': season - } - - -def get_plot_params(adfobj): - """Get AOD plot parameters from ADF configuration.""" - res = adfobj.variable_defaults - res_aod_diags = res.get("aod_diags", {}) - return { - 'default': res_aod_diags.get("plot_params", {}), - 'relerr': res_aod_diags.get("plot_params_relerr", {}) - } - -### refactored aod_panel_latlon: -def aod_panel_latlon(adfobj, plot_titles, plot_params, data, season, obs_name, case_names, case_num, types, symmetric=False): - """Create AOD panel plot with model vs observation differences. - - Parameters - ---------- - adfobj : AdfDiag - The diagnostics object containing configuration - plot_titles : list - List of titles for each panel - plot_params : list - List of plotting parameters for each panel - data : list - List of xarray DataArrays to plot - season : str - Current season being plotted - obs_name : str - Name of observation dataset - case_names : list - List of case names - case_num : int - Number of cases - types : list - List of plot types ('Diff' or 'Percent Diff') - symmetric : bool, optional - Whether to use symmetric colormap, by default False - """ - # Get plot configuration - file_type = adfobj.read_config_var("diag_basic_info").get('plot_type', 'png') - plot_dir = adfobj.plot_location[0] - plotfile = Path(plot_dir) / f'AOD_diff_{obs_name.replace(" ","_")}_{season}_LatLon_Mean.{file_type}' - - # Check if plot should be regenerated - if plotfile.is_file() and not adfobj.get_basic_info('redo_plot'): - adfobj.add_website_data(plotfile, f'AOD_diff_{obs_name.replace(" ","_")}', None, - season=season, multi_case=True, plot_type="LatLon", - category="4-Panel AOD Diags") - return - - # Create figure and axes - fig = plt.figure(figsize=(7*case_num, 10)) - gs = mpl.gridspec.GridSpec(2*case_num, int(3*case_num), wspace=0.5, hspace=0.0) - gs.tight_layout(fig) - - axs = [] - for i in range(case_num): - start = i * 3 - end = (i + 1) * 3 - axs.append(plt.subplot(gs[0:case_num, start:end], projection=ccrs.PlateCarree())) - axs.append(plt.subplot(gs[case_num:, start:end], projection=ccrs.PlateCarree())) - - # Generate each panel - for i, dataField in enumerate(data): - # Create individual plot - ind_fig, ind_ax = plt.subplots(1, 1, figsize=((7*case_num)/2, 10/2), - subplot_kw={'projection': ccrs.PlateCarree()}) - - # Prepare data - # field_values = field.values[:,:] - # lon_values = field.lon.values - lat_values = dataField.lat - field_values, lon_values = add_cyclic_point(dataField, coord=dataField.lon) - lon_mesh, lat_mesh = np.meshgrid(lon_values, lat_values) - - field_mean = np.nanmean(field_values) ## THIS IS PROBABLY THE INCORRECT AVERAGE TO USE - # field_mean = pf.spatial_average(dataField) - - # Set plot parameters - plot_param = plot_params[i] - levels = np.linspace(plot_param['range_min'], plot_param['range_max'], - plot_param['nlevel'], endpoint=True) - if 'augment_levels' in plot_param: - levels = sorted(np.append(levels, np.array(plot_param['augment_levels']))) - - plot_config = plot_titles[i] - title = f"{plot_config['title']} Mean {field_mean:.2g}" - - # Create plots - cmap_option = (plot_param.get('colormap', plt.cm.bwr) if symmetric - else plot_param.get('colormap', plt.cm.turbo)) - extend_option = 'both' if symmetric else 'max' - - for ax, is_panel in [(axs[i], True), (ind_ax, False)]: - img = ax.contourf(lon_mesh, lat_mesh, field_values, - levels, cmap=cmap_option, extend=extend_option, - transform=ccrs.PlateCarree(), - transform_first=True) - ax.set_facecolor('gray') - ax.coastlines() - ax.set_title(title, fontsize=10) - - fig_to_use = ind_fig if not is_panel else fig - cbar = fig_to_use.colorbar(img, ax=ax, orientation='horizontal', pad=0.05) - if 'ticks' in plot_param: - cbar.set_ticks(plot_param['ticks']) - if 'tick_labels' in plot_param: - cbar.ax.set_xticklabels(plot_param['tick_labels']) - cbar.ax.tick_params(labelsize=6) - - # Save individual plot - pbase = f'AOD_{case_names[i]}_vs_{obs_name.replace(" ","_")}_{types[i].replace(" ","_")}' - ind_plotfile = Path(plot_dir) / f'{pbase}_{season}_LatLon_Mean.{file_type}' - ind_fig.savefig(ind_plotfile, bbox_inches='tight', dpi=300) - plt.close(ind_fig) - - # Save panel plot - fig.savefig(plotfile, bbox_inches='tight', dpi=300) - adfobj.add_website_data(plotfile, f'AOD_diff_{obs_name.replace(" ","_")}', None, - season=season, multi_case=True, plot_type="LatLon", - category="4-Panel AOD Diags") - plt.close(fig) - - -def monthly_to_seasonal(ds, obs=False): - """Convert monthly data to seasonal means. - - Parameters - ---------- - ds : xarray.Dataset or xarray.DataArray - Input data with monthly time dimension - obs : bool, optional - Whether input is observation data, by default False - - Returns - ------- - xarray.DataArray - Data array with new season dimension - """ - seasons = ['DJF', 'MAM', 'JJA', 'SON'] - dataarrays = [] - - if obs and isinstance(ds, xr.Dataset): - # Handle observation dataset with multiple variables - for varname in ds.data_vars: - if '_n' not in varname: # Skip count variables - var_data = ds[varname] - for s in seasons: - dataarrays.append(pf.seasonal_mean(var_data, season=s, is_climo=True)) - else: - # Handle single DataArray - for s in seasons: - dataarrays.append(pf.seasonal_mean(ds, season=s, is_climo=True)) - - # Combine seasonal means - ds_seasonal = xr.concat(dataarrays, dim='season') - ds_seasonal['season'] = seasons - ds_seasonal = ds_seasonal.transpose('lat', 'lon', 'season') - - return ds_seasonal \ No newline at end of file diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 1023270be..a56897de1 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -313,7 +313,6 @@ def regional_climatology(adfobj): elif unstruct_plotting == False: base_var_mask = base_var_mask.copy() base_var_mask.values[np.isfinite(base_var_mask.values)] = 1 - print(base_var_mask) map_ax = fig.add_subplot(4, 4, 1, projection=ccrs.PlateCarree()) map_ax.coastlines() From ab6ade9fb74f81681f0f9265d5b295fc68977ee1 Mon Sep 17 00:00:00 2001 From: wwieder Date: Tue, 28 Oct 2025 10:33:30 -0600 Subject: [PATCH 112/126] add burned area to regional climos --- scripts/plotting/regional_climatology.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index a56897de1..3b58260a5 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -78,7 +78,7 @@ def regional_climatology(adfobj): regional_climo_var_list = ['TSA','PREC','ELAI', 'FSDS','FLDS','SNOWDP','ASA', 'FSH','QRUNOFF_TO_COUPLER','ET','FCTR', - 'GPP','TWS','FCEV','FGEV', + 'GPP','TWS','FCEV','FAREA_BURNED', ] ## Open observations YML here? From 91cd20c0a525ac1aaa4bb3cd59ed3d826bb9f379 Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 29 Oct 2025 13:37:07 -0600 Subject: [PATCH 113/126] correct yaml file path for cupid --- scripts/plotting/regional_climatology.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 3b58260a5..052cd8e99 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -121,6 +121,11 @@ def regional_climatology(adfobj): _variable_defaults = adfobj.__variable_defaults + ## Read regions from yml file: + ymlFilename = _adf_lib_dir/'regions_lnd.yaml' + with open(ymlFilename, 'r') as file: + regions = yaml.safe_load(file) + #----------------------------------------- #Extract the "obs_data_loc" default observational data location: obs_data_loc = adfobj.get_basic_info("obs_data_loc") From d9b960ba0aa6dcd11b44bc6319abf1fb3b7adc65 Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 29 Oct 2025 14:29:03 -0600 Subject: [PATCH 114/126] adding path to regional.yaml to config file --- config_clm_unstructured_plots.yaml | 40 ++++++++++++++---------- scripts/plotting/regional_climatology.py | 15 ++++----- 2 files changed, 32 insertions(+), 23 deletions(-) diff --git a/config_clm_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml index e8de42aa1..0858d9034 100644 --- a/config_clm_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -99,6 +99,9 @@ diag_basic_info: #Uncomment and change path for custom variable defaults file defaults_file: lib/ldf_variable_defaults.yaml + # location of land regions YAML file (only used in regional_climatology plots) + regions_file: lib/regions_lnd.yaml + #Longitude line on which to center all lat/lon maps. #If this config option is missing then the central #longitude will default to 180 degrees E. @@ -123,7 +126,7 @@ diag_cam_climo: # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] # Only affects timeseries as everything else uses the created timeseries # Default: - hist_str: clm2.h0 + hist_str: clm2.h0a #Calculate climatologies? #If false, the climatology files will not be created: @@ -137,16 +140,16 @@ diag_cam_climo: cam_overwrite_climo: false #Name of CAM case (or CAM run name): - cam_case_name: b.e30_alpha07b_dev.B1850C_LTso.ne30_t232_wgx3.213 + cam_case_name: ctsm5.4.CMIP7_ciso_ctsm5.3.075_ne30_123_HIST_popDens #Case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '213' + case_nickname: '123_popDens' #Location of CAM history (h0) files: - cam_hist_loc: /glade/derecho/scratch/hannay/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ + cam_hist_loc: /glade/derecho/scratch/wwieder/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ # If unstructured_plotting, a mesh file is required! mesh_file: /glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc @@ -154,12 +157,12 @@ diag_cam_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 01 - climo_start_year: 68 + start_year: 1850 + climo_start_year: 2004 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 88 + end_year: 2023 #Do time series files exist? #If True, then diagnostics assumes that model files are already time series. @@ -188,7 +191,7 @@ diag_cam_baseline_climo: # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] # Only affects timeseries as everything else uses the created timeseries # Default: - hist_str: clm2.h0 + hist_str: clm2.h0a #Calculate cam baseline climatologies? #If false, the climatology files will not be created: @@ -199,17 +202,17 @@ diag_cam_baseline_climo: cam_overwrite_climo: false #Name of CAM baseline case: - cam_case_name: b.e30_alpha07b_dev.B1850C_LTso.ne30_t232_wgx3.198 + cam_case_name: ctsm5.4_5.3.068_PPEcal115_116_HIST #Baseline case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '198' + case_nickname: '116' #Location of CAM baseline history (h0) files: #Example test files - cam_hist_loc: /glade/derecho/scratch/gmarques/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist/ + cam_hist_loc: /glade/derecho/scratch/wwieder/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist/ # If unstructured_plotting, a mesh file is required! mesh_file: /glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc @@ -220,13 +223,13 @@ diag_cam_baseline_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 01 - climo_start_year: 128 + start_year: 1850 + climo_start_year: 2004 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 148 + end_year: 2023 #Do time series files need to be generated? #If True, then diagnostics assumes that model files are already time series. @@ -265,7 +268,7 @@ time_averaging_scripts: #Name of regridding scripts being used. #These scripts must be located in "scripts/regridding": regridding_scripts: - # - regrid_and_vert_interp + #- regrid_and_vert_interp #List of analysis scripts being used. #These scripts must be located in "scripts/analysis": @@ -284,6 +287,7 @@ plotting_scripts: #Shorter list here, for efficiency of testing diag_var_list: - TSA + - TV - PREC - ELAI - FSDS @@ -298,7 +302,6 @@ diag_var_list: - FCEV - QRUNOFF_TO_COUPLER - SNOWDP - - FPSN - TOTVEGC - GPP - NEE @@ -312,6 +315,11 @@ diag_var_list: - FAREA_BURNED - TWS - GRAINC_TO_FOOD + #- C13_GPP_pm + # - C13_TOTVEGC_pm + #- C14_GPP_pm + #- C14_TOTVEGC_pm + region_list: - Global - N Hemisphere Land diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 052cd8e99..8bff628a6 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -109,6 +109,7 @@ def regional_climatology(adfobj): #Determine whether to use adf defaults or custom: _defaults_file = adfobj.get_basic_info('defaults_file') + # Note this won't work if no defaults_file is given if _defaults_file is None: _defaults_file = _adf_lib_dir/'adf_variable_defaults.yaml' else: @@ -122,7 +123,7 @@ def regional_climatology(adfobj): _variable_defaults = adfobj.__variable_defaults ## Read regions from yml file: - ymlFilename = _adf_lib_dir/'regions_lnd.yaml' + ymlFilename = adfobj.get_basic_info("regions_file") with open(ymlFilename, 'r') as file: regions = yaml.safe_load(file) @@ -344,21 +345,21 @@ def regional_climatology(adfobj): map_ax.set_extent([-180, 179, 45, 90],crs=ccrs.PlateCarree()) else: if ((box_south >= 30) & (box_east<=-5) ): - map_ax.set_extent([-180, -5, 30, 90],crs=ccrs.PlateCarree()) + map_ax.set_extent([-180, 0, 30, 90],crs=ccrs.PlateCarree()) elif ((box_south >= 30) & (box_east>=-5) ): - map_ax.set_extent([-5, 179, 30, 90],crs=ccrs.PlateCarree()) + map_ax.set_extent([-10, 179, 30, 90],crs=ccrs.PlateCarree()) elif ((box_south <= 30) & (box_south >= -30) & (box_east<=-5) ): - map_ax.set_extent([-180, -5, -30, 30],crs=ccrs.PlateCarree()) + map_ax.set_extent([-180, 0, -30, 30],crs=ccrs.PlateCarree()) elif ((box_south <= 30) & (box_south >= -30) & (box_east>=-5) ): - map_ax.set_extent([-5, 179, -30, 30],crs=ccrs.PlateCarree()) + map_ax.set_extent([-10, 179, -30, 30],crs=ccrs.PlateCarree()) elif ((box_south <= -30) & (box_south >= -60) & (box_east>=-5) ): - map_ax.set_extent([-5, 179, -89, -30],crs=ccrs.PlateCarree()) + map_ax.set_extent([-10, 179, -89, -30],crs=ccrs.PlateCarree()) elif ((box_south <= -30) & (box_south >= -60) & (box_east<=-5) ): - map_ax.set_extent([-180, -5, -89, -30],crs=ccrs.PlateCarree()) + map_ax.set_extent([-180, 0, -89, -30],crs=ccrs.PlateCarree()) elif ((box_south <= -60)): map_ax.set_extent([-180, 179, -89, -60],crs=ccrs.PlateCarree()) # End if for plotting map extent From bb77ade3c759bd54848f14806ddbdc285e86274c Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 29 Oct 2025 14:42:52 -0600 Subject: [PATCH 115/126] corrected conflicts --- scripts/plotting/regional_climatology.py | 1 - 1 file changed, 1 deletion(-) diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 5c856816f..9a9462630 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -330,7 +330,6 @@ def regional_climatology(adfobj): cmap='rainbow_r', shading='auto') - map_ax.set_global() # Add map extent selection if region_list[iReg]=='N Hemisphere Land': map_ax.set_extent([-180, 179, -3, 90],crs=ccrs.PlateCarree()) From b9035e2e11fb10306447ccb99ea828400bff7ed7 Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 30 Oct 2025 09:58:02 -0600 Subject: [PATCH 116/126] removing old code --- scripts/plotting/regional_climatology.py | 7 ------- 1 file changed, 7 deletions(-) diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 9a9462630..e6ee3f9c4 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -81,13 +81,6 @@ def regional_climatology(adfobj): 'GPP','TWS','FCEV','FAREA_BURNED', ] - ## Open observations YML here? - - ## Read regions from yml file: - ymlFilename = 'lib/regions_lnd.yaml' - with open(ymlFilename, 'r') as file: - regions = yaml.safe_load(file) - # Extract variables: baseline_name = adfobj.get_baseline_info("cam_case_name", required=True) input_climo_baseline = Path(adfobj.get_baseline_info("cam_climo_loc", required=True)) From 8dc22d46ec7de3304695adba95764d234fe72942 Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 13 Nov 2025 14:20:28 -0700 Subject: [PATCH 117/126] minor fix to get land regridding to work --- scripts/regridding/regrid_se_to_fv.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/scripts/regridding/regrid_se_to_fv.py b/scripts/regridding/regrid_se_to_fv.py index 098188104..617726f62 100644 --- a/scripts/regridding/regrid_se_to_fv.py +++ b/scripts/regridding/regrid_se_to_fv.py @@ -60,13 +60,12 @@ def regrid_se_data_bilinear(regridder, data_to_regrid, comp_grid): ) return regridded -def regrid_se_data_conservative(regridder, data_to_regrid, comp_grid): +def regrid_se_data_conservative(regridder, data_to_regrid, comp_grid="lndgrid"): updated = data_to_regrid.copy().transpose(..., comp_grid).expand_dims("dummy", axis=-2) regridded = regridder(updated.rename({"dummy": "lat", comp_grid: "lon"}) ) return regridded - def regrid_atm_se_data_bilinear(regridder, data_to_regrid, comp_grid='ncol'): if isinstance(data_to_regrid, xr.Dataset): vars_with_ncol = [name for name in data_to_regrid.variables if comp_grid in data_to_regrid[name].dims] From f0cc2e6c77f63370ebd78ec3bbb7af02ceca9ae0 Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 13 Nov 2025 14:21:01 -0700 Subject: [PATCH 118/126] start regional TS capability --- scripts/plotting/regional_timeseries.py | 494 ++++++++++++++++++++++++ 1 file changed, 494 insertions(+) create mode 100644 scripts/plotting/regional_timeseries.py diff --git a/scripts/plotting/regional_timeseries.py b/scripts/plotting/regional_timeseries.py new file mode 100644 index 000000000..e6ee3f9c4 --- /dev/null +++ b/scripts/plotting/regional_timeseries.py @@ -0,0 +1,494 @@ +from pathlib import Path +import numpy as np +import yaml +import xarray as xr +import uxarray as ux +import matplotlib.pyplot as plt +import cartopy.crs as ccrs +import warnings # use to warn user about missing files. + +def my_formatwarning(msg, *args, **kwargs): + """custom warning""" + # ignore everything except the message + return str(msg) + "\n" + + +warnings.formatwarning = my_formatwarning + + +def regional_climatology(adfobj): + + """ + load climo file, subset for each region and each var + Make a combined plot, save it, add it to website. + + NOTES (from Meg): There are still a lot of to-do's with this script! + - convert region defintion netCDF file to a yml, read that in instead + - increase number of variables that have a climo plotted; i've just + added two, but left room for more in the subplots + - check that all varaibles have climo files; likely to break otherwise + - add option so that this works with a structured grid too # ...existing code... + if found: + #Check if observations dataset name is specified: + if "obs_name" in default_var_dict: + obs_name = default_var_dict["obs_name"] + else: + obs_name = obs_file_path.name + + if "obs_var_name" in default_var_dict: + obs_var_name = default_var_dict["obs_var_name"] + else: + obs_var_name = field + + # Use the resolved obs_file_path, not the original string + obs_data[field] = xr.open_mfdataset([str(obs_file_path)], combine="by_coords") + plot_obs[field] = True + # ...existing code... + - make sure that climo's are being plotted with the preferred units + - add in observations (need to regrid/area weight) + - need to figure out how to display the figures on the website + + """ + + #Notify user that script has started: + print("\n --- Generating regional climatology plots... ---") + + # Gather ADF configurations + # plot_loc = adfobj.get_basic_info('cam_diag_plot_loc') + # plot_type = adfobj.read_config_var("diag_basic_info").get("plot_type", "png") + plot_locations = adfobj.plot_location + plot_type = adfobj.get_basic_info('plot_type') + if not plot_type: + plot_type = 'png' + #res = adfobj.variable_defaults # will be dict of variable-specific plot preferences + # or an empty dictionary if use_defaults was not specified in YAML. + + # check if existing plots need to be redone + redo_plot = adfobj.get_basic_info('redo_plot') + print(f"\t NOTE: redo_plot is set to {redo_plot}") + + unstruct_plotting = adfobj.unstructured_plotting + print(f"\t unstruct_plotting", unstruct_plotting) + + case_nickname = adfobj.get_cam_info('case_nickname') + base_nickname = adfobj.get_baseline_info('case_nickname') + + region_list = adfobj.region_list + #TODO, make it easier for users decide on these? + regional_climo_var_list = ['TSA','PREC','ELAI', + 'FSDS','FLDS','SNOWDP','ASA', + 'FSH','QRUNOFF_TO_COUPLER','ET','FCTR', + 'GPP','TWS','FCEV','FAREA_BURNED', + ] + + # Extract variables: + baseline_name = adfobj.get_baseline_info("cam_case_name", required=True) + input_climo_baseline = Path(adfobj.get_baseline_info("cam_climo_loc", required=True)) + # TODO hard wired for single case name: + case_name = adfobj.get_cam_info("cam_case_name", required=True)[0] + input_climo_case = Path(adfobj.get_cam_info("cam_climo_loc", required=True)[0]) + + # Get grid file + mesh_file = adfobj.mesh_files["baseline_mesh_file"] + uxgrid = ux.open_grid(mesh_file) + + # Set keywords + kwargs = {} + kwargs["mesh_file"] = mesh_file + kwargs["unstructured_plotting"] = unstruct_plotting + + #Determine local directory: + _adf_lib_dir = adfobj.get_basic_info("obs_data_loc") + + #Determine whether to use adf defaults or custom: + _defaults_file = adfobj.get_basic_info('defaults_file') + # Note this won't work if no defaults_file is given + if _defaults_file is None: + _defaults_file = _adf_lib_dir/'adf_variable_defaults.yaml' + else: + print(f"\n\t Not using ADF default variables yaml file, instead using {_defaults_file}\n") + #End if + + #Open YAML file: + with open(_defaults_file, encoding='UTF-8') as dfil: + adfobj.__variable_defaults = yaml.load(dfil, Loader=yaml.SafeLoader) + + _variable_defaults = adfobj.__variable_defaults + + ## Read regions from yml file: + ymlFilename = adfobj.get_basic_info("regions_file") + with open(ymlFilename, 'r') as file: + regions = yaml.safe_load(file) + + #----------------------------------------- + #Extract the "obs_data_loc" default observational data location: + obs_data_loc = adfobj.get_basic_info("obs_data_loc") + + base_data = {} + case_data = {} + obs_data = {} + obs_name = {} + obs_var_name = {} + plot_obs = {} + + var_obs_dict = adfobj.var_obs_dict + + # First, load all variable data once (instead of inside nested loops) + for field in regional_climo_var_list: + # Load the global climatology for this variable + # TODO unit conversions are not handled consistently here + base_data[field] = adfobj.data.load_reference_climo_da(baseline_name, field, **kwargs) + case_data[field] = adfobj.data.load_climo_da(case_name, field, **kwargs) + + if type(base_data[field]) is type(None): + print('Missing file for ', field) + continue + else: + # get area and landfrac for base and case climo datasets + mdataset = adfobj.data.load_climo_dataset(case_name, field, **kwargs) + area_c = mdataset.area.isel(time=0) # drop time dimension to avoid confusion + landfrac_c = mdataset.landfrac.isel(time=0) + # Redundant, but we'll do this for consistency: + # TODO, won't handle loadling the basecase this way + #area_b = adfobj.data.load_reference_climo_da(baseline_name, 'area', **kwargs) + #landfrac_b = adfobj.data.load_reference_climo_da(baseline_name, 'landfrac', **kwargs) + + mdataset_base = adfobj.data.load_reference_climo_dataset(baseline_name, field, **kwargs) + area_b = mdataset_base.area.isel(time=0) + landfrac_b = mdataset_base.landfrac.isel(time=0) + + # calculate weights + # WW: 1) should actual weight calculation be done after subsetting to region? + # 2) Does this work as intended for different resolutions? + # wgt = area * landfrac # / (area * landfrac).sum() + + #----------------------------------------- + # Now, check if observations are to be plotted for this variable + plot_obs[field] = False + if field in _variable_defaults: + # Extract variable-obs dictionary + default_var_dict = _variable_defaults[field] + + #Check if an observations file is specified: + if "obs_file" in default_var_dict: + #Set found variable: + found = False + + #Extract path/filename: + obs_file_path = Path(default_var_dict["obs_file"]) + + #Check if file exists: + if not obs_file_path.is_file(): + #If not, then check if it is in "obs_data_loc" + if obs_data_loc: + obs_file_path = Path(obs_data_loc)/obs_file_path + + if obs_file_path.is_file(): + found = True + + else: + #File was found: + found = True + #End if + + #If found, then set observations dataset and variable names: + if found: + #Check if observations dataset name is specified: + if "obs_name" in default_var_dict: + obs_name[field] = default_var_dict["obs_name"] + else: + #If not, then just use obs file name: + obs_name[field] = obs_file_path.name + + #Check if observations variable name is specified: + if "obs_var_name" in default_var_dict: + #If so, then set obs_var_name variable: + obs_var_name[field] = default_var_dict["obs_var_name"] + else: + #Assume observation variable name is the same as model variable: + obs_var_name[field] = field + #End if + #Finally read in the obs! + obs_data[field] = xr.open_mfdataset([default_var_dict["obs_file"]], combine="by_coords") + plot_obs[field] = True + # Special handling for some variables:, NOT A GOOD HACK! + # TODO: improve this! + if (field == 'ASA') and ('BRDALB' in obs_data[field].variables): + obs_data[field]['BRDALB'] = obs_data[field]['BRDALB'].swap_dims({'lsmlat':'lat','lsmlon':'lon'}) + + else: + #If not found, then print to log and skip variable: + msg = f'''Unable to find obs file '{default_var_dict["obs_file"]}' ''' + msg += f"for variable '{field}'." + adfobj.debug_log(msg) + continue + # End if + + else: + #No observation file was specified, so print to log and skip variable: + adfobj.debug_log(f"No observations file was listed for variable '{field}'.") + continue + else: + #Variable not in defaults file, so print to log and skip variable: + msg = f"Variable '{field}' not found in variable defaults file: `{_defaults_file}`" + adfobj.debug_log(msg) + # End if + # End of observation loading + #----------------------------------------- + + #----------------------------------------- + # Loop over regions for selected variable + for iReg in range(len(region_list)): + print(f"\n\t - Plotting regional climatology for: {region_list[iReg]}") + # regionDS_thisRg = regionDS.isel(region=region_indexList[iReg]) + box_west, box_east, box_south, box_north, region_category = get_region_boundaries(regions, region_list[iReg]) + ## Set up figure + ## TODO: Make the plot size/number of subplots resopnsive to number of fields specified + fig,axs = plt.subplots(4,4, figsize=(18,12)) + axs = axs.ravel() + + plt_counter = 1 + for field in regional_climo_var_list: + mdataset = adfobj.data.load_climo_dataset(case_name, field, **kwargs) + + if type(base_data[field]) is type(None): + continue + else: + if unstruct_plotting == True: + # uxarray output is time*nface, sum over nface + base_var,wgt_sub = getRegion_uxarray(uxgrid, base_data, field, area_b, landfrac_b, + box_west, box_east, + box_south, box_north) + base_var_wgtd = np.sum(base_var * wgt_sub, axis=-1) # WW not needed?/ np.sum(wgt_sub) + + case_var,wgt_sub = getRegion_uxarray(uxgrid, case_data, field, area_c, landfrac_c, + box_west, box_east, + box_south, box_north) + case_var_wgtd = np.sum(case_var * wgt_sub, axis=-1) #/ np.sum(wgt_sub) + + else: # regular lat/lon grid + # xarray output is time*lat*lon, sum over lat/lon + base_var, wgt_sub = getRegion_xarray(base_data[field], field, + box_west, box_east, + box_south, box_north, + area_b, landfrac_b) + base_var_wgtd = np.sum(base_var * wgt_sub, axis=(1,2)) + + case_var, wgt_sub = getRegion_xarray(case_data[field], field, + box_west, box_east, + box_south, box_north, + area_c, landfrac_c) + case_var_wgtd = np.sum(case_var * wgt_sub, axis=(1,2)) + + # Read in observations, if available + if plot_obs[field] == True: + # obs output is time*lat*lon, sum over lat/lon + obs_var, wgt_sub = getRegion_xarray(obs_data[field], field, + box_west, box_east, + box_south, box_north, + obs_var_name=obs_var_name[field]) + obs_var_wgtd = np.sum(obs_var * wgt_sub, axis=(1,2)) #/ np.sum(wgt_sub) + + ## Plot the map: + if plt_counter==1: + ## Define region in first subplot + fig.delaxes(axs[0]) + + transform = ccrs.PlateCarree() + projection = ccrs.PlateCarree() + base_var_mask = base_var.isel(time=0) + + if unstruct_plotting == True: + base_var_mask[np.isfinite(base_var_mask)]=1 + collection = base_var_mask.to_polycollection() + + collection.set_transform(transform) + collection.set_cmap('rainbow_r') + collection.set_antialiased(False) + map_ax = fig.add_subplot(4, 4, 1, projection=ccrs.PlateCarree()) + + map_ax.coastlines() + map_ax.add_collection(collection) + elif unstruct_plotting == False: + base_var_mask = base_var_mask.copy() + base_var_mask.values[np.isfinite(base_var_mask.values)] = 1 + + map_ax = fig.add_subplot(4, 4, 1, projection=ccrs.PlateCarree()) + map_ax.coastlines() + + # Plot using pcolormesh for structured grids + im = map_ax.pcolormesh(base_var_mask.lon, base_var_mask.lat, + base_var_mask.values, + transform=transform, + cmap='rainbow_r', + shading='auto') + + # Add map extent selection + if region_list[iReg]=='N Hemisphere Land': + map_ax.set_extent([-180, 179, -3, 90],crs=ccrs.PlateCarree()) + elif region_list[iReg]=='Global': + map_ax.set_extent([-180, 179, -89, 90],crs=ccrs.PlateCarree()) + elif region_list[iReg]=='S Hemisphere Land': + map_ax.set_extent([-180, 179, -89, 3],crs=ccrs.PlateCarree()) + elif region_list[iReg]=='Polar': + map_ax.set_extent([-180, 179, 45, 90],crs=ccrs.PlateCarree()) + else: + if ((box_south >= 30) & (box_east<=-5) ): + map_ax.set_extent([-180, 0, 30, 90],crs=ccrs.PlateCarree()) + elif ((box_south >= 30) & (box_east>=-5) ): + map_ax.set_extent([-10, 179, 30, 90],crs=ccrs.PlateCarree()) + elif ((box_south <= 30) & (box_south >= -30) & + (box_east<=-5) ): + map_ax.set_extent([-180, 0, -30, 30],crs=ccrs.PlateCarree()) + elif ((box_south <= 30) & (box_south >= -30) & + (box_east>=-5) ): + map_ax.set_extent([-10, 179, -30, 30],crs=ccrs.PlateCarree()) + elif ((box_south <= -30) & (box_south >= -60) & + (box_east>=-5) ): + map_ax.set_extent([-10, 179, -89, -30],crs=ccrs.PlateCarree()) + elif ((box_south <= -30) & (box_south >= -60) & + (box_east<=-5) ): + map_ax.set_extent([-180, 0, -89, -30],crs=ccrs.PlateCarree()) + elif ((box_south <= -60)): + map_ax.set_extent([-180, 179, -89, -60],crs=ccrs.PlateCarree()) + # End if for plotting map extent + + ## Plot the climatology: + if type(base_data[field]) is type(None): + print('Missing file for ', field) + continue + else: + axs[plt_counter].plot(np.arange(12)+1, case_var_wgtd, + label=case_nickname, linewidth=2) + axs[plt_counter].plot(np.arange(12)+1, base_var_wgtd, + label=base_nickname, linewidth=2) + if plot_obs[field] == True: + axs[plt_counter].plot(np.arange(12)+1, obs_var_wgtd, + label=obs_name[field], color='black', linewidth=2) + axs[plt_counter].set_title(field) + axs[plt_counter].set_ylabel(base_data[field].units) + axs[plt_counter].set_xticks(np.arange(1, 13, 2)) + axs[plt_counter].legend() + + + plt_counter = plt_counter+1 + + fig.subplots_adjust(hspace=0.3, wspace=0.3) + + # Save out figure + plot_loc = Path(plot_locations[0]) / f'{region_list[iReg]}_plot_RegionalClimo_Mean.{plot_type}' + + # Check redo_plot. If set to True: remove old plots, if they already exist: + if (not redo_plot) and plot_loc.is_file(): + #Add already-existing plot to website (if enabled): + adfobj.debug_log(f"'{plot_loc}' exists and clobber is false.") + adfobj.add_website_data(plot_loc, region_list[iReg], None, season=None, multi_case=True, + category=region_category, non_season=True, plot_type = "RegionalClimo") + + #Continue to next iteration: + return + elif (redo_plot): + if plot_loc.is_file(): + plot_loc.unlink() + + fig.savefig(plot_loc, bbox_inches='tight', facecolor='white') + plt.close() + + #Add plot to website (if enabled): + adfobj.add_website_data(plot_loc, region_list[iReg], None, season=None, multi_case=True, + non_season=True, category=region_category, plot_type = "RegionalClimo") + + return + +print("\n --- Regional climatology plots generated successfully! ---") + +def getRegion_uxarray(gridDS, varDS, varName, area, landfrac, BOX_W, BOX_E, BOX_S, BOX_N): + # Method 2: Filter mesh nodes based on coordinates + node_lons = gridDS.face_lon + node_lats = gridDS.face_lat + + # Create a boolean mask for nodes within your domain + in_domain = ((node_lons >= BOX_W) & (node_lons <= BOX_E) & + (node_lats >= BOX_S) & (node_lats <= BOX_N)) + + # Get the indices of nodes within your domain + node_indices = np.where(in_domain)[0] + + # Subset the dataset using these node indices + domain_subset = varDS[varName].isel(n_face=node_indices) + area_subset = area.isel(n_face=node_indices) + landfrac_subset = landfrac.isel(n_face=node_indices) + wgt_subset = area_subset * landfrac_subset / (area_subset* landfrac_subset).sum() + + return domain_subset,wgt_subset + +def getRegion_xarray(varDS, varName, + BOX_W, BOX_E, BOX_S, BOX_N, + area=None, landfrac=None, + obs_var_name=None): + # Assumes regular lat/lon grid in xarray Dataset + # Assumes varDS has 'lon' and 'lat' coordinates w/ lon in [0,360] + # Convert BOX_W and BOX_E to [0,360] if necessary + # Also assumes global weights have already been calculated & masked appropriately + if (BOX_W == -180) & (BOX_E == 180): + BOX_W, BOX_E = 0, 360 # Special case for global domain + if BOX_W < 0: BOX_W = BOX_W + 360 + if BOX_E < 0: BOX_E = BOX_E + 360 + + if varName not in varDS: + varName = obs_var_name + + # TODO is there a less brittle way to do this? + if (area is not None) and (landfrac is not None): + weight = area * landfrac + elif ('weight' in varDS) and ('datamask' in varDS): + weight = varDS['weight'] * varDS['datamask'] + elif ('weight' in varDS) and ('LANDFRAC' in varDS): + #used for MODIS albedo product + weight = varDS['weight'] * varDS['LANDFRAC'] + elif 'area' in varDS and 'landfrac' in varDS: + weight = varDS['area'] * varDS['landfrac'] + elif 'area' in varDS and 'landmask' in varDS: + weight = varDS['area'] * varDS['landmask'] + # Fluxnet data also has a datamask + if 'datamask' in varDS: + weight = weight * varDS['datamask'] + else: + raise ValueError("No valid weight, area, or landmask found in {varName} dataset.") + + # check we have a data array for the variable + if isinstance(varDS, xr.Dataset): + varDS = varDS[varName] + + # Subset the dataarray using the specified box + if BOX_W < BOX_E: + domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N), + lon=slice(BOX_W, BOX_E)) + weight_subset = weight.sel(lat=slice(BOX_S, BOX_N), + lon=slice(BOX_W, BOX_E)) + + else: + # Use boolean indexing to select the region + # The parentheses are important due to operator precedence + west_of_0 = varDS.lon >= BOX_W + east_of_0 = varDS.lon <= BOX_E + domain_subset = varDS.sel(lat=slice(BOX_S, BOX_N), + lon=(west_of_0 | east_of_0)) + weight_subset = weight.sel(lat=slice(BOX_S, BOX_N), + lon=(west_of_0 | east_of_0)) + + wgt_subset = weight_subset / weight_subset.sum() + weight_subset = weight.sel + return domain_subset,wgt_subset + +def get_region_boundaries(regions, region_name): + """Get the boundaries of a specific region.""" + if region_name not in regions: + raise ValueError(f"Region '{region_name}' not found in regions dictionary") + + region = regions[region_name] + south, north = region['lat_bounds'] + west, east = region['lon_bounds'] + region_category = region['region_category'] if 'region_category' in region else None + + return west, east, south, north, region_category From 57022a309e49a9df035ebd3a3601141e1ce5606f Mon Sep 17 00:00:00 2001 From: wwieder Date: Thu, 13 Nov 2025 15:52:48 -0700 Subject: [PATCH 119/126] my last adf_dataset commit --- lib/adf_dataset.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/lib/adf_dataset.py b/lib/adf_dataset.py index ba1bacf50..bba19ee21 100644 --- a/lib/adf_dataset.py +++ b/lib/adf_dataset.py @@ -118,7 +118,7 @@ def get_ref_timeseries_file(self, field): return ts_files - def load_timeseries_dataset(self, fils): + def load_timeseries_dataset(self, fils, **kwargs): """Return DataSet from time series file(s) and assign time to midpoint of interval""" if (len(fils) == 0): warnings.warn("\t WARNING: Input file list is empty.") @@ -146,7 +146,7 @@ def load_timeseries_dataset(self, fils): warnings.warn("\t INFO: Timeseries file does not have time bounds info.") return xr.decode_cf(ds) - def load_timeseries_da(self, case, variablename): + def load_timeseries_da(self, case, variablename, **kwargs): """Return DataArray from time series file(s). Uses defaults file to convert units. """ @@ -155,9 +155,9 @@ def load_timeseries_da(self, case, variablename): if not fils: warnings.warn(f"\t WARNING: Did not find case time series file(s), variable: {variablename}") return None - return self.load_da(fils, variablename, add_offset=add_offset, scale_factor=scale_factor) + return self.load_da(fils, variablename, add_offset=add_offset, scale_factor=scale_factor,**kwargs) - def load_reference_timeseries_da(self, field): + def load_reference_timeseries_da(self, field, **kwargs): """Return a DataArray time series to be used as reference (aka baseline) for variable field. """ @@ -165,7 +165,7 @@ def load_reference_timeseries_da(self, field): if not fils: warnings.warn(f"\t WARNING: Did not find reference time series file(s), variable: {field}") return None - #Change the variable name from CAM standard to what is + # Change the variable name from CAM standard to what is # listed in variable defaults for this observation field if self.adf.compare_obs: field = self.ref_var_nam[field] @@ -174,7 +174,7 @@ def load_reference_timeseries_da(self, field): else: add_offset, scale_factor = self.get_value_converters(self.ref_case_label, field) - return self.load_da(fils, field, add_offset=add_offset, scale_factor=scale_factor) + return self.load_da(fils, field, add_offset=add_offset, scale_factor=scale_factor, **kwargs) #------------------ @@ -305,7 +305,7 @@ def load_reference_regrid_da(self, case, field, **kwargs): #------------------ - + # DataSet and DataArray load #--------------------------- # TODO, make uxarray options fo all of these fuctions. From 71d1b7cd6cc8fe80cd020f173dfcd4e3856e03a5 Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 14 Nov 2025 08:23:03 -0700 Subject: [PATCH 120/126] working regional ts plots --- scripts/plotting/regional_timeseries.py | 123 ++++++++++++------------ 1 file changed, 62 insertions(+), 61 deletions(-) diff --git a/scripts/plotting/regional_timeseries.py b/scripts/plotting/regional_timeseries.py index e6ee3f9c4..d57b27341 100644 --- a/scripts/plotting/regional_timeseries.py +++ b/scripts/plotting/regional_timeseries.py @@ -1,10 +1,16 @@ +""" +Use time series files to produce regional mean time series plots for LDF web site. + +""" from pathlib import Path +from types import NoneType import numpy as np import yaml import xarray as xr import uxarray as ux import matplotlib.pyplot as plt import cartopy.crs as ccrs +import plotting_functions as pf import warnings # use to warn user about missing files. def my_formatwarning(msg, *args, **kwargs): @@ -16,18 +22,15 @@ def my_formatwarning(msg, *args, **kwargs): warnings.formatwarning = my_formatwarning -def regional_climatology(adfobj): +def regional_timeseries(adfobj): """ - load climo file, subset for each region and each var + load timeseries file, subset for each region and each var + calculate regional annual mean time series Make a combined plot, save it, add it to website. - NOTES (from Meg): There are still a lot of to-do's with this script! - - convert region defintion netCDF file to a yml, read that in instead - - increase number of variables that have a climo plotted; i've just - added two, but left room for more in the subplots - - check that all varaibles have climo files; likely to break otherwise - - add option so that this works with a structured grid too # ...existing code... + TODO + - check that all varaibles have TS files; likely to break otherwise if found: #Check if observations dataset name is specified: if "obs_name" in default_var_dict: @@ -44,14 +47,12 @@ def regional_climatology(adfobj): obs_data[field] = xr.open_mfdataset([str(obs_file_path)], combine="by_coords") plot_obs[field] = True # ...existing code... - - make sure that climo's are being plotted with the preferred units - - add in observations (need to regrid/area weight) - - need to figure out how to display the figures on the website + - make sure that TS's are being plotted with the preferred units """ #Notify user that script has started: - print("\n --- Generating regional climatology plots... ---") + print("\n --- Generating regional time series plots... ---") # Gather ADF configurations # plot_loc = adfobj.get_basic_info('cam_diag_plot_loc') @@ -74,19 +75,19 @@ def regional_climatology(adfobj): base_nickname = adfobj.get_baseline_info('case_nickname') region_list = adfobj.region_list - #TODO, make it easier for users decide on these? - regional_climo_var_list = ['TSA','PREC','ELAI', - 'FSDS','FLDS','SNOWDP','ASA', - 'FSH','QRUNOFF_TO_COUPLER','ET','FCTR', - 'GPP','TWS','FCEV','FAREA_BURNED', - ] + #TODO, make it easier for users decide on these by adding to yaml file + regional_ts_var_list = ['TSA','PREC','ELAI', + 'FSDS','FLDS','SNOWDP','ASA', + 'FSH','QRUNOFF_TO_COUPLER','ET','FCTR', + 'GPP','TWS','FCEV','FAREA_BURNED', + ] # Extract variables: baseline_name = adfobj.get_baseline_info("cam_case_name", required=True) - input_climo_baseline = Path(adfobj.get_baseline_info("cam_climo_loc", required=True)) + input_ts_baseline = Path(adfobj.get_baseline_info("cam_ts_loc", required=True)) # TODO hard wired for single case name: case_name = adfobj.get_cam_info("cam_case_name", required=True)[0] - input_climo_case = Path(adfobj.get_cam_info("cam_climo_loc", required=True)[0]) + input_ts_case = Path(adfobj.get_cam_info("cam_ts_loc", required=True)[0]) # Get grid file mesh_file = adfobj.mesh_files["baseline_mesh_file"] @@ -134,34 +135,26 @@ def regional_climatology(adfobj): var_obs_dict = adfobj.var_obs_dict # First, load all variable data once (instead of inside nested loops) - for field in regional_climo_var_list: - # Load the global climatology for this variable + for field in regional_ts_var_list: + # Load the global time series for this variable # TODO unit conversions are not handled consistently here - base_data[field] = adfobj.data.load_reference_climo_da(baseline_name, field, **kwargs) - case_data[field] = adfobj.data.load_climo_da(case_name, field, **kwargs) + base_data[field] = adfobj.data.load_reference_timeseries_da(field, **kwargs) + case_data[field] = adfobj.data.load_timeseries_da(case_name, field, **kwargs) if type(base_data[field]) is type(None): print('Missing file for ', field) continue else: - # get area and landfrac for base and case climo datasets - mdataset = adfobj.data.load_climo_dataset(case_name, field, **kwargs) - area_c = mdataset.area.isel(time=0) # drop time dimension to avoid confusion - landfrac_c = mdataset.landfrac.isel(time=0) - # Redundant, but we'll do this for consistency: - # TODO, won't handle loadling the basecase this way - #area_b = adfobj.data.load_reference_climo_da(baseline_name, 'area', **kwargs) - #landfrac_b = adfobj.data.load_reference_climo_da(baseline_name, 'landfrac', **kwargs) - - mdataset_base = adfobj.data.load_reference_climo_dataset(baseline_name, field, **kwargs) - area_b = mdataset_base.area.isel(time=0) - landfrac_b = mdataset_base.landfrac.isel(time=0) + # get area and landfrac for base and case ts datasets + mdataset = adfobj.data.load_timeseries_dataset(case_name, field, **kwargs) + # TODO: check with for structured grids + area_c = mdataset.area #.isel(time=0) # drop time dimension to avoid confusion + landfrac_c = mdataset.landfrac #.isel(time=0) + + mdataset_base = adfobj.data.load_reference_timeseries_dataset(field, **kwargs) + area_b = mdataset_base.area#.isel(time=0) + landfrac_b = mdataset_base.landfrac#.isel(time=0) - # calculate weights - # WW: 1) should actual weight calculation be done after subsetting to region? - # 2) Does this work as intended for different resolutions? - # wgt = area * landfrac # / (area * landfrac).sum() - #----------------------------------------- # Now, check if observations are to be plotted for this variable plot_obs[field] = False @@ -239,7 +232,7 @@ def regional_climatology(adfobj): #----------------------------------------- # Loop over regions for selected variable for iReg in range(len(region_list)): - print(f"\n\t - Plotting regional climatology for: {region_list[iReg]}") + print(f"\n\t - Plotting regional timeseries for: {region_list[iReg]}") # regionDS_thisRg = regionDS.isel(region=region_indexList[iReg]) box_west, box_east, box_south, box_north, region_category = get_region_boundaries(regions, region_list[iReg]) ## Set up figure @@ -248,8 +241,8 @@ def regional_climatology(adfobj): axs = axs.ravel() plt_counter = 1 - for field in regional_climo_var_list: - mdataset = adfobj.data.load_climo_dataset(case_name, field, **kwargs) + for field in regional_ts_var_list: + mdataset = adfobj.data.load_timeseries_dataset(case_name, field, **kwargs) if type(base_data[field]) is type(None): continue @@ -259,12 +252,16 @@ def regional_climatology(adfobj): base_var,wgt_sub = getRegion_uxarray(uxgrid, base_data, field, area_b, landfrac_b, box_west, box_east, box_south, box_north) - base_var_wgtd = np.sum(base_var * wgt_sub, axis=-1) # WW not needed?/ np.sum(wgt_sub) - + base_var_wgtd = np.sum(base_var * wgt_sub, axis=-1) + case_var,wgt_sub = getRegion_uxarray(uxgrid, case_data, field, area_c, landfrac_c, box_west, box_east, box_south, box_north) - case_var_wgtd = np.sum(case_var * wgt_sub, axis=-1) #/ np.sum(wgt_sub) + case_var_wgtd = np.sum(case_var * wgt_sub, axis=-1) + + # annually averaged + base_var_ann = pf.annual_mean(base_var_wgtd, whole_years=True, time_name="time") + case_var_ann = pf.annual_mean(case_var_wgtd, whole_years=True, time_name="time") else: # regular lat/lon grid # xarray output is time*lat*lon, sum over lat/lon @@ -280,6 +277,10 @@ def regional_climatology(adfobj): area_c, landfrac_c) case_var_wgtd = np.sum(case_var * wgt_sub, axis=(1,2)) + # annually averaged + base_var_ann = pf.annual_mean(base_var_wgtd, whole_years=True, time_name="time") + case_var_ann = pf.annual_mean(case_var_wgtd, whole_years=True, time_name="time") + # Read in observations, if available if plot_obs[field] == True: # obs output is time*lat*lon, sum over lat/lon @@ -353,37 +354,37 @@ def regional_climatology(adfobj): map_ax.set_extent([-180, 179, -89, -60],crs=ccrs.PlateCarree()) # End if for plotting map extent - ## Plot the climatology: + ## Plot the timeseries: if type(base_data[field]) is type(None): print('Missing file for ', field) continue else: - axs[plt_counter].plot(np.arange(12)+1, case_var_wgtd, - label=case_nickname, linewidth=2) - axs[plt_counter].plot(np.arange(12)+1, base_var_wgtd, + # WW set time axis to years + axs[plt_counter].plot(base_var_ann.year, base_var_ann, label=base_nickname, linewidth=2) - if plot_obs[field] == True: - axs[plt_counter].plot(np.arange(12)+1, obs_var_wgtd, - label=obs_name[field], color='black', linewidth=2) + axs[plt_counter].plot(case_var_ann.year, case_var_ann, + label=case_nickname, linewidth=2) + # TODO, reinstate obs plotting once obs TS files are available + # if plot_obs[field] == True: + # axs[plt_counter].plot(np.arange(12)+1, obs_var_wgtd, + # label=obs_name[field], color='black', linewidth=2) axs[plt_counter].set_title(field) axs[plt_counter].set_ylabel(base_data[field].units) - axs[plt_counter].set_xticks(np.arange(1, 13, 2)) - axs[plt_counter].legend() - + axs[plt_counter].legend() plt_counter = plt_counter+1 fig.subplots_adjust(hspace=0.3, wspace=0.3) # Save out figure - plot_loc = Path(plot_locations[0]) / f'{region_list[iReg]}_plot_RegionalClimo_Mean.{plot_type}' + plot_loc = Path(plot_locations[0]) / f'{region_list[iReg]}_plot_RegionalTimeSeries_Mean.{plot_type}' # Check redo_plot. If set to True: remove old plots, if they already exist: if (not redo_plot) and plot_loc.is_file(): #Add already-existing plot to website (if enabled): adfobj.debug_log(f"'{plot_loc}' exists and clobber is false.") adfobj.add_website_data(plot_loc, region_list[iReg], None, season=None, multi_case=True, - category=region_category, non_season=True, plot_type = "RegionalClimo") + category=region_category, non_season=True, plot_type = "RegionalTimeSeries") #Continue to next iteration: return @@ -396,11 +397,11 @@ def regional_climatology(adfobj): #Add plot to website (if enabled): adfobj.add_website_data(plot_loc, region_list[iReg], None, season=None, multi_case=True, - non_season=True, category=region_category, plot_type = "RegionalClimo") + non_season=True, category=region_category, plot_type = "RegionalTimeSeries") return -print("\n --- Regional climatology plots generated successfully! ---") +print("\n --- Regional time series plots generated successfully! ---") def getRegion_uxarray(gridDS, varDS, varName, area, landfrac, BOX_W, BOX_E, BOX_S, BOX_N): # Method 2: Filter mesh nodes based on coordinates From a7f78928503ba3c800637ce671aaf78be5ac6e9e Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 14 Nov 2025 08:23:58 -0700 Subject: [PATCH 121/126] improved load functions from ADF --- lib/adf_dataset.py | 238 +++++++++++++++++++++++---------------------- 1 file changed, 123 insertions(+), 115 deletions(-) diff --git a/lib/adf_dataset.py b/lib/adf_dataset.py index bba19ee21..18544b7a4 100644 --- a/lib/adf_dataset.py +++ b/lib/adf_dataset.py @@ -1,13 +1,9 @@ from pathlib import Path import xarray as xr import uxarray as ux - +#import adf_utils as utils import warnings # use to warn user about missing files - -def my_formatwarning(msg, *args, **kwargs): - # ignore everything except the message - return str(msg) + '\n' -warnings.formatwarning = my_formatwarning +#warnings.formatwarning = utils.my_formatwarning # "reference data" # It is often just a "baseline case", @@ -48,8 +44,7 @@ class AdfData: def __init__(self, adfobj): self.adf = adfobj # provides quick access to the AdfDiag object # paths - #self.model_rgrid_loc = adfobj.get_basic_info("cam_climo_regrid_loc", required=True) - #self.model_rgrid_loc = adfobj.get_cam_info("cam_climo_regrid_loc") + self.model_rgrid_loc = adfobj.get_basic_info("cam_regrid_loc", required=True) # variables (and info for unit transform) # use self.adf.diag_var_list and self.adf.self.adf.variable_defaults @@ -66,11 +61,13 @@ def __init__(self, adfobj): def set_reference(self): """Set attributes for reference (aka baseline) data location, names, and variables.""" if self.adf.compare_obs: - self.ref_var_loc = {v: self.adf.var_obs_dict[v]['obs_file'] for v in self.adf.var_obs_dict} - self.ref_labels = {v: self.adf.var_obs_dict[v]['obs_name'] for v in self.adf.var_obs_dict} - self.ref_var_nam = {v: self.adf.var_obs_dict[v]['obs_var'] for v in self.adf.var_obs_dict} - self.ref_case_label = "Obs" - if not self.adf.var_obs_dict: + if "var_obs_dict" in dir(self.adf): + self.ref_var_loc = {v: self.adf.var_obs_dict[v]['obs_file'] for v in self.adf.var_obs_dict} + self.ref_labels = {v: self.adf.var_obs_dict[v]['obs_name'] for v in self.adf.var_obs_dict} + self.ref_var_nam = {v: self.adf.var_obs_dict[v]['obs_var'] for v in self.adf.var_obs_dict} + self.ref_case_label = "Obs" + else: + #if not self.adf.var_obs_dict: warnings.warn("\t WARNING: reference is observations, but no observations found to plot against.") else: self.ref_var_loc = {} @@ -97,13 +94,30 @@ def set_ref_var_loc(self): # Test case(s) def get_timeseries_file(self, case, field): """Return list of test time series files""" + ts_locs = self.adf.get_cam_info("cam_ts_loc", required=True) # list of paths (could be multiple cases) caseindex = (self.case_names).index(case) - ts_locs = self.adf.get_cam_info("cam_ts_loc") - ts_loc = Path(ts_locs[caseindex]) ts_filenames = f'{case}.*.{field}.*nc' ts_files = sorted(ts_loc.glob(ts_filenames)) return ts_files + + def load_timeseries_dataset(self, case, field, **kwargs): + """Return a data set for variable field.""" + fils = self.get_timeseries_file(case, field) + if not fils: + warnings.warn(f"\t WARNING: Did not find time series file(s) for case: {case}, variable: {field}") + return None + return self.load_dataset(fils, type="tseries", **kwargs) + + def load_timeseries_da(self, case, variablename, **kwargs): + """Return DataArray from time series file(s). + Uses defaults file to convert units. + """ + fils = self.get_timeseries_file(case, variablename) + if not fils: + warnings.warn(f"\t WARNING: Did not find case time series file(s), variable: {variablename}") + return None + return self.load_da(fils, variablename, case, **kwargs) # Reference case (baseline/obs) def get_ref_timeseries_file(self, field): @@ -112,69 +126,30 @@ def get_ref_timeseries_file(self, field): warnings.warn("\t WARNING: ADF does not currently expect observational time series files.") return None else: - ts_loc = Path(self.adf.get_baseline_info("cam_ts_loc")) + ts_loc = Path(self.adf.get_baseline_info("cam_ts_loc", required=True)) ts_filenames = f'{self.ref_case_label}.*.{field}.*nc' ts_files = sorted(ts_loc.glob(ts_filenames)) return ts_files - - - def load_timeseries_dataset(self, fils, **kwargs): - """Return DataSet from time series file(s) and assign time to midpoint of interval""" - if (len(fils) == 0): - warnings.warn("\t WARNING: Input file list is empty.") - return None - elif (len(fils) > 1): - ds = xr.open_mfdataset(fils, decode_times=False) - else: - sfil = str(fils[0]) - if not Path(sfil).is_file(): - warnings.warn(f"\t WARNING: Expecting to find file: {sfil}") - return None - ds = xr.open_dataset(sfil, decode_times=False) - if ds is None: - warnings.warn(f"\t WARNING: invalid data on load_dataset") - # assign time to midpoint of interval (even if it is already) - if 'time_bnds' in ds: - t = ds['time_bnds'].mean(dim='nbnd') - t.attrs = ds['time'].attrs - ds = ds.assign_coords({'time':t}) - elif 'time_bounds' in ds: - t = ds['time_bounds'].mean(dim='nbnd') - t.attrs = ds['time'].attrs - ds = ds.assign_coords({'time':t}) - else: - warnings.warn("\t INFO: Timeseries file does not have time bounds info.") - return xr.decode_cf(ds) - - def load_timeseries_da(self, case, variablename, **kwargs): - """Return DataArray from time series file(s). - Uses defaults file to convert units. - """ - add_offset, scale_factor = self.get_value_converters(case, variablename) - fils = self.get_timeseries_file(case, variablename) + + def load_reference_timeseries_dataset(self, field, **kwargs): + """Return a data set for variable field.""" + case = self.ref_case_label + fils = self.get_ref_timeseries_file(field) if not fils: - warnings.warn(f"\t WARNING: Did not find case time series file(s), variable: {variablename}") + warnings.warn(f"\t WARNING: Did not find time series file(s) for case: {case}, variable: {field}") return None - return self.load_da(fils, variablename, add_offset=add_offset, scale_factor=scale_factor,**kwargs) + return self.load_dataset(fils, type="tseries", **kwargs) def load_reference_timeseries_da(self, field, **kwargs): """Return a DataArray time series to be used as reference (aka baseline) for variable field. """ + case = self.ref_case_label fils = self.get_ref_timeseries_file(field) if not fils: warnings.warn(f"\t WARNING: Did not find reference time series file(s), variable: {field}") return None - # Change the variable name from CAM standard to what is - # listed in variable defaults for this observation field - if self.adf.compare_obs: - field = self.ref_var_nam[field] - add_offset = 0 - scale_factor = 1 - else: - add_offset, scale_factor = self.get_value_converters(self.ref_case_label, field) - - return self.load_da(fils, field, add_offset=add_offset, scale_factor=scale_factor, **kwargs) + return self.load_da(fils, field, case, **kwargs) #------------------ @@ -184,58 +159,66 @@ def load_reference_timeseries_da(self, field, **kwargs): #------------------ # Test case(s) - def load_climo_da(self, case, variablename, **kwargs): - """Return DataArray from climo file""" - add_offset, scale_factor = self.get_value_converters(case, variablename) - fils = self.get_climo_file(case, variablename) - return self.load_da(fils, variablename, add_offset=add_offset, scale_factor=scale_factor, **kwargs) - - - def load_climo_dataset(self, case, field, **kwargs): - """Return a data set to be used as reference (aka baseline) for variable field.""" - fils = self.get_climo_file(case, field) - if not fils: - return None - return self.load_dataset(fils, **kwargs) - - def get_climo_file(self, case, variablename): """Retrieve the climo file path(s) for variablename for a specific case.""" - caseindex = (self.case_names).index(case) # the entry for specified case a = self.adf.get_cam_info("cam_climo_loc", required=True) # list of paths (could be multiple cases) + caseindex = (self.case_names).index(case) # the entry for specified case model_cl_loc = Path(a[caseindex]) return sorted(model_cl_loc.glob(f"{case}_{variablename}_climo.nc")) - - - # Reference case (baseline/obs) - def load_reference_climo_da(self, case, variablename, **kwargs): - """Return DataArray from reference (aka baseline) climo file""" - add_offset, scale_factor = self.get_value_converters(case, variablename) - fils = self.get_reference_climo_file(variablename) - return self.load_da(fils, variablename, add_offset=add_offset, scale_factor=scale_factor, **kwargs) - - def load_reference_climo_dataset(self, case, field, **kwargs): - """Return a data set to be used as reference (aka baseline) for variable field.""" - fils = self.get_reference_climo_file(field) + + def load_climo_dataset(self, case, variablename, **kwargs): + """Return Dataset for climo of field""" + fils = self.get_climo_file(case, variablename) if not fils: + warnings.warn(f"\t WARNING: Did not find climo file(s) for case: {case}, variable: {variablename}") return None return self.load_dataset(fils, **kwargs) + + def load_climo_da(self, case, variablename, **kwargs): + """Return DataArray from climo file""" + fils = self.get_climo_file(case, variablename) + if not fils: + warnings.warn(f"\t WARNING: Did not find climo file(s) for case: {case}, variable: {variablename}") + return None + return self.load_da(fils, variablename, case, **kwargs) + # Reference case (baseline/obs) def get_reference_climo_file(self, var): """Return a list of files to be used as reference (aka baseline) for variable var.""" if self.adf.compare_obs: fils = self.ref_var_loc.get(var, None) return [fils] if fils is not None else None ref_loc = self.adf.get_baseline_info("cam_climo_loc") + if not ref_loc: + return None # NOTE: originally had this looking for *_baseline.nc fils = sorted(Path(ref_loc).glob(f"{self.ref_case_label}_{var}_climo.nc")) if fils: return fils return None + + def load_reference_climo_dataset(self, field, **kwargs): + """Return Dataset for climo of field""" + case = self.ref_case_label + fils = self.get_reference_climo_file(field) + if not fils: + warnings.warn(f"\t WARNING: Did not find climo file(s) for case: {case}, variable: {field}") + return None + return self.load_dataset(fils, **kwargs) + + def load_reference_climo_da(self, field, **kwargs): + """Return DataArray from reference (aka baseline) climo file""" + case = self.ref_case_label + fils = self.get_reference_climo_file(field) + if not fils: + warnings.warn(f"\t WARNING: Did not find climo file(s) for case: {case}, variable: {field}") + return None + return self.load_da(fils, field, case, **kwargs) #------------------ + # Regridded files #------------------ @@ -258,17 +241,17 @@ def load_regrid_dataset(self, case, field, **kwargs): def load_regrid_da(self, case, field, **kwargs): """Return a data array to be used as reference (aka baseline) for variable field.""" - add_offset, scale_factor = self.get_value_converters(case, field) fils = self.get_regrid_file(case, field) if not fils: warnings.warn(f"\t WARNING: Did not find regrid file(s) for case: {case}, variable: {field}") return None - return self.load_da(fils, field, add_offset=add_offset, scale_factor=scale_factor, **kwargs) + return self.load_da(fils, field, case, **kwargs) # Reference case (baseline/obs) - def get_ref_regrid_file(self, case, field): + def get_ref_regrid_file(self, field): """Return list of reference regridded files""" + case = self.ref_case_label if self.adf.compare_obs: obs_loc = self.ref_var_loc.get(field, None) if obs_loc: @@ -281,43 +264,41 @@ def get_ref_regrid_file(self, case, field): return fils - def load_reference_regrid_dataset(self, case, field, **kwargs): + def load_reference_regrid_dataset(self, field, **kwargs): """Return a data set to be used as reference (aka baseline) for variable field.""" - fils = self.get_ref_regrid_file(case, field) + case = self.ref_case_label + fils = self.get_ref_regrid_file(field) if not fils: - warnings.warn(f"\t DATASET WARNING: Did not find regridded file(s) for case: {case}, variable: {field}") + warnings.warn(f"\t WARNING: Did not find regridded file(s) for case: {case}, variable: {field}") return None return self.load_dataset(fils, **kwargs) - def load_reference_regrid_da(self, case, field, **kwargs): + def load_reference_regrid_da(self, field, **kwargs): """Return a data array to be used as reference (aka baseline) for variable field.""" - add_offset, scale_factor = self.get_value_converters(case, field) - fils = self.get_ref_regrid_file(case, field) + case = self.ref_case_label + fils = self.get_ref_regrid_file(field) if not fils: - warnings.warn(f"\t DATAARRAY WARNING: Did not find regridded file(s) for case: {case}, variable: {field}") + warnings.warn(f"\t WARNING: Did not find regridded file(s) for case: {case}, variable: {field}") return None #Change the variable name from CAM standard to what is # listed in variable defaults for this observation field if self.adf.compare_obs: field = self.ref_var_nam[field] - return self.load_da(fils, field, add_offset=add_offset, scale_factor=scale_factor, **kwargs) + return self.load_da(fils, field, case, **kwargs) #------------------ - + # DataSet and DataArray load #--------------------------- - # TODO, make uxarray options fo all of these fuctions. - # What's the most robust way to handle this? # Load DataSet - def load_dataset(self, fils, **kwargs): + def load_dataset(self, fils, type=None, **kwargs): """Return xarray DataSet from file(s)""" - unstructured_plotting = kwargs.get("unstructured_plotting",False) - if not fils: + if (len(fils) == 0): warnings.warn("\t WARNING: Input file list is empty.") return None elif (len(fils) > 1): @@ -327,6 +308,7 @@ def load_dataset(self, fils, **kwargs): if not Path(sfil).is_file(): warnings.warn(f"\t WARNING: Expecting to find file: {sfil}") return None + # Open unstructured data if requested if unstructured_plotting: if "mesh_file" not in kwargs: msg = "\t WARNING: Unstructured plotting is requested, but no available mesh file." @@ -339,24 +321,50 @@ def load_dataset(self, fils, **kwargs): ds = xr.open_dataset(sfil) if ds is None: warnings.warn(f"\t WARNING: invalid data on load_dataset") + if type == "tseries": + # assign time to midpoint of interval (even if it is already) + if 'time_bnds' in ds: + t = ds['time_bnds'].mean(dim='nbnd') + t.attrs = ds['time'].attrs + ds = ds.assign_coords({'time':t}) + # TODO check this for old land model output + elif 'hist_interval' in ds['time_bounds'].dims: + t = ds['time_bounds'].mean(dim='hist_interval')#.value + t.attrs = ds['time'].attrs + ds = ds.assign_coords({'time':t}) + elif 'time_bounds' in ds: + t = ds['time_bounds'].mean(dim='nbnd') + t.attrs = ds['time'].attrs + ds = ds.assign_coords({'time':t}) + + + else: + warnings.warn("\t INFO: dataset does not have time bounds info.") return ds # Load DataArray - def load_da(self, fils, variablename, **kwargs): + def load_da(self, fils, variablename, case, type=None, **kwargs): """Return xarray DataArray from files(s) w/ optional scale factor, offset, and/or new units""" ds = self.load_dataset(fils, **kwargs) if ds is None: warnings.warn(f"\t WARNING: Load failed for {variablename}") return None da = (ds[variablename]).squeeze() - scale_factor = kwargs.get('scale_factor', 1) - add_offset = kwargs.get('add_offset', 0) + units = da.attrs.get('units', '--') + add_offset, scale_factor = self.get_value_converters(case, variablename) da = da * scale_factor + add_offset + da.attrs['scale_factor'] = scale_factor + da.attrs['add_offset'] = add_offset + da = self.update_unit(variablename, da, units) + da.attrs['original_unit'] = units + return da + + def update_unit(self, variablename, da, units): if variablename in self.adf.variable_defaults: vres = self.adf.variable_defaults[variablename] - da.attrs['units'] = vres.get("new_unit", da.attrs.get('units', 'none')) + da.attrs['units'] = vres.get("new_unit", units) else: - da.attrs['units'] = 'none' + da.attrs['units'] = '--' return da # Get variable conversion defaults, if applicable @@ -389,4 +397,4 @@ def get_value_converters(self, case, variablename): - + \ No newline at end of file From 7fb295ec7c455537a6a6469dda92149bdadfa34b Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 14 Nov 2025 08:56:03 -0700 Subject: [PATCH 122/126] updated load_reference_ds calls --- config_clm_structured_plots.yaml | 44 ++++++++++++-------- scripts/plotting/global_latlon_map.py | 9 ++-- scripts/plotting/polar_map.py | 6 +-- scripts/plotting/regional_climatology.py | 4 +- scripts/regridding/regrid_and_vert_interp.py | 4 +- 5 files changed, 38 insertions(+), 29 deletions(-) diff --git a/config_clm_structured_plots.yaml b/config_clm_structured_plots.yaml index 4e9a577d4..12508b64d 100644 --- a/config_clm_structured_plots.yaml +++ b/config_clm_structured_plots.yaml @@ -99,6 +99,9 @@ diag_basic_info: #Uncomment and change path for custom variable defaults file defaults_file: lib/ldf_variable_defaults.yaml + # location of land regions YAML file (only used in regional_climatology plots) + regions_file: lib/regions_lnd.yaml + #Longitude line on which to center all lat/lon maps. #If this config option is missing then the central #longitude will default to 180 degrees E. @@ -137,13 +140,13 @@ diag_cam_climo: cam_overwrite_climo: false #Name of CAM case (or CAM run name): - cam_case_name: ctsm53065_54surfdata_PPEcal115_115_HIST + cam_case_name: ctsm5.4.CMIP7_ciso_ctsm5.3.075_f09_124_HIST #Case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: 'PPE_115_HIST' + case_nickname: 'ctsm5.4_124_HIST' #Location of CAM history (h0) files: cam_hist_loc: /glade/derecho/scratch/wwieder/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ @@ -190,7 +193,7 @@ diag_cam_baseline_climo: # eg. cam.h0 or ocn.pop.h.ecosys.nday1 or hist_str: [cam.h2,cam.h0] # Only affects timeseries as everything else uses the created timeseries # Default: - hist_str: clm2.h0 + hist_str: clm2.h0a #Calculate cam baseline climatologies? #If false, the climatology files will not be created: @@ -201,13 +204,13 @@ diag_cam_baseline_climo: cam_overwrite_climo: false #Name of CAM baseline case: - cam_case_name: ctsm53041_54surfdata_PPEbaseline_101_HIST + cam_case_name: ctsm5.4_5.3.068_PPEcal115f09_118_HIST #Baseline case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: 'PPE_101_HIST' + case_nickname: 'ctsm5.4_118_HIST' #Location of CAM baseline history (h0) files: #Example test files @@ -281,6 +284,7 @@ plotting_scripts: - global_latlon_map - global_mean_timeseries_lnd - polar_map + - regional_timeseries - regional_climatology #List of variables that will be processesd: @@ -313,7 +317,13 @@ diag_var_list: - FAREA_BURNED - DSTFLXT - MEG_isoprene - + - TWS + - GRAINC_TO_FOOD + - C13_GPP_pm + - C13_TOTVEGC_pm + - C14_GPP_pm + - C14_TOTVEGC_pm + region_list: - Global - N Hemisphere Land @@ -321,22 +331,22 @@ region_list: - Polar - Alaskan Arctic - Canadian Arctic - #- Greenland + - Greenland - Russian Arctic #- Antarctica - Alaska - #- Northwest Canada - #- Central Canada + - Northwest Canada + - Central Canada - Eastern Canada - Northern Europe - Western Siberia - Eastern Siberia - Western US - #- Central US - #- Eastern US - #- Europe - #- Mediterranean - #- Central America + - Central US + - Eastern US + - Europe + - Mediterranean + - Central America - Amazonia - Central Africa - Indonesia @@ -344,10 +354,10 @@ region_list: - Sahel - Southern Africa - India - #- Indochina + - Indochina #- Sahara Desert - #- Arabian Peninsula - #- Australia + - Arabian Peninsula + - Australia #- Central Asia ## Was Broken... probably because there were two? #- Mongolia #- Tibetan Plateau diff --git a/scripts/plotting/global_latlon_map.py b/scripts/plotting/global_latlon_map.py index 0bb4b2a9b..60b5b4479 100644 --- a/scripts/plotting/global_latlon_map.py +++ b/scripts/plotting/global_latlon_map.py @@ -195,17 +195,16 @@ def global_latlon_map(adfobj): if unstruct_plotting: mesh_file = adfobj.mesh_files["baseline_mesh_file"] kwargs["mesh_file"] = mesh_file - odata = adfobj.data.load_reference_climo_da(base_name, var, **kwargs) + odata = adfobj.data.load_reference_climo_da(var, **kwargs) unstruct_base = True - odataset = adfobj.data.load_reference_climo_dataset(base_name, var, **kwargs) + odataset = adfobj.data.load_reference_climo_dataset(var, **kwargs) area = odataset.area.isel(time=0) landfrac = odataset.landfrac.isel(time=0) # calculate weights wgt_base = area * landfrac / (area * landfrac).sum() else: - #odata = adfobj.data.load_reference_regrid_da(base_name, var, **kwargs) - odata = adfobj.data.load_reference_regrid_da(base_name, var) + odata = adfobj.data.load_reference_regrid_da(var) if odata is None: dmsg = f"\t WARNING: No regridded baseline file for {base_name} for variable `{var}`, global lat/lon mean plotting skipped." @@ -632,7 +631,7 @@ def aod_latlon(adfobj): base_name = adfobj.data.ref_case_label # Gather reference variable data - ds_base = adfobj.data.load_reference_climo_da(base_name, var) + ds_base = adfobj.data.load_reference_climo_da(var) if ds_base is None: dmsg = f"\t WARNING: No baseline climo file for {base_name} for variable `{var}`, global lat/lon plots skipped." adfobj.debug_log(dmsg) diff --git a/scripts/plotting/polar_map.py b/scripts/plotting/polar_map.py index 8aa1f5b7a..8d87029e4 100644 --- a/scripts/plotting/polar_map.py +++ b/scripts/plotting/polar_map.py @@ -179,17 +179,17 @@ def polar_map(adfobj): if unstruct_plotting: mesh_file = adfobj.mesh_files["baseline_mesh_file"] kwargs["mesh_file"] = mesh_file - odata = adfobj.data.load_reference_climo_da(data_name, data_var, **kwargs) + odata = adfobj.data.load_reference_climo_da(data_var, **kwargs) #if ('ncol' in odata.dims) or ('lndgrid' in odata.dims): if 1==1: unstruct_base = True - odataset = adfobj.data.load_reference_climo_dataset(data_name, data_var, **kwargs) + odataset = adfobj.data.load_reference_climo_dataset(data_var, **kwargs) area = odataset.area.isel(time=0) landfrac = odataset.landfrac.isel(time=0) # calculate weights wgt_base = area * landfrac / (area * landfrac).sum() else: - odata = adfobj.data.load_reference_regrid_da(data_name, data_var, **kwargs) + odata = adfobj.data.load_reference_regrid_da(data_var, **kwargs) if odata is None: print("\t WARNING: Did not find any regridded reference climo files. Will try to skip.") print(f"\t INFO: Data Location, dclimo_loc is {dclimo_loc}") diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index e6ee3f9c4..73d4d79d1 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -137,7 +137,7 @@ def regional_climatology(adfobj): for field in regional_climo_var_list: # Load the global climatology for this variable # TODO unit conversions are not handled consistently here - base_data[field] = adfobj.data.load_reference_climo_da(baseline_name, field, **kwargs) + base_data[field] = adfobj.data.load_reference_climo_da(field, **kwargs) case_data[field] = adfobj.data.load_climo_da(case_name, field, **kwargs) if type(base_data[field]) is type(None): @@ -153,7 +153,7 @@ def regional_climatology(adfobj): #area_b = adfobj.data.load_reference_climo_da(baseline_name, 'area', **kwargs) #landfrac_b = adfobj.data.load_reference_climo_da(baseline_name, 'landfrac', **kwargs) - mdataset_base = adfobj.data.load_reference_climo_dataset(baseline_name, field, **kwargs) + mdataset_base = adfobj.data.load_reference_climo_dataset(field, **kwargs) area_b = mdataset_base.area.isel(time=0) landfrac_b = mdataset_base.landfrac.isel(time=0) diff --git a/scripts/regridding/regrid_and_vert_interp.py b/scripts/regridding/regrid_and_vert_interp.py index 44695d8a2..44b8fb99d 100644 --- a/scripts/regridding/regrid_and_vert_interp.py +++ b/scripts/regridding/regrid_and_vert_interp.py @@ -230,8 +230,8 @@ def regrid_and_vert_interp(adf): #Write to debug log if enabled: #adf.debug_log(f"regrid_example: tclim_fils (n={len(tclim_fils)}): {tclim_fils}") - - tclim_ds = adf.data.load_reference_climo_dataset(target, var) + print(var) + tclim_ds = adf.data.load_reference_climo_dataset(var) if tclim_ds is None: print(f"\t WARNING: regridding {var} failed, no climo file for case '{target}'. Continuing to next variable.") continue From 2fcb8b95d55966557b9a786facc968233f3a6cb3 Mon Sep 17 00:00:00 2001 From: wwieder Date: Fri, 14 Nov 2025 11:42:08 -0700 Subject: [PATCH 123/126] add some LDF titles to websites --- lib/adf_web.py | 6 +++--- lib/website_templates/template.html | 6 +++--- lib/website_templates/template_index.html | 6 +++--- lib/website_templates/template_mean_diag.html | 6 +++--- lib/website_templates/template_mean_tables.html | 8 ++++---- lib/website_templates/template_multi_case_index.html | 6 +++--- lib/website_templates/template_table.html | 8 ++++---- 7 files changed, 23 insertions(+), 23 deletions(-) diff --git a/lib/adf_web.py b/lib/adf_web.py index e39981f8f..fc971de8a 100644 --- a/lib/adf_web.py +++ b/lib/adf_web.py @@ -427,7 +427,7 @@ def jinja_enumerate(arg): #End if #Set main title for website: - main_title = "CAM Diagnostics" + main_title = "CLM Diagnostics" #List of seasons seasons = ["ANN","DJF","MAM","JJA","SON"] @@ -718,7 +718,7 @@ def jinja_enumerate(arg): avail_external_packages = {'MDTF':'mdtf_html_path', 'CVDP':'cvdp_html_path'} #Construct index.html - index_title = "AMP Diagnostics Prototype" + index_title = "CLM Diagnostics" index_tmpl = jinenv.get_template('template_index.html') index_rndr = index_tmpl.render(title=index_title, case_name=web_data.case, @@ -768,7 +768,7 @@ def jinja_enumerate(arg): #End for (model case loop) #Create multi-case site: - main_title = "ADF Diagnostics" + main_title = "CLM Diagnostics" main_tmpl = jinenv.get_template('template_multi_case_index.html') main_rndr = main_tmpl.render(title=main_title, case_sites=case_sites, diff --git a/lib/website_templates/template.html b/lib/website_templates/template.html index 3a06250cb..85dba9860 100644 --- a/lib/website_templates/template.html +++ b/lib/website_templates/template.html @@ -1,7 +1,7 @@ - ADF {{var_title}} + CLM Diagnostics {{var_title}} @@ -22,8 +22,8 @@
  • Links ▾
  • About
    • diff --git a/lib/website_templates/template_index.html b/lib/website_templates/template_index.html index db49975e1..9e411c410 100644 --- a/lib/website_templates/template_index.html +++ b/lib/website_templates/template_index.html @@ -1,7 +1,7 @@ - ADF Diagnostics + CLM Diagnostics @@ -15,8 +15,8 @@
  • Links ▾
  • About
    • diff --git a/lib/website_templates/template_mean_diag.html b/lib/website_templates/template_mean_diag.html index a62250af8..e748d93a7 100644 --- a/lib/website_templates/template_mean_diag.html +++ b/lib/website_templates/template_mean_diag.html @@ -1,7 +1,7 @@ - ADF Mean Plots + LDF Mean Plots @@ -22,8 +22,8 @@
  • Links ▾
  • About
    • diff --git a/lib/website_templates/template_mean_tables.html b/lib/website_templates/template_mean_tables.html index 877d96e26..d6c53dee8 100644 --- a/lib/website_templates/template_mean_tables.html +++ b/lib/website_templates/template_mean_tables.html @@ -1,7 +1,7 @@ - ADF Mean Tables + LDF Mean Tables @@ -22,8 +22,8 @@
  • Links ▾
  • About
    • @@ -38,7 +38,7 @@

    Baseline Case:

    -

    AMWG Tables

    +

    LMWG Tables

    diff --git a/lib/website_templates/template_multi_case_index.html b/lib/website_templates/template_multi_case_index.html index 0ba930dec..4ff607e98 100644 --- a/lib/website_templates/template_multi_case_index.html +++ b/lib/website_templates/template_multi_case_index.html @@ -1,7 +1,7 @@ - ADF diagnostics + CLM Diagnostics @@ -12,8 +12,8 @@
  • Links ▾
  • About
    • diff --git a/lib/website_templates/template_table.html b/lib/website_templates/template_table.html index 82158dd2c..581af913b 100644 --- a/lib/website_templates/template_table.html +++ b/lib/website_templates/template_table.html @@ -1,7 +1,7 @@ - ADF Mean Tables + LDF Mean Tables @@ -22,8 +22,8 @@
  • Links ▾
  • About
    • @@ -38,7 +38,7 @@

    Baseline Case:

    -

    AMWG Tables

    +

    LMWG Tables

    From aa03eb9839c96a9a7b14e6ed45eee01188c1e24e Mon Sep 17 00:00:00 2001 From: wwieder Date: Mon, 24 Nov 2025 15:48:13 -0700 Subject: [PATCH 124/126] add regional TS to defaults --- config_clm_unstructured_plots.yaml | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/config_clm_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml index 0858d9034..56a107603 100644 --- a/config_clm_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -278,10 +278,11 @@ analysis_scripts: #List of plotting scripts being used. #These scripts must be located in "scripts/plotting": plotting_scripts: - - global_latlon_map - - global_mean_timeseries_lnd - - polar_map - - regional_climatology + - global_latlon_map + - global_mean_timeseries_lnd + - polar_map + - regional_climatology + - regional_timeseries #List of variables that will be processesd: #Shorter list here, for efficiency of testing From a9fd0ee51eab6b1132ad218a0080308f15aad83d Mon Sep 17 00:00:00 2001 From: wwieder Date: Wed, 3 Dec 2025 11:52:57 -0700 Subject: [PATCH 125/126] add CERES obs, SOILWATER, more regions --- config_clm_unstructured_plots.yaml | 31 ++++++++++++++---------- lib/ldf_variable_defaults.yaml | 10 ++++++++ lib/regions_lnd.yaml | 8 ++++++ scripts/plotting/regional_climatology.py | 22 ++++++++++++----- scripts/plotting/regional_timeseries.py | 17 ++++++++----- 5 files changed, 63 insertions(+), 25 deletions(-) diff --git a/config_clm_unstructured_plots.yaml b/config_clm_unstructured_plots.yaml index 56a107603..fdb2a0da1 100644 --- a/config_clm_unstructured_plots.yaml +++ b/config_clm_unstructured_plots.yaml @@ -140,16 +140,17 @@ diag_cam_climo: cam_overwrite_climo: false #Name of CAM case (or CAM run name): - cam_case_name: ctsm5.4.CMIP7_ciso_ctsm5.3.075_ne30_123_HIST_popDens + cam_case_name: b.e30_alpha07c_cesm.B1850C_LTso.ne30_t232_wgx3.247 #Case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '123_popDens' + case_nickname: 'B_247' #Location of CAM history (h0) files: - cam_hist_loc: /glade/derecho/scratch/wwieder/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ + cam_hist_loc: /glade/campaign/cesm/development/cross-wg/diagnostic_framework/CESM_output_for_testing/${diag_cam_climo.cam_case_name}/lnd/hist/ + # /glade/derecho/scratch/wwieder/archive/${diag_cam_climo.cam_case_name}/lnd/hist/ # If unstructured_plotting, a mesh file is required! mesh_file: /glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc @@ -157,12 +158,12 @@ diag_cam_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 1850 - climo_start_year: 2004 + start_year: 1 + climo_start_year: 85 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 2023 + end_year: 104 #Do time series files exist? #If True, then diagnostics assumes that model files are already time series. @@ -202,17 +203,18 @@ diag_cam_baseline_climo: cam_overwrite_climo: false #Name of CAM baseline case: - cam_case_name: ctsm5.4_5.3.068_PPEcal115_116_HIST + cam_case_name: b.e30_alpha07c_cesm.B1850C_LTso.ne30_t232_wgx3.234 #Baseline case nickname #NOTE: if nickname starts with '0' - nickname must be in quotes! # ie '026a' as opposed to 026a #If missing or left blank, will default to cam_case_name - case_nickname: '116' + case_nickname: 'B_234' #Location of CAM baseline history (h0) files: #Example test files - cam_hist_loc: /glade/derecho/scratch/wwieder/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist/ + cam_hist_loc: /glade/campaign/cesm/development/cross-wg/diagnostic_framework/CESM_output_for_testing/${diag_cam_baseline_climo.cam_case_name}/lnd/hist/ + # /glade/derecho/scratch/wwieder/archive/${diag_cam_baseline_climo.cam_case_name}/lnd/hist/ # If unstructured_plotting, a mesh file is required! mesh_file: /glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc @@ -223,13 +225,13 @@ diag_cam_baseline_climo: #model year when time series files should start: #Note: Leaving this entry blank will make time series # start at earliest available year. - start_year: 1850 - climo_start_year: 2004 + start_year: 1 + climo_start_year: 61 #model year when time series files should end: #Note: Leaving this entry blank will make time series # end at latest available year. - end_year: 2023 + end_year: 80 #Do time series files need to be generated? #If True, then diagnostics assumes that model files are already time series. @@ -313,9 +315,10 @@ diag_var_list: - TOTECOSYSC - TOTSOMC_1m - ALTMAX - - FAREA_BURNED - TWS + - SOILWATER_10CM - GRAINC_TO_FOOD + - FAREA_BURNED #- C13_GPP_pm # - C13_TOTVEGC_pm #- C14_GPP_pm @@ -341,12 +344,14 @@ region_list: - Western US - Central US - Eastern US + - CONUS - Europe - Mediterranean - Central America - Amazonia - Central Africa - Indonesia + - S America - Brazil - Sahel - Southern Africa diff --git a/lib/ldf_variable_defaults.yaml b/lib/ldf_variable_defaults.yaml index 3f6bcd620..d72665af2 100644 --- a/lib/ldf_variable_defaults.yaml +++ b/lib/ldf_variable_defaults.yaml @@ -122,12 +122,18 @@ FLDS: # atmospheric longwave radiation label : "W m$^{-2}$" pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] pct_diff_colormap: "PuOr_r" + obs_file: "/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/obs_data/CERESed4.2-rlds_ALLMONS_climo.nc" + obs_name: "CERESed4.2" + obs_var_name: "rlds" #W/m2 FSDS: # atmospheric incident solar radiation category: "Atmosphere" pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100] pct_diff_colormap: "PuOr_r" new_unit: "W m$^{-2}$" + obs_file: "/glade/campaign/cgd/tss/people/oleson/FROM_LMWG/diag/lnd_diag4.2/obs_data/CERESed4.2-rsds_ALLMONS_climo.nc" + obs_name: "CERESed4.2" + obs_var_name: "rsds" #W/m2 WIND: # atmospheric air temperature category: "Atmosphere" @@ -296,6 +302,10 @@ TOTRUNOFF: # total liquid runoff colorbar: label : "mm d$^{-1}$" +SOILWATER_10CM: # soil liquid water + ice in top 10cm of soil + category: "Hydrology" + colormap: "Blues" + TWS: # Terrestrial water storage category: "Hydrology" colormap: "Blues" diff --git a/lib/regions_lnd.yaml b/lib/regions_lnd.yaml index 77402761a..1ef070ac3 100644 --- a/lib/regions_lnd.yaml +++ b/lib/regions_lnd.yaml @@ -83,6 +83,10 @@ Eastern US: lat_bounds: [30, 50] lon_bounds: [-90, -70] region_category: Temperate +CONUS: + lat_bounds: [25, 55] + lon_bounds: [-125, -70] + region_category: Temperate Europe: lat_bounds: [45, 60] lon_bounds: [-10, 30] @@ -107,6 +111,10 @@ Indonesia: lat_bounds: [-10, 10] lon_bounds: [90, 150] region_category: Tropical +S America: + lat_bounds: [-30, 5] + lon_bounds: [-85, -35] + region_category: Tropical Brazil: lat_bounds: [-23.5, -10] lon_bounds: [-65, -30] diff --git a/scripts/plotting/regional_climatology.py b/scripts/plotting/regional_climatology.py index 73d4d79d1..0d4e94a60 100644 --- a/scripts/plotting/regional_climatology.py +++ b/scripts/plotting/regional_climatology.py @@ -78,7 +78,7 @@ def regional_climatology(adfobj): regional_climo_var_list = ['TSA','PREC','ELAI', 'FSDS','FLDS','SNOWDP','ASA', 'FSH','QRUNOFF_TO_COUPLER','ET','FCTR', - 'GPP','TWS','FCEV','FAREA_BURNED', + 'GPP','TWS','SOILWATER_10CM','FAREA_BURNED', ] # Extract variables: @@ -332,6 +332,10 @@ def regional_climatology(adfobj): map_ax.set_extent([-180, 179, -89, 3],crs=ccrs.PlateCarree()) elif region_list[iReg]=='Polar': map_ax.set_extent([-180, 179, 45, 90],crs=ccrs.PlateCarree()) + elif region_list[iReg]=='CONUS': + map_ax.set_extent([-140, -55, 10, 70],crs=ccrs.PlateCarree()) + elif region_list[iReg]=='S America': + map_ax.set_extent([-100, -20, -45, 20],crs=ccrs.PlateCarree()) else: if ((box_south >= 30) & (box_east<=-5) ): map_ax.set_extent([-180, 0, 30, 90],crs=ccrs.PlateCarree()) @@ -358,17 +362,18 @@ def regional_climatology(adfobj): print('Missing file for ', field) continue else: - axs[plt_counter].plot(np.arange(12)+1, case_var_wgtd, - label=case_nickname, linewidth=2) axs[plt_counter].plot(np.arange(12)+1, base_var_wgtd, label=base_nickname, linewidth=2) + axs[plt_counter].plot(np.arange(12)+1, case_var_wgtd, + label=case_nickname, linewidth=2) if plot_obs[field] == True: axs[plt_counter].plot(np.arange(12)+1, obs_var_wgtd, label=obs_name[field], color='black', linewidth=2) + axs[plt_counter].legend() + axs[plt_counter].set_title(field) axs[plt_counter].set_ylabel(base_data[field].units) axs[plt_counter].set_xticks(np.arange(1, 13, 2)) - axs[plt_counter].legend() plt_counter = plt_counter+1 @@ -437,6 +442,12 @@ def getRegion_xarray(varDS, varName, if varName not in varDS: varName = obs_var_name + + if varDS.lon.values.min() < 0: + # Convert lon to [0,360] if necessary + longitude = varDS['lon'] + varDS = varDS.assign_coords(lon= (longitude + 180) % 360) + print(f"Converted lon to [0,360] for variable {varName}") # TODO is there a less brittle way to do this? if (area is not None) and (landfrac is not None): @@ -455,7 +466,7 @@ def getRegion_xarray(varDS, varName, weight = weight * varDS['datamask'] else: raise ValueError("No valid weight, area, or landmask found in {varName} dataset.") - + # check we have a data array for the variable if isinstance(varDS, xr.Dataset): varDS = varDS[varName] @@ -478,7 +489,6 @@ def getRegion_xarray(varDS, varName, lon=(west_of_0 | east_of_0)) wgt_subset = weight_subset / weight_subset.sum() - weight_subset = weight.sel return domain_subset,wgt_subset def get_region_boundaries(regions, region_name): diff --git a/scripts/plotting/regional_timeseries.py b/scripts/plotting/regional_timeseries.py index d57b27341..54b7a7e76 100644 --- a/scripts/plotting/regional_timeseries.py +++ b/scripts/plotting/regional_timeseries.py @@ -79,15 +79,15 @@ def regional_timeseries(adfobj): regional_ts_var_list = ['TSA','PREC','ELAI', 'FSDS','FLDS','SNOWDP','ASA', 'FSH','QRUNOFF_TO_COUPLER','ET','FCTR', - 'GPP','TWS','FCEV','FAREA_BURNED', + 'GPP','TWS','SOILWATER_10CM','FAREA_BURNED', ] # Extract variables: - baseline_name = adfobj.get_baseline_info("cam_case_name", required=True) - input_ts_baseline = Path(adfobj.get_baseline_info("cam_ts_loc", required=True)) + #baseline_name = adfobj.get_baseline_info("cam_case_name", required=True) + #input_ts_baseline = Path(adfobj.get_baseline_info("cam_ts_loc", required=True)) # TODO hard wired for single case name: case_name = adfobj.get_cam_info("cam_case_name", required=True)[0] - input_ts_case = Path(adfobj.get_cam_info("cam_ts_loc", required=True)[0]) + #input_ts_case = Path(adfobj.get_cam_info("cam_ts_loc", required=True)[0]) # Get grid file mesh_file = adfobj.mesh_files["baseline_mesh_file"] @@ -132,7 +132,7 @@ def regional_timeseries(adfobj): obs_var_name = {} plot_obs = {} - var_obs_dict = adfobj.var_obs_dict + #var_obs_dict = adfobj.var_obs_dict # First, load all variable data once (instead of inside nested loops) for field in regional_ts_var_list: @@ -333,6 +333,10 @@ def regional_timeseries(adfobj): map_ax.set_extent([-180, 179, -89, 3],crs=ccrs.PlateCarree()) elif region_list[iReg]=='Polar': map_ax.set_extent([-180, 179, 45, 90],crs=ccrs.PlateCarree()) + elif region_list[iReg]=='CONUS': + map_ax.set_extent([-140, -55, 10, 70],crs=ccrs.PlateCarree()) + elif region_list[iReg]=='S America': + map_ax.set_extent([-100, -20, -45, 20],crs=ccrs.PlateCarree()) else: if ((box_south >= 30) & (box_east<=-5) ): map_ax.set_extent([-180, 0, 30, 90],crs=ccrs.PlateCarree()) @@ -370,7 +374,8 @@ def regional_timeseries(adfobj): # label=obs_name[field], color='black', linewidth=2) axs[plt_counter].set_title(field) axs[plt_counter].set_ylabel(base_data[field].units) - axs[plt_counter].legend() + if plt_counter == 3 or plt_counter == 7 or plt_counter ==11 or plt_counter ==15: + axs[plt_counter].legend() plt_counter = plt_counter+1 From a5e79c35adc3764f87f5a2ed609e3a1a288e4dba Mon Sep 17 00:00:00 2001 From: wwieder Date: Mon, 8 Dec 2025 13:42:54 -0700 Subject: [PATCH 126/126] uxarray h1 example --- lib/plot_uxarray_h1_raster_better.ipynb | 1464 +++++++++++++++++++++++ 1 file changed, 1464 insertions(+) create mode 100644 lib/plot_uxarray_h1_raster_better.ipynb diff --git a/lib/plot_uxarray_h1_raster_better.ipynb b/lib/plot_uxarray_h1_raster_better.ipynb new file mode 100644 index 000000000..88eb360eb --- /dev/null +++ b/lib/plot_uxarray_h1_raster_better.ipynb @@ -0,0 +1,1464 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "39545902-0870-4a3f-93f1-493e56403d38", + "metadata": {}, + "source": [ + "### test for plotting pft level data on h1 files\n", + "Created by Will Wieder\n", + "Improved by Orhan Eroglu\n", + "March 2025" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b75e38a9-54ff-438b-91cd-2f72ef3abd95", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " const force = true;\n", + " const py_version = '3.7.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " const reloading = false;\n", + " const Bokeh = root.Bokeh;\n", + "\n", + " // Set a timeout for this load but only if we are not already initializing\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks;\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + " if (js_exports == null) js_exports = {};\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + "\n", + " if (root._bokeh_is_loading > 0) {\n", + " // Don't load bokeh if it is still initializing\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " // There is nothing to load\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + " window._bokeh_on_load = on_load\n", + "\n", + " function on_error(e) {\n", + " const src_el = e.srcElement\n", + " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", + " }\n", + "\n", + " const skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", + " root._bokeh_is_loading = css_urls.length + 0;\n", + " } else {\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", + " }\n", + "\n", + " const existing_stylesheets = []\n", + " const links = document.getElementsByTagName('link')\n", + " for (let i = 0; i < links.length; i++) {\n", + " const link = links[i]\n", + " if (link.href != null) {\n", + " existing_stylesheets.push(link.href)\n", + " }\n", + " }\n", + " for (let i = 0; i < css_urls.length; i++) {\n", + " const url = css_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", + " on_load()\n", + " continue;\n", + " }\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " } var existing_scripts = []\n", + " const scripts = document.getElementsByTagName('script')\n", + " for (let i = 0; i < scripts.length; i++) {\n", + " var script = scripts[i]\n", + " if (script.src != null) {\n", + " existing_scripts.push(script.src)\n", + " }\n", + " }\n", + " for (let i = 0; i < js_urls.length; i++) {\n", + " const url = js_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " const element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (let i = 0; i < js_modules.length; i++) {\n", + " const url = js_modules[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (const name in js_exports) {\n", + " const url = js_exports[name];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " element.textContent = `\n", + " import ${name} from \"${url}\"\n", + " window.${name} = ${name}\n", + " window._bokeh_on_load()\n", + " `\n", + " document.head.appendChild(element);\n", + " }\n", + " if (!js_urls.length && !js_modules.length) {\n", + " on_load()\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " const js_urls = [\"https://cdn.holoviz.org/panel/1.6.2/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.7.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.7.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.7.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.7.2.min.js\", \"https://cdn.holoviz.org/panel/1.6.2/dist/panel.min.js\"];\n", + " const js_modules = [];\n", + " const js_exports = {};\n", + " const css_urls = [];\n", + " const inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {} // ensure no trailing comma for IE\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if ((root.Bokeh !== undefined) || (force === true)) {\n", + " for (let i = 0; i < inline_js.length; i++) {\n", + " try {\n", + " inline_js[i].call(root, root.Bokeh);\n", + " } catch(e) {\n", + " if (!reloading) {\n", + " throw e;\n", + " }\n", + " }\n", + " }\n", + " // Cache old bokeh versions\n", + " if (Bokeh != undefined && !reloading) {\n", + " var NewBokeh = root.Bokeh;\n", + " if (Bokeh.versions === undefined) {\n", + " Bokeh.versions = new Map();\n", + " }\n", + " if (NewBokeh.version !== Bokeh.version) {\n", + " Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", + " }\n", + " root.Bokeh = Bokeh;\n", + " }\n", + " } else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " }\n", + " root._bokeh_is_initializing = false\n", + " }\n", + "\n", + " function load_or_wait() {\n", + " // Implement a backoff loop that tries to ensure we do not load multiple\n", + " // versions of Bokeh and its dependencies at the same time.\n", + " // In recent versions we use the root._bokeh_is_initializing flag\n", + " // to determine whether there is an ongoing attempt to initialize\n", + " // bokeh, however for backward compatibility we also try to ensure\n", + " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", + " // before older versions are fully initialized.\n", + " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", + " // If the timeout and bokeh was not successfully loaded we reset\n", + " // everything and try loading again\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_is_initializing = false;\n", + " root._bokeh_onload_callbacks = undefined;\n", + " root._bokeh_is_loading = 0\n", + " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", + " load_or_wait();\n", + " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", + " setTimeout(load_or_wait, 100);\n", + " } else {\n", + " root._bokeh_is_initializing = true\n", + " root._bokeh_onload_callbacks = []\n", + " const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n", + " if (!reloading && !bokeh_loaded) {\n", + " if (root.Bokeh) {\n", + " root.Bokeh = undefined;\n", + " }\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " }\n", + " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", + " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + " run_inline_js();\n", + " });\n", + " }\n", + " }\n", + " // Give older versions of the autoload script a head-start to ensure\n", + " // they initialize before we start loading newer version.\n", + " setTimeout(load_or_wait, 100)\n", + "}(window));" + ], + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n const py_version = '3.7.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = false;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.6.2/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.7.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.7.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.7.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.7.2.min.js\", \"https://cdn.holoviz.org/panel/1.6.2/dist/panel.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", + " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", + "}\n", + "\n", + "\n", + " function JupyterCommManager() {\n", + " }\n", + "\n", + " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", + " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " comm_manager.register_target(comm_id, function(comm) {\n", + " comm.on_msg(msg_handler);\n", + " });\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", + " comm.onMsg = msg_handler;\n", + " });\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " console.log(message)\n", + " var content = {data: message.data, comm_id};\n", + " var buffers = []\n", + " for (var buffer of message.buffers || []) {\n", + " buffers.push(new DataView(buffer))\n", + " }\n", + " var metadata = message.metadata || {};\n", + " var msg = {content, buffers, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " })\n", + " }\n", + " }\n", + "\n", + " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", + " if (comm_id in window.PyViz.comms) {\n", + " return window.PyViz.comms[comm_id];\n", + " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", + " if (msg_handler) {\n", + " comm.on_msg(msg_handler);\n", + " }\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", + " comm.open();\n", + " if (msg_handler) {\n", + " comm.onMsg = msg_handler;\n", + " }\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", + " comm_promise.then((comm) => {\n", + " window.PyViz.comms[comm_id] = comm;\n", + " if (msg_handler) {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " var content = {data: message.data};\n", + " var metadata = message.metadata || {comm_id};\n", + " var msg = {content, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " })\n", + " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", + " return comm_promise.then((comm) => {\n", + " comm.send(data, metadata, buffers, disposeOnDone);\n", + " });\n", + " };\n", + " var comm = {\n", + " send: sendClosure\n", + " };\n", + " }\n", + " window.PyViz.comms[comm_id] = comm;\n", + " return comm;\n", + " }\n", + " window.PyViz.comm_manager = new JupyterCommManager();\n", + " \n", + "\n", + "\n", + "var JS_MIME_TYPE = 'application/javascript';\n", + "var HTML_MIME_TYPE = 'text/html';\n", + "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", + "var CLASS_NAME = 'output';\n", + "\n", + "/**\n", + " * Render data to the DOM node\n", + " */\n", + "function render(props, node) {\n", + " var div = document.createElement(\"div\");\n", + " var script = document.createElement(\"script\");\n", + " node.appendChild(div);\n", + " node.appendChild(script);\n", + "}\n", + "\n", + "/**\n", + " * Handle when a new output is added\n", + " */\n", + "function handle_add_output(event, handle) {\n", + " var output_area = handle.output_area;\n", + " var output = handle.output;\n", + " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + " if (id !== undefined) {\n", + " var nchildren = toinsert.length;\n", + " var html_node = toinsert[nchildren-1].children[0];\n", + " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var scripts = [];\n", + " var nodelist = html_node.querySelectorAll(\"script\");\n", + " for (var i in nodelist) {\n", + " if (nodelist.hasOwnProperty(i)) {\n", + " scripts.push(nodelist[i])\n", + " }\n", + " }\n", + "\n", + " scripts.forEach( function (oldScript) {\n", + " var newScript = document.createElement(\"script\");\n", + " var attrs = [];\n", + " var nodemap = oldScript.attributes;\n", + " for (var j in nodemap) {\n", + " if (nodemap.hasOwnProperty(j)) {\n", + " attrs.push(nodemap[j])\n", + " }\n", + " }\n", + " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", + " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", + " oldScript.parentNode.replaceChild(newScript, oldScript);\n", + " });\n", + " if (JS_MIME_TYPE in output.data) {\n", + " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", + " }\n", + " output_area._hv_plot_id = id;\n", + " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", + " window.PyViz.plot_index[id] = Bokeh.index[id];\n", + " } else {\n", + " window.PyViz.plot_index[id] = null;\n", + " }\n", + " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " var bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var script_attrs = bk_div.children[0].attributes;\n", + " for (var i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + "function handle_clear_output(event, handle) {\n", + " var id = handle.cell.output_area._hv_plot_id;\n", + " var server_id = handle.cell.output_area._bokeh_server_id;\n", + " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", + " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", + " if (server_id !== null) {\n", + " comm.send({event_type: 'server_delete', 'id': server_id});\n", + " return;\n", + " } else if (comm !== null) {\n", + " comm.send({event_type: 'delete', 'id': id});\n", + " }\n", + " delete PyViz.plot_index[id];\n", + " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", + " var doc = window.Bokeh.index[id].model.document\n", + " doc.clear();\n", + " const i = window.Bokeh.documents.indexOf(doc);\n", + " if (i > -1) {\n", + " window.Bokeh.documents.splice(i, 1);\n", + " }\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle kernel restart event\n", + " */\n", + "function handle_kernel_cleanup(event, handle) {\n", + " delete PyViz.comms[\"hv-extension-comm\"];\n", + " window.PyViz.plot_index = {}\n", + "}\n", + "\n", + "/**\n", + " * Handle update_display_data messages\n", + " */\n", + "function handle_update_output(event, handle) {\n", + " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", + " handle_add_output(event, handle)\n", + "}\n", + "\n", + "function register_renderer(events, OutputArea) {\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " var toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[0]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " events.on('output_added.OutputArea', handle_add_output);\n", + " events.on('output_updated.OutputArea', handle_update_output);\n", + " events.on('clear_output.CodeCell', handle_clear_output);\n", + " events.on('delete.Cell', handle_clear_output);\n", + " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", + "\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " safe: true,\n", + " index: 0\n", + " });\n", + "}\n", + "\n", + "if (window.Jupyter !== undefined) {\n", + " try {\n", + " var events = require('base/js/events');\n", + " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " } catch(err) {\n", + " }\n", + "}\n" + ], + "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n })\n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
    \n", + "
    \n", + "
    \n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "c99174b8-5539-4f69-a0b2-ab0b401a0d6a" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " const force = false;\n", + " const py_version = '3.7.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " const reloading = true;\n", + " const Bokeh = root.Bokeh;\n", + "\n", + " // Set a timeout for this load but only if we are not already initializing\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks;\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + " if (js_exports == null) js_exports = {};\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + "\n", + " if (root._bokeh_is_loading > 0) {\n", + " // Don't load bokeh if it is still initializing\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " // There is nothing to load\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + " window._bokeh_on_load = on_load\n", + "\n", + " function on_error(e) {\n", + " const src_el = e.srcElement\n", + " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", + " }\n", + "\n", + " const skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", + " root._bokeh_is_loading = css_urls.length + 0;\n", + " } else {\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", + " }\n", + "\n", + " const existing_stylesheets = []\n", + " const links = document.getElementsByTagName('link')\n", + " for (let i = 0; i < links.length; i++) {\n", + " const link = links[i]\n", + " if (link.href != null) {\n", + " existing_stylesheets.push(link.href)\n", + " }\n", + " }\n", + " for (let i = 0; i < css_urls.length; i++) {\n", + " const url = css_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", + " on_load()\n", + " continue;\n", + " }\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " } var existing_scripts = []\n", + " const scripts = document.getElementsByTagName('script')\n", + " for (let i = 0; i < scripts.length; i++) {\n", + " var script = scripts[i]\n", + " if (script.src != null) {\n", + " existing_scripts.push(script.src)\n", + " }\n", + " }\n", + " for (let i = 0; i < js_urls.length; i++) {\n", + " const url = js_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " const element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (let i = 0; i < js_modules.length; i++) {\n", + " const url = js_modules[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (const name in js_exports) {\n", + " const url = js_exports[name];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " element.textContent = `\n", + " import ${name} from \"${url}\"\n", + " window.${name} = ${name}\n", + " window._bokeh_on_load()\n", + " `\n", + " document.head.appendChild(element);\n", + " }\n", + " if (!js_urls.length && !js_modules.length) {\n", + " on_load()\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " const js_urls = [\"https://cdn.holoviz.org/panel/1.6.2/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\"];\n", + " const js_modules = [];\n", + " const js_exports = {};\n", + " const css_urls = [];\n", + " const inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {} // ensure no trailing comma for IE\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if ((root.Bokeh !== undefined) || (force === true)) {\n", + " for (let i = 0; i < inline_js.length; i++) {\n", + " try {\n", + " inline_js[i].call(root, root.Bokeh);\n", + " } catch(e) {\n", + " if (!reloading) {\n", + " throw e;\n", + " }\n", + " }\n", + " }\n", + " // Cache old bokeh versions\n", + " if (Bokeh != undefined && !reloading) {\n", + " var NewBokeh = root.Bokeh;\n", + " if (Bokeh.versions === undefined) {\n", + " Bokeh.versions = new Map();\n", + " }\n", + " if (NewBokeh.version !== Bokeh.version) {\n", + " Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", + " }\n", + " root.Bokeh = Bokeh;\n", + " }\n", + " } else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " }\n", + " root._bokeh_is_initializing = false\n", + " }\n", + "\n", + " function load_or_wait() {\n", + " // Implement a backoff loop that tries to ensure we do not load multiple\n", + " // versions of Bokeh and its dependencies at the same time.\n", + " // In recent versions we use the root._bokeh_is_initializing flag\n", + " // to determine whether there is an ongoing attempt to initialize\n", + " // bokeh, however for backward compatibility we also try to ensure\n", + " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", + " // before older versions are fully initialized.\n", + " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", + " // If the timeout and bokeh was not successfully loaded we reset\n", + " // everything and try loading again\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_is_initializing = false;\n", + " root._bokeh_onload_callbacks = undefined;\n", + " root._bokeh_is_loading = 0\n", + " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", + " load_or_wait();\n", + " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", + " setTimeout(load_or_wait, 100);\n", + " } else {\n", + " root._bokeh_is_initializing = true\n", + " root._bokeh_onload_callbacks = []\n", + " const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n", + " if (!reloading && !bokeh_loaded) {\n", + " if (root.Bokeh) {\n", + " root.Bokeh = undefined;\n", + " }\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " }\n", + " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", + " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + " run_inline_js();\n", + " });\n", + " }\n", + " }\n", + " // Give older versions of the autoload script a head-start to ensure\n", + " // they initialize before we start loading newer version.\n", + " setTimeout(load_or_wait, 100)\n", + "}(window));" + ], + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = false;\n const py_version = '3.7.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = true;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.6.2/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", + " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", + "}\n", + "\n", + "\n", + " function JupyterCommManager() {\n", + " }\n", + "\n", + " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", + " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " comm_manager.register_target(comm_id, function(comm) {\n", + " comm.on_msg(msg_handler);\n", + " });\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", + " comm.onMsg = msg_handler;\n", + " });\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " console.log(message)\n", + " var content = {data: message.data, comm_id};\n", + " var buffers = []\n", + " for (var buffer of message.buffers || []) {\n", + " buffers.push(new DataView(buffer))\n", + " }\n", + " var metadata = message.metadata || {};\n", + " var msg = {content, buffers, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " })\n", + " }\n", + " }\n", + "\n", + " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", + " if (comm_id in window.PyViz.comms) {\n", + " return window.PyViz.comms[comm_id];\n", + " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", + " if (msg_handler) {\n", + " comm.on_msg(msg_handler);\n", + " }\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", + " comm.open();\n", + " if (msg_handler) {\n", + " comm.onMsg = msg_handler;\n", + " }\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", + " comm_promise.then((comm) => {\n", + " window.PyViz.comms[comm_id] = comm;\n", + " if (msg_handler) {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " var content = {data: message.data};\n", + " var metadata = message.metadata || {comm_id};\n", + " var msg = {content, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " })\n", + " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", + " return comm_promise.then((comm) => {\n", + " comm.send(data, metadata, buffers, disposeOnDone);\n", + " });\n", + " };\n", + " var comm = {\n", + " send: sendClosure\n", + " };\n", + " }\n", + " window.PyViz.comms[comm_id] = comm;\n", + " return comm;\n", + " }\n", + " window.PyViz.comm_manager = new JupyterCommManager();\n", + " \n", + "\n", + "\n", + "var JS_MIME_TYPE = 'application/javascript';\n", + "var HTML_MIME_TYPE = 'text/html';\n", + "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", + "var CLASS_NAME = 'output';\n", + "\n", + "/**\n", + " * Render data to the DOM node\n", + " */\n", + "function render(props, node) {\n", + " var div = document.createElement(\"div\");\n", + " var script = document.createElement(\"script\");\n", + " node.appendChild(div);\n", + " node.appendChild(script);\n", + "}\n", + "\n", + "/**\n", + " * Handle when a new output is added\n", + " */\n", + "function handle_add_output(event, handle) {\n", + " var output_area = handle.output_area;\n", + " var output = handle.output;\n", + " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + " if (id !== undefined) {\n", + " var nchildren = toinsert.length;\n", + " var html_node = toinsert[nchildren-1].children[0];\n", + " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var scripts = [];\n", + " var nodelist = html_node.querySelectorAll(\"script\");\n", + " for (var i in nodelist) {\n", + " if (nodelist.hasOwnProperty(i)) {\n", + " scripts.push(nodelist[i])\n", + " }\n", + " }\n", + "\n", + " scripts.forEach( function (oldScript) {\n", + " var newScript = document.createElement(\"script\");\n", + " var attrs = [];\n", + " var nodemap = oldScript.attributes;\n", + " for (var j in nodemap) {\n", + " if (nodemap.hasOwnProperty(j)) {\n", + " attrs.push(nodemap[j])\n", + " }\n", + " }\n", + " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", + " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", + " oldScript.parentNode.replaceChild(newScript, oldScript);\n", + " });\n", + " if (JS_MIME_TYPE in output.data) {\n", + " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", + " }\n", + " output_area._hv_plot_id = id;\n", + " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", + " window.PyViz.plot_index[id] = Bokeh.index[id];\n", + " } else {\n", + " window.PyViz.plot_index[id] = null;\n", + " }\n", + " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " var bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var script_attrs = bk_div.children[0].attributes;\n", + " for (var i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + "function handle_clear_output(event, handle) {\n", + " var id = handle.cell.output_area._hv_plot_id;\n", + " var server_id = handle.cell.output_area._bokeh_server_id;\n", + " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", + " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", + " if (server_id !== null) {\n", + " comm.send({event_type: 'server_delete', 'id': server_id});\n", + " return;\n", + " } else if (comm !== null) {\n", + " comm.send({event_type: 'delete', 'id': id});\n", + " }\n", + " delete PyViz.plot_index[id];\n", + " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", + " var doc = window.Bokeh.index[id].model.document\n", + " doc.clear();\n", + " const i = window.Bokeh.documents.indexOf(doc);\n", + " if (i > -1) {\n", + " window.Bokeh.documents.splice(i, 1);\n", + " }\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle kernel restart event\n", + " */\n", + "function handle_kernel_cleanup(event, handle) {\n", + " delete PyViz.comms[\"hv-extension-comm\"];\n", + " window.PyViz.plot_index = {}\n", + "}\n", + "\n", + "/**\n", + " * Handle update_display_data messages\n", + " */\n", + "function handle_update_output(event, handle) {\n", + " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", + " handle_add_output(event, handle)\n", + "}\n", + "\n", + "function register_renderer(events, OutputArea) {\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " var toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[0]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " events.on('output_added.OutputArea', handle_add_output);\n", + " events.on('output_updated.OutputArea', handle_update_output);\n", + " events.on('clear_output.CodeCell', handle_clear_output);\n", + " events.on('delete.Cell', handle_clear_output);\n", + " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", + "\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " safe: true,\n", + " index: 0\n", + " });\n", + "}\n", + "\n", + "if (window.Jupyter !== undefined) {\n", + " try {\n", + " var events = require('base/js/events');\n", + " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " } catch(err) {\n", + " }\n", + "}\n" + ], + "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n })\n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025.6.0\n" + ] + } + ], + "source": [ + "import os, sys\n", + "import shutil\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "import numpy as np\n", + "import xarray as xr\n", + "import xesmf as xe\n", + "\n", + "# Helpful for plotting only\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "import cartopy\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "import uxarray as ux #need npl 2024a or later\n", + "import geoviews.feature as gf\n", + "\n", + "print(ux.__version__)\n", + "#sys.path.append('/glade/u/home/wwieder/python/adf/lib/plotting_functions.py')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "07650a02-db90-4ee9-8880-e3f4ac140871", + "metadata": {}, + "outputs": [], + "source": [ + "# Load datataset\n", + "# TODO, load with adf tools and config file options\n", + "h0_file='/glade/derecho/scratch/wwieder/archive/ctsm5.4_5.3.068_PPEcal115_116_HIST/lnd/hist/ctsm5.4_5.3.068_PPEcal115_116_HIST.clm2.h0a.1930-11.nc'\n", + "#laih1file='/glade/derecho/scratch/wwieder/ctsm53n04ctsm52028_ne30pg3t232_hist.clm2.h1.TLAI.1860s.nc'\n", + "laih1file='/glade/derecho/scratch/wwieder/TLAI_cat/ctsm5.4_5.3.068_PPEcal115_116_HIST.clm2.h1a.TLAI.1850s.nc'\n", + "case = 'ctsm5.4_5.3.068_PPEcal115_116_HIST'\n", + "\n", + "mesh0 = '/glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc'\n", + "\n", + "#ux file for plotting\n", + "uxds0 = ux.open_dataset(mesh0, h0_file).max('time')\n", + "uxds1 = ux.open_dataset(mesh0, laih1file).max('time')\n", + "\n", + "# Assign coords to uxds0, which will be needed later for align() operation\n", + "n_face_coords = np.arange(1,(uxds1.pfts1d_ixy.max().astype(int)+1))\n", + "uxds0 = uxds0.assign_coords({'n_face': ('n_face', n_face_coords)})\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "66066158-c9d6-4dba-9c70-53aeeae4456a", + "metadata": {}, + "outputs": [], + "source": [ + "def reshape_ux_h1(uxds1, uxds0, var='TLAI', npft=15):\n", + " \"\"\"\n", + " Reshape unstructured data from h1 history files:\n", + " - Inputs 1d data from uxarray dataset (pft) into\n", + " - Returns 2d uxarray dataset (pft x n_face)\n", + " - Also include area + landfrac data, taken here from h0 dataset\n", + "\n", + " Requires h1 and h0 datasets that include the target variable\n", + " By default this function only runs on the native pfts\n", + "\n", + " \"\"\"\n", + "\n", + " for i in range(1, npft):\n", + " temp = uxds1.where(uxds1.pfts1d_itype_veg==i, drop=True)\n", + " # TODO, PFT weights should be time evolving, but they aren't here\n", + " # Rename coord, since the pft dimension is not meaningful\n", + " temp= temp.rename({'pft': 'n_face'})\n", + "\n", + " # assign values from pfts1d_ixy to n_face\n", + " temp['n_face'] = temp.pfts1d_ixy.astype(int)\n", + " temp.assign_coords({\"npft\": i})\n", + "\n", + " # combine along PFT variable\n", + " if i == 1:\n", + " uxdsOut = temp\n", + " else:\n", + " uxdsOut = xr.concat([uxdsOut, temp], dim=\"npft\")\n", + "\n", + " uxdsOut.uxgrid = temp.uxgrid\n", + " uxdsOut, _ = xr.align(uxdsOut, uxds0[var], join=\"right\")\n", + " # now copy over area & landfrac\n", + " uxdsOut['area'] = uxds0.area\n", + " uxdsOut['landfrac'] = uxds0.landfrac\n", + " return uxdsOut" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a7921508-b630-4bc2-8549-747ad577184f", + "metadata": {}, + "outputs": [], + "source": [ + "# Call the reshape_ux_h1 function\n", + "npft=15\n", + "var='TLAI'\n", + "uxdsOut = reshape_ux_h1(uxds1, uxds0, var, npft)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f847e56b-d807-4dab-8be1-e3d1cfeb5b71", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"\\nOr hard code them\\npft_names = ['NET Temperate', 'NET Boreal', 'NDT Boreal',\\n 'BET Tropical', 'BET Temperate', 'BDT Tropical',\\n 'BDT Temperate', 'BDT Boreal', 'BES Temperate',\\n 'BDS Temperate', 'BDS Boreal', 'C3 Grass Arctic',\\n 'C3 Grass', 'C4 Grass', 'UCrop UIrr']\\n\"" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Read in pft names\n", + "pft_constants = xr.open_dataset(\n", + " '/glade/campaign/cesm/cesmdata/cseg/inputdata/lnd/clm2/paramdata/ctsm60_params.c241017.nc')\n", + "pft_names = pft_constants.pftname\n", + "\n", + "'''\n", + "Or hard code them\n", + "pft_names = ['NET Temperate', 'NET Boreal', 'NDT Boreal',\n", + " 'BET Tropical', 'BET Temperate', 'BDT Tropical',\n", + " 'BDT Temperate', 'BDT Boreal', 'BES Temperate',\n", + " 'BDS Temperate', 'BDS Boreal', 'C3 Grass Arctic',\n", + " 'C3 Grass', 'C4 Grass', 'UCrop UIrr']\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "55ceea85-e3e2-4e2e-a88c-03c1313acf31", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO Add this to ADF plotting functions?\n", + "def plot_ux_survival(uxdsOut, case=case, var='TLAI', npft = 15,\n", + " pft_names = pft_names, min_pft_wgt = 0.05):\n", + " '''\n", + " Accepts reshaped h1 file from unstructured grid\n", + " - Also requires case name, variable, and PFT names (strings), and\n", + " - min value for PFT weights (fraction of grid cell) as a mask\n", + " Currently hard coded to make nice PFT survival plots, but \n", + " Could be adapted for more general subgid output\n", + " '''\n", + "\n", + " # Basic plot settings\n", + " transform = ccrs.PlateCarree()\n", + " proj = ccrs.PlateCarree()\n", + " cmap = plt.cm.viridis_r\n", + " cmap.set_under(color='deeppink')\n", + " cmap = cmap.resampled(7)\n", + " levels = [0.1, 1, 2, 3, 4, 5, 6, 7]\n", + "\n", + " # create figure object\n", + " fig, axs = plt.subplots(5,3,\n", + " facecolor=\"w\",\n", + " constrained_layout=True,\n", + " subplot_kw=dict(projection=proj),\n", + " dpi=300)\n", + "\n", + " axs=axs.flatten()\n", + "\n", + " # Loop over pfts\n", + " for i in range((npft-1)):\n", + " # Calculate weights bases on area, landfrac and min_pft_wgt\n", + " pft_wgt = uxdsOut.pfts1d_wtgcell.isel(npft=i)\n", + " pft_wgt = pft_wgt.where(pft_wgt >= min_pft_wgt)\n", + " wgts = uxdsOut.area * uxdsOut.landfrac * pft_wgt\n", + " wgts = wgts / wgts.sum()\n", + "\n", + " # Plots where LAI > min_wgt on grid\n", + " axs[i].set_global()\n", + " plot_var = uxdsOut[var].isel(npft=i).where(pft_wgt >= min_pft_wgt)\n", + " raster = plot_var.to_raster(ax=axs[i])\n", + " img = axs[i].imshow(\n", + " raster, cmap=cmap, origin=\"lower\", extent=axs[i].get_xlim() + axs[i].get_ylim()\n", + " )\n", + " img.set_clim(vmin=0.1,vmax=6.9)\n", + "\n", + " # Add titles (pft names) & statistics (mean LAI & survival)\n", + " mean = str(np.round((uxdsOut[var].isel(npft=i)*wgts).sum().values,2))\n", + " dead = ((uxdsOut[var].isel(npft=i)<0.1)*wgts).sum()\n", + " live = ((uxdsOut[var].isel(npft=i)>0.1)*wgts).sum()\n", + " livefrac = str(np.round((live/(live+dead)).values,2))\n", + " axs[i].set_title(str(pft_names[(1+i)].data)[12:50], loc='left',size=6)\n", + " axs[i].text(-30, -45,'mean = '+ mean, fontsize=5)\n", + " axs[i].text(-45, -60,'live frac = '+livefrac,fontsize=5)\n", + "\n", + " # make panels look nice\n", + " for a in axs:\n", + " a.coastlines().set_linewidth(0.1)\n", + " a.set_global()\n", + " a.spines['geo'].set_linewidth(0.1) #cartopy's recommended method\n", + " a.set_extent([-180, 180, -65, 86])\n", + "\n", + " # add color bar with case name\n", + " fig.set_layout_engine(\"compressed\")\n", + " cbar_ax = fig.add_axes([0.94, 0.06, 0.02, 0.88])\n", + " cbar = fig.colorbar(img, cax=cbar_ax, pad=0.1, shrink=0.7, aspect=40, extend='both')\n", + " cbar.ax.tick_params(labelsize=9)\n", + " cbar.set_label(label=(\"max LAI \"+case), size=9, weight='bold')\n", + "\n", + " return fig\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1d2c3658-48a9-4ca9-931d-a592c46e1c60", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-- wrote pft TLAI figure --\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 32.1 s, sys: 115 ms, total: 32.2 s\n", + "Wall time: 39.7 s\n" + ] + } + ], + "source": [ + "%%time\n", + "# Call plotting function\n", + "fig = plot_ux_survival (uxdsOut = uxdsOut, case = case, var = var,\n", + " pft_names = pft_names, min_pft_wgt = 0.05)\n", + "save = True\n", + "# TODO add ADF plotting and webpage hooks\n", + "if (save == True):\n", + " fig.savefig('h1_test_raster', bbox_inches='tight', dpi=300)\n", + " print('-- wrote pft '+var+' figure --')\n", + "plt.show() ;" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1ef215e-562c-4702-a6a4-73389e9c7d2b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93c009b2-f94f-49d5-8810-16c44a3f4c92", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:cupid-analysis]", + "language": "python", + "name": "conda-env-cupid-analysis-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}