def test_bad_format_file():
fig = simple_figure()
local_scope = PlotlyScope()
with pytest.raises(ValueError) as e:
local_scope.transform(fig, format='bogus')
e.match("Invalid format")
def test_missing_mapbox_token():
fig = mapbox_figure()
local_scope = PlotlyScope(mapbox_access_token=None)
with pytest.raises(ValueError) as e:
local_scope.transform(fig)
e.match("access token")
class Kaleido:
def __init__(self):
# Init scopes
if not STATIC_EXPORT:
raise ImportError(
"Static export is not possible due to missing dependencies")
self.plotly_scope = PlotlyScope()
def render_plotly_svg(self, fig, width=None, height=None):
"""
Function to render a plotly figure in SVG inside jupyter
"""
if STATIC_EXPORT:
svg_fig = self.plotly_scope.transform(fig,
format="svg",
width=width,
height=height)
return SVG(svg_fig)
def export_plotly_svg(self, fig, fn, width=None, height=None):
"""
Function to export a plotly figure to SVG
"""
if STATIC_EXPORT:
svg_fig = self.plotly_scope.transform(fig,
format="svg",
width=width,
height=height)
with open(fn, mode="wb") as fp:
fp.write(svg_fig)
def get_table_from_sheet(date):
month = date.strftime("%B")
result = SheetService().read_sheet_multiple(
SPREADSHEET_ID, [f'{month}!A2:C', f'{month}!E2:G', f'{month}!I2:K'],
major_dimension='COLUMNS')
values = result.get('valueRanges', [])
header = []
l_ = []
if len(values) > 0:
for val in values:
header = header + [item[0] for item in val['values']]
l_ = l_ + [i[1:] for i in val['values']]
scope = PlotlyScope()
fig = go.Figure(data=[
go.Table(columnwidth=[80, 150, 100, 80, 150, 100, 100, 100],
header=dict(values=header),
cells=dict(values=l_,
fill=dict(color=[
'lightgreen', 'lightgreen', 'lightgreen',
'#ff9982', '#ff9982', '#ff9982', '#ffbf70',
'#ffbf70'
]),
height=30))
])
test = scope.transform(fig, format="png", scale=2)
str_file = io.BytesIO(test)
return str_file
else:
return None
def save_static(self, figformat):
scope = PlotlyScope()
with open(self.path.replace('html', figformat), "wb") as f:
f.write(scope.transform(self.fig, format=figformat))
logging.info(
f"Saved {self.path.replace('.html', '')} as {figformat} (or png for --legacy)"
)
def generate(data, title: str, format: str = "svg") -> go.Figure:
datetimes = []
prices = []
for kp in data:
if kp['price'] is not None and kp['date'] is not None:
if type(kp['date']) != 'datetime':
dt = datetime.datetime.strptime(kp['date'], "%Y-%m-%d")
datetimes.append(dt)
else:
datetimes.append(kp['date'])
prices.append(kp['price'])
fig = go.Figure(
data = go.Scatter(x=datetimes, y=prices),
layout = dict(
title = dict(
text=title
)
)
)
scope = PlotlyScope()
img = scope.transform(fig, format=format)
# img = plotly.io.to_image(fig=fig, format=format)
return img
def _create_donut(df, lang, filename, width, height, fontsize):
scope = PlotlyScope()
sentiment = get_sentiment(df, lang)
labels, values = dict_to_list(sentiment)
if lang == "tr":
labels = ["Pozitif", "Nötr", "Negatif"]
if lang == "en":
labels = [label.capitalize() for label in labels]
colors = ["darkgreen", "lightgreen", "red"]
fig = go.Figure(data=[
go.Pie(labels=labels,
values=values,
hole=0.5,
textinfo="label+percent+value",
textposition="inside")
])
fig.update_traces(marker=dict(colors=colors),
textfont_size=fontsize,
showlegend=False)
fig.update_layout(margin=dict(l=0, r=0, b=0, t=0, pad=4),
paper_bgcolor="rgba(0,0,0,0)",
plot_bgcolor="rgba(0,0,0,0)",
width=width,
height=height)
fname_stamped = filename + "".join(str(time()).split("."))
donuts_filenames[filename] = "img/" + fname_stamped + ".svg"
with open(f"mint/static/img/{fname_stamped}.svg", "wb") as f:
f.write(scope.transform(fig, format="svg"))
def datauri_from_fig(fig,
fmt: str = "png",
width: int = 600,
height: int = 400,
scale: int = 4) -> str:
"""
Generate a data URI from a Plotly Figure.
:param fig: Plotly Figure object or corresponding dictionary
:param fmt: "png", "jpg", etc. (see PlotlyScope for supported formats)
:param width: width in pixels
:param height: height in pixels
:param scale: scale factor
:return:
"""
from kaleido.scopes.plotly import PlotlyScope
scope = PlotlyScope()
output = scope.transform(fig,
format=fmt,
width=width,
height=height,
scale=scale)
image = b64encode(output).decode("ascii")
return f"data:image/{fmt};base64,{image}"
def test_plotlyjs_file_url():
fig = simple_figure()
plotlyjs_url = local_plotlyjs_url
local_scope = PlotlyScope(plotlyjs=plotlyjs_url)
result = local_scope.transform(fig, format='png', width=700, height=500, scale=1)
expected = load_baseline('simple', 'png')
assert result == expected
def save_fig(date_str, new=True):
'''Saves either new/total plot for a given date YYYY-MM-DD
as a .png file.'''
if new:
kind = 'new'
else:
kind = 'total'
fig = create_fig(date_str, new)
scope = PlotlyScope()
with open(f'{kind}_cases/{date_str}_{kind}_cases.png', 'wb') as f:
f.write(scope.transform(fig, format='png'))
def boxplot(dataset, title, render="colab", filename='figure.png'):
fig = go.Figure()
fig.add_trace(
go.Box(x=dataset,
name=str(title),
fillcolor=L_BLUE_BOX,
marker_color=L_YELOW,
marker_size=10,
line_width=1.5,
boxmean=True))
fig.update_layout(height=250,
paper_bgcolor=COLAB_BKGROUND,
font={'color': ORANGE},
margin={
'l': 50,
't': 5,
'b': 30
},
plot_bgcolor=PLOT_BKGROUND,
xaxis={
'gridcolor': BLACK_GRID,
'zerolinecolor': BLACK_GRID
},
yaxis={
'autorange': True,
'showgrid': True,
'zeroline': True,
'dtick': 5,
'gridcolor': BLACK_GRID,
'gridwidth': 1,
'zerolinecolor': BLACK_GRID,
'zerolinewidth': 4
},
showlegend=False,
hovermode='x',
hoverlabel=dict(bgcolor=PLOT_BKGROUND,
font_size=14,
font_family="verdana"))
if render == 'png':
scope = PlotlyScope()
with open(filename, "wb") as f:
f.write(scope.transform(fig, format="png"))
display(Image(filename=filename))
else:
fig.show()
def plot_meter(value,
reference=10,
render="colab",
filename='figure.png',
title='Error medio'):
'''Medidor tipo `barra horizontal` de una sola magnitud'''
fig = go.Figure(
go.Indicator(mode="number+gauge+delta",
gauge={
'shape': "bullet",
'bgcolor': PLOT_BKGROUND,
'bar': {
'color': L_GREEN
}
},
align='center',
value=value,
delta={'reference': reference},
domain={
'x': [0, 1],
'y': [0, 1]
},
title={
'text': "<b style = 'color: " + ORANGE + ";'>" +
title + "</b>",
'font': {
"size": 18
}
}))
fig.update_layout(height=50,
paper_bgcolor=COLAB_BKGROUND,
font={'color': ORANGE},
margin={
'l': 150,
't': 0,
'b': 0
})
if render == 'png':
scope = PlotlyScope()
with open(filename, "wb") as f:
f.write(scope.transform(fig, format="png"))
display(Image(filename=filename))
else:
fig.show()
def plot_pattcorr(PC, labels, plotpath, lats, latn):
"""
Plot pattern correlation curves as a function of lead time.
:param PC:
:type PC:
:param labels:
:type labels:
:param plotpath:
:type plotpath:
:param region:
:type region: str
:return:
:rtype:
"""
latstring = get_latstring(lats, latn)
plttype = "png"
plotname = plotpath + "PatternCorrelationHovmoeller." + plttype
nlines = len(labels)
colors = ['black', 'dodgerblue', 'orange', 'seagreen', 'firebrick']
scope = PlotlyScope()
fig = go.Figure()
for ll in np.arange(0, nlines):
fig.add_trace(
go.Scatter(x=PC['fchrs'],
y=PC[:, ll],
mode='lines',
name=labels[ll],
line=dict(color=colors[ll], width=2)))
fig.update_layout(title=latstring)
fig.update_xaxes(ticks="", tick0=0, dtick=24, title_text='lead time (h)')
fig.update_yaxes(ticks="",
range=[0, 1],
dtick=0.1,
title_text='correlation')
with open(plotname, "wb") as f:
f.write(scope.transform(fig, format=plttype))
def plot_activity(act, wavename, labels, plotpath, fchr=[]):
"""
Plot pattern correlation curves as a function of lead time.
:param act:
:type act:
:param labels:
:type labels:
:return:
:rtype:
"""
plttype = "png"
plotname = plotpath + wavename + "Activity." + plttype
if fchr:
plotname = plotpath + wavename + "Activity_f" + f"{fchr:03d}" + "." + plttype
nlines, ntim = act.shape
timestr = get_timestr(act['time'])
colors = ['black', 'dodgerblue', 'orange', 'seagreen', 'firebrick']
scope = PlotlyScope()
fig = go.Figure()
for ll in np.arange(nlines):
fig.add_trace(
go.Scatter(x=timestr,
y=act[ll, :].values,
mode='lines',
name=labels[ll],
line=dict(color=colors[ll], width=2)))
fig.update_layout(title=wavename + " FH" + f"{fchr:03d}",
yaxis=dict(range=[0, 25]))
#fig.update_xaxes(ticks="", tick0=0, dtick=12, title_text='date')
fig.update_yaxes(ticks="", tick0=0, dtick=1., title_text='activity')
with open(plotname, "wb") as f:
f.write(scope.transform(fig, format=plttype))
def _create_timeviz_donut(df, lang, filename, width, height, fontsize, metric):
# Template function for creating donut graphs based on time segments
# For more info about time segments, check time_utils.py
scope = PlotlyScope()
labels, values = None, None
if metric not in ["weekdays", "hours"]:
raise ValueError("weekdays and hours are available time viz metrics")
if metric == "weekdays" and lang not in ["tr", "en"]:
raise ValueError("parameter lang should be either en or tr")
if metric == "weekdays":
scores = get_weekdays_score(df)
labels, values = dict_to_list(scores)
if lang == "tr":
labels = ["Hafta içi", "Hafta sonu"]
if lang == "en":
labels = [label.capitalize() for label in labels]
if metric == "hours":
scores = get_hours_score(df)
labels, values = dict_to_list(scores)
labels = [
"00:00 - 06:59", "07:00 - 12:59", "13:00 - 17:59", "18:00 - 23:59"
]
fig = go.Figure(data=[
go.Pie(labels=labels,
values=values,
hole=0.5,
textinfo="label+percent+value",
textposition="inside")
])
fig.update_traces(textfont_size=fontsize, showlegend=False)
fig.update_layout(margin=dict(l=0, r=0, b=0, t=0, pad=4),
paper_bgcolor="rgba(0,0,0,0)",
plot_bgcolor="rgba(0,0,0,0)",
width=width,
height=height)
fname_stamped = filename + "".join(str(time()).split("."))
timeviz_filenames[filename] = "img/" + fname_stamped + ".svg"
with open(f"mint/static/img/{fname_stamped}.svg", "wb") as f:
f.write(scope.transform(fig, format="svg"))
def plot_skill(skill, wavename, labels, plotpath):
"""
Plot pattern correlation curves as a function of lead time.
:param skill:
:type skill:
:param labels:
:type labels:
:return:
:rtype:
"""
plttype = "png"
plotname = plotpath + wavename + "Skill." + plttype
nfchr, nlines = skill.shape
colors = ['dodgerblue', 'orange', 'seagreen', 'firebrick']
scope = PlotlyScope()
fig = go.Figure()
for ll in np.arange(nlines):
fig.add_trace(
go.Scatter(x=skill['fchrs'],
y=skill[:, ll],
mode='lines',
name=labels[ll],
line=dict(color=colors[ll], width=2)))
fig.update_layout(title=wavename + " skill", yaxis=dict(range=[0, 1]))
fig.update_xaxes(ticks="", tick0=0, dtick=24, title_text='lead time (h)')
fig.update_yaxes(ticks="",
tick0=0,
dtick=0.1,
title_text='skill correlation')
with open(plotname, "wb") as f:
f.write(scope.transform(fig, format=plttype))
def test_figure_size():
# Create mocked scope
scope = PlotlyScope()
transform_mock = Mock(return_value={"code": 0, "result": "image"})
scope._perform_transform = transform_mock
# Set defualt width / height
scope.default_width = 543
scope.default_height = 567
scope.default_format = "svg"
scope.default_scale = 2
# Make sure default width/height is used when no figure
# width/height specified
transform_mock.reset_mock()
fig = go.Figure()
scope.transform(fig)
transform_mock.assert_called_once_with(fig.to_dict(),
format="svg",
scale=2,
width=543,
height=567)
# Make sure figure's width/height takes precedence over defaults
transform_mock.reset_mock()
fig = go.Figure().update_layout(width=123, height=234)
scope.transform(fig)
transform_mock.assert_called_once_with(fig.to_dict(),
format="svg",
scale=2,
width=123,
height=234)
# Make sure kwargs take precedence over Figure layout values
transform_mock.reset_mock()
fig = go.Figure().update_layout(width=123, height=234)
scope.transform(fig, width=987, height=876)
transform_mock.assert_called_once_with(fig.to_dict(),
format="svg",
scale=2,
width=987,
height=876)
def main():
# Calcular parâmetros iniciais fixos da tubeira
v_test_rad, v_test_deg = v(M_TEST)
A_test_ratio = A_ratio(M_TEST)
theta_1_rad, theta_1_deg = empirical_theta_1(v_test_rad, A_test_ratio)
v_1_rad = v_test_rad - theta_1_rad
v_1_deg = v_test_deg - theta_1_deg
M_1 = M_from_v(v_1_rad)
# Determinar coordenadas depois do ponto de inflexão, utilizando o método de Foelsch
x_final_curve, y_final_curve = foelsch(Y_0, theta_1_rad, v_1_rad,
v_test_rad, M_1)
y_1 = y_final_curve[0]
# Determinar coordenadas antes do ponto de inflexão
x_initial_curve, y_initial_curve = initial_curve(Y_0, y_1, theta_1_rad)
np.savetxt("nozzle_x.csv",
np.concatenate([x_initial_curve, x_final_curve]),
fmt='%s',
delimiter=";")
np.savetxt("nozzle_y.csv",
np.concatenate([y_initial_curve, y_final_curve]),
fmt='%s',
delimiter=";")
# Plotar resultados
fig, ax = plt.subplots()
ax.plot(x_initial_curve, y_initial_curve, 'r-')
ax.plot(x_initial_curve, -y_initial_curve, 'r-')
ax.plot(x_final_curve, y_final_curve, 'r-')
ax.plot(x_final_curve, -y_final_curve, 'r-')
ax.plot(x_initial_curve, np.zeros(x_initial_curve.shape), 'k--')
ax.plot(x_final_curve, np.zeros(x_final_curve.shape), 'k--')
ax.set_title("")
ax.set_xlabel("")
ax.set_ylabel("")
plt.xlim(x_initial_curve[0], x_final_curve[-1] * 1.05)
plt.ylim(-y_final_curve[-1] * 2, y_final_curve[-1] * 2)
plt.show()
throat_index = np.where(y_initial_curve == 10)[0][0]
# Quasi Unidimensional
graph_y_points = list(
float_range(0, 200,
max(y_final_curve) / len(y_final_curve)))
mach_matriz = []
for i in range(len(graph_y_points)):
mach_matriz.append(
add_line_on_quasi_graph(
graph_y_points[i],
np.concatenate([y_initial_curve[throat_index:],
y_final_curve]),
len(
np.concatenate(
[x_initial_curve[throat_index:], x_final_curve]))))
# Espelhar resultados de Mach e pontos de y
mirror = mach_matriz[::-1]
mirror_y = [-x for x in graph_y_points[::-1]]
scope = PlotlyScope()
fig_quasi_unidimensional = make_subplots(rows=1, cols=1)
fig_quasi_unidimensional.add_trace(
go.Heatmap(z=mirror + mach_matriz,
x=np.concatenate(
[x_initial_curve[throat_index:], x_final_curve]),
y=mirror_y + graph_y_points,
colorbar=dict(title='Mach', titleside='right'),
connectgaps=True,
zsmooth='best'), 1, 1)
fig_quasi_unidimensional.update
fig_quasi_unidimensional.update_yaxes(title_text="Y axis (mm)",
row=1,
col=1)
fig_quasi_unidimensional.update_xaxes(title_text="X axis (mm)",
row=1,
col=1)
with open("quasi_unidimensional_graph.png", "wb") as f:
f.write(scope.transform(fig_quasi_unidimensional, format="png"))
def hovmoeller(data,
lon,
time,
datestrt,
datelast,
plotpath,
lats,
latn,
spd,
source,
pltvarname,
lev=[],
cmin=[],
cmax=[],
cspc=[]):
"""
Main driver for plotting Hovmoeller diagrams.
:param data: input data, should be (time, lon)
:type data: numeric
:param lon: longitude coordinate of data
:type lon: float
:param time: time coordinate of data
:type time: datetime
:param datestrt: start date for Hovmoeller, used in plot file name
:type datestrt: str
:param datelast: end date for Hovmoeller, used in plot file name
:type datelast: str
:param plotpath: path for saving the figure
:type plotpath: str
:param lats: southern latitude limit of the average
:type lats: float
:param latn: northern latitude limit of the average
:type latn: float
:param spd: number of observations per day
:type spd: int
:param source: source of the data, e.g. (ERAI, TRMM, ...), used in plot file name
:type source: str
:param pltvarname: name of variable to be plotted
:type pltvarname: str
:param lev: vertical level of data (optional)
:type lev: str
:param cmin: contour level minimum (optional)
:type cmin: float
:param cmax: contour level maximum (optional)
:type cmax: float
:param cspc: contour spacing (optional)
:type cspc: float
:return: none
:rtype: none
"""
"""
Set plot type and plot file name.
"""
plttype = "png"
plotname = plotpath + "Hovmoeller_" + source + pltvarname + lev + "_" + str(
datestrt) + "-" + str(datelast) + "." + plttype
"""
Set plot resources: colormap, time string, contour levels, latitude band string
"""
cmap_rgb = hov_resources(pltvarname)
timestr = get_timestr(time)
if (not cmin) or (not cmax) or (not cspc):
cmin, cmax, cspc = get_clevels(pltvarname)
latstring = get_latstring(lats, latn)
"""
Generate the Hovmoeller plot.
"""
scope = PlotlyScope()
fig = go.Figure()
fig.add_trace(
go.Contour(z=data.values,
x=lon,
y=timestr,
colorscale=cmap_rgb,
contours=dict(start=cmin,
end=cmax,
size=cspc,
showlines=False),
colorbar=dict(title=data.attrs['units'],
len=0.6,
lenmode='fraction')))
fig.update_layout(title=source + " " + pltvarname + lev,
width=600,
height=900,
annotations=[
go.layout.Annotation(x=300,
y=timestr[5],
xref="x",
yref="y",
text=latstring,
showarrow=False,
bgcolor="white",
opacity=0.9,
font=dict(size=16))
])
fig.update_xaxes(ticks="inside", tick0=0, dtick=30, title_text='longitude')
fig.update_yaxes(autorange="reversed", ticks="inside", nticks=11)
with open(plotname, "wb") as f:
f.write(scope.transform(fig, format=plttype))
return
from kaleido.scopes.plotly import PlotlyScope
import plotly.graph_objects as go
scope = PlotlyScope()
fig = go.Figure(data=[go.Scatter(y=[1, 3, 2])])
with open("figure.png", "wb") as f:
f.write(scope.transform(fig, format="png"))
def plot_vertcoh(coh,
px,
py,
levels,
labels,
titlestr,
plotname,
plotpath,
lats,
latn,
xlim=[0, 0.5]):
"""
Plot averaged coherence and phase values by level.
:param coh: Averaged coherence values. nvar x nlevels
:param px: Averaged phase angle (x-component) values. nvar x nlevels
:param py: Averaged phase angle (y-component) values. nvar x nlevels
:param levels: Vertical level coordinate.
:param labels: Labels for each variable, should include variable and symm/ anti-symm tag.
:param titlestr: Title for the plot, should include CCEW/ MJO tag and variable name for var1 (usually precip).
:param plotname: Name for the plot to be saved under.
:param plotpath: Path for the plot to be saved at.
:param lats: Southern latitude value the spectra were averaged over.
:param latn: Northern latitude value the spectra were averaged over.
:param xlim: optional parameter specifying the maximum coherence value on the x-axis
:return:
"""
# compute phase angle (in degrees) from x-y components.
angcnst = 1.
angle = np.arctan2(angcnst * px, py) * 180 / np.pi
print(np.min(angle), np.max(angle))
# latitude string for plot title
latstring = get_latstring(lats, latn)
# set up plotname for saving
plttype = "png"
plotname = plotpath + plotname + "." + plttype
# plot
nlines = len(labels)
colors = ['firebrick', 'black', 'orange', 'dodgerblue', 'seagreen']
symbols = ['circle', 'square', 'diamond', 'x', 'triangle-up']
scope = PlotlyScope()
fig = make_subplots(rows=1,
cols=2,
shared_yaxes=True,
horizontal_spacing=0.04)
for ll in np.arange(0, nlines):
fig.add_trace(go.Scatter(x=coh[ll, :],
y=levels,
mode='lines',
name=labels[ll],
line=dict(color=colors[ll], width=2)),
row=1,
col=1)
fig.add_trace(go.Scatter(x=angle[ll, :],
y=levels,
mode='markers',
showlegend=False,
marker=dict(color=colors[ll],
size=8,
symbol=symbols[ll])),
row=1,
col=2)
fig.add_annotation(x=-90,
y=50,
xref="x2",
yref="y2",
text="precip lags",
showarrow=False,
bgcolor="white",
opacity=0.8)
fig.add_annotation(x=90,
y=50,
xref="x2",
yref="y2",
text="precip leads",
showarrow=False,
bgcolor="white",
opacity=0.8)
fig.update_layout(title=titlestr + ' ' + latstring,
width=900,
height=600,
legend=dict(yanchor="bottom",
y=0.01,
xanchor="left",
x=0.01))
fig.update_xaxes(title_text='coh^2',
range=[xlim[0], xlim[1]],
row=1,
col=1)
fig.update_xaxes(title_text='phase angle',
range=[-180, 180],
dtick=90,
row=1,
col=2)
fig.update_yaxes(range=[100, 1000],
dtick=100,
title_text='hPa',
autorange="reversed",
row=1,
col=1)
fig.update_yaxes(range=[100, 1000],
dtick=100,
autorange="reversed",
row=1,
col=2)
with open(plotname, "wb") as f:
f.write(scope.transform(fig, format=plttype))
return
def plot_vertcoh_panel(ds_plot,
labels,
titlestr,
plotname,
plotpath,
lats,
latn,
xlim=[0, 0.5]):
"""
Panel plot of averaged coherence and phase values by level.
:param ds_plot: xarray dataset containing the data to plot. This includes nplot as an attribute and
the source names and forecast hours. The
:param labels: Labels for each variable, should include variable and symm/ anti-symm tag.
:param titlestr: Title for the plot, should include CCEW/ MJO tag and variable name for var1 (usually precip).
:param plotname: Name for the plot to be saved under.
:param plotpath: Path for the plot to be saved at.
:param lats: Southern latitude value the spectra were averaged over.
:param latn: Northern latitude value the spectra were averaged over.
:param xlim: optional parameter specifying the maximum coherence value on the x-axis
:return:
"""
# sources1 = ds_plot['sources1']
# sources2 = ds_plot['sources2']
nplot = int(ds_plot.attrs['nplot'])
varnames = list(ds_plot.data_vars)
sourcenames = ds_plot.attrs["sourcenames"]
titles = []
for name in sourcenames:
titles.append(name)
titles.append('')
abcstrings = list(string.ascii_lowercase)
# compute phase angle (in degrees) from x-y components.
angcnst = 1.
# latitude string for plot title
latstring = get_latstring(lats, latn)
# set up plotname for saving
plttype = "png"
plotname = plotpath + plotname + "." + plttype
# plot
nlines = len(labels)
colors = ['firebrick', 'black', 'orange', 'dodgerblue', 'seagreen']
symbols = ['circle', 'square', 'diamond', 'x', 'triangle-up']
ncols = 4
nrows = int(np.ceil(nplot / 2))
scope = PlotlyScope()
fig = make_subplots(rows=nrows,
cols=ncols,
shared_yaxes=True,
horizontal_spacing=0.04,
vertical_spacing=0.04,
subplot_titles=titles)
for pp in np.arange(0, nrows):
coh = ds_plot[varnames[pp * nplot]]
try:
levels = coh['plev']
except KeyError:
levels = coh['level']
px = ds_plot[varnames[pp * nplot + 1]]
py = ds_plot[varnames[pp * nplot + 2]]
angle = np.arctan2(angcnst * px, py) * 180 / np.pi
for ll in np.arange(0, nlines):
if pp == 0:
fig.add_trace(go.Scatter(x=coh[ll, :],
y=levels,
mode='lines',
name=labels[ll],
line=dict(color=colors[ll], width=2)),
row=pp + 1,
col=1)
else:
fig.add_trace(go.Scatter(x=coh[ll, :],
y=levels,
mode='lines',
name=labels[ll],
showlegend=False,
line=dict(color=colors[ll], width=2)),
row=pp + 1,
col=1)
fig.add_trace(go.Scatter(x=angle[ll, :],
y=levels,
mode='markers',
showlegend=False,
marker=dict(color=colors[ll],
size=8,
symbol=symbols[ll])),
row=pp + 1,
col=2)
coh = ds_plot[varnames[pp * nplot + int(np.ceil(nplot / 2))]]
try:
levels = coh['plev']
except KeyError:
levels = coh['level']
px = ds_plot[varnames[pp * nplot + int(np.ceil(nplot / 2)) + 1]]
py = ds_plot[varnames[pp * nplot + int(np.ceil(nplot / 2)) + 2]]
angle = np.arctan2(angcnst * px, py) * 180 / np.pi
for ll in np.arange(0, nlines):
fig.add_trace(go.Scatter(x=coh[ll, :],
y=levels,
mode='lines',
showlegend=False,
name=labels[ll],
line=dict(color=colors[ll], width=2)),
row=pp + 1,
col=3)
fig.add_trace(go.Scatter(x=angle[ll, :],
y=levels,
mode='markers',
showlegend=False,
marker=dict(color=colors[ll],
size=8,
symbol=symbols[ll])),
row=pp + 1,
col=4)
for i in np.arange(2, nrows * ncols + 1, 2):
istr = str(i)
fig.add_annotation(x=-90,
y=50,
xref="x" + istr,
yref="y" + istr,
text="precip lags",
showarrow=False,
bgcolor="white",
opacity=0.8)
fig.add_annotation(x=90,
y=50,
xref="x" + istr,
yref="y" + istr,
text="precip leads",
showarrow=False,
bgcolor="white",
opacity=0.8)
for i in np.arange(1, nrows * ncols + 1):
if i % 2 == 0:
xpos = -180
else:
xpos = xlim[0]
fig.add_annotation(x=xpos,
y=50,
xref="x" + str(i),
yref="y" + str(i),
text=abcstrings[i - 1],
showarrow=False,
bgcolor="white",
opacity=0.8)
fig.update_layout(title=titlestr + ' ' + latstring,
width=1800,
height=1800,
legend=dict(yanchor="bottom",
y=0.45,
xanchor="left",
x=0.15))
for j in np.arange(1, ncols, 2):
fig.update_xaxes(title_text='coh^2',
range=[xlim[0], xlim[1]],
row=nrows,
col=j)
fig.update_xaxes(title_text='phase angle',
range=[-180, 180],
dtick=90,
row=nrows,
col=(j + 1))
for i in range(nrows - 1):
fig.update_xaxes(range=[xlim[0], xlim[1]], row=(i + 1), col=j)
fig.update_xaxes(range=[-180, 180],
dtick=90,
row=(i + 1),
col=(j + 1))
for i in range(nrows):
fig.update_yaxes(range=[100, 1000],
dtick=100,
title_text='hPa',
autorange="reversed",
row=(i + 1),
col=1)
for j in np.arange(2, ncols + 1):
fig.update_yaxes(range=[100, 1000],
dtick=100,
autorange="reversed",
row=(i + 1),
col=j)
with open(plotname, "wb") as f:
f.write(scope.transform(fig, format=plttype))
return
def save_static(self):
scope = PlotlyScope()
with open(self.path.replace('html', 'png'), "wb") as f:
f.write(scope.transform(self.fig, format="png"))
df["timestamp"] = df["timestamp"].transform(lambda x: x - 25000)
df = df[df["timestamp"] >= 0]
fig = px.line(df,
x="timestamp",
y="net.packets_sent.ib0",
color="config",
line_group="iteration",
template=template,
labels={
"timestamp": "time (ms)",
"net.packets_sent.ib0": "packets sent",
"config": "Dyconit configuration"
})
with open(str(output_dir.joinpath("packets_over_time.pdf")), "wb") as f:
f.write(scope.transform(fig, format="pdf"))
df = df.groupby(["iteration", "config"], as_index=False).max()
df["packets_per_second"] = df["net.packets_sent.ib0"] / (df["timestamp"] /
1000)
fig = px.box(df,
x="config",
y="packets_per_second",
template=template,
labels={
"config": "Dyconit policy",
"packets_per_second": "packets per second"
})
with open(str(output_dir.joinpath("packets_per_second_over_policy.pdf")),
"wb") as f:
f.write(scope.transform(fig, format="pdf"))
