def set_default_locators_and_formatters(self, axis):
"""
Set the locators and formatters to specialized versions for
log scaling.
"""
axis.set_major_locator(AutoLocator())
axis.set_major_formatter(ScalarFormatter())
axis.set_minor_locator(NullLocator())
axis.set_minor_formatter(NullFormatter())
def set_default_locators_and_formatters(self, axis):
"""
Set the locators and formatters to reasonable defaults for
linear scaling.
"""
axis.set_major_locator(AutoLocator())
axis.set_major_formatter(ScalarFormatter())
axis.set_minor_locator(NullLocator())
axis.set_minor_formatter(NullFormatter())
def format_axis_with_grid(ax, x_label=None, y_label=None, x_rotation=False):
"""
Adds a major and minor grid to axes, adds labels.
Parameters
----------
ax : Axes
Axes object containing the figure axis (modified)
x_label : str
X axis label
y_label : str
Y axis label
x_rotation : bool
True rotates the X axis labels by 90 deg (useful for ISOT dates)
Returns
-------
Axes
Axes object containing the figure axis (modified)
"""
# Change major ticks
ax.xaxis.set_major_locator(AutoLocator())
ax.yaxis.set_major_locator(AutoLocator())
# Change minor ticks to show with divisor of 4
ax.xaxis.set_minor_locator(AutoMinorLocator(4))
ax.yaxis.set_minor_locator(AutoMinorLocator(4))
ax.grid(which="major", color="#CCCCCC", linestyle="--")
ax.grid(which="minor", color="#CCCCCC", linestyle=":")
# Set axis labels
if x_label:
ax.set_xlabel(x_label)
if y_label:
ax.set_ylabel(y_label)
# Rotate x axis labels
if x_rotation:
ax.tick_params(axis="x", labelrotation=90)
return ax
def add_subplot_unshare(ax):
''' based on an answer from stacked overflow
'''
ax._shared_x_axes.remove(ax)
ax.xaxis.major = mpl.axis.Ticker()
xloc = AutoLocator()
xfmt = ScalarFormatter()
ax.xaxis.set_major_locator(xloc)
ax.xaxis.set_major_formatter(xfmt)
ax.yaxis.set_tick_params(which='both', labelleft=True)
def _get_locators(self, locator, at, upto, count, every, between, minor):
log_base, symlog_thresh = self._parse_for_log_params(self.trans)
if locator is not None:
major_locator = locator
elif upto is not None:
if log_base:
major_locator = LogLocator(base=log_base, numticks=upto)
else:
major_locator = MaxNLocator(upto, steps=[1, 1.5, 2, 2.5, 3, 5, 10])
elif count is not None:
if between is None:
# This is rarely useful (unless you are setting limits)
major_locator = LinearLocator(count)
else:
if log_base or symlog_thresh:
forward, inverse = self._get_transform()
lo, hi = forward(between)
ticks = inverse(np.linspace(lo, hi, num=count))
else:
ticks = np.linspace(*between, num=count)
major_locator = FixedLocator(ticks)
elif every is not None:
if between is None:
major_locator = MultipleLocator(every)
else:
lo, hi = between
ticks = np.arange(lo, hi + every, every)
major_locator = FixedLocator(ticks)
elif at is not None:
major_locator = FixedLocator(at)
else:
if log_base:
major_locator = LogLocator(log_base)
elif symlog_thresh:
major_locator = SymmetricalLogLocator(linthresh=symlog_thresh, base=10)
else:
major_locator = AutoLocator()
if minor is None:
minor_locator = LogLocator(log_base, subs=None) if log_base else None
else:
if log_base:
subs = np.linspace(0, log_base, minor + 2)[1:-1]
minor_locator = LogLocator(log_base, subs=subs)
else:
minor_locator = AutoMinorLocator(minor + 1)
return major_locator, minor_locator
def creation_plot_P(plot_parameters):
nlines = 3
size_figure = (6,2.3*nlines) #height of the figure depends on the number of pair we display
plt.close(1)
fig = plt.figure(figsize = (size_figure[0],size_figure[1]))
gs = GridSpec(nlines,2,width_ratios=[1,2],top = 0.88, bottom = 0.12,
right = 0.95, left = 0.15, wspace = 0, hspace = 0.03)
ax1 = fig.add_subplot(gs[0,1])
ax2 = fig.add_subplot(gs[1,1])
ax3 = fig.add_subplot(gs[2,1])
ax11 = fig.add_subplot(gs[0,0],sharey=ax1)
ax22 = fig.add_subplot(gs[1,0],sharey=ax2)
ax33 = fig.add_subplot(gs[2,0],sharey=ax3)
major_xticks = np.arange(-5,1.5,1)
minor_xticks = np.arange(-5,1.5,0.2)
#apply setup
for ax in [ax11,ax22,ax33]:
ax.set_xticks(major_xticks)
ax.set_xticks(minor_xticks, minor=True)
ax.set_xlim(-1,1)
ax.set_facecolor((1,1,1,0))
for ax in [ax1,ax2,ax3]:
ax.set_xlim(1,275)
ax.set_xscale('log')
plt.setp(ax.get_xticklabels()[1], visible=False)
ax.tick_params(labelleft=False)
for ax in [ax11,ax1,ax22,ax2]:
ax.tick_params(labelbottom=False)
for ax in [ax1,ax2,ax3,ax11,ax22,ax33]:
ax.xaxis.set_ticks_position('both')
ax.tick_params(which = 'both', labelsize = plot_parameters["size_font_ticks"],
width = plot_parameters["size_lines"]/2)
majorLocator = AutoLocator()
minorLocator = AutoMinorLocator()
ax.yaxis.set_ticks_position('both')
ax.yaxis.set_major_locator(majorLocator)
ax.yaxis.set_minor_locator(minorLocator)
plt.autoscale(axis='y')
ax.tick_params(which = 'both', labelsize = plot_parameters["size_font_ticks"],
width = plot_parameters["size_lines"]/2)
ax0 = fig.add_subplot(111, frameon=False)
plt.tick_params(labeltop=False, top=False, labelbottom=False, bottom=False,
labelleft=False, left=False, labelright = False, right=False)
ax0.set_xlabel(r'Pressure (GPa)', fontweight = 'bold', fontsize = plot_parameters["size_fonts"],
labelpad = plot_parameters["shift_labelpad"])
return fig, ax1, ax2, ax3, ax11, ax22, ax33, ax0
def creation_plot(plot_parameters, atom_couple):
""" ********** Creation of the plot ********** """
print("I use creation plot without insert")
#parameters for article format
size_fonts = plot_parameters["size_fonts"]
size_font_ticks = plot_parameters["size_font_ticks"]
size_figure = plot_parameters["size_figure"]
size_markers = plot_parameters["size_markers"]
size_lines = plot_parameters["size_lines"]
shift_labelpad = plot_parameters["shift_labelpad"]
#plot
plt.close()
fig, (ax1, ax2) = plt.subplots(1,
2,
sharex=True,
sharey=False,
figsize=size_figure)
#Adjustment of ticks
major_xticks = np.arange(0, 9, 1)
minor_xticks = np.arange(0, 8.5, 0.5)
for ax in [ax1, ax2]:
majorLocator = AutoLocator()
minorLocator = AutoMinorLocator()
ax.yaxis.set_major_locator(majorLocator)
ax.yaxis.set_minor_locator(minorLocator)
ax.yaxis.set_major_formatter(
FormatStrFormatter('%.1f')) #set one decimal to ticks label``
plt.autoscale(enable=True, axis='y', tight=False)
ax.yaxis.set_ticks_position('both')
ax.set_ylabel(r'g$_{\mathrm{\bf' + atom_couple + '}}$(r)',
fontsize=size_fonts,
fontweight='bold',
labelpad=shift_labelpad)
ax.set_xticks(major_xticks)
ax.set_xticks(minor_xticks, minor=True)
ax.set_xlim([0, 8])
ax.set_xlabel('Distance r ($\AA$)',
fontsize=size_fonts,
fontweight='bold',
labelpad=shift_labelpad)
ax.tick_params(which='both',
labelsize=size_font_ticks,
width=size_lines / 2)
#Fine-tune figure
plt.subplots_adjust(top=0.97,
bottom=0.12,
right=0.89,
left=0.07,
hspace=0,
wspace=0.27)
return fig, ax1, ax2
def _set_zaxis_ticks(ax, lightcone, zticks, z_axis):
if zticks != "distance":
loc = AutoLocator()
# Get redshift ticks.
lc_z = lightcone.lightcone_redshifts
if zticks == "redshift":
coords = lc_z
elif zticks == "frequency":
coords = 1420 / (1 + lc_z) * un.MHz
else:
try:
coords = getattr(lightcone.cosmo_params.cosmo, zticks)(lc_z)
except AttributeError:
raise AttributeError(
"zticks '{}' is not a cosmology function.".format(zticks)
)
zlabel = " ".join(z.capitalize() for z in zticks.split("_"))
units = getattr(coords, "unit", None)
if units:
zlabel += " [{}]".format(str(coords.unit))
coords = coords.value
ticks = loc.tick_values(coords.min(), coords.max())
if ticks.min() < coords.min() / 1.00001:
ticks = ticks[1:]
if ticks.max() > coords.max() * 1.00001:
ticks = ticks[:-1]
if coords[1] < coords[0]:
ticks = ticks[::-1]
if zticks == "redshift":
z_ticks = ticks
elif zticks == "frequency":
z_ticks = 1420 / ticks - 1
else:
z_ticks = [
z_at_value(getattr(lightcone.cosmo_params.cosmo, zticks), z * units)
for z in ticks
]
d_ticks = (
lightcone.cosmo_params.cosmo.comoving_distance(z_ticks).value
- lightcone.lightcone_distances[0]
)
getattr(ax, "set_{}ticks".format(z_axis))(d_ticks)
getattr(ax, "set_{}ticklabels".format(z_axis))(ticks)
else:
zlabel = "Line-of-Sight Distance [Mpc]"
return zlabel
def set_default_locators_and_formatters(self, axis):
# docstring inherited
axis.set_major_locator(AutoLocator())
axis.set_major_formatter(ScalarFormatter())
axis.set_minor_formatter(NullFormatter())
# update the minor locator for x and y axis based on rcParams
if (axis.axis_name == 'x' and mpl.rcParams['xtick.minor.visible'] or
axis.axis_name == 'y' and mpl.rcParams['ytick.minor.visible']):
axis.set_minor_locator(AutoMinorLocator())
else:
axis.set_minor_locator(NullLocator())
def gridded_axis(ax):
"""
Plot major, minor ticks as well as a grid
:param ax:
:return:
"""
# Set number of major and minor ticks
ax.xaxis.set_major_locator(AutoLocator())
ax.xaxis.set_minor_locator(AutoLocator())
ax.yaxis.set_major_locator(AutoLocator())
ax.yaxis.set_minor_locator(AutoLocator())
# Create nice-looking grid for ease of visualization
ax.grid(which='minor', alpha=0.2, linestyle='--')
ax.grid(which='major', alpha=0.5, linestyle='--')
# For y-axis, format the numbers
scale = 1
ticks = tkr.FuncFormatter(lambda x, pos: '{:0,d}'.format(int(x / scale)))
ax.yaxis.set_major_formatter(ticks)
def set_default_locators_and_formatters(self, axis):
"""
Override to set up the locators and formatters to use with the
scale. This is only required if the scale requires custom
locators and formatters. Writing custom locators and
formatters is rather outside the scope of this example, but
there are many helpful examples in ``ticker.py``.
"""
axis.set_major_locator(AutoLocator())
axis.set_major_formatter(ScalarFormatter())
axis.set_minor_formatter(ScalarFormatter())
return
def creation_plot(plot_parameters):
nlines = 3
size_figure = (
6, 2.3 * nlines
) #height of the figure depends on the number of pair we display
plt.close(1)
fig, (ax1, ax2, ax3) = plt.subplots(nrows=nlines,
ncols=1,
sharex=True,
sharey=False,
figsize=size_figure)
major_xticks = np.arange(0, 8, 0.5)
minor_xticks = np.arange(0, 8, 0.1)
for ax in [ax1, ax2, ax3]:
ax.set_xticks(major_xticks)
ax.set_xticks(minor_xticks, minor=True)
ax.set_xlim(0.9, 5.58)
ax.xaxis.set_ticks_position('both')
majorLocator = AutoLocator()
minorLocator = AutoMinorLocator()
ax.yaxis.set_ticks_position('both')
ax.yaxis.set_major_locator(majorLocator)
ax.yaxis.set_minor_locator(minorLocator)
plt.autoscale(axis='y')
ax.tick_params(which='both',
labelsize=plot_parameters["size_font_ticks"],
width=plot_parameters["size_lines"] / 2)
# Fine-tune figure : 1) make subplots close to each other (+ less whitespace around), 2) hide x ticks for all but bottom plot, 3) add a big invisible subplot in order to center x and y labels (since the ticklabels are turned off we have to move the x and y labels with labelpad)
fig.subplots_adjust(top=0.95,
bottom=0.1,
right=0.95,
left=0.1,
hspace=0.03,
wspace=0.02)
ax0 = fig.add_subplot(111, frameon=False)
plt.tick_params(labeltop=False,
top=False,
labelbottom=False,
bottom=False,
labelleft=False,
left=False,
labelright=False,
right=False)
ax0.set_xlabel(r'Density (g.cm$^{-3}$)',
fontweight='bold',
fontsize=plot_parameters["size_fonts"],
labelpad=plot_parameters["shift_labelpad"])
ax0.set_ylabel(r'Coordination number',
fontweight='bold',
fontsize=plot_parameters["size_fonts"],
labelpad=plot_parameters["shift_labelpad"])
return fig, ax1, ax2, ax3, ax0
def plotmerge(n=3):
"""plot merging traps with n timesteps"""
sep = np.linspace(0, max([Cswaist,Rbwaist])*2, n) # initial separation of the tweezer traps
xs = np.linspace(-max(sep)*0.5, max(sep)*1.5, 200) # positions along the beam axis
for atoms in [[Rb1064, Rb880, wrRb], [Cs1064, Cs880, wrCs]]:
plt.figure(figsize=(6,7.5))
for i in range(n):
ax = plt.subplot2grid((n,1), (i,0))
if atoms[0].X == 'Rb':
minU0 = (atoms[0].acStarkShift(0,0,0,mj=0) + atoms[1].acStarkShift(0,0,0,mj=0))/kB*1.1e3
maxU0 = 0.16
elif atoms[0].X=='Cs':
minU0 = atoms[0].acStarkShift(0,0,0,mj=0)/kB*1.1e3
maxU0 = atoms[1].acStarkShift(0,0,0,mj=0)/kB*1.1e3
# combined potential along the beam axis:
U = (atoms[0].acStarkShift(xs,0,0,mj=0) + atoms[1].acStarkShift(xs-sep[n-i-1],0,0,mj=0))/kB*1e3
U1064 = atoms[0].acStarkShift(xs,0,0,mj=0)/kB*1e3 # potential in the 1064 trap
U880 = atoms[1].acStarkShift(xs-sep[n-i-1],0,0,mj=0)/kB*1e3 # potential in the 880 trap
plt.plot(xs*1e6, U, 'k')
plt.plot(xs*1e6, U1064, color=default_colours.DUcherry_red, alpha=0.6)
plt.plot(xs*1e6, U880, color=default_colours.DUsea_blue, alpha=0.6)
plt.plot([0]*2, [minU0,maxU0], color=default_colours.DUcherry_red, linewidth=10, label='%.0f'%(Cswl*1e9), alpha=0.4)
plt.plot([sep[n-i-1]*1e6]*2, [minU0,maxU0], color=default_colours.DUsea_blue, linewidth=10, label='%.0f'%(Rbwl*1e9), alpha=0.4)
ax.set_xticks([])
ax.set_ylim((minU0,maxU0))
ax.set_xlim((xs[0]*1e6, xs[-1]*1e6))
# ax.set_yticks([])
if i == 0:
if atoms[0].X == 'Rb':
ax.set_title('a)', pad=30)
elif atoms[0].X == 'Cs':
ax.set_title('b)', pad=30)
# ax.set_title("Optical potential experienced by "+atoms[0].X
# +"\n%.0f beam power: %.3g mW %.0f beam power: %.3g mW"%(Cswl*1e9, power*1e3, Rbwl*1e9, Rbpower*1e3),
# pad = 30)
plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=2, mode="expand", borderaxespad=0.)
# ax.text(xs[0]*1e6, 0, '$\omega/2\pi = %.0f$ kHz'%(trap_freq(atoms[0])/afu),
# bbox=dict(facecolor='white', edgecolor=None))
# ax.text(sep[-1]*1e6,0,'$\omega/2\pi = %.0f$ kHz'%(trap_freq(atoms[1])/afu),
# bbox=dict(facecolor='white', edgecolor=None))
plt.xlabel(r'Position ($\mu$m)')
ax.set_xticks(sep*1e6)
plt.ylabel('Trap Depth (mK)')
# ax.text(xs[0]*1e6, 0, '$\omega/2\pi = %.0f$ kHz'%atoms[2], bbox=dict(facecolor='white', edgecolor=None))
ax.yaxis.set_major_locator(AutoLocator())
plt.tight_layout()
plt.subplots_adjust(hspace=0.02)
def print_mat():
fig1 = plt.figure()
ax1 = fig1.add_subplot(1, 1, 1)
ax1.xaxis.set_major_formatter(DateFormatter('%m-%d')) #设置时间标签显示格式
ax1.xaxis.set_major_locator(AutoDateLocator()) #设置x轴自动时间刻度
ax1.yaxis.set_major_locator(AutoLocator()) #设置y轴自动刻度
plt.plot(Date, Open, label="Open", color="red")
plt.plot(Date, Close, label="Close", color="blue")
plt.title(u"抓取特斯拉股票历史开盘、收盘价格", fontproperties=font)
plt.xlabel("时间", fontproperties=font)
plt.legend()
plt.show()
def setup_plot_for_right_frame(self, parent_frame):
figure = Figure(dpi=100)
self.plot = figure.add_subplot(111)
self.plot.grid(**PropertiesDictionaries.grid_properties_dict)
self.plot.xaxis.set_major_locator(AutoLocator())
self.plot.xaxis.set_minor_locator(AutoMinorLocator(4))
self.plot.yaxis.set_major_locator(AutoLocator())
self.plot.yaxis.set_minor_locator(AutoMinorLocator(4))
self.plot.tick_params(
**dict(
list(
PropertiesDictionaries.ticks_properties_dict.items())[:2]),
**dict(
list(PropertiesDictionaries.ticks_properties_dict.items())
[3:7]),
**dict(
list(
PropertiesDictionaries.ticks_properties_dict.items())[8:]))
mat_art.setp(self.plot, **PropertiesDictionaries.axes_properties_dict)
self.plot.autoscale()
ChartCreator.chosen_plot_label = ttk.Label(
parent_frame,
text="Chosen: ",
width=24,
justify="left",
font=Constants.MONOSPACED_FONT)
ChartCreator.chosen_plot_label.grid(row=1, column=1, sticky="ew")
self.canvas = FigureCanvasTkAgg(figure, parent_frame)
self.canvas.mpl_connect("pick_event",
self.event_handler.click_artist_callback)
self.canvas.show()
self.canvas.get_tk_widget().grid(row=0,
column=0,
columnspan=2,
sticky="nwse")
toolbar_frame = tk.Frame(parent_frame)
toolbar_frame.grid(row=1, column=0, sticky="w")
toolbar = NavigationToolbar2TkAgg(self.canvas, toolbar_frame)
toolbar.update()
self.canvas._tkcanvas.grid()
def update_ticks(axes, coord, components, is_log):
"""
Changes the axes to have the proper tick formatting based on the type of
component.
Returns `None` or the number of categories if components is Categorical.
Parameters
----------
axes : `~matplotlib.axes.Axes`
A matplotlib axis object to alter
coord : { 'x' | 'y' }
The coordinate axis on which to update the ticks
components : iterable
A list of components that are plotted along this axis
if_log : boolean
Whether the axis has a log-scale
"""
if coord == 'x':
axis = axes.xaxis
elif coord == 'y':
axis = axes.yaxis
else:
raise TypeError("coord must be one of x,y")
is_cat = any(comp.categorical for comp in components)
is_date = any(comp.datetime for comp in components)
if is_date:
loc = AutoDateLocator()
fmt = AutoDateFormatter(loc)
axis.set_major_locator(loc)
axis.set_major_formatter(fmt)
elif is_log:
axis.set_major_locator(LogLocator())
axis.set_major_formatter(LogFormatterMathtext())
elif is_cat:
all_categories = np.empty((0, ), dtype=np.object)
for comp in components:
all_categories = np.union1d(comp.categories, all_categories)
locator = MaxNLocator(10, integer=True)
locator.view_limits(0, all_categories.shape[0])
format_func = partial(tick_linker, all_categories)
formatter = FuncFormatter(format_func)
axis.set_major_locator(locator)
axis.set_major_formatter(formatter)
return all_categories.shape[0]
else:
axis.set_major_locator(AutoLocator())
axis.set_major_formatter(ScalarFormatter())
def set_default_locators_and_formatters(self, axis):
"""
Set the locators and formatters to reasonable defaults for
linear scaling.
"""
axis.set_major_locator(AutoLocator())
axis.set_major_formatter(ScalarFormatter())
axis.set_minor_formatter(NullFormatter())
# update the minor locator for x and y axis based on rcParams
if rcParams['xtick.minor.visible']:
axis.set_minor_locator(AutoMinorLocator())
else:
axis.set_minor_locator(NullLocator())
def set_default_locators_and_formatters(self, axis):
"""
Set the locators and formatters to the same defaults as the
linear scale.
"""
axis.set_major_locator(AutoLocator())
axis.set_major_formatter(ScalarFormatter())
axis.set_minor_formatter(NullFormatter())
# update the minor locator for x and y axis based on rcParams
if (axis.axis_name == 'x' and rcParams['xtick.minor.visible']
or axis.axis_name == 'y' and rcParams['ytick.minor.visible']):
axis.set_minor_locator(AutoMinorLocator())
else:
axis.set_minor_locator(NullLocator())
def apply_commands(self):
from matplotlib.ticker import LogLocator, AutoLocator
for key in sorted(self.ydata.keys()):
ig, ip = key
xdata = nm.array(self.xdata[(ig, ip)])
ydata = nm.array(self.ydata[(ig, ip)])
ax = self.ax[ig]
if self.clear_axes[ig]:
ax.cla()
self.clear_axes[ig] = False
ax.set_yscale(self.yscales[ig])
ax.yaxis.grid(True)
draw_data(ax, nm.array(xdata), nm.array(ydata),
self.data_names[ig][ip], self.plot_kwargs[ig][ip])
if self.yscales[ig] == 'log':
ymajor_formatter = ax.yaxis.get_major_formatter()
ymajor_formatter.label_minor(True)
yminor_locator = LogLocator()
else:
yminor_locator = AutoLocator()
self.ax[ig].yaxis.set_minor_locator(yminor_locator)
if self.show_legends:
for ig, ax in enumerate(self.ax):
try:
ax.legend()
except:
pass
if self.xlabels[ig]:
ax.set_xlabel(self.xlabels[ig])
if self.ylabels[ig]:
ax.set_ylabel(self.ylabels[ig])
for x, kwargs in self.vlines[ig]:
ax.axvline(x, **kwargs)
try:
self.plt.tight_layout(pad=0.5)
except:
pass
def update_plot(self):
if len(self.Plotsignals) == 0:
return
self.ax.clear()
for Plotsignal in self.Plotsignals:
if Plotsignal.plotenable:
if Plotsignal.plotnormalise:
data = Plotsignal.get_normalised_values() * 100
self.ax.plot(data, color=Plotsignal.plotcolor)
else:
data = Plotsignal.get_values()
self.ax.plot(convert_to_si(Plotsignal.unit, data)[1],
color=Plotsignal.plotcolor)
self.ax.grid(True)
self.ax.get_yaxis().tick_right()
self.ax.get_yaxis().set_label_position("right")
self.ax.get_yaxis().set_visible(True)
self.ax.get_xaxis().set_visible(False)
all_normalised = True
all_same_unit = True
unit = ""
iter = self.signalstore.get_iter(0)
while iter is not None:
if self.signalstore[iter][0] == True:
if unit == "":
unit = self.signalstore[iter][4]
if self.signalstore[iter][1] == False:
all_normalised = False
if self.signalstore[iter][4] != unit:
all_same_unit = False
if not all_normalised and not all_same_unit:
break
iter = self.signalstore.iter_next(iter)
if all_normalised:
self.ax.set_yticks(np.arange(0, 101, step=25))
self.ax.set_ylabel('Percent [%]')
else:
self.ax.yaxis.set_major_locator(AutoLocator())
if all_same_unit:
self.ax.set_ylabel(unit)
else:
self.ax.set_ylabel("")
self.canvas.draw()
self.canvas.flush_events()
def creation_plot(xlabel):
""" ********** Creation of the plot ********** """
plt.close()
fig, ax = plt.subplots(figsize=(10, 4))
ax.set_ylabel(r'Cluster absolute lifetime (fs)',
fontweight='bold',
fontsize=12)
ax.set_xlabel(xlabel, fontweight='bold', fontsize=12, labelpad=25)
#Adjustment of ticks
ymajorLocator = AutoLocator()
yminorLocator = AutoMinorLocator()
ax.yaxis.set_major_locator(ymajorLocator)
ax.yaxis.set_minor_locator(yminorLocator)
ax.tick_params(which='both', labelsize=10, width=0.5)
plt.tick_params(bottom=False, top=False, labelbottom=True)
plt.autoscale(enable=True, axis='y', tight=True)
ax.grid(True, which='major', axis='y', linestyle=':', linewidth=0.5)
return fig, ax
def plotLevels(data):
assert span1 == span2
span = span1
# ---------------------- create the figure and axes ---------------------- #
fig, ax = plt.subplots()
# -- discretize the definition space and compute the function's images --- #
X, Y = discretise_space([defspace1, defspace2], n=span)
Z = data
cs = ax.contourf(X, Y, Z, locator=AutoLocator(), cmap=cm.PuBu)
# ---------------------------- titles & misc ----------------------------- #
cbar = fig.colorbar(cs) # bar with scales
ax.set(xlabel='$W\_C$', ylabel='$W\_W$') #,
#title='Utilité à {} ticks en fonction de W_W et W_C'.format(ticks))
plt.show()
def plotStudRes(ax, d, xx , yerr, res_tick, x0=0, left=0):
stu_d = d/yerr
stu_d_err = np.ones(len(d))
divider = make_axes_locatable(ax)
ax2 = divider.append_axes("top", size="20%", pad=0.1)
ax.figure.add_axes(ax2)
ax2.set_xlim(ax.get_xlim())
ax2.set_yticks(res_tick)
ax.tick_params(width=1.3, axis='both', direction='in', bottom=True, top=True, left=True, right=True)
ax2.tick_params(width=1.3, axis='both', direction='in', bottom=True, top=True, left=True, right=True, labelbottom=False)
ax2.set_ylabel('Studentized\nResiduals', color='k', fontsize=12)
from matplotlib.ticker import AutoLocator, AutoMinorLocator
ax2.get_yaxis().set_major_locator(AutoLocator())
# ax2.get_yaxis().set_minor_locator(AutoMinorLocator())
ax2.axhline(y=0, color='r', linestyle='-', linewidth=2)
ax.tick_params(axis='both', direction='in')
ax2.tick_params(axis='both', direction='in')
ax2.errorbar(xx+x0-left, stu_d, yerr=stu_d_err, fmt='o', elinewidth=1.5 ,capsize=2, ecolor='b', \
label='Data', linestyle='None', markersize=3 ,color='k')
def set_xticks(self, ticks=None):
if ticks:
super(Radialplot, self).set_xticks(ticks)
else:
if self.transform == "linear":
loc = AutoLocator()
ticks = loc.tick_values(0., self.max_x)
ticks2 = loc.tick_values(min(self.sez), max(self.sez))
ticks2 = ticks2[::-1]
ticks2[-1] = min(self.sez)
super(Radialplot, self).set_xticks(1.0 / ticks2)
labels = ["{0:5.1}".format(val) for val in ticks2]
self.xaxis.set_ticklabels(labels)
self.spines["bottom"].set_bounds(0., 1. / ticks2[-1])
self.set_xlabel(r'$\sigma$')
else:
loc = MaxNLocator(5)
ticks = loc.tick_values(0., self.max_x)
super(Radialplot, self).set_xticks(ticks)
self.spines["bottom"].set_bounds(ticks[0], ticks[-1])
def update_ticks(axes, coord, components, is_log):
"""
Changes the axes to have the proper tick formatting based on the type of
component.
:param axes: A matplotlib axis object to alter
:param coord: 'x' or 'y'
:param components: A list() of components that are plotted along this axis
:param is_log: Boolean for log-scale.
:kwarg max_categories: The maximum number of categories to display.
:return: None or #categories if components is Categorical
"""
if coord == 'x':
axis = axes.xaxis
elif coord == 'y':
axis = axes.yaxis
else:
raise TypeError("coord must be one of x,y")
is_cat = all(comp.categorical for comp in components)
if is_log:
axis.set_major_locator(LogLocator())
axis.set_major_formatter(LogFormatterMathtext())
elif is_cat:
all_categories = np.empty((0, ), dtype=np.object)
for comp in components:
all_categories = np.union1d(comp.categories, all_categories)
locator = MaxNLocator(10, integer=True)
locator.view_limits(0, all_categories.shape[0])
format_func = partial(tick_linker, all_categories)
formatter = FuncFormatter(format_func)
axis.set_major_locator(locator)
axis.set_major_formatter(formatter)
return all_categories.shape[0]
else:
axis.set_major_locator(AutoLocator())
axis.set_major_formatter(ScalarFormatter())
def creation_plot(speciation):
""" ********** Creation of the plot ********** """
plt.close()
fig, ax = plt.subplots(figsize=(8,5))
if speciation == '1':
xlabel = 'Chemical species'
else:
xlabel = 'Coordinating polyhedra'
ax.set_ylabel(r'Cluster absolute lifetime (fs)', fontweight = 'bold', fontsize = 12)
ax.set_xlabel(xlabel, fontweight = 'bold', fontsize = 12)
ax.xaxis.set_label_coords(0.5, -0.3)
ax.yaxis.set_label_coords(-0.1, 0.5)
#Adjustment of ticks
ymajorLocator = AutoLocator()
yminorLocator = AutoMinorLocator()
ax.yaxis.set_major_locator(ymajorLocator)
ax.yaxis.set_minor_locator(yminorLocator)
ax.tick_params(which = 'both', labelsize = 10, width = 0.5)
#plt.autoscale(enable=True,axis='y',tight=True)
#ax.set_ylim(0,770) #for NaAlSi3O8 a19.0
#ax.set_ylim(0,60) #for NaAlSi3O8 a15.0
plt.tick_params(bottom = False, top = False, labelbottom = True)
ax.grid(True, which='major',axis = 'y', linestyle=':', linewidth=0.5 )
return fig,ax
def draw_pic(dataframe, currency):
# check types
if not isinstance(dataframe, pd.DataFrame):
raise TypeError(
'{} should be Pandas.DataFrame object'.format(dataframe))
if not (currency == 'dol') | (currency == 'eur'):
raise NameError('{} should be \'dol\' or \'eur\''.format(currency))
# Draw pic
fig, ax = plt.subplots(figsize=(10, 7))
mean_val = dataframe.loc[:, ['High', 'Low']].mean(axis=1)
x_values = dataframe.index.strftime('%b %d')
ax.fill_between(x_values,
dataframe['High'],
dataframe['Low'],
color='Purple',
alpha=0.2)
ax.plot(x_values, mean_val, linewidth=2, color='Purple')
ax.tick_params(axis='x', direction='out', length=8)
ax.xaxis.set_major_locator(MultipleLocator(4))
ax.yaxis.set_major_locator(AutoLocator())
ax.xaxis.set_minor_locator(AutoMinorLocator())
ax.grid(which='both')
for tick in ax.get_xticklabels():
tick.set_rotation(45)
if currency == 'dol':
ax.set_title('USD/RUB', fontsize=16, pad=25)
ax.set_ylabel('RUB per USD')
fig.savefig('picDol.png')
if currency == 'eur':
ax.set_title('EUR/RUB', fontsize=16, pad=25)
ax.set_ylabel('RUB per EUR')
fig.savefig('picEur.png')
def plot(ts,
figure_width=12,
linewidth=1,
marker=".",
color="mediumvioletred",
aspect_ratio=None,
font=None):
if font is None:
available_fonts = set(f.name for f in font_manager.fontManager.ttflist)
for font in FONTS:
if font in available_fonts:
break
if aspect_ratio is None:
try:
n_unique_values = len(ts.distribution())
except KeyError:
n_unique_values = 0
scaled = min(MAX_ASPECT_POINTS, max(2, n_unique_values) - 2)
aspect_ratio = MIN_ASPECT_RATIO + (
MAX_ASPECT_RATIO - MIN_ASPECT_RATIO) * (scaled / MAX_ASPECT_POINTS)
with plt.style.context('seaborn'):
fig, ax = plt.subplots(figsize=(figure_width,
aspect_ratio * figure_width))
items = ts.items()
x, y = zip(*items) if items else ([], [])
ax.scatter(x, y, linewidth=linewidth, marker=marker, color=color)
ax.set_aspect(75)
ax.xaxis.set_minor_locator(AutoMinorLocator())
ax.xaxis.set_major_locator(AutoLocator())
if font:
plt.xticks(fontname=font)
plt.yticks(fontname=font)
return fig, ax
def process_command(self, command):
from matplotlib.ticker import LogLocator, AutoLocator
self.output(command[0])
if command[0] == 'ig':
self.ig = command[1]
elif command[0] == 'plot':
xdata, ydata, plot_kwargs = command[1:]
ig = self.ig
ax = self.ax[ig]
ax.set_yscale(self.yscales[ig])
ax.yaxis.grid(True)
ax.plot(xdata, ydata, **plot_kwargs)
if self.yscales[ig] == 'log':
ymajor_formatter = ax.yaxis.get_major_formatter()
ymajor_formatter.label_minor(True)
yminor_locator = LogLocator()
else:
yminor_locator = AutoLocator()
self.ax[ig].yaxis.set_minor_locator(yminor_locator)
elif command[0] == 'vline':
x, kwargs = command[1:]
self.vlines[self.ig].append((x, kwargs))
elif command[0] == 'clear':
self.ax[self.ig].cla()
elif command[0] == 'legends':
for ig, ax in enumerate(self.ax):
try:
ax.legend(self.data_names[ig])
except:
pass
if self.xlabels[ig]:
ax.set_xlabel(self.xlabels[ig])
if self.ylabels[ig]:
ax.set_ylabel(self.ylabels[ig])
for x, kwargs in self.vlines[ig]:
ax.axvline(x, **kwargs)
try:
self.plt.tight_layout(pad=0.5)
except:
pass
elif command[0] == 'add_axis':
ig, names, yscale, xlabel, ylabel = command[1:]
self.data_names[ig] = names
self.yscales[ig] = yscale
self.xlabels[ig] = xlabel
self.ylabels[ig] = ylabel
self.n_gr = len(self.data_names)
self.make_axes()
elif command[0] == 'save':
self.fig.savefig(command[1])
self.pipe.send(True) # Acknowledge save.
from __future__ import division
from builtins import range
from past.utils import old_div
import numpy as np
import matplotlib.pyplot as plt
from boututils.file_import import file_import
from matplotlib.ticker import FixedFormatter, FormatStrFormatter, AutoLocator, AutoMinorLocator
g = file_import("data/cbm18_dens8.grid_nx68ny64.nc")
majorLocator = AutoLocator()
majorFormatter = FormatStrFormatter('%3.0e')
minorLocator = AutoMinorLocator()
Fm = FixedFormatter([
'0', '$1 \\times 10^4$', '$2 \\times 10^4$', '$3 \\times 10^4$',
'$4 \\times 10^4$'
])
Fm2 = FixedFormatter(
['0', '$2 \\times 10^5$', '$4 \\times 10^5$', '$6 \\times 10^5$'])
bxy = g.get('Bxy')
p = g.get('pressure')
jpar0 = g.get('Jpar0')
psixy = g.get('psixy')
btxy = g.get('Btxy')
shiftangle = g.get('ShiftAngle')
nx = g.get('nx')
ny = g.get('ny')
q = np.zeros((nx, ny))
