#!/usr/bin/env python3 # -*- coding: utf-8 -*- # ----------------------------------------------------------------------------- # THIS FILE IS PART OF THE CYLC WORKFLOW ENGINE. # Copyright (C) NIWA & British Crown (Met Office) & Contributors. # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # ----------------------------------------------------------------------------- # This is illustrative code developed for tutorial purposes, it is not # intended for scientific use and is not guarantied to be accurate or correct. """ Usage: forecast INTERVAL ITERATIONS Arguments: INTERVAL: The period between forecasts in minutes. ITERATIONS: The number of forecasts to produce. Example: forecast 60 5 # Produce 5 forecasts at one hour intervals # i.e. T+1, T+2, T+3, T+4, T+5 Environment Variables: PT3H: The cycle point 3 hours prior. PT6H: The cycle point 6 hours prior. SPLINE_LEVEL (int): The beta-spline level to use for interpolating rainfall data onto the grid (either 0 or 1). WEIGHTING (list): The weighting to give to each observation set. """ import os from subprocess import Popen, PIPE import sys import util MI2KM = 1.609344001 # Conversion between miles and kilometers. def get_wind_data(wind_file_path, wind_cycles): """Return wind field data for the provided cycle points. Args: wind_file_path (str): Template for the path to a wind data file. The template should contain substitutions for `{cycles}` (i.e. the cycle point) and `{xy}` (i.e. the value 'x' or 'y'). wind_cycles (list): List of cycle points to get wind data for as strings. Return: list - A list 2-tuples containing wind field matrices i.e. [(wind_x, wind_y), ...] """ wind_fields = [] for cycle in wind_cycles: wind_x = util.read_csv(wind_file_path.format(cycle=cycle, xy='x')) wind_y = util.read_csv(wind_file_path.format(cycle=cycle, xy='y')) wind_fields.append((wind_x, wind_y)) return wind_fields def apply_weighting(wind_fields, weightings): """Return a single wind field averaged from the provided fields using the provided weightings. Args: wind_fields (list): List of wind field data as returned by get_wind_data(). weightings (list): List of the weighting to apply to each field in the generated result (e.g. [1] would just use the first field and [0.5, 0.5] would average the first two. Return: tuple - (weighted_wind_x, weighted_wind_y) """ # Get dimensions (in degrees lng/lat). dim_y = len(wind_fields[0][0]) dim_x = len(wind_fields[0][0][0]) # Generate matrices for the x and y components of the weighted wind. weighted_x = util.generate_matrix(dim_x, dim_y, 0.) weighted_y = util.generate_matrix(dim_x, dim_y, 0.) # Iterate over wind data from this and previous cycles. for ind, (wind_x, wind_y) in enumerate(wind_fields): for itt_y in range(dim_y): for itt_x in range(dim_x): # Acquire weighting for the cycle #ind. try: weighting = weightings[ind] except IndexError: continue weighted_x[itt_y][itt_x] += weighting * wind_x[itt_y][itt_x] weighted_y[itt_y][itt_x] += weighting * wind_y[itt_y][itt_x] util.plot_vector_grid('weighted-wind-data.png', weighted_x, weighted_y) return weighted_x, weighted_y def push_rainfall(rainfall, wind_data, step, resolution, spline_level): """Generate forecasts using rainfall and wind data. A simple system which "pushes" the rainfall by the wind i.e. if there is a 10km/h wind blowing from the west assume that the rain would move 10km to the east every hour. Args: rainfall (list): A 2D list of rainfall data. wind_data (tuple): A 2-tuple containing the x and y components of the wind each as a 2D list. step (int): The number of minutes between each forecast. resolution (float): The size of each grid cell in degrees. spline_level (int): The order of beta-spline to use for the interpolation. Yields: list - A 2D list of predicted rainfall data """ dim_y = len(rainfall) dim_x = len(rainfall[0]) x_values = [] y_values = [] z_values = [] for itt_y in range(dim_y): for itt_x in range(dim_x): x_values.append(itt_x * resolution) y_values.append((dim_y - itt_y) * resolution) # y-axis is flipped. z_values.append(rainfall[itt_y][itt_x]) yield util.interpolate_grid(list(zip(x_values, y_values, z_values)), dim_x, dim_y, resolution, resolution, spline_level) domain = util.parse_domain(os.environ['DOMAIN']) while True: out_of_bounds = [] for itt in range(len(x_values)): try: lng = domain['lng1'] + x_values[itt] lat = domain['lat1'] + y_values[itt] width = util.great_arc_distance( (lng - (resolution / 2.), lat), (lng + (resolution / 2.), lat)) height = util.great_arc_distance( (lng, lat - (resolution / 2.)), (lng, lat + (resolution / 2.))) x_values[itt] += ( (wind_data[0][int(y_values[itt])][int(x_values[itt])] * MI2KM * (step / 60.)) * (resolution / width)) y_values[itt] -= ( (wind_data[1][int(y_values[itt])][int(x_values[itt])] * MI2KM * (step / 60.)) * (resolution / height)) except IndexError: out_of_bounds.append(itt) for itt in reversed(sorted(out_of_bounds)): del x_values[itt] del y_values[itt] del z_values[itt] yield util.interpolate_grid(list(zip(x_values, y_values, z_values)), dim_x, dim_y, resolution, resolution, spline_level) def get_cyclepoint(offset_hours): """Calculate a cyclepoint from a relative offset. Run the system call `cylc cyclepoint --offset-hours ` """ return Popen( ['cylc', 'cyclepoint', '--offset-hours', str(int(offset_hours))], stdout=PIPE ).communicate()[0].strip().decode() def main(forecast_interval, forecast_iterations): # Get workflow settings. domain = util.parse_domain(os.environ['DOMAIN']) resolution = float(os.environ['RESOLUTION']) # Get science settings. spline_level = int(os.environ.get('SPLINE_LEVEL', 0)) weighting = list(map(float, os.environ.get('WEIGHTING', '1').split(','))) # Get file paths. rainfall_file = os.environ['RAINFALL_FILE'] wind_cycles = [get_cyclepoint(offset) for offset in os.environ['WIND_CYCLES'].split(',')] wind_file_template = os.environ['WIND_FILE_TEMPLATE'] map_file = os.environ['MAP_FILE'] map_template = os.environ['MAP_TEMPLATE'] # Get wind data from specified cycles. wind_data = get_wind_data(wind_file_template, wind_cycles) # Convert these into a single data grid using the specified weighting. weighted_wind_data = apply_weighting(wind_data, weighting) # Get rainfall data. rainfall = util.read_csv(rainfall_file) # Initiate the forecaster. generator = push_rainfall(rainfall, weighted_wind_data, forecast_interval, resolution, spline_level) # Generate forecasts. forecasts = {} for lead_minutes in range(0, forecast_interval * (forecast_iterations + 1), forecast_interval): forecast_name = '+PT%02dH%02dM' % (lead_minutes // 60, lead_minutes % 60) # Generate forecast. forecast = next(generator) forecasts[forecast_name] = forecast # Output forecast data. util.write_csv(forecast_name + '.csv', forecast) # Generate html page from forecast data. util.generate_html_map(map_file, map_template, forecasts, domain, resolution) if __name__ == '__main__': util.sleep() try: args = [int(sys.argv[1]), int(sys.argv[2])] except IndexError: print(__doc__) sys.exit(1) main(*args)