def xyplot(x, y, title="", where=None):
#Setting the cartesian view
projection = macro.mmap(
subpage_map_projection='cartesian',
subpage_x_automatic='on',
subpage_y_automatic='on',
)
#Vertical axis
vertical = macro.maxis(axis_orientation="vertical",
axis_grid="on",
axis_grid_colour="grey",
axis_grid_thickness=1,
axis_grid_line_style="dot")
#Horizontal axis
horizontal = macro.maxis(axis_orientation="horizontal",
axis_grid="on",
axis_grid_colour="grey",
axis_grid_thickness=1,
axis_grid_line_style="dot")
x[0] = x[0] * 1.
input = macro.minput(input_x_values=x, input_y_values=y)
graph = macro.mgraph(graph_line_colour="navy", graph_line_thickness=2)
input = macro.minput(input_x_values=x, input_y_values=y)
text = macro.mtext(text_lines=[title])
if where:
where.clear_output()
with where:
display(
macro.plot(projection, vertical, horizontal, input, graph,
text))
else:
return macro.plot(projection, vertical, horizontal, input, graph, text)
def minput_2d(data, lon, lat, metadata, map_region=None):
"""
Put the data into magics minput function.
minput is used 2 define matrices as input for contouring or
list of values as input of curve or symbol plotting.
Args:
data (np.float64): 2D array, [nlat, nlon]
lon (np.float64): 1D vector, [nlon]
lat (np.float64): 1D vector, [nlat]
metadata (dictionary): variable name and units information,
like {'units': 'K', 'long_name': '2 metre temperature'}. Defaults to None.
map_region (list, optional): if set, the data will fit to the map_region.
[lonmin, lonmax, latmin, latmax]
"""
lat = np.squeeze(lat.astype(np.float64))
lon = np.squeeze(lon.astype(np.float64))
input_field_values = np.squeeze(data.astype(np.float64))
if map_region is not None:
loni, lonj, lati, latj = grid_subset(lon, lat, map_region)
lon = lon[loni:lonj]
lat = lat[lati:latj]
input_field_values = input_field_values[lati:latj, loni:lonj]
# put values into magics
return magics.minput(input_type="geographical",
input_field=input_field_values,
input_latitudes_list=lat,
input_longitudes_list=lon,
input_metadata=metadata)
def minput_xarray_vector(uwind,
vwind,
u_varname='data',
v_varname='data',
skip=1,
metadata={
'units': 'm/s',
'long_name': 'Wind field'
}):
"""
Put u and v xarray grid into magics minput data.
refer to: https://github.com/ecmwf/magics-python/blob/master/Magics/macro.py
https://confluence.ecmwf.int/display/MAGP/Input+Data
Args:
uwind (object): u wind xarray dataset which retrieve
from micaps cassandra server directory.
vwind (object): v wind xarray dataset which retrieve
from micaps cassandra server directory.
skip (int, optional): grid skip point number. Defaults to 1.
metadata(dict, optional): data meta information. Defaults to {'units': 'm/s', 'long_name': 'Wind field'}.
"""
# flatten an nD matrix into a 2d matrix
for dim in uwind.dims:
if dim in ['lon', 'lat']:
continue
else:
d = uwind[dim].values[0]
uwind = uwind.loc[{dim: d}]
d = vwind[dim].values[0]
vwind = vwind.loc[{dim: d}]
# extract values
lat = uwind['lat'].values.astype(np.float64) # 1D vector
lon = uwind['lon'].values.astype(np.float64) # 1D vector
uwind_field = np.squeeze(uwind['u_varname'].values.astype(
np.float64)) # 2D array, [nlat, nlon]
vwind_field = np.squeeze(vwind['v_varname'].values.astype(
np.float64)) # 2D array, [nlat, nlon]
lon, lat = np.meshgrid(lon, lat)
# skip values and flatten
uwind_field = uwind_field[::skip, ::skip].flatten()
vwind_field = vwind_field[::skip, ::skip].flatten()
lat = lat[::skip, ::skip].flatten()
lon = lon[::skip, ::skip].flatten()
# put into magics minput function
return magics.minput(input_type="geographical",
input_x_component_values=uwind_field,
input_y_component_values=vwind_field,
input_latitude_values=lat,
input_longitude_values=lon,
input_metadata=metadata)
def minput_2d_vector(udata, vdata, lon, lat, skip=1, metadata=None):
"""
Put the data into magics minput function.
minput is used 2 define matrices as input for contouring or
list of values as input of curve or symbol plotting.
Args:
udata (np.array): 2D array, [nlat, nlon]
vdata (np.array): 2D array, [nlat, nlon]
lon (np.array): 1D vector, [nlon]
lat (np.array): 1D vector, [nlat]
skip (int, optional): grid skip point number. Defaults to 1.
metadata (dictionary): variable name and units information,
like {'units': 'm/s', 'long_name': 'wind field'}. Defaults to None.
"""
# extract values
lat = np.squeeze(lat.astype(np.float64)) # 1D vector
lon = np.squeeze(lon.astype(np.float64)) # 1D vector
uwind_field = np.squeeze(udata.astype(
np.float64)) # 2D array, [nlat, nlon]
vwind_field = np.squeeze(vdata.astype(
np.float64)) # 2D array, [nlat, nlon]
lon, lat = np.meshgrid(lon, lat)
# skip values and flatten
uwind_field = uwind_field[::skip, ::skip].flatten()
vwind_field = vwind_field[::skip, ::skip].flatten()
lat = lat[::skip, ::skip].flatten()
lon = lon[::skip, ::skip].flatten()
# remove nan values
index = (~np.isnan(uwind_field)) & (~np.isnan(vwind_field))
uwind_field = uwind_field[index]
vwind_field = vwind_field[index]
if uwind_field.size == 0:
return None
lat = lat[index]
lon = lon[index]
# check meta information
if metadata is None:
metadata = {'units': 'm/s', 'long_name': 'wind field'}
# put into magics minput function
return magics.minput(input_type="geographical",
input_x_component_values=uwind_field,
input_y_component_values=vwind_field,
input_latitude_values=lat,
input_longitude_values=lon,
input_metadata=metadata)
def minput_xarray(data, varname='data', metadata=None):
"""
Put xarray grid into magics minput data.
refer to: https://github.com/ecmwf/magics-python/blob/master/Magics/macro.py
https://confluence.ecmwf.int/display/MAGP/Input+Data
Args:
data (object): xarray dataset which retrieve
from micaps cassandra server directory.
vwind (object): xarray dataset which retrieve
from micaps cassandra server directory.
if set, data is uwind.
metadata(dict, optional): data meta information. Defaults to {'units': 'm/s', 'long_name': 'Wind field'}.
Examples:
from nmc_met_io.retrieve_micaps_server import get_model_grid
dataset = get_model_grid("ECMWF_HR/TMP/850", varattrs={'units':'C', 'long_name':'temperature'})
data = minput_grid(dataset)
"""
# flatten an nD matrix into a 2d matrix
for dim in data.dims:
if dim in ['lon', 'lat']:
continue
else:
d = data[dim].values[0]
data = data.loc[{dim: d}]
# extract values
lat = data['lat'].values.astype(np.float64) # 1D vector
lon = data['lon'].values.astype(np.float64) # 1D vector
input_field_values = np.squeeze(data[varname].values.astype(
np.float64)) # 2D array, [nlat, nlon]
# set data meta data
if metadata is None:
metadata = dict(data[varname].attrs)
# put values into magics
return magics.minput(input_field=input_field_values,
input_latitudes_list=lat,
input_longitudes_list=lon,
input_metadata=metadata)
def minput_grid(directory, **kwargs):
"""
Retrieve model grid data from micaps cassandra server and
put xarray into magics minput data.
refer to: https://github.com/ecmwf/magics-python/blob/master/Magics/macro.py
Args:
directory (string): micaps cassandra server directory.
Examples:
data = minput_grid("ECMWF_HR/TMP/850", varattrs={'units':'C', 'long_name':'temperature'})
"""
# retrieve data
data = get_model_grid(directory, **kwargs)
if data is None:
return None
# flatten an nD matrix into a 2d matrix
for dim in data.dims:
if dim in ['lon', 'lat']:
continue
else:
d = data[dim].values[0]
data = data.loc[{dim: d}]
# extract values
lat = data['lat'].values.astype(np.float64)
lon = data['lon'].values.astype(np.float64)
input_field_values = np.squeeze(data['data'].values.astype(np.float64))
# put values into magics
data = magics.minput(input_field=input_field_values,
input_latitudes_list=lat,
input_longitudes_list=lon,
input_metadata=dict(data['data'].attrs))
return data
def minput_2d(data, lon, lat, metadata):
"""
Put the data into magics minput function.
minput is used 2 define matrices as input for contouring or
list of values as input of curve or symbol plotting.
Args:
data (np.float64): 2D array, [nlat, nlon]
lon (np.float64): 1D vector, [nlon]
lat (np.float64): 1D vector, [nlat]
metadata (dictionary): variable name and units information,
like {'units': 'K', 'long_name': '2 metre temperature'}. Defaults to None.
"""
lat = np.squeeze(lat.astype(np.float64))
lon = np.squeeze(lon.astype(np.float64))
input_field_values = np.squeeze(data.astype(np.float64))
# put values into magics
return magics.minput(input_type="geographical",
input_field=input_field_values,
input_latitudes_list=lat,
input_longitudes_list=lon,
input_metadata=metadata)
def as_plottable(field, position=0, metadata=None, preproc=None):
# print('as_plottable', preproc)
if isinstance(field, str):
grib = macro.mgrib(grib_input_file_name=field,
grib_file_address_mode='byte_offset',
grib_field_position=position)
return grib, None, metadata, 'path'
if hasattr(field, 'path') and hasattr(field, 'offset') and hasattr(
field, 'area'):
grib = macro.mgrib(grib_input_file_name=field.path,
grib_file_address_mode='byte_offset',
grib_field_position=int(field.offset))
return grib, field.area, metadata, 'gridfield'
if isinstance(field, xr.DataArray):
if metadata is None:
metadata = {}
grib = {}
for k, v in field.attrs.items():
if k.startswith('GRIB_'):
grib[k[5:]] = str(v)
else:
metadata[k] = str(v)
# Only key GRIB
if grib:
metadata = grib
n, w, s, e = float(field.latitude[0]), float(
field.longitude[0]), float(field.latitude[-1]), float(
field.longitude[-1])
ns = float(field.latitude[1]) - float(field.latitude[0])
ew = float(field.longitude[1]) - float(field.longitude[0])
grib = macro.minput(
input_field=field.values,
input_field_initial_latitude=n,
input_field_latitude_step=ns,
input_field_initial_longitude=w,
input_field_longitude_step=ew,
input_metadata=metadata,
)
return grib, (n, w, s, e), metadata, 'xarray'
if hasattr(field, 'array'):
ew, ns = field.grid
n, w, s, e = field.area
if metadata is None:
metadata = field.metadata
if preproc:
f = preproc
else:
f = identity
grib = macro.minput(
input_field=f(field.array),
input_field_initial_latitude=float(n),
input_field_latitude_step=-float(ns),
input_field_initial_longitude=float(w),
input_field_longitude_step=float(ew),
input_metadata=metadata,
)
return grib, (n, w, s, e), metadata, 'bespoke'
if isinstance(field, np.ndarray):
class F:
def __init__(self, f):
self.array = f
self.grid = metadata['grid']
self.area = metadata['area']
return as_plottable(F(field), metadata=metadata, preproc=preproc)
if isinstance(field, list):
if isinstance(position, list):
return [
as_plottable(f, p, metadata)
for (f, p) in zip(field, position)
]
else:
return [as_plottable(f, 0, metadata) for f in field]
raise ValueError("Cannot plot %s" % (type(field), ))
def plot_to_file(field,
file,
size=10.,
projection=None,
contour=None,
grid=True,
title=True,
title_text='Title',
width=400,
ratio=1.0,
area=None,
metadata=None,
text_format='(automatic)',
position=0,
format=None,
preproc=None,
legend=False,
boxes=[]):
plottable = as_plottable(field, position, metadata, preproc)
if isinstance(plottable, list):
_, in_file_area, metadata, what = plottable[0]
grib = [g[0] for g in plottable]
else:
grib, in_file_area, metadata, what = plottable
# print("XXXX PLOT", what, "metadata =>", metadata,
# "contour => ", contour,
# "area =>", area)
if projection is None:
if area is None:
area = in_file_area
if area:
n, w, s, e = area
projection = macro.mmap(subpage_upper_right_longitude=float(e),
subpage_upper_right_latitude=float(n),
subpage_lower_left_latitude=float(s),
subpage_lower_left_longitude=float(w),
subpage_map_projection='cylindrical')
else:
projection = macro.mmap(subpage_map_projection='cylindrical')
if isinstance(projection, str):
projection = PROJECTIONS[projection]
contour = make_contour(contour, legend)
if isinstance(grib, list) and not isinstance(contour, list):
contour = [contour] * len(grib)
base, ext = os.path.splitext(file)
if format is None:
format = ext[1:]
output = macro.output(output_formats=[format],
output_name_first_page_number='off',
page_x_length=float(size),
page_y_length=float(size) * ratio,
super_page_x_length=float(size),
super_page_y_length=float(size) * ratio,
subpage_x_length=float(size),
subpage_y_length=float(size) * ratio,
subpage_x_position=0.,
subpage_y_position=0.,
output_width=width,
page_frame='on',
page_id_line='off',
output_name=base)
foreground = macro.mcoast(map_grid=ONOFF[grid], map_label='off')
background = macro.mcoast(map_grid=ONOFF[grid],
map_grid_colour='tan',
map_label='off',
map_coastline_land_shade='on',
map_coastline_land_shade_colour='cream',
map_coastline_colour='tan')
data = []
data.append(background)
if isinstance(grib, list):
for g, c in zip(grib, contour):
data.append(g)
data.append(c)
else:
data.append(grib)
data.append(contour)
data.append(foreground)
bb = float(len(boxes) + 1)
for i, b in enumerate(boxes):
inc = 0.1
n, w, s, e = b
a = np.ones(((e - w + inc) / inc - 2, ((n - s + inc) / inc) - 2))
a = np.pad(a, 1, 'constant', constant_values=0)
b = macro.minput(input_field=a,
input_field_initial_latitude=float(n),
input_field_latitude_step=-float(inc),
input_field_initial_longitude=float(w),
input_field_longitude_step=float(inc),
input_metadata={})
data.append(b)
# print a.shape
d = "rgba(1,0,0,%g)" % (i / bb)
c = macro.mcont(
contour="off",
contour_shade="on",
contour_shade_method="area_fill",
contour_shade_max_level_colour=d,
contour_shade_min_level_colour=d,
)
data.append(c)
if title:
data.append(macro.mtext())
if legend:
width = 1000
height = 200
width_cm = float(width) / 40.
height_cm = float(height) / 40.
output = macro.output(
output_formats=[format],
output_name_first_page_number='off',
# output_cairo_transparent_background='on',
output_width=width,
super_page_x_length=width_cm,
super_page_y_length=height_cm,
output_name=base,
subpage_frame=False,
page_frame=False,
page_id_line=False)
leg = macro.mlegend(legend_title="on",
legend_title_font_size=1.1,
legend_display_type="continuous",
legend_title_text=title_text,
legend_text_colour="charcoal",
legend_box_mode="positional",
legend_text_format=text_format,
legend_box_x_position=0.00,
legend_box_y_position=0.00,
legend_box_x_length=width_cm,
legend_box_y_length=height_cm,
legend_box_blanking="on",
legend_text_font_size="15%",
legend_border=False,
legend_border_colour="rgb(0.18,0.18,0.62)")
with LOCK:
# print(output, data[1], data[2], leg)
macro.plot(output, data[1], data[2], leg)
return
data.append(macro.page())
# print(output, projection, data)
with LOCK:
macro.plot(output, projection, data)
def minput_2d_vector(udata,
vdata,
lon,
lat,
skip=1,
metadata=None,
map_region=None):
"""
Put the data into magics minput function.
minput is used 2 define matrices as input for contouring or
list of values as input of curve or symbol plotting.
Args:
udata (np.array): 2D array, [nlat, nlon]
vdata (np.array): 2D array, [nlat, nlon]
lon (np.array): 1D vector, [nlon]
lat (np.array): 1D vector, [nlat]
skip (int, optional): grid skip point number. Defaults to 1.
metadata (dictionary): variable name and units information,
like {'units': 'm/s', 'long_name': 'wind field'}. Defaults to None.
map_region (list, optional): if set, the data will fit to the map_region.
[lonmin, lonmax, latmin, latmax]
"""
# check data
if udata is None or vdata is None:
return None
# extract values
lat = np.squeeze(lat.astype(np.float64)) # 1D vector
lon = np.squeeze(lon.astype(np.float64)) # 1D vector
uwind_field = np.squeeze(udata.astype(
np.float64)) # 2D array, [nlat, nlon]
vwind_field = np.squeeze(vdata.astype(
np.float64)) # 2D array, [nlat, nlon]
# check the latitude order (must be ascent for Magics plot)
if lat[0] > lat[1]:
lat = lat[::-1]
uwind_field = uwind_field[::-1, :]
vwind_field = vwind_field[::-1, :]
# cut the data region
if map_region is not None:
loni, lonj, lati, latj = grid_subset(lon, lat, map_region)
lon = lon[loni:lonj]
lat = lat[lati:latj]
uwind_field = uwind_field[lati:latj, loni:lonj]
vwind_field = vwind_field[lati:latj, loni:lonj]
lon, lat = np.meshgrid(lon, lat)
# skip values and flatten
uwind_field = uwind_field[::skip, ::skip].flatten()
vwind_field = vwind_field[::skip, ::skip].flatten()
lat = lat[::skip, ::skip].flatten()
lon = lon[::skip, ::skip].flatten()
# remove nan values
index = (~np.isnan(uwind_field)) & (~np.isnan(vwind_field))
uwind_field = uwind_field[index]
vwind_field = vwind_field[index]
if uwind_field.size == 0:
return None
lat = lat[index]
lon = lon[index]
# check meta information
if metadata is None:
metadata = {'units': 'm/s', 'long_name': 'wind field'}
# put into magics minput function
return magics.minput(input_type="geographical",
input_x_component_values=uwind_field,
input_y_component_values=vwind_field,
input_latitude_values=lat,
input_longitude_values=lon,
input_metadata=metadata)
steplat = -grib.grib_get(field, "jDirectionIncrementInDegrees")
firstlon = grib.grib_get(field, "longitudeOfFirstGridPointInDegrees")
steplon = grib.grib_get(field, "iDirectionIncrementInDegrees")
#Getting the field values
values = grib.grib_get_values(field).reshape(grib.grib_get(field, "Nj"),
grib.grib_get(field, "Ni"))
#Convert from Kelvin to Celsius
values = values
data = magics.minput(
input_field=values,
input_field_initial_latitude=firstlat,
input_field_latitude_step=steplat,
input_field_initial_longitude=firstlon,
input_field_longitude_step=steplon,
input_mars_metadata=json.dumps(metadata),
)
#Setting the field contour
contour = magics.mcont(contour_shade="on",
legend="on",
legend_display_type="continuous",
contour_highlight="off",
contour_shade_method="area_fill",
contour_shade_colour_direction="clockwise",
contour_shade_colour_method="calculate",
contour_shade_max_level_colour="red",
contour_shade_min_level_colour=" blue")
max_date = '2013-09-30 00:00:00'
min_max_dates = [min_date, max_date]
dis_thlow = 1.0
dis_thmed = 2.0
dis_thhigh = 3.0
dis_thextr = 4.0
lows = [dis_thlow, dis_thlow]
mediums = [dis_thmed, dis_thmed]
highs = [dis_thhigh, dis_thhigh]
extremes = [min(dis_thextr, max_y), min(dis_thextr, max_y)]
low_input = mag.minput(input_x_type='date',
input_date_x_values=min_max_dates,
input_date_x2_values=min_max_dates,
input_y_values=lows,
input_y2_values=mediums)
medium_input = mag.minput(input_x_type='date',
input_date_x_values=min_max_dates,
input_date_x2_values=min_max_dates,
input_y_values=mediums,
input_y2_values=highs)
high_input = mag.minput(input_x_type='date',
input_date_x_values=min_max_dates,
input_date_x2_values=min_max_dates,
input_y_values=highs,
input_y2_values=extremes)
def plot_in_magics_boxplot(path, date, pointname, var, meta, y_axis_range, filename, lead_times,\
data_percentiles_eu_eps, point_values_eu_det):
run_time = datetime.datetime(date['year'], date['month'], date['day'],
date['hour'])
if var == 't_2m' or var == 'wind_10m' or var == 'mslp' or var == 'clct':
lead_times = [-1.0 * x for x in lead_times]
elif var == 'prec_rate' or var == 'direct_rad' or var == 'diffuse_rad':
lead_times = [-1.0 * x for x in lead_times]
time_start = -123.
time_end = 3.
output_layout = magics.output(
output_formats=['png'],
output_name=path['base'] + path['plots'] + filename,
output_name_first_page_number='off',
output_width=1500,
super_page_x_length=15.0,
super_page_y_length=6.0,
)
page_layout = magics.page(
layout='positional',
page_x_position=0.0,
page_y_position=0.0,
page_x_length=15.0,
page_y_length=6.0,
page_id_line='off',
)
coord_system = magics.mmap(
subpage_map_projection='cartesian',
subpage_x_min=time_start,
subpage_x_max=time_end,
subpage_y_min=y_axis_range['min'],
subpage_y_max=y_axis_range['max'],
subpage_x_position=1.0,
subpage_y_position=0.48,
subpage_x_length=13.7,
subpage_y_length=5.0,
)
vertical_axis = magics.maxis(
axis_orientation='vertical',
axis_grid='on',
axis_tick_label_height=0.7,
axis_grid_thickness=1,
axis_grid_line_style='dash',
axis_tick_interval=y_axis_range['interval'],
)
horizontal_axis = magics.maxis(
axis_tick_interval=24,
axis_tick_label='off',
axis_title='off',
)
########################################################################
##### icon-eu-eps #####
bar_minmax_eu = magics.mgraph(
graph_type='bar',
graph_bar_colour='black',
graph_bar_width=0.05,
)
data_minmax_eu = magics.minput(
input_x_values=lead_times,
input_y_values=data_percentiles_eu_eps[:, 0],
input_y2_values=data_percentiles_eu_eps[:, 6],
)
bar1090_eu = magics.mgraph(
graph_type='bar',
graph_bar_colour='rgb(0, 150, 130)', # KIT turquoise
graph_bar_width=0.5,
)
data1090_eu = magics.minput(
input_x_values=lead_times,
input_y_values=data_percentiles_eu_eps[:, 1],
input_y2_values=data_percentiles_eu_eps[:, 5],
)
bar2575_eu = magics.mgraph(
graph_type='bar',
graph_bar_colour='rgb(0, 150, 130)', # KIT turquoise
graph_bar_width=1.0,
legend='on',
legend_user_text='<font colour="black"> ICON-EU-EPS (20km)</font>')
data2575_eu = magics.minput(
input_x_values=lead_times,
input_y_values=data_percentiles_eu_eps[:, 2],
input_y2_values=data_percentiles_eu_eps[:, 4],
)
bar_median_eu = magics.mgraph(
graph_type='bar',
graph_bar_colour='black',
graph_bar_width=1.0,
)
data_median_eu = magics.minput(
input_x_values=lead_times,
input_y_values=data_percentiles_eu_eps[:, 3] -
(y_axis_range['max'] - y_axis_range['min']) / 400.,
input_y2_values=data_percentiles_eu_eps[:, 3] +
(y_axis_range['max'] - y_axis_range['min']) / 400.,
)
##### icon-eu #####
bar_eu_det = magics.mgraph(
graph_line='off',
graph_symbol='on',
graph_symbol_marker_index=15,
graph_symbol_height=0.2,
graph_symbol_colour='white',
graph_symbol_outline='on',
graph_symbol_outline_colour='black',
graph_symbol_outline_thickness=3,
legend='on',
legend_user_text='<font colour="black"> ICON-EU-DET (6.5km)</font>')
data_eu_det = magics.minput(
input_x_values=lead_times,
input_y_values=point_values_eu_det[:],
)
########################################################################
analysis_line = magics.mgraph(
graph_line_colour='rgb(0, 242, 209)', # bright turquoise
graph_line_thickness=3,
legend='on',
legend_user_text=
'<font colour="black"> ICON-EU-DET (6.5km), 0h-Forecast</font>')
analysis_value = magics.minput(
input_x_values=[time_start, time_end],
input_y_values=[y_axis_range['analysis'], y_axis_range['analysis']])
if var == 't_2m' or var == 'mslp':
ref_th = 5
else:
ref_th = 0
ref_level_line = magics.mgraph(
graph_line_colour='black',
graph_line_thickness=ref_th,
)
ref_level_value = magics.minput(
input_x_values=[time_start, time_end],
input_y_values=[y_axis_range['ref'], y_axis_range['ref']])
########################################################################
if var == 'direct_rad' or var == 'diffuse_rad':
long_title_adjustment = 0.7
else:
long_title_adjustment = 0.0
title_str = '{} in {}'.format(meta['var'], pointname)
title = magics.mtext(
text_line_1=title_str,
text_font_size=1.0,
text_colour='black',
text_justification='centre',
text_mode='positional',
text_box_x_position=5.3 + long_title_adjustment,
text_box_y_position=5.45,
text_box_x_length=5.0,
text_box_y_length=0.7,
)
########################################################################
timeshift = get_timeshift()
initial_time = run_time.hour + timeshift
if timeshift == 1:
time_code = 'CET' # UTC+1
elif timeshift == 2:
time_code = 'CEST' # UTC+2
if var == 'prec_rate' or var == 'direct_rad' or var == 'diffuse_rad':
initial_time2 = initial_time + 6
if initial_time2 == 26:
initial_time2 = 2
init_time_str = 'Forecast time: {}, {:02}-{:02}{}'.format(\
run_time.strftime('%a., %d %b. %Y'), initial_time, initial_time2, time_code)
else:
init_time_str = 'Forecast time: {}, {:02}{}'.format(\
run_time.strftime('%a., %d %b. %Y'), initial_time, time_code)
init_time = magics.mtext(
text_line_1=init_time_str,
text_font_size=0.8,
text_colour='black',
text_justification='left',
text_mode='positional',
text_box_x_position=1.0,
text_box_y_position=5.45,
text_box_x_length=1.5,
text_box_y_length=0.5,
)
unit_str = meta['units']
unit = magics.mtext(
text_line_1=unit_str,
text_font_size=0.8,
text_colour='black',
text_justification='right',
text_mode='positional',
text_box_x_position=0.31,
text_box_y_position=5.55,
text_box_x_length=0.5,
text_box_y_length=0.5,
)
if var == 't_2m':
unit_special_str = 'o'
correction = -0.12
elif var == 'direct_rad' or var == 'diffuse_rad':
unit_special_str = '2'
correction = 0.06
else:
unit_special_str = ''
correction = 0
unit_special = magics.mtext(
text_line_1=unit_special_str,
text_font_size=0.4,
text_colour='black',
text_justification='right',
text_mode='positional',
text_box_x_position=0.31 + correction,
text_box_y_position=5.55 + 0.14,
text_box_x_length=0.5,
text_box_y_length=0.5,
)
logo = magics.mimport(
import_file_name=path['base'] + 'plots/logo/' + 'w2w_icon.png',
import_x_position=13.74,
import_y_position=5.52,
import_height=0.474,
import_width=1.000,
)
legend = magics.mlegend(
legend_text_font_size=0.8,
legend_box_mode='positional',
legend_box_x_position=5.0,
legend_box_y_position=5.03,
legend_box_x_length=9.0,
legend_box_y_length=0.5,
legend_entry_text_width=90,
)
time_labels = ['-120h', '-96h', '-72h', '-48h', '-24h', '0h']
spacing = 2.61
left_pos = 0.58
date1_label = magics.mtext(
text_line_1=time_labels[0],
text_font_size=0.8,
text_colour='black',
text_justification='centre',
text_mode='positional',
text_box_x_position=left_pos + 0 * spacing,
text_box_y_position=0.0,
text_box_x_length=1.5,
text_box_y_length=0.3,
text_border='off',
)
date2_label = magics.mtext(
text_line_1=time_labels[1],
text_font_size=0.8,
text_colour='black',
text_justification='centre',
text_mode='positional',
text_box_x_position=left_pos + 1 * spacing,
text_box_y_position=0.0,
text_box_x_length=1.5,
text_box_y_length=0.3,
text_border='off',
)
date3_label = magics.mtext(
text_line_1=time_labels[2],
text_font_size=0.8,
text_colour='black',
text_justification='centre',
text_mode='positional',
text_box_x_position=left_pos + 2 * spacing,
text_box_y_position=0.0,
text_box_x_length=1.5,
text_box_y_length=0.3,
text_border='off',
)
date4_label = magics.mtext(
text_line_1=time_labels[3],
text_font_size=0.8,
text_colour='black',
text_justification='centre',
text_mode='positional',
text_box_x_position=left_pos + 3 * spacing,
text_box_y_position=0.0,
text_box_x_length=1.5,
text_box_y_length=0.3,
text_border='off',
)
date5_label = magics.mtext(
text_line_1=time_labels[4],
text_font_size=0.8,
text_colour='black',
text_justification='centre',
text_mode='positional',
text_box_x_position=left_pos + 4 * spacing,
text_box_y_position=0.0,
text_box_x_length=1.5,
text_box_y_length=0.3,
text_border='off',
)
date6_label = magics.mtext(
text_line_1=time_labels[5],
text_font_size=0.8,
text_colour='black',
text_justification='centre',
text_mode='positional',
text_box_x_position=left_pos + 5 * spacing,
text_box_y_position=0.0,
text_box_x_length=1.5,
text_box_y_length=0.3,
text_border='off',
)
magics.context.silent = True
magics.plot(
output_layout,
page_layout,
coord_system,
vertical_axis,
horizontal_axis,
ref_level_value,
ref_level_line,
data_minmax_eu,
bar_minmax_eu,
data1090_eu,
bar1090_eu,
data2575_eu,
bar2575_eu,
data_median_eu,
bar_median_eu,
data_eu_det,
bar_eu_det,
analysis_value,
analysis_line,
title,
init_time,
unit,
unit_special,
logo,
legend,
date1_label,
date2_label,
date3_label,
date4_label,
date5_label,
date6_label,
)
return