def actin_intensity_and_density_histogram(self):
bins = np.logspace(2**-1, np.log2(self.dmax["ring_dens_ratio"].max()),
1000)
logform = ticker.LogFormatterMathtext(base=2)
ticks = ticker.LogLocator(base=2, ).tick_values(
2**-1, np.log2(self.dmax["ring_dens_ratio"].max()))
labels = [logform(i) for i in ticks]
g = sns.FacetGrid(self.dmax, hue="Compound", legend_out=True)
g = (g.map_dataframe(_distplot, "ring_dens_ratio",
bins=bins).set(xscale='log').set(
xticks=ticks,
xticklabels=labels,
xlim=(min(ticks), max(ticks))).add_legend())
path = o.ensure_dir(
os.path.join(self.cc.base_path, 'out', 'graphs',
'actinring_dens_hist_all.pdf'))
g.savefig(path)
plt.close()
g = sns.FacetGrid(self.dmax,
row="Compound",
hue="Compound",
legend_out=True)
g = (g.map_dataframe(_distplot, "ring_dens_ratio",
bins=bins).set(xscale='log').set(
xticks=ticks,
xticklabels=labels,
xlim=(min(ticks), max(ticks))).add_legend())
path = o.ensure_dir(
os.path.join(self.cc.base_path, 'out', 'graphs',
'actinring_dens_hist_each.pdf'))
g.savefig(path)
plt.close()
def plot_dos(aedges, Rpedges, DoS, name, path=None):
"""Plots depth of search as a filled contour plot with contour lines
Args:
aedges (ndarray):
1-D array of semi-major axis bin edges
Rpedges (ndarray):
1-D array of planetary radius bin edges
DoS (ndarray):
2-D array of depth-of-search values
name (str):
string indicating what to put in title of figure
path (str):
desired path to save figure (png, optional)
"""
acents = 0.5 * (aedges[1:] + aedges[:-1])
a = np.hstack((aedges[0], acents, aedges[-1]))
a = np.around(a, 4)
Rcents = 0.5 * (Rpedges[1:] + Rpedges[:-1])
R = np.hstack((Rpedges[0], Rcents, Rpedges[-1]))
R = np.around(R, 4)
# extrapolate to left-most boundary
tmp = DoS[:, 0] + (a[0] - a[1]) * ((DoS[:, 1] - DoS[:, 0]) / (a[2] - a[1]))
DoS = np.insert(DoS, 0, tmp, axis=1)
# extrapolate to right-most boundary
tmp = DoS[:, -1] + (a[-1] - a[-2]) * ((DoS[:, -1] - DoS[:, -2]) /
(a[-2] - a[-3]))
DoS = np.insert(DoS, -1, tmp, axis=1)
# extrapolate to bottom-most boundary
tmp = DoS[0, :] + (R[0] - R[1]) * ((DoS[1, :] - DoS[0, :]) / (R[2] - R[1]))
DoS = np.insert(DoS, 0, tmp, axis=0)
# extrapolate to upper-most boundary
tmp = DoS[-1, :] + (R[-1] - R[-2]) * ((DoS[-1, :] - DoS[-2, :]) /
(R[-2] - R[-3]))
DoS = np.insert(DoS, -1, tmp, axis=0)
DoS = np.ma.masked_where(DoS <= 0.0, DoS)
fig = plt.figure()
ax = fig.add_subplot(111)
cs = ax.contourf(a,
R,
DoS,
locator=ticker.LogLocator(),
levels=[1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1e0])
cs2 = ax.contour(a, R, DoS, colors='k', levels=cs.levels)
ax.set_xscale('log')
ax.set_yscale('log')
ax.set_xlabel('a (AU)')
ax.set_ylabel('$R_p$ ($R_\oplus$)')
ax.set_title('Depth of Search - ' + name)
cbar = fig.colorbar(cs)
ax.clabel(cs2, fmt=ticker.LogFormatterMathtext(), colors='k')
if path is not None:
fig.savefig(path,
format='png',
dpi=100,
bbox_inches='tight',
pad_inches=0.1)
plt.close(fig)
def plot_nplan(self, targ, name, path=None):
'''Plots depth of search convolved with occurrence rates as a filled
contour plot with contour lines
Args:
targ (str):
string indicating which key to access from depth of search
result dictionary
name (str):
string indicating what to put in title of figure
path (str):
desired path to save figure (pdf, optional)
'''
acents = 0.5 * (self.result['aedges'][1:] + self.result['aedges'][:-1])
a = np.hstack(
(self.result['aedges'][0], acents, self.result['aedges'][-1]))
a = np.around(a, 4)
Rcents = 0.5 * (self.result['Redges'][1:] + self.result['Redges'][:-1])
R = np.hstack(
(self.result['Redges'][0], Rcents, self.result['Redges'][-1]))
R = np.around(R, 4)
DoS_occ = self.result['DoS_occ'][targ]
# extrapolate to left-most boundary
tmp = DoS_occ[:, 0] + (a[0] - a[1]) * (
(DoS_occ[:, 1] - DoS_occ[:, 0]) / (a[2] - a[1]))
DoS_occ = np.insert(DoS_occ, 0, tmp, axis=1)
# extrapolate to right-most boundary
tmp = DoS_occ[:, -1] + (a[-1] - a[-2]) * (
(DoS_occ[:, -1] - DoS_occ[:, -2]) / (a[-2] - a[-3]))
DoS_occ = np.insert(DoS_occ, -1, tmp, axis=1)
# extrapolate to bottom-most boundary
tmp = DoS_occ[0, :] + (R[0] - R[1]) * (
(DoS_occ[1, :] - DoS_occ[0, :]) / (R[2] - R[1]))
DoS_occ = np.insert(DoS_occ, 0, tmp, axis=0)
# extrapolate to upper-most boundary
tmp = DoS_occ[-1, :] + (R[-1] - R[-2]) * (
(DoS_occ[-1, :] - DoS_occ[-2, :]) / (R[-2] - R[-3]))
DoS_occ = np.insert(DoS_occ, -1, tmp, axis=0)
DoS_occ = np.ma.masked_where(DoS_occ <= 0.0, DoS_occ)
fig = plt.figure()
ax = fig.add_subplot(111)
cs = ax.contourf(a, R, DoS_occ, locator=ticker.LogLocator())
cs2 = ax.contour(a, R, DoS_occ, levels=cs.levels[1:], colors='k')
ax.set_xscale('log')
ax.set_yscale('log')
ax.set_xlabel('a (AU)')
ax.set_ylabel('R ($R_\oplus$)')
ax.set_title('Number of Planets - ' + name + ' (' +
str(self.result['NumObs'][targ]) + ')')
cbar = fig.colorbar(cs)
ax.clabel(cs2, fmt=ticker.LogFormatterMathtext(), colors='k')
if path != None:
fig.savefig(path,
format='pdf',
dpi=600,
bbox_inches='tight',
pad_inches=0.1)
plt.show()
def plot(nmin=-2, nmax=1, tmin=0, tmax=2, num=301, B=5.4, npar=1.8):
Taxis = scipy.logspace(tmin, tmax, num) * 1e-3
naxis = scipy.logspace(nmin, nmax, num) * 1e20
n, T = scipy.meshgrid(naxis, Taxis)
om = scipy.pi * 2 * 4.6e9
#wpe = n*pow(ec,2)/(e0*mes)
print(nu(n, T))
Ains = As(n, T, B, om, npar)
Bins = Bs(n, T, B, om, npar)
Cins = Cs(n, T, B, om, npar)
Q = (-Bins + scipy.sqrt(pow(Bins, 2) - 4 * Ains * Cins)) / 2 / Ains
output = scipy.sqrt(
scipy.sqrt(pow(scipy.real(Q), 2) + pow(scipy.imag(Q), 2)) -
scipy.real(Q)) / pow(2, .5)
CS = plt.contour(naxis,
Taxis * 1e3,
om * output / 299792458.,
locator=ticker.LogLocator(),
linewidths=2.,
colors=colors['b']) #om*output/299792458.
plt.clabel(CS, inline=1, fontsize=16, fmt=ticker.LogFormatterMathtext()) #
#CS2 = plt.contour(naxis,Taxis*1e3,pow(2,-1)*abs(scipy.imag(Q)/abs(scipy.sqrt(scipy.real(Q))))*om/299792458.,locator=ticker.LogLocator(),linewidths=2.,colors=colors['g'])#om*output/299792458.
#plt.clabel(CS2, inline=1, fontsize=16,fmt=ticker.LogFormatterMathtext())#
wpe = n * pow(ec, 2) / (e0 * mes)
wce = ec * B / mes
wci = ec * B / mi
output2 = nu(n, T) * pow(wpe, .5) / (2 * pow(om, 2)) * scipy.sqrt(
abs((npar**2 - 1) / (1 - wpe / (pow(wce, 2) * (npar**2 - 1)))))
#CS3 = plt.contour(naxis,Taxis*1e3,output2*om/299792458.,locator=ticker.LogLocator(),linewidths=2.,colors=colors['r'])#om*output/299792458.
output3 = nu(n, T) * pow(wpe, .5) / (2 * pow(om, 2)) * npar
# CS2 = plt.contour(naxis,Taxis*1e3,output3*om/299792458.,locator=ticker.LogLocator(),linewidths=2.,colors=colors['g'])#om*output/299792458.
#plt.clabel(CS2, inline=1, fontsize=16,fmt=ticker.LogFormatterMathtext())#
#plt.clabel(CS3, inline=1, fontsize=16,fmt=ticker.LogFormatterMathtext())#
A2 = pow(ec, 2) / (e0 * mi) / pow(om, 2)
B2 = -2 * pow(e0 * mes, -.5) * ec / wce * npar
C2 = npar**2 - 1
temp = pow((-B2 - pow(B2**2 - 4 * A2 * C2, .5)) / (2 * A2), 2)
plt.fill_between(naxis,
Taxis[0] * 1e3,
Taxis[-1] * 1e3,
naxis > temp,
color='k',
alpha=.3,
linewidth=2.)
plt.gca().set_yscale("log")
plt.gca().set_xscale("log")
plt.ylabel(r'Electron Temperature [eV]')
plt.xlabel(r'$n_e$ [m$^{-3}$]')
plt.show()
def GetMagneticFieldArea(self, X, Y, z, I, ax=None):
B = np.zeros((len(X), len(Y)))
for i, x in enumerate(X):
for j, y in enumerate(Y):
B[i, j] = self.GetMagneticField(
I,
[x, y, z],
)
if ax != None:
YY, XX = np.meshgrid(Y, X)
linthres = 10**(-15) #abs(B).mean()
vmax = 10**(-8) #abs(B).max()
norm = colors.SymLogNorm(linthresh=linthres, vmin=-vmax, vmax=vmax)
im = ax[1].pcolormesh(XX, YY, B, cmap='RdBu_r', norm=norm)
ax[1].scatter(self.Mol.Atom[:, 1], self.Mol.Atom[:, 2], color='k')
tick_locations = ([-(10**x) for x in range(-15, 8, 1)][::-1] +
[0.0] + [(10**x) for x in range(-15, 8, 1)])
cb = ax[0].colorbar(im,
ax=ax[1],
extend='both',
label='$Magnetic field$',
ticks=tick_locations,
format=ticker.LogFormatterMathtext())
# cb.colorbar(ticks=tick_locations, format=ticker.LogFormatterMathtext())
return B
def pcolormesh_symlog(ax,
X,
Y,
Z,
vmax=None,
vmin=None,
linthresh=None,
decades=4,
linscale=0.01,
cmap='RdBu_r',
cbar=True,
**kwargs):
"""Wrapper for matplotlib's pcolormesh that uses it sensibly, instead of the defaults.
If linthresh is not specified, it defaults to vmax*10**(-decades), i.e. showing that number of decades each
of positive and negative values.
If not specified, vmax is set automatically
In order to keep colors sensible, vmin is overridden unless set alone.
"""
if vmax is None:
if vmin is not None:
vmax = -vmin
else:
vmax = np.abs(np.nanmax(Z)) * 2
vmin = -vmax
#print("Using automatic range {} to {}".format(vmin, vmax))
else:
vmin = -vmax
int_min_pow, int_max_pow = int(np.ceil(np.log10(-vmin))), int(
np.ceil(np.log10(vmax)))
if linthresh is None:
linthresh = vmax * 10**(-decades)
logthresh = -int(np.ceil(np.log10(linthresh)))
tick_locations = (
[vmin] +
[-(10.0**x) for x in range(int_min_pow - 1, -logthresh - 1, -1)] +
[0.0] + [(10.0**x) for x in range(-logthresh, int_max_pow)] + [vmax])
pcm = ax.pcolormesh(X,
Y,
Z,
norm=colors.SymLogNorm(linthresh=linthresh,
linscale=linscale,
base=10),
cmap=cmap,
vmin=-vmax,
vmax=vmax,
**kwargs)
if cbar:
# TODO add some more anonymous ticks
plt.colorbar(pcm,
ax=ax,
ticks=tick_locations,
format=ticker.LogFormatterMathtext())
return pcm
def set_norm(self, value):
self._cb.set_norm(value)
if self.formatter is None:
from matplotlib import colors, ticker
if isinstance(value, colors.LogNorm):
self._cb.formatter = ticker.LogFormatterMathtext()
else:
self._cb.formatter = ticker.ScalarFormatter()
def plot_photonB_vs_gamma(ax, root, step, sigma, gamma_c, emin=1e-2):
fname = root + 'phst.tot.' + str(step).zfill(3)
if not os.path.isfile(fname):
data_gams = np.array([1e1])
data_Bs = np.array([1e-3])
else:
data = h5py.File(fname, 'r')
data_gams = data['gam'].value
data_Bs = data['B'].value
my_cmap = copy.copy(mpl.cm.get_cmap('jet'))
my_cmap.set_bad(my_cmap(0))
my_cmap.set_under(my_cmap(0))
b_ax = np.linspace(-3,1,100)
g_ax = np.linspace(0,4,100)
if len(data_gams) > 10000:
cnt = ax.hist2d(np.log10(data_gams), np.log10(data_Bs), bins=(g_ax, b_ax), norm=mpl.colors.LogNorm(), cmap=my_cmap);
else:
data_gams = np.array([1e1])
data_Bs = np.array([1e-3])
cnt = ax.hist2d(np.log10(data_gams), np.log10(data_Bs), bins=(g_ax, b_ax), norm=mpl.colors.LogNorm(vmin=1, vmax=1e5), cmap=my_cmap);
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="2%", pad=0.05)
cbar = plt.colorbar(cnt[-1], cax = cax)
cbar.set_label(r'\# of photons')
g_ax, b_ax = np.meshgrid(g_ax, b_ax)
epsph = (10**(g_ax) / gamma_c)**2 * 10**(b_ax) * np.sqrt(sigma / 1000.)
levs = np.logspace(np.log10(emin), 3, (3-np.log10(emin)) + 1)
clab = ax.contour(g_ax, b_ax, epsph, levels=levs, norm=mpl.colors.LogNorm(), colors='black');
if len(levs > 5):
clab = ax.contour(g_ax, b_ax, epsph, levels=levs[0::2], norm=mpl.colors.LogNorm(), colors='black');
g_ticks = [0, 1, 2, 3, 4]
ax.set_xticks(g_ticks)
ax.set_xticklabels([r'$10^{{{0}}}$'.format(str(pow)) for pow in g_ticks])
b_ticks = [-3, -2, -1, 0, 1]
ax.set_yticks(b_ticks)
ax.set_yticklabels([r'$10^{{{0}}}$'.format(str(pow)) for pow in b_ticks])
fmt = ticker.LogFormatterMathtext()
fmt.create_dummy_axis()
clabs = ax.clabel(clab, fmt=fmt);
[txt.set_bbox(dict(facecolor='white', edgecolor='black', pad=6)) for txt in clabs]
ax.set_xlabel(r'particle $\gamma$')
ax.set_ylabel(r'$B / B_{\rm up}$');
ax.set_xlim(np.log10(5),np.log10(1e4))
ax.set_ylim(-3,1)
mpl.rcParams['hatch.color'] = (0,0,0,.2)
xs = np.linspace(-1,4,5)
ys = np.log10(emin * (1e3 / sigma)**0.5 * (gamma_c / 10**xs)**2)
ax.fill_between(xs, -5, ys, hatch="//", linewidth=0.0, alpha=1.0, color='white')
ax.fill_between(xs, -5, ys, hatch="//", linewidth=0.0, alpha=0.0)
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,
extendfrac=None,
):
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.extendfrac = extendfrac
self.solids = None
self.lines = list()
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.LogFormatterMathtext()
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 histogram_of_every_row(counts_col, **kwargs):
"""
Plots the histogram of every row in a dataframe, overlaying them.
Meant to be used within a map_dataframe call.
Implementation inspired in https://matplotlib.org/gallery/api/histogram_path.html
:param df: Dataframe
:param counts_col: Name of the counts column
:param edges_col: Name of the edges column
:param ax: Matplotlib axis object
:return:
"""
ax = plt.gca()
edges_col = kwargs.pop(
"edges_col") if "edges_col" in kwargs else "hist_edges"
data = kwargs.pop("data")
color = kwargs.pop("color")
label = kwargs.pop("label") if "label" in kwargs else None
# FIXME: Find a way to increase opacity resolution
min_op = 1. / 256.
opacity = 1. / len(data)
opacity = opacity if opacity >= min_op else min_op
logger.info("plotting %d histograms overlaid with opacity %e." %
(len(data), opacity))
# get the corners of the rectangles for the histogram
bins = data[edges_col].iloc[0]
left = np.array(bins[:-1])
right = np.array(bins[1:])
bottom = np.zeros(len(left))
for _ix, _d in data.iterrows():
counts = _d[counts_col]
top = bottom + counts
# function to build a compound path
XY = np.array([[left, left, right, right], [bottom, top, top,
bottom]]).T
# get the Path object
barpath = Path.make_compound_path_from_polys(XY)
# make a patch out of it
patch = PathPatch(barpath, alpha=opacity, lw=0, color=color)
ax.add_patch(patch)
ax.xaxis.set_major_locator(ticker.LogLocator(base=10))
ax.xaxis.set_major_formatter(ticker.LogFormatterMathtext(base=10))
ax.yaxis.set_major_formatter(EngFormatter(unit=''))
ax.set_xlim(left[0], right[-1])
ax.set_ylim(bottom.min(),
data[counts_col].apply(lambda r: np.max(r)).max())
def CONTOUR_FLUX(ax, Om_Flux, D, L, r_start, r_end):
Q, R = np.meshgrid(L, D) #Curvas de nivel del flujo omnidireccional
cs = plt.contour(Q, R, Om_Flux, locator=ticker.LogLocator(), Polar=True)
# manual_locations = [(0.05*np.pi, 6.5), (0*np.pi, 5.2), (0.05*np.pi,4.8),(0*np.pi, 4.2), (0.05*np.pi, 3.5), (-0.05*np.pi+np.pi, 6.5), (0*np.pi+np.pi, 5.2), (-0.05*np.pi+np.pi,4.8), (0*np.pi+np.pi, 4.2), (-0.05*np.pi+np.pi, 3.5)]
# manual_locations = [(0.05*np.pi, 3.5), (0*np.pi, 3.3), (-0.05*np.pi,3.1),(0.01*np.pi, 2.8), (0.05*np.pi, 2.1), (-0.05*np.pi+np.pi, 3.5), (0*np.pi+np.pi, 3.3), (0.05*np.pi+np.pi,3.1), (-0.01*np.pi+np.pi, 2.8), (-0.05*np.pi+np.pi, 2.1)]
# manual_locations = [(0*np.pi, 2.8), (0.04*np.pi, 2.5), (0*np.pi,2.1),(0.04*np.pi, 1.6), (0*np.pi+np.pi, 2.8), (-0.04*np.pi+np.pi, 2.5), (0*np.pi+np.pi,2.1), (-0.04*np.pi+np.pi, 1.6)]
fmt = ticker.LogFormatterMathtext()
labels = plt.clabel(cs, inline=1, fmt=fmt)
# manual=manual_locations
for l in labels:
l.set_rotation(0)
def init():
"""initialize the TkAgg backend for gui
and matplotlib figure with their axes (subplots) and visual settings.
"""
use('TkAgg') # matplotlib: set backend
style.use('seaborn-whitegrid')
XLIM_FFT = (1, FREQUENCY)
YLIM_FFT = (0, REFRESH_TIME*FREQUENCY/2 + REFRESH_TIME*FREQUENCY/30)
XLIM_SAMPLE = (0, FREQUENCY*REFRESH_TIME)
YLIM_SAMPLE = (0, 3.3) # 3.3V is signal max voltage
global fig, sample_lines, fft_lines
fig.subplots_adjust(bottom=0.15, top=0.92, hspace=.7)
sample_graph = fig.add_subplot(2, 1, 1,
# TODO(low)show always REFRESH_TIME as max value
xlabel='samples in {} ms'.format(REFRESH_TIME),
ylabel='voltage',
xlim=XLIM_SAMPLE, ylim=YLIM_SAMPLE)
sample_graph.set_title('time domain', fontsize=13)
fft_graph = fig.add_subplot(2, 1, 2,
xlabel='frequency [Hz]', ylabel='FT magnitude',
xlim=XLIM_FFT, ylim=YLIM_FFT, xscale='log')
fft_graph.set_title('frequency domain', fontsize=13)
fft_graph.xaxis.grid(True, which='major', linewidth=0.7, color='0.5')
fft_graph.xaxis.grid(which='minor', linestyle='-', color='0.5')
fft_graph.yaxis.grid(which='major', color='0.7')
subs = [2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0] # ticks to show per decade
fft_graph.xaxis.set_minor_locator(ticker.LogLocator(subs=subs))
fft_graph.xaxis.set_major_formatter(ticker.LogFormatterMathtext(base=10.0,
labelOnlyBase=False))
sample_lines = sample_graph.plot([], [], 'g,', [], [], 'r.')
fft_lines = fft_graph.plot([], [], 'g,', [], [], 'b-')
# for settings check:
# http://matplotlib.org/api/lines_api.html#matplotlib.lines.Line2D
# TIME: microphone1:
# TODO check which one(if above is right)
# sample_lines[0].set_linestyle('--')
# TIME: microphone2:
sample_lines[1].set_linestyle('-')
sample_lines[1].set_linewidth(1)
sample_lines[1].set_marker('')
# sample_lines[1].set_markersize(0.1)
# FREQ: microphone1:
# FREQ: microphone2:
fft_lines[1].set_linestyle('-')
fft_lines[1].set_linewidth(1)
fft_lines[1].set_marker('.')
fft_lines[1].set_markersize(4)
fft_lines[1].set_dash_capstyle('projecting')
fft_lines[1].set_solid_capstyle('projecting')
def draw_faceted_heatmap(data, indexingdf, xaxis, yaxis, zaxis, lognorm,
cbarticks, logarithmic, symlog, symlognorm, linthresh,
**kwargs):
originalColumnOrder = list(
pd.unique(indexingdf.index.get_level_values(xaxis)))
unsortedPivotedData = data.pivot_table(index=yaxis,
columns=xaxis,
values=zaxis)
indexdf = indexingdf.groupby(level=yaxis, sort=False).first()
data = reindexDataFrame(unsortedPivotedData, indexdf, False)
data = data[originalColumnOrder]
data.columns.name = xaxis
plt.axis('off')
if logarithmic:
g = sns.heatmap(data,
norm=lognorm,
**kwargs,
cbar=True,
cbar_kws={
"ticks": cbarticks,
'label': zaxis
})
elif symlog:
linthresh = int(linthresh)
maxlog = int(np.ceil(np.log10(data.values.max())))
minlog = int(np.ceil(np.log10(-1 * data.values.min())))
#tick_locations=([-(10**x) for x in range(-1*int(linthresh), minlog+1, 1)][::-1]+[0.0]+[(10**x) for x in range(-minlog,maxlog+1, 1)])
tick_locations = ([-(10**x)
for x in range(-linthresh, minlog + 1, 1)][::-1] +
[0.0] + [(10**x)
for x in range(-linthresh, maxlog + 1, 1)])
#generate logarithmic ticks
g = sns.heatmap(data,
norm=symlognorm,
cbar_kws={
'label': zaxis,
'ticks': tick_locations,
'format': ticker.LogFormatterMathtext()
},
**kwargs)
#g = sns.heatmap(data, norm=symlognorm,**kwargs,cbar=True,cbar_kws={'label':zaxis})
else:
g = sns.heatmap(data, **kwargs, cbar=True, cbar_kws={'label': zaxis})
#Add hiearchical level names and borders to heatmap
ax1 = plt.gca()
label_index(ax1, data)
draw_borders(g, data)
label_columns(ax1, data)
label_headers(ax1, data)
def plot(r, z, t, xi, E, r_sim, xi_sim, SHM, track):
fig, ax = plt.subplots()
#Make color axis of electric field
if SHM:
colors = ax.pcolormesh(z, r, E, cmap="YlGnBu")
cbar = fig.colorbar(colors, ax=ax)
cbar.set_label('Electric Field ($m_e c\omega_p/e$)')
ax.set_xlabel("z ($c/\omega_p$)")
ax.set_ylabel("r ($c/\omega_p$)")
ax.plot(xi, r, 'k')
else:
colors = ax.pcolormesh(xi_sim,
r_sim,
E,
norm=col.SymLogNorm(linthresh=0.03,
linscale=0.03,
vmin=-E.max(),
vmax=E.max()),
cmap="RdBu_r")
tick_locations = [x * 0.01 for x in range(2, 10)] + [
x * 0.01 for x in range(-10, -1)
] + [x * 0.1 for x in range(-10, 10)] + [x for x in range(-10, 10)]
cbar = fig.colorbar(colors,
ax=ax,
ticks=tick_locations,
format=ticker.LogFormatterMathtext())
cbar.set_label(
'$E_r$, Transverse Electric Field ($m_e c\omega_p / e$)')
ax.set_xlabel("$\\xi$ ($c/\omega_p$)")
ax.set_ylabel('r ($c/\omega_p$)')
ax.set_title('Electron trajectory from simulation v. OSIRIS for ' +
track + ' track')
ax.plot(xi, r, 'k', label="Simulated")
plt.plot(xi[-1], r[-1], 'ro', label="Simulated ($\\xi_f,r_f$)")
plt.xlim(1.2, 1.5) #xi_sim[0], xi_sim[-1])
plt.ylim(0, 1)
xi_OSIRIS, r_OSIRIS = plotSimTracks.get_xir(track)
ax.plot(xi_OSIRIS, r_OSIRIS, 'c--', label="OSIRIS")
plt.plot(xi_OSIRIS[-1], r_OSIRIS[-1], 'bo', label="OSIRIS ($\\xi_f,r_f$)")
ax.legend()
if SHM:
model = "SHM"
else:
model = "simE"
fn = "plots/" + model + "_" + track + ".png"
plt.savefig(fn, dpi=200, transparent=True)
plt.show()
class TestLogFormatterMathtext:
fmt = mticker.LogFormatterMathtext()
test_data = [
(0, 1, '$\\mathdefault{10^{0}}$'),
(0, 1e-2, '$\\mathdefault{10^{-2}}$'),
(0, 1e2, '$\\mathdefault{10^{2}}$'),
(3, 1, '$\\mathdefault{1}$'),
(3, 1e-2, '$\\mathdefault{0.01}$'),
(3, 1e2, '$\\mathdefault{100}$'),
(3, 1e-3, '$\\mathdefault{10^{-3}}$'),
(3, 1e3, '$\\mathdefault{10^{3}}$'),
]
@pytest.mark.parametrize('min_exponent, value, expected', test_data)
def test_min_exponent(self, min_exponent, value, expected):
with mpl.rc_context({'axes.formatter.min_exponent': min_exponent}):
assert self.fmt(value) == expected
def contour(ax, X, Y, Z, fill=True, contour_levels=10, line_levels=5, line_color='k', **kwargs):
"""
Draw contour lines or filled contours.
:param ax: Which axes to use for the plot.
:param array X, Y: The coordinates of the values in Z. X and Y must both be 2-D with the same shape as Z (e.g. created via :py:func:`numpy.meshgrid`)
:param array Z: 2D data to plot.
:param bool fill: draw contour lines or filled contours
:param contour_levels: if fill is True; contour_levels determines the number of the filled contours.
:param line_levels: if fill is True; line_levels determines the number of the lines.
:param line_color: if fill is True; line_color determines the color of the lines.
:param kwargs: Unknown keyword arguments are passed to :py:func:`ax.contour()` or :py:func:`ax.contourf()`.
:return: image object
>>> im = imshow(ax, X, Y, Z)
Only draw contour lines.
>>> im = contour(ax, x, y, Z, fill=True)
Draw contour lines and filled contours,
>>> im = contour(ax, x, y, Z, fill=True, contour_levels=10, line_levels=5)
Draw contour lines and filled contours, filled levels determined by contour_levels and line number determined by line_levels
>>> im = contour(ax, x, y, Z, fill=True, line_color='r')
line color determined by line_color
>>> im = contour(ax, x, y, Z, fill=True, cmap=plt.cm.bone)
filled color determined by cmap
>>> im = contour(ax, X, Y, Z, fill=True, alpha=0.5)
The alpha blending value, between 0 (transparent) and 1 (opaque).
>>> Zm = np.ma.masked_where(np.abs(Z) < 0.000001, Z)
>>> im = contour(ax, x, y, Zm, fill=False)
control the masked region.
>>> from matplotlib import ticker
>>> im = contour(ax, x, y, Z, locator=ticker.LogLocator(), fill=True)
log locator tells contourf to use a log scale
"""
assert X.shape == Z.shape and Y.shape == Z.shape, "The coordinates of X and Y must have the same shape as Z"
if fill:
line_factor = int(contour_levels)//int(line_levels)
im = ax.contourf(X, Y, Z, levels=contour_levels, **kwargs)
ax.contour(im, levels=im.levels[::line_factor], colors=line_color)
else:
im = ax.contour(X, Y, Z, locator=plt.LogLocator(), **kwargs)
fmt = ticker.LogFormatterMathtext()
ax.clabel(im, im.levels, fmt=fmt)
return im
def plot_funct_with_Theta(a, b, x_size, y_size, theta):
x_ax = np.linspace(-x_size,x_size);
y_ax = np.linspace(-y_size,y_size);
X,Y = np.meshgrid(x_ax,y_ax);
himmelblau_fkt = (X**2 + Y -11)**2 + (X + Y**2 - 7)**2;
fig, ax = plt.subplots();
cs = ax.contour(X,Y,himmelblau_fkt, locator=plt.LogLocator());
fmt = ticker.LogFormatterMathtext();
fmt.create_dummy_axis();
ax.clabel(cs, cs.levels, fmt=fmt);
ax.set_title("Bananafunction Min at [1,1]");
for a in range(theta[0].size - 1): #Plot all thetas inclusive the intermidiate results
if(theta[0][a] != 0 or theta[1][a] != 0): #Only plot calculated values (instance created via np.zeros and probability for (0,0) is near zero...)
plt.plot(theta[0][a],theta[1][a],'ro');
#minima=[1 1];
plt.plot(1,1,'rx');
plt.show();
def plot_data_scalar(plot_ax,
slc,
ax_i,
field,
logscale=None,
override_lims=None,
cbar=True,
diverge_cmap=False,
override_cmap=None):
slc_0, slc_1, field_dat = slc
#diverge_cmap, logscale, zlim = True, False, (-30,30)
#zlim = (-180,180)
#if zlim is None: vmin, vmax = 1e-3, field_lims[field][1] #np.nanmax(field_dat), 1e-3
#else: vmin, vmax = zlim
if field in label_lookup: label = label_lookup[field]
else: label = field
norm, cmap, tick_locations, symlogscale = apply_scalar_lims(
field, field_dat, override_lims=override_lims, logscale=logscale)
if override_cmap is not None: cmap = override_cmap
if field_dat.max() != field_dat.min():
im = plot_ax.pcolormesh(slc_0.T,
slc_1.T,
np.ma.masked_array(field_dat.T),
norm=norm,
cmap=cmap,
rasterized=True)
if cbar:
if symlogscale:
plt.colorbar(im,
ax=plot_ax,
label=label,
ticks=tick_locations,
format=ticker.LogFormatterMathtext())
else:
plt.colorbar(im, ax=plot_ax, label=label)
plot_ax.set_xlim(slc_0.min(), slc_0.max())
plot_ax.set_ylim(slc_1.min(), slc_1.max())
def plot_contour(df, vent=False, ax=None, values="MassArea", title="Isomass Plot", cmap='inferno', log=True, lines=True, line_cmap=None, line_colors=None, background="gradient", cbar_label=None, save=None):
# TODO: Figure out why low phi deposits break both the negative/grayscale linemaps, and the filled contours.
df = df[df[values]>0]
piv = pd.pivot_table(df, index="Northing",
columns="Easting", values=values)
if log:
norm = LogNorm(vmin=piv.values.min(), vmax=piv.values.max())
else:
norm = None
if ax is None:
fig, ax = plt.subplots(1, 1)
else:
fig = plt.gcf()
# ax.axis('equal')
ax.set_ylabel("Northing")
ax.set_xlabel("Easting")
ax.set_title(title)
if background == "gradient":
if log:
vals = np.log10(piv.values)
else:
vals = piv.values
bg = ax.imshow(vals,
extent=[piv.columns.min(), piv.columns.max(),
piv.index.min(), piv.index.max()],
origin='lower',
cmap=cmap, alpha=1)
if log:
cbar = fig.colorbar(bg, ax=ax, format=r"$10^{%d}$")
else:
cbar = fig.colorbar(bg, ax=ax)
cbar.set_alpha(alpha=1)
cbar.draw_all()
if cbar_label is not None:
cbar.ax.set_ylabel(cbar_label, rotation=270)
elif background == "fill":
bg = ax.contourf(piv.columns, piv.index, piv.values,
cmap=cmap, vmin=piv.values.min(), vmax=piv.values.max())
cbar = fig.colorbar(bg, ax=ax)
cbar.set_alpha(alpha=1)
cbar.draw_all()
if cbar_label is not None:
cbar.ax.set_ylabel(cbar_label, rotation=270)
if lines:
if line_cmap == "grayscale":
colormap = cm.get_cmap(cmap, 256)
oldcolors = colormap(np.linspace(0, 1, 256))
newcolors = []
for i, col in enumerate(oldcolors):
r, g, b = [(1-col[j]) for j in range(3)]
luminosity = 0.21*r + 0.72*g + 0.07*b
newcolors.append([luminosity, luminosity, luminosity, 1])
newcmp = ListedColormap(np.array(newcolors))
lns = ax.contour(piv.columns, piv.index, piv.values, norm=norm,
cmap=newcmp)
elif line_cmap == "negative":
colormap = cm.get_cmap(cmap, 256)
oldcolors = colormap(np.linspace(0, 1, 256))
newcolors = [[(1-col[j]) for j in range(3)] + [1] for col in oldcolors]
newcmp = ListedColormap(np.array(newcolors))
lns = ax.contour(piv.columns, piv.index, piv.values, norm=norm,
cmap=newcmp)
elif line_cmap is not None:
lns = ax.contour(piv.columns, piv.index, piv.values, norm=norm,
cmap=line_cmap)
elif line_colors is not None:
lns = ax.contour(piv.columns, piv.index, piv.values, norm=norm,
colors=line_colors)
else:
lns = ax.contour(piv.columns, piv.index, piv.values, norm=norm,
colors='k')
fmt = ticker.LogFormatterMathtext()
fmt.create_dummy_axis()
ax.clabel(lns, lns.levels, fmt=fmt, fontsize=10)
if vent:
ax.plot(vent[0], vent[1], 'r^', ms=8)
ax.set_xlim(right=piv.columns.max(), left=piv.columns.min())
ax.set_ylim(bottom=piv.index.min(), top=piv.index.max())
ax.set_aspect("equal")
return ax
def graph_single_stat(self, means_df, ci_df, axis, **kwargs):
all_means = self._rename_configs(self._reorder_configs(means_df))
all_error = self._rename_configs(
self._reorder_configs(ci_df)) if ci_df is not None else None
all_perct = None
labels = all_means.index.tolist()
if self._kwargs_bool(kwargs, 'error_bars'):
cutoff = self._kwargs_default(kwargs, 'cutoff',
all_means.max().max())
threshold = 0.01 * cutoff
#print(all_error)
all_error_clipped = all_error.clip(lower=threshold)
are_equal = (all_error_clipped == all_error).all().all()
if not are_equal:
print('Setting error bar minimum to +/- {} for visibility'.
format(threshold))
all_error = all_error_clipped
if 'Average' in all_error.index:
all_error.loc['Average'][:] = 0.0
#print(all_error)
elif all_error is not None:
all_error[:] = 0
else:
all_error = all_means.copy()
all_error[:] = 0.0
num_configs = len(all_means.columns)
width = num_configs / (num_configs + 2)
bar_width = width / num_configs
max_val = (all_means + all_error + 0.5).max().max()
cutoff = self._kwargs_default(kwargs, 'cutoff', max_val)
start = self._kwargs_default(kwargs, 'start', 0.0)
axis.set_xlim(start, cutoff)
axis.margins(0.0)
ax = all_means.plot.barh(ax=axis,
xerr=all_error,
width=width,
color='0.75',
**self.barchart_defaults)
text_df = all_means.T
min_y_pos = 0.0
max_y_pos = 0.0
for i, bench in enumerate(text_df):
for j, v in enumerate(reversed(text_df[bench])):
offset = (j * bar_width) - (bar_width * (num_configs / 2)) + \
(bar_width / 2)
y = i - offset
min_y_pos = min(y - (bar_width / 2), min_y_pos)
max_y_pos = max(y + (bar_width / 2), max_y_pos)
precision = self._kwargs_default(kwargs, 'precision', 1)
s = ('{0:.%df} ' % precision).format(v) if v >= cutoff or \
self._kwargs_bool(kwargs, 'add_numbers') else ''
pos = cutoff if v >= cutoff else v
if isnan(pos):
continue
txt = ax.text(pos,
y,
s,
va='center',
ha='right',
color='white',
fontweight='bold',
fontfamily='sans',
fontsize=6)
txt.set_path_effects(
[PathEffects.withStroke(linewidth=1, foreground='black')])
if self._kwargs_bool(kwargs, 'label_bars'):
label_txt = ' ' + list(
reversed(text_df[bench].index.tolist()))[j]
txt2 = ax.text(0,
y,
label_txt,
va='center',
ha='left',
color='white',
fontweight='bold',
fontfamily='sans',
fontsize=6)
txt2.set_path_effects([
PathEffects.withStroke(linewidth=1, foreground='black')
])
ybounds = axis.get_ylim()
if self._kwargs_bool(kwargs, 'flush'):
axis.set_ylim(min_y_pos, max_y_pos)
artist = []
#labels = self._clean_benchmark_names(labels)
ax.invert_yaxis()
major_tick = max(float(int(cutoff / 10.0)), 1.0)
if major_tick > 10.0:
major_tick = 5.0 * int(major_tick / 5)
ax.xaxis.set_major_locator(ticker.MultipleLocator(major_tick))
if cutoff > 5.0:
ax.xaxis.set_minor_locator(ticker.MultipleLocator(major_tick /
5.0))
else:
ax.xaxis.set_minor_locator(
ticker.MultipleLocator(major_tick / 10.0))
ax.set_axisbelow(True)
bars = ax.patches
num_configs = all_means.shape[1]
num_bench = all_means.shape[0]
hatches = (self.__class__.HATCH * 10)[:num_configs]
all_hatches = sum(
[list(itertools.repeat(h, num_bench)) for h in hatches], [])
colors = [self._get_config_color(c) for c in all_means.columns]
all_colors = sum(
[list(itertools.repeat(c, num_bench)) for c in colors], [])
for bar, hatch, color in zip(bars, all_hatches, all_colors):
#bar.set_hatch(hatch)
bar.set_color(color)
bar.set_edgecolor('black')
scale = self._kwargs_default(kwargs, 'scale', 1.0)
if scale < 1.0:
print('Scaling!')
box = axis.get_position()
new_box = [
box.x0, box.y0 + box.height * (1.0 - scale), box.width,
box.height * scale
]
axis.set_position(new_box)
plt.sca(axis)
self.__class__._do_grid_lines()
plt.xlabel(self._kwargs_default(kwargs, 'label', ''))
plt.xscale(self._kwargs_default(kwargs, 'xscale', 'linear'))
if 'xscale' in kwargs and 'symlog' in kwargs['xscale']:
#locmin = ticker.LogLocator(base=10.0, subs=(0.1,0.2,0.4,0.6,0.8,1,2,4,6,8,10 ))
locmin = ticker.NullLocator()
ax.xaxis.set_minor_locator(locmin)
ax.xaxis.set_minor_formatter(ticker.NullFormatter())
#locmaj = ticker.LogLocator(base=100.0, subs=(1.0,), numdecs=0)
locmaj = ticker.FixedLocator(
locs=[1, 100, 10000, 1000000, 100000000])
ax.xaxis.set_major_locator(locmaj)
#ax.xaxis.set_major_formatter(ticker.FuncFormatter(
# lambda x, _: '%.0g' % (x) if x >= 0 else ''))
ax.xaxis.set_major_formatter(ticker.LogFormatterMathtext())
if self._kwargs_has(kwargs, 'tick_format'):
ax.xaxis.set_major_formatter(
FormatStrFormatter(kwargs['tick_format']))
if self._kwargs_has(kwargs, 'legend'):
legend = plt.legend(**kwargs['legend'])
artist += [legend]
else:
plt.legend().set_visible(False)
if self._kwargs_bool(kwargs, 'exclude_tick_labels'):
plt.yticks(ticks=range(len(labels)), labels=[''] * len(labels))
else:
# plt.yticks(ticks=range(len(labels)), labels=labels, ha='right')
minor_ticks = []
if self._kwargs_has(kwargs, 'per_tick_label'):
# Required to determine position of ticks.
plt.gcf().canvas.draw()
for tick in axis.yaxis.get_major_ticks():
tick_label = tick.label.get_text()
if tick_label not in kwargs['per_tick_label']:
continue
opt = kwargs['per_tick_label'][tick_label]
if 'font' in opt:
tick.label.set_fontproperties(
FontProperties(**opt['font']))
if self._kwargs_bool(opt, 'line_before'):
minor_ticks += [tick.get_loc() - 0.5]
if len(minor_ticks):
axis.yaxis.set_minor_locator(ticker.FixedLocator(minor_ticks))
axis.tick_params(which='minor', axis='y', length=0, width=0)
plt.grid(which='minor',
color='k',
linestyle='-',
axis='y',
zorder=5.0,
linewidth=2)
return artist, ybounds
def heatmap(ax, arr, xrange, yrange, xy_label, label, log_norm=True, xy_label_force=None, less_xticks=False,
skip_cbar=False, cbar_white_loc=1.0, **kwargs):
"""
xrange: range of values for x
yrange: range of y values
fname: file saved as pdf and eps format with this name
show: shows plots
save: saves plot
log_norm: heatmap is log, this is only used when plotting the posterior
kwargs: a variety of keyword args are used below. They are mostly used for
contour plot lines if I understand correctly. Using Duncan's default ones mostly,
but we can talk about it.
"""
# default parameters, this is relic ofthe previous way we did things. Still might be useful.
if 'levels' in kwargs.keys(): levels = kwargs['levels']
else: levels = [1E0] #, 1E5, 1E10, 1E20]
if 'vmin' in kwargs.keys(): vmin = kwargs['vmin']
else: vmin = 1E-3 #np.min(arr)
if 'vmax' in kwargs.keys(): vmax = kwargs['vmax']
else:
if np.max(arr) > 1E10:
vmax = 1E5
else:
vmax = 1E5 #np.max(arr)
if 'contour_linestyle' in kwargs.keys(): contour_linestyle = kwargs['contour_linestyle']
else: contour_linestyle = '-'
if 'contour_color' in kwargs.keys(): contour_color = kwargs['contour_color']
else: contour_color = 'k'
if 'contour_linewidths' in kwargs.keys(): contour_lindewidths = kwargs['contour_linewidths']
else: contour_lindewidths = 1.2
if 'cmap_colour' in kwargs.keys(): cmap_colour = kwargs['cmap_colour']
else: cmap_colour = 'RdBu_r' #'YlGnBu' or 'RdBu_r'
if 'fmt' in kwargs.keys(): fmt = kwargs['fmt']
else: fmt = ticker.LogFormatterMathtext()
if log_norm:
arr = np.ma.array(arr, mask=( arr<=0.0 ) )
if cmap_colour == 'RdBu_r':
imshow_kw = {'cmap': cmap_colour, 'aspect': None, 'vmin': vmin, 'vmax': vmax, 'norm': MidPointLogNorm(vmin, vmax, cbar_white_loc)}
else:
imshow_kw = {'cmap': cmap_colour, 'aspect': None, 'vmin': vmin, 'vmax': vmax, 'norm': mpl.colors.LogNorm(vmin,vmax)}
print("Logscale")
else:
imshow_kw = {'cmap': cmap_colour, 'aspect': None, 'vmin': vmin, 'vmax': vmax}
# TODO change colour scheme, see https://matplotlib.org/examples/color/colormaps_reference.html
# TODO fix ticks randomly disappearing on colourbar + flip colourbar minor ticks or remove?
"""
Colours viridis, YlGnBu, terrain, plasma
"""
im = ax.imshow(arr, interpolation='none', **imshow_kw)
#im = plt.imshow(arr, interpolation='spline36', **imshow_kw)
# axes setup
# axes log scaled
if less_xticks:
ax.set_xticks([i for i, xval in enumerate(xrange) if (i % POINTS_BETWEEN_TICKS==0 and np.log10(xval)%2 == 0)])
ax.set_xticklabels([r'$10^{%d}$' % np.log10(xval) for i, xval in enumerate(xrange) if (i % POINTS_BETWEEN_TICKS==0 and np.log10(xval)%2 == 0)], fontsize=FS)
else:
ax.set_xticks([i for i, cval in enumerate(xrange) if i % POINTS_BETWEEN_TICKS == 0])
ax.set_xticklabels([r'$10^{%d}$' % np.log10(xval) for i, xval in enumerate(xrange) if (i % POINTS_BETWEEN_TICKS==0)], fontsize=FS)
ax.set_yticks([i for i, kval in enumerate(yrange) if i % POINTS_BETWEEN_TICKS == 0])
ax.set_yticklabels([r'$10^{%d}$' % np.log10(yval) for i, yval in enumerate(yrange) if i % POINTS_BETWEEN_TICKS==0], fontsize=FS)
ax.invert_yaxis()
ax.set_xlabel(xy_label[0], fontsize=FS); ax.set_ylabel(xy_label[1], fontsize=FS)
# create colorbar
#divider = make_axes_locatable(ax) # this does not work, proposed solution online for colorbar for multiplots
#cax = divider.append_axes("right",size="5%",pad=0.05)
#cbar = plt.colorbar(im, ax=cax)
if skip_cbar:
cbar = None
else:
cbar = plt.colorbar(im, ax=ax, fraction=0.046, pad=0.05) # Fig 3 way pad 0.04
cbar.ax.set_ylabel(label, rotation=-90, va="bottom", fontsize=FS, labelpad=-20); cbar.ax.tick_params(labelsize=(FS), width=1,length=1)
cbar.ax.minorticks_off();
#cbar.set_ticks([round(vmin,3)+0.001,round(vmax,3)-0.001]) # UNCOMMENT THIS ONLY WHEN TICKS DON'T APPEAR
cbar.update_ticks()
# TODO IDK why do ticks hide sometimes?
CL = ax.contour(arr, levels=levels, linestyles=contour_linestyle, colors=contour_color, linewidths=contour_lindewidths)
ax.clabel(CL, CL.levels, inline=True, fmt=fmt, fontsize=FS-2)
#Might be an issue
#plt.tight_layout(h_pad=1)
plt.tight_layout(h_pad=1,w_pad=1)
return ax, cbar, im
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()
fig = plt.figure()
ax = fig.add_axes((0.2, 0.2, 0.7, 0.7))
im = ax.pcolor(
bn,
bm,
t_big,
cmap="viridis_r",
norm=LogNorm(vmin=tflat_big.min(), vmax=tflat_big.max()),
)
co = ax.contour(bn,
bm,
t_big,
levels=[1e14, 1e15],
colors="#FFFFFF",
linestyles="dashed")
fmt = ti.LogFormatterMathtext()
fmt.create_dummy_axis()
plt.clabel(co, co.levels, fmt=fmt)
# sc = ax.scatter(
# nn,
# mm,
# c=residuals,
# cmap="RdBu_r",
# s=30,
# edgecolor="#444444",
# linewidth=0,
# norm=Normalize(
# vmin=-np.abs(residuals).max() * 1,
# vmax=np.abs(residuals).max() * 1,
# ),
# )
def plot_contour(self,
values="MassArea",
vent=True,
title="Isomass Plot",
cmap='plasma',
log=True,
lines=True,
line_cmap=None,
line_colors='k',
background="gradient",
cbar_label=None,
save=None):
piv = pd.pivot_table(self.df,
index="Northing",
columns="Easting",
values=values)
if log:
norm = LogNorm(vmin=piv.values.min(), vmax=piv.values.max())
grad_values = np.log(piv.values)
else:
norm = None
fig, ax = plt.subplots(1, 1)
# ax.axis('equal')
plt.ylabel("Northing")
plt.xlabel("Easting")
plt.title(title)
if background == "gradient":
bg = ax.imshow(np.log10(piv.values),
extent=[
piv.columns.min(),
piv.columns.max(),
piv.index.min(),
piv.index.max()
],
origin='lower',
cmap=cmap,
alpha=0.7)
if log:
cbar = fig.colorbar(bg, ax=ax, format=r"$10^{%d}$")
else:
cbar = fig.colorbar(bg, ax=ax)
cbar.set_alpha(alpha=0.5)
cbar.draw_all()
if cbar_label is not None:
cbar.ax.set_ylabel(cbar_label, rotation=270)
elif background == "fill":
bg = ax.contourf(piv.columns,
piv.index,
piv.values,
norm=norm,
cmap=cmap)
cbar = fig.colorbar(bg, ax=ax, extend='both')
if cbar_label is not None:
cbar.ax.set_ylabel(cbar_label, rotation=270)
if lines:
if line_cmap is not None:
lns = ax.contour(piv.columns,
piv.index,
piv.values,
norm=norm,
cmap=lines_cmap)
elif line_colors is not None:
lns = ax.contour(piv.columns,
piv.index,
piv.values,
norm=norm,
colors=line_colors)
fmt = ticker.LogFormatterMathtext()
fmt.create_dummy_axis()
ax.clabel(lns, lns.levels, fmt=fmt)
if vent:
plt.plot(self.vent.x, self.vent.y, 'r^', ms=8)
plt.tight_layout()
plt.gca().set_xlim(right=piv.columns.max(), left=piv.columns.min())
plt.gca().set_ylim(bottom=piv.index.min(), top=piv.index.max())
plt.gca().set_aspect("equal")
if save is not None:
plt.savefig(save, dpi=200, format='png')
return fig, ax
def print_B_vs_alpha_safety():
N = 500
B = list(range(0, int(N/2), 1))
C1 = [int((N - i)/2) for i in B]
C2 = [N - B[i] - C1[i] for i in range(len(B))]
k = 10
alpha = list(range(int(k/2), k+1))
zsafety = []
zliveness = []
cons = 20
trials = 100
for j in range(len(alpha)):
# print(i)
zssafety = []
zsliveness = []
for i in range(len(B)):
u = probOfStreak(trials, cons, hyper(N, B[i]+C1[i], k, alpha[j]))
r_safety = (C1[i]**2)*(((1/(N-B[i]))*u)**2)
v = 1 - probOfStreak(trials, cons, hyper(N, C1[i], k, alpha[j]))
# r_safety = (len(C1)**2)*((probOfStreak(trials, cons, hyper(N, B[i]+C1[i], k, alpha[j])))**2)
r_liveness = v
# print("{},{},{}".format(B[i], C1[i], a), r)
zssafety.append(r_safety)
zsliveness.append(r_liveness)
print(i, j, r_safety)
zsafety.append(zssafety)
zliveness.append(zsliveness)
# fig = plt.figure()
x, y = np.meshgrid(B, alpha)
# max_z = max([max(i) for i in zsafety])
# for i in range(len(zsafety)):
# for j in range(len(zsafety[i])):
# zsafety[i][j] /= max_z
zsafety = np.array(zsafety)
# max_z = max([max(i) for i in zliveness])
# for i in range(len(zliveness)):
# for j in range(len(zliveness[i])):
# zliveness[i][j] /= max_z
zliveness = np.array(zliveness)
if True:
fig, ax = plt.subplots(1, 1)
pcm = ax.pcolor(x, y, zsafety, norm=colors.LogNorm(vmin=zsafety.min(), vmax=zsafety.max()), cmap=cm.coolwarm)
axim = ax.contour(x, y, zsafety, cmap=cm.Greys, norm = LogNorm())
fmt = ticker.LogFormatterMathtext()
fmt.create_dummy_axis()
plt.clabel(axim, axim.levels, fmt=fmt)
# CS = plt.contour(x, y, zsafety, norm=colors.LogNorm(vmin=zsafety.min(), vmax=zsafety.max()), cmap=cm.binary)
# fmt = ticker.LogFormatterMathtext()
# fmt.create_dummy_axis()
# plt.clabel(CS, CS.levels, fmt=fmt)
# CS = plt.pcolor(x, y, zsafety, norm=colors.LogNorm(vmin=zsafety.min(), vmax=zsafety.max()), cmap=cm.coolwarm)
# plt.clabel(axim, axim.levels)
fig.colorbar(pcm, ax=ax, extend='max')
# ax = fig.add_subplot(111, projection='3d')
# ax.plot_surface(x, y, zsafety, cmap=cm.coolwarm,linewidth=0, antialiased=False)
# ax = fig.add_subplot(212, projection='3d')
# ax.plot_surface(x, y, zliveness,linewidth=0, antialiased=False)
# ax.set_zlim(10e-10, 1)
else:
# Plot liveness
fig, ax = plt.subplots(1, 1)
pcm = ax.pcolor(x, y, zliveness, cmap=cm.coolwarm)
axim = ax.contour(x, y, zliveness, cmap=cm.Greys)
fmt = ticker.LogFormatterMathtext()
fmt.create_dummy_axis()
plt.clabel(axim, axim.levels, fmt=fmt)
fig.colorbar(pcm, ax=ax, extend='max')
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.ylabel(r"$\alpha k,\ k=10$")
plt.xlabel("Byzantine |$\mathcal{B}$| size, ($|\mathcal{N}| = 500$)")
plt.show()
def __heatmap__(ax, arr, xrange, yrange, xy_label, label, log_norm=True, less_xticks=False,
skip_cbar=False, cbar_white_loc=1.0, **kwargs):
"""
xrange: range of values for x
yrange: range of y values
xy_label: list with first element the x label (str) and second element the
y label (str)
fname: file saved as pdf and eps format with this name
show: shows plots
save: saves plot
log_norm: heatmap is log, this is only used when plotting the posterior
kwargs: a variety of keyword args are used below. They are mostly used for
contour plot lines
"""
if 'levels' in kwargs.keys():
levels = kwargs['levels']
else:
levels = [1E0] # , 1E5, 1E10, 1E20]
if 'vmin' in kwargs.keys():
vmin = kwargs['vmin']
else:
vmin = 1E-3 # np.min(arr)
if 'vmax' in kwargs.keys():
vmax = kwargs['vmax']
else:
if np.max(arr) > 1E10:
vmax = 1E5
else:
vmax = 1E5 # np.max(arr)
if 'contour_linestyle' in kwargs.keys():
contour_linestyle = kwargs['contour_linestyle']
else:
contour_linestyle = '-'
if 'contour_color' in kwargs.keys():
contour_color = kwargs['contour_color']
else:
contour_color = 'k'
if 'contour_linewidths' in kwargs.keys():
contour_lindewidths = kwargs['contour_linewidths']
else:
contour_lindewidths = 1.2
if 'cmap_colour' in kwargs.keys():
cmap_colour = kwargs['cmap_colour']
else:
cmap_colour = 'RdBu_r' # 'YlGnBu' or 'RdBu_r'
if 'fmt' in kwargs.keys():
fmt = kwargs['fmt']
else:
fmt = ticker.LogFormatterMathtext()
if log_norm:
arr = np.ma.array(arr, mask=(arr <= 0.0))
if cmap_colour == 'RdBu_r':
imshow_kw = {'cmap': cmap_colour, 'aspect': None, 'vmin': vmin, 'vmax': vmax, 'norm': MidPointLogNorm(vmin, vmax, cbar_white_loc)}
else:
imshow_kw = {'cmap': cmap_colour, 'aspect': None, 'vmin': vmin, 'vmax': vmax, 'norm': mpl.colors.LogNorm(vmin, vmax)}
print("Logscale")
else:
imshow_kw = {'cmap': cmap_colour, 'aspect': None, 'vmin': vmin, 'vmax': vmax}
"""
Colours viridis, YlGnBu, terrain, plasma
"""
im = ax.imshow(arr, interpolation='none', **imshow_kw)
# im = plt.imshow(arr, interpolation='spline36', **imshow_kw)
# axes setup
# axes log scaled
if less_xticks:
ax.set_xticks([i for i, xval in enumerate(xrange) if (i % POINTS_BETWEEN_TICKS == 0 and np.log10(xval) % 2 == 0)])
ax.set_xticklabels([r'$10^{%d}$' % np.log10(xval) for i, xval in enumerate(xrange) if (i % POINTS_BETWEEN_TICKS == 0 and np.log10(xval) % 2 == 0)], fontsize=FS)
else:
ax.set_xticks([i for i, cval in enumerate(xrange) if i % POINTS_BETWEEN_TICKS == 0])
ax.set_xticklabels([r'$10^{%d}$' % np.log10(xval) for i, xval in enumerate(xrange) if (i % POINTS_BETWEEN_TICKS == 0)], fontsize=FS)
ax.set_yticks([i for i, kval in enumerate(yrange) if i % POINTS_BETWEEN_TICKS == 0])
ax.set_yticklabels([r'$10^{%d}$' % np.log10(yval) for i, yval in enumerate(yrange) if i % POINTS_BETWEEN_TICKS == 0], fontsize=FS)
ax.invert_yaxis()
ax.set_xlabel(xy_label[0], fontsize=FS)
ax.set_ylabel(xy_label[1], fontsize=FS)
# create colorbar
if skip_cbar:
cbar = None
else:
cbar = plt.colorbar(im, ax=ax, fraction=0.046, pad=0.05) # Fig 3 way pad 0.04
cbar.ax.set_ylabel(label, rotation=-90, va="bottom", fontsize=FS, labelpad=-20)
cbar.ax.tick_params(labelsize=(FS), width=1, length=1)
cbar.ax.minorticks_off()
# cbar.set_ticks([round(vmin,3)+0.001,round(vmax,3)-0.001]) # UNCOMMENT THIS ONLY WHEN TICKS DON'T APPEAR
cbar.update_ticks()
CL = ax.contour(arr, levels=levels, linestyles=contour_linestyle, colors=contour_color, linewidths=contour_lindewidths)
ax.clabel(CL, CL.levels, inline=True, fmt=fmt, fontsize=FS-2)
plt.tight_layout(h_pad=1, w_pad=1)
return ax, cbar, im
fmt = {}
strs = ['first', 'second', 'third', 'fourth', 'fifth', 'sixth', 'seventh']
for l, s in zip(CS1.levels, strs):
fmt[l] = s
# Label every other level using strings
ax1.clabel(CS1, CS1.levels[::2], inline=True, fmt=fmt, fontsize=10)
###############################################################################
# Use a Formatter
fig2, ax2 = plt.subplots()
CS2 = ax2.contour(X, Y, 100**Z, locator=plt.LogLocator())
fmt = ticker.LogFormatterMathtext()
fmt.create_dummy_axis()
ax2.clabel(CS2, CS2.levels, fmt=fmt)
ax2.set_title("$100^Z$")
plt.show()
#############################################################################
#
# .. admonition:: References
#
# The use of the following functions, methods, classes and modules is shown
# in this example:
#
# - `matplotlib.axes.Axes.contour` / `matplotlib.pyplot.contour`
# - `matplotlib.axes.Axes.clabel` / `matplotlib.pyplot.clabel`
def main(graph_name):
G = nx.read_gml(graph_name)
# G = nx.connected_component_subgraphs(G)[0] ### For plotting Giant component ###
top_nodes = []
top_nodes.append(G.nodes())
topn = map(int, G.nodes())
string_mapping = dict(zip(G.nodes(), map(int, G.nodes())))
G = nx.relabel_nodes(G, string_mapping)
H = nx.DiGraph(
) #### For undirected graph use H = nx.Graph() and for directed use nx.DiGraph()
H.add_edges_from(G.edges())
# print G.edges()
activity = []
# nodepos = []
pos = nx.graphviz_layout(H, prog='neato', args='')
# pos = nx.spring_layout(H,iterations=100)
for n in topn:
nodelabel = G.node[n]['label']
activity.append(
float(G.node[n]['activity']) / float(G.node[n]['time_in_system']))
# nodepos.append(int(nodelabel))
max_activity = max(activity)
min_activity = min(activity)
# print activity
pop_plus = []
pop_minus = []
pop_zero = []
pop = []
size_plus = []
size_minus = []
size_zero = []
nodepos_plus = []
nodepos_minus = []
nodepos_zero = []
for n in topn:
pop.append(
((float(G.node[n]['activity']) /
float(G.node[n]['time_in_system'])) / np.log(float(max_activity))
)) ### One can change it to log scale too !!!
size_node = 100 * (float(G.node[n]['n_weight_change']))
if size_node > 0:
size_plus.append(size_node)
nodepos_plus.append(int(G.node[n]['id']))
pop_plus.append(((float(G.node[n]['activity']) /
float(G.node[n]['time_in_system'])) /
np.log(float(max_activity))))
if size_node < 0:
size_minus.append(abs(size_node))
nodepos_minus.append(int(G.node[n]['id']))
pop_minus.append(((float(G.node[n]['activity']) /
float(G.node[n]['time_in_system'])) /
np.log(float(max_activity))))
if size_node == 0:
size_zero.append(abs(size_node))
nodepos_zero.append(int(G.node[n]['id']))
pop_zero.append(((float(G.node[n]['activity']) /
float(G.node[n]['time_in_system'])) /
np.log(float(max_activity))))
# print size_minus, size_plupop_minuss
print pop_zero, pop_minus, pop_plus
colors_plus = []
for rank_plus in pop_plus:
colors_plus.append(plot.cm.jet(float(rank_plus)))
colors_minus = []
for rank_minus in pop_minus:
colors_minus.append(plot.cm.jet(float(rank_minus)))
colors_zero = []
for rank_zero in pop_zero:
colors_zero.append(plot.cm.jet(float(rank_zero)))
fig = plot.figure(figsize=(11, 11))
ax = fig.add_axes((0.0, 0.0, 1.0, 1.0))
# cax = ax.imshow([activity],cmap=cm.jet,norm=LogNorm(vmin=min_activity, vmax=max_activity))
# cax = ax.imshow([activity],cmap=cm.jet)
# nx.draw(H,pos,node_color=colors,node_shape='o',node_size = size_minus, with_labels=False)
# nx1.draw_networkx_nodes(H,pos,nodelist=None,node_size = 300, node_shape = 'o', node_color=colors, cmap=plot.cm.jet)
nx.draw_networkx_nodes(H,
pos,
nodelist=nodepos_plus,
node_size=size_plus,
node_shape='s',
node_color=colors_plus,
cmap=plot.cm.jet)
nx.draw_networkx_nodes(H,
pos,
nodelist=nodepos_minus,
node_size=size_minus,
node_shape='o',
node_color=colors_minus,
cmap=plot.cm.jet)
nx.draw_networkx_nodes(H,
pos,
nodelist=nodepos_zero,
node_size=size_minus,
node_shape='o',
node_color=colors_zero,
cmap=plot.cm.jet)
nx2.draw_networkx_edges(H,
pos,
edgelist=None,
edge_color='k',
style='solid',
alpha=0.25)
# nx1.draw_networkx_labels(H,pos,labels=None,font_size=10) ### For labeling the nodes with uid
formatter = ticker.LogFormatterMathtext()
#colorbar(format=formatter)
plot.rcParams["font.size"] = 12
# c=plot.colorbar(cax,orientation='vertical',shrink = 0.55,format=formatter)
# c.set_label("Normalized Total Activity of Users")
# pyplot.title('weight-loss (circle) and weight-gain (square)')
pyplot.axis('off')
pyplot.show()
def create_plot(field,
xy,
fdat,
r,
show=False,
fname='Output/test.pdf',
override_lims=None):
if override_lims is None:
override_lims = {}
# Check to see if the field diverges
if field in field_lims_shells:
vmin, vmax = field_lims_shells[field]
#linthresh = 10**(int(np.ceil(np.log10(vmax)))-4.5)
linthresh = 1e4
if field in override_lims:
vmin, vmax = override_lims[field]
if sum([1 for k in diverging_field_keys if k in field]):
cmap = 'RdBu'
fdat = np.ma.filled(np.ma.masked_invalid(fdat), 0)
if field not in field_lims_shells:
vmax = np.max(np.abs(fdat))
vmin = -1 * vmax
if len(fdat[fdat > 0]) == 0: return
linthresh = 100 * np.min(np.abs(fdat[fdat > 0]))
else:
cmap = 'viridis'
#fdat = np.ma.masked_where(fdat==0, fdat)
fdat = np.ma.masked_invalid(fdat)
if field not in field_lims_shells:
vmin, vmax = np.min(fdat), np.max(fdat)
symlog = False
if sum([1 for k in symlog_field_keys if k in field]):
norm = SymLogNorm(vmin=vmin, vmax=vmax, linthresh=linthresh)
maxlog = int(np.ceil(np.log10(vmax)))
minlog = int(np.ceil(np.log10(-vmin)))
linlog = int(np.ceil(np.log10(linthresh)))
symlog = True
#generate logarithmic ticks
tick_locations = ([-(10**x) for x in range(minlog, linlog - 1, -1)] +
[0.0] + [(10**x) for x in range(linlog, maxlog + 1)])
elif sum([1 for k in log_field_keys if k in field]):
norm = LogNorm(vmin=vmin, vmax=vmax)
else:
norm = Normalize(vmin=vmin, vmax=vmax)
lon, lat = xy
plt.pcolormesh(lon,
lat,
fdat.reshape(lon.shape),
cmap=cmap,
norm=norm,
rasterized=True,
vmin=vmin,
vmax=vmax)
if symlog:
plt.colorbar(label=label_lookup[field],
ticks=tick_locations,
format=ticker.LogFormatterMathtext())
else:
if field in label_lookup:
plt.colorbar(label=label_lookup[field])
else:
plt.colorbar(label=field)
plt.gca().set_aspect('equal')
plt.ylim(-90, 90)
plt.xlim(-90, 270)
plt.xticks([-90, -30, 30, 90, 150, 210, 270])
plt.yticks([-90, -45, 0, 45, 90])
plt.xlabel('Longitude (0=Dayside, 180=Nightside)')
plt.ylabel('Latitude')
plt.title('R = {0} (RM)'.format(r))
print('Saving: {0}'.format(fname))
if show:
plt.show()
else:
plt.savefig(fname)
plt.close()
def __heatmap2__(arr, crange, koffrange, fname, label, show=SHOW, save=True, log_norm=True, log_norm_axes_only=False,
dedim=False, xy_label_force=None, less_xticks=True, return_cb=False, **kwargs):
"""
crange: range of values for c
koffrange: range of koff values
fname: file saved as pdf and eps format with this name
show: shows plots
save: saves plots
log_norm: heatmap is log, this is only used when plotting the posterior
dedim: makes the axis dedimensionalized. scales them (see by how much below)
kwargs: a variety of keyword args are used below. They are mostly used for contour plot lines
"""
# default parameters
if 'levels' in kwargs.keys():
levels = kwargs['levels']
else:
levels = [1E0, 1E1, 1E2, 1E3]
if 'vmin' in kwargs.keys():
vmin = kwargs['vmin']
else:
vmin = np.min(arr)
if 'vmax' in kwargs.keys():
vmax = kwargs['vmax']
else:
vmax = np.max(arr)
if 'contour_linestyle' in kwargs.keys():
contour_linestyle = kwargs['contour_linestyle']
else:
contour_linestyle = '-'
if 'contour_color' in kwargs.keys():
contour_color = kwargs['contour_color']
else:
contour_color = 'k'
if 'contour_linewidths' in kwargs.keys():
contour_lindewidths = kwargs['contour_linewidths']
else:
contour_lindewidths = 2
if 'cmap_colour' in kwargs.keys():
cmap_colour = kwargs['cmap_colour']
else:
cmap_colour = 'YlGnBu'
if 'fmt' in kwargs.keys():
fmt = kwargs['fmt']
else:
fmt = ticker.LogFormatterMathtext()
if 'fig_width' in kwargs.keys():
fig_width = kwargs['fig_width']
else:
fig_width = 3.0
if dedim:
# if flag is true, this is how we scale the axis. Simple.
crange = crange*KON/KP
koffrange = koffrange/KP
xy_label = [r'$k_{on}c/k_{p}$', r'$k_{off}/k_{p}$']
else:
xy_label = [r'${c}$', r'${k}_{off}$']
if xy_label_force is not None:
xy_label = xy_label_force
# we want most of the functionality that comes with log_norm, but not the log colorbar
if log_norm and not log_norm_axes_only:
imshow_kw = {'cmap': cmap_colour, 'aspect': None, 'vmin': vmin, 'vmax': vmax, 'norm': mpl.colors.LogNorm(vmin, vmax)}
else:
imshow_kw = {'cmap': cmap_colour, 'aspect': None, 'vmin': vmin, 'vmax': vmax}
"""
Colours viridis, YlGnBu, terrain, plasma
"""
# plot setup
f = plt.figure(figsize=(fig_width, fig_width/1.2))
im = plt.imshow(arr, interpolation='spline36', **imshow_kw)
# axes setup
fig = plt.gcf()
ax = plt.gca()
# axes log scaled
if less_xticks:
ax.set_xticks([i for i, cval in enumerate(crange) if (i % POINTS_BETWEEN_TICKS == 0 and np.log10(cval) % 2 == 0)])
ax.set_xticklabels([r'$10^{%d}$' % np.log10(cval) for i, cval in enumerate(crange) if (i % POINTS_BETWEEN_TICKS == 0 and np.log10(cval) % 2 == 0)], fontsize=FS)
else:
ax.set_xticks([i for i, cval in enumerate(crange) if i % POINTS_BETWEEN_TICKS == 0])
ax.set_xticklabels([r'$10^{%d}$' % np.log10(cval) for i, cval in enumerate(crange) if (i % POINTS_BETWEEN_TICKS == 0)], fontsize=FS)
ax.set_yticks([i for i, kval in enumerate(koffrange) if i % POINTS_BETWEEN_TICKS == 0])
ax.set_yticklabels([r'$10^{%d}$' % np.log10(yval) for i, yval in enumerate(koffrange) if i % POINTS_BETWEEN_TICKS == 0], fontsize=FS)
ax.invert_yaxis()
ax.set_xlabel(xy_label[0], fontsize=FS)
ax.set_ylabel(xy_label[1], fontsize=FS)
# create colorbar
cbar = fig.colorbar(im, fraction=0.0375, pad=0.04)
cbar.ax.set_ylabel(label, rotation=-90, va="bottom", fontsize=FS, labelpad=5)
cbar.ax.tick_params(labelsize=FS)
cbar.ax.minorticks_off()
# UNCOMMENT THIS ONLY WHEN TICKS DON'T APPEAR
# cbar.set_ticks([round(vmin,3)+0.001,round(vmax,3)-0.001])
cbar.update_ticks()
cbar.ax.minorticks_off()
CL = plt.contour(arr, levels=levels, linestyles=contour_linestyle, colors=contour_color, linewidths=contour_lindewidths)
plt.clabel(CL, CL.levels, inline=True, fmt=fmt)
# now we can set the ticks without them getting messed up
if not log_norm:
ax = plt.gca()
ax.set_xticks([i for i, cval in enumerate(crange) if i % POINTS_BETWEEN_TICKS == 0] + [len(crange)])
ax.set_yticks([i for i, kval in enumerate(koffrange) if i % POINTS_BETWEEN_TICKS == 0] + [len(koffrange)])
# Exhausting process to make ticks look nice
nice_ticks = ["{}".format(cval) for cval in crange if Decimal(str(cval)) % Decimal(str(crange[-1] / 5)) == 0]
ctilde_ticks = []
for i in range(len(nice_ticks) * 2):
if i % 2 == 0:
ctilde_ticks.append("")
else:
ctilde_ticks.append(nice_ticks.pop(0))
ctilde_ticks = ["0"] + ctilde_ticks
nice_ticks = ["{}".format(koffval) for koffval in koffrange if
Decimal(str(koffval)) % Decimal(str(koffrange[-1] / 5)) == 0]
kofftilde_ticks = []
for i in range(len(nice_ticks) * 2):
if i % 2 == 0:
kofftilde_ticks.append("")
else:
kofftilde_ticks.append(nice_ticks.pop(0))
kofftilde_ticks = ["0"] + kofftilde_ticks
ax.set_xticklabels(ctilde_ticks, fontsize=FS)
ax.set_yticklabels(kofftilde_ticks, fontsize=FS)
# save
if save:
plt.savefig(DIR_OUTPUT + os.sep + fname + '.pdf')
plt.savefig(DIR_OUTPUT + os.sep + fname + '.eps')
plt.savefig(DIR_OUTPUT + os.sep + fname + '.png')
if show:
plt.show()
plt.close()
if return_cb:
return fig, ax, cbar
else:
return fig, ax
