def grid(fields,
title='body spectra',
logZ=False,
show=True,
nstd=1,
vlim=(None, None),
cmap='inferno'):
"""
General purpose plotter for multi-dimensional input tensors from 2D up to 6D. The tensor will be converted to 4D
and plot as a grid of 2D images
:param fields:
:param title:
:param logZ:
:param show:
:return:
"""
if cmap == 'sunlight':
cmap = sunlight
fields = np.array(fields) # just in case its a list
assert fields.ndim > 2
if np.iscomplexobj(fields.flat[0]):
fields = np.abs(fields)**2 # convert to intensity if complex
while len(fields.shape) > 4:
try:
boring_ind = fields.shape.index(1)
fields = np.mean(fields, axis=boring_ind)
except ValueError:
fields = fields[0] # if none are zero slice out first dimension
while len(fields.shape) < 4:
fields = fields[:, np.newaxis]
slices = np.int_(np.ceil(np.array(fields.shape)[:2] / 5))
fields = fields[::slices[0], ::slices[1]]
print(
f'fields being sliced by {slices} making new fields size {fields.shape}'
)
nwave, nobj, x, y = fields.shape
try:
std = np.std(fields)
mean = np.mean(fields)
except ValueError:
std = np.std(fields[0])
mean = np.mean(fields[0])
if vlim == (None, None):
vmin, vmax = mean - nstd * std, mean + nstd * std
else:
vmin, vmax = vlim
fig = plt.figure(figsize=(16, 9))
fig.suptitle(title)
norm = None if not logZ else (LogNorm() if vmin > 0 else SymLogNorm(1e-7))
imgrid = ImageGrid(
fig,
111, # as in plt.subplot(111)
nrows_ncols=(nobj, nwave),
axes_pad=0.15,
share_all=True,
cbar_location="right",
cbar_mode="single",
cbar_size="7%",
cbar_pad=0.15,
)
for i, ax in enumerate(imgrid):
x, y = i % nwave, i // nwave
im = ax.imshow(fields[x, y],
norm=norm,
vmin=vmin,
vmax=vmax,
cmap=cmap)
ax.cax.colorbar(im)
ax.cax.toggle_label(True)
plt.tight_layout()
plt.subplots_adjust(right=0.9)
if show:
plt.show(block=True)
def view_timeseries(img_tseries,
cdi,
title=None,
logZ=False,
vlim=(None, None),
dx=None,
subplt_cols=3,
box={
'use': False,
'threshold': 1e-7
}):
"""
view white light images in the timeseries
:param img_tseries: intensity timeseries [n_tsteps, nx,ny]
:param cdi: struct that contains the CDI params (from CDI.py)
:param title: string, must be set or will error!
:param logZ: turn logscale plotting for Z-axis on or off
:param use_axis: turn on/off using axis ticks, colorbar, etc
:param vlim: tuple of colorbar axis limits (min,max)
:param subplt_cols: number of subplots per row
:param dx: sampling of the image in m. Hardcoded to convert to um
:param box: if True, draw box around CDI region
:return:
"""
# Recreate CDI phase stream for plot titles
if cdi.use_cdi:
phases = cdi.phase_series
# Create figure & adjust subplot number, layout, size, whitespace
n_tsteps = len(img_tseries)
n_rows = int(np.ceil(n_tsteps / float(subplt_cols)))
fig, subplot = plt.subplots(n_rows, subplt_cols, figsize=(12, 10))
fig.subplots_adjust(
bottom=0.1,
top=0.85,
left=0.01,
hspace=.4,
wspace=0.02,
right=0.9,
) # wspace=0.2, right=0.95, left=0.05,
# Title
if title is None:
warnings.warn("Plots without titles: Don't Do It!")
title = input("Please Enter Title: ")
pass
fig.suptitle(title, fontweight='bold', fontsize=16)
for ax, t in zip(subplot.flatten(),
range(n_rows * subplt_cols)): # range(n_tsteps)
if t > n_tsteps - 1:
ax.axis('off') # hides axis
pass
else:
# Axis (Subplot) title
if cdi.use_cdi and not np.isnan(phases[t]):
ax.set_title(f"probe "
r'$\theta$' + f"={phases[t] / np.pi:.2f}" +
r'$\pi$')
else:
ax.set_title(f"t={t * sp.sample_time}")
if logZ:
if vlim[0] is not None and vlim[0] <= 0:
im = ax.imshow(img_tseries[t],
interpolation='none',
origin='lower',
vmin=vlim[0],
vmax=vlim[1],
norm=SymLogNorm(linthresh=1e-5),
cmap="YlGnBu_r")
clabel = "Log Normalized Intensity"
else:
im = ax.imshow(img_tseries[t],
interpolation='none',
origin='lower',
vmin=vlim[0],
vmax=vlim[1],
norm=LogNorm(),
cmap="YlGnBu_r")
clabel = "Log Normalized Intensity"
else:
im = ax.imshow(img_tseries[t],
interpolation='none',
origin='lower',
vmin=vlim[0],
vmax=vlim[1],
cmap="YlGnBu_r")
clabel = "Normalized Intensity"
# XY axis Labels
tic_spacing, tic_labels, xylabel = scale_lD(dx, tp.fn_fp)
ax.set_xticks(tic_spacing)
ax.set_xticklabels(tic_labels)
ax.set_yticks(tic_spacing)
ax.set_yticklabels(tic_labels)
ax.set_xlabel(xylabel)
if box['use']:
from medis.CDI import get_fp_mask
fp_mask, edges, _, _, _, _ = get_fp_mask(
cdi, thresh=box['threshold'])
cl = LineCollection(edges, colors='r')
ax.add_collection(cl)
warnings.simplefilter("ignore", category=UserWarning)
cbar_ax = fig.add_axes([
0.86, 0.1, 0.04, 0.8
]) # Add axes for colorbar @ position [left,bottom,width,height]
cb = fig.colorbar(im, cax=cbar_ax, orientation='vertical') #
cb.set_label(clabel, fontsize=14)
cb.ax.tick_params(labelsize=10)
print('Visualizing J(theta0, theta1) ...')
# 依照定义间隔生成均匀分布的数值
theta0_vals = np.linspace(start=-10, stop=10, num=100)
theta1_vals = np.linspace(start=-1, stop=4, num=100)
xs, ys = np.meshgrid(theta0_vals, theta1_vals)
J_vals = np.zeros(xs.shape)
# Fill out J_vals
for i in range(0, theta0_vals.size):
for j in range(0, theta1_vals.size):
t = np.array([theta0_vals[i], theta1_vals[j]])
J_vals[i][j] = compute_cost(X, y, t)
J_vals = np.transpose(J_vals)
fig1 = plt.figure(2)
ax = fig1.gca(projection='3d')
ax.plot_surface(xs, ys, J_vals)
plt.xlabel(r'$\theta_0$')
plt.ylabel(r'$\theta_1$')
plt.figure(3)
# logspace 创建等比数列
lvls = np.logspace(start=-2, stop=3, num=20)
plt.contour(xs, ys, J_vals, levels=lvls, norm=LogNorm())
plt.plot(theta[0], theta[1], c='r', marker="x")
input('ex1 Finished. Press ENTER to exit')
def showStitchedModels_Redundant(mods,
ax=None,
cmin=None,
cmax=None,
**kwargs):
"""Show several 1d block models as (stitched) section."""
x = kwargs.pop('x', np.arange(len(mods)))
topo = kwargs.pop('topo', x * 0)
nlay = int(np.floor((len(mods[0]) - 1) / 2.)) + 1
if cmin is None or cmax is None:
cmin = 1e9
cmax = 1e-9
for model in mods:
res = np.asarray(model)[nlay - 1:nlay * 2 - 1]
cmin = min(cmin, min(res))
cmax = max(cmax, max(res))
if kwargs.pop('sameSize', True): # all having the same width
dx = np.ones_like(x) * np.median(np.diff(x))
else:
dx = np.diff(x) * 1.05
dx = np.hstack((dx, dx[-1]))
x1 = x - dx / 2
if ax is None:
fig, ax = plt.subplots()
else:
ax = ax
fig = ax.figure
# ax.plot(x, x * 0., 'k.')
zm = kwargs.pop('zm', None)
maxz = 0.
if zm is not None:
maxz = zm
recs = []
RES = []
for i, mod in enumerate(mods):
mod1 = np.asarray(mod)
res = mod1[nlay - 1:]
RES.extend(res)
thk = mod1[:nlay - 1]
thk = np.hstack((thk, thk[-1]))
z = np.hstack((0., np.cumsum(thk)))
if zm is not None:
thk[-1] = zm - z[-2]
z[-1] = zm
else:
maxz = max(maxz, z[-1])
for j, _ in enumerate(thk):
recs.append(Rectangle((x1[i], topo[i] - z[j]), dx[i], -thk[j]))
pp = PatchCollection(recs, edgecolors=kwargs.pop('edgecolors', 'none'))
pp.set_edgecolor(kwargs.pop('edgecolors', 'none'))
pp.set_linewidths(0.0)
ax.add_collection(pp)
if 'cmap' in kwargs:
pp.set_cmap(kwargs['cmap'])
print(cmin, cmax)
norm = LogNorm(cmin, cmax)
pp.set_norm(norm)
pp.set_array(np.array(RES))
# pp.set_clim(cmin, cmax)
ax.set_ylim((-maxz, max(topo)))
ax.set_xlim((x1[0], x1[-1] + dx[-1]))
cbar = None
if kwargs.pop('colorBar', True):
cbar = plt.colorbar(pp,
ax=ax,
norm=norm,
orientation='horizontal',
aspect=60) # , ticks=[1, 3, 10, 30, 100, 300])
if 'ticks' in kwargs:
cbar.set_ticks(kwargs['ticks'])
# cbar.autoscale_None()
if ax is None: # newly created fig+ax
return fig, ax
else: # already given, better give back color bar
return cbar
plt.savefig('figures/hist_constraint_returns.eps')
plt.show()
################################################################################
################################################################################
#plot volatility from different learning rates
with open(path + 'fs_simplified_compare_learning', 'rb') as f:
results_g1, results_g2, results_g3 = pickle.load(f)
#plot heat maps
plt.hist2d(np.zeros(10000) + 0.1,
np.array(results_g1['vol']),
range=[[0.05, 0.35], [0, 0.055]],
bins=[9, 100],
norm=LogNorm())
plt.hist2d(np.zeros(10000) + 0.2,
np.array(results_g2['vol']),
range=[[0.05, 0.35], [0, 0.055]],
bins=[9, 100],
norm=LogNorm())
plt.hist2d(np.zeros(10000) + 0.3,
np.array(results_g3['vol']),
range=[[0.05, 0.35], [0, 0.055]],
bins=[9, 100],
norm=LogNorm())
#plot percentiles
pct = 70
pct1 = [
np.percentile(results_g1['vol'], pct),
z = 0 # z position [kpc] of slice to plot
N = 401 # samples per direction
samples = linspace(-20, 20, N, endpoint=True)
B = zeros((N, N))
X, Y = meshgrid(samples, samples)
for i, x in enumerate(samples):
for j, y in enumerate(samples):
pos = Vector3d(x, y, z) * kpc
B[i, j] = bField.getField(pos).getR() / gauss # B in [G]
figure()
maB = ma.masked_array(B, B == 0)
pc = imshow(maB,
norm=LogNorm(),
extent=(-20, 20, -20, 20),
vmin=1e-9,
vmax=1e-4)
gca().set_aspect(1)
cbar = colorbar(pc, shrink=0.8)
cbar.set_label(r'$\vert \vec{B} \vert$ [G]')
plot(-8.5, 0, 'wo')
xlabel('x [kpc]')
ylabel('y [kpc]')
xlim(-20, 20)
ylim(-20, 20)
savefig('PT11_%s.png' % field, bbox_inches='tight')
show()
control=control_bc[n,0,:,:]
nobb=nobb_bc[n,0,:,:]
noaf=noaf_bc[n,0,:,:]
print(control.shape)
print(nobb.shape)
print(noaf.shape)
fig,(ax1, ax2, ax3)= plt.subplots(1,3,figsize=(12,3))
X,Y=np.meshgrid(lon,lat)
m1=rp.get_basemap(lllon=-70, urlon=0., lllat=-15., urlat=30.,ax=ax1)
m2=rp.get_basemap(lllon=-70, urlon=0., lllat=-15., urlat=30.,ax=ax2)
m3=rp.get_basemap(lllon=-70, urlon=0., lllat=-15., urlat=30.,ax=ax3)
Max=np.nanmax(control)
im=ax1.pcolormesh(X,Y, control, cmap=cmap, vmax=Max, norm=LogNorm())#, vmin=vmin,norm=norm)
im=ax2.pcolormesh(X,Y, noaf, cmap=cmap, vmax=Max, norm=LogNorm())#, vmin=-4000., vmax=4000)#vmin,norm=norm)
im=ax3.pcolormesh(X,Y, nobb, cmap=cmap, vmax=Max, norm=LogNorm())#vmin=-100., vmax=100.)#, vmin=vmin,norm=norm)
ax1.set_title('Control GC_BC')
ax2.set_title('No African BB')
ax3.set_title('No BB')
cbar_ax = fig.add_axes([0.1, 0.1, 0.65, 0.07])
fig.colorbar(im, cax=cbar_ax, orientation='horizontal')
plt.suptitle('SpeciesConc_CO %s' %date)
plt.savefig('/users/mjr583/GC/interhemispheric_mixing/plots/SpeciesConc_map_%s_%s.png' %(out, date))
plt.close()
"""
Launch the stream and the original spectrogram
"""
stream, pa = mic_read.open_mic()
data = get_sample(stream, pa)
arr2D, freqs, bins = get_specgram(data, rate)
"""
Setup the plot paramters
"""
extent = (bins[0], bins[-1] * SAMPLES_PER_FRAME, freqs[-1], freqs[0])
im = plt.imshow(arr2D,
aspect='auto',
extent=extent,
interpolation="none",
cmap='jet',
norm=LogNorm(vmin=.01, vmax=1))
plt.xlabel('Time (s)')
plt.ylabel('Frequency (Hz)')
plt.title('Real Time Spectogram')
plt.gca().invert_yaxis()
##plt.colorbar() #enable if you want to display a color bar
############### Animate ###############
anim = animation.FuncAnimation(fig,
update_fig,
blit=False,
interval=mic_read.CHUNK_SIZE / 1000)
try:
plt.show()
except:
print("Plot Closed")
else:
Npix[j] = n_1(fluxlimit_1d[j]) +n_2(f_b)
N = np.abs(Npix)
N_source = pixel_angle_deg*N # Number of sources per sqiare arcsecond
N_norm = N_source / np.max(N_source) # Normalize
# Construct weight map to gerenate random image:
weight_map = np.reshape(N_norm,(-1,len(image_data[0])))
plt.style.use('default')
plt.figure(figsize = [8, 8])
plt.imshow(weight_map,cmap = 'gray', interpolation = 'none', origin = 'lower', norm = LogNorm())
plt.title('Field '+field[target][0]+ ': Normalized sources per pixel')
plt.savefig(path2+'/expmap.png')
plt.close()
print("Exposure map " + str(i+1) + " created..." )
# Begin making random image:
weight_tot = np.sum(N_norm)
weight_outer = np.cumsum(N_norm) # 'Outer edge' of pixel weight
weight_inner = weight_outer - N_norm # 'Inner edge' of pixel weight
n_sources = int(np.sum(N_source))
def saddleplot(
binedges,
counts,
saddledata,
cmap="coolwarm",
scale="log",
vmin=0.5,
vmax=2,
color=None,
title=None,
xlabel=None,
ylabel=None,
clabel=None,
fig=None,
fig_kws=None,
heatmap_kws=None,
margin_kws=None,
cbar_kws=None,
subplot_spec=None,
):
"""
Generate a saddle plot.
Parameters
----------
binedges : 1D array-like
For `n` bins, there should be `n + 1` bin edges
counts : 1D array-like
Signal track histogram produced by `digitize_track`. It will include
2 flanking elements for outlier values, thus the length should be
`n + 2`.
saddledata : 2D array-like
Saddle matrix produced by `make_saddle`. It will include 2 flanking
rows/columns for outlier signal values, thus the shape should be
`(n+2, n+2)`.
cmap : str or matplotlib colormap
Colormap to use for plotting the saddle heatmap
scale : str
Color scaling to use for plotting the saddle heatmap: log or linear
vmin, vmax : float
Value limits for coloring the saddle heatmap
color : matplotlib color value
Face color for margin bar plots
fig : matplotlib Figure, optional
Specified figure to plot on. A new figure is created if none is
provided.
fig_kws : dict, optional
Passed on to `plt.Figure()`
heatmap_kws : dict, optional
Passed on to `ax.imshow()`
margin_kws : dict, optional
Passed on to `ax.bar()` and `ax.barh()`
cbar_kws : dict, optional
Passed on to `plt.colorbar()`
subplot_spec : GridSpec object
Specify a subregion of a figure to using a GridSpec.
Returns
-------
Dictionary of axes objects.
"""
from matplotlib.gridspec import GridSpec, GridSpecFromSubplotSpec
from matplotlib.colors import Normalize, LogNorm
from matplotlib import ticker
import matplotlib.pyplot as plt
class MinOneMaxFormatter(ticker.LogFormatter):
def set_locs(self, locs=None):
self._sublabels = set([vmin % 10 * 10, vmax % 10, 1])
def __call__(self, x, pos=None):
if x not in [vmin, 1, vmax]:
return ""
else:
return "{x:g}".format(x=x)
n_edges = len(binedges)
n_bins = n_edges - 1
lo, hi = binedges[0], binedges[-1]
# Histogram and saddledata are flanked by outlier bins
n = saddledata.shape[0]
X, Y = np.meshgrid(binedges, binedges)
C = saddledata
hist = counts
if (n - n_bins) == 2:
C = C[1:-1, 1:-1]
hist = hist[1:-1]
# Layout
if subplot_spec is not None:
GridSpec = partial(GridSpecFromSubplotSpec, subplot_spec=subplot_spec)
grid = {}
gs = GridSpec(
nrows=3,
ncols=3,
width_ratios=[0.2, 1, 0.1],
height_ratios=[0.2, 1, 0.1],
wspace=0.05,
hspace=0.05,
)
# Figure
if fig is None:
fig_kws_default = dict(figsize=(5, 5))
fig_kws = merge(fig_kws_default,
fig_kws if fig_kws is not None else {})
fig = plt.figure(**fig_kws)
# Heatmap
if scale == "log":
norm = LogNorm(vmin=vmin, vmax=vmax)
elif scale == "linear":
norm = Normalize(vmin=vmin, vmax=vmax)
else:
raise ValueError("Only linear and log color scaling is supported")
grid["ax_heatmap"] = ax = plt.subplot(gs[4])
heatmap_kws_default = dict(cmap="coolwarm", rasterized=True)
heatmap_kws = merge(heatmap_kws_default,
heatmap_kws if heatmap_kws is not None else {})
img = ax.pcolormesh(X, Y, C, norm=norm, **heatmap_kws)
plt.gca().yaxis.set_visible(False)
# Margins
margin_kws_default = dict(edgecolor="k", facecolor=color, linewidth=1)
margin_kws = merge(margin_kws_default,
margin_kws if margin_kws is not None else {})
# left margin hist
grid["ax_margin_y"] = plt.subplot(gs[3], sharey=grid["ax_heatmap"])
plt.barh(binedges[:-1],
height=np.diff(binedges),
width=hist,
align="edge",
**margin_kws)
plt.xlim(plt.xlim()[1], plt.xlim()[0]) # fliplr
plt.ylim(hi, lo)
plt.gca().spines["top"].set_visible(False)
plt.gca().spines["bottom"].set_visible(False)
plt.gca().spines["left"].set_visible(False)
plt.gca().xaxis.set_visible(False)
# top margin hist
grid["ax_margin_x"] = plt.subplot(gs[1], sharex=grid["ax_heatmap"])
plt.bar(binedges[:-1],
width=np.diff(binedges),
height=hist,
align="edge",
**margin_kws)
plt.xlim(lo, hi)
# plt.ylim(plt.ylim()) # correct
plt.gca().spines["top"].set_visible(False)
plt.gca().spines["right"].set_visible(False)
plt.gca().spines["left"].set_visible(False)
plt.gca().xaxis.set_visible(False)
plt.gca().yaxis.set_visible(False)
# Colorbar
grid["ax_cbar"] = plt.subplot(gs[5])
cbar_kws_default = dict(fraction=0.8, label=clabel or "")
cbar_kws = merge(cbar_kws_default,
cbar_kws if cbar_kws is not None else {})
if scale == "linear" and vmin is not None and vmax is not None:
grid["cbar"] = cb = plt.colorbar(img, **cbar_kws)
# cb.set_ticks(np.arange(vmin, vmax + 0.001, 0.5))
# # do linspace between vmin and vmax of 5 segments and trunc to 1 decimal:
decimal = 10
nsegments = 5
cd_ticks = np.trunc(
np.linspace(vmin, vmax, nsegments) * decimal) / decimal
cb.set_ticks(cd_ticks)
else:
grid["cbar"] = cb = plt.colorbar(img,
format=MinOneMaxFormatter(),
**cbar_kws)
cb.ax.yaxis.set_minor_formatter(MinOneMaxFormatter())
# extra settings
grid["ax_heatmap"].set_xlim(lo, hi)
grid["ax_heatmap"].set_ylim(hi, lo)
plt.grid(False)
plt.axis("off")
if title is not None:
grid["ax_margin_x"].set_title(title)
if xlabel is not None:
grid["ax_heatmap"].set_xlabel(xlabel)
if ylabel is not None:
grid["ax_margin_y"].set_ylabel(ylabel)
return grid
def fieldplot(fig, ax, x, m, WL, comment='', WL_units=' ', crossplane='XZ',
field_to_plot='Pabs', npts=101, factor=2.1, flow_total=11,
is_flow_extend=True, pl=-1, outline_width=1, subplot_label=' '):
Ec, Hc, P, coordX, coordZ = GetField(crossplane, npts, factor, x, m, pl)
Er = np.absolute(Ec)
Hr = np.absolute(Hc)
try:
from matplotlib import cm
from matplotlib.colors import LogNorm
if field_to_plot == 'Pabs':
Eabs_data = np.resize(P, (npts, npts)).T
label = r'$\operatorname{Re}(E \times H)$'
elif field_to_plot == 'Eabs':
Eabs = np.sqrt(Er[:, 0]**2 + Er[:, 1]**2 + Er[:, 2]**2)
Eabs_data = np.resize(Eabs, (npts, npts)).T
label = r'$|E|$'
elif field_to_plot == 'Habs':
Habs = np.sqrt(Hr[:, 0]**2 + Hr[:, 1]**2 + Hr[:, 2]**2)
Eabs_data = np.resize(Habs, (npts, npts)).T
label = r'$|H|$'
elif field_to_plot == 'angleEx':
Eangle = np.angle(Ec[:, 0]) / np.pi * 180
Eabs_data = np.resize(Eangle, (npts, npts)).T
label = r'$arg(E_x)$'
elif field_to_plot == 'angleHy':
Hangle = np.angle(Hc[:, 1]) / np.pi * 180
Eabs_data = np.resize(Hangle, (npts, npts)).T
label = r'$arg(H_y)$'
# Rescale to better show the axes
scale_x = np.linspace(
min(coordX) * WL / 2.0 / np.pi, max(coordX) * WL / 2.0 / np.pi, npts)
scale_z = np.linspace(
min(coordZ) * WL / 2.0 / np.pi, max(coordZ) * WL / 2.0 / np.pi, npts)
# Define scale ticks
min_tick = np.amin(Eabs_data[~np.isnan(Eabs_data)])
#min_tick = 0.1
max_tick = np.amax(Eabs_data[~np.isnan(Eabs_data)])
#max_tick = 60
#scale_ticks = np.linspace(min_tick, max_tick, 5)
scale_ticks = np.power(10.0, np.linspace(np.log10(min_tick), np.log10(max_tick), 6))
#scale_ticks = [0.1,0.3,1,3,10, max_tick]
# Interpolation can be 'nearest', 'bilinear' or 'bicubic'
# ax.set_title(label)
# build a rectangle in axes coords
ax.annotate(subplot_label, xy=(0.0, 1.1), xycoords='axes fraction', # fontsize=10,
horizontalalignment='left', verticalalignment='top')
# ax.text(right, top, subplot_label,
# horizontalalignment='right',
# verticalalignment='bottom',
# transform=ax.transAxes)
cax = ax.imshow(Eabs_data, interpolation='nearest', cmap=cm.jet,
origin='lower', vmin=min_tick, vmax=max_tick, extent=(min(scale_x), max(scale_x), min(scale_z), max(scale_z))
,norm = LogNorm()
)
ax.axis("image")
# Add colorbar
cbar = fig.colorbar(cax, ticks=[a for a in scale_ticks], ax=ax)
# vertically oriented colorbar
cbar.ax.set_yticklabels(['%2.1f' % (a) for a in scale_ticks])
# pos = list(cbar.ax.get_position().bounds)
#fig.text(pos[0] - 0.02, 0.925, '|E|/|E$_0$|', fontsize = 14)
lp2 = -10.0
lp1 = -1.0
if crossplane == 'XZ':
ax.set_xlabel('Z, ' + WL_units, labelpad=lp1)
ax.set_ylabel('X, ' + WL_units, labelpad=lp2)
elif crossplane == 'YZ':
ax.set_xlabel('Z, ' + WL_units, labelpad=lp1)
ax.set_ylabel('Y, ' + WL_units, labelpad=lp2)
elif crossplane == 'XY':
ax.set_xlabel('Y, ' + WL_units, labelpad=lp1)
ax.set_ylabel('X, ' + WL_units, labelpad=lp2)
# # This part draws the nanoshell
from matplotlib import patches
from matplotlib.path import Path
for xx in x:
r = xx * WL / 2.0 / np.pi
s1 = patches.Arc((0, 0), 2.0 * r, 2.0 * r, angle=0.0, zorder=1.8,
theta1=0.0, theta2=360.0, linewidth=outline_width, color='black')
ax.add_patch(s1)
#
# for flow in range(0,flow_total):
# flow_x, flow_z = GetFlow(scale_x, scale_z, Ec, Hc,
# min(scale_x)+flow*(scale_x[-1]-scale_x[0])/(flow_total-1),
# min(scale_z),
# #0.0,
# npts*16)
# verts = np.vstack((flow_z, flow_x)).transpose().tolist()
# #codes = [Path.CURVE4]*len(verts)
# codes = [Path.LINETO]*len(verts)
# codes[0] = Path.MOVETO
# path = Path(verts, codes)
# patch = patches.PathPatch(path, facecolor='none', lw=1, edgecolor='yellow')
# ax.add_patch(patch)
if (crossplane == 'XZ' or crossplane == 'YZ') and flow_total > 0:
from matplotlib.path import Path
scanSP = np.linspace(-factor * x[-1], factor * x[-1], npts)
min_SP = -factor * x[-1]
step_SP = 2.0 * factor * x[-1] / (flow_total - 1)
x0, y0, z0 = 0, 0, 0
max_length = factor * x[-1] * 10
# max_length=factor*x[-1]*5
max_angle = np.pi / 160
if is_flow_extend:
rg = range(0, flow_total * 5 + 1)
else:
rg = range(0, flow_total)
for flow in rg:
if crossplane == 'XZ':
if is_flow_extend:
x0 = min_SP * 2 + flow * step_SP
else:
x0 = min_SP + flow * step_SP
z0 = min_SP
# y0 = x[-1]/20
elif crossplane == 'YZ':
if is_flow_extend:
y0 = min_SP * 2 + flow * step_SP
else:
y0 = min_SP + flow * step_SP
z0 = min_SP
# x0 = x[-1]/20
flow_xSP, flow_ySP, flow_zSP = GetFlow3D(
x0, y0, z0, max_length, max_angle, x, m, pl)
if crossplane == 'XZ':
flow_z_plot = flow_zSP * WL / 2.0 / np.pi
flow_f_plot = flow_xSP * WL / 2.0 / np.pi
elif crossplane == 'YZ':
flow_z_plot = flow_zSP * WL / 2.0 / np.pi
flow_f_plot = flow_ySP * WL / 2.0 / np.pi
verts = np.vstack(
(flow_z_plot, flow_f_plot)).transpose().tolist()
codes = [Path.LINETO] * len(verts)
codes[0] = Path.MOVETO
path = Path(verts, codes)
#patch = patches.PathPatch(path, facecolor='none', lw=0.2, edgecolor='white',zorder = 2.7)
patch = patches.PathPatch(
path, facecolor='none', lw=0.7, edgecolor='white', zorder=1.9, alpha=0.7)
ax.add_patch(patch)
# ax.plot(flow_z_plot, flow_f_plot, 'x', ms=2, mew=0.1,
# linewidth=0.5, color='k', fillstyle='none')
finally:
terms, Qext, Qsca, Qabs, Qbk, Qpr, g, Albedo, S1, S2 = scattnlay(
np.array([x]), np.array([m]))
print("Qabs = " + str(Qabs))
conc_label = conc_labels[ii]
ax.set_ylabel(conc_label,rotation=0,ha='right', fontsize=mpl.rcParams['font.size'])
if ii!=10:
ax.set_xlabel('')
ax.set_xticks([])
if ii == 5:
ax.text(-0.35,0.5,'fluorescein [M]', rotation=90,ha='right', fontsize=mpl.rcParams['font.size'],transform=ax.transAxes)
if ii == 0:
labeler.label_subplot(ax,'A')
vmin = 1e0
vmax = 1E7
#panel B
ax = plt.subplot(gs[0:9,1])
im = ax.imshow(sort_counts , interpolation='nearest', cmap=mpl.cm.hot, norm=LogNorm(vmin=vmin, vmax=vmax))
ax.set_ylabel('fluorescein [M]',labelpad=10)
ticks = range(11)
labels = ['0'] + ['$10^{%1.1f}$'%x for x in np.arange(-9.5,-4.5,0.5)]
ax.set_yticks(ticks)
ax.set_yticklabels(labels)
ax.set_xlabel('bin', labelpad=1)
ax.xaxis.set_major_locator(MaxNLocator(integer=True))
plt.title('cells',fontsize=mpl.rcParams['font.size'])
labeler.label_subplot(ax,'B')
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1/30.)
pad = axes_size.Fraction(0.75, width)
cax = divider.append_axes("right", size=width, pad=pad)
int_density = np.transpose(int_density)
x_density = np.transpose(x_density)
y_density = np.transpose(y_density)
int_density_refined = int_density.copy()
int_density_refined[int_density_refined < threshold] = 0.0
plt.imshow(int_density_refined,
origin='lower',
cmap=cm.jet,
extent=(x_density[0, 0], x_density[0,
-1], y_density[0,
0], y_density[-1,
0]),
aspect='auto',
norm=LogNorm(vmin=0.01, vmax=0.6),
interpolation="nearest")
#ax2.set_ylabel('Intensity/$\mu$T',fontsize=16)
#plt.xlim(x_density[0,0],x_density[-1,0])
#plt.ylim(y_density[0,0],y_density[0,-1])
plt.xlabel('Age/yr', fontsize=16)
plt.ylabel('Intensity/$\mu$T', fontsize=16)
cb = plt.colorbar(ticks=[0.01, 0.1, 0.2, 0.3, 0.4, 0.5, .6],
orientation='vertical',
format='$%.2f$')
#cb = plt.colorbar(ticks=[0.1, 0.2, 0.3, 0.4, 0.5, 0.6,0.7, 0.8,0.9, 1],
# orientation='vertical')
cb.set_label('Probability', fontsize=16)
print("Reading " + directory + " ...")
for file in os.listdir(base_loc + "/" + directory):
if fnmatch.fnmatch(file, '*_coverage_pc.obj'):
filepath = base_loc + "/" + directory + "/" + file
break
coordinates = np.loadtxt(filepath, dtype=str)
print("Done loading ...")
coordinates = coordinates[coordinates[:, 0] == "v", 1:].astype(float)
print("Done pruning ...")
longitudes = np.arctan2(coordinates[:, 1], coordinates[:,
0]) * 180. / np.pi
latitudes = np.arctan(coordinates[:, 2] / np.linalg.norm(
coordinates[:, 0:2], axis=1)) * 180. / np.pi
# radii = np.linalg.norm()
print("Done computing ...")
plt.hist2d(longitudes, latitudes, bins=(50, 25), norm=LogNorm(), cmin=30)
plt.xlabel("Longitude (deg)")
plt.ylabel("Latitude (deg)")
plt.title("Coverage, case " + directory.split("_")[1])
plt.colorbar()
plt.tight_layout()
plt.show()
# plt.savefig("/Users/bbercovici/GDrive/CUBoulder/Research/conferences/GNSKi_2019/paper/Figures/coverage_" + directory + ".pdf")
plt.clf()
data2 = np.random.randn(100, 2) + np.array([20, 30])
data = np.vstack([data1, data2])
print data
# display predicted scores by the model as a contour plot
x = np.linspace(-20.0, 40.0)
y = np.linspace(-20.0, 40.0)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
ax = []
fig, ax = plt.subplots(1, 3, figsize=(20, 10))
fig.subplots_adjust(hspace=.4)
# Plot models for various components
for components in range(1, 4):
gmm = GMM(n_components=components, covariance_type='full')
gmm.fit(data)
Z = -gmm.score_samples(XX)[0]
Z = Z.reshape(X.shape)
CS = ax[components - 1].contour(X,
Y,
Z,
norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
ax[components - 1].scatter(data[:, 0], data[:, 1], .8)
plt.colorbar(CS, shrink=0.8, extend='both')
plt.axis('tight')
plt.show()
def plot_single_heatmap_general(self, heatmap_metric_specification,
heatmap_axes_specification):
# data extraction
output_path, filename = self._construct_output_path_and_filename(
heatmap_metric_specification, heatmap_axes_specification)
logger.debug("output_path is {};\t filename is {}".format(
output_path, filename))
if not self.overwrite_existing_files and os.path.exists(filename):
logger.info(
"Skipping generation of {} as this file already exists".format(
filename))
return
xaxis_parameters = self.extract_parameter_values(
heatmap_axes_specification['x_axis_parameter'])
yaxis_parameters = self.extract_parameter_values(
heatmap_axes_specification['y_axis_parameter'])
# all heatmap values will be stored in X
X = np.zeros((len(yaxis_parameters), len(xaxis_parameters)))
fig, ax = plt.subplots(figsize=(FIGSIZE[0] - 0.75, FIGSIZE[1]))
min_number_of_observed_values = 10000000000000
max_number_of_observed_values = 0
observed_values = np.empty(0)
for x_index, x_val in enumerate(xaxis_parameters):
# all scenario indices which has x_val as xaxis parameter (e.g. node_resource_factor = 0.5
sub_dict = self.data_dict[x_val]
for y_index, y_val in enumerate(yaxis_parameters):
results = self.data_dict[x_val][y_val]
values = [
heatmap_metric_specification['lookup_function'](result)
for result in results
]
if 'metric_filter' in heatmap_metric_specification:
values = [
value for value in values
if heatmap_metric_specification['metric_filter'](value)
]
observed_values = np.append(observed_values, values)
if len(values) < min_number_of_observed_values:
min_number_of_observed_values = len(values)
if len(values) > max_number_of_observed_values:
max_number_of_observed_values = len(values)
logger.debug("values are {}".format(values))
if heatmap_metric_specification[
"plot_type"] == HeatmapPlotType.Simple_Treewidth_Evaluation_Max:
m = np.max(values)
logger.debug("max is {}".format(m))
elif heatmap_metric_specification[
"plot_type"] == HeatmapPlotType.Simple_Treewidth_Evaluation_Average:
m = np.mean(values)
logger.debug("mean is {}".format(m))
else:
raise ValueError("Invalid HeatmapPlotType")
if 'rounding_function' in heatmap_metric_specification:
rounded_m = heatmap_metric_specification[
'rounding_function'](m)
else:
rounded_m = float("{0:.1f}".format(round(m, 2)))
X[y_index, x_index] = rounded_m
if not self.paper_mode:
if min_number_of_observed_values == max_number_of_observed_values:
solution_count_string = "{} values per square".format(
min_number_of_observed_values)
else:
solution_count_string = "between {} and {} values per square".format(
min_number_of_observed_values,
max_number_of_observed_values)
ax.tick_params(axis="both", **HEATMAP_MAJOR_TICK_PARAMS)
if self.paper_mode:
ax.set_title(heatmap_metric_specification['name'],
fontsize=PLOT_TITLE_FONT_SIZE)
else:
title = heatmap_metric_specification['name'] + "\n"
title += solution_count_string + "\n"
title += "min: {:.2f}; mean: {:.2f}; max: {:.2f}".format(
np.nanmin(observed_values), np.nanmean(observed_values),
np.nanmax(observed_values))
ax.set_title(title)
norm = LogNorm(vmin=X[X > 0].min(), vmax=X.max())
heatmap = ax.pcolor(
X,
cmap=heatmap_metric_specification['cmap'],
vmin=heatmap_metric_specification['vmin'],
vmax=heatmap_metric_specification['vmax'],
norm=norm,
)
if not self.paper_mode:
fig.colorbar(heatmap,
label=heatmap_metric_specification['name'] +
' - mean in blue')
else:
cbar = fig.colorbar(heatmap)
if 'colorbar_ticks' in heatmap_metric_specification:
ticks = heatmap_metric_specification['colorbar_ticks']
tick_labels = [str(tick).ljust(3) for tick in ticks]
cbar.set_ticks(ticks)
cbar.set_ticklabels(tick_labels)
cbar.ax.tick_params(labelsize=TICK_LABEL_FONT_SIZE)
else:
print "No colorbar tick labels were specified for {}".format(
heatmap_metric_specification["name"])
# for label in cbar.ax.get_yticklabels():
# label.set_fontproperties(font_manager.FontProperties(family="Courier New",weight='bold'))
cbar.ax.tick_params(**HEATMAP_COLORBAR_TICK_PARAMS)
if "x_axis_ticks" in heatmap_axes_specification:
tick_locations = [
xaxis_parameters.index(x)
for x in heatmap_axes_specification["x_axis_ticks"]
]
tick_locations = np.array(tick_locations) + 0.5
ax.set_xticks(tick_locations, minor=False)
tick_locations_minor = [
xaxis_parameters.index(x)
for x in heatmap_axes_specification["x_axis_ticks_minor"]
]
ax.set_xticks(tick_locations_minor, minor=True)
x_labels = map(
heatmap_axes_specification["x_axis_tick_formatting"],
heatmap_axes_specification["x_axis_ticks"])
ax.set_xticklabels(x_labels,
minor=False,
fontsize=TICK_LABEL_FONT_SIZE)
else:
ax.set_xticks(np.arange(X.shape[1]) + 0.5, minor=False)
if "y_axis_ticks" in heatmap_axes_specification:
tick_locations = [
yaxis_parameters.index(x)
for x in heatmap_axes_specification["y_axis_ticks"]
]
tick_locations = np.array(tick_locations) + 0.5
ax.set_yticks(tick_locations, minor=False)
tick_locations_minor = [
yaxis_parameters.index(x)
for x in heatmap_axes_specification["y_axis_ticks_minor"]
]
ax.set_yticks(tick_locations_minor, minor=True)
y_labels = map(
heatmap_axes_specification["y_axis_tick_formatting"],
heatmap_axes_specification["y_axis_ticks"])
ax.set_yticklabels(y_labels,
minor=False,
fontsize=TICK_LABEL_FONT_SIZE)
else:
ax.set_yticks(np.arange(X.shape[0]) + 0.5, minor=False)
# column_labels = yaxis_parameters
ax.set_xlabel(heatmap_axes_specification['x_axis_title'],
fontsize=X_AXIS_LABEL_FONT_SIZE)
ax.set_ylabel(heatmap_axes_specification['y_axis_title'],
fontsize=Y_AXIS_LABEL_FONT_SIZE)
# ax.set_yticklabels(column_labels, minor=False, fontsize=Y_AXIS_TICK_LABEL_FONT_SIZE)
self._show_and_or_save_plots(output_path, filename)
:param filter: str, filter name
:param fpm: focal plane mask
:param ppm: pupil plane mask - Lyot stop
:return:
"""
nc = webbpsf.NIRCam()
nc.filter = filter
nc.image_mask = fpm
nc.pupil_mask = ppm
return nc
if __name__ == '__main__':
nc_coro = setup_coro('F335M', 'MASK335R', 'CIRCLYOT')
nc_coro, ote_coro = webbpsf.enable_adjustable_ote(nc_coro)
ote_coro.zero()
#ote_coro._apply_hexikes_to_seg('A1', [1e-6])
#ote_coro._apply_hexikes_to_seg('A3', [1e-6])
#ote_coro.move_seg_local('A6', xtilt=0.5)
psf = nc_coro.calc_psf(oversample=1)
psf = psf[1].data
plt.subplot(1, 2, 1)
ote_coro.display_opd()
plt.subplot(1, 2, 2)
plt.imshow(psf, norm=LogNorm())
plt.show()
A = A + A.T
X = A.copy()
ct = 0
f, ax = plt.subplots(2,nprint,sharey=True,figsize=(12,6))
for i in range(niter):
Q, R = np.linalg.qr(X)
X = R @ Q
if i % niterprint == 0:
I, J = np.where(np.abs(X) < 1e-13)
Xtmp = X.copy()
Xtmp[I,J] = 0.0
im = ax[0,ct].imshow(np.abs(Xtmp.real), cmap=plt.cm.winter, norm=LogNorm())
ax[0,ct].axis('off')
if np.abs(Xtmp.imag).max() > 1e-13:
im = ax[1,ct].imshow(np.abs(Xtmp.imag), cmap=plt.cm.winter, norm=LogNorm())
ax[1,ct].axis('off')
ct += 1
f.colorbar(im, ax=ax.ravel().tolist(), shrink=0.95)
# In[79]:
Xtmp
def show_hexbin(axes, x, y):
axes.hexbin(x, y, cmap='Purples', gridsize=40, norm=LogNorm(), mincnt=1)
def plot_contour(*opts,
fxn_name,
animate_gif=True,
fig_size=None,
save_f=True,
f_name='v1',
in_type=None):
def init():
for line in lines:
line.set_data([], [])
return lines
def animate(i):
num1 = int(x2[i])
for lnum, (line, scat) in enumerate(zip(lines, scats)):
if num1 < dp[lnum]:
# print(i, dp[lnum])
line.set_data(
xlist[lnum][:num1],
ylist[lnum][:num1]) # set data for each line separately.
scat.set_offsets([xlist[lnum][num1], ylist[lnum][num1]])
line.set_label(nn[lnum]) # set the label and draw the legend
plt.legend(loc="upper left")
return lines
if fig_size == 'small':
fig, ax = plt.subplots(figsize=(6, 4))
else:
fig, ax = plt.subplots(figsize=(8.5, 6.8))
plt.tight_layout()
data, minima, x_lims, y_lims = plot_fxn(fxn_name, 'contour')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_xlim(x_lims)
ax.set_ylim(y_lims)
ax.contour(*data,
levels=np.logspace(-.5, 5, 35),
norm=LogNorm(),
cmap='viridis',
alpha=0.7) #cmap=plt.cm.jet)
ax.plot(*minima[0:2], 'x', markersize=12, mew=2, color='k')
xlist, ylist, zlist, nn, dp = get_dlists(opts, in_type)
n = len(xlist)
# print(len(xlist))
if fxn_name == 'rosenbrock':
if in_type == 'sdict':
c = cm.rainbow_r(np.linspace(0, 1, n))
else:
c = cm.jet(np.linspace(0, 1, n))
else:
c = cm.rainbow(np.linspace(0, 1, n))
if animate_gif == False:
for k in range(n):
x_history = np.array(xlist[k])
y_history = np.array(ylist[k])
path = np.concatenate(
(np.expand_dims(x_history, 1), np.expand_dims(y_history, 1)),
axis=1).T
ax.quiver(path[0, :-1],
path[1, :-1],
path[0, 1:] - path[0, :-1],
path[1, 1:] - path[1, :-1],
scale_units='xy',
angles='xy',
width=0.003,
scale=1,
color=c[k],
label=nn[k])
plt.legend(loc="upper left")
if save_f == True:
plt.savefig('images/{}_path.png'.format(fxn_name))
else:
line, = ax.plot([], [], lw=2) #, markersize=12)
lines = []
scats = []
for index in range(n):
l_obj = ax.plot([], [], lw=2, color=c[index])[0]
lines.append(l_obj)
s_obj = ax.scatter([], [], lw=2, color=c[index])
scats.append(s_obj)
num_min = int(len(xlist[0]) / 50)
# print(num_min)
x2 = np.rint(np.linspace(0, len(xlist[1]), endpoint=False,
num=200)) # fix this
# print(x2)
# x2 = np.arange(len(xlist[0]))
# blit=True --> only re-draw the parts that have changed.
scat = ax.scatter(
[], []) # Set the dot at some arbitrary position initially
anim = animation.FuncAnimation(fig,
animate,
init_func=init,
frames=len(x2),
interval=1,
blit=True)
anim.save('images/{}_contour_{}.gif'.format(fxn_name, f_name),
dpi=60,
writer="imagemagick")
plt.show()
X_amplitude=100.,
# parameter controling smoothness of the absorbing boundary, if the latter is used
alpha=0.02,
K=lambda p: 0.5 * p**2,
diff_K=lambda p: p,
# the soft core Coulomb potential
V=lambda x: -1. / np.sqrt(x**2 + 1.37),
# the derivative of the potential to calculate Ehrenfest
diff_V=lambda x: x * np.power(x**2 + 1.37, -1.5),
)
# This is how to make logarithmic color plot
norm = LogNorm(vmin=1e-12, vmax=0.1)
#########################################################################
#
# Test propagation under time independent potential
#
#########################################################################
plt.subplot(121)
plt.title(
"No absorbing boundary time independent potential, $|\\Psi(x, t)|^2$")
test(SplitOpSchrodinger1D, params)
plt.subplot(122)
plt.title("Absorbing boundary time independent potential, $|\\Psi(x, t)|^2$")
test(SplitOpSchrodinger1DAbsBoundary, params)
def find_cut(ds, ds_lo, write_db=False):
#Make tier2 dataframe, get e_ftp and first pass calibration constants, then calibrate
t2 = ds.get_t2df()
t2 = t2.reset_index(drop=True)
calDB = ds.calDB
query = db.Query()
table = calDB.table("cal_pass1")
vals = table.all()
df_cal = pd.DataFrame(vals) # <<---- omg awesome
df_cal = df_cal.loc[df_cal.ds==ds_lo]
p1cal = df_cal.iloc[0]["p1cal"]
cal = p1cal * np.asarray(t2["e_ftp"])
hist, bins = np.histogram(cal, bins=2000, range=[0,2000])
b = (bins[:-1] + bins[1:]) / 2
# np.savez('ds{}'.format(ds_lo), cal)
# np.savez('bins_ds{}'.format(ds_lo), b)
# plt.clf()
plt.title('DS{}'.format(ds_lo))
plt.plot(b, hist, ls="steps", linewidth=1.5)
plt.ylabel('Counts')
plt.xlabel('keV')
plt.tight_layout()
plt.show()
exit()
current = "current_max"
e_over_unc = cal / np.asarray(t2["e_ftp"])
y0 = np.asarray(t2[current])
a_over_e = y0 * e_over_unc / cal
y = linear_correction(cal, a_over_e)
# dep_range = [1530,1620]
# hist, bins = np.histogram(cal, bins=450, range=dep_range)
# hist = hist * 5
#
def gauss(x, *params):
y = np.zeros_like(x)
for i in range(0, len(params) - 1, 3):
x0 = params[i]
a = params[i + 1]
sigma = params[i + 2]
y += a * np.exp(-(x - x0)**2 / (2 * sigma**2))
y = y + params[-1]
return y
#
# p0_list = [1591, 200, 3, 4]
#
# par, pcov = curve_fit(
# gauss, bins[1:], hist, p0=p0_list)
# print(par)
# perr = np.sqrt(np.diag(pcov))
# print(perr)
#
# mu, amp, sig, bkg = par[0], par[1], par[2], par[-1]
# print("Scanning ", mu, " peak")
# ans = quad(gauss, 1583, 1600, args=(mu, amp, sig, bkg))
# counts = ans[0] - ((1600-1583)*bkg)
# print("Counts in ", mu, " peak is ", counts)
#
# cut = counts
# line = .4
#
# y1 = y[np.where(line < y)]
# x1 = cal[np.where(line < y)]
# # hist1, bins1 = np.histogram(x1, bins=500, range=[1500,1700])
# hist1, bins1 = np.histogram(x1, bins=450, range=[1530,1620])
# hist1 = hist1*5
#
# print("Finding optimal cut, keeping 90% of 1592 DEP")
# while cut > .9 * counts:
#
# y1 = y[np.where(line < y)]
# x1 = cal[np.where(line < y)]
#
# hist1, bins1 = np.histogram(x1, bins=450, range=dep_range)
# hist1 = hist1*5
#
# par1, pcov1 = curve_fit(
# gauss, bins1[1:], hist1, p0=p0_list)
# perr1 = np.sqrt(np.diag(pcov1))
#
# mu1, amp1, sig1, bkg1 = par1[0], par1[1], par1[2], par1[-1]
# ans1 = quad(gauss, 1583, 1600, args=(mu1, amp1, sig1, bkg1))
# cut = ans1[0] - ((1600-1583)*bkg1)
#
# line += .0005
line = .95
y1 = y[np.where(line < y)]
x1 = cal[np.where(line < y)]
y2 = y[np.where(line > y)]
x2 = cal[np.where(line > y)]
np.savez('thorium', x1)
np.savez('Ac', x2)
# print(line, cut)
plt.hist2d(cal, y, bins=[1000,200], range=[[0, 2000], [0, 2]], norm=LogNorm(), cmap='jet')
plt.hlines(line, 0, 2000, color='r', linewidth=1.5)
cbar = plt.colorbar()
plt.title("Dataset {}".format(ds_lo))
plt.xlabel("Energy (keV)", ha='right', x=1)
plt.ylabel("A/Eunc", ha='right', y=1)
cbar.ax.set_ylabel('Counts')
plt.tight_layout()
plt.show()
hist, bins = np.histogram(cal, bins=2000, range=[0,2000])
hist1, bins1 = np.histogram(x1, bins=2000, range=[0,2000])
hist2, bins2 = np.histogram(x2, bins=2000, range=[0,2000])
p0_list = [1593, 200, 3, 4]
par, pcov = curve_fit(
gauss, bins1[1:], hist1, p0=p0_list)
print(par)
perr = np.sqrt(np.diag(pcov))
print(perr)
plt.clf()
# plt.semilogy(bins[1:], hist, color='black', ls="steps", linewidth=1.5, label='Calibrated Energy: Dataset {}'.format(ds_lo))
plt.semilogy(bins1[1:], hist1, '-r', ls="steps", linewidth=1.5, label='AvsE Cut: Dataset {}'.format(ds_lo))
plt.ylabel('Counts')
plt.xlabel('keV')
plt.legend()
plt.tight_layout()
plt.show()
plt.clf()
plt.semilogy(bins2[1:], hist2, ls="steps", linewidth=1.5)
plt.title('Ac spectra')
plt.ylabel('Counts')
plt.xlabel('keV')
plt.tight_layout()
plt.show()
if write_db:
table = calDB.table("A/E_cut")
for dset in ds.ds_list:
row = {"ds":dset, "line":line}
table.upsert(row, query.ds == dset)
def plt_snapshot(s, h, num, axis='y', savdir=None, savfig=False):
mpl.rcParams['font.size'] = 13
n0 = s.par['problem']['n0']
dfi = s.dfi
if s.par['configure']['radps'] == 'ON':
fields = [
'r', 'nH', '2nH2', 'nHI', 'nHII', 'ne', 'xe', 'xHI', '2xH2',
'xHII', 'T', 'pok', 'chi_PE', 'chi_LW', 'chi_LW_dust', 'heat_rate',
'cool_rate'
]
new_cool = True
elif s.par['configure']['new_cooling'] == 'ON':
fields = [
'r', 'nH', '2nH2', 'nHI', 'nHII', 'ne', 'xe', 'xHI', '2xH2',
'xHII', 'T', 'pok', 'heat_rate', 'cool_rate'
]
new_cool = True
else:
fields = ['r', 'nH', 'T', 'pok', 'heat_rate', 'cool_rate']
new_cool = False
ds = s.load_vtk(num)
Lx = ds.domain['Lx'][0]
slc = ds.get_slice(axis, fields)
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
axes = axes.flatten()
plt.sca(axes[0])
if new_cool:
fields = ('2nH2', 'nHI', 'nHII', 'ne')
else:
fields = ('nH', )
for f in fields:
plt.scatter(slc['r'], slc[f], s=2.0, label=slc.dfi[f]['label'])
plt.xlim(0, 0.5 * 2.0**0.5 * Lx)
plt.ylim(1e-6 * n0, 20.0 * n0)
plt.yscale('log')
plt.legend(loc=4)
plt.sca(axes[1])
if new_cool:
fields = ('2xH2', 'xHI', 'xHII', 'xe')
else:
fields = ('nH', )
for f in fields:
plt.scatter(slc['r'], slc[f], s=2.0, label=slc.dfi[f]['label'])
plt.xlim(0, 0.5 * 2.0**0.5 * Lx)
plt.ylim(1e-6, 2.0)
plt.yscale('log')
plt.legend(loc=4)
plt.sca(axes[2])
for f in ('T', 'pok'):
plt.scatter(slc['r'], slc[f], s=2.0, label=slc.dfi[f]['label'])
plt.xlim(0, 0.5 * 2.0**0.5 * Lx)
plt.ylim(1e1, 1e7)
plt.yscale('log')
plt.legend(loc=4)
plt.sca(axes[4])
for f in ('cool_rate', 'heat_rate'):
plt.scatter(slc['r'], slc[f], s=2.0, label=f)
plt.xlim(0, 0.5 * 2.0**0.5 * Lx)
plt.ylim(1e-25, 1e-18)
plt.yscale('log')
plt.legend(loc=1)
plt.sca(axes[5])
# d = ds.get_slice(axis, ['r','nH','xHI','xHII','xe','rad_energy_density_PH','T'])
# hnu_PH = (s.par['radps']['hnu_PH']*au.eV).cgs.value
# sigma_PH = s.par['radps']['sigma_HI_PH']
# d['xi_ph'] = ac.c.cgs.value*d['rad_energy_density_PH']*s.u.energy_density.value/hnu_PH*sigma_PH
# d['tphoti'] = d['xi_ph']*d['xHI']
# d['treci'] = d['xHII']*d['nH']*d['xe']*2.59e-13*(d['T']*1e-4)**-0.7
# d['tHII'] = 1.0/np.abs(d['tphoti'] - d['treci'])
# plt.scatter(d['r'],d['tHII'],s=2.0,label=['tHII'])
# plt.yscale('log')
d = ds.get_field(['nH', 'cool_rate', 'T'])
plt.hist2d(d['nH'].data.flatten(),
d['T'].data.flatten(),
bins=(np.logspace(np.log10(n0 * 1e-5), np.log10(n0 * 1e2),
100), np.logspace(1, 7, 100)),
norm=LogNorm(),
weights=d['nH'].values.flatten())
plt.xlabel(dfi['nH']['label'])
plt.ylabel(dfi['T']['label'])
plt.xscale('log')
plt.yscale('log')
plt.xlim(1e-5 * n0, 1e2 * n0)
plt.ylim(1e1, 1e7)
# for f in ('chi_PE','chi_LW', 'chi_LW_dust'):
# plt.scatter(slc['r'], slc[f], s=2.0, label=slc.dfi[f]['label'])
# plt.xlim(0, 0.5*2.0**0.5*Lx)
# #plt.ylim(1e0,1e6)
# plt.ylim(1e5,1e15)
# plt.yscale('log')
# plt.legend(loc=1)
# Temperature slice
# slc['T'].plot.imshow(ax=axes[3], norm=LogNorm(1e1,1e3),
# label=slc.dfi['T']['label'],
# cbar_kwargs=dict(label=slc.dfi['T']['label']))
f = 'nH'
slc[f].plot.imshow(
ax=axes[3],
norm=LogNorm(1e-4, 1e4), # norm=slc.dfi[f]['norm'],
label=slc.dfi[f]['label'],
cmap='Spectral_r',
cbar_kwargs=dict(label=slc.dfi[f]['label']))
axes[3].set_aspect('equal')
plt.suptitle(f'Model: {s.basename} ' + \
r'num={0:2d} time={1:f}'.format(num, ds.domain['time']))
print('time:', ds.domain['time'])
plt.tight_layout()
plt.subplots_adjust(top=0.94)
if savfig:
if savdir is None:
savdir = osp.join('/tigress/jk11/figures/FEEDBACK-TEST',
s.basename)
if not osp.exists(savdir):
os.makedirs(savdir)
plt.savefig(osp.join(savdir, 'slice_{0:04d}.png'.format(num)), dpi=200)
return ds
alpha[np.isnan(alpha)] = 0.0
np.clip(alpha, a_min=0.0, a_max=1.0, out=alpha)
Rd = convolve(R, kernel)
Bd = convolve(B, kernel)
Gd = convolve(G, kernel)
A = convolve(alpha, kernel)
rgb = np.transpose(np.array([Rd, Gd, Bd]), axes=(1, 2, 0)).astype("float32")
rgb *= alpha[:, :, np.newaxis]
cmap = plt.cm.viridis
cmap.set_bad(color="black")
fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(20, 10))
ax1.imshow(cts, origin='lower', norm=LogNorm(), cmap=cmap)
ax2.imshow(rgb, origin='lower')
fig.savefig("%s_%sdeg.png" % (basenm, angle))
hdur = fits.ImageHDU(data=Rd * A)
hdur.name = "red"
hdur.writeto("%s_red_%sdeg.fits" % (basenm, angle), overwrite=True)
hdub = fits.ImageHDU(data=Bd * A)
hdub.name = "blue"
hdub.writeto("%s_blue_%sdeg.fits" % (basenm, angle), overwrite=True)
hdug = fits.ImageHDU(data=Gd * A)
hdug.name = "green"
hdug.writeto("%s_green_%sdeg.fits" % (basenm, angle), overwrite=True)
fits.ImageHDU(data=rgb).writeto("%s_rgb_%sdeg.fits" % (basenm, angle),
overwrite=True)
def colorNearHist(galaxies, f):
r"""
Creates a 2d histogram of galaxies with color on the x-axis and
number of nearby neighbors on the y-axis
Parameters
galaxies - Type: dict. A dictionary of galaxy objects to be plotted
f - Type: str. The name of the plot's output file
Returns none but prints two plots to the specified output files.
"""
errFlag = -9999
galaxyList = list(galaxies.values())
color = [galaxy.color for galaxy in galaxyList if galaxy.color > errFlag]
colorSmall = [
galaxy.color for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn > 0
]
colorSmall2 = [
galaxy.color for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn == 0
]
numNear = [
galaxy.nearby for galaxy in galaxyList if galaxy.color > errFlag
]
numNearSmall = [
galaxy.nearby for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn > 0
]
numNearSmall2 = [
galaxy.nearby for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn == 0
]
# Plot the histograms
plt.hist2d(colorSmall2,
numNearSmall2,
bins=100,
norm=LogNorm(),
cmin=1,
cmap=plt.cm.inferno)
plt.title("Color vs. Number of Neighbors", fontsize=14)
plt.xlabel("Color (u - r)", fontsize=14)
plt.ylabel("Number of nearby neighbors", fontsize=14)
plt.colorbar()
plt.savefig(f + 'NoAGN.png')
print("Created near hist 1")
plt.hist2d(colorSmall,
numNearSmall,
bins=100,
norm=LogNorm(),
cmin=1,
cmap=plt.cm.inferno)
plt.savefig(f + 'AGNonly.png')
print("Created near hist 2")
plt.clf()
# Perform the KS test on the groups
colorZeroes = [
galaxy.color for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn > 0 and galaxy.nearby == 0
]
colorZeroes2 = [
galaxy.color for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn == 0 and galaxy.nearby == 0
]
colorOnes = [
galaxy.color for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn > 0 and galaxy.nearby == 1
]
colorOnes2 = [
galaxy.color for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn == 0 and galaxy.nearby == 1
]
colorTwos = [
galaxy.color for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn > 0 and galaxy.nearby == 2
]
colorTwos2 = [
galaxy.color for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn == 0 and galaxy.nearby == 2
]
colorThrees = [
galaxy.color for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn > 0 and galaxy.nearby == 3
]
colorThrees2 = [
galaxy.color for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn == 0 and galaxy.nearby == 3
]
colorFours = [
galaxy.color for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn > 0 and galaxy.nearby == 4
]
colorFours2 = [
galaxy.color for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn == 0 and galaxy.nearby == 4
]
# print("Color KS Test:", ks_2samp(np.array(colorSmall), np.array(colorSmall2)))
# print("NumNear KS Test:", ks_2samp(np.array(numNearSmall), np.array(numNearSmall2)))
print("KS Test 0:",
stats.ks_2samp(np.array(colorZeroes), np.array(colorZeroes2)))
print("KS Test 1:",
stats.ks_2samp(np.array(colorOnes), np.array(colorOnes2)))
print("KS Test 2:",
stats.ks_2samp(np.array(colorTwos), np.array(colorTwos2)))
print("KS Test 3:",
stats.ks_2samp(np.array(colorThrees), np.array(colorThrees2)))
print("KS Test 4:",
stats.ks_2samp(np.array(colorFours), np.array(colorFours2)))
colorZeroes = [
(galaxy.objId, galaxy.color) for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn > 0 and galaxy.nearby == 0
]
colorZeroes2 = [
(galaxy.objId, galaxy.color) for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn == 0 and galaxy.nearby == 0
]
colorOnes = [
(galaxy.objId, galaxy.color) for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn > 0 and galaxy.nearby == 1
]
colorOnes2 = [
(galaxy.objId, galaxy.color) for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn == 0 and galaxy.nearby == 1
]
colorTwos = [
(galaxy.objId, galaxy.color) for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn > 0 and galaxy.nearby == 2
]
colorTwos2 = [
(galaxy.objId, galaxy.color) for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn == 0 and galaxy.nearby == 2
]
colorThrees = [
(galaxy.objId, galaxy.color) for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn > 0 and galaxy.nearby == 3
]
colorThrees2 = [
(galaxy.objId, galaxy.color) for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn == 0 and galaxy.nearby == 3
]
colorFours = [
(galaxy.objId, galaxy.color) for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn > 0 and galaxy.nearby == 4
]
colorFours2 = [
(galaxy.objId, galaxy.color) for galaxy in galaxyList
if galaxy.color > errFlag and galaxy.agn == 0 and galaxy.nearby == 4
]
with open('galaxyData/withAGN.csv', 'w') as f:
f.write("objID,numNear,color\n")
for i in range(0, len(colorZeroes)):
f.write(
str(colorZeroes[i][0]) + ",0," + str(colorZeroes[i][1]) + "\n")
for i in range(0, len(colorOnes)):
f.write(str(colorOnes[i][0]) + ",1," + str(colorOnes[i][1]) + "\n")
for i in range(0, len(colorTwos)):
f.write(str(colorTwos[i][0]) + ",2," + str(colorTwos[i][1]) + "\n")
for i in range(0, len(colorThrees)):
f.write(
str(colorThrees[i][0]) + ",3," + str(colorThrees[i][1]) + "\n")
for i in range(0, len(colorFours)):
f.write(
str(colorFours[i][0]) + ",4," + str(colorFours[i][1]) + "\n")
f.close()
with open('galaxyData/withoutAGN.csv', 'w') as f:
f.write("objID,numNear,color\n")
for i in range(0, len(colorZeroes2)):
f.write(
str(colorZeroes2[i][0]) + ",0," + str(colorZeroes2[i][1]) +
"\n")
for i in range(0, len(colorOnes2)):
f.write(
str(colorOnes2[i][0]) + ",1," + str(colorOnes2[i][1]) + "\n")
for i in range(0, len(colorTwos2)):
f.write(
str(colorTwos2[i][0]) + ",2," + str(colorTwos2[i][1]) + "\n")
for i in range(0, len(colorThrees2)):
f.write(
str(colorThrees2[i][0]) + ",3," + str(colorThrees2[i][1]) +
"\n")
for i in range(0, len(colorFours2)):
f.write(
str(colorFours2[i][0]) + ",4," + str(colorFours2[i][1]) + "\n")
f.close()
det = condor.Detector(distance=2., pixel_size=110E-6*ds, nx=1024/ds+1, ny=1024/ds+1, solid_angle_correction=False)
psphere = {"particle_sphere": condor.ParticleSphere(diameter=1E-9, material_type="water")}
pmap = {"particle_map": condor.ParticleMap(diameter=1E-9, material_type="water", geometry="icosahedron")}
patoms = {"particle_atoms": condor.ParticleAtoms(pdb_filename="%s/../../DNA.pdb" % this_dir)}
particles = [psphere, pmap, patoms]
if do_plot:
fig, (axs1, axs2) = pyplot.subplots(2, len(particles), figsize=(3*len(particles), 3*2))
for i,par in enumerate(particles):
E = condor.Experiment(src, par, det)
res = E.propagate()
data = res["entry_1"]["data_1"]["data"]
if do_plot:
axs1[i].set_title("2D: " + par.keys()[0])
lims = (data.min(), data.max())
axs1[i].imshow(data, norm=LogNorm(lims[0], lims[1]), cmap="gnuplot")
res = E.propagate3d()
data = res["entry_1"]["data_1"]["data"][int(1024/ds/2),:,:]
if do_plot:
axs2[i].set_title("3D slice: " + par.keys()[0])
axs2[i].imshow(data, norm=LogNorm(lims[0], lims[1]), cmap="gnuplot")
if do_plot:
fig.savefig("2Dvs3D.png", dpi=300)
pyplot.show()
def plot_clouds(
tag: str,
offset: Optional[Tuple[float, float]] = None,
output: Optional[str] = "clouds.pdf",
radtrans: Optional[read_radtrans.ReadRadtrans] = None,
composition: str = "MgSiO3",
) -> None:
"""
Function to plot the size distributions for a given cloud composition as function as pressure.
The size distributions are calculated for the median sample by using the radius_g (as function
of pressure) and sigma_g.
Parameters
----------
tag : str
Database tag with the posterior samples.
offset : tuple(float, float), None
Offset of the x- and y-axis label. Default values are used if set to ``None``.
output : str
Output filename for the plot. The plot is shown in an
interface window if the argument is set to ``None``.
radtrans : read_radtrans.ReadRadtrans, None
Instance of :class:`~species.read.read_radtrans.ReadRadtrans`. Not used if set to ``None``.
composition : str
Cloud composition (e.g. 'MgSiO3', 'Fe', 'Al2O3', 'Na2S', 'KCl').
Returns
-------
NoneType
None
"""
species_db = database.Database()
box = species_db.get_samples(tag)
median = box.median_sample
if (
f"{composition.lower()}_fraction" not in median
and "log_tau_cloud" not in median
and f"{composition}(c)" not in median
):
raise ValueError(
f"The mass fraction of the {composition} clouds is not found. The median "
f"sample contains the following parameters: {list(median.keys())}"
)
if output is None:
print(f"Plotting {composition} clouds...", end="", flush=True)
else:
print(f"Plotting {composition} clouds: {output}...", end="", flush=True)
mpl.rcParams["font.serif"] = ["Bitstream Vera Serif"]
mpl.rcParams["font.family"] = "serif"
plt.rc("axes", edgecolor="black", linewidth=2.5)
plt.figure(1, figsize=(4.0, 3.0))
gridsp = mpl.gridspec.GridSpec(1, 2, width_ratios=[4, 0.25])
gridsp.update(wspace=0.1, hspace=0.0, left=0, right=1, bottom=0, top=1)
ax1 = plt.subplot(gridsp[0, 0])
ax2 = plt.subplot(gridsp[0, 1])
radtrans.get_model(median)
cloud_index = radtrans.rt_object.cloud_species.index(f"{composition}(c)")
radius_g = radtrans.rt_object.r_g[:, cloud_index] * 1e4 # (cm) -> (um)
sigma_g = median["sigma_lnorm"]
r_bins = np.logspace(-3.0, 3.0, 1000)
radii = (r_bins[1:] + r_bins[:-1]) / 2.0
dn_dr = np.zeros((radius_g.shape[0], radii.shape[0]))
for i, item in enumerate(radius_g):
dn_dr[
i,
] = lognorm.pdf(radii, s=np.log(sigma_g), loc=0.0, scale=item)
ax1.tick_params(
axis="both",
which="major",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=5,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
labelbottom=True,
)
ax1.tick_params(
axis="both",
which="minor",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=3,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
labelbottom=True,
)
ax2.tick_params(
axis="both",
which="major",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=5,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
)
ax2.tick_params(
axis="both",
which="minor",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=3,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
)
xx_grid, yy_grid = np.meshgrid(radii, 1e-6 * radtrans.rt_object.press)
fig = ax1.pcolormesh(
xx_grid,
yy_grid,
dn_dr,
cmap="viridis",
shading="auto",
norm=LogNorm(vmin=1e-10 * np.amax(dn_dr), vmax=np.amax(dn_dr)),
)
cb = Colorbar(ax=ax2, mappable=fig, orientation="vertical", ticklocation="right")
cb.ax.set_ylabel("dn/dr", rotation=270, labelpad=20, fontsize=11)
for item in radtrans.rt_object.press * 1e-6: # (bar)
ax1.axhline(item, ls="-", lw=0.1, color="white")
for item in radtrans.rt_object.cloud_radii * 1e4: # (um)
ax1.axvline(item, ls="-", lw=0.1, color="white")
ax1.text(
0.07,
0.07,
fr"$\sigma_\mathrm{{g}}$ = {sigma_g:.2f}",
ha="left",
va="bottom",
transform=ax1.transAxes,
color="black",
fontsize=13.0,
)
ax1.set_ylabel("Pressure (bar)", fontsize=13)
ax1.set_xlabel("Grain radius (µm)", fontsize=13)
ax1.set_xlim(radii[0], radii[-1])
ax1.set_ylim(
radtrans.rt_object.press[-1] * 1e-6, radtrans.rt_object.press[0] * 1e-6
)
if offset is not None:
ax1.get_xaxis().set_label_coords(0.5, offset[0])
ax1.get_yaxis().set_label_coords(offset[1], 0.5)
else:
ax1.get_xaxis().set_label_coords(0.5, -0.1)
ax1.get_yaxis().set_label_coords(-0.15, 0.5)
ax1.set_xscale("log")
ax1.set_yscale("log")
ax2.set_yscale("log")
print(" [DONE]")
if output is None:
plt.show()
else:
plt.savefig(output, bbox_inches="tight")
plt.clf()
plt.close()
def view_spectra(datacube,
title=None,
show=True,
logZ=False,
use_axis=True,
vlim=(None, None),
subplt_cols=3,
dx=None):
"""
view plot of intensity in each wavelength bin at a single (last) timestep
:param datacube: 3D spectral cube (n_wavelengths, nx, ny) at single timestep
:param title: string, must be set or will error!
:param show: flag possibly useful for plotting loops of things?
:param logZ: turn logscale plotting for Z axis on or off
:param use_axis: turn on/off using axis ticks, colorbar, etc
:param vlim: tuple of colorbar axis limits (min,max)
:param subplt_cols: number of subplots per row
:param dx: sampling of the image in m. Hardcoded to convert to um
:return:
"""
# Create figure & adjust subplot number, layout, size, whitespace
fig = plt.figure()
n_colors = len(datacube)
n_rows = int(np.ceil(n_colors / float(subplt_cols)) + 1)
plt.axis('off')
gs = gridspec.GridSpec(n_rows, subplt_cols, wspace=0.08, top=0.9)
# Title
if title is None:
warnings.warn("Plots without titles: Don't Do It!")
title = input("Please Enter Title: ")
pass
fig.suptitle(title, fontweight='bold', fontsize=16)
# Wavelength Strings for Subplot Titles
w_string = np.array(np.linspace(ap.wvl_range[0] * 1e9,
ap.wvl_range[1] * 1e9,
ap.n_wvl_final,
dtype=int),
dtype=str)
for w in range(n_colors):
ax = fig.add_subplot(gs[w])
ax.set_title(r'$\lambda$ = ' + f"{w_string[w]} nm")
slice = opx.extract_center(datacube[w])
# X,Y lables
if dx is not None:
dx[w] = dx[w] * 1e6 # [convert to um]
# dprint(f"sampling = {sampl[w]}")
tic_spacing = np.linspace(
0, slice.shape[0],
5) # 5 (number of ticks) is set by hand, arbitrarily chosen
tic_lables = np.round(
np.linspace(-dx[w] * sp.maskd_size / 2,
dx[w] * sp.maskd_size / 2, 5)).astype(
int) # nsteps must be same as tic_spacing
tic_spacing[0] = tic_spacing[0] + 1 # hack for edge effects
tic_spacing[-1] = tic_spacing[-1] - 1 # hack for edge effects
plt.xticks(tic_spacing, tic_lables, fontsize=6)
plt.yticks(tic_spacing, tic_lables, fontsize=6)
# plt.xlabel('[um]', fontsize=8)
# plt.ylabel('[um]', fontsize=8)
# Z-axis scale
if logZ:
if np.min(slice) < 0:
im = ax.imshow(slice,
interpolation='none',
origin='lower',
vmin=vlim[0],
vmax=vlim[1],
norm=SymLogNorm(linthresh=1e-5),
cmap="YlGnBu_r")
clabel = "Log Normalized Intensity"
else:
im = ax.imshow(slice,
interpolation='none',
origin='lower',
vmin=vlim[0],
vmax=vlim[1],
norm=LogNorm(),
cmap="YlGnBu_r")
clabel = "Log Normalized Intensity"
else:
im = ax.imshow(slice,
interpolation='none',
origin='lower',
vmin=vlim[0],
vmax=vlim[1],
cmap="YlGnBu_r")
clabel = "Normalized Intensity"
if use_axis == 'anno':
ax.annotate_axis(im, ax, datacube.shape[1])
if use_axis is None:
plt.axis('off')
if use_axis:
warnings.simplefilter("ignore", category=UserWarning)
gs.tight_layout(fig, pad=1.08,
rect=(0, 0, 1,
0.85)) # rect = (left, bottom, right, top)
# fig.tight_layout(pad=50)
cbar_ax = fig.add_axes([
0.55, 0.3, 0.2, 0.05
]) # Add axes for colorbar @ position [left,bottom,width,height]
cb = fig.colorbar(im, cax=cbar_ax, orientation='horizontal') #
cb.set_label(clabel)
if show is True:
plt.show(block=False)
def plot_opacities(
tag: str,
radtrans: read_radtrans.ReadRadtrans,
offset: Optional[Tuple[float, float]] = None,
output: Optional[str] = "opacities.pdf",
) -> None:
"""
Function to plot the line and continuum opacity
structure from the median posterior samples.
Parameters
----------
tag : str
Database tag with the posterior samples.
radtrans : read_radtrans.ReadRadtrans
Instance of :class:`~species.read.read_radtrans.ReadRadtrans`.
The parameter is not used if set to ``None``.
offset : tuple(float, float), None
Offset of the x- and y-axis label. Default values are used
if set to ``None``.
output : str, None
Output filename for the plot. The plot is shown in an
interface window if the argument is set to ``None``.
Returns
-------
NoneType
None
"""
if output is None:
print("Plotting opacities...", end="", flush=True)
else:
print(f"Plotting opacities: {output}...", end="", flush=True)
species_db = database.Database()
box = species_db.get_samples(tag)
median = box.median_sample
mpl.rcParams["font.serif"] = ["Bitstream Vera Serif"]
mpl.rcParams["font.family"] = "serif"
plt.rc("axes", edgecolor="black", linewidth=2.5)
plt.figure(1, figsize=(10.0, 6.0))
gridsp = mpl.gridspec.GridSpec(2, 5, width_ratios=[4, 0.25, 1.5, 4, 0.25])
gridsp.update(wspace=0.1, hspace=0.1, left=0, right=1, bottom=0, top=1)
ax1 = plt.subplot(gridsp[0, 0])
ax2 = plt.subplot(gridsp[1, 0])
ax3 = plt.subplot(gridsp[0, 1])
ax4 = plt.subplot(gridsp[1, 1])
ax5 = plt.subplot(gridsp[0, 3])
ax6 = plt.subplot(gridsp[1, 3])
ax7 = plt.subplot(gridsp[0, 4])
ax8 = plt.subplot(gridsp[1, 4])
radtrans.get_model(median)
# Line opacities
wavelength, opacity = radtrans.rt_object.get_opa(radtrans.rt_object.temp)
wavelength *= 1e4 # (um)
opacity_line = np.zeros(
(radtrans.rt_object.freq.shape[0], radtrans.rt_object.press.shape[0])
)
for item in opacity.values():
opacity_line += item
# Continuum opacities
opacity_cont_abs = radtrans.rt_object.continuum_opa
opacity_cont_scat = radtrans.rt_object.continuum_opa_scat
# opacity_cont_scat = radtrans.rt_object.continuum_opa_scat_emis
opacity_total = opacity_line + opacity_cont_abs + opacity_cont_scat
albedo = opacity_cont_scat / opacity_total
# if radtrans.scattering:
# opacity_cont = radtrans.rt_object.continuum_opa_scat_emis
# else:
# opacity_cont = radtrans.rt_object.continuum_opa_scat
ax1.tick_params(
axis="both",
which="major",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=5,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
labelbottom=False,
)
ax1.tick_params(
axis="both",
which="minor",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=3,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
labelbottom=False,
)
ax2.tick_params(
axis="both",
which="major",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=5,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
)
ax2.tick_params(
axis="both",
which="minor",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=3,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
)
ax3.tick_params(
axis="both",
which="major",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=5,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
)
ax3.tick_params(
axis="both",
which="minor",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=3,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
)
ax4.tick_params(
axis="both",
which="major",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=5,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
)
ax4.tick_params(
axis="both",
which="minor",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=3,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
)
ax5.tick_params(
axis="both",
which="major",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=5,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
labelbottom=False,
)
ax5.tick_params(
axis="both",
which="minor",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=3,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
labelbottom=False,
)
ax6.tick_params(
axis="both",
which="major",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=5,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
)
ax6.tick_params(
axis="both",
which="minor",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=3,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
)
ax7.tick_params(
axis="both",
which="major",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=5,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
)
ax7.tick_params(
axis="both",
which="minor",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=3,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
)
ax8.tick_params(
axis="both",
which="major",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=5,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
)
ax8.tick_params(
axis="both",
which="minor",
colors="black",
labelcolor="black",
direction="in",
width=1,
length=3,
labelsize=12,
top=True,
bottom=True,
left=True,
right=True,
)
ax1.xaxis.set_major_locator(MultipleLocator(1.0))
ax2.xaxis.set_major_locator(MultipleLocator(1.0))
ax1.xaxis.set_minor_locator(MultipleLocator(0.2))
ax2.xaxis.set_minor_locator(MultipleLocator(0.2))
ax5.xaxis.set_major_locator(MultipleLocator(1.0))
ax6.xaxis.set_major_locator(MultipleLocator(1.0))
ax5.xaxis.set_minor_locator(MultipleLocator(0.2))
ax6.xaxis.set_minor_locator(MultipleLocator(0.2))
# ax1.yaxis.set_major_locator(LogLocator(base=10.))
# ax2.yaxis.set_major_locator(LogLocator(base=10.))
# ax3.yaxis.set_major_locator(LogLocator(base=10.))
# ax4.yaxis.set_major_locator(LogLocator(base=10.))
# ax1.yaxis.set_minor_locator(LogLocator(base=1.))
# ax2.yaxis.set_minor_locator(LogLocator(base=1.))
# ax3.yaxis.set_minor_locator(LogLocator(base=1.))
# ax4.yaxis.set_minor_locator(LogLocator(base=1.))
xx_grid, yy_grid = np.meshgrid(wavelength, 1e-6 * radtrans.rt_object.press)
fig = ax1.pcolormesh(
xx_grid,
yy_grid,
np.transpose(opacity_line),
cmap="viridis",
shading="gouraud",
norm=LogNorm(vmin=1e-6 * np.amax(opacity_line), vmax=np.amax(opacity_line)),
)
cb = Colorbar(ax=ax3, mappable=fig, orientation="vertical", ticklocation="right")
cb.ax.set_ylabel("Line opacity (cm$^2$/g)", rotation=270, labelpad=20, fontsize=11)
fig = ax2.pcolormesh(
xx_grid,
yy_grid,
np.transpose(albedo),
cmap="viridis",
shading="gouraud",
norm=LogNorm(vmin=1e-4*np.amax(albedo), vmax=np.amax(albedo)),
)
cb = Colorbar(ax=ax4, mappable=fig, orientation="vertical", ticklocation="right")
cb.ax.set_ylabel(
"Single scattering albedo", rotation=270, labelpad=20, fontsize=11
)
fig = ax5.pcolormesh(
xx_grid,
yy_grid,
np.transpose(opacity_cont_abs),
cmap="viridis",
shading="gouraud",
norm=LogNorm(
vmin=1e-6 * np.amax(opacity_cont_abs), vmax=np.amax(opacity_cont_abs)
),
)
cb = Colorbar(ax=ax7, mappable=fig, orientation="vertical", ticklocation="right")
cb.ax.set_ylabel(
"Continuum absorption (cm$^2$/g)", rotation=270, labelpad=20, fontsize=11
)
fig = ax6.pcolormesh(
xx_grid,
yy_grid,
np.transpose(opacity_cont_scat),
cmap="viridis",
shading="gouraud",
norm=LogNorm(
vmin=1e-6 * np.amax(opacity_cont_scat), vmax=np.amax(opacity_cont_scat)
),
)
cb = Colorbar(ax=ax8, mappable=fig, orientation="vertical", ticklocation="right")
cb.ax.set_ylabel(
"Continuum scattering (cm$^2$/g)", rotation=270, labelpad=20, fontsize=11
)
ax1.set_ylabel("Pressure (bar)", fontsize=13)
ax2.set_xlabel("Wavelength (µm)", fontsize=13)
ax2.set_ylabel("Pressure (bar)", fontsize=13)
ax5.set_ylabel("Pressure (bar)", fontsize=13)
ax6.set_xlabel("Wavelength (µm)", fontsize=13)
ax6.set_ylabel("Pressure (bar)", fontsize=13)
ax1.set_xlim(wavelength[0], wavelength[-1])
ax2.set_xlim(wavelength[0], wavelength[-1])
ax5.set_xlim(wavelength[0], wavelength[-1])
ax6.set_xlim(wavelength[0], wavelength[-1])
ax1.set_ylim(
radtrans.rt_object.press[-1] * 1e-6, radtrans.rt_object.press[0] * 1e-6
)
ax2.set_ylim(
radtrans.rt_object.press[-1] * 1e-6, radtrans.rt_object.press[0] * 1e-6
)
ax5.set_ylim(
radtrans.rt_object.press[-1] * 1e-6, radtrans.rt_object.press[0] * 1e-6
)
ax6.set_ylim(
radtrans.rt_object.press[-1] * 1e-6, radtrans.rt_object.press[0] * 1e-6
)
if offset is not None:
ax1.get_xaxis().set_label_coords(0.5, offset[0])
ax1.get_yaxis().set_label_coords(offset[1], 0.5)
ax2.get_xaxis().set_label_coords(0.5, offset[0])
ax2.get_yaxis().set_label_coords(offset[1], 0.5)
ax5.get_xaxis().set_label_coords(0.5, offset[0])
ax5.get_yaxis().set_label_coords(offset[1], 0.5)
ax6.get_xaxis().set_label_coords(0.5, offset[0])
ax6.get_yaxis().set_label_coords(offset[1], 0.5)
else:
ax1.get_xaxis().set_label_coords(0.5, -0.1)
ax1.get_yaxis().set_label_coords(-0.14, 0.5)
ax2.get_xaxis().set_label_coords(0.5, -0.1)
ax2.get_yaxis().set_label_coords(-0.14, 0.5)
ax5.get_xaxis().set_label_coords(0.5, -0.1)
ax5.get_yaxis().set_label_coords(-0.14, 0.5)
ax6.get_xaxis().set_label_coords(0.5, -0.1)
ax6.get_yaxis().set_label_coords(-0.14, 0.5)
ax1.set_yscale("log")
ax2.set_yscale("log")
ax3.set_yscale("log")
ax4.set_yscale("log")
ax5.set_yscale("log")
ax6.set_yscale("log")
ax7.set_yscale("log")
ax8.set_yscale("log")
print(" [DONE]")
if output is None:
plt.show()
else:
plt.savefig(output, bbox_inches="tight")
plt.clf()
plt.close()
def __call__(self, *args): v = LogNorm.__call__(self, *args) return 1.0 - v
def plot_NTCs_Vs_ROverZ(inputdata,axis,savename,truncation_curves=None,scaling=None):
#Fill a 2D histogram per bunch-crossing with N_TCs (maximum over bundles)
#Each row represents the r/z bins in a bundle, there are n_bundles*n_events rows
data = inputdata.reshape(-1,inputdata.shape[-1])
#Swap axes, such that each row represents an r/z bin, there are n_roverz_bins rows (later flattened)
data_swap = np.swapaxes(data,0,1)
#Get the r/z bin axis indices, n_bundles*n_events*[0]+n_bundles*n_events*[1]+...n_bundles*n_events*[n_roverz_bins]
axis_indices = np.where(data_swap==data_swap)[0]
#Then get the roverz bin values corresponding to the indices
roverz = np.take(axis,axis_indices)
#Plot the 2D histogram
pl.clf()
pl.hist2d( roverz , data_swap.flatten() , bins = (len(axis)-1,50),range=[[0.076,0.58], [0, 50]],norm=LogNorm())
pl.colorbar().set_label("Number of Events")
#Plot the various 1D truncation curves
colours = ['red','orange','cyan','green','teal','darkviolet']
if ( truncation_curves is not None ):
for t,truncation_option in enumerate(truncation_curves):
scale = 1.
if (scaling is not None):
scale=scaling[t]
plotted_truncation_curve = np.append(truncation_option,truncation_option[-1])/scale
pl.step(axis,plotted_truncation_curve+1, where = 'post' , color=colours[t],linewidth='3')
#plotted_truncation_curve+1 so that bin 'n' is visually included if the truncation value is 'n'
#Note because of the geometric corrections the number of trigger cells might be fractional,
#in which case the +1 is not correct (but only applies to the bins at low and high r/z)
pl.xlabel('r/z')
pl.ylabel('Number of TCs')
pl.savefig( savename + ".png" )
pl.clf()
