diff --git a/.gitignore b/.gitignore index b8ad0ac..727ba43 100644 --- a/.gitignore +++ b/.gitignore @@ -139,3 +139,10 @@ src output input temp.json + +Jupyter notebook files ignored as saved as md +*.ipynb + +# WEkEo deployment +.conda_envs_dir_test +climate_env/ diff --git a/README.md b/README.md index 842ad68..556a9b7 100644 --- a/README.md +++ b/README.md @@ -1,42 +1,56 @@ # Climate-drought -Development of drought indicators linked to the OGC Climate Resilience Pilot +Development of drought indicators linked to the OGC Climate Resilience & Disaster Pilots. -## Standalone installation for Windows +The code includes both pre-computer and computed climate indices, which those marked as experimental where they were included for specific testing purposes +* **SPI_ECMWF:** Standardized Precipitation Index (SPI) calculated from the ECMWF ERA-5 data, Copernicus Climate Change Service (C3S) API access - see below +* **SPI_GDO:** SPI pre-computed from the Global Drought Observatory (GDO), files manually downloaded +* **SPI_NCG:** SPI calculated from NOAA data, Experimental API access +* **SMA_ECMWF:** Soil Moisture Anomaly (SMA) calculated from the ECMWF ERA-5 data, C3S API access - see below +* **SMA_GDO:** SMA pre-computed from GDO, files manually downloaded +* **fAPAR:** Fraction of Active Photosynthetically Active Radiation is obtained from the GDO, files manually downloaded +* **CDI:** Combined Drought Indicator calculated from a combination of SPI, SMA and fAPAR +* **FEATURE_SAFE:** Climate projection data from SAFE, Experimental using provided file +* **UTCI:** Universal Thermal Climate Index (UTCI) download & calculated from the ECMWF ERA-5 data and then combined with SPI to create a Health Index, C3S API access - see below + +## Installation of the climate_env conda environment Install conda environment using the Anaconda Prompt: -- Setup the climate_env conda environment from within the code directory: `conda env create -n climate_env -f environment.yml` -- Activate the environment: `conda activate climate_env` -- Use pip to install the main branch of the climate indices repository: `pip install -e git+https://github.com/monocongo/climate_indices.git@master#egg=climate_indices` -- Use pip to install the feature/20 branch of the pixutils repository: `pip install -e git+https://github.com/pixalytics-ltd/pixutils.git@feature/20#egg=pixutils` -- Use pip to install the main branch of the covjson_pydantic repository (needed as the pip package, version 0.1.0 doesn't have indenting): `pip install git+https://github.com/KNMI/covjson-pydantic.git` +* Setup the climate_env conda environment from within the code directory: `conda env create -n climate_env -f environment.yml` +* Activate the environment: `conda activate climate_env` +* Use pip to install the main branch of the climate indices repository: `pip install -e git+https://github.com/monocongo/climate_indices.git@master#egg=climate_indices` +* Use pip to install the feature/20 branch of the pixutils repository: `pip install -e git+https://github.com/pixalytics-ltd/pixutils.git@feature/20#egg=pixutils` +* Use pip to install the main branch of the covjson_pydantic repository (needed as the pip package, version 0.1.0 doesn't have indenting): `pip install git+https://github.com/KNMI/covjson-pydantic.git` Note: if the climate indices or pixutils respositories needs to be edited locally, then clone them and when inside the repository, with the conda environment activated, run: `python setup.py develop` -## Using pre-calculated index data from GDO - -Fraction of Active Photosynthetically Active Radiation is obtained from the Global Drought Observatory (GDO) where it has been precomputed. Soil moisture anomaly and SPI are either computed from ECMWF data, which takes a long time to request and download, or obtained directly from a precomputed file from GDO. +## Testing/running the climate indices code -## Testing climate indices - -- Register on the Copernicus Climate Services portal: https://cds.climate.copernicus.eu/#!/home -- Get API key details and place in a file in your home directory i.e. create a file in our home directory called `.cdsapirc` with the two lines below where the key should be the one created: +### To download the input data from the Copernicus Climate Change Service +* Register on the Copernicus Climate Change Service's portal: https://cds.climate.copernicus.eu/how-to-api +* Get API key details and place in a file in your home directory i.e. create a file in our home directory called `.cdsapirc` with the two lines below where the key should be the one created: ``` -url: https://cds.climate.copernicus.eu/api/v2 +url: https://cds.climate.copernicus.eu/api key: xxxx ``` -- Run the test procedure in the activated conda environment where you define a local output directory: `python test_drought.py -y 52.5 -x 1.25 -s 20200101 -e 20221231 -p SPI -o ` - -## Index_viewer web app +### Running tests using direct interaction with the code +* Setup and active the climate_env conda environment +* Run the python code interface: `python test_drought.py -y 52.5 -x 1.25 -s 20200101 -e 20221231 -p SPI -o ` +* Run the test_drought notebook, which also needs in the conda environment: + * Install jupytext: `python -m pip install jupytext --upgrade --user` + * Create the ipynb format file from the Github synched Markdown version: `jupytext --set-formats ipynb,md --sync test_drought.md` + * Make the environment available to the jupyter notebook: `python -m ipykernel install --user --name climate_env --display-name "Python (climate_env)"` + * Startup: `jupyter notebook` +### Index_viewer web app Script to generate a web app to view and interact with Index input and output data. To run: -- Ensure streamlit=1.8.1 is installed in your environmnt -- Change `OUTPUT_DIR` to location of downloaded netcdf files from ECMWF and output JSON files -- The `DOWNLOADED` constant is a dictionary containing the details of data which has already been downloaded. I recommend downloading the required data for a number of test case CDI's using the test_drought script, because the web app will hang if you try to download data while that's running. Bear in mind that the dates of the individual index data will not be the same as the arguments specified here, as the CDI requires longer time-periods of indices. - In the command line: `conda activate climate_env` -- Run: `streamlit run index_viewer.py` +* Ensure streamlit=1.8.1 is installed in your environmnt +* Change `OUTPUT_DIR` to location of downloaded netcdf files from ECMWF and output JSON files +* The `DOWNLOADED` constant is a dictionary containing the details of data which has already been downloaded. I recommend downloading the required data for a number of test case CDI's using the test_drought script, because the web app will hang if you try to download data while that's running. Bear in mind that the dates of the individual index data will not be the same as the arguments specified here, as the CDI requires longer time-periods of indices. +* Activate the conda environment: `conda activate climate_env` +* Run streamlit: `streamlit run index_viewer.py` The web app will start up in a window in your browser. diff --git a/climate_drought/config.py b/climate_drought/config.py index 6610628..ecda2a2 100644 --- a/climate_drought/config.py +++ b/climate_drought/config.py @@ -1,4 +1,4 @@ -from datetime import datetime +from datetime import datetime,timedelta class AnalysisArgs(): def __init__(self, latitude, longitude, start_date, end_date, product='SPI', oformat='GeoJSON', singleval=False): @@ -29,11 +29,21 @@ def __init__(self, latitude, longitude, start_date, end_date, spi_source='GDO',s self.singleval = singleval # Used for viewer class Config(): - def __init__(self,outdir='output',indir='input',verbose=True,baseline_start='19850101',baseline_end='20221231',aws=False,era_daily=False): + def __init__(self,outdir='output',indir='input',verbose=True,baseline_start='19850101',baseline_end=None,aws=False,era_daily=False): self.outdir = outdir self.indir = indir self.verbose = verbose self.baseline_start = baseline_start - self.baseline_end = baseline_end self.aws = aws self.era_daily = era_daily + + if baseline_end is None: + # Set to the last day of the last month + ddn = datetime.now().replace(day=1) - timedelta(days=1) + yyyy = str(ddn.year) + mm = ('0' if ddn.month<10 else '') + str(ddn.month) + dd = ('0' if ddn.day<10 else '') + str(ddn.day) + baseline_end = yyyy + mm + dd + + self.baseline_end = baseline_end + diff --git a/climate_drought/drought_indices.py b/climate_drought/drought_indices.py index 4b446dd..a6130c0 100644 --- a/climate_drought/drought_indices.py +++ b/climate_drought/drought_indices.py @@ -9,15 +9,17 @@ # JSON export import json import geojson -import orjson from covjson_pydantic.reference_system import ReferenceSystem from covjson_pydantic.domain import Domain from covjson_pydantic.ndarray import NdArray from covjson_pydantic.coverage import Coverage -from covjson_pydantic.parameter import Parameter, ParameterGroup +from covjson_pydantic.parameter import Parameter # Drought indices calculator -from climate_drought import indices, config, utils, era5_request as erq, gdo_download as gdo, noaa_download as nd, feature_request as fr, load_feature_file as load +from climate_drought import indices, config, utils, era5_request as erq, gdo_download as gdo, noaa_download as nd, \ + feature_request as fr, load_feature_file as load +from xclim.indices import mean_radiant_temperature, universal_thermal_climate_index, uas_vas_2_sfcwind +from xclim.indicators.atmos import relative_humidity_from_dewpoint # pygeometa for OGC API record creation import yaml @@ -46,6 +48,73 @@ class SSType(Enum): BBOX = 'bbox' POLYGON = 'polygon' +class SSType(Enum): + """ + Spatial selection type + """ + POINT = 'point' + BBOX = 'bbox' + POLYGON = 'polygon' + + +# Shared constants +BOX_SIZE = 0.1 + +# where working in netcdf, and if using a polygon, we need a value to show where in the grid is not included in the polygon (since xarray covers a rectangular/square lat/lon area) +# this can't be nan as we can't differentiate between no data, so needs a unique value +OUTSIDE_AREA_SELECTION = np.nan # -99999 + + +class VarInfo(): + """ + Describes a variable which is output as part of the larger Drought Index object + E.g. SPI_ECMWF outputs tp (total precipitation) and spi + """ + + def __init__(self, longname, units, label, link="https://xxx", gridsize=None): + self.longname = longname + self.units = units + self.label = label + self.link = link + self.gridsize = gridsize + + +ALL_VARS = { + 'spg03': VarInfo('Standard Precipitation Index', 'unitless', 'Standard Precipitation Index', + "https://climatedataguide.ucar.edu/climate-data/standardized-precipitation-index-spi", gridsize=1), + 'smand': VarInfo('Soil Moisture Anomaly', 'unitless', 'Soil Moisture Anomaly', + "https://climatedataguide.ucar.edu/climate-data/soil-moisture-data-sets-overview-comparison-tables", + gridsize=0.1), + 'smant': VarInfo('Soil Moisture Anomaly', 'unitless', 'Soil Moisture Anomaly', + "https://climatedataguide.ucar.edu/climate-data/soil-moisture-data-sets-overview-comparison-tables", + gridsize=0.1), + 'fpanv': VarInfo('fraction Absorbed Photosynthetically Active Radiation (fAPAR) Anomaly', 'unitless', + 'fAPAR_anomaly', gridsize=0.083), + 'tp': VarInfo('Total Precipitation', 'm', 'Precipitation_amount', + "https://vocab.nerc.ac.uk/standard_name/precipitation_amount/"), + 'spi': VarInfo('Standard Precipitation Index', 'unitless', 'Standard Precipitation Index', + "https://climatedataguide.ucar.edu/climate-data/standardized-precipitation-index-spi"), + 'swvl1': VarInfo('Soil Water Volume Layer 1', 'm3/m3', 'Soil_moisture_amount', + "https://climatedataguide.ucar.edu/climate-data/soil-moisture-data-sets-overview-comparison-tables"), + 'swvl2': VarInfo('Soil Water Volume Layer 2', 'm3/m3', 'Soil_moisture_amount', + "https://climatedataguide.ucar.edu/climate-data/soil-moisture-data-sets-overview-comparison-tables"), + 'swvl3': VarInfo('Soil Water Volume Layer 3', 'm3/m3', 'Soil_moisture_amount', + "https://climatedataguide.ucar.edu/climate-data/soil-moisture-data-sets-overview-comparison-tables"), + 'swvl4': VarInfo('Soil Water Volume Layer 4', 'm3/m3', 'Soil_moisture_amount', + "https://climatedataguide.ucar.edu/climate-data/soil-moisture-data-sets-overview-comparison-tables"), + 'zscore_swvl1': VarInfo('Soil Moisture Anomaly Layer 1', 'unitless', 'Soil Moisture Anomaly', + "https://climatedataguide.ucar.edu/climate-data/soil-moisture-data-sets-overview-comparison-tables"), + 'zscore_swvl2': VarInfo('Soil Moisture Anomaly Layer 2', 'unitless', 'Soil Moisture Anomaly', + "https://climatedataguide.ucar.edu/climate-data/soil-moisture-data-sets-overview-comparison-tables"), + 'zscore_swvl3': VarInfo('Soil Moisture Anomaly Layer 3', 'unitless', 'Soil Moisture Anomaly', + "https://climatedataguide.ucar.edu/climate-data/soil-moisture-data-sets-overview-comparison-tables"), + 'zscore_swvl4': VarInfo('Soil Moisture Anomaly Layer 4', 'unitless', 'Soil Moisture Anomaly', + "https://climatedataguide.ucar.edu/climate-data/soil-moisture-data-sets-overview-comparison-tables"), + 'CDI': VarInfo('Combined Drought Index', 'unitless', 'Combined Drought Index'), + 'temp': VarInfo('Temperature', 'm', 'Max_Temp'), + 'utci': VarInfo('UTCI', 'K', 'Universal Thermal Climate Index'), +} + # Shared constants BOX_SIZE = 0.1 @@ -90,37 +159,38 @@ class DroughtIndex(ABC): """ Base class providing functionality for all drought indices """ - def __init__(self, config: config.Config, args: config.AnalysisArgs, vars: Dict[str,VarInfo]): + def __init__(self, config: config.Config, args: config.AnalysisArgs, vars: Dict[str, VarInfo]): """ Initializer. :param config: config object :param args: analysis args object """ - + # transfer inputs self.config = config self.args = args self.vars = vars # turn lat, lon input into a list if necessary - if not isinstance(args.latitude,list): + if not isinstance(args.latitude, list): self.args.latitude = [args.latitude] - if not isinstance(args.longitude,list): + if not isinstance(args.longitude, list): self.args.longitude = [args.longitude] - if not len(self.args.latitude)==len(self.args.latitude): + if not len(self.args.latitude) == len(self.args.latitude): self.logger.error('Latitude and longitude input must be single numbers or lists of the same length.') quit() # determine if we'e dealing with a point, polygon or bounding box - if len(self.args.latitude)==1: + if len(self.args.latitude) == 1: self.sstype = SSType.POINT - elif len(self.args.latitude)==2: + elif len(self.args.latitude) == 2: self.sstype = SSType.BBOX else: self.sstype = SSType.POLYGON # set up logger - self.logger = logging.basicConfig(filename='{0}/log_{1}.txt'.format(config.outdir,datetime.datetime.now()),level=logging.DEBUG) + self.logger = logging.basicConfig(filename='{0}/log_{1}.txt'.format(config.outdir, datetime.datetime.now()), + level=logging.DEBUG) self.logger = logging.getLogger("ERA5_Processing") self.logger.setLevel(logging.DEBUG) if config.verbose else self.logger.setLevel(logging.INFO) @@ -131,7 +201,7 @@ def __init__(self, config: config.Config, args: config.AnalysisArgs, vars: Dict[ @property def index_shortname(self): - return type(self).__name__.replace('_','') + return type(self).__name__.replace('_', '') @property def output_file_path(self): @@ -140,7 +210,7 @@ def output_file_path(self): :return: path to the output file """ - bbox = len(self.args.longitude)>1 + bbox = len(self.args.longitude) > 1 minlat = np.min(self.args.latitude) if bbox else float(self.args.latitude[0]) - BOX_SIZE minlon = np.min(self.args.longitude) if bbox else float(self.args.longitude[0]) - BOX_SIZE @@ -156,16 +226,17 @@ def output_file_path(self): file_str = "{sd}-{ed}_{la}_{lo}".format(sd=self.args.start_date, ed=self.args.end_date, la=latstr, lo=lonstr) oformat = self.args.oformat.lower() - if "cov" in oformat: # Generate CoverageJSON file + if "cov" in oformat: # Generate CoverageJSON file file_ext = 'covjson' elif "csv" in oformat: # Generate CSV file_ext = 'csv' elif "net" in oformat: # Generate NetCDF file_ext = 'nc' - else: # Generate GeoJSON + else: # Generate GeoJSON file_ext = 'json' - return os.path.join(self.config.outdir, self.index_shortname.lower() + "_{d}.{e}".format(d=file_str, e=file_ext)) + return os.path.join(self.config.outdir, + self.index_shortname.lower() + "_{d}.{e}".format(d=file_str, e=file_ext)) @abstractclassmethod def download(self) -> List[str]: @@ -192,18 +263,22 @@ def generate_geojson(self) -> None: self.feature_collection = {"type": "FeatureCollection", "features": []} # Reindex and drop duplicates - df = self.data_df.set_index(['time','latitude','longitude']) + df = self.data_df.set_index(['time', 'latitude', 'longitude']) df = df.drop_duplicates() - #print("Data frame: ", self.data_df) + # print("Data frame: ", self.data_df) # Drop if whole row is NANs df = df.dropna(how='all') + # Replace NANs with None + df = df.replace(to_replace=np.NAN, value=None) + for i in df.index: - feature = {"type": "Feature", "geometry": {"type": "Point", "coordinates": [float(i[2]), float(i[1])]}, "properties": {}} + feature = {"type": "Feature", "geometry": {"type": "Point", "coordinates": [float(i[2]), float(i[1])]}, + "properties": {}} # Extract columns as properties - property = df.loc[i].to_json(date_format='iso', force_ascii = True) + property = df.loc[i].to_json(date_format='iso', force_ascii=True) parsed = json.loads(property) # Add time as a property @@ -212,11 +287,10 @@ def generate_geojson(self) -> None: properties.update({"_date": i[0].strftime("%Y-%m-%d")}) properties.update(parsed) feature['properties'] = properties - #self.logger.info("{} Feature: {}".format(i, properties))#['spi'])) # Add feature self.feature_collection['features'].append(feature) dump = geojson.dumps(self.feature_collection, indent=4) - #self.logger.info("JSON: ",dump) + # self.logger.info("JSON: ",dump) # Reload to check formatting json_x = geojson.loads(dump) @@ -249,7 +323,7 @@ def generate_covjson(self) -> None: "en": val.longname }, unit={ - "symbol":val.units + "symbol": val.units }, observedProperty={ "id": val.link, @@ -260,10 +334,10 @@ def generate_covjson(self) -> None: ) # Add each variable data to ranges ranges[key] = NdArray( - axisNames=["x","y","t"], - shape=[len(longitudes),len(latitudes),len(dates)], + axisNames=["x", "y", "t"], + shape=[len(longitudes), len(latitudes), len(dates)], values=df[key].to_numpy().flatten().tolist() - ) + ) # Create Structure self.feature_collection = Coverage( domain=Domain( @@ -281,7 +355,7 @@ def generate_covjson(self) -> None: # TODO Indent option now fails self.logger.warning("The CovJSON indenting option is no longer working - need to look at") - json_x = self.feature_collection.json(exclude_none=True)#, indent=True) + json_x = self.feature_collection.json(exclude_none=True) # , indent=True) f = open(self.output_file_path, "w", encoding='utf-8') f.write(json_x) @@ -299,17 +373,18 @@ def generate_record(self) -> None: f.close() # Define output record yaml - out_yaml = os.path.join(os.path.dirname(__file__), os.path.splitext(os.path.basename(yaml_file))[0] + "-updated.yml") + out_yaml = os.path.join(os.path.dirname(__file__), + os.path.splitext(os.path.basename(yaml_file))[0] + "-updated.yml") # Update bounding box self.logger.info("dataMap: {} ".format(dataMap['identification']['extents']['spatial'])) yaml_dict = {} ## [bounds.left, bounds.bottom, bounds.right, bounds.top] - if self.sstype==SSType.POINT: - minlo = self.args.longitude[0]-BOX_SIZE - minla = self.args.latitude[0]-BOX_SIZE - maxlo = self.args.longitude[0]+BOX_SIZE - maxla = self.args.latitude[0]+BOX_SIZE + if self.sstype == SSType.POINT: + minlo = self.args.longitude[0] - BOX_SIZE + minla = self.args.latitude[0] - BOX_SIZE + maxlo = self.args.longitude[0] + BOX_SIZE + maxla = self.args.latitude[0] + BOX_SIZE else: minlo = np.min(self.args.longitude) minla = np.min(self.args.latitude) @@ -317,7 +392,7 @@ def generate_record(self) -> None: maxla = np.max(self.args.latitude) float_bbox = '[{:.3f},{:.3f},{:.3f},{:.3f}]'.format(minlo, minla, maxlo, maxla) yaml_dict.update({'bbox': ast.literal_eval(float_bbox)}) - #yaml_dict.update({'crs': ast.literal_eval(dst_crs.split(":")[1])}) + # yaml_dict.update({'crs': ast.literal_eval(dst_crs.split(":")[1])}) # remove single quotes res = {key.replace("'", ""): val for key, val in yaml_dict.items()} @@ -391,48 +466,48 @@ def generate_output(self) -> None: # drop if whole row is NANs df = self.data_df.dropna(how='all') - df.to_csv(self.output_file_path,index=False) + df.to_csv(self.output_file_path, index=False) elif "net" in oformat: # Generate NetCDF # drop if whole time-series is NANs df = self.data_ds.dropna(dim='time', how='all') - xr.Dataset(df).to_netcdf(self.output_file_path) else: # Generate GeoJSON - self.generate_geojson() else: self.logger.warning('Outfile not written: already exists') + class GDODroughtIndex(DroughtIndex): """ Specialisation of the Drought class for processing pre-computed indices from the Global Drought Observatory. """ + def __init__(self, config: config.Config, args: config.AnalysisArgs, prod_code: Union[List[str], str]): # Turn product code into list if not already - self.prod_code = [prod_code] if isinstance(prod_code,str) else prod_code + self.prod_code = [prod_code] if isinstance(prod_code, str) else prod_code # Get variable details for requested products vars = dict(filter(lambda k: k[0] in self.prod_code, ALL_VARS.items())) - super().__init__(config,args,vars) + super().__init__(config, args, vars) self.grid_size = next(iter(self.vars.values())).gridsize self.fileloc = config.indir + "/" + self.prod_code[0] if not os.path.isdir(self.fileloc): os.mkdir(self.fileloc) # Create GDO download objects so we can see what the filenames are - + ## create list of years to download data for - years = np.arange(int(self.args.start_date[:4]),int(self.args.end_date[:4])+1) + years = np.arange(int(self.args.start_date[:4]), int(self.args.end_date[:4]) + 1) dl_objs = [] for y in years: for pc in self.prod_code: - obj = gdo.GDODownload(y,pc,self.fileloc,logger=self.logger) + obj = gdo.GDODownload(y, pc, self.fileloc, logger=self.logger) if obj.success: dl_objs.append(obj) @@ -441,7 +516,7 @@ def __init__(self, config: config.Config, args: config.AnalysisArgs, prod_code: def download(self): - self.logger.info("Downloading {} files to {}".format(len(self.files),self.fileloc)) + self.logger.info("Downloading {} files to {}".format(len(self.files), self.fileloc)) filelist = [] for f in self.files: if "https" in f.files_to_download: @@ -450,44 +525,45 @@ def download(self): filelist = filelist + f.files_to_download self.filepaths = [self.fileloc + "/" + f for f in filelist] - - if len(self.filepaths)==0: + if len(self.filepaths) == 0: self.logger.error('No files available to be processed') return None else: return self.filepaths - + def load_and_trim(self): def open_point(fname): - return xr.open_dataset(fname).sel(lat=self.args.latitude,lon=self.args.longitude,method='nearest').drop_vars(['4326']) + return xr.open_dataset(fname).sel(lat=self.args.latitude, lon=self.args.longitude, + method='nearest').drop_vars(['4326']) def open_bbox(fname): ds = xr.open_dataset(fname).drop_vars(['4326']) try: mask = utils.mask_ds_bbox(ds, - np.min(self.args.longitude), - np.max(self.args.longitude), - np.min(self.args.latitude), - np.max(self.args.latitude)) - except: # Expand bounds + np.min(self.args.longitude), + np.max(self.args.longitude), + np.min(self.args.latitude), + np.max(self.args.latitude)) + except: # Expand bounds mask = utils.mask_ds_bbox(ds, - np.min(self.args.longitude)-(BOX_SIZE*3), - np.max(self.args.longitude)+(BOX_SIZE*3), - np.min(self.args.latitude)-(BOX_SIZE*3), - np.max(self.args.latitude)+(BOX_SIZE*3)) + np.min(self.args.longitude) - (BOX_SIZE * 3), + np.max(self.args.longitude) + (BOX_SIZE * 3), + np.min(self.args.latitude) - (BOX_SIZE * 3), + np.max(self.args.latitude) + (BOX_SIZE * 3)) self.logger.info("Needed to expand bounding box: {} ".format(mask.dims)) return mask def open_poly(fname): - ds = xr.open_dataset(fname).drop_vars(['4326']) + ds = xr.open_dataset(fname).drop_vars(['4326']) return utils.mask_ds_poly(ds, - self.args.latitude, - self.args.longitude, - self.grid_size, - self.grid_size, - other = OUTSIDE_AREA_SELECTION - ) + self.args.latitude, + self.args.longitude, + self.grid_size, + self.grid_size, + other=OUTSIDE_AREA_SELECTION + ) + # Methods to open data open_func = { SSType.POINT.value: open_point, @@ -500,13 +576,47 @@ def open_poly(fname): # Trim to required dates try: - ds = ds.sel(time=slice(pd.Timestamp(self.args.start_date),pd.Timestamp(self.args.end_date))) + ds = ds.sel(time=slice(pd.Timestamp(self.args.start_date), pd.Timestamp(self.args.end_date))) except: - self.logger.error("Couldn't slice data between {} and {}".format(self.args.start_date,self.args.end_date)) + self.logger.error("Couldn't slice data between {} and {}".format(self.args.start_date, self.args.end_date)) return None return ds - + + +class SPI_GDO(GDODroughtIndex): + """ + Specialisation of the GDODrought class for processing pre-computed photosynthetically active radiation anomaly data from GDO. + """ + + def __init__(self, config: config.Config, args: config.AnalysisArgs): + super().__init__(config, args, 'spg03') + + def process(self): + ds = super().load_and_trim() + if ds is None: + self.logger.error("No data available") + return None + + # Fill any data gaps + time_months = pd.date_range(self.args.start_date, self.args.end_date, freq='1MS') + ds = ds.reindex({'time': time_months}) + + # Rename lat and lon coords for consitency with other drought indices + ds = ds.rename({'lat': 'latitude', 'lon': 'longitude'}) + + self.data_ds = ds + + # Convert to df for output + df = ds.to_dataframe().reset_index() + + # Drop locations outside of selected area + df = df[df.spg03 != OUTSIDE_AREA_SELECTION] + self.data_df = df + + return df + + class SPI_ECMWF(DroughtIndex): def __init__(self, config: config.Config, args: config.AnalysisArgs): @@ -516,24 +626,24 @@ def __init__(self, config: config.Config, args: config.AnalysisArgs): :param working_dir: directory that will hold all files generated by the class """ # Get variable details for requested products - vars = dict(filter(lambda k: k[0] in ['tp','spi'], ALL_VARS.items())) + vars = dict(filter(lambda k: k[0] in ['tp', 'spi'], ALL_VARS.items())) # precipitation download must return a baseline time series because this is a requirement of the outsourced spi calculation algorithm super().__init__(config, args, vars) - + # create era5 request object request = erq.ERA5Request( erq.PRECIP_VARIABLES, 'precip', self.args, - self.config, + self.config, start_date=config.baseline_start, end_date=config.baseline_end, frequency=erq.Freq.MONTHLY, aws=self.config.aws) # initialise the download object using the request, but don't download yet - self.download_obj = erq.ERA5Download(request,self.logger) + self.download_obj = erq.ERA5Download(request, self.logger) def download(self): """ @@ -560,15 +670,14 @@ def convert_precip_to_spi(self) -> None: # Extract data from NetCDF file ds = xr.open_dataset(self.download_obj.download_file_path) - - if 'expver' in ds.keys(): - ds = ds.sel(expver=1,drop=True) + # if 'expver' in ds.keys(): + # ds = ds.sel(expver=1,drop=True) self.logger.debug("Precip xarray:") self.logger.debug(ds) # Mask polygon if needed - if self.sstype.value==SSType.POLYGON.value: + if self.sstype.value == SSType.POLYGON.value: ds = utils.mask_ds_poly( ds=ds, lats=self.args.latitude, @@ -588,10 +697,10 @@ def convert_precip_to_spi(self) -> None: spi = indices.INDICES() # Convert to monthly sums and extract max of the available cells - if self.config.aws or self.config.era_daily: # or any other setting which would result in more than monthy data + if self.config.aws or self.config.era_daily: # or any other setting which would result in more than monthy data da = da.resample(time='1MS').sum() - - if self.sstype.value==SSType.POINT.value: + + if self.sstype.value == SSType.POINT.value: da = da.max(['latitude', 'longitude']).load() # Calculate SPI from precip @@ -602,22 +711,25 @@ def convert_precip_to_spi(self) -> None: lat = np.repeat(self.args.latitude, num_vals) lon = np.repeat(self.args.longitude, num_vals) ds = xr.Dataset(data_vars={'tp': da, 'spi': ("time", spi_vals)}) - ds = ds.assign_coords({"longitude": lon})\ + ds = ds.assign_coords({"longitude": lon}) \ .assign_coords({"latitude": lat}) - #print("ECMWF ds: ",ds) + # print("ECMWF ds: ",ds) else: - spi_vals = xr.apply_ufunc(spi.calc_spi,da,input_core_dims=[['time']],output_core_dims=[['time']],vectorize=True) + spi_vals = xr.apply_ufunc(spi.calc_spi, da, input_core_dims=[['time']], output_core_dims=[['time']], + vectorize=True) # Store spi - ds = xr.Dataset(data_vars={'tp':da,'spi':spi_vals}) + ds = xr.Dataset(data_vars={'tp': da, 'spi': spi_vals}) - self.logger.info("Input precipitation, {} values: {:.3f} {:.3f} ".format(len(da.values), np.nanmin(da.values), np.nanmax(da.values))) - self.logger.info("SPI, {} values: {:.3f} {:.3f}".format(len(spi_vals), np.nanmin(spi_vals),np.nanmax(spi_vals))) + self.logger.info("Input precipitation, {} values: {:.3f} {:.3f} ".format(len(da.values), np.nanmin(da.values), + np.nanmax(da.values))) + self.logger.info( + "SPI, {} values: {:.3f} {:.3f}".format(len(spi_vals), np.nanmin(spi_vals), np.nanmax(spi_vals))) return ds - + def process(self): """ Carries out processing of the downloaded data. This is the main functionality that is likely to differ between @@ -627,16 +739,17 @@ def process(self): self.logger.info("Initiating processing of ERA5 daily data.") if not os.path.isfile(self.download_obj.download_file_path): - raise FileNotFoundError("Unable to locate downloaded data '{}'.".format(self.spi_download.download_file_path)) - + raise FileNotFoundError( + "Unable to locate downloaded data '{}'.".format(self.spi_download.download_file_path)) + # Calculates SPI precipitation drought index ds = self.convert_precip_to_spi() # Select requested time slice - ds_filtered = utils.crop_ds(ds,self.args.start_date,self.args.end_date) + ds_filtered = utils.crop_ds(ds, self.args.start_date, self.args.end_date) # Fill any missing gaps - time_months = pd.date_range(self.args.start_date,self.args.end_date,freq='1MS') + time_months = pd.date_range(self.args.start_date, self.args.end_date, freq='1MS') ds_reindexed = ds_filtered.reindex({'time': time_months}) df_reindexed = ds_reindexed.to_dataframe().reset_index() @@ -648,38 +761,7 @@ def process(self): self.generate_output() return df_reindexed - -class SPI_GDO(GDODroughtIndex): - """ - Specialisation of the GDODrought class for processing pre-computed photosynthetically active radiation anomaly data from GDO. - """ - def __init__(self, config: config.Config, args: config.AnalysisArgs): - super().__init__(config,args,'spg03') - - def process(self): - ds = super().load_and_trim() - - if ds is None: - self.logger.error("No data available") - return None - - # Fill any data gaps - time_months = pd.date_range(self.args.start_date,self.args.end_date,freq='1MS') - ds = ds.reindex({'time': time_months}) - - # Rename lat and lon coords for consitency with other drought indices - ds = ds.rename({'lat':'latitude','lon':'longitude'}) - - self.data_ds = ds - - # Convert to df for output - df = ds.to_dataframe().reset_index() - - # Drop locations outside of selected area - df = df[df.spg03!=OUTSIDE_AREA_SELECTION] - self.data_df = df - return df class SPI_NCG(DroughtIndex): def __init__(self, config: config.Config, args: config.AnalysisArgs): @@ -701,19 +783,18 @@ def __init__(self, config: config.Config, args: config.AnalysisArgs): # check requeste data is within space constraints isbetween = lambda x, a, b: (x >= a) and (x <= b) if not isbetween(args.latitude, minlat, maxlat): - self.logger.error('Latitude outside data extent: {0} to {1}N'.format(minlat,maxlat)) + self.logger.error('Latitude outside data extent: {0} to {1}N'.format(minlat, maxlat)) quit() elif not isbetween(args.longitude, minlon, maxlon): - self.logger.error('Longitude outside data extent: {0} to {1}N'.format(minlon,maxlon)) + self.logger.error('Longitude outside data extent: {0} to {1}N'.format(minlon, maxlon)) quit() # define a filename to output to self.filename = os.path.join(config.indir, "/noaa_prcp_{sd}-{ed}_{la}_{lo}.csv".format( - sd = config.baseline_start, - ed = config.baseline_end, - la = args.latitude, - lo = args.longitude)) - + sd=config.baseline_start, + ed=config.baseline_end, + la=args.latitude, + lo=args.longitude)) def download(self): """ @@ -730,8 +811,8 @@ def download(self): nd.NClimGridParams.PRECIPITATION, self.filename) self.logger.info("Downloading for '{}' completed.".format(downloaded_file)) - return self.filename - + return self.filename + def convert_precip_to_spi(self) -> None: """ Calculates SPI precipitation drought index @@ -749,10 +830,10 @@ def convert_precip_to_spi(self) -> None: df['spi'] = spi_vals # Select requested time slice - df_filtered = utils.crop_df(df,self.args.start_date,self.args.end_date) + df_filtered = utils.crop_df(df, self.args.start_date, self.args.end_date) return df_filtered - + def process(self): """ Carries out processing of the downloaded data. @@ -762,13 +843,16 @@ def process(self): if not os.path.isfile(self.filename): raise FileNotFoundError("Unable to locate downloaded data '{}'.".format(self.filename)) - + # Calculates SPI precipitation drought index - df_filtered = self.convert_precip_to_spi() + ds = self.convert_precip_to_spi() + + # Select requested time slice + ds_filtered = utils.crop_ds(ds,self.args.start_date,self.args.end_date) # Fill any missing gaps - time_months = pd.date_range(self.args.start_date,self.args.end_date,freq='1MS') - df_filtered = utils.fill_gaps(time_months,df_filtered) + time_months = pd.date_range(self.args.start_date, self.args.end_date, freq='1MS') + df_filtered = utils.fill_gaps(time_months, df_filtered) # store processed data on object self.data_df = df_filtered @@ -788,7 +872,7 @@ def __init__(self, config: config.Config, args: config.AnalysisArgs): """ # Get variable details for requested products - vars = dict(filter(lambda k: k[0] in ['tp','temp'], ALL_VARS.items())) + vars = dict(filter(lambda k: k[0] in ['tp', 'temp'], ALL_VARS.items())) # precipitation download must return a baseline time series because this is a requirement of the outsourced spi calculation algorithm super().__init__(config, args, vars) @@ -810,10 +894,14 @@ def __init__(self, config: config.Config, args: config.AnalysisArgs): # define a filename to output to # To Do use vars for product name? self.filename = os.path.join(config.indir, "safe_{}_forecast_{sd}-{ed}_{la}_{lo}.geojson".format('tp', - sd=config.baseline_start, - ed=config.baseline_end, - la=args.latitude[0], - lo=args.longitude[0])) + sd=config.baseline_start, + ed=config.baseline_end, + la= + args.latitude[ + 0], + lo= + args.longitude[ + 0])) def download(self): """ @@ -877,14 +965,16 @@ def process(self): if int(self.args.start_date[0:6]) < 201912: clip_date = '20191201' else: - end_date = datetime.date(int(self.args.start_date[0:4]),int(self.args.start_date[4:6]),int(self.args.start_date[6:8])) - datetime.timedelta(days=31) + end_date = datetime.date(int(self.args.start_date[0:4]), int(self.args.start_date[4:6]), + int(self.args.start_date[6:8])) - datetime.timedelta(days=31) clip_date = end_date.strftime('%Y%m%d') - self.logger.info("Clipping ECMWF data from {} to {}".format(self.config.baseline_start,clip_date)) + self.logger.info("Clipping ECMWF data from {} to {}".format(self.config.baseline_start, clip_date)) ds = ds.sel(time=slice(pd.Timestamp(self.config.baseline_start), pd.Timestamp(clip_date))) # Load SAFE data - safe = load.LoadSAFE(logger=logging,infile=self.filename) - df_filtered = safe.load_safe(ds.to_dataframe().reset_index(), lat_val=self.args.latitude[0], lon_val=self.args.longitude[0]) + safe = load.LoadSAFE(logger=logging, infile=self.filename) + df_filtered = safe.load_safe(ds.to_dataframe().reset_index(), lat_val=self.args.latitude[0], + lon_val=self.args.longitude[0]) # Generate output file self.data_df = df_filtered @@ -908,8 +998,8 @@ def convert_precip_to_spi(self) -> None: if 'expver' in ds.keys(): ds = ds.sel(expver=1, drop=True) - #self.logger.debug("Xarray:") - #self.logger.debug(ds) + # self.logger.debug("Xarray:") + # self.logger.debug(ds) # Mask polygon if needed if self.sstype.value == SSType.POLYGON.value: @@ -963,81 +1053,367 @@ def convert_precip_to_spi(self) -> None: return ds -class SMA_ECMWF(DroughtIndex): - """ - Specialisation of the json base class for downloading and processing soil water data - """ +class SPI_NCG(DroughtIndex): def __init__(self, config: config.Config, args: config.AnalysisArgs): """ - Initializer. Forwards parameters to super class, then instantiates download object. - :param args: argument object + Metadata: https://www.drought.gov/data-maps-tools/gridded-climate-datasets-noaas-nclimgrid-monthly + Spatial extent: -124.6875 to -67.020836W, 24.562532 to 49.3542N + Temporal extent: + :param args: program arguments :param working_dir: directory that will hold all files generated by the class """ + # precipitation download must return a baseline time series because this is a requirement of the outsourced spi calculation algorithm + super().__init__(config, args) - # Get variable details for requested products - vars = dict(filter(lambda k: k[0] in ['swvl1','swvl2','swvl3','swvl4','zscore_swvl1','zscore_swvl2','zscore_swvl3','zscore_swvl4'], ALL_VARS.items())) + maxlat = 49.3542 + minlat = 24.562532 + maxlon = -67.020836 + minlon = -124.6875 - super().__init__(config,args,vars) - self.logger.debug("Initiated ERA5 daily processing of soil water.") - - #initialise download objects - #long-term 'baseline' object to compute the mean - request_baseline = erq.ERA5Request( - erq.SOILWATER_VARIABLES, - 'soilwater', - self.args, - self.config, - start_date=config.baseline_start, - end_date=config.baseline_end, - frequency=erq.Freq.MONTHLY) - - self.download_obj_baseline = erq.ERA5Download(request_baseline, self.logger) + # check requeste data is within space constraints + isbetween = lambda x, a, b: (x >= a) and (x <= b) + if not isbetween(args.latitude, minlat, maxlat): + self.logger.error('Latitude outside data extent: {0} to {1}N'.format(minlat,maxlat)) + quit() + elif not isbetween(args.longitude, minlon, maxlon): + self.logger.error('Longitude outside data extent: {0} to {1}N'.format(minlon,maxlon)) + quit() - #create era5 request object for short term period - request_sample = erq.ERA5Request( - erq.SOILWATER_VARIABLES, - 'soilwater', - self.args, - self.config, - args.start_date, - args.end_date, - frequency=erq.Freq.DAILY if self.config.era_daily else erq.Freq.HOURLY) - - self.download_obj_sample = erq.ERA5Download(request_sample, self.logger) + # define a filename to output to + self.filename = os.path.join(config.indir, "/noaa_prcp_{sd}-{ed}_{la}_{lo}.csv".format( + sd = config.baseline_start, + ed = config.baseline_end, + la = args.latitude, + lo = args.longitude)) + def download(self): """ - Download requried data from ERA5 portal using the imported ERA5 request module. - Download long term monthly data for the long term mean, and separately hourly data for short term period. + Download required data from NOAA portal. + The processing part of the SPI calculation requires that the long term dataset is passed in at the same time as the short term analysis period therefore we must request the whole baseline period for this analysis. + :output: list containing name of single generated csv file. """ - def exists_or_download(erad: erq.ERA5Download): - if os.path.exists(erad.download_file_path): - self.logger.info("Downloaded file '{}' already exists.".format(erad.download_file_path)) - else: - downloaded_file = erad.download() - self.logger.info("Downloading for '{}' completed.".format(downloaded_file)) - - # download baseline and monthly data - exists_or_download(self.download_obj_baseline) - exists_or_download(self.download_obj_sample) - return [self.download_obj_baseline.download_file_path, self.download_obj_sample.download_file_path] + if os.path.exists(self.filename): + self.logger.info("Downloaded file '{}' already exists.".format(self.filename)) + else: + downloaded_file = nd.get_nclimgrid(self.args.longitude, self.args.latitude, + self.config.baseline_start, self.config.baseline_end, + nd.NClimGridParams.PRECIPITATION, self.filename) + self.logger.info("Downloading for '{}' completed.".format(downloaded_file)) - def process(self) -> str: + return self.filename + + def convert_precip_to_spi(self) -> None: """ - Carries out processing of the downloaded data. This is the main functionality that is likely to differ between - each implementation. - :return: path to the output file generated by the algorithm + Calculates SPI precipitation drought index + :param input_file_path: path to file containing precipitation + :param output_file_path: path to file to be written containing SPI + :return: nothing """ - self.logger.info("Initiating processing of ERA5 soil water data.") - path_monthly = self.download_obj_baseline.download_file_path - path_sample = self.download_obj_sample.download_file_path + # Extract data from csv + df = pd.read_csv(self.filename, index_col='time', parse_dates=True) + + # Calculate SPI and add to df + spi = indices.INDICES() + spi_vals = spi.calc_spi(df['prcp'].to_numpy()) + df['spi'] = spi_vals + + # Select requested time slice + df_filtered = utils.crop_df(df,self.args.start_date,self.args.end_date) + + return df_filtered + + def process(self): + """ + Carries out processing of the downloaded data. + :return: path to the output file generated by the algorithm + """ + self.logger.info("Initiating processing of ERA5 daily data.") + + if not os.path.isfile(self.filename): + raise FileNotFoundError("Unable to locate downloaded data '{}'.".format(self.filename)) + + # Calculates SPI precipitation drought index + df_filtered = self.convert_precip_to_spi() + + # Fill any missing gaps + time_months = pd.date_range(self.args.start_date,self.args.end_date,freq='1MS') + df_filtered = utils.fill_gaps(time_months,df_filtered) + + # store processed data on object + self.data_df = df_filtered + + self.generate_output() + + return df_filtered + + +class FEATURE_SAFE(DroughtIndex): + def __init__(self, config: config.Config, args: config.AnalysisArgs): + """ + Spatial extent: -137.1584, 25.8242, -46.2405, 59.1733 + Temporal extent: + :param args: program arguments + :param working_dir: directory that will hold all files generated by the class + """ + + # Get variable details for requested products + vars = dict(filter(lambda k: k[0] in ['tp','temp'], ALL_VARS.items())) + + # precipitation download must return a baseline time series because this is a requirement of the outsourced spi calculation algorithm + super().__init__(config, args, vars) + + maxlat = 59.1733 + minlat = 25.8242 + maxlon = -46.2405 + minlon = -137.1584 + + # check requested data is within space constraints + isbetween = lambda x, a, b: (x >= a) and (x <= b) + if not isbetween(args.latitude[0], minlat, maxlat): + self.logger.error('Latitude outside data extent: {0} to {1}N'.format(minlat, maxlat)) + quit() + elif not isbetween(args.longitude[0], minlon, maxlon): + self.logger.error('Longitude outside data extent: {0} to {1}N'.format(minlon, maxlon)) + quit() + + # define a filename to output to + # To Do use vars for product name? + self.filename = os.path.join(config.indir, "safe_{}_forecast_{sd}-{ed}_{la}_{lo}.geojson".format('tp', + sd=config.baseline_start, + ed=config.baseline_end, + la=args.latitude[0], + lo=args.longitude[0])) + + def download(self): + """ + Download required data from SAFE server. + :output: list containing name of single generated csv file. + """ + + if os.path.exists(self.filename): + self.logger.info("Downloaded file '{}' already exists.".format(self.filename)) + else: + request = fr.FeatureRequest( + fr.FEATURE_VARIABLES, + self.filename, + self.args, + self.config, + start_date=self.args.start_date, + end_date=self.args.end_date) + + # initialise the download object + self.download_obj = fr.FeatureDownload(request, self.logger) + + # Download and extract data + df = self.download_obj.download() + + self.logger.info("Downloading for '{}' completed.".format(self.filename)) + + return self.filename + + def process(self): + """ + Carries out processing of the downloaded data. + :return: path to the output file generated by the algorithm + """ + self.logger.info("Initiating processing of SAFE Feature data.") + + if not os.path.isfile(self.filename): + raise FileNotFoundError("Unable to locate downloaded data '{}'.".format(self.filename)) + + # Downloading baseline precipitation + ## create era5 request object + request_baseline = erq.ERA5Request( + erq.PRECIP_VARIABLES, + 'precip', + self.args, + self.config, + start_date=self.config.baseline_start, + end_date=self.config.baseline_end, + frequency=erq.Freq.MONTHLY, + aws=self.config.aws) + + self.download_obj_baseline = erq.ERA5Download(request_baseline, self.logger) + + ## call download + self.download_obj_baseline.download() + self.logger.info("Downloading for ECMWF: '{}'".format(self.download_obj_baseline.download_file_path)) + + # Calculate SPI + ds = self.convert_precip_to_spi() + + # Trim to required dates so doesn't overlap with SAFE data + if int(self.args.start_date[0:6]) < 201912: + clip_date = '20191201' + else: + end_date = datetime.date(int(self.args.start_date[0:4]),int(self.args.start_date[4:6]),int(self.args.start_date[6:8])) - datetime.timedelta(days=31) + clip_date = end_date.strftime('%Y%m%d') + self.logger.info("Clipping ECMWF data from {} to {}".format(self.config.baseline_start,clip_date)) + ds = ds.sel(time=slice(pd.Timestamp(self.config.baseline_start), pd.Timestamp(clip_date))) + + # Load SAFE data + safe = load.LoadSAFE(logger=logging,infile=self.filename) + df_filtered = safe.load_safe(ds.to_dataframe().reset_index(), lat_val=self.args.latitude[0], lon_val=self.args.longitude[0]) + + # Generate output file + self.data_df = df_filtered + self.generate_output() + + self.logger.info("Completed processing of SAFE FEATURE data.") + + return df_filtered + + def convert_precip_to_spi(self) -> None: + """ + Calculates SPI precipitation drought index + :param input_file_path: path to file containing precipitation + :param output_file_path: path to file to be written containing SPI + :return: nothing + """ + + # Extract data from NetCDF file + ds = xr.open_dataset(self.download_obj_baseline.download_file_path) + + if 'expver' in ds.keys(): + ds = ds.sel(expver=1, drop=True) + + #self.logger.debug("Xarray:") + #self.logger.debug(ds) + + # Mask polygon if needed + if self.sstype.value == SSType.POLYGON.value: + ds = utils.mask_ds_poly( + ds=ds, + lats=self.args.latitude, + lons=self.args.longitude, + grid_x=0.1, + grid_y=0.1, + ds_lat_name='latitude', + ds_lon_name='longitude', + other=OUTSIDE_AREA_SELECTION, + mask_bbox=False + ) + + # Get total precipitation as data array + da = ds.tp + + # Set up SPI calculation algorithm + spi = indices.INDICES() + + # Convert to monthly sums and extract max of the available cells + if self.config.aws or self.config.era_daily: # or any other setting which would result in more than monthy data + da = da.resample(time='1MS').sum() + + if self.sstype.value == SSType.POINT.value: + da = da.max(['latitude', 'longitude']).load() + + # Calculate SPI from precip + spi_vals = spi.calc_spi(da) + + # Add back latitude and longitude as store ds + num_vals = len(da) + lat = np.repeat(self.args.latitude, num_vals) + lon = np.repeat(self.args.longitude, num_vals) + ds = xr.Dataset( + data_vars={'tp': da, 'spi': ("time", spi_vals), 'latitude': ("time", lat), 'longitude': ("time", lon)}) + # print("ds: ",ds) + + else: + spi_vals = xr.apply_ufunc(spi.calc_spi, da, input_core_dims=[['time']], output_core_dims=[['time']], + vectorize=True) + + # Store spi + ds = xr.Dataset(data_vars={'tp': da, 'spi': spi_vals}) + + self.logger.info("Input precipitation, {} values: {:.3f} {:.3f} ".format(len(da.values), np.nanmin(da.values), + np.nanmax(da.values))) + self.logger.info( + "SPI, {} values: {:.3f} {:.3f}".format(len(spi_vals), np.nanmin(spi_vals), np.nanmax(spi_vals))) + + return ds + +class SMA_ECMWF(DroughtIndex): + """ + Specialisation of the json base class for downloading and processing soil water data + """ + + def __init__(self, config: config.Config, args: config.AnalysisArgs): + """ + Initializer. Forwards parameters to super class, then instantiates download object. + :param args: argument object + :param working_dir: directory that will hold all files generated by the class + """ + + # Get variable details for requested products + vars = dict(filter( + lambda k: k[0] in ['swvl1', 'swvl2', 'swvl3', 'swvl4', 'zscore_swvl1', 'zscore_swvl2', 'zscore_swvl3', + 'zscore_swvl4'], ALL_VARS.items())) + + super().__init__(config, args, vars) + self.logger.debug("Initiated ERA5 daily processing of soil water.") + + # initialise download objects + # long-term 'baseline' object to compute the mean + request_baseline = erq.ERA5Request( + erq.SOILWATER_VARIABLES, + 'soilwater', + self.args, + self.config, + start_date=config.baseline_start, + end_date=config.baseline_end, + frequency=erq.Freq.MONTHLY) + + self.download_obj_baseline = erq.ERA5Download(request_baseline, self.logger) + + # create era5 request object for short term period + request_sample = erq.ERA5Request( + erq.SOILWATER_VARIABLES, + 'soilwater', + self.args, + self.config, + args.start_date, + args.end_date, + frequency=erq.Freq.DAILY if self.config.era_daily else erq.Freq.HOURLY) + + self.download_obj_sample = erq.ERA5Download(request_sample, self.logger) + + def download(self): + """ + Download requried data from ERA5 portal using the imported ERA5 request module. + Download long term monthly data for the long term mean, and separately hourly data for short term period. + """ + + def exists_or_download(erad: erq.ERA5Download): + if os.path.exists(erad.download_file_path): + self.logger.info("Downloaded file '{}' already exists.".format(erad.download_file_path)) + else: + downloaded_file = erad.download() + self.logger.info("Downloading for '{}' completed.".format(downloaded_file)) + + # download baseline and monthly data + exists_or_download(self.download_obj_baseline) + exists_or_download(self.download_obj_sample) + + return [self.download_obj_baseline.download_file_path, self.download_obj_sample.download_file_path] + + def process(self) -> str: + """ + Carries out processing of the downloaded data. This is the main functionality that is likely to differ between + each implementation. + :return: path to the output file generated by the algorithm + """ + self.logger.info("Initiating processing of ERA5 soil water data.") + + path_monthly = self.download_obj_baseline.download_file_path + path_sample = self.download_obj_sample.download_file_path if not os.path.isfile(path_monthly): raise FileNotFoundError("Unable to locate downloaded data '{}'.".format(path_monthly)) - + if not os.path.isfile(path_sample): raise FileNotFoundError("Unable to locate downloaded data '{}'.".format(path_sample)) @@ -1051,25 +1427,24 @@ def process(self) -> str: if 'expver' in monthly_swv.keys(): monthly_swv = monthly_swv.isel(expver=0).drop_vars('expver') - if self.sstype.value==SSType.POINT: - monthly_swv = monthly_swv.mean(('latitude','longitude')) - sample_swv = sample_swv.drop_vars(['lat','lon'] if self.config.era_daily else ['latitude','longitude']) + if self.sstype.value == SSType.POINT: + monthly_swv = monthly_swv.mean(('latitude', 'longitude')) + sample_swv = sample_swv.drop_vars(['lat', 'lon'] if self.config.era_daily else ['latitude', 'longitude']) swv_mean = monthly_swv.mean('time') swv_std = monthly_swv.std('time') # Resmple sample data to dekads swv_dekads = utils.ds_to_dekads(sample_swv) - + # Calculate zscores # Faster to just do this on all the data then remove the areas outside the polygon after - for layer in [1,2,3,4]: + for layer in [1, 2, 3, 4]: col = 'swvl' + str(layer) swv_dekads['zscore_' + col] = ((swv_dekads[col] - swv_mean[col]) / swv_std[col]) - # Mask polygon if needed - if self.sstype.value==SSType.POLYGON.value: + if self.sstype.value == SSType.POLYGON.value: swv_dekads = utils.mask_ds_poly( ds=swv_dekads, lats=self.args.latitude, @@ -1083,8 +1458,8 @@ def process(self) -> str: ) # fill any data gaps - time_dekads = utils.dti_dekads(self.args.start_date,self.args.end_date) - swv_dekads = swv_dekads.reindex({'time':time_dekads}) + time_dekads = utils.dti_dekads(self.args.start_date, self.args.end_date) + swv_dekads = swv_dekads.reindex({'time': time_dekads}) self.logger.info("Completed processing of ERA5 soil water data.") @@ -1099,8 +1474,9 @@ class SMA_GDO(GDODroughtIndex): """ Specialisation of the GDODrought class for processing pre-computed soil moisture anomaly from GDO. """ + def __init__(self, config: config.Config, args: config.AnalysisArgs): - super().__init__(config,args,['smant']) #['smant','smand'] + super().__init__(config, args, ['smant']) # ['smant','smand'] def process(self): self.logger.info('Loading and trimming data...') @@ -1117,42 +1493,55 @@ def process(self): # else: # da = ds.smant + # TODO reimplement if it is important to have data beyond 2022 + # # smand is used instead of smant for November 2022 (2nd dekad) onwards + # # split data, rename smand -> smant, and recombine + # if 'smand' in list(ds.variables): + # da_smant = utils.crop_ds(ds.smant,self.args.start_date,'20221110') + # da_smand = utils.crop_ds(ds.drop_vars('smant').rename({'smand':'smant'}).smant,'20221111',self.args.end_date) + # da = xr.concat([da_smant,da_smand],dim='time') + # self.vars.pop('smand') + # else: + # da = ds.smant + # Fill any data gaps self.logger.info('Filling gaps in data...') - time_dekads = utils.dti_dekads(self.args.start_date,self.args.end_date) + time_dekads = utils.dti_dekads(self.args.start_date, self.args.end_date) ds = ds.reindex({'time': time_dekads}) # Rename lat and lon coords for consitency with other drought indices - ds = ds.rename({'lat':'latitude','lon':'longitude'}) + ds = ds.rename({'lat': 'latitude', 'lon': 'longitude'}) self.data_ds = ds - + # Convert to df for output self.logger.info('Converting to dataframe...') df = ds.to_dataframe().reset_index() # Drop locations outside of selected area self.logger.info('Reducing to requested area...') - df = df[df.smant!=OUTSIDE_AREA_SELECTION] + df = df[df.smant != OUTSIDE_AREA_SELECTION] self.data_df = df return df + class FPAR_GDO(GDODroughtIndex): """ Specialisation of the GDODrought class for processing pre-computed photosynthetically active radiation anomaly data from GDO. """ + def __init__(self, config: config.Config, args: config.AnalysisArgs): - super().__init__(config,args,'fpanv') - + super().__init__(config, args, 'fpanv') + def process(self): ds = super().load_and_trim() # Fill any data gaps - time_dekads = utils.dti_dekads(self.args.start_date,self.args.end_date) + time_dekads = utils.dti_dekads(self.args.start_date, self.args.end_date) ds = ds.reindex({'time': time_dekads}) - + # Rename lat and lon coords for consitency with other drought indices - ds = ds.rename({'lat':'latitude','lon':'longitude'}) + ds = ds.rename({'lat': 'latitude', 'lon': 'longitude'}) self.data_ds = ds @@ -1160,26 +1549,29 @@ def process(self): df = ds.to_dataframe().reset_index() # Drop locations outside of selected area - df = df[df.fpanv!=OUTSIDE_AREA_SELECTION] + df = df[df.fpanv != OUTSIDE_AREA_SELECTION] self.data_df = df return df -class CDI(DroughtIndex): + # SPI: one month before + +class CDI(DroughtIndex): """ Extension of base class for combined drought indicator """ + def __init__( self, cfg: config.Config, args: config.CDIArgs - ): - + ): + # Get variable details for requested products - vars = dict(filter(lambda k: k[0] in [args.spi_var,args.sma_var,args.fpr_var,'CDI'], ALL_VARS.items())) - - super().__init__(cfg,args,vars) + vars = dict(filter(lambda k: k[0] in [args.spi_var, args.sma_var, args.fpr_var, 'CDI'], ALL_VARS.items())) + + super().__init__(cfg, args, vars) # Initialise all separate indicators to be combined sdate_ts = pd.Timestamp(args.start_date) @@ -1191,37 +1583,36 @@ def aa_new(required_sdate: pd.Timestamp) -> config.AnalysisArgs: """ # Makes sure start date is in dekads and the required format sdate = required_sdate.replace(day=utils.nearest_dekad(required_sdate.day)) - return config.AnalysisArgs(args.latitude,args.longitude,sdate.strftime('%Y%m%d'),args.end_date) - - # SPI: one month before + return config.AnalysisArgs(args.latitude, args.longitude, sdate.strftime('%Y%m%d'), args.end_date) + # SPI dates are always at the start of each month because it's the monthly average sdate_spi = sdate_ts.replace(day=1) - relativedelta(months=1) - spi_class = SPI_ECMWF if args.sma_source=='ECMWF' else SPI_GDO + spi_class = SPI_ECMWF if args.sma_source == 'ECMWF' else SPI_GDO self.aa_spi = aa_new(sdate_spi) - self.spi = spi_class(cfg,self.aa_spi) - + self.spi = spi_class(cfg, self.aa_spi) + # SMA: 2 dekads before sdate_sma = sdate_dk - relativedelta(days=20) - sma_class = SMA_ECMWF if args.sma_source=='ECMWF' else SMA_GDO + sma_class = SMA_ECMWF if args.sma_source == 'ECMWF' else SMA_GDO self.aa_sma = aa_new(sdate_sma) - self.sma = sma_class(cfg,self.aa_sma) - + self.sma = sma_class(cfg, self.aa_sma) + # fAPAR - 1 dekad before sdate_fpr = sdate_dk - relativedelta(days=10) self.aa_fpr = aa_new(sdate_fpr) - self.fpr = FPAR_GDO(cfg,self.aa_fpr) - + self.fpr = FPAR_GDO(cfg, self.aa_fpr) + # Initialise times # We want our final timeseries to include all data from the beginning of the SPI to the end of the CDI, so all data can be retained - self.time_dekads = utils.dti_dekads(sdate_spi,args.end_date) + self.time_dekads = utils.dti_dekads(sdate_spi, args.end_date) def download(self): spi_file = self.spi.download() sma_file = self.sma.download() fpr_file = self.fpr.download() - return[spi_file,sma_file,fpr_file] - + return [spi_file, sma_file, fpr_file] + def process(self): self.logger.info("Computing Combined Drought Indicator...") @@ -1242,25 +1633,24 @@ def process(self): # Interpolate SMA and FPR to same grid as CDI if not (self.sstype.value is SSType.POINT.value): - da_sma = utils.regrid_like(da_sma,da_spi) - da_fpr = utils.regrid_like(da_fpr,da_spi) + da_sma = utils.regrid_like(da_sma, da_spi) + da_fpr = utils.regrid_like(da_fpr, da_spi) da_sma = da_sma.reindex({'latitude': da_spi.latitude, 'longitude': da_spi.longitude}, method='nearest') da_fpr = da_fpr.reindex({'latitude': da_spi.latitude, 'longitude': da_spi.longitude}, method='nearest') - else: # For point data + else: # For point data - da_sma = da_sma.reindex({'latitude': self.spi.data_ds.latitude, 'longitude': self.spi.data_ds.longitude}, method='nearest') - da_fpr = da_fpr.reindex({'latitude': self.spi.data_ds.latitude, 'longitude': self.spi.data_ds.longitude}, method='nearest') + da_sma = da_sma.reindex({'latitude': self.spi.data_ds.latitude, 'longitude': self.spi.data_ds.longitude}, + method='nearest') + da_fpr = da_fpr.reindex({'latitude': self.spi.data_ds.latitude, 'longitude': self.spi.data_ds.longitude}, + method='nearest') # Remove duplicates da_sma = da_sma.drop_duplicates(dim=...) da_fpr = da_fpr.drop_duplicates(dim=...) - #self.logger.info("SPI: ",da_spi) - #self.logger.info("SMA: ",da_sma) - # drop values outside requested area if polygon if self.sstype.value is SSType.POLYGON.value: da_spi = da_spi.where(da_spi != OUTSIDE_AREA_SELECTION) @@ -1268,18 +1658,18 @@ def process(self): da_fpr = da_fpr.where(da_fpr != OUTSIDE_AREA_SELECTION) # Reindex to shared timeframe - spi_reindexed = da_spi.reindex({'time':self.time_dekads},method='ffill') - sma_reindexed = da_sma.reindex({'time':self.time_dekads}) - fpr_reindexed = da_fpr.reindex({'time':self.time_dekads}) + spi_reindexed = da_spi.reindex({'time': self.time_dekads}, method='ffill') + sma_reindexed = da_sma.reindex({'time': self.time_dekads}) + fpr_reindexed = da_fpr.reindex({'time': self.time_dekads}) + + self.ds_reindexed = xr.Dataset(data_vars={self.args.spi_var: spi_reindexed, + self.args.sma_var: sma_reindexed, + self.args.fpr_var: fpr_reindexed}) - self.ds_reindexed = xr.Dataset(data_vars = {self.args.spi_var: spi_reindexed, - self.args.sma_var: sma_reindexed, - self.args.fpr_var: fpr_reindexed}) - # Shift data to calculated CDI from delayed data - spi_shifted = spi_reindexed.shift({'time':3}) - sma_shifted = sma_reindexed.shift({'time':2}) - fpr_shifted = fpr_reindexed.shift({'time':1}) + spi_shifted = spi_reindexed.shift({'time': 3}) + sma_shifted = sma_reindexed.shift({'time': 2}) + fpr_shifted = fpr_reindexed.shift({'time': 1}) # Now create CDI with following levels: # 0: no warning @@ -1288,7 +1678,7 @@ def process(self): # 3: alert 1 = fpr < -1 and spi < -1 # 4: alert 2 = all < -1 - def calc_cdi(spi,sma,fpr): + def calc_cdi(spi, sma, fpr): spi_ = spi < -1 sma_ = sma < -1 fpr_ = fpr < -1 @@ -1301,9 +1691,11 @@ def calc_cdi(spi,sma,fpr): cdi[np.isnan(spi) | np.isnan(sma) | np.isnan(fpr)] = np.nan return cdi - cdi = xr.apply_ufunc(calc_cdi,spi_shifted,sma_shifted,fpr_shifted) + cdi = xr.apply_ufunc(calc_cdi, spi_shifted, sma_shifted, fpr_shifted) - self.ds_shifted = xr.Dataset(data_vars={self.args.spi_var: spi_shifted, self.args.sma_var: sma_shifted, self.args.fpr_var: fpr_shifted, 'CDI': cdi}) + self.ds_shifted = xr.Dataset( + data_vars={self.args.spi_var: spi_shifted, self.args.sma_var: sma_shifted, self.args.fpr_var: fpr_shifted, + 'CDI': cdi}) self.data_ds = self.ds_reindexed.assign(CDI=cdi) self.data_df = self.data_ds.to_dataframe().reset_index() @@ -1311,4 +1703,327 @@ def calc_cdi(spi,sma,fpr): self.logger.info("Completed processing of ERA5 CDI data.") return self.data_df - + + +class UTCI(DroughtIndex): + + def __init__(self, config: config.Config, args: config.AnalysisArgs): + """ + Initializer + :param args: program arguments + :param working_dir: directory that will hold all files generated by the class + """ + # Get variable details for requested products + vars = dict(filter(lambda k: k[0] in ['utci'], ALL_VARS.items())) + + # precipitation download must return a baseline time series because this is a requirement of the outsourced spi calculation algorithm + super().__init__(config, args, vars) + + # create era5 request object + request = erq.ERA5Request( + erq.PRECIP_VARIABLES, + 'precip', + self.args, + self.config, + start_date=config.baseline_start, + end_date=config.baseline_end, + frequency=erq.Freq.DAILY if self.config.era_daily else erq.Freq.MONTHLY, + aws=self.config.aws) + + # initialise the download object using the request, but don't download yet + self.download_obj = erq.ERA5Download(request, self.logger) + + # setup download for UTCI + ## create UTCI request object for pre-calculated values + request = erq.ERA5Request( + ['UTCI'], + 'utci', + self.args, + self.config, + start_date=args.start_date, + end_date=args.end_date, + frequency=erq.Freq.DAILY, + aws=self.config.aws) + + # initialise the download object using the request, but don't download yet + self.download_obj_utci = erq.ERA5Download(request, self.logger) + + # if UTCI download fails, backup is to download ERA5 data and calculate + + # create UTCI request object for daily download + request = erq.ERA5Request( + erq.UTCI_VARIABLES, + 'multi', + self.args, + self.config, + start_date=args.start_date, + end_date=args.end_date, + frequency=erq.Freq.HOURLY, + aws=self.config.aws) + + # create UTCI request object for monthly download + ## Always download daily, monthly kept for testing + request_monthly = erq.ERA5Request( + erq.UTCI_VARIABLES, + 'multi', + self.args, + self.config, + start_date=config.baseline_start, + end_date=config.baseline_end, + frequency=erq.Freq.MONTHLY, + aws=self.config.aws) + + # initialise the backup download object using the request, but don't download yet + self.download_obj_utci_backup = erq.ERA5Download(request, self.logger) + + def download(self): + """ + Download required data from ERA5 portal using the imported ERA5 request module. + The processing part of the SPI calculation requires that the long term dataset is passed in at the same time as the short term analysis period therefore we must request the whole baseline period for this analysis. + :output: list containing name of single generated netcdf file. Must be a list as other indices will return the paths to multiple netcdfs for baseline and short-term timespans. + """ + + if os.path.exists(self.download_obj.download_file_path): + self.logger.info("Downloaded file '{}' already exists.".format(self.download_obj.download_file_path)) + else: + downloaded_file = self.download_obj.download() + self.logger.info("Downloading for '{}' completed.".format(downloaded_file)) + + return [self.download_obj.download_file_path] + + def convert_precip_to_spi(self) -> None: + """ + Calculates SPI precipitation drought index + :param input_file_path: path to file containing precipitation + :param output_file_path: path to file to be written containing SPI + :return: nothing + """ + + # Extract data from NetCDF file + ds = xr.open_dataset(self.download_obj.download_file_path) + # if 'expver' in ds.keys(): + # ds = ds.sel(expver=1,drop=True) + + self.logger.debug("Precip xarray:") + self.logger.debug(ds) + + # Mask polygon if needed + if self.sstype.value == SSType.POLYGON.value: + ds = utils.mask_ds_poly( + ds=ds, + lats=self.args.latitude, + lons=self.args.longitude, + grid_x=0.1, + grid_y=0.1, + ds_lat_name='latitude', + ds_lon_name='longitude', + other=OUTSIDE_AREA_SELECTION, + mask_bbox=False + ) + + # Get total precipitation as data array + da = ds.tp + + # Set up SPI calculation algorithm + spi = indices.INDICES() + + # Convert to monthly sums and extract max of the available cells + if self.config.aws or self.config.era_daily: # or any other setting which would result in more than monthly data + print(da) + da = da.resample(time='1MS').sum() + + if self.sstype.value == SSType.POINT.value: + da = da.max(['latitude', 'longitude']).load() + + # Calculate SPI from precip + spi_vals = spi.calc_spi(da) + + # Add back latitude and longitude as store ds + num_vals = len(da) + lat = np.repeat(self.args.latitude, num_vals) + lon = np.repeat(self.args.longitude, num_vals) + ds = xr.Dataset(data_vars={'tp': da, 'spi': ("time", spi_vals)}) + ds = ds.assign_coords({"longitude": lon}) \ + .assign_coords({"latitude": lat}) + + # print("ECMWF ds: ",ds) + + else: + spi_vals = xr.apply_ufunc(spi.calc_spi, da, input_core_dims=[['time']], output_core_dims=[['time']], + vectorize=True) + + # Store spi + ds = xr.Dataset(data_vars={'tp': da, 'spi': spi_vals}) + + self.logger.info("Input precipitation, {} values: {:.3f} {:.3f} ".format(len(da.values), np.nanmin(da.values), + np.nanmax(da.values))) + self.logger.info( + "SPI, {} values: {:.3f} {:.3f}".format(len(spi_vals), np.nanmin(spi_vals), np.nanmax(spi_vals))) + + return ds + + def process(self): + """ + Carries out processing of the downloaded data. This is the main functionality that is likely to differ between + each implementation. + :return: path to the output file generated by the algorithm + """ + if self.config.era_daily: + self.logger.info("Initiating processing of ERA5 & UTCI daily data.") + else: + self.logger.info("Initiating processing of ERA5 & UTCI monthly data.") + + if not os.path.isfile(self.download_obj.download_file_path): + raise FileNotFoundError( + "Unable to locate downloaded data '{}'.".format(self.spi_download.download_file_path)) + + # Calculates SPI precipitation drought index + ds = self.convert_precip_to_spi() + + # Check for UTCI data, if not available then download + if not os.path.isfile(self.download_obj_utci.download_file_path): + file_path = self.download_obj_utci.download() + else: + file_path = self.download_obj_utci.download_file_path + if file_path: + print("UTCI file {} exists".format(self.download_obj_utci.download_file_path)) + # Load data + ds_utci = xr.open_dataset(self.download_obj_utci.download_file_path) + + else: + file_path = self.download_obj_utci_backup.download() + if file_path: + print("UTCI input file {} exists".format(self.download_obj_utci_backup.download_file_path)) + # Load data + ds_utci = xr.open_dataset(self.download_obj_utci_backup.download_file_path) + + else: + raise RuntimeError("Unable to downloaded data needed for UTCI.") + + ## change lat & lon to coordinates + coords = [i for i in ds_utci.coords] + print(ds_utci) + if any("latitude" in var for var in coords): + ds_utci = ds_utci.set_coords(["latitude", "longitude"]) + else: + ds_utci = ds_utci.rename(name_dict={'lat': 'latitude','lon': 'longitude'}) + + # Check if contains utci, else calculate + variables = [i for i in ds_utci.data_vars] + if not any("utci" in var for var in variables): + print("Calculating UTCI using: {}".format(variables)) + ## calculate relative humidity + ds_utci['hurs'] = relative_humidity_from_dewpoint(ds_utci.t2m, ds_utci.d2m) + print("Humidity: {:.3f} {:.3f} {}".format(np.nanmin(ds_utci.hurs), np.nanmax(ds_utci.hurs), ds_utci.hurs.attrs["units"])) + ## calculate windspeed + ds_utci['sfcWind'], ds_utci['sfcWindDir'] = uas_vas_2_sfcwind(ds_utci.u10, ds_utci.v10) + print("Wind: {:.3f} {:.3f} {}".format(np.nanmin(ds_utci.sfcWind), np.nanmax(ds_utci.sfcWind), ds_utci.sfcWind.attrs["units"])) + ## calculate upwelling radiance + print("Downwelling Radiance, SW: {:.3f} {:.3f} LW: {:.3f} {:.3f} {}".format(np.nanmin(ds_utci.msdwswrf), np.nanmax(ds_utci.msdwswrf),np.nanmin(ds_utci.msdwlwrf), np.nanmax(ds_utci.msdwlwrf), ds_utci.msdwswrf.attrs["units"])) + ds_utci['rsus'] = ds_utci.msdwswrf - ds_utci.msnswrf + ds_utci['rlus'] = ds_utci.msdwlwrf - ds_utci.msnlwrf + ds_utci.rsus.attrs["units"] = 'W m**-2' + ds_utci.rlus.attrs["units"] = 'W m**-2' + print("Upwelling Radiance, SW: {:.3f} {:.3f} LW: {:.3f} {:.3f} {}".format(np.nanmin(ds_utci.rsus), np.nanmax(ds_utci.rsus),np.nanmin(ds_utci.rlus), np.nanmax(ds_utci.rlus), ds_utci.rsus.attrs["units"])) + + ## add latitude & longitude units + ds_utci.latitude.attrs["units"] = 'degrees_north' + ds_utci.longitude.attrs["units"] = 'degrees_east' + print("Latitude: {:.3f} {:.3f} {}".format(np.nanmin(ds_utci.latitude), np.nanmax(ds_utci.latitude), ds_utci.latitude.attrs["units"])) + + ## reorder time so increasing + ds_utci = ds_utci.sortby('time') + + ## calculate mean radiant temperature + ds_utci['mrt'] = mean_radiant_temperature(ds_utci.msdwswrf, ds_utci.rsus, ds_utci.msdwlwrf, ds_utci.rlus, stat='sunlit') + print("MRT: {:.3f} {:.3f} {}".format(np.nanmin(ds_utci.mrt), np.nanmax(ds_utci.mrt), ds_utci.mrt.attrs["units"])) + ## calculate utci + ds_utci['utci'] = universal_thermal_climate_index(tas=ds_utci.t2m, hurs=ds_utci.hurs, sfcWind=ds_utci.sfcWind, mrt=ds_utci.mrt, mask_invalid=True) + print("UTCI: {:.3f} {:.3f} {}".format(np.nanmin(ds_utci.utci), np.nanmax(ds_utci.utci), ds_utci.utci.attrs["units"])) + + # Resample to daily if downloaded as hourly data + if 'hourly' in self.download_obj_utci_backup.download_file_path: + ds_utci = ds_utci.resample(time="1D").max()#mean() + + # Resample to monthly data if needed + if not self.config.era_daily: + ds_utci = ds_utci.resample(time="MS").mean()#max() + + # Merge MRT & UTCI into SPI & convert MRT to degC + if any("mrt" in var for var in variables): + mrt = ds_utci.mrt - 272.15 + mrt_vals = mrt.values + + if np.nanmax(ds_utci.utci) > 100: + # Extract UTCI & converted to degC + utci = ds_utci.utci - 272.15 + else: + # Extract UTCI + utci = ds_utci.utci + utci_vals = utci.values + times = ds_utci.time.values + if utci_vals.ndim == 1: + if any("mrt" in var for var in variables): + ds['mrt'] = xr.DataArray(mrt_vals, coords={'time': times}, dims=['time']) + ds['utci'] = xr.DataArray(utci_vals, coords={'time': times}, dims=['time']) + else: + if any("mrt" in var for var in variables): + ds['mrt'] = xr.DataArray(mrt_vals[:, 0, 0], coords={'time': times}, dims=['time']) + ds['utci'] = xr.DataArray(utci_vals[:, 0, 0], coords={'time': times}, dims=['time']) + + # Drop field that aren't needed + if 'expver' in ds.keys(): + ds = ds.drop_vars('expver') + if 'number' in ds.keys(): + ds = ds.drop_vars('number') + + # Select requested time slice + ds_filtered = utils.crop_ds(ds, self.args.start_date, self.args.end_date) + print("UTCI merged: ", ds_filtered) + + # Calculate Health Index + utci_vals = np.array(ds_filtered.utci.values) + spi_vals = np.array(ds_filtered.spi.values) + health = utci_vals.copy() + health[utci_vals < 9] = -1 + health[utci_vals < 0] = -2 + health[utci_vals < -13] = -3 + health[utci_vals < -27] = -4 + health[utci_vals < -40] = -5 + health[utci_vals >= 9] = 0 + health[utci_vals > 26] = 1 + health[utci_vals > 32] = 2 + health[utci_vals > 38] = 3 + health[utci_vals > 46] = 4 + + # Calc SPI impact, then add to array + spi = utci_vals.copy() + spi[spi_vals <= -1] = 1 + spi[spi_vals < -1.5] = 2 + spi[spi_vals < -2] = 3 + spi[spi_vals > -1] = 0 + spi[spi_vals > 1] = -1 + spi[spi_vals > 1.5] = -2 + spi[spi_vals > 2] = -3 + # Add together then add to array + health += health + spi + times = ds_filtered.time.values + if utci_vals.ndim == 1: + ds_filtered['hindex'] = xr.DataArray(health, coords={'time': times}, dims=['time']) + else: + ds_filtered['hindex'] = xr.DataArray(health[:, 0, 0], coords={'time': times}, dims=['time']) + print("Health index: {:.3f} {:.3f}".format(np.nanmin(ds_filtered.hindex), np.nanmax(ds_filtered.hindex))) + + # Fill any missing gaps + time_months = pd.date_range(self.args.start_date, self.args.end_date, freq='1MS') + ds_reindexed = ds_filtered.reindex({'time': time_months}) + + df_reindexed = ds_reindexed.to_dataframe().reset_index() + + # store processed data on object + self.data_ds = ds_reindexed + self.data_df = df_reindexed + + self.generate_output() + + return df_reindexed diff --git a/climate_drought/era5_request.py b/climate_drought/era5_request.py index 4b1e77a..4e2ae47 100644 --- a/climate_drought/era5_request.py +++ b/climate_drought/era5_request.py @@ -9,9 +9,10 @@ from climate_drought import utils, config # ERA download from pixutils import era_download -# AWS ERA5 data access -from kerchunk.hdf import SingleHdf5ToZarr -from kerchunk.combine import MultiZarrToZarr +# AWS ERA5 data access - changed as casuing issues when reading NetCDFs +#from kerchunk.hdf import SingleHdf5ToZarr +#from kerchunk.combine import MultiZarrToZarr +import kerchunk import dask from dask.distributed import Client import fsspec @@ -29,24 +30,32 @@ PRECIP_VARIABLES = ['total_precipitation'] SOILWATER_VARIABLES = ["volumetric_soil_water_layer_1", "volumetric_soil_water_layer_2", "volumetric_soil_water_layer_3", "volumetric_soil_water_layer_4"] +UTCI_VARIABLES = ['2m_dewpoint_temperature', + '2m_temperature', + '10m_u_component_of_wind', '10m_v_component_of_wind', + 'mean_surface_downward_long_wave_radiation_flux', 'mean_surface_downward_short_wave_radiation_flux', + 'mean_surface_net_long_wave_radiation_flux', + 'mean_surface_net_short_wave_radiation_flux'] AWSKEY = os.path.join(expanduser('~'), '.aws_api_key') AWS_PRECIP_VARIABLE = ['precipitation_amount_1hour_Accumulation'] + class Freq(Enum): MONTHLY = 'monthly' DAILY = 'daily' HOURLY = 'hourly' + class ERA5Request(): """ Object to constrain ERA5 download inputs. Built inputs using analysis and config arguments. """ + def __init__(self, variables, fname_out, args: config.AnalysisArgs, config: config.Config, start_date, end_date, frequency: Freq, aws=False): - - bbox = len(args.longitude)>1 + bbox = len(args.longitude) > 1 self.minlat = np.min(args.latitude) if bbox else float(args.latitude[0]) - BOX_SIZE self.minlon = np.min(args.longitude) if bbox else float(args.longitude[0]) - BOX_SIZE @@ -64,6 +73,7 @@ def __init__(self, variables, fname_out, args: config.AnalysisArgs, config: conf self.frequency = frequency self.aws = aws + class ERA5Download(): """ Provides some basic functionality that can be used by different implementation specific strategies for different @@ -102,7 +112,7 @@ def download_file_path(self): la=latstr, lo=lonstr, fq=self.req.frequency.value) - + # Extra identifier for AWS downloaded ERA5 data if not self.req.aws: aws = '' @@ -120,20 +130,25 @@ def download(self) -> str: self.logger.info("Initiating download of ERA5 data.") self.logger.info("Variables to be downloaded: {}.".format(", ".join(self.req.variables))) - area_box = [round(self.req.maxlat,2), - round(self.req.minlon,2), - round(self.req.minlat,2), - round(self.req.maxlon,2) - ] + area_box = [round(self.req.maxlat, 2), + round(self.req.minlon, 2), + round(self.req.minlat, 2), + round(self.req.maxlon, 2) + ] - if self.req.frequency==Freq.HOURLY: + if self.req.frequency == Freq.HOURLY: times = [] for i in range(24): times.append(time(hour=i, minute=0)) else: times = [self.SAMPLE_TIME] - if self.req.aws and self.req.frequency==Freq.MONTHLY and 'precip' in self.req.variables[0]: + if any('UTCI' in var for var in self.req.variables): + self._download_utci_data(dates=self.dates, + area=area_box, + out_file=self.download_file_path) + + elif self.req.aws and self.req.frequency == Freq.MONTHLY and 'precip' in self.req.variables[0]: self._download_aws_data(area=area_box, out_file=self.download_file_path) else: @@ -145,9 +160,12 @@ def download(self) -> str: out_file=self.download_file_path) if os.path.isfile(self.download_file_path): - self.logger.info("ERA5 data was downloaded to '{}'.".format(self.download_file_path)) + self.logger.info("C3S data was downloaded to '{}'.".format(self.download_file_path)) else: - raise FileNotFoundError("ERA5 download file '{}' was missing.".format(self.download_file_path)) + if any('UTCI' in var for var in self.req.variables): + return False + else: + raise FileNotFoundError("C3S download file '{}' was missing.".format(self.download_file_path)) return self.download_file_path @@ -168,7 +186,8 @@ def _download_era5_data(self, variables: List[str], dates: List[date], times: Li if not os.path.exists(out_file): - self.logger.info("Downloading {} ERA data for {} {} for {}".format(frequency.value, dates[0], dates[-1], area)) + self.logger.info( + "Downloading {} ERA data for {} {} for {}".format(frequency.value, dates[0], dates[-1], area)) result = era_download.download_era5_reanalysis_data(dates=dates, times=times, variables=variables, area=str(area), frequency=frequency.value, @@ -205,8 +224,7 @@ def _download_aws_data(self, area: List[float], out_file: str) -> bool: # Get list of AWS files fs = fsspec.filesystem('s3', anon=True) sdate = int(self.req.start_date[0:4]) - # TODO SL Can we fix for later dates? - edate = int(self.req.end_date[0:4])+1 #2020 + 1 # + edate = int(self.req.end_date[0:4]) + 1 years = list(np.arange(sdate, edate, 1)) self.logger.warning("AWS range restricted to {} to 2020 as the files after cause issues".format(sdate)) months = list(np.arange(1, 12 + 1, 1)) @@ -249,7 +267,7 @@ def gen_json(u): jfile = os.path.join(jdir, "{}-{}-aws-precip.json".format(yr, mnth)) if not os.path.exists(jfile): with fsspec.open(u, **so) as inf: - h5chunks = SingleHdf5ToZarr(inf, u, inline_threshold=300) + h5chunks = kerchunk.hdf.SingleHdf5ToZarr(inf, u, inline_threshold=300) with fs2.open(jfile, 'wb') as outf: outf.write(ujson.dumps(h5chunks.translate()).encode()) @@ -283,8 +301,8 @@ def postprocess(out): jlist.sort() # Sort into numerical order jlen = len(jlist) self.logger.debug("Generated {} JSON files {} to {}".format(jlen, os.path.basename(jlist[0]), - os.path.basename(jlist[-1]))) - mzz = MultiZarrToZarr( + os.path.basename(jlist[-1]))) + mzz = kerchunk.combine.MultiZarrToZarr( jlist, remote_protocol="s3", remote_options={'anon': True}, @@ -303,7 +321,7 @@ def postprocess(out): # Make combined JSON file ## Concatenate along a specified dimension (concat_dims) ## Specifying identical coordinates (identical_dims) is not strictly necessary but will speed up computation times. - mzz = MultiZarrToZarr( + mzz = kerchunk.combine.MultiZarrToZarr( year_jlist, remote_protocol="s3", remote_options={'anon': True}, @@ -342,7 +360,8 @@ def postprocess(out): ds_subset = ds.where(mask_lon & mask_lat, drop=True) # Rename variable names - ds_subset = ds_subset.rename({'lon': 'longitude', 'lat': 'latitude', AWS_PRECIP_VARIABLE[0]: 'tp', 'time1': 'time'}) + ds_subset = ds_subset.rename( + {'lon': 'longitude', 'lat': 'latitude', AWS_PRECIP_VARIABLE[0]: 'tp', 'time1': 'time'}) self.logger.debug(ds_subset) # Write to NetCDF @@ -359,4 +378,33 @@ def postprocess(out): if not os.path.isfile(out_file): raise FileNotFoundError("Output file '{}' could not be located.".format(out_file)) - return outfile_exists \ No newline at end of file + return outfile_exists + + def _download_utci_data(self, dates: List[date], area: List[float], out_file: bool) -> bool: + + """ + Executes the ERA5 download script in a separate process. + :param dates: a list of dates to download data for + :param area: area of interest box to download data for + :param out_file: output_file_path: path to the output file containing the requested fields. Supported output format is NetCDF, determined by file extension. + :return: boolean status + """ + outfile_exists = False + + if not os.path.exists(out_file): + + self.logger.info("Downloading UTCI data for {} {} for {}".format(dates[0], dates[-1], area)) + result = era_download.download_utci_data(dates=dates, area=str(area), + file_path=os.path.expanduser(out_file)) + + if result == 0: + raise RuntimeError("Download process returned unexpected non-zero exit code '{}'.".format(result)) + + else: + self.logger.info("Download file '{}' already exists.".format(out_file)) + outfile_exists = True + + if not os.path.isfile(out_file): + print("UTCI output file '{}' could not be located.".format(out_file)) + + return outfile_exists diff --git a/climate_drought/utils.py b/climate_drought/utils.py index 4eb0d1b..a100344 100644 --- a/climate_drought/utils.py +++ b/climate_drought/utils.py @@ -222,7 +222,7 @@ class setup_args: plot=False type='none' start_date = '20200101' - end_date ='20221231' + end_date = '20231231' aws = False oformat = "GeoJSON" sma_source = "GDO" diff --git a/edo_read.ipynb b/edo_read.ipynb deleted file mode 100644 index be1d122..0000000 --- a/edo_read.ipynb +++ /dev/null @@ -1,1096 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# ensure classes imported from .py files are dynamically updated\n", - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", - "# plot matplots nicely\n", - "%matplotlib inline " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "import xarray as xr\n", - "import numpy as np\n", - "import pandas as pd\n", - "from climate_drought import utils" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "23" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import glob\n", - "#flist=glob.glob('input/spg03/spg03*.nc')\n", - "flist=glob.glob('input/smant/sma*.nc')\n", - "#flist = glob.glob('input/fpanv/f*.nc')\n", - "len(flist)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:  (time: 8, lat: 1800, lon: 3600)\n",
-       "Coordinates:\n",
-       "  * lat      (lat) float64 -89.95 -89.85 -89.75 -89.65 ... 89.75 89.85 89.95\n",
-       "  * lon      (lon) float64 -179.9 -179.8 -179.8 -179.7 ... 179.8 179.8 179.9\n",
-       "  * time     (time) datetime64[ns] 2023-01-01 2023-01-11 ... 2023-03-11\n",
-       "Data variables:\n",
-       "    smand    (time, lat, lon) float32 ...\n",
-       "    4326     float32 ...\n",
-       "Attributes: (12/28)\n",
-       "    Source_Software:            dbinterface.py, dbexport.py, netcdf_handling.py\n",
-       "    creator_name:               Carolina Arias Munoz\n",
-       "    Conventions:                CF-1.6\n",
-       "    _CoordSysBuilder:           ucar.nc2.dataset.conv.CF1Convention\n",
-       "    date_created:               2023-04-03\n",
-       "    01.title:                   Ensemble Soil Moisture Anomaly (2M, Lisflood+...\n",
-       "    ...                         ...\n",
-       "    18.factsheet_url:           https://edo.jrc.ec.europa.eu/documents/factsh...\n",
-       "    19.jrc_data_catalogue_url:  http://data.europa.eu/89h/f4af9315-9581-4403-...\n",
-       "    20.sample_url:              /images/map_examples/dbio_data_previews/smant...\n",
-       "    21.metadata_last_updated:   2023-02-09\n",
-       "    22.values_legend:           [Less than or equal to -2, -2 to -1.5, -1.5 t...\n",
-       "    23.version_notes:           Current version: Version 3.0.1 covers data fr...
" - ], - "text/plain": [ - "\n", - "Dimensions: (time: 8, lat: 1800, lon: 3600)\n", - "Coordinates:\n", - " * lat (lat) float64 -89.95 -89.85 -89.75 -89.65 ... 89.75 89.85 89.95\n", - " * lon (lon) float64 -179.9 -179.8 -179.8 -179.7 ... 179.8 179.8 179.9\n", - " * time (time) datetime64[ns] 2023-01-01 2023-01-11 ... 2023-03-11\n", - "Data variables:\n", - " smand (time, lat, lon) float32 ...\n", - " 4326 float32 ...\n", - "Attributes: (12/28)\n", - " Source_Software: dbinterface.py, dbexport.py, netcdf_handling.py\n", - " creator_name: Carolina Arias Munoz\n", - " Conventions: CF-1.6\n", - " _CoordSysBuilder: ucar.nc2.dataset.conv.CF1Convention\n", - " date_created: 2023-04-03\n", - " 01.title: Ensemble Soil Moisture Anomaly (2M, Lisflood+...\n", - " ... ...\n", - " 18.factsheet_url: https://edo.jrc.ec.europa.eu/documents/factsh...\n", - " 19.jrc_data_catalogue_url: http://data.europa.eu/89h/f4af9315-9581-4403-...\n", - " 20.sample_url: /images/map_examples/dbio_data_previews/smant...\n", - " 21.metadata_last_updated: 2023-02-09\n", - " 22.values_legend: [Less than or equal to -2, -2 to -1.5, -1.5 t...\n", - " 23.version_notes: Current version: Version 3.0.1 covers data fr..." - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "xr.open_dataset(flist[0])" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "dses = [xr.open_dataset(fname).sel(lat=62,lon=-100,method='nearest').drop_vars(['lat','lon','4326']) for fname in flist]" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "df = xr.merge(dses).to_dataframe()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df[(df.index > pd.Timestamp(2016,4,16)) & (df.index < pd.Timestamp(2022,12,31))].smant.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "sdate = '20200101'\n", - "edate = '20230101'\n", - "daterange = utils.daterange(sdate,edate,rtv=False)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def fill_gaps(sdate,edate,df):\n", - " dti = pd.date_range(sdate,edate,freq='1D')\n", - " dti_dekads = utils.dti_to_dekads(dti)\n", - " gaps = dti_dekads[~dti_dekads.isin(df.index)]\n", - " if len(gaps) > 0:\n", - " df_gaps = pd.DataFrame(index=gaps)\n", - " return pd.concat([df,df_gaps])\n", - " else:\n", - " return df" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "dti = pd.date_range(sdate,edate,freq='1D')" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "dti_dekads = utils.dti_to_dekads(dti)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "DatetimeIndex(['2020-01-01', '2020-01-11', '2020-01-21', '2020-02-01',\n", - " '2020-02-11', '2020-02-21', '2020-03-01', '2020-03-11',\n", - " '2020-03-21', '2020-04-01',\n", - " ...\n", - " '2022-10-01', '2022-10-11', '2022-10-21', '2022-11-01',\n", - " '2022-11-11', '2022-11-21', '2022-12-01', '2022-12-11',\n", - " '2022-12-21', '2023-01-01'],\n", - " dtype='datetime64[ns]', length=109, freq=None)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dti_dekads" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "gaps = dti_dekads[~dti_dekads.isin(df.index)]" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "df_gaps = pd.DataFrame(index=gaps)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
smandsmant
2001-01-01NaN1.25
2001-01-11NaN1.02
2001-01-21NaN0.67
2001-02-01NaN0.35
2001-02-11NaN0.41
.........
2022-11-11NaNNaN
2022-11-21NaNNaN
2022-12-01NaNNaN
2022-12-11NaNNaN
2022-12-21NaNNaN
\n", - "

800 rows × 2 columns

\n", - "
" - ], - "text/plain": [ - " smand smant\n", - "2001-01-01 NaN 1.25\n", - "2001-01-11 NaN 1.02\n", - "2001-01-21 NaN 0.67\n", - "2001-02-01 NaN 0.35\n", - "2001-02-11 NaN 0.41\n", - "... ... ...\n", - "2022-11-11 NaN NaN\n", - "2022-11-21 NaN NaN\n", - "2022-12-01 NaN NaN\n", - "2022-12-11 NaN NaN\n", - "2022-12-21 NaN NaN\n", - "\n", - "[800 rows x 2 columns]" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pd.concat([df,df_gaps])" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [], - "source": [ - "d = dti.day - np.clip((dti.day-1) // 10, 0, 2)*10 - 1\n", - "date = dti.values - np.array(d, dtype=\"timedelta64[D]\")" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array(['2020-01-01T00:00:00.000000000', '2020-01-11T00:00:00.000000000',\n", - " '2020-01-21T00:00:00.000000000', '2020-02-01T00:00:00.000000000',\n", - " '2020-02-11T00:00:00.000000000', '2020-02-21T00:00:00.000000000',\n", - " '2020-03-01T00:00:00.000000000', '2020-03-11T00:00:00.000000000',\n", - " '2020-03-21T00:00:00.000000000', '2020-04-01T00:00:00.000000000',\n", - " '2020-04-11T00:00:00.000000000', '2020-04-21T00:00:00.000000000',\n", - " '2020-05-01T00:00:00.000000000', '2020-05-11T00:00:00.000000000',\n", - " '2020-05-21T00:00:00.000000000', '2020-06-01T00:00:00.000000000',\n", - " '2020-06-11T00:00:00.000000000', '2020-06-21T00:00:00.000000000',\n", - " '2020-07-01T00:00:00.000000000', '2020-07-11T00:00:00.000000000',\n", - " '2020-07-21T00:00:00.000000000', '2020-08-01T00:00:00.000000000',\n", - " '2020-08-11T00:00:00.000000000', '2020-08-21T00:00:00.000000000',\n", - " '2020-09-01T00:00:00.000000000', '2020-09-11T00:00:00.000000000',\n", - " '2020-09-21T00:00:00.000000000', '2020-10-01T00:00:00.000000000',\n", - " '2020-10-11T00:00:00.000000000', '2020-10-21T00:00:00.000000000',\n", - " '2020-11-01T00:00:00.000000000', '2020-11-11T00:00:00.000000000',\n", - " '2020-11-21T00:00:00.000000000', '2020-12-01T00:00:00.000000000',\n", - " '2020-12-11T00:00:00.000000000', '2020-12-21T00:00:00.000000000',\n", - " '2021-01-01T00:00:00.000000000', '2021-01-11T00:00:00.000000000',\n", - " '2021-01-21T00:00:00.000000000', '2021-02-01T00:00:00.000000000',\n", - " '2021-02-11T00:00:00.000000000', '2021-02-21T00:00:00.000000000',\n", - " '2021-03-01T00:00:00.000000000', '2021-03-11T00:00:00.000000000',\n", - " '2021-03-21T00:00:00.000000000', '2021-04-01T00:00:00.000000000',\n", - " '2021-04-11T00:00:00.000000000', '2021-04-21T00:00:00.000000000',\n", - " '2021-05-01T00:00:00.000000000', '2021-05-11T00:00:00.000000000',\n", - " '2021-05-21T00:00:00.000000000', '2021-06-01T00:00:00.000000000',\n", - " '2021-06-11T00:00:00.000000000', '2021-06-21T00:00:00.000000000',\n", - " '2021-07-01T00:00:00.000000000', '2021-07-11T00:00:00.000000000',\n", - " '2021-07-21T00:00:00.000000000', '2021-08-01T00:00:00.000000000',\n", - " '2021-08-11T00:00:00.000000000', '2021-08-21T00:00:00.000000000',\n", - " '2021-09-01T00:00:00.000000000', '2021-09-11T00:00:00.000000000',\n", - " '2021-09-21T00:00:00.000000000', '2021-10-01T00:00:00.000000000',\n", - " '2021-10-11T00:00:00.000000000', '2021-10-21T00:00:00.000000000',\n", - " '2021-11-01T00:00:00.000000000', '2021-11-11T00:00:00.000000000',\n", - " '2021-11-21T00:00:00.000000000', '2021-12-01T00:00:00.000000000',\n", - " '2021-12-11T00:00:00.000000000', '2021-12-21T00:00:00.000000000',\n", - " '2022-01-01T00:00:00.000000000', '2022-01-11T00:00:00.000000000',\n", - " '2022-01-21T00:00:00.000000000', '2022-02-01T00:00:00.000000000',\n", - " '2022-02-11T00:00:00.000000000', '2022-02-21T00:00:00.000000000',\n", - " '2022-03-01T00:00:00.000000000', '2022-03-11T00:00:00.000000000',\n", - " '2022-03-21T00:00:00.000000000', '2022-04-01T00:00:00.000000000',\n", - " '2022-04-11T00:00:00.000000000', '2022-04-21T00:00:00.000000000',\n", - " '2022-05-01T00:00:00.000000000', '2022-05-11T00:00:00.000000000',\n", - " '2022-05-21T00:00:00.000000000', '2022-06-01T00:00:00.000000000',\n", - " '2022-06-11T00:00:00.000000000', '2022-06-21T00:00:00.000000000',\n", - " '2022-07-01T00:00:00.000000000', '2022-07-11T00:00:00.000000000',\n", - " '2022-07-21T00:00:00.000000000', '2022-08-01T00:00:00.000000000',\n", - " '2022-08-11T00:00:00.000000000', '2022-08-21T00:00:00.000000000',\n", - " '2022-09-01T00:00:00.000000000', '2022-09-11T00:00:00.000000000',\n", - " '2022-09-21T00:00:00.000000000', '2022-10-01T00:00:00.000000000',\n", - " '2022-10-11T00:00:00.000000000', '2022-10-21T00:00:00.000000000',\n", - " '2022-11-01T00:00:00.000000000', '2022-11-11T00:00:00.000000000',\n", - " '2022-11-21T00:00:00.000000000', '2022-12-01T00:00:00.000000000',\n", - " '2022-12-11T00:00:00.000000000', '2022-12-21T00:00:00.000000000',\n", - " '2023-01-01T00:00:00.000000000'], dtype='datetime64[ns]')" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.unique(date)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "dekads = utils.to_dekads(pd.DataFrame(np.zeros(len(daily_times)),index=daily_times)).index" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "df = df.loc[(df.index >= '20200101') & (df.index <= '20221231')]" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df.fpanv.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
fpanv
time
2020-01-01NaN
2020-01-11NaN
2020-01-210.387
2020-02-01-0.484
2020-02-11-1.126
......
2022-11-11-0.559
2022-11-21NaN
2022-12-01NaN
2022-12-11NaN
2022-12-21NaN
\n", - "

108 rows × 1 columns

\n", - "
" - ], - "text/plain": [ - " fpanv\n", - "time \n", - "2020-01-01 NaN\n", - "2020-01-11 NaN\n", - "2020-01-21 0.387\n", - "2020-02-01 -0.484\n", - "2020-02-11 -1.126\n", - "... ...\n", - "2022-11-11 -0.559\n", - "2022-11-21 NaN\n", - "2022-12-01 NaN\n", - "2022-12-11 NaN\n", - "2022-12-21 NaN\n", - "\n", - "[108 rows x 1 columns]" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.fpanv.fillna(df.fapan, inplace=True)\n", - "del df['fapan']\n", - "df" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "df = ds.drop_vars(['lat','lon','4326']).to_dataframe()" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ds.smant.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ds.isel(time=0).smand.plot()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "climate_env", - "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.8.16" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "14944716bd77819cc98e0777f574eeb066b7d8a3e92800e5d93184d7ebe696e1" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/edo_read.md b/edo_read.md new file mode 100644 index 0000000..e88f639 --- /dev/null +++ b/edo_read.md @@ -0,0 +1,135 @@ +--- +jupyter: + jupytext: + formats: ipynb,md + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.6 + kernelspec: + display_name: climate_env + language: python + name: python3 +--- + +```python +# ensure classes imported from .py files are dynamically updated +%load_ext autoreload +%autoreload 2 + +# plot matplots nicely +%matplotlib inline +``` + +```python +import xarray as xr +import numpy as np +import pandas as pd +from climate_drought import utils +``` + +```python +import glob +#flist=glob.glob('input/spg03/spg03*.nc') +flist=glob.glob('input/smant/sma*.nc') +#flist = glob.glob('input/fpanv/f*.nc') +len(flist) +``` + +```python +xr.open_dataset(flist[0]) +``` + +```python +dses = [xr.open_dataset(fname).sel(lat=62,lon=-100,method='nearest').drop_vars(['lat','lon','4326']) for fname in flist] +``` + +```python +df = xr.merge(dses).to_dataframe() +``` + +```python +df[(df.index > pd.Timestamp(2016,4,16)) & (df.index < pd.Timestamp(2022,12,31))].smant.plot() +``` + +```python +sdate = '20200101' +edate = '20230101' +daterange = utils.daterange(sdate,edate,rtv=False) +``` + +```python +def fill_gaps(sdate,edate,df): + dti = pd.date_range(sdate,edate,freq='1D') + dti_dekads = utils.dti_to_dekads(dti) + gaps = dti_dekads[~dti_dekads.isin(df.index)] + if len(gaps) > 0: + df_gaps = pd.DataFrame(index=gaps) + return pd.concat([df,df_gaps]) + else: + return df +``` + +```python +dti = pd.date_range(sdate,edate,freq='1D') +``` + +```python +dti_dekads = utils.dti_to_dekads(dti) +``` + +```python +dti_dekads +``` + +```python +gaps = dti_dekads[~dti_dekads.isin(df.index)] +``` + +```python +df_gaps = pd.DataFrame(index=gaps) +``` + +```python +pd.concat([df,df_gaps]) +``` + +```python +d = dti.day - np.clip((dti.day-1) // 10, 0, 2)*10 - 1 +date = dti.values - np.array(d, dtype="timedelta64[D]") +``` + +```python +np.unique(date) +``` + +```python +dekads = utils.to_dekads(pd.DataFrame(np.zeros(len(daily_times)),index=daily_times)).index +``` + +```python +df = df.loc[(df.index >= '20200101') & (df.index <= '20221231')] +``` + +```python +df.fpanv.plot() +``` + +```python +df.fpanv.fillna(df.fapan, inplace=True) +del df['fapan'] +df +``` + +```python +df = ds.drop_vars(['lat','lon','4326']).to_dataframe() +``` + +```python +ds.smant.plot() +``` + +```python +ds.isel(time=0).smand.plot() +``` diff --git a/environment.yml b/environment.yml index 4ab13da..f31ee43 100644 --- a/environment.yml +++ b/environment.yml @@ -5,7 +5,9 @@ channels: dependencies: - birdy - gdal>=3.4.1 + - libnetcdf==4.9.2 - matplotlib + - netcdf4==1.6.3 - pip - python=3.8.16 - xarray @@ -16,6 +18,7 @@ dependencies: - cdsapi - covjson-pydantic - dask[distributed] + - fiona==1.9.6 - fsspec - geojson - geopandas @@ -31,4 +34,6 @@ dependencies: - scipy - shapely - sentinelsat + - xclim==0.47.0 + - click>=8.1 prefix: ~/anaconda3/envs/climate_env diff --git a/test_cdi.md b/test_cdi.md new file mode 100644 index 0000000..88f1a86 --- /dev/null +++ b/test_cdi.md @@ -0,0 +1,320 @@ +--- +jupyter: + jupytext: + formats: ipynb,md + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.6 + kernelspec: + display_name: climate_env + language: python + name: python3 +--- + +```python +# ensure classes imported from .py files are dynamically updated +%load_ext autoreload +%autoreload 2 + +# plot matplots nicely +%matplotlib inline +``` + +```python +import numpy as np +import pandas as pd +import datetime +import xarray as xr +from climate_drought import config, drought_indices as dri, utils +import matplotlib.pyplot as plt + +``` + +```python +# Set up analysis args +# pt = point, bb = bounding box, pn = polygon +cf = config.Config(outdir= 'output',indir='input',verbose=False) +aa_pt = config.AnalysisArgs(latitude=38.5,longitude=-119.5,start_date='20210121',end_date='20230531',oformat='cov') +aa_bb = config.AnalysisArgs(latitude=[38.5,40.5],longitude=[-119.5,-117.5],start_date='20210121',end_date='20230531') +aa_pn = config.AnalysisArgs(latitude=[38.5,40.5,38,38.5,38.5],longitude=[-119.5,-117.5,-118,-117.5,-116.5],start_date='20210121',end_date='20230531',oformat='cov') +``` + +```python +# create cdi args, using already created args +caa_pn = config.CDIArgs(aa_pn.latitude,aa_pn.longitude,aa_pn.start_date,aa_pn.end_date,oformat='cov') +caa_bb = config.CDIArgs(aa_bb.latitude,aa_bb.longitude,aa_bb.start_date,aa_bb.end_date,oformat='csv') +caa_pt = config.CDIArgs(aa_pt.latitude,aa_pt.longitude,aa_pt.start_date,aa_pn.end_date) +``` + +```python +# initialise a point, bounding box and polygon cdi +cdi_pt = dri.CDI(cf,caa_pt) +cdi_bb = dri.CDI(cf,caa_bb) +cdi_pn = dri.CDI(cf,caa_pn) +``` + +```python +# ensure data is downloaded +cdi_pt.download() +cdi_bb.download() +cdi_pn.download() +``` + +```python +cdi_pt.process() +cdi_bb.process() +cdi_pn.process() +``` + +```python +# check impact of time reindexing using point cdi +fig, axs = plt.subplots(4,1,figsize=(12,10)) +spi_pre = cdi_pt.spi.data_ds.spg03.squeeze() +spi_pro = cdi_pt.data_ds.spg03.squeeze() +sma_pre = cdi_pt.sma.data_ds.smant.squeeze() +sma_pro = cdi_pt.data_ds.smant.squeeze() +fpr_pre = cdi_pt.fpr.data_ds.fpanv.squeeze() +fpr_pro = cdi_pt.data_ds.fpanv.squeeze() +cdi_pro = cdi_pt.data_ds.CDI.squeeze() +axs[0].plot(spi_pre.time,spi_pre) +axs[0].plot(spi_pro.time,spi_pro) +xg = axs[0].get_xlim() +axs[1].plot(sma_pre.time,sma_pre) +axs[1].plot(sma_pro.time,sma_pro) +axs[1].set_xlim(xg) +axs[2].plot(fpr_pre.time,fpr_pre) +axs[2].plot(fpr_pro.time,fpr_pro) +axs[2].set_xlim(xg) +axs[3].plot(cdi_pro.time,cdi_pro) +axs[3].set_xlim(xg) +``` + +```python +fig, axs = plt.subplots(4,1,figsize=(12,10)) +spi_pre = cdi_bb.spi.data_ds.sel({'latitude':aa_pt.latitude,'longitude':aa_pt.longitude},method='nearest').spg03.squeeze() +spi_pro = cdi_bb.data_ds.sel({'latitude':aa_pt.latitude,'longitude':aa_pt.longitude},method='nearest').spg03.squeeze() +sma_pre = cdi_bb.sma.data_ds.sel({'latitude':aa_pt.latitude,'longitude':aa_pt.longitude},method='nearest').smant.squeeze() +sma_pro = cdi_bb.data_ds.sel({'latitude':aa_pt.latitude,'longitude':aa_pt.longitude},method='nearest').smant.squeeze() +fpr_pre = cdi_bb.fpr.data_ds.sel({'latitude':aa_pt.latitude,'longitude':aa_pt.longitude},method='nearest').fpanv.squeeze() +fpr_pro = cdi_bb.data_ds.sel({'latitude':aa_pt.latitude,'longitude':aa_pt.longitude},method='nearest').fpanv.squeeze() +cdi_pro = cdi_bb.data_ds.sel({'latitude':aa_pt.latitude,'longitude':aa_pt.longitude},method='nearest').CDI.squeeze() +axs[0].plot(spi_pre.time,spi_pre) +axs[0].plot(spi_pro.time,spi_pro) +xg = axs[0].get_xlim() +axs[1].plot(sma_pre.time,sma_pre) +axs[1].plot(sma_pro.time,sma_pro) +axs[1].set_xlim(xg) +axs[2].plot(fpr_pre.time,fpr_pre) +axs[2].plot(fpr_pro.time,fpr_pro) +axs[2].set_xlim(xg) +axs[3].plot(cdi_pro.time,cdi_pro) +axs[3].set_xlim(xg) +``` + +```python +# check interpolation method using bbox data +t=pd.Timestamp(2021,5,1) + +fig, axs = plt.subplots(3,2,figsize=(8,10)) +spi_raw = cdi_bb.spi.data_ds.spg03.sel(time=t,method='nearest') +sma_raw = cdi_bb.sma.data_ds.smant.sel(time=t,method='nearest') +fpr_raw = cdi_bb.fpr.data_ds.fpanv.sel(time=t,method='nearest') +spi_pro = cdi_bb.data_ds.spg03.sel(time=t,method='nearest') +sma_pro = cdi_bb.data_ds.smant.sel(time=t,method='nearest') +fpr_pro = cdi_bb.data_ds.fpanv.sel(time=t,method='nearest') + + +def plot_regridded(ax,da,da2,title): + c1=ax[0].pcolor(da.longitude,da.latitude,da,vmin=-1.5,vmax=1.5) + c2=ax[1].pcolor(da2.longitude,da2.latitude,da2,vmin=-1.5,vmax=1.5) + fig.colorbar(c1,ax=ax[0]) + fig.colorbar(c2,ax=ax[1]) + ax[0].set_title(title + ' raw') + ax[1].set_title(title + ' regridded') + +plot_regridded(axs[0],spi_raw,spi_pro,'SPI') +plot_regridded(axs[1],sma_raw,sma_pro,'SMA') +plot_regridded(axs[2],fpr_raw,fpr_pro,'FAPAR') + + + +``` + +```python +# check interpolation method using polygon data +t=pd.Timestamp(2021,5,1) + +fig, axs = plt.subplots(3,2,figsize=(8,10)) +spi_raw = cdi_pn.spi.data_ds.spg03.sel(time=t,method='nearest') +sma_raw = cdi_pn.sma.data_ds.smant.sel(time=t,method='nearest') +fpr_raw = cdi_pn.fpr.data_ds.fpanv.sel(time=t,method='nearest') +spi_pro = cdi_pn.data_ds.spg03.sel(time=t,method='nearest') +sma_pro = cdi_pn.data_ds.smant.sel(time=t,method='nearest') +fpr_pro = cdi_pn.data_ds.fpanv.sel(time=t,method='nearest') + + +def plot_regridded(ax,da,da2,title): + da=da.where(da != dri.OUTSIDE_AREA_SELECTION,drop=True) + da2=da2.where(da2 != dri.OUTSIDE_AREA_SELECTION,drop=True) + c1=ax[0].pcolor(da.longitude,da.latitude,da,vmin=-1.5,vmax=1.5) + c2=ax[1].pcolor(da2.longitude,da2.latitude,da2,vmin=-1.5,vmax=1.5) + fig.colorbar(c1,ax=ax[0]) + fig.colorbar(c2,ax=ax[1]) + ax[0].set_title(title + ' raw') + ax[1].set_title(title + ' regridded') + +plot_regridded(axs[0],spi_raw,spi_pro,'SPI') +plot_regridded(axs[1],sma_raw,sma_pro,'SMA') +plot_regridded(axs[2],fpr_raw,fpr_pro,'FAPAR') + + + +``` + +```python +print(cdi_bb.sma.data_ds.smant.sel({'latitude':38.5,'longitude':-118.5},method='nearest').isel(time=15).values) +print(cdi_pn.sma.data_ds.smant.sel({'latitude':38.5,'longitude':-118.5},method='nearest').isel(time=15).values) +print(cdi_bb.data_ds.smant.sel({'latitude':38.5,'longitude':-118.5},method='nearest').isel(time=15).values) +print(cdi_pn.data_ds.smant.sel({'latitude':38.5,'longitude':-118.5},method='nearest').isel(time=15).values) + + +``` + +```python +da_sma = cdi_pt.sma.data_ds.smant +da = da_sma.reindex({'time': cdi_pt.time_dekads}) +da.interp({'latitude'}=36,method='nearest') +``` + +```python +cdi_pt.process() +``` + +```python +sma_pt = dri.SMA_GDO(cf,aa_pt) +sma_bb = dri.SMA_GDO(cf,aa_bb) +sma_pn = dri.SMA_GDO(cf,aa_pn) +spi_pt = dri.SPI_GDO(cf,aa_pt) +spi_bb = dri.SPI_GDO(cf,aa_bb) +spi_pn = dri.SPI_GDO(cf,aa_pn) +fpr_pt = dri.FPAR_GDO(cf,aa_pt) +fpr_bb = dri.FPAR_GDO(cf,aa_bb) +fpr_pn = dri.FPAR_GDO(cf,aa_pn) +``` + +```python +sma_pt.download() +sma_bb.download() +sma_pn.download() +``` + +```python +spi_pt.download() +spi_bb.download() +spi_pn.download() +``` + +```python +fpr_pt.download() +fpr_bb.download() +fpr_pn.download() +``` + +```python +sma_pt.process() +``` + +```python +sma_bb.process() +``` + +```python +sma_pn.process() +``` + +```python +spi_pt.process() +spi_bb.process() +spi_pn.process() +``` + +```python +fpr_pt.process() +fpr_bb.process() +fpr_pn.process() +``` + +```python +caa = config.CDIArgs(aa_pn.latitude,aa_pn.longitude,aa_pn.start_date,aa_pn.end_date,oformat='cov') +caa = config.CDIArgs([36],[-120],aa_pt.start_date,aa_pn.end_date,oformat='csv') + +``` + +```python +cdi = dri.CDI(cf,caa) +cdi.download() +``` + +```python +cdi.process() +``` + +```python +spi_era = dri.SPI_ECMWF(cf,aa_pn) +spi_era.download() +``` + +```python +spi_era.process() +``` + +```python +spi_era.data_ds.spi.isel(time=10).plot() +``` + +```python +aa_pt = config.AnalysisArgs(latitude=38.5,longitude=-119.5,start_date='20210121',end_date='20210411',oformat='cov') +aa_bb = config.AnalysisArgs(latitude=[38.5,40.5],longitude=[-119.5,-117.5],start_date='20210121',end_date='20210411',oformat='csv') +aa_pn = config.AnalysisArgs(latitude=[38.5,40.5,38,38.5,38.5],longitude=[-119.5,-117.5,-118,-117.5,-116.5],start_date='20210121',end_date='20210411',oformat='csv') +``` + +```python +sma_ecmwf = dri.SMA_ECMWF(cf,aa_pn) +sma_ecmwf.download() +``` + +```python +sma_ecmwf.process() +``` + +```python +sma_ecmwf.data_ds.swvl3.isel(time=4).plot() +``` + +```python +ds=xr.open_dataset('output/soilwater_20210121-20210411_38.5-40.5_-119.5--117.5_hourly.nc') +#ds = ds.sortby('time').resample({'time':'1D'}).mean() +``` + +```python +utils.ds_to_dekads(ds) +``` + +```python +ds.assign(day=) +``` + +```python +time = ds.time.to_numpy() +time = pd.date_range(aa_pn.start_date,aa_pn.end_date,freq='1h') +ds = ds.reindex({'time':time},method='ffill') +fig,ax = plt.subplots() +ax.plot(np.diff(time),'.') + +``` + +```python +ds.time.to_numpy() +``` diff --git a/test_drought.md b/test_drought.md new file mode 100644 index 0000000..20b8c1d --- /dev/null +++ b/test_drought.md @@ -0,0 +1,140 @@ +--- +jupyter: + jupytext: + formats: ipynb,md + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.6 + kernelspec: + display_name: climate_env + language: python + name: climate_env +--- + +```python +import os +import sys +import numpy as np +import xarray as xr +import matplotlib.pyplot as plt +import argparse +import geojson + +# import drought indicies +from climate_drought import drought_indices as dri, config + +INDEX_MAP = { + 'SPI_ECMWF': dri.SPI_ECMWF, + 'SPI_GDO': dri.SPI_GDO, + 'SPI_NCG': dri.SPI_NCG, + 'SMA_ECMWF': dri.SMA_ECMWF, + 'SMA_GDO': dri.SMA_GDO, + 'fAPAR': dri.FPAR_GDO, + 'CDI': dri.CDI, + 'FEATURE_SAFE': dri.FEATURE_SAFE, + 'UTCI': dri.UTCI +} + +``` + +```python +class Drought: + def __init__(self,product,latitude,longitude,start_date,end_date): + # Setup paramaters + self.verbose = True + + self.indir = './input' + self.outdir = './output' + self.oformat = 'GeoJSON' + self.product = product + self.start_date = start_date + self.end_date = end_date + + # Convert latitude and longitude strings to lists + self.latitude = [float(item) for item in latitude.replace('[','').replace(']','').split(',')] + self.longitude = [float(item) for item in longitude.replace('[','').replace(']','').split(',')] + + # setup config and args + self.cfg = config.Config(self.outdir,self.indir) + self.args = config.AnalysisArgs(latitude,longitude, + start_date,end_date,product=product,oformat=self.oformat) + +``` + +```python +product = "UTCI" +latitude = '52.5' +longitude = '1.25' +start_date = '20220101' +end_date = '20241231' + +print("Running {} for {} {} from {} to {}".format(product, + latitude, longitude, start_date, end_date)) + +obj = Drought(product,latitude,longitude,start_date,end_date) +``` + +```python +# Run processing +def drought_index(obj) -> dri.DroughtIndex: + return INDEX_MAP[obj.product](obj.cfg, obj.args) + +idx = drought_index(obj) + +print("Computing {} index for {} to {}.".format(obj.product, + obj.cfg.baseline_start, obj.cfg.baseline_end)) + +if os.path.exists(idx.output_file_path): + print("Processed file '{}' already exists.".format(idx.output_file_path)) +else: + idx.download() + idx.process() + print("Downloading and processing complete for '{}' completed with format {}.".format(idx.output_file_path, obj.oformat)) + +if os.path.exists(idx.output_file_path): + exit_code = 1 + print("{} processing complete, generated {}".format(product, idx.output_file_path)) + +else: + print("Processing failed, {} does not exist".format(idx.output_file_path)) + +``` + +```python +import geopandas as gpd + +# Load in data and display then plot +df = gpd.read_file(idx.output_file_path) +print(df) + +``` + +```python +# plotting + +fig, ax1 = plt.subplots() +ax1.plot(df._date,df.spi,color='b',label='spi') +ax1.set_ylabel('SPI [blue]') +tick_list = df._date.values[::3] +plt.xticks(rotation=45, ticks=tick_list) +minv = np.nanmin([np.nanmin(df.hindex),np.nanmin(df.spi)]) +maxv = np.nanmax([np.nanmax(df.hindex),np.nanmax(df.spi)]) +if product == 'UTCI': + ax1.plot(df._date,df.hindex,color='g',label='utci') + ax1.set_ylabel('SPI [blue], Health index [green]') + ax2 = ax1.twinx() + ax2.plot(df._date, df.utci, color = 'r', label = 'utci') + ax2.set_ylabel('UTCI [degC, red]') + ax1.fill_between(df._date,1.5,maxv, + color = 'C1', alpha=0.3, interpolate = True) + ax1.fill_between(df._date,-1.5,minv, + color = 'C0', alpha=0.3, interpolate = True) +plt.tight_layout() +plt.show() +``` + +```python + +``` diff --git a/test_drought.py b/test_drought.py index 43b3bbe..338bb1f 100644 --- a/test_drought.py +++ b/test_drought.py @@ -1,5 +1,8 @@ import os from sys import exit +import numpy as np +import geopandas as gpd +import matplotlib.pyplot as plt import argparse @@ -17,7 +20,8 @@ 'SMA_GDO': dri.SMA_GDO, 'fAPAR': dri.FPAR_GDO, 'CDI': dri.CDI, - 'FEATURE_SAFE': dri.FEATURE_SAFE + 'FEATURE_SAFE': dri.FEATURE_SAFE, + 'UTCI': dri.UTCI } class DROUGHT: @@ -38,6 +42,8 @@ def __init__(self,args): # Transfer args self.product = args.product + if args.utci: + self.product = "UTCI" self.config = config.Config(args.outdir,args.indir,args.verbose,aws=args.aws,era_daily=args.era_daily) if args.product == 'CDI': @@ -84,8 +90,31 @@ def run_index(self): if os.path.exists(idx.output_file_path): exit_code = 1 self.logger.info("{} processing complete, generated {}".format(self.product, idx.output_file_path)) + else: self.logger.info("Processing failed, {} does not exist".format(idx.output_file_path)) + + # normalise data + def norm(data): + return (data)/(max(data)-min(data)) + + # Load in data and display then plot + df = gpd.read_file(idx.output_file_path) + print(df) + fig, ax1 = plt.subplots() + ax1.plot(df._date,df.spi,color='b',label='spi') + #ax1.set_ylim([-1,1]) + ax1.set_ylabel('SPI [blue]') + tick_list = df._date.values[::3] + plt.xticks(rotation=45, ticks=tick_list) + if self.product == 'UTCI': + ax1.plot(df._date,df.hindex,color='g',label='utci') + ax1.set_ylabel('SPI [blue], Health index [green]') + ax2 = ax1.twinx() + ax2.plot(df._date, df.utci, color = 'r', label = 'utci') + ax2.set_ylabel('UTCI [degC, red]') + plt.tight_layout() + plt.show() return exit_code @@ -124,9 +153,10 @@ def main(): parser.add_argument("-t", "--type", type=str, dest="type", default='none') parser.add_argument("-s", "--sdate", type=str, dest="start_date", default='20200116', help="Start date as YYYYMMDD") parser.add_argument("-e", "--edate", type=str, dest="end_date", default='20200410', help="End date as YYYYMMDD") - parser.add_argument("-d", "--eradaily", type=bool, dest="era_daily", default=False) + parser.add_argument("-d", "--eradaily", action="store_true", dest="era_daily", default=False) parser.add_argument("-sma", "--smasrc", type=str, dest="sma_source", default='GDO', help="'GDO' or 'ECMWF'") parser.add_argument("-spi", "--spisrc", type=str, dest="spi_source", default='GDO', help="'GDO' or 'ECMWF'") + parser.add_argument("-u", "--utci", action="store_true", default=False, help="Download UTCI") # define arguments args = parser.parse_args()