xVarName='xaxis',
yVarName='yaxis',
meshName=inGridName)
outDescriptor = get_Antarctic_stereographic_comparison_descriptor(config)
outGridName = outDescriptor.meshName
outFileName = 'Rignot_2013_melt_rates_{}.nc'.format(outGridName)
mappingFileName = 'map_{}_to_{}.nc'.format(inGridName, outGridName)
remapper = Remapper(inDescriptor, outDescriptor, mappingFileName)
remapper.build_mapping_file(method='bilinear')
remappedDataset = remapper.remap(ds, renormalizationThreshold=0.01)
remappedDataset.attrs['history'] = ' '.join(sys.argv)
remappedDataset.to_netcdf(outFileName)
norm = colors.SymLogNorm(linthresh=1, linscale=1, vmin=-100.0, vmax=100.0)
plt.figure()
plt.imshow(maskedMeltRate, origin='upper', norm=norm)
plt.colorbar()
plt.figure()
plt.imshow(remappedDataset.meltRate.values, origin='lower', norm=norm)
plt.colorbar()
plt.show()
for filename, label in {{files_and_labels}}:
data = np.loadtxt(filename)
all_data.append(data)
all_data = np.vstack(all_data)
ax = plt.gca()
for x_pos, label in {{lines_and_labels}}:
next_color = ax._get_lines.get_next_color()
plt.axvline(x_pos, label=label, color=next_color)
fig = plt.gcf()
if {{log_scale}}:
im = ax.imshow(all_data,
norm=colors.SymLogNorm(1.0,
vmin=np.min(all_data),
vmax=np.max(all_data)),
cmap='hot',
interpolation='nearest')
else:
im = ax.imshow(all_data, cmap='hot', interpolation='nearest')
fig.colorbar(im)
plt.title('{{title}}')
plt.xlabel('{{xlabel}}')
plt.ylabel('{{ylabel}}')
plt.legend()
if args.dump_svg:
# Save SVG in a fake file object.
imgdata = BytesIO()
plt.imshow([[1, 2], [3, np.nan]])
assert len(warns) == 0
@image_comparison(baseline_images=['imshow_flatfield'],
remove_text=True,
style='mpl20',
extensions=['png'])
def test_imshow_flatfield():
fig, ax = plt.subplots()
im = ax.imshow(np.ones((5, 5)))
im.set_clim(.5, 1.5)
@pytest.mark.parametrize("make_norm", [
colors.Normalize, colors.LogNorm, lambda: colors.SymLogNorm(1),
lambda: colors.PowerNorm(1)
])
@pytest.mark.filterwarnings("ignore:Attempting to set identical left==right")
def test_empty_imshow(make_norm):
fig, ax = plt.subplots()
im = ax.imshow([[]], norm=make_norm())
im.set_extent([-5, 5, -5, 5])
fig.canvas.draw()
with pytest.raises(RuntimeError):
im.make_image(fig._cachedRenderer)
def test_imshow_float128():
fig, ax = plt.subplots()
remove_text=True, style='mpl20')
def test_imshow_bignumbers_real():
rcParams['image.interpolation'] = 'nearest'
# putting a big number in an array of integers shouldn't
# ruin the dynamic range of the resolved bits.
fig, ax = plt.subplots()
img = np.array([[2., 1., 1.e22], [4., 1., 3.]])
pc = ax.imshow(img)
pc.set_clim(0, 5)
@pytest.mark.parametrize(
"make_norm",
[colors.Normalize,
colors.LogNorm,
lambda: colors.SymLogNorm(1),
lambda: colors.PowerNorm(1)])
def test_empty_imshow(make_norm):
fig, ax = plt.subplots()
with pytest.warns(UserWarning,
match="Attempting to set identical left == right"):
im = ax.imshow([[]], norm=make_norm())
im.set_extent([-5, 5, -5, 5])
fig.canvas.draw()
with pytest.raises(RuntimeError):
im.make_image(fig._cachedRenderer)
def test_imshow_float128():
fig, ax = plt.subplots()
title=r'$Q_o$ Variance',
units=r'W$^2$ m$^{-4}$',
cbfrac=cbfrac,
cmap=sstcmap,
vmin=varmin,
vmax=varmax)
plt.savefig(fout +
'{:s}_Qrvar_{:1.0f}LP_{:2.0f}Nto{:2.0f}N_detr{:s}.png'.format(
dataname, Tn / 12., latbounds[0], latbounds[1],
str(detr)[0]))
plt.close()
lvmin = -10**4
lvmax = 10**4
lognorm = colors.SymLogNorm(linthresh=0.03,
linscale=0.03,
vmin=lvmin,
vmax=lvmax)
mapper = Mapper()
mapper(covQsQo,
bnds=bnds,
log=False,
norm=lognorm,
title=r'$Q_s, Q_o$ Covariance',
units=r'W$^2$ m$^{-4}$',
cbfrac=cbfrac,
cmap=sstcmap,
vmin=-varmax,
vmax=-varmin)
plt.savefig(fout +
'{:s}_covQsQo_{:1.0f}LP_{:2.0f}Nto{:2.0f}N_detr{:s}.png'.format(
def stPlot(self,
col,
cmapType="coolwarm",
logOption=0,
save=None,
savePath=None,
clim1=None,
clim2=None,
hLineCoords=[0, 1, 2],
vLineCoords=None,
xLabel=1,
tStart=None,
tEnd=None):
print(self.path + ": making ST plot for column " + str(col))
if savePath is None:
savePath = self.path
if tStart is None:
plotData = self.data[col]
tPlotMax = self.tmax
else:
tiStart = self.gettindex(tStart)
tiEnd = self.gettindex(tEnd)
plotData = self.data[col][tiStart:tiEnd]
tPlotMax = tEnd - tStart
title = self.header[col]
if logOption == 1:
plt.imshow(
np.transpose(np.fliplr(plotData)),
extent=[0, tPlotMax,
np.log10(self.rmin),
np.log10(self.rmax)],
aspect=(80 * tPlotMax / (self.rmax - self.rmin)),
cmap=plt.get_cmap(cmapType),
norm=LogNorm(vmin=clim1, vmax=clim2))
if logOption == 0:
plt.imshow(
np.transpose(np.fliplr(plotData)),
extent=[0, tPlotMax,
np.log10(self.rmin),
np.log10(self.rmax)],
aspect=(80 * tPlotMax / (self.rmax - self.rmin)),
cmap=plt.get_cmap(cmapType))
if logOption == 2:
plotData = plotData / np.amax(np.abs(plotData))
plt.imshow(
np.transpose(np.fliplr(plotData)),
extent=[0, tPlotMax,
np.log10(self.rmin),
np.log10(self.rmax)],
aspect=(80 * tPlotMax / (self.rmax - self.rmin)),
cmap=cmapType,
norm=colors.SymLogNorm(linthresh=0.0001,
linscale=0.1,
vmin=-1.0,
vmax=1.0))
#plt.yscale('log')
plt.title(title)
if xLabel == 1: plt.xlabel("Time (code units)")
plt.ylabel("log(r) (code units)")
plt.colorbar(
shrink=0.5
) #ticks=[-10^0, -10^-1, -10^-2, -10^-3, 10^-3, 10^-2, 10^-1, 10^0])
if (clim1 is not None and clim2 is not None):
plt.clim(clim1, clim2)
if (clim1 is not None and clim2 is None):
plt.clim(clim1, np.amax(plotData))
if (clim1 is None and clim2 is not None):
plt.clim(np.aminx(plotData), clim2)
if vLineCoords is not None:
for xc in vLineCoords:
plt.axvline(x=xc, color='g', linestyle=':')
for yc in hLineCoords:
plt.axhline(y=yc, color='k', linestyle='--')
plt.tight_layout()
if save == "png":
plt.savefig(savePath + "ST_" + str(col) + ".png",
bbox_inches='tight')
print("saved ST plot for column " + str(col) + " to png")
if save == "pdf":
plt.savefig(self.pdfName, format='pdf', bbox_inches='tight')
print("saved ST plot for column " + str(col) + " to pdf")
plt.clf()
def multiStPlot3(self,
tFlip,
savePath=None,
vLinesOn=True,
vLineCoords1=[50],
ti1=None,
ti2=None,
nameTag="_"):
print(self.path + ": making multi pannel ST plot")
if savePath is None:
savePath = self.path
f, axArray = plt.subplots(4, sharex=True)
lumRangeLogY = np.log10(np.amax(self.lum) / np.amin(self.lum))
rangeX = self.tmax
if ti1 is None: ti1 = 0
if ti2 is None: ti2 = self.nt - 1
thisNt = ti2 - ti1
#aspect1 = 0.87 *(thisNt)/self.nr
aspect1 = (2.0 * 15.3) * (self.t[ti2] - self.t[ti1]) / self.nr
#aspect1 = 2.28 * (self.tmax / 30.0) * ((ti2-ti1)/ti2)
col = 12
axNum = 0
title = self.header[col]
plotData = self.data[col][ti1:ti2]
plotData = plotData / np.amax(np.abs(plotData))
axArray[axNum].imshow(np.transpose(np.fliplr(plotData)),
extent=[
self.t[ti1], self.t[ti2 - 1],
np.log10(self.rmin),
np.log10(self.rmax)
],
aspect=aspect1,
cmap='coolwarm',
norm=colors.SymLogNorm(linthresh=0.001,
linscale=0.5,
vmin=-1.0,
vmax=1.0))
#, vmin=-1.0, vmax=1.0
axArray[axNum].text(1.02,
0.5,
title,
fontsize=14,
transform=axArray[axNum].transAxes)
axArray[axNum].set_ylabel("log(r) (AU)")
axArray[axNum].set_yticks([-1, 0])
col = 0
axNum = 1
title = self.header[col]
plotData = self.data[col][ti1:ti2]
axArray[axNum].imshow(np.transpose(np.fliplr(plotData)),
extent=[
self.t[ti1], self.t[ti2 - 1],
np.log10(self.rmin),
np.log10(self.rmax)
],
aspect=aspect1,
cmap='viridis',
norm=LogNorm())
axArray[axNum].text(1.02,
0.5,
title,
fontsize=14,
transform=axArray[axNum].transAxes)
axArray[axNum].set_ylabel("log(r) (AU)")
axArray[axNum].set_yticks([-1, 0])
col = 9
axNum = 2
title = self.header[col]
plotData = self.data[col][ti1:ti2]
axArray[axNum].imshow(np.transpose(np.fliplr(plotData)),
extent=[
self.t[ti1], self.t[ti2 - 1],
np.log10(self.rmin),
np.log10(self.rmax)
],
aspect=aspect1,
cmap='viridis',
norm=LogNorm())
axArray[axNum].text(1.02,
0.5,
title,
fontsize=14,
transform=axArray[axNum].transAxes)
axArray[axNum].set_ylabel("log(r) (AU)")
axArray[axNum].set_yticks([-1, 0])
axNum = 3
title = "L"
axArray[axNum].semilogy(self.t[ti1:ti2], self.lum[ti1:ti2])
axArray[axNum].set_ylabel(title)
axArray[axNum].set_xlim([self.t[ti1], self.t[ti2 - 1]])
maxLog = np.log10(
1.1 * np.amax(np.abs(self.lum[int((ti2 + ti1) * 0.0):ti2])))
minLog = np.log10(
0.9 * np.amin(np.abs(self.lum[int((ti2 + ti1) * 0.0):ti2])))
axArray[axNum].set_ylim([np.power(10, minLog), np.power(10, maxLog)])
axArray[axNum].set_xlabel("time (years)")
tickVals = []
for i in range(-5, 6):
if minLog < i < maxLog:
tickVals.append(np.power(10.0, i))
axArray[axNum].set_yticks(tickVals)
vLineCoords1 = np.zeros(int(1 + (self.tmax - tWait) / (2.0 * tFlip)))
i = 0
while i < len(vLineCoords1):
vLineCoords1[i] = tWait + 2 * i * tFlip
i = i + 1
hLineCoords1 = np.asarray([-1])
if vLinesOn is True:
for axNum in np.arange(len(axArray)):
for xc in vLineCoords1:
axArray[axNum].axvline(x=xc, color='r', linestyle=':')
axArray[axNum].axvline(x=xc + tFlip * 1.0,
color='b',
linestyle=':')
axArray[axNum].axvline(x=xc + tFlip * 0.5,
color='k',
linestyle=':')
axArray[axNum].axvline(x=xc + tFlip * 1.5,
color='k',
linestyle=':')
#for axNum in [0,1,2]:
#for yc in hLineCoords1:
#axArray[axNum].axhline(y=yc, color='k')
plt.savefig(savePath + "MST3" + nameTag + ".png",
bbox_inches='tight',
dpi=600)
print("saved MST plot to png")
plt.clf()
fig = plt.figure(figsize=(20, 20))
ax = fig.add_subplot(projection=WCS(hdr_plot), slices=('x', 'y', 1))
ax.update({
'title': r'{} galaxy, $H\alpha$ flux'.format(obj),
'xlabel': r'RA',
'ylabel': r'DEC'
})
halpha_cmap = cm.gray
halpha_cmap.set_under(background_color)
im = ax.imshow(flux6563_image,
interpolation='bicubic',
cmap=halpha_cmap,
norm=colors.SymLogNorm(linthresh=flux6563_levels[-2],
vmin=flux6563_levels[-3],
base=10))
# plt.savefig(folder/'muse_CGCG007_Halpha.png', resolution=300, bbox_inches='tight')
plt.show()
# region_idcs = np.array([0, 1, 2, 3, 4])
# for idx in region_idcs:
#
# mask_label = f'region_{idx}'
# mask_array = fits.getdata(db_addresss, mask_label, ver=1)
#
# flux_Image = np.ma.masked_array(flux6563_image, mask=mask_array)
#
# fig = plt.figure(figsize=(12, 8))
# ax = fig.add_subplot(projection=WCS(hdr_plot), slices=('x', 'y', 1))
# ax.update({'title': r'{} galaxy, {}, $H\alpha$ flux'.format(obj, mask_label), 'xlabel': r'RA', 'ylabel': r'DEC'})
#!/usr/bin/env python3
from matplotlib import use
use('agg')
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as mplc
from matplotlib import cm
import sys
import os
from astropy.io import fits
hdu = fits.open(sys.argv[1])[0]
d = hdu.data
fig, ax = plt.subplots(1, 1, figsize=(5, 5))
vmin = d.min()
vmax = d.max()
norm = mplc.SymLogNorm(1e-9, vmin=vmin, vmax=vmax)
img = ax.imshow(d, norm=norm)
plt.colorbar(img, ax=ax, shrink=0.8)
fig.savefig(sys.argv[1][:-4] + 'png')
import matplotlib.pyplot as plt
from matplotlib import colors
# Loading a sample dataset
counts, lengths, cnv = datasets.load_sample_cancer()
normed = normalization.ICE_normalization(counts, counts_profile=cnv)
# Plotting the results using matplotlib
chromosomes = ["I", "II", "III", "IV", "V", "VI"]
fig, axes = plt.subplots(ncols=2, figsize=(12, 4))
axes[0].imshow(counts,
cmap="RdBu_r",
norm=colors.SymLogNorm(1),
extent=(0, len(counts), 0, len(counts)))
[axes[0].axhline(i, linewidth=1, color="#000000") for i in lengths.cumsum()]
[axes[0].axvline(i, linewidth=1, color="#000000") for i in lengths.cumsum()]
axes[0].set_title("Raw contact counts", fontweight="bold")
m = axes[1].imshow(normed,
cmap="RdBu_r",
norm=colors.SymLogNorm(1),
extent=(0, len(counts), 0, len(counts)))
[axes[1].axhline(i, linewidth=1, color="#000000") for i in lengths.cumsum()]
[axes[1].axvline(i, linewidth=1, color="#000000") for i in lengths.cumsum()]
cb = fig.colorbar(m)
axes[1].set_title("Normalized contact counts with LOIC", fontweight="bold")
for i, percentile in enumerate(levelContours):
print(f'{i}, Level P({pertil_array[i]}) = {percentile} flux')
maFlux_image = np.ma.masked_where(
(flux_image >= levelContours[-5]) & (flux_image < levelContours[-4]),
flux_image)
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(projection=WCS(cube.data_header),
slices=('x', 'y', 1))
# im = ax.imshow(flux_image, vmin=0, interpolation='none')
# im = ax.imshow(flux_image, cmap=cm.gray, norm=colors.SymLogNorm(linthresh=levelContours[1], vmin=levelContours[1], base=10))
im = ax.imshow(maFlux_image,
cmap=cm.gray,
norm=colors.SymLogNorm(linthresh=levelContours[1],
vmin=levelContours[1],
base=10))
# im = ax.imshow(flux_image, cmap=cm.gray, norm=colors.SymLogNorm(linthresh=levelContours[1], vmin=levelContours[2]))
ax.contour(flux_image, levels=[levelContours[-5]], colors='red', alpha=0.5)
# cbar = fig.colorbar(im, ticks=levelContours)
print(levelContours[2:6])
ax.set_title(f'Galaxy {obj} {lineLabel}')
plt.show()
# Image with a clear display of the galaxy features
# lineLabel = 'H1_6563A'
# lineLimits = lineAreas[lineLabel]
#
# # This requires the input wavelengths to be on the same scale as in the cube
# line_image = cube.get_image(np.array(lineLimits) * (1 + z_objs[i]), subtract_off=True)
def setup(
self,
image,
ok=None,
xaxis=None,
yaxis=None,
title='', # title to go over the top of the plot
figsize=(8, 4), # kwargs for figure,
dpi=100,
hspace=0,
wspace=0, # kwargs for gridspec
left=0.05,
right=0.95,
bottom=0.05,
top=0.95,
width_ratios=[1.0, 0.1],
height_ratios=[0.1, 1.0],
initialcrosshairs=[0.0, 0.0], # where the crosshairs should start
aspect='equal', # kwargs for imshow
vmin=None,
vmax=None,
scale='symlog', # make a default that can be edited interactively (in Mask.py)
labelfontsize=5,
datacolor='darkorange',
crosshaircolor='darkorange',
**kwargs):
'''
Initialize the loupe
(this has a pretty big overhead,
so use "updateImage" if you can to update
the data being displayed)
'''
self.ok = ok
self.image = image
# set the image
if xaxis is not None:
self.xaxis = xaxis
else:
xsize = self.imagetoplot.shape[1]
self.xaxis = np.arange(xsize)
if yaxis is not None:
self.yaxis = yaxis
else:
ysize = self.imagetoplot.shape[0]
self.yaxis = np.arange(ysize)
self.dx = np.median(np.diff(self.xaxis))
self.dy = np.median(np.diff(self.yaxis))
self.speak('setting up loupe')
# keep track of where the crosshair is pointing
self.crosshair = dict(x=initialcrosshairs[0], y=initialcrosshairs[1])
# set up the figure
plt.ion()
self.figure = plt.figure(figsize=figsize, dpi=dpi)
# create an interactive plot
self.iplot = iplot(2,
2,
hspace=hspace,
wspace=wspace,
left=left,
right=right,
bottom=bottom,
top=top,
width_ratios=width_ratios,
height_ratios=height_ratios)
# a dictionary to store the axes objects
self.ax = {}
# for displaying the 2D image
labelkw = dict(fontsize=labelfontsize)
self.ax['2d'] = self.iplot.subplot(1, 0)
plt.setp(self.ax['2d'].get_xticklabels(), **labelkw)
plt.setp(self.ax['2d'].get_yticklabels(), **labelkw)
# for displaying cuts along the dispersion direction
self.ax['slicex'] = self.iplot.subplot(0, 0, sharex=self.ax['2d'])
self.ax['slicex'].set_title(title, fontsize=8)
plt.setp(self.ax['slicex'].get_xticklabels(), visible=False)
plt.setp(self.ax['slicex'].get_yticklabels(), **labelkw)
# for display cuts along the cross-dispersion direction
self.ax['slicey'] = self.iplot.subplot(1, 1, sharey=self.ax['2d'])
self.ax['slicey'].xaxis.tick_top()
self.ax['slicey'].xaxis.set_label_position('top')
plt.setp(self.ax['slicey'].get_xticklabels(), rotation=270, **labelkw)
plt.setp(self.ax['slicey'].get_yticklabels(), visible=False)
# set the limits of the plot
ok = np.isfinite(self.imagetoplot)
#self.vmin, self.vmax = np.percentile(self.imagetoplot[ok], [0,100])
# pick a scale for the plotting
if scale == 'symlog':
norm = colors.SymLogNorm(linthresh=craftroom.oned.mad(
self.imagetoplot),
linscale=0.1,
vmin=vmin,
vmax=vmax)
else:
norm = None
self.extent = [
np.min(self.xaxis),
np.max(self.xaxis),
np.min(self.yaxis),
np.max(self.yaxis)
]
self.plotted = {}
# plot the image
self.plotted['2d'] = self.ax['2d'].imshow(self.imagetoplot,
cmap='gray',
extent=self.extent,
interpolation='nearest',
aspect=aspect,
zorder=0,
origin='lower',
norm=norm)
# set the x and y limits
self.ax['2d'].set_xlim(self.extent[0:2])
self.ax['2d'].set_ylim(self.extent[2:4])
# add crosshair
crosskw = dict(alpha=0.5, color=crosshaircolor, linewidth=1)
self.plotted['crossy'] = self.ax['2d'].axvline(self.crosshair['x'],
**crosskw)
self.plotted['crossyextend'] = self.ax['slicex'].axvline(
self.crosshair['x'], linestyle='--', **crosskw)
self.plotted['crossx'] = self.ax['2d'].axhline(self.crosshair['y'],
**crosskw)
self.plotted['crossxextend'] = self.ax['slicey'].axhline(
self.crosshair['y'], linestyle='--', **crosskw)
# plot slicey
slicekw = dict(color=datacolor, linewidth=1)
badalpha = 0.15
h, v = self.slicey
ok = self.ok_slicey
self.plotted['slicey'] = self.ax['slicey'].plot(
h[ok], v[ok], **slicekw)[0]
self.plotted['slicey_bad'] = self.ax['slicey'].plot(h[ok == False],
v[ok == False],
alpha=badalpha,
**slicekw)[0]
h, v = self.slicex
ok = self.ok_slicex
self.plotted['slicex'] = self.ax['slicex'].plot(
h[ok], v[ok], **slicekw)[0]
self.plotted['slicex_bad'] = self.ax['slicex'].plot(h[ok == False],
v[ok == False],
alpha=badalpha,
**slicekw)[0]
# set the limits of the color scale and the plots
for a in self.ax.values():
a.set_autoscaley_on(False)
self.set_limits(vmin, vmax)
def plotImage(pattern,
logscale=True,
offset=None,
symlog=False,
figsize=None,
ax=None,
fn_png=None,
*argv,
**kwargs):
""" Workhorse function to plot an image.
:param logscale: Whether to show the data on logarithmic scale (z axis), defaults to `True`.
:type logscale: bool
:param offset: Offset to apply to the pattern.
:type offset: float
:param symlog: To show the data on symlogarithmic scale (z axis), defaults to `False`.
:type symlog: bool
:param fn_png: The name of the output png file, defaults to `None`.
:type fn_png: str
:return: The axes class instance of the plot.
:rtype: ``matplotlib.axes``
"""
if ax is None:
fig, ax = plt.subplots(figsize=figsize)
# Get limits.
mn, mx = pattern.min(), pattern.max()
x_range, y_range = pattern.shape
if offset:
mn = pattern.min() + offset
mx = pattern.max() + offset
pattern = pattern.astype(float) + offset
if (logscale and symlog):
print('logscale and symlog are both true.\noverrided by logscale')
if 0 in pattern and not offset and (logscale or symlog):
print(
'Warnning: zero-value detected. Please set a small offset (e.g. 1e-3) to get correct log display.'
)
if (logscale or symlog):
kwargs['cmap'] = kwargs.pop('cmap', "viridis")
# default plot setup
if logscale:
kwargs['norm'] = kwargs.pop('norm', colors.LogNorm())
elif symlog:
kwargs['norm'] = kwargs.pop('norm', colors.SymLogNorm(0.015))
kwargs.pop('axes', None)
else:
kwargs['norm'] = kwargs.pop('norm', colors.Normalize(vmin=mn, vmax=mx))
kwargs['cmap'] = kwargs.pop('cmap', "viridis")
ax = plt.imshow(pattern, *argv, **kwargs)
plt.xlabel(r'$x$ (pixel)')
plt.ylabel(r'$y$ (pixel)')
plt.xlim([0, x_range - 1])
plt.ylim([0, y_range - 1])
plt.tight_layout()
plt.colorbar()
if fn_png:
plt.savefig(fn_png, dpi=300)
return ax
def spectrogram(audiofile, samplerate=0):
win_s = 512 # fft window size
hop_s = win_s // 2 # hop size
fft_s = win_s // 2 + 1 # spectrum bins
audio_data = aubio.source(audiofile, samplerate, hop_s) # source file
if samplerate == 0:
samplerate = audio_data.samplerate
pv = aubio.pvoc(win_s, hop_s) # phase vocoder
specgram = np.zeros(
[0, fft_s], dtype=aubio.float_type) # numpy array to store spectrogram
# analysis
while True:
samples, read = audio_data() # read file
specgram = np.vstack(
(specgram, pv(samples).norm)) # store new norm vector
if read < audio_data.hop_size: break
# plotting
#fig = plt.imshow(log10(specgram.T + .001), origin = 'bottom', aspect = 'auto', cmap=plt.cm.gray_r)
#fig = plt.imshow(log10(specgram.T + .001), origin = 'bottom', aspect = 'auto', cmap=plt.cm.gray_r)
plt.figure(figsize=(15, 10))
fig = plt.imshow(np.log10(specgram.T + .001),
origin='bottom',
aspect='auto',
cmap=plt.cm.gray_r)
#print dir(plt.cm)
#fig = plt.imshow(log10(specgram.T + .001), origin = 'bottom', size=800)
#plt.pcolormesh(t, f, Sxx)
#plt.pcolormesh(specgram.T)
#print dir(colors)
#norm = colors.LogNorm(vmin=specgram.T.min(), vmax=specgram.T.max())
#norm = colors.LogNorm(vmin=specgram.min(), vmax=specgram.max())
#norm = colors.SymLogNorm(linthresh=0.03, linscale=0.03, vmin=specgram.min(), vmax=specgram.max())
norm = colors.SymLogNorm(linthresh=0.08,
linscale=0.1,
vmin=specgram.min(),
vmax=specgram.max())
#bounds = np.linspace(-1, 1, 10)
#norm = colors.BoundaryNorm(boundaries=bounds, ncolors=256)
#norm = colors.PowerNorm(gamma=1./2.)
#norm = colors.PowerNorm(gamma=0.25)
#plt.pcolormesh(specgram.T, norm=norm, cmap='PuBu_r')
#plt.pcolormesh(specgram.T, norm=norm, cmap='PuBu_r')
#plt.pcolormesh(specgram.T, norm=norm, cmap='RdBu_r')
#plt.pcolormesh(specgram.T, norm=norm, cmap='RdBu')
#plt.pcolormesh(specgram.T, norm=norm, cmap='gnuplot2')
plt.pcolormesh(specgram.T, norm=norm, cmap='inferno')
#plt.pcolormesh(specgram.T, norm=norm, cmap='hot_r')
#plt.pcolormesh(specgram.T, norm=norm, cmap='copper')
#plt.pcolormesh(specgram.T, norm=norm, cmap='seismic')
ax = fig.axes
ax.axis([0, len(specgram), 0, len(specgram[0])])
# show axes in Hz and seconds
time_step = hop_s / float(samplerate)
total_time = len(specgram) * time_step
outstr = "total time: %0.2fs" % total_time
print(outstr + ", samplerate: %.2fkHz" % (samplerate / 1000.0))
n_xticks = 10
n_yticks = 10
def get_rounded_ticks(top_pos, step, n_ticks):
top_label = top_pos * step
# get the first label
ticks_first_label = top_pos * step / n_ticks
# round to the closest .1
ticks_first_label = round(ticks_first_label * 10.0) / 10.0
# compute all labels from the first rounded one
ticks_labels = [ticks_first_label * n
for n in range(n_ticks)] + [top_label]
# get the corresponding positions
ticks_positions = [ticks_labels[n] / step
for n in range(n_ticks)] + [top_pos]
# convert to string
#ticks_labels = [ "%.1f" % x for x in ticks_labels ]
ticks_labels = ["%i" % x for x in ticks_labels]
# return position, label tuple to use with x/yticks
return ticks_positions, ticks_labels
# apply to the axis
x_ticks, x_labels = get_rounded_ticks(len(specgram), time_step, n_xticks)
ax.set_xticks(x_ticks)
ax.set_xticklabels(x_labels)
#y_ticks, y_labels = get_rounded_ticks(len(specgram[0]), (samplerate / 1000. / 2.) / len(specgram[0]), n_yticks)
y_ticks, y_labels = get_rounded_ticks(len(
specgram[0]), (samplerate / 2.0) / len(specgram[0]), n_yticks)
#y_ticks, y_labels = get_rounded_ticks(len(specgram[0]), 1, n_yticks)
ax.set_yticks(y_ticks)
ax.set_yticklabels(y_labels)
#ax.set_yticks(range(0, 3150, 100))
#print len(specgram), len(specgram[0]), max(specgram[0])
#plt.yticks(range(0, 3151, 100))
ax.set_ylabel('Frequency (Hz)')
ax.set_xlabel('Time (s)')
ax.set_title(os.path.basename(audiofile))
for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +
ax.get_xticklabels() + ax.get_yticklabels()):
item.set_fontsize('x-small')
#return fig
tmpfile = NamedTemporaryFile(suffix='.png', delete=False)
plt.savefig(tmpfile.name)
#plt.show()
return tmpfile.name
def main(ssh=False, labelfontsize=12, ticksize=11):
plot_path = "../../Plots/Analytic_Covariance/"
u_range = numpy.logspace(0, numpy.log10(500), 100)
# 100 frequency channels is fine for now, maybe later do a higher number to push up the k_par range
frequency_range = numpy.linspace(135, 165, 251) * 1e6
eta, sky_only_raw, sky_only_cal = residual_ps_error(u_range,
frequency_range,
residuals='sky')
eta, sky_and_beam_raw, sky_and_beam_cal = residual_ps_error(
u_range, frequency_range, residuals='both')
difference_cal = sky_and_beam_cal - sky_only_cal
fiducial_ps = fiducial_eor(u_range, eta)
figure, axes = pyplot.subplots(1, 3, figsize=(15, 5))
ps_norm = colors.LogNorm(vmin=1e2, vmax=1e15)
plot_power_spectrum(u_range,
eta,
frequency_range,
sky_and_beam_cal,
title=r"$\mathbf{C}_{r}$(sky + beam)",
axes=axes[0],
axes_label_font=labelfontsize,
tickfontsize=ticksize,
norm=ps_norm,
xlabel_show=True,
colorbar_show=True)
diff_norm = colors.SymLogNorm(linthresh=1e2,
linscale=1.5,
vmin=-1e15,
vmax=1e15)
plot_power_spectrum(
u_range,
eta,
frequency_range,
difference_cal,
axes=axes[1],
axes_label_font=labelfontsize,
tickfontsize=ticksize,
norm=diff_norm,
colorbar_show=True,
xlabel_show=True,
title=r"$\mathbf{C}_{r}$(sky + beam) - $\mathbf{C}_{r}$(sky) ",
diff=True,
colormap='coolwarm')
ratio_norm = colors.SymLogNorm(linthresh=1e1,
linscale=1,
vmin=-1e1,
vmax=1e5)
plot_power_spectrum(
u_range,
eta,
frequency_range,
difference_cal / fiducial_ps,
axes=axes[2],
axes_label_font=labelfontsize,
tickfontsize=ticksize,
norm=ratio_norm,
colorbar_show=True,
xlabel_show=True,
z_label="Difference Ratio",
title=
r"$(\mathbf{C}_{r}$(sky + beam) - $\mathbf{C}_{r}$(sky))/$\mathbf{C}_{s}$ ",
diff=True)
figure.tight_layout()
figure.savefig(plot_path +
"Comparing_Sky_and_Beam_Errors_Post_Calibration.pdf")
if not ssh:
pyplot.show()
return
# make test data
data = np.array([[random.randint(0, 100) for row in range(66)]
for column in range(4)])
for row in [0, 61]:
for column in [0, 2]:
data_tmp = random.randint(0, 100)
data[column][row:row + 5] = data_tmp
data[column + 1][row:row + 5] = data_tmp
for row in range(5, 61, 7):
for column in [0, 3]:
data[column][row:row + 7] = random.randint(0, 100)
print('data:', data)
# make log scale colorbar
norm = mcolors.SymLogNorm(linthresh=1, vmin=0, vmax=data.max() * 10)
# plot imshow and colorbar
image_imshow = ax.imshow(data, cmap="viridis", aspect='auto', norm=norm)
fig.colorbar(image_imshow, orientation='horizontal')
# hide ticks and it's label
ax.set_xticks([])
ax.set_yticks([])
ax.xaxis.set_ticklabels([])
ax.yaxis.set_ticklabels([])
# overlay rectangular area on plot
for x in range(5, 61):
for y in range(2):
center_area = plt.Rectangle(
# (x,y) of upper left corner, width, hight
def multiStPlot2(self, tFlip, savePath=None):
print(self.path + ": making multi pannel ST plot")
if savePath is None:
savePath = self.path
f, axArray = plt.subplots(6, sharex=True)
lumRangeLogY = np.log10(np.amax(self.lum) / np.amin(self.lum))
rangeX = self.tmax
#self.lum[800] = self.lum[800]*10
#ti1 = 3000
#ti2 = 4000
ti1 = 0
ti2 = self.nt
#aspect1 = 1.65 * (30.0 / self.tmax)
aspect1 = 1.49 * (self.tmax / 30.0) * ((ti2 - ti1) / ti2)
col = 12
axNum = 0
title = self.header[col]
plotData = self.data[col][ti1:ti2]
plotData = plotData / np.amax(np.abs(plotData))
axArray[axNum].imshow(np.transpose(np.fliplr(plotData)),
extent=[
self.t[ti1], self.t[ti2 - 1],
np.log10(self.rmin),
np.log10(self.rmax)
],
aspect=aspect1,
cmap='coolwarm',
norm=colors.SymLogNorm(linthresh=0.0001,
linscale=0.1,
vmin=-1.0,
vmax=1.0))
axArray[axNum].text(1.02,
0.5,
title,
fontsize=14,
transform=axArray[axNum].transAxes)
axArray[axNum].set_ylabel("log(r)")
axArray[axNum].set_yticks([-1, 0])
col = 0
axNum = 1
title = self.header[col]
plotData = self.data[col][ti1:ti2]
axArray[axNum].imshow(np.transpose(np.fliplr(plotData)),
extent=[
self.t[ti1], self.t[ti2 - 1],
np.log10(self.rmin),
np.log10(self.rmax)
],
aspect=aspect1,
cmap='viridis',
norm=LogNorm())
axArray[axNum].text(1.02,
0.5,
title,
fontsize=14,
transform=axArray[axNum].transAxes)
axArray[axNum].set_ylabel("log(r)")
axArray[axNum].set_yticks([-1, 0])
col = 15
axNum = 2
title = self.header[col]
plotData = self.data[col][ti1:ti2]
axArray[axNum].imshow(np.transpose(np.fliplr(plotData)),
extent=[
self.t[ti1], self.t[ti2 - 1],
np.log10(self.rmin),
np.log10(self.rmax)
],
aspect=aspect1,
cmap='viridis',
norm=LogNorm())
axArray[axNum].text(1.02,
0.5,
title,
fontsize=14,
transform=axArray[axNum].transAxes)
axArray[axNum].set_ylabel("log(r)")
axArray[axNum].set_yticks([-1, 0])
col = 2
axNum = 3
title = self.header[col]
plotData = np.power(self.data[col][ti1:ti2], 1.0)
axArray[axNum].imshow(np.transpose(np.fliplr(plotData)),
extent=[
self.t[ti1], self.t[ti2 - 1],
np.log10(self.rmin),
np.log10(self.rmax)
],
aspect=aspect1,
cmap='viridis',
norm=LogNorm())
axArray[axNum].text(1.02,
0.5,
title,
fontsize=14,
transform=axArray[axNum].transAxes)
axArray[axNum].set_ylabel("log(r)")
axArray[axNum].set_yticks([-1, 0])
axNum = 4
title = "L"
axArray[axNum].semilogy(self.t[ti1:ti2], self.lum[ti1:ti2])
axArray[axNum].set_ylabel(title)
axArray[axNum].set_xlim([self.t[ti1], self.t[ti2 - 1]])
maxLog = np.log10(
1.1 * np.amax(np.abs(self.lum[int((ti2 + ti1) * 0.0):ti2])))
minLog = np.log10(
0.9 * np.amin(np.abs(self.lum[int((ti2 + ti1) * 0.0):ti2])))
axArray[axNum].set_ylim([np.power(10, minLog), np.power(10, maxLog)])
tickVals = []
for i in range(-5, 6):
if minLog < i < maxLog:
tickVals.append(np.power(50.0, i))
axArray[axNum].set_yticks(tickVals)
axNum = 5
title = self.header[9]
plotData = self.data[9][ti1:ti2,
10] / self.data[9][self.gettindex(tWait), 10]
axArray[axNum].semilogy(self.t[ti1:ti2], plotData)
axArray[axNum].set_ylabel(title)
axArray[axNum].set_xlim([self.t[ti1], self.t[ti2 - 1]])
axArray[axNum].set_xlabel("Time")
maxLog = np.log10(
1.1 * np.amax(np.abs(plotData[int((ti2 + ti1) * 0.0):ti2])))
minLog = np.log10(
0.9 * np.amin(np.abs(plotData[int((ti2 + ti1) * 0.0):ti2])))
axArray[axNum].set_ylim([np.power(10, minLog), np.power(10, maxLog)])
tickVals = []
for i in range(-5, 6):
if minLog < i < maxLog:
tickVals.append(np.power(10.0, i))
axArray[axNum].set_yticks(tickVals)
#vLineCoords1 = np.zeros(int(1+(self.tmax-50.0)/(2.0*tFlip)))
#i=0
#while i < len(vLineCoords1):
#vLineCoords1[i] = 50.0 + 2*i*tFlip
#i = i+1
#hLineCoords1 = np.asarray([-1])
#if self.data[12][self.gettindex(50.0), 5] > self.data[12][self.gettindex(10.5), 5]:
# color1 = 'b'
# color2 = 'r'
#else:
# color1 = 'r'
# color2 = 'b'
#for axNum in np.arange(len(axArray)):
# for xc in vLineCoords1:
# axArray[axNum].axvline(x=xc, color=color1, linestyle=':')
# axArray[axNum].axvline(x=xc+tFlip, color=color2, linestyle=':')
#for axNum in [0,1,2]:
#for yc in hLineCoords1:
#axArray[axNum].axhline(y=yc, color='k')
plt.savefig(savePath + "MST2.png", bbox_inches='tight', dpi=600)
print("saved MST plot to png")
plt.clf()
from matplotlib import colors
from iced import datasets
from iced.utils import get_intra_mask
from iced.utils import get_inter_mask
# Loading a sample dataset
counts, lengths = datasets.load_sample_yeast()
intra_mask = get_intra_mask(lengths)
inter_mask = get_inter_mask(lengths)
fig, axes = plt.subplots(ncols=2, figsize=(12, 6))
inter_counts = counts.copy()
inter_counts[intra_mask] = np.nan
intra_counts = counts.copy()
intra_counts[inter_mask] = np.nan
m = axes[0].matshow(intra_counts, cmap="Blues", norm=colors.SymLogNorm(1),
extent=(0, len(counts), 0, len(counts)))
m = axes[1].matshow(inter_counts, cmap="Blues", norm=colors.SymLogNorm(1),
extent=(0, len(counts), 0, len(counts)))
axes[0].set_title("Intra-chromosomal maps")
axes[1].set_title("Inter-chromosomal maps")
[axes[0].axhline(i, linewidth=1, color="#000000") for i in lengths.cumsum()]
[axes[0].axvline(i, linewidth=1, color="#000000") for i in lengths.cumsum()]
[axes[1].axhline(i, linewidth=1, color="#000000") for i in lengths.cumsum()]
[axes[1].axvline(i, linewidth=1, color="#000000") for i in lengths.cumsum()]
def multiStPlot1cbar(self,
tFlip,
savePath=None,
vLinesOn=True,
vLineCoords1=[50],
ti1=None,
ti2=None,
nameTag="_"):
print(self.path + ": making multi pannel ST plot")
if savePath is None:
savePath = self.path
#f, axArray = plt.subplots(4, sharex=True)
lumRangeLogY = np.log10(np.amax(self.lum) / np.amin(self.lum))
rangeX = self.tmax
if ti1 is None: ti1 = 0
if ti2 is None: ti2 = self.nt - 1
thisNt = ti2 - ti1
#aspect1 = 0.87 *(thisNt)/self.nr
aspect1 = 15.3 * (self.t[ti2] - self.t[ti1]) / self.nr
#aspect1 = 2.28 * (self.tmax / 30.0) * ((ti2-ti1)/ti2)
col = 12
axNum = 0
title = self.header[col]
plotData = self.data[col][ti1:ti2]
plotData = plotData / np.amax(np.abs(plotData))
plt.imshow(np.transpose(np.fliplr(plotData)),
extent=[
self.t[ti1], self.t[ti2 - 1],
np.log10(self.rmin),
np.log10(self.rmax)
],
aspect=aspect1,
cmap='coolwarm',
norm=colors.SymLogNorm(linthresh=0.001,
linscale=0.5,
vmin=-1.0,
vmax=1.0))
#axArray[axNum].text(1.02, 0.5, title, fontsize=14,transform=axArray[axNum].transAxes)
#axArray[axNum].set_ylabel("log(r) (AU)")
#axArray[axNum].set_yticks([-1,0])
plt.colorbar(shrink=0.5)
plt.savefig(savePath + "MST1cbar0" + nameTag + ".png",
bbox_inches='tight',
dpi=600)
plt.clf()
col = 0
axNum = 1
title = self.header[col]
plotData = self.data[col][ti1:ti2]
plt.imshow(np.transpose(np.fliplr(plotData)),
extent=[
self.t[ti1], self.t[ti2 - 1],
np.log10(self.rmin),
np.log10(self.rmax)
],
aspect=aspect1,
cmap='viridis',
norm=LogNorm())
#axArray[axNum].text(1.02, 0.5, title, fontsize=14,transform=axArray[axNum].transAxes)
#axArray[axNum].set_ylabel("log(r) (AU)")
#axArray[axNum].set_yticks([-1,0])
plt.colorbar(shrink=0.5)
plt.savefig(savePath + "MST1cbar1" + nameTag + ".png",
bbox_inches='tight',
dpi=600)
plt.clf()
col = 15
axNum = 2
title = self.header[col]
plotData = self.data[col][ti1:ti2]
plt.imshow(np.transpose(np.fliplr(plotData)),
extent=[
self.t[ti1], self.t[ti2 - 1],
np.log10(self.rmin),
np.log10(self.rmax)
],
aspect=aspect1,
cmap='viridis',
norm=LogNorm())
#axArray[axNum].text(1.02, 0.5, title, fontsize=14,transform=axArray[axNum].transAxes)
#axArray[axNum].set_ylabel("log(r) (AU)")
#axArray[axNum].set_yticks([-1,0])
plt.colorbar(shrink=0.5)
plt.savefig(savePath + "MST1cbar2" + nameTag + ".png",
bbox_inches='tight',
dpi=600)
plt.clf()
def plot_continuum(cfg_par):
'''Function to plot the continuum image from where spectra are extracted
'''
cont_im = cfg_par['general']['contname']
if os.path.exists(cont_im):
#load wcs system
hdulist = fits.open(cont_im) # read input
# read data and header
#what follows works for wcs, but can be written better
prihdr = hdulist[0].header
w = wcs.WCS(prihdr)
# RS: the rest of the function requires only 2 axis images
if w.naxis == 4:
w = w.dropaxis(3)
w = w.dropaxis(2)
img = hdulist[0].data[0][0]
elif w.naxis == 3:
w = w.dropaxis(2)
img = hdulist[0].data[0]
elif os.path.exists(cfg_par['general']['cubename']):
cube_im = cfg_par['general']['cubename']
#load wcs system
hdulist = fits.open(cube_im) # read input
# read data and header
#what follows works for wcs, but can be written better
prihdr = hdulist[0].header
w = wcs.WCS(prihdr)
# RS: the rest of the function requires only 2 axis images
if w.naxis == 4:
w = w.dropaxis(3)
w = w.dropaxis(2)
img = hdulist[0].data[0][0]
img = np.zeros(img.shape)
elif w.naxis == 3:
w = w.dropaxis(2)
img = hdulist[0].data[0]
img = np.zeros(img.shape)
else:
print("ERROR: No datacube found. Check configuration file")
sys.exit(1)
ax = plt.subplot(projection=w)
# ax.imshow(img, vmin=cfg_par[key]['clip'],
# vmax=np.max(img), norm=mc.LogNorm(cfg_par[key]['clip']), origin='lower')
#ax.imshow(img, vmin=float(cfg_par[key]['clip'])/10000., vmax=np.min([np.max(img), float(cfg_par[key]['clip'])*1]), origin='lower')
#fig = ax.imshow(img, vmin=0, vmax=float(cfg_par[key]['clip'])/5, origin = 'lower')
fig = ax.imshow(img,
norm=mc.SymLogNorm(
float(cfg_par['source_finder']['clip']) / 5.,
vmin=float(cfg_par['source_finder']['clip']) / 5.),
origin='lower')
# fig = ax.imshow(img, norm=mc.SymLogNorm(
# float(cfg_par[key]['clip'])*10), origin='lower')
cbar = plt.colorbar(fig)
cbar.set_label('Flux Density [Jy/beam]')
#ax.imshow(img, vmin=, origin='lower')
#ax.coords.grid(color='white', ls='solid')
ax.coords[0].set_axislabel('Right Ascension')
ax.coords[1].set_axislabel('Declination')
ax.coords[0].set_major_formatter('hh:mm')
ax.set_title("{0:s}".format(cfg_par['general']['workdir'].split('/')[-2]))
#ax.coords[0].set_ticks(direction='in')
#ax.coords[1].set_ticks(direction='in')
# ax.tick_params(axis='both', bottom='on', top='on', left='on', right='on',
# which='major', direction='in')
mirCatalogFile = cfg_par['general']['absdir'] + 'mir_src_sharp.csv'
catalog_table = '{:s}{:s}'.format(
cfg_par['general'].get('absdir'),
cfg_par['source_catalog'].get('catalog_file'))
catalog_pybdsf = '{:s}{:s}'.format(
cfg_par['general'].get('workdir'),
cfg_par['source_catalog'].get('catalog_file'))
if os.path.exists(mirCatalogFile):
src_list = ascii.read(mirCatalogFile)
coord_list = SkyCoord(src_list['ra'],
src_list['dec'],
unit=(u.hourangle, u.deg),
frame='fk5')
for k in range(len(coord_list.ra)):
ax.scatter(coord_list[k].ra.value,
coord_list[k].dec.value,
transform=ax.get_transform('fk5'),
edgecolor='red',
facecolor='none')
ax.annotate("{0:d}".format(k + 1),
xy=(coord_list[k].ra.value, coord_list[k].dec.value),
xycoords=ax.get_transform('fk5'),
xytext=(1, 1),
textcoords='offset points',
ha='left',
color="white")
elif os.path.exists(catalog_pybdsf) and (
cfg_par['source_catalog']['catalog'] == 'PYBDSF'):
import Tigger
from astropy.coordinates import Angle
model = Tigger.load(catalog_pybdsf)
sources = model.sources
ra = []
dec = []
for source in sources:
ra_deg_angle = Angle(np.rad2deg(source.pos.ra) * u.deg)
dec_deg_angle = Angle(np.rad2deg(source.pos.dec) * u.deg)
ra.append(ra_deg_angle)
dec.append(dec_deg_angle)
coord_list = SkyCoord(ra, dec, unit=(u.deg, u.deg), frame='fk5')
for k in range(len(coord_list.ra)):
ax.scatter(coord_list[k].ra.value,
coord_list[k].dec.value,
transform=ax.get_transform('fk5'),
edgecolor='red',
facecolor='none')
ax.annotate("{0:d}".format(k + 1),
xy=(coord_list[k].ra.value, coord_list[k].dec.value),
xycoords=ax.get_transform('fk5'),
xytext=(1, 1),
textcoords='offset points',
ha='left',
color="white")
elif os.path.exists(catalog_table) and (
cfg_par['source_catalog']['catalog'] == 'NVSS'):
src_list = ascii.read(catalog_table)
ra = np.array(src_list['RAJ2000'], dtype=str)
dec = np.array(src_list['DEJ2000'], dtype=str)
pixels = np.zeros([len(ra), 2])
kk = []
cube_im = cfg_par['general']['cubename']
#load wcs system
hdulist = fits.open(cube_im) # read input
# read data and header
#what follows works for wcs, but can be written better
prihdr = hdulist[0].header
w = wcs.WCS(prihdr)
if w.naxis == 4:
w = w.dropaxis(3)
w = w.dropaxis(2)
if w.naxis == 3:
w = w.dropaxis(2)
ra_vec = []
dec_vec = []
for i in xrange(0, len(ra)):
if ra[i] == 'nan':
pixels[i, 0] = np.nan
pixels[i, 1] = np.nan
else:
ra_deg = conv_units.ra2deg(ra[i])
dec_deg = conv_units.dec2deg(dec[i])
px, py = w.wcs_world2pix(ra_deg, dec_deg, 0)
if (0 < round(px, 0) < prihdr['NAXIS1']
and 0 < round(py, 0) < prihdr['NAXIS2']):
kk.append(i)
ra_vec.append(ra[i])
dec_vec.append(dec[i])
else:
pass
coord_list = SkyCoord(ra_vec,
dec_vec,
unit=(u.hourangle, u.deg),
frame='fk5')
for k in range(len(coord_list.ra)):
ax.scatter(coord_list[k].ra.value,
coord_list[k].dec.value,
transform=ax.get_transform('fk5'),
edgecolor='red',
facecolor='none')
ax.annotate("{0:s}".format(str(kk[k])),
xy=(coord_list[k].ra.value, coord_list[k].dec.value),
xycoords=ax.get_transform('fk5'),
xytext=(1, 1),
textcoords='offset points',
ha='left',
color="white")
output = "{0:s}{1:s}_continuum.png".format(
cfg_par['general'].get('plotdir'),
cfg_par['general']['workdir'].split('/')[-2])
if cfg_par['abs_plot']['plot_format'] == "pdf":
plt.savefig(output.replace(".png", ".pdf"),
overwrite=True,
bbox_inches='tight')
else:
plt.savefig(output, overwrite=True, bbox_inches='tight', dpi=300)
# to one decade in the logarithmic range.
N = 100
X, Y = np.mgrid[-3:3:complex(0, N), -2:2:complex(0, N)]
Z1 = np.exp(-X**2 - Y**2)
Z2 = np.exp(-(X - 1)**2 - (Y - 1)**2)
Z = (Z1 - Z2) * 2
fig, ax = plt.subplots(2, 1)
pcm = ax[0].pcolormesh(X,
Y,
Z,
norm=colors.SymLogNorm(linthresh=0.03,
linscale=0.03,
vmin=-1.0,
vmax=1.0,
base=10),
cmap='RdBu_r',
shading='auto')
fig.colorbar(pcm, ax=ax[0], extend='both')
pcm = ax[1].pcolormesh(X, Y, Z, cmap='RdBu_r', vmin=-np.max(Z), shading='auto')
fig.colorbar(pcm, ax=ax[1], extend='both')
plt.show()
###############################################################################
# Power-law
# ---------
#
# Sometimes it is useful to remap the colors onto a power-law
if np.min(j_xy) == np.max(j_xy):
continue
tickld = [-10, -1, 0, 1, 10]
tick_r = np.logspace(-0.5, 1.5, 20)
tick_r = tick_r.tolist()
tick_l = -np.logspace(-0.5, 1.5, 20)
tick_l = tick_l.tolist()
tick_l.reverse()
tick_l = tick_l + tick_r
print(tick_l)
plt.contourf(X,
Y,
jx.T,
levels=tick_l,
norm=mcolors.SymLogNorm(linthresh=10**(-0.5),
linscale=0.2,
vmin=-10**1.5,
vmax=10**1.5),
cmap='RdBu')
eee = 100. #np.max([-np.min(ex.T),np.max(ex.T)])
#levels = np.logspace(-1, 2, 40)
#plt.contourf(X, Y, jx.T, norm=mcolors.SymLogNorm(linthresh=0.03, linscale=0.03, vmin=-30.0, vmax=30.0), cmap='RdBu_r')
#### manifesting colorbar, changing label and axis properties ####
cbar = plt.colorbar(pad=0.01, ticks=tickld)
cbar.set_label('$j_{x}$ [$I_A/\lambda^2$]', fontdict=font)
cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(), fontsize=15)
## s_j=1
## X = X[::s_j,::s_j]
## Y = Y[::s_j,::s_j]
## j_xy = j_xy.T; jx = jx.T; jy=jy.T
## j_xy = j_xy[::s_j,::s_j]
## jx = jx[::s_j,::s_j]
def make_frame(frame_dir, frame, image_dir, frames, global_vars, add_ds_patches = False, ss= False, ds_wall_params=[0.05,0.05,0.15,0.4], fig_size=(16,16), lin_thresh = 0.1, lin_scale = 1., **kwargs):
# print i
global rhoMin, rhoMax
frame_number = (frame.split("_")[1]).split(".")[0]
QuantumState = np.load(frame_dir)
if int(frame_number) == 0:
set_globals(global_vars, QuantumState)
RhoFields = []
PhaseFields = []
num_comps = int(len(QuantumState[0,0,0,:])/2)
for comp in xrange(num_comps):
rho = (QuantumState[:,:,0,2*comp]+QuantumState[:,:,0,2*comp+1])*(QuantumState[:,:,0,2*comp]+QuantumState[:,:,0,2*comp+1]).conjugate()
RhoFields.append(rho/np.sum(rho))
PhaseFields.append(np.arctan2((QuantumState[:,:,0,2*comp]+QuantumState[:,:,0,2*comp+1]).imag,(QuantumState[:,:,0,2*comp]+QuantumState[:,:,0,2*comp+1]).real) + np.pi)
if int(frame_number) == 0:
for comp in xrange(num_comps):
if np.amax(RhoFields[comp].real)>rhoMax:
rhoMax = np.amax(RhoFields[comp].real)
if np.amin(RhoFields[comp].real)<rhoMin:
rhoMin = np.amin(RhoFields[comp].real)
fig, axs = plt.subplots(num_comps, 2, figsize=fig_size, constrained_layout=True)
#Ref below
time = int(frame_number)
time_text = plt.suptitle(r'$\tau = $' + str(time), fontsize=14, horizontalalignment='center',verticalalignment='top')
print num_comps
cases = np.arange(2*num_comps)
for ax, case in zip(axs, cases):
if case%2==0:
print ax
im = ax.imshow(RhoFields[int(case/2)].real, extent=(np.amin(yAxis), np.amax(yAxis), np.amin(xAxis), np.amax(xAxis)), origin = 'lower',
alpha = 1.0, cmap=colorMapBlue, norm=colors.SymLogNorm(linthresh=lin_thresh*rhoMax,linscale=lin_scale,vmin=0.,vmax=rhoMax))
putLabels(fig,ax,im,r'$y\ \ (\ell)$', r'$x\ \ (\ell)$', r'$\rho \ \ (\frac{1}{\ell^2})$')
ax.set_aspect('auto')
else:
# # Phase
im = ax.imshow((PhaseFields[int(case/2)].real), extent=(np.amin(yAxis), np.amax(yAxis), np.amin(xAxis), np.amax(xAxis)), origin = 'lower',
cmap=colorMapPhase, norm=colors.Normalize(vmin=0.,vmax=2.*np.pi))
# Any value whose absolute value is > .0001 will have zero transparency
rhoMaxCase = np.amax(RhoFields[int(case/2)].real)
alphas = Normalize(0, rhoMaxCase, clip=True)((rhoMaxCase-RhoFields[int(case/2)].real))
# # alphas = colors.SymLogNorm(linthresh=linThresh*rhoMax,linscale=linScale,vmin=0.,vmax=10., clip=True)((rhoMax-RhoField.real).T)
# alphas = np.clip(np.sqrt(alphas), 0.0, 1) # alpha value clipped at the bottom at .4
# Normalize the colors b/w 0 and 1, we'll then pass an MxNx4 array to imshow
cmap = plt.cm.gist_gray.reversed()
colorsMap = colors.SymLogNorm(linthresh=lin_thresh*rhoMaxCase,linscale=lin_scale,vmin=0.,vmax=rhoMaxCase)((0.*RhoFields[int(case/2)].real))
colorsMap = cmap(colorsMap)
# Now set the alpha channel to the one we created above
colorsMap[..., -1] = alphas
ax.imshow(colorsMap, origin = 'lower')
putLabels(fig,ax,im,r'$y\ \ (\ell)$', r'$x\ \ (\ell)$', r'$\theta \ \ (Radians)$')
if add_ds_patches:
#Add walls and screen
slit_width = ds_wall_params[0]*xSize
wall_width = ds_wall_params[1]*xSize
spacing = ds_wall_params[2]*xSize
wall_center = ds_wall_params[3]*xSize
#Double slit
ax.add_patch(patches.Rectangle(
(0.,wall_center-wall_width/2.), #xLoc,yLoc
ySize/2. - spacing/2. - slit_width/2., #Width
wall_width, #Height
color = 'black'
)
)
if ss==False:
ax.add_patch(patches.Rectangle(
((ySize-1.)/2. - spacing/2. + slit_width/2.,wall_center-wall_width/2.), #xLoc,yLoc
spacing - slit_width, #Width
wall_width, #Height
color = 'black'
)
)
ax.add_patch(patches.Rectangle(
((ySize-1.)/2. + spacing/2. + slit_width/2.,wall_center-wall_width/2.), #xLoc,yLoc
ySize/2. - spacing/2. - slit_width/2., #Width
wall_width, #Height
color = 'black'
)
)
#Screen
ax.add_patch(patches.Rectangle(
(0.,2.*(xSize)/3.), #xLoc,yLoc
ySize, #Width
wall_width/8., #Height
color = 'red'
)
)
#Boundary walls
ax.add_patch(patches.Rectangle(
(0.,0.), #xLoc,yLoc
ySize, #Width
xSize/50., #Height
color = 'black'
)
)
ax.add_patch(patches.Rectangle(
(0.,xSize-xSize/50.), #xLoc,yLoc
ySize, #Width
xSize/50., #Height
color = 'black'
)
)
param_image = fits.getdata(chemMaps_fits_address, param, ver=1)
if param == 'O':
O2 = np.power(
10,
fits.getdata(chemMaps_fits_address, 'O2', ver=1) - 12)
O3 = np.power(
10,
fits.getdata(chemMaps_fits_address, 'O3', ver=1) - 12)
param_image = 12 + np.log10(O2 + O3)
latex_labels['O'] = r'12+log(O)'
else:
param_image = fits.getdata(chemMaps_fits_address, param, ver=1)
im = ax.imshow(flux6563_image,
cmap=halpha_cmap,
norm=colors.SymLogNorm(
linthresh=halpha_thresd_level,
vmin=halpha_min_level,
base=10))
im2 = ax.imshow(param_image)
cbar = fig.colorbar(im2, ax=ax)
param_label = latex_labels[param]
ax.update({
'title': r'Galaxy {}, {}'.format(obj, param_label),
'xlabel': r'RA',
'ylabel': r'DEC'
})
ax.set_xlim(120, 210)
ax.set_ylim(110, 220)
plt.tight_layout()
plt.show()
60000, 100000, 200000
]
#plt.contourf(x,y,data,cmap=,resolution='c')
# ticks=[1e0,5e0,1e1,2e1,5e1,1e2,2e2,5e2,1e3,2e3,5e3,1e4,3e4,6e4,1e5]
ticks4 = [-1e3, -1e2, -1e1, 1e1, 1e2, 1e3]
ticks4 = [-1e3, -5e2, -1e2, -5e1, -1e1, 1e1, 5e1, 1e2, 5e2, 1e3]
ticks4_label = [str(o) for o in ticks4]
flag2 = ticks
plt.contourf(x,
y,
data,
ticks4,
norm=colors.SymLogNorm(linthresh=1e1,
linscale=1e0,
vmin=-1e3,
vmax=1e3),
cmap='RdYlBu_r',
format='%.0e')
#plt.contourf(x,y,data,ticks3,norm=colors.LogNorm(vmin=1e-5,vmax=8e4),cmap='RdYlBu_r', format = '%.0e')
#plt.contourf(x,y,data,ticks3,norm=colors.LogNorm(vmin=pow(10,1),vmax=pow(10,6)),cmap=plt.cm.jet,resolution='c', format = '%.0e')
#plt.clim((pow(10,3),pow(10,7)))
plt.plot(lat1, trop_height.data, 'k--')
mn = 0.1
mx = 100000
md = (mx - mn) / 2
print('\nThe maximum value of particle number is = ',
np.max(data))
print('\nThe minimum value of particle number is = ',
np.min(data))
print('\nThe mean value of particle number is = ',
def main():
# Load a sample air temperatures sequence.
file_path = iris.sample_data_path("E1_north_america.nc")
temperatures = iris.load_cube(file_path)
# Create a year-number coordinate from the time information.
iris.coord_categorisation.add_year(temperatures, "time")
# Create a sample anomaly field for one chosen year, by extracting that
# year and subtracting the time mean.
sample_year = 1982
year_temperature = temperatures.extract(iris.Constraint(year=sample_year))
time_mean = temperatures.collapsed("time", iris.analysis.MEAN)
anomaly = year_temperature - time_mean
# Construct a plot title string explaining which years are involved.
years = temperatures.coord("year").points
plot_title = "Temperature anomaly"
plot_title += "\n{} differences from {}-{} average.".format(
sample_year, years[0], years[-1])
# Define scaling levels for the logarithmic colouring.
minimum_log_level = 0.1
maximum_scale_level = 3.0
# Use a standard colour map which varies blue-white-red.
# For suitable options, see the 'Diverging colormaps' section in:
# http://matplotlib.org/stable/gallery/color/colormap_reference.html
anom_cmap = "bwr"
# Create a 'logarithmic' data normalization.
anom_norm = mcols.SymLogNorm(
linthresh=minimum_log_level,
linscale=0,
vmin=-maximum_scale_level,
vmax=maximum_scale_level,
)
# Setting "linthresh=minimum_log_level" makes its non-logarithmic
# data range equal to our 'zero band'.
# Setting "linscale=0" maps the whole zero band to the middle colour value
# (i.e. 0.5), which is the neutral point of a "diverging" style colormap.
# Create an Axes, specifying the map projection.
plt.axes(projection=ccrs.LambertConformal())
# Make a pseudocolour plot using this colour scheme.
mesh = iplt.pcolormesh(anomaly, cmap=anom_cmap, norm=anom_norm)
# Add a colourbar, with extensions to show handling of out-of-range values.
bar = plt.colorbar(mesh, orientation="horizontal", extend="both")
# Set some suitable fixed "logarithmic" colourbar tick positions.
tick_levels = [-3, -1, -0.3, 0.0, 0.3, 1, 3]
bar.set_ticks(tick_levels)
# Modify the tick labels so that the centre one shows "+/-<minumum-level>".
tick_levels[3] = r"$\pm${:g}".format(minimum_log_level)
bar.set_ticklabels(tick_levels)
# Label the colourbar to show the units.
bar.set_label("[{}, log scale]".format(anomaly.units))
# Add coastlines and a title.
plt.gca().coastlines()
plt.title(plot_title)
# Display the result.
iplt.show()
def _norm_kwargs(self, element, ranges, opts, vdim, prefix=''):
"""
Returns valid color normalization kwargs
to be passed to matplotlib plot function.
"""
clim = opts.pop(prefix + 'clims', None)
values = np.asarray(element.dimension_values(vdim))
if clim is None:
if not len(values):
clim = (0, 0)
categorical = False
elif values.dtype.kind in 'uif':
clim = ranges[
vdim.name] if vdim.name in ranges else element.range(vdim)
if self.logz:
# Lower clim must be >0 when logz=True
# Choose the maximum between the lowest non-zero value
# and the overall range
if clim[0] == 0:
clim = (values[values != 0].min(), clim[1])
if self.symmetric:
clim = -np.abs(clim).max(), np.abs(clim).max()
categorical = False
else:
clim = (0, len(np.unique(values)) - 1)
categorical = True
else:
categorical = values.dtype.kind not in 'uif'
if self.logz:
if self.symmetric:
norm = mpl_colors.SymLogNorm(vmin=clim[0],
vmax=clim[1],
linthresh=clim[1] / np.e)
else:
norm = mpl_colors.LogNorm(vmin=clim[0], vmax=clim[1])
opts[prefix + 'norm'] = norm
opts[prefix + 'vmin'] = clim[0]
opts[prefix + 'vmax'] = clim[1]
# Check whether the colorbar should indicate clipping
if values.dtype.kind not in 'OSUM':
ncolors = self.color_levels
try:
el_min, el_max = np.nanmin(values), np.nanmax(values)
except ValueError:
el_min, el_max = -np.inf, np.inf
else:
ncolors = clim[-1] + 1
el_min, el_max = -np.inf, np.inf
vmin = -np.inf if opts[prefix + 'vmin'] is None else opts[prefix +
'vmin']
vmax = np.inf if opts[prefix + 'vmax'] is None else opts[prefix +
'vmax']
if el_min < vmin and el_max > vmax:
self._cbar_extend = 'both'
elif el_min < vmin:
self._cbar_extend = 'min'
elif el_max > vmax:
self._cbar_extend = 'max'
# Define special out-of-range colors on colormap
cmap = opts.get(prefix + 'cmap', 'viridis')
colors = {}
for k, val in self.clipping_colors.items():
if val == 'transparent':
colors[k] = {'color': 'w', 'alpha': 0}
elif isinstance(val, tuple):
colors[k] = {
'color': val[:3],
'alpha': val[3] if len(val) > 3 else 1
}
elif isinstance(val, util.basestring):
color = val
alpha = 1
if color.startswith('#') and len(color) == 9:
alpha = int(color[-2:], 16) / 255.
color = color[:-2]
colors[k] = {'color': color, 'alpha': alpha}
if not isinstance(cmap, mpl_colors.Colormap):
if isinstance(cmap, dict):
factors = np.unique(values)
palette = [
cmap.get(
f,
colors.get('NaN',
{'color': self._default_nan})['color'])
for f in factors
]
else:
palette = process_cmap(cmap, ncolors, categorical=categorical)
cmap = mpl_colors.ListedColormap(palette)
if 'max' in colors: cmap.set_over(**colors['max'])
if 'min' in colors: cmap.set_under(**colors['min'])
if 'NaN' in colors: cmap.set_bad(**colors['NaN'])
opts[prefix + 'cmap'] = cmap
# %%
varlist = ['NCONC01', 'NMR01', 'AWNC_incld', 'AREL_incld']
cbar_orientation = 'vertical'
cases_ctrl = cases_orig
case_oth = cases_sec[0]
ncol = len(cases_ctrl)
nrow = len(varlist)
subfig_size = 2.5
asp_ratio = 1.6
figsize = [subfig_size * ncol * asp_ratio, subfig_size * nrow]
# noinspection PyTypeChecker
fig, axs = plt.subplots(nrow, ncol, figsize=figsize, sharex=True, sharey=True)
norm_dic = dict(
NCONC01=colors.SymLogNorm(vmin=-1e3, vmax=1e3, linthresh=10),
NMR01=colors.SymLogNorm(vmin=-10, vmax=10, linthresh=1),# linscale=.5),
AWNC_incld=colors.SymLogNorm(vmin=-20, vmax=20, linthresh=1),
AREL_incld=colors.SymLogNorm(vmin=-5, vmax=5, linthresh=.1)
)
cases_dic = get_averaged_fields.get_levlat_cases(cases, varlist, startyear, endyear,
pressure_adjust=pressure_adjust)
for j, var in enumerate(varlist):
saxs = axs[j, :]
levlat_more_cases_var(var, case_oth, cases_ctrl, cases_dic, cbar_eq=True,
cbar_orientation='vertical',
axs=saxs,
norm=norm_dic[var],
relative=False,
ylim=[1e3, 200],
width_ratios=widthRatios)
ax = []
cax = []
for n in range(nRows):
if n == 0: ax.append(fig.add_subplot(gs[n, 0]))
else: ax.append(fig.add_subplot(gs[n, 0], sharex=ax[0]))
cax.append(fig.add_subplot(gs[n, 1]))
extent = [tmin, tmax, np.log10(do.rmin), np.log10(do.rmax)]
aspect = 0.3 * (tmax - tmin) / (np.log10(do.rmax) - np.log10(do.rmin))
axNum = 0
im = ax[axNum].imshow(np.transpose(np.fliplr(do.data[12][tiMin:tiMax])),
extent=extent,
aspect=aspect,
cmap=plt.get_cmap('coolwarm'),
norm=colors.SymLogNorm(linthresh=0.1,
linscale=1.0,
vmin=-1.0,
vmax=1.0))
ax[axNum].set_ylabel('log(r) (AU)')
ax[axNum].set_title(do.header[12] + " (G)")
#ax[axNum].axhline(np.log10(do.inp.rIn), color='k')
ax[axNum].axhline(np.log10(do.inp.rDz1), color='k', linestyle='--')
ax[axNum].set_xlabel("Time (yr)")
fig.colorbar(im, cax=cax[axNum], orientation='vertical')
plt.savefig(do.savePath + "justBz.png", bbox_inches='tight')
#
def plot(
self,
i=0,
iaz=0,
vmin=None,
vmax=None,
dynamic_range=1e6,
fpeak=None,
axes_unit='arcsec',
colorbar=True,
type='I',
scale=None,
pola_vector=False,
vector_color="white",
nbin=5,
psf_FWHM=None,
bmaj=None,
bmin=None,
bpa=None,
plot_beam=None,
conv_method=None,
mask=None,
cmap=None,
ax=None,
no_xlabel=False,
no_ylabel=False,
no_xticks=False,
no_yticks=False,
title=None,
limit=None,
limits=None,
coronagraph=None,
clear=False,
Tb=False,
):
# Todo:
# - plot a selected contribution
# - add a mask on the star ?
# bmin and bamj in arcsec
if clear:
plt.clf()
if ax is None:
ax = plt.gca()
ax.cla()
pola_needed = type in ['Q', 'U', 'Qphi', 'Uphi', 'P', 'PI', 'PA'
] or pola_vector
contrib_needed = type in ['star', 'scatt', 'em_th', 'scatt_em_th']
if pola_needed and contrib_needed:
raise ValueError(
'Cannot separate both polarisation and contributions')
# --- We first check if the requested image is present in the mcfost fits file
ntype_flux = self.image.shape[0]
if ntype_flux not in (4, 8): # there is no pola
if pola_needed:
raise ValueError('The model does not have polarisation data')
elif ntype_flux not in (5, 8): # there is no contribution
if contrib_needed:
raise ValueError('The model does not have contribution data')
# --- Compute pixel scale and extent of image
if axes_unit.lower() == 'arcsec':
pix_scale = self.pixelscale
xlabel = r'$\Delta$ Ra ["]'
ylabel = r'$\Delta$ Dec ["]'
elif axes_unit.lower() == 'au':
pix_scale = self.pixelscale * self.P.map.distance
xlabel = 'Distance from star [au]'
ylabel = 'Distance from star [au]'
elif axes_unit.lower() == 'pixels' or axes_unit.lower() == 'pixel':
pix_scale = 1
xlabel = r'$\Delta$ x [pix]'
ylabel = r'$\Delta$ y [pix]'
else:
raise ValueError("Unknown unit for axes_units: " + axes_unit)
halfsize = np.asarray(self.image.shape[-2:]) / 2 * pix_scale
extent = [-halfsize[0], halfsize[0], -halfsize[1], halfsize[1]]
# --- Beam or psf: psf_FWHM and bmaj and bmin are in arcsec, bpa in deg
i_convolve = False
beam = None
if psf_FWHM is not None:
sigma = (psf_FWHM / self.pixelscale *
(2.0 * np.sqrt(2.0 * np.log(2)))) # in pixels
beam = Gaussian2DKernel(sigma)
i_convolve = True
bmin = psf_FWHM
bmaj = psf_FWHM
bpa = 0
if plot_beam is None:
plot_beam = True
if bmaj is not None:
sigma_x = bmin / self.pixelscale * FWHM_to_sigma # in pixels
sigma_y = bmaj / self.pixelscale * FWHM_to_sigma # in pixels
beam = Gaussian2DKernel(sigma_x, sigma_y, bpa * np.pi / 180)
i_convolve = True
if plot_beam is None:
plot_beam = True
# --- Selecting convolution function
if conv_method is None:
conv_method = convolve_fft
# --- Intermediate images
if pola_needed:
I = self.image[0, i, iaz, :, :]
Q = self.image[1, i, iaz, :, :]
U = self.image[2, i, iaz, :, :]
elif contrib_needed:
if pola_needed:
n_pola = 4
else:
n_pola = 1
if type == "star":
I = self.image[n_pola, i, iaz, :, :]
elif type == "scatt":
I = self.image[n_pola + 1, i, iaz, :, :]
elif type == "em_th":
I = self.image[n_pola + 2, i, iaz, :, :]
elif type == "scatt_em_th":
I = self.image[n_pola + 3, i, iaz, :, :]
else:
if self.is_casa:
I = self.image[i, iaz, :, :]
else:
I = self.image[0, i, iaz, :, :]
# --- Convolve with beam
if i_convolve:
I = conv_method(I, beam)
if pola_needed:
Q = conv_method(Q, beam)
U = conv_method(U, beam)
# -- Conversion to brightness temperature
if Tb:
if self.is_casa:
I = Jy_to_Tb(I, self.freq, self.pixelscale)
else:
I = Wm2_to_Tb(I, self.freq, self.pixelscale)
I = np.nan_to_num(I)
print("Max Tb=", np.max(I), "K")
# --- Coronagraph: in mas
if coronagraph is not None:
halfsize = np.asarray(self.image.shape[-2:]) / 2
posx = np.linspace(-halfsize[0], halfsize[0], self.nx)
posy = np.linspace(-halfsize[1], halfsize[1], self.ny)
meshx, meshy = np.meshgrid(posx, posy)
radius_pixel = np.sqrt(meshx**2 + meshy**2)
radius_mas = radius_pixel * pix_scale * 1000
I[radius_mas < coronagraph] = 0.0
if pola_needed:
Q[radius_mas < coronagraph] = 0.0
U[radius_mas < coronagraph] = 0.0
# --- Selecting image to plot & convolution
unit = self.unit
flux_name = type
if type == 'I':
flux_name = 'Flux density'
im = I
_scale = 'log'
elif type == 'Q':
im = Q
_scale = 'symlog'
elif type == 'U':
im = U
_scale = 'symlog'
elif type == 'P':
I = I + (I == 0.0) * 1e-30
im = 100 * np.sqrt((Q / I)**2 + (U / I)**2)
unit = "%"
_scale = 'lin'
elif type == 'PI':
im = np.sqrt(np.float64(Q)**2 + np.float64(U)**2)
_scale = 'log'
elif type in ('Qphi', 'Uphi'):
X = np.arange(1, self.nx + 1) - self.cx
Y = np.arange(1, self.ny + 1) - self.cy
X, Y = np.meshgrid(X, Y)
two_phi = 2 * np.arctan2(Y, X)
if type == 'Qphi':
im = Q * np.cos(two_phi) + U * np.sin(two_phi)
else: # Uphi
im = -Q * np.sin(two_phi) + U * np.cos(two_phi)
_scale = 'symlog'
# --- Plot range and color scale
if vmax is None:
vmax = im.max()
if fpeak is not None:
vmax = im.max() * fpeak
if vmin is None:
if type in ["Q", "U"]:
vmin = -vmax
else:
vmin = im.min()
if scale is None:
scale = _scale
if scale == 'symlog':
norm = colors.SymLogNorm(1e-6 * vmax,
vmin=vmin,
vmax=vmax,
clip=True)
elif scale == 'log':
if vmin <= 0.0:
vmin = 1e-6 * vmax
print(vmin)
norm = colors.LogNorm(vmin=vmin, vmax=vmax, clip=True)
elif scale == 'lin':
norm = colors.Normalize(vmin=vmin, vmax=vmax, clip=True)
else:
raise ValueError("Unknown color scale: " + scale)
# --- Set color map
if cmap is None:
cmap = default_cmap
try:
cmap = copy.copy(cm.get_cmap(cmap))
except:
raise ValueError("Unknown colormap: " + cmap)
try:
cmap.set_bad(cmap.colors[0])
except:
try:
cmap.set_bad(cmap(0.0))
except:
raise Warning("Can't set bad values from given colormap")
# --- Making the actual plot
img = ax.imshow(im,
norm=norm,
extent=extent,
origin='lower',
cmap=cmap)
if limit is not None:
limits = [-limit, limit, -limit, limit]
if limits is not None:
ax.set_xlim(limits[0], limits[1])
ax.set_ylim(limits[2], limits[3])
if not no_xlabel:
ax.set_xlabel(xlabel)
if not no_ylabel:
ax.set_ylabel(ylabel)
if no_xticks:
ax.get_xaxis().set_visible(False)
if no_yticks:
ax.get_yaxis().set_visible(False)
if title is not None:
ax.set_title(title)
# --- Colorbar
if colorbar:
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.05)
cb = plt.colorbar(img, cax=cax)
formatted_unit = unit.replace("-1",
"$^{-1}$").replace("-2", "$^{-2}$")
cb.set_label(flux_name + " [" + formatted_unit + "]")
# --- Overplotting polarisation vectors
if pola_vector:
X = (np.arange(1, self.nx + 1) - self.cx) * pix_scale
Y = (np.arange(1, self.ny + 1) - self.cy) * pix_scale
X, Y = np.meshgrid(X, Y)
Xb = bin_image(X, nbin, func=np.mean)
Yb = bin_image(Y, nbin, func=np.mean)
Ib = bin_image(I, nbin)
Qb = bin_image(Q, nbin)
Ub = bin_image(U, nbin)
pola = 100 * np.sqrt((Qb / Ib)**2 + (Ub / Ib)**2)
theta = 0.5 * np.arctan2(Ub, Qb)
pola_x = -pola * np.sin(
theta
) # Ref is N (vertical axis) --> sin, and Est is toward left --> -
pola_y = pola * np.cos(theta)
plt.quiver(
Xb,
Yb,
pola_x,
pola_y,
headwidth=0,
headlength=0,
headaxislength=0.0,
pivot='middle',
color=vector_color,
)
# --- Adding beam
if plot_beam:
dx = 0.125
dy = 0.125
beam = Ellipse(
ax.transLimits.inverted().transform((dx, dy)),
width=bmin,
height=bmaj,
angle=bpa,
fill=True,
color="grey",
)
ax.add_patch(beam)
# --- Adding mask
if mask is not None:
dx = 0.5
dy = 0.5
mask = Ellipse(
ax.transLimits.inverted().transform((dx, dy)),
width=2 * mask,
height=2 * mask,
fill=True,
color='grey',
)
ax.add_patch(mask)
# --- Return
return img
