def get_ts_from_complete_data(complete_data, mask, keys, dates=None): if keys == None: keys = complete_data.keys() common_dates = becgis.CommonDates([complete_data[key][1] for key in keys]) becgis.AssertProjResNDV([complete_data[key][0] for key in keys]) MASK = becgis.OpenAsArray(mask, nan_values=True) tss = dict() for key in keys: var_mm = np.array([]) for date in common_dates: tif = complete_data[key][0][complete_data[key][1] == date][0] DATA = becgis.OpenAsArray(tif, nan_values=True) DATA[np.isnan(DATA)] = 0.0 DATA[np.isnan(MASK)] = np.nan var_mm = np.append(var_mm, np.nanmean(DATA)) tss[key] = (common_dates, var_mm) return tss
def sum_ts(flow_csvs): flows = list() dates = list() for cv in flow_csvs: coordinates, flow_ts, station_name, unit = pwv.create_dict_entry(cv) flow_dates, flow_values = becgis.Unzip(flow_ts) flow_dates = becgis.ConvertDatetimeDate(flow_dates) if unit == 'm3/s': flow_values = np.array([ flow_values[flow_dates == date] * 60 * 60 * 24 * calendar.monthrange(date.year, date.month)[1] / 1000**3 for date in flow_dates ])[:, 0] flows.append(flow_values) dates.append(flow_dates) common_dates = becgis.CommonDates(dates) data = np.zeros(np.shape(common_dates)) for flow_values, flow_dates in zip(flows, dates): add_data = np.array( [flow_values[flow_dates == date][0] for date in common_dates]) data += add_data return data, common_dates
def get_ts_from_complete_data_spec(complete_data, lu_fh, keys, a, dates=None): if keys == None: keys = complete_data.keys() common_dates = becgis.CommonDates([complete_data[key][1] for key in keys]) becgis.AssertProjResNDV([complete_data[key][0] for key in keys]) MASK = becgis.OpenAsArray(lu_fh, nan_values=True) lucs = lucs = gd.get_sheet4_6_classes() gw_classes = list() for subclass in [ 'Forests', 'Rainfed Crops', 'Shrubland', 'Forest Plantations' ]: gw_classes += lucs[subclass] mask_gw = np.logical_or.reduce([MASK == value for value in gw_classes]) tss = dict() for key in keys: var_mm = np.array([]) for date in common_dates: tif = complete_data[key][0][complete_data[key][1] == date][0] DATA = becgis.OpenAsArray(tif, nan_values=True) DATA[np.isnan(DATA)] = 0.0 DATA[np.isnan(MASK)] = np.nan alpha = np.ones(np.shape(DATA)) * a alpha[mask_gw] = 0.0 var_mm = np.append(var_mm, np.nanmean(DATA * alpha)) tss[key] = (common_dates, var_mm) return tss
def create_sheet1(complete_data, metadata, output_dir, global_data): output_folder = os.path.join(output_dir, metadata['name'], 'sheet1') if not os.path.exists(output_folder): os.makedirs(output_folder) output_fh_in = False output_fh_in, output_fh_out = create_sheet1_in_outflows(os.path.join(output_dir, metadata['name'], "sheet5", "sheet5_monthly"), metadata, output_folder) outflow_values, outflow_dates = sum_ts(np.array([output_fh_out])) transfer_values, transfer_dates = get_transfers(os.path.join(output_dir, metadata['name'], "sheet5", "sheet5_monthly")) if output_fh_in: inflow_values, inflow_dates = sum_ts(np.array([output_fh_in])) # Calculate the average longterm outflow. q_out_avg = np.nanmean(outflow_values) # Open a dictionary specyfing the landuseclasses. sheet1_lucs = gd.get_sheet1_classes() # Determine for what dates all the required data is available. if output_fh_in: common_dates = becgis.CommonDates([complete_data['p'][1], complete_data['etb'][1], complete_data['etg'][1], outflow_dates, inflow_dates]) else: common_dates = becgis.CommonDates([complete_data['tr'][1],complete_data['p'][1], complete_data['etb'][1], complete_data['etg'][1]]) #, outflow_dates]) # Create list to store results. all_results = list() for date in common_dates: # Summurize some data in a dictionary. entries = {'Fractions': complete_data['fractions'][0][complete_data['fractions'][1] == date][0], 'WPL': global_data["wpl_tif"], 'EWR': global_data["environ_water_req"], 'P': complete_data['p'][0][complete_data['p'][1] == date][0], 'ETblue': complete_data['etb'][0][complete_data['etb'][1] == date][0], 'ETgreen': complete_data['etg'][0][complete_data['etg'][1] == date][0]} # Select the required outflow value. q_outflow = outflow_values[outflow_dates == date][0] q_transfer = np.array(transfer_values)[np.array(transfer_dates) == date][0] if output_fh_in: q_inflow = inflow_values[inflow_dates == date][0] else: q_inflow = 0.0 # Calculate the sheet values. results = calc_sheet1(entries, metadata['lu'], sheet1_lucs, metadata['recycling_ratio'], q_outflow, q_out_avg, output_folder, q_in_sw=q_inflow, q_out_sw=q_transfer) # Save the results of the current month. all_results.append(results) # Create the csv-file. output_fh = os.path.join(output_folder,'sheet1_monthly','sheet1_{0}_{1}.csv'.format(date.year, str(date.month).zfill(2))) create_csv(results, output_fh) # Plot the actual sheet. create_sheet1_png(metadata['name'], '{0}-{1}'.format(date.year, str(date.month).zfill(2)), 'km3/month', output_fh, output_fh.replace('.csv','.png'), template = get_path('sheet1_svg'), smart_unit = True) # Create some graphs. plot_storages(all_results, common_dates, metadata['name'], output_folder) plot_parameter(all_results, common_dates, metadata['name'], output_folder, 'utilizable_outflow') # Create yearly csv-files. yearly_csv_fhs = hl.create_csv_yearly(os.path.split(output_fh)[0], os.path.join(output_folder, "sheet1_yearly"), 1, metadata['water_year_start_month'], year_position = [-11,-7], month_position = [-6,-4], header_rows = 1, header_columns = 3) # Plot yearly sheets. for csv_fh in yearly_csv_fhs: create_sheet1_png(metadata['name'], csv_fh[-8:-4], 'km3/year', csv_fh, csv_fh.replace('.csv','.png'), template = get_path('sheet1_svg'), smart_unit = True) return complete_data, all_results
def compare_rasters2rasters_per_lu(ds1_fhs, ds1_dates, ds2_fhs, ds2_dates, lu_fh, output_dir, dataset_names=["DS1", "DS2"], class_dictionary=None, no_of_classes=6): """ Compare two raster datasets with eachother per different landuse categories. Parameters ---------- ds1_fhs : ndarray Array with strings pointing to maps of dataset 1. ds1_dates : ndarray Array with same shape as ds1_fhs, containing datetime.date objects. ds2_fhs : ndarray Array with strings pointing to maps of dataset 2. ds2_dates : ndarray Array with same shape as ds2_fhs, containing datetime.date objects. lu_fh : str Pointer to a landusemap. output_dir : str Map to save results. dataset_names : list, optional List with two strings describing the names of the two datasets. class_dictionary : dict Dictionary specifying all the landuse categories. no_of_classes : int The 'no_of_classes' most dominant classes in the the lu_fh are compared, the rest is ignored. """ LUCS = becgis.OpenAsArray(lu_fh, nan_values=True) DS1 = becgis.OpenAsArray(ds1_fhs[0], nan_values=True) DS2 = becgis.OpenAsArray(ds2_fhs[0], nan_values=True) DS1[np.isnan(DS2)] = np.nan LUCS[np.isnan(DS1)] = np.nan classes, counts = np.unique(LUCS[~np.isnan(LUCS)], return_counts=True) counts_sorted = np.sort(counts)[-no_of_classes:] selected_lucs = [ classes[counts == counter][0] for counter in counts_sorted ] driver, NDV, xsize, ysize, GeoT, Projection = becgis.GetGeoInfo(lu_fh) becgis.CreateGeoTiff(lu_fh.replace('.tif', '_.tif'), LUCS, driver, NDV, xsize, ysize, GeoT, Projection) common_dates = becgis.CommonDates([ds1_dates, ds2_dates]) ds1_totals = np.array([]) ds2_totals = np.array([]) DS1_per_class = dict() DS2_per_class = dict() for date in common_dates: DS1 = becgis.OpenAsArray(ds1_fhs[ds1_dates == date][0], nan_values=True) DS2 = becgis.OpenAsArray(ds2_fhs[ds2_dates == date][0], nan_values=True) for clss in selected_lucs: if clss in DS1_per_class.keys(): DS1_per_class[clss] = np.append(DS1_per_class[clss], np.nanmean(DS1[LUCS == clss])) else: DS1_per_class[clss] = np.array([np.nanmean(DS1[LUCS == clss])]) if clss in DS2_per_class.keys(): DS2_per_class[clss] = np.append(DS2_per_class[clss], np.nanmean(DS2[LUCS == clss])) else: DS2_per_class[clss] = np.array([np.nanmean(DS2[LUCS == clss])]) ds1_totals = np.append(ds1_totals, np.nanmean(DS1)) ds2_totals = np.append(ds2_totals, np.nanmean(DS2)) print("Finished {0}, going to {1}".format(date, common_dates[-1])) for clss in selected_lucs: if class_dictionary is None: plot_scatter_series(DS1_per_class[clss], DS2_per_class[clss], dataset_names[0], dataset_names[1], clss, output_dir) else: cats = {v[0]: k for k, v in class_dictionary.iteritems()} plot_scatter_series(DS1_per_class[clss], DS2_per_class[clss], dataset_names[0], dataset_names[1], cats[clss], output_dir) plot_scatter_series(ds1_totals, ds2_totals, dataset_names[0], dataset_names[1], "Total Area", output_dir) if class_dictionary is not None: output_fh = os.path.join(output_dir, 'landuse_percentages.png') driver, NDV, xsize, ysize, GeoT, Projection = becgis.GetGeoInfo(lu_fh) becgis.CreateGeoTiff(lu_fh.replace('.tif', '_.tif'), LUCS, driver, NDV, xsize, ysize, GeoT, Projection) becgis.plot_category_areas(lu_fh.replace('.tif', '_.tif'), class_dictionary, output_fh, area_treshold=0.01) os.remove(lu_fh.replace('.tif', '_.tif'))
def compare_rasters2rasters(ds1_fhs, ds1_dates, ds2_fhs, ds2_dates, output_dir=None, dataset_names=None, data_treshold=0.75): """ Compare two series of raster maps by computing the relative bias, RMAE, Pearson-correlation coefficient and the Nash-Sutcliffe coefficient per pixel. Parameters ---------- ds1_fhs : list list pointing to georeferenced raster files of dataset 1. ds1_dates : list list corresponding to ds1_fhs specifying the dates. ds2_fhs : list list pointing to georeferenced raster files of dataset 2. ds2_dates : list list corresponding to ds2_fhs specifying the dates. quantity_unit : list, optional list of two strings describing the quantity and unit of the data. e.g. ['Precipitation', 'mm/month']. dataset_names : list, optional list of strings describing the names of the datasets. e.g. ['CHIRPS', 'ERA-I']. output_dir : list, optional directory to store some results, i.e. (1) a graph of the spatially averaged datasets trough time and the bias and (2) 4 geotiffs showing the bias, nash-sutcliffe coefficient, pearson coefficient and rmae per pixel. data_treshold : float, optional pixels with less than data_treshold * total_number_of_samples actual values are set to no-data, i.e. pixels with too few data points are ignored. Returns ------- results : dict dictionary with four keys (relative bias, RMAE, Pearson-correlation coefficient and the Nash-Sutcliffe) with 2dnarrays of the values per pixel. Examples -------- >>> results = compare_rasters2rasters(ds1_fhs, ds1_dates, ds2_fhs, ds2_dates, output_dir = r"C:/Desktop/", quantity_unit = ["P", "mm/month"], dataset_names = ["CHIRPS", "TRMM"]) """ becgis.AssertProjResNDV([ds1_fhs, ds2_fhs]) if dataset_names is None: dataset_names = ['DS1', 'DS2'] driver, NDV, xsize, ysize, GeoT, Projection = becgis.GetGeoInfo(ds1_fhs[0]) common_dates = becgis.CommonDates([ds1_dates, ds2_dates]) diff_sum = np.zeros((ysize, xsize)) non_nans = np.zeros((ysize, xsize)) progress = 0 samples = len(common_dates) for date in common_dates: DS1 = becgis.OpenAsArray(ds1_fhs[ds1_dates == date][0], nan_values=True) DS2 = becgis.OpenAsArray(ds2_fhs[ds2_dates == date][0], nan_values=True) DS1[np.isnan(DS2)] = np.nan DS2[np.isnan(DS1)] = np.nan non_nans[~np.isnan(DS1)] += np.ones((ysize, xsize))[~np.isnan(DS1)] diff = (DS1 - DS2)**2 diff_sum[~np.isnan(DS1)] += diff[~np.isnan(DS1)] progress += 1 print "progress: {0} of {1} finished".format(progress, samples) diff_sum[non_nans <= data_treshold * samples] = np.nan results = dict() results['rmse'] = np.where(non_nans == 0., np.nan, np.sqrt(diff_sum / non_nans)) startdate = common_dates[0].strftime('%Y%m%d') enddate = common_dates[-1].strftime('%Y%m%d') path = os.path.join(output_dir, 'spatial_errors') if not os.path.exists(path): os.makedirs(path) if output_dir is not None: for varname in results.keys(): fh = os.path.join( path, '{0}_{1}_vs_{2}_{3}_{4}.tif'.format(varname, dataset_names[0], dataset_names[1], startdate, enddate)) becgis.CreateGeoTiff(fh, results[varname], driver, NDV, xsize, ysize, GeoT, Projection) return results
def compare_rasters2stations(ds1_fhs, ds1_dates, station_dict, output_dir, station_names=None, quantity_unit=None, dataset_names=None, method='cubic', min_records=1): """ Compare a series of raster maps with station time series by computing the relative bias, RMAE, Pearson-correlation coefficient and the Nash-Sutcliffe coefficient for each station. Parameters ---------- ds1_fhs : 1dnarray List containing filehandles to georeferenced raster files. ds1_dates : 1dnarray List containing datetime.date or datetime.datetime objects corresponding to the filehandles in ds1_fhs. Lenght should be equal to ds1_fhs. station_dict : dictionary Dictionary containing coordinates of stations and timeseries. See examples below for an example output_dir : str, optional Directory to store several results, i.e. (1) a csv file to load in a GIS program, (2) interpolated maps showing the various error indicators spatially and (3) scatter plots for all the stations. station_names : dictionary, optional Dictionary containing names of the respective stations which can be added to the csv-file, see Examples for more information. quantity_unit : list, optional List of two strings describing the quantity and unit of the data. dataset_name : list, optional List of strings describing the names of the datasets. method : str, optional Method used for interpolation of the error-indicators, i.e.: 'linear', 'nearest' or 'cubic' (default). Returns ------- results : dictionary Dictionary containing several error indicators per station. Examples -------- >>> station_dict = {(lat1, lon1): [(datetime.date(year, month, day), data_value), (datetime.date(year, month, day), data_value), etc.], (lat2, lon2): [(datetime.date(year, month, day), data_value), (datetime.date(year, month, day), data_value), etc.], etc.} >>> station_names = {(lat1,lon1): 'stationname1', (lat2,lon2): 'stationname2', etc.} >>> results = compare_rasters2stations(ds1_fhs, ds1_dates, station_dict, output_dir = r"C:/Desktop", station_names = None, quantity_unit = ["P", "mm/month"], dataset_names = ["CHIRPS", "Meteo Stations"], method = 'cubic') """ results = dict() pixel_coordinates = list() if dataset_names is None: dataset_names = ['Spatial', 'Station'] if quantity_unit is not None: quantity_unit[1] = r'[' + quantity_unit[1] + r']' else: quantity_unit = ['data', ''] becgis.AssertProjResNDV([ds1_fhs]) no_of_stations = len(station_dict.keys()) ds1_dates = becgis.ConvertDatetimeDate(ds1_dates, out='datetime') for i, station in enumerate(station_dict.keys()): station_dates, station_values = unzip(station_dict[station]) common_dates = becgis.CommonDates([ds1_dates, station_dates]) sample_size = common_dates.size if sample_size >= min_records: ds1_values = list() xpixel, ypixel = pixelcoordinates(station[0], station[1], ds1_fhs[0]) if np.any([np.isnan(xpixel), np.isnan(ypixel)]): print "Skipping station ({0}), cause its not on the map".format( station) continue else: for date in common_dates: ds1_values.append( becgis.OpenAsArray(ds1_fhs[ds1_dates == date][0], nan_values=True)[ypixel, xpixel]) common_station_values = [ station_values[station_dates == date][0] for date in common_dates ] results[station] = pairwise_validation(ds1_values, common_station_values) results[station] += (sample_size, ) pixel_coordinates.append((xpixel, ypixel)) #m, b = np.polyfit(ds1_values, common_station_values, 1) path_scatter = os.path.join(output_dir, 'scatter_plots') if not os.path.exists(path_scatter): os.makedirs(path_scatter) path_ts = os.path.join(output_dir, 'time_series') if not os.path.exists(path_ts): os.makedirs(path_ts) path_int = os.path.join(output_dir, 'interp_errors') if not os.path.exists(path_int): os.makedirs(path_int) xlabel = '{0} {1} {2}'.format(dataset_names[0], quantity_unit[0], quantity_unit[1]) ylabel = '{0} {1} {2}'.format(dataset_names[1], quantity_unit[0], quantity_unit[1]) if station_names is not None: title = station_names[station] fn = os.path.join( path_scatter, '{0}_vs_{1}.png'.format(station_names[station], dataset_names[0])) fnts = os.path.join( path_ts, '{0}_vs_{1}.png'.format(station_names[station], dataset_names[0])) else: title = station fn = os.path.join( path_scatter, '{0}_vs_station_{1}.png'.format(dataset_names[0], i)) fnts = os.path.join( path_ts, '{0}_vs_station_{1}.png'.format(dataset_names[0], i)) suptitle = 'pearson: {0:.5f}, rmse: {1:.5f}, ns: {2:.5f}, bias: {3:.5f}, n: {4:.0f}'.format( results[station][0], results[station][1], results[station][2], results[station][3], results[station][4]) plot_scatter_series(ds1_values, common_station_values, xlabel, ylabel, title, fn, suptitle=suptitle, dates=common_dates) xaxis_label = '{0} {1}'.format(quantity_unit[0], quantity_unit[1]) xlabel = '{0}'.format(dataset_names[0]) ylabel = '{0}'.format(dataset_names[1]) plot_time_series(ds1_values, common_station_values, common_dates, xlabel, ylabel, xaxis_label, title, fnts, suptitle=suptitle) print "station {0} ({3}) of {1} finished ({2} matching records)".format( i + 1, no_of_stations, sample_size, title) else: print "____station {0} of {1} skipped____ (less than {2} matching records)".format( i + 1, no_of_stations, min_records) continue n = len(results) csv_filename = os.path.join( output_dir, '{0}stations_vs_{1}_indicators.csv'.format(n, dataset_names[0])) with open(csv_filename, 'wb') as csv_file: writer = csv.writer(csv_file, delimiter=';') writer.writerow([ 'longitude', 'latitude', 'station_id', 'pearson', 'rmse', 'nash_sutcliffe', 'bias', 'no_of_samples' ]) for station in results.keys(): writer.writerow([ station[1], station[0], station_names[station], results[station][0], results[station][1], results[station][2], results[station][3], results[station][4] ]) rslt = { 'Relative Bias': list(), 'RMSE': list(), 'Pearson Coefficient': list(), 'Nash-Sutcliffe Coefficient': list(), 'Number Of Samples': list() } for value in results.values(): rslt['Relative Bias'].append(value[3]) rslt['RMSE'].append(value[1]) rslt['Pearson Coefficient'].append(value[0]) rslt['Nash-Sutcliffe Coefficient'].append(value[2]) rslt['Number Of Samples'].append(value[4]) for key, value in rslt.items(): title = '{0}'.format(key) print title if key is 'RMSE': xlabel = '{0} [mm/month]'.format(key) else: xlabel = key value = np.array(value) value = value[(~np.isnan(value)) & (~np.isinf(value))] suptitle = 'mean: {0:.5f}, std: {1:.5f}, n: {2}'.format( np.nanmean(value), np.nanstd(value), n) print value plot_histogram(value[(~np.isnan(value)) & (~np.isinf(value))], title, xlabel, output_dir, suptitle=suptitle) driver, NDV, xsize, ysize, GeoT, Projection = becgis.GetGeoInfo(ds1_fhs[0]) dummy_map = becgis.OpenAsArray(ds1_fhs[0]) grid = np.mgrid[0:ysize, 0:xsize] var_names = ['pearson', 'rmse', 'ns', 'bias', 'no_of_samples'] for i, var in enumerate(unzip(results.values())): xy = np.array(pixel_coordinates)[~np.isnan(var)] z = var[~np.isnan(var)] interpolation_field = interpolate.griddata(xy, z, (grid[1], grid[0]), method=method, fill_value=np.nanmean(z)) interpolation_field[dummy_map == NDV] = NDV fh = os.path.join( path_int, '{0}_{1}stations_vs_{2}.tif'.format(var_names[i], len(xy), dataset_names[0])) becgis.CreateGeoTiff(fh, interpolation_field, driver, NDV, xsize, ysize, GeoT, Projection) return results
def create_sheet7(complete_data, metadata, output_dir, global_data, data): template_m = get_path('sheet7m_svg') template_y = get_path('sheet7y_svg') lu_fh = metadata['lu'] output_folder = os.path.join(output_dir, metadata['name'], 'sheet7') if not os.path.exists(output_folder): os.makedirs(output_folder) recy_ratio = metadata['recycling_ratio'] date_list2 = becgis.CommonDates([complete_data['etb'][1], complete_data['tr'][1], complete_data['recharge'][1]]) date_list = becgis.ConvertDatetimeDate(date_list2, out='datetime') live_feed, feed_dict, abv_grnd_biomass_ratio, fuel_dict, sheet7_lulc_classes, c_fractions = get_sheet7_classes() # year:fish production #avg 2003-2012: 375375 2013:528000 2014:505005 <http://www.fao.org/3/a-i5555e.pdf> #http://www.fao.org/fishery/statistics/global-production/en # fish_production = {'2000':245600, # '2001':385000, # '2002':360300, # '2003':308750, # '2004':250000, # '2005':324000, # '2006':422000, # '2007':395000, # '2008':365000, # '2009':390000} # Select and project population to LULC map pop_fh = global_data['population_tif'] # pop_temp = os.path.join(output_folder, 'temp_pop') # pop_fh = becgis.MatchProjResNDV(lu_fh, pop_fh, pop_temp) # Select and project cattle to LULC map cattle_fh = [global_data["cattle"]] cattle_temp = os.path.join(output_folder, 'temp_cattle') cattle_fh = becgis.MatchProjResNDV(lu_fh, cattle_fh, cattle_temp)[0] ndm_fhs = [] ro_fhs = [] et_blue_fhs = [] et_green_fhs = [] p_fhs = [] dry_bf_fhs = [] gw_rchg_fhs = [] for d in date_list2: ndm_fhs.extend(complete_data['ndm'][0][complete_data['ndm'][1] == d]) ro_fhs.extend(complete_data['tr'][0][complete_data['tr'][1] == d]) et_blue_fhs.extend(complete_data['etb'][0][complete_data['etb'][1] == d]) et_green_fhs.extend(complete_data['etg'][0][complete_data['etg'][1] == d]) p_fhs.extend(complete_data['p'][0][complete_data['p'][1] == d]) dry_bf_fhs.extend(complete_data['bf'][0][complete_data['bf'][1] == d]) gw_rchg_fhs.extend(complete_data['recharge'][0][complete_data['recharge'][1] == d]) # Make fraction maps to split feed and fuel yields in landscape and incremental ET fraction_fhs = split_yield(output_folder, p_fhs, et_blue_fhs, et_green_fhs, ab=(1.0, 1.0)) # calculate feed production and return filehandles of saved tif files feed_fhs_landscape, feed_fhs_incremental = livestock_feed(output_folder, lu_fh, ndm_fhs, feed_dict, live_feed, cattle_fh, fraction_fhs, date_list2) # calculate fuel production and return filehandles of saved tif files fuel_fhs_landscape, fuel_fhs_incremental = fuel_wood(output_folder, lu_fh, ndm_fhs, fraction_fhs, date_list2) # calculate root_storage and return filehandles of saved tif files rz_depth_fh = global_data['root_depth'] rz_depth_tif = becgis.MatchProjResNDV(lu_fh, np.array([rz_depth_fh]), tf.mkdtemp())[0] rz_sm_fhs = complete_data['rzsm'][0] root_storage_fhs = root_zone_storage_Wpx(output_folder, rz_sm_fhs, rz_depth_tif) atm_recy_landscape_fhs = recycle(output_folder, et_green_fhs, recy_ratio, lu_fh, 'landscape') atm_recy_incremental_fhs = recycle(output_folder, et_blue_fhs, recy_ratio, lu_fh, 'incremental') class Vividict(dict): def __missing__(self, key): value = self[key] = type(self)() return value results = Vividict() for d in date_list: datestr1 = "%04d_%02d" %(d.year, d.month) datestr2 = "%04d%02d" %(d.year, d.month) ystr = "%04d" %(d.year) mstr = "%02d" %(d.month) ro_fh = ro_fhs[np.where([datestr2 in ro_fhs[i] for i in range(len(ro_fhs))])[0][0]] feed_fh_landscape = feed_fhs_landscape[np.where([datestr1 in feed_fhs_landscape[i] for i in range(len(feed_fhs_landscape))])[0][0]] feed_fh_incremental = feed_fhs_incremental[np.where([datestr1 in feed_fhs_incremental[i] for i in range(len(feed_fhs_incremental))])[0][0]] fuel_fh_landscape = fuel_fhs_landscape[np.where([datestr1 in fuel_fhs_landscape[i] for i in range(len(fuel_fhs_landscape))])[0][0]] fuel_fh_incremental = fuel_fhs_incremental[np.where([datestr1 in fuel_fhs_incremental[i] for i in range(len(fuel_fhs_incremental))])[0][0]] baseflow_fh = dry_bf_fhs[np.where([datestr2 in dry_bf_fhs[i] for i in range(len(dry_bf_fhs))])[0][0]] gw_recharge_fh = gw_rchg_fhs[np.where([datestr2 in gw_rchg_fhs[i] for i in range(len(gw_rchg_fhs))])[0][0]] root_storage_fh = root_storage_fhs[np.where([datestr2 in root_storage_fhs[i] for i in range(len(root_storage_fhs))])[0][0]] atm_recy_landscape_fh = atm_recy_landscape_fhs[np.where([datestr2 in atm_recy_landscape_fhs[i] for i in range(len(atm_recy_landscape_fhs))])[0][0]] atm_recy_incremental_fh = atm_recy_incremental_fhs[np.where([datestr2 in atm_recy_incremental_fhs[i] for i in range(len(atm_recy_incremental_fhs))])[0][0]] results[ystr][mstr]['tot_runoff'] = lu_type_sum(ro_fh, lu_fh, sheet7_lulc_classes, convert='mm_to_km3') # results['fish'] = results[ystr][mstr]['feed_incremental'] = lu_type_sum(feed_fh_incremental, lu_fh, sheet7_lulc_classes) results[ystr][mstr]['feed_landscape'] = lu_type_sum(feed_fh_landscape, lu_fh, sheet7_lulc_classes) results[ystr][mstr]['fuel_incremental'] = lu_type_sum(fuel_fh_incremental, lu_fh, sheet7_lulc_classes) results[ystr][mstr]['fuel_landscape'] = lu_type_sum(fuel_fh_landscape, lu_fh, sheet7_lulc_classes) results[ystr][mstr]['baseflow'] = lu_type_sum(baseflow_fh, lu_fh, sheet7_lulc_classes, convert='mm_to_km3') results[ystr][mstr]['gw_rech'] = lu_type_sum(gw_recharge_fh, lu_fh, sheet7_lulc_classes, convert='mm_to_km3') results[ystr][mstr]['root_storage'] = lu_type_sum(root_storage_fh, lu_fh, sheet7_lulc_classes, convert='mm_to_km3') results[ystr][mstr]['atm_recycl_landscape'] = lu_type_sum(atm_recy_landscape_fh, lu_fh, sheet7_lulc_classes, convert='mm_to_km3') results[ystr][mstr]['atm_recycl_incremental'] = lu_type_sum(atm_recy_incremental_fh, lu_fh, sheet7_lulc_classes, convert='mm_to_km3') output_fh = output_folder +"\\sheet7_monthly\\sheet7_"+datestr1+".csv" create_csv(results[ystr][mstr], output_fh) output = output_folder + '\\sheet7_monthly\\sheet7_'+datestr1+'.png' create_sheet7_svg(metadata['name'], datestr1, output_fh, output, template=template_m) fhs = hl.create_csv_yearly(os.path.join(output_folder, "sheet7_monthly"), os.path.join(output_folder, "sheet7_yearly"), 7, metadata['water_year_start_month'], year_position=[-11, -7], month_position=[-6, -4], header_rows=1, header_columns=3, minus_header_colums=-1) for csv_fh in fhs: year = csv_fh[-8:-4] create_sheet7_svg(metadata['name'], year, csv_fh, csv_fh.replace('.csv','.png'), template=template_y)