def tanks(instance, qnlp, volnlp, volconv=None):
fig, axs = plt.subplots(nrows=len(instance.tanks),
ncols=1,
sharex=True,
figsize=(8, len(instance.tanks) * 1.5))
if len(instance.tanks) == 1:
axs = [axs]
ax2 = []
x = instance.periods[:-1]
bar_width = x[1] - x[0]
for n, (j, tk) in enumerate(instance.tanks.items()):
inflow = [
sum(max(0, qt[a]) for a in instance.inarcs(j)) -
sum(min(0, qt[a]) for a in instance.outarcs(j))
for t, qt in qnlp.items()
]
ouflow = [
sum(min(0, qt[a]) for a in instance.inarcs(j)) -
sum(max(0, qt[a]) for a in instance.outarcs(j))
for t, qt in qnlp.items()
]
axs[n].bar(x,
inflow,
bar_width,
alpha=0.3,
align='edge',
color='#557f2d',
label='inflow in $m^3/h$')
axs[n].bar(x,
ouflow,
bar_width,
alpha=0.3,
align='edge',
color='#7f6d5f',
label='outflow in $m^3/h$')
#plt.tick_params(axis='x', which='both', labelbottom='off')
axs[n].set_ylabel(j,
bbox=dict(fc='DarkOrange', pad=3, alpha=0.2),
fontsize=12)
#plt.xlim([instance.periods[0], instance.periods[-1]])
mini = min(ouflow)
maxi = max(inflow)
axs[n].set_ylim(mini * 1.2, maxi * 1.2)
axs[n].set_yticks([round(mini), 0, round(maxi)])
ax2.append(axs[n].twinx())
hwaternlp = [vol[j] / tk.surface for vol in volnlp]
ax2[n].plot(instance.periods,
hwaternlp,
'DarkOrange',
linestyle='-',
linewidth=3,
label='real water height in $m$')
hwatermin = tk.vmin / tk.surface
hwatermax = tk.vmax / tk.surface
ax2[n].fill_between(instance.periods,
hwatermin,
hwatermax,
color='DarkOrange',
alpha=0.2)
#plt.plot(instance.periods, hwatermin, 'black', linestyle='-', linewidth=2)
#plt.plot(instance.periods, hwatermax, 'black', linestyle='-', linewidth=2)
ax2[n].tick_params(axis='y', colors='DarkOrange')
ax2[n].yaxis.label.set_color('DarkOrange')
ax2[n].set_ylim(hwatermin - 2, hwatermax + 2)
ax2[n].set_yticks([round(hwatermin, 1), round(hwatermax, 1)])
# mini = np.floor(hwatermin * 2) / 2.
# maxi = np.floor(hwatermax * 2) / 2. + 0.5
# if maxi - mini > 2:
# ec = int(maxi - mini)
# gap = 2
# else:
# ec = int((maxi - mini) / 0.5)
# gap = 0.5
# ax2[n].set_yticks([mini + gap * r for r in range(ec + 1)])
# ax2[n].set_ylim(mini - gap, maxi + gap)
if n == len(instance.tanks) - 1:
axs[n].legend(ncol=2, bbox_to_anchor=(0.67, 6.5))
ax2[n].legend(ncol=1, bbox_to_anchor=(1.1, 6.5))
locator = mdates.AutoDateLocator(minticks=3, maxticks=7)
formatter = mdates.ConciseDateFormatter(locator)
axs[-1].xaxis.set_major_locator(locator)
axs[-1].xaxis.set_major_formatter(formatter)
axs[-1].set_xlim([instance.periods[0], instance.periods[-1]])
#plt.tight_layout()
plt.show()
def plotBeam(inFname, bm, radarCode, tlim=None, rlim=None):
times, rg, pwr, vel, tfreq, rsep, gflg = loadBeam(inFname, bm)
if not tlim:
tlim = [times.min(), times.max()]
plt.style.use('dark_background')
plt.rcParams.update({'font.size': 18})
fig, (ax1, ax2) = plt.subplots(nrows=2,
figsize=(16, 9),
gridspec_kw={'height_ratios': [1, 4]})
plt.suptitle('%s Beam %i' % (radarCode.split('.')[0].upper(), bm))
"""
1. narrow frequency plot
"""
ax1.plot(times, tfreq / 1E3, '.')
ax1.set_xlim(tlim)
ax1.set_ylim([8, 20])
ax1.set_ylabel('Tx Freq. (MHz)')
ax1.xaxis.set_major_formatter(plt.NullFormatter())
ax1.xaxis.set_ticks_position('none')
"""
2. Velocity plot, not yet with alpha = power
"""
locator = mdates.AutoDateLocator(minticks=3, maxticks=7)
formatter = mdates.ConciseDateFormatter(locator)
ax2.xaxis.set_major_locator(locator)
ax2.xaxis.set_major_formatter(formatter)
# define limits
if not rlim:
rlim = [rg.min(), rg.max()]
tlim_hr = [dn_to_dechr(tlim[0]), dn_to_dechr(tlim[1])]
# define scale, with white at zero
colormap = 'bwr' #'bwr'
cmap = plt.get_cmap(colormap)
norm = plt.Normalize(-1000, 1000)
vel = vel.T
gflg = gflg.T
# regrid the data
times_bnd = []
t = tlim[0]
while t <= tlim[1]:
times_bnd.append(t)
t += dt.timedelta(seconds=5)
times_bnd = np.array(times_bnd)
vel_gridded = np.ones((len(times_bnd) - 1, len(rg)))
gflg_gridded = np.ones((len(times_bnd) - 1, len(rg)))
fn = interp1d(to_float(times, times[0]), vel[0, :])
for ind in range(len(rg)):
fn.y = vel[ind, :]
vel_gridded[:, ind] = fn(to_float(times_bnd[:-1], times[0]))
fn.y = gflg[ind, :]
gflg_gridded[:, ind] = fn(to_float(times_bnd[:-1], times[0]))
gflg_gridded[gflg_gridded == 0] *= np.nan
# gflg_gridded[:, rg<1000] *= np.nan
rg_step = np.unique(np.diff(rg))[0]
rg_bnd = np.arange(rg[0] - rg_step / 2, rg[-1] + rg_step, rg_step)
# Plot the scatter
cMap = colors.ListedColormap(['g'])
ax2.pcolormesh(times_bnd,
rg_bnd,
vel_gridded.T,
vmin=-1000,
vmax=1000,
cmap=colormap)
ax2.pcolormesh(times_bnd, rg_bnd, gflg_gridded.T, cmap=cMap)
pos = ax2.get_position()
cbaxes = fig.add_axes([0.85, 0.12, 0.02, 0.53])
cb = mpl.colorbar.ColorbarBase(cbaxes,
cmap=cmap,
norm=norm,
label='Velocity (m/s)')
ax2.set_xlim(tlim)
ax2.set_ylim(rlim)
ax2.set_xlabel('Hour (UT)')
ax2.set_ylabel('Virtual Range (km)')
ax2.grid(which='both')
# Resize ax2
pos2 = [pos.x0, pos.y0, pos.width * 0.9, pos.height]
ax2.set_position(pos2)
# Resize ax1
pos = ax1.get_position()
pos2 = [pos.x0, pos.y0, pos.width * 0.9, pos.height]
ax1.set_position(pos2)
plt.show()
def plot1(ctx):
"""Do main plotting logic"""
import matplotlib
matplotlib.use('agg')
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
df = read_sql("""SELECT * from sm_hourly WHERE
station = %s and valid BETWEEN %s and %s ORDER by valid ASC
""",
ctx['pgconn'],
params=(ctx['station'], ctx['sts'], ctx['ets']),
index_col='valid')
slrkw = df['slrkw_avg_qc']
d12sm = df['calc_vwc_12_avg_qc']
d12t = df['t12_c_avg_qc']
d24t = df['t24_c_avg_qc']
d50t = df['t50_c_avg_qc']
d24sm = df['calc_vwc_24_avg_qc']
d50sm = df['calc_vwc_50_avg_qc']
rain = df['rain_mm_tot_qc']
tair = df['tair_c_avg_qc']
tsoil = df['tsoil_c_avg_qc']
valid = df.index.values
(fig, ax) = plt.subplots(3, 1, sharex=True, figsize=(8, 8))
ax[0].grid(True)
ax2 = ax[0].twinx()
ax[0].set_zorder(ax2.get_zorder() + 1)
ax[0].patch.set_visible(False)
ax2.set_yticks(np.arange(-0.6, 0., 0.1))
ax2.set_yticklabels(0 - np.arange(-0.6, 0.01, 0.1))
ax2.set_ylim(-0.6, 0)
ax2.set_ylabel("Hourly Precipitation [inch]")
b1 = ax2.bar(valid, 0 - rain / 25.4, width=0.04, fc='b', ec='b', zorder=4)
l1 = None
l2 = None
l3 = None
if not d12sm.isnull().all():
l1, = ax[0].plot(valid,
d12sm * 100.0,
linewidth=2,
color='r',
zorder=5)
if not d24sm.isnull().all():
l2, = ax[0].plot(valid,
d24sm * 100.0,
linewidth=2,
color='purple',
zorder=5)
if not d50sm.isnull().all():
l3, = ax[0].plot(valid,
d50sm * 100.0,
linewidth=2,
color='black',
zorder=5)
ax[0].set_ylabel("Volumetric Soil Water Content [%]", fontsize=10)
days = (ctx['ets'] - ctx['sts']).days
if days >= 3:
interval = max(int(days / 7), 1)
ax[0].xaxis.set_major_locator(
mdates.DayLocator(interval=interval,
tz=pytz.timezone("America/Chicago")))
ax[0].xaxis.set_major_formatter(
mdates.DateFormatter('%-d %b\n%Y',
tz=pytz.timezone("America/Chicago")))
else:
ax[0].xaxis.set_major_locator(
mdates.AutoDateLocator(maxticks=10,
tz=pytz.timezone("America/Chicago")))
ax[0].xaxis.set_major_formatter(
mdates.DateFormatter('%-I %p\n%d %b',
tz=pytz.timezone("America/Chicago")))
ax[0].set_title(("ISUSM Station: %s Timeseries") %
(ctx['nt'].sts[ctx['station']]['name'], ))
box = ax[0].get_position()
ax[0].set_position(
[box.x0, box.y0 + box.height * 0.05, box.width, box.height * 0.95])
box = ax2.get_position()
ax2.set_position(
[box.x0, box.y0 + box.height * 0.05, box.width, box.height * 0.95])
if None not in [l1, l2, l3]:
ax[0].legend([l1, l2, l3, b1],
['12 inch', '24 inch', '50 inch', 'Hourly Precip'],
bbox_to_anchor=(0.5, -0.15),
ncol=4,
loc='center',
fontsize=12)
# ----------------------------------------
if not d12t.isnull().all():
ax[1].plot(valid,
temperature(d12t, 'C').value('F'),
linewidth=2,
color='r',
label='12in')
if not d24t.isnull().all():
ax[1].plot(valid,
temperature(d24t, 'C').value('F'),
linewidth=2,
color='purple',
label='24in')
if not d50t.isnull().all():
ax[1].plot(valid,
temperature(d50t, 'C').value('F'),
linewidth=2,
color='black',
label='50in')
ax[1].grid(True)
ax[1].set_ylabel(r"Temperature $^\circ$F")
box = ax[1].get_position()
ax[1].set_position(
[box.x0, box.y0 + box.height * 0.05, box.width, box.height * 0.95])
# ------------------------------------------------------
ax2 = ax[2].twinx()
l3, = ax2.plot(valid, slrkw, color='g', zorder=1, lw=2)
ax2.set_ylabel("Solar Radiation [W/m^2]", color='g')
l1, = ax[2].plot(valid,
temperature(tair, 'C').value('F'),
linewidth=2,
color='blue',
zorder=2)
l2, = ax[2].plot(valid,
temperature(tsoil, 'C').value('F'),
linewidth=2,
color='brown',
zorder=2)
ax[2].grid(True)
ax[2].legend([l1, l2, l3], ['Air', '4" Soil', 'Solar Radiation'],
bbox_to_anchor=(0.5, 1.1),
loc='center',
ncol=3)
ax[2].set_ylabel(r"Temperature $^\circ$F")
ax[2].set_zorder(ax2.get_zorder() + 1)
ax[2].patch.set_visible(False)
# Wow, strange bugs if I did not put this last
ax[0].set_xlim(min(valid), max(valid))
return fig, df
#%% Slider for cumulative displacement
axtim = pv.add_axes([0.1, 0.08, 0.8, 0.05], yticks=[])
tslider = Slider(axtim,
'yr',
imdates_ordinal[0] - 3,
imdates_ordinal[-1] + 3,
valinit=imdates_ordinal[ix_m],
valfmt='') #%0.0f
tslider.ax.bar(imdates_ordinal,
np.ones(len(imdates_ordinal)),
facecolor='black',
width=4)
tslider.ax.bar(imdates_ordinal[ix_m], 1, facecolor='red', width=8)
loc_tslider = tslider.ax.xaxis.set_major_locator(mdates.AutoDateLocator())
try: # Only support from Matplotlib 3.1!
tslider.ax.xaxis.set_major_formatter(
mdates.ConciseDateFormatter(loc_tslider))
except:
tslider.ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y/%m/%d'))
for label in tslider.ax.get_xticklabels():
label.set_rotation(20)
label.set_horizontalalignment('right')
dstr_ref = imdates_dt[ix_m].strftime('%Y/%m/%d')
### Slide bar action
def tim_slidupdate(val):
global cum_disp_flag
timein = tslider.val
def total_time_plot(overall_dict,
dates,
filename,
past_month=False,
past_year=False):
fig, ax = plt.subplots()
times_dict = {name: [] for name in overall_dict}
if past_month or past_year:
# (last date string)
lds = [int(s) for s in dates[-1].split('/')]
last_date = dt.datetime(year=int(lds[2]),
month=int(lds[0]),
day=int(lds[1]))
# first date of the month/year
first_date = dt.datetime(year=lds[2], month=1, day=1)
if past_month:
first_date = dt.datetime(year=lds[2], month=lds[0], day=1)
delta = (last_date - first_date).days
start = len(dates) - 1 - delta
else:
start = 0
for name in overall_dict:
for day_index in range(start, len(dates)):
if overall_dict[name][day_index] is None:
times_dict[name].append(None)
else:
times_dict[name].append(
sum(t for t in overall_dict[name][start:day_index + 1]
if t is not None))
""" The following is poopcode, but its poopcode that should run in O(n)
if overall_dict[name][day_index] is None:
times_dict[name].append(None)
else:
current_sum = overall_dict[name][day_index]
if len(times_dict[name]) == 0:
times_dict[name].append(current_sum)
else:
last_time_index = day_index - 1
print(f'Out loop {last_time_index}')
while last_time_index >= start and times_dict[name][last_time_index-start] is None:
last_time_index -= 1
print(f'In loop {last_time_index}')
if last_time_index >= start:
current_sum += times_dict[name][last_time_index]
elif times_dict[name][0] is not None:
current_sum += times_dict[name][start]
times_dict[name].append(current_sum)"""
missed_days = times_dict[name].count(None)
times = [
seconds for seconds in overall_dict[name] if seconds is not None
]
average = sum(times) / len(times)
missed_day_sum = missed_days * average
last_time_index = len(times_dict[name]) - 1
while last_time_index > 0 and times_dict[name][last_time_index] is None:
last_time_index -= 1
if last_time_index > 0:
missed_day_sum += times_dict[name][last_time_index]
elif times_dict[name][0] is not None:
missed_day_sum += times_dict[name][0]
times_dict[name].append(missed_day_sum)
datetimes = [
dt.datetime(int(date.split('/')[2]), int(date.split('/')[0]),
int(date.split('/')[1])) for date in dates[start:]
]
last_date = dates[-1]
last_datetime = dt.datetime(int(last_date.split('/')[2]),
int(last_date.split('/')[0]),
int(last_date.split('/')[1]))
next_datetime = last_datetime + dt.timedelta(days=1)
datetimes.append(next_datetime)
for name in times_dict:
plt.plot(datetimes, times_dict[name], '.-', label=name, ms=3)
plt.text(datetimes[-1], times_dict[name][-1],
str(dt.timedelta(seconds=int(times_dict[name][-1]))))
plt.gcf().autofmt_xdate()
if len(datetimes) <= 5:
ax.xaxis.set_major_locator(mdates.DayLocator())
else:
ax.xaxis.set_major_locator(mdates.AutoDateLocator())
ax.xaxis.set_major_formatter(DateFormatter("%m-%d"))
formatter = matplotlib.ticker.FuncFormatter(
lambda s, y: str(dt.timedelta(seconds=s)))
ax.yaxis.set_major_formatter(formatter)
ax.yaxis.set_minor_locator(AutoMinorLocator())
title = r'Cumulative Time (with Missed Days × Average Time appended)'
if past_month:
lds = [int(s) for s in dates[-1].split('/')]
last_date = dt.datetime(year=int(lds[2]),
month=int(lds[0]),
day=int(lds[1]))
# Gets month name
month = last_date.strftime("%B")
title += f' for {month}'
elif past_year:
lds = [int(s) for s in dates[-1].split('/')]
last_date = dt.datetime(year=int(lds[2]),
month=int(lds[0]),
day=int(lds[1]))
# Gets month name
year = last_date.strftime("%Y")
title += f' for {year}'
plt.title(title)
plt.legend()
plt.xlabel('Day')
plt.ylabel('Time')
plt.grid(b=True, which='both')
plt.tight_layout()
plt.savefig(filename, dpi=500)
plt.close('all')
def plot_timeseries(ax, cube_list, label_attr='dataset_id', time_lim=None,
title=None, time_extent=None,
depth_in_title=True,
label_alias=None,
style=None, ylim=None,
add_legend=True, legend_kwargs=None,
variable_alias=None,
start_time=None, end_time=None, **kwargs):
"""
Plots time series objects in the given axes.
:arg cube_list: list of cube time series objects to plot. Can be any
iterable container.
"""
def get_label(cube, attr_name):
return cube.attributes.get(attr_name)
kwargs.setdefault('linewidth', 1.2)
for c in cube_list:
_c = utility.constrain_cube_time(c, start_time, end_time)
label = get_label(_c, label_attr)
if label_alias is not None:
label = label_alias.get(label, label)
if isinstance(_c.data, numpy.ma.MaskedArray) \
and numpy.all(_c.data.mask):
# if all data is bad, skip
continue
kw = dict(kwargs)
if style is not None:
dataset_id = _c.attributes.get('dataset_id')
st = style.get(dataset_id, None)
if st is not None:
kw.update(st)
var = utility.map_var_short_name[_c.standard_name]
if var in plot_unit:
_c_units = _c.copy()
_c_units.convert_units(plot_unit[var])
else:
_c_units = _c
if variable_alias is not None:
var = _c_units.standard_name
if var in variable_alias:
new_var = variable_alias[var]
_c_units.standard_name = None
_c_units.long_name = new_var
qplt.plot(_c_units, axes=ax, label=label, **kw)
if add_legend:
lkw = {'loc': 'upper left', 'bbox_to_anchor': (1.02, 1.0)}
if legend_kwargs is not None:
lkw.update(legend_kwargs)
ax.legend(**lkw)
if title is None:
loc_names = [c.attributes['location_name'] for c in cube_list]
if depth_in_title:
dep_strs = ['{:.1f} m'.format(
c.coord('depth').points.mean()) for c in cube_list]
titles = utility.unique([' '.join(a) for
a in zip(loc_names, dep_strs)])
else:
titles = utility.unique(loc_names)
title = ', '.join(titles).strip()
ax.set_title(title)
xlim = ax.get_xlim()
range_days = xlim[1] - xlim[0]
if range_days < 15:
major_locator = mdates.DayLocator()
minor_locator = mdates.HourLocator(interval=6)
elif range_days < 30:
major_locator = mdates.DayLocator([1, 5, 10, 15, 20, 25])
minor_locator = mdates.DayLocator()
elif range_days < 80:
major_locator = mdates.DayLocator([1, 10, 20])
minor_locator = mdates.DayLocator()
elif range_days < 200:
major_locator = mdates.DayLocator([1, 15])
minor_locator = mdates.DayLocator()
elif range_days < 370:
major_locator = mdates.MonthLocator()
minor_locator = mdates.DayLocator([1, 5, 10, 15, 20, 25])
else:
major_locator = mdates.AutoDateLocator(minticks=7, maxticks=16,
interval_multiples=False)
minor_locator = mdates.MonthLocator(bymonthday=[1, 15], interval=1)
ax.xaxis.set_major_locator(major_locator)
ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))
ax.xaxis.set_minor_locator(minor_locator)
ax.tick_params(axis='x', which='major', length=7)
ax.grid(which='major', linewidth=0.7, color='0.7')
ax.grid(which='minor', linestyle='dashed', linewidth=0.3, color='0.7')
ax.autoscale(enable=True, axis='x', tight=True)
if start_time is None and end_time is None and time_extent is not None:
start_time, end_time = utility.get_common_time_overlap(cube_list,
time_extent)
ax.set_xlim(start_time, end_time)
if time_lim is not None:
ax.set_xlim(time_lim)
plt.setp(ax.get_xticklabels(),
rotation=30, ha='right', rotation_mode='anchor')
if ylim is not None:
ax.set_ylim(ylim)
def plot_drawdown(nav, w, alpha=0.05, height=8, width=10, ax=None):
r"""
Create a chart with the evolution of portfolio prices and drawdown.
Parameters
----------
nav : DataFrame
Cumulative assets returns.
w : DataFrame, optional
A portfolio specified by the user to compare with the efficient
frontier. The default is None.
alpha : float, optional
Significante level of DaR and CDaR. The default is 0.05.
height : float, optional
Height of the image in inches. The default is 8.
width : float, optional
Width of the image in inches. The default is 10.
ax : matplotlib axis of size (2,1), optional
If provided, plot on this axis. The default is None.
Raises
------
ValueError
When the value cannot be calculated.
Returns
-------
ax : matplotlib axis.
Returns the Axes object with the plot for further tweaking.
Example
-------
::
nav=port.nav
ax = plf.plot_drawdown(nav=nav, w=w1, alpha=0.05, height=8, width=10, ax=None)
.. image:: images/Drawdown.png
"""
if not isinstance(nav, pd.DataFrame):
raise ValueError("nav must be a DataFrame")
if not isinstance(w, pd.DataFrame):
raise ValueError("w must be a DataFrame")
if w.shape[1] > 1 and w.shape[0] == 0:
w = w.T
elif w.shape[1] > 1 and w.shape[0] > 0:
raise ValueError("w must be a DataFrame")
if nav.shape[1] != w.shape[0]:
a1 = str(nav.shape)
a2 = str(w.shape)
raise ValueError("shapes " + a1 + " and " + a2 + " not aligned")
if ax is None:
fig = plt.gcf()
ax = fig.subplots(nrows=2, ncols=1)
ax = ax.flatten()
fig.set_figwidth(width)
fig.set_figheight(height)
index = nav.index.tolist()
a = np.array(nav, ndmin=2)
a = np.insert(a, 0, 0, axis=0)
a = np.diff(a, axis=0)
a = np.array(a, ndmin=2) @ np.array(w, ndmin=2)
prices = 1 + np.insert(a, 0, 0, axis=0)
prices = np.cumprod(prices, axis=0)
prices = np.ravel(prices).tolist()
prices2 = 1 + np.array(np.cumsum(a, axis=0))
prices2 = np.ravel(prices2).tolist()
del prices[0]
DD = []
peak = -99999
for i in range(0, len(prices)):
if prices2[i] > peak:
peak = prices2[i]
DD.append((peak - prices2[i]))
DD = -np.array(DD)
titles = [
"Historical Compounded Cumulative Returns",
"Historical Uncompounded Drawdown",
]
data = [prices, DD]
color1 = ["b", "orange"]
risk = [
-rk.UCI_Abs(a),
-rk.ADD_Abs(a),
-rk.DaR_Abs(a, alpha),
-rk.CDaR_Abs(a, alpha),
-rk.EDaR_Abs(a, alpha)[0],
-rk.MDD_Abs(a),
]
label = [
"Ulcer Index: " + "{0:.2%}".format(risk[0]),
"Average Drawdown: " + "{0:.2%}".format(risk[1]),
"{0:.2%}".format((1 - alpha)) + " Confidence DaR: " + "{0:.2%}".format(risk[2]),
"{0:.2%}".format((1 - alpha))
+ " Confidence CDaR: "
+ "{0:.2%}".format(risk[3]),
"{0:.2%}".format((1 - alpha))
+ " Confidence EDaR: "
+ "{0:.2%}".format(risk[4]),
"Maximum Drawdown: " + "{0:.2%}".format(risk[5]),
]
color2 = ["b", "r", "fuchsia", "limegreen", "dodgerblue", "darkgrey"]
j = 0
ymin = np.min(DD) * 1.5
for i in ax:
i.clear()
i.plot_date(index, data[j], "-", color=color1[j])
if j == 1:
i.fill_between(index, 0, data[j], facecolor=color1[j], alpha=0.3)
for k in range(0, len(risk)):
i.axhline(y=risk[k], color=color2[k], linestyle="-", label=label[k])
i.set_ylim(ymin, 0)
i.legend(loc="lower right") # , fontsize = 'x-small')
i.set_title(titles[j])
i.xaxis.set_major_locator(
mdates.AutoDateLocator(tz=None, minticks=5, maxticks=10)
)
i.xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m"))
ticks_loc = i.get_yticks().tolist()
i.set_yticks(i.get_yticks())
i.set_yticklabels(["{:3.2%}".format(x) for x in ticks_loc])
i.grid(linestyle=":")
j = j + 1
fig = plt.gcf()
fig.tight_layout()
return ax
ax3.plot(df_out.index,
df_out.sold_sqm,
c='green',
label='Rented houses')
ax3.legend()
ax4.plot(df.index,
df.curr_num,
c='darkblue',
label='Available house rentals')
ax4.plot(df_out.index,
df_out.sold_num,
c='green',
label='Rented houses')
ax4.legend()
locator = mdates.AutoDateLocator(minticks=1, maxticks=10)
formatter = mdates.ConciseDateFormatter(locator)
ax1.yaxis.set_major_locator(ticker.MaxNLocator(integer=True))
ax2.xaxis.set_major_locator(locator)
ax2.xaxis.set_major_formatter(formatter)
ax2.yaxis.set_major_locator(ticker.MaxNLocator(integer=True))
ax3.yaxis.set_major_locator(ticker.MaxNLocator())
ax4.xaxis.set_major_locator(locator)
ax4.xaxis.set_major_formatter(formatter)
ax4.yaxis.set_major_locator(ticker.MaxNLocator(integer=True))
plt.setp(ax1.get_xticklabels(), visible=False)
def formatter(ax):
locator = mdates.AutoDateLocator(minticks=3, maxticks=12)
formatter = mdates.ConciseDateFormatter(locator)
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(formatter)
def draw(self):
"""Show depth graph."""
data = defaultdict(float)
x = []
y = {}
max_depth: int = 0
knowledges = {}
def compute_data_id() -> str:
return (
f"{get_depth(knowledges[record.question_id].interval):05},"
f"{knowledges[record.question_id].get_answers_number():05}")
def parse_data_id() -> list[int]:
return [int(z) for z in id_.split(",")]
count = 0
# Compute data for the plot.
for record in self.records:
if record.question_id in knowledges:
data[compute_data_id()] -= (
1 / (2**knowledges[record.question_id].get_depth())
if self.count_by_depth else 1)
if not record.is_learning():
if self.show_not_learning:
data["00010,00001"] += 1
continue
else:
last_answers = (knowledges[record.question_id].responses
if record.question_id in knowledges else [])
knowledges[record.question_id] = Knowledge(
record.question_id,
last_answers + [record.answer],
record.time,
record.interval,
)
data[compute_data_id()] += (
1 / (2**knowledges[record.question_id].get_depth())
if self.count_by_depth else 1)
x.append(record.time if self.is_time else count)
count += 1
s = 0
for i in reversed(sorted(data.keys())):
s += data[i]
if i not in y:
y[i] = []
y[i].append(s)
fig, ax = plt.subplots()
if self.is_time:
locator = mdates.AutoDateLocator()
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(mdates.ConciseDateFormatter(locator))
# Plot data.
for id_ in sorted(data.keys()):
depth, returns = parse_data_id()
max_depth = max(max_depth, depth)
color: str
if self.color_mode == "return_colors":
number: int = max(0, 255 - returns * 0 - depth * 10)
color = (f"#{hex(number)[2:]:>02}"
f"{hex(number)[2:]:>02}"
f"{hex(number)[2:]:>02}")
else: # Depth colors.
color = DEPTH_COLORS[depth + 1]
plt.fill_between(x, [0] * (len(x) - len(y[id_])) + y[id_],
color=color)
plt.title("Question depth")
plt.xlabel("Time" if self.is_time else "Actions")
plt.ylabel("Questions")
if not self.is_time:
plt.xlim(xmin=0)
plt.ylim(ymin=0)
if self.show_text:
trans_offset = mtransforms.offset_copy(ax.transData,
fig=fig,
x=0.1,
y=0)
for depth in range(max_depth + 1):
for j in range(10, 0, -1):
id_: str = f"{depth:05},{j:05}"
if id_ in y:
plt.text(
x[-1],
y[id_][-1],
f"{2 ** depth} days",
transform=trans_offset,
)
break
if self.interactive:
plt.show()
else:
plt.savefig("out/graph.svg")
def _create_auto_date_locator(date1, date2, tz):
locator = mdates.AutoDateLocator(interval_multiples=True, tz=tz)
locator.create_dummy_axis()
locator.set_view_interval(mdates.date2num(date1),
mdates.date2num(date2))
return locator
def main():
args = parse_args()
# Read candle data
df = pd.read_csv(args.input, index_col=0, parse_dates=True)
short, mid, long = 60, 120, 720
df['roll_short'] = df['close'].rolling(short).mean()
df['roll_mid'] = df['close'].rolling(mid).mean()
df['roll_long'] = df['close'].rolling(long).mean()
print(len(df))
starts = []
results = []
for _ in trange(1000):
# for _ in trange(20):
wallet = Wallet(30000, 0.00 * SATOSHI)
exchange = Exchange()
index = np.random.randint(0, len(df) - 43200)
df_ = df[index:index + 43200]
# df_ = df[index:]
# Loop
for row in df_.itertuples():
now = row[0].to_pydatetime()
# Dicide order or not
# strategy
if row.roll_short < row.roll_mid:
# price = int(row.close * 0.99)
price = int(row.close * 1.01)
if wallet.btc >= (0.01 * (SATOSHI)):
# print("SELL ORDER")
order = Order("SELL", price, int(0.01 * SATOSHI), now)
wallet.add_order(order)
# elif row.roll_mid > row.roll_long:
elif row.roll_short > row.roll_mid:
# price = int(row.close * 1.01)
price = int(row.close * 0.99)
if wallet.jpy > int(price * 0.01):
# print("BUY ORDER")
order = Order("BUY", price, int(0.01 * SATOSHI), now)
wallet.add_order(order)
# Simulate orders
ret, rejected = exchange.judge_orders(row, wallet)
# Apply result
wallet.cancel_orders(rejected)
for order in ret:
# print(order.side)
exchange.exec_order(order, wallet)
# finalize
start = mdates.date2num(pd.to_datetime(df_.index[0]))
starts.append(start)
results.append(wallet.result(row.close))
# print(exchange.orders)
results = np.array(results)
print(np.mean(results))
print(np.std(results))
# fig = plt.figure(figsize=(16.0, 9.0))
# plt.hist(results, bins=50)
# plt.savefig("test.png")
# plt.cla()
fig, ax = plt.subplots(figsize=(16, 9))
ax.scatter(starts, results)
locator = mdates.AutoDateLocator()
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(mdates.DateFormatter('%y/%m/%d %H:%M'))
fig.savefig("result.png")
self.reset()
if __name__ == '__main__':
from datetime import time
from datetime import timedelta
import copy
now = datetime.now()
t0 = datetime.combine(now.date(), time(6, 0, 0, 0))
t = copy.deepcopy(t0)
sim_time = timedelta(days=2)
scenario = RandomScenario(seed=1)
m = []
T = []
while t < t0 + sim_time:
action = scenario.get_action(t)
m.append(action.meal)
T.append(t)
t += timedelta(minutes=1)
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
plt.plot(T, m)
ax = plt.gca()
ax.xaxis.set_minor_locator(mdates.AutoDateLocator())
ax.xaxis.set_minor_formatter(mdates.DateFormatter('%H:%M\n'))
ax.xaxis.set_major_locator(mdates.DayLocator())
ax.xaxis.set_major_formatter(mdates.DateFormatter('\n%b %d'))
plt.show()
def tanksGratien(instance, qnlp, volnlp, volconv=None):
opacity = 0.6
bar_width = 0.0375 * instance.tsinhours()
box = dict(facecolor='red', pad=5, alpha=0.3)
plt.figure('Tanks', figsize=(8, len(instance.tanks) * 1.5))
ax = []
x = instance.periods[:-1]
for n, j in enumerate(instance.tanks):
ax.append(plt.subplot(len(instance.tanks), 1, n + 1))
inflow = [
sum(max(0, qt[a]) for a in instance.inarcs(j)) -
sum(min(0, qt[a]) for a in instance.outarcs(j))
for t, qt in qnlp.items()
]
ouflow = [
sum(min(0, qt[a]) for a in instance.inarcs(j)) -
sum(max(0, qt[a]) for a in instance.outarcs(j))
for t, qt in qnlp.items()
]
plt.bar(x,
inflow,
bar_width,
alpha=opacity,
color='green',
label='inflow in $m^3/h$')
plt.bar(x,
ouflow,
bar_width,
alpha=opacity,
color='blue',
label='outflow in $m^3/h$')
plt.tick_params(axis='x', which='both', labelbottom='off')
plt.ylabel(j, bbox=box, fontsize=12)
plt.xlim([instance.periods[0], instance.periods[-1]])
mini = round(min(ouflow) * 1.2 / 5) * 5
maxi = round(max(inflow) * 1.2 / 5) * 5
plt.ylim(mini, maxi)
ec = 5 * round((maxi - mini) / 20)
plt.yticks([mini + ec * u for u in range(5)])
if n == len(instance.tanks) - 1:
plt.legend(ncol=2, bbox_to_anchor=(0.67, 6.5))
ax.append(ax[2 * n].twinx())
hwaternlp = [vol[j] / instance.tanks[j].surface for vol in volnlp]
plt.plot(instance.periods,
hwaternlp,
'DarkOrange',
linestyle='-',
linewidth=3,
label='real water height in $m$')
if volconv:
hwatercon = [vol[j] / instance.tanks[j].surface for vol in volconv]
plt.plot(instance.periods,
hwatercon,
'black',
linestyle='-',
linewidth=3,
label='water height in $m$')
hwatermin = [
instance.tanks[j].vmin / instance.tanks[j].surface
for t in instance.periods
]
hwatermax = [
instance.tanks[j].vmax / instance.tanks[j].surface
for t in instance.periods
]
plt.plot(instance.periods,
hwatermin,
'black',
linestyle='-',
linewidth=2)
plt.plot(instance.periods,
hwatermax,
'black',
linestyle='-',
linewidth=2)
if n == len(instance.tanks) - 1:
plt.legend(ncol=1, bbox_to_anchor=(1.1, 6.5))
plt.tick_params(color='DarkOrange')
mini = np.floor(
instance.tanks[j].vmin / instance.tanks[j].surface * 2) / 2.
maxi = np.floor(
instance.tanks[j].vmax / instance.tanks[j].surface * 2) / 2. + 0.5
if maxi - mini > 2:
ec = int(maxi - mini)
gap = 2
else:
ec = int((maxi - mini) / 0.5)
gap = 0.5
plt.yticks([mini + gap * r for r in range(ec + 1)])
for t in ax[2 * n + 1].get_yticklabels():
t.set_color('DarkOrange')
plt.ylim(mini - gap, maxi + gap)
plt.xticks(rotation=20)
plt.xlim([instance.periods[0], instance.periods[-1]])
locator = mdates.AutoDateLocator(minticks=3, maxticks=7)
formatter = mdates.ConciseDateFormatter(locator)
ax[-1].xaxis.set_major_locator(locator)
ax[-1].xaxis.set_major_formatter(formatter)
#ax[-1].set_xlim(x[0], x[-1])
plt.show()
def processCmd(cmd):
global t, running, xs, ys0, ys1, ys2, ys3, ys4, ysd0, ysd1, ysd2, ysd3, ysd4
#Parse command into parts
command = cmd.split()
print(command[0])
if command[0] == 'pause':
#pause
running = False
if command[0] == 'play':
#play
running = True
if command[0] == 'add':
#add [port] [capacity] [maxcharge] [SOC] [deptime] [reqSOC] [userid]
station.ports[int(command[1])] = Vehicle(command)
print('Port [', command[1] ,'] Vehicle added', sep="")
if command[0] == 'list':
print("")
for i,port in enumerate(station.ports):
if port:
list_mins = int(port.projDeparture*5)
list_hours = int(list_mins/60)
list_mins = int(list_mins-(60*list_hours))
list_hours = list_hours+8 # simulation starts at 8 am, each sec is simulating 5 mins
if(list_mins < 10):
list_format_zero = "0"
else:
list_format_zero = ""
list_time_string = str(list_hours)+":"+list_format_zero+str(list_mins)
print('Port [', i ,'] Vehicle:',
'\n Pack Capacity: ', port.packCapacity, ' kWh'
'\n Max Charge Rate: ', port.maxChargeRate, ' kW'
'\n Departure Time: ', list_time_string,
'\n Current SOC: %.2f' % port.SOC, '%'
'\n Requested SOC: ', port.requestedCharge, '%', sep="")
else:
print('Port [', i ,'] EMPTY', sep="")
print("")
if command[0] == 'sub':
#sub [port]
station.ports[int(command[1])] = None
if command[0] == 'modtime':
#modtime [port] [deptime]
mod_hours, mod_mins = command[2].split(":")
mod_hours = int(mod_hours)
mod_hours = (mod_hours-8)*12
mod_mins = int(mod_mins)
mod_mins = mod_mins/5
mod_ret = mod_hours + mod_mins
print(str(mod_ret))
station.ports[int(command[1])].projDeparture = mod_ret
print('Port [', command[1] ,'] Vehicle Departure time changed to ', command[2] , sep="")
if command[0] == 'modcharge':
#modcharge [port] [reqSOC]
station.ports[int(command[1])].requestedCharge = int(command[2])
print('Port [', command[1] ,'] Vehicle Requested SOC changed to ', command[2] , sep="")
if command[0] == 'reset':
xs = []
ys0 = []
ys1 = []
ys2 = []
ys3 = []
ys4 = []
ysd0 = []
ysd1 = []
ysd2 = []
ysd3 = []
ysd4 = []
station.ports[0] = None
station.ports[1] = None
station.ports[2] = None
station.ports[3] = None
running = False
ax1.clear()
ax2.clear()
ax3.clear()
ax4.clear()
ax5.clear()
ax1.set_title('Port 0 Delivered Power')
ax2.set_title('Port 1 Delivered Power')
ax3.set_title('Port 2 Delivered Power')
ax4.set_title('Port 3 Delivered Power')
fig.subplots_adjust(hspace=0.33)
ax5.set_title('Total Station Delivered Power')
hfmt = dates.DateFormatter('%H:%M')
ax1.set_xlabel("Time")
ax1.set_ylabel("Power (kW)")
ax1.xaxis_date()
ax1.xaxis_date()
ax1.xaxis.set_major_formatter(hfmt)
ax1.xaxis.set_major_locator(dates.AutoDateLocator())
ax2.set_xlabel("Time")
ax2.set_ylabel("Power (kW)")
ax2.xaxis_date()
ax2.xaxis.set_major_formatter(hfmt)
ax2.xaxis.set_major_locator(dates.AutoDateLocator())
ax3.set_xlabel("Time")
ax3.set_ylabel("Power (kW)")
ax3.xaxis_date()
ax3.xaxis.set_major_formatter(hfmt)
ax3.xaxis.set_major_locator(dates.AutoDateLocator())
ax4.set_xlabel("Time")
ax4.set_ylabel("Power (kW)")
ax4.xaxis_date()
ax4.xaxis.set_major_formatter(hfmt)
ax4.xaxis.set_major_locator(dates.AutoDateLocator())
ax5.set_xlab2el("Time")
ax5.set_ylabel("Power (kW)")
ax5.xaxis_date()
ax5.xaxis.set_major_formatter(hfmt)
ax5.xaxis.set_major_locator(dates.AutoDateLocator())
if command[0] == "runScript":
# runScript [scriptFilePath]
doScriptCalc(command[1])
traffic['byte'][i] = b
lst_time = []
lst_byte = []
i = 1
while i < len(traffic['time']):
byte = traffic['byte'][i-1]
time = traffic['time'][i-1]
while i < len(traffic['time']) and traffic['time'][i-1] == traffic['time'][i]:
byte += traffic['byte'][i]
i += 1
lst_byte.append(byte)
lst_time.append(time)
i += 1
traffic['time'] = lst_time
traffic['byte'] = lst_byte
fig = mplt.figure(figsize=(8,3))
ax = fig.add_subplot(111)
ax.set_ylim([0, 1400])
x = ax.xaxis
y = ax.yaxis
date_formatter = mdates.DateFormatter('%H:%M:%S')
date_locator = mdates.AutoDateLocator()
x.set_major_formatter(date_formatter)
x.set_major_locator(date_locator)
ax.set_xlabel('время')
ax.set_ylabel('трафик (кб)')
mplt.plot(traffic['time'], traffic['byte'])
mplt.show()
def month_year_timeseries(df,
height=1.5,
aspect=2,
col_wrap=5,
style="whitegrid",
filtered=False,
dfprint=False):
df2 = df.copy()
df2.index = pd.to_datetime(df["lev_dt"])
df2 = df2.groupby(["site_no"]).resample("M").lev_va.mean()
df2 = df2.reset_index()
# Filtering out sites by site_no...
filter_sites = [
175708066163000, 175748066160400, 175837066165400, 175921066144500,
175933066161800, 175950066125200, 180000066125200, 180006066123700,
180012066125500, 180017066132100, 180023066175400
]
# ~ indicates is not in. Check pandas doc
if filtered:
df2 = df2[~df2["site_no"].isin(filter_sites)]
if dfprint:
print("Exporting dataframe to current directory.")
CURR_DIR = os.path.dirname(os.path.realpath(__file__))
df2.to_csv(os.path.join(CURR_DIR, "mean_gwlevels_per_month_year.csv"),
index=False)
return
site_no_list = df2.site_no.unique().tolist()
print(df2)
loop = math.ceil(len(site_no_list) / (col_wrap * 2))
sns.set(style=style, font_scale=0.85)
for i in range(loop):
sliced_list = site_no_list[:col_wrap * 2]
g = sns.FacetGrid(df2[df2["site_no"].isin(sliced_list)],
col="site_no",
col_wrap=col_wrap,
height=height,
aspect=aspect,
sharex=True,
sharey=False)
# seaborn doesn't handle dates in axis. Must use matplotlib's base capabilities
g = g.map(plt.plot_date, "lev_dt", "lev_va", marker=None, fmt='r-')
g.fig.suptitle("Water-level: Monthly mean throughout the years",
size=16)
g.set_axis_labels("Year", "Depth to water-level (ft.)").set_titles(
"site_no: {col_name}").set_xticklabels(rotation=75)
for ax in g.axes.flatten():
ax.invert_yaxis()
# formater and locator are necessary to get the axes to behave when
# interacted with
# https://stackoverflow.com/questions/31255815/seaborn-tsplot-does-not-show-datetimes-on-x-axis-well
ax.xaxis.set_major_locator(mdates.AutoDateLocator())
ax.xaxis.set_major_formatter(mdates.DateFormatter('%m-%Y'))
plt.subplots_adjust(hspace=0.2, wspace=0.2)
del site_no_list[:col_wrap * 2]
plt.show()
fig, ax = plt.subplots(figsize=(5, 3), tight_layout=True) base = datetime.datetime(2017, 1, 1, 0, 0, 1) time = [base + datetime.timedelta(days=x) for x in range(len(y1))] ax.plot(time, y1) ax.tick_params(axis='x', rotation=70) plt.show() ############################################################################## # Maybe the format of the labels above is acceptable, but the choices is # rather idiosyncratic. We can make the ticks fall on the start of the month # by modifying `matplotlib.dates.AutoDateLocator` import matplotlib.dates as mdates locator = mdates.AutoDateLocator(interval_multiples=True) fig, ax = plt.subplots(figsize=(5, 3), tight_layout=True) ax.xaxis.set_major_locator(locator) ax.plot(time, y1) ax.tick_params(axis='x', rotation=70) plt.show() ############################################################################## # However, this changes the tick labels. The easiest fix is to pass a format # to `matplotlib.dates.DateFormatter`. Also note that the 29th and the # next month are very close together. We can fix this by using the # `dates.DayLocator` class, which allows us to specify a list of days of the # month to use. Similar formatters are listed in the `matplotlib.dates` module. locator = mdates.DayLocator(bymonthday=[1, 15])
def plot_series(returns, w, cmap="tab20", height=6, width=10, ax=None):
r"""
Create a chart with the compound cumulated of the portfolios.
Parameters
----------
returns : DataFrame
Assets returns.
w : DataFrame of shape (n_assets, n_portfolios)
Portfolio weights.
cmap : cmap, optional
Colorscale, represente the risk adjusted return ratio.
The default is 'tab20'.
height : float, optional
Height of the image in inches. The default is 6.
width : float, optional
Width of the image in inches. The default is 10.
ax : matplotlib axis, optional
If provided, plot on this axis. The default is None.
Raises
------
ValueError
When the value cannot be calculated.
Returns
-------
ax : matplotlib axis
Returns the Axes object with the plot for further tweaking.
Example
-------
::
ax = plf.plot_series(returns=Y, w=ws, cmap='tab20', height=6, width=10, ax=None)
.. image:: images/Port_Series.png
"""
if not isinstance(returns, pd.DataFrame):
raise ValueError("returns must be a DataFrame")
if not isinstance(w, pd.DataFrame):
raise ValueError("w must be a DataFrame")
if returns.shape[1] != w.shape[0]:
a1 = str(returns.shape)
a2 = str(w.shape)
raise ValueError("shapes " + a1 + " and " + a2 + " not aligned")
if ax is None:
ax = plt.gca()
fig = plt.gcf()
fig.set_figwidth(width)
fig.set_figheight(height)
ax.grid(linestyle=":")
title = "Historical Compounded Cumulative Returns"
ax.set_title(title)
labels = w.columns.tolist()
colormap = cm.get_cmap(cmap)
colormap = colormap(np.linspace(0, 1, 20))
if cmap == "gist_rainbow":
colormap = colormap[::-1]
cycle = plt.cycler("color", colormap)
ax.set_prop_cycle(cycle)
X = w.columns.tolist()
index = returns.index.tolist()
for i in range(len(X)):
a = np.array(returns, ndmin=2) @ np.array(w[X[i]], ndmin=2).T
prices = 1 + np.insert(a, 0, 0, axis=0)
prices = np.cumprod(prices, axis=0)
prices = np.ravel(prices).tolist()
del prices[0]
ax.plot_date(index, prices, "-", label=labels[i])
ax.xaxis.set_major_locator(mdates.AutoDateLocator(tz=None, minticks=5, maxticks=10))
ax.xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m"))
ticks_loc = ax.get_yticks().tolist()
ax.set_yticks(ax.get_yticks().tolist())
ax.set_yticklabels(["{:3.2f}".format(x) for x in ticks_loc])
ax.legend(loc="center left", bbox_to_anchor=(1, 0.5))
fig = plt.gcf()
fig.tight_layout()
return ax
def plotHeatMap(title="My Plot Title", xLabel='X Label', yLabel='Y Label', zLabel='Z Label', xs=list(), ys=list(), intensity=list(), zLevels=None, yLog=True, saveFileLocation=None):
#here's our data to plot, all normal Python lists
#xs = [datetime.strptime("2000-06-30", "%Y-%m-%d"), datetime.strptime("2000-09-30", "%Y-%m-%d"), datetime.strptime("2001-03-30", "%Y-%m-%d")] # Time
#ys = [0, 1, 2, 3, 4] # Degree
#if(pltPassed):
#plt = pltPassed
#a1 = plt.axes([.125, .76, .01875, 0.015])
isDates = True
#convert dates to numbers
for i in range(len(xs)):
try:
xs[i] = mdates.date2num(xs[i])
except:
isDates = False
pass
#column1 is xs[0]
#intensity = [
#[250, 150, 190],
#[150, 200, 160],
#[80, 75, 77],
#[60, 65, 58],
#[20, 50, 24],
#]
verticalMax = max(map(max, intensity))
verticalMin = min(map(min, intensity))
#setup the 2D grid with Numpy
x, y = np.meshgrid(xs, ys)
#z=np.array(zs)
#z=z.reshape(len(y),len(x))
#convert intensity (list of lists) to a numpy array for plotting
intensity = np.array(intensity)
#plt size
my_dpi = 100
width = 950
height = 670
figure = plt.figure(figsize=(width/my_dpi, height/my_dpi), dpi=my_dpi)
#assign locator and formatter for the xaxis ticks.
#plt.gca().xaxis.set_major_locator(mdates.AutoDateLocator())
#plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y.%m.%d'))
if(isDates):
plt.gca().xaxis.set_major_locator(mdates.YearLocator())
plt.gca().xaxis.set_major_formatter(mdates.AutoDateFormatter(mdates.AutoDateLocator()))
#plt.title(title, fontsize=13, fontweight='bold')
plt.xlabel(xLabel, fontsize=16)
plt.ylabel(yLabel, fontsize=16)
#plt.xlim([0, 40])
plt.ylim([1, 1800])
if(yLog):
plt.yscale('log', nonposy='clip', basey=10, labelOnlyBase=False)
zColors = list()
#zColors.append((0.0, 0.0, 0.8))
#zColors.append((0.0, 0.0, 0.8))
#zColors.append((0.0, 0.3, 0.8))
#zColors.append((0.0, 0.0, 0.8)) # original blue background
zColors.append((0.9, 0.9, 0.9)) # light grey background - option 1
#zColors.append((0.8, 0.8, 1.0)) # light blue background - option 2
#zColors.append((0.0, 0.8, 0.8))
#zColors.append((0.5, 1.0, 0.5)) #light green - original
#zColors.append((0.5, 1.0, 0.5)) #light green - option 2
#zColors.append((1.0, 1.0, 0.0)) #yellow
zColors.append((1.0, 0.7, 0.0)) #yellow - option 1
zColors.append((1.0, 0.6, 0.0))
zColors.append((1.0, 0.5, 0.0))
zColors.append((1.0, 0.4, 0.0))
zColors.append((1.0, 0.3, 0.0))
zColors.append((1.0, 0.2, 0.0))
#zColors.append((1.0, 0.1, 0.0))
zColors.append((1.0, 0.0, 0.0))
zColors.append((0.8, 0.0, 0.0))
zColors.append((0.7, 0.0, 0.0))
zColors.append((0.6, 0.0, 0.0))
zColors.append((0.5, 0.0, 0.0))
zColors.append((0.4, 0.0, 0.0))
zColors.append((0.3, 0.0, 0.0))
zColors.append((0.2, 0.0, 0.0))
zColors.append((0.1, 0.0, 0.0))
zColors.append((0.0, 0.0, 0.0))
if(not zLevels):
#axisZBase = 1.15
axisZBase = 1.325
zLevels = list()
#zLevelsIntegers = list()
numberOfLevels = len(zColors)
zLevels.append(0)
zLevels.append(1)
zLevels.append(2)
startLoop = 0
endLoop = numberOfLevels+1
startLoop += 5
endLoop += 5 - len(zLevels)
for i in range(startLoop, endLoop):
zLevels.append(int(np.power(axisZBase, i)))
#zLevelsIntegers.append(int(np.power(axisZBase, i)))
verticalMin = -1 * verticalMax
#now just plug the data into pcolormesh, it's that easy!
#plt.pcolormesh(xs, ys, intensity, cmap="jet", vmin=verticalMin, vmax=verticalMax)
pp = plt.contourf(xs, ys, intensity, cmap=None, levels=zLevels, colors=zColors)
colorbar = plt.colorbar(pp, format="%.1f") #need a colorbar to show the intensity scale (pp, ticks=..., format=...) #format="%0.1f" or format="%d"
colorbar.set_label(zLabel, fontsize=16)
#colorbar.set_ticklabels(zLevelsIntegers)
plt.xticks(rotation=45)
if(saveFileLocation):
#save the plot to a file
pp = PdfPages(saveFileLocation)
pp.savefig(figure)
pp.close()
else:
plt.show()
def _create_auto_date_locator(date1, date2):
locator = mdates.AutoDateLocator()
locator.create_dummy_axis()
locator.set_view_interval(mdates.date2num(date1),
mdates.date2num(date2))
return locator
# rotate_labels...
for label in ax.get_xticklabels():
label.set_rotation(40)
label.set_horizontalalignment('right')
axs[0].set_title('Default Date Formatter')
plt.show()
#############################################################################
# The default date formater is quite verbose, so we have the option of
# using `~.dates.ConciseDateFormatter`, as shown below. Note that
# for this example the labels do not need to be rotated as they do for the
# default formatter because the labels are as small as possible.
fig, axs = plt.subplots(3, 1, constrained_layout=True, figsize=(6, 6))
for nn, ax in enumerate(axs):
locator = mdates.AutoDateLocator(minticks=3, maxticks=7)
formatter = mdates.ConciseDateFormatter(locator)
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(formatter)
ax.plot(dates, y)
ax.set_xlim(lims[nn])
axs[0].set_title('Concise Date Formatter')
plt.show()
#############################################################################
# If all calls to axes that have dates are to be made using this converter,
# it is probably most convenient to use the units registry where you do
# imports:
def total_wins_plot(overall_dict,
dates,
filename,
past_month=False,
past_year=False):
fig, ax = plt.subplots()
wins_dict = {name: [] for name in overall_dict}
if past_month or past_year:
# (last date string)
lds = [int(s) for s in dates[-1].split('/')]
last_date = dt.datetime(year=int(lds[2]),
month=int(lds[0]),
day=int(lds[1]))
# first date of the month/year
first_date = dt.datetime(year=lds[2], month=1, day=1)
if past_month:
first_date = dt.datetime(year=lds[2], month=lds[0], day=1)
delta = (last_date - first_date).days
start = len(dates) - 1 - delta
else:
start = 0
for day_index in range(start, len(dates)):
min_time = None
min_names = []
for name in overall_dict:
if overall_dict[name][day_index] is not None:
if min_time is None:
min_time = overall_dict[name][day_index]
min_names = [name]
elif overall_dict[name][day_index] < min_time:
min_time = overall_dict[name][day_index]
min_names = [name]
elif overall_dict[name][day_index] == min_time:
min_names.append(name)
for name in overall_dict:
if len(wins_dict[name]) == 0:
total = 0
else:
total = wins_dict[name][-1]
if name in min_names:
wins_dict[name].append(total + 1)
else:
wins_dict[name].append(total)
datetimes = [
dt.datetime(int(date.split('/')[2]), int(date.split('/')[0]),
int(date.split('/')[1])) for date in dates[start:]
]
for name in wins_dict:
plt.plot(datetimes, wins_dict[name], '-', label=name, ms=3)
plt.text(datetimes[-1], wins_dict[name][-1], wins_dict[name][-1])
plt.gcf().autofmt_xdate()
if len(datetimes) <= 5:
ax.xaxis.set_major_locator(mdates.DayLocator())
else:
ax.xaxis.set_major_locator(mdates.AutoDateLocator())
ax.xaxis.set_major_formatter(DateFormatter("%m-%d"))
ax.yaxis.set_minor_locator(AutoMinorLocator())
title = 'Cumulative Wins'
if past_month:
lds = [int(s) for s in dates[-1].split('/')]
last_date = dt.datetime(year=int(lds[2]),
month=int(lds[0]),
day=int(lds[1]))
# Gets month name
month = last_date.strftime("%B")
title += f' for {month}'
elif past_year:
lds = [int(s) for s in dates[-1].split('/')]
last_date = dt.datetime(year=int(lds[2]),
month=int(lds[0]),
day=int(lds[1]))
# Gets month name
year = last_date.strftime("%Y")
title += f' for {year}'
plt.title(title)
plt.legend()
plt.xlabel('Day')
plt.ylabel('Wins')
plt.grid(b=True, which='both')
plt.savefig(filename, dpi=500)
plt.close('all')
return wins_dict
def overview(sc, mode, start_date, end_date, **kwargs):
# Read the data
b = fgm.load_data(sc=sc, mode=mode,
start_date=start_date, end_date=end_date)
e = edp.load_data(sc=sc, mode=mode,
start_date=start_date, end_date=end_date)
dis_moms = fpi.load_moms(sc=sc, mode=mode, optdesc='dis-moms',
start_date=start_date, end_date=end_date)
des_moms = fpi.load_moms(sc=sc, mode=mode, optdesc='des-moms',
start_date=start_date, end_date=end_date)
nrows = 7
ncols = 1
figsize = (6.0, 7.0)
fig, axes = plt.subplots(nrows=nrows, ncols=ncols,
figsize=figsize, squeeze=False)
locator = mdates.AutoDateLocator()
formatter = mdates.ConciseDateFormatter(locator)
# B
ax = axes[0,0]
b['B_GSE'][:,3].plot(ax=ax, label='|B|')
b['B_GSE'][:,0].plot(ax=ax, label='Bx')
b['B_GSE'][:,1].plot(ax=ax, label='By')
b['B_GSE'][:,2].plot(ax=ax, label='Bz')
ax.set_xlabel('')
ax.set_xticklabels([])
ax.set_ylabel('B [nT]')
ax.set_title('')
# Create the legend outside the right-most axes
leg = ax.legend(bbox_to_anchor=(1.05, 1),
borderaxespad=0.0,
frameon=False,
handlelength=0,
handletextpad=0,
loc='upper left')
# Color the legend text the same color as the lines
for line, text in zip(ax.get_lines(), leg.get_texts()):
text.set_color(line.get_color())
# Ion energy spectrogram
nt = dis_moms['omnispectr'].shape[0]
nE = dis_moms['omnispectr'].shape[1]
x0 = mdates.date2num(dis_moms['time'])[:, np.newaxis].repeat(nE, axis=1)
x1 = dis_moms['energy']
y = np.where(dis_moms['omnispectr'] == 0, 1, dis_moms['omnispectr'])
y = np.log(y[0:-1,0:-1])
ax = axes[1,0]
im = ax.pcolorfast(x0, x1, y, cmap='nipy_spectral')
ax.images.append(im)
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(formatter)
ax.set_xticklabels([])
ax.set_xlabel('')
ax.set_yscale('log')
ax.set_ylabel('E ion\n(eV)')
cbaxes = inset_axes(ax,
width='2%', height='100%', loc=4,
bbox_to_anchor=(0, 0, 1.05, 1),
bbox_transform=ax.transAxes,
borderpad=0)
cb = plt.colorbar(im, cax=cbaxes, orientation='vertical')
cb.set_label('$log_{10}$DEF\nkeV/($cm^{2}$ s sr keV)')
# Electron energy spectrogram
nt = des_moms['omnispectr'].shape[0]
nE = des_moms['omnispectr'].shape[1]
x0 = mdates.date2num(des_moms['time'])[:, np.newaxis].repeat(nE, axis=1)
x1 = des_moms['energy']
y = np.where(des_moms['omnispectr'] == 0, 1, des_moms['omnispectr'])
y = np.log(y[0:-1,0:-1])
ax = axes[2,0]
im = ax.pcolorfast(x0, x1, y, cmap='nipy_spectral')
ax.images.append(im)
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(formatter)
ax.set_xticklabels([])
ax.set_xlabel('')
ax.set_yscale('log')
ax.set_ylabel('E e-\n(eV)')
cbaxes = inset_axes(ax,
width='2%', height='100%', loc=4,
bbox_to_anchor=(0, 0, 1.05, 1),
bbox_transform=ax.transAxes,
borderpad=0)
cb = plt.colorbar(im, cax=cbaxes, orientation='vertical')
cb.set_label('$log_{10}$DEF')
# N
ax = axes[3,0]
dis_moms['density'].plot(ax=ax, label='Ni')
des_moms['density'].plot(ax=ax, label='Ne')
ax.set_xlabel('')
ax.set_xticklabels([])
ax.set_ylabel('N\n($cm^{-3}$)')
ax.set_title('')
leg = ax.legend(bbox_to_anchor=(1.05, 1),
borderaxespad=0.0,
frameon=False,
handlelength=0,
handletextpad=0,
loc='upper left')
for line, text in zip(ax.get_lines(), leg.get_texts()):
text.set_color(line.get_color())
# Vi
ax = axes[4,0]
dis_moms['velocity'][:,0].plot(ax=ax, label='Vx')
dis_moms['velocity'][:,1].plot(ax=ax, label='Vy')
dis_moms['velocity'][:,2].plot(ax=ax, label='Vz')
ax.set_xlabel('')
ax.set_xticklabels([])
ax.set_ylabel('Vi\n(km/s)')
ax.set_title('')
leg = ax.legend(bbox_to_anchor=(1.05, 1),
borderaxespad=0.0,
frameon=False,
handlelength=0,
handletextpad=0,
loc='upper left')
for line, text in zip(ax.get_lines(), leg.get_texts()):
text.set_color(line.get_color())
# Ve
ax = axes[5,0]
des_moms['velocity'][:,0].plot(ax=ax, label='Vx')
des_moms['velocity'][:,1].plot(ax=ax, label='Vy')
des_moms['velocity'][:,2].plot(ax=ax, label='Vz')
ax.set_xlabel('')
ax.set_xticklabels([])
ax.set_ylabel('Ve\n(km/s)')
ax.set_title('')
leg = ax.legend(bbox_to_anchor=(1.05, 1),
borderaxespad=0.0,
frameon=False,
handlelength=0,
handletextpad=0,
loc='upper left')
for line, text in zip(ax.get_lines(), leg.get_texts()):
text.set_color(line.get_color())
# E
ax = axes[6,0]
e['E_GSE'][:,0].plot(ax=ax, label='Ex')
e['E_GSE'][:,1].plot(ax=ax, label='Ey')
e['E_GSE'][:,2].plot(ax=ax, label='Ez')
ax.set_xlabel('')
ax.set_xticklabels([])
ax.set_ylabel('E\n(mV/m)')
ax.set_title('')
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_major_formatter(formatter)
for tick in ax.get_xticklabels():
tick.set_rotation(45)
leg = ax.legend(bbox_to_anchor=(1.05, 1),
borderaxespad=0.0,
frameon=False,
handlelength=0,
handletextpad=0,
loc='upper left')
for line, text in zip(ax.get_lines(), leg.get_texts()):
text.set_color(line.get_color())
fig.suptitle(sc.upper())
plt.subplots_adjust(left=0.2, right=0.8, top=0.95, hspace=0.2)
return fig, axes
def rankings_plot(overall_dict,
dates,
filename,
past_month=False,
past_year=False):
fig, ax = plt.subplots()
scores = [10, 8, 5, 3, 1]
rank_dict = {name: [] for name in overall_dict}
start = 0
if past_month or past_year:
# (last date string)
lds = [int(s) for s in dates[-1].split('/')]
last_date = dt.datetime(year=int(lds[2]),
month=int(lds[0]),
day=int(lds[1]))
# first date of the month/year
first_date = dt.datetime(year=lds[2], month=1, day=1)
if past_month:
first_date = dt.datetime(year=lds[2], month=lds[0], day=1)
delta = (last_date - first_date).days
start = len(dates) - 1 - delta
for day_index in range(start, len(dates)):
daily_rank = []
did_not_play = []
for name in overall_dict:
user_time = overall_dict[name][day_index]
if user_time is None:
did_not_play.append(name)
elif len(daily_rank) == 0:
daily_rank.append([name])
else:
# iterate rank to insert name
i = 0
inserted = False
while i < len(daily_rank) and not inserted:
if user_time < overall_dict[daily_rank[i][0]][day_index]:
daily_rank.insert(i, [name])
inserted = True
elif user_time == overall_dict[daily_rank[i]
[0]][day_index]:
daily_rank[i].append(name)
inserted = True
else:
i += 1
if not inserted:
daily_rank.append([name])
# distribute scores. Ties mean they get assigned the average of their place - two first means (10 + 8) // 2
scores_copy = list(scores)
mg = ''
for place in daily_rank:
score = 0
for i in range(len(place)):
score += scores_copy.pop(0)
# Take average for ties
score //= len(place)
# Add score to rank_dict list
for name in place:
if len(rank_dict[name]) == 0:
total = 0
else:
total = rank_dict[name][-1]
rank_dict[name].append(total + score)
mg += f'{name}: {score} '
for name in did_not_play:
if len(rank_dict[name]) == 0:
total = 0
else:
total = rank_dict[name][-1]
rank_dict[name].append(total)
mg += f'{name}: {0} '
datetimes = [
dt.datetime(int(date.split('/')[2]), int(date.split('/')[0]),
int(date.split('/')[1])) for date in dates[start:]
]
for name in rank_dict:
plt.plot(datetimes, rank_dict[name], '-', label=name, ms=3)
plt.gcf().autofmt_xdate()
# Avoid duplicate day ticks
if len(datetimes) <= 5:
ax.xaxis.set_major_locator(mdates.DayLocator())
else:
ax.xaxis.set_major_locator(mdates.AutoDateLocator())
ax.xaxis.set_major_formatter(DateFormatter("%m-%d"))
ax.yaxis.set_minor_locator(AutoMinorLocator())
title = 'Ranked rankings'
if past_month:
lds = [int(s) for s in dates[-1].split('/')]
last_date = dt.datetime(year=int(lds[2]),
month=int(lds[0]),
day=int(lds[1]))
# Gets month name
month = last_date.strftime("%B")
title += f' for {month}'
elif past_year:
lds = [int(s) for s in dates[-1].split('/')]
last_date = dt.datetime(year=int(lds[2]),
month=int(lds[0]),
day=int(lds[1]))
# Gets month name
year = last_date.strftime("%Y")
title += f' for {year}'
plt.title(title)
plt.legend()
plt.xlabel('Day')
plt.ylabel('Rank')
plt.grid(b=True, which='both')
plt.savefig(filename, dpi=500)
plt.close('all')
return {name: scores[-1] for (name, scores) in rank_dict.items()}
def plotTraffic(pdTrafficRecentRelativePc,
dfMedianPc,
tsAdditionalDetail,
fullLegend=False,
normalLineAlpha=0.5):
fig, ax = plt.subplots(1, 1, figsize=(18, 9), constrained_layout=True)
ax.set_xlabel('Date')
ax.set_ylim([0, 130])
ax.set_ylabel('Percentage')
timeLocatorMajor = mdates.AutoDateLocator(minticks=15, maxticks=60)
conciseZeroFormats = ['', '%Y', '%b', '%d-%b', '%H:%M', '%H:%M']
conciseOffsetFormats = [
'', '%Y', '%b-%Y', '%d-%b-%Y-%b', '%d-%b-%Y', '%d-%b-%Y %H:%M'
]
ax.xaxis.set_tick_params(which='major')
ax.xaxis.set_major_locator(timeLocatorMajor)
ax.xaxis.set_major_formatter(
mdates.ConciseDateFormatter(locator=timeLocatorMajor,
zero_formats=conciseZeroFormats,
offset_formats=conciseOffsetFormats))
ax.grid(linestyle='--')
tsAnnotationOffset = 1
annotationColours = iter(plt.get_cmap('Dark2').colors)
tsAnnotationOffsetAlternator = -8
for ts in reversed(sorted(list(pdTrafficRecentRelativePc.columns))):
dfTs = pdTrafficRecentRelativePc[ts]
dfTs.index = dfTs.index.map(lambda d: datetime.datetime.combine(
d, datetime.time.min).replace(tzinfo=tzLocal))
dfTs = dfTs[(dfTs < 160) & (dfTs > 10)] # Sanity limits :-)
if ts in tsAdditionalDetail.keys():
seriesColour = next(annotationColours)
if fullLegend == True:
ax.plot(dfTs,
color=seriesColour,
alpha=0.8,
linewidth=1.5,
label=tsAdditionalDetail[ts],
zorder=2)
else:
ax.plot(dfTs, color=seriesColour, alpha=0.8, linewidth=1.5)
arrowDay = dateToday - pd.Timedelta(days=tsAnnotationOffset)
arrowPointsAt = list(
dfTs[dfTs.index == arrowDay].to_dict().values())
arrowPointsAt = None if len(
arrowPointsAt) <= 0 else arrowPointsAt[0]
arrowMedian = list(dfMedianPc[dfMedianPc.index ==
arrowDay].to_dict().values())
arrowMedian = None if len(arrowMedian) <= 0 else arrowMedian[0]
shiftAttempt = 0
while (arrowPointsAt is None
or abs(arrowPointsAt - arrowMedian) < 3.5
) and shiftAttempt < 5:
tsAnnotationOffset = tsAnnotationOffset + 1
shiftAttempt = shiftAttempt + 1
arrowDay = dateToday - pd.Timedelta(
days=tsAnnotationOffset)
arrowPointsAt = list(
dfTs[dfTs.index == arrowDay].to_dict().values())
arrowPointsAt = None if len(
arrowPointsAt) <= 0 else arrowPointsAt[0]
arrowMedian = list(dfMedianPc[dfMedianPc.index ==
arrowDay].to_dict().values())
arrowMedian = None if len(
arrowMedian) <= 0 else arrowMedian[0]
tsAnnotationOffsetAlternator = -tsAnnotationOffsetAlternator
ax.annotate(
tsAdditionalDetail[ts],
xy=(arrowDay, arrowPointsAt),
xycoords='data',
xytext=(arrowDay,
max(
12.5, arrowPointsAt +
((+20 + tsAnnotationOffsetAlternator)
if arrowPointsAt > arrowMedian else
(-20 + tsAnnotationOffsetAlternator)))),
textcoords='data',
arrowprops=dict(facecolor='black',
shrink=0.01,
width=0.2,
headwidth=4.5),
horizontalalignment='center',
verticalalignment='top',
fontsize=11,
path_effects=[
pe.withStroke(linewidth=4, foreground='#ffffffa0')
])
ax.annotate(
'●',
xy=(arrowDay,
max(
7, arrowPointsAt +
((+25 + tsAnnotationOffsetAlternator)
if arrowPointsAt > arrowMedian else
(-26 + tsAnnotationOffsetAlternator)))),
xycoords='data',
xytext=(arrowDay,
max(
7, arrowPointsAt +
((+25 + tsAnnotationOffsetAlternator)
if arrowPointsAt > arrowMedian else
(-26 + tsAnnotationOffsetAlternator)))),
textcoords='data',
horizontalalignment='center',
verticalalignment='top',
fontsize=14,
color=seriesColour)
tsAnnotationOffset = tsAnnotationOffset + 3
else:
ax.plot(dfTs,
color='#909090',
alpha=normalLineAlpha,
linewidth=0.35)
for date in dfMedianPc.index:
if date.strftime('%A') in ['Saturday', 'Sunday']:
#print(date)
ax.axvspan(date - pd.Timedelta(days=0.5),
date + pd.Timedelta(days=0.5),
alpha=0.1,
color='#606060',
zorder=3)
ax.plot(dfMedianPc,
color='#f64a8a',
linewidth=2.0,
marker='s',
markersize=10,
label='Median')
plt.xticks(ha='center')
plt.legend(loc='upper right')
return [plt, fig, ax]
def plot2(ctx):
import matplotlib
matplotlib.use('agg')
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
df = read_sql("""SELECT * from sm_hourly WHERE
station = %s and valid BETWEEN %s and %s ORDER by valid ASC
""",
ctx['pgconn'],
params=(ctx['station'], ctx['sts'], ctx['ets']),
index_col='valid')
d12t = df['t12_c_avg_qc']
d24t = df['t24_c_avg_qc']
d50t = df['t50_c_avg_qc']
tsoil = df['tsoil_c_avg_qc']
valid = df.index.values
# maxy = max([np.max(d12sm), np.max(d24sm), np.max(d50sm)])
# miny = min([np.min(d12sm), np.min(d24sm), np.min(d50sm)])
(fig, ax) = plt.subplots(1, 1)
ax.grid(True)
ax.set_title(("ISUSM Station: %s Timeseries\n"
"Soil Temperature at Depth\n ") %
(ctx['nt'].sts[ctx['station']]['name'], ))
ax.plot(valid,
temperature(tsoil, 'C').value('F'),
linewidth=2,
color='brown',
label='4 inch')
if not d12t.isnull().any():
ax.plot(valid,
temperature(d12t, 'C').value('F'),
linewidth=2,
color='r',
label='12 inch')
if not d24t.isnull().any():
ax.plot(valid,
temperature(d24t, 'C').value('F'),
linewidth=2,
color='purple',
label='24 inch')
if not d50t.isnull().any():
ax.plot(valid,
temperature(d50t, 'C').value('F'),
linewidth=2,
color='black',
label='50 inch')
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width, box.height * 0.9])
ax.legend(bbox_to_anchor=(0.5, 1.02), ncol=4, loc='center', fontsize=12)
days = (ctx['ets'] - ctx['sts']).days
if days >= 3:
interval = max(int(days / 7), 1)
ax.xaxis.set_major_locator(
mdates.DayLocator(interval=interval,
tz=pytz.timezone("America/Chicago")))
ax.xaxis.set_major_formatter(
mdates.DateFormatter('%-d %b\n%Y',
tz=pytz.timezone("America/Chicago")))
else:
ax.xaxis.set_major_locator(
mdates.AutoDateLocator(maxticks=10,
tz=pytz.timezone("America/Chicago")))
ax.xaxis.set_major_formatter(
mdates.DateFormatter('%-I %p\n%d %b',
tz=pytz.timezone("America/Chicago")))
if ax.get_ylim()[0] < 40:
ax.axhline(32, linestyle='--', lw=2, color='tan')
ax.set_ylabel(r"Temperature $^\circ$F")
return fig, df
ax3.set_title('Port 2 Delivered Power')
ax4 = fig.add_subplot(2,2,4)
ax4.set_title('Port 3 Delivered Power')
fig.subplots_adjust(hspace=0.33)
fig2 = plt.figure()
ax5 = fig2.add_subplot(1,1,1)
ax5.set_title('Total Station Delivered Power')
hfmt = dates.DateFormatter('%H:%M')
ax1.set_xlabel("Time")
ax1.set_ylabel("Power (kW)")
ax1.xaxis_date()
ax1.xaxis.set_major_formatter(hfmt)
ax1.xaxis.set_major_locator(dates.AutoDateLocator())
ax2.set_xlabel("Time")
ax2.set_ylabel("Power (kW)")
ax2.xaxis_date()
ax2.xaxis.set_major_formatter(hfmt)
ax2.xaxis.set_major_locator(dates.AutoDateLocator())
ax3.set_xlabel("Time")
ax3.set_ylabel("Power (kW)")
ax3.xaxis_date()
ax3.xaxis.set_major_formatter(hfmt)
ax3.xaxis.set_major_locator(dates.AutoDateLocator())
datetime_list[-1],
alpha=0.25,
color=trend_color)
cum_barpoints = ax[1].bar(datetime_list,
clark_data["Confirmed"],
color='lightblue',
label="Cumulative Confirmed Cases")
ax[1].plot(datetime_list,
clark_data["Confirmed_Cum_Moving"],
'-',
linewidth=3,
color='darkblue',
label="5-day moving average")
fig.autofmt_xdate()
ax[1].fmt_xdata = mdates.DateFormatter('%m-%d-%Y')
ax[1].xaxis.set_major_locator(mdates.AutoDateLocator())
ax[1].set_xlabel('Date')
ax[0].set_ylabel('Daily Confirmed Cases')
ax[1].set_ylabel('Cumulative Confirmed Cases')
ax[0].set_title('COVID-19 Cases in Clark County, NV')
ax[0].legend()
ax[1].legend()
#MAKE LABELS FOR PLOTTED VALUES
daily_bar_labels = []
cum_bar_labels = []
for i in range(len(daily_confirmed)):
daily_bar_labels.append(datetime_list[i].strftime('%m-%d-%Y') + ": " +
str(daily_confirmed[i]))
cum_bar_labels.append(datetime_list[i].strftime('%m-%d-%Y') + ": " +
str(confirmed_data[i]))
def pumps(instance, qnlp, qconvex=None):
fig, axs = plt.subplots(nrows=len(instance.pumps) + 1,
ncols=1,
sharex=True,
figsize=(8, (len(instance.pumps) + 1) * 1.5))
# fig.suptitle(instance.name, fontsize=14)
x = instance.periods[:-1]
bar_width = x[1] - x[0]
qmax = max(p.qmax for p in instance.pumps.values()) * 1.1
cm = plt.cm.get_cmap('OrRd')
eleccost = [instance.eleccost(t) for t in instance.horizon()]
ecmin = 0 #min(eleccost)/2
ecspan = max(eleccost) - ecmin
ecm = [cm((cost - ecmin) / ecspan) for cost in eleccost]
for n, (a, p) in enumerate(instance.pumps.items()):
qnlpa = [qt[a] for t, qt in qnlp.items()]
axs[n].bar(x,
qnlpa,
bar_width,
align='edge',
color=ecm,
edgecolor='white',
label='real flow in $m^3/h$')
axs[n].set_ylabel(f'({a[0]},{a[1]})',
bbox=dict(fc='#557f2d', alpha=0.2, pad=3),
fontsize=10)
axs[n].set_ylim(0, qmax)
axs[n].fill_between(x, p.qmin, p.qmax, color='#7f6d5f', alpha=0.1)
axs[-1].step(x,
eleccost,
where='post',
color='#7f6d5f',
label='elec in '
u"\u20AC"
'/MWh')
#axs[-1].bar(x, eleccost, bar_width, align='edge', alpha=0.7, color=ecm, label='elec in 'u"\u20AC"'/MWh')
axs[-1].set_ylim(min(0, min(eleccost)), max(eleccost) * 1.1)
locator = mdates.AutoDateLocator(minticks=3, maxticks=7)
formatter = mdates.ConciseDateFormatter(locator)
axs[-1].xaxis.set_major_locator(locator)
axs[-1].xaxis.set_major_formatter(formatter)
axs[-1].set_xlim(x[0], x[-1])
plt.tight_layout()
axs[0].set_title('pump flow in $m^3/h$', fontsize=9)
axs[-1].set_title('electricity cost in ' u"\u20AC" '/MWh', fontsize=9)
plt.subplots_adjust(bottom=0.1, right=0.95, top=0.9)
cax = plt.axes([0.975, 0.1, 0.025, 0.8])
sm = plt.cm.ScalarMappable(cmap=cm,
norm=plt.Normalize(ecmin, ecmin + ecspan))
sm.set_array([])
cbar = fig.colorbar(sm, cax=cax)
cbar.set_label('electricity cost in '
u"\u20AC"
'/MWh',
rotation=270,
labelpad=25)
plt.show()
