def write_pil(a, out):
comp = 6
nrm = norm if norm != None else plt.Normalize(filter(a.min()),
filter(a.max()))
img = ((2**depth - 1) * jet(nrm(filter(a)))).astype(np.uint8)
i = Image.fromarray(img, 'RGBA')
i.save(out, compress_level=comp, bits=depth)
def plot_global(xx,
yy,
data,
data_projection_code,
cmin,
cmax,
ax,
plot_type='pcolormesh',
show_colorbar=False,
cmap='jet',
show_grid_lines=True,
show_grid_labels=True,
levels=20):
if show_grid_lines:
gl = ax.gridlines(crs=ccrs.PlateCarree(),
linewidth=1,
color='black',
draw_labels=show_grid_labels,
alpha=0.5,
linestyle='--')
else:
gl = []
if data_projection_code == 4326: # lat lon does nneed to be projected
data_crs = ccrs.PlateCarree()
else:
data_crs = ccrs.epsg(data_projection_code)
if plot_type == 'pcolormesh':
p = ax.pcolormesh(xx,
yy,
data,
transform=data_crs,
vmin=cmin,
vmax=cmax,
cmap=cmap)
elif plot_type == 'contourf':
p = ax.contourf(xx,
yy,
data,
levels,
transform=data_crs,
vmin=cmin,
vmax=cmax,
cmap=cmap)
else:
raise ValueError(
'plot_type must be either "pcolormesh" or "contourf"')
ax.coastlines('110m', linewidth=0.8)
ax.add_feature(cfeature.LAND)
cbar = []
if show_colorbar:
sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(cmin, cmax))
sm._A = []
cbar = plt.colorbar(sm, ax=ax)
return p, gl, cbar
def trajectory_vel_with_occupancy_grid(map, file_ptahs):
occupancy_grid, start, goal = get_occupancy_grid(map)
#plt.style.use('ggplot')
labels = []
for fp in file_ptahs:
# data_path = np.genfromtxt(fp, delimiter=',')
# plt.plot(data_path[:, 0], data_path[:, 1], color = "r" if "rrt" in fp else "b")
# labels.append("RRT" if "rrt" in fp else "Wavefront")
data_trajectory = np.genfromtxt(fp, delimiter=',')
fig, axs = plt.subplots()
velocities = data_trajectory[:, 2]
# Create a continuous norm to map from data points to colors
norm = plt.Normalize(velocities.min(), velocities.max())
points = np.array([data_trajectory[:, 0], data_trajectory[:, 1]]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
lc = LineCollection(segments, cmap="Reds" if "rrt" in fp else "Blues", norm=norm)
# Set the values used for colormapping
lc.set_array(velocities)
lc.set_linewidth(2)
line = axs.add_collection(lc)
plt.colorbar(line, ax=axs)
occupancy_grid.draw()
plt.show()
#plt.title('Planned trajectories')
plt.legend(labels)
occupancy_grid.draw()
plt.show()
def __call__(self, i):
if i % 3 == 0:
step = "predict"
if i % 3 == 1:
step = "correct"
if i % 3 == 2:
step = "resample"
particles, weights, lines_coordinates, (x, y), measurements, (x_true, y_true), step = self.moveState(step)
self.particlesScatter.set_offsets(np.c_[[p.x for p in particles], [p.y for p in particles]])
normcolor = plt.Normalize(np.min(weights), np.max(weights))
self.particlesScatter.set_array(normcolor(weights))
self.lines.set_segments(lines_coordinates)
self.positionEst.set_data(x, y)
self.positionTrue.set_data(x_true, y_true)
if step == 'correct':
sizes = np.array([m for m in measurements.values()])
self.circles._widths = np.asarray(sizes).ravel()
self.circles._heights = np.asarray(sizes).ravel()
self.circles.set_edgecolor('black')
else:
self.circles.set_edgecolor('none')
self.text.set_text("STEP: " + step)
return (self.particlesScatter, self.lines, self.positionEst, self.positionTrue, self.circles, self.text, )
def plot_global(xx,yy, data,
data_projection_code,
cmin, cmax, ax,
plot_type = 'pcolormesh',
show_colorbar=False,
cmap=None,
show_grid_lines = True,
show_grid_labels = True,
grid_linewidth = 1,
custom_background = False,
background_name = [],
background_resolution = [],
levels=20):
# assign cmap default
if cmap is None:
if cmin*cmax<0:
cmap = 'RdBu_r'
else:
cmap = 'viridis'
if show_grid_lines :
gl = ax.gridlines(crs=ccrs.PlateCarree(),
linewidth=1, color='black',
draw_labels = show_grid_labels,
alpha=0.5, linestyle='--', zorder=102)
else:
gl = []
if data_projection_code == 4326: # lat lon does nneed to be projected
data_crs = ccrs.PlateCarree()
else:
data_crs =ccrs.epsg(data_projection_code)
if custom_background:
ax.background_img(name=background_name, resolution=background_resolution)
if plot_type == 'pcolormesh':
p = ax.pcolormesh(xx, yy, data, transform=data_crs,
vmin=cmin, vmax=cmax, cmap=cmap)
elif plot_type =='contourf':
p = ax.contourf(xx, yy, data, levels, transform=data_crs,
vmin=cmin, vmax=cmax, cmap=cmap)
else:
raise ValueError('plot_type must be either "pcolormesh" or "contourf"')
if not custom_background:
ax.add_feature(cfeature.LAND, zorder=100)
ax.coastlines('110m', linewidth=grid_linewidth, zorder=101)
cbar = []
if show_colorbar:
sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(cmin,cmax))
sm._A = []
cbar = plt.colorbar(sm,ax=ax)
return p, gl, cbar
def surf(z, cmap='jet', ax=None, x=None, y=None, c=None, **kwargs):
'''
Creates an equivalent "surf" plot, like in matlab
Parameters
----------
z : :class:`numpy.ndarray`
The z data
cmap :
The colormap used to color based on z height. Default: jet
ax : :class:`matplotlib.axes.Axes`
The axes to draw on. Default: gca()
x : :class:`numpy.ndarray`, optional
The x coordinate used to draw. Default uses :func:`numpy.meshgrid`
y : :class:`numpy.ndarray`, optional
The y coordinate used to draw. Default uses :func:`numpy.meshgrid`
c : :class:`numpy.ndarray`, optional
A custom array that is fed into the colormap for coloring. Default uses
``z``
**kwargs : dict
Additional keyword arguments passed to :meth:`mpl_toolkits.mplot3d.axes3d.Axes3D.plot_surface`
By default, :meth:`mpl_toolkits.mplot3d.axes3d.Axes3D.plot_surface` does not
draw the entire mesh, it downsamples it to 50 points instead (for
efficiency). To disable downsampling, consider setting ``rstride`` and
``cstride`` to ``1``.
Shading is also disabled by default
'''
if x is None and y is None:
x, y = np.meshgrid(range(np.shape(z)[1]), range(np.shape(z)[0]))
elif x is None:
x, _ = np.meshgrid(range(np.shape(z)[1]), range(np.shape(z)[0]))
elif y is None:
_, y = np.meshgrid(range(np.shape(z)[1]), range(np.shape(z)[0]))
if c is None:
c = z
kwargs['shade'] = kwargs.pop('shade', False)
if ax is None:
ax = plt.gca(projection='3d')
scalarMap = mpl.cm.ScalarMappable(norm=plt.Normalize(vmin=c.min(),
vmax=c.max()),
cmap=cmap)
# outputs an array where each C value is replaced with a corresponding color value
c_colored = scalarMap.to_rgba(c)
surf = ax.plot_surface(x, y, z, facecolors=c_colored, **kwargs)
return surf
def _add_features_to_axis(ax, p, cmin, cmax,
cmap = 'jet',
show_coastline=True,
show_colorbar=True,
show_land=True,
show_grid_lines=True,
show_grid_labels=True,
show_coastline_over_data = True,
show_land_over_data = True,
grid_linewidth = 1,
grid_linestyle = '--',
colorbar_label = None):
if show_land:
if show_land_over_data:
# place land over the data
zorder = 75
else:
# place land under the data
zorder = 25
ax.add_feature(cfeature.LAND, zorder=zorder)
if show_coastline:
# place the coastline over land and over the data (default zorder 50)
if show_coastline_over_data:
zorder = 85
else:
# place coastline over land but under data
zorder = 35
ax.coastlines(linewidth=0.8, zorder=zorder)
gl = []
if show_grid_lines :
# grid lines go over everything (zorder 110)
gl = ax.gridlines(crs=ccrs.PlateCarree(),
linewidth=grid_linewidth,
color='black',
draw_labels = show_grid_labels,
alpha=0.5,
linestyle=grid_linestyle,
zorder=110)
cbar = []
if show_colorbar:
sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(cmin,cmax))
sm._A = []
cbar = plt.colorbar(sm,ax=ax)
#cbar = plt.colorbar(p, ax=ax)
if type(colorbar_label) is str:
cbar.set_label(colorbar_label)
return gl, cbar
def df_to_emotion_histogram(df,
palette=plt.cm.Pastel1,
emotion_column='emotion',
verbose=False):
""" Take a dataset like ArtEmis and return a histogram over the emotion choices made by the annotators.
:param df: dataframe carrying dataset
:param palette: matplotlib color palette, e.g., plt.cm.jet
:param emotion_column: (str) indicate which column of the dataframe carries the emotion
:return: a list carrying the resulting histogram figure.
"""
hist_vals = []
for emotion in ARTEMIS_EMOTIONS:
hist_vals.append(sum(df[emotion_column] == emotion) / len(df))
norm = plt.Normalize(min(hist_vals), max(hist_vals))
colors = palette(norm(hist_vals))
s = pd.DataFrame({"emotions": ARTEMIS_EMOTIONS, "vals": hist_vals})
s.set_index("emotions", drop=True, inplace=True)
plt.figure()
s.index.name = None
ax = s.plot.bar(grid=True,
figsize=(12, 4),
color=colors,
fontsize=16,
rot=45,
legend=False,
ec="k")
ax.set_ylabel('Percentage of data', fontsize=15)
for rec, col in zip(ax.patches, colors):
rec.set_color(col)
plt.tight_layout()
res = [plt.gcf()]
plt.figure()
s = df[emotion_column].apply(positive_negative_else).value_counts() / len(
df)
if verbose:
print('Pos-Neg-Else, percents:', s.round(3))
ax = s.plot.bar(grid=True,
figsize=(8, 4),
fontsize=16,
rot=45,
legend=False,
color='gray')
ax.set_xticklabels(['positive', 'negative', 'else'])
plt.tight_layout()
res.append(plt.gcf())
return res
def write_png(a, out):
comp = 6
writer = png.Writer(size=a.shape[::-1],
alpha=True,
bitdepth=depth,
compression=comp)
nrm = norm if norm != None else plt.Normalize(filter(a.min()),
filter(a.max()))
img = ((2**depth - 1) * jet(nrm(filter(a)))).astype(np.uint8)
img = img.reshape(img.shape[0], img.shape[1] * img.shape[2])
out_file = open(out, 'wb')
writer.write(out_file, img)
out_file.close()
def __init__(self, fig, ax, configuration, anchors):
self.fig = fig
self.ax = ax
self.conf = configuration
self.anchors = anchors
ax.set(title = "Particle filter state", xlabel = "$x$, meters", ylabel = "$y$, meters")
conf = self.conf
self.robot = Robot(conf['robot_start_x'], conf['robot_start_y'], conf['robot_start_theta'])
self.particleFilter = ParticleFilter(
conf['MIN_X'], conf['MAX_X'],
conf['MIN_Y'], conf['MAX_Y'],
conf['PARTICLES_NUM'])
self.ax.set(aspect = "equal", xlim = (conf['MIN_X'], conf['MAX_X']), ylim=(conf['MIN_Y'], conf['MAX_Y']))
normcolor = plt.Normalize(0.0, 0.01)
self.particlesScatter = self.ax.scatter(
[p.x for p in self.particleFilter.particles], [p.y for p in self.particleFilter.particles],
c=np.arange(conf['PARTICLES_NUM']), marker='.', alpha=0.5, cmap=plt.cm.rainbow, norm=normcolor, s=0.5,
label='particles')
cb = fig.colorbar(plt.cm.ScalarMappable(cmap=plt.cm.rainbow), ax = ax, shrink=0.8)
cb.set_label('Relative particle weight')
self.anchorsScatter = self.ax.scatter([a.x for a in anchors], [a.y for a in anchors],
color='red', marker='x', label='anchors')
lines_coordinates = [[(0.0, 0.0), (0.0, 0.0)]]
lc = mc.LineCollection(lines_coordinates, linewidths=1)
self.lines = self.ax.add_collection(lc)
self.positionEst, = self.ax.plot([0.0], [0.0], marker='x', markersize=9, color="green", alpha=0.98,
label='Estimated position')
self.positionTrue, = self.ax.plot([0.0], [0.0], marker='+', markersize=9, color="black",
label='True position')
self.text = ax.text(conf['MIN_X'] + (conf['MIN_X'] + conf['MAX_X']) * 0.5,
conf['MIN_Y'] + (conf['MIN_Y'] + conf['MAX_Y']) * 0.05, "")
centers = np.array([[a.x, a.y] for a in anchors])
cl = mc.EllipseCollection([1.] * len(anchors), [1.] * len(anchors), [1.] * len(anchors),
offsets=centers, transOffset=ax.transData, units='xy', facecolors='none', color='black', alpha=0.5)
self.circles = ax.add_collection(cl)
self.circles.set_facecolor('none')
self.ax.legend(loc = 'upper left')
def plot_3D_zinflc(sim):
"""
3D plot of the infiltration field map
"""
isvegc = sim.isvegc
dx = sim.dx
ncol = isvegc.shape[0]
nrow = isvegc.shape[1]
xc = np.arange(0, ncol*dx, dx) + dx/2
yc = np.arange(0, nrow*dx, dx) + dx/2
xc, yc = np.meshgrid(xc, yc)
xc = xc.T
yc = yc.T
fig = plt.figure( figsize = (10, 5))
ax = fig.add_subplot(111, projection='3d')
# Get rid of colored axes planes`
ax.xaxis.pane.fill = False
ax.yaxis.pane.fill = False
ax.zaxis.pane.fill = False
ax.xaxis.pane.set_edgecolor('w')
ax.yaxis.pane.set_edgecolor('w')
ax.zaxis.pane.set_edgecolor('w')
ax.set_xticks([], []);
ax.set_zticks([], []);
ax.set_yticks([], []);
ax.grid(False)
# # Plot the surface with face colors taken from the array we made.
norm = plt.Normalize()
colors = cmocean.cm.deep(norm(sim.zinflc ))
ax.w_xaxis.set_pane_color((1.0, 1.0, 1.0, 1.0))
im = ax.plot_surface(xc, yc+1 ,yc, facecolors = colors , rstride = 1, cstride = 1,
linewidth=0,antialiased=True, shade=False)
ax.view_init(25, 195)
return im
def plot_grid_search_scores(grid_search_cv,
vmin=None,
vmax=None,
fig_name=None,
show_plot=True):
"""Draw heatmap of the validation accuracy as a function of x and y
Keyword arguments:
grid_search ... sklearn.grid_search.GridSearchCV object, fitted estimator
"""
try:
y_name, x_name = grid_search_cv.grid_scores_[0][0].keys()
except:
raise Exception('Number of parameters must be 2')
x_range = grid_search_cv.param_grid[x_name]
y_range = grid_search_cv.param_grid[y_name]
scores = [x[1] for x in grid_search_cv.grid_scores_]
scores = np.array(scores).reshape(len(y_range), len(x_range))
fig = plt.figure(figsize=(8, 6))
plt.rc('text', usetex=True)
plt.rc('font', family='serif', serif='Times New Roman')
plt.rc('pgf', texsystem='pdflatex')
plt.subplots_adjust(left=.2, right=0.95, bottom=0.15, top=0.95)
plt.imshow(scores,
interpolation='nearest',
cmap=plt.cm.hot,
norm=plt.Normalize(vmin=vmin, vmax=vmax))
plt.xlabel(x_name, size=20)
plt.ylabel(y_name, size=20)
plt.colorbar()
plt.xticks(np.arange(len(x_range)), x_range.round(5), rotation=45, size=10)
plt.yticks(np.arange(len(y_range)), y_range.round(5), size=10)
plt.title('Validation Accuracy', size=22)
if fig_name is not None:
plt.savefig(fig_name)
if not show_plot:
plt.close(fig)
plt.show()
def colorline(x,
y,
z=None,
cmap='copper',
norm=plt.Normalize(0.0, 1.0),
linewidth=2,
alpha=1.0,
ax=None):
"""
Adapted from :
https://stackoverflow.com/questions/36074455/python-matplotlib-with-a-line-color-gradient-and-colorbar
http://nbviewer.ipython.org/github/dpsanders/matplotlib-examples/blob/master/colorline.ipynb
http://matplotlib.org/examples/pylab_examples/multicolored_line.html
Plot a colored line with coordinates x and y
Optionally specify colors in the array z
Optionally specify a colormap, a norm function and a line width
"""
# Default colors equally spaced on [0,1]:
if z is None:
z = np.linspace(0.0, 1.0, len(x))
# Special case if a single number:
# to check for numerical input -- this is a hack
if not hasattr(z, "__iter__"):
z = np.array([z])
z = np.asarray(z)
segments = make_segments(x, y)
lc = mcoll.LineCollection(segments,
array=z,
cmap=custom_cmap,
norm=norm,
linewidth=linewidth,
alpha=alpha)
if ax == None:
ax = plt.gca()
ax.add_collection(lc)
return lc
def update_map(self):
if self.index < self.size:
self.save_map_v.update_frame_no(self.index)
cmap = plt.cm.jet
norm = plt.Normalize(0, np.max(self.confirmed_raw[:, self.index]))
patches = [
Polygon(shape,
True,
color=cmap(
norm(
int(self.confirmed_data[get_country[
info['WB_A2']]][self.index])))) for info,
shape in zip(self.map.countries_info, self.map.countries)
if info['WB_A2'] in self.countries_codes
if get_country[info['WB_A2']] in self.countries_names
]
if self.index != 0:
self.pc.remove()
self.cax.cla()
else:
self.timer.stop()
self.pc = PatchCollection(patches,
match_original=True,
edgecolor='k',
linewidths=1.,
zorder=2)
self.ax.add_collection(self.pc)
self.ax.set_title(f'cases in {self.dates[self.index]}')
self.sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
self.sm.set_array(list(self.confirmed_raw[:, self.index]))
self.fig.colorbar(self.sm,
ax=self.ax,
cax=self.cax,
orientation='vertical')
self.fig.canvas.draw_idle()
self.fig.savefig(f"imgs/img{0}_{self.index}.jpeg")
self.index += 1
else:
self.stop_start(0)
def plot_3D_veg(sim):
"""
3D plot of the vegetation field
"""
fig = plt.figure( figsize = (15, 7))
ax = fig.add_subplot(111, projection='3d')
# Get rid of colored axes planes
ax.xaxis.pane.fill = False
ax.yaxis.pane.fill = False
ax.zaxis.pane.fill = False
ax.xaxis.pane.set_edgecolor('w')
ax.yaxis.pane.set_edgecolor('w')
ax.zaxis.pane.set_edgecolor('w')
ax.set_xticks([], []);
ax.set_zticks([], []);
ax.set_yticks([], []);
# plt.axis('off')
ax.grid(False)
isvegc = sim.isvegc
dx = sim.dx
ncol = isvegc.shape[0]
nrow = isvegc.shape[1]
xc = np.arange(0, ncol*dx, dx) + dx/2
yc = np.arange(0, nrow*dx, dx) + dx/2
xc, yc = np.meshgrid(xc, yc)
xc = xc.T
yc = yc.T
#Plot the surface with face colors taken from the array we made.
norm = plt.Normalize()
colors = cm.Greens(norm(sim.isvegc ))
ax.w_xaxis.set_pane_color((1.0, 1.0, 1.0, 1.0))
im = ax.scatter(xc[ sim.isvegc == 1], yc[ sim.isvegc == 1],
yc[ sim.isvegc == 1], c = 'g', marker='o', s = 20, alpha =1)
ax.view_init(20, 195)
def plot_velocity(occ_grid, file_path, file_trajectory):
data_path = np.genfromtxt(file_path, delimiter=',')
data_trajectory = np.genfromtxt(file_trajectory, delimiter=',')
fig, axs = plt.subplots()
plt.plot(data_path[:, 0], data_path[:, 1], 'gray', label='path', zorder=9)
velocities = data_trajectory[:, 2]
# Create a continuous norm to map from data points to colors
norm = plt.Normalize(velocities.min(), velocities.max())
points = np.array([data_trajectory[:, 0],
data_trajectory[:, 1]]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
lc = LineCollection(segments, cmap='Blues', norm=norm, zorder=10)
# Set the values used for colormapping
lc.set_array(velocities)
lc.set_linewidth(2)
line = axs.add_collection(lc)
plt.colorbar(line, ax=axs)
occ_grid.draw()
plt.show()
def plot2D(x, y, z, zmin= None, zmax= None, xlim=None, ylim=None, nx = 200, ny = 200):
if zmin == None:
zmin = min(z)
if zmax == None:
zmax = max(z)
for i in range(len(z)):
z[i] = min(z[i], zmax)
z[i] = max(z[i], zmin)
xi = np.linspace(min(x), max(x), nx)
yi = np.linspace(min(y), max(y), ny)
zi = plt.mlab.griddata(x, y, z, xi, yi)
plt.contourf(xi, yi, zi, 32, cmap=plt.cm.jet) #, norm=plt.Normalize(zmin, zmax))
plt.contourf(xi, yi, zi, 32, norm=plt.Normalize(zmin, zmax))
if 1 == 1:
if (xlim == None):
plt.xlim(-6.0, +6.0)
else:
plt.xlim(xlim[0], xlim[1]);
if (ylim == None):
plt.ylim(-6.0, +6.0)
else:
plt.ylim(ylim[0], ylim[1]);
else:
plt.xlim(-0.5, +0.5)
plt.ylim(-0.5, +0.5)
plt.colorbar()
plt.show()
def choroplethMap(df,col,title,cmap='OrRd',figsize=(15,8)):
'''
This function creates choropleth map of input feature
Inpute Parameters:
df:Input DataFrame
col:Feature Name from dataframe to plot choropleth map
title: Title of choropleth map
cmap: (Optional) Color map Default:'OrRd'
figsize: (Optional) figure size Default:(15,8)
Returns:
Choropleth Map
'''
fig, ax = plt.subplots(figsize=figsize)
df.plot(column=col,ax=ax, cmap=cmap, edgecolor='black',linewidth=0.5)
for idx, row in df.iterrows():
plt.annotate(text=row['STATE_ABBR'], xy=row['coords'], horizontalalignment='center',size=8)
ax.set_title(title, fontsize=16)
ax.set_axis_off()
# Create colorbar
vmin = df[col].min()
vmax = df[col].max()
sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(vmin=vmin, vmax=vmax))
sm._A = []
fig.colorbar(sm)
def StellarMassVsOrbitalDistanceVsT90(host, sats, BB, rest, rad, path=''):
x, y, c, s, S = [[[], []], [[], []], [[], []], [[], []], [[], []]]
for h in sats:
if h not in BB:
rel = sats[h]['center'] - host[sats[h]['Host']]['center']
wrap(rel, scale=1, boxsize=25e3)
if sats[h]['Quenched']:
x[0].append(np.linalg.norm(rel))
y[0].append(np.log10(sats[h]['Mstar']))
c[0].append(t_at_sffrac(sats[h]['CumSFH'], .9))
s[0].append(float(sats[h]['Rvir']))
else:
x[1].append(np.linalg.norm(rel))
y[1].append(np.log10(sats[h]['Mstar']))
c[1].append(t_at_sffrac(sats[h]['CumSFH'], .9))
s[1].append(float(sats[h]['Rvir']))
M = max([max(s[0]), max(s[1])])
a = 0
while a < len(s[0]):
S[0].append((4 + (s[0][a] / M) * 10)**2)
a += 1
a = 0
while a < len(s[1]):
S[1].append((4 + (s[1][a] / M) * 10)**2)
a += 1
f, ax = plt.subplots(1, 1, figsize=(10, 8))
ax.set_xlim([0, 400])
ax.set_ylim([6.9, 10.6])
ax.scatter(0,
0,
s=8**2,
marker='D',
edgecolor='.5',
facecolor='None',
label='Quenched')
ax.scatter(0,
0,
s=10**2,
edgecolor='.5',
facecolor='None',
label='Star Forming')
ax.tick_params(labelsize=15,
direction='in',
length=5,
width=1,
top=True,
right=True)
ax.set_xlabel(r'Distance to Host [kpc]', fontsize=25)
ax.set_ylabel(r'Log(M$_{*}$) [M$_{\odot}$]', fontsize=25)
norm = plt.Normalize(3, 13)
p = ax.scatter(x[0],
y[0],
c=c[0],
cmap='viridis',
s=S[0],
norm=norm,
marker='D',
edgecolor='.5',
linewidth=.5)
ax.scatter(x[1],
y[1],
c=c[1],
cmap='viridis',
s=S[1],
norm=norm,
edgecolor='.5',
linewidth=.5)
cbar = f.colorbar(p, cax=f.add_axes([.91, .11, .03, .77]))
cbar.set_label(r'$\tau_{90}$ [Gyr]', fontsize=25)
cbar.ax.tick_params(labelsize=15, length=3)
ax.legend(loc='upper right', prop={'size': 15}, ncol=1, frameon=False)
f.savefig(path + 'StellarMassVsOrbitalDistanceVsT90.' + rest + '.' + rad +
'.png',
bbox_inches='tight',
pad_inches=.1)
f.savefig(path + 'pdf/StellarMassVsOrbitalDistanceVsT90.' + rest + '.' +
rad + '.pdf',
bbox_inches='tight',
pad_inches=.1)
plt.close()
def plot_pstereo(xx,yy, data,
data_projection_code, \
lat_lim,
cmin, cmax, ax,
plot_type = 'pcolormesh',
show_colorbar=False,
circle_boundary = False,
grid_linewidth = 1,
grid_linestyle = '--',
cmap='jet',
show_grid_lines=False,
custom_background = False,
background_name = [],
background_resolution = [],
levels = 20,
less_output=True):
if isinstance(ax.projection, ccrs.NorthPolarStereo):
ax.set_extent([-180, 180, lat_lim, 90], ccrs.PlateCarree())
if not less_output:
print('North Polar Projection')
elif isinstance(ax.projection, ccrs.SouthPolarStereo):
ax.set_extent([-180, 180, -90, lat_lim], ccrs.PlateCarree())
if not less_output:
print('South Polar Projection')
else:
raise ValueError(
'ax must be either ccrs.NorthPolarStereo or ccrs.SouthPolarStereo')
if not less_output:
print('lat_lim: ', lat_lim)
if circle_boundary:
theta = np.linspace(0, 2 * np.pi, 100)
center, radius = [0.5, 0.5], 0.5
verts = np.vstack([np.sin(theta), np.cos(theta)]).T
circle = mpath.Path(verts * radius + center)
ax.set_boundary(circle, transform=ax.transAxes)
if show_grid_lines:
gl = ax.gridlines(crs=ccrs.PlateCarree(),
linewidth=grid_linewidth,
color='black',
alpha=0.5,
linestyle=grid_linestyle)
else:
gl = []
if data_projection_code == 4326: # lat lon does nneed to be projected
data_crs = ccrs.PlateCarree()
else:
# reproject the data if necessary
data_crs = ccrs.epsg(data_projection_code)
if custom_background:
ax.background_img(name=background_name,
resolution=background_resolution)
p = []
if plot_type == 'pcolormesh':
p = ax.pcolormesh(xx, yy, data, transform=data_crs, \
vmin=cmin, vmax=cmax, cmap=cmap)
elif plot_type == 'contourf':
p = ax.contourf(xx, yy, data, levels, transform=data_crs, \
vmin=cmin, vmax=cmax, cmap=cmap)
else:
raise ValueError(
'plot_type must be either "pcolormesh" or "contourf"')
if not custom_background:
ax.add_feature(cfeature.LAND)
ax.coastlines('110m', linewidth=0.8)
cbar = []
if show_colorbar:
sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(cmin, cmax))
sm._A = []
cbar = plt.colorbar(sm, ax=ax)
return p, gl, cbar
def plot(self, block=False, period=False, fap=None, gls=True, data=True, residuals=True):
"""
Create a plot.
Parameters
----------
period : boolean
The periodogram is plotted against log(Period).
fap : float, list
Plots the FAP levels.
gls : boolean
Plots the GLS periodogram.
data : boolean
Plots the data.
residuals : boolean
Plots the residuals.
Returns
-------
fig : mpl.figure
A figure which can be modified.
"""
try:
import matplotlib
import matplotlib.pylab as mpl
except ImportError:
raise(ImportError("Could not import matplotlib.pylab."))
fbest, T0 = self.best["f"], self.best["T0"]
fig = mpl.figure()
fig.canvas.set_window_title('GLS periodogram')
fig.subplots_adjust(hspace=0.05, wspace=0.04, right=0.97, bottom=0.09, top=0.84)
fs = 10 # fontsize
nrow = gls + data + residuals
plt, plt1, plt2, plt3, plt4 = [None] * 5
if gls:
# Periodogram
plt = fig.add_subplot(nrow, 1, 1)
plt.tick_params(direction='in')
if period:
plt.set_xscale("log")
plt.set_xlabel("Period P")
else:
plt.set_xlabel("Frequency $f$")
plt.set_ylabel(self.label["ylabel"])
plt.plot(1/self.f if period else self.f, self.power, 'b-', linewidth=.5)
# mark the highest peak
plt.plot(1/fbest if period else fbest, self.power[self.p.argmax()], 'r.', label="$1/f = %f$" % (1/fbest))
x2tics = 1 / np.array([0.5, 1, 2, 3, 5, 10, 20., 100])
mx2tics = 1 / np.array([0.75, 1.5, 2.5, 4, 15, 40, 60., 80, 100])
def tick_function(X):
return ["%g" % (1/z) for z in X]
plt.tick_params(direction='in', which='both', top=True, right=True)
plt.minorticks_on()
plt.autoscale(enable=True, axis='x', tight=True)
if not period:
ax2 = plt.twiny()
ax2.tick_params(direction='in', which='both')
ax2.format_coord = lambda x,y: "x=%g, x2=%g, y=%g"% (x, 1/x, y)
ax2.set_xticks(x2tics)
ax2.set_xticks(mx2tics, minor=True)
ax2.set_xticklabels(tick_function(x2tics))
ax2.set_xlim(plt.get_xlim())
ax2.set_xlabel("Period")
plt.tick_params(top=False)
if fap is not None:
if isinstance(fap, float):
fap = [fap]
n = max(1, len(fap)-1) # number of dash types
for i,fapi in enumerate(fap):
plt.axhline(self.powerLevel(fapi), linewidth=0.5, color='r', dashes=(8+32*(n-i)/n,8+32*i/n), label="FAP = %s%%"%(fapi*100))
plt.legend(numpoints=1, fontsize=fs, frameon=False)
# Data and model
col = mpl.cm.rainbow(mpl.Normalize()(self.t))
def plot_ecol(plt, x, y):
# script for scatter plot with errorbars and time color-coded
datstyle = dict(color=col, marker='.', edgecolor='k', linewidth=0.5, zorder=2)
if self.e_y is not None:
errstyle = dict(yerr=self.e_y, marker='', ls='', elinewidth=0.5)
if matplotlib.__version__ < '2.' :
errstyle['capsize'] = 0.
datstyle['s'] = 8**2 # requires square size !?
else:
errstyle['ecolor'] = col
_, _, (c,) = plt.errorbar(x, y, **errstyle)
if matplotlib.__version__ < '2.':
c.set_color(col)
plt.scatter(x, y, **datstyle)
def phase(t):
#return (t-T0)*fbest % 1
return (t-T0) % (1/fbest)
if data:
# Time series
tt = arange(self.t.min(), self.t.max(), 0.01/fbest)
ymod = self.sinmod(tt)
plt1 = fig.add_subplot(nrow, 2, 2*gls+1)
plt1.set_ylabel("Data")
if residuals:
mpl.setp(plt1.get_xticklabels(), visible=False)
else:
plt1.set_xlabel("Time")
plot_ecol(plt1, self.t, self.y)
plt1.plot(tt, ymod, 'k-', zorder=0)
# Phase folded data
tt = arange(T0, T0+1/fbest, 0.01/fbest)
yy = self.sinmod(tt)
plt2 = fig.add_subplot(nrow, 2, 2*gls+2, sharey=plt1)
mpl.setp(plt2.get_yticklabels(), visible=False)
if residuals:
mpl.setp(plt2.get_xticklabels(), visible=False)
else:
plt2.set_xlabel("Phase")
plot_ecol(plt2, phase(self.t), self.y)
xx = phase(tt)
ii = np.argsort(xx)
plt2.plot(xx[ii], yy[ii], 'k-')
plt2.format_coord = lambda x,y: "x=%g, x2=%g, y=%g"% (x, x*fbest, y)
if residuals:
# Time serie of residuals
yfit = self.sinmod()
yres = self.y - yfit
plt3 = fig.add_subplot(nrow, 2, 2*(gls+data)+1, sharex=plt1)
plt3.set_xlabel("Time")
plt3.set_ylabel("Residuals")
plot_ecol(plt3, self.t, yres)
plt3.plot([self.t.min(), self.t.max()], [0,0], 'k-')
# Phase folded residuals
plt4 = fig.add_subplot(nrow, 2, 2*(gls+data)+2, sharex=plt2, sharey=plt3)
plt4.set_xlabel("Phase")
mpl.setp(plt4.get_yticklabels(), visible=False)
plot_ecol(plt4, phase(self.t), yres)
plt4.plot([0,1/fbest], [0,0], 'k-')
plt4.format_coord = lambda x,y: "x=%g, x2=%g, y=%g"% (x, x*fbest, y)
for x in fig.get_axes()[2:]:
x.tick_params(direction='in', which='both', top=True, right=True)
x.minorticks_on()
x.autoscale(enable=True, tight=True)
if hasattr(mpl.get_current_fig_manager(), 'toolbar'):
# check seems not needed when "TkAgg" is set
try:
mpl.get_current_fig_manager().toolbar.pan()
except:
pass # e.g. Jupyter
#t = fig.canvas.toolbar
#mpl.ToggleTool(mpl.wx_ids['Pan'], False)
fig.tight_layout() # to get the left margin
marleft = fig.subplotpars.left * fig.get_figwidth() * fig.dpi / fs
def tighter():
# keep margin tight when resizing
xdpi = fs / (fig.get_figwidth() * fig.dpi)
ydpi = fs / (fig.get_figheight() * fig.dpi)
fig.subplots_adjust(bottom=4.*ydpi, top=1-ydpi-4*gls*ydpi, right=1-1*xdpi, wspace=4*xdpi, hspace=4*ydpi, left=marleft*xdpi)
if gls and (residuals or data):
# gls plot needs additional space for x2axis
fig.subplots_adjust(top=1-8*ydpi)
if matplotlib.__version__ < '2.':
ax2.set_position(plt.get_position().translated(0,4*ydpi))
plt.set_position(plt.get_position().translated(0,4*ydpi))
#fig.canvas.mpl_connect("resize_event", lambda _: (fig.tight_layout()))
fig.canvas.mpl_connect("resize_event", lambda _: (tighter()))
fig.show()
if block:
print("Close the plot to continue.")
# needed when called from shell
mpl.show()
else:
# avoids blocking when: import test_gls
mpl.ion()
# mpl.show(block=block) # unexpected keyword argument 'block' in older matplotlib
return fig
def plot_proj_to_latlon_grid(lons,
lats,
data,
projection_type='robin',
plot_type='pcolormesh',
user_lon_0=0,
user_lat_0=None,
lat_lim=50,
parallels=None,
levels=20,
cmap=None,
dx=.25,
dy=.25,
show_colorbar=False,
show_grid_lines=True,
show_grid_labels=False,
show_coastline=True,
show_land=True,
grid_linewidth=1,
grid_linestyle='--',
subplot_grid=None,
less_output=True,
custom_background=False,
background_name=[],
background_resolution=[],
radius_of_influence=100000,
**kwargs):
"""Generate a plot of llc data, resampled to lat/lon grid, on specified
projection.
Parameters
----------
lons, lats, data : xarray DataArray :
give the longitude, latitude values of the grid, and the 2D field to
be plotted
projection_type : string, optional
denote the type of projection, see Cartopy docs.
options include
'robin' - Robinson
'PlateCarree' - flat 2D projection
'LambertConformal'
'Mercator'
'EqualEarth'
'Mollweide'
'AlbersEqualArea'
'cyl' - Lambert Cylindrical
'ortho' - Orthographic
'stereo' - polar stereographic projection, see lat_lim for choosing
'InterruptedGoodeHomolosine'
North or South
user_lon_0 : float, optional, default 0 degrees
denote central longitude
user_lat_0 : float, optional,
denote central latitude (for relevant projections only, see Cartopy)
lat_lim : int, optional, default 50 degrees
for stereographic projection, denote the Southern (Northern) bounds for
North (South) polar projection or cutoff for LambertConformal projection
parallels : float, optional,
standard_parallels, one or two latitudes of correct scale
(for relevant projections only, see Cartopy docs)
levels : int, optional
number of contours to plot
cmap : string or colormap object, optional
denotes to colormap. Default is 'viridis' for data without sign change,
and 'RdBu_r' for "diverging" data (i.e. positive and negative)
dx, dy : float, optional
latitude, longitude spacing for grid resampling
show_colorbar : logical, optional, default False
show a colorbar or not,
show_grid_lines : logical, optional, default True
True only possible for some cartopy projections
show_grid_labels: logical, optional, default False
True only possible for some cartopy projections
grid_linewidth : float, optional, default 1.0
width of grid lines
grid_linestyle : string, optional, default = '--'
pattern of grid lines,
cmin, cmax : float, optional
minimum and maximum values for colorbar, default is: min/max of data
if no sign change, otherwise cmax = max(abs(data)), cmin = -cmax
i.e. centered about zero
subplot_grid : dict or list, optional
specifying placement on subplot as
dict:
{'nrows': rows_val, 'ncols': cols_val, 'index': index_val}
list:
[nrows_val, ncols_val, index_val]
equates to
matplotlib.pyplot.subplot(
row=nrows_val, col=ncols_val,index=index_val)
less_output : string, optional
debugging flag, don't print if True
radius_of_influence : float, optional. Default 100000 m
the radius of the circle within which the input data is search for
when mapping to the new grid
"""
cmap, (cmin, cmax) = assign_colormap(data, cmap)
# default
circle_boundary = False
for key in kwargs:
if key == "cmin":
cmin = kwargs[key]
elif key == "cmax":
cmax = kwargs[key]
elif key == "circle_boundary":
circle_boundary = kwargs[key]
print('circle boundary', circle_boundary)
else:
print("unrecognized argument ", key)
#%%
# To avoid plotting problems around the date line, lon=180E, -180W
# plot the data field in two parts, A and B.
# part 'A' spans from starting longitude to 180E
# part 'B' spans the from 180E to 360E + starting longitude.
# If the starting longitudes or 0 or 180 it is a special case.
if user_lon_0 > -180 and user_lon_0 < 180:
A_left_limit = user_lon_0
A_right_limit = 180
B_left_limit = -180
B_right_limit = user_lon_0
center_lon = A_left_limit + 180
if not less_output:
print('-180 < user_lon_0 < 180')
elif user_lon_0 == 180 or user_lon_0 == -180:
A_left_limit = -180
A_right_limit = 0
B_left_limit = 0
B_right_limit = 180
center_lon = 0
if not less_output:
print('user_lon_0 ==-180 or 180')
else:
raise ValueError('invalid starting longitude')
#%%
# the number of degrees spanned in part A and part B
num_deg_A = int((A_right_limit - A_left_limit) / dx)
num_deg_B = int((B_right_limit - B_left_limit) / dx)
# find the longitudal limits of part A and B
lon_tmp_d = dict()
if num_deg_A > 0:
lon_tmp_d['A'] = [A_left_limit, A_right_limit]
if num_deg_B > 0:
lon_tmp_d['B'] = [B_left_limit, B_right_limit]
if projection_type == 'stereo' and user_lat_0 == None:
if lat_lim > 0:
user_lat_0 = 90
else:
user_lat_0 = -90
# Make projection axis
ax = _create_projection_axis(projection_type, user_lon_0, user_lat_0,
parallels, lat_lim, subplot_grid, less_output)
#%%
# loop through different parts of the map to plot (if they exist),
# do interpolation and plot
f = plt.gcf()
if not less_output:
print('len(lon_tmp_d): ', len(lon_tmp_d))
for key, lon_tmp in lon_tmp_d.items():
new_grid_lon, new_grid_lat, data_latlon_projection = \
resample_to_latlon(lons, lats, data,
-90+dy, 90-dy, dy,
lon_tmp[0], lon_tmp[1], dx,
mapping_method='nearest_neighbor',
radius_of_influence = radius_of_influence)
if isinstance(ax.projection, ccrs.NorthPolarStereo) or \
isinstance(ax.projection, ccrs.SouthPolarStereo) :
p, gl, cbar = \
plot_pstereo(new_grid_lon,
new_grid_lat,
data_latlon_projection,
4326, lat_lim,
cmin, cmax, ax,
plot_type = plot_type,
show_colorbar=False,
show_coastline = show_coastline,
show_land = show_land,
circle_boundary=circle_boundary,
cmap=cmap,
show_grid_lines=False,
show_grid_labels = False,
custom_background = custom_background,
background_name = background_name,
background_resolution = background_resolution,
less_output=less_output)
else: # not polar stereo
p, gl, cbar = \
plot_global(new_grid_lon,
new_grid_lat,
data_latlon_projection,
4326,
cmin, cmax, ax,
plot_type = plot_type,
show_colorbar = False,
show_coastline = show_coastline,
show_land = show_land,
cmap=cmap,
show_grid_lines = False,
show_grid_labels = False,
custom_background = custom_background,
background_name = background_name,
background_resolution = background_resolution,
less_output=less_output)
if show_land:
ax.add_feature(cfeature.LAND, zorder=100)
if show_coastline:
ax.add_feature(cfeature.COASTLINE, linewidth=0.5, zorder=101)
if show_grid_lines:
if not less_output:
print('-- pre plot_pstereo or plot_pstereo', show_grid_lines,
show_grid_labels)
gl2 = ax.gridlines(crs=ccrs.PlateCarree(),
linewidth=grid_linewidth,
color='black',
alpha=0.5,
linestyle=grid_linestyle,
draw_labels=show_grid_labels,
zorder=110)
#ax.gridlines(draw_labels=True,zorder=110)
if show_colorbar:
sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(cmin, cmax))
sm._A = []
cbar = plt.colorbar(sm, ax=ax)
label = ''
if type(data) == xr.DataArray:
if 'long_name' in data.attrs:
label = data.long_name
elif data.name is not None:
label = data.name
if 'units' in data.attrs:
label += ' [' + data.units + ']'
cbar.set_label(label)
#%%
return f, ax, p, cbar, new_grid_lon, new_grid_lat, data_latlon_projection, gl
def plot_proj_to_latlon_grid(lons,
lats,
data,
projection_type='robin',
plot_type='pcolormesh',
user_lon_0=0,
lat_lim=50,
levels=20,
cmap='jet',
dx=.25,
dy=.25,
show_colorbar=False,
show_grid_lines=True,
show_grid_labels=True,
grid_linewidth=1,
grid_linestyle='--',
subplot_grid=None,
less_output=True,
custom_background=False,
background_name=[],
background_resolution=[],
**kwargs):
"""Generate a plot of llc data, resampled to lat/lon grid, on specified
projection.
Parameters
----------
lons, lats, data : xarray DataArray :
give the longitude, latitude values of the grid, and the 2D field to
be plotted
projection_type : string, optional
denote the type of projection, options include
'robin' - Robinson
'PlateCaree' - flat 2D projection
'Mercator'
'cyl' - Lambert Cylindrical
'ortho' - Orthographic
'stereo' - polar stereographic projection, see lat_lim for choosing
'InterruptedGoodeHomolosine'
North or South
user_lon_0 : float, optional, default 0 degrees
denote central longitude
lat_lim : int, optional
for stereographic projection, denote the Southern (Northern) bounds for
North (South) polar projection
levels : int, optional
number of contours to plot
cmap : string or colormap object, optional
denotes to colormap
dx, dy : float, optional
latitude, longitude spacing for grid resampling
show_colorbar : logical, optional, default False
show a colorbar or not,
show_grid_lines : logical, optional
True only possible for Mercator or PlateCarree projections
grid_linewidth : float, optional, default 1.0
width of grid lines
grid_linestyle : string, optional, default = '--'
pattern of grid lines,
cmin, cmax : float, optional
minimum and maximum values for colorbar, default is min/max of data
subplot_grid : dict or list, optional
specifying placement on subplot as
dict:
{'nrows': rows_val, 'ncols': cols_val, 'index': index_val}
list:
[nrows_val, ncols_val, index_val]
equates to
matplotlib.pyplot.subplot(
row=nrows_val, col=ncols_val,index=index_val)
less_output : string, optional
debugging flag, don't print if True
"""
#%%
cmin = np.nanmin(data)
cmax = np.nanmax(data)
for key in kwargs:
if key == "cmin":
cmin = kwargs[key]
elif key == "cmax":
cmax = kwargs[key]
else:
print("unrecognized argument ", key)
#%%
# To avoid plotting problems around the date line, lon=180E, -180W
# plot the data field in two parts, A and B.
# part 'A' spans from starting longitude to 180E
# part 'B' spans the from 180E to 360E + starting longitude.
# If the starting longitudes or 0 or 180 it is a special case.
if user_lon_0 > -180 and user_lon_0 < 180:
A_left_limit = user_lon_0
A_right_limit = 180
B_left_limit = -180
B_right_limit = user_lon_0
center_lon = A_left_limit + 180
if not less_output:
print('-180 < user_lon_0 < 180')
elif user_lon_0 == 180 or user_lon_0 == -180:
A_left_limit = -180
A_right_limit = 0
B_left_limit = 0
B_right_limit = 180
center_lon = 0
if not less_output:
print('user_lon_0 ==-180 or 180')
else:
raise ValueError('invalid starting longitude')
#%%
# the number of degrees spanned in part A and part B
num_deg_A = int((A_right_limit - A_left_limit) / dx)
num_deg_B = int((B_right_limit - B_left_limit) / dx)
# find the longitudal limits of part A and B
lon_tmp_d = dict()
if num_deg_A > 0:
lon_tmp_d['A'] = [A_left_limit, A_right_limit]
if num_deg_B > 0:
lon_tmp_d['B'] = [B_left_limit, B_right_limit]
# Make projection axis
(ax, show_grid_labels) = _create_projection_axis(projection_type,
user_lon_0, lat_lim,
subplot_grid, less_output)
#%%
# loop through different parts of the map to plot (if they exist),
# do interpolation and plot
f = plt.gcf()
if not less_output:
print('len(lon_tmp_d): ', len(lon_tmp_d))
for key, lon_tmp in lon_tmp_d.items():
new_grid_lon, new_grid_lat, data_latlon_projection = \
resample_to_latlon(lons, lats, data,
-90+dy, 90-dy, dy,
lon_tmp[0], lon_tmp[1], dx,
mapping_method='nearest_neighbor')
if isinstance(ax.projection, ccrs.NorthPolarStereo) or \
isinstance(ax.projection, ccrs.SouthPolarStereo) :
p, gl, cbar = \
plot_pstereo(new_grid_lon,
new_grid_lat,
data_latlon_projection,
4326, lat_lim,
cmin, cmax, ax,
plot_type = plot_type,
show_colorbar=False,
circle_boundary=True,
cmap=cmap,
show_grid_lines=False,
custom_background = custom_background,
background_name = background_name,
background_resolution = background_resolution,
less_output=less_output)
else: # not polar stereo
p, gl, cbar = \
plot_global(new_grid_lon,
new_grid_lat,
data_latlon_projection,
4326,
cmin, cmax, ax,
plot_type = plot_type,
show_colorbar = False,
cmap=cmap,
show_grid_lines = False,
custom_background = custom_background,
background_name = background_name,
background_resolution = background_resolution,
show_grid_labels = False)
if show_grid_lines:
ax.gridlines(crs=ccrs.PlateCarree(),
linewidth=grid_linewidth,
color='black',
alpha=0.5,
linestyle=grid_linestyle,
draw_labels=show_grid_labels)
#%%
# ax.add_feature(cfeature.LAND)
#ax.add_feature(cfeature.COASTLINE,linewidth=0.5)
ax = plt.gca()
if show_colorbar:
sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(cmin, cmax))
sm._A = []
cbar = plt.colorbar(sm, ax=ax)
#%%
return f, ax, p, cbar
def dailyStockClusters():
import datetime
import os
import numpy as np
import pandas.io.data as web
from pandas import DataFrame
from matplotlib import pylab as pl
from matplotlib import finance
from matplotlib.collections import LineCollection
from sklearn import cluster, covariance, manifold
########################################################################
###
### This example employs several unsupervised learning techniques to
### extract the stock market structure from variations in historical quotes.
### The quantity that we use is the daily variation in quote price:
### quotes that are linked tend to co-fluctuate during a day.
###
### stocks used are all Nasdaq 100 stocks that have one year of history
### from the current date.
###
### adopted from example at:
### http://scikit-learn.org/0.14/auto_examples/applications/plot_stock_market.html
###
########################################################################
# Retrieve the data from Internet
# Choose a time period reasonnably calm (not too long ago so that we get
# high-tech firms, and before the 2008 crash)
today = datetime.datetime.now()
d1 = datetime.datetime(today.year - 1, today.month, today.day)
d2 = datetime.datetime(today.year, today.month, today.day)
# input symbols and company names from text file
companyName_file = os.path.join(os.getcwd(), "symbols", "companyNames.txt")
with open(companyName_file, "r") as f:
companyNames = f.read()
print "\n\n\n"
companyNames = companyNames.split("\n")
ii = companyNames.index("")
del companyNames[ii]
companySymbolList = []
companyNameList = []
symbol_dict = {}
for iname, name in enumerate(companyNames):
name = name.replace("amp;", "")
testsymbol, testcompanyName = name.split(";")
companySymbolList.append(format(testsymbol, 's'))
companyNameList.append(format(testcompanyName, 's'))
if testsymbol != "CASH":
symbol_dict[testsymbol] = format(testcompanyName, 's')
print " ... symbol_dict = ", symbol_dict
symbols = companySymbolList[:]
names = companyNameList[:]
all_data = {}
for ticker in symbols:
try:
all_data[ticker] = web.get_data_yahoo(ticker, d1, d2)
qclose = DataFrame(
{tic: data['Close']
for tic, data in all_data.iteritems()})
qopen = DataFrame(
{tic: data['Open']
for tic, data in all_data.iteritems()})
except:
print "Cant find ", ticker
symbols_edit = []
names_edit = []
for i, ticker in enumerate(symbols):
if True in np.isnan(np.array(qclose[ticker])).tolist():
print ticker, " nans found, ticker removed"
del qclose[ticker]
del qopen[ticker]
else:
symbols_edit.append(ticker)
names_edit.append(names[i])
# The daily variations of the quotes are what carry most information
variation = qclose - qopen
variation[np.isnan(variation)] = 0.
###############################################################################
# Learn a graphical structure from the correlations
edge_model = covariance.GraphLassoCV()
# standardize the time series: using correlations rather than covariance
# is more efficient for structure recovery
X = variation.copy()
#X = variation.copy().T
X /= X.std(axis=0)
edge_model.fit(X)
###############################################################################
# Cluster using affinity propagation
_, labels = cluster.affinity_propagation(edge_model.covariance_)
n_labels = labels.max()
for i in range(n_labels + 1):
print "Cluster " + str(i) + ":"
for j in range(len(labels)):
if labels[j] == i:
print " ... " + names_edit[j]
#print('Cluster %i: %s' % ((i + 1), ', '.join(names_edit[labels == i])))
for i in range(n_labels + 1):
print "Cluster " + str(i) + ":"
for j in range(len(labels)):
if labels[j] == i:
print " ... " + names_edit[j]
figure7path = 'Clustered_companyNames.png' # re-set to name without full path
figure7_htmlText = "\n<br><h3>Daily stock clustering analyis. Based on one year performance correlations.</h3>\n"
figure7_htmlText = figure7_htmlText + "\nClustering based on daily variation in Nasdaq 100 quotes.\n"
figure7_htmlText = figure7_htmlText + '''<br><img src="''' + figure7path + '''" alt="PyTAAA by DonaldPG" width="850" height="500"><br>\n'''
###############################################################################
# Find a low-dimension embedding for visualization: find the best position of
# the nodes (the stocks) on a 2D plane
# We use a dense eigen_solver to achieve reproducibility (arpack is
# initiated with random vectors that we don't control). In addition, we
# use a large number of neighbors to capture the large-scale structure.
node_position_model = manifold.LocallyLinearEmbedding(n_components=2,
eigen_solver='dense',
n_neighbors=6)
embedding = node_position_model.fit_transform(X.T).T
###############################################################################
# Visualization
pl.figure(1, facecolor='w', figsize=(10, 8))
pl.clf()
ax = pl.axes([0., 0., 1., 1.])
pl.axis('off')
# Display a graph of the partial correlations
partial_correlations = edge_model.precision_.copy()
d = 1 / np.sqrt(np.diag(partial_correlations))
partial_correlations *= d
partial_correlations *= d[:, np.newaxis]
non_zero = (np.abs(np.triu(partial_correlations, k=1)) > 0.02)
# Plot the nodes using the coordinates of our embedding
pl.scatter(embedding[0],
embedding[1],
s=100 * d**2,
c=labels,
cmap=pl.cm.spectral)
# Plot the edges
start_idx, end_idx = np.where(non_zero)
#a sequence of (*line0*, *line1*, *line2*), where::
# linen = (x0, y0), (x1, y1), ... (xm, ym)
segments = [[embedding[:, start], embedding[:, stop]]
for start, stop in zip(start_idx, end_idx)]
values = np.abs(partial_correlations[non_zero])
lc = LineCollection(segments,
zorder=0,
cmap=pl.cm.hot_r,
norm=pl.Normalize(0, .7 * values.max()))
lc.set_array(values)
lc.set_linewidths(15 * values)
ax.add_collection(lc)
# Add a label to each node. The challenge here is that we want to
# position the labels to avoid overlap with other labels
for index, (name, label,
(x, y)) in enumerate(zip(names, labels, embedding.T)):
dx = x - embedding[0]
dx[index] = 1
dy = y - embedding[1]
dy[index] = 1
this_dx = dx[np.argmin(np.abs(dy))]
this_dy = dy[np.argmin(np.abs(dx))]
if this_dx > 0:
horizontalalignment = 'left'
x = x + .002
else:
horizontalalignment = 'right'
x = x - .002
if this_dy > 0:
verticalalignment = 'bottom'
y = y + .002
else:
verticalalignment = 'top'
y = y - .002
pl.text(x,
y,
name,
size=10,
horizontalalignment=horizontalalignment,
verticalalignment=verticalalignment,
bbox=dict(facecolor='w',
edgecolor=pl.cm.spectral(label / float(n_labels)),
alpha=.6))
pl.xlim(
embedding[0].min() - .15 * embedding[0].ptp(),
embedding[0].max() + .10 * embedding[0].ptp(),
)
pl.ylim(embedding[1].min() - .03 * embedding[1].ptp(),
embedding[1].max() + .03 * embedding[1].ptp())
pl.savefig(os.path.join(os.getcwd(), "pyTAAA_web",
"Clustered_companyNames.png"),
format='png')
return figure7_htmlText
def intensityCutImage(imageData, cutLevels):
"""Creates a matplotlib.pylab plot of an image array with the specified cuts in intensity
applied. This routine is used by L{saveBitmap} and L{saveContourOverlayBitmap}, which both
produce output as .png, .jpg, etc. images.
@type imageData: numpy array
@param imageData: image data array
@type cutLevels: list
@param cutLevels: sets the image scaling - available options:
- pixel values: cutLevels=[low value, high value].
- histogram equalisation: cutLevels=["histEq", number of bins ( e.g. 1024)]
- relative: cutLevels=["relative", cut per cent level (e.g. 99.5)]
- smart: cutLevels=["smart", cut per cent level (e.g. 99.5)]
["smart", 99.5] seems to provide good scaling over a range of different images.
@rtype: dictionary
@return: image section (numpy.array), matplotlib image normalisation (matplotlib.colors.Normalize), in the format {'image', 'norm'}.
@note: If cutLevels[0] == "histEq", then only {'image'} is returned.
"""
oImWidth = imageData.shape[1]
oImHeight = imageData.shape[0]
# Optional histogram equalisation
if cutLevels[0] == "histEq":
imageData = histEq(imageData, cutLevels[1])
anorm = pylab.Normalize(imageData.min(), imageData.max())
elif cutLevels[0] == "relative":
# this turns image data into 1D array then sorts
sorted = numpy.sort(numpy.ravel(imageData))
maxValue = sorted.max()
minValue = sorted.min()
# want to discard the top and bottom specified
topCutIndex=len(sorted-1) \
-int(math.floor(float((100.0-cutLevels[1])/100.0)*len(sorted-1)))
bottomCutIndex = int(
math.ceil(float((100.0 - cutLevels[1]) / 100.0) * len(sorted - 1)))
topCut = sorted[topCutIndex]
bottomCut = sorted[bottomCutIndex]
anorm = pylab.Normalize(bottomCut, topCut)
elif cutLevels[0] == "smart":
# this turns image data into 1Darray then sorts
sorted = numpy.sort(numpy.ravel(imageData))
maxValue = sorted.max()
minValue = sorted.min()
numBins = 10000 # 0.01 per cent accuracy
binWidth = (maxValue - minValue) / float(numBins)
histogram = ndimage.histogram(sorted, minValue, maxValue, numBins)
# Find the bin with the most pixels in it, set that as our minimum
# Then search through the bins until we get to a bin with more/or the same number of
# pixels in it than the previous one.
# We take that to be the maximum.
# This means that we avoid the traps of big, bright, saturated stars that cause
# problems for relative scaling
backgroundValue = histogram.max()
foundBackgroundBin = False
foundTopBin = False
lastBin = -10000
for i in range(len(histogram)):
if histogram[i] >= lastBin and foundBackgroundBin == True:
# Added a fudge here to stop us picking for top bin a bin within
# 10 percent of the background pixel value
if (minValue + (binWidth * i)) > bottomBinValue * 1.1:
topBinValue = minValue + (binWidth * i)
foundTopBin = True
break
if histogram[i] == backgroundValue and foundBackgroundBin == False:
bottomBinValue = minValue + (binWidth * i)
foundBackgroundBin = True
lastBin = histogram[i]
if foundTopBin == False:
topBinValue = maxValue
#Now we apply relative scaling to this
smartClipped = numpy.clip(sorted, bottomBinValue, topBinValue)
topCutIndex=len(smartClipped-1) \
-int(math.floor(float((100.0-cutLevels[1])/100.0)*len(smartClipped-1)))
bottomCutIndex = int(
math.ceil(
float((100.0 - cutLevels[1]) / 100.0) * len(smartClipped - 1)))
topCut = smartClipped[topCutIndex]
bottomCut = smartClipped[bottomCutIndex]
anorm = pylab.Normalize(bottomCut, topCut)
else:
# Normalise using given cut levels
anorm = pylab.Normalize(cutLevels[0], cutLevels[1])
if cutLevels[0] == "histEq":
return {'image': imageData.copy()}
else:
return {'image': imageData.copy(), 'norm': anorm}
def drainage_plot(
mg,
surface="topographic__elevation",
receivers=None,
proportions=None,
surf_cmap="gray",
quiver_cmap="viridis",
title="Drainage Plot",
):
if isinstance(surface, six.string_types):
colorbar_label = surface
else:
colorbar_label = "topographic_elevation"
imshow_grid(mg, surface, cmap=surf_cmap, colorbar_label=colorbar_label)
if receivers is None:
receivers = mg.at_node["flow__receiver_node"]
if proportions is None:
if "flow__receiver_proportions" in mg.at_node:
proportions = mg.at_node["flow__receiver_proportions"]
else:
receivers = np.asarray(receivers)
if receivers.ndim == 1:
receivers = np.expand_dims(receivers, axis=1)
nreceievers = receivers.shape[-1]
propColor = plt.get_cmap(quiver_cmap)
for j in range(nreceievers):
rec = receivers[:, j]
is_bad = rec == -1
xdist = -0.8 * (mg.x_of_node - mg.x_of_node[rec])
ydist = -0.8 * (mg.y_of_node - mg.y_of_node[rec])
if proportions is None:
proportions = np.ones_like(receivers, dtype=float)
is_bad[proportions[:, j] == 0.0] = True
xdist[is_bad] = np.nan
ydist[is_bad] = np.nan
prop = proportions[:, j] * 256.0
lu = np.floor(prop)
colors = propColor(lu.astype(int))
shape = (mg.number_of_nodes, 1)
plt.quiver(
mg.x_of_node.reshape(shape),
mg.y_of_node.reshape(shape),
xdist.reshape(shape),
ydist.reshape(shape),
color=colors,
angles="xy",
scale_units="xy",
scale=1,
zorder=3,
)
# Plot differen types of nodes:
o, = plt.plot(
mg.x_of_node[mg.status_at_node == CORE_NODE],
mg.y_of_node[mg.status_at_node == CORE_NODE],
"b.",
label="Core Nodes",
zorder=4,
)
fg, = plt.plot(
mg.x_of_node[mg.status_at_node == FIXED_VALUE_BOUNDARY],
mg.y_of_node[mg.status_at_node == FIXED_VALUE_BOUNDARY],
"c.",
label="Fixed Gradient Nodes",
zorder=5,
)
fv, = plt.plot(
mg.x_of_node[mg.status_at_node == FIXED_GRADIENT_BOUNDARY],
mg.y_of_node[mg.status_at_node == FIXED_GRADIENT_BOUNDARY],
"g.",
label="Fixed Value Nodes",
zorder=6,
)
c, = plt.plot(
mg.x_of_node[mg.status_at_node == CLOSED_BOUNDARY],
mg.y_of_node[mg.status_at_node == CLOSED_BOUNDARY],
"r.",
label="Closed Nodes",
zorder=7,
)
node_id = np.arange(mg.number_of_nodes)
flow_to_self = receivers[:, 0] == node_id
fts, = plt.plot(
mg.x_of_node[flow_to_self],
mg.y_of_node[flow_to_self],
"kx",
markersize=6,
label="Flows To Self",
zorder=8,
)
ax = plt.gca()
ax.legend(
labels=[
"Core Nodes",
"Fixed Gradient Nodes",
"Fixed Value Nodes",
"Closed Nodes",
"Flows To Self",
],
handles=[o, fg, fv, c, fts],
numpoints=1,
loc="center left",
bbox_to_anchor=(1.7, 0.5),
)
sm = plt.cm.ScalarMappable(cmap=propColor,
norm=plt.Normalize(vmin=0, vmax=1))
sm._A = []
cx = plt.colorbar(sm)
cx.set_label("Proportion of Flow")
plt.title(title)
def T90VsT50(host, sats, rest, rad, path=''):
t90mw, t90m31 = [[], []]
t50mw, t50m31 = [[], []]
rmw, rm31 = [[np.NaN], [np.NaN]]
mvmw, mvm31 = [[np.NaN], [np.NaN]]
for s in sats:
if sats[s]['Vmag'] > -13.5:
if host[sats[s]['Host']]['Mstar'] > 10**10.55:
t90m31.append(13.4 - t_at_sffrac(sats[s]['CumSFH'], .9))
t50m31.append(13.4 - t_at_sffrac(sats[s]['CumSFH'], .5))
rm31.append(sats[s]['Rvir'])
mvm31.append(sats[s]['Vmag'])
else:
t90mw.append(13.4 - t_at_sffrac(sats[s]['CumSFH'], .9))
t50mw.append(13.4 - t_at_sffrac(sats[s]['CumSFH'], .5))
rmw.append(sats[s]['Rvir'])
mvmw.append(sats[s]['Vmag'])
try:
MAX = np.nanmax([np.nanmax(rm31), np.nanmax(rmw)])
except:
MAX = 500
Rm31 = [0] * len(rm31)
for i in np.arange(len(rm31)):
Rm31[i] = (3 + 17 * (rm31[i] / MAX))**2
Rmw = [0] * len(rmw)
for i in np.arange(len(rmw)):
Rmw[i] = (3 + 17 * (rmw[i] / MAX))**2
f, ax = plt.subplots(2, 1, figsize=(6, 13), sharex=True)
ax[0].grid(c='.5', alpha=.5, linewidth=.7)
ax[0].set_axisbelow(True)
ax[1].grid(c='.5', alpha=.5, linewidth=.7)
ax[1].set_axisbelow(True)
ax[1].scatter(4,
12,
edgecolor='k',
facecolor='.5',
s=(3 + 17 * (500 / MAX)) * 2)
ax[1].text(3.5, 12.2, '500pc', fontsize=15)
ax[0].plot([13.4 - 0, 13.4 - 6.7], [13.4 - 0, 13.4 - 13.4],
c='k',
zorder=0)
ax[1].plot([13.4 - 0, 13.4 - 6.7], [13.4 - 0, 13.4 - 13.4],
c='k',
zorder=0)
try:
norm = plt.Normalize(np.nanmin([np.nanmin(mvmw),
np.nanmin(mvm31)]),
np.nanmax([np.nanmax(mvmw),
np.nanmax(mvm31)]))
except:
norm = plt.Normalize(0, 1)
del mvmw[0], mvm31[0], rmw[0], rm31[0]
p = ax[0].scatter(t50m31,
t90m31,
s=Rm31,
c=mvm31,
cmap='plasma_r',
norm=norm)
cbar = f.colorbar(p, cax=f.add_axes([.93, .11, .075, .77]))
ax[1].scatter(t50mw, t90mw, s=Rmw, c=mvmw, cmap='plasma_r', norm=norm)
ax[1].set_xlabel(r'$\tau_{50}$ [Gyr ago]', fontsize=20)
ax[0].set_xlim([13.4, 0])
ax[0].set_ylabel(r'$\tau_{90}$ [Gyr ago]', fontsize=20)
ax[0].yaxis.set_label_coords(-0.08, 0)
ax[0].set_ylim([13.4, 0])
ax[1].set_ylim([13.4, 0])
cbar.set_label(r'M$_{V}$', fontsize=20)
cbar.ax.tick_params(labelsize=15, length=5)
ax[0].tick_params(labelsize=15, direction='in', length=5)
ax[1].tick_params(labelsize=15, direction='in', length=5, top=True)
f.subplots_adjust(hspace=0)
f.savefig(path + 'T90vsT50.' + rest + '.' + rad + '.png',
bbox_inches='tight',
pad_inches=0.1)
f.savefig(path + 'pdf/T90VsT50.' + rest + '.' + rad + '.pdf',
bbox_inches='tight',
pad_inches=0.1)
plt.close()
def SatelliteCountVsStellarMassVsEnvironment(host, rest, rad, path=''):
x, y, c = [[], [], []]
for h in host:
x.append(np.log10(host[h]['Mstar']))
y.append(len(host[h]['Satellites']))
c.append(host[h]['Closest'][0] / 1000.)
xs, ys = [[], []]
wkbk = xlrd.open_workbook('AdditionalData/NvMst.xls')
wk = wkbk.sheet_by_index(0)
line = 0
while line < 8:
xs.append(wk.cell_value(line, 0))
ys.append(wk.cell_value(line, 2))
line += 1
wkbk2 = xlrd.open_workbook('AdditionalData/JL.xls')
wk2 = wkbk2.sheet_by_index(0)
xjl, yjl, cjl = [[], [], []]
line = 1
while line < 5:
xjl.append(wk2.cell_value(line, 1))
yjl.append(wk2.cell_value(line, 3))
cjl.append(wk2.cell_value(line, 2))
line += 1
f, ax = plt.subplots(1, 1, figsize=(8, 6))
ax.set_xlabel(r'Log(M$_{*,host}$) [M$_{\odot}$]', fontsize=20)
ax.set_ylabel(r'N$_{sats}$', fontsize=20)
ax.xaxis.set_major_locator(MultipleLocator(.5))
ax.tick_params(which='major',
labelsize=15,
direction='in',
length=6,
width=1,
top=True,
right=True)
ax.xaxis.set_minor_locator(MultipleLocator(.1))
ax.tick_params(which='minor',
labelsize=0,
direction='in',
length=3,
width=1,
top=True,
right=True)
ax.scatter(xs[0], ys[0], label='Rom25', c='k')
ax.scatter(xjl[0],
yjl[0],
label='Justice League',
c='k',
marker='^',
s=10**2)
norm = plt.Normalize(0, max([max(c), max(cjl)]))
ax.scatter(xs, ys, c='k', marker='*', s=13**2, label='SAGA Paper')
p = ax.scatter(x,
y,
c=c,
cmap='viridis_r',
norm=norm,
edgecolor='.3',
linewidth=.3)
ax.scatter(xjl,
yjl,
c=cjl,
cmap='viridis_r',
marker='^',
s=11**2,
norm=norm)
ax.scatter(wk.cell_value(8, 0),
wk.cell_value(8, 2),
marker='*',
c='orange',
s=13**2,
label='MW')
ax.scatter(wk.cell_value(9, 0),
wk.cell_value(9, 2),
marker='*',
c='purple',
s=13**2,
label='M31')
cbar = f.colorbar(p, cax=f.add_axes([.91, .11, .03, .77]))
cbar.ax.tick_params(labelsize=15)
cbar.set_label(r'Distance to closest Large Halo' + '\n' +
r'(M$_{vir}$ $>$ 5*10$^{11}$) [Mpc]',
fontsize=20)
ax.legend(loc='upper left',
bbox_to_anchor=(-.03, 1.01),
prop={'size': 14},
frameon=False)
f.savefig(path + 'SatelliteCountVsStellarMassVsEnvironment.' + rest + '.' +
rad + '.png',
bbox_inches='tight',
pad_inches=0.1)
f.savefig(path + 'pdf/SatelliteCountVsStellarMassVsEnvironment.' + rest +
'.' + rad + '.pdf',
bbox_inches='tight',
pad_inches=0.1)
plt.close()
def drainage_plot(mg,
surface='topographic__elevation',
receivers=None,
proportions=None,
surf_cmap='gray',
quiver_cmap='viridis',
title='Drainage Plot'):
if isinstance(surface, six.string_types):
colorbar_label = surface
else:
colorbar_label = 'topographic_elevation'
imshow_node_grid(mg,
surface,
cmap=surf_cmap,
colorbar_label=colorbar_label)
if receivers is None:
try:
receivers = mg.at_node['flow__receiver_nodes']
if proportions is None:
try:
proportions = mg.at_node['flow__receiver_proportions']
except:
pass
except:
receivers = np.reshape(mg.at_node['flow__receiver_node'],
(mg.number_of_nodes, 1))
nreceievers = int(receivers.size / receivers.shape[0])
propColor = plt.get_cmap(quiver_cmap)
for j in range(nreceievers):
rec = receivers[:, j]
is_bad = rec == -1
xdist = -0.8 * (mg.node_x - mg.node_x[rec])
ydist = -0.8 * (mg.node_y - mg.node_y[rec])
if proportions is None:
proportions = np.ones_like(receivers, dtype=float)
is_bad[proportions[:, j] == 0.] = True
xdist[is_bad] = np.nan
ydist[is_bad] = np.nan
prop = proportions[:, j] * 256.
lu = np.floor(prop)
colors = propColor(lu.astype(int))
shape = (mg.number_of_nodes, 1)
plt.quiver(mg.node_x.reshape(shape),
mg.node_y.reshape(shape),
xdist.reshape(shape),
ydist.reshape(shape),
color=colors,
angles='xy',
scale_units='xy',
scale=1,
zorder=3)
# Plot differen types of nodes:
o, = plt.plot(mg.node_x[mg.status_at_node == CORE_NODE],
mg.node_y[mg.status_at_node == CORE_NODE],
'b.',
label='Core Nodes',
zorder=4)
fg, = plt.plot(mg.node_x[mg.status_at_node == FIXED_VALUE_BOUNDARY],
mg.node_y[mg.status_at_node == FIXED_VALUE_BOUNDARY],
'c.',
label='Fixed Gradient Nodes',
zorder=5)
fv, = plt.plot(mg.node_x[mg.status_at_node == FIXED_GRADIENT_BOUNDARY],
mg.node_y[mg.status_at_node == FIXED_GRADIENT_BOUNDARY],
'g.',
label='Fixed Value Nodes',
zorder=6)
c, = plt.plot(mg.node_x[mg.status_at_node == CLOSED_BOUNDARY],
mg.node_y[mg.status_at_node == CLOSED_BOUNDARY],
'r.',
label='Closed Nodes',
zorder=7)
node_id = np.arange(mg.number_of_nodes)
flow_to_self = receivers[:, 0] == node_id
fts, = plt.plot(mg.node_x[flow_to_self],
mg.node_y[flow_to_self],
'kx',
markersize=6,
label='Flows To Self',
zorder=8)
ax = plt.gca()
ax.legend(labels=[
'Core Nodes', 'Fixed Gradient Nodes', 'Fixed Value Nodes',
'Closed Nodes', 'Flows To Self'
],
handles=[o, fg, fv, c, fts],
numpoints=1,
loc='center left',
bbox_to_anchor=(1.7, 0.5))
sm = plt.cm.ScalarMappable(cmap=propColor,
norm=plt.Normalize(vmin=0, vmax=1))
sm._A = []
cx = plt.colorbar(sm)
cx.set_label('Proportion of Flow')
plt.title(title)
plt.show()
bbox=dict(boxstyle='square', facecolor='white'),
horizontalalignment='right')
clear_ax.axhline(180, color='k', lw=1.5, ls='--', zorder=0, alpha=0.6)
cloudy_ax.axhline(180, color='k', lw=1.5, ls='--', zorder=0, alpha=0.6)
cloudy_ax.annotate('eclipse',
xy=(0, 180),
xycoords='data',
xytext=(7.5, 175),
bbox=dict(boxstyle='square', facecolor='white'),
horizontalalignment='right')
# labels
axes[0].set_xlabel('Doppler shift [km s$^{-1}$]')
axes[1].set_xlabel('Doppler shift [km s$^{-1}$]')
axes[0].set_ylabel('Cross correlation (+ offset)')
cloudy_ax.set_ylabel('Phase angle [deg]')
sm = plt.cm.ScalarMappable(cmap=my_colors, norm=plt.Normalize(vmin=0, vmax=1))
sm._A = []
cbar = fig.colorbar(sm,
ax=axes.ravel().tolist(),
location='top',
aspect=80,
pad=0.02)
cbar.set_label('Orbital phase')
fig.savefig(savefile, bbox_inches='tight', dpi=300)
