#!/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)