def test_LogFormatter_sublabel():
# test label locator
fig, ax = plt.subplots()
ax.set_xscale('log')
ax.xaxis.set_major_locator(mticker.LogLocator(base=10, subs=[]))
ax.xaxis.set_minor_locator(mticker.LogLocator(base=10,
subs=np.arange(2, 10)))
ax.xaxis.set_major_formatter(mticker.LogFormatter(labelOnlyBase=True))
ax.xaxis.set_minor_formatter(mticker.LogFormatter(labelOnlyBase=False))
# axis range above 3 decades, only bases are labeled
ax.set_xlim(1, 1e4)
fmt = ax.xaxis.get_major_formatter()
fmt.set_locs(ax.xaxis.get_majorticklocs())
show_major_labels = [fmt(x) != '' for x in ax.xaxis.get_majorticklocs()]
assert np.all(show_major_labels)
_sub_labels(ax.xaxis, subs=[])
# For the next two, if the numdec threshold in LogFormatter.set_locs
# were 3, then the label sub would be 3 for 2-3 decades and (2,5)
# for 1-2 decades. With a threshold of 1, subs are not labeled.
# axis range at 2 to 3 decades
ax.set_xlim(1, 800)
_sub_labels(ax.xaxis, subs=[])
# axis range at 1 to 2 decades
ax.set_xlim(1, 80)
_sub_labels(ax.xaxis, subs=[])
# axis range at 0.4 to 1 decades, label subs 2, 3, 4, 6
ax.set_xlim(1, 8)
_sub_labels(ax.xaxis, subs=[2, 3, 4, 6])
# axis range at 0 to 0.4 decades, label all
ax.set_xlim(0.5, 0.9)
_sub_labels(ax.xaxis, subs=np.arange(2, 10, dtype=int))
def test_LogFormatter_sublabel():
# test label locator
fig, ax = plt.subplots()
ax.set_xscale('log')
ax.xaxis.set_major_locator(mticker.LogLocator(base=10, subs=[]))
ax.xaxis.set_minor_locator(
mticker.LogLocator(base=10, subs=np.arange(2, 10)))
ax.xaxis.set_major_formatter(mticker.LogFormatter())
ax.xaxis.set_minor_formatter(mticker.LogFormatter(labelOnlyBase=False))
# axis range above 3 decades, only bases are labeled
ax.set_xlim(1, 1e4)
fmt = ax.xaxis.get_major_formatter()
fmt.set_locs(ax.xaxis.get_majorticklocs())
show_major_labels = [fmt(x) != '' for x in ax.xaxis.get_majorticklocs()]
assert np.all(show_major_labels)
_sub_labels(ax.xaxis, subs=[])
# axis range at 2 to 3 decades, label sub 3
ax.set_xlim(1, 800)
_sub_labels(ax.xaxis, subs=[3])
# axis range at 1 to 2 decades, label subs 2 and 5
ax.set_xlim(1, 80)
_sub_labels(ax.xaxis, subs=[2, 5])
# axis range at 0 to 1 decades, label subs 2, 3, 6
ax.set_xlim(1, 8)
_sub_labels(ax.xaxis, subs=[2, 3, 6])
def set_log_minor(ax=None, which="both", subs=(2, 5)):
if ax is None: ax = plt.gca()
if which in ("both", "x"):
ax.xaxis.set_minor_locator(ticker.LogLocator(subs=subs))
ax.xaxis.set_minor_formatter(ticker.LogFormatter(labelOnlyBase=False))
if which in ("both", "y"):
ax.yaxis.set_minor_locator(ticker.LogLocator(subs=subs))
ax.yaxis.set_minor_formatter(ticker.LogFormatter(labelOnlyBase=False))
def plot_curves(file_name, type_name, show_ylabel=True, show_legend=True):
json_file = os.path.join(common.result_folder, file_name)
xlabel = 'num_dexels'
ylabel = 'time'
with open(json_file, 'r') as f:
database = json.load(f)
# Get list of x entries
x_array = set()
for entries in database.values():
x_array = x_array | set(entry[xlabel] for entry in entries)
x_array = sorted(x_array)
# Get list of y entries
y_arrays = {}
for i, entries in enumerate(database.values()):
for entry in entries:
key = (entry['operation'], entry['radius_relative'])
if key not in y_arrays:
y_arrays[key] = numpy.zeros(
(len(database.keys()), len(x_array)))
j = x_array.index(entry[xlabel])
y_arrays[key][i, j] = entry[ylabel] / 1000
# Draw plot
colors = itertools.cycle(('C0', 'C1', 'C2', 'C3'))
markers = itertools.cycle(('o', '*', 'd', '^')) # ',', +', '.', 'o', '*')
linestyles = itertools.cycle(('-', '--', '-.', ':'))
# plt.figure()
fig, ax = common.newfig(1)
show_conv = (type_name == 'loglog')
for key, y_array in sorted(y_arrays.items()):
r = key[1]
c = next(colors)
e = key[0].title()
name = '{}, $r = {}$'.format(e, r)
common.region_plot(x_array, y_array, c, c, name, next(linestyles),
next(markers), show_conv)
if type_name == 'loglog':
plt.loglog()
ax.xaxis.set_major_formatter(plticker.LogFormatter(labelOnlyBase=True))
ax.xaxis.set_minor_formatter(
plticker.LogFormatter(labelOnlyBase=False,
minor_thresholds=(4, 0.5)))
plt.xlabel(common.legends[xlabel], fontsize='large')
if show_ylabel:
plt.ylabel(common.legends[ylabel], fontsize='large')
# if show_legend:
plt.legend(loc='upper left')
result_plot = os.path.join(
common.result_folder, ylabel + '_' + os.path.splitext(file_name)[0] +
'_' + type_name + '.pdf')
# plt.savefig(result_plot)
common.savefig(result_plot)
def main(config_path):
src, fs = wav_tools.read_wav('data/src.wav')
new_brir_path = 'data/test.wav'
# configs = parse_config_file(config_path)
# new_config_path = 'config.cfg'
# new_fig_path = 'test.png'
# syn_brir(configs, new_config_path, new_brir_path, new_fig_path,
# parallel_type=2, n_worker=12)
new_brir, fs = wav_tools.read_wav(new_brir_path)
new_record = wav_tools.brir_filter(src, new_brir)
wav_tools.write_wav(new_record, fs, 'data/new/reverb/15_0387_0.wav')
brir, fs = wav_tools.read_wav(config_path.replace('cfg', 'wav'))
record = wav_tools.brir_filter(src, brir)
wav_tools.write_wav(new_record, fs, 'data/pre/reverb/15_0387_0.wav')
# brir
fig, ax = plt.subplots(3, 3, tight_layout=True, figsize=[10, 8])
ax[0, 0].plot(brir[:, 0])
ax[0, 0].set_ylabel('brir')
ax[0, 0].set_title('pre')
ax[0, 1].plot(new_brir[:, 0])
ax[0, 1].set_title('new')
ax[0, 2].plot(brir[:, 0] - new_brir[:, 0])
ax[0, 2].yaxis.set_major_formatter(ticker.LogFormatter())
ax[0, 2].set_title('difference')
ax[1, 0].plot(record[:, 0])
ax[1, 0].set_ylabel('record')
ax[1, 1].plot(new_record[:, 0])
ax[1, 2].plot(record[:, 0] - new_record[:, 0])
ax[1, 2].yaxis.set_major_formatter(ticker.LogFormatter())
specgram, freqs, bins, im = ax[2, 0].specgram(record[:, 0],
Fs=fs,
NFFT=512,
noverlap=256,
cmap='jet')
new_specgram, freqs, bins, im = ax[2, 1].specgram(new_record[:, 0],
Fs=fs,
NFFT=512,
noverlap=256,
cmap='jet')
ax[2, 2].imshow(specgram - new_specgram,
aspect='auto',
cmap='jet',
extent=[bins[0], bins[-1], freqs[0], freqs[-1]])
fig.savefig('images/validate.png')
def plot_prices(df, module_type):
m = df[module_type + '_mean']
h = df[module_type + '_high']
l = df[module_type + '_low']
fig = plt.figure(figsize=(6, 3.5))
ax = fig.add_subplot(111)
ax.semilogy(df.index, m, 'b', lw=2)
ax.fill_between(df.index, l, h, color='blue', alpha=0.2)
ax.yaxis.set_minor_locator(
ticker.LogLocator(base=10, subs=np.arange(2, 10, step=1.0)))
# ax.yaxis.set_major_locator(ticker.LogLocator(base=10, subs='all'))
# ax.yaxis.set_minor_locator(ticker.MultipleLocator(0.05))
plt.ylim((0.2, 2.25))
# ax.yaxis.set_major_formatter(ticker.ScalarFormatter())
ax.yaxis.set_minor_formatter(
ticker.LogFormatter(labelOnlyBase=False, minor_thresholds=(100, 0.01)))
ax.tick_params(axis='both', which='both')
years = mdates.YearLocator() # every year
yearsFmt = mdates.DateFormatter('%Y')
ax.xaxis.set_major_locator(years)
ax.xaxis.set_major_formatter(yearsFmt)
# months = mdates.MonthLocator() # every month
# ax.xaxis.set_minor_locator(months)
plt.grid(True, 'both')
plt.xlabel('Time')
plt.ylabel('Price ($/Watt)')
plt.title('Historical Prices of ' + module_type + ' Modules')
fig.savefig(module_type + ".pdf", bbox_inches='tight')
return fig
def init(*fargs):
# Create colorbar as a legend
cmap = cm.get_cmap('Reds', 4)
print(vmin, vmax)
if log:
norm = cm.colors.LogNorm(vmin=vmin, vmax=vmax)
else:
norm = cm.colors.Normalize(vmin=vmin, vmax=vmax)
sm = cm.ScalarMappable(cmap=cmap, norm=norm)
# empty array for the data range
sm._A = []
# add the colorbar to the figure
divider = make_axes_locatable(ax)
size = "5%"
cax = divider.append_axes("right", size=size, pad=0.1)
cbar = fig.colorbar(sm, cax=cax, cmap=cmap)
cbar.ax.tick_params(labelsize=18)
vals = list(cbar.ax.get_yticks())
vals.append(vmax)
print(vals)
if log:
cbar.ax.yaxis.set_major_formatter(mtick.LogFormatter())
else:
cbar.ax.yaxis.set_major_formatter(mtick.Formatter())
cbar.ax.set_yticklabels([int(x) for x in vals])
cbar.ax.set_ylabel(key, fontsize=20)
def logscale_plot(ax, xrange, yrange, base=10):
from matplotlib import ticker
if xrange is not None:
ax.xaxis.set_minor_formatter(ticker.LogFormatter())
ax.xaxis.set_major_formatter(ticker.LogFormatter())
ax.set_xscale("log", base=base)
ax.set_xlim([np.min(xrange), np.max(xrange)])
if yrange is not None:
ax.yaxis.set_minor_formatter(ticker.LogFormatter())
ax.yaxis.set_major_formatter(ticker.LogFormatter())
ax.set_yscale("log", base=base)
ax.set_ylim([
yrange.min() - 0.1 * yrange.min(),
yrange.max() + 0.1 * yrange.min()
])
def mozenaPlot(data):
'''
create the plot from Mark Mozena's thesis with given data
Sersic vs Reff vs Axis Ratio
'''
condition = np.ones_like(data["red"], bool)
condition &= data["cam"] != 0
condition &= data["cam"] != 1
condition &= (data["red"] > 1.4) & (data["red"] < 2.6)
condition &= (data["mass"] > 10**8.5) & (data["mass"] < 10**11)
s = 0.5
ser = data["ser"][condition]
rad = data["rad"][condition]
ba = data["ba"][condition]
serlim = [0, 5.5]
serticks = [1, 2, 3, 4, 5]
serVSrad = plt.subplot(221)
serVSrad.plot(rad, ser, "bs", ms=s)
serVSrad.set_xscale("log")
serVSrad.set_ylabel("Sersic (n)", labelpad=15)
serVSrad.set_ylim(serlim)
serVSrad.set_yticks(serticks)
serVSrad.yaxis.set_minor_locator(ticker.AutoMinorLocator(n=2))
plt.setp(serVSrad.get_xticklabels(), visible=False)
baVSrad = plt.subplot(223, sharex=serVSrad)
baVSrad.plot(rad, ba, "bs", ms=s)
baVSrad.set_xlabel("$R_{eff}$ (kpc)")
baVSrad.set_xscale("log")
baVSrad.set_xlim(0.5, 12)
baVSrad.set_xticks([1.0, 3.0, 10.0])
baVSrad.xaxis.set_major_formatter(ticker.LogFormatter(labelOnlyBase=False))
baVSrad.set_ylabel("Axis Ratio (q)")
baVSser = plt.subplot(224, sharey=baVSrad)
baVSser.plot(ser, ba, "bs", ms=s)
baVSser.set_xlim(serlim)
baVSser.set_xticks(serticks)
baVSser.xaxis.set_minor_locator(ticker.AutoMinorLocator(n=2))
baVSser.set_xlabel("Sersic (n)")
baVSser.set_ylim(0, 1.05)
baVSser.set_yticks([0.2, 0.4, 0.6, 0.8, 1.0])
baVSser.yaxis.set_minor_locator(ticker.AutoMinorLocator(n=2))
plt.setp(baVSser.get_yticklabels(), visible=False)
# remove extra space between subplots
plt.tight_layout(w_pad=0, h_pad=0)
# these are matplotlib.patch.Patch properties
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
# place a text box in upper left in axes coords
textstr = "Simulations\nFour Random Cameras\n$z = 1.4 - 2.6$"
textstr += "\n$log(M_{\odot}) = 8.5 - 11.0$\n$N = %d$" % len(ser)
plt.figtext(0.6, 0.9, textstr, fontsize=16,
verticalalignment='top') #, bbox=props)
return
def scatter_plot(xs, ys, xlabel, ylabel, title, leg=False):
width = 505.89
fig, ax = plt.subplots(1, 1, figsize=set_size(width, fraction=0.5))
plt.tight_layout()
plt.gcf().subplots_adjust(bottom=0.2, left=0.2)
ax.scatter(xs, ys, 1.0, alpha=0.5)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
ax.set_yscale('log')
ax.set_xscale('log')
lims = [
np.min([0, 0]), # min of both axes
np.max([6000, 500]), # max of both axes
]
# now plot both limits against eachother
ax.plot(lims, lims, 'k-', alpha=0.6, label='Ping latency')
ax.plot(xs, [x * 10 for x in xs],
'#A62447',
alpha=0.6,
label='ARAs bound K=3 ')
ax.set_ylim([1, 6000.0])
ax.set_xlim([1, 500])
bins = np.arange(min(xs), max(xs), 2)
percentilef = lambda v: np.percentile(v, 50, axis=0)
means = binned_statistic(xs, ys, statistic=percentilef, bins=bins)[0]
ax.plot(bins[:-1],
means,
'go',
alpha=0.2,
markersize=4,
label="50th percentile")
percentilef = lambda v: np.percentile(v, 95, axis=0)
means = binned_statistic(xs, ys, statistic=percentilef, bins=bins)[0]
ax.plot(bins[:-1],
means,
'o',
markerfacecolor="#A62447",
markersize=4,
alpha=0.2,
label="95th percentile")
if leg:
ax.legend(loc='lower right', prop={'size': 6})
ax.xaxis.set_major_locator(ticker.MultipleLocator(2))
ax.xaxis.set_major_formatter(
ticker.LogFormatter(base=2.0,
labelOnlyBase=True,
minor_thresholds=None,
linthresh=None))
def __init__(
self,
ax,
cmap=None,
norm=None,
alpha=None,
values=None,
boundaries=None,
orientation='vertical',
extend='neither',
spacing='uniform', # uniform or proportional
ticks=None,
format=None,
drawedges=False,
filled=True,
):
self.ax = ax
self._patch_ax()
if cmap is None: cmap = cm.get_cmap()
if norm is None: norm = colors.Normalize()
self.alpha = alpha
cm.ScalarMappable.__init__(self, cmap=cmap, norm=norm)
self.values = values
self.boundaries = boundaries
self.extend = extend
self._inside = self._slice_dict[extend]
self.spacing = spacing
self.orientation = orientation
self.drawedges = drawedges
self.filled = filled
self.solids = None
self.lines = None
self.outline = None
self.patch = None
self.dividers = None
self.set_label('')
if cbook.iterable(ticks):
self.locator = ticker.FixedLocator(ticks, nbins=len(ticks))
else:
self.locator = ticks # Handle default in _ticker()
if format is None:
if isinstance(self.norm, colors.LogNorm):
self.formatter = ticker.LogFormatter()
else:
self.formatter = ticker.ScalarFormatter()
elif cbook.is_string_like(format):
self.formatter = ticker.FormatStrFormatter(format)
else:
self.formatter = format # Assume it is a Formatter
# The rest is in a method so we can recalculate when clim changes.
self.config_axis()
self.draw_all()
def stft_pcolormesh(t,
f,
Zxx,
title="STFT Magnitude",
xlabel="Time (s)",
ylabel="Frequency (Hz)",
ylim=None,
yscale="log",
figsize=(6, 4),
options=["grid"],
plot_type="pcolormesh",
shading="gouraud",
max_mag=None,
**kwargs):
tickers = {
"yaxis": {
"major": {
"locator":
ticker.AutoLocator(),
"formatter":
ticker.LogFormatter(labelOnlyBase=False,
minor_thresholds=(np.inf, np.inf))
}
}
}
mag = np.abs(Zxx)**2
return FigData(
xs=t,
ys=f,
zs=mag,
title=title,
xlabel=xlabel,
ylabel=ylabel,
line_options=[{
"vmin": 0,
"vmax": np.max(mag) if max_mag is None else max_mag,
"shading": shading
}],
ylim=ylim,
yscale=yscale,
figsize=figsize,
options=options,
plot_type=plot_type,
tickers=tickers if yscale == "log" else None,
fit_data=False, # This must be False for a 2D zs array
**kwargs)
def plotShear(r, gt, gx, rerr, gterr, gxerr, marker='o', gs=None, **kwargs):
""" plotShear(r,gt,gx,rerr,gterr,gxerr,marker='o',gs=None,**kwargs)
"""
from matplotlib import gridspec
convert = (u.Mpc**(-2)).to(u.pc**(-2)) # plot in units Msun/pc**2
#convert=1e-14
if gs is None:
gs = gridspec.GridSpec(2, 1, height_ratios=[2, 1])
plt.subplots_adjust(hspace=0.001)
# gt
top_ax = plt.subplot(gs[0])
#top_ax = plt.subplot(211)
top_ax.set_yticks([0], minor=True)
top_ax.yaxis.grid(True, which='minor', ls='--')
top_ax.errorbar(r, (gt * convert),
yerr=(gterr * convert),
xerr=rerr,
marker=marker,
ls='None',
**kwargs)
plt.xscale('log')
#plt.yscale('log')
#plt.ylabel(r'$\Delta \Sigma_+\ [h 10^{14} M_\odot \mathrm{Mpc}^{-2}]$')
plt.ylabel(r'$\Delta \Sigma_+\ [h M_\odot \mathrm{pc}^{-2}]$')
# gx
bottom_ax = plt.subplot(gs[1], sharex=top_ax)
#bottom_ax = plt.subplot(212, sharex=top_ax)
bottom_ax.set_yticks([0], minor=True)
bottom_ax.yaxis.grid(True, which='minor', ls='--')
bottom_ax.errorbar(r, (gx * convert),
yerr=(gxerr * convert),
xerr=rerr,
marker=marker,
ls='None',
**kwargs)
plt.ylabel(r'$\Delta\Sigma_\times$')
plt.setp(top_ax.get_xticklabels(), visible=False)
plt.xlabel(r'R [Mpc/$h$]')
bottom_ax.xaxis.set_major_formatter(ticker.LogFormatter())
nbins = len(top_ax.get_yticklabels()) # added
bottom_ax.yaxis.set_major_locator(
ticker.MaxNLocator(nbins=usel.floor_to_odd(nbins / 2.),
prune='upper')) # adde
plt.xlim([r[0] - np.diff(r)[0], r[-1] + np.diff(r)[-1]])
#plt.tight_layout()
#plt.subplots_adjust(hspace=0.001)
return (top_ax, bottom_ax), gs
def n_plot(r, dr, n, dn, **kwargs):
plt.errorbar(r.value,
n.value,
yerr=dn.value,
xerr=dr.value,
marker='s',
ls='None',
**kwargs)
plt.xscale('log')
plt.ylabel(r'$n_g\ [{0}]$'.format(n.unit))
#plt.setp(plt.gca().get_xticklabels(), visible=False)
plt.gca().xaxis.set_major_formatter(ticker.LogFormatter())
plt.xlabel('R [{0}]'.format(r.unit))
plt.xlim(
[r.value[0] - np.diff(r.value)[0], r.value[-1] + np.diff(r.value)[-1]])
def build_plot(self,
xlabel="", ylabel="Overhead w.r.t. native",
legend_loc=None,
figsize=(12, 2),
text_points=(),
vline_position=6,
title="",
ncol=5,
build_names="short",
**kwargs):
# rename builds
self.df.rename(columns=prepare.BUILD_NAMES[build_names], inplace=True)
logging.info("Building plot")
style = self.StyleClass(legend_ncol=ncol, legend_loc=legend_loc)
plot = self.df.plot(
kind="bar",
figsize=figsize,
linewidth=0.5,
edgecolor=style.bar_edge_color,
color=style.colors,
title=title,
**kwargs
)
plot = style.apply(plot)
if kwargs.get("logy", False) == True:
plot.set_yscale('log', basey=2)
plot.yaxis.set_major_formatter(plticker.LogFormatter(base=2))
# parametrize labels
plot.set_ylabel(ylabel, fontsize=10)
plot.set_xlabel("", fontsize=0) # remove x label
# vertical line - usually, a delimiter for mean values
plot.axvline(vline_position, linewidth=0.9, color='grey', dashes=[3, 3])
# additional text
for point in text_points:
plot.text(point[0], point[1], point[2], fontsize=8)
# save the resulting plot as an object property
self.plot = plot
def init():
# Create colorbar as a legend
cmap = cm.get_cmap('Reds', 4)
vmin = 1 if "Deaths" in key else 10
print(vmin, vmax)
size = "5%"
sm = plt.cm.ScalarMappable(cmap=cmap, norm=cm.colors.LogNorm(vmin=vmin,
vmax =vmax))#round(vmax, len(str(vmax))-1)))
# empty array for the data range
sm._A = []
# add the colorbar to the figure
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size = size, pad = 0.1)
cbar = fig.colorbar(sm, cax=cax, cmap = cmap)
cbar.ax.tick_params(labelsize=18)
vals = list(cbar.ax.get_yticks())
vals.append(vmax)
print(vals)
cbar.ax.yaxis.set_major_formatter(mtick.LogFormatter())
cbar.ax.set_yticklabels([int(x) for x in vals])
cbar.ax.set_ylabel(key, fontsize = 20)
def plotShearEB(r, gt, gx, gterr, gxerr, ax=None, **kwargs):
""" plotShearV2(r,gt,gx,,gterr,gxerr,marker='o',gs=None,**kwargs)
"""
convert = (u.Mpc**(-2)).to(u.pc**(-2)) # plot in units Msun/pc**2
#convert=1e-14
if ax is None:
fig, ax = plt.subplots()
#top_ax = plt.subplot(211)
# ax.set_yticks([0], minor=True)
# ax.yaxis.grid(True, which='minor', ls='--')
ax.errorbar(r, (gt * convert),
yerr=(gterr * convert),
marker='o',
color='k',
ls='None',
label='E',
**kwargs)
plt.xscale('log')
#plt.yscale('log')
#plt.ylabel(r'$\Delta \Sigma_+\ [h 10^{14} M_\odot \mathrm{Mpc}^{-2}]$')
plt.ylabel(r'$\Delta \Sigma [h M_\odot \mathrm{pc}^{-2}]$')
# gx
ax.plot(r * 10**0.01, (gx * convert),
marker='x',
color='r',
ls='None',
label='B',
**kwargs)
plt.xlabel(r'R [Mpc/$h$]')
ax.xaxis.set_major_formatter(ticker.LogFormatter())
plt.xlim([r[0] - np.diff(r)[0], r[-1] + np.diff(r)[-1]])
plt.axhline(y=0, ls=':', c='k')
#plt.tight_layout()
#plt.subplots_adjust(hspace=0.001)
plt.legend()
return ax
def setTicks(self, fig, ax):
if self.handlerId == "lineChart" and self.getBooleanOption(
"logy", False):
start, end = ax.get_ylim()
ax.yaxis.set_minor_locator(
ticker.MultipleLocator((end - start) / 4))
ax.yaxis.set_minor_formatter(
ticker.LogFormatter(labelOnlyBase=False))
ax.grid(True, which='both')
labels = [s.get_text() for s in ax.get_xticklabels()]
totalWidth = sum(len(s) for s in labels) * 5
if totalWidth > self.getPreferredOutputWidth():
self.needsStretching = self.canStretch()
if self.isStretchingOn():
#resize image width
fig.set_size_inches(
min(totalWidth / self.getDPI(), 32768 / self.getDPI()),
fig.get_figheight())
else:
self.addMessage(
"Some labels are not displayed because of a lack of space. Click on Stretch image to see them all"
)
#filter down the list to max 20
max = int(len(labels) / 20)
if max < 20:
xl = [(i, a[:10] + ".." if len(a) > 10 else a)
for i, a in enumerate(labels)]
else:
xl = [(i, a) for i, a in enumerate(labels)
if (i % max == 0)]
ax.set_xticks([x[0] for x in xl])
ax.set_xticklabels([x[1] for x in xl])
plt.xticks(rotation=30)
else:
plt.xticks(rotation=0)
def test_LogFormatter_call(self, val):
# test _num_to_string method used in __call__
temp_lf = mticker.LogFormatter()
temp_lf.axis = FakeAxis()
assert temp_lf(val) == str(val)
def test_pprint(self, value, domain, expected):
fmt = mticker.LogFormatter()
label = fmt._pprint_val(value, domain)
assert label == expected
def __init__(self, ax, cmap=None,
norm=None,
alpha=1.0,
values=None,
boundaries=None,
orientation='vertical',
extend='neither',
spacing='uniform', # uniform or proportional
ticks=None,
format=None,
drawedges=False,
filled=True,
):
self.ax = ax
if cmap is None: cmap = cm.get_cmap()
if norm is None: norm = colors.Normalize()
self.alpha = alpha
cm.ScalarMappable.__init__(self, cmap=cmap, norm=norm)
self.values = values
self.boundaries = boundaries
self.extend = extend
self.spacing = spacing
self.orientation = orientation
self.drawedges = drawedges
self.filled = filled
# artists
self.solids = None
self.lines = None
self.dividers = None
self.extension_patch1 = None
self.extension_patch2 = None
if orientation == "vertical":
self.cbar_axis = self.ax.yaxis
else:
self.cbar_axis = self.ax.xaxis
if format is None:
if isinstance(self.norm, colors.LogNorm):
# change both axis for proper aspect
self.ax.xaxis.set_scale("log")
self.ax.yaxis.set_scale("log")
self.ax._update_transScale()
self.cbar_axis.set_minor_locator(ticker.NullLocator())
formatter = ticker.LogFormatter()
else:
formatter = None
elif cbook.is_string_like(format):
formatter = ticker.FormatStrFormatter(format)
else:
formatter = format # Assume it is a Formatter
if formatter is None:
formatter = self.cbar_axis.get_major_formatter()
else:
self.cbar_axis.set_major_formatter(formatter)
if cbook.iterable(ticks):
self.cbar_axis.set_ticks(ticks)
elif ticks is not None:
self.cbar_axis.set_major_locator(ticks)
else:
self._select_locator(formatter)
self._config_axes()
self.update_artists()
self.set_label_text('')
def _pprint_helper(value, domain, expected):
fmt = mticker.LogFormatter()
label = fmt.pprint_val(value, domain)
nose.tools.assert_equal(label, expected)
def _set_ticker(self, a):
try:
if not isiterable(self.ticks):
if self.scale == 'linear':
a.set_major_locator(mticker.AutoLocator())
elif self.scale == 'log':
a.set_major_locator(mticker.LogLocator(self.base))
elif self.scale == 'symlog':
from matplotlib.scale import SymmetricalLogScale
if isMPL33:
scale = SymmetricalLogScale(
a,
base=self.base,
linthresh=self.symloglin,
linscale=self.symloglinscale)
else:
scale = SymmetricalLogScale(
a,
basex=self.base,
linthreshx=self.symloglin,
linscalex=self.symloglinscale)
a.set_major_locator(
mticker.SymmetricalLogLocator(scale.get_transform()))
# scale.set_default_locators_and_formatters(a)
else:
a.set_major_locator(mticker.AutoLocator())
#a.get_axes().locator_params(self.name[0], nbins = 10)
if self.ticks is not None:
value = self.ticks
else:
#figpage = a.get_axes().figobj.get_figpage()
figpage = a.axes.figobj.get_figpage()
if self.name[0] == 'x':
value = figpage.getp('nticks')[0]
elif self.name[0] == 'y':
value = figpage.getp('nticks')[1]
elif self.name[0] == 'z':
value = figpage.getp('nticks')[2]
else:
pass
try:
# this works onlyfor MaxNLocator
#a.get_axes().locator_params(self.name[0], nbins = value)
a.axes.locator_params(self.name[0], nbins=value)
except BaseException:
# for Symlog and LogLocator
a.get_major_locator().numticks = value
else:
a.set_ticks(self.ticks)
if self.format == 'default':
if self.scale == 'linear':
a.set_major_formatter(mticker.ScalarFormatter())
elif self.scale == 'log':
a.set_major_formatter(
mticker.LogFormatterMathtext(self.base))
elif self.scale == 'symlog':
a.set_major_formatter(
mticker.LogFormatterMathtext(self.base))
else:
a.set_major_formatter(mticker.ScalarFormatter())
elif self.format == 'scalar':
a.set_major_formatter(mticker.ScalarFormatter())
elif self.format == 'scalar(mathtext)':
a.set_major_formatter(
mticker.ScalarFormatter(useOffset=True, useMathText=True))
a.get_major_formatter().get_offset()
elif self.format == 'log':
a.set_major_formatter(mticker.LogFormatter(self.base))
elif self.format == 'log(mathtext)':
a.set_major_formatter(mticker.LogFormatterMathtext(self.base))
elif self.format == 'log(exp)':
a.set_major_formatter(mticker.LogFormatterExponent(self.base))
elif self.format == 'none':
a.set_major_formatter(mticker.NullFormatter())
else:
a.set_major_formatter(mticker.FormatStrFormatter(self.format))
except BaseException:
import traceback
traceback.print_exc()
def test_minlocator_type():
fig, ax = plt.subplots()
with pytest.raises(TypeError):
ax.xaxis.set_minor_locator(mticker.LogFormatter())
def show_image(self):
self.fig.clf()
stat_temp = self.get_activated_num()
stat_temp = OrderedDict(
sorted(six.iteritems(stat_temp), key=lambda x: x[0]))
# Check if positions data is available. Positions data may be unavailable
# (not recorded in HDF5 file) if experiment is has not been completed.
# While the data from the completed part of experiment may still be used,
# plotting vs. x-y or scatter plot may not be displayed.
positions_data_available = False
if 'positions' in self.data_dict.keys():
positions_data_available = True
# Create local copies of self.pixel_or_pos, self.scatter_show and self.grid_interpolate
pixel_or_pos_local = self.pixel_or_pos
scatter_show_local = self.scatter_show
grid_interpolate_local = self.grid_interpolate
# Disable plotting vs x-y coordinates if 'positions' data is not available
if not positions_data_available:
if pixel_or_pos_local:
pixel_or_pos_local = 0 # Switch to plotting vs. pixel number
logger.error(
"'Positions' data is not available. Plotting vs. x-y coordinates is disabled"
)
if scatter_show_local:
scatter_show_local = False # Switch to plotting vs. pixel number
logger.error(
"'Positions' data is not available. Scatter plot is disabled."
)
if grid_interpolate_local:
grid_interpolate_local = False # Switch to plotting vs. pixel number
logger.error(
"'Positions' data is not available. Interpolation is disabled."
)
low_lim = 1e-4 # define the low limit for log image
plot_interp = 'Nearest'
if self.scaler_data is not None:
if np.count_nonzero(self.scaler_data) == 0:
logger.warning('scaler is zero - scaling was not applied')
elif len(self.scaler_data[self.scaler_data == 0]) > 0:
logger.warning('scaler data has zero values')
grey_use = self.color_opt
ncol = int(np.ceil(np.sqrt(len(stat_temp))))
try:
nrow = int(np.ceil(len(stat_temp) / float(ncol)))
except ZeroDivisionError:
ncol = 1
nrow = 1
a_pad_v = 0.8
a_pad_h = 0.5
grid = ImageGrid(self.fig,
111,
nrows_ncols=(nrow, ncol),
axes_pad=(a_pad_v, a_pad_h),
cbar_location='right',
cbar_mode='each',
cbar_size='7%',
cbar_pad='2%',
share_all=True)
def _compute_equal_axes_ranges(x_min, x_max, y_min, y_max):
"""
Compute ranges for x- and y- axes of the plot. Make sure that the ranges for x- and y-axes are
always equal and fit the maximum of the ranges for x and y values:
max(abs(x_max-x_min), abs(y_max-y_min))
The ranges are set so that the data is always centered in the middle of the ranges
Parameters
----------
x_min, x_max, y_min, y_max : float
lower and upper boundaries of the x and y values
Returns
-------
x_axis_min, x_axis_max, y_axis_min, y_axis_max : float
lower and upper boundaries of the x- and y-axes ranges
"""
x_axis_min, x_axis_max, y_axis_min, y_axis_max = x_min, x_max, y_min, y_max
x_range, y_range = abs(x_max - x_min), abs(y_max - y_min)
if x_range > y_range:
y_center = (y_max + y_min) / 2
y_axis_max = y_center + x_range / 2
y_axis_min = y_center - x_range / 2
else:
x_center = (x_max + x_min) / 2
x_axis_max = x_center + y_range / 2
x_axis_min = x_center - y_range / 2
return x_axis_min, x_axis_max, y_axis_min, y_axis_max
def _adjust_data_range_using_min_ratio(c_min,
c_max,
c_axis_range,
*,
min_ratio=0.01):
"""
Adjust the range for plotted data along one axis (x or y). The adjusted range is
applied to the 'extend' attribute of imshow(). The adjusted range is always greater
than 'axis_range * min_ratio'. Such transformation has no physical meaning
and performed for aesthetic reasons: stretching the image presentation of
a scan with only a few lines (1-3) greatly improves visibility of data.
Parameters
----------
c_min, c_max : float
boundaries of the data range (along x or y axis)
c_axis_range : float
range presented along the same axis
Returns
-------
cmin, c_max : float
adjusted boundaries of the data range
"""
c_range = c_max - c_min
if c_range < c_axis_range * min_ratio:
c_center = (c_max + c_min) / 2
c_new_range = c_axis_range * min_ratio
c_min = c_center - c_new_range / 2
c_max = c_center + c_new_range / 2
return c_min, c_max
for i, (k, v) in enumerate(six.iteritems(stat_temp)):
quant_norm_applied = False
if self.quantitative_normalization:
# Quantitative normalization
data_dict, quant_norm_applied = self.param_quant_analysis.apply_quantitative_normalization(
data_in=self.dict_to_plot[k],
scaler_dict=self.scaler_norm_dict,
scaler_name_default=self.get_selected_scaler_name(),
data_name=k,
name_not_scalable=self.name_not_scalable)
else:
# Normalize by the selected scaler in a regular way
data_dict = normalize_data_by_scaler(
data_in=self.dict_to_plot[k],
scaler=self.scaler_data,
data_name=k,
name_not_scalable=self.name_not_scalable)
if pixel_or_pos_local or scatter_show_local:
# xd_min, xd_max, yd_min, yd_max = min(self.x_pos), max(self.x_pos),
# min(self.y_pos), max(self.y_pos)
x_pos_2D = self.data_dict['positions']['x_pos']
y_pos_2D = self.data_dict['positions']['y_pos']
xd_min, xd_max, yd_min, yd_max = x_pos_2D.min(), x_pos_2D.max(
), y_pos_2D.min(), y_pos_2D.max()
xd_axis_min, xd_axis_max, yd_axis_min, yd_axis_max = \
_compute_equal_axes_ranges(xd_min, xd_max, yd_min, yd_max)
xd_min, xd_max = _adjust_data_range_using_min_ratio(
xd_min, xd_max, xd_axis_max - xd_axis_min)
yd_min, yd_max = _adjust_data_range_using_min_ratio(
yd_min, yd_max, yd_axis_max - yd_axis_min)
# Adjust the direction of each axis depending on the direction in which encoder values changed
# during the experiment. Data is plotted starting from the upper-right corner of the plot
if x_pos_2D[0, 0] > x_pos_2D[0, -1]:
xd_min, xd_max, xd_axis_min, xd_axis_max = xd_max, xd_min, xd_axis_max, xd_axis_min
if y_pos_2D[0, 0] > y_pos_2D[-1, 0]:
yd_min, yd_max, yd_axis_min, yd_axis_max = yd_max, yd_min, yd_axis_max, yd_axis_min
else:
yd, xd = data_dict.shape
xd_min, xd_max, yd_min, yd_max = 0, xd, 0, yd
if (yd <= math.floor(xd / 100)) and (xd >= 200):
yd_min, yd_max = -math.floor(xd / 200), math.ceil(xd / 200)
if (xd <= math.floor(yd / 100)) and (yd >= 200):
xd_min, xd_max = -math.floor(yd / 200), math.ceil(yd / 200)
xd_axis_min, xd_axis_max, yd_axis_min, yd_axis_max = \
_compute_equal_axes_ranges(xd_min, xd_max, yd_min, yd_max)
if self.scale_opt == 'Linear':
low_ratio = self.limit_dict[k]['low'] / 100.0
high_ratio = self.limit_dict[k]['high'] / 100.0
if (self.scaler_data is None) and (not quant_norm_applied):
minv = self.range_dict[k]['low']
maxv = self.range_dict[k]['high']
else:
# Unfortunately, the new normalization procedure requires to recalculate min and max values
minv = np.min(data_dict)
maxv = np.max(data_dict)
low_limit = (maxv - minv) * low_ratio + minv
high_limit = (maxv - minv) * high_ratio + minv
# Set some minimum range for the colorbar (otherwise it will have white fill)
if math.isclose(low_limit, high_limit, abs_tol=2e-20):
if abs(low_limit) < 1e-20: # The value is zero
dv = 1e-20
else:
dv = math.fabs(low_limit * 0.01)
high_limit += dv
low_limit -= dv
if not scatter_show_local:
if grid_interpolate_local:
data_dict, _, _ = grid_interpolate(
data_dict, self.data_dict['positions']['x_pos'],
self.data_dict['positions']['y_pos'])
im = grid[i].imshow(data_dict,
cmap=grey_use,
interpolation=plot_interp,
extent=(xd_min, xd_max, yd_max,
yd_min),
origin='upper',
clim=(low_limit, high_limit))
grid[i].set_ylim(yd_axis_max, yd_axis_min)
else:
xx = self.data_dict['positions']['x_pos']
yy = self.data_dict['positions']['y_pos']
# The following condition prevents crash if different file is loaded while
# the scatter plot is open (PyXRF specific issue)
if data_dict.shape == xx.shape and data_dict.shape == yy.shape:
im = grid[i].scatter(
xx,
yy,
c=data_dict,
marker='s',
s=500,
alpha=1.0, # Originally: alpha=0.8
cmap=grey_use,
vmin=low_limit,
vmax=high_limit,
linewidths=1,
linewidth=0)
grid[i].set_ylim(yd_axis_max, yd_axis_min)
grid[i].set_xlim(xd_axis_min, xd_axis_max)
grid_title = k
if quant_norm_applied:
grid_title += " - Q" # Mark the plots that represent quantitative information
grid[i].text(0,
1.01,
grid_title,
ha='left',
va='bottom',
transform=grid[i].axes.transAxes)
grid.cbar_axes[i].colorbar(im)
im.colorbar.formatter = im.colorbar.cbar_axis.get_major_formatter(
)
# im.colorbar.ax.get_xaxis().set_ticks([])
# im.colorbar.ax.get_xaxis().set_ticks([], minor=True)
grid.cbar_axes[i].ticklabel_format(style='sci',
scilimits=(-3, 4),
axis='both')
# Do not remove this code, may be useful in the future (Dmitri G.) !!!
# Print label for colorbar
# cax = grid.cbar_axes[i]
# axis = cax.axis[cax.orientation]
# axis.label.set_text("$[a.u.]$")
else:
maxz = np.max(data_dict)
# Set some reasonable minimum range for the colorbar
# Zeros or negative numbers will be shown in white
if maxz <= 1e-30:
maxz = 1
if not scatter_show_local:
if grid_interpolate_local:
data_dict, _, _ = grid_interpolate(
data_dict, self.data_dict['positions']['x_pos'],
self.data_dict['positions']['y_pos'])
im = grid[i].imshow(data_dict,
norm=LogNorm(vmin=low_lim * maxz,
vmax=maxz,
clip=True),
cmap=grey_use,
interpolation=plot_interp,
extent=(xd_min, xd_max, yd_max,
yd_min),
origin='upper',
clim=(low_lim * maxz, maxz))
grid[i].set_ylim(yd_axis_max, yd_axis_min)
else:
im = grid[i].scatter(
self.data_dict['positions']['x_pos'],
self.data_dict['positions']['y_pos'],
norm=LogNorm(vmin=low_lim * maxz, vmax=maxz,
clip=True),
c=data_dict,
marker='s',
s=500,
alpha=1.0, # Originally: alpha=0.8
cmap=grey_use,
linewidths=1,
linewidth=0)
grid[i].set_ylim(yd_axis_min, yd_axis_max)
grid[i].set_xlim(xd_axis_min, xd_axis_max)
grid_title = k
if quant_norm_applied:
grid_title += " - Q" # Mark the plots that represent quantitative information
grid[i].text(0,
1.01,
grid_title,
ha='left',
va='bottom',
transform=grid[i].axes.transAxes)
grid.cbar_axes[i].colorbar(im)
im.colorbar.formatter = im.colorbar.cbar_axis.get_major_formatter(
)
im.colorbar.ax.get_xaxis().set_ticks([])
im.colorbar.ax.get_xaxis().set_ticks([], minor=True)
im.colorbar.cbar_axis.set_minor_formatter(
mticker.LogFormatter())
grid[i].get_xaxis().set_major_locator(
mticker.MaxNLocator(nbins="auto"))
grid[i].get_yaxis().set_major_locator(
mticker.MaxNLocator(nbins="auto"))
grid[i].get_xaxis().get_major_formatter().set_useOffset(False)
grid[i].get_yaxis().get_major_formatter().set_useOffset(False)
self.fig.suptitle(self.img_title, fontsize=20)
self.fig.canvas.draw_idle()
def plot_energy_landscape(x,
y,
values,
log_legend=False,
title=None,
dir_path=None,
legend_title=None,
legend_min=0,
legend_max=None):
# Clearing the canvas, so we always draw on the empty canvas. Just in case.
plt.clf()
x, y = preprocess(x, y)
fig, ax = plt.subplots()
XX, YY = np.meshgrid(x, y)
z = values.reshape(len(x) - 1, len(y) - 1).T
# ax.grid(True, which='minor', axis='both', linestyle='-', color='k')
# ax.set_xticks(x, minor=True)
# ax.set_yticks(y, minor=True)
## This is for having ticks in the plot as multiples of pi
ax.xaxis.set_major_formatter(
tck.FuncFormatter(lambda val, pos: '{:.2f}$\pi$'.format(val / np.pi)
if val != 0 else '0'))
ax.xaxis.set_major_locator(tck.MultipleLocator(base=np.pi / 4))
ax.yaxis.set_major_formatter(
tck.FuncFormatter(lambda val, pos: '{:.2f}$\pi$'.format(val / np.pi)
if val != 0 else '0'))
ax.yaxis.set_major_locator(tck.MultipleLocator(base=np.pi / 4))
if log_legend:
mesh_plot = ax.pcolormesh(XX,
YY,
z,
cmap='RdBu',
vmax=legend_max,
norm=LogNorm())
else:
mesh_plot = ax.pcolormesh(XX,
YY,
z,
cmap='RdBu',
vmin=legend_min,
vmax=legend_max)
ax.set_xlabel("beta")
ax.set_ylabel("gamma")
if title is None:
title = "QAOA energy landscape"
ax.set_title(title)
# set the limits of the plot to the limits of the data
ax.axis([x.min(), x.max(), y.min(), y.max()])
if log_legend:
cbar_formatter = tck.LogFormatter(10, labelOnlyBase=False)
cbar = fig.colorbar(mesh_plot, ax=ax, format=cbar_formatter)
else:
cbar = fig.colorbar(mesh_plot, ax=ax)
if legend_title is None:
legend_title = "energy"
cbar.set_label(legend_title)
file_path = title
if dir_path != None:
file_path = os.path.join(dir_path, file_path)
plt.savefig(file_path)
plt.close()
return ax
def gt_profile(x,
y,
g1,
g2,
sig_g,
xc,
yc,
zl=None,
minr=0.1,
maxr=20,
nbinr=10,
cosmo=None,
a=0.365,
marker='o',
correctResponsivity=False,
**kwargs):
""" gt_profile(x,y,g1,g1,gw, xc, yc, zl, minr, maxr, nbinr=10, cosmo=None, a=0.365)
plot tangential shear profile
"""
gt, gx, r = gT(x, y, g1, g2, xc, yc)
unit = str(minr.unit)
if ('pc' in "{0.unit:FITS}".format(minr)):
r = ((r.to(u.arcmin)) * cosmo.kpc_comoving_per_arcmin(zl)).to(
getattr(u, unit))
#d_co = cd.comoving_distance(zl, **cosmo)
#r = ( r.to(u.rad) * d_co*u.Mpc/u.rad ).to(getattr(u,unit))
else:
r = r.to(getattr(u, unit))
wg = 1 / (sig_g**2 + a**2)
#sig_g = sig_g/np.sqrt(2) # for each component??
if correctResponsivity: ## for regauss
R = 1. - a**2
else: ## no need for KSB
R = 1 #??
# binning over radial axis
gtw, gterr, gterr2, x1, xmin, xmax, Nbin, STD, wbin = usel.Wbinning(
r,
gt,
sig_g,
wg,
minr=minr / minr.unit,
maxr=maxr / minr.unit,
nbinr=nbinr)
gxw, gxerr, gxerr2, _, _, _, _, _, _ = usel.Wbinning(r,
gx,
sig_g,
wg,
minr=minr / minr.unit,
maxr=maxr / minr.unit,
nbinr=nbinr)
xerr = (xmax - xmin) / 2
gtw, gterr, gterr2, gxw, gxerr, gxerr2 = gtw / (2 * R), gterr / (
2 * R), gterr2 / (2 * R), gxw / (2 * R), gxerr / (2 * R), gxerr2 / (
2 * R) # correct for resopnsivity
# plot gt,gx
plt.subplots_adjust(hspace=0.001)
top_ax = plt.subplot(211)
top_ax.set_yticks([0], minor=True)
top_ax.yaxis.grid(True, which='minor', ls='--')
top_ax.errorbar(x1,
gtw,
yerr=gterr2,
xerr=xerr,
marker=marker,
ls='None',
**kwargs)
plt.xscale('log')
plt.ylabel(r'$g_+$')
bottom_ax = plt.subplot(212, sharex=top_ax)
bottom_ax.errorbar(x1,
gxw,
yerr=gxerr2,
xerr=xerr,
marker=marker,
ls='None',
**kwargs)
bottom_ax.set_yticks([0], minor=True)
bottom_ax.yaxis.grid(True, which='minor', ls='--')
plt.ylabel(r'$g_\times$')
plt.setp(top_ax.get_xticklabels(), visible=False)
plt.xlabel('R [{0}]'.format(unit))
bottom_ax.xaxis.set_major_formatter(ticker.LogFormatter())
nbins = len(top_ax.get_yticklabels()) # added
bottom_ax.yaxis.set_major_locator(
ticker.MaxNLocator(nbins=nbins, prune='upper')) # adde
plt.xlim([x1[0] - np.diff(x1)[0], x1[-1] + np.diff(x1)[-1]])
return t.Table([x1, xerr, gtw, gterr, gterr2, gxw, gxerr, gxerr2],
names=('R [{0}]'.format(unit), 'dR [{0}]'.format(unit),
'gt', 'gterr (KSB+)', 'gterr (regauss)', 'gx',
'gxerr (KSB+)', 'gxerr (regauss)'))
def comp_props(dolines,
dotypes=['med_8u'],
clouds=None,
markers=None,
indir=None,
leaves=False,
cmap_name='gist_rainbow',
mec='gray',
xplot=['rad_pc'],
yplot=['vrms_k'],
xlims=[[-1, 1.5]],
ylims=[[-2, 1.5]],
pltname=['rdv'],
slope=[0.5],
pad=[0.03]):
global axes
params = {'mathtext.default': 'regular'}
plt.rcParams.update(params)
cmap = plt.get_cmap(cmap_name)
# Table of cloud-averaged properties
cldtab = Table(names=('cld', 'med_8u', 'med_co', 'avg_st', 'med_24'),
dtype=('S6', 'f4', 'f4', 'f4', 'f4'))
cldtab.add_row(('30Dor', 36.8732, 2.0518, 0.8101, 386.8365))
cldtab.add_row(('N59C', 8.1936, 3.0875, 0.3671, 12.8014))
cldtab.add_row(('A439', 2.6004, 3.2009, 0.6587, 1.2010))
cldtab.add_row(('GMC104', 1.5529, 4.4368, 1.7162, 0.6574))
cldtab.add_row(('GMC1', 1.1792, 2.0274, 0.3059, 0.5231))
cldtab.add_row(('PCC', 0.7974, 1.4606, 0.5502, 0.1617))
# Convert stellar surf density to Msol/pc^2
cldtab['avg_st'] = cldtab['avg_st'] * 62.5
# Generate plots
for i in range(len(xplot)):
for line in dolines:
for type in dotypes:
fig, axes = plt.subplots()
for j, reg in enumerate(clouds):
dir = indir.replace('CLOUD', reg)
if os.path.isfile(dir + reg + '_' + line +
'_physprop_add.txt'):
infile = dir + reg + '_' + line + '_physprop_add.txt'
else:
infile = dir + reg + '_' + line + '_physprop.txt'
if type in ['8um_avg', 'siglum']:
if type == 'siglum' and line == '12':
norm = LogNorm(vmin=10, vmax=1000)
else:
norm = LogNorm(vmin=1, vmax=100)
plot_ecsv(infile,
xplot[i],
yplot[i],
zaxis=type,
cmap=cmap,
mark=markers[j],
mec=mec,
msize=8,
zorder=i,
label=reg,
leaves=leaves,
norm=norm)
else:
if type == 'med_co':
norm = Normalize(vmin=min(cldtab[type]),
vmax=max(cldtab[type]))
else:
norm = LogNorm(vmin=min(cldtab[type]),
vmax=max(cldtab[type]))
colr = np.array(cmap(norm(cldtab[type][j])))
plot_ecsv(infile,
xplot[i],
yplot[i],
col=colr,
mark=markers[j],
mec=mec,
msize=8,
zorder=i,
label=reg,
leaves=leaves)
axes.set_xlim(10**xlims[i][0], 10**xlims[i][1])
axes.set_ylim(10**ylims[i][0], 10**ylims[i][1])
logfmt = ticker.LogFormatterExponent(base=10.0,
labelOnlyBase=True)
axes.xaxis.set_major_formatter(logfmt)
axes.yaxis.set_major_formatter(logfmt)
axes.minorticks_off()
# Reference slopes
xmod = np.logspace(xlims[i][0], xlims[i][1], 100)
ymod = xmod**slope[i]
if xplot[i] == 'rad_pc' and yplot[i] == 'vrms_k':
ymod = ymod * 0.72
axes.plot(xmod,
ymod,
linestyle='-',
color='r',
lw=4,
alpha=0.5,
zorder=-1)
axes.text(10**(xlims[i][1] - 0.05),
10**(ylims[i][1] - 0.8),
'S87',
horizontalalignment='right',
color='r',
rotation=30)
else:
# Plot nominal R(12/13) of 8
if xplot[i] == 'flux12' and yplot[i] == 'flux13':
ymod = ymod / 8
# Plot nominal Sigma_mol of 100 Msol/pc^2
if xplot[i].startswith('area') and yplot[i].startswith(
'm'):
ymod = ymod * 100
axes.plot(xmod, ymod, '--', marker=None, color='k')
# Lines of constant external pressure
if xplot[i].startswith('sig') and yplot[i] == 'sigvir':
ymod = xmod + (20 / (3 * np.pi * 21.1)) * 1.e4 / xmod
axes.plot(xmod, ymod, linestyle='-', color='g', lw=1)
axes.text(10**-0.97,
10**3.5,
'$P_{ext}$ = $10^4$ cm$^{-3}$ K',
color='g',
rotation=-45)
ymod2 = xmod + (20 / (3 * np.pi * 21.1)) * 1.e2 / xmod
axes.plot(xmod, ymod2, linestyle='-', color='m', lw=1)
axes.text(10**-0.97,
10**2.1,
'$P_{ext}$ = $10^2$ cm$^{-3}$ K',
color='m',
rotation=-45)
axes.text(10**-0.95,
10**-0.25,
'Virial Eq',
color='k',
rotation=45)
# Legend and colorbar
plt.legend(loc='lower right',
fontsize='small',
numpoints=1,
markerscale=2)
cax = fig.add_axes([pad[i] + 0.7, 0.11, 0.02, 0.77])
formatter = ticker.LogFormatter(10,
labelOnlyBase=False,
minor_thresholds=(4, 3))
if type == 'med_co':
cbar = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
else:
cbar = mpl.colorbar.ColorbarBase(
cax,
cmap=cmap,
norm=norm,
format=formatter,
ticks=[1, 2, 5, 10, 20, 50, 100, 200, 500, 1000])
cbar.ax.tick_params(labelsize=9)
if type == 'med_8u':
cbar.set_label('cloud median 8$\mu$m intensity [MJy/sr]',
rotation=90)
elif type == 'med_co':
cbar.set_label('cloud median CO intensity [K km/s]',
rotation=90)
elif type == 'avg_st':
cbar.set_label(
'cloud mean $\Sigma_{*}$ [$M_\odot$ $pc^{-2}$]',
rotation=90)
elif type == 'med_24':
cbar.set_label('cloud mean 24$\mu$m intensity [MJy/sr]',
rotation=90)
elif type == '8um_avg':
cbar.set_label('local mean 8$\mu$m intensity [MJy/sr]',
rotation=90)
elif type == 'siglum':
cbar.set_label(
'local mean $\Sigma_{mol}$ [$M_\odot$ $pc^{-2}$]',
rotation=90)
plt.savefig('comp_' + line + '_' + pltname[i] + '_' + type +
'.pdf',
bbox_inches='tight')
plt.close()
return
def main():
parser = argparse.ArgumentParser(description='plotter')
parser.add_argument('--fig_length',
type=int,
default=6,
help='matplotlib figure length (default: 6)')
parser.add_argument('--fig_width',
type=int,
default=6,
help='matplotlib figure width (default: 6)')
parser.add_argument('--style',
default='seaborn',
help='matplotlib figure style (default: seaborn)')
parser.add_argument('--title',
default=None,
help='matplotlib figure title (default: None)')
parser.add_argument('--xlabel',
default=None,
help='matplotlib figure xlabel')
parser.add_argument('--xkey',
default='l',
help='x-axis key in csv file (default: l)')
parser.add_argument('--ykey',
default='r',
help='y-axis key in csv file (default: r)')
parser.add_argument('--ylabel',
default=None,
help='matplotlib figure ylabel')
parser.add_argument('--smooth',
type=int,
default=10,
help='smooth radius of y axis (default: 10)')
parser.add_argument(
'--resample',
type=int,
default=512,
help=
'if not zero, size of the uniform grid in x direction to resample onto. Resampling is performed via symmetric EMA smoothing (see the docstring for symmetric_ema). Default is zero (no resampling). Note that if average_group is True, resampling is necessary; in that case, default value is 512. (default: 512)'
)
parser.add_argument(
'--smooth_step',
type=float,
default=1.0,
help=
'when resampling (i.e. when resample > 0 or average_group is True), use this EMA decay parameter (in units of the new grid step). See docstrings for decay_steps in symmetric_ema or one_sided_ema functions.'
)
parser.add_argument(
'--avg_group',
action='store_true',
help='average the curves in the same group and plot the mean.')
parser.add_argument(
'--shaded_std',
action='store_true',
help='shaded region corresponding to standard deviation of the group')
parser.add_argument(
'--shaded_err',
action='store_true',
help='shaded region corresponding to error in mean estimate')
parser.add_argument('--legend_loc',
type=int,
default=0,
help='location of legend')
parser.add_argument('--legend_outside',
action='store_true',
help='place the legend outside of the figure')
parser.add_argument('--no_legend_group_num',
action='store_true',
help="don't show num of group in legend")
parser.add_argument(
'--time',
action='store_true',
help=
'enable this will set x_key to t, and activate parameters about time')
parser.add_argument(
'--time_unit',
default='h',
help='parameters about time, x axis time unit (default: h)')
parser.add_argument(
'--time_interval',
type=float,
default=1,
help='parameters about time, x axis time interval (default: 1)')
parser.add_argument('--xformat', default='eng', help='x-axis format')
parser.add_argument('--xlim',
type=int,
default=None,
help='x-axis limitation (default: None)')
parser.add_argument('--log_dir',
default='./',
help='log dir (default: ./)')
parser.add_argument('--filename', default='monitor', help='csv filename')
parser.add_argument('--show', action='store_true', help='show figure')
parser.add_argument('--save', action='store_true', help='save figure')
parser.add_argument('--dpi',
type=int,
default=400,
help='figure dpi (default: 400)')
args = parser.parse_args()
xscale = 1
if args.time:
if args.xlabel is None:
args.xlabel = 'Training time'
args.xkey = 't'
if args.time_unit == 'h':
xscale = 60 * 60
args.time_interval = 2
elif args.time_unit == 'min':
xscale = 60
args.time_interval = 20
else:
if args.xlabel is None:
args.xlabel = 'Timesteps'
if args.ylabel is None:
args.ylabel = 'Episode Reward'
if args.filename == 'evaluator':
args.xkey = 'total_steps'
args.ykey = 'mean_score'
allresults = pu.load_results(args.log_dir, filename=args.filename)
pu.plot_results(allresults,
fig_length=args.fig_length,
fig_width=args.fig_width,
style=args.style,
title=args.title,
xlabel=args.xlabel,
ylabel=args.ylabel,
xkey=args.xkey,
ykey=args.ykey,
xscale=xscale,
smooth_radius=args.smooth,
resample=args.resample,
smooth_step=args.smooth_step,
average_group=args.avg_group,
shaded_std=args.shaded_std,
shaded_err=args.shaded_err,
legend_outside=args.legend_outside,
legend_loc=args.legend_loc,
legend_group_num=not args.no_legend_group_num,
filename=args.filename)
ax = plt.gca() # get current axis
if args.time:
if args.time_unit == 'h' or args.time_unit == 'min':
ax.xaxis.set_major_locator(
mticker.MultipleLocator(args.time_interval))
ax.xaxis.set_major_formatter(
mticker.FormatStrFormatter("%d" + args.time_unit))
else:
if args.xformat == 'eng':
ax.xaxis.set_major_formatter(mticker.EngFormatter())
elif args.xformat == 'log':
ax.xaxis.set_major_formatter(mticker.LogFormatter())
elif args.xformat == 'sci':
ax.xaxis.set_major_formatter(mticker.LogFormatterSciNotation())
if args.xlim is not None:
plt.xlim((0, args.xlim))
if args.save:
plt.savefig(args.log_dir + 'figure', dpi=args.dpi, bbox_inches='tight')
if args.show:
plt.show()
"vmax": Zxx_max,
"shading": 'gouraud'
}],
"options": ["grid"],
"plot_type": "pcolormesh",
"xlabel": "Time (s)",
"ylabel": "Frequency (Hz)",
"ylim": ylim,
"yscale": "log",
"tickers": {
"yaxis": {
"major": {
"locator":
ticker.AutoLocator(),
"formatter":
ticker.LogFormatter(labelOnlyBase=False,
minor_thresholds=(np.inf, np.inf))
}
}
},
"fit_data": False
}
signal_fig = FigData(
xs=nst.samp_nums,
ys=nst.data,
title=f"'Contaminated' {scale_name} minor chord (Pure sine waves)\n"
f"Sampling Rate = {samp_rate}Hz",
plot_type="plot",
xlabel="Time (s)",
ylabel="Amplitude")
