From 3de24cbe96461f61b780d826bf37fb852e5f6a35 Mon Sep 17 00:00:00 2001 From: Erik Koene Date: Fri, 13 Sep 2024 17:43:13 +0200 Subject: [PATCH 01/42] Added file structure for CTDAS case --- jobs/CTDAS.py | 45 +++++++++++++++++++++++++++++++++++++++++++ jobs/prepare_CTDAS.py | 0 2 files changed, 45 insertions(+) create mode 100644 jobs/CTDAS.py create mode 100644 jobs/prepare_CTDAS.py diff --git a/jobs/CTDAS.py b/jobs/CTDAS.py new file mode 100644 index 00000000..9b9024c1 --- /dev/null +++ b/jobs/CTDAS.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +import os +import logging +import xarray as xr +import shutil +import subprocess +from . import tools, prepare_icon +from pathlib import Path # noqa: F401 +from .tools.interpolate_data import create_oh_for_restart, create_oh_for_inicond # noqa: F401 +from .tools.fetch_external_data import fetch_era5, fetch_era5_nudging + +BASIC_PYTHON_JOB = False + + +def main(cfg): + """ + Prepare CTDAS inversion + + This does the following steps: + 1. Run the first day (spin-up) + 2. Start CTDAS + + Parameters + ---------- + cfg : Config + Object holding all user-configuration parameters as attributes. + """ + prepare_icon.set_cfg_variables(cfg) + tools.change_logfile(cfg.logfile) + logging.info("Prepare ICON-ART for global simulations") + + # -- Download ERA5 data and create the inicond file + if cfg.era5_inicond and cfg.lrestart == '.FALSE.': + # -- Fetch ERA5 data + fetch_era5(cfg.startdate_sim, cfg.icon_input_icbc) + + # -- Copy ERA5 processing script (icon_era5_inicond.job) in workdir + with open(cfg.icon_era5_inijob) as input_file: + to_write = input_file.read() + output_file = os.path.join(cfg.icon_input_icbc, 'icon_era5_inicond.sh') + with open(output_file, "w") as outf: + outf.write(to_write.format(cfg=cfg)) + diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py new file mode 100644 index 00000000..e69de29b From fadf82e42eb8400bca5089d509c284e84b7faa3a Mon Sep 17 00:00:00 2001 From: github-actions Date: Fri, 13 Sep 2024 15:44:03 +0000 Subject: [PATCH 02/42] GitHub Action: Apply Pep8-formatting --- jobs/CTDAS.py | 1 - 1 file changed, 1 deletion(-) diff --git a/jobs/CTDAS.py b/jobs/CTDAS.py index 9b9024c1..355aaf14 100644 --- a/jobs/CTDAS.py +++ b/jobs/CTDAS.py @@ -42,4 +42,3 @@ def main(cfg): output_file = os.path.join(cfg.icon_input_icbc, 'icon_era5_inicond.sh') with open(output_file, "w") as outf: outf.write(to_write.format(cfg=cfg)) - From d548dc4474dfc7de6324deb604b9f0ce1b7b3061 Mon Sep 17 00:00:00 2001 From: Erik Koene Date: Mon, 16 Sep 2024 17:08:03 +0200 Subject: [PATCH 03/42] Added fetching jobs for CAMS and ICOS --- env/environment.yml | 4 +- jobs/prepare_CTDAS.py | 138 ++++++++++++++++++++++++ jobs/tools/fetch_external_data.py | 171 ++++++++++++++++++++++++++++++ 3 files changed, 311 insertions(+), 2 deletions(-) diff --git a/env/environment.yml b/env/environment.yml index 98b90e44..c00bea76 100644 --- a/env/environment.yml +++ b/env/environment.yml @@ -4,8 +4,6 @@ channels: - defaults dependencies: - python=3.11 - - cdo - - nco - numpy - cartopy - matplotlib @@ -19,3 +17,5 @@ dependencies: - sphinx - sphinx_rtd_theme - sphinx-copybutton + - pip: + - icoscp \ No newline at end of file diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index e69de29b..9a8a1349 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -0,0 +1,138 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +import os +import logging +import xarray as xr +import shutil +import subprocess +from . import tools, prepare_icon +from pathlib import Path # noqa: F401 +from .tools.interpolate_data import create_oh_for_restart, create_oh_for_inicond # noqa: F401 +from .tools.fetch_external_data import fetch_era5, fetch_era5_nudging, fetch_CAMS_CO2, fetch_ICOS + +BASIC_PYTHON_JOB = True + +def main(cfg): + """ + Prepare CTDAS inversion + + This does the following steps: + 1. Download ERA-5 data for the chosen dates + 2. Download CAMS data for the chosen dates + 3. Interpolate CAMS data to the ERA-5 location (horizontally and vertically) + 4. Download ICOS station data for the chosen dates + 5. Prepare the folder output structure + + Parameters + ---------- + cfg : Config + Object holding all user-configuration parameters as attributes. + """ + prepare_icon.set_cfg_variables(cfg) + tools.change_logfile(cfg.logfile) + logging.info("Prepare ICON-ART for CTDAS") + + # -- 1. Download ERA5 data and create the initial conditions file + if cfg.era5_inicond: + # -- Fetch ERA5 data + fetch_era5(cfg.startdate_sim, cfg.icon_input_icbc) + + # -- Copy ERA5 processing script (icon_era5_inicond.job) in workdir + with open(cfg.icon_era5_inijob) as input_file: + to_write = input_file.read() + output_file = os.path.join(cfg.icon_input_icbc, 'icon_era5_inicond.sh') + with open(output_file, "w") as outf: + outf.write(to_write.format(cfg=cfg)) + + # -- Copy mypartab in workdir + shutil.copy( + os.path.join(os.path.dirname(cfg.icon_era5_inijob), 'mypartab'), + os.path.join(cfg.icon_input_icbc, 'mypartab')) + + # -- Run ERA5 processing script + process = subprocess.Popen([ + "bash", + os.path.join(cfg.icon_input_icbc, 'icon_era5_inicond.sh') + ], + stdout=subprocess.PIPE) + process.communicate() + + # -- 2. Download CAMS CO2 data + if cfg.cams_inicond: + fetch_CAMS_CO2(cfg.startdate_sim, cfg.icon_input_icbc) + + # ((( Is there an interpolation step missing for inicond? I assume so...))) + + # -- 3. If global nudging, download and process ERA5 and CAMS data + if cfg.era5_cams_nudging: + for time in tools.iter_hours(cfg.startdate_sim, + cfg.enddate_sim, + step=cfg.nudging_step): + + # -- Give a name to the nudging file + timestr = time.strftime('%Y%m%d%H') + filename = 'era_{timestr}_nudging.nc'.format( + timestr=timestr) + + # -- If initial time, copy the initial conditions to be used as boundary conditions + if time == cfg.startdate_sim and cfg.era5_inicond: + shutil.copy(cfg.input_files_scratch_inicond_filename, + os.path.join(cfg.icon_input_icbc, filename)) + continue + + # -- Fetch ERA5 data + fetch_era5_nudging(time, cfg.icon_input_icbc) + + # -- Copy ERA5 processing script (icon_era5_nudging.job) in workdir + with open(cfg.icon_era5_nudgingjob) as input_file: + to_write = input_file.read() + output_file = os.path.join( + cfg.icon_input_icbc, 'icon_era5_nudging_{}.sh'.format(timestr)) + with open(output_file, "w") as outf: + outf.write(to_write.format(cfg=cfg, filename=filename)) + + # -- Copy mypartab in workdir + if not os.path.exists(os.path.join(cfg.icon_input_icbc, + 'mypartab')): + shutil.copy( + os.path.join(os.path.dirname(cfg.icon_era5_nudgingjob), + 'mypartab'), + os.path.join(cfg.icon_input_icbc, 'mypartab')) + + # -- Run ERA5 processing script + process = subprocess.Popen([ + "bash", + os.path.join(cfg.icon_input_icbc, + 'icon_era5_nudging_{}.sh'.format(timestr)) + ], + stdout=subprocess.PIPE) + process.communicate() + + # -- Copy CAMS processing script (icon_cams_nudging.job) in workdir + with open(cfg.icon_species_nudgingjob) as input_file: + to_write = input_file.read() + output_file = os.path.join( + cfg.icon_input_icbc, + 'icon_cams_nudging_{}.sh'.format(timestr)) + with open(output_file, "w") as outf: + outf.write(to_write.format(cfg=cfg, filename=filename)) + + # -- Run CAMS processing script + process = subprocess.Popen([ + "bash", + os.path.join(cfg.icon_input_icbc, + 'icon_cams_nudging_{}.sh'.format(timestr)) + ], + stdout=subprocess.PIPE) + process.communicate() + + # -- 4. Download ICOS CO2 data + if cfg.fetch_ICOS: + # -- This requires you to have accepted the ICOS license in your profile. + # So, login to https://cpauth.icos-cp.eu/home/ , check the box, and + # copy the cookie token on the bottom as your ICOS_cookie_token. + fetch_ICOS(cookie_token=cfg.ICOS_cookie_token, + start_date=cfg.startdate_sim, end_date=cfg.enddate_sim, save_path=cfg.ICOS_path, species=['co2',]) + + logging.info("OK") \ No newline at end of file diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index b3cfdc41..d6b8c60b 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -1,6 +1,16 @@ import os import shutil import cdsapi +import zipfile +import logging +import xarray as xr +from icoscp.dobj import Dobj +from icoscp.sparql.runsparql import RunSparql +from icoscp_core.icos import bootstrap +from icoscp import cpauth +import numpy as np + +from datetime import datetime, timedelta def fetch_era5(date, dir2move): @@ -113,3 +123,164 @@ def fetch_era5_nudging(date, dir2move): os.path.join(dir2move, 'era5_ml_nudging.grib')) shutil.move('era5_surf_nudging.grib', os.path.join(dir2move, 'era5_surf_nudging.grib')) + + +def fetch_CAMS_CO2(date, dir2move): + """Fetch CAMS CO2 data from ECMWF for initial and boundary conditions + + Parameters + ---------- + date : initial date to fetch a year's worth of data + + """ + + # Set a temporary destionation + tmpdir = os.path.join(os.getenv('SCRATCH'), 'CAMS_i') + if not os.path.exists(tmpdir): + os.makedirs(tmpdir) + + c = cdsapi.Client() + + download = os.path.join(tmpdir,f'cams_GHG_{date.strftime("%Y")}.zip') + if not os.path.isfile(download): + c.retrieve( + 'cams-global-greenhouse-gas-inversion', + { + 'variable': 'carbon_dioxide', + 'quantity': 'concentration', + 'input_observations': 'surface', + 'time_aggregation': 'instantaneous', + 'version': 'latest', + 'year': date.strftime('%Y'), + 'month': [ + '01', '02', '03', + '04', '05', '06', + '07', '08', '09', + '10', '11', '12', + ], + 'format': 'zip', + }, + download) + logging.info(f'downloaded the CAMS data!') + else: + logging.info(f'File already downloaded and present at {download}') + + # --- Extract the zip file + with zipfile.ZipFile(download) as zf: + for member in zf.infolist(): + if not os.path.isfile(os.path.join(tmpdir,member.filename)): + try: + zf.extract(member, tmpdir) + except zipfile.error as e: + pass + + # --- Output files to folder + with zipfile.ZipFile(download) as zf: + for member in zf.infolist(): + filename = os.path.join(tmpdir,member.filename) + logging.info("Writing out CAMS data to file") + ds_CAMS = xr.open_dataset(filename) + for time in ds_CAMS.time: + outpath = os.path.join(dir2move,'cams_egg4_'+ds_CAMS.sel(time=time).time.dt.strftime('%Y%m%d%H').values+'.nc') + if not os.path.isfile(outpath): + ds_out = ds_CAMS.where( ds_CAMS.time == time, drop=True ).squeeze() + ds_out.to_netcdf(outpath) + + +def fetch_ICOS_data(cookie_token, query_type='any',start_date='01-01-2022', end_date='31-12-2022', save_path='', species=['co', 'co2', 'ch4']): + ''' + This script starts a SPARQL query for downloading ICOS-CP data. The query is based on searching at the ICOS-CP + (e.g., https://data.icos-cp.eu/portal/#%7B%22filterCategories%22%3A%7B%22variable%22%3A%5B%22http%3A%2F%2Fmeta.icos-cp.eu%2Fresources%2Fcpmeta%2Fco2atcMoleFrac%22%5D%7D%2C%22filterTemporal%22%3A%7B%22df%22%3A%222017-12-31%22%2C%22dt%22%3A%222018-12-30%22%7D%7D) + and then clicking the well-hidden SPARQL query button (situated right of "Data objects 1 to 20 of 167", consisting of an arrow.) + + cookie_token str cpauthToken=WzE3M.... + query_type str [release, growing, any] correspond to the different file products at the ICOS-CP + start_date str dd-mm-yyyy + end_date str dd-mm-yyyy + save_path str e.g., /scratch/snx/[user]/ICOS_data/year/ + species list can be ['co', 'co2', 'ch4'] or any subset thereof + ''' + meta, data = bootstrap.fromCookieToken(cookie_token) + cpauth.init_by(data.auth) + # --- Build up an SQL query for the different species + qd = "" + for specie in species: + qd += f" + prefix prov: + prefix xsd: + select ?dobj ?hasNextVersion ?spec ?fileName ?size ?submTime ?timeStart ?timeEnd + where {{ + VALUES ?spec {{{0}}} + ?dobj cpmeta:hasObjectSpec ?spec . + BIND(EXISTS{{[] cpmeta:isNextVersionOf ?dobj}} AS ?hasNextVersion) + ?dobj cpmeta:hasSizeInBytes ?size . + ?dobj cpmeta:hasName ?fileName . + ?dobj cpmeta:wasSubmittedBy/prov:endedAtTime ?submTime . + ?dobj cpmeta:hasStartTime | (cpmeta:wasAcquiredBy / prov:startedAtTime) ?timeStart . + ?dobj cpmeta:hasEndTime | (cpmeta:wasAcquiredBy / prov:endedAtTime) ?timeEnd . + FILTER NOT EXISTS {{[] cpmeta:isNextVersionOf ?dobj}} + FILTER( !(?timeStart > '{1}T23:00:00.000Z'^^xsd:dateTime || ?timeEnd < '2017-12-31T23:00:00.000Z'^^xsd:dateTime) ) + + }} + order by desc(?submTime) + '''.format(qd, + (datetime.strptime(start_date, '%d-%m-%Y').date() - timedelta(days=1)).strftime('%Y-%m-%d'), + (datetime.strptime(end_date, '%d-%m-%Y').date() ).strftime('%Y-%m-%d')) + + # --- Run the SQL query + result = RunSparql(query, 'pandas') + result.run() + result.data() + + # --- Loop over the different stations (see https://icos-carbon-portal.github.io/pylib/ for more details) + if not os.path.exists(save_path): + os.makedirs(save_path) + + for d in result.data()['dobj']: + obj = Dobj(d).data + + shape = np.shape(obj) + + lon = Dobj(d).lon + lat = Dobj(d).lat + variables = Dobj(d).variables.to_numpy() + Names=Dobj(d).colNames + specie = set(Names)-set(Names).difference(species) + meta = np.squeeze([x for x in variables if set(species) - set(x) != set(species)]) + ds = xr.Dataset.from_dataframe(obj) # This contains the data... + # --- Cleanup of the dataframe... + ds = ds.set_index(index='TIMESTAMP') + ds = ds.sortby(ds.index) + ds = ds.drop_duplicates(dim="index") + # --- Subset to the timeframe of interest (this has no reason to fail, so you'll have to check these cases manually....) + try: + ds = ds.sel(index=slice(datetime.strptime(start_date,'%d-%m-%Y').date().strftime('%Y-%m-%d'), + datetime.strptime(end_date, '%d-%m-%Y').date().strftime('%Y-%m-%d'))) + except: + print('failure!') + print(ds.index) + print(f"Not doing {Dobj(d).station['id']}, then...?") + break + ds = ds.rename({'index': 'time'}) + # --- Write out further attributes + ds.attrs['Description'] = meta[2] + ds.attrs['Units'] = meta[1] + ds.attrs['Station'] = Dobj(d).station['id'] + ds.attrs['Full name of the station'] = Dobj(d).station['org']['name'] + ds.attrs['Elevation above sea level'] = Dobj(d).alt + ds.attrs['Sampling height over ground'] = Dobj(d).meta['specificInfo']['acquisition']['samplingHeight'] + ds.attrs['Sampling height over sea level'] = float(Dobj(d).meta['specificInfo']['acquisition']['samplingHeight']) + float(Dobj(d).alt) + ds.attrs['Longitude'] = Dobj(d).lon + ds.attrs['Latitude'] = Dobj(d).lat + ds.attrs['Name of the tracer'] = meta[0] + name = 'ICOS_obs_' + str(specie)[2:-2] + '_' + query_type + '_' + str(Dobj(d).station['id']) + '_' + str(Dobj(d).meta['specificInfo']['acquisition']['samplingHeight']) + '_' + start_date + '_' + end_date + '.nc' + ds.to_netcdf(os.path.join(save_path, name)) From bbfe9b6ded4dc7bc7a427995354d2a68090d6d36 Mon Sep 17 00:00:00 2001 From: Erik Koene Date: Mon, 16 Sep 2024 17:12:00 +0200 Subject: [PATCH 04/42] added xarray dependency --- jobs/prepare_CTDAS.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index 9a8a1349..38f30e2a 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -22,7 +22,8 @@ def main(cfg): 2. Download CAMS data for the chosen dates 3. Interpolate CAMS data to the ERA-5 location (horizontally and vertically) 4. Download ICOS station data for the chosen dates - 5. Prepare the folder output structure + 5. Download OCO-2 data for the chosen dates + 6. Prepare the folder output structure Parameters ---------- From d41f4556fb9a97e7b262ce8d4c7f63d57b3e007c Mon Sep 17 00:00:00 2001 From: github-actions Date: Mon, 16 Sep 2024 15:12:34 +0000 Subject: [PATCH 05/42] GitHub Action: Apply Pep8-formatting --- jobs/prepare_CTDAS.py | 26 ++++--- jobs/tools/fetch_external_data.py | 119 +++++++++++++++++++----------- 2 files changed, 91 insertions(+), 54 deletions(-) diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index 38f30e2a..a4c444b3 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -13,6 +13,7 @@ BASIC_PYTHON_JOB = True + def main(cfg): """ Prepare CTDAS inversion @@ -58,7 +59,7 @@ def main(cfg): ], stdout=subprocess.PIPE) process.communicate() - + # -- 2. Download CAMS CO2 data if cfg.cams_inicond: fetch_CAMS_CO2(cfg.startdate_sim, cfg.icon_input_icbc) @@ -73,8 +74,7 @@ def main(cfg): # -- Give a name to the nudging file timestr = time.strftime('%Y%m%d%H') - filename = 'era_{timestr}_nudging.nc'.format( - timestr=timestr) + filename = 'era_{timestr}_nudging.nc'.format(timestr=timestr) # -- If initial time, copy the initial conditions to be used as boundary conditions if time == cfg.startdate_sim and cfg.era5_inicond: @@ -114,8 +114,7 @@ def main(cfg): with open(cfg.icon_species_nudgingjob) as input_file: to_write = input_file.read() output_file = os.path.join( - cfg.icon_input_icbc, - 'icon_cams_nudging_{}.sh'.format(timestr)) + cfg.icon_input_icbc, 'icon_cams_nudging_{}.sh'.format(timestr)) with open(output_file, "w") as outf: outf.write(to_write.format(cfg=cfg, filename=filename)) @@ -123,17 +122,22 @@ def main(cfg): process = subprocess.Popen([ "bash", os.path.join(cfg.icon_input_icbc, - 'icon_cams_nudging_{}.sh'.format(timestr)) + 'icon_cams_nudging_{}.sh'.format(timestr)) ], - stdout=subprocess.PIPE) + stdout=subprocess.PIPE) process.communicate() # -- 4. Download ICOS CO2 data if cfg.fetch_ICOS: # -- This requires you to have accepted the ICOS license in your profile. - # So, login to https://cpauth.icos-cp.eu/home/ , check the box, and + # So, login to https://cpauth.icos-cp.eu/home/ , check the box, and # copy the cookie token on the bottom as your ICOS_cookie_token. fetch_ICOS(cookie_token=cfg.ICOS_cookie_token, - start_date=cfg.startdate_sim, end_date=cfg.enddate_sim, save_path=cfg.ICOS_path, species=['co2',]) - - logging.info("OK") \ No newline at end of file + start_date=cfg.startdate_sim, + end_date=cfg.enddate_sim, + save_path=cfg.ICOS_path, + species=[ + 'co2', + ]) + + logging.info("OK") diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index d6b8c60b..2ef1d96b 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -5,7 +5,7 @@ import logging import xarray as xr from icoscp.dobj import Dobj -from icoscp.sparql.runsparql import RunSparql +from icoscp.sparql.runsparql import RunSparql from icoscp_core.icos import bootstrap from icoscp import cpauth import numpy as np @@ -141,26 +141,39 @@ def fetch_CAMS_CO2(date, dir2move): c = cdsapi.Client() - download = os.path.join(tmpdir,f'cams_GHG_{date.strftime("%Y")}.zip') + download = os.path.join(tmpdir, f'cams_GHG_{date.strftime("%Y")}.zip') if not os.path.isfile(download): c.retrieve( - 'cams-global-greenhouse-gas-inversion', - { - 'variable': 'carbon_dioxide', - 'quantity': 'concentration', - 'input_observations': 'surface', - 'time_aggregation': 'instantaneous', - 'version': 'latest', - 'year': date.strftime('%Y'), + 'cams-global-greenhouse-gas-inversion', { + 'variable': + 'carbon_dioxide', + 'quantity': + 'concentration', + 'input_observations': + 'surface', + 'time_aggregation': + 'instantaneous', + 'version': + 'latest', + 'year': + date.strftime('%Y'), 'month': [ - '01', '02', '03', - '04', '05', '06', - '07', '08', '09', - '10', '11', '12', + '01', + '02', + '03', + '04', + '05', + '06', + '07', + '08', + '09', + '10', + '11', + '12', ], - 'format': 'zip', - }, - download) + 'format': + 'zip', + }, download) logging.info(f'downloaded the CAMS data!') else: logging.info(f'File already downloaded and present at {download}') @@ -168,7 +181,7 @@ def fetch_CAMS_CO2(date, dir2move): # --- Extract the zip file with zipfile.ZipFile(download) as zf: for member in zf.infolist(): - if not os.path.isfile(os.path.join(tmpdir,member.filename)): + if not os.path.isfile(os.path.join(tmpdir, member.filename)): try: zf.extract(member, tmpdir) except zipfile.error as e: @@ -177,17 +190,26 @@ def fetch_CAMS_CO2(date, dir2move): # --- Output files to folder with zipfile.ZipFile(download) as zf: for member in zf.infolist(): - filename = os.path.join(tmpdir,member.filename) + filename = os.path.join(tmpdir, member.filename) logging.info("Writing out CAMS data to file") ds_CAMS = xr.open_dataset(filename) for time in ds_CAMS.time: - outpath = os.path.join(dir2move,'cams_egg4_'+ds_CAMS.sel(time=time).time.dt.strftime('%Y%m%d%H').values+'.nc') + outpath = os.path.join( + dir2move, 'cams_egg4_' + + ds_CAMS.sel(time=time).time.dt.strftime('%Y%m%d%H').values + + '.nc') if not os.path.isfile(outpath): - ds_out = ds_CAMS.where( ds_CAMS.time == time, drop=True ).squeeze() + ds_out = ds_CAMS.where(ds_CAMS.time == time, + drop=True).squeeze() ds_out.to_netcdf(outpath) -def fetch_ICOS_data(cookie_token, query_type='any',start_date='01-01-2022', end_date='31-12-2022', save_path='', species=['co', 'co2', 'ch4']): +def fetch_ICOS_data(cookie_token, + query_type='any', + start_date='01-01-2022', + end_date='31-12-2022', + save_path='', + species=['co', 'co2', 'ch4']): ''' This script starts a SPARQL query for downloading ICOS-CP data. The query is based on searching at the ICOS-CP (e.g., https://data.icos-cp.eu/portal/#%7B%22filterCategories%22%3A%7B%22variable%22%3A%5B%22http%3A%2F%2Fmeta.icos-cp.eu%2Fresources%2Fcpmeta%2Fco2atcMoleFrac%22%5D%7D%2C%22filterTemporal%22%3A%7B%22df%22%3A%222017-12-31%22%2C%22dt%22%3A%222018-12-30%22%7D%7D) @@ -208,11 +230,11 @@ def fetch_ICOS_data(cookie_token, query_type='any',start_date='01-01-2022', end_ qd += f" prefix prov: @@ -232,39 +254,44 @@ def fetch_ICOS_data(cookie_token, query_type='any',start_date='01-01-2022', end_ }} order by desc(?submTime) - '''.format(qd, - (datetime.strptime(start_date, '%d-%m-%Y').date() - timedelta(days=1)).strftime('%Y-%m-%d'), - (datetime.strptime(end_date, '%d-%m-%Y').date() ).strftime('%Y-%m-%d')) + '''.format(qd, (datetime.strptime(start_date, '%d-%m-%Y').date() - + timedelta(days=1)).strftime('%Y-%m-%d'), + (datetime.strptime(end_date, + '%d-%m-%Y').date()).strftime('%Y-%m-%d')) # --- Run the SQL query result = RunSparql(query, 'pandas') result.run() result.data() - + # --- Loop over the different stations (see https://icos-carbon-portal.github.io/pylib/ for more details) if not os.path.exists(save_path): os.makedirs(save_path) for d in result.data()['dobj']: obj = Dobj(d).data - + shape = np.shape(obj) - + lon = Dobj(d).lon lat = Dobj(d).lat variables = Dobj(d).variables.to_numpy() - Names=Dobj(d).colNames - specie = set(Names)-set(Names).difference(species) - meta = np.squeeze([x for x in variables if set(species) - set(x) != set(species)]) - ds = xr.Dataset.from_dataframe(obj) # This contains the data... + Names = Dobj(d).colNames + specie = set(Names) - set(Names).difference(species) + meta = np.squeeze( + [x for x in variables if set(species) - set(x) != set(species)]) + ds = xr.Dataset.from_dataframe(obj) # This contains the data... # --- Cleanup of the dataframe... ds = ds.set_index(index='TIMESTAMP') ds = ds.sortby(ds.index) ds = ds.drop_duplicates(dim="index") # --- Subset to the timeframe of interest (this has no reason to fail, so you'll have to check these cases manually....) try: - ds = ds.sel(index=slice(datetime.strptime(start_date,'%d-%m-%Y').date().strftime('%Y-%m-%d'), - datetime.strptime(end_date, '%d-%m-%Y').date().strftime('%Y-%m-%d'))) + ds = ds.sel(index=slice( + datetime.strptime(start_date, '%d-%m-%Y').date().strftime( + '%Y-%m-%d'), + datetime.strptime(end_date, '%d-%m-%Y').date().strftime( + '%Y-%m-%d'))) except: print('failure!') print(ds.index) @@ -273,14 +300,20 @@ def fetch_ICOS_data(cookie_token, query_type='any',start_date='01-01-2022', end_ ds = ds.rename({'index': 'time'}) # --- Write out further attributes ds.attrs['Description'] = meta[2] - ds.attrs['Units'] = meta[1] + ds.attrs['Units'] = meta[1] ds.attrs['Station'] = Dobj(d).station['id'] ds.attrs['Full name of the station'] = Dobj(d).station['org']['name'] ds.attrs['Elevation above sea level'] = Dobj(d).alt - ds.attrs['Sampling height over ground'] = Dobj(d).meta['specificInfo']['acquisition']['samplingHeight'] - ds.attrs['Sampling height over sea level'] = float(Dobj(d).meta['specificInfo']['acquisition']['samplingHeight']) + float(Dobj(d).alt) + ds.attrs['Sampling height over ground'] = Dobj( + d).meta['specificInfo']['acquisition']['samplingHeight'] + ds.attrs['Sampling height over sea level'] = float( + Dobj(d).meta['specificInfo']['acquisition'] + ['samplingHeight']) + float(Dobj(d).alt) ds.attrs['Longitude'] = Dobj(d).lon ds.attrs['Latitude'] = Dobj(d).lat ds.attrs['Name of the tracer'] = meta[0] - name = 'ICOS_obs_' + str(specie)[2:-2] + '_' + query_type + '_' + str(Dobj(d).station['id']) + '_' + str(Dobj(d).meta['specificInfo']['acquisition']['samplingHeight']) + '_' + start_date + '_' + end_date + '.nc' + name = 'ICOS_obs_' + str(specie)[2:-2] + '_' + query_type + '_' + str( + Dobj(d).station['id']) + '_' + str( + Dobj(d).meta['specificInfo']['acquisition'] + ['samplingHeight']) + '_' + start_date + '_' + end_date + '.nc' ds.to_netcdf(os.path.join(save_path, name)) From 95eefe8eab3554fcf6200f04cab2a67277447034 Mon Sep 17 00:00:00 2001 From: Erik Koene Date: Wed, 18 Sep 2024 10:11:33 +0200 Subject: [PATCH 06/42] Added OCO2 downloader --- env/environment.yml | 6 +- jobs/prepare_CTDAS.py | 23 ++++- jobs/tools/fetch_external_data.py | 158 +++++++++++++++++++++++++++++- 3 files changed, 184 insertions(+), 3 deletions(-) diff --git a/env/environment.yml b/env/environment.yml index c00bea76..3bad9ad5 100644 --- a/env/environment.yml +++ b/env/environment.yml @@ -17,5 +17,9 @@ dependencies: - sphinx - sphinx_rtd_theme - sphinx-copybutton + - pip - pip: - - icoscp \ No newline at end of file + - icoscp + - requests + - urllib3 + - certifi \ No newline at end of file diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index a4c444b3..42037406 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -9,7 +9,7 @@ from . import tools, prepare_icon from pathlib import Path # noqa: F401 from .tools.interpolate_data import create_oh_for_restart, create_oh_for_inicond # noqa: F401 -from .tools.fetch_external_data import fetch_era5, fetch_era5_nudging, fetch_CAMS_CO2, fetch_ICOS +from .tools.fetch_external_data import fetch_era5, fetch_era5_nudging, fetch_CAMS_CO2, fetch_ICOS, fetch_external_data BASIC_PYTHON_JOB = True @@ -140,4 +140,25 @@ def main(cfg): 'co2', ]) + if cfg.fetch_OCO2: + # A user must do the following steps to allow + # from getpass import getpass + # import os + # from subprocess import Popen + # urs = 'urs.earthdata.nasa.gov' # Earthdata URL to call for authentication + # prompts = ['Enter NASA Earthdata Login Username \n(or create an account at urs.earthdata.nasa.gov): ', + # 'Enter NASA Earthdata Login Password: '] + # homeDir = os.path.expanduser("~") + os.sep + # with open(homeDir + '.netrc', 'w') as file: + # file.write('machine {} login {} password {}'.format(urs, getpass(prompt=prompts[0]), getpass(prompt=prompts[1]))) + # file.close() + # with open(homeDir + '.urs_cookies', 'w') as file: + # file.write('') + # file.close() + # with open(homeDir + '.dodsrc', 'w') as file: + # file.write('HTTP.COOKIEJAR={}.urs_cookies\n'.format(homeDir)) + # file.write('HTTP.NETRC={}.netrc'.format(homeDir)) + # file.close() + # Popen('chmod og-rw ~/.netrc', shell=True) + fetch_external_data.fetch_OCO2(x, y, -8, 30, 35, 65, "/capstor/scratch/cscs/ekoene/temp", product="OCO2_L2_Lite_FP_11.1r") logging.info("OK") diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 2ef1d96b..abc8dd1c 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -9,7 +9,14 @@ from icoscp_core.icos import bootstrap from icoscp import cpauth import numpy as np - +import sys +import json +import datetime +import certifi +import urllib3 +import requests +from time import sleep +from subprocess import Popen from datetime import datetime, timedelta @@ -317,3 +324,152 @@ def fetch_ICOS_data(cookie_token, Dobj(d).meta['specificInfo']['acquisition'] ['samplingHeight']) + '_' + start_date + '_' + end_date + '.nc' ds.to_netcdf(os.path.join(save_path, name)) + + +def fetch_OCO2(starttime, endtime, minlon, maxlon, minlat, maxlat, output_folder, product="OCO2_L2_Lite_FP_11r"): + + # hmm. Not currently working. The data is there, https://oco2.gesdisc.eosdis.nasa.gov/data/OCO2_DATA/OCO2_L2_Lite_FP.11.1r/2020/ + # but GES DISC doesn't currently have it anymore... + + # Set the product (based on the list above!) and other output settings + product = product # Standard + begTime = f'{starttime.strftime("%Y-%m-%d")}T00:00:00.000Z' + endTime = f'{endtime.strftime("%Y-%m-%d")}T23:59:59.999Z' + + # Create a urllib PoolManager instance to make requests. + http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',ca_certs=certifi.where()) + + # Set the URL for the GES DISC subset service endpoint + svcurl = 'https://disc.gsfc.nasa.gov/service/subset/jsonwsp' + + # This method POSTs formatted JSON WSP requests to the GES DISC endpoint URL + # It is created for convenience since this task will be repeated more than once + def get_http_data(request): + hdrs = {'Content-Type': 'application/json', + 'Accept' : 'application/json'} + data = json.dumps(request) + r = http.request('POST', svcurl, body=data, headers=hdrs) + response = json.loads(r.data) + # Check for errors + if response['type'] == 'jsonwsp/fault' : + print('API Error: faulty request') + sys.exit(1) + return response + + # Construct JSON WSP request for API method: subset + subset_request = { + 'methodname': 'subset', + 'type': 'jsonwsp/request', + 'version': '1.0', + 'args': { + 'role' : 'subset', + 'start' : begTime, + 'end' : endTime, + 'box' : [minlon, minlat, maxlon, maxlat], + 'crop' : False, + 'data' : [{'datasetId': product}] + } + } + + print("still here...1") + + # Submit the subset request to the GES DISC Server + response = get_http_data(subset_request) + + print("and even here?") + + # Report the JobID and initial status + myJobId = response['result']['jobId'] + print('Job ID: '+myJobId) + print('Job status: '+response['result']['Status']) + + # Construct JSON WSP request for API method: GetStatus + status_request = { + 'methodname': 'GetStatus', + 'version': '1.0', + 'type': 'jsonwsp/request', + 'args': {'jobId': myJobId} + } + + # Check on the job status after a brief nap + while response['result']['Status'] in ['Accepted', 'Running']: + sleep(5) + response = get_http_data(status_request) + status = response['result']['Status'] + percent = response['result']['PercentCompleted'] + print ('Job status: %s (%d%c complete)' % (status,percent,'%')) + + if response['result']['Status'] == 'Succeeded' : + print ('Job Finished: %s' % response['result']['message']) + else : + print('Job Failed: %s' % response['fault']['code']) + sys.exit(1) + + # Construct JSON WSP request for API method: GetResult + batchsize = 20 + results_request = { + 'methodname': 'GetResult', + 'version': '1.0', + 'type': 'jsonwsp/request', + 'args': { + 'jobId': myJobId, + 'count': batchsize, + 'startIndex': 0 + } + } + + # Retrieve the results in JSON in multiple batches + # Initialize variables, then submit the first GetResults request + # Add the results from this batch to the list and increment the count + results = [] + count = 0 + response = get_http_data(results_request) + count = count + response['result']['itemsPerPage'] + results.extend(response['result']['items']) + + # Increment the startIndex and keep asking for more results until we have them all + total = response['result']['totalResults'] + while count < total : + results_request['args']['startIndex'] += batchsize + response = get_http_data(results_request) + count = count + response['result']['itemsPerPage'] + results.extend(response['result']['items']) + + # Check on the bookkeeping + print('Retrieved %d out of %d expected items' % (len(results), total)) + + # Sort the results into documents and URLs + docs = [] + urls = [] + for item in results : + try: + if item['start'] and item['end'] : urls.append(item) + except: + docs.append(item) + + # Print out the documentation links, but do not download them + print('\nDocumentation:') + for item in docs : print(item['label']+': '+item['link']) + + # Use the requests library to submit the HTTP_Services URLs and write out the results. + print('\nHTTP_services output:') + if not os.path.exists(output_folder): + os.makedirs(output_folder) + for item in urls: + outfn = output_folder + '/' + item['label'] + if os.path.isfile(outfn): + continue + + URL = item['link'] + result = requests.get(URL) + try: + result.raise_for_status() + f = open(outfn,'wb') + f.write(result.content) + f.close() + print(outfn, URL) + except: + print('Error! Status code is %d for this URL:\n%s' % (result.status.code,URL)) + print('Help for downloading data is at https://disc.gsfc.nasa.gov/data-access') + + print('Finished') From a3228bed88ef890553b99a6dfdf771c11d18c099 Mon Sep 17 00:00:00 2001 From: github-actions Date: Wed, 18 Sep 2024 08:12:11 +0000 Subject: [PATCH 07/42] GitHub Action: Apply Pep8-formatting --- jobs/prepare_CTDAS.py | 47 ++++++++------ jobs/tools/fetch_external_data.py | 104 ++++++++++++++++++------------ 2 files changed, 88 insertions(+), 63 deletions(-) diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index 42037406..f38c5ca2 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -141,24 +141,31 @@ def main(cfg): ]) if cfg.fetch_OCO2: - # A user must do the following steps to allow - # from getpass import getpass - # import os - # from subprocess import Popen - # urs = 'urs.earthdata.nasa.gov' # Earthdata URL to call for authentication - # prompts = ['Enter NASA Earthdata Login Username \n(or create an account at urs.earthdata.nasa.gov): ', - # 'Enter NASA Earthdata Login Password: '] - # homeDir = os.path.expanduser("~") + os.sep - # with open(homeDir + '.netrc', 'w') as file: - # file.write('machine {} login {} password {}'.format(urs, getpass(prompt=prompts[0]), getpass(prompt=prompts[1]))) - # file.close() - # with open(homeDir + '.urs_cookies', 'w') as file: - # file.write('') - # file.close() - # with open(homeDir + '.dodsrc', 'w') as file: - # file.write('HTTP.COOKIEJAR={}.urs_cookies\n'.format(homeDir)) - # file.write('HTTP.NETRC={}.netrc'.format(homeDir)) - # file.close() - # Popen('chmod og-rw ~/.netrc', shell=True) - fetch_external_data.fetch_OCO2(x, y, -8, 30, 35, 65, "/capstor/scratch/cscs/ekoene/temp", product="OCO2_L2_Lite_FP_11.1r") + # A user must do the following steps to allow + # from getpass import getpass + # import os + # from subprocess import Popen + # urs = 'urs.earthdata.nasa.gov' # Earthdata URL to call for authentication + # prompts = ['Enter NASA Earthdata Login Username \n(or create an account at urs.earthdata.nasa.gov): ', + # 'Enter NASA Earthdata Login Password: '] + # homeDir = os.path.expanduser("~") + os.sep + # with open(homeDir + '.netrc', 'w') as file: + # file.write('machine {} login {} password {}'.format(urs, getpass(prompt=prompts[0]), getpass(prompt=prompts[1]))) + # file.close() + # with open(homeDir + '.urs_cookies', 'w') as file: + # file.write('') + # file.close() + # with open(homeDir + '.dodsrc', 'w') as file: + # file.write('HTTP.COOKIEJAR={}.urs_cookies\n'.format(homeDir)) + # file.write('HTTP.NETRC={}.netrc'.format(homeDir)) + # file.close() + # Popen('chmod og-rw ~/.netrc', shell=True) + fetch_external_data.fetch_OCO2(x, + y, + -8, + 30, + 35, + 65, + "/capstor/scratch/cscs/ekoene/temp", + product="OCO2_L2_Lite_FP_11.1r") logging.info("OK") diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index abc8dd1c..80ea8187 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -9,7 +9,7 @@ from icoscp_core.icos import bootstrap from icoscp import cpauth import numpy as np -import sys +import sys import json import datetime import certifi @@ -326,18 +326,26 @@ def fetch_ICOS_data(cookie_token, ds.to_netcdf(os.path.join(save_path, name)) -def fetch_OCO2(starttime, endtime, minlon, maxlon, minlat, maxlat, output_folder, product="OCO2_L2_Lite_FP_11r"): +def fetch_OCO2(starttime, + endtime, + minlon, + maxlon, + minlat, + maxlat, + output_folder, + product="OCO2_L2_Lite_FP_11r"): - # hmm. Not currently working. The data is there, https://oco2.gesdisc.eosdis.nasa.gov/data/OCO2_DATA/OCO2_L2_Lite_FP.11.1r/2020/ + # hmm. Not currently working. The data is there, https://oco2.gesdisc.eosdis.nasa.gov/data/OCO2_DATA/OCO2_L2_Lite_FP.11.1r/2020/ # but GES DISC doesn't currently have it anymore... - + # Set the product (based on the list above!) and other output settings - product = product # Standard + product = product # Standard begTime = f'{starttime.strftime("%Y-%m-%d")}T00:00:00.000Z' endTime = f'{endtime.strftime("%Y-%m-%d")}T23:59:59.999Z' # Create a urllib PoolManager instance to make requests. - http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',ca_certs=certifi.where()) + http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED', + ca_certs=certifi.where()) # Set the URL for the GES DISC subset service endpoint svcurl = 'https://disc.gsfc.nasa.gov/service/subset/jsonwsp' @@ -345,13 +353,15 @@ def fetch_OCO2(starttime, endtime, minlon, maxlon, minlat, maxlat, output_folder # This method POSTs formatted JSON WSP requests to the GES DISC endpoint URL # It is created for convenience since this task will be repeated more than once def get_http_data(request): - hdrs = {'Content-Type': 'application/json', - 'Accept' : 'application/json'} - data = json.dumps(request) + hdrs = { + 'Content-Type': 'application/json', + 'Accept': 'application/json' + } + data = json.dumps(request) r = http.request('POST', svcurl, body=data, headers=hdrs) - response = json.loads(r.data) + response = json.loads(r.data) # Check for errors - if response['type'] == 'jsonwsp/fault' : + if response['type'] == 'jsonwsp/fault': print('API Error: faulty request') sys.exit(1) return response @@ -362,12 +372,14 @@ def get_http_data(request): 'type': 'jsonwsp/request', 'version': '1.0', 'args': { - 'role' : 'subset', - 'start' : begTime, - 'end' : endTime, - 'box' : [minlon, minlat, maxlon, maxlat], - 'crop' : False, - 'data' : [{'datasetId': product}] + 'role': 'subset', + 'start': begTime, + 'end': endTime, + 'box': [minlon, minlat, maxlon, maxlat], + 'crop': False, + 'data': [{ + 'datasetId': product + }] } } @@ -380,31 +392,33 @@ def get_http_data(request): # Report the JobID and initial status myJobId = response['result']['jobId'] - print('Job ID: '+myJobId) - print('Job status: '+response['result']['Status']) + print('Job ID: ' + myJobId) + print('Job status: ' + response['result']['Status']) # Construct JSON WSP request for API method: GetStatus status_request = { 'methodname': 'GetStatus', 'version': '1.0', 'type': 'jsonwsp/request', - 'args': {'jobId': myJobId} + 'args': { + 'jobId': myJobId + } } # Check on the job status after a brief nap while response['result']['Status'] in ['Accepted', 'Running']: sleep(5) response = get_http_data(status_request) - status = response['result']['Status'] + status = response['result']['Status'] percent = response['result']['PercentCompleted'] - print ('Job status: %s (%d%c complete)' % (status,percent,'%')) + print('Job status: %s (%d%c complete)' % (status, percent, '%')) - if response['result']['Status'] == 'Succeeded' : - print ('Job Finished: %s' % response['result']['message']) - else : + if response['result']['Status'] == 'Succeeded': + print('Job Finished: %s' % response['result']['message']) + else: print('Job Failed: %s' % response['fault']['code']) sys.exit(1) - + # Construct JSON WSP request for API method: GetResult batchsize = 20 results_request = { @@ -418,39 +432,40 @@ def get_http_data(request): } } - # Retrieve the results in JSON in multiple batches + # Retrieve the results in JSON in multiple batches # Initialize variables, then submit the first GetResults request # Add the results from this batch to the list and increment the count results = [] - count = 0 - response = get_http_data(results_request) + count = 0 + response = get_http_data(results_request) count = count + response['result']['itemsPerPage'] - results.extend(response['result']['items']) + results.extend(response['result']['items']) # Increment the startIndex and keep asking for more results until we have them all total = response['result']['totalResults'] - while count < total : - results_request['args']['startIndex'] += batchsize - response = get_http_data(results_request) + while count < total: + results_request['args']['startIndex'] += batchsize + response = get_http_data(results_request) count = count + response['result']['itemsPerPage'] results.extend(response['result']['items']) - + # Check on the bookkeeping print('Retrieved %d out of %d expected items' % (len(results), total)) # Sort the results into documents and URLs docs = [] urls = [] - for item in results : + for item in results: try: - if item['start'] and item['end'] : urls.append(item) + if item['start'] and item['end']: urls.append(item) except: docs.append(item) # Print out the documentation links, but do not download them print('\nDocumentation:') - for item in docs : print(item['label']+': '+item['link']) - + for item in docs: + print(item['label'] + ': ' + item['link']) + # Use the requests library to submit the HTTP_Services URLs and write out the results. print('\nHTTP_services output:') if not os.path.exists(output_folder): @@ -460,16 +475,19 @@ def get_http_data(request): if os.path.isfile(outfn): continue - URL = item['link'] + URL = item['link'] result = requests.get(URL) try: result.raise_for_status() - f = open(outfn,'wb') + f = open(outfn, 'wb') f.write(result.content) f.close() print(outfn, URL) except: - print('Error! Status code is %d for this URL:\n%s' % (result.status.code,URL)) - print('Help for downloading data is at https://disc.gsfc.nasa.gov/data-access') - + print('Error! Status code is %d for this URL:\n%s' % + (result.status.code, URL)) + print( + 'Help for downloading data is at https://disc.gsfc.nasa.gov/data-access' + ) + print('Finished') From dff96396f9ad07ab2e1cc7b3625fab02a5770835 Mon Sep 17 00:00:00 2001 From: efkmoene Date: Mon, 23 Sep 2024 13:52:59 +0200 Subject: [PATCH 08/42] Added CTDAS testcase --- cases/icon-art-CTDAS/config.yaml | 82 ++++ cases/icon-art-CTDAS/icon_era5_inicond.sh | 181 +++++++++ cases/icon-art-CTDAS/icon_era5_nudging.sh | 64 +++ cases/icon-art-CTDAS/icon_runjob.cfg | 399 +++++++++++++++++++ cases/icon-art-CTDAS/icon_species_inicond.sh | 75 ++++ cases/icon-art-CTDAS/icon_species_nudging.sh | 55 +++ cases/icon-art-CTDAS/mypartab | 117 ++++++ jobs/__init__.py | 1 + jobs/prepare_CTDAS.py | 145 ++++--- jobs/tools/fetch_external_data.py | 208 +++++----- 10 files changed, 1151 insertions(+), 176 deletions(-) create mode 100644 cases/icon-art-CTDAS/config.yaml create mode 100644 cases/icon-art-CTDAS/icon_era5_inicond.sh create mode 100644 cases/icon-art-CTDAS/icon_era5_nudging.sh create mode 100644 cases/icon-art-CTDAS/icon_runjob.cfg create mode 100644 cases/icon-art-CTDAS/icon_species_inicond.sh create mode 100644 cases/icon-art-CTDAS/icon_species_nudging.sh create mode 100644 cases/icon-art-CTDAS/mypartab diff --git a/cases/icon-art-CTDAS/config.yaml b/cases/icon-art-CTDAS/config.yaml new file mode 100644 index 00000000..006901ac --- /dev/null +++ b/cases/icon-art-CTDAS/config.yaml @@ -0,0 +1,82 @@ +# Configuration file for the 'icon-art-CTDAS' case with ICON + +workflow: icon +constraint: gpu +run_on: cpu +compute_queue: normal +ntasks_per_node: 36 +startdate: 2018-01-01T00:00:00Z +enddate: 2018-12-31T23:59:59Z +restart_step: PT10D +CTDAS_step: 240 + +eccodes_dir: ./input/eccodes_definitions +iconremap_bin: ./ext/icontools/icontools/iconremap +iconsub_bin: ./ext/icontools/icontools/iconsub +latbc_filename: ifs__lbc.nc +inidata_prefix: ifs_init_ +inidata_nameformat: '%Y%m%d%H' +inidata_filename_suffix: .nc +output_filename: icon-art-global-test +filename_format: _DOM_ +lateral_boundary_grid_order: lateral_boundary +art_input_folder: ./input/icon-art-global/art + +walltime: + prepare_icon: '00:15:00' + prepare_art_global: '00:10:00' + icon: '00:05:00' + prepare_CTDAS: '3:00:00' + +meteo: + dir: ./input/meteo + prefix: ifs_ + nameformat: '%Y%m%d%H' + suffix: .grb + nudging_step: 3 + fetch_era5: True + interpolate_CAMS_to_ERA5: True + url: https://cds-beta.climate.copernicus.eu/api + key: 1c2e45b1-dd08-4bc4-90c8-15c06304ae69 + era5_inijob: icon_era5_inicond.sh + era5_nudgingjob: icon_era5_nudging.sh + + +chem: + dir: ./input/icon-art-global/chem + prefix: cams_gqpe_ + nameformat: '%Y%m%d_%H' + suffix: .grb + nudging_step: 3 + fetch_CAMS: True + url: https://ads-beta.atmosphere.copernicus.eu/api + key: 1c2e45b1-dd08-4bc4-90c8-15c06304ae69 + +obs: + fetch_ICOS: True + ICOS_cookie_token: cpauthToken=WzE3MjcxODM4NTk5NjgsImVyaWsua29lbmVAZW1wYS5jaCIsIlNhbWwiXR4YD2F2BeORMmb6xC6b6emc8jk+SLcju2hKPUGcllTQa238n1qHvl9Nqwr16JLW3MKF0XwDos5eF9zR0t4mgd2MND2Fhq7KI+fEL8Dx8s+usFCCNOpP2ElvuNz/Z3ZEnZr5dyLEwnuo+1AoAugMkuT87DELhj5S4xuarBCIf7GcStTZzYHJAjWtxJ3VbUA5tepWULoqS+40EDagchfYz7A2fQYphTznAB5LlzxOEWMAn2/289UXZMrgce6Rlket3XAMM8TF17bDoHeh8js0kfdlbhZQ0RjbJ1Xjf4MGzYBLru5Rces49D5jQ3oSXF0AmsZnyFdcDjswccj68Nz8pc3X + fetch_OCO2: True + +input_files: + inicond_filename: ./input/icon-art-global/icbc/era2icon_R2B03_2022060200.nc + map_file_nudging: ./input/icon-art-global/icbc/map_file.nudging + radiation_grid_filename: /users/ekoene/CTDAS_inputs/icon_europe_DOM01.parent.nc + dynamics_grid_filename: /users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc + extpar_filename: /users/ekoene/CTDAS_inputs/icon_extpar_EriksGrid.nc + cldopt_filename: ./input/icon-art-global/rad/ECHAM6_CldOptProps.nc + lrtm_filename: ./input/icon-art-global/rad/rrtmg_lw.nc + chemtracer_xml_filename: ./input/icon-art-global/config/tracers.xml + +icon: + binary_file: ./ext/icon-art/bin/icon + runjob_filename: icon_runjob.cfg + # era5_inijob: icon_era5_inicond.sh + # era5_nudgingjob: icon_era5_nudging.sh + species_inijob: icon_species_inicond.sh + species_nudgingjob: icon_species_nudging.sh + output_writing_step: 6 + compute_queue: normal + np_tot: 4 + np_io: 1 + np_restart: 1 + np_prefetch: 1 \ No newline at end of file diff --git a/cases/icon-art-CTDAS/icon_era5_inicond.sh b/cases/icon-art-CTDAS/icon_era5_inicond.sh new file mode 100644 index 00000000..6fef139a --- /dev/null +++ b/cases/icon-art-CTDAS/icon_era5_inicond.sh @@ -0,0 +1,181 @@ +#!/bin/bash + +cd {cfg.icon_input_icbc} + +module load daint-mc CDO NCO + +# --------------------------------- +# -- Pre-processing +# --------------------------------- + +rm -f {inicond_filename} + +# -- Convert the GRIB files to NetCDF +cdo -t ecmwf -f nc copy era5_ml.grib era5_ml.nc +cdo -t ecmwf -f nc copy era5_surf.grib era5_surf.nc + +# -- Put all variables in the same file +cdo merge era5_ml.nc era5_surf.nc era5_original.nc + +# -- Change variable and coordinates names to be consistent with ICON nomenclature +cdo setpartabn,mypartab,convert era5_original.nc tmp.nc + +# -- Order the variables alphabetically +ncks tmp.nc data_in.nc +rm tmp.nc era5_surf.nc era5_ml.nc era5_original.nc + +# --------------------------------- +# -- Re-mapping +# --------------------------------- + +# -- Retrieve the dynamic horizontal grid +cdo -s selgrid,2 {cfg.input_files_scratch_dynamics_grid_filename} triangular-grid.nc + +# -- Create the weights for remapping ERA5 latlon grid onto the triangular grid +cdo gendis,triangular-grid.nc data_in.nc weights.nc + +# -- Extract the land-sea mask variable in input and output files +cdo selname,LSM data_in.nc LSM_in.nc +ncrename -h -v LSM,FR_LAND LSM_in.nc +cdo selname,FR_LAND {cfg.input_files_scratch_extpar_filename} LSM_out_tmp.nc + +# -- Add time dimension to LSM_out.nc +ncecat -O -u time LSM_out_tmp.nc LSM_out_tmp.nc +ncks -h -A -v time LSM_in.nc LSM_out_tmp.nc + +# -- Create two different files for land- and sea-mask +cdo -L setctomiss,0. -ltc,0.5 LSM_in.nc oceanmask_in.nc +cdo -L setctomiss,0. -gec,0.5 LSM_in.nc landmask_in.nc +cdo -L setctomiss,0. -ltc,0.5 LSM_out_tmp.nc oceanmask_out.nc +cdo -L setctomiss,0. -gec,0.5 LSM_out_tmp.nc landmask_out.nc +cdo setrtoc2,0.5,1.0,1,0 LSM_out_tmp.nc LSM_out.nc +rm LSM_in.nc LSM_out_tmp.nc + +# -- Select surface sea variables defined only on sea +ncks -h -v SST,CI data_in.nc datasea_in.nc + +# -- Select surface variables defined on both that must be remap differently on sea and on land +ncks -h -v SKT,STL1,STL2,STL3,STL4,ALB_SNOW,W_SNOW,T_SNOW data_in.nc dataland_in.nc + +# ----------------------------------------------------------------------------- +# -- Remap land and ocean area differently for variables +# ----------------------------------------------------------------------------- + +# -- Ocean part +# ----------------- + +# -- Apply the ocean mask (by dividing) +cdo div dataland_in.nc oceanmask_in.nc tmp1_land.nc +cdo div datasea_in.nc oceanmask_in.nc tmp1_sea.nc + +# -- Set missing values to a distance-weighted average +cdo setmisstodis tmp1_land.nc tmp2_land.nc +cdo setmisstodis tmp1_sea.nc tmp2_sea.nc + +# -- Remap +cdo remapdis,triangular-grid.nc tmp2_land.nc tmp3_land.nc +cdo remapdis,triangular-grid.nc tmp2_sea.nc tmp3_sea.nc + +# -- Apply the ocean mask to remapped variables (by dividing) +cdo div tmp3_land.nc oceanmask_out.nc dataland_ocean_out.nc +cdo div tmp3_sea.nc oceanmask_out.nc datasea_ocean_out.nc + +# -- Clean the repository +rm tmp*.nc oceanmask*.nc + +# # -- Land part +# # ----------------- + +cdo div dataland_in.nc landmask_in.nc tmp1.nc +cdo setmisstodis tmp1.nc tmp2.nc +cdo remapdis,triangular-grid.nc tmp2.nc tmp3.nc +cdo div tmp3.nc landmask_out.nc dataland_land_out.nc +rm tmp*.nc landmask*.nc dataland_in.nc datasea_in.nc + +# -- merge remapped land and ocean part +# -------------------------------------- + +cdo ifthenelse LSM_out.nc dataland_land_out.nc dataland_ocean_out.nc dataland_out.nc +rm dataland_ocean_out.nc dataland_land_out.nc + +# remap the rest and merge all files +# -------------------------------------- + +# -- Select all variables apart from these ones +ncks -h -x -v SKT,STL1,STL2,STL3,STL4,SMIL1,SMIL2,SMIL3,SMIL4,ALB_SNOW,W_SNOW,T_SNOW,SST,CI,LSM data_in.nc datarest_in.nc + +# -- Remap +cdo -s remapdis,triangular-grid.nc datarest_in.nc era5_final.nc +rm datarest_in.nc + +# -- Fill NaN values for SST and CI +cdo setmisstodis -selname,SST,CI datasea_ocean_out.nc dataland_ocean_out_filled.nc +rm datasea_ocean_out.nc + +# -- Merge remapped files plus land sea mask from EXTPAR +ncks -h -A dataland_out.nc era5_final.nc +ncks -h -A dataland_ocean_out_filled.nc era5_final.nc +ncks -h -A -v FR_LAND LSM_out.nc era5_final.nc +ncrename -h -v FR_LAND,LSM era5_final.nc +rm LSM_out.nc dataland_out.nc + +# ------------------------------------------------------------------------ +# -- Convert the (former) SWVLi variables to real soil moisture indices +# ------------------------------------------------------------------------ + +# -- Properties of IFS soil types (see Table 1 ERA5 Data documentation +# -- https://confluence.ecmwf.int/display/CKB/ERA5%3A+data+documentation) +# Soil type 1 2 3 4 5 6 7 +wiltingp=(0 0.059 0.151 0.133 0.279 0.335 0.267 0.151) # wilting point +fieldcap=(0 0.244 0.347 0.383 0.448 0.541 0.663 0.347) # field capacity + +ncks -h -v SMIL1,SMIL2,SMIL3,SMIL4,SLT data_in.nc swvl.nc +rm data_in.nc + +# -- Loop over the soil types and apply the right constants +smi_equation="" +for ilev in {{1..4}}; do + + smi_equation="${{smi_equation}}SMIL${{ilev}} = (SMIL${{ilev}} - ${{wiltingp[1]}}) / (${{fieldcap[1]}} - ${{wiltingp[1]}}) * (SLT==1)" + for ist in {{2..7}}; do + smi_equation="${{smi_equation}} + (SMIL${{ilev}} - ${{wiltingp[$ist]}}) / (${{fieldcap[$ist]}} - ${{wiltingp[$ist]}}) * (SLT==${{ist}})" + done + smi_equation="${{smi_equation}};" + +done + +cdo expr,"${{smi_equation}}" swvl.nc smil_in.nc +rm swvl.nc + +# -- Remap SMIL variables +cdo -s remapdis,triangular-grid.nc smil_in.nc smil_out.nc +rm smil_in.nc + +# -- Overwrite the variables SMIL1,SMIL2,SMIL3,SMIL4 +ncks -A -v SMIL1,SMIL2,SMIL3,SMIL4 smil_out.nc era5_final.nc +rm smil_out.nc + +# -------------------------------------- +# -- Create the LNSP variable +# -------------------------------------- + +# -- Apply logarithm to surface pressure +cdo expr,'LNPS=ln(PS);' era5_final.nc tmp.nc + +# -- Put the new variable LNSP in the original file +ncks -A -v LNPS tmp.nc era5_final.nc +rm tmp.nc + +# --------------------------------- +# -- Post-processing +# --------------------------------- + +# -- Rename dimensions and order alphabetically +ncrename -h -d cell,ncells era5_final.nc +ncrename -h -d nv,vertices era5_final.nc +ncks era5_final.nc {inicond_filename} +rm era5_final.nc + +# -- Clean the repository +rm weights.nc +rm triangular-grid.nc \ No newline at end of file diff --git a/cases/icon-art-CTDAS/icon_era5_nudging.sh b/cases/icon-art-CTDAS/icon_era5_nudging.sh new file mode 100644 index 00000000..c65f1988 --- /dev/null +++ b/cases/icon-art-CTDAS/icon_era5_nudging.sh @@ -0,0 +1,64 @@ +#!/bin/bash + +cd {cfg.icon_input_icbc} + +# --------------------------------- +# -- Pre-processing +# --------------------------------- + +rm -f {filename} + +# -- Convert the GRIB files to NetCDF +cdo -t ecmwf -f nc copy era5_ml_nudging.grib era5_ml_nudging.nc +cdo -t ecmwf -f nc copy era5_surf_nudging.grib era5_surf_nudging.nc + +# -- Put all variables in the same file +cdo merge era5_ml_nudging.nc era5_surf_nudging.nc era5_original_nudging.nc + +# -- Change variable and coordinates names to be consistent with ICON nomenclature +cdo setpartabn,mypartab,convert era5_original_nudging.nc tmp.nc + +# -- Order the variables alphabetically +ncks tmp.nc data_in.nc +rm tmp.nc era5_surf_nudging.nc era5_ml_nudging.nc era5_original_nudging.nc + +# --------------------------------- +# -- Re-mapping +# --------------------------------- + +# -- Retrieve the dynamic horizontal grid +cdo -s selgrid,2 {cfg.input_files_scratch_dynamics_grid_filename} triangular-grid.nc + +# -- Create the weights for remapping ERA5 latlon grid onto the triangular grid +cdo gendis,triangular-grid.nc data_in.nc weights.nc + +# -- Remap +cdo -s remapdis,triangular-grid.nc data_in.nc era5_final.nc +rm data_in.nc + +# -------------------------------------- +# -- Create the LNSP variable +# -------------------------------------- + +# -- Apply logarithm to surface pressure +cdo expr,'LNPS=ln(PS);' era5_final.nc tmp.nc + +# -- Put the new variable LNSP in the original file +ncks -A -v LNPS tmp.nc era5_final.nc +rm tmp.nc + +# --------------------------------- +# -- Post-processing +# --------------------------------- + +# -- Rename dimensions and order alphabetically +ncrename -h -d cell,ncells era5_final.nc +ncrename -h -d nv,vertices era5_final.nc +ncks era5_final.nc {filename} +rm era5_final.nc + + +# -- Clean the repository +rm weights.nc +rm triangular-grid.nc + diff --git a/cases/icon-art-CTDAS/icon_runjob.cfg b/cases/icon-art-CTDAS/icon_runjob.cfg new file mode 100644 index 00000000..4233ff08 --- /dev/null +++ b/cases/icon-art-CTDAS/icon_runjob.cfg @@ -0,0 +1,399 @@ +#!/usr/bin/env bash +#SBATCH --job-name=icon +#SBATCH --account={cfg.compute_account} +#SBATCH --time={cfg.walltime_icon} +#SBATCH --nodes={cfg.icon_np_tot} +#SBATCH --ntasks-per-node={cfg.ntasks_per_node} +#SBATCH --partition={cfg.compute_queue} +#SBATCH --constraint={cfg.constraint} +#SBATCH --hint=nomultithread +#SBATCH --output={cfg.logfile} +#SBATCH --open-mode=append +#SBATCH --chdir={cfg.icon_work} + +# OpenMP environment variables +# ---------------------------- +export OMP_NUM_THREADS=1 +export ICON_THREADS=1 +export OMP_SCHEDULE=static,12 +export OMP_DYNAMIC="false" +export OMP_STACKSIZE=200M + +set -e -x + +# -- ECCODES path +export ECCODES_DEFINITION_PATH={cfg.eccodes_dir}/definitions.edzw-2.12.5-2:{cfg.eccodes_dir}/definitions + +# ---------------------------------------------------------------------------- +# Link radiation input files +# ---------------------------------------------------------------------------- +ln -sf {cfg.art_input_folder}/* . +ln -sf {cfg.art_input_folder}/* . + +# ---------------------------------------------------------------------------- +# Create ICON master namelist +# ---------------------------------------------------------------------------- + +cat > icon_master.namelist << EOF +! master_nml: ---------------------------------------------------------------- +&master_nml + lrestart = {cfg.lrestart} ! .TRUE.=current experiment is resumed + read_restart_namelists = .true. +/ + +! master_time_control_nml: --------------------------------------------------- +&master_time_control_nml + calendar = 'proleptic gregorian' + restartTimeIntval = '{cfg.restart_step}' + checkpointTimeIntval = '{cfg.restart_step}' + experimentStartDate = '{cfg.ini_datetime_string}' + experimentStopDate = '{cfg.end_datetime_string}' +/ + +! master_model_nml: repeated for each model ---------------------------------- +&master_model_nml + model_type = 1 ! identifies which component to run (atmosphere,ocean,...) + model_name = "ATMO" ! character string for naming this component. + model_namelist_filename = "NAMELIST_{cfg.casename}" ! file name containing the model namelists + model_min_rank = 1 ! start MPI rank for this model + model_max_rank = 65536 ! end MPI rank for this model + model_inc_rank = 1 ! stride of MPI ranks +/ +EOF + +# ---------------------------------------------------------------------- +# Create model namelists +# ---------------------------------------------------------------------- + +cat > NAMELIST_{cfg.casename} << EOF +! parallel_nml: MPI parallelization ------------------------------------------- +¶llel_nml + nproma = 8 ! optimal setting 8 for CRAY; use 16 or 24 for IBM + num_io_procs = 1 ! up to one PE per output stream is possible + num_prefetch_proc = 1 +/ + + +! grid_nml: horizontal grid -------------------------------------------------- +&grid_nml + dynamics_grid_filename = "{cfg.input_files_scratch_dynamics_grid_filename}" ! array of the grid filenames for the dycore + dynamics_parent_grid_id = 0 ! array of the indexes of the parent grid filenames + lredgrid_phys = .TRUE. ! .true.=radiation is calculated on a reduced grid + lfeedback = .TRUE. ! specifies if feedback to parent grid is performed + ifeedback_type = 2 ! feedback type (incremental/relaxation-based) +/ + + +! initicon_nml: specify read-in of initial state ------------------------------ +&initicon_nml + init_mode = 2 ! 2: start from IFS data + ifs2icon_filename = '{cfg.input_files_scratch_inicond_filename}' ! initial data filename + zpbl1 = 500. ! bottom height (AGL) of layer used for gradient computation + zpbl2 = 1000. ! top height (AGL) of layer used for gradient computation +/ + +! extpar_nml: external data -------------------------------------------------- +&extpar_nml + extpar_filename = '{cfg.input_files_scratch_extpar_filename}' ! filename of external parameter input file + itopo = 1 ! topography (0:analytical) + itype_vegetation_cycle = 2 ! specifics for annual cycle of LAI + n_iter_smooth_topo = 1 ! iterations of topography smoother + heightdiff_threshold = 2250. + hgtdiff_max_smooth_topo = 750. + read_nc_via_cdi = .TRUE. + itype_lwemiss = 2 +/ + +! io_nml: general switches for model I/O ------------------------------------- +&io_nml + itype_pres_msl = 5 ! method for computation of mean sea level pressure + itype_rh = 1 ! method for computation of relative humidity + lnetcdf_flt64_output = .FALSE. ! NetCDF files is written in 64-bit instead of 32-bit accuracy +/ + +! run_nml: general switches --------------------------------------------------- +&run_nml + dtime = 900 ! timestep in seconds + iforcing = 3 ! forcing of dynamics and transport by parameterized processes + lart = .TRUE. ! main switch for ART + ldynamics = .TRUE. ! compute adiabatic dynamic tendencies + ltestcase = .FALSE. ! real case run + ltimer = .FALSE. ! timer for monitoring the runtime of specific routines + ltransport = .TRUE. ! compute large-scale tracer transport + lvert_nest = .FALSE. ! vertical nesting + msg_level = 10 ! detailed report during integration + timers_level = 1 ! performance timer granularity + output = "nml" ! main switch for enabling/disabling components of the model output + num_lev = 65 ! number of full levels (atm.) for each domain +/ + +! nwp_phy_nml: switches for the physics schemes ------------------------------ +&nwp_phy_nml + lrtm_filename = '{cfg.input_files_scratch_lrtm_filename}' ! longwave absorption coefficients for RRTM_LW + cldopt_filename = '{cfg.input_files_scratch_cldopt_filename}' ! RRTM cloud optical properties + dt_rad = $(( 4 * dtime)) ! time step for radiation in s + dt_conv = $(( 1 * dtime)) ! time step for convection in s (domain specific) + dt_sso = $(( 2 * dtime)) ! time step for SSO parameterization + dt_gwd = $(( 2 * dtime)) ! time step for gravity wave drag parameterization + efdt_min_raylfric = 7200. ! minimum e-folding time of Rayleigh friction + icapdcycl = 3 ! apply CAPE modification to improve diurnalcycle over tropical land + icpl_aero_conv = 1 ! coupling between autoconversion and Tegen aerosol climatology + icpl_aero_gscp = 0 ! + icpl_o3_tp = 1 ! + inwp_cldcover = 1 ! cloud cover scheme for radiation + inwp_convection = 1 ! convection + inwp_gscp = 1 ! cloud microphysics and precipitation + inwp_gwd = 1 ! non-orographic gravity wave drag + inwp_radiation = 1 ! radiation + inwp_satad = 1 ! saturation adjustment + inwp_sso = 1 ! subgrid scale orographic drag + inwp_surface = 1 ! surface scheme + inwp_turb = 1 ! vertical diffusion and transfer + itype_z0 = 2 ! type of roughness length data + latm_above_top = .TRUE. ! take into account atmosphere above model top for radiation computation + ldetrain_conv_prec = .TRUE. ! Activate detrainment of convective rain and snowl + mu_rain = 0.5 + rain_n0_factor = 0.1 + lshallowconv_only = .FALSE. + lgrayzone_deepconv = .TRUE. ! activates shallow and deep convection but not mid-level convection, +/ + +! nwp_tuning_nml: additional tuning parameters ---------------------------------- +&nwp_tuning_nml + itune_albedo = 1 + tune_box_liq_asy = 4.0 + tune_gfrcrit = 0.333 + tune_gkdrag = 0.0 + tune_gkwake = 0.25 + tune_gust_factor = 7.0 + tune_minsnowfrac = 0.3 + tune_sgsclifac = 1.0 + tune_rcucov = 0.075 + tune_rhebc_land = 0.825 + tune_zvz0i = 0.85 + icpl_turb_clc = 2 + max_calibfac_clcl = 2.0 + tune_box_liq = 0.04 +/ + + +! turbdiff_nml: turbulent diffusion ------------------------------------------- +&turbdiff_nml + a_hshr = 2.0 ! length scale factor for separated horizontal shear mode + frcsmot = 0.2 ! these 2 switches together apply vertical smoothing of the TKE source terms + icldm_turb = 2 ! mode of cloud water representation in turbulence + imode_frcsmot = 2 ! in the tropics (only), which reduces the moist bias in the tropical lower troposphere + imode_tkesso = 2 + itype_sher = 2 + ltkeshs = .TRUE. ! type of shear forcing used in turbulence + ltkesso = .TRUE. + pat_len = 750. ! effective length scale of thermal surface patterns + q_crit = 2.0 + rat_sea = 0.8 + tkhmin = 0.5 + tkmmin = 0.75 + tur_len = 300. + rlam_heat = 10.0 + alpha1 = 0.125 +/ + +&lnd_nml + c_soil = 1.25 + c_soil_urb = 0.5 + cwimax_ml = 5.e-4 + idiag_snowfrac = 20 + itype_evsl = 4 + itype_heatcond = 3 + itype_lndtbl = 4 + itype_root = 2 + itype_snowevap = 3 + itype_trvg = 3 + llake = .TRUE. + lmulti_snow = .FALSE. + lprog_albsi = .TRUE. + itype_canopy = 2 + lseaice = .TRUE. + lsnowtile = .TRUE. + nlev_snow = 3 + ntiles = 3 + sstice_mode = 2 +/ + +! radiation_nml: radiation scheme --------------------------------------------- +&radiation_nml + albedo_type = 2 ! Modis albedo + irad_o3 = 79 ! ozone climatology + irad_aero = 6 + islope_rad = 0 + direct_albedo_water = 3 + albedo_whitecap = 1 + vmr_co2 = 407.e-06 ! values representative for 2012 + vmr_ch4 = 1857.e-09 + vmr_n2o = 330.0e-09 + vmr_o2 = 0.20946 + vmr_cfc11 = 240.e-12 + vmr_cfc12 = 532.e-12 +/ + +! nonhydrostatic_nml: nonhydrostatic model ----------------------------------- +&nonhydrostatic_nml + damp_height = 12250.0 ! height at which Rayleigh damping of vertical wind starts + divdamp_fac = 0.004 ! scaling factor for divergence damping + divdamp_order = 24 ! order of divergence damping + divdamp_type = 32 ! type of divergence damping + exner_expol = 0.6 ! temporal extrapolation of Exner function + hbot_qvsubstep = 22500.0 ! height above which QV is advected with substepping scheme + htop_moist_proc = 22500.0 ! max. height for moist physics + iadv_rhotheta = 2 ! advection method for rho and rhotheta + igradp_method = 3 ! discretization of horizontal pressure gradient + itime_scheme = 4 ! time integration scheme + ivctype = 2 ! type of vertical coordinate + l_zdiffu_t = .TRUE. ! specifies computation of Smagorinsky temperature diffusion + rayleigh_coeff = 5.0 ! Rayleigh damping coefficient + thhgtd_zdiffu = 125.0 ! threshold of height difference (temperature diffusion) + thslp_zdiffu = 0.02 ! slope threshold (temperature diffusion) + vwind_offctr = 0.2 ! off-centering in vertical wind solver +/ + +! sleve_nml: vertical level specification ------------------------------------- +&sleve_nml + decay_exp = 1.2 ! exponent of decay function + decay_scale_1 = 4000.0 ! decay scale of large-scale topography component + decay_scale_2 = 2500.0 ! decay scale of small-scale topography component + flat_height = 16000.0 ! height above which the coordinate surfaces are flat + itype_laydistr = 1 + min_lay_thckn = 20.0 ! minimum layer thickness of lowermost layer + stretch_fac = 0.65 ! stretching factor to vary distribution of model levels + htop_thcknlimit = 15000.0 + top_height = 75000.0 ! height of model top +/ + +! dynamics_nml: dynamical core ----------------------------------------------- +&dynamics_nml + divavg_cntrwgt = 0.50 ! weight of central cell for divergence averaging + iequations = 3 ! type of equations and prognostic variables + lcoriolis = .TRUE. ! Coriolis force +/ + +! transport_nml: tracer transport --------------------------------------------- +&transport_nml + ctracer_list = '12345' ! kann vermutlich raus + ihadv_tracer = 52,2,2,2,2,2 ! tracer specific method to compute horizontal advection + ivadv_tracer = 3,3,3,3,3,3 ! tracer specific method to compute vertical advection + itype_hlimit = 3,4,4,4,4,4 ! type of limiter for horizontal transport + llsq_svd = .TRUE. + beta_fct = 1.005 +/ + +! diffusion_nml: horizontal (numerical) diffusion ---------------------------- +&diffusion_nml + hdiff_efdt_ratio = 24.0 ! ratio of e-folding time to time step + hdiff_order = 5 ! order of nabla operator for diffusion + hdiff_smag_fac = 0.025 ! scaling factor for Smagorinsky diffusion + itype_t_diffu = 2 ! discretization of temperature diffusion + itype_vn_diffu = 1 ! reconstruction method used for Smagorinsky diffusion + lhdiff_vn = .TRUE. ! diffusion on the horizontal wind field + lhdiff_temp = .TRUE. ! diffusion on the temperature field +/ + +! interpol_nml: settings for internal interpolation methods ------------------ +&interpol_nml + lsq_high_ord = 3 + l_intp_c2l = .TRUE. + l_mono_c2l = .TRUE. +/ + +! nudging_nml: settings for global nudging ----------------------------------- +&nudging_nml +nudge_type = {cfg.nudge_type} ! global nudging +nudge_var = 'vn' ! variables that shall be nudged, default = all (vn,thermdyn,qv) +nudge_start_height = 0. ! Start nudging at the surface +nudge_end_height = 75000.0 ! End nudging at the top +nudge_profile = 2 +/ + +! limarea_nml: settings for global nudging ----------------------------------- +&limarea_nml +itype_latbc = 1 ! time-dependent lateral boundary conditions provided by an external source +dtime_latbc = {cfg.nudging_step_seconds} ! Time difference between two consecutive boundary data +latbc_path = '{cfg.icon_input_icbc}' ! Absolute path to boundary data +latbc_filename = 'era2icon_R2B03__nudging.nc' ! boundary data input filename +latbc_varnames_map_file = '{cfg.input_files_scratch_map_file_nudging}' ! Dictionary file which maps internal variable names onto GRIB2 shortnames or NetCDF varnames +latbc_boundary_grid = ' ' ! no boundary grid: driving data have to be available on entire grid (important to let a space) +/ + +! art_nml: Aerosols and Reactive Trace gases extension------------------------------------------------- +&art_nml + lart_diag_out = .TRUE. ! If this switch is set to .TRUE., diagnostic + ! ... output elds are available. Set it to + ! ... .FALSE. when facing memory problems. + lart_pntSrc = .TRUE. ! enables point sources + !lart_bound_cond = .FALSE. ! enables boundary conditions + lart_chem = .TRUE. ! enables chemistry + lart_chemtracer = .TRUE. ! main switch for the treatment of chemical tracer + lart_aerosol = .FALSE. ! main switch for the treatment of atmospheric aerosol + + iart_seasalt = 0 + iart_init_gas = {cfg.iart_init_gas} + cart_cheminit_type = 'EMAC' + cart_cheminit_file = '{cfg.input_files_scratch_inicond_filename}' + cart_cheminit_coord = '{cfg.input_files_scratch_inicond_filename}' + + cart_chemtracer_xml = '{cfg.input_files_scratch_chemtracer_xml_filename}' ! path to xml file for chemical tracers + cart_pntSrc_xml = '{cfg.input_files_scratch_pntSrc_xml_filename}' ! path to xml file for point sources + cart_input_folder = '{cfg.art_input_folder}' ! absolute Path to ART source code +/ + +! output_nml: specifies an output stream -------------------------------------- +&output_nml + filetype = 4 ! output format: 2=GRIB2, 4=NETCDFv2 + dom = -1 ! write all domains + output_bounds = 0.,100000000,{cfg.icon_output_writing_step} ! start, end, increment + output_time_unit = 3 ! Unit of bounds is in hours instead of seconds + steps_per_file = 1 ! number of steps per file + steps_per_file_inclfirst = .FALSE. ! First step is not accounted for in steps_per_file + include_last = .FALSE. + mode = 1 ! 1: forecast mode (relative t-axis), 2: climate mode (absolute t-axis) + output_filename = 'ICON-ART' + filename_format = '{cfg.icon_output}/_latlon_' ! file name base + remap = 1 ! 1: remap to lat-lon grid + reg_lon_def = -179.,2,179 + reg_lat_def = 89.,-2,-89. + ml_varlist = 'z_ifc','pres','qv','rho','temp','u','v','group:ART_CHEMISTRY','OH_Nconc', +/ + +! output_nml: specifies an output stream -------------------------------------- +&output_nml + filetype = 4 ! output format: 2=GRIB2, 4=NETCDFv2 + dom = -1 ! write all domains + output_bounds = 0.,100000000,{cfg.icon_output_writing_step} ! start, end, increment + output_time_unit = 3 ! Unit of bounds is in hours instead of seconds + steps_per_file = 1 ! number of steps per file + steps_per_file_inclfirst = .FALSE. ! First step is not accounted for in steps_per_file + include_last = .FALSE. + mode = 1 ! 1: forecast mode (mrelative t-axis), 2: climate mode (absolute t-axis) + output_filename = 'ICON-ART' + filename_format = '{cfg.icon_output}/_unstr_' ! file name base + remap = 0 ! 1: remap to lat-lon grid + ml_varlist = 'z_ifc','pres','qv','rho','temp','u','v','group:ART_CHEMISTRY','OH_Nconc', +/ + + +EOF + +# ! ml_varlist = 'z_ifc','z_mc','pres','pres_sfc','qv','rho','temp','u','v','group:ART_CHEMISTRY', + +# ---------------------------------------------------------------------- +# run the model! +# ---------------------------------------------------------------------- +handle_error(){{ + set +e + # Check for invalid pointer error at the end of icon-art + if grep -q "free(): invalid pointer" {cfg.logfile} && grep -q "clean-up finished" {cfg.logfile}; then + exit 0 + else + exit 1 + fi + set -e +}} +srun ./{cfg.icon_execname} || handle_error diff --git a/cases/icon-art-CTDAS/icon_species_inicond.sh b/cases/icon-art-CTDAS/icon_species_inicond.sh new file mode 100644 index 00000000..aa6d5a07 --- /dev/null +++ b/cases/icon-art-CTDAS/icon_species_inicond.sh @@ -0,0 +1,75 @@ +#!/bin/bash + +cd {cfg.icon_input_icbc} + + +species2restart=($(echo {cfg.species2restart} | tr -d '[],')) + + +if [[ {cfg.lrestart} == '.FALSE.' ]]; then + + # ---------------------------------------------------------- + # -- Replicate Q and GEOSP variables for ICON-ART + # ---------------------------------------------------------- + + cdo expr,'Q=QV;' {filename} tmp.nc + ncks -A -v Q tmp.nc {filename} + rm tmp.nc + + cdo expr,'GEOP_SFC=GEOSP;' {filename} tmp.nc + ncks -A -v GEOP_SFC tmp.nc {filename} + rm tmp.nc + +fi + +# ---------------------------------------------------------- +# -- Create CH4 and CO variables (if CAMS not available) +# ---------------------------------------------------------- +if [[ "${{species2restart[*]}}" =~ "TRCH4" || "${{species2restart[*]}}" =~ "TRCO" ]]; then + + # ---------------------------------------------------------- + # -- Remap CAMS data (if CAMS available...) + # ---------------------------------------------------------- + + # # -- Convert the GRIB files to NetCDF + # cdo -t ecmwf -f nc copy cams.grib cams.nc + + # # -- Retrieve the dynamic horizontal grid + # cdo -s selgrid,2 {cfg.input_files_scratch_dynamics_grid_filename} triangular-grid.nc + + # # -- Remap + # cdo -s remapdis,triangular-grid.nc cams.nc cams_final.nc + # rm cams.nc + + # # -- Merge CAMS and ERA5 data + # ncks -h -A cams.nc tmp.nc + # rm cams.nc cams.grib + + # # -- Rename variables + # ncrename -h CH4,TRCH4 tmp.nc + # ncrename -h CO,TRCO tmp.nc + # ncks tmp.nc {filename} + # rm tmp.nc + + # ---------------------------------------------------------- + # -- Or just create basic variables + # ---------------------------------------------------------- + var_tracer="TRCH4{ext_restart}" + cdo expr,"TRCH4=QV / QV * 0.000002;" {filename} tmp.nc + if [ ! -z "{ext_restart}" ] ; then + ncrename -h -v TRCH4,${{var_tracer}} tmp.nc + fi + ncks -A -v ${{var_tracer}} tmp.nc {filename} + rm tmp.nc + + var_tracer="TRCO{ext_restart}" + cdo expr,"TRCO=QV / QV * 0.000002;" {filename} tmp.nc + if [ ! -z "{ext_restart}" ] ; then + ncrename -h -v TRCO,${{var_tracer}} tmp.nc + fi + ncks -A -v ${{var_tracer}} tmp.nc {filename} + rm tmp.nc + + +fi + diff --git a/cases/icon-art-CTDAS/icon_species_nudging.sh b/cases/icon-art-CTDAS/icon_species_nudging.sh new file mode 100644 index 00000000..061f15f8 --- /dev/null +++ b/cases/icon-art-CTDAS/icon_species_nudging.sh @@ -0,0 +1,55 @@ +#!/bin/bash + +cd {cfg.icon_input_icbc} + +# ---------------------------------------------------------- +# -- Replicate Q and GEOSP variables for ICON-ART +# ---------------------------------------------------------- + +cdo expr,'Q=QV;' {filename} tmp.nc +ncks -A -v Q tmp.nc {filename} +rm tmp.nc + +cdo expr,'GEOP_SFC=GEOSP;' {filename} tmp.nc +ncks -A -v GEOP_SFC tmp.nc {filename} +rm tmp.nc + +# ---------------------------------------------------------- +# -- Remap CAMS data (if CAMS available) +# ---------------------------------------------------------- + +# # -- Convert the GRIB files to NetCDF +# cdo -t ecmwf -f nc copy cams.grib cams.nc + +# # -- Retrieve the dynamic horizontal grid +# cdo -s selgrid,2 {cfg.input_files_scratch_dynamics_grid_filename} triangular-grid.nc + +# # -- Remap +# cdo -s remapdis,triangular-grid.nc cams.nc cams_final.nc +# rm cams.nc + +# # -- Merge CAMS and ERA5 data +# ncks -h -A cams.nc tmp.nc +# rm cams.nc cams.grib + +# # -- Rename variables +# ncrename -h CH4,TRCH4 tmp.nc +# ncrename -h CO,TRCO tmp.nc +# ncks tmp.nc {filename} +# rm tmp.nc + +# ---------------------------------------------------------- +# -- Create CH4 and CO variables (if CAMS not available) +# ---------------------------------------------------------- + +cdo expr,'TRCH4=QV / QV * 0.000002;' {filename} tmp.nc +ncks -A -v TRCH4 tmp.nc {filename} +rm tmp.nc + +cdo expr,'TRCO=QV / QV * 0.0000002;' {filename} tmp.nc +ncks -A -v TRCO tmp.nc {filename} +rm tmp.nc + +cdo expr,'TROH=QV / QV * 0.000004;' {filename} tmp.nc +ncks -A -v TROH tmp.nc {filename} +rm tmp.nc diff --git a/cases/icon-art-CTDAS/mypartab b/cases/icon-art-CTDAS/mypartab new file mode 100644 index 00000000..9552aa1f --- /dev/null +++ b/cases/icon-art-CTDAS/mypartab @@ -0,0 +1,117 @@ +¶meter ! temperature +name = "t" +out_name = "T" +/ +¶meter ! horiz. wind comp. u +name = "u" +out_name = "U" +/ +¶meter ! horiz. wind comp. u +name = "v" +out_name = "V" +/ +¶meter ! vertical velocity +name = "w" +out_name = "W" +/ +¶meter ! specific humidity +name = "q" +out_name = "QV" +/ +¶meter ! cloud liquid water content +name = "clwc" +out_name = "QC" +/ +¶meter ! cloud ice water content +name = "ciwc" +out_name = "QI" +/ +¶meter ! rain water content +name = "crwc" +out_name = "QR" +/ +¶meter ! snow water content +name = "cswc" +out_name = "QS" +/ +¶meter ! snow temperature +name = "TSN" +out_name = "T_SNOW" +/ +¶meter ! water content of snow +name = "SD" +out_name = "W_SNOW" +/ +¶meter ! density of snow +name = "RSN" +out_name = "RHO_SNOW" +/ +¶meter ! snow albedo +name = "ASN" +out_name = "ALB_SNOW" +/ +¶meter ! skin temperature +name = "SKT" +out_name = "SKT" +/ +¶meter ! sea surface temperature +name = "SSTK" +out_name = "SST" +/ +¶meter ! soil temperature level 1 +name = "STL1" +out_name = "STL1" +/ +¶meter ! soil temperature level 2 +name = "STL2" +out_name = "STL2" +/ +¶meter ! soil temperature level 3 +name = "STL3" +out_name = "STL3" +/ +¶meter ! soil temperature level 4 +name = "STL4" +out_name = "STL4" +/ +¶meter ! sea-ice cover +name = "CI" +out_name = "CI" +/ +¶meter ! water cont. of interception storage +name = "SRC" +out_name = "W_I" +/ +¶meter ! Land/sea mask +name = "LSM" +out_name = "LSM" +/ +¶meter ! soil moisture index layer 1 +name = "SWVL1" +out_name = "SMIL1" +/ +¶meter ! soil moisture index layer 2 +name = "SWVL2" +out_name = "SMIL2" +/ +¶meter ! soil moisture index layer 3 +name = "SWVL3" +out_name = "SMIL3" +/ +¶meter ! soil moisture index layer 4 +name = "SWVL4" +out_name = "SMIL4" +/ +¶meter ! logarithm of surface pressure +name = "LNSP" +out_name = "LNPS" +/ +¶meter ! logarithm of surface pressure +name = "SP" +out_name = "PS" +/ +¶meter +name = "Z" +out_name = "GEOSP" +/ + diff --git a/jobs/__init__.py b/jobs/__init__.py index 332f34a8..c9712c82 100644 --- a/jobs/__init__.py +++ b/jobs/__init__.py @@ -18,6 +18,7 @@ from . import prepare_art from . import prepare_art_oem from . import prepare_art_global +from . import prepare_CTDAS from . import prepare_cosmo from . import prepare_icon from . import reduce_output diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index f38c5ca2..d2426c7d 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -9,9 +9,9 @@ from . import tools, prepare_icon from pathlib import Path # noqa: F401 from .tools.interpolate_data import create_oh_for_restart, create_oh_for_inicond # noqa: F401 -from .tools.fetch_external_data import fetch_era5, fetch_era5_nudging, fetch_CAMS_CO2, fetch_ICOS, fetch_external_data +from .tools.fetch_external_data import fetch_era5, fetch_era5_nudging, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2 -BASIC_PYTHON_JOB = True +BASIC_PYTHON_JOB = False def main(cfg): @@ -32,107 +32,98 @@ def main(cfg): Object holding all user-configuration parameters as attributes. """ prepare_icon.set_cfg_variables(cfg) + print(cfg.print_config()) tools.change_logfile(cfg.logfile) logging.info("Prepare ICON-ART for CTDAS") # -- 1. Download ERA5 data and create the initial conditions file - if cfg.era5_inicond: + if cfg.meteo_fetch_era5: # -- Fetch ERA5 data - fetch_era5(cfg.startdate_sim, cfg.icon_input_icbc) - - # -- Copy ERA5 processing script (icon_era5_inicond.job) in workdir - with open(cfg.icon_era5_inijob) as input_file: - to_write = input_file.read() - output_file = os.path.join(cfg.icon_input_icbc, 'icon_era5_inicond.sh') - with open(output_file, "w") as outf: - outf.write(to_write.format(cfg=cfg)) - - # -- Copy mypartab in workdir - shutil.copy( - os.path.join(os.path.dirname(cfg.icon_era5_inijob), 'mypartab'), - os.path.join(cfg.icon_input_icbc, 'mypartab')) - - # -- Run ERA5 processing script - process = subprocess.Popen([ - "bash", - os.path.join(cfg.icon_input_icbc, 'icon_era5_inicond.sh') - ], - stdout=subprocess.PIPE) - process.communicate() - - # -- 2. Download CAMS CO2 data - if cfg.cams_inicond: - fetch_CAMS_CO2(cfg.startdate_sim, cfg.icon_input_icbc) + logging.info(f"Times considered now: {cfg.startdate_sim}, {cfg.enddate_sim}, {cfg.CTDAS_step}") + for time in tools.iter_hours(cfg.startdate_sim, + cfg.enddate_sim, + step=cfg.CTDAS_step): + logging.info("Fetching ERA5 initial data") + fetch_era5(time, cfg.icon_input_icbc, resolution=0.25) + + # -- Copy ERA5 processing script (icon_era5_inicond.job) in workdir. + logging.info("Preparing ERA5 preprocessing script for ICON") + era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob + era5_ini_job = cfg.icon_input_icbc / cfg.meteo_era5_inijob + inicond_filename = cfg.icon_input_icbc / f'era_{time.strftime('%Y%m%d%H')}_ini.nc' + with open(era5_ini_template, 'r') as infile, open(era5_ini_job, 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, inicond_filename=inicond_filename)) - # ((( Is there an interpolation step missing for inicond? I assume so...))) + # -- Copy mypartab in workdir + shutil.copy( + cfg.case_path / 'mypartab', + cfg.icon_input_icbc / 'mypartab') + + # -- Run ERA5 processing script + logging.info("Running ERA5 preprocessing script") + subprocess.run( + ["bash", cfg.icon_input_icbc / 'icon_era5_inicond.sh'], + check=True, + stdout=subprocess.PIPE) + + # -- 2. Download CAMS CO2 data (for a whole year) + if cfg.chem_fetch_CAMS: + fetch_CAMS_CO2(cfg.startdate_sim, cfg.icon_input_icbc) # -- 3. If global nudging, download and process ERA5 and CAMS data - if cfg.era5_cams_nudging: + if cfg.meteo_interpolate_CAMS_to_ERA5: for time in tools.iter_hours(cfg.startdate_sim, cfg.enddate_sim, - step=cfg.nudging_step): + step=cfg.meteo_nudging_step): # -- Give a name to the nudging file timestr = time.strftime('%Y%m%d%H') filename = 'era_{timestr}_nudging.nc'.format(timestr=timestr) # -- If initial time, copy the initial conditions to be used as boundary conditions - if time == cfg.startdate_sim and cfg.era5_inicond: - shutil.copy(cfg.input_files_scratch_inicond_filename, - os.path.join(cfg.icon_input_icbc, filename)) + if time == cfg.startdate_sim: + shutil.copy(cfg.icon_input_icbc / f'era_{timestr}_ini.nc', + cfg.icon_input_icbc / filename) continue # -- Fetch ERA5 data - fetch_era5_nudging(time, cfg.icon_input_icbc) + fetch_era5_nudging(time, cfg.icon_input_icbc, resolution=0.25) # -- Copy ERA5 processing script (icon_era5_nudging.job) in workdir - with open(cfg.icon_era5_nudgingjob) as input_file: - to_write = input_file.read() - output_file = os.path.join( - cfg.icon_input_icbc, 'icon_era5_nudging_{}.sh'.format(timestr)) - with open(output_file, "w") as outf: - outf.write(to_write.format(cfg=cfg, filename=filename)) + nudging_template = cfg.case_path / cfg.meteo_era5_nudgingjob + nudging_job = cfg.icon_input_icbc / f'icon_era5_nudging_{timestr}.sh' + with open(nudging_template, 'r') as infile, open(nudging_job, 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, filename=filename)) # -- Copy mypartab in workdir - if not os.path.exists(os.path.join(cfg.icon_input_icbc, - 'mypartab')): + if not os.path.exists(cfg.case_path / 'mypartab'): shutil.copy( - os.path.join(os.path.dirname(cfg.icon_era5_nudgingjob), - 'mypartab'), - os.path.join(cfg.icon_input_icbc, 'mypartab')) + cfg.case_path / 'mypartab', + cfg.icon_input_icbc / 'mypartab') # -- Run ERA5 processing script - process = subprocess.Popen([ - "bash", - os.path.join(cfg.icon_input_icbc, - 'icon_era5_nudging_{}.sh'.format(timestr)) - ], - stdout=subprocess.PIPE) - process.communicate() + subprocess.run( + ["bash", cfg.icon_input_icbc / f'icon_era5_nudging_{timestr}.sh'], + check=True, + stdout=subprocess.PIPE) # -- Copy CAMS processing script (icon_cams_nudging.job) in workdir - with open(cfg.icon_species_nudgingjob) as input_file: - to_write = input_file.read() - output_file = os.path.join( - cfg.icon_input_icbc, 'icon_cams_nudging_{}.sh'.format(timestr)) - with open(output_file, "w") as outf: - outf.write(to_write.format(cfg=cfg, filename=filename)) + cams_nudging_template = cfg.icon_species_nudgingjob + cams_nudging_job = cfg.icon_input_icbc / f'icon_cams_nudging_{timestr}.sh' + with open(cams_nudging_template, 'r') as infile, open(cams_nudging_job, 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, filename=filename)) # -- Run CAMS processing script - process = subprocess.Popen([ - "bash", - os.path.join(cfg.icon_input_icbc, - 'icon_cams_nudging_{}.sh'.format(timestr)) - ], - stdout=subprocess.PIPE) - process.communicate() + subprocess.run(["bash", cfg.icon_input_icbc / f'icon_cams_nudging_{timestr}.sh'], + check=True, + stdout=subprocess.PIPE) # -- 4. Download ICOS CO2 data - if cfg.fetch_ICOS: + if cfg.obs_fetch_icos: # -- This requires you to have accepted the ICOS license in your profile. # So, login to https://cpauth.icos-cp.eu/home/ , check the box, and # copy the cookie token on the bottom as your ICOS_cookie_token. - fetch_ICOS(cookie_token=cfg.ICOS_cookie_token, + fetch_ICOS_data(cookie_token=cfg.ICOS_cookie_token, start_date=cfg.startdate_sim, end_date=cfg.enddate_sim, save_path=cfg.ICOS_path, @@ -140,7 +131,7 @@ def main(cfg): 'co2', ]) - if cfg.fetch_OCO2: + if cfg.obs_fetch_oco2: # A user must do the following steps to allow # from getpass import getpass # import os @@ -160,12 +151,12 @@ def main(cfg): # file.write('HTTP.NETRC={}.netrc'.format(homeDir)) # file.close() # Popen('chmod og-rw ~/.netrc', shell=True) - fetch_external_data.fetch_OCO2(x, - y, - -8, - 30, - 35, - 65, - "/capstor/scratch/cscs/ekoene/temp", - product="OCO2_L2_Lite_FP_11.1r") + fetch_OCO2(x, + y, + -8, + 30, + 35, + 65, + "/capstor/scratch/cscs/ekoene/temp", + product="OCO2_L2_Lite_FP_11.1r") logging.info("OK") diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 80ea8187..6a9548bc 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -20,75 +20,78 @@ from datetime import datetime, timedelta -def fetch_era5(date, dir2move): - """Fetch ERA5 data from ECMWF for initial conditions - - Parameters - ---------- - date : initial date to fetch - - """ +def fetch_era5(date, dir2move, resolution=1.0): + url_cmd = f"grep 'cds' ~/.cdsapirc" + url = os.popen(url_cmd).read().strip().split(": ")[1] + key_cmd = f"sed -n '/cds/ {{n;p}}' ~/.cdsapirc" + key = os.popen(key_cmd).read().strip().split(": ")[1] + c = cdsapi.Client(url=url, key=key) + + if not os.path.isfile(os.path.join(dir2move, 'era5_ml.grib')): + """Fetch ERA5 data from ECMWF for initial conditions + + Parameters + ---------- + date : initial date to fetch + + """ + + # -- CRWC : Specific rain water content - 75 + # -- CSWC : Specific snow water content - 76 + # -- T : Temperature - 130 + # -- U : U component of wind - 131 + # -- V : V component of wind - 132 + # -- Q : Specific humidity - 133 + # -- W : Vertical velocity - 135 + # -- CLWC : Specific cloud liquid water content - 246 + # -- CIWC : Specific cloud ice water content - 247 + c.retrieve( + 'reanalysis-era5-complete', { + 'class': 'ea', + 'date': date.strftime('%Y-%m-%d'), + 'time': date.strftime('%H:%M:%S'), + 'expver': '1', + 'levelist': '1/to/137', + 'levtype': 'ml', + 'param': '75/76/130/131/132/133/135/246/247', + 'stream': 'oper', + 'type': 'an', + 'grid': '{resolution}/{resolution}', + }, 'era5_ml.grib') + shutil.move('era5_ml.grib', os.path.join(dir2move, 'era5_ml.grib')) + + if not os.path.isfile(os.path.join(dir2move, 'era5_surf.grib')): + # -- CI : Sea Ice Cover - 31 + # -- ASN : Snow albedo - 32 + # -- RSN : Snow density - 33 + # -- SST : Sea Surface Temperature - 34 + # -- SWV1 : Volumetric soil water layer 1 - 39 + # -- SWV2 : Volumetric soil water layer 2 - 40 + # -- SWV3 : Volumetric soil water layer 3 - 41 + # -- SWV4 : Volumetric soil water layer 4 - 42 + # -- SLT : Soil type - 43 + # -- Z : Geopotential - 129 + # -- SP : Surface pressure - 134 + # -- STL1 : Soil temperature level 1 - 139 + # -- SD : Snow depth - 141 + # -- STL2 : Soil temperature level 2 - 170 + # -- LSM : Land-Sea Mask - 172 + # -- STL3 : Soil temperature level 3 - 183 + # -- SRC : Skin reservoir content - 198 + # -- SKT : Skin Temperature - 235 + # -- STL4 : Soil temperature level 4 - 236 + # -- TSN : Temperature of snow layer - 238 + c.retrieve( + 'reanalysis-era5-single-levels', { + 'product_type': 'reanalysis', + 'param': + '31/32/33/34/39/40/41/42/43/129/134/139/141/170/172/183/198/235/236/238', + 'date': date.strftime('%Y-%m-%d'), + 'time': date.strftime('%H:%M:%S'), + 'grid': '{resolution}/{resolution}', + }, 'era5_surf.grib') - c = cdsapi.Client() - - # -- CRWC : Specific rain water content - 75 - # -- CSWC : Specific snow water content - 76 - # -- T : Temperature - 130 - # -- U : U component of wind - 131 - # -- V : V component of wind - 132 - # -- Q : Specific humidity - 133 - # -- W : Vertical velocity - 135 - # -- CLWC : Specific cloud liquid water content - 246 - # -- CIWC : Specific cloud ice water content - 247 - - c.retrieve( - 'reanalysis-era5-complete', { - 'class': 'ea', - 'date': date.strftime('%Y-%m-%d'), - 'time': date.strftime('%H:%M:%S'), - 'expver': '1', - 'levelist': - '1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34/35/36/37/38/39/40/41/42/43/44/45/46/47/48/49/50/51/52/53/54/55/56/57/58/59/60/61/62/63/64/65/66/67/68/69/70/71/72/73/74/75/76/77/78/79/80/81/82/83/84/85/86/87/88/89/90/91/92/93/94/95/96/97/98/99/100/101/102/103/104/105/106/107/108/109/110/111/112/113/114/115/116/117/118/119/120/121/122/123/124/125/126/127/128/129/130/131/132/133/134/135/136/137', - 'levtype': 'ml', - 'param': '75/76/130/131/132/133/135/246/247', - 'stream': 'oper', - 'type': 'an', - 'grid': '1.0/1.0', - }, 'era5_ml.grib') - - # -- CI : Sea Ice Cover - 31 - # -- ASN : Snow albedo - 32 - # -- RSN : Snow density - 33 - # -- SST : Sea Surface Temperature - 34 - # -- SWV1 : Volumetric soil water layer 1 - 39 - # -- SWV2 : Volumetric soil water layer 2 - 40 - # -- SWV3 : Volumetric soil water layer 3 - 41 - # -- SWV4 : Volumetric soil water layer 4 - 42 - # -- SLT : Soil type - 43 - # -- Z : Geopotential - 129 - # -- SP : Surface pressure - 134 - # -- STL1 : Soil temperature level 1 - 139 - # -- SD : Snow depth - 141 - # -- STL2 : Soil temperature level 2 - 170 - # -- LSM : Land-Sea Mask - 172 - # -- STL3 : Soil temperature level 3 - 183 - # -- SRC : Skin reservoir content - 198 - # -- SKT : Skin Temperature - 235 - # -- STL4 : Soil temperature level 4 - 236 - # -- TSN : Temperature of snow layer - 238 - - c.retrieve( - 'reanalysis-era5-single-levels', { - 'product_type': 'reanalysis', - 'param': - '31/32/33/34/39/40/41/42/43/129/134/139/141/170/172/183/198/235/236/238', - 'date': date.strftime('%Y-%m-%d'), - 'time': date.strftime('%H:%M:%S'), - 'grid': '1.0/1.0', - }, 'era5_surf.grib') - - shutil.move('era5_ml.grib', os.path.join(dir2move, 'era5_ml.grib')) - shutil.move('era5_surf.grib', os.path.join(dir2move, 'era5_surf.grib')) + shutil.move('era5_surf.grib', os.path.join(dir2move, 'era5_surf.grib')) def fetch_era5_nudging(date, dir2move): @@ -100,36 +103,39 @@ def fetch_era5_nudging(date, dir2move): """ - c = cdsapi.Client() - - c.retrieve( - 'reanalysis-era5-complete', { - 'class': 'ea', - 'date': date.strftime('%Y-%m-%d'), - 'time': date.strftime('%H:%M:%S'), - 'expver': '1', - 'levelist': - '1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34/35/36/37/38/39/40/41/42/43/44/45/46/47/48/49/50/51/52/53/54/55/56/57/58/59/60/61/62/63/64/65/66/67/68/69/70/71/72/73/74/75/76/77/78/79/80/81/82/83/84/85/86/87/88/89/90/91/92/93/94/95/96/97/98/99/100/101/102/103/104/105/106/107/108/109/110/111/112/113/114/115/116/117/118/119/120/121/122/123/124/125/126/127/128/129/130/131/132/133/134/135/136/137', - 'levtype': 'ml', - 'param': '75/76/130/131/132/133/135/246/247', - 'stream': 'oper', - 'type': 'an', - 'grid': '1.0/1.0', - }, 'era5_ml_nudging.grib') - - c.retrieve( - 'reanalysis-era5-single-levels', { - 'product_type': 'reanalysis', - 'param': '129/134', - 'date': date.strftime('%Y-%m-%d'), - 'time': date.strftime('%H:%M:%S'), - 'grid': '1.0/1.0', - }, 'era5_surf_nudging.grib') - - shutil.move('era5_ml_nudging.grib', - os.path.join(dir2move, 'era5_ml_nudging.grib')) - shutil.move('era5_surf_nudging.grib', - os.path.join(dir2move, 'era5_surf_nudging.grib')) + url_cmd = f"grep 'cds' ~/.cdsapirc" + url = os.popen(url_cmd).read().strip().split(": ")[1] + key_cmd = f"sed -n '/cds/ {{n;p}}' ~/.cdsapirc" + key = os.popen(key_cmd).read().strip().split(": ")[1] + c = cdsapi.Client(url=url, key=key) + if not os.path.isfile(os.path.join(dir2move, 'era5_ml_nudging.grib')): + c.retrieve( + 'reanalysis-era5-complete', { + 'class': 'ea', + 'date': date.strftime('%Y-%m-%d'), + 'time': date.strftime('%H:%M:%S'), + 'expver': '1', + 'levelist': + '1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34/35/36/37/38/39/40/41/42/43/44/45/46/47/48/49/50/51/52/53/54/55/56/57/58/59/60/61/62/63/64/65/66/67/68/69/70/71/72/73/74/75/76/77/78/79/80/81/82/83/84/85/86/87/88/89/90/91/92/93/94/95/96/97/98/99/100/101/102/103/104/105/106/107/108/109/110/111/112/113/114/115/116/117/118/119/120/121/122/123/124/125/126/127/128/129/130/131/132/133/134/135/136/137', + 'levtype': 'ml', + 'param': '75/76/130/131/132/133/135/246/247', + 'stream': 'oper', + 'type': 'an', + 'grid': '1.0/1.0', + }, 'era5_ml_nudging.grib') + shutil.move('era5_ml_nudging.grib', + os.path.join(dir2move, 'era5_ml_nudging.grib')) + if not os.path.isfile(os.path.join(dir2move, 'era5_surf_nudging.grib')): + c.retrieve( + 'reanalysis-era5-single-levels', { + 'product_type': 'reanalysis', + 'param': '129/134', + 'date': date.strftime('%Y-%m-%d'), + 'time': date.strftime('%H:%M:%S'), + 'grid': '1.0/1.0', + }, 'era5_surf_nudging.grib') + shutil.move('era5_surf_nudging.grib', + os.path.join(dir2move, 'era5_surf_nudging.grib')) def fetch_CAMS_CO2(date, dir2move): @@ -146,7 +152,11 @@ def fetch_CAMS_CO2(date, dir2move): if not os.path.exists(tmpdir): os.makedirs(tmpdir) - c = cdsapi.Client() + url_cmd = f"grep 'ads' ~/.cdsapirc" + url = os.popen(url_cmd).read().strip().split(": ")[1] + key_cmd = f"sed -n '/ads/ {{n;p}}' ~/.cdsapirc" + key = os.popen(key_cmd).read().strip().split(": ")[1] + c = cdsapi.Client(url=url, key=key) download = os.path.join(tmpdir, f'cams_GHG_{date.strftime("%Y")}.zip') if not os.path.isfile(download): From 8cab10bb2609ebf73735889ae71aa8ce5d28f2b5 Mon Sep 17 00:00:00 2001 From: efkmoene Date: Wed, 25 Sep 2024 15:06:40 +0200 Subject: [PATCH 09/42] Trying a few variations of vertically interpolating CAMS onto ERA5 --- cases/icon-art-CTDAS/icon_species_inicond.sh | 84 +++----------------- 1 file changed, 13 insertions(+), 71 deletions(-) diff --git a/cases/icon-art-CTDAS/icon_species_inicond.sh b/cases/icon-art-CTDAS/icon_species_inicond.sh index aa6d5a07..e63f5205 100644 --- a/cases/icon-art-CTDAS/icon_species_inicond.sh +++ b/cases/icon-art-CTDAS/icon_species_inicond.sh @@ -2,74 +2,16 @@ cd {cfg.icon_input_icbc} - -species2restart=($(echo {cfg.species2restart} | tr -d '[],')) - - -if [[ {cfg.lrestart} == '.FALSE.' ]]; then - - # ---------------------------------------------------------- - # -- Replicate Q and GEOSP variables for ICON-ART - # ---------------------------------------------------------- - - cdo expr,'Q=QV;' {filename} tmp.nc - ncks -A -v Q tmp.nc {filename} - rm tmp.nc - - cdo expr,'GEOP_SFC=GEOSP;' {filename} tmp.nc - ncks -A -v GEOP_SFC tmp.nc {filename} - rm tmp.nc - -fi - -# ---------------------------------------------------------- -# -- Create CH4 and CO variables (if CAMS not available) -# ---------------------------------------------------------- -if [[ "${{species2restart[*]}}" =~ "TRCH4" || "${{species2restart[*]}}" =~ "TRCO" ]]; then - - # ---------------------------------------------------------- - # -- Remap CAMS data (if CAMS available...) - # ---------------------------------------------------------- - - # # -- Convert the GRIB files to NetCDF - # cdo -t ecmwf -f nc copy cams.grib cams.nc - - # # -- Retrieve the dynamic horizontal grid - # cdo -s selgrid,2 {cfg.input_files_scratch_dynamics_grid_filename} triangular-grid.nc - - # # -- Remap - # cdo -s remapdis,triangular-grid.nc cams.nc cams_final.nc - # rm cams.nc - - # # -- Merge CAMS and ERA5 data - # ncks -h -A cams.nc tmp.nc - # rm cams.nc cams.grib - - # # -- Rename variables - # ncrename -h CH4,TRCH4 tmp.nc - # ncrename -h CO,TRCO tmp.nc - # ncks tmp.nc {filename} - # rm tmp.nc - - # ---------------------------------------------------------- - # -- Or just create basic variables - # ---------------------------------------------------------- - var_tracer="TRCH4{ext_restart}" - cdo expr,"TRCH4=QV / QV * 0.000002;" {filename} tmp.nc - if [ ! -z "{ext_restart}" ] ; then - ncrename -h -v TRCH4,${{var_tracer}} tmp.nc - fi - ncks -A -v ${{var_tracer}} tmp.nc {filename} - rm tmp.nc - - var_tracer="TRCO{ext_restart}" - cdo expr,"TRCO=QV / QV * 0.000002;" {filename} tmp.nc - if [ ! -z "{ext_restart}" ] ; then - ncrename -h -v TRCO,${{var_tracer}} tmp.nc - fi - ncks -A -v ${{var_tracer}} tmp.nc {filename} - rm tmp.nc - - -fi - +# Compute Pressure levels from hybrid model levels (CAMS: 80 levels) +ncap2 -s 'P_level[hlevel,latitude,longitude]=ap+bp*Psurf' {cams_file} -O cams_pressure.nc +ncap2 -s 'P_level_avg[level,latitude,longitude]=(P_level(1:$hlevel.size-1,:,:)+P_level(0:$hlevel.size-2,:,:))/2' cams_pressure.nc -O cams_pressure_avg.nc + +# Compute Pressure levels from hybrid model levels (IFS: 137 levels). The added complexity lies in the need to rename dimension 'nhym' to 'lev' +ncap2 -s 'P_level[time,nhym,ncells]=hyam+hybm*PS' era_2018010100_ini.nc -O era5_pressure.nc +ncks -v P_level era5_pressure.nc -O tmp1.nc +ncks -O -x -v P_level era5_pressure.nc tmp2.nc +ncrename -d nhym,lev tmp1.nc -O tmp3.nc +ncks -h -A tmp3.nc tmp2.nc +mv tmp2.nc era5_pressure.nc + +rm tmp*.nc \ No newline at end of file From 87443b96f9c24a5da536d907dccc396338b2fd85 Mon Sep 17 00:00:00 2001 From: efkmoene Date: Wed, 25 Sep 2024 15:21:44 +0200 Subject: [PATCH 10/42] Trying a few variations of vertically interpolating CAMS onto ERA5-2 --- cases/icon-art-CTDAS/icon_species_inicond.sh | 102 ++++++++++++++++++- 1 file changed, 97 insertions(+), 5 deletions(-) diff --git a/cases/icon-art-CTDAS/icon_species_inicond.sh b/cases/icon-art-CTDAS/icon_species_inicond.sh index e63f5205..e3d79e01 100644 --- a/cases/icon-art-CTDAS/icon_species_inicond.sh +++ b/cases/icon-art-CTDAS/icon_species_inicond.sh @@ -3,15 +3,107 @@ cd {cfg.icon_input_icbc} # Compute Pressure levels from hybrid model levels (CAMS: 80 levels) -ncap2 -s 'P_level[hlevel,latitude,longitude]=ap+bp*Psurf' {cams_file} -O cams_pressure.nc +ncap2 -s 'P_level[hlevel,latitude,longitude]=ap+bp*Psurf' cams_egg4_2018010100.nc -O cams_pressure.nc ncap2 -s 'P_level_avg[level,latitude,longitude]=(P_level(1:$hlevel.size-1,:,:)+P_level(0:$hlevel.size-2,:,:))/2' cams_pressure.nc -O cams_pressure_avg.nc +ncrename -v P_level_avg,plev cams_pressure_avg.nc -O cams_pressure.nc +cdo griddes era_2018010100_ini.nc > triangular-grid.nc +cdo remapdis,triangular-grid.nc cams_pressure.nc cams_triangle.nc -# Compute Pressure levels from hybrid model levels (IFS: 137 levels). The added complexity lies in the need to rename dimension 'nhym' to 'lev' +# Compute Pressure levels from hybrid model levels (IFS: 137 levels). The added complexity lies in the need to rename dimension 'nhym' to 'lev'. ncap2 -s 'P_level[time,nhym,ncells]=hyam+hybm*PS' era_2018010100_ini.nc -O era5_pressure.nc ncks -v P_level era5_pressure.nc -O tmp1.nc ncks -O -x -v P_level era5_pressure.nc tmp2.nc -ncrename -d nhym,lev tmp1.nc -O tmp3.nc +ncrename -d nhym,lev tmp1.nc -v P_level,plev -O tmp3.nc +ncwa -a time tmp3.nc -O tmp5.nc ncks -h -A tmp3.nc tmp2.nc -mv tmp2.nc era5_pressure.nc +ncap2 -s 'P0=1' tmp2.nc -O era5_pressure.nc +ncwa -a time era5_pressure.nc -O era5_pressure2.nc # Full file +ncks -C -v hyam,hybm,hyai,hybi,PS era5_pressure2.nc -O tmp.nc +ncap2 -s 'lnps[ncells]=ln(PS)' tmp.nc -O era5_pressure.nc +ncrename -d nhym,lev -d nhyi,ilev era5_pressure.nc -O era5_pressure2.nc -rm tmp*.nc \ No newline at end of file +# Create a 'light' file of what to remap +ncks -C -v plev,CO2 cams_triangle.nc -O cams_out.nc +ncrename -d level,lev cams_out.nc -O cams_out2.nc + +# Create a 'light' file of vertical information +# ncks -C -v hyam,hybm,hyai,hybi,PS data_in.nc -O tmp.nc +# ncap2 -s 'lnps[time,lat,lon]=ln(PS)' tmp.nc -O data_out.nc +# ncwa -a time data_out.nc -O tmp2.nc +# ncrename -d nhym,lev -d nhyi,lev_2 tmp2.nc -O data_out.nc +# ncap2 -s 'P0=1.0' data_out.nc -O data_out2.nc +# # ncatted -a history_of_appended_files,global,o,c,"" -a history,global,o,c,"" data_out2.nc -O data_out.nc + +# CAMS (lat/lon) +ncap2 -s 'P_level[hlevel,latitude,longitude]=ap+bp*Psurf' cams_egg4_2018010100.nc -O cams_pressure.nc +ncap2 -s 'P_level_avg[level,latitude,longitude]=(P_level(1:$hlevel.size-1,:,:)+P_level(0:$hlevel.size-2,:,:))/2' cams_pressure.nc -O cams_pressure_avg.nc +ncrename -v P_level_avg,plev cams_pressure_avg.nc -O cams_pressure.nc + + +mv tmp2.nc ERA5_plev.nc +mv cams_out2.nc CAMS_plev.nc + +# Remap triangles +ncremap --vrt_fl=ERA5_plev.nc CAMS_plev.nc cams_remapped.nc # Doesn't work... + +# Remap lat/lon.... OH, here lat/lon need to match! They don't, of course (or do they?) +ncremap --vrt_fl=data_out.nc + + +# Create a 'light' file of what to remap +ncks -C -v plev,CO2 cams_triangles.nc -O cams_out.nc +ncrename -d level,lev cams_out.nc -O cams_out2.nc + +ncremap -v CO2 --vrt_fl=data_out.nc cams_out2.nc cams_remapped.nc + +rm tmp*.nc + +# Horizontal interpolation +cdo griddes era_2018010100_ini.nc > triangular-grid.nc +cdo remapdis,triangular-grid.nc cams_pressure.nc cams_triangle.nc + + +# Add P0 to ERA5 data (lat/lon) +ncap2 -s 'P0=1.0' data_in.nc -O data_out.nc +ncremap --dst_fl=data_out.nc cams_egg4_2018010100.nc cams_horizontal.nc + + + +## RESTART +# 1. Remap to same lat/lon positions +cdo griddes data_in.nc > latlon-grid.txt +cdo remapbil,latlon-grid.txt cams_inp.nc cams_out.nc + +# 2. Write out the hybrid levels +cat >CAMS_levels.txt <> CAMS_levels.txt +echo '' >> CAMS_levels.txt +echo 'vctsize = 160' >> CAMS_levels.txt +echo 'vct = ' >> CAMS_levels.txt +ncks -v ap cams_out.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*ap = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt +ncks -v bp cams_out.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*bp = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt +echo '' >> CAMS_levels.txt +echo 'formula = "hyam hybm (mlev=ap+bp*aps)"' >> CAMS_levels.txt +cdo setzaxis,CAMS_levels.txt cams_out.nc cams_withhybrid.nc + +# 3. Prepare P0 presence +ncap2 -s 'P0=1.0; PS=PS(0,:,:)' data_in.nc -O data_in_with_P.nc +ncrename -O -v Psurf,PS -d level,lev -v level,lev cams_withhybrid.nc +ncap2 -s 'P0=1.0' cams_withhybrid.nc -O cams_withhybrid_with_P.nc + +# 4. Make 'light' file +ncks -C -v P0,PS,CO2,hyam,hybm,hyai,hybi cams_withhybrid_with_P.nc -O cams_light.nc +ncks -C -v P0,PS,hyam,hybm,hyai,hybi,lon,lat data_in_with_P.nc -O era5_light.nc + +# 5. Remap +ncremap --vrt_fl=data_in_with_P.nc -v CO2 cams_withhybrid_with_P.nc cams_remapped.nc \ No newline at end of file From cd41f08abbad1f58b70e778323c402d8bade424f Mon Sep 17 00:00:00 2001 From: efkmoene Date: Tue, 1 Oct 2024 08:27:10 +0200 Subject: [PATCH 11/42] ncremap for CAMS to ERA5 --- cases/icon-art-CTDAS/config.yaml | 16 +-- cases/icon-art-CTDAS/icon_era5_inicond.sh | 6 +- cases/icon-art-CTDAS/icon_era5_nudging.sh | 4 +- cases/icon-art-CTDAS/icon_species_inicond.sh | 114 +++++-------------- cases/icon-art-CTDAS/icon_species_nudging.sh | 2 + env/environment.yml | 1 + jobs/prepare_CTDAS.py | 56 +++++---- jobs/tools/fetch_external_data.py | 26 ++--- 8 files changed, 83 insertions(+), 142 deletions(-) diff --git a/cases/icon-art-CTDAS/config.yaml b/cases/icon-art-CTDAS/config.yaml index 006901ac..9e72fc88 100644 --- a/cases/icon-art-CTDAS/config.yaml +++ b/cases/icon-art-CTDAS/config.yaml @@ -29,10 +29,6 @@ walltime: prepare_CTDAS: '3:00:00' meteo: - dir: ./input/meteo - prefix: ifs_ - nameformat: '%Y%m%d%H' - suffix: .grb nudging_step: 3 fetch_era5: True interpolate_CAMS_to_ERA5: True @@ -43,15 +39,13 @@ meteo: chem: - dir: ./input/icon-art-global/chem - prefix: cams_gqpe_ - nameformat: '%Y%m%d_%H' - suffix: .grb nudging_step: 3 fetch_CAMS: True url: https://ads-beta.atmosphere.copernicus.eu/api key: 1c2e45b1-dd08-4bc4-90c8-15c06304ae69 - + cams_inijob: icon_species_inicond.sh + cams_nudgingjob: icon_species_nudging.sh + obs: fetch_ICOS: True ICOS_cookie_token: cpauthToken=WzE3MjcxODM4NTk5NjgsImVyaWsua29lbmVAZW1wYS5jaCIsIlNhbWwiXR4YD2F2BeORMmb6xC6b6emc8jk+SLcju2hKPUGcllTQa238n1qHvl9Nqwr16JLW3MKF0XwDos5eF9zR0t4mgd2MND2Fhq7KI+fEL8Dx8s+usFCCNOpP2ElvuNz/Z3ZEnZr5dyLEwnuo+1AoAugMkuT87DELhj5S4xuarBCIf7GcStTZzYHJAjWtxJ3VbUA5tepWULoqS+40EDagchfYz7A2fQYphTznAB5LlzxOEWMAn2/289UXZMrgce6Rlket3XAMM8TF17bDoHeh8js0kfdlbhZQ0RjbJ1Xjf4MGzYBLru5Rces49D5jQ3oSXF0AmsZnyFdcDjswccj68Nz8pc3X @@ -76,7 +70,7 @@ icon: species_nudgingjob: icon_species_nudging.sh output_writing_step: 6 compute_queue: normal - np_tot: 4 - np_io: 1 + np_tot: 32 + np_io: 3 np_restart: 1 np_prefetch: 1 \ No newline at end of file diff --git a/cases/icon-art-CTDAS/icon_era5_inicond.sh b/cases/icon-art-CTDAS/icon_era5_inicond.sh index 6fef139a..76c3231a 100644 --- a/cases/icon-art-CTDAS/icon_era5_inicond.sh +++ b/cases/icon-art-CTDAS/icon_era5_inicond.sh @@ -11,11 +11,11 @@ module load daint-mc CDO NCO rm -f {inicond_filename} # -- Convert the GRIB files to NetCDF -cdo -t ecmwf -f nc copy era5_ml.grib era5_ml.nc -cdo -t ecmwf -f nc copy era5_surf.grib era5_surf.nc +cdo -t ecmwf -f nc copy era5_ml_{datestr}.grib era5_ml_{datestr}.nc +cdo -t ecmwf -f nc copy era5_surf_{datestr}.grib era5_surf_{datestr}.nc # -- Put all variables in the same file -cdo merge era5_ml.nc era5_surf.nc era5_original.nc +cdo -O merge era5_ml.nc era5_surf.nc era5_original.nc # -- Change variable and coordinates names to be consistent with ICON nomenclature cdo setpartabn,mypartab,convert era5_original.nc tmp.nc diff --git a/cases/icon-art-CTDAS/icon_era5_nudging.sh b/cases/icon-art-CTDAS/icon_era5_nudging.sh index c65f1988..88279ee9 100644 --- a/cases/icon-art-CTDAS/icon_era5_nudging.sh +++ b/cases/icon-art-CTDAS/icon_era5_nudging.sh @@ -2,6 +2,8 @@ cd {cfg.icon_input_icbc} +module load daint-mc NCO CDO + # --------------------------------- # -- Pre-processing # --------------------------------- @@ -13,7 +15,7 @@ cdo -t ecmwf -f nc copy era5_ml_nudging.grib era5_ml_nudging.nc cdo -t ecmwf -f nc copy era5_surf_nudging.grib era5_surf_nudging.nc # -- Put all variables in the same file -cdo merge era5_ml_nudging.nc era5_surf_nudging.nc era5_original_nudging.nc +cdo -O merge era5_ml_nudging.nc era5_surf_nudging.nc era5_original_nudging.nc # -- Change variable and coordinates names to be consistent with ICON nomenclature cdo setpartabn,mypartab,convert era5_original_nudging.nc tmp.nc diff --git a/cases/icon-art-CTDAS/icon_species_inicond.sh b/cases/icon-art-CTDAS/icon_species_inicond.sh index e3d79e01..27335398 100644 --- a/cases/icon-art-CTDAS/icon_species_inicond.sh +++ b/cases/icon-art-CTDAS/icon_species_inicond.sh @@ -2,77 +2,15 @@ cd {cfg.icon_input_icbc} -# Compute Pressure levels from hybrid model levels (CAMS: 80 levels) -ncap2 -s 'P_level[hlevel,latitude,longitude]=ap+bp*Psurf' cams_egg4_2018010100.nc -O cams_pressure.nc -ncap2 -s 'P_level_avg[level,latitude,longitude]=(P_level(1:$hlevel.size-1,:,:)+P_level(0:$hlevel.size-2,:,:))/2' cams_pressure.nc -O cams_pressure_avg.nc -ncrename -v P_level_avg,plev cams_pressure_avg.nc -O cams_pressure.nc -cdo griddes era_2018010100_ini.nc > triangular-grid.nc -cdo remapdis,triangular-grid.nc cams_pressure.nc cams_triangle.nc +module load daint-mc CDO +source ~/miniconda3/bin/activate +conda init bash +source ~/.bashrc +conda activate /scratch/snx3000/ekoene/conda/NCO -# Compute Pressure levels from hybrid model levels (IFS: 137 levels). The added complexity lies in the need to rename dimension 'nhym' to 'lev'. -ncap2 -s 'P_level[time,nhym,ncells]=hyam+hybm*PS' era_2018010100_ini.nc -O era5_pressure.nc -ncks -v P_level era5_pressure.nc -O tmp1.nc -ncks -O -x -v P_level era5_pressure.nc tmp2.nc -ncrename -d nhym,lev tmp1.nc -v P_level,plev -O tmp3.nc -ncwa -a time tmp3.nc -O tmp5.nc -ncks -h -A tmp3.nc tmp2.nc -ncap2 -s 'P0=1' tmp2.nc -O era5_pressure.nc -ncwa -a time era5_pressure.nc -O era5_pressure2.nc # Full file -ncks -C -v hyam,hybm,hyai,hybi,PS era5_pressure2.nc -O tmp.nc -ncap2 -s 'lnps[ncells]=ln(PS)' tmp.nc -O era5_pressure.nc -ncrename -d nhym,lev -d nhyi,ilev era5_pressure.nc -O era5_pressure2.nc - -# Create a 'light' file of what to remap -ncks -C -v plev,CO2 cams_triangle.nc -O cams_out.nc -ncrename -d level,lev cams_out.nc -O cams_out2.nc - -# Create a 'light' file of vertical information -# ncks -C -v hyam,hybm,hyai,hybi,PS data_in.nc -O tmp.nc -# ncap2 -s 'lnps[time,lat,lon]=ln(PS)' tmp.nc -O data_out.nc -# ncwa -a time data_out.nc -O tmp2.nc -# ncrename -d nhym,lev -d nhyi,lev_2 tmp2.nc -O data_out.nc -# ncap2 -s 'P0=1.0' data_out.nc -O data_out2.nc -# # ncatted -a history_of_appended_files,global,o,c,"" -a history,global,o,c,"" data_out2.nc -O data_out.nc - -# CAMS (lat/lon) -ncap2 -s 'P_level[hlevel,latitude,longitude]=ap+bp*Psurf' cams_egg4_2018010100.nc -O cams_pressure.nc -ncap2 -s 'P_level_avg[level,latitude,longitude]=(P_level(1:$hlevel.size-1,:,:)+P_level(0:$hlevel.size-2,:,:))/2' cams_pressure.nc -O cams_pressure_avg.nc -ncrename -v P_level_avg,plev cams_pressure_avg.nc -O cams_pressure.nc - - -mv tmp2.nc ERA5_plev.nc -mv cams_out2.nc CAMS_plev.nc - -# Remap triangles -ncremap --vrt_fl=ERA5_plev.nc CAMS_plev.nc cams_remapped.nc # Doesn't work... - -# Remap lat/lon.... OH, here lat/lon need to match! They don't, of course (or do they?) -ncremap --vrt_fl=data_out.nc - - -# Create a 'light' file of what to remap -ncks -C -v plev,CO2 cams_triangles.nc -O cams_out.nc -ncrename -d level,lev cams_out.nc -O cams_out2.nc - -ncremap -v CO2 --vrt_fl=data_out.nc cams_out2.nc cams_remapped.nc - -rm tmp*.nc - -# Horizontal interpolation -cdo griddes era_2018010100_ini.nc > triangular-grid.nc -cdo remapdis,triangular-grid.nc cams_pressure.nc cams_triangle.nc - - -# Add P0 to ERA5 data (lat/lon) -ncap2 -s 'P0=1.0' data_in.nc -O data_out.nc -ncremap --dst_fl=data_out.nc cams_egg4_2018010100.nc cams_horizontal.nc - - - -## RESTART -# 1. Remap to same lat/lon positions -cdo griddes data_in.nc > latlon-grid.txt -cdo remapbil,latlon-grid.txt cams_inp.nc cams_out.nc +# 1. Remap +cdo griddes {inicond_filename} > triangular-grid.txt +cdo remapnn,triangular-grid.txt cams_egg4_2018010100.nc cams_triangle.nc # 2. Write out the hybrid levels cat >CAMS_levels.txt <> CAMS_levels.txt +ncks -v level cams_triangle.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*level = //' | sed 's/;$//'| tr -d '\n' >> CAMS_levels.txt echo '' >> CAMS_levels.txt echo 'vctsize = 160' >> CAMS_levels.txt echo 'vct = ' >> CAMS_levels.txt -ncks -v ap cams_out.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*ap = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt -ncks -v bp cams_out.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*bp = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt +ncks -v ap cams_triangle.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*ap = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt +ncks -v bp cams_triangle.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*bp = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt echo '' >> CAMS_levels.txt echo 'formula = "hyam hybm (mlev=ap+bp*aps)"' >> CAMS_levels.txt -cdo setzaxis,CAMS_levels.txt cams_out.nc cams_withhybrid.nc +cdo setzaxis,CAMS_levels.txt cams_triangle.nc cams_withhybrid.nc -# 3. Prepare P0 presence -ncap2 -s 'P0=1.0; PS=PS(0,:,:)' data_in.nc -O data_in_with_P.nc +# 3. Add required variables +# --- CAMS ncrename -O -v Psurf,PS -d level,lev -v level,lev cams_withhybrid.nc -ncap2 -s 'P0=1.0' cams_withhybrid.nc -O cams_withhybrid_with_P.nc - -# 4. Make 'light' file -ncks -C -v P0,PS,CO2,hyam,hybm,hyai,hybi cams_withhybrid_with_P.nc -O cams_light.nc -ncks -C -v P0,PS,hyam,hybm,hyai,hybi,lon,lat data_in_with_P.nc -O era5_light.nc - -# 5. Remap -ncremap --vrt_fl=data_in_with_P.nc -v CO2 cams_withhybrid_with_P.nc cams_remapped.nc \ No newline at end of file +ncap2 -s 'P0=1.0; lnsp=ln(PS); lev[lev]=array(0,1,$lev)' cams_withhybrid.nc -O cams_withhybrid_with_P.nc +ncks -C -v P0,PS,lnsp,CO2,hyam,hybm,hyai,hybi,lev,clon,clat cams_withhybrid_with_P.nc -O cams_light.nc +ncatted -a _FillValue,CO2,m,f,1.0e36 -O cams_light.nc +# --- ERA5 +ncap2 -s 'P0=1.0; PS=PS(0,:)' {inicond_filename} -O data_in_with_P.nc +ncks -C -v hyam,hybm,hyai,hybi,clon,clat,P0 data_in_with_P.nc -O era5_light.nc +ncks -A -v PS cams_light.nc era5_light.nc + +# 4. Remap +ncremap --vrt_fl=era5_light.nc -v CO2 cams_light.nc cams_remapped.nc +ncrename -O -d nhym,lev cams_remapped.nc + +# 5. Place in inicond file +ncks -A -v CO2 cams_remapped.nc {inicond_filename} +ncap2 -s 'CO2_new[time,lev,ncells]=CO2; CO2=CO2_new;' {inicond_filename} +ncks -C -O -x -v CO2_new {inicond_filename} diff --git a/cases/icon-art-CTDAS/icon_species_nudging.sh b/cases/icon-art-CTDAS/icon_species_nudging.sh index 061f15f8..0dd38baa 100644 --- a/cases/icon-art-CTDAS/icon_species_nudging.sh +++ b/cases/icon-art-CTDAS/icon_species_nudging.sh @@ -2,6 +2,8 @@ cd {cfg.icon_input_icbc} +module load daint-mc NCO CDO + # ---------------------------------------------------------- # -- Replicate Q and GEOSP variables for ICON-ART # ---------------------------------------------------------- diff --git a/env/environment.yml b/env/environment.yml index 3bad9ad5..94f1e47f 100644 --- a/env/environment.yml +++ b/env/environment.yml @@ -12,6 +12,7 @@ dependencies: - netcdf4 - pyyaml - cdsapi + - nco=4.9.0 - scikit-learn - f90nml - sphinx diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index d2426c7d..c0ca4983 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -40,35 +40,33 @@ def main(cfg): if cfg.meteo_fetch_era5: # -- Fetch ERA5 data logging.info(f"Times considered now: {cfg.startdate_sim}, {cfg.enddate_sim}, {cfg.CTDAS_step}") - for time in tools.iter_hours(cfg.startdate_sim, - cfg.enddate_sim, - step=cfg.CTDAS_step): - logging.info("Fetching ERA5 initial data") - fetch_era5(time, cfg.icon_input_icbc, resolution=0.25) - - # -- Copy ERA5 processing script (icon_era5_inicond.job) in workdir. - logging.info("Preparing ERA5 preprocessing script for ICON") - era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob - era5_ini_job = cfg.icon_input_icbc / cfg.meteo_era5_inijob - inicond_filename = cfg.icon_input_icbc / f'era_{time.strftime('%Y%m%d%H')}_ini.nc' - with open(era5_ini_template, 'r') as infile, open(era5_ini_job, 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, inicond_filename=inicond_filename)) - - # -- Copy mypartab in workdir - shutil.copy( - cfg.case_path / 'mypartab', - cfg.icon_input_icbc / 'mypartab') - - # -- Run ERA5 processing script - logging.info("Running ERA5 preprocessing script") - subprocess.run( - ["bash", cfg.icon_input_icbc / 'icon_era5_inicond.sh'], - check=True, - stdout=subprocess.PIPE) + logging.info("Fetching ERA5 initial data") + fetch_era5(cfg.startdate_sim, cfg.icon_input_icbc, resolution=0.25) # -- 2. Download CAMS CO2 data (for a whole year) if cfg.chem_fetch_CAMS: - fetch_CAMS_CO2(cfg.startdate_sim, cfg.icon_input_icbc) + fetch_CAMS_CO2(cfg.startdate_sim, cfg.icon_input_icbc) # This should be turned into a more central location I think. + + # -- 3. Process data + # --- ERA5 inicond + logging.info("Preparing ERA5 preprocessing script for ICON") + era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob + era5_ini_job = cfg.icon_input_icbc / cfg.meteo_era5_inijob + datestr = cfg.startdate_sim.strftime('%Y%m%d%H') + inicond_filename = cfg.icon_input_icbc / f"era_{datestr}_ini.nc" + with open(era5_ini_template, 'r') as infile, open(era5_ini_job, 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, inicond_filename=inicond_filename, datestr=datestr)) + shutil.copy(cfg.case_path / 'mypartab', cfg.icon_input_icbc / 'mypartab') + logging.info("Running ERA5 preprocessing script") + subprocess.run(["bash", era5_ini_job], check=True, stdout=subprocess.PIPE) + # --- CAMS inicond + logging.info("Preparing CAMS preprocessing script for ICON") + cams_ini_template = cfg.case_path / cfg.chem_cams_inijob + cams_ini_job = cfg.icon_input_icbc / cfg.chem_cams_inijob + with open(cams_ini_template, 'r') as infile, open(cams_ini_job, 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, inicond_filename=inicond_filename)) + logging.info("Running CAMS preprocessing script") + subprocess.run(["bash", cams_ini_job], check=True, stdout=subprocess.PIPE) # -- 3. If global nudging, download and process ERA5 and CAMS data if cfg.meteo_interpolate_CAMS_to_ERA5: @@ -97,9 +95,7 @@ def main(cfg): # -- Copy mypartab in workdir if not os.path.exists(cfg.case_path / 'mypartab'): - shutil.copy( - cfg.case_path / 'mypartab', - cfg.icon_input_icbc / 'mypartab') + shutil.copy(cfg.case_path / 'mypartab', cfg.icon_input_icbc / 'mypartab') # -- Run ERA5 processing script subprocess.run( @@ -108,7 +104,7 @@ def main(cfg): stdout=subprocess.PIPE) # -- Copy CAMS processing script (icon_cams_nudging.job) in workdir - cams_nudging_template = cfg.icon_species_nudgingjob + cams_nudging_template = cfg.case_path / cfg.icon_species_nudgingjob cams_nudging_job = cfg.icon_input_icbc / f'icon_cams_nudging_{timestr}.sh' with open(cams_nudging_template, 'r') as infile, open(cams_nudging_job, 'w') as outfile: outfile.write(infile.read().format(cfg=cfg, filename=filename)) diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 6a9548bc..815edb3c 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -27,7 +27,7 @@ def fetch_era5(date, dir2move, resolution=1.0): key = os.popen(key_cmd).read().strip().split(": ")[1] c = cdsapi.Client(url=url, key=key) - if not os.path.isfile(os.path.join(dir2move, 'era5_ml.grib')): + if not os.path.isfile(os.path.join(dir2move, f"era5_ml_{date.strftime('%Y-%m-%d')}.grib")): """Fetch ERA5 data from ECMWF for initial conditions Parameters @@ -56,11 +56,11 @@ def fetch_era5(date, dir2move, resolution=1.0): 'param': '75/76/130/131/132/133/135/246/247', 'stream': 'oper', 'type': 'an', - 'grid': '{resolution}/{resolution}', + 'grid': f'{resolution}/{resolution}', }, 'era5_ml.grib') - shutil.move('era5_ml.grib', os.path.join(dir2move, 'era5_ml.grib')) + shutil.move('era5_ml.grib', os.path.join(dir2move, f"era5_ml_{date.strftime('%Y-%m-%d')}.grib")) - if not os.path.isfile(os.path.join(dir2move, 'era5_surf.grib')): + if not os.path.isfile(os.path.join(dir2move, f"era5_surf_{date.strftime('%Y-%m-%d')}.grib")): # -- CI : Sea Ice Cover - 31 # -- ASN : Snow albedo - 32 # -- RSN : Snow density - 33 @@ -88,13 +88,13 @@ def fetch_era5(date, dir2move, resolution=1.0): '31/32/33/34/39/40/41/42/43/129/134/139/141/170/172/183/198/235/236/238', 'date': date.strftime('%Y-%m-%d'), 'time': date.strftime('%H:%M:%S'), - 'grid': '{resolution}/{resolution}', + 'grid': f'{resolution}/{resolution}', }, 'era5_surf.grib') - shutil.move('era5_surf.grib', os.path.join(dir2move, 'era5_surf.grib')) + shutil.move('era5_surf.grib', os.path.join(dir2move, f"era5_surf_{date.strftime('%Y-%m-%d')}.grib")) -def fetch_era5_nudging(date, dir2move): +def fetch_era5_nudging(date, dir2move, resolution=1.0): """Fetch ERA5 data from ECMWF for global nudging Parameters @@ -108,7 +108,7 @@ def fetch_era5_nudging(date, dir2move): key_cmd = f"sed -n '/cds/ {{n;p}}' ~/.cdsapirc" key = os.popen(key_cmd).read().strip().split(": ")[1] c = cdsapi.Client(url=url, key=key) - if not os.path.isfile(os.path.join(dir2move, 'era5_ml_nudging.grib')): + if not os.path.isfile(os.path.join(dir2move, f"era5_ml_nudging_{date.strftime('%Y-%m-%d%H')}.grib")): c.retrieve( 'reanalysis-era5-complete', { 'class': 'ea', @@ -121,21 +121,21 @@ def fetch_era5_nudging(date, dir2move): 'param': '75/76/130/131/132/133/135/246/247', 'stream': 'oper', 'type': 'an', - 'grid': '1.0/1.0', + 'grid': f'{resolution}/{resolution}', }, 'era5_ml_nudging.grib') shutil.move('era5_ml_nudging.grib', - os.path.join(dir2move, 'era5_ml_nudging.grib')) - if not os.path.isfile(os.path.join(dir2move, 'era5_surf_nudging.grib')): + os.path.join(dir2move, f"era5_ml_nudging_{date.strftime('%Y-%m-%d%H')}.grib")) + if not os.path.isfile(os.path.join(dir2move, f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib")): c.retrieve( 'reanalysis-era5-single-levels', { 'product_type': 'reanalysis', 'param': '129/134', 'date': date.strftime('%Y-%m-%d'), 'time': date.strftime('%H:%M:%S'), - 'grid': '1.0/1.0', + 'grid': f'{resolution}/{resolution}', }, 'era5_surf_nudging.grib') shutil.move('era5_surf_nudging.grib', - os.path.join(dir2move, 'era5_surf_nudging.grib')) + os.path.join(dir2move, f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib")) def fetch_CAMS_CO2(date, dir2move): From 49384b5b8cdc5b451b949c1ca0e4e408f53d2637 Mon Sep 17 00:00:00 2001 From: github-actions Date: Tue, 1 Oct 2024 06:27:45 +0000 Subject: [PATCH 12/42] GitHub Action: Apply Pep8-formatting --- jobs/prepare_CTDAS.py | 69 +++++++++++++++++++------------ jobs/tools/fetch_external_data.py | 44 +++++++++++++++----- 2 files changed, 75 insertions(+), 38 deletions(-) diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index c0ca4983..4101f141 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -39,13 +39,17 @@ def main(cfg): # -- 1. Download ERA5 data and create the initial conditions file if cfg.meteo_fetch_era5: # -- Fetch ERA5 data - logging.info(f"Times considered now: {cfg.startdate_sim}, {cfg.enddate_sim}, {cfg.CTDAS_step}") + logging.info( + f"Times considered now: {cfg.startdate_sim}, {cfg.enddate_sim}, {cfg.CTDAS_step}" + ) logging.info("Fetching ERA5 initial data") fetch_era5(cfg.startdate_sim, cfg.icon_input_icbc, resolution=0.25) # -- 2. Download CAMS CO2 data (for a whole year) if cfg.chem_fetch_CAMS: - fetch_CAMS_CO2(cfg.startdate_sim, cfg.icon_input_icbc) # This should be turned into a more central location I think. + fetch_CAMS_CO2( + cfg.startdate_sim, cfg.icon_input_icbc + ) # This should be turned into a more central location I think. # -- 3. Process data # --- ERA5 inicond @@ -54,8 +58,11 @@ def main(cfg): era5_ini_job = cfg.icon_input_icbc / cfg.meteo_era5_inijob datestr = cfg.startdate_sim.strftime('%Y%m%d%H') inicond_filename = cfg.icon_input_icbc / f"era_{datestr}_ini.nc" - with open(era5_ini_template, 'r') as infile, open(era5_ini_job, 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, inicond_filename=inicond_filename, datestr=datestr)) + with open(era5_ini_template, 'r') as infile, open(era5_ini_job, + 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + inicond_filename=inicond_filename, + datestr=datestr)) shutil.copy(cfg.case_path / 'mypartab', cfg.icon_input_icbc / 'mypartab') logging.info("Running ERA5 preprocessing script") subprocess.run(["bash", era5_ini_job], check=True, stdout=subprocess.PIPE) @@ -63,8 +70,10 @@ def main(cfg): logging.info("Preparing CAMS preprocessing script for ICON") cams_ini_template = cfg.case_path / cfg.chem_cams_inijob cams_ini_job = cfg.icon_input_icbc / cfg.chem_cams_inijob - with open(cams_ini_template, 'r') as infile, open(cams_ini_job, 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, inicond_filename=inicond_filename)) + with open(cams_ini_template, 'r') as infile, open(cams_ini_job, + 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + inicond_filename=inicond_filename)) logging.info("Running CAMS preprocessing script") subprocess.run(["bash", cams_ini_job], check=True, stdout=subprocess.PIPE) @@ -90,27 +99,33 @@ def main(cfg): # -- Copy ERA5 processing script (icon_era5_nudging.job) in workdir nudging_template = cfg.case_path / cfg.meteo_era5_nudgingjob nudging_job = cfg.icon_input_icbc / f'icon_era5_nudging_{timestr}.sh' - with open(nudging_template, 'r') as infile, open(nudging_job, 'w') as outfile: + with open(nudging_template, 'r') as infile, open(nudging_job, + 'w') as outfile: outfile.write(infile.read().format(cfg=cfg, filename=filename)) # -- Copy mypartab in workdir if not os.path.exists(cfg.case_path / 'mypartab'): - shutil.copy(cfg.case_path / 'mypartab', cfg.icon_input_icbc / 'mypartab') + shutil.copy(cfg.case_path / 'mypartab', + cfg.icon_input_icbc / 'mypartab') # -- Run ERA5 processing script - subprocess.run( - ["bash", cfg.icon_input_icbc / f'icon_era5_nudging_{timestr}.sh'], - check=True, - stdout=subprocess.PIPE) + subprocess.run([ + "bash", cfg.icon_input_icbc / f'icon_era5_nudging_{timestr}.sh' + ], + check=True, + stdout=subprocess.PIPE) # -- Copy CAMS processing script (icon_cams_nudging.job) in workdir cams_nudging_template = cfg.case_path / cfg.icon_species_nudgingjob cams_nudging_job = cfg.icon_input_icbc / f'icon_cams_nudging_{timestr}.sh' - with open(cams_nudging_template, 'r') as infile, open(cams_nudging_job, 'w') as outfile: + with open(cams_nudging_template, + 'r') as infile, open(cams_nudging_job, 'w') as outfile: outfile.write(infile.read().format(cfg=cfg, filename=filename)) # -- Run CAMS processing script - subprocess.run(["bash", cfg.icon_input_icbc / f'icon_cams_nudging_{timestr}.sh'], + subprocess.run([ + "bash", cfg.icon_input_icbc / f'icon_cams_nudging_{timestr}.sh' + ], check=True, stdout=subprocess.PIPE) @@ -120,12 +135,12 @@ def main(cfg): # So, login to https://cpauth.icos-cp.eu/home/ , check the box, and # copy the cookie token on the bottom as your ICOS_cookie_token. fetch_ICOS_data(cookie_token=cfg.ICOS_cookie_token, - start_date=cfg.startdate_sim, - end_date=cfg.enddate_sim, - save_path=cfg.ICOS_path, - species=[ - 'co2', - ]) + start_date=cfg.startdate_sim, + end_date=cfg.enddate_sim, + save_path=cfg.ICOS_path, + species=[ + 'co2', + ]) if cfg.obs_fetch_oco2: # A user must do the following steps to allow @@ -148,11 +163,11 @@ def main(cfg): # file.close() # Popen('chmod og-rw ~/.netrc', shell=True) fetch_OCO2(x, - y, - -8, - 30, - 35, - 65, - "/capstor/scratch/cscs/ekoene/temp", - product="OCO2_L2_Lite_FP_11.1r") + y, + -8, + 30, + 35, + 65, + "/capstor/scratch/cscs/ekoene/temp", + product="OCO2_L2_Lite_FP_11.1r") logging.info("OK") diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 815edb3c..c5dc4b88 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -27,7 +27,9 @@ def fetch_era5(date, dir2move, resolution=1.0): key = os.popen(key_cmd).read().strip().split(": ")[1] c = cdsapi.Client(url=url, key=key) - if not os.path.isfile(os.path.join(dir2move, f"era5_ml_{date.strftime('%Y-%m-%d')}.grib")): + if not os.path.isfile( + os.path.join(dir2move, + f"era5_ml_{date.strftime('%Y-%m-%d')}.grib")): """Fetch ERA5 data from ECMWF for initial conditions Parameters @@ -58,9 +60,14 @@ def fetch_era5(date, dir2move, resolution=1.0): 'type': 'an', 'grid': f'{resolution}/{resolution}', }, 'era5_ml.grib') - shutil.move('era5_ml.grib', os.path.join(dir2move, f"era5_ml_{date.strftime('%Y-%m-%d')}.grib")) - - if not os.path.isfile(os.path.join(dir2move, f"era5_surf_{date.strftime('%Y-%m-%d')}.grib")): + shutil.move( + 'era5_ml.grib', + os.path.join(dir2move, + f"era5_ml_{date.strftime('%Y-%m-%d')}.grib")) + + if not os.path.isfile( + os.path.join(dir2move, + f"era5_surf_{date.strftime('%Y-%m-%d')}.grib")): # -- CI : Sea Ice Cover - 31 # -- ASN : Snow albedo - 32 # -- RSN : Snow density - 33 @@ -91,7 +98,10 @@ def fetch_era5(date, dir2move, resolution=1.0): 'grid': f'{resolution}/{resolution}', }, 'era5_surf.grib') - shutil.move('era5_surf.grib', os.path.join(dir2move, f"era5_surf_{date.strftime('%Y-%m-%d')}.grib")) + shutil.move( + 'era5_surf.grib', + os.path.join(dir2move, + f"era5_surf_{date.strftime('%Y-%m-%d')}.grib")) def fetch_era5_nudging(date, dir2move, resolution=1.0): @@ -108,7 +118,10 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0): key_cmd = f"sed -n '/cds/ {{n;p}}' ~/.cdsapirc" key = os.popen(key_cmd).read().strip().split(": ")[1] c = cdsapi.Client(url=url, key=key) - if not os.path.isfile(os.path.join(dir2move, f"era5_ml_nudging_{date.strftime('%Y-%m-%d%H')}.grib")): + if not os.path.isfile( + os.path.join( + dir2move, + f"era5_ml_nudging_{date.strftime('%Y-%m-%d%H')}.grib")): c.retrieve( 'reanalysis-era5-complete', { 'class': 'ea', @@ -123,9 +136,15 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0): 'type': 'an', 'grid': f'{resolution}/{resolution}', }, 'era5_ml_nudging.grib') - shutil.move('era5_ml_nudging.grib', - os.path.join(dir2move, f"era5_ml_nudging_{date.strftime('%Y-%m-%d%H')}.grib")) - if not os.path.isfile(os.path.join(dir2move, f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib")): + shutil.move( + 'era5_ml_nudging.grib', + os.path.join( + dir2move, + f"era5_ml_nudging_{date.strftime('%Y-%m-%d%H')}.grib")) + if not os.path.isfile( + os.path.join( + dir2move, + f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib")): c.retrieve( 'reanalysis-era5-single-levels', { 'product_type': 'reanalysis', @@ -134,8 +153,11 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0): 'time': date.strftime('%H:%M:%S'), 'grid': f'{resolution}/{resolution}', }, 'era5_surf_nudging.grib') - shutil.move('era5_surf_nudging.grib', - os.path.join(dir2move, f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib")) + shutil.move( + 'era5_surf_nudging.grib', + os.path.join( + dir2move, + f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib")) def fetch_CAMS_CO2(date, dir2move): From 5c293b7cafc31e4c5234981a1c630eab8ab2042a Mon Sep 17 00:00:00 2001 From: efkmoene Date: Fri, 4 Oct 2024 09:53:41 +0200 Subject: [PATCH 13/42] updated ERA5 handling --- cases/icon-art-CTDAS/icon_era5_inicond.sh | 4 +- cases/icon-art-CTDAS/icon_species_nudging.sh | 104 +++++++++---------- jobs/prepare_CTDAS.py | 11 +- jobs/tools/fetch_external_data.py | 16 +-- 4 files changed, 64 insertions(+), 71 deletions(-) diff --git a/cases/icon-art-CTDAS/icon_era5_inicond.sh b/cases/icon-art-CTDAS/icon_era5_inicond.sh index 76c3231a..31c08e71 100644 --- a/cases/icon-art-CTDAS/icon_era5_inicond.sh +++ b/cases/icon-art-CTDAS/icon_era5_inicond.sh @@ -11,8 +11,8 @@ module load daint-mc CDO NCO rm -f {inicond_filename} # -- Convert the GRIB files to NetCDF -cdo -t ecmwf -f nc copy era5_ml_{datestr}.grib era5_ml_{datestr}.nc -cdo -t ecmwf -f nc copy era5_surf_{datestr}.grib era5_surf_{datestr}.nc +cdo -t ecmwf -f nc copy era5_ml_{datestr}.grib era5_ml.nc +cdo -t ecmwf -f nc copy era5_surf_{datestr}.grib era5_surf.nc # -- Put all variables in the same file cdo -O merge era5_ml.nc era5_surf.nc era5_original.nc diff --git a/cases/icon-art-CTDAS/icon_species_nudging.sh b/cases/icon-art-CTDAS/icon_species_nudging.sh index 0dd38baa..41b445c7 100644 --- a/cases/icon-art-CTDAS/icon_species_nudging.sh +++ b/cases/icon-art-CTDAS/icon_species_nudging.sh @@ -2,56 +2,54 @@ cd {cfg.icon_input_icbc} -module load daint-mc NCO CDO - -# ---------------------------------------------------------- -# -- Replicate Q and GEOSP variables for ICON-ART -# ---------------------------------------------------------- - -cdo expr,'Q=QV;' {filename} tmp.nc -ncks -A -v Q tmp.nc {filename} -rm tmp.nc - -cdo expr,'GEOP_SFC=GEOSP;' {filename} tmp.nc -ncks -A -v GEOP_SFC tmp.nc {filename} -rm tmp.nc - -# ---------------------------------------------------------- -# -- Remap CAMS data (if CAMS available) -# ---------------------------------------------------------- - -# # -- Convert the GRIB files to NetCDF -# cdo -t ecmwf -f nc copy cams.grib cams.nc - -# # -- Retrieve the dynamic horizontal grid -# cdo -s selgrid,2 {cfg.input_files_scratch_dynamics_grid_filename} triangular-grid.nc - -# # -- Remap -# cdo -s remapdis,triangular-grid.nc cams.nc cams_final.nc -# rm cams.nc - -# # -- Merge CAMS and ERA5 data -# ncks -h -A cams.nc tmp.nc -# rm cams.nc cams.grib - -# # -- Rename variables -# ncrename -h CH4,TRCH4 tmp.nc -# ncrename -h CO,TRCO tmp.nc -# ncks tmp.nc {filename} -# rm tmp.nc - -# ---------------------------------------------------------- -# -- Create CH4 and CO variables (if CAMS not available) -# ---------------------------------------------------------- - -cdo expr,'TRCH4=QV / QV * 0.000002;' {filename} tmp.nc -ncks -A -v TRCH4 tmp.nc {filename} -rm tmp.nc - -cdo expr,'TRCO=QV / QV * 0.0000002;' {filename} tmp.nc -ncks -A -v TRCO tmp.nc {filename} -rm tmp.nc - -cdo expr,'TROH=QV / QV * 0.000004;' {filename} tmp.nc -ncks -A -v TROH tmp.nc {filename} -rm tmp.nc +module load daint-mc CDO +source ~/miniconda3/bin/activate +conda init bash +source ~/.bashrc +conda activate /scratch/snx3000/ekoene/conda/NCO + +# 1. Remap +cdo griddes {filename} > triangular-grid.txt +cdo remapnn,triangular-grid.txt cams_egg4_2018010100.nc cams_triangle.nc + +# 2. Write out the hybrid levels +cat >CAMS_levels.txt <> CAMS_levels.txt +echo '' >> CAMS_levels.txt +echo 'vctsize = 160' >> CAMS_levels.txt +echo 'vct = ' >> CAMS_levels.txt +ncks -v ap cams_triangle.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*ap = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt +ncks -v bp cams_triangle.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*bp = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt +echo '' >> CAMS_levels.txt +echo 'formula = "hyam hybm (mlev=ap+bp*aps)"' >> CAMS_levels.txt +cdo setzaxis,CAMS_levels.txt cams_triangle.nc cams_withhybrid.nc + +# 3. Add required variables +# --- CAMS +ncrename -O -v Psurf,PS -d level,lev -v level,lev cams_withhybrid.nc +ncap2 -s 'P0=1.0; lnsp=ln(PS); lev[lev]=array(0,1,$lev)' cams_withhybrid.nc -O cams_withhybrid_with_P.nc +ncks -C -v P0,PS,lnsp,CO2,hyam,hybm,hyai,hybi,lev,clon,clat cams_withhybrid_with_P.nc -O cams_light.nc +ncatted -a _FillValue,CO2,m,f,1.0e36 -O cams_light.nc +# --- ERA5 +ncap2 -s 'P0=1.0; PS=PS(0,:)' {filename} -O data_in_with_P.nc +ncks -C -v hyam,hybm,hyai,hybi,clon,clat,P0 data_in_with_P.nc -O era5_light.nc +ncks -A -v PS cams_light.nc era5_light.nc + +# 4. Remap +ncremap --vrt_fl=era5_light.nc -v CO2 cams_light.nc cams_remapped.nc +ncrename -O -d nhym,lev cams_remapped.nc + +# 5. Place in inicond file +ncks -A -v CO2 cams_remapped.nc {filename} +ncap2 -s 'CO2_new[time,lev,ncells]=CO2; CO2=CO2_new;' {filename} +ncks -C -O -x -v CO2_new {filename} diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index c0ca4983..a27803cb 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -98,10 +98,7 @@ def main(cfg): shutil.copy(cfg.case_path / 'mypartab', cfg.icon_input_icbc / 'mypartab') # -- Run ERA5 processing script - subprocess.run( - ["bash", cfg.icon_input_icbc / f'icon_era5_nudging_{timestr}.sh'], - check=True, - stdout=subprocess.PIPE) + subprocess.run(["bash", nudging_job], check=True, stdout=subprocess.PIPE) # -- Copy CAMS processing script (icon_cams_nudging.job) in workdir cams_nudging_template = cfg.case_path / cfg.icon_species_nudgingjob @@ -110,9 +107,7 @@ def main(cfg): outfile.write(infile.read().format(cfg=cfg, filename=filename)) # -- Run CAMS processing script - subprocess.run(["bash", cfg.icon_input_icbc / f'icon_cams_nudging_{timestr}.sh'], - check=True, - stdout=subprocess.PIPE) + subprocess.run(["bash", cams_nudging_job], check=True, stdout=subprocess.PIPE) # -- 4. Download ICOS CO2 data if cfg.obs_fetch_icos: @@ -128,7 +123,7 @@ def main(cfg): ]) if cfg.obs_fetch_oco2: - # A user must do the following steps to allow + # A user must do the following steps to obtain access to OCO2 data # from getpass import getpass # import os # from subprocess import Popen diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 815edb3c..3ba442f2 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -27,7 +27,7 @@ def fetch_era5(date, dir2move, resolution=1.0): key = os.popen(key_cmd).read().strip().split(": ")[1] c = cdsapi.Client(url=url, key=key) - if not os.path.isfile(os.path.join(dir2move, f"era5_ml_{date.strftime('%Y-%m-%d')}.grib")): + if not os.path.isfile(os.path.join(dir2move, f"era5_ml_{date.strftime('%Y%m%d%H')}.grib")): """Fetch ERA5 data from ECMWF for initial conditions Parameters @@ -58,9 +58,9 @@ def fetch_era5(date, dir2move, resolution=1.0): 'type': 'an', 'grid': f'{resolution}/{resolution}', }, 'era5_ml.grib') - shutil.move('era5_ml.grib', os.path.join(dir2move, f"era5_ml_{date.strftime('%Y-%m-%d')}.grib")) + shutil.move('era5_ml.grib', os.path.join(dir2move, f"era5_ml_{date.strftime('%Y%m%d%H')}.grib")) - if not os.path.isfile(os.path.join(dir2move, f"era5_surf_{date.strftime('%Y-%m-%d')}.grib")): + if not os.path.isfile(os.path.join(dir2move, f"era5_surf_{date.strftime('%Y%m%d%H')}.grib")): # -- CI : Sea Ice Cover - 31 # -- ASN : Snow albedo - 32 # -- RSN : Snow density - 33 @@ -91,7 +91,7 @@ def fetch_era5(date, dir2move, resolution=1.0): 'grid': f'{resolution}/{resolution}', }, 'era5_surf.grib') - shutil.move('era5_surf.grib', os.path.join(dir2move, f"era5_surf_{date.strftime('%Y-%m-%d')}.grib")) + shutil.move('era5_surf.grib', os.path.join(dir2move, f"era5_surf_{date.strftime('%Y%m%d%H')}.grib")) def fetch_era5_nudging(date, dir2move, resolution=1.0): @@ -108,7 +108,7 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0): key_cmd = f"sed -n '/cds/ {{n;p}}' ~/.cdsapirc" key = os.popen(key_cmd).read().strip().split(": ")[1] c = cdsapi.Client(url=url, key=key) - if not os.path.isfile(os.path.join(dir2move, f"era5_ml_nudging_{date.strftime('%Y-%m-%d%H')}.grib")): + if not os.path.isfile(os.path.join(dir2move, f"era5_ml_nudging_{date.strftime('%Y%m%d%H%H')}.grib")): c.retrieve( 'reanalysis-era5-complete', { 'class': 'ea', @@ -124,8 +124,8 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0): 'grid': f'{resolution}/{resolution}', }, 'era5_ml_nudging.grib') shutil.move('era5_ml_nudging.grib', - os.path.join(dir2move, f"era5_ml_nudging_{date.strftime('%Y-%m-%d%H')}.grib")) - if not os.path.isfile(os.path.join(dir2move, f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib")): + os.path.join(dir2move, f"era5_ml_nudging_{date.strftime('%Y%m%d%H')}.grib")) + if not os.path.isfile(os.path.join(dir2move, f"era5_surf_nudging_{date.strftime('%Y%m%d%H')}.grib")): c.retrieve( 'reanalysis-era5-single-levels', { 'product_type': 'reanalysis', @@ -135,7 +135,7 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0): 'grid': f'{resolution}/{resolution}', }, 'era5_surf_nudging.grib') shutil.move('era5_surf_nudging.grib', - os.path.join(dir2move, f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib")) + os.path.join(dir2move, f"era5_surf_nudging_{date.strftime('%Y%m%d%H')}.grib")) def fetch_CAMS_CO2(date, dir2move): From 07aaae77a1a5612be05159264afb33e54dec3992 Mon Sep 17 00:00:00 2001 From: efkmoene Date: Fri, 4 Oct 2024 10:06:49 +0200 Subject: [PATCH 14/42] Incorporate PEP changes --- jobs/tools/fetch_external_data.py | 29 ----------------------------- 1 file changed, 29 deletions(-) diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 2fb09518..c5dc4b88 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -27,13 +27,9 @@ def fetch_era5(date, dir2move, resolution=1.0): key = os.popen(key_cmd).read().strip().split(": ")[1] c = cdsapi.Client(url=url, key=key) -<<<<<<< HEAD - if not os.path.isfile(os.path.join(dir2move, f"era5_ml_{date.strftime('%Y%m%d%H')}.grib")): -======= if not os.path.isfile( os.path.join(dir2move, f"era5_ml_{date.strftime('%Y-%m-%d')}.grib")): ->>>>>>> 49384b5b8cdc5b451b949c1ca0e4e408f53d2637 """Fetch ERA5 data from ECMWF for initial conditions Parameters @@ -64,11 +60,6 @@ def fetch_era5(date, dir2move, resolution=1.0): 'type': 'an', 'grid': f'{resolution}/{resolution}', }, 'era5_ml.grib') -<<<<<<< HEAD - shutil.move('era5_ml.grib', os.path.join(dir2move, f"era5_ml_{date.strftime('%Y%m%d%H')}.grib")) - - if not os.path.isfile(os.path.join(dir2move, f"era5_surf_{date.strftime('%Y%m%d%H')}.grib")): -======= shutil.move( 'era5_ml.grib', os.path.join(dir2move, @@ -77,7 +68,6 @@ def fetch_era5(date, dir2move, resolution=1.0): if not os.path.isfile( os.path.join(dir2move, f"era5_surf_{date.strftime('%Y-%m-%d')}.grib")): ->>>>>>> 49384b5b8cdc5b451b949c1ca0e4e408f53d2637 # -- CI : Sea Ice Cover - 31 # -- ASN : Snow albedo - 32 # -- RSN : Snow density - 33 @@ -108,14 +98,10 @@ def fetch_era5(date, dir2move, resolution=1.0): 'grid': f'{resolution}/{resolution}', }, 'era5_surf.grib') -<<<<<<< HEAD - shutil.move('era5_surf.grib', os.path.join(dir2move, f"era5_surf_{date.strftime('%Y%m%d%H')}.grib")) -======= shutil.move( 'era5_surf.grib', os.path.join(dir2move, f"era5_surf_{date.strftime('%Y-%m-%d')}.grib")) ->>>>>>> 49384b5b8cdc5b451b949c1ca0e4e408f53d2637 def fetch_era5_nudging(date, dir2move, resolution=1.0): @@ -132,14 +118,10 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0): key_cmd = f"sed -n '/cds/ {{n;p}}' ~/.cdsapirc" key = os.popen(key_cmd).read().strip().split(": ")[1] c = cdsapi.Client(url=url, key=key) -<<<<<<< HEAD - if not os.path.isfile(os.path.join(dir2move, f"era5_ml_nudging_{date.strftime('%Y%m%d%H%H')}.grib")): -======= if not os.path.isfile( os.path.join( dir2move, f"era5_ml_nudging_{date.strftime('%Y-%m-%d%H')}.grib")): ->>>>>>> 49384b5b8cdc5b451b949c1ca0e4e408f53d2637 c.retrieve( 'reanalysis-era5-complete', { 'class': 'ea', @@ -154,11 +136,6 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0): 'type': 'an', 'grid': f'{resolution}/{resolution}', }, 'era5_ml_nudging.grib') -<<<<<<< HEAD - shutil.move('era5_ml_nudging.grib', - os.path.join(dir2move, f"era5_ml_nudging_{date.strftime('%Y%m%d%H')}.grib")) - if not os.path.isfile(os.path.join(dir2move, f"era5_surf_nudging_{date.strftime('%Y%m%d%H')}.grib")): -======= shutil.move( 'era5_ml_nudging.grib', os.path.join( @@ -168,7 +145,6 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0): os.path.join( dir2move, f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib")): ->>>>>>> 49384b5b8cdc5b451b949c1ca0e4e408f53d2637 c.retrieve( 'reanalysis-era5-single-levels', { 'product_type': 'reanalysis', @@ -177,16 +153,11 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0): 'time': date.strftime('%H:%M:%S'), 'grid': f'{resolution}/{resolution}', }, 'era5_surf_nudging.grib') -<<<<<<< HEAD - shutil.move('era5_surf_nudging.grib', - os.path.join(dir2move, f"era5_surf_nudging_{date.strftime('%Y%m%d%H')}.grib")) -======= shutil.move( 'era5_surf_nudging.grib', os.path.join( dir2move, f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib")) ->>>>>>> 49384b5b8cdc5b451b949c1ca0e4e408f53d2637 def fetch_CAMS_CO2(date, dir2move): From 2cb0080d88081a5c3cb52b9c0cfd97f7d5090bff Mon Sep 17 00:00:00 2001 From: github-actions Date: Fri, 4 Oct 2024 08:07:16 +0000 Subject: [PATCH 15/42] GitHub Action: Apply Pep8-formatting --- jobs/prepare_CTDAS.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index b897d7a6..eca35a1e 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -109,7 +109,9 @@ def main(cfg): cfg.icon_input_icbc / 'mypartab') # -- Run ERA5 processing script - subprocess.run(["bash", nudging_job], check=True, stdout=subprocess.PIPE) + subprocess.run(["bash", nudging_job], + check=True, + stdout=subprocess.PIPE) # -- Copy CAMS processing script (icon_cams_nudging.job) in workdir cams_nudging_template = cfg.case_path / cfg.icon_species_nudgingjob @@ -119,7 +121,9 @@ def main(cfg): outfile.write(infile.read().format(cfg=cfg, filename=filename)) # -- Run CAMS processing script - subprocess.run(["bash", cams_nudging_job], check=True, stdout=subprocess.PIPE) + subprocess.run(["bash", cams_nudging_job], + check=True, + stdout=subprocess.PIPE) # -- 4. Download ICOS CO2 data if cfg.obs_fetch_icos: From c43f26acacfd9f145c336026e6f51a55e3a27aa5 Mon Sep 17 00:00:00 2001 From: efkmoene Date: Fri, 4 Oct 2024 16:57:53 +0200 Subject: [PATCH 16/42] Reorganize ERA5 downloading via CDS API --- jobs/tools/fetch_external_data.py | 154 ++++++++++++------------------ 1 file changed, 63 insertions(+), 91 deletions(-) diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index c5dc4b88..674c7243 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -19,25 +19,66 @@ from subprocess import Popen from datetime import datetime, timedelta - -def fetch_era5(date, dir2move, resolution=1.0): +def fetch_CDS(product, date, levels, params, resolution, outloc): + # Obtain CDS authentification from file url_cmd = f"grep 'cds' ~/.cdsapirc" url = os.popen(url_cmd).read().strip().split(": ")[1] key_cmd = f"sed -n '/cds/ {{n;p}}' ~/.cdsapirc" key = os.popen(key_cmd).read().strip().split(": ")[1] c = cdsapi.Client(url=url, key=key) - if not os.path.isfile( - os.path.join(dir2move, - f"era5_ml_{date.strftime('%Y-%m-%d')}.grib")): - """Fetch ERA5 data from ECMWF for initial conditions - - Parameters - ---------- - date : initial date to fetch + # Set temporal choices. ERA5 data on disk uses lists [2018-01-01, 2018-01-02, etc] while ERA5-complete uses strings with / as the separator + if isinstance(date, datetime): + datestr = date.strftime('%Y-%m-%d') + timestr = date.strftime('%H:%M') + elif isinstance(date, list): + datestr = sorted({dt.date().strftime("%Y-%m-%d") for dt in date}) + datestr = datestr if product=='reanalysis-era5-single-levels' else '/'.join(map(str, datestr)) + timestr = sorted({dt.time().strftime("%H:%M") for dt in date}) + timestr = timestr if product=='reanalysis-era5-single-levels' else '/'.join(map(str, timestr)) + else: + raise TypeError(f"Expected a datetime or list, but got {type(date).__name__}.") + + # Set level choices + if isinstance(levels, str): + levelstr = levels + elif isinstance(levels, list): + levelstr = '/'.join(map(str, levels)) + elif levels is None: + pass + else: + raise TypeError(f"Expected a string or list, but got {type(levels).__name__}.") + + # Set parameters + if isinstance(params, str): + paramstr = params + elif isinstance(params, list): + paramstr = '/'.join(map(str, params)) + else: + raise TypeError(f"Expected a string or list, but got {type(params).__name__}.") + + c.retrieve( + product, { + 'date': datestr, + 'time': timestr, + 'param': paramstr, + 'grid': f'{resolution}/{resolution}', + **({'class': 'ea', + 'type': 'an', + 'stream': 'oper', + 'levelist': levelstr, + 'levtype': 'ml', + 'expver': '1'} if product=='reanalysis-era5-complete' else {}), + **({'product_type': 'reanalysis'} if product=='reanalysis-era5-single-levels' else {}), + }, + outloc.name + ) + shutil.move(outloc.name,outloc) - """ +def fetch_era5(date, dir2move, resolution=1.0): + outfile = dir2move / f"era5_ml_{date.strftime('%Y-%m-%d')}.grib" + if not os.path.isfile(outfile): # -- CRWC : Specific rain water content - 75 # -- CSWC : Specific snow water content - 76 # -- T : Temperature - 130 @@ -47,27 +88,10 @@ def fetch_era5(date, dir2move, resolution=1.0): # -- W : Vertical velocity - 135 # -- CLWC : Specific cloud liquid water content - 246 # -- CIWC : Specific cloud ice water content - 247 - c.retrieve( - 'reanalysis-era5-complete', { - 'class': 'ea', - 'date': date.strftime('%Y-%m-%d'), - 'time': date.strftime('%H:%M:%S'), - 'expver': '1', - 'levelist': '1/to/137', - 'levtype': 'ml', - 'param': '75/76/130/131/132/133/135/246/247', - 'stream': 'oper', - 'type': 'an', - 'grid': f'{resolution}/{resolution}', - }, 'era5_ml.grib') - shutil.move( - 'era5_ml.grib', - os.path.join(dir2move, - f"era5_ml_{date.strftime('%Y-%m-%d')}.grib")) - - if not os.path.isfile( - os.path.join(dir2move, - f"era5_surf_{date.strftime('%Y-%m-%d')}.grib")): + fetch_CDS('reanalysis-era5-complete', date, '1/to/137', [75, 76, 130, 131, 132, 133, 135, 246, 247], resolution, outfile) + + outfile = dir2move / f"era5_surf_{date.strftime('%Y-%m-%d')}.grib" + if not os.path.isfile(outfile): # -- CI : Sea Ice Cover - 31 # -- ASN : Snow albedo - 32 # -- RSN : Snow density - 33 @@ -88,20 +112,7 @@ def fetch_era5(date, dir2move, resolution=1.0): # -- SKT : Skin Temperature - 235 # -- STL4 : Soil temperature level 4 - 236 # -- TSN : Temperature of snow layer - 238 - c.retrieve( - 'reanalysis-era5-single-levels', { - 'product_type': 'reanalysis', - 'param': - '31/32/33/34/39/40/41/42/43/129/134/139/141/170/172/183/198/235/236/238', - 'date': date.strftime('%Y-%m-%d'), - 'time': date.strftime('%H:%M:%S'), - 'grid': f'{resolution}/{resolution}', - }, 'era5_surf.grib') - - shutil.move( - 'era5_surf.grib', - os.path.join(dir2move, - f"era5_surf_{date.strftime('%Y-%m-%d')}.grib")) + fetch_CDS('reanalysis-era5-single-levels', date, None, [31, 32, 33, 34, 39, 40, 41, 42, 43, 129, 134, 139, 141, 170, 172, 183, 198, 235, 236, 238], resolution, outfile) def fetch_era5_nudging(date, dir2move, resolution=1.0): @@ -112,52 +123,13 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0): date : initial date to fetch """ + outfile = dir2move / f"era5_ml_nudging_{date.strftime('%Y-%m-%d%H')}.grib" + if not os.path.isfile(outfile): + fetch_CDS('reanalysis-era5-complete', date, '1/to/137', [75, 76, 130, 131, 132, 133, 135, 246, 247], resolution, outfile) - url_cmd = f"grep 'cds' ~/.cdsapirc" - url = os.popen(url_cmd).read().strip().split(": ")[1] - key_cmd = f"sed -n '/cds/ {{n;p}}' ~/.cdsapirc" - key = os.popen(key_cmd).read().strip().split(": ")[1] - c = cdsapi.Client(url=url, key=key) - if not os.path.isfile( - os.path.join( - dir2move, - f"era5_ml_nudging_{date.strftime('%Y-%m-%d%H')}.grib")): - c.retrieve( - 'reanalysis-era5-complete', { - 'class': 'ea', - 'date': date.strftime('%Y-%m-%d'), - 'time': date.strftime('%H:%M:%S'), - 'expver': '1', - 'levelist': - '1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34/35/36/37/38/39/40/41/42/43/44/45/46/47/48/49/50/51/52/53/54/55/56/57/58/59/60/61/62/63/64/65/66/67/68/69/70/71/72/73/74/75/76/77/78/79/80/81/82/83/84/85/86/87/88/89/90/91/92/93/94/95/96/97/98/99/100/101/102/103/104/105/106/107/108/109/110/111/112/113/114/115/116/117/118/119/120/121/122/123/124/125/126/127/128/129/130/131/132/133/134/135/136/137', - 'levtype': 'ml', - 'param': '75/76/130/131/132/133/135/246/247', - 'stream': 'oper', - 'type': 'an', - 'grid': f'{resolution}/{resolution}', - }, 'era5_ml_nudging.grib') - shutil.move( - 'era5_ml_nudging.grib', - os.path.join( - dir2move, - f"era5_ml_nudging_{date.strftime('%Y-%m-%d%H')}.grib")) - if not os.path.isfile( - os.path.join( - dir2move, - f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib")): - c.retrieve( - 'reanalysis-era5-single-levels', { - 'product_type': 'reanalysis', - 'param': '129/134', - 'date': date.strftime('%Y-%m-%d'), - 'time': date.strftime('%H:%M:%S'), - 'grid': f'{resolution}/{resolution}', - }, 'era5_surf_nudging.grib') - shutil.move( - 'era5_surf_nudging.grib', - os.path.join( - dir2move, - f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib")) + outfile = dir2move / f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib" + if not os.path.isfile(outfile): + fetch_CDS('reanalysis-era5-single-levels', date, None, [31, 32, 33, 34, 39, 40, 41, 42, 43, 129, 134, 139, 141, 170, 172, 183, 198, 235, 236, 238], resolution, outfile) def fetch_CAMS_CO2(date, dir2move): From 61bd2a955d76471ea40871df070b78570dd579e9 Mon Sep 17 00:00:00 2001 From: github-actions Date: Fri, 4 Oct 2024 14:59:49 +0000 Subject: [PATCH 17/42] GitHub Action: Apply Pep8-formatting --- jobs/tools/fetch_external_data.py | 70 ++++++++++++++++++++----------- 1 file changed, 46 insertions(+), 24 deletions(-) diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 674c7243..aa06737d 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -19,6 +19,7 @@ from subprocess import Popen from datetime import datetime, timedelta + def fetch_CDS(product, date, levels, params, resolution, outloc): # Obtain CDS authentification from file url_cmd = f"grep 'cds' ~/.cdsapirc" @@ -27,17 +28,20 @@ def fetch_CDS(product, date, levels, params, resolution, outloc): key = os.popen(key_cmd).read().strip().split(": ")[1] c = cdsapi.Client(url=url, key=key) - # Set temporal choices. ERA5 data on disk uses lists [2018-01-01, 2018-01-02, etc] while ERA5-complete uses strings with / as the separator + # Set temporal choices. ERA5 data on disk uses lists [2018-01-01, 2018-01-02, etc] while ERA5-complete uses strings with / as the separator if isinstance(date, datetime): datestr = date.strftime('%Y-%m-%d') timestr = date.strftime('%H:%M') elif isinstance(date, list): datestr = sorted({dt.date().strftime("%Y-%m-%d") for dt in date}) - datestr = datestr if product=='reanalysis-era5-single-levels' else '/'.join(map(str, datestr)) + datestr = datestr if product == 'reanalysis-era5-single-levels' else '/'.join( + map(str, datestr)) timestr = sorted({dt.time().strftime("%H:%M") for dt in date}) - timestr = timestr if product=='reanalysis-era5-single-levels' else '/'.join(map(str, timestr)) + timestr = timestr if product == 'reanalysis-era5-single-levels' else '/'.join( + map(str, timestr)) else: - raise TypeError(f"Expected a datetime or list, but got {type(date).__name__}.") + raise TypeError( + f"Expected a datetime or list, but got {type(date).__name__}.") # Set level choices if isinstance(levels, str): @@ -47,33 +51,41 @@ def fetch_CDS(product, date, levels, params, resolution, outloc): elif levels is None: pass else: - raise TypeError(f"Expected a string or list, but got {type(levels).__name__}.") - + raise TypeError( + f"Expected a string or list, but got {type(levels).__name__}.") + # Set parameters if isinstance(params, str): paramstr = params elif isinstance(params, list): paramstr = '/'.join(map(str, params)) else: - raise TypeError(f"Expected a string or list, but got {type(params).__name__}.") + raise TypeError( + f"Expected a string or list, but got {type(params).__name__}.") c.retrieve( product, { - 'date': datestr, - 'time': timestr, - 'param': paramstr, - 'grid': f'{resolution}/{resolution}', - **({'class': 'ea', + 'date': + datestr, + 'time': + timestr, + 'param': + paramstr, + 'grid': + f'{resolution}/{resolution}', + **({ + 'class': 'ea', 'type': 'an', 'stream': 'oper', - 'levelist': levelstr, - 'levtype': 'ml', - 'expver': '1'} if product=='reanalysis-era5-complete' else {}), - **({'product_type': 'reanalysis'} if product=='reanalysis-era5-single-levels' else {}), - }, - outloc.name - ) - shutil.move(outloc.name,outloc) + 'levelist': levelstr, + 'levtype': 'ml', + 'expver': '1' + } if product == 'reanalysis-era5-complete' else {}), + **({ + 'product_type': 'reanalysis' + } if product == 'reanalysis-era5-single-levels' else {}), + }, outloc.name) + shutil.move(outloc.name, outloc) def fetch_era5(date, dir2move, resolution=1.0): @@ -88,7 +100,9 @@ def fetch_era5(date, dir2move, resolution=1.0): # -- W : Vertical velocity - 135 # -- CLWC : Specific cloud liquid water content - 246 # -- CIWC : Specific cloud ice water content - 247 - fetch_CDS('reanalysis-era5-complete', date, '1/to/137', [75, 76, 130, 131, 132, 133, 135, 246, 247], resolution, outfile) + fetch_CDS('reanalysis-era5-complete', date, '1/to/137', + [75, 76, 130, 131, 132, 133, 135, 246, 247], resolution, + outfile) outfile = dir2move / f"era5_surf_{date.strftime('%Y-%m-%d')}.grib" if not os.path.isfile(outfile): @@ -112,7 +126,10 @@ def fetch_era5(date, dir2move, resolution=1.0): # -- SKT : Skin Temperature - 235 # -- STL4 : Soil temperature level 4 - 236 # -- TSN : Temperature of snow layer - 238 - fetch_CDS('reanalysis-era5-single-levels', date, None, [31, 32, 33, 34, 39, 40, 41, 42, 43, 129, 134, 139, 141, 170, 172, 183, 198, 235, 236, 238], resolution, outfile) + fetch_CDS('reanalysis-era5-single-levels', date, None, [ + 31, 32, 33, 34, 39, 40, 41, 42, 43, 129, 134, 139, 141, 170, 172, + 183, 198, 235, 236, 238 + ], resolution, outfile) def fetch_era5_nudging(date, dir2move, resolution=1.0): @@ -125,11 +142,16 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0): """ outfile = dir2move / f"era5_ml_nudging_{date.strftime('%Y-%m-%d%H')}.grib" if not os.path.isfile(outfile): - fetch_CDS('reanalysis-era5-complete', date, '1/to/137', [75, 76, 130, 131, 132, 133, 135, 246, 247], resolution, outfile) + fetch_CDS('reanalysis-era5-complete', date, '1/to/137', + [75, 76, 130, 131, 132, 133, 135, 246, 247], resolution, + outfile) outfile = dir2move / f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib" if not os.path.isfile(outfile): - fetch_CDS('reanalysis-era5-single-levels', date, None, [31, 32, 33, 34, 39, 40, 41, 42, 43, 129, 134, 139, 141, 170, 172, 183, 198, 235, 236, 238], resolution, outfile) + fetch_CDS('reanalysis-era5-single-levels', date, None, [ + 31, 32, 33, 34, 39, 40, 41, 42, 43, 129, 134, 139, 141, 170, 172, + 183, 198, 235, 236, 238 + ], resolution, outfile) def fetch_CAMS_CO2(date, dir2move): From d7fb6d7b777f5571d3d207ace29889607b70767b Mon Sep 17 00:00:00 2001 From: efkmoene Date: Fri, 4 Oct 2024 17:14:27 +0200 Subject: [PATCH 18/42] Remove useless shutil data movement --- jobs/tools/fetch_external_data.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index aa06737d..7cedfb80 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -84,8 +84,7 @@ def fetch_CDS(product, date, levels, params, resolution, outloc): **({ 'product_type': 'reanalysis' } if product == 'reanalysis-era5-single-levels' else {}), - }, outloc.name) - shutil.move(outloc.name, outloc) + }, outloc) def fetch_era5(date, dir2move, resolution=1.0): From 7904cc256b15a43b48cd4cee59aa32088074c820 Mon Sep 17 00:00:00 2001 From: efkmoene Date: Fri, 18 Oct 2024 13:59:28 +0200 Subject: [PATCH 19/42] Full ERA5 support and ICOS and OCO2, processing remaining --- cases/icon-art-CTDAS/config.yaml | 5 +- cases/icon-art-CTDAS/icon_era5_inicond.sh | 24 +- cases/icon-art-CTDAS/icon_era5_nudging.sh | 14 +- cases/icon-art-CTDAS/icon_era5_splitfiles.sh | 38 +++ cases/icon-art-CTDAS/icon_species_inicond.sh | 2 +- jobs/prepare_CTDAS.py | 225 ++++++++------ jobs/tools/__init__.py | 7 + jobs/tools/fetch_external_data.py | 306 +++++++++++++++++-- 8 files changed, 478 insertions(+), 143 deletions(-) create mode 100644 cases/icon-art-CTDAS/icon_era5_splitfiles.sh diff --git a/cases/icon-art-CTDAS/config.yaml b/cases/icon-art-CTDAS/config.yaml index 9e72fc88..147ae838 100644 --- a/cases/icon-art-CTDAS/config.yaml +++ b/cases/icon-art-CTDAS/config.yaml @@ -34,6 +34,7 @@ meteo: interpolate_CAMS_to_ERA5: True url: https://cds-beta.climate.copernicus.eu/api key: 1c2e45b1-dd08-4bc4-90c8-15c06304ae69 + era5_splitjob: icon_era5_splitfiles.sh era5_inijob: icon_era5_inicond.sh era5_nudgingjob: icon_era5_nudging.sh @@ -48,8 +49,10 @@ chem: obs: fetch_ICOS: True - ICOS_cookie_token: cpauthToken=WzE3MjcxODM4NTk5NjgsImVyaWsua29lbmVAZW1wYS5jaCIsIlNhbWwiXR4YD2F2BeORMmb6xC6b6emc8jk+SLcju2hKPUGcllTQa238n1qHvl9Nqwr16JLW3MKF0XwDos5eF9zR0t4mgd2MND2Fhq7KI+fEL8Dx8s+usFCCNOpP2ElvuNz/Z3ZEnZr5dyLEwnuo+1AoAugMkuT87DELhj5S4xuarBCIf7GcStTZzYHJAjWtxJ3VbUA5tepWULoqS+40EDagchfYz7A2fQYphTznAB5LlzxOEWMAn2/289UXZMrgce6Rlket3XAMM8TF17bDoHeh8js0kfdlbhZQ0RjbJ1Xjf4MGzYBLru5Rces49D5jQ3oSXF0AmsZnyFdcDjswccj68Nz8pc3X + ICOS_cookie_token: cpauthToken=WzE3MjkzNDMxNzIwNDQsImVyaWsua29lbmVAZW1wYS5jaCIsIlNhbWwiXR4FTcOofdFdurBv8MhnBQBBWQat65zbti2OCQ0t9tZd+rjAthGsn/WVSTwh/FadK3GpF0lh4Y1vxHMCuJKiytEMFREApm/O1TeA+2v1u7h8U0hAjn1Ao+ROzB/avbCzkI9vfxHOi2tTPOC4UomO99Dq7hZo0nNDYffeN4nxWd6kXoG3N6YKp5TzqZveL4GgWogZtaQm90+MdF5+NcPdxTM4mjD3qqsDG2TfwXttRd2WcSNhdAGE1b6o70wP1z22MewNhdCKmLLQH1mnhSXcfCJAwe67rugsSwAkWFpc0yusGylQKkdYiHYQw8vcYlkz1qgs1MNGB8URsHuETblnjqbG + ICOS_path: /scratch/snx3000/ekoene/ICOS/ fetch_OCO2: True + OCO2_path: /scratch/snx3000/ekoene/OCO2 input_files: inicond_filename: ./input/icon-art-global/icbc/era2icon_R2B03_2022060200.nc diff --git a/cases/icon-art-CTDAS/icon_era5_inicond.sh b/cases/icon-art-CTDAS/icon_era5_inicond.sh index 31c08e71..a162e15e 100644 --- a/cases/icon-art-CTDAS/icon_era5_inicond.sh +++ b/cases/icon-art-CTDAS/icon_era5_inicond.sh @@ -8,21 +8,15 @@ module load daint-mc CDO NCO # -- Pre-processing # --------------------------------- -rm -f {inicond_filename} - -# -- Convert the GRIB files to NetCDF -cdo -t ecmwf -f nc copy era5_ml_{datestr}.grib era5_ml.nc -cdo -t ecmwf -f nc copy era5_surf_{datestr}.grib era5_surf.nc - # -- Put all variables in the same file -cdo -O merge era5_ml.nc era5_surf.nc era5_original.nc +cdo -O merge {era5_ml_file} {era5_surf_file} era5_original.nc # -- Change variable and coordinates names to be consistent with ICON nomenclature cdo setpartabn,mypartab,convert era5_original.nc tmp.nc -# -- Order the variables alphabetically -ncks tmp.nc data_in.nc -rm tmp.nc era5_surf.nc era5_ml.nc era5_original.nc +# -- Order the variables alphabetically +ncks -O tmp.nc data_in.nc +rm tmp.nc era5_original.nc # --------------------------------- # -- Re-mapping @@ -52,10 +46,10 @@ cdo setrtoc2,0.5,1.0,1,0 LSM_out_tmp.nc LSM_out.nc rm LSM_in.nc LSM_out_tmp.nc # -- Select surface sea variables defined only on sea -ncks -h -v SST,CI data_in.nc datasea_in.nc +ncks -O -h -v SST,CI data_in.nc datasea_in.nc # -- Select surface variables defined on both that must be remap differently on sea and on land -ncks -h -v SKT,STL1,STL2,STL3,STL4,ALB_SNOW,W_SNOW,T_SNOW data_in.nc dataland_in.nc +ncks -O -h -v SKT,STL1,STL2,STL3,STL4,ALB_SNOW,W_SNOW,T_SNOW data_in.nc dataland_in.nc # ----------------------------------------------------------------------------- # -- Remap land and ocean area differently for variables @@ -102,7 +96,7 @@ rm dataland_ocean_out.nc dataland_land_out.nc # -------------------------------------- # -- Select all variables apart from these ones -ncks -h -x -v SKT,STL1,STL2,STL3,STL4,SMIL1,SMIL2,SMIL3,SMIL4,ALB_SNOW,W_SNOW,T_SNOW,SST,CI,LSM data_in.nc datarest_in.nc +ncks -O -h -x -v SKT,STL1,STL2,STL3,STL4,SMIL1,SMIL2,SMIL3,SMIL4,ALB_SNOW,W_SNOW,T_SNOW,SST,CI,LSM data_in.nc datarest_in.nc # -- Remap cdo -s remapdis,triangular-grid.nc datarest_in.nc era5_final.nc @@ -129,7 +123,7 @@ rm LSM_out.nc dataland_out.nc wiltingp=(0 0.059 0.151 0.133 0.279 0.335 0.267 0.151) # wilting point fieldcap=(0 0.244 0.347 0.383 0.448 0.541 0.663 0.347) # field capacity -ncks -h -v SMIL1,SMIL2,SMIL3,SMIL4,SLT data_in.nc swvl.nc +ncks -O -h -v SMIL1,SMIL2,SMIL3,SMIL4,SLT data_in.nc swvl.nc rm data_in.nc # -- Loop over the soil types and apply the right constants @@ -173,7 +167,7 @@ rm tmp.nc # -- Rename dimensions and order alphabetically ncrename -h -d cell,ncells era5_final.nc ncrename -h -d nv,vertices era5_final.nc -ncks era5_final.nc {inicond_filename} +ncks -O era5_final.nc {inicond_filename} rm era5_final.nc # -- Clean the repository diff --git a/cases/icon-art-CTDAS/icon_era5_nudging.sh b/cases/icon-art-CTDAS/icon_era5_nudging.sh index 88279ee9..736ce571 100644 --- a/cases/icon-art-CTDAS/icon_era5_nudging.sh +++ b/cases/icon-art-CTDAS/icon_era5_nudging.sh @@ -10,19 +10,15 @@ module load daint-mc NCO CDO rm -f {filename} -# -- Convert the GRIB files to NetCDF -cdo -t ecmwf -f nc copy era5_ml_nudging.grib era5_ml_nudging.nc -cdo -t ecmwf -f nc copy era5_surf_nudging.grib era5_surf_nudging.nc - # -- Put all variables in the same file -cdo -O merge era5_ml_nudging.nc era5_surf_nudging.nc era5_original_nudging.nc +cdo -O merge {era5_ml_file} {era5_surf_file} era5_original.nc # -- Change variable and coordinates names to be consistent with ICON nomenclature -cdo setpartabn,mypartab,convert era5_original_nudging.nc tmp.nc +cdo setpartabn,mypartab,convert era5_original.nc tmp.nc # -- Order the variables alphabetically -ncks tmp.nc data_in.nc -rm tmp.nc era5_surf_nudging.nc era5_ml_nudging.nc era5_original_nudging.nc +ncks -O tmp.nc data_in.nc +rm tmp.nc era5_original.nc # --------------------------------- # -- Re-mapping @@ -56,7 +52,7 @@ rm tmp.nc # -- Rename dimensions and order alphabetically ncrename -h -d cell,ncells era5_final.nc ncrename -h -d nv,vertices era5_final.nc -ncks era5_final.nc {filename} +ncks -O era5_final.nc {filename} rm era5_final.nc diff --git a/cases/icon-art-CTDAS/icon_era5_splitfiles.sh b/cases/icon-art-CTDAS/icon_era5_splitfiles.sh new file mode 100644 index 00000000..340d4fc8 --- /dev/null +++ b/cases/icon-art-CTDAS/icon_era5_splitfiles.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +cd {cfg.icon_input_icbc} + +module load daint-mc CDO NCO + +# Loop over ml and surf files +for ml_file in {ml_files}; do + # Convert GRIB to NetCDF for ml file and then process it + cdo -t ecmwf -f nc copy "${{ml_file}}" "${{ml_file%.grib}}.nc" + + # Show timestamp and split for ml file + cdo showtimestamp "${{ml_file%.grib}}.nc" > list_ml.txt + cdo -splitsel,1 "${{ml_file%.grib}}.nc" split_ml_ + + times_ml=($(cat list_ml.txt)) + x=0 + for f in $(ls split_ml_*.nc); do + mv $f era5_ml_${{times_ml[$x]}}.nc + let x=$x+1 + done +done + +for surf_file in {surf_files}; do + # Convert GRIB to NetCDF for surf file and then process it + cdo -t ecmwf -f nc copy "${{surf_file}}" "${{surf_file%.grib}}.nc" + + # Show timestamp and split for surf file + cdo showtimestamp "${{surf_file%.grib}}.nc" > list_surf.txt + cdo -splitsel,1 "${{surf_file%.grib}}.nc" split_surf_ + + times_surf=($(cat list_surf.txt)) + y=0 + for f in $(ls split_surf_*.nc); do + mv $f era5_surf_${{times_surf[$y]}}.nc + let y=$y+1 + done +done diff --git a/cases/icon-art-CTDAS/icon_species_inicond.sh b/cases/icon-art-CTDAS/icon_species_inicond.sh index 27335398..f40f8322 100644 --- a/cases/icon-art-CTDAS/icon_species_inicond.sh +++ b/cases/icon-art-CTDAS/icon_species_inicond.sh @@ -52,4 +52,4 @@ ncrename -O -d nhym,lev cams_remapped.nc # 5. Place in inicond file ncks -A -v CO2 cams_remapped.nc {inicond_filename} ncap2 -s 'CO2_new[time,lev,ncells]=CO2; CO2=CO2_new;' {inicond_filename} -ncks -C -O -x -v CO2_new {inicond_filename} +ncks -C -O -x -v CO2_new {inicond_filename} {inicond_filename} diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index eca35a1e..388f98aa 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -10,6 +10,7 @@ from pathlib import Path # noqa: F401 from .tools.interpolate_data import create_oh_for_restart, create_oh_for_inicond # noqa: F401 from .tools.fetch_external_data import fetch_era5, fetch_era5_nudging, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2 +from concurrent.futures import ThreadPoolExecutor, as_completed BASIC_PYTHON_JOB = False @@ -36,109 +37,136 @@ def main(cfg): tools.change_logfile(cfg.logfile) logging.info("Prepare ICON-ART for CTDAS") - # -- 1. Download ERA5 data and create the initial conditions file - if cfg.meteo_fetch_era5: - # -- Fetch ERA5 data - logging.info( - f"Times considered now: {cfg.startdate_sim}, {cfg.enddate_sim}, {cfg.CTDAS_step}" - ) - logging.info("Fetching ERA5 initial data") - fetch_era5(cfg.startdate_sim, cfg.icon_input_icbc, resolution=0.25) - - # -- 2. Download CAMS CO2 data (for a whole year) - if cfg.chem_fetch_CAMS: - fetch_CAMS_CO2( - cfg.startdate_sim, cfg.icon_input_icbc - ) # This should be turned into a more central location I think. - - # -- 3. Process data - # --- ERA5 inicond - logging.info("Preparing ERA5 preprocessing script for ICON") - era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob - era5_ini_job = cfg.icon_input_icbc / cfg.meteo_era5_inijob - datestr = cfg.startdate_sim.strftime('%Y%m%d%H') - inicond_filename = cfg.icon_input_icbc / f"era_{datestr}_ini.nc" - with open(era5_ini_template, 'r') as infile, open(era5_ini_job, - 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - inicond_filename=inicond_filename, - datestr=datestr)) - shutil.copy(cfg.case_path / 'mypartab', cfg.icon_input_icbc / 'mypartab') - logging.info("Running ERA5 preprocessing script") - subprocess.run(["bash", era5_ini_job], check=True, stdout=subprocess.PIPE) - # --- CAMS inicond - logging.info("Preparing CAMS preprocessing script for ICON") - cams_ini_template = cfg.case_path / cfg.chem_cams_inijob - cams_ini_job = cfg.icon_input_icbc / cfg.chem_cams_inijob - with open(cams_ini_template, 'r') as infile, open(cams_ini_job, - 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - inicond_filename=inicond_filename)) - logging.info("Running CAMS preprocessing script") - subprocess.run(["bash", cams_ini_job], check=True, stdout=subprocess.PIPE) - - # -- 3. If global nudging, download and process ERA5 and CAMS data - if cfg.meteo_interpolate_CAMS_to_ERA5: - for time in tools.iter_hours(cfg.startdate_sim, - cfg.enddate_sim, - step=cfg.meteo_nudging_step): - - # -- Give a name to the nudging file - timestr = time.strftime('%Y%m%d%H') - filename = 'era_{timestr}_nudging.nc'.format(timestr=timestr) - - # -- If initial time, copy the initial conditions to be used as boundary conditions - if time == cfg.startdate_sim: - shutil.copy(cfg.icon_input_icbc / f'era_{timestr}_ini.nc', - cfg.icon_input_icbc / filename) - continue - - # -- Fetch ERA5 data - fetch_era5_nudging(time, cfg.icon_input_icbc, resolution=0.25) - - # -- Copy ERA5 processing script (icon_era5_nudging.job) in workdir - nudging_template = cfg.case_path / cfg.meteo_era5_nudgingjob - nudging_job = cfg.icon_input_icbc / f'icon_era5_nudging_{timestr}.sh' - with open(nudging_template, 'r') as infile, open(nudging_job, - 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, filename=filename)) - - # -- Copy mypartab in workdir - if not os.path.exists(cfg.case_path / 'mypartab'): - shutil.copy(cfg.case_path / 'mypartab', - cfg.icon_input_icbc / 'mypartab') - - # -- Run ERA5 processing script - subprocess.run(["bash", nudging_job], - check=True, - stdout=subprocess.PIPE) - - # -- Copy CAMS processing script (icon_cams_nudging.job) in workdir - cams_nudging_template = cfg.case_path / cfg.icon_species_nudgingjob - cams_nudging_job = cfg.icon_input_icbc / f'icon_cams_nudging_{timestr}.sh' - with open(cams_nudging_template, - 'r') as infile, open(cams_nudging_job, 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, filename=filename)) - - # -- Run CAMS processing script - subprocess.run(["bash", cams_nudging_job], - check=True, - stdout=subprocess.PIPE) - + # # -- 1. Download CAMS CO2 data (for a whole year) + # if cfg.chem_fetch_CAMS: + # fetch_CAMS_CO2( + # cfg.startdate_sim, cfg.icon_input_icbc + # ) # This should be turned into a more central location I think. + + # # -- 2. Fetch *all* ERA5 data (not just for initial conditions) + # if cfg.meteo_fetch_era5: + # times = list(tools.iter_hours(cfg.startdate_sim, cfg.enddate_sim, cfg.meteo_nudging_step)) + # logging.info(f"Time range considered here: {times}") + + # # Split downloads in 3-day chunks, but run simultaneously + # N = 3 + # chunks = list(tools.split_into_chunks(times, N, cfg.meteo_nudging_step)) + # logging.info(f"Time range split up into chunks of {N} days, giving the following chunks: {chunks}") + + # # Run fetch_era5 in parallel over chunks + # output_filenames = [None] * len(chunks) # Create a list to store filenames in order + # with ThreadPoolExecutor(max_workers=4) as executor: + # futures = {executor.submit(fetch_era5, chunk, cfg.icon_input_icbc, resolution=0.25, area=[60, -15, 35, 20]): i for i, chunk in enumerate(chunks)} + # for future in futures: + # index = futures[future] # Get the index of the future + # try: + # result = future.result() # Get the result from the future + # output_filenames[index] = result # Store the returned filename(s) in the correct order + # logging.info(f"Fetched data and saved to: {result}") + # except Exception as exc: + # logging.error(f"Generated an exception: {exc}") + # logging.info(f"All fetched files: {output_filenames}") + + # # Split files (with multiple days/times) into individual files using bash script + # era5_split_template = cfg.case_path / cfg.meteo_era5_splitjob + # era5_split_job = cfg.icon_input_icbc / cfg.meteo_era5_splitjob + # logging.info(f"Preparing ERA5 splitting script for ICON from {era5_split_template}") + # ml_files = " ".join([f"{filenames[0]}" for filenames in output_filenames]) + # surf_files = " ".join([f"{filenames[1]}" for filenames in output_filenames]) + # with open(era5_split_template, 'r') as infile, open(era5_split_job, 'w') as outfile: + # outfile.write(infile.read().format( + # cfg=cfg, + # ml_files=ml_files, + # surf_files=surf_files + # )) + # logging.info(f"Running ERA5 splitting script {era5_split_job}") + # subprocess.run(["bash", era5_split_job], check=True, stdout=subprocess.PIPE) + + + # # -- 3. Process initial conditions data using bash script + # datestr = cfg.startdate_sim.strftime("%Y-%m-%dT%H:%M:%S") + # era5_ml_file = cfg.icon_input_icbc / f"era5_ml_{datestr}.nc" + # era5_surf_file = cfg.icon_input_icbc / f"era5_surf_{datestr}.nc" + # era5_ini_file = cfg.icon_input_icbc / f"era5_ini_{datestr}.nc" + # era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob + # era5_ini_job = cfg.icon_input_icbc / cfg.meteo_era5_inijob + # with open(era5_ini_template, 'r') as infile, open(era5_ini_job, + # 'w') as outfile: + # outfile.write(infile.read().format(cfg=cfg, + # era5_ml_file=era5_ml_file, + # era5_surf_file=era5_surf_file, + # inicond_filename=era5_ini_file)) + # shutil.copy(cfg.case_path / 'mypartab', cfg.icon_input_icbc / 'mypartab') + # logging.info(f"Running ERA5 initial conditions script {era5_ini_job}") + # subprocess.run(["bash", era5_ini_job], check=True, stdout=subprocess.PIPE) + # # --- CAMS inicond + # logging.info("Preparing CAMS preprocessing script for ICON") + # cams_ini_template = cfg.case_path / cfg.chem_cams_inijob + # cams_ini_job = cfg.icon_input_icbc / cfg.chem_cams_inijob + # with open(cams_ini_template, 'r') as infile, open(cams_ini_job, + # 'w') as outfile: + # outfile.write(infile.read().format(cfg=cfg, + # inicond_filename=era5_ini_file)) + # logging.info("Running CAMS preprocessing initial conditions script") + # subprocess.run(["bash", cams_ini_job], check=True, stdout=subprocess.PIPE) + + # # -- 3. If global nudging, download and process ERA5 and CAMS data + # if cfg.meteo_interpolate_CAMS_to_ERA5: + # for time in tools.iter_hours(cfg.startdate_sim, + # cfg.enddate_sim, + # step=cfg.meteo_nudging_step): + + # # -- Give a name to the nudging file + # datestr = time.strftime("%Y-%m-%dT%H:%M:%S") + # era5_ml_file = cfg.icon_input_icbc / f"era5_ml_{datestr}.nc" + # era5_surf_file = cfg.icon_input_icbc / f"era5_surf_{datestr}.nc" + # era5_nudge_file = cfg.icon_input_icbc / f"era5_nudge_{datestr}.nc" + + # # -- Copy ERA5 processing script (icon_era5_nudging.job) in workdir + # nudging_template = cfg.case_path / cfg.meteo_era5_nudgingjob + # nudging_job = cfg.icon_input_icbc / f'icon_era5_nudging_{datestr}.sh' + # with open(nudging_template, 'r') as infile, open(nudging_job, + # 'w') as outfile: + # outfile.write(infile.read().format(cfg=cfg, + # era5_ml_file=era5_ml_file, + # era5_surf_file=era5_surf_file, + # filename=era5_nudge_file)) + + # # -- Copy mypartab in workdir + # if not os.path.exists(cfg.case_path / 'mypartab'): + # shutil.copy(cfg.case_path / 'mypartab', + # cfg.icon_input_icbc / 'mypartab') + + # # -- Run ERA5 processing script + # subprocess.run(["bash", nudging_job], + # check=True, + # stdout=subprocess.PIPE) + + # # -- Copy CAMS processing script (icon_cams_nudging.job) in workdir + # logging.info("Preparing CAMS preprocessing nudging script for ICON") + # cams_nudge_template = cfg.case_path / cfg.chem_cams_nudgingjob + # cams_nudge_job = cfg.icon_input_icbc / cfg.chem_cams_nudgingjob + # with open(cams_nudge_template, 'r') as infile, open(cams_nudge_job, + # 'w') as outfile: + # outfile.write(infile.read().format(cfg=cfg, + # filename=era5_nudge_file)) + # subprocess.run(["bash", cams_nudge_job], check=True, stdout=subprocess.PIPE) + # -- 4. Download ICOS CO2 data - if cfg.obs_fetch_icos: + if cfg.obs_fetch_ICOS: # -- This requires you to have accepted the ICOS license in your profile. # So, login to https://cpauth.icos-cp.eu/home/ , check the box, and # copy the cookie token on the bottom as your ICOS_cookie_token. - fetch_ICOS_data(cookie_token=cfg.ICOS_cookie_token, - start_date=cfg.startdate_sim, - end_date=cfg.enddate_sim, - save_path=cfg.ICOS_path, + fetch_ICOS_data(cookie_token=cfg.obs_ICOS_cookie_token, + start_date=cfg.startdate_sim.strftime("%d-%m-%Y"), + end_date=cfg.enddate_sim.strftime("%d-%m-%Y"), + save_path=cfg.obs_ICOS_path, species=[ 'co2', ]) + process_ICOS_data() # Setup the post-processing, which concatenates all the data into one file - if cfg.obs_fetch_oco2: + if cfg.obs_fetch_OCO2: # A user must do the following steps to obtain access to OCO2 data # from getpass import getpass # import os @@ -158,12 +186,13 @@ def main(cfg): # file.write('HTTP.NETRC={}.netrc'.format(homeDir)) # file.close() # Popen('chmod og-rw ~/.netrc', shell=True) - fetch_OCO2(x, - y, + fetch_OCO2(cfg.startdate_sim, + cfg.enddate_sim, -8, 30, 35, 65, - "/capstor/scratch/cscs/ekoene/temp", + cfg.obs_OCO2_path, product="OCO2_L2_Lite_FP_11.1r") + process_OCO2() # post-process all the OCO2 data logging.info("OK") diff --git a/jobs/tools/__init__.py b/jobs/tools/__init__.py index 15f39ead..5d87aea0 100644 --- a/jobs/tools/__init__.py +++ b/jobs/tools/__init__.py @@ -112,6 +112,13 @@ def iter_hours(startdate, enddate, step=1): current += timedelta(hours=step) +def split_into_chunks(times, N, step): + """Splits the iter_hours iterable into chunks of N days (converted to hours based on step).""" + chunk_size = 24 * N // step # Each N-day chunk corresponds to these many hours + for i in range(0, len(times), chunk_size): + yield times[i:i + chunk_size] + + def prepare_message(logfile_path): """Shortens the logfile to be sent via mail if it is too long. diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 7cedfb80..9df7fcf1 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -20,7 +20,7 @@ from datetime import datetime, timedelta -def fetch_CDS(product, date, levels, params, resolution, outloc): +def fetch_CDS(product, date, levels, params, resolution, area, outloc): # Obtain CDS authentification from file url_cmd = f"grep 'cds' ~/.cdsapirc" url = os.popen(url_cmd).read().strip().split(": ")[1] @@ -73,6 +73,7 @@ def fetch_CDS(product, date, levels, params, resolution, outloc): paramstr, 'grid': f'{resolution}/{resolution}', + **({'area' : area} if area is not None else {}), **({ 'class': 'ea', 'type': 'an', @@ -87,9 +88,12 @@ def fetch_CDS(product, date, levels, params, resolution, outloc): }, outloc) -def fetch_era5(date, dir2move, resolution=1.0): - outfile = dir2move / f"era5_ml_{date.strftime('%Y-%m-%d')}.grib" - if not os.path.isfile(outfile): +def fetch_era5(date, dir2move, resolution=1.0, area=None): + if isinstance(date, list): + outfile_3D = dir2move / f"era5_ml_{date[0].strftime('%Y-%m-%d')}_{date[-1].strftime('%Y-%m-%d')}.grib" + else: + outfile_3D = dir2move / f"era5_ml_{date.strftime('%Y-%m-%d')}.grib" + if not os.path.isfile(outfile_3D): # -- CRWC : Specific rain water content - 75 # -- CSWC : Specific snow water content - 76 # -- T : Temperature - 130 @@ -100,11 +104,14 @@ def fetch_era5(date, dir2move, resolution=1.0): # -- CLWC : Specific cloud liquid water content - 246 # -- CIWC : Specific cloud ice water content - 247 fetch_CDS('reanalysis-era5-complete', date, '1/to/137', - [75, 76, 130, 131, 132, 133, 135, 246, 247], resolution, - outfile) + [75, 76, 130, 131, 132, 133, 135, 246, 247], resolution, area, + outfile_3D) - outfile = dir2move / f"era5_surf_{date.strftime('%Y-%m-%d')}.grib" - if not os.path.isfile(outfile): + if isinstance(date, list): + outfile_surface = dir2move / f"era5_surf_{date[0].strftime('%Y-%m-%d')}_{date[-1].strftime('%Y-%m-%d')}.grib" + else: + outfile_surface = dir2move / f"era5_surf_{date.strftime('%Y-%m-%d')}.grib" + if not os.path.isfile(outfile_surface): # -- CI : Sea Ice Cover - 31 # -- ASN : Snow albedo - 32 # -- RSN : Snow density - 33 @@ -128,10 +135,12 @@ def fetch_era5(date, dir2move, resolution=1.0): fetch_CDS('reanalysis-era5-single-levels', date, None, [ 31, 32, 33, 34, 39, 40, 41, 42, 43, 129, 134, 139, 141, 170, 172, 183, 198, 235, 236, 238 - ], resolution, outfile) + ], resolution, area, outfile_surface) + + return outfile_3D, outfile_surface -def fetch_era5_nudging(date, dir2move, resolution=1.0): +def fetch_era5_nudging(date, dir2move, resolution=1.0, area=None): """Fetch ERA5 data from ECMWF for global nudging Parameters @@ -139,18 +148,25 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0): date : initial date to fetch """ - outfile = dir2move / f"era5_ml_nudging_{date.strftime('%Y-%m-%d%H')}.grib" - if not os.path.isfile(outfile): + if isinstance(date, list): + outfile_3D = dir2move / f"era5_ml_nudging_{date[0].strftime('%Y-%m-%d')}_{date[-1].strftime('%Y-%m-%d')}.grib" + else: + outfile_3D = dir2move / f"era5_ml_nudging_{date.strftime('%Y-%m-%d')}.grib" + if not os.path.isfile(outfile_3D): fetch_CDS('reanalysis-era5-complete', date, '1/to/137', - [75, 76, 130, 131, 132, 133, 135, 246, 247], resolution, - outfile) + [75, 76, 130, 131, 132, 133, 135, 246, 247], resolution, area, + outfile_3D) - outfile = dir2move / f"era5_surf_nudging_{date.strftime('%Y-%m-%d%H')}.grib" - if not os.path.isfile(outfile): + if isinstance(date, list): + outfile_surface = dir2move / f"era5_surf_nudging_{date[0].strftime('%Y-%m-%d')}_{date[-1].strftime('%Y-%m-%d')}.grib" + else: + outfile_surface = dir2move / f"era5_surf_nudging_{date.strftime('%Y-%m-%d')}.grib" + if not os.path.isfile(outfile_surface): fetch_CDS('reanalysis-era5-single-levels', date, None, [ - 31, 32, 33, 34, 39, 40, 41, 42, 43, 129, 134, 139, 141, 170, 172, - 183, 198, 235, 236, 238 - ], resolution, outfile) + 129, 134 + ], resolution, area, outfile_surface) + + return outfile_3D, outfile_surface def fetch_CAMS_CO2(date, dir2move): @@ -516,3 +532,255 @@ def get_http_data(request): ) print('Finished') + +def process_OCO2(): + ######### Some messages ######### + print('=============================================================================') + print(' Pre-processing Observation product, readable for CTDAS-ICON.' ) + print(' Data will be filtered base on a given ICON domain.' ) + print(' David Ho, MPI-BGC Jena' ) + print('=============================================================================') + print('') + print('Loading neccessary packages...') + ## Import + import numpy as np + import pandas as pd + import xarray as xr + import glob + from netCDF4 import Dataset + import datetime + import time as TIME + import warnings + import os + warnings.filterwarnings("ignore") + print('') + #-- retrieve start time + t1 = TIME.time() + ######### Output path ########### + nc_out = '//scratch/snx3000/ekoene/OCO-2_filtered/' + if not os.path.exists(nc_out): + os.makedirs(nc_out) + print(f"Output folder '{nc_out}' created successfully.") + else: + print(f"Output folder '{nc_out}' already exists.") + ######### Time control ########### + Year = 2018 + for month in range(1,13): + if month in [4, 6, 9, 11]: + daymax = 30 + elif month == 2: + daymax = 28 + else: + daymax = 31 + + ndays = np.arange(1, daymax+1) # 1st~31th + ######### Observation ########### + file_list = sorted( glob.glob('/scratch/snx3000/ekoene/OCO-2/OCO2_L2_Lite_FP.11r:oco2_LtCO2_*') ) + if len(file_list) == 0: + raise ValueError("File list is empty, stopping here!") + + ########## ICON grid ############ + mainpath = '/users/ekoene/CTDAS_inputs/' + grid_file = mainpath + '/icon_europe_DOM01.nc' + ICON_GRID = xr.open_dataset(grid_file) + # Convert an array of size 1 to its scalar equivalent. + lon_min = np.min(ICON_GRID.clon.values) + lon_max = np.max(ICON_GRID.clon.values) + lat_min = np.min(ICON_GRID.clat.values) + lat_max = np.max(ICON_GRID.clat.values) + print('ICON grid extends:') + print('Longitude min. %7.4f, max. %7.4f' % (np.rad2deg(lon_min),np.rad2deg(lon_max)) ) + print('Latitude min. %7.4f, max. %7.4f' % (np.rad2deg(lat_min),np.rad2deg(lat_max)) ) + print('') + ########## Set bounds to filter ########## + offset = 1.2 + sub_lon_min = np.rad2deg(lon_min) + offset + sub_lon_max = np.rad2deg(lon_max) - offset + sub_lat_min = np.rad2deg(lat_min) + offset + sub_lat_max = np.rad2deg(lat_max) - offset + print('To avoid cells at the domain boundary, subtracting: %s degree.' %offset) + print('Filtered extends:') + print('Longitude min. %7.4f, max. %7.4f' %(sub_lon_min, sub_lon_max) ) + print('Latitude min. %7.4f, max. %7.4f' %(sub_lat_min, sub_lat_max) ) + print('') + + ######## Begin Production ############# + Total_nobs_before = np.array([]) + Total_nobs_after = np.array([]) + for day in ndays: + print('Processing: (%s/%s)' %(day, len(ndays)) ) + ######### Read data ######### + try: + # Find a file in the file list + for file_name in file_list: + if f"OCO2_L2_Lite_FP.11r:oco2_LtCO2_{str(Year)[2:]}{month:02d}{day:02d}" in file_name: + s5p_file = file_name + print('Opening file: %s' %s5p_file) + s5p_data = Dataset(s5p_file) + except: + print('file %s not found.' %s5p_file) + print('Skipping...') + print('') + continue # Continue to next iteration. + + ######## Filter base of ICON domain ######## + date_list = [] + for timestamp in s5p_data['time'][:]: + value = datetime.datetime.fromtimestamp(timestamp) + date_list.append(value) + + dictionary = { + 'date_time' : date_list[:], + 'raw_time' : s5p_data['time'][:], + 'xco2': s5p_data['xco2'][:], + 'lat': s5p_data['latitude'][:], + 'lon': s5p_data['longitude'][:], + 'qf': s5p_data['xco2_quality_flag'][:], # quality flag 0 = good; 1 = bad. + } + df_pixels = pd.DataFrame(data=dictionary) + + ## Filter base on ICON domain ## + inside_domain_flag = ( ( df_pixels['lon'] > sub_lon_min ) & ( df_pixels['lon'] < sub_lon_max ) & + ( df_pixels['lat'] > sub_lat_min ) & ( df_pixels['lat'] < sub_lat_max ) * + ( df_pixels['qf'] == 0) ) + + # -- Old hard coded settings: + # inside_domain_flag = ( ( df_pixels['lon'] > -20 ) & ( df_pixels['lon'] < 58 ) \ + # & ( df_pixels['lat'] > 32 ) & ( df_pixels['lat'] < 69 ) ) + ## Get the indexes from data frame ## + indexes = df_pixels[inside_domain_flag].index + + ## Some messages + Before = len(s5p_data.variables['xco2'][:]) + print('It had %i data' %Before) + Total_nobs_before = np.append(Total_nobs_before, Before) + + After = len(s5p_data.variables['xco2'][indexes]) + print('Now has %i' %After) + Total_nobs_after = np.append(Total_nobs_after, After) + if After == 0: + print('skipping') + continue + + ######### Create/Write netCDF ######### + _, tail = os.path.split(s5p_file) + output_path = os.path.join(nc_out, 'OCO2_%04d%02d%02d_ctdas.nc' %(Year, month, day)) + ncfile = Dataset( output_path, mode='w', format='NETCDF4' ) + print('Writing %s from %s' %(output_path, s5p_file)) + + ######### Def. attribute ######### + ncfile.level_def = 'pressure_boundaries' + ncfile.retrieval_id = tail + ncfile.creator_name = 'Erik Koene (Empa)' + ncfile.date_created = str( datetime.datetime.now() ) + ######### Create dimension ######### + #ncfile.createDimension( 'soundings', s5p_data.dimensions['sounding_dim'].size ) # Select all + ncfile.createDimension( 'soundings', s5p_data['xco2'][indexes].size ) # Select the indexes + ncfile.createDimension( 'levels', s5p_data.dimensions['levels'].size ) + ncfile.createDimension( 'layers', s5p_data.dimensions['levels'].size ) + ncfile.createDimension( 'epoch_dimension', s5p_data.dimensions['epoch_dimension'].size ) + ######### Set variables ######### + ### Lat/Lon + lat = ncfile.createVariable('latitude', np.float32, ('soundings')) + lat.units = 'degrees_north' + #lat[:] = s5p_data.variables['latitude'][:] + lat[:] = s5p_data.variables['latitude'][indexes] + lon = ncfile.createVariable('longitude', np.float32, ('soundings')) + lon.units = 'degrees_east' + #lon[:] = s5p_data.variables['longitude'][:] + lon[:] = s5p_data.variables['longitude'][indexes] + ### Time + date = ncfile.createVariable('date', np.uint32, ('soundings', 'epoch_dimension')) + date.units = 'seconds since 1970-01-01 00:00:00' # + date.long_name = 'date_time' + # Converting... + A = np.array([], np.uint32) + for timestamp in s5p_data['time'][indexes]: + value = datetime.datetime.fromtimestamp(timestamp) + time = np.array([value.year, value.month, value.day, value.hour, value.minute, value.second, value.microsecond], np.uint32) + A = np.concatenate([A, time], axis=0) + B = A.reshape( int(len(A)/7), 7 ) + date[:] = B[:] + ##### Obs + obs = ncfile.createVariable('obs', np.float32, ('soundings')) + obs.units = '1e-6 [ppm]' + obs.long_name = 'column-averaged dry air mole fraction of atmospheric co2' + obs.comment = 'Retrieved column-averaged dry air mole fraction of atmospheric carbon dioxide (XCO2) in ppm for CTDAS' + obs[:] = s5p_data.variables['xco2'][indexes] # Keep ppm units + ### qa flag + qa_f = ncfile.createVariable('quality_flag', np.int8, ('soundings')) + qa_f.flag_values= '[0, 1]' + qa_f.long_name = 'quality flag for the retrieved column-averaged dry air mole fraction of atmospheric methane' + qa_f.comment = '0=good, 1=bad' + qa_f[:] = s5p_data.variables['xco2_quality_flag'][indexes] + ##### avg kernel + avg_kernel = ncfile.createVariable('averaging_kernel', np.float32, ('soundings', 'layers')) + avg_kernel.units = '1' + avg_kernel.long_name = 'xco2 averaging kernel' + avg_kernel.comment = 'Represents the altitude sensitivity of the retrieval as a function of pressure. All values represent layer averages within the corresponding pressure levels. Profiles are ordered from surface to top of atmosphere.' + #avg_kernel[:] = s5p_data.variables['xch4_averaging_kernel'][:] + avg_kernel[:] = s5p_data.variables['xco2_averaging_kernel'][:][indexes] + ### surface_pressure + psurf = ncfile.createVariable('surface_pressure', np.float32, ('soundings')) + psurf.long_name = 'Surface pressure' + psurf.comment = 'Sliced from: OCO2_pressure_levels[:, 0] in Python. Pressure levels defined at the same levels as the averaging kernel and a priori profile layers. Levels were ordered from top of atmosphere to surface.' + psurf.unit = 'hPa' + #psurf[:] = s5p_data.variables['pressure_levels'][:, 0] + psurf[:] = s5p_data.variables['pressure_levels'][indexes, -1] + ##### pressure_levels + pres_lvls = ncfile.createVariable('pressure_levels', np.float32, ('soundings', 'layers')) + pres_lvls.long_name = 'Pressure levels' + pres_lvls.comment = 'Sliced from: s5p_pressure_levels[:, 1:], Python. Pressure levels define the boundaries of the averaging kernel and a priori profile layers. Levels were ordered from top of atmosphere to surface.' + pres_lvls.unit = 'hPa' + pres_lvls[:] = s5p_data.variables['pressure_levels'][:, ::-1][indexes] + #### pressure_weighting_function + pwf = ncfile.createVariable('pressure_weighting_function', np.float32, ('soundings', 'layers')) + pwf.long_name = 'Pressure weighting function' + pwf.comment = 'Layer dependent weights needed to apply the averaging kernels.' + pwf[:] = s5p_data.variables['pressure_weight'][:,::-1][indexes] + ### prior_profile + prior_profile = ncfile.createVariable('prior_profile', np.float32, ('soundings', 'layers')) + prior_profile.units = '1e-6 [ppm]' + prior_profile.long_name = 'a priori dry air mole fraction profile of atmospheric CO2' + prior_profile.comment = 'A priori dry-air mole fraction profile of atmospheric CO2 in ppm. All values represent layer averages within the corresponding pressure levels. Profiles are ordered from top of atmosphere to the surface.' + prior_profile[:] = s5p_data.variables['co2_profile_apriori'][:,::-1][indexes] + ### prior + prior = ncfile.createVariable('prior', np.float32, ('soundings')) + prior.units = '1e-6 [ppm]' + prior.long_name = 'Prior' + prior.comment = 'The a priori CO2 profile uses the same formulation as used for TCCON GGG2020 retrievals' + prior[:] = s5p_data.variables["xco2_apriori"][indexes] + ### uncertainty + unc = ncfile.createVariable('uncertainty', np.float32, ('soundings')) + unc.units = '1e-6 [ppm]' + unc.long_name = '1-sigma uncertainty of the retrieved column-averaged dry air mole fraction of atmospheric carbon dioxide' + unc.comment = '1-sigma uncertainty of the retrieved column-averaged dry air mole fraction of atmospheric carbon dioxide (XCO2) in ppm' + unc[:] = s5p_data.variables['xco2_uncertainty'][indexes] + + ### Extras + # unique sounding_id + sounding_id = ncfile.createVariable('sounding_id', np.int64, ('soundings')) + sounding_id.comment ='Some numbers unique per observation' + # sounding_id[:] = s5p_data.variables['sounding_id'][indexes] + #s5p_obs = s5p_data.variables['xch4'][:] + s5p_obs = s5p_data.variables['xco2'][indexes] + to_add = int('%04d%02d%02d0000000' %(Year, month, day)) # datetime + 9 zeros + sounding_id[:] = np.arange(len(s5p_obs)) + to_add + print('Added %s to sounding id, unique per observation' %to_add) + + # nobs + #nobs = ncfile.createVariable('nobs', np.unit32, ('soundings')) + #nobs.comment ='Number of observations' + #nobs[:] = + #print(ncfile) + ncfile.close() + print('Done! Closing netcdf, proceeding to the next file.') + print('') + + t2 = TIME.time() + print('') + print('All done! Wallclock time: %0.3f seconds' % (t2-t1)) + sum_before = np.sum(Total_nobs_before) + sum_after = np.sum(Total_nobs_after) + print('Summary:') + print('Original nobs: %i. Filtered nobs: %i.' %(sum_before, sum_after) ) From f19f7d856bcf3e6372c1639743c4eae6e8f4f0a3 Mon Sep 17 00:00:00 2001 From: github-actions Date: Fri, 18 Oct 2024 12:00:00 +0000 Subject: [PATCH 20/42] GitHub Action: Apply Pep8-formatting --- jobs/prepare_CTDAS.py | 10 +- jobs/tools/fetch_external_data.py | 516 ++++++++++++++++-------------- 2 files changed, 282 insertions(+), 244 deletions(-) diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index 388f98aa..914d4ec9 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -49,7 +49,7 @@ def main(cfg): # logging.info(f"Time range considered here: {times}") # # Split downloads in 3-day chunks, but run simultaneously - # N = 3 + # N = 3 # chunks = list(tools.split_into_chunks(times, N, cfg.meteo_nudging_step)) # logging.info(f"Time range split up into chunks of {N} days, giving the following chunks: {chunks}") @@ -82,7 +82,6 @@ def main(cfg): # logging.info(f"Running ERA5 splitting script {era5_split_job}") # subprocess.run(["bash", era5_split_job], check=True, stdout=subprocess.PIPE) - # # -- 3. Process initial conditions data using bash script # datestr = cfg.startdate_sim.strftime("%Y-%m-%dT%H:%M:%S") # era5_ml_file = cfg.icon_input_icbc / f"era5_ml_{datestr}.nc" @@ -151,7 +150,7 @@ def main(cfg): # outfile.write(infile.read().format(cfg=cfg, # filename=era5_nudge_file)) # subprocess.run(["bash", cams_nudge_job], check=True, stdout=subprocess.PIPE) - + # -- 4. Download ICOS CO2 data if cfg.obs_fetch_ICOS: # -- This requires you to have accepted the ICOS license in your profile. @@ -164,7 +163,8 @@ def main(cfg): species=[ 'co2', ]) - process_ICOS_data() # Setup the post-processing, which concatenates all the data into one file + process_ICOS_data( + ) # Setup the post-processing, which concatenates all the data into one file if cfg.obs_fetch_OCO2: # A user must do the following steps to obtain access to OCO2 data @@ -194,5 +194,5 @@ def main(cfg): 65, cfg.obs_OCO2_path, product="OCO2_L2_Lite_FP_11.1r") - process_OCO2() # post-process all the OCO2 data + process_OCO2() # post-process all the OCO2 data logging.info("OK") diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 9df7fcf1..9fc379b4 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -73,7 +73,9 @@ def fetch_CDS(product, date, levels, params, resolution, area, outloc): paramstr, 'grid': f'{resolution}/{resolution}', - **({'area' : area} if area is not None else {}), + **({ + 'area': area + } if area is not None else {}), **({ 'class': 'ea', 'type': 'an', @@ -104,8 +106,8 @@ def fetch_era5(date, dir2move, resolution=1.0, area=None): # -- CLWC : Specific cloud liquid water content - 246 # -- CIWC : Specific cloud ice water content - 247 fetch_CDS('reanalysis-era5-complete', date, '1/to/137', - [75, 76, 130, 131, 132, 133, 135, 246, 247], resolution, area, - outfile_3D) + [75, 76, 130, 131, 132, 133, 135, 246, 247], resolution, + area, outfile_3D) if isinstance(date, list): outfile_surface = dir2move / f"era5_surf_{date[0].strftime('%Y-%m-%d')}_{date[-1].strftime('%Y-%m-%d')}.grib" @@ -136,7 +138,7 @@ def fetch_era5(date, dir2move, resolution=1.0, area=None): 31, 32, 33, 34, 39, 40, 41, 42, 43, 129, 134, 139, 141, 170, 172, 183, 198, 235, 236, 238 ], resolution, area, outfile_surface) - + return outfile_3D, outfile_surface @@ -154,17 +156,16 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0, area=None): outfile_3D = dir2move / f"era5_ml_nudging_{date.strftime('%Y-%m-%d')}.grib" if not os.path.isfile(outfile_3D): fetch_CDS('reanalysis-era5-complete', date, '1/to/137', - [75, 76, 130, 131, 132, 133, 135, 246, 247], resolution, area, - outfile_3D) + [75, 76, 130, 131, 132, 133, 135, 246, 247], resolution, + area, outfile_3D) if isinstance(date, list): outfile_surface = dir2move / f"era5_surf_nudging_{date[0].strftime('%Y-%m-%d')}_{date[-1].strftime('%Y-%m-%d')}.grib" else: outfile_surface = dir2move / f"era5_surf_nudging_{date.strftime('%Y-%m-%d')}.grib" if not os.path.isfile(outfile_surface): - fetch_CDS('reanalysis-era5-single-levels', date, None, [ - 129, 134 - ], resolution, area, outfile_surface) + fetch_CDS('reanalysis-era5-single-levels', date, None, [129, 134], + resolution, area, outfile_surface) return outfile_3D, outfile_surface @@ -533,254 +534,291 @@ def get_http_data(request): print('Finished') + def process_OCO2(): - ######### Some messages ######### - print('=============================================================================') - print(' Pre-processing Observation product, readable for CTDAS-ICON.' ) - print(' Data will be filtered base on a given ICON domain.' ) - print(' David Ho, MPI-BGC Jena' ) - print('=============================================================================') - print('') - print('Loading neccessary packages...') - ## Import - import numpy as np - import pandas as pd - import xarray as xr - import glob - from netCDF4 import Dataset - import datetime - import time as TIME - import warnings + ######### Some messages ######### + print( + '=============================================================================' + ) + print(' Pre-processing Observation product, readable for CTDAS-ICON.') + print(' Data will be filtered base on a given ICON domain.') + print(' David Ho, MPI-BGC Jena') + print( + '=============================================================================' + ) + print('') + print('Loading neccessary packages...') + ## Import + import numpy as np + import pandas as pd + import xarray as xr + import glob + from netCDF4 import Dataset + import datetime + import time as TIME + import warnings import os - warnings.filterwarnings("ignore") - print('') - #-- retrieve start time - t1 = TIME.time() - ######### Output path ########### - nc_out = '//scratch/snx3000/ekoene/OCO-2_filtered/' + warnings.filterwarnings("ignore") + print('') + #-- retrieve start time + t1 = TIME.time() + ######### Output path ########### + nc_out = '//scratch/snx3000/ekoene/OCO-2_filtered/' if not os.path.exists(nc_out): os.makedirs(nc_out) print(f"Output folder '{nc_out}' created successfully.") else: print(f"Output folder '{nc_out}' already exists.") - ######### Time control ########### - Year = 2018 - for month in range(1,13): - if month in [4, 6, 9, 11]: - daymax = 30 - elif month == 2: - daymax = 28 - else: - daymax = 31 - - ndays = np.arange(1, daymax+1) # 1st~31th - ######### Observation ########### - file_list = sorted( glob.glob('/scratch/snx3000/ekoene/OCO-2/OCO2_L2_Lite_FP.11r:oco2_LtCO2_*') ) - if len(file_list) == 0: - raise ValueError("File list is empty, stopping here!") - - ########## ICON grid ############ - mainpath = '/users/ekoene/CTDAS_inputs/' - grid_file = mainpath + '/icon_europe_DOM01.nc' - ICON_GRID = xr.open_dataset(grid_file) - # Convert an array of size 1 to its scalar equivalent. - lon_min = np.min(ICON_GRID.clon.values) - lon_max = np.max(ICON_GRID.clon.values) - lat_min = np.min(ICON_GRID.clat.values) - lat_max = np.max(ICON_GRID.clat.values) - print('ICON grid extends:') - print('Longitude min. %7.4f, max. %7.4f' % (np.rad2deg(lon_min),np.rad2deg(lon_max)) ) - print('Latitude min. %7.4f, max. %7.4f' % (np.rad2deg(lat_min),np.rad2deg(lat_max)) ) - print('') - ########## Set bounds to filter ########## - offset = 1.2 - sub_lon_min = np.rad2deg(lon_min) + offset - sub_lon_max = np.rad2deg(lon_max) - offset - sub_lat_min = np.rad2deg(lat_min) + offset - sub_lat_max = np.rad2deg(lat_max) - offset - print('To avoid cells at the domain boundary, subtracting: %s degree.' %offset) - print('Filtered extends:') - print('Longitude min. %7.4f, max. %7.4f' %(sub_lon_min, sub_lon_max) ) - print('Latitude min. %7.4f, max. %7.4f' %(sub_lat_min, sub_lat_max) ) - print('') - - ######## Begin Production ############# - Total_nobs_before = np.array([]) - Total_nobs_after = np.array([]) - for day in ndays: - print('Processing: (%s/%s)' %(day, len(ndays)) ) - ######### Read data ######### - try: + ######### Time control ########### + Year = 2018 + for month in range(1, 13): + if month in [4, 6, 9, 11]: + daymax = 30 + elif month == 2: + daymax = 28 + else: + daymax = 31 + + ndays = np.arange(1, daymax + 1) # 1st~31th + ######### Observation ########### + file_list = sorted( + glob.glob( + '/scratch/snx3000/ekoene/OCO-2/OCO2_L2_Lite_FP.11r:oco2_LtCO2_*' + )) + if len(file_list) == 0: + raise ValueError("File list is empty, stopping here!") + + ########## ICON grid ############ + mainpath = '/users/ekoene/CTDAS_inputs/' + grid_file = mainpath + '/icon_europe_DOM01.nc' + ICON_GRID = xr.open_dataset(grid_file) + # Convert an array of size 1 to its scalar equivalent. + lon_min = np.min(ICON_GRID.clon.values) + lon_max = np.max(ICON_GRID.clon.values) + lat_min = np.min(ICON_GRID.clat.values) + lat_max = np.max(ICON_GRID.clat.values) + print('ICON grid extends:') + print('Longitude min. %7.4f, max. %7.4f' % + (np.rad2deg(lon_min), np.rad2deg(lon_max))) + print('Latitude min. %7.4f, max. %7.4f' % + (np.rad2deg(lat_min), np.rad2deg(lat_max))) + print('') + ########## Set bounds to filter ########## + offset = 1.2 + sub_lon_min = np.rad2deg(lon_min) + offset + sub_lon_max = np.rad2deg(lon_max) - offset + sub_lat_min = np.rad2deg(lat_min) + offset + sub_lat_max = np.rad2deg(lat_max) - offset + print( + 'To avoid cells at the domain boundary, subtracting: %s degree.' % + offset) + print('Filtered extends:') + print('Longitude min. %7.4f, max. %7.4f' % (sub_lon_min, sub_lon_max)) + print('Latitude min. %7.4f, max. %7.4f' % (sub_lat_min, sub_lat_max)) + print('') + + ######## Begin Production ############# + Total_nobs_before = np.array([]) + Total_nobs_after = np.array([]) + for day in ndays: + print('Processing: (%s/%s)' % (day, len(ndays))) + ######### Read data ######### + try: # Find a file in the file list for file_name in file_list: if f"OCO2_L2_Lite_FP.11r:oco2_LtCO2_{str(Year)[2:]}{month:02d}{day:02d}" in file_name: - s5p_file = file_name - print('Opening file: %s' %s5p_file) - s5p_data = Dataset(s5p_file) - except: - print('file %s not found.' %s5p_file) - print('Skipping...') - print('') - continue # Continue to next iteration. - - ######## Filter base of ICON domain ######## - date_list = [] - for timestamp in s5p_data['time'][:]: - value = datetime.datetime.fromtimestamp(timestamp) - date_list.append(value) - - dictionary = { - 'date_time' : date_list[:], - 'raw_time' : s5p_data['time'][:], - 'xco2': s5p_data['xco2'][:], - 'lat': s5p_data['latitude'][:], - 'lon': s5p_data['longitude'][:], - 'qf': s5p_data['xco2_quality_flag'][:], # quality flag 0 = good; 1 = bad. - } - df_pixels = pd.DataFrame(data=dictionary) - - ## Filter base on ICON domain ## - inside_domain_flag = ( ( df_pixels['lon'] > sub_lon_min ) & ( df_pixels['lon'] < sub_lon_max ) & - ( df_pixels['lat'] > sub_lat_min ) & ( df_pixels['lat'] < sub_lat_max ) * - ( df_pixels['qf'] == 0) ) - - # -- Old hard coded settings: - # inside_domain_flag = ( ( df_pixels['lon'] > -20 ) & ( df_pixels['lon'] < 58 ) \ - # & ( df_pixels['lat'] > 32 ) & ( df_pixels['lat'] < 69 ) ) - ## Get the indexes from data frame ## - indexes = df_pixels[inside_domain_flag].index - - ## Some messages - Before = len(s5p_data.variables['xco2'][:]) - print('It had %i data' %Before) - Total_nobs_before = np.append(Total_nobs_before, Before) - - After = len(s5p_data.variables['xco2'][indexes]) - print('Now has %i' %After) - Total_nobs_after = np.append(Total_nobs_after, After) + s5p_file = file_name + print('Opening file: %s' % s5p_file) + s5p_data = Dataset(s5p_file) + except: + print('file %s not found.' % s5p_file) + print('Skipping...') + print('') + continue # Continue to next iteration. + + ######## Filter base of ICON domain ######## + date_list = [] + for timestamp in s5p_data['time'][:]: + value = datetime.datetime.fromtimestamp(timestamp) + date_list.append(value) + + dictionary = { + 'date_time': date_list[:], + 'raw_time': s5p_data['time'][:], + 'xco2': s5p_data['xco2'][:], + 'lat': s5p_data['latitude'][:], + 'lon': s5p_data['longitude'][:], + 'qf': s5p_data['xco2_quality_flag'] + [:], # quality flag 0 = good; 1 = bad. + } + df_pixels = pd.DataFrame(data=dictionary) + + ## Filter base on ICON domain ## + inside_domain_flag = ((df_pixels['lon'] > sub_lon_min) & + (df_pixels['lon'] < sub_lon_max) & + (df_pixels['lat'] > sub_lat_min) & + (df_pixels['lat'] < sub_lat_max) * + (df_pixels['qf'] == 0)) + + # -- Old hard coded settings: + # inside_domain_flag = ( ( df_pixels['lon'] > -20 ) & ( df_pixels['lon'] < 58 ) \ + # & ( df_pixels['lat'] > 32 ) & ( df_pixels['lat'] < 69 ) ) + ## Get the indexes from data frame ## + indexes = df_pixels[inside_domain_flag].index + + ## Some messages + Before = len(s5p_data.variables['xco2'][:]) + print('It had %i data' % Before) + Total_nobs_before = np.append(Total_nobs_before, Before) + + After = len(s5p_data.variables['xco2'][indexes]) + print('Now has %i' % After) + Total_nobs_after = np.append(Total_nobs_after, After) if After == 0: print('skipping') continue - ######### Create/Write netCDF ######### + ######### Create/Write netCDF ######### _, tail = os.path.split(s5p_file) - output_path = os.path.join(nc_out, 'OCO2_%04d%02d%02d_ctdas.nc' %(Year, month, day)) - ncfile = Dataset( output_path, mode='w', format='NETCDF4' ) - print('Writing %s from %s' %(output_path, s5p_file)) + output_path = os.path.join( + nc_out, 'OCO2_%04d%02d%02d_ctdas.nc' % (Year, month, day)) + ncfile = Dataset(output_path, mode='w', format='NETCDF4') + print('Writing %s from %s' % (output_path, s5p_file)) - ######### Def. attribute ######### - ncfile.level_def = 'pressure_boundaries' + ######### Def. attribute ######### + ncfile.level_def = 'pressure_boundaries' ncfile.retrieval_id = tail - ncfile.creator_name = 'Erik Koene (Empa)' - ncfile.date_created = str( datetime.datetime.now() ) - ######### Create dimension ######### - #ncfile.createDimension( 'soundings', s5p_data.dimensions['sounding_dim'].size ) # Select all - ncfile.createDimension( 'soundings', s5p_data['xco2'][indexes].size ) # Select the indexes - ncfile.createDimension( 'levels', s5p_data.dimensions['levels'].size ) - ncfile.createDimension( 'layers', s5p_data.dimensions['levels'].size ) - ncfile.createDimension( 'epoch_dimension', s5p_data.dimensions['epoch_dimension'].size ) - ######### Set variables ######### - ### Lat/Lon - lat = ncfile.createVariable('latitude', np.float32, ('soundings')) - lat.units = 'degrees_north' - #lat[:] = s5p_data.variables['latitude'][:] - lat[:] = s5p_data.variables['latitude'][indexes] - lon = ncfile.createVariable('longitude', np.float32, ('soundings')) - lon.units = 'degrees_east' - #lon[:] = s5p_data.variables['longitude'][:] - lon[:] = s5p_data.variables['longitude'][indexes] - ### Time - date = ncfile.createVariable('date', np.uint32, ('soundings', 'epoch_dimension')) - date.units = 'seconds since 1970-01-01 00:00:00' # - date.long_name = 'date_time' - # Converting... - A = np.array([], np.uint32) - for timestamp in s5p_data['time'][indexes]: - value = datetime.datetime.fromtimestamp(timestamp) - time = np.array([value.year, value.month, value.day, value.hour, value.minute, value.second, value.microsecond], np.uint32) - A = np.concatenate([A, time], axis=0) - B = A.reshape( int(len(A)/7), 7 ) - date[:] = B[:] - ##### Obs - obs = ncfile.createVariable('obs', np.float32, ('soundings')) - obs.units = '1e-6 [ppm]' - obs.long_name = 'column-averaged dry air mole fraction of atmospheric co2' - obs.comment = 'Retrieved column-averaged dry air mole fraction of atmospheric carbon dioxide (XCO2) in ppm for CTDAS' - obs[:] = s5p_data.variables['xco2'][indexes] # Keep ppm units - ### qa flag - qa_f = ncfile.createVariable('quality_flag', np.int8, ('soundings')) - qa_f.flag_values= '[0, 1]' - qa_f.long_name = 'quality flag for the retrieved column-averaged dry air mole fraction of atmospheric methane' - qa_f.comment = '0=good, 1=bad' - qa_f[:] = s5p_data.variables['xco2_quality_flag'][indexes] - ##### avg kernel - avg_kernel = ncfile.createVariable('averaging_kernel', np.float32, ('soundings', 'layers')) - avg_kernel.units = '1' - avg_kernel.long_name = 'xco2 averaging kernel' - avg_kernel.comment = 'Represents the altitude sensitivity of the retrieval as a function of pressure. All values represent layer averages within the corresponding pressure levels. Profiles are ordered from surface to top of atmosphere.' - #avg_kernel[:] = s5p_data.variables['xch4_averaging_kernel'][:] - avg_kernel[:] = s5p_data.variables['xco2_averaging_kernel'][:][indexes] - ### surface_pressure - psurf = ncfile.createVariable('surface_pressure', np.float32, ('soundings')) - psurf.long_name = 'Surface pressure' - psurf.comment = 'Sliced from: OCO2_pressure_levels[:, 0] in Python. Pressure levels defined at the same levels as the averaging kernel and a priori profile layers. Levels were ordered from top of atmosphere to surface.' - psurf.unit = 'hPa' - #psurf[:] = s5p_data.variables['pressure_levels'][:, 0] - psurf[:] = s5p_data.variables['pressure_levels'][indexes, -1] - ##### pressure_levels - pres_lvls = ncfile.createVariable('pressure_levels', np.float32, ('soundings', 'layers')) - pres_lvls.long_name = 'Pressure levels' - pres_lvls.comment = 'Sliced from: s5p_pressure_levels[:, 1:], Python. Pressure levels define the boundaries of the averaging kernel and a priori profile layers. Levels were ordered from top of atmosphere to surface.' - pres_lvls.unit = 'hPa' - pres_lvls[:] = s5p_data.variables['pressure_levels'][:, ::-1][indexes] - #### pressure_weighting_function - pwf = ncfile.createVariable('pressure_weighting_function', np.float32, ('soundings', 'layers')) - pwf.long_name = 'Pressure weighting function' - pwf.comment = 'Layer dependent weights needed to apply the averaging kernels.' - pwf[:] = s5p_data.variables['pressure_weight'][:,::-1][indexes] - ### prior_profile - prior_profile = ncfile.createVariable('prior_profile', np.float32, ('soundings', 'layers')) - prior_profile.units = '1e-6 [ppm]' - prior_profile.long_name = 'a priori dry air mole fraction profile of atmospheric CO2' - prior_profile.comment = 'A priori dry-air mole fraction profile of atmospheric CO2 in ppm. All values represent layer averages within the corresponding pressure levels. Profiles are ordered from top of atmosphere to the surface.' - prior_profile[:] = s5p_data.variables['co2_profile_apriori'][:,::-1][indexes] - ### prior - prior = ncfile.createVariable('prior', np.float32, ('soundings')) - prior.units = '1e-6 [ppm]' - prior.long_name = 'Prior' - prior.comment = 'The a priori CO2 profile uses the same formulation as used for TCCON GGG2020 retrievals' + ncfile.creator_name = 'Erik Koene (Empa)' + ncfile.date_created = str(datetime.datetime.now()) + ######### Create dimension ######### + #ncfile.createDimension( 'soundings', s5p_data.dimensions['sounding_dim'].size ) # Select all + ncfile.createDimension( + 'soundings', + s5p_data['xco2'][indexes].size) # Select the indexes + ncfile.createDimension('levels', + s5p_data.dimensions['levels'].size) + ncfile.createDimension('layers', + s5p_data.dimensions['levels'].size) + ncfile.createDimension('epoch_dimension', + s5p_data.dimensions['epoch_dimension'].size) + ######### Set variables ######### + ### Lat/Lon + lat = ncfile.createVariable('latitude', np.float32, ('soundings')) + lat.units = 'degrees_north' + #lat[:] = s5p_data.variables['latitude'][:] + lat[:] = s5p_data.variables['latitude'][indexes] + lon = ncfile.createVariable('longitude', np.float32, ('soundings')) + lon.units = 'degrees_east' + #lon[:] = s5p_data.variables['longitude'][:] + lon[:] = s5p_data.variables['longitude'][indexes] + ### Time + date = ncfile.createVariable('date', np.uint32, + ('soundings', 'epoch_dimension')) + date.units = 'seconds since 1970-01-01 00:00:00' # + date.long_name = 'date_time' + # Converting... + A = np.array([], np.uint32) + for timestamp in s5p_data['time'][indexes]: + value = datetime.datetime.fromtimestamp(timestamp) + time = np.array([ + value.year, value.month, value.day, value.hour, + value.minute, value.second, value.microsecond + ], np.uint32) + A = np.concatenate([A, time], axis=0) + B = A.reshape(int(len(A) / 7), 7) + date[:] = B[:] + ##### Obs + obs = ncfile.createVariable('obs', np.float32, ('soundings')) + obs.units = '1e-6 [ppm]' + obs.long_name = 'column-averaged dry air mole fraction of atmospheric co2' + obs.comment = 'Retrieved column-averaged dry air mole fraction of atmospheric carbon dioxide (XCO2) in ppm for CTDAS' + obs[:] = s5p_data.variables['xco2'][indexes] # Keep ppm units + ### qa flag + qa_f = ncfile.createVariable('quality_flag', np.int8, + ('soundings')) + qa_f.flag_values = '[0, 1]' + qa_f.long_name = 'quality flag for the retrieved column-averaged dry air mole fraction of atmospheric methane' + qa_f.comment = '0=good, 1=bad' + qa_f[:] = s5p_data.variables['xco2_quality_flag'][indexes] + ##### avg kernel + avg_kernel = ncfile.createVariable('averaging_kernel', np.float32, + ('soundings', 'layers')) + avg_kernel.units = '1' + avg_kernel.long_name = 'xco2 averaging kernel' + avg_kernel.comment = 'Represents the altitude sensitivity of the retrieval as a function of pressure. All values represent layer averages within the corresponding pressure levels. Profiles are ordered from surface to top of atmosphere.' + #avg_kernel[:] = s5p_data.variables['xch4_averaging_kernel'][:] + avg_kernel[:] = s5p_data.variables['xco2_averaging_kernel'][:][ + indexes] + ### surface_pressure + psurf = ncfile.createVariable('surface_pressure', np.float32, + ('soundings')) + psurf.long_name = 'Surface pressure' + psurf.comment = 'Sliced from: OCO2_pressure_levels[:, 0] in Python. Pressure levels defined at the same levels as the averaging kernel and a priori profile layers. Levels were ordered from top of atmosphere to surface.' + psurf.unit = 'hPa' + #psurf[:] = s5p_data.variables['pressure_levels'][:, 0] + psurf[:] = s5p_data.variables['pressure_levels'][indexes, -1] + ##### pressure_levels + pres_lvls = ncfile.createVariable('pressure_levels', np.float32, + ('soundings', 'layers')) + pres_lvls.long_name = 'Pressure levels' + pres_lvls.comment = 'Sliced from: s5p_pressure_levels[:, 1:], Python. Pressure levels define the boundaries of the averaging kernel and a priori profile layers. Levels were ordered from top of atmosphere to surface.' + pres_lvls.unit = 'hPa' + pres_lvls[:] = s5p_data.variables['pressure_levels'][:, ::-1][ + indexes] + #### pressure_weighting_function + pwf = ncfile.createVariable('pressure_weighting_function', + np.float32, ('soundings', 'layers')) + pwf.long_name = 'Pressure weighting function' + pwf.comment = 'Layer dependent weights needed to apply the averaging kernels.' + pwf[:] = s5p_data.variables['pressure_weight'][:, ::-1][indexes] + ### prior_profile + prior_profile = ncfile.createVariable('prior_profile', np.float32, + ('soundings', 'layers')) + prior_profile.units = '1e-6 [ppm]' + prior_profile.long_name = 'a priori dry air mole fraction profile of atmospheric CO2' + prior_profile.comment = 'A priori dry-air mole fraction profile of atmospheric CO2 in ppm. All values represent layer averages within the corresponding pressure levels. Profiles are ordered from top of atmosphere to the surface.' + prior_profile[:] = s5p_data.variables[ + 'co2_profile_apriori'][:, ::-1][indexes] + ### prior + prior = ncfile.createVariable('prior', np.float32, ('soundings')) + prior.units = '1e-6 [ppm]' + prior.long_name = 'Prior' + prior.comment = 'The a priori CO2 profile uses the same formulation as used for TCCON GGG2020 retrievals' prior[:] = s5p_data.variables["xco2_apriori"][indexes] - ### uncertainty - unc = ncfile.createVariable('uncertainty', np.float32, ('soundings')) - unc.units = '1e-6 [ppm]' - unc.long_name = '1-sigma uncertainty of the retrieved column-averaged dry air mole fraction of atmospheric carbon dioxide' - unc.comment = '1-sigma uncertainty of the retrieved column-averaged dry air mole fraction of atmospheric carbon dioxide (XCO2) in ppm' + ### uncertainty + unc = ncfile.createVariable('uncertainty', np.float32, + ('soundings')) + unc.units = '1e-6 [ppm]' + unc.long_name = '1-sigma uncertainty of the retrieved column-averaged dry air mole fraction of atmospheric carbon dioxide' + unc.comment = '1-sigma uncertainty of the retrieved column-averaged dry air mole fraction of atmospheric carbon dioxide (XCO2) in ppm' unc[:] = s5p_data.variables['xco2_uncertainty'][indexes] - ### Extras - # unique sounding_id - sounding_id = ncfile.createVariable('sounding_id', np.int64, ('soundings')) - sounding_id.comment ='Some numbers unique per observation' + ### Extras + # unique sounding_id + sounding_id = ncfile.createVariable('sounding_id', np.int64, + ('soundings')) + sounding_id.comment = 'Some numbers unique per observation' # sounding_id[:] = s5p_data.variables['sounding_id'][indexes] - #s5p_obs = s5p_data.variables['xch4'][:] - s5p_obs = s5p_data.variables['xco2'][indexes] - to_add = int('%04d%02d%02d0000000' %(Year, month, day)) # datetime + 9 zeros - sounding_id[:] = np.arange(len(s5p_obs)) + to_add - print('Added %s to sounding id, unique per observation' %to_add) - - # nobs - #nobs = ncfile.createVariable('nobs', np.unit32, ('soundings')) - #nobs.comment ='Number of observations' - #nobs[:] = - #print(ncfile) - ncfile.close() - print('Done! Closing netcdf, proceeding to the next file.') - print('') - - t2 = TIME.time() - print('') - print('All done! Wallclock time: %0.3f seconds' % (t2-t1)) - sum_before = np.sum(Total_nobs_before) - sum_after = np.sum(Total_nobs_after) - print('Summary:') - print('Original nobs: %i. Filtered nobs: %i.' %(sum_before, sum_after) ) + #s5p_obs = s5p_data.variables['xch4'][:] + s5p_obs = s5p_data.variables['xco2'][indexes] + to_add = int('%04d%02d%02d0000000' % + (Year, month, day)) # datetime + 9 zeros + sounding_id[:] = np.arange(len(s5p_obs)) + to_add + print('Added %s to sounding id, unique per observation' % to_add) + + # nobs + #nobs = ncfile.createVariable('nobs', np.unit32, ('soundings')) + #nobs.comment ='Number of observations' + #nobs[:] = + #print(ncfile) + ncfile.close() + print('Done! Closing netcdf, proceeding to the next file.') + print('') + + t2 = TIME.time() + print('') + print('All done! Wallclock time: %0.3f seconds' % (t2 - t1)) + sum_before = np.sum(Total_nobs_before) + sum_after = np.sum(Total_nobs_after) + print('Summary:') + print('Original nobs: %i. Filtered nobs: %i.' % (sum_before, sum_after)) From bbdb16009e0ba2639fa6a8101ea4ba55917eac77 Mon Sep 17 00:00:00 2001 From: efkmoene Date: Mon, 2 Dec 2024 14:07:57 +0100 Subject: [PATCH 21/42] Added processing scripts for ICOS and OCO2 data --- cases/icon-art-CTDAS/config.yaml | 1 + jobs/prepare_CTDAS.py | 249 +++++++------- jobs/tools/fetch_external_data.py | 548 +++++++++++++----------------- 3 files changed, 369 insertions(+), 429 deletions(-) diff --git a/cases/icon-art-CTDAS/config.yaml b/cases/icon-art-CTDAS/config.yaml index 147ae838..64648da6 100644 --- a/cases/icon-art-CTDAS/config.yaml +++ b/cases/icon-art-CTDAS/config.yaml @@ -49,6 +49,7 @@ chem: obs: fetch_ICOS: True + # From https://cpauth.icos-cp.eu ICOS_cookie_token: cpauthToken=WzE3MjkzNDMxNzIwNDQsImVyaWsua29lbmVAZW1wYS5jaCIsIlNhbWwiXR4FTcOofdFdurBv8MhnBQBBWQat65zbti2OCQ0t9tZd+rjAthGsn/WVSTwh/FadK3GpF0lh4Y1vxHMCuJKiytEMFREApm/O1TeA+2v1u7h8U0hAjn1Ao+ROzB/avbCzkI9vfxHOi2tTPOC4UomO99Dq7hZo0nNDYffeN4nxWd6kXoG3N6YKp5TzqZveL4GgWogZtaQm90+MdF5+NcPdxTM4mjD3qqsDG2TfwXttRd2WcSNhdAGE1b6o70wP1z22MewNhdCKmLLQH1mnhSXcfCJAwe67rugsSwAkWFpc0yusGylQKkdYiHYQw8vcYlkz1qgs1MNGB8URsHuETblnjqbG ICOS_path: /scratch/snx3000/ekoene/ICOS/ fetch_OCO2: True diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index 914d4ec9..ccc829ff 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -7,9 +7,7 @@ import shutil import subprocess from . import tools, prepare_icon -from pathlib import Path # noqa: F401 -from .tools.interpolate_data import create_oh_for_restart, create_oh_for_inicond # noqa: F401 -from .tools.fetch_external_data import fetch_era5, fetch_era5_nudging, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2 +from .tools.fetch_external_data import fetch_era5, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2_data, process_ICOS_data, process_OCO2_data from concurrent.futures import ThreadPoolExecutor, as_completed BASIC_PYTHON_JOB = False @@ -37,125 +35,122 @@ def main(cfg): tools.change_logfile(cfg.logfile) logging.info("Prepare ICON-ART for CTDAS") - # # -- 1. Download CAMS CO2 data (for a whole year) - # if cfg.chem_fetch_CAMS: - # fetch_CAMS_CO2( - # cfg.startdate_sim, cfg.icon_input_icbc - # ) # This should be turned into a more central location I think. - - # # -- 2. Fetch *all* ERA5 data (not just for initial conditions) - # if cfg.meteo_fetch_era5: - # times = list(tools.iter_hours(cfg.startdate_sim, cfg.enddate_sim, cfg.meteo_nudging_step)) - # logging.info(f"Time range considered here: {times}") - - # # Split downloads in 3-day chunks, but run simultaneously - # N = 3 - # chunks = list(tools.split_into_chunks(times, N, cfg.meteo_nudging_step)) - # logging.info(f"Time range split up into chunks of {N} days, giving the following chunks: {chunks}") - - # # Run fetch_era5 in parallel over chunks - # output_filenames = [None] * len(chunks) # Create a list to store filenames in order - # with ThreadPoolExecutor(max_workers=4) as executor: - # futures = {executor.submit(fetch_era5, chunk, cfg.icon_input_icbc, resolution=0.25, area=[60, -15, 35, 20]): i for i, chunk in enumerate(chunks)} - # for future in futures: - # index = futures[future] # Get the index of the future - # try: - # result = future.result() # Get the result from the future - # output_filenames[index] = result # Store the returned filename(s) in the correct order - # logging.info(f"Fetched data and saved to: {result}") - # except Exception as exc: - # logging.error(f"Generated an exception: {exc}") - # logging.info(f"All fetched files: {output_filenames}") - - # # Split files (with multiple days/times) into individual files using bash script - # era5_split_template = cfg.case_path / cfg.meteo_era5_splitjob - # era5_split_job = cfg.icon_input_icbc / cfg.meteo_era5_splitjob - # logging.info(f"Preparing ERA5 splitting script for ICON from {era5_split_template}") - # ml_files = " ".join([f"{filenames[0]}" for filenames in output_filenames]) - # surf_files = " ".join([f"{filenames[1]}" for filenames in output_filenames]) - # with open(era5_split_template, 'r') as infile, open(era5_split_job, 'w') as outfile: - # outfile.write(infile.read().format( - # cfg=cfg, - # ml_files=ml_files, - # surf_files=surf_files - # )) - # logging.info(f"Running ERA5 splitting script {era5_split_job}") - # subprocess.run(["bash", era5_split_job], check=True, stdout=subprocess.PIPE) - - # # -- 3. Process initial conditions data using bash script - # datestr = cfg.startdate_sim.strftime("%Y-%m-%dT%H:%M:%S") - # era5_ml_file = cfg.icon_input_icbc / f"era5_ml_{datestr}.nc" - # era5_surf_file = cfg.icon_input_icbc / f"era5_surf_{datestr}.nc" - # era5_ini_file = cfg.icon_input_icbc / f"era5_ini_{datestr}.nc" - # era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob - # era5_ini_job = cfg.icon_input_icbc / cfg.meteo_era5_inijob - # with open(era5_ini_template, 'r') as infile, open(era5_ini_job, - # 'w') as outfile: - # outfile.write(infile.read().format(cfg=cfg, - # era5_ml_file=era5_ml_file, - # era5_surf_file=era5_surf_file, - # inicond_filename=era5_ini_file)) - # shutil.copy(cfg.case_path / 'mypartab', cfg.icon_input_icbc / 'mypartab') - # logging.info(f"Running ERA5 initial conditions script {era5_ini_job}") - # subprocess.run(["bash", era5_ini_job], check=True, stdout=subprocess.PIPE) - # # --- CAMS inicond - # logging.info("Preparing CAMS preprocessing script for ICON") - # cams_ini_template = cfg.case_path / cfg.chem_cams_inijob - # cams_ini_job = cfg.icon_input_icbc / cfg.chem_cams_inijob - # with open(cams_ini_template, 'r') as infile, open(cams_ini_job, - # 'w') as outfile: - # outfile.write(infile.read().format(cfg=cfg, - # inicond_filename=era5_ini_file)) - # logging.info("Running CAMS preprocessing initial conditions script") - # subprocess.run(["bash", cams_ini_job], check=True, stdout=subprocess.PIPE) - - # # -- 3. If global nudging, download and process ERA5 and CAMS data - # if cfg.meteo_interpolate_CAMS_to_ERA5: - # for time in tools.iter_hours(cfg.startdate_sim, - # cfg.enddate_sim, - # step=cfg.meteo_nudging_step): - - # # -- Give a name to the nudging file - # datestr = time.strftime("%Y-%m-%dT%H:%M:%S") - # era5_ml_file = cfg.icon_input_icbc / f"era5_ml_{datestr}.nc" - # era5_surf_file = cfg.icon_input_icbc / f"era5_surf_{datestr}.nc" - # era5_nudge_file = cfg.icon_input_icbc / f"era5_nudge_{datestr}.nc" - - # # -- Copy ERA5 processing script (icon_era5_nudging.job) in workdir - # nudging_template = cfg.case_path / cfg.meteo_era5_nudgingjob - # nudging_job = cfg.icon_input_icbc / f'icon_era5_nudging_{datestr}.sh' - # with open(nudging_template, 'r') as infile, open(nudging_job, - # 'w') as outfile: - # outfile.write(infile.read().format(cfg=cfg, - # era5_ml_file=era5_ml_file, - # era5_surf_file=era5_surf_file, - # filename=era5_nudge_file)) - - # # -- Copy mypartab in workdir - # if not os.path.exists(cfg.case_path / 'mypartab'): - # shutil.copy(cfg.case_path / 'mypartab', - # cfg.icon_input_icbc / 'mypartab') - - # # -- Run ERA5 processing script - # subprocess.run(["bash", nudging_job], - # check=True, - # stdout=subprocess.PIPE) - - # # -- Copy CAMS processing script (icon_cams_nudging.job) in workdir - # logging.info("Preparing CAMS preprocessing nudging script for ICON") - # cams_nudge_template = cfg.case_path / cfg.chem_cams_nudgingjob - # cams_nudge_job = cfg.icon_input_icbc / cfg.chem_cams_nudgingjob - # with open(cams_nudge_template, 'r') as infile, open(cams_nudge_job, - # 'w') as outfile: - # outfile.write(infile.read().format(cfg=cfg, - # filename=era5_nudge_file)) - # subprocess.run(["bash", cams_nudge_job], check=True, stdout=subprocess.PIPE) + # -- 1. Download CAMS CO2 data (for a whole year) + if cfg.chem_fetch_CAMS: + fetch_CAMS_CO2( + cfg.startdate_sim, cfg.icon_input_icbc + ) # This should be turned into a more central location I think. + + # -- 2. Fetch *all* ERA5 data (not just for initial conditions) + if cfg.meteo_fetch_era5: + times = list(tools.iter_hours(cfg.startdate_sim, cfg.enddate_sim, cfg.meteo_nudging_step)) + logging.info(f"Time range considered here: {times}") + + # Split downloads in 3-day chunks, but run simultaneously + N = 3 + chunks = list(tools.split_into_chunks(times, N, cfg.meteo_nudging_step)) + logging.info(f"Time range split up into chunks of {N} days, giving the following chunks: {chunks}") + + # Run fetch_era5 in parallel over chunks + output_filenames = [None] * len(chunks) # Create a list to store filenames in order + with ThreadPoolExecutor(max_workers=4) as executor: + futures = {executor.submit(fetch_era5, chunk, cfg.icon_input_icbc, resolution=0.25, area=[60, -15, 35, 20]): i for i, chunk in enumerate(chunks)} + for future in futures: + index = futures[future] # Get the index of the future + try: + result = future.result() # Get the result from the future + output_filenames[index] = result # Store the returned filename(s) in the correct order + logging.info(f"Fetched data and saved to: {result}") + except Exception as exc: + logging.error(f"Generated an exception: {exc}") + logging.info(f"All fetched files: {output_filenames}") + + # Split files (with multiple days/times) into individual files using bash script + era5_split_template = cfg.case_path / cfg.meteo_era5_splitjob + era5_split_job = cfg.icon_input_icbc / cfg.meteo_era5_splitjob + logging.info(f"Preparing ERA5 splitting script for ICON from {era5_split_template}") + ml_files = " ".join([f"{filenames[0]}" for filenames in output_filenames]) + surf_files = " ".join([f"{filenames[1]}" for filenames in output_filenames]) + with open(era5_split_template, 'r') as infile, open(era5_split_job, 'w') as outfile: + outfile.write(infile.read().format( + cfg=cfg, + ml_files=ml_files, + surf_files=surf_files + )) + logging.info(f"Running ERA5 splitting script {era5_split_job}") + subprocess.run(["bash", era5_split_job], check=True, stdout=subprocess.PIPE) + + # -- 3. Process initial conditions data using bash script + datestr = cfg.startdate_sim.strftime("%Y-%m-%dT%H:%M:%S") + era5_ml_file = cfg.icon_input_icbc / f"era5_ml_{datestr}.nc" + era5_surf_file = cfg.icon_input_icbc / f"era5_surf_{datestr}.nc" + era5_ini_file = cfg.icon_input_icbc / f"era5_ini_{datestr}.nc" + era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob + era5_ini_job = cfg.icon_input_icbc / cfg.meteo_era5_inijob + with open(era5_ini_template, 'r') as infile, open(era5_ini_job, + 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + era5_ml_file=era5_ml_file, + era5_surf_file=era5_surf_file, + inicond_filename=era5_ini_file)) + shutil.copy(cfg.case_path / 'mypartab', cfg.icon_input_icbc / 'mypartab') + logging.info(f"Running ERA5 initial conditions script {era5_ini_job}") + subprocess.run(["bash", era5_ini_job], check=True, stdout=subprocess.PIPE) + # --- CAMS inicond + logging.info("Preparing CAMS preprocessing script for ICON") + cams_ini_template = cfg.case_path / cfg.chem_cams_inijob + cams_ini_job = cfg.icon_input_icbc / cfg.chem_cams_inijob + with open(cams_ini_template, 'r') as infile, open(cams_ini_job, + 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + inicond_filename=era5_ini_file)) + logging.info("Running CAMS preprocessing initial conditions script") + subprocess.run(["bash", cams_ini_job], check=True, stdout=subprocess.PIPE) + + # -- 3. Interpolate CAMS to ERA5 3D grid + if cfg.meteo_interpolate_CAMS_to_ERA5: + for time in tools.iter_hours(cfg.startdate_sim, + cfg.enddate_sim, + step=cfg.meteo_nudging_step): + + # -- Give a name to the nudging file + datestr = time.strftime("%Y-%m-%dT%H:%M:%S") + era5_ml_file = cfg.icon_input_icbc / f"era5_ml_{datestr}.nc" + era5_surf_file = cfg.icon_input_icbc / f"era5_surf_{datestr}.nc" + era5_nudge_file = cfg.icon_input_icbc / f"era5_nudge_{datestr}.nc" + + # -- Copy ERA5 processing script (icon_era5_nudging.job) in workdir + nudging_template = cfg.case_path / cfg.meteo_era5_nudgingjob + nudging_job = cfg.icon_input_icbc / f'icon_era5_nudging_{datestr}.sh' + with open(nudging_template, 'r') as infile, open(nudging_job, + 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + era5_ml_file=era5_ml_file, + era5_surf_file=era5_surf_file, + filename=era5_nudge_file)) + + # -- Copy mypartab in workdir + if not os.path.exists(cfg.case_path / 'mypartab'): + shutil.copy(cfg.case_path / 'mypartab', + cfg.icon_input_icbc / 'mypartab') + + # -- Run ERA5 processing script + subprocess.run(["bash", nudging_job], + check=True, + stdout=subprocess.PIPE) + + # -- Copy CAMS processing script (icon_cams_nudging.job) in workdir + logging.info("Preparing CAMS preprocessing nudging script for ICON") + cams_nudge_template = cfg.case_path / cfg.chem_cams_nudgingjob + cams_nudge_job = cfg.icon_input_icbc / cfg.chem_cams_nudgingjob + with open(cams_nudge_template, 'r') as infile, open(cams_nudge_job, + 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + filename=era5_nudge_file)) + subprocess.run(["bash", cams_nudge_job], check=True, stdout=subprocess.PIPE) # -- 4. Download ICOS CO2 data if cfg.obs_fetch_ICOS: - # -- This requires you to have accepted the ICOS license in your profile. - # So, login to https://cpauth.icos-cp.eu/home/ , check the box, and - # copy the cookie token on the bottom as your ICOS_cookie_token. fetch_ICOS_data(cookie_token=cfg.obs_ICOS_cookie_token, start_date=cfg.startdate_sim.strftime("%d-%m-%Y"), end_date=cfg.enddate_sim.strftime("%d-%m-%Y"), @@ -163,8 +158,12 @@ def main(cfg): species=[ 'co2', ]) - process_ICOS_data( - ) # Setup the post-processing, which concatenates all the data into one file + tools.create_dir(cfg.case_root / "global_inputs" / "ICOS", "ICOS input files") + process_ICOS_data(ICOS_obs_folder=cfg.obs_ICOS_path, + start_date=cfg.startdate_sim, + end_date=cfg.enddate_sim, + output_folder=cfg.case_root / "global_inputs" / "ICOS" + ) if cfg.obs_fetch_OCO2: # A user must do the following steps to obtain access to OCO2 data @@ -186,7 +185,7 @@ def main(cfg): # file.write('HTTP.NETRC={}.netrc'.format(homeDir)) # file.close() # Popen('chmod og-rw ~/.netrc', shell=True) - fetch_OCO2(cfg.startdate_sim, + fetch_OCO2_data(cfg.startdate_sim, cfg.enddate_sim, -8, 30, @@ -194,5 +193,9 @@ def main(cfg): 65, cfg.obs_OCO2_path, product="OCO2_L2_Lite_FP_11.1r") - process_OCO2() # post-process all the OCO2 data + tools.create_dir(cfg.case_root / "global_inputs" / "OCO2", "OCO-2 output") + process_OCO2_data(OCO2_obs_folder=cfg.obs_OCO2_path, + start_date=cfg.startdate_sim, + end_date=cfg.enddate_sim, + output_folder=cfg.case_root / "global_inputs" / "OCO2") # post-process all the OCO2 data logging.info("OK") diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 9fc379b4..5e87c805 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -1,5 +1,4 @@ import os -import shutil import cdsapi import zipfile import logging @@ -16,9 +15,10 @@ import urllib3 import requests from time import sleep -from subprocess import Popen from datetime import datetime, timedelta - +from pathlib import Path +from concurrent.futures import ThreadPoolExecutor +from . import iter_hours def fetch_CDS(product, date, levels, params, resolution, area, outloc): # Obtain CDS authentification from file @@ -368,17 +368,187 @@ def fetch_ICOS_data(cookie_token, ds.to_netcdf(os.path.join(save_path, name)) -def fetch_OCO2(starttime, - endtime, - minlon, - maxlon, - minlat, - maxlat, - output_folder, - product="OCO2_L2_Lite_FP_11r"): +def process_ICOS_data(ICOS_obs_folder, + start_date='01-01-2022', + end_date='31-12-2022', + output_folder='~/'): + """Package the downloaded ICOS data into a single file + + Parameters + ---------- + ICOS_obs_folder str e.g., /scratch/snx/[user]/ICOS_data/year + start_date DateTime + end_date DateTime + output_folder str e.g., /scratch/snx/[user]/ICOS_data/year/ + + """ + # Future expected options (or retrieved from grid file); for now hardcoded + lon_lims = [-8.3, 17.5] + lat_lims = [40.9, 58.7] + + # Utility for converting units to PPMv + toppm_dict = {'nmol mol-1':1e-9*1e6, + 'µmol mol-1':1e-6*1e6} + + # Gather chosen dates + delta = end_date - start_date + chosen_dates = [ + np.datetime64((start_date + timedelta(days=i, hours=h)).strftime('%Y-%m-%dT%H:%M:%S.000000000')) + for i in range(delta.days + 1) + for h in range(24) + ] + number_of_hourly_measurements = len(chosen_dates) + logging.info(f'A total of {number_of_hourly_measurements} hours are possible') + + # Gather files + logging.info(f"Looking in folder {ICOS_obs_folder} for ICOS observation files with glob *{start_date.strftime('%d-%m-%Y')}_{end_date.strftime('%d-%m-%Y')}.nc") + files = list(Path(ICOS_obs_folder).glob(f"*{start_date.strftime('%d-%m-%Y')}_{end_date.strftime('%d-%m-%Y')}.nc")) + number_of_stations = len(files) + logging.info(f'Will package data from {number_of_stations} files, {files}') + + # Prepare + obs_cnc_matrix = np.zeros((number_of_stations, number_of_hourly_measurements), dtype=np.float64) + obs_dates_matrix = np.zeros((number_of_stations, number_of_hourly_measurements), dtype = np.dtype('datetime64[ns]')) + obs_std_matrix = np.zeros((number_of_stations, number_of_hourly_measurements), dtype=np.float64) + + # Set-up a function that can be called in parallel + def extract_obs_column(file): + logging.info(f'Opened file {file}') + try: + # Open dataset and extract metadata + ds = xr.open_dataset(file) + name = f"{ds.attrs['Full name of the station']}_{file.name.split('_')[-3][:-2]}" + id_st = ds.attrs['Station'] + units = ds.attrs['Units'] + masl = ds.attrs['Elevation above sea level'] + diff = (ds.time.values[1] - ds.time.values[0]) / 3600000000000 # Time difference in hours + + if diff != 1: + logging.info(f'Observation data at station {name} is not hourly averaged ({diff} hours)') + + # Filter dataset to the desired time range + ds_filtered = ds.sel(time=slice(start_date, end_date)) + + # Align `chosen_dates` with `ds_filtered.time` + ds_aligned = ds_filtered.reindex(time=chosen_dates, method='nearest', tolerance='1h') + + # Update observation arrays + obs_dates1 = ds_aligned.time.values + obs_std1 = ds_aligned.Stdev.values * toppm_dict[units] + obs_cnc1 = ds_aligned["co2"].values * toppm_dict[units] + lons, lats = ds.attrs['Longitude'], ds.attrs['Latitude'] + + except Exception as e: + logging.info(f"Error processing file {file}: {e}") + obs_cnc1 = np.full(number_of_hourly_measurements, np.nan, dtype=np.float64) + obs_dates1 = np.full(number_of_hourly_measurements, np.datetime64("NaT"), dtype="datetime64[ns]") + obs_std1 = np.full(number_of_hourly_measurements, np.nan, dtype=np.float64) + name, id_st, masl, lons, lats = 'nan', 0, -999, np.nan, np.nan + + return name, obs_std1, obs_cnc1, obs_dates1, lons, lats, id_st, masl + + # Process all data concurrently + with ThreadPoolExecutor(max_workers=1) as executor: + results = list(executor.map(extract_obs_column, files)) + M = list(zip(*results)) + + station_names = np.array(M[0]) + obs_cnc = np.array(M[2]) + obs_std = np.array(M[1]) + obs_times = np.array(M[3]) + obs_lons = np.array(M[4]) + obs_lats = np.array(M[5]) + obs_ids = np.array(M[6]) + obs_masl = np.array(M[7]) + + # Initialize mask and removal list + stations_to_keep = [] + mask_true = np.full_like(obs_cnc_matrix[0], True) + + # Filter and populate matrices + for ix, (lon, lat, cnc, std, times) in enumerate(zip(obs_lons, obs_lats, obs_cnc, obs_std, obs_times)): + if any(np.isfinite(cnc)) and (lon_lims[0] < lon < lon_lims[-1]) and (lat_lims[0] < lat < lat_lims[-1]): + np.place(obs_cnc_matrix[ix], mask_true, cnc) + np.place(obs_std_matrix[ix], mask_true, std) + np.place(obs_dates_matrix[ix], mask_true, times) + stations_to_keep.append(ix) + + # Convert keep list to numpy index array for slicing + stations_to_keep = np.array(stations_to_keep) + + # Filter matrices and metadata + obs_cnc_matrix = obs_cnc_matrix[stations_to_keep] + obs_std_matrix = obs_std_matrix[stations_to_keep] + obs_dates_matrix = obs_dates_matrix[stations_to_keep] + station_names = station_names[stations_to_keep] + obs_lons = obs_lons[stations_to_keep] + obs_lats = obs_lats[stations_to_keep] + obs_ids = obs_ids[stations_to_keep] + obs_masl = obs_masl[stations_to_keep] + station_idcs = np.arange(len(station_names)) + + # Define data variables and attributes for xarray dataset + data_vars = { + "Concentration": (["station", "time"], obs_cnc_matrix, { + "units": "ppm", "long_name": "CO2_concentration" + }), + "Std": (["station", "time"], obs_std_matrix, { + "units": "ppm", "long_name": "CO2_concentrations_std" + }), + "Stations_names": (["station"], station_names, { + "units": "-", "long_name": "Stations_names" + }), + "Stations_ids": (["station"], obs_ids, { + "units": "-", "long_name": "Stations_names" + }), + "Stations_masl": (["station"], obs_masl, { + "units": "-", "long_name": "Elevation_heights_above_sl" + }), + "Lon": (["station"], obs_lons, { + "units": "degrees", "long_name": "Longitude" + }), + "Lat": (["station"], obs_lats, { + "units": "degrees", "long_name": "Latitude" + }), + "Dates": (["station", "time"], obs_dates_matrix, { + "long_name": "Dates" + }), + } + + # Define coordinates + coords = { + "station": (["station"], station_idcs) + } + attrs = { + 'creation_date':str(datetime.now()), + 'author':'Processing Chain' + } + + + # Create xarray dataset + ds_extracted_obs_matrix = xr.Dataset( + data_vars=data_vars, + coords=coords, + attrs=attrs + ) + + # Save dataset to file + output_filename = Path(output_folder) / f"Extracted_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}_alldates_masl.nc" + ds_extracted_obs_matrix.to_netcdf(output_filename) + + logging.info(f"Finished extraction and stored obs_matrix for {len(obs_lons)} stations ") + logging.info(f"(from {number_of_stations} available ICOS stations), which were operating ") + logging.info(f"during the given period and are located inside the model domain, in the file: {output_filename}") - # hmm. Not currently working. The data is there, https://oco2.gesdisc.eosdis.nasa.gov/data/OCO2_DATA/OCO2_L2_Lite_FP.11.1r/2020/ - # but GES DISC doesn't currently have it anymore... + +def fetch_OCO2_data(starttime, + endtime, + minlon, + maxlon, + minlat, + maxlat, + output_folder, + product="OCO2_L2_Lite_FP_11r"): # Set the product (based on the list above!) and other output settings product = product # Standard @@ -425,17 +595,11 @@ def get_http_data(request): } } - print("still here...1") - # Submit the subset request to the GES DISC Server response = get_http_data(subset_request) - print("and even here?") - # Report the JobID and initial status myJobId = response['result']['jobId'] - print('Job ID: ' + myJobId) - print('Job status: ' + response['result']['Status']) # Construct JSON WSP request for API method: GetStatus status_request = { @@ -535,290 +699,62 @@ def get_http_data(request): print('Finished') -def process_OCO2(): - ######### Some messages ######### - print( - '=============================================================================' - ) - print(' Pre-processing Observation product, readable for CTDAS-ICON.') - print(' Data will be filtered base on a given ICON domain.') - print(' David Ho, MPI-BGC Jena') - print( - '=============================================================================' - ) - print('') - print('Loading neccessary packages...') - ## Import - import numpy as np - import pandas as pd - import xarray as xr - import glob - from netCDF4 import Dataset - import datetime - import time as TIME - import warnings - import os - warnings.filterwarnings("ignore") - print('') - #-- retrieve start time - t1 = TIME.time() - ######### Output path ########### - nc_out = '//scratch/snx3000/ekoene/OCO-2_filtered/' - if not os.path.exists(nc_out): - os.makedirs(nc_out) - print(f"Output folder '{nc_out}' created successfully.") - else: - print(f"Output folder '{nc_out}' already exists.") - ######### Time control ########### - Year = 2018 - for month in range(1, 13): - if month in [4, 6, 9, 11]: - daymax = 30 - elif month == 2: - daymax = 28 - else: - daymax = 31 - - ndays = np.arange(1, daymax + 1) # 1st~31th - ######### Observation ########### - file_list = sorted( - glob.glob( - '/scratch/snx3000/ekoene/OCO-2/OCO2_L2_Lite_FP.11r:oco2_LtCO2_*' - )) - if len(file_list) == 0: - raise ValueError("File list is empty, stopping here!") - - ########## ICON grid ############ - mainpath = '/users/ekoene/CTDAS_inputs/' - grid_file = mainpath + '/icon_europe_DOM01.nc' - ICON_GRID = xr.open_dataset(grid_file) - # Convert an array of size 1 to its scalar equivalent. - lon_min = np.min(ICON_GRID.clon.values) - lon_max = np.max(ICON_GRID.clon.values) - lat_min = np.min(ICON_GRID.clat.values) - lat_max = np.max(ICON_GRID.clat.values) - print('ICON grid extends:') - print('Longitude min. %7.4f, max. %7.4f' % - (np.rad2deg(lon_min), np.rad2deg(lon_max))) - print('Latitude min. %7.4f, max. %7.4f' % - (np.rad2deg(lat_min), np.rad2deg(lat_max))) - print('') - ########## Set bounds to filter ########## - offset = 1.2 - sub_lon_min = np.rad2deg(lon_min) + offset - sub_lon_max = np.rad2deg(lon_max) - offset - sub_lat_min = np.rad2deg(lat_min) + offset - sub_lat_max = np.rad2deg(lat_max) - offset - print( - 'To avoid cells at the domain boundary, subtracting: %s degree.' % - offset) - print('Filtered extends:') - print('Longitude min. %7.4f, max. %7.4f' % (sub_lon_min, sub_lon_max)) - print('Latitude min. %7.4f, max. %7.4f' % (sub_lat_min, sub_lat_max)) - print('') - - ######## Begin Production ############# - Total_nobs_before = np.array([]) - Total_nobs_after = np.array([]) - for day in ndays: - print('Processing: (%s/%s)' % (day, len(ndays))) - ######### Read data ######### - try: - # Find a file in the file list - for file_name in file_list: - if f"OCO2_L2_Lite_FP.11r:oco2_LtCO2_{str(Year)[2:]}{month:02d}{day:02d}" in file_name: - s5p_file = file_name - print('Opening file: %s' % s5p_file) - s5p_data = Dataset(s5p_file) - except: - print('file %s not found.' % s5p_file) - print('Skipping...') - print('') - continue # Continue to next iteration. - - ######## Filter base of ICON domain ######## - date_list = [] - for timestamp in s5p_data['time'][:]: - value = datetime.datetime.fromtimestamp(timestamp) - date_list.append(value) - - dictionary = { - 'date_time': date_list[:], - 'raw_time': s5p_data['time'][:], - 'xco2': s5p_data['xco2'][:], - 'lat': s5p_data['latitude'][:], - 'lon': s5p_data['longitude'][:], - 'qf': s5p_data['xco2_quality_flag'] - [:], # quality flag 0 = good; 1 = bad. - } - df_pixels = pd.DataFrame(data=dictionary) - - ## Filter base on ICON domain ## - inside_domain_flag = ((df_pixels['lon'] > sub_lon_min) & - (df_pixels['lon'] < sub_lon_max) & - (df_pixels['lat'] > sub_lat_min) & - (df_pixels['lat'] < sub_lat_max) * - (df_pixels['qf'] == 0)) - - # -- Old hard coded settings: - # inside_domain_flag = ( ( df_pixels['lon'] > -20 ) & ( df_pixels['lon'] < 58 ) \ - # & ( df_pixels['lat'] > 32 ) & ( df_pixels['lat'] < 69 ) ) - ## Get the indexes from data frame ## - indexes = df_pixels[inside_domain_flag].index - - ## Some messages - Before = len(s5p_data.variables['xco2'][:]) - print('It had %i data' % Before) - Total_nobs_before = np.append(Total_nobs_before, Before) - - After = len(s5p_data.variables['xco2'][indexes]) - print('Now has %i' % After) - Total_nobs_after = np.append(Total_nobs_after, After) - if After == 0: - print('skipping') - continue - - ######### Create/Write netCDF ######### - _, tail = os.path.split(s5p_file) - output_path = os.path.join( - nc_out, 'OCO2_%04d%02d%02d_ctdas.nc' % (Year, month, day)) - ncfile = Dataset(output_path, mode='w', format='NETCDF4') - print('Writing %s from %s' % (output_path, s5p_file)) - - ######### Def. attribute ######### - ncfile.level_def = 'pressure_boundaries' - ncfile.retrieval_id = tail - ncfile.creator_name = 'Erik Koene (Empa)' - ncfile.date_created = str(datetime.datetime.now()) - ######### Create dimension ######### - #ncfile.createDimension( 'soundings', s5p_data.dimensions['sounding_dim'].size ) # Select all - ncfile.createDimension( - 'soundings', - s5p_data['xco2'][indexes].size) # Select the indexes - ncfile.createDimension('levels', - s5p_data.dimensions['levels'].size) - ncfile.createDimension('layers', - s5p_data.dimensions['levels'].size) - ncfile.createDimension('epoch_dimension', - s5p_data.dimensions['epoch_dimension'].size) - ######### Set variables ######### - ### Lat/Lon - lat = ncfile.createVariable('latitude', np.float32, ('soundings')) - lat.units = 'degrees_north' - #lat[:] = s5p_data.variables['latitude'][:] - lat[:] = s5p_data.variables['latitude'][indexes] - lon = ncfile.createVariable('longitude', np.float32, ('soundings')) - lon.units = 'degrees_east' - #lon[:] = s5p_data.variables['longitude'][:] - lon[:] = s5p_data.variables['longitude'][indexes] - ### Time - date = ncfile.createVariable('date', np.uint32, - ('soundings', 'epoch_dimension')) - date.units = 'seconds since 1970-01-01 00:00:00' # - date.long_name = 'date_time' - # Converting... - A = np.array([], np.uint32) - for timestamp in s5p_data['time'][indexes]: - value = datetime.datetime.fromtimestamp(timestamp) - time = np.array([ - value.year, value.month, value.day, value.hour, - value.minute, value.second, value.microsecond - ], np.uint32) - A = np.concatenate([A, time], axis=0) - B = A.reshape(int(len(A) / 7), 7) - date[:] = B[:] - ##### Obs - obs = ncfile.createVariable('obs', np.float32, ('soundings')) - obs.units = '1e-6 [ppm]' - obs.long_name = 'column-averaged dry air mole fraction of atmospheric co2' - obs.comment = 'Retrieved column-averaged dry air mole fraction of atmospheric carbon dioxide (XCO2) in ppm for CTDAS' - obs[:] = s5p_data.variables['xco2'][indexes] # Keep ppm units - ### qa flag - qa_f = ncfile.createVariable('quality_flag', np.int8, - ('soundings')) - qa_f.flag_values = '[0, 1]' - qa_f.long_name = 'quality flag for the retrieved column-averaged dry air mole fraction of atmospheric methane' - qa_f.comment = '0=good, 1=bad' - qa_f[:] = s5p_data.variables['xco2_quality_flag'][indexes] - ##### avg kernel - avg_kernel = ncfile.createVariable('averaging_kernel', np.float32, - ('soundings', 'layers')) - avg_kernel.units = '1' - avg_kernel.long_name = 'xco2 averaging kernel' - avg_kernel.comment = 'Represents the altitude sensitivity of the retrieval as a function of pressure. All values represent layer averages within the corresponding pressure levels. Profiles are ordered from surface to top of atmosphere.' - #avg_kernel[:] = s5p_data.variables['xch4_averaging_kernel'][:] - avg_kernel[:] = s5p_data.variables['xco2_averaging_kernel'][:][ - indexes] - ### surface_pressure - psurf = ncfile.createVariable('surface_pressure', np.float32, - ('soundings')) - psurf.long_name = 'Surface pressure' - psurf.comment = 'Sliced from: OCO2_pressure_levels[:, 0] in Python. Pressure levels defined at the same levels as the averaging kernel and a priori profile layers. Levels were ordered from top of atmosphere to surface.' - psurf.unit = 'hPa' - #psurf[:] = s5p_data.variables['pressure_levels'][:, 0] - psurf[:] = s5p_data.variables['pressure_levels'][indexes, -1] - ##### pressure_levels - pres_lvls = ncfile.createVariable('pressure_levels', np.float32, - ('soundings', 'layers')) - pres_lvls.long_name = 'Pressure levels' - pres_lvls.comment = 'Sliced from: s5p_pressure_levels[:, 1:], Python. Pressure levels define the boundaries of the averaging kernel and a priori profile layers. Levels were ordered from top of atmosphere to surface.' - pres_lvls.unit = 'hPa' - pres_lvls[:] = s5p_data.variables['pressure_levels'][:, ::-1][ - indexes] - #### pressure_weighting_function - pwf = ncfile.createVariable('pressure_weighting_function', - np.float32, ('soundings', 'layers')) - pwf.long_name = 'Pressure weighting function' - pwf.comment = 'Layer dependent weights needed to apply the averaging kernels.' - pwf[:] = s5p_data.variables['pressure_weight'][:, ::-1][indexes] - ### prior_profile - prior_profile = ncfile.createVariable('prior_profile', np.float32, - ('soundings', 'layers')) - prior_profile.units = '1e-6 [ppm]' - prior_profile.long_name = 'a priori dry air mole fraction profile of atmospheric CO2' - prior_profile.comment = 'A priori dry-air mole fraction profile of atmospheric CO2 in ppm. All values represent layer averages within the corresponding pressure levels. Profiles are ordered from top of atmosphere to the surface.' - prior_profile[:] = s5p_data.variables[ - 'co2_profile_apriori'][:, ::-1][indexes] - ### prior - prior = ncfile.createVariable('prior', np.float32, ('soundings')) - prior.units = '1e-6 [ppm]' - prior.long_name = 'Prior' - prior.comment = 'The a priori CO2 profile uses the same formulation as used for TCCON GGG2020 retrievals' - prior[:] = s5p_data.variables["xco2_apriori"][indexes] - ### uncertainty - unc = ncfile.createVariable('uncertainty', np.float32, - ('soundings')) - unc.units = '1e-6 [ppm]' - unc.long_name = '1-sigma uncertainty of the retrieved column-averaged dry air mole fraction of atmospheric carbon dioxide' - unc.comment = '1-sigma uncertainty of the retrieved column-averaged dry air mole fraction of atmospheric carbon dioxide (XCO2) in ppm' - unc[:] = s5p_data.variables['xco2_uncertainty'][indexes] - - ### Extras - # unique sounding_id - sounding_id = ncfile.createVariable('sounding_id', np.int64, - ('soundings')) - sounding_id.comment = 'Some numbers unique per observation' - # sounding_id[:] = s5p_data.variables['sounding_id'][indexes] - #s5p_obs = s5p_data.variables['xch4'][:] - s5p_obs = s5p_data.variables['xco2'][indexes] - to_add = int('%04d%02d%02d0000000' % - (Year, month, day)) # datetime + 9 zeros - sounding_id[:] = np.arange(len(s5p_obs)) + to_add - print('Added %s to sounding id, unique per observation' % to_add) - - # nobs - #nobs = ncfile.createVariable('nobs', np.unit32, ('soundings')) - #nobs.comment ='Number of observations' - #nobs[:] = - #print(ncfile) - ncfile.close() - print('Done! Closing netcdf, proceeding to the next file.') - print('') - - t2 = TIME.time() - print('') - print('All done! Wallclock time: %0.3f seconds' % (t2 - t1)) - sum_before = np.sum(Total_nobs_before) - sum_after = np.sum(Total_nobs_after) - print('Summary:') - print('Original nobs: %i. Filtered nobs: %i.' % (sum_before, sum_after)) +def process_OCO2_data(OCO2_obs_folder, + start_date='01-01-2022', + end_date='31-12-2022', + output_folder='~/'): + """Package the downloaded ICOS data into a single file + + Parameters + ---------- + OCO2_obs_folder str e.g., /scratch/snx/[user]/OCO2_data/year + start_date DateTime + end_date DateTime + output_folder str e.g., /scratch/snx/[user]/ICOS_data/year/ + + """ + + # # Process files + for day in iter_hours(start_date, end_date, 24): + + # Gather files + logging.info(f"Looking in folder {OCO2_obs_folder} for ICOS observation files with glob OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4") + file = list(Path(OCO2_obs_folder).glob(f"OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4")) + if not file: + continue + elif len(file)>0: + IndexError("Error, more OCO-2 files exist than expected. Review.") + else: + logging.info(f'Will open data from {file}') + + # Open file + s5p_data = xr.open_dataset(file[0]) + + # Process the 'time' variable: convert format, convert shape + # pressure_levels (rename, reverse direction), pressure_weight (rename, reverse, select) + # co2_profile_apriori (rename, reverse, select), xco2_apriori (rename, select) + # xco2_uncertainty (rename, select) + s5p_out = s5p_data[["latitude", "longitude", "date", + "xco2", "xco2_quality_flag", "xco2_averaging_kernel", "pressure_levels", + "pressure_levels", "pressure_weight", "co2_profile_apriori", "xco2_apriori", + "xco2_uncertainty" ]] + s5p_out = s5p_out.rename({"levels": "layers", + "sounding_id": "soundings", + "xco2": "obs", + "xco2_quality_flag": "quality_flag", + "xco2_averaging_kernel": "averaging_kernel", + "pressure_weight": "pressure_weighting_function", + "co2_profile_apriori": "prior_profile", + "xco2_apriori": "prior", + "xco2_uncertainty": "uncertainty"}) + s5p_out["pressure_levels"] = s5p_out.pressure_levels[:,::-1] + s5p_out["pressure_weighting_function"] = s5p_out.pressure_weighting_function[:,::-1] + s5p_out["surface_pressure"] = s5p_out.pressure_levels[:,0] + s5p_out.attrs.update({ + 'creation_date':str(datetime.now()), + 'author':'Processing Chain', + 'level_def': 'pressure_boundaries', + 'retrieval_id': file[0].name + }) + print(s5p_out) + s5p_out.to_netcdf(output_folder / f"OCO2_{day.strftime('%Y%m%d')}_ctdas.nc") \ No newline at end of file From 736aecea83124d3d32ea34b0a1216c4db8c85a8f Mon Sep 17 00:00:00 2001 From: github-actions Date: Mon, 2 Dec 2024 13:08:30 +0000 Subject: [PATCH 22/42] GitHub Action: Apply Pep8-formatting --- jobs/prepare_CTDAS.py | 101 ++++++++++------ jobs/tools/fetch_external_data.py | 192 ++++++++++++++++++------------ 2 files changed, 182 insertions(+), 111 deletions(-) diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index ccc829ff..07225217 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -7,7 +7,7 @@ import shutil import subprocess from . import tools, prepare_icon -from .tools.fetch_external_data import fetch_era5, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2_data, process_ICOS_data, process_OCO2_data +from .tools.fetch_external_data import fetch_era5, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2_data, process_ICOS_data, process_OCO2_data from concurrent.futures import ThreadPoolExecutor, as_completed BASIC_PYTHON_JOB = False @@ -43,23 +43,38 @@ def main(cfg): # -- 2. Fetch *all* ERA5 data (not just for initial conditions) if cfg.meteo_fetch_era5: - times = list(tools.iter_hours(cfg.startdate_sim, cfg.enddate_sim, cfg.meteo_nudging_step)) + times = list( + tools.iter_hours(cfg.startdate_sim, cfg.enddate_sim, + cfg.meteo_nudging_step)) logging.info(f"Time range considered here: {times}") # Split downloads in 3-day chunks, but run simultaneously N = 3 - chunks = list(tools.split_into_chunks(times, N, cfg.meteo_nudging_step)) - logging.info(f"Time range split up into chunks of {N} days, giving the following chunks: {chunks}") + chunks = list(tools.split_into_chunks(times, N, + cfg.meteo_nudging_step)) + logging.info( + f"Time range split up into chunks of {N} days, giving the following chunks: {chunks}" + ) # Run fetch_era5 in parallel over chunks - output_filenames = [None] * len(chunks) # Create a list to store filenames in order + output_filenames = [None] * len( + chunks) # Create a list to store filenames in order with ThreadPoolExecutor(max_workers=4) as executor: - futures = {executor.submit(fetch_era5, chunk, cfg.icon_input_icbc, resolution=0.25, area=[60, -15, 35, 20]): i for i, chunk in enumerate(chunks)} + futures = { + executor.submit(fetch_era5, + chunk, + cfg.icon_input_icbc, + resolution=0.25, + area=[60, -15, 35, 20]): + i + for i, chunk in enumerate(chunks) + } for future in futures: index = futures[future] # Get the index of the future try: result = future.result() # Get the result from the future - output_filenames[index] = result # Store the returned filename(s) in the correct order + output_filenames[ + index] = result # Store the returned filename(s) in the correct order logging.info(f"Fetched data and saved to: {result}") except Exception as exc: logging.error(f"Generated an exception: {exc}") @@ -68,17 +83,22 @@ def main(cfg): # Split files (with multiple days/times) into individual files using bash script era5_split_template = cfg.case_path / cfg.meteo_era5_splitjob era5_split_job = cfg.icon_input_icbc / cfg.meteo_era5_splitjob - logging.info(f"Preparing ERA5 splitting script for ICON from {era5_split_template}") - ml_files = " ".join([f"{filenames[0]}" for filenames in output_filenames]) - surf_files = " ".join([f"{filenames[1]}" for filenames in output_filenames]) - with open(era5_split_template, 'r') as infile, open(era5_split_job, 'w') as outfile: - outfile.write(infile.read().format( - cfg=cfg, - ml_files=ml_files, - surf_files=surf_files - )) + logging.info( + f"Preparing ERA5 splitting script for ICON from {era5_split_template}" + ) + ml_files = " ".join( + [f"{filenames[0]}" for filenames in output_filenames]) + surf_files = " ".join( + [f"{filenames[1]}" for filenames in output_filenames]) + with open(era5_split_template, + 'r') as infile, open(era5_split_job, 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + ml_files=ml_files, + surf_files=surf_files)) logging.info(f"Running ERA5 splitting script {era5_split_job}") - subprocess.run(["bash", era5_split_job], check=True, stdout=subprocess.PIPE) + subprocess.run(["bash", era5_split_job], + check=True, + stdout=subprocess.PIPE) # -- 3. Process initial conditions data using bash script datestr = cfg.startdate_sim.strftime("%Y-%m-%dT%H:%M:%S") @@ -124,10 +144,11 @@ def main(cfg): nudging_job = cfg.icon_input_icbc / f'icon_era5_nudging_{datestr}.sh' with open(nudging_template, 'r') as infile, open(nudging_job, 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - era5_ml_file=era5_ml_file, - era5_surf_file=era5_surf_file, - filename=era5_nudge_file)) + outfile.write(infile.read().format( + cfg=cfg, + era5_ml_file=era5_ml_file, + era5_surf_file=era5_surf_file, + filename=era5_nudge_file)) # -- Copy mypartab in workdir if not os.path.exists(cfg.case_path / 'mypartab'): @@ -140,14 +161,17 @@ def main(cfg): stdout=subprocess.PIPE) # -- Copy CAMS processing script (icon_cams_nudging.job) in workdir - logging.info("Preparing CAMS preprocessing nudging script for ICON") + logging.info( + "Preparing CAMS preprocessing nudging script for ICON") cams_nudge_template = cfg.case_path / cfg.chem_cams_nudgingjob cams_nudge_job = cfg.icon_input_icbc / cfg.chem_cams_nudgingjob - with open(cams_nudge_template, 'r') as infile, open(cams_nudge_job, - 'w') as outfile: + with open(cams_nudge_template, + 'r') as infile, open(cams_nudge_job, 'w') as outfile: outfile.write(infile.read().format(cfg=cfg, filename=era5_nudge_file)) - subprocess.run(["bash", cams_nudge_job], check=True, stdout=subprocess.PIPE) + subprocess.run(["bash", cams_nudge_job], + check=True, + stdout=subprocess.PIPE) # -- 4. Download ICOS CO2 data if cfg.obs_fetch_ICOS: @@ -158,12 +182,13 @@ def main(cfg): species=[ 'co2', ]) - tools.create_dir(cfg.case_root / "global_inputs" / "ICOS", "ICOS input files") + tools.create_dir(cfg.case_root / "global_inputs" / "ICOS", + "ICOS input files") process_ICOS_data(ICOS_obs_folder=cfg.obs_ICOS_path, start_date=cfg.startdate_sim, end_date=cfg.enddate_sim, - output_folder=cfg.case_root / "global_inputs" / "ICOS" - ) + output_folder=cfg.case_root / "global_inputs" / + "ICOS") if cfg.obs_fetch_OCO2: # A user must do the following steps to obtain access to OCO2 data @@ -186,16 +211,18 @@ def main(cfg): # file.close() # Popen('chmod og-rw ~/.netrc', shell=True) fetch_OCO2_data(cfg.startdate_sim, - cfg.enddate_sim, - -8, - 30, - 35, - 65, - cfg.obs_OCO2_path, - product="OCO2_L2_Lite_FP_11.1r") - tools.create_dir(cfg.case_root / "global_inputs" / "OCO2", "OCO-2 output") + cfg.enddate_sim, + -8, + 30, + 35, + 65, + cfg.obs_OCO2_path, + product="OCO2_L2_Lite_FP_11.1r") + tools.create_dir(cfg.case_root / "global_inputs" / "OCO2", + "OCO-2 output") process_OCO2_data(OCO2_obs_folder=cfg.obs_OCO2_path, start_date=cfg.startdate_sim, end_date=cfg.enddate_sim, - output_folder=cfg.case_root / "global_inputs" / "OCO2") # post-process all the OCO2 data + output_folder=cfg.case_root / "global_inputs" / + "OCO2") # post-process all the OCO2 data logging.info("OK") diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 5e87c805..d74a8155 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -20,6 +20,7 @@ from concurrent.futures import ThreadPoolExecutor from . import iter_hours + def fetch_CDS(product, date, levels, params, resolution, area, outloc): # Obtain CDS authentification from file url_cmd = f"grep 'cds' ~/.cdsapirc" @@ -368,7 +369,7 @@ def fetch_ICOS_data(cookie_token, ds.to_netcdf(os.path.join(save_path, name)) -def process_ICOS_data(ICOS_obs_folder, +def process_ICOS_data(ICOS_obs_folder, start_date='01-01-2022', end_date='31-12-2022', output_folder='~/'): @@ -387,29 +388,38 @@ def process_ICOS_data(ICOS_obs_folder, lat_lims = [40.9, 58.7] # Utility for converting units to PPMv - toppm_dict = {'nmol mol-1':1e-9*1e6, - 'µmol mol-1':1e-6*1e6} + toppm_dict = {'nmol mol-1': 1e-9 * 1e6, 'µmol mol-1': 1e-6 * 1e6} # Gather chosen dates delta = end_date - start_date chosen_dates = [ - np.datetime64((start_date + timedelta(days=i, hours=h)).strftime('%Y-%m-%dT%H:%M:%S.000000000')) - for i in range(delta.days + 1) - for h in range(24) + np.datetime64((start_date + timedelta( + days=i, hours=h)).strftime('%Y-%m-%dT%H:%M:%S.000000000')) + for i in range(delta.days + 1) for h in range(24) ] number_of_hourly_measurements = len(chosen_dates) - logging.info(f'A total of {number_of_hourly_measurements} hours are possible') + logging.info( + f'A total of {number_of_hourly_measurements} hours are possible') # Gather files - logging.info(f"Looking in folder {ICOS_obs_folder} for ICOS observation files with glob *{start_date.strftime('%d-%m-%Y')}_{end_date.strftime('%d-%m-%Y')}.nc") - files = list(Path(ICOS_obs_folder).glob(f"*{start_date.strftime('%d-%m-%Y')}_{end_date.strftime('%d-%m-%Y')}.nc")) + logging.info( + f"Looking in folder {ICOS_obs_folder} for ICOS observation files with glob *{start_date.strftime('%d-%m-%Y')}_{end_date.strftime('%d-%m-%Y')}.nc" + ) + files = list( + Path(ICOS_obs_folder).glob( + f"*{start_date.strftime('%d-%m-%Y')}_{end_date.strftime('%d-%m-%Y')}.nc" + )) number_of_stations = len(files) logging.info(f'Will package data from {number_of_stations} files, {files}') # Prepare - obs_cnc_matrix = np.zeros((number_of_stations, number_of_hourly_measurements), dtype=np.float64) - obs_dates_matrix = np.zeros((number_of_stations, number_of_hourly_measurements), dtype = np.dtype('datetime64[ns]')) - obs_std_matrix = np.zeros((number_of_stations, number_of_hourly_measurements), dtype=np.float64) + obs_cnc_matrix = np.zeros( + (number_of_stations, number_of_hourly_measurements), dtype=np.float64) + obs_dates_matrix = np.zeros( + (number_of_stations, number_of_hourly_measurements), + dtype=np.dtype('datetime64[ns]')) + obs_std_matrix = np.zeros( + (number_of_stations, number_of_hourly_measurements), dtype=np.float64) # Set-up a function that can be called in parallel def extract_obs_column(file): @@ -421,30 +431,41 @@ def extract_obs_column(file): id_st = ds.attrs['Station'] units = ds.attrs['Units'] masl = ds.attrs['Elevation above sea level'] - diff = (ds.time.values[1] - ds.time.values[0]) / 3600000000000 # Time difference in hours - + diff = (ds.time.values[1] - ds.time.values[0] + ) / 3600000000000 # Time difference in hours + if diff != 1: - logging.info(f'Observation data at station {name} is not hourly averaged ({diff} hours)') - + logging.info( + f'Observation data at station {name} is not hourly averaged ({diff} hours)' + ) + # Filter dataset to the desired time range ds_filtered = ds.sel(time=slice(start_date, end_date)) - + # Align `chosen_dates` with `ds_filtered.time` - ds_aligned = ds_filtered.reindex(time=chosen_dates, method='nearest', tolerance='1h') - + ds_aligned = ds_filtered.reindex(time=chosen_dates, + method='nearest', + tolerance='1h') + # Update observation arrays obs_dates1 = ds_aligned.time.values obs_std1 = ds_aligned.Stdev.values * toppm_dict[units] obs_cnc1 = ds_aligned["co2"].values * toppm_dict[units] lons, lats = ds.attrs['Longitude'], ds.attrs['Latitude'] - + except Exception as e: logging.info(f"Error processing file {file}: {e}") - obs_cnc1 = np.full(number_of_hourly_measurements, np.nan, dtype=np.float64) - obs_dates1 = np.full(number_of_hourly_measurements, np.datetime64("NaT"), dtype="datetime64[ns]") - obs_std1 = np.full(number_of_hourly_measurements, np.nan, dtype=np.float64) + obs_cnc1 = np.full(number_of_hourly_measurements, + np.nan, + dtype=np.float64) + obs_dates1 = np.full(number_of_hourly_measurements, + np.datetime64("NaT"), + dtype="datetime64[ns]") + obs_std1 = np.full(number_of_hourly_measurements, + np.nan, + dtype=np.float64) name, id_st, masl, lons, lats = 'nan', 0, -999, np.nan, np.nan - + return name, obs_std1, obs_cnc1, obs_dates1, lons, lats, id_st, masl # Process all data concurrently @@ -466,8 +487,10 @@ def extract_obs_column(file): mask_true = np.full_like(obs_cnc_matrix[0], True) # Filter and populate matrices - for ix, (lon, lat, cnc, std, times) in enumerate(zip(obs_lons, obs_lats, obs_cnc, obs_std, obs_times)): - if any(np.isfinite(cnc)) and (lon_lims[0] < lon < lon_lims[-1]) and (lat_lims[0] < lat < lat_lims[-1]): + for ix, (lon, lat, cnc, std, times) in enumerate( + zip(obs_lons, obs_lats, obs_cnc, obs_std, obs_times)): + if any(np.isfinite(cnc)) and (lon_lims[0] < lon < lon_lims[-1]) and ( + lat_lims[0] < lat < lat_lims[-1]): np.place(obs_cnc_matrix[ix], mask_true, cnc) np.place(obs_std_matrix[ix], mask_true, std) np.place(obs_dates_matrix[ix], mask_true, times) @@ -490,25 +513,32 @@ def extract_obs_column(file): # Define data variables and attributes for xarray dataset data_vars = { "Concentration": (["station", "time"], obs_cnc_matrix, { - "units": "ppm", "long_name": "CO2_concentration" + "units": "ppm", + "long_name": "CO2_concentration" }), "Std": (["station", "time"], obs_std_matrix, { - "units": "ppm", "long_name": "CO2_concentrations_std" + "units": "ppm", + "long_name": "CO2_concentrations_std" }), "Stations_names": (["station"], station_names, { - "units": "-", "long_name": "Stations_names" + "units": "-", + "long_name": "Stations_names" }), "Stations_ids": (["station"], obs_ids, { - "units": "-", "long_name": "Stations_names" + "units": "-", + "long_name": "Stations_names" }), "Stations_masl": (["station"], obs_masl, { - "units": "-", "long_name": "Elevation_heights_above_sl" + "units": "-", + "long_name": "Elevation_heights_above_sl" }), "Lon": (["station"], obs_lons, { - "units": "degrees", "long_name": "Longitude" + "units": "degrees", + "long_name": "Longitude" }), "Lat": (["station"], obs_lats, { - "units": "degrees", "long_name": "Latitude" + "units": "degrees", + "long_name": "Latitude" }), "Dates": (["station", "time"], obs_dates_matrix, { "long_name": "Dates" @@ -516,29 +546,32 @@ def extract_obs_column(file): } # Define coordinates - coords = { - "station": (["station"], station_idcs) - } + coords = {"station": (["station"], station_idcs)} attrs = { - 'creation_date':str(datetime.now()), - 'author':'Processing Chain' + 'creation_date': str(datetime.now()), + 'author': 'Processing Chain' } - # Create xarray dataset - ds_extracted_obs_matrix = xr.Dataset( - data_vars=data_vars, - coords=coords, - attrs=attrs - ) + ds_extracted_obs_matrix = xr.Dataset(data_vars=data_vars, + coords=coords, + attrs=attrs) # Save dataset to file - output_filename = Path(output_folder) / f"Extracted_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}_alldates_masl.nc" + output_filename = Path( + output_folder + ) / f"Extracted_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}_alldates_masl.nc" ds_extracted_obs_matrix.to_netcdf(output_filename) - logging.info(f"Finished extraction and stored obs_matrix for {len(obs_lons)} stations ") - logging.info(f"(from {number_of_stations} available ICOS stations), which were operating ") - logging.info(f"during the given period and are located inside the model domain, in the file: {output_filename}") + logging.info( + f"Finished extraction and stored obs_matrix for {len(obs_lons)} stations " + ) + logging.info( + f"(from {number_of_stations} available ICOS stations), which were operating " + ) + logging.info( + f"during the given period and are located inside the model domain, in the file: {output_filename}" + ) def fetch_OCO2_data(starttime, @@ -699,7 +732,7 @@ def get_http_data(request): print('Finished') -def process_OCO2_data(OCO2_obs_folder, +def process_OCO2_data(OCO2_obs_folder, start_date='01-01-2022', end_date='31-12-2022', output_folder='~/'): @@ -713,20 +746,24 @@ def process_OCO2_data(OCO2_obs_folder, output_folder str e.g., /scratch/snx/[user]/ICOS_data/year/ """ - + # # Process files for day in iter_hours(start_date, end_date, 24): # Gather files - logging.info(f"Looking in folder {OCO2_obs_folder} for ICOS observation files with glob OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4") - file = list(Path(OCO2_obs_folder).glob(f"OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4")) + logging.info( + f"Looking in folder {OCO2_obs_folder} for ICOS observation files with glob OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4" + ) + file = list( + Path(OCO2_obs_folder).glob( + f"OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4")) if not file: continue - elif len(file)>0: + elif len(file) > 0: IndexError("Error, more OCO-2 files exist than expected. Review.") - else: + else: logging.info(f'Will open data from {file}') - + # Open file s5p_data = xr.open_dataset(file[0]) @@ -734,27 +771,34 @@ def process_OCO2_data(OCO2_obs_folder, # pressure_levels (rename, reverse direction), pressure_weight (rename, reverse, select) # co2_profile_apriori (rename, reverse, select), xco2_apriori (rename, select) # xco2_uncertainty (rename, select) - s5p_out = s5p_data[["latitude", "longitude", "date", - "xco2", "xco2_quality_flag", "xco2_averaging_kernel", "pressure_levels", - "pressure_levels", "pressure_weight", "co2_profile_apriori", "xco2_apriori", - "xco2_uncertainty" ]] - s5p_out = s5p_out.rename({"levels": "layers", - "sounding_id": "soundings", - "xco2": "obs", - "xco2_quality_flag": "quality_flag", - "xco2_averaging_kernel": "averaging_kernel", - "pressure_weight": "pressure_weighting_function", - "co2_profile_apriori": "prior_profile", - "xco2_apriori": "prior", - "xco2_uncertainty": "uncertainty"}) - s5p_out["pressure_levels"] = s5p_out.pressure_levels[:,::-1] - s5p_out["pressure_weighting_function"] = s5p_out.pressure_weighting_function[:,::-1] - s5p_out["surface_pressure"] = s5p_out.pressure_levels[:,0] + s5p_out = s5p_data[[ + "latitude", "longitude", "date", "xco2", "xco2_quality_flag", + "xco2_averaging_kernel", "pressure_levels", "pressure_levels", + "pressure_weight", "co2_profile_apriori", "xco2_apriori", + "xco2_uncertainty" + ]] + s5p_out = s5p_out.rename({ + "levels": "layers", + "sounding_id": "soundings", + "xco2": "obs", + "xco2_quality_flag": "quality_flag", + "xco2_averaging_kernel": "averaging_kernel", + "pressure_weight": "pressure_weighting_function", + "co2_profile_apriori": "prior_profile", + "xco2_apriori": "prior", + "xco2_uncertainty": "uncertainty" + }) + s5p_out["pressure_levels"] = s5p_out.pressure_levels[:, ::-1] + s5p_out[ + "pressure_weighting_function"] = s5p_out.pressure_weighting_function[:, :: + -1] + s5p_out["surface_pressure"] = s5p_out.pressure_levels[:, 0] s5p_out.attrs.update({ - 'creation_date':str(datetime.now()), - 'author':'Processing Chain', + 'creation_date': str(datetime.now()), + 'author': 'Processing Chain', 'level_def': 'pressure_boundaries', 'retrieval_id': file[0].name }) print(s5p_out) - s5p_out.to_netcdf(output_folder / f"OCO2_{day.strftime('%Y%m%d')}_ctdas.nc") \ No newline at end of file + s5p_out.to_netcdf(output_folder / + f"OCO2_{day.strftime('%Y%m%d')}_ctdas.nc") From b43761b675857ad50125d88887d51adf7db28c86 Mon Sep 17 00:00:00 2001 From: efkmoene Date: Mon, 2 Dec 2024 17:46:09 +0100 Subject: [PATCH 23/42] Updated folder structure with some global (shared) data --- cases/icon-art-CTDAS/config.yaml | 2 +- cases/icon-art-CTDAS/icon_era5_inicond.sh | 2 +- cases/icon-art-CTDAS/icon_era5_nudging.sh | 2 +- cases/icon-art-CTDAS/icon_era5_splitfiles.sh | 2 +- cases/icon-art-CTDAS/icon_species_inicond.sh | 6 +- cases/icon-art-CTDAS/icon_species_nudging.sh | 6 +- env/environment.yml | 3 +- jobs/prepare_CTDAS.py | 84 +++++++++++++------- jobs/tools/fetch_external_data.py | 6 +- 9 files changed, 70 insertions(+), 43 deletions(-) diff --git a/cases/icon-art-CTDAS/config.yaml b/cases/icon-art-CTDAS/config.yaml index 64648da6..c65bf9ec 100644 --- a/cases/icon-art-CTDAS/config.yaml +++ b/cases/icon-art-CTDAS/config.yaml @@ -50,7 +50,7 @@ chem: obs: fetch_ICOS: True # From https://cpauth.icos-cp.eu - ICOS_cookie_token: cpauthToken=WzE3MjkzNDMxNzIwNDQsImVyaWsua29lbmVAZW1wYS5jaCIsIlNhbWwiXR4FTcOofdFdurBv8MhnBQBBWQat65zbti2OCQ0t9tZd+rjAthGsn/WVSTwh/FadK3GpF0lh4Y1vxHMCuJKiytEMFREApm/O1TeA+2v1u7h8U0hAjn1Ao+ROzB/avbCzkI9vfxHOi2tTPOC4UomO99Dq7hZo0nNDYffeN4nxWd6kXoG3N6YKp5TzqZveL4GgWogZtaQm90+MdF5+NcPdxTM4mjD3qqsDG2TfwXttRd2WcSNhdAGE1b6o70wP1z22MewNhdCKmLLQH1mnhSXcfCJAwe67rugsSwAkWFpc0yusGylQKkdYiHYQw8vcYlkz1qgs1MNGB8URsHuETblnjqbG + ICOS_cookie_token: cpauthToken=WzE3MzMyNTAzMTQ5MDgsImVyaWsua29lbmVAZW1wYS5jaCIsIlNhbWwiXR491DfOcSH3wU5kg994O0tfjYmRz96JPlpjzGPnva+LfSUkoNo125YUECiAMGpmkU5F8pioS6dvd9tfk8UodxYuoIS3eF3u9sul3wK+C0cs3CnENtD2WSr0tIZptPecWUkSvPnGtPQkVQxEtJpNgCj8YLtwl2m6XRq0yUO/zbD8bZTsZxzvDpLjoV1LLdQX+p5/Gck0Epvlv8Qij5fnvpl40II4nHLCfBaeFNx3ZYYDdPA8XTLuoIAHkC7tlUvBmnC4t6lk/QLAq//0iZVawanyPSj6R+COJlEx74otpmXgPe3PknaYWwLFfT4dX4YoJFYQC+RQnChePOdS+YoO4Nv9 ICOS_path: /scratch/snx3000/ekoene/ICOS/ fetch_OCO2: True OCO2_path: /scratch/snx3000/ekoene/OCO2 diff --git a/cases/icon-art-CTDAS/icon_era5_inicond.sh b/cases/icon-art-CTDAS/icon_era5_inicond.sh index a162e15e..e1c24ad4 100644 --- a/cases/icon-art-CTDAS/icon_era5_inicond.sh +++ b/cases/icon-art-CTDAS/icon_era5_inicond.sh @@ -1,6 +1,6 @@ #!/bin/bash -cd {cfg.icon_input_icbc} +cd {ERA5_folder} module load daint-mc CDO NCO diff --git a/cases/icon-art-CTDAS/icon_era5_nudging.sh b/cases/icon-art-CTDAS/icon_era5_nudging.sh index 736ce571..ff8f85b1 100644 --- a/cases/icon-art-CTDAS/icon_era5_nudging.sh +++ b/cases/icon-art-CTDAS/icon_era5_nudging.sh @@ -1,6 +1,6 @@ #!/bin/bash -cd {cfg.icon_input_icbc} +cd {ERA5_folder} module load daint-mc NCO CDO diff --git a/cases/icon-art-CTDAS/icon_era5_splitfiles.sh b/cases/icon-art-CTDAS/icon_era5_splitfiles.sh index 340d4fc8..44a804d8 100644 --- a/cases/icon-art-CTDAS/icon_era5_splitfiles.sh +++ b/cases/icon-art-CTDAS/icon_era5_splitfiles.sh @@ -1,6 +1,6 @@ #!/bin/bash -cd {cfg.icon_input_icbc} +cd {ERA5_folder} module load daint-mc CDO NCO diff --git a/cases/icon-art-CTDAS/icon_species_inicond.sh b/cases/icon-art-CTDAS/icon_species_inicond.sh index f40f8322..084f23ac 100644 --- a/cases/icon-art-CTDAS/icon_species_inicond.sh +++ b/cases/icon-art-CTDAS/icon_species_inicond.sh @@ -1,6 +1,6 @@ #!/bin/bash -cd {cfg.icon_input_icbc} +cd {ERA5_folder} module load daint-mc CDO source ~/miniconda3/bin/activate @@ -10,7 +10,7 @@ conda activate /scratch/snx3000/ekoene/conda/NCO # 1. Remap cdo griddes {inicond_filename} > triangular-grid.txt -cdo remapnn,triangular-grid.txt cams_egg4_2018010100.nc cams_triangle.nc +cdo remapnn,triangular-grid.txt {CAMS_file} cams_triangle.nc # 2. Write out the hybrid levels cat >CAMS_levels.txt < triangular-grid.txt -cdo remapnn,triangular-grid.txt cams_egg4_2018010100.nc cams_triangle.nc +cdo remapnn,triangular-grid.txt {CAMS_file} cams_triangle.nc # 2. Write out the hybrid levels cat >CAMS_levels.txt < Date: Wed, 18 Dec 2024 10:56:09 +0100 Subject: [PATCH 24/42] Added CTDAS tools and reorganized ICBC processing --- NAMELIST_ICONSUB | 11 + .../{ => ICBC}/icon_era5_inicond.sh | 4 +- .../{ => ICBC}/icon_era5_nudging.sh | 4 +- .../{ => ICBC}/icon_era5_splitfiles.sh | 0 .../{ => ICBC}/icon_species_inicond.sh | 7 +- .../{ => ICBC}/icon_species_nudging.sh | 26 +- cases/icon-art-CTDAS/config.yaml | 195 ++++++++--- cases/icon-art-oem-test/config.yaml | 10 +- cases/icon-art-oem-test/icon_runjob.cfg | 4 +- config.py | 33 +- jobs/prepare_CTDAS.py | 315 +++++++++++------- jobs/tools/__init__.py | 2 +- jobs/tools/ctdas_utilities.py | 139 ++++++++ jobs/tools/fetch_external_data.py | 137 ++++---- 14 files changed, 632 insertions(+), 255 deletions(-) create mode 100644 NAMELIST_ICONSUB rename cases/icon-art-CTDAS/{ => ICBC}/icon_era5_inicond.sh (98%) rename cases/icon-art-CTDAS/{ => ICBC}/icon_era5_nudging.sh (92%) rename cases/icon-art-CTDAS/{ => ICBC}/icon_era5_splitfiles.sh (100%) rename cases/icon-art-CTDAS/{ => ICBC}/icon_species_inicond.sh (88%) rename cases/icon-art-CTDAS/{ => ICBC}/icon_species_nudging.sh (71%) create mode 100644 jobs/tools/ctdas_utilities.py diff --git a/NAMELIST_ICONSUB b/NAMELIST_ICONSUB new file mode 100644 index 00000000..70f9f29b --- /dev/null +++ b/NAMELIST_ICONSUB @@ -0,0 +1,11 @@ +&iconsub_nml + grid_filename = '/scratch/snx3000/ekoene/test_chain/procchain/processing-chain/work/icon-art-CTDAS/2018010100_2018011100/icon/input/icon_europe_DOM01.nc', + output_type = 4, + lwrite_grid = .TRUE., +/ +&subarea_nml + ORDER = "lateral_boundary", + grf_info_file = '/scratch/snx3000/ekoene/test_chain/procchain/processing-chain/work/icon-art-CTDAS/2018010100_2018011100/icon/input/icon_europe_DOM01.nc', + min_refin_c_ctrl = 1 + max_refin_c_ctrl = 14 +/ diff --git a/cases/icon-art-CTDAS/icon_era5_inicond.sh b/cases/icon-art-CTDAS/ICBC/icon_era5_inicond.sh similarity index 98% rename from cases/icon-art-CTDAS/icon_era5_inicond.sh rename to cases/icon-art-CTDAS/ICBC/icon_era5_inicond.sh index e1c24ad4..f74f5909 100644 --- a/cases/icon-art-CTDAS/icon_era5_inicond.sh +++ b/cases/icon-art-CTDAS/ICBC/icon_era5_inicond.sh @@ -154,10 +154,10 @@ rm smil_out.nc # -------------------------------------- # -- Apply logarithm to surface pressure -cdo expr,'LNPS=ln(PS);' era5_final.nc tmp.nc +cdo expr,'LNPS=ln(PS); Q=QV; GEOP_SFC=GEOSP' era5_final.nc tmp.nc # -- Put the new variable LNSP in the original file -ncks -A -v LNPS tmp.nc era5_final.nc +ncks -A -v LNPS,Q,GEOP_SFC tmp.nc era5_final.nc rm tmp.nc # --------------------------------- diff --git a/cases/icon-art-CTDAS/icon_era5_nudging.sh b/cases/icon-art-CTDAS/ICBC/icon_era5_nudging.sh similarity index 92% rename from cases/icon-art-CTDAS/icon_era5_nudging.sh rename to cases/icon-art-CTDAS/ICBC/icon_era5_nudging.sh index ff8f85b1..eadebe83 100644 --- a/cases/icon-art-CTDAS/icon_era5_nudging.sh +++ b/cases/icon-art-CTDAS/ICBC/icon_era5_nudging.sh @@ -39,10 +39,10 @@ rm data_in.nc # -------------------------------------- # -- Apply logarithm to surface pressure -cdo expr,'LNPS=ln(PS);' era5_final.nc tmp.nc +cdo expr,'LNPS=ln(PS); Q=QV; GEOP_SFC=GEOSP' era5_final.nc tmp.nc # -- Put the new variable LNSP in the original file -ncks -A -v LNPS tmp.nc era5_final.nc +ncks -A -v LNPS,Q,GEOP_SFC tmp.nc era5_final.nc rm tmp.nc # --------------------------------- diff --git a/cases/icon-art-CTDAS/icon_era5_splitfiles.sh b/cases/icon-art-CTDAS/ICBC/icon_era5_splitfiles.sh similarity index 100% rename from cases/icon-art-CTDAS/icon_era5_splitfiles.sh rename to cases/icon-art-CTDAS/ICBC/icon_era5_splitfiles.sh diff --git a/cases/icon-art-CTDAS/icon_species_inicond.sh b/cases/icon-art-CTDAS/ICBC/icon_species_inicond.sh similarity index 88% rename from cases/icon-art-CTDAS/icon_species_inicond.sh rename to cases/icon-art-CTDAS/ICBC/icon_species_inicond.sh index 084f23ac..3de88f0f 100644 --- a/cases/icon-art-CTDAS/icon_species_inicond.sh +++ b/cases/icon-art-CTDAS/ICBC/icon_species_inicond.sh @@ -51,5 +51,8 @@ ncrename -O -d nhym,lev cams_remapped.nc # 5. Place in inicond file ncks -A -v CO2 cams_remapped.nc {inicond_filename} -ncap2 -s 'CO2_new[time,lev,ncells]=CO2; CO2=CO2_new;' {inicond_filename} -ncks -C -O -x -v CO2_new {inicond_filename} {cfg.icon_input_icbc}/$(basename {inicond_filename}) +ncap2 -s 'CO2_new[time,lev,ncells]=CO2;' {inicond_filename} +ncks -C -O -x -v CO2 {inicond_filename} {era5_cams_ini_file} +ncrename -v CO2_new,CO2 {era5_cams_ini_file} +ncrename -d .cell,ncells {era5_cams_ini_file} +ncrename -d .nv,vertices {era5_cams_ini_file} diff --git a/cases/icon-art-CTDAS/icon_species_nudging.sh b/cases/icon-art-CTDAS/ICBC/icon_species_nudging.sh similarity index 71% rename from cases/icon-art-CTDAS/icon_species_nudging.sh rename to cases/icon-art-CTDAS/ICBC/icon_species_nudging.sh index aee0727d..e3112d20 100644 --- a/cases/icon-art-CTDAS/icon_species_nudging.sh +++ b/cases/icon-art-CTDAS/ICBC/icon_species_nudging.sh @@ -51,5 +51,27 @@ ncrename -O -d nhym,lev cams_remapped.nc # 5. Place in inicond file ncks -A -v CO2 cams_remapped.nc {filename} -ncap2 -s 'CO2_new[time,lev,ncells]=CO2; CO2=CO2_new;' {filename} -ncks -C -O -x -v CO2_new {filename} {cfg.icon_input_icbc}/$(basename {filename}) +ncap2 -s 'CO2_new[time,lev,ncells]=CO2;' {filename} +ncks -C -O -x -v CO2 {filename} tmp.nc +ncrename -v CO2_new,CO2 tmp.nc + +# 6. Remap to lateral boundaries +cat > NAMELIST_ICONSUB << EOF_1 +&iconsub_nml + grid_filename = '{cfg.input_files_scratch_dynamics_grid_filename}', + output_type = 4, + lwrite_grid = .TRUE., +/ +&subarea_nml + ORDER = "lateral_boundary", + grf_info_file = '{cfg.input_files_scratch_dynamics_grid_filename}', + min_refin_c_ctrl = 1 + max_refin_c_ctrl = 42 +/ +EOF_1 + +{cfg.iconsub_bin} --nml NAMELIST_ICONSUB +cdo selgrid,2 lateral_boundary.grid.nc triangular-grid_00_lbc.nc +cdo remapdis,triangular-grid_00_lbc.nc tmp.nc {era5_cams_nudge_file} +ncrename -d cell,ncells {era5_cams_nudge_file} +ncrename -d nv,vertices {era5_cams_nudge_file} \ No newline at end of file diff --git a/cases/icon-art-CTDAS/config.yaml b/cases/icon-art-CTDAS/config.yaml index c65bf9ec..ed273877 100644 --- a/cases/icon-art-CTDAS/config.yaml +++ b/cases/icon-art-CTDAS/config.yaml @@ -4,29 +4,150 @@ workflow: icon constraint: gpu run_on: cpu compute_queue: normal -ntasks_per_node: 36 +ntasks_per_node: 12 startdate: 2018-01-01T00:00:00Z enddate: 2018-12-31T23:59:59Z -restart_step: PT10D -CTDAS_step: 240 +restart_step: PT10D # = CTDAS cycle length + +####### CTDAS options. +# First of all, download https://git.wur.nl/ctdas/CTDAS/-/tree/ctdas-icon +# (i.e., CTDAS with the ctdas-icon branch). +# Execute `start_ctdas_icon.sh $SCRATCH ctdas_procchain` +# which will put the CTDAS files into $SCRATCH/ctdas_procchain. +# We will then 'patch' this CTDAS installation with the required files, +# - ctdas-icon.py [which runs CTDAS; and imports the following patched classes]: + # - statevector class [which, ultimately, defines our ensemble members] + # - observation operator (obsoperator) class [which, ultimately, runs the ICON scripts & post-processing sampler] + # - observations class [which, ultimately, defines how to ingest the observations] + # - optimizer class [which, ultimately, defines how to do localization] +# - rc-cteco2 file [which, ultimately, is how we pass general input like folder names etc to CTDAS] +# - rc-job file [which, ultimately, is the setup for CTDAS like lag times, etc.] +CTDAS: + nlag: 2 + tracer: co2 + regions: basegrid # choose: basegrid or parentgrid + nensembles: 180 + # nregions: # read from cells->regions file + restart_init_time: 86400 # 1 day in seconds; using Michael Steiner's "overwriting" restart mechanism + nboundaries: 8 + lambdas: # The first 16 lambdas must be the respiration and uptake ones [even if not relevant, e.g., for a CH4 simulation], followed by the oem_cat categories in the xml file, in order of appearance, but excluding any + - 1,1,1,1,1,1,1,1 # Respiration (Evergreen Forest, Deciduous Forest, Mixed Forest, Shrubland, Savanna, Cropland, Grassland, Urban/Other) + - 1,1,1,1,1,1,1,1 # Uptake (E, D, M, S, SV, C, G, U) + - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2 # Anthropogenic CO2 (ensemble tracer categories that are optimized) + obs: + fetch_ICOS: True + # From https://cpauth.icos-cp.eu + ICOS_cookie_token: cpauthToken=WzE3MzM5NDQ3ODY3MTMsImVyaWsua29lbmVAZW1wYS5jaCIsIlNhbWwiXR6qePH9961Ih4LRBIu9/o+z/K7OSbvSf3EKUqpHA8orTrPjUMcuWrhmFbcVZeZPJ6uHY45go7BivHNShHkeF02yXrsC9MaYschekdvPvO4K9a4u+oqYi4M9J/s4Xv9LGsGTeHytuXhnfzdRtPKY9dykeW/bS6Gy4Rmou4+xJpf//kDajrNBy4Z0Z6Lrj1csQibe+cYjDObplLmDVs1NufUxyorCL6XbhaI2RLqaAvDWUqQ9A8kpbSJvW8Mdxit+6gDg+6gfnBrKFgL9Bs9VGkOjGKEmNUbn6XzBqPfMnt2NWnxsXyK1lXtLruTWRqsPcbK2hLvw7vj7iTUSDMpLQ1ew + ICOS_path: /scratch/snx3000/ekoene/ICOS/ + fetch_OCO2: True + OCO2_path: /scratch/snx3000/ekoene/OCO2 + global_inputs: + inventories: + - /users/ekoene/inventories/inventories/INV_20180101.nc + - /users/ekoene/inventories/inventories/INV_20180111.nc + - /users/ekoene/inventories/inventories/INV_20180121.nc + - /users/ekoene/inventories/inventories/INV_20180131.nc + - /users/ekoene/inventories/inventories/INV_20180210.nc + - /users/ekoene/inventories/inventories/INV_20180220.nc + - /users/ekoene/inventories/inventories/INV_20180302.nc + - /users/ekoene/inventories/inventories/INV_20180312.nc + - /users/ekoene/inventories/inventories/INV_20180322.nc + - /users/ekoene/inventories/inventories/INV_20180401.nc + - /users/ekoene/inventories/inventories/INV_20180411.nc + - /users/ekoene/inventories/inventories/INV_20180421.nc + - /users/ekoene/inventories/inventories/INV_20180501.nc + - /users/ekoene/inventories/inventories/INV_20180511.nc + - /users/ekoene/inventories/inventories/INV_20180521.nc + - /users/ekoene/inventories/inventories/INV_20180531.nc + - /users/ekoene/inventories/inventories/INV_20180610.nc + - /users/ekoene/inventories/inventories/INV_20180620.nc + - /users/ekoene/inventories/inventories/INV_20180630.nc + - /users/ekoene/inventories/inventories/INV_20180710.nc + - /users/ekoene/inventories/inventories/INV_20180720.nc + - /users/ekoene/inventories/inventories/INV_20180730.nc + - /users/ekoene/inventories/inventories/INV_20180809.nc + - /users/ekoene/inventories/inventories/INV_20180819.nc + - /users/ekoene/inventories/inventories/INV_20180829.nc + - /users/ekoene/inventories/inventories/INV_20180908.nc + - /users/ekoene/inventories/inventories/INV_20180918.nc + - /users/ekoene/inventories/inventories/INV_20180928.nc + - /users/ekoene/inventories/inventories/INV_20181008.nc + - /users/ekoene/inventories/inventories/INV_20181018.nc + - /users/ekoene/inventories/inventories/INV_20181028.nc + - /users/ekoene/inventories/inventories/INV_20181107.nc + - /users/ekoene/inventories/inventories/INV_20181117.nc + - /users/ekoene/inventories/inventories/INV_20181127.nc + - /users/ekoene/inventories/inventories/INV_20181207.nc + - /users/ekoene/inventories/inventories/INV_20181217.nc + grid: + - /users/ekoene/CTDAS_inputs/icon_europe_DOM01.parent.nc + - /users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc + - ./work/icon-art-CTDAS/global_inputs/ERA5/lateral_boundary.grid.nc # This is guaranteed to exist due to the ERA5/CAMS preprocessing + extpar: + - /users/ekoene/CTDAS_inputs/icon_extpar_EriksGrid.nc + VPRM: + - /users/ekoene/CTDAS_inputs/VPRM_indices_ICON_datestr.nc + XML: + - /users/ekoene/CTDAS_inputs/tracers_CO2_firstrun.xml + - /users/ekoene/CTDAS_inputs/tracers_CO2_restart.xml + +# # CTDAS ------------------------------------------------------------------------ +# ctdas_restart = False +# ctdas_BG_run = False +# # CTDAS cycle length in days +# ctdas_cycle = int(restart_cycle_window / 60 / 60 / 24) +# ctdas_nlag = 2 +# ctdas_tracer = 'co2' +# # CTDAS number of regions and cells->regions file +# ctdas_nreg_params = 21184 +# ctdas_regionsfile = vprm_regions_synth_nc # <--- Create +# # Number of boundaries, and boundaries mask/regions file +# ctdas_bg_params = 8 +# ctdas_boundary_mask_file = '/scratch/snx3000/ekoene/boundary_mask_bg.nc' +# # Number of ensemble members (make this consistent with your XML file!) +# ctdas_optimizer_nmembers = 180 +# # CTDAS path +# ctdas_dir = '/scratch/snx3000/ekoene/ctdas-icon/exec' +# # Distance file from region to region (shape: [N_reg x N_reg]), for statevector localization +# ctdas_sv_distances = '/scratch/snx3000/ekoene/CTDAS_cells2cells.nc' +# # Distance file from region to stations (shape: [N_reg x N_obs]), for observation localization +# ctdas_op_loc_coeffs = '/scratch/snx3000/ekoene/cells2stations.nc' +# # Directory containing a file with all the observations +# ctdas_datadir = '/scratch/snx3000/ekoene/ICOS_extracted/2018/' +# # CTDAS localization setting +# ctdas_system_localization = 'spatial' +# # CTDAS statevector length for one window +# ctdas_nparameters = 2 * ctdas_nreg_params + 8 # 2 (A , VPRM) * ctdas_nreg_params + ctdas_bg_params +# # Extraction template +# ctdas_extract_template = '/scratch/snx3000/ekoene/processing-chain/cases/VPRM_EU_ERA5_22/extract_template_icos_EU' +# # ICON runscript template +# ctdas_ICON_template = '/scratch/snx3000/ekoene/processing-chain/cases/VPRM_EU_ERA5_22/runscript_template_restart_icos_EU' +# # Full path to SBATCH template that can submit extraction scripts +# ctdas_sbatch_extract_template = '/scratch/snx3000/ekoene/processing-chain/cases/VPRM_EU_ERA5_22/sbatch_extract_template' +# # Full path to possibly time-varying emissionsgrid (if not time-varying, supply a filename without {}!) +# ctdas_oae_grid = "/scratch/snx3000/ekoene/inventories/INV_{}.nc" +# ctdas_oae_grid_fname = '%Y%m%d' # Specifies the naming scheme to use for the emission grids +# # Spinup time length +# ctdas_restart_init_time = 60 * 60 * 24 # 1 day in seconds +# # Restart file for the first simulation +# ctdas_first_restart_init = '/scratch/snx3000/ekoene/processing-chain/work/VPRM_EU_ERA5_22/2018010100_0_240/icon/output_INIT' +# # Number of vertical levels +# nvlev = 60 +# # NOT NEEDED FOR ANYTHING, EXCEPT TO MAKE CTDAS RUN +# ctdas_obsoperator_home = '/scratch/snx3000/msteiner/ctdas_test/exec/da/rc/stilt' +# ctdas_obsoperator_rc = os.path.join(ctdas_obsoperator_home, 'stilt_0.rc') +# ctdas_regtype = 'olson19_oif30' eccodes_dir: ./input/eccodes_definitions iconremap_bin: ./ext/icontools/icontools/iconremap -iconsub_bin: ./ext/icontools/icontools/iconsub -latbc_filename: ifs__lbc.nc -inidata_prefix: ifs_init_ -inidata_nameformat: '%Y%m%d%H' -inidata_filename_suffix: .nc -output_filename: icon-art-global-test -filename_format: _DOM_ -lateral_boundary_grid_order: lateral_boundary -art_input_folder: ./input/icon-art-global/art +iconsub_bin: /scratch/snx3000/ekoene/spack-c2sm/spack/opt/spack/icontools-c2sm-master/gcc-9.3.0/zktezcs5cjwjsptd747zhipi53nd6phr/bin/iconsub +art_input_folder: ./input/icon-art-oem/ART walltime: prepare_icon: '00:15:00' prepare_art_global: '00:10:00' icon: '00:05:00' - prepare_CTDAS: '3:00:00' + prepare_CTDAS: '20:00:00' meteo: nudging_step: 3 @@ -34,30 +155,20 @@ meteo: interpolate_CAMS_to_ERA5: True url: https://cds-beta.climate.copernicus.eu/api key: 1c2e45b1-dd08-4bc4-90c8-15c06304ae69 - era5_splitjob: icon_era5_splitfiles.sh - era5_inijob: icon_era5_inicond.sh - era5_nudgingjob: icon_era5_nudging.sh - + era5_splitjob: ICBC/icon_era5_splitfiles.sh + era5_inijob: ICBC/icon_era5_inicond.sh + era5_nudgingjob: ICBC/icon_era5_nudging.sh + partab: mypartab chem: nudging_step: 3 fetch_CAMS: True url: https://ads-beta.atmosphere.copernicus.eu/api key: 1c2e45b1-dd08-4bc4-90c8-15c06304ae69 - cams_inijob: icon_species_inicond.sh - cams_nudgingjob: icon_species_nudging.sh + cams_inijob: ICBC/icon_species_inicond.sh + cams_nudgingjob: ICBC/icon_species_nudging.sh -obs: - fetch_ICOS: True - # From https://cpauth.icos-cp.eu - ICOS_cookie_token: cpauthToken=WzE3MzMyNTAzMTQ5MDgsImVyaWsua29lbmVAZW1wYS5jaCIsIlNhbWwiXR491DfOcSH3wU5kg994O0tfjYmRz96JPlpjzGPnva+LfSUkoNo125YUECiAMGpmkU5F8pioS6dvd9tfk8UodxYuoIS3eF3u9sul3wK+C0cs3CnENtD2WSr0tIZptPecWUkSvPnGtPQkVQxEtJpNgCj8YLtwl2m6XRq0yUO/zbD8bZTsZxzvDpLjoV1LLdQX+p5/Gck0Epvlv8Qij5fnvpl40II4nHLCfBaeFNx3ZYYDdPA8XTLuoIAHkC7tlUvBmnC4t6lk/QLAq//0iZVawanyPSj6R+COJlEx74otpmXgPe3PknaYWwLFfT4dX4YoJFYQC+RQnChePOdS+YoO4Nv9 - ICOS_path: /scratch/snx3000/ekoene/ICOS/ - fetch_OCO2: True - OCO2_path: /scratch/snx3000/ekoene/OCO2 - input_files: - inicond_filename: ./input/icon-art-global/icbc/era2icon_R2B03_2022060200.nc - map_file_nudging: ./input/icon-art-global/icbc/map_file.nudging radiation_grid_filename: /users/ekoene/CTDAS_inputs/icon_europe_DOM01.parent.nc dynamics_grid_filename: /users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc extpar_filename: /users/ekoene/CTDAS_inputs/icon_extpar_EriksGrid.nc @@ -65,16 +176,16 @@ input_files: lrtm_filename: ./input/icon-art-global/rad/rrtmg_lw.nc chemtracer_xml_filename: ./input/icon-art-global/config/tracers.xml -icon: - binary_file: ./ext/icon-art/bin/icon - runjob_filename: icon_runjob.cfg - # era5_inijob: icon_era5_inicond.sh - # era5_nudgingjob: icon_era5_nudging.sh - species_inijob: icon_species_inicond.sh - species_nudgingjob: icon_species_nudging.sh - output_writing_step: 6 - compute_queue: normal - np_tot: 32 - np_io: 3 - np_restart: 1 - np_prefetch: 1 \ No newline at end of file +# icon: +# binary_file: ./ext/icon-art/bin/icon +# runjob_filename: icon_runjob.cfg +# # era5_inijob: icon_era5_inicond.sh +# # era5_nudgingjob: icon_era5_nudging.sh +# species_inijob: icon_species_inicond.sh +# species_nudgingjob: icon_species_nudging.sh +# output_writing_step: 6 +# compute_queue: normal +# np_tot: 32 +# np_io: 3 +# np_restart: 1 +# np_prefetch: 1 \ No newline at end of file diff --git a/cases/icon-art-oem-test/config.yaml b/cases/icon-art-oem-test/config.yaml index 9010fcfa..98796dc8 100644 --- a/cases/icon-art-oem-test/config.yaml +++ b/cases/icon-art-oem-test/config.yaml @@ -2,7 +2,7 @@ workflow: icon-art-oem constraint: gpu -run_on: cpu +run_on: gpu compute_queue: normal ntasks_per_node: 12 restart_step: PT6H @@ -10,8 +10,8 @@ startdate: 2018-01-01T00:00:00Z enddate: 2018-01-01T12:00:00Z eccodes_dir: ./input/eccodes_definitions -iconremap_bin: ./ext/icontools/icontools/iconremap -iconsub_bin: ./ext/icontools/icontools/iconsub +iconremap_bin: /scratch/snx3000/ekoene/spack-c2sm/spack/opt/spack/icontools-c2sm-master/gcc-9.3.0/zktezcs5cjwjsptd747zhipi53nd6phr/bin/iconremap +iconsub_bin: /scratch/snx3000/ekoene/spack-c2sm/spack/opt/spack/icontools-c2sm-master/gcc-9.3.0/zktezcs5cjwjsptd747zhipi53nd6phr/bin/iconsub latbc_filename: ifs__lbc.nc inidata_prefix: ifs_init_ inidata_nameformat: '%Y%m%d%H' @@ -69,11 +69,11 @@ input_files: oem_monthofyear_nc: ./input/icon-art-oem/OEM/monthofyear.nc icon: - binary_file: ./ext/icon-art/bin/icon + binary_file: /scratch/snx3000/msteiner/icon-kit/gpu/bin/icon runjob_filename: icon_runjob.cfg compute_queue: normal walltime: '00:10:00' - np_tot: 8 + np_tot: 6 np_io: 1 np_restart: 1 np_prefetch: 1 diff --git a/cases/icon-art-oem-test/icon_runjob.cfg b/cases/icon-art-oem-test/icon_runjob.cfg index cfa0f75e..9514e4e1 100644 --- a/cases/icon-art-oem-test/icon_runjob.cfg +++ b/cases/icon-art-oem-test/icon_runjob.cfg @@ -19,6 +19,8 @@ export OMP_SCHEDULE=static,12 export OMP_DYNAMIC="false" export OMP_STACKSIZE=200M +module load daint-gpu CDO + set -e -x # -- ECCODES path @@ -68,7 +70,7 @@ EOF cat > NAMELIST_{cfg.casename} << EOF ! parallel_nml: MPI parallelization ------------------------------------------- ¶llel_nml - nproma = 128 ! loop chunk length + nproma = 800 ! loop chunk length p_test_run = .FALSE. ! .TRUE. means verification run for MPI parallelization num_io_procs = {cfg.icon_np_io} ! number of I/O processors num_restart_procs = {cfg.icon_np_restart} ! number of restart processors diff --git a/config.py b/config.py index 8540c43d..f4257604 100644 --- a/config.py +++ b/config.py @@ -596,11 +596,14 @@ def get_previous_slurm_summary(self, # Get job info for all jobs self.slurm_info = {} for job_name in self.jobs: - for job_id in self.job_ids['previous'][job_name]: - self.slurm_info[job_name] = [] - self.slurm_info[job_name].append( - self.get_job_info(job_id, slurm_keys=info_keys, - parse=True)) + if job_name == "prepare_CTDAS": + continue + else: + for job_id in self.job_ids['previous'][job_name]: + self.slurm_info[job_name] = [] + self.slurm_info[job_name].append( + self.get_job_info(job_id, slurm_keys=info_keys, + parse=True)) def print_previous_slurm_summary(self): # Width of printed slurm piece of information @@ -634,19 +637,25 @@ def print_previous_slurm_summary(self): f.write(table_header) f.write('\n') for job_name in self.jobs: - for info in self.slurm_info[job_name]: - f.write(line_format.format(**info)) - f.write('\n') + if job_name == "prepare_CTDAS": + continue + else: + for info in self.slurm_info[job_name]: + f.write(line_format.format(**info)) + f.write('\n') f.write('\n') def check_previous_chunk_success(self): status = 0 failed_jobs = [] for job_name, info_list in self.slurm_info.items(): - for info in info_list: - if info['State'] != 'COMPLETED': - failed_jobs.append(job_name) - status += 1 + if job_name == "prepare_CTDAS": + continue + else: + for info in info_list: + if info['State'] != 'COMPLETED': + failed_jobs.append(job_name) + status += 1 if status > 0: raise RuntimeError(f"The following job(s) failed: {failed_jobs}") diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index 57127c4e..e56318cb 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -8,7 +8,9 @@ import subprocess from . import tools, prepare_icon from .tools.fetch_external_data import fetch_era5, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2_data, process_ICOS_data, process_OCO2_data +from .tools.ctdas_utilities import create_lambda_regions, create_prior_all_ones, create_boundary_regions, create_boundary_prior_all_onesll_ones from concurrent.futures import ThreadPoolExecutor, as_completed +from datetime import timedelta BASIC_PYTHON_JOB = False @@ -25,6 +27,8 @@ def main(cfg): 5. Download ICOS station data for the chosen dates 6. Download OCO-2 data for the chosen dates 7. Prepare the folder output structure + 8. Run the first one-day simulation + 9. Patch the CTDAS directory with files of our own Parameters ---------- @@ -40,9 +44,8 @@ def main(cfg): if cfg.chem_fetch_CAMS: CAMS_folder = cfg.case_root / "global_inputs" / "CAMS" tools.create_dir(CAMS_folder, "CAMS input files") - fetch_CAMS_CO2( - cfg.startdate_sim, CAMS_folder + cfg.startdate_sim, (cfg.enddate_sim+timedelta(days=1)), CAMS_folder ) # -- 2. Fetch *all* ERA5 data (not just for initial conditions) @@ -50,137 +53,156 @@ def main(cfg): ERA5_folder = cfg.case_root / "global_inputs" / "ERA5" tools.create_dir(ERA5_folder, "CAMS input files") - times = list(tools.iter_hours(cfg.startdate_sim, cfg.enddate_sim, cfg.meteo_nudging_step)) + times = list(tools.iter_hours(cfg.startdate_sim, (cfg.enddate_sim+timedelta(days=1)), cfg.meteo_nudging_step)) logging.info(f"Time range considered here: {times}") - # Split downloads in 3-day chunks, but run simultaneously - N = 3 - chunks = list(tools.split_into_chunks(times, N, cfg.meteo_nudging_step)) - logging.info(f"Time range split up into chunks of {N} days, giving the following chunks: {chunks}") - - # Run fetch_era5 in parallel over chunks - output_filenames = [None] * len(chunks) # Create a list to store filenames in order - with ThreadPoolExecutor(max_workers=4) as executor: - futures = {executor.submit(fetch_era5, chunk, ERA5_folder, resolution=0.25, area=[60, -15, 35, 20]): i for i, chunk in enumerate(chunks)} - for future in futures: - index = futures[future] # Get the index of the future - try: - result = future.result() # Get the result from the future - output_filenames[index] = result # Store the returned filename(s) in the correct order - logging.info(f"Fetched data and saved to: {result}") - except Exception as exc: - logging.error(f"Generated an exception: {exc}") - logging.info(f"All fetched files: {output_filenames}") - - # Split files (with multiple days/times) into individual files using bash script - era5_split_template = cfg.case_path / cfg.meteo_era5_splitjob - era5_split_job = ERA5_folder / cfg.meteo_era5_splitjob - logging.info(f"Preparing ERA5 splitting script for ICON from {era5_split_template}") - ml_files = " ".join([f"{filenames[0]}" for filenames in output_filenames]) - surf_files = " ".join([f"{filenames[1]}" for filenames in output_filenames]) - with open(era5_split_template, 'r') as infile, open(era5_split_job, 'w') as outfile: - outfile.write(infile.read().format( - cfg=cfg, - ml_files=ml_files, - surf_files=surf_files, - ERA5_folder=ERA5_folder - )) - logging.info(f"Running ERA5 splitting script {era5_split_job}") - subprocess.run(["bash", era5_split_job], check=True, stdout=subprocess.PIPE) + file_list = [f"era5_ml_{(cfg.startdate_sim + timedelta(hours=i)).replace(tzinfo=None).isoformat()}.nc" + for i in range(0, int((cfg.enddate_sim - cfg.startdate_sim).total_seconds() // 3600) + 1, cfg.meteo_nudging_step)] + file_list+= [f"era5_surf_{(cfg.startdate_sim + timedelta(hours=i)).replace(tzinfo=None).isoformat()}.nc" + for i in range(0, int((cfg.enddate_sim - cfg.startdate_sim).total_seconds() // 3600) + 1, cfg.meteo_nudging_step)] + missing_files = [file for file in file_list if not (ERA5_folder / file).exists()] + if not missing_files: + logging.info("All model level files already present") + else: + logging.info(f"Missing files: {missing_files}") + # Split downloads in 3-day chunks, but run simultaneously + N = 3 + chunks = list(tools.split_into_chunks(times, N, cfg.meteo_nudging_step)) + logging.info(f"Time range split up into chunks of {N} days, giving the following chunks: {chunks}") + + # Run fetch_era5 in parallel over chunks + output_filenames = [None] * len(chunks) # Create a list to store filenames in order + with ThreadPoolExecutor(max_workers=4) as executor: + futures = {executor.submit(fetch_era5, chunk, ERA5_folder, resolution=0.25, area=[60, -15, 35, 20]): i for i, chunk in enumerate(chunks)} + for future in futures: + index = futures[future] # Get the index of the future + try: + result = future.result() # Get the result from the future + output_filenames[index] = result # Store the returned filename(s) in the correct order + logging.info(f"Fetched data and saved to: {result}") + except Exception as exc: + logging.error(f"Generated an exception: {exc}") + logging.info(f"All fetched files: {output_filenames}") + + # Split files (with multiple days/times) into individual files using bash script + era5_split_template = cfg.case_path / cfg.meteo_era5_splitjob + era5_split_job = ERA5_folder / (cfg.meteo_era5_splitjob.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + cfg.meteo_era5_splitjob.suffix) + logging.info(f"Preparing ERA5 splitting script for ICON from {era5_split_template}") + ml_files = " ".join([f"{filenames[0]}" for filenames in output_filenames]) + surf_files = " ".join([f"{filenames[1]}" for filenames in output_filenames]) + with open(era5_split_template, 'r') as infile, open(era5_split_job, 'w') as outfile: + outfile.write(infile.read().format( + cfg=cfg, + ml_files=ml_files, + surf_files=surf_files, + ERA5_folder=ERA5_folder + )) + logging.info(f"Running ERA5 splitting script {era5_split_job}") + subprocess.run(["bash", era5_split_job], check=True, stdout=subprocess.PIPE) # -- 3. Process initial conditions data using bash script datestr = cfg.startdate_sim.strftime("%Y-%m-%dT%H:%M:%S") - era5_ml_file = ERA5_folder / f"era5_ml_{datestr}.nc" - era5_surf_file = ERA5_folder / f"era5_surf_{datestr}.nc" - era5_ini_file = ERA5_folder / f"era5_ini_{datestr}.nc" - era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob - era5_ini_job = ERA5_folder / cfg.meteo_era5_inijob - with open(era5_ini_template, 'r') as infile, open(era5_ini_job, - 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - era5_ml_file=era5_ml_file, - era5_surf_file=era5_surf_file, - inicond_filename=era5_ini_file, - ERA5_folder=ERA5_folder)) - shutil.copy(cfg.case_path / 'mypartab', ERA5_folder / 'mypartab') - logging.info(f"Running ERA5 initial conditions script {era5_ini_job}") - subprocess.run(["bash", era5_ini_job], check=True, stdout=subprocess.PIPE) - # --- CAMS inicond - logging.info("Preparing CAMS preprocessing script for ICON") - cams_ini_template = cfg.case_path / cfg.chem_cams_inijob - cams_ini_job = ERA5_folder / cfg.chem_cams_inijob - with open(cams_ini_template, 'r') as infile, open(cams_ini_job, - 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - inicond_filename=era5_ini_file, - ERA5_folder=ERA5_folder, - CAMS_file=CAMS_folder / f'cams_egg4_{cfg.startdate_sim.strftime("%Y%m%d%H")}.nc')) - logging.info("Running CAMS preprocessing initial conditions script") - subprocess.run(["bash", cams_ini_job], check=True, stdout=subprocess.PIPE) + era5_ini_file = cfg.icon_input_icbc / f"era5_ini_{datestr}.nc" + if not era5_ini_file.is_file(): + logging.info("Preparing ERA5 initial conditions script for ICON") + era5_ml_file = ERA5_folder / f"era5_ml_{datestr}.nc" + era5_surf_file = ERA5_folder / f"era5_surf_{datestr}.nc" + era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob + era5_ini_job = ERA5_folder / (era5_ini_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + era5_ini_template.suffix) + with open(era5_ini_template, 'r') as infile, open(era5_ini_job, + 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + era5_ml_file=era5_ml_file, + era5_surf_file=era5_surf_file, + inicond_filename=era5_ini_file, + ERA5_folder=ERA5_folder)) + shutil.copy(cfg.case_path / cfg.meteo_partab, ERA5_folder / 'mypartab') + logging.info(f"Running ERA5 initial conditions script {era5_ini_job}") + subprocess.run(["bash", era5_ini_job], check=True, stdout=subprocess.PIPE) + # --- CAMS inicond + logging.info("Preparing CAMS initial conditions script for ICON") + cams_ini_template = cfg.case_path / cfg.chem_cams_inijob + cams_ini_job = ERA5_folder / (cams_ini_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + cams_ini_template.suffix) + with open(cams_ini_template, 'r') as infile, open(cams_ini_job, + 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + inicond_filename=era5_ini_file, + ERA5_folder=ERA5_folder, + CAMS_file=CAMS_folder / f'cams_egg4_{cfg.startdate_sim.strftime("%Y%m%d%H")}.nc', + era5_cams_ini_file=era5_ini_file)) + logging.info(f"Running CAMS initial conditions script {cams_ini_job}") + subprocess.run(["bash", cams_ini_job], check=True, stdout=subprocess.PIPE) # -- 4. Interpolate CAMS to ERA5 3D grid if cfg.meteo_interpolate_CAMS_to_ERA5: for time in tools.iter_hours(cfg.startdate_sim, - cfg.enddate_sim, + (cfg.enddate_sim+timedelta(days=1)), step=cfg.meteo_nudging_step): # -- Give a name to the nudging file datestr = time.strftime("%Y-%m-%dT%H:%M:%S") - era5_ml_file = ERA5_folder / f"era5_ml_{datestr}.nc" - era5_surf_file = ERA5_folder / f"era5_surf_{datestr}.nc" - era5_nudge_file = ERA5_folder / f"era5_nudge_{datestr}.nc" - - # -- Copy ERA5 processing script (icon_era5_nudging.job) in workdir - nudging_template = cfg.case_path / cfg.meteo_era5_nudgingjob - nudging_job = ERA5_folder / f'icon_era5_nudging_{datestr}.sh' - with open(nudging_template, 'r') as infile, open(nudging_job, - 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - era5_ml_file=era5_ml_file, - era5_surf_file=era5_surf_file, - filename=era5_nudge_file, - ERA5_folder=ERA5_folder)) - - # -- Copy mypartab in workdir - if not os.path.exists(cfg.case_path / 'mypartab'): - shutil.copy(cfg.case_path / 'mypartab', - ERA5_folder / 'mypartab') - - # -- Run ERA5 processing script - subprocess.run(["bash", nudging_job], - check=True, - stdout=subprocess.PIPE) - - # -- Copy CAMS processing script (icon_cams_nudging.job) in workdir - logging.info("Preparing CAMS preprocessing nudging script for ICON") - cams_nudge_template = cfg.case_path / cfg.chem_cams_nudgingjob - cams_nudge_job = ERA5_folder / cfg.chem_cams_nudgingjob - with open(cams_nudge_template, 'r') as infile, open(cams_nudge_job, - 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - filename=era5_nudge_file, - ERA5_folder=ERA5_folder, - CAMS_file=CAMS_folder / f'cams_egg4_{time.strftime("%Y%m%d%H")}.nc')) - subprocess.run(["bash", cams_nudge_job], check=True, stdout=subprocess.PIPE) + datestr2= time.strftime("%Y%m%d%H") + era5_nudge_file_final = cfg.icon_input_icbc / f"era5_nudge_{datestr2}.nc" + if not era5_nudge_file_final.exists(): + era5_ml_file = ERA5_folder / f"era5_ml_{datestr}.nc" + era5_surf_file = ERA5_folder / f"era5_surf_{datestr}.nc" + era5_nudge_file = ERA5_folder / f"era5_nudge_{datestr}.nc" + + # -- Copy ERA5 processing script (icon_era5_nudging.job) in workdir + nudging_template = cfg.case_path / cfg.meteo_era5_nudgingjob + nudging_job = ERA5_folder / f'icon_era5_nudging_{datestr}.sh' + with open(nudging_template, 'r') as infile, open(nudging_job, + 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + era5_ml_file=era5_ml_file, + era5_surf_file=era5_surf_file, + filename=era5_nudge_file, + ERA5_folder=ERA5_folder)) + + # -- Copy mypartab into workdir + if not os.path.exists(ERA5_folder / 'mypartab'): + shutil.copy(cfg.case_path / cfg.meteo_partab, + ERA5_folder / 'mypartab') + + # -- Run ERA5 processing script + subprocess.run(["bash", nudging_job], + check=True, + stdout=subprocess.PIPE) + + # -- Copy CAMS processing script (icon_cams_nudging.job) into workdir + logging.info("Preparing CAMS preprocessing nudging script for ICON") + cams_nudge_template = cfg.case_path / cfg.chem_cams_nudgingjob + cams_nudge_job = ERA5_folder / (cams_nudge_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + cams_nudge_template.suffix) + with open(cams_nudge_template, 'r') as infile, open(cams_nudge_job, + 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + filename=era5_nudge_file, + ERA5_folder=ERA5_folder, + CAMS_file=CAMS_folder / f'cams_egg4_{time.strftime("%Y%m%d%H")}.nc', + era5_cams_nudge_file=era5_nudge_file_final, + )) + subprocess.run(["bash", cams_nudge_job], check=True, stdout=subprocess.PIPE) # -- 5. Download ICOS CO2 data - if cfg.obs_fetch_ICOS: - fetch_ICOS_data(cookie_token=cfg.obs_ICOS_cookie_token, + # Lots of potential for 'dehardcoding' things here, but that has to be done with + # a lot of care. + if cfg.CTDAS_obs_fetch_ICOS: + fetch_ICOS_data(cookie_token=cfg.CTDAS_obs_ICOS_cookie_token, start_date=cfg.startdate_sim.strftime("%d-%m-%Y"), - end_date=cfg.enddate_sim.strftime("%d-%m-%Y"), - save_path=cfg.obs_ICOS_path, + end_date=(cfg.enddate_sim+timedelta(days=1)).strftime("%d-%m-%Y"), + save_path=cfg.CTDAS_obs_ICOS_path, species=[ 'co2', ]) tools.create_dir(cfg.case_root / "global_inputs" / "ICOS", "ICOS input files") - process_ICOS_data(ICOS_obs_folder=cfg.obs_ICOS_path, + process_ICOS_data(ICOS_obs_folder=cfg.CTDAS_obs_ICOS_path, start_date=cfg.startdate_sim, - end_date=cfg.enddate_sim, + end_date=(cfg.enddate_sim+timedelta(days=1)), output_folder=cfg.case_root / "global_inputs" / "ICOS" ) # -- 6. Download OCO2 data - if cfg.obs_fetch_OCO2: + if cfg.CTDAS_obs_fetch_OCO2: # A user must do the following steps to obtain access to OCO2 data # from getpass import getpass # import os @@ -201,20 +223,19 @@ def main(cfg): # file.close() # Popen('chmod og-rw ~/.netrc', shell=True) fetch_OCO2_data(cfg.startdate_sim, - cfg.enddate_sim, + (cfg.enddate_sim+timedelta(days=1)), -8, 30, 35, 65, - cfg.obs_OCO2_path, + cfg.CTDAS_obs_OCO2_path, product="OCO2_L2_Lite_FP_11.1r") tools.create_dir(cfg.case_root / "global_inputs" / "OCO2", "OCO-2 output") - process_OCO2_data(OCO2_obs_folder=cfg.obs_OCO2_path, + process_OCO2_data(OCO2_obs_folder=cfg.CTDAS_obs_OCO2_path, start_date=cfg.startdate_sim, - end_date=cfg.enddate_sim, + end_date=(cfg.enddate_sim+timedelta(days=1)), output_folder=cfg.case_root / "global_inputs" / "OCO2") # post-process all the OCO2 data - # The cells2stations and/or cells2cells thing can be computed on-the-fly with from sklearn.metrics.pairwise import haversine_distances. See test_cells2cells.py # -- 7. Create the required folder structure # For the ICON runs tools.create_dir(cfg.icon_base / "output_prior", "Prior") @@ -224,4 +245,72 @@ def main(cfg): # For the sampling tools.create_dir(cfg.case_root / "global_output" / "extracted_ICOS", "Output of the extraction script") + # -- 8. Initialize the first one-day run, only for the first lag + if cfg.startdate_sim == cfg.startdate: + # -- 8.1 Get the global_inputs folder filled out + logging.info('Copy global inputs to working directory') + if cfg.machine == 'daint': + script_lines = [ + '#!/usr/bin/env bash', + f'#SBATCH --job-name="copy_input_{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.enddate_sim_yyyymmddhh}"', + f'#SBATCH --account={cfg.compute_account}', + '#SBATCH --time=00:10:00', + f'#SBATCH --partition={cfg.compute_queue}', + f'#SBATCH --constraint={cfg.constraint}', '#SBATCH --nodes=1', + f'#SBATCH --output={cfg.logfile}', '#SBATCH --open-mode=append', + f'#SBATCH --chdir={cfg.icon_work}', '' + ] + elif cfg.machine == 'euler': + script_lines = [ + '#!/usr/bin/env bash', + f'#SBATCH --job-name="copy_input_{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.enddate_sim_yyyymmddhh}"', + '#SBATCH --time=00:10:00', + f'#SBATCH --partition={cfg.compute_queue}', + f'#SBATCH --constraint={cfg.constraint}', '#SBATCH --ntasks=1', + f'#SBATCH --output={cfg.logfile}', '#SBATCH --open-mode=append', + f'#SBATCH --chdir={cfg.icon_work}', '' + ] + for category in cfg.CTDAS_global_inputs: + tools.create_dir(cat_folder := cfg.case_root / "global_inputs" / category, category) + for file in category: + source = (p := Path(file)) + destination = cat_folder / p.name + script_lines.append(f'rsync -av {source} {destination}') + with (script := cfg.icon_work / 'copy_global_inputs.job').open('w') as f: + f.write('\n'.join(script_lines)) + cfg.submit('global_inputs', script) + + # -- 8.2 Create the ensemble data for the first day + tools.create_dir(OEM_folder := cfg.case_root / "global_inputs" / "OEM", "OEM") + lambdas = [int(item) for line in cfg.CTDAS_lambdas for item in line.split(',')] + if cfg.CTDAS_regions == 'basegrid': + nregs, ncats = create_lambda_regions(cfg.input_files_dynamics_grid_filename, OEM_folder / "lambdaregions.nc", lambdas) + create_prior_all_ones(OEM_folder / "prior_all_ones.nc", nensembles=cfg.CTDAS_nensembles, ncats=lambdas.max(), nregs=nregs) + else: + raise NotImplementedError('Only basegrid is implemented for now') + create_boundary_regions('/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc', '/scratch/snx3000/ekoene/boundary_mask_bg.nc') + create_boundary_prior_all_onesll_ones('/scratch/snx3000/ekoene/boundary_lambdas_bg.nc', nensembles=cfg.CTDAS_nensembles) + + # Create a folder an `nlag` period earlier / icon / output_opt_twice + + # then initialize the runscript file + + # era5_split_template = cfg.case_path / cfg.firstrunscript + # era5_split_job = / cfg.meteo_era5_splitjob + # era5_split_job = era5_split_job.parent / (era5_split_job.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + era5_split_job.suffix) + # logging.info(f"Preparing ERA5 splitting script for ICON from {era5_split_template}") + # ml_files = " ".join([f"{filenames[0]}" for filenames in output_filenames]) + # surf_files = " ".join([f"{filenames[1]}" for filenames in output_filenames]) + # with open(era5_split_template, 'r') as infile, open(era5_split_job, 'w') as outfile: + # outfile.write(infile.read().format( + # cfg=cfg, + # ml_files=ml_files, + # surf_files=surf_files, + # ERA5_folder=ERA5_folder + # )) + # logging.info(f"Running ERA5 splitting script {era5_split_job}") + # subprocess.run(["bash", era5_split_job], check=True, stdout=subprocess.PIPE) + + logging.info("OK") + shutil.copy(cfg.logfile, cfg.logfile_finish) diff --git a/jobs/tools/__init__.py b/jobs/tools/__init__.py index 5d87aea0..490fac40 100644 --- a/jobs/tools/__init__.py +++ b/jobs/tools/__init__.py @@ -135,7 +135,7 @@ def prepare_message(logfile_path): message = message[:2048] + \ "\n\n--------------------------------------------------\n" + \ "### Some lines are skipped here. Original logfile:\n" + \ - logfile_path + \ + logfile_path.name + \ "\n--------------------------------------------------\n\n" + \ message[-2048:] diff --git a/jobs/tools/ctdas_utilities.py b/jobs/tools/ctdas_utilities.py new file mode 100644 index 00000000..6e150fee --- /dev/null +++ b/jobs/tools/ctdas_utilities.py @@ -0,0 +1,139 @@ +import xarray as xr +import numpy as np +import subprocess + + +import xarray as xr +import numpy as np +import subprocess + + +def create_lambda_regions(input_grid, output_path, lambdas_ids): + """ + Create a spatial map of lambda regions and save to NetCDF. + """ + ds = xr.open_dataset(input_grid) + ncells = ds.cell.size + nregs = ncells # Set nregs to match grid cells; modify as needed + categories = np.arange(1, len(lambdas_ids) + 1) + regions = np.arange(nregs) + cells = np.arange(ncells) + 1 + + # Create dataset + ds_cells = xr.Dataset( + data_vars={ + 'REG': (['cell'], regions), + 'Lambda_indicies': (['cat'], lambdas_ids) + }, + coords={ + 'cell': (['cell'], cells), + 'cat': (['cat'], categories) + }, + attrs={ + 'author': 'Processing Chain' + } + ) + + ds_cells.to_netcdf(output_path, encoding={'REG': {'dtype': 'int32'}, 'cell': {'dtype': 'int32'}}) + print(f"Lambda regions saved to {output_path}") + return nregs, categories[-1] + + +def create_prior_all_ones(output_path, nensembles, ncats, nregs): + """ + Create a dataset of initial lambdas (all ones) for testing. + """ + arr = np.ones((nensembles, nregs, ncats, 1), dtype=np.float32) + data = xr.DataArray(arr, dims=['ens', 'reg', 'cat', 'tracer']) + ds = xr.Dataset({'lambda': data}) + ds.to_netcdf(output_path) + print(f"Prior all ones saved to {output_path}") + + +def create_boundary_regions(grid_filename, output_path): + """ + Create boundary region masks based on geographical quadrants and save to NetCDF. + """ + cmd = f""" +cat > NAMELIST_ICONSUB << EOF_1 +&iconsub_nml + grid_filename = '{grid_filename}', + output_type = 4, + lwrite_grid = .TRUE., +/ +&subarea_nml + ORDER = "outgrid", + grf_info_file = '{grid_filename}', + min_refin_c_ctrl = 1, + max_refin_c_ctrl = 120 +/ +EOF_1 + +/scratch/snx3000/ekoene/spack-c2sm/spack/opt/spack/icontools-c2sm-master/gcc-9.3.0/zktezcs5cjwjsptd747zhipi53nd6phr/bin/iconsub --nml NAMELIST_ICONSUB + """ + subprocess.check_output(cmd, shell=True) + + ds_grid = xr.open_dataset('outgrid.grid.nc') + clon, clat = np.rad2deg(ds_grid['clon']), np.rad2deg(ds_grid['clat']) + mid_lon, mid_lat = np.nanquantile(clon, 0.5), np.nanquantile(clat, 0.5) + + boundary_regions = np.zeros((len(clon), 8), dtype=np.int32) + clon_cent, clat_cent = clon - mid_lon, clat - mid_lat + + for i, (lon, lat) in enumerate(zip(clon_cent, clat_cent)): + if lon > 0 and lat > 0: + boundary_regions[i][6 if lon > lat else 7] = 1 + elif lon < 0 and lat < 0: + boundary_regions[i][2 if lon > lat else 3] = 1 + elif lon > 0 and lat < 0: + boundary_regions[i][4 if lon > abs(lat) else 5] = 1 + elif lon < 0 and lat > 0: + boundary_regions[i][0 if abs(lon) > lat else 1] = 1 + + ds_boundary = xr.Dataset( + data_vars={ + 'boundaryregion': (['cell', 'reg'], boundary_regions), + 'global_cell_idx': (['cell'], np.arange(len(clon))) + }, + coords={ + 'cell': (['cell'], np.arange(len(clon))), + 'reg': (['reg'], np.arange(8)) + }, + attrs={ + 'author': 'Erik Koene', + 'email': 'erik.koene@empa.ch' + } + ) + ds_boundary.to_netcdf(output_path) + print(f"Boundary regions saved to {output_path}") + + +def create_boundary_prior_all_onesll_ones(output_path, nensembles): + """ + Create boundary lambdas dataset and save to NetCDF. + """ + lambdas = np.ones((nensembles,8), dtype=np.float32) + ds_lambdas = xr.Dataset( + data_vars={ + 'lambda': (['ens', 'reg'], lambdas) + }, + coords={ + 'ens': (['ens'], np.arange(nensembles)), + 'reg': (['reg'], np.arange(8)) + }, + attrs={ + 'author': 'Erik Koene', + 'email': 'erik.koene@empa.ch' + } + ) + ds_lambdas.to_netcdf(output_path) + print(f"Boundary lambdas saved to {output_path}") + + +# Example usage +# lambdas_ids = np.array([1]*8+[1]*8+[1]*15) +# nensembles=180 +# nregs, ncats = create_lambda_regions('/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc', '/scratch/snx3000/ekoene/lambdaregions.nc', lambdas_ids) +# create_prior_all_ones('/scratch/snx3000/ekoene/prior_all_ones.nc', nensembles=nensembles, ncats=lambdas_ids.max(), nregs=nregs) +# create_boundary_regions('/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc', '/scratch/snx3000/ekoene/boundary_mask_bg.nc') +# create_boundary_prior_all_ones('/scratch/snx3000/ekoene/boundary_lambdas_bg.nc', nensembles=nensembles) diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 070be5de..61ebe365 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -18,7 +18,7 @@ from datetime import datetime, timedelta from pathlib import Path from concurrent.futures import ThreadPoolExecutor -from . import iter_hours +from . import iter_hours, create_dir def fetch_CDS(product, date, levels, params, resolution, area, outloc): # Obtain CDS authentification from file @@ -170,19 +170,19 @@ def fetch_era5_nudging(date, dir2move, resolution=1.0, area=None): return outfile_3D, outfile_surface -def fetch_CAMS_CO2(date, dir2move): +def fetch_CAMS_CO2(start_date, end_date, dir2move): """Fetch CAMS CO2 data from ECMWF for initial and boundary conditions Parameters ---------- - date : initial date to fetch a year's worth of data - + start_date : initial date to fetch data for + end_date : final date to fetch data for + dir2move : directory to move to """ # Set a temporary destionation tmpdir = os.path.join(os.getenv('SCRATCH'), 'CAMS_i') - if not os.path.exists(tmpdir): - os.makedirs(tmpdir) + create_dir(tmpdir, 'Temporary output for CAMS data download') url_cmd = f"grep 'ads' ~/.cdsapirc" url = os.popen(url_cmd).read().strip().split(": ")[1] @@ -190,67 +190,65 @@ def fetch_CAMS_CO2(date, dir2move): key = os.popen(key_cmd).read().strip().split(": ")[1] c = cdsapi.Client(url=url, key=key) - download = os.path.join(tmpdir, f'cams_GHG_{date.strftime("%Y")}.zip') - if not os.path.isfile(download): - c.retrieve( - 'cams-global-greenhouse-gas-inversion', { - 'variable': - 'carbon_dioxide', - 'quantity': - 'concentration', - 'input_observations': - 'surface', - 'time_aggregation': - 'instantaneous', - 'version': - 'latest', - 'year': - date.strftime('%Y'), - 'month': [ - '01', - '02', - '03', - '04', - '05', - '06', - '07', - '08', - '09', - '10', - '11', - '12', - ], - 'format': - 'zip', - }, download) - logging.info(f'downloaded the CAMS data!') - else: - logging.info(f'File already downloaded and present at {download}') - - # --- Extract the zip file - with zipfile.ZipFile(download) as zf: - for member in zf.infolist(): - if not os.path.isfile(os.path.join(tmpdir, member.filename)): + # Iterate over each year + current_date = start_date + while current_date.replace(tzinfo=None) <= end_date.replace(tzinfo=None): + year = current_date.year + start_month = current_date.month if current_date.year == start_date.year else 1 + end_month = end_date.month if current_date.year == end_date.year else 12 + months = [f"{month:02d}" for month in range(start_month, end_month + 1)] + + # Define download file + download = os.path.join(tmpdir, f'cams_GHG_{year}_{start_date.strftime("%Y%m%d")}.zip') + if not os.path.isfile(download): + c.retrieve( + 'cams-global-greenhouse-gas-inversion', { + 'variable': 'carbon_dioxide', + 'quantity': 'concentration', + 'input_observations': 'surface', + 'time_aggregation': 'instantaneous', + 'version': 'latest', + 'year': str(year), + 'month': months, + 'format': 'zip', + }, + download) + logging.info(f'Downloaded CAMS data for year {year}!') + else: + logging.info(f'File already downloaded: {download}') + + # Unzip and process files + with zipfile.ZipFile(download) as zf: + for member in zf.infolist(): + date_str = member.filename.split('_')[-1].split('.')[0] + member.filename = f"CAMS_{date_str}_{start_date.strftime('%Y%m%d')}" + filename = os.path.join(tmpdir, member.filename) + # Extract only files within the date range + try: + if not os.path.isfile(filename): + zf.extract(member, tmpdir) + except Exception as e: + logging.warning(f"Skipping file {member.filename}: {e}") + # Extract individual dates try: - zf.extract(member, tmpdir) - except zipfile.error as e: - pass - - # --- Output files to folder - with zipfile.ZipFile(download) as zf: - for member in zf.infolist(): - filename = os.path.join(tmpdir, member.filename) - ds_CAMS = xr.open_dataset(filename) - for time in ds_CAMS.time: - outpath = os.path.join( - dir2move, 'cams_egg4_' + - ds_CAMS.sel(time=time).time.dt.strftime('%Y%m%d%H').values - + '.nc') - if not os.path.isfile(outpath): - logging.info("Writing out CAMS data to file") - ds_out = ds_CAMS.where(ds_CAMS.time == time, - drop=True).squeeze() - ds_out.to_netcdf(outpath) + ds_CAMS = xr.open_dataset(filename) + for time in ds_CAMS.time: + if np.datetime64(start_date) <= time.values <= np.datetime64(end_date): + outpath = os.path.join( + dir2move, 'cams_egg4_' + + np.datetime_as_string(time.values, unit='h').replace('-', '').replace(':', '') + + '.nc') + if not os.path.isfile(outpath): + logging.info(f"Writing CAMS data to {outpath}") + ds_out = ds_CAMS.sel(time=time, drop=True).squeeze() + ds_out.to_netcdf(outpath) + except Exception as e: + logging.warning(f"Error processing file {filename}: {e}") + + # Move to the next year + current_date = datetime(year + 1, 1, 1) + + logging.info("Finished processing CAMS data.") def fetch_ICOS_data(cookie_token, @@ -525,7 +523,6 @@ def extract_obs_column(file): 'author':'Processing Chain' } - # Create xarray dataset ds_extracted_obs_matrix = xr.Dataset( data_vars=data_vars, @@ -717,7 +714,6 @@ def process_OCO2_data(OCO2_obs_folder, # # Process files for day in iter_hours(start_date, end_date, 24): - # Gather files logging.info(f"Looking in folder {OCO2_obs_folder} for ICOS observation files with glob OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4") file = list(Path(OCO2_obs_folder).glob(f"OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4")) @@ -730,11 +726,6 @@ def process_OCO2_data(OCO2_obs_folder, # Open file s5p_data = xr.open_dataset(file[0]) - - # Process the 'time' variable: convert format, convert shape - # pressure_levels (rename, reverse direction), pressure_weight (rename, reverse, select) - # co2_profile_apriori (rename, reverse, select), xco2_apriori (rename, select) - # xco2_uncertainty (rename, select) s5p_out = s5p_data[["latitude", "longitude", "date", "xco2", "xco2_quality_flag", "xco2_averaging_kernel", "pressure_levels", "pressure_levels", "pressure_weight", "co2_profile_apriori", "xco2_apriori", From 9e6e71994b2076a06a7607ad5205d32345fc1f1b Mon Sep 17 00:00:00 2001 From: github-actions Date: Wed, 18 Dec 2024 10:14:15 +0000 Subject: [PATCH 25/42] GitHub Action: Apply Pep8-formatting --- config.py | 5 +- jobs/prepare_CTDAS.py | 210 +++++++++++++++++++----------- jobs/tools/ctdas_utilities.py | 85 ++++++------ jobs/tools/fetch_external_data.py | 80 +++++++----- 4 files changed, 223 insertions(+), 157 deletions(-) diff --git a/config.py b/config.py index f4257604..4094edbb 100644 --- a/config.py +++ b/config.py @@ -602,8 +602,9 @@ def get_previous_slurm_summary(self, for job_id in self.job_ids['previous'][job_name]: self.slurm_info[job_name] = [] self.slurm_info[job_name].append( - self.get_job_info(job_id, slurm_keys=info_keys, - parse=True)) + self.get_job_info(job_id, + slurm_keys=info_keys, + parse=True)) def print_previous_slurm_summary(self): # Width of printed slurm piece of information diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index 62ac64dc..290cb016 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -7,7 +7,7 @@ import shutil import subprocess from . import tools, prepare_icon -from .tools.fetch_external_data import fetch_era5, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2_data, process_ICOS_data, process_OCO2_data +from .tools.fetch_external_data import fetch_era5, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2_data, process_ICOS_data, process_OCO2_data from .tools.ctdas_utilities import create_lambda_regions, create_prior_all_ones, create_boundary_regions, create_boundary_prior_all_onesll_ones from concurrent.futures import ThreadPoolExecutor, as_completed from datetime import timedelta @@ -44,9 +44,8 @@ def main(cfg): if cfg.chem_fetch_CAMS: CAMS_folder = cfg.case_root / "global_inputs" / "CAMS" tools.create_dir(CAMS_folder, "CAMS input files") - fetch_CAMS_CO2( - cfg.startdate_sim, (cfg.enddate_sim+timedelta(days=1)), CAMS_folder - ) + fetch_CAMS_CO2(cfg.startdate_sim, + (cfg.enddate_sim + timedelta(days=1)), CAMS_folder) # -- 2. Fetch *all* ERA5 data (not just for initial conditions) if cfg.meteo_fetch_era5: @@ -54,23 +53,39 @@ def main(cfg): tools.create_dir(ERA5_folder, "CAMS input files") times = list( - tools.iter_hours(cfg.startdate_sim, (cfg.enddate_sim+timedelta(days=1)), + tools.iter_hours(cfg.startdate_sim, + (cfg.enddate_sim + timedelta(days=1)), cfg.meteo_nudging_step)) logging.info(f"Time range considered here: {times}") - file_list = [f"era5_ml_{(cfg.startdate_sim + timedelta(hours=i)).replace(tzinfo=None).isoformat()}.nc" - for i in range(0, int((cfg.enddate_sim - cfg.startdate_sim).total_seconds() // 3600) + 1, cfg.meteo_nudging_step)] - file_list+= [f"era5_surf_{(cfg.startdate_sim + timedelta(hours=i)).replace(tzinfo=None).isoformat()}.nc" - for i in range(0, int((cfg.enddate_sim - cfg.startdate_sim).total_seconds() // 3600) + 1, cfg.meteo_nudging_step)] - missing_files = [file for file in file_list if not (ERA5_folder / file).exists()] + file_list = [ + f"era5_ml_{(cfg.startdate_sim + timedelta(hours=i)).replace(tzinfo=None).isoformat()}.nc" + for i in range( + 0, + int((cfg.enddate_sim - cfg.startdate_sim).total_seconds() // + 3600) + 1, cfg.meteo_nudging_step) + ] + file_list += [ + f"era5_surf_{(cfg.startdate_sim + timedelta(hours=i)).replace(tzinfo=None).isoformat()}.nc" + for i in range( + 0, + int((cfg.enddate_sim - cfg.startdate_sim).total_seconds() // + 3600) + 1, cfg.meteo_nudging_step) + ] + missing_files = [ + file for file in file_list if not (ERA5_folder / file).exists() + ] if not missing_files: logging.info("All model level files already present") else: logging.info(f"Missing files: {missing_files}") # Split downloads in 3-day chunks, but run simultaneously N = 3 - chunks = list(tools.split_into_chunks(times, N, cfg.meteo_nudging_step)) - logging.info(f"Time range split up into chunks of {N} days, giving the following chunks: {chunks}") + chunks = list( + tools.split_into_chunks(times, N, cfg.meteo_nudging_step)) + logging.info( + f"Time range split up into chunks of {N} days, giving the following chunks: {chunks}" + ) # Run fetch_era5 in parallel over chunks output_filenames = [None] * len( @@ -124,40 +139,50 @@ def main(cfg): era5_ml_file = ERA5_folder / f"era5_ml_{datestr}.nc" era5_surf_file = ERA5_folder / f"era5_surf_{datestr}.nc" era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob - era5_ini_job = ERA5_folder / (era5_ini_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + era5_ini_template.suffix) + era5_ini_job = ERA5_folder / (era5_ini_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + era5_ini_template.suffix) with open(era5_ini_template, 'r') as infile, open(era5_ini_job, - 'w') as outfile: + 'w') as outfile: outfile.write(infile.read().format(cfg=cfg, - era5_ml_file=era5_ml_file, - era5_surf_file=era5_surf_file, - inicond_filename=era5_ini_file, - ERA5_folder=ERA5_folder)) + era5_ml_file=era5_ml_file, + era5_surf_file=era5_surf_file, + inicond_filename=era5_ini_file, + ERA5_folder=ERA5_folder)) shutil.copy(cfg.case_path / cfg.meteo_partab, ERA5_folder / 'mypartab') logging.info(f"Running ERA5 initial conditions script {era5_ini_job}") - subprocess.run(["bash", era5_ini_job], check=True, stdout=subprocess.PIPE) + subprocess.run(["bash", era5_ini_job], + check=True, + stdout=subprocess.PIPE) # --- CAMS inicond logging.info("Preparing CAMS initial conditions script for ICON") cams_ini_template = cfg.case_path / cfg.chem_cams_inijob - cams_ini_job = ERA5_folder / (cams_ini_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + cams_ini_template.suffix) + cams_ini_job = ERA5_folder / (cams_ini_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + cams_ini_template.suffix) with open(cams_ini_template, 'r') as infile, open(cams_ini_job, - 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - inicond_filename=era5_ini_file, - ERA5_folder=ERA5_folder, - CAMS_file=CAMS_folder / f'cams_egg4_{cfg.startdate_sim.strftime("%Y%m%d%H")}.nc', - era5_cams_ini_file=era5_ini_file)) + 'w') as outfile: + outfile.write(infile.read().format( + cfg=cfg, + inicond_filename=era5_ini_file, + ERA5_folder=ERA5_folder, + CAMS_file=CAMS_folder / + f'cams_egg4_{cfg.startdate_sim.strftime("%Y%m%d%H")}.nc', + era5_cams_ini_file=era5_ini_file)) logging.info(f"Running CAMS initial conditions script {cams_ini_job}") - subprocess.run(["bash", cams_ini_job], check=True, stdout=subprocess.PIPE) + subprocess.run(["bash", cams_ini_job], + check=True, + stdout=subprocess.PIPE) # -- 4. Interpolate CAMS to ERA5 3D grid if cfg.meteo_interpolate_CAMS_to_ERA5: for time in tools.iter_hours(cfg.startdate_sim, - (cfg.enddate_sim+timedelta(days=1)), + (cfg.enddate_sim + timedelta(days=1)), step=cfg.meteo_nudging_step): # -- Give a name to the nudging file datestr = time.strftime("%Y-%m-%dT%H:%M:%S") - datestr2= time.strftime("%Y%m%d%H") + datestr2 = time.strftime("%Y%m%d%H") era5_nudge_file_final = cfg.icon_input_icbc / f"era5_nudge_{datestr2}.nc" if not era5_nudge_file_final.exists(): era5_ml_file = ERA5_folder / f"era5_ml_{datestr}.nc" @@ -167,13 +192,14 @@ def main(cfg): # -- Copy ERA5 processing script (icon_era5_nudging.job) in workdir nudging_template = cfg.case_path / cfg.meteo_era5_nudgingjob nudging_job = ERA5_folder / f'icon_era5_nudging_{datestr}.sh' - with open(nudging_template, 'r') as infile, open(nudging_job, - 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - era5_ml_file=era5_ml_file, - era5_surf_file=era5_surf_file, - filename=era5_nudge_file, - ERA5_folder=ERA5_folder)) + with open(nudging_template, + 'r') as infile, open(nudging_job, 'w') as outfile: + outfile.write(infile.read().format( + cfg=cfg, + era5_ml_file=era5_ml_file, + era5_surf_file=era5_surf_file, + filename=era5_nudge_file, + ERA5_folder=ERA5_folder)) # -- Copy mypartab into workdir if not os.path.exists(ERA5_folder / 'mypartab'): @@ -182,30 +208,39 @@ def main(cfg): # -- Run ERA5 processing script subprocess.run(["bash", nudging_job], - check=True, - stdout=subprocess.PIPE) + check=True, + stdout=subprocess.PIPE) # -- Copy CAMS processing script (icon_cams_nudging.job) into workdir - logging.info("Preparing CAMS preprocessing nudging script for ICON") + logging.info( + "Preparing CAMS preprocessing nudging script for ICON") cams_nudge_template = cfg.case_path / cfg.chem_cams_nudgingjob - cams_nudge_job = ERA5_folder / (cams_nudge_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + cams_nudge_template.suffix) - with open(cams_nudge_template, 'r') as infile, open(cams_nudge_job, - 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - filename=era5_nudge_file, - ERA5_folder=ERA5_folder, - CAMS_file=CAMS_folder / f'cams_egg4_{time.strftime("%Y%m%d%H")}.nc', - era5_cams_nudge_file=era5_nudge_file_final, - )) - subprocess.run(["bash", cams_nudge_job], check=True, stdout=subprocess.PIPE) + cams_nudge_job = ERA5_folder / ( + cams_nudge_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + cams_nudge_template.suffix) + with open(cams_nudge_template, + 'r') as infile, open(cams_nudge_job, 'w') as outfile: + outfile.write(infile.read().format( + cfg=cfg, + filename=era5_nudge_file, + ERA5_folder=ERA5_folder, + CAMS_file=CAMS_folder / + f'cams_egg4_{time.strftime("%Y%m%d%H")}.nc', + era5_cams_nudge_file=era5_nudge_file_final, + )) + subprocess.run(["bash", cams_nudge_job], + check=True, + stdout=subprocess.PIPE) # -- 5. Download ICOS CO2 data - # Lots of potential for 'dehardcoding' things here, but that has to be done with - # a lot of care. + # Lots of potential for 'dehardcoding' things here, but that has to be done with + # a lot of care. if cfg.CTDAS_obs_fetch_ICOS: fetch_ICOS_data(cookie_token=cfg.CTDAS_obs_ICOS_cookie_token, start_date=cfg.startdate_sim.strftime("%d-%m-%Y"), - end_date=(cfg.enddate_sim+timedelta(days=1)).strftime("%d-%m-%Y"), + end_date=(cfg.enddate_sim + + timedelta(days=1)).strftime("%d-%m-%Y"), save_path=cfg.CTDAS_obs_ICOS_path, species=[ 'co2', @@ -214,9 +249,9 @@ def main(cfg): "ICOS input files") process_ICOS_data(ICOS_obs_folder=cfg.CTDAS_obs_ICOS_path, start_date=cfg.startdate_sim, - end_date=cfg.enddate_sim+timedelta(days=1), - output_folder=cfg.case_root / "global_inputs" / "ICOS" - ) + end_date=cfg.enddate_sim + timedelta(days=1), + output_folder=cfg.case_root / "global_inputs" / + "ICOS") # -- 6. Download OCO2 data if cfg.CTDAS_obs_fetch_OCO2: @@ -240,18 +275,20 @@ def main(cfg): # file.close() # Popen('chmod og-rw ~/.netrc', shell=True) fetch_OCO2_data(cfg.startdate_sim, - (cfg.enddate_sim+timedelta(days=1)), - -8, - 30, - 35, - 65, - cfg.CTDAS_obs_OCO2_path, - product="OCO2_L2_Lite_FP_11.1r") - tools.create_dir(cfg.case_root / "global_inputs" / "OCO2", "OCO-2 output") + (cfg.enddate_sim + timedelta(days=1)), + -8, + 30, + 35, + 65, + cfg.CTDAS_obs_OCO2_path, + product="OCO2_L2_Lite_FP_11.1r") + tools.create_dir(cfg.case_root / "global_inputs" / "OCO2", + "OCO-2 output") process_OCO2_data(OCO2_obs_folder=cfg.CTDAS_obs_OCO2_path, start_date=cfg.startdate_sim, - end_date=(cfg.enddate_sim+timedelta(days=1)), - output_folder=cfg.case_root / "global_inputs" / "OCO2") # post-process all the OCO2 data + end_date=(cfg.enddate_sim + timedelta(days=1)), + output_folder=cfg.case_root / "global_inputs" / + "OCO2") # post-process all the OCO2 data # -- 7. Create the required folder structure # For the ICON runs @@ -260,7 +297,8 @@ def main(cfg): tools.create_dir(cfg.icon_base / "output_opt_twice", "2 times optimized") # For the sampling - tools.create_dir(cfg.case_root / "global_output" / "extracted_ICOS", "Output of the extraction script") + tools.create_dir(cfg.case_root / "global_output" / "extracted_ICOS", + "Output of the extraction script") # -- 8. Initialize the first one-day run, only for the first lag if cfg.startdate_sim == cfg.startdate: @@ -274,7 +312,8 @@ def main(cfg): '#SBATCH --time=00:10:00', f'#SBATCH --partition={cfg.compute_queue}', f'#SBATCH --constraint={cfg.constraint}', '#SBATCH --nodes=1', - f'#SBATCH --output={cfg.logfile}', '#SBATCH --open-mode=append', + f'#SBATCH --output={cfg.logfile}', + '#SBATCH --open-mode=append', f'#SBATCH --chdir={cfg.icon_work}', '' ] elif cfg.machine == 'euler': @@ -284,29 +323,45 @@ def main(cfg): '#SBATCH --time=00:10:00', f'#SBATCH --partition={cfg.compute_queue}', f'#SBATCH --constraint={cfg.constraint}', '#SBATCH --ntasks=1', - f'#SBATCH --output={cfg.logfile}', '#SBATCH --open-mode=append', + f'#SBATCH --output={cfg.logfile}', + '#SBATCH --open-mode=append', f'#SBATCH --chdir={cfg.icon_work}', '' ] for category in cfg.CTDAS_global_inputs: - tools.create_dir(cat_folder := cfg.case_root / "global_inputs" / category, category) + tools.create_dir( + cat_folder := cfg.case_root / "global_inputs" / category, + category) for file in category: source = (p := Path(file)) destination = cat_folder / p.name script_lines.append(f'rsync -av {source} {destination}') - with (script := cfg.icon_work / 'copy_global_inputs.job').open('w') as f: - f.write('\n'.join(script_lines)) + with (script := + cfg.icon_work / 'copy_global_inputs.job').open('w') as f: + f.write('\n'.join(script_lines)) cfg.submit('global_inputs', script) # -- 8.2 Create the ensemble data for the first day - tools.create_dir(OEM_folder := cfg.case_root / "global_inputs" / "OEM", "OEM") - lambdas = [int(item) for line in cfg.CTDAS_lambdas for item in line.split(',')] + tools.create_dir(OEM_folder := cfg.case_root / "global_inputs" / "OEM", + "OEM") + lambdas = [ + int(item) for line in cfg.CTDAS_lambdas for item in line.split(',') + ] if cfg.CTDAS_regions == 'basegrid': - nregs, ncats = create_lambda_regions(cfg.input_files_dynamics_grid_filename, OEM_folder / "lambdaregions.nc", lambdas) - create_prior_all_ones(OEM_folder / "prior_all_ones.nc", nensembles=cfg.CTDAS_nensembles, ncats=lambdas.max(), nregs=nregs) + nregs, ncats = create_lambda_regions( + cfg.input_files_dynamics_grid_filename, + OEM_folder / "lambdaregions.nc", lambdas) + create_prior_all_ones(OEM_folder / "prior_all_ones.nc", + nensembles=cfg.CTDAS_nensembles, + ncats=lambdas.max(), + nregs=nregs) else: raise NotImplementedError('Only basegrid is implemented for now') - create_boundary_regions('/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc', '/scratch/snx3000/ekoene/boundary_mask_bg.nc') - create_boundary_prior_all_onesll_ones('/scratch/snx3000/ekoene/boundary_lambdas_bg.nc', nensembles=cfg.CTDAS_nensembles) + create_boundary_regions( + '/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc', + '/scratch/snx3000/ekoene/boundary_mask_bg.nc') + create_boundary_prior_all_onesll_ones( + '/scratch/snx3000/ekoene/boundary_lambdas_bg.nc', + nensembles=cfg.CTDAS_nensembles) # Create a folder an `nlag` period earlier / icon / output_opt_twice @@ -328,6 +383,5 @@ def main(cfg): # logging.info(f"Running ERA5 splitting script {era5_split_job}") # subprocess.run(["bash", era5_split_job], check=True, stdout=subprocess.PIPE) - logging.info("OK") shutil.copy(cfg.logfile, cfg.logfile_finish) diff --git a/jobs/tools/ctdas_utilities.py b/jobs/tools/ctdas_utilities.py index 6e150fee..e779afa9 100644 --- a/jobs/tools/ctdas_utilities.py +++ b/jobs/tools/ctdas_utilities.py @@ -2,7 +2,6 @@ import numpy as np import subprocess - import xarray as xr import numpy as np import subprocess @@ -20,21 +19,25 @@ def create_lambda_regions(input_grid, output_path, lambdas_ids): cells = np.arange(ncells) + 1 # Create dataset - ds_cells = xr.Dataset( - data_vars={ - 'REG': (['cell'], regions), - 'Lambda_indicies': (['cat'], lambdas_ids) - }, - coords={ - 'cell': (['cell'], cells), - 'cat': (['cat'], categories) - }, - attrs={ - 'author': 'Processing Chain' - } - ) - - ds_cells.to_netcdf(output_path, encoding={'REG': {'dtype': 'int32'}, 'cell': {'dtype': 'int32'}}) + ds_cells = xr.Dataset(data_vars={ + 'REG': (['cell'], regions), + 'Lambda_indicies': (['cat'], lambdas_ids) + }, + coords={ + 'cell': (['cell'], cells), + 'cat': (['cat'], categories) + }, + attrs={'author': 'Processing Chain'}) + + ds_cells.to_netcdf(output_path, + encoding={ + 'REG': { + 'dtype': 'int32' + }, + 'cell': { + 'dtype': 'int32' + } + }) print(f"Lambda regions saved to {output_path}") return nregs, categories[-1] @@ -90,20 +93,18 @@ def create_boundary_regions(grid_filename, output_path): elif lon < 0 and lat > 0: boundary_regions[i][0 if abs(lon) > lat else 1] = 1 - ds_boundary = xr.Dataset( - data_vars={ - 'boundaryregion': (['cell', 'reg'], boundary_regions), - 'global_cell_idx': (['cell'], np.arange(len(clon))) - }, - coords={ - 'cell': (['cell'], np.arange(len(clon))), - 'reg': (['reg'], np.arange(8)) - }, - attrs={ - 'author': 'Erik Koene', - 'email': 'erik.koene@empa.ch' - } - ) + ds_boundary = xr.Dataset(data_vars={ + 'boundaryregion': (['cell', 'reg'], boundary_regions), + 'global_cell_idx': (['cell'], np.arange(len(clon))) + }, + coords={ + 'cell': (['cell'], np.arange(len(clon))), + 'reg': (['reg'], np.arange(8)) + }, + attrs={ + 'author': 'Erik Koene', + 'email': 'erik.koene@empa.ch' + }) ds_boundary.to_netcdf(output_path) print(f"Boundary regions saved to {output_path}") @@ -112,20 +113,16 @@ def create_boundary_prior_all_onesll_ones(output_path, nensembles): """ Create boundary lambdas dataset and save to NetCDF. """ - lambdas = np.ones((nensembles,8), dtype=np.float32) - ds_lambdas = xr.Dataset( - data_vars={ - 'lambda': (['ens', 'reg'], lambdas) - }, - coords={ - 'ens': (['ens'], np.arange(nensembles)), - 'reg': (['reg'], np.arange(8)) - }, - attrs={ - 'author': 'Erik Koene', - 'email': 'erik.koene@empa.ch' - } - ) + lambdas = np.ones((nensembles, 8), dtype=np.float32) + ds_lambdas = xr.Dataset(data_vars={'lambda': (['ens', 'reg'], lambdas)}, + coords={ + 'ens': (['ens'], np.arange(nensembles)), + 'reg': (['reg'], np.arange(8)) + }, + attrs={ + 'author': 'Erik Koene', + 'email': 'erik.koene@empa.ch' + }) ds_lambdas.to_netcdf(output_path) print(f"Boundary lambdas saved to {output_path}") diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 9998df94..02881248 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -197,13 +197,16 @@ def fetch_CAMS_CO2(start_date, end_date, dir2move): year = current_date.year start_month = current_date.month if current_date.year == start_date.year else 1 end_month = end_date.month if current_date.year == end_date.year else 12 - months = [f"{month:02d}" for month in range(start_month, end_month + 1)] + months = [ + f"{month:02d}" for month in range(start_month, end_month + 1) + ] # Define download file - download = os.path.join(tmpdir, f'cams_GHG_{year}_{start_date.strftime("%Y%m%d")}.zip') + download = os.path.join( + tmpdir, f'cams_GHG_{year}_{start_date.strftime("%Y%m%d")}.zip') if not os.path.isfile(download): c.retrieve( - 'cams-global-greenhouse-gas-inversion', { + 'cams-global-greenhouse-gas-inversion', { 'variable': 'carbon_dioxide', 'quantity': 'concentration', 'input_observations': 'surface', @@ -212,8 +215,7 @@ def fetch_CAMS_CO2(start_date, end_date, dir2move): 'year': str(year), 'month': months, 'format': 'zip', - }, - download) + }, download) logging.info(f'Downloaded CAMS data for year {year}!') else: logging.info(f'File already downloaded: {download}') @@ -234,14 +236,17 @@ def fetch_CAMS_CO2(start_date, end_date, dir2move): try: ds_CAMS = xr.open_dataset(filename) for time in ds_CAMS.time: - if np.datetime64(start_date) <= time.values <= np.datetime64(end_date): + if np.datetime64( + start_date) <= time.values <= np.datetime64( + end_date): outpath = os.path.join( - dir2move, 'cams_egg4_' + - np.datetime_as_string(time.values, unit='h').replace('-', '').replace(':', '') + - '.nc') + dir2move, 'cams_egg4_' + np.datetime_as_string( + time.values, unit='h').replace( + '-', '').replace(':', '') + '.nc') if not os.path.isfile(outpath): logging.info(f"Writing CAMS data to {outpath}") - ds_out = ds_CAMS.sel(time=time, drop=True).squeeze() + ds_out = ds_CAMS.sel(time=time, + drop=True).squeeze() ds_out.to_netcdf(outpath) except Exception as e: logging.warning(f"Error processing file {filename}: {e}") @@ -367,7 +372,7 @@ def fetch_ICOS_data(cookie_token, ds.to_netcdf(os.path.join(save_path, name)) -def process_ICOS_data(ICOS_obs_folder, +def process_ICOS_data(ICOS_obs_folder, start_date='01-01-2022', end_date='31-12-2022', output_folder='~/'): @@ -386,8 +391,7 @@ def process_ICOS_data(ICOS_obs_folder, lat_lims = [40.9, 58.7] # Utility for converting units to PPMv - toppm_dict = {'nmol mol-1':1e-9*1e6, - 'µmol mol-1':1e-6*1e6} + toppm_dict = {'nmol mol-1': 1e-9 * 1e6, 'µmol mol-1': 1e-6 * 1e6} # Gather chosen dates delta = end_date - start_date @@ -440,8 +444,9 @@ def extract_obs_column(file): # Filter dataset to the desired time range ds['time'] = ds['time'] - ds_filtered = ds.sel(time=slice(start_date.replace(tzinfo=None), end_date.replace(tzinfo=None))) - + ds_filtered = ds.sel(time=slice(start_date.replace( + tzinfo=None), end_date.replace(tzinfo=None))) + # Align `chosen_dates` with `ds_filtered.time` ds_aligned = ds_filtered.reindex(time=chosen_dates, method='nearest', @@ -558,7 +563,9 @@ def extract_obs_column(file): attrs=attrs) # Save dataset to file - output_filename = Path(output_folder) / f"Extracted_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}_alldates_masl.nc" + output_filename = Path( + output_folder + ) / f"Extracted_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}_alldates_masl.nc" ds_extracted_obs_matrix.to_netcdf(output_filename) logging.info( @@ -763,22 +770,28 @@ def process_OCO2_data(OCO2_obs_folder, # Open file s5p_data = xr.open_dataset(file[0]) - s5p_out = s5p_data[["latitude", "longitude", "date", - "xco2", "xco2_quality_flag", "xco2_averaging_kernel", "pressure_levels", - "pressure_levels", "pressure_weight", "co2_profile_apriori", "xco2_apriori", - "xco2_uncertainty" ]] - s5p_out = s5p_out.rename({"levels": "layers", - "sounding_id": "soundings", - "xco2": "obs", - "xco2_quality_flag": "quality_flag", - "xco2_averaging_kernel": "averaging_kernel", - "pressure_weight": "pressure_weighting_function", - "co2_profile_apriori": "prior_profile", - "xco2_apriori": "prior", - "xco2_uncertainty": "uncertainty"}) - s5p_out["pressure_levels"] = s5p_out.pressure_levels[:,::-1] - s5p_out["pressure_weighting_function"] = s5p_out.pressure_weighting_function[:,::-1] - s5p_out["surface_pressure"] = s5p_out.pressure_levels[:,0] + s5p_out = s5p_data[[ + "latitude", "longitude", "date", "xco2", "xco2_quality_flag", + "xco2_averaging_kernel", "pressure_levels", "pressure_levels", + "pressure_weight", "co2_profile_apriori", "xco2_apriori", + "xco2_uncertainty" + ]] + s5p_out = s5p_out.rename({ + "levels": "layers", + "sounding_id": "soundings", + "xco2": "obs", + "xco2_quality_flag": "quality_flag", + "xco2_averaging_kernel": "averaging_kernel", + "pressure_weight": "pressure_weighting_function", + "co2_profile_apriori": "prior_profile", + "xco2_apriori": "prior", + "xco2_uncertainty": "uncertainty" + }) + s5p_out["pressure_levels"] = s5p_out.pressure_levels[:, ::-1] + s5p_out[ + "pressure_weighting_function"] = s5p_out.pressure_weighting_function[:, :: + -1] + s5p_out["surface_pressure"] = s5p_out.pressure_levels[:, 0] # Process the 'time' variable: convert format, convert shape # pressure_levels (rename, reverse direction), pressure_weight (rename, reverse, select) @@ -812,4 +825,5 @@ def process_OCO2_data(OCO2_obs_folder, 'level_def': 'pressure_boundaries', 'retrieval_id': file[0].name }) - s5p_out.to_netcdf(output_folder / f"OCO2_{day.strftime('%Y%m%d')}_ctdas.nc") \ No newline at end of file + s5p_out.to_netcdf(output_folder / + f"OCO2_{day.strftime('%Y%m%d')}_ctdas.nc") From 9f910a994a5333db678ed493b632cd47959088bc Mon Sep 17 00:00:00 2001 From: efkmoene Date: Wed, 18 Dec 2024 13:24:36 +0100 Subject: [PATCH 26/42] Fixed merging issue --- jobs/prepare_CTDAS.py | 287 +++++++++++------------------- jobs/tools/ctdas_utilities.py | 2 +- jobs/tools/fetch_external_data.py | 246 +++++++++---------------- 3 files changed, 193 insertions(+), 342 deletions(-) diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index 290cb016..6d32c4e2 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -7,8 +7,8 @@ import shutil import subprocess from . import tools, prepare_icon -from .tools.fetch_external_data import fetch_era5, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2_data, process_ICOS_data, process_OCO2_data -from .tools.ctdas_utilities import create_lambda_regions, create_prior_all_ones, create_boundary_regions, create_boundary_prior_all_onesll_ones +from .tools.fetch_external_data import fetch_era5, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2_data, process_ICOS_data, process_OCO2_data +from .tools.ctdas_utilities import create_lambda_regions, create_prior_all_ones, create_boundary_regions, create_boundary_prior_all_ones from concurrent.futures import ThreadPoolExecutor, as_completed from datetime import timedelta @@ -44,92 +44,61 @@ def main(cfg): if cfg.chem_fetch_CAMS: CAMS_folder = cfg.case_root / "global_inputs" / "CAMS" tools.create_dir(CAMS_folder, "CAMS input files") - fetch_CAMS_CO2(cfg.startdate_sim, - (cfg.enddate_sim + timedelta(days=1)), CAMS_folder) + fetch_CAMS_CO2( + cfg.startdate_sim, (cfg.enddate_sim+timedelta(days=1)), CAMS_folder + ) # -- 2. Fetch *all* ERA5 data (not just for initial conditions) if cfg.meteo_fetch_era5: ERA5_folder = cfg.case_root / "global_inputs" / "ERA5" tools.create_dir(ERA5_folder, "CAMS input files") - times = list( - tools.iter_hours(cfg.startdate_sim, - (cfg.enddate_sim + timedelta(days=1)), - cfg.meteo_nudging_step)) + times = list(tools.iter_hours(cfg.startdate_sim, (cfg.enddate_sim+timedelta(days=1)), cfg.meteo_nudging_step)) logging.info(f"Time range considered here: {times}") - file_list = [ - f"era5_ml_{(cfg.startdate_sim + timedelta(hours=i)).replace(tzinfo=None).isoformat()}.nc" - for i in range( - 0, - int((cfg.enddate_sim - cfg.startdate_sim).total_seconds() // - 3600) + 1, cfg.meteo_nudging_step) - ] - file_list += [ - f"era5_surf_{(cfg.startdate_sim + timedelta(hours=i)).replace(tzinfo=None).isoformat()}.nc" - for i in range( - 0, - int((cfg.enddate_sim - cfg.startdate_sim).total_seconds() // - 3600) + 1, cfg.meteo_nudging_step) - ] - missing_files = [ - file for file in file_list if not (ERA5_folder / file).exists() - ] + file_list = [f"era5_ml_{(cfg.startdate_sim + timedelta(hours=i)).replace(tzinfo=None).isoformat()}.nc" + for i in range(0, int((cfg.enddate_sim - cfg.startdate_sim).total_seconds() // 3600) + 1, cfg.meteo_nudging_step)] + file_list+= [f"era5_surf_{(cfg.startdate_sim + timedelta(hours=i)).replace(tzinfo=None).isoformat()}.nc" + for i in range(0, int((cfg.enddate_sim - cfg.startdate_sim).total_seconds() // 3600) + 1, cfg.meteo_nudging_step)] + missing_files = [file for file in file_list if not (ERA5_folder / file).exists()] if not missing_files: logging.info("All model level files already present") else: logging.info(f"Missing files: {missing_files}") # Split downloads in 3-day chunks, but run simultaneously N = 3 - chunks = list( - tools.split_into_chunks(times, N, cfg.meteo_nudging_step)) - logging.info( - f"Time range split up into chunks of {N} days, giving the following chunks: {chunks}" - ) + chunks = list(tools.split_into_chunks(times, N, cfg.meteo_nudging_step)) + logging.info(f"Time range split up into chunks of {N} days, giving the following chunks: {chunks}") - # Run fetch_era5 in parallel over chunks - output_filenames = [None] * len( - chunks) # Create a list to store filenames in order - with ThreadPoolExecutor(max_workers=4) as executor: - futures = { - executor.submit(fetch_era5, - chunk, - cfg.icon_input_icbc, - resolution=0.25, - area=[60, -15, 35, 20]): - i - for i, chunk in enumerate(chunks) - } - for future in futures: - index = futures[future] # Get the index of the future - try: - result = future.result() # Get the result from the future - output_filenames[ - index] = result # Store the returned filename(s) in the correct order - logging.info(f"Fetched data and saved to: {result}") - except Exception as exc: - logging.error(f"Generated an exception: {exc}") - logging.info(f"All fetched files: {output_filenames}") + # Run fetch_era5 in parallel over chunks + output_filenames = [None] * len(chunks) # Create a list to store filenames in order + with ThreadPoolExecutor(max_workers=4) as executor: + futures = {executor.submit(fetch_era5, chunk, ERA5_folder, resolution=0.25, area=[60, -15, 35, 20]): i for i, chunk in enumerate(chunks)} + for future in futures: + index = futures[future] # Get the index of the future + try: + result = future.result() # Get the result from the future + output_filenames[index] = result # Store the returned filename(s) in the correct order + logging.info(f"Fetched data and saved to: {result}") + except Exception as exc: + logging.error(f"Generated an exception: {exc}") + logging.info(f"All fetched files: {output_filenames}") - # Split files (with multiple days/times) into individual files using bash script - era5_split_template = cfg.case_path / cfg.meteo_era5_splitjob - era5_split_job = cfg.icon_input_icbc / cfg.meteo_era5_splitjob - logging.info( - f"Preparing ERA5 splitting script for ICON from {era5_split_template}" - ) - ml_files = " ".join( - [f"{filenames[0]}" for filenames in output_filenames]) - surf_files = " ".join( - [f"{filenames[1]}" for filenames in output_filenames]) - with open(era5_split_template, - 'r') as infile, open(era5_split_job, 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - ml_files=ml_files, - surf_files=surf_files)) - logging.info(f"Running ERA5 splitting script {era5_split_job}") - subprocess.run(["bash", era5_split_job], - check=True, - stdout=subprocess.PIPE) + # Split files (with multiple days/times) into individual files using bash script + era5_split_template = cfg.case_path / cfg.meteo_era5_splitjob + era5_split_job = ERA5_folder / (cfg.meteo_era5_splitjob.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + cfg.meteo_era5_splitjob.suffix) + logging.info(f"Preparing ERA5 splitting script for ICON from {era5_split_template}") + ml_files = " ".join([f"{filenames[0]}" for filenames in output_filenames]) + surf_files = " ".join([f"{filenames[1]}" for filenames in output_filenames]) + with open(era5_split_template, 'r') as infile, open(era5_split_job, 'w') as outfile: + outfile.write(infile.read().format( + cfg=cfg, + ml_files=ml_files, + surf_files=surf_files, + ERA5_folder=ERA5_folder + )) + logging.info(f"Running ERA5 splitting script {era5_split_job}") + subprocess.run(["bash", era5_split_job], check=True, stdout=subprocess.PIPE) # -- 3. Process initial conditions data using bash script datestr = cfg.startdate_sim.strftime("%Y-%m-%dT%H:%M:%S") @@ -139,50 +108,40 @@ def main(cfg): era5_ml_file = ERA5_folder / f"era5_ml_{datestr}.nc" era5_surf_file = ERA5_folder / f"era5_surf_{datestr}.nc" era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob - era5_ini_job = ERA5_folder / (era5_ini_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}' - + era5_ini_template.suffix) + era5_ini_job = ERA5_folder / (era5_ini_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + era5_ini_template.suffix) with open(era5_ini_template, 'r') as infile, open(era5_ini_job, - 'w') as outfile: + 'w') as outfile: outfile.write(infile.read().format(cfg=cfg, - era5_ml_file=era5_ml_file, - era5_surf_file=era5_surf_file, - inicond_filename=era5_ini_file, - ERA5_folder=ERA5_folder)) + era5_ml_file=era5_ml_file, + era5_surf_file=era5_surf_file, + inicond_filename=era5_ini_file, + ERA5_folder=ERA5_folder)) shutil.copy(cfg.case_path / cfg.meteo_partab, ERA5_folder / 'mypartab') logging.info(f"Running ERA5 initial conditions script {era5_ini_job}") - subprocess.run(["bash", era5_ini_job], - check=True, - stdout=subprocess.PIPE) + subprocess.run(["bash", era5_ini_job], check=True, stdout=subprocess.PIPE) # --- CAMS inicond logging.info("Preparing CAMS initial conditions script for ICON") cams_ini_template = cfg.case_path / cfg.chem_cams_inijob - cams_ini_job = ERA5_folder / (cams_ini_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}' - + cams_ini_template.suffix) + cams_ini_job = ERA5_folder / (cams_ini_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + cams_ini_template.suffix) with open(cams_ini_template, 'r') as infile, open(cams_ini_job, - 'w') as outfile: - outfile.write(infile.read().format( - cfg=cfg, - inicond_filename=era5_ini_file, - ERA5_folder=ERA5_folder, - CAMS_file=CAMS_folder / - f'cams_egg4_{cfg.startdate_sim.strftime("%Y%m%d%H")}.nc', - era5_cams_ini_file=era5_ini_file)) + 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + inicond_filename=era5_ini_file, + ERA5_folder=ERA5_folder, + CAMS_file=CAMS_folder / f'cams_egg4_{cfg.startdate_sim.strftime("%Y%m%d%H")}.nc', + era5_cams_ini_file=era5_ini_file)) logging.info(f"Running CAMS initial conditions script {cams_ini_job}") - subprocess.run(["bash", cams_ini_job], - check=True, - stdout=subprocess.PIPE) + subprocess.run(["bash", cams_ini_job], check=True, stdout=subprocess.PIPE) # -- 4. Interpolate CAMS to ERA5 3D grid if cfg.meteo_interpolate_CAMS_to_ERA5: for time in tools.iter_hours(cfg.startdate_sim, - (cfg.enddate_sim + timedelta(days=1)), + (cfg.enddate_sim+timedelta(days=1)), step=cfg.meteo_nudging_step): # -- Give a name to the nudging file datestr = time.strftime("%Y-%m-%dT%H:%M:%S") - datestr2 = time.strftime("%Y%m%d%H") + datestr2= time.strftime("%Y%m%d%H") era5_nudge_file_final = cfg.icon_input_icbc / f"era5_nudge_{datestr2}.nc" if not era5_nudge_file_final.exists(): era5_ml_file = ERA5_folder / f"era5_ml_{datestr}.nc" @@ -192,14 +151,13 @@ def main(cfg): # -- Copy ERA5 processing script (icon_era5_nudging.job) in workdir nudging_template = cfg.case_path / cfg.meteo_era5_nudgingjob nudging_job = ERA5_folder / f'icon_era5_nudging_{datestr}.sh' - with open(nudging_template, - 'r') as infile, open(nudging_job, 'w') as outfile: - outfile.write(infile.read().format( - cfg=cfg, - era5_ml_file=era5_ml_file, - era5_surf_file=era5_surf_file, - filename=era5_nudge_file, - ERA5_folder=ERA5_folder)) + with open(nudging_template, 'r') as infile, open(nudging_job, + 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + era5_ml_file=era5_ml_file, + era5_surf_file=era5_surf_file, + filename=era5_nudge_file, + ERA5_folder=ERA5_folder)) # -- Copy mypartab into workdir if not os.path.exists(ERA5_folder / 'mypartab'): @@ -208,50 +166,40 @@ def main(cfg): # -- Run ERA5 processing script subprocess.run(["bash", nudging_job], - check=True, - stdout=subprocess.PIPE) + check=True, + stdout=subprocess.PIPE) # -- Copy CAMS processing script (icon_cams_nudging.job) into workdir - logging.info( - "Preparing CAMS preprocessing nudging script for ICON") + logging.info("Preparing CAMS preprocessing nudging script for ICON") cams_nudge_template = cfg.case_path / cfg.chem_cams_nudgingjob - cams_nudge_job = ERA5_folder / ( - cams_nudge_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}' + - cams_nudge_template.suffix) - with open(cams_nudge_template, - 'r') as infile, open(cams_nudge_job, 'w') as outfile: - outfile.write(infile.read().format( - cfg=cfg, - filename=era5_nudge_file, - ERA5_folder=ERA5_folder, - CAMS_file=CAMS_folder / - f'cams_egg4_{time.strftime("%Y%m%d%H")}.nc', - era5_cams_nudge_file=era5_nudge_file_final, - )) - subprocess.run(["bash", cams_nudge_job], - check=True, - stdout=subprocess.PIPE) + cams_nudge_job = ERA5_folder / (cams_nudge_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + cams_nudge_template.suffix) + with open(cams_nudge_template, 'r') as infile, open(cams_nudge_job, + 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + filename=era5_nudge_file, + ERA5_folder=ERA5_folder, + CAMS_file=CAMS_folder / f'cams_egg4_{time.strftime("%Y%m%d%H")}.nc', + era5_cams_nudge_file=era5_nudge_file_final, + )) + subprocess.run(["bash", cams_nudge_job], check=True, stdout=subprocess.PIPE) # -- 5. Download ICOS CO2 data - # Lots of potential for 'dehardcoding' things here, but that has to be done with - # a lot of care. + # Lots of potential for 'dehardcoding' things here, but that has to be done with + # a lot of care. if cfg.CTDAS_obs_fetch_ICOS: fetch_ICOS_data(cookie_token=cfg.CTDAS_obs_ICOS_cookie_token, start_date=cfg.startdate_sim.strftime("%d-%m-%Y"), - end_date=(cfg.enddate_sim + - timedelta(days=1)).strftime("%d-%m-%Y"), + end_date=(cfg.enddate_sim+timedelta(days=1)).strftime("%d-%m-%Y"), save_path=cfg.CTDAS_obs_ICOS_path, species=[ 'co2', ]) - tools.create_dir(cfg.case_root / "global_inputs" / "ICOS", - "ICOS input files") + tools.create_dir(cfg.case_root / "global_inputs" / "ICOS", "ICOS input files") process_ICOS_data(ICOS_obs_folder=cfg.CTDAS_obs_ICOS_path, start_date=cfg.startdate_sim, - end_date=cfg.enddate_sim + timedelta(days=1), - output_folder=cfg.case_root / "global_inputs" / - "ICOS") + end_date=(cfg.enddate_sim+timedelta(days=1)), + output_folder=cfg.case_root / "global_inputs" / "ICOS" + ) # -- 6. Download OCO2 data if cfg.CTDAS_obs_fetch_OCO2: @@ -275,20 +223,18 @@ def main(cfg): # file.close() # Popen('chmod og-rw ~/.netrc', shell=True) fetch_OCO2_data(cfg.startdate_sim, - (cfg.enddate_sim + timedelta(days=1)), - -8, - 30, - 35, - 65, - cfg.CTDAS_obs_OCO2_path, - product="OCO2_L2_Lite_FP_11.1r") - tools.create_dir(cfg.case_root / "global_inputs" / "OCO2", - "OCO-2 output") + (cfg.enddate_sim+timedelta(days=1)), + -8, + 30, + 35, + 65, + cfg.CTDAS_obs_OCO2_path, + product="OCO2_L2_Lite_FP_11.1r") + tools.create_dir(cfg.case_root / "global_inputs" / "OCO2", "OCO-2 output") process_OCO2_data(OCO2_obs_folder=cfg.CTDAS_obs_OCO2_path, start_date=cfg.startdate_sim, - end_date=(cfg.enddate_sim + timedelta(days=1)), - output_folder=cfg.case_root / "global_inputs" / - "OCO2") # post-process all the OCO2 data + end_date=(cfg.enddate_sim+timedelta(days=1)), + output_folder=cfg.case_root / "global_inputs" / "OCO2") # post-process all the OCO2 data # -- 7. Create the required folder structure # For the ICON runs @@ -297,8 +243,7 @@ def main(cfg): tools.create_dir(cfg.icon_base / "output_opt_twice", "2 times optimized") # For the sampling - tools.create_dir(cfg.case_root / "global_output" / "extracted_ICOS", - "Output of the extraction script") + tools.create_dir(cfg.case_root / "global_output" / "extracted_ICOS", "Output of the extraction script") # -- 8. Initialize the first one-day run, only for the first lag if cfg.startdate_sim == cfg.startdate: @@ -312,8 +257,7 @@ def main(cfg): '#SBATCH --time=00:10:00', f'#SBATCH --partition={cfg.compute_queue}', f'#SBATCH --constraint={cfg.constraint}', '#SBATCH --nodes=1', - f'#SBATCH --output={cfg.logfile}', - '#SBATCH --open-mode=append', + f'#SBATCH --output={cfg.logfile}', '#SBATCH --open-mode=append', f'#SBATCH --chdir={cfg.icon_work}', '' ] elif cfg.machine == 'euler': @@ -323,45 +267,29 @@ def main(cfg): '#SBATCH --time=00:10:00', f'#SBATCH --partition={cfg.compute_queue}', f'#SBATCH --constraint={cfg.constraint}', '#SBATCH --ntasks=1', - f'#SBATCH --output={cfg.logfile}', - '#SBATCH --open-mode=append', + f'#SBATCH --output={cfg.logfile}', '#SBATCH --open-mode=append', f'#SBATCH --chdir={cfg.icon_work}', '' ] for category in cfg.CTDAS_global_inputs: - tools.create_dir( - cat_folder := cfg.case_root / "global_inputs" / category, - category) + tools.create_dir(cat_folder := cfg.case_root / "global_inputs" / category, category) for file in category: source = (p := Path(file)) destination = cat_folder / p.name script_lines.append(f'rsync -av {source} {destination}') - with (script := - cfg.icon_work / 'copy_global_inputs.job').open('w') as f: - f.write('\n'.join(script_lines)) + with (script := cfg.icon_work / 'copy_global_inputs.job').open('w') as f: + f.write('\n'.join(script_lines)) cfg.submit('global_inputs', script) # -- 8.2 Create the ensemble data for the first day - tools.create_dir(OEM_folder := cfg.case_root / "global_inputs" / "OEM", - "OEM") - lambdas = [ - int(item) for line in cfg.CTDAS_lambdas for item in line.split(',') - ] + tools.create_dir(OEM_folder := cfg.case_root / "global_inputs" / "OEM", "OEM") + lambdas = [int(item) for line in cfg.CTDAS_lambdas for item in line.split(',')] if cfg.CTDAS_regions == 'basegrid': - nregs, ncats = create_lambda_regions( - cfg.input_files_dynamics_grid_filename, - OEM_folder / "lambdaregions.nc", lambdas) - create_prior_all_ones(OEM_folder / "prior_all_ones.nc", - nensembles=cfg.CTDAS_nensembles, - ncats=lambdas.max(), - nregs=nregs) + nregs, ncats = create_lambda_regions(cfg.input_files_dynamics_grid_filename, OEM_folder / "lambdaregions.nc", lambdas) + create_prior_all_ones(OEM_folder / "prior_all_ones.nc", nensembles=cfg.CTDAS_nensembles, ncats=lambdas.max(), nregs=nregs) else: raise NotImplementedError('Only basegrid is implemented for now') - create_boundary_regions( - '/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc', - '/scratch/snx3000/ekoene/boundary_mask_bg.nc') - create_boundary_prior_all_onesll_ones( - '/scratch/snx3000/ekoene/boundary_lambdas_bg.nc', - nensembles=cfg.CTDAS_nensembles) + create_boundary_regions('/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc', '/scratch/snx3000/ekoene/boundary_mask_bg.nc') + create_boundary_prior_all_ones('/scratch/snx3000/ekoene/boundary_lambdas_bg.nc', nensembles=cfg.CTDAS_nensembles) # Create a folder an `nlag` period earlier / icon / output_opt_twice @@ -383,5 +311,6 @@ def main(cfg): # logging.info(f"Running ERA5 splitting script {era5_split_job}") # subprocess.run(["bash", era5_split_job], check=True, stdout=subprocess.PIPE) + logging.info("OK") shutil.copy(cfg.logfile, cfg.logfile_finish) diff --git a/jobs/tools/ctdas_utilities.py b/jobs/tools/ctdas_utilities.py index e779afa9..f1df6cee 100644 --- a/jobs/tools/ctdas_utilities.py +++ b/jobs/tools/ctdas_utilities.py @@ -109,7 +109,7 @@ def create_boundary_regions(grid_filename, output_path): print(f"Boundary regions saved to {output_path}") -def create_boundary_prior_all_onesll_ones(output_path, nensembles): +def create_boundary_prior_all_ones(output_path, nensembles): """ Create boundary lambdas dataset and save to NetCDF. """ diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 02881248..61ebe365 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -20,7 +20,6 @@ from concurrent.futures import ThreadPoolExecutor from . import iter_hours, create_dir - def fetch_CDS(product, date, levels, params, resolution, area, outloc): # Obtain CDS authentification from file url_cmd = f"grep 'cds' ~/.cdsapirc" @@ -197,16 +196,13 @@ def fetch_CAMS_CO2(start_date, end_date, dir2move): year = current_date.year start_month = current_date.month if current_date.year == start_date.year else 1 end_month = end_date.month if current_date.year == end_date.year else 12 - months = [ - f"{month:02d}" for month in range(start_month, end_month + 1) - ] + months = [f"{month:02d}" for month in range(start_month, end_month + 1)] # Define download file - download = os.path.join( - tmpdir, f'cams_GHG_{year}_{start_date.strftime("%Y%m%d")}.zip') + download = os.path.join(tmpdir, f'cams_GHG_{year}_{start_date.strftime("%Y%m%d")}.zip') if not os.path.isfile(download): c.retrieve( - 'cams-global-greenhouse-gas-inversion', { + 'cams-global-greenhouse-gas-inversion', { 'variable': 'carbon_dioxide', 'quantity': 'concentration', 'input_observations': 'surface', @@ -215,7 +211,8 @@ def fetch_CAMS_CO2(start_date, end_date, dir2move): 'year': str(year), 'month': months, 'format': 'zip', - }, download) + }, + download) logging.info(f'Downloaded CAMS data for year {year}!') else: logging.info(f'File already downloaded: {download}') @@ -236,17 +233,14 @@ def fetch_CAMS_CO2(start_date, end_date, dir2move): try: ds_CAMS = xr.open_dataset(filename) for time in ds_CAMS.time: - if np.datetime64( - start_date) <= time.values <= np.datetime64( - end_date): + if np.datetime64(start_date) <= time.values <= np.datetime64(end_date): outpath = os.path.join( - dir2move, 'cams_egg4_' + np.datetime_as_string( - time.values, unit='h').replace( - '-', '').replace(':', '') + '.nc') + dir2move, 'cams_egg4_' + + np.datetime_as_string(time.values, unit='h').replace('-', '').replace(':', '') + + '.nc') if not os.path.isfile(outpath): logging.info(f"Writing CAMS data to {outpath}") - ds_out = ds_CAMS.sel(time=time, - drop=True).squeeze() + ds_out = ds_CAMS.sel(time=time, drop=True).squeeze() ds_out.to_netcdf(outpath) except Exception as e: logging.warning(f"Error processing file {filename}: {e}") @@ -372,7 +366,7 @@ def fetch_ICOS_data(cookie_token, ds.to_netcdf(os.path.join(save_path, name)) -def process_ICOS_data(ICOS_obs_folder, +def process_ICOS_data(ICOS_obs_folder, start_date='01-01-2022', end_date='31-12-2022', output_folder='~/'): @@ -391,38 +385,29 @@ def process_ICOS_data(ICOS_obs_folder, lat_lims = [40.9, 58.7] # Utility for converting units to PPMv - toppm_dict = {'nmol mol-1': 1e-9 * 1e6, 'µmol mol-1': 1e-6 * 1e6} + toppm_dict = {'nmol mol-1':1e-9*1e6, + 'µmol mol-1':1e-6*1e6} # Gather chosen dates delta = end_date - start_date chosen_dates = [ - np.datetime64((start_date + timedelta( - days=i, hours=h)).strftime('%Y-%m-%dT%H:%M:%S.000000000')) - for i in range(delta.days + 1) for h in range(24) + np.datetime64((start_date + timedelta(days=i, hours=h)).strftime('%Y-%m-%dT%H:%M:%S.000000000')) + for i in range(delta.days + 1) + for h in range(24) ] number_of_hourly_measurements = len(chosen_dates) - logging.info( - f'A total of {number_of_hourly_measurements} hours are possible') + logging.info(f'A total of {number_of_hourly_measurements} hours are possible') # Gather files - logging.info( - f"Looking in folder {ICOS_obs_folder} for ICOS observation files with glob *{start_date.strftime('%d-%m-%Y')}_{end_date.strftime('%d-%m-%Y')}.nc" - ) - files = list( - Path(ICOS_obs_folder).glob( - f"*{start_date.strftime('%d-%m-%Y')}_{end_date.strftime('%d-%m-%Y')}.nc" - )) + logging.info(f"Looking in folder {ICOS_obs_folder} for ICOS observation files with glob *{start_date.strftime('%d-%m-%Y')}_{end_date.strftime('%d-%m-%Y')}.nc") + files = list(Path(ICOS_obs_folder).glob(f"*{start_date.strftime('%d-%m-%Y')}_{end_date.strftime('%d-%m-%Y')}.nc")) number_of_stations = len(files) logging.info(f'Will package data from {number_of_stations} files, {files}') # Prepare - obs_cnc_matrix = np.zeros( - (number_of_stations, number_of_hourly_measurements), dtype=np.float64) - obs_dates_matrix = np.zeros( - (number_of_stations, number_of_hourly_measurements), - dtype=np.dtype('datetime64[ns]')) - obs_std_matrix = np.zeros( - (number_of_stations, number_of_hourly_measurements), dtype=np.float64) + obs_cnc_matrix = np.zeros((number_of_stations, number_of_hourly_measurements), dtype=np.float64) + obs_dates_matrix = np.zeros((number_of_stations, number_of_hourly_measurements), dtype = np.dtype('datetime64[ns]')) + obs_std_matrix = np.zeros((number_of_stations, number_of_hourly_measurements), dtype=np.float64) # Set-up a function that can be called in parallel def extract_obs_column(file): @@ -434,43 +419,31 @@ def extract_obs_column(file): id_st = ds.attrs['Station'] units = ds.attrs['Units'] masl = ds.attrs['Elevation above sea level'] - diff = (ds.time.values[1] - ds.time.values[0] - ) / 3600000000000 # Time difference in hours - + diff = (ds.time.values[1] - ds.time.values[0]) / 3600000000000 # Time difference in hours + if diff != 1: - logging.info( - f'Observation data at station {name} is not hourly averaged ({diff} hours)' - ) - + logging.info(f'Observation data at station {name} is not hourly averaged ({diff} hours)') + # Filter dataset to the desired time range ds['time'] = ds['time'] - ds_filtered = ds.sel(time=slice(start_date.replace( - tzinfo=None), end_date.replace(tzinfo=None))) - + ds_filtered = ds.sel(time=slice(start_date.replace(tzinfo=None), end_date.replace(tzinfo=None))) + # Align `chosen_dates` with `ds_filtered.time` - ds_aligned = ds_filtered.reindex(time=chosen_dates, - method='nearest', - tolerance='1h') - + ds_aligned = ds_filtered.reindex(time=chosen_dates, method='nearest', tolerance='1h') + # Update observation arrays obs_dates1 = ds_aligned.time.values obs_std1 = ds_aligned.Stdev.values * toppm_dict[units] obs_cnc1 = ds_aligned["co2"].values * toppm_dict[units] lons, lats = ds.attrs['Longitude'], ds.attrs['Latitude'] - + except Exception as e: logging.info(f"Error processing file {file}: {e}") - obs_cnc1 = np.full(number_of_hourly_measurements, - np.nan, - dtype=np.float64) - obs_dates1 = np.full(number_of_hourly_measurements, - np.datetime64("NaT"), - dtype="datetime64[ns]") - obs_std1 = np.full(number_of_hourly_measurements, - np.nan, - dtype=np.float64) + obs_cnc1 = np.full(number_of_hourly_measurements, np.nan, dtype=np.float64) + obs_dates1 = np.full(number_of_hourly_measurements, np.datetime64("NaT"), dtype="datetime64[ns]") + obs_std1 = np.full(number_of_hourly_measurements, np.nan, dtype=np.float64) name, id_st, masl, lons, lats = 'nan', 0, -999, np.nan, np.nan - + return name, obs_std1, obs_cnc1, obs_dates1, lons, lats, id_st, masl # Process all data concurrently @@ -492,10 +465,8 @@ def extract_obs_column(file): mask_true = np.full_like(obs_cnc_matrix[0], True) # Filter and populate matrices - for ix, (lon, lat, cnc, std, times) in enumerate( - zip(obs_lons, obs_lats, obs_cnc, obs_std, obs_times)): - if any(np.isfinite(cnc)) and (lon_lims[0] < lon < lon_lims[-1]) and ( - lat_lims[0] < lat < lat_lims[-1]): + for ix, (lon, lat, cnc, std, times) in enumerate(zip(obs_lons, obs_lats, obs_cnc, obs_std, obs_times)): + if any(np.isfinite(cnc)) and (lon_lims[0] < lon < lon_lims[-1]) and (lat_lims[0] < lat < lat_lims[-1]): np.place(obs_cnc_matrix[ix], mask_true, cnc) np.place(obs_std_matrix[ix], mask_true, std) np.place(obs_dates_matrix[ix], mask_true, times) @@ -518,32 +489,25 @@ def extract_obs_column(file): # Define data variables and attributes for xarray dataset data_vars = { "Concentration": (["station", "time"], obs_cnc_matrix, { - "units": "ppm", - "long_name": "CO2_concentration" + "units": "ppm", "long_name": "CO2_concentration" }), "Std": (["station", "time"], obs_std_matrix, { - "units": "ppm", - "long_name": "CO2_concentrations_std" + "units": "ppm", "long_name": "CO2_concentrations_std" }), "Stations_names": (["station"], station_names, { - "units": "-", - "long_name": "Stations_names" + "units": "-", "long_name": "Stations_names" }), "Stations_ids": (["station"], obs_ids, { - "units": "-", - "long_name": "Stations_names" + "units": "-", "long_name": "Stations_names" }), "Stations_masl": (["station"], obs_masl, { - "units": "-", - "long_name": "Elevation_heights_above_sl" + "units": "-", "long_name": "Elevation_heights_above_sl" }), "Lon": (["station"], obs_lons, { - "units": "degrees", - "long_name": "Longitude" + "units": "degrees", "long_name": "Longitude" }), "Lat": (["station"], obs_lats, { - "units": "degrees", - "long_name": "Latitude" + "units": "degrees", "long_name": "Latitude" }), "Dates": (["station", "time"], obs_dates_matrix, { "long_name": "Dates" @@ -551,32 +515,28 @@ def extract_obs_column(file): } # Define coordinates - coords = {"station": (["station"], station_idcs)} + coords = { + "station": (["station"], station_idcs) + } attrs = { - 'creation_date': str(datetime.now()), - 'author': 'Processing Chain' + 'creation_date':str(datetime.now()), + 'author':'Processing Chain' } # Create xarray dataset - ds_extracted_obs_matrix = xr.Dataset(data_vars=data_vars, - coords=coords, - attrs=attrs) + ds_extracted_obs_matrix = xr.Dataset( + data_vars=data_vars, + coords=coords, + attrs=attrs + ) # Save dataset to file - output_filename = Path( - output_folder - ) / f"Extracted_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}_alldates_masl.nc" + output_filename = Path(output_folder) / f"Extracted_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}_alldates_masl.nc" ds_extracted_obs_matrix.to_netcdf(output_filename) - logging.info( - f"Finished extraction and stored obs_matrix for {len(obs_lons)} stations " - ) - logging.info( - f"(from {number_of_stations} available ICOS stations), which were operating " - ) - logging.info( - f"during the given period and are located inside the model domain, in the file: {output_filename}" - ) + logging.info(f"Finished extraction and stored obs_matrix for {len(obs_lons)} stations ") + logging.info(f"(from {number_of_stations} available ICOS stations), which were operating ") + logging.info(f"during the given period and are located inside the model domain, in the file: {output_filename}") def fetch_OCO2_data(starttime, @@ -737,7 +697,7 @@ def get_http_data(request): print('Finished') -def process_OCO2_data(OCO2_obs_folder, +def process_OCO2_data(OCO2_obs_folder, start_date='01-01-2022', end_date='31-12-2022', output_folder='~/'): @@ -751,79 +711,41 @@ def process_OCO2_data(OCO2_obs_folder, output_folder str e.g., /scratch/snx/[user]/ICOS_data/year/ """ - + # # Process files for day in iter_hours(start_date, end_date, 24): # Gather files - logging.info( - f"Looking in folder {OCO2_obs_folder} for ICOS observation files with glob OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4" - ) - file = list( - Path(OCO2_obs_folder).glob( - f"OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4")) + logging.info(f"Looking in folder {OCO2_obs_folder} for ICOS observation files with glob OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4") + file = list(Path(OCO2_obs_folder).glob(f"OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4")) if not file: continue - elif len(file) > 0: + elif len(file)>0: IndexError("Error, more OCO-2 files exist than expected. Review.") - else: + else: logging.info(f'Will open data from {file}') - + # Open file s5p_data = xr.open_dataset(file[0]) - s5p_out = s5p_data[[ - "latitude", "longitude", "date", "xco2", "xco2_quality_flag", - "xco2_averaging_kernel", "pressure_levels", "pressure_levels", - "pressure_weight", "co2_profile_apriori", "xco2_apriori", - "xco2_uncertainty" - ]] - s5p_out = s5p_out.rename({ - "levels": "layers", - "sounding_id": "soundings", - "xco2": "obs", - "xco2_quality_flag": "quality_flag", - "xco2_averaging_kernel": "averaging_kernel", - "pressure_weight": "pressure_weighting_function", - "co2_profile_apriori": "prior_profile", - "xco2_apriori": "prior", - "xco2_uncertainty": "uncertainty" - }) - s5p_out["pressure_levels"] = s5p_out.pressure_levels[:, ::-1] - s5p_out[ - "pressure_weighting_function"] = s5p_out.pressure_weighting_function[:, :: - -1] - s5p_out["surface_pressure"] = s5p_out.pressure_levels[:, 0] - - # Process the 'time' variable: convert format, convert shape - # pressure_levels (rename, reverse direction), pressure_weight (rename, reverse, select) - # co2_profile_apriori (rename, reverse, select), xco2_apriori (rename, select) - # xco2_uncertainty (rename, select) - s5p_out = s5p_data[[ - "latitude", "longitude", "date", "xco2", "xco2_quality_flag", - "xco2_averaging_kernel", "pressure_levels", "pressure_levels", - "pressure_weight", "co2_profile_apriori", "xco2_apriori", - "xco2_uncertainty" - ]] - s5p_out = s5p_out.rename({ - "levels": "layers", - "sounding_id": "soundings", - "xco2": "obs", - "xco2_quality_flag": "quality_flag", - "xco2_averaging_kernel": "averaging_kernel", - "pressure_weight": "pressure_weighting_function", - "co2_profile_apriori": "prior_profile", - "xco2_apriori": "prior", - "xco2_uncertainty": "uncertainty" - }) - s5p_out["pressure_levels"] = s5p_out.pressure_levels[:, ::-1] - s5p_out[ - "pressure_weighting_function"] = s5p_out.pressure_weighting_function[:, :: - -1] - s5p_out["surface_pressure"] = s5p_out.pressure_levels[:, 0] + s5p_out = s5p_data[["latitude", "longitude", "date", + "xco2", "xco2_quality_flag", "xco2_averaging_kernel", "pressure_levels", + "pressure_levels", "pressure_weight", "co2_profile_apriori", "xco2_apriori", + "xco2_uncertainty" ]] + s5p_out = s5p_out.rename({"levels": "layers", + "sounding_id": "soundings", + "xco2": "obs", + "xco2_quality_flag": "quality_flag", + "xco2_averaging_kernel": "averaging_kernel", + "pressure_weight": "pressure_weighting_function", + "co2_profile_apriori": "prior_profile", + "xco2_apriori": "prior", + "xco2_uncertainty": "uncertainty"}) + s5p_out["pressure_levels"] = s5p_out.pressure_levels[:,::-1] + s5p_out["pressure_weighting_function"] = s5p_out.pressure_weighting_function[:,::-1] + s5p_out["surface_pressure"] = s5p_out.pressure_levels[:,0] s5p_out.attrs.update({ - 'creation_date': str(datetime.now()), - 'author': 'Processing Chain', + 'creation_date':str(datetime.now()), + 'author':'Processing Chain', 'level_def': 'pressure_boundaries', 'retrieval_id': file[0].name }) - s5p_out.to_netcdf(output_folder / - f"OCO2_{day.strftime('%Y%m%d')}_ctdas.nc") + s5p_out.to_netcdf(output_folder / f"OCO2_{day.strftime('%Y%m%d')}_ctdas.nc") \ No newline at end of file From 459fdeb7d8c7092249e7868ef2c5ad99051083d6 Mon Sep 17 00:00:00 2001 From: github-actions Date: Wed, 18 Dec 2024 12:26:05 +0000 Subject: [PATCH 27/42] GitHub Action: Apply Pep8-formatting --- jobs/prepare_CTDAS.py | 266 +++++++++++++++++++----------- jobs/tools/fetch_external_data.py | 219 ++++++++++++++---------- 2 files changed, 306 insertions(+), 179 deletions(-) diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index 6d32c4e2..2a699515 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -7,7 +7,7 @@ import shutil import subprocess from . import tools, prepare_icon -from .tools.fetch_external_data import fetch_era5, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2_data, process_ICOS_data, process_OCO2_data +from .tools.fetch_external_data import fetch_era5, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2_data, process_ICOS_data, process_OCO2_data from .tools.ctdas_utilities import create_lambda_regions, create_prior_all_ones, create_boundary_regions, create_boundary_prior_all_ones from concurrent.futures import ThreadPoolExecutor, as_completed from datetime import timedelta @@ -44,41 +44,69 @@ def main(cfg): if cfg.chem_fetch_CAMS: CAMS_folder = cfg.case_root / "global_inputs" / "CAMS" tools.create_dir(CAMS_folder, "CAMS input files") - fetch_CAMS_CO2( - cfg.startdate_sim, (cfg.enddate_sim+timedelta(days=1)), CAMS_folder - ) + fetch_CAMS_CO2(cfg.startdate_sim, + (cfg.enddate_sim + timedelta(days=1)), CAMS_folder) # -- 2. Fetch *all* ERA5 data (not just for initial conditions) if cfg.meteo_fetch_era5: ERA5_folder = cfg.case_root / "global_inputs" / "ERA5" tools.create_dir(ERA5_folder, "CAMS input files") - times = list(tools.iter_hours(cfg.startdate_sim, (cfg.enddate_sim+timedelta(days=1)), cfg.meteo_nudging_step)) + times = list( + tools.iter_hours(cfg.startdate_sim, + (cfg.enddate_sim + timedelta(days=1)), + cfg.meteo_nudging_step)) logging.info(f"Time range considered here: {times}") - file_list = [f"era5_ml_{(cfg.startdate_sim + timedelta(hours=i)).replace(tzinfo=None).isoformat()}.nc" - for i in range(0, int((cfg.enddate_sim - cfg.startdate_sim).total_seconds() // 3600) + 1, cfg.meteo_nudging_step)] - file_list+= [f"era5_surf_{(cfg.startdate_sim + timedelta(hours=i)).replace(tzinfo=None).isoformat()}.nc" - for i in range(0, int((cfg.enddate_sim - cfg.startdate_sim).total_seconds() // 3600) + 1, cfg.meteo_nudging_step)] - missing_files = [file for file in file_list if not (ERA5_folder / file).exists()] + file_list = [ + f"era5_ml_{(cfg.startdate_sim + timedelta(hours=i)).replace(tzinfo=None).isoformat()}.nc" + for i in range( + 0, + int((cfg.enddate_sim - cfg.startdate_sim).total_seconds() // + 3600) + 1, cfg.meteo_nudging_step) + ] + file_list += [ + f"era5_surf_{(cfg.startdate_sim + timedelta(hours=i)).replace(tzinfo=None).isoformat()}.nc" + for i in range( + 0, + int((cfg.enddate_sim - cfg.startdate_sim).total_seconds() // + 3600) + 1, cfg.meteo_nudging_step) + ] + missing_files = [ + file for file in file_list if not (ERA5_folder / file).exists() + ] if not missing_files: logging.info("All model level files already present") else: logging.info(f"Missing files: {missing_files}") # Split downloads in 3-day chunks, but run simultaneously N = 3 - chunks = list(tools.split_into_chunks(times, N, cfg.meteo_nudging_step)) - logging.info(f"Time range split up into chunks of {N} days, giving the following chunks: {chunks}") + chunks = list( + tools.split_into_chunks(times, N, cfg.meteo_nudging_step)) + logging.info( + f"Time range split up into chunks of {N} days, giving the following chunks: {chunks}" + ) # Run fetch_era5 in parallel over chunks - output_filenames = [None] * len(chunks) # Create a list to store filenames in order + output_filenames = [None] * len( + chunks) # Create a list to store filenames in order with ThreadPoolExecutor(max_workers=4) as executor: - futures = {executor.submit(fetch_era5, chunk, ERA5_folder, resolution=0.25, area=[60, -15, 35, 20]): i for i, chunk in enumerate(chunks)} + futures = { + executor.submit(fetch_era5, + chunk, + ERA5_folder, + resolution=0.25, + area=[60, -15, 35, 20]): + i + for i, chunk in enumerate(chunks) + } for future in futures: index = futures[future] # Get the index of the future try: - result = future.result() # Get the result from the future - output_filenames[index] = result # Store the returned filename(s) in the correct order + result = future.result( + ) # Get the result from the future + output_filenames[ + index] = result # Store the returned filename(s) in the correct order logging.info(f"Fetched data and saved to: {result}") except Exception as exc: logging.error(f"Generated an exception: {exc}") @@ -86,19 +114,27 @@ def main(cfg): # Split files (with multiple days/times) into individual files using bash script era5_split_template = cfg.case_path / cfg.meteo_era5_splitjob - era5_split_job = ERA5_folder / (cfg.meteo_era5_splitjob.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + cfg.meteo_era5_splitjob.suffix) - logging.info(f"Preparing ERA5 splitting script for ICON from {era5_split_template}") - ml_files = " ".join([f"{filenames[0]}" for filenames in output_filenames]) - surf_files = " ".join([f"{filenames[1]}" for filenames in output_filenames]) - with open(era5_split_template, 'r') as infile, open(era5_split_job, 'w') as outfile: - outfile.write(infile.read().format( - cfg=cfg, - ml_files=ml_files, - surf_files=surf_files, - ERA5_folder=ERA5_folder - )) + era5_split_job = ERA5_folder / ( + cfg.meteo_era5_splitjob.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + cfg.meteo_era5_splitjob.suffix) + logging.info( + f"Preparing ERA5 splitting script for ICON from {era5_split_template}" + ) + ml_files = " ".join( + [f"{filenames[0]}" for filenames in output_filenames]) + surf_files = " ".join( + [f"{filenames[1]}" for filenames in output_filenames]) + with open(era5_split_template, + 'r') as infile, open(era5_split_job, 'w') as outfile: + outfile.write(infile.read().format(cfg=cfg, + ml_files=ml_files, + surf_files=surf_files, + ERA5_folder=ERA5_folder)) logging.info(f"Running ERA5 splitting script {era5_split_job}") - subprocess.run(["bash", era5_split_job], check=True, stdout=subprocess.PIPE) + subprocess.run(["bash", era5_split_job], + check=True, + stdout=subprocess.PIPE) # -- 3. Process initial conditions data using bash script datestr = cfg.startdate_sim.strftime("%Y-%m-%dT%H:%M:%S") @@ -108,40 +144,50 @@ def main(cfg): era5_ml_file = ERA5_folder / f"era5_ml_{datestr}.nc" era5_surf_file = ERA5_folder / f"era5_surf_{datestr}.nc" era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob - era5_ini_job = ERA5_folder / (era5_ini_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + era5_ini_template.suffix) + era5_ini_job = ERA5_folder / (era5_ini_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + era5_ini_template.suffix) with open(era5_ini_template, 'r') as infile, open(era5_ini_job, - 'w') as outfile: + 'w') as outfile: outfile.write(infile.read().format(cfg=cfg, - era5_ml_file=era5_ml_file, - era5_surf_file=era5_surf_file, - inicond_filename=era5_ini_file, - ERA5_folder=ERA5_folder)) + era5_ml_file=era5_ml_file, + era5_surf_file=era5_surf_file, + inicond_filename=era5_ini_file, + ERA5_folder=ERA5_folder)) shutil.copy(cfg.case_path / cfg.meteo_partab, ERA5_folder / 'mypartab') logging.info(f"Running ERA5 initial conditions script {era5_ini_job}") - subprocess.run(["bash", era5_ini_job], check=True, stdout=subprocess.PIPE) + subprocess.run(["bash", era5_ini_job], + check=True, + stdout=subprocess.PIPE) # --- CAMS inicond logging.info("Preparing CAMS initial conditions script for ICON") cams_ini_template = cfg.case_path / cfg.chem_cams_inijob - cams_ini_job = ERA5_folder / (cams_ini_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + cams_ini_template.suffix) + cams_ini_job = ERA5_folder / (cams_ini_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + cams_ini_template.suffix) with open(cams_ini_template, 'r') as infile, open(cams_ini_job, - 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - inicond_filename=era5_ini_file, - ERA5_folder=ERA5_folder, - CAMS_file=CAMS_folder / f'cams_egg4_{cfg.startdate_sim.strftime("%Y%m%d%H")}.nc', - era5_cams_ini_file=era5_ini_file)) + 'w') as outfile: + outfile.write(infile.read().format( + cfg=cfg, + inicond_filename=era5_ini_file, + ERA5_folder=ERA5_folder, + CAMS_file=CAMS_folder / + f'cams_egg4_{cfg.startdate_sim.strftime("%Y%m%d%H")}.nc', + era5_cams_ini_file=era5_ini_file)) logging.info(f"Running CAMS initial conditions script {cams_ini_job}") - subprocess.run(["bash", cams_ini_job], check=True, stdout=subprocess.PIPE) + subprocess.run(["bash", cams_ini_job], + check=True, + stdout=subprocess.PIPE) # -- 4. Interpolate CAMS to ERA5 3D grid if cfg.meteo_interpolate_CAMS_to_ERA5: for time in tools.iter_hours(cfg.startdate_sim, - (cfg.enddate_sim+timedelta(days=1)), + (cfg.enddate_sim + timedelta(days=1)), step=cfg.meteo_nudging_step): # -- Give a name to the nudging file datestr = time.strftime("%Y-%m-%dT%H:%M:%S") - datestr2= time.strftime("%Y%m%d%H") + datestr2 = time.strftime("%Y%m%d%H") era5_nudge_file_final = cfg.icon_input_icbc / f"era5_nudge_{datestr2}.nc" if not era5_nudge_file_final.exists(): era5_ml_file = ERA5_folder / f"era5_ml_{datestr}.nc" @@ -151,13 +197,14 @@ def main(cfg): # -- Copy ERA5 processing script (icon_era5_nudging.job) in workdir nudging_template = cfg.case_path / cfg.meteo_era5_nudgingjob nudging_job = ERA5_folder / f'icon_era5_nudging_{datestr}.sh' - with open(nudging_template, 'r') as infile, open(nudging_job, - 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - era5_ml_file=era5_ml_file, - era5_surf_file=era5_surf_file, - filename=era5_nudge_file, - ERA5_folder=ERA5_folder)) + with open(nudging_template, + 'r') as infile, open(nudging_job, 'w') as outfile: + outfile.write(infile.read().format( + cfg=cfg, + era5_ml_file=era5_ml_file, + era5_surf_file=era5_surf_file, + filename=era5_nudge_file, + ERA5_folder=ERA5_folder)) # -- Copy mypartab into workdir if not os.path.exists(ERA5_folder / 'mypartab'): @@ -166,40 +213,50 @@ def main(cfg): # -- Run ERA5 processing script subprocess.run(["bash", nudging_job], - check=True, - stdout=subprocess.PIPE) + check=True, + stdout=subprocess.PIPE) # -- Copy CAMS processing script (icon_cams_nudging.job) into workdir - logging.info("Preparing CAMS preprocessing nudging script for ICON") + logging.info( + "Preparing CAMS preprocessing nudging script for ICON") cams_nudge_template = cfg.case_path / cfg.chem_cams_nudgingjob - cams_nudge_job = ERA5_folder / (cams_nudge_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + cams_nudge_template.suffix) - with open(cams_nudge_template, 'r') as infile, open(cams_nudge_job, - 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - filename=era5_nudge_file, - ERA5_folder=ERA5_folder, - CAMS_file=CAMS_folder / f'cams_egg4_{time.strftime("%Y%m%d%H")}.nc', - era5_cams_nudge_file=era5_nudge_file_final, - )) - subprocess.run(["bash", cams_nudge_job], check=True, stdout=subprocess.PIPE) + cams_nudge_job = ERA5_folder / ( + cams_nudge_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + cams_nudge_template.suffix) + with open(cams_nudge_template, + 'r') as infile, open(cams_nudge_job, 'w') as outfile: + outfile.write(infile.read().format( + cfg=cfg, + filename=era5_nudge_file, + ERA5_folder=ERA5_folder, + CAMS_file=CAMS_folder / + f'cams_egg4_{time.strftime("%Y%m%d%H")}.nc', + era5_cams_nudge_file=era5_nudge_file_final, + )) + subprocess.run(["bash", cams_nudge_job], + check=True, + stdout=subprocess.PIPE) # -- 5. Download ICOS CO2 data - # Lots of potential for 'dehardcoding' things here, but that has to be done with - # a lot of care. + # Lots of potential for 'dehardcoding' things here, but that has to be done with + # a lot of care. if cfg.CTDAS_obs_fetch_ICOS: fetch_ICOS_data(cookie_token=cfg.CTDAS_obs_ICOS_cookie_token, start_date=cfg.startdate_sim.strftime("%d-%m-%Y"), - end_date=(cfg.enddate_sim+timedelta(days=1)).strftime("%d-%m-%Y"), + end_date=(cfg.enddate_sim + + timedelta(days=1)).strftime("%d-%m-%Y"), save_path=cfg.CTDAS_obs_ICOS_path, species=[ 'co2', ]) - tools.create_dir(cfg.case_root / "global_inputs" / "ICOS", "ICOS input files") + tools.create_dir(cfg.case_root / "global_inputs" / "ICOS", + "ICOS input files") process_ICOS_data(ICOS_obs_folder=cfg.CTDAS_obs_ICOS_path, start_date=cfg.startdate_sim, - end_date=(cfg.enddate_sim+timedelta(days=1)), - output_folder=cfg.case_root / "global_inputs" / "ICOS" - ) + end_date=(cfg.enddate_sim + timedelta(days=1)), + output_folder=cfg.case_root / "global_inputs" / + "ICOS") # -- 6. Download OCO2 data if cfg.CTDAS_obs_fetch_OCO2: @@ -223,18 +280,20 @@ def main(cfg): # file.close() # Popen('chmod og-rw ~/.netrc', shell=True) fetch_OCO2_data(cfg.startdate_sim, - (cfg.enddate_sim+timedelta(days=1)), - -8, - 30, - 35, - 65, - cfg.CTDAS_obs_OCO2_path, - product="OCO2_L2_Lite_FP_11.1r") - tools.create_dir(cfg.case_root / "global_inputs" / "OCO2", "OCO-2 output") + (cfg.enddate_sim + timedelta(days=1)), + -8, + 30, + 35, + 65, + cfg.CTDAS_obs_OCO2_path, + product="OCO2_L2_Lite_FP_11.1r") + tools.create_dir(cfg.case_root / "global_inputs" / "OCO2", + "OCO-2 output") process_OCO2_data(OCO2_obs_folder=cfg.CTDAS_obs_OCO2_path, start_date=cfg.startdate_sim, - end_date=(cfg.enddate_sim+timedelta(days=1)), - output_folder=cfg.case_root / "global_inputs" / "OCO2") # post-process all the OCO2 data + end_date=(cfg.enddate_sim + timedelta(days=1)), + output_folder=cfg.case_root / "global_inputs" / + "OCO2") # post-process all the OCO2 data # -- 7. Create the required folder structure # For the ICON runs @@ -243,7 +302,8 @@ def main(cfg): tools.create_dir(cfg.icon_base / "output_opt_twice", "2 times optimized") # For the sampling - tools.create_dir(cfg.case_root / "global_output" / "extracted_ICOS", "Output of the extraction script") + tools.create_dir(cfg.case_root / "global_output" / "extracted_ICOS", + "Output of the extraction script") # -- 8. Initialize the first one-day run, only for the first lag if cfg.startdate_sim == cfg.startdate: @@ -257,7 +317,8 @@ def main(cfg): '#SBATCH --time=00:10:00', f'#SBATCH --partition={cfg.compute_queue}', f'#SBATCH --constraint={cfg.constraint}', '#SBATCH --nodes=1', - f'#SBATCH --output={cfg.logfile}', '#SBATCH --open-mode=append', + f'#SBATCH --output={cfg.logfile}', + '#SBATCH --open-mode=append', f'#SBATCH --chdir={cfg.icon_work}', '' ] elif cfg.machine == 'euler': @@ -267,29 +328,45 @@ def main(cfg): '#SBATCH --time=00:10:00', f'#SBATCH --partition={cfg.compute_queue}', f'#SBATCH --constraint={cfg.constraint}', '#SBATCH --ntasks=1', - f'#SBATCH --output={cfg.logfile}', '#SBATCH --open-mode=append', + f'#SBATCH --output={cfg.logfile}', + '#SBATCH --open-mode=append', f'#SBATCH --chdir={cfg.icon_work}', '' ] for category in cfg.CTDAS_global_inputs: - tools.create_dir(cat_folder := cfg.case_root / "global_inputs" / category, category) + tools.create_dir( + cat_folder := cfg.case_root / "global_inputs" / category, + category) for file in category: source = (p := Path(file)) destination = cat_folder / p.name script_lines.append(f'rsync -av {source} {destination}') - with (script := cfg.icon_work / 'copy_global_inputs.job').open('w') as f: - f.write('\n'.join(script_lines)) + with (script := + cfg.icon_work / 'copy_global_inputs.job').open('w') as f: + f.write('\n'.join(script_lines)) cfg.submit('global_inputs', script) # -- 8.2 Create the ensemble data for the first day - tools.create_dir(OEM_folder := cfg.case_root / "global_inputs" / "OEM", "OEM") - lambdas = [int(item) for line in cfg.CTDAS_lambdas for item in line.split(',')] + tools.create_dir(OEM_folder := cfg.case_root / "global_inputs" / "OEM", + "OEM") + lambdas = [ + int(item) for line in cfg.CTDAS_lambdas for item in line.split(',') + ] if cfg.CTDAS_regions == 'basegrid': - nregs, ncats = create_lambda_regions(cfg.input_files_dynamics_grid_filename, OEM_folder / "lambdaregions.nc", lambdas) - create_prior_all_ones(OEM_folder / "prior_all_ones.nc", nensembles=cfg.CTDAS_nensembles, ncats=lambdas.max(), nregs=nregs) + nregs, ncats = create_lambda_regions( + cfg.input_files_dynamics_grid_filename, + OEM_folder / "lambdaregions.nc", lambdas) + create_prior_all_ones(OEM_folder / "prior_all_ones.nc", + nensembles=cfg.CTDAS_nensembles, + ncats=lambdas.max(), + nregs=nregs) else: raise NotImplementedError('Only basegrid is implemented for now') - create_boundary_regions('/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc', '/scratch/snx3000/ekoene/boundary_mask_bg.nc') - create_boundary_prior_all_ones('/scratch/snx3000/ekoene/boundary_lambdas_bg.nc', nensembles=cfg.CTDAS_nensembles) + create_boundary_regions( + '/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc', + '/scratch/snx3000/ekoene/boundary_mask_bg.nc') + create_boundary_prior_all_ones( + '/scratch/snx3000/ekoene/boundary_lambdas_bg.nc', + nensembles=cfg.CTDAS_nensembles) # Create a folder an `nlag` period earlier / icon / output_opt_twice @@ -311,6 +388,5 @@ def main(cfg): # logging.info(f"Running ERA5 splitting script {era5_split_job}") # subprocess.run(["bash", era5_split_job], check=True, stdout=subprocess.PIPE) - logging.info("OK") shutil.copy(cfg.logfile, cfg.logfile_finish) diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 61ebe365..a1bdaf5a 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -20,6 +20,7 @@ from concurrent.futures import ThreadPoolExecutor from . import iter_hours, create_dir + def fetch_CDS(product, date, levels, params, resolution, area, outloc): # Obtain CDS authentification from file url_cmd = f"grep 'cds' ~/.cdsapirc" @@ -196,13 +197,16 @@ def fetch_CAMS_CO2(start_date, end_date, dir2move): year = current_date.year start_month = current_date.month if current_date.year == start_date.year else 1 end_month = end_date.month if current_date.year == end_date.year else 12 - months = [f"{month:02d}" for month in range(start_month, end_month + 1)] + months = [ + f"{month:02d}" for month in range(start_month, end_month + 1) + ] # Define download file - download = os.path.join(tmpdir, f'cams_GHG_{year}_{start_date.strftime("%Y%m%d")}.zip') + download = os.path.join( + tmpdir, f'cams_GHG_{year}_{start_date.strftime("%Y%m%d")}.zip') if not os.path.isfile(download): c.retrieve( - 'cams-global-greenhouse-gas-inversion', { + 'cams-global-greenhouse-gas-inversion', { 'variable': 'carbon_dioxide', 'quantity': 'concentration', 'input_observations': 'surface', @@ -211,8 +215,7 @@ def fetch_CAMS_CO2(start_date, end_date, dir2move): 'year': str(year), 'month': months, 'format': 'zip', - }, - download) + }, download) logging.info(f'Downloaded CAMS data for year {year}!') else: logging.info(f'File already downloaded: {download}') @@ -233,14 +236,17 @@ def fetch_CAMS_CO2(start_date, end_date, dir2move): try: ds_CAMS = xr.open_dataset(filename) for time in ds_CAMS.time: - if np.datetime64(start_date) <= time.values <= np.datetime64(end_date): + if np.datetime64( + start_date) <= time.values <= np.datetime64( + end_date): outpath = os.path.join( - dir2move, 'cams_egg4_' + - np.datetime_as_string(time.values, unit='h').replace('-', '').replace(':', '') + - '.nc') + dir2move, 'cams_egg4_' + np.datetime_as_string( + time.values, unit='h').replace( + '-', '').replace(':', '') + '.nc') if not os.path.isfile(outpath): logging.info(f"Writing CAMS data to {outpath}") - ds_out = ds_CAMS.sel(time=time, drop=True).squeeze() + ds_out = ds_CAMS.sel(time=time, + drop=True).squeeze() ds_out.to_netcdf(outpath) except Exception as e: logging.warning(f"Error processing file {filename}: {e}") @@ -366,7 +372,7 @@ def fetch_ICOS_data(cookie_token, ds.to_netcdf(os.path.join(save_path, name)) -def process_ICOS_data(ICOS_obs_folder, +def process_ICOS_data(ICOS_obs_folder, start_date='01-01-2022', end_date='31-12-2022', output_folder='~/'): @@ -385,29 +391,38 @@ def process_ICOS_data(ICOS_obs_folder, lat_lims = [40.9, 58.7] # Utility for converting units to PPMv - toppm_dict = {'nmol mol-1':1e-9*1e6, - 'µmol mol-1':1e-6*1e6} + toppm_dict = {'nmol mol-1': 1e-9 * 1e6, 'µmol mol-1': 1e-6 * 1e6} # Gather chosen dates delta = end_date - start_date chosen_dates = [ - np.datetime64((start_date + timedelta(days=i, hours=h)).strftime('%Y-%m-%dT%H:%M:%S.000000000')) - for i in range(delta.days + 1) - for h in range(24) + np.datetime64((start_date + timedelta( + days=i, hours=h)).strftime('%Y-%m-%dT%H:%M:%S.000000000')) + for i in range(delta.days + 1) for h in range(24) ] number_of_hourly_measurements = len(chosen_dates) - logging.info(f'A total of {number_of_hourly_measurements} hours are possible') + logging.info( + f'A total of {number_of_hourly_measurements} hours are possible') # Gather files - logging.info(f"Looking in folder {ICOS_obs_folder} for ICOS observation files with glob *{start_date.strftime('%d-%m-%Y')}_{end_date.strftime('%d-%m-%Y')}.nc") - files = list(Path(ICOS_obs_folder).glob(f"*{start_date.strftime('%d-%m-%Y')}_{end_date.strftime('%d-%m-%Y')}.nc")) + logging.info( + f"Looking in folder {ICOS_obs_folder} for ICOS observation files with glob *{start_date.strftime('%d-%m-%Y')}_{end_date.strftime('%d-%m-%Y')}.nc" + ) + files = list( + Path(ICOS_obs_folder).glob( + f"*{start_date.strftime('%d-%m-%Y')}_{end_date.strftime('%d-%m-%Y')}.nc" + )) number_of_stations = len(files) logging.info(f'Will package data from {number_of_stations} files, {files}') # Prepare - obs_cnc_matrix = np.zeros((number_of_stations, number_of_hourly_measurements), dtype=np.float64) - obs_dates_matrix = np.zeros((number_of_stations, number_of_hourly_measurements), dtype = np.dtype('datetime64[ns]')) - obs_std_matrix = np.zeros((number_of_stations, number_of_hourly_measurements), dtype=np.float64) + obs_cnc_matrix = np.zeros( + (number_of_stations, number_of_hourly_measurements), dtype=np.float64) + obs_dates_matrix = np.zeros( + (number_of_stations, number_of_hourly_measurements), + dtype=np.dtype('datetime64[ns]')) + obs_std_matrix = np.zeros( + (number_of_stations, number_of_hourly_measurements), dtype=np.float64) # Set-up a function that can be called in parallel def extract_obs_column(file): @@ -419,31 +434,43 @@ def extract_obs_column(file): id_st = ds.attrs['Station'] units = ds.attrs['Units'] masl = ds.attrs['Elevation above sea level'] - diff = (ds.time.values[1] - ds.time.values[0]) / 3600000000000 # Time difference in hours - + diff = (ds.time.values[1] - ds.time.values[0] + ) / 3600000000000 # Time difference in hours + if diff != 1: - logging.info(f'Observation data at station {name} is not hourly averaged ({diff} hours)') - + logging.info( + f'Observation data at station {name} is not hourly averaged ({diff} hours)' + ) + # Filter dataset to the desired time range ds['time'] = ds['time'] - ds_filtered = ds.sel(time=slice(start_date.replace(tzinfo=None), end_date.replace(tzinfo=None))) - + ds_filtered = ds.sel(time=slice(start_date.replace( + tzinfo=None), end_date.replace(tzinfo=None))) + # Align `chosen_dates` with `ds_filtered.time` - ds_aligned = ds_filtered.reindex(time=chosen_dates, method='nearest', tolerance='1h') - + ds_aligned = ds_filtered.reindex(time=chosen_dates, + method='nearest', + tolerance='1h') + # Update observation arrays obs_dates1 = ds_aligned.time.values obs_std1 = ds_aligned.Stdev.values * toppm_dict[units] obs_cnc1 = ds_aligned["co2"].values * toppm_dict[units] lons, lats = ds.attrs['Longitude'], ds.attrs['Latitude'] - + except Exception as e: logging.info(f"Error processing file {file}: {e}") - obs_cnc1 = np.full(number_of_hourly_measurements, np.nan, dtype=np.float64) - obs_dates1 = np.full(number_of_hourly_measurements, np.datetime64("NaT"), dtype="datetime64[ns]") - obs_std1 = np.full(number_of_hourly_measurements, np.nan, dtype=np.float64) + obs_cnc1 = np.full(number_of_hourly_measurements, + np.nan, + dtype=np.float64) + obs_dates1 = np.full(number_of_hourly_measurements, + np.datetime64("NaT"), + dtype="datetime64[ns]") + obs_std1 = np.full(number_of_hourly_measurements, + np.nan, + dtype=np.float64) name, id_st, masl, lons, lats = 'nan', 0, -999, np.nan, np.nan - + return name, obs_std1, obs_cnc1, obs_dates1, lons, lats, id_st, masl # Process all data concurrently @@ -465,8 +492,10 @@ def extract_obs_column(file): mask_true = np.full_like(obs_cnc_matrix[0], True) # Filter and populate matrices - for ix, (lon, lat, cnc, std, times) in enumerate(zip(obs_lons, obs_lats, obs_cnc, obs_std, obs_times)): - if any(np.isfinite(cnc)) and (lon_lims[0] < lon < lon_lims[-1]) and (lat_lims[0] < lat < lat_lims[-1]): + for ix, (lon, lat, cnc, std, times) in enumerate( + zip(obs_lons, obs_lats, obs_cnc, obs_std, obs_times)): + if any(np.isfinite(cnc)) and (lon_lims[0] < lon < lon_lims[-1]) and ( + lat_lims[0] < lat < lat_lims[-1]): np.place(obs_cnc_matrix[ix], mask_true, cnc) np.place(obs_std_matrix[ix], mask_true, std) np.place(obs_dates_matrix[ix], mask_true, times) @@ -489,25 +518,32 @@ def extract_obs_column(file): # Define data variables and attributes for xarray dataset data_vars = { "Concentration": (["station", "time"], obs_cnc_matrix, { - "units": "ppm", "long_name": "CO2_concentration" + "units": "ppm", + "long_name": "CO2_concentration" }), "Std": (["station", "time"], obs_std_matrix, { - "units": "ppm", "long_name": "CO2_concentrations_std" + "units": "ppm", + "long_name": "CO2_concentrations_std" }), "Stations_names": (["station"], station_names, { - "units": "-", "long_name": "Stations_names" + "units": "-", + "long_name": "Stations_names" }), "Stations_ids": (["station"], obs_ids, { - "units": "-", "long_name": "Stations_names" + "units": "-", + "long_name": "Stations_names" }), "Stations_masl": (["station"], obs_masl, { - "units": "-", "long_name": "Elevation_heights_above_sl" + "units": "-", + "long_name": "Elevation_heights_above_sl" }), "Lon": (["station"], obs_lons, { - "units": "degrees", "long_name": "Longitude" + "units": "degrees", + "long_name": "Longitude" }), "Lat": (["station"], obs_lats, { - "units": "degrees", "long_name": "Latitude" + "units": "degrees", + "long_name": "Latitude" }), "Dates": (["station", "time"], obs_dates_matrix, { "long_name": "Dates" @@ -515,28 +551,32 @@ def extract_obs_column(file): } # Define coordinates - coords = { - "station": (["station"], station_idcs) - } + coords = {"station": (["station"], station_idcs)} attrs = { - 'creation_date':str(datetime.now()), - 'author':'Processing Chain' + 'creation_date': str(datetime.now()), + 'author': 'Processing Chain' } # Create xarray dataset - ds_extracted_obs_matrix = xr.Dataset( - data_vars=data_vars, - coords=coords, - attrs=attrs - ) + ds_extracted_obs_matrix = xr.Dataset(data_vars=data_vars, + coords=coords, + attrs=attrs) # Save dataset to file - output_filename = Path(output_folder) / f"Extracted_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}_alldates_masl.nc" + output_filename = Path( + output_folder + ) / f"Extracted_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}_alldates_masl.nc" ds_extracted_obs_matrix.to_netcdf(output_filename) - logging.info(f"Finished extraction and stored obs_matrix for {len(obs_lons)} stations ") - logging.info(f"(from {number_of_stations} available ICOS stations), which were operating ") - logging.info(f"during the given period and are located inside the model domain, in the file: {output_filename}") + logging.info( + f"Finished extraction and stored obs_matrix for {len(obs_lons)} stations " + ) + logging.info( + f"(from {number_of_stations} available ICOS stations), which were operating " + ) + logging.info( + f"during the given period and are located inside the model domain, in the file: {output_filename}" + ) def fetch_OCO2_data(starttime, @@ -697,7 +737,7 @@ def get_http_data(request): print('Finished') -def process_OCO2_data(OCO2_obs_folder, +def process_OCO2_data(OCO2_obs_folder, start_date='01-01-2022', end_date='31-12-2022', output_folder='~/'): @@ -711,41 +751,52 @@ def process_OCO2_data(OCO2_obs_folder, output_folder str e.g., /scratch/snx/[user]/ICOS_data/year/ """ - + # # Process files for day in iter_hours(start_date, end_date, 24): # Gather files - logging.info(f"Looking in folder {OCO2_obs_folder} for ICOS observation files with glob OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4") - file = list(Path(OCO2_obs_folder).glob(f"OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4")) + logging.info( + f"Looking in folder {OCO2_obs_folder} for ICOS observation files with glob OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4" + ) + file = list( + Path(OCO2_obs_folder).glob( + f"OCO2_L2_Lite*{day.strftime('%y%m%d')}*.nc4")) if not file: continue - elif len(file)>0: + elif len(file) > 0: IndexError("Error, more OCO-2 files exist than expected. Review.") - else: + else: logging.info(f'Will open data from {file}') - + # Open file s5p_data = xr.open_dataset(file[0]) - s5p_out = s5p_data[["latitude", "longitude", "date", - "xco2", "xco2_quality_flag", "xco2_averaging_kernel", "pressure_levels", - "pressure_levels", "pressure_weight", "co2_profile_apriori", "xco2_apriori", - "xco2_uncertainty" ]] - s5p_out = s5p_out.rename({"levels": "layers", - "sounding_id": "soundings", - "xco2": "obs", - "xco2_quality_flag": "quality_flag", - "xco2_averaging_kernel": "averaging_kernel", - "pressure_weight": "pressure_weighting_function", - "co2_profile_apriori": "prior_profile", - "xco2_apriori": "prior", - "xco2_uncertainty": "uncertainty"}) - s5p_out["pressure_levels"] = s5p_out.pressure_levels[:,::-1] - s5p_out["pressure_weighting_function"] = s5p_out.pressure_weighting_function[:,::-1] - s5p_out["surface_pressure"] = s5p_out.pressure_levels[:,0] + s5p_out = s5p_data[[ + "latitude", "longitude", "date", "xco2", "xco2_quality_flag", + "xco2_averaging_kernel", "pressure_levels", "pressure_levels", + "pressure_weight", "co2_profile_apriori", "xco2_apriori", + "xco2_uncertainty" + ]] + s5p_out = s5p_out.rename({ + "levels": "layers", + "sounding_id": "soundings", + "xco2": "obs", + "xco2_quality_flag": "quality_flag", + "xco2_averaging_kernel": "averaging_kernel", + "pressure_weight": "pressure_weighting_function", + "co2_profile_apriori": "prior_profile", + "xco2_apriori": "prior", + "xco2_uncertainty": "uncertainty" + }) + s5p_out["pressure_levels"] = s5p_out.pressure_levels[:, ::-1] + s5p_out[ + "pressure_weighting_function"] = s5p_out.pressure_weighting_function[:, :: + -1] + s5p_out["surface_pressure"] = s5p_out.pressure_levels[:, 0] s5p_out.attrs.update({ - 'creation_date':str(datetime.now()), - 'author':'Processing Chain', + 'creation_date': str(datetime.now()), + 'author': 'Processing Chain', 'level_def': 'pressure_boundaries', 'retrieval_id': file[0].name }) - s5p_out.to_netcdf(output_folder / f"OCO2_{day.strftime('%Y%m%d')}_ctdas.nc") \ No newline at end of file + s5p_out.to_netcdf(output_folder / + f"OCO2_{day.strftime('%Y%m%d')}_ctdas.nc") From 2d4363e8a7848041a0ea75c4b97362716f1685bf Mon Sep 17 00:00:00 2001 From: efmkoene Date: Fri, 7 Feb 2025 14:49:36 +0100 Subject: [PATCH 28/42] Updated ICBC scripts and nearly finished CTDAS preparation --- .../icon-art-CTDAS/ICBC/icon_era5_inicond.sh | 8 +- .../icon-art-CTDAS/ICBC/icon_era5_nudging.sh | 3 +- .../ICBC/icon_era5_splitfiles.sh | 4 +- .../ICBC/icon_species_inicond.sh | 20 +- .../ICBC/icon_species_nudging.sh | 22 +- cases/icon-art-CTDAS/ICON/ICON_template.job | 386 +++++++++++++++++ cases/icon-art-CTDAS/authentification.ipynb | 83 ++++ cases/icon-art-CTDAS/config.yaml | 151 ++++--- cases/icon-art-CTDAS/icon_runjob.cfg | 399 ------------------ cases/icon-art-CTDAS/map_file.ana | 109 +++++ cases/icon-art-CTDAS/wrapper_icon.sh | 1 + config.py | 20 +- env/environment.yml | 2 +- jobs/prepare_CTDAS.py | 257 ++++++++--- jobs/tools/ctdas_utilities.py | 6 +- jobs/tools/fetch_external_data.py | 25 +- jobs/tools/generate_tracers_xml.py | 90 ++++ 17 files changed, 1026 insertions(+), 560 deletions(-) create mode 100644 cases/icon-art-CTDAS/ICON/ICON_template.job create mode 100644 cases/icon-art-CTDAS/authentification.ipynb delete mode 100644 cases/icon-art-CTDAS/icon_runjob.cfg create mode 100644 cases/icon-art-CTDAS/map_file.ana create mode 120000 cases/icon-art-CTDAS/wrapper_icon.sh create mode 100644 jobs/tools/generate_tracers_xml.py diff --git a/cases/icon-art-CTDAS/ICBC/icon_era5_inicond.sh b/cases/icon-art-CTDAS/ICBC/icon_era5_inicond.sh index f74f5909..55e66776 100644 --- a/cases/icon-art-CTDAS/ICBC/icon_era5_inicond.sh +++ b/cases/icon-art-CTDAS/ICBC/icon_era5_inicond.sh @@ -2,7 +2,9 @@ cd {ERA5_folder} -module load daint-mc CDO NCO +{cfg.cdo_nco_cmd} + +set -x # --------------------------------- # -- Pre-processing @@ -172,4 +174,6 @@ rm era5_final.nc # -- Clean the repository rm weights.nc -rm triangular-grid.nc \ No newline at end of file +rm triangular-grid.nc + +{cfg.cdo_nco_cmd_post} \ No newline at end of file diff --git a/cases/icon-art-CTDAS/ICBC/icon_era5_nudging.sh b/cases/icon-art-CTDAS/ICBC/icon_era5_nudging.sh index eadebe83..4befac68 100644 --- a/cases/icon-art-CTDAS/ICBC/icon_era5_nudging.sh +++ b/cases/icon-art-CTDAS/ICBC/icon_era5_nudging.sh @@ -2,7 +2,7 @@ cd {ERA5_folder} -module load daint-mc NCO CDO +{cfg.cdo_nco_cmd} # --------------------------------- # -- Pre-processing @@ -60,3 +60,4 @@ rm era5_final.nc rm weights.nc rm triangular-grid.nc +{cfg.cdo_nco_cmd_post} \ No newline at end of file diff --git a/cases/icon-art-CTDAS/ICBC/icon_era5_splitfiles.sh b/cases/icon-art-CTDAS/ICBC/icon_era5_splitfiles.sh index 44a804d8..e08682a0 100644 --- a/cases/icon-art-CTDAS/ICBC/icon_era5_splitfiles.sh +++ b/cases/icon-art-CTDAS/ICBC/icon_era5_splitfiles.sh @@ -2,7 +2,7 @@ cd {ERA5_folder} -module load daint-mc CDO NCO +{cfg.cdo_nco_cmd} # Loop over ml and surf files for ml_file in {ml_files}; do @@ -36,3 +36,5 @@ for surf_file in {surf_files}; do let y=$y+1 done done + +{cfg.cdo_nco_cmd_post} \ No newline at end of file diff --git a/cases/icon-art-CTDAS/ICBC/icon_species_inicond.sh b/cases/icon-art-CTDAS/ICBC/icon_species_inicond.sh index 3de88f0f..79b1ef66 100644 --- a/cases/icon-art-CTDAS/ICBC/icon_species_inicond.sh +++ b/cases/icon-art-CTDAS/ICBC/icon_species_inicond.sh @@ -2,15 +2,13 @@ cd {ERA5_folder} -module load daint-mc CDO -source ~/miniconda3/bin/activate -conda init bash -source ~/.bashrc -conda activate /scratch/snx3000/ekoene/conda/NCO +{cfg.cdo_nco_cmd} + +set -x # 1. Remap cdo griddes {inicond_filename} > triangular-grid.txt -cdo remapnn,triangular-grid.txt {CAMS_file} cams_triangle.nc +cdo remapbil,triangular-grid.txt {CAMS_file} cams_triangle.nc # 2. Write out the hybrid levels cat >CAMS_levels.txt < triangular-grid.txt -cdo remapnn,triangular-grid.txt {CAMS_file} cams_triangle.nc +cdo remapbil,triangular-grid.txt {CAMS_file} cams_triangle.nc # 2. Write out the hybrid levels cat >CAMS_levels.txt < NAMELIST_ICONSUB << EOF_1 ORDER = "lateral_boundary", grf_info_file = '{cfg.input_files_scratch_dynamics_grid_filename}', min_refin_c_ctrl = 1 - max_refin_c_ctrl = 42 + max_refin_c_ctrl = 120 / EOF_1 -{cfg.iconsub_bin} --nml NAMELIST_ICONSUB +iconsub --nml NAMELIST_ICONSUB + cdo selgrid,2 lateral_boundary.grid.nc triangular-grid_00_lbc.nc cdo remapdis,triangular-grid_00_lbc.nc tmp.nc {era5_cams_nudge_file} ncrename -d cell,ncells {era5_cams_nudge_file} -ncrename -d nv,vertices {era5_cams_nudge_file} \ No newline at end of file +ncrename -d nv,vertices {era5_cams_nudge_file} +{cfg.cdo_nco_cmd_post} diff --git a/cases/icon-art-CTDAS/ICON/ICON_template.job b/cases/icon-art-CTDAS/ICON/ICON_template.job new file mode 100644 index 00000000..94993e4c --- /dev/null +++ b/cases/icon-art-CTDAS/ICON/ICON_template.job @@ -0,0 +1,386 @@ +#!/bin/bash -l +#SBATCH --uenv="icon-wcp/v1:rc4" +#SBATCH --job-name="{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.forecasttime}" +#SBATCH --time=00:40:00 +#SBATCH --account={cfg.compute_account} +#SBATCH --nodes={cfg.nodes} +#SBATCH --ntasks-per-node={cfg.ntasks_per_node} +#SBATCH --ntasks-per-core=1 +#SBATCH --cpus-per-task=1 +#SBATCH --partition={cfg.compute_queue} +#SBATCH --constraint={cfg.constraint} +#SBATCH --chdir={cfg.icon_work} + +export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK + +dtime=120 # Ensure dtime is defined +dt_rad=$(( 4 * dtime )) +dt_conv=$(( 1 * dtime )) +dt_sso=$(( 2 * dtime )) +dt_gwd=$(( 2 * dtime )) + +# ---------------------------------------------------------------------------- +# create ICON master namelist +# ---------------------------------------------------------------------------- + +cat > icon_master.namelist << EOF +! master_nml: ---------------------------------------------------------------- +&master_nml + lrestart = .FALSE. ! .TRUE.=current experiment is resumed +/ + +! master_model_nml: repeated for each model ---------------------------------- +&master_model_nml + model_type = 1 ! identifies which component to run (atmosphere,ocean,...) + model_name = "ATMO" ! character string for naming this component. + model_namelist_filename = "NAMELIST_NWP" ! file name containing the model namelists + model_min_rank = 1 ! start MPI rank for this model + model_max_rank = 65536 ! end MPI rank for this model + model_inc_rank = 1 ! stride of MPI ranks +/ + +! time_nml: specification of date and time------------------------------------ +&time_nml + ini_datetime_string = "{ini_restart_string}" ! initial date and time of the simulation + end_datetime_string = "{ini_restart_end_string}" ! end date and time of the simulation 10T00 +/ +EOF + +# ---------------------------------------------------------------------- +# model namelists +# ---------------------------------------------------------------------- + +cat > NAMELIST_NWP << EOF +! parallel_nml: MPI parallelization ------------------------------------------- +¶llel_nml + nblocks_c = 1 + nproma_sub = 800 ! loop chunk length + p_test_run = .FALSE. ! .TRUE. means verification run for MPI parallelization + num_io_procs = 1 ! number of I/O processors + num_restart_procs = 0 ! number of restart processors + num_prefetch_proc = 1 ! number of processors for LBC prefetching + iorder_sendrecv = 3 ! sequence of MPI send/receive calls +/ + + +! run_nml: general switches --------------------------------------------------- +&run_nml + ltestcase = .FALSE. ! real case run + num_lev = 60 ! number of full levels (atm.) for each domain + lvert_nest = .FALSE. ! no vertical nesting + dtime = $(( dtime )) ! timestep in seconds + ldynamics = .TRUE. ! compute adiabatic dynamic tendencies + ltransport = .TRUE. ! compute large-scale tracer transport + ntracer = 0 ! number of advected tracers + iforcing = 3 ! forcing of dynamics and transport by parameterized processes + msg_level = 2 ! detailed report during integration + ltimer = .TRUE. ! timer for monitoring the runtime of specific routines + timers_level = 10 ! performance timer granularity + check_uuid_gracefully = .TRUE. ! give only warnings for non-matching uuids + output = "nml" ! main switch for enabling/disabling components of the model output + lart = .TRUE. ! main switch for ART + debug_check_level = 2 +/ + +! art_nml: Aerosols and Reactive Trace gases extension------------------------------------------------- +&art_nml + lart_chem = .TRUE. ! enables chemistry + lart_pntSrc = .FALSE. ! enables point sources + lart_aerosol = .FALSE. ! main switch for the treatment of atmospheric aerosol + lart_chemtracer = .TRUE. ! main switch for the treatment of chemical tracer + lart_diag_out = .TRUE. ! + iart_seasalt = 0 ! enable seasalt + iart_init_gas = 4 ! Test versus '4' + cart_cheminit_file = "{inifile_nc}" + cart_chemtracer_xml = '{tracers_xml}' ! path to xml file for passive tracers + cart_cheminit_coord = '{inifile_nc}' + cart_cheminit_type = 'ERA' +/ + +! oem_nml: online emission module --------------------------------------------- +&oemctrl_nml + gridded_emissions_nc = '{emissionsgrid_nc}' + vertical_profile_nc = '{vertical_profile_nc}' + hour_of_year_nc = '{hour_of_year_nc}' + ens_lambda_nc = '{lambda_nc}' + ens_reg_nc = '{lambda_regions_nc}' + boundary_lambda_nc = '{bg_lambda_nc}' + boundary_regions_nc = '{bg_lambda_regions_nc}' + vegetation_indices_nc = '{vprm_coeffs_nc}' + chem_restart_nc = '{restart_file}' + restart_init_time = {restart_init_time} + vprm_par = 452.0801019142973, 356.9982743495175, 444.35135030708693, 483.71014017898636, 6.820000E+02, 549.8142194931744, 545.613483159301, 0.0E+00 + vprm_lambda = -0.1976385733575807, -0.16249650220700065, -0.15183296864822501, -0.12614291858843657, -1.141000E-01, -0.10418834453782252, -0.13114180960813507, 0.0E+00 + vprm_alpha = 0.3002548628277834, 0.22150160044981743, 0.20130383953759856, 0.238064533552737, 4.900000E-03, 0.19239326299324863, 0.405695555089534, 0.0E+00 + vprm_beta = 0.6884293574708447, 1.0916535677003347, 1.7074258216614222, 0.18946623368956772, 0.000000E+00, 0.17642838146641998, 0.41774465249044423, 0.0E+00 + vprm_tmin = 0.0, 0.0, 0.0, 2.0, 2.0, 5.0, 2.0, 0.0 + vprm_tmax = 40.0, 40.0, 40.0, 40.0, 40.0, 40.0, 40.0, 0.0 + vprm_topt = 20.0, 20.0, 20.0, 20.0, 20.0, 22.0, 18.0, 0.0 + vprm_tlow = 4.0, 0.0, 2.0, 4.0, 0.0, 0.0, 0.0, 0.0 +/ + + +! diffusion_nml: horizontal (numerical) diffusion ---------------------------- +&diffusion_nml + lhdiff_vn = .TRUE. ! diffusion on the horizontal wind field + lhdiff_temp = .TRUE. ! diffusion on the temperature field + lhdiff_w = .TRUE. ! diffusion on the vertical wind field + hdiff_order = 5 ! order of nabla operator for diffusion + itype_vn_diffu = 1 ! reconstruction method used for Smagorinsky diffusion + itype_t_diffu = 2 ! discretization of temperature diffusion + hdiff_efdt_ratio = 24.0 ! ratio of e-folding time to time step + hdiff_smag_fac = 0.025 ! scaling factor for Smagorinsky diffusion +/ + +! dynamics_nml: dynamical core ----------------------------------------------- +&dynamics_nml + iequations = 3 ! type of equations and prognostic variables + divavg_cntrwgt = 0.50 ! weight of central cell for divergence averaging + lcoriolis = .TRUE. ! Coriolis force +/ + +! extpar_nml: external data -------------------------------------------------- +&extpar_nml + itopo = 1 ! topography (0:analytical) + extpar_filename = '{cfg.input_files_scratch_extpar_filename}' ! filename of external parameter input file + n_iter_smooth_topo = 1,1 ! iterations of topography smoother + hgtdiff_max_smooth_topo = 750.0, 750.0 ! see Namelist doc + heightdiff_threshold = 2250.0, 1500.0 ! see Namelist doc +/ + +! initicon_nml: specify read-in of initial state ------------------------------ +&initicon_nml + init_mode = 2 + lread_ana = .false. + ltile_coldstart = .true. + ltile_init = .false. + ifs2icon_filename = '{inifile_nc}' + ana_varnames_map_file = '{cfg.input_files_scratch_map_filename}' +/ + +! grid_nml: horizontal grid -------------------------------------------------- +&grid_nml + dynamics_grid_filename = "{cfg.input_files_scratch_dynamics_grid_filename}" ! array of the grid filenames for the dycore + radiation_grid_filename = "{cfg.input_files_scratch_radiation_grid_filename}" ! array of the grid filenames for the radiation model + dynamics_parent_grid_id = 0 ! array of the indexes of the parent grid filenames + lredgrid_phys = .TRUE. ! .true.=radiation is calculated on a reduced grid + lfeedback = .TRUE. ! specifies if feedback to parent grid is performed + l_limited_area = .TRUE. ! .TRUE. performs limited area run + ifeedback_type = 2 ! feedback type (incremental/relaxation-based) + start_time = 0. ! Time when a nested domain starts to be active [s] +/ + +! gridref_nml: grid refinement settings -------------------------------------- +&gridref_nml + denom_diffu_v = 150. ! denominator for lateral boundary diffusion of velocity +/ + +! interpol_nml: settings for internal interpolation methods ------------------ +&interpol_nml + nudge_zone_width = 42 ! width of lateral boundary nudging zone + support_baryctr_intp = .FALSE. ! barycentric interpolation support for output + nudge_max_coeff = 0.069 + nudge_efold_width = 2.0 +/ + + +! io_nml: general switches for model I/O ------------------------------------- +&io_nml + itype_pres_msl = 5 ! method for computation of mean sea level pressure + itype_rh = 1 ! method for computation of relative humidity + lmask_boundary = .TRUE. ! mask out interpolation zone in output +/ + +! limarea_nml: settings for limited area mode --------------------------------- +&limarea_nml + itype_latbc = 1 ! 1: time-dependent lateral boundary conditions + dtime_latbc = 10800 ! time difference between 2 consecutive boundary data + latbc_boundary_grid = "{latbc_boundary_grid_nc}" ! Grid file defining the lateral boundary + latbc_path = "{cfg.icon_input_icbc}" ! Absolute path to boundary data + latbc_varnames_map_file = "{cfg.input_files_scratch_map_filename}" + latbc_filename = "era5_nudge_.nc" ! boundary data input filename + init_latbc_from_fg = .FALSE. ! .TRUE.: take lbc for initial time from first guess +/ + +! lnd_nml: land scheme switches ----------------------------------------------- +&lnd_nml + ntiles = 3 ! number of tiles + nlev_snow = 3 ! number of snow layers + lmulti_snow = .FALSE. ! .TRUE. for use of multi-layer snow model + idiag_snowfrac = 20 ! type of snow-fraction diagnosis + lsnowtile = .TRUE. ! .TRUE.=consider snow-covered and snow-free separately + itype_root = 2 ! root density distribution + itype_heatcond = 3 ! type of soil heat conductivity + itype_lndtbl = 4 ! table for associating surface parameters + itype_evsl = 4 ! type of bare soil evaporation + cwimax_ml = 5.e-4 ! scaling parameter for max. interception storage + c_soil = 1.75 ! surface area density of the evaporative soil surface + c_soil_urb = 0.5 ! same for urban areas + lseaice = .TRUE. ! .TRUE. for use of sea-ice model + llake = .TRUE. ! .TRUE. for use of lake model +/ + +! nonhydrostatic_nml: nonhydrostatic model ----------------------------------- +&nonhydrostatic_nml + iadv_rhotheta = 2 ! advection method for rho and rhotheta + ivctype = 2 ! type of vertical coordinate + itime_scheme = 4 ! time integration scheme + ndyn_substeps = 5 ! number of dynamics steps per fast-physics step + exner_expol = 0.333 ! temporal extrapolation of Exner function + vwind_offctr = 0.2 ! off-centering in vertical wind solver + damp_height = 12250.0 ! height at which Rayleigh damping of vertical wind starts + rayleigh_coeff = 1.5 ! Rayleigh damping coefficient + divdamp_order = 24 ! order of divergence damping + divdamp_type = 3 ! type of divergence damping + divdamp_fac = 0.004 ! scaling factor for divergence damping + igradp_method = 3 ! discretization of horizontal pressure gradient + l_zdiffu_t = .TRUE. ! specifies computation of Smagorinsky temperature diffusion + thslp_zdiffu = 0.02 ! slope threshold (temperature diffusion) + thhgtd_zdiffu = 125.0 ! threshold of height difference (temperature diffusion) + htop_moist_proc = 22500.0 ! max. height for moist physics + hbot_qvsubstep = 22500.0 ! height above which QV is advected with substepping scheme +/ + +! nwp_phy_nml: switches for the physics schemes ------------------------------ +&nwp_phy_nml + inwp_gscp = 2 ! cloud microphysics and precipitation + inwp_convection = 1 ! convection + lshallowconv_only = .FALSE. ! only shallow convection + inwp_radiation = 4 ! radiation + inwp_cldcover = 1 ! cloud cover scheme for radiation + inwp_turb = 1 ! vertical diffusion and transfer + inwp_satad = 1 ! saturation adjustment + inwp_sso = 1 ! subgrid scale orographic drag + inwp_gwd = 0 ! non-orographic gravity wave drag + inwp_surface = 1 ! surface scheme + latm_above_top = .TRUE. ! take into account atmosphere above model top for radiation computation + ldetrain_conv_prec = .TRUE. + efdt_min_raylfric = 7200. ! minimum e-folding time of Rayleigh friction + itype_z0 = 2 ! type of roughness length data + icapdcycl = 3 ! apply CAPE modification to improve diurnalcycle over tropical land + icpl_aero_conv = 1 ! coupling between autoconversion and Tegen aerosol climatology + icpl_aero_gscp = 1 ! coupling between autoconversion and Tegen aerosol climatology + dt_rad = $((dt_rad)) ! time step for radiation in s + dt_conv = $((dt_conv)) ! time step for convection in s (domain specific) + dt_sso = $((dt_sso)) ! time step for SSO parameterization + dt_gwd = $((dt_gwd)) ! time step for gravity wave drag parameterization +/ + +! nwp_tuning_nml: additional tuning parameters ---------------------------------- +&nwp_tuning_nml + itune_albedo = 1 ! reduced albedo (w.r.t. MODIS data) over Sahara + tune_gkwake = 1.8 + tune_gkdrag = 0.0 + tune_minsnowfrac = 0.3 +/ + +! radiation_nml: radiation scheme --------------------------------------------- +&radiation_nml + ecrad_isolver = 2 + irad_o3 = 7 ! ozone climatology + irad_aero = 6 ! aerosols + albedo_type = 2 ! type of surface albedo + vmr_co2 = 390.e-06 + vmr_ch4 = 1800.e-09 + vmr_n2o = 322.0e-09 + vmr_o2 = 0.20946 + vmr_cfc11 = 240.e-12 + vmr_cfc12 = 532.e-12 + direct_albedo_water = 3 + albedo_whitecap = 1 + ecrad_data_path = '/capstor/scratch/cscs/nponomar/icon-kit/externals/ecrad/data' +/ + +! sleve_nml: vertical level specification ------------------------------------- +&sleve_nml + min_lay_thckn = 20.0 ! layer thickness of lowermost layer + top_height = 23000.0 ! height of model top + stretch_fac = 0.65 ! stretching factor to vary distribution of model levels + decay_scale_1 = 4000.0 ! decay scale of large-scale topography component + decay_scale_2 = 2500.0 ! decay scale of small-scale topography component + decay_exp = 1.2 ! exponent of decay function + flat_height = 16000.0 ! height above which the coordinate surfaces are flat +/ + +! transport_nml: tracer transport --------------------------------------------- +&transport_nml + ivadv_tracer = 3, 3, 3, 3, 3, 3 ! tracer specific method to compute vertical advection + itype_hlimit = 3, 4, 4, 4, 4, 4 ! type of limiter for horizontal transport + ihadv_tracer = 52, 2, 2, 2, 2, 2 ! tracer specific method to compute horizontal advection + llsq_svd = .TRUE. ! use SV decomposition for least squares design matrix +/ + +! turbdiff_nml: turbulent diffusion ------------------------------------------- +&turbdiff_nml + tkhmin = 0.75 ! scaling factor for minimum vertical diffusion coefficient + tkmmin = 0.75 ! scaling factor for minimum vertical diffusion coefficient + pat_len = 750.0 ! effective length scale of thermal surface patterns + c_diff = 0.2 ! length scale factor for vertical diffusion of TKE + rat_sea = 0.8 ! controls laminar resistance for sea surface + ltkesso = .TRUE. ! consider TKE-production by sub-grid SSO wakes + frcsmot = 0.2 ! these 2 switches together apply vertical smoothing of the TKE source terms + imode_frcsmot = 2 ! in the tropics (only), which reduces the moist bias in the tropical lower troposphere + itype_sher = 3 ! type of shear forcing used in turbulence + ltkeshs = .TRUE. ! include correction term for coarse grids in hor. shear production term + a_hshr = 2.0 ! length scale factor for separated horizontal shear mode + icldm_turb = 1 ! mode of cloud water representation in turbulence + ldiff_qi = .TRUE. +/ + +! output_nml: specifies an output stream -------------------------------------- +&output_nml + filetype = 4 ! output format: 2=GRIB2, 4=NETCDFv2 + dom = 1 ! write domain 1 only + output_bounds = 0., 10000000., 3600. ! start, end, increment + steps_per_file = 1 ! number of steps per file + mode = 1 ! 1: forecast mode (relative t-axis), 2: climate mode (absolute t-axis) + include_last = .TRUE. + output_filename = 'ICON-ART-UNSTR' + filename_format = '{output_directory}/_' ! file name base + steps_per_file_inclfirst = .FALSE. + output_grid = .TRUE. + remap = 0 ! 1: remap to lat-lon grid + !north_pole = -170.,40. ! definition of north_pole for rotated lat-lon grid + reg_lon_def = -8.25,0.05,17.65 ! + reg_lat_def = 40.75,0.05,58.85 ! + ml_varlist = 'group:PBL_VARS', + 'group:ATMO_ML_VARS', + 'group:precip_vars', + 'group:land_vars', + 'group:nh_prog_vars', + 'group:ART_CHEMISTRY', + 'z_mc', 'z_ifc', + 'topography_c', + 'group:ART_PASSIVE', + 'group:ART_AEROSOL' +/ + +! output_nml: specifies an output stream -------------------------------------- +&output_nml + filetype = 4 ! output format: 2=GRIB2, 4=NETCDFv2 + dom = 1 ! write domain 1 only + output_bounds = {output_init}, 10000000., 604800. ! start, end, increment 518400 + steps_per_file = 1 ! number of steps per file + mode = 1 ! 1: forecast mode (relative t-axis), 2: climate mode (absolute t-axis) + include_last = .TRUE. + output_filename = 'ICON-ART-OEM-INIT' + filename_format = '{output_directory}/_' ! file name base + steps_per_file_inclfirst = .FALSE. + output_grid = .TRUE. + remap = 0 ! 1: remap to lat-lon grid + ml_varlist = 'group:ART_CHEMISTRY' +/ +EOF + +handle_error(){{ + set +e + # Check for invalid pointer error at the end of icon-art + if grep -q "free(): invalid pointer" {cfg.logfile} && grep -q "clean-up finished" {cfg.logfile}; then + exit 0 + else + exit 1 + fi + set -e +}} +cp {cfg.icon_executable} icon +srun ../input/wrapper_icon.sh ./icon || handle_error \ No newline at end of file diff --git a/cases/icon-art-CTDAS/authentification.ipynb b/cases/icon-art-CTDAS/authentification.ipynb new file mode 100644 index 00000000..8e8ffd64 --- /dev/null +++ b/cases/icon-art-CTDAS/authentification.ipynb @@ -0,0 +1,83 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# For access to the NASA Earthdata API, you need to create a .netrc file in your home directory.\n", + "# This script will create the file and prompt you for your NASA Earthdata login credentials.\n", + "from getpass import getpass\n", + "import os\n", + "from subprocess import Popen\n", + "urs = 'urs.earthdata.nasa.gov' # Earthdata URL to call for authentication\n", + "prompts = ['Enter NASA Earthdata Login Username \\n(or create an account at urs.earthdata.nasa.gov): ',\n", + " 'Enter NASA Earthdata Login Password: ']\n", + "homeDir = os.path.expanduser(\"~\") + os.sep\n", + "with open(homeDir + '.netrc', 'w') as file:\n", + " file.write('machine {} login {} password {}'.format(urs, getpass(prompt=prompts[0]), getpass(prompt=prompts[1])))\n", + " file.close()\n", + "with open(homeDir + '.urs_cookies', 'w') as file:\n", + " file.write('')\n", + " file.close()\n", + "with open(homeDir + '.dodsrc', 'w') as file:\n", + " file.write('HTTP.COOKIEJAR={}.urs_cookies\\n'.format(homeDir))\n", + " file.write('HTTP.NETRC={}.netrc'.format(homeDir))\n", + " file.close()\n", + "Popen('chmod og-rw ~/.netrc', shell=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Log in to https://cpauth.icos-cp.eu , tick \"I accept the ICOS data license\" and then \"Save profile\" to be allowed data downloading. \n", + "# Then run this cell to save a configuration file that will be used by the icoscp package to download data.\n", + "from icoscp_core.icos import auth\n", + "auth.init_config_file()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "proc-chain", + "language": "python", + "name": "python3" + }, + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/cases/icon-art-CTDAS/config.yaml b/cases/icon-art-CTDAS/config.yaml index ed273877..6dd8afcd 100644 --- a/cases/icon-art-CTDAS/config.yaml +++ b/cases/icon-art-CTDAS/config.yaml @@ -1,14 +1,46 @@ # Configuration file for the 'icon-art-CTDAS' case with ICON +# From the `icon-wcp` environment: +# - spack install nco@4.9.0 +# - spack install icontools@c2sm-master%gcc +# - spack install cdo + workflow: icon constraint: gpu run_on: cpu compute_queue: normal -ntasks_per_node: 12 +nodes: 2 +ntasks_per_node: 4 startdate: 2018-01-01T00:00:00Z enddate: 2018-12-31T23:59:59Z restart_step: PT10D # = CTDAS cycle length +####### Tracer options +# The tracers XML file will be generated on-the-fly +tracers: + TRCO2_A: + oem_cat: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" + oem_vp: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" + oem_tp: "GNFR_A-CO2, GNFR_B-CO2, GNFR_C-CO2, GNFR_D-CO2, GNFR_A-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_G-CO2, GNFR_H-CO2, GNFR_I-CO2, GNFR_J-CO2, GNFR_L-CO2, L-CO2" + TRCO2_BG: + init_name: "CO2" + CO2_RA: + oem_ftype: "resp" + CO2_GPP: + oem_ftype: "gpp" + TRCO2_A-XXX: + bg: "TRCO2_BG" + ra: "CO2_RA" + gpp: "CO2_GPP" + biosource: + oem_cat: "co2fire, allcropsource, allwoodsource, lakeriveremis, cflx" + oem_vp: "A-CO2, A-CO2, A-CO2, A-CO2, A-CO2" + oem_tp: "GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2" + biosink: + oem_cat: "biofuelcropsource, biofuelwoodsource, mflx" + oem_vp: "A-CO2, A-CO2, A-CO2" + oem_tp: "GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2" + ####### CTDAS options. # First of all, download https://git.wur.nl/ctdas/CTDAS/-/tree/ctdas-icon # (i.e., CTDAS with the ctdas-icon branch). @@ -26,70 +58,74 @@ CTDAS: nlag: 2 tracer: co2 regions: basegrid # choose: basegrid or parentgrid - nensembles: 180 + nensembles: 186 # nregions: # read from cells->regions file restart_init_time: 86400 # 1 day in seconds; using Michael Steiner's "overwriting" restart mechanism + ctdas_cycle: 10 # days nboundaries: 8 lambdas: # The first 16 lambdas must be the respiration and uptake ones [even if not relevant, e.g., for a CH4 simulation], followed by the oem_cat categories in the xml file, in order of appearance, but excluding any - 1,1,1,1,1,1,1,1 # Respiration (Evergreen Forest, Deciduous Forest, Mixed Forest, Shrubland, Savanna, Cropland, Grassland, Urban/Other) - 1,1,1,1,1,1,1,1 # Uptake (E, D, M, S, SV, C, G, U) - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2 # Anthropogenic CO2 (ensemble tracer categories that are optimized) obs: + # Run the 'authentification.ipynb' notebook to get access to ICOS and/or NASA Earthdata (OCO2) data fetch_ICOS: True - # From https://cpauth.icos-cp.eu - ICOS_cookie_token: cpauthToken=WzE3MzM5NDQ3ODY3MTMsImVyaWsua29lbmVAZW1wYS5jaCIsIlNhbWwiXR6qePH9961Ih4LRBIu9/o+z/K7OSbvSf3EKUqpHA8orTrPjUMcuWrhmFbcVZeZPJ6uHY45go7BivHNShHkeF02yXrsC9MaYschekdvPvO4K9a4u+oqYi4M9J/s4Xv9LGsGTeHytuXhnfzdRtPKY9dykeW/bS6Gy4Rmou4+xJpf//kDajrNBy4Z0Z6Lrj1csQibe+cYjDObplLmDVs1NufUxyorCL6XbhaI2RLqaAvDWUqQ9A8kpbSJvW8Mdxit+6gDg+6gfnBrKFgL9Bs9VGkOjGKEmNUbn6XzBqPfMnt2NWnxsXyK1lXtLruTWRqsPcbK2hLvw7vj7iTUSDMpLQ1ew - ICOS_path: /scratch/snx3000/ekoene/ICOS/ + ICOS_path: /capstor/scratch/cscs/ekoene/ICOS/ fetch_OCO2: True - OCO2_path: /scratch/snx3000/ekoene/OCO2 + OCO2_path: /capstor/scratch/cscs/ekoene/OCO2 global_inputs: inventories: - - /users/ekoene/inventories/inventories/INV_20180101.nc - - /users/ekoene/inventories/inventories/INV_20180111.nc - - /users/ekoene/inventories/inventories/INV_20180121.nc - - /users/ekoene/inventories/inventories/INV_20180131.nc - - /users/ekoene/inventories/inventories/INV_20180210.nc - - /users/ekoene/inventories/inventories/INV_20180220.nc - - /users/ekoene/inventories/inventories/INV_20180302.nc - - /users/ekoene/inventories/inventories/INV_20180312.nc - - /users/ekoene/inventories/inventories/INV_20180322.nc - - /users/ekoene/inventories/inventories/INV_20180401.nc - - /users/ekoene/inventories/inventories/INV_20180411.nc - - /users/ekoene/inventories/inventories/INV_20180421.nc - - /users/ekoene/inventories/inventories/INV_20180501.nc - - /users/ekoene/inventories/inventories/INV_20180511.nc - - /users/ekoene/inventories/inventories/INV_20180521.nc - - /users/ekoene/inventories/inventories/INV_20180531.nc - - /users/ekoene/inventories/inventories/INV_20180610.nc - - /users/ekoene/inventories/inventories/INV_20180620.nc - - /users/ekoene/inventories/inventories/INV_20180630.nc - - /users/ekoene/inventories/inventories/INV_20180710.nc - - /users/ekoene/inventories/inventories/INV_20180720.nc - - /users/ekoene/inventories/inventories/INV_20180730.nc - - /users/ekoene/inventories/inventories/INV_20180809.nc - - /users/ekoene/inventories/inventories/INV_20180819.nc - - /users/ekoene/inventories/inventories/INV_20180829.nc - - /users/ekoene/inventories/inventories/INV_20180908.nc - - /users/ekoene/inventories/inventories/INV_20180918.nc - - /users/ekoene/inventories/inventories/INV_20180928.nc - - /users/ekoene/inventories/inventories/INV_20181008.nc - - /users/ekoene/inventories/inventories/INV_20181018.nc - - /users/ekoene/inventories/inventories/INV_20181028.nc - - /users/ekoene/inventories/inventories/INV_20181107.nc - - /users/ekoene/inventories/inventories/INV_20181117.nc - - /users/ekoene/inventories/inventories/INV_20181127.nc - - /users/ekoene/inventories/inventories/INV_20181207.nc - - /users/ekoene/inventories/inventories/INV_20181217.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180102.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180112.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180122.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180201.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180211.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180221.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180303.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180313.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180323.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180402.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180412.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180422.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180502.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180512.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180522.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180601.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180611.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180621.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180701.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180711.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180721.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180731.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180810.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180820.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180830.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180909.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180919.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180929.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181009.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181019.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181029.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181108.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181118.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181128.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181208.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181218.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181228.nc grid: - /users/ekoene/CTDAS_inputs/icon_europe_DOM01.parent.nc - /users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc - - ./work/icon-art-CTDAS/global_inputs/ERA5/lateral_boundary.grid.nc # This is guaranteed to exist due to the ERA5/CAMS preprocessing + - ERA5/lateral_boundary.grid.nc # This is guaranteed to exist due to the ERA5/CAMS preprocessing extpar: - /users/ekoene/CTDAS_inputs/icon_extpar_EriksGrid.nc VPRM: - /users/ekoene/CTDAS_inputs/VPRM_indices_ICON_datestr.nc - XML: - - /users/ekoene/CTDAS_inputs/tracers_CO2_firstrun.xml - - /users/ekoene/CTDAS_inputs/tracers_CO2_restart.xml + OEM: + - /capstor/scratch/cscs/ekoene/inventories/icon_with_tno_emissions/vertical_profiles.nc + - /capstor/scratch/cscs/ekoene/inventories/icon_with_tno_emissions/hourofyear.nc + # - /users/ekoene/CTDAS_inputs/vertical_profiles_t.nc + # - /users/ekoene/CTDAS_inputs/hourofyear8784.nc + # # CTDAS ------------------------------------------------------------------------ # ctdas_restart = False @@ -103,7 +139,6 @@ CTDAS: # ctdas_regionsfile = vprm_regions_synth_nc # <--- Create # # Number of boundaries, and boundaries mask/regions file # ctdas_bg_params = 8 -# ctdas_boundary_mask_file = '/scratch/snx3000/ekoene/boundary_mask_bg.nc' # # Number of ensemble members (make this consistent with your XML file!) # ctdas_optimizer_nmembers = 180 # # CTDAS path @@ -128,7 +163,6 @@ CTDAS: # ctdas_oae_grid = "/scratch/snx3000/ekoene/inventories/INV_{}.nc" # ctdas_oae_grid_fname = '%Y%m%d' # Specifies the naming scheme to use for the emission grids # # Spinup time length -# ctdas_restart_init_time = 60 * 60 * 24 # 1 day in seconds # # Restart file for the first simulation # ctdas_first_restart_init = '/scratch/snx3000/ekoene/processing-chain/work/VPRM_EU_ERA5_22/2018010100_0_240/icon/output_INIT' # # Number of vertical levels @@ -138,9 +172,15 @@ CTDAS: # ctdas_obsoperator_rc = os.path.join(ctdas_obsoperator_home, 'stilt_0.rc') # ctdas_regtype = 'olson19_oif30' +cdo_nco_cmd: | + CLUSTER_NAME=todi uenv start icon-wcp --ignore-tty << 'EOF' + . /capstor/scratch/cscs/ekoene/tmp/spack-c2sm/setup-env.sh /user-environment/ + spack load icontools cdo nco + +cdo_nco_cmd_post: | + EOF + eccodes_dir: ./input/eccodes_definitions -iconremap_bin: ./ext/icontools/icontools/iconremap -iconsub_bin: /scratch/snx3000/ekoene/spack-c2sm/spack/opt/spack/icontools-c2sm-master/gcc-9.3.0/zktezcs5cjwjsptd747zhipi53nd6phr/bin/iconsub art_input_folder: ./input/icon-art-oem/ART walltime: @@ -172,13 +212,12 @@ input_files: radiation_grid_filename: /users/ekoene/CTDAS_inputs/icon_europe_DOM01.parent.nc dynamics_grid_filename: /users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc extpar_filename: /users/ekoene/CTDAS_inputs/icon_extpar_EriksGrid.nc - cldopt_filename: ./input/icon-art-global/rad/ECHAM6_CldOptProps.nc - lrtm_filename: ./input/icon-art-global/rad/rrtmg_lw.nc - chemtracer_xml_filename: ./input/icon-art-global/config/tracers.xml + map_filename: ./cases/icon-art-CTDAS/map_file.ana + wrapper_filename: ./cases/icon-art-CTDAS/wrapper_icon.sh -# icon: -# binary_file: ./ext/icon-art/bin/icon -# runjob_filename: icon_runjob.cfg +icon: + executable: /capstor/scratch/cscs/ekoene/spack-c2sm/spack/opt/spack/linux-sles15-neoverse_v2/nvhpc-24.3/icon-develop-sytqk6o7h5y3imrsevsswc2inxaegbpx/bin/icon + runjob_filename: ICON/ICON_template.job # # era5_inijob: icon_era5_inicond.sh # # era5_nudgingjob: icon_era5_nudging.sh # species_inijob: icon_species_inicond.sh diff --git a/cases/icon-art-CTDAS/icon_runjob.cfg b/cases/icon-art-CTDAS/icon_runjob.cfg deleted file mode 100644 index 4233ff08..00000000 --- a/cases/icon-art-CTDAS/icon_runjob.cfg +++ /dev/null @@ -1,399 +0,0 @@ -#!/usr/bin/env bash -#SBATCH --job-name=icon -#SBATCH --account={cfg.compute_account} -#SBATCH --time={cfg.walltime_icon} -#SBATCH --nodes={cfg.icon_np_tot} -#SBATCH --ntasks-per-node={cfg.ntasks_per_node} -#SBATCH --partition={cfg.compute_queue} -#SBATCH --constraint={cfg.constraint} -#SBATCH --hint=nomultithread -#SBATCH --output={cfg.logfile} -#SBATCH --open-mode=append -#SBATCH --chdir={cfg.icon_work} - -# OpenMP environment variables -# ---------------------------- -export OMP_NUM_THREADS=1 -export ICON_THREADS=1 -export OMP_SCHEDULE=static,12 -export OMP_DYNAMIC="false" -export OMP_STACKSIZE=200M - -set -e -x - -# -- ECCODES path -export ECCODES_DEFINITION_PATH={cfg.eccodes_dir}/definitions.edzw-2.12.5-2:{cfg.eccodes_dir}/definitions - -# ---------------------------------------------------------------------------- -# Link radiation input files -# ---------------------------------------------------------------------------- -ln -sf {cfg.art_input_folder}/* . -ln -sf {cfg.art_input_folder}/* . - -# ---------------------------------------------------------------------------- -# Create ICON master namelist -# ---------------------------------------------------------------------------- - -cat > icon_master.namelist << EOF -! master_nml: ---------------------------------------------------------------- -&master_nml - lrestart = {cfg.lrestart} ! .TRUE.=current experiment is resumed - read_restart_namelists = .true. -/ - -! master_time_control_nml: --------------------------------------------------- -&master_time_control_nml - calendar = 'proleptic gregorian' - restartTimeIntval = '{cfg.restart_step}' - checkpointTimeIntval = '{cfg.restart_step}' - experimentStartDate = '{cfg.ini_datetime_string}' - experimentStopDate = '{cfg.end_datetime_string}' -/ - -! master_model_nml: repeated for each model ---------------------------------- -&master_model_nml - model_type = 1 ! identifies which component to run (atmosphere,ocean,...) - model_name = "ATMO" ! character string for naming this component. - model_namelist_filename = "NAMELIST_{cfg.casename}" ! file name containing the model namelists - model_min_rank = 1 ! start MPI rank for this model - model_max_rank = 65536 ! end MPI rank for this model - model_inc_rank = 1 ! stride of MPI ranks -/ -EOF - -# ---------------------------------------------------------------------- -# Create model namelists -# ---------------------------------------------------------------------- - -cat > NAMELIST_{cfg.casename} << EOF -! parallel_nml: MPI parallelization ------------------------------------------- -¶llel_nml - nproma = 8 ! optimal setting 8 for CRAY; use 16 or 24 for IBM - num_io_procs = 1 ! up to one PE per output stream is possible - num_prefetch_proc = 1 -/ - - -! grid_nml: horizontal grid -------------------------------------------------- -&grid_nml - dynamics_grid_filename = "{cfg.input_files_scratch_dynamics_grid_filename}" ! array of the grid filenames for the dycore - dynamics_parent_grid_id = 0 ! array of the indexes of the parent grid filenames - lredgrid_phys = .TRUE. ! .true.=radiation is calculated on a reduced grid - lfeedback = .TRUE. ! specifies if feedback to parent grid is performed - ifeedback_type = 2 ! feedback type (incremental/relaxation-based) -/ - - -! initicon_nml: specify read-in of initial state ------------------------------ -&initicon_nml - init_mode = 2 ! 2: start from IFS data - ifs2icon_filename = '{cfg.input_files_scratch_inicond_filename}' ! initial data filename - zpbl1 = 500. ! bottom height (AGL) of layer used for gradient computation - zpbl2 = 1000. ! top height (AGL) of layer used for gradient computation -/ - -! extpar_nml: external data -------------------------------------------------- -&extpar_nml - extpar_filename = '{cfg.input_files_scratch_extpar_filename}' ! filename of external parameter input file - itopo = 1 ! topography (0:analytical) - itype_vegetation_cycle = 2 ! specifics for annual cycle of LAI - n_iter_smooth_topo = 1 ! iterations of topography smoother - heightdiff_threshold = 2250. - hgtdiff_max_smooth_topo = 750. - read_nc_via_cdi = .TRUE. - itype_lwemiss = 2 -/ - -! io_nml: general switches for model I/O ------------------------------------- -&io_nml - itype_pres_msl = 5 ! method for computation of mean sea level pressure - itype_rh = 1 ! method for computation of relative humidity - lnetcdf_flt64_output = .FALSE. ! NetCDF files is written in 64-bit instead of 32-bit accuracy -/ - -! run_nml: general switches --------------------------------------------------- -&run_nml - dtime = 900 ! timestep in seconds - iforcing = 3 ! forcing of dynamics and transport by parameterized processes - lart = .TRUE. ! main switch for ART - ldynamics = .TRUE. ! compute adiabatic dynamic tendencies - ltestcase = .FALSE. ! real case run - ltimer = .FALSE. ! timer for monitoring the runtime of specific routines - ltransport = .TRUE. ! compute large-scale tracer transport - lvert_nest = .FALSE. ! vertical nesting - msg_level = 10 ! detailed report during integration - timers_level = 1 ! performance timer granularity - output = "nml" ! main switch for enabling/disabling components of the model output - num_lev = 65 ! number of full levels (atm.) for each domain -/ - -! nwp_phy_nml: switches for the physics schemes ------------------------------ -&nwp_phy_nml - lrtm_filename = '{cfg.input_files_scratch_lrtm_filename}' ! longwave absorption coefficients for RRTM_LW - cldopt_filename = '{cfg.input_files_scratch_cldopt_filename}' ! RRTM cloud optical properties - dt_rad = $(( 4 * dtime)) ! time step for radiation in s - dt_conv = $(( 1 * dtime)) ! time step for convection in s (domain specific) - dt_sso = $(( 2 * dtime)) ! time step for SSO parameterization - dt_gwd = $(( 2 * dtime)) ! time step for gravity wave drag parameterization - efdt_min_raylfric = 7200. ! minimum e-folding time of Rayleigh friction - icapdcycl = 3 ! apply CAPE modification to improve diurnalcycle over tropical land - icpl_aero_conv = 1 ! coupling between autoconversion and Tegen aerosol climatology - icpl_aero_gscp = 0 ! - icpl_o3_tp = 1 ! - inwp_cldcover = 1 ! cloud cover scheme for radiation - inwp_convection = 1 ! convection - inwp_gscp = 1 ! cloud microphysics and precipitation - inwp_gwd = 1 ! non-orographic gravity wave drag - inwp_radiation = 1 ! radiation - inwp_satad = 1 ! saturation adjustment - inwp_sso = 1 ! subgrid scale orographic drag - inwp_surface = 1 ! surface scheme - inwp_turb = 1 ! vertical diffusion and transfer - itype_z0 = 2 ! type of roughness length data - latm_above_top = .TRUE. ! take into account atmosphere above model top for radiation computation - ldetrain_conv_prec = .TRUE. ! Activate detrainment of convective rain and snowl - mu_rain = 0.5 - rain_n0_factor = 0.1 - lshallowconv_only = .FALSE. - lgrayzone_deepconv = .TRUE. ! activates shallow and deep convection but not mid-level convection, -/ - -! nwp_tuning_nml: additional tuning parameters ---------------------------------- -&nwp_tuning_nml - itune_albedo = 1 - tune_box_liq_asy = 4.0 - tune_gfrcrit = 0.333 - tune_gkdrag = 0.0 - tune_gkwake = 0.25 - tune_gust_factor = 7.0 - tune_minsnowfrac = 0.3 - tune_sgsclifac = 1.0 - tune_rcucov = 0.075 - tune_rhebc_land = 0.825 - tune_zvz0i = 0.85 - icpl_turb_clc = 2 - max_calibfac_clcl = 2.0 - tune_box_liq = 0.04 -/ - - -! turbdiff_nml: turbulent diffusion ------------------------------------------- -&turbdiff_nml - a_hshr = 2.0 ! length scale factor for separated horizontal shear mode - frcsmot = 0.2 ! these 2 switches together apply vertical smoothing of the TKE source terms - icldm_turb = 2 ! mode of cloud water representation in turbulence - imode_frcsmot = 2 ! in the tropics (only), which reduces the moist bias in the tropical lower troposphere - imode_tkesso = 2 - itype_sher = 2 - ltkeshs = .TRUE. ! type of shear forcing used in turbulence - ltkesso = .TRUE. - pat_len = 750. ! effective length scale of thermal surface patterns - q_crit = 2.0 - rat_sea = 0.8 - tkhmin = 0.5 - tkmmin = 0.75 - tur_len = 300. - rlam_heat = 10.0 - alpha1 = 0.125 -/ - -&lnd_nml - c_soil = 1.25 - c_soil_urb = 0.5 - cwimax_ml = 5.e-4 - idiag_snowfrac = 20 - itype_evsl = 4 - itype_heatcond = 3 - itype_lndtbl = 4 - itype_root = 2 - itype_snowevap = 3 - itype_trvg = 3 - llake = .TRUE. - lmulti_snow = .FALSE. - lprog_albsi = .TRUE. - itype_canopy = 2 - lseaice = .TRUE. - lsnowtile = .TRUE. - nlev_snow = 3 - ntiles = 3 - sstice_mode = 2 -/ - -! radiation_nml: radiation scheme --------------------------------------------- -&radiation_nml - albedo_type = 2 ! Modis albedo - irad_o3 = 79 ! ozone climatology - irad_aero = 6 - islope_rad = 0 - direct_albedo_water = 3 - albedo_whitecap = 1 - vmr_co2 = 407.e-06 ! values representative for 2012 - vmr_ch4 = 1857.e-09 - vmr_n2o = 330.0e-09 - vmr_o2 = 0.20946 - vmr_cfc11 = 240.e-12 - vmr_cfc12 = 532.e-12 -/ - -! nonhydrostatic_nml: nonhydrostatic model ----------------------------------- -&nonhydrostatic_nml - damp_height = 12250.0 ! height at which Rayleigh damping of vertical wind starts - divdamp_fac = 0.004 ! scaling factor for divergence damping - divdamp_order = 24 ! order of divergence damping - divdamp_type = 32 ! type of divergence damping - exner_expol = 0.6 ! temporal extrapolation of Exner function - hbot_qvsubstep = 22500.0 ! height above which QV is advected with substepping scheme - htop_moist_proc = 22500.0 ! max. height for moist physics - iadv_rhotheta = 2 ! advection method for rho and rhotheta - igradp_method = 3 ! discretization of horizontal pressure gradient - itime_scheme = 4 ! time integration scheme - ivctype = 2 ! type of vertical coordinate - l_zdiffu_t = .TRUE. ! specifies computation of Smagorinsky temperature diffusion - rayleigh_coeff = 5.0 ! Rayleigh damping coefficient - thhgtd_zdiffu = 125.0 ! threshold of height difference (temperature diffusion) - thslp_zdiffu = 0.02 ! slope threshold (temperature diffusion) - vwind_offctr = 0.2 ! off-centering in vertical wind solver -/ - -! sleve_nml: vertical level specification ------------------------------------- -&sleve_nml - decay_exp = 1.2 ! exponent of decay function - decay_scale_1 = 4000.0 ! decay scale of large-scale topography component - decay_scale_2 = 2500.0 ! decay scale of small-scale topography component - flat_height = 16000.0 ! height above which the coordinate surfaces are flat - itype_laydistr = 1 - min_lay_thckn = 20.0 ! minimum layer thickness of lowermost layer - stretch_fac = 0.65 ! stretching factor to vary distribution of model levels - htop_thcknlimit = 15000.0 - top_height = 75000.0 ! height of model top -/ - -! dynamics_nml: dynamical core ----------------------------------------------- -&dynamics_nml - divavg_cntrwgt = 0.50 ! weight of central cell for divergence averaging - iequations = 3 ! type of equations and prognostic variables - lcoriolis = .TRUE. ! Coriolis force -/ - -! transport_nml: tracer transport --------------------------------------------- -&transport_nml - ctracer_list = '12345' ! kann vermutlich raus - ihadv_tracer = 52,2,2,2,2,2 ! tracer specific method to compute horizontal advection - ivadv_tracer = 3,3,3,3,3,3 ! tracer specific method to compute vertical advection - itype_hlimit = 3,4,4,4,4,4 ! type of limiter for horizontal transport - llsq_svd = .TRUE. - beta_fct = 1.005 -/ - -! diffusion_nml: horizontal (numerical) diffusion ---------------------------- -&diffusion_nml - hdiff_efdt_ratio = 24.0 ! ratio of e-folding time to time step - hdiff_order = 5 ! order of nabla operator for diffusion - hdiff_smag_fac = 0.025 ! scaling factor for Smagorinsky diffusion - itype_t_diffu = 2 ! discretization of temperature diffusion - itype_vn_diffu = 1 ! reconstruction method used for Smagorinsky diffusion - lhdiff_vn = .TRUE. ! diffusion on the horizontal wind field - lhdiff_temp = .TRUE. ! diffusion on the temperature field -/ - -! interpol_nml: settings for internal interpolation methods ------------------ -&interpol_nml - lsq_high_ord = 3 - l_intp_c2l = .TRUE. - l_mono_c2l = .TRUE. -/ - -! nudging_nml: settings for global nudging ----------------------------------- -&nudging_nml -nudge_type = {cfg.nudge_type} ! global nudging -nudge_var = 'vn' ! variables that shall be nudged, default = all (vn,thermdyn,qv) -nudge_start_height = 0. ! Start nudging at the surface -nudge_end_height = 75000.0 ! End nudging at the top -nudge_profile = 2 -/ - -! limarea_nml: settings for global nudging ----------------------------------- -&limarea_nml -itype_latbc = 1 ! time-dependent lateral boundary conditions provided by an external source -dtime_latbc = {cfg.nudging_step_seconds} ! Time difference between two consecutive boundary data -latbc_path = '{cfg.icon_input_icbc}' ! Absolute path to boundary data -latbc_filename = 'era2icon_R2B03__nudging.nc' ! boundary data input filename -latbc_varnames_map_file = '{cfg.input_files_scratch_map_file_nudging}' ! Dictionary file which maps internal variable names onto GRIB2 shortnames or NetCDF varnames -latbc_boundary_grid = ' ' ! no boundary grid: driving data have to be available on entire grid (important to let a space) -/ - -! art_nml: Aerosols and Reactive Trace gases extension------------------------------------------------- -&art_nml - lart_diag_out = .TRUE. ! If this switch is set to .TRUE., diagnostic - ! ... output elds are available. Set it to - ! ... .FALSE. when facing memory problems. - lart_pntSrc = .TRUE. ! enables point sources - !lart_bound_cond = .FALSE. ! enables boundary conditions - lart_chem = .TRUE. ! enables chemistry - lart_chemtracer = .TRUE. ! main switch for the treatment of chemical tracer - lart_aerosol = .FALSE. ! main switch for the treatment of atmospheric aerosol - - iart_seasalt = 0 - iart_init_gas = {cfg.iart_init_gas} - cart_cheminit_type = 'EMAC' - cart_cheminit_file = '{cfg.input_files_scratch_inicond_filename}' - cart_cheminit_coord = '{cfg.input_files_scratch_inicond_filename}' - - cart_chemtracer_xml = '{cfg.input_files_scratch_chemtracer_xml_filename}' ! path to xml file for chemical tracers - cart_pntSrc_xml = '{cfg.input_files_scratch_pntSrc_xml_filename}' ! path to xml file for point sources - cart_input_folder = '{cfg.art_input_folder}' ! absolute Path to ART source code -/ - -! output_nml: specifies an output stream -------------------------------------- -&output_nml - filetype = 4 ! output format: 2=GRIB2, 4=NETCDFv2 - dom = -1 ! write all domains - output_bounds = 0.,100000000,{cfg.icon_output_writing_step} ! start, end, increment - output_time_unit = 3 ! Unit of bounds is in hours instead of seconds - steps_per_file = 1 ! number of steps per file - steps_per_file_inclfirst = .FALSE. ! First step is not accounted for in steps_per_file - include_last = .FALSE. - mode = 1 ! 1: forecast mode (relative t-axis), 2: climate mode (absolute t-axis) - output_filename = 'ICON-ART' - filename_format = '{cfg.icon_output}/_latlon_' ! file name base - remap = 1 ! 1: remap to lat-lon grid - reg_lon_def = -179.,2,179 - reg_lat_def = 89.,-2,-89. - ml_varlist = 'z_ifc','pres','qv','rho','temp','u','v','group:ART_CHEMISTRY','OH_Nconc', -/ - -! output_nml: specifies an output stream -------------------------------------- -&output_nml - filetype = 4 ! output format: 2=GRIB2, 4=NETCDFv2 - dom = -1 ! write all domains - output_bounds = 0.,100000000,{cfg.icon_output_writing_step} ! start, end, increment - output_time_unit = 3 ! Unit of bounds is in hours instead of seconds - steps_per_file = 1 ! number of steps per file - steps_per_file_inclfirst = .FALSE. ! First step is not accounted for in steps_per_file - include_last = .FALSE. - mode = 1 ! 1: forecast mode (mrelative t-axis), 2: climate mode (absolute t-axis) - output_filename = 'ICON-ART' - filename_format = '{cfg.icon_output}/_unstr_' ! file name base - remap = 0 ! 1: remap to lat-lon grid - ml_varlist = 'z_ifc','pres','qv','rho','temp','u','v','group:ART_CHEMISTRY','OH_Nconc', -/ - - -EOF - -# ! ml_varlist = 'z_ifc','z_mc','pres','pres_sfc','qv','rho','temp','u','v','group:ART_CHEMISTRY', - -# ---------------------------------------------------------------------- -# run the model! -# ---------------------------------------------------------------------- -handle_error(){{ - set +e - # Check for invalid pointer error at the end of icon-art - if grep -q "free(): invalid pointer" {cfg.logfile} && grep -q "clean-up finished" {cfg.logfile}; then - exit 0 - else - exit 1 - fi - set -e -}} -srun ./{cfg.icon_execname} || handle_error diff --git a/cases/icon-art-CTDAS/map_file.ana b/cases/icon-art-CTDAS/map_file.ana new file mode 100644 index 00000000..6e6f5fcb --- /dev/null +++ b/cases/icon-art-CTDAS/map_file.ana @@ -0,0 +1,109 @@ +# ICON +# +# --------------------------------------------------------------- +# Copyright (C) 2004-2024, DWD, MPI-M, DKRZ, KIT, ETH, MeteoSwiss +# Contact information: icon-model.org +# See AUTHORS.TXT for a list of authors +# See LICENSES/ for license information +# SPDX-License-Identifier: BSD-3-Clause +# --------------------------------------------------------------- + +# Dictionary for mapping between internal names and GRIB2/Netcdf +# variable names, which is needed by ICON's read procedures. +# +# internal name variable name (here GRIB2) +theta_v THETA_V +rho DEN +ddt_tke_pconv DTKE_CON +geopot FI +!z_ifc HHL +vn VN +u U +v V +w W +tke TKE +temp T +pres P +pres_msl PMSL +pres_sfc PS +qv QV +qc QC +qi QI +qr QR +qs QS +qg QG +qh QH +qnc NCCLOUD +qnr NCRAIN +qni NCICE +qns NCSNOW +qng NCGRAUPEL +qnh NCHAIL +t_g T_G +qv_s QV_S +fr_seaice FR_ICE +t_ice T_ICE +h_ice H_ICE +t_snow T_SNOW +freshsnow FRESHSNW +snowfrac_lc SNOWC +w_snow W_SNOW +rho_snow RHO_SNOW +h_snow H_SNOW +hsnow_max HSNOW_MAX +snow_age SNOAG +t_snow_mult T_SNOW_M +rho_snow_mult RHO_SNOW_M +wtot_snow W_SNOW_M +wliq_snow WLIQ_SNOW_M +dzh_snow H_SNOW_M +w_i W_I +w_so W_SO +w_so_ice W_SO_ICE +smi SMI +t_so T_SO +t_sk SKT +t_seasfc T_SEA +gz0 Z0 +t_mnw_lk T_MNW_LK +t_wml_lk T_WML_LK +h_ml_lk H_ML_LK +t_bot_lk T_BOT_LK +c_t_lk C_T_LK +t_b1_lk T_B1_LK +h_b1_lk H_B1_LK +rh RELHUM +rh_2m RELHUM_2M +rh_2m_land RELHUM_2M_L +td_2m_land TD_2M_L +t_2m_land T_2M_L +t_2m T_2M +t2m_bias T_2M_FILTBIAS +rh_avginc RELHUM_LML_FILTINC +t_avginc T_LML_FILTINC +t_wgt_avginc T_LML_COSWGT_FILTINC +t_daywgt_avginc T_LML_DTWGT_FILTINC +rh_daywgt_avginc RELHUM_LML_DTWGT_FILTINC +p_avginc P_LML_FILTINC +vabs_avginc SP_LML_FILTINC +albdif ALB_RAD +alb_si ALB_SEAICE +asodifd_s ASWDIFD_S +asodifu_s ASWDIFU_S +asodird_s ASWDIR_S +topography_c HSURF +gust10 VMAX_10M +aer_ss AER_SS +aer_or AER_ORG +aer_bc AER_BC +aer_su AER_SO4 +aer_du AER_DUST +alb_si ALB_SEAICE +plantevap EVAP_PL +pollcory CORYsnc +pollalnu ALNUsnc +pollbetu BETUsnc +pollpoac POACsnc +pollambr AMBRsnc +GEOSP GEOSP +GEOP_ML GEOP_ML diff --git a/cases/icon-art-CTDAS/wrapper_icon.sh b/cases/icon-art-CTDAS/wrapper_icon.sh new file mode 120000 index 00000000..a99f1b8f --- /dev/null +++ b/cases/icon-art-CTDAS/wrapper_icon.sh @@ -0,0 +1 @@ +/capstor/scratch/cscs/jthanwer/icon-kit//gpu/bin/../run/run_wrapper/alps_mch_gpu.sh \ No newline at end of file diff --git a/config.py b/config.py index 4094edbb..edb83760 100644 --- a/config.py +++ b/config.py @@ -152,6 +152,8 @@ def set_machine(self): self.machine = 'daint' elif hostname.startswith('eu-'): self.machine = 'euler' + elif hostname.startswith("santis-"): + self.machine = 'santis' else: raise ValueError(f"Unsupported hostname: {hostname}") print(f"You are on the {self.machine} machine.") @@ -472,6 +474,22 @@ def submit_basic_python(self, job_name): f'./run_chain.py {self.casename} -j {job_name} -c {self.chunk_id} -f -s --no-logging', '', ] + elif self.machine == 'santis': + script_lines = [ + '#!/usr/bin/env bash', + f'#SBATCH --job-name={job_name}', + '#SBATCH --nodes=1', + f'#SBATCH --time={walltime}', + f'#SBATCH --output={self.logfile}', + '#SBATCH --open-mode=append', + f'#SBATCH --account={self.compute_account}', + f'#SBATCH --partition={self.compute_queue}', + f'#SBATCH --constraint={self.constraint}', + '', + f'cd {self.chain_src_dir}', + f'./run_chain.py {self.casename} -j {job_name} -c {self.chunk_id} -f -s --no-logging', + '', + ] job_path = self.chain_root / 'job_scripts' job_path.mkdir(parents=True, exist_ok=True) @@ -495,7 +513,7 @@ def wait_for_previous(self): job_file = self.case_root / 'submit.wait.slurm' log_file = self.case_root / 'wait.log' dep_str = ':'.join(map(str, dep_ids)) - if self.machine == 'daint': + if self.machine == 'daint' or self.machine == "santis": script_lines = [ '#!/usr/bin/env bash', '#SBATCH --job-name="wait"', '#SBATCH --nodes=1', '#SBATCH --time=00:01:00', diff --git a/env/environment.yml b/env/environment.yml index 23958ed9..3766acc2 100644 --- a/env/environment.yml +++ b/env/environment.yml @@ -12,7 +12,7 @@ dependencies: - netcdf4 - pyyaml - cdsapi - - nco=4.9.0 + - nco - scikit-learn - f90nml - sphinx diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index 2a699515..afe5b340 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -7,14 +7,16 @@ import shutil import subprocess from . import tools, prepare_icon +from .tools.generate_tracers_xml import generate_tracers_xml from .tools.fetch_external_data import fetch_era5, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2_data, process_ICOS_data, process_OCO2_data from .tools.ctdas_utilities import create_lambda_regions, create_prior_all_ones, create_boundary_regions, create_boundary_prior_all_ones from concurrent.futures import ThreadPoolExecutor, as_completed from datetime import timedelta +from pathlib import Path +from subprocess import run BASIC_PYTHON_JOB = False - def main(cfg): """ Prepare CTDAS inversion @@ -27,7 +29,7 @@ def main(cfg): 5. Download ICOS station data for the chosen dates 6. Download OCO-2 data for the chosen dates 7. Prepare the folder output structure - 8. Run the first one-day simulation + 8. Prepare the first one-day simulation 9. Patch the CTDAS directory with files of our own Parameters @@ -115,9 +117,9 @@ def main(cfg): # Split files (with multiple days/times) into individual files using bash script era5_split_template = cfg.case_path / cfg.meteo_era5_splitjob era5_split_job = ERA5_folder / ( - cfg.meteo_era5_splitjob.stem + + era5_split_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + - cfg.meteo_era5_splitjob.suffix) + era5_split_template.suffix) logging.info( f"Preparing ERA5 splitting script for ICON from {era5_split_template}" ) @@ -172,7 +174,7 @@ def main(cfg): inicond_filename=era5_ini_file, ERA5_folder=ERA5_folder, CAMS_file=CAMS_folder / - f'cams_egg4_{cfg.startdate_sim.strftime("%Y%m%d%H")}.nc', + f'cams_egg4_{cfg.startdate_sim.strftime("%Y%m%dT%H")}.nc', era5_cams_ini_file=era5_ini_file)) logging.info(f"Running CAMS initial conditions script {cams_ini_job}") subprocess.run(["bash", cams_ini_job], @@ -231,7 +233,7 @@ def main(cfg): filename=era5_nudge_file, ERA5_folder=ERA5_folder, CAMS_file=CAMS_folder / - f'cams_egg4_{time.strftime("%Y%m%d%H")}.nc', + f'cams_egg4_{time.strftime("%Y%m%dT%H")}.nc', era5_cams_nudge_file=era5_nudge_file_final, )) subprocess.run(["bash", cams_nudge_job], @@ -242,8 +244,7 @@ def main(cfg): # Lots of potential for 'dehardcoding' things here, but that has to be done with # a lot of care. if cfg.CTDAS_obs_fetch_ICOS: - fetch_ICOS_data(cookie_token=cfg.CTDAS_obs_ICOS_cookie_token, - start_date=cfg.startdate_sim.strftime("%d-%m-%Y"), + fetch_ICOS_data(start_date=cfg.startdate_sim.strftime("%d-%m-%Y"), end_date=(cfg.enddate_sim + timedelta(days=1)).strftime("%d-%m-%Y"), save_path=cfg.CTDAS_obs_ICOS_path, @@ -260,25 +261,6 @@ def main(cfg): # -- 6. Download OCO2 data if cfg.CTDAS_obs_fetch_OCO2: - # A user must do the following steps to obtain access to OCO2 data - # from getpass import getpass - # import os - # from subprocess import Popen - # urs = 'urs.earthdata.nasa.gov' # Earthdata URL to call for authentication - # prompts = ['Enter NASA Earthdata Login Username \n(or create an account at urs.earthdata.nasa.gov): ', - # 'Enter NASA Earthdata Login Password: '] - # homeDir = os.path.expanduser("~") + os.sep - # with open(homeDir + '.netrc', 'w') as file: - # file.write('machine {} login {} password {}'.format(urs, getpass(prompt=prompts[0]), getpass(prompt=prompts[1]))) - # file.close() - # with open(homeDir + '.urs_cookies', 'w') as file: - # file.write('') - # file.close() - # with open(homeDir + '.dodsrc', 'w') as file: - # file.write('HTTP.COOKIEJAR={}.urs_cookies\n'.format(homeDir)) - # file.write('HTTP.NETRC={}.netrc'.format(homeDir)) - # file.close() - # Popen('chmod og-rw ~/.netrc', shell=True) fetch_OCO2_data(cfg.startdate_sim, (cfg.enddate_sim + timedelta(days=1)), -8, @@ -297,12 +279,12 @@ def main(cfg): # -- 7. Create the required folder structure # For the ICON runs - tools.create_dir(cfg.icon_base / "output_prior", "Prior") - tools.create_dir(cfg.icon_base / "output_opt_once", "1 time optimized") - tools.create_dir(cfg.icon_base / "output_opt_twice", "2 times optimized") + # tools.create_dir(cfg.icon_base / "output_prior", "Prior") + # tools.create_dir(cfg.icon_base / "output_opt_once", "1 time optimized") + # tools.create_dir(cfg.icon_base / "output_opt_twice", "2 times optimized") # For the sampling - tools.create_dir(cfg.case_root / "global_output" / "extracted_ICOS", + tools.create_dir(cfg.case_root / "global_outputs" / "extracted_ICOS", "Output of the extraction script") # -- 8. Initialize the first one-day run, only for the first lag @@ -316,10 +298,11 @@ def main(cfg): f'#SBATCH --account={cfg.compute_account}', '#SBATCH --time=00:10:00', f'#SBATCH --partition={cfg.compute_queue}', - f'#SBATCH --constraint={cfg.constraint}', '#SBATCH --nodes=1', + f'#SBATCH --constraint={cfg.constraint}', + '#SBATCH --nodes=1', f'#SBATCH --output={cfg.logfile}', '#SBATCH --open-mode=append', - f'#SBATCH --chdir={cfg.icon_work}', '' + f'#SBATCH --chdir={cfg.case_root / "global_inputs"}', '' ] elif cfg.machine == 'euler': script_lines = [ @@ -327,24 +310,53 @@ def main(cfg): f'#SBATCH --job-name="copy_input_{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.enddate_sim_yyyymmddhh}"', '#SBATCH --time=00:10:00', f'#SBATCH --partition={cfg.compute_queue}', - f'#SBATCH --constraint={cfg.constraint}', '#SBATCH --ntasks=1', + f'#SBATCH --constraint={cfg.constraint}', + '#SBATCH --ntasks=1', f'#SBATCH --output={cfg.logfile}', '#SBATCH --open-mode=append', - f'#SBATCH --chdir={cfg.icon_work}', '' + f'#SBATCH --chdir={cfg.case_root / "global_inputs"}', '' ] - for category in cfg.CTDAS_global_inputs: - tools.create_dir( - cat_folder := cfg.case_root / "global_inputs" / category, - category) - for file in category: - source = (p := Path(file)) - destination = cat_folder / p.name - script_lines.append(f'rsync -av {source} {destination}') + elif cfg.machine == 'santis': + script_lines = [ + '#!/usr/bin/env bash', + f'#SBATCH --job-name="copy_input_{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.enddate_sim_yyyymmddhh}"', + '#SBATCH --nodes=1', + f'#SBATCH --time=00:10:00', + f'#SBATCH --output={cfg.logfile}', + '#SBATCH --open-mode=append', + f'#SBATCH --account={cfg.compute_account}', + f'#SBATCH --partition={cfg.compute_queue}', + f'#SBATCH --constraint={cfg.constraint}', + f'#SBATCH --chdir={cfg.case_root / "global_inputs"}', '' + ] + + + for attr in dir(cfg): + if attr.startswith('CTDAS_global_inputs_'): + category = attr[len('CTDAS_global_inputs_'):] + tools.create_dir( + cat_folder := cfg.case_root / "global_inputs" / category, + category) + for file in getattr(cfg, attr): + source = (p := Path(file)) + destination = cat_folder / p.name + script_lines.append(f'rsync -av {source} {destination}') with (script := - cfg.icon_work / 'copy_global_inputs.job').open('w') as f: + cfg.case_root / "global_inputs" / 'copy_global_inputs.job').open('w') as f: f.write('\n'.join(script_lines)) + f.flush() cfg.submit('global_inputs', script) + tools.create_dir( + xml_folder := cfg.case_root / "global_inputs" / "XML", + "XML") + TR_prior = generate_tracers_xml(cfg.tracers,cfg.CTDAS_nensembles, restart=False) + TR_restart=generate_tracers_xml(cfg.tracers,cfg.CTDAS_nensembles, restart=True) + with open(xml_folder / "tracers_firstrun.xml", "w", encoding="utf-8") as file: + file.write(TR_prior) + with open(xml_folder / "tracers_restart.xml", "w", encoding="utf-8") as file: + file.write(TR_restart) + # -- 8.2 Create the ensemble data for the first day tools.create_dir(OEM_folder := cfg.case_root / "global_inputs" / "OEM", "OEM") @@ -357,36 +369,147 @@ def main(cfg): OEM_folder / "lambdaregions.nc", lambdas) create_prior_all_ones(OEM_folder / "prior_all_ones.nc", nensembles=cfg.CTDAS_nensembles, - ncats=lambdas.max(), + ncats=max(lambdas), nregs=nregs) else: raise NotImplementedError('Only basegrid is implemented for now') create_boundary_regions( - '/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc', - '/scratch/snx3000/ekoene/boundary_mask_bg.nc') + cfg.input_files_dynamics_grid_filename, + OEM_folder / 'boundary_mask_bg.nc', + cfg.cdo_nco_cmd, + cfg.cdo_nco_cmd_post) create_boundary_prior_all_ones( - '/scratch/snx3000/ekoene/boundary_lambdas_bg.nc', + OEM_folder / 'boundary_lambdas_bg.nc', nensembles=cfg.CTDAS_nensembles) - # Create a folder an `nlag` period earlier / icon / output_opt_twice - - # then initialize the runscript file - - # era5_split_template = cfg.case_path / cfg.firstrunscript - # era5_split_job = / cfg.meteo_era5_splitjob - # era5_split_job = era5_split_job.parent / (era5_split_job.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + era5_split_job.suffix) - # logging.info(f"Preparing ERA5 splitting script for ICON from {era5_split_template}") - # ml_files = " ".join([f"{filenames[0]}" for filenames in output_filenames]) - # surf_files = " ".join([f"{filenames[1]}" for filenames in output_filenames]) - # with open(era5_split_template, 'r') as infile, open(era5_split_job, 'w') as outfile: - # outfile.write(infile.read().format( - # cfg=cfg, - # ml_files=ml_files, - # surf_files=surf_files, - # ERA5_folder=ERA5_folder - # )) - # logging.info(f"Running ERA5 splitting script {era5_split_job}") - # subprocess.run(["bash", era5_split_job], check=True, stdout=subprocess.PIPE) + # -- 8.3 Prepare the first one-day simulation + logging.info("Creating output file for first run") + tools.create_dir(initial_output := cfg.case_root / "global_outputs" / f"opt2_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}", + "Create initial conditions output file") + + logging.info("Preparing ICON script for first run") + icon_ini_template = cfg.case_path / cfg.icon_runjob_filename + icon_ini_job = cfg.icon_work / (icon_ini_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + icon_ini_template.suffix) + with open(icon_ini_template, 'r') as infile, open(icon_ini_job, + 'w') as outfile: + outfile.write(infile.read().format( + cfg=cfg, + ini_restart_string=cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%SZ'), + ini_restart_end_string=f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%SZ')}", + inifile_nc=cfg.icon_input_icbc / f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", + tracers_xml=cfg.case_root / "global_inputs" / "XML" / "tracers_firstrun.xml", + emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", + vertical_profile_nc=OEM_folder / "vertical_profiles.nc", + hour_of_year_nc=OEM_folder / "hourofyear8784.nc", + lambda_nc=OEM_folder / "prior_all_ones.nc", + lambda_regions_nc=OEM_folder / "lambdaregions.nc", + bg_lambda_nc=OEM_folder / "boundary_lambdas_bg.nc", + bg_lambda_regions_nc=OEM_folder / "boundary_mask_bg.nc", + vprm_coeffs_nc=cfg.case_root / "global_inputs" / cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], + latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / "lateral_boundary.grid.nc", + output_directory=initial_output, + restart_file=cfg.case_root / "global_outputs" / f"opt2_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", + restart_init_time=cfg.CTDAS_restart_init_time, + output_init=cfg.CTDAS_restart_init_time) + ) + + + logging.info("Creating output file for first run") + tools.create_dir(initial_output := cfg.case_root / "global_outputs" / f"prior_{(cfg.startdate).strftime('%Y%m%d')}", + "Create prior output") + tools.create_dir(initial_output := cfg.case_root / "global_outputs" / f"opt1_{(cfg.startdate).strftime('%Y%m%d')}", + "Create opt1 output") + tools.create_dir(initial_output := cfg.case_root / "global_outputs" / f"opt2_{(cfg.startdate).strftime('%Y%m%d')}", + "Create opt2 output") + + logging.info("Preparing ICON script for prior run") + OEM_folder = cfg.case_root / "global_inputs" / "OEM" + icon_ini_template = cfg.case_path / cfg.icon_runjob_filename + icon_ini_job = cfg.icon_work / (icon_ini_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}_prior' + + icon_ini_template.suffix) + with open(icon_ini_template, 'r') as infile, open(icon_ini_job, + 'w') as outfile: + outfile.write(infile.read().format( + cfg=cfg, + ini_restart_string=cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%SZ'), + ini_restart_end_string=f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%SZ')}", + inifile_nc=cfg.icon_input_icbc / f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", + tracers_xml=cfg.case_root / "global_inputs" / "XML" / "tracers_firstrun.xml", + emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", + vertical_profile_nc=OEM_folder / "vertical_profiles.nc", + hour_of_year_nc=OEM_folder / "hourofyear8784.nc", + lambda_nc=OEM_folder / f"lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_prior.nc", + lambda_regions_nc=OEM_folder / "lambdaregions.nc", + bg_lambda_nc=OEM_folder / "bg_lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_prior.nc", + bg_lambda_regions_nc=OEM_folder / "boundary_mask_bg.nc", + vprm_coeffs_nc=cfg.case_root / "global_inputs" / cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], + latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / "lateral_boundary.grid.nc", + output_directory=initial_output, + restart_file=cfg.case_root / "global_outputs" / f"prior_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", + restart_init_time=cfg.CTDAS_restart_init_time, + output_init=24*60*60*cfg.CTDAS_ctdas_cycle + cfg.CTDAS_restart_init_time) + ) + + logging.info("Preparing ICON script for first optimization run") + OEM_folder = cfg.case_root / "global_inputs" / "OEM" + icon_ini_template = cfg.case_path / cfg.icon_runjob_filename + icon_ini_job = cfg.icon_work / (icon_ini_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}_opt1' + + icon_ini_template.suffix) + with open(icon_ini_template, 'r') as infile, open(icon_ini_job, + 'w') as outfile: + outfile.write(infile.read().format( + cfg=cfg, + ini_restart_string=cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%SZ'), + ini_restart_end_string=f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%SZ')}", + inifile_nc=cfg.icon_input_icbc / f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", + tracers_xml=cfg.case_root / "global_inputs" / "XML" / "tracers_firstrun.xml", + emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", + vertical_profile_nc=OEM_folder / "vertical_profiles.nc", + hour_of_year_nc=OEM_folder / "hourofyear8784.nc", + lambda_nc=OEM_folder / f"lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", + lambda_regions_nc=OEM_folder / "lambdaregions.nc", + bg_lambda_nc=OEM_folder / "bg_lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", + bg_lambda_regions_nc=OEM_folder / "boundary_mask_bg.nc", + vprm_coeffs_nc=cfg.case_root / "global_inputs" / cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], + latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / "lateral_boundary.grid.nc", + output_directory=initial_output, + restart_file=cfg.case_root / "global_outputs" / f"opt1_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", + restart_init_time=cfg.CTDAS_restart_init_time, + output_init=24*60*60*cfg.CTDAS_ctdas_cycle + cfg.CTDAS_restart_init_time) + ) + + logging.info("Preparing ICON script for second optimization run") + OEM_folder = cfg.case_root / "global_inputs" / "OEM" + icon_ini_template = cfg.case_path / cfg.icon_runjob_filename + icon_ini_job = cfg.icon_work / (icon_ini_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}_opt2' + + icon_ini_template.suffix) + with open(icon_ini_template, 'r') as infile, open(icon_ini_job, + 'w') as outfile: + outfile.write(infile.read().format( + cfg=cfg, + ini_restart_string=cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%SZ'), + ini_restart_end_string=f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%SZ')}", + inifile_nc=cfg.icon_input_icbc / f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", + tracers_xml=cfg.case_root / "global_inputs" / "XML" / "tracers_firstrun.xml", + emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", + vertical_profile_nc=OEM_folder / "vertical_profiles.nc", + hour_of_year_nc=OEM_folder / "hourofyear8784.nc", + lambda_nc=OEM_folder / f"lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", + lambda_regions_nc=OEM_folder / "lambdaregions.nc", + bg_lambda_nc=OEM_folder / "bg_lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", + bg_lambda_regions_nc=OEM_folder / "boundary_mask_bg.nc", + vprm_coeffs_nc=cfg.case_root / "global_inputs" / cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], + latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / "lateral_boundary.grid.nc", + output_directory=initial_output, + restart_file=cfg.case_root / "global_outputs" / f"opt2_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", + restart_init_time=cfg.CTDAS_restart_init_time, + output_init=24*60*60*cfg.CTDAS_ctdas_cycle + cfg.CTDAS_restart_init_time) + ) logging.info("OK") shutil.copy(cfg.logfile, cfg.logfile_finish) diff --git a/jobs/tools/ctdas_utilities.py b/jobs/tools/ctdas_utilities.py index f1df6cee..d711d5fe 100644 --- a/jobs/tools/ctdas_utilities.py +++ b/jobs/tools/ctdas_utilities.py @@ -53,11 +53,12 @@ def create_prior_all_ones(output_path, nensembles, ncats, nregs): print(f"Prior all ones saved to {output_path}") -def create_boundary_regions(grid_filename, output_path): +def create_boundary_regions(grid_filename, output_path, cdo_nco_cmd, cdo_nco_cmd_post): """ Create boundary region masks based on geographical quadrants and save to NetCDF. """ cmd = f""" +{cdo_nco_cmd} cat > NAMELIST_ICONSUB << EOF_1 &iconsub_nml grid_filename = '{grid_filename}', @@ -72,7 +73,8 @@ def create_boundary_regions(grid_filename, output_path): / EOF_1 -/scratch/snx3000/ekoene/spack-c2sm/spack/opt/spack/icontools-c2sm-master/gcc-9.3.0/zktezcs5cjwjsptd747zhipi53nd6phr/bin/iconsub --nml NAMELIST_ICONSUB +iconsub --nml NAMELIST_ICONSUB +{cdo_nco_cmd_post} """ subprocess.check_output(cmd, shell=True) diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index a1bdaf5a..aac89788 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -257,8 +257,7 @@ def fetch_CAMS_CO2(start_date, end_date, dir2move): logging.info("Finished processing CAMS data.") -def fetch_ICOS_data(cookie_token, - query_type='any', +def fetch_ICOS_data(query_type='any', start_date='01-01-2022', end_date='31-12-2022', save_path='', @@ -268,15 +267,12 @@ def fetch_ICOS_data(cookie_token, (e.g., https://data.icos-cp.eu/portal/#%7B%22filterCategories%22%3A%7B%22variable%22%3A%5B%22http%3A%2F%2Fmeta.icos-cp.eu%2Fresources%2Fcpmeta%2Fco2atcMoleFrac%22%5D%7D%2C%22filterTemporal%22%3A%7B%22df%22%3A%222017-12-31%22%2C%22dt%22%3A%222018-12-30%22%7D%7D) and then clicking the well-hidden SPARQL query button (situated right of "Data objects 1 to 20 of 167", consisting of an arrow.) - cookie_token str cpauthToken=WzE3M.... query_type str [release, growing, any] correspond to the different file products at the ICOS-CP start_date str dd-mm-yyyy end_date str dd-mm-yyyy save_path str e.g., /scratch/snx/[user]/ICOS_data/year/ species list can be ['co', 'co2', 'ch4'] or any subset thereof ''' - meta, data = bootstrap.fromCookieToken(cookie_token) - cpauth.init_by(data.auth) # --- Build up an SQL query for the different species qd = "" for specie in species: @@ -323,6 +319,13 @@ def fetch_ICOS_data(cookie_token, for d in result.data()['dobj']: obj = Dobj(d).data + outfn = os.path.join(save_path, 'ICOS_obs_' + str(specie)[2:-2] + '_' + query_type + '_' + str( + Dobj(d).station['id']) + '_' + str( + Dobj(d).meta['specificInfo']['acquisition'] + ['samplingHeight']) + '_' + start_date + '_' + end_date + '.nc') + # Skip if filename exists + if os.path.isfile(outfn): + continue shape = np.shape(obj) @@ -369,7 +372,7 @@ def fetch_ICOS_data(cookie_token, Dobj(d).station['id']) + '_' + str( Dobj(d).meta['specificInfo']['acquisition'] ['samplingHeight']) + '_' + start_date + '_' + end_date + '.nc' - ds.to_netcdf(os.path.join(save_path, name)) + ds.to_netcdf(outfn) def process_ICOS_data(ICOS_obs_folder, @@ -386,6 +389,13 @@ def process_ICOS_data(ICOS_obs_folder, output_folder str e.g., /scratch/snx/[user]/ICOS_data/year/ """ + output_filename = Path( + output_folder + ) / f"Extracted_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}_alldates_masl.nc" + if os.path.isfile(output_filename): + return + + # Future expected options (or retrieved from grid file); for now hardcoded lon_lims = [-8.3, 17.5] lat_lims = [40.9, 58.7] @@ -563,9 +573,6 @@ def extract_obs_column(file): attrs=attrs) # Save dataset to file - output_filename = Path( - output_folder - ) / f"Extracted_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}_alldates_masl.nc" ds_extracted_obs_matrix.to_netcdf(output_filename) logging.info( diff --git a/jobs/tools/generate_tracers_xml.py b/jobs/tools/generate_tracers_xml.py new file mode 100644 index 00000000..2f3db7f4 --- /dev/null +++ b/jobs/tools/generate_tracers_xml.py @@ -0,0 +1,90 @@ +import xml.etree.ElementTree as ET +import xml.dom.minidom +import numpy as np + +def generate_tracers_xml(data, nens=-1, restart=False): + """ + Generate an XML representation for chemtracers. + + Args: + data (dict): + A dictionary containing details for chemtracers. Example structure: + { + "TRCO2_A": { + "oem_cat": "A-CO2, ...", + "oem_vp": "GNFR_A, ...", + "oem_tp": "GNFR_A-CO2, ..." + }, + "TRCO2_BG": { + "init_name": "CO2" + }, + "CO2_RA": {}, + "CO2_GPP": {}, + "TRCO2_A-XXX": {"start": 0, "count": 10, "bg": "TRCO2_BG", "ra": "CO2_RA", "gpp": "CO2_GPP"} + } + + Returns: + str: The prettyfied XML string. + """ + tracers = ET.Element("tracers") + + # Iterate over all items in data + for item_id, item_data in data.items(): + print() + if any(key == "oem_cat" for key in item_data): + # Make an OEM tracer + tracer = ET.SubElement(tracers, "chemtracer", id=item_id) + ET.SubElement(tracer, "transport", type="char").text = "stdaero" if not item_id.startswith("EM_") else "off" + ET.SubElement(tracer, "c_solve", type="char").text = "passive" + ET.SubElement(tracer, "init_mode", type="int").text = "0" + ET.SubElement(tracer, "unit", type="char").text = "none" + ET.SubElement(tracer, "oem_tscale", type="int").text = "2" + ET.SubElement(tracer, "oem_type", type="char").text = "emis" + for key, value in item_data.items(): + if key.startswith("oem_"): + ET.SubElement(tracer, key, type="char").text = value + if restart and not item_id.startswith("EM_"): + ET.SubElement(tracer, "oem_restart", type="char").text = "file" + if item_id.endswith("BG"): + # Make a background tracer + tracer_bg = ET.SubElement(tracers, "chemtracer", id=item_id) + ET.SubElement(tracer_bg, "transport", type="char").text = "stdaero" + ET.SubElement(tracer_bg, "c_solve", type="char").text = "passive" + ET.SubElement(tracer_bg, "init_mode", type="int").text = "1" + ET.SubElement(tracer_bg, "unit", type="char").text = "none" + ET.SubElement(tracer_bg, "init_name", type="char").text = item_data["init_name"] + ET.SubElement(tracer_bg, "oem_type", type="char").text = "bg" + if restart: + ET.SubElement(tracer_bg, "oem_restart", type="char").text = "file" + ET.SubElement(tracer_bg, "latbc", type="char").text = "file" + if any(key == "oem_ftype" for key in item_data): + # Make a VPRM tracer + tracer_ra = ET.SubElement(tracers, "chemtracer", id=item_id) + ET.SubElement(tracer_ra, "transport", type="char").text = "stdaero" if not item_id.startswith("EM_") else "off" + ET.SubElement(tracer_ra, "c_solve", type="char").text = "passive" + ET.SubElement(tracer_ra, "init_mode", type="int").text = "0" + ET.SubElement(tracer_ra, "unit", type="char").text = "none" + ET.SubElement(tracer_ra, "oem_type", type="char").text = "vprm" + ET.SubElement(tracer_ra, "oem_ftype", type="char").text = item_data["oem_ftype"] + if restart and not item_id.startswith("EM_"): + ET.SubElement(tracer_ra, "oem_restart", type="char").text = "file" + if item_id.endswith("XXX"): + # Make a set of ensemble tracers + for i in np.arange(nens) + 1: + tracer_xxx = ET.SubElement(tracers, "chemtracer", id=f"TRCO2_A-{i:03}") + ET.SubElement(tracer_xxx, "transport", type="char").text = "stdaero" + ET.SubElement(tracer_xxx, "oem_type", type="char").text = "ens" + ET.SubElement(tracer_xxx, "c_solve", type="char").text = "passive" + ET.SubElement(tracer_xxx, "init_mode", type="int").text = "0" + if "bg" in item_data: + ET.SubElement(tracer_xxx, "oem_bg_ens", type="char").text = item_data["bg"] + if "ra" in item_data and "gpp" in item_data: + ET.SubElement(tracer_xxx, "oem_vprm_bg_ens", type="char").text = f"{item_data['ra']}, {item_data['gpp']}" + if restart: + ET.SubElement(tracer_xxx, "oem_restart", type="char").text = "file" + ET.SubElement(tracer_xxx, "unit", type="char").text = "none" + + # Convert to string + xml_declaration = "\n\n" + xml_string = ET.tostring(tracers, encoding="unicode") + return xml.dom.minidom.parseString(xml_declaration + xml_string).toprettyxml() From a8927d890c9bfb05d2b872a76bb853d33eaefe78 Mon Sep 17 00:00:00 2001 From: github-actions Date: Fri, 7 Feb 2025 13:50:08 +0000 Subject: [PATCH 29/42] GitHub Action: Apply Pep8-formatting --- jobs/prepare_CTDAS.py | 238 +++++++++++++++++------------ jobs/tools/ctdas_utilities.py | 3 +- jobs/tools/fetch_external_data.py | 10 +- jobs/tools/generate_tracers_xml.py | 44 ++++-- 4 files changed, 182 insertions(+), 113 deletions(-) diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index afe5b340..71307657 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -17,6 +17,7 @@ BASIC_PYTHON_JOB = False + def main(cfg): """ Prepare CTDAS inversion @@ -298,8 +299,7 @@ def main(cfg): f'#SBATCH --account={cfg.compute_account}', '#SBATCH --time=00:10:00', f'#SBATCH --partition={cfg.compute_queue}', - f'#SBATCH --constraint={cfg.constraint}', - '#SBATCH --nodes=1', + f'#SBATCH --constraint={cfg.constraint}', '#SBATCH --nodes=1', f'#SBATCH --output={cfg.logfile}', '#SBATCH --open-mode=append', f'#SBATCH --chdir={cfg.case_root / "global_inputs"}', '' @@ -310,8 +310,7 @@ def main(cfg): f'#SBATCH --job-name="copy_input_{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.enddate_sim_yyyymmddhh}"', '#SBATCH --time=00:10:00', f'#SBATCH --partition={cfg.compute_queue}', - f'#SBATCH --constraint={cfg.constraint}', - '#SBATCH --ntasks=1', + f'#SBATCH --constraint={cfg.constraint}', '#SBATCH --ntasks=1', f'#SBATCH --output={cfg.logfile}', '#SBATCH --open-mode=append', f'#SBATCH --chdir={cfg.case_root / "global_inputs"}', '' @@ -320,8 +319,7 @@ def main(cfg): script_lines = [ '#!/usr/bin/env bash', f'#SBATCH --job-name="copy_input_{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.enddate_sim_yyyymmddhh}"', - '#SBATCH --nodes=1', - f'#SBATCH --time=00:10:00', + '#SBATCH --nodes=1', f'#SBATCH --time=00:10:00', f'#SBATCH --output={cfg.logfile}', '#SBATCH --open-mode=append', f'#SBATCH --account={cfg.compute_account}', @@ -330,7 +328,6 @@ def main(cfg): f'#SBATCH --chdir={cfg.case_root / "global_inputs"}', '' ] - for attr in dir(cfg): if attr.startswith('CTDAS_global_inputs_'): category = attr[len('CTDAS_global_inputs_'):] @@ -341,20 +338,25 @@ def main(cfg): source = (p := Path(file)) destination = cat_folder / p.name script_lines.append(f'rsync -av {source} {destination}') - with (script := - cfg.case_root / "global_inputs" / 'copy_global_inputs.job').open('w') as f: + with (script := cfg.case_root / "global_inputs" / + 'copy_global_inputs.job').open('w') as f: f.write('\n'.join(script_lines)) f.flush() cfg.submit('global_inputs', script) - tools.create_dir( - xml_folder := cfg.case_root / "global_inputs" / "XML", - "XML") - TR_prior = generate_tracers_xml(cfg.tracers,cfg.CTDAS_nensembles, restart=False) - TR_restart=generate_tracers_xml(cfg.tracers,cfg.CTDAS_nensembles, restart=True) - with open(xml_folder / "tracers_firstrun.xml", "w", encoding="utf-8") as file: + tools.create_dir(xml_folder := cfg.case_root / "global_inputs" / "XML", + "XML") + TR_prior = generate_tracers_xml(cfg.tracers, + cfg.CTDAS_nensembles, + restart=False) + TR_restart = generate_tracers_xml(cfg.tracers, + cfg.CTDAS_nensembles, + restart=True) + with open(xml_folder / "tracers_firstrun.xml", "w", + encoding="utf-8") as file: file.write(TR_prior) - with open(xml_folder / "tracers_restart.xml", "w", encoding="utf-8") as file: + with open(xml_folder / "tracers_restart.xml", "w", + encoding="utf-8") as file: file.write(TR_restart) # -- 8.2 Create the ensemble data for the first day @@ -373,143 +375,191 @@ def main(cfg): nregs=nregs) else: raise NotImplementedError('Only basegrid is implemented for now') - create_boundary_regions( - cfg.input_files_dynamics_grid_filename, - OEM_folder / 'boundary_mask_bg.nc', - cfg.cdo_nco_cmd, - cfg.cdo_nco_cmd_post) - create_boundary_prior_all_ones( - OEM_folder / 'boundary_lambdas_bg.nc', - nensembles=cfg.CTDAS_nensembles) + create_boundary_regions(cfg.input_files_dynamics_grid_filename, + OEM_folder / 'boundary_mask_bg.nc', + cfg.cdo_nco_cmd, cfg.cdo_nco_cmd_post) + create_boundary_prior_all_ones(OEM_folder / 'boundary_lambdas_bg.nc', + nensembles=cfg.CTDAS_nensembles) # -- 8.3 Prepare the first one-day simulation logging.info("Creating output file for first run") - tools.create_dir(initial_output := cfg.case_root / "global_outputs" / f"opt2_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}", - "Create initial conditions output file") + tools.create_dir( + initial_output := cfg.case_root / "global_outputs" / + f"opt2_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}", + "Create initial conditions output file") logging.info("Preparing ICON script for first run") icon_ini_template = cfg.case_path / cfg.icon_runjob_filename - icon_ini_job = cfg.icon_work / (icon_ini_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}' - + icon_ini_template.suffix) + icon_ini_job = cfg.icon_work / ( + icon_ini_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + icon_ini_template.suffix) with open(icon_ini_template, 'r') as infile, open(icon_ini_job, 'w') as outfile: outfile.write(infile.read().format( cfg=cfg, - ini_restart_string=cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%SZ'), - ini_restart_end_string=f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%SZ')}", - inifile_nc=cfg.icon_input_icbc / f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", - tracers_xml=cfg.case_root / "global_inputs" / "XML" / "tracers_firstrun.xml", - emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", + ini_restart_string=cfg.startdate_sim.strftime( + '%Y-%m-%dT%H:%M:%SZ'), + ini_restart_end_string= + f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%SZ')}", + inifile_nc=cfg.icon_input_icbc / + f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", + tracers_xml=cfg.case_root / "global_inputs" / "XML" / + "tracers_firstrun.xml", + emissionsgrid_nc=cfg.case_root / "global_inputs" / + "inventories" / + f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", vertical_profile_nc=OEM_folder / "vertical_profiles.nc", hour_of_year_nc=OEM_folder / "hourofyear8784.nc", lambda_nc=OEM_folder / "prior_all_ones.nc", lambda_regions_nc=OEM_folder / "lambdaregions.nc", bg_lambda_nc=OEM_folder / "boundary_lambdas_bg.nc", bg_lambda_regions_nc=OEM_folder / "boundary_mask_bg.nc", - vprm_coeffs_nc=cfg.case_root / "global_inputs" / cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], - latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / "lateral_boundary.grid.nc", + vprm_coeffs_nc=cfg.case_root / "global_inputs" / + cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], + latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / + "grid" / "lateral_boundary.grid.nc", output_directory=initial_output, - restart_file=cfg.case_root / "global_outputs" / f"opt2_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", + restart_file=cfg.case_root / "global_outputs" / + f"opt2_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" + / + f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", restart_init_time=cfg.CTDAS_restart_init_time, - output_init=cfg.CTDAS_restart_init_time) - ) - + output_init=cfg.CTDAS_restart_init_time)) logging.info("Creating output file for first run") - tools.create_dir(initial_output := cfg.case_root / "global_outputs" / f"prior_{(cfg.startdate).strftime('%Y%m%d')}", - "Create prior output") - tools.create_dir(initial_output := cfg.case_root / "global_outputs" / f"opt1_{(cfg.startdate).strftime('%Y%m%d')}", - "Create opt1 output") - tools.create_dir(initial_output := cfg.case_root / "global_outputs" / f"opt2_{(cfg.startdate).strftime('%Y%m%d')}", - "Create opt2 output") + tools.create_dir( + initial_output := cfg.case_root / "global_outputs" / + f"prior_{(cfg.startdate).strftime('%Y%m%d')}", "Create prior output") + tools.create_dir( + initial_output := cfg.case_root / "global_outputs" / + f"opt1_{(cfg.startdate).strftime('%Y%m%d')}", "Create opt1 output") + tools.create_dir( + initial_output := cfg.case_root / "global_outputs" / + f"opt2_{(cfg.startdate).strftime('%Y%m%d')}", "Create opt2 output") logging.info("Preparing ICON script for prior run") OEM_folder = cfg.case_root / "global_inputs" / "OEM" icon_ini_template = cfg.case_path / cfg.icon_runjob_filename - icon_ini_job = cfg.icon_work / (icon_ini_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}_prior' - + icon_ini_template.suffix) + icon_ini_job = cfg.icon_work / ( + icon_ini_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}_prior' + + icon_ini_template.suffix) with open(icon_ini_template, 'r') as infile, open(icon_ini_job, - 'w') as outfile: + 'w') as outfile: outfile.write(infile.read().format( cfg=cfg, - ini_restart_string=cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%SZ'), - ini_restart_end_string=f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%SZ')}", - inifile_nc=cfg.icon_input_icbc / f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", - tracers_xml=cfg.case_root / "global_inputs" / "XML" / "tracers_firstrun.xml", - emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", + ini_restart_string=cfg.startdate_sim.strftime( + '%Y-%m-%dT%H:%M:%SZ'), + ini_restart_end_string= + f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%SZ')}", + inifile_nc=cfg.icon_input_icbc / + f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", + tracers_xml=cfg.case_root / "global_inputs" / "XML" / + "tracers_firstrun.xml", + emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / + f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", vertical_profile_nc=OEM_folder / "vertical_profiles.nc", hour_of_year_nc=OEM_folder / "hourofyear8784.nc", - lambda_nc=OEM_folder / f"lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_prior.nc", + lambda_nc=OEM_folder / + f"lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_prior.nc", lambda_regions_nc=OEM_folder / "lambdaregions.nc", - bg_lambda_nc=OEM_folder / "bg_lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_prior.nc", + bg_lambda_nc=OEM_folder / + "bg_lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_prior.nc", bg_lambda_regions_nc=OEM_folder / "boundary_mask_bg.nc", - vprm_coeffs_nc=cfg.case_root / "global_inputs" / cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], - latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / "lateral_boundary.grid.nc", + vprm_coeffs_nc=cfg.case_root / "global_inputs" / + cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], + latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / + "lateral_boundary.grid.nc", output_directory=initial_output, - restart_file=cfg.case_root / "global_outputs" / f"prior_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", + restart_file=cfg.case_root / "global_outputs" / + f"prior_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" + / + f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", restart_init_time=cfg.CTDAS_restart_init_time, - output_init=24*60*60*cfg.CTDAS_ctdas_cycle + cfg.CTDAS_restart_init_time) - ) + output_init=24 * 60 * 60 * cfg.CTDAS_ctdas_cycle + + cfg.CTDAS_restart_init_time)) logging.info("Preparing ICON script for first optimization run") OEM_folder = cfg.case_root / "global_inputs" / "OEM" icon_ini_template = cfg.case_path / cfg.icon_runjob_filename - icon_ini_job = cfg.icon_work / (icon_ini_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}_opt1' - + icon_ini_template.suffix) + icon_ini_job = cfg.icon_work / ( + icon_ini_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}_opt1' + + icon_ini_template.suffix) with open(icon_ini_template, 'r') as infile, open(icon_ini_job, - 'w') as outfile: + 'w') as outfile: outfile.write(infile.read().format( cfg=cfg, - ini_restart_string=cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%SZ'), - ini_restart_end_string=f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%SZ')}", - inifile_nc=cfg.icon_input_icbc / f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", - tracers_xml=cfg.case_root / "global_inputs" / "XML" / "tracers_firstrun.xml", - emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", + ini_restart_string=cfg.startdate_sim.strftime( + '%Y-%m-%dT%H:%M:%SZ'), + ini_restart_end_string= + f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%SZ')}", + inifile_nc=cfg.icon_input_icbc / + f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", + tracers_xml=cfg.case_root / "global_inputs" / "XML" / + "tracers_firstrun.xml", + emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / + f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", vertical_profile_nc=OEM_folder / "vertical_profiles.nc", hour_of_year_nc=OEM_folder / "hourofyear8784.nc", - lambda_nc=OEM_folder / f"lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", + lambda_nc=OEM_folder / + f"lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", lambda_regions_nc=OEM_folder / "lambdaregions.nc", - bg_lambda_nc=OEM_folder / "bg_lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", + bg_lambda_nc=OEM_folder / + "bg_lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", bg_lambda_regions_nc=OEM_folder / "boundary_mask_bg.nc", - vprm_coeffs_nc=cfg.case_root / "global_inputs" / cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], - latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / "lateral_boundary.grid.nc", + vprm_coeffs_nc=cfg.case_root / "global_inputs" / + cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], + latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / + "lateral_boundary.grid.nc", output_directory=initial_output, - restart_file=cfg.case_root / "global_outputs" / f"opt1_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", + restart_file=cfg.case_root / "global_outputs" / + f"opt1_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" + / + f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", restart_init_time=cfg.CTDAS_restart_init_time, - output_init=24*60*60*cfg.CTDAS_ctdas_cycle + cfg.CTDAS_restart_init_time) - ) + output_init=24 * 60 * 60 * cfg.CTDAS_ctdas_cycle + + cfg.CTDAS_restart_init_time)) logging.info("Preparing ICON script for second optimization run") OEM_folder = cfg.case_root / "global_inputs" / "OEM" icon_ini_template = cfg.case_path / cfg.icon_runjob_filename - icon_ini_job = cfg.icon_work / (icon_ini_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}_opt2' - + icon_ini_template.suffix) + icon_ini_job = cfg.icon_work / ( + icon_ini_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}_opt2' + + icon_ini_template.suffix) with open(icon_ini_template, 'r') as infile, open(icon_ini_job, - 'w') as outfile: + 'w') as outfile: outfile.write(infile.read().format( cfg=cfg, - ini_restart_string=cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%SZ'), - ini_restart_end_string=f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%SZ')}", - inifile_nc=cfg.icon_input_icbc / f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", - tracers_xml=cfg.case_root / "global_inputs" / "XML" / "tracers_firstrun.xml", - emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", + ini_restart_string=cfg.startdate_sim.strftime( + '%Y-%m-%dT%H:%M:%SZ'), + ini_restart_end_string= + f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%SZ')}", + inifile_nc=cfg.icon_input_icbc / + f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", + tracers_xml=cfg.case_root / "global_inputs" / "XML" / + "tracers_firstrun.xml", + emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / + f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", vertical_profile_nc=OEM_folder / "vertical_profiles.nc", hour_of_year_nc=OEM_folder / "hourofyear8784.nc", - lambda_nc=OEM_folder / f"lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", + lambda_nc=OEM_folder / + f"lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", lambda_regions_nc=OEM_folder / "lambdaregions.nc", - bg_lambda_nc=OEM_folder / "bg_lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", + bg_lambda_nc=OEM_folder / + "bg_lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", bg_lambda_regions_nc=OEM_folder / "boundary_mask_bg.nc", - vprm_coeffs_nc=cfg.case_root / "global_inputs" / cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], - latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / "lateral_boundary.grid.nc", + vprm_coeffs_nc=cfg.case_root / "global_inputs" / + cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], + latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / + "lateral_boundary.grid.nc", output_directory=initial_output, - restart_file=cfg.case_root / "global_outputs" / f"opt2_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", + restart_file=cfg.case_root / "global_outputs" / + f"opt2_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" + / + f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", restart_init_time=cfg.CTDAS_restart_init_time, - output_init=24*60*60*cfg.CTDAS_ctdas_cycle + cfg.CTDAS_restart_init_time) - ) + output_init=24 * 60 * 60 * cfg.CTDAS_ctdas_cycle + + cfg.CTDAS_restart_init_time)) logging.info("OK") shutil.copy(cfg.logfile, cfg.logfile_finish) diff --git a/jobs/tools/ctdas_utilities.py b/jobs/tools/ctdas_utilities.py index d711d5fe..d1177aef 100644 --- a/jobs/tools/ctdas_utilities.py +++ b/jobs/tools/ctdas_utilities.py @@ -53,7 +53,8 @@ def create_prior_all_ones(output_path, nensembles, ncats, nregs): print(f"Prior all ones saved to {output_path}") -def create_boundary_regions(grid_filename, output_path, cdo_nco_cmd, cdo_nco_cmd_post): +def create_boundary_regions(grid_filename, output_path, cdo_nco_cmd, + cdo_nco_cmd_post): """ Create boundary region masks based on geographical quadrants and save to NetCDF. """ diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index aac89788..4ec57a5e 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -319,10 +319,11 @@ def fetch_ICOS_data(query_type='any', for d in result.data()['dobj']: obj = Dobj(d).data - outfn = os.path.join(save_path, 'ICOS_obs_' + str(specie)[2:-2] + '_' + query_type + '_' + str( - Dobj(d).station['id']) + '_' + str( - Dobj(d).meta['specificInfo']['acquisition'] - ['samplingHeight']) + '_' + start_date + '_' + end_date + '.nc') + outfn = os.path.join( + save_path, 'ICOS_obs_' + str(specie)[2:-2] + '_' + query_type + + '_' + str(Dobj(d).station['id']) + '_' + + str(Dobj(d).meta['specificInfo']['acquisition']['samplingHeight']) + + '_' + start_date + '_' + end_date + '.nc') # Skip if filename exists if os.path.isfile(outfn): continue @@ -395,7 +396,6 @@ def process_ICOS_data(ICOS_obs_folder, if os.path.isfile(output_filename): return - # Future expected options (or retrieved from grid file); for now hardcoded lon_lims = [-8.3, 17.5] lat_lims = [40.9, 58.7] diff --git a/jobs/tools/generate_tracers_xml.py b/jobs/tools/generate_tracers_xml.py index 2f3db7f4..545fb021 100644 --- a/jobs/tools/generate_tracers_xml.py +++ b/jobs/tools/generate_tracers_xml.py @@ -2,6 +2,7 @@ import xml.dom.minidom import numpy as np + def generate_tracers_xml(data, nens=-1, restart=False): """ Generate an XML representation for chemtracers. @@ -34,7 +35,9 @@ def generate_tracers_xml(data, nens=-1, restart=False): if any(key == "oem_cat" for key in item_data): # Make an OEM tracer tracer = ET.SubElement(tracers, "chemtracer", id=item_id) - ET.SubElement(tracer, "transport", type="char").text = "stdaero" if not item_id.startswith("EM_") else "off" + ET.SubElement( + tracer, "transport", type="char" + ).text = "stdaero" if not item_id.startswith("EM_") else "off" ET.SubElement(tracer, "c_solve", type="char").text = "passive" ET.SubElement(tracer, "init_mode", type="int").text = "0" ET.SubElement(tracer, "unit", type="char").text = "none" @@ -52,39 +55,54 @@ def generate_tracers_xml(data, nens=-1, restart=False): ET.SubElement(tracer_bg, "c_solve", type="char").text = "passive" ET.SubElement(tracer_bg, "init_mode", type="int").text = "1" ET.SubElement(tracer_bg, "unit", type="char").text = "none" - ET.SubElement(tracer_bg, "init_name", type="char").text = item_data["init_name"] + ET.SubElement(tracer_bg, "init_name", + type="char").text = item_data["init_name"] ET.SubElement(tracer_bg, "oem_type", type="char").text = "bg" if restart: - ET.SubElement(tracer_bg, "oem_restart", type="char").text = "file" + ET.SubElement(tracer_bg, "oem_restart", + type="char").text = "file" ET.SubElement(tracer_bg, "latbc", type="char").text = "file" if any(key == "oem_ftype" for key in item_data): # Make a VPRM tracer tracer_ra = ET.SubElement(tracers, "chemtracer", id=item_id) - ET.SubElement(tracer_ra, "transport", type="char").text = "stdaero" if not item_id.startswith("EM_") else "off" + ET.SubElement( + tracer_ra, "transport", type="char" + ).text = "stdaero" if not item_id.startswith("EM_") else "off" ET.SubElement(tracer_ra, "c_solve", type="char").text = "passive" ET.SubElement(tracer_ra, "init_mode", type="int").text = "0" ET.SubElement(tracer_ra, "unit", type="char").text = "none" ET.SubElement(tracer_ra, "oem_type", type="char").text = "vprm" - ET.SubElement(tracer_ra, "oem_ftype", type="char").text = item_data["oem_ftype"] + ET.SubElement(tracer_ra, "oem_ftype", + type="char").text = item_data["oem_ftype"] if restart and not item_id.startswith("EM_"): - ET.SubElement(tracer_ra, "oem_restart", type="char").text = "file" + ET.SubElement(tracer_ra, "oem_restart", + type="char").text = "file" if item_id.endswith("XXX"): # Make a set of ensemble tracers for i in np.arange(nens) + 1: - tracer_xxx = ET.SubElement(tracers, "chemtracer", id=f"TRCO2_A-{i:03}") - ET.SubElement(tracer_xxx, "transport", type="char").text = "stdaero" + tracer_xxx = ET.SubElement(tracers, + "chemtracer", + id=f"TRCO2_A-{i:03}") + ET.SubElement(tracer_xxx, "transport", + type="char").text = "stdaero" ET.SubElement(tracer_xxx, "oem_type", type="char").text = "ens" - ET.SubElement(tracer_xxx, "c_solve", type="char").text = "passive" + ET.SubElement(tracer_xxx, "c_solve", + type="char").text = "passive" ET.SubElement(tracer_xxx, "init_mode", type="int").text = "0" if "bg" in item_data: - ET.SubElement(tracer_xxx, "oem_bg_ens", type="char").text = item_data["bg"] + ET.SubElement(tracer_xxx, "oem_bg_ens", + type="char").text = item_data["bg"] if "ra" in item_data and "gpp" in item_data: - ET.SubElement(tracer_xxx, "oem_vprm_bg_ens", type="char").text = f"{item_data['ra']}, {item_data['gpp']}" + ET.SubElement( + tracer_xxx, "oem_vprm_bg_ens", type="char" + ).text = f"{item_data['ra']}, {item_data['gpp']}" if restart: - ET.SubElement(tracer_xxx, "oem_restart", type="char").text = "file" + ET.SubElement(tracer_xxx, "oem_restart", + type="char").text = "file" ET.SubElement(tracer_xxx, "unit", type="char").text = "none" # Convert to string xml_declaration = "\n\n" xml_string = ET.tostring(tracers, encoding="unicode") - return xml.dom.minidom.parseString(xml_declaration + xml_string).toprettyxml() + return xml.dom.minidom.parseString(xml_declaration + + xml_string).toprettyxml() From d96d694b739f6360f318b1029af89ef1b38a3a37 Mon Sep 17 00:00:00 2001 From: efmkoene Date: Fri, 7 Feb 2025 15:00:45 +0100 Subject: [PATCH 30/42] Removed NAMELIST_ICONSUB from tracking --- NAMELIST_ICONSUB | 11 ----------- 1 file changed, 11 deletions(-) delete mode 100644 NAMELIST_ICONSUB diff --git a/NAMELIST_ICONSUB b/NAMELIST_ICONSUB deleted file mode 100644 index 70f9f29b..00000000 --- a/NAMELIST_ICONSUB +++ /dev/null @@ -1,11 +0,0 @@ -&iconsub_nml - grid_filename = '/scratch/snx3000/ekoene/test_chain/procchain/processing-chain/work/icon-art-CTDAS/2018010100_2018011100/icon/input/icon_europe_DOM01.nc', - output_type = 4, - lwrite_grid = .TRUE., -/ -&subarea_nml - ORDER = "lateral_boundary", - grf_info_file = '/scratch/snx3000/ekoene/test_chain/procchain/processing-chain/work/icon-art-CTDAS/2018010100_2018011100/icon/input/icon_europe_DOM01.nc', - min_refin_c_ctrl = 1 - max_refin_c_ctrl = 14 -/ From d6ad3b1203c0e984956e87db1d0720f509cbd946 Mon Sep 17 00:00:00 2001 From: efmkoene Date: Tue, 4 Mar 2025 16:15:39 +0100 Subject: [PATCH 31/42] First CTDAS case working --- cases/icon-art-CTDAS/ICON/ICON_template.job | 15 +- cases/icon-art-CTDAS/ICON/Michael_sampler.py | 362 +++++ cases/icon-art-CTDAS/config.yaml | 134 +- .../ctdas_patch/carbontracker_icon_oco2.rc | 35 + .../icon-art-CTDAS/ctdas_patch/icon_helper.py | 1330 +++++++++++++++++ .../ctdas_patch/icon_sampler.py | 269 ++++ .../ctdas_patch/initexit_cteco2.py | 681 +++++++++ .../ctdas_patch/obs_class_ICOS_OCO2.py | 964 ++++++++++++ .../ctdas_patch/obsoperator_ICOS_OCO2.py | 591 ++++++++ .../optimizer_baseclass_icos_cities.py | 661 ++++++++ .../ctdas_patch/pipeline_icon.py | 505 +++++++ .../statevector_baseclass_icos_cities.py | 568 +++++++ cases/icon-art-CTDAS/ctdas_patch/template.jb | 16 + cases/icon-art-CTDAS/ctdas_patch/template.py | 81 + cases/icon-art-CTDAS/ctdas_patch/template.rc | 90 ++ cases/icon-art-CTDAS/ctdas_patch/utilities.py | 319 ++++ .../icon-art-CTDAS2/ICBC/icon_era5_inicond.sh | 179 +++ .../icon-art-CTDAS2/ICBC/icon_era5_nudging.sh | 63 + .../ICBC/icon_era5_splitfiles.sh | 40 + .../ICBC/icon_species_inicond.sh | 58 + .../ICBC/icon_species_nudging.sh | 77 + cases/icon-art-CTDAS2/ICON/ICON_template.job | 386 +++++ cases/icon-art-CTDAS2/authentification.ipynb | 83 + cases/icon-art-CTDAS2/config.yaml | 253 ++++ .../ctdas_patch/carbontracker_icon_oco2.rc | 31 + .../ctdas_patch/icon_helper.py | 1329 ++++++++++++++++ .../ctdas_patch/icon_sampler.py | 269 ++++ .../ctdas_patch/obs_class_ICOS_OCO2.py | 1061 +++++++++++++ .../ctdas_patch/obsoperator_ICOS_OCO2.py | 766 ++++++++++ .../optimizer_baseclass_icos_cities.py | 703 +++++++++ .../statevector_baseclass_icos_cities.py | 643 ++++++++ cases/icon-art-CTDAS2/ctdas_patch/template.jb | 16 + cases/icon-art-CTDAS2/ctdas_patch/template.py | 81 + cases/icon-art-CTDAS2/ctdas_patch/template.rc | 116 ++ .../icon-art-CTDAS2/ctdas_patch/utilities.py | 319 ++++ cases/icon-art-CTDAS2/map_file.ana | 109 ++ cases/icon-art-CTDAS2/mypartab | 117 ++ cases/icon-art-CTDAS2/wrapper_icon.sh | 1 + config.py | 6 +- jobs/CTDAS.py | 128 +- jobs/__init__.py | 1 + jobs/prepare_CTDAS.py | 697 ++++----- jobs/tools/ICON_to_point.py | 67 +- jobs/tools/ICON_to_point2.py | 52 + jobs/tools/ctdas_utilities.py | 93 +- jobs/tools/fetch_external_data.py | 65 +- jobs/tools/generate_tracers_xml.py | 85 +- 47 files changed, 13964 insertions(+), 551 deletions(-) create mode 100644 cases/icon-art-CTDAS/ICON/Michael_sampler.py create mode 100644 cases/icon-art-CTDAS/ctdas_patch/carbontracker_icon_oco2.rc create mode 100644 cases/icon-art-CTDAS/ctdas_patch/icon_helper.py create mode 100755 cases/icon-art-CTDAS/ctdas_patch/icon_sampler.py create mode 100755 cases/icon-art-CTDAS/ctdas_patch/initexit_cteco2.py create mode 100644 cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py create mode 100644 cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py create mode 100644 cases/icon-art-CTDAS/ctdas_patch/optimizer_baseclass_icos_cities.py create mode 100644 cases/icon-art-CTDAS/ctdas_patch/pipeline_icon.py create mode 100644 cases/icon-art-CTDAS/ctdas_patch/statevector_baseclass_icos_cities.py create mode 100644 cases/icon-art-CTDAS/ctdas_patch/template.jb create mode 100644 cases/icon-art-CTDAS/ctdas_patch/template.py create mode 100644 cases/icon-art-CTDAS/ctdas_patch/template.rc create mode 100644 cases/icon-art-CTDAS/ctdas_patch/utilities.py create mode 100644 cases/icon-art-CTDAS2/ICBC/icon_era5_inicond.sh create mode 100644 cases/icon-art-CTDAS2/ICBC/icon_era5_nudging.sh create mode 100644 cases/icon-art-CTDAS2/ICBC/icon_era5_splitfiles.sh create mode 100644 cases/icon-art-CTDAS2/ICBC/icon_species_inicond.sh create mode 100644 cases/icon-art-CTDAS2/ICBC/icon_species_nudging.sh create mode 100644 cases/icon-art-CTDAS2/ICON/ICON_template.job create mode 100644 cases/icon-art-CTDAS2/authentification.ipynb create mode 100644 cases/icon-art-CTDAS2/config.yaml create mode 100644 cases/icon-art-CTDAS2/ctdas_patch/carbontracker_icon_oco2.rc create mode 100644 cases/icon-art-CTDAS2/ctdas_patch/icon_helper.py create mode 100755 cases/icon-art-CTDAS2/ctdas_patch/icon_sampler.py create mode 100644 cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py create mode 100644 cases/icon-art-CTDAS2/ctdas_patch/obsoperator_ICOS_OCO2.py create mode 100644 cases/icon-art-CTDAS2/ctdas_patch/optimizer_baseclass_icos_cities.py create mode 100644 cases/icon-art-CTDAS2/ctdas_patch/statevector_baseclass_icos_cities.py create mode 100644 cases/icon-art-CTDAS2/ctdas_patch/template.jb create mode 100644 cases/icon-art-CTDAS2/ctdas_patch/template.py create mode 100644 cases/icon-art-CTDAS2/ctdas_patch/template.rc create mode 100644 cases/icon-art-CTDAS2/ctdas_patch/utilities.py create mode 100644 cases/icon-art-CTDAS2/map_file.ana create mode 100644 cases/icon-art-CTDAS2/mypartab create mode 120000 cases/icon-art-CTDAS2/wrapper_icon.sh create mode 100644 jobs/tools/ICON_to_point2.py diff --git a/cases/icon-art-CTDAS/ICON/ICON_template.job b/cases/icon-art-CTDAS/ICON/ICON_template.job index 94993e4c..f2043029 100644 --- a/cases/icon-art-CTDAS/ICON/ICON_template.job +++ b/cases/icon-art-CTDAS/ICON/ICON_template.job @@ -1,7 +1,7 @@ #!/bin/bash -l #SBATCH --uenv="icon-wcp/v1:rc4" #SBATCH --job-name="{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.forecasttime}" -#SBATCH --time=00:40:00 +#SBATCH --time=00:50:00 #SBATCH --account={cfg.compute_account} #SBATCH --nodes={cfg.nodes} #SBATCH --ntasks-per-node={cfg.ntasks_per_node} @@ -372,15 +372,6 @@ cat > NAMELIST_NWP << EOF / EOF -handle_error(){{ - set +e - # Check for invalid pointer error at the end of icon-art - if grep -q "free(): invalid pointer" {cfg.logfile} && grep -q "clean-up finished" {cfg.logfile}; then - exit 0 - else - exit 1 - fi - set -e -}} + cp {cfg.icon_executable} icon -srun ../input/wrapper_icon.sh ./icon || handle_error \ No newline at end of file +srun /capstor/scratch/cscs/ekoene/icon-kit/run/run_wrapper/alps_mch_gpu.sh ./icon \ No newline at end of file diff --git a/cases/icon-art-CTDAS/ICON/Michael_sampler.py b/cases/icon-art-CTDAS/ICON/Michael_sampler.py new file mode 100644 index 00000000..b906bd23 --- /dev/null +++ b/cases/icon-art-CTDAS/ICON/Michael_sampler.py @@ -0,0 +1,362 @@ +# %% +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Mon Nov 29 19:38:13 2021 + +@author: stem +""" + + +#%% +"""Import""" +from shapely.geometry import Point, Polygon +from netCDF4 import Dataset +import os +import numpy as np +import datetime +from multiprocessing import Pool +from itertools import repeat +from math import sin, cos, sqrt, atan2, radians +import xarray as xr +from multiprocessing import Process, Manager +from unidecode import unidecode + +#%% + +# mountain_stations = {mountain_stations} +# ICON_grid = {ICON_grid} +# fname_base = 'ICON-ART-UNSTR' +# DATA_path = {DATA_path} +# starttime = {starttime} +# enddtime = {endtime} +# obs_dir = {observation_dir} +# nlev = 60 #number of vertical levels +# nneighb = 5 #number of nearest neighbors to consider +# n_member = {n_member} +# meta = { +# 'TRCO2_A': {'offset': 0.}, +# 'TRCO2_BG': {'offset': 0.}, +# 'CO2_RA': {'offset': 0.}, +# 'CO2_GPP': {'offset': 0.}, +# 'u': {'offset': 0.}, +# 'v': {'offset': 0.}, +# 'qv': {'offset': 0.}, +# 'temp': {'offset': 0.}, +# # 'biosink_chemtr': {'offset': 0.}, +# # 'biosource_all_chemtr': {'offset': 0.}, +# 'TRCO2_A-ENS': {'offset': 0, 'ensemble': n_member}, +# } +# outfile = {outfile} + +"""Interpolation function""" + +# def intp_icon_data(args): +def intp_icon_data(iloc, gridinfo, datainfo, latitudes, longitudes, asl, elev, station_name, mountain_stations): + + nn_sel = np.zeros(gridinfo.nn) + u=np.zeros(gridinfo.nn) + + R = 6373.0 # approximate radius of earth in km + + + if (radians(longitudes[iloc])np.nanmax(gridinfo.clon)): + u[:] = np.nan + return np.zeros((gridinfo.nn)), np.zeros((gridinfo.nn)).astype(int), np.zeros((gridinfo.nn)).astype(int), nn_sel[:], u[:] + + + if (radians(latitudes[iloc])np.nanmax(gridinfo.clat)): + u[:] = np.nan + return np.zeros((gridinfo.nn)), np.zeros((gridinfo.nn)).astype(int), np.zeros((gridinfo.nn)).astype(int), nn_sel[:], u[:] + + #% + lat1 = radians(latitudes[iloc]) + lon1 = radians(longitudes[iloc]) + + #% + """FIND 4 CLOSEST CENTERS""" + distances = np.zeros((len(gridinfo.clon))) + for icell in np.arange(len(gridinfo.clon)): + lat2 = gridinfo.clat[icell] + lon2 = gridinfo.clon[icell] + dlon = lon2 - lon1 + dlat = lat2 - lat1 + a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2 + c = 2 * atan2(sqrt(a), sqrt(1 - a)) + distances[icell] = R * c + nn_sel[:] = [x for _, x in sorted(zip(distances,np.arange(len(gridinfo.clon))))][0:gridinfo.nn] + nn_sel=nn_sel.astype(int) + #print('---nn_sel:',nn_sel) + #print('---distances[0:gridinfo.nn]:',distances[0:gridinfo.nn]) + u[:] = [1./distances[y] for y in nn_sel] + print('---distances:',[distances[y] for y in nn_sel]) + print('---weights:',u) + + #% + """Calculate vertical interpolation factor""" + idx_above = -1*np.ones((len(nn_sel))).astype(int) + idx_below = -1*np.ones((len(nn_sel))).astype(int) + target_asl = np.zeros((len(nn_sel))) + for nnidx in np.arange(len(nn_sel)): + model_topo = datainfo.z_ifc[-1,nn_sel[nnidx]] + print(station_name[iloc]) + if station_name[iloc] not in mountain_stations: + print('not a mountain station') + target_asl[nnidx] = model_topo + elev[iloc] + else: + print('mountain station') + target_asl[nnidx] = asl[iloc] + elev[iloc] + for i_mc,mc in enumerate(datainfo.z_mc[:,nn_sel[nnidx]]): + # if mc>=asl[iloc]: + if mc>=target_asl[nnidx]: + idx_above[nnidx] = i_mc + else: + idx_below[nnidx] = i_mc + break + + + #in case of data point below lowest midlevel: + for nnidx in np.arange(len(nn_sel)): + if idx_below[nnidx]==-1: + idx_below[nnidx] = idx_above[nnidx] + if any(np.ravel([idx_above,idx_below])<0): + print("At least one nearest neigbor has no valid height levels") + u[:] = np.nan #-999. + return np.zeros((gridinfo.nn)), np.zeros((gridinfo.nn)).astype(int), np.zeros((gridinfo.nn)).astype(int), nn_sel[:], u + + vert_scaling_fact = np.zeros((len(nn_sel))) + for nnidx in np.arange(len(nn_sel)): + if idx_below[nnidx] != idx_above[nnidx]: + vert_scaling_fact[nnidx] = (target_asl[nnidx]-datainfo.z_mc[idx_below[nnidx],nn_sel[nnidx]])/(datainfo.z_mc[idx_above[nnidx],nn_sel[nnidx]]-datainfo.z_mc[idx_below[nnidx],nn_sel[nnidx]]) + else: + vert_scaling_fact[nnidx] = 0. + + print('---idx above:',idx_above) + print('---idx below:',idx_below) + print('---vert_scaling_fact:',vert_scaling_fact) + + #% + + return vert_scaling_fact, idx_below, idx_above, nn_sel[:], u + + +def ICON_sampler(DATA_path, fname_base, ICON_grid, starttime, endtime, obs_dir, nneighb, meta, outfile, nlev=60, mountain_stations=[]): + fh_grid = Dataset(ICON_grid,'r') + class gridinfo: + clon_vertices = np.array(fh_grid.variables['clon_vertices']) + clat_vertices = np.array(fh_grid.variables['clat_vertices']) + cells_of_vertex = np.array(fh_grid.variables['cells_of_vertex']) + vertex_of_cell = np.array(fh_grid.variables['vertex_of_cell']) + neighbor_cell_index = np.array(fh_grid.variables['neighbor_cell_index']) + vlon = np.array(fh_grid.variables['vlon']) + vlat = np.array(fh_grid.variables['vlat']) + clon = np.array(fh_grid.variables['clon']) + clat = np.array(fh_grid.variables['clat']) + ncells = len(fh_grid.dimensions['cell']) + nn=nneighb + + #%% + + """Times""" + + firstfile=True + startdate = datetime.datetime.strptime(starttime,'%Y-%m-%d %H:%M:%S') + enddate = datetime.datetime.strptime(endtime,'%Y-%m-%d %H:%M:%S') + delta = datetime.timedelta(hours=1) + looptime = startdate + + #%% + + """Get locations of measurement stations""" + + + longitudes = [] + latitudes = [] + obsnames = [] + # stationnames = [] + asl = [] + elev = [] + #for station in stationlist: + for ncfile in os.listdir(obs_dir): + if not ncfile.endswith('.nc'): continue + if not startdate.strftime('%Y%m%d') in ncfile: continue + + infile = os.path.join(obs_dir, ncfile) + print(f"Reading {infile}") + + f = xr.open_dataset(infile) + stationnames = f.Stations_names.values + st_ind = np.arange(len(stationnames)) + for x in st_ind: + latitudes.append(f.Lat[x].values) + obsnames.append(unidecode(str(f.Stations_names[x].values))) + longitudes.append(f.Lon[x].values) + asl.append(f.Stations_masl[x]) + elev.append( float(obsnames[-1].split('_')[-1]) ) + print("Found %i locations."%(len(latitudes))) + + # """Add 5 missing stations""" + # missing_longitudes = [-1.15, 4.93, 0.23, 8.4, 8.18] + # missing_latitudes = [54.36, 51.97, 50.98, 47.48, 47.19] + # missing_stationnames = ['bsd', 'cbw', 'hea', 'lae', 'beo'] + # missing_asl = [628.,200.,250.,872.,1009.] + # for imiss in np.arange(len(missing_longitudes)): + # latitudes.append(missing_latitudes[imiss]) + # longitudes.append(missing_longitudes[imiss]) + # stationnames.append(missing_stationnames[imiss]) + # asl.append(missing_asl[imiss]) + # print("Added %i missing locations."%(len(missing_longitudes))) + + #%% + + """Initialize output variables""" + n_det = int(np.nansum([1 for var in meta.keys() if 'ensemble' not in meta[var]])) + n_ens = int(np.nansum([1 for var in meta.keys() if 'ensemble' in meta[var]])) + intp_ICON_data_det = np.zeros((n_det,len(latitudes),0)) + maxmem=0 + for var in meta.keys(): + if 'ensemble' in meta[var]: + if meta[var]['ensemble']>maxmem: + maxmem=meta[var]['ensemble'] + maxmem=int(maxmem) + intp_ICON_data_ens = np.zeros((n_ens,maxmem,len(latitudes),0)) + #%% + + """Loop over Data Files (=timesteps)""" + def process_data(index, gridinfo, datainfo, latitudes, longitudes, asl, elev, obsnames, mountain_stations, results): + result = intp_icon_data(index, gridinfo, datainfo, latitudes, longitudes, asl, elev, obsnames, mountain_stations) + results.append((index, result)) + + datetime_list = [] + print('======================================') + date_idx = 0 + while looptime <= enddate: + + intp_ICON_data_det = np.concatenate(( intp_ICON_data_det,np.zeros((n_det,len(latitudes),1)) ),axis=2) + intp_ICON_data_ens = np.concatenate(( intp_ICON_data_ens,np.zeros((n_ens,maxmem,len(latitudes),1)) ),axis=3) + + timestring = datetime.datetime.strftime(looptime,'%Y-%m-%dT%H') + datetime_list.append(timestring) + DATA_file = os.path.join(DATA_path,'%s_%s:00:00.000.nc' %(fname_base,timestring)) + + print('extracting from %s'%(DATA_file), flush=True) + + + fh_data = Dataset(DATA_file,'r') + + class datainfo: + z_mc = np.array(fh_data.variables['z_mc']) + z_ifc = np.array(fh_data.variables['z_ifc']) + + + ICON_data_det = np.zeros(( n_det, nlev, gridinfo.ncells )) + ICON_data_ens = np.zeros(( n_ens, maxmem, nlev, gridinfo.ncells )) + ivar = 0 + for var in meta.keys(): + if not 'ensemble' in meta[var]: + ICON_data_det[ivar,...] = np.array(fh_data.variables[var]) + ivar+=1 + ivar = 0 + for var in meta.keys(): + if 'ensemble' in meta[var]: + # for iens in np.arange(n_member): + for iens in np.arange(meta[var]['ensemble']): + varnc = var.split('-')[0]+'-%.3i'%(iens+1) + ICON_data_ens[ivar,iens,...] = np.array(fh_data.variables[varnc]) + ivar+=1 + #%% + + """Since the stations don't walk around, I only call the function at the first timestep""" + + if looptime == startdate: + manager = Manager() + results = manager.list() + processes = [] + + for i in range(len(latitudes)): + p = Process(target=process_data, args=(i, gridinfo, datainfo, latitudes, longitudes, asl, elev, obsnames, mountain_stations, results)) + processes.append(p) + p.start() + + for p in processes: + p.join() + + # Sort the results based on the index + results = sorted(results, key=lambda x: x[0]) + + # Extract the sorted results + sorted_results = [result for _, result in results] + vsf, idxb, idxa, neighbours, u_ret = zip(*sorted_results) + + + vsf = np.array(vsf) + idxb = np.array(idxb, dtype=int) + idxa = np.array(idxa, dtype=int) + neighbours = np.array(neighbours, dtype=int) + u_ret = np.array(u_ret) + + #Do the interpolation + for iloc in np.arange(len(latitudes)): + + ###First, the deterministic values: + ##First, the vertical interpolation: + vert_intp_data = np.zeros(( n_det, len(idxb[iloc]) )) + for nn in np.arange(len(idxb[iloc])): + vert_intp_data[:,nn] = ICON_data_det[:,idxb[iloc,nn],neighbours[iloc,nn]] + vsf[iloc,nn]*(ICON_data_det[:,idxa[iloc,nn],neighbours[iloc,nn]] \ + -ICON_data_det[:,idxb[iloc,nn],neighbours[iloc,nn]]) + ##Now the horizontal interpolation: + #intp_ICON_data_det[:,iloc,date_idx] = u_ret[iloc,0]*vert_intp_data[:,0]+u_ret[iloc,1]*vert_intp_data[:,1] \ + # +u_ret[iloc,2]*vert_intp_data[:,2] + # + intp_ICON_data_det[:,iloc,date_idx] = np.nansum([w*vert_intp_data[:,i] for i,w in enumerate(u_ret[iloc,:])],axis=0)/np.nansum(u_ret[iloc,:]) + ###Second, the ensemble values: + vert_intp_data = np.zeros(( n_ens, maxmem, len(idxb[iloc]) )) + for nn in np.arange(len(idxb[iloc])): + vert_intp_data[:,:,nn] = ICON_data_ens[:,:,idxb[iloc,nn],neighbours[iloc,nn]] + vsf[iloc,nn]*(ICON_data_ens[:,:,idxa[iloc,nn],neighbours[iloc,nn]] \ + -ICON_data_ens[:,:,idxb[iloc,nn],neighbours[iloc,nn]]) + #intp_ICON_data_ens[:,:,iloc,date_idx] = u_ret[iloc,0]*vert_intp_data[:,:,0]+u_ret[iloc,1]*vert_intp_data[:,:,1] \ + # +u_ret[iloc,2]*vert_intp_data[:,:,2] + intp_ICON_data_ens[:,:,iloc,date_idx] = np.nansum([w*vert_intp_data[:,:,i] for i,w in enumerate(u_ret[iloc,:])],axis=0)/np.nansum(u_ret[iloc,:]) + #%% + """Update time""" + looptime += delta + date_idx += 1 + #%% + """Save as netcdf""" + with Dataset(outfile, mode='w') as ofile: + + osites = ofile.createDimension('sites', len(latitudes)) + otime = ofile.createDimension('time', (date_idx)) + + oname = ofile.createVariable('site_name', str, ('sites')) + otimes = ofile.createVariable('time', np.unicode_, ('time')) + + ivar = 0 + for var in meta.keys(): + if 'ensemble' not in meta[var]: + ovar = ofile.createVariable(var, np.float32, ('sites','time')) + ovar[:,:] = intp_ICON_data_det[ivar,:,:] + ivar+=1 + ivar=0 + for var in meta.keys(): + if 'ensemble' in meta[var]: + oens = ofile.createDimension('ens_%.2i'%(ivar+1), meta[var]['ensemble']) + varnc = var.split('-')[0]+'_ENS' + ovar = ofile.createVariable(varnc, np.float32, ('ens_%.2i'%(ivar+1),'sites','time')) + ovar[:,:,:] = intp_ICON_data_ens[ivar,0:meta[var]['ensemble'],:,:] + ivar+=1 + + + oname[:] = np.array(stationnames[:]) + otimes[:] = np.array(datetime_list) + + + +if __name__ == '__main__': + sample_ICON = ICON_sampler("/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/prior_20180101", + "ICON-ART-UNSTR", + "/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_inputs/grid/icon_europe_DOM01.nc", + "2018-01-01 00:00:00", "2018-01-12 00:00:00", "/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_inputs/ICOS", 5, + {'TRCO2_A': {}, 'TRCO2_BG': {}, 'CO2_RA': {}, 'CO2_GPP': {}, 'TRCO2_A-ENS': {'ensemble': 186}, 'biosource': {}, 'biosink': {}, 'u': {}, 'v': {}, 'temp': {}, 'qv': {}}, + "/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/prior_20180101.nc", + nlev=60, mountain_stations=['Jungfraujoch_13', 'Monte Cimone_8', 'Puy de Dome_10', 'Pic du Midi_28', 'Zugspitze_3', 'Hohenpeissenberg_50', 'Hohenpeissenberg_93', 'Hohenpeissenberg_131', 'Schauinsland_12', 'Plateau Rosa_10']) diff --git a/cases/icon-art-CTDAS/config.yaml b/cases/icon-art-CTDAS/config.yaml index 6dd8afcd..ebb1f497 100644 --- a/cases/icon-art-CTDAS/config.yaml +++ b/cases/icon-art-CTDAS/config.yaml @@ -21,7 +21,7 @@ tracers: TRCO2_A: oem_cat: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" oem_vp: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" - oem_tp: "GNFR_A-CO2, GNFR_B-CO2, GNFR_C-CO2, GNFR_D-CO2, GNFR_A-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_G-CO2, GNFR_H-CO2, GNFR_I-CO2, GNFR_J-CO2, GNFR_L-CO2, L-CO2" + oem_tp: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" TRCO2_BG: init_name: "CO2" CO2_RA: @@ -33,17 +33,25 @@ tracers: ra: "CO2_RA" gpp: "CO2_GPP" biosource: - oem_cat: "co2fire, allcropsource, allwoodsource, lakeriveremis, cflx" - oem_vp: "A-CO2, A-CO2, A-CO2, A-CO2, A-CO2" - oem_tp: "GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2" + oem_cat: "GFAS1, GFAS2, GFAS3, GFAS4, GFAS5, GFAS6, GFAS7, GFAS8, GFAS9, GFAS10, allcropsource, allwoodsource, lakeriveremis, cflx" + oem_vp: "L-CO2, L-CO2, L-CO2, L-CO2, L-CO2, L-CO2, L-CO2, L-CO2, L-CO2, L-CO2, L-CO2, L-CO2, L-CO2, L-CO2" + oem_tp: "GFAS1, GFAS2, GFAS3, GFAS4, GFAS5, GFAS6, GFAS7, GFAS8, GFAS9, GFAS10, L-CO2, L-CO2, L-CO2, L-CO2" biosink: oem_cat: "biofuelcropsource, biofuelwoodsource, mflx" - oem_vp: "A-CO2, A-CO2, A-CO2" - oem_tp: "GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2" - + oem_vp: "L-CO2, L-CO2, L-CO2" + oem_tp: "L-CO2, L-CO2, L-CO2" + EM_TRCO2_A: + oem_cat: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" + oem_vp: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" + oem_tp: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" + EM_CO2_RA: + oem_ftype: "resp" + EM_CO2_GPP: + oem_ftype: "gpp" ####### CTDAS options. -# First of all, download https://git.wur.nl/ctdas/CTDAS/-/tree/ctdas-icon -# (i.e., CTDAS with the ctdas-icon branch). +# First of all, do the following in your ~ (home) folder, e.g., +# git clone -b ctdas-icon https://git.wur.nl/ctdas/CTDAS.git ~/ctdas-icon +# We will PATCH that code # Execute `start_ctdas_icon.sh $SCRATCH ctdas_procchain` # which will put the CTDAS files into $SCRATCH/ctdas_procchain. # We will then 'patch' this CTDAS installation with the required files, @@ -55,6 +63,7 @@ tracers: # - rc-cteco2 file [which, ultimately, is how we pass general input like folder names etc to CTDAS] # - rc-job file [which, ultimately, is the setup for CTDAS like lag times, etc.] CTDAS: + runthrough: True # If true, this runs through the year without any optimization. Useful for getting the BG and other fields nlag: 2 tracer: co2 regions: basegrid # choose: basegrid or parentgrid @@ -62,17 +71,68 @@ CTDAS: # nregions: # read from cells->regions file restart_init_time: 86400 # 1 day in seconds; using Michael Steiner's "overwriting" restart mechanism ctdas_cycle: 10 # days + ctdas_nlag: 2 nboundaries: 8 + propagate_bg: True # If true, an additional ensemble member is created which just holds the background tracer lambdas: # The first 16 lambdas must be the respiration and uptake ones [even if not relevant, e.g., for a CH4 simulation], followed by the oem_cat categories in the xml file, in order of appearance, but excluding any - 1,1,1,1,1,1,1,1 # Respiration (Evergreen Forest, Deciduous Forest, Mixed Forest, Shrubland, Savanna, Cropland, Grassland, Urban/Other) - 1,1,1,1,1,1,1,1 # Uptake (E, D, M, S, SV, C, G, U) - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2 # Anthropogenic CO2 (ensemble tracer categories that are optimized) obs: # Run the 'authentification.ipynb' notebook to get access to ICOS and/or NASA Earthdata (OCO2) data - fetch_ICOS: True - ICOS_path: /capstor/scratch/cscs/ekoene/ICOS/ - fetch_OCO2: True - OCO2_path: /capstor/scratch/cscs/ekoene/OCO2 + ICOS: + fetch: False + path: /capstor/scratch/cscs/ekoene/ICOS/ + c_offset: 2 # ppm + mdm: + - Beromunster_212: 6.2383423 + c_offset + - Bilsdale_248: 3.8534036 + c_offset + - Biscarrosse_47: 3.5997221 + c_offset + - Cabauw_207: 6.6093283 + c_offset + - Carnsore Point_14: 2.1894007 + c_offset + - Ersa_40: 2.3997285 + c_offset + - Gartow_341: 4.570544 + c_offset + - Heidelberg_30: 8.660628 + c_offset + - Hohenpeissenberg_131: 4.0553513 + c_offset + - Hyltemossa_150: 3.485432 + c_offset + - Ispra_100: 9.612817 + c_offset + - Jungfraujoch_13: 1.0802848 + c_offset + - Karlsruhe_200: 8.05013 + c_offset + - Kresin u Pacova_250: 3.829324 + c_offset + - Heathfield_100: 4.6675706 + c_offset # <--- CHECK + - La Muela_80: 3.2093291 + c_offset + - Laegern-Hochwacht_32: 9.556924 + c_offset + - Lindenberg_98: 5.4387555 + c_offset + - Lutjewad_60: 5.651525 + c_offset + - Monte Cimone_8: 1.7325112 + c_offset + - Observatoire de Haute Provence_100: 4.146905 + c_offset + - Observatoire perenne de l'environnement_120: 6.8854113 + c_offset + - Pic du Midi_28: 1.2196398 + c_offset + - Plateau Rosa_10: 1.3211231 + c_offset + - Puy de Dome_10: 3.4529948 + c_offset + - Ridge Hill_90: 5.0861707 + c_offset + - Saclay_100: 6.8669567 + c_offset + - Schauinsland_12: 3.7896755 + c_offset + - Tacolneston_185: 4.6675706 + c_offset + - Torfhaus_147: 4.622525 + c_offset + - Trainou_180: 5.821612 + c_offset + - Weybourne_10: 4.4674397 + c_offset + - Zugspitze_3: 1.6796716 + c_offset + mountain_stations: + - Jungfraujoch_13 + - Monte Cimone_8 + - Puy de Dome_10 + - Pic du Midi_28 + - Zugspitze_3 + - Hohenpeissenberg_50 + - Hohenpeissenberg_93 + - Hohenpeissenberg_131 + - Schauinsland_12 + - Plateau Rosa_10 + OCO2: + fetch: True + path: /capstor/scratch/cscs/ekoene/OCO2 + localization: 400 # km -- currently applies to ICOS and OCO2 observations equally global_inputs: inventories: - /capstor/scratch/cscs/ekoene/inventories/INV_20180102.nc @@ -123,8 +183,45 @@ CTDAS: OEM: - /capstor/scratch/cscs/ekoene/inventories/icon_with_tno_emissions/vertical_profiles.nc - /capstor/scratch/cscs/ekoene/inventories/icon_with_tno_emissions/hourofyear.nc - # - /users/ekoene/CTDAS_inputs/vertical_profiles_t.nc - # - /users/ekoene/CTDAS_inputs/hourofyear8784.nc + ctdas_path: /users/ekoene/ctdas-icon + ctdas_patch: + templates: + - ctdas_patch/template.py + - ctdas_patch/template.rc # ADD THESE! + - ctdas_patch/template.jb # ADD THESE! + da/cyclecontrol: ctdas_patch/initexit_cteco2.py + da/statevectors: ctdas_patch/statevector_baseclass_icos_cities.py + da/observations: ctdas_patch/obs_class_ICOS_OCO2.py + da/obsoperators: ctdas_patch/obsoperator_ICOS_OCO2.py + da/optimizers: ctdas_patch/optimizer_baseclass_icos_cities.py + da/pipelines: ctdas_patch/pipeline_icon.py + da/rc/cteco2: ctdas_patch/carbontracker_icon_oco2.rc + da/tools/icon: + - ctdas_patch/utilities.py + - ctdas_patch/icon_helper.py + - ctdas_patch/icon_sampler.py + covariancematrix_definition: | + Corr = np.array([[1, 0], # VPRM has a 100% error + [0, 0.5]]) # Anthropogenic has a 50% error + specific_length_bio = 300 + specific_length_anth = 200 + exp_factors_anth = np.exp(-distances / specific_length_anth) + exp_factors_bio = np.exp(-distances / specific_length_bio) + + for ix, _ in enumerate(distances): + for ic in range(Corr.shape[0]): + for ik in range(Corr.shape[1]): + idx = ix * categories + ic + exp_factor = exp_factors_anth[ix] if ic == 1 or ik == 1 else exp_factors_bio[ix] + covariancematrix[idx, ik:-n_bg_params:categories] = exp_factor * Corr[ic, ik] + + #set variances for the 8 background elements + if n_bg_params>0: + for iii in np.arange(n_bg_params): + covariancematrix[-n_bg_params + iii , -n_bg_params + iii] = 0.015 * 0.015 # 0.015 * 400 = 6 ppm stdev + covariancematrix[-n_bg_params + (iii + 1) % n_bg_params, -n_bg_params + iii] = 0.015 * 0.015 * 0.25 # Neighbouring entries + covariancematrix[-n_bg_params + (iii - 1) % n_bg_params, -n_bg_params + iii] = 0.015 * 0.015 * 0.25 # Neighbouring entries + # # CTDAS ------------------------------------------------------------------------ @@ -173,7 +270,7 @@ CTDAS: # ctdas_regtype = 'olson19_oif30' cdo_nco_cmd: | - CLUSTER_NAME=todi uenv start icon-wcp --ignore-tty << 'EOF' + uenv start icon-wcp --ignore-tty << 'EOF' . /capstor/scratch/cscs/ekoene/tmp/spack-c2sm/setup-env.sh /user-environment/ spack load icontools cdo nco @@ -187,12 +284,11 @@ walltime: prepare_icon: '00:15:00' prepare_art_global: '00:10:00' icon: '00:05:00' - prepare_CTDAS: '20:00:00' + prepare_CTDAS: '00:00:00' meteo: nudging_step: 3 fetch_era5: True - interpolate_CAMS_to_ERA5: True url: https://cds-beta.climate.copernicus.eu/api key: 1c2e45b1-dd08-4bc4-90c8-15c06304ae69 era5_splitjob: ICBC/icon_era5_splitfiles.sh @@ -216,7 +312,7 @@ input_files: wrapper_filename: ./cases/icon-art-CTDAS/wrapper_icon.sh icon: - executable: /capstor/scratch/cscs/ekoene/spack-c2sm/spack/opt/spack/linux-sles15-neoverse_v2/nvhpc-24.3/icon-develop-sytqk6o7h5y3imrsevsswc2inxaegbpx/bin/icon + executable: /capstor/scratch/cscs/ekoene/tmp/spack-c2sm/spack/opt/spack/linux-sles15-neoverse_v2/nvhpc-24.3/icon-develop-sytqk6o7h5y3imrsevsswc2inxaegbpx/bin/icon runjob_filename: ICON/ICON_template.job # # era5_inijob: icon_era5_inicond.sh # # era5_nudgingjob: icon_era5_nudging.sh diff --git a/cases/icon-art-CTDAS/ctdas_patch/carbontracker_icon_oco2.rc b/cases/icon-art-CTDAS/ctdas_patch/carbontracker_icon_oco2.rc new file mode 100644 index 00000000..070eca69 --- /dev/null +++ b/cases/icon-art-CTDAS/ctdas_patch/carbontracker_icon_oco2.rc @@ -0,0 +1,35 @@ +! CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +! Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +! updates of the code. See also: http://www.carbontracker.eu. +! +! This program is free software: you can redistribute it and/or modify it under the +! terms of the GNU General Public License as published by the Free Software Foundation, +! version 3. This program is distributed in the hope that it will be useful, but +! WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +! FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. +! +! You should have received a copy of the GNU General Public License along with this +! program. If not, see . + +!!! Info for the CarbonTracker data assimilation system + +! For our case, 2*grid size + 8 +nparameters : {nregs*max(lambdas)+cfg.CTDAS_nboundaries} +dir.icon_sim : {cfg.case_root} + +! ICOS stuff +datadir : {cfg.case_root / "global_inputs" / "ICOS"} +obs.input.dir : {cfg.case_root / "global_inputs" / "ICOS"} +obspack.input.dir : {cfg.case_root / "global_inputs" / "ICOS"} + +! OCO2 stuff +obs.column.input.dir : {cfg.case_root / "global_inputs" / "OCO2"} +obs.column.ncfile : OCO2__ctdas.nc +obs.column.selection.variables : quality_flag +obs.column.selection.criteria : == 0 +mdm.calculation : 0.015 +sigma_scale : 0.5 +output_prefix : ICON-ART-UNSTR +icon_grid_path : {cfg.input_files_scratch_dynamics_grid_filename} +tracer_optim : TRCO2_A +obs.column.footprint_samples_dim : 1 \ No newline at end of file diff --git a/cases/icon-art-CTDAS/ctdas_patch/icon_helper.py b/cases/icon-art-CTDAS/ctdas_patch/icon_helper.py new file mode 100644 index 00000000..30df386a --- /dev/null +++ b/cases/icon-art-CTDAS/ctdas_patch/icon_helper.py @@ -0,0 +1,1330 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Created on Mon Jul 22 15:03:02 2019 + +This class contains helper functions mainly for sampling WRF-Chem, but a +few are also needed by the WRF-Chem column observation operator. + +@author: friedemann + +Modified on June 26, 10:40:12, 2023 +Adaptation for sampling ICON instead of WRF. + +@author: David Ho +""" + +# Instructions for pylint: +# pylint: disable=too-many-instance-attributes +# pylint: disable=W0201 +# pylint: disable=C0301 +# pylint: disable=E1136 +# pylint: disable=E1101 + + +import os +import shutil +import re +import glob +import bisect +import copy +import numpy as np +import netCDF4 as nc +import datetime as dt +#import wrf # Not needed, since working on ICON +#import f90nml # Not needed, used for reading wrf namelist +import pickle +import xarray as xr +import pandas as pd + +# CTDAS modules +import da.tools.io4 as io +from da.tools.icon.utilities import utilities + +# Erik added: +from datetime import datetime, timedelta + + +class ICON_Helper(object): + """Contains helper functions for sampling WRF-Chem""" + def __init__(self, settings): + self.settings = settings + + #def __init__(self): # Use this part for offline testing + # pass + + def validate_settings(self, needed_items=[]): + """ + This is based on WRFChemOO._validate_rc + """ + + if len(needed_items)==0: + return + + for key in needed_items: + if key not in self.settings: + msg = "Missing a required value in settings: %s" % key + raise IOError(msg) + + + @staticmethod + def get_pressure_boundaries_paxis(p_axis, p_surf): + """ + Arguments + --------- + p_axis (:class:`array-like`) + Pressure at mid points of layers + p_surf (:class:`numeric`) + Surface pressure + Output + ------ + Pressure at layer boundaries + """ + + #pb = np.array([float("nan")]*(len(p_axis)+1)) + #pb[0] = p_surf + # + #for nl in range(len(pb)-1): + # pb[nl+1] = pb[nl] + 2*(p_axis[nl] - pb[nl]) + # ^ commented out by David coz it didn't work + # v Added by David + p_full = np.insert(p_axis, 0, psurf, axis=1) # Insert p_surf to the first index + pb = np.array([float("nan")]*(len(p_axis)+1)) + pb[0] = p_surf + + for nl in range(len(pb)-1): + pb[nl+1] = 0.5*( p_full[nl] + p_full[nl+1] ) + + return pb + + @staticmethod + def get_pressure_boundaries_znw(znw, p_surf, p_top): + """ + Arguments + --------- + ZNW (:class:`ndarray`) + Eta coordinates of z-staggered WRF grid. For each + observation (2D) + p_surf (:class:`ndarray`) + Surface pressure (1D) + p_top (:class:`ndarray`) + Top-of-atmosphere pressure (1D) + Output + ------ + Pressure at layer boundaries + + CAVEATS + ------- + Maybe I should rather use P_HYD? Well, Butler et al. 2018 + (https://www.geosci-model-dev-discuss.net/gmd-2018-342/) used + znu and surface pressure to compute "WRF midpoint layer + pressure". + + For WRF it would be more consistent to interpolate to levels. + See also comments in code. + """ + + return znw*(p_surf-p_top) + p_top + + + @staticmethod + def get_int_coefs(pb_ret, pb_mod, level_def): + """ + Computes a coefficients matrix to transfer a model profile onto + a retrieval pressure axis. + + If level_def=="layer_average", this assumes that profiles are + constant in each layer of the retrieval, bound by the pressure + boundaries pb_ret. In this case, the WRF model layer is treated + in the same way, and coefficients integrate over the assumed + constant model layers. This works with non-staggered WRF + variables (on "theta" points). However, this is actually not how + WRF is defined, and the implementation should be changed to + z-staggered variables. Details for this change are in a comment + at the beginning of the code. + + If level_def=="pressure_boundary" (IMPLEMENTATION IN PROGRESS), + assumes that profiles, kernel and pwf are defined at pressure + boundaries that don't have a thickness (this is how OCO-2 data + are defined, for example). In this case, the coefficients + linearly interpolate adjacent model level points. This is + incompatible with the treatment of WRF in the above-described + layer-average assumption, but is closer to how WRF is actually + defined. The exception is that pb_mod is still constructed and + non-staggered variables are not defined at psurf. This can only + be fixed by switching to z-staggered variables. + + In cases where retrieval surface pressure is higher than model + surface pressure, and in cases where retrieval top pressure is + lower than model top pressure, the model profile will be + extrapolated with constant tracer mixing ratios. In cases where + retrieval surface pressure is lower than model surface pressure, + and in cases where retrieval top pressure is higher than model + top pressure, only the parts of the model column that fall + within the retrieval presure boundaries are sampled. + + Arguments + --------- + pb_ret (:class:`array_like`) + Pressure boundaries of the retrieval column + pb_mod (:class:`array_like`) + Pressure boundaries of the model column + level_def (:class:`string`) + "layer_average" or "pressure_boundary" (IMPLEMENTATION IN + PROGRESS). Refers to the retrieval profile. + + Note 2021-09-13: Inspected code for pressure_boundary. + Should be correct. Interpolates linearly between two model + levels. + + + Returns + ------- + coefs (:class:`array_like`) + Integration coefficient matrix. Each row sums to 1. + + Usage + ----- + .. code-block:: python + + import numpy as np + pb_ret = np.linspace(900., 50., 5) + pb_mod = np.linspace(1013., 50., 7) + model_profile = 1. - np.linspace(0., 1., len(pb_mod)-1)**3 + coefs = get_int_coefs(pb_ret, pb_mod, "layer_average") + retrieval_profile = np.matmul(coefs, model_profile) + """ + + if level_def == "layer_average": + # This code assumes that WRF variables are constant in + # layers, but they are defined on levels. This can be seen + # for example by asking wrf.interplevel for the value of a + # variable that is defined on the mass grid ("theta points") + # at a pressure slightly higher than the pressure on its + # grid (wrf.getvar(ncf, "p")), it returns nan. So There is + # no extrapolation. There are no layers. There are only + # levels. + # In addition, this page here: + # https://www.openwfm.org/wiki/How_to_interpret_WRF_variables + # says that to find values at theta-points of a variable + # living on u-points, you interpolate linearly. That's the + # other way around from what I would do if I want to go from + # theta to staggered. + # WRF4.0 user guide: + # - ungrib can interpolate linearly in p or log p + # - real.exe comes with an extrap_type namelist option, that + # extrapolates constantly BELOW GROUND. + # This would mean the correct way would be to integrate over + # a piecewise-linear function. It also means that I really + # want the value at surface level, so I'd need the CO2 + # fields on the Z-staggered grid ("w-points")! Interpolate + # the vertical in p with wrf.interp1d, example: + # wrf.interp1d(np.array(rh.isel(south_north=1, west_east=0)), + # np.array(p.isel(south_north=1, west_east=0)), + # np.array(988, 970)) + # (wrf.interp1d gives the same results as wrf.interplevel, + # but the latter just doesn't want to work with single + # columns (32,1,1), it wants a dim>1 in the horizontal + # directions) + # So basically, I can keep using pb_ret and pb_mod, but it + # would be more accurate to do the piecewise-linear + # interpolation and the output matrix will have 1 more + # value in each dimension. + + # Calculate integration weights by weighting with layer + # thickness. This assumes that both axes are ordered + # psurf to ptop. + coefs = np.ndarray(shape=(len(pb_ret)-1, len(pb_mod)-1)) + coefs[:] = 0. + + # Extend the model pressure grid if retrieval encompasses + # more. + pb_mod_tmp = copy.deepcopy(pb_mod) + + # In case the retrieval pressure is higher than the model + # surface pressure, extend the lowest model layer. + if pb_mod_tmp[0] < pb_ret[0]: + pb_mod_tmp[0] = pb_ret[0] + + # In case the model doesn't extend as far as the retrieval, + # extend the upper model layer upwards. + if pb_mod_tmp[-1] > pb_ret[-1]: + pb_mod_tmp[-1] = pb_ret[-1] + + # For each retrieval layer, this loop computes which + # proportion falls into each model layer. + for nret in range(len(pb_ret)-1): + + # 1st model pressure boundary index = the one before the + # first boundary with lower pressure than high-pressure + # retrieval layer boundary. + model_lower = pb_mod_tmp < pb_ret[nret] + id_model_lower = model_lower.nonzero()[0] + id_min = id_model_lower[0]-1 + + # Last model pressure boundary index = the last one with + # higher pressure than low-pressure retrieval layer + # boundary. + model_higher = pb_mod_tmp > pb_ret[nret+1] + + id_model_higher = model_higher.nonzero()[0] + + if len(id_model_higher) == 0: + #id_max = id_min + raise ValueError("This shouldn't happen. Debug.") + else: + id_max = id_model_higher[-1] + + # By the way, in case there is no model level with + # higher pressure than the next retrieval level, + # id_max must be the same as id_min. + + # For each model layer, find out how much of it makes up this + # retrieval layer + for nmod in range(id_min, id_max+1): + if (nmod == id_min) & (nmod != id_max): + # Part of 1st model layer that falls within + # retrieval layer + coefs[nret, nmod] = pb_ret[nret] - pb_mod_tmp[nmod+1] + elif (nmod != id_min) & (nmod == id_max): + # Part of last model layer that falls within + # retrieval layer + coefs[nret, nmod] = pb_mod_tmp[nmod] - pb_ret[nret+1] + elif (nmod == id_min) & (nmod == id_max): + # id_min = id_max, i.e. model layer encompasses + # retrieval layer + coefs[nret, nmod] = pb_ret[nret] - pb_ret[nret+1] + else: + # Retrieval layer encompasses model layer + coefs[nret, nmod] = pb_mod_tmp[nmod] - pb_mod_tmp[nmod+1] + + coefs[nret, :] = coefs[nret, :]/sum(coefs[nret, :]) + + # I tested the code with many cases, but I'm only 99.9% sure + # it works for all input. Hence a test here that the + # coefficients sum to 1 and dump the data if not. + sum_ = np.abs(coefs.sum(1) - 1) + if np.any(sum_ > 2.*np.finfo(sum_.dtype).eps): + dump = dict(pb_ret=pb_ret, + pb_mod=pb_mod, + level_def=level_def) + fp = "int_coefs_dump.pkl" + with open(fp, "w") as f: + pickle.dump(dump, f, 0) + + msg_fmt = "Something doesn't sum to 1. Arguments dumped to: %s" + raise ValueError(msg_fmt % fp) + + elif level_def=="pressure_boundary": + #msg = "level_def is pressure_boundary. Implementation not complete." + ##logging.error(msg) + #raise ValueError(msg) + # Note 2021-09-13: Inspected the code. Should be correct. + + # Go back to pressure midpoints for model... + # Change this line to p_mod = pb_mod for z-staggered + # variables + p_mod = pb_mod[1:] - 0.5*np.diff(pb_mod) # Interpolate linearly in pressure space + + coefs = np.ndarray(shape=(len(pb_ret), len(pb_mod)-1)) + coefs[:] = 0. + + # For each retrieval pressure level, compute linear + # interpolation coefficients + for nret in range(len(pb_ret)): + nmod_list = (p_mod < pb_ret[nret]).nonzero()[0] + if(len(nmod_list)>0): + nmod = nmod_list[0] - 1 + if nmod==-1: + # Constant extrapolation at surface + nmod = 0 + coef = 1. + else: + # Normal case: + coef = (pb_ret[nret]-p_mod[nmod+1])/(p_mod[nmod]-p_mod[nmod+1]) + else: + # Constant extrapolation at atmosphere top + nmod = len(p_mod)-2 + coef=0. + + coefs[nret, nmod] = coef + coefs[nret, nmod+1] = 1.-coef + + else: + msg = "Unknown level_def: " + level_def + raise ValueError(msg) + + return coefs + + @staticmethod + def get_pressure_weighting_function(pressure_boundaries, rule): + """ + Compute pressure weighting function according to 'rule'. + Valid rules are: + - simple (=layer thickness) + - connor2008 (not implemented) + """ + if rule == 'simple': + pwf = np.abs(np.diff(pressure_boundaries)/np.ptp(pressure_boundaries)) + else: + raise NotImplementedError("Rule %s not implemented" % rule) + + return pwf + + + ### David: Original function from ctdas-wrf ### + ### Keeping here as reference. ### + + def sample_total_columns(self, dat, loc, fields_list): + """ + Sample total_columns of fields_list in WRF output in + self.settings["run_dir"] at the location id_xy in domain, id_t + in all wrfout-times. Files and indices therein are recognized + by id_t and file_time_start_indices. + All quantities needed for computing total columns from profiles + are in dat (kernel, prior, ...). + + Arguments + --------- + dat (:class:`list`) + Result of wrfhelper.read_sampling_coords. Used here: prior, + prior_profile, kernel, psurf, pressure_axis, [, pwf] + If psurf or any of pressure_axis are nan, wrf's own + surface pressure is used and pressure_axis constructed + from this and the number of levels in the averaging kernel. + This allows sampling with synthetic data that don't have + pressure information. This only works with level_def + "layer_average". + If pwf is not present or nan, a simple one is created, for + level_def "layer_average". + loc (:class:`dict`) + A dictionary with all location-related input for sampling, + computed in wrfout_sampler. Keys: + id_xy, domain: Domain coordinates + id_t: Timestep (continous throughout all files) + frac_t: Interpolation coeficient between id_t and id_t+1: + t_obs = frac_t*t[id_t] + (1-frac_t)*t[id_t+1]) + file_start_time_indices: Time index at which a new wrfout + file starts + files: names of wrfout files. + fields_list (:class:`list`) + The fields to sample total columns from. + + Output + ------ + sampled_columns (:class:`array`) + A 2D-array of sampled columns. + Shape: (len(dat["prior"]), len(fields_list)) + """ + + # Initialize output + tc = np.ndarray(shape=(len(dat["prior"]), len(fields_list)), dtype=float) + tc[:] = float("nan") + + # Process by domain + UD = list(set(loc["domain"])) + # Added by David, above ^ returns [0,1] where domain 0 doesn't exsist + UD = [1] + for dom in UD: + idd = np.nonzero(loc["domain"] == dom)[0] + # Process by id_t + UT = list(set(loc["id_t"][idd])) + for time_id in UT: + # Coordinates to process + idt = idd[np.nonzero(loc["id_t"][idd] == time_id)[0]] + # Get tracer ensemble profiles + profiles = self._read_and_intrp_v(loc, fields_list, time_id, idt) + # List, len=len(fields_list), shape of each: (len(idt),nz) + # Get pressure axis: + #paxis = self.read_and_intrp(wh_names, id_ts, frac_t, id_xy, "P_HYD")/1e2 # Pa -> hPa + psurf = self._read_and_intrp_v(loc, ["PSFC"], time_id, idt)[0]/1.e2 # Pa -> hPa + # Shape: (len(idt),) + ptop = float(self.namelist["domains"]["p_top_requested"])/1.e2 + # Shape: (len(idt),) + znw = self._read_and_intrp_v(loc, ["ZNW"], time_id, idt)[0] + #Shape:(len(idt),nz) + + # DONE reading from file. + # Here it starts to make sense to loop over individual observations + for nidt in range(len(idt)): + nobs = idt[nidt] + # Construct model pressure layer boundaries + pb_mod = self.get_pressure_boundaries_znw(znw[nidt, :], psurf[nidt], ptop) + + if (np.diff(pb_mod) >= 0).any(): + msg = ("Model pressure boundaries for observation %d " + \ + "are not monotonically decreasing! Investigate.") % nobs + raise ValueError(msg) + + # Construct retrieval pressure layer boundaries + if dat["level_def"][nobs] == "layer_average": + if np.any(np.isnan(dat["pressure_levels"][nobs])) \ + or np.isnan(dat["psurf"][nobs]): + # Code for synthetic data without a pressure axis, + # but with an averaging kernel: + # Use wrf's surface and top pressure + nlayers = len(dat["averaging_kernel"][nobs]) + pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) + else: + nlayers = len(dat["averaging_kernel"][nobs]) + pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) + # Below commented out by David + # Because somehow doesn't work + #pb_ret = self.get_pressure_boundaries_paxis( + # dat["pressure_levels"][nobs], + # dat["psurf"][nobs]) + elif dat["level_def"][nobs] == "pressure_boundary": + if np.any(np.isnan(dat["pressure_levels"][nobs])): + # Code for synthetic data without a pressure axis, + # but with an averaging kernel: + # Use wrf's surface and top pressure + nlevels = len(dat["averaging_kernel"][nobs]) + pb_ret = np.linspace(psurf[nidt], ptop, nlevels) + else: + pb_ret = dat["pressure_levels"][nobs] + + if (np.diff(pb_ret) >= 0).any(): + msg = ("Retrieval pressure boundaries for " + \ + "observation %d are not monotonically " + \ + "decreasing! Investigate.") % nobs + print('pb_ret[:]: %s, np.diff(pb_ret): %s' %(pb_ret[:], np.diff(pb_ret))) + raise ValueError(msg) + + # Get vertical integration coefficients (i.e. to + # "interpolate" from model to retrieval grid) + coef_matrix = self.get_int_coefs(pb_ret, pb_mod, dat["level_def"][nobs]) + + # Model retrieval with averaging kernel and prior profile + if "pressure_weighting_function" in list(dat.keys()): + pwf = dat["pressure_weighting_function"][nobs] + if (not "pressure_weighting_function" in list(dat.keys())) or np.any(np.isnan(pwf)): + # Construct pressure weighting function from + # pressure boundaries + pwf = self.get_pressure_weighting_function(pb_ret, rule="simple") + + # Compute pressure-weighted averaging kernel + avpw = pwf*dat["averaging_kernel"][nobs] + + # Get prior + prior_col = dat["prior"][nobs] + prior_profile = dat["prior_profile"][nobs] + if np.isnan(prior_col): # compute prior + prior_col = np.dot(pwf, prior_profile) + + # Compute total columns + for nf in range(len(fields_list)): + # Integrate model profile + profile_intrp = np.matmul(coef_matrix, profiles[nf][nidt, :]) + + # Model retrieval + tc[nobs, nf] = prior_col + np.dot(avpw, profile_intrp - prior_profile) + + # Test phase: save pb_ret, pb_mod, coef_matrix, + # one profile for manual checking + + # dat_save = dict(pb_ret=pb_ret, + # pb_mod=pb_mod, + # coef_matrix=coef_matrix, + # ens_profile=ens_profiles[0], + # profile_intrp=profile_intrp, + # id=dat.id) + # + #out = open("model_profile_%d.pkl"%dat.id, "w") + #cPickle.dump(dat_save, out, 0) + # Average over footprint + if self.settings["footprint_samples_dim"] > 1: + indices = utilities.get_index_groups(dat["sounding_id"]) + + # Make sure that this is correct: i know the number of indices + lens = [len(group) for group in list(indices.values())] + correct_len = self.settings["footprint_samples_dim"]**2 + if np.any([len_ != correct_len for len_ in set(lens)]): + raise ValueError("Not all footprints have %d samples" %correct_len) + # Ok, paranoid mode, also confirm that the indices are what I + # think they are: consecutive numbers + ranges = [np.ptp(group) for group in list(indices.values())] + if np.any([ptp != correct_len for ptp in set(ranges)]): + raise ValueError("Not all footprints have consecutive samples") + + tc_original = copy.deepcopy(tc) + tc = utilities.apply_by_group(np.average, tc_original, indices) + + return tc + + ### David: Original function from ctdas-wrf ### + ### Keeping here as reference. ### + + @staticmethod + def _read_and_intrp_v(loc, fields_list, time_id, idp): + """ + Helper function for sample_total_columns. + read_and_intrp, but vectorized. + Reads in fields and interpolates + them linearly in time. + + Arguments + ---------- + loc (:class:`dict`) + Passed through from sample_total_columns, see there. + fields_list (:class:`list` of :class:`str`) + List of netcdf-variables to process. + time_id (:class:`int`) + Time index referring to all files in loc to read + idp (:class:`array` of :class:`int`) + Indices for id_xy, domain and frac_t in loc (i.e. + observations) to process. + + Output + ------ + List of temporally interpolated fields, one entry per member of + fields_list. + """ + + var_intrp_l = list() + + # Check we were really called with observations for just one domain + domains = set(loc["domain"][idp]) + if len(domains) > 1: + raise ValueError("I can only operate on idp with identical domains.") + dom = domains.pop() + + # Select input files + id_file0 = bisect.bisect_right(loc["file_start_time_indices"][dom], time_id) - 1 + id_file1 = bisect.bisect_right(loc["file_start_time_indices"][dom], time_id+1) - 1 + if id_file0 < 0 or id_file1 < 0: + raise ValueError("This shouldn't happen.") + + # Get time id in file + id_t_file0 = time_id - loc["file_start_time_indices"][dom][id_file0] + id_t_file1 = time_id+1 - loc["file_start_time_indices"][dom][id_file1] + + # Open files + nc0 = nc.Dataset(loc["files"][dom][id_file0], "r") + nc1 = nc.Dataset(loc["files"][dom][id_file1], "r") + # Per field to sample + for field in fields_list: + # Read input file + field0 = wrf.getvar(wrfin=nc0, + varname=field, + timeidx=id_t_file0, + squeeze=False, + meta=False) + + field1 = wrf.getvar(wrfin=nc1, + varname=field, + timeidx=id_t_file1, + squeeze=False, + meta=False) + + if len(field0.shape) == 4: + # Sample field at timesteps before and after observation + # They are ordered nt x nz x ny x nx + # var0 will have shape (len(idp),len(profile)) + var0 = field0[0, :, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] + var1 = field1[0, :, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] + # Repeat frac_t for profile size + frac_t_ = np.array(loc["frac_t"][idp]).reshape((len(idp), 1)).repeat(var0.shape[1], 1) + elif len(field0.shape) == 3: + # var0 will have shape (len(idp),) + var0 = field0[0, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] + var1 = field1[0, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] + frac_t_ = np.array(loc["frac_t"][idp]) + elif len(field0.shape) == 2: + # var0 will have shape (len(idp),len(profile)) + # This is for ZNW, which is saved as (time_coordinate, + # vertical_coordinate) + var0 = field0[[0]*len(idp), :] + var1 = field1[[0]*len(idp), :] + frac_t_ = np.array(loc["frac_t"][idp]).reshape((len(idp), 1)).repeat(var0.shape[1], 1) + else: + raise ValueError("Can't deal with field with %d dimensions." % len(field0.shape)) + + # Interpolate in time + var_intrp_l.append(var0*frac_t_ + var1*(1. - frac_t_)) + + nc0.close() + nc1.close() + + return var_intrp_l + + @staticmethod + def read_sampling_coords(sampling_coords_file, id0=None, id1=None): + """Read in samples""" + + ncf = nc.Dataset(sampling_coords_file, "r") + if id0 is None: + id0 = 0 + if id1 is None: + id1 = len(ncf.dimensions['soundings']) + + dat = dict( + sounding_id=np.array(ncf.variables["sounding_id"][id0:id1]), + date=ncf.variables["date"][id0:id1], + latitude=np.array(ncf.variables["latitude"][id0:id1]), + longitude=np.array(ncf.variables["longitude"][id0:id1]), + latc_0=np.array(ncf.variables["latc_0"][id0:id1]), + latc_1=np.array(ncf.variables["latc_1"][id0:id1]), + latc_2=np.array(ncf.variables["latc_2"][id0:id1]), + latc_3=np.array(ncf.variables["latc_3"][id0:id1]), + lonc_0=np.array(ncf.variables["lonc_0"][id0:id1]), + lonc_1=np.array(ncf.variables["lonc_1"][id0:id1]), + lonc_2=np.array(ncf.variables["lonc_2"][id0:id1]), + lonc_3=np.array(ncf.variables["lonc_3"][id0:id1]), + prior=np.array(ncf.variables["prior"][id0:id1]), + prior_profile=np.array(ncf.variables["prior_profile"][id0:id1,]), + averaging_kernel=np.array(ncf.variables["averaging_kernel"][id0:id1]), + pressure_levels=np.array(ncf.variables["pressure_levels"][id0:id1]), + pressure_weighting_function=np.array(ncf.variables["pressure_weighting_function"][id0:id1]), + level_def=ncf.variables["level_def"][id0:id1], + psurf=np.array(ncf.variables["psurf"][id0:id1]) + ) + + ncf.close() + + # Convert level_def from it's weird nc format to string + dat["level_def"] = nc.chartostring(dat["level_def"]) + + # Convert date to datetime object + dat["time"] = [dt.datetime(*x) for x in dat["date"]] + + return dat + + @staticmethod + def write_simulated_columns(obs_id, simulated, nmembers, outfile): + """Write simulated observations to file.""" + + # Output format: see obs_xco2_fr + + f = io.CT_CDF(outfile, method="create") + + dimid = f.createDimension("sounding_id", size=None) + dimid = ("sounding_id",) + savedict = io.std_savedict.copy() + savedict["name"] = "sounding_id" + savedict["dtype"] = "int64" + savedict["long_name"] = "Unique_Dataset_observation_index_number" + savedict["units"] = "" + savedict["dims"] = dimid + savedict["comment"] = "Format as in input" + savedict["values"] = obs_id.tolist() + f.add_data(savedict, nsets=0) + + dimmember = f.createDimension("nmembers", size=nmembers) + dimmember = ("nmembers",) + savedict = io.std_savedict.copy() + savedict["name"] = "column_modeled" + savedict["dtype"] = "float" + savedict["long_name"] = "Simulated total column" + savedict["units"] = "??" + savedict["dims"] = dimid + dimmember + savedict["comment"] = "Simulated model value created by ICON_sampler" + savedict["values"] = simulated.tolist() + f.add_data(savedict, nsets=0) + + f.close() + + @staticmethod + def save_file_with_timestamp(file_path, out_dir, suffix=""): + """ Saves a file to with a timestamp""" + nowstamp = dt.datetime.now().strftime("_%Y-%m-%d_%H:%M:%S") + new_name = os.path.basename(file_path) + suffix + nowstamp + new_path = os.path.join(out_dir, new_name) + shutil.copy2(file_path, new_path) + + +################################################### +# Here are some adaptations written by David Ho + + def get_icon_filenames(self, glob_pattern): + """ + Gets the filenames in self.settings["dir.icon_sim"] that follow + glob_pattern + """ + path = self.settings["run_dir"] + #path = '/work/mj0143/b301043/Project/Ensemble_sim/ICON/ICON-ART/icon-kit/ERA5_EMPA/CTDAS_test/bckup' + # All files... + wfiles = glob.glob(os.path.join(path, glob_pattern)) + files = [x for x in wfiles] + + # I need this sorted too often to not do it here. + files = np.sort(files).tolist() + return files + + + @staticmethod + def times_in_icon_file(ds_icon): + """ + Returns the times in netCDF4.Dataset ncf as datetime object + """ + times_nc = pd.to_datetime(ds_icon["time"].values, format='date_format') + #times_dtm = pd.to_datetime(ds_icon["time"].values, format='date_format') + times_str = str(times_nc.strftime('%Y-%m-%d_%H:%M:%S')[0]) + times_dtm = dt.datetime.strptime(times_str, "%Y-%m-%d_%H:%M:%S") + + return times_dtm + + + def icon_times(self, file_list): + """Read all times in a list of icon files + + Output + ------ + - 1D-array containing all times + - 1D-array containing start indices of each file + """ + + #times = [] + times = list() + start_indices = np.ndarray( (len(file_list), ), int ) + for file in range( len(file_list) ): + ds = xr.open_dataset( file_list[file] ) + times_this = self.times_in_icon_file(ds) + start_indices[file] = len(times) + #times += times_this + times.append(times_this) + #ncf.close() + + return times, start_indices + + ### David: Too slow, no longer needed ### + ### To be deleted ### + @staticmethod + def fetch_weight_and_neighbor_cells_Serial(gridinfo, latitudes_array, longitudes_array, z_info=None): + """ + Provide Grid info of your ICON grid, see icon_sampler. + Given lat/lon, calculates the distances then: + return the indexes of the neighboring N cells from unstructured ICON grid, + and the weights, for horizontal interpolation. + Vertical interpolation is skipped, since it will calculates the column average later. + ----- + Code originally inherited from Michael Steier. + Future developments: + Include vertical interpolation from 'z_info' argument, for geting the model levels. + + Output + ----- + - 1D-array containing the nearest neighbor indexes + - 1D-array containing the weights for the indexes + """ + # Libraries for this function: + from math import sin, cos, sqrt, atan2, radians + + # Initialize + nn_sel_list = np.zeros( (len(latitudes_array), gridinfo.nn) ).astype(int) # indexes must be integers + u_list = np.zeros( (len(latitudes_array), gridinfo.nn) ) + + + # Loop over lat/lon array to collect. #### This loop takes too long, needs to parallelize!!! + for index in np.arange( len(latitudes_array) ): + + # For debugging... + #print('Calculating index: %s' %index) + + latitudes = latitudes_array[index] + longitudes = longitudes_array[index] + + # For debugging... + #print('Lat: %s, Lon: %s' %(latitudes, longitudes)) + + # Initialize: + nn_sel = np.zeros(gridinfo.nn) # Index of neighbor cells + u = np.zeros(gridinfo.nn) # Weights for neighbor cells + + R = 6373.0 # approximate radius of earth in km + + # This step is used for filtering obs outside of domain. + # However, in the satellite pre-processing step, we will make sure all obs are in the domain! + # vvv Therefore, skipped... vvv + + #if (radians(longitudes)np.nanmax(gridinfo.clon)): + # u[:] = np.nan + # return np.zeros((gridinfo.nn)), np.zeros((gridinfo.nn)).astype(int), np.zeros((gridinfo.nn)).astype(int), nn_sel[:], u[:] + + #if (radians(latitudes)np.nanmax(gridinfo.clat)): + # u[:] = np.nan + # return np.zeros((gridinfo.nn)), np.zeros((gridinfo.nn)).astype(int), np.zeros((gridinfo.nn)).astype(int), nn_sel[:], u[:] + + #% + lat1 = radians(latitudes) + lon1 = radians(longitudes) + + #% + """FIND "N" CLOSEST CENTERS""" + distances = np.zeros( (len(gridinfo.clon))) + for icell in np.arange(len(gridinfo.clon)): + lat2 = gridinfo.clat[icell] + lon2 = gridinfo.clon[icell] + dlon = lon2 - lon1 + dlat = lat2 - lat1 + a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2 + c = 2 * atan2(sqrt(a), sqrt(1 - a)) + distances[icell] = R * c + nn_sel[:] = [x for _, x in sorted(zip(distances,np.arange(len(gridinfo.clon))))][0:gridinfo.nn] + nn_sel = nn_sel.astype(int) + + u[:] = [1./distances[y] for y in nn_sel] + + nn_sel_list[index] = nn_sel[:] + u_list[index] = u + + # For debugging... + #print('Done, added NS:%s and U:%s' %(nn_sel, u[:]) ) + + # End of loop + + return nn_sel_list, u_list + + + ### David: Too slow, no longer needed ### + ### To be deleted ### + @staticmethod + def fetch_weight_and_neighbor_cells_Parallel(args): + #def fetch_weight_and_neighbor_cells_Parallel(idx, gridinfo, latitudes, longitudes): + """ + Provide Grid info of your ICON grid, see icon_sampler. + Given lat/lon, calculates the distances then: + return the indexes of the neighboring N cells from unstructured ICON grid, + and the weights, for horizontal interpolation. + Vertical interpolation is skipped, since it will calculates the column average later. + ----- + Code originally inherited from Michael Steier. + Future developments: + Include vertical interpolation from 'z_info' argument, for geting the model levels. + + Output + ----- + - 1D-array containing the nearest neighbor indexes + - 1D-array containing the weights for the indexes + """ + + idx = args[0] + gridinfo = args[1] + latitudes = args[2] + longitudes = args[3] + + # Libraries for this function: + from math import sin, cos, sqrt, atan2, radians + + # Initialize: + nn_sel = np.zeros(gridinfo.nn).astype(int) # Index of neighbor cells, # indexes must be integers + u = np.zeros(gridinfo.nn) # Weights for neighbor cells + + R = 6373.0 # approximate radius of earth in km + + #% + lat1 = radians(latitudes[idx]) + lon1 = radians(longitudes[idx]) + + #% + """FIND "N" CLOSEST CENTERS""" + distances = np.zeros( (len(gridinfo.clon))) + for icell in np.arange(len(gridinfo.clon)): + lat2 = gridinfo.clat[icell] + lon2 = gridinfo.clon[icell] + dlon = lon2 - lon1 + dlat = lat2 - lat1 + a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2 + c = 2 * atan2(sqrt(a), sqrt(1 - a)) + distances[icell] = R * c + nn_sel[:] = [x for _, x in sorted(zip(distances,np.arange(len(gridinfo.clon))))][0:gridinfo.nn] + nn_sel = nn_sel.astype(int) + + u[:] = [1./distances[y] for y in nn_sel] + + #return nn_sel[:], u + return np.array(nn_sel[:], dtype=int), np.array(u) + + @staticmethod + def get_divisible_hours_string(datetime_obj, hours=3): + """ + Added by Erik; extracts a string for the previous and next datetimes + that are divisible by three + """ + # Get the hour from the datetime object + hour = datetime_obj.hour + + # Check if the hour is divisible by N hours + if hour % hours == 0: + # If divisible, get the current hour and the next hour + current_hour = datetime_obj.replace(minute=0, second=0, microsecond=0) + hour_above = current_hour + timedelta(hours=hours) + return [current_hour.strftime('%Y%m%dT%H'), hour_above.strftime('%Y%m%dT%H')] + else: + # If not divisible, get the hour below and above + hour_below = datetime_obj.replace(hour=hour - (hour % hours), minute=0, second=0, microsecond=0) + hour_above = hour_below + timedelta(hours=hours) + return [hour_below.strftime('%Y%m%dT%H'), hour_above.strftime('%Y%m%dT%H')] + + + @staticmethod + def _read_and_intrp_v_ICON(loc, fields_list, time_id, idp): + """ + David: + Slight modification from "self.sample_total_columns" for WRF. + + Helper function for sample_total_columns. + read_and_intrp, but vectorized. + Reads in fields and interpolates + them linearly in time. + + Arguments + ---------- + loc (:class:`dict`) + Passed through from sample_total_columns, see there. + fields_list (:class:`list` of :class:`str`) + List of netcdf-variables to process. + time_id (:class:`int`) + Time index referring to all files in loc to read + idp (:class:`array` of :class:`int`) + Indices for id_xy, domain and frac_t in loc (i.e. + observations) to process. + + Output + ------ + List of temporally interpolated fields, one entry per member of + fields_list. + """ + + var_intrp_l = list() + + # Select input files + id_file0 = bisect.bisect_right(loc["file_start_time_indices"], time_id) - 1 + id_file1 = bisect.bisect_right(loc["file_start_time_indices"], time_id+1) - 1 + if id_file0 < 0 or id_file1 < 0: + raise ValueError("This shouldn't happen.") + + # Get time id in file + id_t_file0 = time_id - loc["file_start_time_indices"][id_file0] + id_t_file1 = time_id+1 - loc["file_start_time_indices"][id_file1] + + # Open files + ### NetCDF approach: + nc0 = nc.Dataset(loc["files"][id_file0], "r") + nc1 = nc.Dataset(loc["files"][id_file1], "r") + + ### Xarray approach: + #nc0 = xr.open_dataset(loc["files"][id_file0]) + #nc1 = xr.open_dataset(loc["files"][id_file1]) + + # Per field to sample + for field in fields_list: + # Read input file + ### NetCDF approach: + field0 = nc0[ field ][:] + field1 = nc1[ field ][:] + + ### Xarray approach: + #field0 = nc0[ field ].values + #field1 = nc1[ field ].values + + if len(field0.shape) == 3: + ### For ICON fields that has shape (time, z, cells) + # -- First select the nearest neighbours of the fields + + var00 = field0[ 0, :, loc["nn_sel_list"][idp] ] + var01 = field1[ 0, :, loc["nn_sel_list"][idp] ] + + # -- Then interpolate spatially with weights + # The sum of the weights per obs location + u_sums = np.nansum(loc["weight_list"][idp], axis=1) + + # Fancy way of mulitply the weights onto 4 nearest neighbors per obs location. (to be varified) + # see: https://numpy.org/doc/stable/reference/generated/numpy.einsum.html + # Since the dimension does not match, so here are the tricks to do so... + var0 = ( np.einsum( "ij,ijk->ik", loc["weight_list"][idp], var00 ) / u_sums[:, np.newaxis] ) + var1 = ( np.einsum( "ij,ijk->ik", loc["weight_list"][idp], var01 ) / u_sums[:, np.newaxis] ) + + # -- Get the time fractions per obs location + frac_t_ = np.array(loc["frac_t"][idp]).reshape((len(idp), 1)) + + elif len(field0.shape) == 2: + ### For ICON fields that has shape (time, cells), e.g. "pres_sfc" + # var0 will have shape (len(idp),len(profile)) + + # -- First select the fields: + var00 = field0[ 0, loc["nn_sel_list"][idp] ] + var01 = field1[ 0, loc["nn_sel_list"][idp] ] + + # -- Then interpolate in space with weights: + # The sum of the weights per obs location + u_sums = np.nansum(loc["weight_list"][idp], axis=1) + + var0 = np.nansum( loc["weight_list"][idp] * var00, axis=1 ) / u_sums + var1 = np.nansum( loc["weight_list"][idp] * var01, axis=1 ) / u_sums + + # -- Get the time fractions per obs location + frac_t_ = np.array(loc["frac_t"][idp]) + + else: + raise ValueError("Can't deal with field with %d dimensions." % len(field0.shape)) + + # Interpolate in time + var_intrp_l.append(var0*frac_t_ + var1*(1. - frac_t_)) + + nc0.close() + nc1.close() + + return var_intrp_l + + + + #### David: A variation for sampling ICON ### + def sample_total_columns_ICON(self, dat, loc, fields_list): + """ + David: + Slight modification from "self.sample_total_columns" for WRF. + + Sample total_columns of fields_list in ICON output in + self.settings["dir.icon_sim"] at the location id_xy in domain, id_t + in all wrfout-times. Files and indices therein are recognized + by id_t and file_time_start_indices. + All quantities needed for computing total columns from profiles + are in dat (kernel, prior, ...). + + Arguments + --------- + dat (:class:`list`) + Result of wrfhelper.read_sampling_coords. Used here: prior, + prior_profile, kernel, psurf, pressure_axis, [, pwf] + If psurf or any of pressure_axis are nan, wrf's own + surface pressure is used and pressure_axis constructed + from this and the number of levels in the averaging kernel. + This allows sampling with synthetic data that don't have + pressure information. This only works with level_def + "layer_average". + If pwf is not present or nan, a simple one is created, for + level_def "layer_average". + loc (:class:`dict`) + A dictionary with all location-related input for sampling, + computed in wrfout_sampler. Keys: + id_xy, domain: Domain coordinates + id_t: Timestep (continous throughout all files) + frac_t: Interpolation coeficient between id_t and id_t+1: + t_obs = frac_t*t[id_t] + (1-frac_t)*t[id_t+1]) + file_start_time_indices: Time index at which a new wrfout + file starts + files: names of wrfout files. + fields_list (:class:`list`) + The fields to sample total columns from. + + Output + ------ + sampled_columns (:class:`array`) + A 2D-array of sampled columns. + Shape: (len(dat["prior"]), len(fields_list)) + """ + + # Initialize output of all tracers + tc = np.ndarray(shape=(len(dat["prior"]), len(fields_list)), dtype=float) + tc[:] = float("nan") + + tc_unperturbed = np.ndarray(shape=(len(dat["prior"]), 1), dtype=float) + tc_unperturbed[:] = float("nan") + + do_CAMS = True + + # Process by id_t + UT = list(set(loc["id_t"][:])) + + #print('Tests, UT: %s' %UT) + + # print(loc['times']) + + for time_id in UT: + # Coordinates to process + idt = np.nonzero(loc["id_t"] == time_id)[0] + # David: idt seems to be a list + # print('Tests, idt: %s' %idt) + + din = loc['times'][idt[0]] + # print(din) + [hour_below, hour_above ] = self.get_divisible_hours_string(datetime_obj=din) + print("oi oi", hour_below, hour_above) + if do_CAMS: + CAMS1 = xr.open_dataset(f'{cfg.case_root / "global_inputs" / "CAMS"}/cams_egg4_{{hour_below}}.nc') + CAMS2 = xr.open_dataset(f'{cfg.case_root / "global_inputs" / "CAMS"}/cams_egg4_{{hour_above}}.nc') + CAMS1["time"] = datetime.strptime(hour_below, "%Y%m%dT%H") + CAMS2["time"] = datetime.strptime(hour_above, "%Y%m%dT%H") + CAMS = xr.concat([CAMS1, CAMS2], dim="time") + pressure = CAMS.ap.values[:,:,np.newaxis,np.newaxis] + np.einsum('pi,pjk->pijk',CAMS.bp.values, CAMS.Psurf.values) + # The following is applicable if we only use joint (CO2,Pres) levels [as needed by, e.g., OCO2] + CAMS["pressure"] = (("time", "level", "latitude", "longitude"), (pressure[:,1:,:,:] + pressure[:,:-1,:,:])*0.5) + # The following is applicable if we want to use (CO2,Pres_ifc) combinations [note the 'hlevel' dimension] + # CAMS["pressure"] = (("time", "hlevel", "latitude", "longitude"), pressure) + + # Read and get tracer ensemble profiles, and flip them, since ICON start from the model top + m_dry = 28.97 # g/mol for dry air + m_gas = 44.01 # g/mol for CO2 + to_ppm = 1e6 + qv = self._read_and_intrp_v_ICON(loc, ['qv'], time_id, idt)[0] + + # The unperturbed tracer + BG = np.asarray(self._read_and_intrp_v_ICON(loc, ['TRCO2_BG'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + # TRCO2_A = np.asarray(self._read_and_intrp_v_ICON(loc, ['TRCO2_A'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + try: # In the "PRIOR" simulations I made, the following tracer contains the anthropogenic portion; it doesn't exist otherwise. + TRCO2_A = np.asarray(self._read_and_intrp_v_ICON(loc, ['ANTH'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + except: + TRCO2_A = np.asarray(self._read_and_intrp_v_ICON(loc, ['TRCO2_A'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + CO2_RA = np.asarray(self._read_and_intrp_v_ICON(loc, ['CO2_RA'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + CO2_GPP = np.asarray(self._read_and_intrp_v_ICON(loc, ['CO2_GPP'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + biosource = np.asarray(self._read_and_intrp_v_ICON(loc, ['biosource'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + biosink = np.asarray(self._read_and_intrp_v_ICON(loc, ['biosink'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + # The ensemble tracers + tracers = np.asarray(self._read_and_intrp_v_ICON(loc, fields_list, time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + + # Correct for the missing biospheric components! + tracers = tracers + biosource - biosink + prior_tracers = BG + TRCO2_A + CO2_RA - CO2_GPP + biosource - biosink + + #profiles = np.fliplr( self._read_and_intrp_v_ICON(loc, fields_list, time_id, idt) ) * (28.97/16.01)*1e6 # mol/kg -> ppm + # List, len=len(fields_list), shape of each: (len(idt),nz) + + # Read and get water vapor for wet/dry correction + # print(np.asarray(qv).shape, np.asarray(tracers).shape, type(qv), type(tracers)) + + # Read and get pressure axis: + psurf = self._read_and_intrp_v_ICON(loc, ["pres"], time_id, idt)[0]/1.e2 # Pa -> hPa + # Shape: (len(idt),) + + ptop = 50 # David: Since ICON does not have hard coded ptop, assume it is 50 hPa... + # Shape: (len(idt),) + if not do_CAMS: + ptop = 50 + + if do_CAMS: + ptop = 0.01 + + ### David: ZNW was for WRF, for ICON first try getting "pres" or "pres_ifc" + pres = np.fliplr( self._read_and_intrp_v_ICON(loc, ["pres"], time_id, idt)[0] )/1.e2 # Pa -> hPa + # pres = np.fliplr( self._read_and_intrp_v_ICON(loc, ["pres_ifc"], time_id, idt)[0] )/1.e2 # Pa -> hPa + #znw = self._read_and_intrp_v_ICON(loc, ["ZNW"], time_id, idt)[0] + #Shape:(len(idt),nz) + + # DONE reading from file. + # Here it starts to make sense to loop over individual observations + for nidt in range(len(idt)): + + nobs = idt[nidt] + + # Construct model pressure layer boundaries + #pb_mod = self.get_pressure_boundaries_znw(znw[nidt, :], psurf[nidt], ptop) + + # numpy.fliplr reverses the order of elements along axis 1 (left/right). + # For a 2-D array, this flips the entries in each row in the left/right direction. + # Columns are preserved, but appear in a different order than before. + pb_mod = pres[nidt] + + # Do the CAMS extension + if do_CAMS: + CAMS_obs = CAMS.interp(time=loc['times'][nobs], latitude=loc['latitude'][nobs], longitude=loc['longitude'][nobs]) + CAMS_pressures = CAMS_obs.pressure.values + CAMS_idx = CAMS_pressures < np.min(pb_mod) + pb_mod = np.concatenate((pb_mod, CAMS_pressures[CAMS_idx])) + CAMS_gas = CAMS_obs.CO2.values[CAMS_idx] * 1e6 + + # Add a final value onto the column... + pb_mod = np.append(pb_mod,np.min(pb_mod)-1) + + + if (np.diff(pb_mod) >= 0).any(): + msg = ("Model pressure boundaries for observation %d " + \ + "are not monotonically decreasing! Investigate.") % nobs + # --> Erik: I have removed this, because I don't quite know how to investigate this easily. Was triggered though! + # raise ValueError(msg) + + # Construct retrieval pressure layer boundaries + # print(dat["level_def"][nobs]) + if dat["level_def"][nobs] == "layer_average": + if np.any(np.isnan(dat["pressure_levels"][nobs])) \ + or np.isnan(dat["psurf"][nobs]): + # Code for synthetic data without a pressure axis, + # but with an averaging kernel: + # Use wrf's surface and top pressure + nlayers = len(dat["averaging_kernel"][nobs]) + pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) + else: + nlayers = len(dat["averaging_kernel"][nobs]) + pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) + # Below commented out by David + # Because somehow doesn't work + #pb_ret = self.get_pressure_boundaries_paxis( + # dat["pressure_levels"][nobs], + # dat["psurf"][nobs]) + elif dat["level_def"][nobs] == "pressure_boundary": + if np.any(np.isnan(dat["pressure_levels"][nobs])): + # Code for synthetic data without a pressure axis, + # but with an averaging kernel: + # Use wrf's surface and top pressure + nlevels = len(dat["averaging_kernel"][nobs]) + pb_ret = np.linspace(psurf[nidt], ptop, nlevels) + else: + pb_ret = dat["pressure_levels"][nobs] + else: + # print('No appropriate level chosen...') + dat["level_def"][nobs] = "pressure_boundary" + # print("changed definition to pressure_boundary") + if np.any(np.isnan(dat["pressure_levels"][nobs])): + # Code for synthetic data without a pressure axis, + # but with an averaging kernel: + # Use wrf's surface and top pressure + nlevels = len(dat["averaging_kernel"][nobs]) + pb_ret = np.linspace(psurf[nidt], ptop, nlevels) + else: + pb_ret = dat["pressure_levels"][nobs] + + if (np.diff(pb_ret) >= 0).any(): + msg = ("Retrieval pressure boundaries for " + \ + "observation %d are not monotonically " + \ + "decreasing! Investigate.") % nobs + print('pb_ret[:]: %s, np.diff(pb_ret): %s' %(pb_ret[:], np.diff(pb_ret))) + raise ValueError(msg) + + # Get vertical integration coefficients (i.e. to + # "interpolate" from model to retrieval grid) + coef_matrix = self.get_int_coefs(pb_ret, pb_mod, dat["level_def"][nobs]) ### To be verified !! + + # Model retrieval with averaging kernel and prior profile + if "pressure_weighting_function" in list(dat.keys()): + pwf = dat["pressure_weighting_function"][nobs] + if (not "pressure_weighting_function" in list(dat.keys())) or np.any(np.isnan(pwf)): + # Construct pressure weighting function from + # pressure boundaries + pwf = self.get_pressure_weighting_function(pb_ret, rule="simple") + + # Compute pressure-weighted averaging kernel + avpw = pwf*dat["averaging_kernel"][nobs] + + # Get prior + prior_col = dat["prior"][nobs] + prior_profile = dat["prior_profile"][nobs] + if np.isnan(prior_col): # compute prior + prior_col = np.dot(pwf, prior_profile) + + # Compute total columns + offset = 0 + for nf in range(len(fields_list)): + # Integrate model profile + tr_here = np.flip(tracers[nf][nidt, :]) + if do_CAMS: + tr_here = np.concatenate((tr_here, CAMS_gas)) + profile = ( (tr_here - offset ) ) + profile_intrp = np.matmul( coef_matrix, profile ) ### To be verified !! + + # Model retrieval + # print(prior_profile) + # print(profile_intrp) + # print(prior_col) + tc[nobs, nf] = prior_col + np.dot(avpw, profile_intrp - prior_profile) + # print(tc[nobs,nf]) + + tr_here = np.flip(prior_tracers[0][nidt, :]) + if do_CAMS: + tr_here = np.concatenate((tr_here, CAMS_gas)) + profile = ( (tr_here - offset ) ) + profile_intrp = np.matmul( coef_matrix, profile ) ### To be verified !! + tc_unperturbed[nobs,0] = prior_col + np.dot(avpw, profile_intrp - prior_profile) + + return tc, tc_unperturbed + +if __name__ == "__main__": + pass diff --git a/cases/icon-art-CTDAS/ctdas_patch/icon_sampler.py b/cases/icon-art-CTDAS/ctdas_patch/icon_sampler.py new file mode 100755 index 00000000..a5c4b1b6 --- /dev/null +++ b/cases/icon-art-CTDAS/ctdas_patch/icon_sampler.py @@ -0,0 +1,269 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Created on Mon Jul 22 15:07:13 2019 + +@author: friedemann + +Modified on June 26, 10:40:12, 2023 +Adaptation for sampling ICON instead of WRF. +@author: David Ho + +""" + +# Samples ICON-ART history files for CTDAS + +# This is called as external executable from CTDAS +# to allow simple parallelization +# +# Usage: + +# icon_sampler.py --arg1 val1 --arg2 val2 ... +# Arguments: See parser in code below + +import os +import sys +#import itertools +#import bisect +import copy +import numpy as np +import xarray as xr +import netCDF4 as nc + +# Import some CTDAS tools +pd = os.path.pardir +inc_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), + pd, pd, pd) +inc_path = os.path.abspath(inc_path) +sys.path.append(inc_path) +from da.tools.icon.icon_helper import ICON_Helper +from da.tools.icon.utilities import utilities +import argparse + + +########## Parse options +parser = argparse.ArgumentParser() +parser.add_argument("--nproc", type=int, + help="ID of this sampling process (0 ... nprocs-1)") +parser.add_argument("--nprocs", type=int, + help="Number of sampling processes") +parser.add_argument("--sampling_coords_file", type=str, + help="File with sampling coordinates as created " + \ + "by CTDAS column samples object") +parser.add_argument("--run_dir", type=str, + help="Directory with icon output files") +parser.add_argument("--iconout_prefix", type=str, + help="Headings of the ICON output files") +parser.add_argument("--icon_grid", type=str, + help="Absolute path points to the ICON grid file") +parser.add_argument("--nmembers", type=int, + help="Number of tracer ensemble members") +parser.add_argument("--tracer_optim", type=str, + help="Tracer that was optimized (e.g. CO2 for " + \ + "ensemble members CO2_000 etc.)") +parser.add_argument("--outfile_prefix", type=str, + help="One process: output file. More processes: " + \ + "output file is ..slice") +parser.add_argument("--footprint_samples_dim", type=int, + help="Sample column footprint at n x n points") + +args = parser.parse_args() +settings = copy.deepcopy(vars(args)) + +# Start (stupid) logging - should be updated +wd = os.getcwd() +try: + os.makedirs("log") +except OSError: # Case when directory already exists. Will look nicer in python 3... + pass + +logfile = os.path.join(wd, "log/iconout_sampler." + str(settings['nproc']) + ".log") + +os.system("touch " + logfile) +os.system("rm " + logfile) +os.system("echo 'Process " + str(settings['nproc']) + " of " + str(settings['nprocs']) + ": start' >> " + logfile) +os.system("date >> " + logfile) + + +# David: could be helpful for validate arguments for icon sampling +########## Initialize iconhelper +iconhelper = ICON_Helper(settings) +iconhelper.validate_settings(['sampling_coords_file', + 'run_dir', + 'iconout_prefix', + 'icon_grid', + 'nproc', + 'nprocs', + 'nmembers', # special case 0: sample 'tracer_optim' + 'tracer_optim', + 'outfile_prefix', + 'footprint_samples_dim']) + +cwd = os.getcwd() +os.chdir(iconhelper.settings['run_dir']) + + +# ########## Figure out which samples to process +# # Get number of samples +ncf = nc.Dataset(settings['sampling_coords_file'], "r") +nsamples = len(ncf.dimensions['soundings']) +ncf.close() + +id0, id1 = utilities.get_slicing_ids(nsamples, settings['nproc'], settings['nprocs']) + +os.system("echo 'id0=" + str(id0) + "' >> " + logfile) +os.system("echo 'id1=" + str(id1) + "' >> " + logfile) + +# ########## Read samples from coord file +dat = iconhelper.read_sampling_coords(settings['sampling_coords_file'], id0, id1) + +os.system("echo 'Data read, len=" + str(len(dat['sounding_id'])) + "' >> " + logfile) + + +########## Locate samples in ICON domains + +# Take care of special case without ensemble +nmembers = settings['nmembers'] + +if nmembers == 0: + # Special case: sample 'tracer_optim', don't add member suffix + member_names = [settings['tracer_optim']] + nmembers = 1 +else: + member_names = [settings['tracer_optim'] + "-%03d" % nm for nm in range(1, nmembers+1)] # In ICON, ensemble member starts with XXX-001 + + +#### Here gets the indexes of neighboring cells and the weights +#### Choose number of neighbours, recommend 4 as done in "cdo remapdis" + +nneighb = 4 + +# Read grid file, and store the grid info. Only needs to do it once. +grid_file = settings['icon_grid'] + +# Import modules (takes 8 seconds) +from sklearn.neighbors import BallTree + +# Get ICON grid specifics +ICON_GRID = xr.open_dataset(grid_file) +clon = ICON_GRID.clon.values +clat = ICON_GRID.clat.values + +# Generate BallTree +test_points = np.column_stack([clat, clon]) +tree = BallTree(test_points, metric = 'haversine') + +lat_q = dat['latitude'] +lon_q = dat['longitude'] + +# Query BallTree +(d,i) = tree.query(np.column_stack([np.deg2rad(lat_q), np.deg2rad(lon_q)]), k=nneighb, return_distance=True) + +R = 6373.0 # approximate radius of earth in km + +weight_list = 1./(d*R) +nn_sel_list = i + + +######### Locate in time: Which file, time index, and temporal interpolation +# factor. +# MAYBE make this a function. See which quantities I need later. +# -- Initialize +id_t = np.zeros_like(dat['latitude'], int) +frac_t = np.ndarray(id_t.shape, float) +frac_t[:] = float("nan") + +# Add a little flexibility by doing this per domain - namelists allow +# different output frequencies per domain. +iconout_files = dict() +iconout_times = dict() +iconout_start_time_ids = dict() + + +# -- Get full time vector +iconout_prefix = settings['iconout_prefix'] +iconout_files = iconhelper.get_icon_filenames(iconout_prefix + "*") +iconout_times, iconout_start_time_ids = iconhelper.icon_times(iconout_files) + +# time id +for idx in range( len(dat['latitude']) ): + # Look where it sorts in + tmp = [i + for i in range( len(iconout_times) -1 ) + if iconout_times[i] <= dat['time'][idx] \ + and dat['time'][idx] < iconout_times[i+1]] + + # Catch the case that the observation took place exactly at the last time step + if len(tmp) == 1: + id_t[idx] = tmp[0] + time0 = iconout_times[id_t[idx]] + time1 = iconout_times[id_t[idx]+1] + frac_t[idx] = (time1 - dat['time'][idx]).total_seconds() / (time1 - time0).total_seconds() + + else: # len must be 0 in this case + if len(tmp) > 1:\ + raise ValueError("wat") + + if dat['time'][idx] == iconout_times[-1]: + # For debugging + print('check dat[time]: %s' %(dat['time'][idx])) + id_t[idx] = len(iconout_times)-1 + frac_t[idx] = 1 + + else: + msg = "Sample %d, sounding_id %s: outside of simulated time."%(idx, dat['sounding_id'][idx]) + raise ValueError(msg) + + +# -- Create dictionary for column sampling: +loc_input = dict(nn_sel_list = nn_sel_list, + weight_list = weight_list, + id_t = id_t, + frac_t = frac_t, + files = iconout_files, + file_start_time_indices = iconout_start_time_ids, + times = dat['time'][:], + latitude=lat_q, + longitude=lon_q) + + +# -- Begin Sampling +ens_sim, prior = iconhelper.sample_total_columns_ICON(dat, loc_input, member_names) + +# -- Write results to file +obs_ids = dat['sounding_id'] +# Remove simulations that are nan (=not in domain) +if ens_sim.shape[0] > 0: + valid = np.apply_along_axis(lambda arr: not np.any(np.isnan(arr)), 1, ens_sim) + obs_ids_write = obs_ids[valid] + ens_sim_write = ens_sim[valid, :] + prior_sim_write = prior[valid, :] +else: + obs_ids_write = obs_ids + ens_sim_write = ens_sim + prior_sim_write = prior +### +if settings['nprocs'] == 1: + outfile = settings['outfile_prefix'] +else: + # Create output files with the appendix "..slice" + # Format so that they can later be easily sorted. + len_nproc = int(np.floor(np.log10(settings['nprocs']))) + 1 + outfile = settings['outfile_prefix'] + (".%0" + str(len_nproc) + "d.slice") % settings['nproc'] + +os.system("echo 'Writing output file '" + os.path.join(iconhelper.settings['run_dir'], outfile) + " >> " + logfile) + +### Write +iconhelper.write_simulated_columns( obs_id=obs_ids_write, + simulated=ens_sim_write, + nmembers=nmembers, + outfile=outfile ) + +iconhelper.write_simulated_columns( obs_id=obs_ids_write, + simulated=prior_sim_write, + nmembers=1, + outfile=outfile+'_prior.nc' ) + +os.chdir(cwd) + +os.system("echo 'Done' >> " + logfile) diff --git a/cases/icon-art-CTDAS/ctdas_patch/initexit_cteco2.py b/cases/icon-art-CTDAS/ctdas_patch/initexit_cteco2.py new file mode 100755 index 00000000..f677b091 --- /dev/null +++ b/cases/icon-art-CTDAS/ctdas_patch/initexit_cteco2.py @@ -0,0 +1,681 @@ +"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +updates of the code. See also: http://www.carbontracker.eu. + +This program is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free Software Foundation, +version 3. This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this +program. If not, see .""" +#!/usr/bin/env python +# da_initexit.py + +""" +.. module:: initexit +.. moduleauthor:: Wouter Peters + +Revision History: +File created on 13 May 2009. + +The CycleControl class is found in the module :mod:`initexit`. It is derived from the standard python :class:`dictionary` object. It is the only core object of CTDAS that is automatically created in the pipeline, the user (normally) does not need to modify or extend it. The class is created based on options and arguments passes on the command line when submitting your main CTDAS job. + +Valid options are defined in + +.. autofunction:: da.tools.initexit.parse_options + +With the name of a valid ``rc-file``, the CycleControl object is instantiated and validated. An example rc-file looks +like this::: + + ! Info on the data assimilation cycle + + time.restart : False ! Restart from an existing run T/F + time.start : 2000-01-01 00:00:00 ! Start time of first cycle + time.finish : 2000-01-08 00:00:00 ! End time of last cycle + time.cycle : 7 ! length of each cycle, 7 means one week + time.nlag : 5 ! number of cycles in one smoother window + dir.da_run : ${{HOME}}/tmp/test_da ! the run directory for you project + + ! Info on the DA system used + + da.system : CarbonTracker ! an identifier for your inversion system + da.system.rc : da/rc/carbontracker.rc ! the settings needed in your inversion system + + ! Info on the forward model to be used + + da.obsoperator : TM5 ! an identifier for your observation operator + da.obsoperator.rc : ${{HOME}}/Modeling/TM5/tm5-ctdas.rc ! the rc-file needed to run youobservation operator + da.optimizer.nmembers : 30 ! the number of ensemble members desired in the optimization + +The most important method of the CycleControl object are listed below: + +.. autoclass:: da.tools.initexit.CycleControl + :members: setup, finalize, collect_restart_data, move_restart_data, + submit_next_cycle, setup_file_structure, recover_run, random_seed + +Two important attributes of the CycleControl object are: + (1) DaSystem, an instance of a :ref:`dasystem` + (2) DaPlatForm, an instance of a :ref:`platform` + +Other functions in the module initexit that are related to the control of a DA cycle are: + +.. autofunction:: da.tools.initexit.start_logger +.. autofunction:: da.tools.initexit.validate_opts_args + + +""" +import logging +import os +import sys +import glob +import shutil +import copy +import getopt +import pickle +import numpy as np +#from string import join + +import da.tools.rc as rc +from da.tools.general import create_dirs, to_datetime, advance_time + +needed_da_items = [ + 'time.start', + 'time.finish', + 'time.nlag', + 'time.cycle', + 'dir.da_run', + 'da.resources.ncycles_per_job', + 'da.resources.ntasks', + 'da.resources.ntime', + 'da.system', + 'da.system.rc', + 'da.obsoperator', + 'da.optimizer.nmembers'] + +# only needed in an earlier implemented where each substep was a separate job +# validprocesses = ['start','done','samplestate','advance','invert'] + + +class CycleControl(dict): + """ + This object controls the CTDAS system flow and functionality. + """ + + def __init__(self, opts=[], args={{}}): + """ + The CycleControl object is instantiated with a set of options and arguments. + The list of arguments must contain the name of an existing ``rc-file``. + This rc-file is loaded by method :meth:`~da.tools.initexit.CycleControl.load_rc` and validated + by :meth:`~da.tools.initexit.CycleControl.validate_rc` + + Options for the CycleControl consist of accepted command line flags or arguments + in :func:`~da.tools.initexit.CycleControl.parse_options` + + """ + rcfile = args['rc'] + self.load_rc(rcfile) + self.validate_rc() + self.opts = opts + + # Add some useful variables to the rc-file dictionary + + self['jobrcfilename'] = rcfile + self['dir.da_submit'] = os.getcwd() + self['da.crash.recover'] = '-r' in opts + self['transition'] = '-t' in opts + self['verbose'] = '-v' in opts + self.dasystem = None # to be filled later + self.restart_filelist = [] # List of files needed for restart, to be extended later + self.output_filelist = [] # List of files needed for output, to be extended later + + + def load_rc(self, rcfilename): + """ + This method loads a DA Cycle rc-file with settings for this simulation + """ + + rcdata = rc.read(rcfilename) + for k, v in list(rcdata.items()): + self[k] = v + + logging.info('DA Cycle rc-file (%s) loaded successfully' % rcfilename) + + + def validate_rc(self): + """ + Validate the contents of the rc-file given a dictionary of required keys. + Currently required keys are :attr:`~da.tools.initexit.needed_da_items` + """ + + for k, v in list(self.items()): + if v in ['True', 'true', 't', 'T', 'y', 'yes']: + self[k] = True + if v in ['False', 'false', 'f', 'F', 'n', 'no']: + self[k] = False + if 'date' in k : + self[k] = to_datetime(v) + if k in ['time.start', 'time.end', 'time.finish', 'da.restart.tstamp']: + self[k] = to_datetime(v) + for key in needed_da_items: + if key not in self: + msg = 'Missing a required value in rc-file : %s' % key + logging.error(msg) + logging.error('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ') + logging.error('Please note the update on Dec 02 2011 where rc-file names for DaSystem and ') + logging.error('are from now on specified in the main rc-file (see da/rc/da.rc for example)') + logging.error('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ') + raise IOError(msg) + logging.debug('DA Cycle settings have been validated succesfully') + + def parse_times(self): + """ + Parse time related parameters into datetime objects for later use + """ + + startdate = self['time.start'] + finaldate = self['time.finish'] + + if finaldate <= startdate: + logging.error('The start date (%s) is not greater than the end date (%s), please revise' % (startdate.strftime('%Y%m%d'), finaldate.strftime('%Y%m%d'))) + raise ValueError + cyclelength = self['time.cycle'] # get time step + +# Determine end date + + if cyclelength == 'infinite': + enddate = finaldate + else: + enddate = advance_time(startdate, cyclelength) + + dt = enddate - startdate + + if enddate > finaldate: # do not run beyond finaldate + enddate = finaldate + + self['time.start'] = startdate + self['time.end'] = enddate + self['time.finish'] = finaldate + self['cyclelength'] = dt + + logging.info("===============================================================") + logging.info("DA Cycle start date is %s" % startdate.strftime('%Y-%m-%d %H:%M')) + logging.info("DA Cycle end date is %s" % enddate.strftime('%Y-%m-%d %H:%M')) + logging.info("DA Cycle final date is %s" % finaldate.strftime('%Y-%m-%d %H:%M')) + logging.info("DA Cycle cycle length is %s" % cyclelength) + logging.info("DA Cycle restart is %s" % str(self['time.restart'])) + logging.info("===============================================================") + + + def set_sample_times(self, lag): + """ + Set the times over which a sampling interval will loop, depending on + the lag. Note that lag falls in the interval [0,nlag-1] + """ + + # Start from cycle times + self['time.sample.start'] = copy.deepcopy(self['time.start']) + self['time.sample.end'] = copy.deepcopy(self['time.end']) + + # Now advance depending on lag + + for l in range(lag): + self.advance_sample_times() + + + def advance_sample_times(self): + """ + Advance sampling start and end time by one cycle interval + """ + + days = self['cyclelength'].days + + self['time.sample.start'] = advance_time(self['time.sample.start'], days) + self['time.sample.end'] = advance_time(self['time.sample.end'], days) + + + def advance_cycle_times(self): + """ + Advance cycle start and end time by one cycle interval + """ + + days = self['cyclelength'].days + + startdate = advance_time(self['time.start'], days) + enddate = advance_time(self['time.end'], days) + + filtertime = startdate.strftime('%Y%m%d') + self['dir.output'] = os.path.join(self['dir.da_run'], 'output', filtertime) + + self['time.start'] = startdate + self['time.end'] = enddate + + + def write_random_seed(self): + filename = os.path.join(self['dir.restart'], 'randomseed_%s.pickle' % self['time.start'].strftime('%Y%m%d')) + f = open(filename, 'wb') + seed = np.random.get_state() + pickle.dump(seed, f, -1) + f.close() + + logging.info("Saved the random seed generator values to file") + + + def read_random_seed(self, first=False): + if first: + filename = self.dasystem['random.seed.init'] + logging.info("Initialised random seed from: %s"%filename) + else: + filename = os.path.join(self['dir.restart'], 'randomseed_%s.pickle' % self['da.restart.tstamp'].strftime('%Y%m%d')) + logging.info("Retrieved the random seed generator values of last cycle from file") + f = open(filename, 'rb') + seed = pickle.load(f,encoding='latin1') + np.random.set_state(seed) + f.close() + + + def setup(self): + """ + This method determines how to proceed with the cycle. Three options are implemented: + + 1. *Fresh start* : set up the required file structure for this simulation and start + 2. *Restart* : use latest da_runtime variables from the exec dir and restart + 3. *Recover* : restart after crash by getting data from restart/one-ago folder + + The choice that gets executed depends on the presence of + + # the ``-r`` option on the command line, this triggers a recover + # the ``time.restart : True`` option in the da.rc file + + The latter is automatically set if the filter submits the next cycle at the end of the current one, + through method :meth:`~da.tools.initexit.CycleControl.submit_next_cycle`. + + The specific call tree under each scenario is: + + 1. *Fresh Start* + * :meth:`~da.tools.initexit.CycleControl.setup_file_structure()` <- Create directory tree + 2. *Restart* + * :meth:`~da.tools.initexit.CycleControl.setup_file_structure()` + * :meth:`~da.tools.initexit.CycleControl.random_seed` <- Read the random seed from file + 3. *Recover* + * :meth:`~da.tools.initexit.CycleControl.setup_file_structure()` + * :meth:`~da.tools.initexit.CycleControl.recover_run()` <- Recover files from restart/one-ago dir, reset ``time.start`` + * :meth:`~da.tools.initexit.CycleControl.random_seed` + + And is always followed by a call to + + * parse_times() + * WriteRc('jobfilename') + """ + if self['transition']: + logging.info("Transition of filter from previous step with od meteo from 25 to 34 levels") + self.setup_file_structure() + strippedname = os.path.split(self['jobrcfilename'])[-1] + self['jobrcfilename'] = os.path.join(self['dir.exec'], strippedname) + self.read_random_seed(False) + + elif self['time.restart']: + logging.info("Restarting filter from previous step") + self.setup_file_structure() + strippedname = os.path.split(self['jobrcfilename'])[-1] + self['jobrcfilename'] = os.path.join(self['dir.exec'], strippedname) + self.read_random_seed(False) + + else: #assume that it is a fresh start, change this condition to more specific if crash recover added + logging.info("First time step in filter sequence") + self.setup_file_structure() + + # expand jobrcfilename to include exec dir from now on. + # First strip current leading path from filename + + strippedname = os.path.split(self['jobrcfilename'])[-1] + self['jobrcfilename'] = os.path.join(self['dir.exec'], strippedname) + if 'extendedregionsfile' in self.dasystem: + shutil.copy(os.path.join(self.dasystem['extendedregionsfile']),os.path.join(self['dir.exec'],'da','analysis','cteco2','copied_regions_extended.nc')) + logging.info('Copied extended regions file to the analysis directory: %s'%os.path.join(self.dasystem['extendedregionsfile'])) + else: + shutil.copy(os.path.join(self['dir.exec'],'da','analysis','cteco2','olson_extended.nc'),os.path.join(self['dir.exec'],'da','analysis','cteco2','copied_regions_extended.nc')) + logging.info('Copied extended regions within the analysis directory: %s'%os.path.join(self['dir.exec'],'da','analysis','cteco2','olson_extended.nc')) + for filename in glob.glob(os.path.join(self['dir.exec'],'da','analysis','cteco2','*.pickle')): + logging.info('Deleting pickle file %s to make sure the correct regions are used'%os.path.split(filename)[1]) + os.remove(filename) + for filename in glob.glob(os.path.join(self['dir.exec'],'*.pickle')): + logging.info('Deleting pickle file %s to make sure the correct regions are used'%os.path.split(filename)[1]) + os.remove(filename) + if 'random.seed.init' in self.dasystem: + self.read_random_seed(True) + + self.parse_times() + #self.write_rc(self['jobrcfilename']) + + def setup_file_structure(self): + """ + Create file structure needed for data assimilation system. + In principle this looks like: + + * ``${{da_rundir}}`` + * ``${{da_rundir}}/input`` + * ``${{da_rundir}}/output`` + * ``${{da_rundir}}/exec`` + * ``${{da_rundir}}/analysis`` + * ``${{da_rundir}}/jobs`` + * ``${{da_rundir}}/restart/current`` + * ``${{da_rundir}}/restart/one-ago`` + + .. note:: The exec dir will actually be a simlink to the directory where + the observation operator executable lives. This directory is passed through + the ``da.rc`` file. + + .. note:: The observation input files will be placed in the exec dir, + and the resulting simulated values will be retrieved from there as well. + + """ + +# Create the run directory for this DA job, including I/O structure + + filtertime = self['time.start'].strftime('%Y%m%d') + + self['dir.exec'] = os.path.join(self['dir.da_run'], 'exec') + self['dir.input'] = os.path.join(self['dir.da_run'], 'input') + self['dir.output'] = os.path.join(self['dir.da_run'], 'output', filtertime) + self['dir.analysis'] = os.path.join(self['dir.da_run'], 'analysis') + self['dir.jobs'] = os.path.join(self['dir.da_run'], 'jobs') + self['dir.restart'] = os.path.join(self['dir.da_run'], 'restart') + + create_dirs(self['dir.da_run']) + create_dirs(os.path.join(self['dir.exec'])) + create_dirs(os.path.join(self['dir.input'])) + create_dirs(os.path.join(self['dir.output'])) + create_dirs(os.path.join(self['dir.analysis'])) + create_dirs(os.path.join(self['dir.jobs'])) + create_dirs(os.path.join(self['dir.restart'])) + + logging.info('Succesfully created the file structure for the assimilation job') + + + def finalize(self): + """ + finalize the da cycle, this means writing the save data and rc-files for the next run. + The following sequence of actions occur: + + * Write the randomseed to file for reuse in next cycle + * Write a new ``rc-file`` with ``time.restart : True``, and new ``time.start`` and ``time.end`` + * Collect all needed data needed for check-pointing (restart from current system state) + * Move the previous check pointing data out of the way, and replace with current + * Submit the next cycle + + """ + self.write_random_seed() + self.write_new_rc_file() + + self.collect_restart_data() # Collect restart data for next cycle into a clean restart/current folder + self.collect_output() # Collect restart data for next cycle into a clean restart/current folder + self.submit_next_cycle() + + def collect_output(self): + """ Collect files that are part of the requested output for this cycle. This function allows users to add files + to a list, and then the system will copy these to the current cycle's output directory. + The list of files included is read from the + attribute "output_filelist" which is a simple list of files that can be appended by other objects/methods that + require output data to be saved. + + + """ + targetdir = os.path.join(self['dir.output']) + create_dirs(targetdir) + + logging.info("Collecting the required output data") + logging.debug(" to directory: %s " % targetdir) + + for file in set(self.output_filelist): + if os.path.isdir(file): # skip dirs + continue + if not os.path.exists(file): # skip dirs + logging.warning(" [not found] .... %s " % file) + continue + + logging.debug(" [copy] .... %s " % file) + shutil.copy(file, file.replace(os.path.split(file)[0], targetdir)) + + + + def collect_restart_data(self): + """ Collect files needed for the restart of this cycle in case of a crash, or for the continuation of the next cycle. + All files needed are written to the restart/current directory. The list of files included is read from the + attribute "restart_filelist" which is a simple list of files that can be appended by other objects/methods that + require restart data to be saved. + + .. note:: Before collecting the files in the ``restart_filelist``, the restart/current directory will be emptied and + recreated. This prevents files from accumulating in the restart/current and restart/one-ago folders. It + also means that if a file is missing from the ``restart_filelist``, it will not be available for check-pointing + if your run crashes or dies! + + Currently, the following files are included: + + * The ``da_runtime.rc`` file + * The ``randomseed.pickle`` file + * The savestate.nc file + * The files in the ``ObservationOperator.restart_filelist``, i.e., restart data for the transport model + + + .. note:: We assume that the restart files for the :ref:`ObservationOperator` + reside in a separate folder, i.e, the ObservationOperator does *not* write directly to the CTDAS restart dir! + + """ + + targetdir = os.path.join(self['dir.restart']) + + #logging.info("Purging the current restart directory before collecting new data") + + #create_dirs(targetdir, forceclean=True) + + logging.info("Collecting the required restart data") + logging.debug(" to directory: %s " % targetdir) + + for file in set(self.restart_filelist): + if os.path.isdir(file): # skip dirs + continue + if not os.path.exists(file): + logging.warning(" [not found] .... %s " % file) + else: + logging.debug(" [copy] .... %s " % file) + shutil.copy(file, file.replace(os.path.split(file)[0], targetdir)) + + + +# + def write_new_rc_file(self): + """ Write the rc-file for the next DA cycle. + + .. note:: The start time for the next cycle is the end time of this one, while + the end time for the next cycle is the current end time + one cycle length. + + The resulting rc-file is written to the ``dir.exec`` so that it can be used when resubmitting the next cycle + + """ + + # We make a copy of the current dacycle object, and modify the start + end dates and restart value + + new_dacycle = copy.deepcopy(self) + new_dacycle['da.restart.tstamp'] = self['time.start'] + new_dacycle.advance_cycle_times() + new_dacycle['time.restart'] = True + + # Create the name of the rc-file that will hold this new input, and write it + + #fname = os.path.join(self['dir.exec'], 'da_runtime.rc') # current exec dir holds next rc file + + fname = os.path.join(self['dir.restart'], 'da_runtime_%s.rc' % new_dacycle['time.start'].strftime('%Y%m%d'))#advanced time + + rc.write(fname, new_dacycle) + logging.debug('Wrote new da_runtime.rc (%s) to restart dir' % fname) + + # The rest is info needed for a system restart, so it modifies the current dacycle object (self) + + self['da.restart.fname'] = fname # needed for next job template + #self.restart_filelist.append(fname) # not that needed since it is already written to the restart dir... + #logging.debug('Added da_runtime.rc to the restart_filelist for later collection') + + + def write_rc(self, fname): + """ Write RC file after each process to reflect updated info """ + + rc.write(fname, self) + logging.debug('Wrote expanded rc-file (%s)' % fname) + + + def submit_next_cycle(self): + """ + Submit the next job of a DA cycle, this consists of + * Changing to the working directory from which the job was started initially + * create a line to start the master script again with a newly created rc-file + * Submitting the jobfile + + If the end of the cycle series is reached, no new job is submitted. + + """ + + + if self['time.end'] < self['time.finish']: + + # file ID and names + jobid = self['time.end'].strftime('%Y%m%d') + targetdir = os.path.join(self['dir.exec']) + jobfile = os.path.join(targetdir, 'jb.%s.jb' % jobid) + logfile = os.path.join(targetdir, 'jb.%s.log' % jobid) + # Template and commands for job + jobparams = {{'jobname':"j.%s" % jobid, 'jobnodes':self['da.resources.ntasks'], 'jobtime': self['da.resources.ntime'], 'logfile': logfile, 'errfile': logfile}} + template = self.daplatform.get_job_template(jobparams) + execcommand = os.path.join(self['dir.da_submit'], sys.argv[0]) + if '-t' in self.opts: + (self.opts).remove('-t') + + if 'icycle_in_job' not in os.environ: + logging.info('Environment variable icycle_in_job not found, resubmitting after this cycle') + os.environ['icycle_in_job'] = self['da.resources.ncycles_per_job'] # assume that if no cycle number is set, we should submit the next job by default + else: + logging.info('Environment variable icycle_in_job was found, processing cycle %s of %s in this job'%(os.environ['icycle_in_job'],self['da.resources.ncycles_per_job']) ) + + ncycles = int(self['da.resources.ncycles_per_job']) + for cycle in range(ncycles): + nextjobid = '%s'% ( (self['time.end']+cycle*self['cyclelength']).strftime('%Y%m%d'),) + nextrestartfilename = self['da.restart.fname'].replace(jobid,nextjobid) + nextlogfilename = logfile.replace(jobid,nextjobid) + if self.daplatform.ID == 'WU capegrim': + template += """\nexport icycle_in_job=%d\npython3 %s rc=%s %s >&%s &\n""" % (cycle+1,execcommand, nextrestartfilename, ''.join(self.opts), nextlogfilename,) + else: + template += """\nexport icycle_in_job=%d\npython3 %s rc=%s %s >&%s\n""" % (cycle+1,execcommand, nextrestartfilename, ''.join(self.opts), nextlogfilename,) + + # write and submit + self.daplatform.write_job(jobfile, template, jobid) + if 'da.resources.ncycles_per_job' in self: + do_submit = (int(os.environ['icycle_in_job']) >= int(self['da.resources.ncycles_per_job'])) + else: + dosubmit = False + + if do_submit: + jobid = self.daplatform.submit_job(jobfile, joblog=logfile) + + else: + logging.info('Final date reached, no new cycle started') + + +def start_logger(level=logging.INFO): + """ start the logging of messages to screen""" + +# start the logging basic configuration by setting up a log file + + logging.basicConfig(level=level, + format=' [%(levelname)-7s] (%(asctime)s) py-%(module)-20s : %(message)s', + datefmt='%Y-%m-%d %H:%M:%S') + +def parse_options(): + """ + Function parses options from the command line and returns the arguments as a dictionary. + Accepted command line arguments are: + + ======== ======= + Argument Meaning + ======== ======= + -v verbose output in log files + -h display help + -r start a simulation by recovering from a previous crash + -t start a simulation by transitioning from 25 to 34 layers in December 2005 (od meteo) + ======== ======= + + """ + +# Parse keywords, the only option accepted so far is the "-h" flag for help + + opts = [] + args = [] + try: + opts, args = getopt.gnu_getopt(sys.argv[1:], "-rvt") + except getopt.GetoptError as msg: + logging.error('%s' % msg) + sys.exit(2) + + for options in opts: + options = options[0].lower() + if options == '-r': + logging.info('-r flag specified on command line: recovering from crash') + if options == '-t': + logging.info('-t flag specified on command line: transition with od from December 2005') + if options == '-v': + logging.info('-v flag specified on command line: extra verbose output') + logging.root.setLevel(logging.DEBUG) + + if opts: + optslist = [item[0] for item in opts] + else: + optslist = [] + +# Parse arguments and return as dictionary + + arguments = {{}} + for item in args: + #item=item.lower() + +# Catch arguments that are passed not in "key=value" format + + if '=' in item: + key, arg = item.split('=') + else: + logging.error('%s' % 'Argument passed without description (%s)' % item) + raise getopt.GetoptError(arg) + + arguments[key] = arg + + + return optslist, arguments + +def validate_opts_args(opts, args): + """ + Validate the options and arguments passed from the command line before starting the cycle. The validation consists of checking for the presence of an argument "rc", and the existence of + the specified rc-file. + + """ + if "rc" not in args: + msg = "There is no rc-file specified on the command line. Please use rc=yourfile.rc" + logging.error(msg) + raise IOError(msg) + elif not os.path.exists(args['rc']): + msg = "The specified rc-file (%s) does not exist " % args['rc'] + logging.error(msg) + raise IOError(msg) + + # WP not needed anymore + #if not args.has_key('process'): + # msg = "There is no process specified on the command line, assuming process=Start" ; logging.info(msg) + # args['process'] = 'start' + #if args['process'].lower() not in validprocesses: + # msg = "The specified process (%s) is not valid"%args['process'] ; logging.error(msg) + # raise IOError,msg + + return opts, args + + +if __name__ == "__main__": + pass + diff --git a/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py b/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py new file mode 100644 index 00000000..7f0050a9 --- /dev/null +++ b/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py @@ -0,0 +1,964 @@ +"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +updates of the code. See also: http://www.carbontracker.eu. + +This program is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free Software Foundation, +version 3. This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this +program. If not, see .""" +#!/usr/bin/env python +# obs.py + +""" +.. module:: obs +.. moduleauthor:: Wouter Peters + +Revision History: +File created on 28 Jul 2010. + +.. autoclass:: da.baseclasses.obs.Observations + :members: setup, Validate, add_observations, add_simulations, add_model_data_mismatch, write_sample_coords + +.. autoclass:: da.baseclasses.obs.ObservationList + :members: __init__ + +""" + +import logging, sys, os, glob +from numpy import array, ndarray +import datetime as dt +from datetime import timedelta +import numpy as np +from netCDF4 import Dataset +import xarray as xr +from multiprocessing import Pool +import datetime +sys.path.append(os.getcwd()) +sys.path.append('../../') + +print("Python Version:", sys.version) +print("Python Executable Path:", sys.executable) + +from unidecode import unidecode + +identifier = 'Observations baseclass' +version = '0.0' + +from da.observations.obs_baseclass import Observations +import da.tools.io4 as io +import da.tools.rc as rc + +################### Begin Class Observations ################### + +class ICOSObservations(object): + """ + The baseclass Observations is a generic object that provides a number of methods required for any type of observations used in + a data assimilation system. These methods are called from the CarbonTracker pipeline. + + .. note:: Most of the actual functionality will need to be provided through a derived Observations class with the methods + below overwritten. Writing your own derived class for Observations is one of the first tasks you'll likely + perform when extending or modifying the CarbonTracker Data Assimilation Shell. + + Upon initialization of the class, an object is created that holds no actual data, but has a placeholder attribute `self.Data` + which is an empty list of type :class:`~da.baseclasses.obs.ObservationList`. An ObservationList object is created when the + method :meth:`~da.baseclasses.obs.Observations.add_observations` is invoked in the pipeline. + + From the list of observations, a file is written by method + :meth:`~da.baseclasses.obs.Observations.write_sample_info` + with the sample info needed by the + :class:`~da.baseclasses.observationoperator.ObservationOperator` object. The values returned after sampling + are finally added by :meth:`~da.baseclasses.obs.Observations.add_simulations` + + """ + + def __init__(self): + """ + create an object with an identifier, version, and an empty ObservationList + """ + self.ID = identifier + self.version = version + self.datalist = [] # initialize with an empty list of obs + + # The following code allows the object to be initialized with a dacycle object already present. Otherwise, it can + # be added at a later moment. + + logging.info('Observations object initialized: %s' % self.ID) + + def getlength(self): + return len(self.datalist) + + def setup(self, dacycle): + """ Perform all steps needed to start working with observational data, this can include moving data, concatenating files, + selecting datasets, etc. + """ + + self.dacycle = dacycle + self.startdate = dacycle['time.sample.start'] + self.enddate = dacycle['time.sample.end'] + op_dir = dacycle.dasystem['obs.input.dir'] + #self.obs_fname = dacycle.dasystem['obs.input.fname'] + self.n_bg_params = int(dacycle['statevector.bg_params']) + self.tracer = str(dacycle['statevector.tracer']) + if not os.path.exists(op_dir): + msg = 'Could not find the required ObsPack distribution (%s) ' % op_dir + logging.error(msg) + raise IOError(msg) + else: + self.obspack_dir = op_dir + + self.datalist = [] + + + def get_samples_type(self): + return 'insitu' + + + def add_observations(self): + """ + Add actual observation data to the Observations object. This is in a form of an + :class:`~da.baseclasses.obs.ObservationList` that is contained in self.Data. The + list has as only requirement that it can return the observed+simulated values + through the method :meth:`~da.baseclasses.obs.ObservationList.getvalues` + + """ + + # Step 1: Read list of available site files in package + ###################################################### + + mountain_stations = {cfg.CTDAS["obs"]["ICOS"]["mountain_stations"]} + + os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE" + +########################################################################################################## +# THE FOLLOWING COMMENTED BLOCK IS FOR READING-IN REAL DATA +########################################################################################################## + + mdm_dictionary = { evaluate_dict({k: v for d in cfg.CTDAS["obs"]["ICOS"]["mdm"] for k, v in d.items()}, "c_offset", cfg.CTDAS_obs_ICOS_c_offset) }# Based on the simulated standard deviation of the signal (without background) over a full year. + + u_id = 1 + for ncfile in list(glob.glob(os.path.join(self.obspack_dir,f'Extracted_{{self.dacycle["time.sample.stamp"][0:8]}}*.nc'))): + if not ncfile.endswith('.nc'): continue + + logging.info('Found file ', ) + infile = os.path.join(self.obspack_dir, ncfile) + print("infile = ", infile) + + f = xr.open_dataset(infile) + + logging.info('Looking into the file %s...'%(infile)) + + sites_names = np.array([unidecode(x) for x in f.Stations_names.values]) + + mountain_hours = ['0' + str(x) for x in np.arange(0,7)] + rest_hours = [str(x) for x in np.arange(12,17)] + + st_ind = np.arange(len(sites_names)) + + #def caculate_interval_mean_cnc(dates, conc, hr): + + + for x in st_ind: + + station_name = sites_names[x] + if station_name not in mdm_dictionary: continue # Skip stations outside of the domain! + + cnc = f.Concentration[x].values + + dates = f.Dates[x].values + flag = 1 + mdm_value = mdm_dictionary[station_name] # ERIK: CHANGED FROM constant 10 + base_height_above_sealevel = f.Stations_masl[x].values + inlet_height = float( station_name.split("_")[-1] ) + lon = f.Lon[x].values + lat = f.Lat[x].values + species = self.tracer + strategy = 'mountain' if station_name in mountain_stations else 'ground' # 1 for + + if station_name in mountain_stations: + ind_dt = np.asarray([str(x)[11:13] in mountain_hours for x in f.Dates.values[x]]) #mask of hours taken for mountain sites + hr=0 + else: + ind_dt = np.asarray([str(x)[11:13] in rest_hours for x in f.Dates.values[x]]) #mask of hours taken for the rest of the sites + hr=12 + data = cnc[ind_dt] + times = np.asarray([datetime.datetime.strptime(str(x)[:-13], "%Y-%m-%dT%H:%M") for x in dates[ind_dt]]) + logging.info('Check dates: %s %s'%(self.enddate+timedelta(days=1), self.startdate+timedelta(days=1))) + mask_da_interval = np.logical_and(times<=(self.enddate+timedelta(days=1)), (self.startdate+timedelta(days=1))<=times) + times = times[mask_da_interval] + data = data[mask_da_interval] + if len(times)>0: + for iday in set([ii.day for ii in times]): + ids = [iii for iii,dd in enumerate(times) if dd.day==iday] + value = np.nanmean(np.array([c for i,c in enumerate(data) if times[i].day==iday])) + dict_date = times[ids[0]].replace(hour=hr) + if not np.isfinite(value): continue + + self.datalist.append(MoleFractionSample(u_id,dict_date,station_name,value,0.0,0.0,0.0,mdm_value,flag,base_height_above_sealevel,lat,lon,station_name,species,strategy,0.0,station_name,inlet_height,base_height_above_sealevel)) + + logging.info('For itime([day]T[hour]) (%iT%i) adding synthetic obs %i at station %s: %5.2e'%(dict_date.day,dict_date.hour,u_id,station_name,value)) + u_id += 1 + + # add_station_data_to_sample(x) + + logging.info("Observations list now holds %d values" % len(self.datalist)) +########################################################################################################## + + + + def add_simulations(self, filename, silent=False): + """ Add the simulation data to the Observations object. + """ + + + if not os.path.exists(filename): + msg = "Sample output filename for observations could not be found : %s" % filename + logging.error(msg) + logging.error("Did the sampling step succeed?") + logging.error("...exiting") + raise IOError(msg) + + ncf = io.ct_read(filename, method='read') + ids = ncf.get_variable('obs_num') + simulated = ncf.get_variable('flask') + ncf.close() + logging.info("Successfully read data from model sample file (%s)" % filename) + + obs_ids = self.getvalues('id').tolist() + ids = list(map(int, ids)) + + missing_samples = [] + + for idx, val in zip(ids, simulated): + if idx in obs_ids: + index = obs_ids.index(idx) + self.datalist[index].simulated = val # in mol/mol + else: + missing_samples.append(idx) + + if not silent and missing_samples != []: + logging.warning('Model samples were found that did not match any ID in the observation list. Skipping them...') + msg = '%s'%missing_samples ; logging.warning(msg) + + logging.debug("Added %d simulated values to the Data list" % (len(ids) - len(missing_samples))) + logging.info("Added %d simulated values to the Data list" % (len(ids) - len(missing_samples))) + + + def add_model_data_mismatch(self, filename): + """ + Get the model-data mismatch values for this cycle. + """ + self.rejection_threshold = 10.0 # 3-sigma cut-off + self.global_R_scaling = 1.0 # no scaling applied + + for obs in self.datalist: # first loop over all available data points to set flags correctly + + obs.may_localize = True #False + obs.may_reject = False + obs.flag = 0 + + logging.debug("Added Model Data Mismatch to all samples ") + + + def write_sample_coords(self,obsinputfile): + """ + Write the information needed by the observation operator to a file. Return the filename that was written for later use + """ + + if len(self.datalist) == 0: + logging.debug("No observations found for this time period, nothing written to obs file") + else: + f = io.CT_CDF(obsinputfile, method='create') + logging.debug('Creating new observations file for ObservationOperator (%s)' % obsinputfile) + + dimid = f.add_dim('obs', len(self.datalist)) +# dim200char = f.add_dim('string_of200chars', 200) + dim50char = f.add_dim('string_of50chars', 50) + dim3char = f.add_dim('string_of3chars', 3) + dimcalcomp = f.add_dim('calendar_components', 6) + + data = self.getvalues('id') + + savedict = io.std_savedict.copy() + savedict['name'] = "obs_num" + savedict['dtype'] = "int" + savedict['long_name'] = "Unique_Dataset_observation_index_number" + savedict['units'] = "" + savedict['dims'] = dimid + savedict['values'] = data.tolist() + savedict['comment'] = "Unique index number within this dataset ranging from 0 to UNLIMITED." + f.add_data(savedict) + + data = self.getvalues('evn') + # print("data==", data) + + savedict = io.std_savedict.copy() + savedict['name'] = "evn" + savedict['dtype'] = "char" + savedict['long_name'] = "Site_name_abbreviation" + savedict['units'] = "" + savedict['dims'] = dimid + dim50char + savedict['values'] = data.tolist() + savedict['comment'] = "Site name abbreviation as in the data file." + f.add_data(savedict) + + data = self.getvalues('fromfile') + + savedict = io.std_savedict.copy() + savedict['name'] = "fromfile" + savedict['dtype'] = "char" + savedict['long_name'] = "data_file_name" + savedict['units'] = "" + savedict['dims'] = dimid + dim50char + savedict['values'] = data.tolist() + savedict['comment'] = "File name of data file." + f.add_data(savedict) + + data = [[d.year, d.month, d.day, d.hour, d.minute, d.second] for d in self.getvalues('xdate') ] + + savedict = io.std_savedict.copy() + savedict['dtype'] = "int" + savedict['name'] = "date_components" + savedict['units'] = "integer components of UTC date/time" + savedict['dims'] = dimid + dimcalcomp + savedict['values'] = data + savedict['missing_value'] = -999 + savedict['comment'] = "Calendar date components as integers. Times and dates are UTC." + savedict['order'] = "year, month, day, hour, minute, second" + f.add_data(savedict) + + data = self.getvalues('lat') + + savedict = io.std_savedict.copy() + savedict['dtype'] = "float" + savedict['name'] = "latitude" + savedict['units'] = "degrees_north" + savedict['dims'] = dimid + savedict['values'] = data.tolist() + savedict['missing_value'] = -999.9 + f.add_data(savedict) + + data = self.getvalues('lon') + + savedict = io.std_savedict.copy() + savedict['dtype'] = "float" + savedict['name'] = "longitude" + savedict['units'] = "degrees_east" + savedict['dims'] = dimid + savedict['values'] = data.tolist() + savedict['missing_value'] = -999.9 + f.add_data(savedict) + + data = self.getvalues('masl') + + savedict = io.std_savedict.copy() + savedict['dtype'] = "float" + savedict['name'] = "base_height_over_sea_level" + savedict['units'] = "meters_above_sea_level" + savedict['dims'] = dimid + savedict['values'] = data.tolist() + savedict['missing_value'] = -999.9 + f.add_data(savedict) + + data = self.getvalues('mag') + + savedict = io.std_savedict.copy() + savedict['dtype'] = "float" + savedict['name'] = "inlet_height_over_base" + savedict['units'] = "meters_above_ground" + savedict['dims'] = dimid + savedict['values'] = data.tolist() + savedict['missing_value'] = -999.9 + f.add_data(savedict) + + data = self.getvalues('samplingstrategy') + + savedict = io.std_savedict.copy() + savedict['dtype'] = "char" + savedict['name'] = "sampling_strategy" + savedict['units'] = "" + savedict['dims'] = dimid + dim50char + savedict['values'] = data.tolist() + savedict['comment'] = "Sampling strategy (ground or mountain)." + f.add_data(savedict) + + data = self.getvalues('obs') + + savedict = io.std_savedict.copy() + savedict['dtype'] = "float" + savedict['name'] = "observed" + savedict['long_name'] = "observedvalues" + savedict['units'] = "mol mol-1" + savedict['dims'] = dimid + savedict['values'] = data.tolist() + savedict['comment'] = 'Observations used in optimization' + f.add_data(savedict) + + data = self.getvalues('mdm') + + savedict = io.std_savedict.copy() + savedict['dtype'] = "float" + savedict['name'] = "modeldatamismatch" + savedict['long_name'] = "modeldatamismatch" + savedict['units'] = "[mol mol-1]" + savedict['dims'] = dimid + savedict['values'] = data.tolist() + savedict['comment'] = 'Standard deviation of mole fractions resulting from model-data mismatch' + f.add_data(savedict) + f.close() + + logging.debug("Successfully wrote data to obs file") + logging.info("Sample input file for obs operator now in place [%s]" % obsinputfile) + + + + + def write_sample_auxiliary(self, auxoutputfile): + """ + Write selected additional information contained in the Observations object to a file for later processing. + + """ + + def getvalues(self, name, constructor=array): + + result = constructor([getattr(o, name) for o in self.datalist]) + if isinstance(result, ndarray): + return result.squeeze() + else: + return result + + +################### End Class Observations ################### + +################### Begin Class MoleFractionSample ################### + +class MoleFractionSample(object): + """ + Holds the data that defines a mole fraction Sample in the data assimilation framework. Sor far, this includes all + attributes listed below in the __init__ method. One can additionally make more types of data, or make new + objects for specific projects. + + """ + + def __init__(self, idx, xdate, code='XXX', obs=0.0, simulated=0.0, resid=0.0, hphr=0.0, mdm=0.0, flag=0, height=0.0, lat= -999., lon= -999., evn='0000', species='co2', samplingstrategy=1, sdev=0.0, fromfile='none.nc', height_above_ground=0, height_above_sealevel=0): + self.code = code.strip() # dataset identifier, i.e., co2_lef_tower_insitu_1_99 + self.xdate = xdate # Date of obs + self.obs = obs # Value observed + self.simulated = simulated # Value simulated by model + self.resid = resid # Mole fraction residuals + self.hphr = hphr # Mole fraction prior uncertainty from fluxes and (HPH) and model data mismatch (R) + self.mdm = mdm # Model data mismatch + self.may_localize = True # Whether sample may be localized in optimizer + self.may_reject = True # Whether sample may be rejected if outside threshold + self.flag = flag # Flag + self.height = height # Sample height in masl + self.lat = lat # Sample lat + self.lon = lon # Sample lon + self.id = idx # Obspack ID within distrution (integer), e.g., 82536 + self.evn = evn # Obspack Number within distrution (string), e.g., obspack_co2_1_PROTOTYPE_v0.9.2_2012-07-26_99_82536 + self.sdev = sdev # standard deviation of ensemble + self.masl = height_above_sealevel # Sample is in Meters Above Sea Level + self.mag = height_above_ground # Sample is in Meters Above Ground + self.species = species.strip() + self.samplingstrategy = samplingstrategy + self.fromfile = fromfile # netcdf filename inside ObsPack distribution, to write back later + +################### End Class MoleFractionSample ################### + + + + +################### Begin Class TotalColumnSample ################### +class TotalColumnSample(object): + """ + Holds the data that defines a total column sample in the data assimilation framework. Sor far, this includes all + attributes listed below in the __init__ method. One can additionally make more types of data, or make new + objects for specific projects. + This file may contain OCO-2 specific parts... + """ + + def __init__(self, idx, codex, xdate, obs=0.0, simulated=0.0, lat=-999., lon=-999., mdm=None, prior=0.0, prior_profile=0.0, av_kernel=0.0, pressure=0.0, \ + ##### freum vvvv + pressure_weighting_function=None, + ##### freum ^^^^ + level_def = "pressure_boundary", psurf = float('nan'), resid=0.0, hphr=0.0, flag=0, species='co2', sdev=0.0, \ + ##### freum vvvv + latc_0=None, latc_1=None, latc_2=None, latc_3=None, lonc_0=None, lonc_1=None, lonc_2=None, lonc_3=None \ + ##### freum ^^^^ + ): + self.id = idx # Sounding ID + self.code = codex # Retrieval ID + self.xdate = xdate # Date of obs + self.obs = obs # Value observed + self.simulated = simulated # Value simulated by model, fillvalue = -9999 + self.lat = lat # Sample lat + self.lon = lon # Sample lon + ##### freum vvvv + self.latc_0 = latc_0 # Sample latitude corner + self.latc_1 = latc_1 # Sample latitude corner + self.latc_2 = latc_2 # Sample latitude corner + self.latc_3 = latc_3 # Sample latitude corner + self.lonc_0 = lonc_0 # Sample longitude corner + self.lonc_1 = lonc_1 # Sample longitude corner + self.lonc_2 = lonc_2 # Sample longitude corner + self.lonc_3 = lonc_3 # Sample longitude corner + ##### freum ^^^^ + self.mdm = mdm # Model data mismatch + self.prior = prior # A priori column value used in retrieval + self.prior_profile = prior_profile # A priori profile used in retrieval + self.av_kernel = av_kernel # Averaging kernel + self.pressure = pressure # Pressure levels of retrieval + # freum vvvv + self.pressure_weighting_function = pressure_weighting_function # Pressure weighting function + # freum ^^^^ + self.level_def = level_def # Are prior and averaging kernel defined as layer averages? + self.psurf = psurf # Surface pressure (only needed if level_def is "layer_average") + self.loc_L = int(600) #int(0) # freum 2021-07-13: insert this dummy value so the code runs with the current version of CTDAS. *Should* not affect results if localizetype == "CT2007" as in all my runs. However, replace this file with the standard observation file, obs_column_xco2.py + + self.resid = resid # Mole fraction residuals + self.hphr = hphr # Mole fraction prior uncertainty from fluxes and (HPH) and model data mismatch (R) + self.may_localize = True # Whether sample may be localized in optimizer + self.may_reject = True # Whether sample may be rejected if outside threshold + self.flag = flag # Flag + self.sdev = sdev # standard deviation of ensemble + self.species = species.strip() + + +################### End Class TotalColumnSample ################### + + +################### Begin Class TotalColumnObservations ################### + +class TotalColumnObservations(Observations): + """ An object that holds data + methods and attributes needed to manipulate column samples + """ + + def setup(self, dacycle): + + self.startdate = dacycle['time.sample.start'] + timedelta(days=1) + self.enddate = dacycle['time.sample.end'] + + # Path to the input data (daily files) + sat_files = dacycle.dasystem['obs.column.ncfile'].split(',') + sat_dirs = dacycle.dasystem['obs.column.input.dir'].split(',') + + self.sat_dirs = [] + self.sat_files = [] + for i in range(len(sat_dirs)): + if not os.path.exists(sat_dirs[i].strip()): + msg = 'Could not find the required satellite input directory (%s) ' % sat_dirs[i] + logging.error(msg) + raise IOError(msg) + else: + self.sat_dirs.append(sat_dirs[i].strip()) + self.sat_files.append(sat_files[i].strip()) + del i + + # Get observation selection criteria (if present): + if 'obs.column.selection.variables' in dacycle.dasystem.keys() and 'obs.column.selection.criteria' in dacycle.dasystem.keys(): + self.selection_vars = dacycle.dasystem['obs.column.selection.variables'].split(',') + self.selection_criteria = dacycle.dasystem['obs.column.selection.criteria'].split(',') + logging.debug('Data selection criteria found: %s, %s' %(self.selection_vars, self.selection_criteria)) + else: + self.selection_vars = [] + self.selection_criteria = [] + logging.info('No data observation selection criteria found, using all observations in file.') + + # Model data mismatch approach + # self.mdm_calculation = dacycle.dasystem.get('mdm.calculation') + # logging.debug('mdm.calculation = %s' %self.mdm_calculation) + # if not self.mdm_calculation in ['parametrization','empirical','no_transport_error']: + # logging.warning('No valid model data mismatch method found. Valid options are \'parametrization\' and \'empirical\'. ' + \ + # 'Using a constant estimate for the model uncertainty of 1ppm everywhere.') + # else: + # logging.info('Model data mismatch approach = %s' %self.mdm_calculation) + + # Path to file with observation error settings for column observations + # Currently the same settings for all assimilated retrieval products: should this be one file per product? + logging.debug('Skipping obs.column.rc check!') + # if not os.path.exists(dacycle.dasystem['obs.column.rc']): + # msg = 'Could not find the required column observation .rc input file (%s) ' % dacycle.dasystem['obs.column.rc'] + # logging.debug(msg) + # logging.debug('...but continuing!') + # # logging.error(msg) + # # raise IOError(msg) + # else: + # self.obs_file = (dacycle.dasystem['obs.column.rc']) + + self.datalist = [] + + # Switch to indicate whether simulated column samples are read from obsOperator output, + # or whether the sampling is done within CTDAS (in obsOperator class) + self.sample_in_ctdas = dacycle.dasystem['sample.in.ctdas'] if 'sample.in.ctdas' in dacycle.dasystem.keys() else False + logging.debug('sample.in.ctdas = %s' % self.sample_in_ctdas) + + + + def get_samples_type(self): + return 'column' + + + + def add_observations(self): + """ Reading of total column observations, and selection of observations that will be sampled and assimilated. + + """ + + # Read observations from daily input files + for i in range(len(self.sat_dirs)): + + logging.info('Reading observations from %s' %os.path.join(self.sat_dirs[i],self.sat_files[i])) + + infile0 = os.path.join(self.sat_dirs[i], self.sat_files[i]) + ndays = 0 + + while self.startdate+dt.timedelta(days=ndays) <= self.enddate: + + infile = infile0.replace("",(self.startdate+dt.timedelta(days=ndays)).strftime("%Y%m%d")) + logging.info('To be precise, reading observations from %s' % infile) + + + if os.path.exists(infile): + + logging.info("Reading observations for %s" % (self.startdate+dt.timedelta(days=ndays)).strftime("%Y%m%d")) + len_init = len(self.datalist) + + # get index of observations that satisfy selection criteria (based on variable names and values in system rc file, if present) + ncf = io.ct_read(infile, 'read') + + # retrieval attributes + code = ncf.get_attribute('retrieval_id') + level_def = ncf.get_attribute('level_def') + + # only read good quality observations + ids = ncf.get_variable('soundings') + lats = ncf.get_variable('latitude') + lons = ncf.get_variable('longitude') + obs = ncf.get_variable('obs') + unc = ncf.get_variable('uncertainty') + dates = ncf.get_variable('date').astype(int) + dates = array([dt.datetime(*d) for d in dates]) + av_kernel = ncf.get_variable('averaging_kernel') + prior_profile = ncf.get_variable('prior_profile') + pressure = ncf.get_variable('pressure_levels') + + prior = ncf.get_variable('prior') + + ##### freum vvvv + pwf = ncf.get_variable('pressure_weighting_function') + + # Additional variable surface pressure in case the profiles are defined as layer averages + if level_def == "layer_average": + psurf = ncf.get_variable('surface_pressure') + else: + psurf = [float('nan')]*len(ids) + + # Optional: footprint corners + latc = dict( + latc_0=[float('nan')]*len(ids), + latc_1=[float('nan')]*len(ids), + latc_2=[float('nan')]*len(ids), + latc_3=[float('nan')]*len(ids)) + lonc = dict( + lonc_0=[float('nan')]*len(ids), + lonc_1=[float('nan')]*len(ids), + lonc_2=[float('nan')]*len(ids), + lonc_3=[float('nan')]*len(ids)) + # If one footprint corner variable is there, assume + # all are there. That's the only case that makes sense + if 'latc_0' in list(ncf.variables.keys()): + latc['latc_0'] = ncf.get_variable('latc_0') + latc['latc_1'] = ncf.get_variable('latc_1') + latc['latc_2'] = ncf.get_variable('latc_2') + latc['latc_3'] = ncf.get_variable('latc_3') + lonc['lonc_0'] = ncf.get_variable('lonc_0') + lonc['lonc_1'] = ncf.get_variable('lonc_1') + lonc['lonc_2'] = ncf.get_variable('lonc_2') + lonc['lonc_3'] = ncf.get_variable('lonc_3') + ###### freum ^^^^ + + ncf.close() + + # Add samples to datalist + # Note that the mdm is initialized here equal to the measurement uncertainty. This value is used in add_model_data_mismatch to calculate the mdm including model error + for n in range(len(ids)): + # Check for every sounding if time is between start and end time (relevant for first and last days of window) + if self.startdate <= dates[n] <= self.enddate: + self.datalist.append(TotalColumnSample(ids[n], code, dates[n], obs[n], None, lats[n], lons[n], unc[n], prior[n], prior_profile[n,:], \ + av_kernel=av_kernel[n,:], pressure=pressure[n,:], pressure_weighting_function=pwf[n,:],level_def=level_def,psurf=psurf[n], + ##### freum vvvv + latc_0=latc['latc_0'][n], latc_1=latc['latc_1'][n], latc_2=latc['latc_2'][n], latc_3=latc['latc_3'][n], + lonc_0=lonc['lonc_0'][n], lonc_1=lonc['lonc_1'][n], lonc_2=lonc['lonc_2'][n], lonc_3=lonc['lonc_3'][n] + ##### freum ^^^^ + )) + + logging.debug("Added %d observations to the Data list" % (len(self.datalist)-len_init)) + + ndays += 1 + + del i + + if len(self.datalist) > 0: + logging.info("Observations list now holds %d values" % len(self.datalist)) + else: + logging.info("No observations found for sampling window") + + + + def add_model_data_mismatch(self, filename=None, advance=False): + """ This function is empty: model data mismatch calculation is done during sampling in observation operator (TM5) to enhance computational efficiency + (i.e. to prevent reading all soundings twice and writing large additional files) + + """ + # obs_data = rc.read(self.obs_file) + self.rejection_threshold = 15 #int(obs_data['obs.rejection.threshold']) + + # At this point mdm is set to the measurement uncertainty only, added in the add_observations function. + # Here this value is used to set the combined mdm by adding an estimate for the model uncertainty as a sum of squares. + if len(self.datalist) <= 1: return #== 0: return + for obs in self.datalist: + obs.mdm = ( obs.mdm*obs.mdm + 2**2 )**0.5 ## Here changed into 2 (2ppm) for CO2 : ERIK, CHANGE THIS TO WHAT I NEED! + del obs + + meanmdm = np.average(np.array( [obs.mdm for obs in self.datalist] )) + logging.debug('Mean MDM = %s' %meanmdm) + + + + def add_simulations(self, filename, silent=False): + """ Adds observed and model simulated column values to the mole fraction objects + This function includes the add_observations and add_model_data_mismatch functionality for the sake of computational efficiency + + """ + + if self.sample_in_ctdas: + logging.debug("CODE TO ADD SIMULATED SAMPLES TO DATALIST TO BE ADDED") + + else: + # read simulated samples from file + if not os.path.exists(filename): + msg = "Sample output filename for observations could not be found : %s" % filename + logging.error(msg) + logging.error("Did the sampling step succeed?") + logging.error("...exiting") + raise IOError(msg) + + ncf = io.ct_read(filename, method='read') + ids = ncf.get_variable('sounding_id') + simulated = ncf.get_variable('column_modeled') + ncf.close() + logging.info("Successfully read data from model sample file (%s)" % filename) + + obs_ids = self.getvalues('id').tolist() + + missing_samples = [] + + # Match read simulated samples with observations in datalist + logging.info("Adding %i simulated samples to the data list..." % len(ids)) + for i in range(len(ids)): + # Assume samples are in same order in both datalist and file with simulated samples... + if ids[i] == obs_ids[i]: + self.datalist[i].simulated = simulated[i] + # If not, find index of current sample + elif ids[i] in obs_ids: + index = obs_ids.index(ids[i]) + # Only add simulated value to datalist if sample has not been filled before. Otherwise: exiting + if self.datalist[index].simulated is not None: + msg = 'Simulated and observed samples not in same order, and duplicate sample IDs found.' + logging.error(msg) + raise IOError(msg) + else: + self.datalist[index].simulated = simulated[i] + else: + logging.debug('added %s to missing_samples, obs id = %s' %(ids[i],obs_ids[i])) + missing_samples.append(ids[i]) + del i + + if not silent and missing_samples != []: + logging.warning('%i Model samples were found that did not match any ID in the observation list. Skipping them...' % len(missing_samples)) + + # if number of simulated samples < observations: remove observations without samples + if len(simulated) < len(self.datalist): + test = len(self.datalist) - len(simulated) + logging.warning('%i Observations were not sampled, removing them from datalist...' % test) + for index in reversed(list(range(len(self.datalist)))): + if self.datalist[index].simulated is None: + del self.datalist[index] + del index + + logging.debug("%d simulated values were added to the data list" % (len(ids) - len(missing_samples))) + + + + def write_sample_coords(self, obsinputfile): + """ + Write empty sample_coords_file if soundings are present in time interval, just such that general pipeline code does not have to be changed... + """ + + if self.sample_in_ctdas: + return + + if len(self.datalist) <= 1: #== 0: + logging.info("No observations found for this time period, no obs file written") + return + + # write data required by observation operator for sampling to file + f = io.CT_CDF(obsinputfile, method='create') + logging.debug('Creating new observations file for ObservationOperator (%s)' % obsinputfile) + + dimsoundings = f.add_dim('soundings', len(self.datalist)) + dimdate = f.add_dim('epoch_dimension', 7) + dimchar = f.add_dim('char', 20) + if len(self.datalist) == 1: + dimlevels = f.add_dim('levels', len(self.getvalues('pressure'))) + # freum: inserted but commented Liesbeth's new code for layers for reference, + # but I handle them differently. + # if len(self.getvalues('av_kernel')) != len(self.getvalues('pressure')): + # dimlayers = f.add_dim('layers',len(self.getvalues('av_kernel'))) + # layers = True + # else: layers = False + else: + dimlevels = f.add_dim('levels', self.getvalues('pressure').shape[1]) + # if self.getvalues('av_kernel').shape[1] != self.getvalues('pressure').shape[1]: + # dimlayers = f.add_dim('layers', self.getvalues('pressure').shape[1] - 1) + # layers = True + # else: layers = False + + savedict = io.std_savedict.copy() + savedict['dtype'] = "int64" + savedict['name'] = "sounding_id" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('id').tolist() + f.add_data(savedict) + + data = [[d.year, d.month, d.day, d.hour, d.minute, d.second, d.microsecond] for d in self.getvalues('xdate') ] + savedict = io.std_savedict.copy() + savedict['dtype'] = "int" + savedict['name'] = "date" + savedict['dims'] = dimsoundings + dimdate + savedict['values'] = data + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "latitude" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('lat').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "longitude" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('lon').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "prior" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('prior').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "prior_profile" + savedict['dims'] = dimsoundings + dimlevels + savedict['values'] = self.getvalues('prior_profile').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "averaging_kernel" + savedict['dims'] = dimsoundings + dimlevels + savedict['values'] = self.getvalues('av_kernel').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "pressure_levels" + savedict['dims'] = dimsoundings + dimlevels + savedict['values'] = self.getvalues('pressure').tolist() + f.add_data(savedict) + + # freum vvvv + savedict = io.std_savedict.copy() + savedict['name'] = "pressure_weighting_function" + savedict['dims'] = dimsoundings + dimlevels + savedict['values'] = self.getvalues('pressure_weighting_function').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_0" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('latc_0').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_1" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('latc_1').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_2" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('latc_2').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_3" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('latc_3').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_0" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('lonc_0').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_1" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('lonc_1').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_2" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('lonc_2').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_3" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('lonc_3').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "XCO2" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('obs').tolist() + f.add_data(savedict) + + # freum ^^^^ + + savedict = io.std_savedict.copy() + savedict['dtype'] = "char" + savedict['name'] = "level_def" + savedict['dims'] = dimsoundings + dimchar + savedict['values'] = self.getvalues('level_def').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "psurf" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('psurf').tolist() + f.add_data(savedict) + + f.close() + + +################### End Class TotalColumnObservations ################### + + +if __name__ == "__main__": + pass diff --git a/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py b/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py new file mode 100644 index 00000000..e265605d --- /dev/null +++ b/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py @@ -0,0 +1,591 @@ +"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +updates of the code. See also: http://www.carbontracker.eu. + +This program is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free Software Foundation, +version 3. This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this +program. If not, see .""" +#!/usr/bin/env python +# model.py + +""" +.. module:: observationoperator +.. moduleauthor:: Wouter Peters + +Revision History: +File created on 30 Aug 2010. + +""" + +import logging +import subprocess +import datetime as dt +import numpy as np +from netCDF4 import Dataset +import os, sys +import subprocess +import time +import re +import da.tools.io4 as io +sys.path.append(os.getcwd()) +sys.path.append('../../') + +import da.tools.rc as rc +from da.tools.icon.icon_helper import ICON_Helper +from da.tools.icon.utilities import utilities +import subprocess +import glob + + +identifier = 'RandomizerObservationOperator' +version = '1.0' + +################### Begin Class ObservationOperator ################### +class ObservationOperator(object): + """ + Testing + ======= + This is a class that defines an ObervationOperator. This object is used to control the sampling of + a statevector in the ensemble Kalman filter framework. The methods of this class specify which (external) code + is called to perform the sampling, and which files should be read for input and are written for output. + + The baseclasses consist mainly of empty methods that require an application specific application. The baseclass will take observed values, and perturb them with a random number chosen from the model-data mismatch distribution. This means no real operator will be at work, but random normally distributed residuals will come out of y-H(x) and thus the inverse model can proceed. This is mainly for testing the code... + + """ + + def __init__(self, rc_filename, dacycle=None): + """ The instance of an ObservationOperator is application dependent """ + self.ID = identifier + self.version = version + self.restart_filelist = [] + self.output_filelist = [] + self.outputdir = None # Needed for opening the samples.nc files created + + # Load settings + self._load_rc(rc_filename) + self._validate_rc() + + # Instantiate an ICON_Helper object + self.settings["dir.icon_sim"] + self.iconhelper = ICON_Helper(self.settings) + self.iconhelper.validate_settings(["dir.icon_sim"]) + + logging.info('Observation Operator object initialized: %s (%s)', + self.ID, self.version) + + # The following code allows the object to be initialized with a dacycle object already present. Otherwise, it can + # be added at a later moment. + + if dacycle != None: + self.dacycle = dacycle + else: + self.dacycle = {{}} + + def _load_rc(self, name): + """Read settings from the observation operator's rc-file + + Based on TM5ObservationOperator.load_rc + """ + self.rcfile = rc.RcFile(name) + self.settings = self.rcfile.values + logging.debug(self.settings) + self.rc_filename = name + + logging.debug("rc-file %s loaded", name) + + + def _validate_rc(self): + """Check that some required values are given in the rc-file. + + Based on TM5ObservationOperator.validate_rc + """ + + needed_rc_items = ["dir.icon_sim"] + + for key in needed_rc_items: + if key not in self.settings: + msg = "Missing a required value in rc-file : %s" % key + logging.error(msg) + raise IOError(msg) + logging.debug("rc-file has been validated succesfully") + + def get_initial_data(self): + """ This method places all initial data needed by an ObservationOperator in the proper folder for the model """ + + def setup(self,dacycle): + """ Perform all steps necessary to start the observation operator through a simple Run() call """ + + self.dacycle = dacycle + self.outputdir = dacycle['dir.output'] + self.simulationdir = self.settings["dir.icon_sim"] + self.n_bg_params = int(dacycle['statevector.bg_params']) + self.n_regs = int(dacycle['statevector.number_regions']) + self.tracer = str(dacycle['statevector.tracer']) + + def prepare_run(self,samples): + """ Prepare the running of the actual forecast model, for example compile code """ + + import os + + # For each sample type, define the name of the file that will contain the modeled output of each observation + self.simulated_file = [None] * len(samples) + for i in range(len(samples)): + self.simulated_file[i] = os.path.join(self.outputdir, '%s_output.%s.nc' % (samples[i].get_samples_type(),self.dacycle['time.sample.stamp'])) + logging.info("Simulated flask file added: %s"%self.simulated_file[i]) + del i + self.forecast_nmembers = int(self.dacycle['da.optimizer.nmembers']) + + def make_lambdas(self,statevector,lag): + """ Write out lambda file parameters + """ + #msteiner: + #write lambda file for current lag: + members = statevector.ensemble_members[lag] + if statevector.isOptimized: + self.lambda_file = os.path.join(self.simulationdir,'global_inputs','OEM','lambda_%s_opt2.nc' %self.dacycle['time.sample.stamp'][0:8]) + self.bg_lambda_file = os.path.join(self.simulationdir,'global_inputs','OEM','bg_lambda_%s_opt2.nc' %self.dacycle['time.sample.stamp'][0:8]) + else: + if lag==0: + self.lambda_file = os.path.join(self.simulationdir,'global_inputs','OEM','lambda_%s_opt1.nc' %self.dacycle['time.sample.stamp'][0:8]) + self.bg_lambda_file = os.path.join(self.simulationdir,'global_inputs','OEM','bg_lambda_%s_opt1.nc' %self.dacycle['time.sample.stamp'][0:8]) + else: + self.lambda_file = os.path.join(self.simulationdir,'global_inputs','OEM','lambda_%s_prior.nc' %self.dacycle['time.sample.stamp'][0:8]) + self.bg_lambda_file = os.path.join(self.simulationdir,'global_inputs','OEM','bg_lambda_%s_prior.nc' %self.dacycle['time.sample.stamp'][0:8]) + + ofile = Dataset(self.lambda_file, mode='w') + nr_ens = self.forecast_nmembers + 1 if {cfg.CTDAS_propagate_bg} else 0 + nr_reg = self.n_regs + nr_cat = {max(lambdas)} + nr_tracer = 1 + oens = ofile.createDimension('ens', nr_ens) + oreg = ofile.createDimension('reg', nr_reg) + ocat = ofile.createDimension('cat', nr_cat) + otracer = ofile.createDimension('tracer', nr_tracer) + odata = ofile.createVariable('lambda', np.float32, ('ens','reg','cat','tracer'),fill_value=-999.99) + lambdas = np.empty(shape=(nr_ens,nr_reg,nr_cat,nr_tracer)) + for m in range(0,self.forecast_nmembers): + param_count=0 + for ireg in range(0,nr_reg): + for icat in range(0,nr_cat): + if statevector.isOptimized: + lambdas[m,ireg,icat,0] = members[0].param_values[param_count] + else: + lambdas[m,ireg,icat,0] = members[m].param_values[param_count] + param_count+=1 + if {cfg.CTDAS_propagate_bg}: + for ireg in range(0,nr_reg): + for icat in range(0,nr_cat): + lambdas[-1,ireg,icat,0] = 0.0 # Set anthropogenic component to 0 + odata[:] = lambdas + ofile.close() + logging.info('lambdas for ICON simulation written to the file: %s' % self.lambda_file) + + #write bg_lambdas + ofile = Dataset(self.bg_lambda_file, mode='w') + nr_ens = self.forecast_nmembers + 1 if {cfg.CTDAS_propagate_bg} else 0 + nr_dir = {cfg.CTDAS_nboundaries} + nr_tracer = 1 + oens = ofile.createDimension('ens', nr_ens) + odir = ofile.createDimension('reg', nr_dir) + # otracer = ofile.createDimension('tracer', nr_tracer) + odata = ofile.createVariable('lambda', np.float32, ('ens','reg'),fill_value=-999.99) #,'tracer' + lambdas = np.empty(shape=(nr_ens,nr_dir)) #,nr_tracer + for m in range(0,self.forecast_nmembers): + for idir in range(0,nr_dir): + if statevector.isOptimized: + lambdas[m,idir] = members[0].param_values[-self.n_bg_params + idir] + else: + lambdas[m,idir] = members[m].param_values[-self.n_bg_params + idir] + if {cfg.CTDAS_propagate_bg}: + for idir in range(0,nr_dir): + lambdas[-1,idir] = lambdas[-2,idir] # Populate BG lambdas with the last member (which, for an optimized run, is the optimized member) + odata[:] = lambdas + ofile.close() + logging.info('bg_lambdas for ICON simulation written to the file: %s' % self.bg_lambda_file) + + + def validate_input(self): + """ Make sure that data needed for the ObservationOperator (such as observation input lists, or parameter files) + are present. + """ + def save_data(self): + """ Write the data that is needed for a restart or recovery of the Observation Operator to the save directory """ + + def run(self,samples,statevector,lag): + """ + This Randomizer will take the original observation data in the Obs object, and simply copy each mean value. Next, the mean + value will be perturbed by a random normal number drawn from a specified uncertainty of +/- 2 ppm + """ + + import da.tools.io4 as io + import numpy as np + + #select runscript for ICON-ART-OEM simulation: + time = dt.datetime.strptime(self.dacycle['time.sample.stamp'][0:10], "%Y%m%d%H") + job_timestr = f'{{time.strftime("%Y%m%d")}}' + folder_timestr = f'{{time.strftime("%Y%m%d%H")}}_{{(time+dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime("%Y%m%d%H")}}' + if statevector.isOptimized: + runscript = os.path.join(self.simulationdir,folder_timestr,'icon','run','{ (cfg.case_path / cfg.icon_runjob_filename).stem }' + '_%s_opt2.job'%(self.dacycle['time.sample.stamp'][0:8])) + self.outfolder = os.path.join('{cfg.case_root / "global_outputs"}', f"opt2_{{job_timestr}}") + finalfile = os.path.join(self.outfolder, f"ICON-ART-OEM-INIT_{{(time + dt.timedelta(seconds={cfg.CTDAS_restart_init_time}) + dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime('%Y-%m-%dT%H:%M:%S')}}.000.nc") + else: + if lag==0: + runscript = os.path.join(self.simulationdir,folder_timestr,'icon','run','{ (cfg.case_path / cfg.icon_runjob_filename).stem }' + '_%s_opt1.job'%(self.dacycle['time.sample.stamp'][0:8])) + self.outfolder = os.path.join('{cfg.case_root / "global_outputs"}', f"opt1_{{job_timestr}}") + finalfile = os.path.join(self.outfolder, f"ICON-ART-OEM-INIT_{{(time + dt.timedelta(seconds={cfg.CTDAS_restart_init_time}) + dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime('%Y-%m-%dT%H:%M:%S')}}.000.nc") + else: + runscript = os.path.join(self.simulationdir,folder_timestr,'icon','run','{ (cfg.case_path / cfg.icon_runjob_filename).stem }' + '_%s_prior.job'%(self.dacycle['time.sample.stamp'][0:8])) + self.outfolder = os.path.join('{cfg.case_root / "global_outputs"}', f"prior_{{job_timestr}}") + finalfile = os.path.join(self.outfolder, f"ICON-ART-OEM-INIT_{{(time + dt.timedelta(seconds={cfg.CTDAS_restart_init_time}) + dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime('%Y-%m-%dT%H:%M:%S')}}.000.nc") + + while not (os.path.exists(finalfile)): + logging.info('runscript name: %s'%(runscript)) + start_icon(runscript) + logging.info('ICON done!') + + def sample(self, samples, statevector, lag): + for j,sample in enumerate(samples): + sample_type = sample.get_samples_type() + logging.info(f"Want to do...{{sample_type}} extraction") + if sample_type == "column": + logging.info("Starting _launch_icon_column_sampling") + + warning_msg = "JM: Be careful! The current column sampling " + \ + "method is designed for a specific case of study. " + \ + "Please evaluate if the satellite product is suitable " + \ + "with an appropriate model spatial resolution!" + logging.warning( warning_msg ) + + self._launch_icon_column_sampling(j,sample) + + logging.info("Finished _launch_icon_column_sampling") + + elif sample_type == "insitu": + self.ICOS_sampling(j,sample, statevector, lag) + + else: + logging.error("Unknown sample type: %s", + sample.get_samples_type()) + + + def ICOS_sampling(self,j,sample, statevector, lag): + + if statevector.isOptimized: + prefix = 'opt2_' + else: + if lag==0: + prefix = 'prior_' + else: + prefix = 'opt1_' + + # Create a flask output file to hold simulated values for later reading + f = io.CT_CDF(self.simulated_file[j], method='create') + logging.debug('Creating new simulated observation file in ObservationOperator (%s)' % self.simulated_file) + + dimid = f.createDimension('obs_num', size=None) + dimid = ('obs_num',) + savedict = io.std_savedict.copy() + savedict['name'] = "obs_num" + savedict['dtype'] = "int" + savedict['long_name'] = "Unique_Dataset_observation_index_number" + savedict['units'] = "" + savedict['dims'] = dimid + savedict['comment'] = "Unique index number within this dataset ranging from 0 to UNLIMITED." + f.add_data(savedict,nsets=0) + + dimmember = f.createDimension('nmembers', size=self.forecast_nmembers) + dimmember = ('nmembers',) + savedict = io.std_savedict.copy() + savedict['name'] = "flask" + savedict['dtype'] = "float" + savedict['long_name'] = "mole_fraction_of_trace_gas_in_air" + savedict['units'] = "mol tracer (mol air)^-1" + savedict['dims'] = dimid + dimmember + savedict['comment'] = "Simulated model value created by RandomizerObservationOperator" + f.add_data(savedict,nsets=0) + + # Open file with x,y,z,t of model samples that need to be sampled + f_in = io.ct_read(self.dacycle['ObsOperator.inputfile.'+sample.get_samples_type()],method='read') + + # Get simulated values and ID + + ids = f_in.get_variable('obs_num') + obs = f_in.get_variable('observed') + mdm = f_in.get_variable('modeldatamismatch') + + #msteiner: + date_components = f_in.get_variable('date_components') + evn = f_in.get_variable('evn') + fromfile = f_in.get_variable('fromfile') + #--------- + + # Loop over observations, add random white noise, and write to file + +########################################################### + os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE" + + molar_mass = {{'ch4' : 16.04e-3, + 'co2' : 44.01e-3, + 'da' : 28.97e-3 + }} + units_factor = {{'ch4' : 1.e9, #ppb for ch4 + 'co2' : 1.e6, #ppm for co2 + }} + + import sys + sys.path.insert(1, "{cfg.case_path / 'ICON'}") + from Michael_sampler import ICON_sampler + logging.info("Starting ICON sampling") + # obs_lon, idx = np.unique(f_in.get_variable("longitude"), return_index=True) + # obs_lat = f_in.get_variable("latitude")[idx] + # inlet_height_agl = f_in.get_variable("inlet_height_over_base")[idx] + # base_height_msl = f_in.get_variable("base_height_over_sea_level")[idx] + # sampling_strategy = f_in.get_variable("sampling_strategy") + # sampling_strategy = np.asarray([''.join(sampling_strategy[i].astype(str)) for i in range(sampling_strategy.shape[0])]) + # sampling_strategy_unique = sampling_strategy[idx] + # unique_site_names = f_in.get_variable('evn') + # unique_site_names = np.asarray([''.join(unique_site_names[i].astype(str)) for i in range(unique_site_names.shape[0])]) + # unique_site_names = unique_site_names[idx] + time = dt.datetime.strptime(self.dacycle['time.sample.stamp'][0:10], "%Y%m%d%H") + job_timestr = f'{{time.strftime("%Y%m%d")}}' + starttime = f'{{time.strftime("%Y-%m-%d %H:%M:%S")}}' + endtime = f"{{(time + dt.timedelta(seconds={cfg.CTDAS_restart_init_time}) + dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime('%Y-%m-%d %H:%M:%S')}}" + obs_dir = os.path.join(self.simulationdir,"global_inputs","ICOS") + nneighb = 5 + meta = {meta_dict} + meta["u"] = {{}} + meta["v"] = {{}} + meta["temp"] = {{}} + meta["qv"] = {{}} + outfile = os.path.join(self.simulationdir,"global_outputs","extracted_ICOS",'%s%s.nc'%(prefix,job_timestr)) + # files = os.path.join(self.simulationdir,"global_outputs",'%s%s'%(prefix,job_timestr), 'ICON-ART-UNSTR*.nc') + # logging.info(f"ICON files to sample: {{files}}") + mountain_stations = {cfg.CTDAS["obs"]["ICOS"]["mountain_stations"]} + mdm_dictionary = { evaluate_dict({k: v for d in cfg.CTDAS["obs"]["ICOS"]["mdm"] for k, v in d.items()}, "c_offset", cfg.CTDAS_obs_ICOS_c_offset) }# Based on the simulated standard deviation of the signal (without background) over a full year. + infolder = self.outfolder + logging.info(f"Running ICON sampler with input folder {{infolder}}") + logging.info(f"Running ICON sampler with starttime {{starttime}} and endtime {{endtime}} and obsdir {{obs_dir}} and nneighb {{nneighb}} and meta {{meta}} and outfile {{outfile}}") + ICON_sampler(infolder, "ICON-ART-UNSTR", "{cfg.input_files_scratch_dynamics_grid_filename}", starttime, endtime, obs_dir, nneighb, meta, outfile, mountain_stations=mountain_stations) + logging.info("Finished ICON sampling") + logging.info(f"Written to output file {{outfile}}") + + simulated_values = np.zeros((len(obs),self.forecast_nmembers)) + f1 = io.ct_read(outfile,method='read') + TR_A_ENS = (molar_mass['da']/molar_mass[self.tracer])*units_factor[self.tracer]*np.array(f1.get_variable('TR'+self.tracer.upper()+'_A_ENS') + f1.get_variable('biosource') - f1.get_variable('biosink')) #float CH4_A_ENS(ens, sites, time) 1 --> ppb + qv = np.array(f1.get_variable('qv')) #float qv(sites, time) + site_names = np.array(f1.get_variable('site_name')) + obs_times = np.array(f1.get_variable('time')) + + # wet --> dry mmr + for iiens in np.arange(TR_A_ENS.shape[0]): + TR_A_ENS[iiens,...] = TR_A_ENS[iiens,...]/(1.-qv[...]) + + + #LOOP OVER OBS: + for iobs in np.arange(len(obs)): + station_name = fromfile[iobs][fromfile[iobs]!=b''].tostring().decode('utf-8') + if station_name not in mdm_dictionary.keys(): continue # Skip stations that aren't considered + print('DEBUG iobs: ',iobs,flush=True) + obs_date = dt.datetime(*date_components[iobs,:]) + print('DEBUG obs_date: ',obs_date,flush=True) + obs_date = obs_date.replace(minute=0,second=0) + print('DEBUG modified obs_date: ',obs_date,flush=True) + + # LOOP OVER EXTRACTED DATA TIMES + for itime in np.arange(TR_A_ENS.shape[2]): + otime = dt.datetime.strptime(obs_times[itime],'%Y-%m-%dT%H') +# print('DEBUG checking otime: ',otime,flush=True) + if not (obs_date == otime): continue + print('DEBUG found otime: ',otime,flush=True) + + # find index (or the difference) of hour at 12 UTC and 0 UTC + if station_name in mountain_stations: + print('DEBUG station',station_name, 'is a mountain site',flush=True) + delta_index = obs_date.hour + print('DEBUG delta_index: ',delta_index,flush=True) + else: + print('DEBUG station',station_name, 'is NOT a mountain site',flush=True) + delta_index = obs_date.hour - 12 + print('DEBUG delta_index: ',delta_index,flush=True) + + + # LOOP OVER STATIONS + for isite in np.arange(TR_A_ENS.shape[1]): + site_name = site_names[isite] +# print('DEBUG looking through sampled stations. Checking site_name: ',site_name,flush=True) + if (site_name==station_name): + print('DEBUG looking through sampled stations. Found site_name: ',site_name,flush=True) + for iens in np.arange(self.forecast_nmembers): + if station_name in mountain_stations: + simulated_values[iobs,iens] = np.nanmean(TR_A_ENS[iens,isite,itime-delta_index:itime-delta_index+7]) + else: + simulated_values[iobs,iens] = np.nanmean(TR_A_ENS[iens,isite,itime-delta_index:itime-delta_index+5]) + if iens==50: + print('Added model value for member 0 of %.2f for iobs %i at %s at %s with a delta idx of %i'%(simulated_values[iobs,0],iobs,site_name,obs_date,delta_index)) + print('Added model value for member 50 of %.2f for iobs %i at %s at %s with a delta idx of %i'%(simulated_values[iobs,50],iobs,site_name,obs_date,delta_index)) + break + else: + continue + break +########################################################### + + for i in range(0,len(obs)): + f.variables['obs_num'][i] = ids[i] + f.variables['flask'][i,:] = simulated_values[i] + + f.close() + f_in.close() + + # Report success and exit + logging.info('ICOS ObservationOperator finished successfully, output file written (%s)' % self.simulated_file) + + + def _launch_icon_column_sampling(self, j, sample): + """Sample ICON output at coordinates of column observations.""" + """Here we can implement Erik's CDO technique.""" + + # To be continued.... + # run_dir = self.settings["dir.icon_sim"] # Erik: run_dir here means: output dir. + # run_dir = '/scratch/snx3000/ekoene/processing-chain/work/VPRM_EU_ERA5_22/XCO2_test' # This should, eventually, be determined automatically from however the folder structure is made! + run_dir = os.path.join(self.outfolder) + logging.info(f"Directory that satellite data will be taken from: {{run_dir}}") + + sampling_coords_file = self.dacycle['ObsOperator.inputfile.'+sample.get_samples_type()] + logging.info(f"Sampling coords file: {{sampling_coords_file}}") + + # Reconstruct self.simulated_file[i] + out_file = self.simulated_file[j] + nprocs = 1 + Nobs = len(sample.datalist) + if Nobs == 0: + logging.info("No observations, skipping sampling") + return + + # Make run command + command_ = " " # Erik: this would have to look different for us + # Submit processes + procs = list() + for nproc in range(nprocs): + cmd = " ".join([ + command_, + "python ./da/tools/icon/icon_sampler.py", + "--nproc %d" % nproc, + "--nprocs %d" % nprocs, + "--sampling_coords_file %s" % sampling_coords_file, + "--run_dir %s" % run_dir, + "--iconout_prefix %s" % self.settings["output_prefix"], + "--icon_grid %s" % self.settings["icon_grid_path"], + "--nmembers %d" % int(self.dacycle["da.optimizer.nmembers"]), + "--tracer_optim %s" % self.settings["tracer_optim"], + "--outfile_prefix %s" % out_file, + "--footprint_samples_dim %d" % int(self.settings['obs.column.footprint_samples_dim']) + ]) + + procs.append(subprocess.Popen(cmd.split(), + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT)) + + + logging.info("Started %d sampling process(es).", nprocs) + logging.debug("Command of last process: %s", cmd) + + # Wait for all processes to finish + for n in range(nprocs): + procs[n].wait() + + # Check for errors + retcodes = [] + for n in range(nprocs): + logging.debug("Checking errors in process %d", n) + retcodes.append(utilities.check_out_err(procs[n])) + + if any([r != 0 for r in retcodes]): + raise RuntimeError("At least one sampling process " + \ + "finished with errors.") + + logging.info("All sampling processes finished.") + + # Join output files + logging.info("Joining output files.") + + # Finishing msg + logging.info("ICON column output sampled.") + logging.info("If samples object carried observations, output " + \ + "file written to %s", self.simulated_file) + + +######################################################################################## + def run_forecast_model(self,samples,statevector,lag,dacycle): + self.startdate = dacycle['time.sample.start'] + self.prepare_run(samples) + self.make_lambdas(statevector,lag) + self.validate_input() + self.run(samples,statevector,lag) + self.sample(samples,statevector,lag) + self.save_data() + +################### End Class ObservationOperator ################### + +class RandomizerObservationOperator(ObservationOperator): + """ This class holds methods and variables that are needed to use a random number generated as substitute + for a true observation operator. It takes observations and returns values for each obs, with a specified + amount of white noise added + """ + +def wait_for_job(job_id): + """Wait for a job to complete.""" + if not job_id: + return False + + while True: + result = subprocess.run(f"sacct -j {{job_id}} --format=State --noheader", shell=True, capture_output=True, text=True) + state = result.stdout.strip() + + if state: + if any(s in state for s in ["COMPLETED", "FAILED", "CANCELLED", "TIMEOUT"]): + logging.info(f"Job {{job_id}} finished with state: {{state}}") + return state == "COMPLETED", state + + time.sleep(10) + +def submit_job(command): + """Submit a job and return the job ID.""" + logging.info(f"Running: {{command}}") + result = subprocess.run(command, shell=True, capture_output=True, text=True, check=False) + match = re.search(r"Submitted batch job (\d+)", result.stdout) + + if match: + return match.group(1) + + logging.error("Failed to get job ID from sbatch output.") + return None + +def start_icon(runscript, max_retries=3): + retries = 0 + while retries <= max_retries: + command = f"uenv run icon-wcp -- sbatch {{runscript}} --wait" + logging.info(f"Running ICON case job with {{command}}") + job_id = submit_job(command) + logging.info(f"Running job ID {{job_id}}") + + completed, state = wait_for_job(job_id) + + if completed: + return True + + if state in ["FAILED", "CANCELLED", "TIMEOUT"]: + retries += 1 + logging.warning(f"Job failed with state {{state}}. Retrying {{retries}}/{{max_retries}}...") + else: + break + + logging.error("ICON job failed after maximum retries.") + return False + +if __name__ == "__main__": + pass \ No newline at end of file diff --git a/cases/icon-art-CTDAS/ctdas_patch/optimizer_baseclass_icos_cities.py b/cases/icon-art-CTDAS/ctdas_patch/optimizer_baseclass_icos_cities.py new file mode 100644 index 00000000..7623bfc3 --- /dev/null +++ b/cases/icon-art-CTDAS/ctdas_patch/optimizer_baseclass_icos_cities.py @@ -0,0 +1,661 @@ +"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +updates of the code. See also: http://www.carbontracker.eu. + +This program is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free Software Foundation, +version 3. This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this +program. If not, see .""" +#!/usr/bin/env python +# optimizer.py + +""" +.. module:: optimizer +.. moduleauthor:: Wouter Peters + +Revision History: +File created on 28 Jul 2010. + +""" + +import logging +import numpy as np +import numpy.linalg as la +import da.tools.io4 as io +import csv +import xarray as xr +from sklearn.metrics.pairwise import haversine_distances + +identifier = 'Optimizer baseclass' +version = '0.0' + +################### Begin Class Optimizer ################### + +class Optimizer(object): + """ + This creates an instance of an optimization object. It handles the minimum least squares optimization + of the state vector given a set of sample objects. Two routines will be implemented: one where the optimization + is sequential and one where it is the equivalent matrix solution. The choice can be made based on considerations of speed + and efficiency. + """ + + def __init__(self): + self.ID = identifier + self.version = version + + logging.info('Optimizer object initialized: %s' % self.ID) + + def setup(self, dims): + self.nlag = dims[0] + self.nmembers = dims[1] + self.nparams = dims[2] + self.nobs = dims[3] + self.create_matrices() + + def create_matrices(self): + """ Create Matrix space needed in optimization routine """ + + # mean state [X] + self.x = np.zeros((self.nlag * self.nparams,), float) + # deviations from mean state [X'] + self.X_prime = np.zeros((self.nlag * self.nparams, self.nmembers,), float) + # mean state, transported to observation space [ H(X) ] + self.Hx = np.zeros((self.nobs,), float) + # deviations from mean state, transported to observation space [ H(X') ] + self.HX_prime = np.zeros((self.nobs, self.nmembers), float) + # observations + self.obs = np.zeros((self.nobs,), float) + # observation ids + self.obs_ids = np.zeros((self.nobs,), float) + # covariance of observations + # Total covariance of fluxes and obs in units of obs [H P H^t + R] + if self.algorithm == 'Serial': + self.R = np.zeros((self.nobs,), float) + self.HPHR = np.zeros((self.nobs,), float) + else: + self.R = np.zeros((self.nobs, self.nobs,), float) + self.HPHR = np.zeros((self.nobs, self.nobs,), float) + # localization of obs + self.may_localize = np.zeros(self.nobs, bool) + # rejection of obs + self.may_reject = np.zeros(self.nobs, bool) + # flags of obs + self.flags = np.zeros(self.nobs, int) + # species type + self.species = np.zeros(self.nobs, str) + # species type + self.sitecode = np.zeros(self.nobs, str) + # rejection_threshold + self.rejection_threshold = np.zeros(self.nobs, float) + # lat/lon + self.latitude = np.zeros(self.nobs, float) + self.longitude = np.zeros(self.nobs, float) + + # species mask + self.speciesmask = {{}} + + # Kalman Gain matrix + self.KG = np.zeros((self.nlag * self.nparams,), float) + + #msteiner: + self.fromfile = np.zeros(self.nobs, str) + + def state_to_matrix(self, statevector): + allsites = [] # collect all obs for n=1,..,nlag + allobs = [] # collect all obs for n=1,..,nlag + allmdm = [] # collect all mdm for n=1,..,nlag + allids = [] # collect all model samples for n=1,..,nlag + allreject = [] # collect all model samples for n=1,..,nlag + alllocalize = [] # collect all model samples for n=1,..,nlag + allflags = [] # collect all model samples for n=1,..,nlag + allspecies = [] # collect all model samples for n=1,..,nlag + allsimulated = [] # collect all members model samples for n=1,..,nlag + allrej_thres = [] # collect all rejection_thresholds, will be the same for all samples of same source + alllats = [] # collect all latitudes for n=1,..,nlag + alllons = [] # collect all longitudes for n=1,..,nlag + #msteiner: + allevns = [] # collect all evns for finding loc_coeffs in localize() + allfromfiles = [] # collect all evns for finding loc_coeffs in localize() + + for n in range(self.nlag): + samples = statevector.obs_to_assimilate[n] + members = statevector.ensemble_members[n] + self.x[n * self.nparams:(n + 1) * self.nparams] = members[0].param_values + self.X_prime[n * self.nparams:(n + 1) * self.nparams, :] = np.transpose(np.array([m.param_values for m in members])) + + # Add observation data for all sample objects + if samples != None: + if type(samples) != list: samples = [samples] + for m in range(len(samples)): + sample = samples[m] + logging.debug('Lag %i, sample %i: rejection_threshold = %i, nobs = %i' %(n, m, sample.rejection_threshold, sample.getlength())) + logging.info('Lag %i, sample %i: rejection_threshold = %i, nobs = %i' %(n, m, sample.rejection_threshold, sample.getlength())) + logging.info(f'{{dir(sample)}}') + alllats.extend(sample.getvalues('lat')) + alllons.extend(sample.getvalues('lon')) + allrej_thres.extend([sample.rejection_threshold] * sample.getlength()) + allreject.extend(sample.getvalues('may_reject')) + alllocalize.extend(sample.getvalues('may_localize')) + allflags.extend(sample.getvalues('flag')) + allspecies.extend(sample.getvalues('species')) + allobs.extend(sample.getvalues('obs')) + allsites.extend(sample.getvalues('code')) + allmdm.extend(sample.getvalues('mdm')) + allids.extend(sample.getvalues('id')) + #msteiner: + # if sample.get_samples_type() == 'insitu': + try: + allevns.extend(sample.getvalues('evn')) + allfromfiles.extend(sample.getvalues('fromfile')) + except: + logging.debug(f"Number of copies: {{len(sample.getvalues('lat'))}}") + allevns.extend(['column']*len(sample.getvalues('lat'))) + allfromfiles.extend(['column']*len(sample.getvalues('lat'))) + simulatedensemble = sample.getvalues('simulated') + for s in range(simulatedensemble.shape[0]): + allsimulated.append(simulatedensemble[s]) + + self.latitude[:] = np.array(alllats) + self.longitude[:] = np.array(alllons) + self.rejection_threshold[:] = np.array(allrej_thres) + self.obs[:] = np.array(allobs) + self.obs_ids[:] = np.array(allids) + self.HX_prime[:, :] = np.array(allsimulated) + self.Hx[:] = self.HX_prime[:, 0] + + self.may_reject[:] = np.array(allreject) + self.may_localize[:] = np.array(alllocalize) + self.flags[:] = np.array(allflags) + self.species[:] = np.array(allspecies) + self.sitecode = allsites + + #msteiner: + # self.evn = allevns + self.fromfile = allfromfiles + + # ~~~~~~~~ NEW SINCE OCO2, but generally valid: Setup localization (distance between observations and regions) + OBSERVATIONS_IN_RADIANS_LATLON = np.deg2rad(np.column_stack([self.latitude,self.longitude])) + grid = xr.open_dataset('/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc') + grid_latitudes = grid.lat_cell_centre.values + grid_longitudes = grid.lon_cell_centre.values + REGIONS_IN_RADIANS_LATLON = np.column_stack([grid_latitudes,grid_longitudes]) + Distances = haversine_distances(OBSERVATIONS_IN_RADIANS_LATLON,REGIONS_IN_RADIANS_LATLON) * 6371000/1000 # distance to km s + logging.debug(Distances) + self.coeff_matrix = np.exp(-Distances/{cfg.CTDAS_obs_localization}) # Footprint size for a station + self.name_array = np.arange(OBSERVATIONS_IN_RADIANS_LATLON.shape[0]) # These should be 'names' but my pixels don't have names, of course! + + self.X_prime = self.X_prime - self.x[:, np.newaxis] # make into a deviation matrix + self.HX_prime = self.HX_prime - self.Hx[:, np.newaxis] # make a deviation matrix + + if self.algorithm == 'Serial': + for i, mdm in enumerate(allmdm): + self.R[i] = mdm ** 2 + else: + for i, mdm in enumerate(allmdm): + self.R[i, i] = mdm ** 2 + + def matrix_to_state(self, statevector): + for n in range(self.nlag): + members = statevector.ensemble_members[n] + for m, mem in enumerate(members): + members[m].param_values[:] = self.X_prime[n * self.nparams:(n + 1) * self.nparams, m] + self.x[n * self.nparams:(n + 1) * self.nparams] + + #msteiner: + statevector.isOptimized = True + #--------- + + logging.debug('Returning optimized data to the StateVector, setting "StateVector.isOptimized = True" ') + + def write_diagnostics(self, filename, type): + """ + Open a NetCDF file and write diagnostic output from optimization process: + + - calculated residuals + - model-data mismatches + - HPH^T + - prior ensemble of samples + - posterior ensemble of samples + - prior ensemble of fluxes + - posterior ensemble of fluxes + + The type designation refers to the writing of prior or posterior data and is used in naming the variables" + """ + + # Open or create file + + if type == 'prior': + f = io.CT_CDF(filename, method='create') + logging.debug('Creating new diagnostics file for optimizer (%s)' % filename) + elif type == 'optimized': + f = io.CT_CDF(filename, method='write') + logging.debug('Opening existing diagnostics file for optimizer (%s)' % filename) + + # Add dimensions + + dimparams = f.add_params_dim(self.nparams) + dimmembers = f.add_members_dim(self.nmembers) + dimlag = f.add_lag_dim(self.nlag, unlimited=False) + dimobs = f.add_obs_dim(self.nobs) + dimstate = f.add_dim('nstate', self.nparams * self.nlag) + dim200char = f.add_dim('string_of200chars', 200) + + # Add data, first the ones that are written both before and after the optimization + + savedict = io.std_savedict.copy() + savedict['name'] = "statevectormean_%s" % type + savedict['long_name'] = "full_statevector_mean_%s" % type + savedict['units'] = "unitless" + savedict['dims'] = dimstate + savedict['values'] = self.x.tolist() + savedict['comment'] = 'Full %s state vector mean ' % type + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "statevectordeviations_%s" % type + savedict['long_name'] = "full_statevector_deviations_%s" % type + savedict['units'] = "unitless" + savedict['dims'] = dimstate + dimmembers + savedict['values'] = self.X_prime.tolist() + savedict['comment'] = 'Full state vector %s deviations as resulting from the optimizer' % type + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "modelsamplesmean_%s" % type + savedict['long_name'] = "modelsamplesforecastmean_%s" % type + savedict['units'] = "mol mol-1" + savedict['dims'] = dimobs + savedict['values'] = self.Hx.tolist() + savedict['comment'] = '%s mean mole fractions based on %s state vector' % (type, type) + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "modelsamplesdeviations_%s" % type + savedict['long_name'] = "modelsamplesforecastdeviations_%s" % type + savedict['units'] = "mol mol-1" + savedict['dims'] = dimobs + dimmembers + savedict['values'] = self.HX_prime.tolist() + savedict['comment'] = '%s mole fraction deviations based on %s state vector' % (type, type) + f.add_data(savedict) + + # Continue with prior only data + + if type == 'prior': + + savedict = io.std_savedict.copy() + savedict['name'] = "sitecode" + savedict['long_name'] = "site code propagated from observation file" + savedict['dtype'] = "char" + savedict['dims'] = dimobs + dim200char + savedict['values'] = self.sitecode + savedict['missing_value'] = '!' + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "observed" + savedict['long_name'] = "observedvalues" + savedict['units'] = "mol mol-1" + savedict['dims'] = dimobs + savedict['values'] = self.obs.tolist() + savedict['comment'] = 'Observations used in optimization' + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "obspack_num" + savedict['dtype'] = "int64" + savedict['long_name'] = "Unique_ObsPack_observation_number" + savedict['units'] = "" + savedict['dims'] = dimobs + savedict['values'] = self.obs_ids.tolist() + savedict['comment'] = 'Unique observation number across the entire ObsPack distribution' + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "modeldatamismatchvariance" + savedict['long_name'] = "modeldatamismatch variance" + savedict['units'] = "[mol mol-1]^2" + if self.algorithm == 'Serial': + savedict['dims'] = dimobs + else: savedict['dims'] = dimobs + dimobs + savedict['values'] = self.R.tolist() + savedict['comment'] = 'Variance of mole fractions resulting from model-data mismatch' + f.add_data(savedict) + + # Continue with posterior only data + + elif type == 'optimized': + + savedict = io.std_savedict.copy() + savedict['name'] = "totalmolefractionvariance" + savedict['long_name'] = "totalmolefractionvariance" + savedict['units'] = "[mol mol-1]^2" + if self.algorithm == 'Serial': + savedict['dims'] = dimobs + else: savedict['dims'] = dimobs + dimobs + savedict['values'] = self.HPHR.tolist() + savedict['comment'] = 'Variance of mole fractions resulting from prior state and model-data mismatch' + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "flag" + savedict['long_name'] = "flag_for_obs_model" + savedict['units'] = "None" + savedict['dims'] = dimobs + savedict['values'] = self.flags.tolist() + savedict['comment'] = 'Flag (0/1/2/99) for observation value, 0 means okay, 1 means QC error, 2 means rejected, 99 means not sampled' + f.add_data(savedict) + + #savedict = io.std_savedict.copy() + #savedict['name'] = "kalmangainmatrix" + #savedict['long_name'] = "kalmangainmatrix" + #savedict['units'] = "unitless molefraction-1" + #savedict['dims'] = dimstate + dimobs + #savedict['values'] = self.KG.tolist() + #savedict['comment'] = 'Kalman gain matrix of all obs and state vector elements' + #dummy = f.add_data(savedict) + + f.close() + logging.debug('Diagnostics file closed') + + + def serial_minimum_least_squares(self,n_bg_params=0): + """ Make minimum least squares solution by looping over obs""" + + # Calculate prior value cost function (observation part) + res_prior = np.abs(self.obs-self.Hx) + select = (res_prior < 1E15).nonzero()[0] + J_prior = res_prior.take(select,axis=0)**2/self.R.take(select,axis=0) + res_prior = np.mean(res_prior) + for n in range(self.nobs): + + # Screen for flagged observations (for instance site not found, or no sample written from model) + + if self.flags[n] != 0: + logging.debug('Skipping observation (%s,%i) because of flag value %d' % (self.sitecode[n], self.obs_ids[n], self.flags[n])) + logging.info('Skipping observation (%s,%i) because of flag value %d' % (self.sitecode[n], self.obs_ids[n], self.flags[n])) + continue + + # Screen for outliers greather than 3x model-data mismatch, only apply if obs may be rejected + + res = self.obs[n] - self.Hx[n] + + if self.may_reject[n]: + threshold = self.rejection_threshold[n] * np.sqrt(self.R[n]) + if np.abs(res) > threshold: + logging.debug('Rejecting observation (%s,%i) because residual (%f) exceeds threshold (%f)' % (self.sitecode[n], self.obs_ids[n], res, threshold)) + logging.info('Rejecting observation (%s,%i) because residual (%f) exceeds threshold (%f)' % (self.sitecode[n], self.obs_ids[n], res, threshold)) + self.flags[n] = 2 + continue + + logging.debug('Proceeding to assimilate observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) + logging.info('Proceeding to assimilate observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) + + PHt = 1. / (self.nmembers - 1) * np.dot(self.X_prime, self.HX_prime[n, :]) + self.HPHR[n] = 1. / (self.nmembers - 1) * (self.HX_prime[n, :] * self.HX_prime[n, :]).sum() + self.R[n] + self.KG[:] = PHt / self.HPHR[n] + + if self.may_localize[n]: + logging.debug('Trying to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) + logging.info('Trying to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) + self.localize(n,n_bg_params) + else: + logging.debug('Not allowed to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) +# logging.info('Not allowed to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) + + alpha = np.double(1.0) / (np.double(1.0) + np.sqrt((self.R[n]) / self.HPHR[n])) + + self.x[:] = self.x + self.KG[:] * res + + for r in range(self.nmembers): +# logging.info('X_prime before: %s'%(str(self.X_prime[:, r]))) + self.X_prime[:, r] = self.X_prime[:, r] - alpha * self.KG[:] * (self.HX_prime[n, r]) +# logging.info('X_prime after: %s'%(str(self.X_prime[:, r]))) +# logging.info('======================================') + del r + + # update samples to account for update of statevector based on observation n + HXprime_n = self.HX_prime[n,:].copy() + res = self.obs[n] - self.Hx[n] + fac = 1.0 / (self.nmembers - 1) * np.sum(HXprime_n[np.newaxis,:] * self.HX_prime, axis=1) / self.HPHR[n] + self.Hx = self.Hx + fac*res + self.HX_prime = self.HX_prime - alpha* fac[:,np.newaxis]*HXprime_n + + + del n + if 'HXprime_n' in globals(): del HXprime_n + + # calculate posterior value cost function + res_post = np.abs(self.obs-self.Hx) + select = (res_post < 1E15).nonzero()[0] + J_post = res_post.take(select,axis=0)**2/self.R.take(select,axis=0) + res_post = np.mean(res_post) + + logging.info('Observation part cost function: prior = %s, posterior = %s' % (np.mean(J_prior), np.mean(J_post))) + logging.info('Mean residual: prior = %s, posterior = %s' % (res_prior, res_post)) + +#WP !!!! Very important to first do all obervations from n=1 through the end, and only then update 1,...,n. The current observation +#WP should always be updated last because it features in the loop of the adjustments !!!! +# +# for m in range(n + 1, self.nobs): +# res = self.obs[n] - self.Hx[n] +# fac = 1.0 / (self.nmembers - 1) * (self.HX_prime[n, :] * self.HX_prime[m, :]).sum() / self.HPHR[n] +# self.Hx[m] = self.Hx[m] + fac * res +# self.HX_prime[m, :] = self.HX_prime[m, :] - alpha * fac * self.HX_prime[n, :] +# +# for m in range(1, n + 1): +# res = self.obs[n] - self.Hx[n] +# fac = 1.0 / (self.nmembers - 1) * (self.HX_prime[n, :] * self.HX_prime[m, :]).sum() / self.HPHR[n] +# self.Hx[m] = self.Hx[m] + fac * res +# self.HX_prime[m, :] = self.HX_prime[m, :] - alpha * fac * self.HX_prime[n, :] + + + + def bulk_minimum_least_squares(self): + """ Make minimum least squares solution by solving matrix equations""" + + + # Create full solution, first calculate the mean of the posterior analysis + + HPH = np.dot(self.HX_prime, np.transpose(self.HX_prime)) / (self.nmembers - 1) # HPH = 1/N * HX' * (HX')^T + self.HPHR[:, :] = HPH + self.R # HPHR = HPH + R + HPb = np.dot(self.X_prime, np.transpose(self.HX_prime)) / (self.nmembers - 1) # HP = 1/N X' * (HX')^T + self.KG[:, :] = np.dot(HPb, la.inv(self.HPHR)) # K = HP/(HPH+R) + + for n in range(self.nobs): + self.localize(n) + + self.x[:] = self.x + np.dot(self.KG, self.obs - self.Hx) # xa = xp + K (y-Hx) + + # And next make the updated ensemble deviations. Note that we calculate P by using the full equation (10) at once, and + # not in a serial update fashion as described in Whitaker and Hamill. + # For the current problem with limited N_obs this is easier, or at least more straightforward to do. + + I = np.identity(self.nlag * self.nparams) + sHPHR = la.cholesky(self.HPHR) # square root of HPH+R + part1 = np.dot(HPb, np.transpose(la.inv(sHPHR))) # HP(sqrt(HPH+R))^-1 + part2 = la.inv(sHPHR + np.sqrt(self.R)) # (sqrt(HPH+R)+sqrt(R))^-1 + Kw = np.dot(part1, part2) # K~ + self.X_prime[:, :] = np.dot(I, self.X_prime) - np.dot(Kw, self.HX_prime) # HX' = I - K~ * HX' + + + # Now do the adjustments of the modeled mole fractions using the linearized ensemble. These are not strictly needed but can be used + # for diagnosis. + + part3 = np.dot(HPH, np.transpose(la.inv(sHPHR))) # HPH(sqrt(HPH+R))^-1 + Kw = np.dot(part3, part2) # K~ + self.Hx[:] = self.Hx + np.dot(np.dot(HPH, la.inv(self.HPHR)), self.obs - self.Hx) # Hx = Hx+ HPH/HPH+R (y-Hx) + self.HX_prime[:, :] = self.HX_prime - np.dot(Kw, self.HX_prime) # HX' = HX'- K~ * HX' + + logging.info('Minimum Least Squares solution was calculated, returning') + + + def set_localization(self, loctype='None'): + """ determine which localization to use """ + + if loctype == 'CT2007': + self.localization = True + self.localizetype = 'CT2007' + #T-test values for two-tailed student's T-test using 95% confidence interval for some options of nmembers + if self.nmembers == 50: + self.tvalue = 2.0086 + elif self.nmembers == 100: + self.tvalue = 1.9840 + elif self.nmembers == 150: + self.tvalue = 1.97591 + elif self.nmembers == 192: + self.tvalue = 1.9724 + elif self.nmembers == 200: + self.tvalue = 1.9719 + else: self.tvalue = 0 + elif loctype == 'spatial': + logging.info('Spatial localization selected') + self.localization = True + self.localizetype = 'spatial' + else: + self.localization = False + self.localizetype = 'None' + + logging.info("Current localization option is set to %s" % self.localizetype) + if ((self.localization == True) and (self.localizetype == 'CT2007')): + if self.tvalue == 0: + logging.error("Critical tvalue for localization not set for %i ensemble members"%(self.nmembers)) + sys.exit(2) + else: logging.info("Used critical tvalue %0.05f is based on 95%% probability and %i ensemble members in a two-tailed student's T-test"%(self.tvalue,self.nmembers)) + + + def get_prob(self,n,i): +# def get_prob(self,obsdev,paramdev,r): + """Calculate probability from correlations""" +# corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] +# corr = np.corrcoef(obsdev,paramdev)[0,1] +# corr = np.ma.corrcoef(np.ma.masked_invalid(self.HX_prime[n, :]),np.ma.masked_invalid(self.X_prime[r, :].squeeze()))[0,1] + for r in np.arange(i,self.nlag * self.nparams)[::36]: + corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] + prob = corr / np.sqrt((1.000000001 - corr ** 2) / (self.nmembers - 2)) + if abs(prob) < self.tvalue: + self.KG[r] = 0.0 + + + def localize(self, n, n_bg_params): + skip_stations = ['Malin Head_47', + 'Hegyhatsal hatterszennyettseg-mero allomas_48', + 'Hegyhatsal hatterszennyettseg-mero allomas_82', + 'Birkenes_2', + 'Hegyhatsal hatterszennyettseg-mero allomas_115', + 'Hegyhatsal hatterszennyettseg-mero allomas_10', + 'Beromunster_12', + 'Beromunster_44', + 'Beromunster_72', + 'Beromunster_132', + 'Bilsdale_42', + 'Bilsdale_108', + 'Cabauw_27', + 'Cabauw_67', + 'Cabauw_127', + 'Gartow_30', + 'Gartow_60', + 'Gartow_132', + 'Gartow_216', + 'Hohenpeissenberg_50', + 'Hohenpeissenberg_93', + 'Hyltemossa_30', + 'Hyltemossa_70', + 'Ispara_40', + 'Ispra_70', + 'Karlsruhe_30', + 'Karlsruhe_60', + 'Karlsruhe_100', + 'Kresin u Pacova_10', + 'Kresin u Pacova_50', + 'Kresin u Pacova_125', + 'Lindenberg_2', + 'Lindenberg_10', + 'Lindenberg_40', + 'Observatoire de Haute Provence_10', + 'Observatoire de Haute Provence_50', + "Observatoire perenne de l'environnement_10", + "Observatoire perenne de l'environnement_50", + 'Ridge Hill_45', + 'Saclay_15', + 'Saclay_60', + 'Tacolneston_54', + 'Tacolneston_100', + 'Torfhaus_10', + 'Torfhaus_76', + 'Torfhaus_110', + 'Trainou_5', + 'Trainou_50', + 'Trainou_100', + ] + + """ localize the Kalman Gain matrix """ + import numpy as np + from multiprocessing import Pool + + if not self.localization: + logging.debug('Not localized observation %i' % self.obs_ids[n]) + return + if self.localizetype == 'CT2007': + +# count_localized = 0 +# for r in range(self.nlag * self.nparams): +## corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] +# corr = np.ma.corrcoef(np.ma.masked_invalid(self.HX_prime[n, :]),np.ma.masked_invalid(self.X_prime[r, :].squeeze()))[0,1] +# prob = corr / np.sqrt((1.000000001 - corr ** 2) / (self.nmembers - 2)) +# if abs(prob) < self.tvalue: +# self.KG[r] = 0.0 +# count_localized = count_localized + 1 +# logging.debug('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) +# logging.info('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) + + ############################################ + ###make the CT2007 parallel: +# args = [ (n, i) for i in range(self.nlag * self.nparams) ] + args = [ (n, i) for i in range(36) ] +# args = [ (self.HX_prime[n, :], self.X_prime[r, :].squeeze(), r ) for r in range(self.nlag * self.nparams) ] + with Pool(36) as pool: + pool.starmap(self.get_prob, args) +# count_localized = 0 +# for r in range(self.nlag * self.nparams): +# if abs(prob[r]) < self.tvalue: +# self.KG[r] = 0.0 +# count_localized = count_localized + 1 +# logging.debug('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) +# logging.info('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) + logging.info('Localized observation %i' % (self.obs_ids[n])) + ############################################ + + + elif self.localizetype == 'spatial': + n_em_cat = {max(lambdas)} + if self.fromfile[n] in skip_stations: return # Skip stations outside of the domain! + + coeff_l = np.zeros((n_em_cat*len(self.coeff_matrix[n,:]))) + for i_n_cat in range(n_em_cat): + coeff_l[i_n_cat:][::n_em_cat] = self.coeff_matrix[n,:] + + for l in range(self.nlag): + self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params] = np.multiply( self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params], coeff_l ) + + logging.info('Localized observation %i at station %s (nr. %i)'%(self.obs_ids[n],self.fromfile[n], n)) + + + def set_algorithm(self, algorithm='Serial'): + """ determine which minimum least squares algorithm to use """ + + if algorithm == 'Serial': + self.algorithm = 'Serial' + else: + self.algorithm = 'Bulk' + + logging.info("Current minimum least squares algorithm is set to %s" % self.algorithm) + +################### End Class Optimizer ################### + + + +if __name__ == "__main__": + pass diff --git a/cases/icon-art-CTDAS/ctdas_patch/pipeline_icon.py b/cases/icon-art-CTDAS/ctdas_patch/pipeline_icon.py new file mode 100644 index 00000000..c219e90d --- /dev/null +++ b/cases/icon-art-CTDAS/ctdas_patch/pipeline_icon.py @@ -0,0 +1,505 @@ +"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +updates of the code. See also: http://www.carbontracker.eu. + +This program is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free Software Foundation, +version 3. This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this +program. If not, see .""" +#!/usr/bin/env python +# pipeline.py + +""" +.. module:: pipeline +.. moduleauthor:: Wouter Peters + +Revision History: +File created on 06 Sep 2010. + +The pipeline module holds methods that execute consecutive tasks with each of the objects of the DA system. + +""" +import logging +import os +import sys +import datetime +import copy + +header = """\n\n *************************************** """ +footer = """ *************************************** \n """ + + +def ensemble_smoother_pipeline(dacycle, platform, dasystem, samples, statevector, obsoperator, optimizer): + """ The main point of entry for the pipeline """ + sys.path.append(os.getcwd()) + + samples = samples if isinstance(samples,list) else [samples] + + logging.info(header + "Initializing current cycle" + footer) + start_job(dacycle, dasystem, platform, statevector, samples, obsoperator) + + prepare_state(dacycle, statevector) + + sample_state(dacycle, samples, statevector, obsoperator) + + invert(dacycle, statevector, optimizer) + + advance(dacycle, samples, statevector, obsoperator) + + save_and_submit(dacycle, statevector) + logging.info("Cycle finished...exiting pipeline") + + + +def forward_pipeline(dacycle, platform, dasystem, samples, statevector, obsoperator): + """ The main point of entry for the pipeline """ + sys.path.append(os.getcwd()) + + samples = samples if isinstance(samples,list) else [samples] + + logging.info(header + "Initializing current cycle" + footer) + start_job(dacycle, dasystem, platform, statevector, samples, obsoperator) + + if 'forward.savestate.exceptsam' in dacycle: + sam = (dacycle['forward.savestate.exceptsam'].upper() in ["TRUE","T","YES","Y"]) + else: + sam = False + + if 'forward.savestate.dir' in dacycle: + fwddir = dacycle['forward.savestate.dir'] + else: + logging.debug("No forward.savestate.dir key found in rc-file, proceeding with self-constructed prior parameters") + fwddir = False + + if 'forward.savestate.legacy' in dacycle: + legacy = (dacycle['forward.savestate.legacy'].upper() in ["TRUE","T","YES","Y"]) + else: + legacy = False + logging.debug("No forward.savestate.legacy key found in rc-file") + + if not fwddir: + # Simply make a prior statevector using the normal method + prepare_state(dacycle, statevector)#LU tutaj zamiast tego raczej to stworzenie nowej kowariancji i ensembli bo pozostale rzeczy sa na gorze i na doel. + else: + # Read prior information from another simulation into the statevector. + # This loads the results from another assimilation experiment into the current statevector + + if sam: + filename = os.path.join(fwddir, dacycle['time.start'].strftime('%Y%m%d'), 'savestate_%s.nc'%dacycle['time.start'].strftime('%Y%m%d')) + #filename = os.path.join(fwddir, dacycle['time.start'].strftime('%Y%m%d'), 'savestate.nc') + statevector.read_from_file_exceptsam(filename, 'prior') + elif not legacy: + filename = os.path.join(fwddir, dacycle['time.start'].strftime('%Y%m%d'), 'savestate_%s.nc'%dacycle['time.start'].strftime('%Y%m%d')) + statevector.read_from_file(filename, 'prior') + else: + filename = os.path.join(fwddir, dacycle['time.start'].strftime('%Y%m%d'), 'savestate.nc') + statevector.read_from_legacy_file(filename, 'prior') + + + # We write this "prior" statevector to the restart directory, so we can later also populate it with the posterior statevector + # Note that we could achieve the same by just copying the wanted forward savestate.nc file to the restart folder of our current + # experiment, but then it would already contain a posterior field as well which we will try to write in save_and_submit. + # This could cause problems. Moreover, this method allows us to read older formatted savestate.nc files (legacy) and write them into + # the current format through the "write_to_file" method. + + savefilename = os.path.join(dacycle['dir.restart'], 'savestate_%s.nc' % dacycle['time.start'].strftime('%Y%m%d')) + statevector.write_to_file(savefilename, 'prior') + + # Now read optimized fluxes which we will actually use to propagate through the system + + if not fwddir: + # if there is no forward dir specified, we simply run forward with unoptimized prior fluxes in the statevector + logging.info("Running forward with prior savestate from: %s"%savefilename) + + else: + # Read posterior information from another simulation into the statevector. + # This loads the results from another assimilation experiment into the current statevector + + if sam: + statevector.read_from_file_exceptsam(filename, 'opt') + elif not legacy: + statevector.read_from_file(filename, 'opt') + else: + statevector.read_from_legacy_file(filename, 'opt') + + logging.info("Running forward with optimized savestate from: %s"%filename) + + # Finally, we run forward with these parameters + advance(dacycle, samples, statevector, obsoperator) + + # In save_and_submit, the posterior statevector will be added to the savestate.nc file, and it is added to the copy list. + # This way, we have both the prior and posterior data from another run copied into this assimilation, for later analysis. + + save_and_submit(dacycle, statevector) + + logging.info("Cycle finished...exiting pipeline") +#################################################################################################### + +def analysis_pipeline(dacycle, platform, dasystem, samples, statevector): + """ Main entry point for analysis of ctdas results """ + + from da.analysis.cteco2.expand_fluxes import save_weekly_avg_1x1_data, save_weekly_avg_state_data, save_weekly_avg_tc_data, save_weekly_avg_ext_tc_data, save_weekly_avg_agg_data + from da.analysis.cteco2.expand_molefractions import write_mole_fractions + from da.analysis.cteco2.summarize_obs import summarize_obs + from da.analysis.cteco2.time_avg_fluxes import time_avg + + logging.info(header + "Starting analysis" + footer) + + dasystem.validate() + dacycle.dasystem = dasystem + dacycle.daplatform = platform + dacycle.setup() + statevector.setup(dacycle) + + logging.info(header + "Starting mole fractions" + footer) + + write_mole_fractions(dacycle) + summarize_obs(dacycle['dir.analysis']) + + logging.info(header + "Starting weekly averages" + footer) + + save_weekly_avg_1x1_data(dacycle, statevector) + save_weekly_avg_state_data(dacycle, statevector) + save_weekly_avg_tc_data(dacycle, statevector) + save_weekly_avg_ext_tc_data(dacycle) + save_weekly_avg_agg_data(dacycle,region_aggregate='transcom') + save_weekly_avg_agg_data(dacycle,region_aggregate='transcom_extended') + save_weekly_avg_agg_data(dacycle,region_aggregate='olson') + save_weekly_avg_agg_data(dacycle,region_aggregate='olson_extended') + save_weekly_avg_agg_data(dacycle,region_aggregate='country') + + logging.info(header + "Starting monthly and yearly averages" + footer) + + time_avg(dacycle,'flux1x1') + time_avg(dacycle,'transcom') + time_avg(dacycle,'transcom_extended') + time_avg(dacycle,'olson') + time_avg(dacycle,'olson_extended') + time_avg(dacycle,'country') + + logging.info(header + "Finished analysis" + footer) + + + +def archive_pipeline(dacycle, platform, dasystem): + """ Main entry point for archiving of output from one disk/system to another """ + + if not 'task.rsync' in dacycle: + logging.info('rsync task not found, not starting automatic backup...') + return + else: + logging.info('rsync task found, starting automatic backup...') + + for task in dacycle['task.rsync'].split(): + sourcedirs = dacycle['task.rsync.%s.sourcedirs'%task] + destdir = dacycle['task.rsync.%s.destinationdir'%task] + + rsyncflags = dacycle['task.rsync.%s.flags'%task] + + # file ID and names + jobid = dacycle['time.end'].strftime('%Y%m%d') + targetdir = os.path.join(dacycle['dir.exec']) + jobfile = os.path.join(targetdir, 'jb.rsync.%s.%s.jb' % (task,jobid) ) + logfile = os.path.join(targetdir, 'jb.rsync.%s.%s.log' % (task,jobid) ) + # Template and commands for job + jobparams = {{'jobname':"r.%s" % jobid, 'jobnodes': '1', 'jobtime': '1:00:00', 'joblog': logfile, 'errfile': logfile}} + + if platform.ID == 'cartesius': + jobparams['jobqueue'] = 'staging' + + template = platform.get_job_template(jobparams) + for sourcedir in sourcedirs.split(): + execcommand = """\nrsync %s %s %s\n""" % (rsyncflags, sourcedir,destdir,) + template += execcommand + + # write and submit + platform.write_job(jobfile, template, jobid) + jobid = platform.submit_job(jobfile, joblog=logfile) + + + +def start_job(dacycle, dasystem, platform, statevector, samples, obsoperator): + """ Set up the job specific directory structure and create an expanded rc-file """ + + dasystem.validate() + dacycle.dasystem = dasystem + dacycle.daplatform = platform + dacycle.setup() + #statevector.dacycle = dacycle # also embed object in statevector so it can access cycle information for I/O etc + #samples.dacycle = dacycle # also embed object in samples object so it can access cycle information for I/O etc + #obsoperator.dacycle = dacycle # also embed object in obsoperator object so it can access cycle information for I/O etc + obsoperator.setup(dacycle) # Setup Observation Operator + statevector.setup(dacycle) + + +def prepare_state(dacycle, statevector): + """ Set up the input data for the forward model: obs and parameters/fluxes""" + + # We now have an empty statevector object that we need to populate with data. If this is a continuation from a previous cycle, we can read + # the previous statevector values from a NetCDF file in the restart directory. If this is the first cycle, we need to populate the statevector + # with new values for each week. After we have constructed the statevector, it will be propagated by one cycle length so it is ready to be used + # in the current cycle + + logging.info(header + "starting prepare_state" + footer) + + if 'inversion.savestate.dir' in dacycle: + initdir = dacycle['inversion.savestate.dir'] + method = dacycle['inversion.savestate.method'] # valid options: read_new_member and read_mean + logging.info('Ensemble members will be initialized from optimized ensembles in %s' %initdir) + else: + method = 'create_new_member' + + logging.info('msteiner: prepare_state: method is: %s' %method) + + if not dacycle['time.restart']: + + logging.info('msteiner: prepare_state: not dacycle[time.restart]') + + # Fill each week from n=1 to n=nlag with a new ensemble + for n in range(statevector.nlag): + + if method == 'create_new_member': + date = dacycle['time.start'] + datetime.timedelta(days=(n + 0.5) * int(dacycle['time.cycle'])) + cov = statevector.get_covariance(date, dacycle) + statevector.make_new_ensemble(n, cov, int(dacycle['statevector.bg_params'])) + + elif method == 'read_new_member' or method == 'read_mean': + date = dacycle['time.start'] + datetime.timedelta(days=n * int(dacycle['time.cycle'])) + filename_new_member = os.path.join(initdir, date.strftime('%Y%m%d'), 'savestate_%s.nc'%date.strftime('%Y%m%d')) + + # Check if filename exits, else we will need to interpolate between dates + if os.path.exists(filename_new_member): + if method == 'read_new_member': + statevector.read_ensemble_member_from_file(filename_new_member, n, qual='opt', read_lag=0) + elif method == 'read_mean': + date = dacycle['time.start'] + datetime.timedelta(days=(n + 0.5) * int(dacycle['time.cycle'])) + cov = statevector.get_covariance(date, dacycle) + meanstate = statevector.read_mean_from_file(filename_new_member, n, qual='opt') + statevector.make_new_ensemble(n, cov, meanstate) + else: + if method == 'read_new_member': + statevector.read_ensemble_member_from_file(filename_new_member, n, date, initdir, qual='opt', read_lag=0) + elif method == 'read_mean': + meanstate = statevector.read_mean_from_file(filename_new_member, n, date, initdir, qual='opt') + date = dacycle['time.start'] + datetime.timedelta(days=(n + 0.5) * int(dacycle['time.cycle'])) + cov = statevector.get_covariance(date, dacycle) + statevector.make_new_ensemble(n, cov, meanstate) + + else: + + logging.info('msteiner: prepare_state: dacycle[time.restart]') + + # Read the statevector data from file + #saved_sv = os.path.join(dacycle['dir.restart.current'], 'savestate.nc') + saved_sv = os.path.join(dacycle['dir.restart'], 'savestate_%s.nc' % dacycle['da.restart.tstamp'].strftime('%Y%m%d')) + statevector.read_from_file(saved_sv) # by default will read "opt"(imized) variables, and then propagate + + # read ensemble for new week from file, or create new ensemble member, and propagate the ensemble by one cycle to prepare for the current cycle + if method == 'create_new_member': + statevector.propagate(dacycle) + + elif method == 'read_new_member' or method == 'read_mean': + date = dacycle['time.start'] + datetime.timedelta(days=(statevector.nlag-1) * int(dacycle['time.cycle'])) + filename_new_member = os.path.join(initdir, date.strftime('%Y%m%d'), 'savestate_%s.nc'%date.strftime('%Y%m%d')) + statevector.propagate(dacycle, method, filename_new_member, date, initdir) + + # Finally, also write the statevector to a file so that we can always access the a-priori information + current_sv = os.path.join(dacycle['dir.restart'], 'savestate_%s.nc' % dacycle['time.start'].strftime('%Y%m%d')) + statevector.write_to_file(current_sv, 'prior') # write prior info + + + +def sample_state(dacycle, samples, statevector, obsoperator): + """ Sample the filter state for the inversion """ + + # Before a forecast step, save all the data to a save/tmp directory so we can later recover it before the propagation step. + # This is especially important for: + # (i) The transport model restart data which holds the background mole fractions. This is needed to run the model one cycle forward + # (ii) The random numbers (or the seed for the random number generator) so we can recreate the ensembles if needed + + #status = dacycle.MoveSaveData(io_option='store',save_option='partial',filter=[]) + #msg = "All restart data have been copied to the save/tmp directory for future use" ; logging.debug(msg) + logging.info(header + "starting sample_state" + footer) + nlag = int(dacycle['time.nlag']) + logging.info("Sampling model will be run over %d cycles" % nlag) + + obsoperator.get_initial_data() + + for lag in range(nlag): + logging.info(header + ".....Ensemble Kalman Filter at lag %d" % (lag + 1)) + + ############# Perform the actual sampling loop ##################### + + sample_step(dacycle, samples, statevector, obsoperator, lag) + + logging.debug("statevector now carries %d samples" % statevector.nobs) + + + +def sample_step(dacycle, samples, statevector, obsoperator, lag, advance=False): + """ Perform all actions needed to sample one cycle """ + + # First set up the information for time start and time end of this sample + dacycle.set_sample_times(lag) + + startdate = dacycle['time.sample.start'] + enddate = dacycle['time.sample.end'] + dacycle['time.sample.window'] = lag + dacycle['time.sample.stamp'] = "%s_%s" % (startdate.strftime("%Y%m%d%H"), enddate.strftime("%Y%m%d%H")) + + logging.info("New simulation interval set : ") + logging.info(" start date : %s " % startdate.strftime('%F %H:%M')) + logging.info(" end date : %s " % enddate.strftime('%F %H:%M')) + logging.info(" file stamp: %s " % dacycle['time.sample.stamp']) + + + # Implement something that writes the ensemble member parameter info to file, or manipulates them further into the + # type of info needed in your transport model + + # statevector.write_members_to_file(lag, dacycle['dir.input'], obsoperator=obsoperator) + + for sample in samples: + + sample.setup(dacycle) + + # Read observations + perform observation selection + sample.add_observations() + + # Add model-data mismatch to all samples, this *might* use output from the ensemble in the future?? + sample.add_model_data_mismatch('None') + + sampling_coords_file = os.path.join(dacycle['dir.input'], sample.get_samples_type()+'_coordinates_%s.nc' % dacycle['time.sample.stamp']) + sample.write_sample_coords(sampling_coords_file) + + # Write filename to dacycle, and to output collection list + dacycle['ObsOperator.inputfile.'+sample.get_samples_type()] = sampling_coords_file + + del sample + + # Run the observation operator + obsoperator.run_forecast_model(samples,statevector,lag,dacycle) + + + # Read forecast model samples that were written to NetCDF files by each member. Add them to the exisiting + # Observation object for each sample loop. This data fill be written to file in the output folder for each sample cycle. + + # We retrieve all model samples from one output file written by the ObsOperator. If the ObsOperator creates + # one file per member, some logic needs to be included to merge all files!!! + + for i in range(len(samples)): + if os.path.exists(dacycle['ObsOperator.inputfile.'+samples[i].get_samples_type()]): + samples[i].add_simulations(obsoperator.simulated_file[i]) + + else: + logging.warning("No simulations added, because input file does not exist (no samples found in obspack)") + logging.info("No simulations added, because input file does not exist (no samples found in obspack)") + + # Now add the observations that need to be assimilated to the statevector. + # Note that obs will only be added to the statevector if either this is the first step (restart=False), or lag==nlag + # This is to make sure that the first step of the system uses all observations available, while the subsequent + # steps only optimize against the data at the front (lag==nlag) of the filter. This way, each observation is used only + # (and at least) once # in the assimilation + + + if not advance: + if dacycle['time.restart'] == False or lag == int(dacycle['time.nlag']) - 1: + statevector.obs_to_assimilate += (copy.deepcopy(samples),) + for sample in samples: + statevector.nobs += sample.getlength() + del sample + logging.info('nobs = %i' %statevector.nobs) + logging.debug("Added samples from the observation operator to the assimilated obs list in the statevector") + + else: + statevector.obs_to_assimilate += (None,) + + + +def invert(dacycle, statevector, optimizer): + """ Perform the inverse calculation """ + logging.info(header + "starting invert" + footer) + + if statevector.nobs <= 1: #== 0: + logging.info('List with observations to assimilate is empty, skipping invert step and continuing without statevector update...') + return + + dims = (int(dacycle['time.nlag']), + int(dacycle['da.optimizer.nmembers']), + int(dacycle.dasystem['nparameters']), + statevector.nobs) + + if 'opt.algorithm' not in dacycle.dasystem: + logging.info("There was no minimum least squares algorithm specified in the DA System rc file (key : opt.algorithm)") + logging.info("...using serial algorithm as default...") + optimizer.set_algorithm('Serial') + elif dacycle.dasystem['opt.algorithm'] == 'serial': + logging.info("Using the serial minimum least squares algorithm to solve ENKF equations") + optimizer.set_algorithm('Serial') + elif dacycle.dasystem['opt.algorithm'] == 'bulk': + logging.info("Using the bulk minimum least squares algorithm to solve ENKF equations") + optimizer.set_algorithm('Bulk') + + optimizer.setup(dims) + optimizer.state_to_matrix(statevector) + + diagnostics_file = os.path.join(dacycle['dir.output'], 'optimizer.%s.nc' % dacycle['time.start'].strftime('%Y%m%d')) + + optimizer.write_diagnostics(diagnostics_file, 'prior') + optimizer.set_localization(dacycle['da.system.localization']) + + if optimizer.algorithm == 'Serial': + #optimizer.serial_minimum_least_squares() + optimizer.serial_minimum_least_squares(int(dacycle['statevector.bg_params'])) + else: + optimizer.bulk_minimum_least_squares() + + optimizer.matrix_to_state(statevector) + optimizer.write_diagnostics(diagnostics_file, 'optimized') + + + +def advance(dacycle, samples, statevector, obsoperator): + """ Advance the filter state to the next step """ + + # This is the advance of the modeled CO2 state. Optionally, routines can be added to advance the state vector (mean+covariance) + + # Then, restore model state from the start of the filter + logging.info(header + "starting advance" + footer) + logging.info("Sampling model will be run over 1 cycle") + + obsoperator.get_initial_data() + + sample_step(dacycle, samples, statevector, obsoperator, 0, True) + + dacycle.restart_filelist.extend(obsoperator.restart_filelist) + dacycle.output_filelist.extend(obsoperator.output_filelist) + logging.debug("Appended ObsOperator restart and output file lists to dacycle for collection ") + + # write sample output file + for sample in samples: + dacycle.output_filelist.append(dacycle['ObsOperator.inputfile.'+sample.get_samples_type()]) + logging.debug("Appended Observation filename to dacycle for collection: %s"%(dacycle['ObsOperator.inputfile.'+sample.get_samples_type()])) + + sampling_coords_file = os.path.join(dacycle['dir.input'], sample.get_samples_type()+'_coordinates_%s.nc' % dacycle['time.sample.stamp']) + if os.path.exists(sampling_coords_file): + if sample.get_samples_type() == 'flask': + outfile = os.path.join(dacycle['dir.output'], 'sample_auxiliary_%s.nc' % dacycle['time.sample.stamp']) + sample.write_sample_auxiliary(outfile) + else: logging.warning("Sample auxiliary output not written, because input file does not exist (no samples found in obspack)") + del sample + + + +def save_and_submit(dacycle, statevector): + """ Save the model state and submit the next job """ + logging.info(header + "starting save_and_submit" + footer) + + filename = os.path.join(dacycle['dir.restart'], 'savestate_%s.nc' % dacycle['time.start'].strftime('%Y%m%d')) + statevector.write_to_file(filename, 'opt') + + dacycle.output_filelist.append(filename) + dacycle.finalize() diff --git a/cases/icon-art-CTDAS/ctdas_patch/statevector_baseclass_icos_cities.py b/cases/icon-art-CTDAS/ctdas_patch/statevector_baseclass_icos_cities.py new file mode 100644 index 00000000..9904013a --- /dev/null +++ b/cases/icon-art-CTDAS/ctdas_patch/statevector_baseclass_icos_cities.py @@ -0,0 +1,568 @@ +"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +updates of the code. See also: http://www.carbontracker.eu. + +This program is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free Software Foundation, +version 3. This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this +program. If not, see .""" +#!/usr/bin/env python +# ct_statevector_tools.py + +""" +.. module:: statevector +.. moduleauthor:: Wouter Peters + +Revision History: +File created on 28 Jul 2010. + +The module statevector implements the data structure and methods needed to work with state vectors (a set of unknown parameters to be optimized by a DA system) of different lengths, types, and configurations. Two baseclasses together form a generic framework: + * :class:`~da.baseclasses.statevector.StateVector` + * :class:`~da.baseclasses.statevector.EnsembleMember` + +As usual, specific implementations of StateVector objects are done through inheritance form these baseclasses. An example of designing +your own baseclass StateVector we refer to :ref:`tut_chapter5`. + +.. autoclass:: da.baseclasses.statevector.StateVector + +.. autoclass:: da.baseclasses.statevector.EnsembleMember + +""" + +import os +import logging +import numpy as np +from scipy.linalg import cholesky +from datetime import timedelta +import datetime as dt +import da.tools.io4 as io +from multiprocessing import Pool +import xarray as xr +from sklearn.metrics.pairwise import haversine_distances + +identifier = 'ICON Statevector ' +version = '0.0' + +################### Begin Class EnsembleMember ################### + +class EnsembleMember(object): + """ + An ensemble member object consists of: + * a member number + * parameter values + * an observation object to hold sampled values for this member + + Ensemble members are initialized by passing only an ensemble member number, all data is added by methods + from the :class:`~da.baseclasses.statevector.StateVector`. Ensemble member objects have almost no functionality + except to write their data to file using method :meth:`~da.baseclasses.statevector.EnsembleMember.write_to_file` + + .. automethod:: da.baseclasses.statevector.EnsembleMember.__init__ + .. automethod:: da.baseclasses.statevector.EnsembleMember.write_to_file + .. automethod:: da.baseclasses.statevector.EnsembleMember.AddCustomFields + + """ + + def __init__(self, membernumber): + """ + :param memberno: integer ensemble number + :rtype: None + + An EnsembleMember object is initialized with only a number, and holds two attributes as containter for later + data: + * param_values, will hold the actual values of the parameters for this data + * ModelSample, will hold an :class:`~da.baseclasses.obs.Observation` object and the model samples resulting from this members' data + + """ + self.membernumber = membernumber # the member number + self.param_values = None # Parameter values of this member + +################### End Class EnsembleMember ################### + +################### Begin Class StateVector ################### + + +class StateVector(object): + """ + The StateVector object first of all contains the data structure of a statevector, defined by 3 attributes that define the + dimensions of the problem in parameter space: + * nlag + * nparameters + * nmembers + + The fourth important dimension `nobs` is not related to the StateVector directly but is initialized to 0, and later on + modified to be used in other parts of the pipeline: + * nobs + + These values are set as soon as the :meth:`~da.baseclasses.statevector.StateVector.setup` is called from the :ref:`pipeline`. + Additionally, the value of attribute `isOptimized` is set to `False` indicating that the StateVector holds a-priori values + and has not been modified by the :ref:`optimizer`. + + StateVector objects can be filled with data in two ways + 1. By reading the data from file + 2. By creating the data through a set of method calls + + Option (1) is invoked using method :meth:`~da.baseclasses.statevector.StateVector.read_from_file`. + Option (2) consists of a call to method :meth:`~da.baseclasses.statevector.StateVector.make_new_ensemble` + + Once the StateVector object has been filled with data, it is used in the pipeline and a few more methods are + invoked from there: + * :meth:`~da.baseclasses.statevector.StateVector.propagate`, to advance the StateVector from t=t to t=t+1 + * :meth:`~da.baseclasses.statevector.StateVector.write_to_file`, to write the StateVector to a NetCDF file for later use + + The methods are described below: + + .. automethod:: da.baseclasses.statevector.StateVector.setup + .. automethod:: da.baseclasses.statevector.StateVector.read_from_file + .. automethod:: da.baseclasses.statevector.StateVector.write_to_file + .. automethod:: da.baseclasses.statevector.StateVector.make_new_ensemble + .. automethod:: da.baseclasses.statevector.StateVector.propagate + .. automethod:: da.baseclasses.statevector.StateVector.write_members_to_file + + Finally, the StateVector can be mapped to a gridded array, or to a vector of TransCom regions, using: + + .. automethod:: da.baseclasses.statevector.StateVector.grid2vector + .. automethod:: da.baseclasses.statevector.StateVector.vector2grid + .. automethod:: da.baseclasses.statevector.StateVector.vector2tc + .. automethod:: da.baseclasses.statevector.StateVector.state2tc + + """ + + def __init__(self): + self.ID = identifier + self.version = version + + # The following code allows the object to be initialized with a dacycle object already present. Otherwise, it can + # be added at a later moment. + + logging.info('Statevector object initialized: %s' % self.ID) + + def setup(self, dacycle): + """ + setup the object by specifying the dimensions. + There are two major requirements for each statvector that you want to build: + + (1) is that the statevector can map itself onto a regular grid + (2) is that the statevector can map itself (mean+covariance) onto TransCom regions + + An example is given below. + """ + + self.nlag = int(dacycle['time.nlag']) + self.nmembers = int(dacycle['da.optimizer.nmembers']) #number of ensemble members, e.g. 192 for the icon case + self.nparams = int(dacycle.dasystem['nparameters']) #n_reg * n_tracers * n_categories + n_bg_params + self.nobs = 0 + self.grid_fn = dacycle['icon_grid_path'] + + self.obs_to_assimilate = () # empty containter to hold observations to assimilate later on + + # These list objects hold the data for each time step of lag in the system. Note that the ensembles for each time step consist + # of lists of EnsembleMember objects, we define member 0 as the mean of the distribution and n=1,...,nmembers as the spread. + + self.ensemble_members = list(range(self.nlag)) + + for n in range(self.nlag): + self.ensemble_members[n] = [] + + #msteiner: + self.isOptimized = False + self.C = np.zeros((self.nparams,self.nparams)) + #--------- + + + + def make_new_ensemble(self, lag, covariancematrix=None,n_bg_params=0): + """ + :param lag: an integer indicating the time step in the lag order + :param covariancematrix: a matrix to draw random values from + :rtype: None + + Make a new ensemble, the attribute lag refers to the position in the state vector. + Note that lag=1 means an index of 0 in python, hence the notation lag-1 in the indexing below. + The argument is thus referring to the lagged state vector as [1,2,3,4,5,..., nlag] + + The optional covariance object to be passed holds a matrix of dimensions [nparams, nparams] which is + used to draw ensemblemembers from. If this argument is not passed it will ne substituted with an + identity matrix of the same dimensions. + + """ + + logging.info('msteiner: current lag: %i '%(lag)) + logging.info('msteiner: nlag; %i '%(self.nlag)) + categories = {max(lambdas)} + if np.all(self.C==0.): + logging.info('msteiner: performing cholesky decomposition') + + ds_grid = xr.open_dataset(self.grid_fn) + grid_coords = np.stack([ds_grid['clat'].values, ds_grid['clon'].values], axis=-1) # Radians + distances = haversine_distances(grid_coords, grid_coords) * 6371.0 + logging.info('ekoene: computed distances matrix') + covariancematrix = np.zeros((self.nparams,self.nparams), dtype=np.float32) + + {re.sub(fr'(?m)(?<={chr(10)})^', ' ', cfg.CTDAS_covariancematrix_definition.strip(), flags=re.MULTILINE)} + + self.C = np.linalg.cholesky(covariancematrix) + del covariancematrix + + logging.info('Cholesky decomposition has finished') + + # Propagate mean values + newmean = np.ones(self.nparams, float) # standard value for a new time step is 1.0 + if lag == self.nlag - 1 and self.nlag >= 2: + newmean += 2*self.ensemble_members[lag - 1][0].param_values + newmean = newmean / 3.0 + + + #Propagate background mean state by 100%: + if n_bg_params>0: + newmean[self.nparams-n_bg_params:] = self.ensemble_members[lag - 1][0].param_values[self.nparams-n_bg_params:] + + + ####### New forecast model for the mean: take 100% of the optimized value ####### + #newmean = np.ones(self.nparams, float) # standard value for a new time step is 1.0 + #if lag == self.nlag - 1 and self.nlag >= 2: #self.nlag >= 3: + # newmean -= 1. + # newmean += self.ensemble_members[lag - 1][0].param_values + ####### --- ####### + + #DEBUG newmean + for cat in range(categories): + logging.info('Category (%s) ' % str(cat + 1)) + logging.info('New mean (%s) ' % str(np.nanmean(newmean[cat:][::categories]))) + # Create the first ensemble member with a deviation of 0.0 and add to list + newmember = EnsembleMember(0) + newmember.param_values = newmean.flatten() # no deviations + self.ensemble_members[lag].append(newmember) + + # Create members 1:nmembers and add to ensemble_members list + #np.random.normal(loc=1.0, scale=0.5, size=100) + for member in range(1, self.nmembers): + rands = np.random.randn(self.nparams) + newmember = EnsembleMember(member) + logging.info('pre-dot') + # newmember.param_values = np.dot(self.C, rands) + newmean + newmember.param_values = np.einsum("ij, j -> i", self.C, rands) + newmean + logging.info('post-dot') + self.ensemble_members[lag].append(newmember) + logging.info('Created parameters for ensemble member %i'%(member)) + + #DEBUG lambdas + lambdas = np.array([]) + for member in range(0, self.nmembers): + logging.info('Member shape (%s) ' % str(np.shape(self.ensemble_members[lag][member].param_values))) + lambdas = np.append(lambdas, self.ensemble_members[lag][member].param_values) + lambdas = np.reshape(lambdas, (self.nmembers, self.nparams)) + members_array = np.mean(lambdas, axis = 0) + # logging.info('Member array shape (%s) ' % str(np.shape(members_array))) + for cat in range(categories): + logging.info('Category (%s) ' % str(cat + 1)) + logging.info('Lambda mean (%s) ' % str(np.nanmean(members_array[cat:][::categories]))) + + #del C #msteiner: this line causes the "invalid pointer"-error at this point, otherwise it occurs after the code reached the end of this function + + logging.info('%d new ensemble members were added to the state vector # %d' % (self.nmembers, (lag + 1))) + + + def propagate(self, dacycle, method='create_new_member', filename=None, date=None, initdir=None): + """ + :rtype: None + + Propagate the parameter values in the StateVector to the next cycle. This means a shift by one cycle + step for all states that will + be optimized once more, and the creation of a new ensemble for the time step that just + comes in for the first time (step=nlag). + In the future, this routine can incorporate a formal propagation of the statevector. + + """ + + # Remove State Vector n=1 by simply "popping" it from the list and appending a new empty list at the front. This empty list will + # hold the new ensemble for the new cycle + + self.ensemble_members.pop(0) + self.ensemble_members.append([]) + + # And now create a new time step of mean + members for n=nlag + if method == 'create_new_member': + date = dacycle['time.start'] + timedelta(days=(self.nlag - 0.5) * int(dacycle['time.cycle'])) + cov = self.get_covariance(date, dacycle) + self.make_new_ensemble(self.nlag - 1, cov,int(dacycle['statevector.bg_params'])) + + elif method == 'read_new_member': + if os.path.exists(filename): + self.read_ensemble_member_from_file(filename, self.nlag-1, qual='opt', read_lag=0) + else: + self.read_ensemble_member_from_file(filename, self.nlag-1, date, initdir, qual='opt', read_lag=0) + + elif method == 'read_mean': + date = dacycle['time.start'] + timedelta(days=(self.nlag - 0.5) * int(dacycle['time.cycle'])) + cov = self.get_covariance(date, dacycle) + if os.path.exists(filename): + meanstate = self.read_mean_from_file(filename, self.nlag-1, qual='opt') + else: + meanstate = self.read_mean_from_file(filename, self.nlag-1, date, initdir, qual='opt') + self.make_new_ensemble(self.nlag - 1, cov, meanstate) + + logging.info('The state vector has been propagated by one cycle') + + + def write_to_file(self, filename, qual): + """ + :param filename: the full filename for the output NetCDF file + :rtype: None + + Write the StateVector information to a NetCDF file for later use. + In principle the output file will have only one two datasets inside + called: + * `meanstate`, dimensions [nlag, nparamaters] + * `ensemblestate`, dimensions [nlag,nmembers, nparameters] + + This NetCDF information can be read back into a StateVector object using + :meth:`~da.baseclasses.statevector.StateVector.read_from_file` + + """ + #import da.tools.io4 as io + #import da.tools.io as io + + if qual == 'prior': + f = io.CT_CDF(filename, method='create') + logging.debug('Creating new StateVector output file (%s)' % filename) + #qual = 'prior' + else: + f = io.CT_CDF(filename, method='write') + logging.debug('Opening existing StateVector output file (%s)' % filename) + #qual = 'opt' + + dimparams = f.add_params_dim(self.nparams) + dimmembers = f.add_members_dim(self.nmembers) + dimlag = f.add_lag_dim(self.nlag, unlimited=True) + + for n in range(self.nlag): + members = self.ensemble_members[n] + mean_state = members[0].param_values + + savedict = f.standard_var(varname='meanstate_%s' % qual) + savedict['dims'] = dimlag + dimparams + savedict['values'] = mean_state + savedict['count'] = n + savedict['comment'] = 'this represents the mean of the ensemble' + f.add_data(savedict) + + members = self.ensemble_members[n] + devs = np.asarray([m.param_values.flatten() for m in members]) + data = devs - np.asarray(mean_state) + + savedict = f.standard_var(varname='ensemblestate_%s' % qual) + savedict['dims'] = dimlag + dimmembers + dimparams + savedict['values'] = data + savedict['count'] = n + savedict['comment'] = 'this represents deviations from the mean of the ensemble' + f.add_data(savedict) + f.close() + + logging.info('Successfully wrote the State Vector to file (%s) ' % filename) + + + + def interpolate_mean_ensemble(self, initdir, date, qual='opt', readensemble=True): + # deduce window length of source run: + all_dates = os.listdir(initdir) + for i, dstr in enumerate(all_dates): + all_dates[i] = dt.datetime.strptime(dstr,'%Y%m%d') + del i, dstr + all_dates = sorted(all_dates) + ddays = (all_dates[1]-all_dates[0]).days + del all_dates + + # find dates in source directory just before and after target date + found_datemin, found_datemax = False, False + for d in range(ddays): + datei = date - dt.timedelta(days=d) + if not found_datemin and os.path.exists(os.path.join(initdir, datei.strftime('%Y%m%d'), 'savestate_%s.nc'%datei.strftime('%Y%m%d'))): + datemin = datei + found_datemin = True + + datei = date + dt.timedelta(days=d) + if not found_datemax and os.path.exists(os.path.join(initdir, datei.strftime('%Y%m%d'), 'savestate_%s.nc'%datei.strftime('%Y%m%d'))): + datemax = datei + found_datemax = True + + if found_datemin and found_datemax: + print('Found datemin = %s and datemax = %s' %(datemin.strftime('%Y%m%d'), datemax.strftime('%Y%m%d'))) + break + del d + logging.debug('Ensemble for %s will be interpolated from %s and %s' %(date.strftime('%Y-%m-%d'), datemin.strftime('%Y-%m-%d'),datemax.strftime('%Y-%m-%d'))) + + # Read ensemble from both files + filename1 = os.path.join(initdir, datemin.strftime('%Y%m%d'), 'savestate_%s.nc'%datemin.strftime('%Y%m%d')) + f = io.ct_read(filename1, 'read') + meanstate1 = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] + if readensemble: + ensmembers1 = f.get_variable('statevectorensemble_' + qual) # [nlag x nmembers x nparameters] + f.close() + + filename2 = os.path.join(initdir, datemax.strftime('%Y%m%d'), 'savestate_%s.nc'%datemax.strftime('%Y%m%d')) + f = io.ct_read(filename2, 'read') + meanstate2 = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] + if readensemble: + ensmembers2 = f.get_variable('statevectorensemble_' + qual) # [nlag x nmembers x nparameters] + f.close() + + # interpolate mean and ensemble between datemin and datemax + meanstate = ((datemax-date).days/ddays)*meanstate1 + ((date-datemin).days/ddays)*meanstate2 + if readensemble: + ensmembers = ((datemax-date).days/ddays)*ensmembers1 + ((date-datemin).days/ddays)*ensmembers2 + return meanstate, ensmembers + + else: + return meanstate + + + + def read_mean_from_file(self, filename, lag, date=None, initdir=None, qual='opt'): + if date is None: + f = io.ct_read(filename, 'read') + meanstate = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] + f.close + else: + meanstate = self.interpolate_mean_ensemble(initdir, date, qual, readensemble=False) + + logging.info('Successfully read the mean state vector from file (%s) ' %filename) + + return meanstate[lag,:] + + + + def read_ensemble_member_from_file(self, filename, lag, date=None, initdir=None, qual='opt', read_lag=0): + + # if date is None we can directly read mean and ensemble members. Else we will need to read 2 ensembles and interpolate + if date is None: + f = io.ct_read(filename, 'read') + meanstate = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] + ensmembers = f.get_variable('statevectorensemble_' + qual) # [nlag x nmembers x nparameters] + f.close() + + else: + meanstate, ensmembers = self.interpolate_mean_ensemble(initdir, date, qual, readensemble=True) + + # add to statevector + if not self.ensemble_members[lag] == []: + self.ensemble_members[lag] = [] + logging.warning('Existing ensemble for lag=%d was removed to make place for newly read data' % (n + 1)) + + for m in range(self.nmembers): + newmember = EnsembleMember(m) + newmember.param_values = ensmembers[read_lag, m, :].flatten() + meanstate[read_lag,:] # add the mean to the deviations to hold the full parameter values + self.ensemble_members[lag].append(newmember) + + logging.info('Successfully read the State Vector for lag %s from file (%s) ' % (lag,filename)) + + + + + def read_from_file(self, filename, qual='opt'): + """ + :param filename: the full filename for the input NetCDF file + :param qual: a string indicating whether to read the 'prior' or 'opt'(imized) StateVector from file + :rtype: None + + Read the StateVector information from a NetCDF file and put in a StateVector object + In principle the input file will have only one four datasets inside + called: + * `meanstate_prior`, dimensions [nlag, nparamaters] + * `ensemblestate_prior`, dimensions [nlag,nmembers, nparameters] + * `meanstate_opt`, dimensions [nlag, nparamaters] + * `ensemblestate_opt`, dimensions [nlag,nmembers, nparameters] + + This NetCDF information can be written to file using + :meth:`~da.baseclasses.statevector.StateVector.write_to_file` + + """ + + #import da.tools.io as io + f = io.ct_read(filename, 'read') + meanstate = f.get_variable('statevectormean_' + qual) + ensmembers = f.get_variable('statevectorensemble_' + qual) + f.close() + + for n in range(self.nlag): + if not self.ensemble_members[n] == []: + self.ensemble_members[n] = [] + logging.warning('Existing ensemble for lag=%d was removed to make place for newly read data' % (n + 1)) + + for m in range(self.nmembers): + newmember = EnsembleMember(m) + newmember.param_values = ensmembers[n, m, :].flatten() + meanstate[n] # add the mean to the deviations to hold the full parameter values + self.ensemble_members[n].append(newmember) + + logging.info('Successfully read the State Vector from file (%s) ' % filename) + + def write_members_to_file(self, lag, outdir, endswith='.nc', obsoperator=None): + """ + :param: lag: Which lag step of the filter to write, must lie in range [1,...,nlag] + :param: outdir: Directory where to write files + :param: endswith: Optional label to add to the filename, default is simply .nc + :rtype: None + + Write ensemble member information to a NetCDF file for later use. The standard output filename is + *parameters.DDD.nc* where *DDD* is the number of the ensemble member. Standard output file location + is the `dir.input` of the dacycle object. In principle the output file will have only two datasets inside + called `parametervalues` which is of dimensions `nparameters` and `parametermap` which is of dimensions (180,360). + This dataset can be read and used by a :class:`~da.baseclasses.observationoperator.ObservationOperator` object. + + .. note:: if more, or other information is needed to complete the sampling of the ObservationOperator you + can simply inherit from the StateVector baseclass and overwrite this write_members_to_file function. + + """ + + # These import statements caused a crash in netCDF4 on MacOSX. No problems on Jet though. Solution was + # to do the import already at the start of the module, not just in this method. + + #import da.tools.io as io + #import da.tools.io4 as io + + members = self.ensemble_members[lag] + + for mem in members: + filename = os.path.join(outdir, 'parameters.%03d%s' % (mem.membernumber, endswith)) + ncf = io.CT_CDF(filename, method='create') + dimparams = ncf.add_params_dim(self.nparams) + dimgrid = ncf.add_latlon_dim() + + data = mem.param_values + + savedict = io.std_savedict.copy() + savedict['name'] = "parametervalues" + savedict['long_name'] = "parameter_values_for_member_%d" % mem.membernumber + savedict['units'] = "unitless" + savedict['dims'] = dimparams + savedict['values'] = data + savedict['comment'] = 'These are parameter values to use for member %d' % mem.membernumber + ncf.add_data(savedict) + + griddata = self.vector2grid(vectordata=data) + + savedict = io.std_savedict.copy() + savedict['name'] = "parametermap" + savedict['long_name'] = "parametermap_for_member_%d" % mem.membernumber + savedict['units'] = "unitless" + savedict['dims'] = dimgrid + savedict['values'] = griddata.tolist() + savedict['comment'] = 'These are gridded parameter values to use for member %d' % mem.membernumber + ncf.add_data(savedict) + + ncf.close() + + logging.debug('Successfully wrote data from ensemble member %d to file (%s) ' % (mem.membernumber, filename)) + + + def get_covariance(self, date, cycleparams): + pass + +################### End Class StateVector ################### + +if __name__ == "__main__": + pass + diff --git a/cases/icon-art-CTDAS/ctdas_patch/template.jb b/cases/icon-art-CTDAS/ctdas_patch/template.jb new file mode 100644 index 00000000..604f9fc5 --- /dev/null +++ b/cases/icon-art-CTDAS/ctdas_patch/template.jb @@ -0,0 +1,16 @@ +#!/bin/bash +## +## This is a set of dummy names, to be replaced by values from the dictionary +## Please make your own platform specific ctdas-icon with your own keys and place it in a subfolder of the da package. + ## +#SBATCH --job-name=CTDAS-cycle-1 +#SBATCH --partition=normal +#SBATCH --nodes=1 +#SBATCH --time=10:00:00 +#SBATCH --account={cfg.compute_account} +#SBATCH --ntasks-per-core=1 +#SBATCH --ntasks-per-node=36 + +export icycle_in_job=1 + +python3 $SCRATCH/ctdas_procchain/exec/ctdas_procchain.py -v rc=$SCRATCH/ctdas_procchain/exec/ctdas_procchain.rc >& $SCRATCH/ctdas_procchain/exec/ctdas_procchain.log diff --git a/cases/icon-art-CTDAS/ctdas_patch/template.py b/cases/icon-art-CTDAS/ctdas_patch/template.py new file mode 100644 index 00000000..abb9638d --- /dev/null +++ b/cases/icon-art-CTDAS/ctdas_patch/template.py @@ -0,0 +1,81 @@ +"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +updates of the code. See also: http://www.carbontracker.eu. + +This program is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free Software Foundation, +version 3. This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this +program. If not, see .""" +#!/usr/bin/env python + +################################################################################################# +# First order of business is always to make all other python modules accessible through the path +################################################################################################# + +import sys +import os +import logging +sys.path.append(os.getcwd()) + +################################################################################################# +# Next, import the tools needed to initialize a data assimilation cycle +################################################################################################# + +from da.cyclecontrol.initexit_cteco2 import start_logger, validate_opts_args, parse_options, CycleControl +from da.pipelines.pipeline_icon import ensemble_smoother_pipeline, header, footer, analysis_pipeline, archive_pipeline +from da.dasystems.dasystem_baseclass import DaSystem +from da.platform.pizdaint import PizDaintPlatform +from da.statevectors.statevector_baseclass_icos_cities import StateVector +from da.observations.obs_class_ICOS_OCO2 import ICOSObservations, TotalColumnObservations # Here we set which observations we consider! +from da.obsoperators.obsoperator_ICOS_OCO2 import ObservationOperator # Here we set the obs-operator, which should sample the same observations! +from da.optimizers.optimizer_baseclass_icos_cities import Optimizer + + +################################################################################################# +# Parse and validate the command line options, start logging +################################################################################################# + +start_logger() +opts, args = parse_options() +opts, args = validate_opts_args(opts, args) + +################################################################################################# +# Create the Cycle Control object for this job +################################################################################################# + +dacycle = CycleControl(opts, args) + +platform = PizDaintPlatform() +dasystem = DaSystem(dacycle['da.system.rc']) +obsoperator = ObservationOperator(dacycle['da.system.rc']) +samples = [ICOSObservations(), TotalColumnObservations()] +statevector = StateVector() +optimizer = Optimizer() + +########################################################################################## +################### ENTER THE PIPELINE WITH THE OBJECTS PASSED BY THE USER ############### +########################################################################################## + + +logging.info(header + "Entering Pipeline " + footer) + +ensemble_smoother_pipeline(dacycle, platform, dasystem, samples, statevector, obsoperator,optimizer) + + +########################################################################################## +################### All done, extra stuff can be added next, such as analysis +########################################################################################## + +sys.exit(0) + +logging.info(header + "Starting analysis" + footer) + +analysis_pipeline(dacycle, platform, dasystem, samples, statevector ) + +sys.exit(0) + + diff --git a/cases/icon-art-CTDAS/ctdas_patch/template.rc b/cases/icon-art-CTDAS/ctdas_patch/template.rc new file mode 100644 index 00000000..ba3da8c7 --- /dev/null +++ b/cases/icon-art-CTDAS/ctdas_patch/template.rc @@ -0,0 +1,90 @@ +! CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +! Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +! updates of the code. See also: http://www.carbontracker.eu. +! +! This program is free software: you can redistribute it and/or modify it under the +! terms of the GNU General Public License as published by the Free Software Foundation, +! version 3. This program is distributed in the hope that it will be useful, but +! WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +! FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. +! +! You should have received a copy of the GNU General Public License along with this +! program. If not, see . + +! author: Wouter Peters +! +! This is a blueprint for an rc-file used in CTDAS. Feel free to modify it, and please go to the main webpage for further documentation. +! +! Note that rc-files have the convention that commented lines start with an exclamation mark (!), while special lines start with a hashtag (#). +! +! When running the script start_ctdas.sh, this /.rc file will be copied to your run directory, and some items will be replaced for you. +! The result will be a nearly ready-to-go rc-file for your assimilation job. The entries and their meaning are explained by the comments below. +! +! +! HISTORY: +! +! Created on August 20th, 2013 by Wouter Peters +! +! +! The time for which to start and end the data assimilation experiment in format YYYY-MM-DD HH:MM:SS + +time.start : {cfg.startdate.strftime('%Y-%m-%d %H:%M:%S')} +time.finish : {cfg.enddate.strftime('%Y-%m-%d %H:%M:%S')} + +! Whether to restart the CTDAS system from a previous cycle, or to start the sequence fresh. Valid entries are T/F/True/False/TRUE/FALSE + +time.restart : False + +! The length of a cycle is given in days, such that the integer 7 denotes the typically used weekly cycle. Valid entries are integers > 1 + +time.cycle : {cfg.CTDAS_ctdas_cycle} + +! The number of cycles of lag to use for a smoother version of CTDAS. CarbonTracker CO2 typically uses 5 weeks of lag. Valid entries are integers > 0 + +time.nlag : {cfg.CTDAS_ctdas_nlag} + +! The directory under which the code, input, and output will be stored. This is the base directory for a run. The word +! '/' will be replaced through the start_ctdas.sh script by a user-specified folder name. DO NOT REPLACE + +dir.da_run : template + +! The resources used to complete the data assimilation experiment. This depends on your computing platform. +! The number of cycles per job denotes how many cycles should be completed before starting a new process or job, this +! allows you to complete many cycles before resubmitting a job to the queue and having to wait again for resources. +! Valid entries are integers > 0 + +da.resources.ncycles_per_job : 1 + +! The ntasks specifies the number of threads to use for the MPI part of the code, if relevant. Note that the CTDAS code +! itself is not parallelized and the python code underlying CTDAS does not use multiple processors. The chosen observation +! operator though might use many processors, like TM5. Valid entries are integers > 0 + +da.resources.ntasks : 1 + +! This specifies the amount of wall-clock time to request for each job. Its value depends on your computing platform and might take +! any form appropriate for your system. Typically, HPC queueing systems allow you a certain number of hours of usage before +! your job is killed, and you are expected to finalize and submit a next job before that time. Valid entries are strings. + +da.resources.ntime : 24:00:00 + +! The resource settings above will cause the creation of a job file in which 2 cycles will be run, and 30 threads +! are asked for a duration of 4 hours +! +! Info on the DA system used, this depends on your application of CTDAS and might refer to for instance CO2, or CH4 optimizations. +! + +da.system : CarbonTracker + +! The specific settings for your system are read from a separate rc-file, which points to the data directories, observations, etc + +! The directory where the ICON-simulation is located: +statevector.bg_params : {cfg.CTDAS_nboundaries} +statevector.number_regions : {nregs} +statevector.tracer : co2 +da.system.rc : da/rc/cteco2/carbontracker_icon_oco2.rc +da.optimizer.nmembers : {cfg.CTDAS_nensembles} +da.system.localization : spatial +da.obsoperator : RandomizerObservationOperator +icon_grid_path : {cfg.input_files_scratch_dynamics_grid_filename} + + diff --git a/cases/icon-art-CTDAS/ctdas_patch/utilities.py b/cases/icon-art-CTDAS/ctdas_patch/utilities.py new file mode 100644 index 00000000..30e3de52 --- /dev/null +++ b/cases/icon-art-CTDAS/ctdas_patch/utilities.py @@ -0,0 +1,319 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" + +Created on Wed Sep 18 16:03:02 2019 + +@author: friedemann +""" + +import os +import glob +import logging +import subprocess +import tempfile +import copy +import netCDF4 as nc +import numpy as np + +class utilities(object): + """ + Collection of utilities for wrfchem observation operator + that do not depend on other CTDAS modules + """ + + def __init__(self): + pass + + @staticmethod + def get_slicing_ids(N, nproc, nprocs): + """ + Purpose + ------- + For parallel processing, figure out which samples to process + by this process. + + Parameters + ---------- + N : int + Length to slice + nproc : int + id of this process (0... nprocs-1) + nprocs : int + Number of processes that work on the task. + + Output + ------ + Slicing indices id0, id1 + Usage + ----- + ..code-block:: python + + id0, id1 = get_slicing_ids(N, nproc, nprocs) + field[id0:id1, ...] + """ + + f0 = float(nproc)/float(nprocs) + id0 = int(np.floor(f0*N)) + + f1 = float(nproc+1)/float(nprocs) + id1 = int(np.floor(f1*N)) + + if id0==id1: + raise ValueError("id0==id1. Probably too many processes.") + return id0, id1 + + + + @classmethod + def cat_ncfiles(cls, path, in_arg, cat_dim, out_file, in_pattern=False, rm_original=True): + """ + Combine output of all processes into 1 file + If in_pattern, a pattern is provided instead of a file list. + This has the advantage that it can be interpreted by the shell, + because there are problems with long argument lists. + + This calls ncrcat from the nco library. If nco is not available, + rewrite this function. Note: I first tried to do this with + "cdo cat", but it messed up sounding_id + (see https://code.mpimet.mpg.de/boards/1/topics/908) + """ + + # To preserve dimension names, we start from one of the existing + # slice files instead of a new file. + + # Do this in path to avoid long command line arguments and history + # entries in outfile. + cwd = os.getcwd() + os.chdir(path) + + if in_pattern: + if not isinstance(in_arg, str): + raise TypeError("in_arg must be a string if in_pattern is True.") + file_pattern = in_arg + in_files = glob.glob(file_pattern) + else: + if isinstance(in_arg, list): + raise TypeError("in_arg must be a list if in_pattern is False.") + in_files = in_arg + + if len(in_files) == 0: + logging.error("Nothing to do.") + # Change back to previous directory + os.chdir(cwd) + return + + # Sorting is important! + in_files.sort() + + # ncrcat needs total number of soundings, count + Nobs = 0 + for f in in_files: + ncf = nc.Dataset(f, "r") + Nobs += len(ncf.dimensions[cat_dim]) + ncf.close() + + # Cat files + cmd_ = "ncrcat -h -O -d " + cat_dim + ",0,%d"%(Nobs-1) + if in_pattern: + cmd = cmd_ + " " + file_pattern + " " + out_file + # If PIPE is used here, it gets clogged, and the process + # stops without error message (see also + # https://thraxil.org/users/anders/posts/2008/03/13/Subprocess-Hanging-PIPE-is-your-enemy/) + # Hence, piping the output to a temporary file. + proc = subprocess.Popen(cmd, shell=True, + stdout=tempfile.TemporaryFile(), + stderr=tempfile.TemporaryFile()) + else: + cmdsplt = cmd_.split() + in_files + [out_file] + proc = subprocess.Popen(cmdsplt, stdout=tempfile.TemporaryFile(), stderr=tempfile.TemporaryFile()) + cmd = " ".join(cmdsplt) + + proc.wait() + + # This is probably useless since the output is piped to a + # tempfile. + retcode = cls.check_out_err(proc) + + if retcode != 0: + msg = "Something went wrong in the sampling. Command: " + cmd + logging.error(msg) + raise OSError(msg) + + # Delete slice files + if rm_original: + logging.info("Deleting slice files.") + for f in in_files: + os.remove(f) + + logging.info("Sampled WRF output written to file.") + + # Change back to previous directory + os.chdir(cwd) + + + @staticmethod + def check_out_err(process): + """Displays stdout and stderr, returns returncode of the + process. + """ + + # Get process messages + out, err = process.communicate() + + # Print output + def to_str(str_or_bytestr): + """If argument is of type str, return argument. If + argument is of type bytes, return decoded str""" + if isinstance(str_or_bytestr, str): + return str_or_bytestr + elif isinstance(str_or_bytestr, bytes): + return str(str_or_bytestr, 'utf-8') + else: + msg = "str_or_bytestr is " + str(type(str_or_bytestr)) + \ + ", should be str or bytestr." + raise TypeError(msg) + + logging.debug("Subprocess output:") + if out is None: + logging.debug("No output.") + elif isinstance(out, list): + for line in out: + logging.debug(to_str(line.rstrip())) + else: + logging.debug(to_str(out.rstrip())) + + # Handle errors + if process.returncode != 0: + logging.error("subprocess error") + logging.error("Returncode: %s", str(process.returncode)) + logging.error("Message, if any:") + if not err is None: + for line in err: + logging.error(line.rstrip()) + + return process.returncode + + @classmethod + def get_index_groups(cls, *args): + """ + Input: + numpy arrays with 1 dimension or lists, all same length + Output: + Dictionary of lists of indices that have the same + combination of input values. + """ + + try: + # If pandas is available, it makes a pandas DataFrame and + # uses its groupby-function. + import pandas as pd + + args_array = np.array(args).transpose() + df = pd.DataFrame(args_array) + groups = df.groupby(list(range(len(args)))).indices + + except ImportError: + # If pandas is not available, use an own implementation of groupby. + # Recursive implementation. It's fast. + args_array = np.array(args).transpose() + groups = cls._group(args_array) + + return groups + + @classmethod + def _group(cls, a): + """ + Reimplementation of pandas.DataFrame.groupby.indices because + py 2.7 on cartesius isn't compatible with pandas. + Unlike the pandas function, this always uses all columns of the + input array. + + Parameters + ---------- + a : numpy.ndarray (2D) + Array of indices. Each row is a combination of indices. + + Returns + ------- + groups : dict + The keys are the unique combinations of indices (rows of a), + the values are the indices of the rows of a equal the key. + """ + + # This is a recursive function: It makes groups according to the + # first columnm, then calls itself with the remaining columns. + # Some index juggling. + + # Group according to first column + UI = list(set(a[:, 0])) + groups0 = dict() + for ui in UI: + # Key must be a tuple + groups0[(ui, )] = [i for i, x in enumerate(a[:, 0]) if x == ui] + + if a.shape[1] == 1: + # If the array only has one column, we're done + return groups0 + else: + # If the array has more than one column, we group those. + groups = dict() + for ui in UI: + # Group according to the remaining columns + subgroups_ui = cls._group(a[groups0[(ui, )], 1:]) + # Now the index juggling: Add the keys together and + # locate values in the original array. + for key in list(subgroups_ui.keys()): + # Get indices of bigger array + subgroups_ui[key] = [groups0[(ui, )][n] for n in subgroups_ui[key]] + # Add the keys together + groups[(ui, ) + key] = subgroups_ui[key] + + return groups + + + @staticmethod + def apply_by_group(func, array, groups, grouped_args=None, *args, **kwargs): + """ + Apply function 'func' to a numpy array by groups of indices. + 'groups' can be a list of lists or a dictionary with lists as + values. + + If 'array' has more than 1 dimension, the indices in 'groups' + are for the first axis. + + If 'grouped_args' is not None, its members are added to + 'kwargs' after slicing. + + *args and **kwargs are passed through to 'func'. + + Example: + apply_by_group(np.mean, np.array([0., 1., 2.]), [[0, 1], [2]]) + Output: + array([0.5, 2. ]) + """ + + shape_in = array.shape + shape_out = list(shape_in) + shape_out[0] = len(groups) + array_out = np.ndarray(shape_out, dtype=array.dtype) + + if type(groups) == list: + # Make a dictionary + groups = {{n: groups[n] for n in range(len(groups))}} + + if not grouped_args is None: + kwargs0 = copy.deepcopy(kwargs) + for n in range(len(groups)): + k = list(groups.keys())[n] + + # Add additional arguments that need to be grouped to kwargs + if not grouped_args is None: + kwargs = copy.deepcopy(kwargs0) + for ka, v in grouped_args.items(): + kwargs[ka] = v[groups[k], ...] + + array_out[n, ...] = np.apply_along_axis(func, 0, array[groups[k], ...], *args, **kwargs) + + return array_out + diff --git a/cases/icon-art-CTDAS2/ICBC/icon_era5_inicond.sh b/cases/icon-art-CTDAS2/ICBC/icon_era5_inicond.sh new file mode 100644 index 00000000..55e66776 --- /dev/null +++ b/cases/icon-art-CTDAS2/ICBC/icon_era5_inicond.sh @@ -0,0 +1,179 @@ +#!/bin/bash + +cd {ERA5_folder} + +{cfg.cdo_nco_cmd} + +set -x + +# --------------------------------- +# -- Pre-processing +# --------------------------------- + +# -- Put all variables in the same file +cdo -O merge {era5_ml_file} {era5_surf_file} era5_original.nc + +# -- Change variable and coordinates names to be consistent with ICON nomenclature +cdo setpartabn,mypartab,convert era5_original.nc tmp.nc + +# -- Order the variables alphabetically +ncks -O tmp.nc data_in.nc +rm tmp.nc era5_original.nc + +# --------------------------------- +# -- Re-mapping +# --------------------------------- + +# -- Retrieve the dynamic horizontal grid +cdo -s selgrid,2 {cfg.input_files_scratch_dynamics_grid_filename} triangular-grid.nc + +# -- Create the weights for remapping ERA5 latlon grid onto the triangular grid +cdo gendis,triangular-grid.nc data_in.nc weights.nc + +# -- Extract the land-sea mask variable in input and output files +cdo selname,LSM data_in.nc LSM_in.nc +ncrename -h -v LSM,FR_LAND LSM_in.nc +cdo selname,FR_LAND {cfg.input_files_scratch_extpar_filename} LSM_out_tmp.nc + +# -- Add time dimension to LSM_out.nc +ncecat -O -u time LSM_out_tmp.nc LSM_out_tmp.nc +ncks -h -A -v time LSM_in.nc LSM_out_tmp.nc + +# -- Create two different files for land- and sea-mask +cdo -L setctomiss,0. -ltc,0.5 LSM_in.nc oceanmask_in.nc +cdo -L setctomiss,0. -gec,0.5 LSM_in.nc landmask_in.nc +cdo -L setctomiss,0. -ltc,0.5 LSM_out_tmp.nc oceanmask_out.nc +cdo -L setctomiss,0. -gec,0.5 LSM_out_tmp.nc landmask_out.nc +cdo setrtoc2,0.5,1.0,1,0 LSM_out_tmp.nc LSM_out.nc +rm LSM_in.nc LSM_out_tmp.nc + +# -- Select surface sea variables defined only on sea +ncks -O -h -v SST,CI data_in.nc datasea_in.nc + +# -- Select surface variables defined on both that must be remap differently on sea and on land +ncks -O -h -v SKT,STL1,STL2,STL3,STL4,ALB_SNOW,W_SNOW,T_SNOW data_in.nc dataland_in.nc + +# ----------------------------------------------------------------------------- +# -- Remap land and ocean area differently for variables +# ----------------------------------------------------------------------------- + +# -- Ocean part +# ----------------- + +# -- Apply the ocean mask (by dividing) +cdo div dataland_in.nc oceanmask_in.nc tmp1_land.nc +cdo div datasea_in.nc oceanmask_in.nc tmp1_sea.nc + +# -- Set missing values to a distance-weighted average +cdo setmisstodis tmp1_land.nc tmp2_land.nc +cdo setmisstodis tmp1_sea.nc tmp2_sea.nc + +# -- Remap +cdo remapdis,triangular-grid.nc tmp2_land.nc tmp3_land.nc +cdo remapdis,triangular-grid.nc tmp2_sea.nc tmp3_sea.nc + +# -- Apply the ocean mask to remapped variables (by dividing) +cdo div tmp3_land.nc oceanmask_out.nc dataland_ocean_out.nc +cdo div tmp3_sea.nc oceanmask_out.nc datasea_ocean_out.nc + +# -- Clean the repository +rm tmp*.nc oceanmask*.nc + +# # -- Land part +# # ----------------- + +cdo div dataland_in.nc landmask_in.nc tmp1.nc +cdo setmisstodis tmp1.nc tmp2.nc +cdo remapdis,triangular-grid.nc tmp2.nc tmp3.nc +cdo div tmp3.nc landmask_out.nc dataland_land_out.nc +rm tmp*.nc landmask*.nc dataland_in.nc datasea_in.nc + +# -- merge remapped land and ocean part +# -------------------------------------- + +cdo ifthenelse LSM_out.nc dataland_land_out.nc dataland_ocean_out.nc dataland_out.nc +rm dataland_ocean_out.nc dataland_land_out.nc + +# remap the rest and merge all files +# -------------------------------------- + +# -- Select all variables apart from these ones +ncks -O -h -x -v SKT,STL1,STL2,STL3,STL4,SMIL1,SMIL2,SMIL3,SMIL4,ALB_SNOW,W_SNOW,T_SNOW,SST,CI,LSM data_in.nc datarest_in.nc + +# -- Remap +cdo -s remapdis,triangular-grid.nc datarest_in.nc era5_final.nc +rm datarest_in.nc + +# -- Fill NaN values for SST and CI +cdo setmisstodis -selname,SST,CI datasea_ocean_out.nc dataland_ocean_out_filled.nc +rm datasea_ocean_out.nc + +# -- Merge remapped files plus land sea mask from EXTPAR +ncks -h -A dataland_out.nc era5_final.nc +ncks -h -A dataland_ocean_out_filled.nc era5_final.nc +ncks -h -A -v FR_LAND LSM_out.nc era5_final.nc +ncrename -h -v FR_LAND,LSM era5_final.nc +rm LSM_out.nc dataland_out.nc + +# ------------------------------------------------------------------------ +# -- Convert the (former) SWVLi variables to real soil moisture indices +# ------------------------------------------------------------------------ + +# -- Properties of IFS soil types (see Table 1 ERA5 Data documentation +# -- https://confluence.ecmwf.int/display/CKB/ERA5%3A+data+documentation) +# Soil type 1 2 3 4 5 6 7 +wiltingp=(0 0.059 0.151 0.133 0.279 0.335 0.267 0.151) # wilting point +fieldcap=(0 0.244 0.347 0.383 0.448 0.541 0.663 0.347) # field capacity + +ncks -O -h -v SMIL1,SMIL2,SMIL3,SMIL4,SLT data_in.nc swvl.nc +rm data_in.nc + +# -- Loop over the soil types and apply the right constants +smi_equation="" +for ilev in {{1..4}}; do + + smi_equation="${{smi_equation}}SMIL${{ilev}} = (SMIL${{ilev}} - ${{wiltingp[1]}}) / (${{fieldcap[1]}} - ${{wiltingp[1]}}) * (SLT==1)" + for ist in {{2..7}}; do + smi_equation="${{smi_equation}} + (SMIL${{ilev}} - ${{wiltingp[$ist]}}) / (${{fieldcap[$ist]}} - ${{wiltingp[$ist]}}) * (SLT==${{ist}})" + done + smi_equation="${{smi_equation}};" + +done + +cdo expr,"${{smi_equation}}" swvl.nc smil_in.nc +rm swvl.nc + +# -- Remap SMIL variables +cdo -s remapdis,triangular-grid.nc smil_in.nc smil_out.nc +rm smil_in.nc + +# -- Overwrite the variables SMIL1,SMIL2,SMIL3,SMIL4 +ncks -A -v SMIL1,SMIL2,SMIL3,SMIL4 smil_out.nc era5_final.nc +rm smil_out.nc + +# -------------------------------------- +# -- Create the LNSP variable +# -------------------------------------- + +# -- Apply logarithm to surface pressure +cdo expr,'LNPS=ln(PS); Q=QV; GEOP_SFC=GEOSP' era5_final.nc tmp.nc + +# -- Put the new variable LNSP in the original file +ncks -A -v LNPS,Q,GEOP_SFC tmp.nc era5_final.nc +rm tmp.nc + +# --------------------------------- +# -- Post-processing +# --------------------------------- + +# -- Rename dimensions and order alphabetically +ncrename -h -d cell,ncells era5_final.nc +ncrename -h -d nv,vertices era5_final.nc +ncks -O era5_final.nc {inicond_filename} +rm era5_final.nc + +# -- Clean the repository +rm weights.nc +rm triangular-grid.nc + +{cfg.cdo_nco_cmd_post} \ No newline at end of file diff --git a/cases/icon-art-CTDAS2/ICBC/icon_era5_nudging.sh b/cases/icon-art-CTDAS2/ICBC/icon_era5_nudging.sh new file mode 100644 index 00000000..4befac68 --- /dev/null +++ b/cases/icon-art-CTDAS2/ICBC/icon_era5_nudging.sh @@ -0,0 +1,63 @@ +#!/bin/bash + +cd {ERA5_folder} + +{cfg.cdo_nco_cmd} + +# --------------------------------- +# -- Pre-processing +# --------------------------------- + +rm -f {filename} + +# -- Put all variables in the same file +cdo -O merge {era5_ml_file} {era5_surf_file} era5_original.nc + +# -- Change variable and coordinates names to be consistent with ICON nomenclature +cdo setpartabn,mypartab,convert era5_original.nc tmp.nc + +# -- Order the variables alphabetically +ncks -O tmp.nc data_in.nc +rm tmp.nc era5_original.nc + +# --------------------------------- +# -- Re-mapping +# --------------------------------- + +# -- Retrieve the dynamic horizontal grid +cdo -s selgrid,2 {cfg.input_files_scratch_dynamics_grid_filename} triangular-grid.nc + +# -- Create the weights for remapping ERA5 latlon grid onto the triangular grid +cdo gendis,triangular-grid.nc data_in.nc weights.nc + +# -- Remap +cdo -s remapdis,triangular-grid.nc data_in.nc era5_final.nc +rm data_in.nc + +# -------------------------------------- +# -- Create the LNSP variable +# -------------------------------------- + +# -- Apply logarithm to surface pressure +cdo expr,'LNPS=ln(PS); Q=QV; GEOP_SFC=GEOSP' era5_final.nc tmp.nc + +# -- Put the new variable LNSP in the original file +ncks -A -v LNPS,Q,GEOP_SFC tmp.nc era5_final.nc +rm tmp.nc + +# --------------------------------- +# -- Post-processing +# --------------------------------- + +# -- Rename dimensions and order alphabetically +ncrename -h -d cell,ncells era5_final.nc +ncrename -h -d nv,vertices era5_final.nc +ncks -O era5_final.nc {filename} +rm era5_final.nc + + +# -- Clean the repository +rm weights.nc +rm triangular-grid.nc + +{cfg.cdo_nco_cmd_post} \ No newline at end of file diff --git a/cases/icon-art-CTDAS2/ICBC/icon_era5_splitfiles.sh b/cases/icon-art-CTDAS2/ICBC/icon_era5_splitfiles.sh new file mode 100644 index 00000000..e08682a0 --- /dev/null +++ b/cases/icon-art-CTDAS2/ICBC/icon_era5_splitfiles.sh @@ -0,0 +1,40 @@ +#!/bin/bash + +cd {ERA5_folder} + +{cfg.cdo_nco_cmd} + +# Loop over ml and surf files +for ml_file in {ml_files}; do + # Convert GRIB to NetCDF for ml file and then process it + cdo -t ecmwf -f nc copy "${{ml_file}}" "${{ml_file%.grib}}.nc" + + # Show timestamp and split for ml file + cdo showtimestamp "${{ml_file%.grib}}.nc" > list_ml.txt + cdo -splitsel,1 "${{ml_file%.grib}}.nc" split_ml_ + + times_ml=($(cat list_ml.txt)) + x=0 + for f in $(ls split_ml_*.nc); do + mv $f era5_ml_${{times_ml[$x]}}.nc + let x=$x+1 + done +done + +for surf_file in {surf_files}; do + # Convert GRIB to NetCDF for surf file and then process it + cdo -t ecmwf -f nc copy "${{surf_file}}" "${{surf_file%.grib}}.nc" + + # Show timestamp and split for surf file + cdo showtimestamp "${{surf_file%.grib}}.nc" > list_surf.txt + cdo -splitsel,1 "${{surf_file%.grib}}.nc" split_surf_ + + times_surf=($(cat list_surf.txt)) + y=0 + for f in $(ls split_surf_*.nc); do + mv $f era5_surf_${{times_surf[$y]}}.nc + let y=$y+1 + done +done + +{cfg.cdo_nco_cmd_post} \ No newline at end of file diff --git a/cases/icon-art-CTDAS2/ICBC/icon_species_inicond.sh b/cases/icon-art-CTDAS2/ICBC/icon_species_inicond.sh new file mode 100644 index 00000000..79b1ef66 --- /dev/null +++ b/cases/icon-art-CTDAS2/ICBC/icon_species_inicond.sh @@ -0,0 +1,58 @@ +#!/bin/bash + +cd {ERA5_folder} + +{cfg.cdo_nco_cmd} + +set -x + +# 1. Remap +cdo griddes {inicond_filename} > triangular-grid.txt +cdo remapbil,triangular-grid.txt {CAMS_file} cams_triangle.nc + +# 2. Write out the hybrid levels +cat >CAMS_levels.txt <> CAMS_levels.txt +echo '' >> CAMS_levels.txt +echo 'vctsize = 160' >> CAMS_levels.txt +echo 'vct = ' >> CAMS_levels.txt +ncks -v ap cams_triangle.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*ap = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt +ncks -v bp cams_triangle.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*bp = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt +echo '' >> CAMS_levels.txt +echo 'formula = "hyam hybm (mlev=ap+bp*aps)"' >> CAMS_levels.txt +cdo setzaxis,CAMS_levels.txt cams_triangle.nc cams_withhybrid.nc + +# 3. Add required variables +# --- CAMS +ncrename -O -v Psurf,PS -d level,lev -v level,lev cams_withhybrid.nc +ncap2 -s 'P0=1.0; lnsp=ln(PS); lev[lev]=array(0,1,$lev)' cams_withhybrid.nc -O cams_withhybrid_with_P.nc +ncks -C -v P0,PS,lnsp,CO2,hyam,hybm,hyai,hybi,lev,clon,clat cams_withhybrid_with_P.nc -O cams_light.nc +ncatted -a _FillValue,CO2,m,f,1.0e36 -O cams_light.nc +# --- ERA5 +ncap2 -s 'P0=1.0; PS=PS(0,:)' {inicond_filename} -O data_in_with_P.nc +ncks -C -v hyam,hybm,hyai,hybi,clon,clat,P0 data_in_with_P.nc -O era5_light.nc +ncks -A -v PS cams_light.nc era5_light.nc + +# 4. Remap +ncremap --no_stdin --vrt_fl=era5_light.nc -v CO2 cams_light.nc cams_remapped.nc +ncrename -O -d nhym,lev cams_remapped.nc + +# 5. Place in inicond file +ncks -A -v CO2 cams_remapped.nc {inicond_filename} +ncap2 -s 'M_Air=28.9647; M_CO2=44.01; CO2_new[time,lev,ncells]=CO2*(M_CO2/M_Air)*(1-QV);' {inicond_filename} +ncks -C -O -x -v CO2 {inicond_filename} {era5_cams_ini_file} # Remove old CO2 variable +ncrename -v CO2_new,CO2 {era5_cams_ini_file} # Rename CO2_new to CO2 +ncrename -d .cell,ncells {era5_cams_ini_file} +ncrename -d .nv,vertices {era5_cams_ini_file} + +{cfg.cdo_nco_cmd_post} \ No newline at end of file diff --git a/cases/icon-art-CTDAS2/ICBC/icon_species_nudging.sh b/cases/icon-art-CTDAS2/ICBC/icon_species_nudging.sh new file mode 100644 index 00000000..1d3eda4d --- /dev/null +++ b/cases/icon-art-CTDAS2/ICBC/icon_species_nudging.sh @@ -0,0 +1,77 @@ +#!/bin/bash + +cd {ERA5_folder} + +{cfg.cdo_nco_cmd} + +set -x + +# 1. Remap +cdo griddes {filename} > triangular-grid.txt +cdo remapbil,triangular-grid.txt {CAMS_file} cams_triangle.nc + +# 2. Write out the hybrid levels +cat >CAMS_levels.txt <> CAMS_levels.txt +echo '' >> CAMS_levels.txt +echo 'vctsize = 160' >> CAMS_levels.txt +echo 'vct = ' >> CAMS_levels.txt +ncks -v ap cams_triangle.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*ap = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt +ncks -v bp cams_triangle.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*bp = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt +echo '' >> CAMS_levels.txt +echo 'formula = "hyam hybm (mlev=ap+bp*aps)"' >> CAMS_levels.txt +cdo setzaxis,CAMS_levels.txt cams_triangle.nc cams_withhybrid.nc + +# 3. Add required variables +# --- CAMS +ncrename -O -v Psurf,PS -d level,lev -v level,lev cams_withhybrid.nc +ncap2 -s 'P0=1.0; lnsp=ln(PS); lev[lev]=array(0,1,$lev)' cams_withhybrid.nc -O cams_withhybrid_with_P.nc +ncks -C -v P0,PS,lnsp,CO2,hyam,hybm,hyai,hybi,lev,clon,clat cams_withhybrid_with_P.nc -O cams_light.nc +ncatted -a _FillValue,CO2,m,f,1.0e36 -O cams_light.nc +# --- ERA5 +ncap2 -s 'P0=1.0; PS=PS(0,:)' {filename} -O data_in_with_P.nc +ncks -C -v hyam,hybm,hyai,hybi,clon,clat,P0 data_in_with_P.nc -O era5_light.nc +ncks -A -v PS cams_light.nc era5_light.nc + +# 4. Remap +ncremap --no_stdin --vrt_fl=era5_light.nc -v CO2 cams_light.nc cams_remapped.nc +ncrename -O -d nhym,lev cams_remapped.nc + +# 5. Place in inicond file +ncks -A -v CO2 cams_remapped.nc {filename} +ncap2 -s 'M_Air=28.9647; M_CO2=44.01; CO2_new[time,lev,ncells]=CO2*(M_CO2/M_Air)*(1-QV);' {filename} +ncks -C -O -x -v CO2 {filename} tmp.nc +ncrename -v CO2_new,CO2 tmp.nc + +# 6. Remap to lateral boundaries +cat > NAMELIST_ICONSUB << EOF_1 +&iconsub_nml + grid_filename = '{cfg.input_files_scratch_dynamics_grid_filename}', + output_type = 4, + lwrite_grid = .TRUE., +/ +&subarea_nml + ORDER = "lateral_boundary", + grf_info_file = '{cfg.input_files_scratch_dynamics_grid_filename}', + min_refin_c_ctrl = 1 + max_refin_c_ctrl = 120 +/ +EOF_1 + +iconsub --nml NAMELIST_ICONSUB + +cdo selgrid,2 lateral_boundary.grid.nc triangular-grid_00_lbc.nc +cdo remapdis,triangular-grid_00_lbc.nc tmp.nc {era5_cams_nudge_file} +ncrename -d cell,ncells {era5_cams_nudge_file} +ncrename -d nv,vertices {era5_cams_nudge_file} +{cfg.cdo_nco_cmd_post} diff --git a/cases/icon-art-CTDAS2/ICON/ICON_template.job b/cases/icon-art-CTDAS2/ICON/ICON_template.job new file mode 100644 index 00000000..94993e4c --- /dev/null +++ b/cases/icon-art-CTDAS2/ICON/ICON_template.job @@ -0,0 +1,386 @@ +#!/bin/bash -l +#SBATCH --uenv="icon-wcp/v1:rc4" +#SBATCH --job-name="{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.forecasttime}" +#SBATCH --time=00:40:00 +#SBATCH --account={cfg.compute_account} +#SBATCH --nodes={cfg.nodes} +#SBATCH --ntasks-per-node={cfg.ntasks_per_node} +#SBATCH --ntasks-per-core=1 +#SBATCH --cpus-per-task=1 +#SBATCH --partition={cfg.compute_queue} +#SBATCH --constraint={cfg.constraint} +#SBATCH --chdir={cfg.icon_work} + +export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK + +dtime=120 # Ensure dtime is defined +dt_rad=$(( 4 * dtime )) +dt_conv=$(( 1 * dtime )) +dt_sso=$(( 2 * dtime )) +dt_gwd=$(( 2 * dtime )) + +# ---------------------------------------------------------------------------- +# create ICON master namelist +# ---------------------------------------------------------------------------- + +cat > icon_master.namelist << EOF +! master_nml: ---------------------------------------------------------------- +&master_nml + lrestart = .FALSE. ! .TRUE.=current experiment is resumed +/ + +! master_model_nml: repeated for each model ---------------------------------- +&master_model_nml + model_type = 1 ! identifies which component to run (atmosphere,ocean,...) + model_name = "ATMO" ! character string for naming this component. + model_namelist_filename = "NAMELIST_NWP" ! file name containing the model namelists + model_min_rank = 1 ! start MPI rank for this model + model_max_rank = 65536 ! end MPI rank for this model + model_inc_rank = 1 ! stride of MPI ranks +/ + +! time_nml: specification of date and time------------------------------------ +&time_nml + ini_datetime_string = "{ini_restart_string}" ! initial date and time of the simulation + end_datetime_string = "{ini_restart_end_string}" ! end date and time of the simulation 10T00 +/ +EOF + +# ---------------------------------------------------------------------- +# model namelists +# ---------------------------------------------------------------------- + +cat > NAMELIST_NWP << EOF +! parallel_nml: MPI parallelization ------------------------------------------- +¶llel_nml + nblocks_c = 1 + nproma_sub = 800 ! loop chunk length + p_test_run = .FALSE. ! .TRUE. means verification run for MPI parallelization + num_io_procs = 1 ! number of I/O processors + num_restart_procs = 0 ! number of restart processors + num_prefetch_proc = 1 ! number of processors for LBC prefetching + iorder_sendrecv = 3 ! sequence of MPI send/receive calls +/ + + +! run_nml: general switches --------------------------------------------------- +&run_nml + ltestcase = .FALSE. ! real case run + num_lev = 60 ! number of full levels (atm.) for each domain + lvert_nest = .FALSE. ! no vertical nesting + dtime = $(( dtime )) ! timestep in seconds + ldynamics = .TRUE. ! compute adiabatic dynamic tendencies + ltransport = .TRUE. ! compute large-scale tracer transport + ntracer = 0 ! number of advected tracers + iforcing = 3 ! forcing of dynamics and transport by parameterized processes + msg_level = 2 ! detailed report during integration + ltimer = .TRUE. ! timer for monitoring the runtime of specific routines + timers_level = 10 ! performance timer granularity + check_uuid_gracefully = .TRUE. ! give only warnings for non-matching uuids + output = "nml" ! main switch for enabling/disabling components of the model output + lart = .TRUE. ! main switch for ART + debug_check_level = 2 +/ + +! art_nml: Aerosols and Reactive Trace gases extension------------------------------------------------- +&art_nml + lart_chem = .TRUE. ! enables chemistry + lart_pntSrc = .FALSE. ! enables point sources + lart_aerosol = .FALSE. ! main switch for the treatment of atmospheric aerosol + lart_chemtracer = .TRUE. ! main switch for the treatment of chemical tracer + lart_diag_out = .TRUE. ! + iart_seasalt = 0 ! enable seasalt + iart_init_gas = 4 ! Test versus '4' + cart_cheminit_file = "{inifile_nc}" + cart_chemtracer_xml = '{tracers_xml}' ! path to xml file for passive tracers + cart_cheminit_coord = '{inifile_nc}' + cart_cheminit_type = 'ERA' +/ + +! oem_nml: online emission module --------------------------------------------- +&oemctrl_nml + gridded_emissions_nc = '{emissionsgrid_nc}' + vertical_profile_nc = '{vertical_profile_nc}' + hour_of_year_nc = '{hour_of_year_nc}' + ens_lambda_nc = '{lambda_nc}' + ens_reg_nc = '{lambda_regions_nc}' + boundary_lambda_nc = '{bg_lambda_nc}' + boundary_regions_nc = '{bg_lambda_regions_nc}' + vegetation_indices_nc = '{vprm_coeffs_nc}' + chem_restart_nc = '{restart_file}' + restart_init_time = {restart_init_time} + vprm_par = 452.0801019142973, 356.9982743495175, 444.35135030708693, 483.71014017898636, 6.820000E+02, 549.8142194931744, 545.613483159301, 0.0E+00 + vprm_lambda = -0.1976385733575807, -0.16249650220700065, -0.15183296864822501, -0.12614291858843657, -1.141000E-01, -0.10418834453782252, -0.13114180960813507, 0.0E+00 + vprm_alpha = 0.3002548628277834, 0.22150160044981743, 0.20130383953759856, 0.238064533552737, 4.900000E-03, 0.19239326299324863, 0.405695555089534, 0.0E+00 + vprm_beta = 0.6884293574708447, 1.0916535677003347, 1.7074258216614222, 0.18946623368956772, 0.000000E+00, 0.17642838146641998, 0.41774465249044423, 0.0E+00 + vprm_tmin = 0.0, 0.0, 0.0, 2.0, 2.0, 5.0, 2.0, 0.0 + vprm_tmax = 40.0, 40.0, 40.0, 40.0, 40.0, 40.0, 40.0, 0.0 + vprm_topt = 20.0, 20.0, 20.0, 20.0, 20.0, 22.0, 18.0, 0.0 + vprm_tlow = 4.0, 0.0, 2.0, 4.0, 0.0, 0.0, 0.0, 0.0 +/ + + +! diffusion_nml: horizontal (numerical) diffusion ---------------------------- +&diffusion_nml + lhdiff_vn = .TRUE. ! diffusion on the horizontal wind field + lhdiff_temp = .TRUE. ! diffusion on the temperature field + lhdiff_w = .TRUE. ! diffusion on the vertical wind field + hdiff_order = 5 ! order of nabla operator for diffusion + itype_vn_diffu = 1 ! reconstruction method used for Smagorinsky diffusion + itype_t_diffu = 2 ! discretization of temperature diffusion + hdiff_efdt_ratio = 24.0 ! ratio of e-folding time to time step + hdiff_smag_fac = 0.025 ! scaling factor for Smagorinsky diffusion +/ + +! dynamics_nml: dynamical core ----------------------------------------------- +&dynamics_nml + iequations = 3 ! type of equations and prognostic variables + divavg_cntrwgt = 0.50 ! weight of central cell for divergence averaging + lcoriolis = .TRUE. ! Coriolis force +/ + +! extpar_nml: external data -------------------------------------------------- +&extpar_nml + itopo = 1 ! topography (0:analytical) + extpar_filename = '{cfg.input_files_scratch_extpar_filename}' ! filename of external parameter input file + n_iter_smooth_topo = 1,1 ! iterations of topography smoother + hgtdiff_max_smooth_topo = 750.0, 750.0 ! see Namelist doc + heightdiff_threshold = 2250.0, 1500.0 ! see Namelist doc +/ + +! initicon_nml: specify read-in of initial state ------------------------------ +&initicon_nml + init_mode = 2 + lread_ana = .false. + ltile_coldstart = .true. + ltile_init = .false. + ifs2icon_filename = '{inifile_nc}' + ana_varnames_map_file = '{cfg.input_files_scratch_map_filename}' +/ + +! grid_nml: horizontal grid -------------------------------------------------- +&grid_nml + dynamics_grid_filename = "{cfg.input_files_scratch_dynamics_grid_filename}" ! array of the grid filenames for the dycore + radiation_grid_filename = "{cfg.input_files_scratch_radiation_grid_filename}" ! array of the grid filenames for the radiation model + dynamics_parent_grid_id = 0 ! array of the indexes of the parent grid filenames + lredgrid_phys = .TRUE. ! .true.=radiation is calculated on a reduced grid + lfeedback = .TRUE. ! specifies if feedback to parent grid is performed + l_limited_area = .TRUE. ! .TRUE. performs limited area run + ifeedback_type = 2 ! feedback type (incremental/relaxation-based) + start_time = 0. ! Time when a nested domain starts to be active [s] +/ + +! gridref_nml: grid refinement settings -------------------------------------- +&gridref_nml + denom_diffu_v = 150. ! denominator for lateral boundary diffusion of velocity +/ + +! interpol_nml: settings for internal interpolation methods ------------------ +&interpol_nml + nudge_zone_width = 42 ! width of lateral boundary nudging zone + support_baryctr_intp = .FALSE. ! barycentric interpolation support for output + nudge_max_coeff = 0.069 + nudge_efold_width = 2.0 +/ + + +! io_nml: general switches for model I/O ------------------------------------- +&io_nml + itype_pres_msl = 5 ! method for computation of mean sea level pressure + itype_rh = 1 ! method for computation of relative humidity + lmask_boundary = .TRUE. ! mask out interpolation zone in output +/ + +! limarea_nml: settings for limited area mode --------------------------------- +&limarea_nml + itype_latbc = 1 ! 1: time-dependent lateral boundary conditions + dtime_latbc = 10800 ! time difference between 2 consecutive boundary data + latbc_boundary_grid = "{latbc_boundary_grid_nc}" ! Grid file defining the lateral boundary + latbc_path = "{cfg.icon_input_icbc}" ! Absolute path to boundary data + latbc_varnames_map_file = "{cfg.input_files_scratch_map_filename}" + latbc_filename = "era5_nudge_.nc" ! boundary data input filename + init_latbc_from_fg = .FALSE. ! .TRUE.: take lbc for initial time from first guess +/ + +! lnd_nml: land scheme switches ----------------------------------------------- +&lnd_nml + ntiles = 3 ! number of tiles + nlev_snow = 3 ! number of snow layers + lmulti_snow = .FALSE. ! .TRUE. for use of multi-layer snow model + idiag_snowfrac = 20 ! type of snow-fraction diagnosis + lsnowtile = .TRUE. ! .TRUE.=consider snow-covered and snow-free separately + itype_root = 2 ! root density distribution + itype_heatcond = 3 ! type of soil heat conductivity + itype_lndtbl = 4 ! table for associating surface parameters + itype_evsl = 4 ! type of bare soil evaporation + cwimax_ml = 5.e-4 ! scaling parameter for max. interception storage + c_soil = 1.75 ! surface area density of the evaporative soil surface + c_soil_urb = 0.5 ! same for urban areas + lseaice = .TRUE. ! .TRUE. for use of sea-ice model + llake = .TRUE. ! .TRUE. for use of lake model +/ + +! nonhydrostatic_nml: nonhydrostatic model ----------------------------------- +&nonhydrostatic_nml + iadv_rhotheta = 2 ! advection method for rho and rhotheta + ivctype = 2 ! type of vertical coordinate + itime_scheme = 4 ! time integration scheme + ndyn_substeps = 5 ! number of dynamics steps per fast-physics step + exner_expol = 0.333 ! temporal extrapolation of Exner function + vwind_offctr = 0.2 ! off-centering in vertical wind solver + damp_height = 12250.0 ! height at which Rayleigh damping of vertical wind starts + rayleigh_coeff = 1.5 ! Rayleigh damping coefficient + divdamp_order = 24 ! order of divergence damping + divdamp_type = 3 ! type of divergence damping + divdamp_fac = 0.004 ! scaling factor for divergence damping + igradp_method = 3 ! discretization of horizontal pressure gradient + l_zdiffu_t = .TRUE. ! specifies computation of Smagorinsky temperature diffusion + thslp_zdiffu = 0.02 ! slope threshold (temperature diffusion) + thhgtd_zdiffu = 125.0 ! threshold of height difference (temperature diffusion) + htop_moist_proc = 22500.0 ! max. height for moist physics + hbot_qvsubstep = 22500.0 ! height above which QV is advected with substepping scheme +/ + +! nwp_phy_nml: switches for the physics schemes ------------------------------ +&nwp_phy_nml + inwp_gscp = 2 ! cloud microphysics and precipitation + inwp_convection = 1 ! convection + lshallowconv_only = .FALSE. ! only shallow convection + inwp_radiation = 4 ! radiation + inwp_cldcover = 1 ! cloud cover scheme for radiation + inwp_turb = 1 ! vertical diffusion and transfer + inwp_satad = 1 ! saturation adjustment + inwp_sso = 1 ! subgrid scale orographic drag + inwp_gwd = 0 ! non-orographic gravity wave drag + inwp_surface = 1 ! surface scheme + latm_above_top = .TRUE. ! take into account atmosphere above model top for radiation computation + ldetrain_conv_prec = .TRUE. + efdt_min_raylfric = 7200. ! minimum e-folding time of Rayleigh friction + itype_z0 = 2 ! type of roughness length data + icapdcycl = 3 ! apply CAPE modification to improve diurnalcycle over tropical land + icpl_aero_conv = 1 ! coupling between autoconversion and Tegen aerosol climatology + icpl_aero_gscp = 1 ! coupling between autoconversion and Tegen aerosol climatology + dt_rad = $((dt_rad)) ! time step for radiation in s + dt_conv = $((dt_conv)) ! time step for convection in s (domain specific) + dt_sso = $((dt_sso)) ! time step for SSO parameterization + dt_gwd = $((dt_gwd)) ! time step for gravity wave drag parameterization +/ + +! nwp_tuning_nml: additional tuning parameters ---------------------------------- +&nwp_tuning_nml + itune_albedo = 1 ! reduced albedo (w.r.t. MODIS data) over Sahara + tune_gkwake = 1.8 + tune_gkdrag = 0.0 + tune_minsnowfrac = 0.3 +/ + +! radiation_nml: radiation scheme --------------------------------------------- +&radiation_nml + ecrad_isolver = 2 + irad_o3 = 7 ! ozone climatology + irad_aero = 6 ! aerosols + albedo_type = 2 ! type of surface albedo + vmr_co2 = 390.e-06 + vmr_ch4 = 1800.e-09 + vmr_n2o = 322.0e-09 + vmr_o2 = 0.20946 + vmr_cfc11 = 240.e-12 + vmr_cfc12 = 532.e-12 + direct_albedo_water = 3 + albedo_whitecap = 1 + ecrad_data_path = '/capstor/scratch/cscs/nponomar/icon-kit/externals/ecrad/data' +/ + +! sleve_nml: vertical level specification ------------------------------------- +&sleve_nml + min_lay_thckn = 20.0 ! layer thickness of lowermost layer + top_height = 23000.0 ! height of model top + stretch_fac = 0.65 ! stretching factor to vary distribution of model levels + decay_scale_1 = 4000.0 ! decay scale of large-scale topography component + decay_scale_2 = 2500.0 ! decay scale of small-scale topography component + decay_exp = 1.2 ! exponent of decay function + flat_height = 16000.0 ! height above which the coordinate surfaces are flat +/ + +! transport_nml: tracer transport --------------------------------------------- +&transport_nml + ivadv_tracer = 3, 3, 3, 3, 3, 3 ! tracer specific method to compute vertical advection + itype_hlimit = 3, 4, 4, 4, 4, 4 ! type of limiter for horizontal transport + ihadv_tracer = 52, 2, 2, 2, 2, 2 ! tracer specific method to compute horizontal advection + llsq_svd = .TRUE. ! use SV decomposition for least squares design matrix +/ + +! turbdiff_nml: turbulent diffusion ------------------------------------------- +&turbdiff_nml + tkhmin = 0.75 ! scaling factor for minimum vertical diffusion coefficient + tkmmin = 0.75 ! scaling factor for minimum vertical diffusion coefficient + pat_len = 750.0 ! effective length scale of thermal surface patterns + c_diff = 0.2 ! length scale factor for vertical diffusion of TKE + rat_sea = 0.8 ! controls laminar resistance for sea surface + ltkesso = .TRUE. ! consider TKE-production by sub-grid SSO wakes + frcsmot = 0.2 ! these 2 switches together apply vertical smoothing of the TKE source terms + imode_frcsmot = 2 ! in the tropics (only), which reduces the moist bias in the tropical lower troposphere + itype_sher = 3 ! type of shear forcing used in turbulence + ltkeshs = .TRUE. ! include correction term for coarse grids in hor. shear production term + a_hshr = 2.0 ! length scale factor for separated horizontal shear mode + icldm_turb = 1 ! mode of cloud water representation in turbulence + ldiff_qi = .TRUE. +/ + +! output_nml: specifies an output stream -------------------------------------- +&output_nml + filetype = 4 ! output format: 2=GRIB2, 4=NETCDFv2 + dom = 1 ! write domain 1 only + output_bounds = 0., 10000000., 3600. ! start, end, increment + steps_per_file = 1 ! number of steps per file + mode = 1 ! 1: forecast mode (relative t-axis), 2: climate mode (absolute t-axis) + include_last = .TRUE. + output_filename = 'ICON-ART-UNSTR' + filename_format = '{output_directory}/_' ! file name base + steps_per_file_inclfirst = .FALSE. + output_grid = .TRUE. + remap = 0 ! 1: remap to lat-lon grid + !north_pole = -170.,40. ! definition of north_pole for rotated lat-lon grid + reg_lon_def = -8.25,0.05,17.65 ! + reg_lat_def = 40.75,0.05,58.85 ! + ml_varlist = 'group:PBL_VARS', + 'group:ATMO_ML_VARS', + 'group:precip_vars', + 'group:land_vars', + 'group:nh_prog_vars', + 'group:ART_CHEMISTRY', + 'z_mc', 'z_ifc', + 'topography_c', + 'group:ART_PASSIVE', + 'group:ART_AEROSOL' +/ + +! output_nml: specifies an output stream -------------------------------------- +&output_nml + filetype = 4 ! output format: 2=GRIB2, 4=NETCDFv2 + dom = 1 ! write domain 1 only + output_bounds = {output_init}, 10000000., 604800. ! start, end, increment 518400 + steps_per_file = 1 ! number of steps per file + mode = 1 ! 1: forecast mode (relative t-axis), 2: climate mode (absolute t-axis) + include_last = .TRUE. + output_filename = 'ICON-ART-OEM-INIT' + filename_format = '{output_directory}/_' ! file name base + steps_per_file_inclfirst = .FALSE. + output_grid = .TRUE. + remap = 0 ! 1: remap to lat-lon grid + ml_varlist = 'group:ART_CHEMISTRY' +/ +EOF + +handle_error(){{ + set +e + # Check for invalid pointer error at the end of icon-art + if grep -q "free(): invalid pointer" {cfg.logfile} && grep -q "clean-up finished" {cfg.logfile}; then + exit 0 + else + exit 1 + fi + set -e +}} +cp {cfg.icon_executable} icon +srun ../input/wrapper_icon.sh ./icon || handle_error \ No newline at end of file diff --git a/cases/icon-art-CTDAS2/authentification.ipynb b/cases/icon-art-CTDAS2/authentification.ipynb new file mode 100644 index 00000000..8e8ffd64 --- /dev/null +++ b/cases/icon-art-CTDAS2/authentification.ipynb @@ -0,0 +1,83 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# For access to the NASA Earthdata API, you need to create a .netrc file in your home directory.\n", + "# This script will create the file and prompt you for your NASA Earthdata login credentials.\n", + "from getpass import getpass\n", + "import os\n", + "from subprocess import Popen\n", + "urs = 'urs.earthdata.nasa.gov' # Earthdata URL to call for authentication\n", + "prompts = ['Enter NASA Earthdata Login Username \\n(or create an account at urs.earthdata.nasa.gov): ',\n", + " 'Enter NASA Earthdata Login Password: ']\n", + "homeDir = os.path.expanduser(\"~\") + os.sep\n", + "with open(homeDir + '.netrc', 'w') as file:\n", + " file.write('machine {} login {} password {}'.format(urs, getpass(prompt=prompts[0]), getpass(prompt=prompts[1])))\n", + " file.close()\n", + "with open(homeDir + '.urs_cookies', 'w') as file:\n", + " file.write('')\n", + " file.close()\n", + "with open(homeDir + '.dodsrc', 'w') as file:\n", + " file.write('HTTP.COOKIEJAR={}.urs_cookies\\n'.format(homeDir))\n", + " file.write('HTTP.NETRC={}.netrc'.format(homeDir))\n", + " file.close()\n", + "Popen('chmod og-rw ~/.netrc', shell=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Log in to https://cpauth.icos-cp.eu , tick \"I accept the ICOS data license\" and then \"Save profile\" to be allowed data downloading. \n", + "# Then run this cell to save a configuration file that will be used by the icoscp package to download data.\n", + "from icoscp_core.icos import auth\n", + "auth.init_config_file()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "proc-chain", + "language": "python", + "name": "python3" + }, + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/cases/icon-art-CTDAS2/config.yaml b/cases/icon-art-CTDAS2/config.yaml new file mode 100644 index 00000000..439ad3ef --- /dev/null +++ b/cases/icon-art-CTDAS2/config.yaml @@ -0,0 +1,253 @@ +# Configuration file for the 'icon-art-CTDAS' case with ICON + +# From the `icon-wcp` environment: +# - spack install nco@4.9.0 +# - spack install icontools@c2sm-master%gcc +# - spack install cdo + +workflow: icon +constraint: gpu +run_on: cpu +compute_queue: normal +nodes: 2 +ntasks_per_node: 4 +startdate: 2021-01-01T00:00:00Z +enddate: 2021-12-31T23:59:59Z +restart_step: PT10D # = CTDAS cycle length + +####### Tracer options +# The tracers XML file will be generated on-the-fly +tracers: + TRCO2_A: + oem_cat: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" + oem_vp: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" + oem_tp: "GNFR_A-CO2, GNFR_B-CO2, GNFR_C-CO2, GNFR_D-CO2, GNFR_A-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_G-CO2, GNFR_H-CO2, GNFR_I-CO2, GNFR_J-CO2, GNFR_L-CO2, GNFR_L-CO2" + TRCO2_BG: + init_name: "CO2" + CO2_RA: + oem_ftype: "resp" + CO2_GPP: + oem_ftype: "gpp" + TRCO2_A-XXX: + bg: "TRCO2_BG" + ra: "CO2_RA" + gpp: "CO2_GPP" + biosource: + oem_cat: "co2fire, allcropsource, allwoodsource, lakeriveremis, cflx" + oem_vp: "A-CO2, A-CO2, A-CO2, A-CO2, A-CO2" + oem_tp: "GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2" + biosink: + oem_cat: "biofuelcropsource, biofuelwoodsource, mflx" + oem_vp: "A-CO2, A-CO2, A-CO2" + oem_tp: "GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2" + EM_TRCO2_A: + oem_cat: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" + oem_vp: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" + oem_tp: "GNFR_A-CO2, GNFR_B-CO2, GNFR_C-CO2, GNFR_D-CO2, GNFR_A-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_G-CO2, GNFR_H-CO2, GNFR_I-CO2, GNFR_J-CO2, GNFR_L-CO2, GNFR_L-CO2" + EM_CO2_RA: + oem_ftype: "resp" + EM_CO2_GPP: + oem_ftype: "gpp" +####### CTDAS options. +# First of all, do the following in your ~ (home) folder, e.g., +# git clone -b ctdas-icon https://git.wur.nl/ctdas/CTDAS.git ~/ctdas-icon +# We will PATCH that code +# Execute `start_ctdas_icon.sh $SCRATCH ctdas_procchain` +# which will put the CTDAS files into $SCRATCH/ctdas_procchain. +# We will then 'patch' this CTDAS installation with the required files, +# - ctdas-icon.py [which runs CTDAS; and imports the following patched classes]: + # - statevector class [which, ultimately, defines our ensemble members] + # - observation operator (obsoperator) class [which, ultimately, runs the ICON scripts & post-processing sampler] + # - observations class [which, ultimately, defines how to ingest the observations] + # - optimizer class [which, ultimately, defines how to do localization] +# - rc-cteco2 file [which, ultimately, is how we pass general input like folder names etc to CTDAS] +# - rc-job file [which, ultimately, is the setup for CTDAS like lag times, etc.] +CTDAS: + nlag: 2 + tracer: co2 + regions: basegrid # choose: basegrid or parentgrid + nensembles: 186 + # nregions: # read from cells->regions file + restart_init_time: 86400 # 1 day in seconds; using Michael Steiner's "overwriting" restart mechanism + ctdas_cycle: 10 # days + ctdas_nlag: 2 + nboundaries: 8 + lambdas: # The first 16 lambdas must be the respiration and uptake ones [even if not relevant, e.g., for a CH4 simulation], followed by the oem_cat categories in the xml file, in order of appearance, but excluding any + - 1,1,1,1,1,1,1,1 # Respiration (Evergreen Forest, Deciduous Forest, Mixed Forest, Shrubland, Savanna, Cropland, Grassland, Urban/Other) + - 1,1,1,1,1,1,1,1 # Uptake (E, D, M, S, SV, C, G, U) + - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2 # Anthropogenic CO2 (ensemble tracer categories that are optimized) + obs: + # Run the 'authentification.ipynb' notebook to get access to ICOS and/or NASA Earthdata (OCO2) data + fetch_ICOS: True + ICOS_path: /capstor/scratch/cscs/ekoene/ICOS/ + fetch_OCO2: True + OCO2_path: /capstor/scratch/cscs/ekoene/OCO2 + global_inputs: + inventories: + - /capstor/scratch/cscs/ekoene/inventories/INV_20180102.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180112.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180122.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180201.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180211.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180221.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180303.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180313.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180323.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180402.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180412.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180422.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180502.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180512.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180522.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180601.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180611.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180621.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180701.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180711.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180721.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180731.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180810.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180820.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180830.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180909.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180919.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20180929.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181009.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181019.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181029.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181108.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181118.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181128.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181208.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181218.nc + - /capstor/scratch/cscs/ekoene/inventories/INV_20181228.nc + grid: + - /users/ekoene/CTDAS_inputs/icon_europe_DOM01.parent.nc + - /users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc + - ERA5/lateral_boundary.grid.nc # This is guaranteed to exist due to the ERA5/CAMS preprocessing + extpar: + - /users/ekoene/CTDAS_inputs/icon_extpar_EriksGrid.nc + VPRM: + - /users/ekoene/CTDAS_inputs/VPRM_indices_ICON_datestr.nc + OEM: + - /capstor/scratch/cscs/ekoene/inventories/icon_with_tno_emissions/vertical_profiles.nc # It /should/ be these + - /capstor/scratch/cscs/ekoene/inventories/icon_with_tno_emissions/hourofyear.nc + - /users/ekoene/CTDAS_inputs/vertical_profiles_t.nc # ... but these old files are still used + - /users/ekoene/CTDAS_inputs/hourofyear8784.nc + ctdas_path: /users/ekoene/ctdas-icon + ctdas_patch: + templates: + - ctdas_patch/template.py + - ctdas_patch/template.rc # ADD THESE! + - ctdas_patch/template.jb # ADD THESE! + da/statevectors: ctdas_patch/statevector_baseclass_icos_cities.py + da/observations: ctdas_patch/obs_class_ICOS_OCO2.py + da/obsoperators: ctdas_patch/obsoperator_ICOS_OCO2.py + da/optimizers: ctdas_patch/optimizer_baseclass_icos_cities.py + da/rc/cteco2: ctdas_patch/carbontracker_icon_oco2.rc + da/tools/icon: + - ctdas_patch/utilities.py + - ctdas_patch/icon_helper.py + - ctdas_patch/icon_sampler.py + + +# # CTDAS ------------------------------------------------------------------------ +# ctdas_restart = False +# ctdas_BG_run = False +# # CTDAS cycle length in days +# ctdas_cycle = int(restart_cycle_window / 60 / 60 / 24) +# ctdas_nlag = 2 +# ctdas_tracer = 'co2' +# # CTDAS number of regions and cells->regions file +# ctdas_nreg_params = 21184 +# ctdas_regionsfile = vprm_regions_synth_nc # <--- Create +# # Number of boundaries, and boundaries mask/regions file +# ctdas_bg_params = 8 +# # Number of ensemble members (make this consistent with your XML file!) +# ctdas_optimizer_nmembers = 180 +# # CTDAS path +# ctdas_dir = '/scratch/snx3000/ekoene/ctdas-icon/exec' +# # Distance file from region to region (shape: [N_reg x N_reg]), for statevector localization +# ctdas_sv_distances = '/scratch/snx3000/ekoene/CTDAS_cells2cells.nc' +# # Distance file from region to stations (shape: [N_reg x N_obs]), for observation localization +# ctdas_op_loc_coeffs = '/scratch/snx3000/ekoene/cells2stations.nc' +# # Directory containing a file with all the observations +# ctdas_datadir = '/scratch/snx3000/ekoene/ICOS_extracted/2018/' +# # CTDAS localization setting +# ctdas_system_localization = 'spatial' +# # CTDAS statevector length for one window +# ctdas_nparameters = 2 * ctdas_nreg_params + 8 # 2 (A , VPRM) * ctdas_nreg_params + ctdas_bg_params +# # Extraction template +# ctdas_extract_template = '/scratch/snx3000/ekoene/processing-chain/cases/VPRM_EU_ERA5_22/extract_template_icos_EU' +# # ICON runscript template +# ctdas_ICON_template = '/scratch/snx3000/ekoene/processing-chain/cases/VPRM_EU_ERA5_22/runscript_template_restart_icos_EU' +# # Full path to SBATCH template that can submit extraction scripts +# ctdas_sbatch_extract_template = '/scratch/snx3000/ekoene/processing-chain/cases/VPRM_EU_ERA5_22/sbatch_extract_template' +# # Full path to possibly time-varying emissionsgrid (if not time-varying, supply a filename without {}!) +# ctdas_oae_grid = "/scratch/snx3000/ekoene/inventories/INV_{}.nc" +# ctdas_oae_grid_fname = '%Y%m%d' # Specifies the naming scheme to use for the emission grids +# # Spinup time length +# # Restart file for the first simulation +# ctdas_first_restart_init = '/scratch/snx3000/ekoene/processing-chain/work/VPRM_EU_ERA5_22/2018010100_0_240/icon/output_INIT' +# # Number of vertical levels +# nvlev = 60 +# # NOT NEEDED FOR ANYTHING, EXCEPT TO MAKE CTDAS RUN +# ctdas_obsoperator_home = '/scratch/snx3000/msteiner/ctdas_test/exec/da/rc/stilt' +# ctdas_obsoperator_rc = os.path.join(ctdas_obsoperator_home, 'stilt_0.rc') +# ctdas_regtype = 'olson19_oif30' + +cdo_nco_cmd: | + uenv start icon-wcp --ignore-tty << 'EOF' + . /capstor/scratch/cscs/ekoene/tmp/spack-c2sm/setup-env.sh /user-environment/ + spack load icontools cdo nco + +cdo_nco_cmd_post: | + EOF + +eccodes_dir: ./input/eccodes_definitions +art_input_folder: ./input/icon-art-oem/ART + +walltime: + prepare_icon: '00:15:00' + prepare_art_global: '00:10:00' + icon: '00:05:00' + prepare_CTDAS: '00:00:00' + +meteo: + nudging_step: 3 + fetch_era5: True + url: https://cds-beta.climate.copernicus.eu/api + key: 1c2e45b1-dd08-4bc4-90c8-15c06304ae69 + era5_splitjob: ICBC/icon_era5_splitfiles.sh + era5_inijob: ICBC/icon_era5_inicond.sh + era5_nudgingjob: ICBC/icon_era5_nudging.sh + partab: mypartab + +chem: + nudging_step: 3 + fetch_CAMS: True + url: https://ads-beta.atmosphere.copernicus.eu/api + key: 1c2e45b1-dd08-4bc4-90c8-15c06304ae69 + cams_inijob: ICBC/icon_species_inicond.sh + cams_nudgingjob: ICBC/icon_species_nudging.sh + +input_files: + radiation_grid_filename: /users/ekoene/CTDAS_inputs/icon_europe_DOM01.parent.nc + dynamics_grid_filename: /users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc + extpar_filename: /users/ekoene/CTDAS_inputs/icon_extpar_EriksGrid.nc + map_filename: ./cases/icon-art-CTDAS/map_file.ana + wrapper_filename: ./cases/icon-art-CTDAS/wrapper_icon.sh + +icon: + executable: /capstor/scratch/cscs/ekoene/tmp/spack-c2sm/spack/opt/spack/linux-sles15-neoverse_v2/nvhpc-24.3/icon-develop-sytqk6o7h5y3imrsevsswc2inxaegbpx/bin/icon + runjob_filename: ICON/ICON_template.job +# # era5_inijob: icon_era5_inicond.sh +# # era5_nudgingjob: icon_era5_nudging.sh +# species_inijob: icon_species_inicond.sh +# species_nudgingjob: icon_species_nudging.sh +# output_writing_step: 6 +# compute_queue: normal +# np_tot: 32 +# np_io: 3 +# np_restart: 1 +# np_prefetch: 1 \ No newline at end of file diff --git a/cases/icon-art-CTDAS2/ctdas_patch/carbontracker_icon_oco2.rc b/cases/icon-art-CTDAS2/ctdas_patch/carbontracker_icon_oco2.rc new file mode 100644 index 00000000..e4b89444 --- /dev/null +++ b/cases/icon-art-CTDAS2/ctdas_patch/carbontracker_icon_oco2.rc @@ -0,0 +1,31 @@ +! CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +! Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +! updates of the code. See also: http://www.carbontracker.eu. +! +! This program is free software: you can redistribute it and/or modify it under the +! terms of the GNU General Public License as published by the Free Software Foundation, +! version 3. This program is distributed in the hope that it will be useful, but +! WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +! FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. +! +! You should have received a copy of the GNU General Public License along with this +! program. If not, see . + +!!! Info for the CarbonTracker data assimilation system + +! For our case, 2*grid size + 8 +nparameters : {nregs*ncats+cfg.CTDAS_nboundaries} + +! ICOS stuff +datadir : {cfg.case_root / "global_inputs" / "ICOS"} +obs.input.dir : {cfg.case_root / "global_inputs" / "ICOS"} +obspack.input.dir : {cfg.case_root / "global_inputs" / "ICOS"} +regtype : olson19_oif30 + +! OCO2 stuff +obs.column.input.dir : {cfg.case_root / "global_inputs" / "OCO2"} +obs.column.ncfile : OCO2__ctdas.nc +obs.column.selection.variables : quality_flag +obs.column.selection.criteria : == 0 +mdm.calculation : 0.015 +sigma_scale : 0.5 \ No newline at end of file diff --git a/cases/icon-art-CTDAS2/ctdas_patch/icon_helper.py b/cases/icon-art-CTDAS2/ctdas_patch/icon_helper.py new file mode 100644 index 00000000..2020d30d --- /dev/null +++ b/cases/icon-art-CTDAS2/ctdas_patch/icon_helper.py @@ -0,0 +1,1329 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Created on Mon Jul 22 15:03:02 2019 + +This class contains helper functions mainly for sampling WRF-Chem, but a +few are also needed by the WRF-Chem column observation operator. + +@author: friedemann + +Modified on June 26, 10:40:12, 2023 +Adaptation for sampling ICON instead of WRF. + +@author: David Ho +""" + +# Instructions for pylint: +# pylint: disable=too-many-instance-attributes +# pylint: disable=W0201 +# pylint: disable=C0301 +# pylint: disable=E1136 +# pylint: disable=E1101 + + +import os +import shutil +import re +import glob +import bisect +import copy +import numpy as np +import netCDF4 as nc +import datetime as dt +#import wrf # Not needed, since working on ICON +#import f90nml # Not needed, used for reading wrf namelist +import pickle +import xarray as xr +import pandas as pd + +# CTDAS modules +import da.tools.io4 as io +from da.tools.icon.utilities import utilities + +# Erik added: +from datetime import datetime, timedelta + + +class ICON_Helper(object): + """Contains helper functions for sampling WRF-Chem""" + def __init__(self, settings): + self.settings = settings + + #def __init__(self): # Use this part for offline testing + # pass + + def validate_settings(self, needed_items=[]): + """ + This is based on WRFChemOO._validate_rc + """ + + if len(needed_items)==0: + return + + for key in needed_items: + if key not in self.settings: + msg = "Missing a required value in settings: %s" % key + raise IOError(msg) + + + @staticmethod + def get_pressure_boundaries_paxis(p_axis, p_surf): + """ + Arguments + --------- + p_axis (:class:`array-like`) + Pressure at mid points of layers + p_surf (:class:`numeric`) + Surface pressure + Output + ------ + Pressure at layer boundaries + """ + + #pb = np.array([float("nan")]*(len(p_axis)+1)) + #pb[0] = p_surf + # + #for nl in range(len(pb)-1): + # pb[nl+1] = pb[nl] + 2*(p_axis[nl] - pb[nl]) + # ^ commented out by David coz it didn't work + # v Added by David + p_full = np.insert(p_axis, 0, psurf, axis=1) # Insert p_surf to the first index + pb = np.array([float("nan")]*(len(p_axis)+1)) + pb[0] = p_surf + + for nl in range(len(pb)-1): + pb[nl+1] = 0.5*( p_full[nl] + p_full[nl+1] ) + + return pb + + @staticmethod + def get_pressure_boundaries_znw(znw, p_surf, p_top): + """ + Arguments + --------- + ZNW (:class:`ndarray`) + Eta coordinates of z-staggered WRF grid. For each + observation (2D) + p_surf (:class:`ndarray`) + Surface pressure (1D) + p_top (:class:`ndarray`) + Top-of-atmosphere pressure (1D) + Output + ------ + Pressure at layer boundaries + + CAVEATS + ------- + Maybe I should rather use P_HYD? Well, Butler et al. 2018 + (https://www.geosci-model-dev-discuss.net/gmd-2018-342/) used + znu and surface pressure to compute "WRF midpoint layer + pressure". + + For WRF it would be more consistent to interpolate to levels. + See also comments in code. + """ + + return znw*(p_surf-p_top) + p_top + + + @staticmethod + def get_int_coefs(pb_ret, pb_mod, level_def): + """ + Computes a coefficients matrix to transfer a model profile onto + a retrieval pressure axis. + + If level_def=="layer_average", this assumes that profiles are + constant in each layer of the retrieval, bound by the pressure + boundaries pb_ret. In this case, the WRF model layer is treated + in the same way, and coefficients integrate over the assumed + constant model layers. This works with non-staggered WRF + variables (on "theta" points). However, this is actually not how + WRF is defined, and the implementation should be changed to + z-staggered variables. Details for this change are in a comment + at the beginning of the code. + + If level_def=="pressure_boundary" (IMPLEMENTATION IN PROGRESS), + assumes that profiles, kernel and pwf are defined at pressure + boundaries that don't have a thickness (this is how OCO-2 data + are defined, for example). In this case, the coefficients + linearly interpolate adjacent model level points. This is + incompatible with the treatment of WRF in the above-described + layer-average assumption, but is closer to how WRF is actually + defined. The exception is that pb_mod is still constructed and + non-staggered variables are not defined at psurf. This can only + be fixed by switching to z-staggered variables. + + In cases where retrieval surface pressure is higher than model + surface pressure, and in cases where retrieval top pressure is + lower than model top pressure, the model profile will be + extrapolated with constant tracer mixing ratios. In cases where + retrieval surface pressure is lower than model surface pressure, + and in cases where retrieval top pressure is higher than model + top pressure, only the parts of the model column that fall + within the retrieval presure boundaries are sampled. + + Arguments + --------- + pb_ret (:class:`array_like`) + Pressure boundaries of the retrieval column + pb_mod (:class:`array_like`) + Pressure boundaries of the model column + level_def (:class:`string`) + "layer_average" or "pressure_boundary" (IMPLEMENTATION IN + PROGRESS). Refers to the retrieval profile. + + Note 2021-09-13: Inspected code for pressure_boundary. + Should be correct. Interpolates linearly between two model + levels. + + + Returns + ------- + coefs (:class:`array_like`) + Integration coefficient matrix. Each row sums to 1. + + Usage + ----- + .. code-block:: python + + import numpy as np + pb_ret = np.linspace(900., 50., 5) + pb_mod = np.linspace(1013., 50., 7) + model_profile = 1. - np.linspace(0., 1., len(pb_mod)-1)**3 + coefs = get_int_coefs(pb_ret, pb_mod, "layer_average") + retrieval_profile = np.matmul(coefs, model_profile) + """ + + if level_def == "layer_average": + # This code assumes that WRF variables are constant in + # layers, but they are defined on levels. This can be seen + # for example by asking wrf.interplevel for the value of a + # variable that is defined on the mass grid ("theta points") + # at a pressure slightly higher than the pressure on its + # grid (wrf.getvar(ncf, "p")), it returns nan. So There is + # no extrapolation. There are no layers. There are only + # levels. + # In addition, this page here: + # https://www.openwfm.org/wiki/How_to_interpret_WRF_variables + # says that to find values at theta-points of a variable + # living on u-points, you interpolate linearly. That's the + # other way around from what I would do if I want to go from + # theta to staggered. + # WRF4.0 user guide: + # - ungrib can interpolate linearly in p or log p + # - real.exe comes with an extrap_type namelist option, that + # extrapolates constantly BELOW GROUND. + # This would mean the correct way would be to integrate over + # a piecewise-linear function. It also means that I really + # want the value at surface level, so I'd need the CO2 + # fields on the Z-staggered grid ("w-points")! Interpolate + # the vertical in p with wrf.interp1d, example: + # wrf.interp1d(np.array(rh.isel(south_north=1, west_east=0)), + # np.array(p.isel(south_north=1, west_east=0)), + # np.array(988, 970)) + # (wrf.interp1d gives the same results as wrf.interplevel, + # but the latter just doesn't want to work with single + # columns (32,1,1), it wants a dim>1 in the horizontal + # directions) + # So basically, I can keep using pb_ret and pb_mod, but it + # would be more accurate to do the piecewise-linear + # interpolation and the output matrix will have 1 more + # value in each dimension. + + # Calculate integration weights by weighting with layer + # thickness. This assumes that both axes are ordered + # psurf to ptop. + coefs = np.ndarray(shape=(len(pb_ret)-1, len(pb_mod)-1)) + coefs[:] = 0. + + # Extend the model pressure grid if retrieval encompasses + # more. + pb_mod_tmp = copy.deepcopy(pb_mod) + + # In case the retrieval pressure is higher than the model + # surface pressure, extend the lowest model layer. + if pb_mod_tmp[0] < pb_ret[0]: + pb_mod_tmp[0] = pb_ret[0] + + # In case the model doesn't extend as far as the retrieval, + # extend the upper model layer upwards. + if pb_mod_tmp[-1] > pb_ret[-1]: + pb_mod_tmp[-1] = pb_ret[-1] + + # For each retrieval layer, this loop computes which + # proportion falls into each model layer. + for nret in range(len(pb_ret)-1): + + # 1st model pressure boundary index = the one before the + # first boundary with lower pressure than high-pressure + # retrieval layer boundary. + model_lower = pb_mod_tmp < pb_ret[nret] + id_model_lower = model_lower.nonzero()[0] + id_min = id_model_lower[0]-1 + + # Last model pressure boundary index = the last one with + # higher pressure than low-pressure retrieval layer + # boundary. + model_higher = pb_mod_tmp > pb_ret[nret+1] + + id_model_higher = model_higher.nonzero()[0] + + if len(id_model_higher) == 0: + #id_max = id_min + raise ValueError("This shouldn't happen. Debug.") + else: + id_max = id_model_higher[-1] + + # By the way, in case there is no model level with + # higher pressure than the next retrieval level, + # id_max must be the same as id_min. + + # For each model layer, find out how much of it makes up this + # retrieval layer + for nmod in range(id_min, id_max+1): + if (nmod == id_min) & (nmod != id_max): + # Part of 1st model layer that falls within + # retrieval layer + coefs[nret, nmod] = pb_ret[nret] - pb_mod_tmp[nmod+1] + elif (nmod != id_min) & (nmod == id_max): + # Part of last model layer that falls within + # retrieval layer + coefs[nret, nmod] = pb_mod_tmp[nmod] - pb_ret[nret+1] + elif (nmod == id_min) & (nmod == id_max): + # id_min = id_max, i.e. model layer encompasses + # retrieval layer + coefs[nret, nmod] = pb_ret[nret] - pb_ret[nret+1] + else: + # Retrieval layer encompasses model layer + coefs[nret, nmod] = pb_mod_tmp[nmod] - pb_mod_tmp[nmod+1] + + coefs[nret, :] = coefs[nret, :]/sum(coefs[nret, :]) + + # I tested the code with many cases, but I'm only 99.9% sure + # it works for all input. Hence a test here that the + # coefficients sum to 1 and dump the data if not. + sum_ = np.abs(coefs.sum(1) - 1) + if np.any(sum_ > 2.*np.finfo(sum_.dtype).eps): + dump = dict(pb_ret=pb_ret, + pb_mod=pb_mod, + level_def=level_def) + fp = "int_coefs_dump.pkl" + with open(fp, "w") as f: + pickle.dump(dump, f, 0) + + msg_fmt = "Something doesn't sum to 1. Arguments dumped to: %s" + raise ValueError(msg_fmt % fp) + + elif level_def=="pressure_boundary": + #msg = "level_def is pressure_boundary. Implementation not complete." + ##logging.error(msg) + #raise ValueError(msg) + # Note 2021-09-13: Inspected the code. Should be correct. + + # Go back to pressure midpoints for model... + # Change this line to p_mod = pb_mod for z-staggered + # variables + p_mod = pb_mod[1:] - 0.5*np.diff(pb_mod) # Interpolate linearly in pressure space + + coefs = np.ndarray(shape=(len(pb_ret), len(pb_mod)-1)) + coefs[:] = 0. + + # For each retrieval pressure level, compute linear + # interpolation coefficients + for nret in range(len(pb_ret)): + nmod_list = (p_mod < pb_ret[nret]).nonzero()[0] + if(len(nmod_list)>0): + nmod = nmod_list[0] - 1 + if nmod==-1: + # Constant extrapolation at surface + nmod = 0 + coef = 1. + else: + # Normal case: + coef = (pb_ret[nret]-p_mod[nmod+1])/(p_mod[nmod]-p_mod[nmod+1]) + else: + # Constant extrapolation at atmosphere top + nmod = len(p_mod)-2 + coef=0. + + coefs[nret, nmod] = coef + coefs[nret, nmod+1] = 1.-coef + + else: + msg = "Unknown level_def: " + level_def + raise ValueError(msg) + + return coefs + + @staticmethod + def get_pressure_weighting_function(pressure_boundaries, rule): + """ + Compute pressure weighting function according to 'rule'. + Valid rules are: + - simple (=layer thickness) + - connor2008 (not implemented) + """ + if rule == 'simple': + pwf = np.abs(np.diff(pressure_boundaries)/np.ptp(pressure_boundaries)) + else: + raise NotImplementedError("Rule %s not implemented" % rule) + + return pwf + + + ### David: Original function from ctdas-wrf ### + ### Keeping here as reference. ### + + def sample_total_columns(self, dat, loc, fields_list): + """ + Sample total_columns of fields_list in WRF output in + self.settings["run_dir"] at the location id_xy in domain, id_t + in all wrfout-times. Files and indices therein are recognized + by id_t and file_time_start_indices. + All quantities needed for computing total columns from profiles + are in dat (kernel, prior, ...). + + Arguments + --------- + dat (:class:`list`) + Result of wrfhelper.read_sampling_coords. Used here: prior, + prior_profile, kernel, psurf, pressure_axis, [, pwf] + If psurf or any of pressure_axis are nan, wrf's own + surface pressure is used and pressure_axis constructed + from this and the number of levels in the averaging kernel. + This allows sampling with synthetic data that don't have + pressure information. This only works with level_def + "layer_average". + If pwf is not present or nan, a simple one is created, for + level_def "layer_average". + loc (:class:`dict`) + A dictionary with all location-related input for sampling, + computed in wrfout_sampler. Keys: + id_xy, domain: Domain coordinates + id_t: Timestep (continous throughout all files) + frac_t: Interpolation coeficient between id_t and id_t+1: + t_obs = frac_t*t[id_t] + (1-frac_t)*t[id_t+1]) + file_start_time_indices: Time index at which a new wrfout + file starts + files: names of wrfout files. + fields_list (:class:`list`) + The fields to sample total columns from. + + Output + ------ + sampled_columns (:class:`array`) + A 2D-array of sampled columns. + Shape: (len(dat["prior"]), len(fields_list)) + """ + + # Initialize output + tc = np.ndarray(shape=(len(dat["prior"]), len(fields_list)), dtype=float) + tc[:] = float("nan") + + # Process by domain + UD = list(set(loc["domain"])) + # Added by David, above ^ returns [0,1] where domain 0 doesn't exsist + UD = [1] + for dom in UD: + idd = np.nonzero(loc["domain"] == dom)[0] + # Process by id_t + UT = list(set(loc["id_t"][idd])) + for time_id in UT: + # Coordinates to process + idt = idd[np.nonzero(loc["id_t"][idd] == time_id)[0]] + # Get tracer ensemble profiles + profiles = self._read_and_intrp_v(loc, fields_list, time_id, idt) + # List, len=len(fields_list), shape of each: (len(idt),nz) + # Get pressure axis: + #paxis = self.read_and_intrp(wh_names, id_ts, frac_t, id_xy, "P_HYD")/1e2 # Pa -> hPa + psurf = self._read_and_intrp_v(loc, ["PSFC"], time_id, idt)[0]/1.e2 # Pa -> hPa + # Shape: (len(idt),) + ptop = float(self.namelist["domains"]["p_top_requested"])/1.e2 + # Shape: (len(idt),) + znw = self._read_and_intrp_v(loc, ["ZNW"], time_id, idt)[0] + #Shape:(len(idt),nz) + + # DONE reading from file. + # Here it starts to make sense to loop over individual observations + for nidt in range(len(idt)): + nobs = idt[nidt] + # Construct model pressure layer boundaries + pb_mod = self.get_pressure_boundaries_znw(znw[nidt, :], psurf[nidt], ptop) + + if (np.diff(pb_mod) >= 0).any(): + msg = ("Model pressure boundaries for observation %d " + \ + "are not monotonically decreasing! Investigate.") % nobs + raise ValueError(msg) + + # Construct retrieval pressure layer boundaries + if dat["level_def"][nobs] == "layer_average": + if np.any(np.isnan(dat["pressure_levels"][nobs])) \ + or np.isnan(dat["psurf"][nobs]): + # Code for synthetic data without a pressure axis, + # but with an averaging kernel: + # Use wrf's surface and top pressure + nlayers = len(dat["averaging_kernel"][nobs]) + pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) + else: + nlayers = len(dat["averaging_kernel"][nobs]) + pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) + # Below commented out by David + # Because somehow doesn't work + #pb_ret = self.get_pressure_boundaries_paxis( + # dat["pressure_levels"][nobs], + # dat["psurf"][nobs]) + elif dat["level_def"][nobs] == "pressure_boundary": + if np.any(np.isnan(dat["pressure_levels"][nobs])): + # Code for synthetic data without a pressure axis, + # but with an averaging kernel: + # Use wrf's surface and top pressure + nlevels = len(dat["averaging_kernel"][nobs]) + pb_ret = np.linspace(psurf[nidt], ptop, nlevels) + else: + pb_ret = dat["pressure_levels"][nobs] + + if (np.diff(pb_ret) >= 0).any(): + msg = ("Retrieval pressure boundaries for " + \ + "observation %d are not monotonically " + \ + "decreasing! Investigate.") % nobs + print('pb_ret[:]: %s, np.diff(pb_ret): %s' %(pb_ret[:], np.diff(pb_ret))) + raise ValueError(msg) + + # Get vertical integration coefficients (i.e. to + # "interpolate" from model to retrieval grid) + coef_matrix = self.get_int_coefs(pb_ret, pb_mod, dat["level_def"][nobs]) + + # Model retrieval with averaging kernel and prior profile + if "pressure_weighting_function" in list(dat.keys()): + pwf = dat["pressure_weighting_function"][nobs] + if (not "pressure_weighting_function" in list(dat.keys())) or np.any(np.isnan(pwf)): + # Construct pressure weighting function from + # pressure boundaries + pwf = self.get_pressure_weighting_function(pb_ret, rule="simple") + + # Compute pressure-weighted averaging kernel + avpw = pwf*dat["averaging_kernel"][nobs] + + # Get prior + prior_col = dat["prior"][nobs] + prior_profile = dat["prior_profile"][nobs] + if np.isnan(prior_col): # compute prior + prior_col = np.dot(pwf, prior_profile) + + # Compute total columns + for nf in range(len(fields_list)): + # Integrate model profile + profile_intrp = np.matmul(coef_matrix, profiles[nf][nidt, :]) + + # Model retrieval + tc[nobs, nf] = prior_col + np.dot(avpw, profile_intrp - prior_profile) + + # Test phase: save pb_ret, pb_mod, coef_matrix, + # one profile for manual checking + + # dat_save = dict(pb_ret=pb_ret, + # pb_mod=pb_mod, + # coef_matrix=coef_matrix, + # ens_profile=ens_profiles[0], + # profile_intrp=profile_intrp, + # id=dat.id) + # + #out = open("model_profile_%d.pkl"%dat.id, "w") + #cPickle.dump(dat_save, out, 0) + # Average over footprint + if self.settings["footprint_samples_dim"] > 1: + indices = utilities.get_index_groups(dat["sounding_id"]) + + # Make sure that this is correct: i know the number of indices + lens = [len(group) for group in list(indices.values())] + correct_len = self.settings["footprint_samples_dim"]**2 + if np.any([len_ != correct_len for len_ in set(lens)]): + raise ValueError("Not all footprints have %d samples" %correct_len) + # Ok, paranoid mode, also confirm that the indices are what I + # think they are: consecutive numbers + ranges = [np.ptp(group) for group in list(indices.values())] + if np.any([ptp != correct_len for ptp in set(ranges)]): + raise ValueError("Not all footprints have consecutive samples") + + tc_original = copy.deepcopy(tc) + tc = utilities.apply_by_group(np.average, tc_original, indices) + + return tc + + ### David: Original function from ctdas-wrf ### + ### Keeping here as reference. ### + + @staticmethod + def _read_and_intrp_v(loc, fields_list, time_id, idp): + """ + Helper function for sample_total_columns. + read_and_intrp, but vectorized. + Reads in fields and interpolates + them linearly in time. + + Arguments + ---------- + loc (:class:`dict`) + Passed through from sample_total_columns, see there. + fields_list (:class:`list` of :class:`str`) + List of netcdf-variables to process. + time_id (:class:`int`) + Time index referring to all files in loc to read + idp (:class:`array` of :class:`int`) + Indices for id_xy, domain and frac_t in loc (i.e. + observations) to process. + + Output + ------ + List of temporally interpolated fields, one entry per member of + fields_list. + """ + + var_intrp_l = list() + + # Check we were really called with observations for just one domain + domains = set(loc["domain"][idp]) + if len(domains) > 1: + raise ValueError("I can only operate on idp with identical domains.") + dom = domains.pop() + + # Select input files + id_file0 = bisect.bisect_right(loc["file_start_time_indices"][dom], time_id) - 1 + id_file1 = bisect.bisect_right(loc["file_start_time_indices"][dom], time_id+1) - 1 + if id_file0 < 0 or id_file1 < 0: + raise ValueError("This shouldn't happen.") + + # Get time id in file + id_t_file0 = time_id - loc["file_start_time_indices"][dom][id_file0] + id_t_file1 = time_id+1 - loc["file_start_time_indices"][dom][id_file1] + + # Open files + nc0 = nc.Dataset(loc["files"][dom][id_file0], "r") + nc1 = nc.Dataset(loc["files"][dom][id_file1], "r") + # Per field to sample + for field in fields_list: + # Read input file + field0 = wrf.getvar(wrfin=nc0, + varname=field, + timeidx=id_t_file0, + squeeze=False, + meta=False) + + field1 = wrf.getvar(wrfin=nc1, + varname=field, + timeidx=id_t_file1, + squeeze=False, + meta=False) + + if len(field0.shape) == 4: + # Sample field at timesteps before and after observation + # They are ordered nt x nz x ny x nx + # var0 will have shape (len(idp),len(profile)) + var0 = field0[0, :, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] + var1 = field1[0, :, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] + # Repeat frac_t for profile size + frac_t_ = np.array(loc["frac_t"][idp]).reshape((len(idp), 1)).repeat(var0.shape[1], 1) + elif len(field0.shape) == 3: + # var0 will have shape (len(idp),) + var0 = field0[0, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] + var1 = field1[0, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] + frac_t_ = np.array(loc["frac_t"][idp]) + elif len(field0.shape) == 2: + # var0 will have shape (len(idp),len(profile)) + # This is for ZNW, which is saved as (time_coordinate, + # vertical_coordinate) + var0 = field0[[0]*len(idp), :] + var1 = field1[[0]*len(idp), :] + frac_t_ = np.array(loc["frac_t"][idp]).reshape((len(idp), 1)).repeat(var0.shape[1], 1) + else: + raise ValueError("Can't deal with field with %d dimensions." % len(field0.shape)) + + # Interpolate in time + var_intrp_l.append(var0*frac_t_ + var1*(1. - frac_t_)) + + nc0.close() + nc1.close() + + return var_intrp_l + + @staticmethod + def read_sampling_coords(sampling_coords_file, id0=None, id1=None): + """Read in samples""" + + ncf = nc.Dataset(sampling_coords_file, "r") + if id0 is None: + id0 = 0 + if id1 is None: + id1 = len(ncf.dimensions['soundings']) + + dat = dict( + sounding_id=np.array(ncf.variables["sounding_id"][id0:id1]), + date=ncf.variables["date"][id0:id1], + latitude=np.array(ncf.variables["latitude"][id0:id1]), + longitude=np.array(ncf.variables["longitude"][id0:id1]), + latc_0=np.array(ncf.variables["latc_0"][id0:id1]), + latc_1=np.array(ncf.variables["latc_1"][id0:id1]), + latc_2=np.array(ncf.variables["latc_2"][id0:id1]), + latc_3=np.array(ncf.variables["latc_3"][id0:id1]), + lonc_0=np.array(ncf.variables["lonc_0"][id0:id1]), + lonc_1=np.array(ncf.variables["lonc_1"][id0:id1]), + lonc_2=np.array(ncf.variables["lonc_2"][id0:id1]), + lonc_3=np.array(ncf.variables["lonc_3"][id0:id1]), + prior=np.array(ncf.variables["prior"][id0:id1]), + prior_profile=np.array(ncf.variables["prior_profile"][id0:id1,]), + averaging_kernel=np.array(ncf.variables["averaging_kernel"][id0:id1]), + pressure_levels=np.array(ncf.variables["pressure_levels"][id0:id1]), + pressure_weighting_function=np.array(ncf.variables["pressure_weighting_function"][id0:id1]), + level_def=ncf.variables["level_def"][id0:id1], + psurf=np.array(ncf.variables["psurf"][id0:id1]) + ) + + ncf.close() + + # Convert level_def from it's weird nc format to string + dat["level_def"] = nc.chartostring(dat["level_def"]) + + # Convert date to datetime object + dat["time"] = [dt.datetime(*x) for x in dat["date"]] + + return dat + + @staticmethod + def write_simulated_columns(obs_id, simulated, nmembers, outfile): + """Write simulated observations to file.""" + + # Output format: see obs_xco2_fr + + f = io.CT_CDF(outfile, method="create") + + dimid = f.createDimension("sounding_id", size=None) + dimid = ("sounding_id",) + savedict = io.std_savedict.copy() + savedict["name"] = "sounding_id" + savedict["dtype"] = "int64" + savedict["long_name"] = "Unique_Dataset_observation_index_number" + savedict["units"] = "" + savedict["dims"] = dimid + savedict["comment"] = "Format as in input" + savedict["values"] = obs_id.tolist() + f.add_data(savedict, nsets=0) + + dimmember = f.createDimension("nmembers", size=nmembers) + dimmember = ("nmembers",) + savedict = io.std_savedict.copy() + savedict["name"] = "column_modeled" + savedict["dtype"] = "float" + savedict["long_name"] = "Simulated total column" + savedict["units"] = "??" + savedict["dims"] = dimid + dimmember + savedict["comment"] = "Simulated model value created by ICON_sampler" + savedict["values"] = simulated.tolist() + f.add_data(savedict, nsets=0) + + f.close() + + @staticmethod + def save_file_with_timestamp(file_path, out_dir, suffix=""): + """ Saves a file to with a timestamp""" + nowstamp = dt.datetime.now().strftime("_%Y-%m-%d_%H:%M:%S") + new_name = os.path.basename(file_path) + suffix + nowstamp + new_path = os.path.join(out_dir, new_name) + shutil.copy2(file_path, new_path) + + +################################################### +# Here are some adaptations written by David Ho + + def get_icon_filenames(self, glob_pattern): + """ + Gets the filenames in self.settings["dir.icon_sim"] that follow + glob_pattern + """ + path = self.settings["run_dir"] + #path = '/work/mj0143/b301043/Project/Ensemble_sim/ICON/ICON-ART/icon-kit/ERA5_EMPA/CTDAS_test/bckup' + # All files... + wfiles = glob.glob(os.path.join(path, glob_pattern)) + files = [x for x in wfiles] + + # I need this sorted too often to not do it here. + files = np.sort(files).tolist() + return files + + + @staticmethod + def times_in_icon_file(ds_icon): + """ + Returns the times in netCDF4.Dataset ncf as datetime object + """ + times_nc = pd.to_datetime(ds_icon["time"].values, format='date_format') + #times_dtm = pd.to_datetime(ds_icon["time"].values, format='date_format') + times_str = str(times_nc.strftime('%Y-%m-%d_%H:%M:%S')[0]) + times_dtm = dt.datetime.strptime(times_str, "%Y-%m-%d_%H:%M:%S") + + return times_dtm + + + def icon_times(self, file_list): + """Read all times in a list of icon files + + Output + ------ + - 1D-array containing all times + - 1D-array containing start indices of each file + """ + + #times = [] + times = list() + start_indices = np.ndarray( (len(file_list), ), int ) + for file in range( len(file_list) ): + ds = xr.open_dataset( file_list[file] ) + times_this = self.times_in_icon_file(ds) + start_indices[file] = len(times) + #times += times_this + times.append(times_this) + #ncf.close() + + return times, start_indices + + ### David: Too slow, no longer needed ### + ### To be deleted ### + @staticmethod + def fetch_weight_and_neighbor_cells_Serial(gridinfo, latitudes_array, longitudes_array, z_info=None): + """ + Provide Grid info of your ICON grid, see icon_sampler. + Given lat/lon, calculates the distances then: + return the indexes of the neighboring N cells from unstructured ICON grid, + and the weights, for horizontal interpolation. + Vertical interpolation is skipped, since it will calculates the column average later. + ----- + Code originally inherited from Michael Steier. + Future developments: + Include vertical interpolation from 'z_info' argument, for geting the model levels. + + Output + ----- + - 1D-array containing the nearest neighbor indexes + - 1D-array containing the weights for the indexes + """ + # Libraries for this function: + from math import sin, cos, sqrt, atan2, radians + + # Initialize + nn_sel_list = np.zeros( (len(latitudes_array), gridinfo.nn) ).astype(int) # indexes must be integers + u_list = np.zeros( (len(latitudes_array), gridinfo.nn) ) + + + # Loop over lat/lon array to collect. #### This loop takes too long, needs to parallelize!!! + for index in np.arange( len(latitudes_array) ): + + # For debugging... + #print('Calculating index: %s' %index) + + latitudes = latitudes_array[index] + longitudes = longitudes_array[index] + + # For debugging... + #print('Lat: %s, Lon: %s' %(latitudes, longitudes)) + + # Initialize: + nn_sel = np.zeros(gridinfo.nn) # Index of neighbor cells + u = np.zeros(gridinfo.nn) # Weights for neighbor cells + + R = 6373.0 # approximate radius of earth in km + + # This step is used for filtering obs outside of domain. + # However, in the satellite pre-processing step, we will make sure all obs are in the domain! + # vvv Therefore, skipped... vvv + + #if (radians(longitudes)np.nanmax(gridinfo.clon)): + # u[:] = np.nan + # return np.zeros((gridinfo.nn)), np.zeros((gridinfo.nn)).astype(int), np.zeros((gridinfo.nn)).astype(int), nn_sel[:], u[:] + + #if (radians(latitudes)np.nanmax(gridinfo.clat)): + # u[:] = np.nan + # return np.zeros((gridinfo.nn)), np.zeros((gridinfo.nn)).astype(int), np.zeros((gridinfo.nn)).astype(int), nn_sel[:], u[:] + + #% + lat1 = radians(latitudes) + lon1 = radians(longitudes) + + #% + """FIND "N" CLOSEST CENTERS""" + distances = np.zeros( (len(gridinfo.clon))) + for icell in np.arange(len(gridinfo.clon)): + lat2 = gridinfo.clat[icell] + lon2 = gridinfo.clon[icell] + dlon = lon2 - lon1 + dlat = lat2 - lat1 + a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2 + c = 2 * atan2(sqrt(a), sqrt(1 - a)) + distances[icell] = R * c + nn_sel[:] = [x for _, x in sorted(zip(distances,np.arange(len(gridinfo.clon))))][0:gridinfo.nn] + nn_sel = nn_sel.astype(int) + + u[:] = [1./distances[y] for y in nn_sel] + + nn_sel_list[index] = nn_sel[:] + u_list[index] = u + + # For debugging... + #print('Done, added NS:%s and U:%s' %(nn_sel, u[:]) ) + + # End of loop + + return nn_sel_list, u_list + + + ### David: Too slow, no longer needed ### + ### To be deleted ### + @staticmethod + def fetch_weight_and_neighbor_cells_Parallel(args): + #def fetch_weight_and_neighbor_cells_Parallel(idx, gridinfo, latitudes, longitudes): + """ + Provide Grid info of your ICON grid, see icon_sampler. + Given lat/lon, calculates the distances then: + return the indexes of the neighboring N cells from unstructured ICON grid, + and the weights, for horizontal interpolation. + Vertical interpolation is skipped, since it will calculates the column average later. + ----- + Code originally inherited from Michael Steier. + Future developments: + Include vertical interpolation from 'z_info' argument, for geting the model levels. + + Output + ----- + - 1D-array containing the nearest neighbor indexes + - 1D-array containing the weights for the indexes + """ + + idx = args[0] + gridinfo = args[1] + latitudes = args[2] + longitudes = args[3] + + # Libraries for this function: + from math import sin, cos, sqrt, atan2, radians + + # Initialize: + nn_sel = np.zeros(gridinfo.nn).astype(int) # Index of neighbor cells, # indexes must be integers + u = np.zeros(gridinfo.nn) # Weights for neighbor cells + + R = 6373.0 # approximate radius of earth in km + + #% + lat1 = radians(latitudes[idx]) + lon1 = radians(longitudes[idx]) + + #% + """FIND "N" CLOSEST CENTERS""" + distances = np.zeros( (len(gridinfo.clon))) + for icell in np.arange(len(gridinfo.clon)): + lat2 = gridinfo.clat[icell] + lon2 = gridinfo.clon[icell] + dlon = lon2 - lon1 + dlat = lat2 - lat1 + a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2 + c = 2 * atan2(sqrt(a), sqrt(1 - a)) + distances[icell] = R * c + nn_sel[:] = [x for _, x in sorted(zip(distances,np.arange(len(gridinfo.clon))))][0:gridinfo.nn] + nn_sel = nn_sel.astype(int) + + u[:] = [1./distances[y] for y in nn_sel] + + #return nn_sel[:], u + return np.array(nn_sel[:], dtype=int), np.array(u) + + @staticmethod + def get_divisible_hours_string(datetime_obj, hours=3): + """ + Added by Erik; extracts a string for the previous and next datetimes + that are divisible by three + """ + # Get the hour from the datetime object + hour = datetime_obj.hour + + # Check if the hour is divisible by N hours + if hour % hours == 0: + # If divisible, get the current hour and the next hour + current_hour = datetime_obj.replace(minute=0, second=0, microsecond=0) + hour_above = current_hour + timedelta(hours=hours) + return [current_hour.strftime('%Y%m%d%H'), hour_above.strftime('%Y%m%d%H')] + else: + # If not divisible, get the hour below and above + hour_below = datetime_obj.replace(hour=hour - (hour % hours), minute=0, second=0, microsecond=0) + hour_above = hour_below + timedelta(hours=hours) + return [hour_below.strftime('%Y%m%d%H'), hour_above.strftime('%Y%m%d%H')] + + + @staticmethod + def _read_and_intrp_v_ICON(loc, fields_list, time_id, idp): + """ + David: + Slight modification from "self.sample_total_columns" for WRF. + + Helper function for sample_total_columns. + read_and_intrp, but vectorized. + Reads in fields and interpolates + them linearly in time. + + Arguments + ---------- + loc (:class:`dict`) + Passed through from sample_total_columns, see there. + fields_list (:class:`list` of :class:`str`) + List of netcdf-variables to process. + time_id (:class:`int`) + Time index referring to all files in loc to read + idp (:class:`array` of :class:`int`) + Indices for id_xy, domain and frac_t in loc (i.e. + observations) to process. + + Output + ------ + List of temporally interpolated fields, one entry per member of + fields_list. + """ + + var_intrp_l = list() + + # Select input files + id_file0 = bisect.bisect_right(loc["file_start_time_indices"], time_id) - 1 + id_file1 = bisect.bisect_right(loc["file_start_time_indices"], time_id+1) - 1 + if id_file0 < 0 or id_file1 < 0: + raise ValueError("This shouldn't happen.") + + # Get time id in file + id_t_file0 = time_id - loc["file_start_time_indices"][id_file0] + id_t_file1 = time_id+1 - loc["file_start_time_indices"][id_file1] + + # Open files + ### NetCDF approach: + nc0 = nc.Dataset(loc["files"][id_file0], "r") + nc1 = nc.Dataset(loc["files"][id_file1], "r") + + ### Xarray approach: + #nc0 = xr.open_dataset(loc["files"][id_file0]) + #nc1 = xr.open_dataset(loc["files"][id_file1]) + + # Per field to sample + for field in fields_list: + # Read input file + ### NetCDF approach: + field0 = nc0[ field ][:] + field1 = nc1[ field ][:] + + ### Xarray approach: + #field0 = nc0[ field ].values + #field1 = nc1[ field ].values + + if len(field0.shape) == 3: + ### For ICON fields that has shape (time, z, cells) + # -- First select the nearest neighbours of the fields + + var00 = field0[ 0, :, loc["nn_sel_list"][idp] ] + var01 = field1[ 0, :, loc["nn_sel_list"][idp] ] + + # -- Then interpolate spatially with weights + # The sum of the weights per obs location + u_sums = np.nansum(loc["weight_list"][idp], axis=1) + + # Fancy way of mulitply the weights onto 4 nearest neighbors per obs location. (to be varified) + # see: https://numpy.org/doc/stable/reference/generated/numpy.einsum.html + # Since the dimension does not match, so here are the tricks to do so... + var0 = ( np.einsum( "ij,ijk->ik", loc["weight_list"][idp], var00 ) / u_sums[:, np.newaxis] ) + var1 = ( np.einsum( "ij,ijk->ik", loc["weight_list"][idp], var01 ) / u_sums[:, np.newaxis] ) + + # -- Get the time fractions per obs location + frac_t_ = np.array(loc["frac_t"][idp]).reshape((len(idp), 1)) + + elif len(field0.shape) == 2: + ### For ICON fields that has shape (time, cells), e.g. "pres_sfc" + # var0 will have shape (len(idp),len(profile)) + + # -- First select the fields: + var00 = field0[ 0, loc["nn_sel_list"][idp] ] + var01 = field1[ 0, loc["nn_sel_list"][idp] ] + + # -- Then interpolate in space with weights: + # The sum of the weights per obs location + u_sums = np.nansum(loc["weight_list"][idp], axis=1) + + var0 = np.nansum( loc["weight_list"][idp] * var00, axis=1 ) / u_sums + var1 = np.nansum( loc["weight_list"][idp] * var01, axis=1 ) / u_sums + + # -- Get the time fractions per obs location + frac_t_ = np.array(loc["frac_t"][idp]) + + else: + raise ValueError("Can't deal with field with %d dimensions." % len(field0.shape)) + + # Interpolate in time + var_intrp_l.append(var0*frac_t_ + var1*(1. - frac_t_)) + + nc0.close() + nc1.close() + + return var_intrp_l + + + + #### David: A variation for sampling ICON ### + def sample_total_columns_ICON(self, dat, loc, fields_list): + """ + David: + Slight modification from "self.sample_total_columns" for WRF. + + Sample total_columns of fields_list in ICON output in + self.settings["dir.icon_sim"] at the location id_xy in domain, id_t + in all wrfout-times. Files and indices therein are recognized + by id_t and file_time_start_indices. + All quantities needed for computing total columns from profiles + are in dat (kernel, prior, ...). + + Arguments + --------- + dat (:class:`list`) + Result of wrfhelper.read_sampling_coords. Used here: prior, + prior_profile, kernel, psurf, pressure_axis, [, pwf] + If psurf or any of pressure_axis are nan, wrf's own + surface pressure is used and pressure_axis constructed + from this and the number of levels in the averaging kernel. + This allows sampling with synthetic data that don't have + pressure information. This only works with level_def + "layer_average". + If pwf is not present or nan, a simple one is created, for + level_def "layer_average". + loc (:class:`dict`) + A dictionary with all location-related input for sampling, + computed in wrfout_sampler. Keys: + id_xy, domain: Domain coordinates + id_t: Timestep (continous throughout all files) + frac_t: Interpolation coeficient between id_t and id_t+1: + t_obs = frac_t*t[id_t] + (1-frac_t)*t[id_t+1]) + file_start_time_indices: Time index at which a new wrfout + file starts + files: names of wrfout files. + fields_list (:class:`list`) + The fields to sample total columns from. + + Output + ------ + sampled_columns (:class:`array`) + A 2D-array of sampled columns. + Shape: (len(dat["prior"]), len(fields_list)) + """ + + # Initialize output of all tracers + tc = np.ndarray(shape=(len(dat["prior"]), len(fields_list)), dtype=float) + tc[:] = float("nan") + + tc_unperturbed = np.ndarray(shape=(len(dat["prior"]), 1), dtype=float) + tc_unperturbed[:] = float("nan") + + do_CAMS = True + + # Process by id_t + UT = list(set(loc["id_t"][:])) + + #print('Tests, UT: %s' %UT) + + # print(loc['times']) + + for time_id in UT: + # Coordinates to process + idt = np.nonzero(loc["id_t"] == time_id)[0] + # David: idt seems to be a list + # print('Tests, idt: %s' %idt) + + din = loc['times'][idt[0]] + # print(din) + [hour_below, hour_above ] = self.get_divisible_hours_string(datetime_obj=din) + print("oi oi", hour_below, hour_above) + if do_CAMS: + CAMS = xr.open_mfdataset(["/scratch/snx3000/ekoene/CAMS_i/cams_egg4_"+hour_below+".nc", + "/scratch/snx3000/ekoene/CAMS_i/cams_egg4_"+hour_above+".nc"], + concat_dim="Time", + combine="nested").rename({{'Time': 'time'}}) + pressure = CAMS.ap.values[:,:,np.newaxis,np.newaxis] + np.einsum('pi,pjk->pijk',CAMS.bp.values, CAMS.Psurf.values) + # The following is applicable if we only use joint (CO2,Pres) levels [as needed by, e.g., OCO2] + CAMS["pressure"] = (("time", "level", "latitude", "longitude"), (pressure[:,1:,:,:] + pressure[:,:-1,:,:])*0.5) + # The following is applicable if we want to use (CO2,Pres_ifc) combinations [note the 'hlevel' dimension] + # CAMS["pressure"] = (("time", "hlevel", "latitude", "longitude"), pressure) + + # Read and get tracer ensemble profiles, and flip them, since ICON start from the model top + m_dry = 28.97 # g/mol for dry air + m_gas = 44.01 # g/mol for CO2 + to_ppm = 1e6 + qv = self._read_and_intrp_v_ICON(loc, ['qv'], time_id, idt)[0] + + # The unperturbed tracer + BG = np.asarray(self._read_and_intrp_v_ICON(loc, ['TRCO2_BG'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + # TRCO2_A = np.asarray(self._read_and_intrp_v_ICON(loc, ['TRCO2_A'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + try: # In the "PRIOR" simulations I made, the following tracer contains the anthropogenic portion; it doesn't exist otherwise. + TRCO2_A = np.asarray(self._read_and_intrp_v_ICON(loc, ['ANTH'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + except: + TRCO2_A = np.asarray(self._read_and_intrp_v_ICON(loc, ['TRCO2_A'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + CO2_RA = np.asarray(self._read_and_intrp_v_ICON(loc, ['CO2_RA'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + CO2_GPP = np.asarray(self._read_and_intrp_v_ICON(loc, ['CO2_GPP'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + biosource_all_chemtr = np.asarray(self._read_and_intrp_v_ICON(loc, ['biosource_all_chemtr'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + biosink_chemtr = np.asarray(self._read_and_intrp_v_ICON(loc, ['biosink_chemtr'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + # The ensemble tracers + tracers = np.asarray(self._read_and_intrp_v_ICON(loc, fields_list, time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + + # Correct for the missing biospheric components! + tracers = tracers + biosource_all_chemtr - biosink_chemtr + prior_tracers = BG + TRCO2_A + CO2_RA - CO2_GPP + biosource_all_chemtr - biosink_chemtr + + #profiles = np.fliplr( self._read_and_intrp_v_ICON(loc, fields_list, time_id, idt) ) * (28.97/16.01)*1e6 # mol/kg -> ppm + # List, len=len(fields_list), shape of each: (len(idt),nz) + + # Read and get water vapor for wet/dry correction + # print(np.asarray(qv).shape, np.asarray(tracers).shape, type(qv), type(tracers)) + + # Read and get pressure axis: + psurf = self._read_and_intrp_v_ICON(loc, ["pres"], time_id, idt)[0]/1.e2 # Pa -> hPa + # Shape: (len(idt),) + + ptop = 50 # David: Since ICON does not have hard coded ptop, assume it is 50 hPa... + # Shape: (len(idt),) + if not do_CAMS: + ptop = 50 + + if do_CAMS: + ptop = 0.01 + + ### David: ZNW was for WRF, for ICON first try getting "pres" or "pres_ifc" + pres = np.fliplr( self._read_and_intrp_v_ICON(loc, ["pres"], time_id, idt)[0] )/1.e2 # Pa -> hPa + # pres = np.fliplr( self._read_and_intrp_v_ICON(loc, ["pres_ifc"], time_id, idt)[0] )/1.e2 # Pa -> hPa + #znw = self._read_and_intrp_v_ICON(loc, ["ZNW"], time_id, idt)[0] + #Shape:(len(idt),nz) + + # DONE reading from file. + # Here it starts to make sense to loop over individual observations + for nidt in range(len(idt)): + + nobs = idt[nidt] + + # Construct model pressure layer boundaries + #pb_mod = self.get_pressure_boundaries_znw(znw[nidt, :], psurf[nidt], ptop) + + # numpy.fliplr reverses the order of elements along axis 1 (left/right). + # For a 2-D array, this flips the entries in each row in the left/right direction. + # Columns are preserved, but appear in a different order than before. + pb_mod = pres[nidt] + + # Do the CAMS extension + if do_CAMS: + CAMS_obs = CAMS.interp(time=loc['times'][nobs], latitude=loc['latitude'][nobs], longitude=loc['longitude'][nobs]) + CAMS_pressures = CAMS_obs.pressure.values + CAMS_idx = CAMS_pressures < np.min(pb_mod) + pb_mod = np.concatenate((pb_mod, CAMS_pressures[CAMS_idx])) + CAMS_gas = CAMS_obs.CO2.values[CAMS_idx] * 1e6 + + # Add a final value onto the column... + pb_mod = np.append(pb_mod,np.min(pb_mod)-1) + + + if (np.diff(pb_mod) >= 0).any(): + msg = ("Model pressure boundaries for observation %d " + \ + "are not monotonically decreasing! Investigate.") % nobs + # --> Erik: I have removed this, because I don't quite know how to investigate this easily. Was triggered though! + # raise ValueError(msg) + + # Construct retrieval pressure layer boundaries + # print(dat["level_def"][nobs]) + if dat["level_def"][nobs] == "layer_average": + if np.any(np.isnan(dat["pressure_levels"][nobs])) \ + or np.isnan(dat["psurf"][nobs]): + # Code for synthetic data without a pressure axis, + # but with an averaging kernel: + # Use wrf's surface and top pressure + nlayers = len(dat["averaging_kernel"][nobs]) + pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) + else: + nlayers = len(dat["averaging_kernel"][nobs]) + pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) + # Below commented out by David + # Because somehow doesn't work + #pb_ret = self.get_pressure_boundaries_paxis( + # dat["pressure_levels"][nobs], + # dat["psurf"][nobs]) + elif dat["level_def"][nobs] == "pressure_boundary": + if np.any(np.isnan(dat["pressure_levels"][nobs])): + # Code for synthetic data without a pressure axis, + # but with an averaging kernel: + # Use wrf's surface and top pressure + nlevels = len(dat["averaging_kernel"][nobs]) + pb_ret = np.linspace(psurf[nidt], ptop, nlevels) + else: + pb_ret = dat["pressure_levels"][nobs] + else: + # print('No appropriate level chosen...') + dat["level_def"][nobs] = "pressure_boundary" + # print("changed definition to pressure_boundary") + if np.any(np.isnan(dat["pressure_levels"][nobs])): + # Code for synthetic data without a pressure axis, + # but with an averaging kernel: + # Use wrf's surface and top pressure + nlevels = len(dat["averaging_kernel"][nobs]) + pb_ret = np.linspace(psurf[nidt], ptop, nlevels) + else: + pb_ret = dat["pressure_levels"][nobs] + + if (np.diff(pb_ret) >= 0).any(): + msg = ("Retrieval pressure boundaries for " + \ + "observation %d are not monotonically " + \ + "decreasing! Investigate.") % nobs + print('pb_ret[:]: %s, np.diff(pb_ret): %s' %(pb_ret[:], np.diff(pb_ret))) + raise ValueError(msg) + + # Get vertical integration coefficients (i.e. to + # "interpolate" from model to retrieval grid) + coef_matrix = self.get_int_coefs(pb_ret, pb_mod, dat["level_def"][nobs]) ### To be verified !! + + # Model retrieval with averaging kernel and prior profile + if "pressure_weighting_function" in list(dat.keys()): + pwf = dat["pressure_weighting_function"][nobs] + if (not "pressure_weighting_function" in list(dat.keys())) or np.any(np.isnan(pwf)): + # Construct pressure weighting function from + # pressure boundaries + pwf = self.get_pressure_weighting_function(pb_ret, rule="simple") + + # Compute pressure-weighted averaging kernel + avpw = pwf*dat["averaging_kernel"][nobs] + + # Get prior + prior_col = dat["prior"][nobs] + prior_profile = dat["prior_profile"][nobs] + if np.isnan(prior_col): # compute prior + prior_col = np.dot(pwf, prior_profile) + + # Compute total columns + offset = 0 + for nf in range(len(fields_list)): + # Integrate model profile + tr_here = np.flip(tracers[nf][nidt, :]) + if do_CAMS: + tr_here = np.concatenate((tr_here, CAMS_gas)) + profile = ( (tr_here - offset ) ) + profile_intrp = np.matmul( coef_matrix, profile ) ### To be verified !! + + # Model retrieval + # print(prior_profile) + # print(profile_intrp) + # print(prior_col) + tc[nobs, nf] = prior_col + np.dot(avpw, profile_intrp - prior_profile) + # print(tc[nobs,nf]) + + tr_here = np.flip(prior_tracers[0][nidt, :]) + if do_CAMS: + tr_here = np.concatenate((tr_here, CAMS_gas)) + profile = ( (tr_here - offset ) ) + profile_intrp = np.matmul( coef_matrix, profile ) ### To be verified !! + tc_unperturbed[nobs,0] = prior_col + np.dot(avpw, profile_intrp - prior_profile) + + return tc, tc_unperturbed + +if __name__ == "__main__": + pass diff --git a/cases/icon-art-CTDAS2/ctdas_patch/icon_sampler.py b/cases/icon-art-CTDAS2/ctdas_patch/icon_sampler.py new file mode 100755 index 00000000..a5c4b1b6 --- /dev/null +++ b/cases/icon-art-CTDAS2/ctdas_patch/icon_sampler.py @@ -0,0 +1,269 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Created on Mon Jul 22 15:07:13 2019 + +@author: friedemann + +Modified on June 26, 10:40:12, 2023 +Adaptation for sampling ICON instead of WRF. +@author: David Ho + +""" + +# Samples ICON-ART history files for CTDAS + +# This is called as external executable from CTDAS +# to allow simple parallelization +# +# Usage: + +# icon_sampler.py --arg1 val1 --arg2 val2 ... +# Arguments: See parser in code below + +import os +import sys +#import itertools +#import bisect +import copy +import numpy as np +import xarray as xr +import netCDF4 as nc + +# Import some CTDAS tools +pd = os.path.pardir +inc_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), + pd, pd, pd) +inc_path = os.path.abspath(inc_path) +sys.path.append(inc_path) +from da.tools.icon.icon_helper import ICON_Helper +from da.tools.icon.utilities import utilities +import argparse + + +########## Parse options +parser = argparse.ArgumentParser() +parser.add_argument("--nproc", type=int, + help="ID of this sampling process (0 ... nprocs-1)") +parser.add_argument("--nprocs", type=int, + help="Number of sampling processes") +parser.add_argument("--sampling_coords_file", type=str, + help="File with sampling coordinates as created " + \ + "by CTDAS column samples object") +parser.add_argument("--run_dir", type=str, + help="Directory with icon output files") +parser.add_argument("--iconout_prefix", type=str, + help="Headings of the ICON output files") +parser.add_argument("--icon_grid", type=str, + help="Absolute path points to the ICON grid file") +parser.add_argument("--nmembers", type=int, + help="Number of tracer ensemble members") +parser.add_argument("--tracer_optim", type=str, + help="Tracer that was optimized (e.g. CO2 for " + \ + "ensemble members CO2_000 etc.)") +parser.add_argument("--outfile_prefix", type=str, + help="One process: output file. More processes: " + \ + "output file is ..slice") +parser.add_argument("--footprint_samples_dim", type=int, + help="Sample column footprint at n x n points") + +args = parser.parse_args() +settings = copy.deepcopy(vars(args)) + +# Start (stupid) logging - should be updated +wd = os.getcwd() +try: + os.makedirs("log") +except OSError: # Case when directory already exists. Will look nicer in python 3... + pass + +logfile = os.path.join(wd, "log/iconout_sampler." + str(settings['nproc']) + ".log") + +os.system("touch " + logfile) +os.system("rm " + logfile) +os.system("echo 'Process " + str(settings['nproc']) + " of " + str(settings['nprocs']) + ": start' >> " + logfile) +os.system("date >> " + logfile) + + +# David: could be helpful for validate arguments for icon sampling +########## Initialize iconhelper +iconhelper = ICON_Helper(settings) +iconhelper.validate_settings(['sampling_coords_file', + 'run_dir', + 'iconout_prefix', + 'icon_grid', + 'nproc', + 'nprocs', + 'nmembers', # special case 0: sample 'tracer_optim' + 'tracer_optim', + 'outfile_prefix', + 'footprint_samples_dim']) + +cwd = os.getcwd() +os.chdir(iconhelper.settings['run_dir']) + + +# ########## Figure out which samples to process +# # Get number of samples +ncf = nc.Dataset(settings['sampling_coords_file'], "r") +nsamples = len(ncf.dimensions['soundings']) +ncf.close() + +id0, id1 = utilities.get_slicing_ids(nsamples, settings['nproc'], settings['nprocs']) + +os.system("echo 'id0=" + str(id0) + "' >> " + logfile) +os.system("echo 'id1=" + str(id1) + "' >> " + logfile) + +# ########## Read samples from coord file +dat = iconhelper.read_sampling_coords(settings['sampling_coords_file'], id0, id1) + +os.system("echo 'Data read, len=" + str(len(dat['sounding_id'])) + "' >> " + logfile) + + +########## Locate samples in ICON domains + +# Take care of special case without ensemble +nmembers = settings['nmembers'] + +if nmembers == 0: + # Special case: sample 'tracer_optim', don't add member suffix + member_names = [settings['tracer_optim']] + nmembers = 1 +else: + member_names = [settings['tracer_optim'] + "-%03d" % nm for nm in range(1, nmembers+1)] # In ICON, ensemble member starts with XXX-001 + + +#### Here gets the indexes of neighboring cells and the weights +#### Choose number of neighbours, recommend 4 as done in "cdo remapdis" + +nneighb = 4 + +# Read grid file, and store the grid info. Only needs to do it once. +grid_file = settings['icon_grid'] + +# Import modules (takes 8 seconds) +from sklearn.neighbors import BallTree + +# Get ICON grid specifics +ICON_GRID = xr.open_dataset(grid_file) +clon = ICON_GRID.clon.values +clat = ICON_GRID.clat.values + +# Generate BallTree +test_points = np.column_stack([clat, clon]) +tree = BallTree(test_points, metric = 'haversine') + +lat_q = dat['latitude'] +lon_q = dat['longitude'] + +# Query BallTree +(d,i) = tree.query(np.column_stack([np.deg2rad(lat_q), np.deg2rad(lon_q)]), k=nneighb, return_distance=True) + +R = 6373.0 # approximate radius of earth in km + +weight_list = 1./(d*R) +nn_sel_list = i + + +######### Locate in time: Which file, time index, and temporal interpolation +# factor. +# MAYBE make this a function. See which quantities I need later. +# -- Initialize +id_t = np.zeros_like(dat['latitude'], int) +frac_t = np.ndarray(id_t.shape, float) +frac_t[:] = float("nan") + +# Add a little flexibility by doing this per domain - namelists allow +# different output frequencies per domain. +iconout_files = dict() +iconout_times = dict() +iconout_start_time_ids = dict() + + +# -- Get full time vector +iconout_prefix = settings['iconout_prefix'] +iconout_files = iconhelper.get_icon_filenames(iconout_prefix + "*") +iconout_times, iconout_start_time_ids = iconhelper.icon_times(iconout_files) + +# time id +for idx in range( len(dat['latitude']) ): + # Look where it sorts in + tmp = [i + for i in range( len(iconout_times) -1 ) + if iconout_times[i] <= dat['time'][idx] \ + and dat['time'][idx] < iconout_times[i+1]] + + # Catch the case that the observation took place exactly at the last time step + if len(tmp) == 1: + id_t[idx] = tmp[0] + time0 = iconout_times[id_t[idx]] + time1 = iconout_times[id_t[idx]+1] + frac_t[idx] = (time1 - dat['time'][idx]).total_seconds() / (time1 - time0).total_seconds() + + else: # len must be 0 in this case + if len(tmp) > 1:\ + raise ValueError("wat") + + if dat['time'][idx] == iconout_times[-1]: + # For debugging + print('check dat[time]: %s' %(dat['time'][idx])) + id_t[idx] = len(iconout_times)-1 + frac_t[idx] = 1 + + else: + msg = "Sample %d, sounding_id %s: outside of simulated time."%(idx, dat['sounding_id'][idx]) + raise ValueError(msg) + + +# -- Create dictionary for column sampling: +loc_input = dict(nn_sel_list = nn_sel_list, + weight_list = weight_list, + id_t = id_t, + frac_t = frac_t, + files = iconout_files, + file_start_time_indices = iconout_start_time_ids, + times = dat['time'][:], + latitude=lat_q, + longitude=lon_q) + + +# -- Begin Sampling +ens_sim, prior = iconhelper.sample_total_columns_ICON(dat, loc_input, member_names) + +# -- Write results to file +obs_ids = dat['sounding_id'] +# Remove simulations that are nan (=not in domain) +if ens_sim.shape[0] > 0: + valid = np.apply_along_axis(lambda arr: not np.any(np.isnan(arr)), 1, ens_sim) + obs_ids_write = obs_ids[valid] + ens_sim_write = ens_sim[valid, :] + prior_sim_write = prior[valid, :] +else: + obs_ids_write = obs_ids + ens_sim_write = ens_sim + prior_sim_write = prior +### +if settings['nprocs'] == 1: + outfile = settings['outfile_prefix'] +else: + # Create output files with the appendix "..slice" + # Format so that they can later be easily sorted. + len_nproc = int(np.floor(np.log10(settings['nprocs']))) + 1 + outfile = settings['outfile_prefix'] + (".%0" + str(len_nproc) + "d.slice") % settings['nproc'] + +os.system("echo 'Writing output file '" + os.path.join(iconhelper.settings['run_dir'], outfile) + " >> " + logfile) + +### Write +iconhelper.write_simulated_columns( obs_id=obs_ids_write, + simulated=ens_sim_write, + nmembers=nmembers, + outfile=outfile ) + +iconhelper.write_simulated_columns( obs_id=obs_ids_write, + simulated=prior_sim_write, + nmembers=1, + outfile=outfile+'_prior.nc' ) + +os.chdir(cwd) + +os.system("echo 'Done' >> " + logfile) diff --git a/cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py b/cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py new file mode 100644 index 00000000..96e7d3a8 --- /dev/null +++ b/cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py @@ -0,0 +1,1061 @@ +"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +updates of the code. See also: http://www.carbontracker.eu. + +This program is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free Software Foundation, +version 3. This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this +program. If not, see .""" +#!/usr/bin/env python +# obs.py + +""" +.. module:: obs +.. moduleauthor:: Wouter Peters + +Revision History: +File created on 28 Jul 2010. + +.. autoclass:: da.baseclasses.obs.Observations + :members: setup, Validate, add_observations, add_simulations, add_model_data_mismatch, write_sample_coords + +.. autoclass:: da.baseclasses.obs.ObservationList + :members: __init__ + +""" + +import logging, sys, os +from numpy import array, ndarray +import datetime as dt +from datetime import timedelta +import numpy as np +from netCDF4 import Dataset +import xarray as xr +from multiprocessing import Pool +import datetime +sys.path.append(os.getcwd()) +sys.path.append('../../') + +print("Python Version:", sys.version) +print("Python Executable Path:", sys.executable) + +from unidecode import unidecode + +identifier = 'Observations baseclass' +version = '0.0' + +from da.observations.obs_baseclass import Observations +import da.tools.io4 as io +import da.tools.rc as rc + +################### Begin Class Observations ################### + +class ICOSObservations(object): + """ + The baseclass Observations is a generic object that provides a number of methods required for any type of observations used in + a data assimilation system. These methods are called from the CarbonTracker pipeline. + + .. note:: Most of the actual functionality will need to be provided through a derived Observations class with the methods + below overwritten. Writing your own derived class for Observations is one of the first tasks you'll likely + perform when extending or modifying the CarbonTracker Data Assimilation Shell. + + Upon initialization of the class, an object is created that holds no actual data, but has a placeholder attribute `self.Data` + which is an empty list of type :class:`~da.baseclasses.obs.ObservationList`. An ObservationList object is created when the + method :meth:`~da.baseclasses.obs.Observations.add_observations` is invoked in the pipeline. + + From the list of observations, a file is written by method + :meth:`~da.baseclasses.obs.Observations.write_sample_info` + with the sample info needed by the + :class:`~da.baseclasses.observationoperator.ObservationOperator` object. The values returned after sampling + are finally added by :meth:`~da.baseclasses.obs.Observations.add_simulations` + + """ + + def __init__(self): + """ + create an object with an identifier, version, and an empty ObservationList + """ + self.ID = identifier + self.version = version + self.datalist = [] # initialize with an empty list of obs + + # The following code allows the object to be initialized with a dacycle object already present. Otherwise, it can + # be added at a later moment. + + logging.info('Observations object initialized: %s' % self.ID) + + def getlength(self): + return len(self.datalist) + + def setup(self, dacycle): + """ Perform all steps needed to start working with observational data, this can include moving data, concatenating files, + selecting datasets, etc. + """ + + self.startdate = dacycle['time.sample.start'] + self.enddate = dacycle['time.sample.end'] + op_dir = dacycle.dasystem['obs.input.dir'] + #self.obs_fname = dacycle.dasystem['obs.input.fname'] + self.n_bg_params = int(dacycle['statevector.bg_params']) + self.tracer = str(dacycle['statevector.tracer']) + if not os.path.exists(op_dir): + msg = 'Could not find the required ObsPack distribution (%s) ' % op_dir + logging.error(msg) + raise IOError(msg) + else: + self.obspack_dir = op_dir + + self.datalist = [] + + + def get_samples_type(self): + return 'insitu' + + + def add_observations(self): + """ + Add actual observation data to the Observations object. This is in a form of an + :class:`~da.baseclasses.obs.ObservationList` that is contained in self.Data. The + list has as only requirement that it can return the observed+simulated values + through the method :meth:`~da.baseclasses.obs.ObservationList.getvalues` + + """ + + # Step 1: Read list of available site files in package + ###################################################### + + + mdm_dict = {{}} + + mountain_stations = ['Jungfraujoch_5', + 'Monte Cimone_8', + 'Puy de Dome_10', + 'Pic du Midi_28', + 'Zugspitze_3', + 'Hohenpeissenberg_50', + 'Hohenpeissenberg_93', + 'Hohenpeissenberg_131', + 'Schauinsland_12', + 'Plateau Rosa_10'] + skip_stations = ['Malin Head_47', + 'Hegyhatsal hatterszennyettseg-mero allomas_48', + 'Hegyhatsal hatterszennyettseg-mero allomas_82', + 'Birkenes_2', + 'Hegyhatsal hatterszennyettseg-mero allomas_115', + 'Hegyhatsal hatterszennyettseg-mero allomas_10', + 'Beromunster_12', + 'Beromunster_44', + 'Beromunster_72', + 'Beromunster_132', + 'Bilsdale_42', + 'Bilsdale_108', + 'Cabauw_27', + 'Cabauw_67', + 'Cabauw_127', + 'Gartow_30', + 'Gartow_60', + 'Gartow_132', + 'Gartow_216', + 'Hohenpeissenberg_50', + 'Hohenpeissenberg_93', + 'Hyltemossa_30', + 'Hyltemossa_70', + 'Ispra_40', + 'Ispra_60', + 'Karlsruhe_30', + 'Karlsruhe_60', + 'Karlsruhe_100', + 'Kresin u Pacova_10', + 'Kresin u Pacova_50', + 'Kresin u Pacova_125', + 'Lindenberg_2', + 'Lindenberg_10', + 'Lindenberg_40', + 'Observatoire de Haute Provence_10', + 'Observatoire de Haute Provence_50', + "Observatoire perenne de l'environnement_10", + "Observatoire perenne de l'environnement_50", + 'Ridge Hill_45', + 'Saclay_15', + 'Saclay_60', + 'Tacolneston_54', + 'Tacolneston_100', + 'Torfhaus_10', + 'Torfhaus_76', + 'Torfhaus_110', + 'Trainou_5', + 'Trainou_50', + 'Trainou_100', + ] + + os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE" + +########################################################################################################## +# THE FOLLOWING COMMENTED BLOCK IS FOR READING-IN REAL DATA +########################################################################################################## + c_offset = 2 # ppm + + mdm_dictionary = {{ + "Beromunster_212": 6.2383423 + c_offset, + "Bilsdale_248": 3.8534036 + c_offset, + "Biscarrosse_47": 3.5997221 + c_offset, + "Cabauw_207": 6.6093283 + c_offset, + "Carnsore Point_14": 2.1894007 + c_offset, + "Ersa_40": 2.3997285 + c_offset, + "Gartow_341": 4.570544 + c_offset, + "Heidelberg_30": 8.660628 + c_offset, + "Hohenpeissenberg_131": 4.0553513 + c_offset, + "Hyltemossa_150": 3.485432 + c_offset, + "Ispra_100": 9.612817 + c_offset, + "Jungfraujoch_5": 1.0802848 + c_offset, + "Karlsruhe_200": 8.05013 + c_offset, + "Kresin u Pacova_250": 3.829324 + c_offset, + "La Muela_80": 3.2093291 + c_offset, + "Laegern-Hochwacht_32": 9.556924 + c_offset, + "Lindenberg_98": 5.4387555 + c_offset, + "Lutjewad_60": 5.651525 + c_offset, + "Monte Cimone_8": 1.7325112 + c_offset, + "Observatoire de Haute Provence_100": 4.146905 + c_offset, + "Observatoire perenne de l'environnement_120": 6.8854113 + c_offset, + "Pic du Midi_28": 1.2196398 + c_offset, + "Plateau Rosa_10": 1.3211231 + c_offset, + "Puy de Dome_10": 3.4529948 + c_offset, + "Ridge Hill_90": 5.0861707 + c_offset, + "Saclay_100": 6.8669567 + c_offset, + "Schauinsland_12": 3.7896755 + c_offset, + "Tacolneston_185": 4.6675706 + c_offset, + "Torfhaus_147": 4.622525 + c_offset, + "Trainou_180": 5.821612 + c_offset, + "Weybourne_10": 4.4674397 + c_offset, + "Zugspitze_3": 1.6796716 + c_offset + }} # Based on the simulated standard deviation of the signal (without background) over a full year. + + u_id = 1 + for ncfile in os.listdir(self.obspack_dir): + if not ncfile.endswith('.nc'): continue + + logging.info('Found file ', ) + infile = os.path.join(self.obspack_dir, ncfile) + print("infile = ", infile) + + f = xr.open_dataset(infile) + + logging.info('Looking into the file %s...'%(infile)) + + sites_names = np.array([unidecode(x) for x in f.Stations_names.values]) + + mountain_hours = ['0' + str(x) for x in np.arange(0,7)] + rest_hours = [str(x) for x in np.arange(12,17)] + + st_ind = np.arange(len(sites_names)) + + #def caculate_interval_mean_cnc(dates, conc, hr): + + + for x in st_ind: + + station_name = sites_names[x] + if station_name in skip_stations: continue # Skip stations outside of the domain! + + cnc = f.Concentration[x].values + + dates = f.Dates[x].values + flag = 1 + mdm_value = mdm_dictionary[station_name] # ERIK: CHANGED FROM constant 10 + height = f.Stations_masl[x].values + lon = f.Lon[x].values + lat = f.Lat[x].values + species = self.tracer + strategy = 1 + + # ERIK: What is the influence of using UTC here? 00 UTC is already 1 o clock in the Netherlands? BUT, simulation is not w.r.t. UTC (or is it?). + if station_name in mountain_stations: + ind_dt = np.asarray([str(x)[11:13] in mountain_hours for x in f.Dates.values[x]]) #mask of hours taken for mountain sites + hr=0 + else: + ind_dt = np.asarray([str(x)[11:13] in rest_hours for x in f.Dates.values[x]]) #mask of hours taken for the rest of the sites + hr=12 + data = cnc[ind_dt] + times = np.asarray([datetime.datetime.strptime(str(x)[:-13], "%Y-%m-%dT%H:%M") for x in dates[ind_dt]]) + logging.info('Check dates: %s %s'%(self.enddate+timedelta(days=1), self.startdate+timedelta(days=1))) + mask_da_interval = np.logical_and(times<=(self.enddate+timedelta(days=1)), (self.startdate+timedelta(days=1))<=times) + times = times[mask_da_interval] + data = data[mask_da_interval] + if len(times)>0: + for iday in set([ii.day for ii in times]): + ids = [iii for iii,dd in enumerate(times) if dd.day==iday] + value = np.nanmean(np.array([c for i,c in enumerate(data) if times[i].day==iday])) + dict_date = times[ids[0]].replace(hour=hr) + if not np.isfinite(value): continue + + self.datalist.append(MoleFractionSample(u_id,dict_date,station_name,value,0.0,0.0,0.0,mdm_value,flag,height,lat,lon,station_name,species,strategy,0.0,station_name)) + + logging.info('For itime([day]T[hour]) (%iT%i) adding synthetic obs %i at station %s: %5.2e'%(dict_date.day,dict_date.hour,u_id,station_name,value)) + u_id += 1 + + # add_station_data_to_sample(x) + + logging.info("Observations list now holds %d values" % len(self.datalist)) +########################################################################################################## + + + + def add_simulations(self, filename, silent=False): + """ Add the simulation data to the Observations object. + """ + + + if not os.path.exists(filename): + msg = "Sample output filename for observations could not be found : %s" % filename + logging.error(msg) + logging.error("Did the sampling step succeed?") + logging.error("...exiting") + raise IOError(msg) + + ncf = io.ct_read(filename, method='read') + ids = ncf.get_variable('obs_num') + simulated = ncf.get_variable('flask') + ncf.close() + logging.info("Successfully read data from model sample file (%s)" % filename) + + obs_ids = self.getvalues('id').tolist() + ids = list(map(int, ids)) + + missing_samples = [] + + for idx, val in zip(ids, simulated): + if idx in obs_ids: + index = obs_ids.index(idx) + self.datalist[index].simulated = val # in mol/mol + else: + missing_samples.append(idx) + + if not silent and missing_samples != []: + logging.warning('Model samples were found that did not match any ID in the observation list. Skipping them...') + msg = '%s'%missing_samples ; logging.warning(msg) + + logging.debug("Added %d simulated values to the Data list" % (len(ids) - len(missing_samples))) + logging.info("Added %d simulated values to the Data list" % (len(ids) - len(missing_samples))) + + + def add_model_data_mismatch(self, filename): + """ + Get the model-data mismatch values for this cycle. + """ + self.rejection_threshold = 10.0 # 3-sigma cut-off + self.global_R_scaling = 1.0 # no scaling applied + + for obs in self.datalist: # first loop over all available data points to set flags correctly + + obs.may_localize = True #False + obs.may_reject = False + obs.flag = 0 + + logging.debug("Added Model Data Mismatch to all samples ") + + + def write_sample_coords(self,obsinputfile): + """ + Write the information needed by the observation operator to a file. Return the filename that was written for later use + """ + + if len(self.datalist) == 0: + logging.debug("No observations found for this time period, nothing written to obs file") + else: + f = io.CT_CDF(obsinputfile, method='create') + logging.debug('Creating new observations file for ObservationOperator (%s)' % obsinputfile) + + dimid = f.add_dim('obs', len(self.datalist)) +# dim200char = f.add_dim('string_of200chars', 200) + dim50char = f.add_dim('string_of50chars', 50) + dim3char = f.add_dim('string_of3chars', 3) + dimcalcomp = f.add_dim('calendar_components', 6) + + data = self.getvalues('id') + + savedict = io.std_savedict.copy() + savedict['name'] = "obs_num" + savedict['dtype'] = "int" + savedict['long_name'] = "Unique_Dataset_observation_index_number" + savedict['units'] = "" + savedict['dims'] = dimid + savedict['values'] = data.tolist() + savedict['comment'] = "Unique index number within this dataset ranging from 0 to UNLIMITED." + f.add_data(savedict) + + data = self.getvalues('evn') + # print("data==", data) + + savedict = io.std_savedict.copy() + savedict['name'] = "evn" + savedict['dtype'] = "char" + savedict['long_name'] = "Site_name_abbreviation" + savedict['units'] = "" + savedict['dims'] = dimid + dim50char + savedict['values'] = data.tolist() + savedict['comment'] = "Site name abbreviation as in the data file." + f.add_data(savedict) + + data = self.getvalues('fromfile') + + savedict = io.std_savedict.copy() + savedict['name'] = "fromfile" + savedict['dtype'] = "char" + savedict['long_name'] = "data_file_name" + savedict['units'] = "" + savedict['dims'] = dimid + dim50char + savedict['values'] = data.tolist() + savedict['comment'] = "File name of data file." + f.add_data(savedict) + + data = [[d.year, d.month, d.day, d.hour, d.minute, d.second] for d in self.getvalues('xdate') ] + + savedict = io.std_savedict.copy() + savedict['dtype'] = "int" + savedict['name'] = "date_components" + savedict['units'] = "integer components of UTC date/time" + savedict['dims'] = dimid + dimcalcomp + savedict['values'] = data + savedict['missing_value'] = -999 + savedict['comment'] = "Calendar date components as integers. Times and dates are UTC." + savedict['order'] = "year, month, day, hour, minute, second" + f.add_data(savedict) + + data = self.getvalues('lat') + + savedict = io.std_savedict.copy() + savedict['dtype'] = "float" + savedict['name'] = "latitude" + savedict['units'] = "degrees_north" + savedict['dims'] = dimid + savedict['values'] = data.tolist() + savedict['missing_value'] = -999.9 + f.add_data(savedict) + + data = self.getvalues('lon') + + savedict = io.std_savedict.copy() + savedict['dtype'] = "float" + savedict['name'] = "longitude" + savedict['units'] = "degrees_east" + savedict['dims'] = dimid + savedict['values'] = data.tolist() + savedict['missing_value'] = -999.9 + f.add_data(savedict) + + data = self.getvalues('height') + + savedict = io.std_savedict.copy() + savedict['dtype'] = "float" + savedict['name'] = "altitude" + savedict['units'] = "meters_above_sea_level" + savedict['dims'] = dimid + savedict['values'] = data.tolist() + savedict['missing_value'] = -999.9 + f.add_data(savedict) + + data = self.getvalues('samplingstrategy') + + savedict = io.std_savedict.copy() + savedict['dtype'] = "int" + savedict['name'] = "sampling_strategy" + savedict['units'] = "NA" + savedict['dims'] = dimid + savedict['values'] = data.tolist() + savedict['missing_value'] = -999 + f.add_data(savedict) + + data = self.getvalues('obs') + + savedict = io.std_savedict.copy() + savedict['dtype'] = "float" + savedict['name'] = "observed" + savedict['long_name'] = "observedvalues" + savedict['units'] = "mol mol-1" + savedict['dims'] = dimid + savedict['values'] = data.tolist() + savedict['comment'] = 'Observations used in optimization' + f.add_data(savedict) + + data = self.getvalues('mdm') + + savedict = io.std_savedict.copy() + savedict['dtype'] = "float" + savedict['name'] = "modeldatamismatch" + savedict['long_name'] = "modeldatamismatch" + savedict['units'] = "[mol mol-1]" + savedict['dims'] = dimid + savedict['values'] = data.tolist() + savedict['comment'] = 'Standard deviation of mole fractions resulting from model-data mismatch' + f.add_data(savedict) + f.close() + + logging.debug("Successfully wrote data to obs file") + logging.info("Sample input file for obs operator now in place [%s]" % obsinputfile) + + + + + def write_sample_auxiliary(self, auxoutputfile): + """ + Write selected additional information contained in the Observations object to a file for later processing. + + """ + + def getvalues(self, name, constructor=array): + + result = constructor([getattr(o, name) for o in self.datalist]) + if isinstance(result, ndarray): + return result.squeeze() + else: + return result + + +################### End Class Observations ################### + +################### Begin Class MoleFractionSample ################### + +class MoleFractionSample(object): + """ + Holds the data that defines a mole fraction Sample in the data assimilation framework. Sor far, this includes all + attributes listed below in the __init__ method. One can additionally make more types of data, or make new + objects for specific projects. + + """ + + def __init__(self, idx, xdate, code='XXX', obs=0.0, simulated=0.0, resid=0.0, hphr=0.0, mdm=0.0, flag=0, height=0.0, lat= -999., lon= -999., evn='0000', species='co2', samplingstrategy=1, sdev=0.0, fromfile='none.nc'): + self.code = code.strip() # dataset identifier, i.e., co2_lef_tower_insitu_1_99 + self.xdate = xdate # Date of obs + self.obs = obs # Value observed + self.simulated = simulated # Value simulated by model + self.resid = resid # Mole fraction residuals + self.hphr = hphr # Mole fraction prior uncertainty from fluxes and (HPH) and model data mismatch (R) + self.mdm = mdm # Model data mismatch + self.may_localize = True # Whether sample may be localized in optimizer + self.may_reject = True # Whether sample may be rejected if outside threshold + self.flag = flag # Flag + self.height = height # Sample height in masl + self.lat = lat # Sample lat + self.lon = lon # Sample lon + self.id = idx # Obspack ID within distrution (integer), e.g., 82536 + self.evn = evn # Obspack Number within distrution (string), e.g., obspack_co2_1_PROTOTYPE_v0.9.2_2012-07-26_99_82536 + self.sdev = sdev # standard deviation of ensemble + self.masl = True # Sample is in Meters Above Sea Level + self.mag = not self.masl # Sample is in Meters Above Ground + self.species = species.strip() + self.samplingstrategy = samplingstrategy + self.fromfile = fromfile # netcdf filename inside ObsPack distribution, to write back later + +################### End Class MoleFractionSample ################### + + + + +################### Begin Class TotalColumnSample ################### +class TotalColumnSample(object): + """ + Holds the data that defines a total column sample in the data assimilation framework. Sor far, this includes all + attributes listed below in the __init__ method. One can additionally make more types of data, or make new + objects for specific projects. + This file may contain OCO-2 specific parts... + """ + + def __init__(self, idx, codex, xdate, obs=0.0, simulated=0.0, lat=-999., lon=-999., mdm=None, prior=0.0, prior_profile=0.0, av_kernel=0.0, pressure=0.0, \ + ##### freum vvvv + pressure_weighting_function=None, + ##### freum ^^^^ + level_def = "pressure_boundary", psurf = float('nan'), resid=0.0, hphr=0.0, flag=0, species='co2', sdev=0.0, \ + ##### freum vvvv + latc_0=None, latc_1=None, latc_2=None, latc_3=None, lonc_0=None, lonc_1=None, lonc_2=None, lonc_3=None \ + ##### freum ^^^^ + ): + self.id = idx # Sounding ID + self.code = codex # Retrieval ID + self.xdate = xdate # Date of obs + self.obs = obs # Value observed + self.simulated = simulated # Value simulated by model, fillvalue = -9999 + self.lat = lat # Sample lat + self.lon = lon # Sample lon + ##### freum vvvv + self.latc_0 = latc_0 # Sample latitude corner + self.latc_1 = latc_1 # Sample latitude corner + self.latc_2 = latc_2 # Sample latitude corner + self.latc_3 = latc_3 # Sample latitude corner + self.lonc_0 = lonc_0 # Sample longitude corner + self.lonc_1 = lonc_1 # Sample longitude corner + self.lonc_2 = lonc_2 # Sample longitude corner + self.lonc_3 = lonc_3 # Sample longitude corner + ##### freum ^^^^ + self.mdm = mdm # Model data mismatch + self.prior = prior # A priori column value used in retrieval + self.prior_profile = prior_profile # A priori profile used in retrieval + self.av_kernel = av_kernel # Averaging kernel + self.pressure = pressure # Pressure levels of retrieval + # freum vvvv + self.pressure_weighting_function = pressure_weighting_function # Pressure weighting function + # freum ^^^^ + self.level_def = level_def # Are prior and averaging kernel defined as layer averages? + self.psurf = psurf # Surface pressure (only needed if level_def is "layer_average") + self.loc_L = int(600) #int(0) # freum 2021-07-13: insert this dummy value so the code runs with the current version of CTDAS. *Should* not affect results if localizetype == "CT2007" as in all my runs. However, replace this file with the standard observation file, obs_column_xco2.py + + self.resid = resid # Mole fraction residuals + self.hphr = hphr # Mole fraction prior uncertainty from fluxes and (HPH) and model data mismatch (R) + self.may_localize = True # Whether sample may be localized in optimizer + self.may_reject = True # Whether sample may be rejected if outside threshold + self.flag = flag # Flag + self.sdev = sdev # standard deviation of ensemble + self.species = species.strip() + + +################### End Class TotalColumnSample ################### + + +################### Begin Class TotalColumnObservations ################### + +class TotalColumnObservations(Observations): + """ An object that holds data + methods and attributes needed to manipulate column samples + """ + + def setup(self, dacycle): + + self.startdate = dacycle['time.sample.start'] + timedelta(days=1) + self.enddate = dacycle['time.sample.end'] + + # Path to the input data (daily files) + sat_files = dacycle.dasystem['obs.column.ncfile'].split(',') + sat_dirs = dacycle.dasystem['obs.column.input.dir'].split(',') + + self.sat_dirs = [] + self.sat_files = [] + for i in range(len(sat_dirs)): + if not os.path.exists(sat_dirs[i].strip()): + msg = 'Could not find the required satellite input directory (%s) ' % sat_dirs[i] + logging.error(msg) + raise IOError(msg) + else: + self.sat_dirs.append(sat_dirs[i].strip()) + self.sat_files.append(sat_files[i].strip()) + del i + + # Get observation selection criteria (if present): + if 'obs.column.selection.variables' in dacycle.dasystem.keys() and 'obs.column.selection.criteria' in dacycle.dasystem.keys(): + self.selection_vars = dacycle.dasystem['obs.column.selection.variables'].split(',') + self.selection_criteria = dacycle.dasystem['obs.column.selection.criteria'].split(',') + logging.debug('Data selection criteria found: %s, %s' %(self.selection_vars, self.selection_criteria)) + else: + self.selection_vars = [] + self.selection_criteria = [] + logging.info('No data observation selection criteria found, using all observations in file.') + + # Model data mismatch approach + # self.mdm_calculation = dacycle.dasystem.get('mdm.calculation') + # logging.debug('mdm.calculation = %s' %self.mdm_calculation) + # if not self.mdm_calculation in ['parametrization','empirical','no_transport_error']: + # logging.warning('No valid model data mismatch method found. Valid options are \'parametrization\' and \'empirical\'. ' + \ + # 'Using a constant estimate for the model uncertainty of 1ppm everywhere.') + # else: + # logging.info('Model data mismatch approach = %s' %self.mdm_calculation) + + # Path to file with observation error settings for column observations + # Currently the same settings for all assimilated retrieval products: should this be one file per product? + logging.debug('Skipping obs.column.rc check!') + # if not os.path.exists(dacycle.dasystem['obs.column.rc']): + # msg = 'Could not find the required column observation .rc input file (%s) ' % dacycle.dasystem['obs.column.rc'] + # logging.debug(msg) + # logging.debug('...but continuing!') + # # logging.error(msg) + # # raise IOError(msg) + # else: + # self.obs_file = (dacycle.dasystem['obs.column.rc']) + + self.datalist = [] + + # Switch to indicate whether simulated column samples are read from obsOperator output, + # or whether the sampling is done within CTDAS (in obsOperator class) + self.sample_in_ctdas = dacycle.dasystem['sample.in.ctdas'] if 'sample.in.ctdas' in dacycle.dasystem.keys() else False + logging.debug('sample.in.ctdas = %s' % self.sample_in_ctdas) + + + + def get_samples_type(self): + return 'column' + + + + def add_observations(self): + """ Reading of total column observations, and selection of observations that will be sampled and assimilated. + + """ + + # Read observations from daily input files + for i in range(len(self.sat_dirs)): + + logging.info('Reading observations from %s' %os.path.join(self.sat_dirs[i],self.sat_files[i])) + + infile0 = os.path.join(self.sat_dirs[i], self.sat_files[i]) + ndays = 0 + + while self.startdate+dt.timedelta(days=ndays) <= self.enddate: + + infile = infile0.replace("",(self.startdate+dt.timedelta(days=ndays)).strftime("%Y%m%d")) + logging.info('To be precise, reading observations from %s' % infile) + + + if os.path.exists(infile): + + logging.info("Reading observations for %s" % (self.startdate+dt.timedelta(days=ndays)).strftime("%Y%m%d")) + len_init = len(self.datalist) + + # get index of observations that satisfy selection criteria (based on variable names and values in system rc file, if present) + ncf = io.ct_read(infile, 'read') + if self.selection_vars: + selvars = [] + for j in self.selection_vars: + selvars.append(ncf.get_variable(j.strip())) + del j + criteria = [] + for j in range(len(self.selection_vars)): + criteria.append(eval('selvars[j]'+self.selection_criteria[j])) + del j + #criteria = [eval('selvars[i]'+self.selection_criteria[i]) for i in range(len(self.selection_vars))] + subselect = np.logical_and.reduce(criteria).nonzero()[0] + else: + subselect = np.arange(ncf.get_variable('sounding_id').size) + + # retrieval attributes + code = ncf.get_attribute('retrieval_id') + level_def = ncf.get_attribute('level_def') + + # only read good quality observations + ids = ncf.get_variable('sounding_id').take(subselect, axis=0) + lats = ncf.get_variable('latitude').take(subselect, axis=0) + lons = ncf.get_variable('longitude').take(subselect, axis=0) + obs = ncf.get_variable('obs').take(subselect, axis=0) + unc = ncf.get_variable('uncertainty').take(subselect, axis=0) + dates = ncf.get_variable('date').take(subselect, axis=0) + dates = array([dt.datetime(*d) for d in dates]) + av_kernel = ncf.get_variable('averaging_kernel').take(subselect, axis=0) + prior_profile = ncf.get_variable('prior_profile').take(subselect, axis=0) + pressure = ncf.get_variable('pressure_levels').take(subselect, axis=0) + + prior = ncf.get_variable('prior').take(subselect, axis=0) + + ##### freum vvvv + pwf = ncf.get_variable('pressure_weighting_function').take(subselect, axis=0) + + # Additional variable surface pressure in case the profiles are defined as layer averages + if level_def == "layer_average": + psurf = ncf.get_variable('surface_pressure').take(subselect, axis=0) + else: + psurf = [float('nan')]*len(ids) + + # Optional: footprint corners + latc = dict( + latc_0=[float('nan')]*len(ids), + latc_1=[float('nan')]*len(ids), + latc_2=[float('nan')]*len(ids), + latc_3=[float('nan')]*len(ids)) + lonc = dict( + lonc_0=[float('nan')]*len(ids), + lonc_1=[float('nan')]*len(ids), + lonc_2=[float('nan')]*len(ids), + lonc_3=[float('nan')]*len(ids)) + # If one footprint corner variable is there, assume + # all are there. That's the only case that makes sense + if 'latc_0' in list(ncf.variables.keys()): + latc['latc_0'] = ncf.get_variable('latc_0').take(subselect, axis=0) + latc['latc_1'] = ncf.get_variable('latc_1').take(subselect, axis=0) + latc['latc_2'] = ncf.get_variable('latc_2').take(subselect, axis=0) + latc['latc_3'] = ncf.get_variable('latc_3').take(subselect, axis=0) + lonc['lonc_0'] = ncf.get_variable('lonc_0').take(subselect, axis=0) + lonc['lonc_1'] = ncf.get_variable('lonc_1').take(subselect, axis=0) + lonc['lonc_2'] = ncf.get_variable('lonc_2').take(subselect, axis=0) + lonc['lonc_3'] = ncf.get_variable('lonc_3').take(subselect, axis=0) + ###### freum ^^^^ + + ncf.close() + + # Add samples to datalist + # Note that the mdm is initialized here equal to the measurement uncertainty. This value is used in add_model_data_mismatch to calculate the mdm including model error + for n in range(len(ids)): + # Check for every sounding if time is between start and end time (relevant for first and last days of window) + if self.startdate <= dates[n] <= self.enddate: + self.datalist.append(TotalColumnSample(ids[n], code, dates[n], obs[n], None, lats[n], lons[n], unc[n], prior[n], prior_profile[n,:], \ + av_kernel=av_kernel[n,:], pressure=pressure[n,:], pressure_weighting_function=pwf[n,:],level_def=level_def,psurf=psurf[n], + ##### freum vvvv + latc_0=latc['latc_0'][n], latc_1=latc['latc_1'][n], latc_2=latc['latc_2'][n], latc_3=latc['latc_3'][n], + lonc_0=lonc['lonc_0'][n], lonc_1=lonc['lonc_1'][n], lonc_2=lonc['lonc_2'][n], lonc_3=lonc['lonc_3'][n] + ##### freum ^^^^ + )) + + logging.debug("Added %d observations to the Data list" % (len(self.datalist)-len_init)) + + ndays += 1 + + del i + + if len(self.datalist) > 0: + logging.info("Observations list now holds %d values" % len(self.datalist)) + else: + logging.info("No observations found for sampling window") + + + + def add_model_data_mismatch(self, filename=None, advance=False): + """ This function is empty: model data mismatch calculation is done during sampling in observation operator (TM5) to enhance computational efficiency + (i.e. to prevent reading all soundings twice and writing large additional files) + + """ + # obs_data = rc.read(self.obs_file) + self.rejection_threshold = 15 #int(obs_data['obs.rejection.threshold']) + + # At this point mdm is set to the measurement uncertainty only, added in the add_observations function. + # Here this value is used to set the combined mdm by adding an estimate for the model uncertainty as a sum of squares. + if len(self.datalist) <= 1: return #== 0: return + for obs in self.datalist: + obs.mdm = ( obs.mdm*obs.mdm + 2**2 )**0.5 ## Here changed into 2 (2ppm) for CO2 : ERIK, CHANGE THIS TO WHAT I NEED! + del obs + + meanmdm = np.average(np.array( [obs.mdm for obs in self.datalist] )) + logging.debug('Mean MDM = %s' %meanmdm) + + + + def add_simulations(self, filename, silent=False): + """ Adds observed and model simulated column values to the mole fraction objects + This function includes the add_observations and add_model_data_mismatch functionality for the sake of computational efficiency + + """ + + if self.sample_in_ctdas: + logging.debug("CODE TO ADD SIMULATED SAMPLES TO DATALIST TO BE ADDED") + + else: + # read simulated samples from file + if not os.path.exists(filename): + msg = "Sample output filename for observations could not be found : %s" % filename + logging.error(msg) + logging.error("Did the sampling step succeed?") + logging.error("...exiting") + raise IOError(msg) + + ncf = io.ct_read(filename, method='read') + ids = ncf.get_variable('sounding_id') + simulated = ncf.get_variable('column_modeled') + ncf.close() + logging.info("Successfully read data from model sample file (%s)" % filename) + + obs_ids = self.getvalues('id').tolist() + + missing_samples = [] + + # Match read simulated samples with observations in datalist + logging.info("Adding %i simulated samples to the data list..." % len(ids)) + for i in range(len(ids)): + # Assume samples are in same order in both datalist and file with simulated samples... + if ids[i] == obs_ids[i]: + self.datalist[i].simulated = simulated[i] + # If not, find index of current sample + elif ids[i] in obs_ids: + index = obs_ids.index(ids[i]) + # Only add simulated value to datalist if sample has not been filled before. Otherwise: exiting + if self.datalist[index].simulated is not None: + msg = 'Simulated and observed samples not in same order, and duplicate sample IDs found.' + logging.error(msg) + raise IOError(msg) + else: + self.datalist[index].simulated = simulated[i] + else: + logging.debug('added %s to missing_samples, obs id = %s' %(ids[i],obs_ids[i])) + missing_samples.append(ids[i]) + del i + + if not silent and missing_samples != []: + logging.warning('%i Model samples were found that did not match any ID in the observation list. Skipping them...' % len(missing_samples)) + + # if number of simulated samples < observations: remove observations without samples + if len(simulated) < len(self.datalist): + test = len(self.datalist) - len(simulated) + logging.warning('%i Observations were not sampled, removing them from datalist...' % test) + for index in reversed(list(range(len(self.datalist)))): + if self.datalist[index].simulated is None: + del self.datalist[index] + del index + + logging.debug("%d simulated values were added to the data list" % (len(ids) - len(missing_samples))) + + + + def write_sample_coords(self, obsinputfile): + """ + Write empty sample_coords_file if soundings are present in time interval, just such that general pipeline code does not have to be changed... + """ + + if self.sample_in_ctdas: + return + + if len(self.datalist) <= 1: #== 0: + logging.info("No observations found for this time period, no obs file written") + return + + # write data required by observation operator for sampling to file + f = io.CT_CDF(obsinputfile, method='create') + logging.debug('Creating new observations file for ObservationOperator (%s)' % obsinputfile) + + dimsoundings = f.add_dim('soundings', len(self.datalist)) + dimdate = f.add_dim('epoch_dimension', 7) + dimchar = f.add_dim('char', 20) + if len(self.datalist) == 1: + dimlevels = f.add_dim('levels', len(self.getvalues('pressure'))) + # freum: inserted but commented Liesbeth's new code for layers for reference, + # but I handle them differently. + # if len(self.getvalues('av_kernel')) != len(self.getvalues('pressure')): + # dimlayers = f.add_dim('layers',len(self.getvalues('av_kernel'))) + # layers = True + # else: layers = False + else: + dimlevels = f.add_dim('levels', self.getvalues('pressure').shape[1]) + # if self.getvalues('av_kernel').shape[1] != self.getvalues('pressure').shape[1]: + # dimlayers = f.add_dim('layers', self.getvalues('pressure').shape[1] - 1) + # layers = True + # else: layers = False + + savedict = io.std_savedict.copy() + savedict['dtype'] = "int64" + savedict['name'] = "sounding_id" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('id').tolist() + f.add_data(savedict) + + data = [[d.year, d.month, d.day, d.hour, d.minute, d.second, d.microsecond] for d in self.getvalues('xdate') ] + savedict = io.std_savedict.copy() + savedict['dtype'] = "int" + savedict['name'] = "date" + savedict['dims'] = dimsoundings + dimdate + savedict['values'] = data + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "latitude" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('lat').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "longitude" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('lon').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "prior" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('prior').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "prior_profile" + savedict['dims'] = dimsoundings + dimlevels + savedict['values'] = self.getvalues('prior_profile').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "averaging_kernel" + savedict['dims'] = dimsoundings + dimlevels + savedict['values'] = self.getvalues('av_kernel').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "pressure_levels" + savedict['dims'] = dimsoundings + dimlevels + savedict['values'] = self.getvalues('pressure').tolist() + f.add_data(savedict) + + # freum vvvv + savedict = io.std_savedict.copy() + savedict['name'] = "pressure_weighting_function" + savedict['dims'] = dimsoundings + dimlevels + savedict['values'] = self.getvalues('pressure_weighting_function').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_0" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('latc_0').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_1" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('latc_1').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_2" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('latc_2').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_3" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('latc_3').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_0" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('lonc_0').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_1" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('lonc_1').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_2" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('lonc_2').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_3" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('lonc_3').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "XCO2" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('obs').tolist() + f.add_data(savedict) + + # freum ^^^^ + + savedict = io.std_savedict.copy() + savedict['dtype'] = "char" + savedict['name'] = "level_def" + savedict['dims'] = dimsoundings + dimchar + savedict['values'] = self.getvalues('level_def').tolist() + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "psurf" + savedict['dims'] = dimsoundings + savedict['values'] = self.getvalues('psurf').tolist() + f.add_data(savedict) + + f.close() + + +################### End Class TotalColumnObservations ################### + + +if __name__ == "__main__": + pass diff --git a/cases/icon-art-CTDAS2/ctdas_patch/obsoperator_ICOS_OCO2.py b/cases/icon-art-CTDAS2/ctdas_patch/obsoperator_ICOS_OCO2.py new file mode 100644 index 00000000..dad38bbc --- /dev/null +++ b/cases/icon-art-CTDAS2/ctdas_patch/obsoperator_ICOS_OCO2.py @@ -0,0 +1,766 @@ +"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +updates of the code. See also: http://www.carbontracker.eu. + +This program is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free Software Foundation, +version 3. This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this +program. If not, see .""" +#!/usr/bin/env python +# model.py + +""" +.. module:: observationoperator +.. moduleauthor:: Wouter Peters + +Revision History: +File created on 30 Aug 2010. + +""" + +import logging +import subprocess +import datetime as dt +import numpy as np +from netCDF4 import Dataset +import os, sys +from multiprocessing import Pool +from scipy import interpolate +import da.tools.io4 as io +sys.path.append(os.getcwd()) +sys.path.append('../../') + +import da.tools.rc as rc +from da.tools.icon.icon_helper import ICON_Helper +from da.tools.icon.utilities import utilities +import subprocess +import glob + + +identifier = 'RandomizerObservationOperator' +version = '1.0' + +################### Begin Class ObservationOperator ################### +class ObservationOperator(object): + """ + Testing + ======= + This is a class that defines an ObervationOperator. This object is used to control the sampling of + a statevector in the ensemble Kalman filter framework. The methods of this class specify which (external) code + is called to perform the sampling, and which files should be read for input and are written for output. + + The baseclasses consist mainly of empty methods that require an application specific application. The baseclass will take observed values, and perturb them with a random number chosen from the model-data mismatch distribution. This means no real operator will be at work, but random normally distributed residuals will come out of y-H(x) and thus the inverse model can proceed. This is mainly for testing the code... + + """ + + def __init__(self, rc_filename, dacycle=None): # David: addition arg "rc_filename" added. + """ The instance of an ObservationOperator is application dependent """ + self.ID = identifier + self.version = version + self.restart_filelist = [] + self.output_filelist = [] + self.outputdir = None # Needed for opening the samples.nc files created + + # vvv Added by David: + # Load settings + self._load_rc(rc_filename) + self._validate_rc() + + # Instantiate an ICON_Helper object *David could be useful for icon sampler + self.settings["dir.icon_sim"] + + self.iconhelper = ICON_Helper(self.settings) + self.iconhelper.validate_settings(["dir.icon_sim"]) + # ^^^ Added by David: ^^^ + + logging.info('Observation Operator object initialized: %s (%s)', + self.ID, self.version) + + # The following code allows the object to be initialized with a dacycle object already present. Otherwise, it can + # be added at a later moment. + + if dacycle != None: + self.dacycle = dacycle + else: + self.dacycle = {{}} + + def _load_rc(self, name): + """Read settings from the observation operator's rc-file + + Based on TM5ObservationOperator.load_rc + """ + self.rcfile = rc.RcFile(name) + self.settings = self.rcfile.values + self.rc_filename = name + + logging.debug("rc-file %s loaded", name) + + + def _validate_rc(self): + """Check that some required values are given in the rc-file. + + Based on TM5ObservationOperator.validate_rc + """ + + needed_rc_items = ["dir.icon_sim", "obsoperator.icon_exe"] + + for key in needed_rc_items: + if key not in self.settings: + msg = "Missing a required value in rc-file : %s" % key + logging.error(msg) + raise IOError(msg) + logging.debug("rc-file has been validated succesfully") + + def get_initial_data(self): + """ This method places all initial data needed by an ObservationOperator in the proper folder for the model """ + + def setup(self,dacycle): + """ Perform all steps necessary to start the observation operator through a simple Run() call """ + + self.dacycle = dacycle + self.outputdir = dacycle['dir.output'] + self.simulationdir = dacycle['dir.icon_sim'] + self.n_bg_params = int(dacycle['statevector.bg_params']) + self.n_regs = int(dacycle['statevector.number_regions']) + self.tracer = str(dacycle['statevector.tracer']) + + def prepare_run(self,samples): + """ Prepare the running of the actual forecast model, for example compile code """ + + import os + + # For each sample type, define the name of the file that will contain the modeled output of each observation + self.simulated_file = [None] * len(samples) + for i in range(len(samples)): + self.simulated_file[i] = os.path.join(self.outputdir, '%s_output.%s.nc' % (samples[i].get_samples_type(),self.dacycle['time.sample.stamp'])) + logging.info("Simulated flask file added: %s"%self.simulated_file[i]) + del i + #self.simulated_file = os.path.join(self.outputdir, 'samples_simulated.%s.nc' % self.dacycle['time.sample.stamp']) + self.forecast_nmembers = int(self.dacycle['da.optimizer.nmembers']) + + def make_lambdas(self,statevector,lag): + """ Write out lambda file parameters + """ + #msteiner: + #write lambda file for current lag: + members = statevector.ensemble_members[lag] + if statevector.isOptimized: + self.lambda_file = os.path.join(self.simulationdir,'input','oae','lambda_%s_opt.nc' %self.dacycle['time.sample.stamp'][0:10]) + self.bg_lambda_file = os.path.join(self.simulationdir,'input','oae','bg_lambda_%s_opt.nc' %self.dacycle['time.sample.stamp'][0:10]) + else: + if lag==0: + self.lambda_file = os.path.join(self.simulationdir,'input','oae','lambda_%s_priorcycle1.nc' %self.dacycle['time.sample.stamp'][0:10]) + self.bg_lambda_file = os.path.join(self.simulationdir,'input','oae','bg_lambda_%s_priorcycle1.nc' %self.dacycle['time.sample.stamp'][0:10]) + else: + self.lambda_file = os.path.join(self.simulationdir,'input','oae','lambda_%s_prior.nc' %self.dacycle['time.sample.stamp'][0:10]) + self.bg_lambda_file = os.path.join(self.simulationdir,'input','oae','bg_lambda_%s_prior.nc' %self.dacycle['time.sample.stamp'][0:10]) + + # if os.path.exists(self.lambda_file): + # os.system('mv %s %s_cycle1.nc'%(self.lambda_file,self.lambda_file[:-3])) + # if os.path.exists(self.bg_lambda_file): + # os.system('mv %s %s_cycle1.nc'%(self.lambda_file,self.lambda_file[:-3])) + + ofile = Dataset(self.lambda_file, mode='w') + nr_ens = self.forecast_nmembers + nr_reg = self.n_regs + nr_cat = 2 + nr_tracer = 1 + oens = ofile.createDimension('ens', nr_ens) + oreg = ofile.createDimension('reg', nr_reg) + ocat = ofile.createDimension('cat', nr_cat) + otracer = ofile.createDimension('tracer', nr_tracer) + odata = ofile.createVariable('lambda', np.float32, ('ens','reg','cat','tracer'),fill_value=-999.99) + lambdas = np.empty(shape=(nr_ens,nr_reg,nr_cat,nr_tracer)) + for m in range(0,self.forecast_nmembers): + param_count=0 + for ireg in range(0,nr_reg): + for icat in range(0,nr_cat): + if statevector.isOptimized: + lambdas[m,ireg,icat,0] = members[0].param_values[param_count] + else: + lambdas[m,ireg,icat,0] = members[m].param_values[param_count] + param_count+=1 + odata[:] = lambdas + ofile.close() + logging.info('lambdas for ICON simulation written to the file: %s' % self.lambda_file) + + #write bg_lambdas + ofile = Dataset(self.bg_lambda_file, mode='w') + nr_ens = self.forecast_nmembers + nr_dir = 8 + nr_tracer = 1 + oens = ofile.createDimension('ens', nr_ens) + odir = ofile.createDimension('reg', nr_dir) + # otracer = ofile.createDimension('tracer', nr_tracer) + odata = ofile.createVariable('lambda', np.float32, ('ens','reg'),fill_value=-999.99) #,'tracer' + lambdas = np.empty(shape=(nr_ens,nr_dir)) #,nr_tracer + for m in range(0,self.forecast_nmembers): + for idir in range(0,nr_dir): + if statevector.isOptimized: + lambdas[m,idir] = members[0].param_values[-self.n_bg_params + idir] + else: + lambdas[m,idir] = members[m].param_values[-self.n_bg_params + idir] + odata[:] = lambdas + ofile.close() + logging.info('bg_lambdas for ICON simulation written to the file: %s' % self.bg_lambda_file) + + + def validate_input(self): + """ Make sure that data needed for the ObservationOperator (such as observation input lists, or parameter files) + are present. + """ + def save_data(self): + """ Write the data that is needed for a restart or recovery of the Observation Operator to the save directory """ + + def run(self,samples,statevector,lag): + """ + This Randomizer will take the original observation data in the Obs object, and simply copy each mean value. Next, the mean + value will be perturbed by a random normal number drawn from a specified uncertainty of +/- 2 ppm + """ + + import da.tools.io4 as io + import numpy as np + + #msteiner: + #write lambda file for current lag: + members = statevector.ensemble_members[lag] + if statevector.isOptimized: + self.lambda_file = os.path.join(self.simulationdir,'input','oae','lambda_%s_opt.nc' %self.dacycle['time.sample.stamp'][0:10]) + self.bg_lambda_file = os.path.join(self.simulationdir,'input','oae','bg_lambda_%s_opt.nc' %self.dacycle['time.sample.stamp'][0:10]) + else: + if lag==0: + self.lambda_file = os.path.join(self.simulationdir,'input','oae','lambda_%s_priorcycle1.nc' %self.dacycle['time.sample.stamp'][0:10]) + self.bg_lambda_file = os.path.join(self.simulationdir,'input','oae','bg_lambda_%s_priorcycle1.nc' %self.dacycle['time.sample.stamp'][0:10]) + else: + self.lambda_file = os.path.join(self.simulationdir,'input','oae','lambda_%s_prior.nc' %self.dacycle['time.sample.stamp'][0:10]) + self.bg_lambda_file = os.path.join(self.simulationdir,'input','oae','bg_lambda_%s_prior.nc' %self.dacycle['time.sample.stamp'][0:10]) + + # if os.path.exists(self.lambda_file): + # os.system('mv %s %s_cycle1.nc'%(self.lambda_file,self.lambda_file[:-3])) + # if os.path.exists(self.bg_lambda_file): + # os.system('mv %s %s_cycle1.nc'%(self.lambda_file,self.lambda_file[:-3])) + + ofile = Dataset(self.lambda_file, mode='w') + nr_ens = self.forecast_nmembers + nr_reg = self.n_regs + nr_cat = 2 + nr_tracer = 1 + oens = ofile.createDimension('ens', nr_ens) + oreg = ofile.createDimension('reg', nr_reg) + ocat = ofile.createDimension('cat', nr_cat) + otracer = ofile.createDimension('tracer', nr_tracer) + odata = ofile.createVariable('lambda', np.float32, ('ens','reg','cat','tracer'),fill_value=-999.99) + lambdas = np.empty(shape=(nr_ens,nr_reg,nr_cat,nr_tracer)) + for m in range(0,self.forecast_nmembers): + param_count=0 + for ireg in range(0,nr_reg): + for icat in range(0,nr_cat): + if statevector.isOptimized: + lambdas[m,ireg,icat,0] = members[0].param_values[param_count] + else: + lambdas[m,ireg,icat,0] = members[m].param_values[param_count] + param_count+=1 + odata[:] = lambdas + ofile.close() + logging.info('lambdas for ICON simulation written to the file: %s' % self.lambda_file) + + #write bg_lambdas + ofile = Dataset(self.bg_lambda_file, mode='w') + nr_ens = self.forecast_nmembers + nr_dir = 8 + nr_tracer = 1 + oens = ofile.createDimension('ens', nr_ens) + odir = ofile.createDimension('reg', nr_dir) + # otracer = ofile.createDimension('tracer', nr_tracer) + odata = ofile.createVariable('lambda', np.float32, ('ens','reg'),fill_value=-999.99) #,'tracer' + lambdas = np.empty(shape=(nr_ens,nr_dir)) #,nr_tracer + for m in range(0,self.forecast_nmembers): + for idir in range(0,nr_dir): + if statevector.isOptimized: + lambdas[m,idir] = members[0].param_values[-self.n_bg_params + idir] + else: + lambdas[m,idir] = members[m].param_values[-self.n_bg_params + idir] + odata[:] = lambdas + ofile.close() + logging.info('bg_lambdas for ICON simulation written to the file: %s' % self.bg_lambda_file) + + + #msteiner: + #select runscript for ICON-ART-OEM simulation: + if statevector.isOptimized: + #icon_path = os.path.join(self.simulationdir,'output_%s_opt'%(self.dacycle['time.sample.stamp'][0:10])) + runscript = os.path.join(self.simulationdir,'run','runscript_%sopt'%(self.dacycle['time.sample.stamp'][0:10])) + #runscript_boundaries = os.path.join(self.simulationdir,'run','runscript_%sopt'%(self.dacycle['time.sample.stamp'][0:10])) + extraction_script = os.path.join(self.simulationdir,'run','extract_%sopt'%(self.dacycle['time.sample.stamp'][0:10])) + #extraction_script_boundaries = os.path.join(self.simulationdir,'run','extract_boundaries%sopt'%(self.dacycle['time.sample.stamp'][0:10])) + extracted_file = os.path.join(self.simulationdir,'extracted','output_%s_opt'%(self.dacycle['time.sample.stamp'][0:10])) + else: + if lag==0: + runscript = os.path.join(self.simulationdir,'run','runscript_%spriorcycle1'%(self.dacycle['time.sample.stamp'][0:10])) + extraction_script = os.path.join(self.simulationdir,'run','extract_%spriorcycle1'%(self.dacycle['time.sample.stamp'][0:10])) + extracted_file = os.path.join(self.simulationdir,'extracted','output_%s_priorcycle1'%(self.dacycle['time.sample.stamp'][0:10])) + else: + runscript = os.path.join(self.simulationdir,'run','runscript_%sprior'%(self.dacycle['time.sample.stamp'][0:10])) + extraction_script = os.path.join(self.simulationdir,'run','extract_%sprior'%(self.dacycle['time.sample.stamp'][0:10])) + #extraction_script_boundaries = os.path.join(self.simulationdir,'run','extract_boundaries%sprior'%(self.dacycle['time.sample.stamp'][0:10])) + #icon_path = os.path.join(self.simulationdir,'output_%s_prior'%(self.dacycle['time.sample.stamp'][0:10])) + extracted_file = os.path.join(self.simulationdir,'extracted','output_%s_prior'%(self.dacycle['time.sample.stamp'][0:10])) + runscript_boundaries = os.path.join(self.simulationdir,'run_bg','runscript_boundaries%spriorcycle1'%(self.dacycle['time.sample.stamp'][0:10])) + extraction_script_boundaries = os.path.join(self.simulationdir,'run_bg','extract_boundaries%spriorcycle1'%(self.dacycle['time.sample.stamp'][0:10])) + extracted_boundaries_ens_file = os.path.join(self.simulationdir,'extracted','output_bg_%s_priorcycle1'%(self.dacycle['time.sample.stamp'][0:10])) + logging.info('extraction_script: %s'%(extraction_script)) + + template = os.path.join(self.simulationdir,'run','templates','sbatch_extract_template') + sbatch_script = os.path.join(self.simulationdir,'run','sbatch_script') + sbatch_script_bg = os.path.join(self.simulationdir,'run_bg','sbatch_script') + # Write sbatch file + with open(template) as input_file: + to_write = input_file.read() + with open(sbatch_script, "w") as outf: + outf.write(to_write.format(extract_script=extraction_script)) + + self.extracted_file = extracted_file + # inidata = os.path.join( + # self.simulationdir, + # 'input', + # 'icbc', + # self.startdate.strftime(cfg.meteo_nameformat) + '.nc') + # link = os.path.join( + # '/users/nponomar/Emissions/ART', #ART input folder same as specified in ICON nml + # 'ART_ICE_iconR19B09-grid_.nc' #ini5 from processing chain + # ) + # os.system('ln -sf ' + inidata + ' ' + link) + + #now run ICON-ART-OEM: + # if not (os.path.exists(extracted_file) or os.path.exists(extracted_boundaries_ens_file)): + # logging.info('In branch 0') + # self.start_multiple_icon_jobs([runscript, runscript_boundaries]) + # logging.info('ICON ensemble and boudnaries runs - done!') + # with open(sbatch_script_bg, "w") as outf: + # outf.write(to_write.format(extract_script=extraction_script_boundaries)) + # #self.start_icon(sbatch_script_bg) + # self.start_multiple_icon_jobs([sbatch_script, sbatch_script_bg]) + # logging.info('Extraction for ensemble and boudnaries runs - done!') + while not (os.path.exists(extracted_file)): + logging.info('In branch 1') + logging.info('runscript name: %s'%(runscript)) + self.start_icon(runscript) + logging.info('ICON done!') + #now run the extraction script: + self.start_icon(sbatch_script) + logging.info('extractionscript name: %s'%(sbatch_script)) + logging.info('Extraction done!') + # if not (os.path.exists(extracted_boundaries_ens_file)): + # logging.info('In branch 2') + # logging.info('runscript name: %s'%(runscript_boundaries)) + # self.start_icon(runscript_boundaries) + # logging.info('ICON boundaries done!') + # with open(sbatch_script_bg, "w") as outf: + # outf.write(to_write.format(extract_script=extraction_script_boundaries)) + # self.start_icon(sbatch_script_bg) + # logging.info('runscript name: %s'%(sbatch_script_bg)) + # logging.info('Extraction done!') + + + + def sample(self,samples): + for j,sample in enumerate(samples): + sample_type = sample.get_samples_type() + logging.info(f"Want to do...{{sample_type}} extraction") + if sample_type == "column": + logging.info("Starting _launch_icon_column_sampling") + + warning_msg = "JM: Be careful! The current column sampling " + \ + "method is designed for a specific case of study. " + \ + "Please evaluate if the satellite product is suitable " + \ + "with an appropriate model spatial resolution!" + logging.warning( warning_msg ) + + self._launch_icon_column_sampling(j,sample) + + logging.info("Finished _launch_icon_column_sampling") + + elif sample_type == "insitu": + self.ICOS_sampling(j,sample) + + else: + logging.error("Unknown sample type: %s", + sample.get_samples_type()) + + + def ICOS_sampling(self,j,sample): + # logging.info('WARNING!! Just for testing, Im copying the input file to the output file!') + + # cmd = f"cp {{self.dacycle['ObsOperator.inputfile.'+sample.get_samples_type()]}} {{self.simulated_file[j]}}" + # logging.info(f"Will run cmd={{cmd}}") + # os.system(cmd) + # cmd = f"module load daint-mc NCO; ncrename -v observed,flask {{self.simulated_file[j]}}" + # logging.info(f"Will run cmd={{cmd}}") + # os.system(cmd) + # return + + # Create a flask output file to hold simulated values for later reading + f = io.CT_CDF(self.simulated_file[j], method='create') + logging.debug('Creating new simulated observation file in ObservationOperator (%s)' % self.simulated_file) + + dimid = f.createDimension('obs_num', size=None) + dimid = ('obs_num',) + savedict = io.std_savedict.copy() + savedict['name'] = "obs_num" + savedict['dtype'] = "int" + savedict['long_name'] = "Unique_Dataset_observation_index_number" + savedict['units'] = "" + savedict['dims'] = dimid + savedict['comment'] = "Unique index number within this dataset ranging from 0 to UNLIMITED." + f.add_data(savedict,nsets=0) + + dimmember = f.createDimension('nmembers', size=self.forecast_nmembers) + dimmember = ('nmembers',) + savedict = io.std_savedict.copy() + savedict['name'] = "flask" + savedict['dtype'] = "float" + savedict['long_name'] = "mole_fraction_of_trace_gas_in_air" + savedict['units'] = "mol tracer (mol air)^-1" + savedict['dims'] = dimid + dimmember + savedict['comment'] = "Simulated model value created by RandomizerObservationOperator" + f.add_data(savedict,nsets=0) + + # Open file with x,y,z,t of model samples that need to be sampled + f_in = io.ct_read(self.dacycle['ObsOperator.inputfile.'+sample.get_samples_type()],method='read') + + # Get simulated values and ID + + ids = f_in.get_variable('obs_num') + obs = f_in.get_variable('observed') + mdm = f_in.get_variable('modeldatamismatch') + + #msteiner: + date_components = f_in.get_variable('date_components') + evn = f_in.get_variable('evn') + fromfile = f_in.get_variable('fromfile') + #--------- + + # Loop over observations, add random white noise, and write to file + +########################################################### + os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE" + + molar_mass = {{'ch4' : 16.04e-3, + 'co2' : 44.01e-3, + 'da' : 28.97e-3 + }} + units_factor = {{'ch4' : 1.e9, #ppb for ch4 + 'co2' : 1.e6, #ppm for co2 + }} + + #M_CH4 = 16.04e-3 #mol. weight CH4 [kg/mol] + #M_da = 28.97e-3 #mol. weight dry air [kg/mol] + + #mountain_sites = ['cmn_insitu','jfj_insitu','kas_insitu','oxk_icos','oxk_ingos','oxk_noaa','pdm_lsceflask','puy_insitu','puy_lsceflask','zsf_wdcgg','cur_wdcgg','pdm_lsce','snb_wdcgg'] + mountain_stations = ['Jungfraujoch_5', + 'Monte Cimone_8', + 'Puy de Dome_10', + 'Pic du Midi_28', + 'Zugspitze_3', + 'Hohenpeissenberg_50', + 'Hohenpeissenberg_93', + 'Hohenpeissenberg_131', + 'Schauinsland_12', + 'Plateau Rosa_10'] + skip_stations = ['Malin Head_47', + 'Hegyhatsal hatterszennyettseg-mero allomas_48', + 'Hegyhatsal hatterszennyettseg-mero allomas_82', + 'Birkenes_2', + 'Hegyhatsal hatterszennyettseg-mero allomas_115', + 'Hegyhatsal hatterszennyettseg-mero allomas_10', + 'Beromunster_12', + 'Beromunster_44', + 'Beromunster_72', + 'Beromunster_132', + 'Bilsdale_42', + 'Bilsdale_108', + 'Cabauw_27', + 'Cabauw_67', + 'Cabauw_127', + 'Gartow_30', + 'Gartow_60', + 'Gartow_132', + 'Gartow_216', + 'Hohenpeissenberg_50', + 'Hohenpeissenberg_93', + 'Hyltemossa_30', + 'Hyltemossa_70', + 'Ispara_40', + 'Ispra_70', + 'Karlsruhe_30', + 'Karlsruhe_60', + 'Karlsruhe_100', + 'Kresin u Pacova_10', + 'Kresin u Pacova_50', + 'Kresin u Pacova_125', + 'Lindenberg_2', + 'Lindenberg_10', + 'Lindenberg_40', + 'Observatoire de Haute Provence_10', + 'Observatoire de Haute Provence_50', + "Observatoire perenne de l'environnement_10", + "Observatoire perenne de l'environnement_50", + 'Ridge Hill_45', + 'Saclay_15', + 'Saclay_60', + 'Tacolneston_54', + 'Tacolneston_100', + 'Torfhaus_10', + 'Torfhaus_76', + 'Torfhaus_110', + 'Trainou_5', + 'Trainou_50', + 'Trainou_100', + ] + + simulated_values = np.zeros((len(obs),self.forecast_nmembers)) + + f1 = io.ct_read(self.extracted_file,method='read') + TR_A_ENS = (molar_mass['da']/molar_mass[self.tracer])*units_factor[self.tracer]*np.array(f1.get_variable('TR'+self.tracer.upper()+'_A_ENS') + f1.get_variable('biosource_all_chemtr') - f1.get_variable('biosink_chemtr')) #float CH4_A_ENS(ens, sites, time) 1 --> ppb + qv = np.array(f1.get_variable('qv')) #float qv(sites, time) + site_names = np.array(f1.get_variable('site_name')) + obs_times = np.array(f1.get_variable('time')) + + # wet --> dry mmr + for iiens in np.arange(TR_A_ENS.shape[0]): + TR_A_ENS[iiens,...] = TR_A_ENS[iiens,...]/(1.-qv[...]) + + + #LOOP OVER OBS: + for iobs in np.arange(len(obs)): + station_name = fromfile[iobs][fromfile[iobs]!=b''].tostring().decode('utf-8') + if station_name in skip_stations: continue # Skip stations outside of the domain! + print('DEBUG iobs: ',iobs,flush=True) + obs_date = dt.datetime(*date_components[iobs,:]) + print('DEBUG obs_date: ',obs_date,flush=True) + obs_date = obs_date.replace(minute=0,second=0) + print('DEBUG modified obs_date: ',obs_date,flush=True) + + # LOOP OVER EXTRACTED DATA TIMES + for itime in np.arange(TR_A_ENS.shape[2]): + otime = dt.datetime.strptime(obs_times[itime],'%Y-%m-%dT%H') +# print('DEBUG checking otime: ',otime,flush=True) + if not (obs_date == otime): continue + print('DEBUG found otime: ',otime,flush=True) + + # find index (or the difference) of hour at 12 UTC and 0 UTC + if station_name in mountain_stations: + print('DEBUG station',station_name, 'is a mountain site',flush=True) + delta_index = obs_date.hour + print('DEBUG delta_index: ',delta_index,flush=True) + else: + print('DEBUG station',station_name, 'is NOT a mountain site',flush=True) + delta_index = obs_date.hour - 12 + print('DEBUG delta_index: ',delta_index,flush=True) + + + # LOOP OVER STATIONS + for isite in np.arange(TR_A_ENS.shape[1]): + site_name = site_names[isite] +# print('DEBUG looking through sampled stations. Checking site_name: ',site_name,flush=True) + if (site_name==station_name): + print('DEBUG looking through sampled stations. Found site_name: ',site_name,flush=True) + for iens in np.arange(self.forecast_nmembers): + if station_name in mountain_stations: + simulated_values[iobs,iens] = np.nanmean(TR_A_ENS[iens,isite,itime-delta_index:itime-delta_index+7]) + else: + simulated_values[iobs,iens] = np.nanmean(TR_A_ENS[iens,isite,itime-delta_index:itime-delta_index+5]) + if iens==50: + print('Added model value for member 0 of %.2f for iobs %i at %s at %s with a delta idx of %i'%(simulated_values[iobs,0],iobs,site_name,obs_date,delta_index)) + print('Added model value for member 50 of %.2f for iobs %i at %s at %s with a delta idx of %i'%(simulated_values[iobs,50],iobs,site_name,obs_date,delta_index)) + break + else: + continue + break +########################################################### + + + + for i in range(0,len(obs)): + f.variables['obs_num'][i] = ids[i] + f.variables['flask'][i,:] = simulated_values[i] + + f.close() + f_in.close() + + # Report success and exit + + logging.info('ICOS ObservationOperator finished successfully, output file written (%s)' % self.simulated_file) + + + def _launch_icon_column_sampling(self, j, sample): + """Sample ICON output at coordinates of column observations.""" + """Here we can implement Erik's CDO technique.""" + + # To be continued.... + # run_dir = self.settings["dir.icon_sim"] # Erik: run_dir here means: output dir. + # run_dir = '/scratch/snx3000/ekoene/processing-chain/work/VPRM_EU_ERA5_22/XCO2_test' # This should, eventually, be determined automatically from however the folder structure is made! + run_dir = os.path.join(self.simulationdir,os.path.basename(self.extracted_file)) + logging.info(f"Directory that satellite data will be taken from: {{run_dir}}") + + sampling_coords_file = self.dacycle['ObsOperator.inputfile.'+sample.get_samples_type()] + logging.info(f"Sampling coords file: {{sampling_coords_file}}") + + # Reconstruct self.simulated_file[i] + out_file = self.simulated_file[j] + # out_file = self._sim_fpattern % sample.get_samples_type() + + # Remove intermediate files from a previous sampling job (might + # still be there if that one fails) + # The file pattern is hardcoded in wrfout_sampler + # slicefile_pattern = out_file + ".*.slice" + # for f in glob.glob(os.path.join(run_dir, slicefile_pattern)): + # os.remove(f) + + + # Sould be parallelized? + # Spawn multiple icon_sampler instances, + # using at most all processes available + #nprocs1 = int(self.dacycle["da.resources.ntasks"]) + nprocs1 = int(1) + + # Might not want to use that many processes if there are few + # observations, because of overhead. Set a minimum number of + # observations per process, and reduce the number of + # processes to hit that. + Nobs = len(sample.datalist) + if Nobs == 0: + logging.info("No observations, skipping sampling") + return + + # Might want to increase this, no idea if this is reasonable + nobs_min = 100 + nprocs2 = max(1, int(float(Nobs)/float(nobs_min))) + + # Number of processes to use: + nprocs = min(nprocs1, nprocs2) + + # Make run command + # For a task with 1 processor, specifically request -N1 because + # otherwise slurm apparently sometimes tries to allocate one task to + # more than one node. Or something like that. See here: + # https://stackoverflow.com/questions/24056961/running-slurm-script-with-multiple-nodes-launch-job-steps-with-1-task + #command_ = "srun --exclusive -n1 -N1" + command_ = " " # Erik: this would have to look different for us + + # Check if output slice files are already present + # This shouldn't happen, because they are deleted + # a few lines above. But if for some reason (crash) + # they are still here, this might lead to funny behavios. + if nprocs > 1: + output_files = glob.glob(slicefile_pattern) + if len(output_files) > 0: + msg = "Files that match the pattern of the " + \ + "sampler output are already present. Stopping." + logging.error(msg) + raise OSError(msg) + + # Submit processes + procs = list() + for nproc in range(nprocs): + cmd = " ".join([ + command_, + "python ./da/tools/icon/icon_sampler.py", + "--nproc %d" % nproc, + "--nprocs %d" % nprocs, + "--sampling_coords_file %s" % sampling_coords_file, + "--run_dir %s" % run_dir, + "--iconout_prefix %s" % self.settings["output_prefix"], + "--icon_grid %s" % self.settings["icon_grid_path"], + "--nmembers %d" % int(self.dacycle["da.optimizer.nmembers"]), + "--tracer_optim %s" % self.settings["tracer_optim"], + "--outfile_prefix %s" % out_file, + "--footprint_samples_dim %d" % int(self.settings['obs.column.footprint_samples_dim']) + ]) + + procs.append(subprocess.Popen(cmd.split(), + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT)) + + + logging.info("Started %d sampling process(es).", nprocs) + logging.debug("Command of last process: %s", cmd) + + # Wait for all processes to finish + for n in range(nprocs): + procs[n].wait() + + # Check for errors + retcodes = [] + for n in range(nprocs): + logging.debug("Checking errors in process %d", n) + retcodes.append(utilities.check_out_err(procs[n])) + + if any([r != 0 for r in retcodes]): + raise RuntimeError("At least one sampling process " + \ + "finished with errors.") + + logging.info("All sampling processes finished.") + + # Join output files + logging.info("Joining output files.") + ### Some code for joining the files + if nprocs > 1: + utilities.cat_ncfiles(run_dir, slicefile_pattern, + "sounding_id", out_file, + in_pattern=True) + + # Finishing msg + logging.info("ICON column output sampled.") + logging.info("If samples object carried observations, output " + \ + "file written to %s", self.simulated_file) + + +######################################################################################## + def run_forecast_model(self,samples,statevector,lag,dacycle): + self.startdate = dacycle['time.sample.start'] + self.prepare_run(samples) + self.make_lambdas(statevector,lag) + self.validate_input() + self.run(samples,statevector,lag) + self.sample(samples) + self.save_data() + + + + def start_icon(self, runscript): + os.system('sbatch --wait '+runscript) +# pass + def start_multiple_icon_jobs(self, scripts): + files = scripts + #command = "sbatch --wait " + os.system('sbatch '+files[1]) + os.system('sbatch --wait '+files[0]) + # processes = list() + # max_processes = len(files) + + + # for name in files: + # logging.info('Starting a new job: %s'%(command + name)) + # processes.append(subprocess.Popen([command + name], shell=True)) + + # # if len(processes) >= max_processes: + # os.wait() + # processes.difference_update([ + # p for p in processes if p.poll() is not None]) +################### End Class ObservationOperator ################### + +class RandomizerObservationOperator(ObservationOperator): + """ This class holds methods and variables that are needed to use a random number generated as substitute + for a true observation operator. It takes observations and returns values for each obs, with a specified + amount of white noise added + """ + + + +if __name__ == "__main__": + pass diff --git a/cases/icon-art-CTDAS2/ctdas_patch/optimizer_baseclass_icos_cities.py b/cases/icon-art-CTDAS2/ctdas_patch/optimizer_baseclass_icos_cities.py new file mode 100644 index 00000000..230e5ffc --- /dev/null +++ b/cases/icon-art-CTDAS2/ctdas_patch/optimizer_baseclass_icos_cities.py @@ -0,0 +1,703 @@ +"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +updates of the code. See also: http://www.carbontracker.eu. + +This program is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free Software Foundation, +version 3. This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this +program. If not, see .""" +#!/usr/bin/env python +# optimizer.py + +""" +.. module:: optimizer +.. moduleauthor:: Wouter Peters + +Revision History: +File created on 28 Jul 2010. + +""" + +import logging +import numpy as np +import numpy.linalg as la +import da.tools.io4 as io +import csv +import xarray as xr +from sklearn.metrics.pairwise import haversine_distances + +identifier = 'Optimizer baseclass' +version = '0.0' + +################### Begin Class Optimizer ################### + +class Optimizer(object): + """ + This creates an instance of an optimization object. It handles the minimum least squares optimization + of the state vector given a set of sample objects. Two routines will be implemented: one where the optimization + is sequential and one where it is the equivalent matrix solution. The choice can be made based on considerations of speed + and efficiency. + """ + + def __init__(self): + self.ID = identifier + self.version = version + + logging.info('Optimizer object initialized: %s' % self.ID) + + def setup(self, dims, loc_coeff_file): + self.nlag = dims[0] + self.nmembers = dims[1] + self.nparams = dims[2] + self.nobs = dims[3] + self.loc_coeffs = loc_coeff_file + self.create_matrices() + + def create_matrices(self): + """ Create Matrix space needed in optimization routine """ + + # mean state [X] + self.x = np.zeros((self.nlag * self.nparams,), float) + # deviations from mean state [X'] + self.X_prime = np.zeros((self.nlag * self.nparams, self.nmembers,), float) + # mean state, transported to observation space [ H(X) ] + self.Hx = np.zeros((self.nobs,), float) + # deviations from mean state, transported to observation space [ H(X') ] + self.HX_prime = np.zeros((self.nobs, self.nmembers), float) + # observations + self.obs = np.zeros((self.nobs,), float) + # observation ids + self.obs_ids = np.zeros((self.nobs,), float) + # covariance of observations + # Total covariance of fluxes and obs in units of obs [H P H^t + R] + if self.algorithm == 'Serial': + self.R = np.zeros((self.nobs,), float) + self.HPHR = np.zeros((self.nobs,), float) + else: + self.R = np.zeros((self.nobs, self.nobs,), float) + self.HPHR = np.zeros((self.nobs, self.nobs,), float) + # localization of obs + self.may_localize = np.zeros(self.nobs, bool) + # rejection of obs + self.may_reject = np.zeros(self.nobs, bool) + # flags of obs + self.flags = np.zeros(self.nobs, int) + # species type + self.species = np.zeros(self.nobs, str) + # species type + self.sitecode = np.zeros(self.nobs, str) + # rejection_threshold + self.rejection_threshold = np.zeros(self.nobs, float) + # lat/lon + self.latitude = np.zeros(self.nobs, float) + self.longitude = np.zeros(self.nobs, float) + + # species mask + self.speciesmask = {{}} + + # Kalman Gain matrix + #self.KG = np.zeros((self.nlag * self.nparams, self.nobs,), float) + self.KG = np.zeros((self.nlag * self.nparams,), float) + + #msteiner: + self.evn = np.zeros(self.nobs, str) + self.fromfile = np.zeros(self.nobs, str) + + #read loc_coeffs from file + ds = xr.open_dataset(self.loc_coeffs) + self.coeff_matrix = np.exp(-ds.Distances.values/400).T # ERIK: I set this to 400 as a rough footprint size for a station (was 600 km for Michael; 60 km for Nikolai) + self.name_array = ds.Stations_names.values + + + def state_to_matrix(self, statevector): + allsites = [] # collect all obs for n=1,..,nlag + allobs = [] # collect all obs for n=1,..,nlag + allmdm = [] # collect all mdm for n=1,..,nlag + allids = [] # collect all model samples for n=1,..,nlag + allreject = [] # collect all model samples for n=1,..,nlag + alllocalize = [] # collect all model samples for n=1,..,nlag + allflags = [] # collect all model samples for n=1,..,nlag + allspecies = [] # collect all model samples for n=1,..,nlag + allsimulated = [] # collect all members model samples for n=1,..,nlag + allrej_thres = [] # collect all rejection_thresholds, will be the same for all samples of same source + alllats = [] # collect all latitudes for n=1,..,nlag + alllons = [] # collect all longitudes for n=1,..,nlag + #msteiner: + allevns = [] # collect all evns for finding loc_coeffs in localize() + allfromfiles = [] # collect all evns for finding loc_coeffs in localize() + + for n in range(self.nlag): + samples = statevector.obs_to_assimilate[n] + members = statevector.ensemble_members[n] + self.x[n * self.nparams:(n + 1) * self.nparams] = members[0].param_values + self.X_prime[n * self.nparams:(n + 1) * self.nparams, :] = np.transpose(np.array([m.param_values for m in members])) + + # Add observation data for all sample objects + if samples != None: + if type(samples) != list: samples = [samples] + for m in range(len(samples)): + sample = samples[m] + logging.debug('Lag %i, sample %i: rejection_threshold = %i, nobs = %i' %(n, m, sample.rejection_threshold, sample.getlength())) + logging.info('Lag %i, sample %i: rejection_threshold = %i, nobs = %i' %(n, m, sample.rejection_threshold, sample.getlength())) + logging.info(f'{{dir(sample)}}') + alllats.extend(sample.getvalues('lat')) + alllons.extend(sample.getvalues('lon')) + allrej_thres.extend([sample.rejection_threshold] * sample.getlength()) + allreject.extend(sample.getvalues('may_reject')) + alllocalize.extend(sample.getvalues('may_localize')) + allflags.extend(sample.getvalues('flag')) + allspecies.extend(sample.getvalues('species')) + allobs.extend(sample.getvalues('obs')) + allsites.extend(sample.getvalues('code')) + allmdm.extend(sample.getvalues('mdm')) + allids.extend(sample.getvalues('id')) + #msteiner: + # if sample.get_samples_type() == 'insitu': + try: + allevns.extend(sample.getvalues('evn')) + allfromfiles.extend(sample.getvalues('fromfile')) + except: + logging.debug(f"Number of copies: {{len(sample.getvalues('lat'))}}") + allevns.extend(['column']*len(sample.getvalues('lat'))) + allfromfiles.extend(['column']*len(sample.getvalues('lat'))) + simulatedensemble = sample.getvalues('simulated') + for s in range(simulatedensemble.shape[0]): + allsimulated.append(simulatedensemble[s]) + + self.latitude[:] = np.array(alllats) + self.longitude[:] = np.array(alllons) + self.rejection_threshold[:] = np.array(allrej_thres) + self.obs[:] = np.array(allobs) + self.obs_ids[:] = np.array(allids) + self.HX_prime[:, :] = np.array(allsimulated) + self.Hx[:] = self.HX_prime[:, 0] + + self.may_reject[:] = np.array(allreject) + self.may_localize[:] = np.array(alllocalize) + self.flags[:] = np.array(allflags) + self.species[:] = np.array(allspecies) + self.sitecode = allsites + + #msteiner: + # self.evn = allevns + self.fromfile = allfromfiles + + # ~~~~~~~~ NEW SINCE OCO2, but generally valid: Setup localization (distance between observations and regions) + OBSERVATIONS_IN_RADIANS_LATLON = np.deg2rad(np.column_stack([self.latitude,self.longitude])) + grid = xr.open_dataset('/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc') + grid_latitudes = grid.lat_cell_centre.values + grid_longitudes = grid.lon_cell_centre.values + REGIONS_IN_RADIANS_LATLON = np.column_stack([grid_latitudes,grid_longitudes]) + Distances = haversine_distances(OBSERVATIONS_IN_RADIANS_LATLON,REGIONS_IN_RADIANS_LATLON) * 6371000/1000 # distance to km s + logging.debug(Distances) + self.coeff_matrix = np.exp(-Distances/400) # ERIK: I set this to 400 as a rough footprint size for a station (was 600 km for Michael; 60 km for Nikolai) + self.name_array = np.arange(OBSERVATIONS_IN_RADIANS_LATLON.shape[0]) # These should be 'names' but my pixels don't have names, of course! + + self.X_prime = self.X_prime - self.x[:, np.newaxis] # make into a deviation matrix + self.HX_prime = self.HX_prime - self.Hx[:, np.newaxis] # make a deviation matrix + + if self.algorithm == 'Serial': + for i, mdm in enumerate(allmdm): + self.R[i] = mdm ** 2 + else: + for i, mdm in enumerate(allmdm): + self.R[i, i] = mdm ** 2 + + def matrix_to_state(self, statevector): + for n in range(self.nlag): + members = statevector.ensemble_members[n] + for m, mem in enumerate(members): + members[m].param_values[:] = self.X_prime[n * self.nparams:(n + 1) * self.nparams, m] + self.x[n * self.nparams:(n + 1) * self.nparams] + + #msteiner: + statevector.isOptimized = True + #--------- + + logging.debug('Returning optimized data to the StateVector, setting "StateVector.isOptimized = True" ') + + def write_diagnostics(self, filename, type): + """ + Open a NetCDF file and write diagnostic output from optimization process: + + - calculated residuals + - model-data mismatches + - HPH^T + - prior ensemble of samples + - posterior ensemble of samples + - prior ensemble of fluxes + - posterior ensemble of fluxes + + The type designation refers to the writing of prior or posterior data and is used in naming the variables" + """ + + # Open or create file + + if type == 'prior': + f = io.CT_CDF(filename, method='create') + logging.debug('Creating new diagnostics file for optimizer (%s)' % filename) + elif type == 'optimized': + f = io.CT_CDF(filename, method='write') + logging.debug('Opening existing diagnostics file for optimizer (%s)' % filename) + + # Add dimensions + + dimparams = f.add_params_dim(self.nparams) + dimmembers = f.add_members_dim(self.nmembers) + dimlag = f.add_lag_dim(self.nlag, unlimited=False) + dimobs = f.add_obs_dim(self.nobs) + dimstate = f.add_dim('nstate', self.nparams * self.nlag) + dim200char = f.add_dim('string_of200chars', 200) + + # Add data, first the ones that are written both before and after the optimization + + savedict = io.std_savedict.copy() + savedict['name'] = "statevectormean_%s" % type + savedict['long_name'] = "full_statevector_mean_%s" % type + savedict['units'] = "unitless" + savedict['dims'] = dimstate + savedict['values'] = self.x.tolist() + savedict['comment'] = 'Full %s state vector mean ' % type + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "statevectordeviations_%s" % type + savedict['long_name'] = "full_statevector_deviations_%s" % type + savedict['units'] = "unitless" + savedict['dims'] = dimstate + dimmembers + savedict['values'] = self.X_prime.tolist() + savedict['comment'] = 'Full state vector %s deviations as resulting from the optimizer' % type + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "modelsamplesmean_%s" % type + savedict['long_name'] = "modelsamplesforecastmean_%s" % type + savedict['units'] = "mol mol-1" + savedict['dims'] = dimobs + savedict['values'] = self.Hx.tolist() + savedict['comment'] = '%s mean mole fractions based on %s state vector' % (type, type) + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "modelsamplesdeviations_%s" % type + savedict['long_name'] = "modelsamplesforecastdeviations_%s" % type + savedict['units'] = "mol mol-1" + savedict['dims'] = dimobs + dimmembers + savedict['values'] = self.HX_prime.tolist() + savedict['comment'] = '%s mole fraction deviations based on %s state vector' % (type, type) + f.add_data(savedict) + + # Continue with prior only data + + if type == 'prior': + + savedict = io.std_savedict.copy() + savedict['name'] = "sitecode" + savedict['long_name'] = "site code propagated from observation file" + savedict['dtype'] = "char" + savedict['dims'] = dimobs + dim200char + savedict['values'] = self.sitecode + savedict['missing_value'] = '!' + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "observed" + savedict['long_name'] = "observedvalues" + savedict['units'] = "mol mol-1" + savedict['dims'] = dimobs + savedict['values'] = self.obs.tolist() + savedict['comment'] = 'Observations used in optimization' + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "obspack_num" + savedict['dtype'] = "int64" + savedict['long_name'] = "Unique_ObsPack_observation_number" + savedict['units'] = "" + savedict['dims'] = dimobs + savedict['values'] = self.obs_ids.tolist() + savedict['comment'] = 'Unique observation number across the entire ObsPack distribution' + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "modeldatamismatchvariance" + savedict['long_name'] = "modeldatamismatch variance" + savedict['units'] = "[mol mol-1]^2" + if self.algorithm == 'Serial': + savedict['dims'] = dimobs + else: savedict['dims'] = dimobs + dimobs + savedict['values'] = self.R.tolist() + savedict['comment'] = 'Variance of mole fractions resulting from model-data mismatch' + f.add_data(savedict) + + # Continue with posterior only data + + elif type == 'optimized': + + savedict = io.std_savedict.copy() + savedict['name'] = "totalmolefractionvariance" + savedict['long_name'] = "totalmolefractionvariance" + savedict['units'] = "[mol mol-1]^2" + if self.algorithm == 'Serial': + savedict['dims'] = dimobs + else: savedict['dims'] = dimobs + dimobs + savedict['values'] = self.HPHR.tolist() + savedict['comment'] = 'Variance of mole fractions resulting from prior state and model-data mismatch' + f.add_data(savedict) + + savedict = io.std_savedict.copy() + savedict['name'] = "flag" + savedict['long_name'] = "flag_for_obs_model" + savedict['units'] = "None" + savedict['dims'] = dimobs + savedict['values'] = self.flags.tolist() + savedict['comment'] = 'Flag (0/1/2/99) for observation value, 0 means okay, 1 means QC error, 2 means rejected, 99 means not sampled' + f.add_data(savedict) + + #savedict = io.std_savedict.copy() + #savedict['name'] = "kalmangainmatrix" + #savedict['long_name'] = "kalmangainmatrix" + #savedict['units'] = "unitless molefraction-1" + #savedict['dims'] = dimstate + dimobs + #savedict['values'] = self.KG.tolist() + #savedict['comment'] = 'Kalman gain matrix of all obs and state vector elements' + #dummy = f.add_data(savedict) + + f.close() + logging.debug('Diagnostics file closed') + + + def serial_minimum_least_squares(self,n_bg_params=0): + """ Make minimum least squares solution by looping over obs""" + + # Calculate prior value cost function (observation part) + res_prior = np.abs(self.obs-self.Hx) + select = (res_prior < 1E15).nonzero()[0] + J_prior = res_prior.take(select,axis=0)**2/self.R.take(select,axis=0) + res_prior = np.mean(res_prior) + for n in range(self.nobs): + + # Screen for flagged observations (for instance site not found, or no sample written from model) + + if self.flags[n] != 0: + logging.debug('Skipping observation (%s,%i) because of flag value %d' % (self.sitecode[n], self.obs_ids[n], self.flags[n])) + logging.info('Skipping observation (%s,%i) because of flag value %d' % (self.sitecode[n], self.obs_ids[n], self.flags[n])) + continue + + # Screen for outliers greather than 3x model-data mismatch, only apply if obs may be rejected + + res = self.obs[n] - self.Hx[n] + + if self.may_reject[n]: + threshold = self.rejection_threshold[n] * np.sqrt(self.R[n]) + if np.abs(res) > threshold: + logging.debug('Rejecting observation (%s,%i) because residual (%f) exceeds threshold (%f)' % (self.sitecode[n], self.obs_ids[n], res, threshold)) + logging.info('Rejecting observation (%s,%i) because residual (%f) exceeds threshold (%f)' % (self.sitecode[n], self.obs_ids[n], res, threshold)) + self.flags[n] = 2 + continue + + logging.debug('Proceeding to assimilate observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) + logging.info('Proceeding to assimilate observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) + + PHt = 1. / (self.nmembers - 1) * np.dot(self.X_prime, self.HX_prime[n, :]) + self.HPHR[n] = 1. / (self.nmembers - 1) * (self.HX_prime[n, :] * self.HX_prime[n, :]).sum() + self.R[n] + self.KG[:] = PHt / self.HPHR[n] + + if self.may_localize[n]: + logging.debug('Trying to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) + logging.info('Trying to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) + self.localize(n,n_bg_params) + else: + logging.debug('Not allowed to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) +# logging.info('Not allowed to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) + + alpha = np.double(1.0) / (np.double(1.0) + np.sqrt((self.R[n]) / self.HPHR[n])) + + self.x[:] = self.x + self.KG[:] * res + + for r in range(self.nmembers): +# logging.info('X_prime before: %s'%(str(self.X_prime[:, r]))) + self.X_prime[:, r] = self.X_prime[:, r] - alpha * self.KG[:] * (self.HX_prime[n, r]) +# logging.info('X_prime after: %s'%(str(self.X_prime[:, r]))) +# logging.info('======================================') + del r + + # update samples to account for update of statevector based on observation n + HXprime_n = self.HX_prime[n,:].copy() + res = self.obs[n] - self.Hx[n] + fac = 1.0 / (self.nmembers - 1) * np.sum(HXprime_n[np.newaxis,:] * self.HX_prime, axis=1) / self.HPHR[n] + self.Hx = self.Hx + fac*res + self.HX_prime = self.HX_prime - alpha* fac[:,np.newaxis]*HXprime_n + + + del n + if 'HXprime_n' in globals(): del HXprime_n + + # calculate posterior value cost function + res_post = np.abs(self.obs-self.Hx) + select = (res_post < 1E15).nonzero()[0] + J_post = res_post.take(select,axis=0)**2/self.R.take(select,axis=0) + res_post = np.mean(res_post) + + logging.info('Observation part cost function: prior = %s, posterior = %s' % (np.mean(J_prior), np.mean(J_post))) + logging.info('Mean residual: prior = %s, posterior = %s' % (res_prior, res_post)) + +#WP !!!! Very important to first do all obervations from n=1 through the end, and only then update 1,...,n. The current observation +#WP should always be updated last because it features in the loop of the adjustments !!!! +# +# for m in range(n + 1, self.nobs): +# res = self.obs[n] - self.Hx[n] +# fac = 1.0 / (self.nmembers - 1) * (self.HX_prime[n, :] * self.HX_prime[m, :]).sum() / self.HPHR[n] +# self.Hx[m] = self.Hx[m] + fac * res +# self.HX_prime[m, :] = self.HX_prime[m, :] - alpha * fac * self.HX_prime[n, :] +# +# for m in range(1, n + 1): +# res = self.obs[n] - self.Hx[n] +# fac = 1.0 / (self.nmembers - 1) * (self.HX_prime[n, :] * self.HX_prime[m, :]).sum() / self.HPHR[n] +# self.Hx[m] = self.Hx[m] + fac * res +# self.HX_prime[m, :] = self.HX_prime[m, :] - alpha * fac * self.HX_prime[n, :] + + + + def bulk_minimum_least_squares(self): + """ Make minimum least squares solution by solving matrix equations""" + + + # Create full solution, first calculate the mean of the posterior analysis + + HPH = np.dot(self.HX_prime, np.transpose(self.HX_prime)) / (self.nmembers - 1) # HPH = 1/N * HX' * (HX')^T + self.HPHR[:, :] = HPH + self.R # HPHR = HPH + R + HPb = np.dot(self.X_prime, np.transpose(self.HX_prime)) / (self.nmembers - 1) # HP = 1/N X' * (HX')^T + self.KG[:, :] = np.dot(HPb, la.inv(self.HPHR)) # K = HP/(HPH+R) + + for n in range(self.nobs): + self.localize(n) + + self.x[:] = self.x + np.dot(self.KG, self.obs - self.Hx) # xa = xp + K (y-Hx) + + # And next make the updated ensemble deviations. Note that we calculate P by using the full equation (10) at once, and + # not in a serial update fashion as described in Whitaker and Hamill. + # For the current problem with limited N_obs this is easier, or at least more straightforward to do. + + I = np.identity(self.nlag * self.nparams) + sHPHR = la.cholesky(self.HPHR) # square root of HPH+R + part1 = np.dot(HPb, np.transpose(la.inv(sHPHR))) # HP(sqrt(HPH+R))^-1 + part2 = la.inv(sHPHR + np.sqrt(self.R)) # (sqrt(HPH+R)+sqrt(R))^-1 + Kw = np.dot(part1, part2) # K~ + self.X_prime[:, :] = np.dot(I, self.X_prime) - np.dot(Kw, self.HX_prime) # HX' = I - K~ * HX' + + + # Now do the adjustments of the modeled mole fractions using the linearized ensemble. These are not strictly needed but can be used + # for diagnosis. + + part3 = np.dot(HPH, np.transpose(la.inv(sHPHR))) # HPH(sqrt(HPH+R))^-1 + Kw = np.dot(part3, part2) # K~ + self.Hx[:] = self.Hx + np.dot(np.dot(HPH, la.inv(self.HPHR)), self.obs - self.Hx) # Hx = Hx+ HPH/HPH+R (y-Hx) + self.HX_prime[:, :] = self.HX_prime - np.dot(Kw, self.HX_prime) # HX' = HX'- K~ * HX' + + logging.info('Minimum Least Squares solution was calculated, returning') + + + def set_localization(self, loctype='None'): + """ determine which localization to use """ + + if loctype == 'CT2007': + self.localization = True + self.localizetype = 'CT2007' + #T-test values for two-tailed student's T-test using 95% confidence interval for some options of nmembers + if self.nmembers == 50: + self.tvalue = 2.0086 + elif self.nmembers == 100: + self.tvalue = 1.9840 + elif self.nmembers == 150: + self.tvalue = 1.97591 + elif self.nmembers == 192: + self.tvalue = 1.9724 + elif self.nmembers == 200: + self.tvalue = 1.9719 + else: self.tvalue = 0 + elif loctype == 'spatial': + logging.info('Spatial localization selected') + self.localization = True + self.localizetype = 'spatial' + else: + self.localization = False + self.localizetype = 'None' + + logging.info("Current localization option is set to %s" % self.localizetype) + if ((self.localization == True) and (self.localizetype == 'CT2007')): + if self.tvalue == 0: + logging.error("Critical tvalue for localization not set for %i ensemble members"%(self.nmembers)) + sys.exit(2) + else: logging.info("Used critical tvalue %0.05f is based on 95%% probability and %i ensemble members in a two-tailed student's T-test"%(self.tvalue,self.nmembers)) + + + def get_prob(self,n,i): +# def get_prob(self,obsdev,paramdev,r): + """Calculate probability from correlations""" +# corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] +# corr = np.corrcoef(obsdev,paramdev)[0,1] +# corr = np.ma.corrcoef(np.ma.masked_invalid(self.HX_prime[n, :]),np.ma.masked_invalid(self.X_prime[r, :].squeeze()))[0,1] + for r in np.arange(i,self.nlag * self.nparams)[::36]: + corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] + prob = corr / np.sqrt((1.000000001 - corr ** 2) / (self.nmembers - 2)) + if abs(prob) < self.tvalue: + self.KG[r] = 0.0 + + + def localize(self, n, n_bg_params): + skip_stations = ['Malin Head_47', + 'Hegyhatsal hatterszennyettseg-mero allomas_48', + 'Hegyhatsal hatterszennyettseg-mero allomas_82', + 'Birkenes_2', + 'Hegyhatsal hatterszennyettseg-mero allomas_115', + 'Hegyhatsal hatterszennyettseg-mero allomas_10', + 'Beromunster_12', + 'Beromunster_44', + 'Beromunster_72', + 'Beromunster_132', + 'Bilsdale_42', + 'Bilsdale_108', + 'Cabauw_27', + 'Cabauw_67', + 'Cabauw_127', + 'Gartow_30', + 'Gartow_60', + 'Gartow_132', + 'Gartow_216', + 'Hohenpeissenberg_50', + 'Hohenpeissenberg_93', + 'Hyltemossa_30', + 'Hyltemossa_70', + 'Ispara_40', + 'Ispra_70', + 'Karlsruhe_30', + 'Karlsruhe_60', + 'Karlsruhe_100', + 'Kresin u Pacova_10', + 'Kresin u Pacova_50', + 'Kresin u Pacova_125', + 'Lindenberg_2', + 'Lindenberg_10', + 'Lindenberg_40', + 'Observatoire de Haute Provence_10', + 'Observatoire de Haute Provence_50', + "Observatoire perenne de l'environnement_10", + "Observatoire perenne de l'environnement_50", + 'Ridge Hill_45', + 'Saclay_15', + 'Saclay_60', + 'Tacolneston_54', + 'Tacolneston_100', + 'Torfhaus_10', + 'Torfhaus_76', + 'Torfhaus_110', + 'Trainou_5', + 'Trainou_50', + 'Trainou_100', + ] + + """ localize the Kalman Gain matrix """ + import numpy as np + from multiprocessing import Pool + + if not self.localization: + logging.debug('Not localized observation %i' % self.obs_ids[n]) + return + if self.localizetype == 'CT2007': + +# count_localized = 0 +# for r in range(self.nlag * self.nparams): +## corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] +# corr = np.ma.corrcoef(np.ma.masked_invalid(self.HX_prime[n, :]),np.ma.masked_invalid(self.X_prime[r, :].squeeze()))[0,1] +# prob = corr / np.sqrt((1.000000001 - corr ** 2) / (self.nmembers - 2)) +# if abs(prob) < self.tvalue: +# self.KG[r] = 0.0 +# count_localized = count_localized + 1 +# logging.debug('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) +# logging.info('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) + + ############################################ + ###make the CT2007 parallel: +# args = [ (n, i) for i in range(self.nlag * self.nparams) ] + args = [ (n, i) for i in range(36) ] +# args = [ (self.HX_prime[n, :], self.X_prime[r, :].squeeze(), r ) for r in range(self.nlag * self.nparams) ] + with Pool(36) as pool: + pool.starmap(self.get_prob, args) +# count_localized = 0 +# for r in range(self.nlag * self.nparams): +# if abs(prob[r]) < self.tvalue: +# self.KG[r] = 0.0 +# count_localized = count_localized + 1 +# logging.debug('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) +# logging.info('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) + logging.info('Localized observation %i' % (self.obs_ids[n])) + ############################################ + + + elif self.localizetype == 'spatial': +# ### if self.loc_L[n] > 0: +# ### obslati, obsloni = self.find_coord_index(self.latitude[n],self.longitude[n],180,360) +# ### for l in range(self.nlag): +# ### self.KG[l*self.nparams:(l+1)*self.nparams] = np.multiply(self.KG[l*self.nparams:(l+1)*self.nparams], self.loc_coeff[str(self.loc_L[n])][obslati,obsloni,:]) +# ### logging.debug('Localized observation %i with localization length %s' %(self.obs_ids[n], self.loc_L[n])) +# print(self.latitude[n], self.longitude[n], "lat and lon!") + +# n_em_cat = 2 +# lfound = False +# for iname,stationname in enumerate(self.name_array): +# if stationname in skip_stations: continue # Skip stations outside of the domain! +# if stationname==self.fromfile[n]: +# coeff_l = np.zeros((n_em_cat*len(self.coeff_matrix[iname,:]))) +# for i_n_cat in range(n_em_cat): +# coeff_l[i_n_cat:][::n_em_cat] = self.coeff_matrix[iname,:] + +# for l in range(self.nlag): +# self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params] = np.multiply( self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params], coeff_l ) + +# logging.info('Localized observation %i at station %s (nr. %i)'%(self.obs_ids[n],stationname,iname)) + +# lfound = True + +# break + +# if not lfound: +# logging.info('Not localized observation %i as coefficient not found' %(self.obs_ids[n])) +### if self.loc_L[n] > 0: +### obslati, obsloni = self.find_coord_index(self.latitude[n],self.longitude[n],180,360) +### for l in range(self.nlag): +### self.KG[l*self.nparams:(l+1)*self.nparams] = np.multiply(self.KG[l*self.nparams:(l+1)*self.nparams], self.loc_coeff[str(self.loc_L[n])][obslati,obsloni,:]) +### logging.debug('Localized observation %i with localization length %s' %(self.obs_ids[n], self.loc_L[n])) + + n_em_cat = 2 + if self.fromfile[n] in skip_stations: return # Skip stations outside of the domain! + + coeff_l = np.zeros((n_em_cat*len(self.coeff_matrix[n,:]))) + for i_n_cat in range(n_em_cat): + coeff_l[i_n_cat:][::n_em_cat] = self.coeff_matrix[n,:] + + for l in range(self.nlag): + self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params] = np.multiply( self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params], coeff_l ) + + logging.info('Localized observation %i at station %s (nr. %i)'%(self.obs_ids[n],self.fromfile[n], n)) + + + def set_algorithm(self, algorithm='Serial'): + """ determine which minimum least squares algorithm to use """ + + if algorithm == 'Serial': + self.algorithm = 'Serial' + else: + self.algorithm = 'Bulk' + + logging.info("Current minimum least squares algorithm is set to %s" % self.algorithm) + +################### End Class Optimizer ################### + + + +if __name__ == "__main__": + pass diff --git a/cases/icon-art-CTDAS2/ctdas_patch/statevector_baseclass_icos_cities.py b/cases/icon-art-CTDAS2/ctdas_patch/statevector_baseclass_icos_cities.py new file mode 100644 index 00000000..a93c4a2a --- /dev/null +++ b/cases/icon-art-CTDAS2/ctdas_patch/statevector_baseclass_icos_cities.py @@ -0,0 +1,643 @@ +"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +updates of the code. See also: http://www.carbontracker.eu. + +This program is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free Software Foundation, +version 3. This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this +program. If not, see .""" +#!/usr/bin/env python +# ct_statevector_tools.py + +""" +.. module:: statevector +.. moduleauthor:: Wouter Peters + +Revision History: +File created on 28 Jul 2010. + +The module statevector implements the data structure and methods needed to work with state vectors (a set of unknown parameters to be optimized by a DA system) of different lengths, types, and configurations. Two baseclasses together form a generic framework: + * :class:`~da.baseclasses.statevector.StateVector` + * :class:`~da.baseclasses.statevector.EnsembleMember` + +As usual, specific implementations of StateVector objects are done through inheritance form these baseclasses. An example of designing +your own baseclass StateVector we refer to :ref:`tut_chapter5`. + +.. autoclass:: da.baseclasses.statevector.StateVector + +.. autoclass:: da.baseclasses.statevector.EnsembleMember + +""" + +import os +import logging +import numpy as np +from scipy.linalg import cholesky +from datetime import timedelta +import datetime as dt +import da.tools.io4 as io +import csv +from multiprocessing import Pool +import xarray as xr + +identifier = 'ICON Statevector ' +version = '0.0' + +################### Begin Class EnsembleMember ################### + +class EnsembleMember(object): + """ + An ensemble member object consists of: + * a member number + * parameter values + * an observation object to hold sampled values for this member + + Ensemble members are initialized by passing only an ensemble member number, all data is added by methods + from the :class:`~da.baseclasses.statevector.StateVector`. Ensemble member objects have almost no functionality + except to write their data to file using method :meth:`~da.baseclasses.statevector.EnsembleMember.write_to_file` + + .. automethod:: da.baseclasses.statevector.EnsembleMember.__init__ + .. automethod:: da.baseclasses.statevector.EnsembleMember.write_to_file + .. automethod:: da.baseclasses.statevector.EnsembleMember.AddCustomFields + + """ + + def __init__(self, membernumber): + """ + :param memberno: integer ensemble number + :rtype: None + + An EnsembleMember object is initialized with only a number, and holds two attributes as containter for later + data: + * param_values, will hold the actual values of the parameters for this data + * ModelSample, will hold an :class:`~da.baseclasses.obs.Observation` object and the model samples resulting from this members' data + + """ + self.membernumber = membernumber # the member number + self.param_values = None # Parameter values of this member + +################### End Class EnsembleMember ################### + +################### Begin Class StateVector ################### + + +class StateVector(object): + """ + The StateVector object first of all contains the data structure of a statevector, defined by 3 attributes that define the + dimensions of the problem in parameter space: + * nlag + * nparameters + * nmembers + + The fourth important dimension `nobs` is not related to the StateVector directly but is initialized to 0, and later on + modified to be used in other parts of the pipeline: + * nobs + + These values are set as soon as the :meth:`~da.baseclasses.statevector.StateVector.setup` is called from the :ref:`pipeline`. + Additionally, the value of attribute `isOptimized` is set to `False` indicating that the StateVector holds a-priori values + and has not been modified by the :ref:`optimizer`. + + StateVector objects can be filled with data in two ways + 1. By reading the data from file + 2. By creating the data through a set of method calls + + Option (1) is invoked using method :meth:`~da.baseclasses.statevector.StateVector.read_from_file`. + Option (2) consists of a call to method :meth:`~da.baseclasses.statevector.StateVector.make_new_ensemble` + + Once the StateVector object has been filled with data, it is used in the pipeline and a few more methods are + invoked from there: + * :meth:`~da.baseclasses.statevector.StateVector.propagate`, to advance the StateVector from t=t to t=t+1 + * :meth:`~da.baseclasses.statevector.StateVector.write_to_file`, to write the StateVector to a NetCDF file for later use + + The methods are described below: + + .. automethod:: da.baseclasses.statevector.StateVector.setup + .. automethod:: da.baseclasses.statevector.StateVector.read_from_file + .. automethod:: da.baseclasses.statevector.StateVector.write_to_file + .. automethod:: da.baseclasses.statevector.StateVector.make_new_ensemble + .. automethod:: da.baseclasses.statevector.StateVector.propagate + .. automethod:: da.baseclasses.statevector.StateVector.write_members_to_file + + Finally, the StateVector can be mapped to a gridded array, or to a vector of TransCom regions, using: + + .. automethod:: da.baseclasses.statevector.StateVector.grid2vector + .. automethod:: da.baseclasses.statevector.StateVector.vector2grid + .. automethod:: da.baseclasses.statevector.StateVector.vector2tc + .. automethod:: da.baseclasses.statevector.StateVector.state2tc + + """ + + def __init__(self): + self.ID = identifier + self.version = version + + # The following code allows the object to be initialized with a dacycle object already present. Otherwise, it can + # be added at a later moment. + + logging.info('Statevector object initialized: %s' % self.ID) + + def setup(self, dacycle): + """ + setup the object by specifying the dimensions. + There are two major requirements for each statvector that you want to build: + + (1) is that the statevector can map itself onto a regular grid + (2) is that the statevector can map itself (mean+covariance) onto TransCom regions + + An example is given below. + """ + + self.nlag = int(dacycle['time.nlag']) + self.nmembers = int(dacycle['da.optimizer.nmembers']) #number of ensemble members, e.g. 192 for the icon case + self.nparams = int(dacycle.dasystem['nparameters']) #n_reg * n_tracers * n_categories + n_bg_params + self.nobs = 0 + + self.obs_to_assimilate = () # empty containter to hold observations to assimilate later on + + # These list objects hold the data for each time step of lag in the system. Note that the ensembles for each time step consist + # of lists of EnsembleMember objects, we define member 0 as the mean of the distribution and n=1,...,nmembers as the spread. + + self.ensemble_members = list(range(self.nlag)) + + for n in range(self.nlag): + self.ensemble_members[n] = [] + + #msteiner: + self.isOptimized = False + self.C = np.zeros((self.nparams,self.nparams)) + self.distances = dacycle['sv.distances'] + #--------- + + + + def make_new_ensemble(self, lag, covariancematrix=None,n_bg_params=0): + """ + :param lag: an integer indicating the time step in the lag order + :param covariancematrix: a matrix to draw random values from + :rtype: None + + Make a new ensemble, the attribute lag refers to the position in the state vector. + Note that lag=1 means an index of 0 in python, hence the notation lag-1 in the indexing below. + The argument is thus referring to the lagged state vector as [1,2,3,4,5,..., nlag] + + The optional covariance object to be passed holds a matrix of dimensions [nparams, nparams] which is + used to draw ensemblemembers from. If this argument is not passed it will ne substituted with an + identity matrix of the same dimensions. + + """ + + logging.info('msteiner: current lag: %i '%(lag)) + logging.info('msteiner: nlag; %i '%(self.nlag)) + categories = 2 + if np.all(self.C==0.): + logging.info('msteiner: performing cholesky decomposition') + + +# covariancematrix = np.identity((self.nparams)) + + Corr = np.array([[1, 0], # VPRM + [0, 1]]) #U + + +# covariancematrix = np.identity((self.nparams)) + + + covariancematrix = np.zeros((self.nparams,self.nparams), dtype=np.float32) + # covariancematrix = np.zeros((self.nparams,self.nparams)) + # print("COV=", covariancematrix.shape) + specific_length_bio = 300 + specific_length_anth = 200 + # print("dist=", self.distances) + + ds = xr.open_dataset(self.distances) + logging.info('opened distances file, nparams = %d'%self.nparams) + distances = ds.Distances.values + # covariancematrix[:-n_bg_params, :-n_bg_params] = np.kron(np.exp(-distances/specific_length), c), c is the correlation matrix between categories + # for ix, x in enumerate(distances): + # if ix<1: + # covariancematrix[0,0:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) + # covariancematrix[1,1:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) + # covariancematrix[2,2:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) + # else: + # covariancematrix[3*(ix)+0,0:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) + # covariancematrix[3*(ix)+1,1:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) + # covariancematrix[3*(ix)+2,2:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) + for ix, x in enumerate(distances): + for ic, c in enumerate(Corr): + for ik, k in enumerate(c): + if ic == 1 or ik == 1: + covariancematrix[ix*categories + ic,ik:-n_bg_params][::categories] = 0.5*np.exp(-x/specific_length_anth)*k + else: + covariancematrix[ix*categories + ic,ik:-n_bg_params][::categories] = 1*np.exp(-x/specific_length_bio)*k + + #covariancematrix = np.zeros((self.nparams,self.nparams), dtype=np.float32) + # covariancematrix = np.zeros((self.nparams,self.nparams)) + # specific_length=200 + + # print(self.distances) + # print(covariancematrix.shape) + # ds = xr.open_dataset(self.distances) + # #logging.info('opened distances file, nparams = %d'%self.nparams) + # distances = ds.Distances.values + # for ix, x in enumerate(distances): + # if ix<1: + # covariancematrix[0,0:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) + # covariancematrix[1,1:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) + # covariancematrix[2,2:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) + # else: + # covariancematrix[3*(ix)+0,0:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) + # covariancematrix[3*(ix)+1,1:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) + # covariancematrix[3*(ix)+2,2:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) + + #set variances for the 8 background elements (note python indexing) (10% std in this case): + if n_bg_params>0: + for iii in np.arange(n_bg_params): + covariancematrix[-n_bg_params+ iii ,-n_bg_params+iii] = 0.015*0.015 # 0.015*400 = 6 ppm stdev + covariancematrix[-n_bg_params+np.mod(iii+1,n_bg_params),-n_bg_params+iii] = 0.015*0.015*0.25 + covariancematrix[-n_bg_params+np.mod(iii-1,n_bg_params),-n_bg_params+iii] = 0.015*0.015*0.25 + #logging.info('Filled in cov matrix, dtype %s, %s, %d, %d'%(str(covariancematrix.dtype),str(covariancematrix[0][0].dtype), covariancematrix.shape[0], covariancematrix.shape[1]) ) + self.C = np.linalg.cholesky(covariancematrix) + del covariancematrix + + +# # covariancematrix[covariancematrix<1.2e-2] = 0. +# +# #set variances for lbc-scaling +## for idir in np.arange(4): +## covariancematrix[-(idir+1),-(idir+1)] = 0.5 + + # msteiner: commented-out the svd as it takes endless time for a large statevector and + #... it is just for information about the dof + +# try: +# _, s, _ = np.linalg.svd(covariancematrix) +# except: +# s = np.linalg.svd(covariancematrix, full_matrices=1, compute_uv=0) #Cartesius fix +# dof = np.sum(s) ** 2 / sum(s ** 2) + + logging.info('Cholesky decomposition has finished') +# logging.info('Appr. degrees of freedom in covariance matrix is %s' % (int(dof))) + + + + # Create mean values + newmean = np.ones(self.nparams, float) # standard value for a new time step is 1.0 + if lag == self.nlag - 1 and self.nlag >= 2: + newmean += 2*self.ensemble_members[lag - 1][0].param_values + newmean = newmean / 3.0 + + + #Propagate background mean state by 100%: + if n_bg_params>0: + newmean[self.nparams-n_bg_params:] = self.ensemble_members[lag - 1][0].param_values[self.nparams-n_bg_params:] + + + ####### New forecast model for the mean: take 100% of the optimized value ####### + #newmean = np.ones(self.nparams, float) # standard value for a new time step is 1.0 + #if lag == self.nlag - 1 and self.nlag >= 2: #self.nlag >= 3: + # newmean -= 1. + # newmean += self.ensemble_members[lag - 1][0].param_values + ####### --- ####### + + #DEBUG newmean + for cat in range(categories): + logging.info('Category (%s) ' % str(cat + 1)) + logging.info('New mean (%s) ' % str(np.nanmean(newmean[cat:][::categories]))) + # Create the first ensemble member with a deviation of 0.0 and add to list + newmember = EnsembleMember(0) + newmember.param_values = newmean.flatten() # no deviations + self.ensemble_members[lag].append(newmember) + + # Create members 1:nmembers and add to ensemble_members list + #np.random.normal(loc=1.0, scale=0.5, size=100) + for member in range(1, self.nmembers): + rands = np.random.randn(self.nparams) + newmember = EnsembleMember(member) + logging.info('pre-dot') + # newmember.param_values = np.dot(self.C, rands) + newmean + newmember.param_values = np.einsum("ij, j -> i", self.C, rands) + newmean + logging.info('post-dot') + self.ensemble_members[lag].append(newmember) + logging.info('Created parameters for ensemble member %i'%(member)) + + #DEBUG lambdas + lambdas = np.array([]) + for member in range(0, self.nmembers): + logging.info('Member shape (%s) ' % str(np.shape(self.ensemble_members[lag][member].param_values))) + lambdas = np.append(lambdas, self.ensemble_members[lag][member].param_values) + lambdas = np.reshape(lambdas, (self.nmembers, self.nparams)) + members_array = np.mean(lambdas, axis = 0) + # logging.info('Member array shape (%s) ' % str(np.shape(members_array))) + for cat in range(categories): + logging.info('Category (%s) ' % str(cat + 1)) + logging.info('Lambda mean (%s) ' % str(np.nanmean(members_array[cat:][::categories]))) + + #del C #msteiner: this line causes the "invalid pointer"-error at this point, otherwise it occurs after the code reached the end of this function + + logging.info('%d new ensemble members were added to the state vector # %d' % (self.nmembers, (lag + 1))) + + + def propagate(self, dacycle, method='create_new_member', filename=None, date=None, initdir=None): + """ + :rtype: None + + Propagate the parameter values in the StateVector to the next cycle. This means a shift by one cycle + step for all states that will + be optimized once more, and the creation of a new ensemble for the time step that just + comes in for the first time (step=nlag). + In the future, this routine can incorporate a formal propagation of the statevector. + + """ + + # Remove State Vector n=1 by simply "popping" it from the list and appending a new empty list at the front. This empty list will + # hold the new ensemble for the new cycle + + self.ensemble_members.pop(0) + self.ensemble_members.append([]) + + # And now create a new time step of mean + members for n=nlag + if method == 'create_new_member': + date = dacycle['time.start'] + timedelta(days=(self.nlag - 0.5) * int(dacycle['time.cycle'])) + cov = self.get_covariance(date, dacycle) + self.make_new_ensemble(self.nlag - 1, cov,int(dacycle['statevector.bg_params'])) + + elif method == 'read_new_member': + if os.path.exists(filename): + self.read_ensemble_member_from_file(filename, self.nlag-1, qual='opt', read_lag=0) + else: + self.read_ensemble_member_from_file(filename, self.nlag-1, date, initdir, qual='opt', read_lag=0) + + elif method == 'read_mean': + date = dacycle['time.start'] + timedelta(days=(self.nlag - 0.5) * int(dacycle['time.cycle'])) + cov = self.get_covariance(date, dacycle) + if os.path.exists(filename): + meanstate = self.read_mean_from_file(filename, self.nlag-1, qual='opt') + else: + meanstate = self.read_mean_from_file(filename, self.nlag-1, date, initdir, qual='opt') + self.make_new_ensemble(self.nlag - 1, cov, meanstate) + + logging.info('The state vector has been propagated by one cycle') + + + def write_to_file(self, filename, qual): + """ + :param filename: the full filename for the output NetCDF file + :rtype: None + + Write the StateVector information to a NetCDF file for later use. + In principle the output file will have only one two datasets inside + called: + * `meanstate`, dimensions [nlag, nparamaters] + * `ensemblestate`, dimensions [nlag,nmembers, nparameters] + + This NetCDF information can be read back into a StateVector object using + :meth:`~da.baseclasses.statevector.StateVector.read_from_file` + + """ + #import da.tools.io4 as io + #import da.tools.io as io + + if qual == 'prior': + f = io.CT_CDF(filename, method='create') + logging.debug('Creating new StateVector output file (%s)' % filename) + #qual = 'prior' + else: + f = io.CT_CDF(filename, method='write') + logging.debug('Opening existing StateVector output file (%s)' % filename) + #qual = 'opt' + + dimparams = f.add_params_dim(self.nparams) + dimmembers = f.add_members_dim(self.nmembers) + dimlag = f.add_lag_dim(self.nlag, unlimited=True) + + for n in range(self.nlag): + members = self.ensemble_members[n] + mean_state = members[0].param_values + + savedict = f.standard_var(varname='meanstate_%s' % qual) + savedict['dims'] = dimlag + dimparams + savedict['values'] = mean_state + savedict['count'] = n + savedict['comment'] = 'this represents the mean of the ensemble' + f.add_data(savedict) + + members = self.ensemble_members[n] + devs = np.asarray([m.param_values.flatten() for m in members]) + data = devs - np.asarray(mean_state) + + savedict = f.standard_var(varname='ensemblestate_%s' % qual) + savedict['dims'] = dimlag + dimmembers + dimparams + savedict['values'] = data + savedict['count'] = n + savedict['comment'] = 'this represents deviations from the mean of the ensemble' + f.add_data(savedict) + f.close() + + logging.info('Successfully wrote the State Vector to file (%s) ' % filename) + + + + def interpolate_mean_ensemble(self, initdir, date, qual='opt', readensemble=True): + # deduce window length of source run: + all_dates = os.listdir(initdir) + for i, dstr in enumerate(all_dates): + all_dates[i] = dt.datetime.strptime(dstr,'%Y%m%d') + del i, dstr + all_dates = sorted(all_dates) + ddays = (all_dates[1]-all_dates[0]).days + del all_dates + + # find dates in source directory just before and after target date + found_datemin, found_datemax = False, False + for d in range(ddays): + datei = date - dt.timedelta(days=d) + if not found_datemin and os.path.exists(os.path.join(initdir, datei.strftime('%Y%m%d'), 'savestate_%s.nc'%datei.strftime('%Y%m%d'))): + datemin = datei + found_datemin = True + + datei = date + dt.timedelta(days=d) + if not found_datemax and os.path.exists(os.path.join(initdir, datei.strftime('%Y%m%d'), 'savestate_%s.nc'%datei.strftime('%Y%m%d'))): + datemax = datei + found_datemax = True + + if found_datemin and found_datemax: + print('Found datemin = %s and datemax = %s' %(datemin.strftime('%Y%m%d'), datemax.strftime('%Y%m%d'))) + break + del d + logging.debug('Ensemble for %s will be interpolated from %s and %s' %(date.strftime('%Y-%m-%d'), datemin.strftime('%Y-%m-%d'),datemax.strftime('%Y-%m-%d'))) + + # Read ensemble from both files + filename1 = os.path.join(initdir, datemin.strftime('%Y%m%d'), 'savestate_%s.nc'%datemin.strftime('%Y%m%d')) + f = io.ct_read(filename1, 'read') + meanstate1 = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] + if readensemble: + ensmembers1 = f.get_variable('statevectorensemble_' + qual) # [nlag x nmembers x nparameters] + f.close() + + filename2 = os.path.join(initdir, datemax.strftime('%Y%m%d'), 'savestate_%s.nc'%datemax.strftime('%Y%m%d')) + f = io.ct_read(filename2, 'read') + meanstate2 = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] + if readensemble: + ensmembers2 = f.get_variable('statevectorensemble_' + qual) # [nlag x nmembers x nparameters] + f.close() + + # interpolate mean and ensemble between datemin and datemax + meanstate = ((datemax-date).days/ddays)*meanstate1 + ((date-datemin).days/ddays)*meanstate2 + if readensemble: + ensmembers = ((datemax-date).days/ddays)*ensmembers1 + ((date-datemin).days/ddays)*ensmembers2 + return meanstate, ensmembers + + else: + return meanstate + + + + def read_mean_from_file(self, filename, lag, date=None, initdir=None, qual='opt'): + if date is None: + f = io.ct_read(filename, 'read') + meanstate = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] + f.close + else: + meanstate = self.interpolate_mean_ensemble(initdir, date, qual, readensemble=False) + + logging.info('Successfully read the mean state vector from file (%s) ' %filename) + + return meanstate[lag,:] + + + + def read_ensemble_member_from_file(self, filename, lag, date=None, initdir=None, qual='opt', read_lag=0): + + # if date is None we can directly read mean and ensemble members. Else we will need to read 2 ensembles and interpolate + if date is None: + f = io.ct_read(filename, 'read') + meanstate = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] + ensmembers = f.get_variable('statevectorensemble_' + qual) # [nlag x nmembers x nparameters] + f.close() + + else: + meanstate, ensmembers = self.interpolate_mean_ensemble(initdir, date, qual, readensemble=True) + + # add to statevector + if not self.ensemble_members[lag] == []: + self.ensemble_members[lag] = [] + logging.warning('Existing ensemble for lag=%d was removed to make place for newly read data' % (n + 1)) + + for m in range(self.nmembers): + newmember = EnsembleMember(m) + newmember.param_values = ensmembers[read_lag, m, :].flatten() + meanstate[read_lag,:] # add the mean to the deviations to hold the full parameter values + self.ensemble_members[lag].append(newmember) + + logging.info('Successfully read the State Vector for lag %s from file (%s) ' % (lag,filename)) + + + + + def read_from_file(self, filename, qual='opt'): + """ + :param filename: the full filename for the input NetCDF file + :param qual: a string indicating whether to read the 'prior' or 'opt'(imized) StateVector from file + :rtype: None + + Read the StateVector information from a NetCDF file and put in a StateVector object + In principle the input file will have only one four datasets inside + called: + * `meanstate_prior`, dimensions [nlag, nparamaters] + * `ensemblestate_prior`, dimensions [nlag,nmembers, nparameters] + * `meanstate_opt`, dimensions [nlag, nparamaters] + * `ensemblestate_opt`, dimensions [nlag,nmembers, nparameters] + + This NetCDF information can be written to file using + :meth:`~da.baseclasses.statevector.StateVector.write_to_file` + + """ + + #import da.tools.io as io + f = io.ct_read(filename, 'read') + meanstate = f.get_variable('statevectormean_' + qual) + ensmembers = f.get_variable('statevectorensemble_' + qual) + f.close() + + for n in range(self.nlag): + if not self.ensemble_members[n] == []: + self.ensemble_members[n] = [] + logging.warning('Existing ensemble for lag=%d was removed to make place for newly read data' % (n + 1)) + + for m in range(self.nmembers): + newmember = EnsembleMember(m) + newmember.param_values = ensmembers[n, m, :].flatten() + meanstate[n] # add the mean to the deviations to hold the full parameter values + self.ensemble_members[n].append(newmember) + + logging.info('Successfully read the State Vector from file (%s) ' % filename) + + def write_members_to_file(self, lag, outdir, endswith='.nc', obsoperator=None): + """ + :param: lag: Which lag step of the filter to write, must lie in range [1,...,nlag] + :param: outdir: Directory where to write files + :param: endswith: Optional label to add to the filename, default is simply .nc + :rtype: None + + Write ensemble member information to a NetCDF file for later use. The standard output filename is + *parameters.DDD.nc* where *DDD* is the number of the ensemble member. Standard output file location + is the `dir.input` of the dacycle object. In principle the output file will have only two datasets inside + called `parametervalues` which is of dimensions `nparameters` and `parametermap` which is of dimensions (180,360). + This dataset can be read and used by a :class:`~da.baseclasses.observationoperator.ObservationOperator` object. + + .. note:: if more, or other information is needed to complete the sampling of the ObservationOperator you + can simply inherit from the StateVector baseclass and overwrite this write_members_to_file function. + + """ + + # These import statements caused a crash in netCDF4 on MacOSX. No problems on Jet though. Solution was + # to do the import already at the start of the module, not just in this method. + + #import da.tools.io as io + #import da.tools.io4 as io + + members = self.ensemble_members[lag] + + for mem in members: + filename = os.path.join(outdir, 'parameters.%03d%s' % (mem.membernumber, endswith)) + ncf = io.CT_CDF(filename, method='create') + dimparams = ncf.add_params_dim(self.nparams) + dimgrid = ncf.add_latlon_dim() + + data = mem.param_values + + savedict = io.std_savedict.copy() + savedict['name'] = "parametervalues" + savedict['long_name'] = "parameter_values_for_member_%d" % mem.membernumber + savedict['units'] = "unitless" + savedict['dims'] = dimparams + savedict['values'] = data + savedict['comment'] = 'These are parameter values to use for member %d' % mem.membernumber + ncf.add_data(savedict) + + griddata = self.vector2grid(vectordata=data) + + savedict = io.std_savedict.copy() + savedict['name'] = "parametermap" + savedict['long_name'] = "parametermap_for_member_%d" % mem.membernumber + savedict['units'] = "unitless" + savedict['dims'] = dimgrid + savedict['values'] = griddata.tolist() + savedict['comment'] = 'These are gridded parameter values to use for member %d' % mem.membernumber + ncf.add_data(savedict) + + ncf.close() + + logging.debug('Successfully wrote data from ensemble member %d to file (%s) ' % (mem.membernumber, filename)) + + + def get_covariance(self, date, cycleparams): + pass + +################### End Class StateVector ################### + +if __name__ == "__main__": + pass + diff --git a/cases/icon-art-CTDAS2/ctdas_patch/template.jb b/cases/icon-art-CTDAS2/ctdas_patch/template.jb new file mode 100644 index 00000000..06880a81 --- /dev/null +++ b/cases/icon-art-CTDAS2/ctdas_patch/template.jb @@ -0,0 +1,16 @@ +#!/bin/bash +## +## This is a set of dummy names, to be replaced by values from the dictionary +## Please make your own platform specific ctdas-icon with your own keys and place it in a subfolder of the da package. + ## +#SBATCH --job-name=CTDAS-cycle-1 +#SBATCH --partition=normal +#SBATCH --nodes=1 +#SBATCH --time=23:00:00 +#SBATCH --account={cfg.compute_account} +#SBATCH --ntasks-per-core=1 +#SBATCH --ntasks-per-node=36 + +export icycle_in_job=1 + +python3 $SCRATCH/ctdas_procchain/exec/ctdas_procchain.py -v rc=$SCRATCH/ctdas_procchain/exec/ctdas_procchain.rc >& $SCRATCH/ctdas_procchain/exec/ctdas_procchain.log diff --git a/cases/icon-art-CTDAS2/ctdas_patch/template.py b/cases/icon-art-CTDAS2/ctdas_patch/template.py new file mode 100644 index 00000000..540434a7 --- /dev/null +++ b/cases/icon-art-CTDAS2/ctdas_patch/template.py @@ -0,0 +1,81 @@ +"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +updates of the code. See also: http://www.carbontracker.eu. + +This program is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free Software Foundation, +version 3. This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this +program. If not, see .""" +#!/usr/bin/env python + +################################################################################################# +# First order of business is always to make all other python modules accessible through the path +################################################################################################# + +import sys +import os +import logging +sys.path.append(os.getcwd()) + +################################################################################################# +# Next, import the tools needed to initialize a data assimilation cycle +################################################################################################# + +from da.cyclecontrol.initexit_cteco2 import start_logger, validate_opts_args, parse_options, CycleControl +from da.pipelines.pipeline_icon import ensemble_smoother_pipeline, header, footer, analysis_pipeline, archive_pipeline +from da.dasystems.dasystem_baseclass import DaSystem +from da.platform.pizdaint import PizDaintPlatform +from da.statevectors.statevector_baseclass_icos_cities import StateVector +from da.observations.obs_class_ICOS_OCO2 import ICOSObservations, TotalColumnObservations # Here we set which observations we consider! +from da.obsoperators.obsoperator_ICOS_OCO2 import ObservationOperator # Here we set the obs-operator, which should sample the same observations! +from da.optimizers.optimizer_baseclass_icos_cities import Optimizer + + +################################################################################################# +# Parse and validate the command line options, start logging +################################################################################################# + +start_logger() +opts, args = parse_options() +opts, args = validate_opts_args(opts, args) + +################################################################################################# +# Create the Cycle Control object for this job +################################################################################################# + +dacycle = CycleControl(opts, args) + +platform = PizDaintPlatform() +dasystem = DaSystem(dacycle['da.system.rc']) +obsoperator = ObservationOperator(dacycle['da.obsoperator.rc']) +samples = [ICOSObservations(), TotalColumnObservations()] +statevector = StateVector() +optimizer = Optimizer() + +########################################################################################## +################### ENTER THE PIPELINE WITH THE OBJECTS PASSED BY THE USER ############### +########################################################################################## + + +logging.info(header + "Entering Pipeline " + footer) + +ensemble_smoother_pipeline(dacycle, platform, dasystem, samples, statevector, obsoperator,optimizer) + + +########################################################################################## +################### All done, extra stuff can be added next, such as analysis +########################################################################################## + +sys.exit(0) + +logging.info(header + "Starting analysis" + footer) + +analysis_pipeline(dacycle, platform, dasystem, samples, statevector ) + +sys.exit(0) + + diff --git a/cases/icon-art-CTDAS2/ctdas_patch/template.rc b/cases/icon-art-CTDAS2/ctdas_patch/template.rc new file mode 100644 index 00000000..564df385 --- /dev/null +++ b/cases/icon-art-CTDAS2/ctdas_patch/template.rc @@ -0,0 +1,116 @@ +! CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +! Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +! updates of the code. See also: http://www.carbontracker.eu. +! +! This program is free software: you can redistribute it and/or modify it under the +! terms of the GNU General Public License as published by the Free Software Foundation, +! version 3. This program is distributed in the hope that it will be useful, but +! WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +! FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. +! +! You should have received a copy of the GNU General Public License along with this +! program. If not, see . + +! author: Wouter Peters +! +! This is a blueprint for an rc-file used in CTDAS. Feel free to modify it, and please go to the main webpage for further documentation. +! +! Note that rc-files have the convention that commented lines start with an exclamation mark (!), while special lines start with a hashtag (#). +! +! When running the script start_ctdas.sh, this /.rc file will be copied to your run directory, and some items will be replaced for you. +! The result will be a nearly ready-to-go rc-file for your assimilation job. The entries and their meaning are explained by the comments below. +! +! +! HISTORY: +! +! Created on August 20th, 2013 by Wouter Peters +! +! +! The time for which to start and end the data assimilation experiment in format YYYY-MM-DD HH:MM:SS + +time.start : {cfg.startdate.strftime('%Y-%m-%d %H:%M:%S')} +time.finish : {cfg.enddate.strftime('%Y-%m-%d %H:%M:%S')} + +! Whether to restart the CTDAS system from a previous cycle, or to start the sequence fresh. Valid entries are T/F/True/False/TRUE/FALSE + +time.restart : False + +! The length of a cycle is given in days, such that the integer 7 denotes the typically used weekly cycle. Valid entries are integers > 1 + +time.cycle : {cfg.CTDAS_ctdas_cycle} + +! The number of cycles of lag to use for a smoother version of CTDAS. CarbonTracker CO2 typically uses 5 weeks of lag. Valid entries are integers > 0 + +time.nlag : {cfg.CTDAS_ctdas_nlag} + +! The directory under which the code, input, and output will be stored. This is the base directory for a run. The word +! '/' will be replaced through the start_ctdas.sh script by a user-specified folder name. DO NOT REPLACE + +dir.da_run : template + + +! msteiner: The directory, where the ICON-simulation is located: +dir.icon_sim : /scratch/snx3000/ekoene/processing-chain/work/CTDAS_OCO2/2018010100_0_8664/icon +sv.distances : /scratch/snx3000/ekoene/CTDAS_cells2cells.nc +op.loc_coeffs : /scratch/snx3000/ekoene/cells2stations.nc + +statevector.bg_params : {cfg.CTDAS_nboundaries} +statevector.number_regions : {nregs} +statevector.tracer : co2 + +! The resources used to complete the data assimilation experiment. This depends on your computing platform. +! The number of cycles per job denotes how many cycles should be completed before starting a new process or job, this +! allows you to complete many cycles before resubmitting a job to the queue and having to wait again for resources. +! Valid entries are integers > 0 + +da.resources.ncycles_per_job : 1 + +! The ntasks specifies the number of threads to use for the MPI part of the code, if relevant. Note that the CTDAS code +! itself is not parallelized and the python code underlying CTDAS does not use multiple processors. The chosen observation +! operator though might use many processors, like TM5. Valid entries are integers > 0 + +da.resources.ntasks : 1 + +! This specifies the amount of wall-clock time to request for each job. Its value depends on your computing platform and might take +! any form appropriate for your system. Typically, HPC queueing systems allow you a certain number of hours of usage before +! your job is killed, and you are expected to finalize and submit a next job before that time. Valid entries are strings. + +da.resources.ntime : 24:00:00 + +! The resource settings above will cause the creation of a job file in which 2 cycles will be run, and 30 threads +! are asked for a duration of 4 hours +! +! Info on the DA system used, this depends on your application of CTDAS and might refer to for instance CO2, or CH4 optimizations. +! + +da.system : CarbonTracker + +! The specific settings for your system are read from a separate rc-file, which points to the data directories, observations, etc + +da.system.rc : da/rc/cteco2/carbontracker_icon_oco2.rc + +! This flag should probably be moved to the da.system.rc file. It denotes which type of filtering to use in the optimizer + +da.system.localization : spatial + +! Info on the observation operator to be used, these keys help to identify the settings for the transport model in this case + +da.obsoperator : RandomizerObservationOperator + +! +! The TM5 transport model is controlled by an rc-file as well. The value below refers to the configuration of the TM5 model to +! be used as observation operator in this experiment. +! + +da.obsoperator.rc : da/rc/cteco2/carbontracker_icon_oco2.rc + + +da.optimizer.nmembers : {cfg.CTDAS_nensembles} +dir.icon_sim : {cfg.case_root} + + +! Column sampler specifics +output_prefix : ICON-ART-UNSTR +icon_grid_path : {cfg.input_files_scratch_dynamics_grid_filename} +tracer_optim : TRCO2_A +obs.column.footprint_samples_dim : 1 diff --git a/cases/icon-art-CTDAS2/ctdas_patch/utilities.py b/cases/icon-art-CTDAS2/ctdas_patch/utilities.py new file mode 100644 index 00000000..30e3de52 --- /dev/null +++ b/cases/icon-art-CTDAS2/ctdas_patch/utilities.py @@ -0,0 +1,319 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" + +Created on Wed Sep 18 16:03:02 2019 + +@author: friedemann +""" + +import os +import glob +import logging +import subprocess +import tempfile +import copy +import netCDF4 as nc +import numpy as np + +class utilities(object): + """ + Collection of utilities for wrfchem observation operator + that do not depend on other CTDAS modules + """ + + def __init__(self): + pass + + @staticmethod + def get_slicing_ids(N, nproc, nprocs): + """ + Purpose + ------- + For parallel processing, figure out which samples to process + by this process. + + Parameters + ---------- + N : int + Length to slice + nproc : int + id of this process (0... nprocs-1) + nprocs : int + Number of processes that work on the task. + + Output + ------ + Slicing indices id0, id1 + Usage + ----- + ..code-block:: python + + id0, id1 = get_slicing_ids(N, nproc, nprocs) + field[id0:id1, ...] + """ + + f0 = float(nproc)/float(nprocs) + id0 = int(np.floor(f0*N)) + + f1 = float(nproc+1)/float(nprocs) + id1 = int(np.floor(f1*N)) + + if id0==id1: + raise ValueError("id0==id1. Probably too many processes.") + return id0, id1 + + + + @classmethod + def cat_ncfiles(cls, path, in_arg, cat_dim, out_file, in_pattern=False, rm_original=True): + """ + Combine output of all processes into 1 file + If in_pattern, a pattern is provided instead of a file list. + This has the advantage that it can be interpreted by the shell, + because there are problems with long argument lists. + + This calls ncrcat from the nco library. If nco is not available, + rewrite this function. Note: I first tried to do this with + "cdo cat", but it messed up sounding_id + (see https://code.mpimet.mpg.de/boards/1/topics/908) + """ + + # To preserve dimension names, we start from one of the existing + # slice files instead of a new file. + + # Do this in path to avoid long command line arguments and history + # entries in outfile. + cwd = os.getcwd() + os.chdir(path) + + if in_pattern: + if not isinstance(in_arg, str): + raise TypeError("in_arg must be a string if in_pattern is True.") + file_pattern = in_arg + in_files = glob.glob(file_pattern) + else: + if isinstance(in_arg, list): + raise TypeError("in_arg must be a list if in_pattern is False.") + in_files = in_arg + + if len(in_files) == 0: + logging.error("Nothing to do.") + # Change back to previous directory + os.chdir(cwd) + return + + # Sorting is important! + in_files.sort() + + # ncrcat needs total number of soundings, count + Nobs = 0 + for f in in_files: + ncf = nc.Dataset(f, "r") + Nobs += len(ncf.dimensions[cat_dim]) + ncf.close() + + # Cat files + cmd_ = "ncrcat -h -O -d " + cat_dim + ",0,%d"%(Nobs-1) + if in_pattern: + cmd = cmd_ + " " + file_pattern + " " + out_file + # If PIPE is used here, it gets clogged, and the process + # stops without error message (see also + # https://thraxil.org/users/anders/posts/2008/03/13/Subprocess-Hanging-PIPE-is-your-enemy/) + # Hence, piping the output to a temporary file. + proc = subprocess.Popen(cmd, shell=True, + stdout=tempfile.TemporaryFile(), + stderr=tempfile.TemporaryFile()) + else: + cmdsplt = cmd_.split() + in_files + [out_file] + proc = subprocess.Popen(cmdsplt, stdout=tempfile.TemporaryFile(), stderr=tempfile.TemporaryFile()) + cmd = " ".join(cmdsplt) + + proc.wait() + + # This is probably useless since the output is piped to a + # tempfile. + retcode = cls.check_out_err(proc) + + if retcode != 0: + msg = "Something went wrong in the sampling. Command: " + cmd + logging.error(msg) + raise OSError(msg) + + # Delete slice files + if rm_original: + logging.info("Deleting slice files.") + for f in in_files: + os.remove(f) + + logging.info("Sampled WRF output written to file.") + + # Change back to previous directory + os.chdir(cwd) + + + @staticmethod + def check_out_err(process): + """Displays stdout and stderr, returns returncode of the + process. + """ + + # Get process messages + out, err = process.communicate() + + # Print output + def to_str(str_or_bytestr): + """If argument is of type str, return argument. If + argument is of type bytes, return decoded str""" + if isinstance(str_or_bytestr, str): + return str_or_bytestr + elif isinstance(str_or_bytestr, bytes): + return str(str_or_bytestr, 'utf-8') + else: + msg = "str_or_bytestr is " + str(type(str_or_bytestr)) + \ + ", should be str or bytestr." + raise TypeError(msg) + + logging.debug("Subprocess output:") + if out is None: + logging.debug("No output.") + elif isinstance(out, list): + for line in out: + logging.debug(to_str(line.rstrip())) + else: + logging.debug(to_str(out.rstrip())) + + # Handle errors + if process.returncode != 0: + logging.error("subprocess error") + logging.error("Returncode: %s", str(process.returncode)) + logging.error("Message, if any:") + if not err is None: + for line in err: + logging.error(line.rstrip()) + + return process.returncode + + @classmethod + def get_index_groups(cls, *args): + """ + Input: + numpy arrays with 1 dimension or lists, all same length + Output: + Dictionary of lists of indices that have the same + combination of input values. + """ + + try: + # If pandas is available, it makes a pandas DataFrame and + # uses its groupby-function. + import pandas as pd + + args_array = np.array(args).transpose() + df = pd.DataFrame(args_array) + groups = df.groupby(list(range(len(args)))).indices + + except ImportError: + # If pandas is not available, use an own implementation of groupby. + # Recursive implementation. It's fast. + args_array = np.array(args).transpose() + groups = cls._group(args_array) + + return groups + + @classmethod + def _group(cls, a): + """ + Reimplementation of pandas.DataFrame.groupby.indices because + py 2.7 on cartesius isn't compatible with pandas. + Unlike the pandas function, this always uses all columns of the + input array. + + Parameters + ---------- + a : numpy.ndarray (2D) + Array of indices. Each row is a combination of indices. + + Returns + ------- + groups : dict + The keys are the unique combinations of indices (rows of a), + the values are the indices of the rows of a equal the key. + """ + + # This is a recursive function: It makes groups according to the + # first columnm, then calls itself with the remaining columns. + # Some index juggling. + + # Group according to first column + UI = list(set(a[:, 0])) + groups0 = dict() + for ui in UI: + # Key must be a tuple + groups0[(ui, )] = [i for i, x in enumerate(a[:, 0]) if x == ui] + + if a.shape[1] == 1: + # If the array only has one column, we're done + return groups0 + else: + # If the array has more than one column, we group those. + groups = dict() + for ui in UI: + # Group according to the remaining columns + subgroups_ui = cls._group(a[groups0[(ui, )], 1:]) + # Now the index juggling: Add the keys together and + # locate values in the original array. + for key in list(subgroups_ui.keys()): + # Get indices of bigger array + subgroups_ui[key] = [groups0[(ui, )][n] for n in subgroups_ui[key]] + # Add the keys together + groups[(ui, ) + key] = subgroups_ui[key] + + return groups + + + @staticmethod + def apply_by_group(func, array, groups, grouped_args=None, *args, **kwargs): + """ + Apply function 'func' to a numpy array by groups of indices. + 'groups' can be a list of lists or a dictionary with lists as + values. + + If 'array' has more than 1 dimension, the indices in 'groups' + are for the first axis. + + If 'grouped_args' is not None, its members are added to + 'kwargs' after slicing. + + *args and **kwargs are passed through to 'func'. + + Example: + apply_by_group(np.mean, np.array([0., 1., 2.]), [[0, 1], [2]]) + Output: + array([0.5, 2. ]) + """ + + shape_in = array.shape + shape_out = list(shape_in) + shape_out[0] = len(groups) + array_out = np.ndarray(shape_out, dtype=array.dtype) + + if type(groups) == list: + # Make a dictionary + groups = {{n: groups[n] for n in range(len(groups))}} + + if not grouped_args is None: + kwargs0 = copy.deepcopy(kwargs) + for n in range(len(groups)): + k = list(groups.keys())[n] + + # Add additional arguments that need to be grouped to kwargs + if not grouped_args is None: + kwargs = copy.deepcopy(kwargs0) + for ka, v in grouped_args.items(): + kwargs[ka] = v[groups[k], ...] + + array_out[n, ...] = np.apply_along_axis(func, 0, array[groups[k], ...], *args, **kwargs) + + return array_out + diff --git a/cases/icon-art-CTDAS2/map_file.ana b/cases/icon-art-CTDAS2/map_file.ana new file mode 100644 index 00000000..6e6f5fcb --- /dev/null +++ b/cases/icon-art-CTDAS2/map_file.ana @@ -0,0 +1,109 @@ +# ICON +# +# --------------------------------------------------------------- +# Copyright (C) 2004-2024, DWD, MPI-M, DKRZ, KIT, ETH, MeteoSwiss +# Contact information: icon-model.org +# See AUTHORS.TXT for a list of authors +# See LICENSES/ for license information +# SPDX-License-Identifier: BSD-3-Clause +# --------------------------------------------------------------- + +# Dictionary for mapping between internal names and GRIB2/Netcdf +# variable names, which is needed by ICON's read procedures. +# +# internal name variable name (here GRIB2) +theta_v THETA_V +rho DEN +ddt_tke_pconv DTKE_CON +geopot FI +!z_ifc HHL +vn VN +u U +v V +w W +tke TKE +temp T +pres P +pres_msl PMSL +pres_sfc PS +qv QV +qc QC +qi QI +qr QR +qs QS +qg QG +qh QH +qnc NCCLOUD +qnr NCRAIN +qni NCICE +qns NCSNOW +qng NCGRAUPEL +qnh NCHAIL +t_g T_G +qv_s QV_S +fr_seaice FR_ICE +t_ice T_ICE +h_ice H_ICE +t_snow T_SNOW +freshsnow FRESHSNW +snowfrac_lc SNOWC +w_snow W_SNOW +rho_snow RHO_SNOW +h_snow H_SNOW +hsnow_max HSNOW_MAX +snow_age SNOAG +t_snow_mult T_SNOW_M +rho_snow_mult RHO_SNOW_M +wtot_snow W_SNOW_M +wliq_snow WLIQ_SNOW_M +dzh_snow H_SNOW_M +w_i W_I +w_so W_SO +w_so_ice W_SO_ICE +smi SMI +t_so T_SO +t_sk SKT +t_seasfc T_SEA +gz0 Z0 +t_mnw_lk T_MNW_LK +t_wml_lk T_WML_LK +h_ml_lk H_ML_LK +t_bot_lk T_BOT_LK +c_t_lk C_T_LK +t_b1_lk T_B1_LK +h_b1_lk H_B1_LK +rh RELHUM +rh_2m RELHUM_2M +rh_2m_land RELHUM_2M_L +td_2m_land TD_2M_L +t_2m_land T_2M_L +t_2m T_2M +t2m_bias T_2M_FILTBIAS +rh_avginc RELHUM_LML_FILTINC +t_avginc T_LML_FILTINC +t_wgt_avginc T_LML_COSWGT_FILTINC +t_daywgt_avginc T_LML_DTWGT_FILTINC +rh_daywgt_avginc RELHUM_LML_DTWGT_FILTINC +p_avginc P_LML_FILTINC +vabs_avginc SP_LML_FILTINC +albdif ALB_RAD +alb_si ALB_SEAICE +asodifd_s ASWDIFD_S +asodifu_s ASWDIFU_S +asodird_s ASWDIR_S +topography_c HSURF +gust10 VMAX_10M +aer_ss AER_SS +aer_or AER_ORG +aer_bc AER_BC +aer_su AER_SO4 +aer_du AER_DUST +alb_si ALB_SEAICE +plantevap EVAP_PL +pollcory CORYsnc +pollalnu ALNUsnc +pollbetu BETUsnc +pollpoac POACsnc +pollambr AMBRsnc +GEOSP GEOSP +GEOP_ML GEOP_ML diff --git a/cases/icon-art-CTDAS2/mypartab b/cases/icon-art-CTDAS2/mypartab new file mode 100644 index 00000000..9552aa1f --- /dev/null +++ b/cases/icon-art-CTDAS2/mypartab @@ -0,0 +1,117 @@ +¶meter ! temperature +name = "t" +out_name = "T" +/ +¶meter ! horiz. wind comp. u +name = "u" +out_name = "U" +/ +¶meter ! horiz. wind comp. u +name = "v" +out_name = "V" +/ +¶meter ! vertical velocity +name = "w" +out_name = "W" +/ +¶meter ! specific humidity +name = "q" +out_name = "QV" +/ +¶meter ! cloud liquid water content +name = "clwc" +out_name = "QC" +/ +¶meter ! cloud ice water content +name = "ciwc" +out_name = "QI" +/ +¶meter ! rain water content +name = "crwc" +out_name = "QR" +/ +¶meter ! snow water content +name = "cswc" +out_name = "QS" +/ +¶meter ! snow temperature +name = "TSN" +out_name = "T_SNOW" +/ +¶meter ! water content of snow +name = "SD" +out_name = "W_SNOW" +/ +¶meter ! density of snow +name = "RSN" +out_name = "RHO_SNOW" +/ +¶meter ! snow albedo +name = "ASN" +out_name = "ALB_SNOW" +/ +¶meter ! skin temperature +name = "SKT" +out_name = "SKT" +/ +¶meter ! sea surface temperature +name = "SSTK" +out_name = "SST" +/ +¶meter ! soil temperature level 1 +name = "STL1" +out_name = "STL1" +/ +¶meter ! soil temperature level 2 +name = "STL2" +out_name = "STL2" +/ +¶meter ! soil temperature level 3 +name = "STL3" +out_name = "STL3" +/ +¶meter ! soil temperature level 4 +name = "STL4" +out_name = "STL4" +/ +¶meter ! sea-ice cover +name = "CI" +out_name = "CI" +/ +¶meter ! water cont. of interception storage +name = "SRC" +out_name = "W_I" +/ +¶meter ! Land/sea mask +name = "LSM" +out_name = "LSM" +/ +¶meter ! soil moisture index layer 1 +name = "SWVL1" +out_name = "SMIL1" +/ +¶meter ! soil moisture index layer 2 +name = "SWVL2" +out_name = "SMIL2" +/ +¶meter ! soil moisture index layer 3 +name = "SWVL3" +out_name = "SMIL3" +/ +¶meter ! soil moisture index layer 4 +name = "SWVL4" +out_name = "SMIL4" +/ +¶meter ! logarithm of surface pressure +name = "LNSP" +out_name = "LNPS" +/ +¶meter ! logarithm of surface pressure +name = "SP" +out_name = "PS" +/ +¶meter +name = "Z" +out_name = "GEOSP" +/ + diff --git a/cases/icon-art-CTDAS2/wrapper_icon.sh b/cases/icon-art-CTDAS2/wrapper_icon.sh new file mode 120000 index 00000000..a99f1b8f --- /dev/null +++ b/cases/icon-art-CTDAS2/wrapper_icon.sh @@ -0,0 +1 @@ +/capstor/scratch/cscs/jthanwer/icon-kit//gpu/bin/../run/run_wrapper/alps_mch_gpu.sh \ No newline at end of file diff --git a/config.py b/config.py index edb83760..9f2fefc4 100644 --- a/config.py +++ b/config.py @@ -290,7 +290,11 @@ def print_config(self): for item in value: item_type = "Path" if type( item).__name__ == "PosixPath" else type(item).__name__ - print(f" - {item:<{max_col_width-4}} {item_type}") + if item_type == "dict": + for sub_key, sub_value in item.items(): + print(f" - {sub_key:<{max_col_width-4}} {sub_value}") + else: + print(f" - {item:<{max_col_width-4}} {item_type}") elif isinstance(value, dict): # If the value is a dictionary, format it as before print(f"{key:<{max_col_width}} dict") diff --git a/jobs/CTDAS.py b/jobs/CTDAS.py index 355aaf14..885c3cc0 100644 --- a/jobs/CTDAS.py +++ b/jobs/CTDAS.py @@ -1,22 +1,95 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -import os import logging import xarray as xr -import shutil +import re import subprocess from . import tools, prepare_icon -from pathlib import Path # noqa: F401 -from .tools.interpolate_data import create_oh_for_restart, create_oh_for_inicond # noqa: F401 -from .tools.fetch_external_data import fetch_era5, fetch_era5_nudging +import time +import shutil +from datetime import timedelta BASIC_PYTHON_JOB = False +def submit_job(command): + """Submit a job and return the job ID.""" + logging.info(f"Running: {command}") + result = subprocess.run(command, shell=True, capture_output=True, text=True, check=False) + match = re.search(r"Submitted batch job (\d+)", result.stdout) + + if match: + return match.group(1) + + logging.error("Failed to get job ID from sbatch output.") + return None + +def wait_for_job(job_id): + """Wait for a job to complete.""" + if not job_id: + return False, None + + logging.info(f"Waiting for job {job_id} to complete...") + while True: + result = subprocess.run(f"sacct -j {job_id} --format=State --noheader", shell=True, capture_output=True, text=True) + state = result.stdout.strip() + + if state: + logging.info(f"Job {job_id} state: {state}") + if any(s in state for s in ["COMPLETED", "FAILED", "CANCELLED", "TIMEOUT"]): + logging.info(f"Job {job_id} finished with state: {state}") + return False, state + if any(s in state for s in ["COMPLETED",]): + logging.info(f"Job {job_id} finished with state: {state}") + return True, state + time.sleep(10) + +def run_icon_case(cfg, suffix="", output_file=None, max_retries=5): + """Run an ICON case job and wait for it to complete if output is not already present.""" + if output_file and output_file.exists(): + logging.info(f"Skipping ICON case {suffix} as output exists: {output_file}") + return True + + icon_ini_template = cfg.case_path / cfg.icon_runjob_filename + job_name = f"{icon_ini_template.stem}_{cfg.startdate_sim.strftime('%Y%m%d')}{suffix}" + icon_ini_job = cfg.icon_work / (job_name + icon_ini_template.suffix) + + command = f"uenv run icon-wcp -- sbatch {icon_ini_job} --wait" + logging.info(f"Running ICON case job with {command}") + logging.info(f"To generate {output_file}") + + retries = 0 + while retries <= max_retries: + job_id = submit_job(command) + completed, state = wait_for_job(job_id) + + if completed: + return True + + if state in ["FAILED", "CANCELLED", "TIMEOUT"]: + retries += 1 + logging.warning(f"Job failed with state {state}. Retrying {retries}/{max_retries}...") + else: + break + + logging.error("ICON job failed after maximum retries.") + return False + +def start_ctdas(cfg): + """Start CTDAS process.""" + logging.info("Starting CTDAS") + try: + command = f"cd {cfg.CTDAS_ctdas_path} && ./start_ctdas.sh $SCRATCH ctdas_procchain" + subprocess.run(command, shell=True, check=True) + command = "cd $SCRATCH/ctdas_procchain/exec && sbatch ctdas_procchain.jb" + subprocess.run(command, shell=True, check=True) + except subprocess.CalledProcessError: + logging.info("CTDAS already exists -- we did NOT instantiate this CTDAS run") + def main(cfg): + prepare_icon.set_cfg_variables(cfg) + tools.change_logfile(cfg.logfile) + """ - Prepare CTDAS inversion + Start CTDAS inversion This does the following steps: 1. Run the first day (spin-up) @@ -27,18 +100,25 @@ def main(cfg): cfg : Config Object holding all user-configuration parameters as attributes. """ - prepare_icon.set_cfg_variables(cfg) - tools.change_logfile(cfg.logfile) - logging.info("Prepare ICON-ART for global simulations") - - # -- Download ERA5 data and create the inicond file - if cfg.era5_inicond and cfg.lrestart == '.FALSE.': - # -- Fetch ERA5 data - fetch_era5(cfg.startdate_sim, cfg.icon_input_icbc) - - # -- Copy ERA5 processing script (icon_era5_inicond.job) in workdir - with open(cfg.icon_era5_inijob) as input_file: - to_write = input_file.read() - output_file = os.path.join(cfg.icon_input_icbc, 'icon_era5_inicond.sh') - with open(output_file, "w") as outf: - outf.write(to_write.format(cfg=cfg)) + global_output_path = cfg.case_root / "global_outputs" + output_file_1 = global_output_path / f"opt2_{(cfg.startdate_sim - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.000.nc" + output_file_2 = global_output_path / f"runthrough_{(cfg.startdate_sim - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.000.nc" + output_file_3 = global_output_path / f"runthrough_{(cfg.startdate_sim).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%S')}.000.nc" + + if cfg.startdate_sim == cfg.startdate: + logging.info("Prepare CTDAS for global simulations") + + logging.info("Run first ICON case") + run_icon_case(cfg, output_file=output_file_1) + + logging.info("Start CTDAS") + start_ctdas(cfg) + + if cfg.CTDAS_runthrough: + run_icon_case(cfg, "_firstrun_runthrough", output_file=output_file_2) + + if cfg.CTDAS_runthrough: + run_icon_case(cfg, "_runthrough", output_file=output_file_3) + + logging.info("OK") + shutil.copy(cfg.logfile, cfg.logfile_finish) diff --git a/jobs/__init__.py b/jobs/__init__.py index c9712c82..ba6beda6 100644 --- a/jobs/__init__.py +++ b/jobs/__init__.py @@ -4,6 +4,7 @@ from . import biofluxes from . import check_output from . import cosmo +from . import CTDAS from . import emissions from . import icon from . import icontools diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index 71307657..130f36e6 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -9,14 +9,222 @@ from . import tools, prepare_icon from .tools.generate_tracers_xml import generate_tracers_xml from .tools.fetch_external_data import fetch_era5, fetch_CAMS_CO2, fetch_ICOS_data, fetch_OCO2_data, process_ICOS_data, process_OCO2_data -from .tools.ctdas_utilities import create_lambda_regions, create_prior_all_ones, create_boundary_regions, create_boundary_prior_all_ones -from concurrent.futures import ThreadPoolExecutor, as_completed +from .tools.ctdas_utilities import create_lambda_regions, create_prior_all_ones, create_prior_all_zeros, create_boundary_regions, create_boundary_prior_all_ones, create_boundary_prior_separate +from concurrent.futures import ThreadPoolExecutor from datetime import timedelta from pathlib import Path from subprocess import run +import re BASIC_PYTHON_JOB = False +def run_bash_script(template, job, **kwargs): + with job.open('w') as outfile: + outfile.write(template.read_text().format(**kwargs)) + subprocess.run(["bash", job], check=True, stdout=subprocess.PIPE) + +def era5_splitting_script(cfg, ERA5_folder, output_filenames): + era5_split_template = cfg.case_path / cfg.meteo_era5_splitjob + era5_split_job = ERA5_folder / ( + era5_split_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + era5_split_template.suffix) + logging.info(f"Preparing ERA5 splitting script for ICON from {era5_split_template}") + ml_files = " ".join( + [f"{filenames[0]}" for filenames in output_filenames]) + surf_files = " ".join( + [f"{filenames[1]}" for filenames in output_filenames]) + run_bash_script(era5_split_template, era5_split_job, cfg=cfg, + ml_files=ml_files, surf_files=surf_files, ERA5_folder=ERA5_folder) + +def initial_conditions_script(cfg, ERA5_folder, CAMS_folder, era5_ini_file): + datestr = cfg.startdate_sim.strftime("%Y-%m-%dT%H:%M:%S") + era5_ml_file = ERA5_folder / f"era5_ml_{datestr}.nc" + era5_surf_file = ERA5_folder / f"era5_surf_{datestr}.nc" + era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob + era5_ini_job = ERA5_folder / (era5_ini_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + era5_ini_template.suffix) + run_bash_script(era5_ini_template, era5_ini_job, cfg=cfg, + era5_ml_file=era5_ml_file, era5_surf_file=era5_surf_file, + inicond_filename=era5_ini_file, ERA5_folder=ERA5_folder) + shutil.copy(cfg.case_path / cfg.meteo_partab, ERA5_folder / 'mypartab') + logging.info(f"Running ERA5 initial conditions script {era5_ini_job}") + + cams_ini_template = cfg.case_path / cfg.chem_cams_inijob + cams_ini_job = ERA5_folder / (cams_ini_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + cams_ini_template.suffix) + run_bash_script(cams_ini_template, cams_ini_job, cfg=cfg, + inicond_filename=era5_ini_file, ERA5_folder=ERA5_folder, + CAMS_file=CAMS_folder / + f'cams_egg4_{cfg.startdate_sim.strftime("%Y%m%dT%H")}.nc', + era5_cams_ini_file=era5_ini_file) + logging.info(f"Running CAMS initial conditions script {cams_ini_job}") + +def boundary_conditions_script(cfg, ERA5_folder, CAMS_folder, time): + datestr = time.strftime("%Y-%m-%dT%H:%M:%S") + datestr2 = time.strftime("%Y%m%d%H") + era5_nudge_file_final = cfg.icon_input_icbc / f"era5_nudge_{datestr2}.nc" + if not era5_nudge_file_final.exists(): + era5_ml_file = ERA5_folder / f"era5_ml_{datestr}.nc" + era5_surf_file = ERA5_folder / f"era5_surf_{datestr}.nc" + era5_nudge_file = ERA5_folder / f"era5_nudge_{datestr}.nc" + + nudging_template = cfg.case_path / cfg.meteo_era5_nudgingjob + nudging_job = ERA5_folder / f'icon_era5_nudging_{datestr}.sh' + run_bash_script(nudging_template, nudging_job, cfg=cfg, + era5_ml_file=era5_ml_file, era5_surf_file=era5_surf_file, + filename=era5_nudge_file, ERA5_folder=ERA5_folder) + + if not os.path.exists(ERA5_folder / 'mypartab'): + shutil.copy(cfg.case_path / cfg.meteo_partab, + ERA5_folder / 'mypartab') + + cams_nudge_template = cfg.case_path / cfg.chem_cams_nudgingjob + cams_nudge_job = ERA5_folder / ( + cams_nudge_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + cams_nudge_template.suffix) + run_bash_script(cams_nudge_template, cams_nudge_job, cfg=cfg, + filename=era5_nudge_file, ERA5_folder=ERA5_folder, + CAMS_file=CAMS_folder / + f'cams_egg4_{time.strftime("%Y%m%dT%H")}.nc', + era5_cams_nudge_file=era5_nudge_file_final) + logging.info(f"Running CAMS nudging script {cams_nudge_job}") + +def create_icon_job(cfg, run_type, firstrun=False, runthrough=False): + """Generate ICON script dynamically.""" + OEM_folder = cfg.case_root / "global_inputs" / "OEM" + + if firstrun: + tracers_xml = cfg.case_root / "global_inputs" / "XML" / "tracers_firstrun.xml" + ini_restart_end_string = f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%SZ')}" + output_directory = cfg.case_root / "global_outputs" / f"{run_type}_{(cfg.startdate_sim - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" + lambda_nc = OEM_folder / f"prior_all_ones.nc" + bg_lambda_nc = OEM_folder / f"boundary_lambdas_bg.nc" + output_init = cfg.CTDAS_restart_init_time + restart_file = cfg.case_root / "global_outputs" / f"opt2_{(cfg.startdate_sim - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.000.nc" + else: + tracers_xml = cfg.case_root / "global_inputs" / "XML" / "tracers_restart.xml" + ini_restart_end_string = f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%SZ')}" + output_directory = cfg.case_root / "global_outputs" / f"{run_type}_{cfg.startdate_sim.strftime('%Y%m%d')}" + lambda_nc = OEM_folder / f"lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_{run_type}.nc" + bg_lambda_nc = OEM_folder / f"bg_lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_{run_type}.nc" + output_init = 24 * 60 * 60 * cfg.CTDAS_ctdas_cycle + cfg.CTDAS_restart_init_time + restart_job = "opt1" if run_type == "prior" else "opt2" + restart_file = cfg.case_root / "global_outputs" / f"{restart_job}_{(cfg.startdate_sim - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.000.nc" + + if runthrough: + if firstrun: + tracers_xml = cfg.case_root / "global_inputs" / "XML" / "tracers_runthrough_firstrun.xml" + ini_restart_end_string = f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%SZ')}" + output_directory = cfg.case_root / "global_outputs" / f"runthrough_{(cfg.startdate_sim - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" + lambda_nc = OEM_folder / f"prior_all_zeros.nc" + bg_lambda_nc = OEM_folder / f"boundary_lambdas_separate.nc" + output_init = cfg.CTDAS_restart_init_time + restart_file = cfg.case_root / "global_outputs" / f"runthrough_{(cfg.startdate_sim - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.000.nc" + else: + tracers_xml = cfg.case_root / "global_inputs" / "XML" / "tracers_runthrough_restart.xml" + ini_restart_end_string = f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%SZ')}" + output_directory = cfg.case_root / "global_outputs" / f"runthrough_{cfg.startdate_sim.strftime('%Y%m%d')}" + lambda_nc = OEM_folder / f"prior_all_zeros.nc" + bg_lambda_nc = OEM_folder / f"boundary_lambdas_separate.nc" + output_init = 24 * 60 * 60 * cfg.CTDAS_ctdas_cycle + cfg.CTDAS_restart_init_time + restart_file = cfg.case_root / "global_outputs" / f"runthrough_{(cfg.startdate_sim - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.000.nc" + + + tools.create_dir(output_directory, f"Create {run_type} output") + + script_content = (fn := cfg.case_path / cfg.icon_runjob_filename).read_text().format( + cfg=cfg, + ini_restart_string=cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%SZ'), + ini_restart_end_string=ini_restart_end_string, + inifile_nc=cfg.icon_input_icbc / f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", + tracers_xml=tracers_xml, + emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", + vertical_profile_nc=OEM_folder / "vertical_profiles.nc", + hour_of_year_nc=OEM_folder / "hourofyear.nc", + lambda_nc=lambda_nc, + lambda_regions_nc=OEM_folder / "lambdaregions.nc", + bg_lambda_nc=bg_lambda_nc, + bg_lambda_regions_nc=OEM_folder / "boundary_mask_bg.nc", + vprm_coeffs_nc=cfg.case_root / "global_inputs" / "VPRM" / cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], + latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / "lateral_boundary.grid.nc", + output_directory=output_directory, + restart_file=restart_file, + restart_init_time=cfg.CTDAS_restart_init_time, + output_init=output_init + ) + + script_path = cfg.icon_work / f"{fn.stem}_{cfg.startdate_sim.strftime('%Y%m%d')}{'_' + run_type if not firstrun else ''}{'_firstrun_runthrough' if firstrun and runthrough else ''}{fn.suffix}" + with script_path.open('w') as outfile: + outfile.write(script_content) + logging.info(f"Preparing ICON script for {run_type} run at {script_path}") + +def create_slurm_script(cfg): + """Generate SLURM script based on machine type.""" + base_lines = [ + '#!/usr/bin/env bash', + f'#SBATCH --job-name="copy_input_{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.enddate_sim_yyyymmddhh}"', + '#SBATCH --time=00:10:00', + f'#SBATCH --partition={cfg.compute_queue}', + f'#SBATCH --constraint={cfg.constraint}', + f'#SBATCH --output={cfg.logfile}', + '#SBATCH --open-mode=append', + f'#SBATCH --chdir={cfg.case_root / "global_inputs"}', '' + ] + + machine_specific = { + 'daint': [ + f'#SBATCH --account={cfg.compute_account}', + '#SBATCH --nodes=1' + ], + 'euler': ['#SBATCH --ntasks=1'], + 'santis': [ + '#SBATCH --nodes=1', + f'#SBATCH --account={cfg.compute_account}' + ] + } + + return base_lines + machine_specific.get(cfg.machine, []) + +def copy_global_inputs(cfg): + """Handle copying of global input files.""" + script_lines = create_slurm_script(cfg) + + for attr in dir(cfg): + if attr.startswith('CTDAS_global_inputs_'): + category = attr[len('CTDAS_global_inputs_'):] + cat_folder = cfg.case_root / "global_inputs" / category + tools.create_dir(cat_folder, category) + + for file in getattr(cfg, attr): + source = Path(file) + destination = cat_folder / source.name + script_lines.append(f'rsync -av {source} {destination}') + + script_path = cfg.case_root / "global_inputs" / 'copy_global_inputs.job' + with script_path.open('w') as f: + f.write('\n'.join(script_lines)) + cfg.submit('global_inputs', script_path) + +def generate_tracers(cfg): + """Generate tracers XML files.""" + tools.create_dir(xml_folder := cfg.case_root / "global_inputs" / "XML", "XML") + TR_prior = generate_tracers_xml(cfg.tracers, cfg.CTDAS_nensembles, restart=False, propagate_bg=cfg.CTDAS_propagate_bg) + TR_restart = generate_tracers_xml(cfg.tracers, cfg.CTDAS_nensembles, restart=True, propagate_bg=cfg.CTDAS_propagate_bg) + with open(xml_folder / "tracers_firstrun.xml", "w", encoding="utf-8") as file: + file.write(TR_prior) + with open(xml_folder / "tracers_restart.xml", "w", encoding="utf-8") as file: + file.write(TR_restart) + if cfg.CTDAS_runthrough: + TR_runthrough_prior = generate_tracers_xml(cfg.tracers, cfg.CTDAS_nensembles, cfg.CTDAS_nboundaries, restart=False, runthrough=True) + TR_runthrough_restart = generate_tracers_xml(cfg.tracers, cfg.CTDAS_nensembles, cfg.CTDAS_nboundaries, restart=True, runthrough=True) + with open(xml_folder / "tracers_runthrough_firstrun.xml", "w", encoding="utf-8") as file: + file.write(TR_runthrough_prior) + with open(xml_folder / "tracers_runthrough_restart.xml", "w", encoding="utf-8") as file: + file.write(TR_runthrough_restart) def main(cfg): """ @@ -43,18 +251,15 @@ def main(cfg): tools.change_logfile(cfg.logfile) logging.info("Prepare ICON-ART for CTDAS") - # -- 1. Download CAMS CO2 data (for a whole year) + # -- 1. Download CAMS CO2 data (for simulation period) if cfg.chem_fetch_CAMS: - CAMS_folder = cfg.case_root / "global_inputs" / "CAMS" - tools.create_dir(CAMS_folder, "CAMS input files") + tools.create_dir(CAMS_folder := cfg.case_root / "global_inputs" / "CAMS", "CAMS input files") fetch_CAMS_CO2(cfg.startdate_sim, (cfg.enddate_sim + timedelta(days=1)), CAMS_folder) - # -- 2. Fetch *all* ERA5 data (not just for initial conditions) + # -- 2. Fetch ERA5 data (for simulation period) if cfg.meteo_fetch_era5: - ERA5_folder = cfg.case_root / "global_inputs" / "ERA5" - tools.create_dir(ERA5_folder, "CAMS input files") - + tools.create_dir(ERA5_folder := cfg.case_root / "global_inputs" / "ERA5", "ERA5 input files") times = list( tools.iter_hours(cfg.startdate_sim, (cfg.enddate_sim + timedelta(days=1)), @@ -81,7 +286,7 @@ def main(cfg): if not missing_files: logging.info("All model level files already present") else: - logging.info(f"Missing files: {missing_files}") + logging.info(f"Missing files: {missing_files}. All data will be re-fetched.") # Split downloads in 3-day chunks, but run simultaneously N = 3 chunks = list( @@ -115,136 +320,25 @@ def main(cfg): logging.error(f"Generated an exception: {exc}") logging.info(f"All fetched files: {output_filenames}") - # Split files (with multiple days/times) into individual files using bash script - era5_split_template = cfg.case_path / cfg.meteo_era5_splitjob - era5_split_job = ERA5_folder / ( - era5_split_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}' + - era5_split_template.suffix) - logging.info( - f"Preparing ERA5 splitting script for ICON from {era5_split_template}" - ) - ml_files = " ".join( - [f"{filenames[0]}" for filenames in output_filenames]) - surf_files = " ".join( - [f"{filenames[1]}" for filenames in output_filenames]) - with open(era5_split_template, - 'r') as infile, open(era5_split_job, 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - ml_files=ml_files, - surf_files=surf_files, - ERA5_folder=ERA5_folder)) - logging.info(f"Running ERA5 splitting script {era5_split_job}") - subprocess.run(["bash", era5_split_job], - check=True, - stdout=subprocess.PIPE) - - # -- 3. Process initial conditions data using bash script + era5_splitting_script(cfg, ERA5_folder, output_filenames) + + # -- 3. Create initial conditions for ICON datestr = cfg.startdate_sim.strftime("%Y-%m-%dT%H:%M:%S") era5_ini_file = cfg.icon_input_icbc / f"era5_ini_{datestr}.nc" if not era5_ini_file.is_file(): logging.info("Preparing ERA5 initial conditions script for ICON") - era5_ml_file = ERA5_folder / f"era5_ml_{datestr}.nc" - era5_surf_file = ERA5_folder / f"era5_surf_{datestr}.nc" - era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob - era5_ini_job = ERA5_folder / (era5_ini_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}' - + era5_ini_template.suffix) - with open(era5_ini_template, 'r') as infile, open(era5_ini_job, - 'w') as outfile: - outfile.write(infile.read().format(cfg=cfg, - era5_ml_file=era5_ml_file, - era5_surf_file=era5_surf_file, - inicond_filename=era5_ini_file, - ERA5_folder=ERA5_folder)) - shutil.copy(cfg.case_path / cfg.meteo_partab, ERA5_folder / 'mypartab') - logging.info(f"Running ERA5 initial conditions script {era5_ini_job}") - subprocess.run(["bash", era5_ini_job], - check=True, - stdout=subprocess.PIPE) - # --- CAMS inicond - logging.info("Preparing CAMS initial conditions script for ICON") - cams_ini_template = cfg.case_path / cfg.chem_cams_inijob - cams_ini_job = ERA5_folder / (cams_ini_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}' - + cams_ini_template.suffix) - with open(cams_ini_template, 'r') as infile, open(cams_ini_job, - 'w') as outfile: - outfile.write(infile.read().format( - cfg=cfg, - inicond_filename=era5_ini_file, - ERA5_folder=ERA5_folder, - CAMS_file=CAMS_folder / - f'cams_egg4_{cfg.startdate_sim.strftime("%Y%m%dT%H")}.nc', - era5_cams_ini_file=era5_ini_file)) - logging.info(f"Running CAMS initial conditions script {cams_ini_job}") - subprocess.run(["bash", cams_ini_job], - check=True, - stdout=subprocess.PIPE) - - # -- 4. Interpolate CAMS to ERA5 3D grid - if cfg.meteo_interpolate_CAMS_to_ERA5: - for time in tools.iter_hours(cfg.startdate_sim, - (cfg.enddate_sim + timedelta(days=1)), - step=cfg.meteo_nudging_step): - - # -- Give a name to the nudging file - datestr = time.strftime("%Y-%m-%dT%H:%M:%S") - datestr2 = time.strftime("%Y%m%d%H") - era5_nudge_file_final = cfg.icon_input_icbc / f"era5_nudge_{datestr2}.nc" - if not era5_nudge_file_final.exists(): - era5_ml_file = ERA5_folder / f"era5_ml_{datestr}.nc" - era5_surf_file = ERA5_folder / f"era5_surf_{datestr}.nc" - era5_nudge_file = ERA5_folder / f"era5_nudge_{datestr}.nc" - - # -- Copy ERA5 processing script (icon_era5_nudging.job) in workdir - nudging_template = cfg.case_path / cfg.meteo_era5_nudgingjob - nudging_job = ERA5_folder / f'icon_era5_nudging_{datestr}.sh' - with open(nudging_template, - 'r') as infile, open(nudging_job, 'w') as outfile: - outfile.write(infile.read().format( - cfg=cfg, - era5_ml_file=era5_ml_file, - era5_surf_file=era5_surf_file, - filename=era5_nudge_file, - ERA5_folder=ERA5_folder)) - - # -- Copy mypartab into workdir - if not os.path.exists(ERA5_folder / 'mypartab'): - shutil.copy(cfg.case_path / cfg.meteo_partab, - ERA5_folder / 'mypartab') - - # -- Run ERA5 processing script - subprocess.run(["bash", nudging_job], - check=True, - stdout=subprocess.PIPE) - - # -- Copy CAMS processing script (icon_cams_nudging.job) into workdir - logging.info( - "Preparing CAMS preprocessing nudging script for ICON") - cams_nudge_template = cfg.case_path / cfg.chem_cams_nudgingjob - cams_nudge_job = ERA5_folder / ( - cams_nudge_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}' + - cams_nudge_template.suffix) - with open(cams_nudge_template, - 'r') as infile, open(cams_nudge_job, 'w') as outfile: - outfile.write(infile.read().format( - cfg=cfg, - filename=era5_nudge_file, - ERA5_folder=ERA5_folder, - CAMS_file=CAMS_folder / - f'cams_egg4_{time.strftime("%Y%m%dT%H")}.nc', - era5_cams_nudge_file=era5_nudge_file_final, - )) - subprocess.run(["bash", cams_nudge_job], - check=True, - stdout=subprocess.PIPE) + initial_conditions_script(cfg, ERA5_folder, CAMS_folder, era5_ini_file) + + # -- 4. Create boundary conditions for ICON + for time in tools.iter_hours(cfg.startdate_sim, + (cfg.enddate_sim + timedelta(days=1)), + step=cfg.meteo_nudging_step): + boundary_conditions_script(cfg, ERA5_folder, CAMS_folder, time) # -- 5. Download ICOS CO2 data # Lots of potential for 'dehardcoding' things here, but that has to be done with # a lot of care. - if cfg.CTDAS_obs_fetch_ICOS: + if cfg.CTDAS_obs_ICOS_fetch: fetch_ICOS_data(start_date=cfg.startdate_sim.strftime("%d-%m-%Y"), end_date=(cfg.enddate_sim + timedelta(days=1)).strftime("%d-%m-%Y"), @@ -252,119 +346,57 @@ def main(cfg): species=[ 'co2', ]) - tools.create_dir(cfg.case_root / "global_inputs" / "ICOS", + tools.create_dir(ICOS_path := cfg.case_root / "global_inputs" / "ICOS", "ICOS input files") process_ICOS_data(ICOS_obs_folder=cfg.CTDAS_obs_ICOS_path, start_date=cfg.startdate_sim, end_date=(cfg.enddate_sim + timedelta(days=1)), - output_folder=cfg.case_root / "global_inputs" / - "ICOS") + output_folder=ICOS_path) # -- 6. Download OCO2 data - if cfg.CTDAS_obs_fetch_OCO2: - fetch_OCO2_data(cfg.startdate_sim, - (cfg.enddate_sim + timedelta(days=1)), - -8, - 30, - 35, - 65, - cfg.CTDAS_obs_OCO2_path, - product="OCO2_L2_Lite_FP_11.1r") - tools.create_dir(cfg.case_root / "global_inputs" / "OCO2", + if cfg.CTDAS_obs_OCO2_fetch: + # fetch_OCO2_data(cfg.startdate_sim, + # (cfg.enddate_sim + timedelta(days=1)), + # -8, 30, 35, 65, + # cfg.CTDAS_obs_OCO2_path, + # product="OCO2_L2_Lite_FP_11.1r") + tools.create_dir(OCO2_path := cfg.case_root / "global_inputs" / "OCO2", "OCO-2 output") process_OCO2_data(OCO2_obs_folder=cfg.CTDAS_obs_OCO2_path, + ICON_grid_file=cfg.input_files_dynamics_grid_filename, start_date=cfg.startdate_sim, end_date=(cfg.enddate_sim + timedelta(days=1)), - output_folder=cfg.case_root / "global_inputs" / - "OCO2") # post-process all the OCO2 data - - # -- 7. Create the required folder structure - # For the ICON runs - # tools.create_dir(cfg.icon_base / "output_prior", "Prior") - # tools.create_dir(cfg.icon_base / "output_opt_once", "1 time optimized") - # tools.create_dir(cfg.icon_base / "output_opt_twice", "2 times optimized") + output_folder=OCO2_path) - # For the sampling + # -- 7. Create the required run data + # Create sampling output folder tools.create_dir(cfg.case_root / "global_outputs" / "extracted_ICOS", "Output of the extraction script") - - # -- 8. Initialize the first one-day run, only for the first lag + + # Create ICON jobs + create_icon_job(cfg, "prior") + create_icon_job(cfg, "opt1") + create_icon_job(cfg, "opt2") + if cfg.startdate_sim == cfg.startdate: create_icon_job(cfg, "opt2", firstrun=True) + if cfg.CTDAS_runthrough: create_icon_job(cfg, "runthrough", runthrough=True) + if (cfg.startdate_sim == cfg.startdate) and cfg.CTDAS_runthrough: create_icon_job(cfg, "runthrough", firstrun=True, runthrough=True) + + # Copy global input data + if cfg.startdate_sim == cfg.startdate: copy_global_inputs(cfg) + + # Generate tracers + if cfg.startdate_sim == cfg.startdate: generate_tracers(cfg) + + # Generate initial ensemble lambdas (equal to 1) if cfg.startdate_sim == cfg.startdate: - # -- 8.1 Get the global_inputs folder filled out - logging.info('Copy global inputs to working directory') - if cfg.machine == 'daint': - script_lines = [ - '#!/usr/bin/env bash', - f'#SBATCH --job-name="copy_input_{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.enddate_sim_yyyymmddhh}"', - f'#SBATCH --account={cfg.compute_account}', - '#SBATCH --time=00:10:00', - f'#SBATCH --partition={cfg.compute_queue}', - f'#SBATCH --constraint={cfg.constraint}', '#SBATCH --nodes=1', - f'#SBATCH --output={cfg.logfile}', - '#SBATCH --open-mode=append', - f'#SBATCH --chdir={cfg.case_root / "global_inputs"}', '' - ] - elif cfg.machine == 'euler': - script_lines = [ - '#!/usr/bin/env bash', - f'#SBATCH --job-name="copy_input_{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.enddate_sim_yyyymmddhh}"', - '#SBATCH --time=00:10:00', - f'#SBATCH --partition={cfg.compute_queue}', - f'#SBATCH --constraint={cfg.constraint}', '#SBATCH --ntasks=1', - f'#SBATCH --output={cfg.logfile}', - '#SBATCH --open-mode=append', - f'#SBATCH --chdir={cfg.case_root / "global_inputs"}', '' - ] - elif cfg.machine == 'santis': - script_lines = [ - '#!/usr/bin/env bash', - f'#SBATCH --job-name="copy_input_{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.enddate_sim_yyyymmddhh}"', - '#SBATCH --nodes=1', f'#SBATCH --time=00:10:00', - f'#SBATCH --output={cfg.logfile}', - '#SBATCH --open-mode=append', - f'#SBATCH --account={cfg.compute_account}', - f'#SBATCH --partition={cfg.compute_queue}', - f'#SBATCH --constraint={cfg.constraint}', - f'#SBATCH --chdir={cfg.case_root / "global_inputs"}', '' - ] - - for attr in dir(cfg): - if attr.startswith('CTDAS_global_inputs_'): - category = attr[len('CTDAS_global_inputs_'):] - tools.create_dir( - cat_folder := cfg.case_root / "global_inputs" / category, - category) - for file in getattr(cfg, attr): - source = (p := Path(file)) - destination = cat_folder / p.name - script_lines.append(f'rsync -av {source} {destination}') - with (script := cfg.case_root / "global_inputs" / - 'copy_global_inputs.job').open('w') as f: - f.write('\n'.join(script_lines)) - f.flush() - cfg.submit('global_inputs', script) - - tools.create_dir(xml_folder := cfg.case_root / "global_inputs" / "XML", - "XML") - TR_prior = generate_tracers_xml(cfg.tracers, - cfg.CTDAS_nensembles, - restart=False) - TR_restart = generate_tracers_xml(cfg.tracers, - cfg.CTDAS_nensembles, - restart=True) - with open(xml_folder / "tracers_firstrun.xml", "w", - encoding="utf-8") as file: - file.write(TR_prior) - with open(xml_folder / "tracers_restart.xml", "w", - encoding="utf-8") as file: - file.write(TR_restart) - - # -- 8.2 Create the ensemble data for the first day + # Set up OEM Folder tools.create_dir(OEM_folder := cfg.case_root / "global_inputs" / "OEM", "OEM") + # Interpret lambdas from the YAML file lambdas = [ int(item) for line in cfg.CTDAS_lambdas for item in line.split(',') ] + # Create lambda regions for basegrid if cfg.CTDAS_regions == 'basegrid': nregs, ncats = create_lambda_regions( cfg.input_files_dynamics_grid_filename, @@ -372,194 +404,43 @@ def main(cfg): create_prior_all_ones(OEM_folder / "prior_all_ones.nc", nensembles=cfg.CTDAS_nensembles, ncats=max(lambdas), + nregs=nregs, + propagate_bg=cfg.CTDAS_propagate_bg) + if cfg.CTDAS_runthrough: + create_prior_all_zeros(OEM_folder / "prior_all_zeros.nc", + nensembles=cfg.CTDAS_nboundaries, + ncats=max(lambdas), nregs=nregs) else: raise NotImplementedError('Only basegrid is implemented for now') create_boundary_regions(cfg.input_files_dynamics_grid_filename, - OEM_folder / 'boundary_mask_bg.nc', + OEM_folder / 'boundary_mask_bg.nc', + cfg.CTDAS_nboundaries, cfg.cdo_nco_cmd, cfg.cdo_nco_cmd_post) create_boundary_prior_all_ones(OEM_folder / 'boundary_lambdas_bg.nc', - nensembles=cfg.CTDAS_nensembles) - - # -- 8.3 Prepare the first one-day simulation - logging.info("Creating output file for first run") - tools.create_dir( - initial_output := cfg.case_root / "global_outputs" / - f"opt2_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}", - "Create initial conditions output file") - - logging.info("Preparing ICON script for first run") - icon_ini_template = cfg.case_path / cfg.icon_runjob_filename - icon_ini_job = cfg.icon_work / ( - icon_ini_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' - + icon_ini_template.suffix) - with open(icon_ini_template, 'r') as infile, open(icon_ini_job, - 'w') as outfile: - outfile.write(infile.read().format( - cfg=cfg, - ini_restart_string=cfg.startdate_sim.strftime( - '%Y-%m-%dT%H:%M:%SZ'), - ini_restart_end_string= - f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%SZ')}", - inifile_nc=cfg.icon_input_icbc / - f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", - tracers_xml=cfg.case_root / "global_inputs" / "XML" / - "tracers_firstrun.xml", - emissionsgrid_nc=cfg.case_root / "global_inputs" / - "inventories" / - f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", - vertical_profile_nc=OEM_folder / "vertical_profiles.nc", - hour_of_year_nc=OEM_folder / "hourofyear8784.nc", - lambda_nc=OEM_folder / "prior_all_ones.nc", - lambda_regions_nc=OEM_folder / "lambdaregions.nc", - bg_lambda_nc=OEM_folder / "boundary_lambdas_bg.nc", - bg_lambda_regions_nc=OEM_folder / "boundary_mask_bg.nc", - vprm_coeffs_nc=cfg.case_root / "global_inputs" / - cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], - latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / - "grid" / "lateral_boundary.grid.nc", - output_directory=initial_output, - restart_file=cfg.case_root / "global_outputs" / - f"opt2_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" - / - f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", - restart_init_time=cfg.CTDAS_restart_init_time, - output_init=cfg.CTDAS_restart_init_time)) - - logging.info("Creating output file for first run") - tools.create_dir( - initial_output := cfg.case_root / "global_outputs" / - f"prior_{(cfg.startdate).strftime('%Y%m%d')}", "Create prior output") - tools.create_dir( - initial_output := cfg.case_root / "global_outputs" / - f"opt1_{(cfg.startdate).strftime('%Y%m%d')}", "Create opt1 output") - tools.create_dir( - initial_output := cfg.case_root / "global_outputs" / - f"opt2_{(cfg.startdate).strftime('%Y%m%d')}", "Create opt2 output") - - logging.info("Preparing ICON script for prior run") - OEM_folder = cfg.case_root / "global_inputs" / "OEM" - icon_ini_template = cfg.case_path / cfg.icon_runjob_filename - icon_ini_job = cfg.icon_work / ( - icon_ini_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}_prior' + - icon_ini_template.suffix) - with open(icon_ini_template, 'r') as infile, open(icon_ini_job, - 'w') as outfile: - outfile.write(infile.read().format( - cfg=cfg, - ini_restart_string=cfg.startdate_sim.strftime( - '%Y-%m-%dT%H:%M:%SZ'), - ini_restart_end_string= - f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%SZ')}", - inifile_nc=cfg.icon_input_icbc / - f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", - tracers_xml=cfg.case_root / "global_inputs" / "XML" / - "tracers_firstrun.xml", - emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / - f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", - vertical_profile_nc=OEM_folder / "vertical_profiles.nc", - hour_of_year_nc=OEM_folder / "hourofyear8784.nc", - lambda_nc=OEM_folder / - f"lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_prior.nc", - lambda_regions_nc=OEM_folder / "lambdaregions.nc", - bg_lambda_nc=OEM_folder / - "bg_lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_prior.nc", - bg_lambda_regions_nc=OEM_folder / "boundary_mask_bg.nc", - vprm_coeffs_nc=cfg.case_root / "global_inputs" / - cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], - latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / - "lateral_boundary.grid.nc", - output_directory=initial_output, - restart_file=cfg.case_root / "global_outputs" / - f"prior_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" - / - f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", - restart_init_time=cfg.CTDAS_restart_init_time, - output_init=24 * 60 * 60 * cfg.CTDAS_ctdas_cycle + - cfg.CTDAS_restart_init_time)) - - logging.info("Preparing ICON script for first optimization run") - OEM_folder = cfg.case_root / "global_inputs" / "OEM" - icon_ini_template = cfg.case_path / cfg.icon_runjob_filename - icon_ini_job = cfg.icon_work / ( - icon_ini_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}_opt1' - + icon_ini_template.suffix) - with open(icon_ini_template, 'r') as infile, open(icon_ini_job, - 'w') as outfile: - outfile.write(infile.read().format( - cfg=cfg, - ini_restart_string=cfg.startdate_sim.strftime( - '%Y-%m-%dT%H:%M:%SZ'), - ini_restart_end_string= - f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%SZ')}", - inifile_nc=cfg.icon_input_icbc / - f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", - tracers_xml=cfg.case_root / "global_inputs" / "XML" / - "tracers_firstrun.xml", - emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / - f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", - vertical_profile_nc=OEM_folder / "vertical_profiles.nc", - hour_of_year_nc=OEM_folder / "hourofyear8784.nc", - lambda_nc=OEM_folder / - f"lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", - lambda_regions_nc=OEM_folder / "lambdaregions.nc", - bg_lambda_nc=OEM_folder / - "bg_lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", - bg_lambda_regions_nc=OEM_folder / "boundary_mask_bg.nc", - vprm_coeffs_nc=cfg.case_root / "global_inputs" / - cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], - latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / - "lateral_boundary.grid.nc", - output_directory=initial_output, - restart_file=cfg.case_root / "global_outputs" / - f"opt1_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" - / - f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", - restart_init_time=cfg.CTDAS_restart_init_time, - output_init=24 * 60 * 60 * cfg.CTDAS_ctdas_cycle + - cfg.CTDAS_restart_init_time)) - - logging.info("Preparing ICON script for second optimization run") - OEM_folder = cfg.case_root / "global_inputs" / "OEM" - icon_ini_template = cfg.case_path / cfg.icon_runjob_filename - icon_ini_job = cfg.icon_work / ( - icon_ini_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}_opt2' - + icon_ini_template.suffix) - with open(icon_ini_template, 'r') as infile, open(icon_ini_job, - 'w') as outfile: - outfile.write(infile.read().format( - cfg=cfg, - ini_restart_string=cfg.startdate_sim.strftime( - '%Y-%m-%dT%H:%M:%SZ'), - ini_restart_end_string= - f"{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time) + timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y-%m-%dT%H:%M:%SZ')}", - inifile_nc=cfg.icon_input_icbc / - f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", - tracers_xml=cfg.case_root / "global_inputs" / "XML" / - "tracers_firstrun.xml", - emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / - f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", - vertical_profile_nc=OEM_folder / "vertical_profiles.nc", - hour_of_year_nc=OEM_folder / "hourofyear8784.nc", - lambda_nc=OEM_folder / - f"lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", - lambda_regions_nc=OEM_folder / "lambdaregions.nc", - bg_lambda_nc=OEM_folder / - "bg_lambda_{cfg.startdate_sim.strftime('%Y%m%d')}_opt.nc", - bg_lambda_regions_nc=OEM_folder / "boundary_mask_bg.nc", - vprm_coeffs_nc=cfg.case_root / "global_inputs" / - cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], - latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / - "lateral_boundary.grid.nc", - output_directory=initial_output, - restart_file=cfg.case_root / "global_outputs" / - f"opt2_{(cfg.startdate - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" - / - f"ICON-ART-OEM-INIT_{(cfg.startdate + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.nc", - restart_init_time=cfg.CTDAS_restart_init_time, - output_init=24 * 60 * 60 * cfg.CTDAS_ctdas_cycle + - cfg.CTDAS_restart_init_time)) + n_bg_ens=cfg.CTDAS_nboundaries, + nensembles=cfg.CTDAS_nensembles, + propagate_bg=cfg.CTDAS_propagate_bg) + if cfg.CTDAS_runthrough: + create_boundary_prior_separate(OEM_folder / 'boundary_lambdas_separate.nc', + n_bg_ens=cfg.CTDAS_nboundaries) + # Patch CTDAS files + if cfg.startdate_sim == cfg.startdate: + logging.info("Patching CTDAS files") + def evaluate_dict(d, replace, using): + return {key: eval(value.replace(replace, str(using))) for key, value in d.items()} + meta_dict = {d.replace("XXX", "ENS"): {"ensemble": cfg.CTDAS_nensembles} if "XXX" in d else {} for d in cfg.tracers if not d.startswith("EM")} + for key, source_paths in cfg.CTDAS["ctdas_patch"].items(): + destination_dir = Path(cfg.CTDAS_ctdas_path) / key + os.makedirs(destination_dir, exist_ok=True) + if isinstance(source_paths, str): + source_paths = [source_paths] + for source_path in source_paths: + in_path = cfg.case_path / source_path + destination_path = destination_dir / in_path.name + with in_path.open('r') as infile, destination_path.open('w') as outfile: + outfile.write(eval(f"f'''{infile.read()}'''")) + logging.info(f"Copied {in_path} -> {destination_path}") logging.info("OK") shutil.copy(cfg.logfile, cfg.logfile_finish) diff --git a/jobs/tools/ICON_to_point.py b/jobs/tools/ICON_to_point.py index 65371be1..a1063c6a 100644 --- a/jobs/tools/ICON_to_point.py +++ b/jobs/tools/ICON_to_point.py @@ -1,11 +1,10 @@ import numpy as np import xarray as xr from sklearn.neighbors import BallTree -from scipy import argmin import argparse -def get_horizontal_distances(longitude, latitude, icon_grid_path, k=5): +def get_horizontal_distances(longitude, latitude, icon_grid, k=5): """ Get horizontal distances between points and their k nearest neighbours on the ICON grid using a quick BallTree algorithm @@ -18,8 +17,8 @@ def get_horizontal_distances(longitude, latitude, icon_grid_path, k=5): latitude : list or 1D np.array e.g., [52] or np.array([52,53,54]) - icon_grid_path : str - Contains the path to the ICON grid + icon_grid : str + Contains the xarray ICON grid object k : int, default is 5 Sets the number of nearest neighbours desired @@ -35,7 +34,6 @@ def get_horizontal_distances(longitude, latitude, icon_grid_path, k=5): nearest neighbours """ # Get ICON grid specifics - icon_grid = xr.open_dataset(icon_grid_path) clon = icon_grid.clon.values clat = icon_grid.clat.values @@ -50,12 +48,7 @@ def get_horizontal_distances(longitude, latitude, icon_grid_path, k=5): k=k, return_distance=True) - if np.any(distances == 0): - print( - 'The longitude/latitude coincides identically with an ICON cell, which is an issue for the inverse distance weighting.' - ) - print('I will slightly modify this value to avoid errors.') - distances[distances == 0] = 1e-12 + distances[distances == 0] = 1e-12 # Avoid division by zero if np.any(distances is np.nan): raise ValueError( @@ -88,9 +81,11 @@ def get_nearest_vertical_distances(model_topography, model_levels, base_height_msl : list or 1D np.array e.g., [20,] or np.array([72,180,40]) + This is the elevation over the mean sea level for the base of the station inlet_height_agl : list or 1D np.array e.g., [15,] or np.array([15, 21, 42]) + This is the height of the station over the ground interpolation_strategy : list of strings e.g., ['ground',] or ['ground','mountain','ground'] @@ -119,7 +114,7 @@ def get_nearest_vertical_distances(model_topography, model_levels, model_topography.isel({ "station": i }).values / 2 + inlet_height_agl[i] - # if strategy=='middle' + # if strategy[i]=='middle' for (i, strategy) in enumerate(interpolation_strategy) ] target_altitude = xr.DataArray(target_altitude, dims=['station', 'ncells']) @@ -144,7 +139,7 @@ def icon_to_point(longitude, latitude, inlet_height_agl, base_height_msl, - icon_field_path, + icon_field_paths, icon_grid_path, interpolation_strategy, k=5, @@ -172,8 +167,10 @@ def icon_to_point(longitude, (e.g., for Jungfraujoch: base_height_msl=3850, inlet_height_agl=5) - icon_field_path : str - Contains the path to the unstructured ICON output + icon_field_paths : str + Contains the path to the unstructured ICON output. + As this uses `xr.open_mfadataset` it can be a list of paths or + a 'glob' string (e.g., 'path/to/icon_output/*.nc') icon_grid_path : str Contains the path to the ICON grid @@ -200,32 +197,39 @@ def icon_to_point(longitude, values """ - # Load dataset - icon_field = xr.open_dataset(icon_field_path) - # Get dimension names - icon_heights = icon_field.z_mc.dims[ - 0] # Dimension name (something like "heights_5") - icon_cells = icon_field.z_mc.dims[ - 1] # Dimension name (something like "ncells") - icon_field[icon_cells] = icon_field[ - icon_cells] # Explicitly assign 'ncells' + # Open multiple ICON datasets + icon_field = xr.open_mfdataset(icon_field_paths, combine='by_coords', chunks={'time': 50}) + + # Load the ICON grid + icon_grid = xr.open_dataset(icon_grid_path) + + # Dimensions + if icon_field.time.size > 1: + icon_heights = icon_field.z_mc.dims[1] + icon_cells = icon_field.z_mc.dims[2] + else: + icon_heights = icon_field.z_mc.dims[0] + icon_cells = icon_field.z_mc.dims[1] # --- Horizontal grid selection & interpolation weights # Get k nearest horizontal distances (for use in inverse distance weighing) horizontal_distances, icon_grid_indices = get_horizontal_distances( - longitude, latitude, icon_grid_path, k=k) + longitude, latitude, icon_grid, k=k) - horizontal_interp = 1 / horizontal_distances / ( - 1 / horizontal_distances).sum(axis=1, keepdims=True) - weights_horizontal = xr.DataArray(horizontal_interp, - dims=["station", icon_cells]) + horizontal_weights = 1 / horizontal_distances / (1 / horizontal_distances).sum(axis=1, keepdims=True) + + weights_horizontal = xr.DataArray(horizontal_weights, dims=["station", icon_cells]) ind_X = xr.DataArray(icon_grid_indices, dims=["station", icon_cells]) icon_subset = icon_field.isel({icon_cells: ind_X}) # --- Vertical level selection & interpolation weights # Get 2 nearest vertical distances (for use in linear interpolation) - model_topography = icon_subset.z_ifc[-1] - model_levels = icon_subset.z_mc + if icon_field.time.size > 1: + model_topography = icon_subset.z_ifc[-1,-1] + model_levels = icon_subset.z_mc[1] + else: + model_topography = icon_subset.z_ifc[-1] + model_levels = icon_subset.z_mc vertical_distances, icon_level_indices = get_nearest_vertical_distances( model_topography, model_levels, inlet_height_agl, base_height_msl, interpolation_strategy) @@ -264,7 +268,6 @@ def icon_to_point(longitude, ) # Remove out of bounds values where weights_vertical has NaNs return xr.merge([icon_out, ds]) - if __name__ == '__main__': parser = argparse.ArgumentParser( description='Interpolate ICON output to point locations.') diff --git a/jobs/tools/ICON_to_point2.py b/jobs/tools/ICON_to_point2.py new file mode 100644 index 00000000..e1f3de53 --- /dev/null +++ b/jobs/tools/ICON_to_point2.py @@ -0,0 +1,52 @@ +from sklearn.neighbors import BallTree +import numpy as np +from math import radians + +def intp_icon_data(iloc, gridinfo, datainfo, latitudes, longitudes, asl, elev, station_name): + nn_sel = np.zeros(gridinfo.nn, dtype=int) + u = np.zeros(gridinfo.nn) + + R = 6373.0 # Earth's radius in km + + if (radians(longitudes[iloc]) < np.nanmin(gridinfo.clon)) or (radians(longitudes[iloc]) > np.nanmax(gridinfo.clon)): + return np.nan * np.ones((gridinfo.nn)), np.full((gridinfo.nn), -1), np.full((gridinfo.nn), -1), nn_sel, u + + if (radians(latitudes[iloc]) < np.nanmin(gridinfo.clat)) or (radians(latitudes[iloc]) > np.nanmax(gridinfo.clat)): + return np.nan * np.ones((gridinfo.nn)), np.full((gridinfo.nn), -1), np.full((gridinfo.nn), -1), nn_sel, u + + lat1, lon1 = radians(latitudes[iloc]), radians(longitudes[iloc]) + + # Use BallTree for fast nearest-neighbor search + coords = np.deg2rad(np.column_stack((gridinfo.clat, gridinfo.clon))) + tree = BallTree(coords, metric='haversine') + dist, nn_sel = tree.query([[lat1, lon1]], k=gridinfo.nn) + + # Convert haversine distance (in radians) to km + dist *= R + + u = 1.0 / dist.flatten() + + idx_above = -1 * np.ones(gridinfo.nn, dtype=int) + idx_below = -1 * np.ones(gridinfo.nn, dtype=int) + + target_asl = datainfo.z_ifc[-1, nn_sel].flatten() + elev[iloc] + + for nnidx in range(gridinfo.nn): + for i_mc, mc in enumerate(datainfo.z_mc[:, nn_sel[0, nnidx]]): + if mc >= target_asl[nnidx]: + idx_above[nnidx] = i_mc + else: + idx_below[nnidx] = i_mc + break + + if idx_below[nnidx] == -1: + idx_below[nnidx] = idx_above[nnidx] + + vert_scaling_fact = np.zeros(gridinfo.nn) + + for nnidx in range(gridinfo.nn): + if idx_below[nnidx] != idx_above[nnidx]: + vert_scaling_fact[nnidx] = (target_asl[nnidx] - datainfo.z_mc[idx_below[nnidx], nn_sel[0, nnidx]]) / ( + datainfo.z_mc[idx_above[nnidx], nn_sel[0, nnidx]] - datainfo.z_mc[idx_below[nnidx], nn_sel[0, nnidx]]) + + return vert_scaling_fact, idx_below, idx_above, nn_sel.flatten(), u diff --git a/jobs/tools/ctdas_utilities.py b/jobs/tools/ctdas_utilities.py index d1177aef..fa1734de 100644 --- a/jobs/tools/ctdas_utilities.py +++ b/jobs/tools/ctdas_utilities.py @@ -29,7 +29,8 @@ def create_lambda_regions(input_grid, output_path, lambdas_ids): }, attrs={'author': 'Processing Chain'}) - ds_cells.to_netcdf(output_path, + try: + ds_cells.to_netcdf(output_path, encoding={ 'REG': { 'dtype': 'int32' @@ -38,22 +39,42 @@ def create_lambda_regions(input_grid, output_path, lambdas_ids): 'dtype': 'int32' } }) + except: + print("File currently open. Please close the file and try again.") print(f"Lambda regions saved to {output_path}") return nregs, categories[-1] -def create_prior_all_ones(output_path, nensembles, ncats, nregs): +def create_prior_all_ones(output_path, nensembles, ncats, nregs, propagate_bg=False): """ Create a dataset of initial lambdas (all ones) for testing. """ + nensembles = nensembles + 1 if propagate_bg else nensembles arr = np.ones((nensembles, nregs, ncats, 1), dtype=np.float32) + arr[-1, :, :, :] = 0 if propagate_bg else 1 data = xr.DataArray(arr, dims=['ens', 'reg', 'cat', 'tracer']) ds = xr.Dataset({'lambda': data}) - ds.to_netcdf(output_path) + try: + ds.to_netcdf(output_path) + except: + print("File currently open. Please close the file and try again.") print(f"Prior all ones saved to {output_path}") +def create_prior_all_zeros(output_path, nensembles, ncats, nregs): + """ + Create a dataset of initial lambdas (all zeros) for testing. + """ + arr = np.zeros((nensembles, nregs, ncats, 1), dtype=np.float32) + data = xr.DataArray(arr, dims=['ens', 'reg', 'cat', 'tracer']) + ds = xr.Dataset({'lambda': data}) + try: + ds.to_netcdf(output_path) + except: + print("File currently open. Please close the file and try again.") + print(f"Prior all zeros saved to {output_path}") + -def create_boundary_regions(grid_filename, output_path, cdo_nco_cmd, +def create_boundary_regions(grid_filename, output_path, n_bg_ens, cdo_nco_cmd, cdo_nco_cmd_post): """ Create boundary region masks based on geographical quadrants and save to NetCDF. @@ -81,20 +102,25 @@ def create_boundary_regions(grid_filename, output_path, cdo_nco_cmd, ds_grid = xr.open_dataset('outgrid.grid.nc') clon, clat = np.rad2deg(ds_grid['clon']), np.rad2deg(ds_grid['clat']) + + # Compute the central reference point mid_lon, mid_lat = np.nanquantile(clon, 0.5), np.nanquantile(clat, 0.5) - boundary_regions = np.zeros((len(clon), 8), dtype=np.int32) + # Center coordinates relative to the midpoint clon_cent, clat_cent = clon - mid_lon, clat - mid_lat - for i, (lon, lat) in enumerate(zip(clon_cent, clat_cent)): - if lon > 0 and lat > 0: - boundary_regions[i][6 if lon > lat else 7] = 1 - elif lon < 0 and lat < 0: - boundary_regions[i][2 if lon > lat else 3] = 1 - elif lon > 0 and lat < 0: - boundary_regions[i][4 if lon > abs(lat) else 5] = 1 - elif lon < 0 and lat > 0: - boundary_regions[i][0 if abs(lon) > lat else 1] = 1 + # Compute angles of all points relative to the center + angles = np.arctan2(clat_cent, clon_cent) # Range: [-Ï€, Ï€] + + # Set number of regions + sector_size = (2 * np.pi) / n_bg_ens # Each sector covers an angle range + + # Assign each point to a region (0 to N-1) + region_indices = (angles // sector_size).astype(int) # Range: [-Ï€, Ï€] + + # One-hot encode the region assignments + boundary_regions = np.zeros((len(clon), n_bg_ens), dtype=np.int32) + boundary_regions[np.arange(len(clon)), region_indices] = 1 ds_boundary = xr.Dataset(data_vars={ 'boundaryregion': (['cell', 'reg'], boundary_regions), @@ -102,33 +128,60 @@ def create_boundary_regions(grid_filename, output_path, cdo_nco_cmd, }, coords={ 'cell': (['cell'], np.arange(len(clon))), - 'reg': (['reg'], np.arange(8)) + 'reg': (['reg'], np.arange(n_bg_ens)) }, attrs={ 'author': 'Erik Koene', 'email': 'erik.koene@empa.ch' }) - ds_boundary.to_netcdf(output_path) + try: + ds_boundary.to_netcdf(output_path) + except: + print("File currently open. Please close the file and try again.") print(f"Boundary regions saved to {output_path}") -def create_boundary_prior_all_ones(output_path, nensembles): +def create_boundary_prior_all_ones(output_path, n_bg_ens, nensembles, propagate_bg=False): """ Create boundary lambdas dataset and save to NetCDF. """ - lambdas = np.ones((nensembles, 8), dtype=np.float32) + nensembles = nensembles + 1 if propagate_bg else nensembles + lambdas = np.ones((nensembles, n_bg_ens), dtype=np.float32) ds_lambdas = xr.Dataset(data_vars={'lambda': (['ens', 'reg'], lambdas)}, coords={ 'ens': (['ens'], np.arange(nensembles)), - 'reg': (['reg'], np.arange(8)) + 'reg': (['reg'], np.arange(n_bg_ens)) }, attrs={ 'author': 'Erik Koene', 'email': 'erik.koene@empa.ch' }) - ds_lambdas.to_netcdf(output_path) + try: + ds_lambdas.to_netcdf(output_path) + except: + print("File currently open. Please close the file and try again.") print(f"Boundary lambdas saved to {output_path}") +def create_boundary_prior_separate(output_path, n_bg_ens): + """ + Create boundary lambdas dataset and save to NetCDF. + """ + lambdas = np.identity(n_bg_ens, dtype=np.float32) + ds_lambdas = xr.Dataset(data_vars={'lambda': (['ens', 'reg'], lambdas)}, + coords={ + 'ens': (['ens'], np.arange(n_bg_ens)), + 'reg': (['reg'], np.arange(n_bg_ens)) + }, + attrs={ + 'author': 'Erik Koene', + 'email': 'erik.koene@empa.ch' + }) + try: + ds_lambdas.to_netcdf(output_path) + except: + print("File currently open. Please close the file and try again.") + print(f"Boundary-separated lambdas saved to {output_path}") + # Example usage # lambdas_ids = np.array([1]*8+[1]*8+[1]*15) diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 4ec57a5e..d887a50b 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -327,7 +327,6 @@ def fetch_ICOS_data(query_type='any', # Skip if filename exists if os.path.isfile(outfn): continue - shape = np.shape(obj) lon = Dobj(d).lon @@ -369,10 +368,6 @@ def fetch_ICOS_data(query_type='any', ds.attrs['Longitude'] = Dobj(d).lon ds.attrs['Latitude'] = Dobj(d).lat ds.attrs['Name of the tracer'] = meta[0] - name = 'ICOS_obs_' + str(specie)[2:-2] + '_' + query_type + '_' + str( - Dobj(d).station['id']) + '_' + str( - Dobj(d).meta['specificInfo']['acquisition'] - ['samplingHeight']) + '_' + start_date + '_' + end_date + '.nc' ds.to_netcdf(outfn) @@ -745,6 +740,7 @@ def get_http_data(request): def process_OCO2_data(OCO2_obs_folder, + ICON_grid_file, start_date='01-01-2022', end_date='31-12-2022', output_folder='~/'): @@ -753,10 +749,10 @@ def process_OCO2_data(OCO2_obs_folder, Parameters ---------- OCO2_obs_folder str e.g., /scratch/snx/[user]/OCO2_data/year + ICON_grid_file str e.g., /scratch/snx/[user]/ICON_grid.nc start_date DateTime end_date DateTime output_folder str e.g., /scratch/snx/[user]/ICOS_data/year/ - """ # # Process files @@ -777,6 +773,56 @@ def process_OCO2_data(OCO2_obs_folder, # Open file s5p_data = xr.open_dataset(file[0]) + + # Limit to extent of ICON grid + ICON_grid = xr.open_dataset(ICON_grid_file) + offset = 1.2 # 1.2 degrees offset to ensure no data is beyond the grid bounds + try: + s5p_data = s5p_data.where( + (s5p_data.longitude >= np.rad2deg(ICON_grid.clon.min().values) + offset) & + (s5p_data.longitude <= np.rad2deg(ICON_grid.clon.max().values) - offset) & + (s5p_data.latitude >= np.rad2deg(ICON_grid.clat.min().values) + offset) & + (s5p_data.latitude <= np.rad2deg(ICON_grid.clat.max().values) - offset), + drop=True).where(s5p_data.xco2_quality_flag == 0, drop=True) + # s5p_data = s5p_data.where((s5p_data.longitude > -8.6) & (s5p_data.longitude < 17.9) & (s5p_data.latitude > 40.6) & (s5p_data.latitude < 59), drop=True) + print("The new limits are....") + print(f"{s5p_data.longitude.min().values} {s5p_data.longitude.max().values}") + print(f"{s5p_data.latitude.min().values} {s5p_data.latitude.max().values}") + print("Filtered on") + print(f"{np.rad2deg(ICON_grid.clon.min()).values} {np.rad2deg(ICON_grid.clon.max()).values}") + print(f"{np.rad2deg(ICON_grid.clat.min()).values} {np.rad2deg(ICON_grid.clat.max()).values}") + except: + print(f"No observations remain after filtering {file} to ICON grid limits") + s5p_out = xr.Dataset( + { + "latitude": (["soundings"], np.array([], dtype=np.float32)), + "longitude": (["soundings"], np.array([], dtype=np.float32)), + "date": (["soundings", "epoch_dimension"], np.empty((0, 7), dtype=np.float32)), + "obs": (["soundings"], np.array([], dtype=np.float32)), + "quality_flag": (["soundings"], np.array([], dtype=np.int32)), + "averaging_kernel": (["soundings", "layers"], np.empty((0, 20), dtype=np.float32)), + "pressure_levels": (["soundings", "layers"], np.empty((0, 20), dtype=np.float32)), + "pressure_weighting_function": (["soundings", "layers"], np.empty((0, 20), dtype=np.float32)), + "prior_profile": (["soundings", "layers"], np.empty((0, 20), dtype=np.float32)), + "prior": (["soundings"], np.array([], dtype=np.float32)), + "uncertainty": (["soundings"], np.array([], dtype=np.float32)), + "surface_pressure": (["soundings"], np.array([], dtype=np.float32)), + }, + coords={ + "soundings": np.array([], dtype=np.int32), + "layers": np.arange(20), + "epoch_dimension": np.arange(7), + }, + attrs={ + 'creation_date': str(datetime.now()), + 'author': 'Processing Chain', + 'level_def': 'pressure_boundaries', + 'retrieval_id': file[0].name if file else 'unknown', + }, + ) + s5p_out.to_netcdf(output_folder / f"OCO2_{day.strftime('%Y%m%d')}_ctdas.nc") + continue + s5p_out = s5p_data[[ "latitude", "longitude", "date", "xco2", "xco2_quality_flag", "xco2_averaging_kernel", "pressure_levels", "pressure_levels", @@ -794,10 +840,11 @@ def process_OCO2_data(OCO2_obs_folder, "xco2_apriori": "prior", "xco2_uncertainty": "uncertainty" }) - s5p_out["pressure_levels"] = s5p_out.pressure_levels[:, ::-1] + s5p_out["pressure_levels"][:] = s5p_out.pressure_levels[:, ::-1].values s5p_out[ - "pressure_weighting_function"] = s5p_out.pressure_weighting_function[:, :: - -1] + "pressure_weighting_function"][:] = s5p_out.pressure_weighting_function[:, :: + -1].values + s5p_out["prior_profile"][:] = s5p_out.prior_profile[:, ::-1].values s5p_out["surface_pressure"] = s5p_out.pressure_levels[:, 0] s5p_out.attrs.update({ 'creation_date': str(datetime.now()), diff --git a/jobs/tools/generate_tracers_xml.py b/jobs/tools/generate_tracers_xml.py index 545fb021..98aef5da 100644 --- a/jobs/tools/generate_tracers_xml.py +++ b/jobs/tools/generate_tracers_xml.py @@ -3,7 +3,7 @@ import numpy as np -def generate_tracers_xml(data, nens=-1, restart=False): +def generate_tracers_xml(data, nens=-1, n_bg_ens=-1, restart=False, runthrough=False, propagate_bg=False): """ Generate an XML representation for chemtracers. @@ -21,7 +21,7 @@ def generate_tracers_xml(data, nens=-1, restart=False): }, "CO2_RA": {}, "CO2_GPP": {}, - "TRCO2_A-XXX": {"start": 0, "count": 10, "bg": "TRCO2_BG", "ra": "CO2_RA", "gpp": "CO2_GPP"} + "TRCO2_A-XXX": {"bg": "TRCO2_BG", "ra": "CO2_RA", "gpp": "CO2_GPP"} } Returns: @@ -77,30 +77,63 @@ def generate_tracers_xml(data, nens=-1, restart=False): if restart and not item_id.startswith("EM_"): ET.SubElement(tracer_ra, "oem_restart", type="char").text = "file" - if item_id.endswith("XXX"): - # Make a set of ensemble tracers - for i in np.arange(nens) + 1: - tracer_xxx = ET.SubElement(tracers, - "chemtracer", - id=f"TRCO2_A-{i:03}") - ET.SubElement(tracer_xxx, "transport", - type="char").text = "stdaero" - ET.SubElement(tracer_xxx, "oem_type", type="char").text = "ens" - ET.SubElement(tracer_xxx, "c_solve", - type="char").text = "passive" - ET.SubElement(tracer_xxx, "init_mode", type="int").text = "0" - if "bg" in item_data: - ET.SubElement(tracer_xxx, "oem_bg_ens", - type="char").text = item_data["bg"] - if "ra" in item_data and "gpp" in item_data: - ET.SubElement( - tracer_xxx, "oem_vprm_bg_ens", type="char" - ).text = f"{item_data['ra']}, {item_data['gpp']}" - if restart: - ET.SubElement(tracer_xxx, "oem_restart", - type="char").text = "file" - ET.SubElement(tracer_xxx, "unit", type="char").text = "none" - + if not runthrough: + if item_id.endswith("XXX"): + # Make a set of ensemble tracers + for i in np.arange(nens) + 1: + tracer_xxx = ET.SubElement(tracers, + "chemtracer", + id=f"{item_id[:-4]}-{i:03}") + ET.SubElement(tracer_xxx, "transport", + type="char").text = "stdaero" + ET.SubElement(tracer_xxx, "oem_type", type="char").text = "ens" + ET.SubElement(tracer_xxx, "c_solve", + type="char").text = "passive" + ET.SubElement(tracer_xxx, "init_mode", type="int").text = "0" + if "bg" in item_data: + ET.SubElement(tracer_xxx, "oem_bg_ens", + type="char").text = item_data["bg"] + if "ra" in item_data and "gpp" in item_data: + ET.SubElement( + tracer_xxx, "oem_vprm_bg_ens", type="char" + ).text = f"{item_data['ra']}, {item_data['gpp']}" + if restart: + ET.SubElement(tracer_xxx, "oem_restart", + type="char").text = "file" + ET.SubElement(tracer_xxx, "unit", type="char").text = "none" + if propagate_bg: + tracer_xxx = ET.SubElement(tracers, + "chemtracer", + id=f"{item_id[:-4]}-{nens+1:03}") + ET.SubElement(tracer_xxx, "transport", + type="char").text = "stdaero" + ET.SubElement(tracer_xxx, "oem_type", type="char").text = "ens" + ET.SubElement(tracer_xxx, "c_solve", + type="char").text = "passive" + ET.SubElement(tracer_xxx, "init_mode", type="int").text = "0" + if "bg" in item_data: + ET.SubElement(tracer_xxx, "oem_bg_ens", + type="char").text = item_data["bg"] + if restart: + ET.SubElement(tracer_xxx, "oem_restart", + type="char").text = "file" + ET.SubElement(tracer_xxx, "unit", type="char").text = "none" + else: + if item_id.endswith("XXX"): + for i in np.arange(n_bg_ens) + 1: + tracer_bg_xxx = ET.SubElement(tracers, "chemtracer", id=f"{item_id[:-4]}-{i:03}") + ET.SubElement(tracer_bg_xxx, "transport", + type="char").text = "stdaero" + ET.SubElement(tracer_bg_xxx, "oem_type", type="char").text = "ens" + ET.SubElement(tracer_bg_xxx, "c_solve", + type="char").text = "passive" + ET.SubElement(tracer_bg_xxx, "init_mode", type="int").text = "0" + if "bg" in item_data: + ET.SubElement(tracer_bg_xxx, "oem_bg_ens", + type="char").text = item_data["bg"] + if restart: + ET.SubElement(tracer_bg_xxx, "oem_restart", type="char").text = "file" + ET.SubElement(tracer_bg_xxx, "unit", type="char").text = "none" # Convert to string xml_declaration = "\n\n" xml_string = ET.tostring(tracers, encoding="unicode") From fab977bd5bf05b7e7ec98ed05109288d009ca535 Mon Sep 17 00:00:00 2001 From: github-actions Date: Tue, 4 Mar 2025 15:16:25 +0000 Subject: [PATCH 32/42] GitHub Action: Apply Pep8-formatting --- cases/icon-art-CTDAS/ICON/Michael_sampler.py | 293 +++--- .../icon-art-CTDAS/ctdas_patch/icon_helper.py | 590 +++++++----- .../ctdas_patch/icon_sampler.py | 165 ++-- .../ctdas_patch/initexit_cteco2.py | 335 ++++--- .../ctdas_patch/obs_class_ICOS_OCO2.py | 652 ++++++++------ .../ctdas_patch/obsoperator_ICOS_OCO2.py | 459 ++++++---- .../optimizer_baseclass_icos_cities.py | 498 +++++----- .../ctdas_patch/pipeline_icon.py | 295 +++--- .../statevector_baseclass_icos_cities.py | 312 ++++--- cases/icon-art-CTDAS/ctdas_patch/template.py | 29 +- cases/icon-art-CTDAS/ctdas_patch/utilities.py | 92 +- .../ctdas_patch/icon_helper.py | 596 ++++++------ .../ctdas_patch/icon_sampler.py | 165 ++-- .../ctdas_patch/obs_class_ICOS_OCO2.py | 850 ++++++++++-------- .../ctdas_patch/obsoperator_ICOS_OCO2.py | 660 ++++++++------ .../optimizer_baseclass_icos_cities.py | 571 +++++++----- .../statevector_baseclass_icos_cities.py | 349 ++++--- cases/icon-art-CTDAS2/ctdas_patch/template.py | 29 +- .../icon-art-CTDAS2/ctdas_patch/utilities.py | 92 +- config.py | 4 +- jobs/CTDAS.py | 39 +- jobs/prepare_CTDAS.py | 237 +++-- jobs/tools/ICON_to_point.py | 13 +- jobs/tools/ICON_to_point2.py | 23 +- jobs/tools/ctdas_utilities.py | 31 +- jobs/tools/fetch_external_data.py | 76 +- jobs/tools/generate_tracers_xml.py | 75 +- 27 files changed, 4497 insertions(+), 3033 deletions(-) diff --git a/cases/icon-art-CTDAS/ICON/Michael_sampler.py b/cases/icon-art-CTDAS/ICON/Michael_sampler.py index b906bd23..91db0d0c 100644 --- a/cases/icon-art-CTDAS/ICON/Michael_sampler.py +++ b/cases/icon-art-CTDAS/ICON/Michael_sampler.py @@ -7,7 +7,6 @@ @author: stem """ - #%% """Import""" from shapely.geometry import Point, Polygon @@ -34,7 +33,7 @@ # nlev = 60 #number of vertical levels # nneighb = 5 #number of nearest neighbors to consider # n_member = {n_member} -# meta = { +# meta = { # 'TRCO2_A': {'offset': 0.}, # 'TRCO2_BG': {'offset': 0.}, # 'CO2_RA': {'offset': 0.}, @@ -48,31 +47,36 @@ # 'TRCO2_A-ENS': {'offset': 0, 'ensemble': n_member}, # } # outfile = {outfile} - """Interpolation function""" - + + # def intp_icon_data(args): -def intp_icon_data(iloc, gridinfo, datainfo, latitudes, longitudes, asl, elev, station_name, mountain_stations): +def intp_icon_data(iloc, gridinfo, datainfo, latitudes, longitudes, asl, elev, + station_name, mountain_stations): nn_sel = np.zeros(gridinfo.nn) - u=np.zeros(gridinfo.nn) - - R = 6373.0 # approximate radius of earth in km - - - if (radians(longitudes[iloc])np.nanmax(gridinfo.clon)): + u = np.zeros(gridinfo.nn) + + R = 6373.0 # approximate radius of earth in km + + if (radians(longitudes[iloc]) < np.nanmin(gridinfo.clon)) or (radians( + longitudes[iloc]) > np.nanmax(gridinfo.clon)): u[:] = np.nan - return np.zeros((gridinfo.nn)), np.zeros((gridinfo.nn)).astype(int), np.zeros((gridinfo.nn)).astype(int), nn_sel[:], u[:] - - - if (radians(latitudes[iloc])np.nanmax(gridinfo.clat)): + return np.zeros((gridinfo.nn)), np.zeros( + (gridinfo.nn)).astype(int), np.zeros( + (gridinfo.nn)).astype(int), nn_sel[:], u[:] + + if (radians(latitudes[iloc]) < np.nanmin(gridinfo.clat)) or (radians( + latitudes[iloc]) > np.nanmax(gridinfo.clat)): u[:] = np.nan - return np.zeros((gridinfo.nn)), np.zeros((gridinfo.nn)).astype(int), np.zeros((gridinfo.nn)).astype(int), nn_sel[:], u[:] + return np.zeros((gridinfo.nn)), np.zeros( + (gridinfo.nn)).astype(int), np.zeros( + (gridinfo.nn)).astype(int), nn_sel[:], u[:] #% lat1 = radians(latitudes[iloc]) lon1 = radians(longitudes[iloc]) - + #% """FIND 4 CLOSEST CENTERS""" distances = np.zeros((len(gridinfo.clon))) @@ -84,21 +88,23 @@ def intp_icon_data(iloc, gridinfo, datainfo, latitudes, longitudes, asl, elev, s a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2 c = 2 * atan2(sqrt(a), sqrt(1 - a)) distances[icell] = R * c - nn_sel[:] = [x for _, x in sorted(zip(distances,np.arange(len(gridinfo.clon))))][0:gridinfo.nn] - nn_sel=nn_sel.astype(int) + nn_sel[:] = [ + x for _, x in sorted(zip(distances, np.arange(len(gridinfo.clon)))) + ][0:gridinfo.nn] + nn_sel = nn_sel.astype(int) #print('---nn_sel:',nn_sel) #print('---distances[0:gridinfo.nn]:',distances[0:gridinfo.nn]) - u[:] = [1./distances[y] for y in nn_sel] - print('---distances:',[distances[y] for y in nn_sel]) - print('---weights:',u) - + u[:] = [1. / distances[y] for y in nn_sel] + print('---distances:', [distances[y] for y in nn_sel]) + print('---weights:', u) + #% """Calculate vertical interpolation factor""" - idx_above = -1*np.ones((len(nn_sel))).astype(int) - idx_below = -1*np.ones((len(nn_sel))).astype(int) + idx_above = -1 * np.ones((len(nn_sel))).astype(int) + idx_below = -1 * np.ones((len(nn_sel))).astype(int) target_asl = np.zeros((len(nn_sel))) for nnidx in np.arange(len(nn_sel)): - model_topo = datainfo.z_ifc[-1,nn_sel[nnidx]] + model_topo = datainfo.z_ifc[-1, nn_sel[nnidx]] print(station_name[iloc]) if station_name[iloc] not in mountain_stations: print('not a mountain station') @@ -106,70 +112,84 @@ def intp_icon_data(iloc, gridinfo, datainfo, latitudes, longitudes, asl, elev, s else: print('mountain station') target_asl[nnidx] = asl[iloc] + elev[iloc] - for i_mc,mc in enumerate(datainfo.z_mc[:,nn_sel[nnidx]]): + for i_mc, mc in enumerate(datainfo.z_mc[:, nn_sel[nnidx]]): # if mc>=asl[iloc]: - if mc>=target_asl[nnidx]: + if mc >= target_asl[nnidx]: idx_above[nnidx] = i_mc else: idx_below[nnidx] = i_mc break - - + #in case of data point below lowest midlevel: for nnidx in np.arange(len(nn_sel)): - if idx_below[nnidx]==-1: + if idx_below[nnidx] == -1: idx_below[nnidx] = idx_above[nnidx] - if any(np.ravel([idx_above,idx_below])<0): + if any(np.ravel([idx_above, idx_below]) < 0): print("At least one nearest neigbor has no valid height levels") - u[:] = np.nan #-999. - return np.zeros((gridinfo.nn)), np.zeros((gridinfo.nn)).astype(int), np.zeros((gridinfo.nn)).astype(int), nn_sel[:], u - + u[:] = np.nan #-999. + return np.zeros((gridinfo.nn)), np.zeros( + (gridinfo.nn)).astype(int), np.zeros( + (gridinfo.nn)).astype(int), nn_sel[:], u + vert_scaling_fact = np.zeros((len(nn_sel))) for nnidx in np.arange(len(nn_sel)): if idx_below[nnidx] != idx_above[nnidx]: - vert_scaling_fact[nnidx] = (target_asl[nnidx]-datainfo.z_mc[idx_below[nnidx],nn_sel[nnidx]])/(datainfo.z_mc[idx_above[nnidx],nn_sel[nnidx]]-datainfo.z_mc[idx_below[nnidx],nn_sel[nnidx]]) + vert_scaling_fact[nnidx] = ( + target_asl[nnidx] - + datainfo.z_mc[idx_below[nnidx], nn_sel[nnidx]]) / ( + datainfo.z_mc[idx_above[nnidx], nn_sel[nnidx]] - + datainfo.z_mc[idx_below[nnidx], nn_sel[nnidx]]) else: vert_scaling_fact[nnidx] = 0. - - print('---idx above:',idx_above) - print('---idx below:',idx_below) - print('---vert_scaling_fact:',vert_scaling_fact) - + + print('---idx above:', idx_above) + print('---idx below:', idx_below) + print('---vert_scaling_fact:', vert_scaling_fact) + #% return vert_scaling_fact, idx_below, idx_above, nn_sel[:], u -def ICON_sampler(DATA_path, fname_base, ICON_grid, starttime, endtime, obs_dir, nneighb, meta, outfile, nlev=60, mountain_stations=[]): - fh_grid = Dataset(ICON_grid,'r') +def ICON_sampler(DATA_path, + fname_base, + ICON_grid, + starttime, + endtime, + obs_dir, + nneighb, + meta, + outfile, + nlev=60, + mountain_stations=[]): + fh_grid = Dataset(ICON_grid, 'r') + class gridinfo: clon_vertices = np.array(fh_grid.variables['clon_vertices']) clat_vertices = np.array(fh_grid.variables['clat_vertices']) cells_of_vertex = np.array(fh_grid.variables['cells_of_vertex']) vertex_of_cell = np.array(fh_grid.variables['vertex_of_cell']) - neighbor_cell_index = np.array(fh_grid.variables['neighbor_cell_index']) + neighbor_cell_index = np.array( + fh_grid.variables['neighbor_cell_index']) vlon = np.array(fh_grid.variables['vlon']) vlat = np.array(fh_grid.variables['vlat']) clon = np.array(fh_grid.variables['clon']) clat = np.array(fh_grid.variables['clat']) ncells = len(fh_grid.dimensions['cell']) - nn=nneighb + nn = nneighb #%% - """Times""" - firstfile=True - startdate = datetime.datetime.strptime(starttime,'%Y-%m-%d %H:%M:%S') - enddate = datetime.datetime.strptime(endtime,'%Y-%m-%d %H:%M:%S') + firstfile = True + startdate = datetime.datetime.strptime(starttime, '%Y-%m-%d %H:%M:%S') + enddate = datetime.datetime.strptime(endtime, '%Y-%m-%d %H:%M:%S') delta = datetime.timedelta(hours=1) looptime = startdate #%% - """Get locations of measurement stations""" - longitudes = [] latitudes = [] obsnames = [] @@ -183,17 +203,17 @@ class gridinfo: infile = os.path.join(obs_dir, ncfile) print(f"Reading {infile}") - + f = xr.open_dataset(infile) stationnames = f.Stations_names.values st_ind = np.arange(len(stationnames)) for x in st_ind: - latitudes.append(f.Lat[x].values) + latitudes.append(f.Lat[x].values) obsnames.append(unidecode(str(f.Stations_names[x].values))) longitudes.append(f.Lon[x].values) asl.append(f.Stations_masl[x]) - elev.append( float(obsnames[-1].split('_')[-1]) ) - print("Found %i locations."%(len(latitudes))) + elev.append(float(obsnames[-1].split('_')[-1])) + print("Found %i locations." % (len(latitudes))) # """Add 5 missing stations""" # missing_longitudes = [-1.15, 4.93, 0.23, 8.4, 8.18] @@ -208,23 +228,27 @@ class gridinfo: # print("Added %i missing locations."%(len(missing_longitudes))) #%% - """Initialize output variables""" - n_det = int(np.nansum([1 for var in meta.keys() if 'ensemble' not in meta[var]])) - n_ens = int(np.nansum([1 for var in meta.keys() if 'ensemble' in meta[var]])) - intp_ICON_data_det = np.zeros((n_det,len(latitudes),0)) - maxmem=0 + n_det = int( + np.nansum([1 for var in meta.keys() if 'ensemble' not in meta[var]])) + n_ens = int( + np.nansum([1 for var in meta.keys() if 'ensemble' in meta[var]])) + intp_ICON_data_det = np.zeros((n_det, len(latitudes), 0)) + maxmem = 0 for var in meta.keys(): if 'ensemble' in meta[var]: - if meta[var]['ensemble']>maxmem: - maxmem=meta[var]['ensemble'] - maxmem=int(maxmem) - intp_ICON_data_ens = np.zeros((n_ens,maxmem,len(latitudes),0)) + if meta[var]['ensemble'] > maxmem: + maxmem = meta[var]['ensemble'] + maxmem = int(maxmem) + intp_ICON_data_ens = np.zeros((n_ens, maxmem, len(latitudes), 0)) #%% - """Loop over Data Files (=timesteps)""" - def process_data(index, gridinfo, datainfo, latitudes, longitudes, asl, elev, obsnames, mountain_stations, results): - result = intp_icon_data(index, gridinfo, datainfo, latitudes, longitudes, asl, elev, obsnames, mountain_stations) + + def process_data(index, gridinfo, datainfo, latitudes, longitudes, asl, + elev, obsnames, mountain_stations, results): + result = intp_icon_data(index, gridinfo, datainfo, latitudes, + longitudes, asl, elev, obsnames, + mountain_stations) results.append((index, result)) datetime_list = [] @@ -232,49 +256,54 @@ def process_data(index, gridinfo, datainfo, latitudes, longitudes, asl, elev, ob date_idx = 0 while looptime <= enddate: - intp_ICON_data_det = np.concatenate(( intp_ICON_data_det,np.zeros((n_det,len(latitudes),1)) ),axis=2) - intp_ICON_data_ens = np.concatenate(( intp_ICON_data_ens,np.zeros((n_ens,maxmem,len(latitudes),1)) ),axis=3) - - timestring = datetime.datetime.strftime(looptime,'%Y-%m-%dT%H') + intp_ICON_data_det = np.concatenate( + (intp_ICON_data_det, np.zeros((n_det, len(latitudes), 1))), axis=2) + intp_ICON_data_ens = np.concatenate( + (intp_ICON_data_ens, np.zeros((n_ens, maxmem, len(latitudes), 1))), + axis=3) + + timestring = datetime.datetime.strftime(looptime, '%Y-%m-%dT%H') datetime_list.append(timestring) - DATA_file = os.path.join(DATA_path,'%s_%s:00:00.000.nc' %(fname_base,timestring)) + DATA_file = os.path.join( + DATA_path, '%s_%s:00:00.000.nc' % (fname_base, timestring)) - print('extracting from %s'%(DATA_file), flush=True) + print('extracting from %s' % (DATA_file), flush=True) + + fh_data = Dataset(DATA_file, 'r') - - fh_data = Dataset(DATA_file,'r') - class datainfo: z_mc = np.array(fh_data.variables['z_mc']) z_ifc = np.array(fh_data.variables['z_ifc']) - - - ICON_data_det = np.zeros(( n_det, nlev, gridinfo.ncells )) - ICON_data_ens = np.zeros(( n_ens, maxmem, nlev, gridinfo.ncells )) + + ICON_data_det = np.zeros((n_det, nlev, gridinfo.ncells)) + ICON_data_ens = np.zeros((n_ens, maxmem, nlev, gridinfo.ncells)) ivar = 0 for var in meta.keys(): if not 'ensemble' in meta[var]: - ICON_data_det[ivar,...] = np.array(fh_data.variables[var]) - ivar+=1 + ICON_data_det[ivar, ...] = np.array(fh_data.variables[var]) + ivar += 1 ivar = 0 for var in meta.keys(): if 'ensemble' in meta[var]: - # for iens in np.arange(n_member): + # for iens in np.arange(n_member): for iens in np.arange(meta[var]['ensemble']): - varnc = var.split('-')[0]+'-%.3i'%(iens+1) - ICON_data_ens[ivar,iens,...] = np.array(fh_data.variables[varnc]) - ivar+=1 + varnc = var.split('-')[0] + '-%.3i' % (iens + 1) + ICON_data_ens[ivar, iens, + ...] = np.array(fh_data.variables[varnc]) + ivar += 1 #%% - - """Since the stations don't walk around, I only call the function at the first timestep""" - + """Since the stations don't walk around, I only call the function at the first timestep""" + if looptime == startdate: manager = Manager() results = manager.list() processes = [] for i in range(len(latitudes)): - p = Process(target=process_data, args=(i, gridinfo, datainfo, latitudes, longitudes, asl, elev, obsnames, mountain_stations, results)) + p = Process(target=process_data, + args=(i, gridinfo, datainfo, latitudes, longitudes, + asl, elev, obsnames, mountain_stations, + results)) processes.append(p) p.start() @@ -288,19 +317,18 @@ class datainfo: sorted_results = [result for _, result in results] vsf, idxb, idxa, neighbours, u_ret = zip(*sorted_results) - vsf = np.array(vsf) idxb = np.array(idxb, dtype=int) idxa = np.array(idxa, dtype=int) neighbours = np.array(neighbours, dtype=int) u_ret = np.array(u_ret) - #Do the interpolation + #Do the interpolation for iloc in np.arange(len(latitudes)): ###First, the deterministic values: ##First, the vertical interpolation: - vert_intp_data = np.zeros(( n_det, len(idxb[iloc]) )) + vert_intp_data = np.zeros((n_det, len(idxb[iloc]))) for nn in np.arange(len(idxb[iloc])): vert_intp_data[:,nn] = ICON_data_det[:,idxb[iloc,nn],neighbours[iloc,nn]] + vsf[iloc,nn]*(ICON_data_det[:,idxa[iloc,nn],neighbours[iloc,nn]] \ -ICON_data_det[:,idxb[iloc,nn],neighbours[iloc,nn]]) @@ -308,15 +336,25 @@ class datainfo: #intp_ICON_data_det[:,iloc,date_idx] = u_ret[iloc,0]*vert_intp_data[:,0]+u_ret[iloc,1]*vert_intp_data[:,1] \ # +u_ret[iloc,2]*vert_intp_data[:,2] # - intp_ICON_data_det[:,iloc,date_idx] = np.nansum([w*vert_intp_data[:,i] for i,w in enumerate(u_ret[iloc,:])],axis=0)/np.nansum(u_ret[iloc,:]) + intp_ICON_data_det[:, iloc, date_idx] = np.nansum( + [ + w * vert_intp_data[:, i] + for i, w in enumerate(u_ret[iloc, :]) + ], + axis=0) / np.nansum(u_ret[iloc, :]) ###Second, the ensemble values: - vert_intp_data = np.zeros(( n_ens, maxmem, len(idxb[iloc]) )) + vert_intp_data = np.zeros((n_ens, maxmem, len(idxb[iloc]))) for nn in np.arange(len(idxb[iloc])): vert_intp_data[:,:,nn] = ICON_data_ens[:,:,idxb[iloc,nn],neighbours[iloc,nn]] + vsf[iloc,nn]*(ICON_data_ens[:,:,idxa[iloc,nn],neighbours[iloc,nn]] \ -ICON_data_ens[:,:,idxb[iloc,nn],neighbours[iloc,nn]]) #intp_ICON_data_ens[:,:,iloc,date_idx] = u_ret[iloc,0]*vert_intp_data[:,:,0]+u_ret[iloc,1]*vert_intp_data[:,:,1] \ # +u_ret[iloc,2]*vert_intp_data[:,:,2] - intp_ICON_data_ens[:,:,iloc,date_idx] = np.nansum([w*vert_intp_data[:,:,i] for i,w in enumerate(u_ret[iloc,:])],axis=0)/np.nansum(u_ret[iloc,:]) + intp_ICON_data_ens[:, :, iloc, date_idx] = np.nansum( + [ + w * vert_intp_data[:, :, i] + for i, w in enumerate(u_ret[iloc, :]) + ], + axis=0) / np.nansum(u_ret[iloc, :]) #%% """Update time""" looptime += delta @@ -330,33 +368,58 @@ class datainfo: oname = ofile.createVariable('site_name', str, ('sites')) otimes = ofile.createVariable('time', np.unicode_, ('time')) - + ivar = 0 for var in meta.keys(): if 'ensemble' not in meta[var]: - ovar = ofile.createVariable(var, np.float32, ('sites','time')) - ovar[:,:] = intp_ICON_data_det[ivar,:,:] - ivar+=1 - ivar=0 + ovar = ofile.createVariable(var, np.float32, ('sites', 'time')) + ovar[:, :] = intp_ICON_data_det[ivar, :, :] + ivar += 1 + ivar = 0 for var in meta.keys(): if 'ensemble' in meta[var]: - oens = ofile.createDimension('ens_%.2i'%(ivar+1), meta[var]['ensemble']) - varnc = var.split('-')[0]+'_ENS' - ovar = ofile.createVariable(varnc, np.float32, ('ens_%.2i'%(ivar+1),'sites','time')) - ovar[:,:,:] = intp_ICON_data_ens[ivar,0:meta[var]['ensemble'],:,:] - ivar+=1 + oens = ofile.createDimension('ens_%.2i' % (ivar + 1), + meta[var]['ensemble']) + varnc = var.split('-')[0] + '_ENS' + ovar = ofile.createVariable(varnc, np.float32, + ('ens_%.2i' % + (ivar + 1), 'sites', 'time')) + ovar[:, :, :] = intp_ICON_data_ens[ + ivar, 0:meta[var]['ensemble'], :, :] + ivar += 1 - oname[:] = np.array(stationnames[:]) otimes[:] = np.array(datetime_list) - if __name__ == '__main__': - sample_ICON = ICON_sampler("/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/prior_20180101", - "ICON-ART-UNSTR", - "/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_inputs/grid/icon_europe_DOM01.nc", - "2018-01-01 00:00:00", "2018-01-12 00:00:00", "/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_inputs/ICOS", 5, - {'TRCO2_A': {}, 'TRCO2_BG': {}, 'CO2_RA': {}, 'CO2_GPP': {}, 'TRCO2_A-ENS': {'ensemble': 186}, 'biosource': {}, 'biosink': {}, 'u': {}, 'v': {}, 'temp': {}, 'qv': {}}, - "/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/prior_20180101.nc", - nlev=60, mountain_stations=['Jungfraujoch_13', 'Monte Cimone_8', 'Puy de Dome_10', 'Pic du Midi_28', 'Zugspitze_3', 'Hohenpeissenberg_50', 'Hohenpeissenberg_93', 'Hohenpeissenberg_131', 'Schauinsland_12', 'Plateau Rosa_10']) + sample_ICON = ICON_sampler( + "/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/prior_20180101", + "ICON-ART-UNSTR", + "/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_inputs/grid/icon_europe_DOM01.nc", + "2018-01-01 00:00:00", + "2018-01-12 00:00:00", + "/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_inputs/ICOS", + 5, { + 'TRCO2_A': {}, + 'TRCO2_BG': {}, + 'CO2_RA': {}, + 'CO2_GPP': {}, + 'TRCO2_A-ENS': { + 'ensemble': 186 + }, + 'biosource': {}, + 'biosink': {}, + 'u': {}, + 'v': {}, + 'temp': {}, + 'qv': {} + }, + "/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/prior_20180101.nc", + nlev=60, + mountain_stations=[ + 'Jungfraujoch_13', 'Monte Cimone_8', 'Puy de Dome_10', + 'Pic du Midi_28', 'Zugspitze_3', 'Hohenpeissenberg_50', + 'Hohenpeissenberg_93', 'Hohenpeissenberg_131', 'Schauinsland_12', + 'Plateau Rosa_10' + ]) diff --git a/cases/icon-art-CTDAS/ctdas_patch/icon_helper.py b/cases/icon-art-CTDAS/ctdas_patch/icon_helper.py index 30df386a..d8950c53 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/icon_helper.py +++ b/cases/icon-art-CTDAS/ctdas_patch/icon_helper.py @@ -21,7 +21,6 @@ # pylint: disable=E1136 # pylint: disable=E1101 - import os import shutil import re @@ -47,9 +46,10 @@ class ICON_Helper(object): """Contains helper functions for sampling WRF-Chem""" + def __init__(self, settings): self.settings = settings - + #def __init__(self): # Use this part for offline testing # pass @@ -58,7 +58,7 @@ def validate_settings(self, needed_items=[]): This is based on WRFChemOO._validate_rc """ - if len(needed_items)==0: + if len(needed_items) == 0: return for key in needed_items: @@ -66,7 +66,6 @@ def validate_settings(self, needed_items=[]): msg = "Missing a required value in settings: %s" % key raise IOError(msg) - @staticmethod def get_pressure_boundaries_paxis(p_axis, p_surf): """ @@ -80,7 +79,7 @@ def get_pressure_boundaries_paxis(p_axis, p_surf): ------ Pressure at layer boundaries """ - + #pb = np.array([float("nan")]*(len(p_axis)+1)) #pb[0] = p_surf # @@ -88,12 +87,13 @@ def get_pressure_boundaries_paxis(p_axis, p_surf): # pb[nl+1] = pb[nl] + 2*(p_axis[nl] - pb[nl]) # ^ commented out by David coz it didn't work # v Added by David - p_full = np.insert(p_axis, 0, psurf, axis=1) # Insert p_surf to the first index - pb = np.array([float("nan")]*(len(p_axis)+1)) + p_full = np.insert(p_axis, 0, psurf, + axis=1) # Insert p_surf to the first index + pb = np.array([float("nan")] * (len(p_axis) + 1)) pb[0] = p_surf - for nl in range(len(pb)-1): - pb[nl+1] = 0.5*( p_full[nl] + p_full[nl+1] ) + for nl in range(len(pb) - 1): + pb[nl + 1] = 0.5 * (p_full[nl] + p_full[nl + 1]) return pb @@ -124,8 +124,7 @@ def get_pressure_boundaries_znw(znw, p_surf, p_top): See also comments in code. """ - return znw*(p_surf-p_top) + p_top - + return znw * (p_surf - p_top) + p_top @staticmethod def get_int_coefs(pb_ret, pb_mod, level_def): @@ -194,7 +193,7 @@ def get_int_coefs(pb_ret, pb_mod, level_def): coefs = get_int_coefs(pb_ret, pb_mod, "layer_average") retrieval_profile = np.matmul(coefs, model_profile) """ - + if level_def == "layer_average": # This code assumes that WRF variables are constant in # layers, but they are defined on levels. This can be seen @@ -230,92 +229,91 @@ def get_int_coefs(pb_ret, pb_mod, level_def): # would be more accurate to do the piecewise-linear # interpolation and the output matrix will have 1 more # value in each dimension. - + # Calculate integration weights by weighting with layer # thickness. This assumes that both axes are ordered # psurf to ptop. - coefs = np.ndarray(shape=(len(pb_ret)-1, len(pb_mod)-1)) + coefs = np.ndarray(shape=(len(pb_ret) - 1, len(pb_mod) - 1)) coefs[:] = 0. - + # Extend the model pressure grid if retrieval encompasses # more. pb_mod_tmp = copy.deepcopy(pb_mod) - + # In case the retrieval pressure is higher than the model # surface pressure, extend the lowest model layer. if pb_mod_tmp[0] < pb_ret[0]: pb_mod_tmp[0] = pb_ret[0] - + # In case the model doesn't extend as far as the retrieval, # extend the upper model layer upwards. if pb_mod_tmp[-1] > pb_ret[-1]: pb_mod_tmp[-1] = pb_ret[-1] - + # For each retrieval layer, this loop computes which # proportion falls into each model layer. - for nret in range(len(pb_ret)-1): - + for nret in range(len(pb_ret) - 1): + # 1st model pressure boundary index = the one before the # first boundary with lower pressure than high-pressure # retrieval layer boundary. model_lower = pb_mod_tmp < pb_ret[nret] id_model_lower = model_lower.nonzero()[0] - id_min = id_model_lower[0]-1 - + id_min = id_model_lower[0] - 1 + # Last model pressure boundary index = the last one with # higher pressure than low-pressure retrieval layer # boundary. - model_higher = pb_mod_tmp > pb_ret[nret+1] - + model_higher = pb_mod_tmp > pb_ret[nret + 1] + id_model_higher = model_higher.nonzero()[0] - + if len(id_model_higher) == 0: #id_max = id_min raise ValueError("This shouldn't happen. Debug.") else: id_max = id_model_higher[-1] - + # By the way, in case there is no model level with # higher pressure than the next retrieval level, # id_max must be the same as id_min. - + # For each model layer, find out how much of it makes up this # retrieval layer - for nmod in range(id_min, id_max+1): + for nmod in range(id_min, id_max + 1): if (nmod == id_min) & (nmod != id_max): # Part of 1st model layer that falls within # retrieval layer - coefs[nret, nmod] = pb_ret[nret] - pb_mod_tmp[nmod+1] + coefs[nret, nmod] = pb_ret[nret] - pb_mod_tmp[nmod + 1] elif (nmod != id_min) & (nmod == id_max): # Part of last model layer that falls within # retrieval layer - coefs[nret, nmod] = pb_mod_tmp[nmod] - pb_ret[nret+1] + coefs[nret, nmod] = pb_mod_tmp[nmod] - pb_ret[nret + 1] elif (nmod == id_min) & (nmod == id_max): # id_min = id_max, i.e. model layer encompasses # retrieval layer - coefs[nret, nmod] = pb_ret[nret] - pb_ret[nret+1] + coefs[nret, nmod] = pb_ret[nret] - pb_ret[nret + 1] else: # Retrieval layer encompasses model layer - coefs[nret, nmod] = pb_mod_tmp[nmod] - pb_mod_tmp[nmod+1] - - coefs[nret, :] = coefs[nret, :]/sum(coefs[nret, :]) - + coefs[nret, + nmod] = pb_mod_tmp[nmod] - pb_mod_tmp[nmod + 1] + + coefs[nret, :] = coefs[nret, :] / sum(coefs[nret, :]) + # I tested the code with many cases, but I'm only 99.9% sure # it works for all input. Hence a test here that the # coefficients sum to 1 and dump the data if not. sum_ = np.abs(coefs.sum(1) - 1) - if np.any(sum_ > 2.*np.finfo(sum_.dtype).eps): - dump = dict(pb_ret=pb_ret, - pb_mod=pb_mod, - level_def=level_def) + if np.any(sum_ > 2. * np.finfo(sum_.dtype).eps): + dump = dict(pb_ret=pb_ret, pb_mod=pb_mod, level_def=level_def) fp = "int_coefs_dump.pkl" with open(fp, "w") as f: pickle.dump(dump, f, 0) - + msg_fmt = "Something doesn't sum to 1. Arguments dumped to: %s" raise ValueError(msg_fmt % fp) - - elif level_def=="pressure_boundary": + + elif level_def == "pressure_boundary": #msg = "level_def is pressure_boundary. Implementation not complete." ##logging.error(msg) #raise ValueError(msg) @@ -324,36 +322,38 @@ def get_int_coefs(pb_ret, pb_mod, level_def): # Go back to pressure midpoints for model... # Change this line to p_mod = pb_mod for z-staggered # variables - p_mod = pb_mod[1:] - 0.5*np.diff(pb_mod) # Interpolate linearly in pressure space - - coefs = np.ndarray(shape=(len(pb_ret), len(pb_mod)-1)) + p_mod = pb_mod[1:] - 0.5 * np.diff( + pb_mod) # Interpolate linearly in pressure space + + coefs = np.ndarray(shape=(len(pb_ret), len(pb_mod) - 1)) coefs[:] = 0. - + # For each retrieval pressure level, compute linear # interpolation coefficients for nret in range(len(pb_ret)): nmod_list = (p_mod < pb_ret[nret]).nonzero()[0] - if(len(nmod_list)>0): + if (len(nmod_list) > 0): nmod = nmod_list[0] - 1 - if nmod==-1: + if nmod == -1: # Constant extrapolation at surface nmod = 0 coef = 1. else: # Normal case: - coef = (pb_ret[nret]-p_mod[nmod+1])/(p_mod[nmod]-p_mod[nmod+1]) + coef = (pb_ret[nret] - p_mod[nmod + 1]) / ( + p_mod[nmod] - p_mod[nmod + 1]) else: # Constant extrapolation at atmosphere top - nmod = len(p_mod)-2 - coef=0. - + nmod = len(p_mod) - 2 + coef = 0. + coefs[nret, nmod] = coef - coefs[nret, nmod+1] = 1.-coef - + coefs[nret, nmod + 1] = 1. - coef + else: msg = "Unknown level_def: " + level_def raise ValueError(msg) - + return coefs @staticmethod @@ -365,13 +365,13 @@ def get_pressure_weighting_function(pressure_boundaries, rule): - connor2008 (not implemented) """ if rule == 'simple': - pwf = np.abs(np.diff(pressure_boundaries)/np.ptp(pressure_boundaries)) + pwf = np.abs( + np.diff(pressure_boundaries) / np.ptp(pressure_boundaries)) else: raise NotImplementedError("Rule %s not implemented" % rule) return pwf - ### David: Original function from ctdas-wrf ### ### Keeping here as reference. ### @@ -418,7 +418,8 @@ def sample_total_columns(self, dat, loc, fields_list): """ # Initialize output - tc = np.ndarray(shape=(len(dat["prior"]), len(fields_list)), dtype=float) + tc = np.ndarray(shape=(len(dat["prior"]), len(fields_list)), + dtype=float) tc[:] = float("nan") # Process by domain @@ -433,13 +434,16 @@ def sample_total_columns(self, dat, loc, fields_list): # Coordinates to process idt = idd[np.nonzero(loc["id_t"][idd] == time_id)[0]] # Get tracer ensemble profiles - profiles = self._read_and_intrp_v(loc, fields_list, time_id, idt) + profiles = self._read_and_intrp_v(loc, fields_list, time_id, + idt) # List, len=len(fields_list), shape of each: (len(idt),nz) # Get pressure axis: #paxis = self.read_and_intrp(wh_names, id_ts, frac_t, id_xy, "P_HYD")/1e2 # Pa -> hPa - psurf = self._read_and_intrp_v(loc, ["PSFC"], time_id, idt)[0]/1.e2 # Pa -> hPa + psurf = self._read_and_intrp_v(loc, ["PSFC"], time_id, + idt)[0] / 1.e2 # Pa -> hPa # Shape: (len(idt),) - ptop = float(self.namelist["domains"]["p_top_requested"])/1.e2 + ptop = float( + self.namelist["domains"]["p_top_requested"]) / 1.e2 # Shape: (len(idt),) znw = self._read_and_intrp_v(loc, ["ZNW"], time_id, idt)[0] #Shape:(len(idt),nz) @@ -449,7 +453,8 @@ def sample_total_columns(self, dat, loc, fields_list): for nidt in range(len(idt)): nobs = idt[nidt] # Construct model pressure layer boundaries - pb_mod = self.get_pressure_boundaries_znw(znw[nidt, :], psurf[nidt], ptop) + pb_mod = self.get_pressure_boundaries_znw( + znw[nidt, :], psurf[nidt], ptop) if (np.diff(pb_mod) >= 0).any(): msg = ("Model pressure boundaries for observation %d " + \ @@ -464,11 +469,13 @@ def sample_total_columns(self, dat, loc, fields_list): # but with an averaging kernel: # Use wrf's surface and top pressure nlayers = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) + pb_ret = np.linspace(psurf[nidt], ptop, + nlayers + 1) else: nlayers = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) - # Below commented out by David + pb_ret = np.linspace(psurf[nidt], ptop, + nlayers + 1) + # Below commented out by David # Because somehow doesn't work #pb_ret = self.get_pressure_boundaries_paxis( # dat["pressure_levels"][nobs], @@ -487,37 +494,43 @@ def sample_total_columns(self, dat, loc, fields_list): msg = ("Retrieval pressure boundaries for " + \ "observation %d are not monotonically " + \ "decreasing! Investigate.") % nobs - print('pb_ret[:]: %s, np.diff(pb_ret): %s' %(pb_ret[:], np.diff(pb_ret))) + print('pb_ret[:]: %s, np.diff(pb_ret): %s' % + (pb_ret[:], np.diff(pb_ret))) raise ValueError(msg) # Get vertical integration coefficients (i.e. to # "interpolate" from model to retrieval grid) - coef_matrix = self.get_int_coefs(pb_ret, pb_mod, dat["level_def"][nobs]) + coef_matrix = self.get_int_coefs(pb_ret, pb_mod, + dat["level_def"][nobs]) # Model retrieval with averaging kernel and prior profile if "pressure_weighting_function" in list(dat.keys()): pwf = dat["pressure_weighting_function"][nobs] - if (not "pressure_weighting_function" in list(dat.keys())) or np.any(np.isnan(pwf)): + if (not "pressure_weighting_function" in list( + dat.keys())) or np.any(np.isnan(pwf)): # Construct pressure weighting function from # pressure boundaries - pwf = self.get_pressure_weighting_function(pb_ret, rule="simple") - + pwf = self.get_pressure_weighting_function( + pb_ret, rule="simple") + # Compute pressure-weighted averaging kernel - avpw = pwf*dat["averaging_kernel"][nobs] + avpw = pwf * dat["averaging_kernel"][nobs] # Get prior prior_col = dat["prior"][nobs] prior_profile = dat["prior_profile"][nobs] - if np.isnan(prior_col): # compute prior + if np.isnan(prior_col): # compute prior prior_col = np.dot(pwf, prior_profile) # Compute total columns for nf in range(len(fields_list)): # Integrate model profile - profile_intrp = np.matmul(coef_matrix, profiles[nf][nidt, :]) + profile_intrp = np.matmul(coef_matrix, + profiles[nf][nidt, :]) # Model retrieval - tc[nobs, nf] = prior_col + np.dot(avpw, profile_intrp - prior_profile) + tc[nobs, nf] = prior_col + np.dot( + avpw, profile_intrp - prior_profile) # Test phase: save pb_ret, pb_mod, coef_matrix, # one profile for manual checking @@ -534,21 +547,22 @@ def sample_total_columns(self, dat, loc, fields_list): # Average over footprint if self.settings["footprint_samples_dim"] > 1: indices = utilities.get_index_groups(dat["sounding_id"]) - + # Make sure that this is correct: i know the number of indices lens = [len(group) for group in list(indices.values())] correct_len = self.settings["footprint_samples_dim"]**2 if np.any([len_ != correct_len for len_ in set(lens)]): - raise ValueError("Not all footprints have %d samples" %correct_len) + raise ValueError("Not all footprints have %d samples" % + correct_len) # Ok, paranoid mode, also confirm that the indices are what I # think they are: consecutive numbers ranges = [np.ptp(group) for group in list(indices.values())] if np.any([ptp != correct_len for ptp in set(ranges)]): raise ValueError("Not all footprints have consecutive samples") - + tc_original = copy.deepcopy(tc) tc = utilities.apply_by_group(np.average, tc_original, indices) - + return tc ### David: Original function from ctdas-wrf ### @@ -585,18 +599,21 @@ def _read_and_intrp_v(loc, fields_list, time_id, idp): # Check we were really called with observations for just one domain domains = set(loc["domain"][idp]) if len(domains) > 1: - raise ValueError("I can only operate on idp with identical domains.") + raise ValueError( + "I can only operate on idp with identical domains.") dom = domains.pop() # Select input files - id_file0 = bisect.bisect_right(loc["file_start_time_indices"][dom], time_id) - 1 - id_file1 = bisect.bisect_right(loc["file_start_time_indices"][dom], time_id+1) - 1 + id_file0 = bisect.bisect_right(loc["file_start_time_indices"][dom], + time_id) - 1 + id_file1 = bisect.bisect_right(loc["file_start_time_indices"][dom], + time_id + 1) - 1 if id_file0 < 0 or id_file1 < 0: raise ValueError("This shouldn't happen.") # Get time id in file id_t_file0 = time_id - loc["file_start_time_indices"][dom][id_file0] - id_t_file1 = time_id+1 - loc["file_start_time_indices"][dom][id_file1] + id_t_file1 = time_id + 1 - loc["file_start_time_indices"][dom][id_file1] # Open files nc0 = nc.Dataset(loc["files"][dom][id_file0], "r") @@ -623,7 +640,8 @@ def _read_and_intrp_v(loc, fields_list, time_id, idp): var0 = field0[0, :, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] var1 = field1[0, :, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] # Repeat frac_t for profile size - frac_t_ = np.array(loc["frac_t"][idp]).reshape((len(idp), 1)).repeat(var0.shape[1], 1) + frac_t_ = np.array(loc["frac_t"][idp]).reshape( + (len(idp), 1)).repeat(var0.shape[1], 1) elif len(field0.shape) == 3: # var0 will have shape (len(idp),) var0 = field0[0, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] @@ -633,14 +651,16 @@ def _read_and_intrp_v(loc, fields_list, time_id, idp): # var0 will have shape (len(idp),len(profile)) # This is for ZNW, which is saved as (time_coordinate, # vertical_coordinate) - var0 = field0[[0]*len(idp), :] - var1 = field1[[0]*len(idp), :] - frac_t_ = np.array(loc["frac_t"][idp]).reshape((len(idp), 1)).repeat(var0.shape[1], 1) + var0 = field0[[0] * len(idp), :] + var1 = field1[[0] * len(idp), :] + frac_t_ = np.array(loc["frac_t"][idp]).reshape( + (len(idp), 1)).repeat(var0.shape[1], 1) else: - raise ValueError("Can't deal with field with %d dimensions." % len(field0.shape)) + raise ValueError("Can't deal with field with %d dimensions." % + len(field0.shape)) # Interpolate in time - var_intrp_l.append(var0*frac_t_ + var1*(1. - frac_t_)) + var_intrp_l.append(var0 * frac_t_ + var1 * (1. - frac_t_)) nc0.close() nc1.close() @@ -657,27 +677,30 @@ def read_sampling_coords(sampling_coords_file, id0=None, id1=None): if id1 is None: id1 = len(ncf.dimensions['soundings']) - dat = dict( - sounding_id=np.array(ncf.variables["sounding_id"][id0:id1]), - date=ncf.variables["date"][id0:id1], - latitude=np.array(ncf.variables["latitude"][id0:id1]), - longitude=np.array(ncf.variables["longitude"][id0:id1]), - latc_0=np.array(ncf.variables["latc_0"][id0:id1]), - latc_1=np.array(ncf.variables["latc_1"][id0:id1]), - latc_2=np.array(ncf.variables["latc_2"][id0:id1]), - latc_3=np.array(ncf.variables["latc_3"][id0:id1]), - lonc_0=np.array(ncf.variables["lonc_0"][id0:id1]), - lonc_1=np.array(ncf.variables["lonc_1"][id0:id1]), - lonc_2=np.array(ncf.variables["lonc_2"][id0:id1]), - lonc_3=np.array(ncf.variables["lonc_3"][id0:id1]), - prior=np.array(ncf.variables["prior"][id0:id1]), - prior_profile=np.array(ncf.variables["prior_profile"][id0:id1,]), - averaging_kernel=np.array(ncf.variables["averaging_kernel"][id0:id1]), - pressure_levels=np.array(ncf.variables["pressure_levels"][id0:id1]), - pressure_weighting_function=np.array(ncf.variables["pressure_weighting_function"][id0:id1]), - level_def=ncf.variables["level_def"][id0:id1], - psurf=np.array(ncf.variables["psurf"][id0:id1]) - ) + dat = dict(sounding_id=np.array(ncf.variables["sounding_id"][id0:id1]), + date=ncf.variables["date"][id0:id1], + latitude=np.array(ncf.variables["latitude"][id0:id1]), + longitude=np.array(ncf.variables["longitude"][id0:id1]), + latc_0=np.array(ncf.variables["latc_0"][id0:id1]), + latc_1=np.array(ncf.variables["latc_1"][id0:id1]), + latc_2=np.array(ncf.variables["latc_2"][id0:id1]), + latc_3=np.array(ncf.variables["latc_3"][id0:id1]), + lonc_0=np.array(ncf.variables["lonc_0"][id0:id1]), + lonc_1=np.array(ncf.variables["lonc_1"][id0:id1]), + lonc_2=np.array(ncf.variables["lonc_2"][id0:id1]), + lonc_3=np.array(ncf.variables["lonc_3"][id0:id1]), + prior=np.array(ncf.variables["prior"][id0:id1]), + prior_profile=np.array(ncf.variables["prior_profile"][ + id0:id1, + ]), + averaging_kernel=np.array( + ncf.variables["averaging_kernel"][id0:id1]), + pressure_levels=np.array( + ncf.variables["pressure_levels"][id0:id1]), + pressure_weighting_function=np.array( + ncf.variables["pressure_weighting_function"][id0:id1]), + level_def=ncf.variables["level_def"][id0:id1], + psurf=np.array(ncf.variables["psurf"][id0:id1])) ncf.close() @@ -698,7 +721,7 @@ def write_simulated_columns(obs_id, simulated, nmembers, outfile): f = io.CT_CDF(outfile, method="create") dimid = f.createDimension("sounding_id", size=None) - dimid = ("sounding_id",) + dimid = ("sounding_id", ) savedict = io.std_savedict.copy() savedict["name"] = "sounding_id" savedict["dtype"] = "int64" @@ -710,7 +733,7 @@ def write_simulated_columns(obs_id, simulated, nmembers, outfile): f.add_data(savedict, nsets=0) dimmember = f.createDimension("nmembers", size=nmembers) - dimmember = ("nmembers",) + dimmember = ("nmembers", ) savedict = io.std_savedict.copy() savedict["name"] = "column_modeled" savedict["dtype"] = "float" @@ -730,7 +753,7 @@ def save_file_with_timestamp(file_path, out_dir, suffix=""): new_name = os.path.basename(file_path) + suffix + nowstamp new_path = os.path.join(out_dir, new_name) shutil.copy2(file_path, new_path) - + ################################################### # Here are some adaptations written by David Ho @@ -750,20 +773,18 @@ def get_icon_filenames(self, glob_pattern): files = np.sort(files).tolist() return files - @staticmethod def times_in_icon_file(ds_icon): """ Returns the times in netCDF4.Dataset ncf as datetime object """ - times_nc = pd.to_datetime(ds_icon["time"].values, format='date_format') + times_nc = pd.to_datetime(ds_icon["time"].values, format='date_format') #times_dtm = pd.to_datetime(ds_icon["time"].values, format='date_format') times_str = str(times_nc.strftime('%Y-%m-%d_%H:%M:%S')[0]) times_dtm = dt.datetime.strptime(times_str, "%Y-%m-%d_%H:%M:%S") - + return times_dtm - - + def icon_times(self, file_list): """Read all times in a list of icon files @@ -775,21 +796,24 @@ def icon_times(self, file_list): #times = [] times = list() - start_indices = np.ndarray( (len(file_list), ), int ) - for file in range( len(file_list) ): - ds = xr.open_dataset( file_list[file] ) + start_indices = np.ndarray((len(file_list), ), int) + for file in range(len(file_list)): + ds = xr.open_dataset(file_list[file]) times_this = self.times_in_icon_file(ds) start_indices[file] = len(times) #times += times_this times.append(times_this) #ncf.close() - + return times, start_indices - + ### David: Too slow, no longer needed ### ### To be deleted ### @staticmethod - def fetch_weight_and_neighbor_cells_Serial(gridinfo, latitudes_array, longitudes_array, z_info=None): + def fetch_weight_and_neighbor_cells_Serial(gridinfo, + latitudes_array, + longitudes_array, + z_info=None): """ Provide Grid info of your ICON grid, see icon_sampler. Given lat/lon, calculates the distances then: @@ -808,34 +832,35 @@ def fetch_weight_and_neighbor_cells_Serial(gridinfo, latitudes_array, longitudes """ # Libraries for this function: from math import sin, cos, sqrt, atan2, radians - + # Initialize - nn_sel_list = np.zeros( (len(latitudes_array), gridinfo.nn) ).astype(int) # indexes must be integers - u_list = np.zeros( (len(latitudes_array), gridinfo.nn) ) - - + nn_sel_list = np.zeros( + (len(latitudes_array), + gridinfo.nn)).astype(int) # indexes must be integers + u_list = np.zeros((len(latitudes_array), gridinfo.nn)) + # Loop over lat/lon array to collect. #### This loop takes too long, needs to parallelize!!! - for index in np.arange( len(latitudes_array) ): + for index in np.arange(len(latitudes_array)): # For debugging... #print('Calculating index: %s' %index) - - latitudes = latitudes_array[index] + + latitudes = latitudes_array[index] longitudes = longitudes_array[index] - + # For debugging... #print('Lat: %s, Lon: %s' %(latitudes, longitudes)) # Initialize: - nn_sel = np.zeros(gridinfo.nn) # Index of neighbor cells - u = np.zeros(gridinfo.nn) # Weights for neighbor cells + nn_sel = np.zeros(gridinfo.nn) # Index of neighbor cells + u = np.zeros(gridinfo.nn) # Weights for neighbor cells - R = 6373.0 # approximate radius of earth in km + R = 6373.0 # approximate radius of earth in km # This step is used for filtering obs outside of domain. # However, in the satellite pre-processing step, we will make sure all obs are in the domain! # vvv Therefore, skipped... vvv - + #if (radians(longitudes)np.nanmax(gridinfo.clon)): # u[:] = np.nan # return np.zeros((gridinfo.nn)), np.zeros((gridinfo.nn)).astype(int), np.zeros((gridinfo.nn)).astype(int), nn_sel[:], u[:] @@ -850,7 +875,7 @@ def fetch_weight_and_neighbor_cells_Serial(gridinfo, latitudes_array, longitudes #% """FIND "N" CLOSEST CENTERS""" - distances = np.zeros( (len(gridinfo.clon))) + distances = np.zeros((len(gridinfo.clon))) for icell in np.arange(len(gridinfo.clon)): lat2 = gridinfo.clat[icell] lon2 = gridinfo.clon[icell] @@ -859,27 +884,29 @@ def fetch_weight_and_neighbor_cells_Serial(gridinfo, latitudes_array, longitudes a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2 c = 2 * atan2(sqrt(a), sqrt(1 - a)) distances[icell] = R * c - nn_sel[:] = [x for _, x in sorted(zip(distances,np.arange(len(gridinfo.clon))))][0:gridinfo.nn] - nn_sel = nn_sel.astype(int) + nn_sel[:] = [ + x for _, x in sorted( + zip(distances, np.arange(len(gridinfo.clon)))) + ][0:gridinfo.nn] + nn_sel = nn_sel.astype(int) + + u[:] = [1. / distances[y] for y in nn_sel] - u[:] = [1./distances[y] for y in nn_sel] - nn_sel_list[index] = nn_sel[:] - u_list[index] = u - + u_list[index] = u + # For debugging... #print('Done, added NS:%s and U:%s' %(nn_sel, u[:]) ) - + # End of loop return nn_sel_list, u_list - ### David: Too slow, no longer needed ### ### To be deleted ### @staticmethod def fetch_weight_and_neighbor_cells_Parallel(args): - #def fetch_weight_and_neighbor_cells_Parallel(idx, gridinfo, latitudes, longitudes): + #def fetch_weight_and_neighbor_cells_Parallel(idx, gridinfo, latitudes, longitudes): """ Provide Grid info of your ICON grid, see icon_sampler. Given lat/lon, calculates the distances then: @@ -896,20 +923,21 @@ def fetch_weight_and_neighbor_cells_Parallel(args): - 1D-array containing the nearest neighbor indexes - 1D-array containing the weights for the indexes """ - - idx = args[0] - gridinfo = args[1] - latitudes = args[2] + + idx = args[0] + gridinfo = args[1] + latitudes = args[2] longitudes = args[3] - + # Libraries for this function: from math import sin, cos, sqrt, atan2, radians - + # Initialize: - nn_sel = np.zeros(gridinfo.nn).astype(int) # Index of neighbor cells, # indexes must be integers - u = np.zeros(gridinfo.nn) # Weights for neighbor cells + nn_sel = np.zeros(gridinfo.nn).astype( + int) # Index of neighbor cells, # indexes must be integers + u = np.zeros(gridinfo.nn) # Weights for neighbor cells - R = 6373.0 # approximate radius of earth in km + R = 6373.0 # approximate radius of earth in km #% lat1 = radians(latitudes[idx]) @@ -917,7 +945,7 @@ def fetch_weight_and_neighbor_cells_Parallel(args): #% """FIND "N" CLOSEST CENTERS""" - distances = np.zeros( (len(gridinfo.clon))) + distances = np.zeros((len(gridinfo.clon))) for icell in np.arange(len(gridinfo.clon)): lat2 = gridinfo.clat[icell] lon2 = gridinfo.clon[icell] @@ -926,11 +954,13 @@ def fetch_weight_and_neighbor_cells_Parallel(args): a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2 c = 2 * atan2(sqrt(a), sqrt(1 - a)) distances[icell] = R * c - nn_sel[:] = [x for _, x in sorted(zip(distances,np.arange(len(gridinfo.clon))))][0:gridinfo.nn] - nn_sel = nn_sel.astype(int) + nn_sel[:] = [ + x for _, x in sorted(zip(distances, np.arange(len(gridinfo.clon)))) + ][0:gridinfo.nn] + nn_sel = nn_sel.astype(int) + + u[:] = [1. / distances[y] for y in nn_sel] - u[:] = [1./distances[y] for y in nn_sel] - #return nn_sel[:], u return np.array(nn_sel[:], dtype=int), np.array(u) @@ -946,16 +976,26 @@ def get_divisible_hours_string(datetime_obj, hours=3): # Check if the hour is divisible by N hours if hour % hours == 0: # If divisible, get the current hour and the next hour - current_hour = datetime_obj.replace(minute=0, second=0, microsecond=0) + current_hour = datetime_obj.replace(minute=0, + second=0, + microsecond=0) hour_above = current_hour + timedelta(hours=hours) - return [current_hour.strftime('%Y%m%dT%H'), hour_above.strftime('%Y%m%dT%H')] + return [ + current_hour.strftime('%Y%m%dT%H'), + hour_above.strftime('%Y%m%dT%H') + ] else: # If not divisible, get the hour below and above - hour_below = datetime_obj.replace(hour=hour - (hour % hours), minute=0, second=0, microsecond=0) + hour_below = datetime_obj.replace(hour=hour - (hour % hours), + minute=0, + second=0, + microsecond=0) hour_above = hour_below + timedelta(hours=hours) - return [hour_below.strftime('%Y%m%dT%H'), hour_above.strftime('%Y%m%dT%H')] + return [ + hour_below.strftime('%Y%m%dT%H'), + hour_above.strftime('%Y%m%dT%H') + ] - @staticmethod def _read_and_intrp_v_ICON(loc, fields_list, time_id, idp): """ @@ -988,31 +1028,33 @@ def _read_and_intrp_v_ICON(loc, fields_list, time_id, idp): var_intrp_l = list() # Select input files - id_file0 = bisect.bisect_right(loc["file_start_time_indices"], time_id) - 1 - id_file1 = bisect.bisect_right(loc["file_start_time_indices"], time_id+1) - 1 + id_file0 = bisect.bisect_right(loc["file_start_time_indices"], + time_id) - 1 + id_file1 = bisect.bisect_right(loc["file_start_time_indices"], + time_id + 1) - 1 if id_file0 < 0 or id_file1 < 0: raise ValueError("This shouldn't happen.") # Get time id in file - id_t_file0 = time_id - loc["file_start_time_indices"][id_file0] - id_t_file1 = time_id+1 - loc["file_start_time_indices"][id_file1] + id_t_file0 = time_id - loc["file_start_time_indices"][id_file0] + id_t_file1 = time_id + 1 - loc["file_start_time_indices"][id_file1] # Open files ### NetCDF approach: nc0 = nc.Dataset(loc["files"][id_file0], "r") nc1 = nc.Dataset(loc["files"][id_file1], "r") - + ### Xarray approach: #nc0 = xr.open_dataset(loc["files"][id_file0]) #nc1 = xr.open_dataset(loc["files"][id_file1]) - + # Per field to sample for field in fields_list: # Read input file ### NetCDF approach: - field0 = nc0[ field ][:] - field1 = nc1[ field ][:] - + field0 = nc0[field][:] + field1 = nc1[field][:] + ### Xarray approach: #field0 = nc0[ field ].values #field1 = nc1[ field ].values @@ -1020,10 +1062,10 @@ def _read_and_intrp_v_ICON(loc, fields_list, time_id, idp): if len(field0.shape) == 3: ### For ICON fields that has shape (time, z, cells) # -- First select the nearest neighbours of the fields - - var00 = field0[ 0, :, loc["nn_sel_list"][idp] ] - var01 = field1[ 0, :, loc["nn_sel_list"][idp] ] - + + var00 = field0[0, :, loc["nn_sel_list"][idp]] + var01 = field1[0, :, loc["nn_sel_list"][idp]] + # -- Then interpolate spatially with weights # The sum of the weights per obs location u_sums = np.nansum(loc["weight_list"][idp], axis=1) @@ -1031,8 +1073,12 @@ def _read_and_intrp_v_ICON(loc, fields_list, time_id, idp): # Fancy way of mulitply the weights onto 4 nearest neighbors per obs location. (to be varified) # see: https://numpy.org/doc/stable/reference/generated/numpy.einsum.html # Since the dimension does not match, so here are the tricks to do so... - var0 = ( np.einsum( "ij,ijk->ik", loc["weight_list"][idp], var00 ) / u_sums[:, np.newaxis] ) - var1 = ( np.einsum( "ij,ijk->ik", loc["weight_list"][idp], var01 ) / u_sums[:, np.newaxis] ) + var0 = ( + np.einsum("ij,ijk->ik", loc["weight_list"][idp], var00) / + u_sums[:, np.newaxis]) + var1 = ( + np.einsum("ij,ijk->ik", loc["weight_list"][idp], var01) / + u_sums[:, np.newaxis]) # -- Get the time fractions per obs location frac_t_ = np.array(loc["frac_t"][idp]).reshape((len(idp), 1)) @@ -1040,35 +1086,36 @@ def _read_and_intrp_v_ICON(loc, fields_list, time_id, idp): elif len(field0.shape) == 2: ### For ICON fields that has shape (time, cells), e.g. "pres_sfc" # var0 will have shape (len(idp),len(profile)) - + # -- First select the fields: - var00 = field0[ 0, loc["nn_sel_list"][idp] ] - var01 = field1[ 0, loc["nn_sel_list"][idp] ] - + var00 = field0[0, loc["nn_sel_list"][idp]] + var01 = field1[0, loc["nn_sel_list"][idp]] + # -- Then interpolate in space with weights: # The sum of the weights per obs location u_sums = np.nansum(loc["weight_list"][idp], axis=1) - - var0 = np.nansum( loc["weight_list"][idp] * var00, axis=1 ) / u_sums - var1 = np.nansum( loc["weight_list"][idp] * var01, axis=1 ) / u_sums - - # -- Get the time fractions per obs location + + var0 = np.nansum(loc["weight_list"][idp] * var00, + axis=1) / u_sums + var1 = np.nansum(loc["weight_list"][idp] * var01, + axis=1) / u_sums + + # -- Get the time fractions per obs location frac_t_ = np.array(loc["frac_t"][idp]) - + else: - raise ValueError("Can't deal with field with %d dimensions." % len(field0.shape)) + raise ValueError("Can't deal with field with %d dimensions." % + len(field0.shape)) # Interpolate in time - var_intrp_l.append(var0*frac_t_ + var1*(1. - frac_t_)) + var_intrp_l.append(var0 * frac_t_ + var1 * (1. - frac_t_)) nc0.close() nc1.close() return var_intrp_l - - - #### David: A variation for sampling ICON ### + #### David: A variation for sampling ICON ### def sample_total_columns_ICON(self, dat, loc, fields_list): """ David: @@ -1115,21 +1162,22 @@ def sample_total_columns_ICON(self, dat, loc, fields_list): """ # Initialize output of all tracers - tc = np.ndarray(shape=(len(dat["prior"]), len(fields_list)), dtype=float) + tc = np.ndarray(shape=(len(dat["prior"]), len(fields_list)), + dtype=float) tc[:] = float("nan") - tc_unperturbed = np.ndarray(shape=(len(dat["prior"]), 1), dtype=float) + tc_unperturbed = np.ndarray(shape=(len(dat["prior"]), 1), dtype=float) tc_unperturbed[:] = float("nan") do_CAMS = True # Process by id_t UT = list(set(loc["id_t"][:])) - + #print('Tests, UT: %s' %UT) # print(loc['times']) - + for time_id in UT: # Coordinates to process idt = np.nonzero(loc["id_t"] == time_id)[0] @@ -1138,39 +1186,72 @@ def sample_total_columns_ICON(self, dat, loc, fields_list): din = loc['times'][idt[0]] # print(din) - [hour_below, hour_above ] = self.get_divisible_hours_string(datetime_obj=din) + [hour_below, + hour_above] = self.get_divisible_hours_string(datetime_obj=din) print("oi oi", hour_below, hour_above) if do_CAMS: - CAMS1 = xr.open_dataset(f'{cfg.case_root / "global_inputs" / "CAMS"}/cams_egg4_{{hour_below}}.nc') - CAMS2 = xr.open_dataset(f'{cfg.case_root / "global_inputs" / "CAMS"}/cams_egg4_{{hour_above}}.nc') + CAMS1 = xr.open_dataset( + f'{cfg.case_root / "global_inputs" / "CAMS"}/cams_egg4_{{hour_below}}.nc' + ) + CAMS2 = xr.open_dataset( + f'{cfg.case_root / "global_inputs" / "CAMS"}/cams_egg4_{{hour_above}}.nc' + ) CAMS1["time"] = datetime.strptime(hour_below, "%Y%m%dT%H") CAMS2["time"] = datetime.strptime(hour_above, "%Y%m%dT%H") CAMS = xr.concat([CAMS1, CAMS2], dim="time") - pressure = CAMS.ap.values[:,:,np.newaxis,np.newaxis] + np.einsum('pi,pjk->pijk',CAMS.bp.values, CAMS.Psurf.values) + pressure = CAMS.ap.values[:, :, np.newaxis, + np.newaxis] + np.einsum( + 'pi,pjk->pijk', CAMS.bp.values, + CAMS.Psurf.values) # The following is applicable if we only use joint (CO2,Pres) levels [as needed by, e.g., OCO2] - CAMS["pressure"] = (("time", "level", "latitude", "longitude"), (pressure[:,1:,:,:] + pressure[:,:-1,:,:])*0.5) + CAMS["pressure"] = ( + ("time", "level", "latitude", "longitude"), + (pressure[:, 1:, :, :] + pressure[:, :-1, :, :]) * 0.5) # The following is applicable if we want to use (CO2,Pres_ifc) combinations [note the 'hlevel' dimension] # CAMS["pressure"] = (("time", "hlevel", "latitude", "longitude"), pressure) # Read and get tracer ensemble profiles, and flip them, since ICON start from the model top - m_dry = 28.97 # g/mol for dry air - m_gas = 44.01 # g/mol for CO2 + m_dry = 28.97 # g/mol for dry air + m_gas = 44.01 # g/mol for CO2 to_ppm = 1e6 - qv = self._read_and_intrp_v_ICON(loc, ['qv'], time_id, idt)[0] - + qv = self._read_and_intrp_v_ICON(loc, ['qv'], time_id, idt)[0] + # The unperturbed tracer - BG = np.asarray(self._read_and_intrp_v_ICON(loc, ['TRCO2_BG'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + BG = np.asarray( + self._read_and_intrp_v_ICON( + loc, ['TRCO2_BG'], time_id, + idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm # TRCO2_A = np.asarray(self._read_and_intrp_v_ICON(loc, ['TRCO2_A'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm - try: # In the "PRIOR" simulations I made, the following tracer contains the anthropogenic portion; it doesn't exist otherwise. - TRCO2_A = np.asarray(self._read_and_intrp_v_ICON(loc, ['ANTH'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + try: # In the "PRIOR" simulations I made, the following tracer contains the anthropogenic portion; it doesn't exist otherwise. + TRCO2_A = np.asarray( + self._read_and_intrp_v_ICON( + loc, ['ANTH'], time_id, + idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm except: - TRCO2_A = np.asarray(self._read_and_intrp_v_ICON(loc, ['TRCO2_A'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm - CO2_RA = np.asarray(self._read_and_intrp_v_ICON(loc, ['CO2_RA'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm - CO2_GPP = np.asarray(self._read_and_intrp_v_ICON(loc, ['CO2_GPP'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm - biosource = np.asarray(self._read_and_intrp_v_ICON(loc, ['biosource'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm - biosink = np.asarray(self._read_and_intrp_v_ICON(loc, ['biosink'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + TRCO2_A = np.asarray( + self._read_and_intrp_v_ICON( + loc, ['TRCO2_A'], time_id, + idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm + CO2_RA = np.asarray( + self._read_and_intrp_v_ICON(loc, ['CO2_RA'], time_id, idt)) / ( + 1 - qv) * (m_dry / m_gas) * to_ppm + CO2_GPP = np.asarray( + self._read_and_intrp_v_ICON( + loc, ['CO2_GPP'], time_id, + idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm + biosource = np.asarray( + self._read_and_intrp_v_ICON( + loc, ['biosource'], time_id, + idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm + biosink = np.asarray( + self._read_and_intrp_v_ICON( + loc, ['biosink'], time_id, + idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm # The ensemble tracers - tracers = np.asarray(self._read_and_intrp_v_ICON(loc, fields_list, time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + tracers = np.asarray( + self._read_and_intrp_v_ICON( + loc, fields_list, time_id, + idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm # Correct for the missing biospheric components! tracers = tracers + biosource - biosink @@ -1178,24 +1259,27 @@ def sample_total_columns_ICON(self, dat, loc, fields_list): #profiles = np.fliplr( self._read_and_intrp_v_ICON(loc, fields_list, time_id, idt) ) * (28.97/16.01)*1e6 # mol/kg -> ppm # List, len=len(fields_list), shape of each: (len(idt),nz) - + # Read and get water vapor for wet/dry correction # print(np.asarray(qv).shape, np.asarray(tracers).shape, type(qv), type(tracers)) # Read and get pressure axis: - psurf = self._read_and_intrp_v_ICON(loc, ["pres"], time_id, idt)[0]/1.e2 # Pa -> hPa + psurf = self._read_and_intrp_v_ICON(loc, ["pres"], time_id, + idt)[0] / 1.e2 # Pa -> hPa # Shape: (len(idt),) - - ptop = 50 # David: Since ICON does not have hard coded ptop, assume it is 50 hPa... + + ptop = 50 # David: Since ICON does not have hard coded ptop, assume it is 50 hPa... # Shape: (len(idt),) if not do_CAMS: ptop = 50 if do_CAMS: ptop = 0.01 - + ### David: ZNW was for WRF, for ICON first try getting "pres" or "pres_ifc" - pres = np.fliplr( self._read_and_intrp_v_ICON(loc, ["pres"], time_id, idt)[0] )/1.e2 # Pa -> hPa + pres = np.fliplr( + self._read_and_intrp_v_ICON(loc, ["pres"], time_id, + idt)[0]) / 1.e2 # Pa -> hPa # pres = np.fliplr( self._read_and_intrp_v_ICON(loc, ["pres_ifc"], time_id, idt)[0] )/1.e2 # Pa -> hPa #znw = self._read_and_intrp_v_ICON(loc, ["ZNW"], time_id, idt)[0] #Shape:(len(idt),nz) @@ -1203,29 +1287,30 @@ def sample_total_columns_ICON(self, dat, loc, fields_list): # DONE reading from file. # Here it starts to make sense to loop over individual observations for nidt in range(len(idt)): - + nobs = idt[nidt] - + # Construct model pressure layer boundaries #pb_mod = self.get_pressure_boundaries_znw(znw[nidt, :], psurf[nidt], ptop) - + # numpy.fliplr reverses the order of elements along axis 1 (left/right). - # For a 2-D array, this flips the entries in each row in the left/right direction. + # For a 2-D array, this flips the entries in each row in the left/right direction. # Columns are preserved, but appear in a different order than before. pb_mod = pres[nidt] # Do the CAMS extension if do_CAMS: - CAMS_obs = CAMS.interp(time=loc['times'][nobs], latitude=loc['latitude'][nobs], longitude=loc['longitude'][nobs]) + CAMS_obs = CAMS.interp(time=loc['times'][nobs], + latitude=loc['latitude'][nobs], + longitude=loc['longitude'][nobs]) CAMS_pressures = CAMS_obs.pressure.values CAMS_idx = CAMS_pressures < np.min(pb_mod) pb_mod = np.concatenate((pb_mod, CAMS_pressures[CAMS_idx])) - CAMS_gas = CAMS_obs.CO2.values[CAMS_idx] * 1e6 + CAMS_gas = CAMS_obs.CO2.values[CAMS_idx] * 1e6 # Add a final value onto the column... - pb_mod = np.append(pb_mod,np.min(pb_mod)-1) + pb_mod = np.append(pb_mod, np.min(pb_mod) - 1) - if (np.diff(pb_mod) >= 0).any(): msg = ("Model pressure boundaries for observation %d " + \ "are not monotonically decreasing! Investigate.") % nobs @@ -1241,11 +1326,11 @@ def sample_total_columns_ICON(self, dat, loc, fields_list): # but with an averaging kernel: # Use wrf's surface and top pressure nlayers = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) + pb_ret = np.linspace(psurf[nidt], ptop, nlayers + 1) else: nlayers = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) - # Below commented out by David + pb_ret = np.linspace(psurf[nidt], ptop, nlayers + 1) + # Below commented out by David # Because somehow doesn't work #pb_ret = self.get_pressure_boundaries_paxis( # dat["pressure_levels"][nobs], @@ -1276,55 +1361,64 @@ def sample_total_columns_ICON(self, dat, loc, fields_list): msg = ("Retrieval pressure boundaries for " + \ "observation %d are not monotonically " + \ "decreasing! Investigate.") % nobs - print('pb_ret[:]: %s, np.diff(pb_ret): %s' %(pb_ret[:], np.diff(pb_ret))) + print('pb_ret[:]: %s, np.diff(pb_ret): %s' % + (pb_ret[:], np.diff(pb_ret))) raise ValueError(msg) # Get vertical integration coefficients (i.e. to # "interpolate" from model to retrieval grid) - coef_matrix = self.get_int_coefs(pb_ret, pb_mod, dat["level_def"][nobs]) ### To be verified !! + coef_matrix = self.get_int_coefs( + pb_ret, pb_mod, + dat["level_def"][nobs]) ### To be verified !! # Model retrieval with averaging kernel and prior profile if "pressure_weighting_function" in list(dat.keys()): pwf = dat["pressure_weighting_function"][nobs] - if (not "pressure_weighting_function" in list(dat.keys())) or np.any(np.isnan(pwf)): + if (not "pressure_weighting_function" in list( + dat.keys())) or np.any(np.isnan(pwf)): # Construct pressure weighting function from # pressure boundaries - pwf = self.get_pressure_weighting_function(pb_ret, rule="simple") + pwf = self.get_pressure_weighting_function(pb_ret, + rule="simple") # Compute pressure-weighted averaging kernel - avpw = pwf*dat["averaging_kernel"][nobs] + avpw = pwf * dat["averaging_kernel"][nobs] # Get prior prior_col = dat["prior"][nobs] prior_profile = dat["prior_profile"][nobs] - if np.isnan(prior_col): # compute prior + if np.isnan(prior_col): # compute prior prior_col = np.dot(pwf, prior_profile) # Compute total columns - offset = 0 + offset = 0 for nf in range(len(fields_list)): # Integrate model profile tr_here = np.flip(tracers[nf][nidt, :]) if do_CAMS: tr_here = np.concatenate((tr_here, CAMS_gas)) - profile = ( (tr_here - offset ) ) - profile_intrp = np.matmul( coef_matrix, profile ) ### To be verified !! + profile = ((tr_here - offset)) + profile_intrp = np.matmul(coef_matrix, + profile) ### To be verified !! # Model retrieval # print(prior_profile) # print(profile_intrp) # print(prior_col) - tc[nobs, nf] = prior_col + np.dot(avpw, profile_intrp - prior_profile) + tc[nobs, nf] = prior_col + np.dot( + avpw, profile_intrp - prior_profile) # print(tc[nobs,nf]) tr_here = np.flip(prior_tracers[0][nidt, :]) if do_CAMS: tr_here = np.concatenate((tr_here, CAMS_gas)) - profile = ( (tr_here - offset ) ) - profile_intrp = np.matmul( coef_matrix, profile ) ### To be verified !! - tc_unperturbed[nobs,0] = prior_col + np.dot(avpw, profile_intrp - prior_profile) + profile = ((tr_here - offset)) + profile_intrp = np.matmul(coef_matrix, + profile) ### To be verified !! + tc_unperturbed[nobs, 0] = prior_col + np.dot( + avpw, profile_intrp - prior_profile) return tc, tc_unperturbed - + if __name__ == "__main__": pass diff --git a/cases/icon-art-CTDAS/ctdas_patch/icon_sampler.py b/cases/icon-art-CTDAS/ctdas_patch/icon_sampler.py index a5c4b1b6..8f357878 100755 --- a/cases/icon-art-CTDAS/ctdas_patch/icon_sampler.py +++ b/cases/icon-art-CTDAS/ctdas_patch/icon_sampler.py @@ -32,31 +32,33 @@ # Import some CTDAS tools pd = os.path.pardir -inc_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), - pd, pd, pd) +inc_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), pd, pd, pd) inc_path = os.path.abspath(inc_path) sys.path.append(inc_path) from da.tools.icon.icon_helper import ICON_Helper from da.tools.icon.utilities import utilities import argparse - -########## Parse options +########## Parse options parser = argparse.ArgumentParser() -parser.add_argument("--nproc", type=int, +parser.add_argument("--nproc", + type=int, help="ID of this sampling process (0 ... nprocs-1)") -parser.add_argument("--nprocs", type=int, - help="Number of sampling processes") +parser.add_argument("--nprocs", type=int, help="Number of sampling processes") parser.add_argument("--sampling_coords_file", type=str, help="File with sampling coordinates as created " + \ "by CTDAS column samples object") -parser.add_argument("--run_dir", type=str, +parser.add_argument("--run_dir", + type=str, help="Directory with icon output files") -parser.add_argument("--iconout_prefix", type=str, +parser.add_argument("--iconout_prefix", + type=str, help="Headings of the ICON output files") -parser.add_argument("--icon_grid", type=str, +parser.add_argument("--icon_grid", + type=str, help="Absolute path points to the ICON grid file") -parser.add_argument("--nmembers", type=int, +parser.add_argument("--nmembers", + type=int, help="Number of tracer ensemble members") parser.add_argument("--tracer_optim", type=str, help="Tracer that was optimized (e.g. CO2 for " + \ @@ -64,61 +66,66 @@ parser.add_argument("--outfile_prefix", type=str, help="One process: output file. More processes: " + \ "output file is ..slice") -parser.add_argument("--footprint_samples_dim", type=int, +parser.add_argument("--footprint_samples_dim", + type=int, help="Sample column footprint at n x n points") -args = parser.parse_args() +args = parser.parse_args() settings = copy.deepcopy(vars(args)) # Start (stupid) logging - should be updated wd = os.getcwd() try: os.makedirs("log") -except OSError: # Case when directory already exists. Will look nicer in python 3... +except OSError: # Case when directory already exists. Will look nicer in python 3... pass -logfile = os.path.join(wd, "log/iconout_sampler." + str(settings['nproc']) + ".log") +logfile = os.path.join( + wd, "log/iconout_sampler." + str(settings['nproc']) + ".log") os.system("touch " + logfile) os.system("rm " + logfile) -os.system("echo 'Process " + str(settings['nproc']) + " of " + str(settings['nprocs']) + ": start' >> " + logfile) +os.system("echo 'Process " + str(settings['nproc']) + " of " + + str(settings['nprocs']) + ": start' >> " + logfile) os.system("date >> " + logfile) - # David: could be helpful for validate arguments for icon sampling ########## Initialize iconhelper iconhelper = ICON_Helper(settings) -iconhelper.validate_settings(['sampling_coords_file', - 'run_dir', - 'iconout_prefix', - 'icon_grid', - 'nproc', - 'nprocs', - 'nmembers', # special case 0: sample 'tracer_optim' - 'tracer_optim', - 'outfile_prefix', - 'footprint_samples_dim']) +iconhelper.validate_settings([ + 'sampling_coords_file', + 'run_dir', + 'iconout_prefix', + 'icon_grid', + 'nproc', + 'nprocs', + 'nmembers', # special case 0: sample 'tracer_optim' + 'tracer_optim', + 'outfile_prefix', + 'footprint_samples_dim' +]) cwd = os.getcwd() os.chdir(iconhelper.settings['run_dir']) - # ########## Figure out which samples to process # # Get number of samples ncf = nc.Dataset(settings['sampling_coords_file'], "r") nsamples = len(ncf.dimensions['soundings']) ncf.close() -id0, id1 = utilities.get_slicing_ids(nsamples, settings['nproc'], settings['nprocs']) +id0, id1 = utilities.get_slicing_ids(nsamples, settings['nproc'], + settings['nprocs']) os.system("echo 'id0=" + str(id0) + "' >> " + logfile) os.system("echo 'id1=" + str(id1) + "' >> " + logfile) # ########## Read samples from coord file -dat = iconhelper.read_sampling_coords(settings['sampling_coords_file'], id0, id1) - -os.system("echo 'Data read, len=" + str(len(dat['sounding_id'])) + "' >> " + logfile) +dat = iconhelper.read_sampling_coords(settings['sampling_coords_file'], id0, + id1) +os.system("echo 'Data read, len=" + str(len(dat['sounding_id'])) + "' >> " + + logfile) ########## Locate samples in ICON domains @@ -130,8 +137,10 @@ member_names = [settings['tracer_optim']] nmembers = 1 else: - member_names = [settings['tracer_optim'] + "-%03d" % nm for nm in range(1, nmembers+1)] # In ICON, ensemble member starts with XXX-001 - + member_names = [ + settings['tracer_optim'] + "-%03d" % nm + for nm in range(1, nmembers + 1) + ] # In ICON, ensemble member starts with XXX-001 #### Here gets the indexes of neighboring cells and the weights #### Choose number of neighbours, recommend 4 as done in "cdo remapdis" @@ -151,25 +160,27 @@ # Generate BallTree test_points = np.column_stack([clat, clon]) -tree = BallTree(test_points, metric = 'haversine') +tree = BallTree(test_points, metric='haversine') -lat_q = dat['latitude'] -lon_q = dat['longitude'] +lat_q = dat['latitude'] +lon_q = dat['longitude'] # Query BallTree -(d,i) = tree.query(np.column_stack([np.deg2rad(lat_q), np.deg2rad(lon_q)]), k=nneighb, return_distance=True) +(d, i) = tree.query(np.column_stack([np.deg2rad(lat_q), + np.deg2rad(lon_q)]), + k=nneighb, + return_distance=True) -R = 6373.0 # approximate radius of earth in km +R = 6373.0 # approximate radius of earth in km -weight_list = 1./(d*R) +weight_list = 1. / (d * R) nn_sel_list = i - ######### Locate in time: Which file, time index, and temporal interpolation # factor. # MAYBE make this a function. See which quantities I need later. # -- Initialize -id_t = np.zeros_like(dat['latitude'], int) +id_t = np.zeros_like(dat['latitude'], int) frac_t = np.ndarray(id_t.shape, float) frac_t[:] = float("nan") @@ -179,14 +190,13 @@ iconout_times = dict() iconout_start_time_ids = dict() - # -- Get full time vector iconout_prefix = settings['iconout_prefix'] -iconout_files = iconhelper.get_icon_filenames(iconout_prefix + "*") +iconout_files = iconhelper.get_icon_filenames(iconout_prefix + "*") iconout_times, iconout_start_time_ids = iconhelper.icon_times(iconout_files) # time id -for idx in range( len(dat['latitude']) ): +for idx in range(len(dat['latitude'])): # Look where it sorts in tmp = [i for i in range( len(iconout_times) -1 ) @@ -197,44 +207,46 @@ if len(tmp) == 1: id_t[idx] = tmp[0] time0 = iconout_times[id_t[idx]] - time1 = iconout_times[id_t[idx]+1] - frac_t[idx] = (time1 - dat['time'][idx]).total_seconds() / (time1 - time0).total_seconds() + time1 = iconout_times[id_t[idx] + 1] + frac_t[idx] = (time1 - dat['time'][idx]).total_seconds() / ( + time1 - time0).total_seconds() - else: # len must be 0 in this case + else: # len must be 0 in this case if len(tmp) > 1:\ raise ValueError("wat") - + if dat['time'][idx] == iconout_times[-1]: # For debugging - print('check dat[time]: %s' %(dat['time'][idx])) - id_t[idx] = len(iconout_times)-1 + print('check dat[time]: %s' % (dat['time'][idx])) + id_t[idx] = len(iconout_times) - 1 frac_t[idx] = 1 - + else: - msg = "Sample %d, sounding_id %s: outside of simulated time."%(idx, dat['sounding_id'][idx]) + msg = "Sample %d, sounding_id %s: outside of simulated time." % ( + idx, dat['sounding_id'][idx]) raise ValueError(msg) - # -- Create dictionary for column sampling: -loc_input = dict(nn_sel_list = nn_sel_list, - weight_list = weight_list, - id_t = id_t, - frac_t = frac_t, - files = iconout_files, - file_start_time_indices = iconout_start_time_ids, - times = dat['time'][:], +loc_input = dict(nn_sel_list=nn_sel_list, + weight_list=weight_list, + id_t=id_t, + frac_t=frac_t, + files=iconout_files, + file_start_time_indices=iconout_start_time_ids, + times=dat['time'][:], latitude=lat_q, longitude=lon_q) - # -- Begin Sampling -ens_sim, prior = iconhelper.sample_total_columns_ICON(dat, loc_input, member_names) +ens_sim, prior = iconhelper.sample_total_columns_ICON(dat, loc_input, + member_names) # -- Write results to file obs_ids = dat['sounding_id'] # Remove simulations that are nan (=not in domain) if ens_sim.shape[0] > 0: - valid = np.apply_along_axis(lambda arr: not np.any(np.isnan(arr)), 1, ens_sim) + valid = np.apply_along_axis(lambda arr: not np.any(np.isnan(arr)), 1, + ens_sim) obs_ids_write = obs_ids[valid] ens_sim_write = ens_sim[valid, :] prior_sim_write = prior[valid, :] @@ -249,20 +261,23 @@ # Create output files with the appendix "..slice" # Format so that they can later be easily sorted. len_nproc = int(np.floor(np.log10(settings['nprocs']))) + 1 - outfile = settings['outfile_prefix'] + (".%0" + str(len_nproc) + "d.slice") % settings['nproc'] + outfile = settings['outfile_prefix'] + (".%0" + str(len_nproc) + + "d.slice") % settings['nproc'] -os.system("echo 'Writing output file '" + os.path.join(iconhelper.settings['run_dir'], outfile) + " >> " + logfile) +os.system("echo 'Writing output file '" + + os.path.join(iconhelper.settings['run_dir'], outfile) + " >> " + + logfile) ### Write -iconhelper.write_simulated_columns( obs_id=obs_ids_write, - simulated=ens_sim_write, - nmembers=nmembers, - outfile=outfile ) - -iconhelper.write_simulated_columns( obs_id=obs_ids_write, - simulated=prior_sim_write, - nmembers=1, - outfile=outfile+'_prior.nc' ) +iconhelper.write_simulated_columns(obs_id=obs_ids_write, + simulated=ens_sim_write, + nmembers=nmembers, + outfile=outfile) + +iconhelper.write_simulated_columns(obs_id=obs_ids_write, + simulated=prior_sim_write, + nmembers=1, + outfile=outfile + '_prior.nc') os.chdir(cwd) diff --git a/cases/icon-art-CTDAS/ctdas_patch/initexit_cteco2.py b/cases/icon-art-CTDAS/ctdas_patch/initexit_cteco2.py index f677b091..884aa76e 100755 --- a/cases/icon-art-CTDAS/ctdas_patch/initexit_cteco2.py +++ b/cases/icon-art-CTDAS/ctdas_patch/initexit_cteco2.py @@ -12,7 +12,6 @@ program. If not, see .""" #!/usr/bin/env python # da_initexit.py - """ .. module:: initexit .. moduleauthor:: Wouter Peters @@ -81,18 +80,11 @@ from da.tools.general import create_dirs, to_datetime, advance_time needed_da_items = [ - 'time.start', - 'time.finish', - 'time.nlag', - 'time.cycle', - 'dir.da_run', - 'da.resources.ncycles_per_job', - 'da.resources.ntasks', - 'da.resources.ntime', - 'da.system', - 'da.system.rc', - 'da.obsoperator', - 'da.optimizer.nmembers'] + 'time.start', 'time.finish', 'time.nlag', 'time.cycle', 'dir.da_run', + 'da.resources.ncycles_per_job', 'da.resources.ntasks', + 'da.resources.ntime', 'da.system', 'da.system.rc', 'da.obsoperator', + 'da.optimizer.nmembers' +] # only needed in an earlier implemented where each substep was a separate job # validprocesses = ['start','done','samplestate','advance','invert'] @@ -102,7 +94,7 @@ class CycleControl(dict): """ This object controls the CTDAS system flow and functionality. """ - + def __init__(self, opts=[], args={{}}): """ The CycleControl object is instantiated with a set of options and arguments. @@ -126,10 +118,11 @@ def __init__(self, opts=[], args={{}}): self['da.crash.recover'] = '-r' in opts self['transition'] = '-t' in opts self['verbose'] = '-v' in opts - self.dasystem = None # to be filled later - self.restart_filelist = [] # List of files needed for restart, to be extended later - self.output_filelist = [] # List of files needed for output, to be extended later - + self.dasystem = None # to be filled later + self.restart_filelist = [ + ] # List of files needed for restart, to be extended later + self.output_filelist = [ + ] # List of files needed for output, to be extended later def load_rc(self, rcfilename): """ @@ -141,7 +134,6 @@ def load_rc(self, rcfilename): self[k] = v logging.info('DA Cycle rc-file (%s) loaded successfully' % rcfilename) - def validate_rc(self): """ @@ -154,18 +146,29 @@ def validate_rc(self): self[k] = True if v in ['False', 'false', 'f', 'F', 'n', 'no']: self[k] = False - if 'date' in k : + if 'date' in k: self[k] = to_datetime(v) - if k in ['time.start', 'time.end', 'time.finish', 'da.restart.tstamp']: + if k in [ + 'time.start', 'time.end', 'time.finish', + 'da.restart.tstamp' + ]: self[k] = to_datetime(v) for key in needed_da_items: if key not in self: msg = 'Missing a required value in rc-file : %s' % key logging.error(msg) - logging.error('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ') - logging.error('Please note the update on Dec 02 2011 where rc-file names for DaSystem and ') - logging.error('are from now on specified in the main rc-file (see da/rc/da.rc for example)') - logging.error('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ') + logging.error( + '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ' + ) + logging.error( + 'Please note the update on Dec 02 2011 where rc-file names for DaSystem and ' + ) + logging.error( + 'are from now on specified in the main rc-file (see da/rc/da.rc for example)' + ) + logging.error( + '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ' + ) raise IOError(msg) logging.debug('DA Cycle settings have been validated succesfully') @@ -175,14 +178,16 @@ def parse_times(self): """ startdate = self['time.start'] - finaldate = self['time.finish'] + finaldate = self['time.finish'] if finaldate <= startdate: - logging.error('The start date (%s) is not greater than the end date (%s), please revise' % (startdate.strftime('%Y%m%d'), finaldate.strftime('%Y%m%d'))) + logging.error( + 'The start date (%s) is not greater than the end date (%s), please revise' + % (startdate.strftime('%Y%m%d'), finaldate.strftime('%Y%m%d'))) raise ValueError - cyclelength = self['time.cycle'] # get time step + cyclelength = self['time.cycle'] # get time step -# Determine end date + # Determine end date if cyclelength == 'infinite': enddate = finaldate @@ -199,14 +204,18 @@ def parse_times(self): self['time.finish'] = finaldate self['cyclelength'] = dt - logging.info("===============================================================") - logging.info("DA Cycle start date is %s" % startdate.strftime('%Y-%m-%d %H:%M')) - logging.info("DA Cycle end date is %s" % enddate.strftime('%Y-%m-%d %H:%M')) - logging.info("DA Cycle final date is %s" % finaldate.strftime('%Y-%m-%d %H:%M')) + logging.info( + "===============================================================") + logging.info("DA Cycle start date is %s" % + startdate.strftime('%Y-%m-%d %H:%M')) + logging.info("DA Cycle end date is %s" % + enddate.strftime('%Y-%m-%d %H:%M')) + logging.info("DA Cycle final date is %s" % + finaldate.strftime('%Y-%m-%d %H:%M')) logging.info("DA Cycle cycle length is %s" % cyclelength) logging.info("DA Cycle restart is %s" % str(self['time.restart'])) - logging.info("===============================================================") - + logging.info( + "===============================================================") def set_sample_times(self, lag): """ @@ -214,7 +223,7 @@ def set_sample_times(self, lag): the lag. Note that lag falls in the interval [0,nlag-1] """ - # Start from cycle times + # Start from cycle times self['time.sample.start'] = copy.deepcopy(self['time.start']) self['time.sample.end'] = copy.deepcopy(self['time.end']) @@ -223,37 +232,38 @@ def set_sample_times(self, lag): for l in range(lag): self.advance_sample_times() - def advance_sample_times(self): """ Advance sampling start and end time by one cycle interval """ - days = self['cyclelength'].days + days = self['cyclelength'].days - self['time.sample.start'] = advance_time(self['time.sample.start'], days) + self['time.sample.start'] = advance_time(self['time.sample.start'], + days) self['time.sample.end'] = advance_time(self['time.sample.end'], days) - def advance_cycle_times(self): """ Advance cycle start and end time by one cycle interval """ - - days = self['cyclelength'].days + + days = self['cyclelength'].days startdate = advance_time(self['time.start'], days) enddate = advance_time(self['time.end'], days) filtertime = startdate.strftime('%Y%m%d') - self['dir.output'] = os.path.join(self['dir.da_run'], 'output', filtertime) + self['dir.output'] = os.path.join(self['dir.da_run'], 'output', + filtertime) self['time.start'] = startdate self['time.end'] = enddate - def write_random_seed(self): - filename = os.path.join(self['dir.restart'], 'randomseed_%s.pickle' % self['time.start'].strftime('%Y%m%d')) + filename = os.path.join( + self['dir.restart'], + 'randomseed_%s.pickle' % self['time.start'].strftime('%Y%m%d')) f = open(filename, 'wb') seed = np.random.get_state() pickle.dump(seed, f, -1) @@ -261,20 +271,22 @@ def write_random_seed(self): logging.info("Saved the random seed generator values to file") - def read_random_seed(self, first=False): if first: filename = self.dasystem['random.seed.init'] - logging.info("Initialised random seed from: %s"%filename) - else: - filename = os.path.join(self['dir.restart'], 'randomseed_%s.pickle' % self['da.restart.tstamp'].strftime('%Y%m%d')) - logging.info("Retrieved the random seed generator values of last cycle from file") + logging.info("Initialised random seed from: %s" % filename) + else: + filename = os.path.join( + self['dir.restart'], 'randomseed_%s.pickle' % + self['da.restart.tstamp'].strftime('%Y%m%d')) + logging.info( + "Retrieved the random seed generator values of last cycle from file" + ) f = open(filename, 'rb') - seed = pickle.load(f,encoding='latin1') + seed = pickle.load(f, encoding='latin1') np.random.set_state(seed) f.close() - def setup(self): """ This method determines how to proceed with the cycle. Three options are implemented: @@ -307,22 +319,26 @@ def setup(self): * parse_times() * WriteRc('jobfilename') - """ + """ if self['transition']: - logging.info("Transition of filter from previous step with od meteo from 25 to 34 levels") + logging.info( + "Transition of filter from previous step with od meteo from 25 to 34 levels" + ) self.setup_file_structure() strippedname = os.path.split(self['jobrcfilename'])[-1] - self['jobrcfilename'] = os.path.join(self['dir.exec'], strippedname) + self['jobrcfilename'] = os.path.join(self['dir.exec'], + strippedname) self.read_random_seed(False) elif self['time.restart']: logging.info("Restarting filter from previous step") self.setup_file_structure() strippedname = os.path.split(self['jobrcfilename'])[-1] - self['jobrcfilename'] = os.path.join(self['dir.exec'], strippedname) + self['jobrcfilename'] = os.path.join(self['dir.exec'], + strippedname) self.read_random_seed(False) - else: #assume that it is a fresh start, change this condition to more specific if crash recover added + else: #assume that it is a fresh start, change this condition to more specific if crash recover added logging.info("First time step in filter sequence") self.setup_file_structure() @@ -330,19 +346,39 @@ def setup(self): # First strip current leading path from filename strippedname = os.path.split(self['jobrcfilename'])[-1] - self['jobrcfilename'] = os.path.join(self['dir.exec'], strippedname) + self['jobrcfilename'] = os.path.join(self['dir.exec'], + strippedname) if 'extendedregionsfile' in self.dasystem: - shutil.copy(os.path.join(self.dasystem['extendedregionsfile']),os.path.join(self['dir.exec'],'da','analysis','cteco2','copied_regions_extended.nc')) - logging.info('Copied extended regions file to the analysis directory: %s'%os.path.join(self.dasystem['extendedregionsfile'])) - else: - shutil.copy(os.path.join(self['dir.exec'],'da','analysis','cteco2','olson_extended.nc'),os.path.join(self['dir.exec'],'da','analysis','cteco2','copied_regions_extended.nc')) - logging.info('Copied extended regions within the analysis directory: %s'%os.path.join(self['dir.exec'],'da','analysis','cteco2','olson_extended.nc')) - for filename in glob.glob(os.path.join(self['dir.exec'],'da','analysis','cteco2','*.pickle')): - logging.info('Deleting pickle file %s to make sure the correct regions are used'%os.path.split(filename)[1]) - os.remove(filename) - for filename in glob.glob(os.path.join(self['dir.exec'],'*.pickle')): - logging.info('Deleting pickle file %s to make sure the correct regions are used'%os.path.split(filename)[1]) - os.remove(filename) + shutil.copy( + os.path.join(self.dasystem['extendedregionsfile']), + os.path.join(self['dir.exec'], 'da', 'analysis', 'cteco2', + 'copied_regions_extended.nc')) + logging.info( + 'Copied extended regions file to the analysis directory: %s' + % os.path.join(self.dasystem['extendedregionsfile'])) + else: + shutil.copy( + os.path.join(self['dir.exec'], 'da', 'analysis', 'cteco2', + 'olson_extended.nc'), + os.path.join(self['dir.exec'], 'da', 'analysis', 'cteco2', + 'copied_regions_extended.nc')) + logging.info( + 'Copied extended regions within the analysis directory: %s' + % os.path.join(self['dir.exec'], 'da', 'analysis', + 'cteco2', 'olson_extended.nc')) + for filename in glob.glob( + os.path.join(self['dir.exec'], 'da', 'analysis', 'cteco2', + '*.pickle')): + logging.info( + 'Deleting pickle file %s to make sure the correct regions are used' + % os.path.split(filename)[1]) + os.remove(filename) + for filename in glob.glob( + os.path.join(self['dir.exec'], '*.pickle')): + logging.info( + 'Deleting pickle file %s to make sure the correct regions are used' + % os.path.split(filename)[1]) + os.remove(filename) if 'random.seed.init' in self.dasystem: self.read_random_seed(True) @@ -372,13 +408,14 @@ def setup_file_structure(self): """ -# Create the run directory for this DA job, including I/O structure + # Create the run directory for this DA job, including I/O structure filtertime = self['time.start'].strftime('%Y%m%d') self['dir.exec'] = os.path.join(self['dir.da_run'], 'exec') self['dir.input'] = os.path.join(self['dir.da_run'], 'input') - self['dir.output'] = os.path.join(self['dir.da_run'], 'output', filtertime) + self['dir.output'] = os.path.join(self['dir.da_run'], 'output', + filtertime) self['dir.analysis'] = os.path.join(self['dir.da_run'], 'analysis') self['dir.jobs'] = os.path.join(self['dir.da_run'], 'jobs') self['dir.restart'] = os.path.join(self['dir.da_run'], 'restart') @@ -391,8 +428,8 @@ def setup_file_structure(self): create_dirs(os.path.join(self['dir.jobs'])) create_dirs(os.path.join(self['dir.restart'])) - logging.info('Succesfully created the file structure for the assimilation job') - + logging.info( + 'Succesfully created the file structure for the assimilation job') def finalize(self): """ @@ -406,11 +443,13 @@ def finalize(self): * Submit the next cycle """ - self.write_random_seed() - self.write_new_rc_file() - - self.collect_restart_data() # Collect restart data for next cycle into a clean restart/current folder - self.collect_output() # Collect restart data for next cycle into a clean restart/current folder + self.write_random_seed() + self.write_new_rc_file() + + self.collect_restart_data( + ) # Collect restart data for next cycle into a clean restart/current folder + self.collect_output( + ) # Collect restart data for next cycle into a clean restart/current folder self.submit_next_cycle() def collect_output(self): @@ -425,21 +464,19 @@ def collect_output(self): targetdir = os.path.join(self['dir.output']) create_dirs(targetdir) - logging.info("Collecting the required output data") + logging.info("Collecting the required output data") logging.debug(" to directory: %s " % targetdir) for file in set(self.output_filelist): - if os.path.isdir(file): # skip dirs + if os.path.isdir(file): # skip dirs continue - if not os.path.exists(file): # skip dirs + if not os.path.exists(file): # skip dirs logging.warning(" [not found] .... %s " % file) continue logging.debug(" [copy] .... %s " % file) shutil.copy(file, file.replace(os.path.split(file)[0], targetdir)) - - def collect_restart_data(self): """ Collect files needed for the restart of this cycle in case of a crash, or for the continuation of the next cycle. All files needed are written to the restart/current directory. The list of files included is read from the @@ -474,17 +511,18 @@ def collect_restart_data(self): logging.debug(" to directory: %s " % targetdir) for file in set(self.restart_filelist): - if os.path.isdir(file): # skip dirs + if os.path.isdir(file): # skip dirs continue - if not os.path.exists(file): + if not os.path.exists(file): logging.warning(" [not found] .... %s " % file) else: logging.debug(" [copy] .... %s " % file) - shutil.copy(file, file.replace(os.path.split(file)[0], targetdir)) - + shutil.copy(file, + file.replace(os.path.split(file)[0], targetdir)) # + def write_new_rc_file(self): """ Write the rc-file for the next DA cycle. @@ -494,36 +532,36 @@ def write_new_rc_file(self): The resulting rc-file is written to the ``dir.exec`` so that it can be used when resubmitting the next cycle """ - + # We make a copy of the current dacycle object, and modify the start + end dates and restart value new_dacycle = copy.deepcopy(self) new_dacycle['da.restart.tstamp'] = self['time.start'] new_dacycle.advance_cycle_times() new_dacycle['time.restart'] = True - + # Create the name of the rc-file that will hold this new input, and write it #fname = os.path.join(self['dir.exec'], 'da_runtime.rc') # current exec dir holds next rc file - - fname = os.path.join(self['dir.restart'], 'da_runtime_%s.rc' % new_dacycle['time.start'].strftime('%Y%m%d'))#advanced time - + + fname = os.path.join( + self['dir.restart'], 'da_runtime_%s.rc' % + new_dacycle['time.start'].strftime('%Y%m%d')) #advanced time + rc.write(fname, new_dacycle) logging.debug('Wrote new da_runtime.rc (%s) to restart dir' % fname) # The rest is info needed for a system restart, so it modifies the current dacycle object (self) - self['da.restart.fname'] = fname # needed for next job template + self['da.restart.fname'] = fname # needed for next job template #self.restart_filelist.append(fname) # not that needed since it is already written to the restart dir... #logging.debug('Added da_runtime.rc to the restart_filelist for later collection') - def write_rc(self, fname): """ Write RC file after each process to reflect updated info """ rc.write(fname, self) logging.debug('Wrote expanded rc-file (%s)' % fname) - def submit_next_cycle(self): """ @@ -535,45 +573,72 @@ def submit_next_cycle(self): If the end of the cycle series is reached, no new job is submitted. """ - if self['time.end'] < self['time.finish']: # file ID and names - jobid = self['time.end'].strftime('%Y%m%d') + jobid = self['time.end'].strftime('%Y%m%d') targetdir = os.path.join(self['dir.exec']) jobfile = os.path.join(targetdir, 'jb.%s.jb' % jobid) logfile = os.path.join(targetdir, 'jb.%s.log' % jobid) # Template and commands for job - jobparams = {{'jobname':"j.%s" % jobid, 'jobnodes':self['da.resources.ntasks'], 'jobtime': self['da.resources.ntime'], 'logfile': logfile, 'errfile': logfile}} + jobparams = {{ + 'jobname': "j.%s" % jobid, + 'jobnodes': self['da.resources.ntasks'], + 'jobtime': self['da.resources.ntime'], + 'logfile': logfile, + 'errfile': logfile + }} template = self.daplatform.get_job_template(jobparams) - execcommand = os.path.join(self['dir.da_submit'], sys.argv[0]) + execcommand = os.path.join(self['dir.da_submit'], sys.argv[0]) if '-t' in self.opts: - (self.opts).remove('-t') + (self.opts).remove('-t') if 'icycle_in_job' not in os.environ: - logging.info('Environment variable icycle_in_job not found, resubmitting after this cycle') - os.environ['icycle_in_job'] = self['da.resources.ncycles_per_job'] # assume that if no cycle number is set, we should submit the next job by default + logging.info( + 'Environment variable icycle_in_job not found, resubmitting after this cycle' + ) + os.environ['icycle_in_job'] = self[ + 'da.resources.ncycles_per_job'] # assume that if no cycle number is set, we should submit the next job by default else: - logging.info('Environment variable icycle_in_job was found, processing cycle %s of %s in this job'%(os.environ['icycle_in_job'],self['da.resources.ncycles_per_job']) ) + logging.info( + 'Environment variable icycle_in_job was found, processing cycle %s of %s in this job' + % (os.environ['icycle_in_job'], + self['da.resources.ncycles_per_job'])) ncycles = int(self['da.resources.ncycles_per_job']) - for cycle in range(ncycles): - nextjobid = '%s'% ( (self['time.end']+cycle*self['cyclelength']).strftime('%Y%m%d'),) - nextrestartfilename = self['da.restart.fname'].replace(jobid,nextjobid) - nextlogfilename = logfile.replace(jobid,nextjobid) + for cycle in range(ncycles): + nextjobid = '%s' % ( + (self['time.end'] + + cycle * self['cyclelength']).strftime('%Y%m%d'), ) + nextrestartfilename = self['da.restart.fname'].replace( + jobid, nextjobid) + nextlogfilename = logfile.replace(jobid, nextjobid) if self.daplatform.ID == 'WU capegrim': - template += """\nexport icycle_in_job=%d\npython3 %s rc=%s %s >&%s &\n""" % (cycle+1,execcommand, nextrestartfilename, ''.join(self.opts), nextlogfilename,) - else: - template += """\nexport icycle_in_job=%d\npython3 %s rc=%s %s >&%s\n""" % (cycle+1,execcommand, nextrestartfilename, ''.join(self.opts), nextlogfilename,) - - # write and submit + template += """\nexport icycle_in_job=%d\npython3 %s rc=%s %s >&%s &\n""" % ( + cycle + 1, + execcommand, + nextrestartfilename, + ''.join(self.opts), + nextlogfilename, + ) + else: + template += """\nexport icycle_in_job=%d\npython3 %s rc=%s %s >&%s\n""" % ( + cycle + 1, + execcommand, + nextrestartfilename, + ''.join(self.opts), + nextlogfilename, + ) + + # write and submit self.daplatform.write_job(jobfile, template, jobid) if 'da.resources.ncycles_per_job' in self: - do_submit = (int(os.environ['icycle_in_job']) >= int(self['da.resources.ncycles_per_job'])) + do_submit = (int(os.environ['icycle_in_job']) + >= int(self['da.resources.ncycles_per_job'])) else: dosubmit = False - + if do_submit: jobid = self.daplatform.submit_job(jobfile, joblog=logfile) @@ -584,11 +649,14 @@ def submit_next_cycle(self): def start_logger(level=logging.INFO): """ start the logging of messages to screen""" -# start the logging basic configuration by setting up a log file + # start the logging basic configuration by setting up a log file + + logging.basicConfig( + level=level, + format= + ' [%(levelname)-7s] (%(asctime)s) py-%(module)-20s : %(message)s', + datefmt='%Y-%m-%d %H:%M:%S') - logging.basicConfig(level=level, - format=' [%(levelname)-7s] (%(asctime)s) py-%(module)-20s : %(message)s', - datefmt='%Y-%m-%d %H:%M:%S') def parse_options(): """ @@ -606,50 +674,56 @@ def parse_options(): """ -# Parse keywords, the only option accepted so far is the "-h" flag for help + # Parse keywords, the only option accepted so far is the "-h" flag for help opts = [] args = [] - try: + try: opts, args = getopt.gnu_getopt(sys.argv[1:], "-rvt") - except getopt.GetoptError as msg: + except getopt.GetoptError as msg: logging.error('%s' % msg) - sys.exit(2) + sys.exit(2) for options in opts: options = options[0].lower() if options == '-r': - logging.info('-r flag specified on command line: recovering from crash') + logging.info( + '-r flag specified on command line: recovering from crash') if options == '-t': - logging.info('-t flag specified on command line: transition with od from December 2005') + logging.info( + '-t flag specified on command line: transition with od from December 2005' + ) if options == '-v': - logging.info('-v flag specified on command line: extra verbose output') + logging.info( + '-v flag specified on command line: extra verbose output') logging.root.setLevel(logging.DEBUG) - if opts: + if opts: optslist = [item[0] for item in opts] else: optslist = [] + # Parse arguments and return as dictionary arguments = {{}} for item in args: #item=item.lower() -# Catch arguments that are passed not in "key=value" format + # Catch arguments that are passed not in "key=value" format if '=' in item: key, arg = item.split('=') else: - logging.error('%s' % 'Argument passed without description (%s)' % item) + logging.error('%s' % 'Argument passed without description (%s)' % + item) raise getopt.GetoptError(arg) arguments[key] = arg - return optslist, arguments + def validate_opts_args(opts, args): """ Validate the options and arguments passed from the command line before starting the cycle. The validation consists of checking for the presence of an argument "rc", and the existence of @@ -661,7 +735,7 @@ def validate_opts_args(opts, args): logging.error(msg) raise IOError(msg) elif not os.path.exists(args['rc']): - msg = "The specified rc-file (%s) does not exist " % args['rc'] + msg = "The specified rc-file (%s) does not exist " % args['rc'] logging.error(msg) raise IOError(msg) @@ -678,4 +752,3 @@ def validate_opts_args(opts, args): if __name__ == "__main__": pass - diff --git a/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py b/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py index 7f0050a9..9fe73d57 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py +++ b/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py @@ -12,7 +12,6 @@ program. If not, see .""" #!/usr/bin/env python # obs.py - """ .. module:: obs .. moduleauthor:: Wouter Peters @@ -37,6 +36,7 @@ import xarray as xr from multiprocessing import Pool import datetime + sys.path.append(os.getcwd()) sys.path.append('../../') @@ -54,6 +54,7 @@ ################### Begin Class Observations ################### + class ICOSObservations(object): """ The baseclass Observations is a generic object that provides a number of methods required for any type of observations used in @@ -73,7 +74,7 @@ class ICOSObservations(object): :class:`~da.baseclasses.observationoperator.ObservationOperator` object. The values returned after sampling are finally added by :meth:`~da.baseclasses.obs.Observations.add_simulations` - """ + """ def __init__(self): """ @@ -112,11 +113,9 @@ def setup(self, dacycle): self.datalist = [] - def get_samples_type(self): return 'insitu' - def add_observations(self): """ Add actual observation data to the Observations object. This is in a form of an @@ -133,89 +132,131 @@ def add_observations(self): os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE" -########################################################################################################## -# THE FOLLOWING COMMENTED BLOCK IS FOR READING-IN REAL DATA -########################################################################################################## + ########################################################################################################## + # THE FOLLOWING COMMENTED BLOCK IS FOR READING-IN REAL DATA + ########################################################################################################## - mdm_dictionary = { evaluate_dict({k: v for d in cfg.CTDAS["obs"]["ICOS"]["mdm"] for k, v in d.items()}, "c_offset", cfg.CTDAS_obs_ICOS_c_offset) }# Based on the simulated standard deviation of the signal (without background) over a full year. + mdm_dictionary = { + evaluate_dict( + { + k: v + for d in cfg.CTDAS["obs"]["ICOS"]["mdm"] + for k, v in d.items() + }, "c_offset", cfg.CTDAS_obs_ICOS_c_offset) + } # Based on the simulated standard deviation of the signal (without background) over a full year. u_id = 1 - for ncfile in list(glob.glob(os.path.join(self.obspack_dir,f'Extracted_{{self.dacycle["time.sample.stamp"][0:8]}}*.nc'))): + for ncfile in list( + glob.glob( + os.path.join( + self.obspack_dir, + f'Extracted_{{self.dacycle["time.sample.stamp"][0:8]}}*.nc' + ))): if not ncfile.endswith('.nc'): continue logging.info('Found file ', ) infile = os.path.join(self.obspack_dir, ncfile) print("infile = ", infile) - + f = xr.open_dataset(infile) - logging.info('Looking into the file %s...'%(infile)) + logging.info('Looking into the file %s...' % (infile)) - sites_names = np.array([unidecode(x) for x in f.Stations_names.values]) + sites_names = np.array( + [unidecode(x) for x in f.Stations_names.values]) - mountain_hours = ['0' + str(x) for x in np.arange(0,7)] - rest_hours = [str(x) for x in np.arange(12,17)] + mountain_hours = ['0' + str(x) for x in np.arange(0, 7)] + rest_hours = [str(x) for x in np.arange(12, 17)] st_ind = np.arange(len(sites_names)) - - #def caculate_interval_mean_cnc(dates, conc, hr): + #def caculate_interval_mean_cnc(dates, conc, hr): for x in st_ind: station_name = sites_names[x] - if station_name not in mdm_dictionary: continue # Skip stations outside of the domain! - + if station_name not in mdm_dictionary: + continue # Skip stations outside of the domain! + cnc = f.Concentration[x].values - + dates = f.Dates[x].values flag = 1 - mdm_value = mdm_dictionary[station_name] # ERIK: CHANGED FROM constant 10 + mdm_value = mdm_dictionary[ + station_name] # ERIK: CHANGED FROM constant 10 base_height_above_sealevel = f.Stations_masl[x].values - inlet_height = float( station_name.split("_")[-1] ) + inlet_height = float(station_name.split("_")[-1]) lon = f.Lon[x].values lat = f.Lat[x].values species = self.tracer - strategy = 'mountain' if station_name in mountain_stations else 'ground' # 1 for + strategy = 'mountain' if station_name in mountain_stations else 'ground' # 1 for if station_name in mountain_stations: - ind_dt = np.asarray([str(x)[11:13] in mountain_hours for x in f.Dates.values[x]]) #mask of hours taken for mountain sites - hr=0 + ind_dt = np.asarray([ + str(x)[11:13] in mountain_hours + for x in f.Dates.values[x] + ]) #mask of hours taken for mountain sites + hr = 0 else: - ind_dt = np.asarray([str(x)[11:13] in rest_hours for x in f.Dates.values[x]]) #mask of hours taken for the rest of the sites - hr=12 + ind_dt = np.asarray([ + str(x)[11:13] in rest_hours for x in f.Dates.values[x] + ]) #mask of hours taken for the rest of the sites + hr = 12 data = cnc[ind_dt] - times = np.asarray([datetime.datetime.strptime(str(x)[:-13], "%Y-%m-%dT%H:%M") for x in dates[ind_dt]]) - logging.info('Check dates: %s %s'%(self.enddate+timedelta(days=1), self.startdate+timedelta(days=1))) - mask_da_interval = np.logical_and(times<=(self.enddate+timedelta(days=1)), (self.startdate+timedelta(days=1))<=times) + times = np.asarray([ + datetime.datetime.strptime(str(x)[:-13], "%Y-%m-%dT%H:%M") + for x in dates[ind_dt] + ]) + logging.info('Check dates: %s %s' % + (self.enddate + timedelta(days=1), + self.startdate + timedelta(days=1))) + mask_da_interval = np.logical_and( + times <= (self.enddate + timedelta(days=1)), + (self.startdate + timedelta(days=1)) <= times) times = times[mask_da_interval] data = data[mask_da_interval] - if len(times)>0: + if len(times) > 0: for iday in set([ii.day for ii in times]): - ids = [iii for iii,dd in enumerate(times) if dd.day==iday] - value = np.nanmean(np.array([c for i,c in enumerate(data) if times[i].day==iday])) + ids = [ + iii for iii, dd in enumerate(times) + if dd.day == iday + ] + value = np.nanmean( + np.array([ + c for i, c in enumerate(data) + if times[i].day == iday + ])) dict_date = times[ids[0]].replace(hour=hr) if not np.isfinite(value): continue - - self.datalist.append(MoleFractionSample(u_id,dict_date,station_name,value,0.0,0.0,0.0,mdm_value,flag,base_height_above_sealevel,lat,lon,station_name,species,strategy,0.0,station_name,inlet_height,base_height_above_sealevel)) - logging.info('For itime([day]T[hour]) (%iT%i) adding synthetic obs %i at station %s: %5.2e'%(dict_date.day,dict_date.hour,u_id,station_name,value)) + self.datalist.append( + MoleFractionSample(u_id, dict_date, station_name, + value, 0.0, 0.0, 0.0, mdm_value, + flag, + base_height_above_sealevel, lat, + lon, station_name, species, + strategy, 0.0, station_name, + inlet_height, + base_height_above_sealevel)) + + logging.info( + 'For itime([day]T[hour]) (%iT%i) adding synthetic obs %i at station %s: %5.2e' + % (dict_date.day, dict_date.hour, u_id, + station_name, value)) u_id += 1 - - # add_station_data_to_sample(x) - - logging.info("Observations list now holds %d values" % len(self.datalist)) -########################################################################################################## + # add_station_data_to_sample(x) + logging.info("Observations list now holds %d values" % + len(self.datalist)) +########################################################################################################## def add_simulations(self, filename, silent=False): """ Add the simulation data to the Observations object. """ - if not os.path.exists(filename): - msg = "Sample output filename for observations could not be found : %s" % filename + msg = "Sample output filename for observations could not be found : %s" % filename logging.error(msg) logging.error("Did the sampling step succeed?") logging.error("...exiting") @@ -225,7 +266,8 @@ def add_simulations(self, filename, silent=False): ids = ncf.get_variable('obs_num') simulated = ncf.get_variable('flask') ncf.close() - logging.info("Successfully read data from model sample file (%s)" % filename) + logging.info("Successfully read data from model sample file (%s)" % + filename) obs_ids = self.getvalues('id').tolist() ids = list(map(int, ids)) @@ -240,56 +282,64 @@ def add_simulations(self, filename, silent=False): missing_samples.append(idx) if not silent and missing_samples != []: - logging.warning('Model samples were found that did not match any ID in the observation list. Skipping them...') - msg = '%s'%missing_samples ; logging.warning(msg) - - logging.debug("Added %d simulated values to the Data list" % (len(ids) - len(missing_samples))) - logging.info("Added %d simulated values to the Data list" % (len(ids) - len(missing_samples))) + logging.warning( + 'Model samples were found that did not match any ID in the observation list. Skipping them...' + ) + msg = '%s' % missing_samples + logging.warning(msg) + logging.debug("Added %d simulated values to the Data list" % + (len(ids) - len(missing_samples))) + logging.info("Added %d simulated values to the Data list" % + (len(ids) - len(missing_samples))) def add_model_data_mismatch(self, filename): """ Get the model-data mismatch values for this cycle. """ - self.rejection_threshold = 10.0 # 3-sigma cut-off - self.global_R_scaling = 1.0 # no scaling applied + self.rejection_threshold = 10.0 # 3-sigma cut-off + self.global_R_scaling = 1.0 # no scaling applied for obs in self.datalist: # first loop over all available data points to set flags correctly - obs.may_localize = True #False + obs.may_localize = True #False obs.may_reject = False obs.flag = 0 logging.debug("Added Model Data Mismatch to all samples ") - - def write_sample_coords(self,obsinputfile): + def write_sample_coords(self, obsinputfile): """ Write the information needed by the observation operator to a file. Return the filename that was written for later use """ if len(self.datalist) == 0: - logging.debug("No observations found for this time period, nothing written to obs file") + logging.debug( + "No observations found for this time period, nothing written to obs file" + ) else: f = io.CT_CDF(obsinputfile, method='create') - logging.debug('Creating new observations file for ObservationOperator (%s)' % obsinputfile) + logging.debug( + 'Creating new observations file for ObservationOperator (%s)' % + obsinputfile) dimid = f.add_dim('obs', len(self.datalist)) -# dim200char = f.add_dim('string_of200chars', 200) + # dim200char = f.add_dim('string_of200chars', 200) dim50char = f.add_dim('string_of50chars', 50) dim3char = f.add_dim('string_of3chars', 3) dimcalcomp = f.add_dim('calendar_components', 6) data = self.getvalues('id') - savedict = io.std_savedict.copy() + savedict = io.std_savedict.copy() savedict['name'] = "obs_num" savedict['dtype'] = "int" savedict['long_name'] = "Unique_Dataset_observation_index_number" savedict['units'] = "" savedict['dims'] = dimid savedict['values'] = data.tolist() - savedict['comment'] = "Unique index number within this dataset ranging from 0 to UNLIMITED." + savedict[ + 'comment'] = "Unique index number within this dataset ranging from 0 to UNLIMITED." f.add_data(savedict) data = self.getvalues('evn') @@ -317,16 +367,18 @@ def write_sample_coords(self,obsinputfile): savedict['comment'] = "File name of data file." f.add_data(savedict) - data = [[d.year, d.month, d.day, d.hour, d.minute, d.second] for d in self.getvalues('xdate') ] + data = [[d.year, d.month, d.day, d.hour, d.minute, d.second] + for d in self.getvalues('xdate')] - savedict = io.std_savedict.copy() + savedict = io.std_savedict.copy() savedict['dtype'] = "int" savedict['name'] = "date_components" savedict['units'] = "integer components of UTC date/time" savedict['dims'] = dimid + dimcalcomp savedict['values'] = data savedict['missing_value'] = -999 - savedict['comment'] = "Calendar date components as integers. Times and dates are UTC." + savedict[ + 'comment'] = "Calendar date components as integers. Times and dates are UTC." savedict['order'] = "year, month, day, hour, minute, second" f.add_data(savedict) @@ -343,7 +395,7 @@ def write_sample_coords(self,obsinputfile): data = self.getvalues('lon') - savedict = io.std_savedict.copy() + savedict = io.std_savedict.copy() savedict['dtype'] = "float" savedict['name'] = "longitude" savedict['units'] = "degrees_east" @@ -354,7 +406,7 @@ def write_sample_coords(self,obsinputfile): data = self.getvalues('masl') - savedict = io.std_savedict.copy() + savedict = io.std_savedict.copy() savedict['dtype'] = "float" savedict['name'] = "base_height_over_sea_level" savedict['units'] = "meters_above_sea_level" @@ -365,7 +417,7 @@ def write_sample_coords(self,obsinputfile): data = self.getvalues('mag') - savedict = io.std_savedict.copy() + savedict = io.std_savedict.copy() savedict['dtype'] = "float" savedict['name'] = "inlet_height_over_base" savedict['units'] = "meters_above_ground" @@ -376,7 +428,7 @@ def write_sample_coords(self,obsinputfile): data = self.getvalues('samplingstrategy') - savedict = io.std_savedict.copy() + savedict = io.std_savedict.copy() savedict['dtype'] = "char" savedict['name'] = "sampling_strategy" savedict['units'] = "" @@ -396,9 +448,9 @@ def write_sample_coords(self,obsinputfile): savedict['values'] = data.tolist() savedict['comment'] = 'Observations used in optimization' f.add_data(savedict) - + data = self.getvalues('mdm') - + savedict = io.std_savedict.copy() savedict['dtype'] = "float" savedict['name'] = "modeldatamismatch" @@ -406,15 +458,15 @@ def write_sample_coords(self,obsinputfile): savedict['units'] = "[mol mol-1]" savedict['dims'] = dimid savedict['values'] = data.tolist() - savedict['comment'] = 'Standard deviation of mole fractions resulting from model-data mismatch' + savedict[ + 'comment'] = 'Standard deviation of mole fractions resulting from model-data mismatch' f.add_data(savedict) f.close() logging.debug("Successfully wrote data to obs file") - logging.info("Sample input file for obs operator now in place [%s]" % obsinputfile) - - - + logging.info( + "Sample input file for obs operator now in place [%s]" % + obsinputfile) def write_sample_auxiliary(self, auxoutputfile): """ @@ -425,7 +477,7 @@ def write_sample_auxiliary(self, auxoutputfile): def getvalues(self, name, constructor=array): result = constructor([getattr(o, name) for o in self.datalist]) - if isinstance(result, ndarray): + if isinstance(result, ndarray): return result.squeeze() else: return result @@ -435,6 +487,7 @@ def getvalues(self, name, constructor=array): ################### Begin Class MoleFractionSample ################### + class MoleFractionSample(object): """ Holds the data that defines a mole fraction Sample in the data assimilation framework. Sor far, this includes all @@ -443,32 +496,51 @@ class MoleFractionSample(object): """ - def __init__(self, idx, xdate, code='XXX', obs=0.0, simulated=0.0, resid=0.0, hphr=0.0, mdm=0.0, flag=0, height=0.0, lat= -999., lon= -999., evn='0000', species='co2', samplingstrategy=1, sdev=0.0, fromfile='none.nc', height_above_ground=0, height_above_sealevel=0): - self.code = code.strip() # dataset identifier, i.e., co2_lef_tower_insitu_1_99 - self.xdate = xdate # Date of obs - self.obs = obs # Value observed - self.simulated = simulated # Value simulated by model - self.resid = resid # Mole fraction residuals - self.hphr = hphr # Mole fraction prior uncertainty from fluxes and (HPH) and model data mismatch (R) - self.mdm = mdm # Model data mismatch - self.may_localize = True # Whether sample may be localized in optimizer - self.may_reject = True # Whether sample may be rejected if outside threshold - self.flag = flag # Flag - self.height = height # Sample height in masl - self.lat = lat # Sample lat - self.lon = lon # Sample lon - self.id = idx # Obspack ID within distrution (integer), e.g., 82536 - self.evn = evn # Obspack Number within distrution (string), e.g., obspack_co2_1_PROTOTYPE_v0.9.2_2012-07-26_99_82536 - self.sdev = sdev # standard deviation of ensemble - self.masl = height_above_sealevel # Sample is in Meters Above Sea Level - self.mag = height_above_ground # Sample is in Meters Above Ground + def __init__(self, + idx, + xdate, + code='XXX', + obs=0.0, + simulated=0.0, + resid=0.0, + hphr=0.0, + mdm=0.0, + flag=0, + height=0.0, + lat=-999., + lon=-999., + evn='0000', + species='co2', + samplingstrategy=1, + sdev=0.0, + fromfile='none.nc', + height_above_ground=0, + height_above_sealevel=0): + self.code = code.strip( + ) # dataset identifier, i.e., co2_lef_tower_insitu_1_99 + self.xdate = xdate # Date of obs + self.obs = obs # Value observed + self.simulated = simulated # Value simulated by model + self.resid = resid # Mole fraction residuals + self.hphr = hphr # Mole fraction prior uncertainty from fluxes and (HPH) and model data mismatch (R) + self.mdm = mdm # Model data mismatch + self.may_localize = True # Whether sample may be localized in optimizer + self.may_reject = True # Whether sample may be rejected if outside threshold + self.flag = flag # Flag + self.height = height # Sample height in masl + self.lat = lat # Sample lat + self.lon = lon # Sample lon + self.id = idx # Obspack ID within distrution (integer), e.g., 82536 + self.evn = evn # Obspack Number within distrution (string), e.g., obspack_co2_1_PROTOTYPE_v0.9.2_2012-07-26_99_82536 + self.sdev = sdev # standard deviation of ensemble + self.masl = height_above_sealevel # Sample is in Meters Above Sea Level + self.mag = height_above_ground # Sample is in Meters Above Ground self.species = species.strip() self.samplingstrategy = samplingstrategy - self.fromfile = fromfile # netcdf filename inside ObsPack distribution, to write back later - -################### End Class MoleFractionSample ################### + self.fromfile = fromfile # netcdf filename inside ObsPack distribution, to write back later +################### End Class MoleFractionSample ################### ################### Begin Class TotalColumnSample ################### @@ -482,56 +554,61 @@ class TotalColumnSample(object): def __init__(self, idx, codex, xdate, obs=0.0, simulated=0.0, lat=-999., lon=-999., mdm=None, prior=0.0, prior_profile=0.0, av_kernel=0.0, pressure=0.0, \ ##### freum vvvv + pressure_weighting_function=None, ##### freum ^^^^ level_def = "pressure_boundary", psurf = float('nan'), resid=0.0, hphr=0.0, flag=0, species='co2', sdev=0.0, \ ##### freum vvvv + latc_0=None, latc_1=None, latc_2=None, latc_3=None, lonc_0=None, lonc_1=None, lonc_2=None, lonc_3=None \ ##### freum ^^^^ + ): - self.id = idx # Sounding ID - self.code = codex # Retrieval ID - self.xdate = xdate # Date of obs - self.obs = obs # Value observed - self.simulated = simulated # Value simulated by model, fillvalue = -9999 - self.lat = lat # Sample lat - self.lon = lon # Sample lon + self.id = idx # Sounding ID + self.code = codex # Retrieval ID + self.xdate = xdate # Date of obs + self.obs = obs # Value observed + self.simulated = simulated # Value simulated by model, fillvalue = -9999 + self.lat = lat # Sample lat + self.lon = lon # Sample lon ##### freum vvvv - self.latc_0 = latc_0 # Sample latitude corner - self.latc_1 = latc_1 # Sample latitude corner - self.latc_2 = latc_2 # Sample latitude corner - self.latc_3 = latc_3 # Sample latitude corner - self.lonc_0 = lonc_0 # Sample longitude corner - self.lonc_1 = lonc_1 # Sample longitude corner - self.lonc_2 = lonc_2 # Sample longitude corner - self.lonc_3 = lonc_3 # Sample longitude corner + self.latc_0 = latc_0 # Sample latitude corner + self.latc_1 = latc_1 # Sample latitude corner + self.latc_2 = latc_2 # Sample latitude corner + self.latc_3 = latc_3 # Sample latitude corner + self.lonc_0 = lonc_0 # Sample longitude corner + self.lonc_1 = lonc_1 # Sample longitude corner + self.lonc_2 = lonc_2 # Sample longitude corner + self.lonc_3 = lonc_3 # Sample longitude corner ##### freum ^^^^ - self.mdm = mdm # Model data mismatch - self.prior = prior # A priori column value used in retrieval - self.prior_profile = prior_profile # A priori profile used in retrieval - self.av_kernel = av_kernel # Averaging kernel - self.pressure = pressure # Pressure levels of retrieval + self.mdm = mdm # Model data mismatch + self.prior = prior # A priori column value used in retrieval + self.prior_profile = prior_profile # A priori profile used in retrieval + self.av_kernel = av_kernel # Averaging kernel + self.pressure = pressure # Pressure levels of retrieval # freum vvvv - self.pressure_weighting_function = pressure_weighting_function # Pressure weighting function + self.pressure_weighting_function = pressure_weighting_function # Pressure weighting function # freum ^^^^ - self.level_def = level_def # Are prior and averaging kernel defined as layer averages? - self.psurf = psurf # Surface pressure (only needed if level_def is "layer_average") - self.loc_L = int(600) #int(0) # freum 2021-07-13: insert this dummy value so the code runs with the current version of CTDAS. *Should* not affect results if localizetype == "CT2007" as in all my runs. However, replace this file with the standard observation file, obs_column_xco2.py - - self.resid = resid # Mole fraction residuals - self.hphr = hphr # Mole fraction prior uncertainty from fluxes and (HPH) and model data mismatch (R) - self.may_localize = True # Whether sample may be localized in optimizer - self.may_reject = True # Whether sample may be rejected if outside threshold - self.flag = flag # Flag - self.sdev = sdev # standard deviation of ensemble - self.species = species.strip() + self.level_def = level_def # Are prior and averaging kernel defined as layer averages? + self.psurf = psurf # Surface pressure (only needed if level_def is "layer_average") + self.loc_L = int( + 600 + ) #int(0) # freum 2021-07-13: insert this dummy value so the code runs with the current version of CTDAS. *Should* not affect results if localizetype == "CT2007" as in all my runs. However, replace this file with the standard observation file, obs_column_xco2.py + + self.resid = resid # Mole fraction residuals + self.hphr = hphr # Mole fraction prior uncertainty from fluxes and (HPH) and model data mismatch (R) + self.may_localize = True # Whether sample may be localized in optimizer + self.may_reject = True # Whether sample may be rejected if outside threshold + self.flag = flag # Flag + self.sdev = sdev # standard deviation of ensemble + self.species = species.strip() ################### End Class TotalColumnSample ################### - ################### Begin Class TotalColumnObservations ################### + class TotalColumnObservations(Observations): """ An object that holds data + methods and attributes needed to manipulate column samples """ @@ -539,17 +616,18 @@ class TotalColumnObservations(Observations): def setup(self, dacycle): self.startdate = dacycle['time.sample.start'] + timedelta(days=1) - self.enddate = dacycle['time.sample.end'] + self.enddate = dacycle['time.sample.end'] # Path to the input data (daily files) - sat_files = dacycle.dasystem['obs.column.ncfile'].split(',') - sat_dirs = dacycle.dasystem['obs.column.input.dir'].split(',') + sat_files = dacycle.dasystem['obs.column.ncfile'].split(',') + sat_dirs = dacycle.dasystem['obs.column.input.dir'].split(',') - self.sat_dirs = [] - self.sat_files = [] + self.sat_dirs = [] + self.sat_files = [] for i in range(len(sat_dirs)): if not os.path.exists(sat_dirs[i].strip()): - msg = 'Could not find the required satellite input directory (%s) ' % sat_dirs[i] + msg = 'Could not find the required satellite input directory (%s) ' % sat_dirs[ + i] logging.error(msg) raise IOError(msg) else: @@ -558,14 +636,20 @@ def setup(self, dacycle): del i # Get observation selection criteria (if present): - if 'obs.column.selection.variables' in dacycle.dasystem.keys() and 'obs.column.selection.criteria' in dacycle.dasystem.keys(): - self.selection_vars = dacycle.dasystem['obs.column.selection.variables'].split(',') - self.selection_criteria = dacycle.dasystem['obs.column.selection.criteria'].split(',') - logging.debug('Data selection criteria found: %s, %s' %(self.selection_vars, self.selection_criteria)) + if 'obs.column.selection.variables' in dacycle.dasystem.keys( + ) and 'obs.column.selection.criteria' in dacycle.dasystem.keys(): + self.selection_vars = dacycle.dasystem[ + 'obs.column.selection.variables'].split(',') + self.selection_criteria = dacycle.dasystem[ + 'obs.column.selection.criteria'].split(',') + logging.debug('Data selection criteria found: %s, %s' % + (self.selection_vars, self.selection_criteria)) else: - self.selection_vars = [] + self.selection_vars = [] self.selection_criteria = [] - logging.info('No data observation selection criteria found, using all observations in file.') + logging.info( + 'No data observation selection criteria found, using all observations in file.' + ) # Model data mismatch approach # self.mdm_calculation = dacycle.dasystem.get('mdm.calculation') @@ -592,16 +676,14 @@ def setup(self, dacycle): # Switch to indicate whether simulated column samples are read from obsOperator output, # or whether the sampling is done within CTDAS (in obsOperator class) - self.sample_in_ctdas = dacycle.dasystem['sample.in.ctdas'] if 'sample.in.ctdas' in dacycle.dasystem.keys() else False + self.sample_in_ctdas = dacycle.dasystem[ + 'sample.in.ctdas'] if 'sample.in.ctdas' in dacycle.dasystem.keys( + ) else False logging.debug('sample.in.ctdas = %s' % self.sample_in_ctdas) - - def get_samples_type(self): return 'column' - - def add_observations(self): """ Reading of total column observations, and selection of observations that will be sampled and assimilated. @@ -610,74 +692,78 @@ def add_observations(self): # Read observations from daily input files for i in range(len(self.sat_dirs)): - logging.info('Reading observations from %s' %os.path.join(self.sat_dirs[i],self.sat_files[i])) + logging.info('Reading observations from %s' % + os.path.join(self.sat_dirs[i], self.sat_files[i])) infile0 = os.path.join(self.sat_dirs[i], self.sat_files[i]) ndays = 0 - while self.startdate+dt.timedelta(days=ndays) <= self.enddate: - - infile = infile0.replace("",(self.startdate+dt.timedelta(days=ndays)).strftime("%Y%m%d")) - logging.info('To be precise, reading observations from %s' % infile) + while self.startdate + dt.timedelta(days=ndays) <= self.enddate: + infile = infile0.replace( + "", + (self.startdate + + dt.timedelta(days=ndays)).strftime("%Y%m%d")) + logging.info('To be precise, reading observations from %s' % + infile) if os.path.exists(infile): - logging.info("Reading observations for %s" % (self.startdate+dt.timedelta(days=ndays)).strftime("%Y%m%d")) + logging.info("Reading observations for %s" % + (self.startdate + + dt.timedelta(days=ndays)).strftime("%Y%m%d")) len_init = len(self.datalist) # get index of observations that satisfy selection criteria (based on variable names and values in system rc file, if present) ncf = io.ct_read(infile, 'read') # retrieval attributes - code = ncf.get_attribute('retrieval_id') + code = ncf.get_attribute('retrieval_id') level_def = ncf.get_attribute('level_def') # only read good quality observations - ids = ncf.get_variable('soundings') - lats = ncf.get_variable('latitude') - lons = ncf.get_variable('longitude') - obs = ncf.get_variable('obs') - unc = ncf.get_variable('uncertainty') - dates = ncf.get_variable('date').astype(int) - dates = array([dt.datetime(*d) for d in dates]) - av_kernel = ncf.get_variable('averaging_kernel') + ids = ncf.get_variable('soundings') + lats = ncf.get_variable('latitude') + lons = ncf.get_variable('longitude') + obs = ncf.get_variable('obs') + unc = ncf.get_variable('uncertainty') + dates = ncf.get_variable('date').astype(int) + dates = array([dt.datetime(*d) for d in dates]) + av_kernel = ncf.get_variable('averaging_kernel') prior_profile = ncf.get_variable('prior_profile') - pressure = ncf.get_variable('pressure_levels') + pressure = ncf.get_variable('pressure_levels') - prior = ncf.get_variable('prior') + prior = ncf.get_variable('prior') ##### freum vvvv - pwf = ncf.get_variable('pressure_weighting_function') + pwf = ncf.get_variable('pressure_weighting_function') # Additional variable surface pressure in case the profiles are defined as layer averages if level_def == "layer_average": psurf = ncf.get_variable('surface_pressure') else: - psurf = [float('nan')]*len(ids) + psurf = [float('nan')] * len(ids) # Optional: footprint corners - latc = dict( - latc_0=[float('nan')]*len(ids), - latc_1=[float('nan')]*len(ids), - latc_2=[float('nan')]*len(ids), - latc_3=[float('nan')]*len(ids)) - lonc = dict( - lonc_0=[float('nan')]*len(ids), - lonc_1=[float('nan')]*len(ids), - lonc_2=[float('nan')]*len(ids), - lonc_3=[float('nan')]*len(ids)) - # If one footprint corner variable is there, assume + latc = dict(latc_0=[float('nan')] * len(ids), + latc_1=[float('nan')] * len(ids), + latc_2=[float('nan')] * len(ids), + latc_3=[float('nan')] * len(ids)) + lonc = dict(lonc_0=[float('nan')] * len(ids), + lonc_1=[float('nan')] * len(ids), + lonc_2=[float('nan')] * len(ids), + lonc_3=[float('nan')] * len(ids)) + # If one footprint corner variable is there, assume # all are there. That's the only case that makes sense if 'latc_0' in list(ncf.variables.keys()): - latc['latc_0'] = ncf.get_variable('latc_0') - latc['latc_1'] = ncf.get_variable('latc_1') - latc['latc_2'] = ncf.get_variable('latc_2') - latc['latc_3'] = ncf.get_variable('latc_3') - lonc['lonc_0'] = ncf.get_variable('lonc_0') - lonc['lonc_1'] = ncf.get_variable('lonc_1') - lonc['lonc_2'] = ncf.get_variable('lonc_2') - lonc['lonc_3'] = ncf.get_variable('lonc_3') + latc['latc_0'] = ncf.get_variable('latc_0') + latc['latc_1'] = ncf.get_variable('latc_1') + latc['latc_2'] = ncf.get_variable('latc_2') + latc['latc_3'] = ncf.get_variable('latc_3') + lonc['lonc_0'] = ncf.get_variable('lonc_0') + lonc['lonc_1'] = ncf.get_variable('lonc_1') + lonc['lonc_2'] = ncf.get_variable('lonc_2') + lonc['lonc_3'] = ncf.get_variable('lonc_3') ###### freum ^^^^ ncf.close() @@ -695,38 +781,38 @@ def add_observations(self): ##### freum ^^^^ )) - logging.debug("Added %d observations to the Data list" % (len(self.datalist)-len_init)) + logging.debug("Added %d observations to the Data list" % + (len(self.datalist) - len_init)) ndays += 1 del i if len(self.datalist) > 0: - logging.info("Observations list now holds %d values" % len(self.datalist)) + logging.info("Observations list now holds %d values" % + len(self.datalist)) else: logging.info("No observations found for sampling window") - - def add_model_data_mismatch(self, filename=None, advance=False): """ This function is empty: model data mismatch calculation is done during sampling in observation operator (TM5) to enhance computational efficiency (i.e. to prevent reading all soundings twice and writing large additional files) """ # obs_data = rc.read(self.obs_file) - self.rejection_threshold = 15 #int(obs_data['obs.rejection.threshold']) + self.rejection_threshold = 15 #int(obs_data['obs.rejection.threshold']) # At this point mdm is set to the measurement uncertainty only, added in the add_observations function. # Here this value is used to set the combined mdm by adding an estimate for the model uncertainty as a sum of squares. - if len(self.datalist) <= 1: return #== 0: return + if len(self.datalist) <= 1: return #== 0: return for obs in self.datalist: - obs.mdm = ( obs.mdm*obs.mdm + 2**2 )**0.5 ## Here changed into 2 (2ppm) for CO2 : ERIK, CHANGE THIS TO WHAT I NEED! + obs.mdm = ( + obs.mdm * obs.mdm + 2**2 + )**0.5 ## Here changed into 2 (2ppm) for CO2 : ERIK, CHANGE THIS TO WHAT I NEED! del obs - meanmdm = np.average(np.array( [obs.mdm for obs in self.datalist] )) - logging.debug('Mean MDM = %s' %meanmdm) - - + meanmdm = np.average(np.array([obs.mdm for obs in self.datalist])) + logging.debug('Mean MDM = %s' % meanmdm) def add_simulations(self, filename, silent=False): """ Adds observed and model simulated column values to the mole fraction objects @@ -735,7 +821,8 @@ def add_simulations(self, filename, silent=False): """ if self.sample_in_ctdas: - logging.debug("CODE TO ADD SIMULATED SAMPLES TO DATALIST TO BE ADDED") + logging.debug( + "CODE TO ADD SIMULATED SAMPLES TO DATALIST TO BE ADDED") else: # read simulated samples from file @@ -746,18 +833,20 @@ def add_simulations(self, filename, silent=False): logging.error("...exiting") raise IOError(msg) - ncf = io.ct_read(filename, method='read') - ids = ncf.get_variable('sounding_id') + ncf = io.ct_read(filename, method='read') + ids = ncf.get_variable('sounding_id') simulated = ncf.get_variable('column_modeled') ncf.close() - logging.info("Successfully read data from model sample file (%s)" % filename) + logging.info("Successfully read data from model sample file (%s)" % + filename) obs_ids = self.getvalues('id').tolist() missing_samples = [] # Match read simulated samples with observations in datalist - logging.info("Adding %i simulated samples to the data list..." % len(ids)) + logging.info("Adding %i simulated samples to the data list..." % + len(ids)) for i in range(len(ids)): # Assume samples are in same order in both datalist and file with simulated samples... if ids[i] == obs_ids[i]: @@ -773,25 +862,29 @@ def add_simulations(self, filename, silent=False): else: self.datalist[index].simulated = simulated[i] else: - logging.debug('added %s to missing_samples, obs id = %s' %(ids[i],obs_ids[i])) + logging.debug('added %s to missing_samples, obs id = %s' % + (ids[i], obs_ids[i])) missing_samples.append(ids[i]) del i if not silent and missing_samples != []: - logging.warning('%i Model samples were found that did not match any ID in the observation list. Skipping them...' % len(missing_samples)) + logging.warning( + '%i Model samples were found that did not match any ID in the observation list. Skipping them...' + % len(missing_samples)) # if number of simulated samples < observations: remove observations without samples if len(simulated) < len(self.datalist): test = len(self.datalist) - len(simulated) - logging.warning('%i Observations were not sampled, removing them from datalist...' % test) + logging.warning( + '%i Observations were not sampled, removing them from datalist...' + % test) for index in reversed(list(range(len(self.datalist)))): if self.datalist[index].simulated is None: del self.datalist[index] del index - logging.debug("%d simulated values were added to the data list" % (len(ids) - len(missing_samples))) - - + logging.debug("%d simulated values were added to the data list" % + (len(ids) - len(missing_samples))) def write_sample_coords(self, obsinputfile): """ @@ -801,17 +894,21 @@ def write_sample_coords(self, obsinputfile): if self.sample_in_ctdas: return - if len(self.datalist) <= 1: #== 0: - logging.info("No observations found for this time period, no obs file written") + if len(self.datalist) <= 1: #== 0: + logging.info( + "No observations found for this time period, no obs file written" + ) return # write data required by observation operator for sampling to file f = io.CT_CDF(obsinputfile, method='create') - logging.debug('Creating new observations file for ObservationOperator (%s)' % obsinputfile) + logging.debug( + 'Creating new observations file for ObservationOperator (%s)' % + obsinputfile) - dimsoundings = f.add_dim('soundings', len(self.datalist)) - dimdate = f.add_dim('epoch_dimension', 7) - dimchar = f.add_dim('char', 20) + dimsoundings = f.add_dim('soundings', len(self.datalist)) + dimdate = f.add_dim('epoch_dimension', 7) + dimchar = f.add_dim('char', 20) if len(self.datalist) == 1: dimlevels = f.add_dim('levels', len(self.getvalues('pressure'))) # freum: inserted but commented Liesbeth's new code for layers for reference, @@ -821,136 +918,140 @@ def write_sample_coords(self, obsinputfile): # layers = True # else: layers = False else: - dimlevels = f.add_dim('levels', self.getvalues('pressure').shape[1]) + dimlevels = f.add_dim('levels', + self.getvalues('pressure').shape[1]) # if self.getvalues('av_kernel').shape[1] != self.getvalues('pressure').shape[1]: # dimlayers = f.add_dim('layers', self.getvalues('pressure').shape[1] - 1) # layers = True # else: layers = False - savedict = io.std_savedict.copy() - savedict['dtype'] = "int64" - savedict['name'] = "sounding_id" - savedict['dims'] = dimsoundings + savedict = io.std_savedict.copy() + savedict['dtype'] = "int64" + savedict['name'] = "sounding_id" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('id').tolist() f.add_data(savedict) - data = [[d.year, d.month, d.day, d.hour, d.minute, d.second, d.microsecond] for d in self.getvalues('xdate') ] - savedict = io.std_savedict.copy() - savedict['dtype'] = "int" - savedict['name'] = "date" - savedict['dims'] = dimsoundings + dimdate + data = [[ + d.year, d.month, d.day, d.hour, d.minute, d.second, d.microsecond + ] for d in self.getvalues('xdate')] + savedict = io.std_savedict.copy() + savedict['dtype'] = "int" + savedict['name'] = "date" + savedict['dims'] = dimsoundings + dimdate savedict['values'] = data f.add_data(savedict) - savedict = io.std_savedict.copy() - savedict['name'] = "latitude" - savedict['dims'] = dimsoundings + savedict = io.std_savedict.copy() + savedict['name'] = "latitude" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('lat').tolist() f.add_data(savedict) - savedict = io.std_savedict.copy() - savedict['name'] = "longitude" - savedict['dims'] = dimsoundings + savedict = io.std_savedict.copy() + savedict['name'] = "longitude" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('lon').tolist() f.add_data(savedict) savedict = io.std_savedict.copy() - savedict['name'] = "prior" - savedict['dims'] = dimsoundings + savedict['name'] = "prior" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('prior').tolist() f.add_data(savedict) savedict = io.std_savedict.copy() - savedict['name'] = "prior_profile" - savedict['dims'] = dimsoundings + dimlevels + savedict['name'] = "prior_profile" + savedict['dims'] = dimsoundings + dimlevels savedict['values'] = self.getvalues('prior_profile').tolist() f.add_data(savedict) savedict = io.std_savedict.copy() - savedict['name'] = "averaging_kernel" - savedict['dims'] = dimsoundings + dimlevels + savedict['name'] = "averaging_kernel" + savedict['dims'] = dimsoundings + dimlevels savedict['values'] = self.getvalues('av_kernel').tolist() f.add_data(savedict) savedict = io.std_savedict.copy() - savedict['name'] = "pressure_levels" - savedict['dims'] = dimsoundings + dimlevels + savedict['name'] = "pressure_levels" + savedict['dims'] = dimsoundings + dimlevels savedict['values'] = self.getvalues('pressure').tolist() f.add_data(savedict) # freum vvvv savedict = io.std_savedict.copy() - savedict['name'] = "pressure_weighting_function" - savedict['dims'] = dimsoundings + dimlevels - savedict['values'] = self.getvalues('pressure_weighting_function').tolist() + savedict['name'] = "pressure_weighting_function" + savedict['dims'] = dimsoundings + dimlevels + savedict['values'] = self.getvalues( + 'pressure_weighting_function').tolist() f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "latc_0" - savedict['dims'] = dimsoundings + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_0" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('latc_0').tolist() f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "latc_1" - savedict['dims'] = dimsoundings + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_1" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('latc_1').tolist() f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "latc_2" - savedict['dims'] = dimsoundings + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_2" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('latc_2').tolist() f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "latc_3" - savedict['dims'] = dimsoundings + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_3" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('latc_3').tolist() f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "lonc_0" - savedict['dims'] = dimsoundings + + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_0" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('lonc_0').tolist() f.add_data(savedict) - savedict = io.std_savedict.copy() - savedict['name'] = "lonc_1" - savedict['dims'] = dimsoundings + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_1" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('lonc_1').tolist() f.add_data(savedict) - savedict = io.std_savedict.copy() - savedict['name'] = "lonc_2" - savedict['dims'] = dimsoundings + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_2" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('lonc_2').tolist() f.add_data(savedict) - savedict = io.std_savedict.copy() - savedict['name'] = "lonc_3" - savedict['dims'] = dimsoundings + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_3" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('lonc_3').tolist() f.add_data(savedict) - savedict = io.std_savedict.copy() - savedict['name'] = "XCO2" - savedict['dims'] = dimsoundings + savedict = io.std_savedict.copy() + savedict['name'] = "XCO2" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('obs').tolist() f.add_data(savedict) # freum ^^^^ savedict = io.std_savedict.copy() - savedict['dtype'] = "char" - savedict['name'] = "level_def" - savedict['dims'] = dimsoundings + dimchar + savedict['dtype'] = "char" + savedict['name'] = "level_def" + savedict['dims'] = dimsoundings + dimchar savedict['values'] = self.getvalues('level_def').tolist() f.add_data(savedict) savedict = io.std_savedict.copy() - savedict['name'] = "psurf" - savedict['dims'] = dimsoundings + savedict['name'] = "psurf" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('psurf').tolist() f.add_data(savedict) @@ -959,6 +1060,5 @@ def write_sample_coords(self, obsinputfile): ################### End Class TotalColumnObservations ################### - if __name__ == "__main__": pass diff --git a/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py b/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py index e265605d..8a2f00d6 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py +++ b/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py @@ -12,7 +12,6 @@ program. If not, see .""" #!/usr/bin/env python # model.py - """ .. module:: observationoperator .. moduleauthor:: Wouter Peters @@ -32,6 +31,7 @@ import time import re import da.tools.io4 as io + sys.path.append(os.getcwd()) sys.path.append('../../') @@ -41,10 +41,10 @@ import subprocess import glob - identifier = 'RandomizerObservationOperator' version = '1.0' + ################### Begin Class ObservationOperator ################### class ObservationOperator(object): """ @@ -64,14 +64,14 @@ def __init__(self, rc_filename, dacycle=None): self.version = version self.restart_filelist = [] self.output_filelist = [] - self.outputdir = None # Needed for opening the samples.nc files created + self.outputdir = None # Needed for opening the samples.nc files created # Load settings self._load_rc(rc_filename) self._validate_rc() # Instantiate an ICON_Helper object - self.settings["dir.icon_sim"] + self.settings["dir.icon_sim"] self.iconhelper = ICON_Helper(self.settings) self.iconhelper.validate_settings(["dir.icon_sim"]) @@ -95,9 +95,8 @@ def _load_rc(self, name): self.settings = self.rcfile.values logging.debug(self.settings) self.rc_filename = name - - logging.debug("rc-file %s loaded", name) + logging.debug("rc-file %s loaded", name) def _validate_rc(self): """Check that some required values are given in the rc-file. @@ -113,11 +112,11 @@ def _validate_rc(self): logging.error(msg) raise IOError(msg) logging.debug("rc-file has been validated succesfully") - + def get_initial_data(self): """ This method places all initial data needed by an ObservationOperator in the proper folder for the model """ - def setup(self,dacycle): + def setup(self, dacycle): """ Perform all steps necessary to start the observation operator through a simple Run() call """ self.dacycle = dacycle @@ -127,7 +126,7 @@ def setup(self,dacycle): self.n_regs = int(dacycle['statevector.number_regions']) self.tracer = str(dacycle['statevector.tracer']) - def prepare_run(self,samples): + def prepare_run(self, samples): """ Prepare the running of the actual forecast model, for example compile code """ import os @@ -135,27 +134,48 @@ def prepare_run(self,samples): # For each sample type, define the name of the file that will contain the modeled output of each observation self.simulated_file = [None] * len(samples) for i in range(len(samples)): - self.simulated_file[i] = os.path.join(self.outputdir, '%s_output.%s.nc' % (samples[i].get_samples_type(),self.dacycle['time.sample.stamp'])) - logging.info("Simulated flask file added: %s"%self.simulated_file[i]) + self.simulated_file[i] = os.path.join( + self.outputdir, + '%s_output.%s.nc' % (samples[i].get_samples_type(), + self.dacycle['time.sample.stamp'])) + logging.info("Simulated flask file added: %s" % + self.simulated_file[i]) del i self.forecast_nmembers = int(self.dacycle['da.optimizer.nmembers']) - def make_lambdas(self,statevector,lag): + def make_lambdas(self, statevector, lag): """ Write out lambda file parameters """ #msteiner: #write lambda file for current lag: members = statevector.ensemble_members[lag] if statevector.isOptimized: - self.lambda_file = os.path.join(self.simulationdir,'global_inputs','OEM','lambda_%s_opt2.nc' %self.dacycle['time.sample.stamp'][0:8]) - self.bg_lambda_file = os.path.join(self.simulationdir,'global_inputs','OEM','bg_lambda_%s_opt2.nc' %self.dacycle['time.sample.stamp'][0:8]) + self.lambda_file = os.path.join( + self.simulationdir, 'global_inputs', 'OEM', + 'lambda_%s_opt2.nc' % self.dacycle['time.sample.stamp'][0:8]) + self.bg_lambda_file = os.path.join( + self.simulationdir, 'global_inputs', 'OEM', + 'bg_lambda_%s_opt2.nc' % + self.dacycle['time.sample.stamp'][0:8]) else: - if lag==0: - self.lambda_file = os.path.join(self.simulationdir,'global_inputs','OEM','lambda_%s_opt1.nc' %self.dacycle['time.sample.stamp'][0:8]) - self.bg_lambda_file = os.path.join(self.simulationdir,'global_inputs','OEM','bg_lambda_%s_opt1.nc' %self.dacycle['time.sample.stamp'][0:8]) + if lag == 0: + self.lambda_file = os.path.join( + self.simulationdir, 'global_inputs', 'OEM', + 'lambda_%s_opt1.nc' % + self.dacycle['time.sample.stamp'][0:8]) + self.bg_lambda_file = os.path.join( + self.simulationdir, 'global_inputs', 'OEM', + 'bg_lambda_%s_opt1.nc' % + self.dacycle['time.sample.stamp'][0:8]) else: - self.lambda_file = os.path.join(self.simulationdir,'global_inputs','OEM','lambda_%s_prior.nc' %self.dacycle['time.sample.stamp'][0:8]) - self.bg_lambda_file = os.path.join(self.simulationdir,'global_inputs','OEM','bg_lambda_%s_prior.nc' %self.dacycle['time.sample.stamp'][0:8]) + self.lambda_file = os.path.join( + self.simulationdir, 'global_inputs', 'OEM', + 'lambda_%s_prior.nc' % + self.dacycle['time.sample.stamp'][0:8]) + self.bg_lambda_file = os.path.join( + self.simulationdir, 'global_inputs', 'OEM', + 'bg_lambda_%s_prior.nc' % + self.dacycle['time.sample.stamp'][0:8]) ofile = Dataset(self.lambda_file, mode='w') nr_ens = self.forecast_nmembers + 1 if {cfg.CTDAS_propagate_bg} else 0 @@ -166,24 +186,31 @@ def make_lambdas(self,statevector,lag): oreg = ofile.createDimension('reg', nr_reg) ocat = ofile.createDimension('cat', nr_cat) otracer = ofile.createDimension('tracer', nr_tracer) - odata = ofile.createVariable('lambda', np.float32, ('ens','reg','cat','tracer'),fill_value=-999.99) - lambdas = np.empty(shape=(nr_ens,nr_reg,nr_cat,nr_tracer)) - for m in range(0,self.forecast_nmembers): - param_count=0 - for ireg in range(0,nr_reg): - for icat in range(0,nr_cat): + odata = ofile.createVariable('lambda', + np.float32, + ('ens', 'reg', 'cat', 'tracer'), + fill_value=-999.99) + lambdas = np.empty(shape=(nr_ens, nr_reg, nr_cat, nr_tracer)) + for m in range(0, self.forecast_nmembers): + param_count = 0 + for ireg in range(0, nr_reg): + for icat in range(0, nr_cat): if statevector.isOptimized: - lambdas[m,ireg,icat,0] = members[0].param_values[param_count] + lambdas[m, ireg, icat, + 0] = members[0].param_values[param_count] else: - lambdas[m,ireg,icat,0] = members[m].param_values[param_count] - param_count+=1 + lambdas[m, ireg, icat, + 0] = members[m].param_values[param_count] + param_count += 1 if {cfg.CTDAS_propagate_bg}: - for ireg in range(0,nr_reg): - for icat in range(0,nr_cat): - lambdas[-1,ireg,icat,0] = 0.0 # Set anthropogenic component to 0 + for ireg in range(0, nr_reg): + for icat in range(0, nr_cat): + lambdas[-1, ireg, icat, + 0] = 0.0 # Set anthropogenic component to 0 odata[:] = lambdas ofile.close() - logging.info('lambdas for ICON simulation written to the file: %s' % self.lambda_file) + logging.info('lambdas for ICON simulation written to the file: %s' % + self.lambda_file) #write bg_lambdas ofile = Dataset(self.bg_lambda_file, mode='w') @@ -193,30 +220,39 @@ def make_lambdas(self,statevector,lag): oens = ofile.createDimension('ens', nr_ens) odir = ofile.createDimension('reg', nr_dir) # otracer = ofile.createDimension('tracer', nr_tracer) - odata = ofile.createVariable('lambda', np.float32, ('ens','reg'),fill_value=-999.99) #,'tracer' - lambdas = np.empty(shape=(nr_ens,nr_dir)) #,nr_tracer - for m in range(0,self.forecast_nmembers): - for idir in range(0,nr_dir): + odata = ofile.createVariable('lambda', + np.float32, ('ens', 'reg'), + fill_value=-999.99) #,'tracer' + lambdas = np.empty(shape=(nr_ens, nr_dir)) #,nr_tracer + for m in range(0, self.forecast_nmembers): + for idir in range(0, nr_dir): if statevector.isOptimized: - lambdas[m,idir] = members[0].param_values[-self.n_bg_params + idir] + lambdas[m, + idir] = members[0].param_values[-self.n_bg_params + + idir] else: - lambdas[m,idir] = members[m].param_values[-self.n_bg_params + idir] + lambdas[m, + idir] = members[m].param_values[-self.n_bg_params + + idir] if {cfg.CTDAS_propagate_bg}: - for idir in range(0,nr_dir): - lambdas[-1,idir] = lambdas[-2,idir] # Populate BG lambdas with the last member (which, for an optimized run, is the optimized member) + for idir in range(0, nr_dir): + lambdas[-1, idir] = lambdas[ + -2, + idir] # Populate BG lambdas with the last member (which, for an optimized run, is the optimized member) odata[:] = lambdas ofile.close() - logging.info('bg_lambdas for ICON simulation written to the file: %s' % self.bg_lambda_file) - + logging.info('bg_lambdas for ICON simulation written to the file: %s' % + self.bg_lambda_file) def validate_input(self): """ Make sure that data needed for the ObservationOperator (such as observation input lists, or parameter files) are present. """ + def save_data(self): """ Write the data that is needed for a restart or recovery of the Observation Operator to the save directory """ - def run(self,samples,statevector,lag): + def run(self, samples, statevector, lag): """ This Randomizer will take the original observation data in the Obs object, and simply copy each mean value. Next, the mean value will be perturbed by a random normal number drawn from a specified uncertainty of +/- 2 ppm @@ -226,91 +262,120 @@ def run(self,samples,statevector,lag): import numpy as np #select runscript for ICON-ART-OEM simulation: - time = dt.datetime.strptime(self.dacycle['time.sample.stamp'][0:10], "%Y%m%d%H") + time = dt.datetime.strptime(self.dacycle['time.sample.stamp'][0:10], + "%Y%m%d%H") job_timestr = f'{{time.strftime("%Y%m%d")}}' folder_timestr = f'{{time.strftime("%Y%m%d%H")}}_{{(time+dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime("%Y%m%d%H")}}' if statevector.isOptimized: - runscript = os.path.join(self.simulationdir,folder_timestr,'icon','run','{ (cfg.case_path / cfg.icon_runjob_filename).stem }' + '_%s_opt2.job'%(self.dacycle['time.sample.stamp'][0:8])) - self.outfolder = os.path.join('{cfg.case_root / "global_outputs"}', f"opt2_{{job_timestr}}") - finalfile = os.path.join(self.outfolder, f"ICON-ART-OEM-INIT_{{(time + dt.timedelta(seconds={cfg.CTDAS_restart_init_time}) + dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime('%Y-%m-%dT%H:%M:%S')}}.000.nc") + runscript = os.path.join( + self.simulationdir, folder_timestr, 'icon', 'run', + '{ (cfg.case_path / cfg.icon_runjob_filename).stem }' + + '_%s_opt2.job' % (self.dacycle['time.sample.stamp'][0:8])) + self.outfolder = os.path.join('{cfg.case_root / "global_outputs"}', + f"opt2_{{job_timestr}}") + finalfile = os.path.join( + self.outfolder, + f"ICON-ART-OEM-INIT_{{(time + dt.timedelta(seconds={cfg.CTDAS_restart_init_time}) + dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime('%Y-%m-%dT%H:%M:%S')}}.000.nc" + ) else: - if lag==0: - runscript = os.path.join(self.simulationdir,folder_timestr,'icon','run','{ (cfg.case_path / cfg.icon_runjob_filename).stem }' + '_%s_opt1.job'%(self.dacycle['time.sample.stamp'][0:8])) - self.outfolder = os.path.join('{cfg.case_root / "global_outputs"}', f"opt1_{{job_timestr}}") - finalfile = os.path.join(self.outfolder, f"ICON-ART-OEM-INIT_{{(time + dt.timedelta(seconds={cfg.CTDAS_restart_init_time}) + dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime('%Y-%m-%dT%H:%M:%S')}}.000.nc") + if lag == 0: + runscript = os.path.join( + self.simulationdir, folder_timestr, 'icon', 'run', + '{ (cfg.case_path / cfg.icon_runjob_filename).stem }' + + '_%s_opt1.job' % (self.dacycle['time.sample.stamp'][0:8])) + self.outfolder = os.path.join( + '{cfg.case_root / "global_outputs"}', + f"opt1_{{job_timestr}}") + finalfile = os.path.join( + self.outfolder, + f"ICON-ART-OEM-INIT_{{(time + dt.timedelta(seconds={cfg.CTDAS_restart_init_time}) + dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime('%Y-%m-%dT%H:%M:%S')}}.000.nc" + ) else: - runscript = os.path.join(self.simulationdir,folder_timestr,'icon','run','{ (cfg.case_path / cfg.icon_runjob_filename).stem }' + '_%s_prior.job'%(self.dacycle['time.sample.stamp'][0:8])) - self.outfolder = os.path.join('{cfg.case_root / "global_outputs"}', f"prior_{{job_timestr}}") - finalfile = os.path.join(self.outfolder, f"ICON-ART-OEM-INIT_{{(time + dt.timedelta(seconds={cfg.CTDAS_restart_init_time}) + dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime('%Y-%m-%dT%H:%M:%S')}}.000.nc") - + runscript = os.path.join( + self.simulationdir, folder_timestr, 'icon', 'run', + '{ (cfg.case_path / cfg.icon_runjob_filename).stem }' + + '_%s_prior.job' % (self.dacycle['time.sample.stamp'][0:8])) + self.outfolder = os.path.join( + '{cfg.case_root / "global_outputs"}', + f"prior_{{job_timestr}}") + finalfile = os.path.join( + self.outfolder, + f"ICON-ART-OEM-INIT_{{(time + dt.timedelta(seconds={cfg.CTDAS_restart_init_time}) + dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime('%Y-%m-%dT%H:%M:%S')}}.000.nc" + ) + while not (os.path.exists(finalfile)): - logging.info('runscript name: %s'%(runscript)) + logging.info('runscript name: %s' % (runscript)) start_icon(runscript) logging.info('ICON done!') def sample(self, samples, statevector, lag): - for j,sample in enumerate(samples): + for j, sample in enumerate(samples): sample_type = sample.get_samples_type() logging.info(f"Want to do...{{sample_type}} extraction") if sample_type == "column": logging.info("Starting _launch_icon_column_sampling") - + warning_msg = "JM: Be careful! The current column sampling " + \ "method is designed for a specific case of study. " + \ "Please evaluate if the satellite product is suitable " + \ "with an appropriate model spatial resolution!" - logging.warning( warning_msg ) - - self._launch_icon_column_sampling(j,sample) - + logging.warning(warning_msg) + + self._launch_icon_column_sampling(j, sample) + logging.info("Finished _launch_icon_column_sampling") - + elif sample_type == "insitu": - self.ICOS_sampling(j,sample, statevector, lag) - + self.ICOS_sampling(j, sample, statevector, lag) + else: logging.error("Unknown sample type: %s", sample.get_samples_type()) - - def ICOS_sampling(self,j,sample, statevector, lag): + def ICOS_sampling(self, j, sample, statevector, lag): if statevector.isOptimized: prefix = 'opt2_' else: - if lag==0: + if lag == 0: prefix = 'prior_' else: prefix = 'opt1_' # Create a flask output file to hold simulated values for later reading f = io.CT_CDF(self.simulated_file[j], method='create') - logging.debug('Creating new simulated observation file in ObservationOperator (%s)' % self.simulated_file) - + logging.debug( + 'Creating new simulated observation file in ObservationOperator (%s)' + % self.simulated_file) + dimid = f.createDimension('obs_num', size=None) - dimid = ('obs_num',) - savedict = io.std_savedict.copy() + dimid = ('obs_num', ) + savedict = io.std_savedict.copy() savedict['name'] = "obs_num" savedict['dtype'] = "int" savedict['long_name'] = "Unique_Dataset_observation_index_number" savedict['units'] = "" savedict['dims'] = dimid - savedict['comment'] = "Unique index number within this dataset ranging from 0 to UNLIMITED." - f.add_data(savedict,nsets=0) + savedict[ + 'comment'] = "Unique index number within this dataset ranging from 0 to UNLIMITED." + f.add_data(savedict, nsets=0) dimmember = f.createDimension('nmembers', size=self.forecast_nmembers) - dimmember = ('nmembers',) - savedict = io.std_savedict.copy() + dimmember = ('nmembers', ) + savedict = io.std_savedict.copy() savedict['name'] = "flask" savedict['dtype'] = "float" savedict['long_name'] = "mole_fraction_of_trace_gas_in_air" savedict['units'] = "mol tracer (mol air)^-1" savedict['dims'] = dimid + dimmember - savedict['comment'] = "Simulated model value created by RandomizerObservationOperator" - f.add_data(savedict,nsets=0) + savedict[ + 'comment'] = "Simulated model value created by RandomizerObservationOperator" + f.add_data(savedict, nsets=0) # Open file with x,y,z,t of model samples that need to be sampled - f_in = io.ct_read(self.dacycle['ObsOperator.inputfile.'+sample.get_samples_type()],method='read') + f_in = io.ct_read(self.dacycle['ObsOperator.inputfile.' + + sample.get_samples_type()], + method='read') # Get simulated values and ID @@ -326,16 +391,14 @@ def ICOS_sampling(self,j,sample, statevector, lag): # Loop over observations, add random white noise, and write to file -########################################################### + ########################################################### os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE" - - molar_mass = {{'ch4' : 16.04e-3, - 'co2' : 44.01e-3, - 'da' : 28.97e-3 - }} - units_factor = {{'ch4' : 1.e9, #ppb for ch4 - 'co2' : 1.e6, #ppm for co2 - }} + + molar_mass = {{'ch4': 16.04e-3, 'co2': 44.01e-3, 'da': 28.97e-3}} + units_factor = {{ + 'ch4': 1.e9, #ppb for ch4 + 'co2': 1.e6, #ppm for co2 + }} import sys sys.path.insert(1, "{cfg.case_path / 'ICON'}") @@ -351,99 +414,146 @@ def ICOS_sampling(self,j,sample, statevector, lag): # unique_site_names = f_in.get_variable('evn') # unique_site_names = np.asarray([''.join(unique_site_names[i].astype(str)) for i in range(unique_site_names.shape[0])]) # unique_site_names = unique_site_names[idx] - time = dt.datetime.strptime(self.dacycle['time.sample.stamp'][0:10], "%Y%m%d%H") + time = dt.datetime.strptime(self.dacycle['time.sample.stamp'][0:10], + "%Y%m%d%H") job_timestr = f'{{time.strftime("%Y%m%d")}}' starttime = f'{{time.strftime("%Y-%m-%d %H:%M:%S")}}' endtime = f"{{(time + dt.timedelta(seconds={cfg.CTDAS_restart_init_time}) + dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime('%Y-%m-%d %H:%M:%S')}}" - obs_dir = os.path.join(self.simulationdir,"global_inputs","ICOS") + obs_dir = os.path.join(self.simulationdir, "global_inputs", "ICOS") nneighb = 5 meta = {meta_dict} meta["u"] = {{}} meta["v"] = {{}} meta["temp"] = {{}} meta["qv"] = {{}} - outfile = os.path.join(self.simulationdir,"global_outputs","extracted_ICOS",'%s%s.nc'%(prefix,job_timestr)) + outfile = os.path.join(self.simulationdir, "global_outputs", + "extracted_ICOS", + '%s%s.nc' % (prefix, job_timestr)) # files = os.path.join(self.simulationdir,"global_outputs",'%s%s'%(prefix,job_timestr), 'ICON-ART-UNSTR*.nc') # logging.info(f"ICON files to sample: {{files}}") mountain_stations = {cfg.CTDAS["obs"]["ICOS"]["mountain_stations"]} - mdm_dictionary = { evaluate_dict({k: v for d in cfg.CTDAS["obs"]["ICOS"]["mdm"] for k, v in d.items()}, "c_offset", cfg.CTDAS_obs_ICOS_c_offset) }# Based on the simulated standard deviation of the signal (without background) over a full year. + mdm_dictionary = { + evaluate_dict( + { + k: v + for d in cfg.CTDAS["obs"]["ICOS"]["mdm"] + for k, v in d.items() + }, "c_offset", cfg.CTDAS_obs_ICOS_c_offset) + } # Based on the simulated standard deviation of the signal (without background) over a full year. infolder = self.outfolder logging.info(f"Running ICON sampler with input folder {{infolder}}") - logging.info(f"Running ICON sampler with starttime {{starttime}} and endtime {{endtime}} and obsdir {{obs_dir}} and nneighb {{nneighb}} and meta {{meta}} and outfile {{outfile}}") - ICON_sampler(infolder, "ICON-ART-UNSTR", "{cfg.input_files_scratch_dynamics_grid_filename}", starttime, endtime, obs_dir, nneighb, meta, outfile, mountain_stations=mountain_stations) + logging.info( + f"Running ICON sampler with starttime {{starttime}} and endtime {{endtime}} and obsdir {{obs_dir}} and nneighb {{nneighb}} and meta {{meta}} and outfile {{outfile}}" + ) + ICON_sampler(infolder, + "ICON-ART-UNSTR", + "{cfg.input_files_scratch_dynamics_grid_filename}", + starttime, + endtime, + obs_dir, + nneighb, + meta, + outfile, + mountain_stations=mountain_stations) logging.info("Finished ICON sampling") logging.info(f"Written to output file {{outfile}}") - simulated_values = np.zeros((len(obs),self.forecast_nmembers)) - f1 = io.ct_read(outfile,method='read') - TR_A_ENS = (molar_mass['da']/molar_mass[self.tracer])*units_factor[self.tracer]*np.array(f1.get_variable('TR'+self.tracer.upper()+'_A_ENS') + f1.get_variable('biosource') - f1.get_variable('biosink')) #float CH4_A_ENS(ens, sites, time) 1 --> ppb + simulated_values = np.zeros((len(obs), self.forecast_nmembers)) + f1 = io.ct_read(outfile, method='read') + TR_A_ENS = (molar_mass['da'] / molar_mass[self.tracer]) * units_factor[ + self.tracer] * np.array( + f1.get_variable('TR' + self.tracer.upper() + '_A_ENS') + + f1.get_variable('biosource') - f1.get_variable('biosink') + ) #float CH4_A_ENS(ens, sites, time) 1 --> ppb qv = np.array(f1.get_variable('qv')) #float qv(sites, time) site_names = np.array(f1.get_variable('site_name')) obs_times = np.array(f1.get_variable('time')) # wet --> dry mmr for iiens in np.arange(TR_A_ENS.shape[0]): - TR_A_ENS[iiens,...] = TR_A_ENS[iiens,...]/(1.-qv[...]) - + TR_A_ENS[iiens, ...] = TR_A_ENS[iiens, ...] / (1. - qv[...]) #LOOP OVER OBS: for iobs in np.arange(len(obs)): - station_name = fromfile[iobs][fromfile[iobs]!=b''].tostring().decode('utf-8') - if station_name not in mdm_dictionary.keys(): continue # Skip stations that aren't considered - print('DEBUG iobs: ',iobs,flush=True) - obs_date = dt.datetime(*date_components[iobs,:]) - print('DEBUG obs_date: ',obs_date,flush=True) - obs_date = obs_date.replace(minute=0,second=0) - print('DEBUG modified obs_date: ',obs_date,flush=True) + station_name = fromfile[iobs][fromfile[iobs] != + b''].tostring().decode('utf-8') + if station_name not in mdm_dictionary.keys(): + continue # Skip stations that aren't considered + print('DEBUG iobs: ', iobs, flush=True) + obs_date = dt.datetime(*date_components[iobs, :]) + print('DEBUG obs_date: ', obs_date, flush=True) + obs_date = obs_date.replace(minute=0, second=0) + print('DEBUG modified obs_date: ', obs_date, flush=True) # LOOP OVER EXTRACTED DATA TIMES for itime in np.arange(TR_A_ENS.shape[2]): - otime = dt.datetime.strptime(obs_times[itime],'%Y-%m-%dT%H') -# print('DEBUG checking otime: ',otime,flush=True) + otime = dt.datetime.strptime(obs_times[itime], '%Y-%m-%dT%H') + # print('DEBUG checking otime: ',otime,flush=True) if not (obs_date == otime): continue - print('DEBUG found otime: ',otime,flush=True) + print('DEBUG found otime: ', otime, flush=True) # find index (or the difference) of hour at 12 UTC and 0 UTC if station_name in mountain_stations: - print('DEBUG station',station_name, 'is a mountain site',flush=True) + print('DEBUG station', + station_name, + 'is a mountain site', + flush=True) delta_index = obs_date.hour - print('DEBUG delta_index: ',delta_index,flush=True) + print('DEBUG delta_index: ', delta_index, flush=True) else: - print('DEBUG station',station_name, 'is NOT a mountain site',flush=True) + print('DEBUG station', + station_name, + 'is NOT a mountain site', + flush=True) delta_index = obs_date.hour - 12 - print('DEBUG delta_index: ',delta_index,flush=True) - + print('DEBUG delta_index: ', delta_index, flush=True) # LOOP OVER STATIONS for isite in np.arange(TR_A_ENS.shape[1]): site_name = site_names[isite] -# print('DEBUG looking through sampled stations. Checking site_name: ',site_name,flush=True) - if (site_name==station_name): - print('DEBUG looking through sampled stations. Found site_name: ',site_name,flush=True) + # print('DEBUG looking through sampled stations. Checking site_name: ',site_name,flush=True) + if (site_name == station_name): + print( + 'DEBUG looking through sampled stations. Found site_name: ', + site_name, + flush=True) for iens in np.arange(self.forecast_nmembers): if station_name in mountain_stations: - simulated_values[iobs,iens] = np.nanmean(TR_A_ENS[iens,isite,itime-delta_index:itime-delta_index+7]) + simulated_values[iobs, iens] = np.nanmean( + TR_A_ENS[iens, isite, + itime - delta_index:itime - + delta_index + 7]) else: - simulated_values[iobs,iens] = np.nanmean(TR_A_ENS[iens,isite,itime-delta_index:itime-delta_index+5]) - if iens==50: - print('Added model value for member 0 of %.2f for iobs %i at %s at %s with a delta idx of %i'%(simulated_values[iobs,0],iobs,site_name,obs_date,delta_index)) - print('Added model value for member 50 of %.2f for iobs %i at %s at %s with a delta idx of %i'%(simulated_values[iobs,50],iobs,site_name,obs_date,delta_index)) + simulated_values[iobs, iens] = np.nanmean( + TR_A_ENS[iens, isite, + itime - delta_index:itime - + delta_index + 5]) + if iens == 50: + print( + 'Added model value for member 0 of %.2f for iobs %i at %s at %s with a delta idx of %i' + % (simulated_values[iobs, 0], iobs, + site_name, obs_date, delta_index)) + print( + 'Added model value for member 50 of %.2f for iobs %i at %s at %s with a delta idx of %i' + % (simulated_values[iobs, 50], iobs, + site_name, obs_date, delta_index)) break else: continue break ########################################################### - for i in range(0,len(obs)): + for i in range(0, len(obs)): f.variables['obs_num'][i] = ids[i] - f.variables['flask'][i,:] = simulated_values[i] + f.variables['flask'][i, :] = simulated_values[i] f.close() f_in.close() # Report success and exit - logging.info('ICOS ObservationOperator finished successfully, output file written (%s)' % self.simulated_file) - + logging.info( + 'ICOS ObservationOperator finished successfully, output file written (%s)' + % self.simulated_file) def _launch_icon_column_sampling(self, j, sample): """Sample ICON output at coordinates of column observations.""" @@ -453,9 +563,11 @@ def _launch_icon_column_sampling(self, j, sample): # run_dir = self.settings["dir.icon_sim"] # Erik: run_dir here means: output dir. # run_dir = '/scratch/snx3000/ekoene/processing-chain/work/VPRM_EU_ERA5_22/XCO2_test' # This should, eventually, be determined automatically from however the folder structure is made! run_dir = os.path.join(self.outfolder) - logging.info(f"Directory that satellite data will be taken from: {{run_dir}}") + logging.info( + f"Directory that satellite data will be taken from: {{run_dir}}") - sampling_coords_file = self.dacycle['ObsOperator.inputfile.'+sample.get_samples_type()] + sampling_coords_file = self.dacycle['ObsOperator.inputfile.' + + sample.get_samples_type()] logging.info(f"Sampling coords file: {{sampling_coords_file}}") # Reconstruct self.simulated_file[i] @@ -465,31 +577,31 @@ def _launch_icon_column_sampling(self, j, sample): if Nobs == 0: logging.info("No observations, skipping sampling") return - + # Make run command - command_ = " " # Erik: this would have to look different for us + command_ = " " # Erik: this would have to look different for us # Submit processes procs = list() for nproc in range(nprocs): cmd = " ".join([ - command_, - "python ./da/tools/icon/icon_sampler.py", - "--nproc %d" % nproc, - "--nprocs %d" % nprocs, - "--sampling_coords_file %s" % sampling_coords_file, - "--run_dir %s" % run_dir, - "--iconout_prefix %s" % self.settings["output_prefix"], - "--icon_grid %s" % self.settings["icon_grid_path"], - "--nmembers %d" % int(self.dacycle["da.optimizer.nmembers"]), - "--tracer_optim %s" % self.settings["tracer_optim"], - "--outfile_prefix %s" % out_file, - "--footprint_samples_dim %d" % int(self.settings['obs.column.footprint_samples_dim']) + command_, "python ./da/tools/icon/icon_sampler.py", + "--nproc %d" % nproc, + "--nprocs %d" % nprocs, + "--sampling_coords_file %s" % sampling_coords_file, + "--run_dir %s" % run_dir, + "--iconout_prefix %s" % self.settings["output_prefix"], + "--icon_grid %s" % self.settings["icon_grid_path"], + "--nmembers %d" % int(self.dacycle["da.optimizer.nmembers"]), + "--tracer_optim %s" % self.settings["tracer_optim"], + "--outfile_prefix %s" % out_file, + "--footprint_samples_dim %d" % + int(self.settings['obs.column.footprint_samples_dim']) ]) - - procs.append(subprocess.Popen(cmd.split(), - stdout=subprocess.PIPE, - stderr=subprocess.STDOUT)) - + + procs.append( + subprocess.Popen(cmd.split(), + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT)) logging.info("Started %d sampling process(es).", nprocs) logging.debug("Command of last process: %s", cmd) @@ -497,7 +609,7 @@ def _launch_icon_column_sampling(self, j, sample): # Wait for all processes to finish for n in range(nprocs): procs[n].wait() - + # Check for errors retcodes = [] for n in range(nprocs): @@ -509,62 +621,76 @@ def _launch_icon_column_sampling(self, j, sample): "finished with errors.") logging.info("All sampling processes finished.") - + # Join output files logging.info("Joining output files.") - # Finishing msg + # Finishing msg logging.info("ICON column output sampled.") logging.info("If samples object carried observations, output " + \ "file written to %s", self.simulated_file) - ######################################################################################## - def run_forecast_model(self,samples,statevector,lag,dacycle): + + def run_forecast_model(self, samples, statevector, lag, dacycle): self.startdate = dacycle['time.sample.start'] self.prepare_run(samples) - self.make_lambdas(statevector,lag) + self.make_lambdas(statevector, lag) self.validate_input() - self.run(samples,statevector,lag) - self.sample(samples,statevector,lag) + self.run(samples, statevector, lag) + self.sample(samples, statevector, lag) self.save_data() + ################### End Class ObservationOperator ################### + class RandomizerObservationOperator(ObservationOperator): """ This class holds methods and variables that are needed to use a random number generated as substitute for a true observation operator. It takes observations and returns values for each obs, with a specified amount of white noise added """ + def wait_for_job(job_id): """Wait for a job to complete.""" if not job_id: return False - + while True: - result = subprocess.run(f"sacct -j {{job_id}} --format=State --noheader", shell=True, capture_output=True, text=True) + result = subprocess.run( + f"sacct -j {{job_id}} --format=State --noheader", + shell=True, + capture_output=True, + text=True) state = result.stdout.strip() - + if state: - if any(s in state for s in ["COMPLETED", "FAILED", "CANCELLED", "TIMEOUT"]): + if any(s in state + for s in ["COMPLETED", "FAILED", "CANCELLED", "TIMEOUT"]): logging.info(f"Job {{job_id}} finished with state: {{state}}") return state == "COMPLETED", state - + time.sleep(10) + def submit_job(command): """Submit a job and return the job ID.""" logging.info(f"Running: {{command}}") - result = subprocess.run(command, shell=True, capture_output=True, text=True, check=False) + result = subprocess.run(command, + shell=True, + capture_output=True, + text=True, + check=False) match = re.search(r"Submitted batch job (\d+)", result.stdout) - + if match: return match.group(1) - + logging.error("Failed to get job ID from sbatch output.") return None + def start_icon(runscript, max_retries=3): retries = 0 while retries <= max_retries: @@ -580,12 +706,15 @@ def start_icon(runscript, max_retries=3): if state in ["FAILED", "CANCELLED", "TIMEOUT"]: retries += 1 - logging.warning(f"Job failed with state {{state}}. Retrying {{retries}}/{{max_retries}}...") + logging.warning( + f"Job failed with state {{state}}. Retrying {{retries}}/{{max_retries}}..." + ) else: break logging.error("ICON job failed after maximum retries.") return False + if __name__ == "__main__": - pass \ No newline at end of file + pass diff --git a/cases/icon-art-CTDAS/ctdas_patch/optimizer_baseclass_icos_cities.py b/cases/icon-art-CTDAS/ctdas_patch/optimizer_baseclass_icos_cities.py index 7623bfc3..911fc743 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/optimizer_baseclass_icos_cities.py +++ b/cases/icon-art-CTDAS/ctdas_patch/optimizer_baseclass_icos_cities.py @@ -12,7 +12,6 @@ program. If not, see .""" #!/usr/bin/env python # optimizer.py - """ .. module:: optimizer .. moduleauthor:: Wouter Peters @@ -35,6 +34,7 @@ ################### Begin Class Optimizer ################### + class Optimizer(object): """ This creates an instance of an optimization object. It handles the minimum least squares optimization @@ -60,25 +60,34 @@ def create_matrices(self): """ Create Matrix space needed in optimization routine """ # mean state [X] - self.x = np.zeros((self.nlag * self.nparams,), float) + self.x = np.zeros((self.nlag * self.nparams, ), float) # deviations from mean state [X'] - self.X_prime = np.zeros((self.nlag * self.nparams, self.nmembers,), float) + self.X_prime = np.zeros(( + self.nlag * self.nparams, + self.nmembers, + ), float) # mean state, transported to observation space [ H(X) ] - self.Hx = np.zeros((self.nobs,), float) + self.Hx = np.zeros((self.nobs, ), float) # deviations from mean state, transported to observation space [ H(X') ] self.HX_prime = np.zeros((self.nobs, self.nmembers), float) # observations - self.obs = np.zeros((self.nobs,), float) + self.obs = np.zeros((self.nobs, ), float) # observation ids - self.obs_ids = np.zeros((self.nobs,), float) + self.obs_ids = np.zeros((self.nobs, ), float) # covariance of observations # Total covariance of fluxes and obs in units of obs [H P H^t + R] if self.algorithm == 'Serial': - self.R = np.zeros((self.nobs,), float) - self.HPHR = np.zeros((self.nobs,), float) + self.R = np.zeros((self.nobs, ), float) + self.HPHR = np.zeros((self.nobs, ), float) else: - self.R = np.zeros((self.nobs, self.nobs,), float) - self.HPHR = np.zeros((self.nobs, self.nobs,), float) + self.R = np.zeros(( + self.nobs, + self.nobs, + ), float) + self.HPHR = np.zeros(( + self.nobs, + self.nobs, + ), float) # localization of obs self.may_localize = np.zeros(self.nobs, bool) # rejection of obs @@ -99,45 +108,57 @@ def create_matrices(self): self.speciesmask = {{}} # Kalman Gain matrix - self.KG = np.zeros((self.nlag * self.nparams,), float) + self.KG = np.zeros((self.nlag * self.nparams, ), float) #msteiner: self.fromfile = np.zeros(self.nobs, str) def state_to_matrix(self, statevector): - allsites = [] # collect all obs for n=1,..,nlag - allobs = [] # collect all obs for n=1,..,nlag - allmdm = [] # collect all mdm for n=1,..,nlag + allsites = [] # collect all obs for n=1,..,nlag + allobs = [] # collect all obs for n=1,..,nlag + allmdm = [] # collect all mdm for n=1,..,nlag allids = [] # collect all model samples for n=1,..,nlag allreject = [] # collect all model samples for n=1,..,nlag alllocalize = [] # collect all model samples for n=1,..,nlag allflags = [] # collect all model samples for n=1,..,nlag allspecies = [] # collect all model samples for n=1,..,nlag allsimulated = [] # collect all members model samples for n=1,..,nlag - allrej_thres = [] # collect all rejection_thresholds, will be the same for all samples of same source - alllats = [] # collect all latitudes for n=1,..,nlag - alllons = [] # collect all longitudes for n=1,..,nlag + allrej_thres = [ + ] # collect all rejection_thresholds, will be the same for all samples of same source + alllats = [] # collect all latitudes for n=1,..,nlag + alllons = [] # collect all longitudes for n=1,..,nlag #msteiner: - allevns = [] # collect all evns for finding loc_coeffs in localize() - allfromfiles = [] # collect all evns for finding loc_coeffs in localize() + allevns = [] # collect all evns for finding loc_coeffs in localize() + allfromfiles = [ + ] # collect all evns for finding loc_coeffs in localize() for n in range(self.nlag): samples = statevector.obs_to_assimilate[n] members = statevector.ensemble_members[n] - self.x[n * self.nparams:(n + 1) * self.nparams] = members[0].param_values - self.X_prime[n * self.nparams:(n + 1) * self.nparams, :] = np.transpose(np.array([m.param_values for m in members])) + self.x[n * self.nparams:(n + 1) * + self.nparams] = members[0].param_values + self.X_prime[n * self.nparams:(n + 1) * + self.nparams, :] = np.transpose( + np.array([m.param_values for m in members])) # Add observation data for all sample objects if samples != None: if type(samples) != list: samples = [samples] for m in range(len(samples)): sample = samples[m] - logging.debug('Lag %i, sample %i: rejection_threshold = %i, nobs = %i' %(n, m, sample.rejection_threshold, sample.getlength())) - logging.info('Lag %i, sample %i: rejection_threshold = %i, nobs = %i' %(n, m, sample.rejection_threshold, sample.getlength())) + logging.debug( + 'Lag %i, sample %i: rejection_threshold = %i, nobs = %i' + % + (n, m, sample.rejection_threshold, sample.getlength())) + logging.info( + 'Lag %i, sample %i: rejection_threshold = %i, nobs = %i' + % + (n, m, sample.rejection_threshold, sample.getlength())) logging.info(f'{{dir(sample)}}') alllats.extend(sample.getvalues('lat')) alllons.extend(sample.getvalues('lon')) - allrej_thres.extend([sample.rejection_threshold] * sample.getlength()) + allrej_thres.extend([sample.rejection_threshold] * + sample.getlength()) allreject.extend(sample.getvalues('may_reject')) alllocalize.extend(sample.getvalues('may_localize')) allflags.extend(sample.getvalues('flag')) @@ -152,9 +173,13 @@ def state_to_matrix(self, statevector): allevns.extend(sample.getvalues('evn')) allfromfiles.extend(sample.getvalues('fromfile')) except: - logging.debug(f"Number of copies: {{len(sample.getvalues('lat'))}}") - allevns.extend(['column']*len(sample.getvalues('lat'))) - allfromfiles.extend(['column']*len(sample.getvalues('lat'))) + logging.debug( + f"Number of copies: {{len(sample.getvalues('lat'))}}" + ) + allevns.extend(['column'] * + len(sample.getvalues('lat'))) + allfromfiles.extend(['column'] * + len(sample.getvalues('lat'))) simulatedensemble = sample.getvalues('simulated') for s in range(simulatedensemble.shape[0]): allsimulated.append(simulatedensemble[s]) @@ -178,37 +203,52 @@ def state_to_matrix(self, statevector): self.fromfile = allfromfiles # ~~~~~~~~ NEW SINCE OCO2, but generally valid: Setup localization (distance between observations and regions) - OBSERVATIONS_IN_RADIANS_LATLON = np.deg2rad(np.column_stack([self.latitude,self.longitude])) - grid = xr.open_dataset('/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc') + OBSERVATIONS_IN_RADIANS_LATLON = np.deg2rad( + np.column_stack([self.latitude, self.longitude])) + grid = xr.open_dataset( + '/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc') grid_latitudes = grid.lat_cell_centre.values grid_longitudes = grid.lon_cell_centre.values - REGIONS_IN_RADIANS_LATLON = np.column_stack([grid_latitudes,grid_longitudes]) - Distances = haversine_distances(OBSERVATIONS_IN_RADIANS_LATLON,REGIONS_IN_RADIANS_LATLON) * 6371000/1000 # distance to km s + REGIONS_IN_RADIANS_LATLON = np.column_stack( + [grid_latitudes, grid_longitudes]) + Distances = haversine_distances( + OBSERVATIONS_IN_RADIANS_LATLON, + REGIONS_IN_RADIANS_LATLON) * 6371000 / 1000 # distance to km s logging.debug(Distances) - self.coeff_matrix = np.exp(-Distances/{cfg.CTDAS_obs_localization}) # Footprint size for a station - self.name_array = np.arange(OBSERVATIONS_IN_RADIANS_LATLON.shape[0]) # These should be 'names' but my pixels don't have names, of course! - - self.X_prime = self.X_prime - self.x[:, np.newaxis] # make into a deviation matrix - self.HX_prime = self.HX_prime - self.Hx[:, np.newaxis] # make a deviation matrix + self.coeff_matrix = np.exp( + -Distances / + {cfg.CTDAS_obs_localization}) # Footprint size for a station + self.name_array = np.arange( + OBSERVATIONS_IN_RADIANS_LATLON.shape[0] + ) # These should be 'names' but my pixels don't have names, of course! + + self.X_prime = self.X_prime - self.x[:, np. + newaxis] # make into a deviation matrix + self.HX_prime = self.HX_prime - self.Hx[:, np. + newaxis] # make a deviation matrix if self.algorithm == 'Serial': for i, mdm in enumerate(allmdm): - self.R[i] = mdm ** 2 + self.R[i] = mdm**2 else: for i, mdm in enumerate(allmdm): - self.R[i, i] = mdm ** 2 + self.R[i, i] = mdm**2 def matrix_to_state(self, statevector): for n in range(self.nlag): members = statevector.ensemble_members[n] for m, mem in enumerate(members): - members[m].param_values[:] = self.X_prime[n * self.nparams:(n + 1) * self.nparams, m] + self.x[n * self.nparams:(n + 1) * self.nparams] + members[m].param_values[:] = self.X_prime[ + n * self.nparams:(n + 1) * self.nparams, + m] + self.x[n * self.nparams:(n + 1) * self.nparams] #msteiner: statevector.isOptimized = True #--------- - logging.debug('Returning optimized data to the StateVector, setting "StateVector.isOptimized = True" ') + logging.debug( + 'Returning optimized data to the StateVector, setting "StateVector.isOptimized = True" ' + ) def write_diagnostics(self, filename, type): """ @@ -229,12 +269,15 @@ def write_diagnostics(self, filename, type): if type == 'prior': f = io.CT_CDF(filename, method='create') - logging.debug('Creating new diagnostics file for optimizer (%s)' % filename) + logging.debug('Creating new diagnostics file for optimizer (%s)' % + filename) elif type == 'optimized': f = io.CT_CDF(filename, method='write') - logging.debug('Opening existing diagnostics file for optimizer (%s)' % filename) + logging.debug( + 'Opening existing diagnostics file for optimizer (%s)' % + filename) - # Add dimensions + # Add dimensions dimparams = f.add_params_dim(self.nparams) dimmembers = f.add_members_dim(self.nmembers) @@ -245,7 +288,7 @@ def write_diagnostics(self, filename, type): # Add data, first the ones that are written both before and after the optimization - savedict = io.std_savedict.copy() + savedict = io.std_savedict.copy() savedict['name'] = "statevectormean_%s" % type savedict['long_name'] = "full_statevector_mean_%s" % type savedict['units'] = "unitless" @@ -260,7 +303,8 @@ def write_diagnostics(self, filename, type): savedict['units'] = "unitless" savedict['dims'] = dimstate + dimmembers savedict['values'] = self.X_prime.tolist() - savedict['comment'] = 'Full state vector %s deviations as resulting from the optimizer' % type + savedict[ + 'comment'] = 'Full state vector %s deviations as resulting from the optimizer' % type f.add_data(savedict) savedict = io.std_savedict.copy() @@ -269,7 +313,9 @@ def write_diagnostics(self, filename, type): savedict['units'] = "mol mol-1" savedict['dims'] = dimobs savedict['values'] = self.Hx.tolist() - savedict['comment'] = '%s mean mole fractions based on %s state vector' % (type, type) + savedict[ + 'comment'] = '%s mean mole fractions based on %s state vector' % ( + type, type) f.add_data(savedict) savedict = io.std_savedict.copy() @@ -278,7 +324,9 @@ def write_diagnostics(self, filename, type): savedict['units'] = "mol mol-1" savedict['dims'] = dimobs + dimmembers savedict['values'] = self.HX_prime.tolist() - savedict['comment'] = '%s mole fraction deviations based on %s state vector' % (type, type) + savedict[ + 'comment'] = '%s mole fraction deviations based on %s state vector' % ( + type, type) f.add_data(savedict) # Continue with prior only data @@ -287,7 +335,8 @@ def write_diagnostics(self, filename, type): savedict = io.std_savedict.copy() savedict['name'] = "sitecode" - savedict['long_name'] = "site code propagated from observation file" + savedict[ + 'long_name'] = "site code propagated from observation file" savedict['dtype'] = "char" savedict['dims'] = dimobs + dim200char savedict['values'] = self.sitecode @@ -310,7 +359,8 @@ def write_diagnostics(self, filename, type): savedict['units'] = "" savedict['dims'] = dimobs savedict['values'] = self.obs_ids.tolist() - savedict['comment'] = 'Unique observation number across the entire ObsPack distribution' + savedict[ + 'comment'] = 'Unique observation number across the entire ObsPack distribution' f.add_data(savedict) savedict = io.std_savedict.copy() @@ -319,24 +369,28 @@ def write_diagnostics(self, filename, type): savedict['units'] = "[mol mol-1]^2" if self.algorithm == 'Serial': savedict['dims'] = dimobs - else: savedict['dims'] = dimobs + dimobs + else: + savedict['dims'] = dimobs + dimobs savedict['values'] = self.R.tolist() - savedict['comment'] = 'Variance of mole fractions resulting from model-data mismatch' + savedict[ + 'comment'] = 'Variance of mole fractions resulting from model-data mismatch' f.add_data(savedict) # Continue with posterior only data elif type == 'optimized': - + savedict = io.std_savedict.copy() savedict['name'] = "totalmolefractionvariance" savedict['long_name'] = "totalmolefractionvariance" savedict['units'] = "[mol mol-1]^2" if self.algorithm == 'Serial': savedict['dims'] = dimobs - else: savedict['dims'] = dimobs + dimobs + else: + savedict['dims'] = dimobs + dimobs savedict['values'] = self.HPHR.tolist() - savedict['comment'] = 'Variance of mole fractions resulting from prior state and model-data mismatch' + savedict[ + 'comment'] = 'Variance of mole fractions resulting from prior state and model-data mismatch' f.add_data(savedict) savedict = io.std_savedict.copy() @@ -345,7 +399,8 @@ def write_diagnostics(self, filename, type): savedict['units'] = "None" savedict['dims'] = dimobs savedict['values'] = self.flags.tolist() - savedict['comment'] = 'Flag (0/1/2/99) for observation value, 0 means okay, 1 means QC error, 2 means rejected, 99 means not sampled' + savedict[ + 'comment'] = 'Flag (0/1/2/99) for observation value, 0 means okay, 1 means QC error, 2 means rejected, 99 means not sampled' f.add_data(savedict) #savedict = io.std_savedict.copy() @@ -360,22 +415,26 @@ def write_diagnostics(self, filename, type): f.close() logging.debug('Diagnostics file closed') - - def serial_minimum_least_squares(self,n_bg_params=0): + def serial_minimum_least_squares(self, n_bg_params=0): """ Make minimum least squares solution by looping over obs""" # Calculate prior value cost function (observation part) - res_prior = np.abs(self.obs-self.Hx) - select = (res_prior < 1E15).nonzero()[0] - J_prior = res_prior.take(select,axis=0)**2/self.R.take(select,axis=0) + res_prior = np.abs(self.obs - self.Hx) + select = (res_prior < 1E15).nonzero()[0] + J_prior = res_prior.take(select, axis=0)**2 / self.R.take(select, + axis=0) res_prior = np.mean(res_prior) for n in range(self.nobs): # Screen for flagged observations (for instance site not found, or no sample written from model) if self.flags[n] != 0: - logging.debug('Skipping observation (%s,%i) because of flag value %d' % (self.sitecode[n], self.obs_ids[n], self.flags[n])) - logging.info('Skipping observation (%s,%i) because of flag value %d' % (self.sitecode[n], self.obs_ids[n], self.flags[n])) + logging.debug( + 'Skipping observation (%s,%i) because of flag value %d' % + (self.sitecode[n], self.obs_ids[n], self.flags[n])) + logging.info( + 'Skipping observation (%s,%i) because of flag value %d' % + (self.sitecode[n], self.obs_ids[n], self.flags[n])) continue # Screen for outliers greather than 3x model-data mismatch, only apply if obs may be rejected @@ -385,56 +444,75 @@ def serial_minimum_least_squares(self,n_bg_params=0): if self.may_reject[n]: threshold = self.rejection_threshold[n] * np.sqrt(self.R[n]) if np.abs(res) > threshold: - logging.debug('Rejecting observation (%s,%i) because residual (%f) exceeds threshold (%f)' % (self.sitecode[n], self.obs_ids[n], res, threshold)) - logging.info('Rejecting observation (%s,%i) because residual (%f) exceeds threshold (%f)' % (self.sitecode[n], self.obs_ids[n], res, threshold)) + logging.debug( + 'Rejecting observation (%s,%i) because residual (%f) exceeds threshold (%f)' + % (self.sitecode[n], self.obs_ids[n], res, threshold)) + logging.info( + 'Rejecting observation (%s,%i) because residual (%f) exceeds threshold (%f)' + % (self.sitecode[n], self.obs_ids[n], res, threshold)) self.flags[n] = 2 continue - logging.debug('Proceeding to assimilate observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) - logging.info('Proceeding to assimilate observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) + logging.debug('Proceeding to assimilate observation %s, %i' % + (self.sitecode[n], self.obs_ids[n])) + logging.info('Proceeding to assimilate observation %s, %i' % + (self.sitecode[n], self.obs_ids[n])) - PHt = 1. / (self.nmembers - 1) * np.dot(self.X_prime, self.HX_prime[n, :]) - self.HPHR[n] = 1. / (self.nmembers - 1) * (self.HX_prime[n, :] * self.HX_prime[n, :]).sum() + self.R[n] - self.KG[:] = PHt / self.HPHR[n] + PHt = 1. / (self.nmembers - 1) * np.dot(self.X_prime, + self.HX_prime[n, :]) + self.HPHR[n] = 1. / (self.nmembers - 1) * ( + self.HX_prime[n, :] * self.HX_prime[n, :]).sum() + self.R[n] + self.KG[:] = PHt / self.HPHR[n] if self.may_localize[n]: - logging.debug('Trying to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) - logging.info('Trying to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) - self.localize(n,n_bg_params) + logging.debug('Trying to localize observation %s, %i' % + (self.sitecode[n], self.obs_ids[n])) + logging.info('Trying to localize observation %s, %i' % + (self.sitecode[n], self.obs_ids[n])) + self.localize(n, n_bg_params) else: - logging.debug('Not allowed to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) + logging.debug('Not allowed to localize observation %s, %i' % + (self.sitecode[n], self.obs_ids[n])) # logging.info('Not allowed to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) - alpha = np.double(1.0) / (np.double(1.0) + np.sqrt((self.R[n]) / self.HPHR[n])) + alpha = np.double(1.0) / (np.double(1.0) + np.sqrt( + (self.R[n]) / self.HPHR[n])) self.x[:] = self.x + self.KG[:] * res for r in range(self.nmembers): -# logging.info('X_prime before: %s'%(str(self.X_prime[:, r]))) - self.X_prime[:, r] = self.X_prime[:, r] - alpha * self.KG[:] * (self.HX_prime[n, r]) + # logging.info('X_prime before: %s'%(str(self.X_prime[:, r]))) + self.X_prime[:, + r] = self.X_prime[:, r] - alpha * self.KG[:] * ( + self.HX_prime[n, r]) # logging.info('X_prime after: %s'%(str(self.X_prime[:, r]))) # logging.info('======================================') del r # update samples to account for update of statevector based on observation n - HXprime_n = self.HX_prime[n,:].copy() - res = self.obs[n] - self.Hx[n] - fac = 1.0 / (self.nmembers - 1) * np.sum(HXprime_n[np.newaxis,:] * self.HX_prime, axis=1) / self.HPHR[n] - self.Hx = self.Hx + fac*res - self.HX_prime = self.HX_prime - alpha* fac[:,np.newaxis]*HXprime_n - + HXprime_n = self.HX_prime[n, :].copy() + res = self.obs[n] - self.Hx[n] + fac = 1.0 / (self.nmembers - 1) * np.sum( + HXprime_n[np.newaxis, :] * self.HX_prime, + axis=1) / self.HPHR[n] + self.Hx = self.Hx + fac * res + self.HX_prime = self.HX_prime - alpha * fac[:, + np.newaxis] * HXprime_n del n if 'HXprime_n' in globals(): del HXprime_n # calculate posterior value cost function - res_post = np.abs(self.obs-self.Hx) - select = (res_post < 1E15).nonzero()[0] - J_post = res_post.take(select,axis=0)**2/self.R.take(select,axis=0) + res_post = np.abs(self.obs - self.Hx) + select = (res_post < 1E15).nonzero()[0] + J_post = res_post.take(select, axis=0)**2 / self.R.take(select, axis=0) res_post = np.mean(res_post) - logging.info('Observation part cost function: prior = %s, posterior = %s' % (np.mean(J_prior), np.mean(J_post))) - logging.info('Mean residual: prior = %s, posterior = %s' % (res_prior, res_post)) + logging.info( + 'Observation part cost function: prior = %s, posterior = %s' % + (np.mean(J_prior), np.mean(J_post))) + logging.info('Mean residual: prior = %s, posterior = %s' % + (res_prior, res_post)) #WP !!!! Very important to first do all obervations from n=1 through the end, and only then update 1,...,n. The current observation #WP should always be updated last because it features in the loop of the adjustments !!!! @@ -451,46 +529,48 @@ def serial_minimum_least_squares(self,n_bg_params=0): # self.Hx[m] = self.Hx[m] + fac * res # self.HX_prime[m, :] = self.HX_prime[m, :] - alpha * fac * self.HX_prime[n, :] - - def bulk_minimum_least_squares(self): """ Make minimum least squares solution by solving matrix equations""" - # Create full solution, first calculate the mean of the posterior analysis - HPH = np.dot(self.HX_prime, np.transpose(self.HX_prime)) / (self.nmembers - 1) # HPH = 1/N * HX' * (HX')^T - self.HPHR[:, :] = HPH + self.R # HPHR = HPH + R - HPb = np.dot(self.X_prime, np.transpose(self.HX_prime)) / (self.nmembers - 1) # HP = 1/N X' * (HX')^T - self.KG[:, :] = np.dot(HPb, la.inv(self.HPHR)) # K = HP/(HPH+R) + HPH = np.dot(self.HX_prime, np.transpose(self.HX_prime)) / ( + self.nmembers - 1) # HPH = 1/N * HX' * (HX')^T + self.HPHR[:, :] = HPH + self.R # HPHR = HPH + R + HPb = np.dot(self.X_prime, np.transpose(self.HX_prime)) / ( + self.nmembers - 1) # HP = 1/N X' * (HX')^T + self.KG[:, :] = np.dot(HPb, la.inv(self.HPHR)) # K = HP/(HPH+R) for n in range(self.nobs): self.localize(n) - self.x[:] = self.x + np.dot(self.KG, self.obs - self.Hx) # xa = xp + K (y-Hx) + self.x[:] = self.x + np.dot(self.KG, + self.obs - self.Hx) # xa = xp + K (y-Hx) - # And next make the updated ensemble deviations. Note that we calculate P by using the full equation (10) at once, and - # not in a serial update fashion as described in Whitaker and Hamill. + # And next make the updated ensemble deviations. Note that we calculate P by using the full equation (10) at once, and + # not in a serial update fashion as described in Whitaker and Hamill. # For the current problem with limited N_obs this is easier, or at least more straightforward to do. I = np.identity(self.nlag * self.nparams) - sHPHR = la.cholesky(self.HPHR) # square root of HPH+R - part1 = np.dot(HPb, np.transpose(la.inv(sHPHR))) # HP(sqrt(HPH+R))^-1 - part2 = la.inv(sHPHR + np.sqrt(self.R)) # (sqrt(HPH+R)+sqrt(R))^-1 - Kw = np.dot(part1, part2) # K~ - self.X_prime[:, :] = np.dot(I, self.X_prime) - np.dot(Kw, self.HX_prime) # HX' = I - K~ * HX' - + sHPHR = la.cholesky(self.HPHR) # square root of HPH+R + part1 = np.dot(HPb, np.transpose(la.inv(sHPHR))) # HP(sqrt(HPH+R))^-1 + part2 = la.inv(sHPHR + np.sqrt(self.R)) # (sqrt(HPH+R)+sqrt(R))^-1 + Kw = np.dot(part1, part2) # K~ + self.X_prime[:, :] = np.dot(I, self.X_prime) - np.dot( + Kw, self.HX_prime) # HX' = I - K~ * HX' # Now do the adjustments of the modeled mole fractions using the linearized ensemble. These are not strictly needed but can be used # for diagnosis. - part3 = np.dot(HPH, np.transpose(la.inv(sHPHR))) # HPH(sqrt(HPH+R))^-1 - Kw = np.dot(part3, part2) # K~ - self.Hx[:] = self.Hx + np.dot(np.dot(HPH, la.inv(self.HPHR)), self.obs - self.Hx) # Hx = Hx+ HPH/HPH+R (y-Hx) - self.HX_prime[:, :] = self.HX_prime - np.dot(Kw, self.HX_prime) # HX' = HX'- K~ * HX' - - logging.info('Minimum Least Squares solution was calculated, returning') + part3 = np.dot(HPH, np.transpose(la.inv(sHPHR))) # HPH(sqrt(HPH+R))^-1 + Kw = np.dot(part3, part2) # K~ + self.Hx[:] = self.Hx + np.dot(np.dot(HPH, la.inv( + self.HPHR)), self.obs - self.Hx) # Hx = Hx+ HPH/HPH+R (y-Hx) + self.HX_prime[:, :] = self.HX_prime - np.dot( + Kw, self.HX_prime) # HX' = HX'- K~ * HX' + logging.info( + 'Minimum Least Squares solution was calculated, returning') def set_localization(self, loctype='None'): """ determine which localization to use """ @@ -508,8 +588,9 @@ def set_localization(self, loctype='None'): elif self.nmembers == 192: self.tvalue = 1.9724 elif self.nmembers == 200: - self.tvalue = 1.9719 - else: self.tvalue = 0 + self.tvalue = 1.9719 + else: + self.tvalue = 0 elif loctype == 'spatial': logging.info('Spatial localization selected') self.localization = True @@ -517,105 +598,111 @@ def set_localization(self, loctype='None'): else: self.localization = False self.localizetype = 'None' - - logging.info("Current localization option is set to %s" % self.localizetype) + + logging.info("Current localization option is set to %s" % + self.localizetype) if ((self.localization == True) and (self.localizetype == 'CT2007')): if self.tvalue == 0: - logging.error("Critical tvalue for localization not set for %i ensemble members"%(self.nmembers)) + logging.error( + "Critical tvalue for localization not set for %i ensemble members" + % (self.nmembers)) sys.exit(2) - else: logging.info("Used critical tvalue %0.05f is based on 95%% probability and %i ensemble members in a two-tailed student's T-test"%(self.tvalue,self.nmembers)) - + else: + logging.info( + "Used critical tvalue %0.05f is based on 95%% probability and %i ensemble members in a two-tailed student's T-test" + % (self.tvalue, self.nmembers)) - def get_prob(self,n,i): -# def get_prob(self,obsdev,paramdev,r): + def get_prob(self, n, i): + # def get_prob(self,obsdev,paramdev,r): """Calculate probability from correlations""" -# corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] -# corr = np.corrcoef(obsdev,paramdev)[0,1] -# corr = np.ma.corrcoef(np.ma.masked_invalid(self.HX_prime[n, :]),np.ma.masked_invalid(self.X_prime[r, :].squeeze()))[0,1] - for r in np.arange(i,self.nlag * self.nparams)[::36]: - corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] - prob = corr / np.sqrt((1.000000001 - corr ** 2) / (self.nmembers - 2)) + # corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] + # corr = np.corrcoef(obsdev,paramdev)[0,1] + # corr = np.ma.corrcoef(np.ma.masked_invalid(self.HX_prime[n, :]),np.ma.masked_invalid(self.X_prime[r, :].squeeze()))[0,1] + for r in np.arange(i, self.nlag * self.nparams)[::36]: + corr = np.corrcoef(self.HX_prime[n, :], + self.X_prime[r, :].squeeze())[0, 1] + prob = corr / np.sqrt( + (1.000000001 - corr**2) / (self.nmembers - 2)) if abs(prob) < self.tvalue: self.KG[r] = 0.0 - def localize(self, n, n_bg_params): - skip_stations = ['Malin Head_47', - 'Hegyhatsal hatterszennyettseg-mero allomas_48', - 'Hegyhatsal hatterszennyettseg-mero allomas_82', - 'Birkenes_2', - 'Hegyhatsal hatterszennyettseg-mero allomas_115', - 'Hegyhatsal hatterszennyettseg-mero allomas_10', - 'Beromunster_12', - 'Beromunster_44', - 'Beromunster_72', - 'Beromunster_132', - 'Bilsdale_42', - 'Bilsdale_108', - 'Cabauw_27', - 'Cabauw_67', - 'Cabauw_127', - 'Gartow_30', - 'Gartow_60', - 'Gartow_132', - 'Gartow_216', - 'Hohenpeissenberg_50', - 'Hohenpeissenberg_93', - 'Hyltemossa_30', - 'Hyltemossa_70', - 'Ispara_40', - 'Ispra_70', - 'Karlsruhe_30', - 'Karlsruhe_60', - 'Karlsruhe_100', - 'Kresin u Pacova_10', - 'Kresin u Pacova_50', - 'Kresin u Pacova_125', - 'Lindenberg_2', - 'Lindenberg_10', - 'Lindenberg_40', - 'Observatoire de Haute Provence_10', - 'Observatoire de Haute Provence_50', - "Observatoire perenne de l'environnement_10", - "Observatoire perenne de l'environnement_50", - 'Ridge Hill_45', - 'Saclay_15', - 'Saclay_60', - 'Tacolneston_54', - 'Tacolneston_100', - 'Torfhaus_10', - 'Torfhaus_76', - 'Torfhaus_110', - 'Trainou_5', - 'Trainou_50', - 'Trainou_100', - ] - + skip_stations = [ + 'Malin Head_47', + 'Hegyhatsal hatterszennyettseg-mero allomas_48', + 'Hegyhatsal hatterszennyettseg-mero allomas_82', + 'Birkenes_2', + 'Hegyhatsal hatterszennyettseg-mero allomas_115', + 'Hegyhatsal hatterszennyettseg-mero allomas_10', + 'Beromunster_12', + 'Beromunster_44', + 'Beromunster_72', + 'Beromunster_132', + 'Bilsdale_42', + 'Bilsdale_108', + 'Cabauw_27', + 'Cabauw_67', + 'Cabauw_127', + 'Gartow_30', + 'Gartow_60', + 'Gartow_132', + 'Gartow_216', + 'Hohenpeissenberg_50', + 'Hohenpeissenberg_93', + 'Hyltemossa_30', + 'Hyltemossa_70', + 'Ispara_40', + 'Ispra_70', + 'Karlsruhe_30', + 'Karlsruhe_60', + 'Karlsruhe_100', + 'Kresin u Pacova_10', + 'Kresin u Pacova_50', + 'Kresin u Pacova_125', + 'Lindenberg_2', + 'Lindenberg_10', + 'Lindenberg_40', + 'Observatoire de Haute Provence_10', + 'Observatoire de Haute Provence_50', + "Observatoire perenne de l'environnement_10", + "Observatoire perenne de l'environnement_50", + 'Ridge Hill_45', + 'Saclay_15', + 'Saclay_60', + 'Tacolneston_54', + 'Tacolneston_100', + 'Torfhaus_10', + 'Torfhaus_76', + 'Torfhaus_110', + 'Trainou_5', + 'Trainou_50', + 'Trainou_100', + ] """ localize the Kalman Gain matrix """ import numpy as np from multiprocessing import Pool - if not self.localization: + if not self.localization: logging.debug('Not localized observation %i' % self.obs_ids[n]) - return + return if self.localizetype == 'CT2007': -# count_localized = 0 -# for r in range(self.nlag * self.nparams): -## corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] -# corr = np.ma.corrcoef(np.ma.masked_invalid(self.HX_prime[n, :]),np.ma.masked_invalid(self.X_prime[r, :].squeeze()))[0,1] -# prob = corr / np.sqrt((1.000000001 - corr ** 2) / (self.nmembers - 2)) -# if abs(prob) < self.tvalue: -# self.KG[r] = 0.0 -# count_localized = count_localized + 1 -# logging.debug('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) -# logging.info('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) + # count_localized = 0 + # for r in range(self.nlag * self.nparams): + ## corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] + # corr = np.ma.corrcoef(np.ma.masked_invalid(self.HX_prime[n, :]),np.ma.masked_invalid(self.X_prime[r, :].squeeze()))[0,1] + # prob = corr / np.sqrt((1.000000001 - corr ** 2) / (self.nmembers - 2)) + # if abs(prob) < self.tvalue: + # self.KG[r] = 0.0 + # count_localized = count_localized + 1 + # logging.debug('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) + # logging.info('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) ############################################ ###make the CT2007 parallel: -# args = [ (n, i) for i in range(self.nlag * self.nparams) ] - args = [ (n, i) for i in range(36) ] -# args = [ (self.HX_prime[n, :], self.X_prime[r, :].squeeze(), r ) for r in range(self.nlag * self.nparams) ] + # args = [ (n, i) for i in range(self.nlag * self.nparams) ] + args = [(n, i) for i in range(36)] + # args = [ (self.HX_prime[n, :], self.X_prime[r, :].squeeze(), r ) for r in range(self.nlag * self.nparams) ] with Pool(36) as pool: pool.starmap(self.get_prob, args) # count_localized = 0 @@ -628,21 +715,24 @@ def localize(self, n, n_bg_params): logging.info('Localized observation %i' % (self.obs_ids[n])) ############################################ - elif self.localizetype == 'spatial': n_em_cat = {max(lambdas)} - if self.fromfile[n] in skip_stations: return # Skip stations outside of the domain! - - coeff_l = np.zeros((n_em_cat*len(self.coeff_matrix[n,:]))) - for i_n_cat in range(n_em_cat): - coeff_l[i_n_cat:][::n_em_cat] = self.coeff_matrix[n,:] - + if self.fromfile[n] in skip_stations: + return # Skip stations outside of the domain! + + coeff_l = np.zeros((n_em_cat * len(self.coeff_matrix[n, :]))) + for i_n_cat in range(n_em_cat): + coeff_l[i_n_cat:][::n_em_cat] = self.coeff_matrix[n, :] + for l in range(self.nlag): - self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params] = np.multiply( self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params], coeff_l ) + self.KG[l * self.nparams:(l + 1) * self.nparams - + n_bg_params] = np.multiply( + self.KG[l * self.nparams:(l + 1) * self.nparams - + n_bg_params], coeff_l) - logging.info('Localized observation %i at station %s (nr. %i)'%(self.obs_ids[n],self.fromfile[n], n)) + logging.info('Localized observation %i at station %s (nr. %i)' % + (self.obs_ids[n], self.fromfile[n], n)) - def set_algorithm(self, algorithm='Serial'): """ determine which minimum least squares algorithm to use """ @@ -650,12 +740,12 @@ def set_algorithm(self, algorithm='Serial'): self.algorithm = 'Serial' else: self.algorithm = 'Bulk' - - logging.info("Current minimum least squares algorithm is set to %s" % self.algorithm) -################### End Class Optimizer ################### + logging.info("Current minimum least squares algorithm is set to %s" % + self.algorithm) +################### End Class Optimizer ################### if __name__ == "__main__": pass diff --git a/cases/icon-art-CTDAS/ctdas_patch/pipeline_icon.py b/cases/icon-art-CTDAS/ctdas_patch/pipeline_icon.py index c219e90d..13811d90 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/pipeline_icon.py +++ b/cases/icon-art-CTDAS/ctdas_patch/pipeline_icon.py @@ -12,7 +12,6 @@ program. If not, see .""" #!/usr/bin/env python # pipeline.py - """ .. module:: pipeline .. moduleauthor:: Wouter Peters @@ -33,11 +32,12 @@ footer = """ *************************************** \n """ -def ensemble_smoother_pipeline(dacycle, platform, dasystem, samples, statevector, obsoperator, optimizer): +def ensemble_smoother_pipeline(dacycle, platform, dasystem, samples, + statevector, obsoperator, optimizer): """ The main point of entry for the pipeline """ sys.path.append(os.getcwd()) - samples = samples if isinstance(samples,list) else [samples] + samples = samples if isinstance(samples, list) else [samples] logging.info(header + "Initializing current cycle" + footer) start_job(dacycle, dasystem, platform, statevector, samples, obsoperator) @@ -54,66 +54,80 @@ def ensemble_smoother_pipeline(dacycle, platform, dasystem, samples, statevector logging.info("Cycle finished...exiting pipeline") - -def forward_pipeline(dacycle, platform, dasystem, samples, statevector, obsoperator): +def forward_pipeline(dacycle, platform, dasystem, samples, statevector, + obsoperator): """ The main point of entry for the pipeline """ sys.path.append(os.getcwd()) - samples = samples if isinstance(samples,list) else [samples] + samples = samples if isinstance(samples, list) else [samples] logging.info(header + "Initializing current cycle" + footer) start_job(dacycle, dasystem, platform, statevector, samples, obsoperator) if 'forward.savestate.exceptsam' in dacycle: - sam = (dacycle['forward.savestate.exceptsam'].upper() in ["TRUE","T","YES","Y"]) + sam = (dacycle['forward.savestate.exceptsam'].upper() + in ["TRUE", "T", "YES", "Y"]) else: sam = False if 'forward.savestate.dir' in dacycle: fwddir = dacycle['forward.savestate.dir'] else: - logging.debug("No forward.savestate.dir key found in rc-file, proceeding with self-constructed prior parameters") + logging.debug( + "No forward.savestate.dir key found in rc-file, proceeding with self-constructed prior parameters" + ) fwddir = False if 'forward.savestate.legacy' in dacycle: - legacy = (dacycle['forward.savestate.legacy'].upper() in ["TRUE","T","YES","Y"]) + legacy = (dacycle['forward.savestate.legacy'].upper() + in ["TRUE", "T", "YES", "Y"]) else: legacy = False logging.debug("No forward.savestate.legacy key found in rc-file") if not fwddir: # Simply make a prior statevector using the normal method - prepare_state(dacycle, statevector)#LU tutaj zamiast tego raczej to stworzenie nowej kowariancji i ensembli bo pozostale rzeczy sa na gorze i na doel. + prepare_state( + dacycle, statevector + ) #LU tutaj zamiast tego raczej to stworzenie nowej kowariancji i ensembli bo pozostale rzeczy sa na gorze i na doel. else: # Read prior information from another simulation into the statevector. # This loads the results from another assimilation experiment into the current statevector if sam: - filename = os.path.join(fwddir, dacycle['time.start'].strftime('%Y%m%d'), 'savestate_%s.nc'%dacycle['time.start'].strftime('%Y%m%d')) + filename = os.path.join( + fwddir, dacycle['time.start'].strftime('%Y%m%d'), + 'savestate_%s.nc' % dacycle['time.start'].strftime('%Y%m%d')) #filename = os.path.join(fwddir, dacycle['time.start'].strftime('%Y%m%d'), 'savestate.nc') statevector.read_from_file_exceptsam(filename, 'prior') elif not legacy: - filename = os.path.join(fwddir, dacycle['time.start'].strftime('%Y%m%d'), 'savestate_%s.nc'%dacycle['time.start'].strftime('%Y%m%d')) + filename = os.path.join( + fwddir, dacycle['time.start'].strftime('%Y%m%d'), + 'savestate_%s.nc' % dacycle['time.start'].strftime('%Y%m%d')) statevector.read_from_file(filename, 'prior') else: - filename = os.path.join(fwddir, dacycle['time.start'].strftime('%Y%m%d'), 'savestate.nc') + filename = os.path.join(fwddir, + dacycle['time.start'].strftime('%Y%m%d'), + 'savestate.nc') statevector.read_from_legacy_file(filename, 'prior') - # We write this "prior" statevector to the restart directory, so we can later also populate it with the posterior statevector # Note that we could achieve the same by just copying the wanted forward savestate.nc file to the restart folder of our current # experiment, but then it would already contain a posterior field as well which we will try to write in save_and_submit. # This could cause problems. Moreover, this method allows us to read older formatted savestate.nc files (legacy) and write them into # the current format through the "write_to_file" method. - savefilename = os.path.join(dacycle['dir.restart'], 'savestate_%s.nc' % dacycle['time.start'].strftime('%Y%m%d')) + savefilename = os.path.join( + dacycle['dir.restart'], + 'savestate_%s.nc' % dacycle['time.start'].strftime('%Y%m%d')) statevector.write_to_file(savefilename, 'prior') # Now read optimized fluxes which we will actually use to propagate through the system if not fwddir: # if there is no forward dir specified, we simply run forward with unoptimized prior fluxes in the statevector - logging.info("Running forward with prior savestate from: %s"%savefilename) + logging.info("Running forward with prior savestate from: %s" % + savefilename) else: # Read posterior information from another simulation into the statevector. @@ -126,7 +140,8 @@ def forward_pipeline(dacycle, platform, dasystem, samples, statevector, obsopera else: statevector.read_from_legacy_file(filename, 'opt') - logging.info("Running forward with optimized savestate from: %s"%filename) + logging.info("Running forward with optimized savestate from: %s" % + filename) # Finally, we run forward with these parameters advance(dacycle, samples, statevector, obsoperator) @@ -137,8 +152,11 @@ def forward_pipeline(dacycle, platform, dasystem, samples, statevector, obsopera save_and_submit(dacycle, statevector) logging.info("Cycle finished...exiting pipeline") + + #################################################################################################### + def analysis_pipeline(dacycle, platform, dasystem, samples, statevector): """ Main entry point for analysis of ctdas results """ @@ -166,25 +184,24 @@ def analysis_pipeline(dacycle, platform, dasystem, samples, statevector): save_weekly_avg_state_data(dacycle, statevector) save_weekly_avg_tc_data(dacycle, statevector) save_weekly_avg_ext_tc_data(dacycle) - save_weekly_avg_agg_data(dacycle,region_aggregate='transcom') - save_weekly_avg_agg_data(dacycle,region_aggregate='transcom_extended') - save_weekly_avg_agg_data(dacycle,region_aggregate='olson') - save_weekly_avg_agg_data(dacycle,region_aggregate='olson_extended') - save_weekly_avg_agg_data(dacycle,region_aggregate='country') + save_weekly_avg_agg_data(dacycle, region_aggregate='transcom') + save_weekly_avg_agg_data(dacycle, region_aggregate='transcom_extended') + save_weekly_avg_agg_data(dacycle, region_aggregate='olson') + save_weekly_avg_agg_data(dacycle, region_aggregate='olson_extended') + save_weekly_avg_agg_data(dacycle, region_aggregate='country') logging.info(header + "Starting monthly and yearly averages" + footer) - time_avg(dacycle,'flux1x1') - time_avg(dacycle,'transcom') - time_avg(dacycle,'transcom_extended') - time_avg(dacycle,'olson') - time_avg(dacycle,'olson_extended') - time_avg(dacycle,'country') + time_avg(dacycle, 'flux1x1') + time_avg(dacycle, 'transcom') + time_avg(dacycle, 'transcom_extended') + time_avg(dacycle, 'olson') + time_avg(dacycle, 'olson_extended') + time_avg(dacycle, 'country') logging.info(header + "Finished analysis" + footer) - def archive_pipeline(dacycle, platform, dasystem): """ Main entry point for archiving of output from one disk/system to another """ @@ -195,25 +212,35 @@ def archive_pipeline(dacycle, platform, dasystem): logging.info('rsync task found, starting automatic backup...') for task in dacycle['task.rsync'].split(): - sourcedirs = dacycle['task.rsync.%s.sourcedirs'%task] - destdir = dacycle['task.rsync.%s.destinationdir'%task] + sourcedirs = dacycle['task.rsync.%s.sourcedirs' % task] + destdir = dacycle['task.rsync.%s.destinationdir' % task] - rsyncflags = dacycle['task.rsync.%s.flags'%task] + rsyncflags = dacycle['task.rsync.%s.flags' % task] # file ID and names jobid = dacycle['time.end'].strftime('%Y%m%d') targetdir = os.path.join(dacycle['dir.exec']) - jobfile = os.path.join(targetdir, 'jb.rsync.%s.%s.jb' % (task,jobid) ) - logfile = os.path.join(targetdir, 'jb.rsync.%s.%s.log' % (task,jobid) ) + jobfile = os.path.join(targetdir, 'jb.rsync.%s.%s.jb' % (task, jobid)) + logfile = os.path.join(targetdir, 'jb.rsync.%s.%s.log' % (task, jobid)) # Template and commands for job - jobparams = {{'jobname':"r.%s" % jobid, 'jobnodes': '1', 'jobtime': '1:00:00', 'joblog': logfile, 'errfile': logfile}} + jobparams = {{ + 'jobname': "r.%s" % jobid, + 'jobnodes': '1', + 'jobtime': '1:00:00', + 'joblog': logfile, + 'errfile': logfile + }} if platform.ID == 'cartesius': jobparams['jobqueue'] = 'staging' template = platform.get_job_template(jobparams) for sourcedir in sourcedirs.split(): - execcommand = """\nrsync %s %s %s\n""" % (rsyncflags, sourcedir,destdir,) + execcommand = """\nrsync %s %s %s\n""" % ( + rsyncflags, + sourcedir, + destdir, + ) template += execcommand # write and submit @@ -221,7 +248,6 @@ def archive_pipeline(dacycle, platform, dasystem): jobid = platform.submit_job(jobfile, joblog=logfile) - def start_job(dacycle, dasystem, platform, statevector, samples, obsoperator): """ Set up the job specific directory structure and create an expanded rc-file """ @@ -248,12 +274,15 @@ def prepare_state(dacycle, statevector): if 'inversion.savestate.dir' in dacycle: initdir = dacycle['inversion.savestate.dir'] - method = dacycle['inversion.savestate.method'] # valid options: read_new_member and read_mean - logging.info('Ensemble members will be initialized from optimized ensembles in %s' %initdir) + method = dacycle[ + 'inversion.savestate.method'] # valid options: read_new_member and read_mean + logging.info( + 'Ensemble members will be initialized from optimized ensembles in %s' + % initdir) else: method = 'create_new_member' - logging.info('msteiner: prepare_state: method is: %s' %method) + logging.info('msteiner: prepare_state: method is: %s' % method) if not dacycle['time.restart']: @@ -263,29 +292,45 @@ def prepare_state(dacycle, statevector): for n in range(statevector.nlag): if method == 'create_new_member': - date = dacycle['time.start'] + datetime.timedelta(days=(n + 0.5) * int(dacycle['time.cycle'])) + date = dacycle['time.start'] + datetime.timedelta( + days=(n + 0.5) * int(dacycle['time.cycle'])) cov = statevector.get_covariance(date, dacycle) - statevector.make_new_ensemble(n, cov, int(dacycle['statevector.bg_params'])) + statevector.make_new_ensemble( + n, cov, int(dacycle['statevector.bg_params'])) elif method == 'read_new_member' or method == 'read_mean': - date = dacycle['time.start'] + datetime.timedelta(days=n * int(dacycle['time.cycle'])) - filename_new_member = os.path.join(initdir, date.strftime('%Y%m%d'), 'savestate_%s.nc'%date.strftime('%Y%m%d')) + date = dacycle['time.start'] + datetime.timedelta( + days=n * int(dacycle['time.cycle'])) + filename_new_member = os.path.join( + initdir, date.strftime('%Y%m%d'), + 'savestate_%s.nc' % date.strftime('%Y%m%d')) # Check if filename exits, else we will need to interpolate between dates if os.path.exists(filename_new_member): if method == 'read_new_member': - statevector.read_ensemble_member_from_file(filename_new_member, n, qual='opt', read_lag=0) + statevector.read_ensemble_member_from_file( + filename_new_member, n, qual='opt', read_lag=0) elif method == 'read_mean': - date = dacycle['time.start'] + datetime.timedelta(days=(n + 0.5) * int(dacycle['time.cycle'])) + date = dacycle['time.start'] + datetime.timedelta( + days=(n + 0.5) * int(dacycle['time.cycle'])) cov = statevector.get_covariance(date, dacycle) - meanstate = statevector.read_mean_from_file(filename_new_member, n, qual='opt') + meanstate = statevector.read_mean_from_file( + filename_new_member, n, qual='opt') statevector.make_new_ensemble(n, cov, meanstate) else: if method == 'read_new_member': - statevector.read_ensemble_member_from_file(filename_new_member, n, date, initdir, qual='opt', read_lag=0) + statevector.read_ensemble_member_from_file( + filename_new_member, + n, + date, + initdir, + qual='opt', + read_lag=0) elif method == 'read_mean': - meanstate = statevector.read_mean_from_file(filename_new_member, n, date, initdir, qual='opt') - date = dacycle['time.start'] + datetime.timedelta(days=(n + 0.5) * int(dacycle['time.cycle'])) + meanstate = statevector.read_mean_from_file( + filename_new_member, n, date, initdir, qual='opt') + date = dacycle['time.start'] + datetime.timedelta( + days=(n + 0.5) * int(dacycle['time.cycle'])) cov = statevector.get_covariance(date, dacycle) statevector.make_new_ensemble(n, cov, meanstate) @@ -295,24 +340,33 @@ def prepare_state(dacycle, statevector): # Read the statevector data from file #saved_sv = os.path.join(dacycle['dir.restart.current'], 'savestate.nc') - saved_sv = os.path.join(dacycle['dir.restart'], 'savestate_%s.nc' % dacycle['da.restart.tstamp'].strftime('%Y%m%d')) - statevector.read_from_file(saved_sv) # by default will read "opt"(imized) variables, and then propagate + saved_sv = os.path.join( + dacycle['dir.restart'], 'savestate_%s.nc' % + dacycle['da.restart.tstamp'].strftime('%Y%m%d')) + statevector.read_from_file( + saved_sv + ) # by default will read "opt"(imized) variables, and then propagate # read ensemble for new week from file, or create new ensemble member, and propagate the ensemble by one cycle to prepare for the current cycle if method == 'create_new_member': statevector.propagate(dacycle) elif method == 'read_new_member' or method == 'read_mean': - date = dacycle['time.start'] + datetime.timedelta(days=(statevector.nlag-1) * int(dacycle['time.cycle'])) - filename_new_member = os.path.join(initdir, date.strftime('%Y%m%d'), 'savestate_%s.nc'%date.strftime('%Y%m%d')) - statevector.propagate(dacycle, method, filename_new_member, date, initdir) + date = dacycle['time.start'] + datetime.timedelta( + days=(statevector.nlag - 1) * int(dacycle['time.cycle'])) + filename_new_member = os.path.join( + initdir, date.strftime('%Y%m%d'), + 'savestate_%s.nc' % date.strftime('%Y%m%d')) + statevector.propagate(dacycle, method, filename_new_member, date, + initdir) # Finally, also write the statevector to a file so that we can always access the a-priori information - current_sv = os.path.join(dacycle['dir.restart'], 'savestate_%s.nc' % dacycle['time.start'].strftime('%Y%m%d')) + current_sv = os.path.join( + dacycle['dir.restart'], + 'savestate_%s.nc' % dacycle['time.start'].strftime('%Y%m%d')) statevector.write_to_file(current_sv, 'prior') # write prior info - def sample_state(dacycle, samples, statevector, obsoperator): """ Sample the filter state for the inversion """ @@ -330,7 +384,8 @@ def sample_state(dacycle, samples, statevector, obsoperator): obsoperator.get_initial_data() for lag in range(nlag): - logging.info(header + ".....Ensemble Kalman Filter at lag %d" % (lag + 1)) + logging.info(header + ".....Ensemble Kalman Filter at lag %d" % + (lag + 1)) ############# Perform the actual sampling loop ##################### @@ -339,8 +394,12 @@ def sample_state(dacycle, samples, statevector, obsoperator): logging.debug("statevector now carries %d samples" % statevector.nobs) - -def sample_step(dacycle, samples, statevector, obsoperator, lag, advance=False): +def sample_step(dacycle, + samples, + statevector, + obsoperator, + lag, + advance=False): """ Perform all actions needed to sample one cycle """ # First set up the information for time start and time end of this sample @@ -349,13 +408,16 @@ def sample_step(dacycle, samples, statevector, obsoperator, lag, advance=False): startdate = dacycle['time.sample.start'] enddate = dacycle['time.sample.end'] dacycle['time.sample.window'] = lag - dacycle['time.sample.stamp'] = "%s_%s" % (startdate.strftime("%Y%m%d%H"), enddate.strftime("%Y%m%d%H")) + dacycle['time.sample.stamp'] = "%s_%s" % (startdate.strftime("%Y%m%d%H"), + enddate.strftime("%Y%m%d%H")) logging.info("New simulation interval set : ") - logging.info(" start date : %s " % startdate.strftime('%F %H:%M')) - logging.info(" end date : %s " % enddate.strftime('%F %H:%M')) - logging.info(" file stamp: %s " % dacycle['time.sample.stamp']) - + logging.info(" start date : %s " % + startdate.strftime('%F %H:%M')) + logging.info(" end date : %s " % + enddate.strftime('%F %H:%M')) + logging.info(" file stamp: %s " % + dacycle['time.sample.stamp']) # Implement something that writes the ensemble member parameter info to file, or manipulates them further into the # type of info needed in your transport model @@ -372,17 +434,20 @@ def sample_step(dacycle, samples, statevector, obsoperator, lag, advance=False): # Add model-data mismatch to all samples, this *might* use output from the ensemble in the future?? sample.add_model_data_mismatch('None') - sampling_coords_file = os.path.join(dacycle['dir.input'], sample.get_samples_type()+'_coordinates_%s.nc' % dacycle['time.sample.stamp']) + sampling_coords_file = os.path.join( + dacycle['dir.input'], + sample.get_samples_type() + + '_coordinates_%s.nc' % dacycle['time.sample.stamp']) sample.write_sample_coords(sampling_coords_file) # Write filename to dacycle, and to output collection list - dacycle['ObsOperator.inputfile.'+sample.get_samples_type()] = sampling_coords_file + dacycle['ObsOperator.inputfile.' + + sample.get_samples_type()] = sampling_coords_file del sample # Run the observation operator - obsoperator.run_forecast_model(samples,statevector,lag,dacycle) - + obsoperator.run_forecast_model(samples, statevector, lag, dacycle) # Read forecast model samples that were written to NetCDF files by each member. Add them to the exisiting # Observation object for each sample loop. This data fill be written to file in the output folder for each sample cycle. @@ -391,12 +456,17 @@ def sample_step(dacycle, samples, statevector, obsoperator, lag, advance=False): # one file per member, some logic needs to be included to merge all files!!! for i in range(len(samples)): - if os.path.exists(dacycle['ObsOperator.inputfile.'+samples[i].get_samples_type()]): + if os.path.exists(dacycle['ObsOperator.inputfile.' + + samples[i].get_samples_type()]): samples[i].add_simulations(obsoperator.simulated_file[i]) - + else: - logging.warning("No simulations added, because input file does not exist (no samples found in obspack)") - logging.info("No simulations added, because input file does not exist (no samples found in obspack)") + logging.warning( + "No simulations added, because input file does not exist (no samples found in obspack)" + ) + logging.info( + "No simulations added, because input file does not exist (no samples found in obspack)" + ) # Now add the observations that need to be assimilated to the statevector. # Note that obs will only be added to the statevector if either this is the first step (restart=False), or lag==nlag @@ -404,56 +474,66 @@ def sample_step(dacycle, samples, statevector, obsoperator, lag, advance=False): # steps only optimize against the data at the front (lag==nlag) of the filter. This way, each observation is used only # (and at least) once # in the assimilation - if not advance: - if dacycle['time.restart'] == False or lag == int(dacycle['time.nlag']) - 1: - statevector.obs_to_assimilate += (copy.deepcopy(samples),) + if dacycle['time.restart'] == False or lag == int( + dacycle['time.nlag']) - 1: + statevector.obs_to_assimilate += (copy.deepcopy(samples), ) for sample in samples: statevector.nobs += sample.getlength() del sample - logging.info('nobs = %i' %statevector.nobs) - logging.debug("Added samples from the observation operator to the assimilated obs list in the statevector") + logging.info('nobs = %i' % statevector.nobs) + logging.debug( + "Added samples from the observation operator to the assimilated obs list in the statevector" + ) else: - statevector.obs_to_assimilate += (None,) - + statevector.obs_to_assimilate += (None, ) def invert(dacycle, statevector, optimizer): """ Perform the inverse calculation """ logging.info(header + "starting invert" + footer) - if statevector.nobs <= 1: #== 0: - logging.info('List with observations to assimilate is empty, skipping invert step and continuing without statevector update...') + if statevector.nobs <= 1: #== 0: + logging.info( + 'List with observations to assimilate is empty, skipping invert step and continuing without statevector update...' + ) return - dims = (int(dacycle['time.nlag']), - int(dacycle['da.optimizer.nmembers']), - int(dacycle.dasystem['nparameters']), - statevector.nobs) + dims = (int(dacycle['time.nlag']), int(dacycle['da.optimizer.nmembers']), + int(dacycle.dasystem['nparameters']), statevector.nobs) if 'opt.algorithm' not in dacycle.dasystem: - logging.info("There was no minimum least squares algorithm specified in the DA System rc file (key : opt.algorithm)") + logging.info( + "There was no minimum least squares algorithm specified in the DA System rc file (key : opt.algorithm)" + ) logging.info("...using serial algorithm as default...") optimizer.set_algorithm('Serial') elif dacycle.dasystem['opt.algorithm'] == 'serial': - logging.info("Using the serial minimum least squares algorithm to solve ENKF equations") + logging.info( + "Using the serial minimum least squares algorithm to solve ENKF equations" + ) optimizer.set_algorithm('Serial') elif dacycle.dasystem['opt.algorithm'] == 'bulk': - logging.info("Using the bulk minimum least squares algorithm to solve ENKF equations") + logging.info( + "Using the bulk minimum least squares algorithm to solve ENKF equations" + ) optimizer.set_algorithm('Bulk') optimizer.setup(dims) optimizer.state_to_matrix(statevector) - diagnostics_file = os.path.join(dacycle['dir.output'], 'optimizer.%s.nc' % dacycle['time.start'].strftime('%Y%m%d')) + diagnostics_file = os.path.join( + dacycle['dir.output'], + 'optimizer.%s.nc' % dacycle['time.start'].strftime('%Y%m%d')) optimizer.write_diagnostics(diagnostics_file, 'prior') optimizer.set_localization(dacycle['da.system.localization']) if optimizer.algorithm == 'Serial': #optimizer.serial_minimum_least_squares() - optimizer.serial_minimum_least_squares(int(dacycle['statevector.bg_params'])) + optimizer.serial_minimum_least_squares( + int(dacycle['statevector.bg_params'])) else: optimizer.bulk_minimum_least_squares() @@ -461,7 +541,6 @@ def invert(dacycle, statevector, optimizer): optimizer.write_diagnostics(diagnostics_file, 'optimized') - def advance(dacycle, samples, statevector, obsoperator): """ Advance the filter state to the next step """ @@ -477,28 +556,42 @@ def advance(dacycle, samples, statevector, obsoperator): dacycle.restart_filelist.extend(obsoperator.restart_filelist) dacycle.output_filelist.extend(obsoperator.output_filelist) - logging.debug("Appended ObsOperator restart and output file lists to dacycle for collection ") + logging.debug( + "Appended ObsOperator restart and output file lists to dacycle for collection " + ) # write sample output file for sample in samples: - dacycle.output_filelist.append(dacycle['ObsOperator.inputfile.'+sample.get_samples_type()]) - logging.debug("Appended Observation filename to dacycle for collection: %s"%(dacycle['ObsOperator.inputfile.'+sample.get_samples_type()])) - - sampling_coords_file = os.path.join(dacycle['dir.input'], sample.get_samples_type()+'_coordinates_%s.nc' % dacycle['time.sample.stamp']) + dacycle.output_filelist.append(dacycle['ObsOperator.inputfile.' + + sample.get_samples_type()]) + logging.debug( + "Appended Observation filename to dacycle for collection: %s" % + (dacycle['ObsOperator.inputfile.' + sample.get_samples_type()])) + + sampling_coords_file = os.path.join( + dacycle['dir.input'], + sample.get_samples_type() + + '_coordinates_%s.nc' % dacycle['time.sample.stamp']) if os.path.exists(sampling_coords_file): if sample.get_samples_type() == 'flask': - outfile = os.path.join(dacycle['dir.output'], 'sample_auxiliary_%s.nc' % dacycle['time.sample.stamp']) + outfile = os.path.join( + dacycle['dir.output'], + 'sample_auxiliary_%s.nc' % dacycle['time.sample.stamp']) sample.write_sample_auxiliary(outfile) - else: logging.warning("Sample auxiliary output not written, because input file does not exist (no samples found in obspack)") + else: + logging.warning( + "Sample auxiliary output not written, because input file does not exist (no samples found in obspack)" + ) del sample - def save_and_submit(dacycle, statevector): """ Save the model state and submit the next job """ logging.info(header + "starting save_and_submit" + footer) - filename = os.path.join(dacycle['dir.restart'], 'savestate_%s.nc' % dacycle['time.start'].strftime('%Y%m%d')) + filename = os.path.join( + dacycle['dir.restart'], + 'savestate_%s.nc' % dacycle['time.start'].strftime('%Y%m%d')) statevector.write_to_file(filename, 'opt') dacycle.output_filelist.append(filename) diff --git a/cases/icon-art-CTDAS/ctdas_patch/statevector_baseclass_icos_cities.py b/cases/icon-art-CTDAS/ctdas_patch/statevector_baseclass_icos_cities.py index 9904013a..ec5787ed 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/statevector_baseclass_icos_cities.py +++ b/cases/icon-art-CTDAS/ctdas_patch/statevector_baseclass_icos_cities.py @@ -12,7 +12,6 @@ program. If not, see .""" #!/usr/bin/env python # ct_statevector_tools.py - """ .. module:: statevector .. moduleauthor:: Wouter Peters @@ -49,6 +48,7 @@ ################### Begin Class EnsembleMember ################### + class EnsembleMember(object): """ An ensemble member object consists of: @@ -77,8 +77,9 @@ def __init__(self, membernumber): * ModelSample, will hold an :class:`~da.baseclasses.obs.Observation` object and the model samples resulting from this members' data """ - self.membernumber = membernumber # the member number - self.param_values = None # Parameter values of this member + self.membernumber = membernumber # the member number + self.param_values = None # Parameter values of this member + ################### End Class EnsembleMember ################### @@ -152,14 +153,18 @@ def setup(self, dacycle): """ self.nlag = int(dacycle['time.nlag']) - self.nmembers = int(dacycle['da.optimizer.nmembers']) #number of ensemble members, e.g. 192 for the icon case - self.nparams = int(dacycle.dasystem['nparameters']) #n_reg * n_tracers * n_categories + n_bg_params + self.nmembers = int( + dacycle['da.optimizer.nmembers'] + ) #number of ensemble members, e.g. 192 for the icon case + self.nparams = int(dacycle.dasystem['nparameters'] + ) #n_reg * n_tracers * n_categories + n_bg_params self.nobs = 0 self.grid_fn = dacycle['icon_grid_path'] - - self.obs_to_assimilate = () # empty containter to hold observations to assimilate later on - # These list objects hold the data for each time step of lag in the system. Note that the ensembles for each time step consist + self.obs_to_assimilate = ( + ) # empty containter to hold observations to assimilate later on + + # These list objects hold the data for each time step of lag in the system. Note that the ensembles for each time step consist # of lists of EnsembleMember objects, we define member 0 as the mean of the distribution and n=1,...,nmembers as the spread. self.ensemble_members = list(range(self.nlag)) @@ -169,12 +174,10 @@ def setup(self, dacycle): #msteiner: self.isOptimized = False - self.C = np.zeros((self.nparams,self.nparams)) + self.C = np.zeros((self.nparams, self.nparams)) #--------- - - - def make_new_ensemble(self, lag, covariancematrix=None,n_bg_params=0): + def make_new_ensemble(self, lag, covariancematrix=None, n_bg_params=0): """ :param lag: an integer indicating the time step in the lag order :param covariancematrix: a matrix to draw random values from @@ -188,38 +191,46 @@ def make_new_ensemble(self, lag, covariancematrix=None,n_bg_params=0): used to draw ensemblemembers from. If this argument is not passed it will ne substituted with an identity matrix of the same dimensions. - """ + """ - logging.info('msteiner: current lag: %i '%(lag)) - logging.info('msteiner: nlag; %i '%(self.nlag)) + logging.info('msteiner: current lag: %i ' % (lag)) + logging.info('msteiner: nlag; %i ' % (self.nlag)) categories = {max(lambdas)} - if np.all(self.C==0.): + if np.all(self.C == 0.): logging.info('msteiner: performing cholesky decomposition') ds_grid = xr.open_dataset(self.grid_fn) - grid_coords = np.stack([ds_grid['clat'].values, ds_grid['clon'].values], axis=-1) # Radians + grid_coords = np.stack( + [ds_grid['clat'].values, ds_grid['clon'].values], + axis=-1) # Radians distances = haversine_distances(grid_coords, grid_coords) * 6371.0 logging.info('ekoene: computed distances matrix') - covariancematrix = np.zeros((self.nparams,self.nparams), dtype=np.float32) - - {re.sub(fr'(?m)(?<={chr(10)})^', ' ', cfg.CTDAS_covariancematrix_definition.strip(), flags=re.MULTILINE)} + covariancematrix = np.zeros((self.nparams, self.nparams), + dtype=np.float32) + + { + re.sub(fr'(?m)(?<={chr(10)})^', + ' ', + cfg.CTDAS_covariancematrix_definition.strip(), + flags=re.MULTILINE) + } self.C = np.linalg.cholesky(covariancematrix) del covariancematrix logging.info('Cholesky decomposition has finished') - # Propagate mean values - newmean = np.ones(self.nparams, float) # standard value for a new time step is 1.0 + # Propagate mean values + newmean = np.ones(self.nparams, + float) # standard value for a new time step is 1.0 if lag == self.nlag - 1 and self.nlag >= 2: - newmean += 2*self.ensemble_members[lag - 1][0].param_values + newmean += 2 * self.ensemble_members[lag - 1][0].param_values newmean = newmean / 3.0 - #Propagate background mean state by 100%: - if n_bg_params>0: - newmean[self.nparams-n_bg_params:] = self.ensemble_members[lag - 1][0].param_values[self.nparams-n_bg_params:] - + if n_bg_params > 0: + newmean[self.nparams - n_bg_params:] = self.ensemble_members[ + lag - 1][0].param_values[self.nparams - n_bg_params:] ####### New forecast model for the mean: take 100% of the optimized value ####### #newmean = np.ones(self.nparams, float) # standard value for a new time step is 1.0 @@ -231,7 +242,8 @@ def make_new_ensemble(self, lag, covariancematrix=None,n_bg_params=0): #DEBUG newmean for cat in range(categories): logging.info('Category (%s) ' % str(cat + 1)) - logging.info('New mean (%s) ' % str(np.nanmean(newmean[cat:][::categories]))) + logging.info('New mean (%s) ' % + str(np.nanmean(newmean[cat:][::categories]))) # Create the first ensemble member with a deviation of 0.0 and add to list newmember = EnsembleMember(0) newmember.param_values = newmean.flatten() # no deviations @@ -244,29 +256,41 @@ def make_new_ensemble(self, lag, covariancematrix=None,n_bg_params=0): newmember = EnsembleMember(member) logging.info('pre-dot') # newmember.param_values = np.dot(self.C, rands) + newmean - newmember.param_values = np.einsum("ij, j -> i", self.C, rands) + newmean + newmember.param_values = np.einsum("ij, j -> i", self.C, + rands) + newmean logging.info('post-dot') self.ensemble_members[lag].append(newmember) - logging.info('Created parameters for ensemble member %i'%(member)) + logging.info('Created parameters for ensemble member %i' % + (member)) #DEBUG lambdas lambdas = np.array([]) for member in range(0, self.nmembers): - logging.info('Member shape (%s) ' % str(np.shape(self.ensemble_members[lag][member].param_values))) - lambdas = np.append(lambdas, self.ensemble_members[lag][member].param_values) + logging.info( + 'Member shape (%s) ' % + str(np.shape(self.ensemble_members[lag][member].param_values))) + lambdas = np.append( + lambdas, self.ensemble_members[lag][member].param_values) lambdas = np.reshape(lambdas, (self.nmembers, self.nparams)) - members_array = np.mean(lambdas, axis = 0) + members_array = np.mean(lambdas, axis=0) # logging.info('Member array shape (%s) ' % str(np.shape(members_array))) for cat in range(categories): logging.info('Category (%s) ' % str(cat + 1)) - logging.info('Lambda mean (%s) ' % str(np.nanmean(members_array[cat:][::categories]))) + logging.info('Lambda mean (%s) ' % + str(np.nanmean(members_array[cat:][::categories]))) #del C #msteiner: this line causes the "invalid pointer"-error at this point, otherwise it occurs after the code reached the end of this function - logging.info('%d new ensemble members were added to the state vector # %d' % (self.nmembers, (lag + 1))) - + logging.info( + '%d new ensemble members were added to the state vector # %d' % + (self.nmembers, (lag + 1))) - def propagate(self, dacycle, method='create_new_member', filename=None, date=None, initdir=None): + def propagate(self, + dacycle, + method='create_new_member', + filename=None, + date=None, + initdir=None): """ :rtype: None @@ -277,37 +301,53 @@ def propagate(self, dacycle, method='create_new_member', filename=None, date=Non In the future, this routine can incorporate a formal propagation of the statevector. """ - + # Remove State Vector n=1 by simply "popping" it from the list and appending a new empty list at the front. This empty list will - # hold the new ensemble for the new cycle + # hold the new ensemble for the new cycle self.ensemble_members.pop(0) self.ensemble_members.append([]) # And now create a new time step of mean + members for n=nlag if method == 'create_new_member': - date = dacycle['time.start'] + timedelta(days=(self.nlag - 0.5) * int(dacycle['time.cycle'])) + date = dacycle['time.start'] + timedelta( + days=(self.nlag - 0.5) * int(dacycle['time.cycle'])) cov = self.get_covariance(date, dacycle) - self.make_new_ensemble(self.nlag - 1, cov,int(dacycle['statevector.bg_params'])) + self.make_new_ensemble(self.nlag - 1, cov, + int(dacycle['statevector.bg_params'])) elif method == 'read_new_member': if os.path.exists(filename): - self.read_ensemble_member_from_file(filename, self.nlag-1, qual='opt', read_lag=0) + self.read_ensemble_member_from_file(filename, + self.nlag - 1, + qual='opt', + read_lag=0) else: - self.read_ensemble_member_from_file(filename, self.nlag-1, date, initdir, qual='opt', read_lag=0) + self.read_ensemble_member_from_file(filename, + self.nlag - 1, + date, + initdir, + qual='opt', + read_lag=0) elif method == 'read_mean': - date = dacycle['time.start'] + timedelta(days=(self.nlag - 0.5) * int(dacycle['time.cycle'])) + date = dacycle['time.start'] + timedelta( + days=(self.nlag - 0.5) * int(dacycle['time.cycle'])) cov = self.get_covariance(date, dacycle) if os.path.exists(filename): - meanstate = self.read_mean_from_file(filename, self.nlag-1, qual='opt') + meanstate = self.read_mean_from_file(filename, + self.nlag - 1, + qual='opt') else: - meanstate = self.read_mean_from_file(filename, self.nlag-1, date, initdir, qual='opt') + meanstate = self.read_mean_from_file(filename, + self.nlag - 1, + date, + initdir, + qual='opt') self.make_new_ensemble(self.nlag - 1, cov, meanstate) logging.info('The state vector has been propagated by one cycle') - def write_to_file(self, filename, qual): """ :param filename: the full filename for the output NetCDF file @@ -328,11 +368,13 @@ def write_to_file(self, filename, qual): if qual == 'prior': f = io.CT_CDF(filename, method='create') - logging.debug('Creating new StateVector output file (%s)' % filename) + logging.debug('Creating new StateVector output file (%s)' % + filename) #qual = 'prior' else: f = io.CT_CDF(filename, method='write') - logging.debug('Opening existing StateVector output file (%s)' % filename) + logging.debug('Opening existing StateVector output file (%s)' % + filename) #qual = 'opt' dimparams = f.add_params_dim(self.nparams) @@ -344,7 +386,7 @@ def write_to_file(self, filename, qual): mean_state = members[0].param_values savedict = f.standard_var(varname='meanstate_%s' % qual) - savedict['dims'] = dimlag + dimparams + savedict['dims'] = dimlag + dimparams savedict['values'] = mean_state savedict['count'] = n savedict['comment'] = 'this represents the mean of the ensemble' @@ -355,112 +397,157 @@ def write_to_file(self, filename, qual): data = devs - np.asarray(mean_state) savedict = f.standard_var(varname='ensemblestate_%s' % qual) - savedict['dims'] = dimlag + dimmembers + dimparams + savedict['dims'] = dimlag + dimmembers + dimparams savedict['values'] = data savedict['count'] = n - savedict['comment'] = 'this represents deviations from the mean of the ensemble' + savedict[ + 'comment'] = 'this represents deviations from the mean of the ensemble' f.add_data(savedict) f.close() - logging.info('Successfully wrote the State Vector to file (%s) ' % filename) + logging.info('Successfully wrote the State Vector to file (%s) ' % + filename) - - - def interpolate_mean_ensemble(self, initdir, date, qual='opt', readensemble=True): + def interpolate_mean_ensemble(self, + initdir, + date, + qual='opt', + readensemble=True): # deduce window length of source run: all_dates = os.listdir(initdir) for i, dstr in enumerate(all_dates): - all_dates[i] = dt.datetime.strptime(dstr,'%Y%m%d') + all_dates[i] = dt.datetime.strptime(dstr, '%Y%m%d') del i, dstr all_dates = sorted(all_dates) - ddays = (all_dates[1]-all_dates[0]).days + ddays = (all_dates[1] - all_dates[0]).days del all_dates # find dates in source directory just before and after target date found_datemin, found_datemax = False, False for d in range(ddays): datei = date - dt.timedelta(days=d) - if not found_datemin and os.path.exists(os.path.join(initdir, datei.strftime('%Y%m%d'), 'savestate_%s.nc'%datei.strftime('%Y%m%d'))): + if not found_datemin and os.path.exists( + os.path.join( + initdir, datei.strftime('%Y%m%d'), + 'savestate_%s.nc' % datei.strftime('%Y%m%d'))): datemin = datei found_datemin = True datei = date + dt.timedelta(days=d) - if not found_datemax and os.path.exists(os.path.join(initdir, datei.strftime('%Y%m%d'), 'savestate_%s.nc'%datei.strftime('%Y%m%d'))): + if not found_datemax and os.path.exists( + os.path.join( + initdir, datei.strftime('%Y%m%d'), + 'savestate_%s.nc' % datei.strftime('%Y%m%d'))): datemax = datei found_datemax = True if found_datemin and found_datemax: - print('Found datemin = %s and datemax = %s' %(datemin.strftime('%Y%m%d'), datemax.strftime('%Y%m%d'))) + print('Found datemin = %s and datemax = %s' % + (datemin.strftime('%Y%m%d'), datemax.strftime('%Y%m%d'))) break del d - logging.debug('Ensemble for %s will be interpolated from %s and %s' %(date.strftime('%Y-%m-%d'), datemin.strftime('%Y-%m-%d'),datemax.strftime('%Y-%m-%d'))) + logging.debug('Ensemble for %s will be interpolated from %s and %s' % + (date.strftime('%Y-%m-%d'), datemin.strftime('%Y-%m-%d'), + datemax.strftime('%Y-%m-%d'))) # Read ensemble from both files - filename1 = os.path.join(initdir, datemin.strftime('%Y%m%d'), 'savestate_%s.nc'%datemin.strftime('%Y%m%d')) + filename1 = os.path.join( + initdir, datemin.strftime('%Y%m%d'), + 'savestate_%s.nc' % datemin.strftime('%Y%m%d')) f = io.ct_read(filename1, 'read') - meanstate1 = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] + meanstate1 = f.get_variable('statevectormean_' + + qual) # [nlag x nparameters] if readensemble: - ensmembers1 = f.get_variable('statevectorensemble_' + qual) # [nlag x nmembers x nparameters] + ensmembers1 = f.get_variable( + 'statevectorensemble_' + + qual) # [nlag x nmembers x nparameters] f.close() - filename2 = os.path.join(initdir, datemax.strftime('%Y%m%d'), 'savestate_%s.nc'%datemax.strftime('%Y%m%d')) + filename2 = os.path.join( + initdir, datemax.strftime('%Y%m%d'), + 'savestate_%s.nc' % datemax.strftime('%Y%m%d')) f = io.ct_read(filename2, 'read') - meanstate2 = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] + meanstate2 = f.get_variable('statevectormean_' + + qual) # [nlag x nparameters] if readensemble: - ensmembers2 = f.get_variable('statevectorensemble_' + qual) # [nlag x nmembers x nparameters] + ensmembers2 = f.get_variable( + 'statevectorensemble_' + + qual) # [nlag x nmembers x nparameters] f.close() # interpolate mean and ensemble between datemin and datemax - meanstate = ((datemax-date).days/ddays)*meanstate1 + ((date-datemin).days/ddays)*meanstate2 + meanstate = ((datemax - date).days / ddays) * meanstate1 + ( + (date - datemin).days / ddays) * meanstate2 if readensemble: - ensmembers = ((datemax-date).days/ddays)*ensmembers1 + ((date-datemin).days/ddays)*ensmembers2 + ensmembers = ((datemax - date).days / ddays) * ensmembers1 + ( + (date - datemin).days / ddays) * ensmembers2 return meanstate, ensmembers else: return meanstate - - - def read_mean_from_file(self, filename, lag, date=None, initdir=None, qual='opt'): + def read_mean_from_file(self, + filename, + lag, + date=None, + initdir=None, + qual='opt'): if date is None: f = io.ct_read(filename, 'read') - meanstate = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] + meanstate = f.get_variable('statevectormean_' + + qual) # [nlag x nparameters] f.close else: - meanstate = self.interpolate_mean_ensemble(initdir, date, qual, readensemble=False) + meanstate = self.interpolate_mean_ensemble(initdir, + date, + qual, + readensemble=False) - logging.info('Successfully read the mean state vector from file (%s) ' %filename) + logging.info( + 'Successfully read the mean state vector from file (%s) ' % + filename) - return meanstate[lag,:] + return meanstate[lag, :] - - - def read_ensemble_member_from_file(self, filename, lag, date=None, initdir=None, qual='opt', read_lag=0): + def read_ensemble_member_from_file(self, + filename, + lag, + date=None, + initdir=None, + qual='opt', + read_lag=0): # if date is None we can directly read mean and ensemble members. Else we will need to read 2 ensembles and interpolate if date is None: f = io.ct_read(filename, 'read') - meanstate = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] - ensmembers = f.get_variable('statevectorensemble_' + qual) # [nlag x nmembers x nparameters] + meanstate = f.get_variable('statevectormean_' + + qual) # [nlag x nparameters] + ensmembers = f.get_variable( + 'statevectorensemble_' + + qual) # [nlag x nmembers x nparameters] f.close() else: - meanstate, ensmembers = self.interpolate_mean_ensemble(initdir, date, qual, readensemble=True) + meanstate, ensmembers = self.interpolate_mean_ensemble( + initdir, date, qual, readensemble=True) # add to statevector if not self.ensemble_members[lag] == []: self.ensemble_members[lag] = [] - logging.warning('Existing ensemble for lag=%d was removed to make place for newly read data' % (n + 1)) + logging.warning( + 'Existing ensemble for lag=%d was removed to make place for newly read data' + % (n + 1)) for m in range(self.nmembers): newmember = EnsembleMember(m) - newmember.param_values = ensmembers[read_lag, m, :].flatten() + meanstate[read_lag,:] # add the mean to the deviations to hold the full parameter values + newmember.param_values = ensmembers[read_lag, m, :].flatten( + ) + meanstate[ + read_lag, :] # add the mean to the deviations to hold the full parameter values self.ensemble_members[lag].append(newmember) - logging.info('Successfully read the State Vector for lag %s from file (%s) ' % (lag,filename)) - - - + logging.info( + 'Successfully read the State Vector for lag %s from file (%s) ' % + (lag, filename)) def read_from_file(self, filename, qual='opt'): """ @@ -490,16 +577,25 @@ def read_from_file(self, filename, qual='opt'): for n in range(self.nlag): if not self.ensemble_members[n] == []: self.ensemble_members[n] = [] - logging.warning('Existing ensemble for lag=%d was removed to make place for newly read data' % (n + 1)) + logging.warning( + 'Existing ensemble for lag=%d was removed to make place for newly read data' + % (n + 1)) for m in range(self.nmembers): newmember = EnsembleMember(m) - newmember.param_values = ensmembers[n, m, :].flatten() + meanstate[n] # add the mean to the deviations to hold the full parameter values + newmember.param_values = ensmembers[n, m, :].flatten( + ) + meanstate[ + n] # add the mean to the deviations to hold the full parameter values self.ensemble_members[n].append(newmember) - logging.info('Successfully read the State Vector from file (%s) ' % filename) + logging.info('Successfully read the State Vector from file (%s) ' % + filename) - def write_members_to_file(self, lag, outdir, endswith='.nc', obsoperator=None): + def write_members_to_file(self, + lag, + outdir, + endswith='.nc', + obsoperator=None): """ :param: lag: Which lag step of the filter to write, must lie in range [1,...,nlag] :param: outdir: Directory where to write files @@ -519,14 +615,15 @@ def write_members_to_file(self, lag, outdir, endswith='.nc', obsoperator=None): # These import statements caused a crash in netCDF4 on MacOSX. No problems on Jet though. Solution was # to do the import already at the start of the module, not just in this method. - + #import da.tools.io as io #import da.tools.io4 as io members = self.ensemble_members[lag] for mem in members: - filename = os.path.join(outdir, 'parameters.%03d%s' % (mem.membernumber, endswith)) + filename = os.path.join( + outdir, 'parameters.%03d%s' % (mem.membernumber, endswith)) ncf = io.CT_CDF(filename, method='create') dimparams = ncf.add_params_dim(self.nparams) dimgrid = ncf.add_latlon_dim() @@ -535,34 +632,39 @@ def write_members_to_file(self, lag, outdir, endswith='.nc', obsoperator=None): savedict = io.std_savedict.copy() savedict['name'] = "parametervalues" - savedict['long_name'] = "parameter_values_for_member_%d" % mem.membernumber + savedict[ + 'long_name'] = "parameter_values_for_member_%d" % mem.membernumber savedict['units'] = "unitless" - savedict['dims'] = dimparams + savedict['dims'] = dimparams savedict['values'] = data - savedict['comment'] = 'These are parameter values to use for member %d' % mem.membernumber + savedict[ + 'comment'] = 'These are parameter values to use for member %d' % mem.membernumber ncf.add_data(savedict) griddata = self.vector2grid(vectordata=data) savedict = io.std_savedict.copy() savedict['name'] = "parametermap" - savedict['long_name'] = "parametermap_for_member_%d" % mem.membernumber + savedict[ + 'long_name'] = "parametermap_for_member_%d" % mem.membernumber savedict['units'] = "unitless" - savedict['dims'] = dimgrid + savedict['dims'] = dimgrid savedict['values'] = griddata.tolist() - savedict['comment'] = 'These are gridded parameter values to use for member %d' % mem.membernumber + savedict[ + 'comment'] = 'These are gridded parameter values to use for member %d' % mem.membernumber ncf.add_data(savedict) ncf.close() - logging.debug('Successfully wrote data from ensemble member %d to file (%s) ' % (mem.membernumber, filename)) - + logging.debug( + 'Successfully wrote data from ensemble member %d to file (%s) ' + % (mem.membernumber, filename)) def get_covariance(self, date, cycleparams): pass - + + ################### End Class StateVector ################### if __name__ == "__main__": pass - diff --git a/cases/icon-art-CTDAS/ctdas_patch/template.py b/cases/icon-art-CTDAS/ctdas_patch/template.py index abb9638d..8a8a7662 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/template.py +++ b/cases/icon-art-CTDAS/ctdas_patch/template.py @@ -19,6 +19,7 @@ import sys import os import logging + sys.path.append(os.getcwd()) ################################################################################################# @@ -29,12 +30,11 @@ from da.pipelines.pipeline_icon import ensemble_smoother_pipeline, header, footer, analysis_pipeline, archive_pipeline from da.dasystems.dasystem_baseclass import DaSystem from da.platform.pizdaint import PizDaintPlatform -from da.statevectors.statevector_baseclass_icos_cities import StateVector -from da.observations.obs_class_ICOS_OCO2 import ICOSObservations, TotalColumnObservations # Here we set which observations we consider! +from da.statevectors.statevector_baseclass_icos_cities import StateVector +from da.observations.obs_class_ICOS_OCO2 import ICOSObservations, TotalColumnObservations # Here we set which observations we consider! from da.obsoperators.obsoperator_ICOS_OCO2 import ObservationOperator # Here we set the obs-operator, which should sample the same observations! from da.optimizers.optimizer_baseclass_icos_cities import Optimizer - ################################################################################################# # Parse and validate the command line options, start logging ################################################################################################# @@ -44,27 +44,26 @@ opts, args = validate_opts_args(opts, args) ################################################################################################# -# Create the Cycle Control object for this job +# Create the Cycle Control object for this job ################################################################################################# dacycle = CycleControl(opts, args) -platform = PizDaintPlatform() -dasystem = DaSystem(dacycle['da.system.rc']) +platform = PizDaintPlatform() +dasystem = DaSystem(dacycle['da.system.rc']) obsoperator = ObservationOperator(dacycle['da.system.rc']) -samples = [ICOSObservations(), TotalColumnObservations()] +samples = [ICOSObservations(), TotalColumnObservations()] statevector = StateVector() -optimizer = Optimizer() +optimizer = Optimizer() ########################################################################################## ################### ENTER THE PIPELINE WITH THE OBJECTS PASSED BY THE USER ############### ########################################################################################## +logging.info(header + "Entering Pipeline " + footer) -logging.info(header + "Entering Pipeline " + footer) - -ensemble_smoother_pipeline(dacycle, platform, dasystem, samples, statevector, obsoperator,optimizer) - +ensemble_smoother_pipeline(dacycle, platform, dasystem, samples, statevector, + obsoperator, optimizer) ########################################################################################## ################### All done, extra stuff can be added next, such as analysis @@ -72,10 +71,8 @@ sys.exit(0) -logging.info(header + "Starting analysis" + footer) +logging.info(header + "Starting analysis" + footer) -analysis_pipeline(dacycle, platform, dasystem, samples, statevector ) +analysis_pipeline(dacycle, platform, dasystem, samples, statevector) sys.exit(0) - - diff --git a/cases/icon-art-CTDAS/ctdas_patch/utilities.py b/cases/icon-art-CTDAS/ctdas_patch/utilities.py index 30e3de52..c25c064e 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/utilities.py +++ b/cases/icon-art-CTDAS/ctdas_patch/utilities.py @@ -16,12 +16,13 @@ import netCDF4 as nc import numpy as np + class utilities(object): """ Collection of utilities for wrfchem observation operator that do not depend on other CTDAS modules """ - + def __init__(self): pass @@ -53,20 +54,24 @@ def get_slicing_ids(N, nproc, nprocs): field[id0:id1, ...] """ - f0 = float(nproc)/float(nprocs) - id0 = int(np.floor(f0*N)) + f0 = float(nproc) / float(nprocs) + id0 = int(np.floor(f0 * N)) - f1 = float(nproc+1)/float(nprocs) - id1 = int(np.floor(f1*N)) + f1 = float(nproc + 1) / float(nprocs) + id1 = int(np.floor(f1 * N)) - if id0==id1: + if id0 == id1: raise ValueError("id0==id1. Probably too many processes.") return id0, id1 - - @classmethod - def cat_ncfiles(cls, path, in_arg, cat_dim, out_file, in_pattern=False, rm_original=True): + def cat_ncfiles(cls, + path, + in_arg, + cat_dim, + out_file, + in_pattern=False, + rm_original=True): """ Combine output of all processes into 1 file If in_pattern, a pattern is provided instead of a file list. @@ -89,12 +94,14 @@ def cat_ncfiles(cls, path, in_arg, cat_dim, out_file, in_pattern=False, rm_origi if in_pattern: if not isinstance(in_arg, str): - raise TypeError("in_arg must be a string if in_pattern is True.") + raise TypeError( + "in_arg must be a string if in_pattern is True.") file_pattern = in_arg in_files = glob.glob(file_pattern) else: if isinstance(in_arg, list): - raise TypeError("in_arg must be a list if in_pattern is False.") + raise TypeError( + "in_arg must be a list if in_pattern is False.") in_files = in_arg if len(in_files) == 0: @@ -114,19 +121,22 @@ def cat_ncfiles(cls, path, in_arg, cat_dim, out_file, in_pattern=False, rm_origi ncf.close() # Cat files - cmd_ = "ncrcat -h -O -d " + cat_dim + ",0,%d"%(Nobs-1) + cmd_ = "ncrcat -h -O -d " + cat_dim + ",0,%d" % (Nobs - 1) if in_pattern: cmd = cmd_ + " " + file_pattern + " " + out_file # If PIPE is used here, it gets clogged, and the process - # stops without error message (see also + # stops without error message (see also # https://thraxil.org/users/anders/posts/2008/03/13/Subprocess-Hanging-PIPE-is-your-enemy/) # Hence, piping the output to a temporary file. - proc = subprocess.Popen(cmd, shell=True, + proc = subprocess.Popen(cmd, + shell=True, stdout=tempfile.TemporaryFile(), stderr=tempfile.TemporaryFile()) else: cmdsplt = cmd_.split() + in_files + [out_file] - proc = subprocess.Popen(cmdsplt, stdout=tempfile.TemporaryFile(), stderr=tempfile.TemporaryFile()) + proc = subprocess.Popen(cmdsplt, + stdout=tempfile.TemporaryFile(), + stderr=tempfile.TemporaryFile()) cmd = " ".join(cmdsplt) proc.wait() @@ -151,7 +161,6 @@ def cat_ncfiles(cls, path, in_arg, cat_dim, out_file, in_pattern=False, rm_origi # Change back to previous directory os.chdir(cwd) - @staticmethod def check_out_err(process): """Displays stdout and stderr, returns returncode of the @@ -160,7 +169,7 @@ def check_out_err(process): # Get process messages out, err = process.communicate() - + # Print output def to_str(str_or_bytestr): """If argument is of type str, return argument. If @@ -193,7 +202,7 @@ def to_str(str_or_bytestr): logging.error(line.rstrip()) return process.returncode - + @classmethod def get_index_groups(cls, *args): """ @@ -203,22 +212,22 @@ def get_index_groups(cls, *args): Dictionary of lists of indices that have the same combination of input values. """ - + try: # If pandas is available, it makes a pandas DataFrame and # uses its groupby-function. import pandas as pd - + args_array = np.array(args).transpose() df = pd.DataFrame(args_array) groups = df.groupby(list(range(len(args)))).indices - + except ImportError: # If pandas is not available, use an own implementation of groupby. # Recursive implementation. It's fast. args_array = np.array(args).transpose() groups = cls._group(args_array) - + return groups @classmethod @@ -240,18 +249,18 @@ def _group(cls, a): The keys are the unique combinations of indices (rows of a), the values are the indices of the rows of a equal the key. """ - + # This is a recursive function: It makes groups according to the # first columnm, then calls itself with the remaining columns. # Some index juggling. - + # Group according to first column UI = list(set(a[:, 0])) groups0 = dict() for ui in UI: # Key must be a tuple groups0[(ui, )] = [i for i, x in enumerate(a[:, 0]) if x == ui] - + if a.shape[1] == 1: # If the array only has one column, we're done return groups0 @@ -263,17 +272,23 @@ def _group(cls, a): subgroups_ui = cls._group(a[groups0[(ui, )], 1:]) # Now the index juggling: Add the keys together and # locate values in the original array. - for key in list(subgroups_ui.keys()): + for key in list(subgroups_ui.keys()): # Get indices of bigger array - subgroups_ui[key] = [groups0[(ui, )][n] for n in subgroups_ui[key]] + subgroups_ui[key] = [ + groups0[(ui, )][n] for n in subgroups_ui[key] + ] # Add the keys together groups[(ui, ) + key] = subgroups_ui[key] - - return groups + return groups @staticmethod - def apply_by_group(func, array, groups, grouped_args=None, *args, **kwargs): + def apply_by_group(func, + array, + groups, + grouped_args=None, + *args, + **kwargs): """ Apply function 'func' to a numpy array by groups of indices. 'groups' can be a list of lists or a dictionary with lists as @@ -292,28 +307,29 @@ def apply_by_group(func, array, groups, grouped_args=None, *args, **kwargs): Output: array([0.5, 2. ]) """ - + shape_in = array.shape shape_out = list(shape_in) shape_out[0] = len(groups) array_out = np.ndarray(shape_out, dtype=array.dtype) - + if type(groups) == list: # Make a dictionary groups = {{n: groups[n] for n in range(len(groups))}} - + if not grouped_args is None: kwargs0 = copy.deepcopy(kwargs) for n in range(len(groups)): k = list(groups.keys())[n] - + # Add additional arguments that need to be grouped to kwargs if not grouped_args is None: kwargs = copy.deepcopy(kwargs0) for ka, v in grouped_args.items(): kwargs[ka] = v[groups[k], ...] - - array_out[n, ...] = np.apply_along_axis(func, 0, array[groups[k], ...], *args, **kwargs) - - return array_out + array_out[n, ...] = np.apply_along_axis(func, 0, array[groups[k], + ...], *args, + **kwargs) + + return array_out diff --git a/cases/icon-art-CTDAS2/ctdas_patch/icon_helper.py b/cases/icon-art-CTDAS2/ctdas_patch/icon_helper.py index 2020d30d..10922adc 100644 --- a/cases/icon-art-CTDAS2/ctdas_patch/icon_helper.py +++ b/cases/icon-art-CTDAS2/ctdas_patch/icon_helper.py @@ -21,7 +21,6 @@ # pylint: disable=E1136 # pylint: disable=E1101 - import os import shutil import re @@ -47,9 +46,10 @@ class ICON_Helper(object): """Contains helper functions for sampling WRF-Chem""" + def __init__(self, settings): self.settings = settings - + #def __init__(self): # Use this part for offline testing # pass @@ -58,7 +58,7 @@ def validate_settings(self, needed_items=[]): This is based on WRFChemOO._validate_rc """ - if len(needed_items)==0: + if len(needed_items) == 0: return for key in needed_items: @@ -66,7 +66,6 @@ def validate_settings(self, needed_items=[]): msg = "Missing a required value in settings: %s" % key raise IOError(msg) - @staticmethod def get_pressure_boundaries_paxis(p_axis, p_surf): """ @@ -80,7 +79,7 @@ def get_pressure_boundaries_paxis(p_axis, p_surf): ------ Pressure at layer boundaries """ - + #pb = np.array([float("nan")]*(len(p_axis)+1)) #pb[0] = p_surf # @@ -88,12 +87,13 @@ def get_pressure_boundaries_paxis(p_axis, p_surf): # pb[nl+1] = pb[nl] + 2*(p_axis[nl] - pb[nl]) # ^ commented out by David coz it didn't work # v Added by David - p_full = np.insert(p_axis, 0, psurf, axis=1) # Insert p_surf to the first index - pb = np.array([float("nan")]*(len(p_axis)+1)) + p_full = np.insert(p_axis, 0, psurf, + axis=1) # Insert p_surf to the first index + pb = np.array([float("nan")] * (len(p_axis) + 1)) pb[0] = p_surf - for nl in range(len(pb)-1): - pb[nl+1] = 0.5*( p_full[nl] + p_full[nl+1] ) + for nl in range(len(pb) - 1): + pb[nl + 1] = 0.5 * (p_full[nl] + p_full[nl + 1]) return pb @@ -124,8 +124,7 @@ def get_pressure_boundaries_znw(znw, p_surf, p_top): See also comments in code. """ - return znw*(p_surf-p_top) + p_top - + return znw * (p_surf - p_top) + p_top @staticmethod def get_int_coefs(pb_ret, pb_mod, level_def): @@ -194,7 +193,7 @@ def get_int_coefs(pb_ret, pb_mod, level_def): coefs = get_int_coefs(pb_ret, pb_mod, "layer_average") retrieval_profile = np.matmul(coefs, model_profile) """ - + if level_def == "layer_average": # This code assumes that WRF variables are constant in # layers, but they are defined on levels. This can be seen @@ -230,92 +229,91 @@ def get_int_coefs(pb_ret, pb_mod, level_def): # would be more accurate to do the piecewise-linear # interpolation and the output matrix will have 1 more # value in each dimension. - + # Calculate integration weights by weighting with layer # thickness. This assumes that both axes are ordered # psurf to ptop. - coefs = np.ndarray(shape=(len(pb_ret)-1, len(pb_mod)-1)) + coefs = np.ndarray(shape=(len(pb_ret) - 1, len(pb_mod) - 1)) coefs[:] = 0. - + # Extend the model pressure grid if retrieval encompasses # more. pb_mod_tmp = copy.deepcopy(pb_mod) - + # In case the retrieval pressure is higher than the model # surface pressure, extend the lowest model layer. if pb_mod_tmp[0] < pb_ret[0]: pb_mod_tmp[0] = pb_ret[0] - + # In case the model doesn't extend as far as the retrieval, # extend the upper model layer upwards. if pb_mod_tmp[-1] > pb_ret[-1]: pb_mod_tmp[-1] = pb_ret[-1] - + # For each retrieval layer, this loop computes which # proportion falls into each model layer. - for nret in range(len(pb_ret)-1): - + for nret in range(len(pb_ret) - 1): + # 1st model pressure boundary index = the one before the # first boundary with lower pressure than high-pressure # retrieval layer boundary. model_lower = pb_mod_tmp < pb_ret[nret] id_model_lower = model_lower.nonzero()[0] - id_min = id_model_lower[0]-1 - + id_min = id_model_lower[0] - 1 + # Last model pressure boundary index = the last one with # higher pressure than low-pressure retrieval layer # boundary. - model_higher = pb_mod_tmp > pb_ret[nret+1] - + model_higher = pb_mod_tmp > pb_ret[nret + 1] + id_model_higher = model_higher.nonzero()[0] - + if len(id_model_higher) == 0: #id_max = id_min raise ValueError("This shouldn't happen. Debug.") else: id_max = id_model_higher[-1] - + # By the way, in case there is no model level with # higher pressure than the next retrieval level, # id_max must be the same as id_min. - + # For each model layer, find out how much of it makes up this # retrieval layer - for nmod in range(id_min, id_max+1): + for nmod in range(id_min, id_max + 1): if (nmod == id_min) & (nmod != id_max): # Part of 1st model layer that falls within # retrieval layer - coefs[nret, nmod] = pb_ret[nret] - pb_mod_tmp[nmod+1] + coefs[nret, nmod] = pb_ret[nret] - pb_mod_tmp[nmod + 1] elif (nmod != id_min) & (nmod == id_max): # Part of last model layer that falls within # retrieval layer - coefs[nret, nmod] = pb_mod_tmp[nmod] - pb_ret[nret+1] + coefs[nret, nmod] = pb_mod_tmp[nmod] - pb_ret[nret + 1] elif (nmod == id_min) & (nmod == id_max): # id_min = id_max, i.e. model layer encompasses # retrieval layer - coefs[nret, nmod] = pb_ret[nret] - pb_ret[nret+1] + coefs[nret, nmod] = pb_ret[nret] - pb_ret[nret + 1] else: # Retrieval layer encompasses model layer - coefs[nret, nmod] = pb_mod_tmp[nmod] - pb_mod_tmp[nmod+1] - - coefs[nret, :] = coefs[nret, :]/sum(coefs[nret, :]) - + coefs[nret, + nmod] = pb_mod_tmp[nmod] - pb_mod_tmp[nmod + 1] + + coefs[nret, :] = coefs[nret, :] / sum(coefs[nret, :]) + # I tested the code with many cases, but I'm only 99.9% sure # it works for all input. Hence a test here that the # coefficients sum to 1 and dump the data if not. sum_ = np.abs(coefs.sum(1) - 1) - if np.any(sum_ > 2.*np.finfo(sum_.dtype).eps): - dump = dict(pb_ret=pb_ret, - pb_mod=pb_mod, - level_def=level_def) + if np.any(sum_ > 2. * np.finfo(sum_.dtype).eps): + dump = dict(pb_ret=pb_ret, pb_mod=pb_mod, level_def=level_def) fp = "int_coefs_dump.pkl" with open(fp, "w") as f: pickle.dump(dump, f, 0) - + msg_fmt = "Something doesn't sum to 1. Arguments dumped to: %s" raise ValueError(msg_fmt % fp) - - elif level_def=="pressure_boundary": + + elif level_def == "pressure_boundary": #msg = "level_def is pressure_boundary. Implementation not complete." ##logging.error(msg) #raise ValueError(msg) @@ -324,36 +322,38 @@ def get_int_coefs(pb_ret, pb_mod, level_def): # Go back to pressure midpoints for model... # Change this line to p_mod = pb_mod for z-staggered # variables - p_mod = pb_mod[1:] - 0.5*np.diff(pb_mod) # Interpolate linearly in pressure space - - coefs = np.ndarray(shape=(len(pb_ret), len(pb_mod)-1)) + p_mod = pb_mod[1:] - 0.5 * np.diff( + pb_mod) # Interpolate linearly in pressure space + + coefs = np.ndarray(shape=(len(pb_ret), len(pb_mod) - 1)) coefs[:] = 0. - + # For each retrieval pressure level, compute linear # interpolation coefficients for nret in range(len(pb_ret)): nmod_list = (p_mod < pb_ret[nret]).nonzero()[0] - if(len(nmod_list)>0): + if (len(nmod_list) > 0): nmod = nmod_list[0] - 1 - if nmod==-1: + if nmod == -1: # Constant extrapolation at surface nmod = 0 coef = 1. else: # Normal case: - coef = (pb_ret[nret]-p_mod[nmod+1])/(p_mod[nmod]-p_mod[nmod+1]) + coef = (pb_ret[nret] - p_mod[nmod + 1]) / ( + p_mod[nmod] - p_mod[nmod + 1]) else: # Constant extrapolation at atmosphere top - nmod = len(p_mod)-2 - coef=0. - + nmod = len(p_mod) - 2 + coef = 0. + coefs[nret, nmod] = coef - coefs[nret, nmod+1] = 1.-coef - + coefs[nret, nmod + 1] = 1. - coef + else: msg = "Unknown level_def: " + level_def raise ValueError(msg) - + return coefs @staticmethod @@ -365,13 +365,13 @@ def get_pressure_weighting_function(pressure_boundaries, rule): - connor2008 (not implemented) """ if rule == 'simple': - pwf = np.abs(np.diff(pressure_boundaries)/np.ptp(pressure_boundaries)) + pwf = np.abs( + np.diff(pressure_boundaries) / np.ptp(pressure_boundaries)) else: raise NotImplementedError("Rule %s not implemented" % rule) return pwf - ### David: Original function from ctdas-wrf ### ### Keeping here as reference. ### @@ -418,7 +418,8 @@ def sample_total_columns(self, dat, loc, fields_list): """ # Initialize output - tc = np.ndarray(shape=(len(dat["prior"]), len(fields_list)), dtype=float) + tc = np.ndarray(shape=(len(dat["prior"]), len(fields_list)), + dtype=float) tc[:] = float("nan") # Process by domain @@ -433,13 +434,16 @@ def sample_total_columns(self, dat, loc, fields_list): # Coordinates to process idt = idd[np.nonzero(loc["id_t"][idd] == time_id)[0]] # Get tracer ensemble profiles - profiles = self._read_and_intrp_v(loc, fields_list, time_id, idt) + profiles = self._read_and_intrp_v(loc, fields_list, time_id, + idt) # List, len=len(fields_list), shape of each: (len(idt),nz) # Get pressure axis: #paxis = self.read_and_intrp(wh_names, id_ts, frac_t, id_xy, "P_HYD")/1e2 # Pa -> hPa - psurf = self._read_and_intrp_v(loc, ["PSFC"], time_id, idt)[0]/1.e2 # Pa -> hPa + psurf = self._read_and_intrp_v(loc, ["PSFC"], time_id, + idt)[0] / 1.e2 # Pa -> hPa # Shape: (len(idt),) - ptop = float(self.namelist["domains"]["p_top_requested"])/1.e2 + ptop = float( + self.namelist["domains"]["p_top_requested"]) / 1.e2 # Shape: (len(idt),) znw = self._read_and_intrp_v(loc, ["ZNW"], time_id, idt)[0] #Shape:(len(idt),nz) @@ -449,7 +453,8 @@ def sample_total_columns(self, dat, loc, fields_list): for nidt in range(len(idt)): nobs = idt[nidt] # Construct model pressure layer boundaries - pb_mod = self.get_pressure_boundaries_znw(znw[nidt, :], psurf[nidt], ptop) + pb_mod = self.get_pressure_boundaries_znw( + znw[nidt, :], psurf[nidt], ptop) if (np.diff(pb_mod) >= 0).any(): msg = ("Model pressure boundaries for observation %d " + \ @@ -464,11 +469,13 @@ def sample_total_columns(self, dat, loc, fields_list): # but with an averaging kernel: # Use wrf's surface and top pressure nlayers = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) + pb_ret = np.linspace(psurf[nidt], ptop, + nlayers + 1) else: nlayers = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) - # Below commented out by David + pb_ret = np.linspace(psurf[nidt], ptop, + nlayers + 1) + # Below commented out by David # Because somehow doesn't work #pb_ret = self.get_pressure_boundaries_paxis( # dat["pressure_levels"][nobs], @@ -487,37 +494,43 @@ def sample_total_columns(self, dat, loc, fields_list): msg = ("Retrieval pressure boundaries for " + \ "observation %d are not monotonically " + \ "decreasing! Investigate.") % nobs - print('pb_ret[:]: %s, np.diff(pb_ret): %s' %(pb_ret[:], np.diff(pb_ret))) + print('pb_ret[:]: %s, np.diff(pb_ret): %s' % + (pb_ret[:], np.diff(pb_ret))) raise ValueError(msg) # Get vertical integration coefficients (i.e. to # "interpolate" from model to retrieval grid) - coef_matrix = self.get_int_coefs(pb_ret, pb_mod, dat["level_def"][nobs]) + coef_matrix = self.get_int_coefs(pb_ret, pb_mod, + dat["level_def"][nobs]) # Model retrieval with averaging kernel and prior profile if "pressure_weighting_function" in list(dat.keys()): pwf = dat["pressure_weighting_function"][nobs] - if (not "pressure_weighting_function" in list(dat.keys())) or np.any(np.isnan(pwf)): + if (not "pressure_weighting_function" in list( + dat.keys())) or np.any(np.isnan(pwf)): # Construct pressure weighting function from # pressure boundaries - pwf = self.get_pressure_weighting_function(pb_ret, rule="simple") - + pwf = self.get_pressure_weighting_function( + pb_ret, rule="simple") + # Compute pressure-weighted averaging kernel - avpw = pwf*dat["averaging_kernel"][nobs] + avpw = pwf * dat["averaging_kernel"][nobs] # Get prior prior_col = dat["prior"][nobs] prior_profile = dat["prior_profile"][nobs] - if np.isnan(prior_col): # compute prior + if np.isnan(prior_col): # compute prior prior_col = np.dot(pwf, prior_profile) # Compute total columns for nf in range(len(fields_list)): # Integrate model profile - profile_intrp = np.matmul(coef_matrix, profiles[nf][nidt, :]) + profile_intrp = np.matmul(coef_matrix, + profiles[nf][nidt, :]) # Model retrieval - tc[nobs, nf] = prior_col + np.dot(avpw, profile_intrp - prior_profile) + tc[nobs, nf] = prior_col + np.dot( + avpw, profile_intrp - prior_profile) # Test phase: save pb_ret, pb_mod, coef_matrix, # one profile for manual checking @@ -534,21 +547,22 @@ def sample_total_columns(self, dat, loc, fields_list): # Average over footprint if self.settings["footprint_samples_dim"] > 1: indices = utilities.get_index_groups(dat["sounding_id"]) - + # Make sure that this is correct: i know the number of indices lens = [len(group) for group in list(indices.values())] correct_len = self.settings["footprint_samples_dim"]**2 if np.any([len_ != correct_len for len_ in set(lens)]): - raise ValueError("Not all footprints have %d samples" %correct_len) + raise ValueError("Not all footprints have %d samples" % + correct_len) # Ok, paranoid mode, also confirm that the indices are what I # think they are: consecutive numbers ranges = [np.ptp(group) for group in list(indices.values())] if np.any([ptp != correct_len for ptp in set(ranges)]): raise ValueError("Not all footprints have consecutive samples") - + tc_original = copy.deepcopy(tc) tc = utilities.apply_by_group(np.average, tc_original, indices) - + return tc ### David: Original function from ctdas-wrf ### @@ -585,18 +599,21 @@ def _read_and_intrp_v(loc, fields_list, time_id, idp): # Check we were really called with observations for just one domain domains = set(loc["domain"][idp]) if len(domains) > 1: - raise ValueError("I can only operate on idp with identical domains.") + raise ValueError( + "I can only operate on idp with identical domains.") dom = domains.pop() # Select input files - id_file0 = bisect.bisect_right(loc["file_start_time_indices"][dom], time_id) - 1 - id_file1 = bisect.bisect_right(loc["file_start_time_indices"][dom], time_id+1) - 1 + id_file0 = bisect.bisect_right(loc["file_start_time_indices"][dom], + time_id) - 1 + id_file1 = bisect.bisect_right(loc["file_start_time_indices"][dom], + time_id + 1) - 1 if id_file0 < 0 or id_file1 < 0: raise ValueError("This shouldn't happen.") # Get time id in file id_t_file0 = time_id - loc["file_start_time_indices"][dom][id_file0] - id_t_file1 = time_id+1 - loc["file_start_time_indices"][dom][id_file1] + id_t_file1 = time_id + 1 - loc["file_start_time_indices"][dom][id_file1] # Open files nc0 = nc.Dataset(loc["files"][dom][id_file0], "r") @@ -623,7 +640,8 @@ def _read_and_intrp_v(loc, fields_list, time_id, idp): var0 = field0[0, :, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] var1 = field1[0, :, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] # Repeat frac_t for profile size - frac_t_ = np.array(loc["frac_t"][idp]).reshape((len(idp), 1)).repeat(var0.shape[1], 1) + frac_t_ = np.array(loc["frac_t"][idp]).reshape( + (len(idp), 1)).repeat(var0.shape[1], 1) elif len(field0.shape) == 3: # var0 will have shape (len(idp),) var0 = field0[0, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] @@ -633,14 +651,16 @@ def _read_and_intrp_v(loc, fields_list, time_id, idp): # var0 will have shape (len(idp),len(profile)) # This is for ZNW, which is saved as (time_coordinate, # vertical_coordinate) - var0 = field0[[0]*len(idp), :] - var1 = field1[[0]*len(idp), :] - frac_t_ = np.array(loc["frac_t"][idp]).reshape((len(idp), 1)).repeat(var0.shape[1], 1) + var0 = field0[[0] * len(idp), :] + var1 = field1[[0] * len(idp), :] + frac_t_ = np.array(loc["frac_t"][idp]).reshape( + (len(idp), 1)).repeat(var0.shape[1], 1) else: - raise ValueError("Can't deal with field with %d dimensions." % len(field0.shape)) + raise ValueError("Can't deal with field with %d dimensions." % + len(field0.shape)) # Interpolate in time - var_intrp_l.append(var0*frac_t_ + var1*(1. - frac_t_)) + var_intrp_l.append(var0 * frac_t_ + var1 * (1. - frac_t_)) nc0.close() nc1.close() @@ -657,27 +677,30 @@ def read_sampling_coords(sampling_coords_file, id0=None, id1=None): if id1 is None: id1 = len(ncf.dimensions['soundings']) - dat = dict( - sounding_id=np.array(ncf.variables["sounding_id"][id0:id1]), - date=ncf.variables["date"][id0:id1], - latitude=np.array(ncf.variables["latitude"][id0:id1]), - longitude=np.array(ncf.variables["longitude"][id0:id1]), - latc_0=np.array(ncf.variables["latc_0"][id0:id1]), - latc_1=np.array(ncf.variables["latc_1"][id0:id1]), - latc_2=np.array(ncf.variables["latc_2"][id0:id1]), - latc_3=np.array(ncf.variables["latc_3"][id0:id1]), - lonc_0=np.array(ncf.variables["lonc_0"][id0:id1]), - lonc_1=np.array(ncf.variables["lonc_1"][id0:id1]), - lonc_2=np.array(ncf.variables["lonc_2"][id0:id1]), - lonc_3=np.array(ncf.variables["lonc_3"][id0:id1]), - prior=np.array(ncf.variables["prior"][id0:id1]), - prior_profile=np.array(ncf.variables["prior_profile"][id0:id1,]), - averaging_kernel=np.array(ncf.variables["averaging_kernel"][id0:id1]), - pressure_levels=np.array(ncf.variables["pressure_levels"][id0:id1]), - pressure_weighting_function=np.array(ncf.variables["pressure_weighting_function"][id0:id1]), - level_def=ncf.variables["level_def"][id0:id1], - psurf=np.array(ncf.variables["psurf"][id0:id1]) - ) + dat = dict(sounding_id=np.array(ncf.variables["sounding_id"][id0:id1]), + date=ncf.variables["date"][id0:id1], + latitude=np.array(ncf.variables["latitude"][id0:id1]), + longitude=np.array(ncf.variables["longitude"][id0:id1]), + latc_0=np.array(ncf.variables["latc_0"][id0:id1]), + latc_1=np.array(ncf.variables["latc_1"][id0:id1]), + latc_2=np.array(ncf.variables["latc_2"][id0:id1]), + latc_3=np.array(ncf.variables["latc_3"][id0:id1]), + lonc_0=np.array(ncf.variables["lonc_0"][id0:id1]), + lonc_1=np.array(ncf.variables["lonc_1"][id0:id1]), + lonc_2=np.array(ncf.variables["lonc_2"][id0:id1]), + lonc_3=np.array(ncf.variables["lonc_3"][id0:id1]), + prior=np.array(ncf.variables["prior"][id0:id1]), + prior_profile=np.array(ncf.variables["prior_profile"][ + id0:id1, + ]), + averaging_kernel=np.array( + ncf.variables["averaging_kernel"][id0:id1]), + pressure_levels=np.array( + ncf.variables["pressure_levels"][id0:id1]), + pressure_weighting_function=np.array( + ncf.variables["pressure_weighting_function"][id0:id1]), + level_def=ncf.variables["level_def"][id0:id1], + psurf=np.array(ncf.variables["psurf"][id0:id1])) ncf.close() @@ -698,7 +721,7 @@ def write_simulated_columns(obs_id, simulated, nmembers, outfile): f = io.CT_CDF(outfile, method="create") dimid = f.createDimension("sounding_id", size=None) - dimid = ("sounding_id",) + dimid = ("sounding_id", ) savedict = io.std_savedict.copy() savedict["name"] = "sounding_id" savedict["dtype"] = "int64" @@ -710,7 +733,7 @@ def write_simulated_columns(obs_id, simulated, nmembers, outfile): f.add_data(savedict, nsets=0) dimmember = f.createDimension("nmembers", size=nmembers) - dimmember = ("nmembers",) + dimmember = ("nmembers", ) savedict = io.std_savedict.copy() savedict["name"] = "column_modeled" savedict["dtype"] = "float" @@ -730,7 +753,7 @@ def save_file_with_timestamp(file_path, out_dir, suffix=""): new_name = os.path.basename(file_path) + suffix + nowstamp new_path = os.path.join(out_dir, new_name) shutil.copy2(file_path, new_path) - + ################################################### # Here are some adaptations written by David Ho @@ -750,20 +773,18 @@ def get_icon_filenames(self, glob_pattern): files = np.sort(files).tolist() return files - @staticmethod def times_in_icon_file(ds_icon): """ Returns the times in netCDF4.Dataset ncf as datetime object """ - times_nc = pd.to_datetime(ds_icon["time"].values, format='date_format') + times_nc = pd.to_datetime(ds_icon["time"].values, format='date_format') #times_dtm = pd.to_datetime(ds_icon["time"].values, format='date_format') times_str = str(times_nc.strftime('%Y-%m-%d_%H:%M:%S')[0]) times_dtm = dt.datetime.strptime(times_str, "%Y-%m-%d_%H:%M:%S") - + return times_dtm - - + def icon_times(self, file_list): """Read all times in a list of icon files @@ -775,21 +796,24 @@ def icon_times(self, file_list): #times = [] times = list() - start_indices = np.ndarray( (len(file_list), ), int ) - for file in range( len(file_list) ): - ds = xr.open_dataset( file_list[file] ) + start_indices = np.ndarray((len(file_list), ), int) + for file in range(len(file_list)): + ds = xr.open_dataset(file_list[file]) times_this = self.times_in_icon_file(ds) start_indices[file] = len(times) #times += times_this times.append(times_this) #ncf.close() - + return times, start_indices - + ### David: Too slow, no longer needed ### ### To be deleted ### @staticmethod - def fetch_weight_and_neighbor_cells_Serial(gridinfo, latitudes_array, longitudes_array, z_info=None): + def fetch_weight_and_neighbor_cells_Serial(gridinfo, + latitudes_array, + longitudes_array, + z_info=None): """ Provide Grid info of your ICON grid, see icon_sampler. Given lat/lon, calculates the distances then: @@ -808,34 +832,35 @@ def fetch_weight_and_neighbor_cells_Serial(gridinfo, latitudes_array, longitudes """ # Libraries for this function: from math import sin, cos, sqrt, atan2, radians - + # Initialize - nn_sel_list = np.zeros( (len(latitudes_array), gridinfo.nn) ).astype(int) # indexes must be integers - u_list = np.zeros( (len(latitudes_array), gridinfo.nn) ) - - + nn_sel_list = np.zeros( + (len(latitudes_array), + gridinfo.nn)).astype(int) # indexes must be integers + u_list = np.zeros((len(latitudes_array), gridinfo.nn)) + # Loop over lat/lon array to collect. #### This loop takes too long, needs to parallelize!!! - for index in np.arange( len(latitudes_array) ): + for index in np.arange(len(latitudes_array)): # For debugging... #print('Calculating index: %s' %index) - - latitudes = latitudes_array[index] + + latitudes = latitudes_array[index] longitudes = longitudes_array[index] - + # For debugging... #print('Lat: %s, Lon: %s' %(latitudes, longitudes)) # Initialize: - nn_sel = np.zeros(gridinfo.nn) # Index of neighbor cells - u = np.zeros(gridinfo.nn) # Weights for neighbor cells + nn_sel = np.zeros(gridinfo.nn) # Index of neighbor cells + u = np.zeros(gridinfo.nn) # Weights for neighbor cells - R = 6373.0 # approximate radius of earth in km + R = 6373.0 # approximate radius of earth in km # This step is used for filtering obs outside of domain. # However, in the satellite pre-processing step, we will make sure all obs are in the domain! # vvv Therefore, skipped... vvv - + #if (radians(longitudes)np.nanmax(gridinfo.clon)): # u[:] = np.nan # return np.zeros((gridinfo.nn)), np.zeros((gridinfo.nn)).astype(int), np.zeros((gridinfo.nn)).astype(int), nn_sel[:], u[:] @@ -850,7 +875,7 @@ def fetch_weight_and_neighbor_cells_Serial(gridinfo, latitudes_array, longitudes #% """FIND "N" CLOSEST CENTERS""" - distances = np.zeros( (len(gridinfo.clon))) + distances = np.zeros((len(gridinfo.clon))) for icell in np.arange(len(gridinfo.clon)): lat2 = gridinfo.clat[icell] lon2 = gridinfo.clon[icell] @@ -859,27 +884,29 @@ def fetch_weight_and_neighbor_cells_Serial(gridinfo, latitudes_array, longitudes a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2 c = 2 * atan2(sqrt(a), sqrt(1 - a)) distances[icell] = R * c - nn_sel[:] = [x for _, x in sorted(zip(distances,np.arange(len(gridinfo.clon))))][0:gridinfo.nn] - nn_sel = nn_sel.astype(int) + nn_sel[:] = [ + x for _, x in sorted( + zip(distances, np.arange(len(gridinfo.clon)))) + ][0:gridinfo.nn] + nn_sel = nn_sel.astype(int) + + u[:] = [1. / distances[y] for y in nn_sel] - u[:] = [1./distances[y] for y in nn_sel] - nn_sel_list[index] = nn_sel[:] - u_list[index] = u - + u_list[index] = u + # For debugging... #print('Done, added NS:%s and U:%s' %(nn_sel, u[:]) ) - + # End of loop return nn_sel_list, u_list - ### David: Too slow, no longer needed ### ### To be deleted ### @staticmethod def fetch_weight_and_neighbor_cells_Parallel(args): - #def fetch_weight_and_neighbor_cells_Parallel(idx, gridinfo, latitudes, longitudes): + #def fetch_weight_and_neighbor_cells_Parallel(idx, gridinfo, latitudes, longitudes): """ Provide Grid info of your ICON grid, see icon_sampler. Given lat/lon, calculates the distances then: @@ -896,20 +923,21 @@ def fetch_weight_and_neighbor_cells_Parallel(args): - 1D-array containing the nearest neighbor indexes - 1D-array containing the weights for the indexes """ - - idx = args[0] - gridinfo = args[1] - latitudes = args[2] + + idx = args[0] + gridinfo = args[1] + latitudes = args[2] longitudes = args[3] - + # Libraries for this function: from math import sin, cos, sqrt, atan2, radians - + # Initialize: - nn_sel = np.zeros(gridinfo.nn).astype(int) # Index of neighbor cells, # indexes must be integers - u = np.zeros(gridinfo.nn) # Weights for neighbor cells + nn_sel = np.zeros(gridinfo.nn).astype( + int) # Index of neighbor cells, # indexes must be integers + u = np.zeros(gridinfo.nn) # Weights for neighbor cells - R = 6373.0 # approximate radius of earth in km + R = 6373.0 # approximate radius of earth in km #% lat1 = radians(latitudes[idx]) @@ -917,7 +945,7 @@ def fetch_weight_and_neighbor_cells_Parallel(args): #% """FIND "N" CLOSEST CENTERS""" - distances = np.zeros( (len(gridinfo.clon))) + distances = np.zeros((len(gridinfo.clon))) for icell in np.arange(len(gridinfo.clon)): lat2 = gridinfo.clat[icell] lon2 = gridinfo.clon[icell] @@ -926,11 +954,13 @@ def fetch_weight_and_neighbor_cells_Parallel(args): a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2 c = 2 * atan2(sqrt(a), sqrt(1 - a)) distances[icell] = R * c - nn_sel[:] = [x for _, x in sorted(zip(distances,np.arange(len(gridinfo.clon))))][0:gridinfo.nn] - nn_sel = nn_sel.astype(int) + nn_sel[:] = [ + x for _, x in sorted(zip(distances, np.arange(len(gridinfo.clon)))) + ][0:gridinfo.nn] + nn_sel = nn_sel.astype(int) + + u[:] = [1. / distances[y] for y in nn_sel] - u[:] = [1./distances[y] for y in nn_sel] - #return nn_sel[:], u return np.array(nn_sel[:], dtype=int), np.array(u) @@ -946,16 +976,26 @@ def get_divisible_hours_string(datetime_obj, hours=3): # Check if the hour is divisible by N hours if hour % hours == 0: # If divisible, get the current hour and the next hour - current_hour = datetime_obj.replace(minute=0, second=0, microsecond=0) + current_hour = datetime_obj.replace(minute=0, + second=0, + microsecond=0) hour_above = current_hour + timedelta(hours=hours) - return [current_hour.strftime('%Y%m%d%H'), hour_above.strftime('%Y%m%d%H')] + return [ + current_hour.strftime('%Y%m%d%H'), + hour_above.strftime('%Y%m%d%H') + ] else: # If not divisible, get the hour below and above - hour_below = datetime_obj.replace(hour=hour - (hour % hours), minute=0, second=0, microsecond=0) + hour_below = datetime_obj.replace(hour=hour - (hour % hours), + minute=0, + second=0, + microsecond=0) hour_above = hour_below + timedelta(hours=hours) - return [hour_below.strftime('%Y%m%d%H'), hour_above.strftime('%Y%m%d%H')] + return [ + hour_below.strftime('%Y%m%d%H'), + hour_above.strftime('%Y%m%d%H') + ] - @staticmethod def _read_and_intrp_v_ICON(loc, fields_list, time_id, idp): """ @@ -988,31 +1028,33 @@ def _read_and_intrp_v_ICON(loc, fields_list, time_id, idp): var_intrp_l = list() # Select input files - id_file0 = bisect.bisect_right(loc["file_start_time_indices"], time_id) - 1 - id_file1 = bisect.bisect_right(loc["file_start_time_indices"], time_id+1) - 1 + id_file0 = bisect.bisect_right(loc["file_start_time_indices"], + time_id) - 1 + id_file1 = bisect.bisect_right(loc["file_start_time_indices"], + time_id + 1) - 1 if id_file0 < 0 or id_file1 < 0: raise ValueError("This shouldn't happen.") # Get time id in file - id_t_file0 = time_id - loc["file_start_time_indices"][id_file0] - id_t_file1 = time_id+1 - loc["file_start_time_indices"][id_file1] + id_t_file0 = time_id - loc["file_start_time_indices"][id_file0] + id_t_file1 = time_id + 1 - loc["file_start_time_indices"][id_file1] # Open files ### NetCDF approach: nc0 = nc.Dataset(loc["files"][id_file0], "r") nc1 = nc.Dataset(loc["files"][id_file1], "r") - + ### Xarray approach: #nc0 = xr.open_dataset(loc["files"][id_file0]) #nc1 = xr.open_dataset(loc["files"][id_file1]) - + # Per field to sample for field in fields_list: # Read input file ### NetCDF approach: - field0 = nc0[ field ][:] - field1 = nc1[ field ][:] - + field0 = nc0[field][:] + field1 = nc1[field][:] + ### Xarray approach: #field0 = nc0[ field ].values #field1 = nc1[ field ].values @@ -1020,10 +1062,10 @@ def _read_and_intrp_v_ICON(loc, fields_list, time_id, idp): if len(field0.shape) == 3: ### For ICON fields that has shape (time, z, cells) # -- First select the nearest neighbours of the fields - - var00 = field0[ 0, :, loc["nn_sel_list"][idp] ] - var01 = field1[ 0, :, loc["nn_sel_list"][idp] ] - + + var00 = field0[0, :, loc["nn_sel_list"][idp]] + var01 = field1[0, :, loc["nn_sel_list"][idp]] + # -- Then interpolate spatially with weights # The sum of the weights per obs location u_sums = np.nansum(loc["weight_list"][idp], axis=1) @@ -1031,8 +1073,12 @@ def _read_and_intrp_v_ICON(loc, fields_list, time_id, idp): # Fancy way of mulitply the weights onto 4 nearest neighbors per obs location. (to be varified) # see: https://numpy.org/doc/stable/reference/generated/numpy.einsum.html # Since the dimension does not match, so here are the tricks to do so... - var0 = ( np.einsum( "ij,ijk->ik", loc["weight_list"][idp], var00 ) / u_sums[:, np.newaxis] ) - var1 = ( np.einsum( "ij,ijk->ik", loc["weight_list"][idp], var01 ) / u_sums[:, np.newaxis] ) + var0 = ( + np.einsum("ij,ijk->ik", loc["weight_list"][idp], var00) / + u_sums[:, np.newaxis]) + var1 = ( + np.einsum("ij,ijk->ik", loc["weight_list"][idp], var01) / + u_sums[:, np.newaxis]) # -- Get the time fractions per obs location frac_t_ = np.array(loc["frac_t"][idp]).reshape((len(idp), 1)) @@ -1040,35 +1086,36 @@ def _read_and_intrp_v_ICON(loc, fields_list, time_id, idp): elif len(field0.shape) == 2: ### For ICON fields that has shape (time, cells), e.g. "pres_sfc" # var0 will have shape (len(idp),len(profile)) - + # -- First select the fields: - var00 = field0[ 0, loc["nn_sel_list"][idp] ] - var01 = field1[ 0, loc["nn_sel_list"][idp] ] - + var00 = field0[0, loc["nn_sel_list"][idp]] + var01 = field1[0, loc["nn_sel_list"][idp]] + # -- Then interpolate in space with weights: # The sum of the weights per obs location u_sums = np.nansum(loc["weight_list"][idp], axis=1) - - var0 = np.nansum( loc["weight_list"][idp] * var00, axis=1 ) / u_sums - var1 = np.nansum( loc["weight_list"][idp] * var01, axis=1 ) / u_sums - - # -- Get the time fractions per obs location + + var0 = np.nansum(loc["weight_list"][idp] * var00, + axis=1) / u_sums + var1 = np.nansum(loc["weight_list"][idp] * var01, + axis=1) / u_sums + + # -- Get the time fractions per obs location frac_t_ = np.array(loc["frac_t"][idp]) - + else: - raise ValueError("Can't deal with field with %d dimensions." % len(field0.shape)) + raise ValueError("Can't deal with field with %d dimensions." % + len(field0.shape)) # Interpolate in time - var_intrp_l.append(var0*frac_t_ + var1*(1. - frac_t_)) + var_intrp_l.append(var0 * frac_t_ + var1 * (1. - frac_t_)) nc0.close() nc1.close() return var_intrp_l - - - #### David: A variation for sampling ICON ### + #### David: A variation for sampling ICON ### def sample_total_columns_ICON(self, dat, loc, fields_list): """ David: @@ -1115,21 +1162,22 @@ def sample_total_columns_ICON(self, dat, loc, fields_list): """ # Initialize output of all tracers - tc = np.ndarray(shape=(len(dat["prior"]), len(fields_list)), dtype=float) + tc = np.ndarray(shape=(len(dat["prior"]), len(fields_list)), + dtype=float) tc[:] = float("nan") - tc_unperturbed = np.ndarray(shape=(len(dat["prior"]), 1), dtype=float) + tc_unperturbed = np.ndarray(shape=(len(dat["prior"]), 1), dtype=float) tc_unperturbed[:] = float("nan") do_CAMS = True # Process by id_t UT = list(set(loc["id_t"][:])) - + #print('Tests, UT: %s' %UT) # print(loc['times']) - + for time_id in UT: # Coordinates to process idt = np.nonzero(loc["id_t"] == time_id)[0] @@ -1138,38 +1186,73 @@ def sample_total_columns_ICON(self, dat, loc, fields_list): din = loc['times'][idt[0]] # print(din) - [hour_below, hour_above ] = self.get_divisible_hours_string(datetime_obj=din) + [hour_below, + hour_above] = self.get_divisible_hours_string(datetime_obj=din) print("oi oi", hour_below, hour_above) if do_CAMS: - CAMS = xr.open_mfdataset(["/scratch/snx3000/ekoene/CAMS_i/cams_egg4_"+hour_below+".nc", - "/scratch/snx3000/ekoene/CAMS_i/cams_egg4_"+hour_above+".nc"], - concat_dim="Time", - combine="nested").rename({{'Time': 'time'}}) - pressure = CAMS.ap.values[:,:,np.newaxis,np.newaxis] + np.einsum('pi,pjk->pijk',CAMS.bp.values, CAMS.Psurf.values) + CAMS = xr.open_mfdataset([ + "/scratch/snx3000/ekoene/CAMS_i/cams_egg4_" + hour_below + + ".nc", "/scratch/snx3000/ekoene/CAMS_i/cams_egg4_" + + hour_above + ".nc" + ], + concat_dim="Time", + combine="nested").rename({{ + 'Time': + 'time' + }}) + pressure = CAMS.ap.values[:, :, np.newaxis, + np.newaxis] + np.einsum( + 'pi,pjk->pijk', CAMS.bp.values, + CAMS.Psurf.values) # The following is applicable if we only use joint (CO2,Pres) levels [as needed by, e.g., OCO2] - CAMS["pressure"] = (("time", "level", "latitude", "longitude"), (pressure[:,1:,:,:] + pressure[:,:-1,:,:])*0.5) + CAMS["pressure"] = ( + ("time", "level", "latitude", "longitude"), + (pressure[:, 1:, :, :] + pressure[:, :-1, :, :]) * 0.5) # The following is applicable if we want to use (CO2,Pres_ifc) combinations [note the 'hlevel' dimension] # CAMS["pressure"] = (("time", "hlevel", "latitude", "longitude"), pressure) # Read and get tracer ensemble profiles, and flip them, since ICON start from the model top - m_dry = 28.97 # g/mol for dry air - m_gas = 44.01 # g/mol for CO2 + m_dry = 28.97 # g/mol for dry air + m_gas = 44.01 # g/mol for CO2 to_ppm = 1e6 - qv = self._read_and_intrp_v_ICON(loc, ['qv'], time_id, idt)[0] - + qv = self._read_and_intrp_v_ICON(loc, ['qv'], time_id, idt)[0] + # The unperturbed tracer - BG = np.asarray(self._read_and_intrp_v_ICON(loc, ['TRCO2_BG'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + BG = np.asarray( + self._read_and_intrp_v_ICON( + loc, ['TRCO2_BG'], time_id, + idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm # TRCO2_A = np.asarray(self._read_and_intrp_v_ICON(loc, ['TRCO2_A'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm - try: # In the "PRIOR" simulations I made, the following tracer contains the anthropogenic portion; it doesn't exist otherwise. - TRCO2_A = np.asarray(self._read_and_intrp_v_ICON(loc, ['ANTH'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + try: # In the "PRIOR" simulations I made, the following tracer contains the anthropogenic portion; it doesn't exist otherwise. + TRCO2_A = np.asarray( + self._read_and_intrp_v_ICON( + loc, ['ANTH'], time_id, + idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm except: - TRCO2_A = np.asarray(self._read_and_intrp_v_ICON(loc, ['TRCO2_A'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm - CO2_RA = np.asarray(self._read_and_intrp_v_ICON(loc, ['CO2_RA'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm - CO2_GPP = np.asarray(self._read_and_intrp_v_ICON(loc, ['CO2_GPP'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm - biosource_all_chemtr = np.asarray(self._read_and_intrp_v_ICON(loc, ['biosource_all_chemtr'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm - biosink_chemtr = np.asarray(self._read_and_intrp_v_ICON(loc, ['biosink_chemtr'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + TRCO2_A = np.asarray( + self._read_and_intrp_v_ICON( + loc, ['TRCO2_A'], time_id, + idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm + CO2_RA = np.asarray( + self._read_and_intrp_v_ICON(loc, ['CO2_RA'], time_id, idt)) / ( + 1 - qv) * (m_dry / m_gas) * to_ppm + CO2_GPP = np.asarray( + self._read_and_intrp_v_ICON( + loc, ['CO2_GPP'], time_id, + idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm + biosource_all_chemtr = np.asarray( + self._read_and_intrp_v_ICON( + loc, ['biosource_all_chemtr'], time_id, + idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm + biosink_chemtr = np.asarray( + self._read_and_intrp_v_ICON( + loc, ['biosink_chemtr'], time_id, + idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm # The ensemble tracers - tracers = np.asarray(self._read_and_intrp_v_ICON(loc, fields_list, time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm + tracers = np.asarray( + self._read_and_intrp_v_ICON( + loc, fields_list, time_id, + idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm # Correct for the missing biospheric components! tracers = tracers + biosource_all_chemtr - biosink_chemtr @@ -1177,24 +1260,27 @@ def sample_total_columns_ICON(self, dat, loc, fields_list): #profiles = np.fliplr( self._read_and_intrp_v_ICON(loc, fields_list, time_id, idt) ) * (28.97/16.01)*1e6 # mol/kg -> ppm # List, len=len(fields_list), shape of each: (len(idt),nz) - + # Read and get water vapor for wet/dry correction # print(np.asarray(qv).shape, np.asarray(tracers).shape, type(qv), type(tracers)) # Read and get pressure axis: - psurf = self._read_and_intrp_v_ICON(loc, ["pres"], time_id, idt)[0]/1.e2 # Pa -> hPa + psurf = self._read_and_intrp_v_ICON(loc, ["pres"], time_id, + idt)[0] / 1.e2 # Pa -> hPa # Shape: (len(idt),) - - ptop = 50 # David: Since ICON does not have hard coded ptop, assume it is 50 hPa... + + ptop = 50 # David: Since ICON does not have hard coded ptop, assume it is 50 hPa... # Shape: (len(idt),) if not do_CAMS: ptop = 50 if do_CAMS: ptop = 0.01 - + ### David: ZNW was for WRF, for ICON first try getting "pres" or "pres_ifc" - pres = np.fliplr( self._read_and_intrp_v_ICON(loc, ["pres"], time_id, idt)[0] )/1.e2 # Pa -> hPa + pres = np.fliplr( + self._read_and_intrp_v_ICON(loc, ["pres"], time_id, + idt)[0]) / 1.e2 # Pa -> hPa # pres = np.fliplr( self._read_and_intrp_v_ICON(loc, ["pres_ifc"], time_id, idt)[0] )/1.e2 # Pa -> hPa #znw = self._read_and_intrp_v_ICON(loc, ["ZNW"], time_id, idt)[0] #Shape:(len(idt),nz) @@ -1202,29 +1288,30 @@ def sample_total_columns_ICON(self, dat, loc, fields_list): # DONE reading from file. # Here it starts to make sense to loop over individual observations for nidt in range(len(idt)): - + nobs = idt[nidt] - + # Construct model pressure layer boundaries #pb_mod = self.get_pressure_boundaries_znw(znw[nidt, :], psurf[nidt], ptop) - + # numpy.fliplr reverses the order of elements along axis 1 (left/right). - # For a 2-D array, this flips the entries in each row in the left/right direction. + # For a 2-D array, this flips the entries in each row in the left/right direction. # Columns are preserved, but appear in a different order than before. pb_mod = pres[nidt] # Do the CAMS extension if do_CAMS: - CAMS_obs = CAMS.interp(time=loc['times'][nobs], latitude=loc['latitude'][nobs], longitude=loc['longitude'][nobs]) + CAMS_obs = CAMS.interp(time=loc['times'][nobs], + latitude=loc['latitude'][nobs], + longitude=loc['longitude'][nobs]) CAMS_pressures = CAMS_obs.pressure.values CAMS_idx = CAMS_pressures < np.min(pb_mod) pb_mod = np.concatenate((pb_mod, CAMS_pressures[CAMS_idx])) - CAMS_gas = CAMS_obs.CO2.values[CAMS_idx] * 1e6 + CAMS_gas = CAMS_obs.CO2.values[CAMS_idx] * 1e6 # Add a final value onto the column... - pb_mod = np.append(pb_mod,np.min(pb_mod)-1) + pb_mod = np.append(pb_mod, np.min(pb_mod) - 1) - if (np.diff(pb_mod) >= 0).any(): msg = ("Model pressure boundaries for observation %d " + \ "are not monotonically decreasing! Investigate.") % nobs @@ -1240,11 +1327,11 @@ def sample_total_columns_ICON(self, dat, loc, fields_list): # but with an averaging kernel: # Use wrf's surface and top pressure nlayers = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) + pb_ret = np.linspace(psurf[nidt], ptop, nlayers + 1) else: nlayers = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, nlayers+1) - # Below commented out by David + pb_ret = np.linspace(psurf[nidt], ptop, nlayers + 1) + # Below commented out by David # Because somehow doesn't work #pb_ret = self.get_pressure_boundaries_paxis( # dat["pressure_levels"][nobs], @@ -1275,55 +1362,64 @@ def sample_total_columns_ICON(self, dat, loc, fields_list): msg = ("Retrieval pressure boundaries for " + \ "observation %d are not monotonically " + \ "decreasing! Investigate.") % nobs - print('pb_ret[:]: %s, np.diff(pb_ret): %s' %(pb_ret[:], np.diff(pb_ret))) + print('pb_ret[:]: %s, np.diff(pb_ret): %s' % + (pb_ret[:], np.diff(pb_ret))) raise ValueError(msg) # Get vertical integration coefficients (i.e. to # "interpolate" from model to retrieval grid) - coef_matrix = self.get_int_coefs(pb_ret, pb_mod, dat["level_def"][nobs]) ### To be verified !! + coef_matrix = self.get_int_coefs( + pb_ret, pb_mod, + dat["level_def"][nobs]) ### To be verified !! # Model retrieval with averaging kernel and prior profile if "pressure_weighting_function" in list(dat.keys()): pwf = dat["pressure_weighting_function"][nobs] - if (not "pressure_weighting_function" in list(dat.keys())) or np.any(np.isnan(pwf)): + if (not "pressure_weighting_function" in list( + dat.keys())) or np.any(np.isnan(pwf)): # Construct pressure weighting function from # pressure boundaries - pwf = self.get_pressure_weighting_function(pb_ret, rule="simple") + pwf = self.get_pressure_weighting_function(pb_ret, + rule="simple") # Compute pressure-weighted averaging kernel - avpw = pwf*dat["averaging_kernel"][nobs] + avpw = pwf * dat["averaging_kernel"][nobs] # Get prior prior_col = dat["prior"][nobs] prior_profile = dat["prior_profile"][nobs] - if np.isnan(prior_col): # compute prior + if np.isnan(prior_col): # compute prior prior_col = np.dot(pwf, prior_profile) # Compute total columns - offset = 0 + offset = 0 for nf in range(len(fields_list)): # Integrate model profile tr_here = np.flip(tracers[nf][nidt, :]) if do_CAMS: tr_here = np.concatenate((tr_here, CAMS_gas)) - profile = ( (tr_here - offset ) ) - profile_intrp = np.matmul( coef_matrix, profile ) ### To be verified !! + profile = ((tr_here - offset)) + profile_intrp = np.matmul(coef_matrix, + profile) ### To be verified !! # Model retrieval # print(prior_profile) # print(profile_intrp) # print(prior_col) - tc[nobs, nf] = prior_col + np.dot(avpw, profile_intrp - prior_profile) + tc[nobs, nf] = prior_col + np.dot( + avpw, profile_intrp - prior_profile) # print(tc[nobs,nf]) tr_here = np.flip(prior_tracers[0][nidt, :]) if do_CAMS: tr_here = np.concatenate((tr_here, CAMS_gas)) - profile = ( (tr_here - offset ) ) - profile_intrp = np.matmul( coef_matrix, profile ) ### To be verified !! - tc_unperturbed[nobs,0] = prior_col + np.dot(avpw, profile_intrp - prior_profile) + profile = ((tr_here - offset)) + profile_intrp = np.matmul(coef_matrix, + profile) ### To be verified !! + tc_unperturbed[nobs, 0] = prior_col + np.dot( + avpw, profile_intrp - prior_profile) return tc, tc_unperturbed - + if __name__ == "__main__": pass diff --git a/cases/icon-art-CTDAS2/ctdas_patch/icon_sampler.py b/cases/icon-art-CTDAS2/ctdas_patch/icon_sampler.py index a5c4b1b6..8f357878 100755 --- a/cases/icon-art-CTDAS2/ctdas_patch/icon_sampler.py +++ b/cases/icon-art-CTDAS2/ctdas_patch/icon_sampler.py @@ -32,31 +32,33 @@ # Import some CTDAS tools pd = os.path.pardir -inc_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), - pd, pd, pd) +inc_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), pd, pd, pd) inc_path = os.path.abspath(inc_path) sys.path.append(inc_path) from da.tools.icon.icon_helper import ICON_Helper from da.tools.icon.utilities import utilities import argparse - -########## Parse options +########## Parse options parser = argparse.ArgumentParser() -parser.add_argument("--nproc", type=int, +parser.add_argument("--nproc", + type=int, help="ID of this sampling process (0 ... nprocs-1)") -parser.add_argument("--nprocs", type=int, - help="Number of sampling processes") +parser.add_argument("--nprocs", type=int, help="Number of sampling processes") parser.add_argument("--sampling_coords_file", type=str, help="File with sampling coordinates as created " + \ "by CTDAS column samples object") -parser.add_argument("--run_dir", type=str, +parser.add_argument("--run_dir", + type=str, help="Directory with icon output files") -parser.add_argument("--iconout_prefix", type=str, +parser.add_argument("--iconout_prefix", + type=str, help="Headings of the ICON output files") -parser.add_argument("--icon_grid", type=str, +parser.add_argument("--icon_grid", + type=str, help="Absolute path points to the ICON grid file") -parser.add_argument("--nmembers", type=int, +parser.add_argument("--nmembers", + type=int, help="Number of tracer ensemble members") parser.add_argument("--tracer_optim", type=str, help="Tracer that was optimized (e.g. CO2 for " + \ @@ -64,61 +66,66 @@ parser.add_argument("--outfile_prefix", type=str, help="One process: output file. More processes: " + \ "output file is ..slice") -parser.add_argument("--footprint_samples_dim", type=int, +parser.add_argument("--footprint_samples_dim", + type=int, help="Sample column footprint at n x n points") -args = parser.parse_args() +args = parser.parse_args() settings = copy.deepcopy(vars(args)) # Start (stupid) logging - should be updated wd = os.getcwd() try: os.makedirs("log") -except OSError: # Case when directory already exists. Will look nicer in python 3... +except OSError: # Case when directory already exists. Will look nicer in python 3... pass -logfile = os.path.join(wd, "log/iconout_sampler." + str(settings['nproc']) + ".log") +logfile = os.path.join( + wd, "log/iconout_sampler." + str(settings['nproc']) + ".log") os.system("touch " + logfile) os.system("rm " + logfile) -os.system("echo 'Process " + str(settings['nproc']) + " of " + str(settings['nprocs']) + ": start' >> " + logfile) +os.system("echo 'Process " + str(settings['nproc']) + " of " + + str(settings['nprocs']) + ": start' >> " + logfile) os.system("date >> " + logfile) - # David: could be helpful for validate arguments for icon sampling ########## Initialize iconhelper iconhelper = ICON_Helper(settings) -iconhelper.validate_settings(['sampling_coords_file', - 'run_dir', - 'iconout_prefix', - 'icon_grid', - 'nproc', - 'nprocs', - 'nmembers', # special case 0: sample 'tracer_optim' - 'tracer_optim', - 'outfile_prefix', - 'footprint_samples_dim']) +iconhelper.validate_settings([ + 'sampling_coords_file', + 'run_dir', + 'iconout_prefix', + 'icon_grid', + 'nproc', + 'nprocs', + 'nmembers', # special case 0: sample 'tracer_optim' + 'tracer_optim', + 'outfile_prefix', + 'footprint_samples_dim' +]) cwd = os.getcwd() os.chdir(iconhelper.settings['run_dir']) - # ########## Figure out which samples to process # # Get number of samples ncf = nc.Dataset(settings['sampling_coords_file'], "r") nsamples = len(ncf.dimensions['soundings']) ncf.close() -id0, id1 = utilities.get_slicing_ids(nsamples, settings['nproc'], settings['nprocs']) +id0, id1 = utilities.get_slicing_ids(nsamples, settings['nproc'], + settings['nprocs']) os.system("echo 'id0=" + str(id0) + "' >> " + logfile) os.system("echo 'id1=" + str(id1) + "' >> " + logfile) # ########## Read samples from coord file -dat = iconhelper.read_sampling_coords(settings['sampling_coords_file'], id0, id1) - -os.system("echo 'Data read, len=" + str(len(dat['sounding_id'])) + "' >> " + logfile) +dat = iconhelper.read_sampling_coords(settings['sampling_coords_file'], id0, + id1) +os.system("echo 'Data read, len=" + str(len(dat['sounding_id'])) + "' >> " + + logfile) ########## Locate samples in ICON domains @@ -130,8 +137,10 @@ member_names = [settings['tracer_optim']] nmembers = 1 else: - member_names = [settings['tracer_optim'] + "-%03d" % nm for nm in range(1, nmembers+1)] # In ICON, ensemble member starts with XXX-001 - + member_names = [ + settings['tracer_optim'] + "-%03d" % nm + for nm in range(1, nmembers + 1) + ] # In ICON, ensemble member starts with XXX-001 #### Here gets the indexes of neighboring cells and the weights #### Choose number of neighbours, recommend 4 as done in "cdo remapdis" @@ -151,25 +160,27 @@ # Generate BallTree test_points = np.column_stack([clat, clon]) -tree = BallTree(test_points, metric = 'haversine') +tree = BallTree(test_points, metric='haversine') -lat_q = dat['latitude'] -lon_q = dat['longitude'] +lat_q = dat['latitude'] +lon_q = dat['longitude'] # Query BallTree -(d,i) = tree.query(np.column_stack([np.deg2rad(lat_q), np.deg2rad(lon_q)]), k=nneighb, return_distance=True) +(d, i) = tree.query(np.column_stack([np.deg2rad(lat_q), + np.deg2rad(lon_q)]), + k=nneighb, + return_distance=True) -R = 6373.0 # approximate radius of earth in km +R = 6373.0 # approximate radius of earth in km -weight_list = 1./(d*R) +weight_list = 1. / (d * R) nn_sel_list = i - ######### Locate in time: Which file, time index, and temporal interpolation # factor. # MAYBE make this a function. See which quantities I need later. # -- Initialize -id_t = np.zeros_like(dat['latitude'], int) +id_t = np.zeros_like(dat['latitude'], int) frac_t = np.ndarray(id_t.shape, float) frac_t[:] = float("nan") @@ -179,14 +190,13 @@ iconout_times = dict() iconout_start_time_ids = dict() - # -- Get full time vector iconout_prefix = settings['iconout_prefix'] -iconout_files = iconhelper.get_icon_filenames(iconout_prefix + "*") +iconout_files = iconhelper.get_icon_filenames(iconout_prefix + "*") iconout_times, iconout_start_time_ids = iconhelper.icon_times(iconout_files) # time id -for idx in range( len(dat['latitude']) ): +for idx in range(len(dat['latitude'])): # Look where it sorts in tmp = [i for i in range( len(iconout_times) -1 ) @@ -197,44 +207,46 @@ if len(tmp) == 1: id_t[idx] = tmp[0] time0 = iconout_times[id_t[idx]] - time1 = iconout_times[id_t[idx]+1] - frac_t[idx] = (time1 - dat['time'][idx]).total_seconds() / (time1 - time0).total_seconds() + time1 = iconout_times[id_t[idx] + 1] + frac_t[idx] = (time1 - dat['time'][idx]).total_seconds() / ( + time1 - time0).total_seconds() - else: # len must be 0 in this case + else: # len must be 0 in this case if len(tmp) > 1:\ raise ValueError("wat") - + if dat['time'][idx] == iconout_times[-1]: # For debugging - print('check dat[time]: %s' %(dat['time'][idx])) - id_t[idx] = len(iconout_times)-1 + print('check dat[time]: %s' % (dat['time'][idx])) + id_t[idx] = len(iconout_times) - 1 frac_t[idx] = 1 - + else: - msg = "Sample %d, sounding_id %s: outside of simulated time."%(idx, dat['sounding_id'][idx]) + msg = "Sample %d, sounding_id %s: outside of simulated time." % ( + idx, dat['sounding_id'][idx]) raise ValueError(msg) - # -- Create dictionary for column sampling: -loc_input = dict(nn_sel_list = nn_sel_list, - weight_list = weight_list, - id_t = id_t, - frac_t = frac_t, - files = iconout_files, - file_start_time_indices = iconout_start_time_ids, - times = dat['time'][:], +loc_input = dict(nn_sel_list=nn_sel_list, + weight_list=weight_list, + id_t=id_t, + frac_t=frac_t, + files=iconout_files, + file_start_time_indices=iconout_start_time_ids, + times=dat['time'][:], latitude=lat_q, longitude=lon_q) - # -- Begin Sampling -ens_sim, prior = iconhelper.sample_total_columns_ICON(dat, loc_input, member_names) +ens_sim, prior = iconhelper.sample_total_columns_ICON(dat, loc_input, + member_names) # -- Write results to file obs_ids = dat['sounding_id'] # Remove simulations that are nan (=not in domain) if ens_sim.shape[0] > 0: - valid = np.apply_along_axis(lambda arr: not np.any(np.isnan(arr)), 1, ens_sim) + valid = np.apply_along_axis(lambda arr: not np.any(np.isnan(arr)), 1, + ens_sim) obs_ids_write = obs_ids[valid] ens_sim_write = ens_sim[valid, :] prior_sim_write = prior[valid, :] @@ -249,20 +261,23 @@ # Create output files with the appendix "..slice" # Format so that they can later be easily sorted. len_nproc = int(np.floor(np.log10(settings['nprocs']))) + 1 - outfile = settings['outfile_prefix'] + (".%0" + str(len_nproc) + "d.slice") % settings['nproc'] + outfile = settings['outfile_prefix'] + (".%0" + str(len_nproc) + + "d.slice") % settings['nproc'] -os.system("echo 'Writing output file '" + os.path.join(iconhelper.settings['run_dir'], outfile) + " >> " + logfile) +os.system("echo 'Writing output file '" + + os.path.join(iconhelper.settings['run_dir'], outfile) + " >> " + + logfile) ### Write -iconhelper.write_simulated_columns( obs_id=obs_ids_write, - simulated=ens_sim_write, - nmembers=nmembers, - outfile=outfile ) - -iconhelper.write_simulated_columns( obs_id=obs_ids_write, - simulated=prior_sim_write, - nmembers=1, - outfile=outfile+'_prior.nc' ) +iconhelper.write_simulated_columns(obs_id=obs_ids_write, + simulated=ens_sim_write, + nmembers=nmembers, + outfile=outfile) + +iconhelper.write_simulated_columns(obs_id=obs_ids_write, + simulated=prior_sim_write, + nmembers=1, + outfile=outfile + '_prior.nc') os.chdir(cwd) diff --git a/cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py b/cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py index 96e7d3a8..f8fdde91 100644 --- a/cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py +++ b/cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py @@ -12,7 +12,6 @@ program. If not, see .""" #!/usr/bin/env python # obs.py - """ .. module:: obs .. moduleauthor:: Wouter Peters @@ -37,6 +36,7 @@ import xarray as xr from multiprocessing import Pool import datetime + sys.path.append(os.getcwd()) sys.path.append('../../') @@ -54,6 +54,7 @@ ################### Begin Class Observations ################### + class ICOSObservations(object): """ The baseclass Observations is a generic object that provides a number of methods required for any type of observations used in @@ -73,7 +74,7 @@ class ICOSObservations(object): :class:`~da.baseclasses.observationoperator.ObservationOperator` object. The values returned after sampling are finally added by :meth:`~da.baseclasses.obs.Observations.add_simulations` - """ + """ def __init__(self): """ @@ -111,11 +112,9 @@ def setup(self, dacycle): self.datalist = [] - def get_samples_type(self): return 'insitu' - def add_observations(self): """ Add actual observation data to the Observations object. This is in a form of an @@ -128,111 +127,110 @@ def add_observations(self): # Step 1: Read list of available site files in package ###################################################### - mdm_dict = {{}} - mountain_stations = ['Jungfraujoch_5', - 'Monte Cimone_8', - 'Puy de Dome_10', - 'Pic du Midi_28', - 'Zugspitze_3', - 'Hohenpeissenberg_50', - 'Hohenpeissenberg_93', - 'Hohenpeissenberg_131', - 'Schauinsland_12', - 'Plateau Rosa_10'] - skip_stations = ['Malin Head_47', - 'Hegyhatsal hatterszennyettseg-mero allomas_48', - 'Hegyhatsal hatterszennyettseg-mero allomas_82', - 'Birkenes_2', - 'Hegyhatsal hatterszennyettseg-mero allomas_115', - 'Hegyhatsal hatterszennyettseg-mero allomas_10', - 'Beromunster_12', - 'Beromunster_44', - 'Beromunster_72', - 'Beromunster_132', - 'Bilsdale_42', - 'Bilsdale_108', - 'Cabauw_27', - 'Cabauw_67', - 'Cabauw_127', - 'Gartow_30', - 'Gartow_60', - 'Gartow_132', - 'Gartow_216', - 'Hohenpeissenberg_50', - 'Hohenpeissenberg_93', - 'Hyltemossa_30', - 'Hyltemossa_70', - 'Ispra_40', - 'Ispra_60', - 'Karlsruhe_30', - 'Karlsruhe_60', - 'Karlsruhe_100', - 'Kresin u Pacova_10', - 'Kresin u Pacova_50', - 'Kresin u Pacova_125', - 'Lindenberg_2', - 'Lindenberg_10', - 'Lindenberg_40', - 'Observatoire de Haute Provence_10', - 'Observatoire de Haute Provence_50', - "Observatoire perenne de l'environnement_10", - "Observatoire perenne de l'environnement_50", - 'Ridge Hill_45', - 'Saclay_15', - 'Saclay_60', - 'Tacolneston_54', - 'Tacolneston_100', - 'Torfhaus_10', - 'Torfhaus_76', - 'Torfhaus_110', - 'Trainou_5', - 'Trainou_50', - 'Trainou_100', - ] + mountain_stations = [ + 'Jungfraujoch_5', 'Monte Cimone_8', 'Puy de Dome_10', + 'Pic du Midi_28', 'Zugspitze_3', 'Hohenpeissenberg_50', + 'Hohenpeissenberg_93', 'Hohenpeissenberg_131', 'Schauinsland_12', + 'Plateau Rosa_10' + ] + skip_stations = [ + 'Malin Head_47', + 'Hegyhatsal hatterszennyettseg-mero allomas_48', + 'Hegyhatsal hatterszennyettseg-mero allomas_82', + 'Birkenes_2', + 'Hegyhatsal hatterszennyettseg-mero allomas_115', + 'Hegyhatsal hatterszennyettseg-mero allomas_10', + 'Beromunster_12', + 'Beromunster_44', + 'Beromunster_72', + 'Beromunster_132', + 'Bilsdale_42', + 'Bilsdale_108', + 'Cabauw_27', + 'Cabauw_67', + 'Cabauw_127', + 'Gartow_30', + 'Gartow_60', + 'Gartow_132', + 'Gartow_216', + 'Hohenpeissenberg_50', + 'Hohenpeissenberg_93', + 'Hyltemossa_30', + 'Hyltemossa_70', + 'Ispra_40', + 'Ispra_60', + 'Karlsruhe_30', + 'Karlsruhe_60', + 'Karlsruhe_100', + 'Kresin u Pacova_10', + 'Kresin u Pacova_50', + 'Kresin u Pacova_125', + 'Lindenberg_2', + 'Lindenberg_10', + 'Lindenberg_40', + 'Observatoire de Haute Provence_10', + 'Observatoire de Haute Provence_50', + "Observatoire perenne de l'environnement_10", + "Observatoire perenne de l'environnement_50", + 'Ridge Hill_45', + 'Saclay_15', + 'Saclay_60', + 'Tacolneston_54', + 'Tacolneston_100', + 'Torfhaus_10', + 'Torfhaus_76', + 'Torfhaus_110', + 'Trainou_5', + 'Trainou_50', + 'Trainou_100', + ] os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE" -########################################################################################################## -# THE FOLLOWING COMMENTED BLOCK IS FOR READING-IN REAL DATA -########################################################################################################## - c_offset = 2 # ppm - - mdm_dictionary = {{ - "Beromunster_212": 6.2383423 + c_offset, - "Bilsdale_248": 3.8534036 + c_offset, - "Biscarrosse_47": 3.5997221 + c_offset, - "Cabauw_207": 6.6093283 + c_offset, - "Carnsore Point_14": 2.1894007 + c_offset, - "Ersa_40": 2.3997285 + c_offset, - "Gartow_341": 4.570544 + c_offset, - "Heidelberg_30": 8.660628 + c_offset, - "Hohenpeissenberg_131": 4.0553513 + c_offset, - "Hyltemossa_150": 3.485432 + c_offset, - "Ispra_100": 9.612817 + c_offset, - "Jungfraujoch_5": 1.0802848 + c_offset, - "Karlsruhe_200": 8.05013 + c_offset, - "Kresin u Pacova_250": 3.829324 + c_offset, - "La Muela_80": 3.2093291 + c_offset, - "Laegern-Hochwacht_32": 9.556924 + c_offset, - "Lindenberg_98": 5.4387555 + c_offset, - "Lutjewad_60": 5.651525 + c_offset, - "Monte Cimone_8": 1.7325112 + c_offset, - "Observatoire de Haute Provence_100": 4.146905 + c_offset, - "Observatoire perenne de l'environnement_120": 6.8854113 + c_offset, - "Pic du Midi_28": 1.2196398 + c_offset, - "Plateau Rosa_10": 1.3211231 + c_offset, - "Puy de Dome_10": 3.4529948 + c_offset, - "Ridge Hill_90": 5.0861707 + c_offset, - "Saclay_100": 6.8669567 + c_offset, - "Schauinsland_12": 3.7896755 + c_offset, - "Tacolneston_185": 4.6675706 + c_offset, - "Torfhaus_147": 4.622525 + c_offset, - "Trainou_180": 5.821612 + c_offset, - "Weybourne_10": 4.4674397 + c_offset, - "Zugspitze_3": 1.6796716 + c_offset - }} # Based on the simulated standard deviation of the signal (without background) over a full year. + ########################################################################################################## + # THE FOLLOWING COMMENTED BLOCK IS FOR READING-IN REAL DATA + ########################################################################################################## + c_offset = 2 # ppm + + mdm_dictionary = { + { + "Beromunster_212": 6.2383423 + c_offset, + "Bilsdale_248": 3.8534036 + c_offset, + "Biscarrosse_47": 3.5997221 + c_offset, + "Cabauw_207": 6.6093283 + c_offset, + "Carnsore Point_14": 2.1894007 + c_offset, + "Ersa_40": 2.3997285 + c_offset, + "Gartow_341": 4.570544 + c_offset, + "Heidelberg_30": 8.660628 + c_offset, + "Hohenpeissenberg_131": 4.0553513 + c_offset, + "Hyltemossa_150": 3.485432 + c_offset, + "Ispra_100": 9.612817 + c_offset, + "Jungfraujoch_5": 1.0802848 + c_offset, + "Karlsruhe_200": 8.05013 + c_offset, + "Kresin u Pacova_250": 3.829324 + c_offset, + "La Muela_80": 3.2093291 + c_offset, + "Laegern-Hochwacht_32": 9.556924 + c_offset, + "Lindenberg_98": 5.4387555 + c_offset, + "Lutjewad_60": 5.651525 + c_offset, + "Monte Cimone_8": 1.7325112 + c_offset, + "Observatoire de Haute Provence_100": 4.146905 + c_offset, + "Observatoire perenne de l'environnement_120": + 6.8854113 + c_offset, + "Pic du Midi_28": 1.2196398 + c_offset, + "Plateau Rosa_10": 1.3211231 + c_offset, + "Puy de Dome_10": 3.4529948 + c_offset, + "Ridge Hill_90": 5.0861707 + c_offset, + "Saclay_100": 6.8669567 + c_offset, + "Schauinsland_12": 3.7896755 + c_offset, + "Tacolneston_185": 4.6675706 + c_offset, + "Torfhaus_147": 4.622525 + c_offset, + "Trainou_180": 5.821612 + c_offset, + "Weybourne_10": 4.4674397 + c_offset, + "Zugspitze_3": 1.6796716 + c_offset + } + } # Based on the simulated standard deviation of the signal (without background) over a full year. u_id = 1 for ncfile in os.listdir(self.obspack_dir): @@ -241,31 +239,33 @@ def add_observations(self): logging.info('Found file ', ) infile = os.path.join(self.obspack_dir, ncfile) print("infile = ", infile) - + f = xr.open_dataset(infile) - logging.info('Looking into the file %s...'%(infile)) + logging.info('Looking into the file %s...' % (infile)) - sites_names = np.array([unidecode(x) for x in f.Stations_names.values]) + sites_names = np.array( + [unidecode(x) for x in f.Stations_names.values]) - mountain_hours = ['0' + str(x) for x in np.arange(0,7)] - rest_hours = [str(x) for x in np.arange(12,17)] + mountain_hours = ['0' + str(x) for x in np.arange(0, 7)] + rest_hours = [str(x) for x in np.arange(12, 17)] st_ind = np.arange(len(sites_names)) - - #def caculate_interval_mean_cnc(dates, conc, hr): + #def caculate_interval_mean_cnc(dates, conc, hr): for x in st_ind: station_name = sites_names[x] - if station_name in skip_stations: continue # Skip stations outside of the domain! - + if station_name in skip_stations: + continue # Skip stations outside of the domain! + cnc = f.Concentration[x].values - + dates = f.Dates[x].values flag = 1 - mdm_value = mdm_dictionary[station_name] # ERIK: CHANGED FROM constant 10 + mdm_value = mdm_dictionary[ + station_name] # ERIK: CHANGED FROM constant 10 height = f.Stations_masl[x].values lon = f.Lon[x].values lat = f.Lat[x].values @@ -274,43 +274,68 @@ def add_observations(self): # ERIK: What is the influence of using UTC here? 00 UTC is already 1 o clock in the Netherlands? BUT, simulation is not w.r.t. UTC (or is it?). if station_name in mountain_stations: - ind_dt = np.asarray([str(x)[11:13] in mountain_hours for x in f.Dates.values[x]]) #mask of hours taken for mountain sites - hr=0 + ind_dt = np.asarray([ + str(x)[11:13] in mountain_hours + for x in f.Dates.values[x] + ]) #mask of hours taken for mountain sites + hr = 0 else: - ind_dt = np.asarray([str(x)[11:13] in rest_hours for x in f.Dates.values[x]]) #mask of hours taken for the rest of the sites - hr=12 + ind_dt = np.asarray([ + str(x)[11:13] in rest_hours for x in f.Dates.values[x] + ]) #mask of hours taken for the rest of the sites + hr = 12 data = cnc[ind_dt] - times = np.asarray([datetime.datetime.strptime(str(x)[:-13], "%Y-%m-%dT%H:%M") for x in dates[ind_dt]]) - logging.info('Check dates: %s %s'%(self.enddate+timedelta(days=1), self.startdate+timedelta(days=1))) - mask_da_interval = np.logical_and(times<=(self.enddate+timedelta(days=1)), (self.startdate+timedelta(days=1))<=times) + times = np.asarray([ + datetime.datetime.strptime(str(x)[:-13], "%Y-%m-%dT%H:%M") + for x in dates[ind_dt] + ]) + logging.info('Check dates: %s %s' % + (self.enddate + timedelta(days=1), + self.startdate + timedelta(days=1))) + mask_da_interval = np.logical_and( + times <= (self.enddate + timedelta(days=1)), + (self.startdate + timedelta(days=1)) <= times) times = times[mask_da_interval] data = data[mask_da_interval] - if len(times)>0: + if len(times) > 0: for iday in set([ii.day for ii in times]): - ids = [iii for iii,dd in enumerate(times) if dd.day==iday] - value = np.nanmean(np.array([c for i,c in enumerate(data) if times[i].day==iday])) + ids = [ + iii for iii, dd in enumerate(times) + if dd.day == iday + ] + value = np.nanmean( + np.array([ + c for i, c in enumerate(data) + if times[i].day == iday + ])) dict_date = times[ids[0]].replace(hour=hr) if not np.isfinite(value): continue - - self.datalist.append(MoleFractionSample(u_id,dict_date,station_name,value,0.0,0.0,0.0,mdm_value,flag,height,lat,lon,station_name,species,strategy,0.0,station_name)) - logging.info('For itime([day]T[hour]) (%iT%i) adding synthetic obs %i at station %s: %5.2e'%(dict_date.day,dict_date.hour,u_id,station_name,value)) + self.datalist.append( + MoleFractionSample(u_id, dict_date, station_name, + value, 0.0, 0.0, 0.0, mdm_value, + flag, height, lat, lon, + station_name, species, strategy, + 0.0, station_name)) + + logging.info( + 'For itime([day]T[hour]) (%iT%i) adding synthetic obs %i at station %s: %5.2e' + % (dict_date.day, dict_date.hour, u_id, + station_name, value)) u_id += 1 - - # add_station_data_to_sample(x) - - logging.info("Observations list now holds %d values" % len(self.datalist)) -########################################################################################################## + # add_station_data_to_sample(x) + logging.info("Observations list now holds %d values" % + len(self.datalist)) +########################################################################################################## def add_simulations(self, filename, silent=False): """ Add the simulation data to the Observations object. """ - if not os.path.exists(filename): - msg = "Sample output filename for observations could not be found : %s" % filename + msg = "Sample output filename for observations could not be found : %s" % filename logging.error(msg) logging.error("Did the sampling step succeed?") logging.error("...exiting") @@ -320,7 +345,8 @@ def add_simulations(self, filename, silent=False): ids = ncf.get_variable('obs_num') simulated = ncf.get_variable('flask') ncf.close() - logging.info("Successfully read data from model sample file (%s)" % filename) + logging.info("Successfully read data from model sample file (%s)" % + filename) obs_ids = self.getvalues('id').tolist() ids = list(map(int, ids)) @@ -335,56 +361,64 @@ def add_simulations(self, filename, silent=False): missing_samples.append(idx) if not silent and missing_samples != []: - logging.warning('Model samples were found that did not match any ID in the observation list. Skipping them...') - msg = '%s'%missing_samples ; logging.warning(msg) - - logging.debug("Added %d simulated values to the Data list" % (len(ids) - len(missing_samples))) - logging.info("Added %d simulated values to the Data list" % (len(ids) - len(missing_samples))) + logging.warning( + 'Model samples were found that did not match any ID in the observation list. Skipping them...' + ) + msg = '%s' % missing_samples + logging.warning(msg) + logging.debug("Added %d simulated values to the Data list" % + (len(ids) - len(missing_samples))) + logging.info("Added %d simulated values to the Data list" % + (len(ids) - len(missing_samples))) def add_model_data_mismatch(self, filename): """ Get the model-data mismatch values for this cycle. """ - self.rejection_threshold = 10.0 # 3-sigma cut-off - self.global_R_scaling = 1.0 # no scaling applied + self.rejection_threshold = 10.0 # 3-sigma cut-off + self.global_R_scaling = 1.0 # no scaling applied for obs in self.datalist: # first loop over all available data points to set flags correctly - obs.may_localize = True #False + obs.may_localize = True #False obs.may_reject = False obs.flag = 0 logging.debug("Added Model Data Mismatch to all samples ") - - def write_sample_coords(self,obsinputfile): + def write_sample_coords(self, obsinputfile): """ Write the information needed by the observation operator to a file. Return the filename that was written for later use """ if len(self.datalist) == 0: - logging.debug("No observations found for this time period, nothing written to obs file") + logging.debug( + "No observations found for this time period, nothing written to obs file" + ) else: f = io.CT_CDF(obsinputfile, method='create') - logging.debug('Creating new observations file for ObservationOperator (%s)' % obsinputfile) + logging.debug( + 'Creating new observations file for ObservationOperator (%s)' % + obsinputfile) dimid = f.add_dim('obs', len(self.datalist)) -# dim200char = f.add_dim('string_of200chars', 200) + # dim200char = f.add_dim('string_of200chars', 200) dim50char = f.add_dim('string_of50chars', 50) dim3char = f.add_dim('string_of3chars', 3) dimcalcomp = f.add_dim('calendar_components', 6) data = self.getvalues('id') - savedict = io.std_savedict.copy() + savedict = io.std_savedict.copy() savedict['name'] = "obs_num" savedict['dtype'] = "int" savedict['long_name'] = "Unique_Dataset_observation_index_number" savedict['units'] = "" savedict['dims'] = dimid savedict['values'] = data.tolist() - savedict['comment'] = "Unique index number within this dataset ranging from 0 to UNLIMITED." + savedict[ + 'comment'] = "Unique index number within this dataset ranging from 0 to UNLIMITED." f.add_data(savedict) data = self.getvalues('evn') @@ -412,16 +446,18 @@ def write_sample_coords(self,obsinputfile): savedict['comment'] = "File name of data file." f.add_data(savedict) - data = [[d.year, d.month, d.day, d.hour, d.minute, d.second] for d in self.getvalues('xdate') ] + data = [[d.year, d.month, d.day, d.hour, d.minute, d.second] + for d in self.getvalues('xdate')] - savedict = io.std_savedict.copy() + savedict = io.std_savedict.copy() savedict['dtype'] = "int" savedict['name'] = "date_components" savedict['units'] = "integer components of UTC date/time" savedict['dims'] = dimid + dimcalcomp savedict['values'] = data savedict['missing_value'] = -999 - savedict['comment'] = "Calendar date components as integers. Times and dates are UTC." + savedict[ + 'comment'] = "Calendar date components as integers. Times and dates are UTC." savedict['order'] = "year, month, day, hour, minute, second" f.add_data(savedict) @@ -438,7 +474,7 @@ def write_sample_coords(self,obsinputfile): data = self.getvalues('lon') - savedict = io.std_savedict.copy() + savedict = io.std_savedict.copy() savedict['dtype'] = "float" savedict['name'] = "longitude" savedict['units'] = "degrees_east" @@ -449,7 +485,7 @@ def write_sample_coords(self,obsinputfile): data = self.getvalues('height') - savedict = io.std_savedict.copy() + savedict = io.std_savedict.copy() savedict['dtype'] = "float" savedict['name'] = "altitude" savedict['units'] = "meters_above_sea_level" @@ -460,7 +496,7 @@ def write_sample_coords(self,obsinputfile): data = self.getvalues('samplingstrategy') - savedict = io.std_savedict.copy() + savedict = io.std_savedict.copy() savedict['dtype'] = "int" savedict['name'] = "sampling_strategy" savedict['units'] = "NA" @@ -480,9 +516,9 @@ def write_sample_coords(self,obsinputfile): savedict['values'] = data.tolist() savedict['comment'] = 'Observations used in optimization' f.add_data(savedict) - + data = self.getvalues('mdm') - + savedict = io.std_savedict.copy() savedict['dtype'] = "float" savedict['name'] = "modeldatamismatch" @@ -490,15 +526,15 @@ def write_sample_coords(self,obsinputfile): savedict['units'] = "[mol mol-1]" savedict['dims'] = dimid savedict['values'] = data.tolist() - savedict['comment'] = 'Standard deviation of mole fractions resulting from model-data mismatch' + savedict[ + 'comment'] = 'Standard deviation of mole fractions resulting from model-data mismatch' f.add_data(savedict) f.close() logging.debug("Successfully wrote data to obs file") - logging.info("Sample input file for obs operator now in place [%s]" % obsinputfile) - - - + logging.info( + "Sample input file for obs operator now in place [%s]" % + obsinputfile) def write_sample_auxiliary(self, auxoutputfile): """ @@ -509,7 +545,7 @@ def write_sample_auxiliary(self, auxoutputfile): def getvalues(self, name, constructor=array): result = constructor([getattr(o, name) for o in self.datalist]) - if isinstance(result, ndarray): + if isinstance(result, ndarray): return result.squeeze() else: return result @@ -519,6 +555,7 @@ def getvalues(self, name, constructor=array): ################### Begin Class MoleFractionSample ################### + class MoleFractionSample(object): """ Holds the data that defines a mole fraction Sample in the data assimilation framework. Sor far, this includes all @@ -527,32 +564,49 @@ class MoleFractionSample(object): """ - def __init__(self, idx, xdate, code='XXX', obs=0.0, simulated=0.0, resid=0.0, hphr=0.0, mdm=0.0, flag=0, height=0.0, lat= -999., lon= -999., evn='0000', species='co2', samplingstrategy=1, sdev=0.0, fromfile='none.nc'): - self.code = code.strip() # dataset identifier, i.e., co2_lef_tower_insitu_1_99 - self.xdate = xdate # Date of obs - self.obs = obs # Value observed - self.simulated = simulated # Value simulated by model - self.resid = resid # Mole fraction residuals - self.hphr = hphr # Mole fraction prior uncertainty from fluxes and (HPH) and model data mismatch (R) - self.mdm = mdm # Model data mismatch - self.may_localize = True # Whether sample may be localized in optimizer - self.may_reject = True # Whether sample may be rejected if outside threshold - self.flag = flag # Flag - self.height = height # Sample height in masl - self.lat = lat # Sample lat - self.lon = lon # Sample lon - self.id = idx # Obspack ID within distrution (integer), e.g., 82536 - self.evn = evn # Obspack Number within distrution (string), e.g., obspack_co2_1_PROTOTYPE_v0.9.2_2012-07-26_99_82536 - self.sdev = sdev # standard deviation of ensemble - self.masl = True # Sample is in Meters Above Sea Level - self.mag = not self.masl # Sample is in Meters Above Ground + def __init__(self, + idx, + xdate, + code='XXX', + obs=0.0, + simulated=0.0, + resid=0.0, + hphr=0.0, + mdm=0.0, + flag=0, + height=0.0, + lat=-999., + lon=-999., + evn='0000', + species='co2', + samplingstrategy=1, + sdev=0.0, + fromfile='none.nc'): + self.code = code.strip( + ) # dataset identifier, i.e., co2_lef_tower_insitu_1_99 + self.xdate = xdate # Date of obs + self.obs = obs # Value observed + self.simulated = simulated # Value simulated by model + self.resid = resid # Mole fraction residuals + self.hphr = hphr # Mole fraction prior uncertainty from fluxes and (HPH) and model data mismatch (R) + self.mdm = mdm # Model data mismatch + self.may_localize = True # Whether sample may be localized in optimizer + self.may_reject = True # Whether sample may be rejected if outside threshold + self.flag = flag # Flag + self.height = height # Sample height in masl + self.lat = lat # Sample lat + self.lon = lon # Sample lon + self.id = idx # Obspack ID within distrution (integer), e.g., 82536 + self.evn = evn # Obspack Number within distrution (string), e.g., obspack_co2_1_PROTOTYPE_v0.9.2_2012-07-26_99_82536 + self.sdev = sdev # standard deviation of ensemble + self.masl = True # Sample is in Meters Above Sea Level + self.mag = not self.masl # Sample is in Meters Above Ground self.species = species.strip() self.samplingstrategy = samplingstrategy - self.fromfile = fromfile # netcdf filename inside ObsPack distribution, to write back later - -################### End Class MoleFractionSample ################### + self.fromfile = fromfile # netcdf filename inside ObsPack distribution, to write back later +################### End Class MoleFractionSample ################### ################### Begin Class TotalColumnSample ################### @@ -566,56 +620,61 @@ class TotalColumnSample(object): def __init__(self, idx, codex, xdate, obs=0.0, simulated=0.0, lat=-999., lon=-999., mdm=None, prior=0.0, prior_profile=0.0, av_kernel=0.0, pressure=0.0, \ ##### freum vvvv + pressure_weighting_function=None, ##### freum ^^^^ level_def = "pressure_boundary", psurf = float('nan'), resid=0.0, hphr=0.0, flag=0, species='co2', sdev=0.0, \ ##### freum vvvv + latc_0=None, latc_1=None, latc_2=None, latc_3=None, lonc_0=None, lonc_1=None, lonc_2=None, lonc_3=None \ ##### freum ^^^^ + ): - self.id = idx # Sounding ID - self.code = codex # Retrieval ID - self.xdate = xdate # Date of obs - self.obs = obs # Value observed - self.simulated = simulated # Value simulated by model, fillvalue = -9999 - self.lat = lat # Sample lat - self.lon = lon # Sample lon + self.id = idx # Sounding ID + self.code = codex # Retrieval ID + self.xdate = xdate # Date of obs + self.obs = obs # Value observed + self.simulated = simulated # Value simulated by model, fillvalue = -9999 + self.lat = lat # Sample lat + self.lon = lon # Sample lon ##### freum vvvv - self.latc_0 = latc_0 # Sample latitude corner - self.latc_1 = latc_1 # Sample latitude corner - self.latc_2 = latc_2 # Sample latitude corner - self.latc_3 = latc_3 # Sample latitude corner - self.lonc_0 = lonc_0 # Sample longitude corner - self.lonc_1 = lonc_1 # Sample longitude corner - self.lonc_2 = lonc_2 # Sample longitude corner - self.lonc_3 = lonc_3 # Sample longitude corner + self.latc_0 = latc_0 # Sample latitude corner + self.latc_1 = latc_1 # Sample latitude corner + self.latc_2 = latc_2 # Sample latitude corner + self.latc_3 = latc_3 # Sample latitude corner + self.lonc_0 = lonc_0 # Sample longitude corner + self.lonc_1 = lonc_1 # Sample longitude corner + self.lonc_2 = lonc_2 # Sample longitude corner + self.lonc_3 = lonc_3 # Sample longitude corner ##### freum ^^^^ - self.mdm = mdm # Model data mismatch - self.prior = prior # A priori column value used in retrieval - self.prior_profile = prior_profile # A priori profile used in retrieval - self.av_kernel = av_kernel # Averaging kernel - self.pressure = pressure # Pressure levels of retrieval + self.mdm = mdm # Model data mismatch + self.prior = prior # A priori column value used in retrieval + self.prior_profile = prior_profile # A priori profile used in retrieval + self.av_kernel = av_kernel # Averaging kernel + self.pressure = pressure # Pressure levels of retrieval # freum vvvv - self.pressure_weighting_function = pressure_weighting_function # Pressure weighting function + self.pressure_weighting_function = pressure_weighting_function # Pressure weighting function # freum ^^^^ - self.level_def = level_def # Are prior and averaging kernel defined as layer averages? - self.psurf = psurf # Surface pressure (only needed if level_def is "layer_average") - self.loc_L = int(600) #int(0) # freum 2021-07-13: insert this dummy value so the code runs with the current version of CTDAS. *Should* not affect results if localizetype == "CT2007" as in all my runs. However, replace this file with the standard observation file, obs_column_xco2.py - - self.resid = resid # Mole fraction residuals - self.hphr = hphr # Mole fraction prior uncertainty from fluxes and (HPH) and model data mismatch (R) - self.may_localize = True # Whether sample may be localized in optimizer - self.may_reject = True # Whether sample may be rejected if outside threshold - self.flag = flag # Flag - self.sdev = sdev # standard deviation of ensemble - self.species = species.strip() + self.level_def = level_def # Are prior and averaging kernel defined as layer averages? + self.psurf = psurf # Surface pressure (only needed if level_def is "layer_average") + self.loc_L = int( + 600 + ) #int(0) # freum 2021-07-13: insert this dummy value so the code runs with the current version of CTDAS. *Should* not affect results if localizetype == "CT2007" as in all my runs. However, replace this file with the standard observation file, obs_column_xco2.py + + self.resid = resid # Mole fraction residuals + self.hphr = hphr # Mole fraction prior uncertainty from fluxes and (HPH) and model data mismatch (R) + self.may_localize = True # Whether sample may be localized in optimizer + self.may_reject = True # Whether sample may be rejected if outside threshold + self.flag = flag # Flag + self.sdev = sdev # standard deviation of ensemble + self.species = species.strip() ################### End Class TotalColumnSample ################### - ################### Begin Class TotalColumnObservations ################### + class TotalColumnObservations(Observations): """ An object that holds data + methods and attributes needed to manipulate column samples """ @@ -623,17 +682,18 @@ class TotalColumnObservations(Observations): def setup(self, dacycle): self.startdate = dacycle['time.sample.start'] + timedelta(days=1) - self.enddate = dacycle['time.sample.end'] + self.enddate = dacycle['time.sample.end'] # Path to the input data (daily files) - sat_files = dacycle.dasystem['obs.column.ncfile'].split(',') - sat_dirs = dacycle.dasystem['obs.column.input.dir'].split(',') + sat_files = dacycle.dasystem['obs.column.ncfile'].split(',') + sat_dirs = dacycle.dasystem['obs.column.input.dir'].split(',') - self.sat_dirs = [] - self.sat_files = [] + self.sat_dirs = [] + self.sat_files = [] for i in range(len(sat_dirs)): if not os.path.exists(sat_dirs[i].strip()): - msg = 'Could not find the required satellite input directory (%s) ' % sat_dirs[i] + msg = 'Could not find the required satellite input directory (%s) ' % sat_dirs[ + i] logging.error(msg) raise IOError(msg) else: @@ -642,14 +702,20 @@ def setup(self, dacycle): del i # Get observation selection criteria (if present): - if 'obs.column.selection.variables' in dacycle.dasystem.keys() and 'obs.column.selection.criteria' in dacycle.dasystem.keys(): - self.selection_vars = dacycle.dasystem['obs.column.selection.variables'].split(',') - self.selection_criteria = dacycle.dasystem['obs.column.selection.criteria'].split(',') - logging.debug('Data selection criteria found: %s, %s' %(self.selection_vars, self.selection_criteria)) + if 'obs.column.selection.variables' in dacycle.dasystem.keys( + ) and 'obs.column.selection.criteria' in dacycle.dasystem.keys(): + self.selection_vars = dacycle.dasystem[ + 'obs.column.selection.variables'].split(',') + self.selection_criteria = dacycle.dasystem[ + 'obs.column.selection.criteria'].split(',') + logging.debug('Data selection criteria found: %s, %s' % + (self.selection_vars, self.selection_criteria)) else: - self.selection_vars = [] + self.selection_vars = [] self.selection_criteria = [] - logging.info('No data observation selection criteria found, using all observations in file.') + logging.info( + 'No data observation selection criteria found, using all observations in file.' + ) # Model data mismatch approach # self.mdm_calculation = dacycle.dasystem.get('mdm.calculation') @@ -676,16 +742,14 @@ def setup(self, dacycle): # Switch to indicate whether simulated column samples are read from obsOperator output, # or whether the sampling is done within CTDAS (in obsOperator class) - self.sample_in_ctdas = dacycle.dasystem['sample.in.ctdas'] if 'sample.in.ctdas' in dacycle.dasystem.keys() else False + self.sample_in_ctdas = dacycle.dasystem[ + 'sample.in.ctdas'] if 'sample.in.ctdas' in dacycle.dasystem.keys( + ) else False logging.debug('sample.in.ctdas = %s' % self.sample_in_ctdas) - - def get_samples_type(self): return 'column' - - def add_observations(self): """ Reading of total column observations, and selection of observations that will be sampled and assimilated. @@ -694,20 +758,26 @@ def add_observations(self): # Read observations from daily input files for i in range(len(self.sat_dirs)): - logging.info('Reading observations from %s' %os.path.join(self.sat_dirs[i],self.sat_files[i])) + logging.info('Reading observations from %s' % + os.path.join(self.sat_dirs[i], self.sat_files[i])) infile0 = os.path.join(self.sat_dirs[i], self.sat_files[i]) ndays = 0 - while self.startdate+dt.timedelta(days=ndays) <= self.enddate: - - infile = infile0.replace("",(self.startdate+dt.timedelta(days=ndays)).strftime("%Y%m%d")) - logging.info('To be precise, reading observations from %s' % infile) + while self.startdate + dt.timedelta(days=ndays) <= self.enddate: + infile = infile0.replace( + "", + (self.startdate + + dt.timedelta(days=ndays)).strftime("%Y%m%d")) + logging.info('To be precise, reading observations from %s' % + infile) if os.path.exists(infile): - logging.info("Reading observations for %s" % (self.startdate+dt.timedelta(days=ndays)).strftime("%Y%m%d")) + logging.info("Reading observations for %s" % + (self.startdate + + dt.timedelta(days=ndays)).strftime("%Y%m%d")) len_init = len(self.datalist) # get index of observations that satisfy selection criteria (based on variable names and values in system rc file, if present) @@ -719,62 +789,80 @@ def add_observations(self): del j criteria = [] for j in range(len(self.selection_vars)): - criteria.append(eval('selvars[j]'+self.selection_criteria[j])) + criteria.append( + eval('selvars[j]' + + self.selection_criteria[j])) del j #criteria = [eval('selvars[i]'+self.selection_criteria[i]) for i in range(len(self.selection_vars))] - subselect = np.logical_and.reduce(criteria).nonzero()[0] + subselect = np.logical_and.reduce( + criteria).nonzero()[0] else: - subselect = np.arange(ncf.get_variable('sounding_id').size) + subselect = np.arange( + ncf.get_variable('sounding_id').size) # retrieval attributes - code = ncf.get_attribute('retrieval_id') + code = ncf.get_attribute('retrieval_id') level_def = ncf.get_attribute('level_def') # only read good quality observations - ids = ncf.get_variable('sounding_id').take(subselect, axis=0) - lats = ncf.get_variable('latitude').take(subselect, axis=0) - lons = ncf.get_variable('longitude').take(subselect, axis=0) - obs = ncf.get_variable('obs').take(subselect, axis=0) - unc = ncf.get_variable('uncertainty').take(subselect, axis=0) - dates = ncf.get_variable('date').take(subselect, axis=0) - dates = array([dt.datetime(*d) for d in dates]) - av_kernel = ncf.get_variable('averaging_kernel').take(subselect, axis=0) - prior_profile = ncf.get_variable('prior_profile').take(subselect, axis=0) - pressure = ncf.get_variable('pressure_levels').take(subselect, axis=0) - - prior = ncf.get_variable('prior').take(subselect, axis=0) + ids = ncf.get_variable('sounding_id').take(subselect, + axis=0) + lats = ncf.get_variable('latitude').take(subselect, axis=0) + lons = ncf.get_variable('longitude').take(subselect, + axis=0) + obs = ncf.get_variable('obs').take(subselect, axis=0) + unc = ncf.get_variable('uncertainty').take(subselect, + axis=0) + dates = ncf.get_variable('date').take(subselect, axis=0) + dates = array([dt.datetime(*d) for d in dates]) + av_kernel = ncf.get_variable('averaging_kernel').take( + subselect, axis=0) + prior_profile = ncf.get_variable('prior_profile').take( + subselect, axis=0) + pressure = ncf.get_variable('pressure_levels').take( + subselect, axis=0) + + prior = ncf.get_variable('prior').take(subselect, axis=0) ##### freum vvvv - pwf = ncf.get_variable('pressure_weighting_function').take(subselect, axis=0) + pwf = ncf.get_variable('pressure_weighting_function').take( + subselect, axis=0) # Additional variable surface pressure in case the profiles are defined as layer averages if level_def == "layer_average": - psurf = ncf.get_variable('surface_pressure').take(subselect, axis=0) + psurf = ncf.get_variable('surface_pressure').take( + subselect, axis=0) else: - psurf = [float('nan')]*len(ids) + psurf = [float('nan')] * len(ids) # Optional: footprint corners - latc = dict( - latc_0=[float('nan')]*len(ids), - latc_1=[float('nan')]*len(ids), - latc_2=[float('nan')]*len(ids), - latc_3=[float('nan')]*len(ids)) - lonc = dict( - lonc_0=[float('nan')]*len(ids), - lonc_1=[float('nan')]*len(ids), - lonc_2=[float('nan')]*len(ids), - lonc_3=[float('nan')]*len(ids)) - # If one footprint corner variable is there, assume + latc = dict(latc_0=[float('nan')] * len(ids), + latc_1=[float('nan')] * len(ids), + latc_2=[float('nan')] * len(ids), + latc_3=[float('nan')] * len(ids)) + lonc = dict(lonc_0=[float('nan')] * len(ids), + lonc_1=[float('nan')] * len(ids), + lonc_2=[float('nan')] * len(ids), + lonc_3=[float('nan')] * len(ids)) + # If one footprint corner variable is there, assume # all are there. That's the only case that makes sense if 'latc_0' in list(ncf.variables.keys()): - latc['latc_0'] = ncf.get_variable('latc_0').take(subselect, axis=0) - latc['latc_1'] = ncf.get_variable('latc_1').take(subselect, axis=0) - latc['latc_2'] = ncf.get_variable('latc_2').take(subselect, axis=0) - latc['latc_3'] = ncf.get_variable('latc_3').take(subselect, axis=0) - lonc['lonc_0'] = ncf.get_variable('lonc_0').take(subselect, axis=0) - lonc['lonc_1'] = ncf.get_variable('lonc_1').take(subselect, axis=0) - lonc['lonc_2'] = ncf.get_variable('lonc_2').take(subselect, axis=0) - lonc['lonc_3'] = ncf.get_variable('lonc_3').take(subselect, axis=0) + latc['latc_0'] = ncf.get_variable('latc_0').take( + subselect, axis=0) + latc['latc_1'] = ncf.get_variable('latc_1').take( + subselect, axis=0) + latc['latc_2'] = ncf.get_variable('latc_2').take( + subselect, axis=0) + latc['latc_3'] = ncf.get_variable('latc_3').take( + subselect, axis=0) + lonc['lonc_0'] = ncf.get_variable('lonc_0').take( + subselect, axis=0) + lonc['lonc_1'] = ncf.get_variable('lonc_1').take( + subselect, axis=0) + lonc['lonc_2'] = ncf.get_variable('lonc_2').take( + subselect, axis=0) + lonc['lonc_3'] = ncf.get_variable('lonc_3').take( + subselect, axis=0) ###### freum ^^^^ ncf.close() @@ -792,38 +880,38 @@ def add_observations(self): ##### freum ^^^^ )) - logging.debug("Added %d observations to the Data list" % (len(self.datalist)-len_init)) + logging.debug("Added %d observations to the Data list" % + (len(self.datalist) - len_init)) ndays += 1 del i if len(self.datalist) > 0: - logging.info("Observations list now holds %d values" % len(self.datalist)) + logging.info("Observations list now holds %d values" % + len(self.datalist)) else: logging.info("No observations found for sampling window") - - def add_model_data_mismatch(self, filename=None, advance=False): """ This function is empty: model data mismatch calculation is done during sampling in observation operator (TM5) to enhance computational efficiency (i.e. to prevent reading all soundings twice and writing large additional files) """ # obs_data = rc.read(self.obs_file) - self.rejection_threshold = 15 #int(obs_data['obs.rejection.threshold']) + self.rejection_threshold = 15 #int(obs_data['obs.rejection.threshold']) # At this point mdm is set to the measurement uncertainty only, added in the add_observations function. # Here this value is used to set the combined mdm by adding an estimate for the model uncertainty as a sum of squares. - if len(self.datalist) <= 1: return #== 0: return + if len(self.datalist) <= 1: return #== 0: return for obs in self.datalist: - obs.mdm = ( obs.mdm*obs.mdm + 2**2 )**0.5 ## Here changed into 2 (2ppm) for CO2 : ERIK, CHANGE THIS TO WHAT I NEED! + obs.mdm = ( + obs.mdm * obs.mdm + 2**2 + )**0.5 ## Here changed into 2 (2ppm) for CO2 : ERIK, CHANGE THIS TO WHAT I NEED! del obs - meanmdm = np.average(np.array( [obs.mdm for obs in self.datalist] )) - logging.debug('Mean MDM = %s' %meanmdm) - - + meanmdm = np.average(np.array([obs.mdm for obs in self.datalist])) + logging.debug('Mean MDM = %s' % meanmdm) def add_simulations(self, filename, silent=False): """ Adds observed and model simulated column values to the mole fraction objects @@ -832,7 +920,8 @@ def add_simulations(self, filename, silent=False): """ if self.sample_in_ctdas: - logging.debug("CODE TO ADD SIMULATED SAMPLES TO DATALIST TO BE ADDED") + logging.debug( + "CODE TO ADD SIMULATED SAMPLES TO DATALIST TO BE ADDED") else: # read simulated samples from file @@ -843,18 +932,20 @@ def add_simulations(self, filename, silent=False): logging.error("...exiting") raise IOError(msg) - ncf = io.ct_read(filename, method='read') - ids = ncf.get_variable('sounding_id') + ncf = io.ct_read(filename, method='read') + ids = ncf.get_variable('sounding_id') simulated = ncf.get_variable('column_modeled') ncf.close() - logging.info("Successfully read data from model sample file (%s)" % filename) + logging.info("Successfully read data from model sample file (%s)" % + filename) obs_ids = self.getvalues('id').tolist() missing_samples = [] # Match read simulated samples with observations in datalist - logging.info("Adding %i simulated samples to the data list..." % len(ids)) + logging.info("Adding %i simulated samples to the data list..." % + len(ids)) for i in range(len(ids)): # Assume samples are in same order in both datalist and file with simulated samples... if ids[i] == obs_ids[i]: @@ -870,25 +961,29 @@ def add_simulations(self, filename, silent=False): else: self.datalist[index].simulated = simulated[i] else: - logging.debug('added %s to missing_samples, obs id = %s' %(ids[i],obs_ids[i])) + logging.debug('added %s to missing_samples, obs id = %s' % + (ids[i], obs_ids[i])) missing_samples.append(ids[i]) del i if not silent and missing_samples != []: - logging.warning('%i Model samples were found that did not match any ID in the observation list. Skipping them...' % len(missing_samples)) + logging.warning( + '%i Model samples were found that did not match any ID in the observation list. Skipping them...' + % len(missing_samples)) # if number of simulated samples < observations: remove observations without samples if len(simulated) < len(self.datalist): test = len(self.datalist) - len(simulated) - logging.warning('%i Observations were not sampled, removing them from datalist...' % test) + logging.warning( + '%i Observations were not sampled, removing them from datalist...' + % test) for index in reversed(list(range(len(self.datalist)))): if self.datalist[index].simulated is None: del self.datalist[index] del index - logging.debug("%d simulated values were added to the data list" % (len(ids) - len(missing_samples))) - - + logging.debug("%d simulated values were added to the data list" % + (len(ids) - len(missing_samples))) def write_sample_coords(self, obsinputfile): """ @@ -898,17 +993,21 @@ def write_sample_coords(self, obsinputfile): if self.sample_in_ctdas: return - if len(self.datalist) <= 1: #== 0: - logging.info("No observations found for this time period, no obs file written") + if len(self.datalist) <= 1: #== 0: + logging.info( + "No observations found for this time period, no obs file written" + ) return # write data required by observation operator for sampling to file f = io.CT_CDF(obsinputfile, method='create') - logging.debug('Creating new observations file for ObservationOperator (%s)' % obsinputfile) + logging.debug( + 'Creating new observations file for ObservationOperator (%s)' % + obsinputfile) - dimsoundings = f.add_dim('soundings', len(self.datalist)) - dimdate = f.add_dim('epoch_dimension', 7) - dimchar = f.add_dim('char', 20) + dimsoundings = f.add_dim('soundings', len(self.datalist)) + dimdate = f.add_dim('epoch_dimension', 7) + dimchar = f.add_dim('char', 20) if len(self.datalist) == 1: dimlevels = f.add_dim('levels', len(self.getvalues('pressure'))) # freum: inserted but commented Liesbeth's new code for layers for reference, @@ -918,136 +1017,140 @@ def write_sample_coords(self, obsinputfile): # layers = True # else: layers = False else: - dimlevels = f.add_dim('levels', self.getvalues('pressure').shape[1]) + dimlevels = f.add_dim('levels', + self.getvalues('pressure').shape[1]) # if self.getvalues('av_kernel').shape[1] != self.getvalues('pressure').shape[1]: # dimlayers = f.add_dim('layers', self.getvalues('pressure').shape[1] - 1) # layers = True # else: layers = False - savedict = io.std_savedict.copy() - savedict['dtype'] = "int64" - savedict['name'] = "sounding_id" - savedict['dims'] = dimsoundings + savedict = io.std_savedict.copy() + savedict['dtype'] = "int64" + savedict['name'] = "sounding_id" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('id').tolist() f.add_data(savedict) - data = [[d.year, d.month, d.day, d.hour, d.minute, d.second, d.microsecond] for d in self.getvalues('xdate') ] - savedict = io.std_savedict.copy() - savedict['dtype'] = "int" - savedict['name'] = "date" - savedict['dims'] = dimsoundings + dimdate + data = [[ + d.year, d.month, d.day, d.hour, d.minute, d.second, d.microsecond + ] for d in self.getvalues('xdate')] + savedict = io.std_savedict.copy() + savedict['dtype'] = "int" + savedict['name'] = "date" + savedict['dims'] = dimsoundings + dimdate savedict['values'] = data f.add_data(savedict) - savedict = io.std_savedict.copy() - savedict['name'] = "latitude" - savedict['dims'] = dimsoundings + savedict = io.std_savedict.copy() + savedict['name'] = "latitude" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('lat').tolist() f.add_data(savedict) - savedict = io.std_savedict.copy() - savedict['name'] = "longitude" - savedict['dims'] = dimsoundings + savedict = io.std_savedict.copy() + savedict['name'] = "longitude" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('lon').tolist() f.add_data(savedict) savedict = io.std_savedict.copy() - savedict['name'] = "prior" - savedict['dims'] = dimsoundings + savedict['name'] = "prior" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('prior').tolist() f.add_data(savedict) savedict = io.std_savedict.copy() - savedict['name'] = "prior_profile" - savedict['dims'] = dimsoundings + dimlevels + savedict['name'] = "prior_profile" + savedict['dims'] = dimsoundings + dimlevels savedict['values'] = self.getvalues('prior_profile').tolist() f.add_data(savedict) savedict = io.std_savedict.copy() - savedict['name'] = "averaging_kernel" - savedict['dims'] = dimsoundings + dimlevels + savedict['name'] = "averaging_kernel" + savedict['dims'] = dimsoundings + dimlevels savedict['values'] = self.getvalues('av_kernel').tolist() f.add_data(savedict) savedict = io.std_savedict.copy() - savedict['name'] = "pressure_levels" - savedict['dims'] = dimsoundings + dimlevels + savedict['name'] = "pressure_levels" + savedict['dims'] = dimsoundings + dimlevels savedict['values'] = self.getvalues('pressure').tolist() f.add_data(savedict) # freum vvvv savedict = io.std_savedict.copy() - savedict['name'] = "pressure_weighting_function" - savedict['dims'] = dimsoundings + dimlevels - savedict['values'] = self.getvalues('pressure_weighting_function').tolist() + savedict['name'] = "pressure_weighting_function" + savedict['dims'] = dimsoundings + dimlevels + savedict['values'] = self.getvalues( + 'pressure_weighting_function').tolist() f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "latc_0" - savedict['dims'] = dimsoundings + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_0" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('latc_0').tolist() f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "latc_1" - savedict['dims'] = dimsoundings + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_1" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('latc_1').tolist() f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "latc_2" - savedict['dims'] = dimsoundings + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_2" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('latc_2').tolist() f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "latc_3" - savedict['dims'] = dimsoundings + + savedict = io.std_savedict.copy() + savedict['name'] = "latc_3" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('latc_3').tolist() f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "lonc_0" - savedict['dims'] = dimsoundings + + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_0" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('lonc_0').tolist() f.add_data(savedict) - savedict = io.std_savedict.copy() - savedict['name'] = "lonc_1" - savedict['dims'] = dimsoundings + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_1" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('lonc_1').tolist() f.add_data(savedict) - savedict = io.std_savedict.copy() - savedict['name'] = "lonc_2" - savedict['dims'] = dimsoundings + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_2" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('lonc_2').tolist() f.add_data(savedict) - savedict = io.std_savedict.copy() - savedict['name'] = "lonc_3" - savedict['dims'] = dimsoundings + savedict = io.std_savedict.copy() + savedict['name'] = "lonc_3" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('lonc_3').tolist() f.add_data(savedict) - savedict = io.std_savedict.copy() - savedict['name'] = "XCO2" - savedict['dims'] = dimsoundings + savedict = io.std_savedict.copy() + savedict['name'] = "XCO2" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('obs').tolist() f.add_data(savedict) # freum ^^^^ savedict = io.std_savedict.copy() - savedict['dtype'] = "char" - savedict['name'] = "level_def" - savedict['dims'] = dimsoundings + dimchar + savedict['dtype'] = "char" + savedict['name'] = "level_def" + savedict['dims'] = dimsoundings + dimchar savedict['values'] = self.getvalues('level_def').tolist() f.add_data(savedict) savedict = io.std_savedict.copy() - savedict['name'] = "psurf" - savedict['dims'] = dimsoundings + savedict['name'] = "psurf" + savedict['dims'] = dimsoundings savedict['values'] = self.getvalues('psurf').tolist() f.add_data(savedict) @@ -1056,6 +1159,5 @@ def write_sample_coords(self, obsinputfile): ################### End Class TotalColumnObservations ################### - if __name__ == "__main__": pass diff --git a/cases/icon-art-CTDAS2/ctdas_patch/obsoperator_ICOS_OCO2.py b/cases/icon-art-CTDAS2/ctdas_patch/obsoperator_ICOS_OCO2.py index dad38bbc..06b24e28 100644 --- a/cases/icon-art-CTDAS2/ctdas_patch/obsoperator_ICOS_OCO2.py +++ b/cases/icon-art-CTDAS2/ctdas_patch/obsoperator_ICOS_OCO2.py @@ -12,7 +12,6 @@ program. If not, see .""" #!/usr/bin/env python # model.py - """ .. module:: observationoperator .. moduleauthor:: Wouter Peters @@ -31,6 +30,7 @@ from multiprocessing import Pool from scipy import interpolate import da.tools.io4 as io + sys.path.append(os.getcwd()) sys.path.append('../../') @@ -40,10 +40,10 @@ import subprocess import glob - identifier = 'RandomizerObservationOperator' version = '1.0' + ################### Begin Class ObservationOperator ################### class ObservationOperator(object): """ @@ -57,13 +57,15 @@ class ObservationOperator(object): """ - def __init__(self, rc_filename, dacycle=None): # David: addition arg "rc_filename" added. + def __init__(self, + rc_filename, + dacycle=None): # David: addition arg "rc_filename" added. """ The instance of an ObservationOperator is application dependent """ self.ID = identifier self.version = version self.restart_filelist = [] self.output_filelist = [] - self.outputdir = None # Needed for opening the samples.nc files created + self.outputdir = None # Needed for opening the samples.nc files created # vvv Added by David: # Load settings @@ -71,7 +73,7 @@ def __init__(self, rc_filename, dacycle=None): # David: addition arg "rc_filenam self._validate_rc() # Instantiate an ICON_Helper object *David could be useful for icon sampler - self.settings["dir.icon_sim"] + self.settings["dir.icon_sim"] self.iconhelper = ICON_Helper(self.settings) self.iconhelper.validate_settings(["dir.icon_sim"]) @@ -96,9 +98,8 @@ def _load_rc(self, name): self.rcfile = rc.RcFile(name) self.settings = self.rcfile.values self.rc_filename = name - - logging.debug("rc-file %s loaded", name) + logging.debug("rc-file %s loaded", name) def _validate_rc(self): """Check that some required values are given in the rc-file. @@ -114,11 +115,11 @@ def _validate_rc(self): logging.error(msg) raise IOError(msg) logging.debug("rc-file has been validated succesfully") - + def get_initial_data(self): """ This method places all initial data needed by an ObservationOperator in the proper folder for the model """ - def setup(self,dacycle): + def setup(self, dacycle): """ Perform all steps necessary to start the observation operator through a simple Run() call """ self.dacycle = dacycle @@ -128,7 +129,7 @@ def setup(self,dacycle): self.n_regs = int(dacycle['statevector.number_regions']) self.tracer = str(dacycle['statevector.tracer']) - def prepare_run(self,samples): + def prepare_run(self, samples): """ Prepare the running of the actual forecast model, for example compile code """ import os @@ -136,28 +137,47 @@ def prepare_run(self,samples): # For each sample type, define the name of the file that will contain the modeled output of each observation self.simulated_file = [None] * len(samples) for i in range(len(samples)): - self.simulated_file[i] = os.path.join(self.outputdir, '%s_output.%s.nc' % (samples[i].get_samples_type(),self.dacycle['time.sample.stamp'])) - logging.info("Simulated flask file added: %s"%self.simulated_file[i]) + self.simulated_file[i] = os.path.join( + self.outputdir, + '%s_output.%s.nc' % (samples[i].get_samples_type(), + self.dacycle['time.sample.stamp'])) + logging.info("Simulated flask file added: %s" % + self.simulated_file[i]) del i #self.simulated_file = os.path.join(self.outputdir, 'samples_simulated.%s.nc' % self.dacycle['time.sample.stamp']) self.forecast_nmembers = int(self.dacycle['da.optimizer.nmembers']) - def make_lambdas(self,statevector,lag): + def make_lambdas(self, statevector, lag): """ Write out lambda file parameters """ #msteiner: #write lambda file for current lag: members = statevector.ensemble_members[lag] if statevector.isOptimized: - self.lambda_file = os.path.join(self.simulationdir,'input','oae','lambda_%s_opt.nc' %self.dacycle['time.sample.stamp'][0:10]) - self.bg_lambda_file = os.path.join(self.simulationdir,'input','oae','bg_lambda_%s_opt.nc' %self.dacycle['time.sample.stamp'][0:10]) + self.lambda_file = os.path.join( + self.simulationdir, 'input', 'oae', + 'lambda_%s_opt.nc' % self.dacycle['time.sample.stamp'][0:10]) + self.bg_lambda_file = os.path.join( + self.simulationdir, 'input', 'oae', 'bg_lambda_%s_opt.nc' % + self.dacycle['time.sample.stamp'][0:10]) else: - if lag==0: - self.lambda_file = os.path.join(self.simulationdir,'input','oae','lambda_%s_priorcycle1.nc' %self.dacycle['time.sample.stamp'][0:10]) - self.bg_lambda_file = os.path.join(self.simulationdir,'input','oae','bg_lambda_%s_priorcycle1.nc' %self.dacycle['time.sample.stamp'][0:10]) + if lag == 0: + self.lambda_file = os.path.join( + self.simulationdir, 'input', 'oae', + 'lambda_%s_priorcycle1.nc' % + self.dacycle['time.sample.stamp'][0:10]) + self.bg_lambda_file = os.path.join( + self.simulationdir, 'input', 'oae', + 'bg_lambda_%s_priorcycle1.nc' % + self.dacycle['time.sample.stamp'][0:10]) else: - self.lambda_file = os.path.join(self.simulationdir,'input','oae','lambda_%s_prior.nc' %self.dacycle['time.sample.stamp'][0:10]) - self.bg_lambda_file = os.path.join(self.simulationdir,'input','oae','bg_lambda_%s_prior.nc' %self.dacycle['time.sample.stamp'][0:10]) + self.lambda_file = os.path.join( + self.simulationdir, 'input', 'oae', 'lambda_%s_prior.nc' % + self.dacycle['time.sample.stamp'][0:10]) + self.bg_lambda_file = os.path.join( + self.simulationdir, 'input', 'oae', + 'bg_lambda_%s_prior.nc' % + self.dacycle['time.sample.stamp'][0:10]) # if os.path.exists(self.lambda_file): # os.system('mv %s %s_cycle1.nc'%(self.lambda_file,self.lambda_file[:-3])) @@ -173,20 +193,26 @@ def make_lambdas(self,statevector,lag): oreg = ofile.createDimension('reg', nr_reg) ocat = ofile.createDimension('cat', nr_cat) otracer = ofile.createDimension('tracer', nr_tracer) - odata = ofile.createVariable('lambda', np.float32, ('ens','reg','cat','tracer'),fill_value=-999.99) - lambdas = np.empty(shape=(nr_ens,nr_reg,nr_cat,nr_tracer)) - for m in range(0,self.forecast_nmembers): - param_count=0 - for ireg in range(0,nr_reg): - for icat in range(0,nr_cat): + odata = ofile.createVariable('lambda', + np.float32, + ('ens', 'reg', 'cat', 'tracer'), + fill_value=-999.99) + lambdas = np.empty(shape=(nr_ens, nr_reg, nr_cat, nr_tracer)) + for m in range(0, self.forecast_nmembers): + param_count = 0 + for ireg in range(0, nr_reg): + for icat in range(0, nr_cat): if statevector.isOptimized: - lambdas[m,ireg,icat,0] = members[0].param_values[param_count] + lambdas[m, ireg, icat, + 0] = members[0].param_values[param_count] else: - lambdas[m,ireg,icat,0] = members[m].param_values[param_count] - param_count+=1 + lambdas[m, ireg, icat, + 0] = members[m].param_values[param_count] + param_count += 1 odata[:] = lambdas ofile.close() - logging.info('lambdas for ICON simulation written to the file: %s' % self.lambda_file) + logging.info('lambdas for ICON simulation written to the file: %s' % + self.lambda_file) #write bg_lambdas ofile = Dataset(self.bg_lambda_file, mode='w') @@ -196,27 +222,34 @@ def make_lambdas(self,statevector,lag): oens = ofile.createDimension('ens', nr_ens) odir = ofile.createDimension('reg', nr_dir) # otracer = ofile.createDimension('tracer', nr_tracer) - odata = ofile.createVariable('lambda', np.float32, ('ens','reg'),fill_value=-999.99) #,'tracer' - lambdas = np.empty(shape=(nr_ens,nr_dir)) #,nr_tracer - for m in range(0,self.forecast_nmembers): - for idir in range(0,nr_dir): + odata = ofile.createVariable('lambda', + np.float32, ('ens', 'reg'), + fill_value=-999.99) #,'tracer' + lambdas = np.empty(shape=(nr_ens, nr_dir)) #,nr_tracer + for m in range(0, self.forecast_nmembers): + for idir in range(0, nr_dir): if statevector.isOptimized: - lambdas[m,idir] = members[0].param_values[-self.n_bg_params + idir] + lambdas[m, + idir] = members[0].param_values[-self.n_bg_params + + idir] else: - lambdas[m,idir] = members[m].param_values[-self.n_bg_params + idir] + lambdas[m, + idir] = members[m].param_values[-self.n_bg_params + + idir] odata[:] = lambdas ofile.close() - logging.info('bg_lambdas for ICON simulation written to the file: %s' % self.bg_lambda_file) - + logging.info('bg_lambdas for ICON simulation written to the file: %s' % + self.bg_lambda_file) def validate_input(self): """ Make sure that data needed for the ObservationOperator (such as observation input lists, or parameter files) are present. """ + def save_data(self): """ Write the data that is needed for a restart or recovery of the Observation Operator to the save directory """ - def run(self,samples,statevector,lag): + def run(self, samples, statevector, lag): """ This Randomizer will take the original observation data in the Obs object, and simply copy each mean value. Next, the mean value will be perturbed by a random normal number drawn from a specified uncertainty of +/- 2 ppm @@ -229,15 +262,30 @@ def run(self,samples,statevector,lag): #write lambda file for current lag: members = statevector.ensemble_members[lag] if statevector.isOptimized: - self.lambda_file = os.path.join(self.simulationdir,'input','oae','lambda_%s_opt.nc' %self.dacycle['time.sample.stamp'][0:10]) - self.bg_lambda_file = os.path.join(self.simulationdir,'input','oae','bg_lambda_%s_opt.nc' %self.dacycle['time.sample.stamp'][0:10]) + self.lambda_file = os.path.join( + self.simulationdir, 'input', 'oae', + 'lambda_%s_opt.nc' % self.dacycle['time.sample.stamp'][0:10]) + self.bg_lambda_file = os.path.join( + self.simulationdir, 'input', 'oae', 'bg_lambda_%s_opt.nc' % + self.dacycle['time.sample.stamp'][0:10]) else: - if lag==0: - self.lambda_file = os.path.join(self.simulationdir,'input','oae','lambda_%s_priorcycle1.nc' %self.dacycle['time.sample.stamp'][0:10]) - self.bg_lambda_file = os.path.join(self.simulationdir,'input','oae','bg_lambda_%s_priorcycle1.nc' %self.dacycle['time.sample.stamp'][0:10]) + if lag == 0: + self.lambda_file = os.path.join( + self.simulationdir, 'input', 'oae', + 'lambda_%s_priorcycle1.nc' % + self.dacycle['time.sample.stamp'][0:10]) + self.bg_lambda_file = os.path.join( + self.simulationdir, 'input', 'oae', + 'bg_lambda_%s_priorcycle1.nc' % + self.dacycle['time.sample.stamp'][0:10]) else: - self.lambda_file = os.path.join(self.simulationdir,'input','oae','lambda_%s_prior.nc' %self.dacycle['time.sample.stamp'][0:10]) - self.bg_lambda_file = os.path.join(self.simulationdir,'input','oae','bg_lambda_%s_prior.nc' %self.dacycle['time.sample.stamp'][0:10]) + self.lambda_file = os.path.join( + self.simulationdir, 'input', 'oae', 'lambda_%s_prior.nc' % + self.dacycle['time.sample.stamp'][0:10]) + self.bg_lambda_file = os.path.join( + self.simulationdir, 'input', 'oae', + 'bg_lambda_%s_prior.nc' % + self.dacycle['time.sample.stamp'][0:10]) # if os.path.exists(self.lambda_file): # os.system('mv %s %s_cycle1.nc'%(self.lambda_file,self.lambda_file[:-3])) @@ -253,20 +301,26 @@ def run(self,samples,statevector,lag): oreg = ofile.createDimension('reg', nr_reg) ocat = ofile.createDimension('cat', nr_cat) otracer = ofile.createDimension('tracer', nr_tracer) - odata = ofile.createVariable('lambda', np.float32, ('ens','reg','cat','tracer'),fill_value=-999.99) - lambdas = np.empty(shape=(nr_ens,nr_reg,nr_cat,nr_tracer)) - for m in range(0,self.forecast_nmembers): - param_count=0 - for ireg in range(0,nr_reg): - for icat in range(0,nr_cat): + odata = ofile.createVariable('lambda', + np.float32, + ('ens', 'reg', 'cat', 'tracer'), + fill_value=-999.99) + lambdas = np.empty(shape=(nr_ens, nr_reg, nr_cat, nr_tracer)) + for m in range(0, self.forecast_nmembers): + param_count = 0 + for ireg in range(0, nr_reg): + for icat in range(0, nr_cat): if statevector.isOptimized: - lambdas[m,ireg,icat,0] = members[0].param_values[param_count] + lambdas[m, ireg, icat, + 0] = members[0].param_values[param_count] else: - lambdas[m,ireg,icat,0] = members[m].param_values[param_count] - param_count+=1 + lambdas[m, ireg, icat, + 0] = members[m].param_values[param_count] + param_count += 1 odata[:] = lambdas ofile.close() - logging.info('lambdas for ICON simulation written to the file: %s' % self.lambda_file) + logging.info('lambdas for ICON simulation written to the file: %s' % + self.lambda_file) #write bg_lambdas ofile = Dataset(self.bg_lambda_file, mode='w') @@ -276,52 +330,85 @@ def run(self,samples,statevector,lag): oens = ofile.createDimension('ens', nr_ens) odir = ofile.createDimension('reg', nr_dir) # otracer = ofile.createDimension('tracer', nr_tracer) - odata = ofile.createVariable('lambda', np.float32, ('ens','reg'),fill_value=-999.99) #,'tracer' - lambdas = np.empty(shape=(nr_ens,nr_dir)) #,nr_tracer - for m in range(0,self.forecast_nmembers): - for idir in range(0,nr_dir): + odata = ofile.createVariable('lambda', + np.float32, ('ens', 'reg'), + fill_value=-999.99) #,'tracer' + lambdas = np.empty(shape=(nr_ens, nr_dir)) #,nr_tracer + for m in range(0, self.forecast_nmembers): + for idir in range(0, nr_dir): if statevector.isOptimized: - lambdas[m,idir] = members[0].param_values[-self.n_bg_params + idir] + lambdas[m, + idir] = members[0].param_values[-self.n_bg_params + + idir] else: - lambdas[m,idir] = members[m].param_values[-self.n_bg_params + idir] + lambdas[m, + idir] = members[m].param_values[-self.n_bg_params + + idir] odata[:] = lambdas ofile.close() - logging.info('bg_lambdas for ICON simulation written to the file: %s' % self.bg_lambda_file) - + logging.info('bg_lambdas for ICON simulation written to the file: %s' % + self.bg_lambda_file) #msteiner: #select runscript for ICON-ART-OEM simulation: if statevector.isOptimized: #icon_path = os.path.join(self.simulationdir,'output_%s_opt'%(self.dacycle['time.sample.stamp'][0:10])) - runscript = os.path.join(self.simulationdir,'run','runscript_%sopt'%(self.dacycle['time.sample.stamp'][0:10])) + runscript = os.path.join( + self.simulationdir, 'run', + 'runscript_%sopt' % (self.dacycle['time.sample.stamp'][0:10])) #runscript_boundaries = os.path.join(self.simulationdir,'run','runscript_%sopt'%(self.dacycle['time.sample.stamp'][0:10])) - extraction_script = os.path.join(self.simulationdir,'run','extract_%sopt'%(self.dacycle['time.sample.stamp'][0:10])) + extraction_script = os.path.join( + self.simulationdir, 'run', + 'extract_%sopt' % (self.dacycle['time.sample.stamp'][0:10])) #extraction_script_boundaries = os.path.join(self.simulationdir,'run','extract_boundaries%sopt'%(self.dacycle['time.sample.stamp'][0:10])) - extracted_file = os.path.join(self.simulationdir,'extracted','output_%s_opt'%(self.dacycle['time.sample.stamp'][0:10])) + extracted_file = os.path.join( + self.simulationdir, 'extracted', + 'output_%s_opt' % (self.dacycle['time.sample.stamp'][0:10])) else: - if lag==0: - runscript = os.path.join(self.simulationdir,'run','runscript_%spriorcycle1'%(self.dacycle['time.sample.stamp'][0:10])) - extraction_script = os.path.join(self.simulationdir,'run','extract_%spriorcycle1'%(self.dacycle['time.sample.stamp'][0:10])) - extracted_file = os.path.join(self.simulationdir,'extracted','output_%s_priorcycle1'%(self.dacycle['time.sample.stamp'][0:10])) + if lag == 0: + runscript = os.path.join( + self.simulationdir, 'run', 'runscript_%spriorcycle1' % + (self.dacycle['time.sample.stamp'][0:10])) + extraction_script = os.path.join( + self.simulationdir, 'run', 'extract_%spriorcycle1' % + (self.dacycle['time.sample.stamp'][0:10])) + extracted_file = os.path.join( + self.simulationdir, 'extracted', 'output_%s_priorcycle1' % + (self.dacycle['time.sample.stamp'][0:10])) else: - runscript = os.path.join(self.simulationdir,'run','runscript_%sprior'%(self.dacycle['time.sample.stamp'][0:10])) - extraction_script = os.path.join(self.simulationdir,'run','extract_%sprior'%(self.dacycle['time.sample.stamp'][0:10])) + runscript = os.path.join( + self.simulationdir, 'run', 'runscript_%sprior' % + (self.dacycle['time.sample.stamp'][0:10])) + extraction_script = os.path.join( + self.simulationdir, 'run', 'extract_%sprior' % + (self.dacycle['time.sample.stamp'][0:10])) #extraction_script_boundaries = os.path.join(self.simulationdir,'run','extract_boundaries%sprior'%(self.dacycle['time.sample.stamp'][0:10])) - #icon_path = os.path.join(self.simulationdir,'output_%s_prior'%(self.dacycle['time.sample.stamp'][0:10])) - extracted_file = os.path.join(self.simulationdir,'extracted','output_%s_prior'%(self.dacycle['time.sample.stamp'][0:10])) - runscript_boundaries = os.path.join(self.simulationdir,'run_bg','runscript_boundaries%spriorcycle1'%(self.dacycle['time.sample.stamp'][0:10])) - extraction_script_boundaries = os.path.join(self.simulationdir,'run_bg','extract_boundaries%spriorcycle1'%(self.dacycle['time.sample.stamp'][0:10])) - extracted_boundaries_ens_file = os.path.join(self.simulationdir,'extracted','output_bg_%s_priorcycle1'%(self.dacycle['time.sample.stamp'][0:10])) - logging.info('extraction_script: %s'%(extraction_script)) - - template = os.path.join(self.simulationdir,'run','templates','sbatch_extract_template') - sbatch_script = os.path.join(self.simulationdir,'run','sbatch_script') - sbatch_script_bg = os.path.join(self.simulationdir,'run_bg','sbatch_script') + #icon_path = os.path.join(self.simulationdir,'output_%s_prior'%(self.dacycle['time.sample.stamp'][0:10])) + extracted_file = os.path.join( + self.simulationdir, 'extracted', 'output_%s_prior' % + (self.dacycle['time.sample.stamp'][0:10])) + runscript_boundaries = os.path.join( + self.simulationdir, 'run_bg', 'runscript_boundaries%spriorcycle1' % + (self.dacycle['time.sample.stamp'][0:10])) + extraction_script_boundaries = os.path.join( + self.simulationdir, 'run_bg', 'extract_boundaries%spriorcycle1' % + (self.dacycle['time.sample.stamp'][0:10])) + extracted_boundaries_ens_file = os.path.join( + self.simulationdir, 'extracted', 'output_bg_%s_priorcycle1' % + (self.dacycle['time.sample.stamp'][0:10])) + logging.info('extraction_script: %s' % (extraction_script)) + + template = os.path.join(self.simulationdir, 'run', 'templates', + 'sbatch_extract_template') + sbatch_script = os.path.join(self.simulationdir, 'run', + 'sbatch_script') + sbatch_script_bg = os.path.join(self.simulationdir, 'run_bg', + 'sbatch_script') # Write sbatch file with open(template) as input_file: to_write = input_file.read() with open(sbatch_script, "w") as outf: - outf.write(to_write.format(extract_script=extraction_script)) + outf.write(to_write.format(extract_script=extraction_script)) self.extracted_file = extracted_file # inidata = os.path.join( @@ -332,7 +419,7 @@ def run(self,samples,statevector,lag): # link = os.path.join( # '/users/nponomar/Emissions/ART', #ART input folder same as specified in ICON nml # 'ART_ICE_iconR19B09-grid_.nc' #ini5 from processing chain - # ) + # ) # os.system('ln -sf ' + inidata + ' ' + link) #now run ICON-ART-OEM: @@ -346,14 +433,14 @@ def run(self,samples,statevector,lag): # self.start_multiple_icon_jobs([sbatch_script, sbatch_script_bg]) # logging.info('Extraction for ensemble and boudnaries runs - done!') while not (os.path.exists(extracted_file)): - logging.info('In branch 1') - logging.info('runscript name: %s'%(runscript)) - self.start_icon(runscript) - logging.info('ICON done!') - #now run the extraction script: - self.start_icon(sbatch_script) - logging.info('extractionscript name: %s'%(sbatch_script)) - logging.info('Extraction done!') + logging.info('In branch 1') + logging.info('runscript name: %s' % (runscript)) + self.start_icon(runscript) + logging.info('ICON done!') + #now run the extraction script: + self.start_icon(sbatch_script) + logging.info('extractionscript name: %s' % (sbatch_script)) + logging.info('Extraction done!') # if not (os.path.exists(extracted_boundaries_ens_file)): # logging.info('In branch 2') # logging.info('runscript name: %s'%(runscript_boundaries)) @@ -365,36 +452,33 @@ def run(self,samples,statevector,lag): # logging.info('runscript name: %s'%(sbatch_script_bg)) # logging.info('Extraction done!') - - - def sample(self,samples): - for j,sample in enumerate(samples): + def sample(self, samples): + for j, sample in enumerate(samples): sample_type = sample.get_samples_type() logging.info(f"Want to do...{{sample_type}} extraction") if sample_type == "column": logging.info("Starting _launch_icon_column_sampling") - + warning_msg = "JM: Be careful! The current column sampling " + \ "method is designed for a specific case of study. " + \ "Please evaluate if the satellite product is suitable " + \ "with an appropriate model spatial resolution!" - logging.warning( warning_msg ) - - self._launch_icon_column_sampling(j,sample) - + logging.warning(warning_msg) + + self._launch_icon_column_sampling(j, sample) + logging.info("Finished _launch_icon_column_sampling") - + elif sample_type == "insitu": - self.ICOS_sampling(j,sample) - + self.ICOS_sampling(j, sample) + else: logging.error("Unknown sample type: %s", sample.get_samples_type()) - - def ICOS_sampling(self,j,sample): + def ICOS_sampling(self, j, sample): # logging.info('WARNING!! Just for testing, Im copying the input file to the output file!') - + # cmd = f"cp {{self.dacycle['ObsOperator.inputfile.'+sample.get_samples_type()]}} {{self.simulated_file[j]}}" # logging.info(f"Will run cmd={{cmd}}") # os.system(cmd) @@ -402,35 +486,41 @@ def ICOS_sampling(self,j,sample): # logging.info(f"Will run cmd={{cmd}}") # os.system(cmd) # return - + # Create a flask output file to hold simulated values for later reading f = io.CT_CDF(self.simulated_file[j], method='create') - logging.debug('Creating new simulated observation file in ObservationOperator (%s)' % self.simulated_file) - + logging.debug( + 'Creating new simulated observation file in ObservationOperator (%s)' + % self.simulated_file) + dimid = f.createDimension('obs_num', size=None) - dimid = ('obs_num',) - savedict = io.std_savedict.copy() + dimid = ('obs_num', ) + savedict = io.std_savedict.copy() savedict['name'] = "obs_num" savedict['dtype'] = "int" savedict['long_name'] = "Unique_Dataset_observation_index_number" savedict['units'] = "" savedict['dims'] = dimid - savedict['comment'] = "Unique index number within this dataset ranging from 0 to UNLIMITED." - f.add_data(savedict,nsets=0) + savedict[ + 'comment'] = "Unique index number within this dataset ranging from 0 to UNLIMITED." + f.add_data(savedict, nsets=0) dimmember = f.createDimension('nmembers', size=self.forecast_nmembers) - dimmember = ('nmembers',) - savedict = io.std_savedict.copy() + dimmember = ('nmembers', ) + savedict = io.std_savedict.copy() savedict['name'] = "flask" savedict['dtype'] = "float" savedict['long_name'] = "mole_fraction_of_trace_gas_in_air" savedict['units'] = "mol tracer (mol air)^-1" savedict['dims'] = dimid + dimmember - savedict['comment'] = "Simulated model value created by RandomizerObservationOperator" - f.add_data(savedict,nsets=0) + savedict[ + 'comment'] = "Simulated model value created by RandomizerObservationOperator" + f.add_data(savedict, nsets=0) # Open file with x,y,z,t of model samples that need to be sampled - f_in = io.ct_read(self.dacycle['ObsOperator.inputfile.'+sample.get_samples_type()],method='read') + f_in = io.ct_read(self.dacycle['ObsOperator.inputfile.' + + sample.get_samples_type()], + method='read') # Get simulated values and ID @@ -446,156 +536,176 @@ def ICOS_sampling(self,j,sample): # Loop over observations, add random white noise, and write to file -########################################################### + ########################################################### os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE" - - molar_mass = {{'ch4' : 16.04e-3, - 'co2' : 44.01e-3, - 'da' : 28.97e-3 - }} - units_factor = {{'ch4' : 1.e9, #ppb for ch4 - 'co2' : 1.e6, #ppm for co2 - }} + + molar_mass = {{'ch4': 16.04e-3, 'co2': 44.01e-3, 'da': 28.97e-3}} + units_factor = {{ + 'ch4': 1.e9, #ppb for ch4 + 'co2': 1.e6, #ppm for co2 + }} #M_CH4 = 16.04e-3 #mol. weight CH4 [kg/mol] #M_da = 28.97e-3 #mol. weight dry air [kg/mol] #mountain_sites = ['cmn_insitu','jfj_insitu','kas_insitu','oxk_icos','oxk_ingos','oxk_noaa','pdm_lsceflask','puy_insitu','puy_lsceflask','zsf_wdcgg','cur_wdcgg','pdm_lsce','snb_wdcgg'] - mountain_stations = ['Jungfraujoch_5', - 'Monte Cimone_8', - 'Puy de Dome_10', - 'Pic du Midi_28', - 'Zugspitze_3', - 'Hohenpeissenberg_50', - 'Hohenpeissenberg_93', - 'Hohenpeissenberg_131', - 'Schauinsland_12', - 'Plateau Rosa_10'] - skip_stations = ['Malin Head_47', - 'Hegyhatsal hatterszennyettseg-mero allomas_48', - 'Hegyhatsal hatterszennyettseg-mero allomas_82', - 'Birkenes_2', - 'Hegyhatsal hatterszennyettseg-mero allomas_115', - 'Hegyhatsal hatterszennyettseg-mero allomas_10', - 'Beromunster_12', - 'Beromunster_44', - 'Beromunster_72', - 'Beromunster_132', - 'Bilsdale_42', - 'Bilsdale_108', - 'Cabauw_27', - 'Cabauw_67', - 'Cabauw_127', - 'Gartow_30', - 'Gartow_60', - 'Gartow_132', - 'Gartow_216', - 'Hohenpeissenberg_50', - 'Hohenpeissenberg_93', - 'Hyltemossa_30', - 'Hyltemossa_70', - 'Ispara_40', - 'Ispra_70', - 'Karlsruhe_30', - 'Karlsruhe_60', - 'Karlsruhe_100', - 'Kresin u Pacova_10', - 'Kresin u Pacova_50', - 'Kresin u Pacova_125', - 'Lindenberg_2', - 'Lindenberg_10', - 'Lindenberg_40', - 'Observatoire de Haute Provence_10', - 'Observatoire de Haute Provence_50', - "Observatoire perenne de l'environnement_10", - "Observatoire perenne de l'environnement_50", - 'Ridge Hill_45', - 'Saclay_15', - 'Saclay_60', - 'Tacolneston_54', - 'Tacolneston_100', - 'Torfhaus_10', - 'Torfhaus_76', - 'Torfhaus_110', - 'Trainou_5', - 'Trainou_50', - 'Trainou_100', - ] - - simulated_values = np.zeros((len(obs),self.forecast_nmembers)) - - f1 = io.ct_read(self.extracted_file,method='read') - TR_A_ENS = (molar_mass['da']/molar_mass[self.tracer])*units_factor[self.tracer]*np.array(f1.get_variable('TR'+self.tracer.upper()+'_A_ENS') + f1.get_variable('biosource_all_chemtr') - f1.get_variable('biosink_chemtr')) #float CH4_A_ENS(ens, sites, time) 1 --> ppb + mountain_stations = [ + 'Jungfraujoch_5', 'Monte Cimone_8', 'Puy de Dome_10', + 'Pic du Midi_28', 'Zugspitze_3', 'Hohenpeissenberg_50', + 'Hohenpeissenberg_93', 'Hohenpeissenberg_131', 'Schauinsland_12', + 'Plateau Rosa_10' + ] + skip_stations = [ + 'Malin Head_47', + 'Hegyhatsal hatterszennyettseg-mero allomas_48', + 'Hegyhatsal hatterszennyettseg-mero allomas_82', + 'Birkenes_2', + 'Hegyhatsal hatterszennyettseg-mero allomas_115', + 'Hegyhatsal hatterszennyettseg-mero allomas_10', + 'Beromunster_12', + 'Beromunster_44', + 'Beromunster_72', + 'Beromunster_132', + 'Bilsdale_42', + 'Bilsdale_108', + 'Cabauw_27', + 'Cabauw_67', + 'Cabauw_127', + 'Gartow_30', + 'Gartow_60', + 'Gartow_132', + 'Gartow_216', + 'Hohenpeissenberg_50', + 'Hohenpeissenberg_93', + 'Hyltemossa_30', + 'Hyltemossa_70', + 'Ispara_40', + 'Ispra_70', + 'Karlsruhe_30', + 'Karlsruhe_60', + 'Karlsruhe_100', + 'Kresin u Pacova_10', + 'Kresin u Pacova_50', + 'Kresin u Pacova_125', + 'Lindenberg_2', + 'Lindenberg_10', + 'Lindenberg_40', + 'Observatoire de Haute Provence_10', + 'Observatoire de Haute Provence_50', + "Observatoire perenne de l'environnement_10", + "Observatoire perenne de l'environnement_50", + 'Ridge Hill_45', + 'Saclay_15', + 'Saclay_60', + 'Tacolneston_54', + 'Tacolneston_100', + 'Torfhaus_10', + 'Torfhaus_76', + 'Torfhaus_110', + 'Trainou_5', + 'Trainou_50', + 'Trainou_100', + ] + + simulated_values = np.zeros((len(obs), self.forecast_nmembers)) + + f1 = io.ct_read(self.extracted_file, method='read') + TR_A_ENS = (molar_mass['da'] / molar_mass[self.tracer]) * units_factor[ + self.tracer] * np.array( + f1.get_variable('TR' + self.tracer.upper() + '_A_ENS') + + f1.get_variable('biosource_all_chemtr') - + f1.get_variable('biosink_chemtr') + ) #float CH4_A_ENS(ens, sites, time) 1 --> ppb qv = np.array(f1.get_variable('qv')) #float qv(sites, time) site_names = np.array(f1.get_variable('site_name')) obs_times = np.array(f1.get_variable('time')) # wet --> dry mmr for iiens in np.arange(TR_A_ENS.shape[0]): - TR_A_ENS[iiens,...] = TR_A_ENS[iiens,...]/(1.-qv[...]) - + TR_A_ENS[iiens, ...] = TR_A_ENS[iiens, ...] / (1. - qv[...]) #LOOP OVER OBS: for iobs in np.arange(len(obs)): - station_name = fromfile[iobs][fromfile[iobs]!=b''].tostring().decode('utf-8') - if station_name in skip_stations: continue # Skip stations outside of the domain! - print('DEBUG iobs: ',iobs,flush=True) - obs_date = dt.datetime(*date_components[iobs,:]) - print('DEBUG obs_date: ',obs_date,flush=True) - obs_date = obs_date.replace(minute=0,second=0) - print('DEBUG modified obs_date: ',obs_date,flush=True) + station_name = fromfile[iobs][fromfile[iobs] != + b''].tostring().decode('utf-8') + if station_name in skip_stations: + continue # Skip stations outside of the domain! + print('DEBUG iobs: ', iobs, flush=True) + obs_date = dt.datetime(*date_components[iobs, :]) + print('DEBUG obs_date: ', obs_date, flush=True) + obs_date = obs_date.replace(minute=0, second=0) + print('DEBUG modified obs_date: ', obs_date, flush=True) # LOOP OVER EXTRACTED DATA TIMES for itime in np.arange(TR_A_ENS.shape[2]): - otime = dt.datetime.strptime(obs_times[itime],'%Y-%m-%dT%H') -# print('DEBUG checking otime: ',otime,flush=True) + otime = dt.datetime.strptime(obs_times[itime], '%Y-%m-%dT%H') + # print('DEBUG checking otime: ',otime,flush=True) if not (obs_date == otime): continue - print('DEBUG found otime: ',otime,flush=True) + print('DEBUG found otime: ', otime, flush=True) # find index (or the difference) of hour at 12 UTC and 0 UTC if station_name in mountain_stations: - print('DEBUG station',station_name, 'is a mountain site',flush=True) + print('DEBUG station', + station_name, + 'is a mountain site', + flush=True) delta_index = obs_date.hour - print('DEBUG delta_index: ',delta_index,flush=True) + print('DEBUG delta_index: ', delta_index, flush=True) else: - print('DEBUG station',station_name, 'is NOT a mountain site',flush=True) + print('DEBUG station', + station_name, + 'is NOT a mountain site', + flush=True) delta_index = obs_date.hour - 12 - print('DEBUG delta_index: ',delta_index,flush=True) - + print('DEBUG delta_index: ', delta_index, flush=True) # LOOP OVER STATIONS for isite in np.arange(TR_A_ENS.shape[1]): site_name = site_names[isite] -# print('DEBUG looking through sampled stations. Checking site_name: ',site_name,flush=True) - if (site_name==station_name): - print('DEBUG looking through sampled stations. Found site_name: ',site_name,flush=True) + # print('DEBUG looking through sampled stations. Checking site_name: ',site_name,flush=True) + if (site_name == station_name): + print( + 'DEBUG looking through sampled stations. Found site_name: ', + site_name, + flush=True) for iens in np.arange(self.forecast_nmembers): if station_name in mountain_stations: - simulated_values[iobs,iens] = np.nanmean(TR_A_ENS[iens,isite,itime-delta_index:itime-delta_index+7]) + simulated_values[iobs, iens] = np.nanmean( + TR_A_ENS[iens, isite, + itime - delta_index:itime - + delta_index + 7]) else: - simulated_values[iobs,iens] = np.nanmean(TR_A_ENS[iens,isite,itime-delta_index:itime-delta_index+5]) - if iens==50: - print('Added model value for member 0 of %.2f for iobs %i at %s at %s with a delta idx of %i'%(simulated_values[iobs,0],iobs,site_name,obs_date,delta_index)) - print('Added model value for member 50 of %.2f for iobs %i at %s at %s with a delta idx of %i'%(simulated_values[iobs,50],iobs,site_name,obs_date,delta_index)) + simulated_values[iobs, iens] = np.nanmean( + TR_A_ENS[iens, isite, + itime - delta_index:itime - + delta_index + 5]) + if iens == 50: + print( + 'Added model value for member 0 of %.2f for iobs %i at %s at %s with a delta idx of %i' + % (simulated_values[iobs, 0], iobs, + site_name, obs_date, delta_index)) + print( + 'Added model value for member 50 of %.2f for iobs %i at %s at %s with a delta idx of %i' + % (simulated_values[iobs, 50], iobs, + site_name, obs_date, delta_index)) break else: continue break ########################################################### - - - for i in range(0,len(obs)): + for i in range(0, len(obs)): f.variables['obs_num'][i] = ids[i] - f.variables['flask'][i,:] = simulated_values[i] + f.variables['flask'][i, :] = simulated_values[i] f.close() f_in.close() # Report success and exit - logging.info('ICOS ObservationOperator finished successfully, output file written (%s)' % self.simulated_file) - + logging.info( + 'ICOS ObservationOperator finished successfully, output file written (%s)' + % self.simulated_file) def _launch_icon_column_sampling(self, j, sample): """Sample ICON output at coordinates of column observations.""" @@ -604,24 +714,26 @@ def _launch_icon_column_sampling(self, j, sample): # To be continued.... # run_dir = self.settings["dir.icon_sim"] # Erik: run_dir here means: output dir. # run_dir = '/scratch/snx3000/ekoene/processing-chain/work/VPRM_EU_ERA5_22/XCO2_test' # This should, eventually, be determined automatically from however the folder structure is made! - run_dir = os.path.join(self.simulationdir,os.path.basename(self.extracted_file)) - logging.info(f"Directory that satellite data will be taken from: {{run_dir}}") + run_dir = os.path.join(self.simulationdir, + os.path.basename(self.extracted_file)) + logging.info( + f"Directory that satellite data will be taken from: {{run_dir}}") - sampling_coords_file = self.dacycle['ObsOperator.inputfile.'+sample.get_samples_type()] + sampling_coords_file = self.dacycle['ObsOperator.inputfile.' + + sample.get_samples_type()] logging.info(f"Sampling coords file: {{sampling_coords_file}}") # Reconstruct self.simulated_file[i] out_file = self.simulated_file[j] # out_file = self._sim_fpattern % sample.get_samples_type() - + # Remove intermediate files from a previous sampling job (might # still be there if that one fails) # The file pattern is hardcoded in wrfout_sampler - # slicefile_pattern = out_file + ".*.slice" + # slicefile_pattern = out_file + ".*.slice" # for f in glob.glob(os.path.join(run_dir, slicefile_pattern)): # os.remove(f) - # Sould be parallelized? # Spawn multiple icon_sampler instances, # using at most all processes available @@ -636,21 +748,21 @@ def _launch_icon_column_sampling(self, j, sample): if Nobs == 0: logging.info("No observations, skipping sampling") return - + # Might want to increase this, no idea if this is reasonable nobs_min = 100 - nprocs2 = max(1, int(float(Nobs)/float(nobs_min))) + nprocs2 = max(1, int(float(Nobs) / float(nobs_min))) # Number of processes to use: nprocs = min(nprocs1, nprocs2) # Make run command - # For a task with 1 processor, specifically request -N1 because - # otherwise slurm apparently sometimes tries to allocate one task to + # For a task with 1 processor, specifically request -N1 because + # otherwise slurm apparently sometimes tries to allocate one task to # more than one node. Or something like that. See here: # https://stackoverflow.com/questions/24056961/running-slurm-script-with-multiple-nodes-launch-job-steps-with-1-task #command_ = "srun --exclusive -n1 -N1" - command_ = " " # Erik: this would have to look different for us + command_ = " " # Erik: this would have to look different for us # Check if output slice files are already present # This shouldn't happen, because they are deleted @@ -668,24 +780,24 @@ def _launch_icon_column_sampling(self, j, sample): procs = list() for nproc in range(nprocs): cmd = " ".join([ - command_, - "python ./da/tools/icon/icon_sampler.py", - "--nproc %d" % nproc, - "--nprocs %d" % nprocs, - "--sampling_coords_file %s" % sampling_coords_file, - "--run_dir %s" % run_dir, - "--iconout_prefix %s" % self.settings["output_prefix"], - "--icon_grid %s" % self.settings["icon_grid_path"], - "--nmembers %d" % int(self.dacycle["da.optimizer.nmembers"]), - "--tracer_optim %s" % self.settings["tracer_optim"], - "--outfile_prefix %s" % out_file, - "--footprint_samples_dim %d" % int(self.settings['obs.column.footprint_samples_dim']) + command_, "python ./da/tools/icon/icon_sampler.py", + "--nproc %d" % nproc, + "--nprocs %d" % nprocs, + "--sampling_coords_file %s" % sampling_coords_file, + "--run_dir %s" % run_dir, + "--iconout_prefix %s" % self.settings["output_prefix"], + "--icon_grid %s" % self.settings["icon_grid_path"], + "--nmembers %d" % int(self.dacycle["da.optimizer.nmembers"]), + "--tracer_optim %s" % self.settings["tracer_optim"], + "--outfile_prefix %s" % out_file, + "--footprint_samples_dim %d" % + int(self.settings['obs.column.footprint_samples_dim']) ]) - - procs.append(subprocess.Popen(cmd.split(), - stdout=subprocess.PIPE, - stderr=subprocess.STDOUT)) - + + procs.append( + subprocess.Popen(cmd.split(), + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT)) logging.info("Started %d sampling process(es).", nprocs) logging.debug("Command of last process: %s", cmd) @@ -693,7 +805,7 @@ def _launch_icon_column_sampling(self, j, sample): # Wait for all processes to finish for n in range(nprocs): procs[n].wait() - + # Check for errors retcodes = [] for n in range(nprocs): @@ -705,55 +817,58 @@ def _launch_icon_column_sampling(self, j, sample): "finished with errors.") logging.info("All sampling processes finished.") - + # Join output files logging.info("Joining output files.") ### Some code for joining the files if nprocs > 1: - utilities.cat_ncfiles(run_dir, slicefile_pattern, - "sounding_id", out_file, - in_pattern=True) + utilities.cat_ncfiles(run_dir, + slicefile_pattern, + "sounding_id", + out_file, + in_pattern=True) - # Finishing msg + # Finishing msg logging.info("ICON column output sampled.") logging.info("If samples object carried observations, output " + \ "file written to %s", self.simulated_file) - ######################################################################################## - def run_forecast_model(self,samples,statevector,lag,dacycle): + + def run_forecast_model(self, samples, statevector, lag, dacycle): self.startdate = dacycle['time.sample.start'] self.prepare_run(samples) - self.make_lambdas(statevector,lag) + self.make_lambdas(statevector, lag) self.validate_input() - self.run(samples,statevector,lag) + self.run(samples, statevector, lag) self.sample(samples) self.save_data() - - def start_icon(self, runscript): - os.system('sbatch --wait '+runscript) + os.system('sbatch --wait ' + runscript) # pass + def start_multiple_icon_jobs(self, scripts): files = scripts #command = "sbatch --wait " - os.system('sbatch '+files[1]) - os.system('sbatch --wait '+files[0]) + os.system('sbatch ' + files[1]) + os.system('sbatch --wait ' + files[0]) # processes = list() # max_processes = len(files) - # for name in files: # logging.info('Starting a new job: %s'%(command + name)) # processes.append(subprocess.Popen([command + name], shell=True)) - + # # if len(processes) >= max_processes: # os.wait() - # processes.difference_update([ - # p for p in processes if p.poll() is not None]) + # processes.difference_update([ + # p for p in processes if p.poll() is not None]) + + ################### End Class ObservationOperator ################### + class RandomizerObservationOperator(ObservationOperator): """ This class holds methods and variables that are needed to use a random number generated as substitute for a true observation operator. It takes observations and returns values for each obs, with a specified @@ -761,6 +876,5 @@ class RandomizerObservationOperator(ObservationOperator): """ - if __name__ == "__main__": pass diff --git a/cases/icon-art-CTDAS2/ctdas_patch/optimizer_baseclass_icos_cities.py b/cases/icon-art-CTDAS2/ctdas_patch/optimizer_baseclass_icos_cities.py index 230e5ffc..1c6ff97f 100644 --- a/cases/icon-art-CTDAS2/ctdas_patch/optimizer_baseclass_icos_cities.py +++ b/cases/icon-art-CTDAS2/ctdas_patch/optimizer_baseclass_icos_cities.py @@ -12,7 +12,6 @@ program. If not, see .""" #!/usr/bin/env python # optimizer.py - """ .. module:: optimizer .. moduleauthor:: Wouter Peters @@ -35,6 +34,7 @@ ################### Begin Class Optimizer ################### + class Optimizer(object): """ This creates an instance of an optimization object. It handles the minimum least squares optimization @@ -61,25 +61,34 @@ def create_matrices(self): """ Create Matrix space needed in optimization routine """ # mean state [X] - self.x = np.zeros((self.nlag * self.nparams,), float) + self.x = np.zeros((self.nlag * self.nparams, ), float) # deviations from mean state [X'] - self.X_prime = np.zeros((self.nlag * self.nparams, self.nmembers,), float) + self.X_prime = np.zeros(( + self.nlag * self.nparams, + self.nmembers, + ), float) # mean state, transported to observation space [ H(X) ] - self.Hx = np.zeros((self.nobs,), float) + self.Hx = np.zeros((self.nobs, ), float) # deviations from mean state, transported to observation space [ H(X') ] self.HX_prime = np.zeros((self.nobs, self.nmembers), float) # observations - self.obs = np.zeros((self.nobs,), float) + self.obs = np.zeros((self.nobs, ), float) # observation ids - self.obs_ids = np.zeros((self.nobs,), float) + self.obs_ids = np.zeros((self.nobs, ), float) # covariance of observations # Total covariance of fluxes and obs in units of obs [H P H^t + R] if self.algorithm == 'Serial': - self.R = np.zeros((self.nobs,), float) - self.HPHR = np.zeros((self.nobs,), float) + self.R = np.zeros((self.nobs, ), float) + self.HPHR = np.zeros((self.nobs, ), float) else: - self.R = np.zeros((self.nobs, self.nobs,), float) - self.HPHR = np.zeros((self.nobs, self.nobs,), float) + self.R = np.zeros(( + self.nobs, + self.nobs, + ), float) + self.HPHR = np.zeros(( + self.nobs, + self.nobs, + ), float) # localization of obs self.may_localize = np.zeros(self.nobs, bool) # rejection of obs @@ -101,52 +110,65 @@ def create_matrices(self): # Kalman Gain matrix #self.KG = np.zeros((self.nlag * self.nparams, self.nobs,), float) - self.KG = np.zeros((self.nlag * self.nparams,), float) + self.KG = np.zeros((self.nlag * self.nparams, ), float) #msteiner: self.evn = np.zeros(self.nobs, str) self.fromfile = np.zeros(self.nobs, str) - + #read loc_coeffs from file ds = xr.open_dataset(self.loc_coeffs) - self.coeff_matrix = np.exp(-ds.Distances.values/400).T # ERIK: I set this to 400 as a rough footprint size for a station (was 600 km for Michael; 60 km for Nikolai) + self.coeff_matrix = np.exp( + -ds.Distances.values / 400 + ).T # ERIK: I set this to 400 as a rough footprint size for a station (was 600 km for Michael; 60 km for Nikolai) self.name_array = ds.Stations_names.values - def state_to_matrix(self, statevector): - allsites = [] # collect all obs for n=1,..,nlag - allobs = [] # collect all obs for n=1,..,nlag - allmdm = [] # collect all mdm for n=1,..,nlag + allsites = [] # collect all obs for n=1,..,nlag + allobs = [] # collect all obs for n=1,..,nlag + allmdm = [] # collect all mdm for n=1,..,nlag allids = [] # collect all model samples for n=1,..,nlag allreject = [] # collect all model samples for n=1,..,nlag alllocalize = [] # collect all model samples for n=1,..,nlag allflags = [] # collect all model samples for n=1,..,nlag allspecies = [] # collect all model samples for n=1,..,nlag allsimulated = [] # collect all members model samples for n=1,..,nlag - allrej_thres = [] # collect all rejection_thresholds, will be the same for all samples of same source - alllats = [] # collect all latitudes for n=1,..,nlag - alllons = [] # collect all longitudes for n=1,..,nlag + allrej_thres = [ + ] # collect all rejection_thresholds, will be the same for all samples of same source + alllats = [] # collect all latitudes for n=1,..,nlag + alllons = [] # collect all longitudes for n=1,..,nlag #msteiner: - allevns = [] # collect all evns for finding loc_coeffs in localize() - allfromfiles = [] # collect all evns for finding loc_coeffs in localize() + allevns = [] # collect all evns for finding loc_coeffs in localize() + allfromfiles = [ + ] # collect all evns for finding loc_coeffs in localize() for n in range(self.nlag): samples = statevector.obs_to_assimilate[n] members = statevector.ensemble_members[n] - self.x[n * self.nparams:(n + 1) * self.nparams] = members[0].param_values - self.X_prime[n * self.nparams:(n + 1) * self.nparams, :] = np.transpose(np.array([m.param_values for m in members])) + self.x[n * self.nparams:(n + 1) * + self.nparams] = members[0].param_values + self.X_prime[n * self.nparams:(n + 1) * + self.nparams, :] = np.transpose( + np.array([m.param_values for m in members])) # Add observation data for all sample objects if samples != None: if type(samples) != list: samples = [samples] for m in range(len(samples)): sample = samples[m] - logging.debug('Lag %i, sample %i: rejection_threshold = %i, nobs = %i' %(n, m, sample.rejection_threshold, sample.getlength())) - logging.info('Lag %i, sample %i: rejection_threshold = %i, nobs = %i' %(n, m, sample.rejection_threshold, sample.getlength())) + logging.debug( + 'Lag %i, sample %i: rejection_threshold = %i, nobs = %i' + % + (n, m, sample.rejection_threshold, sample.getlength())) + logging.info( + 'Lag %i, sample %i: rejection_threshold = %i, nobs = %i' + % + (n, m, sample.rejection_threshold, sample.getlength())) logging.info(f'{{dir(sample)}}') alllats.extend(sample.getvalues('lat')) alllons.extend(sample.getvalues('lon')) - allrej_thres.extend([sample.rejection_threshold] * sample.getlength()) + allrej_thres.extend([sample.rejection_threshold] * + sample.getlength()) allreject.extend(sample.getvalues('may_reject')) alllocalize.extend(sample.getvalues('may_localize')) allflags.extend(sample.getvalues('flag')) @@ -161,9 +183,13 @@ def state_to_matrix(self, statevector): allevns.extend(sample.getvalues('evn')) allfromfiles.extend(sample.getvalues('fromfile')) except: - logging.debug(f"Number of copies: {{len(sample.getvalues('lat'))}}") - allevns.extend(['column']*len(sample.getvalues('lat'))) - allfromfiles.extend(['column']*len(sample.getvalues('lat'))) + logging.debug( + f"Number of copies: {{len(sample.getvalues('lat'))}}" + ) + allevns.extend(['column'] * + len(sample.getvalues('lat'))) + allfromfiles.extend(['column'] * + len(sample.getvalues('lat'))) simulatedensemble = sample.getvalues('simulated') for s in range(simulatedensemble.shape[0]): allsimulated.append(simulatedensemble[s]) @@ -187,37 +213,52 @@ def state_to_matrix(self, statevector): self.fromfile = allfromfiles # ~~~~~~~~ NEW SINCE OCO2, but generally valid: Setup localization (distance between observations and regions) - OBSERVATIONS_IN_RADIANS_LATLON = np.deg2rad(np.column_stack([self.latitude,self.longitude])) - grid = xr.open_dataset('/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc') + OBSERVATIONS_IN_RADIANS_LATLON = np.deg2rad( + np.column_stack([self.latitude, self.longitude])) + grid = xr.open_dataset( + '/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc') grid_latitudes = grid.lat_cell_centre.values grid_longitudes = grid.lon_cell_centre.values - REGIONS_IN_RADIANS_LATLON = np.column_stack([grid_latitudes,grid_longitudes]) - Distances = haversine_distances(OBSERVATIONS_IN_RADIANS_LATLON,REGIONS_IN_RADIANS_LATLON) * 6371000/1000 # distance to km s + REGIONS_IN_RADIANS_LATLON = np.column_stack( + [grid_latitudes, grid_longitudes]) + Distances = haversine_distances( + OBSERVATIONS_IN_RADIANS_LATLON, + REGIONS_IN_RADIANS_LATLON) * 6371000 / 1000 # distance to km s logging.debug(Distances) - self.coeff_matrix = np.exp(-Distances/400) # ERIK: I set this to 400 as a rough footprint size for a station (was 600 km for Michael; 60 km for Nikolai) - self.name_array = np.arange(OBSERVATIONS_IN_RADIANS_LATLON.shape[0]) # These should be 'names' but my pixels don't have names, of course! - - self.X_prime = self.X_prime - self.x[:, np.newaxis] # make into a deviation matrix - self.HX_prime = self.HX_prime - self.Hx[:, np.newaxis] # make a deviation matrix + self.coeff_matrix = np.exp( + -Distances / 400 + ) # ERIK: I set this to 400 as a rough footprint size for a station (was 600 km for Michael; 60 km for Nikolai) + self.name_array = np.arange( + OBSERVATIONS_IN_RADIANS_LATLON.shape[0] + ) # These should be 'names' but my pixels don't have names, of course! + + self.X_prime = self.X_prime - self.x[:, np. + newaxis] # make into a deviation matrix + self.HX_prime = self.HX_prime - self.Hx[:, np. + newaxis] # make a deviation matrix if self.algorithm == 'Serial': for i, mdm in enumerate(allmdm): - self.R[i] = mdm ** 2 + self.R[i] = mdm**2 else: for i, mdm in enumerate(allmdm): - self.R[i, i] = mdm ** 2 + self.R[i, i] = mdm**2 def matrix_to_state(self, statevector): for n in range(self.nlag): members = statevector.ensemble_members[n] for m, mem in enumerate(members): - members[m].param_values[:] = self.X_prime[n * self.nparams:(n + 1) * self.nparams, m] + self.x[n * self.nparams:(n + 1) * self.nparams] + members[m].param_values[:] = self.X_prime[ + n * self.nparams:(n + 1) * self.nparams, + m] + self.x[n * self.nparams:(n + 1) * self.nparams] #msteiner: statevector.isOptimized = True #--------- - logging.debug('Returning optimized data to the StateVector, setting "StateVector.isOptimized = True" ') + logging.debug( + 'Returning optimized data to the StateVector, setting "StateVector.isOptimized = True" ' + ) def write_diagnostics(self, filename, type): """ @@ -238,12 +279,15 @@ def write_diagnostics(self, filename, type): if type == 'prior': f = io.CT_CDF(filename, method='create') - logging.debug('Creating new diagnostics file for optimizer (%s)' % filename) + logging.debug('Creating new diagnostics file for optimizer (%s)' % + filename) elif type == 'optimized': f = io.CT_CDF(filename, method='write') - logging.debug('Opening existing diagnostics file for optimizer (%s)' % filename) + logging.debug( + 'Opening existing diagnostics file for optimizer (%s)' % + filename) - # Add dimensions + # Add dimensions dimparams = f.add_params_dim(self.nparams) dimmembers = f.add_members_dim(self.nmembers) @@ -254,7 +298,7 @@ def write_diagnostics(self, filename, type): # Add data, first the ones that are written both before and after the optimization - savedict = io.std_savedict.copy() + savedict = io.std_savedict.copy() savedict['name'] = "statevectormean_%s" % type savedict['long_name'] = "full_statevector_mean_%s" % type savedict['units'] = "unitless" @@ -269,7 +313,8 @@ def write_diagnostics(self, filename, type): savedict['units'] = "unitless" savedict['dims'] = dimstate + dimmembers savedict['values'] = self.X_prime.tolist() - savedict['comment'] = 'Full state vector %s deviations as resulting from the optimizer' % type + savedict[ + 'comment'] = 'Full state vector %s deviations as resulting from the optimizer' % type f.add_data(savedict) savedict = io.std_savedict.copy() @@ -278,7 +323,9 @@ def write_diagnostics(self, filename, type): savedict['units'] = "mol mol-1" savedict['dims'] = dimobs savedict['values'] = self.Hx.tolist() - savedict['comment'] = '%s mean mole fractions based on %s state vector' % (type, type) + savedict[ + 'comment'] = '%s mean mole fractions based on %s state vector' % ( + type, type) f.add_data(savedict) savedict = io.std_savedict.copy() @@ -287,7 +334,9 @@ def write_diagnostics(self, filename, type): savedict['units'] = "mol mol-1" savedict['dims'] = dimobs + dimmembers savedict['values'] = self.HX_prime.tolist() - savedict['comment'] = '%s mole fraction deviations based on %s state vector' % (type, type) + savedict[ + 'comment'] = '%s mole fraction deviations based on %s state vector' % ( + type, type) f.add_data(savedict) # Continue with prior only data @@ -296,7 +345,8 @@ def write_diagnostics(self, filename, type): savedict = io.std_savedict.copy() savedict['name'] = "sitecode" - savedict['long_name'] = "site code propagated from observation file" + savedict[ + 'long_name'] = "site code propagated from observation file" savedict['dtype'] = "char" savedict['dims'] = dimobs + dim200char savedict['values'] = self.sitecode @@ -319,7 +369,8 @@ def write_diagnostics(self, filename, type): savedict['units'] = "" savedict['dims'] = dimobs savedict['values'] = self.obs_ids.tolist() - savedict['comment'] = 'Unique observation number across the entire ObsPack distribution' + savedict[ + 'comment'] = 'Unique observation number across the entire ObsPack distribution' f.add_data(savedict) savedict = io.std_savedict.copy() @@ -328,24 +379,28 @@ def write_diagnostics(self, filename, type): savedict['units'] = "[mol mol-1]^2" if self.algorithm == 'Serial': savedict['dims'] = dimobs - else: savedict['dims'] = dimobs + dimobs + else: + savedict['dims'] = dimobs + dimobs savedict['values'] = self.R.tolist() - savedict['comment'] = 'Variance of mole fractions resulting from model-data mismatch' + savedict[ + 'comment'] = 'Variance of mole fractions resulting from model-data mismatch' f.add_data(savedict) # Continue with posterior only data elif type == 'optimized': - + savedict = io.std_savedict.copy() savedict['name'] = "totalmolefractionvariance" savedict['long_name'] = "totalmolefractionvariance" savedict['units'] = "[mol mol-1]^2" if self.algorithm == 'Serial': savedict['dims'] = dimobs - else: savedict['dims'] = dimobs + dimobs + else: + savedict['dims'] = dimobs + dimobs savedict['values'] = self.HPHR.tolist() - savedict['comment'] = 'Variance of mole fractions resulting from prior state and model-data mismatch' + savedict[ + 'comment'] = 'Variance of mole fractions resulting from prior state and model-data mismatch' f.add_data(savedict) savedict = io.std_savedict.copy() @@ -354,7 +409,8 @@ def write_diagnostics(self, filename, type): savedict['units'] = "None" savedict['dims'] = dimobs savedict['values'] = self.flags.tolist() - savedict['comment'] = 'Flag (0/1/2/99) for observation value, 0 means okay, 1 means QC error, 2 means rejected, 99 means not sampled' + savedict[ + 'comment'] = 'Flag (0/1/2/99) for observation value, 0 means okay, 1 means QC error, 2 means rejected, 99 means not sampled' f.add_data(savedict) #savedict = io.std_savedict.copy() @@ -369,22 +425,26 @@ def write_diagnostics(self, filename, type): f.close() logging.debug('Diagnostics file closed') - - def serial_minimum_least_squares(self,n_bg_params=0): + def serial_minimum_least_squares(self, n_bg_params=0): """ Make minimum least squares solution by looping over obs""" # Calculate prior value cost function (observation part) - res_prior = np.abs(self.obs-self.Hx) - select = (res_prior < 1E15).nonzero()[0] - J_prior = res_prior.take(select,axis=0)**2/self.R.take(select,axis=0) + res_prior = np.abs(self.obs - self.Hx) + select = (res_prior < 1E15).nonzero()[0] + J_prior = res_prior.take(select, axis=0)**2 / self.R.take(select, + axis=0) res_prior = np.mean(res_prior) for n in range(self.nobs): # Screen for flagged observations (for instance site not found, or no sample written from model) if self.flags[n] != 0: - logging.debug('Skipping observation (%s,%i) because of flag value %d' % (self.sitecode[n], self.obs_ids[n], self.flags[n])) - logging.info('Skipping observation (%s,%i) because of flag value %d' % (self.sitecode[n], self.obs_ids[n], self.flags[n])) + logging.debug( + 'Skipping observation (%s,%i) because of flag value %d' % + (self.sitecode[n], self.obs_ids[n], self.flags[n])) + logging.info( + 'Skipping observation (%s,%i) because of flag value %d' % + (self.sitecode[n], self.obs_ids[n], self.flags[n])) continue # Screen for outliers greather than 3x model-data mismatch, only apply if obs may be rejected @@ -394,56 +454,75 @@ def serial_minimum_least_squares(self,n_bg_params=0): if self.may_reject[n]: threshold = self.rejection_threshold[n] * np.sqrt(self.R[n]) if np.abs(res) > threshold: - logging.debug('Rejecting observation (%s,%i) because residual (%f) exceeds threshold (%f)' % (self.sitecode[n], self.obs_ids[n], res, threshold)) - logging.info('Rejecting observation (%s,%i) because residual (%f) exceeds threshold (%f)' % (self.sitecode[n], self.obs_ids[n], res, threshold)) + logging.debug( + 'Rejecting observation (%s,%i) because residual (%f) exceeds threshold (%f)' + % (self.sitecode[n], self.obs_ids[n], res, threshold)) + logging.info( + 'Rejecting observation (%s,%i) because residual (%f) exceeds threshold (%f)' + % (self.sitecode[n], self.obs_ids[n], res, threshold)) self.flags[n] = 2 continue - logging.debug('Proceeding to assimilate observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) - logging.info('Proceeding to assimilate observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) + logging.debug('Proceeding to assimilate observation %s, %i' % + (self.sitecode[n], self.obs_ids[n])) + logging.info('Proceeding to assimilate observation %s, %i' % + (self.sitecode[n], self.obs_ids[n])) - PHt = 1. / (self.nmembers - 1) * np.dot(self.X_prime, self.HX_prime[n, :]) - self.HPHR[n] = 1. / (self.nmembers - 1) * (self.HX_prime[n, :] * self.HX_prime[n, :]).sum() + self.R[n] - self.KG[:] = PHt / self.HPHR[n] + PHt = 1. / (self.nmembers - 1) * np.dot(self.X_prime, + self.HX_prime[n, :]) + self.HPHR[n] = 1. / (self.nmembers - 1) * ( + self.HX_prime[n, :] * self.HX_prime[n, :]).sum() + self.R[n] + self.KG[:] = PHt / self.HPHR[n] if self.may_localize[n]: - logging.debug('Trying to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) - logging.info('Trying to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) - self.localize(n,n_bg_params) + logging.debug('Trying to localize observation %s, %i' % + (self.sitecode[n], self.obs_ids[n])) + logging.info('Trying to localize observation %s, %i' % + (self.sitecode[n], self.obs_ids[n])) + self.localize(n, n_bg_params) else: - logging.debug('Not allowed to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) + logging.debug('Not allowed to localize observation %s, %i' % + (self.sitecode[n], self.obs_ids[n])) # logging.info('Not allowed to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) - alpha = np.double(1.0) / (np.double(1.0) + np.sqrt((self.R[n]) / self.HPHR[n])) + alpha = np.double(1.0) / (np.double(1.0) + np.sqrt( + (self.R[n]) / self.HPHR[n])) self.x[:] = self.x + self.KG[:] * res for r in range(self.nmembers): -# logging.info('X_prime before: %s'%(str(self.X_prime[:, r]))) - self.X_prime[:, r] = self.X_prime[:, r] - alpha * self.KG[:] * (self.HX_prime[n, r]) + # logging.info('X_prime before: %s'%(str(self.X_prime[:, r]))) + self.X_prime[:, + r] = self.X_prime[:, r] - alpha * self.KG[:] * ( + self.HX_prime[n, r]) # logging.info('X_prime after: %s'%(str(self.X_prime[:, r]))) # logging.info('======================================') del r # update samples to account for update of statevector based on observation n - HXprime_n = self.HX_prime[n,:].copy() - res = self.obs[n] - self.Hx[n] - fac = 1.0 / (self.nmembers - 1) * np.sum(HXprime_n[np.newaxis,:] * self.HX_prime, axis=1) / self.HPHR[n] - self.Hx = self.Hx + fac*res - self.HX_prime = self.HX_prime - alpha* fac[:,np.newaxis]*HXprime_n - + HXprime_n = self.HX_prime[n, :].copy() + res = self.obs[n] - self.Hx[n] + fac = 1.0 / (self.nmembers - 1) * np.sum( + HXprime_n[np.newaxis, :] * self.HX_prime, + axis=1) / self.HPHR[n] + self.Hx = self.Hx + fac * res + self.HX_prime = self.HX_prime - alpha * fac[:, + np.newaxis] * HXprime_n del n if 'HXprime_n' in globals(): del HXprime_n # calculate posterior value cost function - res_post = np.abs(self.obs-self.Hx) - select = (res_post < 1E15).nonzero()[0] - J_post = res_post.take(select,axis=0)**2/self.R.take(select,axis=0) + res_post = np.abs(self.obs - self.Hx) + select = (res_post < 1E15).nonzero()[0] + J_post = res_post.take(select, axis=0)**2 / self.R.take(select, axis=0) res_post = np.mean(res_post) - logging.info('Observation part cost function: prior = %s, posterior = %s' % (np.mean(J_prior), np.mean(J_post))) - logging.info('Mean residual: prior = %s, posterior = %s' % (res_prior, res_post)) + logging.info( + 'Observation part cost function: prior = %s, posterior = %s' % + (np.mean(J_prior), np.mean(J_post))) + logging.info('Mean residual: prior = %s, posterior = %s' % + (res_prior, res_post)) #WP !!!! Very important to first do all obervations from n=1 through the end, and only then update 1,...,n. The current observation #WP should always be updated last because it features in the loop of the adjustments !!!! @@ -460,46 +539,48 @@ def serial_minimum_least_squares(self,n_bg_params=0): # self.Hx[m] = self.Hx[m] + fac * res # self.HX_prime[m, :] = self.HX_prime[m, :] - alpha * fac * self.HX_prime[n, :] - - def bulk_minimum_least_squares(self): """ Make minimum least squares solution by solving matrix equations""" - # Create full solution, first calculate the mean of the posterior analysis - HPH = np.dot(self.HX_prime, np.transpose(self.HX_prime)) / (self.nmembers - 1) # HPH = 1/N * HX' * (HX')^T - self.HPHR[:, :] = HPH + self.R # HPHR = HPH + R - HPb = np.dot(self.X_prime, np.transpose(self.HX_prime)) / (self.nmembers - 1) # HP = 1/N X' * (HX')^T - self.KG[:, :] = np.dot(HPb, la.inv(self.HPHR)) # K = HP/(HPH+R) + HPH = np.dot(self.HX_prime, np.transpose(self.HX_prime)) / ( + self.nmembers - 1) # HPH = 1/N * HX' * (HX')^T + self.HPHR[:, :] = HPH + self.R # HPHR = HPH + R + HPb = np.dot(self.X_prime, np.transpose(self.HX_prime)) / ( + self.nmembers - 1) # HP = 1/N X' * (HX')^T + self.KG[:, :] = np.dot(HPb, la.inv(self.HPHR)) # K = HP/(HPH+R) for n in range(self.nobs): self.localize(n) - self.x[:] = self.x + np.dot(self.KG, self.obs - self.Hx) # xa = xp + K (y-Hx) + self.x[:] = self.x + np.dot(self.KG, + self.obs - self.Hx) # xa = xp + K (y-Hx) - # And next make the updated ensemble deviations. Note that we calculate P by using the full equation (10) at once, and - # not in a serial update fashion as described in Whitaker and Hamill. + # And next make the updated ensemble deviations. Note that we calculate P by using the full equation (10) at once, and + # not in a serial update fashion as described in Whitaker and Hamill. # For the current problem with limited N_obs this is easier, or at least more straightforward to do. I = np.identity(self.nlag * self.nparams) - sHPHR = la.cholesky(self.HPHR) # square root of HPH+R - part1 = np.dot(HPb, np.transpose(la.inv(sHPHR))) # HP(sqrt(HPH+R))^-1 - part2 = la.inv(sHPHR + np.sqrt(self.R)) # (sqrt(HPH+R)+sqrt(R))^-1 - Kw = np.dot(part1, part2) # K~ - self.X_prime[:, :] = np.dot(I, self.X_prime) - np.dot(Kw, self.HX_prime) # HX' = I - K~ * HX' - + sHPHR = la.cholesky(self.HPHR) # square root of HPH+R + part1 = np.dot(HPb, np.transpose(la.inv(sHPHR))) # HP(sqrt(HPH+R))^-1 + part2 = la.inv(sHPHR + np.sqrt(self.R)) # (sqrt(HPH+R)+sqrt(R))^-1 + Kw = np.dot(part1, part2) # K~ + self.X_prime[:, :] = np.dot(I, self.X_prime) - np.dot( + Kw, self.HX_prime) # HX' = I - K~ * HX' # Now do the adjustments of the modeled mole fractions using the linearized ensemble. These are not strictly needed but can be used # for diagnosis. - part3 = np.dot(HPH, np.transpose(la.inv(sHPHR))) # HPH(sqrt(HPH+R))^-1 - Kw = np.dot(part3, part2) # K~ - self.Hx[:] = self.Hx + np.dot(np.dot(HPH, la.inv(self.HPHR)), self.obs - self.Hx) # Hx = Hx+ HPH/HPH+R (y-Hx) - self.HX_prime[:, :] = self.HX_prime - np.dot(Kw, self.HX_prime) # HX' = HX'- K~ * HX' - - logging.info('Minimum Least Squares solution was calculated, returning') + part3 = np.dot(HPH, np.transpose(la.inv(sHPHR))) # HPH(sqrt(HPH+R))^-1 + Kw = np.dot(part3, part2) # K~ + self.Hx[:] = self.Hx + np.dot(np.dot(HPH, la.inv( + self.HPHR)), self.obs - self.Hx) # Hx = Hx+ HPH/HPH+R (y-Hx) + self.HX_prime[:, :] = self.HX_prime - np.dot( + Kw, self.HX_prime) # HX' = HX'- K~ * HX' + logging.info( + 'Minimum Least Squares solution was calculated, returning') def set_localization(self, loctype='None'): """ determine which localization to use """ @@ -517,8 +598,9 @@ def set_localization(self, loctype='None'): elif self.nmembers == 192: self.tvalue = 1.9724 elif self.nmembers == 200: - self.tvalue = 1.9719 - else: self.tvalue = 0 + self.tvalue = 1.9719 + else: + self.tvalue = 0 elif loctype == 'spatial': logging.info('Spatial localization selected') self.localization = True @@ -526,105 +608,111 @@ def set_localization(self, loctype='None'): else: self.localization = False self.localizetype = 'None' - - logging.info("Current localization option is set to %s" % self.localizetype) + + logging.info("Current localization option is set to %s" % + self.localizetype) if ((self.localization == True) and (self.localizetype == 'CT2007')): if self.tvalue == 0: - logging.error("Critical tvalue for localization not set for %i ensemble members"%(self.nmembers)) + logging.error( + "Critical tvalue for localization not set for %i ensemble members" + % (self.nmembers)) sys.exit(2) - else: logging.info("Used critical tvalue %0.05f is based on 95%% probability and %i ensemble members in a two-tailed student's T-test"%(self.tvalue,self.nmembers)) - + else: + logging.info( + "Used critical tvalue %0.05f is based on 95%% probability and %i ensemble members in a two-tailed student's T-test" + % (self.tvalue, self.nmembers)) - def get_prob(self,n,i): -# def get_prob(self,obsdev,paramdev,r): + def get_prob(self, n, i): + # def get_prob(self,obsdev,paramdev,r): """Calculate probability from correlations""" -# corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] -# corr = np.corrcoef(obsdev,paramdev)[0,1] -# corr = np.ma.corrcoef(np.ma.masked_invalid(self.HX_prime[n, :]),np.ma.masked_invalid(self.X_prime[r, :].squeeze()))[0,1] - for r in np.arange(i,self.nlag * self.nparams)[::36]: - corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] - prob = corr / np.sqrt((1.000000001 - corr ** 2) / (self.nmembers - 2)) + # corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] + # corr = np.corrcoef(obsdev,paramdev)[0,1] + # corr = np.ma.corrcoef(np.ma.masked_invalid(self.HX_prime[n, :]),np.ma.masked_invalid(self.X_prime[r, :].squeeze()))[0,1] + for r in np.arange(i, self.nlag * self.nparams)[::36]: + corr = np.corrcoef(self.HX_prime[n, :], + self.X_prime[r, :].squeeze())[0, 1] + prob = corr / np.sqrt( + (1.000000001 - corr**2) / (self.nmembers - 2)) if abs(prob) < self.tvalue: self.KG[r] = 0.0 - def localize(self, n, n_bg_params): - skip_stations = ['Malin Head_47', - 'Hegyhatsal hatterszennyettseg-mero allomas_48', - 'Hegyhatsal hatterszennyettseg-mero allomas_82', - 'Birkenes_2', - 'Hegyhatsal hatterszennyettseg-mero allomas_115', - 'Hegyhatsal hatterszennyettseg-mero allomas_10', - 'Beromunster_12', - 'Beromunster_44', - 'Beromunster_72', - 'Beromunster_132', - 'Bilsdale_42', - 'Bilsdale_108', - 'Cabauw_27', - 'Cabauw_67', - 'Cabauw_127', - 'Gartow_30', - 'Gartow_60', - 'Gartow_132', - 'Gartow_216', - 'Hohenpeissenberg_50', - 'Hohenpeissenberg_93', - 'Hyltemossa_30', - 'Hyltemossa_70', - 'Ispara_40', - 'Ispra_70', - 'Karlsruhe_30', - 'Karlsruhe_60', - 'Karlsruhe_100', - 'Kresin u Pacova_10', - 'Kresin u Pacova_50', - 'Kresin u Pacova_125', - 'Lindenberg_2', - 'Lindenberg_10', - 'Lindenberg_40', - 'Observatoire de Haute Provence_10', - 'Observatoire de Haute Provence_50', - "Observatoire perenne de l'environnement_10", - "Observatoire perenne de l'environnement_50", - 'Ridge Hill_45', - 'Saclay_15', - 'Saclay_60', - 'Tacolneston_54', - 'Tacolneston_100', - 'Torfhaus_10', - 'Torfhaus_76', - 'Torfhaus_110', - 'Trainou_5', - 'Trainou_50', - 'Trainou_100', - ] - + skip_stations = [ + 'Malin Head_47', + 'Hegyhatsal hatterszennyettseg-mero allomas_48', + 'Hegyhatsal hatterszennyettseg-mero allomas_82', + 'Birkenes_2', + 'Hegyhatsal hatterszennyettseg-mero allomas_115', + 'Hegyhatsal hatterszennyettseg-mero allomas_10', + 'Beromunster_12', + 'Beromunster_44', + 'Beromunster_72', + 'Beromunster_132', + 'Bilsdale_42', + 'Bilsdale_108', + 'Cabauw_27', + 'Cabauw_67', + 'Cabauw_127', + 'Gartow_30', + 'Gartow_60', + 'Gartow_132', + 'Gartow_216', + 'Hohenpeissenberg_50', + 'Hohenpeissenberg_93', + 'Hyltemossa_30', + 'Hyltemossa_70', + 'Ispara_40', + 'Ispra_70', + 'Karlsruhe_30', + 'Karlsruhe_60', + 'Karlsruhe_100', + 'Kresin u Pacova_10', + 'Kresin u Pacova_50', + 'Kresin u Pacova_125', + 'Lindenberg_2', + 'Lindenberg_10', + 'Lindenberg_40', + 'Observatoire de Haute Provence_10', + 'Observatoire de Haute Provence_50', + "Observatoire perenne de l'environnement_10", + "Observatoire perenne de l'environnement_50", + 'Ridge Hill_45', + 'Saclay_15', + 'Saclay_60', + 'Tacolneston_54', + 'Tacolneston_100', + 'Torfhaus_10', + 'Torfhaus_76', + 'Torfhaus_110', + 'Trainou_5', + 'Trainou_50', + 'Trainou_100', + ] """ localize the Kalman Gain matrix """ import numpy as np from multiprocessing import Pool - if not self.localization: + if not self.localization: logging.debug('Not localized observation %i' % self.obs_ids[n]) - return + return if self.localizetype == 'CT2007': -# count_localized = 0 -# for r in range(self.nlag * self.nparams): -## corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] -# corr = np.ma.corrcoef(np.ma.masked_invalid(self.HX_prime[n, :]),np.ma.masked_invalid(self.X_prime[r, :].squeeze()))[0,1] -# prob = corr / np.sqrt((1.000000001 - corr ** 2) / (self.nmembers - 2)) -# if abs(prob) < self.tvalue: -# self.KG[r] = 0.0 -# count_localized = count_localized + 1 -# logging.debug('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) -# logging.info('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) + # count_localized = 0 + # for r in range(self.nlag * self.nparams): + ## corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] + # corr = np.ma.corrcoef(np.ma.masked_invalid(self.HX_prime[n, :]),np.ma.masked_invalid(self.X_prime[r, :].squeeze()))[0,1] + # prob = corr / np.sqrt((1.000000001 - corr ** 2) / (self.nmembers - 2)) + # if abs(prob) < self.tvalue: + # self.KG[r] = 0.0 + # count_localized = count_localized + 1 + # logging.debug('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) + # logging.info('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) ############################################ ###make the CT2007 parallel: -# args = [ (n, i) for i in range(self.nlag * self.nparams) ] - args = [ (n, i) for i in range(36) ] -# args = [ (self.HX_prime[n, :], self.X_prime[r, :].squeeze(), r ) for r in range(self.nlag * self.nparams) ] + # args = [ (n, i) for i in range(self.nlag * self.nparams) ] + args = [(n, i) for i in range(36)] + # args = [ (self.HX_prime[n, :], self.X_prime[r, :].squeeze(), r ) for r in range(self.nlag * self.nparams) ] with Pool(36) as pool: pool.starmap(self.get_prob, args) # count_localized = 0 @@ -637,54 +725,57 @@ def localize(self, n, n_bg_params): logging.info('Localized observation %i' % (self.obs_ids[n])) ############################################ - elif self.localizetype == 'spatial': -# ### if self.loc_L[n] > 0: -# ### obslati, obsloni = self.find_coord_index(self.latitude[n],self.longitude[n],180,360) -# ### for l in range(self.nlag): -# ### self.KG[l*self.nparams:(l+1)*self.nparams] = np.multiply(self.KG[l*self.nparams:(l+1)*self.nparams], self.loc_coeff[str(self.loc_L[n])][obslati,obsloni,:]) -# ### logging.debug('Localized observation %i with localization length %s' %(self.obs_ids[n], self.loc_L[n])) -# print(self.latitude[n], self.longitude[n], "lat and lon!") - -# n_em_cat = 2 -# lfound = False -# for iname,stationname in enumerate(self.name_array): -# if stationname in skip_stations: continue # Skip stations outside of the domain! -# if stationname==self.fromfile[n]: -# coeff_l = np.zeros((n_em_cat*len(self.coeff_matrix[iname,:]))) -# for i_n_cat in range(n_em_cat): -# coeff_l[i_n_cat:][::n_em_cat] = self.coeff_matrix[iname,:] - -# for l in range(self.nlag): -# self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params] = np.multiply( self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params], coeff_l ) - -# logging.info('Localized observation %i at station %s (nr. %i)'%(self.obs_ids[n],stationname,iname)) - -# lfound = True - -# break - -# if not lfound: -# logging.info('Not localized observation %i as coefficient not found' %(self.obs_ids[n])) -### if self.loc_L[n] > 0: -### obslati, obsloni = self.find_coord_index(self.latitude[n],self.longitude[n],180,360) -### for l in range(self.nlag): -### self.KG[l*self.nparams:(l+1)*self.nparams] = np.multiply(self.KG[l*self.nparams:(l+1)*self.nparams], self.loc_coeff[str(self.loc_L[n])][obslati,obsloni,:]) -### logging.debug('Localized observation %i with localization length %s' %(self.obs_ids[n], self.loc_L[n])) - + # ### if self.loc_L[n] > 0: + # ### obslati, obsloni = self.find_coord_index(self.latitude[n],self.longitude[n],180,360) + # ### for l in range(self.nlag): + # ### self.KG[l*self.nparams:(l+1)*self.nparams] = np.multiply(self.KG[l*self.nparams:(l+1)*self.nparams], self.loc_coeff[str(self.loc_L[n])][obslati,obsloni,:]) + # ### logging.debug('Localized observation %i with localization length %s' %(self.obs_ids[n], self.loc_L[n])) + # print(self.latitude[n], self.longitude[n], "lat and lon!") + + # n_em_cat = 2 + # lfound = False + # for iname,stationname in enumerate(self.name_array): + # if stationname in skip_stations: continue # Skip stations outside of the domain! + # if stationname==self.fromfile[n]: + # coeff_l = np.zeros((n_em_cat*len(self.coeff_matrix[iname,:]))) + # for i_n_cat in range(n_em_cat): + # coeff_l[i_n_cat:][::n_em_cat] = self.coeff_matrix[iname,:] + + # for l in range(self.nlag): + # self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params] = np.multiply( self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params], coeff_l ) + + # logging.info('Localized observation %i at station %s (nr. %i)'%(self.obs_ids[n],stationname,iname)) + + # lfound = True + + # break + + # if not lfound: + # logging.info('Not localized observation %i as coefficient not found' %(self.obs_ids[n])) + ### if self.loc_L[n] > 0: + ### obslati, obsloni = self.find_coord_index(self.latitude[n],self.longitude[n],180,360) + ### for l in range(self.nlag): + ### self.KG[l*self.nparams:(l+1)*self.nparams] = np.multiply(self.KG[l*self.nparams:(l+1)*self.nparams], self.loc_coeff[str(self.loc_L[n])][obslati,obsloni,:]) + ### logging.debug('Localized observation %i with localization length %s' %(self.obs_ids[n], self.loc_L[n])) + n_em_cat = 2 - if self.fromfile[n] in skip_stations: return # Skip stations outside of the domain! - - coeff_l = np.zeros((n_em_cat*len(self.coeff_matrix[n,:]))) - for i_n_cat in range(n_em_cat): - coeff_l[i_n_cat:][::n_em_cat] = self.coeff_matrix[n,:] - + if self.fromfile[n] in skip_stations: + return # Skip stations outside of the domain! + + coeff_l = np.zeros((n_em_cat * len(self.coeff_matrix[n, :]))) + for i_n_cat in range(n_em_cat): + coeff_l[i_n_cat:][::n_em_cat] = self.coeff_matrix[n, :] + for l in range(self.nlag): - self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params] = np.multiply( self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params], coeff_l ) + self.KG[l * self.nparams:(l + 1) * self.nparams - + n_bg_params] = np.multiply( + self.KG[l * self.nparams:(l + 1) * self.nparams - + n_bg_params], coeff_l) - logging.info('Localized observation %i at station %s (nr. %i)'%(self.obs_ids[n],self.fromfile[n], n)) + logging.info('Localized observation %i at station %s (nr. %i)' % + (self.obs_ids[n], self.fromfile[n], n)) - def set_algorithm(self, algorithm='Serial'): """ determine which minimum least squares algorithm to use """ @@ -692,12 +783,12 @@ def set_algorithm(self, algorithm='Serial'): self.algorithm = 'Serial' else: self.algorithm = 'Bulk' - - logging.info("Current minimum least squares algorithm is set to %s" % self.algorithm) -################### End Class Optimizer ################### + logging.info("Current minimum least squares algorithm is set to %s" % + self.algorithm) +################### End Class Optimizer ################### if __name__ == "__main__": pass diff --git a/cases/icon-art-CTDAS2/ctdas_patch/statevector_baseclass_icos_cities.py b/cases/icon-art-CTDAS2/ctdas_patch/statevector_baseclass_icos_cities.py index a93c4a2a..e2a7e98a 100644 --- a/cases/icon-art-CTDAS2/ctdas_patch/statevector_baseclass_icos_cities.py +++ b/cases/icon-art-CTDAS2/ctdas_patch/statevector_baseclass_icos_cities.py @@ -12,7 +12,6 @@ program. If not, see .""" #!/usr/bin/env python # ct_statevector_tools.py - """ .. module:: statevector .. moduleauthor:: Wouter Peters @@ -49,6 +48,7 @@ ################### Begin Class EnsembleMember ################### + class EnsembleMember(object): """ An ensemble member object consists of: @@ -77,8 +77,9 @@ def __init__(self, membernumber): * ModelSample, will hold an :class:`~da.baseclasses.obs.Observation` object and the model samples resulting from this members' data """ - self.membernumber = membernumber # the member number - self.param_values = None # Parameter values of this member + self.membernumber = membernumber # the member number + self.param_values = None # Parameter values of this member + ################### End Class EnsembleMember ################### @@ -152,13 +153,17 @@ def setup(self, dacycle): """ self.nlag = int(dacycle['time.nlag']) - self.nmembers = int(dacycle['da.optimizer.nmembers']) #number of ensemble members, e.g. 192 for the icon case - self.nparams = int(dacycle.dasystem['nparameters']) #n_reg * n_tracers * n_categories + n_bg_params + self.nmembers = int( + dacycle['da.optimizer.nmembers'] + ) #number of ensemble members, e.g. 192 for the icon case + self.nparams = int(dacycle.dasystem['nparameters'] + ) #n_reg * n_tracers * n_categories + n_bg_params self.nobs = 0 - - self.obs_to_assimilate = () # empty containter to hold observations to assimilate later on - # These list objects hold the data for each time step of lag in the system. Note that the ensembles for each time step consist + self.obs_to_assimilate = ( + ) # empty containter to hold observations to assimilate later on + + # These list objects hold the data for each time step of lag in the system. Note that the ensembles for each time step consist # of lists of EnsembleMember objects, we define member 0 as the mean of the distribution and n=1,...,nmembers as the spread. self.ensemble_members = list(range(self.nlag)) @@ -168,13 +173,11 @@ def setup(self, dacycle): #msteiner: self.isOptimized = False - self.C = np.zeros((self.nparams,self.nparams)) + self.C = np.zeros((self.nparams, self.nparams)) self.distances = dacycle['sv.distances'] #--------- - - - def make_new_ensemble(self, lag, covariancematrix=None,n_bg_params=0): + def make_new_ensemble(self, lag, covariancematrix=None, n_bg_params=0): """ :param lag: an integer indicating the time step in the lag order :param covariancematrix: a matrix to draw random values from @@ -188,25 +191,25 @@ def make_new_ensemble(self, lag, covariancematrix=None,n_bg_params=0): used to draw ensemblemembers from. If this argument is not passed it will ne substituted with an identity matrix of the same dimensions. - """ + """ - logging.info('msteiner: current lag: %i '%(lag)) - logging.info('msteiner: nlag; %i '%(self.nlag)) + logging.info('msteiner: current lag: %i ' % (lag)) + logging.info('msteiner: nlag; %i ' % (self.nlag)) categories = 2 - if np.all(self.C==0.): + if np.all(self.C == 0.): logging.info('msteiner: performing cholesky decomposition') + # covariancematrix = np.identity((self.nparams)) -# covariancematrix = np.identity((self.nparams)) - - Corr = np.array([[1, 0], # VPRM - [0, 1]]) #U + Corr = np.array([ + [1, 0], # VPRM + [0, 1] + ]) #U + # covariancematrix = np.identity((self.nparams)) -# covariancematrix = np.identity((self.nparams)) - - - covariancematrix = np.zeros((self.nparams,self.nparams), dtype=np.float32) + covariancematrix = np.zeros((self.nparams, self.nparams), + dtype=np.float32) # covariancematrix = np.zeros((self.nparams,self.nparams)) # print("COV=", covariancematrix.shape) specific_length_bio = 300 @@ -214,7 +217,7 @@ def make_new_ensemble(self, lag, covariancematrix=None,n_bg_params=0): # print("dist=", self.distances) ds = xr.open_dataset(self.distances) - logging.info('opened distances file, nparams = %d'%self.nparams) + logging.info('opened distances file, nparams = %d' % self.nparams) distances = ds.Distances.values # covariancematrix[:-n_bg_params, :-n_bg_params] = np.kron(np.exp(-distances/specific_length), c), c is the correlation matrix between categories # for ix, x in enumerate(distances): @@ -230,14 +233,20 @@ def make_new_ensemble(self, lag, covariancematrix=None,n_bg_params=0): for ic, c in enumerate(Corr): for ik, k in enumerate(c): if ic == 1 or ik == 1: - covariancematrix[ix*categories + ic,ik:-n_bg_params][::categories] = 0.5*np.exp(-x/specific_length_anth)*k + covariancematrix[ + ix * categories + ic, + ik:-n_bg_params][::categories] = 0.5 * np.exp( + -x / specific_length_anth) * k else: - covariancematrix[ix*categories + ic,ik:-n_bg_params][::categories] = 1*np.exp(-x/specific_length_bio)*k + covariancematrix[ + ix * categories + ic, + ik:-n_bg_params][::categories] = 1 * np.exp( + -x / specific_length_bio) * k #covariancematrix = np.zeros((self.nparams,self.nparams), dtype=np.float32) # covariancematrix = np.zeros((self.nparams,self.nparams)) # specific_length=200 - + # print(self.distances) # print(covariancematrix.shape) # ds = xr.open_dataset(self.distances) @@ -254,24 +263,29 @@ def make_new_ensemble(self, lag, covariancematrix=None,n_bg_params=0): # covariancematrix[3*(ix)+2,2:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) #set variances for the 8 background elements (note python indexing) (10% std in this case): - if n_bg_params>0: + if n_bg_params > 0: for iii in np.arange(n_bg_params): - covariancematrix[-n_bg_params+ iii ,-n_bg_params+iii] = 0.015*0.015 # 0.015*400 = 6 ppm stdev - covariancematrix[-n_bg_params+np.mod(iii+1,n_bg_params),-n_bg_params+iii] = 0.015*0.015*0.25 - covariancematrix[-n_bg_params+np.mod(iii-1,n_bg_params),-n_bg_params+iii] = 0.015*0.015*0.25 + covariancematrix[ + -n_bg_params + iii, -n_bg_params + + iii] = 0.015 * 0.015 # 0.015*400 = 6 ppm stdev + covariancematrix[-n_bg_params + + np.mod(iii + 1, n_bg_params), + -n_bg_params + iii] = 0.015 * 0.015 * 0.25 + covariancematrix[-n_bg_params + + np.mod(iii - 1, n_bg_params), + -n_bg_params + iii] = 0.015 * 0.015 * 0.25 #logging.info('Filled in cov matrix, dtype %s, %s, %d, %d'%(str(covariancematrix.dtype),str(covariancematrix[0][0].dtype), covariancematrix.shape[0], covariancematrix.shape[1]) ) self.C = np.linalg.cholesky(covariancematrix) del covariancematrix - # # covariancematrix[covariancematrix<1.2e-2] = 0. # # #set variances for lbc-scaling ## for idir in np.arange(4): ## covariancematrix[-(idir+1),-(idir+1)] = 0.5 - # msteiner: commented-out the svd as it takes endless time for a large statevector and - #... it is just for information about the dof +# msteiner: commented-out the svd as it takes endless time for a large statevector and +#... it is just for information about the dof # try: # _, s, _ = np.linalg.svd(covariancematrix) @@ -280,21 +294,19 @@ def make_new_ensemble(self, lag, covariancematrix=None,n_bg_params=0): # dof = np.sum(s) ** 2 / sum(s ** 2) logging.info('Cholesky decomposition has finished') -# logging.info('Appr. degrees of freedom in covariance matrix is %s' % (int(dof))) - + # logging.info('Appr. degrees of freedom in covariance matrix is %s' % (int(dof))) - - # Create mean values - newmean = np.ones(self.nparams, float) # standard value for a new time step is 1.0 + # Create mean values + newmean = np.ones(self.nparams, + float) # standard value for a new time step is 1.0 if lag == self.nlag - 1 and self.nlag >= 2: - newmean += 2*self.ensemble_members[lag - 1][0].param_values + newmean += 2 * self.ensemble_members[lag - 1][0].param_values newmean = newmean / 3.0 - #Propagate background mean state by 100%: - if n_bg_params>0: - newmean[self.nparams-n_bg_params:] = self.ensemble_members[lag - 1][0].param_values[self.nparams-n_bg_params:] - + if n_bg_params > 0: + newmean[self.nparams - n_bg_params:] = self.ensemble_members[ + lag - 1][0].param_values[self.nparams - n_bg_params:] ####### New forecast model for the mean: take 100% of the optimized value ####### #newmean = np.ones(self.nparams, float) # standard value for a new time step is 1.0 @@ -306,7 +318,8 @@ def make_new_ensemble(self, lag, covariancematrix=None,n_bg_params=0): #DEBUG newmean for cat in range(categories): logging.info('Category (%s) ' % str(cat + 1)) - logging.info('New mean (%s) ' % str(np.nanmean(newmean[cat:][::categories]))) + logging.info('New mean (%s) ' % + str(np.nanmean(newmean[cat:][::categories]))) # Create the first ensemble member with a deviation of 0.0 and add to list newmember = EnsembleMember(0) newmember.param_values = newmean.flatten() # no deviations @@ -319,29 +332,41 @@ def make_new_ensemble(self, lag, covariancematrix=None,n_bg_params=0): newmember = EnsembleMember(member) logging.info('pre-dot') # newmember.param_values = np.dot(self.C, rands) + newmean - newmember.param_values = np.einsum("ij, j -> i", self.C, rands) + newmean + newmember.param_values = np.einsum("ij, j -> i", self.C, + rands) + newmean logging.info('post-dot') self.ensemble_members[lag].append(newmember) - logging.info('Created parameters for ensemble member %i'%(member)) + logging.info('Created parameters for ensemble member %i' % + (member)) #DEBUG lambdas lambdas = np.array([]) for member in range(0, self.nmembers): - logging.info('Member shape (%s) ' % str(np.shape(self.ensemble_members[lag][member].param_values))) - lambdas = np.append(lambdas, self.ensemble_members[lag][member].param_values) + logging.info( + 'Member shape (%s) ' % + str(np.shape(self.ensemble_members[lag][member].param_values))) + lambdas = np.append( + lambdas, self.ensemble_members[lag][member].param_values) lambdas = np.reshape(lambdas, (self.nmembers, self.nparams)) - members_array = np.mean(lambdas, axis = 0) + members_array = np.mean(lambdas, axis=0) # logging.info('Member array shape (%s) ' % str(np.shape(members_array))) for cat in range(categories): logging.info('Category (%s) ' % str(cat + 1)) - logging.info('Lambda mean (%s) ' % str(np.nanmean(members_array[cat:][::categories]))) + logging.info('Lambda mean (%s) ' % + str(np.nanmean(members_array[cat:][::categories]))) #del C #msteiner: this line causes the "invalid pointer"-error at this point, otherwise it occurs after the code reached the end of this function - logging.info('%d new ensemble members were added to the state vector # %d' % (self.nmembers, (lag + 1))) - + logging.info( + '%d new ensemble members were added to the state vector # %d' % + (self.nmembers, (lag + 1))) - def propagate(self, dacycle, method='create_new_member', filename=None, date=None, initdir=None): + def propagate(self, + dacycle, + method='create_new_member', + filename=None, + date=None, + initdir=None): """ :rtype: None @@ -352,37 +377,53 @@ def propagate(self, dacycle, method='create_new_member', filename=None, date=Non In the future, this routine can incorporate a formal propagation of the statevector. """ - + # Remove State Vector n=1 by simply "popping" it from the list and appending a new empty list at the front. This empty list will - # hold the new ensemble for the new cycle + # hold the new ensemble for the new cycle self.ensemble_members.pop(0) self.ensemble_members.append([]) # And now create a new time step of mean + members for n=nlag if method == 'create_new_member': - date = dacycle['time.start'] + timedelta(days=(self.nlag - 0.5) * int(dacycle['time.cycle'])) + date = dacycle['time.start'] + timedelta( + days=(self.nlag - 0.5) * int(dacycle['time.cycle'])) cov = self.get_covariance(date, dacycle) - self.make_new_ensemble(self.nlag - 1, cov,int(dacycle['statevector.bg_params'])) + self.make_new_ensemble(self.nlag - 1, cov, + int(dacycle['statevector.bg_params'])) elif method == 'read_new_member': if os.path.exists(filename): - self.read_ensemble_member_from_file(filename, self.nlag-1, qual='opt', read_lag=0) + self.read_ensemble_member_from_file(filename, + self.nlag - 1, + qual='opt', + read_lag=0) else: - self.read_ensemble_member_from_file(filename, self.nlag-1, date, initdir, qual='opt', read_lag=0) + self.read_ensemble_member_from_file(filename, + self.nlag - 1, + date, + initdir, + qual='opt', + read_lag=0) elif method == 'read_mean': - date = dacycle['time.start'] + timedelta(days=(self.nlag - 0.5) * int(dacycle['time.cycle'])) + date = dacycle['time.start'] + timedelta( + days=(self.nlag - 0.5) * int(dacycle['time.cycle'])) cov = self.get_covariance(date, dacycle) if os.path.exists(filename): - meanstate = self.read_mean_from_file(filename, self.nlag-1, qual='opt') + meanstate = self.read_mean_from_file(filename, + self.nlag - 1, + qual='opt') else: - meanstate = self.read_mean_from_file(filename, self.nlag-1, date, initdir, qual='opt') + meanstate = self.read_mean_from_file(filename, + self.nlag - 1, + date, + initdir, + qual='opt') self.make_new_ensemble(self.nlag - 1, cov, meanstate) logging.info('The state vector has been propagated by one cycle') - def write_to_file(self, filename, qual): """ :param filename: the full filename for the output NetCDF file @@ -403,11 +444,13 @@ def write_to_file(self, filename, qual): if qual == 'prior': f = io.CT_CDF(filename, method='create') - logging.debug('Creating new StateVector output file (%s)' % filename) + logging.debug('Creating new StateVector output file (%s)' % + filename) #qual = 'prior' else: f = io.CT_CDF(filename, method='write') - logging.debug('Opening existing StateVector output file (%s)' % filename) + logging.debug('Opening existing StateVector output file (%s)' % + filename) #qual = 'opt' dimparams = f.add_params_dim(self.nparams) @@ -419,7 +462,7 @@ def write_to_file(self, filename, qual): mean_state = members[0].param_values savedict = f.standard_var(varname='meanstate_%s' % qual) - savedict['dims'] = dimlag + dimparams + savedict['dims'] = dimlag + dimparams savedict['values'] = mean_state savedict['count'] = n savedict['comment'] = 'this represents the mean of the ensemble' @@ -430,112 +473,157 @@ def write_to_file(self, filename, qual): data = devs - np.asarray(mean_state) savedict = f.standard_var(varname='ensemblestate_%s' % qual) - savedict['dims'] = dimlag + dimmembers + dimparams + savedict['dims'] = dimlag + dimmembers + dimparams savedict['values'] = data savedict['count'] = n - savedict['comment'] = 'this represents deviations from the mean of the ensemble' + savedict[ + 'comment'] = 'this represents deviations from the mean of the ensemble' f.add_data(savedict) f.close() - logging.info('Successfully wrote the State Vector to file (%s) ' % filename) - - + logging.info('Successfully wrote the State Vector to file (%s) ' % + filename) - def interpolate_mean_ensemble(self, initdir, date, qual='opt', readensemble=True): + def interpolate_mean_ensemble(self, + initdir, + date, + qual='opt', + readensemble=True): # deduce window length of source run: all_dates = os.listdir(initdir) for i, dstr in enumerate(all_dates): - all_dates[i] = dt.datetime.strptime(dstr,'%Y%m%d') + all_dates[i] = dt.datetime.strptime(dstr, '%Y%m%d') del i, dstr all_dates = sorted(all_dates) - ddays = (all_dates[1]-all_dates[0]).days + ddays = (all_dates[1] - all_dates[0]).days del all_dates # find dates in source directory just before and after target date found_datemin, found_datemax = False, False for d in range(ddays): datei = date - dt.timedelta(days=d) - if not found_datemin and os.path.exists(os.path.join(initdir, datei.strftime('%Y%m%d'), 'savestate_%s.nc'%datei.strftime('%Y%m%d'))): + if not found_datemin and os.path.exists( + os.path.join( + initdir, datei.strftime('%Y%m%d'), + 'savestate_%s.nc' % datei.strftime('%Y%m%d'))): datemin = datei found_datemin = True datei = date + dt.timedelta(days=d) - if not found_datemax and os.path.exists(os.path.join(initdir, datei.strftime('%Y%m%d'), 'savestate_%s.nc'%datei.strftime('%Y%m%d'))): + if not found_datemax and os.path.exists( + os.path.join( + initdir, datei.strftime('%Y%m%d'), + 'savestate_%s.nc' % datei.strftime('%Y%m%d'))): datemax = datei found_datemax = True if found_datemin and found_datemax: - print('Found datemin = %s and datemax = %s' %(datemin.strftime('%Y%m%d'), datemax.strftime('%Y%m%d'))) + print('Found datemin = %s and datemax = %s' % + (datemin.strftime('%Y%m%d'), datemax.strftime('%Y%m%d'))) break del d - logging.debug('Ensemble for %s will be interpolated from %s and %s' %(date.strftime('%Y-%m-%d'), datemin.strftime('%Y-%m-%d'),datemax.strftime('%Y-%m-%d'))) + logging.debug('Ensemble for %s will be interpolated from %s and %s' % + (date.strftime('%Y-%m-%d'), datemin.strftime('%Y-%m-%d'), + datemax.strftime('%Y-%m-%d'))) # Read ensemble from both files - filename1 = os.path.join(initdir, datemin.strftime('%Y%m%d'), 'savestate_%s.nc'%datemin.strftime('%Y%m%d')) + filename1 = os.path.join( + initdir, datemin.strftime('%Y%m%d'), + 'savestate_%s.nc' % datemin.strftime('%Y%m%d')) f = io.ct_read(filename1, 'read') - meanstate1 = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] + meanstate1 = f.get_variable('statevectormean_' + + qual) # [nlag x nparameters] if readensemble: - ensmembers1 = f.get_variable('statevectorensemble_' + qual) # [nlag x nmembers x nparameters] + ensmembers1 = f.get_variable( + 'statevectorensemble_' + + qual) # [nlag x nmembers x nparameters] f.close() - filename2 = os.path.join(initdir, datemax.strftime('%Y%m%d'), 'savestate_%s.nc'%datemax.strftime('%Y%m%d')) + filename2 = os.path.join( + initdir, datemax.strftime('%Y%m%d'), + 'savestate_%s.nc' % datemax.strftime('%Y%m%d')) f = io.ct_read(filename2, 'read') - meanstate2 = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] + meanstate2 = f.get_variable('statevectormean_' + + qual) # [nlag x nparameters] if readensemble: - ensmembers2 = f.get_variable('statevectorensemble_' + qual) # [nlag x nmembers x nparameters] + ensmembers2 = f.get_variable( + 'statevectorensemble_' + + qual) # [nlag x nmembers x nparameters] f.close() # interpolate mean and ensemble between datemin and datemax - meanstate = ((datemax-date).days/ddays)*meanstate1 + ((date-datemin).days/ddays)*meanstate2 + meanstate = ((datemax - date).days / ddays) * meanstate1 + ( + (date - datemin).days / ddays) * meanstate2 if readensemble: - ensmembers = ((datemax-date).days/ddays)*ensmembers1 + ((date-datemin).days/ddays)*ensmembers2 + ensmembers = ((datemax - date).days / ddays) * ensmembers1 + ( + (date - datemin).days / ddays) * ensmembers2 return meanstate, ensmembers else: return meanstate - - - def read_mean_from_file(self, filename, lag, date=None, initdir=None, qual='opt'): + def read_mean_from_file(self, + filename, + lag, + date=None, + initdir=None, + qual='opt'): if date is None: f = io.ct_read(filename, 'read') - meanstate = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] + meanstate = f.get_variable('statevectormean_' + + qual) # [nlag x nparameters] f.close else: - meanstate = self.interpolate_mean_ensemble(initdir, date, qual, readensemble=False) - - logging.info('Successfully read the mean state vector from file (%s) ' %filename) - - return meanstate[lag,:] + meanstate = self.interpolate_mean_ensemble(initdir, + date, + qual, + readensemble=False) + logging.info( + 'Successfully read the mean state vector from file (%s) ' % + filename) + return meanstate[lag, :] - def read_ensemble_member_from_file(self, filename, lag, date=None, initdir=None, qual='opt', read_lag=0): + def read_ensemble_member_from_file(self, + filename, + lag, + date=None, + initdir=None, + qual='opt', + read_lag=0): # if date is None we can directly read mean and ensemble members. Else we will need to read 2 ensembles and interpolate if date is None: f = io.ct_read(filename, 'read') - meanstate = f.get_variable('statevectormean_' + qual) # [nlag x nparameters] - ensmembers = f.get_variable('statevectorensemble_' + qual) # [nlag x nmembers x nparameters] + meanstate = f.get_variable('statevectormean_' + + qual) # [nlag x nparameters] + ensmembers = f.get_variable( + 'statevectorensemble_' + + qual) # [nlag x nmembers x nparameters] f.close() else: - meanstate, ensmembers = self.interpolate_mean_ensemble(initdir, date, qual, readensemble=True) + meanstate, ensmembers = self.interpolate_mean_ensemble( + initdir, date, qual, readensemble=True) # add to statevector if not self.ensemble_members[lag] == []: self.ensemble_members[lag] = [] - logging.warning('Existing ensemble for lag=%d was removed to make place for newly read data' % (n + 1)) + logging.warning( + 'Existing ensemble for lag=%d was removed to make place for newly read data' + % (n + 1)) for m in range(self.nmembers): newmember = EnsembleMember(m) - newmember.param_values = ensmembers[read_lag, m, :].flatten() + meanstate[read_lag,:] # add the mean to the deviations to hold the full parameter values + newmember.param_values = ensmembers[read_lag, m, :].flatten( + ) + meanstate[ + read_lag, :] # add the mean to the deviations to hold the full parameter values self.ensemble_members[lag].append(newmember) - logging.info('Successfully read the State Vector for lag %s from file (%s) ' % (lag,filename)) - - - + logging.info( + 'Successfully read the State Vector for lag %s from file (%s) ' % + (lag, filename)) def read_from_file(self, filename, qual='opt'): """ @@ -565,16 +653,25 @@ def read_from_file(self, filename, qual='opt'): for n in range(self.nlag): if not self.ensemble_members[n] == []: self.ensemble_members[n] = [] - logging.warning('Existing ensemble for lag=%d was removed to make place for newly read data' % (n + 1)) + logging.warning( + 'Existing ensemble for lag=%d was removed to make place for newly read data' + % (n + 1)) for m in range(self.nmembers): newmember = EnsembleMember(m) - newmember.param_values = ensmembers[n, m, :].flatten() + meanstate[n] # add the mean to the deviations to hold the full parameter values + newmember.param_values = ensmembers[n, m, :].flatten( + ) + meanstate[ + n] # add the mean to the deviations to hold the full parameter values self.ensemble_members[n].append(newmember) - logging.info('Successfully read the State Vector from file (%s) ' % filename) + logging.info('Successfully read the State Vector from file (%s) ' % + filename) - def write_members_to_file(self, lag, outdir, endswith='.nc', obsoperator=None): + def write_members_to_file(self, + lag, + outdir, + endswith='.nc', + obsoperator=None): """ :param: lag: Which lag step of the filter to write, must lie in range [1,...,nlag] :param: outdir: Directory where to write files @@ -594,14 +691,15 @@ def write_members_to_file(self, lag, outdir, endswith='.nc', obsoperator=None): # These import statements caused a crash in netCDF4 on MacOSX. No problems on Jet though. Solution was # to do the import already at the start of the module, not just in this method. - + #import da.tools.io as io #import da.tools.io4 as io members = self.ensemble_members[lag] for mem in members: - filename = os.path.join(outdir, 'parameters.%03d%s' % (mem.membernumber, endswith)) + filename = os.path.join( + outdir, 'parameters.%03d%s' % (mem.membernumber, endswith)) ncf = io.CT_CDF(filename, method='create') dimparams = ncf.add_params_dim(self.nparams) dimgrid = ncf.add_latlon_dim() @@ -610,34 +708,39 @@ def write_members_to_file(self, lag, outdir, endswith='.nc', obsoperator=None): savedict = io.std_savedict.copy() savedict['name'] = "parametervalues" - savedict['long_name'] = "parameter_values_for_member_%d" % mem.membernumber + savedict[ + 'long_name'] = "parameter_values_for_member_%d" % mem.membernumber savedict['units'] = "unitless" - savedict['dims'] = dimparams + savedict['dims'] = dimparams savedict['values'] = data - savedict['comment'] = 'These are parameter values to use for member %d' % mem.membernumber + savedict[ + 'comment'] = 'These are parameter values to use for member %d' % mem.membernumber ncf.add_data(savedict) griddata = self.vector2grid(vectordata=data) savedict = io.std_savedict.copy() savedict['name'] = "parametermap" - savedict['long_name'] = "parametermap_for_member_%d" % mem.membernumber + savedict[ + 'long_name'] = "parametermap_for_member_%d" % mem.membernumber savedict['units'] = "unitless" - savedict['dims'] = dimgrid + savedict['dims'] = dimgrid savedict['values'] = griddata.tolist() - savedict['comment'] = 'These are gridded parameter values to use for member %d' % mem.membernumber + savedict[ + 'comment'] = 'These are gridded parameter values to use for member %d' % mem.membernumber ncf.add_data(savedict) ncf.close() - logging.debug('Successfully wrote data from ensemble member %d to file (%s) ' % (mem.membernumber, filename)) - + logging.debug( + 'Successfully wrote data from ensemble member %d to file (%s) ' + % (mem.membernumber, filename)) def get_covariance(self, date, cycleparams): pass - + + ################### End Class StateVector ################### if __name__ == "__main__": pass - diff --git a/cases/icon-art-CTDAS2/ctdas_patch/template.py b/cases/icon-art-CTDAS2/ctdas_patch/template.py index 540434a7..79f68af8 100644 --- a/cases/icon-art-CTDAS2/ctdas_patch/template.py +++ b/cases/icon-art-CTDAS2/ctdas_patch/template.py @@ -19,6 +19,7 @@ import sys import os import logging + sys.path.append(os.getcwd()) ################################################################################################# @@ -29,12 +30,11 @@ from da.pipelines.pipeline_icon import ensemble_smoother_pipeline, header, footer, analysis_pipeline, archive_pipeline from da.dasystems.dasystem_baseclass import DaSystem from da.platform.pizdaint import PizDaintPlatform -from da.statevectors.statevector_baseclass_icos_cities import StateVector -from da.observations.obs_class_ICOS_OCO2 import ICOSObservations, TotalColumnObservations # Here we set which observations we consider! +from da.statevectors.statevector_baseclass_icos_cities import StateVector +from da.observations.obs_class_ICOS_OCO2 import ICOSObservations, TotalColumnObservations # Here we set which observations we consider! from da.obsoperators.obsoperator_ICOS_OCO2 import ObservationOperator # Here we set the obs-operator, which should sample the same observations! from da.optimizers.optimizer_baseclass_icos_cities import Optimizer - ################################################################################################# # Parse and validate the command line options, start logging ################################################################################################# @@ -44,27 +44,26 @@ opts, args = validate_opts_args(opts, args) ################################################################################################# -# Create the Cycle Control object for this job +# Create the Cycle Control object for this job ################################################################################################# dacycle = CycleControl(opts, args) -platform = PizDaintPlatform() -dasystem = DaSystem(dacycle['da.system.rc']) +platform = PizDaintPlatform() +dasystem = DaSystem(dacycle['da.system.rc']) obsoperator = ObservationOperator(dacycle['da.obsoperator.rc']) -samples = [ICOSObservations(), TotalColumnObservations()] +samples = [ICOSObservations(), TotalColumnObservations()] statevector = StateVector() -optimizer = Optimizer() +optimizer = Optimizer() ########################################################################################## ################### ENTER THE PIPELINE WITH THE OBJECTS PASSED BY THE USER ############### ########################################################################################## +logging.info(header + "Entering Pipeline " + footer) -logging.info(header + "Entering Pipeline " + footer) - -ensemble_smoother_pipeline(dacycle, platform, dasystem, samples, statevector, obsoperator,optimizer) - +ensemble_smoother_pipeline(dacycle, platform, dasystem, samples, statevector, + obsoperator, optimizer) ########################################################################################## ################### All done, extra stuff can be added next, such as analysis @@ -72,10 +71,8 @@ sys.exit(0) -logging.info(header + "Starting analysis" + footer) +logging.info(header + "Starting analysis" + footer) -analysis_pipeline(dacycle, platform, dasystem, samples, statevector ) +analysis_pipeline(dacycle, platform, dasystem, samples, statevector) sys.exit(0) - - diff --git a/cases/icon-art-CTDAS2/ctdas_patch/utilities.py b/cases/icon-art-CTDAS2/ctdas_patch/utilities.py index 30e3de52..c25c064e 100644 --- a/cases/icon-art-CTDAS2/ctdas_patch/utilities.py +++ b/cases/icon-art-CTDAS2/ctdas_patch/utilities.py @@ -16,12 +16,13 @@ import netCDF4 as nc import numpy as np + class utilities(object): """ Collection of utilities for wrfchem observation operator that do not depend on other CTDAS modules """ - + def __init__(self): pass @@ -53,20 +54,24 @@ def get_slicing_ids(N, nproc, nprocs): field[id0:id1, ...] """ - f0 = float(nproc)/float(nprocs) - id0 = int(np.floor(f0*N)) + f0 = float(nproc) / float(nprocs) + id0 = int(np.floor(f0 * N)) - f1 = float(nproc+1)/float(nprocs) - id1 = int(np.floor(f1*N)) + f1 = float(nproc + 1) / float(nprocs) + id1 = int(np.floor(f1 * N)) - if id0==id1: + if id0 == id1: raise ValueError("id0==id1. Probably too many processes.") return id0, id1 - - @classmethod - def cat_ncfiles(cls, path, in_arg, cat_dim, out_file, in_pattern=False, rm_original=True): + def cat_ncfiles(cls, + path, + in_arg, + cat_dim, + out_file, + in_pattern=False, + rm_original=True): """ Combine output of all processes into 1 file If in_pattern, a pattern is provided instead of a file list. @@ -89,12 +94,14 @@ def cat_ncfiles(cls, path, in_arg, cat_dim, out_file, in_pattern=False, rm_origi if in_pattern: if not isinstance(in_arg, str): - raise TypeError("in_arg must be a string if in_pattern is True.") + raise TypeError( + "in_arg must be a string if in_pattern is True.") file_pattern = in_arg in_files = glob.glob(file_pattern) else: if isinstance(in_arg, list): - raise TypeError("in_arg must be a list if in_pattern is False.") + raise TypeError( + "in_arg must be a list if in_pattern is False.") in_files = in_arg if len(in_files) == 0: @@ -114,19 +121,22 @@ def cat_ncfiles(cls, path, in_arg, cat_dim, out_file, in_pattern=False, rm_origi ncf.close() # Cat files - cmd_ = "ncrcat -h -O -d " + cat_dim + ",0,%d"%(Nobs-1) + cmd_ = "ncrcat -h -O -d " + cat_dim + ",0,%d" % (Nobs - 1) if in_pattern: cmd = cmd_ + " " + file_pattern + " " + out_file # If PIPE is used here, it gets clogged, and the process - # stops without error message (see also + # stops without error message (see also # https://thraxil.org/users/anders/posts/2008/03/13/Subprocess-Hanging-PIPE-is-your-enemy/) # Hence, piping the output to a temporary file. - proc = subprocess.Popen(cmd, shell=True, + proc = subprocess.Popen(cmd, + shell=True, stdout=tempfile.TemporaryFile(), stderr=tempfile.TemporaryFile()) else: cmdsplt = cmd_.split() + in_files + [out_file] - proc = subprocess.Popen(cmdsplt, stdout=tempfile.TemporaryFile(), stderr=tempfile.TemporaryFile()) + proc = subprocess.Popen(cmdsplt, + stdout=tempfile.TemporaryFile(), + stderr=tempfile.TemporaryFile()) cmd = " ".join(cmdsplt) proc.wait() @@ -151,7 +161,6 @@ def cat_ncfiles(cls, path, in_arg, cat_dim, out_file, in_pattern=False, rm_origi # Change back to previous directory os.chdir(cwd) - @staticmethod def check_out_err(process): """Displays stdout and stderr, returns returncode of the @@ -160,7 +169,7 @@ def check_out_err(process): # Get process messages out, err = process.communicate() - + # Print output def to_str(str_or_bytestr): """If argument is of type str, return argument. If @@ -193,7 +202,7 @@ def to_str(str_or_bytestr): logging.error(line.rstrip()) return process.returncode - + @classmethod def get_index_groups(cls, *args): """ @@ -203,22 +212,22 @@ def get_index_groups(cls, *args): Dictionary of lists of indices that have the same combination of input values. """ - + try: # If pandas is available, it makes a pandas DataFrame and # uses its groupby-function. import pandas as pd - + args_array = np.array(args).transpose() df = pd.DataFrame(args_array) groups = df.groupby(list(range(len(args)))).indices - + except ImportError: # If pandas is not available, use an own implementation of groupby. # Recursive implementation. It's fast. args_array = np.array(args).transpose() groups = cls._group(args_array) - + return groups @classmethod @@ -240,18 +249,18 @@ def _group(cls, a): The keys are the unique combinations of indices (rows of a), the values are the indices of the rows of a equal the key. """ - + # This is a recursive function: It makes groups according to the # first columnm, then calls itself with the remaining columns. # Some index juggling. - + # Group according to first column UI = list(set(a[:, 0])) groups0 = dict() for ui in UI: # Key must be a tuple groups0[(ui, )] = [i for i, x in enumerate(a[:, 0]) if x == ui] - + if a.shape[1] == 1: # If the array only has one column, we're done return groups0 @@ -263,17 +272,23 @@ def _group(cls, a): subgroups_ui = cls._group(a[groups0[(ui, )], 1:]) # Now the index juggling: Add the keys together and # locate values in the original array. - for key in list(subgroups_ui.keys()): + for key in list(subgroups_ui.keys()): # Get indices of bigger array - subgroups_ui[key] = [groups0[(ui, )][n] for n in subgroups_ui[key]] + subgroups_ui[key] = [ + groups0[(ui, )][n] for n in subgroups_ui[key] + ] # Add the keys together groups[(ui, ) + key] = subgroups_ui[key] - - return groups + return groups @staticmethod - def apply_by_group(func, array, groups, grouped_args=None, *args, **kwargs): + def apply_by_group(func, + array, + groups, + grouped_args=None, + *args, + **kwargs): """ Apply function 'func' to a numpy array by groups of indices. 'groups' can be a list of lists or a dictionary with lists as @@ -292,28 +307,29 @@ def apply_by_group(func, array, groups, grouped_args=None, *args, **kwargs): Output: array([0.5, 2. ]) """ - + shape_in = array.shape shape_out = list(shape_in) shape_out[0] = len(groups) array_out = np.ndarray(shape_out, dtype=array.dtype) - + if type(groups) == list: # Make a dictionary groups = {{n: groups[n] for n in range(len(groups))}} - + if not grouped_args is None: kwargs0 = copy.deepcopy(kwargs) for n in range(len(groups)): k = list(groups.keys())[n] - + # Add additional arguments that need to be grouped to kwargs if not grouped_args is None: kwargs = copy.deepcopy(kwargs0) for ka, v in grouped_args.items(): kwargs[ka] = v[groups[k], ...] - - array_out[n, ...] = np.apply_along_axis(func, 0, array[groups[k], ...], *args, **kwargs) - - return array_out + array_out[n, ...] = np.apply_along_axis(func, 0, array[groups[k], + ...], *args, + **kwargs) + + return array_out diff --git a/config.py b/config.py index 9f2fefc4..2aca1dba 100644 --- a/config.py +++ b/config.py @@ -292,7 +292,9 @@ def print_config(self): item).__name__ == "PosixPath" else type(item).__name__ if item_type == "dict": for sub_key, sub_value in item.items(): - print(f" - {sub_key:<{max_col_width-4}} {sub_value}") + print( + f" - {sub_key:<{max_col_width-4}} {sub_value}" + ) else: print(f" - {item:<{max_col_width-4}} {item_type}") elif isinstance(value, dict): diff --git a/jobs/CTDAS.py b/jobs/CTDAS.py index 885c3cc0..8999c066 100644 --- a/jobs/CTDAS.py +++ b/jobs/CTDAS.py @@ -9,10 +9,15 @@ BASIC_PYTHON_JOB = False + def submit_job(command): """Submit a job and return the job ID.""" logging.info(f"Running: {command}") - result = subprocess.run(command, shell=True, capture_output=True, text=True, check=False) + result = subprocess.run(command, + shell=True, + capture_output=True, + text=True, + check=False) match = re.search(r"Submitted batch job (\d+)", result.stdout) if match: @@ -21,6 +26,7 @@ def submit_job(command): logging.error("Failed to get job ID from sbatch output.") return None + def wait_for_job(job_id): """Wait for a job to complete.""" if not job_id: @@ -28,23 +34,31 @@ def wait_for_job(job_id): logging.info(f"Waiting for job {job_id} to complete...") while True: - result = subprocess.run(f"sacct -j {job_id} --format=State --noheader", shell=True, capture_output=True, text=True) + result = subprocess.run(f"sacct -j {job_id} --format=State --noheader", + shell=True, + capture_output=True, + text=True) state = result.stdout.strip() if state: logging.info(f"Job {job_id} state: {state}") - if any(s in state for s in ["COMPLETED", "FAILED", "CANCELLED", "TIMEOUT"]): + if any(s in state + for s in ["COMPLETED", "FAILED", "CANCELLED", "TIMEOUT"]): logging.info(f"Job {job_id} finished with state: {state}") return False, state - if any(s in state for s in ["COMPLETED",]): + if any(s in state for s in [ + "COMPLETED", + ]): logging.info(f"Job {job_id} finished with state: {state}") return True, state time.sleep(10) + def run_icon_case(cfg, suffix="", output_file=None, max_retries=5): """Run an ICON case job and wait for it to complete if output is not already present.""" if output_file and output_file.exists(): - logging.info(f"Skipping ICON case {suffix} as output exists: {output_file}") + logging.info( + f"Skipping ICON case {suffix} as output exists: {output_file}") return True icon_ini_template = cfg.case_path / cfg.icon_runjob_filename @@ -65,13 +79,16 @@ def run_icon_case(cfg, suffix="", output_file=None, max_retries=5): if state in ["FAILED", "CANCELLED", "TIMEOUT"]: retries += 1 - logging.warning(f"Job failed with state {state}. Retrying {retries}/{max_retries}...") + logging.warning( + f"Job failed with state {state}. Retrying {retries}/{max_retries}..." + ) else: break logging.error("ICON job failed after maximum retries.") return False + def start_ctdas(cfg): """Start CTDAS process.""" logging.info("Starting CTDAS") @@ -81,13 +98,13 @@ def start_ctdas(cfg): command = "cd $SCRATCH/ctdas_procchain/exec && sbatch ctdas_procchain.jb" subprocess.run(command, shell=True, check=True) except subprocess.CalledProcessError: - logging.info("CTDAS already exists -- we did NOT instantiate this CTDAS run") + logging.info( + "CTDAS already exists -- we did NOT instantiate this CTDAS run") def main(cfg): prepare_icon.set_cfg_variables(cfg) tools.change_logfile(cfg.logfile) - """ Start CTDAS inversion @@ -110,12 +127,14 @@ def main(cfg): logging.info("Run first ICON case") run_icon_case(cfg, output_file=output_file_1) - + logging.info("Start CTDAS") start_ctdas(cfg) if cfg.CTDAS_runthrough: - run_icon_case(cfg, "_firstrun_runthrough", output_file=output_file_2) + run_icon_case(cfg, + "_firstrun_runthrough", + output_file=output_file_2) if cfg.CTDAS_runthrough: run_icon_case(cfg, "_runthrough", output_file=output_file_3) diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index 130f36e6..2f729999 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -18,24 +18,30 @@ BASIC_PYTHON_JOB = False + def run_bash_script(template, job, **kwargs): with job.open('w') as outfile: outfile.write(template.read_text().format(**kwargs)) subprocess.run(["bash", job], check=True, stdout=subprocess.PIPE) + def era5_splitting_script(cfg, ERA5_folder, output_filenames): era5_split_template = cfg.case_path / cfg.meteo_era5_splitjob - era5_split_job = ERA5_folder / ( - era5_split_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}' + - era5_split_template.suffix) - logging.info(f"Preparing ERA5 splitting script for ICON from {era5_split_template}") - ml_files = " ".join( - [f"{filenames[0]}" for filenames in output_filenames]) + era5_split_job = ERA5_folder / (era5_split_template.stem + + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + era5_split_template.suffix) + logging.info( + f"Preparing ERA5 splitting script for ICON from {era5_split_template}") + ml_files = " ".join([f"{filenames[0]}" for filenames in output_filenames]) surf_files = " ".join( [f"{filenames[1]}" for filenames in output_filenames]) - run_bash_script(era5_split_template, era5_split_job, cfg=cfg, - ml_files=ml_files, surf_files=surf_files, ERA5_folder=ERA5_folder) + run_bash_script(era5_split_template, + era5_split_job, + cfg=cfg, + ml_files=ml_files, + surf_files=surf_files, + ERA5_folder=ERA5_folder) + def initial_conditions_script(cfg, ERA5_folder, CAMS_folder, era5_ini_file): datestr = cfg.startdate_sim.strftime("%Y-%m-%dT%H:%M:%S") @@ -43,25 +49,33 @@ def initial_conditions_script(cfg, ERA5_folder, CAMS_folder, era5_ini_file): era5_surf_file = ERA5_folder / f"era5_surf_{datestr}.nc" era5_ini_template = cfg.case_path / cfg.meteo_era5_inijob era5_ini_job = ERA5_folder / (era5_ini_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}' - + era5_ini_template.suffix) - run_bash_script(era5_ini_template, era5_ini_job, cfg=cfg, - era5_ml_file=era5_ml_file, era5_surf_file=era5_surf_file, - inicond_filename=era5_ini_file, ERA5_folder=ERA5_folder) + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + era5_ini_template.suffix) + run_bash_script(era5_ini_template, + era5_ini_job, + cfg=cfg, + era5_ml_file=era5_ml_file, + era5_surf_file=era5_surf_file, + inicond_filename=era5_ini_file, + ERA5_folder=ERA5_folder) shutil.copy(cfg.case_path / cfg.meteo_partab, ERA5_folder / 'mypartab') logging.info(f"Running ERA5 initial conditions script {era5_ini_job}") cams_ini_template = cfg.case_path / cfg.chem_cams_inijob cams_ini_job = ERA5_folder / (cams_ini_template.stem + - f'{cfg.startdate_sim.strftime("%Y%m%d")}' - + cams_ini_template.suffix) - run_bash_script(cams_ini_template, cams_ini_job, cfg=cfg, - inicond_filename=era5_ini_file, ERA5_folder=ERA5_folder, + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + + cams_ini_template.suffix) + run_bash_script(cams_ini_template, + cams_ini_job, + cfg=cfg, + inicond_filename=era5_ini_file, + ERA5_folder=ERA5_folder, CAMS_file=CAMS_folder / f'cams_egg4_{cfg.startdate_sim.strftime("%Y%m%dT%H")}.nc', era5_cams_ini_file=era5_ini_file) logging.info(f"Running CAMS initial conditions script {cams_ini_job}") + def boundary_conditions_script(cfg, ERA5_folder, CAMS_folder, time): datestr = time.strftime("%Y-%m-%dT%H:%M:%S") datestr2 = time.strftime("%Y%m%d%H") @@ -73,9 +87,13 @@ def boundary_conditions_script(cfg, ERA5_folder, CAMS_folder, time): nudging_template = cfg.case_path / cfg.meteo_era5_nudgingjob nudging_job = ERA5_folder / f'icon_era5_nudging_{datestr}.sh' - run_bash_script(nudging_template, nudging_job, cfg=cfg, - era5_ml_file=era5_ml_file, era5_surf_file=era5_surf_file, - filename=era5_nudge_file, ERA5_folder=ERA5_folder) + run_bash_script(nudging_template, + nudging_job, + cfg=cfg, + era5_ml_file=era5_ml_file, + era5_surf_file=era5_surf_file, + filename=era5_nudge_file, + ERA5_folder=ERA5_folder) if not os.path.exists(ERA5_folder / 'mypartab'): shutil.copy(cfg.case_path / cfg.meteo_partab, @@ -86,13 +104,17 @@ def boundary_conditions_script(cfg, ERA5_folder, CAMS_folder, time): cams_nudge_template.stem + f'{cfg.startdate_sim.strftime("%Y%m%d")}' + cams_nudge_template.suffix) - run_bash_script(cams_nudge_template, cams_nudge_job, cfg=cfg, - filename=era5_nudge_file, ERA5_folder=ERA5_folder, + run_bash_script(cams_nudge_template, + cams_nudge_job, + cfg=cfg, + filename=era5_nudge_file, + ERA5_folder=ERA5_folder, CAMS_file=CAMS_folder / f'cams_egg4_{time.strftime("%Y%m%dT%H")}.nc', era5_cams_nudge_file=era5_nudge_file_final) logging.info(f"Running CAMS nudging script {cams_nudge_job}") + def create_icon_job(cfg, run_type, firstrun=False, runthrough=False): """Generate ICON script dynamically.""" OEM_folder = cfg.case_root / "global_inputs" / "OEM" @@ -133,99 +155,122 @@ def create_icon_job(cfg, run_type, firstrun=False, runthrough=False): output_init = 24 * 60 * 60 * cfg.CTDAS_ctdas_cycle + cfg.CTDAS_restart_init_time restart_file = cfg.case_root / "global_outputs" / f"runthrough_{(cfg.startdate_sim - timedelta(days=cfg.CTDAS_ctdas_cycle)).strftime('%Y%m%d')}" / f"ICON-ART-OEM-INIT_{(cfg.startdate_sim + timedelta(seconds=cfg.CTDAS_restart_init_time)).strftime('%Y-%m-%dT%H:%M:%S')}.000.nc" - tools.create_dir(output_directory, f"Create {run_type} output") - - script_content = (fn := cfg.case_path / cfg.icon_runjob_filename).read_text().format( + + script_content = ( + fn := cfg.case_path / cfg.icon_runjob_filename + ).read_text().format( cfg=cfg, ini_restart_string=cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%SZ'), ini_restart_end_string=ini_restart_end_string, - inifile_nc=cfg.icon_input_icbc / f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", + inifile_nc=cfg.icon_input_icbc / + f"era5_ini_{cfg.startdate_sim.strftime('%Y-%m-%dT%H:%M:%S')}.nc", tracers_xml=tracers_xml, - emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", + emissionsgrid_nc=cfg.case_root / "global_inputs" / "inventories" / + f"INV_{(cfg.startdate_sim + timedelta(days=1)).strftime('%Y%m%d')}.nc", vertical_profile_nc=OEM_folder / "vertical_profiles.nc", hour_of_year_nc=OEM_folder / "hourofyear.nc", lambda_nc=lambda_nc, lambda_regions_nc=OEM_folder / "lambdaregions.nc", bg_lambda_nc=bg_lambda_nc, bg_lambda_regions_nc=OEM_folder / "boundary_mask_bg.nc", - vprm_coeffs_nc=cfg.case_root / "global_inputs" / "VPRM" / cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], - latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / "lateral_boundary.grid.nc", + vprm_coeffs_nc=cfg.case_root / "global_inputs" / "VPRM" / + cfg.CTDAS_global_inputs_VPRM[0].split('/')[-1], + latbc_boundary_grid_nc=cfg.case_root / "global_inputs" / "grid" / + "lateral_boundary.grid.nc", output_directory=output_directory, restart_file=restart_file, restart_init_time=cfg.CTDAS_restart_init_time, - output_init=output_init - ) - + output_init=output_init) + script_path = cfg.icon_work / f"{fn.stem}_{cfg.startdate_sim.strftime('%Y%m%d')}{'_' + run_type if not firstrun else ''}{'_firstrun_runthrough' if firstrun and runthrough else ''}{fn.suffix}" with script_path.open('w') as outfile: outfile.write(script_content) logging.info(f"Preparing ICON script for {run_type} run at {script_path}") + def create_slurm_script(cfg): """Generate SLURM script based on machine type.""" base_lines = [ '#!/usr/bin/env bash', f'#SBATCH --job-name="copy_input_{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.enddate_sim_yyyymmddhh}"', - '#SBATCH --time=00:10:00', - f'#SBATCH --partition={cfg.compute_queue}', + '#SBATCH --time=00:10:00', f'#SBATCH --partition={cfg.compute_queue}', f'#SBATCH --constraint={cfg.constraint}', - f'#SBATCH --output={cfg.logfile}', - '#SBATCH --open-mode=append', + f'#SBATCH --output={cfg.logfile}', '#SBATCH --open-mode=append', f'#SBATCH --chdir={cfg.case_root / "global_inputs"}', '' ] - + machine_specific = { - 'daint': [ - f'#SBATCH --account={cfg.compute_account}', - '#SBATCH --nodes=1' - ], + 'daint': + [f'#SBATCH --account={cfg.compute_account}', '#SBATCH --nodes=1'], 'euler': ['#SBATCH --ntasks=1'], - 'santis': [ - '#SBATCH --nodes=1', - f'#SBATCH --account={cfg.compute_account}' - ] + 'santis': + ['#SBATCH --nodes=1', f'#SBATCH --account={cfg.compute_account}'] } - + return base_lines + machine_specific.get(cfg.machine, []) + def copy_global_inputs(cfg): """Handle copying of global input files.""" script_lines = create_slurm_script(cfg) - + for attr in dir(cfg): if attr.startswith('CTDAS_global_inputs_'): category = attr[len('CTDAS_global_inputs_'):] cat_folder = cfg.case_root / "global_inputs" / category tools.create_dir(cat_folder, category) - + for file in getattr(cfg, attr): source = Path(file) destination = cat_folder / source.name script_lines.append(f'rsync -av {source} {destination}') - + script_path = cfg.case_root / "global_inputs" / 'copy_global_inputs.job' with script_path.open('w') as f: f.write('\n'.join(script_lines)) cfg.submit('global_inputs', script_path) + def generate_tracers(cfg): """Generate tracers XML files.""" - tools.create_dir(xml_folder := cfg.case_root / "global_inputs" / "XML", "XML") - TR_prior = generate_tracers_xml(cfg.tracers, cfg.CTDAS_nensembles, restart=False, propagate_bg=cfg.CTDAS_propagate_bg) - TR_restart = generate_tracers_xml(cfg.tracers, cfg.CTDAS_nensembles, restart=True, propagate_bg=cfg.CTDAS_propagate_bg) - with open(xml_folder / "tracers_firstrun.xml", "w", encoding="utf-8") as file: + tools.create_dir(xml_folder := cfg.case_root / "global_inputs" / "XML", + "XML") + TR_prior = generate_tracers_xml(cfg.tracers, + cfg.CTDAS_nensembles, + restart=False, + propagate_bg=cfg.CTDAS_propagate_bg) + TR_restart = generate_tracers_xml(cfg.tracers, + cfg.CTDAS_nensembles, + restart=True, + propagate_bg=cfg.CTDAS_propagate_bg) + with open(xml_folder / "tracers_firstrun.xml", "w", + encoding="utf-8") as file: file.write(TR_prior) - with open(xml_folder / "tracers_restart.xml", "w", encoding="utf-8") as file: + with open(xml_folder / "tracers_restart.xml", "w", + encoding="utf-8") as file: file.write(TR_restart) if cfg.CTDAS_runthrough: - TR_runthrough_prior = generate_tracers_xml(cfg.tracers, cfg.CTDAS_nensembles, cfg.CTDAS_nboundaries, restart=False, runthrough=True) - TR_runthrough_restart = generate_tracers_xml(cfg.tracers, cfg.CTDAS_nensembles, cfg.CTDAS_nboundaries, restart=True, runthrough=True) - with open(xml_folder / "tracers_runthrough_firstrun.xml", "w", encoding="utf-8") as file: + TR_runthrough_prior = generate_tracers_xml(cfg.tracers, + cfg.CTDAS_nensembles, + cfg.CTDAS_nboundaries, + restart=False, + runthrough=True) + TR_runthrough_restart = generate_tracers_xml(cfg.tracers, + cfg.CTDAS_nensembles, + cfg.CTDAS_nboundaries, + restart=True, + runthrough=True) + with open(xml_folder / "tracers_runthrough_firstrun.xml", + "w", + encoding="utf-8") as file: file.write(TR_runthrough_prior) - with open(xml_folder / "tracers_runthrough_restart.xml", "w", encoding="utf-8") as file: + with open(xml_folder / "tracers_runthrough_restart.xml", + "w", + encoding="utf-8") as file: file.write(TR_runthrough_restart) + def main(cfg): """ Prepare CTDAS inversion @@ -253,13 +298,17 @@ def main(cfg): # -- 1. Download CAMS CO2 data (for simulation period) if cfg.chem_fetch_CAMS: - tools.create_dir(CAMS_folder := cfg.case_root / "global_inputs" / "CAMS", "CAMS input files") + tools.create_dir( + CAMS_folder := cfg.case_root / "global_inputs" / "CAMS", + "CAMS input files") fetch_CAMS_CO2(cfg.startdate_sim, (cfg.enddate_sim + timedelta(days=1)), CAMS_folder) # -- 2. Fetch ERA5 data (for simulation period) if cfg.meteo_fetch_era5: - tools.create_dir(ERA5_folder := cfg.case_root / "global_inputs" / "ERA5", "ERA5 input files") + tools.create_dir( + ERA5_folder := cfg.case_root / "global_inputs" / "ERA5", + "ERA5 input files") times = list( tools.iter_hours(cfg.startdate_sim, (cfg.enddate_sim + timedelta(days=1)), @@ -286,7 +335,9 @@ def main(cfg): if not missing_files: logging.info("All model level files already present") else: - logging.info(f"Missing files: {missing_files}. All data will be re-fetched.") + logging.info( + f"Missing files: {missing_files}. All data will be re-fetched." + ) # Split downloads in 3-day chunks, but run simultaneously N = 3 chunks = list( @@ -331,8 +382,8 @@ def main(cfg): # -- 4. Create boundary conditions for ICON for time in tools.iter_hours(cfg.startdate_sim, - (cfg.enddate_sim + timedelta(days=1)), - step=cfg.meteo_nudging_step): + (cfg.enddate_sim + timedelta(days=1)), + step=cfg.meteo_nudging_step): boundary_conditions_script(cfg, ERA5_folder, CAMS_folder, time) # -- 5. Download ICOS CO2 data @@ -362,31 +413,35 @@ def main(cfg): # product="OCO2_L2_Lite_FP_11.1r") tools.create_dir(OCO2_path := cfg.case_root / "global_inputs" / "OCO2", "OCO-2 output") - process_OCO2_data(OCO2_obs_folder=cfg.CTDAS_obs_OCO2_path, - ICON_grid_file=cfg.input_files_dynamics_grid_filename, - start_date=cfg.startdate_sim, - end_date=(cfg.enddate_sim + timedelta(days=1)), - output_folder=OCO2_path) + process_OCO2_data( + OCO2_obs_folder=cfg.CTDAS_obs_OCO2_path, + ICON_grid_file=cfg.input_files_dynamics_grid_filename, + start_date=cfg.startdate_sim, + end_date=(cfg.enddate_sim + timedelta(days=1)), + output_folder=OCO2_path) # -- 7. Create the required run data # Create sampling output folder tools.create_dir(cfg.case_root / "global_outputs" / "extracted_ICOS", "Output of the extraction script") - + # Create ICON jobs create_icon_job(cfg, "prior") create_icon_job(cfg, "opt1") create_icon_job(cfg, "opt2") - if cfg.startdate_sim == cfg.startdate: create_icon_job(cfg, "opt2", firstrun=True) - if cfg.CTDAS_runthrough: create_icon_job(cfg, "runthrough", runthrough=True) - if (cfg.startdate_sim == cfg.startdate) and cfg.CTDAS_runthrough: create_icon_job(cfg, "runthrough", firstrun=True, runthrough=True) + if cfg.startdate_sim == cfg.startdate: + create_icon_job(cfg, "opt2", firstrun=True) + if cfg.CTDAS_runthrough: + create_icon_job(cfg, "runthrough", runthrough=True) + if (cfg.startdate_sim == cfg.startdate) and cfg.CTDAS_runthrough: + create_icon_job(cfg, "runthrough", firstrun=True, runthrough=True) # Copy global input data if cfg.startdate_sim == cfg.startdate: copy_global_inputs(cfg) # Generate tracers if cfg.startdate_sim == cfg.startdate: generate_tracers(cfg) - + # Generate initial ensemble lambdas (equal to 1) if cfg.startdate_sim == cfg.startdate: # Set up OEM Folder @@ -408,28 +463,39 @@ def main(cfg): propagate_bg=cfg.CTDAS_propagate_bg) if cfg.CTDAS_runthrough: create_prior_all_zeros(OEM_folder / "prior_all_zeros.nc", - nensembles=cfg.CTDAS_nboundaries, - ncats=max(lambdas), - nregs=nregs) + nensembles=cfg.CTDAS_nboundaries, + ncats=max(lambdas), + nregs=nregs) else: raise NotImplementedError('Only basegrid is implemented for now') create_boundary_regions(cfg.input_files_dynamics_grid_filename, - OEM_folder / 'boundary_mask_bg.nc', - cfg.CTDAS_nboundaries, - cfg.cdo_nco_cmd, cfg.cdo_nco_cmd_post) + OEM_folder / 'boundary_mask_bg.nc', + cfg.CTDAS_nboundaries, cfg.cdo_nco_cmd, + cfg.cdo_nco_cmd_post) create_boundary_prior_all_ones(OEM_folder / 'boundary_lambdas_bg.nc', n_bg_ens=cfg.CTDAS_nboundaries, nensembles=cfg.CTDAS_nensembles, propagate_bg=cfg.CTDAS_propagate_bg) if cfg.CTDAS_runthrough: - create_boundary_prior_separate(OEM_folder / 'boundary_lambdas_separate.nc', - n_bg_ens=cfg.CTDAS_nboundaries) + create_boundary_prior_separate(OEM_folder / + 'boundary_lambdas_separate.nc', + n_bg_ens=cfg.CTDAS_nboundaries) # Patch CTDAS files if cfg.startdate_sim == cfg.startdate: logging.info("Patching CTDAS files") + def evaluate_dict(d, replace, using): - return {key: eval(value.replace(replace, str(using))) for key, value in d.items()} - meta_dict = {d.replace("XXX", "ENS"): {"ensemble": cfg.CTDAS_nensembles} if "XXX" in d else {} for d in cfg.tracers if not d.startswith("EM")} + return { + key: eval(value.replace(replace, str(using))) + for key, value in d.items() + } + + meta_dict = { + d.replace("XXX", "ENS"): { + "ensemble": cfg.CTDAS_nensembles + } if "XXX" in d else {} + for d in cfg.tracers if not d.startswith("EM") + } for key, source_paths in cfg.CTDAS["ctdas_patch"].items(): destination_dir = Path(cfg.CTDAS_ctdas_path) / key os.makedirs(destination_dir, exist_ok=True) @@ -438,7 +504,8 @@ def evaluate_dict(d, replace, using): for source_path in source_paths: in_path = cfg.case_path / source_path destination_path = destination_dir / in_path.name - with in_path.open('r') as infile, destination_path.open('w') as outfile: + with in_path.open('r') as infile, destination_path.open( + 'w') as outfile: outfile.write(eval(f"f'''{infile.read()}'''")) logging.info(f"Copied {in_path} -> {destination_path}") diff --git a/jobs/tools/ICON_to_point.py b/jobs/tools/ICON_to_point.py index a1063c6a..da5ff8e6 100644 --- a/jobs/tools/ICON_to_point.py +++ b/jobs/tools/ICON_to_point.py @@ -198,7 +198,9 @@ def icon_to_point(longitude, """ # Open multiple ICON datasets - icon_field = xr.open_mfdataset(icon_field_paths, combine='by_coords', chunks={'time': 50}) + icon_field = xr.open_mfdataset(icon_field_paths, + combine='by_coords', + chunks={'time': 50}) # Load the ICON grid icon_grid = xr.open_dataset(icon_grid_path) @@ -216,16 +218,18 @@ def icon_to_point(longitude, horizontal_distances, icon_grid_indices = get_horizontal_distances( longitude, latitude, icon_grid, k=k) - horizontal_weights = 1 / horizontal_distances / (1 / horizontal_distances).sum(axis=1, keepdims=True) + horizontal_weights = 1 / horizontal_distances / ( + 1 / horizontal_distances).sum(axis=1, keepdims=True) - weights_horizontal = xr.DataArray(horizontal_weights, dims=["station", icon_cells]) + weights_horizontal = xr.DataArray(horizontal_weights, + dims=["station", icon_cells]) ind_X = xr.DataArray(icon_grid_indices, dims=["station", icon_cells]) icon_subset = icon_field.isel({icon_cells: ind_X}) # --- Vertical level selection & interpolation weights # Get 2 nearest vertical distances (for use in linear interpolation) if icon_field.time.size > 1: - model_topography = icon_subset.z_ifc[-1,-1] + model_topography = icon_subset.z_ifc[-1, -1] model_levels = icon_subset.z_mc[1] else: model_topography = icon_subset.z_ifc[-1] @@ -268,6 +272,7 @@ def icon_to_point(longitude, ) # Remove out of bounds values where weights_vertical has NaNs return xr.merge([icon_out, ds]) + if __name__ == '__main__': parser = argparse.ArgumentParser( description='Interpolate ICON output to point locations.') diff --git a/jobs/tools/ICON_to_point2.py b/jobs/tools/ICON_to_point2.py index e1f3de53..d88a0ad8 100644 --- a/jobs/tools/ICON_to_point2.py +++ b/jobs/tools/ICON_to_point2.py @@ -2,17 +2,23 @@ import numpy as np from math import radians -def intp_icon_data(iloc, gridinfo, datainfo, latitudes, longitudes, asl, elev, station_name): + +def intp_icon_data(iloc, gridinfo, datainfo, latitudes, longitudes, asl, elev, + station_name): nn_sel = np.zeros(gridinfo.nn, dtype=int) u = np.zeros(gridinfo.nn) R = 6373.0 # Earth's radius in km - if (radians(longitudes[iloc]) < np.nanmin(gridinfo.clon)) or (radians(longitudes[iloc]) > np.nanmax(gridinfo.clon)): - return np.nan * np.ones((gridinfo.nn)), np.full((gridinfo.nn), -1), np.full((gridinfo.nn), -1), nn_sel, u + if (radians(longitudes[iloc]) < np.nanmin(gridinfo.clon)) or (radians( + longitudes[iloc]) > np.nanmax(gridinfo.clon)): + return np.nan * np.ones((gridinfo.nn)), np.full( + (gridinfo.nn), -1), np.full((gridinfo.nn), -1), nn_sel, u - if (radians(latitudes[iloc]) < np.nanmin(gridinfo.clat)) or (radians(latitudes[iloc]) > np.nanmax(gridinfo.clat)): - return np.nan * np.ones((gridinfo.nn)), np.full((gridinfo.nn), -1), np.full((gridinfo.nn), -1), nn_sel, u + if (radians(latitudes[iloc]) < np.nanmin(gridinfo.clat)) or (radians( + latitudes[iloc]) > np.nanmax(gridinfo.clat)): + return np.nan * np.ones((gridinfo.nn)), np.full( + (gridinfo.nn), -1), np.full((gridinfo.nn), -1), nn_sel, u lat1, lon1 = radians(latitudes[iloc]), radians(longitudes[iloc]) @@ -46,7 +52,10 @@ def intp_icon_data(iloc, gridinfo, datainfo, latitudes, longitudes, asl, elev, s for nnidx in range(gridinfo.nn): if idx_below[nnidx] != idx_above[nnidx]: - vert_scaling_fact[nnidx] = (target_asl[nnidx] - datainfo.z_mc[idx_below[nnidx], nn_sel[0, nnidx]]) / ( - datainfo.z_mc[idx_above[nnidx], nn_sel[0, nnidx]] - datainfo.z_mc[idx_below[nnidx], nn_sel[0, nnidx]]) + vert_scaling_fact[nnidx] = ( + target_asl[nnidx] - + datainfo.z_mc[idx_below[nnidx], nn_sel[0, nnidx]]) / ( + datainfo.z_mc[idx_above[nnidx], nn_sel[0, nnidx]] - + datainfo.z_mc[idx_below[nnidx], nn_sel[0, nnidx]]) return vert_scaling_fact, idx_below, idx_above, nn_sel.flatten(), u diff --git a/jobs/tools/ctdas_utilities.py b/jobs/tools/ctdas_utilities.py index fa1734de..4ddc0d20 100644 --- a/jobs/tools/ctdas_utilities.py +++ b/jobs/tools/ctdas_utilities.py @@ -31,21 +31,25 @@ def create_lambda_regions(input_grid, output_path, lambdas_ids): try: ds_cells.to_netcdf(output_path, - encoding={ - 'REG': { - 'dtype': 'int32' - }, - 'cell': { - 'dtype': 'int32' - } - }) + encoding={ + 'REG': { + 'dtype': 'int32' + }, + 'cell': { + 'dtype': 'int32' + } + }) except: print("File currently open. Please close the file and try again.") print(f"Lambda regions saved to {output_path}") return nregs, categories[-1] -def create_prior_all_ones(output_path, nensembles, ncats, nregs, propagate_bg=False): +def create_prior_all_ones(output_path, + nensembles, + ncats, + nregs, + propagate_bg=False): """ Create a dataset of initial lambdas (all ones) for testing. """ @@ -55,11 +59,12 @@ def create_prior_all_ones(output_path, nensembles, ncats, nregs, propagate_bg=Fa data = xr.DataArray(arr, dims=['ens', 'reg', 'cat', 'tracer']) ds = xr.Dataset({'lambda': data}) try: - ds.to_netcdf(output_path) + ds.to_netcdf(output_path) except: print("File currently open. Please close the file and try again.") print(f"Prior all ones saved to {output_path}") + def create_prior_all_zeros(output_path, nensembles, ncats, nregs): """ Create a dataset of initial lambdas (all zeros) for testing. @@ -141,7 +146,10 @@ def create_boundary_regions(grid_filename, output_path, n_bg_ens, cdo_nco_cmd, print(f"Boundary regions saved to {output_path}") -def create_boundary_prior_all_ones(output_path, n_bg_ens, nensembles, propagate_bg=False): +def create_boundary_prior_all_ones(output_path, + n_bg_ens, + nensembles, + propagate_bg=False): """ Create boundary lambdas dataset and save to NetCDF. """ @@ -162,6 +170,7 @@ def create_boundary_prior_all_ones(output_path, n_bg_ens, nensembles, propagate_ print("File currently open. Please close the file and try again.") print(f"Boundary lambdas saved to {output_path}") + def create_boundary_prior_separate(output_path, n_bg_ens): """ Create boundary lambdas dataset and save to NetCDF. diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index d887a50b..3cef0058 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -776,37 +776,64 @@ def process_OCO2_data(OCO2_obs_folder, # Limit to extent of ICON grid ICON_grid = xr.open_dataset(ICON_grid_file) - offset = 1.2 # 1.2 degrees offset to ensure no data is beyond the grid bounds - try: + offset = 1.2 # 1.2 degrees offset to ensure no data is beyond the grid bounds + try: s5p_data = s5p_data.where( - (s5p_data.longitude >= np.rad2deg(ICON_grid.clon.min().values) + offset) & - (s5p_data.longitude <= np.rad2deg(ICON_grid.clon.max().values) - offset) & - (s5p_data.latitude >= np.rad2deg(ICON_grid.clat.min().values) + offset) & - (s5p_data.latitude <= np.rad2deg(ICON_grid.clat.max().values) - offset), + (s5p_data.longitude + >= np.rad2deg(ICON_grid.clon.min().values) + offset) & + (s5p_data.longitude + <= np.rad2deg(ICON_grid.clon.max().values) - offset) & + (s5p_data.latitude + >= np.rad2deg(ICON_grid.clat.min().values) + offset) & + (s5p_data.latitude + <= np.rad2deg(ICON_grid.clat.max().values) - offset), drop=True).where(s5p_data.xco2_quality_flag == 0, drop=True) # s5p_data = s5p_data.where((s5p_data.longitude > -8.6) & (s5p_data.longitude < 17.9) & (s5p_data.latitude > 40.6) & (s5p_data.latitude < 59), drop=True) print("The new limits are....") - print(f"{s5p_data.longitude.min().values} {s5p_data.longitude.max().values}") - print(f"{s5p_data.latitude.min().values} {s5p_data.latitude.max().values}") + print( + f"{s5p_data.longitude.min().values} {s5p_data.longitude.max().values}" + ) + print( + f"{s5p_data.latitude.min().values} {s5p_data.latitude.max().values}" + ) print("Filtered on") - print(f"{np.rad2deg(ICON_grid.clon.min()).values} {np.rad2deg(ICON_grid.clon.max()).values}") - print(f"{np.rad2deg(ICON_grid.clat.min()).values} {np.rad2deg(ICON_grid.clat.max()).values}") + print( + f"{np.rad2deg(ICON_grid.clon.min()).values} {np.rad2deg(ICON_grid.clon.max()).values}" + ) + print( + f"{np.rad2deg(ICON_grid.clat.min()).values} {np.rad2deg(ICON_grid.clat.max()).values}" + ) except: - print(f"No observations remain after filtering {file} to ICON grid limits") + print( + f"No observations remain after filtering {file} to ICON grid limits" + ) s5p_out = xr.Dataset( { - "latitude": (["soundings"], np.array([], dtype=np.float32)), - "longitude": (["soundings"], np.array([], dtype=np.float32)), - "date": (["soundings", "epoch_dimension"], np.empty((0, 7), dtype=np.float32)), + "latitude": + (["soundings"], np.array([], dtype=np.float32)), + "longitude": + (["soundings"], np.array([], dtype=np.float32)), + "date": (["soundings", "epoch_dimension" + ], np.empty((0, 7), dtype=np.float32)), "obs": (["soundings"], np.array([], dtype=np.float32)), - "quality_flag": (["soundings"], np.array([], dtype=np.int32)), - "averaging_kernel": (["soundings", "layers"], np.empty((0, 20), dtype=np.float32)), - "pressure_levels": (["soundings", "layers"], np.empty((0, 20), dtype=np.float32)), - "pressure_weighting_function": (["soundings", "layers"], np.empty((0, 20), dtype=np.float32)), - "prior_profile": (["soundings", "layers"], np.empty((0, 20), dtype=np.float32)), + "quality_flag": + (["soundings"], np.array([], dtype=np.int32)), + "averaging_kernel": (["soundings", "layers" + ], np.empty( + (0, 20), dtype=np.float32)), + "pressure_levels": (["soundings", "layers" + ], np.empty( + (0, 20), dtype=np.float32)), + "pressure_weighting_function": + (["soundings", "layers" + ], np.empty((0, 20), dtype=np.float32)), + "prior_profile": (["soundings", "layers" + ], np.empty((0, 20), dtype=np.float32)), "prior": (["soundings"], np.array([], dtype=np.float32)), - "uncertainty": (["soundings"], np.array([], dtype=np.float32)), - "surface_pressure": (["soundings"], np.array([], dtype=np.float32)), + "uncertainty": + (["soundings"], np.array([], dtype=np.float32)), + "surface_pressure": + (["soundings"], np.array([], dtype=np.float32)), }, coords={ "soundings": np.array([], dtype=np.int32), @@ -820,9 +847,10 @@ def process_OCO2_data(OCO2_obs_folder, 'retrieval_id': file[0].name if file else 'unknown', }, ) - s5p_out.to_netcdf(output_folder / f"OCO2_{day.strftime('%Y%m%d')}_ctdas.nc") + s5p_out.to_netcdf(output_folder / + f"OCO2_{day.strftime('%Y%m%d')}_ctdas.nc") continue - + s5p_out = s5p_data[[ "latitude", "longitude", "date", "xco2", "xco2_quality_flag", "xco2_averaging_kernel", "pressure_levels", "pressure_levels", @@ -843,7 +871,7 @@ def process_OCO2_data(OCO2_obs_folder, s5p_out["pressure_levels"][:] = s5p_out.pressure_levels[:, ::-1].values s5p_out[ "pressure_weighting_function"][:] = s5p_out.pressure_weighting_function[:, :: - -1].values + -1].values s5p_out["prior_profile"][:] = s5p_out.prior_profile[:, ::-1].values s5p_out["surface_pressure"] = s5p_out.pressure_levels[:, 0] s5p_out.attrs.update({ diff --git a/jobs/tools/generate_tracers_xml.py b/jobs/tools/generate_tracers_xml.py index 98aef5da..667f59fd 100644 --- a/jobs/tools/generate_tracers_xml.py +++ b/jobs/tools/generate_tracers_xml.py @@ -3,7 +3,12 @@ import numpy as np -def generate_tracers_xml(data, nens=-1, n_bg_ens=-1, restart=False, runthrough=False, propagate_bg=False): +def generate_tracers_xml(data, + nens=-1, + n_bg_ens=-1, + restart=False, + runthrough=False, + propagate_bg=False): """ Generate an XML representation for chemtracers. @@ -82,58 +87,72 @@ def generate_tracers_xml(data, nens=-1, n_bg_ens=-1, restart=False, runthrough=F # Make a set of ensemble tracers for i in np.arange(nens) + 1: tracer_xxx = ET.SubElement(tracers, - "chemtracer", - id=f"{item_id[:-4]}-{i:03}") + "chemtracer", + id=f"{item_id[:-4]}-{i:03}") ET.SubElement(tracer_xxx, "transport", - type="char").text = "stdaero" - ET.SubElement(tracer_xxx, "oem_type", type="char").text = "ens" + type="char").text = "stdaero" + ET.SubElement(tracer_xxx, "oem_type", + type="char").text = "ens" ET.SubElement(tracer_xxx, "c_solve", - type="char").text = "passive" - ET.SubElement(tracer_xxx, "init_mode", type="int").text = "0" + type="char").text = "passive" + ET.SubElement(tracer_xxx, "init_mode", + type="int").text = "0" if "bg" in item_data: ET.SubElement(tracer_xxx, "oem_bg_ens", - type="char").text = item_data["bg"] + type="char").text = item_data["bg"] if "ra" in item_data and "gpp" in item_data: ET.SubElement( tracer_xxx, "oem_vprm_bg_ens", type="char" ).text = f"{item_data['ra']}, {item_data['gpp']}" if restart: ET.SubElement(tracer_xxx, "oem_restart", - type="char").text = "file" - ET.SubElement(tracer_xxx, "unit", type="char").text = "none" + type="char").text = "file" + ET.SubElement(tracer_xxx, "unit", + type="char").text = "none" if propagate_bg: - tracer_xxx = ET.SubElement(tracers, - "chemtracer", - id=f"{item_id[:-4]}-{nens+1:03}") + tracer_xxx = ET.SubElement( + tracers, + "chemtracer", + id=f"{item_id[:-4]}-{nens+1:03}") ET.SubElement(tracer_xxx, "transport", - type="char").text = "stdaero" - ET.SubElement(tracer_xxx, "oem_type", type="char").text = "ens" + type="char").text = "stdaero" + ET.SubElement(tracer_xxx, "oem_type", + type="char").text = "ens" ET.SubElement(tracer_xxx, "c_solve", - type="char").text = "passive" - ET.SubElement(tracer_xxx, "init_mode", type="int").text = "0" + type="char").text = "passive" + ET.SubElement(tracer_xxx, "init_mode", + type="int").text = "0" if "bg" in item_data: ET.SubElement(tracer_xxx, "oem_bg_ens", - type="char").text = item_data["bg"] + type="char").text = item_data["bg"] if restart: ET.SubElement(tracer_xxx, "oem_restart", - type="char").text = "file" - ET.SubElement(tracer_xxx, "unit", type="char").text = "none" + type="char").text = "file" + ET.SubElement(tracer_xxx, "unit", + type="char").text = "none" else: if item_id.endswith("XXX"): for i in np.arange(n_bg_ens) + 1: - tracer_bg_xxx = ET.SubElement(tracers, "chemtracer", id=f"{item_id[:-4]}-{i:03}") + tracer_bg_xxx = ET.SubElement(tracers, + "chemtracer", + id=f"{item_id[:-4]}-{i:03}") ET.SubElement(tracer_bg_xxx, "transport", - type="char").text = "stdaero" - ET.SubElement(tracer_bg_xxx, "oem_type", type="char").text = "ens" + type="char").text = "stdaero" + ET.SubElement(tracer_bg_xxx, "oem_type", + type="char").text = "ens" ET.SubElement(tracer_bg_xxx, "c_solve", - type="char").text = "passive" - ET.SubElement(tracer_bg_xxx, "init_mode", type="int").text = "0" + type="char").text = "passive" + ET.SubElement(tracer_bg_xxx, "init_mode", + type="int").text = "0" if "bg" in item_data: ET.SubElement(tracer_bg_xxx, "oem_bg_ens", - type="char").text = item_data["bg"] + type="char").text = item_data["bg"] if restart: - ET.SubElement(tracer_bg_xxx, "oem_restart", type="char").text = "file" - ET.SubElement(tracer_bg_xxx, "unit", type="char").text = "none" + ET.SubElement(tracer_bg_xxx, + "oem_restart", + type="char").text = "file" + ET.SubElement(tracer_bg_xxx, "unit", + type="char").text = "none" # Convert to string xml_declaration = "\n\n" xml_string = ET.tostring(tracers, encoding="unicode") From e4964b7dee9a523a96b96eeac3a13f5beb005051 Mon Sep 17 00:00:00 2001 From: efmkoene Date: Fri, 7 Mar 2025 16:53:28 +0100 Subject: [PATCH 33/42] Running the first full year 2018 inversion with added MDM computations --- cases/icon-art-CTDAS/ICON/Get_mdm.ipynb | 1158 +++++++++++++++++ cases/icon-art-CTDAS/ICON/ICON_template.job | 10 +- cases/icon-art-CTDAS/config.yaml | 133 +- .../ctdas_patch/carbontracker_icon_oco2.rc | 14 +- .../ctdas_patch/obsoperator_ICOS_OCO2.py | 6 +- cases/icon-art-CTDAS/ctdas_patch/santis.py | 150 +++ cases/icon-art-CTDAS/ctdas_patch/template.py | 4 +- cases/icon-art-CTDAS/ctdas_patch/template.rc | 2 +- jobs/prepare_CTDAS.py | 2 +- jobs/tools/fetch_external_data.py | 14 - 10 files changed, 1369 insertions(+), 124 deletions(-) create mode 100644 cases/icon-art-CTDAS/ICON/Get_mdm.ipynb create mode 100644 cases/icon-art-CTDAS/ctdas_patch/santis.py diff --git a/cases/icon-art-CTDAS/ICON/Get_mdm.ipynb b/cases/icon-art-CTDAS/ICON/Get_mdm.ipynb new file mode 100644 index 00000000..23142391 --- /dev/null +++ b/cases/icon-art-CTDAS/ICON/Get_mdm.ipynb @@ -0,0 +1,1158 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Beromunster_212\n", + "RMSE for Beromunster_212 (Time: 12:00-17:00): 5.246687084978375\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Bilsdale_248\n", + "RMSE for Bilsdale_248 (Time: 12:00-17:00): 3.7267864090697658\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Biscarrosse_47\n", + "RMSE for Biscarrosse_47 (Time: 12:00-17:00): 4.44391367284266\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Cabauw_207\n", + "RMSE for Cabauw_207 (Time: 12:00-17:00): 4.556938758005444\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Carnsore Point_14\n", + "RMSE for Carnsore Point_14 (Time: 12:00-17:00): 3.9379375857221026\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Ersa_40\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-01 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-11 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-10-28 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-11-07 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-11-17 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-11-27 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-12-07 00:00:00\n", + "RMSE for Ersa_40 (Time: 12:00-17:00): 5.097001363286457\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Gartow_341\n", + "Skipping Gartow_341: Not found in ICON dataset on 2018-10-28 00:00:00\n", + "RMSE for Gartow_341 (Time: 12:00-17:00): 4.34505600864283\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkEAAAGxCAYAAABlfmIpAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAlOpJREFUeJzs3Xd4U/X+B/D3aZM0bTPapJtOaCmUMgvIlA0i0wEOVPiJGxEUvYrbe0W8Kg7cePGi4pWrFwEnskFEZWMZbVkthe6VNG2TtMn5/fFNTpImaZu2dOXzep4+yslJcnIoOe/z+S6O53kehBBCCCFexqe9D4AQQgghpD1QCCKEEEKIV6IQRAghhBCvRCGIEEIIIV6JQhAhhBBCvBKFIEIIIYR4JQpBhBBCCPFKFIIIIYQQ4pUoBBFCCCHEK1EIIl7jr7/+wsKFC9GjRw/4+/vD398fSUlJuP/++3H48OFWf78DBw7gxRdfREVFRau/dkt99dVXuPbaaxEeHg4/Pz9ERUVhxowZOHDgQIPPKywshFqtBsdx+N///ufwWGVlJf72t79h8uTJCA0NBcdxePHFFz0+trvvvhvXXXedw7a3334bN954IxISEsBxHMaOHevyud9++y1uu+02JCYmwt/fH/Hx8Zg3bx7Onj3r0TG8++676NWrF/z8/JCQkICXXnoJtbW1TvsVFRVhwYIFCAkJQUBAAIYPH46dO3c2+X3279+Pe+65B2lpafDz8wPHccjOznbab926deA4zu3Pq6++2qT3O3r0KCZOnAiZTIagoCDceOONuHDhQrPPwXPPPYdBgwbBbDY3+TMT0qHwhHiBjz76iBeJRHyfPn34d955h9+xYwe/c+dO/r333uNHjhzJA+DPnTvXqu/5+uuv8wD4ixcvturrtoZ3332Xf+qpp/j//e9//J49e/ivvvqKHzJkCO/r68vv2bPH7fNuuukmPioqigfAf/PNNw6PXbx4kVcqlfy1117L33PPPTwA/oUXXvDouI4ePcr7+Pjwhw4dctienJzMDxo0iL/77rv50NBQfsyYMS6fP3ToUH7mzJn8p59+yu/Zs4f/4osv+N69e/MymYw/efJkk47h5Zdf5jmO45cvX87v3r2bf+2113iJRMLfe++9Dvvp9Xo+NTWVj46O5tevX89v27aNnzVrFi8SiRo8h/ZefPFFPi4ujp89ezY/duxYt78vRUVF/O+//+70M2nSJB4An5GR0eh7nTlzhpfL5fzo0aP5H3/8kd+4cSPfp08fPioqii8qKmrWOaioqOCDgoL4Tz/9tEmfl5COhkIQ6fL279/P+/j48DNmzOANBoPLfb7++mv+ypUrrfJ+1dXVvNls7tAhyJWKigpeLBbzd955p8vH//e///EymYz/7LPPXIYgs9nMm81mnud5vri4uFkhaO7cufywYcOctptMJuH/+/Tp4zYEFRYWOm27cuUKLxaL+YULFzb6/iUlJbxUKuXvu+8+h+0rVqzgOY7jT506JWx7//33eQD8gQMHhG21tbV8SkoKP3To0Ebfi+cdP5envy86nY6XyWT8qFGjmrT/nDlz+JCQEF6j0QjbsrOzebFYzP/tb38TtnlyDnie5x9++GG+Z8+ewt89IZ0JNYeRLu+VV16Br68vPv74Y0gkEpf7zJkzB1FRUcKfDx8+jFtvvRXx8fFCs8ptt92GnJwch+dZmym2bduGu+++G6GhoQgICMDy5cvxxBNPAIDQhMNxHPbs2QMAMJvNeO2114TmhrCwMNx11124fPmy8Nrvv/8+fHx8UFRUJGxbtWoVOI7DokWLhG1msxnBwcFYtmxZi86TXC6HVCqFSCRyeqysrAyLFi3CihUrEBsb6/L51s/YXIWFhdi0aRPuvPNOp8d8fJr2VRUWFua0LSoqCtHR0cjNzW30+Vu3boVer8f//d//OWz/v//7P/A8j82bNwvbNm3ahOTkZAwfPlzYJhKJcMcdd+DgwYO4cuVKo+/X1M/lyn//+1/odDrcc889je5bV1eHH374ATfddBMUCoWwPS4uDuPGjcOmTZuEbZ6cAwC48847kZWVhd27dzf7sxDSXigEkS7NZDJh9+7dGDx4MCIjI5v8vOzsbCQnJ+Ptt9/GL7/8gn/+85/Iz8/HkCFDUFJS4rT/3XffDbFYjC+++AL/+9//8OCDD2Lx4sUAWD+V33//Hb///jsGDRoEAHjwwQfx5JNPYtKkSfjuu+/wj3/8A1u3bsWIESOE1584cSJ4nnfoY7Jjxw74+/tj+/btwrbDhw+joqICEydObNb5qa2tRXZ2Nh588EHwPO8QsKweeeQRJCQk4OGHH/b4PZpq27ZtqK2txbhx41r1dS9cuICcnBz06dPHYfuLL77oEEwB4OTJkwCAvn37OuwbGRmJkJAQ4XHrvv369XN6P+u2U6dOtdZHcGnt2rVQKBSYM2eOw/bs7GxwHIcFCxYI286fP4+amhq3x3vu3Dno9XoAnp0DAEhLS4NMJsOPP/7YGh+LkDblfMtHSBdSUlKCmpoaxMXFOT1mMpnA87zwZ19fX6GScfPNN+Pmm2922Hf69OkIDw/Hf/7zHzzyyCMOrzVhwgR8/PHHDtusFZOBAwciPj5e2J6RkYE1a9bgoYcewrvvvitsHzhwIK655hq89dZbWLFiBZKTkxEdHY0dO3bgtttug9FoxK+//opHHnkE//znP3Hp0iXExsZix44dEIvFuPbaaz0+P3369EFmZiYAdpHbunUr0tLSHPb58ccf8fXXX+Po0aMtqlw05vfff4e/vz969erVaq9ZV1eHhQsXQiaT4dFHH3V4zMfHx+HvHABKS0vh5+eHwMBAp9dSqVQoLS112FelUrncz/r41ZKRkYEDBw7g/vvvR0BAgMNjHMfB19cXvr6+Dsdqf2z1j5fneZSXlyMyMtKjcwCwfzf9+/fHb7/91hofjZA2RZUg4rXS0tIgFouFn1WrVgmP6XQ6PPnkk0hMTIRIJIJIJIJMJkNVVRXOnDnj9Fo33XRTk9/X2mxgf6cOAEOHDkXv3r0dKj8TJkzAjh07ALDRZtXV1XjssccQEhIiVIN27NiB4cOHu7xoNWbjxo34888/8c033yAlJQVTp051qIxoNBrcf//9ePLJJ5Gamurx63siLy9PGFXWGniex8KFC/Hrr7/i888/R0xMjMPjzz//POrq6jBmzBiH7Q29f/3HmrKv2WxGXV2d8GMymTz9KE7Wrl0LAC6bwuLi4lBXVyfs4+nxerKfVVhYWJOa/wjpaCgEkS4tJCQE/v7+Tn15AOA///kPDh06hO+++87psdtvvx3vvfce7rnnHvzyyy84ePAgDh06hNDQUNTU1Djt70lTm/VO2tVzoqKiHO60J06ciEuXLuHs2bPYsWMHBg4ciLCwMIwfPx47duxATU0NDhw40KymMIBVgoYOHYqbb74ZW7duRVxcHJYsWSI8/swzz0AsFuPhhx9GRUUFKioqoNPpAADV1dWoqKhwqKa1RE1NDaRSaau8Fs/zuOeee7B+/XqsW7cOs2bNatLz1Go19Ho9qqurnR4rKytzqKSo1WqX1Z6ysjIAtqqLtanU+jNhwoTmfCRBbW0tPv/8c/Tv3x+DBw9u0nPUajUA19WpsrIycByHoKAgYd+mngMrqVTq8t8FIR0dNYeRLs3X1xfjx4/Htm3bkJ+f7xA8UlJSAMBpXhaNRoMffvgBL7zwAp566ilhu8FgEC5w9XlSvbBekPLz8xEdHe3wWF5eHkJCQoQ/Wy+YO3bswPbt2zFp0iRh+7PPPot9+/bBYDA0OwTZE4lEGDRoEL7++mth28mTJ5GdnY2IiAin/efPnw8AKC8vFy6gLRESEoKjR4+2+HWsAejf//431q5dizvuuKPJz7X2g0lPT8c111wjbC8oKEBJSYlDNaxv375IT093eg3rNuu+L774okNfKrlc7tkHqueHH35AUVERnnvuuSY/xzo3lrvjTUxMFAKoJ+fAqqyszOH3lpDOgipBpMtbvnw5TCYTHnjgAZcT3tXHcRx4noefn5/D9n/9618eNWVYn1//Dnn8+PEAgPXr1ztsP3ToEM6cOeNQKYiMjERKSgo2btyII0eOCCFo0qRJKC4uxptvvgmFQoEhQ4Y0+bjc0ev1+OOPP5CYmChse/vtt7F7926Hn7feegsAu7jv3r0bMpmsxe8NAL169UJpaSk0Gk2zX4Pnedx7773497//jY8//thphFNjrrvuOkilUqxbt85hu3UU4OzZs4VtN9xwAzIyMvDnn38K2+rq6rB+/Xpcc801wmjD+Ph4DB48WPhJTk5u9ucDWFOYVCrFvHnzmvwckUiEGTNm4Ntvv0VlZaWw/dKlS9i9ezduvPFGYZsn58DqwoULwk0FIZ0JVYJIlzdy5Ei8//77WLx4MQYNGoT77rsPffr0gY+PD/Lz87Fx40YAEIYOKxQKXHvttXj99dcREhKC+Ph47N27F2vXrvWo4mG9o37nnXcwf/58iMViJCcnIzk5Gffddx/effdd+Pj4YOrUqcjOzsZzzz2HmJgYpw68EyZMwLvvvgt/f3+MHDkSABt2n5CQgG3btmHmzJkuh7U3ZMSIEZg5cyZ69+4NpVKJ7OxsfPjhhzh//rzDcOkBAwa4fY0+ffo4zdz8888/o6qqSrjQnj59WphZ+vrrr3fqxGtv7Nix4Hkef/75JyZPnuzw2OHDh4WKnVarBc/zwusOGTJE6Pj+yCOPYO3atbj77rvRt29f/PHHH8Jr+Pn5YeDAgcKf//73v+Pvf/87du7cKfQLUqlUePbZZ/Hcc89BpVJh8uTJOHToEF588UXcc889Dhf6u+++G++//z7mzJmDV199FWFhYfjggw+QmZkp9ONqTHFxMfbu3QvAVkH6+eefERoaitDQUKf+Snl5edi6dStuueUWBAcHu3zNnJwc9OjRA/Pnz3foF/TSSy9hyJAhmD59Op566ino9Xo8//zzCAkJcZhewZNzALAmtrNnzwqjIQnpVNpjciJC2sPx48f5//u//+MTEhJ4Pz8/XiqV8omJifxdd93F79y502Hfy5cv8zfddBMfHBzMy+Vy/rrrruNPnjzJx8XF8fPnzxf2+/e//80DcJrh2Gr58uV8VFQU7+PjwwPgd+/ezfM8myTvn//8J9+zZ09eLBbzISEh/B133MHn5uY6vcaWLVt4APykSZMctt977708AH716tUen4tly5bx/fv355VKJS8SifiIiAj+hhtu4H/77bdGn7t7926XkyXyPM/HxcXxAFz+NDYJoMlk4uPj4/mHHnrI6bH58+e7fd1///vfTXr/uLg4h9d84YUXHP5O7L3zzjt8z549eYlEwsfGxvIvvPACbzQanfYrKCjg77rrLl6lUvFSqZQfNmwYv3379gY/pz3ruXT142pCyBUrVvAA+F27drl9zYsXL/IAHH5PrQ4fPsxPmDCBDwgI4BUKBT979my3M6U39RysXbuWF4vFfEFBQZM/NyEdBcfzrdSrkRBCWmjVqlVYsWIFrly5An9///Y+HNIEo0ePRmxsLL788sv2PhRCPEZ9ggghHcaiRYugVCrx/vvvt/ehkCbYt28fDh06hH/84x/tfSiENAuFIEK6EJPJ5DAnTf2f1pij5mqSSqX44osvnDqlk46ptLQUn3/+Obp3797eh0JIs1BzGCFdyNixY4WOtq7ExcU5TQlACCHeikIQIV1IZmamwxDo+vz8/JzWhCKEEG9FIYgQQgghXon6BBFCCCHEK3XKyRLNZjPy8vIgl8tbbbFFQgghhFxdPM+jsrISUVFR8PFp/zpMpwxBeXl5TitCE0IIIaRzyM3NdVo7sT10yhBkXYAwNzdXWOqAEEIIIR2bVqtFTExMixcSbi2dMgRZm8AUCgWFIEIIIaST6ShdWdq/QY4QQgghpB1QCCKEEEKIV6IQRAghhBCv1Cn7BBFCCCGtief5TrG+XmcgFovh6+vb3ofRJBSCCCGEeDWj0Yj8/HxUV1e396F0CRzHITo6GjKZrL0PpVEUggghhHgts9mMixcvwtfXF1FRUZBIJB1m5FJnxPM8iouLcfnyZSQlJXX4ihCFIEIIIV7LaDTCbDYjJiYGAQEB7X04XUJoaCiys7NRW1vb4UMQdYwmhBDi9TrCEg5dRWeqpNHfOiGEEEK8EoUgQgghhHglCkGEEEII8UoUggghhJBOaMGCBZg9e7bw54KCAixevBjdu3eHn58fYmJiMGPGDOzcudPheQcOHMD111+P4OBgSKVS9O3bF6tWrXKaI4njOEilUuTk5Dhsnz17NhYsWHC1PlabohBECCGEdHLZ2dlIS0vDrl278NprryE9PR1bt27FuHHjsGjRImG/TZs2YcyYMYiOjsbu3buRkZGBJUuWYMWKFbj11lvB87zD63Ich+eff76tP06boSHyhBBCSCf30EMPgeM4HDx4EIGBgcL2Pn364O677wYAVFVV4d5778XMmTOxZs0aYZ977rkH4eHhmDlzJr7++mvccsstwmOLFy/GqlWr8Pjjj6Nv375t94HaCFWCCCGEkE6srKwMW7duxaJFixwCkFVQUBAAYNu2bSgtLcXjjz/utM+MGTPQs2dPfPXVVw7bR4wYgenTp2P58uVX5djbG1WCCCGEEFcefBC4cqXt3q9bN+DDDz1+2rlz58DzPHr16tXgfllZWQCA3r17u3y8V69ewj72Vq5ciX79+uHXX3/F6NGjPT6+joxCECGEEOJKMwJJe7D242nqJIX1+/3Yb3f1GikpKbjrrrvw5JNP4sCBA80/0A6ImsMIIYSQTiwpKQkcx+HMmTMN7tezZ08AcLtfRkYGkpKSXD720ksv4dixY9i8eXOLjrWjoRBECCGEdGIqlQpTpkzB+++/j6qqKqfHKyoqAACTJ0+GSqXCqlWrnPb57rvvcPbsWdx2220u3yMmJgYPP/wwnn76aaeh9J1Zi0LQypUrwXEcli5dKmzT6XR4+OGHER0dDX9/f/Tu3Rsf1ispGgwGLF68GCEhIQgMDMTMmTNx+fLllhwKIYQQ4rU++OADmEwmDB06FBs3bsTZs2dx5swZrF69GsOHDwcABAYG4uOPP8aWLVtw33334a+//kJ2djbWrl2LBQsW4Oabb8bcuXPdvsfy5cuRl5eHHTt2tNXHuuqaHYIOHTqENWvWoF+/fg7bH330UWzduhXr16/HmTNn8Oijj2Lx4sXYsmWLsM/SpUuxadMmbNiwAfv374dOp8P06dO7VLokhBBC2kpCQgKOHj2KcePGYdmyZUhNTcWkSZOwc+dOh0LEzTffjN27dyM3NxfXXnstkpOT8eabb+KZZ57Bhg0bGuxXpFKp8OSTT0Kv17fFR2oTHO+uh1QDdDodBg0ahA8++AAvv/wyBgwYgLfffhsAkJqailtuuQXPPfecsH9aWhquv/56/OMf/4BGo0FoaCi++OILYS6CvLw8xMTE4KeffsKUKVMafX+tVgulUgmNRgOFQuHp4RNCCCEAAL1ej4sXLyIhIQFSqbS9D6dLaOicdrTrd7MqQYsWLcK0adMwceJEp8dGjRqF7777DleuXAHP89i9ezeysrKEcHPkyBHU1tZi8uTJwnOioqKQmprqtte5wWCAVqt1+CGEEEIIaQmPh8hv2LABR48exaFDh1w+vnr1atx7772Ijo6GSCSCj48P/vWvf2HUqFEA2NomEokEwcHBDs8LDw9HQUGBy9dcuXIlXnrpJU8PlRBCCCHELY8qQbm5uViyZAnWr1/vtmy4evVq/PHHH/juu+9w5MgRrFq1Cg899FCjHanczU8AsM5YGo1G+MnNzfXksAkhhBBCnHhUCTpy5AiKioqQlpYmbDOZTNi3bx/ee+89aDQaPP3009i0aROmTZsGAOjXrx+OHz+ON954AxMnTkRERASMRiPKy8sdqkFFRUUYMWKEy/f18/ODn59fcz4fIYQQQohLHlWCJkyYgPT0dBw/flz4GTx4MObNm4fjx4/DZDKhtrYWPj6OL+vr6wuz2QyAdZIWi8XYvn278Hh+fj5OnjzpNgQRQgghhLQ2jypBcrkcqampDtsCAwOhVquF7WPGjMETTzwBf39/xMXFYe/evfj888/x5ptvAgCUSiUWLlyIZcuWQa1WQ6VSCavTuupoTQghhBByNbT62mEbNmzA8uXLMW/ePJSVlSEuLg4rVqzAAw88IOzz1ltvQSQSYe7cuaipqcGECROwbt06+Pr6tvbhEEIIIYS41Kx5gtpbR5tngBBCSOdE8wS1vi4/TxAhhBBCSGdHIYgQQgghXolCECGEENIJLViwALNnzxb+XFBQgMWLF6N79+7w8/NDTEwMZsyYgZ07dzo878CBA7j++usRHBwMqVSKvn37YtWqVU7rd+7evRvjxo2DSqVCQEAAkpKSMH/+fNTV1bXFx2sTFIIIIYSQTi47OxtpaWnYtWsXXnvtNaSnp2Pr1q0YN24cFi1aJOy3adMmjBkzBtHR0di9ezcyMjKwZMkSrFixArfeeius3YRPnTqFqVOnYsiQIdi3bx/S09Px7rvvQiwWC1PedAWtPjqMEEIIIW3roYceAsdxOHjwIAIDA4Xtffr0wd133w0AqKqqwr333ouZM2dizZo1wj733HMPwsPDMXPmTHz99de45ZZbsH37dkRGRuK1114T9uvRoweuu+66tvtQbYBCECGEEFKPXq/HuXPn2vQ9ExMTmzVCraysDFu3bsWKFSscApBVUFAQAGDbtm0oLS3F448/7rTPjBkz0LNnT3z11Ve45ZZbEBERgfz8fOzbtw/XXnutx8fUWVBzGCGEENKJnTt3DjzPo1evXg3ul5WVBQDo3bu3y8d79eol7DNnzhzcdtttGDNmDCIjI3HDDTfgvffeg1arbd2Db2dUCSKEEELqkUqlTiskdFTWfjzuFiF3t7+r7dbX8PX1xb///W+8/PLL2LVrF/744w+sWLEC//znP3Hw4EFERka2zsG3M6oEEUIIIZ1YUlISOI7DmTNnGtyvZ8+eAOB2v4yMDCQlJTls69atG+688068//77OH36NPR6PT766KPWOfAOgEIQIYQQ0ompVCpMmTIF77//Pqqqqpwer6ioAABMnjwZKpUKq1atctrnu+++w9mzZ3Hbbbe5fZ/g4GBERka6fI/OikIQIYQQ0sl98MEHMJlMGDp0KDZu3IizZ8/izJkzWL16NYYPHw6ALXj+8ccfY8uWLbjvvvvw119/ITs7G2vXrsWCBQtw8803Y+7cuQCAjz/+GA8++CC2bduG8+fP49SpU3jyySdx6tQpzJgxoz0/aquiPkGEEEJIJ5eQkICjR49ixYoVWLZsGfLz8xEaGoq0tDR8+OGHwn4333wzdu/ejVdeeQXXXnstampqkJiYiGeeeQZLly4V+gQNHToU+/fvxwMPPIC8vDzIZDL06dMHmzdvxpgxY9rrY7Y6WkCVEEKI16IFVFsfLaBKCCGEENLBUQgihBBCiFeiEEQIIYQQr0QhiBBCCCFeiUIQIYQQr9cJxwh1WJ3pXFIIIoQQ4rXEYjEAoLq6up2PpOswGo0A2NIbHR3NE0QIIcRr+fr6IigoCEVFRQCAgICAJq/BRZyZzWYUFxcjICAAIlHHjxgd/wgJIYSQqygiIgIAhCBEWsbHxwexsbGdIkxSCCKEEOLVOI5DZGQkwsLCUFtb296H0+lJJBL4+HSO3jYUggghhBCwprHO0I+FtJ7OEdUIIYQQQloZhSBCCCGEeCUKQYQQQgjxShSCCCGEEOKVKAQRQgghxCtRCCKEEEKIV6IQRAghhBCvRCGIEEIIIV6JQhAhhBBCvBKFIEIIIYR4JQpBhBBCCPFKFIIIIYQQ4pUoBBFCCCHEK1EIIoQQQohXohBECCGEEK9EIYgQQgghXolCECGEEEK8EoUgQgghhHglCkGEEEII8UotCkErV64Ex3FYunSpw/YzZ85g5syZUCqVkMvlGDZsGC5duiQ8bjAYsHjxYoSEhCAwMBAzZ87E5cuXW3IohBBCCCEeaXYIOnToENasWYN+/fo5bD9//jxGjRqFXr16Yc+ePThx4gSee+45SKVSYZ+lS5di06ZN2LBhA/bv3w+dTofp06fDZDI1/5MQQgghhHiA43me9/RJOp0OgwYNwgcffICXX34ZAwYMwNtvvw0AuPXWWyEWi/HFF1+4fK5Go0FoaCi++OIL3HLLLQCAvLw8xMTE4KeffsKUKVMafX+tVgulUgmNRgOFQuHp4RNCCCGkHXS063ezKkGLFi3CtGnTMHHiRIftZrMZP/74I3r27IkpU6YgLCwM11xzDTZv3izsc+TIEdTW1mLy5MnCtqioKKSmpuLAgQMu389gMECr1Tr8EEIIIYS0hMchaMOGDTh69ChWrlzp9FhRURF0Oh1effVVXHfdddi2bRtuuOEG3Hjjjdi7dy8AoKCgABKJBMHBwQ7PDQ8PR0FBgcv3XLlyJZRKpfATExPj6WETQgghhDgQebJzbm4ulixZgm3btjn08bEym80AgFmzZuHRRx8FAAwYMAAHDhzARx99hDFjxrh9bZ7nwXGcy8eWL1+Oxx57TPizVqulIEQIIYSQFvGoEnTkyBEUFRUhLS0NIpEIIpEIe/fuxerVqyESiaBWqyESiZCSkuLwvN69ewujwyIiImA0GlFeXu6wT1FREcLDw12+r5+fHxQKhcMPIYQQQkhLeBSCJkyYgPT0dBw/flz4GTx4MObNm4fjx4/Dz88PQ4YMQWZmpsPzsrKyEBcXBwBIS0uDWCzG9u3bhcfz8/Nx8uRJjBgxohU+EiGEEEJI4zxqDpPL5UhNTXXYFhgYCLVaLWx/4okncMstt+Daa6/FuHHjsHXrVnz//ffYs2cPAECpVGLhwoVYtmwZ1Go1VCoVHn/8cfTt29epozUhhBBCyNXiUQhqihtuuAEfffQRVq5ciUceeQTJycnYuHEjRo0aJezz1ltvQSQSYe7cuaipqcGECROwbt06+Pr6tvbhEEIIIYS41Kx5gtpbR5tngBBCCCGN62jXb1o7jBBCCCFeiUIQIYQQQrwShSBCCCGEeCUKQYQQQgjxShSCCCGEEOKVKAQRQgghxCtRCCKEEEKIV6IQRAghhBCvRCGIEEIIIV6JQhAhhBBCvBKFIEIIIYR4JQpBhBBCCPFKFIIIIYQQ4pUoBBFCCCHEK1EIIoQQQohXohBECCGEEK9EIYgQQgghXolCECGEEEK8EoUgQgghhHglCkGEEEII8UoUggghhBDilSgEEUIIIcQrUQgihBBCiFeiEEQIIYQQr0QhiBBCCCFeiUIQIYQQQrwShSBCCCGEeCUKQYQQQgjxShSCCCGEEOKVKAQRQgghxCtRCCKEEEKIV6IQRAghhBCvRCGIEEIIIV6JQhAhhBBCvBKFIEIIIYR4JQpBhBBCCPFKFIIIIYQQ4pUoBBFCCCHEK1EIIoQQQohXohBECCGEEK9EIYgQQgghXolCECGEEEK8UotC0MqVK8FxHJYuXery8fvvvx8cx+Htt9922G4wGLB48WKEhIQgMDAQM2fOxOXLl1tyKIQQQgghHml2CDp06BDWrFmDfv36uXx88+bN+PPPPxEVFeX02NKlS7Fp0yZs2LAB+/fvh06nw/Tp02EymZp7OIQQQgghHmlWCNLpdJg3bx4++eQTBAcHOz1+5coVPPzww/jyyy8hFosdHtNoNFi7di1WrVqFiRMnYuDAgVi/fj3S09OxY8eO5n0KQgghhBAPNSsELVq0CNOmTcPEiROdHjObzbjzzjvxxBNPoE+fPk6PHzlyBLW1tZg8ebKwLSoqCqmpqThw4IDL9zMYDNBqtQ4/hBBCCCEtIfL0CRs2bMDRo0dx6NAhl4//85//hEgkwiOPPOLy8YKCAkgkEqcKUnh4OAoKClw+Z+XKlXjppZc8PVRCCCGEELc8qgTl5uZiyZIlWL9+PaRSqdPjR44cwTvvvIN169aB4ziPDoTnebfPWb58OTQajfCTm5vr0WsTQgghhNTnUQg6cuQIioqKkJaWBpFIBJFIhL1792L16tUQiUTYs2cPioqKEBsbKzyek5ODZcuWIT4+HgAQEREBo9GI8vJyh9cuKipCeHi4y/f18/ODQqFw+CGEEEIIaQmPQtCECROQnp6O48ePCz+DBw/GvHnzcPz4cSxYsAB//fWXw+NRUVF44okn8MsvvwAA0tLSIBaLsX37duF18/PzcfLkSYwYMaJ1Px0hhBDSBWzevLm9D6FL8qhPkFwuR2pqqsO2wMBAqNVqYbtarXZ4XCwWIyIiAsnJyQAApVKJhQsXYtmyZVCr1VCpVHj88cfRt29flx2tCSGEEG939uzZ9j6ELsnjjtGt4a233oJIJMLcuXNRU1ODCRMmYN26dfD19W2PwyGEEEI6tOLi4vY+hC6J43meb++D8JRWq4VSqYRGo6H+QYQQQrq8BQsWYN26de19GC3W0a7ftHYYIYQQ0sHVH0xEWgeFIEIIIaQDMxqNEInapfdKl0chiBBCCOnAOkrTUVdEIYi0r19/be8jIISQDk2r1SIoKKi9D6NLohBE2o9eD/z97+19FIQQ0qFpNBoolcr2PowuiUIQaT8VFSwIEUIIcYuaw64eCkGk/ZSXAzU17X0UhJCuymgETp5s76NosZZUgkpKSlr5aLoWCkFdWIefAqq8nCpBhJCrJysL+Pjj9j6KFqupqYG/v3+znvvdd9+18tF0LRSCuqjKykr897//bb8D4Hngm28a3ocqQYSQq6m8nFWDOjme58FxXLOeq9VqW/louhYKQV1UZWUlsrKy2vMAgA8/bHgf6hNECLmaysuB2tr2PopW05zqPoWghlEI6qJ0Oh00Gk37HUBZGVBWhvT0dPf7UHMYIeRq6iKVII7jIJFIYGzGZ6EQ1DAKQV2UTqeDXC5vvwOwhKA1a9a436e8HBCL2+6YCCHepYuEIADw8/ODwWDw+HkUghpGIaiL0ul0kMlkwAMPtOn7CuXasjIYy8pw5coV9zuXlwPBwaz/ECGEtLaKii7THNbcEKTRaDr+IJl2RCGoi9LpdAgJDkbNH3+06ft+Nn8++JISoLwcx6qqMLBfP/c7l5cD4eFd5k6NENLBUCUIdXV1qKuruwpH1DVQCOqidDodUuPikN3G/YLy09NR8ddfQFkZzimV6BEe7n7nigogIoL6BRFCro4uFIKkUmmzQpBUKkUNjcJ1i0JQF2UymZAUFIQLVVVt+r7V1dUoyMxkfYLCw8E19P4mEyCX0zB5QsjVodEAfn7tfRStormVIH9/f+jpRtMtCkFdmLK2Fppm/KNpiWCzGQXnzwNlZeAiIoDGQphUSpUgQsjVYTYDPl3jMufn59esMNPc53mLrvHbQVwrLUVOG4egUJMJxbm5qCspgW9EBEQ1NQ23R/v7UwgihFwdHNdlBl60pBJEzWHuUQjqykpLEd/GHeJEZjNM5eXIz89HVHIypAZDw3chUik1hxFCiAtGoxHffPMNYmNj3Yagbdu2oaioyO1rUHNYwygEdWVlZWweHpOp7d5ToQA0GlzS6RDbqxeker3ru5e6OsDXlypBhJCrq5nLTXQEP/74I8aOHYuRI0e6DUHFxcUNLpLa6I2ol6MQ1JWVloIPDm7bkCEWg6+txRW9Ht0SEyGtqXH9D7CiAggKokoQIeTqMBgAiaRTN4fV1NQgJCQEgPvmsIqKCpSXl7t9DenmzajR6a7aMXZ2FIK6srIyQK1uu5BhNgv/W2c2QxQWBml1tWMIslalrBMlUsdoQsjVYL3R6sxqasBZQpy7ECQSiRoMQf4mE/RlZVftEDs7CkFdWWkpuLasBOl0LNRYqVTw0+kcQ9B117H/WkMQNYcRQpqjpATYuNH949bvmE7cHIatW9kPWNhxNchELpejsrLS7UtI6+qgLy29aofY2VEIagUnT55s70NwrboakMnarhJUWclCjZ8f64skl0Oq19tCkF4P7NrFhs2XlLAqFTWHEUKaIzMT2LvX/ePWENSJcTU1QFYW+383YY7juAaXxZDW1VElqAEUglrB008/DbNdU1CHIpG0XaVFqwX8/eEbHAxTQADAcZD6+NhCUHY2+29WFnDqFJCSQpUgQkjzFBU1fAPVBUIQbxeC3HEXjoTHa2vBU58gtygEtQKFQtFgObJdicVtVmnhtVpw/v4I7dYNekuzmEMIunABuOYadgf3119A375UCSKENE9hYcPfHRUVnT4EoaaGfW82gOf5hoOQ0chaBYhLFIJaQXBwcIMd09pVG1aCqouKEKBUIjwhAd0iIwEAUrMZ+uefB3bvBs6fB6ZOZSHI2mm7M1SCdu9u7yMghNTXWAgqL7d1jO6sI8QMhibNeN3gKvFGY+Mz93sxCkGtQKVSocy+zfWppxxGSrWL2loWgDytBNXWCh3xPKUrKYEsKAi9Z87ExLvuAgBIp06FfuBAYNs2dkczdSpw8iQ7LqBzVIJefLG9j4AQUl9hoe0G6vBhFhjsWZvDRCI2L1lnxPNAYGCzKzkmkwk+HOdxCHrttdfw3//+t+Fw1UVQCGoFDpUgvR545x2gHXvjm81mtnCpSgVIJOA9+Qd07hzw9tvNel9dSQlkKhV8UlMhGTsWACB+7DHUjhjBmr+ys4F+/dj/9+rFntQZKkElJZ33S5SQrqqoyHazuWYN++6yZw1BEkmnXUme4zggKcn5s9kzm+GuMazWYIBYLm88BH32GbsBtoiJicH111/faH+jroBCUCsIDg62VYL272dVjvz8djue6upqBJrNgFoNv8BAGJrYX8loNEL/119AQUGz3ldXWgqZWu2wjeM4Vs4Vi9noMYkEiIxkYQjoHPMEVVdTOZmQjsZotFWUq6udbzytfYIkEocLfKeTnOy2czTP86xyn5Hh8vHaykpIVKrGv79WrgT27XN4Xblc3uxD7kwoBLWQwWCATCZDrfUf2fbtwJw5zQ4SrUGn00FmNgNKJQJkMlRrNM47ZWayeX3sZGRkYPfPPze7iqUrL4csNNRpO8/zwNChtokShwwB0tLY//v7d/zmsKoqCkGEdCB1dXWOTTWuQpC1T5BY3GkrQQCAnj2B9HSXD+n1evjr9WxkrgvGykpI1GrXzWlHjwJffcWaEX19gS1bADTSv6gLohDUQgUFBYiIiLBtOHECmDKl/UMQxwGBgfCXy11Pmf7KK8ChQw6bqqqqkHX6NBAX16z1xiorKiAPC3P94KhRQPfu7P9fe43d3QCdoxJUVeUUGAkh7Wfnzp3Is795qq5mzdb26upYAOqkzWG1tbXw5Th2A/nbb6yyVU9FRQWCTCZAp3MZXoxaLSTuJszNzga+/57dEM+YwapJPA+tVgulUtn6H6iDohDUQgUFBYiMjGTNPnV17KIeFdX+IQgAAgMRIJej2tVdwv797E7JTnV1NZtPIjm5WdUgnUaDQHchaPRo4I032P/btzN39I7RZjM1hxHSwRgqK6G1HzXlqhJk1Umbw7SlpVD4+bEqzfLl7Ma1noqKCgTV1cHfaESNi+9RY2UlxP7+rt+gqgr44w82Z1ufPsCAAcDBgygsLHS8se/iKAS1UH5+PiIiIlgKr6hgnZEjItq1T1BlZSVkPA8EBMBfoUBN/Qt4QQGg0TiFoCqdDgEiETv+wkKP37e2qgoSy2J/TjjO9ZwdUin2Xb7ctDc4dQrIyfH4uFrE+sVClSBCOgxjcTG0CoVtQ1VVwyGoE1aCtPn5torMhAnA6dNO+2g0GgQZDAiurXU5TUttVRUk/v6ulw6xNvPv3s1C0KOPAsuXo+DsWYSHh7f2x+mwKAS1UM2BAwiwBgbraISIiPavBJnNQEAAApRK5+aw334Drr/euRKUlwd/lQp8WFjzjl+vBzzsTFdQUoLPL12CxlW/pfo++gjYudPz42oJa1s6hSBCOgxjSQm0gYG2DRKJ+xDUEfsEWWfPb4AmPx9K+xtHF/MFVVRUQKnXQ+UmBBkrKyEJDHQ9T1JVFTB+PPDNN2y0bmQk8M9/oujppxHmYqHWropCUEtt3gzccQf7B2gNQTJZu140tVot5GYz6xOkVKK6fiVo/35g+nSnEMRfuYLI5GQUSaXNqgTBZGJzcnjghx9+wMpevXDgwIHGd/71V+DSJc+PqyWqqgClkprDSOvS62kW3xaoKy+H1n6x5uBgNgGrlclkCw3t0RxmNDY8QePs2UBxsduHCwoKoCkshFKlsm3083MKcxqNBgo/PwRXVzvOVWc9DJ0O4oAA9of6x1NVxSpMajUQEICqqirUDRyI2gULILnvvsY+YZdBIail5HJWVamocJyhtB3V1dVBpNezSlBwsHNzWFYWMGyYUwhCWRl6DxyIMzU1zQpBzZlRIjAwEKF+fihtrA9ScTGrsLVHCAoLo0oQaV0//QR8+ml7H0WnJa6qgiEw0DYRokjkOJijosL2XdwezWFPPcXmLnKnoAD45ReXD9XV1eGll16CpqgISvvuBeHhrBuDHbPZDF+pFME877o5rLoakoAAFqDqh+6qKraM0dKlAIAtW7bgt99+Y9+zMlmzBsd0RhSCWoLnWV8gtZrNgdOctWrMZuDKlVY+LJ79wgcEwD8oCNX2HebMZnaHpFI5hyCdDlGJifiruLhVm/PcTbhlNpuFxxodlrlvH3DjjQ3ePV0VFILI1VBd3faBviuprAQnk7kfWGG/eGp7NIdlZgL/+5/LEV0wmYAePdzOzH/x4kVIJBJUlZcj0H7eNRchyCrA1xdaFwNgjFVVrDksMND5WKxV7ocfBsC+g3Nzc9ljkZHt2qWjLVEIagnrZF0hISwE2f/Da+qop0OHgCefbLVDKiwsZJ3aqquBwECIFQoY7YdH5uQA8fHsH0X9C7tOB06thn9oqOeVIKMRvIeziwrHCkAmk0HXUNDYswcYN86zY2oNVVXsy4eaw0hrqqkBrBcc4jmjkVU3/P3Zd1397x77G9K2rgSZzex4Hn0U+OQT58eLi4HevVkXChfVltOnT2PChAm4cuUKOPuh6i5CkPUmkvPxcT1EvqoKEpmMfd/Xv+mtqmLbXYmN9ZqQTiGoBUwaDXz9/YGQEIirq1FbUiL8w9OqVKhrSoXn8OFW/TL8/fffMXz4cPYLHhAAzt/f8Qvg5EkgNdX1aAGdDlCrERga6vwPpjGHD9vmAarHXZXn8uXLiI6OBgDERUcjt6F/dBcuAImJ1hdk/YPaQnU1+/KhShBpTXq911xkrgbOYGA3mv7+7LvKOgLKuoyGfdeEtu4TdPYsm+AwNdX1aNbCQtbklJYGHDvm9LBOp8OECRNwMCPDcaBJ/RDE86izTnQIttRFbr1ribG6GmJrJchVCLL0FyooKEB4eDhEIhGb+JdCEGmK3KwsxISEACEhCDYaUZ6fL/zDeyUjAzkufsGduFr4D2iwU51Wq8WOHTtcPqbT6SCTyYTmMIjFjncb1hDk+smsmcyTio5GA95gwAvPP4/QYcMa3X3btm3C/9uHIPXHH6P0229dP4nn2TFxHBAaCuTlsY7dbTG/EDWHkatBr6dKUAvwBgMLN/7+rKISEMC+e61NPvZV+bauBB09CgwaxEKLqyalwkL2WO/eLDDVw3EcAgMDESwSAfbTAERE2EJQeTn0CxbAz2xm+/j6YvTw4dh3220Or1VbU8MqQUql87Ho9SxIAvjjjz8wbNgwDBo0CPn5+RSCSNOcy8hAYlQUEBIClcGAsqIiIDgYx48fR68ePaBtypdcYSG7yNqtOr/zvffwQf/+bp9SUFCAXbt2uXzMxzoiwtIc5uTkSTYnBOAcdvR69+VRd559FlXPP4/BVVWY+NBDje7+r3/9y+7t9PC3VKrUv/2GshMnXD8pJ4fNYg0AMTGsrV0kYrNz2/vmm5bf8T31lGMopeYwcjXU1LB/87Qwb/MYDKw5TCq1haCQENsw+fbsE2QNQfVHc2VmsqHxBQXsO6VHD+D8ebcvs2jgQPeVoPR0/Pr77xidmspCUHAwRJcugTt+3OE1jNXVkMjl7Ny4CjWWa0B1dTVkMhmSkpIwe/ZsCkFNtXLlSnAch6WW3uW1tbV48skn0bdvXwQGBiIqKgp33XUX8vLyHJ5nMBiwePFihISEIDAwEDNnzsTlpk6Y14EU5+cjNDQUUKuhqqpCmaU57OTJk5g8ejQ09T63E2s5Mjxc6INTlJkJzccfI7iBnvklJSUIsJQxr7hrcrNbXNChY7JGAwQFYePGjSitP4zTWm0B2D8+V5367PE8kJmJoiNHEAawu7IGmM1mKBQKFNS/I+E4BK5aBd3Fi66faF+9io0F1q0DFi1iVTTYNbetWdOyjtM8z9bSWbLEto0qQeRq0OtZ83E7Tqraqfz8M/DFF7Y/G43g61eC1GpbCKrfJ6gtm8PS023LAllVVrI1Jb/+2tYc5iIEme1uhvsFBDhWgsLDwVtD0F9/oaCkBBFSqRCCcOAAuKoqh89q1OshlsnAq9UNTjQr9C3iOCQnJwPdugGd8JrcHM0OQYcOHcKaNWvQz7oaOFiaPHr0KJ577jkcPXoU3377LbKysjBz5kyH5y5duhSbNm3Chg0bsH//fuh0OkyfPh2mTjYkj9frwcnlgFiMKLEYVyorAT8/+Pj4QBkfD00jvesv/vQTinr2ZBd2S9WoaMcOJM6cySoybtbUKsnMRI/aWlRUVGDZsmXCdpPJZKsEAc6VntpaYR6fzMxMZPO8Y4XDPhD17+9caakvMxPo1QtF8+cjbNq0hvcFm117xowZOHLkiOMD774LbupU93fFJ08Cffuy/4+NZSXkBx4ADh9GTk4Ovv/+e/ZYSQlQVNTocbil17Mho1qt7XWqqrAlM5PmdCGtq6aG9RvxkrvtFisrc+gPw9XWspu8+iHIun5YezWH/fgjqwJZ+ukIXngBePFFFpAszWH7Tp92ulG+dOkSYmNj2R8qKx0rQf7+4Kyf46+/4BMUxM6LQsG6Mfz2G9vfbg013mCAT2AgOLUavCfNr2Kx11QpmxWCdDod5s2bh08++QTBdkPClUoltm/fjrlz5yI5ORnDhg3Du+++iyNHjuCS5R+7RqPB2rVrsWrVKkycOBEDBw7E+vXrkZ6e7rafi8FggFardfhpc9XVwN/+5rhNr2fzKQCQcBxq7VJ8QEwMqhuZ++bkjh3YbTazJh7LL2jJpUtQx8Wxvi9ukrvu1ClMrqzEa6+9hpSUFKESkpeXh6ioKPdvWFDA1jUDEB4ejksc574DdFNC0E8/AdOmoUipRNijjza8L4Bz584hLS3NeXboxEQW2Fy1WwPsi8PahBcTw9Yhi4oCiopw8uRJ2yRhxcUtqwRZ7x5jYmx3lNXV+C0z06G5kpAW0+spBHmiqsqhmZq39hP092dBIDDQuTnM2jG6rZrDqquBVauAZ5+1bbNOnJuVBdxwAzsuS3OYXKFAXr0b3dzcXFsI0modK0EA/Hx8oNfrgStX4JOQAJw7Z6sE7d8PpKQ4juw1GgF/f0hlMhjq9T3Vm0woaslNYxfRrBC0aNEiTJs2DRMnTmx0X41GA47jEGT5hTxy5Ahqa2sxefJkYZ+oqCikpqa6nTV45cqVUCqVwk9MTExzDrtlsrKAP/902MQZDEIIsuJ5HhzHgQsLY7/EDai8eBHGsDB20bV8GZbm5UGdkMCaYC5ccPk8TqOBWq+HQqHA4MGDhVBx8eJFJCQkuH/DoiLW9AbA398fNVKpLQTV1Ql3LxKJBMaUlEZD0MkffgDGjEF1dTUCm9CXqLGQxsXHu35P+9J2cjLw73+z/w8MhKawEBKJhFWx6lWCDh06hKeeegrGpn4BWidYCw62nZeqKpxtrFmTEE9ZK0HUObppqqtdDyCx7xOUkmIbbdUelaCXXwaWLRNGXAFwXEKJ49h3bGkpoFQiKioKV8xm9rvw008AHKcNcTWEPUgigaa8nE1HolIBZ87YKkEXLwJJSeDtQ1BtLSCVQiqVoqZeS8vF6mps377dYb42B66mUemCPA5BGzZswNGjR7Fy5cpG99Xr9Xjqqadw++23Q2FJtAUFBZBIJA4VJIBVJpz6ilgsX74cGo1G+Kk/DLBNZGQ4TMvO87xDJQg+PgDPo7i4mPUTkssbH71UUgIuJMShOcxQXg5pdDSrBLnpI8NbZqd+6qmnoFKphEpIo5WgoiIgLAw1NTWQSqWOwybLy4V/cCqVCmUSCfvHazC47rfA81h97hwglTY60aH9hIg+Pj7w9fVFYWGh0z88PjYWqNexD2azY2mZ49gXC8D6CVn7ROl0rJJkVwk6e/YsZs6c6dQnzS3r3aNKZfu7rqpCc4rCGzZsaMazOh6npkvSOqgS5Jl6lSCBfXNY795skVGeZ/9+rX0U26JP0KlT7Ka1freAiAj2mHXSw549WYWf4xAaGorioCA20OOuu4Bdu2A0GuHn58c+Q02NU5cGZUAAKg4fRnVMDALDw9l1yVoJ6tkTgRERqLK/PloqQXq9HoW+vg6hptRoRF5eHoqLixEWFub8mUaObLxfaBfgUQjKzc3FkiVLsH79enYRbUBtbS1uvfVWmM1mfPDBB42+trWC4oqfnx8UCoXDz1VVV2er4libQTIyHH6Bqqqq2Ert1qQeFARwnK0a05Rh5jyPyG7dkO/ra7sj1GpZAAoPB+9u5IB1iQ4AarVaWHLCbDbDt35bNAAholhGomVkZKBXr16OIchaUgYLQaWlpagwm1H7yCPAM884H0NODsrEYtQ0YZh6/ZA0Z84cbN68mY0Msxcd7bxSsnU4qSsxMUB5Ofu9KSlBTc+eTn2C4uLikNPUleftK0GWEGTQauEfGAhTYzNa17OzrRd6vUp+bav5mLyNXs8mLfWSWXlbrF4lyPrtykulrAIcEMC+cxMTWaV4xAjbc692cxjPswlv33jD+bGICDbbfc+e7M99+wo3zj4+PuBDQ4HnnmNLaKxYYeuHc+AAm0eonqAbbkDF3/+OikGDEBQba6sEBQcDKSlQx8ai1H5xVqMRkEoxbNgwFCgUttBtMqG0rg5BQUEOU5U4WLyYfSd3cR6FoCNHjqCoqAhpaWkQiUQQiUTYu3cvVq9eDZFIJHRsrq2txdy5c3Hx4kVs377dIbRERETAaDQ6rXNSVFRkKwO2t+xs4Pnn2f8/9BDrk5KRwb60LMrKyhDMcbZKUEgIJDIZzp0717TmOr0enFiMYcOG4Y8TJ2ydoC1z9cgTEqA7d871c+361NhXgtyyXsAtlaBz584hKSnJOQRZOuGp1WqUlZXhZ5EIX5w/7/KLWvfbb0jt06fpAcOOj48P7r//fsyaNcthOyeXO68EnZvLKmUumCIj4WM9/uJivFJTg5p6VavIyEg274W9//yHjTapz9rsZrekSF5pKXr16YNKDzsJuqtqdjalpaWo85IOkm3KbGaVio62unlHVS8E8QCkUikMIpGtEgSwSsxjjwELF9qee7Wbwz7/nC1E6iowWEOQdbRYv36ON3Xh4UBSEgs806ezaw0AvPeesJyFvaBbb0XFyy+jfPhwBCUksNYChYKtAv/ww1AnJKDUvhJUWwv4+yMiIgL5/v62EFRdjWpfXwQEBCA3N9d1CPISHoWgCRMmID09HcePHxd+Bg8ejHnz5uH48ePw9fUVAtDZs2exY8cOqO3XPgGQlpYGsViM7du3C9vy8/Nx8uRJjLBP7+0pLs7WKfnkSeD771k4CQsTmrjKy8uh4nmHEBQfGYmzZ8+yPioAuzOxqyBUVlYi25rSz58HHx6OwMBA1tHNno8PgsPDUVZZ6fLwuLo6Yfh7UFAQKuqXLOtXLXx82B2GpU+QwWCAWCx2DEGlpcJnsQYr86xZGLRyJX43GNhIBTund+zAtDlzcPHiRbcVPOF4OQ4Gg8Fx5JrrHZ23XbrEKj4uXADQ3drOXVICZXQ0DlgmH6uqqkJgYCB8fHwchp2C54G33wb++MP5BV1UgvJ0OvROTYXGg3K6TqeDXC53fN9OSq/XO3dkJ63Dw2VmvJqL5jCFQgGtycT+rVpD0LhxwP332+YVA65uc1hpKbB+PauauBIRweYNslaCUlJYvyGr5GTgk09Ya8nNNwMHD7IbbonEZahSKpXQaDSoqKhAcM+e7PtMoWA/o0ZBnZiIUvsbMLMZEInAcZzjMPmqKkAqha+vL3Q6nTDlijfyKATJ5XKkpqY6/AQGBkKtViM1NRV1dXW4+eabcfjwYXz55ZcwmUwoKChAQUGB0DlVqVRi4cKFWLZsGXbu3Iljx47hjjvuQN++fZvU0bpNiMW2fzQyGVuigeNwzGQSQkNZWRmby8cuBHWPi8MF+87MAQEOVZtff/3VNmNyVhZbpA6W5qJ6ndCCg4NRXlvb4MzRAODr6+t8sdXrHefskUjYtsJC7DxzBt26dQMABEVGosIyF0RtURFElopdQEAAqqqqAH9/DBgyBBfDwoB6fUMunDyJQTfd5BzAXPDz88PGjRsxZcqURveFr6/j0MwGKkGnKyqQYv1iLC5GVFwc8i1D/nNzc11X5A4fZkNYMzOdH7PvE2T5e87X69GrVy9oPJjY7sqVKxgwYIDQTNmZmc3mJv0dE3JV2VeCLN+JQgiyrwQFBAD//KfDU/mr2Rz29NPAP/4hTD3iJCKCBZGkJPZniQQYO9b2uEQCY1QUGxkdE8OuF08/bWuJqMfa4lJeXs4qQRKJwwiy4O7dUe7ueyckhLVyACwE+fl51l2gi2rVGaMvX76M7777DpcvX8aAAQMQGRkp/NiP/Hrrrbcwe/ZszJ07FyNHjkRAQAC+//57l/1Z2o2PD+ufExTEmoni4rAxP1+oEJSXlyO4rs4hBAVHRjp2+FYoHPqolJeX2/rBZGWBs4QgAGziNLsAFRwcjHLrujj2eJ718fHxcRi2bTAYbBUouzVhAIBTq1lFRaPBpdJSjLMsRBqflobsjAz2lMJCtmYYHCfOAsAm9Tp0CPj4Y+C664AbboBZr4dvE+8epFIpSktLnTrD1+fv74+a8HC2LIbVpUtuQ5CmthYyS2WOLy62zamRk4PcSZMQ8/77tuCi1wO33w7cdx8rl7sa9eCiEmQ0mxESEgKNWNzkWaMvX76MIQpF0ztkd2AKhYJC0NXkYV+zDu3QIYfBI63KvhJkMABiMRQKBSpNJvZnN6NTCwoK8PaXX16dEPTbb+x7uKHlgtRq9t3ewESyJ0+eRL9+/Vizc9++rALUo0eDb63T6SCTy9lUIXYhSCSRwOSuAh0VxTppA0IISk5ORlZWVoPv1dW5ia9Nt2fPHuH/4+PjGx0pBLCL4rvvvot33323pW9/9URHA3v3sl/G/v1RV1GBrF9/tXWYNRggramx/eObPBmcwYAH7IcnyuVstJK1FLp/P8L37kXB998jIi8P/Lx5AFgfGXNCAnxOnhSauYKDg1EeFMTafIOD2euEhaG2rIwtiCeXsyYqpRI8zyMnJwdx1hJwvSUz+Kgo4PRpVNfVIcguiMT17YsdxcUYAKC6sBCBdmuKVVdX25oyExKAl15i5dqffmIjst5/HwBQV1fHRjM0IDEx0WFSTXdUKhVKQ0IQmJ6OYGvwuXxZKAv/9ttviIqKQkJCAkwmkxCaZTIZSi9dgl9CAvzEYpT/8gtKZs5EyJAh7K4wIYG1sc+aBXz5pW1mbLOZfYlZWfsEKRQO0xsolUpofHzYF4f9qs5uFBcXY/ILL+CPNWvQv4HlTzoDl82thLjyzTesynH99a3/2jU1tmqL5QKuUChQaK3Yu7kh27NnD5TBwU0fhXf8OPu+buwGr7aWTYD4zTcN7+frCzRwnfP19cXp06cxdepUZGVlwXfqVGDu3AZfUpiGhePYiLhGvn8F1vNnNArnUKVS2a4bXorWDnMnMZH12O/RA5g7FyUzZkCpVDpWZoxGVo4EWOhQqdC7d2/b40qlUAmqLC+HbP9+XPvHH/h14kTwjz8uJPjo6GjkyuWsn4qlmiGVSmFQq1l1KCuLTRB4ww0oPXMGIZGRjsO4UW+OIOviqRaiuDjUpafjck2NQwe4wMBAVFv61FQVFyPArsNeVlYWmz4dYHcxr74KzXPPAT4+4KOjwVtmcC4tLXXq91VfUlKS0ATXELVajRKlEg/+4x+22cPtFvlLT0/HMcs8IPv378eoUaMAAKEhITialYWYXr1wbWQk9nz9NfikJHDz5wMZGfD58kuYt21j09Zbq1t2E1QKKirY35ldXy6O4yCTyaCrN7y0IXx1NYKLilDR2PDy+pNvdkBKpdJpEANpRV2pX1BFha25pbWJRLZqjl0I0lqrQ25Ci9FohMTfny242hRr17I+PI15+21gwQLbXEQNaSAUhoeHIz8/H3369MHevXsRHhXlvmnNlc2bXW93UYxQKBTQpqayLgGWcwhAWPbKW1EIcqdHD2DbNhaGABRaR6/Zl3sb+QLjrZUgAAdeeQUj7rwTUoUCxsBAVI4fD4WlqpCcnIxMkwmm33+Hr3WWU8A2V9CpU+yC2bs3SjZvRkhMjOOEfqgXRuo1h0UPHYrLR44gV6937ifj6wvU1qLqyhUE2jU7XblyBYmWz+7v74/q2bPxz9dfx+XLl5Geno5US9XI19e31Ub1qdVqfHf+PB5MSXGoMAJsSRCZTIZqy/IVQuUrJAShIhGO5OYirm9fKKKiUJmVxc4dxwGff47wm25C4YoVjlWf5GTnfkEGgxC4rKxzG5n9/Jq+iGp5ObgRI2ylZ3fcfYF1IH5+fk2fbJJ4t6sZgizzsAFgN3l+fggMDITO2tztIgSVlZVBpVIhKSkJ55raP0+rbXwCy5wcNuLLUslviW7duuHKlSuQWUYWR1jnQGsq6024PX9/p4EsANC9e3dc7NGDtXDYhSCVStWcQ+8yKAS506MHW6PK0jZbVFSEsMhI8B50dvUJCoKpsJDNyfDTTwi1LMzJcZxDaAkJCUGx2YzyM2cQbB8orLNGnz7NRhXMmYPi9esRkpDgVAmyvi4Ap+aw+JQUZF+8iCKx2HlSLJUKuHwZVQYDAu0C2MCBA4U+Rj169MCFCxeQlJSEffv2IT09HX0tlaABAwY0PEGjB1QqFf7Ky8MYHx9c2bUL+zdvxglL6Nm3bx+uvfZaAGzklzBPVXQ0Qg0GnNJoEBoVBYSGQhQWhlrrlyPHIW7sWGTbdWo+c+YMLiiVbBSGC/ZNusL/yeWO09E3pKyMNb01sEI0amtZwO0CI8gIAcAqpW3RydZyAec4DrylarL/2DGnASK//fYbRo8ejYFpaTjW1H+7lZWNh6AnngBef71VqngRERHCyKyioiJE2vcTdaOx0bgIC3P53RMfH48sqZStfGAZHUYoBLnXvTu7u7D8UpaWliKxVy+UWzq7NqXvkyIhAZU7dgCffAIMHiwkb6lUitzcXCEEcRwH+PigJDycVXmsgoNZJ+HTp1nb74AByDSboe7Rw6ESxHEcazZ69VV2t1SvOSwiIgIFYjHMCoXzMPXQUODgQVQrFA5LX9iXSHv06IE9e/YgISEBdXV1QnUEAEaPHt1qdxISiQQPLl0KHDmC7j/+iIDnn8dfln4/OTk5iI2NRWRkJP71r3/hemuJOToa8rIyaGpr2TGFhWHk5Mm2qQgAxMbGCmvXAWw5jaPV1WyiMRfmzp2Lyro6XDx7FrHWcxIeztbpaYqyMjanlEjkfuHV0lLWabuDDz9v9AuXtExX6hgtEjW9WtoS1dW2CohYDIjF2Ll3LzLq3dRotVoolUpIZDJccjPdiJPGQtCWLayK3KtXMw/ekVwuxyuvvAIASEhIaJ2JgBMSnEbzAmzUr0ylwpYrV9jNfFP7EnVxFILcCQgA7r5baELheR7dEhORb12mgW1s8CWU8fHQLF0KfPEFm7/Con///ti9ezdCQkKEbbW1tcgPC2OLp1pZS8CWUWqvv/EGRj/4ICSpqQ4jmACwO7B//5t1wqu35oyPjw/M9UYRWMmio1H5v/+hKjraYa4IkV27dGBgIHbs2IHhw4ezLxVXJdhWMmHiRCApCaN++gmDliyBT3w8ioqKhKA1fPhwaDQayKyj8qKjwX32GdSWDuW46SbEPfoo7rvvPofPYj/hn4+PD4xKJQs19dbTKS4uxo033ojtOh0ObNqEEZahrVxkJKsMNkV5OdCtG/uydLMenrDScwcfRt+UsE88ZF0BnTSPfRXDsoZW9x498NdffznsJgR4sRihTR157OvLBmO4otMB77zDhrBfBUuWLGmdm46EBNbvx4WpU6dCl5gI3U8/QWbf9cKLUQhqyLvvotjSp4fneUQkJaHAg1V3lUolND16sKGUdsGhe/fuOHLkiLCoLADcfPPN+LiyEiHW1dKtLFUigC002+ell1inXru5bHx8fGDKyWHTtm/dytb6qt9GnpAAzjIE3l7PwYNxdutW1ERFOS9jYWf06NHw8/PDddddZ6vCXC1ff82Gcy5ciNHPPotnn30W1113HQB2N/O8/RwaY8YAixbhmkceYX+OjARCQ92WlYWSOccBEycCO3YAAPb/+iu+vHwZX331FebMmYMqqZT10Zo0ie0fEtKkUr/JZGKzWHfrBqSkgHe3fEZJCfs7tIYh4j3sOvt3qY7RAOuP4q762VrsK0EAoFbD19fXNpiiPl9fSJp6nhuaWPHvf2d9Mxv4nmyJxgaYePBCMOfksD6PLqr0URMn4q8dO6B2tV6YF6IQ5EJVVRUOHjwIAHjttdeEIcIhMTEosV9TrJF/WNbZPSsrK22VC7A7FJPJ5NA0JZPJsPzLLxFg6WsjiI4GEhKg1Woht86DAzg0hwUHByOosBDo3x+45Rbgq6+cQ9CIEcDQoU7HmDBsGC7odOBjYxu8C1lmmeXUz8/P4bNcbbGxsZg7d6776lNgIDB+PB544okGXyc0NBRFRUU4ffo0+liD5p13Al98gS1btkAllWJuz56YNWsWRCIRVGo1gg4fBqwhyNfXqWrkSnl5OVRVVUBUFHpOnIiM335zvWNJCasUdfBKEEBNYq3OPgQBXaNJzPoZ4uNbf1FYk8lxUINdp15fX18Yg4Mbn43eE65+39PT2dQglpux9tRYdbZvv35I1+uBjz4CLP0o7V1z66342d8fak87YXdRFIJc+P7773HixAkA7OJ57NgxcBwHX5EIQtc7o9HtBF1W1hAkrNVlRxjObqd///4OFxye52GOiwNSUnDo0CEMGTLEtrNdc1h8fDz6GAysQjR7NiuF1j8269w49Ui6dYMuMhKXO/Aw6KbMJN7YhXrYsGH4888/sX//fvTr14+NeAsKAnQ6VBYXIyUiAmK1WpgzY+qQIZgeGckqQFb2s1lnZrrs1FxSUoIQHx9AIsGgIUNw1GBw3e+npIT1K6BKkPepqbFVE0SiJs9E3qC9e1v+Gi1RU8NuvOLiWn+EWL0+jtbRYQC7Sfp92DBER0dDqVQKN6y1tbUOTfoekUqF5ZEAsH/nf/sb8NprzfwArUssFjc4YjMlJQWngoLYCDYXky4GBAbiUlwc1N27X8Wj7DwoBNVjMplgMBgQEBAAnU6Hnj17Os38azKZ4FNba5st2g2ZTIbKykpcuHAB3ev9wr333nuNHss111yD31NSgLlzUVhY6NjEExzMRhdNm4aevr7obl1FWakEpkxxqgRJJBLX68NwHEJffx0PPvhgo8fTmSkUCvz111+49tpr4evri969e+PMmTPAlCngTp5kgdJuIkSfkBD41L/ri49nX/Bffw0MH+5yBEZJSQlCLFUrHx8f8L16sS+j+oqLWQjqBJUg0srsK0F+fk5rYnnMaARefrnlx9US1jm2rP9GWlO90a6mykr4WkJk9+7d8YtEgqSkJIwePRqbN2/Gf//7X1y6dMnzSQCtFZb6c4h9+ikwdSpr4u4AZDIZdA3MWebj4wM+JQVYtMhta0Xk9dcj2H5OOy9GIaieCxcuYMqUKYiPj8eGDRtwzTXXODzO8zw0Gg2CrAuQNsDHxwelpaXQ6/WNzqrsSo8ePXDBOotxfVIp+7K57Ta2YKD90hKrVwMDBjjsnpSU5BTErKbNm+fY1NZFPfPMM0hJSQHAZrE+e/YsqidNQsCJE2wRRPvQM3s28Oijji+QlARs2AD8738oWbrUZR+hksJCqO2aOgIGDoTObrFggPVLev6HH/BZXh5VgryRfSXIz6/lSzpUVrbNqKyGaDRsyRn7xadbi3XeM0tIMWq1kFhuQMPCwpCeno6wsDAolUosWLAAIpEIx44dQ49Glp5wYg1b9iGouJjd9Dz0UGt+ohZpSvO0T2oqTPPnu338b3/7W8dapqodUQiqJykpCRERERg6dCh++uknREZGOrbBikQoKyhAsNnM5mNoxK233or09PQWHdPx48dd98M5exa44w52h2Lflyguzmn4Y//+/Zu0dIW3EIlE0Gg0OJyXh8FmMxspZt9+rlQ6hE+e59nEmR98gO9nzcK68+dx2rISvclkwmuWUnlNQQEC7O4Yh918Mw79+afDe5eXl2NkQADE0dEdvhLEcRyNEGuq1aubtp99JUgiaXklSKu9+p2RG2Ndd8/VTOwtVa8SZKisFEIQx3EICQlxCAbTpk3Dl19+6dTRuNHfY62WzQcWE2Pr1/TUU8CKFZ7N4nyVhYSEINbNeopWaWlp2LJli9vHW60TdhdAIcgNsViMJZbJDeVyuVApSYiLw8bPPoNKr2cjmBoREhKCV199tdnHMXbsWNTU1GDmzJnOD1r/4b/7LnDXXc1+D281c+ZMrF27FtH33w+8+GKD+3IcB/Pw4fj6kUeQlJaGZYsX489Dh1BdXY333nsPMktHepSVOZTNI7t1QwHgMINrcXExQk0mNkdTB68E8TzfaB+ELi0zk6031xRPP+2w5pxb9StBLQ1BHaESZA1BSmXrz31lPwM+z8NYWQk/u+k+5tereEilUjz22GMOwSjAx0eYbd6tykoWgkaMYINLtm1jf0/2fTE7gMGDB2PGjBkN7tOzZ0/07du31Wbz78ooBDVgzJgxAIARI0YIMyQPT0vD8JgYRNbUNCkEtVRMTAyGDx/e8E4KRaNNc8RZZGQkXnrpJXC3385G1jUgJSUF6zdvxsCbbkKvXr3AxccjUKPBxx9/jAceeACq3bthKi+3zRFkwXEc+J49HeYLKi4uRqifH5srpgOHC+udc1BQEDQdfFLHq+bChaatJaXXs3Cze3eT9jVJJKitre16Ichu3b1WU10Nra8vCkwmoLYWxqoqSOya78eOHev0lNGjRzv8WS4WO/SjcVklsYagqCjgsceA++5r/75WLZCUlITx48e392F0eBSCmiA0NNTWya5bN1wbFgZZaWmbhCBydcXHxzdpv/79++Ouu+6yjfJTqzEzIAALFy6EX10dosrKkH/sGJuJtX4Hyl69gL17cfLkSQCWECSRdPih53V1dRCJRN69knxZWdOqdRUVbM6qbdsa31evx+nycuzdu7frhSCABaHWXA6muhqZWi1O6/WAwQCjTgeJhzMry3x9HUJQ/bUJAbAqnvV1r7uOLatDEwp2eRSCPNWtG5svIi+vw4wWIO2A4yD19WXT3J89ixi5HJdOnHCqBAFgfbROnsRbb70FADAYDJD6+oLn+Q7d38ZgMMDPzw/BwcHeHYKa0m+rooItjdOUpVVqalBWW8uWcmmtENRR+gQBQERE09fZc6Hu8mXw9qGuqgqFRiMqAcBggKG62qES1BQysRiVlt9hg16Py64WN7ZWgqxobS2vQCHIU1FRLASVl9Ndgrez3vFmZqLb+PG4kpXl1CcIAODjA95sRklJCWsCMRgAf3/I5XLoTCZg7Vq25EkHYw1BXl0JKi9veggKCmKTm+bnN7yvXo8yg4EF4NYaHQa0b9OqfQhqaudoN5OP/vi3v6H4559tG6qroTWbUc1xrBJUVwc/D2dtlgcFQWeZ7T9/3z5EWJfY2LMHsAai+iGIeAUKQZ7q1o1VgYCuN+U98Ux4OFBUBGRmQjJpEmqLi1mzRL0pDeRyOU7odBg9ciSbc0qnA9RqBAcHo9zPj83sahlp5o5Op8P5hlalvwqsIch+EjqvU1bG/r4aYw0BvXoBWVkN71tTgxqALVPTGqPDKivZSNX2bBLzNATxPJuGwgVtRQUqLcsVbdy4EaiqAmftQ2cwwMjzHq9fKFOpbCHom28QaV0aY9cuwDqoobLS5fqKpGujEOQpudxhpA/xYrGxbChtZiYwYYKtYlAvHHfv3h2bqqowY8gQ5ObmsouVSsVCUP/+rApkvzCvC1lZWdjpbh2yq8RgMEAqlUIsFjssQNtaNBqNZ6/rbk2nq6msrGkVX2sI6Nmz8RCk14OzXsRbqzksIqLjhaB33nHfTFdaClj6yNWn1WpRafm39Ouvv9pmiBaJWAgymz0PQSEhQrDKP3QIEdHRbKbunBxb5c46RJ54FQpBzVFvlXbipWJjWedJjQbo2RN1FRUQuagOJiQk4LTRiB5mM6sE1dQACgVUKhXKxo4FUlMbfaucnJzWXR+pCZo7yWdT5eTkICMjo+lPaI91mzQatghlY2HNPgSdPdvwvjU1tgVAWzMEtWe/oJoaWx+amBjgyBHgySfd9w06f97tUPoanQ6VlmV8Lly4wL5vJRKhEmRoRggSq1Soq6wELl6EXqVCUEQEai5eZDcx1hBEzWFeiUJQc3AcjQwjrJz/1VfsAunjg1KtFiEuqgYBAQHo1bMnRJcusZWuq6sBhYJVgsrLwfM8thoM2Pjpp27fSq/Xs+aTNmRtDrtakpOTmx6CjEa2/EhLA4OnzGZArRYWK3bLGoK6d3e5nIoDvR68ZfI9vrWaw9qqEmQyAS+95Pox6w1ATAzwn/+wBZst6xs6OXeOVV5cDAwIrK0VQpBUKkW1RsMCll0lyOPfS6WS/bs7cQJITERobCxKTp1ir2kfgqg5zOtQCGqOqCgKQYR9sf7vf8DzzwMAeLMZIW5mcn32iSeACxdYZ1hLJUgqlUKv1+P06dOQJSai+vx5t6PFeJ6/ekPqy8pcXtiudgjy8/NznoTx+HFbHw17ubksbLb2CuWN4Ti2iG5jnaOtIah+R2dXAUevByQShIWFoUivb7xDcyNNpdBq2y4E/fknCzhuGAwGnLp4EbjnHuDmmxsOQQkJLvtbyYxG6CxVori4OOQUFNgqQRUVMIrFHleChBBUVAQoFAjp0QMlGRlsMkTr3xE1h3klCkHN0a0bhSDCBAayGWYBxHbrhhA367P5JSc7hSCrs2fPYuCECejD8zjlauiuhVwuh7YpMxJ76tw5YP9+p80ehSCdTmje2LhxY/OOo7ISePhhYM0a58eys1mV5cKF5r12c/E8qwQ1NleQfZ8YHx/byKfRo537ENbUgJNIEBcXh0sajXNQsq86abXAvHkNv7dOxzrpuwtBhw4BI0cCb7zR8Os0xY8/Oh+vXXDPzMzEL7/8Anz8MTtv7kLQ+fNAWprLJjGRwQBTdTV4nkd8TAxyzpxhTZIiEVBUBKNU6nkIUijYv7uiIkCpRGhyMoqPHGHh0XpzQc1hXolCUHNMmMDmBCHEzg3XXIMoywKtTpRKoLISWq0WCp4XQhDHcaiurkbgwIEYWFmJY8eOoby83GWH4d69eyPDVZWkpXJybCMe6+qEi5onIejymjU4+847AIBffvkFVxqrXgCsP5VdQPjz9tvBr1jhuvKRnQ2MHw9cvNik4xHwPDB9uu3zefpcwLNKEMD6iuXm2ppf6gdMnQ7w80N0dDRyXYUg+75PBQWNf2azGaUc575P0MWLwIMPsubEljpyhC0jYf9eOh1gWcsrKysLwdbRkSqV+xBUXs5WnHcRgniJBNDrUV1djegrV5DXuzcbEi8WA0VFqJVKIfJ0La96laDg3r1R9tdfbA4vnmc/BoPTmouk66MQ1ByTJrEOkITY8Z09G7jmGvc78DyMRiNCASEECc1f8fHgzp2DSCTCV199hYMuwk5CaCguPPyww7bjx4/b/lBXB2g0qKmp8ezAs7NtlY4XXwSeeQaAZyEoOyMD31qWBhkxYgT2u6gsAWAXG+uooFWrEHDmDKqqqoANG/C/khJkhIWxi2P9C//Fi8C4cZ5Xgn77jQWJDRs8ex7ALpoyWdMqQdXVtvXAkpLYCLETJ1i/sfqj+srKwAcGwt/fH1cqKhxDEM8Dx47ZqjoFBdDk5jY6Mu4/R486V4Ks/a1KS1kgaa5332XHlZfHKidRUY4dngsLWSUKgNFotP3OqFQNh0elkoXH+qRS8DU17Ibh119R2LMnwsPDwYnF7L0CAjxvGlYqbZUghQK+sbEwX7jAAmtwsK36RtOeeB0KQYS0ltGjWadQd8RixERFIdRsdu6A6esLREbitpEj8eCDD7JRMRZarRZyuRy+587hQkGBsL20tBSbN2+2vcauXeBffRXPPvts04532zZ2cc3OZv0zqqvZxbu6GrjpJhi++grSJs6aaywqglivh0ajQWh1NYzuOvsWF7NgwPPAoUNI0elw5vRpVH7wAYY+8ghOnDjBKj67djk+LzsbGDuW/dcTq1cDGzfi8pYtns91VFbGLpBqddMmTLReQK+5hk3Cd/QoW9i4/lBwnhf29QsIcAxBWi37O7EOsy8owBqptNG+UNkVFc4h6J57bJ9DrW7+ml5vvsnmsfryS2DOHBaE7H4PUVQkhCAr3tqM6KoSZO17ExTkXAnieTYnkNGIyspKKHx9UVBRgYiICNaZvKioeSNzLZUgQ2UlxDIZW5BVKmUhKDKSdY6+CtNAkI6PQhAhbUWtxtQhQxAHODSHCebMAb75xmHbBx98gAsXLrC1686cQbxOJ3xZnz171rFZoKwMFw4edL/i+969jhell19m1YorV1gTR34+u1t+6y3gk09gvHAB4sZGRVlU5OdDWVuLzMxM9ProI0i3b4der3feMScHuHwZ2L4d6NcPPYqL8fuPP2KXTIZJU6ey0XNjx7JZtH/6ye4NKlgFwl2Vq67OVvmwyshgF9u4OOwVi5HraXNQWRmrZoSENG39MKuhQ1nn7sOHWb+XepWkOp4X/t7kCoVjx2hr1SYzEwDA5+fjRHBwg01iRrMZ+Vqtcwg6d44Fn5ZWgqRS4IsvgF9+YU119UNQYSGbrNEiMjIS+fn57pvDzp8HEhNdrzhvaSoEAG1ZGRRSKUwmE1sN3VoJas4oSUsIulhdbVsvUKWyhaA//qB+nl6KQhAhbSUkBP5VVfCxG4Wi0WjY+mMAMHEisGOHsHtBQQHUajVWrVrFQlBGBqvYWPq35OTk2Bb2BYDychxNT8eQIUNYmKjv009tSwQA7CJ58CALELGxjjOhq1TAsGHgmtjJWW8wQKrX4+LFi4iPjUWvsjJk/fij846XLgG33QY8/jgwcSJ86+owOzQU55RKBFn61PAhIazq8O9/A+npzq9x5Ajr7GsvIwOYOdNxKYY33wSWLQMA5IaHQ1f/OY0pL2fnoamVICuOA0aNAg4cYIEhLY2FTQAwGFDBcbZ+M5a5bwSlpayjvSUEVV66xEJYAyGozGhEoFzu2E+H51nwqqgQKkEnmzPJq9EI9O7NRu1dey2rWIaHu6wEWRfcTUlJwenTp903d507B/To4fR4VlYWqxIFBAAAtFeuQB4SgiFDhkAmk7HmsOZWgmQyQK/HMa0WAwYMYNv69mWDXCIj2aztbmawJl0bhSBC2oq1omA0Cne7JSUl6GntXyYWswpRZSUiIyPx5Zdf4sYbb8SLL74IpVIJZGaC69sXZkuTkMlkgq+vr+31y8thNJvRKyYGF11dNLOybBWJigqgTx/bcPSoKODMGcdmugEDhGqMRCKBoYH5bDgfH6hFIhQVFsKX45A4dy7OueoXdOkScPvtLHCNGQMEByPm4EEsswzR7969O1seJCGBTT3w8ccsJFhHAymVwMKFwKZNjq9rnetl82YWnlauZBd/S0f1gMhIVDbWlLZ5M2vCsrI2h1krM9dfD6xa5XbNKwAotsxKjHnzgEGD2P/bLyian48ypVIIQbyvb4MhqDA7G2FJSe5DEM+jtLYW6pAQx0pQVRU7zqIi9netVOJ/hYWery9mrYatWAHcf7/t87ioBF28eBEJCQls6H9REQtMZjN7jaVLbfufOwckJuJCVZWtEsTz2PDRR+zPlkpPZX4+FBERmD9/PgCAE4thKigQQpJHLCP2TADEYjHbdvvt7PcqMpL97k+c6Pnrkk6PQhAhbcUaguyau6KiopCQkGDbJzkZOHsWQ4YMQVlZGcT5+ejxwAOsaaWmBjF9+yL32DHXr19WBj45Gb3NZnYnXt/Zs6xPjvX/R41iwUitZiHot9/YMHQriYRd8DIzERQUBI2bGX5hNgMch/4KBU6fOAEolfDv2RN6VyOycnLYe3z/PRuZk5rKOg4nJQEAhg4dautU3bcv6wj98svAwIFs27Jl7Ln1O0jn54N/6ingb39jF90RI9iyDRbyuDhUXr7s+vh//hl4/XW2/3//63A+haHZajVrJjSbWUdhO6aqKuyyTF2wZs0anDx5kn2e//yH9Y0JD7eFoLw8lMnlUFmbp+pXgkpK2PmxvF5RYSEi+vaFyd0EjFVVKPH1RUj9tcOsf1fFxYDZDH1tLc4bjZ4v+VNayn5vx42z9ftx0yfo559/Rs+ePcFxnGMl8swZ1vxpZWkOW7drl3CcppwcZH71FXi7EFRdXAz/iAjhaXKlkq3/1ZwQBDiMYgOA6Oho9j+xscCsWbRqvJeiEERIWwkNtYUQi//7v/+z3ZkCwtpTCoUC/3jpJeDOO4Hly9lF2tcXPQcPxlm7JiIfHx/hglNRUIDgQYMgv3gRuvqT0FmrGtZKUFYWe6+YGDYaKyqKDeW2D2QACxUrVjS8knxxMXiFAhFSKYYmJbGLZXy802fVaDT45fBhmKOigOHD2cbUVBZ2LMHQ19cXCoUC5da+SMuWsX2snb0HDmTHXO/zma9cwQNbtrBmsWXLWJWpWzcAbMSSLDwcRrsQJ4zK02qBV19ln/uXXwDr6uKArTkMALZsYQF16VIWmuz4VlaiwLKkSUJCAg4fPswe4Dg89thjjiEoPx/lAQG2EGSZBVlQWgqo1SivrQV4HkV6PfoOHYpCd81xlZUo9fGBuv48QRoN+32zLBp6+fJlhDRx3cNi+783y/E4sHtdAEBhIUxqNQIDA1nFEmymZ+F3MDOThV/rCLeCAphDQnDq0iUhBJUfOQJpVRWqi4sREBTE+sXpdOBCQoS3USiVqKyra3YIKqupQaw1+AC49tpr2f/Ex7M+T8QrUQgipK246GDrNNTXbgFOnwMH2JxU48ezpoXu3RHarx+KcnKEGaRDQ0NRYnnN9EuX0Hf2bODkSXAch59++okt2Aqwys+IEbb3z8xkF/Vhw2wh6MIFh0oQz/PseEQiBB8+jIp6oUaQlwdYLlz/N3Ik6yQbHg7eEmT++OMPAMCRI0cQDOCk/dpaI0cCjz7q8HIzZszAT9ZO0RMmALfc0ujQ5eILF9B/0CDs3LePdcq1c+7cOSTVm9Ji/fr1rLKVng5MnsxmN5ZIWH8Ta1DIymLnxp5YjJxu3fDje+/ZtlVUCBdmjuOgUChQUVGBU6dOISQkBAWAQyWoQiIR+oFxEolzx2i1Gq8XF0OflQW92YzExERccdchXKuFQSyGVKFwDkGJiUIQzcnJQVxoqFBhasiHH37odDz1z4HDSCqDAd9t24ZZs2YJm6ZNm4YfrX3CMjJYKLX7e8/Lz0dYZKTQJ6jkxAmo9XpU5udDrlKx5iuNhv2bsVAEB0MLINuTTup2ugcFYWj//q4fbON1+UjHQX/zhLSVpowysl+F/L//ZQEAAF54AZgzB1y3bkB5OQoKChAREYGoqCi2KCuAXJ0OMWPGABcuoKysDCKRCIesnYGzslj1xb4SlJQEPPQQ678il7OmAlczXr/2GoJyclD+97+7Pua8PHAqFeuvc/Ysq3xYLiqlpaX44IMPAAD5+fkYEhSEfv362Z4bHMxCiB2xWNz4PDAKhcPIoivZ2Rg/cyZ8fHywdu1aVNt1Es7IyEBycjILkpaLd1lZGeuI+9dfgP2FceRI1qGZ51n/pXpTHly+fBm7YmOh/eUXtuHSJRbi+vVDXV0dfH19MWPGDHzxxRfYtWsXlixZgj+ysmwdq/PywAcF2RbDdVUJCglBbWwsLnz+OcBx6NatG66Yza6X4KisZM1HEonjyDmNhv39WsJXUVERQlWqJlWC0tPTbZN1lpQ4hyAXampqEGIXWAICAlgfMpmMdaqeOZN1yq+pAfz9cf78efTo1Uuo6JWcOQN1fDy06elQhISwPnPFxQ7vLQ8OhpbjENOjR6PH48rU+HhILdVBQqwoBBHSVkJC2EWpobtO69wpdXWsA2lyMtuenMwqOSIRzHV12LJlC/r162cbjmzBiUQAz2PRokWYPHmybeLErCw2DN7apKXTseDj52frdBwfLzQh1T9uxYsvQuOuSSYvz9aB+MwZYbh0pL8/1n/xBcaNG8eqSgYDuOb256ive3eHzsJXNBp0S0zEuHHjcN111+Gypf/Pr7/+it27d7PFZ1UqNjwfQHBwMOs8fuKEYwgaM4b1UTp5kjXDOXzMPPzyyy9Y8Pzzwuvg9deBV14B17cvLly4gPj4eIjFYjz44IMYP348ZDIZdNXVtjl68vPZubKQBAbCYD+qq6QEvEqFxPHjce7bbwG5HAEBAaiRy22dv+1VVgJSKThfX5jNZhZaqqttlaDz523TMfj7NykEBQUFCdVFlJbir/JyrFq1yrmJtZF5hyQSCcwqFWs6GzgQOH1aqDbm5eUhMipKaJYsyclB9yFDcOXYMchDQ1mwKy52rASpVNAGBoJrbtVGqXQYyk8IQCGIkLYjl7PA0Nj6RDwPbNzIRiO50E0qxc033wy1Wg2lUum+w7K9s2dZlcm6RIArn33GqiUW9tUYkUQCk9ns+nnWEKRWsxBk6UCb3KMHcjMykJSUxJrlSktZJ9QmaLQSVG8dscq6Osgt5zU6OloIQTk5OXjX2pE5NFQITmKxmFU7cnMBu34iGDCANd+sXu24fAWAnTt34u6777ZdhM1mdgwDBiA+Ph7btm1DkqWDt0gkQp8+fZyPu6zMYYh3kEoFjX2Fp6YGl0pKkJqWBp2fn20pjuBgFoKuXAFuvJFNEwCwUBsYiMDAQFSbTGx9sB9/tFWCMjIAtZqFjSaEIJPJhMjISBRam+9KS3GisBDz5s0TmjWFc1lUxJryJBKXf18REREolEhYsE5JYSHIMjKM53nI5XJUWSpONbW1SBwwAFkZGZCHh4OTSmGuXwlSqXBcLEZ3N+vzNUqhYMdNiB0KQYS0FY5jF6f6s0XXFx7ORiLde6/Lh8d1744QS2dq68XHYfV5kch59lv7xSHz8lxPDDdoECorK92vZO/ueOuHIMvddlRKCpZOmYKUmhqceu014IcfnDteuxEQEMCW03DBaDTCFBdnC0H1gp11iHZtba3jsh+hocKM03xhIbjqalaVs7+A+/gA77/PRjONHg2DwYAzZ84AYJ22hYt9RASrrlme37t3b/z++++2+X/syGQyVJlMLDTZzRYNsKpLhf2SGDyP48ePo3///mx9QmsH6uBgdp5Pn2ZVwccfZ9stC4LKZDLo6urYCL/8fPZ7FhnJQp7lNTh/f/DWPkEXLgD2fX8scnNzMXjwYIcQ5KNQICIiAgX2I8J692Z/19nZMERGOnbut4iJicElnmfHK5OxY/3iCyA5GRzHQa1Wo9RoBAwG8GIxIvv3R2ZZGRSRkZAplagqLnasmsnlOGg2Y6B1pKCnHnqIHTchdigEEdKWXC2ZUV9KCuuo667pyNrMYacwNxcR1gqD3Si08PBwXMrJwfKMDLYkBcAu3tZmtnpef/1113MMAW7DEQoKWFODSsVChiUEcQkJiN68Gao1a1AkkUA8daptKYdGdO/e3ek4vv32W7zyyivYsmUL/nvqlC0EWfvFWPj4+MBsNuPSpUuOk0nahSD88AP4l18Gn5CAt956y/HNY2JYxUIqxYULF7Cz/tpfABve//XXwnlsaAqB6Oho5Pn5uWwKdQpBAKqqqiCTydjM2ePGsY3WEJSdzfp2yWQsUFnWwpLJZKisrmZ/F9YQpFSypk5LNSUgKAg1libNs0uX4qP6nxvA+fPnhekZAKC4oAAh9ufQKiWF9fE5fhxXYmNtw83rfe7L1n0B4JFH2Mi90aPB8zwLQbW17FyHhyN00CBcBBAYEQF5UBC0RiML9FZ+foBY3OSlXJz060cLpBInFIIIaUuhoY2HIOvFwp3ERHbhsNBqtfhq3TqkWpua7IZkDxgwAE8/9hieGTUKBw8eRK1EwjoDu1gAuKKiAj179hQWZXUbeuoxm0zgfH3ZxdbazwhgTVbHjgGff46LCgW6T5zY5ItQQkKCw/ppAFvQ9emnn8acOXNglMnAHz/Owp61ElXPhQsXHJtOwsJswam8HHjsMfw2bBg0Go3zZ7VcfC9cuOA4IaVVXByblNE6ISKA4dZh//VEREQgXypllbAhQxweCwoKQoVd1a6irs42KaWPj3AcZqXSFoLi44VJNa0hSC6XQ1deDkyf7hiCQkNhtozcU4SEQFtSAhw+jD2VlZAHBztONVBXh6LnnkNEeLhwPtIrKtDXMsOyRCKxLcnSpw+rSh0/jtzgYMS4WDPPz88PxsGDYZ4/H2+88QZwww3A8OFCRVGtVqO0ro5NUhkbC9+QEJhEInBBQZCrVKisvzyGVIoJiYkuzzEhzUUhiJC2FBLSeAgSixseEt6jh0MIuv/++zFr+HCEWTs124WgkJAQTOvTB7KUFPTq1QuFAQHA77+7DEE//vgj5syZ43rNLwCRUqkwEk1gMqHSbGZDvtVqx46nQ4aw5hl/f2g0GqG/TFPIZDLnjrh2xowbh7333gvceitw4gS4eiGI4ziUlJRAbT+yKTBQWC2c43lE9euHX3NyMG3aNGRmZuLChQu2ZiALjUYDpVLpFJK4mBjWP8cuBD3zzDMujzUsLAyFYjHw3/+Ct85NY6FUKoVKkEmnw7r8fNx1110AWIiwBrCI5GTknT/PQlBcnG3piuJiQC5nlSCxGJgxg/U7soagsDDkWOaRUoSFQVNWhnMbNiD55pvBJSbaZgwHWGfwEyfA7d4tbMqvqUFkZCQAYPDgwfj999/ZA7GxbO6fM2dQ4O+PCLtJDR34+ODipUu4ZFkANicnB5988gnGjRuH4OBglIvFQEEBuJEjAQBihQLw84NcrXZeI0wsxoPW9yeklVAIIqQtNSUENcZFc1h3mcxWDbGfnA/AbbGxQM+ebKi1WAz8+afLvjkcx8HPz89tBShNrcaRP//EJ598YptQLy8PFWo1W/dLpXJcTZzjhH5I8+fPFybSaw0JCQnINBqhf+MN4IknbB2ILayfwWUHa0u/nF69eiEmJgaDBg3C0aNH8csvv+DXX3912NX6/NLSUodAJZXJUDN5ssswWZ9EIkGdXA788Qcqe/cWOnADrAO1yXKsJw8cwMTkZCH49OjRQ3jPIePH4/DFi4BWC5NMhvcuXGCTFFZVwScggFWCEhLYCvY8D2i1KNLrgdBQ5NTUYMyYMVCEh0NbXo6TJ05g8NSprOP0b79h06ZNrOr255/gb7sNeO89h98B6zno3r07MjMzUVlZyapUPA8YjTBxnOtqmcVff/2Fvn37AmCj9e677z5ERkayz37nncDq1UJ1qMfttwMA5Gq1bU09Qq4iCkGEtKXWCEFhYbaQU1XFLkbWGaEBpxCEs2eBpCRERkYij+NYE4t1WLwLHMfBbDY7rRWmVKmQnZmJ2tpaockMFy9CExrKAk5oqNuOz8Kilc3kKpjddddd+PT331H9zTeQ2lVkGhQcDJw5w2a4jojAHXfcAV9fX5w/fx59+/Z1uz7a5cuXHZp8VCoVyj76qMmT7PFKJTB0KAorKtiK6C6cOnAAKXYjyvr374+xY8cCsJstGcDGjRtZuCwoQLnRiODgYAQGBkJ32222kWcmE/65ahVw3XXI4zhERkZCGRkJbUUFakpLEZCQAElyMgwHD6K6uho7d+7E5d274TdsGPv9LC8HzGan4ej/93//h2+++Yb9ITTUYQi7OzU1NYiNjbUNu7cXGOhQ9RxgaVKUh4VBUS/YEnI1UAgipC1de23LR6hYLxrWGaWHDXMYBeQUgiyrdvv7+0MvlbrsFG2d6A8AEhMT8eqrr2Ji/QUlFQqITSbcd999tkrQhQuoCApilSCZDPj885Z9tnqsoUSr1TpVkvz9/TF9+nSs3r0b3erN6ePv72+bI8leUhLM27aBqzdU+tZbb8WoUaOcwhbP8wgKCkJ6erpD51+1Wo1SS+fhJunWDbjvPhQWFroNQeaLF+GTlib8matfYTGZcLG2FkVFRVB36wYUFuKyXo+YmBhWVbGu1+XnBxiNuHjxIow33gjI5axPUGQktNYh8hyHhJ49kV1bC5SUoH///vjp5EncuHAhm6H8zBlUXb4Mab3pHMRisW0ixJQUxzmWXLCez/79++P48eO2SSLduN1SCQoID8cYGslF2kCLQtDKlSvBcRyW2q0QzPM8XnzxRURFRcHf3x9jx47FqVOnHJ5nMBiwePFihISEIDAwEDNnzhTm9SCkS5swoUlNKI3y9wfefpvNKv3EE2x1c3eVIL3e1r9CLnf5/jk5OcJIqj59+iA2Nta5s6tcjgdmzYLIfsTOxYuokMlYCGplU6dOFZZeKCkpcZiR2Co2NhajR49GYr0Os9HR0a6rOomJ0P38M+T15iuy9leyLnkB2C7gCQkJOHHihEPzjEqlEkZQNUlwMHDrrS5DkNBkl53t0MeoPt+AAGytrcXDDz8MaVgYanJycLGmBvH1l/aIiICpqAh9+vRBRkaG8Pp+AQHQGwzCXFA9evTAiYkTEbBpE4b27o37UlLYvmPGAGfOYOfq1Rh/ww1OxzFhwgTs2LEDuOsu4I47GvzY1vmYwsPDsX37dqFZzF5dXZ3j7xQArl8/9Fy9usHXJqQ1NDsEHTp0CGvWrHGcAh/Aa6+9hjfffBPvvfceDh06hIiICEyaNIm1I1ssXboUmzZtwoYNG7B//37odDpMnz7dceVhQoh73buzprC4ODbqxsfHFoKUStvM0GazY5NNcjKwaJHTy509e1YIAoGBgbjD1cVNoXBae0p/7hyqLLMat7bg4GBUVFSA53m3IQgARo4caVuQ1CIhIcFpPhlfX1/UJSRA8+uvCHKz9MLw4cPx559/AmALiYaFhSE+Ph7Z1qH1Fh6HIAuDweA8xJvnkZ+bi0i9ns3t48b1Awbg7mnTAAAxKSnIPXYMNQEBbDZse1FRyOM4jBs3DhkZGcJmjuPAW1eFBxuZtvv8eaT16wfMmcNGlgFAfDx8SkpQuns3giydtO0J69VFRKBMJGLD+d2Ijo5GZGQkOI5DQUGBywkky8vLnedX4jiHSSUJuVqaFYJ0Oh3mzZuHTz75xOGXl+d5vP3223jmmWdw4403IjU1FZ999hmqq6vxn//8BwAbbbF27VqsWrUKEydOxMCBA7F+/Xqkp6ezuwtCSOPGjWMrvAPszv6//2XDlgHHkWXffssm3bOSSoEePfDtt986vFxZWZnjSCpX7FYhl1rm0HnryBGkX7jQ+AzPzZSSkoLz5887j/RqREhICIYNG+awTS6XQxcVhYqaGijdVONCQ0OFSQEvXryI7t27w9/f36kpzs/Pz23/IVcaPD+pqfj+73/HNY0s6aDo3h1+lqAa268fcs+ccd2/LDISOWIxEhMTodVqHUNSXZ3DCL7y8nLEvPMOsHUrq+xY+KtUqOZ5l1MPAGwixLNnz+Lnn3/GdfVm1rY3dOhQjLPMdfTcc8+5bA47duyYRyMHCWlNzQpBixYtwrRp05z6DFy8eBEFBQWYbLcgop+fH8aMGYMDBw4AYCtJ19bWOuwTFRWF1NRUYZ/6DAYDtFqtww8hXu2661izhdWAAc5Dio8dAz79FFi+3GFzVVUV/vOf/7C1pjxhVwnq27cv3nr1VTwVH49XVq5sxgdomuTkZJw9exYajabFo4VkMhkqfXxQERqKoAbmm/Hz84Ner0dmZqbQJDhnzpwWvbePj49tUdJ6dGlpmLRzJ2SNzYT8yCOApRIUGhmJIp3OdQiKisIVHx9ERUXhwoUL6GkX+Dh/f4cQtGjRIpcBrc9tt2G2NWS7MH78eOzYsQN1dXWQNNDJ3tfXV2jqqt9kCbBqW0lJiXOTHiFtRNT4Lo42bNiAo0eP2lantmO9g6rf5h0eHo6cnBxhH4lE4lT+DA8Pd5yW3c7KlSvx0ksveXqohHgvX1/g1VeBdeucRoIdPHgQDz30EA4fPoyhQ4c2/TXlcmGenR5xcXgyJwfcihWteNDOgoODUW6d26eF1Sa5XA6dToeKhx5CUL3mM3tTpkzBunXrEB4eLiwH0VC1oynCwsJQXFzscpTbPY88wiawtOsU7ZJdMxrHcazZ0y4E8TzPXj8iAiZ/f4hEIvTu3Rs97Jr+KiUSRNoFjtGjR7t8q8T77mv0M11//fUNBqCm6N27NyZMmNCi1yCkJTyqBOXm5mLJkiVYv359g1OX1/+y4nm+0S+whvZZvnw5NBqN8JObm+vJYRPifdavBzZscFo1OyAgAGfPnsX48eORmZkpbG/S7NB2lSCfI0cQPXSoY1NbByeXy1FZWQldcnKD/ViCg4Nx6dIlzJo1q9XeOzIy0u3aYgCAd99lEx16oFahgKje623YsAG7CwuFxXfvvPNOh/XTrsjl6NbC6Qqs4uLihIkUm2vSpEmNjhgj5Gry6LfvyJEjKCoqQlpaGkQiEUQiEfbu3YvVq1dDJBIJFaD6FZ2ioiLhsYiICBiNRuHuztU+9fn5+UGhUDj8EEIaIJO5nHW6W7duwqzPJpMJZrMZhw4dYgt2NsauTxDy81nn7E5EJpMJAzQauyl75ZVXWvXiHBERgR9++AFTp051vYO/f5PnHLK6JBIh1r6pi+NgMBhwyd0CuQDyBw1CN1p6ghCBR//qJkyYgPT0dBw/flz4GTx4MObNm4fjx4+je/fuiIiIwPbt24XnGI1G7N27FyNGjAAApKWlQSwWO+yTn5+PkydPCvsQQq6OqKgoRFkukFOnTsXmzZtx6tQppNabZ8cl63pVAFuyoYVVgLZmbQ5r6ppojUl2switK0qlEqtWrWrVDuS1Aweih12/sIyMDAwaNAihoaFuF3MNCAhAaL05kgjxZh71CZLL5U5floGBgVCr1cL2pUuX4pVXXkFSUhKSkpLwyiuvICAgQJgES6lUYuHChVi2bBnUajVUKhUef/xx9O3b13lyNkJIq4qKisLdd98NgPXDMxqNCGtkVJJALrcNkc/PB9ropkUsFqOqqqrFr+Pv74/q6upWOCJmUFNnqQar0rhtCmumaQ8+6LDC+4wZM9CvXz/07t3bNqN3Pb1796bmJ0LseNwxujF/+9vfUFNTg4ceegjl5eW45pprsG3bNof1ct566y2IRCLMnTsXNTU1mDBhAtatW9fg+jOEkNZhPzHdLbfc0vQn1q8EuVs0s5UlJCTgl19+afHrcByHjIyMVg8j7aV+p/bBlv5ZYrEYQ+qtVm917733XvXjIqQz4fjWqg23IesU+q0xbJYQ0kRmM5uYccsWYPZsYONGYfbhq0mj0WDdunVYsmRJi1+rrq4OJSUl7lc9J4RcVR3t+k11UUJI0/j4sCAEACZTmwQggDWhz5s3r1VeSyQSUQAihAgoBBFCOjx3S2YQQkhLUAgihDQdx7Fq0FVaJoMQQtoShSBCSNOZzUBJibAIJyGEdGYUggghTRcfD+zZ0+nmCCKEEFcoBBFCmm7uXOCdd9pseDwhhFxNFIIIIU03ahSQnU2VIEJIl0AhiBDSdD4+wB13sGYxQgjp5Fp9xmhCSBf36qs0OowQ0iVQJYgQ4hkKQISQLoJCECGEEEK8EoUgQgghhHglCkGEEEII8UoUggghhBDilSgEEUIIIcQrUQgihBBCiFeiEEQIIYQQr0QhiBBCCCFeiUIQIYQQQrwShSBCCCGEeCUKQYQQQgjxShSCCCGEEOKVKAQRQgghxCtRCCKEEEKIV6IQRAghhBCvRCGIEEIIIV6JQhAhhBBCvBKFIEIIIYR4JQpBhBBCCPFKFIIIIYQQ4pUoBBFCCCHEK1EIIoQQQohXohBECCGEEK9EIYgQQgghXolCECGEEEK8EoUgQgghhHglCkGEEEII8UoUggghhBDilSgEEUIIIcQrUQgihBBCiFeiEEQIIYQQr0QhiBBCCCFeyaMQ9OGHH6Jfv35QKBRQKBQYPnw4fv75Z+FxnU6Hhx9+GNHR0fD390fv3r3x4YcfOryGwWDA4sWLERISgsDAQMycOROXL19unU9DCCGEENJEHoWg6OhovPrqqzh8+DAOHz6M8ePHY9asWTh16hQA4NFHH8XWrVuxfv16nDlzBo8++igWL16MLVu2CK+xdOlSbNq0CRs2bMD+/fuh0+kwffp0mEym1v1khBBCCCEN4Hie51vyAiqVCq+//joWLlyI1NRU3HLLLXjuueeEx9PS0nD99dfjH//4BzQaDUJDQ/HFF1/glltuAQDk5eUhJiYGP/30E6ZMmdKk99RqtVAqldBoNFAoFC05fEIIIYS0kY52/W52nyCTyYQNGzagqqoKw4cPBwCMGjUK3333Ha5cuQKe57F7925kZWUJ4ebIkSOora3F5MmThdeJiopCamoqDhw44Pa9DAYDtFqtww8hhBBCSEuIPH1Ceno6hg8fDr1eD5lMhk2bNiElJQUAsHr1atx7772Ijo6GSCSCj48P/vWvf2HUqFEAgIKCAkgkEgQHBzu8Znh4OAoKCty+58qVK/HSSy95eqiEEEIIIW55XAlKTk7G8ePH8ccff+DBBx/E/Pnzcfr0aQAsBP3xxx/47rvvcOTIEaxatQoPPfQQduzY0eBr8jwPjuPcPr58+XJoNBrhJzc319PDJoQQQghx4HElSCKRIDExEQAwePBgHDp0CO+88w7efvttPP3009i0aROmTZsGAOjXrx+OHz+ON954AxMnTkRERASMRiPKy8sdqkFFRUUYMWKE2/f08/ODn5+fp4dKCCGEEOJWi+cJ4nkeBoMBtbW1qK2thY+P40v6+vrCbDYDYJ2kxWIxtm/fLjyen5+PkydPNhiCCCGEEEJam0eVoKeffhpTp05FTEwMKisrsWHDBuzZswdbt26FQqHAmDFj8MQTT8Df3x9xcXHYu3cvPv/8c7z55psAAKVSiYULF2LZsmVQq9VQqVR4/PHH0bdvX0ycOPGqfEBCCCGEEFc8CkGFhYW48847kZ+fD6VSiX79+mHr1q2YNGkSAGDDhg1Yvnw55s2bh7KyMsTFxWHFihV44IEHhNd46623IBKJMHfuXNTU1GDChAlYt24dfH19W/eTEUIIIYQ0oMXzBLWHjjbPACGEEEIa19Gu37R2GCGEEEK8EoUgQgghhHglCkGEEEII8UoUggghhBDilSgEEUIIIcQrUQgihBBCiFeiEEQIIYQQr0QhiBBCCCFeiUIQIYQQQrwShSBCCCGEeCUKQYQQQgjxShSCCCGEEOKVKAQRQgghxCtRCCKEEEKIV6IQRAghhBCvRCGIEEIIIV6JQhAhhBBCvBKFIEIIIYR4JQpBhBBCCPFKFIIIIYQQ4pUoBBFCCCHEK1EIIoQQQohXohBECCGEEK9EIYgQQgghXolCECGEEEK8EoUgQgghhHglCkGEEEII8UoUggghhBDilSgEEUIIIcQrUQgihBBCiFeiEEQIIYQQr0QhiBBCCCFeiUIQIYQQQrwShSBCCCGEeCUKQYQQQgjxShSCCCGEEOKVKAQRQgghxCtRCCKEEEKIV6IQRAghhBCvRCGIEEIIIV6JQhAhhBBCvBKFIEIIIYR4JY9C0Icffoh+/fpBoVBAoVBg+PDh+Pnnnx32OXPmDGbOnAmlUgm5XI5hw4bh0qVLwuMGgwGLFy9GSEgIAgMDMXPmTFy+fLl1Pg0hhBBCSBN5FIKio6Px6quv4vDhwzh8+DDGjx+PWbNm4dSpUwCA8+fPY9SoUejVqxf27NmDEydO4LnnnoNUKhVeY+nSpdi0aRM2bNiA/fv3Q6fTYfr06TCZTK37yQghhBBCGsDxPM+35AVUKhVef/11LFy4ELfeeivEYjG++OILl/tqNBqEhobiiy++wC233AIAyMvLQ0xMDH766SdMmTKlSe+p1WqhVCqh0WigUChacviEEEIIaSMd7frd7D5BJpMJGzZsQFVVFYYPHw6z2Ywff/wRPXv2xJQpUxAWFoZrrrkGmzdvFp5z5MgR1NbWYvLkycK2qKgopKam4sCBA27fy2AwQKvVOvwQQgghhLSExyEoPT0dMpkMfn5+eOCBB7Bp0yakpKSgqKgIOp0Or776Kq677jps27YNN9xwA2688Ubs3bsXAFBQUACJRILg4GCH1wwPD0dBQYHb91y5ciWUSqXwExMT4+lhE0IIIYQ4EHn6hOTkZBw/fhwVFRXYuHEj5s+fj7179yIoKAgAMGvWLDz66KMAgAEDBuDAgQP46KOPMGbMGLevyfM8OI5z+/jy5cvx2GOPCX/WarUUhAghhBDSIh5XgiQSCRITEzF48GCsXLkS/fv3xzvvvIOQkBCIRCKkpKQ47N+7d29hdFhERASMRiPKy8sd9ikqKkJ4eLjb9/Tz8xNGpFl/CCGEEEJaosXzBPE8D4PBAIlEgiFDhiAzM9Ph8aysLMTFxQEA0tLSIBaLsX37duHx/Px8nDx5EiNGjGjpoRBCCCGENJlHzWFPP/00pk6dipiYGFRWVmLDhg3Ys2cPtm7dCgB44okncMstt+Daa6/FuHHjsHXrVnz//ffYs2cPAECpVGLhwoVYtmwZ1Go1VCoVHn/8cfTt2xcTJ05s9Q9HCCGEEOKORyGosLAQd955J/Lz86FUKtGvXz9s3boVkyZNAgDccMMN+Oijj7By5Uo88sgjSE5OxsaNGzFq1CjhNd566y2IRCLMnTsXNTU1mDBhAtatWwdfX9/W/WSEEEIIIQ1o8TxB7aGjzTNACCGEkMZ1tOs3rR1GCCGEEK9EIYgQQgghXolCECGEEEK8EoUgQgghhHglCkGEEEII8UoUggghhBDilSgEEUIIIcQrUQgihBBCiFeiEEQIIYQQr0QhiBBCCCFeiUIQIYQQQrwShSBCCCGEeCUKQYQQQgjxShSCCCGEEOKVKAQRQgghxCtRCCKEEEKIV6IQRAghhBCvRCGIEEIIIV5J1N4H0Bw8zwMAtFptOx8JIYQQQprKet22XsfbW6cMQZWVlQCAmJiYdj4SQgghhHiqsrISSqWyvQ8DHN9R4pgHzGYz8vLyIJfLwXFcq72uVqtFTEwMcnNzoVAoWu11uyo6X81H56556Ly1DJ2/5qNz1zz1zxvP86isrERUVBR8fNq/R06nrAT5+PggOjr6qr2+QqGgX3IP0PlqPjp3zUPnrWXo/DUfnbvmsT9vHaECZNX+MYwQQgghpB1QCCKEEEKIV6IQZMfPzw8vvPAC/Pz82vtQOgU6X81H56556Ly1DJ2/5qNz1zwd/bx1yo7RhBBCCCEtRZUgQgghhHglCkGEEEII8UoUggghhBDilSgEEUIIIcQrUQgihBBCiFfq8CFo5cqVGDJkCORyOcLCwjB79mxkZmY67MPzPF588UVERUXB398fY8eOxalTpxz2WbNmDcaOHQuFQgGO41BRUeH0XllZWZg1axZCQkKgUCgwcuRI7N69u9FjTE9Px5gxY+Dv749u3brh73//u8PicPn5+bj99tuRnJwMHx8fLF26tFnnoim6wvnav38/Ro4cCbVaDX9/f/Tq1QtvvfVW806IB7rCuduzZw84jnP6ycjIaN5JaYKucN4WLFjg8rz16dOneSfFA13h/AHA+++/j969e8Pf3x/Jycn4/PPPPT8ZHuro506v12PBggXo27cvRCIRZs+e7bRPW14frNryvB09ehSTJk1CUFAQ1Go17rvvPuh0ukaPsa2uqx0+BO3duxeLFi3CH3/8ge3bt6Ourg6TJ09GVVWVsM9rr72GN998E++99x4OHTqEiIgITJo0SVhoFQCqq6tx3XXX4emnn3b7XtOmTUNdXR127dqFI0eOYMCAAZg+fToKCgrcPker1WLSpEmIiorCoUOH8O677+KNN97Am2++KexjMBgQGhqKZ555Bv3792/hGWlYVzhfgYGBePjhh7Fv3z6cOXMGzz77LJ599lmsWbOmhWenYV3h3FllZmYiPz9f+ElKSmrmWWlcVzhv77zzjsP5ys3NhUqlwpw5c1p4dhrXFc7fhx9+iOXLl+PFF1/EqVOn8NJLL2HRokX4/vvvW3h2GtbRz53JZIK/vz8eeeQRTJw40eU+bXl9sGqr85aXl4eJEyciMTERf/75J7Zu3YpTp05hwYIFDR5fm15X+U6mqKiIB8Dv3buX53meN5vNfEREBP/qq68K++j1el6pVPIfffSR0/N3797NA+DLy8sdthcXF/MA+H379gnbtFotD4DfsWOH2+P54IMPeKVSyev1emHbypUr+aioKN5sNjvtP2bMGH7JkiVN/bgt1tnPl9UNN9zA33HHHY1+3tbUGc+du/dsS53xvNW3adMmnuM4Pjs7u0mfuTV1xvM3fPhw/vHHH3d43pIlS/iRI0c2/YO3go527uzNnz+fnzVrVoP7tPX1wepqnbePP/6YDwsL400mk7Dt2LFjPAD+7Nmzbo+nLa+rHb4SVJ9GowEAqFQqAMDFixdRUFCAyZMnC/v4+flhzJgxOHDgQJNfV61Wo3fv3vj8889RVVWFuro6fPzxxwgPD0daWprb5/3+++8YM2aMw2yYU6ZMQV5eHrKzsz38dK2vK5yvY8eO4cCBAxgzZkyTj681dOZzN3DgQERGRmLChAlNau5oTZ35vFmtXbsWEydORFxcXJOPr7V0xvNnMBgglUodnufv74+DBw+itra2ycfYUh3t3HUWV+u8GQwGSCQSh9Xi/f39AbBuD+605XW1U4Ugnufx2GOPYdSoUUhNTQUAoRQZHh7usG94eHiDZcr6OI7D9u3bcezYMcjlckilUrz11lvYunUrgoKC3D6voKDA5XvbH1t76eznKzo6Gn5+fhg8eDAWLVqEe+65p8nH11Kd9dxFRkZizZo12LhxI7799lskJydjwoQJ2LdvX5OPryU663mzl5+fj59//rlNf9+sOuv5mzJlCv71r3/hyJEj4Hkehw8fxqeffora2lqUlJQ0+RhboiOeu87gap638ePHo6CgAK+//jqMRiPKy8uFprP8/Hy3z2vL62qnCkEPP/ww/vrrL3z11VdOj3Ec5/BnnuedtjWE53k89NBDCAsLw6+//oqDBw9i1qxZmD59uvCX1adPH8hkMshkMkydOrXB93a1va119vP166+/4vDhw/joo4/w9ttvu/wcV0tnPXfJycm49957MWjQIAwfPhwffPABpk2bhjfeeKPJx9cSnfW82Vu3bh2CgoJcdmK92jrr+XvuuecwdepUDBs2DGKxGLNmzRL6ffj6+jb5GFuio567ju5qnrc+ffrgs88+w6pVqxAQEICIiAh0794d4eHhwu9Fe19XRa36alfR4sWL8d1332Hfvn2Ijo4WtkdERABg6TAyMlLYXlRU5JQkG7Jr1y788MMPKC8vh0KhAAB88MEH2L59Oz777DM89dRT+Omnn4TSrrWkFxER4ZRMi4qKADin6LbUFc5XQkICAKBv374oLCzEiy++iNtuu63Jx9hcXeHc2Rs2bBjWr1/f5ONrrq5w3niex6effoo777wTEomkycfWGjrz+fP398enn36Kjz/+GIWFhUJFUi6XIyQkxNNT4bGOeu46uqt93gDg9ttvx+23347CwkIEBgaC4zi8+eabwvd7e19XO3wliOd5PPzww/j222+xa9cu4cRZJSQkICIiAtu3bxe2GY1G7N27FyNGjGjy+1RXVwOAQ9ul9c9msxkAEBcXh8TERCQmJqJbt24AgOHDh2Pfvn0wGo3Cc7Zt24aoqCjEx8d79FlbQ1c9XzzPw2AwNPn4mqOrnrtjx445fJG1tq503vbu/f/27R8ktSiOA/h5hOmNutJ1UCFwaAyiaKjBwsUmI2gJxaam9oagwcaCICppMEiopYYUApt7o0Qc6aZ4L0GjUxANjX3f0EuMfNl7/sF37/cDdzuce/wO/r7DuT/F/f29WF5e/va5mmWl/BwOhxgaGhI9PT3i9PRURCKRT+9rpW7Prlt1KrdaXq9X9Pf3i7OzM+FyuUQ4HBZCdMFc/afr1B20srICt9uNq6srVCqV6vPy8lJds7m5CbfbjUwmA13XEY1G4ff78fz8XF1TqVQgpcTh4WH1lr+UEo+PjwDebv97PB4sLCygUCjAMAysrq7C4XCgUCj88XxPT0/wer2IRqPQdR2ZTAaqqmJ7e/vDOiklpJSYmJhALBaDlBLFYrHFaVkjr2QyiYuLC5imCdM0cXR0BFVVsb6+3vK8alkhu52dHWSzWZimibu7O6ytrUEIgfPz8zYk9sYKub2Lx+OYnJxsYTqNWSE/wzBwcnIC0zSRz+exuLgITdPw8PDQ+sBqdHt2AFAsFiGlxNzcHEKhUHUW1OrUfHjXqdwAYH9/Hzc3NzAMA8lkEoqiYHd398vzdXKudn0JEkLUfdLpdHXN6+srEokEfD4fnE4nZmZmoOv6h30SiUTDfa6vrzE7OwtN0zAwMICpqSlcXl42POPt7S2mp6fhdDrh8/mwsbHx6TO+eu8OBALNRFOXFfLa29vDyMgI+vr6oKoqxsfHcXBw8OEzy3awQnZbW1sYHh6Gy+XC4OAggsEgcrlc09l8xQq5AW9/vIqiIJVKNZXH37JCfqVSCWNjY1AUBaqqYn5+HuVyuelsGvkfsgsEAnX3bvQ72jEfvnpfu3JbWlqCpmno7e3F6Ogojo+Pv3XGTs3VH783IiIiIrKVrr8TRERERNQOLEFERERkSyxBREREZEssQURERGRLLEFERERkSyxBREREZEssQURERGRLLEFERERkSyxBREREZEssQURERGRLLEFERERkS78AezTxpehcqNcAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Heidelberg_30\n", + "RMSE for Heidelberg_30 (Time: 12:00-17:00): 7.653180633677891\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Hohenpeissenberg_131\n", + "RMSE for Hohenpeissenberg_131 (Time: 0:00-7:00): 4.500672670985617\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Hyltemossa_150\n", + "RMSE for Hyltemossa_150 (Time: 12:00-17:00): 4.451277813256869\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Ispra_100\n", + "RMSE for Ispra_100 (Time: 12:00-17:00): 7.200474834686076\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkEAAAGxCAYAAABlfmIpAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAApeFJREFUeJzs3Xd8VFX6P/DPnZ6p6Y2EhN5RAQuooIJYQewF29p2LSiuuq76dVd/uy6uirq4NnYtq+iyNqyIIAKKWCiC9BYS0nsmmUyfub8/Tu6de2fuJDPJpJHn/XrlJZm5M3MnJjOfec5zzuF4nudBCCGEEDLAqHr7BAghhBBCegOFIEIIIYQMSBSCCCGEEDIgUQgihBBCyIBEIYgQQgghAxKFIEIIIYQMSBSCCCGEEDIgUQgihBBCyIBEIYgQQgghAxKFIEIAvPnmm+A4Dlu2bOntU+mS3bt344477sDUqVNhMpnAcRzWr18f9fjly5fj+OOPh8FgQG5uLhYuXAiHwxFxnMPhwMKFC5GbmwuDwYDjjz8ey5cvj+vcbrrpJpx77rmyy55//nlccsklGDJkCDiOwxlnnKF4248++ghXX301hg8fjqSkJBQWFmL+/Pk4ePBgXOfwwgsvYPTo0dDr9RgyZAgef/xx+Hy+iONqampw4403Ij09HUajEVOnTsXatWtjfpyNGzfilltuweTJk6HX68FxHIqLiyOOE37von09+eSTMT3etm3bMGvWLJjNZiQnJ+OSSy5BUVFRp38Gjz76KCZNmoRgMBjzcyakX+IJIfwbb7zBA+A3b97c26fSJW+++Safk5PDn3/++fycOXN4APy6desUj122bBkPgL/lllv4b775hn/llVd4m83Gn3322RHHnn322XxycjL/yiuv8N988w1/yy238AD4d955J6bz2rZtG69SqSJ+vqNGjeInTZrE33TTTXxGRgY/Y8YMxdufdNJJ/Ny5c/nXX3+dX79+Pf/222/zY8aM4c1mM79r166YzuGvf/0rz3Ec/9BDD/Hr1q3jn3rqKV6n0/G33nqr7Di3282PHz+ez8vL45ctW8avXr2av+iii3iNRsOvX78+psd67LHH+IKCAn7evHn8GWecwQPgjxw5EnFcTU0N/8MPP0R8nX322TwAft++fR0+1t69e3mLxcKffvrp/BdffMF/+OGH/Lhx4/jc3Fy+pqamUz+DpqYmPjk5mX/99ddjer6E9FcUggjheycEeb1e3ufzJfQ+A4GA+O/3338/agjy+/18Tk4OP3v2bNnl77zzDg+AX7lypXjZF198wQPg3333XdmxZ599Np+bm8v7/f4Oz+uKK67gTznllHbPd9y4cVFDUHV1dcRl5eXlvFar5W+++eYOH7+uro43GAz8bbfdJrv8iSee4DmO43fv3i1e9uKLL/IA+E2bNomX+Xw+fuzYsfxJJ53U4WPxvPx5Pf3001FDkBKHw8GbzWb+tNNOi+n4yy+/nE9PT+ftdrt4WXFxMa/Vavk//OEP4mXx/Ax4nufvuusufuTIkXwwGIzpPAjpj2g4jJAoioqKcNVVVyE3Nxd6vR5ZWVmYOXMmtm/fLh5TWFiICy+8ECtWrMDEiRNhMBgwdOhQLFmyRHZf69evB8dxePvtt3Hfffdh0KBB0Ov1OHToEGpra3HHHXdg7NixMJvNyMzMxFlnnYXvvvsu7nNWqWL7k/7xxx9RWVmJ3/zmN7LLL7/8cpjNZqxYsUK8bMWKFTCbzbj88stlx/7mN79BRUUFfvrpp3Yfq7q6GitWrMB1113X6fPNzMyMuCw3Nxd5eXkoLS3t8ParVq2C2+2OeL6/+c1vwPM8Pv74Y/GyFStWYNSoUZg6dap4mUajwbXXXouff/4Z5eXlHT5erM9Lyf/+9z84HA7ccsstHR7r9/vx+eef49JLL4XVahUvLygowJlnnin7/xjPzwAArrvuOhw4cADr1q3r9HMhpK+jEERIFOeffz62bt2Kp556CmvWrMHLL7+ME044AU1NTbLjtm/fjoULF+Lee+/FihUrMG3aNNxzzz145plnIu7zoYcewtGjR/HKK6/gs88+Q2ZmJhoaGgAAf/7zn/HFF1/gjTfewNChQ3HGGWe028/TFbt27QIATJw4UXa5VqvF6NGjxeuFY8eMGQONRiM7Vrit9Fglq1evhs/nw5lnnpmIUxcVFRWhpKQE48aNk13+2GOPRfRCCec4YcIE2bE5OTlIT0+PeL7hPxcg9Hx3796dqKeg6LXXXoPVao0IncXFxeA4DjfeeKN42eHDh+FyuaKe76FDh+B2uwHE9zMAgMmTJ8NsNuOLL75IxNMipE/SdHwIIQNPfX099u/fj+effx7XXnutePkll1wScWxFRQV++eUXHHfccQCA8847DzU1NfjLX/6CO+64A0ajUTx22LBheP/992W3T01NxUsvvSR+HwgEcM4556C4uBhLliyJ2izcFfX19eJjh0tNTZU18dbX12Po0KGKx0nvK5offvgBSUlJGD16dBfOWM7v9+Pmm2+G2WzGvffeK7tOpVJBrVaD4zjxsvr6euj1ephMpoj7Sk1NlT2H+vr6qD8X4frusm/fPmzatAm//e1vZb83AMBxHNRqNdRqtexcpecWfr48z6OxsRE5OTlx/QwAQK1W47jjjsP333+fiKdGSJ9ElSBCFKSmpmLYsGF4+umn8eyzz+KXX36JOlNm3LhxYgASXHPNNWhubsa2bdtkl1966aWK9/HKK69g0qRJMBgM0Gg00Gq1WLt2Lfbu3ZuYJxSFNCi0d3m04zq6DmAhMSMjo8PjYsXzPG6++WZ89913eOutt5Cfny+7/k9/+hP8fj9mzJgR83l25vkGg0H4/X7xKxAIxPtUIrz22msAoDgUVlBQAL/fLx4T7/nGc5wgMzMzpuE/QvorCkGEKOA4DmvXrsU555yDp556CpMmTUJGRgbuvvtutLS0yI7Nzs6OuL1wWfin65ycnIhjn332Wdx+++04+eST8eGHH+LHH3/E5s2bce6558LlciXwWYWkpaUpnh8ANDQ0yCoLaWlpUY8DlKsQUi6XCwaDoSunK+J5HrfccguWLVuGN998ExdddFFMt0tLS4Pb7YbT6Yy4rrPP96abboJWqxW/Zs6c2ZmnJPL5fHjrrbdw3HHHYcqUKTHdpqP/jxzHITk5WTw21p+BwGAwdNvvICF9AQ2HERJFQUGB+Kn7wIEDeO+99/DYY4/B6/XilVdeEY+rqqqKuK1wmfAmJVD6tL1s2TKcccYZePnll2WXh4etRBL6Qnbu3ImxY8eKl/v9fuzbtw9XX3217Nj//ve/8Pv9sr6gnTt3AgDGjx/f7mOlp6dHVMQ6QwhAb7zxBl577TXZMGVHpM/35JNPFi+vqqpCXV2d7DlMmDBBfG5S4c/3sccew1133SVeb7FY4ntCYT7//HPU1NTg0Ucfjfk2w4YNQ1JSUtTzHT58uBhA4/kZCBoaGpCenh7vUyGk36BKECExGDlyJP7v//4PEyZMiHhD3717N3bs2CG77N1334XFYsGkSZM6vG+O46DX62WX/frrr/jhhx+6fuJRnHzyycjJycGbb74pu/yDDz6Aw+GQ9T5dfPHFcDgc+PDDD2XH/uc//0Fubq7sDVXJ6NGjUV9fD7vd3unz5Xket956K9544w28+uqrETOcOnLuuefCYDBEPF9hscJ58+aJl1188cXYt2+fbNab3+/HsmXLcPLJJyM3NxcAmxk4ZcoU8WvUqFGdfn4AGwozGAyYP39+zLfRaDSYM2cOPvroI1loPnr0KNatWyf7/xjPz0BQVFQkC8mEHHN6cXo+IX1G+DpBO3bs4E8//XR+yZIl/JdffsmvXbuWf+SRR3iVSsU//PDD4u0KCgr4QYMG8YMHD+Zff/11/ssvv+Tnz5/PA+D//ve/i8etW7eOB8C///77EY/9pz/9iec4jv/Tn/7Er127ln/ppZf47OxsftiwYXxBQUFcz6O1tZV///33+ffff5+/7777eAD8Y489xr///vuytX94nufffvttHgB/22238evWreOXLl3KJycnR10sMSUlhV+6dCn/zTff8LfeeisPgF+2bFmH5/Ttt9/yAPivvvoq4rrNmzeL55ufn8+PHTtW/L64uFg87q677uIB8DfddFPEwoLbtm2T3efjjz/Oq9XqiIUNhYUCH374YX79+vX8008/zev1esXFEseNG8fn5+fz77zzDr9mzRr+4osvjmuxxJqaGvF5XH/99TwA/qWXXuLff/99xfsoLy/n1Wo1f80110S9z+LiYl6tVvM33XST7PK9e/fyZrOZnz59Or9y5Ur+o48+4sePH9/uYokd/Qx4nq0rBIBfsmRJTM+ZkP6IQhAhfGQIqq6u5m+88UZ+9OjRvMlk4s1mMz9x4kT+ueeeky0OWFBQwF9wwQX8Bx98wI8bN47X6XR8YWEh/+yzz8ruv70Q5PF4+Pvvv58fNGgQbzAY+EmTJvEff/wxf8MNN8Qdgo4cOcIDUPxSuq93332XnzhxIq/T6fjs7Gz+7rvv5ltaWiKOa2lp4e+++24+Ozub1+l0/MSJE/n//ve/MZ1TIBDgCwsL+TvuuCPiuhtuuCHq+b7xxhvicQUFBTE/rz//+c9RF4n8xz/+wY8cOZLX6XT84MGD+T//+c+81+uNOK6qqoq//vrr+dTUVN5gMPCnnHIKv2bNmpieL8+H/n8rfSktCPnEE0/wAPhvvvkm6n0K/29vuOGGiOu2bNnCz5w5kzcajbzVauXnzZvHHzp0SPF+Yv0ZvPbaa7xWq+Wrqqpift6E9Dccz/N8NxaaCDmmFRYWYvz48fj88897+1T6tMWLF+OJJ55AeXk5kpKSevt0SAxOP/10DB48GO+8805vnwoh3YZ6gggh3e7OO++EzWbDiy++2NunQmLw7bffYvPmzfjLX/7S26dCSLeiEERIPxAIBGRr0oR/JWKNmu5kMBjw9ttvRzSAk76pvr4eb731luIimYQcS2g4jJB+4IwzzsCGDRuiXl9QUCBb5ZkQQkjHKAQR0g/s37+/3XWD9Hp9xJ5QhBBC2kchiBBCCCEDEvUEEUIIIWRA6pfbZgSDQVRUVMBisSRsU0ZCCCGEdC+e59HS0oLc3FyoVL1fh+mXIaiioiJi52hCCCGE9A+lpaXIy8vr7dPonyFI2KiwtLQUVqu1l8+GEEIIIbFobm5Gfn5+lzccTpR+GYKEITCr1UohiBBCCOln+korS+8PyBFCCCGE9AIKQYQQQggZkCgEEUIIIWRA6pc9QYQQQkgi8TzfL/bh6w+0Wi3UanVvn0ZMKAQRQggZ0LxeLyorK+F0Onv7VI4JHMchLy8PZrO5t0+lQxSCCCGEDFjBYBBHjhyBWq1Gbm4udDpdn5m51B/xPI/a2lqUlZVhxIgRfb4iRCGIEELIgOX1ehEMBpGfnw+j0djbp3NMyMjIQHFxMXw+X58PQdQYTQghZMDrC1s4HCv6UyWN/q8TQgghZECiEEQIIYSQAYlCECGEEEIGJApBhBBCSD904403Yt68eeL3VVVVWLBgAYYOHQq9Xo/8/HzMmTMHa9euld1u06ZNOP/885GSkgKDwYAJEyZg8eLFEWskcRwHg8GAkpIS2eXz5s3DjTfe2F1Pq0dRCCKEEEL6ueLiYkyePBnffPMNnnrqKezcuROrVq3CmWeeiTvvvFM8bsWKFZgxYwby8vKwbt067Nu3D/fccw+eeOIJXHXVVeB5Xna/HMfhT3/6U08/nR5DU+QJIYSQfu6OO+4Ax3H4+eefYTKZxMvHjRuHm266CQDQ2tqKW2+9FXPnzsXSpUvFY2655RZkZWVh7ty5eO+993DllVeK1y1YsACLFy/G/fffjwkTJvTcE+ohVAkihBBC+rGGhgasWrUKd955pywACZKTkwEAq1evRn19Pe6///6IY+bMmYORI0fiv//9r+zyadOm4cILL8RDDz3ULefe26gSRAghhCi5/XagvLznHm/QIODll+O+2aFDh8DzPEaPHt3ucQcOHAAAjBkzRvH60aNHi8dILVq0CBMnTsR3332H008/Pe7z68soBBFCCCFKOhFIeoPQxxPrIoXhfT/Sy5XuY+zYsbj++uvx4IMPYtOmTZ0/0T6IhsMIIYSQfmzEiBHgOA579+5t97iRI0cCQNTj9u3bhxEjRihe9/jjj+OXX37Bxx9/3KVz7WsoBBFCCCH9WGpqKs455xy8+OKLaG1tjbi+qakJADB79mykpqZi8eLFEcd8+umnOHjwIK6++mrFx8jPz8ddd92Fhx9+OGIqfX/WpRC0aNEicByHhQsXipc5HA7cddddyMvLQ1JSEsaMGYOXw0qKHo8HCxYsQHp6OkwmE+bOnYuysrKunAohhBAyYL300ksIBAI46aST8OGHH+LgwYPYu3cvlixZgqlTpwIATCYTXn31VXzyySe47bbb8Ouvv6K4uBivvfYabrzxRlx22WW44ooroj7GQw89hIqKCnz99dc99bS6XadD0ObNm7F06VJMnDhRdvm9996LVatWYdmyZdi7dy/uvfdeLFiwAJ988ol4zMKFC7FixQosX74cGzduhMPhwIUXXnhMpUtCCCGkpwwZMgTbtm3DmWeeifvuuw/jx4/H2WefjbVr18oKEZdddhnWrVuH0tJSTJ8+HaNGjcKzzz6LRx55BMuXL2+3ryg1NRUPPvgg3G53TzylHsHx0Tqk2uFwODBp0iS89NJL+Otf/4rjjz8ezz//PABg/PjxuPLKK/Hoo4+Kx0+ePBnnn38+/vKXv8ButyMjIwNvv/22uBZBRUUF8vPzsXLlSpxzzjkdPn5zczNsNhvsdjusVmu8p08IIYQAANxuN44cOYIhQ4bAYDD09ukcE9r7mfa19+9OVYLuvPNOXHDBBZg1a1bEdaeddho+/fRTlJeXg+d5rFu3DgcOHBDDzdatW+Hz+TB79mzxNrm5uRg/fnzUrnOPx4Pm5mbZFyGEEEJIV8Q9RX758uXYtm0bNm/erHj9kiVLcOuttyIvLw8ajQYqlQr//ve/cdpppwFge5vodDqkpKTIbpeVlYWqqirF+1y0aBEef/zxeE+VEEIIISSquCpBpaWluOeee7Bs2bKoZcMlS5bgxx9/xKeffoqtW7di8eLFuOOOOzpspIq2PgHAmrHsdrv4VVpaGs9pE0IIIYREiKsStHXrVtTU1GDy5MniZYFAAN9++y3++c9/wm634+GHH8aKFStwwQUXAAAmTpyI7du345lnnsGsWbOQnZ0Nr9eLxsZGWTWopqYG06ZNU3xcvV4PvV7fmedHCCGEEKIorkrQzJkzsXPnTmzfvl38mjJlCubPn4/t27cjEAjA5/NBpZLfrVqtRjAYBMCapLVaLdasWSNeX1lZiV27dkUNQYQQQgghiRZXJchisWD8+PGyy0wmE9LS0sTLZ8yYgQceeABJSUkoKCjAhg0b8NZbb+HZZ58FANhsNtx888247777kJaWhtTUVHF3WqVGa0IIIYSQ7pDwFaOXL1+OE088EfPnz8fYsWPx5JNP4oknnsDvfvc78ZjnnnsO8+bNwxVXXIFTTz0VRqMRn332GdRqdaJP55hy99139/YpEEIIIceMTq0T1Nv62joDPWXOnDn47LPPevs0CCHkmEHrBCXeMb9OECGEEEJIf0chqB9pbzlzQgghhMSHQhAhhBDSD914442YN2+e+H1VVRUWLFiAoUOHQq/XIz8/H3PmzMHatWtlt9u0aRPOP/98pKSkwGAwYMKECVi8eHHE/p3r1q3DmWeeidTUVBiNRowYMQI33HAD/H5/Tzy9HkEhiBBCCOnniouLMXnyZHzzzTd46qmnsHPnTqxatQpnnnkm7rzzTvG4FStWYMaMGcjLy8O6deuwb98+3HPPPXjiiSdw1VVXQWgT3r17N8477zyceOKJ+Pbbb7Fz50688MIL0Gq14pI3x4K4t80ghBBCSN9yxx13gOM4/PzzzzCZTOLl48aNw0033QQAaG1txa233oq5c+di6dKl4jG33HILsrKyMHfuXLz33nu48sorsWbNGuTk5OCpp54Sjxs2bBjOPffcnntSPYBCECGEEBLG7Xbj0KFDPfqYw4cP79QMtYaGBqxatQpPPPGELAAJkpOTAQCrV69GfX097r///ohj5syZg5EjR+K///0vrrzySmRnZ6OyshLffvstpk+fHvc59Rc0HEYIIYT0Y4cOHQLP8xg9enS7xx04cAAAMGbMGMXrR48eLR5z+eWX4+qrr8aMGTOQk5ODiy++GP/85z/R3Nyc2JPvZVQJIoQQQsIYDIaIHRL6KqGPJ9YZxNGWB5RuZK5Wq/HGG2/gr3/9K7755hv8+OOPeOKJJ/D3v/8dP//8M3JychJz8r2MKkGEEEJIPzZixAhwHIe9e/e2e9zIkSMBIOpx+/btw4gRI2SXDRo0CNdddx1efPFF7NmzB263G6+88kpiTrwPoBBECCGE9GOpqak455xz8OKLL6K1tTXi+qamJgDA7NmzkZqaisWLF0cc8+mnn+LgwYO4+uqroz5OSkoKcnJyFB+jv6IQ1M/0w11OCCGEdLOXXnoJgUAAJ510Ej788EMcPHgQe/fuxZIlSzB16lQAbMPzV199FZ988gluu+02/PrrryguLsZrr72GG2+8EZdddhmuuOIKAMCrr76K22+/HatXr8bhw4exe/duPPjgg9i9ezfmzJnTm081oagnqI/x+/1wOp2Ke6rodDr4fD7odLpeODNCCCF91ZAhQ7Bt2zY88cQTuO+++1BZWYmMjAxMnjwZL7/8snjcZZddhnXr1uFvf/sbpk+fDpfLheHDh+ORRx7BwoULxZ6gk046CRs3bsTvfvc7VFRUwGw2Y9y4cfj4448xY8aM3nqaCUcbqPYxDQ0N+PnnnxXXYrjmmmuwdOlSmM3mXjgzQgg59tAGqolHG6iSTlOr1RFLlwt0Oh28Xm8PnxEhhBBybKIQ1Md0FII8Hk8PnxEhhBBybKIQ1MdQJYgQQgjpGRSC+pj2QpBer6cQRAghhCQIhaA+hipBhBDS8/rhHKE+qz/9LCkE9TEqlQrBYFDxOgpBhBCSWFqtFgDgdDp7+UyOHcL7lFqt7uUz6RitE9THtLf3C4UgQghJLLVajeTkZNTU1AAAjEZjzHtwkUjBYBC1tbUwGo3QaPp+xOj7Z0hEFIIIISTxsrOzAUAMQqRrVCoVBg8e3C/CJIWgfoRCECGEJB7HccjJyUFmZiZ8Pl9vn06/p9PpoFL1j24bCkH9CIUgQgjpPmq1ul/0sZDE6R9RjQCgEEQIIYQkEoWgPmD16tUdHhMMBmEwGCgEEUIIIQlCIagPKCsr6/CYQCAAvV4Pv9/fA2dECCGEHPsoBPUBsewH5vf7+8V0Q0IIIaS/oBDUB7jd7g6PoRBECCGEJBaFoD4glkpQIBCgWQuEEEJIAlEI6mU8z1MliBBCCOkFFIJ6WTAYjGlxLiEE9aeN6QghhJC+jEJQL4s1BNFwGCGEEJJYFIJ6WSAQiGnau1AJ6g97sRBCCCH9AYWgXhYIBOIaDiOEEEJIYlAI6mWxVoJoOIwQQghJLApBvYwqQYQQQkjvoBDUywKBAAKBQEzHUQgihBBCEodCUC8LBoMxDXP5/X4aDiOEEEISiEJQLwsEAlCpOv7fQMNhhBBCSGJRCOplsQ5z0XAYIYQQklgUgnpZrLO+aDiMEEIISSwKQb2MhsMIIYSQ3tGlELRo0SJwHIeFCxfKLt+7dy/mzp0Lm80Gi8WCU045BUePHhWv93g8WLBgAdLT02EymTB37lyUlZV15VT6rVgrQbROECGEEJJYnQ5BmzdvxtKlSzFx4kTZ5YcPH8Zpp52G0aNHY/369dixYwceffRRGAwG8ZiFCxdixYoVWL58OTZu3AiHw4ELL7wwpqnix5p4hsOoEkQIIYQkTqfeVR0OB+bPn49//etf+Otf/yq77pFHHsH555+Pp556Srxs6NCh4r/tdjtee+01vP3225g1axYAYNmyZcjPz8fXX3+Nc845pzOn1G8Fg0EaDiOEENJnVFRUIDc3t7dPo0d0qhJ055134oILLhBDjCAYDOKLL77AyJEjcc455yAzMxMnn3wyPv74Y/GYrVu3wufzYfbs2eJlubm5GD9+PDZt2qT4eB6PB83NzbKvYwUNhxFCCOlLPvzww94+hR4Tdwhavnw5tm3bhkWLFkVcV1NTA4fDgSeffBLnnnsuVq9ejYsvvhiXXHIJNmzYAACoqqqCTqdDSkqK7LZZWVmoqqpSfMxFixbBZrOJX/n5+fGedp8V69R3qgQRQgjpCQOpRzeud9XS0lLcc889WL16tazHRxAMBgEAF110Ee69914AwPHHH49NmzbhlVdewYwZM6LeN8/z4DhO8bqHHnoIv//978Xvm5ubj5kgRD1BhBBC+pKBFILiqgRt3boVNTU1mDx5MjQaDTQaDTZs2IAlS5ZAo9EgLS0NGo0GY8eOld1uzJgx4uyw7OxseL1eNDY2yo6pqalBVlaW4uPq9XpYrVbZ17Ei1inysR5HCCGEdIXL5YppY+9jQVzvqjNnzsTOnTuxfft28WvKlCmYP38+tm/fDr1ejxNPPBH79++X3e7AgQMoKCgAAEyePBlarRZr1qwRr6+srMSuXbswbdq0BDyl/iWeXp9olTJCCCEkUTIzM1FTU9Pbp9Ej4hpfsVgsGD9+vOwyk8mEtLQ08fIHHngAV155JaZPn44zzzwTq1atwmeffYb169cDAGw2G26++Wbcd999SEtLQ2pqKu6//35MmDAhotF6IIh1A1VCCCGkJ2RlZaGmpgaDBg3q7VPpdglvMrn44ovxyiuvYNGiRbj77rsxatQofPjhhzjttNPEY5577jloNBpcccUVcLlcmDlzJt58880BGQZo1hchhJC+JCsrC9XV1b19Gj2iyyFIqPBI3XTTTbjpppui3sZgMOCFF17ACy+80NWH7/c6E4LaayInhBBCuiI5OTmib/dYRZ22vSzehme1Wi3OwiOEEEISjeM48Dzf26fRIygE9bJ4K0EajQZ+v78bz4gQQshAN1BGGygE9TIKQYQQQkjvoBDUy2INQUIqpxBECCGkOw2UKhBAIajXCVPkOxp/Fa6nEEQIIYQkBoWgXhYIBGAwGGIONhSCCCGEdKeB0hQNUAjqdYFAAHq9vsMlymk4jBBCSE+ZMGFCb59Cj6AQ1MuESlBHIYiGwwghpP9wOp34+uuve/s0Oi18d4hjFYWgXsbzPHQ6HQ2HEULIMcTr9aKpqam3TyNuA2koDKAQ1CdoNBoaDiOEkGOIz+frlzux+/1+aDQJ31Grz6IQ1AdotdoOgw0NhxFCSP/h9/v75Wu1z+eDTqfr7dPoMRSC+oBYKkHSY/vjHxYhhAwk/bUS5PP5oNVqe/s0egyFoD5Aq9XK/liUxmRpOIwQQvqP/lwJohBEetQxPRx25EhvnwEhhPS4/loJ8nq9FIJIzzqmh8PuuKO3z4AQQnocVYL6BwpBfUAslaB+OxzmdALBYG+fBSGE9Cifz9e/XqvbUAgiPctuh+af/zx2F0v0eoFAoLfPghBCepTf7++Xw2EUgkjPcruhraw8dofDvF6gH74QEEJIV/h8PgT7YRWcpsiTnhUIQOvxHLvDYV4v0J/OlxBCEsDv9/fLigpVgga4/fv3w+Vy9dwD+v3QuN2ySpAQeKT67XCYx0OVIELIgNOnwkRZGWC3x3RonzrvHkAhKExJSQmcTmfPPWAgAK3bfezuHUaVIELIANSntp94913gp59iOpSmyA9warW6Z0NGIACNyxXRExS+YCINhxFCSP/RpyoqLS0xT1DpU+fdAygEhdFoNAj05GymQABal0sWbNRqddRzUKlU/avZjhqjCSEDUF+qBDnq6+HzeGI6lkLQANcXKkHthaB+x+OhShAhZMDx+Xx9JgT95bvvcLisLKZjKQQNcL1RCVK5XLLhr14JQeXlgMKeZV1Gw2GEkAGoxytB7bx+t7pcMMZ4LuIU+fvvBw4eTNTZ9VkUgsIo9txUVACHDnXPA/r9bFVliV4JQX/4A1Bbm9j75HkaDiOEDEg8zyvO9E209evXo3L1auDxx6Meo/L5EIzxdVisBHk8wABYL6hv1Or6EMXhsJ9/ZkFo+PDEP2Ag0DdCUGMjCyyJJPwcqRJECBmAeiIEFRUVgdu5EznthBy1zwd/jCEoGAxCpVKx94MBEIKoEhRGcTjM72epOA4HDx5Ec3NzxwcGAqxSEmNjdLdpaEh8CBJ+ZlQJIoSQbqHX61Hxyy9AO+vbaXw+BOL9MOr1AgOgN4hCUBjFSpDPB7jdcd3Pnj17UF9f3/GBgQCgUsmCwjFTCRLujypBhBDSLVQqFYLV1REjClIarxf+eF/ffT6qBA1EUStBcYYgu90OTyzVo0AAsFpllaZeC0FxVrs6RCGIEEK6l9cLmEztvkepvd6Yh8Nk90shaOBRrAR1IgQ1NTX1nxDE891bCaLhMEII6R4lJeAKC6Mvhsjz0Hi9CHQmBNFw2MCTqJ6glpaW2EOQzSYLID0eglpb2XPsjhCk01EliBBCuktxMfjCwohdBkQeD5v1HG8ICgYBtbrr59fHUQgKk6hKkFarjS0E+f0sBPViJWjH99+zf3RHY7TJRJUgQgjpLnY70goL0RDtdbalBeqkpP613VIPohAURrES1InGaL1eH1sICgZ7vRL0wYcfRpxDQni9+FGjoUoQIYR0g0DbYrvDx47F4WiN0c3N0BiN8Q+HDRAUgsIkqhIUcwiKtxK0cSMbvkqgPfv3A1lZ3RKCdnAchSBCCOkG9fX1SPP7UTBuHIqjhCBvQwMMJlP8w2EDBIWgMInqCYo5BIX3BG3bBvXKlRHnII73fvwxUFcX17l0hPd44MnI6JYQ1KzR0HAYIWRAitqnkyDV1dXI8vuhTUuDL8rG2o0VFchITqYQFAWFoDCJqgTpdDp4YwgVvN8vnx1WWwt1ba0sBAUCAaiFBjWnM/osgE4qtNlQbDZ3S0+QXaWiShAhhHSDmpoaZGq1QDv7gjVWViI9Le3Y2ZQ7wSgEhUnUOkEqVYw/2vBKkNcLdSAgO4e6ujqkpaWxb5xO1keUQMNMJhzWaLplnaBmCkGEkAGqu7fNqKurQ7qwlg/HKVaeGmtqkJGZSZWgKCgEhUnUitGx4oQQJAQQrxdqvx+BQEAcTquurkZWVha7PsGVIJ7nkcLzaEpK6nIl6IsvvpBf4PXCzvM0HEYIId0gEAhA3Ra08oxGlBUXRxzTWFeHjOxsmh0WBYWgMInoCYprHDh8dpjHI1aC/vWvfwFgJU9ZCEpgJcjj8UDvdidkdtj69euxefPm0AVeL1oAqgQRQkg3Oz4rC9ulr79tmhsbkZqTE//eYQMEhaAwKpWqyz1BbrcbSUlJsR3cTiWoqKgIHo+HzQCQDoclsBLU2toKk9sNLjm5SyEoEAhg8uTJ2L59e+hCjweBsH3RCCGEJAbH80BbJciWnIxmhUkzvNMJXXo6VYKioBAURnEM1+8Xf9Fi0dTUhOTk5NgOFqbISytBbSGI53mUlZUhGAyGeowSXAlqbW2FyesFbzJ1KQSVlZUhPz8fZrM5VAnzetmKoz35x3foEHD0aM89HiGE9BLe6WQTawAgKUn5A6fbDVVaGoLUGK2oSyFo0aJF4DgOCxcuVLz+t7/9LTiOw/PPPy+73OPxYMGCBUhPT4fJZMLcuXNRVlbWlVPpXn5/u9334ex2O2w2W2wHh+8dJqkE5efno7S0VH58d1SC1Gq2R0wXQtChQ4cwfPhwGAwGuIWqWVsI4nuyEvTVV4CwAjYhhBzLnE5A+MCdlARO4TU86HKxYygEKep0CNq8eTOWLl2KiRMnKl7/8ccf46effkJubm7EdQsXLsSKFSuwfPlybNy4EQ6HAxdeeGHfncLn98e1kVxclaC24bDTheM9Hqh9PgQCAWRlZaGqslJ+fHdUgjQaFvK6EIKqq6uRmZ4Om82G5uZmdqHXC41OB3+iZ521p6Eh4YtJEkIGiH/8A+jLH8jDhYcgpQ+cTieQkpLwWcXHik6FIIfDgfnz5+Nf//oXUlJSIq4vLy/HXXfdhXfeeQfasPBgt9vx2muvYfHixZg1axZOOOEELFu2DDt37sTXX3/duWeRYBFDYj5fXJWgzgyH5QnfSypBKpUK/HffAd98Ezo+wZUgp9PJKkFdDEEAwM2bB6vVCrvdzi7weKDV6eBL9PpD7amvZz8jQgiJoqioSPmKffuAxsaePZku4KQhyGiEAYDL5RKvr6qqQhbHARZLfCFI0mt0rOtUCLrzzjtxwQUXYNasWRHXBYNBXHfddXjggQcwbty4iOu3bt0Kn8+H2bNni5fl5uZi/Pjx2LRpk+LjeTweNDc3y756lDAcFuOsr+bmZliFcdqOBINsLFfom/F6xUoQALY69FdfhR67OypBajXUOh0CXVkGgOeB1ath02hCIcjrhVavh7enK0EUgggh7Vi3bp3yFQ5H4heNDRNMZEUmrBKUb7PJWig2bdqEaSkpbCQjnsf1+eIa/ejP4g5By5cvx7Zt27Bo0SLF6//+979Do9Hg7rvvVry+qqoKOp0uooKUlZWFqqoqxdssWrQINptN/MrPz4/3tLvG75cHlQ7IVnju+GD5L5tkOAwA0NIC5OezPcOAxPcEtbTApNVCbzTC05Xw4HQCXi9sVVViSA16PNAbDPDRcBghpA9pjfYakeAQpLRcyuuvv564+3c4ZCGowGpFSUmJeL3L5YJRo2ETVGIMQTzPs5+BsAjjMS6uEFRaWop77rkHy5Ytg8FgiLh+69at+Mc//oE333wz7pUyeZ6PepuHHnoIdrtd/IpoFu5ufj9gNsc8TT6u5x4Msl9QgWQ4DAD45mbggguA5cvZefh8CQ1BvtZW6CwWGMxmeDpZCQoGgzi6bx8wdCisxcViJcjtdMJqsVAliBDSpzgcjmhXJHRJD5VKFVH5OZrI2athlaB0rRa1tbXi1eJ7kUYT3/sGhSBlW7duRU1NDSZPngyNRgONRoMNGzZgyZIl0Gg0WL9+PWpqajB48GDx+pKSEtx3330oLCwEAGRnZ8Pr9aIxbNxVtiBgGL1eD6vVKvvqUUIIivHNvEub5oVVgtytrUgeOxaoqQFcLsBkSmyDm8cDmM3Qm0xwS8aS41FXV4cT8/KAs86CYf9+caVrl9MJq83Wsz1BbjeFIEJIu9oNQQl8vdJqtRHr8yRqJjTP8xE9QVzYB1kxBMVRCeI4jobDopk5cyZ27tyJ7du3i19TpkzB/PnzsX37dtx444349ddfZdfn5ubigQcewFdffQUAmDx5MrRaLdasWSPeb2VlJXbt2oVp06Yl9tklis8HmEwIxDjMIvzixRKGxGMka+uovV5xnaAcvR5ZgweH3tyt1sSGILcbMJthsFhi2/VeQVlZGfJUKmDqVODwYfFyl9MJW0pKTBvJJozRSMNhhJB2RQ1Bra0JrQRpNBr4JPfH8zzqFBY07Ayn0wmjzyerBMHlUh6JiCMEARhQlaDYpzwBsFgsGD9+vOwyk8mEtLQ08XJxZeM2Wq0W2dnZGDVqFADAZrPh5ptvxn333Ye0tDSkpqbi/vvvx4QJExQbrfsEngeMRrywdCkWPvFEDId3sRIk2brj1NRUaMeMYZ36Tifr8k/kUgJuN2AysUpQJ4fDysrKcFYgAOTkyP7QXC4XrEOGwFdRkaizbR/Ps0oZVYIIIe3orUqQz+eLmDHdWS0tLbB4vfIQ5HSCl65RJ0zq0WgoBEURVwhKlOeeew4ajQZXXHEFXC4XZs6ciTfffDP2ZuKexnGo8ftR0g0rEYupXfiv1wuVwQCXywWb1QqrVst+uXm+eytBJhM8nfwE1NraCrPdDmRlAamprJkbgMvthi0trecqQS0tQFoaeyEjhBAFfr8/+ge+BPcEhVeC3G63Yj9tZ7S0tMAs7PsIiJUgGbebfXCmSlBUXQ5B69evb/f6YoVdbQ0GA1544QW88MILXX34HrPLbsfgjIyYjo23KVym7ZevtbUVuTYb+wUWCCEo0ZWgjAwYDAa0dCVc1dQAmZnsqy2EuNxuWNPSZC8C3aqhgUIQIaRdHo8nerW+mytBQghqbyKQ6A9/AJ56KurVDocDFiC0hp3RGDEcxrtc7D1EpYp/ivwACUG0d1iMqr1eZEoDSaIJe2y1LczY2toKk88HSINXa2viQ5DQGK3Xw9PVEJSRIZtF53K5YMvMhLcnQ1Bqas88FiGkX3K73TAoBZ1AgFVSurES5PF4kJWVFdtad19/3W5waWlpgUW6iG/bcJgsXLlc7D0jjg/m4hR5aowmIp4HtFrlJckTRVrK5Dhxd3cxBJnNQG1t9wyHmUxsz6+uhCuvF9Dr2acOIQR5vbCmp/fc7DAKQYSQDrgdDuh//jnyCuFDZjdXgvLy8mTT2KNqamq3qq0YgtreQ3ieZ9UmYTgsXgNoOIxCUIx4rRZcd+6GbjDI1iFqbW2FyeUKhaCUFKCiolsrQV0KQQJpJSgYhC0tDb6e2kWeQhAhpAOe+noYlIbDHA72OtvNPUF5eXmxzRBrbgaE1fcVOBwOmBVCkFarhc/ng9/vh9bnoxDUAQpBMeB5HtBounc39LCmttbWVphaW0MhKDkZKC/vvsZog6FTw2ERY+uSEOQJBmG22eDtyRAUNjuREEKk3HV1UGxNFkJQX6gE8TwLQe0MmwUCAailw1xtPUF6vR5erxderxc6n4+9Z8SooqICmZmZ1BM00IW/sZd7PBiUldW9e8oohaCWFnkIqqiIfyO8jrRVgjQaDRSjit0O/Phj1Js3NDQgzWJhQ2GAfGVtnodOp4Ovp3YvpkoQIaQD7oYG6KNVglJTE/o6r1QJSk9Pjz5FP3QgCyLtVII4jpP3+uj1gNsNnU4Hj8fDQpDXG1cl6IcffmDr9VFPEJFq8fthsdliHg7r1DpBSiHIbo8MQd0xO8xsjn79/v3Au+9GvbqsrAx5BgObFQYAZjN4ybCeVquFtyvrJsWjvj4UgnrqMQkh/Yq7oQEGpQ9mra0JHw4LrwR5PB4kJSV1fEOhAhTPZuFtgUhWCYozBLlcLhiNRhoOI3KeQAAGsxl8T1WC1Gr4fT5oGxp6JgSZTNGvb2lhO9lHUV5ejlyDgb14AIDZLK54DY6DWq1GsKcCiVAJSkqKeZ83QsjA4mlsjN4T1A2VIL9kL8iY1wlqbmYfLNupBCl+2OZ56FasgKehIRSCOrPNFIUgIuUJBqE3m2P+hCBbpyHWACBtjNbp2JCX3R5aDVTaGN0NPUFRORzthiC73Q6bShUKUmYzrMFgbFNAE81uZwuHGY20ajQhRJHbbkeS0mtoNzZG/+c//2GPHU8IystrvxIUDEZOfd+9G/oPP4S3qoqFoDhmh5WWliI/P599Qz1BA1v4IlaeYBB6iwXqQEBM9LHQ6XSxr5YsrQTp9ewXnOfZIlcAC0MtLYnfNsPjYaEhmg4qQQDYJn5CCLJYYA0G2U7yQgDsyuKR8fD72Tg2hSBCCMCGyN94Q3aRu6kJeqXX0ARWgoQPv8JwWGlpKQDA6/VCo4lhjeLmZiA/v91KEHw+9uFZ6qefoJs1C57W1rhD0L59+zB27Fi0nSj1BJEQoRJkAuvViZVer499U1JpCNLpIntahIqQ1Qo+QSHI5/NBDbCFGqNpaQHq6/Hrr79GP6a1NRSkzGbYfL7eqQQJTCbaRJUQwhZxDVsTyNPcDH03V4ICgQDUarVYCSovLxeDERcMgn/llXY/IK/85psOK0Gcz8feN6QyMqAzGOCVhqAYh8OamppgE7bgoOEwIiVUgsxoZ+M9BR2GIOkfYlgIMgqzrQSSEIRgsGubtLapr69HuvQXnecjw1dLC+BwYPfu3dHvqLVVNhyWEQigpqam5ypA4agSRAgB2HB/2Gsw73IpVzkSWAny+/3QarViJailpQUuYUuLd9/FOT//jK9WrYp6+1e/+KJzlSAAeqMRHqeThSCXq/12B9nd+aAT3g8oBBEpTyAAvcUCE893WAmShpMOQ5Cwwy8QEYIswqapAiEEWSxQ8zyCCegLqqmpQZY0bAlbd0i1tADp6REvJDLS4TCdDlkqFQtBgp5qjBYeh0IQIQRgr1thkyQ4p1O5BSCBlSCfzweNRiNWgoxGI3vvCASAN99E2rnnor6yUvG2TqcTo9LScFCjabcSxHs8kZUggFWChBAEhFoq4nsCFIJIiJfnobNaYwpBfr9fHPPtMAT5fKGhqLZ9X8BxgE4Ha/gvt1bLglBSEjQ8L5t22ZFoVaPq6mpkSn/RtdrIT0EtLcCQIe1vSiqtBHVWIJC4hm+TiUIQIYSFoPBKkNOpGB66sxJkNpvZKEJTEzBiBJCRAatGA6fC61RtbS3mDBmCHxsaul4J6kwAAqgniETikpJgCgQ6DEEejwf6tupKRyGI93pDIchgYKlfp1MOQQCQmwtoNNAEg3GFoDfffFPx8vr6eqRKK0EajXIIKixk/41GKQRJg1csw2Kvvgp8+WXHx0UjfTyjkXqCCCGKlSC43YrhoTsrQWIIEhbAtdlggXKPaW1tLbI4DgUjR7Z7Lpzfr1wJSkqC1+XqegiiShCR0ethDgQ67AmSToGMFoKEJuOgxwOVdDjMbg+FIKU/0sGDWQji+bhmqR09elTxcp7n5cuuRwtBQ4YohiBX2xLtssZoAOA4mDgOrcIniWjDYTwP/O9/7N9VVUB1daxPKZLLFXpBoOEwQgigWAkCwD58hr2GNjU2JrwSpFarEQwGYTKZWOAR2gtsNhgDgaiVoAy/H9PPOotdsHcvsGRJ5IN4vcqVIJMJHgpBMaMQ1BHhDdxggMnvT0gl6IcffgAABNxuqKUhqKmJTY/X6WBVqSJ/wd97r1OVIOnMBJlAQD5erNGwT0nSJmi3m81SUAhB1dXVyM7OlvcEAQDP4/j0dOzvqBeoogJ4/nn279raDqfit0tYPgCg4TBCCKNUCQJYCAqrsvxr/372GpKoStDRo8DTT4PneXklKD0dsFphDATgkuwSIGhqaoLN4wnN6tqyRf6ajLYWB6XZYQA0SUnwud2s0bmzIYh6gojI72d/MCoV9GCVnvZ4PJ4OK0H2tnHeoNcLtVAtCasEnTdqVOQQk8UCqFRx9wQ1Nzcr/rEJ+4aJ1GrgyBHg//5Pflx6etQQlJWVpTgcNjgQQEZOTvsndvBgqPpTVxc1BLW72WBDA3uBkIYgGg4jhABRK0GcRhMRdn5tbkaipnD4/X5oy8qAxYvhdjiQkZEhD0E2G5K8XsVKEACoHI7Qa/OePRGvjU6nE0mAYiWIMxgAvx9etxva9pY/Cb+ddFSAKkFEJIQgRC6iqMTtdndYCRJCUEBpOKytEpTLccrNxhwHDccphqDDhw8rnpM4MyHyZOUhSKNhe4W1Dflt3LgR7kAgagiqqqpSDkEqFbjSUtx9zTWK5yM6cCD0x11fz74ULF26NPp9fP89sHx5ZAiiShAhpL1KUNiwl1WjERc17IqPP/6YVYLq64GpU2HftAnZ2dnsg6jDERoO83iihiAEg+L7TnDfPvyvqEhWzXc4HLCo1cq9TTod4POB9/nAxbJPmRJqjCYivz80ZMRxHQahWIbDpCFIrAQZDLJKEBobo8640qhUiiHo+bahpT179sim0JvNZuUQFF4JCgtBZWVl0KtUQHo6VA5HRB9Sa2srzGZzZE+QyQQcOADDkCHs+2g/s4MHWdN1aysLgQohiOf59hdqrK5mQ2k0HEYICRdeCRKChEIlaIzZjD179nT5IdevX88qQXV1wIMPomnjRiQLQ1vSniC3W7lCL6XVQtXaijMyM/HWW2+JF7e0tMCiUinPctPr2ftWlNljMaFKEBFJKkFAx3uBxTIc1tTUBCAsBIX1BLUbghQqQTzPo6ioCACwbds2qCRjwSaTSbmh2+WSP4YQgtqqPjzPg1OpgLQ0GF2u6J9aAoHQekcAC1b797NeInZHETdpbGzE7u3bgalT2aquCo2KAJvBZmxvW4+qqsgQRMNhhBAgshLkdLLXWIVJIGk6HRoaGrr8kKWlpXA6ndDU1gJjx6IpLw+2zz9nV0p6gpLc7uivqQKrFTCZkKXXQ6PRiB9EW1paYOG46JUgvz9q43RMqCeIiKQhKIZF/6TDYVqtFr6wTxu8ZK2hgNsdCkF6PfsDiaUSpBCC3G43Ro0ahZKSkojjlSpBPM+zECQskw6EQlD4MusmE0w+X/Sm8PBKj9kMHD7MdkEOPaDskIqKCrx95Aib8VZdHbVaVFZWhkGDBik/LqBcCaIQRAgBIitBdjv7wKlWs8UGwyRiJf68vDwUFRVB63IBViuaBg9G8oYN7PVW2KvRZkOS06lYCZKdg80GjBsHAJh6yinipJqWlhZYgIRVgoLBIPUEkRDZL6HfD15SVYlnOIzjuIg/KrfbLS5NHvB6Q7PDOI79gXQyBDkcDpx11ln4z3/+gzFjxrAxZY9HPjNBoqWlBVaeD61EDbAx4Pp6IC2NfR8IsADIcTCp1R1/ahFYLOzTlxAe1eqIhRCdLS0wajQsKB04ID8PifLycuTn50dfIbuqKhQghRBksbS/rhEhZGDweOR7I9rtgNEIjU4Hf0dDUZ1UWFiIgwcPQtP2XmFvboZ1+nSgrIwdwHGAzQZVc3PHoctmA8aOBaxWDM3IwJEjRwCw13szz7fbExRPCHI4HLBIN1qlniAikq7qHENjtHQ4jN1EfhvpOkIB6ewwQSzDYQo9QS0tLcjIyEBJSQlOOOEE4IcfgKeegsvlQkZGRkQVp6amBplqtawSxGk0bL+a0MmKwcKkVkevBIX/IZvNQHZ26HuVKjT+3jbm3nTwIFIyM1kI2r2blYgVtu2w2+0YOnQo6qM0TcPjYX/o4T1BPVEJWrsW+PTT7n8cQkjneDzsNVXQVgnSaLWKISiWyS8dyczMRHlZGbRt9xUIBKCZMAEoLw8dZLUCdrtyCPL5QgFkzhxg5kz2wVQyQ0wMQe1VgpSGw6J8mJRtniqcQyy73R8DKAR1xO8HF8c0Q+lwmBKXy4Wktl/coNcLtbTkaDB0qRJkNpvx7LPPsn6gykqguRlNTU3IycmJqOLU1NQgE4gcDissDG2fIdl8z6jRRISgqC8YZnOoHwgIhZv//Q+44AIALATZ8vKArKxQCEpNZc87TE5ODqqqqpQfS7j/pqZQCOqpjVsPHGBLChBC+iYhBAlho7mZVYL0evgVZo3p9Xo2I7YLOI6D3+mEJjU1dOHYsaFKEHsgxUUZvV4vtM3NodfPE09kr5Hp6UB9PdRqNfi2xXI1wgfAcEJPUHglSKVS7LsE2IfNZGk1nuN6bwPsHkYhqCPS2WEqVYf7WwWDQajbCU2ySpDHA5W0EpSU1OnGaCEEiWm+pgZwOGC325GSkhLxiaOmpgYZgUBkCBoyhIWJ1tbYK0HhzGZA2sejVrNPQW++CYwZw557Swu0NluoEpSRwf7QFdYKys7Obj8EpaUBJSWhEAT0zB+w0ItECOmbhEUHhcDRVgnShg+Htb3OJycnwx7HGmzhgsEgOJ6Hz26Htu010GKxAMOHA0ePyqtSCrON6+rqkO5yAcOGye+4rRJks9lgFypIbnd8PUFRJp8ACpWgAYRCUEekO70bjV1eUj08BKnDQ1AXK0GithDU1NQkT/htXC4XkpxOWQji1WoWgsxm9ubucoVCkEaD1mhv+EqN0eEhaPdu4Mwz2c+S58G3tkJvtcJttQLFxSwAtX3aCZeamqo8HOZysT/yjAygqEgegqKNtS9cyKpGiVBb2+4uz4SQXiaEIKHqI+0JklaCPB5Aq2UhqAsrRre2tsL89NMwt7RA0/YamJGRwarrDof8NQqRjdgVFRXIdTpZaJJqe23M+OAD1B48yC4TXv/CCT1B4cNh8VSCEtAg3l9QCOqItBKUlAS+gxWjOyIdDguED4dJQ1BTU7eGII7jwDU3yxqS1RMmIHDxxYDZDH9TE9Rer/hHa7Ra4ZLsaCz+8So10M2eDdx8c+h7tZpVavLyWJB0uQCnE0OGDcOR2lp2WTuVIJVKpdwYXV3NSsVKISia775L3BAWVYLIABYMBhMym6pbeTzsg54wE6y5mfUEKYUgjQbJyclo6kIIam5uhrW1FUM2b4a2rb8yPT2dXZmZ2eEHtcOHD2NoU1PUSlDGhg2oPXSIVZCibQQbrRKkUkX0XAoi3j8GEApBCmQlSmljdFISuC7uKyOrBPl8kZUgYTgsEIirMdrj8YizzgCwEOTxsD/K8CnvaAsxTU2ySpA+KwuejAzAYkF9eTnSNBrxj1ZltSIo6StqbW2FSWhADl/Hx2hkuzELhO048vLY49ntgMuFYaNH49ChQ+zFQagEVVcDf/1rez/CkOpq1oCdkcF6oKR/xBwXOXTJ88ChQ6zyBLDrX38deOyxzu1b1tBAlSAyYP3yyy9Yv359b59G+9xu5UqQ0BPk94szaaHTwWazdSkEtbS0wJKTg7PmzIGubehfDEGDBkV8UAsfDvP7/dCWlrLeTKn0dODQIWQcOYK6igp2mXTTaKlO9ATxPC8/lwHSDwRQCOpYeCWoi8NhLpdLPhwWrTEaiKsSBIT9QbV9sgkGg7KFE2XCFsQyGAxsbzSzGXUVFUhXq0N/tGazbNGxxsZGpKSkRG6eqkSlYsEjL4+9IDU3A04nrIMGoaWlJRSC0tLYbslPPw20rUsUsVCi2w188w37d1VVqBJkNAIqFXbs2IFXXnkFfpNJXPlaVFfHHr+khL0YzJ/PQlxzM7BrV/vPQYlOF/kYpaXAO+/Ef1+E9DNutxs7duzo7dNoX3glSBqCPB7gtdeAVavY64pGw3puutAT1NzYCKtWi0n//S/UEycCAGbNmsWunDBBHm60WvBKgcvrlfcOAey1ceVKmAoL4RBaA8Jnvgk6UQmK0NcrfAlEIagj0sUSk5IAr7dLJWC32x2aHebzRQ6HCZUgIGq40KlUHW7kKrNhg/IngLDnYTAY2ArXZjPqqqqQoVJFDUENDQ1ITU1V3Dw1glrNQlBuLqpVKhY62hYS4zgOuPRSVjnKyGDHX389cOQIysvLkZeXB+zeHQp4RUXAH/7A/i2tBLWd5/79+3H55Zfjf7W17AVP6vBhYNYsdi579rBPZgsWAOPHd65PSKlR/vvv2dR5Qo5xHo8n+vpdfYVQURdeu4TZYcJwWHMzG9Ju6wnSarXw83ynQ0BLVRUs0llhAEaMGAEA4EeNAjdqVOgKm429DkpFe9y0NODIEXCzZwMuF3sP4nnlik1bJYiLozFaxu+nShCRkIYgoxFGjut4v5d2hK8TpIrWEwREDRdmtZpVUGK1ZElkxUKBXq9n4cpiQV1NDdL8/tBwmbAAYhuxEhRrCHI4AIMBaysrWTiRNmX/4Q8sUIwYAXz7LVsh9cABlJeXY1BqKnDLLaHgWVMDbN/O+nEqKkKVoLYQFAgEkJaWBpXRGBmCDh1izdlHjwI7dgCTJ7PLk5PjD0HCi3/4i8X27WxojpBjnPS1rE/T6+WVoKQkaAwG+Dwe9jrkcoF3uUK9jWp1xL5isWqproZVulK+RETLgs0GTvJe4vP5oGlpAXJzI2+clMQ+KM6YERmcwqlULCDFMRwmU1QEDB3a8XHHCApBHQmrBNm0WnED1M7w+XzQtv2xKTZGC5UgrTbqip1cRxu5CitPtx2LxkblnZTD7sNgMODnn3/GH957D56WFuhraoCcHHZltOGwWEOQEHiSktinr0Agcll2jmOfeEaOBPbvR3V1NTIDAaCqCjqdjlWpamqAM84AvvySNTlPnCgLQaKkJOUQNHYsKzdv3w4cfzy7vDMhqKlJeZXrffviux9C+im3241BgwZFX8i0rzAYxNcuv8cDtV4f6glyOgGnE36nE1phaElhc9VYuerrYRB6gMLodDp5aLRaZRs9Hz58GMPU6simaMETT7DXOpeLva53VK3p7HDY3r3sdXKAoBDUkbDGaKtajeYuNsMKs50CTifU0mZeaSWoo2DRntpa1mfD86EG6BiqVykpKfB4PLhg+nQcKCtjFY0oIUgc1nM6Ixujw6nV4uJfGosF/oaG9svNo0YBBw6wNZeqqoDKSowaORIHDhxgIWj+fOCPfwQuv5yFRqMROP10+X0YjZFNy4cPh15gDhxgYQvoXAiqrQ0N30kNoJVWycDm9Xoxbdo0bNmypbdPJTqOk1WCPMEgDAZDqCeotRVwOuFtaYFOaDJWqzu/FEprK7iw4TCB2WyWh6Cw6vr+/fsx2udjFXElt9/OglOsIxFxTJGX2bNHXM9tIKAQ1JGwxmibWq1cCaqrU5x6rdQ/JOwuH2hthVpawTCbQ0GoKyGopoaFIKFnpbFRvokgwMaLw5rqCgoKcP3112PG6adDFwiw5y5Ua8JCkCiWSpBKJYagvMGDUV5a2v7xublAeTn7tFNeDvA8RmVnY//+/Sx8HH886yP6zW9Ct3n+efl9KA2HNTWxkrLFwsKbEG67EoKk/3+rqliPUqxj74T0YzzPIyMjo09VghT7NSWVIHdbCNImJbEQ1DYc5ktQJQhOZ9R9EE0mkzwEmc2y12WHwwFzUZG4YaqithAUS18qr1AJUmrEttvt8hnEe/dSCCKSP6awniAboByCPv4YWLEipvvW6XTwer3wORzQSn/5HnuMVUFiDEGKfwjXXw8cPMhCkNmMM08+mb3BhwUYvrVVvlq0lNmMh4WhIkHYpxYAwJNPspDS0blqNGIIKhw+HHuPHIEh2ow1QCzz8jzP7n/iROgaGuD1elnAy8gAXnghIsT5fL7Qat1Kw2GCwkL5mHdysuJ2He0SQpB0v7MdO1hAy8hg50nIMWhf2JBvIvbbSoTi4mJ89913kVdIKkHOQABJSUmhSlDbcJi3tTVhlSDZ8iASZrNZvqWStGEbbT/Hw4fb78exWkN9RB0FobAQpNZoEFQIQcXFxSiUzlpraAhtoj0AUAhSoFarQ7MewnqCrIDycNiePYpvukovEEIlqLW5GSbp+HFSEgsAWm2HwSLqVhKbNgH/7/+JIShbCAOSEirP8+1+YoHZzIKTdPsPpUrQRx+xNX3iqARlDx2KvaWlSA7vB1I6B5eLhaDJk4GqKvazFEKQgtLSUgwePJh9E14JcjpDa2oUFob6gYDQ2kXxEIYcLZZQ07nQZ5STw6pChByDvvrqq94+BUWtra3KW/tIKkHNfj+sVis0SUnwe70stLhcLAQJw/pdqQS1E4KGDBmCfOkG1WGVIADyHQqUWK3ghZ6gjoQNh6k1GgQUwp0sBAWDA2pmGEAhSJFarRbX4Ql4vVAJv5RJSdD7/awiEW737piHVIQm31aHAyalmQQcFz2gtBk2dCgOHz4sv5DnWUObXs9mTZnNbAaV0SgLME6nEyaej14JsljYJ5KsrNBl4SGI59nQz5VXsjDQnpwc8G1rZqiSk9HY0IBkpUW+pMaNA1dWJgtBAJTX0Ghz5MgRDBkyhH0THoLKykKbEt5wQ+SK1vFO9RUqQcK6RwCrBE2cyH4uNEOMHKMqe+N3+8cf2WSIdrhcLuWZu0IlyOdDC8+zEKTXsxDUVgnyOZ3QCoGhmypBWVlZyJS+VoZXgtrWaGtX2206Gg7jeT4iBGk0Glb9CuN0OtnCtwD7MC+8hg4QFIIUaDQaBNp6OjxOZ6iEmZQUvSmtpSXmaoJer2fDYU4ndFH+YMS1cJRPEHk5OSiT7koMsCGdlBRg+XK2+7DZzN788/PZFNA2TU1NSOa46CHIaGSNw9KpmuEhSKgk/eMfwEkntft8daecAp8wzm2zsRAUpXlQ4J88GeqiIvY4w4YBVVUwGo1obWd2Q01NTehFJikJvPT/R2kpIHwKMxiiBinE2uQphCCLJbR1ht3OfqZUCSLHsAphxeLuJLyJC/bsYR8y2hE1BAmVILsdzTpdqBLk8bDKi8sFr9MJnRAENJquhaAOPsCK2ipBYqApL+94VpZKBYNKBY/bHdvsMMmHTY1Wy4Jfe556CrjzzhhO/thBIUiBtBLkka6FIex7Fa6pib3BxjhrTBgOQzAYdRo8zj03+h1oNFDzfOSq0cIKyiNHsl9+s1l889dJKlh2ux3J7VWC1Gr2hi7dBLWtJ6ixsZFVoOrrQ5WVDmi12lD1zGCAv7UVKW3DgBzHKX6qqRo8GNnl5eyb7GygqgozZ86Epp0/fOnS7+aMjNDKqoA8BEUTCABz58a2UJqwF5rVykKQdJZc2/kScqzx+/3xrVEGsL+n8Kp1R/bsYT2Sgrq6Dre2cblccEqmnIuESlBzM5q1WlgsFmgMBviFkOB0wut0QisEhm4aDotgMkHn84mvjXxZWUxT03P0eqQkJXU8K1c6sQXsfU1pOEy0Zw977tIFHQcACkEKNBqNLATphRAkTAkP89MHH7BhkBiXJBfXvOmstmbcYcOGYfHixaEQIaygLJBUgkyBgDhe3tTUBFsg0P4nFotFHoLMZnidTixbtgxHjx5FisfTcahoo9Pp4BNeVDgOhYEArG19PUlJSYovXOWtrRjk9bJPO22hwqzThf5fdCAlNxeN8Yagigo2jFVU1P5xPB9ast5iCW27MWECuz4nh4bDyDEpYrfxWDQ2Ao88Et9tmpvl7QX19TGFIMVeGUklyKvTQafThXqC2nZc97lcYk+QRqeDXylMtaOpqQlNTU3sdaGjcCIwm2EMBELVq1gqQQCmpqZi3vHHA0L/Y3skP48OK0ErVwLXXtvxfR5jKAQpUKvV4nCYOzwEKVSCin76SfzlHT58OLvw1VeBdesU718YDus0jQbw+zF16lSccsopKBY2BBV2VReYTGIvjNnvl4WgZJ8veiUIYAFKGoJ0OkyzWPDb227DmWecgXMzM2MOQVarVfx5AsBvkpOhanshtVgscCisZl1eXo7cvDw2SyElhc1YqKuL2hQNyJvQU9LT0SgNmh2FIJWKfVqdOJH1H7RjxdKl4h5AvDAcJl18MSuLKkHkmNTU1ARbe68bSpxO5eU1OrqNtOIUQyVIuiURgNCkFqESZLeDaxvy0iQlwSd8yOJ5eF0u6Nr6cawmE5rjnCjxzTffYNmyZeybWBuLTSYY/X44nU72Qba+PrZgA7CtfwoK4jrHDkNQdXVoXbgBhEKQgohKkPCH1RaCIoZvhATP85gyZQq77OOPgU2boFKpZAEAkAyHdf4ExXVopkyZgu+++4798YeHIGklyOcTw0ZLSwssTmf7ZdvwEMRxGGE2Q/fZZ2x6eiyVlTbTpk0L7aQMIDMlRQxgZrNZsbxeW1uLpFNPZecgvKgoLFBYUlKCL774AoB8yYCUlBQ0Skva4T+bcDYb6zm46qoOQ9DPX34JnHQSdu/eje9KS9mn1u3bgeOOYwe01ztGSD/W1NTEVooH2N/j0aMd38jl6noIamjocPJCxGbRQrVWqAQ1N4s9MpqkJDYc1vaa4XW7oW2r4CRbLGhqaIjpNIUPsy6XC7NmzcJP8aw3ZjYjyeuF0+lEc3MzrMFg7OvDlZS0G4LUHIdA2M9LrdEgEDbMFwwGQx8ea2raf408RnUpBC1atAgcx2HhwoUA2DotDz74ICZMmACTyYTc3Fxcf/31EY10Ho8HCxYsQHp6OkwmE+bOnRvZ5NuLpJUgWQiK1hNUWyvvqPf52HE7d4Y2JZXo8nBYWyUIYIGqoaEBZrO53RCU4vezci3aXizq6tqf1VVYqBySNm8GvvgirhAUwWZjvTRQrgRt2rQJ06ZNAy6+mC2KKBAWgZT46aefUFNTA4fDEZrhAIUQFAzKp/yHS05mQeass9j2GkpcLmD3bhzauxc48URUVFSg2OFgL9ZHjsg/xaWnAz/91N5PgZB+p7GxEclCJWjrVrY5c0cSUQnqaOq4EiEESSpBwlCVOilJtmaOz+0WK0HJViuapJUgYcNnBfdfcon479GjR+O59hY6DGc0wujzweVyob6+Huk6XWxVJL2eTVyRru0TfohOB29Ye4ZSJaixsZFthM2+ib2f6RjS6RC0efNmLF26FBPbpj4DbKrdtm3b8Oijj2Lbtm346KOPcODAAcydO1d224ULF2LFihVYvnw5Nm7cCIfDgQsvvDCiYtJbZJUgjyc0HKbXA2535Liz0IDWVlrFli1sfyuHAwaDIWLH90QNhwm8Xi8LQUJjtEAIQVlZSAdQJy0n19ayN+poPvpI+Q9y3z7WzF1R0fk/GKtVrARZLJaISpDRaMSECRPY7LQTTmAXmkzAP/8pVoKE/z9erxd6vR7FxcWh6fFg+6C5ovw+bdy4EQ3hn/RSUlgIGjIkeiXnhx+AmTPhqawERo9GfX091EYj6yFKS5P/vJ57Dnj4YbGH7L///W+sPx1C+qymxkYkL1/OvmloiGlj5k6FoNZWeQjqjPBKUNvmqQDYa5jQEwRWCZKFIGlF5623gHfeibh7V3MzWr//HnV1dawCxfOIa4UdtRpGjoPT6UR9fT3Sok2SCWe1Ar/+2m4lSKfTQRX2+qcUgqqrq0MzaqPtSn+M61QIcjgcmD9/Pv71r3+FSqMAbDYb1qxZgyuuuAKjRo3CKaecghdeeAFbt27F0bayqd1ux2uvvYbFixdj1qxZOOGEE7Bs2TLs3LkTX3/9teLjeTweNDc3y766k6wS5PGEKkHSlYwFPA/xO+HNc906tlt5UhIMPK8YgjwuF/jO/sKFhaDJkyezcfr6evlKn2Yzq0olJ0fuPO/3R5+ZBoS2Cgnn8wEzZ7IhwM6ev83W7nDY8eGrVQPAf/7DmivPPx8A8L///U9sKOR5Xr5GENr6gwwG9imuuVmsPAHAwYMHxU8/mzZtYhcmJ7NqTkYGW7Z+797IcygqAr94MVTDhyPIcayUnJTEAuPZZ8uPTUkB7roLeP558DyPrVu3xvEDIqRv8jU3Qyf8bcQaghIxHAaEgks0hw6xSrWgnUoQdDoWtIxGgOPgc7uhbQtBaSkpqJOuIF9byyY+hNn3ww+4w+/HSy+9hFGjRrH762idnzBJKlXnQlBFReSm0RJ6g4FtfSSh1mojhsNqamqQNQCHwKQ6FYLuvPNOXHDBBZg1a1aHx9rtdnAcJ84o2Lp1K3w+H2bPni0ek5ubi/Hjx4fekMIsWrQINptN/Mrv7DBMjGSVIK83FIIU8LW1oTdYYeXhzZuBU04Bxo+HoaIiIgRptVp4W1qir1XT8QnKQtDMmTMxZsyYyCEf4Q8yOTkxS9u73SwkzJ4d8/R4RZJKkNlsVmyMjqDTsfWI2m43b948vPLKK8jOzkZaWhqKi4thCX9RSE1lYU0ydFdaWoo8yblXV1ezEJacDOTkoNXpZCFI4UUPRUVwDBuGwaedhsbGRvYzTUpi9y/5fRYrmvPmARs3ovHQIfknS0L6q6Ym8M3N7LWgsbH7KkHSECSsYpyezj7oAWxV/PDh5uJiNs1b4Ha3XwmSLGvh9XjESpDGYJBPJa+tZYvhhjn4yy+Y6HCgrLiYVa63b49793WjWg2Xy4WmhoaOV9EXWK3yPcEU6HQ66MJ6VzUaTUQlqLa2lvVrDsCVogVxh6Dly5dj27ZtWLRoUYfHut1u/PGPf8Q111wjbtBWVVUFnU4nqyABbDVNxW0gADz00EOw2+3iV2lHG3B2kWyxRI8H+rApj9wXXwBte9Q07NiBNKEsKYQgYXPS446Dobg4FIIcDqCxESqVii1eGON07wjS/aoA9oa9fXvkL7HZzC6T7k/WFUlJrPl37Fhg6dLO38+jj4o7uEt/1vEwmUzIyMjAKaecguOOOw47lBZSS01lw4FFReL4+bp16zBz5kzxkDPOOAPr169nIaiwEI8//jgLQQoveigqQlNyMkaOHIkaYW+wpCQ2o6xtVkVdXR3efPNNdh3HAXfdhYqlS5HRzqw2QvqNxkZoNRr4Dh9mFValbSrCdbYSJLyeCRsfp6ezGWItLWyRVmEdMUFDA3jpZeGVoCNHQi0AajU7r7bXdp/HA43QU6jTyV9fa2vlTdlt//bV10NrNOLvd94JrVbLppi3VapjlaRWY/fu3eCdTnHGbIes1g5nhumTkqAL+5Ct1mpZM7iE3+9n5z5A+4GAOENQaWkp7rnnHixbtky+G64Cn8+Hq666CsFgEC+99FKH9y1d6C6cXq+H1WqVfXUn2WKJCiFIvXkzKn/4Abt27ULl9u3IERaXstnYH6zwPMaNg6GkJBSCVq5kM6uk68x0RlglCO+9J99RXWA2s3MKH9rqaCgsGrOZveFzXNeWVs/JiT7cFodrr70WZrMZ2dnZ8qmxgrQ09kJ56BAwYgR4ngfP87IZJCkpKaxK0xaC9u/fD9/QoazxMFxrK5p8PlkIUpvN8L//vnjIL7/8Iq/8nXoqKjZvRq509W1C+qvGRiQNHw7XgQPsNaS9SpDQV9fZniCTib1W1tWx8JKezgLJ66+zxWTDq6v19fLHEV5jhWG01tbQB0+OY5eZTOy1yONhQ9sAO176+iqsiSZ88PnjH9lMUrsdOO44pAg/g23bQj2MMdKpVMjOzgbvcMQeQqzWdpuiAUCn10eEII1OFzEcJltjboAOi8X1TrR161bU1NRg8uTJ0Gg00Gg02LBhA5YsWSL7RO/z+XDFFVfgyJEjWLNmjSy0ZGdnw+v1ojFs1+6+NDYpPJc///nP8Ph88hDU3IwsrxdfrF+P7du3o3LvXuQIU6OTk4H9+0MLFmZkwNDcHHpTPHyY/RF+9BH7Y+1sJUgyRR4AqwT97W9sewmppCRWDQnX3NzuejtRzZ7N9vHqYziOw4MPPhh5hVAJOngQGDECP/zwA6ZOnRpxGM/z4MePh+uyy3DKKadgx969yivG8jwaGxsxfPhw1NbWgud55OXno1zyYlNTUxOabQEANhvqm5rklxHSXzU2Imn8eLi2bmWhxOGQfWiUufZaFmA6OxyWns7+K/Q6CpWglSvZh77wtXwcDnBpaaFgJoQgjovslxSuNxpDeysKs890Otnr65amJhzKyQkNkX//PbBvHzi7nb0eVlSwr+zsTn240+l0cDc0KL9WK4m1EhT2/qJRqASJBuj0eCDOEDRz5kzs3LkT27dvF7+mTJmC+fPnY/v27VCr1WIAOnjwIL7++mukhf3iTZ48GVqtFmvWrBEvq6ysxK5du9i06D5A+KP2er3YUlEBlXSs1uXCjAULcEtbn019SQnShEZemy00wwgArFYYnM5QCCoqAm68kTX5ejzguhKCpC86bjdw3nlsRpIUx4V6d1QqIBhEIBCAyuHoXAi64YY+WzLNU+pREkJQ24KRhw4dwsi2YTipgoIClLvdKBs8GGeddRb279/PPiFKPuVWHzgAv8WCpqYmZGZmiitgFxYWhharjMZmYy+YhPR3jY0wHn88nD/+yCq6DgeSkpLgUtpPbOfO0PTyWLaikXI62XIYLS3yStCvv7LHTUtT3LCaz8kJVXHbQlAwGGSXhX+ACwZDIUi6ZElYJeiI04mDJhMLQYEAcOQInHv3wuh0sspPeTmwenX7Wx1Fo1LhjNNPxw9btsT+2jp3LnDTTe0eojMYoI1hOExElaDYWCwWjB8/XvZlMpmQlpaG8ePHw+/347LLLsOWLVvwzjvvIBAIoKqqClVVVeKUcJvNhptvvhn33Xcf1q5di19++QXXXnstJkyYEFOjdU8QGqMnFBWhpKpKvj5FUhJw2WVASwsyMjJQXVUFlTDUISy4J5Qq2za7E0IQX1nJwgfPd70SJPyRdvQJ4uWX2X/bNkCtq6tDpkrV8c7vxwKbjS0bwPOASgV1lHWCRo8ejf3796O0tBSDBw9mJeIxY2RNlm+//DKOpqWhtbUVJpMJgUAAarUaOTk5HW8oOXx47HsndWXpBEK6W1MTkk48Ea4tW1goCQZhNBrhuugiNlTlcLAPex4P+52X7qvXwWKHMk4nq6y0tISqOBkZwLvvAuecw6ru0g8WQsjKzWXLeACAxwO/VouXX36ZvWZOmiR/DLWafdhJSpL/3SUnh3qdgkH4eB4Nqalswsv+/cDMmajduxeZbje7z/JyVh067bR4f5qAyYQsiwXnjhkTewhKSuqwz3NIVhZOli52C+XhMFF19cB4T1CQ0BWjy8rK8Omnn6KsrAzHH388cnJyxC/pzK/nnnsO8+bNwxVXXIFTTz0VRqMRn332WdQ3qZ6mVqvRUFkJ265d+POECfLtJV57TSxFTps2DT80NoZKoOGVIEAWgvzBILQ6HfuDlI5Px0sagnbsCG3XoESYrdC2AWpFRQVygM5VgvoZk8UCR3MzoNMhEAhAE2WxtczMTFRXV6O6uhpZWVkoKSkBP3Mm8OCDYogM1tXhaFvjJMdxqK2tRUZGBlQqFerq6vDtt99GLNgoGjYs9hB04YWK+9MR0hfwHg+MBQVw+f3ih6+kpCQ4a2vZMP8LLwCPP86GoDUaFmJcLvYGH88CsS4Xe40KrwQVF7PlKIT+S0FDAziLBdygQbIQVOPxsEptUhI8Y8dCL62OaDShSpA0BOXlQWe3swVtGxpCvZXNzcA33wDnnYeGykqk+P3AiBFsKKy8vHMzZs1mwOHApSNHxj4cFgOVwQBd2GsRDYcp63IIWr9+PZ5//nkAbGhAaD4N/zrjjDPE2xgMBrzwwguor6+H0+nEZ5991u3T3uOh0WhQ8vPPGDRtGsavWiXfaHToUPZfvR7migpMka4SbLOxLntJ05pOpWJ/TF4v3Go1a+AdPBi+o0ehiXWjvcgTDIUg6Z5V7TGbofJ6UVpaitxAoE+lfqVd5BMhPz8fpQ0NwNChKC4uRmGUZkJOsv6TSqXCmWeeieK8PGDtWmDPHvBvvYXsAwdQJXlREQITACxYsABerxfPPPOM8hpH+flAaWnHz5Pn2Sq8HQ2vkV7Xl1a472lJRiOcWVnsTZvjWCUoL49tFfT116z6umcPe10SKkGpqfH3BQn78tXXh0LQiSey/1qtLJQISkuBtDTw2dmsWgMAHg8qnE62kOxtt6EFkC+jIQ1B0h7LzExku92orq5m1S2Lhb1GXHMN8Je/AFOmoMHrRapWG9qfMd5NZQUmE/tAnOjZWcLSABJqnU4egpqaWGXtoovYh2kKQUSgVqtxdNcu5J18cvSDCgqAZctw3113hS6z2dgvnmQnd05YRbq4GK25uSwEDRmC1pISmDr7hyOdIi/ds6o9ZjNSdTqUlJTAYrcPiErQ4MGDUWqxACNGYP/+/Yr9QEomTZqErVu3guc4/HD55ShatQojrr4aQWFzXLD917Il/59nzZqFxx57TPZBQKTRwADA3dF+YjU1bDgh1qoR6TWrV6/u7VPoeW0rIiclJcGVmcmCDc8jSauF02Bgr3+XXcY+KK5cCZx8srwS1NkQVF3NXq/MZvbBBIicHFJaCj41lb3+CpVUjwcVDgdycnKAP/6R7c8lHUbSaELDYdLZsioVsrVaVFZWArW14ITbzJvHwtfw4WjkeaRIp/ArTLiISVslCA0NiQ1BOl1ECNJotQhIep1cr78OQ2Eh8MwzLIS1t4PAMYxCkAKNRoPqkhKktfeLXVAAvPUWOEmFC8nJ7HLpVP+2YSgcPowdGg1bVGvIELSWlcHU2V96aSVIYVNRRRYL0nU61NXVgetgN/aelpCFHBWkpaWhzmwGRoyQb/zYwXkI+73t2LED67//Hu9PnIhJt98OIFS1ys3NjXp/FosFrW09BcIGhZacHLQIZfpo9uxh260UFcXxLElviGmBz2OMu6YGOrMZRqMRLXfeCXXb8I0xEIArKQl48UXgllvY7/B777GqTSIqQdLXuGgrMpeVAamp8tcSjwetgQCrBAGRIUitDlWCwpYMyTEYxBDEC9UjvZ41R6tU8KalhYabBg0COjupR1oJSuQMUoVKkEavl1WCSlevRt6ll7IhvY0b49+b7RhBIUiBWq2Gv6kJXHuVg8JC9ksjHQe2WoHp0+XHpaaKn+7r2hb4Q2EhWuvrYersL70QguJpZjObka5Wo7a2NjTG3keMHj26W+6X4zhW6j399A6PNZlMEW9sO3bswB//+Efk5eXJewkAXHPNNfIdqyUyMjLYzxlscdD09HRYJkxAS/gKt6tX4+1LLw3NQtuzB5gzh0JQPzAQQ1DDvn1Iy82FwWBAk8cj/k0kud1wJiWx5mWtFpgxg72+5OaGQlBXKkGA4mrGPM+LW+cIw2EqlQoBoQrrcAB6vbh/o2IlyGiMrAQBMJrNcDU1icNhGo2GzQgVXgcyM0MV/0ceia0ar0SoBCV6OEyhEiSbHeb3Y0dtLSZ2toJ1DKEQpECj0cAfDLa/oOCIEbKtEgCwTxbhKymnpIBzOtkbmxBYhgxBKwBT+LoVsZ8gKwVv2hT7J5DUVKS53WyLCLe7c4sldpMT4lxgLC5Wa0yfcEaNGiVOewdYKOI4DhzH4dprrxUvFz5pDmlnsUghBLndbrz//vuYPn06LCecgJZffgkdxPPAX/+KVdu3w7VzJ7ts9242zbZtnz3Sd7XGslJyf+b1yoebANQfPoy0vDyoVCq4XC62YK5aDaPTCZf0DTc7G3jzzVCI8XrZUJlSCGpvH0iLhc0Ai/Jh472KCrwjbGx6+DCQmcn6kwwGFizKyoC0NNYbWFqKlpaWyJ4gk4kFofDXiLw8uCor4auuhiYlBYMGDUK5ZDVqLjs7FIJmzOh8FUWoBHVl8VwlSpWgtgkiAICff4anoKDDRY8HAgpBCtQtLVB1FBLGjGG7mnekrRLUeugQjMICV1YrWvV6mDpbjREqQZs2AaeeGtttpk+HceNGDMnI6FNVoO4W61DbsGHDZPvZnXnmmbjgggsijouliVsIQR988AFuu+026HQ6WCdNQot0U9aGBgQLC2HJyUGD0AN09Cjrp4g2g4P0CTzPH/uVoH//G3j7bdlFdaWlSGubdu12u9kbqNkMQ3U1XOH7Xp11FmCxoLmuDnafj1VblELQtdey7SyUWCysyVlhtfUtW7ZgqNEIgxAc2mbbJiUlwZmWxpqz24bIBg8ejKNHj6KlpUUcGgMAqNU4UleHRqUPvIMGoam0FDVHjyJr6FAUFBSgpKQEX375Jbt+wgTg97+P+uOLmVAJSrScnIgFFWXDYatXg5swIfGP2w9RCFKgCQaRPWVKxwfGsjpoaip4hwM/1tRgqmRYptVshqmzfTlCCNqzh4WxWGRmAo2NuNRkint/m/5u3759HW5bodVqMVzS+Gyz2SIW+kxPT0e9sIFjOywWC5qbm8HzvLidhyU9HS0uVyjgHDqE3VYrTp88GY3S2WAqFSv9x7OmCulRPp9PXPfsmPP55+y/RUWAtHIJoL6yUtwn0ePxiCFIVVEBXmlpCIsFX+7Zgy9rakKbmErxPPDzz0BJSeTlbbfHzp1AQQEOHTqE3ZL9/A4cOIApeXlsF/bmZnHj6KSkJLhSUlgIcrkAnQ6ZmZmoqamBy+WSD2FrNNhx+DCK7fbIEJSXh0EqFUpKSpAzahRycnKwdOlS7BP6+lSquHeMVyQsyprov/epU1kjt4RKq0UwEGBrH337LTTd1IbQ31AIUqDOyUFerBWWjrRVgso9Htlsotbhw7tWCRKWeY9nmfbp03HcsmWdW9m0n6qsrMSPP/4oW6KhswYPHhzTWlYcx6G+vl62VYbZbIZjxgzgzjvZi/yhQ9gJYPr06WgoLWVlf6FfITeXvYiTPsnr9fb/EFRVxdbzkXI6Q9WNkpKI/fN8TU3Qt02jdrvdrCfIZGL9OErLfVgs8La2whsMshAUPjuytJS9+YeHIJ+P9bRYLGyIuLAQ33//PQ6HzZrkkpNx6pgx+P7DD+ErKIBWq2UhSFgkVTiO49DY2Bix5ySn0aDO4UCtUnvAoEE4VafDh4cPI3v4cKjVarzyyiuy1/CEMJvZ2koJeH3qkEYDBIOwf/opdo0Zgwmd7WM6xlAIUqBSqRSHQjolNRXB0lKopAsuAvBkZkLflV3kDx4MrVkUqzlz2EKOfXTri+5w9dVX4/rrr0/IfQ0ePLjdXiCp7777Tha8NBoNAlOmYIPHg7K33gIOH0ZxMIi0kSPRUFHBhsKE8vXQoTRNvg/zer2h3or+qrg4cpPg0lI2NOX3sw9ZKpVsuwve4RD335JWglBaCphMqK6uxoYNG8QV1Bu8XqQEg0jWatEYCERWgn7+GbjkksgeOGGFaYuFDXMVFkKlUkX2YSUnI1uvR9WOHXANG4akpCQYjUY4LRbg6FH42va3BIAvvvgCc+bMkd2cP+88JFksaIgSgvLefReHkpPFPiKLxQKbzcY2XE6U/HxWsbn//sTdZzRqNZqdTqxfvBjfZmdjlLDx9wBHISiKWNeU6VBKCn789VdMVRhe6/TUcI2G7aEjrAYdq/HjQ+XuASInJyfqLK54GY1GnHfeeTEdO336dMXVow+OHIlfPvgAOHQIhccfj6SCArjq6+UhKC+PrUBL+iSv1wtdeA9MNH1pUcVvvgn9u6Iisim5tJS9thQXs/BTUCCv0khCkLQnCGVlgMmEDz74AEOGDBH3hfx63TqclZqKmenp+ObQIeUQdPnlkZUgIQSZTADHITh4sPLfcNuq0arKSriGDEFSUhKrBJnN+GblShw2m9kaQQBefvnlyP9nEyZApVaD1+kiQ1BuLuDx4Nr77pO9Tgu9QQkzZAiwaJHi7LeEU6vxW6sVFxUU4J5HH+0zOzT0NgpB3S01Ffl1dRh20kmJu0+Nho2Vx9oPJNXZVapJXO68807Fy42FhWguKUFLTQ3M2dnghHWkSkpCISg7G6is7MGzJfGIOQTZ7WzVZKUd1ntaUxPbBkZQURGafi4oLWUTLX75hQWQ449ni7G24VpbxSqyOBwmqQSlpKRg8ODB0Ov1cDgcaG1thVGjgUmjgYfjIkPQ3r1sZlVNjfzy1lYxACEjAztrajBx4kTxarvdzoa22vYP4yoq4MrPD4UgoxFHd+3CG+XlGNTWyD1YurJ/OKMxsr/HYAA2bsTlkpmhQDeEoJ6k0QAffNAzVad+hEJQd0tJwQN+P9s/KlE0Gta42JkQRHoXx4FLScHO6mr2wi58Ajx6FBBeqHNyQj0Ny5b1znmSqGIOQa++yqoVHW2w2xNKSuTBOlolaOZMYM0atg7accex7RQEwaA4FVw2HFZZyUJLm3POOQcLFy7EPGljrlYbGYKE+wufcSlUggBg2jTs3rMH48aNE6/ev38/W1usrRKkcThgV6lCw2E6HbQ1NXjytttiG75OSWFbYoSTPKbAbDajsbER2j60xEjMkpLY5rOxbLM0gFAI6m46HTizOaJ/55FHHun8fWo0bLZXZ9cZIr1rwgSUJCWhQDqFtaREHoKEN6y77gK2bev5cyRR+Xy+jt8E/X7gq6+AW2+NHO7pDcXFLFgLvUwVFZFV4dJSNrV9zRpWlTzuOLZzukASVmTDYVotAmq1OGSVkpKCP/zhD2xF9WCQBf3wEOR0hoKTsLWQ5LqgwcBmg334ITiOkw2HHTlyhO0DmJwMbNqEIQUF2Lt3r1gJsre0QG+1gmuv+tMFjY2NskkP/UZhIdvfjchQCOoJw4dHNCOf3N6+ZB3RaOLvByK9rq6uDmlpadCfdBJcp58e6jXQaICGBgSEN6XkZLaCbFMTW5TzlVfY5Twv/2TeB/wUvgo2wJpdr7qKrbZ7DIqpElRVxf7fFRb2nRCUnx/6f1JfHzlBoqYGmDyZBfDCQjYklJKiWMnS6XSh4bCUFBw+fFi2xITYU+nxsLCl08lDUHk5224CYB/opENiTieqAwG2P5tCL9Dhw4dZw7PNBrz2GoY98gh27doFo9EItVqNffv2YURmZuhDRYI1NjZ2uAVPn9UfK1jdjEJQT3j33cTen0ZDQ2H9kFDGH3viiTgifRO12QC7PdRHJISjkhK2KnlVFdtg8bvvgFmzWFN8HyGu2Cvl87F1So7RClZMIai6mvV2hTcXd7c33gDWr4+8vLiYrS4vHRILb8blefbaMnw4C0EAa1x+//2IISubzcaqMyaTGILGKQwfwWAIbUsRLQQNHhyaIfbrr0BrK0pcrtCWGGEKhXPLzgauvhqpJ56I8vJycU2uAwcOYORZZ7GKajs8Hk/sDe4Sra2t/bMSRBRRCOoJiQ4sY8YAN96Y2Psk3U6j0SA/Px8jRozAWWedFbrCZoO9bXn/LVu2hC4vLmZvRn/8I/CHP7D1RNauZWu5SJtt33wzsq+iu3k88B09itLSUvnlwvBHWhqrZB2DYg5BWVk9H4KOHGGPHe7oUbaru7Sqo9OxLS3CnXtuqEn/nHOA1asRaGqCqi1kAAiFgLZK0Lhx48QQImOxAEYjOKVKkLDvYkEB+10HWOj66SeUOZ3iAqdRV2kfMgR4/XUAgMvlEh/f4/Eg6ZVXOtzKora2Fpmx7r0oMWjQIApBxxAKQf1RRgaQyNlmpEfMnTsXKpUKGo0GZ555ZuiK5GTsNZlw9dVXY6ewj5hWCxw6xN4gpk1j1SKbDZg4Ebj4YvbpHGBh6PbbI1b37XZLl+LowoXyviaADWtkZrJhlIEcgqqqWAjKzlYOJd2ltlZ5Py6vlwXqigq2aKHBwBbnFGaISRfrfOaZUL+OXg8YjWjcvRupksVdxeGgthB01113KZ+PxRKqBEkrO9JK0LhxbHd2p5MNf/3rX/BpNBE/Y71eD6fTqbi0iEajEUPQ0BjXT6upqUFWVhbbdDWOdZ/mzZsn336D9GsUggjpIbLqj1RKCooNBhQUFIR2q8/OBn76KfSJ/O9/B5YsYf/+zW9C1Z+DB9k047ZPxD0iEAA+/hiHS0owcuRI+KVVKeETfnLyMR2COmyMFipBKlXPboFSWyuf+v7FF6E1p3JzWQiqrGT/tlpDgam0lPUMAeI6P6LJk1H/+edIk6yWLFZCkpOB3FzFNbEAiJWgiJ6gsrJQCJowgQ2D7d4NXHklO7e2ABQMBsXQk56ejl9++UVxuvuYMWPE5unwRRGj8fv9yMzMRFpaWkzb4QiGDBnS+TXeSJ9DIYiQXqaaPBn+s86CWq1Gamoqe0HOyWEhSHjB12hCs3mMRja0sWEDW8fl2mtZGFLaoLI7fP45cN55qLNaMS4jA9XSSkdZWSgENTb2zPn0sLh6ggRFRWwI+09/6tZzQ12dvBL00UfAwoWsipibywJQRQX7t8USOraoiA0vAfj000/l24Kccgrqvv4aaZIem+uuu479IyUFWLo0+vlIK0HS30/hHABWbfJ6WRCaMAF47DGxn6e+vh7pbRWojIwMbNq0CSNGjIh4mKuvvlr898yZM9v/GbUxmUyw2WxIT0+P2n9Ejn0UggjpZckpKbC3bQkwatQo7N+/n72BejzsDUQBP38+8N57bLbYccexhumNGxN6XkXCjtnh/v1v4JZbgDFjkFNSgkpps21bCOJtNvDHYgiqrYW3ri72niAASE9nAegPf2D9Qd3ZI9TQIK8ENTSwalRhIRumrK4OBRBpJWjPHnHGqVqtli8IOGUK6nfuRFpbpQhA7KuwC5Wg8BDk8bAhOcHgwaxqNXEi20YiIwNWqxUHDx4U9+vKyMjAnj17kKGw8XSsQ2BSgwYNAsdxyMjI6J/r/pCEoBBESC9LSUmB0+kEwFa2PXr0KPskLMyCUbCmpATf/Pwze/MaPRo47TTg++8RCATw9NNPd/2k7Ha8esUVkQ3Xv/zCKgbJycDo0cjZvVsxBK3/9VdUHYubwN53H3yffNLxm2ZrK5YJa7KMHAlccQULGddeC/z3v913fgaDvBLk9wPPPccWA9Ro2FDml1+ynsLwENQ2gWP48OHyzUrNZjiys2ESKjfxECpBGg0LPoLw4aQpU9i2HpIwk5ubi23btokhKCUlBQ0NDQkbirriiisAsGG2zswSI8cGCkGE9LLU1FQMa1tRXK1WIxgMhqZXR1FXV4fSvDzWgKvVApMmAdu24ZuvvgK/caO8T6cT+J9+wh6nMzRrR7B4MXDPPezf6emwtLbC8frrodlqbb0eecOHo6w/V4JuuCFyOO/QIYDnwR8+DFVHb8Q8j3379rF///GPbNFLgC1GuHYtC5fBILB1a+LOORhkw17SEMRxrOozdiw++OAD1qcVDAKjRslDUEODuPhqamoqGhoa5Pc9fDg4hQpMh4YOBQoKoNFq4RN6owKByPV/pkxhYVGthsPhgMlkQm5uLn799VektZ2XWq3uVMUnGuF+9Xo9pk6dmrD7Jf0LhSBCetmwYcMimzlHjwZ++9uot+F5HpYzzkDz5MkAgEOlpThgt6Pso49w2Q8/4McffujcybjdAM+jfu1apI0cCWzaFLpu2TLW7zNsWGja8v/+x/67YQM8Hg9+OHIESE7GoLw8lLVVt/odu51t7vnYY/LLn3+e7b81eHBMQ1pHjhxh/5AGJrWaVVz272c9MGF7UwFsx/NOaWhg/3+i/Nw3b97Mgsb//R+7QAhBwrIG7bn2WraQYrxmzgRmz4bZbEarEIKkQ4WCceOAv/0NAHD06FEUFBQgIyMDVVVVsqG3axV+XokwRWGDazIwUAgipJdxHCcbXuE4jk09bptNtnLlStSEbzIJ4Jxbb8X2q64CwIYwirOzMX7tWgydORNH2psyLwSYDz+MbKa+7DLgjTdw9KefMHHuXDStW8eqPP/4B/DJJ8ATTwAAKioq2DouHAfu9NOBFSvwv//9DxMtFoDjYDQa4erJWVGJ9MMPwO9+x6b7S8NOcTF7sz7lFOCnn6KvX+PzIaDRwOFwKF9/3nlsS41161hDsLBQYJsPPvigc+ddV8eWzxCEhZtDhw4B//43qiwWFBUVhabIl5aKDfhRFxDU67u007nZbEaLUC1ct471/khpNKyvDSwEDR48GGq1OuJcJncmiBHSDgpBhPQxarUaPp9P/L6hoQErV66UHcNxHEwmE6bPmCFeNvuWW3DilVcCp58OLlql4rPP2AJ4P/4ILFyIz/78Z2wVhmQ2bGAb/b7zDo62tOD0Sy9F8e7dwPXXs+bW//2PVTIA7N69O7RCcG4utm3ZAoNOB1MHC9T1C999B5x+Ovvas0d+HccBQ4dCc/Ro9LVlamrgSk2NPm18+nT2s964EXj0UWD1avGqpqYm2f/7uNTWykOQ3c6Gx8AWE1S3/b/bvHkzNm7ciO3CJqqSpmilBQSbmppga7ufzrJYLHD4/Ww47vXX2Z5qUTQ2NiI5ORkAMGHChC49LiEdoRBESB8zYsQIHDx4UPxerVYjOTkZy5cvxzPPPCNbHVdm1ixg0SJg0iSojx5lvUXhli9nq/JedRWwdi1q1qxhFQKeB558Evjzn4FrroEzOxtjxo5FiU4HnH8+e9OSDEvU1taKs3R4nsdPKSm44t//ZsdK9fRK1oKqKvkCkkeOhNbL6ciOHaxSkZ/PqiRAaIFBAFCpoFOr4Y023Fddjdbk5OghyGRifTFuNzB3LusRarNnzx6M7ey+gLW1bCaaoL5e/L6hoUFc28fhcOD666/H3srKiBAkLCDIcZz4+7N3716M6eKq92azmYWgP/+ZfbXTiMzzvNj8fMMNN3TpcQnpCIUgQvqYcePGsR20JebMmYPzzjsPeXl52Llzp+JaKQBYpWLiRAyqrUV5+Jt+ayvgcLBAs38/6tPSkGm1Ilhby96ITzoJFW43AjfcAFx5JevjuO02xb4V6Qwdnucx54kngH/+k61eLRyj18tXCW7PQw/FdlysPvuMLTAJsLBxyy3Addexxu32eDys2qXRsP4aIQQVF4vr6ACArrAQ3mh7uFVXw2mzwWazydfbkTrtNNbMnprKqiNtYbGkpAQFBQXRh9qi8fsjK0F1dWKzc0NDA9LS0uT3azSyELR1K1tmAUB1dTUyMzNhNBrF1cuLi4sjVwaPk9lshqOxkQ0xTp8e8+0K25khSUgiUAgipI/R6XQRb55qtRo2mw3nnnsu/vnPf4qzyRQZjRimVrO+D6nPPwcuvJD9W6/H119/jdl//zv4V19lVaC774bX68XG778P7bsUQx/INddcg7xJk1gzd9h5xLRq9NGj7PGlU+3bs3p15CahtbWsyiXYtg3Yt4+Fg0cfZQsG/utfLAC2FzC++goQtjSRVoKKimTTt3Vjx8K7eXPodsXFoUUDt25F6+DBKCwsRF1dnfLj/Pa37JwAtnJy24KTPM8j5fPPYY9jBWO4XMCJJ7KAIQ1BYZWgIUOGwG63h643GNiQWWMjC2NgQ1/JycmYM2cOvvvuO/A8j0AgIA6ldZbZbIZDrQYef7zDY2k1ZtKTKAQR0ofxPC/79J6cnIyxY8cqD4dJ5KSloSI8BL31FlrPOw972vpc/H4/9CefzLbhuOkmIC0NhYWF8oXyopxTTIxG8I2N2NjRIo4bNrBm4a+/Zt87nWwmmpKvv2ahRjh282bWALxihXzrkJIS1uT97rvs33PmsH6nWbPYZdEsXw5cdRV7jmlpLEgAkSFo/Hh4hV6qfftYpemjj1iQ+/57OEeORGFhoWJDOwDWlNxWpcGoUWy2GADY7chYuxa1zzzTzg8sTFERG+5bvpyFIIOBVbQklaD6+nqMGjUKtbW1odtptWyrirCqIsdxUKlUuOSSS/Diiy8mZFq60WhE6/33s9lphPQhFIII6YPUajUCgYBs2wDBH//4xw5vr8rJAS/91P/998DYsdhaVISvhQDRRl9QAPcll4jfazSadptzq6urxQXs2pORmYmdW7fi9ddeUz7g119ZpWXDBuD//b9QsHnuOeCvf1W+zZIlbPNYYahv4UK2+N+qVaEd0X0+Vsm64ALgjjtYD4pgwQLgjTeU77u5mQWw7GxcdNFFrAomBL4jR+TDYfn58ApDa5s3A7fdxs5l0SIgJwdOr7f9ECQ1cmQoBB08iIx77kHtt9+yKe/BIPDpp+3f/vBh4IEH2H/T00PbYUgqQR6PB/n5+fIQBLDHkDTXS+Xm5uKuu+7CtGnTOn4OHVCpVODDqkmffPKJ+O8jR47g22+/RSAQiH01akISgH7bCOmDhO0zSktLkS/ZriBmmZlsqKPN6/fcA9x7L44ePYrU1FS4XC5xs9bwRuzp06eLb5YjRoyImJm2c+fOmJp38/Ly8J8PPsBZX3+NgFKoWrSITUUvLYXvuONYM/PWrWxtotNOi+zfaWlh1Yv8/FCFRq1moYk9IHtT37uXNfoefzwbAhNmsQGsITcjQ3mn9c8+Ay66CEBYtYvn2XCXpC9Gp9fDq9GwfiOhsfjss1k1aN48tLa2Ii8vL7aNOdsqQR6PB/ojR5A+cyZqhw5lwaiykvVZtVd9O3yYTdtftowFIGHqe319qNoEtu2ENATxPM+OjaNHJ5GWtVX7Dhw4gM2bN6OkbQuWHMkeZYR0NwpBhPRB48aNw6+//tr5EJSVFQpBO3dind2Oer1eHOrYuXOnOP145MiROHDggHjTvLw83H///QCAE088EYMHD8bbb78tBoPi4uKYKkF5Q4bAeOgQRvr9KProI/mVbjd7o774YqCwEI8//jhw6aVsGv6SJcCpp7L1eqTWrmXDWUKFxutllY6xY9lw2vjxbHhn2zbWdMxxgGRjTdHYsaGp74EAWwMJYNs2zJ4NnudD1bC0NBasvF62Vk4bnU4H74gRbCbZ/v1sSEmtBl57DTj7bDidTphMptiGDocOBYqKWNWvqgqmKVPQmpzMqk9FRaxnZ+9etueXdO2hvXvZsNehQ2yo77LL4PP7wZvNLORJhsMAtmFoa2urvOfmL3+R9xH1EGETWqfTia1bt+LSSy+FwWDAgQMHutyETUg8KAQR0gfpdDq43W60trbCbDbHfweZmaFqx+LFOP366/Htt98CYKFn5cqV4gwzg8GAE044IepdjR8/HrNmzcJLL72E9957L+bhEXN2Nv58+DDGvvQSdof34QiB5pZbgJdeQlFRERovvxx46in2hj5tmny1agBYuZKFHYGwY/0zz7CepnHjgN27sfTVV9HY3pRuaQj6/nu2rUVzMwsZgwahpqYGkyZNYrPr8vPZVPuwHiydTgfvqFFsKEwakM45B0hKgt/vj31TTp0O8PlQW1GBjKQkcBoNuMxMFoCKithyBqtXs01YpVW5xx5jQ4ilpew8wYaYjvj9ipUggPUGpUkvk4TEYDAYfe2jBDt69CguvPBC/PrrrwgGg1Cr1Zg2bRref/99tggnIT2EQhAhfdRxxx2H7du3d+7GmZmwejywHzmCFrsd2ccdh7KyMiQnJ2PixInYu3evrPeio+bXnJwc3HHHHRg+fHhokcSOJCdDc9JJMM+bB2dREevVEXz8MdstHADUakyfPh3fffdd6HppnwzAZk+VloY2lbVYgF272ErHOh2gVuMHrxdYtQoejwcbw/c8kxo3LhSCPvyQDTf9+99sjy0Ahw8fxllnncU2ss3PZyEpbAsTsRL03Xfy3dA7S6tF3fLlSBf6czIzWSXoyBEWfl5+mc0CkwxboqSEhaNgUFzEcu/evXBoNCzUScKZUJGqrKyMWsX78ccfcfLJJ3f9uUQhrUAVFRVh5syZoa1FwHZ1r6+vpx3dSY+iEERIH3XCCSdg0KBBnbtxVhbGqFTYs2YNjuTnY8iQIXC73Zg0aRJ0Oh3uuOOOuO+S4zhMmjQp9huMHcvW6uE48GecAZx7LvDOO+y6igox0ASDQSQnJ6NZ0qfz686dbMr9/fez1a1vv51ViQR5eaxS1DZ0wvM8nnr7bTjWrEHupZfKp4KHGzaMDSEFg2xI6cEH2b5VbQHk6NGjOPHEE1FRUcEeh+fZHlgSOp0OXpOJDYeFLw3QGUOHon7VKqQ++CB7PhYLm/JeVARMmMCqZkuXhkJQIMCGsfbsEQMQwJraW9RqFoIUqjrhPTfS4bpDhw5FX38qwerq6pCRkYGamhpZZWrBggU98viECCgEEdKH3X333Z27YWYmhrrdKPrlFxzR6zFkyBD8/ve/F98AZ0SZEZRQVisb1gJCjbvffMMWbTQaxcMaGxuRmpoqVgp4nmcL9T37LGtUXruW7eou3UIhLAQ5nU6cMGkSXpg3DzPa2XgWAGuu9vvZmkBTp7L+qXHjxBAUDAah0+nYismnncam3oetXSOu5TR+vLjacpfcfDMCt98OjVBVEh6vsRFISQFefJGFLWHdoZISFiILC8V9v4C2PbpUKtYbJan4CD9bjUYjhg6z2YzW1lYA6JFZWeH9URzH4aeffsIpp5wiXnb66ad36zkQEu4Y2OiHEBLBZALndAJ+P1pzczvXV5RAKpUKfHY2uKoqNjVesoFmTU0NMjMz4Xa74XA44PV6kZKSwq4U9vCScLlcsBuNyN68WQxBLS0tOP3007HG7UZ6ejpycnLan2lkNgNPPw189hlWrlyJ87/6KmJYi+M4tvdW22rKUmIIuvFGxetl9xGLsWNZVUl6O7WaNT6HLgz9e98+tht9YaG4yGRLSwtycnLgaGgA3noLeOkl8XAhgEyYMEE8J5vNBrvdDrPZjB07dsRX5UuQe+65R9wnjJDeQJUgQo5hfHU1q3T0MqvVipaWFtZgvGkTcMIJ2LZtG5qbm8UQNHz4cBw6dAhHjhzBEMmaPOGKi4uxtbmZDVO1bfbZ3NwMi8WCv/3tbwCAk08+GZulKzqHu+461mdjMuHTTz+VBaBYgosYgi68UGxKTrj8fFnFDACrrtntLASNHs32arv5ZgBsU9tJkybBp9OxClLbruxSt0u2NRFCEADs27cPoxMxrNcOnucj1p/qzh4kQmJBIYiQY1iKx4PGzu5KnkCZmZmorq5ma/e8+SZw/PFYvnw5ioqKUFtbi/T0dAwdOhSHDx9GSUlJu3tG1dfXo1mnY8NAbYGlpaUFFotFPEY61KPogguAUaPgdrsjtraIZVq7VquNvi9YGMWNbMGGoKL1ZlmtVtRlZMhWqQYADB/O+pmEECRx5MgRFBYWsinyl14qBjuXywVjW5iSNh1LQxDP890+HDZ79mysWrUKAG2NQfoOCkGEHKvUakyxWLBly5bePhNkZWWxEDRlClBVBX9WFkaNGoVDhw7B5/NBp9PBYDDA4/HA7Xa3uy1IfX093AYDcMYZ4mXhIUiJ1+vFv//9b9llpaWlGCzpqWloaAgNxSF6IFKpVDGFJZvNJmv4ltqwYQOOP/54lAr7k0mcffbZ+MrjYesdSY0YwZqjKyqAnBxZiBP7etLSZKtil5eXw+/3K55buw3kCZaeno76+nq8+eabOPXUU3vscQlpD4UgQo5VGRnISk/HxRdf3NtngszMTLaFxOTJwNSp+GbdOpx33nkxV1OknE4n9EZjaMNSsBBktVrbvd2vv/6Kqqoq2WVHjx7FkCFDxPVxDh8+jOHDhwMAUlJS0BTLBrDtSE1NRWNjo/j93r17xX+Xlpbi1ltvxerVqyNup9Pp4BsxAsErr5RfMWIE8MgjwEknARwHrVaLr776ShbIOI6T9Q81NzeLC2NKWa1WNDc3o6ysrPOzEON00kkn4eyzz5YFT0J6E4UgQo5VmZnAsGGYO3dub5+JWOVBRgY++c1vYLfbFRfFi2WYRKkC09raCpPJ1O5x+/fvj+g1qq2txbhx48Q9voqLi8UVi3Nyctg0+TjOI1xKSgoaGhrE74V1n9xuN/RtK3gnJSUp3teZZ56Jzz//XH7hlCnAF18Af/oTALbHXDAYbLenp6amBhkKq0JrNBoEAgH8/PPPOPHEEzt8LokwduzYHgtchMSiSyFo0aJF4DgOCxcuFC/jeR6PPfYYcnNzkZSUhDPOOAO7d++W3c7j8WDBggVIT0+HyWTC3LlzURa+TxAhpGsyMyN7SnoZz/Nodblw+eWXJ/x+owWo22+/HR6PR7Hvhed5DBo0SAw7fr8fOp0OANtAtL0QFIvU1FRZCJK68MILAbB94vbt2xdxfUFBASzhw5kaTUQvUHZ2NlauXBl1dldTU1O7M7CELT4IGYg6HYI2b96MpUuXYqJkqisAPPXUU3j22Wfxz3/+E5s3b0Z2djbOPvtsNjOkzcKFC7FixQosX74cGzduhMPhwIUXXthjS7YTMiBcfjkg2R2+LwjfgZ7jOFnjsNVq7fB1INamWmE4a9y4cfjyyy+j3k4adqQVmbS0tIim6XArVqwQm33bO4dwBoNBXLbguOOOw8aNGxV7ms4880zZvm5KZsyYgbKysqiNzT3R9ExIf9WpvwyHw4H58+fjX//6V0QT4fPPP49HHnkEl1xyCcaPH4///Oc/cDqdeLdt7yC73Y7XXnsNixcvxqxZs3DCCSdg2bJl2LlzJ77++uvEPCtCCNsGImzvqN524MABjBw5Uvx+8ODBqGxb5wZgG8cmatXiwsJCbN26FUOGDEFlZWXUxmmLxSL7kCaIJTi4XC5wHIf90i0+JDQajdiUHAgEoJas7iw9pqqqSnHIKhY6nQ7PPPNMp25bUVFBe3WRAa1TIejOO+/EBRdcgFlh61AcOXIEVVVVmD17tniZXq/HjBkzsKltM8StW7fC5/PJjsnNzcX48ePFY8J5PB40NzfLvggh/U9ZWZnsTXf06NGymWCFhYWyFYS7oqCgAO+88w5OO+00zJ49G6eeeirUarXiTKmuOOecc/Dzzz93eFxjY6PsQ6OUWq1Genp6zI8Z3uCtFK5i8csvv2Dq1Kmdui0hx4K4V4xevnw5tm3bprgQmfCHmRW2OFtWVhZKSkrEY3Q6XcSLQVZWVsQftmDRokV4/PHH4z1VQkgfEz40k5aWhvnz58d9H7EwGo1obW2FzWaDzWYDAGRkZKC2thZHjx5FQ0ODbIispaUl7pW1ow2xKV1eV1cn38Fd4vLLL++wIiPte/rmm29wzTXXxHWuSubMmdPucgSEHOviqgSVlpbinnvuwbJly2BoZ+fk8BeA9poWYznmoYcegt1uF7+U1tUghPRP3bltwn333Sf7Pjs7G1VVVTh8+DDGjx8v26tq8+bNGNvJfcAGDRqE8vJy8XuloFZfXx+12jNixIioYURYmPGTTz7psD8oXleGT8EnZICJKwRt3boVNTU1mDx5MjQaDTQaDTZs2IAlS5ZAo9GIFaDwik5NTY14XXZ2Nrxer2ztjPBjwun1elitVtkXIaR/0ev1cLvdXbqPYDAYV5PvSSedJPs+OzubLdoIID8/X5yuXVdXh+bmZnGNIEGsVafTTjsNGzduBAD4fD7ZysyC+vr6qJWg9uTm5qKyshL19fXYvXs36uvrkZqaGvPtY30OhAxEcYWgmTNnYufOndi+fbv4NWXKFMyfPx/bt2/H0KFDkZ2djTVr1oi38Xq92LBhA6a17SY9efJkaLVa2TGVlZXYtWuXeAwh5NiTlZUFjaZrezbb7XZxaKszb+7JycmKU9ZvvvlmzJs3T/E20seRNjdLL9fpdDh06BAA5TWLhMuN4XuBxSAvLw9lZWUwGAxwuVw4ePCgrLmcENJ5cb0iWSwWjB8/XnaZyWRCWlqaePnChQvxt7/9DSNGjMCIESPwt7/9DUajURy/ttlsuPnmm3HfffchLS0NqampuP/++zFhwoSIRmtCyLFjyJAhXR76qqurQ3p6OtxuN9xuN+rr65GXlxfz7TmOw5EjR3DWWWfJLo+2To6w1YMwjOX1esV1hOrr6zFmzBjx2MLCQgSDQTidzqhhpzN7ZuXm5sp6MIuLi9td3FAYPtPpdHA6ndTzQ0g7Er54xB/+8AcsXLgQd9xxB6ZMmYLy8nKsXr1aNj31ueeew7x583DFFVfg1FNPhdFoxGeffdbpGQ6EkL4vNzcX48aNi+s2xcXFsgULhSElYcuHp556CjzPx1UV2rFjR8T6Zu2ds/TxpSGovLxctvrx8ccfjx07dnS64hONVquF0+mETqcDz/MIBoPtvlZaLBY4HA4AbEXszMzMhJ0LIceaLoeg9evX4/nnnxe/5zgOjz32GCorK+F2u7Fhw4aI6pHBYMALL7yA+vp6OJ1OfPbZZ8jPz+/qqRBCjjH5+flYu3at+L1QCRI2//R4PHGv6jx06NCYV0geNGgQPvvsM3F2q9frFft9KioqZCFo7Nix2LNnD3744YeI1zygazunC+srCUNi7ZGue1RbW9vp9YcIGQhoGVFCSJ+lVqvB87y4ivSOHTtgsVhgtVpht9sxduxY7N69O66Acf/998d8bEpKCh544AFxNqyw4z0AJCUlySZpcByH6upqpKamyoag9Ho9XC5XlxqUjx49ilGjRmHs2LGKW2xImc1mMQTV1NRQJYiQdlAIIoT0aTNnzsSqVasQDAaRlZUFjuNgs9lQVFSEsWPHory8XHE2VjTxLEoIsKZnYeaqdDhsyJAhEeHrwgsvxAUXXCC77JRTTsH3338f12OGO/vss2EwGDB8+HDo9fp2j5UOh9XU1IiN5ISQSBSCCCF92qBBg+D3+/Hcc8/hvPPOA8AmWGzevBkjR45ES0tL1C0xEk0agmbOnBlx/ciRIyOCkTDFvSuuu+46AKw/6K9//Wu7xwrDYfX19UhKSurSMBwhx7quzVclhJAecNFFF2H37t1iD45er8eBAweQn5/foyEoEAiIQ2PhaxC1J3yj2O5kNpvR3NyM//73v7j99tt75DEJ6a+oEkQI6RekM8s4jgPHcVCpVEhOTu6xBVTHjBkT9ww3ADj11FN7rCKj1+vx/vvv47LLLqMZt4R0gCpBhJB+SVij55RTTunzM6CGDBmCwsLCHnksjuPw8ssvR92slRASQiGIENIvCRuvTp48uZfPJDY92ZtDAYiQ2NBwGCGkX5owYUJvnwIhpJ+jEEQIIYSQAYlCECGEEEIGJApBhBBCCBmQKAQRQgghZECiEEQIIYSQAYlCECGEEEIGJApBhBBCCBmQKAQRQgghZECiEEQIIYSQAYlCECGEEEIGJApBhBBCCBmQKAQRQgghZECiEEQIIYSQAYlCECGEEEIGJApBhBBCCBmQKAQRQgghZECiEEQIIYSQAYlCECGEEEIGJApBhBBCCBmQKAQRQgghZECiEEQIIYSQAYlCECGEEEIGJApBhBBCCBmQKAQRQgghZECiEEQIIYSQAYlCECGEEEIGJApBhBBCCBmQKAQRQgghZECiEEQIIYSQAYlCECGEEEIGJApBhBBCCBmQKAQRQgghZECiEEQIIYSQAYlCECGEEEIGpLhC0Msvv4yJEyfCarXCarVi6tSp+PLLL8XrHQ4H7rrrLuTl5SEpKQljxozByy+/LLsPj8eDBQsWID09HSaTCXPnzkVZWVling0hhBBCSIziCkF5eXl48sknsWXLFmzZsgVnnXUWLrroIuzevRsAcO+992LVqlVYtmwZ9u7di3vvvRcLFizAJ598It7HwoULsWLFCixfvhwbN26Ew+HAhRdeiEAgkNhnRgghhBDSDo7neb4rd5Camoqnn34aN998M8aPH48rr7wSjz76qHj95MmTcf755+Mvf/kL7HY7MjIy8Pbbb+PKK68EAFRUVCA/Px8rV67EOeecE9NjNjc3w2azwW63w2q1duX0CSGEENJD+tr7d6d7ggKBAJYvX47W1lZMnToVAHDaaafh008/RXl5OXiex7p163DgwAEx3GzduhU+nw+zZ88W7yc3Nxfjx4/Hpk2boj6Wx+NBc3Oz7IsQQgghpCs08d5g586dmDp1KtxuN8xmM1asWIGxY8cCAJYsWYJbb70VeXl50Gg0UKlU+Pe//43TTjsNAFBVVQWdToeUlBTZfWZlZaGqqirqYy5atAiPP/54vKdKCCGEEBJV3JWgUaNGYfv27fjxxx9x++2344YbbsCePXsAsBD0448/4tNPP8XWrVuxePFi3HHHHfj666/bvU+e58FxXNTrH3roIdjtdvGrtLQ03tMmhBBCCJGJuxKk0+kwfPhwAMCUKVOwefNm/OMf/8Dzzz+Phx9+GCtWrMAFF1wAAJg4cSK2b9+OZ555BrNmzUJ2dja8Xi8aGxtl1aCamhpMmzYt6mPq9Xro9fp4T5UQQgghJKourxPE8zw8Hg98Ph98Ph9UKvldqtVqBINBAKxJWqvVYs2aNeL1lZWV2LVrV7shiBBCCCEk0eKqBD388MM477zzkJ+fj5aWFixfvhzr16/HqlWrYLVaMWPGDDzwwANISkpCQUEBNmzYgLfeegvPPvssAMBms+Hmm2/Gfffdh7S0NKSmpuL+++/HhAkTMGvWrG55goQQQgghSuIKQdXV1bjuuutQWVkJm82GiRMnYtWqVTj77LMBAMuXL8dDDz2E+fPno6GhAQUFBXjiiSfwu9/9TryP5557DhqNBldccQVcLhdmzpyJN998E2q1OrHPjBBCCCGkHV1eJ6g39LV1BgghhBDSsb72/k17hxFCCCFkQKIQRAghhJABiUIQIYQQQgYkCkGEEEIIGZAoBBFCCCFkQKIQRAghhJABiUIQIYQQQgYkCkGEEEIIGZAoBBFCCCFkQKIQRAghhJABiUIQIYQQQgYkCkGEEEIIGZAoBBFCCCFkQKIQRAghhJABiUIQIYQQQgYkCkGEEEIIGZAoBBFCCCFkQKIQRAghhJABiUIQIYQQQgYkCkGEEEIIGZAoBBFCCCFkQKIQRAghhJABiUIQIYQQQgYkCkGEEEIIGZAoBBFCCCFkQKIQRAghhJABiUIQIYQQQgYkCkGEEEIIGZAoBBFCCCFkQKIQRAghhJABiUIQIYQQQgYkCkGEEEIIGZAoBBFCCCFkQKIQRAghhJABiUIQIYQQQgYkCkGEEEIIGZAoBBFCCCFkQKIQRAghhJABiUIQIYQQQgYkCkGEEEIIGZAoBBFCCCFkQKIQRAghhJABKa4Q9PLLL2PixImwWq2wWq2YOnUqvvzyS9kxe/fuxdy5c2Gz2WCxWHDKKafg6NGj4vUejwcLFixAeno6TCYT5s6di7KyssQ8G0IIIYSQGMUVgvLy8vDkk09iy5Yt2LJlC8466yxcdNFF2L17NwDg8OHDOO200zB69GisX78eO3bswKOPPgqDwSDex8KFC7FixQosX74cGzduhMPhwIUXXohAIJDYZ0YIIYQQ0g6O53m+K3eQmpqKp59+GjfffDOuuuoqaLVavP3224rH2u12ZGRk4O2338aVV14JAKioqEB+fj5WrlyJc845J6bHbG5uhs1mg91uh9Vq7crpE0IIIaSH9LX37073BAUCASxfvhytra2YOnUqgsEgvvjiC4wcORLnnHMOMjMzcfLJJ+Pjjz8Wb7N161b4fD7Mnj1bvCw3Nxfjx4/Hpk2boj6Wx+NBc3Oz7IsQQgghpCviDkE7d+6E2WyGXq/H7373O6xYsQJjx45FTU0NHA4HnnzySZx77rlYvXo1Lr74YlxyySXYsGEDAKCqqgo6nQ4pKSmy+8zKykJVVVXUx1y0aBFsNpv4lZ+fH+9pE0IIIYTIaOK9wahRo7B9+3Y0NTXhww8/xA033IANGzYgOTkZAHDRRRfh3nvvBQAcf/zx2LRpE1555RXMmDEj6n3yPA+O46Je/9BDD+H3v/+9+H1zczMFIUIIIYR0SdyVIJ1Oh+HDh2PKlClYtGgRjjvuOPzjH/9Aeno6NBoNxo4dKzt+zJgx4uyw7OxseL1eNDY2yo6pqalBVlZW1MfU6/XijDThixBCCCGkK7q8ThDP8/B4PNDpdDjxxBOxf/9+2fUHDhxAQUEBAGDy5MnQarVYs2aNeH1lZSV27dqFadOmdfVUCCGEEEJiFtdw2MMPP4zzzjsP+fn5aGlpwfLly7F+/XqsWrUKAPDAAw/gyiuvxPTp/7+9+41pq2zDAH51DMrZoMUyaWEsOMXggszNaQRBQfkzl2HYTNRARiSZmii4GeXDdDOgX5iK4BwioOKGJuoHWLLpJGIYMDPdGHYZogNNtmQJBdQwwSEwxv1+2EsD8q+0pbQ91y/pBw7Pec59Lpo+d04P7YN46KGHUF9fj2PHjqGpqQkAoNfrsXPnTrz88ssIDg6GwWBAfn4+YmJikJKS4vSTIyIiIprNgpqg3t5eZGdnw2KxQK/XY/369aivr0dqaioAYPv27aioqEBRURF27dqFqKgo1NbWIiEhwTpHaWkpli9fjieeeAL//vsvkpOTcejQIfj4+Dj3zIiIiIjm4PDnBC0Fd/ucASIiIpqfu63f/O4wIiIiUiU2QURERKRKbIKIiIhIldgEERERkSqxCSIiIiJVYhNEREREqsQmiIiIiFSJTRARERGpEpsgIiIiUiU2QURERKRKbIKIiIhIldgEERERkSqxCSIiIiJVYhNEREREqsQmiIiIiFSJTRARERGpEpsgIiIiUiU2QURERKRKy5e6AHuICABgYGBgiSshIiIiW02s2xPr+FLzyCZocHAQALBmzZolroSIiIgWanBwEHq9fqnLgEbcpR1bgPHxcXR3dyMwMBAajcZp8w4MDGDNmjW4fPkydDqd0+b1VszLfszOPszNMczPfszOPv/NTUQwODiIsLAwLFu29HfkeOSVoGXLliE8PHzR5tfpdHySLwDzsh+zsw9zcwzzsx+zs8/k3NzhCtCEpW/DiIiIiJYAmyAiIiJSJTZBk2i1WhQUFECr1S51KR6BedmP2dmHuTmG+dmP2dnH3XPzyBujiYiIiBzFK0FERESkSmyCiIiISJXYBBEREZEqsQkiIiIiVWITRERERKrk9k1QUVER7r33XgQGBiIkJATbtm1DZ2fnlDEigsLCQoSFhUFRFCQlJaGjo2PKmKqqKiQlJUGn00Gj0eDKlSvTjtXV1YWMjAysWrUKOp0O8fHxOHHixLw1tre3IzExEYqiYPXq1XjjjTemfDmcxWJBVlYWoqKisGzZMrz44ot2ZWELb8jr+++/R3x8PIKDg6EoCu644w6UlpbaF8gCeEN2TU1N0Gg00x4XLlywLxQbeENuOTk5M+YWHR1tXygL4A35AcD777+PdevWQVEUREVFoaamZuFhLJC7Zzc8PIycnBzExMRg+fLl2LZt27QxrlwfJrgyt59++gmpqakICgpCcHAwnn32Wfzzzz/z1uiqddXtm6Dm5mbk5ubixx9/RENDA8bGxpCWloarV69ax7z11lsoKSlBWVkZWltbYTKZkJqaav2iVQAYGhrCI488gldffXXWY23duhVjY2NobGxEW1sbNmzYgPT0dPT09My6z8DAAFJTUxEWFobW1lYcPHgQxcXFKCkpsY4ZGRnBzTffjL179+Kuu+5yMJG5eUNeK1euRF5eHlpaWvDrr79i37592LdvH6qqqhxMZ27ekN2Ezs5OWCwW6+P222+3M5X5eUNuBw4cmJLX5cuXYTAY8PjjjzuYzvy8Ib8PPvgAr7zyCgoLC9HR0YHXX38dubm5OHbsmIPpzM3ds7t+/ToURcGuXbuQkpIy4xhXrg8TXJVbd3c3UlJSEBkZidOnT6O+vh4dHR3IycmZsz6XrqviYfr6+gSANDc3i4jI+Pi4mEwm2b9/v3XM8PCw6PV6qaiomLb/iRMnBID09/dP2f7HH38IAGlpabFuGxgYEADy3XffzVpPeXm56PV6GR4etm4rKiqSsLAwGR8fnzY+MTFRdu/ebevpOszT85qwfft22bFjx7zn60yemN1sx3QlT8ztv44cOSIajUYuXbpk0zk7kyfmFxcXJ/n5+VP22717t8THx9t+4k7gbtlN9tRTT0lGRsacY1y9PkxYrNwqKyslJCRErl+/bt1mNpsFgPz222+z1uPKddXtrwT9199//w0AMBgMAICLFy+ip6cHaWlp1jFarRaJiYk4deqUzfMGBwdj3bp1qKmpwdWrVzE2NobKykoYjUZs2rRp1v1++OEHJCYmTvk0zM2bN6O7uxuXLl1a4Nk5nzfkZTabcerUKSQmJtpcnzN4cnYbN25EaGgokpOTbXq7w5k8ObcJH3/8MVJSUhAREWFzfc7iifmNjIzA399/yn6KouDMmTO4du2azTU6yt2y8xSLldvIyAj8/PymfFu8oigAbtz2MBtXrqse1QSJCF566SUkJCTgzjvvBADrpUij0ThlrNFonPMy5X9pNBo0NDTAbDYjMDAQ/v7+KC0tRX19PYKCgmbdr6enZ8ZjT65tqXh6XuHh4dBqtbjnnnuQm5uLp59+2ub6HOWp2YWGhqKqqgq1tbWoq6tDVFQUkpOT0dLSYnN9jvDU3CazWCz45ptvXPp8m+Cp+W3evBkfffQR2traICI4e/Ysqqurce3aNfz555821+gId8zOEyxmbg8//DB6enrw9ttvY3R0FP39/da3ziwWy6z7uXJd9agmKC8vD+fPn8fnn38+7XcajWbKzyIybdtcRATPP/88QkJCcPLkSZw5cwYZGRlIT0+3/rGio6MREBCAgIAAbNmyZc5jz7Td1Tw9r5MnT+Ls2bOoqKjAu+++O+N5LBZPzS4qKgrPPPMM7r77bsTFxaG8vBxbt25FcXGxzfU5wlNzm+zQoUMICgqa8SbWxeap+b322mvYsmULYmNj4evri4yMDOt9Hz4+PjbX6Ah3zc7dLWZu0dHROHz4MN555x2sWLECJpMJt956K4xGo/V5sdTr6nKnzraIXnjhBRw9ehQtLS0IDw+3bjeZTABudIehoaHW7X19fdM6ybk0Njbiq6++Qn9/P3Q6HQCgvLwcDQ0NOHz4MPbs2YPjx49bL+1OXNIzmUzTOtO+vj4A07toV/KGvNauXQsAiImJQW9vLwoLC5GZmWlzjfbyhuwmi42NxWeffWZzffbyhtxEBNXV1cjOzoafn5/NtTmDJ+enKAqqq6tRWVmJ3t5e6xXJwMBArFq1aqFRLJi7ZufuFjs3AMjKykJWVhZ6e3uxcuVKaDQalJSUWF/fl3pddfsrQSKCvLw81NXVobGx0RrchLVr18JkMqGhocG6bXR0FM3Nzbj//vttPs7Q0BAATHnvcuLn8fFxAEBERAQiIyMRGRmJ1atXAwDi4uLQ0tKC0dFR6z7ffvstwsLCcMsttyzoXJ3BW/MSEYyMjNhcnz28NTuz2TzlhczZvCm35uZm/P7779i5c6fNdTnKm/Lz9fVFeHg4fHx88MUXXyA9PX3a8ZzJ3bNzV67KbTKj0YiAgAB8+eWX8Pf3R2pqKgA3WFftup3ahZ577jnR6/XS1NQkFovF+hgaGrKO2b9/v+j1eqmrq5P29nbJzMyU0NBQGRgYsI6xWCxiNpvlww8/tN7lbzab5a+//hKRG3f/BwcHy2OPPSbnzp2Tzs5Oyc/PF19fXzl37tys9V25ckWMRqNkZmZKe3u71NXViU6nk+Li4injzGazmM1m2bRpk2RlZYnZbJaOjg4np+UdeZWVlcnRo0elq6tLurq6pLq6WnQ6nezdu9fpeU3mDdmVlpbKkSNHpKurS37++WfZs2ePAJDa2tpFSOwGb8htwo4dO+S+++5zYjrz84b8Ojs75dNPP5Wuri45ffq0PPnkk2IwGOTixYvOD2wSd89ORKSjo0PMZrM8+uijkpSUZF0LJnPV+jDBVbmJiBw8eFDa2tqks7NTysrKRFEUOXDgwJz1uXJddfsmCMCMj08++cQ6Znx8XAoKCsRkMolWq5UHH3xQ2tvbp8xTUFAw7zytra2SlpYmBoNBAgMDJTY2Vo4fPz5vjefPn5cHHnhAtFqtmEwmKSwsnPZvfDMdOyIiwpFoZuQNeb333nsSHR0tK1asEJ1OJxs3bpTy8vIp/2a5GLwhuzfffFNuu+028ff3l5tuukkSEhLk66+/djibuXhDbiI3XngVRZGqqiqH8lgob8jvl19+kQ0bNoiiKKLT6SQjI0MuXLjgcDbz8YTsIiIiZpx7vvNYjPVhruMtVm7Z2dliMBjEz89P1q9fLzU1NTbV6Kp1VfP/iYiIiIhUxe3vCSIiIiJaDGyCiIiISJXYBBEREZEqsQkiIiIiVWITRERERKrEJoiIiIhUiU0QERERqRKbICIiIlIlNkFERESkSmyCiIiISJXYBBEREZEq/Q89Uu4gbuDMBwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Jungfraujoch_13\n", + "RMSE for Jungfraujoch_13 (Time: 0:00-7:00): 2.0936499868978484\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Karlsruhe_200\n", + "RMSE for Karlsruhe_200 (Time: 12:00-17:00): 6.269164507580145\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Kresin u Pacova_250\n", + "RMSE for Kresin u Pacova_250 (Time: 12:00-17:00): 4.779867829743723\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Heathfield_100\n", + "RMSE for Heathfield_100 (Time: 12:00-17:00): 5.16261949284921\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: La Muela_80\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-03-12 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-03-22 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-08-29 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-09-08 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-09-18 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-09-28 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-10-08 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-10-18 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-10-28 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-11-07 00:00:00\n", + "RMSE for La Muela_80 (Time: 12:00-17:00): 3.9377850799858414\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Laegern-Hochwacht_32\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-01 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-11 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-05-11 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-05-21 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-05-31 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-11-27 00:00:00\n", + "RMSE for Laegern-Hochwacht_32 (Time: 12:00-17:00): 7.6073774299042185\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Lindenberg_98\n", + "Skipping Lindenberg_98: Not found in ICON dataset on 2018-04-01 00:00:00\n", + "RMSE for Lindenberg_98 (Time: 12:00-17:00): 4.975832792946022\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Lutjewad_60\n", + "RMSE for Lutjewad_60 (Time: 12:00-17:00): 4.7013604883358715\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Monte Cimone_8\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-01 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-11 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-03-12 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-03-22 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-04-01 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-04-11 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-04-21 00:00:00\n", + "RMSE for Monte Cimone_8 (Time: 0:00-7:00): 3.010641066355188\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Observatoire de Haute Provence_100\n", + "RMSE for Observatoire de Haute Provence_100 (Time: 12:00-17:00): 4.222056466810487\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Observatoire perenne de l'environnement_120\n", + "RMSE for Observatoire perenne de l'environnement_120 (Time: 12:00-17:00): 5.5236885807122915\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Pic du Midi_28\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "RMSE for Pic du Midi_28 (Time: 0:00-7:00): 2.0843713258172123\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Plateau Rosa_10\n", + "Skipping Plateau Rosa_10: Not found in ICON dataset on 2018-04-21 00:00:00\n", + "RMSE for Plateau Rosa_10 (Time: 0:00-7:00): 1.9979033074650259\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Puy de Dome_10\n", + "RMSE for Puy de Dome_10 (Time: 0:00-7:00): 4.330821043481535\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Ridge Hill_90\n", + "RMSE for Ridge Hill_90 (Time: 12:00-17:00): 4.100794768506457\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Saclay_100\n", + "RMSE for Saclay_100 (Time: 12:00-17:00): 6.1904467326367945\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Schauinsland_12\n", + "RMSE for Schauinsland_12 (Time: 0:00-7:00): 4.018460150933421\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Tacolneston_185\n", + "RMSE for Tacolneston_185 (Time: 12:00-17:00): 4.8551091246134215\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Torfhaus_147\n", + "RMSE for Torfhaus_147 (Time: 12:00-17:00): 4.4048914639305385\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Trainou_180\n", + "RMSE for Trainou_180 (Time: 12:00-17:00): 5.605470151137809\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Weybourne_10\n", + "RMSE for Weybourne_10 (Time: 12:00-17:00): 5.239988261278576\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Zugspitze_3\n", + "RMSE for Zugspitze_3 (Time: 0:00-7:00): 2.5079204353773696\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Beromunster_212': 5.246687084978375, 'Bilsdale_248': 3.7267864090697658, 'Biscarrosse_47': 4.44391367284266, 'Cabauw_207': 4.556938758005444, 'Carnsore Point_14': 3.9379375857221026, 'Ersa_40': 5.097001363286457, 'Gartow_341': 4.34505600864283, 'Heidelberg_30': 7.653180633677891, 'Hohenpeissenberg_131': 4.500672670985617, 'Hyltemossa_150': 4.451277813256869, 'Ispra_100': 7.200474834686076, 'Jungfraujoch_13': 2.0936499868978484, 'Karlsruhe_200': 6.269164507580145, 'Kresin u Pacova_250': 4.779867829743723, 'Heathfield_100': 5.16261949284921, 'La Muela_80': 3.9377850799858414, 'Laegern-Hochwacht_32': 7.6073774299042185, 'Lindenberg_98': 4.975832792946022, 'Lutjewad_60': 4.7013604883358715, 'Monte Cimone_8': 3.010641066355188, 'Observatoire de Haute Provence_100': 4.222056466810487, \"Observatoire perenne de l'environnement_120\": 5.5236885807122915, 'Pic du Midi_28': 2.0843713258172123, 'Plateau Rosa_10': 1.9979033074650259, 'Puy de Dome_10': 4.330821043481535, 'Ridge Hill_90': 4.100794768506457, 'Saclay_100': 6.1904467326367945, 'Schauinsland_12': 4.018460150933421, 'Tacolneston_185': 4.8551091246134215, 'Torfhaus_147': 4.4048914639305385, 'Trainou_180': 5.605470151137809, 'Weybourne_10': 5.239988261278576, 'Zugspitze_3': 2.5079204353773696}\n" + ] + } + ], + "source": [ + "import xarray as xr\n", + "import matplotlib.pyplot as plt\n", + "from unidecode import unidecode\n", + "import numpy as np\n", + "import datetime as dt\n", + "import pandas as pd\n", + "\n", + "# Station dictionary with measurement uncertainty\n", + "mdm_dictionary = {\n", + " 'Beromunster_212': 8.2383423, 'Bilsdale_248': 5.8534036, 'Biscarrosse_47': 5.5997221,\n", + " 'Cabauw_207': 8.6093283, 'Carnsore Point_14': 4.1894007, 'Ersa_40': 4.3997285,\n", + " 'Gartow_341': 6.570544, 'Heidelberg_30': 10.660628, 'Hohenpeissenberg_131': 6.0553513,\n", + " 'Hyltemossa_150': 5.485432, 'Ispra_100': 11.612817, 'Jungfraujoch_13': 3.0802848,\n", + " 'Karlsruhe_200': 10.05013, 'Kresin u Pacova_250': 5.829324, 'Heathfield_100': 6.6675706,\n", + " 'La Muela_80': 5.2093291, 'Laegern-Hochwacht_32': 11.556924, 'Lindenberg_98': 7.4387555,\n", + " 'Lutjewad_60': 7.651525, 'Monte Cimone_8': 3.7325112,\n", + " 'Observatoire de Haute Provence_100': 6.146905,\n", + " \"Observatoire perenne de l'environnement_120\": 8.8854113, 'Pic du Midi_28': 3.2196398,\n", + " 'Plateau Rosa_10': 3.3211231, 'Puy de Dome_10': 5.4529948, 'Ridge Hill_90': 7.0861707,\n", + " 'Saclay_100': 8.8669567, 'Schauinsland_12': 5.7896755, 'Tacolneston_185': 6.6675706,\n", + " 'Torfhaus_147': 6.622525, 'Trainou_180': 7.821612, 'Weybourne_10': 6.4674397,\n", + " 'Zugspitze_3': 3.6796716,\n", + "}\n", + "\n", + "# Stations using the midnight-to-morning window (00:00 - 07:00)\n", + "nighttime_stations = {\n", + " 'Jungfraujoch_13', 'Monte Cimone_8', 'Puy de Dome_10', 'Pic du Midi_28', 'Zugspitze_3',\n", + " 'Hohenpeissenberg_131', 'Schauinsland_12', 'Plateau Rosa_10'\n", + "}\n", + "\n", + "resample = True\n", + "\n", + "for selected_station in mdm_dictionary.keys():\n", + " print(f\"Processing station: {selected_station}\")\n", + "\n", + " # Reset start and end date for each station\n", + " startdate = dt.datetime(2018, 1, 1)\n", + " enddate = dt.datetime(2018, 12, 17)\n", + "\n", + " # Reset data storage for each station\n", + " ICON_values = []\n", + " ICOS_values = []\n", + " ICON_dates = []\n", + " ICOS_dates = []\n", + "\n", + " # Identify which time window to use\n", + " if selected_station in nighttime_stations:\n", + " time_start = 0 # 00:00\n", + " time_end = 7 # 07:00\n", + " else:\n", + " time_start = 12 # 12:00\n", + " time_end = 17 # 17:00\n", + "\n", + " while startdate < enddate:\n", + " try:\n", + " ICON = xr.open_dataset(f\"/capstor/scratch/cscs/ekoene/extracted_ICOS/runthrough_{startdate.strftime('%Y%m%d')}.nc\")\n", + " ICOS = xr.open_dataset(f\"/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_inputs/ICOS/Extracted_{startdate.strftime('%Y%m%d')}_{(startdate+dt.timedelta(days=11)).strftime('%Y%m%d')}_alldates_masl.nc\")\n", + "\n", + " full = (ICON.TRCO2_A + ICON.TRCO2_BG + ICON.CO2_RA - ICON.CO2_GPP + ICON.biosource - ICON.biosink) / (1 - ICON.qv) * 28.97 / 44.01 * 1e6\n", + " \n", + " stations = np.array([unidecode(x) for x in ICON.site_name.values])\n", + " mdm_keys = np.array([unidecode(k) for k in mdm_dictionary.keys()])\n", + "\n", + " # Ensure the station exists\n", + " if selected_station not in mdm_keys:\n", + " raise ValueError(f\"Station '{selected_station}' not found in mdm_dictionary\")\n", + "\n", + " # Get the station index\n", + " station_index = np.where(stations == selected_station)[0]\n", + " if len(station_index) == 0:\n", + " print(f\"Skipping {selected_station}: Not found in ICON dataset on {startdate}\")\n", + " startdate += dt.timedelta(days=10)\n", + " continue\n", + "\n", + " station_index = station_index[0]\n", + "\n", + " # Filter by time range\n", + " # Ensure time is in datetime64 format\n", + " ICON_times = ICON.time.values.astype('datetime64[h]')[24:] # Convert to hourly datetime\n", + "\n", + " # Extract the hours using numpy\n", + " time_hours = np.array([t.astype(object).hour for t in ICON_times]) \n", + " time_mask = (time_hours >= time_start) & (time_hours < time_end)\n", + "\n", + " full['time'] = pd.DatetimeIndex(full['time'].values)\n", + " ICOS[\"time\"] = pd.DatetimeIndex(ICOS.Dates[0].values)\n", + " full = full.isel(sites=station_index)[24:]\n", + " ICOS = ICOS.Concentration.isel(station=station_index)\n", + " if selected_station in nighttime_stations:\n", + " full = full.sel(time=full.time.dt.hour.isin([0, 1, 2, 3, 4, 5, 6, 7]))\n", + " ICOS = ICOS.sel(time=ICOS.time.dt.hour.isin([0, 1, 2, 3, 4, 5, 6, 7]))\n", + " else:\n", + " full = full.sel(time=full.time.dt.hour.isin([12, 13, 14, 15, 16]))\n", + " ICOS = ICOS.sel(time=ICOS.time.dt.hour.isin([12, 13, 14, 15, 16]))\n", + " \n", + " if resample:\n", + " full = full.resample(time='D').mean(\"time\")\n", + " ICOS = ICOS.resample(time='D').mean(\"time\")\n", + "\n", + " ICON_values.append(full)\n", + " ICOS_values.append(ICOS)\n", + " ICON_dates.append(full.time)\n", + " ICOS_dates.append(ICOS.time)\n", + "\n", + " except FileNotFoundError as e:\n", + " print(f\"Skipping date {startdate} due to missing file: {e}\")\n", + "\n", + " except Exception as e:\n", + " print(f\"Error on {startdate}: {e}\")\n", + "\n", + " startdate += dt.timedelta(days=10)\n", + "\n", + " # Flatten arrays\n", + " ICON_values = np.asarray(ICON_values).flatten()\n", + " ICOS_values = np.asarray(ICOS_values).flatten()\n", + " ICON_dates = np.asarray(ICON_dates).flatten()\n", + " ICOS_dates = np.asarray(ICOS_dates).flatten()\n", + "\n", + " if len(ICON_values) == 0 or len(ICOS_values) == 0:\n", + " print(f\"No data available for station {selected_station}\")\n", + " continue\n", + "\n", + " # Align datasets by timestamps\n", + " common_dates, icon_idx, icos_idx = np.intersect1d(ICON_dates, ICOS_dates, return_indices=True)\n", + "\n", + " icon_common = ICON_values[icon_idx]\n", + " icos_common = ICOS_values[icos_idx]\n", + "\n", + " # Remove NaN values\n", + " valid_mask = ~np.isnan(icos_common)\n", + " icon_valid = icon_common[valid_mask]\n", + " icos_valid = icos_common[valid_mask]\n", + "\n", + " # Calculate RMSE\n", + " rmse = np.sqrt(np.mean((icon_valid - icos_valid) ** 2))\n", + " print(f\"RMSE for {selected_station} (Time: {time_start}:00-{time_end}:00): {rmse}\")\n", + " mdm_dictionary[selected_station] = rmse\n", + " # Plot results\n", + " plt.plot(ICON_dates, ICON_values, 'r', linewidth=0.5)\n", + " plt.plot(ICOS_dates, ICOS_values, 'k', linewidth=0.25)\n", + " plt.legend([\"ICON\", \"ICOS\"])\n", + " plt.ylim([350, 490])\n", + " plt.title(f\"{selected_station} ({time_start}:00-{time_end}:00)\")\n", + " plt.show()\n", + "print(mdm_dictionary)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Beromunster_212\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Bilsdale_248\n", + "Processing station: Biscarrosse_47\n", + "Processing station: Cabauw_207\n", + "Processing station: Carnsore Point_14\n", + "Processing station: Ersa_40\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-01 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-11 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-10-28 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-11-07 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-11-17 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-11-27 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-12-07 00:00:00\n", + "Processing station: Gartow_341\n", + "Skipping Gartow_341: Not found in ICON dataset on 2018-10-28 00:00:00\n", + "Processing station: Heidelberg_30\n", + "Processing station: Hohenpeissenberg_131\n", + "Processing station: Hyltemossa_150\n", + "Processing station: Ispra_100\n", + "Processing station: Jungfraujoch_13\n", + "Processing station: Karlsruhe_200\n", + "Processing station: Kresin u Pacova_250\n", + "Processing station: Heathfield_100\n", + "Processing station: La Muela_80\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-03-12 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-03-22 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-08-29 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-09-08 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-09-18 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-09-28 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-10-08 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-10-18 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-10-28 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-11-07 00:00:00\n", + "Processing station: Laegern-Hochwacht_32\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-01 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-11 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-05-11 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-05-21 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-05-31 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-11-27 00:00:00\n", + "Processing station: Lindenberg_98\n", + "Skipping Lindenberg_98: Not found in ICON dataset on 2018-04-01 00:00:00\n", + "Processing station: Lutjewad_60\n", + "Processing station: Monte Cimone_8\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-01 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-11 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-03-12 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-03-22 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-04-01 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-04-11 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-04-21 00:00:00\n", + "Processing station: Observatoire de Haute Provence_100\n", + "Processing station: Observatoire perenne de l'environnement_120\n", + "Processing station: Pic du Midi_28\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Processing station: Plateau Rosa_10\n", + "Skipping Plateau Rosa_10: Not found in ICON dataset on 2018-04-21 00:00:00\n", + "Processing station: Puy de Dome_10\n", + "Processing station: Ridge Hill_90\n", + "Processing station: Saclay_100\n", + "Processing station: Schauinsland_12\n", + "Processing station: Tacolneston_185\n", + "Processing station: Torfhaus_147\n", + "Processing station: Trainou_180\n", + "Processing station: Weybourne_10\n", + "Processing station: Zugspitze_3\n", + "Processing station: Beromunster_212 for the MDM correlations\n", + "Processing station: Bilsdale_248 for the MDM correlations\n", + "Processing station: Biscarrosse_47 for the MDM correlations\n", + "Processing station: Cabauw_207 for the MDM correlations\n", + "Processing station: Carnsore Point_14 for the MDM correlations\n", + "Processing station: Ersa_40 for the MDM correlations\n", + "Processing station: Gartow_341 for the MDM correlations\n", + "Processing station: Heidelberg_30 for the MDM correlations\n", + "Processing station: Hohenpeissenberg_131 for the MDM correlations\n", + "Processing station: Hyltemossa_150 for the MDM correlations\n", + "Processing station: Ispra_100 for the MDM correlations\n", + "Processing station: Jungfraujoch_13 for the MDM correlations\n", + "Processing station: Karlsruhe_200 for the MDM correlations\n", + "Processing station: Kresin u Pacova_250 for the MDM correlations\n", + "Processing station: Heathfield_100 for the MDM correlations\n", + "Processing station: La Muela_80 for the MDM correlations\n", + "Processing station: Laegern-Hochwacht_32 for the MDM correlations\n", + "Processing station: Lindenberg_98 for the MDM correlations\n", + "Processing station: Lutjewad_60 for the MDM correlations\n", + "Processing station: Monte Cimone_8 for the MDM correlations\n", + "Processing station: Observatoire de Haute Provence_100 for the MDM correlations\n", + "Processing station: Observatoire perenne de l'environnement_120 for the MDM correlations\n", + "Processing station: Pic du Midi_28 for the MDM correlations\n", + "Processing station: Plateau Rosa_10 for the MDM correlations\n", + "Processing station: Puy de Dome_10 for the MDM correlations\n", + "Processing station: Ridge Hill_90 for the MDM correlations\n", + "Processing station: Saclay_100 for the MDM correlations\n", + "Processing station: Schauinsland_12 for the MDM correlations\n", + "Processing station: Tacolneston_185 for the MDM correlations\n", + "Processing station: Torfhaus_147 for the MDM correlations\n", + "Processing station: Trainou_180 for the MDM correlations\n", + "Processing station: Weybourne_10 for the MDM correlations\n", + "Processing station: Zugspitze_3 for the MDM correlations\n" + ] + } + ], + "source": [ + "mdm_dict = {}\n", + "station_times_dict = {}\n", + "\n", + "for selected_station in mdm_dictionary.keys():\n", + " print(f\"Processing station: {selected_station}\")\n", + "\n", + " # Reset start and end date for each station\n", + " startdate = dt.datetime(2018, 1, 1)\n", + " enddate = dt.datetime(2018, 12, 17)\n", + "\n", + " # Reset data storage for each station\n", + " ICON_values = []\n", + " ICOS_values = []\n", + " ICON_dates = []\n", + " ICOS_dates = []\n", + "\n", + " # Identify which time window to use\n", + " if selected_station in nighttime_stations:\n", + " time_start = 0 # 00:00\n", + " time_end = 7 # 07:00\n", + " else:\n", + " time_start = 12 # 12:00\n", + " time_end = 17 # 17:00\n", + "\n", + " while startdate < enddate:\n", + " try:\n", + " ICON = xr.open_dataset(f\"/capstor/scratch/cscs/ekoene/extracted_ICOS/runthrough_{startdate.strftime('%Y%m%d')}.nc\")\n", + " ICOS = xr.open_dataset(f\"/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_inputs/ICOS/Extracted_{startdate.strftime('%Y%m%d')}_{(startdate+dt.timedelta(days=11)).strftime('%Y%m%d')}_alldates_masl.nc\")\n", + "\n", + " full = (ICON.TRCO2_A + ICON.TRCO2_BG + ICON.CO2_RA - ICON.CO2_GPP + ICON.biosource - ICON.biosink) / (1 - ICON.qv) * 28.97 / 44.01 * 1e6\n", + " \n", + " stations = np.array([unidecode(x) for x in ICON.site_name.values])\n", + " mdm_keys = np.array([unidecode(k) for k in mdm_dictionary.keys()])\n", + "\n", + " # Ensure the station exists\n", + " if selected_station not in mdm_keys:\n", + " raise ValueError(f\"Station '{selected_station}' not found in mdm_dictionary\")\n", + "\n", + " # Get the station index\n", + " station_index = np.where(stations == selected_station)[0]\n", + " if len(station_index) == 0:\n", + " print(f\"Skipping {selected_station}: Not found in ICON dataset on {startdate}\")\n", + " startdate += dt.timedelta(days=10)\n", + " continue\n", + "\n", + " station_index = station_index[0]\n", + "\n", + " # Filter by time range\n", + " # Ensure time is in datetime64 format\n", + " ICON_times = ICON.time.values.astype('datetime64[h]')[24:] # Convert to hourly datetime\n", + "\n", + " # Extract the hours using numpy\n", + " time_hours = np.array([t.astype(object).hour for t in ICON_times]) \n", + " time_mask = (time_hours >= time_start) & (time_hours < time_end)\n", + "\n", + " full['time'] = pd.DatetimeIndex(full['time'].values)\n", + " ICOS[\"time\"] = pd.DatetimeIndex(ICOS.Dates[0].values)\n", + " full = full.isel(sites=station_index)[24:]\n", + " ICOS = ICOS.Concentration.isel(station=station_index)\n", + " if selected_station in nighttime_stations:\n", + " full = full.sel(time=full.time.dt.hour.isin([0, 1, 2, 3, 4, 5, 6, 7]))\n", + " ICOS = ICOS.sel(time=ICOS.time.dt.hour.isin([0, 1, 2, 3, 4, 5, 6, 7]))\n", + " else:\n", + " full = full.sel(time=full.time.dt.hour.isin([12, 13, 14, 15, 16]))\n", + " ICOS = ICOS.sel(time=ICOS.time.dt.hour.isin([12, 13, 14, 15, 16]))\n", + "\n", + "\n", + " ICON_values.append(full.resample(time='D').mean(\"time\"))\n", + " ICOS_values.append(ICOS.resample(time='D').mean(\"time\"))\n", + " ICON_dates.append(full.time.resample(time='D').mean(\"time\"))\n", + " ICOS_dates.append(ICOS.time.resample(time='D').mean(\"time\"))\n", + "\n", + " except FileNotFoundError as e:\n", + " print(f\"Skipping date {startdate} due to missing file: {e}\")\n", + "\n", + " except Exception as e:\n", + " print(f\"Error on {startdate}: {e}\")\n", + "\n", + " startdate += dt.timedelta(days=10)\n", + "\n", + " # Flatten arrays\n", + " ICON_values = np.asarray(ICON_values).flatten()\n", + " ICOS_values = np.asarray(ICOS_values).flatten()\n", + " ICON_dates = np.asarray(ICON_dates).flatten()\n", + " ICOS_dates = np.asarray(ICOS_dates).flatten()\n", + "\n", + " if len(ICON_values) == 0 or len(ICOS_values) == 0:\n", + " print(f\"No data available for station {selected_station}\")\n", + " continue\n", + "\n", + " # Align datasets by timestamps\n", + " common_dates, icon_idx, icos_idx = np.intersect1d(ICON_dates, ICOS_dates, return_indices=True)\n", + "\n", + " icon_common = ICON_values[icon_idx]\n", + " icos_common = ICOS_values[icos_idx]\n", + "\n", + " # Remove NaN values\n", + " valid_mask = ~np.isnan(icos_common)\n", + " icon_valid = icon_common[valid_mask]\n", + " icos_valid = icos_common[valid_mask]\n", + "\n", + " # Calculate RMSE\n", + " mdm_dict[selected_station] = icon_valid - icos_valid\n", + " station_times_dict[selected_station] = ICON_dates[icon_idx][valid_mask]\n", + "\n", + "def compute_correlation(x, y):\n", + " \"\"\"\n", + " Manually compute the Pearson correlation coefficient between two variables x and y.\n", + " \"\"\"\n", + " # Mean of x and y\n", + " mean_x = np.mean(x)\n", + " mean_y = np.mean(y)\n", + "\n", + " # Compute the numerator and the denominator of the Pearson correlation formula\n", + " numerator = np.sum((x - mean_x) * (y - mean_y))\n", + " denominator = np.sqrt(np.sum((x - mean_x) ** 2) * np.sum((y - mean_y) ** 2))\n", + "\n", + " # Return the correlation coefficient\n", + " return numerator / denominator\n", + "\n", + "# Create a dictionary to store correlation values for all pairs of stations\n", + "correlation_results = {}\n", + "\n", + "# Iterate over all pairs of stations\n", + "for station_1 in mdm_dictionary:\n", + " print(f\"Processing station: {station_1} for the MDM correlations\")\n", + " for station_2 in mdm_dictionary:\n", + " # Get the overlapping times for station_1 and station_2\n", + " common_times = set(station_times_dict[station_1]) & set(station_times_dict[station_2])\n", + " \n", + " if common_times: # If there is any overlap\n", + " # Get the MDM values for the common times\n", + " mdm_1 = [mdm_dict[station_1][np.where(station_times_dict[station_1] == time)[0][0]] for time in common_times]\n", + " mdm_2 = [mdm_dict[station_2][np.where(station_times_dict[station_2] == time)[0][0]] for time in common_times]\n", + " \n", + " # Compute the correlation between the MDM values for this pair of stations\n", + " correlation = compute_correlation(np.array(mdm_1), np.array(mdm_2))\n", + " correlation_results[(station_1, station_2)] = correlation\n", + " else:\n", + " correlation_results[(station_1, station_2)] = np.nan\n", + "\n", + "station_names = list(mdm_dictionary.keys())\n", + "correlation_matrix = np.zeros((len(station_names), len(station_names)))\n", + "\n", + "# Fill the correlation matrix with the computed values\n", + "for i, station_1 in enumerate(station_names):\n", + " for j, station_2 in enumerate(station_names):\n", + " if station_1 != station_2:\n", + " # Get the correlation for the pair (station_1, station_2)\n", + " correlation = correlation_results.get((station_1, station_2), None)\n", + " if correlation is not None:\n", + " correlation_matrix[i, j] = correlation\n", + " else:\n", + " # If there's no correlation (no overlap), fill with NaN\n", + " correlation_matrix[i, j] = np.nan\n", + " else:\n", + " # Set the diagonal to 1 (100% correlation with itself)\n", + " correlation_matrix[i, j] = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "\n", + "plt.figure(figsize=(12, 10))\n", + "sns.heatmap(correlation_matrix, xticklabels=list(mdm_dictionary.keys()), yticklabels=list(mdm_dictionary.keys()), cmap='coolwarm', annot=True, fmt=\".2f\", annot_kws={\"fontsize\":6}, vmin=-1, vmax=1)\n", + "plt.title(\"Model-Data Mismatch (MDM) Correlation Matrix\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/cases/icon-art-CTDAS/ICON/ICON_template.job b/cases/icon-art-CTDAS/ICON/ICON_template.job index f2043029..cd69ab29 100644 --- a/cases/icon-art-CTDAS/ICON/ICON_template.job +++ b/cases/icon-art-CTDAS/ICON/ICON_template.job @@ -13,11 +13,11 @@ export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK -dtime=120 # Ensure dtime is defined -dt_rad=$(( 4 * dtime )) -dt_conv=$(( 1 * dtime )) -dt_sso=$(( 2 * dtime )) -dt_gwd=$(( 2 * dtime )) +dtime=120 # Simulation time step in seconds +dt_rad=$(( 4 * dtime )) # Radiation time step in seconds +dt_conv=$(( 1 * dtime )) # Convection time step in seconds +dt_sso=$(( 2 * dtime )) # SSO time step in seconds +dt_gwd=$(( 2 * dtime )) # gravity wave drag time step in seconds # ---------------------------------------------------------------------------- # create ICON master namelist diff --git a/cases/icon-art-CTDAS/config.yaml b/cases/icon-art-CTDAS/config.yaml index ebb1f497..911e1a52 100644 --- a/cases/icon-art-CTDAS/config.yaml +++ b/cases/icon-art-CTDAS/config.yaml @@ -63,7 +63,7 @@ tracers: # - rc-cteco2 file [which, ultimately, is how we pass general input like folder names etc to CTDAS] # - rc-job file [which, ultimately, is the setup for CTDAS like lag times, etc.] CTDAS: - runthrough: True # If true, this runs through the year without any optimization. Useful for getting the BG and other fields + runthrough: True # If true, this makes the 'CTDAS' job run (1) CTDAS but also (2) a simulation for the full year without the ensemble members but with n_boundaries BG tracers nlag: 2 tracer: co2 regions: basegrid # choose: basegrid or parentgrid @@ -84,48 +84,46 @@ CTDAS: fetch: False path: /capstor/scratch/cscs/ekoene/ICOS/ c_offset: 2 # ppm - mdm: - - Beromunster_212: 6.2383423 + c_offset - - Bilsdale_248: 3.8534036 + c_offset - - Biscarrosse_47: 3.5997221 + c_offset - - Cabauw_207: 6.6093283 + c_offset - - Carnsore Point_14: 2.1894007 + c_offset - - Ersa_40: 2.3997285 + c_offset - - Gartow_341: 4.570544 + c_offset - - Heidelberg_30: 8.660628 + c_offset - - Hohenpeissenberg_131: 4.0553513 + c_offset - - Hyltemossa_150: 3.485432 + c_offset - - Ispra_100: 9.612817 + c_offset - - Jungfraujoch_13: 1.0802848 + c_offset - - Karlsruhe_200: 8.05013 + c_offset - - Kresin u Pacova_250: 3.829324 + c_offset - - Heathfield_100: 4.6675706 + c_offset # <--- CHECK - - La Muela_80: 3.2093291 + c_offset - - Laegern-Hochwacht_32: 9.556924 + c_offset - - Lindenberg_98: 5.4387555 + c_offset - - Lutjewad_60: 5.651525 + c_offset - - Monte Cimone_8: 1.7325112 + c_offset - - Observatoire de Haute Provence_100: 4.146905 + c_offset - - Observatoire perenne de l'environnement_120: 6.8854113 + c_offset - - Pic du Midi_28: 1.2196398 + c_offset - - Plateau Rosa_10: 1.3211231 + c_offset - - Puy de Dome_10: 3.4529948 + c_offset - - Ridge Hill_90: 5.0861707 + c_offset - - Saclay_100: 6.8669567 + c_offset - - Schauinsland_12: 3.7896755 + c_offset - - Tacolneston_185: 4.6675706 + c_offset - - Torfhaus_147: 4.622525 + c_offset - - Trainou_180: 5.821612 + c_offset - - Weybourne_10: 4.4674397 + c_offset - - Zugspitze_3: 1.6796716 + c_offset + mdm: # Based on the 'runthrough' simulation + - Beromunster_212: 5.246687084978375 + c_offset + - Bilsdale_248: 3.7267864090697658 + c_offset + - Biscarrosse_47: 4.44391367284266 + c_offset + - Cabauw_207: 4.556938758005444 + c_offset + - Carnsore Point_14: 3.9379375857221026 + c_offset + - Ersa_40: 5.097001363286457 + c_offset + - Gartow_341: 4.34505600864283 + c_offset + - Heidelberg_30: 7.653180633677891 + c_offset + - Hohenpeissenberg_131: 4.500672670985617 + c_offset + - Hyltemossa_150: 4.451277813256869 + c_offset + - Ispra_100: 7.200474834686076 + c_offset + - Jungfraujoch_13: 2.0936499868978484 + c_offset + - Karlsruhe_200: 6.269164507580145 + c_offset + - Kresin u Pacova_250: 4.779867829743723 + c_offset + - Heathfield_100: 5.16261949284921 + c_offset + - La Muela_80: 3.9377850799858414 + c_offset + - Laegern-Hochwacht_32: 7.6073774299042185 + c_offset + - Lindenberg_98: 4.975832792946022 + c_offset + - Lutjewad_60: 4.7013604883358715 + c_offset + - Monte Cimone_8: 3.010641066355188 + c_offset + - Observatoire de Haute Provence_100: 4.222056466810487 + c_offset + - Observatoire perenne de l'environnement_120: 5.5236885807122915 + c_offset + - Pic du Midi_28: 2.0843713258172123 + c_offset + - Plateau Rosa_10: 1.9979033074650259 + c_offset + - Puy de Dome_10: 4.330821043481535 + c_offset + - Ridge Hill_90: 4.100794768506457 + c_offset + - Saclay_100: 6.1904467326367945 + c_offset + - Schauinsland_12: 4.018460150933421 + c_offset + - Tacolneston_185: 4.8551091246134215 + c_offset + - Torfhaus_147: 4.4048914639305385 + c_offset + - Trainou_180: 5.605470151137809 + c_offset + - Weybourne_10: 5.239988261278576 + c_offset + - Zugspitze_3: 2.5079204353773696 + c_offset mountain_stations: - Jungfraujoch_13 - Monte Cimone_8 - Puy de Dome_10 - Pic du Midi_28 - Zugspitze_3 - - Hohenpeissenberg_50 - - Hohenpeissenberg_93 - Hohenpeissenberg_131 - Schauinsland_12 - Plateau Rosa_10 @@ -187,24 +185,25 @@ CTDAS: ctdas_patch: templates: - ctdas_patch/template.py - - ctdas_patch/template.rc # ADD THESE! - - ctdas_patch/template.jb # ADD THESE! + - ctdas_patch/template.rc + - ctdas_patch/template.jb da/cyclecontrol: ctdas_patch/initexit_cteco2.py da/statevectors: ctdas_patch/statevector_baseclass_icos_cities.py da/observations: ctdas_patch/obs_class_ICOS_OCO2.py da/obsoperators: ctdas_patch/obsoperator_ICOS_OCO2.py da/optimizers: ctdas_patch/optimizer_baseclass_icos_cities.py da/pipelines: ctdas_patch/pipeline_icon.py + da/platform: ctdas_patch/santis.py da/rc/cteco2: ctdas_patch/carbontracker_icon_oco2.rc da/tools/icon: - ctdas_patch/utilities.py - ctdas_patch/icon_helper.py - ctdas_patch/icon_sampler.py covariancematrix_definition: | - Corr = np.array([[1, 0], # VPRM has a 100% error - [0, 0.5]]) # Anthropogenic has a 50% error - specific_length_bio = 300 - specific_length_anth = 200 + Corr = np.array([[1, 0], # VPRM has a 100% error (remember, lambda VPRM=1 as set above) + [0, 0.5]]) # Anthropogenic has a 50% error (remember, lambda Anth=2 as set above) + specific_length_bio = 300 # km + specific_length_anth = 200 # km exp_factors_anth = np.exp(-distances / specific_length_anth) exp_factors_bio = np.exp(-distances / specific_length_bio) @@ -221,53 +220,7 @@ CTDAS: covariancematrix[-n_bg_params + iii , -n_bg_params + iii] = 0.015 * 0.015 # 0.015 * 400 = 6 ppm stdev covariancematrix[-n_bg_params + (iii + 1) % n_bg_params, -n_bg_params + iii] = 0.015 * 0.015 * 0.25 # Neighbouring entries covariancematrix[-n_bg_params + (iii - 1) % n_bg_params, -n_bg_params + iii] = 0.015 * 0.015 * 0.25 # Neighbouring entries - - - -# # CTDAS ------------------------------------------------------------------------ -# ctdas_restart = False -# ctdas_BG_run = False -# # CTDAS cycle length in days -# ctdas_cycle = int(restart_cycle_window / 60 / 60 / 24) -# ctdas_nlag = 2 -# ctdas_tracer = 'co2' -# # CTDAS number of regions and cells->regions file -# ctdas_nreg_params = 21184 -# ctdas_regionsfile = vprm_regions_synth_nc # <--- Create -# # Number of boundaries, and boundaries mask/regions file -# ctdas_bg_params = 8 -# # Number of ensemble members (make this consistent with your XML file!) -# ctdas_optimizer_nmembers = 180 -# # CTDAS path -# ctdas_dir = '/scratch/snx3000/ekoene/ctdas-icon/exec' -# # Distance file from region to region (shape: [N_reg x N_reg]), for statevector localization -# ctdas_sv_distances = '/scratch/snx3000/ekoene/CTDAS_cells2cells.nc' -# # Distance file from region to stations (shape: [N_reg x N_obs]), for observation localization -# ctdas_op_loc_coeffs = '/scratch/snx3000/ekoene/cells2stations.nc' -# # Directory containing a file with all the observations -# ctdas_datadir = '/scratch/snx3000/ekoene/ICOS_extracted/2018/' -# # CTDAS localization setting -# ctdas_system_localization = 'spatial' -# # CTDAS statevector length for one window -# ctdas_nparameters = 2 * ctdas_nreg_params + 8 # 2 (A , VPRM) * ctdas_nreg_params + ctdas_bg_params -# # Extraction template -# ctdas_extract_template = '/scratch/snx3000/ekoene/processing-chain/cases/VPRM_EU_ERA5_22/extract_template_icos_EU' -# # ICON runscript template -# ctdas_ICON_template = '/scratch/snx3000/ekoene/processing-chain/cases/VPRM_EU_ERA5_22/runscript_template_restart_icos_EU' -# # Full path to SBATCH template that can submit extraction scripts -# ctdas_sbatch_extract_template = '/scratch/snx3000/ekoene/processing-chain/cases/VPRM_EU_ERA5_22/sbatch_extract_template' -# # Full path to possibly time-varying emissionsgrid (if not time-varying, supply a filename without {}!) -# ctdas_oae_grid = "/scratch/snx3000/ekoene/inventories/INV_{}.nc" -# ctdas_oae_grid_fname = '%Y%m%d' # Specifies the naming scheme to use for the emission grids -# # Spinup time length -# # Restart file for the first simulation -# ctdas_first_restart_init = '/scratch/snx3000/ekoene/processing-chain/work/VPRM_EU_ERA5_22/2018010100_0_240/icon/output_INIT' -# # Number of vertical levels -# nvlev = 60 -# # NOT NEEDED FOR ANYTHING, EXCEPT TO MAKE CTDAS RUN -# ctdas_obsoperator_home = '/scratch/snx3000/msteiner/ctdas_test/exec/da/rc/stilt' -# ctdas_obsoperator_rc = os.path.join(ctdas_obsoperator_home, 'stilt_0.rc') -# ctdas_regtype = 'olson19_oif30' + job_time: 10:00:00 cdo_nco_cmd: | uenv start icon-wcp --ignore-tty << 'EOF' diff --git a/cases/icon-art-CTDAS/ctdas_patch/carbontracker_icon_oco2.rc b/cases/icon-art-CTDAS/ctdas_patch/carbontracker_icon_oco2.rc index 070eca69..87dc4050 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/carbontracker_icon_oco2.rc +++ b/cases/icon-art-CTDAS/ctdas_patch/carbontracker_icon_oco2.rc @@ -23,13 +23,11 @@ obs.input.dir : {cfg.case_root / "global_inputs" / "ICOS"} obspack.input.dir : {cfg.case_root / "global_inputs" / "ICOS"} ! OCO2 stuff -obs.column.input.dir : {cfg.case_root / "global_inputs" / "OCO2"} +obs.column.input.dir : {cfg.case_root / "global_inputs" / "OCO2"} obs.column.ncfile : OCO2__ctdas.nc -obs.column.selection.variables : quality_flag -obs.column.selection.criteria : == 0 -mdm.calculation : 0.015 -sigma_scale : 0.5 -output_prefix : ICON-ART-UNSTR -icon_grid_path : {cfg.input_files_scratch_dynamics_grid_filename} -tracer_optim : TRCO2_A +mdm.calculation : 0.015 +sigma_scale : 0.5 +output_prefix : ICON-ART-UNSTR +icon_grid_path : {cfg.input_files_scratch_dynamics_grid_filename} +tracer_optim : TRCO2_A obs.column.footprint_samples_dim : 1 \ No newline at end of file diff --git a/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py b/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py index 8a2f00d6..539d4334 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py +++ b/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py @@ -446,7 +446,7 @@ def ICOS_sampling(self, j, sample, statevector, lag): f"Running ICON sampler with starttime {{starttime}} and endtime {{endtime}} and obsdir {{obs_dir}} and nneighb {{nneighb}} and meta {{meta}} and outfile {{outfile}}" ) ICON_sampler(infolder, - "ICON-ART-UNSTR", + self.settings["output_prefix"], "{cfg.input_files_scratch_dynamics_grid_filename}", starttime, endtime, @@ -470,7 +470,7 @@ def ICOS_sampling(self, j, sample, statevector, lag): obs_times = np.array(f1.get_variable('time')) # wet --> dry mmr - for iiens in np.arange(TR_A_ENS.shape[0]): + for iiens in np.arange(self.forecast_nmembers): TR_A_ENS[iiens, ...] = TR_A_ENS[iiens, ...] / (1. - qv[...]) #LOOP OVER OBS: @@ -591,7 +591,7 @@ def _launch_icon_column_sampling(self, j, sample): "--run_dir %s" % run_dir, "--iconout_prefix %s" % self.settings["output_prefix"], "--icon_grid %s" % self.settings["icon_grid_path"], - "--nmembers %d" % int(self.dacycle["da.optimizer.nmembers"]), + "--nmembers %d" % int(self.forecast_nmembers), "--tracer_optim %s" % self.settings["tracer_optim"], "--outfile_prefix %s" % out_file, "--footprint_samples_dim %d" % diff --git a/cases/icon-art-CTDAS/ctdas_patch/santis.py b/cases/icon-art-CTDAS/ctdas_patch/santis.py new file mode 100644 index 00000000..ec68fd73 --- /dev/null +++ b/cases/icon-art-CTDAS/ctdas_patch/santis.py @@ -0,0 +1,150 @@ +"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. +Users are recommended to contact the developers (wouter.peters@wur.nl) to receive +updates of the code. See also: http://www.carbontracker.eu. + +This program is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free Software Foundation, +version 3. This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this +program. If not, see .""" +#!/usr/bin/env python +# cartesius.py + +""" +Author : peters + +Revision History: +File created on 06 Sep 2010. + +""" + +import logging +import subprocess + +from da.platform.platform_baseclass import Platform + +std_joboptions ={{'jobname':'test', + 'jobaccount':'{cfg.compute_account}', + 'jobtype':'serial', + 'jobshell':'/bin/sh', + 'jobtime':'10:00:00', + 'jobinput':'/dev/null', + 'jobnodes':'1', + 'jobconstraint':'{cfg.constraint}', + 'jobtasks':'', + 'modulenetcdf':'netcdf/4.1.2', + 'networkMPI':'', + 'jobqueue': '{cfg.compute_queue}', + 'ntaskspercore': '1', + 'ntaskspernode': '36', + 'cpuspertask': '1'}} + + +class SantisPlatform(Platform): + def __init__(self): + self.ID = 'Santis' # the identifier gives the platform name + self.version = '1.0' # the platform version used + + + def give_blocking_flag(self): + """ + Returns a blocking flag, which is important if tm5 is submitted in a queue system. The python ctdas code is forced to wait before tm5 run is finished + + -on Huygens: return "-s" + -on Maunaloa: return "" (no queue available) + -on Jet/Zeus: return + """ + return "" + + def give_queue_type(self): + """ + Return a queue type depending whether your computer system has a queue system, or whether you prefer to run in the foreground. + On most large systems using the queue is mandatory if you run a large job. + -on Huygens: return "queue" + -on Maunaloa: return "foreground" (no queue available) + -on Jet/Zeus: return + + """ + return "foreground" + + def get_job_template(self, joboptions={{}}, block=False): + """ + Returns the job template for a given computing system, and fill it with options from the dictionary provided as argument. + The job template should return the preamble of a job that can be submitted to a queue on your platform, + examples of popular queuing systems are: + - SGE + - MOAB + - XGrid + - + + A list of job options can be passed through a dictionary, which are then filled in on the proper line, + an example is for instance passing the dictionary {{'account':'co2'}} which will be placed + after the ``-A`` flag in a ``qsub`` environment. + + An extra option ``block`` has been added that allows the job template to be configured to block the current + job until the submitted job in this template has been completed fully. + """ + + template = """#!/bin/bash \n""" + \ + """## \n""" + \ + """## This is a set of dummy names, to be replaced by values from the dictionary \n""" + \ + """## Please make your own platform specific template with your own keys and place it in a subfolder of the da package.\n """ + \ + """## \n""" + \ + """#SBATCH --job-name=jobname \n""" + \ + """#SBATCH --partition=jobqueue \n""" + \ + """#SBATCH --nodes=jobnodes \n""" + \ + """#SBATCH --time=jobtime \n""" + \ + """#SBATCH --constraint=jobconstraint \n""" + \ + """#SBATCH --account=jobaccount \n""" + \ + """#SBATCH --ntasks-per-core=ntaskspercore \n""" + \ + """#SBATCH --ntasks-per-node=ntaskspernode \n""" + \ + """#SBATCH --cpus-per-task=cpuspertask \n""" + \ + """\n""" + + if 'depends' in joboptions: + template += """#$ -hold_jid depends \n""" + + # First replace from passed dictionary + for k, v in list(joboptions.items()): + while k in template: + template = template.replace(k, v) + + # Fill remaining values with std_options + for k, v in list(std_joboptions.items()): + while k in template: + template = template.replace(k, v) + + return template + + + def submit_job(self, jobfile, joblog=None, block=False): + """ This method submits a jobfile to the queue, and returns the queue ID """ + + + #cmd = ["llsubmit","-s",jobfile] + #msg = "A new task will be started (%s)"%cmd ; logging.info(msg) + + if block: + cmd = ["salloc",'-n',std_joboptions['jobnodes'],'-',std_joboptions['jobtime'], jobfile] + logging.info("A new task will be started (%s)" % cmd) + output = subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()[0] + logging.info(output) + print(('output', output)) + jobid = output.split()[-1] + print(('jobid', jobid)) + else: + cmd = ["sbatch", jobfile] + logging.info("A new job will be submitted (%s)" % cmd) + output = subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()[0] ; logging.info(output) + jobid = output.split()[-1] + + return jobid + + + + +if __name__ == "__main__": + pass diff --git a/cases/icon-art-CTDAS/ctdas_patch/template.py b/cases/icon-art-CTDAS/ctdas_patch/template.py index 8a8a7662..a745b58c 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/template.py +++ b/cases/icon-art-CTDAS/ctdas_patch/template.py @@ -29,7 +29,7 @@ from da.cyclecontrol.initexit_cteco2 import start_logger, validate_opts_args, parse_options, CycleControl from da.pipelines.pipeline_icon import ensemble_smoother_pipeline, header, footer, analysis_pipeline, archive_pipeline from da.dasystems.dasystem_baseclass import DaSystem -from da.platform.pizdaint import PizDaintPlatform +from da.platform.santis import SantisPlatform from da.statevectors.statevector_baseclass_icos_cities import StateVector from da.observations.obs_class_ICOS_OCO2 import ICOSObservations, TotalColumnObservations # Here we set which observations we consider! from da.obsoperators.obsoperator_ICOS_OCO2 import ObservationOperator # Here we set the obs-operator, which should sample the same observations! @@ -49,7 +49,7 @@ dacycle = CycleControl(opts, args) -platform = PizDaintPlatform() +platform = SantisPlatform() dasystem = DaSystem(dacycle['da.system.rc']) obsoperator = ObservationOperator(dacycle['da.system.rc']) samples = [ICOSObservations(), TotalColumnObservations()] diff --git a/cases/icon-art-CTDAS/ctdas_patch/template.rc b/cases/icon-art-CTDAS/ctdas_patch/template.rc index ba3da8c7..84facd43 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/template.rc +++ b/cases/icon-art-CTDAS/ctdas_patch/template.rc @@ -65,7 +65,7 @@ da.resources.ntasks : 1 ! any form appropriate for your system. Typically, HPC queueing systems allow you a certain number of hours of usage before ! your job is killed, and you are expected to finalize and submit a next job before that time. Valid entries are strings. -da.resources.ntime : 24:00:00 +da.resources.ntime : {cfg.CTDAS_job_time} ! The resource settings above will cause the creation of a job file in which 2 cycles will be run, and 30 threads ! are asked for a duration of 4 hours diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index 2f729999..63fc2558 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -492,7 +492,7 @@ def evaluate_dict(d, replace, using): meta_dict = { d.replace("XXX", "ENS"): { - "ensemble": cfg.CTDAS_nensembles + "ensemble": cfg.CTDAS_nensembles + (1 if cfg.CTDAS_propagate_bg else 0) } if "XXX" in d else {} for d in cfg.tracers if not d.startswith("EM") } diff --git a/jobs/tools/fetch_external_data.py b/jobs/tools/fetch_external_data.py index 3cef0058..09139e3a 100644 --- a/jobs/tools/fetch_external_data.py +++ b/jobs/tools/fetch_external_data.py @@ -789,20 +789,6 @@ def process_OCO2_data(OCO2_obs_folder, <= np.rad2deg(ICON_grid.clat.max().values) - offset), drop=True).where(s5p_data.xco2_quality_flag == 0, drop=True) # s5p_data = s5p_data.where((s5p_data.longitude > -8.6) & (s5p_data.longitude < 17.9) & (s5p_data.latitude > 40.6) & (s5p_data.latitude < 59), drop=True) - print("The new limits are....") - print( - f"{s5p_data.longitude.min().values} {s5p_data.longitude.max().values}" - ) - print( - f"{s5p_data.latitude.min().values} {s5p_data.latitude.max().values}" - ) - print("Filtered on") - print( - f"{np.rad2deg(ICON_grid.clon.min()).values} {np.rad2deg(ICON_grid.clon.max()).values}" - ) - print( - f"{np.rad2deg(ICON_grid.clat.min()).values} {np.rad2deg(ICON_grid.clat.max()).values}" - ) except: print( f"No observations remain after filtering {file} to ICON grid limits" From 76d501654d9ebf75ddc700313ace601e050e1858 Mon Sep 17 00:00:00 2001 From: github-actions Date: Fri, 7 Mar 2025 15:54:09 +0000 Subject: [PATCH 34/42] GitHub Action: Apply Pep8-formatting --- .../ctdas_patch/obs_class_ICOS_OCO2.py | 3 + cases/icon-art-CTDAS/ctdas_patch/santis.py | 61 ++++++++++--------- .../ctdas_patch/obs_class_ICOS_OCO2.py | 3 + jobs/prepare_CTDAS.py | 3 +- 4 files changed, 40 insertions(+), 30 deletions(-) diff --git a/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py b/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py index 9fe73d57..865949a8 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py +++ b/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py @@ -555,14 +555,17 @@ class TotalColumnSample(object): def __init__(self, idx, codex, xdate, obs=0.0, simulated=0.0, lat=-999., lon=-999., mdm=None, prior=0.0, prior_profile=0.0, av_kernel=0.0, pressure=0.0, \ ##### freum vvvv + pressure_weighting_function=None, ##### freum ^^^^ level_def = "pressure_boundary", psurf = float('nan'), resid=0.0, hphr=0.0, flag=0, species='co2', sdev=0.0, \ ##### freum vvvv + latc_0=None, latc_1=None, latc_2=None, latc_3=None, lonc_0=None, lonc_1=None, lonc_2=None, lonc_3=None \ ##### freum ^^^^ + ): self.id = idx # Sounding ID self.code = codex # Retrieval ID diff --git a/cases/icon-art-CTDAS/ctdas_patch/santis.py b/cases/icon-art-CTDAS/ctdas_patch/santis.py index ec68fd73..f0a6707f 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/santis.py +++ b/cases/icon-art-CTDAS/ctdas_patch/santis.py @@ -12,7 +12,6 @@ program. If not, see .""" #!/usr/bin/env python # cartesius.py - """ Author : peters @@ -26,28 +25,30 @@ from da.platform.platform_baseclass import Platform -std_joboptions ={{'jobname':'test', - 'jobaccount':'{cfg.compute_account}', - 'jobtype':'serial', - 'jobshell':'/bin/sh', - 'jobtime':'10:00:00', - 'jobinput':'/dev/null', - 'jobnodes':'1', - 'jobconstraint':'{cfg.constraint}', - 'jobtasks':'', - 'modulenetcdf':'netcdf/4.1.2', - 'networkMPI':'', - 'jobqueue': '{cfg.compute_queue}', - 'ntaskspercore': '1', - 'ntaskspernode': '36', - 'cpuspertask': '1'}} +std_joboptions = {{ + 'jobname': 'test', + 'jobaccount': '{cfg.compute_account}', + 'jobtype': 'serial', + 'jobshell': '/bin/sh', + 'jobtime': '10:00:00', + 'jobinput': '/dev/null', + 'jobnodes': '1', + 'jobconstraint': '{cfg.constraint}', + 'jobtasks': '', + 'modulenetcdf': 'netcdf/4.1.2', + 'networkMPI': '', + 'jobqueue': '{cfg.compute_queue}', + 'ntaskspercore': '1', + 'ntaskspernode': '36', + 'cpuspertask': '1' +}} class SantisPlatform(Platform): - def __init__(self): - self.ID = 'Santis' # the identifier gives the platform name - self.version = '1.0' # the platform version used + def __init__(self): + self.ID = 'Santis' # the identifier gives the platform name + self.version = '1.0' # the platform version used def give_blocking_flag(self): """ @@ -87,7 +88,7 @@ def get_job_template(self, joboptions={{}}, block=False): An extra option ``block`` has been added that allows the job template to be configured to block the current job until the submitted job in this template has been completed fully. """ - + template = """#!/bin/bash \n""" + \ """## \n""" + \ """## This is a set of dummy names, to be replaced by values from the dictionary \n""" + \ @@ -119,31 +120,33 @@ def get_job_template(self, joboptions={{}}, block=False): return template - def submit_job(self, jobfile, joblog=None, block=False): """ This method submits a jobfile to the queue, and returns the queue ID """ - #cmd = ["llsubmit","-s",jobfile] #msg = "A new task will be started (%s)"%cmd ; logging.info(msg) if block: - cmd = ["salloc",'-n',std_joboptions['jobnodes'],'-',std_joboptions['jobtime'], jobfile] + cmd = [ + "salloc", '-n', std_joboptions['jobnodes'], '-', + std_joboptions['jobtime'], jobfile + ] logging.info("A new task will be started (%s)" % cmd) - output = subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()[0] + output = subprocess.Popen(cmd, + stdout=subprocess.PIPE).communicate()[0] logging.info(output) print(('output', output)) - jobid = output.split()[-1] + jobid = output.split()[-1] print(('jobid', jobid)) else: cmd = ["sbatch", jobfile] logging.info("A new job will be submitted (%s)" % cmd) - output = subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()[0] ; logging.info(output) + output = subprocess.Popen(cmd, + stdout=subprocess.PIPE).communicate()[0] + logging.info(output) jobid = output.split()[-1] - - return jobid - + return jobid if __name__ == "__main__": diff --git a/cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py b/cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py index f8fdde91..9f390744 100644 --- a/cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py +++ b/cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py @@ -621,14 +621,17 @@ class TotalColumnSample(object): def __init__(self, idx, codex, xdate, obs=0.0, simulated=0.0, lat=-999., lon=-999., mdm=None, prior=0.0, prior_profile=0.0, av_kernel=0.0, pressure=0.0, \ ##### freum vvvv + pressure_weighting_function=None, ##### freum ^^^^ level_def = "pressure_boundary", psurf = float('nan'), resid=0.0, hphr=0.0, flag=0, species='co2', sdev=0.0, \ ##### freum vvvv + latc_0=None, latc_1=None, latc_2=None, latc_3=None, lonc_0=None, lonc_1=None, lonc_2=None, lonc_3=None \ ##### freum ^^^^ + ): self.id = idx # Sounding ID self.code = codex # Retrieval ID diff --git a/jobs/prepare_CTDAS.py b/jobs/prepare_CTDAS.py index 63fc2558..a860b5e4 100644 --- a/jobs/prepare_CTDAS.py +++ b/jobs/prepare_CTDAS.py @@ -492,7 +492,8 @@ def evaluate_dict(d, replace, using): meta_dict = { d.replace("XXX", "ENS"): { - "ensemble": cfg.CTDAS_nensembles + (1 if cfg.CTDAS_propagate_bg else 0) + "ensemble": + cfg.CTDAS_nensembles + (1 if cfg.CTDAS_propagate_bg else 0) } if "XXX" in d else {} for d in cfg.tracers if not d.startswith("EM") } From f884405b0644df8ed16444e0be6144c069092b27 Mon Sep 17 00:00:00 2001 From: efmkoene Date: Fri, 21 Mar 2025 10:57:52 +0100 Subject: [PATCH 35/42] Small updates to ICON-CTDAS example case --- .../ICON/Evaluate_performance.ipynb | 2300 +++++++++++++++++ cases/icon-art-CTDAS/ICON/ICON_template.job | 2 +- cases/icon-art-CTDAS/config.yaml | 17 +- .../ctdas_patch/obsoperator_ICOS_OCO2.py | 84 +- cases/icon-art-CTDAS/ctdas_patch/template.jb | 2 +- cases/icon-art-CTDAS/ctdas_patch/template.rc | 2 +- .../icon-art-CTDAS2/ICBC/icon_era5_inicond.sh | 179 -- .../icon-art-CTDAS2/ICBC/icon_era5_nudging.sh | 63 - .../ICBC/icon_era5_splitfiles.sh | 40 - .../ICBC/icon_species_inicond.sh | 58 - .../ICBC/icon_species_nudging.sh | 77 - cases/icon-art-CTDAS2/ICON/ICON_template.job | 386 --- cases/icon-art-CTDAS2/authentification.ipynb | 83 - cases/icon-art-CTDAS2/config.yaml | 253 -- .../ctdas_patch/carbontracker_icon_oco2.rc | 31 - .../ctdas_patch/icon_helper.py | 1425 ---------- .../ctdas_patch/icon_sampler.py | 284 -- .../ctdas_patch/obs_class_ICOS_OCO2.py | 1166 --------- .../ctdas_patch/obsoperator_ICOS_OCO2.py | 880 ------- .../optimizer_baseclass_icos_cities.py | 794 ------ .../statevector_baseclass_icos_cities.py | 746 ------ cases/icon-art-CTDAS2/ctdas_patch/template.jb | 16 - cases/icon-art-CTDAS2/ctdas_patch/template.py | 78 - cases/icon-art-CTDAS2/ctdas_patch/template.rc | 116 - .../icon-art-CTDAS2/ctdas_patch/utilities.py | 335 --- cases/icon-art-CTDAS2/map_file.ana | 109 - cases/icon-art-CTDAS2/mypartab | 117 - cases/icon-art-CTDAS2/wrapper_icon.sh | 1 - jobs/CTDAS.py | 6 +- 29 files changed, 2346 insertions(+), 7304 deletions(-) create mode 100644 cases/icon-art-CTDAS/ICON/Evaluate_performance.ipynb delete mode 100644 cases/icon-art-CTDAS2/ICBC/icon_era5_inicond.sh delete mode 100644 cases/icon-art-CTDAS2/ICBC/icon_era5_nudging.sh delete mode 100644 cases/icon-art-CTDAS2/ICBC/icon_era5_splitfiles.sh delete mode 100644 cases/icon-art-CTDAS2/ICBC/icon_species_inicond.sh delete mode 100644 cases/icon-art-CTDAS2/ICBC/icon_species_nudging.sh delete mode 100644 cases/icon-art-CTDAS2/ICON/ICON_template.job delete mode 100644 cases/icon-art-CTDAS2/authentification.ipynb delete mode 100644 cases/icon-art-CTDAS2/config.yaml delete mode 100644 cases/icon-art-CTDAS2/ctdas_patch/carbontracker_icon_oco2.rc delete mode 100644 cases/icon-art-CTDAS2/ctdas_patch/icon_helper.py delete mode 100755 cases/icon-art-CTDAS2/ctdas_patch/icon_sampler.py delete mode 100644 cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py delete mode 100644 cases/icon-art-CTDAS2/ctdas_patch/obsoperator_ICOS_OCO2.py delete mode 100644 cases/icon-art-CTDAS2/ctdas_patch/optimizer_baseclass_icos_cities.py delete mode 100644 cases/icon-art-CTDAS2/ctdas_patch/statevector_baseclass_icos_cities.py delete mode 100644 cases/icon-art-CTDAS2/ctdas_patch/template.jb delete mode 100644 cases/icon-art-CTDAS2/ctdas_patch/template.py delete mode 100644 cases/icon-art-CTDAS2/ctdas_patch/template.rc delete mode 100644 cases/icon-art-CTDAS2/ctdas_patch/utilities.py delete mode 100644 cases/icon-art-CTDAS2/map_file.ana delete mode 100644 cases/icon-art-CTDAS2/mypartab delete mode 120000 cases/icon-art-CTDAS2/wrapper_icon.sh diff --git a/cases/icon-art-CTDAS/ICON/Evaluate_performance.ipynb b/cases/icon-art-CTDAS/ICON/Evaluate_performance.ipynb new file mode 100644 index 00000000..27a2882e --- /dev/null +++ b/cases/icon-art-CTDAS/ICON/Evaluate_performance.ipynb @@ -0,0 +1,2300 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Beromunster_212\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Beromunster_212 (Time: 12:00-17:00): 4.870704337914896\n", + "RMSE_postBeromunster_212 (Time: 12:00-17:00): 3.802112177872216\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Bilsdale_248\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Bilsdale_248 (Time: 12:00-17:00): 4.099240961889037\n", + "RMSE_postBilsdale_248 (Time: 12:00-17:00): 3.416271654240215\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Biscarrosse_47\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Biscarrosse_47 (Time: 12:00-17:00): 3.6286698363772114\n", + "RMSE_postBiscarrosse_47 (Time: 12:00-17:00): 3.5862404264881227\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Cabauw_207\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Cabauw_207 (Time: 12:00-17:00): 4.441601923449455\n", + "RMSE_postCabauw_207 (Time: 12:00-17:00): 4.267883773898803\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Carnsore Point_14\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Carnsore Point_14 (Time: 12:00-17:00): 4.2323680010387\n", + "RMSE_postCarnsore Point_14 (Time: 12:00-17:00): 3.623636096028631\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Ersa_40\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-01 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-11 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Ersa_40 (Time: 12:00-17:00): 4.041720081809645\n", + "RMSE_postErsa_40 (Time: 12:00-17:00): 3.2890228372654446\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Gartow_341\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Gartow_341 (Time: 12:00-17:00): 4.020367181920504\n", + "RMSE_postGartow_341 (Time: 12:00-17:00): 4.075457908274276\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Heidelberg_30\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Heidelberg_30 (Time: 12:00-17:00): 5.68847108073695\n", + "RMSE_postHeidelberg_30 (Time: 12:00-17:00): 5.860014572829595\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Hohenpeissenberg_131\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Hohenpeissenberg_131 (Time: 0:00-7:00): 4.522767198933845\n", + "RMSE_postHohenpeissenberg_131 (Time: 0:00-7:00): 4.233448498276791\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Hyltemossa_150\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Hyltemossa_150 (Time: 12:00-17:00): 4.091151868767758\n", + "RMSE_postHyltemossa_150 (Time: 12:00-17:00): 5.39890959889631\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Ispra_100\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Ispra_100 (Time: 12:00-17:00): 7.264604784380843\n", + "RMSE_postIspra_100 (Time: 12:00-17:00): 5.641118133796353\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Jungfraujoch_13\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Jungfraujoch_13 (Time: 0:00-7:00): 2.09259671004597\n", + "RMSE_postJungfraujoch_13 (Time: 0:00-7:00): 2.04998985722839\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Karlsruhe_200\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Karlsruhe_200 (Time: 12:00-17:00): 5.704734083738697\n", + "RMSE_postKarlsruhe_200 (Time: 12:00-17:00): 5.9543535702792365\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Kresin u Pacova_250\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Kresin u Pacova_250 (Time: 12:00-17:00): 4.39203849153931\n", + "RMSE_postKresin u Pacova_250 (Time: 12:00-17:00): 6.340104473767879\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Heathfield_100\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Heathfield_100 (Time: 12:00-17:00): 4.787743529281923\n", + "RMSE_postHeathfield_100 (Time: 12:00-17:00): 4.033753825372047\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: La Muela_80\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-03-12 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-03-22 00:00:00\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for La Muela_80 (Time: 12:00-17:00): 3.057698787110178\n", + "RMSE_postLa Muela_80 (Time: 12:00-17:00): 2.737811049122988\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Laegern-Hochwacht_32\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-01 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-11 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-05-11 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-05-21 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-05-31 00:00:00\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Laegern-Hochwacht_32 (Time: 12:00-17:00): 6.947796727083331\n", + "RMSE_postLaegern-Hochwacht_32 (Time: 12:00-17:00): 3.9645163779151766\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGxCAYAAABIjE2TAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAkGtJREFUeJzs3Xd8jdcfwPHPzY7IkIhIxCYRYsbee4tRo6pGq1WjiqKqy2iVUtWhqBaxKm1/apfaao9YsTdBIgiJyM59fn88cuXm3kwhN3zfr1deL/d5zn2ec+9Ne78553u+R6MoioIQQgghhAkxy+sOCCGEEEKkJQGKEEIIIUyOBChCCCGEMDkSoAghhBDC5EiAIoQQQgiTIwGKEEIIIUyOBChCCCGEMDkSoAghhBDC5EiAIoQQQgiTIwGKyFRAQAAajYYjR47kdVdM2oABAyhYsGC65wsWLMiAAQOe2/01Gg3vv//+c7t+bpo4cSIajYZ79+5l2vbrr79m9erVObrPp59+SvXq1XF2dsbGxoYyZcowaNAgrl+/rtcuKCiIYcOGUblyZezt7XFzc6Nly5Zs3749W/ebPHkyFStWRKvV6o4tWbKE119/HW9vb8zMzChVqpTR527fvp23336bChUqYGdnR7FixejcuTNBQUHZ6kNgYCDVqlXDxsYGDw8PRo4cSXR0tEG76OhoRo4ciYeHBzY2NlSrVo3AwMAs3+f06dMMHTqUevXqYWdnh0ajYefOnQbtdu7ciUajSfdn8ODBWbrflStX6NatG05OThQsWJBWrVpx9OjRHL8HCxYsoFixYjx+/DjLr1m8WBKgCCFM2rMEKA8fPqR3794sXryYTZs2MWbMGNavX0+dOnW4f/++rt2KFSs4dOgQb7/9NmvWrOG3337D2tqaFi1asGTJkizd6/bt20yfPp3JkydjZvb0f61Lly7l9OnT1K5dm7Jly6b7/Llz53Lt2jVGjBjBP//8ww8//EB4eDh169bNcqC0fPlyevfuTa1atdi4cSMTJkwgICCAbt26GbTt1q0bixcvZsKECWzcuJFatWrRu3dvfv/99yzd68iRI6xevRpnZ2datGiRbrsaNWqwf/9+g59+/foB0LVr10zvdffuXRo1asSFCxdYuHAhf/75J3FxcTRt2pTz58/n6D3o378/dnZ2TJ8+PUuvV+QBRYhMLFq0SAGUw4cP53VXcp1Wq1ViYmJy5Vr9+/dX7Ozs0j1vZ2en9O/fP1fuZQygDBs27LldPzdNmDBBAZS7d+9m2ja337d//vlHAZQFCxbojt25c8egXVJSklKlShWlbNmyWbruRx99pBQrVkxJTk7WO576cYcOHZSSJUsafb6xPjx69Ehxc3NTWrRoken9k5KSFHd3d6V169Z6x5cvX64Ayj///KM7tmHDBgVQfv/9d722rVq1Ujw8PJSkpKRM75f6df31118KoOzYsSPT5ymK+t9dmTJllJIlSxq8X8aMHTtWsbS0VK5du6Y7FhkZqRQuXFjp2bOn7lh23gNFUZRvv/1WcXR0VB4/fpylfosXS0ZQRK6Ii4tj9OjRVKtWDUdHR5ydnalXrx5r1qwxaKsoCnPmzKFatWrY2tpSqFAhunfvzpUrVwzaff3115QsWRIbGxtq1qzJli1baNq0KU2bNtVrGxUVxZgxYyhdujRWVlYUK1aMkSNHGgzfpkyDzJs3Dx8fH6ytrVm8eLFuGmvHjh0MGTKEwoUL4+LiQrdu3bh9+3auv18pbty4wZtvvkmRIkWwtrbGx8eHmTNn6k0RAMTHxzN58mR8fHywsbHBxcWFZs2asW/fPoNrLl26FB8fHwoUKEDVqlVZv3697tzp06fRaDT89ddfumNBQUFoNBoqVaqkdx1/f3/8/Px0j//44w9at26Nu7s7tra2+Pj48PHHHxsdIj948CCdOnXCxcUFGxsbypYty8iRIw3a3blzh969e+Po6Iibmxtvv/02kZGRuvMajYbHjx+zePFi3ZRA2s8+u1xdXQGwsLDQHStSpIhBO3Nzc/z8/AgJCcn0mgkJCSxYsIA33nhDb/QEMHicHmN9KFiwIBUrVsxSHw4cOEBoaChvvfWW3vEePXpQsGBBVq1apTu2atUqChYsSI8ePfTavvXWW9y+fZuDBw9mer+svi5jduzYwZUrV3jrrbeydJ1Vq1bRvHlzSpYsqTvm4OBAt27dWLduHUlJSUD23gOAPn36EBUVla2pLfHiSIAickV8fDwRERGMGTOG1atXs2LFCho2bEi3bt0Mhsjfe+89Ro4cScuWLVm9ejVz5szh9OnT1K9fnzt37ujaffrpp3z66ae0bduWNWvWMHjwYN555x0uXLigd72YmBiaNGnC4sWL+eCDD9i4cSPjxo0jICAAf39/lDQbdq9evZq5c+fyxRdf8O+//9KoUSPduXfeeQdLS0t+//13pk+fzs6dO3nzzTez9V4kJSUZ/Unr7t271K9fn82bN/Pll1+ydu1aWrZsyZgxY/RySZKSkmjXrh1ffvklHTt2ZNWqVQQEBFC/fn1u3Lihd80NGzYwe/ZsJk+ezMqVK3F2dqZr16664K9SpUq4u7uzdetW3XO2bt2Kra0tZ86c0QVjSUlJ7Nq1i5YtW+raXbx4kfbt27NgwQI2bdrEyJEj+fPPP+nUqZNeH1Le0xs3bvDdd9+xceNGPvvsM73PNsVrr72Gl5cXK1eu5OOPP+b3339n1KhRuvP79+/H1taW9u3b66YG5syZk52PQ/d6YmNjOXbsGCNHjsTLy8votEfa5+zevdsgcDPm4MGD3L9/n2bNmmW7bxmJjIzk6NGjBn1ICagDAgJ0x06dOgVAlSpV9NpaWlpSoUIF3fmUtj4+PnpBWurnpm77PCxYsAAzMzODQAIwCEJjY2O5fPmywesCtb+xsbG63+/svAcARYsWpUKFCmzYsOFZX5J4HvJ4BEfkAzmZ4klKSlISExOVgQMHKtWrV9cd379/vwIoM2fO1GsfEhKi2NraKh999JGiKIoSERGhWFtbK7169dJrl/L8Jk2a6I5NnTpVMTMzM+jf//73P4NhXUBxdHRUIiIijL7GoUOH6h2fPn26AiihoaGZvub+/fsrQIY/qacqPv74YwVQDh48qHedIUOGKBqNRjl//ryiKIqyZMkSBVB+/fXXDO8PKG5ubkpUVJTuWFhYmGJmZqZMnTpVd+zNN99UypQpo3vcsmVL5d1331UKFSqkLF68WFEURdm7d68CKJs3bzZ6L61WqyQmJiq7du1SAOXEiRO6c2XLllXKli2rxMbGptvXlCme6dOn6x0fOnSoYmNjo2i1Wt2xZ53iCQ0N1fsM6tSpo9y6dSvT53366acKoKxevTrTtt98840CKGFhYRm2y2iKx5g+ffooFhYWypEjR/SOL168WDE3N9d9XoqiKFOmTEn3d7V169aKl5eX7nH58uWVNm3aGLS7ffu2Aihff/11lvuoKNmb4nnw4IFiY2Nj9P6Koijm5uZK8+bNdY9v3bqlAHq/wyl+//13BVD27dunKEr23oMUffr0Udzc3DLtt3jxZARF5Jq//vqLBg0aULBgQSwsLLC0tGTBggWcPXtW12b9+vVoNBrefPNNvdGFokWLUrVqVd0qgAMHDhAfH0/Pnj317lG3bl2DVRDr16/H19eXatWq6V2zTZs2RlcWNG/enEKFChl9Df7+/nqPU/4SS1n1odVq9e6RnJys197W1pbDhw8b/bG1tdVru337dipWrEjt2rX1jg8YMABFUXSJkRs3bsTGxoa3337baJ9Ta9asGfb29rrHbm5uFClSRG/VSosWLbhy5QpXr14lLi6OPXv20LZtW5o1a8aWLVsAdVTF2tqahg0b6p535coV3njjDYoWLYq5uTmWlpY0adIEQPcZX7hwgcuXLzNw4EBsbGwy7a+x9zsuLo7w8PBMn5tVhQsX5vDhw+zZs4dff/2ViIgImjVrRmhoaLrP+e2335gyZQqjR4+mc+fOmd7j9u3baDQaChcunGv9/vzzz1m+fDmzZs3Sm2oD6NevH0lJSbpE09Q0Go3R66U9nl671Ocy+33PieXLlxMXF8c777xj9HxSUhLbtm1Lt08Z9TeztsaOFylShPDwcKOjnCJvWWTeRIjM/f333/Ts2ZMePXowduxYihYtioWFBXPnzmXhwoW6dnfu3EFRFNzc3Ixep0yZMgC6FRbG2qU9dufOHS5duoSlpaXRa6Zdyuru7p7u63BxcdF7bG1tDajDzKAuI500aZLufMmSJbl27ZrusZmZGTVr1jR67bRz7ffv3ze65NTDw0N3HtSpIA8PjyzN1aftf8prSOk/oJu22bp1K6VLlyYxMZHmzZtz584dvvzyS925Bg0a6IKq6OhoGjVqhI2NDV999RVeXl4UKFCAkJAQunXrprv+3bt3AfD09My0r8b6m/b9zg0WFha6z6RBgwa0bduW0qVLM23aNH744QeD9osWLeK9995j0KBBzJgxI0v3iI2NxdLSEnNz81zp86RJk/jqq6+YMmVKlpeOp7yX9+/fN/hvJCIiAmdnZ722qVcxpW4H6Npm9vueEwsWLMDV1TVLgR9AoUKF0Gg0Wepvdt6DFDY2NiiKQlxcXIZlAsSLJwGKyBXLli2jdOnS/PHHH3p/pcTHx+u1K1y4MBqNht27d+u+jFJLOZbyPxpjeQthYWF6X+yFCxfG1tZWLxBKe8/UMvpLLDODBg2iY8eOBv3NCRcXF6N/xafkgaT029XVlT179qDVap8pMTGFp6cnXl5ebN26lVKlSlGzZk2cnJxo0aIFQ4cO5eDBgxw4cEDvi2n79u3cvn2bnTt36kZNQF3Gm1pKAurNmzefuZ/Pi6enJx4eHga5TKAGJ++88w79+/dn3rx5Wf5dKVy4MAkJCTx+/Bg7O7tn6t+kSZOYOHEiEydO5JNPPsny8ypXrgxAcHAwFStW1B1PSkri3Llz9O7dW6/tihUrSEpK0stDCQ4OBsDX1xfI3d93gGPHjnHs2DFGjx6d7h8Uadna2lKuXDld31ILDg7G1tZW94dNdt6DFBEREVhbW0twYoJkikfkCo1Gg5WVld7/0MPCwgxW8XTs2BFFUbh16xY1a9Y0+En5H0ydOnWwtrbmjz/+0Hv+gQMHDIpsdezYkcuXL+Pi4mL0mukVxsoJDw8Po/3NiRYtWnDmzBmDYlNLlixBo9HoEi7btWtHXFycXkLks0opQrZlyxZatWoFgJeXFyVKlOCLL74gMTFRL0E25XNN+wX1yy+/6D328vKibNmyLFy40CA4zam0I0DP6tKlS9y8eZNy5crpHQ8ICOCdd97hzTff5LfffstWIFuhQgUALl++/Ex9+/LLL5k4cSKfffYZEyZMyNZz69Spg7u7u8Hvyf/+9z+io6P1koK7du1KdHQ0K1eu1Gu7ePFiPDw8qFOnDpC7v++gjp4ADBw4MFvP69q1K9u3b9dbzfTo0SP+/vtv/P39dUFWdt6DFFeuXNELZoTpkBEUkWXbt283Orzbvn17OnbsyN9//83QoUPp3r07ISEhfPnll7i7u3Px4kVd2wYNGjBo0CDeeustjhw5QuPGjbGzsyM0NJQ9e/ZQuXJlhgwZgrOzMx9++CFTp06lUKFCdO3alZs3bzJp0iTc3d31RhJGjhzJypUrady4MaNGjaJKlSpotVpu3LjB5s2bGT16tO5/uKZk1KhRLFmyhA4dOjB58mRKlizJhg0bmDNnDkOGDMHLywuA3r17s2jRIgYPHsz58+dp1qwZWq2WgwcP4uPjw+uvv57te7do0YI5c+Zw7949vv/+e73jixYtolChQnp5D/Xr16dQoUIMHjyYCRMmYGlpyfLlyzlx4oTBtX/++Wc6depE3bp1GTVqFCVKlODGjRv8+++/LF++PNt9rVy5Mjt37mTdunW4u7tjb2+Pt7d3ps87efIko0aNonv37pQpUwYzMzOCg4OZNWsWLi4ujBkzRtf2r7/+YuDAgVSrVo333nuPQ4cO6V2revXqGY4epKw6OXDggMEKkjNnznDmzBlADdpjYmL43//+B0DFihV1X44zZ87kiy++oG3btnTo0IEDBw7oXadu3bq6fy9ZsoS3336bhQsX6vJQzM3NmT59On379uW9996jd+/eXLx4kY8++ohWrVrRtm1b3fPbtWtHq1atGDJkCFFRUZQrV44VK1awadMmli1blqWpqpiYGP755x/d6wbYtWsX9+7dw87Ojnbt2um1j4uL4/fff6d+/fr4+Pike10LCwuaNGmil4cyZswYli5dqvtvxdrammnTphEXF8fEiRN17bLzHoCaY3Po0KFsB0ziBcnbHF2RH6SscEnv5+rVq4qiKMq0adOUUqVKKdbW1oqPj4/y66+/6lZrpLVw4UKlTp06ip2dnWJra6uULVtW6devn95qBa1Wq3z11VeKp6enYmVlpVSpUkVZv369UrVqVaVr165614uOjlY+++wzxdvbW7GyslIcHR2VypUrK6NGjdJbWUE6xczSW6m0Y8eOLK9OyEmhtuvXrytvvPGG4uLiolhaWire3t7KjBkzDIpXxcbGKl988YVSvnx5xcrKSnFxcVGaN2+uW72Q0WsrWbKkwX0fPHigmJmZKXZ2dkpCQoLueEpBq27duhlcZ9++fUq9evWUAgUKKK6urso777yjHD16VAGURYsW6bXdv3+/0q5dO8XR0VGxtrZWypYtq4waNUp3Pr1CbSmfQ8rvlKIoyvHjx5UGDRooBQoUMFjBlZGwsDDlzTffVMqWLasUKFBAsbKyUsqUKaMMHjxYuXHjhl7bzFZgpe5Peho1aqS0b9/e4HjKazX2M2HCBF27Jk2aZNgHY+9T2vddUdSVLVWqVFGsrKyUokWLKh988IHy6NEjg3aPHj1SPvjgA6Vo0aK6/75WrFiR6etMcfXq1XT7amylUsrv1sKFCzO8bnqf8aVLl5QuXbooDg4OSoECBZQWLVooQUFBRq+R1fdg27ZtCpDudUTe0ihKmiIRQpiwq1evUqFCBSZMmJCt+XkhnreVK1fSq1cvrl+/TrFixfK6OyIL+vbty5UrV9i7d29ed0UYIQGKMFknTpxgxYoV1K9fHwcHB86fP8/06dOJiori1KlT6a4EEiIvKIpC/fr18fPzY/bs2XndHZGJy5cv4+Pjw/bt2/WW0wvTITkowmTZ2dlx5MgRFixYwMOHD3F0dKRp06ZMmTJFgpNXXGY1K8zMzHJlxVN2aDQafv31V9auXZtrK67E83Pjxg1mz54twYkJkxEUIUS+k9kKm/79++fqqichxIsnIyhCiHzn8OHDGZ7PzYquQoi8ISMoQgghhDA5MkkqhBBCCJOTL6d4tFott2/fxt7e/pnKlgshhBDixVEUhUePHmVpf7F8GaDcvn2b4sWL53U3hBBCCJEDISEhmW4qmi8DlJTt5ENCQnBwcMjj3gghhBAiK6KioihevLjuezwj+TJASZnWcXBwkABFCCGEyGeykp4hSbJCCCGEMDkSoAghhBDC5EiAIoQQQgiTky9zUIQQQqRPURSSkpJITk7O666IV5ClpSXm5ubPfB0JUIQQ4iWSkJBAaGgoMTExed0V8YrSaDR4enpSsGDBZ7qOBChCCPGS0Gq1XL16FXNzczw8PLCyspJiluKFUhSFu3fvcvPmTcqXL/9MIykSoAghxEsiISEBrVZL8eLFKVCgQF53R7yiXF1duXbtGomJic8UoEiSrBBCvGQyKyEuxPOUW6N28lsshBBCCJMjAYoQQgghTI4EKEIIIUQm+vbty9dff/3M19m5cycajYaHDx8+03XCw8NxdXXl1q1bz9wnUyUBihBCiDw1YMAAunTponcsLCyM4cOHU6ZMGaytrSlevDidOnVi27Zteu327dtH+/btKVSoEDY2NlSuXJmZM2ca1IDRaDTY2Nhw/fp1veNdunRhwIABGfbv5MmTbNiwgeHDh+f4NaaoX78+oaGhODo6PtN1ihQpQt++fZkwYcIz98lUSYAihBDCpFy7dg0/Pz+2b9/O9OnTCQ4OZtOmTTRr1oxhw4bp2q1atYomTZrg6enJjh07OHfuHCNGjGDKlCm8/vrrKIqid12NRsMXX3yR7f7Mnj2bHj16ZGkH3owkJiZiZWVF0aJFnymRNCEhAYC33nqL5cuX8+DBg2fql6mSAEUIIYRJGTp0KBqNhkOHDtG9e3e8vLyoVKkSH374IQcOHADg8ePHvPvuu/j7+zN//nyqVatGqVKleOedd1i8eDH/+9//+PPPP/WuO3z4cJYtW0ZwcHCW+6LVavnrr7/w9/fXO16qVCm+/PJL3njjDQoWLIiHhwc//fSTXhuNRsO8efPo3LkzdnZ2fPXVV0aneFauXEmlSpWwtramVKlSzJw50+BeX331FQMGDMDR0ZF3330XgMqVK1O0aFFWrVqV5deTn0iAIoQQwmRERESwadMmhg0bhp2dncF5JycnADZv3sz9+/cZM2aMQZtOnTrh5eXFihUr9I7Xr1+fjh07Mn78+Cz35+TJkzx8+JCaNWsanJsxYwZVqlTh6NGjjB8/nlGjRrFlyxa9NhMmTKBz584EBwfz9ttvG1wjKCiInj178vrrrxMcHMzEiRP5/PPPCQgIMLiXr68vQUFBfP7557rjtWvXZvfu3Vl+PfmJFGoTQoiX3ZAh8CKTKYsVg7lzc/TUS5cuoSgKFSpUyLDdhQsXAPDx8TF6vkKFCro2qU2dOpUqVaqwe/duGjVqlGl/rl27hrm5OUWKFDE416BBAz7++GMAvLy82Lt3L7NmzaJVq1a6Nm+88YZeYHL16lW9a3z33Xe0aNFCF3R4eXlx5swZZsyYoZcb07x5c6PBWLFixTh27FimryM/kgBFCCFedjkMFvJCSt5IVnM00uaZpD5u7BoVK1akX79+jBs3jn379mV6/djYWKytrY1eq169egaPv//+e71jxkZeUjt79iydO3fWO9agQQO+//57kpOTdZVY07uOra3tS7vvkkzxCCGEMBnly5dHo9Fw9uzZDNt5eXkBpNvu3LlzlC9f3ui5SZMmcezYMVavXp1pfwoXLkxMTIwuMTUzaQMZY9NUqRkLpIwFXeldJyIiAldX1yz1Lb+RAEUIIYTJcHZ2pk2bNvz88888fvzY4HxKcmnr1q1xdnY2SCgFWLt2LRcvXqR3795G71G8eHHef/99PvnkE4PlyGlVq1YNgDNnzhicS0nYTf04s6mptCpWrMiePXv0ju3btw8vL68s7WNz6tQpqlevnq175hfPFKBMnToVjUbDyJEjdceio6N5//338fT0xNbWFh8fH+amGV6Mj49n+PDhFC5cGDs7O/z9/bl58+azdEUIIcRLYs6cOSQnJ1O7dm1WrlzJxYsXOXv2LD/++KNuWsXOzo5ffvmFNWvWMGjQIE6ePMm1a9dYsGABAwYMoHv37vTs2TPde4wfP57bt2+zdevWDPvi6upKjRo1DIIIgL179zJ9+nQuXLjAzz//zF9//cWIESOy9VpHjx7Ntm3b+PLLL7lw4QKLFy9m9uzZRvNN0oqJiSEoKIjWrVtn6575RY4DlMOHDzN//nyqVKmid3zUqFFs2rSJZcuWcfbsWUaNGsXw4cNZs2aNrs3IkSNZtWoVgYGB7Nmzh+joaDp27JhpJCuEEOLlV7p0aY4ePUqzZs0YPXo0vr6+tGrVim3btun9wdu9e3d27NhBSEgIjRs3xtvbm++++45PP/2UwMDADPNYnJ2dGTduHHFxcZn2Z9CgQSxfvtzg+OjRowkKCqJ69ep8+eWXzJw5kzZt2mTrtdaoUYM///yTwMBAfH19+eKLL5g8eXKmxeMA1qxZQ4kSJbKU7JsvKTnw6NEjpXz58sqWLVuUJk2aKCNGjNCdq1SpkjJ58mS99jVq1FA+++wzRVEU5eHDh4qlpaUSGBioO3/r1i3FzMxM2bRpU5buHxkZqQBKZGRkTrovhBAvpdjYWOXMmTNKbGxsXnflpRIbG6uUKFFC2bdvn+5YyZIllVmzZuVdpxRFqVWrlrJ8+fI87YMxGf0eZuf7O0cjKMOGDaNDhw60bNnS4FzDhg1Zu3Ytt27dQlEUduzYwYULF3RRZVBQEImJiXpDUh4eHvj6+qabUR0fH09UVJTejxBCCPEi2NjYsGTJEu7du5fXXdEJDw+ne/fu6ebZvAyyvcw4MDCQo0ePcvjwYaPnf/zxR9599108PT2xsLDAzMyM3377jYYNGwLq/gpWVlYUKlRI73lubm6EhYUZvebUqVOZNGlSdrsqhBBC5IomTZrkdRf0FClShI8++iivu/FcZStACQkJYcSIEWzevBkbGxujbX788UcOHDjA2rVrKVmyJP/99x9Dhw7F3d3d6IhLCiWdNeugJjN9+OGHusdRUVEUL148O10XQgghcs21a9fyugsvvWwFKEFBQYSHh+Pn56c7lpyczH///cfs2bOJjIzkk08+YdWqVXTo0AGAKlWqcPz4cb799ltatmxJ0aJFSUhI4MGDB3qjKOHh4dSvX9/ofa2trbG2ts7J6xNCCCFEPpStHJQWLVoQHBzM8ePHdT81a9akT58+HD9+nOTkZBITEzEz07+subk5Wq0WAD8/PywtLfX2KwgNDeXUqVPpBihCCCGEeLVkawTF3t4eX19fvWN2dna4uLjojjdp0oSxY8dia2tLyZIl2bVrF0uWLOG7774DwNHRkYEDBzJ69GhcXFxwdnZmzJgxVK5cOcMpICGEEEK8OnJ9L57AwEDGjx9Pnz59iIiIoGTJkkyZMoXBgwfr2syaNQsLCwt69uxJbGwsLVq0ICAgIEtV84QQQgjx8tMoSjo7LZmwqKgoHB0diYyMxMHBIa+7I4QQJiEuLo6rV69SunTpdBcyCPG8ZfR7mJ3vb9mLRwghhBAmRwIUIYQQIhN9+/bl66+/zutu5NiAAQPo0qXLM19n9uzZ+Pv7P3uHskACFCGEEHnK2JdnWFgYw4cPp0yZMlhbW1O8eHE6derEtm3b9Nrt27eP9u3bU6hQIWxsbKhcuTIzZ8402NtNo9FgY2PD9evX9Y536dIl031vTp48yYYNGxg+fHiOX2N2BQQE4OTklGvX++GHHwgICHjm67z77rscPnzY6OaJuU0CFCGEECbl2rVr+Pn5sX37dqZPn05wcDCbNm2iWbNmDBs2TNdu1apVNGnSBE9PT3bs2MG5c+cYMWIEU6ZM4fXXXydtiqVGo+GLL77Idn9mz55Njx49sLe3f+bX9qIlJyej1WpxdHR8poBHURSSkpKwtrbmjTfe4Keffsq9TmZw03xHNgsUQghD+XWzwP79+yudO3fWPW7Xrp1SrFgxJTo62qDtgwcPFEVRlOjoaMXFxUXp1q2bQZu1a9cqgN6mtIAyduxYxczMTDl58qTueOfOnZX+/fun27fk5GTFyclJWb9+vd7xkiVLKpMnT1Z69+6t2NnZKe7u7sqPP/6o1+b69euKv7+/Ymdnp9jb2ys9evRQwsLCdOePHz+uNG3aVClYsKBib2+v1KhRQzl8+LCyY8cOBdD7mTBhgqIoihIfH6+MHTtW8fDwUAoUKKDUrl1b2bFjh+6aixYtUhwdHZV169YpPj4+irm5uXLlyhWD9zguLk4ZPny44urqqlhbWysNGjRQDh06pDuf0odNmzYpfn5+iqWlpbJ9+3ZFURRl586dipWVlRITE2P0PcvTzQKFEEKI5yEiIoJNmzYxbNgw7OzsDM6njAJs3ryZ+/fvM2bMGIM2nTp1wsvLixUrVugdr1+/Ph07dmT8+PFZ7s/Jkyd5+PAhNWvWNDg3Y8YMqlSpwtGjRxk/fjyjRo3SFSFVFIUuXboQERHBrl272LJlC5cvX6ZXr1665/fp0wdPT08OHz5MUFAQH3/8MZaWltSvX5/vv/8eBwcHQkNDCQ0N1b3Ot956i7179xIYGMjJkyfp0aMHbdu25eLFi7rrxsTEMHXqVH777TdOnz5NkSJFDPr+0UcfsXLlShYvXszRo0cpV64cbdq0ISIiwqDd1KlTOXv2LFWqVAGgZs2aJCYmcujQoSy/jzmR63VQhBBCmJYhQ+DWrRd3v2LFYO7cnD330qVLKIpChQoVMmx34cIFAHx8fIyer1Chgq5NalOnTqVKlSrs3r2bRo0aZdqfa9euYW5ubvRLvkGDBnz88ccAeHl5sXfvXmbNmkWrVq3YunUrJ0+e5OrVq7q945YuXUqlSpU4fPgwtWrV4saNG4wdO1b3WsuXL6+7tqOjIxqNhqJFi+qOXb58mRUrVnDz5k08PDwAGDNmDJs2bWLRokW6JN7ExETmzJlD1apVjb6mx48fM3fuXAICAmjXrh0Av/76K1u2bGHBggWMHTtW13by5Mm0atVK7/l2dnY4OTlx7dq157qJogQoQgjxkstpsJAXlCd5I+ltHptee2PHjV2jYsWK9OvXj3HjxrFv375Mrx8bG4u1tbXRa9WrV8/g8ffffw/A2bNnKV68uN7GthUrVsTJyYmzZ89Sq1YtPvzwQ9555x2WLl1Ky5Yt6dGjB2XLlk23L0ePHkVRFLy8vPSOx8fH4+LiontsZWWlG+0w5vLlyyQmJtKgQQPdMUtLS2rXrs3Zs2f12hobOQKwtbUlJiYm3XvkBpniEUIIYTLKly+PRqMx+KJMK+VLOr12586d0xuRSG3SpEkcO3aM1atXZ9qfwoULExMTQ0JCQqZt4WlglV6AlPr4xIkTOX36NB06dGD79u1UrFiRVatWpXttrVaLubk5QUFBenvinT17lh9++EHXztbWNsMAL70g0FifjU2zgToV5+rqmu49coMEKEIIIUyGs7Mzbdq04eeff+bx48cG5x8+fAhA69atcXZ2ZubMmQZt1q5dy8WLF+ndu7fRexQvXpz333+fTz75xGA5clrVqlUD4MyZMwbnDhw4YPA4ZbqmYsWK3Lhxg5CQEN35M2fOEBkZqTct5eXlxahRo9i8eTPdunVj0aJFgDoKkrZv1atXJzk5mfDwcMqVK6f3k3oqKDPlypXDyspKb6lwYmIiR44cSXfKLLXLly8TFxdH9erVs3zPnJAARQghhEmZM2cOycnJ1K5dm5UrV3Lx4kXOnj3Ljz/+qJtWsbOz45dffmHNmjUMGjSIkydPcu3aNRYsWMCAAQPo3r07PXv2TPce48eP5/bt22zdujXDvri6ulKjRg2jdT/27t3L9OnTuXDhAj///DN//fUXI0aMAKBly5ZUqVKFPn36cPToUQ4dOkS/fv1o0qQJNWvWJDY2lvfff5+dO3dy/fp19u7dy+HDh3UBQqlSpYiOjmbbtm3cu3ePmJgYvLy86NOnD/369ePvv//m6tWrHD58mG+++YZ//vkny++vnZ0dQ4YMYezYsWzatIkzZ87w7rvvEhMTw8CBAzN9/u7duylTpkyG01G5QQIUIYQQJqV06dIcPXqUZs2aMXr0aHx9fWnVqhXbtm1jbqqEmu7du7Njxw5CQkJo3Lgx3t7efPfdd3z66acEBgZmOM3h7OzMuHHjiIuLy7Q/gwYNYvny5QbHR48eTVBQENWrV+fLL79k5syZtGnTBlCnT1avXk2hQoVo3LgxLVu2pEyZMvzxxx8AmJubc//+ffr164eXlxc9e/akXbt2TJo0CVBXHA0ePJhevXrh6urK9OnTAVi0aBH9+vVj9OjReHt74+/vz8GDB/VyXbJi2rRpvPbaa/Tt25caNWpw6dIl/v33XwoVKpTpc1esWMG7776brfvlhGwWKIQQLwnZLPD5iIuLw9vbm8DAQN0ITqlSpRg5ciQjR47M2869YKdOnaJFixZcuHABR0dHo21ks0AhhBDiBbCxsWHJkiXcu3cvr7uS527fvs2SJUvSDU5ykywzFkIIITLxPOt95CetW7d+YfeSAEUIIYTIpmvXruV1F156MsUjhBBCCJMjAYoQQgghTI4EKEIIIYQwORKgCCGEEMLkSIAihBBCCJMjAYoQQgghTI4EKEIIIYQwORKgCCGEyHMDBgygS5cuusdhYWEMHz6cMmXKYG1tTfHixenUqRPbtm3Te96+ffto3749hQoVwsbGhsqVKzNz5kyDnYB37NhBs2bNcHZ2pkCBApQvX57+/fuTlJT0Il6eyAEJUIQQQpiUa9eu4efnx/bt25k+fTrBwcFs2rSJZs2aMWzYMF27VatW0aRJEzw9PdmxYwfnzp1jxIgRTJkyhddff52UreZOnz5Nu3btqFWrFv/99x/BwcH89NNPWFpaotVq8+plikxIJVkhhBAmZejQoWg0Gg4dOoSdnZ3ueKVKlXj77bcBePz4Me+++y7+/v7Mnz9f1+add97Bzc0Nf39//vzzT3r16sWWLVtwd3fX7QgMULZsWdq2bfviXpTINglQhBDiJRYXF8elS5de6D3LlSuX492UIyIi2LRpE1OmTNELTlI4OTkBsHnzZu7fv8+YMWMM2nTq1AkvLy9WrFhBr169KFq0KKGhofz33380btw4R/0SL55M8QghhDAZly5dQlEUKlSokGG7CxcuAODj42P0fIUKFXRtevToQe/evWnSpAnu7u507dqV2bNnExUVlbudF7lKRlCEEOIlZmNjg6+vb153I8tS8kY0Gk222hs7nnINc3NzFi1axFdffcX27ds5cOAAU6ZM4ZtvvuHQoUO4u7vnTudFrpIRFCGEECajfPnyaDQazp49m2E7Ly8vgHTbnTt3jvLly+sdK1asGH379uXnn3/mzJkzxMXFMW/evNzpuMh1EqAIIYQwGc7OzrRp04aff/6Zx48fG5x/+PAhAK1bt8bZ2ZmZM2catFm7di0XL16kd+/e6d6nUKFCuLu7G72HMA0SoAghhDApc+bMITk5mdq1a7Ny5UouXrzI2bNn+fHHH6lXrx4AdnZ2/PLLL6xZs4ZBgwZx8uRJrl27xoIFCxgwYADdu3enZ8+eAPzyyy8MGTKEzZs3c/nyZU6fPs24ceM4ffo0nTp1ysuXKjIgOShCCCFMSunSpTl69ChTpkxh9OjRhIaG4urqip+fH3PnztW16969Ozt27ODrr7+mcePGxMbGUq5cOT799FNGjhypy0GpXbs2e/bsYfDgwdy+fZuCBQtSqVIlVq9eTZMmTfLqZYpMaJT0MoxMWFRUFI6OjkRGRuLg4JDX3RFCCJMQFxfH1atXKV26dI6X+QrxrDL6PczO97dM8QghhBDC5EiAIoQQQgiTIwGKEEIIIUyOBChCCCGEMDkSoAghxEsmH659EC+R3Pr9kwBFCCFeEpaWlgDExMTkcU/EqywhIQFQtxh4FlIHRQghXhLm5uY4OTkRHh4OQIECBbK8p40QuUGr1XL37l0KFCiAhcWzhRgSoAghxEukaNGiALogRYgXzczMjBIlSjxzcPxMAcrUqVP55JNPGDFiBN9//73u+NmzZxk3bhy7du1Cq9VSqVIl/vzzT0qUKAFAfHw8Y8aMYcWKFcTGxtKiRQvmzJmDp6fnM70YIYR41Wk0Gtzd3SlSpAiJiYl53R3xCrKyssLM7NkzSHIcoBw+fJj58+dTpUoVveOXL1+mYcOGDBw4kEmTJuHo6MjZs2f1qsmNHDmSdevWERgYiIuLC6NHj6Zjx44EBQU985yVEEIIdbpH/n8q8rMclbqPjo6mRo0azJkzh6+++opq1arpRlBef/11LC0tWbp0qdHnRkZG4urqytKlS+nVqxcAt2/fpnjx4vzzzz+0adMm0/tLqXshhBAi/3nupe6HDRtGhw4daNmypd5xrVbLhg0b8PLyok2bNhQpUoQ6deqwevVqXZugoCASExNp3bq17piHhwe+vr7s27fP6P3i4+OJiorS+xFCCCHEyyvbAUpgYCBHjx5l6tSpBufCw8OJjo5m2rRptG3bls2bN9O1a1e6devGrl27AAgLC8PKyopChQrpPdfNzY2wsDCj95w6dSqOjo66n+LFi2e320IIIYTIR7KVgxISEsKIESPYvHmz0Z0ytVotAJ07d2bUqFEAVKtWjX379jFv3rwMt7VWFCXdjN/x48fz4Ycf6h5HRUVJkCKEEEK8xLI1ghIUFER4eDh+fn5YWFhgYWHBrl27+PHHH7GwsMDFxQULCwsqVqyo9zwfHx9u3LgBqEvgEhISePDggV6b8PBw3NzcjN7X2toaBwcHvR8hhBBCvLyyFaC0aNGC4OBgjh8/rvupWbMmffr04fjx41hbW1OrVi3Onz+v97wLFy5QsmRJAPz8/LC0tGTLli2686GhoZw6dYr69evnwksSQgghRH6XrSkee3t7fH199Y7Z2dnh4uKiOz527Fh69epF48aNadasGZs2bWLdunXs3LkTAEdHRwYOHMjo0aNxcXHB2dmZMWPGULlyZYOkWyGEEEK8mnK9kmzXrl2ZN28eU6dO5YMPPsDb25uVK1fSsGFDXZtZs2ZhYWFBz549dYXaAgICZM2+EEIIIYAc1kHJa1IHRQghhMh/nnsdFCGEEEKI50kCFCGEEEKYHAlQhBBCCGFyJEARQgghhMmRAEUIIYQQJkcClFfJjh2wYkVe90IIIYTIlAQor5KQEDh0KK97IYQQQmRKApRXSXQ0pNmGQAghhDBFEqC8Sh49kgBFCCFEviAByqskOhoUBeLj87onQgghRIYkQHmVREdDtWpw+XJe90QIIYTIkAQor5JHj8DPT6Z5hBBCmDwJUF4l0dFQs6YEKEIIIUyeBCivkpgYdYpHAhQhhBAmTgKUV4miQJEicPduXvdECCGEyJAEKK8ajSaveyCEEEJkSgKUV5GzM9y/n9e9EEIIIdIlAcqryNtb8lCEEEKYNAlQXkUSoAghhDBxEqC8KrTap/knEqAIIYQwcRKgvCpiYsDOTv13uXJw6VLe9kcIIYTIgAQor4roaChYUP23rS3ExeVtf4QQQogMSIDyqnj06GmAAmBmBsnJedcfIYQQIgMSoLwqoqPB3v7p41Kl4Nq1vOqNEEIIkSEJUF4Vqad4QBJlhRBCmDQJUF4Vjx7pj6B4ecGFC3nXHyGEECIDEqC8KoyNoEiAIoQQwkRJgPKqSDuCUqQI3LuXd/0RQgghMiAByqsi7QiKtbUsNRZCCGGyJEB5VaRdZiy7GgshhDBhEqC8KtIuMxZCCCFMmAQor4q0UzxCCCGECZMA5VWRNklWCCGEMGESoJiAq1evMnny5Od7k/RGUBTl+d5XCCGEyAEJUEzAnTt3SEpKer43SUgAKyv9YzY2EB//fO8rhBBC5IAEKCbg5s2bNG/enPMvuvS8vT1ERb3YewohhBBZIAGKCUhISKBJkybs37//xd7YwUHNTRFCCCFMjAQoJkKj0WBtbU3ciyyeJiMoQgghTJQEKCakXbt2bNq06cXdUEZQhBBCmCgJUEyIk5MTDx8+fHE3lBEUIYQQJkoCFBPj7e2d+8myiYlgYWF4XEZQhBBCmCgJUPJYcnIyZmZPP4a6dety+PDh3L1JemXu7e0lQBFCCGGSnilAmTp1KhqNhpEjRxo9/95776HRaPj+++/1jsfHxzN8+HAKFy6MnZ0d/v7+3Lx581m6km+Fh4fj5uame6zRaDA3N8/dm6RXpE2meIQQQpioHAcohw8fZv78+VSpUsXo+dWrV3Pw4EE8PDwMzo0cOZJVq1YRGBjInj17iI6OpmPHjiQnJ+e0O/nWzZs38fT0fL43SbuTcQqZ4hFCCGGichSgREdH06dPH3799VcKFSpkcP7WrVu8//77LF++HEtLS71zkZGRLFiwgJkzZ9KyZUuqV6/OsmXLCA4OZuvWrTl7FfnYCwlQMprikREUIYQQJihHAcqwYcPo0KEDLVu2NDin1Wrp27cvY8eOpVKlSgbng4KCSExMpHXr1rpjHh4e+Pr6sm/fPqP3i4+PJyoqSu/nZREbG4utre3zvUl6UzwygiKEEMJEGVnakbHAwECOHj2abiLnN998g4WFBR988IHR82FhYVhZWRmMvLi5uREWFmb0OVOnTmXSpEnZ7apIkd5OxpIkK4QQwkRlawQlJCSEESNGsGzZMmxsbAzOBwUF8cMPPxAQEIBGo8lWRxRFSfc548ePJzIyUvcTEhKSrWu/8tIbQbGxgdjYF98fIYQQIhPZClCCgoIIDw/Hz88PCwsLLCws2LVrFz/++CMWFhbs3LmT8PBwSpQooTt//fp1Ro8eTalSpQAoWrQoCQkJPHjwQO/aaVezpGZtbY2Dg4Pez8vk0iXYseM53iC9JNlsBpFCCCHEi5KtKZ4WLVoQHBysd+ytt96iQoUKjBs3Dnd3d9q0aaN3vk2bNvTt25e33noLAD8/PywtLdmyZQs9e/YEIDQ0lFOnTjF9+vRneS351oEDcOECNGv29FhGI0rZll6SrBBCCGGishWg2Nvb4+vrq3fMzs4OFxcX3XEXFxe985aWlhQtWhRvb28AHB0dGThwIKNHj8bFxQVnZ2fGjBlD5cqVjSbdvsy0Wi0ajYabN+Hu3afH7ezsiImJwc7OLndulN4IihBCCGGisp0kmxtmzZqFhYUFPXv2JDY2lhYtWhAQEJD7BcpM3L179yhSpAh79+oHKI6Ojjx8+DD3AhQZQRFCCJHPPHOAsnPnzgzPX7t2zeCYjY0NP/30Ez/99NOz3j5fCwkJwdPTk1u3ID7+6XFHR0ciIyMpVqxY7twovSRZIYQQwkTJXjx56ObNmxQrVsxgLz8nJyciIyNz70bpLTMGsLbWj46EEEIIEyABSh56/PgxBY2MbKSMoOTijaBAAePnpJqsEEIIEyQBSh6Lj1cHMczMIGUrIgcHh9wNULRaSC+/R6rJCiGEMEESoOSxW7egWDFwdoaICPWYubk5Wq32xXRARlCEEEKYIAlQ8tjNm+DpCa6u+it5XhgZQRFCCGGC8mSZsVCl1EApbh2O2aNo7t4t8+I7ISMoQgghTJCMoOQRRVGAJyMod4/hemlf3oygyIaBQgghTJAEKHkkIiICFxcXQkLAM+YCrnfPPp8A5UkglC6Z4hFCCGGCJEDJI6mLtHk8OI1r/M3nE6DExYGtbfrnZYpHCCGECZIAJY+kLtJmfe8WrmUduHsrIfdvlNk+PDKCIoQQwgRJgJJHHj58iKOjo/pAUShcxYO7V55DoJDZPjwygiKEEMIESYCShxISwNJCAY0Gu6rleHw3JvdvktkISnaSZMPC4JNPcqdfQgghRAZkmXEeiImJwdbWltu3oVihGDAviqaijzrakdsyG0FxcMj6CEpwMBw9mjv9EkIIITIgIyh5YP/+/dSrV09dYmx7H0qWhPLl4fHTAEWj0eRONdnMdjK2tYXY2Kxd69w5CA199j4JIYQQmZAAJQ+Ehobi4eGhBiiaW2qAYm0NWkW3Ktje3p7o3BhRyWgnYwCNJuvXOncu82XLQgghRC6QACUPhYSAZ+JVKFUKACfrWB6GxQHqjsYPHz589ptkNoKSHTduQNmyavKMEEII8RxJgPKCPX78mAIFCgBqFdnij8+qIyiAq5sZd49cB9QAJVd2NM4sSTY7FAU8PNRkWSGEEOI5kgDlBdu3bx/169cH1J2MPR6eVb/0AddSBbh77CYATk5OuROgZJYkm1WRkep13N0lD0UIIcRzJwHKC3bnzh2KFi0KQHw82BAHFupiKlcvZ+6eUcvJZjaCEhoayvHjxzO/YW6NoJw/DxUqvJoBSlAQ3LmT170QQohXigQoaQQHv8gZDP2EU9fKRXXF2goWLMijDOqTnD9/njNnzmR+i5AQ3QhNuqys1GgpI+fOgY+Peq3btzO/78tk1izYsSOveyGEEK8UCVDSCAqC3bufz7Wjo6Mp+GQ0IzERLLQJ4OKiO+9awpa7UVYAmJmZ6XY8NiYsLCzzZciKAnfvQuHCAJw+Dfv3G2mXlWJt5869miMoigIHDsDFi3ndEyGEeKVIgJJGxYtrOL3h2nO59t69e3X5J6Gh4GEXqVvBA+DqCncTnCA5OdNrabVazMwy+fiuXFFX3Tzxxx/w009G2mVlP54LF9RaLa/aCMrFi1C3rvr6hRBCvDASoKThU9OOsyefzzLau3fvUqRIEUBdweNpFa5bwQNPAhSrYnD1au7ccOdOaNpU9/DYMYiIMLJKOCv78cTGgq0tyYUKw717udO//GDnTnjtNXjwIK97IoQQrxQJUNKwr1OR6Htxz+XaqUc8QkKguBKiN4Li6AiRVoXh7NncueGuXdCkCaAGJRoNtGihHtaT2RRPYiJYWHDlCgwZZga5UeE2v0j1HgohhHhxJEBJy90dy4THJCY+39vcvAmecZf0RlA0GqCgfZYDlIxyVFAUCA+HJyM2QUHg5wddusDq1WnaZrYfz5OpoiNHspeKERUVxfLly9m0aVPWn5QdWu3zrWyrKOqQk7MzFCqk/vtZPX4MAwc++3WEEOIlJwFKWhoN5QqEculC7o4S3L9/H2dnZ93jPXugavwhKF5cv6F9QXUpUQZS55+kG6RcvQplyuge7t4NjRqpaSQXL6b5Xs9sBOXJCp6jR9WcWywsyCiCe/jwIQEBAfz777+89tpr3HteU0Kffgpr1z6fa8PTxGAAL6/cSZTdtw9WrID795/9WkII8RKTACWN+/fv413iEad33s3V6wYHB1O5cmUALl1SF+8U4oG6xDc1K2uU2LgMvwxDQ0Nxd3fH2dk5/XL4afJPDh5Ucz0BatZUR1R0MkuSffJFffasGk8pRdzSrQsSGRnJsmXL6Nu3Lz169MDGxib96z6LmBj48091adLzsmMHNGum/jslssuNaw4dCuvWPfu1hBDiJSYBihH3C53hzN7cTYq8ffs2Hk/qkfzyC7z3HkY36itYEKInzICPPkp3+uLatWuUfPwYjwcPuJ3eipqdO3W5E1qtmuP6pMK+4TRPZkmy586heFcgMRGKFoX7TmWNLjV+9OgRS5YsYciQIZibm+uOu7i4cD+3RwyWL4cPPni+q2t274bGjdV/51aAcuIEfPIJrF//7NcSQoiXmAQoabi4uOBUzorgk4aJshef8QtKo9EQFwcnT0JNryijJehdXeGuXSl1mOPQIaPXubV/P54zZuARGGg8QEnJP3FzA9RBhkqVnp6uWRMOH07VPrMRlPBwbsUXpnhx8PSEm9ZlDJYaR0dHExAQYBCcANSqVYvDejd8Roqijp4MHvz8pkoURS3v7+SkPs6NACU6Gmxt1ZyW5GT1sRBCCKMkQDGi9/B3uXzrX71jGzduZO3atemPWGTRX39Bjx6guXFdbwVPClfXJ3keY8bAli2GgcPFiyQtWoTFn3/iYm3NPWNLkq9dg9KldQ9T8k9SmJmp6SmXLj05kHYEZeZM2LBB/feTUZyjxzRUr65O8dzUlDAYQVm9ejWDBw/G4knZ/tQKFy6cuyMoO3dCgwZgbZ1710wrbVSXWSJxVuzdq/YboG1beF7Jw0II8RKQAMUIxxIlUJJjefQoFoCrV6+SmJjIhx9+yOrVqzNePWOEVqtF82Q6Z8UK6N0bNYhItYInhS5AsbbGvGtXksePh8uX1WjiyBF1bmjIEHB1xax3b5R9+wxvmCb/JPX3YorOnWHNmicPUifJXr2qJnJu2KBORdy6Be7uHDsGNWqoIyghCW4GAYrZ8eNYGhRYySVpC9fNm/dkjgw1med5jKLs2KH3Huo8y6qh1Dkteh+AEEKItCRASUeDwj788vNfJCYmsnHjRvz9/bl/X0OnTp1Yn838gevXr1OyZElOnIBy5cDODrh+PeMABXBo2JAoT0+1/OvPP0NgICxcqE4RAHTooFZfSytV/omiqN/fqSrqA+r3pG57mdSjA5MmweTJMGcO+PpCx45QoQInT0Llyk+meGKcDavJ/v23ujQpA9kN7AC1gIuPjxqQXLyoBlA2NmrJfVBX1zyPPJQ9e/SHnUBdsn33GZKnT56EKlXUfxctmk7VPCGEECABSrqqV7Dg1qkH/PLLL/Tr149Tp6BaNXB3L05CQgJh2dhR8NSpU/j6+vLLL2raBFotbNyoXjCN1AGKo6MjD3v1gu+/Vzes+/ZbKFVKNxqDtbX6hPPnn17g8mW16umTHZPTzPboWFurheHCw1GzZ2Ni1C9Qc/OnUxtvvKHOSb3+OnFxavpE8eJw80GBJ098IipKff7evem+B2XKlOFqTirk7tmj1g0ZPhymTIH27dVVMCm8vPRff26JjlYDt9SeJQ/l0SM1Mk29PYFelCiEECI1CVDSUbF2QRxi6tK6dWsKFizITz9Bu3bwzz/QrVs31maj/sajR4+wt3fg6lWoWBF1iqJDB10QkVraACUyMlLvvMEoRKNGsHSp+u+EBPXLO9WGO2nzT1Lr1OnJYpKUgGfyZJgwQb9R+fLctfbUjcA4OUHEA/1qsvE7d2LdujUcP57ue1CtWjWOGRvtycw//6hBia8vBASo00916jw9/zxGUO7ffzpKlVp2ApT169W13Sn27IGGDfXbdO0Kq1blvJ9CCPESkwAlHRVbFePiOWu8vLy4d08dMJg2DRYvVlfjODo6kpiNcrMXLqjfpVy7pn7pDh5stF3qAMXJyckgQLl79y6urq5PD5Qrp+62q9WqhcsGDdJNHWm16gaBzZsb71NKwAWoOS4lSqg/aaTkn4DRldFcW7+eUm3aqPNJSUlG72Vra0tcXA62EAgOVoOTFIUK6Z/PreW/qaV+wTm914IF6ueRMrqzc+fT/JMUZcuqU1bPsxquEELkUxKgpMOxlheREeqX7fz5agqES9wt7Ozgxg2oXr16tkYEduyAZk0VGDlSnbJJZydiZ2f1+vfuGR9BSclnSWFmbo62YUP47DO1jPprr+nO/fijmkJiZKBGfY2OajwRHY2aXDJ+PKDGKqlTI9J+X2s0oJiZ64KRy8eOUaZNG6haVa3zkVuuXlVXOhmLioA9e/Zw6dYttchLbkovQClXLtXSpwzEx6uJvUuXqgnNYWF6gVZISMjTtqVLq/seCCGE0CMBSnqsrDBXkoiNVYOL1pfnQsOGvOMfzoIFUL58+SzVRYmPj8fKyor//oMmIcvUwl/lyqXb3swMZsyA998HW9sCPH78WO/8jRs3KJ6qPL6rqyt327dXlyTPnKk7fvo0/PdfugM1Om3bwubNwL//gqsrMTHqKqPhw5/+YX/s2NN0mdu3b+PsDBGOpdVhpZgYHgKTvirMxVKtMsxDsbCwyNaoExs3qtM76bhy5QonTpxQ37Tc3MAw9QtOzc5OzbXJzL59UL++msg7Zw706aOulDIzQ1EUZsyY8bRtjRpw9GiudV0IIV4WEqBkoKxTBNMnx9Gt4lnM9u+F9etpFDiMffsUkpON/1Wf1rlz5/D2rsDD+8kUWrsYRozI9Dl+fur346JFhveIj4/XKx/v4eHBbUtLtaibrS2gjn6MGqUu/Eln8EHH3//JatcnDadNg88/V5Nh585V2zx6pOaLJiQk8O2336oreQp4qUuNDxyA8uXZuhXWhNaG/fvTvVeVKlUIzmSfIT3btqnbL6cjKcmcx4/j1Wmp1KMSzyoyUh1eSk9mUzJbtkCrVuq/K1RQk3vffhuAsLAw/aBTAhQhhDBKApQMVPRR+GWuln6nxsGvv0KlSmiqVqG9+zFd7kZmS2fPnz+PVutNhcRgdTVKmiqr6Rk7Vs2fzGyxkIeHh1o87kmAERur1ngbPPjpStyMn6/mvCQmqpsWnzqlJs9++qma17l+/dOCt9evX0er1aoreSxKqUuN//uPuDIVKVcOdh60hYcP0/0C9/b25nzqFTe3bhnWOEkRF6dOIRUsmG7fV61SBytydSVPVFSG98Td3WiZfz3HjkH16k8f160LbdoAcPbsWXx8fJ7+3vj6Zro5pBBCvIokQMlAneZ2DNfMxm7pPN3oBOPG0e/6VyyeH0/p0qUzXTqblJTEnl1mNLv/P7WEbBaZm6uzA/PmqVvOfPCBmr5y4oT+97+DgwMPH0Zy8KAalHTvDrVqQbduWX+djRurq30+/lgdQdFo1J/589WyKCmzHZcvX8bLywt39yRCkj3UL+qgIK5Tijp11EDmXpGKahKNEWZmZmhTTcXEDBqpdtrY9MyuXcYLpaVy9qwaVOXqSp4TJ/SDi7QyS5S9f19N5E0nx+j27VCKFq38tLKujY2asyKEEEKPBCgZqPJuHcYf66kOM6SwssJlxsfYng3Cw8OPIL1tgQ0pisJ/y0No/FZZMFIGPiMlSqijIR9+qP4MG6Z+Ibdpo5YnOXoUPvlEw7Rp6uZ/o0apBWD79s3e6+zSRR2xKV36yUqjJwoWVKd/+vdXH0dERFC/fn0SE89xM8EVrl1Dq9Fw9YY5fn5qQu4G624ZFmzTpJpz6h00msNFO6kvLG2QkrK8GHXlUlpnzsRQurQtDx4U5q6LS+4FKOklyKbw8so4QNm+Pf1lU6gjUp995kVQUKpruLllPlQmhBCvGAlQMmJra3S/HGrXpme5Y6ybH0F8Bn/93rx5Ewd7Bx5dvoPj4N456kLBgmoXSpVS/3hPKZ1x65ZaWPa112D8eA1Tp4K3d8bXevz4Mb///jsrVqxgxYoVnDlzBlDTJHx81IVAaXl46E8VVapUiYcPT3PzkSOsXUtohQqEhrrj5/dk2fKtqhkmypqbm5OUlAQPHnAlrhjLH/mrQzQjRugPDZ0/D15eaLVa+vX7yOA6S5dewt+/PM7OVQm6G6FW5s2KxMSME2qPHjUYQYmKSrV6unp1/fomaaXOP0nj998hIkJDQEAJvv8+1ShTjRrGKwILIcQr7JkClKlTp6LRaBg5ciQAiYmJjBs3jsqVK2NnZ4eHhwf9+vUz2GAvPj6e4cOHU7hwYezs7PD39+dmPltq2eab5mxadi/DNhs2bKDE5QLq6tJUia3ZkZCQoMtXePjwIU5OTtjZqdM906erOxND1upo7Nq1i7Zt29K7d2969+7N0VTJmcuWGd1c2YClpSXW1klExNrCmTNcKVGCpKSyuLioS6RjzOyIu5T+Z5my+il053lqlX/AmTOQNPA9tQR8p05q1m6nTmpRM42Gf/89zObNpbl8WT9XZfv2S7zxRjn8/Nw4evyeYS6LsaXHigK9eqnzZum5e1ctRpPKkCFqPRngaUKusdwZRVGnt4xsYbBzpzrK1a8fNG1qTlRUMk/iQ0mUFUIII3IcoBw+fJj58+dTJWVvESAmJoajR4/y+eefc/ToUf7++28uXLiAv7+/3nNHjhzJqlWrCAwMZM+ePURHR9OxY0eS00uYNEHW1Xxw09whIcKCBw8eGJw/cOAAdWrXZuf8CzQbXjnH92nSpAnz5s3j8uXLXLt2Ta8GSnY9ePAA5zQVUnOyP45GA2jMoEQJLlk5ULhwMd25Fi00bI+rp66EMaJixYqcOXOGoH/v4VfLnFatYOtW4N131fmPtWth3TrdcM6qVRfo3dufiRPP6a4RHQ1abRwuLrbUrPkkD8XGRk2sBXV6yNtbzfhN7Y8/SKxYFWXl38YDjNhYg0AyLEwdrdqyJdXBBg2MjxJdvmx0CfnevWpuz6xZD3B2dgLUOOnTT58MGlWtmmEVXiGEeBXlKECJjo6mT58+/PrrrxRKVdnT0dGRLVu20LNnT7y9valbty4//fQTQUFB3HiSOBkZGcmCBQuYOXMmLVu2pHr16ixbtozg4GC2bt1q9H7x8fFERUXp/ZiCXu84cGOtNQcOHNA7rtVqOXnyJNVu3GC3WVMati6Q43uUKlWKIUOGcPnyZRYsWPBMAUpaBqtqMpA6kDE3N0erTUJZtZprtyypUePpr5G/P6xJ6qgWo4uIMLiOjY0NcXFxBB1R8GvrSu/e6tRHeoKDYcaMSpw5c4qUOHDrVnXjQlATgq9cQQ0MLl9WRyJ+/lmNCj744GlZ3jt3YMECJiZ9xkrPEWogZOxmqQJuUBOFP/9czQfWvQXduhkvUZ9qeicyMpK4OC3jx6tFZf/4A65fV1fwABQurC7g2bAB4/VVNm5US/sLIcQrKkcByrBhw+jQoQMtW7bMtG1kZCQajQYnJycAgoKCSExMpHXr1ro2Hh4e+Pr6sm/fPqPXmDp1Ko6Ojrqf1IXK8lLzj2py4Fgx7t+5o3d89erVdO3YkYTv5xDjWT5LUyeZad26NbNmzaKgkSWwWSmAlpycjFmalSXVq1fXm+bJSHh4OEWKFAGgQoUKmJmd42Gpaly5ouDn97RdmTJwza4S2vLeavnd114zmjR78pYzVVu64umprkw+dOiUwYqoy5evo9WWwN3dkmbNknQzM+vXP11Z5OkJDx5YE1+6tBogjBmjVnAtXhx++EHN8I2PV+fEvv2WbTvN2VuwtbpsPK00CbIJCerqpubN1f0TdVMyFSuqlfDSjj79+69u5dHs2f+jceND1KypbkDt6KgW2UsdYI4bp/Ddd0/yWwoVehrQKYq6OeS//6b/gQghxEsu2wFKYGAgR48eZerUqZm2jYuL4+OPP+aNN97A4cnOsGFhYVhZWemNvAC4ubmlu0Pw+PHjiYyM1P2E5GZRrmdgaW1G6YoFCN2iTiUkJSWxfft2kpOTcV29mkXFv6DH69lbuZMRi3RWAbm7u3MnTZCU1unTp6mUsktxqutps1iB9cqVK5QtWxZQE2XNzU8TEqKOXqQOUABq1TFjh9vr6lKj335T5zdS0SgKcVorbAuoK3q6doVFi46zRW8eBZYu3UubNg0AdRZk61Z1FickRMHFRQ0ONBpwdq7IMcVKTcpZsODpRn+VK6sJJE2aQIUKhDhXxccHLlyzVoOMNCNfHD2qF6D8/bfaN40GWrdONc2j0ajJsqkTW3fvVnNPHB1JTobAQFvefPNi6p0H0Gq1uiDR3d2dqKhQXnvtSX5L6utt26bWTjGRkUIhhMgL2QpQQkJCGDFiBMuWLdOrZmpMYmIir7/+Olqtljlz5mR6bUVR9JagpmZtbY2Dg4Pej6l4/dMyHNuRxNKlS/nzzz/x8vKiR5s2JPxvLX+E1OfNN59/H3TF2jJgLEABddlvVoKU1CX2LS0tcXJK5OZNdfuflJ2OUwwfDosWqauH7yYVUqcwUuXpJIXGUajQ0y/fbt3g8GHD7QOOHUumY0c1KLO2tqRnzwRGj4YKFe7g5uama9eggRdbw63UgKN0af3OdOqkFnMZP55//lGXQltZQdygD9TNilK7dUtvSfnSpWpSK6i1YnbtStU29TSPVgtffqnbCTogQA3a0u5rmJqXlxcXL17k7bfV90pbLVWi7I8/qtNTLi7qpkxCCPEKylaAEhQURHh4OH5+flhYWGBhYcGuXbv48ccfsbCw0CW5JiYm0rNnT65evcqWLVv0AoqiRYuSkJBgkFgaHh6u96WTXzRsVYB7NsN4M+gob9SqhaenJ3zzDYurzKTPmxosLZ9/H9zd3bl161aGbbRaLeZGqthWrlyZU2mTSY1ITk7WG8FxdoZjx6KwtzcMFt3c1FVBb76p1mQJdBqsl2WadK0QbiWebrpnZ5eElZU5FSs2Y8eOHQBERUVx86b9k1VKaj+rVAnm77/B2/s83qnWVNeubcGlKxjdiRlQC8dYWbFlC7Rs+WTRzL0Sal2aoCD45Rc1cqldW1eR99gxdVl3yoxagQJqXq1uVXmtWur2AgBLlqiBkLMzkZHw++8KLVqAp6dnuqN9Hh4e3Lp1C1tbdXRm3Z1a6k0PHlR3OS5cWF2idfhweh+JEEK81LIVoLRo0YLg4GCOHz+u+6lZsyZ9+vTh+PHjmJub64KTixcvsnXrVlzS/Hnt5+eHpaWl3nB+aGgop06don79+rnzql4gc3Oo3KUc64oNhm++AX9/EoPPERhcSffX9/NWoEABYnO4o6+vr2/29sd5wtXVgr//vkDNmmXTbVOvnrqg5rcz9UjcsFl3POSMMw6lnq7yCQoKYvjwmowbB7Vr1+HAgQOsWrWD8uWb6Qqyent7c/XqeTZuBAeHWxQr9nTlkG4lTwbi4tTgwtFR7df+/aj5KlOmgJMT/PknfPGFrv2sWeoIUGr16z8prQ9qpdhy5dQAZ+lS3a6MX30F770XhqenOw0bNmTvk9U+jx8/pkCBp8nSqUcLBw+GuUsKojx4qG74OHq0eqJ27ecfoISGZlx4Tggh8ki2AhR7e3t8fX31fuzs7HBxccHX15ekpCS6d+/OkSNHWL58OcnJyYSFhREWFkZCQgKgrvQZOHAgo0ePZtu2bRw7dow333yTypUrZynp1hR9NUXDqjPezPD+DWXxEpa0Xkbv3ryQ0ZMUjx8/JsLIqhlQK8CmXV6cwuzJDrvZVadOBY4d+4cWLUpn2M7MDLr0smHVidK6AmknLxagRI3CujYXL17k9dfL4esL27dX5eTJk+zdG0mnTo6prqP2s1o10GgUvYTfokXVVc0ZvY7UlfNr134y+FGlippo0quXOkTyxNq1UKSIOoKSml4eCqgJKl27qmV4LS25cEEtkeLkFIyvry+WlpZqUTrUPZm806mk5+Cg9mlbTD01gvL0VE9Uq5b58uM//lBXL+XU5MlqInEmU4RCCPGi5Wol2Zs3b7J27Vpu3rxJtWrVcHd31/2kXqEza9YsunTpQs+ePWnQoAEFChRg3bp1Rqcg8gNbW3WlhoUFDBjpxPK/bV/Y6EmKgQMHsnz5ch49emRw7uDBg9SuXTvd55qZmemm5xRFYf78+bqAMj0NGlRCowmiXr3MC9D17w+Lo1/TJYHGJphjZW+t10aj0TB6tLoVTsGC7Tl92jplf70sKVSoBOfPP51OSdv9DRt0lfNxcFDzT43FM6Gh8NNP6sBKWtWqpSn42qSJuktx27ZotWqc8vXXcO/ePVyfFHuzsbEhJiaGy5cvU85IjZQUH3wAP8S9B5988vRgyj49GQWQCxfCjBnpn89IRIQamAQEwIABakKREEKYiGcOUHbu3Mn3338PqDU7FEUx+tM01cZvNjY2/PTTT9y/f5+YmBjWrVtnMkuHc0qjUffC6ddPHaG3snqx9zczM2Pw4MEsXLjQYLonIiLCYKottRo1anDs2DGSk5P55ZdfqFWrFtu2bdOdj4mJwTZls8QnrKwsqVzZ2yBB1hh7eyhT1YHjC4IIuxKDm90jNBoNiqLw+PFj7OzsAPU9nDcPAgI8KViwF4UL61/H1taWmJgYo8nUjRtXYfXq41y5oua91K0LT9JZUBQ4d04t6Z8ipSBsalqtuujnhx9AUeIM7mFmpubepOzzh6UlTJwIqAFNx47qMuvUmjRpwq5du0hMTMQyzZBa6sCwcGGo1aEIr40pzbffqvm+SUmooynpVVmOi1ODmPBw9Se7fv0VBg1S9xf69FN46630d5cWQogXTPbiyWUtWkCHDnlzb0tLS9577z3mz5/P42z8Nezt7c2JEyeYM2cOvXr1onr16nob9F29epUyab95gf/+M7J5Tzren1yEn9eVIGh1CH4V4yhevDghISHs2bOHhg0b6trZ2qorhZ/snqCnevXqHDp0yOCLHqBhQ0fmzbvPxx+rgxB79qiBxqZN6j6C3t66/FcgVR5KKt9/D61bK5w79zeLFy9mlZFibC1aqNcEdbRp6dKlbN6sbgX0zjuGfXZ1deVeOitxUt6DFF98AYsXqyuO165VA15q1Uo/D+XwYXVuaNgwdevr7EhMhM2b1Q2UQB0N6tjR+NCREELkAQlQXjI2NjYMGTKEgIAAwsPDjRZoS0uj0RAaGsrAgQN19WlSRitArYFiLEDJznJv70oW3FVc2PL3I2o2sqVy5coEBwdz9+5d3XRIiuLFn35vplaqVCm2b99utC9NmsDYsZ7MnBmCj4+aUvLHH+oMyJgxT6d3FEXh2rVrPHr0N4sWLWfZsmX88ccfrF59ge3bb5Gc/DN16tThvffew9vbmxUrVujdp2tXtVDc++/D6tW7OXr0MtOna/npJzUASl3rJDMpS41TK1hQDYK+/lpd9Rxaqt7T1UJp7dqlvvDmzdXs3bTVaNMRHR2t5t506wap+9q3r2FtGCGEyCMSoLyErKysGDp0KOvXr2ft2rVG65+k9dlnn+mtMmnVqhWbN6srbx49eoR9LpTDHfhaJL/s9aVqpxI4OTnx8OHDbD1fo9Fw5coVvLy8DM5ZW8OQIS30pqasrWH5cjUXtmlTuHv3LrNnz+bmzZu8/XZbzMz68Oabb9KmTTe++iqSxo3X8P77w3QrhCpWrEidOnUICAjQJeAWKgQrVqhTeZMnX2HLljcYMuQQKTNgV69epXSaWixVq1Y1GrQULlxYb6QqrdGj4buNPqlK2KZx6JA6wqLRPEn0WZzR26cTEBDAge+/V5+TmkajzsdJgTghhAmQAOUlpdFoePvtt4mLi8tSgJKWk5MTkels+JdT7cdWYpTlbGx9SgFw586dbNe+8ff3TzdYMjMzw8bGRi8Hx9JSnbU4efIgmzdvZtiwYTRs2BA7uwJYW6tpHB99ZMk339Tio4+GGuS3lClThmbNmrF+/Xq948WLhzJlihv793sRE/N0FOT06dNUrFhRr22VKlXo1auXQX/TK0yYokEDOHfBjPtxdroVUDqJiWpyjfWTZOOePbm1fCf3wzPPIXG+f58zjo5Pi7w8kZCQwKcREayYNo0VK1awZMmSTK8lhBDPiwQoL7nevXvneHVUTkY5MmLu6c7Xf5XXTSs8fvyYBg0aZOsaPXv2zPB8hw4d2LBhg+6xoij88ccfKIpCnz599EYy/Pzg44/Vgq0tWqR/zZIlSxIdHa1XXHDr1q20adMae3t0ieCgTp8YC6DSC0YyW+L9wQfwQ9QAw1olQUHg58f16+pK4badLPk0/gt6tLif+arj//6j9JtvciVN8Zj//e9/fDx+PL2trenduzfOzs7c12UECyHEiyUBikhXy5Yt091hOsc6d9b989NPP9WbVsoN9vb2REdHoygKCQkJzJ07l4YNG1K3bl2Dtg0aqImykydnft0ePXrw119/Aehqm6QEfpUqVeJMetMwmXB1dTXYJDG1li3hYEwVov47rn/iv/9IqN+UgQPVFJQNGyBgZymWOAxn0Lta0isOfP/+fZwjI2napw87d+7UHQ8PD8fW1hb7hg11JfdbtNCfMhNCiBdJAhSRLjs7O6Kjo7Oc9Jldz+u6jRo1YtWqVcybN4/+/fvrVZ1NrWlTNc80KwX1LCwsqFmzJgcPHmTLli20atVKd65GjRpZ3hU6rVatWhlskpiaRgPDhir8tNBO/8SBA3y7vz7vvgsNG6oVjbGzw/OtVgS2W8KHHxpf/HNs+3Zi7Frz1Vca9u514uefHxAUBKtXr6Fz587q+vjkZEhOxtbWlrg4w+XWQgjxIkiAIjJUuHDhdL/gTVXZsmWxtrbm/fff19VYMUajUcuIZFWNGjUIDg7m5s2bFC1aNNV1NLoRG6tsFsDRaDTUrFmTI0eOpNum0yB3zobYsXLGkymZ5GQuRxTi8HErDGa83noL13+X8dfCRyl7F+oJ37ePBRGDad0aunfvyPnz6/nppxP89lsVvv7aTK0NU6mSLjHXxcUl3WXSQgjxPEmAIjLUoUMHvTol+UWHDh2eywhNz549adSokcHxkiVLsnnz5nTL2WckZQQmvXwUjZmGRUFVWfntVf7+9T7K8ROMDh3NzJn6tV0AdSjlww9x/PVbXFwgLEz/9KOTV3Eo4UidOtCunRW1akHduvvZv78ODRqoq5MiqzbWbTok0zxCiLwiAYrIkEajyXS1yavEwcGBCqlL0j7RoEEDFi5cmKMABaB169a6Zd3GWLo5s3hHCf76/CTvDYa6DSwMqtbqtGsHx47RsX4EqfKFATh50Za2PZ7Wr+ncuTNdu3bF3ByaNVPzcUZvaK4LUGxsbIjXbeEshBAvjkVed0CIl4GFhQXt27fP9hRPilKlSrFkyRLu3r2LmZkZGo0GrVZrEBy2G3iOf745RbFBHVmxIki3gkij0VC2bFnKly+Pvb09lhMn0nb2lwyMmsXAgepzI2/e5HRcNSa0f3pNBwcHvYJ7jRrBmjW2rNtRmk5PjqXUa0lbUE8IIZ4njZKTrWzzWFRUFI6OjkRGRmarmqkQpiw5OTlrS8JDQ8HdXe+QoihcvnyZS5cu8ejRI5KSkng8Ywbriuxjxd82FCgA26bNYMpvDdl+qV6Gl4+Lgw6lT/PH9iIU9nElPj6e1atXG63lIoQQ2ZGd728ZQRHCRGS5Xk2a4ATUqbhy5crp7Zi84epVam/5H9u2vUmnTrBzwwWateyd6eVtbOCbt87x4VAHluwAa2vrTHe3FkKI3CY5KEK8pNp+9BE2t+ey9m+1bsvxCwXo9E7RTJ6lqtnbi5jbD4mOVh9Xr16df/7553l1VQghDEiAIsRLytzCAo+W1bi6/yra2Hiux7pR1S+Lg6YVK1Lf7IBux2dfX18KFSr04lb0bN+uboSYxf2FhBAvHwlQhHiJdfzySxwjfmTJ5GDci9gYLktOj7k5jcveYteqCN2hevXqYWZmxt69e7N0iRwVeTtxQq02vHkz/P47PKneK14tWi2cOweLFsGoURARkflzxMtHAhQhXmL2zs74Vo1nzLeh9Ozmm63nVvvyNY5vuKl3rFmzZty/f99gHx9jRr7zDolZWKIcGhqq/uPAARg/HubNg2nToFgxNd8mo82FHjyAunXh5s302wiTFxUFW7aoy9y7doVOneCXX8DODurUgW+/zeseirwgAYoQL7m3v/uAhKQl9PrIsMBcRiyqV8YyKZa4K7f1jnfs2JH9KXM/6bh97RqeGzZwNYMpoZiYGObPn69uSHj8OEyYAIGB+knA/fpBersqx8XBm2+qOz2m2W1amC6tFs6ehYUL4d13oX17GDQIgoOhVStYsULdW2rWLOjZE15/XT0XHp7XPRcvmqziEeIlV7KyL7/O70jBwrbZfm4d/6Ic/HQtTVYM1h0zMzNDq9Vm+Lytn3/OMB8f9uzfj1f79gbnjx88SFBwMP369cPmyhUYMwb+/BPSLjts2BAmTVK/1VJXBk5OhrfeghEjoF496N8fBg9GmJ6HD+HQIXVjzmPHIDERvL3Vj23CBPD0zPwaH3+sDqp9991z7+5LKSfbcJgCCVCEeAX0erd/jp7XuG9Jtg2wo8mDB1CokO64ubl5unVb4u/exeL4cQp99x1RRpJcE8+f58hrr/FOjRqwZo0aeCxfDs7Ohh3QaNTqcf/9p+7uCKAoamDSvj20bq0e02rh8WN1TkDkmZTRkQMH1IDk9m1wdFSnadq0UQMNa+vsX7dBA5g5E27dUmf+RPZMnTqVQYMG4W6kRIEpkykeIUS6ataEI86tYc4cveM1atTg2LFjRp/zz/vv0/6LL9Q/k+/cMTh/YcsWar31FqxdS+yf6/iq1hoeFXBLvxOpp3m0Wnj/fahQAfr2fdqmZUvYujXbr088mwcPYNMmmDhRzW3u1ElNbHVyUge+/vlHnbIZOVJNFcpJcJLi00/h669zqeOvEEVRKFSoEEFBQXndlWyTAEUIkS4rK1CKFCFx+274+284ehQiIvD28uLcuXMG7ZXQUB6eP49T9+7q2L2R5RdnDxygQpMmJCWpMzMFCqiJkdevP20TGqrGH//+C5QuDXfvQmQkvPMO+PmpQUpqnTrBunU5eo1r1qgpMCJjWi2cOgW//goDB6oDWMOGwfnz6r//+kvNHfn2W3jttdwf6fDzg/v3IQv52a+smBjDY0ePHqV58+ZERka++A49I5niEUJkyM9PQ1Cl36j7cDOsXk3iiTMoDRqCR2GDtgeHD6fu+PHq1IxGg8bIThoJISFY+lbh3ffUJMju3aFbN/VLb+JENQbauFENXrZsUacG6NZNHef/7DM1azKtkiUhJMQwVyULVq4EX1+oVi1bT3vpPXjwdKrmxAk17cfHR80d+fJL8PB48X366isYOlQNKp9lNCY7YmPVRWLly7+Y++XUkSNq/O7urs6Kdu2qfl6nT5+mX79+nDhxIq+7mG0SoAghMtSkCew66EndcW8TGQndX1OoN3cZlb7S6Cff3bjB6evXGfhkz54DB6CApS2Rd+/imGqjQSXqER/NcKVOHTU4AShVSh2gGTFCzYtN2YV56dInT+rVS50yql8//Y7WrKn+X7p2bePnFUU9v2IFHD4MPXrA8OHcuKEhMTHn78/LIDkZzpxRg5H9+9WZOScndVqmUyc1LjSFHMty5dQA5cMP4eefX8w9V65U81+CgrId+75QU77U8s+MsxRpVondu2H2bLh+XaF8eXWxG6DbWDS/MOG3WwhhCurUgYMH1WWe3bvDV1M07LNqSs17Dzlw4ICu3b5Ro6g9Zgyg/s+xVy9IKNyM87t2Pb2YonAzzoVH0RoGDdK/j4ODmr8wcKD6RWBmBhYWkJCAOg+UUXACGU/zJCWpa1hXroQBA9SkW0UhsusA3J3jyYej388kIkLND/n8c/D3V/NHli4FV1c1z+Off9Q6eR98ALVqmUZwksLfX83XflFFhjdsUEfxVq16MffLid2/h1D2xN94rJiJRZ9eNCt1lZ9/hg8+OIhFrA+tfEKwinHi6tWred3VbJERFCFEhmxtIT4eeveGH3+ESpWgXf8inFlyl0iXGwAk37zJmatXebtHL8aOVeOJ+fMh+JeWKEc2UfvJUMnDy5e5SSXats3avatWhZMn1cGRTNWura5bNWbzZmjbVl3OnGLECIKsL+D37SKOlHudyEgnHB2z1q/8JDlZzR1Jma4JD1cXTNWpowYmX3wBlpZ53cvsmTRJDZYrV4YaNZ7ffeLj4dEjNZDr3FmdNjGpURRFQfltAd98VoWAf+tCte5qUtCHH0Lx4oTt3s2MypU53bsT337jgLnLccqUKZPXvc4yCVCEEJlKWThTurT6uN+71gwJ6EaXS38D8PeQIXT5agoDB6qpIu+8o9a/WDzNG4/QRbrrBG/axB3LdtStm7X71q2rfrFmKUAxM1MTc2/cgBIl9M/9/jtMn27wlMORXtT7rgjaD//k2O43aNqxYNY6ZsLu3XsajJw8qc5s+fqq7+W0aVA0a/tFmjRzc/jtN+jTR81Xel6zFtu3Q/Pm6ur19u3hf/9T86YylZysFhJ83svet21jy5oYarxbk8LVnkRO3t7w999oDx9GU6UKvPMOlYC45YcJ+e+wms+VT0iAIoTIVLt2+o9dXcG6YlliNx7iZtcTKLdv88fVdlStqgYnoOYwPFQc9ZYahxw/ziOL7mS1HEPt2mrKSNpFO+l64w116Oarr54ei4xU/ww2ktUZFATDhjmRMLIxRz9bSdP2fU3sT+SMJSWpoyMpuSN370Lhwmow0q2bmnT8QkdHFEWtxJbyk5DwbI8TE9Xo4+23DeaZXFzUZND169XZvedhzRoYO1b99+DB6n1ee00NkNJ17Zq6vMnZOVUSVTZFR8OlS5lmbitnzzEztDd/LEvzO6vRsDc+ngbNm+sOffRLOT7qsYIR32U/kTyvSIAihMiRt4fbsfn9Lnzx2muM/Hgxv69XE11Tcy1uw8OTj3WPH1+/h5N7gSzfo3BhdWlpljVvrtZIv3tXjaJAzTtJycZNIzoaChaEGm9UIGCJGcyYAePGZeOGuUhR1Igjgy/uu3e0HDhmzf7jtpy8aAuKlsoloqhX/h4zGofjZhf9tP2hRNibw+AgpzQaNXHIykqNjFJ+0j42diz1Yzu7p4937VITQJ4kX6f2wQdqwNCxY85GUVI+f2O0Wrh6FcqWVR8XKKDmv/z5pzrdadTvv6tByc8/q/tK3b6dveVOMTEwd646LASZ1vbZu1tLnbpmODkZnrt8+TKNGj3d3qJ680JE2RcnZOYKio/tk/U+5SEJUIQQOdKsGXxt15NfWcJ7f9Rn8WLDP8zq1DPjyl43tFotZmZmXL5uTp33sjfs7eKiTlsUNlzVDKjf67ovJ40GPvpInc6ZMUM9tmqVOgyTRljY0+kOZ2eIKFxeXcoyYwbY2+f8r/7US6tT/p3SwbSP00r15Z5kbk3wo1Lsv+/FgfDS3I1zwLVgPHVL3KBH6TAmd3mAhU2aYECxVL9JHR2zHgwYe2xKKz0aNFDncowEKPb2ao2+VauyN3ORkKDGD//9pw7ODB5s+JKPHDGcWhw0CDp0UONdvZGphAR4/30iC5Vi57vr2fa9OfXKf0HvX35RE2Yyc/kyLFsGu3fDe++pOVP+/ml+uQ2dvWiBX08Hg+O3bt3Czc2w+OHQLxry6ad7WTIokvyQcCUBihAiR8zMoFV3J976Zzcjh2qM/qFYpw4cSKzMzWvX8CxViotRRenaMKPxcUN166qriDp0MH6+d2/1D1YXlycHGjdWN20JDVUDBmdno38mHz6srlBJUbCghkfT52J/YIsaKOTki93SMsfD5+HhT3NHgoPV76XKldW6Iz3qPh0Qguo5un6+5eCg5hadOQMVKxqcHjZMTWDt0iVrb/2lS+pS5aFD1Vj0m2/UacnZs9WE8BSrV6vXTM3WFt5oHsbC34rw3pAnN7t3DwYMYJLDtwRHVKB5STXGGDu2Ir0T96mZtilFWxRFnXcLCVFHiQoUUOfo3N3Vismff/70Rbi7q7/DGYzAXH1UmLrehnN4//77LwMGDDA4/kbfavw0/QTh/u9Q5NN31ZVt6QVAixerieVGAp0XRQIUIUSOvfUWJCVp6NrV+PkqVSDcrDHn9+whOSGBu0nVs10QrW5d9cvCWIDy8KF6bsgQtV6LzvjxTzNCU4pApHH4sPpHaopq1eDExQI07Nw5ex3MgcRENYH1wAH15/59NQCpW1cdKPjySzVGEk8MHgzz5qnLyNJISWD96y+jgyx6rl1Tg4dFi57mUY8frxYE7NRJTV1KSeA+ckQ/lQmA+/cZENiWNrcX8ub5ldi1qg8zZ3J44DyubPbif78/berioiGsSj+K/vXX09/BmTPVgOubb9S9ox4/hjJl9COjFN7e6oqc9AIUrZYrsUV1iespwsLCKFKkCGZGojVLS0v837Dlje0rqDFxPz2//BC/7/ui8UuzFCo5WZ2qSr2dRB7IH5kyQgiT5OamFvFKj6UlmNuVJOz0GU5u3oqNfbVsVwCtUkX9Mjdm/Xr1r+czZ9KcqFNHnf9fv17NSzHi5En12in8/NSk2efhzh01kBo3Ts2XeO01dVqiZEk1Zeaff9Q/WIcMUQMlCU7SqFoVLl5Uv9CNGDJETd0ICcn4Mlu2qCMnaRd5tWql7le5fLk6IvfBB7/i6HjMcERmyxYsxoxk+ILq/JA4BIKCiF+4nPGLvAx2Wvb3h3W2PdWpG4Bt29ShsQ8/VKPRUqXUNfvGghNQl82dP5/+iwkNJdrcyWBwcOPGjbQ3soN4irJlYcsOC16f3Yj/VfuKzm3jSIpNk3e0bRvfWn3Cnbt5GyLIfwZCiOeqgjeEXojmTuhNfL3S+Z9xBiwt1T/ojFWxX7tW3SF34UIjT/z8c9i50+iSi5TFJqkXhtSooX5BPavERLU0/P796uhIRIQayNWrpy4y8vXNZBWIMK53bzWXKGWZWCq2turvQP/+6vLj9Ep97N79NDUpLTc3+OkndQqob19rmjU7icF02r//wtdf07mohl/me3Jv0hf8+KMaIOmmGJ9o2xYGDLDm3cqV1eGd+fPVZUFZze/x9s44SfbKFbDTXw539+5dnJ2djY6epLC0tCQxMYEaNayoUcOO5Y9j+fKNM0xaVfXpy5x6lEvFh+fl7A4gAYoQ4jmr08SGrQtBY5NEC/+crXmtUAHOndNPQXj8WJ3er1ZNf6NBnSpV9IZI4uLAxkb999WrGAyNu7qq6QTZFRb2dJnv6dNq8FG16tOAJO0Xl8ihnj3V4bKBA9WVPT/+qH6of/wB9vaUKaOOQvXvr46meHsbXiI8PPOUijJltAwbZoaiKCQnJ2OeEk1qtRAayj1LSwpr4JNP1ClOe3uYPNnwOvb26lOi+w+jYMu6sG+fmnOSBY8fw/w1ZRiVQeXXqFM3cHApqXdsw4YN9M1kWqZGjRrMmzcP1ydJTSX7FGFr31B276pMoyZm3Dx+j2/PtGftP8+5hksWSIAihHiu6rR34ZcpBcHcjE87F8nRNVIKtqUOUDZtUuuzmJnpL5wxRqsFLy/1O+6LL+DQIeNb9hQooH45pFdfKyFBf3TkwQM1zaVePTXNoFIlGR15bmxs1Kzhpk3VAihz56qrX954Q137a2tL8eJPp2nWrNFfqGKsfp8xR48epUaNGjg4OLBjxw5atmypnjhxgmulSzPts8+YO3cujRpp2LhR3T8qPW3awL/nS/Ha1avpT+UYERAA8341Z1T55HTbXD32kDIVng4Bnj9/Hg8Pj6cBVTrKlSvHBx98oHu8fPlypr51kzeG1+SPbYUZ1DuKnyffz053nxvJQRFCPFclylvzIMGZB7FOFPd1ytE1GjVSv4MSEp4eW7Xq6SqLlKXI6bl1S02ybdtWXY46e7b+Cp4UKaX1U9y+rdZ2GTv26fLSdevUnW1nz1bLVSxapC4/rVJFgpPnbvJkdXOcr75Sh0Lq11eLofTrp6vf4u6uDrKsXq3/1N271d+jzJw9exYfHx88PT25devW0xObNrG1YEHGjBnD3r17AXXfooxGZPz91WnI7HzbJyerv3MVKkCshb26nbIRV87GU7qaGoElJiayfft2WrduneX7pOjWrRvbSjkzteAU/PwUBlgsx2tgFt6oF0ACFCHEc6XRgJt1OTxsyua4vIabm7r6ImUrnfj4p6MXoI5cGCTKpnLunDrk37KlOvIyfLjxKQA/P/j2W/WP8nbt1ATg+/fVaYO1a9WfyZPVc87OOXst4hkUKGC4ZLxVK/UD69NHXaaDOhOUNkD57z91BXpWpOz46+joyMOHDwE4vWkTPh06UK5cOS5dupTh8x88eMCff/6Jh4eaIJ2d2ndr16qrknx94YJzXTU52Igr9x0pU0kNfJYtW8ab6axWy4ytrS2Wjo5UqANbu/9Czy4JJpOlbRq9EEK81BqVNsdSk/RM1+jaVV36uWSJWrQtZeQd1Kmf06fT/wI6f179ixTU//emtxy1WTM1KbdmTXXHXJFPdO2qLon6/HNQFBxGjcLKyk+vwN+NG2qT1BITE7FMVXHt5s2bFCtWTPe4TZs2rF27ll5t27IvOpp3mzYFwNXVlfDwcIoUMT5lefLkSV0Q07gx7Nmj/m5lxW+/qQVp16+HM/erUfX8ef3lZk9cjXGjexnYv38/vr6+2NvbZ+0GRnTp0oXfQ0MZ8MlotS6LiZARFCHEczeowy0GdryTecNMTJ6sTu1Mm4Ze7ZWsjqBkxtZW/YNcgpN8qEYNtXbHV1/Br7/SPWohKwPVoYvwcMNKxIqiMHToUEJDQ3XH9uzZo1ce3tbWltjYWA7/8gu1Um3B3bp1azZv3pxuV27dukW9evW4ceMGnTurq4MmTlRHdho2NBzdSXHwoBpIOzqqQfeZ+LLGlxpHRhKS5E6hQo85f/48tYzNV2aDlZUVjiVKcHfLFsPs8TwkAYoQ4rkr3K89zv06PvN1zM1hwQJ1KqZUqafHS5bUje4bldUESfESKFUK5s2jwzvurJ90BM6eZc8ew/yTY8eO8cEHH7By5UoSniQ3JSUl6Y2oAHh5ebH5r7+olmp5s6WlJcnJyWi12nS70bhxY/777z8qVlRzUVKKye3YoeaYBAQYPufHH58m3Xp7w7mIImp0ndblyyQXKMjmzRvpns4+U9nl7+/P6tOnc+VaueWZApSpU6ei0WgYOXKk7piiKEycOBEPDw9sbW1p2rQpp9O86Pj4eIYPH07hwoWxs7PD39+fmzdvPktXhBCmrFSpXIsQnJ3V4mapZbaSR6uVBNZXTYHX2uHUpCq3P5jG7sBbBtN/p4OD8d2+nbf69mXRokU8fvyYAinLgPfsUSPhS5eoV7cuw+ztDUYWWrRowbZt24zeW1EUzM3NSU5OBhQGDFBXjaXsjBAQoBYF/O47dV/LXbvUURYzs6f/mRQoALHJVmqyVRrai5fRFCjA48ePKZjebofZZG5uTsOGDQkMDMyV6+WGHAcohw8fZv78+VRJMzc2ffp0vvvuO2bPns3hw4cpWrQorVq14tGjR7o2I0eOZNWqVQQGBrJnzx6io6Pp2LHjkw9TCCGyL72VPI8fZ7n8hHjJ9OxfgL+azeHcrjDDKb5jx9D8+y92o0bRsnlzxo0bR9OmTdXiaCkl6b//Hk3btjgZWZNusMrnieTkZF2htBo1anDs2DGDNmZm6mhJUpK6t+WhQ2r8M3u2fjtLS0jQWhhE36HH72BT6LzB9++z8vHxoWbNmixdujRXr5tjSg48evRIKV++vLJlyxalSZMmyogRIxRFURStVqsULVpUmTZtmq5tXFyc4ujoqMybN09RFEV5+PChYmlpqQQGBura3Lp1SzEzM1M2bdqUpftHRkYqgBIZGZmT7gshXkLTpinKrl2Gx48eVZRPP33x/RF5Ly5OURo1UpQe5Y8pysGDuuOXL11SdteurShRUYoSEKAogwcr165eVZRt2xTF319RYmKydP0///xTiUnT9vz588qhQ4d0jwMCAnT/TkxMVBYuXJjl/o8dqygnu32qTBk3Tnn48KHu+H8dv1F6dJyb5etk17Vr15SFCxcqWq0216+dne/vHI2gDBs2jA4dOjwtYPPE1atXCQsL01uLbW1tTZMmTdi3bx8AQUFBJCYm6rXx8PDA19dX1yat+Ph4oqKi9H6EECK19BJlU6/gEa8Wa2u1Zk2DN0qqoyJP7P/1V+q1aaOWe+3fH6pWpeTYsfD992o5/SzWLalfvz779+/XO3b69GkqVaqke2xubk5SUhJRUVHMmTOHIkWKcDWDCrGpVawI80KjGFSnDr///nQnwrPXFYqVe36Z3CVLlqRL2q2c80C2lxkHBgZy9OhRDh8+bHAuLCwMALc0lWvc3Ny4/qQWdVhYGFZWVhRKkybv5uame35aU6dOZdKkSdntqhDiFVKxorpVSlrnzhnfCVm8GiZMADu7QjDOXo1gK1ZEu2kT5tu3P200eDAUL65Wqc3GfGCxYsXYsWOH3rHY2NinuSxA8+bNCQgIIDk5maFDh6LRaFixYgWls7BaJjp6K4pTSwqH3aJNmzZs2LCBDh06sOVuKMO7Ds1yP3Mi7Xd0XsjWCEpISAgjRoxg2bJl2KRsamGEJk01JkVRDI6llVGb8ePHExkZqfsJyWzLSiHEK6dUKeMrec6fz9oSY/HySL3ookSJJ/shjR0LM2Zwd906CpcrZ1hpr0OH9Pc4yICSyT4LHh4elC1blvfeew8LCwvMzc0zXP2T4tKlS7i6xhChaQbnz1OmTBmSkpK4fuECtxNsqFw553VP8otsBShBQUGEh4fj5+eHhYUFFhYW7Nq1ix9//BELCwvdyEnakZDw8HDduaJFi5KQkMCDNJnJqdukZW1tjYODg96PEEKkZmamrtZJ69EjNd9RvDouXryoG7XX8faG2Fh2jhtH0/S2NM4BBwcHIiMjdY+NBSzN0lRp8/T0zHTl6qJFi+jVy59o7NTdLVGXAi+ePRuNTY1XolZPtgKUFi1aEBwczPHjx3U/NWvWpE+fPhw/fpwyZcpQtGhRtmzZontOQkICu3bton79+gD4+flhaWmp1yY0NJRTp07p2gghRE64uKil6VNk4Q9V8RJq3Lgxu3fvNjwxbhxxPj7Y5mIxskaNGrFnzx4AIiMjs/QHdKNGjfjvv//SPR8aGkrz5s0BMDM3Iyk2EaKi0Gg0fNKqFU7ORna6fAllKwfF3t4eX19fvWN2dna4uLjojo8cOZKvv/6a8uXLU758eb7++msKFCjAG2+8Aah7GwwcOJDRo0fj4uKCs7MzY8aMoXLlygZJt0IIkR2VKqmb/aX8wXrrFnh65m2fxIuXUoMkberAveLFcezfP1fv5ezsTEREBACnTp2icuXKmT4npdBbevbs2UOnTp0AKFsWrlQYi9dbb0FyMolaa2ydfsidzpu4XN+L56OPPiI2NpahQ4fy4MED6tSpw+bNm/X2CZg1axYWFhb07NmT2NhYWrRoQUBAQKbbRAshREZ69FC3Y0kJUGQFz6urWrVqnDhxgmrVqumOrVu3jr59+z63e16/fj3LMwFFihThzp07RlMb4uPjdXmeFSvCGddmeK1sBtHRXFt8iFIXXo2dKp+51P3OnTv5/vvvdY81Gg0TJ04kNDSUuLg4du3aZTDqYmNjw08//cT9+/eJiYlh3bp1FC9e/Fm7IoR4xZUpo64QTdnvLKt78IiXT5UqVThx4oTu8b179yhUqBAWz2Gn3iJFihAeHg4YLhJJT9OmTQ1WAAFotVq9a1SsmGr5fMGCXCnVnDIVrJ65z/mB7MUjhHipjB8PU6eq/5YVPK8ujUaTqty8OnrSseOz7wdlTMOGDdm7d2+mK3pSs7a21u0BlNrx48epXr267rGPj359n7Nn1UD8VSABihDipVK2LNjYwOnTcP26upGgeDU1adKEXbt2cffu3ec2egJqLmZ0dHSWR09SFC1alBs3bugdO3PmDD4+PrrHzs7qFg5r1kCXLuqoYL16udFr0ycBihDipZMyiiKbBL7aihcvzs2bN1m3bp0u6fR5uXfvXpaKr6XWqlUrNm3aZHA8baBTuTJcvgwLF8Jvv706y+afTzgphBB5qFw5dedY2SRQ2NjYYG1t/dwXYfj7++Pu7p6t52g0GmrUqEFQUBB+fn48evTI6O7EuVi2JV+RAEUI8VL67DM4ejSveyHy2muvvabbXfh5Klu2bI6eV7NmTebPn0+NGjXYvXs3jRo1yuWe5V8SoAghXkplyrw6yYQiffmhfEXbtm3ZtGkTERERuLi45HV3TIbkoAghhBB5qESJEoSFhWVYvO1VJCMoQgghRB7r3r079+7dy+tumBQJUIQQQog8Zm9vr1dxXcgUjxBCCCFMkAQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMTrYClLlz51KlShUcHBxwcHCgXr16bNy4UXc+Ojqa999/H09PT2xtbfHx8WHu3Ll614iPj2f48OEULlwYOzs7/P39uXnzZu68GiGEEEK8FLIVoHh6ejJt2jSOHDnCkSNHaN68OZ07d+b06dMAjBo1ik2bNrFs2TLOnj3LqFGjGD58OGvWrNFdY+TIkaxatYrAwED27NlDdHQ0HTt2JDk5OXdfmRBCCCHyLY2iKMqzXMDZ2ZkZM2YwcOBAfH196dWrF59//rnuvJ+fH+3bt+fLL78kMjISV1dXli5dSq9evQC4ffs2xYsX559//qFNmzZZumdUVBSOjo5ERkbi4ODwLN0XQgghxAuSne/vHOegJCcnExgYyOPHj6lXrx4ADRs2ZO3atdy6dQtFUdixYwcXLlzQBR5BQUEkJibSunVr3XU8PDzw9fVl37596d4rPj6eqKgovR8hhBBCvLwssvuE4OBg6tWrR1xcHAULFmTVqlVUrFgRgB9//JF3330XT09PLCwsMDMz47fffqNhw4YAhIWFYWVlRaFChfSu6ebmRlhYWLr3nDp1KpMmTcpuV4UQQgiRT2V7BMXb25vjx49z4MABhgwZQv/+/Tlz5gygBigHDhxg7dq1BAUFMXPmTIYOHcrWrVszvKaiKGg0mnTPjx8/nsjISN1PSEhIdrsthBBCiHwk2yMoVlZWlCtXDoCaNWty+PBhfvjhB77//ns++eQTVq1aRYcOHQCoUqUKx48f59tvv6Vly5YULVqUhIQEHjx4oDeKEh4eTv369dO9p7W1NdbW1tntqhBCCCHyqWeug6IoCvHx8SQmJpKYmIiZmf4lzc3N0Wq1gJowa2lpyZYtW3TnQ0NDOXXqVIYBihBCCCFeLdkaQfnkk09o164dxYsX59GjRwQGBrJz5042bdqEg4MDTZo0YezYsdja2lKyZEl27drFkiVL+O677wBwdHRk4MCBjB49GhcXF5ydnRkzZgyVK1emZcuWz+UFCiGEECL/yVaAcufOHfr27UtoaCiOjo5UqVKFTZs20apVKwACAwMZP348ffr0ISIigpIlSzJlyhQGDx6su8asWbOwsLCgZ8+exMbG0qJFCwICAjA3N8/dVyaEEEKIfOuZ66DkBamDIoQQQuQ/L6QOihBCCCHE8yIBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMjgQoQgghhDA5EqAIIYQQwuRIgCKEEEIIkyMBihBCCCFMTrYClLlz51KlShUcHBxwcHCgXr16bNy4Ua/N2bNn8ff3x9HREXt7e+rWrcuNGzd05+Pj4xk+fDiFCxfGzs4Of39/bt68mTuvRgghhBAvhWwFKJ6enkybNo0jR45w5MgRmjdvTufOnTl9+jQAly9fpmHDhlSoUIGdO3dy4sQJPv/8c2xsbHTXGDlyJKtWrSIwMJA9e/YQHR1Nx44dSU5Ozt1XJoQQQoh8S6MoivIsF3B2dmbGjBkMHDiQ119/HUtLS5YuXWq0bWRkJK6urixdupRevXoBcPv2bYoXL84///xDmzZtsnTPqKgoHB0diYyMxMHB4Vm6L4QQQogXJDvf3znOQUlOTiYwMJDHjx9Tr149tFotGzZswMvLizZt2lCkSBHq1KnD6tWrdc8JCgoiMTGR1q1b6455eHjg6+vLvn370r1XfHw8UVFRej9CCCGEeHllO0AJDg6mYMGCWFtbM3jwYFatWkXFihUJDw8nOjqaadOm0bZtWzZv3kzXrl3p1q0bu3btAiAsLAwrKysKFSqkd003NzfCwsLSvefUqVNxdHTU/RQvXjy73RZCCCFEPmKR3Sd4e3tz/PhxHj58yMqVK+nfvz+7du3CyckJgM6dOzNq1CgAqlWrxr59+5g3bx5NmjRJ95qKoqDRaNI9P378eD788EPd46ioKAlShBBCiJdYtkdQrKysKFeuHDVr1mTq1KlUrVqVH374gcKFC2NhYUHFihX12vv4+OhW8RQtWpSEhAQePHig1yY8PBw3N7d072ltba1bOZTyI4QQQoiX1zPXQVEUhfj4eKysrKhVqxbnz5/XO3/hwgVKliwJgJ+fH5aWlmzZskV3PjQ0lFOnTlG/fv1n7YoQQgghXhLZmuL55JNPaNeuHcWLF+fRo0cEBgayc+dONm3aBMDYsWPp1asXjRs3plmzZmzatIl169axc+dOABwdHRk4cCCjR4/GxcUFZ2dnxowZQ+XKlWnZsmWuvzghhBBC5E/ZClDu3LlD3759CQ0NxdHRkSpVqrBp0yZatWoFQNeuXZk3bx5Tp07lgw8+wNvbm5UrV9KwYUPdNWbNmoWFhQU9e/YkNjaWFi1aEBAQgLm5ee6+MiGEEELkW89cByUvSB0UIYQQIv95IXVQhBBCCCGeFwlQhBBCCGFyJEARQgghhMmRAEUIIYQQJkcCFCGEEEKYHAlQhBBCCGFyJEARQgghhMmRAEUIIYQQJkcCFCGEEEKYHAlQhBBCCGFyJEARQgghhMmRAEUIIYQQJkcCFCGEEEKYHAlQhBBCCGFyJEARQgghhMmRAEUIIYQQJkcCFCGEEEKYHAlQhBBCCGFyLPK6AzmhKAoAUVFRedwTIYQQQmRVyvd2yvd4RvJlgPLo0SMAihcvnsc9EUIIIUR2PXr0CEdHxwzbaJSshDEmRqvVcvv2bezt7dFoNHndnRyJioqiePHihISE4ODgkNfdeeXJ52Ea5HMwLfJ5mIaX6XNQFIVHjx7h4eGBmVnGWSb5cgTFzMwMT0/PvO5GrnBwcMj3v3AvE/k8TIN8DqZFPg/T8LJ8DpmNnKSQJFkhhBBCmBwJUIQQQghhciRAySPW1tZMmDABa2vrvO6KQD4PUyGfg2mRz8M0vKqfQ75MkhVCCCHEy01GUIQQQghhciRAEUIIIYTJkQBFCCGEECZHAhQhhBBCmBwJUIQQQghhciRASWXq1KnUqlULe3t7ihQpQpcuXTh//rxeG0VRmDhxIh4eHtja2tK0aVNOnz6t12b+/Pk0bdoUBwcHNBoNDx8+NLjXhQsX6Ny5M4ULF8bBwYEGDRqwY8eOTPsYHBxMkyZNsLW1pVixYkyePFlv06U9e/bQoEEDXFxcsLW1pUKFCsyaNStnb0geexk+j9T27t2LhYUF1apVy/J7YApehs9h586daDQag59z587l7E3JQy/D5wEQHx/Pp59+SsmSJbG2tqZs2bIsXLgw+29IHnkZPocBAwYY/e+iUqVKOXtTcpsidNq0aaMsWrRIOXXqlHL8+HGlQ4cOSokSJZTo6Ghdm2nTpin29vbKypUrleDgYKVXr16Ku7u7EhUVpWsza9YsZerUqcrUqVMVQHnw4IHBvcqVK6e0b99eOXHihHLhwgVl6NChSoECBZTQ0NB0+xcZGam4ubkpr7/+uhIcHKysXLlSsbe3V7799ltdm6NHjyq///67curUKeXq1avK0qVLlQIFCii//PJL7rxJL9DL8HmkePjwoVKmTBmldevWStWqVZ/pfXnRXobPYceOHQqgnD9/XgkNDdX9JCUl5c6b9AK9DJ+HoiiKv7+/UqdOHWXLli3K1atXlYMHDyp79+599jfoBXkZPoeHDx/q/fcQEhKiODs7KxMmTMiV9+hZSYCSgfDwcAVQdu3apSiKomi1WqVo0aLKtGnTdG3i4uIUR0dHZd68eQbPT/mfYtpfuLt37yqA8t9//+mORUVFKYCydevWdPszZ84cxdHRUYmLi9Mdmzp1quLh4aFotdp0n9e1a1flzTffzPT1mrr8/Hn06tVL+eyzz5QJEybkuwAlrfz4OaR3z5dBfvw8Nm7cqDg6Oir379/P0Ws2Rfnxc0hr1apVikajUa5du5al1/y8yRRPBiIjIwFwdnYG4OrVq4SFhdG6dWtdG2tra5o0acK+ffuyfF0XFxd8fHxYsmQJjx8/JikpiV9++QU3Nzf8/PzSfd7+/ftp0qSJXjXBNm3acPv2ba5du2b0OceOHWPfvn00adIky/0zVfn181i0aBGXL19mwoQJWe6TKcuvnwNA9erVcXd3p0WLFlkaIs8P8uPnsXbtWmrWrMn06dMpVqwYXl5ejBkzhtjY2Oy8dJOSHz+HtBYsWEDLli0pWbJklvv3POXL3YxfBEVR+PDDD2nYsCG+vr4AhIWFAeDm5qbX1s3NjevXr2f52hqNhi1bttC5c2fs7e0xMzPDzc2NTZs24eTklO7zwsLCKFWqlMG9U86VLl1ad9zT05O7d++SlJTExIkTeeedd7LcP1OUXz+Pixcv8vHHH7N7924sLPL/f2759XNwd3dn/vz5+Pn5ER8fz9KlS2nRogU7d+6kcePGWe6jqcmvn8eVK1fYs2cPNjY2rFq1inv37jF06FAiIiLyVR5Kivz6OaQWGhrKxo0b+f3337Pct+dNRlDS8f7773Py5ElWrFhhcE6j0eg9VhTF4FhGFEVh6NChFClShN27d3Po0CE6d+5Mx44dCQ0NBaBSpUoULFiQggUL0q5duwzvbez47t27OXLkCPPmzeP77783+jryk/z4eSQnJ/PGG28wadIkvLy8stwfU5YfPwcAb29v3n33XWrUqEG9evWYM2cOHTp04Ntvv81y/0xRfv08tFotGo2G5cuXU7t2bdq3b893331HQEBAvhxFya+fQ2oBAQE4OTnRpUuXLPftecv/f9I9B8OHD2ft2rX8999/eHp66o4XLVoUUKNPd3d33fHw8HCDKDkj27dvZ/369Tx48AAHBwcA5syZw5YtW1i8eDEff/wx//zzD4mJiQDY2trq7p8Slae+NxhG6SnRceXKlblz5w4TJ06kd+/eWe6jKcmvn8ejR484cuQIx44d4/333wfU/zErioKFhQWbN2+mefPm2X078kx+/RzSU7duXZYtW5bl/pma/Px5uLu78/927p+ldSgMA/h7C1ormKAOBlsQsUXEyan+n8QPIC4FnXRQcBIHwaGOOgkiDgr1ExhB0EFBjKtDglHE4Cg6uBSUggX73Mlg9Iq9aDQNzw+ylNP09H2G8xLOSTweF1VV3TEdHR0CQG5ubiSVSpU9z99WyTm8ACC5XE7Gx8elurq67Ln5jU9QXgEgMzMzouu6HB0dvXsE1traKpqmyeHhoftZsVgUwzCkt7e37N8pFAoiIhKJeMsfiUSkVCqJiEhLS4skk0lJJpMSj8dFRKSnp0dOTk6kWCy63zk4OJDm5uZ3j/Le/q+np6ey5xcUlZ6Hoihi27ZYluVeU1NT0t7eLpZlSTqd/r+C/JJKz+Ejpml6Fo5KEYY8+vr65Pb2Vh4fH90xjuNIJBLxLPJBFoYcXhiGIdfX1zIxMVH2vH7Ej2zFrRDT09NQVRXHx8eeo1eFQsEds7S0BFVVoes6bNtGJpN5d2zs7u4Opmlic3PT3X1tmqa7Y/3+/h6NjY0YGRmBZVm4urrC3NwcqqqqYFnWh/PL5/NoampCJpOBbdvQdR2KoniOja2trWF3dxeO48BxHORyOSiKgoWFBR8q5q8w5PFWJZ7iCUMOKysr2NnZgeM4OD8/x/z8PEQE29vbPlTMX2HI4+HhAYlEAqOjo7i4uIBhGEilUpicnPShYv4IQw4vxsbGkE6nv7E634MNyisi8s9ra2vLHVMqlZDNZqFpGqLRKAYHB2Hbtuc+2Wz20/ucnp5ieHgYDQ0NqKurQ3d3N/b39z+d49nZGQYGBhCNRqFpGhYXFz1HxlZXV9HZ2Yna2looioKuri6sr6/j+fn5y/X5aWHI461KbFDCkMPy8jLa2tpQU1OD+vp69Pf3Y29v78u1+Q1hyAMALi8vMTQ0hFgshkQigdnZWc/iHnRhySGfzyMWi2FjY+NL9fDDH+CD114SERER/RLuQSEiIqLAYYNCREREgcMGhYiIiAKHDQoREREFDhsUIiIiChw2KERERBQ4bFCIiIgocNigEBERUeCwQSEiIqLAYYNCREREgcMGhYiIiALnL9dclgHlEfUKAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Lindenberg_98\n", + "Skipping Lindenberg_98: Not found in ICON dataset on 2018-04-01 00:00:00\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Lindenberg_98 (Time: 12:00-17:00): 4.444045744708574\n", + "RMSE_postLindenberg_98 (Time: 12:00-17:00): 5.882662880577198\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Lutjewad_60\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Lutjewad_60 (Time: 12:00-17:00): 5.027118560017733\n", + "RMSE_postLutjewad_60 (Time: 12:00-17:00): 4.829454095883846\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Monte Cimone_8\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-01 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-11 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-03-12 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-03-22 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-04-01 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-04-11 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-04-21 00:00:00\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Monte Cimone_8 (Time: 0:00-7:00): 2.959680174567201\n", + "RMSE_postMonte Cimone_8 (Time: 0:00-7:00): 3.3325682482481693\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Observatoire de Haute Provence_100\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Observatoire de Haute Provence_100 (Time: 12:00-17:00): 3.4017750652349736\n", + "RMSE_postObservatoire de Haute Provence_100 (Time: 12:00-17:00): 3.194361223199104\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Observatoire perenne de l'environnement_120\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Observatoire perenne de l'environnement_120 (Time: 12:00-17:00): 5.016921877327441\n", + "RMSE_postObservatoire perenne de l'environnement_120 (Time: 12:00-17:00): 5.074751149489404\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Pic du Midi_28\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Pic du Midi_28 (Time: 0:00-7:00): 2.0063922680970365\n", + "RMSE_postPic du Midi_28 (Time: 0:00-7:00): 2.095163772129502\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Plateau Rosa_10\n", + "Skipping Plateau Rosa_10: Not found in ICON dataset on 2018-04-21 00:00:00\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Plateau Rosa_10 (Time: 0:00-7:00): 1.9134055189671928\n", + "RMSE_postPlateau Rosa_10 (Time: 0:00-7:00): 1.8114063928000324\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Puy de Dome_10\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Puy de Dome_10 (Time: 0:00-7:00): 4.1369019254444925\n", + "RMSE_postPuy de Dome_10 (Time: 0:00-7:00): 4.621298610563304\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Ridge Hill_90\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Ridge Hill_90 (Time: 12:00-17:00): 4.47760216030187\n", + "RMSE_postRidge Hill_90 (Time: 12:00-17:00): 3.789236001309949\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Saclay_100\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Saclay_100 (Time: 12:00-17:00): 5.417616123397512\n", + "RMSE_postSaclay_100 (Time: 12:00-17:00): 4.755895997837327\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Schauinsland_12\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Schauinsland_12 (Time: 0:00-7:00): 4.13354979667175\n", + "RMSE_postSchauinsland_12 (Time: 0:00-7:00): 4.138133076924095\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Tacolneston_185\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Tacolneston_185 (Time: 12:00-17:00): 5.104249912485458\n", + "RMSE_postTacolneston_185 (Time: 12:00-17:00): 4.132113046595612\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGxCAYAAABIjE2TAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAApw5JREFUeJzs3XdYFNfXwPHvLixt6b0qFkABK/aGxhZ7YiwxRlPUvGkmGk3/pceYmJhuiomxJJYUo9EYe4tdxIYKgijSpffOzvvHwMLCUkVEcz/Ps48yMztzZyl79t5zz1VIkiQhCIIgCILQgihvdwMEQRAEQRCqEgGKIAiCIAgtjghQBEEQBEFocUSAIgiCIAhCiyMCFEEQBEEQWhwRoAiCIAiC0OKIAEUQBEEQhBZHBCiCIAiCILQ4IkARBEEQBKHFEQGK0OIoFIp6PQ4cONCs7Vq1ahUKhYKoqKhmvW5V8fHxvP3225w9e/a2tqNcbGws8+bNIzAwEGtraxQKBatWrdJ7bGFhIR9//DH+/v6o1WqcnJwYNWoUR48e1TkuKiqqxu/7hg0b6t22d999F19fXzQajXbbmjVrePDBB/Hx8UGpVOLp6an3ufv27ePxxx+nQ4cOqNVq3NzcmDBhAsHBwfW+PsCGDRvo2rUrJiYmuLq6Mm/ePHJycqodl5OTw7x583B1dcXExISuXbs26F4vXrzI008/Td++fVGr1TX+jhw4cKDW36snn3yyXte7evUqEydOxNraGnNzc4YPH87p06cb/RqsWLECNzc3cnNz633Pwl1OEoQW5tixYzqP0aNHS6amptW2Z2ZmNmu7Vq5cKQHStWvXmvW6VQUFBUmAtHLlytvajnL79++X7O3tpWHDhknTpk2rtW0zZsyQlEql9Prrr0t79+6Vfv/9dykgIEAyNDSUTpw4oT3u2rVrEiDNnTu32vc9JSWlXu2Ki4uT1Gq19Pvvv+tsHzZsmOTv7y89/PDDUvv27aXWrVvrff6kSZOkIUOGSN9884104MAB6ffff5f69OkjGRoaSnv37q1XG3755RcJkGbPni3t27dP+u677yQrKytp+PDh1Y4dPny4ZG1tLX333XfSvn37pNmzZ0uAtHbt2npda9WqVZKLi4s0evRoady4cRIg7d+/v9pxmZmZ1V7TY8eOSTNnzpQAaceOHXVeKykpSXJ1dZX8/PykjRs3Stu2bZMGDBggWVhYSGFhYY16DYqLiyUvLy/pzTffrNf9Cnc/EaAILd4jjzwiqdXq290MEaDUoLS0VPv/2tpWUFAgGRgYSA8//LDO9vj4eAmQnnvuOe228gDl448/bnS7XnrpJcnNzU2nfVXbO2bMmBoDlBs3blTblp2dLTk5OUlDhw6t8/olJSWSi4uLNGLECJ3ta9eulQDpn3/+0W7btm2bBEjr1q3TOXb48OGSq6urVFJSUuf1Kt/X77//XmOAoo9Go5Hatm0rtW7dutrrpc+LL74oqVQqKSoqSrstMzNTsre3l6ZMmaLd1pDXQJIk6ZNPPpGsrKyk3NzcerVbuLuJIR7hjrRs2TIGDRqEo6MjarWaTp06sWTJEoqLi6sdu2PHDoYOHYqVlRVmZmZ07NiRxYsX6xyzZcsW+vbti5mZGRYWFgwfPpxjx47V2Y7Bgwfj7+9PUFAQAwcOxMzMjLZt2/Lhhx/qDCsAZGVlsXDhQtq0aYORkRFubm7MmzevWpf277//Tu/evbXtbdu2LY8//jggd8/37NkTgMcee0zbLf/222836F7efvttFAoFFy9eZNq0aVhZWeHk5MTjjz9OZmZmnfddmVJZvz8jSqUSpVKJlZWVznZLS0uUSiUmJiYNum5tioqKWLFiBQ899FC19tW3vY6OjtW2mZub4+vrS0xMTJ3PP378OAkJCTz22GM62ydPnoy5uTmbNm3Sbtu0aRPm5uZMnjxZ59jHHnuM+Ph4Tpw4Uef16ntf+uzfv5+rV6/y2GOP1es8mzZt4p577qF169babZaWlkycOJGtW7dSUlICNOw1AJg+fTpZWVkNGtoS7l4iQBHuSJGRkTz00EP8/PPP/P3338yaNYuPP/6Y//u//9M5bsWKFYwePRqNRsN3333H1q1bee6554iNjdUes27dOiZMmIClpSXr169nxYoVpKenM3jwYA4fPlxnWxITE5k+fToPP/wwW7ZsYdSoUbz66qv88ssv2mPy8vIIDAxk9erVPPfcc2zfvp2XX36ZVatWMX78eKSyRcWPHTvG1KlTadu2LRs2bGDbtm28+eab2j/43bt3Z+XKlQD873//49ixYxw7dozZs2c36l4eeOABvL292bhxI6+88grr1q1j/vz5Dfxu1I9KpeLpp59m9erVbN68maysLKKiopgzZw5WVlbMmTOn2nM+/PBDjIyMMDMzY8CAAWzZsqVe1zpx4gSpqakMGTKkSe8hMzOT06dP4+fnp7O9PD+pcu7NhQsXAOjcubPOsSqVig4dOmj3lx/bsWNHDA0NdY4tf27lY2+FFStWoFQqqwUSIOeEDR48WPt1fn4+kZGR1e4L5Pbm5+dz9epVoGGvAYCzszMdOnRg27ZtN3tLwt3gdnfhCEJd6hriKS0tlYqLi6U1a9ZIBgYGUlpamiRJcne8paWlNGDAAEmj0dT4XFdXV6lTp046XdvZ2dmSo6Oj1K9fP+02fUM8gYGBEqCTPyFJkuTr6yuNHDlS+/XixYslpVIpBQUF6Rz3xx9/6HR1f/LJJxIgZWRk1Hi/NQ2jNORe3nrrLQmQlixZonOOp59+WjIxManx9apLXcNPGo1GevPNNyWlUikBEiC1atVKOnPmjM5x8fHx0pw5c6TffvtNOnTokLR27VqpT58+EiD98MMPdbbjo48+kgApMTGx1uNqG+LRZ/r06ZKhoaF06tQpne2rV6+WDAwMpNWrV2u3LVq0SAKkhISEaucZMWKE5O3trf3ay8tL5+elXPnw1wcffFDvNkpSw4Z40tPTJRMTE73XlyRJMjAwkO655x7t13FxcRIgLV68uNqx69atkwDp6NGjkiQ17DUoN336dMnJyanOdgt3P9GDItyRzpw5w/jx47Gzs8PAwACVSsXMmTMpLS0lPDwcgKNHj5KVlcXTTz+NQqHQe57Lly8THx/PjBkzdLq2zc3NeeCBBzh+/Dh5eXm1tsXZ2ZlevXrpbOvcuTPXr1/Xfv3333/j7+9P165dKSkp0T5GjhypM9uifPhmypQp/Pbbb8TFxdX7NWnMvYwfP75auwsKCkhKSqr3dRti0aJFfPLJJ7z99tvs37+fv/76Cx8fH4YPH86ZM2e0x7m4uLB8+XImT57MgAEDeOihh/j333/p1q0br7zyirZHqSbx8fEoFArs7e2brO1vvPEGa9eu5bPPPiMgIEBn38yZMykpKWHmzJnVnlfTz17V7TUdV3mfRqPR+fkpLS1t6G1Us3btWgoKCrS9cFWVlJSwd+/eGttUW3vrOlbfdkdHR5KSkur8Hgt3PxGgCHec6OhoBg4cSFxcHF988QWHDh0iKCiIZcuWAXIXNEBycjIA7u7uNZ4rNTUVkN8Qq3J1dUWj0ZCenl5re+zs7KptMzY21rYD4MaNG5w/fx6VSqXzsLCwQJIkUlJSABg0aBCbN2/Wvtm5u7vj7+/P+vXra21DY++latuNjY0BdNreVEJDQ3nzzTd55513eOONNxg8eDDjx49n27ZtWFtb88ILL9T6fJVKxdSpU0lNTSUiIqLWY/Pz81GpVBgYGDRJ29955x3ef/99Fi1axLPPPluv55S/tuXfl8rS0tKwtbXVObam4wDtse+++67Oz0+7du0afC9VrVixAgcHByZMmFCv421sbFAoFPVqb0Neg3ImJiZIkkRBQUG970G4OxnWfYggtCybN28mNzeXP//8UydJr2pdEAcHBwCdfJOqyv+AJiQkVNsXHx+PUqnExsbmpttsb2+PqakpP/30U437y02YMIEJEyZQWFjI8ePHWbx4MQ899BCenp707du3xms017001rlz55AkSdtLVE6lUtGlSxcOHjxY5zmkslyduhI57e3tKSoqIjc3F7Va3fhGIwcnb7/9Nm+//TavvfZavZ/XqVMnAEJCQvD19dVuLykpISwsjGnTpukcu379ekpKSnTyUEJCQgDw9/cH4IknnmDs2LHa/eUBZWOdOXOGM2fOsGDBAlQqVb2eY2pqSvv27bVtqywkJARTU1Patm0LNOw1KJeWloaxsTHm5uaNuSXhLiJ6UIQ7Tnm3cOU/zpIk8cMPP+gc169fP6ysrPjuu++0b2xV+fj44Obmxrp163SOyc3NZePGjdrZMDdr7NixREZGYmdnR48ePao99BULMzY2JjAwkI8++ghAOwRSUy9Hc91LY7m6ugLyzI7KCgsLOX36dK09XQDFxcX8+uuv2Nvb0759+1qP7dChAyAnU9+M9957j7fffpv//e9/vPXWWw16bu/evXFxcalWtO6PP/4gJyeHiRMnarfdf//95OTksHHjRp1jV69ejaurK7179wbk17Dyz015ANBYK1asAGDWrFkNet7999/Pvn37dGYzZWdn8+effzJ+/HhtkNWQ16Dc1atXdYIZ4b9L9KAId5zhw4djZGTEtGnTeOmllygoKODbb7+tNnxhbm7O0qVLmT17NsOGDWPOnDk4OTlx5coVzp07x9dff41SqWTJkiVMnz6dsWPH8n//93/aaqcZGRl8+OGHTdLmefPmsXHjRgYNGsT8+fPp3LkzGo2G6Ohodu3axYIFC+jduzdvvvkmsbGxDB06FHd3dzIyMvjiiy9QqVQEBgYC0K5dO0xNTVm7di0dO3bE3NwcV1dXXF1dm+Ve9Pnjjz8AtLM3Tp06pf0EPGnSJAAGDBhAz549efvtt8nLy2PQoEFkZmby1Vdfce3aNX7++Wft+V544QWKi4vp378/zs7OxMTE8NVXX3H27FlWrlxZ59BN+ayT48ePV5tBcunSJS5dugTIM7Dy8vK07ff19dW+OS5dupQ333yTe++9lzFjxlQLrPr06aP9/5o1a3j88cf56aeftHkoBgYGLFmyhBkzZvB///d/TJs2jYiICF566SWGDx/Ovffeq33+qFGjGD58OE899RRZWVm0b9+e9evXs2PHDn755Zd6DVXl5eXxzz//aO8b4ODBg6SkpKBWqxk1apTO8QUFBaxbt45+/frRsWPHGs9raGhIYGCgTh7KwoUL+fnnnxkzZgzvvvsuxsbGfPjhhxQUFOhMeW/IawByjs3JkycbHDAJd6nbl58rCPWjbxbP1q1bpS5dukgmJiaSm5ub9OKLL0rbt2/XO3Phn3/+kQIDAyW1Wi2ZmZlJvr6+0kcffaRzzObNm6XevXtLJiYmklqtloYOHSodOXJE55iaZvH4+fnpbXPV2SE5OTnS//73P8nHx0cyMjKSrKyspE6dOknz58/Xzjb5+++/pVGjRklubm6SkZGR5OjoKI0ePVo6dOiQzrnWr18vdejQQVKpVBIgvfXWWw26l/JZPMnJyXXeY31QNiNH36OyjIwM6fXXX5c6duwomZmZSY6OjtLgwYOrFexasWKF1KtXL8nW1lYyNDSUbGxspJEjR0o7d+6sd5sGDhwojR49utr28nvX96j8OpbP0KrPfZW/bvpmL61bt07q3LmzZGRkJDk7O0vPPfeclJ2dXe247Oxs6bnnnpOcnZ0lIyMjqXPnztL69evrfb/lxe30PfTNVCovlvbTTz/Vel5ACgwMrLb9ypUr0n333SdZWlpKZmZm0tChQ6Xg4GC956jva7B3714JqPE8wn+LQpJq6PsWBEG4g23cuJGpU6dy/fp13NzcbndzhHqYMWMGV69e5ciRI7e7KUILIAIUQRDuSpIk0a9fPwICAvj6669vd3OEOkRGRtKxY0f27dvHgAEDbndzhBZAJMkKgqBX1Zob+h4tmUKh4IcfftBOsRZatujoaL7++msRnAhaogdFEAS9Hn30UVavXl3rMeLPhyAIt4oIUARB0CsqKkpbQK4mPXr0aKbWCILwXyMCFEEQBEEQWhyRgyIIgiAIQotzRxZq02g0xMfHY2FhUeuCVYIgCIIgtBySJJGdnY2rq2udS1bckQFKfHw8Hh4et7sZgiAIgiA0QkxMTJ3LW9yRAYqFhQUg36ClpeVtbo0gCIIgCPWRlZWFh4eH9n28NndkgFI+rGNpaSkCFEEQBEG4w9QnPUMkyQqCIAiC0OKIAEUQBEEQhBZHBCiCIAiCILQ4d2QOiiAIglAzSZIoKSmhtLT0djdF+A9SqVQYGBjc9HlEgCIIgnAXKSoqIiEhgby8vNvdFOE/SqFQ4O7ujrm5+U2dRwQogiAIdwmNRsO1a9cwMDDA1dUVIyMjUcxSaFaSJJGcnExsbCxeXl431ZMiAhRBEIS7RFFRERqNBg8PD8zMzG53c4T/KAcHB6KioiguLr6pAEUkyQqCINxl6iohLgi3UlP12omfYkEQBEEQWhwRoAiCIAiC0OKIAEUQBEEQ6jBjxgw++OCDmz7PgQMHUCgUZGRk3NR5kpKScHBwIC4u7qbb1FKJAEUQBEG4rR599FHuu+8+nW2JiYnMnTuXtm3bYmxsjIeHB+PGjWPv3r06xx09epTRo0djY2ODiYkJnTp1YunSpdVqwCgUCkxMTLh+/brO9vvuu49HH3201vadP3+ebdu2MXfu3EbfY7l+/fqRkJCAlZXVTZ3H0dGRGTNm8NZbb910m1oqEaAIgiAILUpUVBQBAQHs27ePJUuWEBISwo4dOxgyZAjPPPOM9rhNmzYRGBiIu7s7+/fvJywsjOeff55Fixbx4IMPIkmSznkVCgVvvvlmg9vz9ddfM3ny5HqtwFub4uJijIyMcHZ2vqlE0qKiIgAee+wx1q5dS3p6+k21q6USAYogCILQojz99NMoFApOnjzJpEmT8Pb2xs/PjxdeeIHjx48DkJuby5w5cxg/fjzLly+na9eueHp6Mnv2bFavXs0ff/zBb7/9pnPeuXPn8ssvvxASElLvtmg0Gn7//XfGjx+vs93T05P33nuPhx56CHNzc1xdXfnqq690jlEoFHz33XdMmDABtVrN+++/r3eIZ+PGjfj5+WFsbIynpydLly6tdq3333+fRx99FCsrK+bMmQNAp06dcHZ2ZtOmTfW+nzuJCFAEQRCEFiMtLY0dO3bwzDPPoFarq+23trYGYNeuXaSmprJw4cJqx4wbNw5vb2/Wr1+vs71fv36MHTuWV199td7tOX/+PBkZGfTo0aPavo8//pjOnTtz+vRpXn31VebPn8/u3bt1jnnrrbeYMGECISEhPP7449XOERwczJQpU3jwwQcJCQnh7bff5o033mDVqlXVruXv709wcDBvvPGGdnuvXr04dOhQve/nTiIKtQmCINztnnoKmjOZ0s0Nvv22UU+9cuUKkiTRoUOHWo8LDw8HoGPHjnr3d+jQQXtMZYsXL6Zz584cOnSIgQMH1tmeqKgoDAwMcHR0rLavf//+vPLKKwB4e3tz5MgRPvvsM4YPH6495qGHHtIJTK5du6Zzjk8//ZShQ4dqgw5vb28uXbrExx9/rJMbc8899+gNxtzc3Dhz5kyd93EnEgGKIAjC3a6RwcLtUJ43Ut8cjap5JpW36zuHr68vM2fO5OWXX+bo0aN1nj8/Px9jY2O95+rbt2+1rz///HOdbfp6XioLDQ1lwoQJOtv69+/P559/TmlpqbYSa03nMTU1vWvXXRJDPIIgCEKL4eXlhUKhIDQ0tNbjvL29AWo8LiwsDC8vL7373nnnHc6cOcPmzZvrbI+9vT15eXnaxNS6VA1k9A1TVaYvkNIXdNV0nrS0NBwcHOrVtjuNCFAEQRCEFsPW1paRI0eybNkycnNzq+0vTy4dMWIEtra21RJKAbZs2UJERATTpk3Tew0PDw+effZZXnvttWrTkavq2rUrAJcuXaq2rzxht/LXdQ1NVeXr68vhw4d1th09ehRvb+96rWNz4cIFunXr1qBr3iluKkBZvHgxCoWCefPmabfl5OTw7LPP4u7ujqmpKR07duTbKt2LhYWFzJ07F3t7e9RqNePHjyc2NvZmmiIIgiDcJb755htKS0vp1asXGzduJCIigtDQUL788kvtsIpareb777/nr7/+4oknnuD8+fNERUWxYsUKHn30USZNmsSUKVNqvMarr75KfHw8e/bsqbUtDg4OdO/evVoQAXDkyBGWLFlCeHg4y5Yt4/fff+f5559v0L0uWLCAvXv38t577xEeHs7q1av5+uuv9eabVJWXl0dwcDAjRoxo0DXvFI0OUIKCgli+fDmdO3fW2T5//nx27NjBL7/8QmhoKPPnz2fu3Ln89ddf2mPmzZvHpk2b2LBhA4cPHyYnJ4exY8fWGckKgiAId782bdpw+vRphgwZwoIFC/D392f48OHs3btX5wPvpEmT2L9/PzExMQwaNAgfHx8+/fRTXn/9dTZs2FBrHoutrS0vv/wyBQUFdbbniSeeYO3atdW2L1iwgODgYLp168Z7773H0qVLGTlyZIPutXv37vz2229s2LABf39/3nzzTd599906i8cB/PXXX7Rq1apeyb53JKkRsrOzJS8vL2n37t1SYGCg9Pzzz2v3+fn5Se+++67O8d27d5f+97//SZIkSRkZGZJKpZI2bNig3R8XFycplUppx44d9bp+ZmamBEiZmZmNab4gCMJdKT8/X7p06ZKUn59/u5tyV8nPz5datWolHT16VLutdevW0meffXb7GiVJUs+ePaW1a9fe1jboU9vPYUPevxvVg/LMM88wZswYhg0bVm3fgAED2LJlC3FxcUiSxP79+wkPD9dGlcHBwRQXF+t0Sbm6uuLv719jRnVhYSFZWVk6D0EQBEFoDiYmJqxZs4aUlJTb3RStpKQkJk2aVGOezd2gwdOMN2zYwOnTpwkKCtK7/8svv2TOnDm4u7tjaGiIUqnkxx9/ZMCAAYC8voKRkRE2NjY6z3NyciIxMVHvORcvXsw777zT0KYKgiAIQpMIDAy83U3Q4ejoyEsvvXS7m3FLNShAiYmJ4fnnn2fXrl2YmJjoPebLL7/k+PHjbNmyhdatW/Pvv//y9NNP4+LiorfHpZxUw5x1kJOZXnjhBe3XWVlZeHh4NKTpgiAIgtBkoqKibncT7noNClCCg4NJSkoiICBAu620tJR///2Xr7/+mszMTF577TU2bdrEmDFjAOjcuTNnz57lk08+YdiwYTg7O1NUVER6erpOL0pSUhL9+vXTe11jY2OMjY0bc3+CIAiCINyBGpSDMnToUEJCQjh79qz20aNHD6ZPn87Zs2cpLS2luLgYpVL3tAYGBmg0GgACAgJQqVQ66xUkJCRw4cKFGgMUQRAEQRD+WxrUg2JhYYG/v7/ONrVajZ2dnXZ7YGAgL774IqamprRu3ZqDBw+yZs0aPv30UwCsrKyYNWsWCxYswM7ODltbWxYuXEinTp1qHQISBEEQBOG/o8nX4tmwYQOvvvoq06dPJy0tjdatW7No0SKefPJJ7TGfffYZhoaGTJkyhfz8fIYOHcqqVavqVTVPEARBEIS7n0KSalhpqQXLysrCysqKzMxMLC0tb3dzBEEQWoSCggKuXbtGmzZtapzIIAi3Wm0/hw15/xZr8QiCIAiC0OKIAEUQBEEQ6jBjxgw++OCD292MRnv00Ue57777bvo8X3/9NePHj7/5BtWDCFAEQRCE20rfm2diYiJz586lbdu2GBsb4+Hhwbhx49i7d6/OcUePHmX06NHY2NhgYmJCp06dWLp0abW13RQKBSYmJly/fl1n+3333Vfnujfnz59n27ZtzJ07t9H32FCrVq3C2tq6yc73xRdfsGrVqps+z5w5cwgKCtK7eGJTEwGKIAiC0KJERUUREBDAvn37WLJkCSEhIezYsYMhQ4bwzDPPaI/btGkTgYGBuLu7s3//fsLCwnj++edZtGgRDz74IFVTLBUKBW+++WaD2/P1118zefJkLCwsbvremltpaSkajQYrK6ubCngkSaKkpARjY2Meeughvvrqq6ZrZC0XveOIxQIFQRCqu1MXC3zkkUekCRMmaL8eNWqU5ObmJuXk5FQ7Nj09XZIkScrJyZHs7OykiRMnVjtmy5YtEqCzKC0gvfjii5JSqZTOnz+v3T5hwgTpkUceqbFtpaWlkrW1tfT333/rbG/durX07rvvStOmTZPUarXk4uIiffnllzrHXL9+XRo/frykVqslCwsLafLkyVJiYqJ2/9mzZ6XBgwdL5ubmkoWFhdS9e3cpKChI2r9/vwToPN566y1JkiSpsLBQevHFFyVXV1fJzMxM6tWrl7R//37tOVeuXClZWVlJW7dulTp27CgZGBhIV69erfYaFxQUSHPnzpUcHBwkY2NjqX///tLJkye1+8vbsGPHDikgIEBSqVTSvn37JEmSpAMHDkhGRkZSXl6e3tfsti4WKAiCIAi3QlpaGjt27OCZZ55BrVZX21/eC7Br1y5SU1NZuHBhtWPGjRuHt7c369ev19ner18/xo4dy6uvvlrv9pw/f56MjAx69OhRbd/HH39M586dOX36NK+++irz58/XFiGVJIn77ruPtLQ0Dh48yO7du4mMjGTq1Kna50+fPh13d3eCgoIIDg7mlVdeQaVS0a9fPz7//HMsLS1JSEggISFBe5+PPfYYR44cYcOGDZw/f57Jkydz7733EhERoT1vXl4eixcv5scff+TixYs4OjpWa/tLL73Exo0bWb16NadPn6Z9+/aMHDmStLS0asctXryY0NBQOnfuDECPHj0oLi7m5MmT9X4dG6PJ66AIgiAILctTT0FcXPNdz80Nvv22cc+9cuUKkiTRoUOHWo8LDw8HoGPHjnr3d+jQQXtMZYsXL6Zz584cOnSIgQMH1tmeqKgoDAwM9L7J9+/fn1deeQUAb29vjhw5wmeffcbw4cPZs2cP58+f59q1a9q1437++Wf8/PwICgqiZ8+eREdH8+KLL2rv1cvLS3tuKysrFAoFzs7O2m2RkZGsX7+e2NhYXF1dAVi4cCE7duxg5cqV2iTe4uJivvnmG7p06aL3nnJzc/n2229ZtWoVo0aNAuCHH35g9+7drFixghdffFF77Lvvvsvw4cN1nq9Wq7G2tiYqKuqWLqIoAhRBEIS7XGODhdtBKssbqWnx2JqO17dd3zl8fX2ZOXMmL7/8MkePHq3z/Pn5+RgbG+s9V9++fat9/fnnnwMQGhqKh4eHzsK2vr6+WFtbExoaSs+ePXnhhReYPXs2P//8M8OGDWPy5Mm0a9euxracPn0aSZLw9vbW2V5YWIidnZ32ayMjI21vhz6RkZEUFxfTv39/7TaVSkWvXr0IDQ3VOVZfzxGAqakpeXl5NV6jKYghHkEQBKHF8PLyQqFQVHujrKr8Tbqm48LCwnR6JCp75513OHPmDJs3b66zPfb29uTl5VFUVFTnsVARWNUUIFXe/vbbb3Px4kXGjBnDvn378PX1ZdOmTTWeW6PRYGBgQHBwsM6aeKGhoXzxxRfa40xNTWsN8GoKAvW1Wd8wG8hDcQ4ODjVeoymIAEUQBEFoMWxtbRk5ciTLli0jNze32v6MjAwARowYga2tLUuXLq12zJYtW4iIiGDatGl6r+Hh4cGzzz7La6+9Vm06clVdu3YF4NKlS9X2HT9+vNrX5cM1vr6+REdHExMTo91/6dIlMjMzdYalvL29mT9/Prt27WLixImsXLkSkHtBqratW7dulJaWkpSURPv27XUelYeC6tK+fXuMjIx0pgoXFxdz6tSpGofMKouMjKSgoIBu3brV+5qNIQIUQRAEoUX55ptvKC0tpVevXmzcuJGIiAhCQ0P58ssvtcMqarWa77//nr/++osnnniC8+fPExUVxYoVK3j00UeZNGkSU6ZMqfEar776KvHx8ezZs6fWtjg4ONC9e3e9dT+OHDnCkiVLCA8PZ9myZfz+++88//zzAAwbNozOnTszffp0Tp8+zcmTJ5k5cyaBgYH06NGD/Px8nn32WQ4cOMD169c5cuQIQUFB2gDB09OTnJwc9u7dS0pKCnl5eXh7ezN9+nRmzpzJn3/+ybVr1wgKCuKjjz7in3/+qffrq1areeqpp3jxxRfZsWMHly5dYs6cOeTl5TFr1qw6n3/o0CHatm1b63BUUxABiiAIgtCitGnThtOnTzNkyBAWLFiAv78/w4cPZ+/evXxbKaFm0qRJ7N+/n5iYGAYNGoSPjw+ffvopr7/+Ohs2bKh1mMPW1paXX36ZgoKCOtvzxBNPsHbt2mrbFyxYQHBwMN26deO9995j6dKljBw5EpCHTzZv3oyNjQ2DBg1i2LBhtG3bll9//RUAAwMDUlNTmTlzJt7e3kyZMoVRo0bxzjvvAPKMoyeffJKpU6fi4ODAkiVLAFi5ciUzZ85kwYIF+Pj4MH78eE6cOKGT61IfH374IQ888AAzZsyge/fuXLlyhZ07d2JjY1Pnc9evX8+cOXMadL3GEIsFCoIg3CXEYoG3RkFBAT4+PmzYsEHbg+Pp6cm8efOYN2/e7W1cM7tw4QJDhw4lPDwcKysrvceIxQIFQRAEoRmYmJiwZs0aUlJSbndTbrv4+HjWrFlTY3DSlMQ0Y0EQBEGow62s93EnGTFiRLNdSwQogiAIgtBAUVFRt7sJdz0xxCMIgiAIQosjAhRBEARBEFocEaAIgiAIgtDiiABFEARBEIQWRwQogiAIgiC0OCJAEQRBEAShxREBiiAIgiAILY4IUARBEITb7tFHH+W+++7Tfp2YmMjcuXNp27YtxsbGeHh4MG7cOPbu3avzvKNHjzJ69GhsbGwwMTGhU6dOLF26tNpKwPv372fIkCHY2tpiZmaGl5cXjzzyCCUlJc1xe0IjiABFEARBaFGioqIICAhg3759LFmyhJCQEHbs2MGQIUN45plntMdt2rSJwMBA3N3d2b9/P2FhYTz//PMsWrSIBx98kPKl5i5evMioUaPo2bMn//77LyEhIXz11VeoVCo0Gs3tuk2hDqKSrCAIgtCiPP300ygUCk6ePIlardZu9/Pz4/HHHwcgNzeXOXPmMH78eJYvX649Zvbs2Tg5OTF+/Hh+++03pk6dyu7du3FxcdGuCAzQrl077r333ua7KaHBRIAiCIJwFysoKODKlSvNes327ds3ejXltLQ0duzYwaJFi3SCk3LW1tYA7Nq1i9TUVBYuXFjtmHHjxuHt7c369euZOnUqzs7OJCQk8O+//zJo0KBGtUtofmKIRxAEQWgxrly5giRJdOjQodbjwsPDAejYsaPe/R06dNAeM3nyZKZNm0ZgYCAuLi7cf//9fP3112RlZTVt44UmJXpQBEEQ7mImJib4+/vf7mbUW3neiEKhaNDx+raXn8PAwICVK1fy/vvvs2/fPo4fP86iRYv46KOPOHnyJC4uLk3TeKFJiR4UQRAEocXw8vJCoVAQGhpa63He3t4ANR4XFhaGl5eXzjY3NzdmzJjBsmXLuHTpEgUFBXz33XdN03ChyYkARRAEQWgxbG1tGTlyJMuWLSM3N7fa/oyMDABGjBiBra0tS5curXbMli1biIiIYNq0aTVex8bGBhcXF73XEFoGEaAIgiAILco333xDaWkpvXr1YuPGjURERBAaGsqXX35J3759AVCr1Xz//ff89ddfPPHEE5w/f56oqChWrFjBo48+yqRJk5gyZQoA33//PU899RS7du0iMjKSixcv8vLLL3Px4kXGjRt3O29VqIXIQREEQRBalDZt2nD69GkWLVrEggULSEhIwMHBgYCAAL799lvtcZMmTWL//v188MEHDBo0iPz8fNq3b8/rr7/OvHnztDkovXr14vDhwzz55JPEx8djbm6On58fmzdvJjAw8HbdplAHhVRThlELlpWVhZWVFZmZmVhaWt7u5giCILQIBQUFXLt2jTZt2jR6mq8g3Kzafg4b8v4thngEQRAEQWhxRIAiCIIgCEKLIwIUQRAEQRBaHBGgCIIgCILQ4ogARRAE4S5zB859EO4iTfXzJwIUQRCEu4RKpQIgLy/vNrdE+C8rKioC5CUGboaogyIIgnCXMDAwwNramqSkJADMzMzqvaaNIDQFjUZDcnIyZmZmGBreXIghAhRBEIS7iLOzM4A2SBGE5qZUKmnVqtVNB8c3FaAsXryY1157jeeff57PP/9cuz00NJSXX36ZgwcPotFo8PPz47fffqNVq1YAFBYWsnDhQtavX09+fj5Dhw7lm2++wd3d/aZuRhAE4b9OoVDg4uKCo6MjxcXFt7s5wn+QkZERSuXNZ5A0OkAJCgpi+fLldO7cWWd7ZGQkAwYMYNasWbzzzjtYWVkRGhqqU01u3rx5bN26lQ0bNmBnZ8eCBQsYO3YswcHBNz1mJQiCIMjDPeLvqXAna1Sp+5ycHLp3784333zD+++/T9euXbU9KA8++CAqlYqff/5Z73MzMzNxcHDg559/ZurUqQDEx8fj4eHBP//8w8iRI+u8vih1LwiCIAh3nlte6v6ZZ55hzJgxDBs2TGe7RqNh27ZteHt7M3LkSBwdHenduzebN2/WHhMcHExxcTEjRozQbnN1dcXf35+jR4/qvV5hYSFZWVk6D0EQBEEQ7l4NDlA2bNjA6dOnWbx4cbV9SUlJ5OTk8OGHH3Lvvfeya9cu7r//fiZOnMjBgwcBSExMxMjICBsbG53nOjk5kZiYqPeaixcvxsrKSvvw8PBoaLMFQRAEQbiDNCgHJSYmhueff55du3bpXSlTo9EAMGHCBObPnw9A165dOXr0KN99912ty1pLklRjxu+rr77KCy+8oP06KytLBCmCIAiCcBdrUA9KcHAwSUlJBAQEYGhoiKGhIQcPHuTLL7/E0NAQOzs7DA0N8fX11Xlex44diY6OBuQpcEVFRaSnp+sck5SUhJOTk97rGhsbY2lpqfMQBEEQBOHu1aAAZejQoYSEhHD27Fnto0ePHkyfPp2zZ89ibGxMz549uXz5ss7zwsPDad26NQABAQGoVCp2796t3Z+QkMCFCxfo169fE9ySIAiCIAh3ugYN8VhYWODv76+zTa1WY2dnp93+4osvMnXqVAYNGsSQIUPYsWMHW7du5cCBAwBYWVkxa9YsFixYgJ2dHba2tixcuJBOnTpVS7oVBEEQBOG/qckryd5///189913LF68mOeeew4fHx82btzIgAEDtMd89tlnGBoaMmXKFG2htlWrVok5+4IgCIIgAI2sg3K7iToogiAIgnDnueV1UARBEARBEG4lEaAIgiAIgtDiiABFEARBEIQWRwQogiAIgiC0OCJAEQRBEAShxREBiiAIgiAILY4IUARBEARBaHFEgCIIgiAIQosjAhRBEARBEFocEaAIgiAIgtDiiABFEARBEIQWRwQogiAIgiC0OCJAEQRBEAShxREBiiAIgiAILY4IUARBEARBaHFEgCIIgiAIQosjAhRBEARBEFocEaAIgiAIgtDiiABFEARBEIQWRwQogiAIgiC0OCJAEQRBEAShxREBiiAIgiAILY4IUARBEARBaHFEgCIIgiAIQosjAhRBEARBEFocEaAIgiAIgtDiiABFEARBEIQWRwQogiAIgiC0OCJAEQRBEAShxREBiiAIgiAILY4IUARBEARBaHFEgCIIgiAIQosjAhRBEARBEFocEaAIgiAIgtDiiABFEARBEIQWRwQogiAIgiC0OCJAEQRBEAShxREBiiAIgiAILY4IUARBEARBaHFEgCIIgiAIQosjAhRBEARBEFocEaAIgiAIgtDi3FSAsnjxYhQKBfPmzdO7///+7/9QKBR8/vnnOtsLCwuZO3cu9vb2qNVqxo8fT2xs7M00RRAEQRCEu0ijA5SgoCCWL19O586d9e7fvHkzJ06cwNXVtdq+efPmsWnTJjZs2MDhw4fJyclh7NixlJaWNrY5giAIgiDcRRoVoOTk5DB9+nR++OEHbGxsqu2Pi4vj2WefZe3atahUKp19mZmZrFixgqVLlzJs2DC6devGL7/8QkhICHv27GncXQiCIAiCcFdpVIDyzDPPMGbMGIYNG1Ztn0ajYcaMGbz44ov4+flV2x8cHExxcTEjRozQbnN1dcXf35+jR4/qvV5hYSFZWVk6D0EQBEEQ7l6GDX3Chg0bOH36NEFBQXr3f/TRRxgaGvLcc8/p3Z+YmIiRkVG1nhcnJycSExP1Pmfx4sW88847DW2qIAiCIAh3qAb1oMTExPD888/zyy+/YGJiUm1/cHAwX3zxBatWrUKhUDSoIZIk1ficV199lczMTO0jJiamQecWBEEQBOHO0qAAJTg4mKSkJAICAjA0NMTQ0JCDBw/y5ZdfYmhoyIEDB0hKSqJVq1ba/devX2fBggV4enoC4OzsTFFREenp6TrnTkpKwsnJSe91jY2NsbS01HkIgiAIgnD3atAQz9ChQwkJCdHZ9thjj9GhQwdefvllXFxcGDlypM7+kSNHMmPGDB577DEAAgICUKlU7N69mylTpgCQkJDAhQsXWLJkyc3ciyAIgiAId4kGBSgWFhb4+/vrbFOr1djZ2Wm329nZ6exXqVQ4Ozvj4+MDgJWVFbNmzWLBggXY2dlha2vLwoUL6dSpk96kW0EQ6kGSoIHDqoIgCC1Zg5Nkm8Jnn32GoaEhU6ZMIT8/n6FDh7Jq1SoMDAxuR3ME4c526hRs3w5vvHG7WyIIgtBkFJIkSbe7EQ2VlZWFlZUVmZmZIh9FaHGCg4MJCAhovguuXw8bNsBffzXfNQVBEBqhIe/fYi0eQWhi+/bta94LxsTApUvNe01BEIRbTAQogtDEoqOjm/eCMTFgZQV5ec17XUEQhFtIBCiC0MTi4uJo1pHTuDgYOhTCwprvmoIgCLeYCFAEoYkZGhpSUFDQfBcsLoZu3eDixea7piAIwi0mAhRBaGIWFhZkZ2c370X9/ESAIgjCXUUEKILQxJo1QCksBCMj8PaG8PDmuaYgCEIzEAGKIDSxZg1QYmPB3R2MjaGoqHmuKQiC0AxEgCIITaigoABHR8fmDVA8POT/m5lBbm7zXFcQBOEWEwGKIDSh9PR0PDw8yMrKap4LxsRUBCgdO0JoaPNcVxAE4RYTAcotdOzYMXJycm53M4RmlJGRgYeHR/N932Ni5CEeAH9/kSgrCMJdQwQot9ClS5dISkrS3bhy5e1pjNAs0tPTsbe3R6PRNM8FK/eg+PnBhQvNc11BEIRbTAQot1BaWhopKSm6Gz/9tHrFz9jY5muUcEulp6djbW3dfBdMSABXV/n/Xl4QEdF81xYEQbiFRIByC5mbm5OamlqxQZLg+nWovK2oCO6/v/kbJ9wS2dnZWFhYNP2JT5yAf/+tvr2khHMXDVm6FFCpoLS06a8tCIJwG4gA5RaysrIiIyOjYkNmJmRnQ+VeldRUuUT5nbeotKCHJEkolcqmL3V/9CgcOKB316lT8MsvZV8oFE17XUEQhNtEBCi3kKLqm0V0NJib6/agJCdDTo68noog1CQ6GiIjdbfl5YGpKWFhchmUu/pHKD4egoL077t6Fd55p3nbIwjCLScClOZ0/Tq/uL2k24OSkgKtWonpoXcRSdITnOo7qCGF1WJi4MYN3W1lRdquXIG5c2H7dkCpvDuHeY4fh7//1r/v1CnYubN52yMIwi0nApTmFB3NJ6mPU5iYXrEtORkGDhQr0d4qV67AkiXNesnHHqtH7LF7N7z0Uv1PWlgo55hUVlakrbgYxoyBXbsAtbp6EvbdIDlZfugTEiL3sNyNgZkg/IeJAOUWkSSpeh5CdDSxBXZkxFVU+5SSUxh9tpsIUG6R0pgY/tq3r1mvefZsze+lWgcOyL0CDaFWy8OB5WJiKHBshbExWFtDfj4UmlrrHnO3qC1AuXQJRo8WM5gE4S4jApRbJDc3F3Nzc51t+ZHxpOaYkJ5QoN2WHZdFcLytnGMgNLnshASiqtaiucXi46HOS54/Dy4u9StNX1AgJ5m0a6ebhxITQ4TUHi8v+cuBA+FQZmc5Eftuk5xc84taUAB9+8KZM83bJkEQbikRoNwiycnJODg46GyLSzVBoZBITyrWbkuPyyMl05bUgpLmbuJ/QvaNG6Q34xt2SYnck5GcXMssnrw8eQXiPn3k/Im6lC8IWDVAuXqVsPzWdOwofzl6NPwT2/nu7EFJStI/Qyk7W04879ZNBCiCcJcRAcotUh6gVB7miS2wp21byMis+EOblliERtOHf3KM5WnIQpPKSkqiMD+/2a6XmQk9A0prH+I5cUIOTvr1k6cP1yUmRk6krhqgJCYSlmhNhw7yl35+EJbhdFcGKCVZWWQaG1ffceGCXOK/QwcxTCoIdxkRoNwilXtQJEmC4mJii53w91eQXlwx9JOebYi7uxNhKmfxB/YWyE5JwaK4uO4Dm0h6OvSN/o3k2MKaD/r3Xxg0CHr00J06e/So/l6A6OjqAUpqKtjaEhoKPj7yJoUCDI2Ud+UQT3R+Pv9mZFRPhA0Jgc6dwdBQ3ifqCQnCXUMEKLdIVlYWlpaWqNVq8vLyIDaWWKO2dOoEGSVq7XFpReYEBECSyk1MNb4FstLSsGym4mWlpaVkZChpl3OO4pRsSkpqGLYLDoaAADA1lfMnJAk0GnjrLXj7bVi/Xvf46Gh5vR1X14piJ8eOQd++ZGbKCbJaBoZ3ZQ9KUlERGcbGkJamu+P8eejUSf6/u/tdXgxGEP5bRIByCykUCuzt7eVy99HRxCo88PeH9KJKPSjFcoCSLNmjEQFKk8tOT8eiSrLyrZKVlUVBnjmunkYYZpfqX9G4qEju6iifMuztDeHhsHUrDB8OGzfKvSpfflnxnPIhHmWlX9ejR9H07a+zCUBlrKQo4y6bZixJJBcVUaRWV5/JExUFnp7y/7t2FXkognAXEQHKLWZnZycvGBgdTXyxA76+kK6x0n5yLg9QCgwCuHz69O1u7l0nLyuPbGO3ZqmRkZ6eTl6yEa5eaizVpsSdCq9+0KlT8tBOufI8lG+/haeekocqli6Ff/6pOCYxEZyc5P+rVHKQExJCrLW/diHjclZWkJnSfENazSIzkxwjI0xtbXUDFEmSH0qlPLIjEmUF4a4iApRbzM7OTu5BuX6dEmMzHB0hw8BWziHIyiJNaU/r1qBUdeNc5RL4QpOIyrHjn4y+kJV1y6+VkZFB1g1jXP1s8PR35fK6A/KOkhL44QdYtgy++goCAyue1K+fXEiuTx8oX2RQoQAHh4pptZLEmXNKOV2ldWu53odCQWiEoTZBtpyVjfLuC1CSk5EsLVFYWuoGKHFx4OZGZCS88AJyLsr587etmYIgNC0RoNxiNjY2pKeny3kEpmZYW0O6ZCOXuE9JIV1ph40NKJUqSpTKhpU/F+qUXWJGHqbNMkMqPT2dnDQz7Dq50m6gDxFHr8i5Jf/3f3KPWbt28Mgj0L9/xZPc3cHMDJ57TvdkQ4bIxdzKkj7Xr5dHgWjfXh4G6taNsDC0U4zLWdkakJmuuaX32eySk+XgzcJCN0AJCYFOnbhwAf78M0p+HXNzRaKsINwlRIByixkaGlJaWkpRfAoqc2OMjaHIwFTuQUlOJk2ywcZGLhJaYOkokvyaWHaJKflYUVhnadebl5GRgWGBIYp2bfH2teWaxlaue9+3r7xYzr33yg8DA90nBgWBra3utiFDYP9+yMgAGxtCQuSCqbRrB2vWQP/+XLpUPUCxtDUkK+MuDFAsLeVH5WJtZQFKWFgpqanziYlBnh3111+3ramCIDQdEaA0A0mSSMizwtWtbDaJkZG2B6VAaYapKbRpA6mGzvWokS40RFaJKUU4kR4bq90WHBxM0i2oLltUVIQyvwQ8PfH1tSDGth307AmzZ1c7Ni1NLokPUC3TFeQfiGvXIDqaPJd2mJrKBeBo105evbd3b2Jjwc1N92lWDioys5pn1lKzSUqSe0+qDvGEhoKvLxcvpuPra8OBA8g9UV9/LfdcCYJwRxMBSnOQJGIL7HF3L/vayEjbg4KREYBcwE3pRn5MzO1r591GoyG7xIwCjRPp8fHazWFhYURFRTX55YqLwVgqBDMz2rUzJqnUHJ59lsJCeOMN3WO/+KL6tmpcXeHYMU6UdKd3bzAxgXzH1tCjB8VmVhgayukqkiRpZwxZORrffQFKeQ9K1SGepCRwcCAmJoWAAHs5QFGrYexY+O2329VaQRCaiAhQboGCggKMjY356Se5XIUiO5tYVZuKT7tGKm0PisJYDlDatIFsRWvSrl+/fQ2/22RnkyVZYGJsQ/qNG9rN0dEFhIXF1/LExsnMBBdjuU6HkZFCO3Fo7Vr44w+5PhvI6ShHj8ojPZWX4gkJqdKBds89sGYNh5I6MHAg+PpC2FUjOHiQS5fkyrEAiYmJfPPNNwBY2anILNBTcfVOVh6gmJiUdSNVolBQVJRCmzb2FaOjTz4pJyXXVIdGEIQ7gghQboHyKrJBQbBqFXDpErFOAdoeFKWJEZqUtGo9KOmlbUgTPShNJyODHEmNva0l6ZWGdM6dM+PAgaavFZIen4+rje4bqEYjByi7d8PHH8vb1q+HadPksid79lQcO38+/PprpScPGQLHjnEq1okePeSA5MIFwNSU06ehe3f5sLi4OG0PiqUlZJWYNfm9NbtK1XCl8iGeylJTwc6OnBxQKlOxs7PDw6NszU0TExg3DrZta942C4LQpESAcguUBygJCXJl8pKzIcRa+WkDFEtbFZnxuZQmpaI0kQOUVq0gtcCD1Pim/2T/n5WRgcbAEBMzK7LS0rWbc3LkNI6mln49C5fWRtqvLSzkfNZhw+TJOv7+ct7runXw0EPye+jWrfKx4eFgby9P3NFyc6PEqyMaY1OMjOTnX7gg7woO1g1QvL29ycnJkeugVKpUfEfKyZGTictkpaZi5eKie8zly+DjQ0QE2NvnoVarCQzUcPBg2f4hQ+D48eZrsyAITU4EKLdAeYBSWgojhmu4GGNJbIa5dojHxlFFRrpExo1CbJzkiqIqFSiMnEmrNBQh3KSMDFAaYGGtoiC7Yvp2TraG+Pimn4qaHpeHq3dF1VpHR1i0SB5xAFi4EJ55Rp7UY2IiB6WxsXIvy/ffy/vz8nRHJs58sJ1uPeWfkfKisyDnz7ZpI/8/NzeXUaNGcejQITlAKb7NPSgffCDfWGPFxMDp03JSD5BcVISDoyMmJiYUaDTyC1YpQHF2BkdHR/z9kysCPF9fuHjxpm9FEITbRwQot0B6ejo2NjYATO54keOlPSgokJdeAbC2UZBepCatwAwb24pvgaGpBfmZt76gWEtQUqKbf3FLZGSAgQFWtobkZlW86+deS8KyNL3Jr5+eXIxrJzvt146OMGYMlP0oYGcHr70mBymFhYVcvHiRXr3k3JQLF+QCs7166a4feDimNQMHyv83MpLL5JSUyBN/Ki8xVF4Q0NISMm/3EM++ffDnn41/fkyM/MtS1l2UVFiIo6MjVlZWZJqZyd/X8HDw8SE8HFxcwN3dndLSWGJjy8qgqFTyCyVqogjCHUsEKLeARqOhqEiJsTG0Of8XGcYeFBVVrG5rYwMZJeakF5vrlL9wdFTcHfkD9bBhQy5vv30Tn7LroTg5AwMjJdaOKvJyKqadlhaU0M4giqZeWSA9HVwDKoYi+vSBjz7SPebhh+Wq9efPn+fgwYOMGyf3sEyZIu+vmpeyf7/c41LOwkIOYKpWkC1nZgZ5pU2UJHvsWOOep1TCrl2Nv25MDIwfL9+oJJFcXIy1tQMGBtZklM/kiYiA9u21PShubm7ExsbSvTucOFF2nvIp2YIg3JFEgHKLxMXJeQccO0a/oR6UllaUsbexQe5BKbbQfroGucs/pciy+Rt7G1y7VMDxAwfrPvAmJETnYWVliLW9irx8+Ue9sLAQZbFEu5LLOj0VN6u0tJSUnCRsOjhptxkagnENsUJERASWlpYEBMgzYx98UN7eq1fFG+zBg/J7bOX8UD8/+OUXeTHkqjw9PYmKuib3rNzsDBZJkqveNuZ5xsZytm5jhytjYmDiRDh5EnJyyDU05J9/1Pz2mxUZpqby9OKyLsnUVPn1KV81/LHHYOXKsvP06CGvfSQIwh1JBCi3SGwsuNvmgYUFD0x2omfPFO0+udy9Nekaq2oBSmqxxX+iW/r60TSSrqbUfeBNiI7Jwc7OAmsbhbZXITExEWNs8LHO4MTRppvJExISgpPRABTK+tUgkSQJpVKJUim/h6rL8lpVKvn9PTMT3n8f3nxT93n+/rBhQ0WCbGW9e/fmxIkTSAaqmx8/S02VeykKChr2vORkeWzrvvsaX9E1JgZ694b4eO0U4xMnICrKmkxjY3nxxLLidooqL7e3t/y7l5eHCFAE4Q4nApRbJDYW3FPOwogR+PraMWKEbg9KhsqBdGMnnSGeVq0gRbLVmWJ5t7oRr8GsJPuWFvyMSSzAydUGKyvILTUBICEhEWMDe7wCOpB87UqTXevS+fOYq9o06rlV32QHDYLHH4cHHkAngAW5B6W4WF6SpyqVSkVJSQkYGsgzYW5GZKQcBDQ02TU6Wv5BHj1ad0XmhkhOlhdLNDODqCiwsCAiAkpLLclUqeSgw9OT1NTqrw/Ir9vGjcjjYKGhjWuDIAi3nQhQbpHYWHBPOwe9e2sTGDMzM9m1a5c8xGNgR5qBY7UelDTJ7r9R7j43F3tlKreyLl1scgEuHnZYW1fkZVyLjMPeyAzXwECMc0NIaaJOnIKzlzBxtK7Xsfn5+ZiYmNS4f/hwuHJFb4V82rWT81jKq+NnZWVhUWkMSKlUgoFh0wQoXbvKvRkNUR6gmJvL3UHp6br7jx6Ve2dqI0nyDXbrBrt2Uay2wtgY1GoVeUZqOHwYvL2JiJB7TKqaPLmskKyBgXwuUfZeEO5IIkC5RWJjwT3zErRujZGREUFBQezevZvAwECsrSEDG9IVtjo9KO7ukFpqpbsg2l0oPx+MNfm4WWQTGnLrqn0mZpTg2tZeDlA0coCSfC0JR2sVLiNH4lJ4tElGACRJ4tw/sQya7Fyv48+fP0+XLl20z63K11dOvzA0rP5cAwMoKxoLyDVQ3LVrKMiUKgWlGTfZCxcZCYMH19yD8vrr+vNcygMUkAu9/P237v5Fi2Dv3pqvW/n16NkT/vmH6wXOdO0qd4jE59vIPShlU4zbti3BsMoLZWEh15S5ehU5gomIqOtuBUFogUSAcovExYGrFCd/kgQ++ugjJk2ahLGxsdyDIllrVzIuZ2oKxQrjO7IHRZIkjhw5Uq9jr12DtmaJuLpoCD1cx6fpm3CjQEErT5uyHhQTKCkhJyEbOwclxg4OeBpebZJE2eiQEEJS+vHgk9bV9ukLQK5cuUK7du2wtbUlvWoPQ5makmuriouLw63SioFOTk6ojJPITm5g7khV5QFKTT0oa9boHz6pGqBs2VKxr6BAnh587lzN183IkJO0QM4hCQnhSrodvXvLw1uxGRbyXGsfHy5eBBeXiin9UPF6T5wIO3Yg8lAE4Q52UwHK4sWLUSgUzJs3D4Di4mJefvllOnXqhFqtxtXVlZkzZxJfpTpqYWEhc+fOxd7eHrVazfjx44m9mcJOLUhOTg5qtZriYjBSFOs9xtwccuxak2HTRvu3uJxkaIh0BxZrS0hI4I8//qjXsVfOZNPeIRO39qaEncmv+wmNlFwErVtbYGUF+QpLilNTyUnKw9ZFrvba2q2EI3vzWboUCgsBSSJ1+UaKD5+o/cRV7P90OVZthuPgoLvdzMyM/Kprx5RRKBS4u7vf9M99cnIy9vb22q/btWuHRhlNZlJhzU86eVIeJqlNamrNQzy5uXIW7wk9r1NMDNqSyTY2csJM+XDToUPw2GNw6VLN142OBg8P+f+2ttC+PZHJFvTqJScIx95Qydvd3Tl3DhwcUrT3b2NjQ0ZGBiBP8T5+HBGgCMIdrNEBSlBQEMuXL6dz587abXl5eZw+fZo33niD06dP8+effxIeHs748eN1njtv3jw2bdrEhg0bOHz4MDk5OYwdO5bS8tXV7mBJSUk4OTnJ494qld5jFAqQUFCqUVTrxjcxsyA9uvkClGvXrjXJea5cuSLfdz1EnkqjXQcVTh1dib1+k7kStcgqNsHZ2RBrayhWOpN+/TrZyfnYucu1Zox82vLPk1txc5UYMyCTsU5BPPqJPx8+07C8i3/3ZDPt+dbVtltYWJBdS8JzUwQo5bOBynl4eKAxSCQzuajG5+T88y/ZX62q++QuLpCQUH17RETFNOCqKlckBBg1CrZvl/+/fTtMmCD3gNQkJqaiBwaQpk4lt9gYW1vw8YH4BAU8+ywpaUq5JzK9IkCp/Ho6OMjrceLlJYZ4BOEO1agAJScnh+nTp/PDDz/odK9aWVmxe/dupkyZgo+PD3369OGrr74iODiY6OhoADIzM1mxYgVLly5l2LBhdOvWjV9++YWQkBD2VK5QVUlhYSFZWVk6j5bqxo0b2Ng4oSrJr/gk2ADuHvZcDMto+obpcePGDb7++usmOVdcXBy+vn41DllUduVCIe27WeDWsweFWVG3bFZ1kcYAMzO5rLxkYE96XBy5aUXYesq1ZiQvL5RLP+bBn0awZ/D7/H2+FX9e9OF4QittmfUaXbwoLz8cHMzp/I6Me8Co2iH6ApS8vDxMy97AraystJ/4m4qBgQGmZhJZqTW3f/VOZ1Yf9675HvPy5CDD0BD0fWi4fBmGDq0xP2XfvkqLDt93H2zeLP//4kU5wcbWtuZE2ZgYnd+byEcXYucoV+c1Ni5Le3nnHfbskZOJU1JSsLOT91cN+OztITlV+Z+Yti8Id6NGBSjPPPMMY8aMYdiwYXUem5mZiUKhwLpsLCM4OJji4mJGjBihPcbV1RV/f3+OHj2q9xyLFy/GyspK+/BoxBt/c7lx4walpY64maVD6+qfquvS1seFsOibzB+op3PnzunkL9SoHlNdEhMldu/uywl93f5VxMRIuPdyxbVDB0w1Ebcm5aa0FMqm7yoUoDK2JSMhgewsDXbeZeXoXVzkRXB27pSXGnZ2RqUCE0crsrfXMgSi0chTbNat4/T/VuDUwVOn06CctbU1aWlpOtvOnTunTZBVVJ1f3ERM1Uoy0ytmrlTtpbmcaEm4+z1UrKxXxdWr0Lat3tgE0JaZx8xMt95KQQEYG/P66wkVM4ydnOThoPBwuWdEoYAuXWrOQ4mJQXL3YM8eORjZuzeJHj0ctbuNjORL7tolBygFBQU1Bnx9+pSNQjk43PWJ54JwN2pwgLJhwwZOnz7N4sWL6zy2oKCAV155hYceeghLS/lTa2JiIkZGRjo9LyAn9yUmJuo9z6uvvkpmZqb2EdPQqY/NKC8vj7Q0Ne6GiXUGKPo+2Hn5OXMltXmmRSYnJ9O9e/e6hxkeeKBsHfuapSZriL9iRmpdU0gBTU4+Bh28cHZ2xlYVTujFW3C/WVnydNsyhkb2pCUmkpNngF2bsmq9CoVc8Uyp+2sw+D5rDi6/XPO5L1xgZtbXjL+4mFmJw3h10Ui9h7Vv356wsDCdbREREbRt27Zx91RPpuYGZGbIP1w3btzgs88+09l/Pd+RKOMOFT0bVUVGIrVtR2Ag1YMQkHtQvL3lcraV1wuIjUVy9yAq6jN+/TWzYvvw4bBggTzcA3UGKAmqVrz4IowcCd9/n8zAgRXJPe7ucm6utlJzJZUDvj179uDmFilX6/fzEwsHCsIdqEEBSkxMDM8//zy//PJLrXUcQE6YffDBB9FoNHxTeV5kDSRJqvETpbGxMZaWljqP5tDYnuHYWHDXROuMpVdVPvRQla+fHVH5euaXNtRvv5WV06xdnz59OFbbmiu5uXK2YR1rmmREJBEfHF/rMSCPKqhK8sHGBmNjY5zs8wk9llHn8xpKSs8Ag4ofb5WxDVejoiiRHLG1k3/OTE1NyavyGl29ehWvAdnsPu9U4w9AwZ7D5Fi5sWFDHvPn5zB4sJ5qYchvmJIkaWeWlP//VvWclDO1qAhQjh8/TvvKVd3y8tAoVZSamsu9GvruMTKS6+Z+HDkCKXY+1RNly2fa9Oqlm4cSHU2UuT9t2zoRHR1UUYT2/vvlKTVDh1JQAFLnWgKUjAwuxlrxyCPyU0aOTGLQIN0A5bff5JijJnv27MHExITk5H85fx4RoAjCHapBAUpwcDBJSUkEBARgaGiIoaEhBw8e5Msvv8TQ0FCb5FpcXMyUKVO4du0au3fv1gkonJ2dKSoqqparoE0ubSHS0+UJB3XZvn17tamksbHgnh9eaw+KtbX+Kpht2qhILrzJBQPDw+GJJ+o1e8HExITCwlpmfBw+LJcdj4ys8RBJkshMyCMhS42BgYFczRT9U2yjo6GVacWYjltbY0KDmr5ybmZsNmYmFT0zSmNj4m/coFjjpp055erqSkKlJNDCwkJ27tzJjRtHCTPwhbNn9Z77/D+xdA604Y8//mDy5Mm1tqNHjx4EBwcDcPjwYQYMGHBT91VZcXFxtRogAHaOViRnytFBdnY2rVu31vZs5V+6homlESYmkN+lD5S1TUdkJCfSvOjcGc7RRTfXpOx7+vfff8szZCrP046O5myRL76+Lnh5JVasF9iqFfz+O1hZ8fjjsOW4Y61T6S9eUuDnJ+eYd+qUj6Vlxe+DuzssXy73ruhz/fp1zMzMGDBgALa2VhQVZVDaQQQognAnalCAMnToUEJCQjh79qz20aNHD6ZPn87Zs2cxMDDQBicRERHs2bNHm8BWLiAgAJVKxe7du7XbEhISuHDhAv369Wuau2oC1tZ1F7wE+Q91cpU/trGx4F4QSbV5p5XY2KBTpK2ckxNkFqsb330jSfDSS/Dpp/pnWZQpLCzESKnUTvnUF0wAclGtOXNq7UFJS0ujMMMUg9IiOnfuwrmyT8erVq0it8rwQOS5HNrbVQSnDl42XI1owtlbZQnUydfzsDCvCFBM1AbExSVipHLWjui4urrqTIFfs2YNM2fORKUyxLmDmrif91U/v0bD6URXWnklY2dnp81/qImfnx+Xyl7jq1ev0q5du0bdVnJyMj/88ANr1qxhyZIl5OXlkZCQgKura7Vjffx8uJ5W8TPZt29fbS9ZxOEbeLUrxcsLrnSbrH+YJzaWk5F2zJkD5/K8dHtQbtwAZ2d+/vlnCk1MtK83ANHRHEu0xs/Pkp494c8/K53zvvtISJAnBf35J3L0UXU2j0YDCgUXL1b0kGiqVIF1dVVSWlrKwIH6X6eXX35Z+3dkzJgxGBlt40JWqzqHKBtt795KqxMKzeGfxi6hINxxGhSgWFhY4O/vr/NQq9XY2dnh7+9PSUkJkyZN4tSpU6xdu5bS0lISExNJTEykqOyPkZWVFbNmzWLBggXs3buXM2fO8PDDD9OpU6d6Jd02l/r2wru5uRFRaRqjQqEgNhbcTFJrPYmNjf4eFKUSJANDObGwMf78U/5k+8ADtfaghIaG0lGjgVGj8GrVSucedJw/L08NraUHJTIykpJsV3ytE3AwcSUsLIzNmzfTr18/1OWr4JW5cjKNdt4G2q+VHm5YFqbQJLOdr12Dtm0hIYHk2EIsK60CbGVrQOKNNIzVFb10zs7OJCQkUFpayq+//qpt79ChQ3HyP8ee7cXVS8ZfukSwsgcZGbsZPXp0vZqlVCpJSUnRJopXpm+mT1xcHGvWrNHZFhISwj333MPMmTN5/vnnWb16NbGxsXqTnH27+RKfnaKtyVO5Psjl4By8O5ng4wOXDf3kmUiVi6kBlJYSFq5kyhQ4l+yqG6CEh1Pavj1BQb4cOhSim4AaHc2JKzcYOdIXW1u4cUPSiUF++AH+9z8557rIyw+q5OeUr8ETHy/nL0P1wNnW1pK1a7Mxq6GTsfLwmbGxMW3blnDkqKb8ZPqfdDMOHZLL9wvN5mQtH7yEu0uTVpKNjY1ly5YtxMbG0rVrV1xcXLSPyjN0PvvsM+677z6mTJlC//79MTMzY+vWrRgYGNRy9maWlQWhtRSUQk4C9vLy0knalSSJgnwJE8PaS7hbW+vvQQFAZYh0o+GzDvKySxkxpzU3ZiwEKyvdT7dVXL58GZ/cXOjVi4Djx7XDEDrS0uSGWlrWurZLVFQURfmt8PMuJjEolsuXL+Po6IiPj498wPXrckJlXBxXQvJp39W84sm2trzstJKPPmrw7VYjffwJy8dtQfPSK6QkFGNhVfHjbW2vojCnAIVpxTubSqXi3LlzrF27lgEDBuBX9rHdyckJd48U9rg/IvdGVXbwIHFGnjg4qOqdSxIYGMhrr73GvffeW22fu7s7cXFxOtv+/vvvar8LSUlJeHp6AvIb76hRo1i+fLneHhRnd0uyiiVOnDhBnz59dPZdvizh088Ob2+4HKGUh17++gs+/1x+Ay8tpVhhhIGBvChxSqG5boBy+TKnDa1ITx/LunUR0LdvRVdJUhJZefH4+HjSunVrAgKitcM8xcXw779wzz3yY5/B8Op5KNHRSO7yDD2FQs55q1rG38rKis6dM/S8yvrNnj2SP//cAc7Ocu9PUwsJafh6RcJNaaraTULLd9MByoEDB/j8888B8PT01CYCVn0MHjxY+xwTExO++uorUlNTycvLY+vWrS1v6rClJYbZGfpLRUgSZGQQEhJCly5ddLqhg4OhtUOePFZTi/79oaYRLXNTDelX664nUtXxX6/j4a7hocdN5Ppajo41/lEuKSlBFR4Ob7+N4d69lOrrsdm/H4YMkf9f5c34+0UVU49LSkpQKFS4tTUm/lwKr732mu5w3XffwfPPk/rgM5w9K9Gmb6U1axQKOrfJIT029+Z64RMT2XHWmTUR/Xgl9BGSD1zE0rriTd7a0YiighIUVYZkFi1axMyZM6v1RLRpY0siRuRKZvI05DKFB45RqE7Ez8+33k3z8PDgwQcfxFhP/Xo3NzedWVSHDh1iwIAB1YIfjUajE7R4enry3HPP6T2nhQUUlBqRmJiIS1lXRHlC8OV4S3z62eHjI6cqrV6/Hn78Uf6ZHjECPv6YC2a96NRJPpeRuTFFCZXGOsPD+SsSXnihE8HBGnnZ5eBgWLqU1AI15hZyj1H37t1p3z6YZcvgjz9g0ya5JIpCIdd4+/Nq17JSr5XExBBr3kFbBuXIkSP0799f5xBra2syG9C72KmTM8nJaaR6etYvD0WS5KHRb7+Vu3vqUlAgD1eJWivNpurUfeHuJdbiqYWTdSFJFyr1ZMTFwbPPwr33wv33c+XKFdq3b699MwkKKmD/fmM+m3WhzinG/v41z0Sws9UQHZqrf2ctDm1JZ85DuXz7LUyfDnld+1HTYjMKhUJeMtfbG155BWXVRd1AHl8fOlT+v6WldtipKKuAt97UVPxRLigAAwNcfa1JCMvUneFVUADBwWimz+D/zNfyifJlVB0rZpWYmpqS9+ijvOSwkiVLGnzLFT77jG8UT7NlC5gM7c8XocOxsK2o5Gttb8hAZRes7PVX961qxIgRtG+/i9+6LIKPPpILbxQVcSHOBgubi3Tt2rVBzbvnnnv0bre3t9fmMBUXFxMeHo6fn1+9eme6d++ud7uBgVypuLLevXsTFBREerE5tvZK7O0hKSmfv/76Cwlg/nzYuhUcHTnpeh+9esG+ffvo6KsgNLtS8BYZyYU4c0aNMsLGBq7GGslZq8XFnE1vrf2xV6vVGBrmsWWLXIvk5Zdh5kx5X5s2EJ1lTWlsgvw7VW7dOi46DNb+XhQXF2NkpFsAr3Ktk5KS6gsF6tOx43RWXL+BJiSkzmM5cgQWL5aLxV27Rq1jj2lpBJV2Z0vpGNGL0oyUSuVdUXVcqJsIUGrh7GNFwq5Kf9S+/lrOx9i5E+zt0eTllf2yyN3Xzz2XxDvvOGIUH9WoIm3l7B2UxETWUg68BsHnDOj+oA/e3vKH4VPqQL2Jstpx/ZIS+dPfkCEYJiRQXHVmRWQktGvHsWNQ0sZLmygbvTOUGxpHsi9cB0CTmITS3BSXLo7ER1Vp9++/w5QpfPqZgiFj1XSP3iyX+Czj6upKQuvWBMRtIepaEgkJjfgkmp7OqcMFtO1hh60tvPOhMfdOt8exQ8UYmpW1AkuT4di61m8VPmNjY7p2LeS3v4zg55/l4Yhx4zhtfQ+enrrl5W+GUqlEkiRKS0tZvny5dlaQSqWqfXZVHSRKdd683d3dibl6DZQVgUtWVggzZz7C6fJaJiYm8PjjnMjsQM+eEl988QVdukicy2pTceKiIq7HKOnaFQIDjVizplDuFnnlFc5OXqTzY69QKFCp5Bp4p07JMW65AQPg0JgP4d135Q3btkGHDlxMdcbPr+bgo3IPSlpaGrY1jpNW6NlTiVfvZ1n71191v3B798rDemPHyr/r+/fXfOy5c+xRDGdnbn+4cKHucws3TZIkLCwsyKllyFm4e4gApRYuAa4kHqmUHBocDOWJvGVTb7/6CpYskdi/X+K115Lw8XGSZwzcRIBi52FKVKj+ReYKCvRPzikulncaebpqm3cipZ2c5FpFQkICLtbWUCmB1fO++4j6/vuKg86fl9cxUSh47DGIMOuiTZSN3H0VK1Uu17bLSY7Z11NxcDLAtaMVCWlVAoB16/ihcAaXLsHTT1NtqMjV1ZX4hASYNIm8azP57rtGjC+vWcNnBguZPx9KS0tRKOC9761w8qjIdbG2hquG3th5qGs+TxX9+/fAwiKYC+lu8OKLsHMnJ93G4OVVv16Y+ioqKmLZsmVMnz5dOyXf09OTqKioRp9TgQFdu3YlK72U37+Up1JnXE3Byb5iONLAIJK+fcdpZxmVS0yEwsIo7rnnHiwtwzmb30HuPSsuJh9jDAzkNaQefLAz27eHaDvSTgZn06mTVaXzy7P6AOzs5JljP/74IxkZGUyaBGuOe8u1es6dk2edvfqqdgbPiRMn6N27d7X7MjMz084MS0lJ0VkosSa9esHlFB8MMjLkKfCSJNcRuHhRLjpXSfSh63x1opf8xeDBtQcoZ89yvsCbyAK3ugOUeixpkJ/f+Nz4WlU9aUSEPOyqh0ZTfeStJcnNzcXZ2bnWNa6Eu4cIUGrh3MWJhGtlgUJYmFzeu+wNtrhnT0ouR/HPP/DZZ048+WQSSuUNuZbL9eu1Fmmri1cfe/aEOOrd9/nSUp6dnc9vv+luP30ol+72Fd3MPXrAqbOGcuRSZXz8/PnzdDYygo4dK645axYRlWdzLFsGTz/N5cvy5Iowjbe2B+Xq6QyG9Cvk6uF4cnJyKEosxKm1Cc4uChIKKz7RFp8I5rnE14hNMubHH/VPaiqfSXPGz483LPLYsqWOv44FBdWCrsiNZzFo5YqLSyFPPfUUINf/sLComMZjbQ1XbQOwdah/IrY8U+0CP/xQsS0k5DhjxvSp+UmNYGZmxuzZs3Vm+bRr147IsoAwLy8Ps5qmrdTA1WQ4Pj4+rH01hJdfKCbiRBrJV/Jo166iV8bFRSIiQvdPQFaWnMMSHBzMrFmzSEs7zZVST3j0URg3js3txtOjhxcAPj5eODiE8/338ntedHQovXtX5OZ06tSJdevWsWfPHj7//HM2bNjAhAkT2LVrFx06yJ13R8d/KFeYfeIJUKu5cUNOnbp69areiruVh77qG6B07w7BpxV0Mjfn0quvyt2Lzz0Ha9bIxY7KFw7Kz+ffdB+++Lqsp8WxrF5LTfklZ8+SZWiDoZU5UkgtAUphIXTrBkuW1JqrsvHDcL5/ronrtWRny/db2YULOnlVlcXHw9Sp8re7PmUWmltKSgpt27YVAcp/hAhQauHiqiBR4yT/kv/1l9zlWyZMrebqxTY89BB4eXkRERFBZmam/Ak4Lg7qs8ZNDZxdrLCwyefqXt3ehORk+Hd9HEcYwD9fXWH16op9/26IZ9DAiqqlFhZys2nfvtoU4dTUVOzi4+WF28rYuLqSoVbLx6anyx+jfX3ZskVOu7mc664NUCJTrRk2yZprV0qJjIzENN0MZx9LTEygUGmqnT303cJIOo734p13qlWT11KpVBQXFxN08SJD+nTDVJNJDSseIF0OZ1XAV0y7JxEppyxHJyyMxcmzefFlA/755x+mTZvGuXPnyM7O1ikQaG0NkZq2VCnLUydfX3MuXswmOFj+sF9UFI2nZ+N7x/SZMmVKtQCk8tTgmt6sa6NQGiAVFbN5k8Q/P8bz0gORmGa3B9uK6eSurnIHgouLi7YezIEDcvJ2YWEh5ubmSFIppa3bIn3xJezYwdZkNQ88IGfQKpVKxo+XMDKS41kPjyhaV+o59PX1ZdiwYXTp0oVHH32URx55BAcHB/LLAoLFi+HN790o/uVXmDKlvAwKIFWrf1JZ+c/49evXq9VZ0ketlr93vs8+yyVJgn/+kYftPvpIficurwVz9CgHDNuSmXke7ftfeTaxHnk3sjG1MsbV00heZbkmW7fCwoVy98Tzz5eteFjdtd2RXD1SdzXmBjlxQs41q+z69RoThtPS4OGH4Zln5ALAVVc5uN1SUlJo06aNCFD+I0SAUoNz585x4sR6Eqw7yH2eBw8iL04iu3glkiMp45n8gEZnFVWFQlGR2d9IdnZ23D8lix8/0J1q/M4bJbxpsgTVqWP81Ot79i09w+5dZSXNj5Tic68VEyZM0CaQubhAvFdg2YppFRQKhVygzbfKTJQBA+CXX2DVKm0Z3YMH5Q+3YfGW8ser2Fiu4Ul4xGJ2pFxm25YtKDKtcfYu69pXq+U/iEVFnIy0Y8pzztTl4MGD8uKRzz1H35KT/PprpcUSv/iCwqfmETPtJR4fep3oUU/gc487fz0jfwIM//wfClt74+8vkZGRwZAhQzhz5gxZWVk6AYqVlZzH2NAAZdSoUdx773Y2bYLJk3U6nW658t6Cq1ev0qZNmzqO1mVmrOHwz1fxd7hBh0f7EOCTw5pdvTB0ksfuS0pKcHMzIDwcBg4cyKFDhwD5W//ww7rncm9nQlSpPLUmPLyQgQMrkqDVankiz+efw3336ebmKBQK3NzccHBw0Okd8vDwIDo6GltbOT74NGggKBTakdFjx47pHd6p7N9//8XFxaXOJTfKubpC4oCplHbrpvu7OWUK2u7IffsIyS1h4EAXtKs/3HOPvDxzVYWFXChoj7+/nPB+IbeN/pWfAdatg4cegldekafvTZwIo0dDlSVArkYbEJVhIwcyTeXoUTn5p/IbenS0nG9UUFDt8LQ0ufxBz54wY4acGtSSiADlv0UEKHpERERw+fJlzM1LuWFcVqbb3l7nD1toaAk92+Zgcv2yNtERkBdP69Dhpq5va2tL69EuBJ030k5zvnwZ0k9G0OflQDAyQrn0Y74dtYWPFtwgJgbyU3PZdSOKFStWsH79eqAsD0U1QC4mVUaj0chvfOHhZDl5sXp1pV5nHx/52L//hrFjSU6W39hdXSElVSEfePw4qUZZTJkyDDObx3lt7Fgyihxxdi37UVKrkcIjYOdO0qzr12PxzDPPyDU+2rXj6TY5rF+9F4Dr644QuGQMD0d/wLvKN+n5ihmtO23GbdgJvtzahsKUbN7/qxP/+9yeo0ePaqc2m5mZkZCQUG2IR5JqqT1TA7VajZVVJp06/cq0ab/wwgvNGKGUycnJ0bmX+rBSF/PJ2znMfl0OEF/8awBWFhocvawBCA8PZ+BAH0JC5ITgoqIiIiLk4oHGxjmYm8v5O61bt2b8+Os8/TS8+iqUlip01pAyMjKioKCAwsJCbb5JXQIDAzlYtpLy9OkQFQXjxsEbb8j5J5cvX6ZDLb9DIWWzcRpS2LFXrxomtJXnYsXFIZ05S6GBhoAAy4pfmUGD5G6lqi5e5KxZP7p2hU6dIETVXX+15ZgY+fzlVRmnTpUL423bJv9b3puSmkqKZI+hlVnTluU/fVruCrl+vWJbdLQ87FO1UB5y52n578j991epBtwCpKen4+HhIQKU/wgRoFSRmJjI0aNHmTJlCubmxuQbmcCvv8L48TrH7dlTypOPFULVhfa++w6efPKm2mBvb09yZgbjPc6ydV02e/bAU3NKWKT+QK4QW8bsvVf5xuJl7h9bTGujUzi6u+Pg4ECbNm04ffq0HKBcc5TfAcqEhYXJf/yLijhyypjly+XmFhUhj8P07y+vPmtoyN9/w5gxcre7JIGkNEA6dJgMxRX69u1JiZUtHD5MYom9tuyLrYsRaSFxZK/ZhLlX3b0nAF26dNH+v91r8yHxDJfOFfP4s6as3uHEB5/H0X3Az9wzzI5HHnkEcwsTZs3M5anuJzB0tseng4Lw8HBtYbjRo0fz66+/6vSgmJvLt9fQHhSA6dOnM3HiRB5++GECAgIafoLbwEpdSkYGdHxQfm2NzVUcS/XG1l6eBXPx4kW6dfOlWzf5x7ugoIDFi6/xzDNypc5eveRE0Z49e5KXd5J//oHevRMZO1Z3KCowMJDff/+dbdu2EViph7E2BgYGlJaWli2cKJcc+eMPmDULunULx8vLq9bn/+9//2PQoEENej3K1zVUq9UkJeXoDiM+/DB8+y0JSjdsbBW0aiVVLMNkYyMnmVbt1Th7lnMaf7p0KetBKe2oP1F29Wp49NHqMY5CoZuEe+AA2Nlh6GRHye5aEnMborRUDoC8vXX+BlBYKCfm6AmEyntQQP5MVlBQa43GZidJEmZmZtUW+RTuTiJAqcLW1paZZQUb+vbtS3rmSfljXqXVyZYtO4qjYwCtJ3TVLXOdmysXRiuvoHoTbUhJSeHhOaYsfBE2bShkq9NsPF+frpvMYWSE9zfzeUfzBvZOFaXX+/fvT0hICLa2CfLfIA8P7VokISEhdGrfHkxMOHkSli6VcxQnTwYDAxVFL70kz1gBtm+HESNK+eqrr7C1zSHZwZeUncFYOhijVCpRWFsj/fobiQZuOJfFIq5e5iSciOZMgjPd+9W+To1e/frRU3WOMYNz+PSF6xw+9xdRUVE89dRT2k/Vw4cPx3JIGlk5Sl5fasvVq1d1ch/Mzc21j3IKRR3Ve2thZmaG6iaG7BpLoVDUmotRGzvrUmZPTK+WmVw+nFNeY+Ttt+WlZPr1m82JE9vp1k2SZ3mVFXgrX0yyoCCfuLiNvPvuBJ3zOTo6MmPGDCZOnKitdFsf3bp1Y9u2bWzatIk1a9aQmHidwYMhNPRwteJsVVVdPqE+/Pzk+MHRsQejRgUzf77cQ7BtG3JAvm4dZ9zG0ro1mJoaAYVoZ3l37lw9+Dh7lqhCFzw95Wr/KQqH6sdoNHDgACH2Qxg9Ws/IzeTJcu8sULTnX1TOdrTqYkP0ruo9G41SPiWqdWudHpTEAmv+SeujP0CJycVm3iNy3gxyz5a+Ekm3i0Kh0D6Eu58IUKowMjLS/vC7u7tTUBCLtOwbOesUiIiQWLbsIr/84iePfVRabI5Dh+CRR5qsLTaTh3HMfQrLro1GPW+OXCCujCRJZGVlcSQ3l9QOkYy8r5vOL+3MmTPZt28X2dlhlA4eqv2kVlpaimFkJHTowNmz0LWrXOGzZ09ISWnDtdhYMDAgMxPy8wtZv/4bpkyZQkHB74SZdeOwcTu8vOVgwLGVCUlReWSrbMtfHlzamhJ/MoZTrSbS2M6G+x/ryvv2EzlsHceYMWMYPny4zn57e3vSMtL5I2Uw7e5pzZ49exhSXvG2zIcfflitXLyDg/bbeEdwcXHRWW25IV5YG8DDP1Tv0aicfAvyqOU338Do0Qr+7//GsbXsjakySZJYsWIFs2fPbrI3hi5duuDs7MyIESOYMWMGly9f5vvvv8fBweGWvPkYGsq9hG++6cbMmbGsXy8HZl99BRnZBvDCC5wx64+nJ7Rq1Qovr5iKISE9eSia8CsozMy08Z/S0pzS8xcqxkuvXYNp02DaNN5bpKR/fz0LOLdrJ39wKCkh+kIWrX3VtPUx4mq6TY2JtA1y9KjcI+rpWdGDkp/P2YIOrNzXWu8QT1p0NraBneTxsClTuG90EZs23XxTBKEx6i7D+B9nZib38Fpby6UMpkzZyw8/DK0oIWJnB8uX42xrS9jJk/DTT01yXR8fHy6npuLz+mwYPZoSlYp9u3aRkJCAoaEhSqVSu3hjv99+q/ZHXaFQ8Mgjj7Bp0yY2F7jwwL8/VQRPly4hdfSl8DTafILHH4e5c9vj6XkEHx8fvv0WXF2XM2vWLMzMzPD3d+fQ1WLijawYMmQAIFcEvep9L+SptX+oXd0UJHgPJrikC481MkAZ9PpLbPby5OmHHqrxzcrOzo6UtDQuX75Mv379qh2n71N2v371XwSyJWjbti1Xrlxp1Bu2kYNVjfuqLsDXtq1cit7f34NNm6ovfNerVy/s7Oz0ltW/GT169ND+f8SIEWVDPrfuG7R4Mfj4KNi8Wb6GtbX8c79uHTz97LOcnpjD1KnmeHp64u5+nkOH2tO/P/wYMZj+27bjO6/sROnpXDP0om3bira28zHkak4AXmPHykGKmRksWsTxdB+cz8kdGdHRelbAGDwY1q/nqokvVtYxqFQ5RNr3ZlhwsJxEdhOkI0dQfPqp3JbyHpToaBLM2hF81gA6Vi8EmJ5YhO1AB3h1Iaxcid2WlRQV/R/Z2XdWcC/cHUQPSh3s7c24elUe7/zxRw0DBlynf/9KUz6/+QasrfFatw7rAQPkj2pNoEePHgQFBck5J6amrFmzBn9/fx555BGmT5/OtGnTGDt2LJ6enrX+UX/44fvZfCCM4oQEMtLTsbKygt27iXbprVOqxdUVVCproqIyyc+HP/8M4plnhminv06ZMowDcdEkunfDy0vumWjTBq4FPopkXbEss4sLxD8wl4xcld7VmuvDUKVi0vTptd7X8OHD2blzJ6Ghofj7+9frvE0UOzYbNzc3goODtcMtTaVVq1bVZgV17w5GRjB58mQmTNAdxvHx8alXvZGbdau77bt1o9oqyBMmyBUEJAmSkq7QubMXDg4O2Nkls2ePPApzKMiEf2I6VfRqHDzIWdfRVEqdwt8fQka9VJH8+scf4OPDBx/Aa6/Jo6x6q+FPngwvv8w11/6kp+8lMzOIq1Zd9c8caoDg4GA+CQpi28mTFKlM5XnWANHRxKvkX/x0Q4eK7WXSkkq4IpWtszVjBvz2G2NGFLNjx001R+vcOZ2cfUGolQhQ6tCtWz/27ZM/Va5fv5r588fqHmBhAVOm4LZxI5O+/bbJrlt5ZlBUVBRubm56V66tS2AgFBY+yK8KBSc3baJXURFYWHAytR1leZBas2bJ04pXroSuXS/SuXPFG3/79gpKNX1JSTOivCRH27YQLnmhMqvIz3B1lXuOK5c1vxWMjY1JSkrivvvuu7UXuo2USiWRkZENroFSl8DAQPr27VvjNSvn7tyNyosDAhgby7Nw9u8HSZJfa7lEv0S/fvDmm/IU6rOqnkinT/Ppp58St2UL51Q9qLwck79/pRQUQ0OiouQp1IMGyQsp1xigtGsHbm6Eq9rg7m6Ks7MhVwudYceOasFDQ0ScPMkLvXtjY9ON9u1frdhx/ToJGmfGjIEzloEQGqrzvPzsEhIplBfkMzSE2bPpcfW3agtPN1Z52YKbWMVB+A8RAUodvL2duXbtBitX/oyV1RDattW/SrH8R61pEykdHR25ceMGu3btkuuENIKDA2RnW2HXuy/Hf/sNh6+/hkWLCAqS804qGzpULo+yYUM6I0da6+xTqcDMrAsWFg9pl9Jp00YusVK529rFRf7bWsM6dk1q/vz5zfLJ/nZKS0urttKycHP69OnDjh07+Pnnn7l69SqzZ8O8eeDhUagzjPXee3J+rK0tpKvdOLl6NaNGjeLM2bNsPbqJkJB1rF+/nl9//ZXk5L3s3n2dFSvkkdQXX5Rrsy1cKJ+rxgAF4OBBjl06zIwZYxg6dACx8Ufhrbfk3tNGrtxbeuECBoGB/PSTK8bGEwkpKpIDnuhoEgptGTMGTkvdqiXKKgoLmDh9On+Wzy+eOhWfU2u5fLHhOTG5udocYK24OJg0Cb78slG3VW14Uri7iQClDi4ukJJSiJlZP4YM8WzWaw8ePJhPPvmEHj163FT3d/fu4DBkAb0PHJBXrbWwIDS0ep02pVI+1sdnO2PHjqp2HiMjOdGwvCmOjhASohugmJjI1fXvkNm4Ld69995bLdlXuDlmZmY89thjPPzww+zevRtvbw1WVrUvn2XmasP5w0F0tLVllF9nXFxm8eijDzFt2jQeeOABevb0Z+hQY6yt4cMP5TfmyiOPlSbSVSOZmpKXl4OzswWtW7cmPz8aacg98MEH8hBQYxboOXGCK10nkZ8PXbr05ojGQG7A9esUGpjRpw+cTvOsFqBIBYUYurnh6+sr15tRKjH9v5nkX4nTf51aXL6MTrVrkAOUF16Qe6xqqhhdk9LS0iZbpFO4M4jvdh2cnaFVq8cJC2vH0KHNe21jY2NGjBhB95vsjhg5EnYcsWDk5s0wdiylpfKYu773vfHjjejTJ19vQmT79rqJcgqFXMjNuUq5E1fX5ulB+S94pAlnhQm6FAoFY8eOZdeuXaxYUXuV4E5dlcTk28GuXZxrN5Fu3So+MBgaGuLk5MTbbzvzwAPyh5qq1OqKJX+qOnr0KDY2/bRfW1qqSEwskpNmZs1qeLW0mBgwMWHxMktef10OjqzduxN++LDcI2OkwtoaMiXL6mX8JQkMDenXrx8ny1clHTsWVWqiXCupAa5dqx6UlU84eP/9ioWs6ysjI6Neq1cLdw8RoNTBxUWO9PUNiTSHqlNsG6Nv37IVSsumKV++XHOx2x49etR4zQ4doGo6RNu21QOUn36S/wgJQkvn5uZGfHw83t5gbFwRdKhUKooqvSObm59Ccr0PlizhYOkAGlgnrlaWlm64uFTUTurd+x5+/70sSXbsWG1NkvpK+eYbCvs9QFGR3EvaqhU4th/N4X//JSE/n6Sk7Zw7dw5zSyVZeRVJ/SUlYKioKNdvZWVFQUEBmJvjpY4n4nwNEVYNrl2Ty0JVpVDIH2DKVgep/33Vc3HI/4rTp2my5OWWSgQodbCykn+RjI1vanmd20rOH6noKT55suZgy9PTk1Y1rMQ8bJi8jEhlbdpUnzpZNflWEFqyrl27snfvXp2FBz08PLTrawEYGISSaDkB8vI4GmZLv376zlQ7AwP95U00Gk8qT6rq0sWJkJAYEhMT5WxzpVKucVAfGg0Xdu0iyfoBJk+WN7VqBTG0oq+REccyJNq160tKSgpq9U7OFXbQdu1kpJZibVSRmNu1a1fOlWXH+vYyJ3TjpQbd77Vrcq9reVX6m00fSU5OFgFKJb+sLGbTuoYFjXcaEaDUQaGQSwgMHHi7W3JzymtNhYbKq8w3ZriqVSu5N6ayt9666XINgnBbde/enY0bN+Lt7a3d5unpSVRZcTNJkrC2hvgSRzRLPyM3t3E1QdzcdOs6lrt6Vbdnsm1b8PSczYEDBzh27Ji8zEZ9e1EOHSKuTRsSkzy0Q1YeHhBd4EDHiAi82gzC09OGoUOH0quXE6vTFRAhr3CddiUNW+uKHpR27dpxpWwlZN8HOnJpT8PyUGJj5b8X5cnBWVnyB77GEj0oui7sSST2kJ71n+4iIkCpBycnuffgTjZypFw1c+5cuTBVU/2e29npVt8XhDvR448/joeHh/br8hl0AJs2bcLPzxdDlZKzrcbj59e4a9SUKHvtGjo9KO3awdWrCh588EGuXLlC3tChcm2V+vj5Zxg4kGvXFNpztmoF0TdMICKCBLUX5dUKJk3qSqF6praibNqVVGztKxLTKifmdxjmTmisRYO6QTQauYht+T3HxclBWmPl5+dr6zJJkvSfntETGQlti8IwzE6nnmt03pHEW0s9LFpEo/8otRRt2kCfPvLsgqo5I4LwX9ejRw+d2VLldYiuX79OUVERPXr0wNdXXgu0nmsiVlPTVOOqAYqjY8Vxffv2JSQ2Vl74Lyur7oskJoK9PaWlFTUjHR3LckGcnYk38tQm8drbQ5rCTk5KA9KvZWLjZKT3tJaWkG3mJE/bqwdJknufW7WquJeqAYqhIY1+czU1NZXzY+4weXl5pKSk3PR5tm/TMNr6KB1b5RG28zoRZb1gtSku1rMeVG3ef7/hiUJNTAQo9XDPPXdWifSafPABja7uKgj/NdnZ2Wzfvp2pU6cC8qSadetgwIDGnU9fgHLggNyBUanzRptEum+fvNzB1atX65csq9EgKRQUFSkwrbROp1JZ1vHRujUJuFC53qOhlTmll+QAJS02F1t33VK7NjY2ctE2wMDZkdIt2+p1rzduyD3PlXuNqgYoVlb1i7n0sbCwILs8ueUOsuS91Xz8Vj17w2qxd1Mm9wyR6DbcnuD1Ybzzzjt1Pmf+fLkGTflrnpgIMzsGEXs5V+/xn613Jk7TtFWsG0oEKIIgCHq4ubkxa9Ys7VBHt27g5dX4GWpVA5Rly+DHH2Hz5uorZLz8Mnz0EYBSXtF65Eg5mqlNbCwx1taAB5XSabSkCfcRr3HWmQbdqp2K6BtySYG0+EJsPXWTa3r27MmpU6cAaBNgw7V913T25+bm8tlnn1W71rVrlC28WKUHJf8KPPssfPABVrlx9c79repODFAiIyMJ+qOUf/9Kuqnz5OWBJikF81ED6T69I/8ejsfCwoKSWhaYvH5dXqxy4UJ5osPq1TBjXAYTYpfxwlN5ekfuDqT44+hye2swiQBFEARBj7Fjx+pUh27XTk4wbyw3t4oe85Mn5WmiP/8Meta1xMYGhg+Xl/QBiCpy5XJ4Hd24ly9zwcwMjcavWhkBOztIG/cICRmmOgFK+/ZwJdcFJIn0pGJs2uh2sTo4OJBctgxzRz8DLmW56+ShpKenc7lsiKiy8mErW1tITZW3xcWB675f4P77ITAQ69P7G1WDDm5xgHKLkjq2b9tJaXIAuTnSTc1oOnAAhij/hX79aOdvyvnMNB5+4AHCLl2C2bNhzBh45hmdgHbRInj9dXnB1OXLISFeYqv9YzzwzVD8jCO1P2daycmUqExu+8xVEaAIgiDUg1Ipr9vTWEZGFdOMv/4a/ve/2oeOn30Wvv0Wvv/egCef0vB97Gj985TLXb5MhrU1sbG21QKUVq3koZbCwooVzEHuEYpQdYT4eNLSFdi2q3kM2NcXQpV+ULaOEchLMVSenl2uPECpfH8JCeASGySPmffvj7VxXsvrQSkokAOoJvLcc8+xdu1aPv/8c5TnrBk1rBh3o+SqSyA1yMbfSxntEASmpiiVUGJuQI+sHC6+8Qb07w9//y2vtbB8Oaxbx5Ur8rIDnTvLz2/bFl4J2I1JD38YNYpXbb/n++91V1W48e9lHF2aZuHbm3H7WyAIgvAfEh8vBwpVFpSuxsQEliyBuDhvnJzC+W62uzwluKaSt2FhTHvhBR56Xc43qKw8QKnKywt2G3SAy5dJK1Jj66j/LUGSJHx9FfxIR3lVxLJEltTUVL3VXaOiKu5PoZA7XUpyC1C52GujFitVPhlpGhrzOfmWBSg3blRbQLGxEhMTGT9+PMOGDUOj0fCwx798eqAb10d+ycED8utZb+npcOwY69LuxTw7Ee9hFbWqnNqYEb3wW0r8jOCxx+SNnp5y99zTT/PuJ515fUYsfBYqfyPs7OR9GzeClRVGGUnaeOaVV+Snn9+bTOfut39Kt+hBEQRBaCYmJvDZZ/DUU/U7vmdPGDXKj5iYi2QYO8HZszUfHB2NonVrsrOrrybeqpWch1CVpydcK3KDsDAyi9V665R4enpy/fp1eZjIwKHSss01ByjlSbIgL1ianAykpOoUYLK2NyQztn5BRl5ens5w2y0LUBISuHz9ujxr6iadOHGC3mVFonKDwsg1ssHZy4Ku7rns256uPW7nTkiqKS2lpESeOjZlCkc2J7PxhSN8mj1H+zqWlpbS1t+C0/cshClTdJ9rYMCaft/h5irha5ckd6F06yaPKb7/fkVRGjMzBvfMlauNlzkfXEyXoSJAEQRB+M/w8IB//23YVGVjY2OKiwvRWFhBWWVXvTQaNAoDvcNGrVrJT60aS6hUUGJiAZcuoUGpt6ZR586dOX/+vPyFhaVOgFJUVISdnR1ZVabjSBIowi/Dk0/SqpVcjM4w9YZOgGLlqiYjpn5BxoEDBwis9KIZGBjIycNVLFu2TJ711EiFMTF8plDICTM3KScnB4uyin6bFhzm/lnyi9+5qxcJ18OQJLnK7nPPwcqV+s+x7KEjDPt4JOOMd/F+zCOsutQLg8cf0a7GGhYWxpAhHTljPxwDlUonUfb0afhzk4L3/+oEM2fKr/2QIfJUnj59Ki7StSvGoWeRJLTrLZ2Ls6fzkOpDd81NBCiCIAjNxMdHzi1pVNkCc/Oahx9yc8HMjJgYORipysNDXo9L30KGBhamlBw/Ja/noYeFhQU5OTnyF8bGSIm6C+x4e3trK86C3PmgVAKffALx8XjkXebkCQlnKV5nnrG1hwWZCXnU5tQpuTcmNTUVBweHWo8FsLa2Zvfu3XUeV5OzQUG4urvLSTRN5Po7q/gpbgQTn5Pnkrfr1Qs7g2DCwuDjj2HpUtizp3oNPEmCzUfs2XlYzda/FWzfDhb2xjB1qnba14ULFxg3zp8jR8DOriNhYXLgc+KEPGPnp5/0Lwpbbt++fUjdu0NwMD17ymvOodGQWmyBvcPtr60hAhRBEIRm8sQTMGNG454rKRQ1zzCJiAAvL8LC5CCoKrVaHmapXAOlXKvWSqKzrMFEf4BSmY0NZJSa61T8atu2LZGRkdqvY2PB3SZXXj9o1Spa7V3J8T3ZuFW5tpWnDRk3Cmu93ldfwbJl9asuVl5ZtlevXhUrMTfQlStXaN+lC9JN9MIAFBQUYGxsTNh3B3jsu96s2tdaO+xm0bkz7Y0usW6d3Ks1Zow8+lJ19O7YMehtFoKBi2ON1ykpKcHU1JAPPoAff/RlzpyLjBwpL4C9enX1HrOqDh06xHFJguBghgyB/fsh4cQZVOq6fxaagwhQBEEQmkljCz66ublRWBiPxqlsefWqLl8GHx/CwmpeqdzdXX8PipcXRDj2153eUwMXF0hw6KLTw2BkZERxpcDp2jVoE7VfztS1tcVjmA/H9uTi1lM3QrFuZ0dGai2zkpBzM7ZvP0X37nUvJR8VFUXbtm3p1q0bZ8+ebVQpfE16Bgl2Q0m+1LCFEavauTOYE6vVPP+mFeuOt8WzTaVvfPv2+JRcZMkSeS0zhUIOWn/+WfccK3/S8Gir/fW63sCB8OuvKmbOLGHrVrmGTuXifzXx8vIiPDkZUlLo2RMOH07inXe+xMj2cAPu9tYRAYogCEIL17VrV0pLz5Lp3VN/Hko9ApRWrfT3oHh5wVlVT8yta57UqVKpKCoqwsUF4h266OShVFZcDOdP5NEm+zzlSz57vPwQUQUuuA3RrR5n5e1EZkbNQUR6ulwUz9PzMnFxerqFqjhz5gxdu3YF4N5772XPnj11Pqeq0DhLvto9lvBKJf3z8vK4VmXIZ/Pmzfz4449El02Nun79Ops2bUKSJDauLeCdWQcZbp7A9hh/nFtX6Y0wM0OtyWb7drliMGFhdPHKIySklOBg+XubkwOJkXm076KnSE6ZjIwMCgt1e6AsLWscqasmPj4eFxcXTE1NyTMywqg4lxs3thFgMpGuAS78+eef9TvRLSQCFEEQhBbO2toaY+MMUlt1qzVAiYuTe0r0GTpULjZXlZcXnFQPwbajU43X9/HxITw8HFdXSLDw1rsmz+jRcnrE5b+vMHBuV+12Mxtj7Owk3HzMdY43dHWktKDmomgnT0KvXvLSAmvWyD0QkiSvm1i1cyQ6Wl5M0LSsxn+rVq1IqFSvBeQgIkbfYkhlkpOTCUrvQ5t2rbgYX1H+/eTJk2zatEnn2MzMTGbNmkVYWBirV68mKiqKrl278ueff/L3ZxHMGp/MiPWPozTWX+lMoVBwz5Cym3jySRSb/sTH5yRffSUvJfDHHzDZ/xLJnp7k5uovRb9z507GjBmjs83ExKRawnJNgoOD6d69O/feey87TExIO3QIPz9Lfjjkx32zRxAQEHDbF2QUAYogCMIdQK2WSHXsqD9AycgAa2skqebVxefO1b9QaOvWcPqiMTb2Nfeg+Pj4EBYWJg/xGHpU60FJT5enFf/5JyxzXYTjRN0Fi1q1UlRfybiOZdBPnAB390i6dm1FXp5ckfa552DBAt0c1vh4uYDeuXO642empqbk5VUk4e7du5cLFy6wcuVKMvWUsD14MAhDRTceesiAsJyKrqbY2FhcXFy0vRVRUVGkpbXm668VODmNYMaMRwgMDKRNmzbY2dkRfu081gNqr+intLGhNCZGvhErK9i2DR+fCC5dasXYsfDDD/CAeiebkpIICgqq9vzS0lLy8vJwctINKseNG8fGjRtrvXa5rKwsrKyssLS0JNvbm63z5vFU/hXOp3vg3U1N69atdVa0vh1EgCIIgnAHsLQ0JKnATI4GKqv0Kbcx7ycqlTwppLaESmNj44ohnjQTeX5sJfHxtnTtWlbTXk8hlv/9D701ViSp5gafOQPnz/9C7969eeghuUhqz55y2fbKyxLt3w8ff1zCgQNKdu2q2D58+HDtjJ4bN27g5OTEqFGjePjhh/nrr7+qXW/XzlSmu1+kf38Iz/PQzrlVKBQ65/r330Ns2zaQtnaZrH3xLE+OqEio9es4iNLSILzrKDns3qEDsUeOyGsnzJ8P2dlYq0v4/PO2fPnlVY4cAfWVc5h4ehIfH1/t+Tt37uTee++ttt3IyAhnZ2ft0FNtKgcfbYYOxfitt+j93v3cf09mtbWhbhcRoAiCINwB/P27cO7cebkbpPIbUGiovKgO1Yc+6svLq+4ZH1CWJJsAGBkhVcp/iI31wtk5Qp4qZF+9wNfEiTUET0qlXFa3CkmCuLi9TJs2GRMTEyZMkFeSnjlTriFTOUDZtw/atLnEN9/4sWQJpKTI262trbU9JTt37mTkyJGAnE+j1NN7E3S8lPt9L9OhA8SVOkJ0NJIkIUkS9vb2pJYtKhQaqqEfJxizeQ5LZocTcy5VO7nq6O9xPBrQn549a0/qbdejB5EnT8KhQzBoEMk9emCfkEDPnj21M5DSs7Ox1dPlJUkSiYmJuOjLeEbOv9mxY0e17efOndMOcZXfV7lBgwYx9cEHMfT1Zv2emmcNNTcRoAiCINwB/P19CA8Pg/vuk5dALvf77/DAA+WlUBqlfXt5CnFtJElCrYb8fGDsWHI++khbiCwxsTWSdF0upNGrV72vqzAxRorXzRVBo+HU8p1YW9/A19cXkHt5uneXdzs5ybN7yt9f4+IgLS2Ubt18ufde3fQYCwsL0tLSUCqVSJKh9jn29vbaRRABrlzRYG1ShLqVHUolGJkZkX3xGrGxsbQqKyzj4ODAgQMHOHvKmznF38Cvv8KUKQxqE8O/v8r3cOTvdPqPsa7zvp179yZx61a5W0ip5KCtLYHR0ajKi61lZ7M/N5chQ4ZUe+6hQ4cYOHBgza+pQkFAQIB2Fepyp06dYufOnQBER0fTunXras9raUSAIgiCcAewt1eSnS3JyxxXLkZ2+DD0709KilxWvjEmToSyCTA1UqvV5Obmym/yjz9O2oUL2F65UjaiY4hGUyoHKHX0HlRmbqkk50qladNxcXDfffz42Xqm52fp7V0BOdk3KUlO4fD0lHMyDAwM8PODixcrjhs+fDgLFy5k5MiRvPoqbN0qbx84cCCHDh3SHrdkySUeHmiiTdIJ8HXk77+vc+rUKQLKqrYOHz6czz//DvM0Bzzm3KvtErr/MRs2LZdr1V+8KOE7te4VJRXt2sm1VmbOBCDfxgaza9dAklAoFGjOnyfX2Rl12VLXlXs7rl+/jpeXV63nDwgI4PTp09rKsufPn6dz5860b9+eiIgIzpw5Q7du3eps5+0mAhRBEIQ7gJ2dPP0UU1O5qyQ1FS5dkucVGxiQnNz4AGXwYDlZtjZ+fn5cunQJSQIJBanz5mH3xx8c35RA377yzJai06ehS5d6X9fa3pDMq2W5K+Hh8hv2kiVEt7mXvjM6yJGTnrLzgwfLI1v798PgwaXaN2JfX/klKWdubs6jjz6Kg4MDZ87I6+OBHGyVJ9AWF8Phwyd4rLOkLRQzdowXO48nkZeXR36+mr17oaBAhb/f18yWVuise9Ph0T5cDpUoKABVUS4GbnoykasyNsZo9myCMzIoLS2Vh5y6doVz5+jSpQvB27Zh6OkJyDOSKs8+qm9Px9SpU/ntt98ACAoKomfPngQGBnLw4EFyc3O1wU9LJgIUQRCEO4CdHZSWuhEbGwvjxsndAb//DpMnAzWmfzSZ8oqxVlZyHmxaXh62n3/OoQ+PMGAAzHj4YdZcvcrJ8nV79CgpKdFZL8bK0YiMa2VJvz//LC9i16EDiYngNWewXHHsmWfkZXYrJQcHBkJoqJK9e0vJTlnL2LKV7vSt2jxo0CDy8+Uk3aSkivVmQO6ZWL06kUGDnFHeSNQGKEOn+HAhvpTERDkWCQqC2bPh/D6J4RPMwMio4iSmpvS0u8ry924Q4FpluKoWk5cvJz8/n/fee48ePXrIQ3fvvYefgQHfb97MwIkTATkwDCkbt4qNjcW9pnnkVVhZWWFnZ8eOHTtoX5ajpFAo8PPzIyoqqt7tvJ1EgCIIgnAHUKvB2LinPO10zBjYtg2OHJHzGOCmelDqw8DAgNLSUm2ibFpaGrbdunEmz4dunME8LY3Z/fujUChYvny53noc27dvZ9u2bdqvrV3MKhYMPHECevfW5okoFIC/v5xvM3w4PPigdpVhR0fIzbUgNvY61uGnsP3tN0hKQqHQnygcHAw9esi1YPbulbf5+/tz8eJFvvlmB4sXj5Ir9JYN8Zg4WlJQrGHVKkN+HrWOV/aP5FeHZ9liNAnlU/9X7fz3T1Hx3iem9BvcsBLxAwYMYMGCBXh7e8uF7V56CcWXX9IrOxv3sgX9bGxsyMjIAOD48eP0qbzQXx1GjhzJtWvXGDRokHZb3759mVk2tNTS3VSAsnjxYhQKBfPmzdNukySJt99+G1dXV0xNTRk8eDAXKw8KAoWFhcydOxd7e3vUajXjx4+XPxUIgiAIeikUYGhYNjRhYwN5efLCO2Wrwd1MDkpDuLjItUdKS0uRJENo3w7Vpx9p80969uzJY489xl9//VUtUTMjI0MncLHysCQzPlcer/HxAaWSGzeKsbSsMs916FC5p+jrr7WbWre2oKBgNRNjYuSelrLxG0dHuaeksqNHoW9feOABuVYLyKs0//77QWxsLLCxUcpRV6VZM10ttvHjiEu4RR+D7dvhhRfg88/lC1TR49k+mBel0nta2wa/nhYWFhXDNr17w7ff8kRMjN46MQUFBZjUY0mCyp566qlqw0Ie9amD3wI0OkAJCgpi+fLldO7cWWf7kiVL+PTTT/n6668JCgrC2dmZ4cOHk11p3vy8efPYtGkTGzZs4PDhw+Tk5DB27FhKy6JjQRAEQb82bdqwdu1a1nbsSEGllQdvdQ9KOe1UY+TVhgMGmMl1T376STuDR6VSMWPGDC5UKuhWnuipUCjQlC02aO1sQkamQg4uHngAgDNnUmjTRs9Y1eOPw65dUJaPMX26G3Me7IuBsTFMmyb3KFE9DwUqcnfbtJGfXlICSqWSX389ynvvjZMPys2VV4wuM8INekrZ8OWXcrDQti3UkFiqcHTgzNyVmPeoYZ0BoVEaFaDk5OQwffp0fvjhB2wqzU2TJInPP/+c119/nYkTJ+Lv78/q1avJy8tj3bp1gJxItWLFCpYuXcqwYcPo1q0bv/zyCyEhIY1aO0EQBOG/pF+/fkyfPp3pn3yCSaUpvbc6BwXk5FIbmxxtgLJ1qzzaxCuvyN0UHTvqHO/m5kZcWZLr2bNn6dq1q3aGCYC1jYLMEjO5Hsj/t3fvUVWV+R/HPwcPHFE5x0AFEYbyfsFLo2WYSaOoqS3NZkbL8le/odYyR9PMZmVNS6o1YWXZZcasacrSlFY/ZXImJakEM7tpUOCkVNqkCWLFzUuA8Pz+OHEUkMsBlH3w/VrrrBV7P2fvZ3+z+PjsZz/7l0dns7Ly1b//Wdbi8POTli93L2xmjH772566LeAb9ySRDh3cC7l8/32tJ3mMqZ49rrrKvZT87NnS9OmvKSYmoPa5JP3Pu+/K74knGr36XednHmpwddymstvt2r9/v+eR5wtFk6r5xz/+UVOmTFFcXFy17QcOHFBeXp4mTJjg2eZwOBQbG6udO3dKcq//X15eXq1NeHi4oqOjPW1qKi0tVXFxcbUPAFxo/P2rT/I8048/uifSnksDBgzQiRP7VLW46a5d0vDhco8ufPqpai5BOnbsWG3b5n4jb3Z2tqKjo9W/f3/t3btXknviauEJh/sRol9uVe3dm6/Bg+tYLGzAAGnSJPeM1VOn3KMmkye79/3+99Ibb9QaQTlwwN29KjNmSKtWuZfMT0ysJ38EBTX99dMtrE+fPlq7dq0u92KNmbbA64CSlJSkzz77TImJibX25f3yGvCa7wcIDQ317MvLy1NAQEC1kZeabWpKTEyUy+XyfHzl/hkAtKTgYOmnn86+r6LCHWDOpV69eqm4+Gvl5rrnlPbsecagwVnW5qiaWHvm7R2bzeb5uXNnqSigq+f2jiR9++2PGjasnmVt4+Ola65xP8kUHi5VzcmYMEF6++1aT/JUzT+p0qePeyXaauu+NGeVu/NgwIAB2rt3r9fzT3ydVyvuHzx4UAsWLNDWrVvrLVTNCTnml8Vn6lNfmyVLlmjRokWen4uLiwkpAC44ISHugHK2l/6djxfP2u12+fufUnGx+8mYm25q+DsjRoxQSkqKupxx/6lbt246cuSIXK5QFQ67Woo7HQ4KCozCwxv4u/Pvf+9eUvbMISOHQ4qMlN++L1VZefpW04cfSosXN9DJM57gsaLAwEDNmTOntbtx3nk1grJ7927l5+dr+PDhstvtstvtSk9P1zPPPCO73e4ZOak5EpKfn+/ZFxYWprKyMhXUeOHVmW1qcjgccjqd1T4AcKEJDnbfymlNVX+P/M9/pLFjG24/aNAgrV27VrGxsZ5tY8aM0fbt29W5s1RYEeS5vVPzHPUaM0YaNKj6tkWLpMceU5cu7jk5J064+3nxxZIeeMD94p6zyTu9BopVnfmo8IXCq4Aybtw4ZWVlKTMz0/MZMWKEbrrpJmVmZqpnz54KCwvzvPVRksrKypSenq5Ro0ZJci/B6+/vX61Nbm6usrOzPW0AALWFhJw9oJSX15r+cc7YbDaVl7sHLByNXPbjscceU4czbqEEBgaqrKxMgYHuEFGlrKyZ19G/v1RWpkFhP+q996Tp0925xPZOqnTokPtVyFVv9jvToUOWDygXIq/+KAQFBSk6Orrato4dOyokJMSzfeHChXrkkUfUp08f9enTR4888og6dOigWbNmSXKvbhcfH6+7775bISEhCg4O1uLFizV48OBak24BAKdV3eKp6ccfz/0TPFUCAgIUFPSzevVq/Hd69OhRa5t7Pkr1bd991wLX8ac/KXrJet31z3l6802pf2iB9NtE9yNH//d/0sqV0oIFp9sfOCA9/7y0fn0zT4yW1uKZ+09/+pNOnjypuXPnqqCgQCNHjtTWrVs9b72UpBUrVshut2vGjBk6efKkxo0bp9WrV6tdjWE+AMBpISHS11/X3n6+1kCR3E+UxMTsVmSkq1nHqVoPxWY7PZD/zTdnXQfNO0OHamKHR/TZujh1PHpUuv8p6ZFH3Evxzp7tfupn1ix3wQ4dcq+vsnq1e04LLKXZASUtLa3azzabTQkJCUpISKjzO+3bt9ezzz6rZ599trmnB4ALRl1zUH744fyNoPTt21epqX9TVNRVzTpOz549tX//fhnT27Nt//6WyQntHrhPHR97WBo82D0vpWp5eD8/6aGH3E8NuVxSZaX04osNvykRreI83bUEADRXXXNQzucISmBgoL7//nsFB9fzKHAjDBo0SO+++66klg8oGjpUeu21s++7/HJp+/YWOAnONV4WCAA+oq51UM5nQJGkgoIChTRzVbhOnTrp+PHjCgiQSkvd27766riiojq2QA/RFhBQAMBHOBynV5L94YfTv9jPd0Dp3r27XK7mzUGpEhx8emG14uJ8RUY2dxIK2goCCgD4kNJS6eGHpYkT3Q+fSOd3Dook/eEPf2ixhxruuUeaN086eVIqLc1X1/OZtGBpBBQA8CEDB0pDhrhXSP3lBb7nfQSlz1mWtW+KgIAARUWVavFi6YYbpPbtj6pbsx/jQVvBJFkA8CFPPXX6n/v3l774wj36YOFXydSp6sWB48cPVU6O9PHHJepU9dphXPAYQQEAH/W//+tewuN8vIfnXOjbt6/27dsnSfrjH90vKm7ovW24cBBQAMBHDRsmZWdLp061dk+aJiAgQOVnW3oeEAEFAHza5Mmt3QPg3GAOCgD4sJtuqvUyYJ9ijFFFRQWvOkEtjKAAgA/r2lWaP7+1e9F0kydP1uuvv97a3YAFEVAAAK0mODhYYWFh2rNnT2t3BRZDQAEAtKqxY8dqx44dPMGDapiDAgBodbNmzVJhYWFrdwMWQkABALS6oKAgBQUFtXY3YCHc4gEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJZDQAEAAJbjVUB57rnnNGTIEDmdTjmdTsXExGjLli2e/ceOHdO8efMUERGhwMBADRgwQM8991y1Y5SWlmr+/Pnq0qWLOnbsqKlTp+rQoUMtczUAAKBN8CqgREREaNmyZdq1a5d27dqlsWPHatq0adqzZ48k6a677lJKSorWrl2rL7/8UnfddZfmz5+vN99803OMhQsXKjk5WUlJSdqxY4eOHTuma6+9VhUVFS17ZQAAwGfZjDGmOQcIDg7W448/rvj4eEVHR2vmzJl64IEHPPuHDx+uyZMn6+GHH1ZRUZG6du2qNWvWaObMmZKkw4cPKzIyUps3b9bEiRMbdc7i4mK5XC4VFRXJ6XQ2p/sAAOA88eb3d5PnoFRUVCgpKUnHjx9XTEyMJGn06NHatGmTvv/+exljtG3bNuXk5HiCx+7du1VeXq4JEyZ4jhMeHq7o6Gjt3LmzznOVlpaquLi42gcAALRddm+/kJWVpZiYGP3888/q1KmTkpOTNXDgQEnSM888o9tvv10RERGy2+3y8/PTiy++qNGjR0uS8vLyFBAQoIsuuqjaMUNDQ5WXl1fnORMTE/Xggw9621UAAOCjvB5B6devnzIzM/XRRx/pjjvu0C233KL//Oc/ktwB5aOPPtKmTZu0e/duPfHEE5o7d67eeeedeo9pjJHNZqtz/5IlS1RUVOT5HDx40NtuAwAAH+L1CEpAQIB69+4tSRoxYoQ+/fRTPf3003rqqad03333KTk5WVOmTJEkDRkyRJmZmVq+fLni4uIUFhamsrIyFRQUVBtFyc/P16hRo+o8p8PhkMPh8LarAADARzV7HRRjjEpLS1VeXq7y8nL5+VU/ZLt27VRZWSnJPWHW399fqampnv25ubnKzs6uN6AAAIALi1cjKPfdd58mTZqkyMhIlZSUKCkpSWlpaUpJSZHT6VRsbKzuueceBQYGKioqSunp6Xr11Vf15JNPSpJcLpfi4+N19913KyQkRMHBwVq8eLEGDx6suLi4c3KBAADA93gVUI4cOaLZs2crNzdXLpdLQ4YMUUpKisaPHy9JSkpK0pIlS3TTTTfpp59+UlRUlP7yl79ozpw5nmOsWLFCdrtdM2bM0MmTJzVu3DitXr1a7dq1a9krAwAAPqvZ66C0BtZBAQDA95yXdVAAAADOFQIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHAIKAACwHK8CynPPPachQ4bI6XTK6XQqJiZGW7Zsqdbmyy+/1NSpU+VyuRQUFKQrrrhC3333nWd/aWmp5s+fry5duqhjx46aOnWqDh061DJXAwAA2gSvAkpERISWLVumXbt2adeuXRo7dqymTZumPXv2SJK++eYbjR49Wv3791daWpo+//xzPfDAA2rfvr3nGAsXLlRycrKSkpK0Y8cOHTt2TNdee60qKipa9soAAIDPshljTHMOEBwcrMcff1zx8fG64YYb5O/vrzVr1py1bVFRkbp27ao1a9Zo5syZkqTDhw8rMjJSmzdv1sSJExt1zuLiYrlcLhUVFcnpdDan+wAA4Dzx5vd3k+egVFRUKCkpScePH1dMTIwqKyv11ltvqW/fvpo4caK6deumkSNH6p///KfnO7t371Z5ebkmTJjg2RYeHq7o6Gjt3LmzznOVlpaquLi42gcAALRdXgeUrKwsderUSQ6HQ3PmzFFycrIGDhyo/Px8HTt2TMuWLdM111yjrVu3avr06br++uuVnp4uScrLy1NAQIAuuuiiascMDQ1VXl5enedMTEyUy+XyfCIjI73tNgAA8CF2b7/Qr18/ZWZmqrCwUBs2bNAtt9yi9PR0de7cWZI0bdo03XXXXZKkYcOGaefOnVq1apViY2PrPKYxRjabrc79S5Ys0aJFizw/FxcXE1IAAGjDvB5BCQgIUO/evTVixAglJiZq6NChevrpp9WlSxfZ7XYNHDiwWvsBAwZ4nuIJCwtTWVmZCgoKqrXJz89XaGhoned0OByeJ4eqPgAAoO1q9jooxhiVlpYqICBAl112mfbt21dtf05OjqKioiRJw4cPl7+/v1JTUz37c3NzlZ2drVGjRjW3KwAAoI3w6hbPfffdp0mTJikyMlIlJSVKSkpSWlqaUlJSJEn33HOPZs6cqTFjxug3v/mNUlJS9K9//UtpaWmSJJfLpfj4eN19990KCQlRcHCwFi9erMGDBysuLq7FLw4AAPgmrwLKkSNHNHv2bOXm5srlcmnIkCFKSUnR+PHjJUnTp0/XqlWrlJiYqDvvvFP9+vXThg0bNHr0aM8xVqxYIbvdrhkzZujkyZMaN26cVq9erXbt2rXslQEAAJ/V7HVQWgProAAA4HvOyzooAAAA5woBBQAAWA4BBQAAWA4BBQAAWA4BBQAAWA4BBQAAWA4BBQAAWA4BBQAAWA4BBQAAWA4BBQAAWA4BBQAAWA4BBQAAWA4BBQAAWA4BBQAAWA4BBQAAWA4BBQAAWA4BBQAAWA4BBQAAWI69tTvQFMYYSVJxcXEr9wQAADRW1e/tqt/j9fHJgFJSUiJJioyMbOWeAAAAb5WUlMjlctXbxmYaE2MsprKyUocPH1ZQUJBsNluLHru4uFiRkZE6ePCgnE5nix67raBGp1GLhlGj+lGfhlGjuvlabYwxKikpUXh4uPz86p9l4pMjKH5+foqIiDin53A6nT7xL7s1UaPTqEXDqFH9qE/DqFHdfKk2DY2cVGGSLAAAsBwCCgAAsBwCSg0Oh0NLly6Vw+Fo7a5YFjU6jVo0jBrVj/o0jBrVrS3XxicnyQIAgLaNERQAAGA5BBQAAGA5BBQAAGA5BBQAAGA5BBQAAGA5PhFQEhMTddlllykoKEjdunXTddddp3379lVrY4xRQkKCwsPDFRgYqKuvvlp79uyp1uaFF17Q1VdfLafTKZvNpsLCwlrnysnJ0bRp09SlSxc5nU5deeWV2rZtW4N9zMrKUmxsrAIDA9WjRw899NBD1V6GlJubq1mzZqlfv37y8/PTwoULm1SLurSFGm3cuFHjx49X165d5XQ6FRMTo7fffvuCrMWOHTt05ZVXKiQkRIGBgerfv79WrFjhdS3q0hZqdKYPPvhAdrtdw4YNa3QN6tMW6pOWliabzVbrs3fv3qYVpYa2UCNJKi0t1f3336+oqCg5HA716tVLL730kvcFOUNbqM2tt9561j8/gwYNalpRmsL4gIkTJ5qXX37ZZGdnm8zMTDNlyhTzq1/9yhw7dszTZtmyZSYoKMhs2LDBZGVlmZkzZ5ru3bub4uJiT5sVK1aYxMREk5iYaCSZgoKCWufq3bu3mTx5svn8889NTk6OmTt3runQoYPJzc2ts39FRUUmNDTU3HDDDSYrK8ts2LDBBAUFmeXLl3vaHDhwwNx5553mlVdeMcOGDTMLFixokdpUaQs1WrBggXn00UfNJ598YnJycsySJUuMv7+/+eyzzy64Wnz22Wdm3bp1Jjs72xw4cMCsWbPGdOjQwTz//PNe1aIt16hKYWGh6dmzp5kwYYIZOnRos+pSpS3UZ9u2bUaS2bdvn8nNzfV8Tp06RY3OMHXqVDNy5EiTmppqDhw4YD7++GPzwQcfXPC1KSwsrPbn5uDBgyY4ONgsXbq0WbXxhk8ElJry8/ONJJOenm6MMaaystKEhYWZZcuWedr8/PPPxuVymVWrVtX6ftV/uDX/ZR89etRIMtu3b/dsKy4uNpLMO++8U2d/Vq5caVwul/n555892xITE014eLiprKys1T42NrbFA0pNvl6jKgMHDjQPPvhgg9dbn7ZSi+nTp5ubb765wettCl+u0cyZM82f//xns3Tp0hYLKDX5Yn3qOue54os12rJli3G5XObHH39s0jU3li/Wpqbk5GRjs9nMt99+26hrbgk+cYunpqKiIklScHCwJOnAgQPKy8vThAkTPG0cDodiY2O1c+fORh83JCREAwYM0Kuvvqrjx4/r1KlTev755xUaGqrhw4fX+b0PP/xQsbGx1Vbymzhxog4fPqxvv/3Wy6trGW2hRpWVlSopKfFcQ1O1hVpkZGRo586dio2NbXT/vOGrNXr55Zf1zTffaOnSpY3uU1P4an0k6dJLL1X37t01bty4Rg39N5Uv1mjTpk0aMWKEHnvsMfXo0UN9+/bV4sWLdfLkSW8uvUG+WJua/vGPfyguLk5RUVGN7l9z+dzbjI0xWrRokUaPHq3o6GhJUl5eniQpNDS0WtvQ0FD997//bfSxbTabUlNTNW3aNAUFBcnPz0+hoaFKSUlR586d6/xeXl6eLr744lrnrtp3ySWXNLoPLaGt1OiJJ57Q8ePHNWPGjEb3ryZfr0VERISOHj2qU6dOKSEhQbfddluj+9dYvlqjr776Svfee6/ef/992e3n7n9lvlqf7t2764UXXtDw4cNVWlqqNWvWaNy4cUpLS9OYMWMa3cfG8NUa7d+/Xzt27FD79u2VnJysH374QXPnztVPP/3U7HkoVXy1NmfKzc3Vli1btG7dukb3rSX43AjKvHnz9MUXX2j9+vW19tlstmo/G2NqbauPMUZz585Vt27d9P777+uTTz7RtGnTdO211yo3N1eSNGjQIHXq1EmdOnXSpEmT6j332bafD22hRuvXr1dCQoJef/11devWrdH9q8nXa/H+++9r165dWrVqlZ566qmzXkdz+WKNKioqNGvWLD344IPq27dvo/vTFL5YH0nq16+fbr/9dv36179WTEyMVq5cqSlTpmj58uWN7l9j+WqNKisrZbPZ9Nprr+nyyy/X5MmT9eSTT2r16tUtNoriq7U50+rVq9W5c2ddd911je5bS/CpEZT58+dr06ZN2r59uyIiIjzbw8LCJLmTX/fu3T3b8/PzayXU+rz33nv697//rYKCAjmdTknSypUrlZqaqldeeUX33nuvNm/erPLycklSYGCg5/xVifjMc0u1E/K51hZq9Prrrys+Pl5vvPGG4uLiGt23mtpCLar+JjN48GAdOXJECQkJuvHGGxvdx4b4ao1KSkq0a9cuZWRkaN68eZLcv2yMMbLb7dq6davGjh3rbTlq8dX61OWKK67Q2rVrG92/xvDlGnXv3l09evSQy+XytBkwYICMMTp06JD69OnT6H6ejS/XpooxRi+99JJmz56tgICARvetJfjECIoxRvPmzdPGjRv13nvv1Rp+uuSSSxQWFqbU1FTPtrKyMqWnp2vUqFGNPs+JEyckSX5+1cvi5+enyspKSVJUVJR69+6t3r17q0ePHpKkmJgYbd++XWVlZZ7vbN26VeHh4bWG0c6VtlKj9evX69Zbb9W6des0ZcqURvfrTG2lFme7rtLS0kb3rz6+XiOn06msrCxlZmZ6PnPmzFG/fv2UmZmpkSNHeleQGny9PnXJyMio9guxOdpCja688kodPnxYx44d87TJycmRn59ftUDhrbZQmyrp6en6+uuvFR8f3+h+tZhzOAG3xdxxxx3G5XKZtLS0ao89nThxwtNm2bJlxuVymY0bN5qsrCxz44031npkKzc312RkZJi///3vnpnPGRkZnhncR48eNSEhIeb66683mZmZZt++fWbx4sXG39/fZGZm1tm/wsJCExoaam688UaTlZVlNm7caJxOZ63H2TIyMkxGRoYZPny4mTVrlsnIyDB79uyhRr9Yt26dsdvt5m9/+1u1aygsLLzgavHXv/7VbNq0yeTk5JicnBzz0ksvGafTae6//36vatGWa1RTSz7F0xbqs2LFCpOcnGxycnJMdna2uffee40ks2HDBmr0i5KSEhMREWF+97vfmT179pj09HTTp08fc9ttt13wtaly8803m5EjRzarHk3lEwFF0lk/L7/8sqdNZWWlWbp0qQkLCzMOh8OMGTPGZGVlVTvO0qVLGzzOp59+aiZMmGCCg4NNUFCQueKKK8zmzZsb7OMXX3xhrrrqKuNwOExYWJhJSEio9bjW2c4dFRXVnNLUe2xfq1FsbOxZz33LLbdccLV45plnzKBBg0yHDh2M0+k0l156qVm5cqWpqKjwqhZ1aQs1qqklA0pbqM+jjz5qevXqZdq3b28uuugiM3r0aPPWW281uzZV2kKNjDHmyy+/NHFxcSYwMNBERESYRYsWVQsSF3JtCgsLTWBgoHnhhReaVY+mshlTx9KMAAAArcQn5qAAAIALCwEFAABYDgEFAABYDgEFAABYDgEFAABYDgEFAABYDgEFAABYDgEFAABYDgEFAABYDgEFAABYDgEFAABYzv8DQ8IGmro6xlIAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Torfhaus_147\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Torfhaus_147 (Time: 12:00-17:00): 3.998937935495093\n", + "RMSE_postTorfhaus_147 (Time: 12:00-17:00): 4.489716974157919\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Trainou_180\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Trainou_180 (Time: 12:00-17:00): 5.159534798350454\n", + "RMSE_postTrainou_180 (Time: 12:00-17:00): 4.923588524152613\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Weybourne_10\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Weybourne_10 (Time: 12:00-17:00): 5.8042357282085035\n", + "RMSE_postWeybourne_10 (Time: 12:00-17:00): 5.08702918420633\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Zugspitze_3\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "RMSE for Zugspitze_3 (Time: 0:00-7:00): 2.3292844063210065\n", + "RMSE_postZugspitze_3 (Time: 0:00-7:00): 2.067792045155942\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Beromunster_212': 4.870704337914896, 'Bilsdale_248': 4.099240961889037, 'Biscarrosse_47': 3.6286698363772114, 'Cabauw_207': 4.441601923449455, 'Carnsore Point_14': 4.2323680010387, 'Ersa_40': 4.041720081809645, 'Gartow_341': 4.020367181920504, 'Heidelberg_30': 5.68847108073695, 'Hohenpeissenberg_131': 4.522767198933845, 'Hyltemossa_150': 4.091151868767758, 'Ispra_100': 7.264604784380843, 'Jungfraujoch_13': 2.09259671004597, 'Karlsruhe_200': 5.704734083738697, 'Kresin u Pacova_250': 4.39203849153931, 'Heathfield_100': 4.787743529281923, 'La Muela_80': 3.057698787110178, 'Laegern-Hochwacht_32': 6.947796727083331, 'Lindenberg_98': 4.444045744708574, 'Lutjewad_60': 5.027118560017733, 'Monte Cimone_8': 2.959680174567201, 'Observatoire de Haute Provence_100': 3.4017750652349736, \"Observatoire perenne de l'environnement_120\": 5.016921877327441, 'Pic du Midi_28': 2.0063922680970365, 'Plateau Rosa_10': 1.9134055189671928, 'Puy de Dome_10': 4.1369019254444925, 'Ridge Hill_90': 4.47760216030187, 'Saclay_100': 5.417616123397512, 'Schauinsland_12': 4.13354979667175, 'Tacolneston_185': 5.104249912485458, 'Torfhaus_147': 3.998937935495093, 'Trainou_180': 5.159534798350454, 'Weybourne_10': 5.8042357282085035, 'Zugspitze_3': 2.3292844063210065}\n" + ] + } + ], + "source": [ + "import xarray as xr\n", + "import matplotlib.pyplot as plt\n", + "from unidecode import unidecode\n", + "import numpy as np\n", + "import datetime as dt\n", + "import pandas as pd\n", + "\n", + "# Station dictionary with measurement uncertainty\n", + "mdm_dictionary = {\n", + " 'Beromunster_212': 8.2383423, 'Bilsdale_248': 5.8534036, 'Biscarrosse_47': 5.5997221,\n", + " 'Cabauw_207': 8.6093283, 'Carnsore Point_14': 4.1894007, 'Ersa_40': 4.3997285,\n", + " 'Gartow_341': 6.570544, 'Heidelberg_30': 10.660628, 'Hohenpeissenberg_131': 6.0553513,\n", + " 'Hyltemossa_150': 5.485432, 'Ispra_100': 11.612817, 'Jungfraujoch_13': 3.0802848,\n", + " 'Karlsruhe_200': 10.05013, 'Kresin u Pacova_250': 5.829324, 'Heathfield_100': 6.6675706,\n", + " 'La Muela_80': 5.2093291, 'Laegern-Hochwacht_32': 11.556924, 'Lindenberg_98': 7.4387555,\n", + " 'Lutjewad_60': 7.651525, 'Monte Cimone_8': 3.7325112,\n", + " 'Observatoire de Haute Provence_100': 6.146905,\n", + " \"Observatoire perenne de l'environnement_120\": 8.8854113, 'Pic du Midi_28': 3.2196398,\n", + " 'Plateau Rosa_10': 3.3211231, 'Puy de Dome_10': 5.4529948, 'Ridge Hill_90': 7.0861707,\n", + " 'Saclay_100': 8.8669567, 'Schauinsland_12': 5.7896755, 'Tacolneston_185': 6.6675706,\n", + " 'Torfhaus_147': 6.622525, 'Trainou_180': 7.821612, 'Weybourne_10': 6.4674397,\n", + " 'Zugspitze_3': 3.6796716,\n", + "}\n", + "\n", + "rmse_post = {}\n", + "\n", + "# Stations using the midnight-to-morning window (00:00 - 07:00)\n", + "nighttime_stations = {\n", + " 'Jungfraujoch_13', 'Monte Cimone_8', 'Puy de Dome_10', 'Pic du Midi_28', 'Zugspitze_3',\n", + " 'Hohenpeissenberg_131', 'Schauinsland_12', 'Plateau Rosa_10'\n", + "}\n", + "\n", + "resample = True\n", + "\n", + "for selected_station in mdm_dictionary.keys():\n", + " print(f\"Processing station: {selected_station}\")\n", + "\n", + " # Reset start and end date for each station\n", + " startdate = dt.datetime(2018, 1, 1)\n", + " enddate = dt.datetime(2018, 12, 17)\n", + "\n", + " # Reset data storage for each station\n", + " ICON_values = []\n", + " ICOS_values = []\n", + " post_values = []\n", + " ICON_dates = []\n", + " ICOS_dates = []\n", + "\n", + " # Identify which time window to use\n", + " if selected_station in nighttime_stations:\n", + " time_start = 0 # 00:00\n", + " time_end = 7 # 07:00\n", + " else:\n", + " time_start = 12 # 12:00\n", + " time_end = 17 # 17:00\n", + "\n", + " while startdate < enddate:\n", + " try:\n", + " ICON = xr.open_dataset(f\"/capstor/scratch/cscs/ekoene/extracted_ICOS/runthrough_{startdate.strftime('%Y%m%d')}.nc\")\n", + " ICONopt = xr.open_dataset(f\"/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_{startdate.strftime('%Y%m%d')}.nc\")\n", + " ICOS = xr.open_dataset(f\"/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_inputs/ICOS/Extracted_{startdate.strftime('%Y%m%d')}_{(startdate+dt.timedelta(days=11)).strftime('%Y%m%d')}_alldates_masl.nc\")\n", + "\n", + " full = (ICON.TRCO2_A + ICON.TRCO2_BG + ICON.CO2_RA - ICON.CO2_GPP + ICON.biosource - ICON.biosink) / (1 - ICON.qv) * 28.97 / 44.01 * 1e6\n", + " post = (ICONopt[\"TRCO2_A_ENS\"][0,:,:].squeeze() + ICONopt.biosource - ICONopt.biosink) / (1 - ICONopt.qv) * 28.97 / 44.01 * 1e6\n", + " \n", + " stations = np.array([unidecode(x) for x in ICON.site_name.values])\n", + " stations_post = np.array([unidecode(x) for x in ICONopt.site_name.values])\n", + " mdm_keys = np.array([unidecode(k) for k in mdm_dictionary.keys()])\n", + "\n", + " # Ensure the station exists\n", + " if selected_station not in mdm_keys:\n", + " raise ValueError(f\"Station '{selected_station}' not found in mdm_dictionary\")\n", + "\n", + " # Get the station index\n", + " station_index = np.where(stations == selected_station)[0]\n", + " if len(station_index) == 0:\n", + " print(f\"Skipping {selected_station}: Not found in ICON dataset on {startdate}\")\n", + " startdate += dt.timedelta(days=10)\n", + " continue\n", + " station_index = station_index[0]\n", + "\n", + " # Get the station index\n", + " station_index_post = np.where(stations_post == selected_station)[0]\n", + " if len(station_index_post) == 0:\n", + " print(f\"Skipping {selected_station}: Not found in ICON dataset on {startdate}\")\n", + " startdate += dt.timedelta(days=10)\n", + " continue\n", + " station_index_post = station_index_post[0]\n", + "\n", + " # Filter by time range\n", + " # Ensure time is in datetime64 format\n", + " ICON_times = ICON.time.values.astype('datetime64[h]')[24:] # Convert to hourly datetime\n", + "\n", + " # Extract the hours using numpy\n", + " time_hours = np.array([t.astype(object).hour for t in ICON_times]) \n", + " time_mask = (time_hours >= time_start) & (time_hours < time_end)\n", + "\n", + " full['time'] = pd.DatetimeIndex(full['time'].values)\n", + " post['time'] = pd.DatetimeIndex(post['time'].values)\n", + " ICOS[\"time\"] = pd.DatetimeIndex(ICOS.Dates[0].values)\n", + " full = full.isel(sites=station_index)[24:]\n", + " post = post.isel(sites=station_index_post)[24:]\n", + " ICOS = ICOS.Concentration.isel(station=station_index)\n", + " if selected_station in nighttime_stations:\n", + " full = full.sel(time=full.time.dt.hour.isin([0, 1, 2, 3, 4, 5, 6, 7]))\n", + " post = post.sel(time=post.time.dt.hour.isin([0, 1, 2, 3, 4, 5, 6, 7]))\n", + " ICOS = ICOS.sel(time=ICOS.time.dt.hour.isin([0, 1, 2, 3, 4, 5, 6, 7]))\n", + " else:\n", + " full = full.sel(time=full.time.dt.hour.isin([12, 13, 14, 15, 16]))\n", + " post = post.sel(time=post.time.dt.hour.isin([12, 13, 14, 15, 16]))\n", + " ICOS = ICOS.sel(time=ICOS.time.dt.hour.isin([12, 13, 14, 15, 16]))\n", + " \n", + " if resample:\n", + " full = full.resample(time='D').mean(\"time\")\n", + " post = post.resample(time='D').mean(\"time\")\n", + " ICOS = ICOS.resample(time='D').mean(\"time\")\n", + "\n", + " ICON_values.append(full)\n", + " post_values.append(post)\n", + " ICOS_values.append(ICOS)\n", + " ICON_dates.append(full.time)\n", + " ICOS_dates.append(ICOS.time)\n", + "\n", + " except FileNotFoundError as e:\n", + " print(f\"Skipping date {startdate} due to missing file: {e}\")\n", + "\n", + " except Exception as e:\n", + " print(f\"Error on {startdate}: {e}\")\n", + "\n", + " startdate += dt.timedelta(days=10)\n", + "\n", + " # Flatten arrays\n", + " ICON_values = np.asarray(ICON_values).flatten()\n", + " post_values = np.asarray(post_values).flatten()\n", + " ICOS_values = np.asarray(ICOS_values).flatten()\n", + " ICON_dates = np.asarray(ICON_dates).flatten()\n", + " ICOS_dates = np.asarray(ICOS_dates).flatten()\n", + "\n", + " if len(ICON_values) == 0 or len(ICOS_values) == 0:\n", + " print(f\"No data available for station {selected_station}\")\n", + " continue\n", + "\n", + " # Align datasets by timestamps\n", + " common_dates, icon_idx, icos_idx = np.intersect1d(ICON_dates, ICOS_dates, return_indices=True)\n", + "\n", + " icon_common = ICON_values[icon_idx]\n", + " post_common = post_values[icon_idx]\n", + " icos_common = ICOS_values[icos_idx]\n", + "\n", + " # Remove NaN values\n", + " valid_mask = ~np.isnan(icos_common)\n", + " icon_valid = icon_common[valid_mask]\n", + " post_valid = post_common[valid_mask]\n", + " icos_valid = icos_common[valid_mask]\n", + "\n", + " # Calculate RMSE\n", + " rmse = np.sqrt(np.mean((icon_valid - icos_valid) ** 2))\n", + " print(f\"RMSE for {selected_station} (Time: {time_start}:00-{time_end}:00): {rmse}\")\n", + " mdm_dictionary[selected_station] = rmse\n", + " rmse = np.sqrt(np.mean((post_valid - icos_valid) ** 2))\n", + " print(f\"RMSE_post{selected_station} (Time: {time_start}:00-{time_end}:00): {rmse}\")\n", + " rmse_post[selected_station] = rmse\n", + " # Plot results\n", + " plt.plot(ICON_dates, ICON_values, 'r', linewidth=0.5)\n", + " plt.plot(ICON_dates, post_values, 'b', linewidth=0.5)\n", + " plt.plot(ICOS_dates, ICOS_values, 'k', linewidth=0.25)\n", + " plt.legend([\"ICON (prior)\", \"ICON (posterior)\", \"ICOS\"])\n", + " plt.ylim([350, 490])\n", + " plt.title(f\"{selected_station} ({time_start}:00-{time_end}:00)\")\n", + " plt.show()\n", + "print(mdm_dictionary)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing station: Beromunster_212\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Bilsdale_248\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Biscarrosse_47\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Cabauw_207\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Carnsore Point_14\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Ersa_40\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-01 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-11 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping Ersa_40: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Gartow_341\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Heidelberg_30\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Hohenpeissenberg_131\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Hyltemossa_150\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Ispra_100\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Jungfraujoch_13\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Karlsruhe_200\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Kresin u Pacova_250\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Heathfield_100\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: La Muela_80\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-03-12 00:00:00\n", + "Skipping La Muela_80: Not found in ICON dataset on 2018-03-22 00:00:00\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Laegern-Hochwacht_32\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-01 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-11 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-05-11 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-05-21 00:00:00\n", + "Skipping Laegern-Hochwacht_32: Not found in ICON dataset on 2018-05-31 00:00:00\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Lindenberg_98\n", + "Skipping Lindenberg_98: Not found in ICON dataset on 2018-04-01 00:00:00\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Lutjewad_60\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Monte Cimone_8\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-01 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-11 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-03-12 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-03-22 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-04-01 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-04-11 00:00:00\n", + "Skipping Monte Cimone_8: Not found in ICON dataset on 2018-04-21 00:00:00\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Observatoire de Haute Provence_100\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Observatoire perenne de l'environnement_120\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Pic du Midi_28\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-01-21 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-01-31 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-02-10 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-02-20 00:00:00\n", + "Skipping Pic du Midi_28: Not found in ICON dataset on 2018-03-02 00:00:00\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Plateau Rosa_10\n", + "Skipping Plateau Rosa_10: Not found in ICON dataset on 2018-04-21 00:00:00\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Puy de Dome_10\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Ridge Hill_90\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Saclay_100\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Schauinsland_12\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Tacolneston_185\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Torfhaus_147\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Trainou_180\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Weybourne_10\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Zugspitze_3\n", + "Skipping date 2018-07-10 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180710.nc'\n", + "Skipping date 2018-07-20 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180720.nc'\n", + "Skipping date 2018-07-30 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180730.nc'\n", + "Skipping date 2018-08-09 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180809.nc'\n", + "Skipping date 2018-08-19 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180819.nc'\n", + "Skipping date 2018-08-29 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180829.nc'\n", + "Skipping date 2018-09-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180908.nc'\n", + "Skipping date 2018-09-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180918.nc'\n", + "Skipping date 2018-09-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20180928.nc'\n", + "Skipping date 2018-10-08 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181008.nc'\n", + "Skipping date 2018-10-18 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181018.nc'\n", + "Skipping date 2018-10-28 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181028.nc'\n", + "Skipping date 2018-11-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181107.nc'\n", + "Skipping date 2018-11-17 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181117.nc'\n", + "Skipping date 2018-11-27 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181127.nc'\n", + "Skipping date 2018-12-07 00:00:00 due to missing file: [Errno 2] No such file or directory: '/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_20181207.nc'\n", + "Processing station: Beromunster_212 for the MDM correlations\n", + "Processing station: Bilsdale_248 for the MDM correlations\n", + "Processing station: Biscarrosse_47 for the MDM correlations\n", + "Processing station: Cabauw_207 for the MDM correlations\n", + "Processing station: Carnsore Point_14 for the MDM correlations\n", + "Processing station: Ersa_40 for the MDM correlations\n", + "Processing station: Gartow_341 for the MDM correlations\n", + "Processing station: Heidelberg_30 for the MDM correlations\n", + "Processing station: Hohenpeissenberg_131 for the MDM correlations\n", + "Processing station: Hyltemossa_150 for the MDM correlations\n", + "Processing station: Ispra_100 for the MDM correlations\n", + "Processing station: Jungfraujoch_13 for the MDM correlations\n", + "Processing station: Karlsruhe_200 for the MDM correlations\n", + "Processing station: Kresin u Pacova_250 for the MDM correlations\n", + "Processing station: Heathfield_100 for the MDM correlations\n", + "Processing station: La Muela_80 for the MDM correlations\n", + "Processing station: Laegern-Hochwacht_32 for the MDM correlations\n", + "Processing station: Lindenberg_98 for the MDM correlations\n", + "Processing station: Lutjewad_60 for the MDM correlations\n", + "Processing station: Monte Cimone_8 for the MDM correlations\n", + "Processing station: Observatoire de Haute Provence_100 for the MDM correlations\n", + "Processing station: Observatoire perenne de l'environnement_120 for the MDM correlations\n", + "Processing station: Pic du Midi_28 for the MDM correlations\n", + "Processing station: Plateau Rosa_10 for the MDM correlations\n", + "Processing station: Puy de Dome_10 for the MDM correlations\n", + "Processing station: Ridge Hill_90 for the MDM correlations\n", + "Processing station: Saclay_100 for the MDM correlations\n", + "Processing station: Schauinsland_12 for the MDM correlations\n", + "Processing station: Tacolneston_185 for the MDM correlations\n", + "Processing station: Torfhaus_147 for the MDM correlations\n", + "Processing station: Trainou_180 for the MDM correlations\n", + "Processing station: Weybourne_10 for the MDM correlations\n", + "Processing station: Zugspitze_3 for the MDM correlations\n" + ] + } + ], + "source": [ + "import xarray as xr\n", + "import matplotlib.pyplot as plt\n", + "from unidecode import unidecode\n", + "import numpy as np\n", + "import datetime as dt\n", + "import pandas as pd\n", + "\n", + "# Station dictionary with measurement uncertainty\n", + "mdm_dictionary = {\n", + " 'Beromunster_212': 8.2383423, 'Bilsdale_248': 5.8534036, 'Biscarrosse_47': 5.5997221,\n", + " 'Cabauw_207': 8.6093283, 'Carnsore Point_14': 4.1894007, 'Ersa_40': 4.3997285,\n", + " 'Gartow_341': 6.570544, 'Heidelberg_30': 10.660628, 'Hohenpeissenberg_131': 6.0553513,\n", + " 'Hyltemossa_150': 5.485432, 'Ispra_100': 11.612817, 'Jungfraujoch_13': 3.0802848,\n", + " 'Karlsruhe_200': 10.05013, 'Kresin u Pacova_250': 5.829324, 'Heathfield_100': 6.6675706,\n", + " 'La Muela_80': 5.2093291, 'Laegern-Hochwacht_32': 11.556924, 'Lindenberg_98': 7.4387555,\n", + " 'Lutjewad_60': 7.651525, 'Monte Cimone_8': 3.7325112,\n", + " 'Observatoire de Haute Provence_100': 6.146905,\n", + " \"Observatoire perenne de l'environnement_120\": 8.8854113, 'Pic du Midi_28': 3.2196398,\n", + " 'Plateau Rosa_10': 3.3211231, 'Puy de Dome_10': 5.4529948, 'Ridge Hill_90': 7.0861707,\n", + " 'Saclay_100': 8.8669567, 'Schauinsland_12': 5.7896755, 'Tacolneston_185': 6.6675706,\n", + " 'Torfhaus_147': 6.622525, 'Trainou_180': 7.821612, 'Weybourne_10': 6.4674397,\n", + " 'Zugspitze_3': 3.6796716,\n", + "}\n", + "\n", + "rmse_post = {}\n", + "\n", + "# Stations using the midnight-to-morning window (00:00 - 07:00)\n", + "nighttime_stations = {\n", + " 'Jungfraujoch_13', 'Monte Cimone_8', 'Puy de Dome_10', 'Pic du Midi_28', 'Zugspitze_3',\n", + " 'Hohenpeissenberg_131', 'Schauinsland_12', 'Plateau Rosa_10'\n", + "}\n", + "\n", + "resample = True\n", + "mdm_dict = {}\n", + "station_times_dict = {}\n", + "\n", + "for selected_station in mdm_dictionary.keys():\n", + " print(f\"Processing station: {selected_station}\")\n", + "\n", + " # Reset start and end date for each station\n", + " startdate = dt.datetime(2018, 1, 1)\n", + " enddate = dt.datetime(2018, 12, 17)\n", + "\n", + " # Reset data storage for each station\n", + " ICON_values = []\n", + " ICOS_values = []\n", + " post_values = []\n", + " ICON_dates = []\n", + " ICOS_dates = []\n", + "\n", + " # Identify which time window to use\n", + " if selected_station in nighttime_stations:\n", + " time_start = 0 # 00:00\n", + " time_end = 7 # 07:00\n", + " else:\n", + " time_start = 12 # 12:00\n", + " time_end = 17 # 17:00\n", + "\n", + " while startdate < enddate:\n", + " try:\n", + " ICON = xr.open_dataset(f\"/capstor/scratch/cscs/ekoene/extracted_ICOS/runthrough_{startdate.strftime('%Y%m%d')}.nc\")\n", + " ICONopt = xr.open_dataset(f\"/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_outputs/extracted_ICOS/opt2_{startdate.strftime('%Y%m%d')}.nc\")\n", + " ICOS = xr.open_dataset(f\"/capstor/scratch/cscs/ekoene/processing-chain/work/icon-art-CTDAS/global_inputs/ICOS/Extracted_{startdate.strftime('%Y%m%d')}_{(startdate+dt.timedelta(days=11)).strftime('%Y%m%d')}_alldates_masl.nc\")\n", + "\n", + " full = (ICON.TRCO2_A + ICON.TRCO2_BG + ICON.CO2_RA - ICON.CO2_GPP + ICON.biosource - ICON.biosink) / (1 - ICON.qv) * 28.97 / 44.01 * 1e6\n", + " post = (ICONopt[\"TRCO2_A_ENS\"][0,:,:].squeeze() + ICONopt.biosource - ICONopt.biosink) / (1 - ICONopt.qv) * 28.97 / 44.01 * 1e6\n", + " \n", + " stations = np.array([unidecode(x) for x in ICON.site_name.values])\n", + " stations_post = np.array([unidecode(x) for x in ICONopt.site_name.values])\n", + " mdm_keys = np.array([unidecode(k) for k in mdm_dictionary.keys()])\n", + "\n", + " # Ensure the station exists\n", + " if selected_station not in mdm_keys:\n", + " raise ValueError(f\"Station '{selected_station}' not found in mdm_dictionary\")\n", + "\n", + " # Get the station index\n", + " station_index = np.where(stations == selected_station)[0]\n", + " if len(station_index) == 0:\n", + " print(f\"Skipping {selected_station}: Not found in ICON dataset on {startdate}\")\n", + " startdate += dt.timedelta(days=10)\n", + " continue\n", + " station_index = station_index[0]\n", + "\n", + " # Get the station index\n", + " station_index_post = np.where(stations_post == selected_station)[0]\n", + " if len(station_index_post) == 0:\n", + " print(f\"Skipping {selected_station}: Not found in ICON dataset on {startdate}\")\n", + " startdate += dt.timedelta(days=10)\n", + " continue\n", + " station_index_post = station_index_post[0]\n", + "\n", + " # Filter by time range\n", + " # Ensure time is in datetime64 format\n", + " ICON_times = ICON.time.values.astype('datetime64[h]')[24:] # Convert to hourly datetime\n", + "\n", + " # Extract the hours using numpy\n", + " time_hours = np.array([t.astype(object).hour for t in ICON_times]) \n", + " time_mask = (time_hours >= time_start) & (time_hours < time_end)\n", + "\n", + " full['time'] = pd.DatetimeIndex(full['time'].values)\n", + " post['time'] = pd.DatetimeIndex(post['time'].values)\n", + " ICOS[\"time\"] = pd.DatetimeIndex(ICOS.Dates[0].values)\n", + " full = full.isel(sites=station_index)[24:]\n", + " post = post.isel(sites=station_index_post)[24:]\n", + " ICOS = ICOS.Concentration.isel(station=station_index)\n", + " if selected_station in nighttime_stations:\n", + " full = full.sel(time=full.time.dt.hour.isin([0, 1, 2, 3, 4, 5, 6, 7]))\n", + " post = post.sel(time=post.time.dt.hour.isin([0, 1, 2, 3, 4, 5, 6, 7]))\n", + " ICOS = ICOS.sel(time=ICOS.time.dt.hour.isin([0, 1, 2, 3, 4, 5, 6, 7]))\n", + " else:\n", + " full = full.sel(time=full.time.dt.hour.isin([12, 13, 14, 15, 16]))\n", + " post = post.sel(time=post.time.dt.hour.isin([12, 13, 14, 15, 16]))\n", + " ICOS = ICOS.sel(time=ICOS.time.dt.hour.isin([12, 13, 14, 15, 16]))\n", + " \n", + " if resample:\n", + " full = full.resample(time='D').mean(\"time\")\n", + " post = post.resample(time='D').mean(\"time\")\n", + " ICOS = ICOS.resample(time='D').mean(\"time\")\n", + "\n", + " ICON_values.append(full)\n", + " post_values.append(post)\n", + " ICOS_values.append(ICOS)\n", + " ICON_dates.append(full.time)\n", + " ICOS_dates.append(ICOS.time)\n", + "\n", + " except FileNotFoundError as e:\n", + " print(f\"Skipping date {startdate} due to missing file: {e}\")\n", + "\n", + " except Exception as e:\n", + " print(f\"Error on {startdate}: {e}\")\n", + "\n", + " startdate += dt.timedelta(days=10)\n", + "\n", + " # Flatten arrays\n", + " ICON_values = np.asarray(ICON_values).flatten()\n", + " post_values = np.asarray(post_values).flatten()\n", + " ICOS_values = np.asarray(ICOS_values).flatten()\n", + " ICON_dates = np.asarray(ICON_dates).flatten()\n", + " ICOS_dates = np.asarray(ICOS_dates).flatten()\n", + "\n", + " if len(ICON_values) == 0 or len(ICOS_values) == 0:\n", + " print(f\"No data available for station {selected_station}\")\n", + " continue\n", + "\n", + " # Align datasets by timestamps\n", + " common_dates, icon_idx, icos_idx = np.intersect1d(ICON_dates, ICOS_dates, return_indices=True)\n", + "\n", + " icon_common = ICON_values[icon_idx]\n", + " post_common = post_values[icon_idx]\n", + " icos_common = ICOS_values[icos_idx]\n", + "\n", + " # Remove NaN values\n", + " valid_mask = ~np.isnan(icos_common)\n", + " icon_valid = icon_common[valid_mask]\n", + " post_valid = post_common[valid_mask]\n", + " icos_valid = icos_common[valid_mask]\n", + "\n", + " # Calculate RMSE\n", + " mdm_dict[selected_station] = post_valid - icos_valid\n", + " station_times_dict[selected_station] = ICON_dates[icon_idx][valid_mask]\n", + "\n", + "def compute_correlation(x, y):\n", + " \"\"\"\n", + " Manually compute the Pearson correlation coefficient between two variables x and y.\n", + " \"\"\"\n", + " # Mean of x and y\n", + " mean_x = np.mean(x)\n", + " mean_y = np.mean(y)\n", + "\n", + " # Compute the numerator and the denominator of the Pearson correlation formula\n", + " numerator = np.sum((x - mean_x) * (y - mean_y))\n", + " denominator = np.sqrt(np.sum((x - mean_x) ** 2) * np.sum((y - mean_y) ** 2))\n", + "\n", + " # Return the correlation coefficient\n", + " return numerator / denominator\n", + "\n", + "# Create a dictionary to store correlation values for all pairs of stations\n", + "correlation_results = {}\n", + "\n", + "# Iterate over all pairs of stations\n", + "for station_1 in mdm_dictionary:\n", + " print(f\"Processing station: {station_1} for the MDM correlations\")\n", + " for station_2 in mdm_dictionary:\n", + " # Get the overlapping times for station_1 and station_2\n", + " common_times = set(station_times_dict[station_1]) & set(station_times_dict[station_2])\n", + " \n", + " if common_times: # If there is any overlap\n", + " # Get the MDM values for the common times\n", + " mdm_1 = [mdm_dict[station_1][np.where(station_times_dict[station_1] == time)[0][0]] for time in common_times]\n", + " mdm_2 = [mdm_dict[station_2][np.where(station_times_dict[station_2] == time)[0][0]] for time in common_times]\n", + " \n", + " # Compute the correlation between the MDM values for this pair of stations\n", + " correlation = compute_correlation(np.array(mdm_1), np.array(mdm_2))\n", + " correlation_results[(station_1, station_2)] = correlation\n", + " else:\n", + " correlation_results[(station_1, station_2)] = np.nan\n", + "\n", + "station_names = list(mdm_dictionary.keys())\n", + "correlation_matrix = np.zeros((len(station_names), len(station_names)))\n", + "\n", + "# Fill the correlation matrix with the computed values\n", + "for i, station_1 in enumerate(station_names):\n", + " for j, station_2 in enumerate(station_names):\n", + " if station_1 != station_2:\n", + " # Get the correlation for the pair (station_1, station_2)\n", + " correlation = correlation_results.get((station_1, station_2), None)\n", + " if correlation is not None:\n", + " correlation_matrix[i, j] = correlation\n", + " else:\n", + " # If there's no correlation (no overlap), fill with NaN\n", + " correlation_matrix[i, j] = np.nan\n", + " else:\n", + " # Set the diagonal to 1 (100% correlation with itself)\n", + " correlation_matrix[i, j] = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "\n", + "plt.figure(figsize=(12, 10))\n", + "sns.heatmap(correlation_matrix, xticklabels=list(mdm_dictionary.keys()), yticklabels=list(mdm_dictionary.keys()), cmap='coolwarm', annot=True, fmt=\".2f\", annot_kws={\"fontsize\":6}, vmin=-1, vmax=1)\n", + "plt.title(\"Model-Data Mismatch (MDM) Correlation Matrix\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/cases/icon-art-CTDAS/ICON/ICON_template.job b/cases/icon-art-CTDAS/ICON/ICON_template.job index cd69ab29..06a21065 100644 --- a/cases/icon-art-CTDAS/ICON/ICON_template.job +++ b/cases/icon-art-CTDAS/ICON/ICON_template.job @@ -1,7 +1,7 @@ #!/bin/bash -l #SBATCH --uenv="icon-wcp/v1:rc4" #SBATCH --job-name="{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.forecasttime}" -#SBATCH --time=00:50:00 +#SBATCH --time={cfg.walltime_icon} #SBATCH --account={cfg.compute_account} #SBATCH --nodes={cfg.nodes} #SBATCH --ntasks-per-node={cfg.ntasks_per_node} diff --git a/cases/icon-art-CTDAS/config.yaml b/cases/icon-art-CTDAS/config.yaml index 911e1a52..3454ac57 100644 --- a/cases/icon-art-CTDAS/config.yaml +++ b/cases/icon-art-CTDAS/config.yaml @@ -63,6 +63,8 @@ tracers: # - rc-cteco2 file [which, ultimately, is how we pass general input like folder names etc to CTDAS] # - rc-job file [which, ultimately, is the setup for CTDAS like lag times, etc.] CTDAS: + project_name: ctdas_ICOS_OCO2 + job_time: '10:00:00' runthrough: True # If true, this makes the 'CTDAS' job run (1) CTDAS but also (2) a simulation for the full year without the ensemble members but with n_boundaries BG tracers nlag: 2 tracer: co2 @@ -220,7 +222,6 @@ CTDAS: covariancematrix[-n_bg_params + iii , -n_bg_params + iii] = 0.015 * 0.015 # 0.015 * 400 = 6 ppm stdev covariancematrix[-n_bg_params + (iii + 1) % n_bg_params, -n_bg_params + iii] = 0.015 * 0.015 * 0.25 # Neighbouring entries covariancematrix[-n_bg_params + (iii - 1) % n_bg_params, -n_bg_params + iii] = 0.015 * 0.015 * 0.25 # Neighbouring entries - job_time: 10:00:00 cdo_nco_cmd: | uenv start icon-wcp --ignore-tty << 'EOF' @@ -236,7 +237,7 @@ art_input_folder: ./input/icon-art-oem/ART walltime: prepare_icon: '00:15:00' prepare_art_global: '00:10:00' - icon: '00:05:00' + icon: '03:00:00' prepare_CTDAS: '00:00:00' meteo: @@ -266,14 +267,4 @@ input_files: icon: executable: /capstor/scratch/cscs/ekoene/tmp/spack-c2sm/spack/opt/spack/linux-sles15-neoverse_v2/nvhpc-24.3/icon-develop-sytqk6o7h5y3imrsevsswc2inxaegbpx/bin/icon - runjob_filename: ICON/ICON_template.job -# # era5_inijob: icon_era5_inicond.sh -# # era5_nudgingjob: icon_era5_nudging.sh -# species_inijob: icon_species_inicond.sh -# species_nudgingjob: icon_species_nudging.sh -# output_writing_step: 6 -# compute_queue: normal -# np_tot: 32 -# np_io: 3 -# np_restart: 1 -# np_prefetch: 1 \ No newline at end of file + runjob_filename: ICON/ICON_template.job \ No newline at end of file diff --git a/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py b/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py index 539d4334..b89add21 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py +++ b/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py @@ -273,10 +273,6 @@ def run(self, samples, statevector, lag): '_%s_opt2.job' % (self.dacycle['time.sample.stamp'][0:8])) self.outfolder = os.path.join('{cfg.case_root / "global_outputs"}', f"opt2_{{job_timestr}}") - finalfile = os.path.join( - self.outfolder, - f"ICON-ART-OEM-INIT_{{(time + dt.timedelta(seconds={cfg.CTDAS_restart_init_time}) + dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime('%Y-%m-%dT%H:%M:%S')}}.000.nc" - ) else: if lag == 0: runscript = os.path.join( @@ -286,10 +282,6 @@ def run(self, samples, statevector, lag): self.outfolder = os.path.join( '{cfg.case_root / "global_outputs"}', f"opt1_{{job_timestr}}") - finalfile = os.path.join( - self.outfolder, - f"ICON-ART-OEM-INIT_{{(time + dt.timedelta(seconds={cfg.CTDAS_restart_init_time}) + dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime('%Y-%m-%dT%H:%M:%S')}}.000.nc" - ) else: runscript = os.path.join( self.simulationdir, folder_timestr, 'icon', 'run', @@ -298,15 +290,10 @@ def run(self, samples, statevector, lag): self.outfolder = os.path.join( '{cfg.case_root / "global_outputs"}', f"prior_{{job_timestr}}") - finalfile = os.path.join( - self.outfolder, - f"ICON-ART-OEM-INIT_{{(time + dt.timedelta(seconds={cfg.CTDAS_restart_init_time}) + dt.timedelta(days={cfg.CTDAS_ctdas_cycle})).strftime('%Y-%m-%dT%H:%M:%S')}}.000.nc" - ) - while not (os.path.exists(finalfile)): - logging.info('runscript name: %s' % (runscript)) - start_icon(runscript) - logging.info('ICON done!') + logging.info('runscript name: %s' % (runscript)) + start_icon(runscript) + logging.info('ICON done!') def sample(self, samples, statevector, lag): for j, sample in enumerate(samples): @@ -653,35 +640,34 @@ class RandomizerObservationOperator(ObservationOperator): def wait_for_job(job_id): - """Wait for a job to complete.""" + """Wait for a job to complete and check if all states are COMPLETED.""" if not job_id: - return False + return False, "UNKNOWN" while True: result = subprocess.run( - f"sacct -j {{job_id}} --format=State --noheader", + f"sacct -j {job_id} --format=State --noheader", shell=True, capture_output=True, - text=True) - state = result.stdout.strip() + text=True + ) - if state: - if any(s in state - for s in ["COMPLETED", "FAILED", "CANCELLED", "TIMEOUT"]): - logging.info(f"Job {{job_id}} finished with state: {{state}}") - return state == "COMPLETED", state + # Extract all job states from the output + states = [s.strip() for s in result.stdout.split("\n") if s.strip()] + logging.info(f"Job {job_id} finished with states: {states}") - time.sleep(10) + if states: + if all(s == "COMPLETED" for s in states): + return True, "COMPLETED" + elif any(s in ["FAILED", "CANCELLED", "TIMEOUT"] for s in states): + return False, "FAILED" + time.sleep(10) def submit_job(command): """Submit a job and return the job ID.""" - logging.info(f"Running: {{command}}") - result = subprocess.run(command, - shell=True, - capture_output=True, - text=True, - check=False) + logging.info(f"Submitting job: {command}") + result = subprocess.run(command, shell=True, capture_output=True, text=True, check=False) match = re.search(r"Submitted batch job (\d+)", result.stdout) if match: @@ -690,31 +676,31 @@ def submit_job(command): logging.error("Failed to get job ID from sbatch output.") return None - def start_icon(runscript, max_retries=3): + """Start an ICON job, retrying if it fails.""" retries = 0 - while retries <= max_retries: - command = f"uenv run icon-wcp -- sbatch {{runscript}} --wait" - logging.info(f"Running ICON case job with {{command}}") + + while retries < max_retries: + command = f"uenv run icon-wcp -- sbatch {runscript} --wait" + logging.info(f"Starting ICON case job: {command}") job_id = submit_job(command) - logging.info(f"Running job ID {{job_id}}") + if not job_id: + logging.error("Failed to submit job.") + return False # Failed to even submit + + logging.info(f"Running job ID {job_id}") completed, state = wait_for_job(job_id) if completed: - return True - - if state in ["FAILED", "CANCELLED", "TIMEOUT"]: - retries += 1 - logging.warning( - f"Job failed with state {{state}}. Retrying {{retries}}/{{max_retries}}..." - ) - else: - break + return True # Job finished successfully - logging.error("ICON job failed after maximum retries.") - return False + # Job failed, retry if under max_retries + retries += 1 + logging.warning(f"Job failed with state {state}. Retrying {retries}/{max_retries}...") + logging.error(f"Job failed after {max_retries} retries.") + return False # Exhausted all retries if __name__ == "__main__": pass diff --git a/cases/icon-art-CTDAS/ctdas_patch/template.jb b/cases/icon-art-CTDAS/ctdas_patch/template.jb index 604f9fc5..43c0a80d 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/template.jb +++ b/cases/icon-art-CTDAS/ctdas_patch/template.jb @@ -13,4 +13,4 @@ export icycle_in_job=1 -python3 $SCRATCH/ctdas_procchain/exec/ctdas_procchain.py -v rc=$SCRATCH/ctdas_procchain/exec/ctdas_procchain.rc >& $SCRATCH/ctdas_procchain/exec/ctdas_procchain.log +python3 $SCRATCH/{cfg.CTDAS_project_name}/exec/{cfg.CTDAS_project_name}.py -v rc=$SCRATCH/{cfg.CTDAS_project_name}/exec/{cfg.CTDAS_project_name}.rc >& $SCRATCH/{cfg.CTDAS_project_name}/exec/{cfg.CTDAS_project_name}.log diff --git a/cases/icon-art-CTDAS/ctdas_patch/template.rc b/cases/icon-art-CTDAS/ctdas_patch/template.rc index 84facd43..6b2da364 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/template.rc +++ b/cases/icon-art-CTDAS/ctdas_patch/template.rc @@ -41,7 +41,7 @@ time.cycle : {cfg.CTDAS_ctdas_cycle} ! The number of cycles of lag to use for a smoother version of CTDAS. CarbonTracker CO2 typically uses 5 weeks of lag. Valid entries are integers > 0 -time.nlag : {cfg.CTDAS_ctdas_nlag} +time.nlag : {cfg.CTDAS_nlag} ! The directory under which the code, input, and output will be stored. This is the base directory for a run. The word ! '/' will be replaced through the start_ctdas.sh script by a user-specified folder name. DO NOT REPLACE diff --git a/cases/icon-art-CTDAS2/ICBC/icon_era5_inicond.sh b/cases/icon-art-CTDAS2/ICBC/icon_era5_inicond.sh deleted file mode 100644 index 55e66776..00000000 --- a/cases/icon-art-CTDAS2/ICBC/icon_era5_inicond.sh +++ /dev/null @@ -1,179 +0,0 @@ -#!/bin/bash - -cd {ERA5_folder} - -{cfg.cdo_nco_cmd} - -set -x - -# --------------------------------- -# -- Pre-processing -# --------------------------------- - -# -- Put all variables in the same file -cdo -O merge {era5_ml_file} {era5_surf_file} era5_original.nc - -# -- Change variable and coordinates names to be consistent with ICON nomenclature -cdo setpartabn,mypartab,convert era5_original.nc tmp.nc - -# -- Order the variables alphabetically -ncks -O tmp.nc data_in.nc -rm tmp.nc era5_original.nc - -# --------------------------------- -# -- Re-mapping -# --------------------------------- - -# -- Retrieve the dynamic horizontal grid -cdo -s selgrid,2 {cfg.input_files_scratch_dynamics_grid_filename} triangular-grid.nc - -# -- Create the weights for remapping ERA5 latlon grid onto the triangular grid -cdo gendis,triangular-grid.nc data_in.nc weights.nc - -# -- Extract the land-sea mask variable in input and output files -cdo selname,LSM data_in.nc LSM_in.nc -ncrename -h -v LSM,FR_LAND LSM_in.nc -cdo selname,FR_LAND {cfg.input_files_scratch_extpar_filename} LSM_out_tmp.nc - -# -- Add time dimension to LSM_out.nc -ncecat -O -u time LSM_out_tmp.nc LSM_out_tmp.nc -ncks -h -A -v time LSM_in.nc LSM_out_tmp.nc - -# -- Create two different files for land- and sea-mask -cdo -L setctomiss,0. -ltc,0.5 LSM_in.nc oceanmask_in.nc -cdo -L setctomiss,0. -gec,0.5 LSM_in.nc landmask_in.nc -cdo -L setctomiss,0. -ltc,0.5 LSM_out_tmp.nc oceanmask_out.nc -cdo -L setctomiss,0. -gec,0.5 LSM_out_tmp.nc landmask_out.nc -cdo setrtoc2,0.5,1.0,1,0 LSM_out_tmp.nc LSM_out.nc -rm LSM_in.nc LSM_out_tmp.nc - -# -- Select surface sea variables defined only on sea -ncks -O -h -v SST,CI data_in.nc datasea_in.nc - -# -- Select surface variables defined on both that must be remap differently on sea and on land -ncks -O -h -v SKT,STL1,STL2,STL3,STL4,ALB_SNOW,W_SNOW,T_SNOW data_in.nc dataland_in.nc - -# ----------------------------------------------------------------------------- -# -- Remap land and ocean area differently for variables -# ----------------------------------------------------------------------------- - -# -- Ocean part -# ----------------- - -# -- Apply the ocean mask (by dividing) -cdo div dataland_in.nc oceanmask_in.nc tmp1_land.nc -cdo div datasea_in.nc oceanmask_in.nc tmp1_sea.nc - -# -- Set missing values to a distance-weighted average -cdo setmisstodis tmp1_land.nc tmp2_land.nc -cdo setmisstodis tmp1_sea.nc tmp2_sea.nc - -# -- Remap -cdo remapdis,triangular-grid.nc tmp2_land.nc tmp3_land.nc -cdo remapdis,triangular-grid.nc tmp2_sea.nc tmp3_sea.nc - -# -- Apply the ocean mask to remapped variables (by dividing) -cdo div tmp3_land.nc oceanmask_out.nc dataland_ocean_out.nc -cdo div tmp3_sea.nc oceanmask_out.nc datasea_ocean_out.nc - -# -- Clean the repository -rm tmp*.nc oceanmask*.nc - -# # -- Land part -# # ----------------- - -cdo div dataland_in.nc landmask_in.nc tmp1.nc -cdo setmisstodis tmp1.nc tmp2.nc -cdo remapdis,triangular-grid.nc tmp2.nc tmp3.nc -cdo div tmp3.nc landmask_out.nc dataland_land_out.nc -rm tmp*.nc landmask*.nc dataland_in.nc datasea_in.nc - -# -- merge remapped land and ocean part -# -------------------------------------- - -cdo ifthenelse LSM_out.nc dataland_land_out.nc dataland_ocean_out.nc dataland_out.nc -rm dataland_ocean_out.nc dataland_land_out.nc - -# remap the rest and merge all files -# -------------------------------------- - -# -- Select all variables apart from these ones -ncks -O -h -x -v SKT,STL1,STL2,STL3,STL4,SMIL1,SMIL2,SMIL3,SMIL4,ALB_SNOW,W_SNOW,T_SNOW,SST,CI,LSM data_in.nc datarest_in.nc - -# -- Remap -cdo -s remapdis,triangular-grid.nc datarest_in.nc era5_final.nc -rm datarest_in.nc - -# -- Fill NaN values for SST and CI -cdo setmisstodis -selname,SST,CI datasea_ocean_out.nc dataland_ocean_out_filled.nc -rm datasea_ocean_out.nc - -# -- Merge remapped files plus land sea mask from EXTPAR -ncks -h -A dataland_out.nc era5_final.nc -ncks -h -A dataland_ocean_out_filled.nc era5_final.nc -ncks -h -A -v FR_LAND LSM_out.nc era5_final.nc -ncrename -h -v FR_LAND,LSM era5_final.nc -rm LSM_out.nc dataland_out.nc - -# ------------------------------------------------------------------------ -# -- Convert the (former) SWVLi variables to real soil moisture indices -# ------------------------------------------------------------------------ - -# -- Properties of IFS soil types (see Table 1 ERA5 Data documentation -# -- https://confluence.ecmwf.int/display/CKB/ERA5%3A+data+documentation) -# Soil type 1 2 3 4 5 6 7 -wiltingp=(0 0.059 0.151 0.133 0.279 0.335 0.267 0.151) # wilting point -fieldcap=(0 0.244 0.347 0.383 0.448 0.541 0.663 0.347) # field capacity - -ncks -O -h -v SMIL1,SMIL2,SMIL3,SMIL4,SLT data_in.nc swvl.nc -rm data_in.nc - -# -- Loop over the soil types and apply the right constants -smi_equation="" -for ilev in {{1..4}}; do - - smi_equation="${{smi_equation}}SMIL${{ilev}} = (SMIL${{ilev}} - ${{wiltingp[1]}}) / (${{fieldcap[1]}} - ${{wiltingp[1]}}) * (SLT==1)" - for ist in {{2..7}}; do - smi_equation="${{smi_equation}} + (SMIL${{ilev}} - ${{wiltingp[$ist]}}) / (${{fieldcap[$ist]}} - ${{wiltingp[$ist]}}) * (SLT==${{ist}})" - done - smi_equation="${{smi_equation}};" - -done - -cdo expr,"${{smi_equation}}" swvl.nc smil_in.nc -rm swvl.nc - -# -- Remap SMIL variables -cdo -s remapdis,triangular-grid.nc smil_in.nc smil_out.nc -rm smil_in.nc - -# -- Overwrite the variables SMIL1,SMIL2,SMIL3,SMIL4 -ncks -A -v SMIL1,SMIL2,SMIL3,SMIL4 smil_out.nc era5_final.nc -rm smil_out.nc - -# -------------------------------------- -# -- Create the LNSP variable -# -------------------------------------- - -# -- Apply logarithm to surface pressure -cdo expr,'LNPS=ln(PS); Q=QV; GEOP_SFC=GEOSP' era5_final.nc tmp.nc - -# -- Put the new variable LNSP in the original file -ncks -A -v LNPS,Q,GEOP_SFC tmp.nc era5_final.nc -rm tmp.nc - -# --------------------------------- -# -- Post-processing -# --------------------------------- - -# -- Rename dimensions and order alphabetically -ncrename -h -d cell,ncells era5_final.nc -ncrename -h -d nv,vertices era5_final.nc -ncks -O era5_final.nc {inicond_filename} -rm era5_final.nc - -# -- Clean the repository -rm weights.nc -rm triangular-grid.nc - -{cfg.cdo_nco_cmd_post} \ No newline at end of file diff --git a/cases/icon-art-CTDAS2/ICBC/icon_era5_nudging.sh b/cases/icon-art-CTDAS2/ICBC/icon_era5_nudging.sh deleted file mode 100644 index 4befac68..00000000 --- a/cases/icon-art-CTDAS2/ICBC/icon_era5_nudging.sh +++ /dev/null @@ -1,63 +0,0 @@ -#!/bin/bash - -cd {ERA5_folder} - -{cfg.cdo_nco_cmd} - -# --------------------------------- -# -- Pre-processing -# --------------------------------- - -rm -f {filename} - -# -- Put all variables in the same file -cdo -O merge {era5_ml_file} {era5_surf_file} era5_original.nc - -# -- Change variable and coordinates names to be consistent with ICON nomenclature -cdo setpartabn,mypartab,convert era5_original.nc tmp.nc - -# -- Order the variables alphabetically -ncks -O tmp.nc data_in.nc -rm tmp.nc era5_original.nc - -# --------------------------------- -# -- Re-mapping -# --------------------------------- - -# -- Retrieve the dynamic horizontal grid -cdo -s selgrid,2 {cfg.input_files_scratch_dynamics_grid_filename} triangular-grid.nc - -# -- Create the weights for remapping ERA5 latlon grid onto the triangular grid -cdo gendis,triangular-grid.nc data_in.nc weights.nc - -# -- Remap -cdo -s remapdis,triangular-grid.nc data_in.nc era5_final.nc -rm data_in.nc - -# -------------------------------------- -# -- Create the LNSP variable -# -------------------------------------- - -# -- Apply logarithm to surface pressure -cdo expr,'LNPS=ln(PS); Q=QV; GEOP_SFC=GEOSP' era5_final.nc tmp.nc - -# -- Put the new variable LNSP in the original file -ncks -A -v LNPS,Q,GEOP_SFC tmp.nc era5_final.nc -rm tmp.nc - -# --------------------------------- -# -- Post-processing -# --------------------------------- - -# -- Rename dimensions and order alphabetically -ncrename -h -d cell,ncells era5_final.nc -ncrename -h -d nv,vertices era5_final.nc -ncks -O era5_final.nc {filename} -rm era5_final.nc - - -# -- Clean the repository -rm weights.nc -rm triangular-grid.nc - -{cfg.cdo_nco_cmd_post} \ No newline at end of file diff --git a/cases/icon-art-CTDAS2/ICBC/icon_era5_splitfiles.sh b/cases/icon-art-CTDAS2/ICBC/icon_era5_splitfiles.sh deleted file mode 100644 index e08682a0..00000000 --- a/cases/icon-art-CTDAS2/ICBC/icon_era5_splitfiles.sh +++ /dev/null @@ -1,40 +0,0 @@ -#!/bin/bash - -cd {ERA5_folder} - -{cfg.cdo_nco_cmd} - -# Loop over ml and surf files -for ml_file in {ml_files}; do - # Convert GRIB to NetCDF for ml file and then process it - cdo -t ecmwf -f nc copy "${{ml_file}}" "${{ml_file%.grib}}.nc" - - # Show timestamp and split for ml file - cdo showtimestamp "${{ml_file%.grib}}.nc" > list_ml.txt - cdo -splitsel,1 "${{ml_file%.grib}}.nc" split_ml_ - - times_ml=($(cat list_ml.txt)) - x=0 - for f in $(ls split_ml_*.nc); do - mv $f era5_ml_${{times_ml[$x]}}.nc - let x=$x+1 - done -done - -for surf_file in {surf_files}; do - # Convert GRIB to NetCDF for surf file and then process it - cdo -t ecmwf -f nc copy "${{surf_file}}" "${{surf_file%.grib}}.nc" - - # Show timestamp and split for surf file - cdo showtimestamp "${{surf_file%.grib}}.nc" > list_surf.txt - cdo -splitsel,1 "${{surf_file%.grib}}.nc" split_surf_ - - times_surf=($(cat list_surf.txt)) - y=0 - for f in $(ls split_surf_*.nc); do - mv $f era5_surf_${{times_surf[$y]}}.nc - let y=$y+1 - done -done - -{cfg.cdo_nco_cmd_post} \ No newline at end of file diff --git a/cases/icon-art-CTDAS2/ICBC/icon_species_inicond.sh b/cases/icon-art-CTDAS2/ICBC/icon_species_inicond.sh deleted file mode 100644 index 79b1ef66..00000000 --- a/cases/icon-art-CTDAS2/ICBC/icon_species_inicond.sh +++ /dev/null @@ -1,58 +0,0 @@ -#!/bin/bash - -cd {ERA5_folder} - -{cfg.cdo_nco_cmd} - -set -x - -# 1. Remap -cdo griddes {inicond_filename} > triangular-grid.txt -cdo remapbil,triangular-grid.txt {CAMS_file} cams_triangle.nc - -# 2. Write out the hybrid levels -cat >CAMS_levels.txt <> CAMS_levels.txt -echo '' >> CAMS_levels.txt -echo 'vctsize = 160' >> CAMS_levels.txt -echo 'vct = ' >> CAMS_levels.txt -ncks -v ap cams_triangle.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*ap = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt -ncks -v bp cams_triangle.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*bp = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt -echo '' >> CAMS_levels.txt -echo 'formula = "hyam hybm (mlev=ap+bp*aps)"' >> CAMS_levels.txt -cdo setzaxis,CAMS_levels.txt cams_triangle.nc cams_withhybrid.nc - -# 3. Add required variables -# --- CAMS -ncrename -O -v Psurf,PS -d level,lev -v level,lev cams_withhybrid.nc -ncap2 -s 'P0=1.0; lnsp=ln(PS); lev[lev]=array(0,1,$lev)' cams_withhybrid.nc -O cams_withhybrid_with_P.nc -ncks -C -v P0,PS,lnsp,CO2,hyam,hybm,hyai,hybi,lev,clon,clat cams_withhybrid_with_P.nc -O cams_light.nc -ncatted -a _FillValue,CO2,m,f,1.0e36 -O cams_light.nc -# --- ERA5 -ncap2 -s 'P0=1.0; PS=PS(0,:)' {inicond_filename} -O data_in_with_P.nc -ncks -C -v hyam,hybm,hyai,hybi,clon,clat,P0 data_in_with_P.nc -O era5_light.nc -ncks -A -v PS cams_light.nc era5_light.nc - -# 4. Remap -ncremap --no_stdin --vrt_fl=era5_light.nc -v CO2 cams_light.nc cams_remapped.nc -ncrename -O -d nhym,lev cams_remapped.nc - -# 5. Place in inicond file -ncks -A -v CO2 cams_remapped.nc {inicond_filename} -ncap2 -s 'M_Air=28.9647; M_CO2=44.01; CO2_new[time,lev,ncells]=CO2*(M_CO2/M_Air)*(1-QV);' {inicond_filename} -ncks -C -O -x -v CO2 {inicond_filename} {era5_cams_ini_file} # Remove old CO2 variable -ncrename -v CO2_new,CO2 {era5_cams_ini_file} # Rename CO2_new to CO2 -ncrename -d .cell,ncells {era5_cams_ini_file} -ncrename -d .nv,vertices {era5_cams_ini_file} - -{cfg.cdo_nco_cmd_post} \ No newline at end of file diff --git a/cases/icon-art-CTDAS2/ICBC/icon_species_nudging.sh b/cases/icon-art-CTDAS2/ICBC/icon_species_nudging.sh deleted file mode 100644 index 1d3eda4d..00000000 --- a/cases/icon-art-CTDAS2/ICBC/icon_species_nudging.sh +++ /dev/null @@ -1,77 +0,0 @@ -#!/bin/bash - -cd {ERA5_folder} - -{cfg.cdo_nco_cmd} - -set -x - -# 1. Remap -cdo griddes {filename} > triangular-grid.txt -cdo remapbil,triangular-grid.txt {CAMS_file} cams_triangle.nc - -# 2. Write out the hybrid levels -cat >CAMS_levels.txt <> CAMS_levels.txt -echo '' >> CAMS_levels.txt -echo 'vctsize = 160' >> CAMS_levels.txt -echo 'vct = ' >> CAMS_levels.txt -ncks -v ap cams_triangle.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*ap = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt -ncks -v bp cams_triangle.nc | sed -e '1,/data:/d' -e '$d' | sed 's/^[ ]*bp = //' | sed 's/;$//' | tr -d '\n' >> CAMS_levels.txt -echo '' >> CAMS_levels.txt -echo 'formula = "hyam hybm (mlev=ap+bp*aps)"' >> CAMS_levels.txt -cdo setzaxis,CAMS_levels.txt cams_triangle.nc cams_withhybrid.nc - -# 3. Add required variables -# --- CAMS -ncrename -O -v Psurf,PS -d level,lev -v level,lev cams_withhybrid.nc -ncap2 -s 'P0=1.0; lnsp=ln(PS); lev[lev]=array(0,1,$lev)' cams_withhybrid.nc -O cams_withhybrid_with_P.nc -ncks -C -v P0,PS,lnsp,CO2,hyam,hybm,hyai,hybi,lev,clon,clat cams_withhybrid_with_P.nc -O cams_light.nc -ncatted -a _FillValue,CO2,m,f,1.0e36 -O cams_light.nc -# --- ERA5 -ncap2 -s 'P0=1.0; PS=PS(0,:)' {filename} -O data_in_with_P.nc -ncks -C -v hyam,hybm,hyai,hybi,clon,clat,P0 data_in_with_P.nc -O era5_light.nc -ncks -A -v PS cams_light.nc era5_light.nc - -# 4. Remap -ncremap --no_stdin --vrt_fl=era5_light.nc -v CO2 cams_light.nc cams_remapped.nc -ncrename -O -d nhym,lev cams_remapped.nc - -# 5. Place in inicond file -ncks -A -v CO2 cams_remapped.nc {filename} -ncap2 -s 'M_Air=28.9647; M_CO2=44.01; CO2_new[time,lev,ncells]=CO2*(M_CO2/M_Air)*(1-QV);' {filename} -ncks -C -O -x -v CO2 {filename} tmp.nc -ncrename -v CO2_new,CO2 tmp.nc - -# 6. Remap to lateral boundaries -cat > NAMELIST_ICONSUB << EOF_1 -&iconsub_nml - grid_filename = '{cfg.input_files_scratch_dynamics_grid_filename}', - output_type = 4, - lwrite_grid = .TRUE., -/ -&subarea_nml - ORDER = "lateral_boundary", - grf_info_file = '{cfg.input_files_scratch_dynamics_grid_filename}', - min_refin_c_ctrl = 1 - max_refin_c_ctrl = 120 -/ -EOF_1 - -iconsub --nml NAMELIST_ICONSUB - -cdo selgrid,2 lateral_boundary.grid.nc triangular-grid_00_lbc.nc -cdo remapdis,triangular-grid_00_lbc.nc tmp.nc {era5_cams_nudge_file} -ncrename -d cell,ncells {era5_cams_nudge_file} -ncrename -d nv,vertices {era5_cams_nudge_file} -{cfg.cdo_nco_cmd_post} diff --git a/cases/icon-art-CTDAS2/ICON/ICON_template.job b/cases/icon-art-CTDAS2/ICON/ICON_template.job deleted file mode 100644 index 94993e4c..00000000 --- a/cases/icon-art-CTDAS2/ICON/ICON_template.job +++ /dev/null @@ -1,386 +0,0 @@ -#!/bin/bash -l -#SBATCH --uenv="icon-wcp/v1:rc4" -#SBATCH --job-name="{cfg.casename}_{cfg.startdate_sim_yyyymmddhh}_{cfg.forecasttime}" -#SBATCH --time=00:40:00 -#SBATCH --account={cfg.compute_account} -#SBATCH --nodes={cfg.nodes} -#SBATCH --ntasks-per-node={cfg.ntasks_per_node} -#SBATCH --ntasks-per-core=1 -#SBATCH --cpus-per-task=1 -#SBATCH --partition={cfg.compute_queue} -#SBATCH --constraint={cfg.constraint} -#SBATCH --chdir={cfg.icon_work} - -export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK - -dtime=120 # Ensure dtime is defined -dt_rad=$(( 4 * dtime )) -dt_conv=$(( 1 * dtime )) -dt_sso=$(( 2 * dtime )) -dt_gwd=$(( 2 * dtime )) - -# ---------------------------------------------------------------------------- -# create ICON master namelist -# ---------------------------------------------------------------------------- - -cat > icon_master.namelist << EOF -! master_nml: ---------------------------------------------------------------- -&master_nml - lrestart = .FALSE. ! .TRUE.=current experiment is resumed -/ - -! master_model_nml: repeated for each model ---------------------------------- -&master_model_nml - model_type = 1 ! identifies which component to run (atmosphere,ocean,...) - model_name = "ATMO" ! character string for naming this component. - model_namelist_filename = "NAMELIST_NWP" ! file name containing the model namelists - model_min_rank = 1 ! start MPI rank for this model - model_max_rank = 65536 ! end MPI rank for this model - model_inc_rank = 1 ! stride of MPI ranks -/ - -! time_nml: specification of date and time------------------------------------ -&time_nml - ini_datetime_string = "{ini_restart_string}" ! initial date and time of the simulation - end_datetime_string = "{ini_restart_end_string}" ! end date and time of the simulation 10T00 -/ -EOF - -# ---------------------------------------------------------------------- -# model namelists -# ---------------------------------------------------------------------- - -cat > NAMELIST_NWP << EOF -! parallel_nml: MPI parallelization ------------------------------------------- -¶llel_nml - nblocks_c = 1 - nproma_sub = 800 ! loop chunk length - p_test_run = .FALSE. ! .TRUE. means verification run for MPI parallelization - num_io_procs = 1 ! number of I/O processors - num_restart_procs = 0 ! number of restart processors - num_prefetch_proc = 1 ! number of processors for LBC prefetching - iorder_sendrecv = 3 ! sequence of MPI send/receive calls -/ - - -! run_nml: general switches --------------------------------------------------- -&run_nml - ltestcase = .FALSE. ! real case run - num_lev = 60 ! number of full levels (atm.) for each domain - lvert_nest = .FALSE. ! no vertical nesting - dtime = $(( dtime )) ! timestep in seconds - ldynamics = .TRUE. ! compute adiabatic dynamic tendencies - ltransport = .TRUE. ! compute large-scale tracer transport - ntracer = 0 ! number of advected tracers - iforcing = 3 ! forcing of dynamics and transport by parameterized processes - msg_level = 2 ! detailed report during integration - ltimer = .TRUE. ! timer for monitoring the runtime of specific routines - timers_level = 10 ! performance timer granularity - check_uuid_gracefully = .TRUE. ! give only warnings for non-matching uuids - output = "nml" ! main switch for enabling/disabling components of the model output - lart = .TRUE. ! main switch for ART - debug_check_level = 2 -/ - -! art_nml: Aerosols and Reactive Trace gases extension------------------------------------------------- -&art_nml - lart_chem = .TRUE. ! enables chemistry - lart_pntSrc = .FALSE. ! enables point sources - lart_aerosol = .FALSE. ! main switch for the treatment of atmospheric aerosol - lart_chemtracer = .TRUE. ! main switch for the treatment of chemical tracer - lart_diag_out = .TRUE. ! - iart_seasalt = 0 ! enable seasalt - iart_init_gas = 4 ! Test versus '4' - cart_cheminit_file = "{inifile_nc}" - cart_chemtracer_xml = '{tracers_xml}' ! path to xml file for passive tracers - cart_cheminit_coord = '{inifile_nc}' - cart_cheminit_type = 'ERA' -/ - -! oem_nml: online emission module --------------------------------------------- -&oemctrl_nml - gridded_emissions_nc = '{emissionsgrid_nc}' - vertical_profile_nc = '{vertical_profile_nc}' - hour_of_year_nc = '{hour_of_year_nc}' - ens_lambda_nc = '{lambda_nc}' - ens_reg_nc = '{lambda_regions_nc}' - boundary_lambda_nc = '{bg_lambda_nc}' - boundary_regions_nc = '{bg_lambda_regions_nc}' - vegetation_indices_nc = '{vprm_coeffs_nc}' - chem_restart_nc = '{restart_file}' - restart_init_time = {restart_init_time} - vprm_par = 452.0801019142973, 356.9982743495175, 444.35135030708693, 483.71014017898636, 6.820000E+02, 549.8142194931744, 545.613483159301, 0.0E+00 - vprm_lambda = -0.1976385733575807, -0.16249650220700065, -0.15183296864822501, -0.12614291858843657, -1.141000E-01, -0.10418834453782252, -0.13114180960813507, 0.0E+00 - vprm_alpha = 0.3002548628277834, 0.22150160044981743, 0.20130383953759856, 0.238064533552737, 4.900000E-03, 0.19239326299324863, 0.405695555089534, 0.0E+00 - vprm_beta = 0.6884293574708447, 1.0916535677003347, 1.7074258216614222, 0.18946623368956772, 0.000000E+00, 0.17642838146641998, 0.41774465249044423, 0.0E+00 - vprm_tmin = 0.0, 0.0, 0.0, 2.0, 2.0, 5.0, 2.0, 0.0 - vprm_tmax = 40.0, 40.0, 40.0, 40.0, 40.0, 40.0, 40.0, 0.0 - vprm_topt = 20.0, 20.0, 20.0, 20.0, 20.0, 22.0, 18.0, 0.0 - vprm_tlow = 4.0, 0.0, 2.0, 4.0, 0.0, 0.0, 0.0, 0.0 -/ - - -! diffusion_nml: horizontal (numerical) diffusion ---------------------------- -&diffusion_nml - lhdiff_vn = .TRUE. ! diffusion on the horizontal wind field - lhdiff_temp = .TRUE. ! diffusion on the temperature field - lhdiff_w = .TRUE. ! diffusion on the vertical wind field - hdiff_order = 5 ! order of nabla operator for diffusion - itype_vn_diffu = 1 ! reconstruction method used for Smagorinsky diffusion - itype_t_diffu = 2 ! discretization of temperature diffusion - hdiff_efdt_ratio = 24.0 ! ratio of e-folding time to time step - hdiff_smag_fac = 0.025 ! scaling factor for Smagorinsky diffusion -/ - -! dynamics_nml: dynamical core ----------------------------------------------- -&dynamics_nml - iequations = 3 ! type of equations and prognostic variables - divavg_cntrwgt = 0.50 ! weight of central cell for divergence averaging - lcoriolis = .TRUE. ! Coriolis force -/ - -! extpar_nml: external data -------------------------------------------------- -&extpar_nml - itopo = 1 ! topography (0:analytical) - extpar_filename = '{cfg.input_files_scratch_extpar_filename}' ! filename of external parameter input file - n_iter_smooth_topo = 1,1 ! iterations of topography smoother - hgtdiff_max_smooth_topo = 750.0, 750.0 ! see Namelist doc - heightdiff_threshold = 2250.0, 1500.0 ! see Namelist doc -/ - -! initicon_nml: specify read-in of initial state ------------------------------ -&initicon_nml - init_mode = 2 - lread_ana = .false. - ltile_coldstart = .true. - ltile_init = .false. - ifs2icon_filename = '{inifile_nc}' - ana_varnames_map_file = '{cfg.input_files_scratch_map_filename}' -/ - -! grid_nml: horizontal grid -------------------------------------------------- -&grid_nml - dynamics_grid_filename = "{cfg.input_files_scratch_dynamics_grid_filename}" ! array of the grid filenames for the dycore - radiation_grid_filename = "{cfg.input_files_scratch_radiation_grid_filename}" ! array of the grid filenames for the radiation model - dynamics_parent_grid_id = 0 ! array of the indexes of the parent grid filenames - lredgrid_phys = .TRUE. ! .true.=radiation is calculated on a reduced grid - lfeedback = .TRUE. ! specifies if feedback to parent grid is performed - l_limited_area = .TRUE. ! .TRUE. performs limited area run - ifeedback_type = 2 ! feedback type (incremental/relaxation-based) - start_time = 0. ! Time when a nested domain starts to be active [s] -/ - -! gridref_nml: grid refinement settings -------------------------------------- -&gridref_nml - denom_diffu_v = 150. ! denominator for lateral boundary diffusion of velocity -/ - -! interpol_nml: settings for internal interpolation methods ------------------ -&interpol_nml - nudge_zone_width = 42 ! width of lateral boundary nudging zone - support_baryctr_intp = .FALSE. ! barycentric interpolation support for output - nudge_max_coeff = 0.069 - nudge_efold_width = 2.0 -/ - - -! io_nml: general switches for model I/O ------------------------------------- -&io_nml - itype_pres_msl = 5 ! method for computation of mean sea level pressure - itype_rh = 1 ! method for computation of relative humidity - lmask_boundary = .TRUE. ! mask out interpolation zone in output -/ - -! limarea_nml: settings for limited area mode --------------------------------- -&limarea_nml - itype_latbc = 1 ! 1: time-dependent lateral boundary conditions - dtime_latbc = 10800 ! time difference between 2 consecutive boundary data - latbc_boundary_grid = "{latbc_boundary_grid_nc}" ! Grid file defining the lateral boundary - latbc_path = "{cfg.icon_input_icbc}" ! Absolute path to boundary data - latbc_varnames_map_file = "{cfg.input_files_scratch_map_filename}" - latbc_filename = "era5_nudge_.nc" ! boundary data input filename - init_latbc_from_fg = .FALSE. ! .TRUE.: take lbc for initial time from first guess -/ - -! lnd_nml: land scheme switches ----------------------------------------------- -&lnd_nml - ntiles = 3 ! number of tiles - nlev_snow = 3 ! number of snow layers - lmulti_snow = .FALSE. ! .TRUE. for use of multi-layer snow model - idiag_snowfrac = 20 ! type of snow-fraction diagnosis - lsnowtile = .TRUE. ! .TRUE.=consider snow-covered and snow-free separately - itype_root = 2 ! root density distribution - itype_heatcond = 3 ! type of soil heat conductivity - itype_lndtbl = 4 ! table for associating surface parameters - itype_evsl = 4 ! type of bare soil evaporation - cwimax_ml = 5.e-4 ! scaling parameter for max. interception storage - c_soil = 1.75 ! surface area density of the evaporative soil surface - c_soil_urb = 0.5 ! same for urban areas - lseaice = .TRUE. ! .TRUE. for use of sea-ice model - llake = .TRUE. ! .TRUE. for use of lake model -/ - -! nonhydrostatic_nml: nonhydrostatic model ----------------------------------- -&nonhydrostatic_nml - iadv_rhotheta = 2 ! advection method for rho and rhotheta - ivctype = 2 ! type of vertical coordinate - itime_scheme = 4 ! time integration scheme - ndyn_substeps = 5 ! number of dynamics steps per fast-physics step - exner_expol = 0.333 ! temporal extrapolation of Exner function - vwind_offctr = 0.2 ! off-centering in vertical wind solver - damp_height = 12250.0 ! height at which Rayleigh damping of vertical wind starts - rayleigh_coeff = 1.5 ! Rayleigh damping coefficient - divdamp_order = 24 ! order of divergence damping - divdamp_type = 3 ! type of divergence damping - divdamp_fac = 0.004 ! scaling factor for divergence damping - igradp_method = 3 ! discretization of horizontal pressure gradient - l_zdiffu_t = .TRUE. ! specifies computation of Smagorinsky temperature diffusion - thslp_zdiffu = 0.02 ! slope threshold (temperature diffusion) - thhgtd_zdiffu = 125.0 ! threshold of height difference (temperature diffusion) - htop_moist_proc = 22500.0 ! max. height for moist physics - hbot_qvsubstep = 22500.0 ! height above which QV is advected with substepping scheme -/ - -! nwp_phy_nml: switches for the physics schemes ------------------------------ -&nwp_phy_nml - inwp_gscp = 2 ! cloud microphysics and precipitation - inwp_convection = 1 ! convection - lshallowconv_only = .FALSE. ! only shallow convection - inwp_radiation = 4 ! radiation - inwp_cldcover = 1 ! cloud cover scheme for radiation - inwp_turb = 1 ! vertical diffusion and transfer - inwp_satad = 1 ! saturation adjustment - inwp_sso = 1 ! subgrid scale orographic drag - inwp_gwd = 0 ! non-orographic gravity wave drag - inwp_surface = 1 ! surface scheme - latm_above_top = .TRUE. ! take into account atmosphere above model top for radiation computation - ldetrain_conv_prec = .TRUE. - efdt_min_raylfric = 7200. ! minimum e-folding time of Rayleigh friction - itype_z0 = 2 ! type of roughness length data - icapdcycl = 3 ! apply CAPE modification to improve diurnalcycle over tropical land - icpl_aero_conv = 1 ! coupling between autoconversion and Tegen aerosol climatology - icpl_aero_gscp = 1 ! coupling between autoconversion and Tegen aerosol climatology - dt_rad = $((dt_rad)) ! time step for radiation in s - dt_conv = $((dt_conv)) ! time step for convection in s (domain specific) - dt_sso = $((dt_sso)) ! time step for SSO parameterization - dt_gwd = $((dt_gwd)) ! time step for gravity wave drag parameterization -/ - -! nwp_tuning_nml: additional tuning parameters ---------------------------------- -&nwp_tuning_nml - itune_albedo = 1 ! reduced albedo (w.r.t. MODIS data) over Sahara - tune_gkwake = 1.8 - tune_gkdrag = 0.0 - tune_minsnowfrac = 0.3 -/ - -! radiation_nml: radiation scheme --------------------------------------------- -&radiation_nml - ecrad_isolver = 2 - irad_o3 = 7 ! ozone climatology - irad_aero = 6 ! aerosols - albedo_type = 2 ! type of surface albedo - vmr_co2 = 390.e-06 - vmr_ch4 = 1800.e-09 - vmr_n2o = 322.0e-09 - vmr_o2 = 0.20946 - vmr_cfc11 = 240.e-12 - vmr_cfc12 = 532.e-12 - direct_albedo_water = 3 - albedo_whitecap = 1 - ecrad_data_path = '/capstor/scratch/cscs/nponomar/icon-kit/externals/ecrad/data' -/ - -! sleve_nml: vertical level specification ------------------------------------- -&sleve_nml - min_lay_thckn = 20.0 ! layer thickness of lowermost layer - top_height = 23000.0 ! height of model top - stretch_fac = 0.65 ! stretching factor to vary distribution of model levels - decay_scale_1 = 4000.0 ! decay scale of large-scale topography component - decay_scale_2 = 2500.0 ! decay scale of small-scale topography component - decay_exp = 1.2 ! exponent of decay function - flat_height = 16000.0 ! height above which the coordinate surfaces are flat -/ - -! transport_nml: tracer transport --------------------------------------------- -&transport_nml - ivadv_tracer = 3, 3, 3, 3, 3, 3 ! tracer specific method to compute vertical advection - itype_hlimit = 3, 4, 4, 4, 4, 4 ! type of limiter for horizontal transport - ihadv_tracer = 52, 2, 2, 2, 2, 2 ! tracer specific method to compute horizontal advection - llsq_svd = .TRUE. ! use SV decomposition for least squares design matrix -/ - -! turbdiff_nml: turbulent diffusion ------------------------------------------- -&turbdiff_nml - tkhmin = 0.75 ! scaling factor for minimum vertical diffusion coefficient - tkmmin = 0.75 ! scaling factor for minimum vertical diffusion coefficient - pat_len = 750.0 ! effective length scale of thermal surface patterns - c_diff = 0.2 ! length scale factor for vertical diffusion of TKE - rat_sea = 0.8 ! controls laminar resistance for sea surface - ltkesso = .TRUE. ! consider TKE-production by sub-grid SSO wakes - frcsmot = 0.2 ! these 2 switches together apply vertical smoothing of the TKE source terms - imode_frcsmot = 2 ! in the tropics (only), which reduces the moist bias in the tropical lower troposphere - itype_sher = 3 ! type of shear forcing used in turbulence - ltkeshs = .TRUE. ! include correction term for coarse grids in hor. shear production term - a_hshr = 2.0 ! length scale factor for separated horizontal shear mode - icldm_turb = 1 ! mode of cloud water representation in turbulence - ldiff_qi = .TRUE. -/ - -! output_nml: specifies an output stream -------------------------------------- -&output_nml - filetype = 4 ! output format: 2=GRIB2, 4=NETCDFv2 - dom = 1 ! write domain 1 only - output_bounds = 0., 10000000., 3600. ! start, end, increment - steps_per_file = 1 ! number of steps per file - mode = 1 ! 1: forecast mode (relative t-axis), 2: climate mode (absolute t-axis) - include_last = .TRUE. - output_filename = 'ICON-ART-UNSTR' - filename_format = '{output_directory}/_' ! file name base - steps_per_file_inclfirst = .FALSE. - output_grid = .TRUE. - remap = 0 ! 1: remap to lat-lon grid - !north_pole = -170.,40. ! definition of north_pole for rotated lat-lon grid - reg_lon_def = -8.25,0.05,17.65 ! - reg_lat_def = 40.75,0.05,58.85 ! - ml_varlist = 'group:PBL_VARS', - 'group:ATMO_ML_VARS', - 'group:precip_vars', - 'group:land_vars', - 'group:nh_prog_vars', - 'group:ART_CHEMISTRY', - 'z_mc', 'z_ifc', - 'topography_c', - 'group:ART_PASSIVE', - 'group:ART_AEROSOL' -/ - -! output_nml: specifies an output stream -------------------------------------- -&output_nml - filetype = 4 ! output format: 2=GRIB2, 4=NETCDFv2 - dom = 1 ! write domain 1 only - output_bounds = {output_init}, 10000000., 604800. ! start, end, increment 518400 - steps_per_file = 1 ! number of steps per file - mode = 1 ! 1: forecast mode (relative t-axis), 2: climate mode (absolute t-axis) - include_last = .TRUE. - output_filename = 'ICON-ART-OEM-INIT' - filename_format = '{output_directory}/_' ! file name base - steps_per_file_inclfirst = .FALSE. - output_grid = .TRUE. - remap = 0 ! 1: remap to lat-lon grid - ml_varlist = 'group:ART_CHEMISTRY' -/ -EOF - -handle_error(){{ - set +e - # Check for invalid pointer error at the end of icon-art - if grep -q "free(): invalid pointer" {cfg.logfile} && grep -q "clean-up finished" {cfg.logfile}; then - exit 0 - else - exit 1 - fi - set -e -}} -cp {cfg.icon_executable} icon -srun ../input/wrapper_icon.sh ./icon || handle_error \ No newline at end of file diff --git a/cases/icon-art-CTDAS2/authentification.ipynb b/cases/icon-art-CTDAS2/authentification.ipynb deleted file mode 100644 index 8e8ffd64..00000000 --- a/cases/icon-art-CTDAS2/authentification.ipynb +++ /dev/null @@ -1,83 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# For access to the NASA Earthdata API, you need to create a .netrc file in your home directory.\n", - "# This script will create the file and prompt you for your NASA Earthdata login credentials.\n", - "from getpass import getpass\n", - "import os\n", - "from subprocess import Popen\n", - "urs = 'urs.earthdata.nasa.gov' # Earthdata URL to call for authentication\n", - "prompts = ['Enter NASA Earthdata Login Username \\n(or create an account at urs.earthdata.nasa.gov): ',\n", - " 'Enter NASA Earthdata Login Password: ']\n", - "homeDir = os.path.expanduser(\"~\") + os.sep\n", - "with open(homeDir + '.netrc', 'w') as file:\n", - " file.write('machine {} login {} password {}'.format(urs, getpass(prompt=prompts[0]), getpass(prompt=prompts[1])))\n", - " file.close()\n", - "with open(homeDir + '.urs_cookies', 'w') as file:\n", - " file.write('')\n", - " file.close()\n", - "with open(homeDir + '.dodsrc', 'w') as file:\n", - " file.write('HTTP.COOKIEJAR={}.urs_cookies\\n'.format(homeDir))\n", - " file.write('HTTP.NETRC={}.netrc'.format(homeDir))\n", - " file.close()\n", - "Popen('chmod og-rw ~/.netrc', shell=True)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# Log in to https://cpauth.icos-cp.eu , tick \"I accept the ICOS data license\" and then \"Save profile\" to be allowed data downloading. \n", - "# Then run this cell to save a configuration file that will be used by the icoscp package to download data.\n", - "from icoscp_core.icos import auth\n", - "auth.init_config_file()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "proc-chain", - "language": "python", - "name": "python3" - }, - "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.11" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/cases/icon-art-CTDAS2/config.yaml b/cases/icon-art-CTDAS2/config.yaml deleted file mode 100644 index 439ad3ef..00000000 --- a/cases/icon-art-CTDAS2/config.yaml +++ /dev/null @@ -1,253 +0,0 @@ -# Configuration file for the 'icon-art-CTDAS' case with ICON - -# From the `icon-wcp` environment: -# - spack install nco@4.9.0 -# - spack install icontools@c2sm-master%gcc -# - spack install cdo - -workflow: icon -constraint: gpu -run_on: cpu -compute_queue: normal -nodes: 2 -ntasks_per_node: 4 -startdate: 2021-01-01T00:00:00Z -enddate: 2021-12-31T23:59:59Z -restart_step: PT10D # = CTDAS cycle length - -####### Tracer options -# The tracers XML file will be generated on-the-fly -tracers: - TRCO2_A: - oem_cat: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" - oem_vp: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" - oem_tp: "GNFR_A-CO2, GNFR_B-CO2, GNFR_C-CO2, GNFR_D-CO2, GNFR_A-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_G-CO2, GNFR_H-CO2, GNFR_I-CO2, GNFR_J-CO2, GNFR_L-CO2, GNFR_L-CO2" - TRCO2_BG: - init_name: "CO2" - CO2_RA: - oem_ftype: "resp" - CO2_GPP: - oem_ftype: "gpp" - TRCO2_A-XXX: - bg: "TRCO2_BG" - ra: "CO2_RA" - gpp: "CO2_GPP" - biosource: - oem_cat: "co2fire, allcropsource, allwoodsource, lakeriveremis, cflx" - oem_vp: "A-CO2, A-CO2, A-CO2, A-CO2, A-CO2" - oem_tp: "GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2" - biosink: - oem_cat: "biofuelcropsource, biofuelwoodsource, mflx" - oem_vp: "A-CO2, A-CO2, A-CO2" - oem_tp: "GNFR_A-CO2, GNFR_A-CO2, GNFR_A-CO2" - EM_TRCO2_A: - oem_cat: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" - oem_vp: "A-CO2, B-CO2, C-CO2, D-CO2, E-CO2, F1-CO2, F2-CO2, F3-CO2, F4-CO2, G-CO2, H-CO2, I-CO2, J-CO2, K-CO2, L-CO2" - oem_tp: "GNFR_A-CO2, GNFR_B-CO2, GNFR_C-CO2, GNFR_D-CO2, GNFR_A-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_F-CO2, GNFR_G-CO2, GNFR_H-CO2, GNFR_I-CO2, GNFR_J-CO2, GNFR_L-CO2, GNFR_L-CO2" - EM_CO2_RA: - oem_ftype: "resp" - EM_CO2_GPP: - oem_ftype: "gpp" -####### CTDAS options. -# First of all, do the following in your ~ (home) folder, e.g., -# git clone -b ctdas-icon https://git.wur.nl/ctdas/CTDAS.git ~/ctdas-icon -# We will PATCH that code -# Execute `start_ctdas_icon.sh $SCRATCH ctdas_procchain` -# which will put the CTDAS files into $SCRATCH/ctdas_procchain. -# We will then 'patch' this CTDAS installation with the required files, -# - ctdas-icon.py [which runs CTDAS; and imports the following patched classes]: - # - statevector class [which, ultimately, defines our ensemble members] - # - observation operator (obsoperator) class [which, ultimately, runs the ICON scripts & post-processing sampler] - # - observations class [which, ultimately, defines how to ingest the observations] - # - optimizer class [which, ultimately, defines how to do localization] -# - rc-cteco2 file [which, ultimately, is how we pass general input like folder names etc to CTDAS] -# - rc-job file [which, ultimately, is the setup for CTDAS like lag times, etc.] -CTDAS: - nlag: 2 - tracer: co2 - regions: basegrid # choose: basegrid or parentgrid - nensembles: 186 - # nregions: # read from cells->regions file - restart_init_time: 86400 # 1 day in seconds; using Michael Steiner's "overwriting" restart mechanism - ctdas_cycle: 10 # days - ctdas_nlag: 2 - nboundaries: 8 - lambdas: # The first 16 lambdas must be the respiration and uptake ones [even if not relevant, e.g., for a CH4 simulation], followed by the oem_cat categories in the xml file, in order of appearance, but excluding any - - 1,1,1,1,1,1,1,1 # Respiration (Evergreen Forest, Deciduous Forest, Mixed Forest, Shrubland, Savanna, Cropland, Grassland, Urban/Other) - - 1,1,1,1,1,1,1,1 # Uptake (E, D, M, S, SV, C, G, U) - - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2 # Anthropogenic CO2 (ensemble tracer categories that are optimized) - obs: - # Run the 'authentification.ipynb' notebook to get access to ICOS and/or NASA Earthdata (OCO2) data - fetch_ICOS: True - ICOS_path: /capstor/scratch/cscs/ekoene/ICOS/ - fetch_OCO2: True - OCO2_path: /capstor/scratch/cscs/ekoene/OCO2 - global_inputs: - inventories: - - /capstor/scratch/cscs/ekoene/inventories/INV_20180102.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180112.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180122.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180201.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180211.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180221.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180303.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180313.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180323.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180402.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180412.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180422.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180502.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180512.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180522.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180601.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180611.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180621.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180701.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180711.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180721.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180731.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180810.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180820.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180830.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180909.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180919.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20180929.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20181009.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20181019.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20181029.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20181108.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20181118.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20181128.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20181208.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20181218.nc - - /capstor/scratch/cscs/ekoene/inventories/INV_20181228.nc - grid: - - /users/ekoene/CTDAS_inputs/icon_europe_DOM01.parent.nc - - /users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc - - ERA5/lateral_boundary.grid.nc # This is guaranteed to exist due to the ERA5/CAMS preprocessing - extpar: - - /users/ekoene/CTDAS_inputs/icon_extpar_EriksGrid.nc - VPRM: - - /users/ekoene/CTDAS_inputs/VPRM_indices_ICON_datestr.nc - OEM: - - /capstor/scratch/cscs/ekoene/inventories/icon_with_tno_emissions/vertical_profiles.nc # It /should/ be these - - /capstor/scratch/cscs/ekoene/inventories/icon_with_tno_emissions/hourofyear.nc - - /users/ekoene/CTDAS_inputs/vertical_profiles_t.nc # ... but these old files are still used - - /users/ekoene/CTDAS_inputs/hourofyear8784.nc - ctdas_path: /users/ekoene/ctdas-icon - ctdas_patch: - templates: - - ctdas_patch/template.py - - ctdas_patch/template.rc # ADD THESE! - - ctdas_patch/template.jb # ADD THESE! - da/statevectors: ctdas_patch/statevector_baseclass_icos_cities.py - da/observations: ctdas_patch/obs_class_ICOS_OCO2.py - da/obsoperators: ctdas_patch/obsoperator_ICOS_OCO2.py - da/optimizers: ctdas_patch/optimizer_baseclass_icos_cities.py - da/rc/cteco2: ctdas_patch/carbontracker_icon_oco2.rc - da/tools/icon: - - ctdas_patch/utilities.py - - ctdas_patch/icon_helper.py - - ctdas_patch/icon_sampler.py - - -# # CTDAS ------------------------------------------------------------------------ -# ctdas_restart = False -# ctdas_BG_run = False -# # CTDAS cycle length in days -# ctdas_cycle = int(restart_cycle_window / 60 / 60 / 24) -# ctdas_nlag = 2 -# ctdas_tracer = 'co2' -# # CTDAS number of regions and cells->regions file -# ctdas_nreg_params = 21184 -# ctdas_regionsfile = vprm_regions_synth_nc # <--- Create -# # Number of boundaries, and boundaries mask/regions file -# ctdas_bg_params = 8 -# # Number of ensemble members (make this consistent with your XML file!) -# ctdas_optimizer_nmembers = 180 -# # CTDAS path -# ctdas_dir = '/scratch/snx3000/ekoene/ctdas-icon/exec' -# # Distance file from region to region (shape: [N_reg x N_reg]), for statevector localization -# ctdas_sv_distances = '/scratch/snx3000/ekoene/CTDAS_cells2cells.nc' -# # Distance file from region to stations (shape: [N_reg x N_obs]), for observation localization -# ctdas_op_loc_coeffs = '/scratch/snx3000/ekoene/cells2stations.nc' -# # Directory containing a file with all the observations -# ctdas_datadir = '/scratch/snx3000/ekoene/ICOS_extracted/2018/' -# # CTDAS localization setting -# ctdas_system_localization = 'spatial' -# # CTDAS statevector length for one window -# ctdas_nparameters = 2 * ctdas_nreg_params + 8 # 2 (A , VPRM) * ctdas_nreg_params + ctdas_bg_params -# # Extraction template -# ctdas_extract_template = '/scratch/snx3000/ekoene/processing-chain/cases/VPRM_EU_ERA5_22/extract_template_icos_EU' -# # ICON runscript template -# ctdas_ICON_template = '/scratch/snx3000/ekoene/processing-chain/cases/VPRM_EU_ERA5_22/runscript_template_restart_icos_EU' -# # Full path to SBATCH template that can submit extraction scripts -# ctdas_sbatch_extract_template = '/scratch/snx3000/ekoene/processing-chain/cases/VPRM_EU_ERA5_22/sbatch_extract_template' -# # Full path to possibly time-varying emissionsgrid (if not time-varying, supply a filename without {}!) -# ctdas_oae_grid = "/scratch/snx3000/ekoene/inventories/INV_{}.nc" -# ctdas_oae_grid_fname = '%Y%m%d' # Specifies the naming scheme to use for the emission grids -# # Spinup time length -# # Restart file for the first simulation -# ctdas_first_restart_init = '/scratch/snx3000/ekoene/processing-chain/work/VPRM_EU_ERA5_22/2018010100_0_240/icon/output_INIT' -# # Number of vertical levels -# nvlev = 60 -# # NOT NEEDED FOR ANYTHING, EXCEPT TO MAKE CTDAS RUN -# ctdas_obsoperator_home = '/scratch/snx3000/msteiner/ctdas_test/exec/da/rc/stilt' -# ctdas_obsoperator_rc = os.path.join(ctdas_obsoperator_home, 'stilt_0.rc') -# ctdas_regtype = 'olson19_oif30' - -cdo_nco_cmd: | - uenv start icon-wcp --ignore-tty << 'EOF' - . /capstor/scratch/cscs/ekoene/tmp/spack-c2sm/setup-env.sh /user-environment/ - spack load icontools cdo nco - -cdo_nco_cmd_post: | - EOF - -eccodes_dir: ./input/eccodes_definitions -art_input_folder: ./input/icon-art-oem/ART - -walltime: - prepare_icon: '00:15:00' - prepare_art_global: '00:10:00' - icon: '00:05:00' - prepare_CTDAS: '00:00:00' - -meteo: - nudging_step: 3 - fetch_era5: True - url: https://cds-beta.climate.copernicus.eu/api - key: 1c2e45b1-dd08-4bc4-90c8-15c06304ae69 - era5_splitjob: ICBC/icon_era5_splitfiles.sh - era5_inijob: ICBC/icon_era5_inicond.sh - era5_nudgingjob: ICBC/icon_era5_nudging.sh - partab: mypartab - -chem: - nudging_step: 3 - fetch_CAMS: True - url: https://ads-beta.atmosphere.copernicus.eu/api - key: 1c2e45b1-dd08-4bc4-90c8-15c06304ae69 - cams_inijob: ICBC/icon_species_inicond.sh - cams_nudgingjob: ICBC/icon_species_nudging.sh - -input_files: - radiation_grid_filename: /users/ekoene/CTDAS_inputs/icon_europe_DOM01.parent.nc - dynamics_grid_filename: /users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc - extpar_filename: /users/ekoene/CTDAS_inputs/icon_extpar_EriksGrid.nc - map_filename: ./cases/icon-art-CTDAS/map_file.ana - wrapper_filename: ./cases/icon-art-CTDAS/wrapper_icon.sh - -icon: - executable: /capstor/scratch/cscs/ekoene/tmp/spack-c2sm/spack/opt/spack/linux-sles15-neoverse_v2/nvhpc-24.3/icon-develop-sytqk6o7h5y3imrsevsswc2inxaegbpx/bin/icon - runjob_filename: ICON/ICON_template.job -# # era5_inijob: icon_era5_inicond.sh -# # era5_nudgingjob: icon_era5_nudging.sh -# species_inijob: icon_species_inicond.sh -# species_nudgingjob: icon_species_nudging.sh -# output_writing_step: 6 -# compute_queue: normal -# np_tot: 32 -# np_io: 3 -# np_restart: 1 -# np_prefetch: 1 \ No newline at end of file diff --git a/cases/icon-art-CTDAS2/ctdas_patch/carbontracker_icon_oco2.rc b/cases/icon-art-CTDAS2/ctdas_patch/carbontracker_icon_oco2.rc deleted file mode 100644 index e4b89444..00000000 --- a/cases/icon-art-CTDAS2/ctdas_patch/carbontracker_icon_oco2.rc +++ /dev/null @@ -1,31 +0,0 @@ -! CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. -! Users are recommended to contact the developers (wouter.peters@wur.nl) to receive -! updates of the code. See also: http://www.carbontracker.eu. -! -! This program is free software: you can redistribute it and/or modify it under the -! terms of the GNU General Public License as published by the Free Software Foundation, -! version 3. This program is distributed in the hope that it will be useful, but -! WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS -! FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. -! -! You should have received a copy of the GNU General Public License along with this -! program. If not, see . - -!!! Info for the CarbonTracker data assimilation system - -! For our case, 2*grid size + 8 -nparameters : {nregs*ncats+cfg.CTDAS_nboundaries} - -! ICOS stuff -datadir : {cfg.case_root / "global_inputs" / "ICOS"} -obs.input.dir : {cfg.case_root / "global_inputs" / "ICOS"} -obspack.input.dir : {cfg.case_root / "global_inputs" / "ICOS"} -regtype : olson19_oif30 - -! OCO2 stuff -obs.column.input.dir : {cfg.case_root / "global_inputs" / "OCO2"} -obs.column.ncfile : OCO2__ctdas.nc -obs.column.selection.variables : quality_flag -obs.column.selection.criteria : == 0 -mdm.calculation : 0.015 -sigma_scale : 0.5 \ No newline at end of file diff --git a/cases/icon-art-CTDAS2/ctdas_patch/icon_helper.py b/cases/icon-art-CTDAS2/ctdas_patch/icon_helper.py deleted file mode 100644 index 10922adc..00000000 --- a/cases/icon-art-CTDAS2/ctdas_patch/icon_helper.py +++ /dev/null @@ -1,1425 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- -""" -Created on Mon Jul 22 15:03:02 2019 - -This class contains helper functions mainly for sampling WRF-Chem, but a -few are also needed by the WRF-Chem column observation operator. - -@author: friedemann - -Modified on June 26, 10:40:12, 2023 -Adaptation for sampling ICON instead of WRF. - -@author: David Ho -""" - -# Instructions for pylint: -# pylint: disable=too-many-instance-attributes -# pylint: disable=W0201 -# pylint: disable=C0301 -# pylint: disable=E1136 -# pylint: disable=E1101 - -import os -import shutil -import re -import glob -import bisect -import copy -import numpy as np -import netCDF4 as nc -import datetime as dt -#import wrf # Not needed, since working on ICON -#import f90nml # Not needed, used for reading wrf namelist -import pickle -import xarray as xr -import pandas as pd - -# CTDAS modules -import da.tools.io4 as io -from da.tools.icon.utilities import utilities - -# Erik added: -from datetime import datetime, timedelta - - -class ICON_Helper(object): - """Contains helper functions for sampling WRF-Chem""" - - def __init__(self, settings): - self.settings = settings - - #def __init__(self): # Use this part for offline testing - # pass - - def validate_settings(self, needed_items=[]): - """ - This is based on WRFChemOO._validate_rc - """ - - if len(needed_items) == 0: - return - - for key in needed_items: - if key not in self.settings: - msg = "Missing a required value in settings: %s" % key - raise IOError(msg) - - @staticmethod - def get_pressure_boundaries_paxis(p_axis, p_surf): - """ - Arguments - --------- - p_axis (:class:`array-like`) - Pressure at mid points of layers - p_surf (:class:`numeric`) - Surface pressure - Output - ------ - Pressure at layer boundaries - """ - - #pb = np.array([float("nan")]*(len(p_axis)+1)) - #pb[0] = p_surf - # - #for nl in range(len(pb)-1): - # pb[nl+1] = pb[nl] + 2*(p_axis[nl] - pb[nl]) - # ^ commented out by David coz it didn't work - # v Added by David - p_full = np.insert(p_axis, 0, psurf, - axis=1) # Insert p_surf to the first index - pb = np.array([float("nan")] * (len(p_axis) + 1)) - pb[0] = p_surf - - for nl in range(len(pb) - 1): - pb[nl + 1] = 0.5 * (p_full[nl] + p_full[nl + 1]) - - return pb - - @staticmethod - def get_pressure_boundaries_znw(znw, p_surf, p_top): - """ - Arguments - --------- - ZNW (:class:`ndarray`) - Eta coordinates of z-staggered WRF grid. For each - observation (2D) - p_surf (:class:`ndarray`) - Surface pressure (1D) - p_top (:class:`ndarray`) - Top-of-atmosphere pressure (1D) - Output - ------ - Pressure at layer boundaries - - CAVEATS - ------- - Maybe I should rather use P_HYD? Well, Butler et al. 2018 - (https://www.geosci-model-dev-discuss.net/gmd-2018-342/) used - znu and surface pressure to compute "WRF midpoint layer - pressure". - - For WRF it would be more consistent to interpolate to levels. - See also comments in code. - """ - - return znw * (p_surf - p_top) + p_top - - @staticmethod - def get_int_coefs(pb_ret, pb_mod, level_def): - """ - Computes a coefficients matrix to transfer a model profile onto - a retrieval pressure axis. - - If level_def=="layer_average", this assumes that profiles are - constant in each layer of the retrieval, bound by the pressure - boundaries pb_ret. In this case, the WRF model layer is treated - in the same way, and coefficients integrate over the assumed - constant model layers. This works with non-staggered WRF - variables (on "theta" points). However, this is actually not how - WRF is defined, and the implementation should be changed to - z-staggered variables. Details for this change are in a comment - at the beginning of the code. - - If level_def=="pressure_boundary" (IMPLEMENTATION IN PROGRESS), - assumes that profiles, kernel and pwf are defined at pressure - boundaries that don't have a thickness (this is how OCO-2 data - are defined, for example). In this case, the coefficients - linearly interpolate adjacent model level points. This is - incompatible with the treatment of WRF in the above-described - layer-average assumption, but is closer to how WRF is actually - defined. The exception is that pb_mod is still constructed and - non-staggered variables are not defined at psurf. This can only - be fixed by switching to z-staggered variables. - - In cases where retrieval surface pressure is higher than model - surface pressure, and in cases where retrieval top pressure is - lower than model top pressure, the model profile will be - extrapolated with constant tracer mixing ratios. In cases where - retrieval surface pressure is lower than model surface pressure, - and in cases where retrieval top pressure is higher than model - top pressure, only the parts of the model column that fall - within the retrieval presure boundaries are sampled. - - Arguments - --------- - pb_ret (:class:`array_like`) - Pressure boundaries of the retrieval column - pb_mod (:class:`array_like`) - Pressure boundaries of the model column - level_def (:class:`string`) - "layer_average" or "pressure_boundary" (IMPLEMENTATION IN - PROGRESS). Refers to the retrieval profile. - - Note 2021-09-13: Inspected code for pressure_boundary. - Should be correct. Interpolates linearly between two model - levels. - - - Returns - ------- - coefs (:class:`array_like`) - Integration coefficient matrix. Each row sums to 1. - - Usage - ----- - .. code-block:: python - - import numpy as np - pb_ret = np.linspace(900., 50., 5) - pb_mod = np.linspace(1013., 50., 7) - model_profile = 1. - np.linspace(0., 1., len(pb_mod)-1)**3 - coefs = get_int_coefs(pb_ret, pb_mod, "layer_average") - retrieval_profile = np.matmul(coefs, model_profile) - """ - - if level_def == "layer_average": - # This code assumes that WRF variables are constant in - # layers, but they are defined on levels. This can be seen - # for example by asking wrf.interplevel for the value of a - # variable that is defined on the mass grid ("theta points") - # at a pressure slightly higher than the pressure on its - # grid (wrf.getvar(ncf, "p")), it returns nan. So There is - # no extrapolation. There are no layers. There are only - # levels. - # In addition, this page here: - # https://www.openwfm.org/wiki/How_to_interpret_WRF_variables - # says that to find values at theta-points of a variable - # living on u-points, you interpolate linearly. That's the - # other way around from what I would do if I want to go from - # theta to staggered. - # WRF4.0 user guide: - # - ungrib can interpolate linearly in p or log p - # - real.exe comes with an extrap_type namelist option, that - # extrapolates constantly BELOW GROUND. - # This would mean the correct way would be to integrate over - # a piecewise-linear function. It also means that I really - # want the value at surface level, so I'd need the CO2 - # fields on the Z-staggered grid ("w-points")! Interpolate - # the vertical in p with wrf.interp1d, example: - # wrf.interp1d(np.array(rh.isel(south_north=1, west_east=0)), - # np.array(p.isel(south_north=1, west_east=0)), - # np.array(988, 970)) - # (wrf.interp1d gives the same results as wrf.interplevel, - # but the latter just doesn't want to work with single - # columns (32,1,1), it wants a dim>1 in the horizontal - # directions) - # So basically, I can keep using pb_ret and pb_mod, but it - # would be more accurate to do the piecewise-linear - # interpolation and the output matrix will have 1 more - # value in each dimension. - - # Calculate integration weights by weighting with layer - # thickness. This assumes that both axes are ordered - # psurf to ptop. - coefs = np.ndarray(shape=(len(pb_ret) - 1, len(pb_mod) - 1)) - coefs[:] = 0. - - # Extend the model pressure grid if retrieval encompasses - # more. - pb_mod_tmp = copy.deepcopy(pb_mod) - - # In case the retrieval pressure is higher than the model - # surface pressure, extend the lowest model layer. - if pb_mod_tmp[0] < pb_ret[0]: - pb_mod_tmp[0] = pb_ret[0] - - # In case the model doesn't extend as far as the retrieval, - # extend the upper model layer upwards. - if pb_mod_tmp[-1] > pb_ret[-1]: - pb_mod_tmp[-1] = pb_ret[-1] - - # For each retrieval layer, this loop computes which - # proportion falls into each model layer. - for nret in range(len(pb_ret) - 1): - - # 1st model pressure boundary index = the one before the - # first boundary with lower pressure than high-pressure - # retrieval layer boundary. - model_lower = pb_mod_tmp < pb_ret[nret] - id_model_lower = model_lower.nonzero()[0] - id_min = id_model_lower[0] - 1 - - # Last model pressure boundary index = the last one with - # higher pressure than low-pressure retrieval layer - # boundary. - model_higher = pb_mod_tmp > pb_ret[nret + 1] - - id_model_higher = model_higher.nonzero()[0] - - if len(id_model_higher) == 0: - #id_max = id_min - raise ValueError("This shouldn't happen. Debug.") - else: - id_max = id_model_higher[-1] - - # By the way, in case there is no model level with - # higher pressure than the next retrieval level, - # id_max must be the same as id_min. - - # For each model layer, find out how much of it makes up this - # retrieval layer - for nmod in range(id_min, id_max + 1): - if (nmod == id_min) & (nmod != id_max): - # Part of 1st model layer that falls within - # retrieval layer - coefs[nret, nmod] = pb_ret[nret] - pb_mod_tmp[nmod + 1] - elif (nmod != id_min) & (nmod == id_max): - # Part of last model layer that falls within - # retrieval layer - coefs[nret, nmod] = pb_mod_tmp[nmod] - pb_ret[nret + 1] - elif (nmod == id_min) & (nmod == id_max): - # id_min = id_max, i.e. model layer encompasses - # retrieval layer - coefs[nret, nmod] = pb_ret[nret] - pb_ret[nret + 1] - else: - # Retrieval layer encompasses model layer - coefs[nret, - nmod] = pb_mod_tmp[nmod] - pb_mod_tmp[nmod + 1] - - coefs[nret, :] = coefs[nret, :] / sum(coefs[nret, :]) - - # I tested the code with many cases, but I'm only 99.9% sure - # it works for all input. Hence a test here that the - # coefficients sum to 1 and dump the data if not. - sum_ = np.abs(coefs.sum(1) - 1) - if np.any(sum_ > 2. * np.finfo(sum_.dtype).eps): - dump = dict(pb_ret=pb_ret, pb_mod=pb_mod, level_def=level_def) - fp = "int_coefs_dump.pkl" - with open(fp, "w") as f: - pickle.dump(dump, f, 0) - - msg_fmt = "Something doesn't sum to 1. Arguments dumped to: %s" - raise ValueError(msg_fmt % fp) - - elif level_def == "pressure_boundary": - #msg = "level_def is pressure_boundary. Implementation not complete." - ##logging.error(msg) - #raise ValueError(msg) - # Note 2021-09-13: Inspected the code. Should be correct. - - # Go back to pressure midpoints for model... - # Change this line to p_mod = pb_mod for z-staggered - # variables - p_mod = pb_mod[1:] - 0.5 * np.diff( - pb_mod) # Interpolate linearly in pressure space - - coefs = np.ndarray(shape=(len(pb_ret), len(pb_mod) - 1)) - coefs[:] = 0. - - # For each retrieval pressure level, compute linear - # interpolation coefficients - for nret in range(len(pb_ret)): - nmod_list = (p_mod < pb_ret[nret]).nonzero()[0] - if (len(nmod_list) > 0): - nmod = nmod_list[0] - 1 - if nmod == -1: - # Constant extrapolation at surface - nmod = 0 - coef = 1. - else: - # Normal case: - coef = (pb_ret[nret] - p_mod[nmod + 1]) / ( - p_mod[nmod] - p_mod[nmod + 1]) - else: - # Constant extrapolation at atmosphere top - nmod = len(p_mod) - 2 - coef = 0. - - coefs[nret, nmod] = coef - coefs[nret, nmod + 1] = 1. - coef - - else: - msg = "Unknown level_def: " + level_def - raise ValueError(msg) - - return coefs - - @staticmethod - def get_pressure_weighting_function(pressure_boundaries, rule): - """ - Compute pressure weighting function according to 'rule'. - Valid rules are: - - simple (=layer thickness) - - connor2008 (not implemented) - """ - if rule == 'simple': - pwf = np.abs( - np.diff(pressure_boundaries) / np.ptp(pressure_boundaries)) - else: - raise NotImplementedError("Rule %s not implemented" % rule) - - return pwf - - ### David: Original function from ctdas-wrf ### - ### Keeping here as reference. ### - - def sample_total_columns(self, dat, loc, fields_list): - """ - Sample total_columns of fields_list in WRF output in - self.settings["run_dir"] at the location id_xy in domain, id_t - in all wrfout-times. Files and indices therein are recognized - by id_t and file_time_start_indices. - All quantities needed for computing total columns from profiles - are in dat (kernel, prior, ...). - - Arguments - --------- - dat (:class:`list`) - Result of wrfhelper.read_sampling_coords. Used here: prior, - prior_profile, kernel, psurf, pressure_axis, [, pwf] - If psurf or any of pressure_axis are nan, wrf's own - surface pressure is used and pressure_axis constructed - from this and the number of levels in the averaging kernel. - This allows sampling with synthetic data that don't have - pressure information. This only works with level_def - "layer_average". - If pwf is not present or nan, a simple one is created, for - level_def "layer_average". - loc (:class:`dict`) - A dictionary with all location-related input for sampling, - computed in wrfout_sampler. Keys: - id_xy, domain: Domain coordinates - id_t: Timestep (continous throughout all files) - frac_t: Interpolation coeficient between id_t and id_t+1: - t_obs = frac_t*t[id_t] + (1-frac_t)*t[id_t+1]) - file_start_time_indices: Time index at which a new wrfout - file starts - files: names of wrfout files. - fields_list (:class:`list`) - The fields to sample total columns from. - - Output - ------ - sampled_columns (:class:`array`) - A 2D-array of sampled columns. - Shape: (len(dat["prior"]), len(fields_list)) - """ - - # Initialize output - tc = np.ndarray(shape=(len(dat["prior"]), len(fields_list)), - dtype=float) - tc[:] = float("nan") - - # Process by domain - UD = list(set(loc["domain"])) - # Added by David, above ^ returns [0,1] where domain 0 doesn't exsist - UD = [1] - for dom in UD: - idd = np.nonzero(loc["domain"] == dom)[0] - # Process by id_t - UT = list(set(loc["id_t"][idd])) - for time_id in UT: - # Coordinates to process - idt = idd[np.nonzero(loc["id_t"][idd] == time_id)[0]] - # Get tracer ensemble profiles - profiles = self._read_and_intrp_v(loc, fields_list, time_id, - idt) - # List, len=len(fields_list), shape of each: (len(idt),nz) - # Get pressure axis: - #paxis = self.read_and_intrp(wh_names, id_ts, frac_t, id_xy, "P_HYD")/1e2 # Pa -> hPa - psurf = self._read_and_intrp_v(loc, ["PSFC"], time_id, - idt)[0] / 1.e2 # Pa -> hPa - # Shape: (len(idt),) - ptop = float( - self.namelist["domains"]["p_top_requested"]) / 1.e2 - # Shape: (len(idt),) - znw = self._read_and_intrp_v(loc, ["ZNW"], time_id, idt)[0] - #Shape:(len(idt),nz) - - # DONE reading from file. - # Here it starts to make sense to loop over individual observations - for nidt in range(len(idt)): - nobs = idt[nidt] - # Construct model pressure layer boundaries - pb_mod = self.get_pressure_boundaries_znw( - znw[nidt, :], psurf[nidt], ptop) - - if (np.diff(pb_mod) >= 0).any(): - msg = ("Model pressure boundaries for observation %d " + \ - "are not monotonically decreasing! Investigate.") % nobs - raise ValueError(msg) - - # Construct retrieval pressure layer boundaries - if dat["level_def"][nobs] == "layer_average": - if np.any(np.isnan(dat["pressure_levels"][nobs])) \ - or np.isnan(dat["psurf"][nobs]): - # Code for synthetic data without a pressure axis, - # but with an averaging kernel: - # Use wrf's surface and top pressure - nlayers = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, - nlayers + 1) - else: - nlayers = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, - nlayers + 1) - # Below commented out by David - # Because somehow doesn't work - #pb_ret = self.get_pressure_boundaries_paxis( - # dat["pressure_levels"][nobs], - # dat["psurf"][nobs]) - elif dat["level_def"][nobs] == "pressure_boundary": - if np.any(np.isnan(dat["pressure_levels"][nobs])): - # Code for synthetic data without a pressure axis, - # but with an averaging kernel: - # Use wrf's surface and top pressure - nlevels = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, nlevels) - else: - pb_ret = dat["pressure_levels"][nobs] - - if (np.diff(pb_ret) >= 0).any(): - msg = ("Retrieval pressure boundaries for " + \ - "observation %d are not monotonically " + \ - "decreasing! Investigate.") % nobs - print('pb_ret[:]: %s, np.diff(pb_ret): %s' % - (pb_ret[:], np.diff(pb_ret))) - raise ValueError(msg) - - # Get vertical integration coefficients (i.e. to - # "interpolate" from model to retrieval grid) - coef_matrix = self.get_int_coefs(pb_ret, pb_mod, - dat["level_def"][nobs]) - - # Model retrieval with averaging kernel and prior profile - if "pressure_weighting_function" in list(dat.keys()): - pwf = dat["pressure_weighting_function"][nobs] - if (not "pressure_weighting_function" in list( - dat.keys())) or np.any(np.isnan(pwf)): - # Construct pressure weighting function from - # pressure boundaries - pwf = self.get_pressure_weighting_function( - pb_ret, rule="simple") - - # Compute pressure-weighted averaging kernel - avpw = pwf * dat["averaging_kernel"][nobs] - - # Get prior - prior_col = dat["prior"][nobs] - prior_profile = dat["prior_profile"][nobs] - if np.isnan(prior_col): # compute prior - prior_col = np.dot(pwf, prior_profile) - - # Compute total columns - for nf in range(len(fields_list)): - # Integrate model profile - profile_intrp = np.matmul(coef_matrix, - profiles[nf][nidt, :]) - - # Model retrieval - tc[nobs, nf] = prior_col + np.dot( - avpw, profile_intrp - prior_profile) - - # Test phase: save pb_ret, pb_mod, coef_matrix, - # one profile for manual checking - - # dat_save = dict(pb_ret=pb_ret, - # pb_mod=pb_mod, - # coef_matrix=coef_matrix, - # ens_profile=ens_profiles[0], - # profile_intrp=profile_intrp, - # id=dat.id) - # - #out = open("model_profile_%d.pkl"%dat.id, "w") - #cPickle.dump(dat_save, out, 0) - # Average over footprint - if self.settings["footprint_samples_dim"] > 1: - indices = utilities.get_index_groups(dat["sounding_id"]) - - # Make sure that this is correct: i know the number of indices - lens = [len(group) for group in list(indices.values())] - correct_len = self.settings["footprint_samples_dim"]**2 - if np.any([len_ != correct_len for len_ in set(lens)]): - raise ValueError("Not all footprints have %d samples" % - correct_len) - # Ok, paranoid mode, also confirm that the indices are what I - # think they are: consecutive numbers - ranges = [np.ptp(group) for group in list(indices.values())] - if np.any([ptp != correct_len for ptp in set(ranges)]): - raise ValueError("Not all footprints have consecutive samples") - - tc_original = copy.deepcopy(tc) - tc = utilities.apply_by_group(np.average, tc_original, indices) - - return tc - - ### David: Original function from ctdas-wrf ### - ### Keeping here as reference. ### - - @staticmethod - def _read_and_intrp_v(loc, fields_list, time_id, idp): - """ - Helper function for sample_total_columns. - read_and_intrp, but vectorized. - Reads in fields and interpolates - them linearly in time. - - Arguments - ---------- - loc (:class:`dict`) - Passed through from sample_total_columns, see there. - fields_list (:class:`list` of :class:`str`) - List of netcdf-variables to process. - time_id (:class:`int`) - Time index referring to all files in loc to read - idp (:class:`array` of :class:`int`) - Indices for id_xy, domain and frac_t in loc (i.e. - observations) to process. - - Output - ------ - List of temporally interpolated fields, one entry per member of - fields_list. - """ - - var_intrp_l = list() - - # Check we were really called with observations for just one domain - domains = set(loc["domain"][idp]) - if len(domains) > 1: - raise ValueError( - "I can only operate on idp with identical domains.") - dom = domains.pop() - - # Select input files - id_file0 = bisect.bisect_right(loc["file_start_time_indices"][dom], - time_id) - 1 - id_file1 = bisect.bisect_right(loc["file_start_time_indices"][dom], - time_id + 1) - 1 - if id_file0 < 0 or id_file1 < 0: - raise ValueError("This shouldn't happen.") - - # Get time id in file - id_t_file0 = time_id - loc["file_start_time_indices"][dom][id_file0] - id_t_file1 = time_id + 1 - loc["file_start_time_indices"][dom][id_file1] - - # Open files - nc0 = nc.Dataset(loc["files"][dom][id_file0], "r") - nc1 = nc.Dataset(loc["files"][dom][id_file1], "r") - # Per field to sample - for field in fields_list: - # Read input file - field0 = wrf.getvar(wrfin=nc0, - varname=field, - timeidx=id_t_file0, - squeeze=False, - meta=False) - - field1 = wrf.getvar(wrfin=nc1, - varname=field, - timeidx=id_t_file1, - squeeze=False, - meta=False) - - if len(field0.shape) == 4: - # Sample field at timesteps before and after observation - # They are ordered nt x nz x ny x nx - # var0 will have shape (len(idp),len(profile)) - var0 = field0[0, :, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] - var1 = field1[0, :, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] - # Repeat frac_t for profile size - frac_t_ = np.array(loc["frac_t"][idp]).reshape( - (len(idp), 1)).repeat(var0.shape[1], 1) - elif len(field0.shape) == 3: - # var0 will have shape (len(idp),) - var0 = field0[0, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] - var1 = field1[0, loc["id_xy"][idp, 1], loc["id_xy"][idp, 0]] - frac_t_ = np.array(loc["frac_t"][idp]) - elif len(field0.shape) == 2: - # var0 will have shape (len(idp),len(profile)) - # This is for ZNW, which is saved as (time_coordinate, - # vertical_coordinate) - var0 = field0[[0] * len(idp), :] - var1 = field1[[0] * len(idp), :] - frac_t_ = np.array(loc["frac_t"][idp]).reshape( - (len(idp), 1)).repeat(var0.shape[1], 1) - else: - raise ValueError("Can't deal with field with %d dimensions." % - len(field0.shape)) - - # Interpolate in time - var_intrp_l.append(var0 * frac_t_ + var1 * (1. - frac_t_)) - - nc0.close() - nc1.close() - - return var_intrp_l - - @staticmethod - def read_sampling_coords(sampling_coords_file, id0=None, id1=None): - """Read in samples""" - - ncf = nc.Dataset(sampling_coords_file, "r") - if id0 is None: - id0 = 0 - if id1 is None: - id1 = len(ncf.dimensions['soundings']) - - dat = dict(sounding_id=np.array(ncf.variables["sounding_id"][id0:id1]), - date=ncf.variables["date"][id0:id1], - latitude=np.array(ncf.variables["latitude"][id0:id1]), - longitude=np.array(ncf.variables["longitude"][id0:id1]), - latc_0=np.array(ncf.variables["latc_0"][id0:id1]), - latc_1=np.array(ncf.variables["latc_1"][id0:id1]), - latc_2=np.array(ncf.variables["latc_2"][id0:id1]), - latc_3=np.array(ncf.variables["latc_3"][id0:id1]), - lonc_0=np.array(ncf.variables["lonc_0"][id0:id1]), - lonc_1=np.array(ncf.variables["lonc_1"][id0:id1]), - lonc_2=np.array(ncf.variables["lonc_2"][id0:id1]), - lonc_3=np.array(ncf.variables["lonc_3"][id0:id1]), - prior=np.array(ncf.variables["prior"][id0:id1]), - prior_profile=np.array(ncf.variables["prior_profile"][ - id0:id1, - ]), - averaging_kernel=np.array( - ncf.variables["averaging_kernel"][id0:id1]), - pressure_levels=np.array( - ncf.variables["pressure_levels"][id0:id1]), - pressure_weighting_function=np.array( - ncf.variables["pressure_weighting_function"][id0:id1]), - level_def=ncf.variables["level_def"][id0:id1], - psurf=np.array(ncf.variables["psurf"][id0:id1])) - - ncf.close() - - # Convert level_def from it's weird nc format to string - dat["level_def"] = nc.chartostring(dat["level_def"]) - - # Convert date to datetime object - dat["time"] = [dt.datetime(*x) for x in dat["date"]] - - return dat - - @staticmethod - def write_simulated_columns(obs_id, simulated, nmembers, outfile): - """Write simulated observations to file.""" - - # Output format: see obs_xco2_fr - - f = io.CT_CDF(outfile, method="create") - - dimid = f.createDimension("sounding_id", size=None) - dimid = ("sounding_id", ) - savedict = io.std_savedict.copy() - savedict["name"] = "sounding_id" - savedict["dtype"] = "int64" - savedict["long_name"] = "Unique_Dataset_observation_index_number" - savedict["units"] = "" - savedict["dims"] = dimid - savedict["comment"] = "Format as in input" - savedict["values"] = obs_id.tolist() - f.add_data(savedict, nsets=0) - - dimmember = f.createDimension("nmembers", size=nmembers) - dimmember = ("nmembers", ) - savedict = io.std_savedict.copy() - savedict["name"] = "column_modeled" - savedict["dtype"] = "float" - savedict["long_name"] = "Simulated total column" - savedict["units"] = "??" - savedict["dims"] = dimid + dimmember - savedict["comment"] = "Simulated model value created by ICON_sampler" - savedict["values"] = simulated.tolist() - f.add_data(savedict, nsets=0) - - f.close() - - @staticmethod - def save_file_with_timestamp(file_path, out_dir, suffix=""): - """ Saves a file to with a timestamp""" - nowstamp = dt.datetime.now().strftime("_%Y-%m-%d_%H:%M:%S") - new_name = os.path.basename(file_path) + suffix + nowstamp - new_path = os.path.join(out_dir, new_name) - shutil.copy2(file_path, new_path) - - -################################################### -# Here are some adaptations written by David Ho - - def get_icon_filenames(self, glob_pattern): - """ - Gets the filenames in self.settings["dir.icon_sim"] that follow - glob_pattern - """ - path = self.settings["run_dir"] - #path = '/work/mj0143/b301043/Project/Ensemble_sim/ICON/ICON-ART/icon-kit/ERA5_EMPA/CTDAS_test/bckup' - # All files... - wfiles = glob.glob(os.path.join(path, glob_pattern)) - files = [x for x in wfiles] - - # I need this sorted too often to not do it here. - files = np.sort(files).tolist() - return files - - @staticmethod - def times_in_icon_file(ds_icon): - """ - Returns the times in netCDF4.Dataset ncf as datetime object - """ - times_nc = pd.to_datetime(ds_icon["time"].values, format='date_format') - #times_dtm = pd.to_datetime(ds_icon["time"].values, format='date_format') - times_str = str(times_nc.strftime('%Y-%m-%d_%H:%M:%S')[0]) - times_dtm = dt.datetime.strptime(times_str, "%Y-%m-%d_%H:%M:%S") - - return times_dtm - - def icon_times(self, file_list): - """Read all times in a list of icon files - - Output - ------ - - 1D-array containing all times - - 1D-array containing start indices of each file - """ - - #times = [] - times = list() - start_indices = np.ndarray((len(file_list), ), int) - for file in range(len(file_list)): - ds = xr.open_dataset(file_list[file]) - times_this = self.times_in_icon_file(ds) - start_indices[file] = len(times) - #times += times_this - times.append(times_this) - #ncf.close() - - return times, start_indices - - ### David: Too slow, no longer needed ### - ### To be deleted ### - @staticmethod - def fetch_weight_and_neighbor_cells_Serial(gridinfo, - latitudes_array, - longitudes_array, - z_info=None): - """ - Provide Grid info of your ICON grid, see icon_sampler. - Given lat/lon, calculates the distances then: - return the indexes of the neighboring N cells from unstructured ICON grid, - and the weights, for horizontal interpolation. - Vertical interpolation is skipped, since it will calculates the column average later. - ----- - Code originally inherited from Michael Steier. - Future developments: - Include vertical interpolation from 'z_info' argument, for geting the model levels. - - Output - ----- - - 1D-array containing the nearest neighbor indexes - - 1D-array containing the weights for the indexes - """ - # Libraries for this function: - from math import sin, cos, sqrt, atan2, radians - - # Initialize - nn_sel_list = np.zeros( - (len(latitudes_array), - gridinfo.nn)).astype(int) # indexes must be integers - u_list = np.zeros((len(latitudes_array), gridinfo.nn)) - - # Loop over lat/lon array to collect. #### This loop takes too long, needs to parallelize!!! - for index in np.arange(len(latitudes_array)): - - # For debugging... - #print('Calculating index: %s' %index) - - latitudes = latitudes_array[index] - longitudes = longitudes_array[index] - - # For debugging... - #print('Lat: %s, Lon: %s' %(latitudes, longitudes)) - - # Initialize: - nn_sel = np.zeros(gridinfo.nn) # Index of neighbor cells - u = np.zeros(gridinfo.nn) # Weights for neighbor cells - - R = 6373.0 # approximate radius of earth in km - - # This step is used for filtering obs outside of domain. - # However, in the satellite pre-processing step, we will make sure all obs are in the domain! - # vvv Therefore, skipped... vvv - - #if (radians(longitudes)np.nanmax(gridinfo.clon)): - # u[:] = np.nan - # return np.zeros((gridinfo.nn)), np.zeros((gridinfo.nn)).astype(int), np.zeros((gridinfo.nn)).astype(int), nn_sel[:], u[:] - - #if (radians(latitudes)np.nanmax(gridinfo.clat)): - # u[:] = np.nan - # return np.zeros((gridinfo.nn)), np.zeros((gridinfo.nn)).astype(int), np.zeros((gridinfo.nn)).astype(int), nn_sel[:], u[:] - - #% - lat1 = radians(latitudes) - lon1 = radians(longitudes) - - #% - """FIND "N" CLOSEST CENTERS""" - distances = np.zeros((len(gridinfo.clon))) - for icell in np.arange(len(gridinfo.clon)): - lat2 = gridinfo.clat[icell] - lon2 = gridinfo.clon[icell] - dlon = lon2 - lon1 - dlat = lat2 - lat1 - a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2 - c = 2 * atan2(sqrt(a), sqrt(1 - a)) - distances[icell] = R * c - nn_sel[:] = [ - x for _, x in sorted( - zip(distances, np.arange(len(gridinfo.clon)))) - ][0:gridinfo.nn] - nn_sel = nn_sel.astype(int) - - u[:] = [1. / distances[y] for y in nn_sel] - - nn_sel_list[index] = nn_sel[:] - u_list[index] = u - - # For debugging... - #print('Done, added NS:%s and U:%s' %(nn_sel, u[:]) ) - - # End of loop - - return nn_sel_list, u_list - - ### David: Too slow, no longer needed ### - ### To be deleted ### - @staticmethod - def fetch_weight_and_neighbor_cells_Parallel(args): - #def fetch_weight_and_neighbor_cells_Parallel(idx, gridinfo, latitudes, longitudes): - """ - Provide Grid info of your ICON grid, see icon_sampler. - Given lat/lon, calculates the distances then: - return the indexes of the neighboring N cells from unstructured ICON grid, - and the weights, for horizontal interpolation. - Vertical interpolation is skipped, since it will calculates the column average later. - ----- - Code originally inherited from Michael Steier. - Future developments: - Include vertical interpolation from 'z_info' argument, for geting the model levels. - - Output - ----- - - 1D-array containing the nearest neighbor indexes - - 1D-array containing the weights for the indexes - """ - - idx = args[0] - gridinfo = args[1] - latitudes = args[2] - longitudes = args[3] - - # Libraries for this function: - from math import sin, cos, sqrt, atan2, radians - - # Initialize: - nn_sel = np.zeros(gridinfo.nn).astype( - int) # Index of neighbor cells, # indexes must be integers - u = np.zeros(gridinfo.nn) # Weights for neighbor cells - - R = 6373.0 # approximate radius of earth in km - - #% - lat1 = radians(latitudes[idx]) - lon1 = radians(longitudes[idx]) - - #% - """FIND "N" CLOSEST CENTERS""" - distances = np.zeros((len(gridinfo.clon))) - for icell in np.arange(len(gridinfo.clon)): - lat2 = gridinfo.clat[icell] - lon2 = gridinfo.clon[icell] - dlon = lon2 - lon1 - dlat = lat2 - lat1 - a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2 - c = 2 * atan2(sqrt(a), sqrt(1 - a)) - distances[icell] = R * c - nn_sel[:] = [ - x for _, x in sorted(zip(distances, np.arange(len(gridinfo.clon)))) - ][0:gridinfo.nn] - nn_sel = nn_sel.astype(int) - - u[:] = [1. / distances[y] for y in nn_sel] - - #return nn_sel[:], u - return np.array(nn_sel[:], dtype=int), np.array(u) - - @staticmethod - def get_divisible_hours_string(datetime_obj, hours=3): - """ - Added by Erik; extracts a string for the previous and next datetimes - that are divisible by three - """ - # Get the hour from the datetime object - hour = datetime_obj.hour - - # Check if the hour is divisible by N hours - if hour % hours == 0: - # If divisible, get the current hour and the next hour - current_hour = datetime_obj.replace(minute=0, - second=0, - microsecond=0) - hour_above = current_hour + timedelta(hours=hours) - return [ - current_hour.strftime('%Y%m%d%H'), - hour_above.strftime('%Y%m%d%H') - ] - else: - # If not divisible, get the hour below and above - hour_below = datetime_obj.replace(hour=hour - (hour % hours), - minute=0, - second=0, - microsecond=0) - hour_above = hour_below + timedelta(hours=hours) - return [ - hour_below.strftime('%Y%m%d%H'), - hour_above.strftime('%Y%m%d%H') - ] - - @staticmethod - def _read_and_intrp_v_ICON(loc, fields_list, time_id, idp): - """ - David: - Slight modification from "self.sample_total_columns" for WRF. - - Helper function for sample_total_columns. - read_and_intrp, but vectorized. - Reads in fields and interpolates - them linearly in time. - - Arguments - ---------- - loc (:class:`dict`) - Passed through from sample_total_columns, see there. - fields_list (:class:`list` of :class:`str`) - List of netcdf-variables to process. - time_id (:class:`int`) - Time index referring to all files in loc to read - idp (:class:`array` of :class:`int`) - Indices for id_xy, domain and frac_t in loc (i.e. - observations) to process. - - Output - ------ - List of temporally interpolated fields, one entry per member of - fields_list. - """ - - var_intrp_l = list() - - # Select input files - id_file0 = bisect.bisect_right(loc["file_start_time_indices"], - time_id) - 1 - id_file1 = bisect.bisect_right(loc["file_start_time_indices"], - time_id + 1) - 1 - if id_file0 < 0 or id_file1 < 0: - raise ValueError("This shouldn't happen.") - - # Get time id in file - id_t_file0 = time_id - loc["file_start_time_indices"][id_file0] - id_t_file1 = time_id + 1 - loc["file_start_time_indices"][id_file1] - - # Open files - ### NetCDF approach: - nc0 = nc.Dataset(loc["files"][id_file0], "r") - nc1 = nc.Dataset(loc["files"][id_file1], "r") - - ### Xarray approach: - #nc0 = xr.open_dataset(loc["files"][id_file0]) - #nc1 = xr.open_dataset(loc["files"][id_file1]) - - # Per field to sample - for field in fields_list: - # Read input file - ### NetCDF approach: - field0 = nc0[field][:] - field1 = nc1[field][:] - - ### Xarray approach: - #field0 = nc0[ field ].values - #field1 = nc1[ field ].values - - if len(field0.shape) == 3: - ### For ICON fields that has shape (time, z, cells) - # -- First select the nearest neighbours of the fields - - var00 = field0[0, :, loc["nn_sel_list"][idp]] - var01 = field1[0, :, loc["nn_sel_list"][idp]] - - # -- Then interpolate spatially with weights - # The sum of the weights per obs location - u_sums = np.nansum(loc["weight_list"][idp], axis=1) - - # Fancy way of mulitply the weights onto 4 nearest neighbors per obs location. (to be varified) - # see: https://numpy.org/doc/stable/reference/generated/numpy.einsum.html - # Since the dimension does not match, so here are the tricks to do so... - var0 = ( - np.einsum("ij,ijk->ik", loc["weight_list"][idp], var00) / - u_sums[:, np.newaxis]) - var1 = ( - np.einsum("ij,ijk->ik", loc["weight_list"][idp], var01) / - u_sums[:, np.newaxis]) - - # -- Get the time fractions per obs location - frac_t_ = np.array(loc["frac_t"][idp]).reshape((len(idp), 1)) - - elif len(field0.shape) == 2: - ### For ICON fields that has shape (time, cells), e.g. "pres_sfc" - # var0 will have shape (len(idp),len(profile)) - - # -- First select the fields: - var00 = field0[0, loc["nn_sel_list"][idp]] - var01 = field1[0, loc["nn_sel_list"][idp]] - - # -- Then interpolate in space with weights: - # The sum of the weights per obs location - u_sums = np.nansum(loc["weight_list"][idp], axis=1) - - var0 = np.nansum(loc["weight_list"][idp] * var00, - axis=1) / u_sums - var1 = np.nansum(loc["weight_list"][idp] * var01, - axis=1) / u_sums - - # -- Get the time fractions per obs location - frac_t_ = np.array(loc["frac_t"][idp]) - - else: - raise ValueError("Can't deal with field with %d dimensions." % - len(field0.shape)) - - # Interpolate in time - var_intrp_l.append(var0 * frac_t_ + var1 * (1. - frac_t_)) - - nc0.close() - nc1.close() - - return var_intrp_l - - #### David: A variation for sampling ICON ### - def sample_total_columns_ICON(self, dat, loc, fields_list): - """ - David: - Slight modification from "self.sample_total_columns" for WRF. - - Sample total_columns of fields_list in ICON output in - self.settings["dir.icon_sim"] at the location id_xy in domain, id_t - in all wrfout-times. Files and indices therein are recognized - by id_t and file_time_start_indices. - All quantities needed for computing total columns from profiles - are in dat (kernel, prior, ...). - - Arguments - --------- - dat (:class:`list`) - Result of wrfhelper.read_sampling_coords. Used here: prior, - prior_profile, kernel, psurf, pressure_axis, [, pwf] - If psurf or any of pressure_axis are nan, wrf's own - surface pressure is used and pressure_axis constructed - from this and the number of levels in the averaging kernel. - This allows sampling with synthetic data that don't have - pressure information. This only works with level_def - "layer_average". - If pwf is not present or nan, a simple one is created, for - level_def "layer_average". - loc (:class:`dict`) - A dictionary with all location-related input for sampling, - computed in wrfout_sampler. Keys: - id_xy, domain: Domain coordinates - id_t: Timestep (continous throughout all files) - frac_t: Interpolation coeficient between id_t and id_t+1: - t_obs = frac_t*t[id_t] + (1-frac_t)*t[id_t+1]) - file_start_time_indices: Time index at which a new wrfout - file starts - files: names of wrfout files. - fields_list (:class:`list`) - The fields to sample total columns from. - - Output - ------ - sampled_columns (:class:`array`) - A 2D-array of sampled columns. - Shape: (len(dat["prior"]), len(fields_list)) - """ - - # Initialize output of all tracers - tc = np.ndarray(shape=(len(dat["prior"]), len(fields_list)), - dtype=float) - tc[:] = float("nan") - - tc_unperturbed = np.ndarray(shape=(len(dat["prior"]), 1), dtype=float) - tc_unperturbed[:] = float("nan") - - do_CAMS = True - - # Process by id_t - UT = list(set(loc["id_t"][:])) - - #print('Tests, UT: %s' %UT) - - # print(loc['times']) - - for time_id in UT: - # Coordinates to process - idt = np.nonzero(loc["id_t"] == time_id)[0] - # David: idt seems to be a list - # print('Tests, idt: %s' %idt) - - din = loc['times'][idt[0]] - # print(din) - [hour_below, - hour_above] = self.get_divisible_hours_string(datetime_obj=din) - print("oi oi", hour_below, hour_above) - if do_CAMS: - CAMS = xr.open_mfdataset([ - "/scratch/snx3000/ekoene/CAMS_i/cams_egg4_" + hour_below + - ".nc", "/scratch/snx3000/ekoene/CAMS_i/cams_egg4_" + - hour_above + ".nc" - ], - concat_dim="Time", - combine="nested").rename({{ - 'Time': - 'time' - }}) - pressure = CAMS.ap.values[:, :, np.newaxis, - np.newaxis] + np.einsum( - 'pi,pjk->pijk', CAMS.bp.values, - CAMS.Psurf.values) - # The following is applicable if we only use joint (CO2,Pres) levels [as needed by, e.g., OCO2] - CAMS["pressure"] = ( - ("time", "level", "latitude", "longitude"), - (pressure[:, 1:, :, :] + pressure[:, :-1, :, :]) * 0.5) - # The following is applicable if we want to use (CO2,Pres_ifc) combinations [note the 'hlevel' dimension] - # CAMS["pressure"] = (("time", "hlevel", "latitude", "longitude"), pressure) - - # Read and get tracer ensemble profiles, and flip them, since ICON start from the model top - m_dry = 28.97 # g/mol for dry air - m_gas = 44.01 # g/mol for CO2 - to_ppm = 1e6 - qv = self._read_and_intrp_v_ICON(loc, ['qv'], time_id, idt)[0] - - # The unperturbed tracer - BG = np.asarray( - self._read_and_intrp_v_ICON( - loc, ['TRCO2_BG'], time_id, - idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm - # TRCO2_A = np.asarray(self._read_and_intrp_v_ICON(loc, ['TRCO2_A'], time_id, idt)) / (1-qv) * (m_dry/m_gas) * to_ppm - try: # In the "PRIOR" simulations I made, the following tracer contains the anthropogenic portion; it doesn't exist otherwise. - TRCO2_A = np.asarray( - self._read_and_intrp_v_ICON( - loc, ['ANTH'], time_id, - idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm - except: - TRCO2_A = np.asarray( - self._read_and_intrp_v_ICON( - loc, ['TRCO2_A'], time_id, - idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm - CO2_RA = np.asarray( - self._read_and_intrp_v_ICON(loc, ['CO2_RA'], time_id, idt)) / ( - 1 - qv) * (m_dry / m_gas) * to_ppm - CO2_GPP = np.asarray( - self._read_and_intrp_v_ICON( - loc, ['CO2_GPP'], time_id, - idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm - biosource_all_chemtr = np.asarray( - self._read_and_intrp_v_ICON( - loc, ['biosource_all_chemtr'], time_id, - idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm - biosink_chemtr = np.asarray( - self._read_and_intrp_v_ICON( - loc, ['biosink_chemtr'], time_id, - idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm - # The ensemble tracers - tracers = np.asarray( - self._read_and_intrp_v_ICON( - loc, fields_list, time_id, - idt)) / (1 - qv) * (m_dry / m_gas) * to_ppm - - # Correct for the missing biospheric components! - tracers = tracers + biosource_all_chemtr - biosink_chemtr - prior_tracers = BG + TRCO2_A + CO2_RA - CO2_GPP + biosource_all_chemtr - biosink_chemtr - - #profiles = np.fliplr( self._read_and_intrp_v_ICON(loc, fields_list, time_id, idt) ) * (28.97/16.01)*1e6 # mol/kg -> ppm - # List, len=len(fields_list), shape of each: (len(idt),nz) - - # Read and get water vapor for wet/dry correction - # print(np.asarray(qv).shape, np.asarray(tracers).shape, type(qv), type(tracers)) - - # Read and get pressure axis: - psurf = self._read_and_intrp_v_ICON(loc, ["pres"], time_id, - idt)[0] / 1.e2 # Pa -> hPa - # Shape: (len(idt),) - - ptop = 50 # David: Since ICON does not have hard coded ptop, assume it is 50 hPa... - # Shape: (len(idt),) - if not do_CAMS: - ptop = 50 - - if do_CAMS: - ptop = 0.01 - - ### David: ZNW was for WRF, for ICON first try getting "pres" or "pres_ifc" - pres = np.fliplr( - self._read_and_intrp_v_ICON(loc, ["pres"], time_id, - idt)[0]) / 1.e2 # Pa -> hPa - # pres = np.fliplr( self._read_and_intrp_v_ICON(loc, ["pres_ifc"], time_id, idt)[0] )/1.e2 # Pa -> hPa - #znw = self._read_and_intrp_v_ICON(loc, ["ZNW"], time_id, idt)[0] - #Shape:(len(idt),nz) - - # DONE reading from file. - # Here it starts to make sense to loop over individual observations - for nidt in range(len(idt)): - - nobs = idt[nidt] - - # Construct model pressure layer boundaries - #pb_mod = self.get_pressure_boundaries_znw(znw[nidt, :], psurf[nidt], ptop) - - # numpy.fliplr reverses the order of elements along axis 1 (left/right). - # For a 2-D array, this flips the entries in each row in the left/right direction. - # Columns are preserved, but appear in a different order than before. - pb_mod = pres[nidt] - - # Do the CAMS extension - if do_CAMS: - CAMS_obs = CAMS.interp(time=loc['times'][nobs], - latitude=loc['latitude'][nobs], - longitude=loc['longitude'][nobs]) - CAMS_pressures = CAMS_obs.pressure.values - CAMS_idx = CAMS_pressures < np.min(pb_mod) - pb_mod = np.concatenate((pb_mod, CAMS_pressures[CAMS_idx])) - CAMS_gas = CAMS_obs.CO2.values[CAMS_idx] * 1e6 - - # Add a final value onto the column... - pb_mod = np.append(pb_mod, np.min(pb_mod) - 1) - - if (np.diff(pb_mod) >= 0).any(): - msg = ("Model pressure boundaries for observation %d " + \ - "are not monotonically decreasing! Investigate.") % nobs - # --> Erik: I have removed this, because I don't quite know how to investigate this easily. Was triggered though! - # raise ValueError(msg) - - # Construct retrieval pressure layer boundaries - # print(dat["level_def"][nobs]) - if dat["level_def"][nobs] == "layer_average": - if np.any(np.isnan(dat["pressure_levels"][nobs])) \ - or np.isnan(dat["psurf"][nobs]): - # Code for synthetic data without a pressure axis, - # but with an averaging kernel: - # Use wrf's surface and top pressure - nlayers = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, nlayers + 1) - else: - nlayers = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, nlayers + 1) - # Below commented out by David - # Because somehow doesn't work - #pb_ret = self.get_pressure_boundaries_paxis( - # dat["pressure_levels"][nobs], - # dat["psurf"][nobs]) - elif dat["level_def"][nobs] == "pressure_boundary": - if np.any(np.isnan(dat["pressure_levels"][nobs])): - # Code for synthetic data without a pressure axis, - # but with an averaging kernel: - # Use wrf's surface and top pressure - nlevels = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, nlevels) - else: - pb_ret = dat["pressure_levels"][nobs] - else: - # print('No appropriate level chosen...') - dat["level_def"][nobs] = "pressure_boundary" - # print("changed definition to pressure_boundary") - if np.any(np.isnan(dat["pressure_levels"][nobs])): - # Code for synthetic data without a pressure axis, - # but with an averaging kernel: - # Use wrf's surface and top pressure - nlevels = len(dat["averaging_kernel"][nobs]) - pb_ret = np.linspace(psurf[nidt], ptop, nlevels) - else: - pb_ret = dat["pressure_levels"][nobs] - - if (np.diff(pb_ret) >= 0).any(): - msg = ("Retrieval pressure boundaries for " + \ - "observation %d are not monotonically " + \ - "decreasing! Investigate.") % nobs - print('pb_ret[:]: %s, np.diff(pb_ret): %s' % - (pb_ret[:], np.diff(pb_ret))) - raise ValueError(msg) - - # Get vertical integration coefficients (i.e. to - # "interpolate" from model to retrieval grid) - coef_matrix = self.get_int_coefs( - pb_ret, pb_mod, - dat["level_def"][nobs]) ### To be verified !! - - # Model retrieval with averaging kernel and prior profile - if "pressure_weighting_function" in list(dat.keys()): - pwf = dat["pressure_weighting_function"][nobs] - if (not "pressure_weighting_function" in list( - dat.keys())) or np.any(np.isnan(pwf)): - # Construct pressure weighting function from - # pressure boundaries - pwf = self.get_pressure_weighting_function(pb_ret, - rule="simple") - - # Compute pressure-weighted averaging kernel - avpw = pwf * dat["averaging_kernel"][nobs] - - # Get prior - prior_col = dat["prior"][nobs] - prior_profile = dat["prior_profile"][nobs] - if np.isnan(prior_col): # compute prior - prior_col = np.dot(pwf, prior_profile) - - # Compute total columns - offset = 0 - for nf in range(len(fields_list)): - # Integrate model profile - tr_here = np.flip(tracers[nf][nidt, :]) - if do_CAMS: - tr_here = np.concatenate((tr_here, CAMS_gas)) - profile = ((tr_here - offset)) - profile_intrp = np.matmul(coef_matrix, - profile) ### To be verified !! - - # Model retrieval - # print(prior_profile) - # print(profile_intrp) - # print(prior_col) - tc[nobs, nf] = prior_col + np.dot( - avpw, profile_intrp - prior_profile) - # print(tc[nobs,nf]) - - tr_here = np.flip(prior_tracers[0][nidt, :]) - if do_CAMS: - tr_here = np.concatenate((tr_here, CAMS_gas)) - profile = ((tr_here - offset)) - profile_intrp = np.matmul(coef_matrix, - profile) ### To be verified !! - tc_unperturbed[nobs, 0] = prior_col + np.dot( - avpw, profile_intrp - prior_profile) - - return tc, tc_unperturbed - -if __name__ == "__main__": - pass diff --git a/cases/icon-art-CTDAS2/ctdas_patch/icon_sampler.py b/cases/icon-art-CTDAS2/ctdas_patch/icon_sampler.py deleted file mode 100755 index 8f357878..00000000 --- a/cases/icon-art-CTDAS2/ctdas_patch/icon_sampler.py +++ /dev/null @@ -1,284 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- -""" -Created on Mon Jul 22 15:07:13 2019 - -@author: friedemann - -Modified on June 26, 10:40:12, 2023 -Adaptation for sampling ICON instead of WRF. -@author: David Ho - -""" - -# Samples ICON-ART history files for CTDAS - -# This is called as external executable from CTDAS -# to allow simple parallelization -# -# Usage: - -# icon_sampler.py --arg1 val1 --arg2 val2 ... -# Arguments: See parser in code below - -import os -import sys -#import itertools -#import bisect -import copy -import numpy as np -import xarray as xr -import netCDF4 as nc - -# Import some CTDAS tools -pd = os.path.pardir -inc_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), pd, pd, pd) -inc_path = os.path.abspath(inc_path) -sys.path.append(inc_path) -from da.tools.icon.icon_helper import ICON_Helper -from da.tools.icon.utilities import utilities -import argparse - -########## Parse options -parser = argparse.ArgumentParser() -parser.add_argument("--nproc", - type=int, - help="ID of this sampling process (0 ... nprocs-1)") -parser.add_argument("--nprocs", type=int, help="Number of sampling processes") -parser.add_argument("--sampling_coords_file", type=str, - help="File with sampling coordinates as created " + \ - "by CTDAS column samples object") -parser.add_argument("--run_dir", - type=str, - help="Directory with icon output files") -parser.add_argument("--iconout_prefix", - type=str, - help="Headings of the ICON output files") -parser.add_argument("--icon_grid", - type=str, - help="Absolute path points to the ICON grid file") -parser.add_argument("--nmembers", - type=int, - help="Number of tracer ensemble members") -parser.add_argument("--tracer_optim", type=str, - help="Tracer that was optimized (e.g. CO2 for " + \ - "ensemble members CO2_000 etc.)") -parser.add_argument("--outfile_prefix", type=str, - help="One process: output file. More processes: " + \ - "output file is ..slice") -parser.add_argument("--footprint_samples_dim", - type=int, - help="Sample column footprint at n x n points") - -args = parser.parse_args() -settings = copy.deepcopy(vars(args)) - -# Start (stupid) logging - should be updated -wd = os.getcwd() -try: - os.makedirs("log") -except OSError: # Case when directory already exists. Will look nicer in python 3... - pass - -logfile = os.path.join( - wd, "log/iconout_sampler." + str(settings['nproc']) + ".log") - -os.system("touch " + logfile) -os.system("rm " + logfile) -os.system("echo 'Process " + str(settings['nproc']) + " of " + - str(settings['nprocs']) + ": start' >> " + logfile) -os.system("date >> " + logfile) - -# David: could be helpful for validate arguments for icon sampling -########## Initialize iconhelper -iconhelper = ICON_Helper(settings) -iconhelper.validate_settings([ - 'sampling_coords_file', - 'run_dir', - 'iconout_prefix', - 'icon_grid', - 'nproc', - 'nprocs', - 'nmembers', # special case 0: sample 'tracer_optim' - 'tracer_optim', - 'outfile_prefix', - 'footprint_samples_dim' -]) - -cwd = os.getcwd() -os.chdir(iconhelper.settings['run_dir']) - -# ########## Figure out which samples to process -# # Get number of samples -ncf = nc.Dataset(settings['sampling_coords_file'], "r") -nsamples = len(ncf.dimensions['soundings']) -ncf.close() - -id0, id1 = utilities.get_slicing_ids(nsamples, settings['nproc'], - settings['nprocs']) - -os.system("echo 'id0=" + str(id0) + "' >> " + logfile) -os.system("echo 'id1=" + str(id1) + "' >> " + logfile) - -# ########## Read samples from coord file -dat = iconhelper.read_sampling_coords(settings['sampling_coords_file'], id0, - id1) - -os.system("echo 'Data read, len=" + str(len(dat['sounding_id'])) + "' >> " + - logfile) - -########## Locate samples in ICON domains - -# Take care of special case without ensemble -nmembers = settings['nmembers'] - -if nmembers == 0: - # Special case: sample 'tracer_optim', don't add member suffix - member_names = [settings['tracer_optim']] - nmembers = 1 -else: - member_names = [ - settings['tracer_optim'] + "-%03d" % nm - for nm in range(1, nmembers + 1) - ] # In ICON, ensemble member starts with XXX-001 - -#### Here gets the indexes of neighboring cells and the weights -#### Choose number of neighbours, recommend 4 as done in "cdo remapdis" - -nneighb = 4 - -# Read grid file, and store the grid info. Only needs to do it once. -grid_file = settings['icon_grid'] - -# Import modules (takes 8 seconds) -from sklearn.neighbors import BallTree - -# Get ICON grid specifics -ICON_GRID = xr.open_dataset(grid_file) -clon = ICON_GRID.clon.values -clat = ICON_GRID.clat.values - -# Generate BallTree -test_points = np.column_stack([clat, clon]) -tree = BallTree(test_points, metric='haversine') - -lat_q = dat['latitude'] -lon_q = dat['longitude'] - -# Query BallTree -(d, i) = tree.query(np.column_stack([np.deg2rad(lat_q), - np.deg2rad(lon_q)]), - k=nneighb, - return_distance=True) - -R = 6373.0 # approximate radius of earth in km - -weight_list = 1. / (d * R) -nn_sel_list = i - -######### Locate in time: Which file, time index, and temporal interpolation -# factor. -# MAYBE make this a function. See which quantities I need later. -# -- Initialize -id_t = np.zeros_like(dat['latitude'], int) -frac_t = np.ndarray(id_t.shape, float) -frac_t[:] = float("nan") - -# Add a little flexibility by doing this per domain - namelists allow -# different output frequencies per domain. -iconout_files = dict() -iconout_times = dict() -iconout_start_time_ids = dict() - -# -- Get full time vector -iconout_prefix = settings['iconout_prefix'] -iconout_files = iconhelper.get_icon_filenames(iconout_prefix + "*") -iconout_times, iconout_start_time_ids = iconhelper.icon_times(iconout_files) - -# time id -for idx in range(len(dat['latitude'])): - # Look where it sorts in - tmp = [i - for i in range( len(iconout_times) -1 ) - if iconout_times[i] <= dat['time'][idx] \ - and dat['time'][idx] < iconout_times[i+1]] - - # Catch the case that the observation took place exactly at the last time step - if len(tmp) == 1: - id_t[idx] = tmp[0] - time0 = iconout_times[id_t[idx]] - time1 = iconout_times[id_t[idx] + 1] - frac_t[idx] = (time1 - dat['time'][idx]).total_seconds() / ( - time1 - time0).total_seconds() - - else: # len must be 0 in this case - if len(tmp) > 1:\ - raise ValueError("wat") - - if dat['time'][idx] == iconout_times[-1]: - # For debugging - print('check dat[time]: %s' % (dat['time'][idx])) - id_t[idx] = len(iconout_times) - 1 - frac_t[idx] = 1 - - else: - msg = "Sample %d, sounding_id %s: outside of simulated time." % ( - idx, dat['sounding_id'][idx]) - raise ValueError(msg) - -# -- Create dictionary for column sampling: -loc_input = dict(nn_sel_list=nn_sel_list, - weight_list=weight_list, - id_t=id_t, - frac_t=frac_t, - files=iconout_files, - file_start_time_indices=iconout_start_time_ids, - times=dat['time'][:], - latitude=lat_q, - longitude=lon_q) - -# -- Begin Sampling -ens_sim, prior = iconhelper.sample_total_columns_ICON(dat, loc_input, - member_names) - -# -- Write results to file -obs_ids = dat['sounding_id'] -# Remove simulations that are nan (=not in domain) -if ens_sim.shape[0] > 0: - valid = np.apply_along_axis(lambda arr: not np.any(np.isnan(arr)), 1, - ens_sim) - obs_ids_write = obs_ids[valid] - ens_sim_write = ens_sim[valid, :] - prior_sim_write = prior[valid, :] -else: - obs_ids_write = obs_ids - ens_sim_write = ens_sim - prior_sim_write = prior -### -if settings['nprocs'] == 1: - outfile = settings['outfile_prefix'] -else: - # Create output files with the appendix "..slice" - # Format so that they can later be easily sorted. - len_nproc = int(np.floor(np.log10(settings['nprocs']))) + 1 - outfile = settings['outfile_prefix'] + (".%0" + str(len_nproc) + - "d.slice") % settings['nproc'] - -os.system("echo 'Writing output file '" + - os.path.join(iconhelper.settings['run_dir'], outfile) + " >> " + - logfile) - -### Write -iconhelper.write_simulated_columns(obs_id=obs_ids_write, - simulated=ens_sim_write, - nmembers=nmembers, - outfile=outfile) - -iconhelper.write_simulated_columns(obs_id=obs_ids_write, - simulated=prior_sim_write, - nmembers=1, - outfile=outfile + '_prior.nc') - -os.chdir(cwd) - -os.system("echo 'Done' >> " + logfile) diff --git a/cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py b/cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py deleted file mode 100644 index 9f390744..00000000 --- a/cases/icon-art-CTDAS2/ctdas_patch/obs_class_ICOS_OCO2.py +++ /dev/null @@ -1,1166 +0,0 @@ -"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. -Users are recommended to contact the developers (wouter.peters@wur.nl) to receive -updates of the code. See also: http://www.carbontracker.eu. - -This program is free software: you can redistribute it and/or modify it under the -terms of the GNU General Public License as published by the Free Software Foundation, -version 3. This program is distributed in the hope that it will be useful, but -WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS -FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - -You should have received a copy of the GNU General Public License along with this -program. If not, see .""" -#!/usr/bin/env python -# obs.py -""" -.. module:: obs -.. moduleauthor:: Wouter Peters - -Revision History: -File created on 28 Jul 2010. - -.. autoclass:: da.baseclasses.obs.Observations - :members: setup, Validate, add_observations, add_simulations, add_model_data_mismatch, write_sample_coords - -.. autoclass:: da.baseclasses.obs.ObservationList - :members: __init__ - -""" - -import logging, sys, os -from numpy import array, ndarray -import datetime as dt -from datetime import timedelta -import numpy as np -from netCDF4 import Dataset -import xarray as xr -from multiprocessing import Pool -import datetime - -sys.path.append(os.getcwd()) -sys.path.append('../../') - -print("Python Version:", sys.version) -print("Python Executable Path:", sys.executable) - -from unidecode import unidecode - -identifier = 'Observations baseclass' -version = '0.0' - -from da.observations.obs_baseclass import Observations -import da.tools.io4 as io -import da.tools.rc as rc - -################### Begin Class Observations ################### - - -class ICOSObservations(object): - """ - The baseclass Observations is a generic object that provides a number of methods required for any type of observations used in - a data assimilation system. These methods are called from the CarbonTracker pipeline. - - .. note:: Most of the actual functionality will need to be provided through a derived Observations class with the methods - below overwritten. Writing your own derived class for Observations is one of the first tasks you'll likely - perform when extending or modifying the CarbonTracker Data Assimilation Shell. - - Upon initialization of the class, an object is created that holds no actual data, but has a placeholder attribute `self.Data` - which is an empty list of type :class:`~da.baseclasses.obs.ObservationList`. An ObservationList object is created when the - method :meth:`~da.baseclasses.obs.Observations.add_observations` is invoked in the pipeline. - - From the list of observations, a file is written by method - :meth:`~da.baseclasses.obs.Observations.write_sample_info` - with the sample info needed by the - :class:`~da.baseclasses.observationoperator.ObservationOperator` object. The values returned after sampling - are finally added by :meth:`~da.baseclasses.obs.Observations.add_simulations` - - """ - - def __init__(self): - """ - create an object with an identifier, version, and an empty ObservationList - """ - self.ID = identifier - self.version = version - self.datalist = [] # initialize with an empty list of obs - - # The following code allows the object to be initialized with a dacycle object already present. Otherwise, it can - # be added at a later moment. - - logging.info('Observations object initialized: %s' % self.ID) - - def getlength(self): - return len(self.datalist) - - def setup(self, dacycle): - """ Perform all steps needed to start working with observational data, this can include moving data, concatenating files, - selecting datasets, etc. - """ - - self.startdate = dacycle['time.sample.start'] - self.enddate = dacycle['time.sample.end'] - op_dir = dacycle.dasystem['obs.input.dir'] - #self.obs_fname = dacycle.dasystem['obs.input.fname'] - self.n_bg_params = int(dacycle['statevector.bg_params']) - self.tracer = str(dacycle['statevector.tracer']) - if not os.path.exists(op_dir): - msg = 'Could not find the required ObsPack distribution (%s) ' % op_dir - logging.error(msg) - raise IOError(msg) - else: - self.obspack_dir = op_dir - - self.datalist = [] - - def get_samples_type(self): - return 'insitu' - - def add_observations(self): - """ - Add actual observation data to the Observations object. This is in a form of an - :class:`~da.baseclasses.obs.ObservationList` that is contained in self.Data. The - list has as only requirement that it can return the observed+simulated values - through the method :meth:`~da.baseclasses.obs.ObservationList.getvalues` - - """ - - # Step 1: Read list of available site files in package - ###################################################### - - mdm_dict = {{}} - - mountain_stations = [ - 'Jungfraujoch_5', 'Monte Cimone_8', 'Puy de Dome_10', - 'Pic du Midi_28', 'Zugspitze_3', 'Hohenpeissenberg_50', - 'Hohenpeissenberg_93', 'Hohenpeissenberg_131', 'Schauinsland_12', - 'Plateau Rosa_10' - ] - skip_stations = [ - 'Malin Head_47', - 'Hegyhatsal hatterszennyettseg-mero allomas_48', - 'Hegyhatsal hatterszennyettseg-mero allomas_82', - 'Birkenes_2', - 'Hegyhatsal hatterszennyettseg-mero allomas_115', - 'Hegyhatsal hatterszennyettseg-mero allomas_10', - 'Beromunster_12', - 'Beromunster_44', - 'Beromunster_72', - 'Beromunster_132', - 'Bilsdale_42', - 'Bilsdale_108', - 'Cabauw_27', - 'Cabauw_67', - 'Cabauw_127', - 'Gartow_30', - 'Gartow_60', - 'Gartow_132', - 'Gartow_216', - 'Hohenpeissenberg_50', - 'Hohenpeissenberg_93', - 'Hyltemossa_30', - 'Hyltemossa_70', - 'Ispra_40', - 'Ispra_60', - 'Karlsruhe_30', - 'Karlsruhe_60', - 'Karlsruhe_100', - 'Kresin u Pacova_10', - 'Kresin u Pacova_50', - 'Kresin u Pacova_125', - 'Lindenberg_2', - 'Lindenberg_10', - 'Lindenberg_40', - 'Observatoire de Haute Provence_10', - 'Observatoire de Haute Provence_50', - "Observatoire perenne de l'environnement_10", - "Observatoire perenne de l'environnement_50", - 'Ridge Hill_45', - 'Saclay_15', - 'Saclay_60', - 'Tacolneston_54', - 'Tacolneston_100', - 'Torfhaus_10', - 'Torfhaus_76', - 'Torfhaus_110', - 'Trainou_5', - 'Trainou_50', - 'Trainou_100', - ] - - os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE" - - ########################################################################################################## - # THE FOLLOWING COMMENTED BLOCK IS FOR READING-IN REAL DATA - ########################################################################################################## - c_offset = 2 # ppm - - mdm_dictionary = { - { - "Beromunster_212": 6.2383423 + c_offset, - "Bilsdale_248": 3.8534036 + c_offset, - "Biscarrosse_47": 3.5997221 + c_offset, - "Cabauw_207": 6.6093283 + c_offset, - "Carnsore Point_14": 2.1894007 + c_offset, - "Ersa_40": 2.3997285 + c_offset, - "Gartow_341": 4.570544 + c_offset, - "Heidelberg_30": 8.660628 + c_offset, - "Hohenpeissenberg_131": 4.0553513 + c_offset, - "Hyltemossa_150": 3.485432 + c_offset, - "Ispra_100": 9.612817 + c_offset, - "Jungfraujoch_5": 1.0802848 + c_offset, - "Karlsruhe_200": 8.05013 + c_offset, - "Kresin u Pacova_250": 3.829324 + c_offset, - "La Muela_80": 3.2093291 + c_offset, - "Laegern-Hochwacht_32": 9.556924 + c_offset, - "Lindenberg_98": 5.4387555 + c_offset, - "Lutjewad_60": 5.651525 + c_offset, - "Monte Cimone_8": 1.7325112 + c_offset, - "Observatoire de Haute Provence_100": 4.146905 + c_offset, - "Observatoire perenne de l'environnement_120": - 6.8854113 + c_offset, - "Pic du Midi_28": 1.2196398 + c_offset, - "Plateau Rosa_10": 1.3211231 + c_offset, - "Puy de Dome_10": 3.4529948 + c_offset, - "Ridge Hill_90": 5.0861707 + c_offset, - "Saclay_100": 6.8669567 + c_offset, - "Schauinsland_12": 3.7896755 + c_offset, - "Tacolneston_185": 4.6675706 + c_offset, - "Torfhaus_147": 4.622525 + c_offset, - "Trainou_180": 5.821612 + c_offset, - "Weybourne_10": 4.4674397 + c_offset, - "Zugspitze_3": 1.6796716 + c_offset - } - } # Based on the simulated standard deviation of the signal (without background) over a full year. - - u_id = 1 - for ncfile in os.listdir(self.obspack_dir): - if not ncfile.endswith('.nc'): continue - - logging.info('Found file ', ) - infile = os.path.join(self.obspack_dir, ncfile) - print("infile = ", infile) - - f = xr.open_dataset(infile) - - logging.info('Looking into the file %s...' % (infile)) - - sites_names = np.array( - [unidecode(x) for x in f.Stations_names.values]) - - mountain_hours = ['0' + str(x) for x in np.arange(0, 7)] - rest_hours = [str(x) for x in np.arange(12, 17)] - - st_ind = np.arange(len(sites_names)) - - #def caculate_interval_mean_cnc(dates, conc, hr): - - for x in st_ind: - - station_name = sites_names[x] - if station_name in skip_stations: - continue # Skip stations outside of the domain! - - cnc = f.Concentration[x].values - - dates = f.Dates[x].values - flag = 1 - mdm_value = mdm_dictionary[ - station_name] # ERIK: CHANGED FROM constant 10 - height = f.Stations_masl[x].values - lon = f.Lon[x].values - lat = f.Lat[x].values - species = self.tracer - strategy = 1 - - # ERIK: What is the influence of using UTC here? 00 UTC is already 1 o clock in the Netherlands? BUT, simulation is not w.r.t. UTC (or is it?). - if station_name in mountain_stations: - ind_dt = np.asarray([ - str(x)[11:13] in mountain_hours - for x in f.Dates.values[x] - ]) #mask of hours taken for mountain sites - hr = 0 - else: - ind_dt = np.asarray([ - str(x)[11:13] in rest_hours for x in f.Dates.values[x] - ]) #mask of hours taken for the rest of the sites - hr = 12 - data = cnc[ind_dt] - times = np.asarray([ - datetime.datetime.strptime(str(x)[:-13], "%Y-%m-%dT%H:%M") - for x in dates[ind_dt] - ]) - logging.info('Check dates: %s %s' % - (self.enddate + timedelta(days=1), - self.startdate + timedelta(days=1))) - mask_da_interval = np.logical_and( - times <= (self.enddate + timedelta(days=1)), - (self.startdate + timedelta(days=1)) <= times) - times = times[mask_da_interval] - data = data[mask_da_interval] - if len(times) > 0: - for iday in set([ii.day for ii in times]): - ids = [ - iii for iii, dd in enumerate(times) - if dd.day == iday - ] - value = np.nanmean( - np.array([ - c for i, c in enumerate(data) - if times[i].day == iday - ])) - dict_date = times[ids[0]].replace(hour=hr) - if not np.isfinite(value): continue - - self.datalist.append( - MoleFractionSample(u_id, dict_date, station_name, - value, 0.0, 0.0, 0.0, mdm_value, - flag, height, lat, lon, - station_name, species, strategy, - 0.0, station_name)) - - logging.info( - 'For itime([day]T[hour]) (%iT%i) adding synthetic obs %i at station %s: %5.2e' - % (dict_date.day, dict_date.hour, u_id, - station_name, value)) - u_id += 1 - - # add_station_data_to_sample(x) - - logging.info("Observations list now holds %d values" % - len(self.datalist)) -########################################################################################################## - - def add_simulations(self, filename, silent=False): - """ Add the simulation data to the Observations object. - """ - - if not os.path.exists(filename): - msg = "Sample output filename for observations could not be found : %s" % filename - logging.error(msg) - logging.error("Did the sampling step succeed?") - logging.error("...exiting") - raise IOError(msg) - - ncf = io.ct_read(filename, method='read') - ids = ncf.get_variable('obs_num') - simulated = ncf.get_variable('flask') - ncf.close() - logging.info("Successfully read data from model sample file (%s)" % - filename) - - obs_ids = self.getvalues('id').tolist() - ids = list(map(int, ids)) - - missing_samples = [] - - for idx, val in zip(ids, simulated): - if idx in obs_ids: - index = obs_ids.index(idx) - self.datalist[index].simulated = val # in mol/mol - else: - missing_samples.append(idx) - - if not silent and missing_samples != []: - logging.warning( - 'Model samples were found that did not match any ID in the observation list. Skipping them...' - ) - msg = '%s' % missing_samples - logging.warning(msg) - - logging.debug("Added %d simulated values to the Data list" % - (len(ids) - len(missing_samples))) - logging.info("Added %d simulated values to the Data list" % - (len(ids) - len(missing_samples))) - - def add_model_data_mismatch(self, filename): - """ - Get the model-data mismatch values for this cycle. - """ - self.rejection_threshold = 10.0 # 3-sigma cut-off - self.global_R_scaling = 1.0 # no scaling applied - - for obs in self.datalist: # first loop over all available data points to set flags correctly - - obs.may_localize = True #False - obs.may_reject = False - obs.flag = 0 - - logging.debug("Added Model Data Mismatch to all samples ") - - def write_sample_coords(self, obsinputfile): - """ - Write the information needed by the observation operator to a file. Return the filename that was written for later use - """ - - if len(self.datalist) == 0: - logging.debug( - "No observations found for this time period, nothing written to obs file" - ) - else: - f = io.CT_CDF(obsinputfile, method='create') - logging.debug( - 'Creating new observations file for ObservationOperator (%s)' % - obsinputfile) - - dimid = f.add_dim('obs', len(self.datalist)) - # dim200char = f.add_dim('string_of200chars', 200) - dim50char = f.add_dim('string_of50chars', 50) - dim3char = f.add_dim('string_of3chars', 3) - dimcalcomp = f.add_dim('calendar_components', 6) - - data = self.getvalues('id') - - savedict = io.std_savedict.copy() - savedict['name'] = "obs_num" - savedict['dtype'] = "int" - savedict['long_name'] = "Unique_Dataset_observation_index_number" - savedict['units'] = "" - savedict['dims'] = dimid - savedict['values'] = data.tolist() - savedict[ - 'comment'] = "Unique index number within this dataset ranging from 0 to UNLIMITED." - f.add_data(savedict) - - data = self.getvalues('evn') - # print("data==", data) - - savedict = io.std_savedict.copy() - savedict['name'] = "evn" - savedict['dtype'] = "char" - savedict['long_name'] = "Site_name_abbreviation" - savedict['units'] = "" - savedict['dims'] = dimid + dim50char - savedict['values'] = data.tolist() - savedict['comment'] = "Site name abbreviation as in the data file." - f.add_data(savedict) - - data = self.getvalues('fromfile') - - savedict = io.std_savedict.copy() - savedict['name'] = "fromfile" - savedict['dtype'] = "char" - savedict['long_name'] = "data_file_name" - savedict['units'] = "" - savedict['dims'] = dimid + dim50char - savedict['values'] = data.tolist() - savedict['comment'] = "File name of data file." - f.add_data(savedict) - - data = [[d.year, d.month, d.day, d.hour, d.minute, d.second] - for d in self.getvalues('xdate')] - - savedict = io.std_savedict.copy() - savedict['dtype'] = "int" - savedict['name'] = "date_components" - savedict['units'] = "integer components of UTC date/time" - savedict['dims'] = dimid + dimcalcomp - savedict['values'] = data - savedict['missing_value'] = -999 - savedict[ - 'comment'] = "Calendar date components as integers. Times and dates are UTC." - savedict['order'] = "year, month, day, hour, minute, second" - f.add_data(savedict) - - data = self.getvalues('lat') - - savedict = io.std_savedict.copy() - savedict['dtype'] = "float" - savedict['name'] = "latitude" - savedict['units'] = "degrees_north" - savedict['dims'] = dimid - savedict['values'] = data.tolist() - savedict['missing_value'] = -999.9 - f.add_data(savedict) - - data = self.getvalues('lon') - - savedict = io.std_savedict.copy() - savedict['dtype'] = "float" - savedict['name'] = "longitude" - savedict['units'] = "degrees_east" - savedict['dims'] = dimid - savedict['values'] = data.tolist() - savedict['missing_value'] = -999.9 - f.add_data(savedict) - - data = self.getvalues('height') - - savedict = io.std_savedict.copy() - savedict['dtype'] = "float" - savedict['name'] = "altitude" - savedict['units'] = "meters_above_sea_level" - savedict['dims'] = dimid - savedict['values'] = data.tolist() - savedict['missing_value'] = -999.9 - f.add_data(savedict) - - data = self.getvalues('samplingstrategy') - - savedict = io.std_savedict.copy() - savedict['dtype'] = "int" - savedict['name'] = "sampling_strategy" - savedict['units'] = "NA" - savedict['dims'] = dimid - savedict['values'] = data.tolist() - savedict['missing_value'] = -999 - f.add_data(savedict) - - data = self.getvalues('obs') - - savedict = io.std_savedict.copy() - savedict['dtype'] = "float" - savedict['name'] = "observed" - savedict['long_name'] = "observedvalues" - savedict['units'] = "mol mol-1" - savedict['dims'] = dimid - savedict['values'] = data.tolist() - savedict['comment'] = 'Observations used in optimization' - f.add_data(savedict) - - data = self.getvalues('mdm') - - savedict = io.std_savedict.copy() - savedict['dtype'] = "float" - savedict['name'] = "modeldatamismatch" - savedict['long_name'] = "modeldatamismatch" - savedict['units'] = "[mol mol-1]" - savedict['dims'] = dimid - savedict['values'] = data.tolist() - savedict[ - 'comment'] = 'Standard deviation of mole fractions resulting from model-data mismatch' - f.add_data(savedict) - f.close() - - logging.debug("Successfully wrote data to obs file") - logging.info( - "Sample input file for obs operator now in place [%s]" % - obsinputfile) - - def write_sample_auxiliary(self, auxoutputfile): - """ - Write selected additional information contained in the Observations object to a file for later processing. - - """ - - def getvalues(self, name, constructor=array): - - result = constructor([getattr(o, name) for o in self.datalist]) - if isinstance(result, ndarray): - return result.squeeze() - else: - return result - - -################### End Class Observations ################### - -################### Begin Class MoleFractionSample ################### - - -class MoleFractionSample(object): - """ - Holds the data that defines a mole fraction Sample in the data assimilation framework. Sor far, this includes all - attributes listed below in the __init__ method. One can additionally make more types of data, or make new - objects for specific projects. - - """ - - def __init__(self, - idx, - xdate, - code='XXX', - obs=0.0, - simulated=0.0, - resid=0.0, - hphr=0.0, - mdm=0.0, - flag=0, - height=0.0, - lat=-999., - lon=-999., - evn='0000', - species='co2', - samplingstrategy=1, - sdev=0.0, - fromfile='none.nc'): - self.code = code.strip( - ) # dataset identifier, i.e., co2_lef_tower_insitu_1_99 - self.xdate = xdate # Date of obs - self.obs = obs # Value observed - self.simulated = simulated # Value simulated by model - self.resid = resid # Mole fraction residuals - self.hphr = hphr # Mole fraction prior uncertainty from fluxes and (HPH) and model data mismatch (R) - self.mdm = mdm # Model data mismatch - self.may_localize = True # Whether sample may be localized in optimizer - self.may_reject = True # Whether sample may be rejected if outside threshold - self.flag = flag # Flag - self.height = height # Sample height in masl - self.lat = lat # Sample lat - self.lon = lon # Sample lon - self.id = idx # Obspack ID within distrution (integer), e.g., 82536 - self.evn = evn # Obspack Number within distrution (string), e.g., obspack_co2_1_PROTOTYPE_v0.9.2_2012-07-26_99_82536 - self.sdev = sdev # standard deviation of ensemble - self.masl = True # Sample is in Meters Above Sea Level - self.mag = not self.masl # Sample is in Meters Above Ground - self.species = species.strip() - self.samplingstrategy = samplingstrategy - self.fromfile = fromfile # netcdf filename inside ObsPack distribution, to write back later - - -################### End Class MoleFractionSample ################### - - -################### Begin Class TotalColumnSample ################### -class TotalColumnSample(object): - """ - Holds the data that defines a total column sample in the data assimilation framework. Sor far, this includes all - attributes listed below in the __init__ method. One can additionally make more types of data, or make new - objects for specific projects. - This file may contain OCO-2 specific parts... - """ - - def __init__(self, idx, codex, xdate, obs=0.0, simulated=0.0, lat=-999., lon=-999., mdm=None, prior=0.0, prior_profile=0.0, av_kernel=0.0, pressure=0.0, \ - ##### freum vvvv - - - pressure_weighting_function=None, - ##### freum ^^^^ - level_def = "pressure_boundary", psurf = float('nan'), resid=0.0, hphr=0.0, flag=0, species='co2', sdev=0.0, \ - ##### freum vvvv - - - latc_0=None, latc_1=None, latc_2=None, latc_3=None, lonc_0=None, lonc_1=None, lonc_2=None, lonc_3=None \ - ##### freum ^^^^ - - - ): - self.id = idx # Sounding ID - self.code = codex # Retrieval ID - self.xdate = xdate # Date of obs - self.obs = obs # Value observed - self.simulated = simulated # Value simulated by model, fillvalue = -9999 - self.lat = lat # Sample lat - self.lon = lon # Sample lon - ##### freum vvvv - self.latc_0 = latc_0 # Sample latitude corner - self.latc_1 = latc_1 # Sample latitude corner - self.latc_2 = latc_2 # Sample latitude corner - self.latc_3 = latc_3 # Sample latitude corner - self.lonc_0 = lonc_0 # Sample longitude corner - self.lonc_1 = lonc_1 # Sample longitude corner - self.lonc_2 = lonc_2 # Sample longitude corner - self.lonc_3 = lonc_3 # Sample longitude corner - ##### freum ^^^^ - self.mdm = mdm # Model data mismatch - self.prior = prior # A priori column value used in retrieval - self.prior_profile = prior_profile # A priori profile used in retrieval - self.av_kernel = av_kernel # Averaging kernel - self.pressure = pressure # Pressure levels of retrieval - # freum vvvv - self.pressure_weighting_function = pressure_weighting_function # Pressure weighting function - # freum ^^^^ - self.level_def = level_def # Are prior and averaging kernel defined as layer averages? - self.psurf = psurf # Surface pressure (only needed if level_def is "layer_average") - self.loc_L = int( - 600 - ) #int(0) # freum 2021-07-13: insert this dummy value so the code runs with the current version of CTDAS. *Should* not affect results if localizetype == "CT2007" as in all my runs. However, replace this file with the standard observation file, obs_column_xco2.py - - self.resid = resid # Mole fraction residuals - self.hphr = hphr # Mole fraction prior uncertainty from fluxes and (HPH) and model data mismatch (R) - self.may_localize = True # Whether sample may be localized in optimizer - self.may_reject = True # Whether sample may be rejected if outside threshold - self.flag = flag # Flag - self.sdev = sdev # standard deviation of ensemble - self.species = species.strip() - - -################### End Class TotalColumnSample ################### - -################### Begin Class TotalColumnObservations ################### - - -class TotalColumnObservations(Observations): - """ An object that holds data + methods and attributes needed to manipulate column samples - """ - - def setup(self, dacycle): - - self.startdate = dacycle['time.sample.start'] + timedelta(days=1) - self.enddate = dacycle['time.sample.end'] - - # Path to the input data (daily files) - sat_files = dacycle.dasystem['obs.column.ncfile'].split(',') - sat_dirs = dacycle.dasystem['obs.column.input.dir'].split(',') - - self.sat_dirs = [] - self.sat_files = [] - for i in range(len(sat_dirs)): - if not os.path.exists(sat_dirs[i].strip()): - msg = 'Could not find the required satellite input directory (%s) ' % sat_dirs[ - i] - logging.error(msg) - raise IOError(msg) - else: - self.sat_dirs.append(sat_dirs[i].strip()) - self.sat_files.append(sat_files[i].strip()) - del i - - # Get observation selection criteria (if present): - if 'obs.column.selection.variables' in dacycle.dasystem.keys( - ) and 'obs.column.selection.criteria' in dacycle.dasystem.keys(): - self.selection_vars = dacycle.dasystem[ - 'obs.column.selection.variables'].split(',') - self.selection_criteria = dacycle.dasystem[ - 'obs.column.selection.criteria'].split(',') - logging.debug('Data selection criteria found: %s, %s' % - (self.selection_vars, self.selection_criteria)) - else: - self.selection_vars = [] - self.selection_criteria = [] - logging.info( - 'No data observation selection criteria found, using all observations in file.' - ) - - # Model data mismatch approach - # self.mdm_calculation = dacycle.dasystem.get('mdm.calculation') - # logging.debug('mdm.calculation = %s' %self.mdm_calculation) - # if not self.mdm_calculation in ['parametrization','empirical','no_transport_error']: - # logging.warning('No valid model data mismatch method found. Valid options are \'parametrization\' and \'empirical\'. ' + \ - # 'Using a constant estimate for the model uncertainty of 1ppm everywhere.') - # else: - # logging.info('Model data mismatch approach = %s' %self.mdm_calculation) - - # Path to file with observation error settings for column observations - # Currently the same settings for all assimilated retrieval products: should this be one file per product? - logging.debug('Skipping obs.column.rc check!') - # if not os.path.exists(dacycle.dasystem['obs.column.rc']): - # msg = 'Could not find the required column observation .rc input file (%s) ' % dacycle.dasystem['obs.column.rc'] - # logging.debug(msg) - # logging.debug('...but continuing!') - # # logging.error(msg) - # # raise IOError(msg) - # else: - # self.obs_file = (dacycle.dasystem['obs.column.rc']) - - self.datalist = [] - - # Switch to indicate whether simulated column samples are read from obsOperator output, - # or whether the sampling is done within CTDAS (in obsOperator class) - self.sample_in_ctdas = dacycle.dasystem[ - 'sample.in.ctdas'] if 'sample.in.ctdas' in dacycle.dasystem.keys( - ) else False - logging.debug('sample.in.ctdas = %s' % self.sample_in_ctdas) - - def get_samples_type(self): - return 'column' - - def add_observations(self): - """ Reading of total column observations, and selection of observations that will be sampled and assimilated. - - """ - - # Read observations from daily input files - for i in range(len(self.sat_dirs)): - - logging.info('Reading observations from %s' % - os.path.join(self.sat_dirs[i], self.sat_files[i])) - - infile0 = os.path.join(self.sat_dirs[i], self.sat_files[i]) - ndays = 0 - - while self.startdate + dt.timedelta(days=ndays) <= self.enddate: - - infile = infile0.replace( - "", - (self.startdate + - dt.timedelta(days=ndays)).strftime("%Y%m%d")) - logging.info('To be precise, reading observations from %s' % - infile) - - if os.path.exists(infile): - - logging.info("Reading observations for %s" % - (self.startdate + - dt.timedelta(days=ndays)).strftime("%Y%m%d")) - len_init = len(self.datalist) - - # get index of observations that satisfy selection criteria (based on variable names and values in system rc file, if present) - ncf = io.ct_read(infile, 'read') - if self.selection_vars: - selvars = [] - for j in self.selection_vars: - selvars.append(ncf.get_variable(j.strip())) - del j - criteria = [] - for j in range(len(self.selection_vars)): - criteria.append( - eval('selvars[j]' + - self.selection_criteria[j])) - del j - #criteria = [eval('selvars[i]'+self.selection_criteria[i]) for i in range(len(self.selection_vars))] - subselect = np.logical_and.reduce( - criteria).nonzero()[0] - else: - subselect = np.arange( - ncf.get_variable('sounding_id').size) - - # retrieval attributes - code = ncf.get_attribute('retrieval_id') - level_def = ncf.get_attribute('level_def') - - # only read good quality observations - ids = ncf.get_variable('sounding_id').take(subselect, - axis=0) - lats = ncf.get_variable('latitude').take(subselect, axis=0) - lons = ncf.get_variable('longitude').take(subselect, - axis=0) - obs = ncf.get_variable('obs').take(subselect, axis=0) - unc = ncf.get_variable('uncertainty').take(subselect, - axis=0) - dates = ncf.get_variable('date').take(subselect, axis=0) - dates = array([dt.datetime(*d) for d in dates]) - av_kernel = ncf.get_variable('averaging_kernel').take( - subselect, axis=0) - prior_profile = ncf.get_variable('prior_profile').take( - subselect, axis=0) - pressure = ncf.get_variable('pressure_levels').take( - subselect, axis=0) - - prior = ncf.get_variable('prior').take(subselect, axis=0) - - ##### freum vvvv - pwf = ncf.get_variable('pressure_weighting_function').take( - subselect, axis=0) - - # Additional variable surface pressure in case the profiles are defined as layer averages - if level_def == "layer_average": - psurf = ncf.get_variable('surface_pressure').take( - subselect, axis=0) - else: - psurf = [float('nan')] * len(ids) - - # Optional: footprint corners - latc = dict(latc_0=[float('nan')] * len(ids), - latc_1=[float('nan')] * len(ids), - latc_2=[float('nan')] * len(ids), - latc_3=[float('nan')] * len(ids)) - lonc = dict(lonc_0=[float('nan')] * len(ids), - lonc_1=[float('nan')] * len(ids), - lonc_2=[float('nan')] * len(ids), - lonc_3=[float('nan')] * len(ids)) - # If one footprint corner variable is there, assume - # all are there. That's the only case that makes sense - if 'latc_0' in list(ncf.variables.keys()): - latc['latc_0'] = ncf.get_variable('latc_0').take( - subselect, axis=0) - latc['latc_1'] = ncf.get_variable('latc_1').take( - subselect, axis=0) - latc['latc_2'] = ncf.get_variable('latc_2').take( - subselect, axis=0) - latc['latc_3'] = ncf.get_variable('latc_3').take( - subselect, axis=0) - lonc['lonc_0'] = ncf.get_variable('lonc_0').take( - subselect, axis=0) - lonc['lonc_1'] = ncf.get_variable('lonc_1').take( - subselect, axis=0) - lonc['lonc_2'] = ncf.get_variable('lonc_2').take( - subselect, axis=0) - lonc['lonc_3'] = ncf.get_variable('lonc_3').take( - subselect, axis=0) - ###### freum ^^^^ - - ncf.close() - - # Add samples to datalist - # Note that the mdm is initialized here equal to the measurement uncertainty. This value is used in add_model_data_mismatch to calculate the mdm including model error - for n in range(len(ids)): - # Check for every sounding if time is between start and end time (relevant for first and last days of window) - if self.startdate <= dates[n] <= self.enddate: - self.datalist.append(TotalColumnSample(ids[n], code, dates[n], obs[n], None, lats[n], lons[n], unc[n], prior[n], prior_profile[n,:], \ - av_kernel=av_kernel[n,:], pressure=pressure[n,:], pressure_weighting_function=pwf[n,:],level_def=level_def,psurf=psurf[n], - ##### freum vvvv - latc_0=latc['latc_0'][n], latc_1=latc['latc_1'][n], latc_2=latc['latc_2'][n], latc_3=latc['latc_3'][n], - lonc_0=lonc['lonc_0'][n], lonc_1=lonc['lonc_1'][n], lonc_2=lonc['lonc_2'][n], lonc_3=lonc['lonc_3'][n] - ##### freum ^^^^ - )) - - logging.debug("Added %d observations to the Data list" % - (len(self.datalist) - len_init)) - - ndays += 1 - - del i - - if len(self.datalist) > 0: - logging.info("Observations list now holds %d values" % - len(self.datalist)) - else: - logging.info("No observations found for sampling window") - - def add_model_data_mismatch(self, filename=None, advance=False): - """ This function is empty: model data mismatch calculation is done during sampling in observation operator (TM5) to enhance computational efficiency - (i.e. to prevent reading all soundings twice and writing large additional files) - - """ - # obs_data = rc.read(self.obs_file) - self.rejection_threshold = 15 #int(obs_data['obs.rejection.threshold']) - - # At this point mdm is set to the measurement uncertainty only, added in the add_observations function. - # Here this value is used to set the combined mdm by adding an estimate for the model uncertainty as a sum of squares. - if len(self.datalist) <= 1: return #== 0: return - for obs in self.datalist: - obs.mdm = ( - obs.mdm * obs.mdm + 2**2 - )**0.5 ## Here changed into 2 (2ppm) for CO2 : ERIK, CHANGE THIS TO WHAT I NEED! - del obs - - meanmdm = np.average(np.array([obs.mdm for obs in self.datalist])) - logging.debug('Mean MDM = %s' % meanmdm) - - def add_simulations(self, filename, silent=False): - """ Adds observed and model simulated column values to the mole fraction objects - This function includes the add_observations and add_model_data_mismatch functionality for the sake of computational efficiency - - """ - - if self.sample_in_ctdas: - logging.debug( - "CODE TO ADD SIMULATED SAMPLES TO DATALIST TO BE ADDED") - - else: - # read simulated samples from file - if not os.path.exists(filename): - msg = "Sample output filename for observations could not be found : %s" % filename - logging.error(msg) - logging.error("Did the sampling step succeed?") - logging.error("...exiting") - raise IOError(msg) - - ncf = io.ct_read(filename, method='read') - ids = ncf.get_variable('sounding_id') - simulated = ncf.get_variable('column_modeled') - ncf.close() - logging.info("Successfully read data from model sample file (%s)" % - filename) - - obs_ids = self.getvalues('id').tolist() - - missing_samples = [] - - # Match read simulated samples with observations in datalist - logging.info("Adding %i simulated samples to the data list..." % - len(ids)) - for i in range(len(ids)): - # Assume samples are in same order in both datalist and file with simulated samples... - if ids[i] == obs_ids[i]: - self.datalist[i].simulated = simulated[i] - # If not, find index of current sample - elif ids[i] in obs_ids: - index = obs_ids.index(ids[i]) - # Only add simulated value to datalist if sample has not been filled before. Otherwise: exiting - if self.datalist[index].simulated is not None: - msg = 'Simulated and observed samples not in same order, and duplicate sample IDs found.' - logging.error(msg) - raise IOError(msg) - else: - self.datalist[index].simulated = simulated[i] - else: - logging.debug('added %s to missing_samples, obs id = %s' % - (ids[i], obs_ids[i])) - missing_samples.append(ids[i]) - del i - - if not silent and missing_samples != []: - logging.warning( - '%i Model samples were found that did not match any ID in the observation list. Skipping them...' - % len(missing_samples)) - - # if number of simulated samples < observations: remove observations without samples - if len(simulated) < len(self.datalist): - test = len(self.datalist) - len(simulated) - logging.warning( - '%i Observations were not sampled, removing them from datalist...' - % test) - for index in reversed(list(range(len(self.datalist)))): - if self.datalist[index].simulated is None: - del self.datalist[index] - del index - - logging.debug("%d simulated values were added to the data list" % - (len(ids) - len(missing_samples))) - - def write_sample_coords(self, obsinputfile): - """ - Write empty sample_coords_file if soundings are present in time interval, just such that general pipeline code does not have to be changed... - """ - - if self.sample_in_ctdas: - return - - if len(self.datalist) <= 1: #== 0: - logging.info( - "No observations found for this time period, no obs file written" - ) - return - - # write data required by observation operator for sampling to file - f = io.CT_CDF(obsinputfile, method='create') - logging.debug( - 'Creating new observations file for ObservationOperator (%s)' % - obsinputfile) - - dimsoundings = f.add_dim('soundings', len(self.datalist)) - dimdate = f.add_dim('epoch_dimension', 7) - dimchar = f.add_dim('char', 20) - if len(self.datalist) == 1: - dimlevels = f.add_dim('levels', len(self.getvalues('pressure'))) - # freum: inserted but commented Liesbeth's new code for layers for reference, - # but I handle them differently. - # if len(self.getvalues('av_kernel')) != len(self.getvalues('pressure')): - # dimlayers = f.add_dim('layers',len(self.getvalues('av_kernel'))) - # layers = True - # else: layers = False - else: - dimlevels = f.add_dim('levels', - self.getvalues('pressure').shape[1]) - # if self.getvalues('av_kernel').shape[1] != self.getvalues('pressure').shape[1]: - # dimlayers = f.add_dim('layers', self.getvalues('pressure').shape[1] - 1) - # layers = True - # else: layers = False - - savedict = io.std_savedict.copy() - savedict['dtype'] = "int64" - savedict['name'] = "sounding_id" - savedict['dims'] = dimsoundings - savedict['values'] = self.getvalues('id').tolist() - f.add_data(savedict) - - data = [[ - d.year, d.month, d.day, d.hour, d.minute, d.second, d.microsecond - ] for d in self.getvalues('xdate')] - savedict = io.std_savedict.copy() - savedict['dtype'] = "int" - savedict['name'] = "date" - savedict['dims'] = dimsoundings + dimdate - savedict['values'] = data - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "latitude" - savedict['dims'] = dimsoundings - savedict['values'] = self.getvalues('lat').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "longitude" - savedict['dims'] = dimsoundings - savedict['values'] = self.getvalues('lon').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "prior" - savedict['dims'] = dimsoundings - savedict['values'] = self.getvalues('prior').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "prior_profile" - savedict['dims'] = dimsoundings + dimlevels - savedict['values'] = self.getvalues('prior_profile').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "averaging_kernel" - savedict['dims'] = dimsoundings + dimlevels - savedict['values'] = self.getvalues('av_kernel').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "pressure_levels" - savedict['dims'] = dimsoundings + dimlevels - savedict['values'] = self.getvalues('pressure').tolist() - f.add_data(savedict) - - # freum vvvv - savedict = io.std_savedict.copy() - savedict['name'] = "pressure_weighting_function" - savedict['dims'] = dimsoundings + dimlevels - savedict['values'] = self.getvalues( - 'pressure_weighting_function').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "latc_0" - savedict['dims'] = dimsoundings - savedict['values'] = self.getvalues('latc_0').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "latc_1" - savedict['dims'] = dimsoundings - savedict['values'] = self.getvalues('latc_1').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "latc_2" - savedict['dims'] = dimsoundings - savedict['values'] = self.getvalues('latc_2').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "latc_3" - savedict['dims'] = dimsoundings - savedict['values'] = self.getvalues('latc_3').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "lonc_0" - savedict['dims'] = dimsoundings - savedict['values'] = self.getvalues('lonc_0').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "lonc_1" - savedict['dims'] = dimsoundings - savedict['values'] = self.getvalues('lonc_1').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "lonc_2" - savedict['dims'] = dimsoundings - savedict['values'] = self.getvalues('lonc_2').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "lonc_3" - savedict['dims'] = dimsoundings - savedict['values'] = self.getvalues('lonc_3').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "XCO2" - savedict['dims'] = dimsoundings - savedict['values'] = self.getvalues('obs').tolist() - f.add_data(savedict) - - # freum ^^^^ - - savedict = io.std_savedict.copy() - savedict['dtype'] = "char" - savedict['name'] = "level_def" - savedict['dims'] = dimsoundings + dimchar - savedict['values'] = self.getvalues('level_def').tolist() - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "psurf" - savedict['dims'] = dimsoundings - savedict['values'] = self.getvalues('psurf').tolist() - f.add_data(savedict) - - f.close() - - -################### End Class TotalColumnObservations ################### - -if __name__ == "__main__": - pass diff --git a/cases/icon-art-CTDAS2/ctdas_patch/obsoperator_ICOS_OCO2.py b/cases/icon-art-CTDAS2/ctdas_patch/obsoperator_ICOS_OCO2.py deleted file mode 100644 index 06b24e28..00000000 --- a/cases/icon-art-CTDAS2/ctdas_patch/obsoperator_ICOS_OCO2.py +++ /dev/null @@ -1,880 +0,0 @@ -"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. -Users are recommended to contact the developers (wouter.peters@wur.nl) to receive -updates of the code. See also: http://www.carbontracker.eu. - -This program is free software: you can redistribute it and/or modify it under the -terms of the GNU General Public License as published by the Free Software Foundation, -version 3. This program is distributed in the hope that it will be useful, but -WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS -FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - -You should have received a copy of the GNU General Public License along with this -program. If not, see .""" -#!/usr/bin/env python -# model.py -""" -.. module:: observationoperator -.. moduleauthor:: Wouter Peters - -Revision History: -File created on 30 Aug 2010. - -""" - -import logging -import subprocess -import datetime as dt -import numpy as np -from netCDF4 import Dataset -import os, sys -from multiprocessing import Pool -from scipy import interpolate -import da.tools.io4 as io - -sys.path.append(os.getcwd()) -sys.path.append('../../') - -import da.tools.rc as rc -from da.tools.icon.icon_helper import ICON_Helper -from da.tools.icon.utilities import utilities -import subprocess -import glob - -identifier = 'RandomizerObservationOperator' -version = '1.0' - - -################### Begin Class ObservationOperator ################### -class ObservationOperator(object): - """ - Testing - ======= - This is a class that defines an ObervationOperator. This object is used to control the sampling of - a statevector in the ensemble Kalman filter framework. The methods of this class specify which (external) code - is called to perform the sampling, and which files should be read for input and are written for output. - - The baseclasses consist mainly of empty methods that require an application specific application. The baseclass will take observed values, and perturb them with a random number chosen from the model-data mismatch distribution. This means no real operator will be at work, but random normally distributed residuals will come out of y-H(x) and thus the inverse model can proceed. This is mainly for testing the code... - - """ - - def __init__(self, - rc_filename, - dacycle=None): # David: addition arg "rc_filename" added. - """ The instance of an ObservationOperator is application dependent """ - self.ID = identifier - self.version = version - self.restart_filelist = [] - self.output_filelist = [] - self.outputdir = None # Needed for opening the samples.nc files created - - # vvv Added by David: - # Load settings - self._load_rc(rc_filename) - self._validate_rc() - - # Instantiate an ICON_Helper object *David could be useful for icon sampler - self.settings["dir.icon_sim"] - - self.iconhelper = ICON_Helper(self.settings) - self.iconhelper.validate_settings(["dir.icon_sim"]) - # ^^^ Added by David: ^^^ - - logging.info('Observation Operator object initialized: %s (%s)', - self.ID, self.version) - - # The following code allows the object to be initialized with a dacycle object already present. Otherwise, it can - # be added at a later moment. - - if dacycle != None: - self.dacycle = dacycle - else: - self.dacycle = {{}} - - def _load_rc(self, name): - """Read settings from the observation operator's rc-file - - Based on TM5ObservationOperator.load_rc - """ - self.rcfile = rc.RcFile(name) - self.settings = self.rcfile.values - self.rc_filename = name - - logging.debug("rc-file %s loaded", name) - - def _validate_rc(self): - """Check that some required values are given in the rc-file. - - Based on TM5ObservationOperator.validate_rc - """ - - needed_rc_items = ["dir.icon_sim", "obsoperator.icon_exe"] - - for key in needed_rc_items: - if key not in self.settings: - msg = "Missing a required value in rc-file : %s" % key - logging.error(msg) - raise IOError(msg) - logging.debug("rc-file has been validated succesfully") - - def get_initial_data(self): - """ This method places all initial data needed by an ObservationOperator in the proper folder for the model """ - - def setup(self, dacycle): - """ Perform all steps necessary to start the observation operator through a simple Run() call """ - - self.dacycle = dacycle - self.outputdir = dacycle['dir.output'] - self.simulationdir = dacycle['dir.icon_sim'] - self.n_bg_params = int(dacycle['statevector.bg_params']) - self.n_regs = int(dacycle['statevector.number_regions']) - self.tracer = str(dacycle['statevector.tracer']) - - def prepare_run(self, samples): - """ Prepare the running of the actual forecast model, for example compile code """ - - import os - - # For each sample type, define the name of the file that will contain the modeled output of each observation - self.simulated_file = [None] * len(samples) - for i in range(len(samples)): - self.simulated_file[i] = os.path.join( - self.outputdir, - '%s_output.%s.nc' % (samples[i].get_samples_type(), - self.dacycle['time.sample.stamp'])) - logging.info("Simulated flask file added: %s" % - self.simulated_file[i]) - del i - #self.simulated_file = os.path.join(self.outputdir, 'samples_simulated.%s.nc' % self.dacycle['time.sample.stamp']) - self.forecast_nmembers = int(self.dacycle['da.optimizer.nmembers']) - - def make_lambdas(self, statevector, lag): - """ Write out lambda file parameters - """ - #msteiner: - #write lambda file for current lag: - members = statevector.ensemble_members[lag] - if statevector.isOptimized: - self.lambda_file = os.path.join( - self.simulationdir, 'input', 'oae', - 'lambda_%s_opt.nc' % self.dacycle['time.sample.stamp'][0:10]) - self.bg_lambda_file = os.path.join( - self.simulationdir, 'input', 'oae', 'bg_lambda_%s_opt.nc' % - self.dacycle['time.sample.stamp'][0:10]) - else: - if lag == 0: - self.lambda_file = os.path.join( - self.simulationdir, 'input', 'oae', - 'lambda_%s_priorcycle1.nc' % - self.dacycle['time.sample.stamp'][0:10]) - self.bg_lambda_file = os.path.join( - self.simulationdir, 'input', 'oae', - 'bg_lambda_%s_priorcycle1.nc' % - self.dacycle['time.sample.stamp'][0:10]) - else: - self.lambda_file = os.path.join( - self.simulationdir, 'input', 'oae', 'lambda_%s_prior.nc' % - self.dacycle['time.sample.stamp'][0:10]) - self.bg_lambda_file = os.path.join( - self.simulationdir, 'input', 'oae', - 'bg_lambda_%s_prior.nc' % - self.dacycle['time.sample.stamp'][0:10]) - - # if os.path.exists(self.lambda_file): - # os.system('mv %s %s_cycle1.nc'%(self.lambda_file,self.lambda_file[:-3])) - # if os.path.exists(self.bg_lambda_file): - # os.system('mv %s %s_cycle1.nc'%(self.lambda_file,self.lambda_file[:-3])) - - ofile = Dataset(self.lambda_file, mode='w') - nr_ens = self.forecast_nmembers - nr_reg = self.n_regs - nr_cat = 2 - nr_tracer = 1 - oens = ofile.createDimension('ens', nr_ens) - oreg = ofile.createDimension('reg', nr_reg) - ocat = ofile.createDimension('cat', nr_cat) - otracer = ofile.createDimension('tracer', nr_tracer) - odata = ofile.createVariable('lambda', - np.float32, - ('ens', 'reg', 'cat', 'tracer'), - fill_value=-999.99) - lambdas = np.empty(shape=(nr_ens, nr_reg, nr_cat, nr_tracer)) - for m in range(0, self.forecast_nmembers): - param_count = 0 - for ireg in range(0, nr_reg): - for icat in range(0, nr_cat): - if statevector.isOptimized: - lambdas[m, ireg, icat, - 0] = members[0].param_values[param_count] - else: - lambdas[m, ireg, icat, - 0] = members[m].param_values[param_count] - param_count += 1 - odata[:] = lambdas - ofile.close() - logging.info('lambdas for ICON simulation written to the file: %s' % - self.lambda_file) - - #write bg_lambdas - ofile = Dataset(self.bg_lambda_file, mode='w') - nr_ens = self.forecast_nmembers - nr_dir = 8 - nr_tracer = 1 - oens = ofile.createDimension('ens', nr_ens) - odir = ofile.createDimension('reg', nr_dir) - # otracer = ofile.createDimension('tracer', nr_tracer) - odata = ofile.createVariable('lambda', - np.float32, ('ens', 'reg'), - fill_value=-999.99) #,'tracer' - lambdas = np.empty(shape=(nr_ens, nr_dir)) #,nr_tracer - for m in range(0, self.forecast_nmembers): - for idir in range(0, nr_dir): - if statevector.isOptimized: - lambdas[m, - idir] = members[0].param_values[-self.n_bg_params + - idir] - else: - lambdas[m, - idir] = members[m].param_values[-self.n_bg_params + - idir] - odata[:] = lambdas - ofile.close() - logging.info('bg_lambdas for ICON simulation written to the file: %s' % - self.bg_lambda_file) - - def validate_input(self): - """ Make sure that data needed for the ObservationOperator (such as observation input lists, or parameter files) - are present. - """ - - def save_data(self): - """ Write the data that is needed for a restart or recovery of the Observation Operator to the save directory """ - - def run(self, samples, statevector, lag): - """ - This Randomizer will take the original observation data in the Obs object, and simply copy each mean value. Next, the mean - value will be perturbed by a random normal number drawn from a specified uncertainty of +/- 2 ppm - """ - - import da.tools.io4 as io - import numpy as np - - #msteiner: - #write lambda file for current lag: - members = statevector.ensemble_members[lag] - if statevector.isOptimized: - self.lambda_file = os.path.join( - self.simulationdir, 'input', 'oae', - 'lambda_%s_opt.nc' % self.dacycle['time.sample.stamp'][0:10]) - self.bg_lambda_file = os.path.join( - self.simulationdir, 'input', 'oae', 'bg_lambda_%s_opt.nc' % - self.dacycle['time.sample.stamp'][0:10]) - else: - if lag == 0: - self.lambda_file = os.path.join( - self.simulationdir, 'input', 'oae', - 'lambda_%s_priorcycle1.nc' % - self.dacycle['time.sample.stamp'][0:10]) - self.bg_lambda_file = os.path.join( - self.simulationdir, 'input', 'oae', - 'bg_lambda_%s_priorcycle1.nc' % - self.dacycle['time.sample.stamp'][0:10]) - else: - self.lambda_file = os.path.join( - self.simulationdir, 'input', 'oae', 'lambda_%s_prior.nc' % - self.dacycle['time.sample.stamp'][0:10]) - self.bg_lambda_file = os.path.join( - self.simulationdir, 'input', 'oae', - 'bg_lambda_%s_prior.nc' % - self.dacycle['time.sample.stamp'][0:10]) - - # if os.path.exists(self.lambda_file): - # os.system('mv %s %s_cycle1.nc'%(self.lambda_file,self.lambda_file[:-3])) - # if os.path.exists(self.bg_lambda_file): - # os.system('mv %s %s_cycle1.nc'%(self.lambda_file,self.lambda_file[:-3])) - - ofile = Dataset(self.lambda_file, mode='w') - nr_ens = self.forecast_nmembers - nr_reg = self.n_regs - nr_cat = 2 - nr_tracer = 1 - oens = ofile.createDimension('ens', nr_ens) - oreg = ofile.createDimension('reg', nr_reg) - ocat = ofile.createDimension('cat', nr_cat) - otracer = ofile.createDimension('tracer', nr_tracer) - odata = ofile.createVariable('lambda', - np.float32, - ('ens', 'reg', 'cat', 'tracer'), - fill_value=-999.99) - lambdas = np.empty(shape=(nr_ens, nr_reg, nr_cat, nr_tracer)) - for m in range(0, self.forecast_nmembers): - param_count = 0 - for ireg in range(0, nr_reg): - for icat in range(0, nr_cat): - if statevector.isOptimized: - lambdas[m, ireg, icat, - 0] = members[0].param_values[param_count] - else: - lambdas[m, ireg, icat, - 0] = members[m].param_values[param_count] - param_count += 1 - odata[:] = lambdas - ofile.close() - logging.info('lambdas for ICON simulation written to the file: %s' % - self.lambda_file) - - #write bg_lambdas - ofile = Dataset(self.bg_lambda_file, mode='w') - nr_ens = self.forecast_nmembers - nr_dir = 8 - nr_tracer = 1 - oens = ofile.createDimension('ens', nr_ens) - odir = ofile.createDimension('reg', nr_dir) - # otracer = ofile.createDimension('tracer', nr_tracer) - odata = ofile.createVariable('lambda', - np.float32, ('ens', 'reg'), - fill_value=-999.99) #,'tracer' - lambdas = np.empty(shape=(nr_ens, nr_dir)) #,nr_tracer - for m in range(0, self.forecast_nmembers): - for idir in range(0, nr_dir): - if statevector.isOptimized: - lambdas[m, - idir] = members[0].param_values[-self.n_bg_params + - idir] - else: - lambdas[m, - idir] = members[m].param_values[-self.n_bg_params + - idir] - odata[:] = lambdas - ofile.close() - logging.info('bg_lambdas for ICON simulation written to the file: %s' % - self.bg_lambda_file) - - #msteiner: - #select runscript for ICON-ART-OEM simulation: - if statevector.isOptimized: - #icon_path = os.path.join(self.simulationdir,'output_%s_opt'%(self.dacycle['time.sample.stamp'][0:10])) - runscript = os.path.join( - self.simulationdir, 'run', - 'runscript_%sopt' % (self.dacycle['time.sample.stamp'][0:10])) - #runscript_boundaries = os.path.join(self.simulationdir,'run','runscript_%sopt'%(self.dacycle['time.sample.stamp'][0:10])) - extraction_script = os.path.join( - self.simulationdir, 'run', - 'extract_%sopt' % (self.dacycle['time.sample.stamp'][0:10])) - #extraction_script_boundaries = os.path.join(self.simulationdir,'run','extract_boundaries%sopt'%(self.dacycle['time.sample.stamp'][0:10])) - extracted_file = os.path.join( - self.simulationdir, 'extracted', - 'output_%s_opt' % (self.dacycle['time.sample.stamp'][0:10])) - else: - if lag == 0: - runscript = os.path.join( - self.simulationdir, 'run', 'runscript_%spriorcycle1' % - (self.dacycle['time.sample.stamp'][0:10])) - extraction_script = os.path.join( - self.simulationdir, 'run', 'extract_%spriorcycle1' % - (self.dacycle['time.sample.stamp'][0:10])) - extracted_file = os.path.join( - self.simulationdir, 'extracted', 'output_%s_priorcycle1' % - (self.dacycle['time.sample.stamp'][0:10])) - else: - runscript = os.path.join( - self.simulationdir, 'run', 'runscript_%sprior' % - (self.dacycle['time.sample.stamp'][0:10])) - extraction_script = os.path.join( - self.simulationdir, 'run', 'extract_%sprior' % - (self.dacycle['time.sample.stamp'][0:10])) - #extraction_script_boundaries = os.path.join(self.simulationdir,'run','extract_boundaries%sprior'%(self.dacycle['time.sample.stamp'][0:10])) - #icon_path = os.path.join(self.simulationdir,'output_%s_prior'%(self.dacycle['time.sample.stamp'][0:10])) - extracted_file = os.path.join( - self.simulationdir, 'extracted', 'output_%s_prior' % - (self.dacycle['time.sample.stamp'][0:10])) - runscript_boundaries = os.path.join( - self.simulationdir, 'run_bg', 'runscript_boundaries%spriorcycle1' % - (self.dacycle['time.sample.stamp'][0:10])) - extraction_script_boundaries = os.path.join( - self.simulationdir, 'run_bg', 'extract_boundaries%spriorcycle1' % - (self.dacycle['time.sample.stamp'][0:10])) - extracted_boundaries_ens_file = os.path.join( - self.simulationdir, 'extracted', 'output_bg_%s_priorcycle1' % - (self.dacycle['time.sample.stamp'][0:10])) - logging.info('extraction_script: %s' % (extraction_script)) - - template = os.path.join(self.simulationdir, 'run', 'templates', - 'sbatch_extract_template') - sbatch_script = os.path.join(self.simulationdir, 'run', - 'sbatch_script') - sbatch_script_bg = os.path.join(self.simulationdir, 'run_bg', - 'sbatch_script') - # Write sbatch file - with open(template) as input_file: - to_write = input_file.read() - with open(sbatch_script, "w") as outf: - outf.write(to_write.format(extract_script=extraction_script)) - - self.extracted_file = extracted_file - # inidata = os.path.join( - # self.simulationdir, - # 'input', - # 'icbc', - # self.startdate.strftime(cfg.meteo_nameformat) + '.nc') - # link = os.path.join( - # '/users/nponomar/Emissions/ART', #ART input folder same as specified in ICON nml - # 'ART_ICE_iconR19B09-grid_.nc' #ini5 from processing chain - # ) - # os.system('ln -sf ' + inidata + ' ' + link) - - #now run ICON-ART-OEM: - # if not (os.path.exists(extracted_file) or os.path.exists(extracted_boundaries_ens_file)): - # logging.info('In branch 0') - # self.start_multiple_icon_jobs([runscript, runscript_boundaries]) - # logging.info('ICON ensemble and boudnaries runs - done!') - # with open(sbatch_script_bg, "w") as outf: - # outf.write(to_write.format(extract_script=extraction_script_boundaries)) - # #self.start_icon(sbatch_script_bg) - # self.start_multiple_icon_jobs([sbatch_script, sbatch_script_bg]) - # logging.info('Extraction for ensemble and boudnaries runs - done!') - while not (os.path.exists(extracted_file)): - logging.info('In branch 1') - logging.info('runscript name: %s' % (runscript)) - self.start_icon(runscript) - logging.info('ICON done!') - #now run the extraction script: - self.start_icon(sbatch_script) - logging.info('extractionscript name: %s' % (sbatch_script)) - logging.info('Extraction done!') - # if not (os.path.exists(extracted_boundaries_ens_file)): - # logging.info('In branch 2') - # logging.info('runscript name: %s'%(runscript_boundaries)) - # self.start_icon(runscript_boundaries) - # logging.info('ICON boundaries done!') - # with open(sbatch_script_bg, "w") as outf: - # outf.write(to_write.format(extract_script=extraction_script_boundaries)) - # self.start_icon(sbatch_script_bg) - # logging.info('runscript name: %s'%(sbatch_script_bg)) - # logging.info('Extraction done!') - - def sample(self, samples): - for j, sample in enumerate(samples): - sample_type = sample.get_samples_type() - logging.info(f"Want to do...{{sample_type}} extraction") - if sample_type == "column": - logging.info("Starting _launch_icon_column_sampling") - - warning_msg = "JM: Be careful! The current column sampling " + \ - "method is designed for a specific case of study. " + \ - "Please evaluate if the satellite product is suitable " + \ - "with an appropriate model spatial resolution!" - logging.warning(warning_msg) - - self._launch_icon_column_sampling(j, sample) - - logging.info("Finished _launch_icon_column_sampling") - - elif sample_type == "insitu": - self.ICOS_sampling(j, sample) - - else: - logging.error("Unknown sample type: %s", - sample.get_samples_type()) - - def ICOS_sampling(self, j, sample): - # logging.info('WARNING!! Just for testing, Im copying the input file to the output file!') - - # cmd = f"cp {{self.dacycle['ObsOperator.inputfile.'+sample.get_samples_type()]}} {{self.simulated_file[j]}}" - # logging.info(f"Will run cmd={{cmd}}") - # os.system(cmd) - # cmd = f"module load daint-mc NCO; ncrename -v observed,flask {{self.simulated_file[j]}}" - # logging.info(f"Will run cmd={{cmd}}") - # os.system(cmd) - # return - - # Create a flask output file to hold simulated values for later reading - f = io.CT_CDF(self.simulated_file[j], method='create') - logging.debug( - 'Creating new simulated observation file in ObservationOperator (%s)' - % self.simulated_file) - - dimid = f.createDimension('obs_num', size=None) - dimid = ('obs_num', ) - savedict = io.std_savedict.copy() - savedict['name'] = "obs_num" - savedict['dtype'] = "int" - savedict['long_name'] = "Unique_Dataset_observation_index_number" - savedict['units'] = "" - savedict['dims'] = dimid - savedict[ - 'comment'] = "Unique index number within this dataset ranging from 0 to UNLIMITED." - f.add_data(savedict, nsets=0) - - dimmember = f.createDimension('nmembers', size=self.forecast_nmembers) - dimmember = ('nmembers', ) - savedict = io.std_savedict.copy() - savedict['name'] = "flask" - savedict['dtype'] = "float" - savedict['long_name'] = "mole_fraction_of_trace_gas_in_air" - savedict['units'] = "mol tracer (mol air)^-1" - savedict['dims'] = dimid + dimmember - savedict[ - 'comment'] = "Simulated model value created by RandomizerObservationOperator" - f.add_data(savedict, nsets=0) - - # Open file with x,y,z,t of model samples that need to be sampled - f_in = io.ct_read(self.dacycle['ObsOperator.inputfile.' + - sample.get_samples_type()], - method='read') - - # Get simulated values and ID - - ids = f_in.get_variable('obs_num') - obs = f_in.get_variable('observed') - mdm = f_in.get_variable('modeldatamismatch') - - #msteiner: - date_components = f_in.get_variable('date_components') - evn = f_in.get_variable('evn') - fromfile = f_in.get_variable('fromfile') - #--------- - - # Loop over observations, add random white noise, and write to file - - ########################################################### - os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE" - - molar_mass = {{'ch4': 16.04e-3, 'co2': 44.01e-3, 'da': 28.97e-3}} - units_factor = {{ - 'ch4': 1.e9, #ppb for ch4 - 'co2': 1.e6, #ppm for co2 - }} - - #M_CH4 = 16.04e-3 #mol. weight CH4 [kg/mol] - #M_da = 28.97e-3 #mol. weight dry air [kg/mol] - - #mountain_sites = ['cmn_insitu','jfj_insitu','kas_insitu','oxk_icos','oxk_ingos','oxk_noaa','pdm_lsceflask','puy_insitu','puy_lsceflask','zsf_wdcgg','cur_wdcgg','pdm_lsce','snb_wdcgg'] - mountain_stations = [ - 'Jungfraujoch_5', 'Monte Cimone_8', 'Puy de Dome_10', - 'Pic du Midi_28', 'Zugspitze_3', 'Hohenpeissenberg_50', - 'Hohenpeissenberg_93', 'Hohenpeissenberg_131', 'Schauinsland_12', - 'Plateau Rosa_10' - ] - skip_stations = [ - 'Malin Head_47', - 'Hegyhatsal hatterszennyettseg-mero allomas_48', - 'Hegyhatsal hatterszennyettseg-mero allomas_82', - 'Birkenes_2', - 'Hegyhatsal hatterszennyettseg-mero allomas_115', - 'Hegyhatsal hatterszennyettseg-mero allomas_10', - 'Beromunster_12', - 'Beromunster_44', - 'Beromunster_72', - 'Beromunster_132', - 'Bilsdale_42', - 'Bilsdale_108', - 'Cabauw_27', - 'Cabauw_67', - 'Cabauw_127', - 'Gartow_30', - 'Gartow_60', - 'Gartow_132', - 'Gartow_216', - 'Hohenpeissenberg_50', - 'Hohenpeissenberg_93', - 'Hyltemossa_30', - 'Hyltemossa_70', - 'Ispara_40', - 'Ispra_70', - 'Karlsruhe_30', - 'Karlsruhe_60', - 'Karlsruhe_100', - 'Kresin u Pacova_10', - 'Kresin u Pacova_50', - 'Kresin u Pacova_125', - 'Lindenberg_2', - 'Lindenberg_10', - 'Lindenberg_40', - 'Observatoire de Haute Provence_10', - 'Observatoire de Haute Provence_50', - "Observatoire perenne de l'environnement_10", - "Observatoire perenne de l'environnement_50", - 'Ridge Hill_45', - 'Saclay_15', - 'Saclay_60', - 'Tacolneston_54', - 'Tacolneston_100', - 'Torfhaus_10', - 'Torfhaus_76', - 'Torfhaus_110', - 'Trainou_5', - 'Trainou_50', - 'Trainou_100', - ] - - simulated_values = np.zeros((len(obs), self.forecast_nmembers)) - - f1 = io.ct_read(self.extracted_file, method='read') - TR_A_ENS = (molar_mass['da'] / molar_mass[self.tracer]) * units_factor[ - self.tracer] * np.array( - f1.get_variable('TR' + self.tracer.upper() + '_A_ENS') + - f1.get_variable('biosource_all_chemtr') - - f1.get_variable('biosink_chemtr') - ) #float CH4_A_ENS(ens, sites, time) 1 --> ppb - qv = np.array(f1.get_variable('qv')) #float qv(sites, time) - site_names = np.array(f1.get_variable('site_name')) - obs_times = np.array(f1.get_variable('time')) - - # wet --> dry mmr - for iiens in np.arange(TR_A_ENS.shape[0]): - TR_A_ENS[iiens, ...] = TR_A_ENS[iiens, ...] / (1. - qv[...]) - - #LOOP OVER OBS: - for iobs in np.arange(len(obs)): - station_name = fromfile[iobs][fromfile[iobs] != - b''].tostring().decode('utf-8') - if station_name in skip_stations: - continue # Skip stations outside of the domain! - print('DEBUG iobs: ', iobs, flush=True) - obs_date = dt.datetime(*date_components[iobs, :]) - print('DEBUG obs_date: ', obs_date, flush=True) - obs_date = obs_date.replace(minute=0, second=0) - print('DEBUG modified obs_date: ', obs_date, flush=True) - - # LOOP OVER EXTRACTED DATA TIMES - for itime in np.arange(TR_A_ENS.shape[2]): - otime = dt.datetime.strptime(obs_times[itime], '%Y-%m-%dT%H') - # print('DEBUG checking otime: ',otime,flush=True) - if not (obs_date == otime): continue - print('DEBUG found otime: ', otime, flush=True) - - # find index (or the difference) of hour at 12 UTC and 0 UTC - if station_name in mountain_stations: - print('DEBUG station', - station_name, - 'is a mountain site', - flush=True) - delta_index = obs_date.hour - print('DEBUG delta_index: ', delta_index, flush=True) - else: - print('DEBUG station', - station_name, - 'is NOT a mountain site', - flush=True) - delta_index = obs_date.hour - 12 - print('DEBUG delta_index: ', delta_index, flush=True) - - # LOOP OVER STATIONS - for isite in np.arange(TR_A_ENS.shape[1]): - site_name = site_names[isite] - # print('DEBUG looking through sampled stations. Checking site_name: ',site_name,flush=True) - if (site_name == station_name): - print( - 'DEBUG looking through sampled stations. Found site_name: ', - site_name, - flush=True) - for iens in np.arange(self.forecast_nmembers): - if station_name in mountain_stations: - simulated_values[iobs, iens] = np.nanmean( - TR_A_ENS[iens, isite, - itime - delta_index:itime - - delta_index + 7]) - else: - simulated_values[iobs, iens] = np.nanmean( - TR_A_ENS[iens, isite, - itime - delta_index:itime - - delta_index + 5]) - if iens == 50: - print( - 'Added model value for member 0 of %.2f for iobs %i at %s at %s with a delta idx of %i' - % (simulated_values[iobs, 0], iobs, - site_name, obs_date, delta_index)) - print( - 'Added model value for member 50 of %.2f for iobs %i at %s at %s with a delta idx of %i' - % (simulated_values[iobs, 50], iobs, - site_name, obs_date, delta_index)) - break - else: - continue - break -########################################################### - - for i in range(0, len(obs)): - f.variables['obs_num'][i] = ids[i] - f.variables['flask'][i, :] = simulated_values[i] - - f.close() - f_in.close() - - # Report success and exit - - logging.info( - 'ICOS ObservationOperator finished successfully, output file written (%s)' - % self.simulated_file) - - def _launch_icon_column_sampling(self, j, sample): - """Sample ICON output at coordinates of column observations.""" - """Here we can implement Erik's CDO technique.""" - - # To be continued.... - # run_dir = self.settings["dir.icon_sim"] # Erik: run_dir here means: output dir. - # run_dir = '/scratch/snx3000/ekoene/processing-chain/work/VPRM_EU_ERA5_22/XCO2_test' # This should, eventually, be determined automatically from however the folder structure is made! - run_dir = os.path.join(self.simulationdir, - os.path.basename(self.extracted_file)) - logging.info( - f"Directory that satellite data will be taken from: {{run_dir}}") - - sampling_coords_file = self.dacycle['ObsOperator.inputfile.' + - sample.get_samples_type()] - logging.info(f"Sampling coords file: {{sampling_coords_file}}") - - # Reconstruct self.simulated_file[i] - out_file = self.simulated_file[j] - # out_file = self._sim_fpattern % sample.get_samples_type() - - # Remove intermediate files from a previous sampling job (might - # still be there if that one fails) - # The file pattern is hardcoded in wrfout_sampler - # slicefile_pattern = out_file + ".*.slice" - # for f in glob.glob(os.path.join(run_dir, slicefile_pattern)): - # os.remove(f) - - # Sould be parallelized? - # Spawn multiple icon_sampler instances, - # using at most all processes available - #nprocs1 = int(self.dacycle["da.resources.ntasks"]) - nprocs1 = int(1) - - # Might not want to use that many processes if there are few - # observations, because of overhead. Set a minimum number of - # observations per process, and reduce the number of - # processes to hit that. - Nobs = len(sample.datalist) - if Nobs == 0: - logging.info("No observations, skipping sampling") - return - - # Might want to increase this, no idea if this is reasonable - nobs_min = 100 - nprocs2 = max(1, int(float(Nobs) / float(nobs_min))) - - # Number of processes to use: - nprocs = min(nprocs1, nprocs2) - - # Make run command - # For a task with 1 processor, specifically request -N1 because - # otherwise slurm apparently sometimes tries to allocate one task to - # more than one node. Or something like that. See here: - # https://stackoverflow.com/questions/24056961/running-slurm-script-with-multiple-nodes-launch-job-steps-with-1-task - #command_ = "srun --exclusive -n1 -N1" - command_ = " " # Erik: this would have to look different for us - - # Check if output slice files are already present - # This shouldn't happen, because they are deleted - # a few lines above. But if for some reason (crash) - # they are still here, this might lead to funny behavios. - if nprocs > 1: - output_files = glob.glob(slicefile_pattern) - if len(output_files) > 0: - msg = "Files that match the pattern of the " + \ - "sampler output are already present. Stopping." - logging.error(msg) - raise OSError(msg) - - # Submit processes - procs = list() - for nproc in range(nprocs): - cmd = " ".join([ - command_, "python ./da/tools/icon/icon_sampler.py", - "--nproc %d" % nproc, - "--nprocs %d" % nprocs, - "--sampling_coords_file %s" % sampling_coords_file, - "--run_dir %s" % run_dir, - "--iconout_prefix %s" % self.settings["output_prefix"], - "--icon_grid %s" % self.settings["icon_grid_path"], - "--nmembers %d" % int(self.dacycle["da.optimizer.nmembers"]), - "--tracer_optim %s" % self.settings["tracer_optim"], - "--outfile_prefix %s" % out_file, - "--footprint_samples_dim %d" % - int(self.settings['obs.column.footprint_samples_dim']) - ]) - - procs.append( - subprocess.Popen(cmd.split(), - stdout=subprocess.PIPE, - stderr=subprocess.STDOUT)) - - logging.info("Started %d sampling process(es).", nprocs) - logging.debug("Command of last process: %s", cmd) - - # Wait for all processes to finish - for n in range(nprocs): - procs[n].wait() - - # Check for errors - retcodes = [] - for n in range(nprocs): - logging.debug("Checking errors in process %d", n) - retcodes.append(utilities.check_out_err(procs[n])) - - if any([r != 0 for r in retcodes]): - raise RuntimeError("At least one sampling process " + \ - "finished with errors.") - - logging.info("All sampling processes finished.") - - # Join output files - logging.info("Joining output files.") - ### Some code for joining the files - if nprocs > 1: - utilities.cat_ncfiles(run_dir, - slicefile_pattern, - "sounding_id", - out_file, - in_pattern=True) - - # Finishing msg - logging.info("ICON column output sampled.") - logging.info("If samples object carried observations, output " + \ - "file written to %s", self.simulated_file) - -######################################################################################## - - def run_forecast_model(self, samples, statevector, lag, dacycle): - self.startdate = dacycle['time.sample.start'] - self.prepare_run(samples) - self.make_lambdas(statevector, lag) - self.validate_input() - self.run(samples, statevector, lag) - self.sample(samples) - self.save_data() - - def start_icon(self, runscript): - os.system('sbatch --wait ' + runscript) -# pass - - def start_multiple_icon_jobs(self, scripts): - files = scripts - #command = "sbatch --wait " - os.system('sbatch ' + files[1]) - os.system('sbatch --wait ' + files[0]) - # processes = list() - # max_processes = len(files) - - # for name in files: - # logging.info('Starting a new job: %s'%(command + name)) - # processes.append(subprocess.Popen([command + name], shell=True)) - - # # if len(processes) >= max_processes: - # os.wait() - # processes.difference_update([ - # p for p in processes if p.poll() is not None]) - - -################### End Class ObservationOperator ################### - - -class RandomizerObservationOperator(ObservationOperator): - """ This class holds methods and variables that are needed to use a random number generated as substitute - for a true observation operator. It takes observations and returns values for each obs, with a specified - amount of white noise added - """ - - -if __name__ == "__main__": - pass diff --git a/cases/icon-art-CTDAS2/ctdas_patch/optimizer_baseclass_icos_cities.py b/cases/icon-art-CTDAS2/ctdas_patch/optimizer_baseclass_icos_cities.py deleted file mode 100644 index 1c6ff97f..00000000 --- a/cases/icon-art-CTDAS2/ctdas_patch/optimizer_baseclass_icos_cities.py +++ /dev/null @@ -1,794 +0,0 @@ -"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. -Users are recommended to contact the developers (wouter.peters@wur.nl) to receive -updates of the code. See also: http://www.carbontracker.eu. - -This program is free software: you can redistribute it and/or modify it under the -terms of the GNU General Public License as published by the Free Software Foundation, -version 3. This program is distributed in the hope that it will be useful, but -WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS -FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - -You should have received a copy of the GNU General Public License along with this -program. If not, see .""" -#!/usr/bin/env python -# optimizer.py -""" -.. module:: optimizer -.. moduleauthor:: Wouter Peters - -Revision History: -File created on 28 Jul 2010. - -""" - -import logging -import numpy as np -import numpy.linalg as la -import da.tools.io4 as io -import csv -import xarray as xr -from sklearn.metrics.pairwise import haversine_distances - -identifier = 'Optimizer baseclass' -version = '0.0' - -################### Begin Class Optimizer ################### - - -class Optimizer(object): - """ - This creates an instance of an optimization object. It handles the minimum least squares optimization - of the state vector given a set of sample objects. Two routines will be implemented: one where the optimization - is sequential and one where it is the equivalent matrix solution. The choice can be made based on considerations of speed - and efficiency. - """ - - def __init__(self): - self.ID = identifier - self.version = version - - logging.info('Optimizer object initialized: %s' % self.ID) - - def setup(self, dims, loc_coeff_file): - self.nlag = dims[0] - self.nmembers = dims[1] - self.nparams = dims[2] - self.nobs = dims[3] - self.loc_coeffs = loc_coeff_file - self.create_matrices() - - def create_matrices(self): - """ Create Matrix space needed in optimization routine """ - - # mean state [X] - self.x = np.zeros((self.nlag * self.nparams, ), float) - # deviations from mean state [X'] - self.X_prime = np.zeros(( - self.nlag * self.nparams, - self.nmembers, - ), float) - # mean state, transported to observation space [ H(X) ] - self.Hx = np.zeros((self.nobs, ), float) - # deviations from mean state, transported to observation space [ H(X') ] - self.HX_prime = np.zeros((self.nobs, self.nmembers), float) - # observations - self.obs = np.zeros((self.nobs, ), float) - # observation ids - self.obs_ids = np.zeros((self.nobs, ), float) - # covariance of observations - # Total covariance of fluxes and obs in units of obs [H P H^t + R] - if self.algorithm == 'Serial': - self.R = np.zeros((self.nobs, ), float) - self.HPHR = np.zeros((self.nobs, ), float) - else: - self.R = np.zeros(( - self.nobs, - self.nobs, - ), float) - self.HPHR = np.zeros(( - self.nobs, - self.nobs, - ), float) - # localization of obs - self.may_localize = np.zeros(self.nobs, bool) - # rejection of obs - self.may_reject = np.zeros(self.nobs, bool) - # flags of obs - self.flags = np.zeros(self.nobs, int) - # species type - self.species = np.zeros(self.nobs, str) - # species type - self.sitecode = np.zeros(self.nobs, str) - # rejection_threshold - self.rejection_threshold = np.zeros(self.nobs, float) - # lat/lon - self.latitude = np.zeros(self.nobs, float) - self.longitude = np.zeros(self.nobs, float) - - # species mask - self.speciesmask = {{}} - - # Kalman Gain matrix - #self.KG = np.zeros((self.nlag * self.nparams, self.nobs,), float) - self.KG = np.zeros((self.nlag * self.nparams, ), float) - - #msteiner: - self.evn = np.zeros(self.nobs, str) - self.fromfile = np.zeros(self.nobs, str) - - #read loc_coeffs from file - ds = xr.open_dataset(self.loc_coeffs) - self.coeff_matrix = np.exp( - -ds.Distances.values / 400 - ).T # ERIK: I set this to 400 as a rough footprint size for a station (was 600 km for Michael; 60 km for Nikolai) - self.name_array = ds.Stations_names.values - - def state_to_matrix(self, statevector): - allsites = [] # collect all obs for n=1,..,nlag - allobs = [] # collect all obs for n=1,..,nlag - allmdm = [] # collect all mdm for n=1,..,nlag - allids = [] # collect all model samples for n=1,..,nlag - allreject = [] # collect all model samples for n=1,..,nlag - alllocalize = [] # collect all model samples for n=1,..,nlag - allflags = [] # collect all model samples for n=1,..,nlag - allspecies = [] # collect all model samples for n=1,..,nlag - allsimulated = [] # collect all members model samples for n=1,..,nlag - allrej_thres = [ - ] # collect all rejection_thresholds, will be the same for all samples of same source - alllats = [] # collect all latitudes for n=1,..,nlag - alllons = [] # collect all longitudes for n=1,..,nlag - #msteiner: - allevns = [] # collect all evns for finding loc_coeffs in localize() - allfromfiles = [ - ] # collect all evns for finding loc_coeffs in localize() - - for n in range(self.nlag): - samples = statevector.obs_to_assimilate[n] - members = statevector.ensemble_members[n] - self.x[n * self.nparams:(n + 1) * - self.nparams] = members[0].param_values - self.X_prime[n * self.nparams:(n + 1) * - self.nparams, :] = np.transpose( - np.array([m.param_values for m in members])) - - # Add observation data for all sample objects - if samples != None: - if type(samples) != list: samples = [samples] - for m in range(len(samples)): - sample = samples[m] - logging.debug( - 'Lag %i, sample %i: rejection_threshold = %i, nobs = %i' - % - (n, m, sample.rejection_threshold, sample.getlength())) - logging.info( - 'Lag %i, sample %i: rejection_threshold = %i, nobs = %i' - % - (n, m, sample.rejection_threshold, sample.getlength())) - logging.info(f'{{dir(sample)}}') - alllats.extend(sample.getvalues('lat')) - alllons.extend(sample.getvalues('lon')) - allrej_thres.extend([sample.rejection_threshold] * - sample.getlength()) - allreject.extend(sample.getvalues('may_reject')) - alllocalize.extend(sample.getvalues('may_localize')) - allflags.extend(sample.getvalues('flag')) - allspecies.extend(sample.getvalues('species')) - allobs.extend(sample.getvalues('obs')) - allsites.extend(sample.getvalues('code')) - allmdm.extend(sample.getvalues('mdm')) - allids.extend(sample.getvalues('id')) - #msteiner: - # if sample.get_samples_type() == 'insitu': - try: - allevns.extend(sample.getvalues('evn')) - allfromfiles.extend(sample.getvalues('fromfile')) - except: - logging.debug( - f"Number of copies: {{len(sample.getvalues('lat'))}}" - ) - allevns.extend(['column'] * - len(sample.getvalues('lat'))) - allfromfiles.extend(['column'] * - len(sample.getvalues('lat'))) - simulatedensemble = sample.getvalues('simulated') - for s in range(simulatedensemble.shape[0]): - allsimulated.append(simulatedensemble[s]) - - self.latitude[:] = np.array(alllats) - self.longitude[:] = np.array(alllons) - self.rejection_threshold[:] = np.array(allrej_thres) - self.obs[:] = np.array(allobs) - self.obs_ids[:] = np.array(allids) - self.HX_prime[:, :] = np.array(allsimulated) - self.Hx[:] = self.HX_prime[:, 0] - - self.may_reject[:] = np.array(allreject) - self.may_localize[:] = np.array(alllocalize) - self.flags[:] = np.array(allflags) - self.species[:] = np.array(allspecies) - self.sitecode = allsites - - #msteiner: - # self.evn = allevns - self.fromfile = allfromfiles - - # ~~~~~~~~ NEW SINCE OCO2, but generally valid: Setup localization (distance between observations and regions) - OBSERVATIONS_IN_RADIANS_LATLON = np.deg2rad( - np.column_stack([self.latitude, self.longitude])) - grid = xr.open_dataset( - '/users/ekoene/CTDAS_inputs/icon_europe_DOM01.nc') - grid_latitudes = grid.lat_cell_centre.values - grid_longitudes = grid.lon_cell_centre.values - REGIONS_IN_RADIANS_LATLON = np.column_stack( - [grid_latitudes, grid_longitudes]) - Distances = haversine_distances( - OBSERVATIONS_IN_RADIANS_LATLON, - REGIONS_IN_RADIANS_LATLON) * 6371000 / 1000 # distance to km s - logging.debug(Distances) - self.coeff_matrix = np.exp( - -Distances / 400 - ) # ERIK: I set this to 400 as a rough footprint size for a station (was 600 km for Michael; 60 km for Nikolai) - self.name_array = np.arange( - OBSERVATIONS_IN_RADIANS_LATLON.shape[0] - ) # These should be 'names' but my pixels don't have names, of course! - - self.X_prime = self.X_prime - self.x[:, np. - newaxis] # make into a deviation matrix - self.HX_prime = self.HX_prime - self.Hx[:, np. - newaxis] # make a deviation matrix - - if self.algorithm == 'Serial': - for i, mdm in enumerate(allmdm): - self.R[i] = mdm**2 - else: - for i, mdm in enumerate(allmdm): - self.R[i, i] = mdm**2 - - def matrix_to_state(self, statevector): - for n in range(self.nlag): - members = statevector.ensemble_members[n] - for m, mem in enumerate(members): - members[m].param_values[:] = self.X_prime[ - n * self.nparams:(n + 1) * self.nparams, - m] + self.x[n * self.nparams:(n + 1) * self.nparams] - - #msteiner: - statevector.isOptimized = True - #--------- - - logging.debug( - 'Returning optimized data to the StateVector, setting "StateVector.isOptimized = True" ' - ) - - def write_diagnostics(self, filename, type): - """ - Open a NetCDF file and write diagnostic output from optimization process: - - - calculated residuals - - model-data mismatches - - HPH^T - - prior ensemble of samples - - posterior ensemble of samples - - prior ensemble of fluxes - - posterior ensemble of fluxes - - The type designation refers to the writing of prior or posterior data and is used in naming the variables" - """ - - # Open or create file - - if type == 'prior': - f = io.CT_CDF(filename, method='create') - logging.debug('Creating new diagnostics file for optimizer (%s)' % - filename) - elif type == 'optimized': - f = io.CT_CDF(filename, method='write') - logging.debug( - 'Opening existing diagnostics file for optimizer (%s)' % - filename) - - # Add dimensions - - dimparams = f.add_params_dim(self.nparams) - dimmembers = f.add_members_dim(self.nmembers) - dimlag = f.add_lag_dim(self.nlag, unlimited=False) - dimobs = f.add_obs_dim(self.nobs) - dimstate = f.add_dim('nstate', self.nparams * self.nlag) - dim200char = f.add_dim('string_of200chars', 200) - - # Add data, first the ones that are written both before and after the optimization - - savedict = io.std_savedict.copy() - savedict['name'] = "statevectormean_%s" % type - savedict['long_name'] = "full_statevector_mean_%s" % type - savedict['units'] = "unitless" - savedict['dims'] = dimstate - savedict['values'] = self.x.tolist() - savedict['comment'] = 'Full %s state vector mean ' % type - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "statevectordeviations_%s" % type - savedict['long_name'] = "full_statevector_deviations_%s" % type - savedict['units'] = "unitless" - savedict['dims'] = dimstate + dimmembers - savedict['values'] = self.X_prime.tolist() - savedict[ - 'comment'] = 'Full state vector %s deviations as resulting from the optimizer' % type - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "modelsamplesmean_%s" % type - savedict['long_name'] = "modelsamplesforecastmean_%s" % type - savedict['units'] = "mol mol-1" - savedict['dims'] = dimobs - savedict['values'] = self.Hx.tolist() - savedict[ - 'comment'] = '%s mean mole fractions based on %s state vector' % ( - type, type) - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "modelsamplesdeviations_%s" % type - savedict['long_name'] = "modelsamplesforecastdeviations_%s" % type - savedict['units'] = "mol mol-1" - savedict['dims'] = dimobs + dimmembers - savedict['values'] = self.HX_prime.tolist() - savedict[ - 'comment'] = '%s mole fraction deviations based on %s state vector' % ( - type, type) - f.add_data(savedict) - - # Continue with prior only data - - if type == 'prior': - - savedict = io.std_savedict.copy() - savedict['name'] = "sitecode" - savedict[ - 'long_name'] = "site code propagated from observation file" - savedict['dtype'] = "char" - savedict['dims'] = dimobs + dim200char - savedict['values'] = self.sitecode - savedict['missing_value'] = '!' - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "observed" - savedict['long_name'] = "observedvalues" - savedict['units'] = "mol mol-1" - savedict['dims'] = dimobs - savedict['values'] = self.obs.tolist() - savedict['comment'] = 'Observations used in optimization' - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "obspack_num" - savedict['dtype'] = "int64" - savedict['long_name'] = "Unique_ObsPack_observation_number" - savedict['units'] = "" - savedict['dims'] = dimobs - savedict['values'] = self.obs_ids.tolist() - savedict[ - 'comment'] = 'Unique observation number across the entire ObsPack distribution' - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "modeldatamismatchvariance" - savedict['long_name'] = "modeldatamismatch variance" - savedict['units'] = "[mol mol-1]^2" - if self.algorithm == 'Serial': - savedict['dims'] = dimobs - else: - savedict['dims'] = dimobs + dimobs - savedict['values'] = self.R.tolist() - savedict[ - 'comment'] = 'Variance of mole fractions resulting from model-data mismatch' - f.add_data(savedict) - - # Continue with posterior only data - - elif type == 'optimized': - - savedict = io.std_savedict.copy() - savedict['name'] = "totalmolefractionvariance" - savedict['long_name'] = "totalmolefractionvariance" - savedict['units'] = "[mol mol-1]^2" - if self.algorithm == 'Serial': - savedict['dims'] = dimobs - else: - savedict['dims'] = dimobs + dimobs - savedict['values'] = self.HPHR.tolist() - savedict[ - 'comment'] = 'Variance of mole fractions resulting from prior state and model-data mismatch' - f.add_data(savedict) - - savedict = io.std_savedict.copy() - savedict['name'] = "flag" - savedict['long_name'] = "flag_for_obs_model" - savedict['units'] = "None" - savedict['dims'] = dimobs - savedict['values'] = self.flags.tolist() - savedict[ - 'comment'] = 'Flag (0/1/2/99) for observation value, 0 means okay, 1 means QC error, 2 means rejected, 99 means not sampled' - f.add_data(savedict) - - #savedict = io.std_savedict.copy() - #savedict['name'] = "kalmangainmatrix" - #savedict['long_name'] = "kalmangainmatrix" - #savedict['units'] = "unitless molefraction-1" - #savedict['dims'] = dimstate + dimobs - #savedict['values'] = self.KG.tolist() - #savedict['comment'] = 'Kalman gain matrix of all obs and state vector elements' - #dummy = f.add_data(savedict) - - f.close() - logging.debug('Diagnostics file closed') - - def serial_minimum_least_squares(self, n_bg_params=0): - """ Make minimum least squares solution by looping over obs""" - - # Calculate prior value cost function (observation part) - res_prior = np.abs(self.obs - self.Hx) - select = (res_prior < 1E15).nonzero()[0] - J_prior = res_prior.take(select, axis=0)**2 / self.R.take(select, - axis=0) - res_prior = np.mean(res_prior) - for n in range(self.nobs): - - # Screen for flagged observations (for instance site not found, or no sample written from model) - - if self.flags[n] != 0: - logging.debug( - 'Skipping observation (%s,%i) because of flag value %d' % - (self.sitecode[n], self.obs_ids[n], self.flags[n])) - logging.info( - 'Skipping observation (%s,%i) because of flag value %d' % - (self.sitecode[n], self.obs_ids[n], self.flags[n])) - continue - - # Screen for outliers greather than 3x model-data mismatch, only apply if obs may be rejected - - res = self.obs[n] - self.Hx[n] - - if self.may_reject[n]: - threshold = self.rejection_threshold[n] * np.sqrt(self.R[n]) - if np.abs(res) > threshold: - logging.debug( - 'Rejecting observation (%s,%i) because residual (%f) exceeds threshold (%f)' - % (self.sitecode[n], self.obs_ids[n], res, threshold)) - logging.info( - 'Rejecting observation (%s,%i) because residual (%f) exceeds threshold (%f)' - % (self.sitecode[n], self.obs_ids[n], res, threshold)) - self.flags[n] = 2 - continue - - logging.debug('Proceeding to assimilate observation %s, %i' % - (self.sitecode[n], self.obs_ids[n])) - logging.info('Proceeding to assimilate observation %s, %i' % - (self.sitecode[n], self.obs_ids[n])) - - PHt = 1. / (self.nmembers - 1) * np.dot(self.X_prime, - self.HX_prime[n, :]) - self.HPHR[n] = 1. / (self.nmembers - 1) * ( - self.HX_prime[n, :] * self.HX_prime[n, :]).sum() + self.R[n] - self.KG[:] = PHt / self.HPHR[n] - - if self.may_localize[n]: - logging.debug('Trying to localize observation %s, %i' % - (self.sitecode[n], self.obs_ids[n])) - logging.info('Trying to localize observation %s, %i' % - (self.sitecode[n], self.obs_ids[n])) - self.localize(n, n_bg_params) - else: - logging.debug('Not allowed to localize observation %s, %i' % - (self.sitecode[n], self.obs_ids[n])) -# logging.info('Not allowed to localize observation %s, %i' % (self.sitecode[n], self.obs_ids[n])) - - alpha = np.double(1.0) / (np.double(1.0) + np.sqrt( - (self.R[n]) / self.HPHR[n])) - - self.x[:] = self.x + self.KG[:] * res - - for r in range(self.nmembers): - # logging.info('X_prime before: %s'%(str(self.X_prime[:, r]))) - self.X_prime[:, - r] = self.X_prime[:, r] - alpha * self.KG[:] * ( - self.HX_prime[n, r]) -# logging.info('X_prime after: %s'%(str(self.X_prime[:, r]))) -# logging.info('======================================') - del r - - # update samples to account for update of statevector based on observation n - HXprime_n = self.HX_prime[n, :].copy() - res = self.obs[n] - self.Hx[n] - fac = 1.0 / (self.nmembers - 1) * np.sum( - HXprime_n[np.newaxis, :] * self.HX_prime, - axis=1) / self.HPHR[n] - self.Hx = self.Hx + fac * res - self.HX_prime = self.HX_prime - alpha * fac[:, - np.newaxis] * HXprime_n - - del n - if 'HXprime_n' in globals(): del HXprime_n - - # calculate posterior value cost function - res_post = np.abs(self.obs - self.Hx) - select = (res_post < 1E15).nonzero()[0] - J_post = res_post.take(select, axis=0)**2 / self.R.take(select, axis=0) - res_post = np.mean(res_post) - - logging.info( - 'Observation part cost function: prior = %s, posterior = %s' % - (np.mean(J_prior), np.mean(J_post))) - logging.info('Mean residual: prior = %s, posterior = %s' % - (res_prior, res_post)) - -#WP !!!! Very important to first do all obervations from n=1 through the end, and only then update 1,...,n. The current observation -#WP should always be updated last because it features in the loop of the adjustments !!!! -# -# for m in range(n + 1, self.nobs): -# res = self.obs[n] - self.Hx[n] -# fac = 1.0 / (self.nmembers - 1) * (self.HX_prime[n, :] * self.HX_prime[m, :]).sum() / self.HPHR[n] -# self.Hx[m] = self.Hx[m] + fac * res -# self.HX_prime[m, :] = self.HX_prime[m, :] - alpha * fac * self.HX_prime[n, :] -# -# for m in range(1, n + 1): -# res = self.obs[n] - self.Hx[n] -# fac = 1.0 / (self.nmembers - 1) * (self.HX_prime[n, :] * self.HX_prime[m, :]).sum() / self.HPHR[n] -# self.Hx[m] = self.Hx[m] + fac * res -# self.HX_prime[m, :] = self.HX_prime[m, :] - alpha * fac * self.HX_prime[n, :] - - def bulk_minimum_least_squares(self): - """ Make minimum least squares solution by solving matrix equations""" - - # Create full solution, first calculate the mean of the posterior analysis - - HPH = np.dot(self.HX_prime, np.transpose(self.HX_prime)) / ( - self.nmembers - 1) # HPH = 1/N * HX' * (HX')^T - self.HPHR[:, :] = HPH + self.R # HPHR = HPH + R - HPb = np.dot(self.X_prime, np.transpose(self.HX_prime)) / ( - self.nmembers - 1) # HP = 1/N X' * (HX')^T - self.KG[:, :] = np.dot(HPb, la.inv(self.HPHR)) # K = HP/(HPH+R) - - for n in range(self.nobs): - self.localize(n) - - self.x[:] = self.x + np.dot(self.KG, - self.obs - self.Hx) # xa = xp + K (y-Hx) - - # And next make the updated ensemble deviations. Note that we calculate P by using the full equation (10) at once, and - # not in a serial update fashion as described in Whitaker and Hamill. - # For the current problem with limited N_obs this is easier, or at least more straightforward to do. - - I = np.identity(self.nlag * self.nparams) - sHPHR = la.cholesky(self.HPHR) # square root of HPH+R - part1 = np.dot(HPb, np.transpose(la.inv(sHPHR))) # HP(sqrt(HPH+R))^-1 - part2 = la.inv(sHPHR + np.sqrt(self.R)) # (sqrt(HPH+R)+sqrt(R))^-1 - Kw = np.dot(part1, part2) # K~ - self.X_prime[:, :] = np.dot(I, self.X_prime) - np.dot( - Kw, self.HX_prime) # HX' = I - K~ * HX' - - # Now do the adjustments of the modeled mole fractions using the linearized ensemble. These are not strictly needed but can be used - # for diagnosis. - - part3 = np.dot(HPH, np.transpose(la.inv(sHPHR))) # HPH(sqrt(HPH+R))^-1 - Kw = np.dot(part3, part2) # K~ - self.Hx[:] = self.Hx + np.dot(np.dot(HPH, la.inv( - self.HPHR)), self.obs - self.Hx) # Hx = Hx+ HPH/HPH+R (y-Hx) - self.HX_prime[:, :] = self.HX_prime - np.dot( - Kw, self.HX_prime) # HX' = HX'- K~ * HX' - - logging.info( - 'Minimum Least Squares solution was calculated, returning') - - def set_localization(self, loctype='None'): - """ determine which localization to use """ - - if loctype == 'CT2007': - self.localization = True - self.localizetype = 'CT2007' - #T-test values for two-tailed student's T-test using 95% confidence interval for some options of nmembers - if self.nmembers == 50: - self.tvalue = 2.0086 - elif self.nmembers == 100: - self.tvalue = 1.9840 - elif self.nmembers == 150: - self.tvalue = 1.97591 - elif self.nmembers == 192: - self.tvalue = 1.9724 - elif self.nmembers == 200: - self.tvalue = 1.9719 - else: - self.tvalue = 0 - elif loctype == 'spatial': - logging.info('Spatial localization selected') - self.localization = True - self.localizetype = 'spatial' - else: - self.localization = False - self.localizetype = 'None' - - logging.info("Current localization option is set to %s" % - self.localizetype) - if ((self.localization == True) and (self.localizetype == 'CT2007')): - if self.tvalue == 0: - logging.error( - "Critical tvalue for localization not set for %i ensemble members" - % (self.nmembers)) - sys.exit(2) - else: - logging.info( - "Used critical tvalue %0.05f is based on 95%% probability and %i ensemble members in a two-tailed student's T-test" - % (self.tvalue, self.nmembers)) - - def get_prob(self, n, i): - # def get_prob(self,obsdev,paramdev,r): - """Calculate probability from correlations""" - # corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] - # corr = np.corrcoef(obsdev,paramdev)[0,1] - # corr = np.ma.corrcoef(np.ma.masked_invalid(self.HX_prime[n, :]),np.ma.masked_invalid(self.X_prime[r, :].squeeze()))[0,1] - for r in np.arange(i, self.nlag * self.nparams)[::36]: - corr = np.corrcoef(self.HX_prime[n, :], - self.X_prime[r, :].squeeze())[0, 1] - prob = corr / np.sqrt( - (1.000000001 - corr**2) / (self.nmembers - 2)) - if abs(prob) < self.tvalue: - self.KG[r] = 0.0 - - def localize(self, n, n_bg_params): - skip_stations = [ - 'Malin Head_47', - 'Hegyhatsal hatterszennyettseg-mero allomas_48', - 'Hegyhatsal hatterszennyettseg-mero allomas_82', - 'Birkenes_2', - 'Hegyhatsal hatterszennyettseg-mero allomas_115', - 'Hegyhatsal hatterszennyettseg-mero allomas_10', - 'Beromunster_12', - 'Beromunster_44', - 'Beromunster_72', - 'Beromunster_132', - 'Bilsdale_42', - 'Bilsdale_108', - 'Cabauw_27', - 'Cabauw_67', - 'Cabauw_127', - 'Gartow_30', - 'Gartow_60', - 'Gartow_132', - 'Gartow_216', - 'Hohenpeissenberg_50', - 'Hohenpeissenberg_93', - 'Hyltemossa_30', - 'Hyltemossa_70', - 'Ispara_40', - 'Ispra_70', - 'Karlsruhe_30', - 'Karlsruhe_60', - 'Karlsruhe_100', - 'Kresin u Pacova_10', - 'Kresin u Pacova_50', - 'Kresin u Pacova_125', - 'Lindenberg_2', - 'Lindenberg_10', - 'Lindenberg_40', - 'Observatoire de Haute Provence_10', - 'Observatoire de Haute Provence_50', - "Observatoire perenne de l'environnement_10", - "Observatoire perenne de l'environnement_50", - 'Ridge Hill_45', - 'Saclay_15', - 'Saclay_60', - 'Tacolneston_54', - 'Tacolneston_100', - 'Torfhaus_10', - 'Torfhaus_76', - 'Torfhaus_110', - 'Trainou_5', - 'Trainou_50', - 'Trainou_100', - ] - """ localize the Kalman Gain matrix """ - import numpy as np - from multiprocessing import Pool - - if not self.localization: - logging.debug('Not localized observation %i' % self.obs_ids[n]) - return - if self.localizetype == 'CT2007': - - # count_localized = 0 - # for r in range(self.nlag * self.nparams): - ## corr = np.corrcoef(self.HX_prime[n, :], self.X_prime[r, :].squeeze())[0, 1] - # corr = np.ma.corrcoef(np.ma.masked_invalid(self.HX_prime[n, :]),np.ma.masked_invalid(self.X_prime[r, :].squeeze()))[0,1] - # prob = corr / np.sqrt((1.000000001 - corr ** 2) / (self.nmembers - 2)) - # if abs(prob) < self.tvalue: - # self.KG[r] = 0.0 - # count_localized = count_localized + 1 - # logging.debug('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) - # logging.info('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) - - ############################################ - ###make the CT2007 parallel: - # args = [ (n, i) for i in range(self.nlag * self.nparams) ] - args = [(n, i) for i in range(36)] - # args = [ (self.HX_prime[n, :], self.X_prime[r, :].squeeze(), r ) for r in range(self.nlag * self.nparams) ] - with Pool(36) as pool: - pool.starmap(self.get_prob, args) -# count_localized = 0 -# for r in range(self.nlag * self.nparams): -# if abs(prob[r]) < self.tvalue: -# self.KG[r] = 0.0 -# count_localized = count_localized + 1 -# logging.debug('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) -# logging.info('Localized observation %i, %i%% of values set to 0' % (self.obs_ids[n],count_localized*100/(self.nlag * self.nparams))) - logging.info('Localized observation %i' % (self.obs_ids[n])) - ############################################ - - elif self.localizetype == 'spatial': - # ### if self.loc_L[n] > 0: - # ### obslati, obsloni = self.find_coord_index(self.latitude[n],self.longitude[n],180,360) - # ### for l in range(self.nlag): - # ### self.KG[l*self.nparams:(l+1)*self.nparams] = np.multiply(self.KG[l*self.nparams:(l+1)*self.nparams], self.loc_coeff[str(self.loc_L[n])][obslati,obsloni,:]) - # ### logging.debug('Localized observation %i with localization length %s' %(self.obs_ids[n], self.loc_L[n])) - # print(self.latitude[n], self.longitude[n], "lat and lon!") - - # n_em_cat = 2 - # lfound = False - # for iname,stationname in enumerate(self.name_array): - # if stationname in skip_stations: continue # Skip stations outside of the domain! - # if stationname==self.fromfile[n]: - # coeff_l = np.zeros((n_em_cat*len(self.coeff_matrix[iname,:]))) - # for i_n_cat in range(n_em_cat): - # coeff_l[i_n_cat:][::n_em_cat] = self.coeff_matrix[iname,:] - - # for l in range(self.nlag): - # self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params] = np.multiply( self.KG[l*self.nparams:(l+1)*self.nparams-n_bg_params], coeff_l ) - - # logging.info('Localized observation %i at station %s (nr. %i)'%(self.obs_ids[n],stationname,iname)) - - # lfound = True - - # break - - # if not lfound: - # logging.info('Not localized observation %i as coefficient not found' %(self.obs_ids[n])) - ### if self.loc_L[n] > 0: - ### obslati, obsloni = self.find_coord_index(self.latitude[n],self.longitude[n],180,360) - ### for l in range(self.nlag): - ### self.KG[l*self.nparams:(l+1)*self.nparams] = np.multiply(self.KG[l*self.nparams:(l+1)*self.nparams], self.loc_coeff[str(self.loc_L[n])][obslati,obsloni,:]) - ### logging.debug('Localized observation %i with localization length %s' %(self.obs_ids[n], self.loc_L[n])) - - n_em_cat = 2 - if self.fromfile[n] in skip_stations: - return # Skip stations outside of the domain! - - coeff_l = np.zeros((n_em_cat * len(self.coeff_matrix[n, :]))) - for i_n_cat in range(n_em_cat): - coeff_l[i_n_cat:][::n_em_cat] = self.coeff_matrix[n, :] - - for l in range(self.nlag): - self.KG[l * self.nparams:(l + 1) * self.nparams - - n_bg_params] = np.multiply( - self.KG[l * self.nparams:(l + 1) * self.nparams - - n_bg_params], coeff_l) - - logging.info('Localized observation %i at station %s (nr. %i)' % - (self.obs_ids[n], self.fromfile[n], n)) - - def set_algorithm(self, algorithm='Serial'): - """ determine which minimum least squares algorithm to use """ - - if algorithm == 'Serial': - self.algorithm = 'Serial' - else: - self.algorithm = 'Bulk' - - logging.info("Current minimum least squares algorithm is set to %s" % - self.algorithm) - - -################### End Class Optimizer ################### - -if __name__ == "__main__": - pass diff --git a/cases/icon-art-CTDAS2/ctdas_patch/statevector_baseclass_icos_cities.py b/cases/icon-art-CTDAS2/ctdas_patch/statevector_baseclass_icos_cities.py deleted file mode 100644 index e2a7e98a..00000000 --- a/cases/icon-art-CTDAS2/ctdas_patch/statevector_baseclass_icos_cities.py +++ /dev/null @@ -1,746 +0,0 @@ -"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. -Users are recommended to contact the developers (wouter.peters@wur.nl) to receive -updates of the code. See also: http://www.carbontracker.eu. - -This program is free software: you can redistribute it and/or modify it under the -terms of the GNU General Public License as published by the Free Software Foundation, -version 3. This program is distributed in the hope that it will be useful, but -WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS -FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - -You should have received a copy of the GNU General Public License along with this -program. If not, see .""" -#!/usr/bin/env python -# ct_statevector_tools.py -""" -.. module:: statevector -.. moduleauthor:: Wouter Peters - -Revision History: -File created on 28 Jul 2010. - -The module statevector implements the data structure and methods needed to work with state vectors (a set of unknown parameters to be optimized by a DA system) of different lengths, types, and configurations. Two baseclasses together form a generic framework: - * :class:`~da.baseclasses.statevector.StateVector` - * :class:`~da.baseclasses.statevector.EnsembleMember` - -As usual, specific implementations of StateVector objects are done through inheritance form these baseclasses. An example of designing -your own baseclass StateVector we refer to :ref:`tut_chapter5`. - -.. autoclass:: da.baseclasses.statevector.StateVector - -.. autoclass:: da.baseclasses.statevector.EnsembleMember - -""" - -import os -import logging -import numpy as np -from scipy.linalg import cholesky -from datetime import timedelta -import datetime as dt -import da.tools.io4 as io -import csv -from multiprocessing import Pool -import xarray as xr - -identifier = 'ICON Statevector ' -version = '0.0' - -################### Begin Class EnsembleMember ################### - - -class EnsembleMember(object): - """ - An ensemble member object consists of: - * a member number - * parameter values - * an observation object to hold sampled values for this member - - Ensemble members are initialized by passing only an ensemble member number, all data is added by methods - from the :class:`~da.baseclasses.statevector.StateVector`. Ensemble member objects have almost no functionality - except to write their data to file using method :meth:`~da.baseclasses.statevector.EnsembleMember.write_to_file` - - .. automethod:: da.baseclasses.statevector.EnsembleMember.__init__ - .. automethod:: da.baseclasses.statevector.EnsembleMember.write_to_file - .. automethod:: da.baseclasses.statevector.EnsembleMember.AddCustomFields - - """ - - def __init__(self, membernumber): - """ - :param memberno: integer ensemble number - :rtype: None - - An EnsembleMember object is initialized with only a number, and holds two attributes as containter for later - data: - * param_values, will hold the actual values of the parameters for this data - * ModelSample, will hold an :class:`~da.baseclasses.obs.Observation` object and the model samples resulting from this members' data - - """ - self.membernumber = membernumber # the member number - self.param_values = None # Parameter values of this member - - -################### End Class EnsembleMember ################### - -################### Begin Class StateVector ################### - - -class StateVector(object): - """ - The StateVector object first of all contains the data structure of a statevector, defined by 3 attributes that define the - dimensions of the problem in parameter space: - * nlag - * nparameters - * nmembers - - The fourth important dimension `nobs` is not related to the StateVector directly but is initialized to 0, and later on - modified to be used in other parts of the pipeline: - * nobs - - These values are set as soon as the :meth:`~da.baseclasses.statevector.StateVector.setup` is called from the :ref:`pipeline`. - Additionally, the value of attribute `isOptimized` is set to `False` indicating that the StateVector holds a-priori values - and has not been modified by the :ref:`optimizer`. - - StateVector objects can be filled with data in two ways - 1. By reading the data from file - 2. By creating the data through a set of method calls - - Option (1) is invoked using method :meth:`~da.baseclasses.statevector.StateVector.read_from_file`. - Option (2) consists of a call to method :meth:`~da.baseclasses.statevector.StateVector.make_new_ensemble` - - Once the StateVector object has been filled with data, it is used in the pipeline and a few more methods are - invoked from there: - * :meth:`~da.baseclasses.statevector.StateVector.propagate`, to advance the StateVector from t=t to t=t+1 - * :meth:`~da.baseclasses.statevector.StateVector.write_to_file`, to write the StateVector to a NetCDF file for later use - - The methods are described below: - - .. automethod:: da.baseclasses.statevector.StateVector.setup - .. automethod:: da.baseclasses.statevector.StateVector.read_from_file - .. automethod:: da.baseclasses.statevector.StateVector.write_to_file - .. automethod:: da.baseclasses.statevector.StateVector.make_new_ensemble - .. automethod:: da.baseclasses.statevector.StateVector.propagate - .. automethod:: da.baseclasses.statevector.StateVector.write_members_to_file - - Finally, the StateVector can be mapped to a gridded array, or to a vector of TransCom regions, using: - - .. automethod:: da.baseclasses.statevector.StateVector.grid2vector - .. automethod:: da.baseclasses.statevector.StateVector.vector2grid - .. automethod:: da.baseclasses.statevector.StateVector.vector2tc - .. automethod:: da.baseclasses.statevector.StateVector.state2tc - - """ - - def __init__(self): - self.ID = identifier - self.version = version - - # The following code allows the object to be initialized with a dacycle object already present. Otherwise, it can - # be added at a later moment. - - logging.info('Statevector object initialized: %s' % self.ID) - - def setup(self, dacycle): - """ - setup the object by specifying the dimensions. - There are two major requirements for each statvector that you want to build: - - (1) is that the statevector can map itself onto a regular grid - (2) is that the statevector can map itself (mean+covariance) onto TransCom regions - - An example is given below. - """ - - self.nlag = int(dacycle['time.nlag']) - self.nmembers = int( - dacycle['da.optimizer.nmembers'] - ) #number of ensemble members, e.g. 192 for the icon case - self.nparams = int(dacycle.dasystem['nparameters'] - ) #n_reg * n_tracers * n_categories + n_bg_params - self.nobs = 0 - - self.obs_to_assimilate = ( - ) # empty containter to hold observations to assimilate later on - - # These list objects hold the data for each time step of lag in the system. Note that the ensembles for each time step consist - # of lists of EnsembleMember objects, we define member 0 as the mean of the distribution and n=1,...,nmembers as the spread. - - self.ensemble_members = list(range(self.nlag)) - - for n in range(self.nlag): - self.ensemble_members[n] = [] - - #msteiner: - self.isOptimized = False - self.C = np.zeros((self.nparams, self.nparams)) - self.distances = dacycle['sv.distances'] - #--------- - - def make_new_ensemble(self, lag, covariancematrix=None, n_bg_params=0): - """ - :param lag: an integer indicating the time step in the lag order - :param covariancematrix: a matrix to draw random values from - :rtype: None - - Make a new ensemble, the attribute lag refers to the position in the state vector. - Note that lag=1 means an index of 0 in python, hence the notation lag-1 in the indexing below. - The argument is thus referring to the lagged state vector as [1,2,3,4,5,..., nlag] - - The optional covariance object to be passed holds a matrix of dimensions [nparams, nparams] which is - used to draw ensemblemembers from. If this argument is not passed it will ne substituted with an - identity matrix of the same dimensions. - - """ - - logging.info('msteiner: current lag: %i ' % (lag)) - logging.info('msteiner: nlag; %i ' % (self.nlag)) - categories = 2 - if np.all(self.C == 0.): - logging.info('msteiner: performing cholesky decomposition') - - # covariancematrix = np.identity((self.nparams)) - - Corr = np.array([ - [1, 0], # VPRM - [0, 1] - ]) #U - - # covariancematrix = np.identity((self.nparams)) - - covariancematrix = np.zeros((self.nparams, self.nparams), - dtype=np.float32) - # covariancematrix = np.zeros((self.nparams,self.nparams)) - # print("COV=", covariancematrix.shape) - specific_length_bio = 300 - specific_length_anth = 200 - # print("dist=", self.distances) - - ds = xr.open_dataset(self.distances) - logging.info('opened distances file, nparams = %d' % self.nparams) - distances = ds.Distances.values - # covariancematrix[:-n_bg_params, :-n_bg_params] = np.kron(np.exp(-distances/specific_length), c), c is the correlation matrix between categories - # for ix, x in enumerate(distances): - # if ix<1: - # covariancematrix[0,0:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) - # covariancematrix[1,1:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) - # covariancematrix[2,2:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) - # else: - # covariancematrix[3*(ix)+0,0:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) - # covariancematrix[3*(ix)+1,1:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) - # covariancematrix[3*(ix)+2,2:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) - for ix, x in enumerate(distances): - for ic, c in enumerate(Corr): - for ik, k in enumerate(c): - if ic == 1 or ik == 1: - covariancematrix[ - ix * categories + ic, - ik:-n_bg_params][::categories] = 0.5 * np.exp( - -x / specific_length_anth) * k - else: - covariancematrix[ - ix * categories + ic, - ik:-n_bg_params][::categories] = 1 * np.exp( - -x / specific_length_bio) * k - - #covariancematrix = np.zeros((self.nparams,self.nparams), dtype=np.float32) - # covariancematrix = np.zeros((self.nparams,self.nparams)) - # specific_length=200 - - # print(self.distances) - # print(covariancematrix.shape) - # ds = xr.open_dataset(self.distances) - # #logging.info('opened distances file, nparams = %d'%self.nparams) - # distances = ds.Distances.values - # for ix, x in enumerate(distances): - # if ix<1: - # covariancematrix[0,0:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) - # covariancematrix[1,1:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) - # covariancematrix[2,2:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) - # else: - # covariancematrix[3*(ix)+0,0:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) - # covariancematrix[3*(ix)+1,1:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) - # covariancematrix[3*(ix)+2,2:-n_bg_params][::3] = 1.*np.exp(-x/specific_length) - - #set variances for the 8 background elements (note python indexing) (10% std in this case): - if n_bg_params > 0: - for iii in np.arange(n_bg_params): - covariancematrix[ - -n_bg_params + iii, -n_bg_params + - iii] = 0.015 * 0.015 # 0.015*400 = 6 ppm stdev - covariancematrix[-n_bg_params + - np.mod(iii + 1, n_bg_params), - -n_bg_params + iii] = 0.015 * 0.015 * 0.25 - covariancematrix[-n_bg_params + - np.mod(iii - 1, n_bg_params), - -n_bg_params + iii] = 0.015 * 0.015 * 0.25 - #logging.info('Filled in cov matrix, dtype %s, %s, %d, %d'%(str(covariancematrix.dtype),str(covariancematrix[0][0].dtype), covariancematrix.shape[0], covariancematrix.shape[1]) ) - self.C = np.linalg.cholesky(covariancematrix) - del covariancematrix - -# # covariancematrix[covariancematrix<1.2e-2] = 0. -# -# #set variances for lbc-scaling -## for idir in np.arange(4): -## covariancematrix[-(idir+1),-(idir+1)] = 0.5 - -# msteiner: commented-out the svd as it takes endless time for a large statevector and -#... it is just for information about the dof - -# try: -# _, s, _ = np.linalg.svd(covariancematrix) -# except: -# s = np.linalg.svd(covariancematrix, full_matrices=1, compute_uv=0) #Cartesius fix -# dof = np.sum(s) ** 2 / sum(s ** 2) - - logging.info('Cholesky decomposition has finished') - # logging.info('Appr. degrees of freedom in covariance matrix is %s' % (int(dof))) - - # Create mean values - newmean = np.ones(self.nparams, - float) # standard value for a new time step is 1.0 - if lag == self.nlag - 1 and self.nlag >= 2: - newmean += 2 * self.ensemble_members[lag - 1][0].param_values - newmean = newmean / 3.0 - - #Propagate background mean state by 100%: - if n_bg_params > 0: - newmean[self.nparams - n_bg_params:] = self.ensemble_members[ - lag - 1][0].param_values[self.nparams - n_bg_params:] - - ####### New forecast model for the mean: take 100% of the optimized value ####### - #newmean = np.ones(self.nparams, float) # standard value for a new time step is 1.0 - #if lag == self.nlag - 1 and self.nlag >= 2: #self.nlag >= 3: - # newmean -= 1. - # newmean += self.ensemble_members[lag - 1][0].param_values - ####### --- ####### - - #DEBUG newmean - for cat in range(categories): - logging.info('Category (%s) ' % str(cat + 1)) - logging.info('New mean (%s) ' % - str(np.nanmean(newmean[cat:][::categories]))) - # Create the first ensemble member with a deviation of 0.0 and add to list - newmember = EnsembleMember(0) - newmember.param_values = newmean.flatten() # no deviations - self.ensemble_members[lag].append(newmember) - - # Create members 1:nmembers and add to ensemble_members list - #np.random.normal(loc=1.0, scale=0.5, size=100) - for member in range(1, self.nmembers): - rands = np.random.randn(self.nparams) - newmember = EnsembleMember(member) - logging.info('pre-dot') - # newmember.param_values = np.dot(self.C, rands) + newmean - newmember.param_values = np.einsum("ij, j -> i", self.C, - rands) + newmean - logging.info('post-dot') - self.ensemble_members[lag].append(newmember) - logging.info('Created parameters for ensemble member %i' % - (member)) - - #DEBUG lambdas - lambdas = np.array([]) - for member in range(0, self.nmembers): - logging.info( - 'Member shape (%s) ' % - str(np.shape(self.ensemble_members[lag][member].param_values))) - lambdas = np.append( - lambdas, self.ensemble_members[lag][member].param_values) - lambdas = np.reshape(lambdas, (self.nmembers, self.nparams)) - members_array = np.mean(lambdas, axis=0) - # logging.info('Member array shape (%s) ' % str(np.shape(members_array))) - for cat in range(categories): - logging.info('Category (%s) ' % str(cat + 1)) - logging.info('Lambda mean (%s) ' % - str(np.nanmean(members_array[cat:][::categories]))) - - #del C #msteiner: this line causes the "invalid pointer"-error at this point, otherwise it occurs after the code reached the end of this function - - logging.info( - '%d new ensemble members were added to the state vector # %d' % - (self.nmembers, (lag + 1))) - - def propagate(self, - dacycle, - method='create_new_member', - filename=None, - date=None, - initdir=None): - """ - :rtype: None - - Propagate the parameter values in the StateVector to the next cycle. This means a shift by one cycle - step for all states that will - be optimized once more, and the creation of a new ensemble for the time step that just - comes in for the first time (step=nlag). - In the future, this routine can incorporate a formal propagation of the statevector. - - """ - - # Remove State Vector n=1 by simply "popping" it from the list and appending a new empty list at the front. This empty list will - # hold the new ensemble for the new cycle - - self.ensemble_members.pop(0) - self.ensemble_members.append([]) - - # And now create a new time step of mean + members for n=nlag - if method == 'create_new_member': - date = dacycle['time.start'] + timedelta( - days=(self.nlag - 0.5) * int(dacycle['time.cycle'])) - cov = self.get_covariance(date, dacycle) - self.make_new_ensemble(self.nlag - 1, cov, - int(dacycle['statevector.bg_params'])) - - elif method == 'read_new_member': - if os.path.exists(filename): - self.read_ensemble_member_from_file(filename, - self.nlag - 1, - qual='opt', - read_lag=0) - else: - self.read_ensemble_member_from_file(filename, - self.nlag - 1, - date, - initdir, - qual='opt', - read_lag=0) - - elif method == 'read_mean': - date = dacycle['time.start'] + timedelta( - days=(self.nlag - 0.5) * int(dacycle['time.cycle'])) - cov = self.get_covariance(date, dacycle) - if os.path.exists(filename): - meanstate = self.read_mean_from_file(filename, - self.nlag - 1, - qual='opt') - else: - meanstate = self.read_mean_from_file(filename, - self.nlag - 1, - date, - initdir, - qual='opt') - self.make_new_ensemble(self.nlag - 1, cov, meanstate) - - logging.info('The state vector has been propagated by one cycle') - - def write_to_file(self, filename, qual): - """ - :param filename: the full filename for the output NetCDF file - :rtype: None - - Write the StateVector information to a NetCDF file for later use. - In principle the output file will have only one two datasets inside - called: - * `meanstate`, dimensions [nlag, nparamaters] - * `ensemblestate`, dimensions [nlag,nmembers, nparameters] - - This NetCDF information can be read back into a StateVector object using - :meth:`~da.baseclasses.statevector.StateVector.read_from_file` - - """ - #import da.tools.io4 as io - #import da.tools.io as io - - if qual == 'prior': - f = io.CT_CDF(filename, method='create') - logging.debug('Creating new StateVector output file (%s)' % - filename) - #qual = 'prior' - else: - f = io.CT_CDF(filename, method='write') - logging.debug('Opening existing StateVector output file (%s)' % - filename) - #qual = 'opt' - - dimparams = f.add_params_dim(self.nparams) - dimmembers = f.add_members_dim(self.nmembers) - dimlag = f.add_lag_dim(self.nlag, unlimited=True) - - for n in range(self.nlag): - members = self.ensemble_members[n] - mean_state = members[0].param_values - - savedict = f.standard_var(varname='meanstate_%s' % qual) - savedict['dims'] = dimlag + dimparams - savedict['values'] = mean_state - savedict['count'] = n - savedict['comment'] = 'this represents the mean of the ensemble' - f.add_data(savedict) - - members = self.ensemble_members[n] - devs = np.asarray([m.param_values.flatten() for m in members]) - data = devs - np.asarray(mean_state) - - savedict = f.standard_var(varname='ensemblestate_%s' % qual) - savedict['dims'] = dimlag + dimmembers + dimparams - savedict['values'] = data - savedict['count'] = n - savedict[ - 'comment'] = 'this represents deviations from the mean of the ensemble' - f.add_data(savedict) - f.close() - - logging.info('Successfully wrote the State Vector to file (%s) ' % - filename) - - def interpolate_mean_ensemble(self, - initdir, - date, - qual='opt', - readensemble=True): - # deduce window length of source run: - all_dates = os.listdir(initdir) - for i, dstr in enumerate(all_dates): - all_dates[i] = dt.datetime.strptime(dstr, '%Y%m%d') - del i, dstr - all_dates = sorted(all_dates) - ddays = (all_dates[1] - all_dates[0]).days - del all_dates - - # find dates in source directory just before and after target date - found_datemin, found_datemax = False, False - for d in range(ddays): - datei = date - dt.timedelta(days=d) - if not found_datemin and os.path.exists( - os.path.join( - initdir, datei.strftime('%Y%m%d'), - 'savestate_%s.nc' % datei.strftime('%Y%m%d'))): - datemin = datei - found_datemin = True - - datei = date + dt.timedelta(days=d) - if not found_datemax and os.path.exists( - os.path.join( - initdir, datei.strftime('%Y%m%d'), - 'savestate_%s.nc' % datei.strftime('%Y%m%d'))): - datemax = datei - found_datemax = True - - if found_datemin and found_datemax: - print('Found datemin = %s and datemax = %s' % - (datemin.strftime('%Y%m%d'), datemax.strftime('%Y%m%d'))) - break - del d - logging.debug('Ensemble for %s will be interpolated from %s and %s' % - (date.strftime('%Y-%m-%d'), datemin.strftime('%Y-%m-%d'), - datemax.strftime('%Y-%m-%d'))) - - # Read ensemble from both files - filename1 = os.path.join( - initdir, datemin.strftime('%Y%m%d'), - 'savestate_%s.nc' % datemin.strftime('%Y%m%d')) - f = io.ct_read(filename1, 'read') - meanstate1 = f.get_variable('statevectormean_' + - qual) # [nlag x nparameters] - if readensemble: - ensmembers1 = f.get_variable( - 'statevectorensemble_' + - qual) # [nlag x nmembers x nparameters] - f.close() - - filename2 = os.path.join( - initdir, datemax.strftime('%Y%m%d'), - 'savestate_%s.nc' % datemax.strftime('%Y%m%d')) - f = io.ct_read(filename2, 'read') - meanstate2 = f.get_variable('statevectormean_' + - qual) # [nlag x nparameters] - if readensemble: - ensmembers2 = f.get_variable( - 'statevectorensemble_' + - qual) # [nlag x nmembers x nparameters] - f.close() - - # interpolate mean and ensemble between datemin and datemax - meanstate = ((datemax - date).days / ddays) * meanstate1 + ( - (date - datemin).days / ddays) * meanstate2 - if readensemble: - ensmembers = ((datemax - date).days / ddays) * ensmembers1 + ( - (date - datemin).days / ddays) * ensmembers2 - return meanstate, ensmembers - - else: - return meanstate - - def read_mean_from_file(self, - filename, - lag, - date=None, - initdir=None, - qual='opt'): - if date is None: - f = io.ct_read(filename, 'read') - meanstate = f.get_variable('statevectormean_' + - qual) # [nlag x nparameters] - f.close - else: - meanstate = self.interpolate_mean_ensemble(initdir, - date, - qual, - readensemble=False) - - logging.info( - 'Successfully read the mean state vector from file (%s) ' % - filename) - - return meanstate[lag, :] - - def read_ensemble_member_from_file(self, - filename, - lag, - date=None, - initdir=None, - qual='opt', - read_lag=0): - - # if date is None we can directly read mean and ensemble members. Else we will need to read 2 ensembles and interpolate - if date is None: - f = io.ct_read(filename, 'read') - meanstate = f.get_variable('statevectormean_' + - qual) # [nlag x nparameters] - ensmembers = f.get_variable( - 'statevectorensemble_' + - qual) # [nlag x nmembers x nparameters] - f.close() - - else: - meanstate, ensmembers = self.interpolate_mean_ensemble( - initdir, date, qual, readensemble=True) - - # add to statevector - if not self.ensemble_members[lag] == []: - self.ensemble_members[lag] = [] - logging.warning( - 'Existing ensemble for lag=%d was removed to make place for newly read data' - % (n + 1)) - - for m in range(self.nmembers): - newmember = EnsembleMember(m) - newmember.param_values = ensmembers[read_lag, m, :].flatten( - ) + meanstate[ - read_lag, :] # add the mean to the deviations to hold the full parameter values - self.ensemble_members[lag].append(newmember) - - logging.info( - 'Successfully read the State Vector for lag %s from file (%s) ' % - (lag, filename)) - - def read_from_file(self, filename, qual='opt'): - """ - :param filename: the full filename for the input NetCDF file - :param qual: a string indicating whether to read the 'prior' or 'opt'(imized) StateVector from file - :rtype: None - - Read the StateVector information from a NetCDF file and put in a StateVector object - In principle the input file will have only one four datasets inside - called: - * `meanstate_prior`, dimensions [nlag, nparamaters] - * `ensemblestate_prior`, dimensions [nlag,nmembers, nparameters] - * `meanstate_opt`, dimensions [nlag, nparamaters] - * `ensemblestate_opt`, dimensions [nlag,nmembers, nparameters] - - This NetCDF information can be written to file using - :meth:`~da.baseclasses.statevector.StateVector.write_to_file` - - """ - - #import da.tools.io as io - f = io.ct_read(filename, 'read') - meanstate = f.get_variable('statevectormean_' + qual) - ensmembers = f.get_variable('statevectorensemble_' + qual) - f.close() - - for n in range(self.nlag): - if not self.ensemble_members[n] == []: - self.ensemble_members[n] = [] - logging.warning( - 'Existing ensemble for lag=%d was removed to make place for newly read data' - % (n + 1)) - - for m in range(self.nmembers): - newmember = EnsembleMember(m) - newmember.param_values = ensmembers[n, m, :].flatten( - ) + meanstate[ - n] # add the mean to the deviations to hold the full parameter values - self.ensemble_members[n].append(newmember) - - logging.info('Successfully read the State Vector from file (%s) ' % - filename) - - def write_members_to_file(self, - lag, - outdir, - endswith='.nc', - obsoperator=None): - """ - :param: lag: Which lag step of the filter to write, must lie in range [1,...,nlag] - :param: outdir: Directory where to write files - :param: endswith: Optional label to add to the filename, default is simply .nc - :rtype: None - - Write ensemble member information to a NetCDF file for later use. The standard output filename is - *parameters.DDD.nc* where *DDD* is the number of the ensemble member. Standard output file location - is the `dir.input` of the dacycle object. In principle the output file will have only two datasets inside - called `parametervalues` which is of dimensions `nparameters` and `parametermap` which is of dimensions (180,360). - This dataset can be read and used by a :class:`~da.baseclasses.observationoperator.ObservationOperator` object. - - .. note:: if more, or other information is needed to complete the sampling of the ObservationOperator you - can simply inherit from the StateVector baseclass and overwrite this write_members_to_file function. - - """ - - # These import statements caused a crash in netCDF4 on MacOSX. No problems on Jet though. Solution was - # to do the import already at the start of the module, not just in this method. - - #import da.tools.io as io - #import da.tools.io4 as io - - members = self.ensemble_members[lag] - - for mem in members: - filename = os.path.join( - outdir, 'parameters.%03d%s' % (mem.membernumber, endswith)) - ncf = io.CT_CDF(filename, method='create') - dimparams = ncf.add_params_dim(self.nparams) - dimgrid = ncf.add_latlon_dim() - - data = mem.param_values - - savedict = io.std_savedict.copy() - savedict['name'] = "parametervalues" - savedict[ - 'long_name'] = "parameter_values_for_member_%d" % mem.membernumber - savedict['units'] = "unitless" - savedict['dims'] = dimparams - savedict['values'] = data - savedict[ - 'comment'] = 'These are parameter values to use for member %d' % mem.membernumber - ncf.add_data(savedict) - - griddata = self.vector2grid(vectordata=data) - - savedict = io.std_savedict.copy() - savedict['name'] = "parametermap" - savedict[ - 'long_name'] = "parametermap_for_member_%d" % mem.membernumber - savedict['units'] = "unitless" - savedict['dims'] = dimgrid - savedict['values'] = griddata.tolist() - savedict[ - 'comment'] = 'These are gridded parameter values to use for member %d' % mem.membernumber - ncf.add_data(savedict) - - ncf.close() - - logging.debug( - 'Successfully wrote data from ensemble member %d to file (%s) ' - % (mem.membernumber, filename)) - - def get_covariance(self, date, cycleparams): - pass - - -################### End Class StateVector ################### - -if __name__ == "__main__": - pass diff --git a/cases/icon-art-CTDAS2/ctdas_patch/template.jb b/cases/icon-art-CTDAS2/ctdas_patch/template.jb deleted file mode 100644 index 06880a81..00000000 --- a/cases/icon-art-CTDAS2/ctdas_patch/template.jb +++ /dev/null @@ -1,16 +0,0 @@ -#!/bin/bash -## -## This is a set of dummy names, to be replaced by values from the dictionary -## Please make your own platform specific ctdas-icon with your own keys and place it in a subfolder of the da package. - ## -#SBATCH --job-name=CTDAS-cycle-1 -#SBATCH --partition=normal -#SBATCH --nodes=1 -#SBATCH --time=23:00:00 -#SBATCH --account={cfg.compute_account} -#SBATCH --ntasks-per-core=1 -#SBATCH --ntasks-per-node=36 - -export icycle_in_job=1 - -python3 $SCRATCH/ctdas_procchain/exec/ctdas_procchain.py -v rc=$SCRATCH/ctdas_procchain/exec/ctdas_procchain.rc >& $SCRATCH/ctdas_procchain/exec/ctdas_procchain.log diff --git a/cases/icon-art-CTDAS2/ctdas_patch/template.py b/cases/icon-art-CTDAS2/ctdas_patch/template.py deleted file mode 100644 index 79f68af8..00000000 --- a/cases/icon-art-CTDAS2/ctdas_patch/template.py +++ /dev/null @@ -1,78 +0,0 @@ -"""CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. -Users are recommended to contact the developers (wouter.peters@wur.nl) to receive -updates of the code. See also: http://www.carbontracker.eu. - -This program is free software: you can redistribute it and/or modify it under the -terms of the GNU General Public License as published by the Free Software Foundation, -version 3. This program is distributed in the hope that it will be useful, but -WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS -FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - -You should have received a copy of the GNU General Public License along with this -program. If not, see .""" -#!/usr/bin/env python - -################################################################################################# -# First order of business is always to make all other python modules accessible through the path -################################################################################################# - -import sys -import os -import logging - -sys.path.append(os.getcwd()) - -################################################################################################# -# Next, import the tools needed to initialize a data assimilation cycle -################################################################################################# - -from da.cyclecontrol.initexit_cteco2 import start_logger, validate_opts_args, parse_options, CycleControl -from da.pipelines.pipeline_icon import ensemble_smoother_pipeline, header, footer, analysis_pipeline, archive_pipeline -from da.dasystems.dasystem_baseclass import DaSystem -from da.platform.pizdaint import PizDaintPlatform -from da.statevectors.statevector_baseclass_icos_cities import StateVector -from da.observations.obs_class_ICOS_OCO2 import ICOSObservations, TotalColumnObservations # Here we set which observations we consider! -from da.obsoperators.obsoperator_ICOS_OCO2 import ObservationOperator # Here we set the obs-operator, which should sample the same observations! -from da.optimizers.optimizer_baseclass_icos_cities import Optimizer - -################################################################################################# -# Parse and validate the command line options, start logging -################################################################################################# - -start_logger() -opts, args = parse_options() -opts, args = validate_opts_args(opts, args) - -################################################################################################# -# Create the Cycle Control object for this job -################################################################################################# - -dacycle = CycleControl(opts, args) - -platform = PizDaintPlatform() -dasystem = DaSystem(dacycle['da.system.rc']) -obsoperator = ObservationOperator(dacycle['da.obsoperator.rc']) -samples = [ICOSObservations(), TotalColumnObservations()] -statevector = StateVector() -optimizer = Optimizer() - -########################################################################################## -################### ENTER THE PIPELINE WITH THE OBJECTS PASSED BY THE USER ############### -########################################################################################## - -logging.info(header + "Entering Pipeline " + footer) - -ensemble_smoother_pipeline(dacycle, platform, dasystem, samples, statevector, - obsoperator, optimizer) - -########################################################################################## -################### All done, extra stuff can be added next, such as analysis -########################################################################################## - -sys.exit(0) - -logging.info(header + "Starting analysis" + footer) - -analysis_pipeline(dacycle, platform, dasystem, samples, statevector) - -sys.exit(0) diff --git a/cases/icon-art-CTDAS2/ctdas_patch/template.rc b/cases/icon-art-CTDAS2/ctdas_patch/template.rc deleted file mode 100644 index 564df385..00000000 --- a/cases/icon-art-CTDAS2/ctdas_patch/template.rc +++ /dev/null @@ -1,116 +0,0 @@ -! CarbonTracker Data Assimilation Shell (CTDAS) Copyright (C) 2017 Wouter Peters. -! Users are recommended to contact the developers (wouter.peters@wur.nl) to receive -! updates of the code. See also: http://www.carbontracker.eu. -! -! This program is free software: you can redistribute it and/or modify it under the -! terms of the GNU General Public License as published by the Free Software Foundation, -! version 3. This program is distributed in the hope that it will be useful, but -! WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS -! FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. -! -! You should have received a copy of the GNU General Public License along with this -! program. If not, see . - -! author: Wouter Peters -! -! This is a blueprint for an rc-file used in CTDAS. Feel free to modify it, and please go to the main webpage for further documentation. -! -! Note that rc-files have the convention that commented lines start with an exclamation mark (!), while special lines start with a hashtag (#). -! -! When running the script start_ctdas.sh, this /.rc file will be copied to your run directory, and some items will be replaced for you. -! The result will be a nearly ready-to-go rc-file for your assimilation job. The entries and their meaning are explained by the comments below. -! -! -! HISTORY: -! -! Created on August 20th, 2013 by Wouter Peters -! -! -! The time for which to start and end the data assimilation experiment in format YYYY-MM-DD HH:MM:SS - -time.start : {cfg.startdate.strftime('%Y-%m-%d %H:%M:%S')} -time.finish : {cfg.enddate.strftime('%Y-%m-%d %H:%M:%S')} - -! Whether to restart the CTDAS system from a previous cycle, or to start the sequence fresh. Valid entries are T/F/True/False/TRUE/FALSE - -time.restart : False - -! The length of a cycle is given in days, such that the integer 7 denotes the typically used weekly cycle. Valid entries are integers > 1 - -time.cycle : {cfg.CTDAS_ctdas_cycle} - -! The number of cycles of lag to use for a smoother version of CTDAS. CarbonTracker CO2 typically uses 5 weeks of lag. Valid entries are integers > 0 - -time.nlag : {cfg.CTDAS_ctdas_nlag} - -! The directory under which the code, input, and output will be stored. This is the base directory for a run. The word -! '/' will be replaced through the start_ctdas.sh script by a user-specified folder name. DO NOT REPLACE - -dir.da_run : template - - -! msteiner: The directory, where the ICON-simulation is located: -dir.icon_sim : /scratch/snx3000/ekoene/processing-chain/work/CTDAS_OCO2/2018010100_0_8664/icon -sv.distances : /scratch/snx3000/ekoene/CTDAS_cells2cells.nc -op.loc_coeffs : /scratch/snx3000/ekoene/cells2stations.nc - -statevector.bg_params : {cfg.CTDAS_nboundaries} -statevector.number_regions : {nregs} -statevector.tracer : co2 - -! The resources used to complete the data assimilation experiment. This depends on your computing platform. -! The number of cycles per job denotes how many cycles should be completed before starting a new process or job, this -! allows you to complete many cycles before resubmitting a job to the queue and having to wait again for resources. -! Valid entries are integers > 0 - -da.resources.ncycles_per_job : 1 - -! The ntasks specifies the number of threads to use for the MPI part of the code, if relevant. Note that the CTDAS code -! itself is not parallelized and the python code underlying CTDAS does not use multiple processors. The chosen observation -! operator though might use many processors, like TM5. Valid entries are integers > 0 - -da.resources.ntasks : 1 - -! This specifies the amount of wall-clock time to request for each job. Its value depends on your computing platform and might take -! any form appropriate for your system. Typically, HPC queueing systems allow you a certain number of hours of usage before -! your job is killed, and you are expected to finalize and submit a next job before that time. Valid entries are strings. - -da.resources.ntime : 24:00:00 - -! The resource settings above will cause the creation of a job file in which 2 cycles will be run, and 30 threads -! are asked for a duration of 4 hours -! -! Info on the DA system used, this depends on your application of CTDAS and might refer to for instance CO2, or CH4 optimizations. -! - -da.system : CarbonTracker - -! The specific settings for your system are read from a separate rc-file, which points to the data directories, observations, etc - -da.system.rc : da/rc/cteco2/carbontracker_icon_oco2.rc - -! This flag should probably be moved to the da.system.rc file. It denotes which type of filtering to use in the optimizer - -da.system.localization : spatial - -! Info on the observation operator to be used, these keys help to identify the settings for the transport model in this case - -da.obsoperator : RandomizerObservationOperator - -! -! The TM5 transport model is controlled by an rc-file as well. The value below refers to the configuration of the TM5 model to -! be used as observation operator in this experiment. -! - -da.obsoperator.rc : da/rc/cteco2/carbontracker_icon_oco2.rc - - -da.optimizer.nmembers : {cfg.CTDAS_nensembles} -dir.icon_sim : {cfg.case_root} - - -! Column sampler specifics -output_prefix : ICON-ART-UNSTR -icon_grid_path : {cfg.input_files_scratch_dynamics_grid_filename} -tracer_optim : TRCO2_A -obs.column.footprint_samples_dim : 1 diff --git a/cases/icon-art-CTDAS2/ctdas_patch/utilities.py b/cases/icon-art-CTDAS2/ctdas_patch/utilities.py deleted file mode 100644 index c25c064e..00000000 --- a/cases/icon-art-CTDAS2/ctdas_patch/utilities.py +++ /dev/null @@ -1,335 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- -""" - -Created on Wed Sep 18 16:03:02 2019 - -@author: friedemann -""" - -import os -import glob -import logging -import subprocess -import tempfile -import copy -import netCDF4 as nc -import numpy as np - - -class utilities(object): - """ - Collection of utilities for wrfchem observation operator - that do not depend on other CTDAS modules - """ - - def __init__(self): - pass - - @staticmethod - def get_slicing_ids(N, nproc, nprocs): - """ - Purpose - ------- - For parallel processing, figure out which samples to process - by this process. - - Parameters - ---------- - N : int - Length to slice - nproc : int - id of this process (0... nprocs-1) - nprocs : int - Number of processes that work on the task. - - Output - ------ - Slicing indices id0, id1 - Usage - ----- - ..code-block:: python - - id0, id1 = get_slicing_ids(N, nproc, nprocs) - field[id0:id1, ...] - """ - - f0 = float(nproc) / float(nprocs) - id0 = int(np.floor(f0 * N)) - - f1 = float(nproc + 1) / float(nprocs) - id1 = int(np.floor(f1 * N)) - - if id0 == id1: - raise ValueError("id0==id1. Probably too many processes.") - return id0, id1 - - @classmethod - def cat_ncfiles(cls, - path, - in_arg, - cat_dim, - out_file, - in_pattern=False, - rm_original=True): - """ - Combine output of all processes into 1 file - If in_pattern, a pattern is provided instead of a file list. - This has the advantage that it can be interpreted by the shell, - because there are problems with long argument lists. - - This calls ncrcat from the nco library. If nco is not available, - rewrite this function. Note: I first tried to do this with - "cdo cat", but it messed up sounding_id - (see https://code.mpimet.mpg.de/boards/1/topics/908) - """ - - # To preserve dimension names, we start from one of the existing - # slice files instead of a new file. - - # Do this in path to avoid long command line arguments and history - # entries in outfile. - cwd = os.getcwd() - os.chdir(path) - - if in_pattern: - if not isinstance(in_arg, str): - raise TypeError( - "in_arg must be a string if in_pattern is True.") - file_pattern = in_arg - in_files = glob.glob(file_pattern) - else: - if isinstance(in_arg, list): - raise TypeError( - "in_arg must be a list if in_pattern is False.") - in_files = in_arg - - if len(in_files) == 0: - logging.error("Nothing to do.") - # Change back to previous directory - os.chdir(cwd) - return - - # Sorting is important! - in_files.sort() - - # ncrcat needs total number of soundings, count - Nobs = 0 - for f in in_files: - ncf = nc.Dataset(f, "r") - Nobs += len(ncf.dimensions[cat_dim]) - ncf.close() - - # Cat files - cmd_ = "ncrcat -h -O -d " + cat_dim + ",0,%d" % (Nobs - 1) - if in_pattern: - cmd = cmd_ + " " + file_pattern + " " + out_file - # If PIPE is used here, it gets clogged, and the process - # stops without error message (see also - # https://thraxil.org/users/anders/posts/2008/03/13/Subprocess-Hanging-PIPE-is-your-enemy/) - # Hence, piping the output to a temporary file. - proc = subprocess.Popen(cmd, - shell=True, - stdout=tempfile.TemporaryFile(), - stderr=tempfile.TemporaryFile()) - else: - cmdsplt = cmd_.split() + in_files + [out_file] - proc = subprocess.Popen(cmdsplt, - stdout=tempfile.TemporaryFile(), - stderr=tempfile.TemporaryFile()) - cmd = " ".join(cmdsplt) - - proc.wait() - - # This is probably useless since the output is piped to a - # tempfile. - retcode = cls.check_out_err(proc) - - if retcode != 0: - msg = "Something went wrong in the sampling. Command: " + cmd - logging.error(msg) - raise OSError(msg) - - # Delete slice files - if rm_original: - logging.info("Deleting slice files.") - for f in in_files: - os.remove(f) - - logging.info("Sampled WRF output written to file.") - - # Change back to previous directory - os.chdir(cwd) - - @staticmethod - def check_out_err(process): - """Displays stdout and stderr, returns returncode of the - process. - """ - - # Get process messages - out, err = process.communicate() - - # Print output - def to_str(str_or_bytestr): - """If argument is of type str, return argument. If - argument is of type bytes, return decoded str""" - if isinstance(str_or_bytestr, str): - return str_or_bytestr - elif isinstance(str_or_bytestr, bytes): - return str(str_or_bytestr, 'utf-8') - else: - msg = "str_or_bytestr is " + str(type(str_or_bytestr)) + \ - ", should be str or bytestr." - raise TypeError(msg) - - logging.debug("Subprocess output:") - if out is None: - logging.debug("No output.") - elif isinstance(out, list): - for line in out: - logging.debug(to_str(line.rstrip())) - else: - logging.debug(to_str(out.rstrip())) - - # Handle errors - if process.returncode != 0: - logging.error("subprocess error") - logging.error("Returncode: %s", str(process.returncode)) - logging.error("Message, if any:") - if not err is None: - for line in err: - logging.error(line.rstrip()) - - return process.returncode - - @classmethod - def get_index_groups(cls, *args): - """ - Input: - numpy arrays with 1 dimension or lists, all same length - Output: - Dictionary of lists of indices that have the same - combination of input values. - """ - - try: - # If pandas is available, it makes a pandas DataFrame and - # uses its groupby-function. - import pandas as pd - - args_array = np.array(args).transpose() - df = pd.DataFrame(args_array) - groups = df.groupby(list(range(len(args)))).indices - - except ImportError: - # If pandas is not available, use an own implementation of groupby. - # Recursive implementation. It's fast. - args_array = np.array(args).transpose() - groups = cls._group(args_array) - - return groups - - @classmethod - def _group(cls, a): - """ - Reimplementation of pandas.DataFrame.groupby.indices because - py 2.7 on cartesius isn't compatible with pandas. - Unlike the pandas function, this always uses all columns of the - input array. - - Parameters - ---------- - a : numpy.ndarray (2D) - Array of indices. Each row is a combination of indices. - - Returns - ------- - groups : dict - The keys are the unique combinations of indices (rows of a), - the values are the indices of the rows of a equal the key. - """ - - # This is a recursive function: It makes groups according to the - # first columnm, then calls itself with the remaining columns. - # Some index juggling. - - # Group according to first column - UI = list(set(a[:, 0])) - groups0 = dict() - for ui in UI: - # Key must be a tuple - groups0[(ui, )] = [i for i, x in enumerate(a[:, 0]) if x == ui] - - if a.shape[1] == 1: - # If the array only has one column, we're done - return groups0 - else: - # If the array has more than one column, we group those. - groups = dict() - for ui in UI: - # Group according to the remaining columns - subgroups_ui = cls._group(a[groups0[(ui, )], 1:]) - # Now the index juggling: Add the keys together and - # locate values in the original array. - for key in list(subgroups_ui.keys()): - # Get indices of bigger array - subgroups_ui[key] = [ - groups0[(ui, )][n] for n in subgroups_ui[key] - ] - # Add the keys together - groups[(ui, ) + key] = subgroups_ui[key] - - return groups - - @staticmethod - def apply_by_group(func, - array, - groups, - grouped_args=None, - *args, - **kwargs): - """ - Apply function 'func' to a numpy array by groups of indices. - 'groups' can be a list of lists or a dictionary with lists as - values. - - If 'array' has more than 1 dimension, the indices in 'groups' - are for the first axis. - - If 'grouped_args' is not None, its members are added to - 'kwargs' after slicing. - - *args and **kwargs are passed through to 'func'. - - Example: - apply_by_group(np.mean, np.array([0., 1., 2.]), [[0, 1], [2]]) - Output: - array([0.5, 2. ]) - """ - - shape_in = array.shape - shape_out = list(shape_in) - shape_out[0] = len(groups) - array_out = np.ndarray(shape_out, dtype=array.dtype) - - if type(groups) == list: - # Make a dictionary - groups = {{n: groups[n] for n in range(len(groups))}} - - if not grouped_args is None: - kwargs0 = copy.deepcopy(kwargs) - for n in range(len(groups)): - k = list(groups.keys())[n] - - # Add additional arguments that need to be grouped to kwargs - if not grouped_args is None: - kwargs = copy.deepcopy(kwargs0) - for ka, v in grouped_args.items(): - kwargs[ka] = v[groups[k], ...] - - array_out[n, ...] = np.apply_along_axis(func, 0, array[groups[k], - ...], *args, - **kwargs) - - return array_out diff --git a/cases/icon-art-CTDAS2/map_file.ana b/cases/icon-art-CTDAS2/map_file.ana deleted file mode 100644 index 6e6f5fcb..00000000 --- a/cases/icon-art-CTDAS2/map_file.ana +++ /dev/null @@ -1,109 +0,0 @@ -# ICON -# -# --------------------------------------------------------------- -# Copyright (C) 2004-2024, DWD, MPI-M, DKRZ, KIT, ETH, MeteoSwiss -# Contact information: icon-model.org -# See AUTHORS.TXT for a list of authors -# See LICENSES/ for license information -# SPDX-License-Identifier: BSD-3-Clause -# --------------------------------------------------------------- - -# Dictionary for mapping between internal names and GRIB2/Netcdf -# variable names, which is needed by ICON's read procedures. -# -# internal name variable name (here GRIB2) -theta_v THETA_V -rho DEN -ddt_tke_pconv DTKE_CON -geopot FI -!z_ifc HHL -vn VN -u U -v V -w W -tke TKE -temp T -pres P -pres_msl PMSL -pres_sfc PS -qv QV -qc QC -qi QI -qr QR -qs QS -qg QG -qh QH -qnc NCCLOUD -qnr NCRAIN -qni NCICE -qns NCSNOW -qng NCGRAUPEL -qnh NCHAIL -t_g T_G -qv_s QV_S -fr_seaice FR_ICE -t_ice T_ICE -h_ice H_ICE -t_snow T_SNOW -freshsnow FRESHSNW -snowfrac_lc SNOWC -w_snow W_SNOW -rho_snow RHO_SNOW -h_snow H_SNOW -hsnow_max HSNOW_MAX -snow_age SNOAG -t_snow_mult T_SNOW_M -rho_snow_mult RHO_SNOW_M -wtot_snow W_SNOW_M -wliq_snow WLIQ_SNOW_M -dzh_snow H_SNOW_M -w_i W_I -w_so W_SO -w_so_ice W_SO_ICE -smi SMI -t_so T_SO -t_sk SKT -t_seasfc T_SEA -gz0 Z0 -t_mnw_lk T_MNW_LK -t_wml_lk T_WML_LK -h_ml_lk H_ML_LK -t_bot_lk T_BOT_LK -c_t_lk C_T_LK -t_b1_lk T_B1_LK -h_b1_lk H_B1_LK -rh RELHUM -rh_2m RELHUM_2M -rh_2m_land RELHUM_2M_L -td_2m_land TD_2M_L -t_2m_land T_2M_L -t_2m T_2M -t2m_bias T_2M_FILTBIAS -rh_avginc RELHUM_LML_FILTINC -t_avginc T_LML_FILTINC -t_wgt_avginc T_LML_COSWGT_FILTINC -t_daywgt_avginc T_LML_DTWGT_FILTINC -rh_daywgt_avginc RELHUM_LML_DTWGT_FILTINC -p_avginc P_LML_FILTINC -vabs_avginc SP_LML_FILTINC -albdif ALB_RAD -alb_si ALB_SEAICE -asodifd_s ASWDIFD_S -asodifu_s ASWDIFU_S -asodird_s ASWDIR_S -topography_c HSURF -gust10 VMAX_10M -aer_ss AER_SS -aer_or AER_ORG -aer_bc AER_BC -aer_su AER_SO4 -aer_du AER_DUST -alb_si ALB_SEAICE -plantevap EVAP_PL -pollcory CORYsnc -pollalnu ALNUsnc -pollbetu BETUsnc -pollpoac POACsnc -pollambr AMBRsnc -GEOSP GEOSP -GEOP_ML GEOP_ML diff --git a/cases/icon-art-CTDAS2/mypartab b/cases/icon-art-CTDAS2/mypartab deleted file mode 100644 index 9552aa1f..00000000 --- a/cases/icon-art-CTDAS2/mypartab +++ /dev/null @@ -1,117 +0,0 @@ -¶meter ! temperature -name = "t" -out_name = "T" -/ -¶meter ! horiz. wind comp. u -name = "u" -out_name = "U" -/ -¶meter ! horiz. wind comp. u -name = "v" -out_name = "V" -/ -¶meter ! vertical velocity -name = "w" -out_name = "W" -/ -¶meter ! specific humidity -name = "q" -out_name = "QV" -/ -¶meter ! cloud liquid water content -name = "clwc" -out_name = "QC" -/ -¶meter ! cloud ice water content -name = "ciwc" -out_name = "QI" -/ -¶meter ! rain water content -name = "crwc" -out_name = "QR" -/ -¶meter ! snow water content -name = "cswc" -out_name = "QS" -/ -¶meter ! snow temperature -name = "TSN" -out_name = "T_SNOW" -/ -¶meter ! water content of snow -name = "SD" -out_name = "W_SNOW" -/ -¶meter ! density of snow -name = "RSN" -out_name = "RHO_SNOW" -/ -¶meter ! snow albedo -name = "ASN" -out_name = "ALB_SNOW" -/ -¶meter ! skin temperature -name = "SKT" -out_name = "SKT" -/ -¶meter ! sea surface temperature -name = "SSTK" -out_name = "SST" -/ -¶meter ! soil temperature level 1 -name = "STL1" -out_name = "STL1" -/ -¶meter ! soil temperature level 2 -name = "STL2" -out_name = "STL2" -/ -¶meter ! soil temperature level 3 -name = "STL3" -out_name = "STL3" -/ -¶meter ! soil temperature level 4 -name = "STL4" -out_name = "STL4" -/ -¶meter ! sea-ice cover -name = "CI" -out_name = "CI" -/ -¶meter ! water cont. of interception storage -name = "SRC" -out_name = "W_I" -/ -¶meter ! Land/sea mask -name = "LSM" -out_name = "LSM" -/ -¶meter ! soil moisture index layer 1 -name = "SWVL1" -out_name = "SMIL1" -/ -¶meter ! soil moisture index layer 2 -name = "SWVL2" -out_name = "SMIL2" -/ -¶meter ! soil moisture index layer 3 -name = "SWVL3" -out_name = "SMIL3" -/ -¶meter ! soil moisture index layer 4 -name = "SWVL4" -out_name = "SMIL4" -/ -¶meter ! logarithm of surface pressure -name = "LNSP" -out_name = "LNPS" -/ -¶meter ! logarithm of surface pressure -name = "SP" -out_name = "PS" -/ -¶meter -name = "Z" -out_name = "GEOSP" -/ - diff --git a/cases/icon-art-CTDAS2/wrapper_icon.sh b/cases/icon-art-CTDAS2/wrapper_icon.sh deleted file mode 120000 index a99f1b8f..00000000 --- a/cases/icon-art-CTDAS2/wrapper_icon.sh +++ /dev/null @@ -1 +0,0 @@ -/capstor/scratch/cscs/jthanwer/icon-kit//gpu/bin/../run/run_wrapper/alps_mch_gpu.sh \ No newline at end of file diff --git a/jobs/CTDAS.py b/jobs/CTDAS.py index 8999c066..26fd1975 100644 --- a/jobs/CTDAS.py +++ b/jobs/CTDAS.py @@ -93,9 +93,11 @@ def start_ctdas(cfg): """Start CTDAS process.""" logging.info("Starting CTDAS") try: - command = f"cd {cfg.CTDAS_ctdas_path} && ./start_ctdas.sh $SCRATCH ctdas_procchain" + command = f"cd {cfg.CTDAS_ctdas_path} && ./start_ctdas.sh $SCRATCH {cfg.CTDAS_project_name}" + logging.info(f"Running: {command}") subprocess.run(command, shell=True, check=True) - command = "cd $SCRATCH/ctdas_procchain/exec && sbatch ctdas_procchain.jb" + command = f"cd $SCRATCH/{cfg.CTDAS_project_name}/exec && sbatch {cfg.CTDAS_project_name}.jb" + logging.info(f"Running: {command}") subprocess.run(command, shell=True, check=True) except subprocess.CalledProcessError: logging.info( From 48b2a998d66e1db817a6be025106d84e049d3b46 Mon Sep 17 00:00:00 2001 From: github-actions Date: Fri, 21 Mar 2025 10:05:14 +0000 Subject: [PATCH 36/42] GitHub Action: Apply Pep8-formatting --- .../ctdas_patch/obs_class_ICOS_OCO2.py | 3 +++ .../ctdas_patch/obsoperator_ICOS_OCO2.py | 23 ++++++++++++------- 2 files changed, 18 insertions(+), 8 deletions(-) diff --git a/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py b/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py index 865949a8..589c5c73 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py +++ b/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py @@ -556,16 +556,19 @@ def __init__(self, idx, codex, xdate, obs=0.0, simulated=0.0, lat=-999., lon=-99 ##### freum vvvv + pressure_weighting_function=None, ##### freum ^^^^ level_def = "pressure_boundary", psurf = float('nan'), resid=0.0, hphr=0.0, flag=0, species='co2', sdev=0.0, \ ##### freum vvvv + latc_0=None, latc_1=None, latc_2=None, latc_3=None, lonc_0=None, lonc_1=None, lonc_2=None, lonc_3=None \ ##### freum ^^^^ + ): self.id = idx # Sounding ID self.code = codex # Retrieval ID diff --git a/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py b/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py index b89add21..53a74409 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py +++ b/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py @@ -645,12 +645,10 @@ def wait_for_job(job_id): return False, "UNKNOWN" while True: - result = subprocess.run( - f"sacct -j {job_id} --format=State --noheader", - shell=True, - capture_output=True, - text=True - ) + result = subprocess.run(f"sacct -j {job_id} --format=State --noheader", + shell=True, + capture_output=True, + text=True) # Extract all job states from the output states = [s.strip() for s in result.stdout.split("\n") if s.strip()] @@ -664,10 +662,15 @@ def wait_for_job(job_id): time.sleep(10) + def submit_job(command): """Submit a job and return the job ID.""" logging.info(f"Submitting job: {command}") - result = subprocess.run(command, shell=True, capture_output=True, text=True, check=False) + result = subprocess.run(command, + shell=True, + capture_output=True, + text=True, + check=False) match = re.search(r"Submitted batch job (\d+)", result.stdout) if match: @@ -676,6 +679,7 @@ def submit_job(command): logging.error("Failed to get job ID from sbatch output.") return None + def start_icon(runscript, max_retries=3): """Start an ICON job, retrying if it fails.""" retries = 0 @@ -697,10 +701,13 @@ def start_icon(runscript, max_retries=3): # Job failed, retry if under max_retries retries += 1 - logging.warning(f"Job failed with state {state}. Retrying {retries}/{max_retries}...") + logging.warning( + f"Job failed with state {state}. Retrying {retries}/{max_retries}..." + ) logging.error(f"Job failed after {max_retries} retries.") return False # Exhausted all retries + if __name__ == "__main__": pass From e0b7dbfbe5e558dee715317683f6b51665ab5c0c Mon Sep 17 00:00:00 2001 From: efmkoene Date: Fri, 21 Mar 2025 11:13:46 +0100 Subject: [PATCH 37/42] Reduce logging info during ICON job runs --- cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py b/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py index 53a74409..e47182e1 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py +++ b/cases/icon-art-CTDAS/ctdas_patch/obsoperator_ICOS_OCO2.py @@ -652,12 +652,13 @@ def wait_for_job(job_id): # Extract all job states from the output states = [s.strip() for s in result.stdout.split("\n") if s.strip()] - logging.info(f"Job {job_id} finished with states: {states}") if states: if all(s == "COMPLETED" for s in states): + logging.info(f"Job {job_id} finished with states: {states}") return True, "COMPLETED" elif any(s in ["FAILED", "CANCELLED", "TIMEOUT"] for s in states): + logging.info(f"Job {job_id} finished with states: {states}") return False, "FAILED" time.sleep(10) From 306ebc1cf4e5be36b28c9acba22521dc901a2b31 Mon Sep 17 00:00:00 2001 From: github-actions Date: Fri, 21 Mar 2025 10:14:16 +0000 Subject: [PATCH 38/42] GitHub Action: Apply Pep8-formatting --- cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py b/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py index 589c5c73..5bbef0c8 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py +++ b/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py @@ -557,6 +557,7 @@ def __init__(self, idx, codex, xdate, obs=0.0, simulated=0.0, lat=-999., lon=-99 + pressure_weighting_function=None, ##### freum ^^^^ level_def = "pressure_boundary", psurf = float('nan'), resid=0.0, hphr=0.0, flag=0, species='co2', sdev=0.0, \ @@ -564,11 +565,13 @@ def __init__(self, idx, codex, xdate, obs=0.0, simulated=0.0, lat=-999., lon=-99 + latc_0=None, latc_1=None, latc_2=None, latc_3=None, lonc_0=None, lonc_1=None, lonc_2=None, lonc_3=None \ ##### freum ^^^^ + ): self.id = idx # Sounding ID self.code = codex # Retrieval ID From 0e1ced79f9fd75caee4241e6380333bbb65d6579 Mon Sep 17 00:00:00 2001 From: efmkoene Date: Wed, 18 Jun 2025 09:57:40 +0200 Subject: [PATCH 39/42] Final modifications of CTDAS case --- cases/icon-art-CTDAS/ICON/ICON_template.job | 14 +++++++++++++- cases/icon-art-CTDAS/config.yaml | 3 ++- 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/cases/icon-art-CTDAS/ICON/ICON_template.job b/cases/icon-art-CTDAS/ICON/ICON_template.job index 06a21065..826ed10f 100644 --- a/cases/icon-art-CTDAS/ICON/ICON_template.job +++ b/cases/icon-art-CTDAS/ICON/ICON_template.job @@ -374,4 +374,16 @@ EOF cp {cfg.icon_executable} icon -srun /capstor/scratch/cscs/ekoene/icon-kit/run/run_wrapper/alps_mch_gpu.sh ./icon \ No newline at end of file + +export SOCKETS_PER_NODE=4 +export GPUS=(0 1 2 3) + +srun --export=ALL bash -c ' +export LOCAL_RANK=$SLURM_LOCALID +export GLOBAL_RANK=$SLURM_PROCID +export CUDA_VISIBLE_DEVICES=${{GPUS[$SLURM_LOCALID%8]}} +export NUMA_NODE=$(($SLURM_LOCALID % $SOCKETS_PER_NODE)) + +ulimit -s unlimited +numactl --cpunodebind=$NUMA_NODE --membind=$NUMA_NODE ./icon +' \ No newline at end of file diff --git a/cases/icon-art-CTDAS/config.yaml b/cases/icon-art-CTDAS/config.yaml index 3454ac57..08c8db59 100644 --- a/cases/icon-art-CTDAS/config.yaml +++ b/cases/icon-art-CTDAS/config.yaml @@ -1,6 +1,7 @@ # Configuration file for the 'icon-art-CTDAS' case with ICON # From the `icon-wcp` environment: +# git clone --depth 1 --recurse-submodules --shallow-submodules -b jasperfix git@github.com:efmkoene/spack-c2sm.git # - spack install nco@4.9.0 # - spack install icontools@c2sm-master%gcc # - spack install cdo @@ -10,7 +11,7 @@ constraint: gpu run_on: cpu compute_queue: normal nodes: 2 -ntasks_per_node: 4 +ntasks_per_node: 5 startdate: 2018-01-01T00:00:00Z enddate: 2018-12-31T23:59:59Z restart_step: PT10D # = CTDAS cycle length From dba221ce7ab5b53a58016fd1526a182804547fbe Mon Sep 17 00:00:00 2001 From: efmkoene Date: Wed, 18 Jun 2025 10:04:09 +0200 Subject: [PATCH 40/42] Fetch ICOS set to TRUE again (was False for debugging purposes) --- cases/icon-art-CTDAS/config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cases/icon-art-CTDAS/config.yaml b/cases/icon-art-CTDAS/config.yaml index 08c8db59..861ef23e 100644 --- a/cases/icon-art-CTDAS/config.yaml +++ b/cases/icon-art-CTDAS/config.yaml @@ -84,7 +84,7 @@ CTDAS: obs: # Run the 'authentification.ipynb' notebook to get access to ICOS and/or NASA Earthdata (OCO2) data ICOS: - fetch: False + fetch: True path: /capstor/scratch/cscs/ekoene/ICOS/ c_offset: 2 # ppm mdm: # Based on the 'runthrough' simulation From cdf3e877ef18ce15d2482443cc18dd181cb7dd05 Mon Sep 17 00:00:00 2001 From: efmkoene Date: Wed, 18 Jun 2025 10:21:23 +0200 Subject: [PATCH 41/42] Revert some changes made to main branch --- cases/icon-art-oem-test/config.yaml | 10 ++-- cases/icon-art-oem-test/icon_runjob.cfg | 4 +- jobs/tools/ICON_to_point2.py | 61 ------------------------- 3 files changed, 6 insertions(+), 69 deletions(-) delete mode 100644 jobs/tools/ICON_to_point2.py diff --git a/cases/icon-art-oem-test/config.yaml b/cases/icon-art-oem-test/config.yaml index 98796dc8..9010fcfa 100644 --- a/cases/icon-art-oem-test/config.yaml +++ b/cases/icon-art-oem-test/config.yaml @@ -2,7 +2,7 @@ workflow: icon-art-oem constraint: gpu -run_on: gpu +run_on: cpu compute_queue: normal ntasks_per_node: 12 restart_step: PT6H @@ -10,8 +10,8 @@ startdate: 2018-01-01T00:00:00Z enddate: 2018-01-01T12:00:00Z eccodes_dir: ./input/eccodes_definitions -iconremap_bin: /scratch/snx3000/ekoene/spack-c2sm/spack/opt/spack/icontools-c2sm-master/gcc-9.3.0/zktezcs5cjwjsptd747zhipi53nd6phr/bin/iconremap -iconsub_bin: /scratch/snx3000/ekoene/spack-c2sm/spack/opt/spack/icontools-c2sm-master/gcc-9.3.0/zktezcs5cjwjsptd747zhipi53nd6phr/bin/iconsub +iconremap_bin: ./ext/icontools/icontools/iconremap +iconsub_bin: ./ext/icontools/icontools/iconsub latbc_filename: ifs__lbc.nc inidata_prefix: ifs_init_ inidata_nameformat: '%Y%m%d%H' @@ -69,11 +69,11 @@ input_files: oem_monthofyear_nc: ./input/icon-art-oem/OEM/monthofyear.nc icon: - binary_file: /scratch/snx3000/msteiner/icon-kit/gpu/bin/icon + binary_file: ./ext/icon-art/bin/icon runjob_filename: icon_runjob.cfg compute_queue: normal walltime: '00:10:00' - np_tot: 6 + np_tot: 8 np_io: 1 np_restart: 1 np_prefetch: 1 diff --git a/cases/icon-art-oem-test/icon_runjob.cfg b/cases/icon-art-oem-test/icon_runjob.cfg index 9514e4e1..cfa0f75e 100644 --- a/cases/icon-art-oem-test/icon_runjob.cfg +++ b/cases/icon-art-oem-test/icon_runjob.cfg @@ -19,8 +19,6 @@ export OMP_SCHEDULE=static,12 export OMP_DYNAMIC="false" export OMP_STACKSIZE=200M -module load daint-gpu CDO - set -e -x # -- ECCODES path @@ -70,7 +68,7 @@ EOF cat > NAMELIST_{cfg.casename} << EOF ! parallel_nml: MPI parallelization ------------------------------------------- ¶llel_nml - nproma = 800 ! loop chunk length + nproma = 128 ! loop chunk length p_test_run = .FALSE. ! .TRUE. means verification run for MPI parallelization num_io_procs = {cfg.icon_np_io} ! number of I/O processors num_restart_procs = {cfg.icon_np_restart} ! number of restart processors diff --git a/jobs/tools/ICON_to_point2.py b/jobs/tools/ICON_to_point2.py deleted file mode 100644 index d88a0ad8..00000000 --- a/jobs/tools/ICON_to_point2.py +++ /dev/null @@ -1,61 +0,0 @@ -from sklearn.neighbors import BallTree -import numpy as np -from math import radians - - -def intp_icon_data(iloc, gridinfo, datainfo, latitudes, longitudes, asl, elev, - station_name): - nn_sel = np.zeros(gridinfo.nn, dtype=int) - u = np.zeros(gridinfo.nn) - - R = 6373.0 # Earth's radius in km - - if (radians(longitudes[iloc]) < np.nanmin(gridinfo.clon)) or (radians( - longitudes[iloc]) > np.nanmax(gridinfo.clon)): - return np.nan * np.ones((gridinfo.nn)), np.full( - (gridinfo.nn), -1), np.full((gridinfo.nn), -1), nn_sel, u - - if (radians(latitudes[iloc]) < np.nanmin(gridinfo.clat)) or (radians( - latitudes[iloc]) > np.nanmax(gridinfo.clat)): - return np.nan * np.ones((gridinfo.nn)), np.full( - (gridinfo.nn), -1), np.full((gridinfo.nn), -1), nn_sel, u - - lat1, lon1 = radians(latitudes[iloc]), radians(longitudes[iloc]) - - # Use BallTree for fast nearest-neighbor search - coords = np.deg2rad(np.column_stack((gridinfo.clat, gridinfo.clon))) - tree = BallTree(coords, metric='haversine') - dist, nn_sel = tree.query([[lat1, lon1]], k=gridinfo.nn) - - # Convert haversine distance (in radians) to km - dist *= R - - u = 1.0 / dist.flatten() - - idx_above = -1 * np.ones(gridinfo.nn, dtype=int) - idx_below = -1 * np.ones(gridinfo.nn, dtype=int) - - target_asl = datainfo.z_ifc[-1, nn_sel].flatten() + elev[iloc] - - for nnidx in range(gridinfo.nn): - for i_mc, mc in enumerate(datainfo.z_mc[:, nn_sel[0, nnidx]]): - if mc >= target_asl[nnidx]: - idx_above[nnidx] = i_mc - else: - idx_below[nnidx] = i_mc - break - - if idx_below[nnidx] == -1: - idx_below[nnidx] = idx_above[nnidx] - - vert_scaling_fact = np.zeros(gridinfo.nn) - - for nnidx in range(gridinfo.nn): - if idx_below[nnidx] != idx_above[nnidx]: - vert_scaling_fact[nnidx] = ( - target_asl[nnidx] - - datainfo.z_mc[idx_below[nnidx], nn_sel[0, nnidx]]) / ( - datainfo.z_mc[idx_above[nnidx], nn_sel[0, nnidx]] - - datainfo.z_mc[idx_below[nnidx], nn_sel[0, nnidx]]) - - return vert_scaling_fact, idx_below, idx_above, nn_sel.flatten(), u From d1d185e4d77c8742ae58f19032f754864513c3aa Mon Sep 17 00:00:00 2001 From: github-actions Date: Wed, 18 Jun 2025 08:22:01 +0000 Subject: [PATCH 42/42] GitHub Action: Apply Pep8-formatting --- cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py b/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py index 5bbef0c8..95ff7446 100644 --- a/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py +++ b/cases/icon-art-CTDAS/ctdas_patch/obs_class_ICOS_OCO2.py @@ -558,6 +558,7 @@ def __init__(self, idx, codex, xdate, obs=0.0, simulated=0.0, lat=-999., lon=-99 + pressure_weighting_function=None, ##### freum ^^^^ level_def = "pressure_boundary", psurf = float('nan'), resid=0.0, hphr=0.0, flag=0, species='co2', sdev=0.0, \ @@ -566,12 +567,14 @@ def __init__(self, idx, codex, xdate, obs=0.0, simulated=0.0, lat=-999., lon=-99 + latc_0=None, latc_1=None, latc_2=None, latc_3=None, lonc_0=None, lonc_1=None, lonc_2=None, lonc_3=None \ ##### freum ^^^^ + ): self.id = idx # Sounding ID self.code = codex # Retrieval ID