def make_spectra(dataset, maps, tels=['AP-H201-X202', 'AP-H201-X201']):
cl = read_class.ClassObject(
os.path.join(make_apex_cubes.april2014path, dataset) + ".apex")
for tel in tels:
for map in maps:
spectra = cl.get_spectra(sourcere='^' + map, telescope=tel)
data = np.array([s for s, h in spectra])
header = spectra[0][1]
xarr = read_class.make_axis(header)
sp = pyspeckit.Spectrum(data=data.mean(axis=0),
header=read_class.clean_header(header),
xarr=xarr)
sp.write(
paths.dpath('field_spectra/{name}_{window}_{date}.fits'.format(
name=sp.specname,
window=sp.header['XTEL'],
date=Time(sp.header['DOBS'],
format='jyear').iso.split()[0])))
datafflag = fourier_flag_spectra(data)
header['FTFLGMOD'] = (3, 'Fourier component flagged')
header['FTFLGFRC'] = (0.05, 'Bad fraction of Fourier component')
sp = pyspeckit.Spectrum(data=datafflag.mean(axis=0),
header=read_class.clean_header(header),
xarr=xarr)
sp.write(
paths.dpath(
'field_spectra/{name}_{window}_{date}_fflagged.fits'.
format(name=sp.specname,
window=sp.header['XTEL'],
date=Time(sp.header['DOBS'],
format='jyear').iso.split()[0])))
def make_spectra(dataset, maps, tels=['AP-H201-X202', 'AP-H201-X201']):
cl = read_class.ClassObject(os.path.join(make_apex_cubes.april2014path, dataset)+".apex")
for tel in tels:
for map in maps:
spectra = cl.get_spectra(sourcere='^'+map, telescope=tel)
data = np.array([s for s,h in spectra])
header = spectra[0][1]
xarr = read_class.make_axis(header)
sp = pyspeckit.Spectrum(data=data.mean(axis=0),
header=read_class.clean_header(header),
xarr=xarr)
sp.write(paths.dpath('field_spectra/{name}_{window}_{date}.fits'.format(name=sp.specname,
window=sp.header['XTEL'],
date=Time(sp.header['DOBS'],
format='jyear').iso.split()[0])))
datafflag = fourier_flag_spectra(data)
header['FTFLGMOD'] = (3, 'Fourier component flagged')
header['FTFLGFRC'] = (0.05, 'Bad fraction of Fourier component')
sp = pyspeckit.Spectrum(data=datafflag.mean(axis=0),
header=read_class.clean_header(header),
xarr=xarr)
sp.write(paths.dpath('field_spectra/{name}_{window}_{date}_fflagged.fits'.format(name=sp.specname,
window=sp.header['XTEL'],
date=Time(sp.header['DOBS'],
format='jyear').iso.split()[0])))
def do_rrlspectra():
hcubes = load_rrlcubes()
order = ['H77$\\alpha$', 'H110$\\alpha$']
pl.close(1)
pl.close(2)
fig = pl.figure(1, figsize=(12,8))
fig2 = pl.figure(2, figsize=(12,8))
colors = ['k','r','g','b','m','#11AAAA']
for regfn in regfiledict:
regions = pyregion.open(regfn)
for r in regions:
spectra = [(c,hcubes[c].get_apspec(r.coord_list,
coordsys=r.coord_format,
wunit='degree'))
for c in order]
fig.clf()
fig2.clf()
for ii,(hline,sp) in enumerate(spectra):
sp.xarr.convert_to_unit('km/s')
sp.specname = r.attr[1]['text']
sp.unit = 'K'
# fit twice: first time, sets the errors
sp.specfit(fittype='gaussian', guesses=[1,60,5], multifit=True)
sp.specfit(fittype='gaussian', guesses=[1,60,5], multifit=True)
pars = sp.specfit.modelpars
pars[2] /= 5
sp.plotter(figure=fig, xmin=40, xmax=80, color=colors[ii], clear=False,
label=hline)
ax1 = sp.plotter.axis
sp.plotter(figure=fig2, xmin=00, xmax=120, color=colors[ii], clear=False,
label=hline, linewidth=2)
ax2 = sp.plotter.axis
sp.specfit.plot_fit(composite_fit_color=colors[ii+2], annotate=False)
box = ax2.get_position()
ax2.set_position([box.x0, box.y0, box.width * 0.9, box.height])
sp.specfit.annotate(bbox_to_anchor=(1.01,0.95) if '110' in hline else (1.01, 0.75), loc='upper left',
fontsize=14)
sp.plotter.axis.set_ylabel("$T_A^*$ (K)")
fig2.savefig(dpath(regfiledict[regfn]+"_wideplot_RRL_aperture_%s.pdf" % sp.specname),
bbox_extra_artists=[sp.specfit.fitleg])
fakespec = pyspeckit.Spectrum(xarr=sp.xarr,
data=sp.specfit.get_model_frompars(sp.xarr,
pars),
header=sp.header)
fakespec.plotter(axis=ax1, xmin=40, xmax=80,
color=colors[ii], clear=False,
linestyle='steps--')
rrlid = 'H77a' if '77' in hline else '110'
sp.write(dpath(regfiledict[regfn]+"_RRL%s_aperture_%s.fits" % (rrlid,sp.specname)))
sp.plotter.axis.set_ylabel("$T_A^*$ (K)")
sp.plotter.savefig(dpath(regfiledict[regfn]+"_RRL_aperture_%s.pdf" % sp.specname))
def make_rgb(
outname,
redline='H2CO303_202',
greenline='H2CO321_220',
blueline='H2CO322_221',
fntemplate=paths.dpath(
'merge/moments/W51_b6_7M_12M.{0}.image.pbcor_medsub_max.fits'),
suffix="_auto",
**kwargs):
print(outname, suffix)
rgb_cube_fits = outname
if not os.path.exists(rgb_cube_fits):
# does not return anything
aplpy.make_rgb_cube([
fntemplate.format(redline) if 'fits' not in redline else redline,
fntemplate.format(greenline)
if 'fits' not in greenline else greenline,
fntemplate.format(blueline)
if 'fits' not in blueline else blueline,
], rgb_cube_fits)
rgb_cube_png = rgb_cube_fits[:-5] + suffix + ".png"
rgb_im = aplpy.make_rgb_image(data=rgb_cube_fits,
output=rgb_cube_png,
embed_avm_tags=True,
**kwargs)
return rgb_im
def make_rgb(
outname,
redline="H2CO303_202",
greenline="H2CO321_220",
blueline="H2CO322_221",
fntemplate=paths.dpath("merge/moments/W51_b6_7M_12M.{0}.image.pbcor_medsub_max.fits"),
suffix="_auto",
**kwargs
):
print(outname, suffix)
rgb_cube_fits = outname
if not os.path.exists(rgb_cube_fits):
# does not return anything
aplpy.make_rgb_cube(
[
fntemplate.format(redline) if "fits" not in redline else redline,
fntemplate.format(greenline) if "fits" not in greenline else greenline,
fntemplate.format(blueline) if "fits" not in blueline else blueline,
],
rgb_cube_fits,
)
rgb_cube_png = rgb_cube_fits[:-5] + suffix + ".png"
rgb_im = aplpy.make_rgb_image(data=rgb_cube_fits, output=rgb_cube_png, embed_avm_tags=True, **kwargs)
return rgb_im
def get_cont(header):
contfn = paths.dpath('W51_te_continuum_best.fits')
beam = radio_beam.Beam.from_fits_header(contfn)
cont_Jy = reproject.reproject_interp(input_data=contfn,
output_projection=header)[0]*u.Jy
cont_K = cont_Jy.to(u.K, u.brightness_temperature(beam,
continuum_frequency))
return cont_K
def setup_sims(maxscale=3):
for scale in range(1,maxscale):
fh = simulate_grid_for_fitsfile(paths.dpath("w51_te_continuum_best.fits"),
separation=45*scale, amplitude_range=[0.001,0.1],
scale=scale,
random_offset=20)
fh[0].header['BUNIT'] = 'Jy/beam'
fh.writeto(paths.simpath("simimage_scale{0}_gaussian.fits".format(scale)),
clobber=True)
fh = simulate_grid_for_fitsfile(paths.dpath("w51_te_continuum_best.fits"),
separation=45*scale, amplitude_range=[0.001,0.1],
kernel=Tophat2DKernel,
scale=scale,
random_offset=20)
fh[0].header['BUNIT'] = 'Jy/beam'
fh.writeto(paths.simpath("simimage_scale{0}_tophat.fits".format(scale)),
clobber=True)
def get_mom0(fn,
vrange=[51, 60] * u.km / u.s,
exclude_vrange=[40, 75] * u.km / u.s,
percentile=30,
iterate=True):
savename = paths.dpath(
os.path.join(
os.path.split(fn)[0], 'moments',
os.path.split(fn)[1].replace(".fits", "_p30sub.fits")))
if os.path.exists(savename):
print("Loading {0} from disk".format(savename))
fh = fits.open(savename)
m0 = Projection(
value=fh[0].data,
header=fh[0].header,
wcs=wcs.WCS(fh[0].header),
unit=u.Unit(fh[0].header['BUNIT']),
)
else:
print("Computing {0} from analysis of {1}".format(savename, fn))
cube = SpectralCube.read(fn)
#bm = cube.beams[0]
#jtok = bm.jtok(cube.wcs.wcs.restfrq*u.Hz)
slab = cube.spectral_slab(*vrange)
cube.beam_threshold = 1
#contguess = cube.spectral_slab(0*u.km/u.s, 40*u.km/u.s).percentile(50, axis=0)
#contguess = cube.spectral_slab(70*u.km/u.s, 100*u.km/u.s).percentile(50, axis=0)
mask = (cube.spectral_axis < exclude_vrange[0]) | (cube.spectral_axis >
exclude_vrange[1])
masked_cube = cube.with_mask(mask[:, None, None])
try:
log.info("Continuum measurement.")
contguess = masked_cube.percentile(percentile,
axis=0,
iterate_rays=iterate,
progressbar=iterate)
except ValueError as ex:
print("skipping {0}".format(fn))
print(ex)
raise
log.info("Subtract the continuum")
slabsub = (slab - contguess)
slabsub.beam_threshold = 0.25
log.info("Compute moment 0")
m0 = slabsub.moment0()
log.info("Save results to {0}".format(savename))
m0.hdu.writeto(savename)
return m0
def ridiculous_tests():
for unit in ('Jy/beam', 'Jy/pixel', 'Jy', 'K'):
fh = simulate_grid_for_fitsfile(paths.dpath("w51_te_continuum_best.fits"),
separation=45*3, amplitude_range=[0.001,0.1],
scale=3,
random_offset=20)
assert fh[0].data.max() > 0
fh[0].header['BUNIT'] = unit
fh.writeto(paths.simpath("stupidtest_{0}.fits".format(unit.replace("/","_"))),
clobber=True)
synthetically_image_fitsfile(paths.simpath("stupidtest_{0}.fits".format(unit.replace("/","_"))),
base_name="casa_stupidtest_{0}".format(unit.replace("/","_")),
cleanup=True
)
def setup_sims(maxscale=3):
for scale in range(1, maxscale):
fh = simulate_grid_for_fitsfile(
paths.dpath("w51_te_continuum_best.fits"),
separation=45 * scale,
amplitude_range=[0.001, 0.1],
scale=scale,
random_offset=20)
fh[0].header['BUNIT'] = 'Jy/beam'
fh.writeto(paths.simpath(
"simimage_scale{0}_gaussian.fits".format(scale)),
clobber=True)
fh = simulate_grid_for_fitsfile(
paths.dpath("w51_te_continuum_best.fits"),
separation=45 * scale,
amplitude_range=[0.001, 0.1],
kernel=Tophat2DKernel,
scale=scale,
random_offset=20)
fh[0].header['BUNIT'] = 'Jy/beam'
fh.writeto(paths.simpath(
"simimage_scale{0}_tophat.fits".format(scale)),
clobber=True)
def ridiculous_tests():
for unit in ('Jy/beam', 'Jy/pixel', 'Jy', 'K'):
fh = simulate_grid_for_fitsfile(
paths.dpath("w51_te_continuum_best.fits"),
separation=45 * 3,
amplitude_range=[0.001, 0.1],
scale=3,
random_offset=20)
assert fh[0].data.max() > 0
fh[0].header['BUNIT'] = unit
fh.writeto(paths.simpath("stupidtest_{0}.fits".format(
unit.replace("/", "_"))),
clobber=True)
synthetically_image_fitsfile(
paths.simpath("stupidtest_{0}.fits".format(unit.replace("/",
"_"))),
base_name="casa_stupidtest_{0}".format(unit.replace("/", "_")),
cleanup=True)
def get_mom0(fn, vrange=[51,60]*u.km/u.s, exclude_vrange=[40,75]*u.km/u.s,
percentile=30, iterate=True):
savename = paths.dpath(os.path.join(os.path.split(fn)[0], 'moments',
os.path.split(fn)[1].replace(".fits","_p30sub.fits")))
if os.path.exists(savename):
print("Loading {0} from disk".format(savename))
fh = fits.open(savename)
m0 = Projection(value=fh[0].data, header=fh[0].header,
wcs=wcs.WCS(fh[0].header),
unit=u.Unit(fh[0].header['BUNIT']),)
else:
print("Computing {0} from analysis of {1}".format(savename, fn))
cube = SpectralCube.read(fn)
#bm = cube.beams[0]
#jtok = bm.jtok(cube.wcs.wcs.restfrq*u.Hz)
slab = cube.spectral_slab(*vrange)
cube.beam_threshold = 1
#contguess = cube.spectral_slab(0*u.km/u.s, 40*u.km/u.s).percentile(50, axis=0)
#contguess = cube.spectral_slab(70*u.km/u.s, 100*u.km/u.s).percentile(50, axis=0)
mask = (cube.spectral_axis<exclude_vrange[0]) | (cube.spectral_axis > exclude_vrange[1])
masked_cube = cube.with_mask(mask[:,None,None])
try:
log.info("Continuum measurement.")
contguess = masked_cube.percentile(percentile, axis=0,
iterate_rays=iterate,
progressbar=iterate)
except ValueError as ex:
print("skipping {0}".format(fn))
print(ex)
raise
log.info("Subtract the continuum")
slabsub = (slab-contguess)
slabsub.beam_threshold = 0.25
log.info("Compute moment 0")
m0 = slabsub.moment0()
log.info("Save results to {0}".format(savename))
m0.hdu.writeto(savename)
return m0
def cutout_id_chem_map(yslice=slice(367,467), xslice=slice(114,214),
vrange=[51,60]*u.km/u.s, sourcename='e2',
filelist=glob.glob(paths.dpath('12m/cutouts/*e2e8*fits')),
source=None, radius=None,
chem_name='CH3OH',
shape=None, # check that shape matches slice
):
assert filelist
maps = {}
map_error = {}
energies = {}
degeneracies = {}
frequencies = {}
indices = {}
# sanity check
#shapes = [fits.getdata(fn).shape for fn in filelist]
#assert len(set(shapes)) == 1
for ii,fn in enumerate(ProgressBar(filelist)):
if chem_name not in fn:
log.debug("Skipping {0} because it doesn't have {1}".format(fn, chem_name))
continue
if 'temperature' in fn or 'column' in fn:
continue
if 'moment0' in fn:
# there is a slight danger of off-by-one-pixel errors with the
# cropping used here. Ideally, we'd reproject...
m0_full = fits.getdata(fn)
#stddev = fits.getdata(fn.replace("moment0","madstd"))
header = fits.getheader(fn)
cutout = Cutout2D(m0_full, source, 2*radius, wcs=wcs.WCS(header))
m0 = cutout.data
#cutout_std = Cutout2D(stddev, source, 2*radius, wcs=wcs.WCS(header))
#stddev = cutout_std.data
try:
beam = radio_beam.Beam.from_fits_header(header)
jtok = beam.jtok(header['RESTFRQ']*u.Hz).value
except:
jtok = 222. # approximated 0.32x0.34 at 225 GHz
m0 = m0 * jtok
# stddev = error in a single channel... not very accurate
#stddev = stddev * jtok
print("stddev for {0}".format(fn)) # this debug statement prevents abort traps
stddev = mad_std(m0_full[np.isfinite(m0_full)]) * jtok
header = cutout.wcs.to_header()
else:
cube_ = SpectralCube.read(fn)
if shape:
# have to have same shapes, otherwise pixel slices don't make sense
assert cube_.shape == shape
cube = cube_[:,yslice,xslice]
bm = cube.beams[0]
#jtok = bm.jtok(cube.wcs.wcs.restfrq*u.Hz)
cube = cube.to(u.K, bm.jtok_equiv(cube.wcs.wcs.restfrq*u.Hz))
slab = cube.spectral_slab(*vrange)
cube.beam_threshold = 1
#contguess = cube.spectral_slab(0*u.km/u.s, 40*u.km/u.s).percentile(50, axis=0)
#contguess = cube.spectral_slab(70*u.km/u.s, 100*u.km/u.s).percentile(50, axis=0)
mask = (cube.spectral_axis<40*u.km/u.s) | (cube.spectral_axis > 75*u.km/u.s)
contguess = cube.with_mask(mask[:,None,None]).percentile(30, axis=0)
stddev = cube.with_mask(mask[:,None,None]).apply_numpy_function(mad_std, axis=0)
slabsub = (slab-contguess)
slabsub.beam_threshold = 0.15
m0 = slabsub.moment0()
header = m0.hdu.header
label = linere.search(fn).groups()[0]
frq = name_to_freq[label]
closest_ind = np.argmin(np.abs(frqs - frq))
closest_key = list(rt.keys())[closest_ind]
closest_rt = rt[closest_key]
upperstate = ch3oh.data['States'][closest_rt.UpperStateRef]
upperen = u.Quantity(float(upperstate.StateEnergyValue),
unit=upperstate.StateEnergyUnit)
maps[label] = m0
map_error[label] = stddev
energies[label] = upperen
degeneracies[label] = int(upperstate.TotalStatisticalWeight)
indices[label] = closest_ind
frequencies[label] = frq
# make sure the dict indices don't change order
energy_to_key = {v:k for k,v in energies.items()}
order = sorted(energy_to_key.keys())
keys = [energy_to_key[k] for k in order]
cube = np.empty((len(maps),)+maps[label].shape)
ecube = np.empty_like(cube)
xaxis = u.Quantity([energies[k] for k in keys])
xaxis = xaxis.to(u.erg, u.spectral()).to(u.K, u.temperature_energy())
for ii,key in enumerate(keys):
# divide by degeneracy
cube[ii,:,:] = maps[key]
ecube[ii,:,:] = map_error[key]
frequencies = u.Quantity([frequencies[k] for k in keys])
indices = [indices[k] for k in keys]
degeneracies = [degeneracies[k] for k in keys]
assert xaxis.size == cube.shape[0]
return xaxis,cube,ecube,maps,map_error,energies,frequencies,indices,degeneracies,header
spectra.specfit(fittype='ch3oh',
guesses=[55, 4, 200, 5e15],
limitedmin=[True] * 4,
limitedmax=[True] * 4,
limits=[(50, 70), (1, 4), (20, 1000), (1e13, 1e18)])
ok = slaim['Species'] == 'CH3OHvt=0'
spectra.xarr.refX = 225 * u.GHz
spectra.plotter.line_ids(
line_names=[str(x) for x in slaim['Resolved QNs'][ok]],
line_xvals=freqs[ok],
velocity_offset=55.626 * u.km / u.s)
pixel_regions = pyregion.open(paths.rpath('three_e2_pixels.reg'))
colmap = fits.open(
paths.dpath('12m/moments/CH3OH_e2_cutout_columnmap.fits'))
temmap = fits.open(
paths.dpath('12m/moments/CH3OH_e2_cutout_temperaturemap.fits'))
ch3ohwcs = wcs.WCS(colmap[0].header)
target = 'SelectedPixel{0}'
for selreg, tem, col, vel, width, ylim in (
(1, 9999401, 99995.1e18, 55.2, 5.3, (-5, 100)),
(2, 9999220, 99991.3e18, 55.6, 5.3, (-5, 100)),
(3, 9999167, 99995.7e17, 53.0, 5.3, (-5, 100)),
(4, 9999127, 99991.7e17, 54.0, 5.3, (-5, 60)),
(5, 9999999, 9999999999, 55.8, 7.0, (-5, 110)),
):
# tem, col should be extractd from RTD fits
reg = [
guesses = [0.5,50,5,
1,60,5,
0.5,70,5]
limits = [(0.1,3.5),(40,80),(1,15)]*3
limits[1] = (45,55)
limits[4] = (55,65)
limits[7] = (65,75)
limits[5] = (2,15)
sp.specfit(fittype='gaussian', multifit=True, guesses=guesses, limits=limits, limited=[(True,True)]*9)
sp.specfit.plot_fit(show_components=True)
pars.append(sp.specfit.modelpars)
spectra.append(sp)
[sp.specfit.plot_fit(show_components=True) for sp in spectra]
parsarr = np.array(pars)
pl.figure(0)
pl.clf()
pl.plot((8*np.log(2))**0.5*parsarr[:,2])
pl.plot((8*np.log(2))**0.5*parsarr[:,5])
pl.plot((8*np.log(2))**0.5*parsarr[:,8])
pl.plot((8*np.log(2))**0.5*(parsarr[:,5]**2+parsarr[:,8]**2)**0.5, '--')
geosum = (parsarr[:,2]**2+parsarr[:,5]**2+parsarr[:,8]**2)**0.5
pl.plot((8*np.log(2))**0.5*geosum, '--')
pl.show()
np.savetxt(paths.dpath('vwidth_vs_r.txt'),
np.array([aprs, parsarr[:,2], parsarr[:,5], parsarr[:,8], geosum]).T,
header=" ".join(["{0:>15s}".format(x) for x in ('rad_as','sigma_1','sigma_2','sigma_3','sigma_all')]),
fmt=" %15i %15f %15f %15f %15f")
F.tick_labels.set_yformat('dd:mm:ss.ss')
F.tick_labels.set_xformat('hh:mm:ss.ss')
F.ticks.set_xspacing(0.001)
F.ticks.set_yspacing(0.001)
F.tick_labels.set_x_full_label_side('left')
#aplpy.make_rgb_cube( ('W51-CBAND-feathered.fits','W51-X-ABCD-S1.VTESS.VTC.DAVID-MEH.fits','W51Ku_BDarray_continuum_2048_both_uniform.hires.clean.image.fits'), 'W51_CXU_rgb' )
pl.close(1)
figure = pl.figure(1)
figure.clf()
# clean the header of junk axes
hdu = fits.open(
dpath('W51Ku_BDarray_continuum_2048_both_uniform.hires.clean.image.fits'))
hdu[0].data = hdu[0].data.squeeze()
hdu[0].header = wcs.WCS(hdu[0].header).sub([wcs.WCSSUB_CELESTIAL]).to_header()
F = aplpy.FITSFigure(hdu, convention='calabretta', figure=figure)
#F = aplpy.FITSFigure(dpath+'W51Ku_BDarray_continuum_2048_both_uniform.hires.clean.image.rot45.fits',convention='calabretta',figure=figure)
F.tick_labels.set_xformat('dd.dd')
F.tick_labels.set_yformat('dd.dd')
F.tick_labels.set_font(size=20)
F.axis_labels.set_font(size=20)
F.show_grayscale(stretch='arcsinh', vmin=-5e-4, vmax=0.011, invert=True)
#e1 = coordinates.ICRS(290.93263,14.50745,unit=('deg','deg'))
#F.recenter(e1.ra.value,e1.dec.value,width=1/60.,height=1/60.)
#F.recenter(290.92633,14.514769,radius=1.4/60.)
F.recenter(290.92345, 14.511772, radius=1.5 / 60.)
from ch3cn_fits import SpectralCube, pyspeckit, fits, u, np
import os
import paths
T=True
F=False
cubefn = paths.dpath('longbaseline/W51northcax.SPW2_ALL_cutout.fits')
cubeKfn = paths.dpath('longbaseline/W51northcax.SPW2_ALL_cutout_medsub_K.fits')
medKfn = paths.dpath('longbaseline/W51northcax.SPW2_ALL_cutout_med_K.fits')
if not os.path.exists(cubeKfn):
cube = SpectralCube.read(cubefn).minimal_subcube()
contcubeK = cube.to(u.K, u.brightness_temperature(cube.beam,
cube.wcs.wcs.restfrq*u.Hz))
cube.allow_huge_operations = True
cubeK = cube.to(u.K, u.brightness_temperature(cube.beam,
cube.wcs.wcs.restfrq*u.Hz))
med = cubeK.percentile(25, axis=0)
cubeK.allow_huge_operations=True
cubeK = cubeK - med
med.write(medKfn)
cubeK.write(cubeKfn)
else:
cubeK = SpectralCube.read(cubeKfn)
cubeK.allow_huge_operations = True
med = fits.getdata(medKfn) * u.K
contcubeK = cubeK + med
contcubeK.allow_huge_operations = True
# BAD error estimate
err = cubeK.std(axis=0)
err[:] = 5*u.K
):
regs = regions.read_ds9(paths.rpath('velo_centroid_guesses_{linename}.reg').format(linename=linename))
guesses = {}
for reg in regs:
vel = float(reg.meta['text'].strip("{}"))
if vel in guesses:
guesses[vel].append(reg)
else:
guesses[vel] = [reg]
velocities = np.array(sorted(guesses.keys()))*u.km/u.s
cubefn = paths.dpath('cubes/OrionSourceI_{linename}_robust0.5maskedclarkclean10000_medsub_K.fits'
.format(linename=linename))
basename = os.path.splitext(os.path.basename(cubefn))[0]
cube = SpectralCube.read(cubefn)
# hard-coded icrs radecsys assumed
assert cube.header['RADESYS'] == 'ICRS'
vdiff = np.abs(np.diff(cube.spectral_axis).mean())
rms = cube.std()
weights = np.ones(cube.shape[1:]) * rms.value**2
try:
beam = cube.beam
except AttributeError:
beam = cube.average_beams(1)
pixscale = wcs.utils.proj_plane_pixel_area(cube.wcs.celestial)**0.5 * u.deg
import pylab as pl
import matplotlib
matplotlib.rc_file('pubfiguresrc')
from aplpy_figure_maker import FITSFigure
from paths import dpath, fpath
for label in ("","lower","upper"):
files = [dpath(label+'peak_optdepth_11.fits'),
dpath(label+'peak_optdepth_22.fits'),
dpath(label+'peak_optdepth_ratio.fits'),
dpath(label+'peak_optdepth_11_tex1.0.fits'),
dpath(label+'peak_optdepth_22_tex1.5.fits'),
dpath(label+'peak_optdepth_ratio_tex1.0_1.5.fits')]
for ii in xrange(1,len(files)+1):
pl.figure(ii)
pl.clf()
figs = [FITSFigure(fn, figure=pl.figure(ii+1))
for ii,fn in enumerate(files)]
for fig,fn in zip(figs,files):
if '11' in fn:
cblabel = (r'$\tau_{1-1}$')
elif '22' in fn:
cblabel = (r'$\tau_{2-2}$')
elif 'ratio' in fn:
cblabel = (r'$\tau_{1-1} / \tau_{2-2}$')
else:
raise ValueError("This is not a file: {0}".format(fn))
from astropy import units as u
from astropy.io import fits
from spectral_cube import SpectralCube
from paths import dpath
from fnames import cube_names, continua
import radio_beam
import ds9
dd = ds9.ds9()
cubes = {name: SpectralCube.read(dpath(fn)) for name,fn in cube_names.items()}
vcubes = {name: cube.with_spectral_unit(u.km/u.s, velocity_convention='radio')
for name,cube in cubes.items()}
beams = {name: radio_beam.Beam.from_fits_header(cube.header)
for name,cube in vcubes.items()}
for cube in vcubes.values():
cube._unit = u.Jy
vkcubes = {name: cube.with_flux_unit(u.K,
u.brightness_temperature(beams[name],
cube.wcs.wcs.restfrq*u.Hz))
for name,cube in vcubes.items()}
for name,vc in vkcubes.items():
vc._header['OBJECT'] = name
vc.to_ds9(dd.id, newframe=True)
dd.set('tile yes')
def make_fourier_spectra(dataset, maps, tels=['AP-H201-X202', 'AP-H201-X201']):
for tel in tels:
for map in maps:
sp = pyspeckit.Spectrum(paths.dpath('field_spectra/'
"{name}_{window}_{date}{ff}.fits".format(name=map,
window=tel,
date=dataset[-10:],
ff="")))
spff = pyspeckit.Spectrum(paths.dpath('field_spectra/'
"{name}_{window}_{date}{ff}.fits".format(name=map,
window=tel,
date=dataset[-10:],
ff="_fflagged")))
ft1 = np.fft.fft(sp.data)
ft2 = np.fft.fft(spff.data)
ftf = np.fft.fftfreq(sp.data.size)
vres = float(sp.header['VRES'])
fvr = ftf.size*vres
fvelo = fvr/(ftf/ftf[1])/2.
fig = pl.figure(1)
fig.clf()
ax = fig.add_subplot(2,1,1)
ax2 = ax.twiny()
def tick_function(X):
V = abs(fvr/(X/ftf[1])/2.)
return ["%0.3g" % z for z in V]
pl.loglog(ftf, np.abs(ft1), 'k', alpha=0.5)
pl.loglog(ftf, np.abs(ft2), 'r', alpha=0.5)
pl.loglog(ftf, np.abs(ft1)-np.abs(ft2), 'g', alpha=0.8, linewidth=0.5)
tick_locs = np.logspace(-np.log10(ftf.size/2.), np.log10(0.5), 7)
ax2.set_xticks(tick_locs)
ax2.set_xticklabels(tick_function(tick_locs))
ax.set_xlabel("Fourier Frequency")
ax2.set_xlabel("Velocity Scale (km/s)")
ax.set_ylabel("Fourier Amplitude")
ax.set_xlim(ftf[1], ftf[ftf.size/2-1])
ax.set_xscale('log')
ax.set_xlim(ftf[1], ftf[ftf.size/2-1])
ax.set_xlim(ftf[1], ftf[ftf.size/2-1])
ax.set_xlim(ftf[1], ftf[ftf.size/2-1])
pl.xlim(ftf[1], ftf[ftf.size/2-1])
assert ax.get_xlim() == (ftf[1], ftf[ftf.size/2-1])
ax3 = fig.add_subplot(2,1,2)
diff = sp-spff
diff.specname = ''
diff.baseline(order=0)
stats = diff.stats()
diff.plotter(axis=ax3, ymin=-stats['std']*5, ymax=stats['std']*5,
linestyle='none', marker=',')
ax2.set_xlabel("{0} Velocity Scale (km/s)".format(sp.specname))
pl.savefig(paths.dpath('field_spectra/'
"{name}_{window}_{date}_psds.png".format(name=map,
window=tel,
date=dataset[-10:],)
),
bbox_inches='tight')
from spectral_cube.lower_dimensional_structures import Projection
fh = fits.open(filename)
return Projection(value=fh[0].data,
header=fh[0].header,
wcs=wcs.WCS(fh[0].header),
unit=u.Unit(fh[0].header['BUNIT']),
)
for fn in files:
fname = os.path.splitext(os.path.basename(fn))[0]
print(fname)
m0fn = dpath("moments/{0}_moment0.fits".format(fname))
m1fn = dpath("moments/{0}_moment1.fits".format(fname))
m2fn = dpath("moments/{0}_moment2.fits".format(fname))
if os.path.exists(m0fn):
m0 = load_projection(m0fn)
m1 = load_projection(m1fn)
m2 = load_projection(m2fn)
else:
cube = SpectralCube.read(dpath(fn)).minimal_subcube()
vcube = cube.with_spectral_unit(u.km/u.s, velocity_convention='radio')
vcube = vcube.spectral_slab(35*u.km/u.s, 75*u.km/u.s)
try:
m0 = vcube.with_mask(vcube>0.05*u.Jy).moment0()
m1 = vcube.with_mask(vcube>0.05*u.Jy).moment1()
m2 = vcube.with_mask(vcube>0.05*u.Jy).moment2()
import paths
import matplotlib
import reproject
import radio_beam
import dust_emissivity
from astropy.io import fits
import pylab as pl
from astropy import units as u
from astropy import wcs
import image_tools
matplotlib.rc_file('pubfiguresrc')
for source in ('e8','north','e2',):
matplotlib.pyplot.figure(1).clf()
F1 = aplpy.FITSFigure(paths.dpath('chemslices/chemical_m0_slabs_{0}_CH3OH1029-936_merge.fits'.format(source)),
figure=matplotlib.pyplot.figure(1))
F1.show_grayscale(invert=True, vmax=1100, vmin=-20)
F1.show_contour(paths.dpath('W51_te_continuum_best.fits'),
colors=['r']*11,
levels=[0.015, 0.0256944, 0.0577778, 0.11125, 0.186111,
0.282361, 0.4, ])
F1.add_scalebar((0.025*u.pc / (5400*u.pc)).to(u.deg,u.dimensionless_angles()))
F1.scalebar.set_label('5000 au / 0.025 pc')
F1.scalebar.set_color('k')
F1.save(paths.fpath("{0}_continuum_contours_on_ch3oh1029.png".format(source)))
matplotlib.pyplot.figure(2).clf()
F = aplpy.FITSFigure(paths.dpath('W51_te_continuum_best.fits'),
def cutout_id_chem_map(
yslice=slice(367, 467),
xslice=slice(114, 214),
vrange=[51, 60] * u.km / u.s,
sourcename='e2',
filelist=glob.glob(paths.dpath('merge/cutouts/*natural*e2e8*fits')),
linere=re.compile("W51_b6_7M_12M_natural.(.*).image.pbcor"),
chem_name='HNCO',
):
maps = {}
energies = {}
degeneracies = {}
frequencies = {}
indices = {}
assert len(filelist) > 1
for ii, fn in enumerate(ProgressBar(filelist)):
if chem_name not in fn:
log.debug("Skipping {0} because it doesn't have {1}".format(
fn, chem_name))
continue
if 'temperature' in fn or 'column' in fn:
continue
cube = SpectralCube.read(fn)[:, yslice, xslice]
print(yslice, xslice)
print(cube)
bm = cube.beams[0]
#jtok = bm.jtok(cube.wcs.wcs.restfrq*u.Hz)
cube = cube.to(u.K, bm.jtok_equiv(cube.wcs.wcs.restfrq * u.Hz))
slab = cube.spectral_slab(*vrange)
cube.beam_threshold = 1
#contguess = cube.spectral_slab(0*u.km/u.s, 40*u.km/u.s).percentile(50, axis=0)
#contguess = cube.spectral_slab(70*u.km/u.s, 100*u.km/u.s).percentile(50, axis=0)
mask = (cube.spectral_axis < 40 * u.km / u.s) | (cube.spectral_axis >
75 * u.km / u.s)
contguess = cube.with_mask(mask[:, None, None]).percentile(30, axis=0)
slabsub = (slab - contguess)
slabsub.beam_threshold = 0.15
m0 = slabsub.moment0()
label = linere.search(fn).groups()[0]
frq = name_to_freq[label]
closest_ind = np.argmin(np.abs(frqs - frq))
closest_key = list(rt.keys())[closest_ind]
closest_rt = rt[closest_key]
upperstate = hnco.data['States'][closest_rt.UpperStateRef]
upperen = u.Quantity(float(upperstate.StateEnergyValue),
unit=upperstate.StateEnergyUnit)
maps[label] = m0
energies[label] = upperen
degeneracies[label] = int(upperstate.TotalStatisticalWeight)
indices[label] = closest_ind
frequencies[label] = frq
# make sure the dict indices don't change order
energy_to_key = {v: k for k, v in energies.items()}
order = sorted(energy_to_key.keys())
keys = [energy_to_key[k] for k in order]
cube = np.empty((len(maps), ) + maps[label].shape)
xaxis = u.Quantity([energies[k] for k in keys])
xaxis = xaxis.to(u.erg, u.spectral()).to(u.K, u.temperature_energy())
for ii, key in enumerate(keys):
# divide by degeneracy
cube[ii, :, :] = maps[key]
frequencies = u.Quantity([frequencies[k] for k in keys])
indices = [indices[k] for k in keys]
degeneracies = [degeneracies[k] for k in keys]
return xaxis, cube, maps, energies, frequencies, indices, degeneracies, m0.hdu.header
from astropy import units as u
from astropy.io import fits
import aplpy
from fnames import fnames, cube_names, continua
distance = 5.1*u.kpc
e1e2 = coordinates.ICRS(290.93268,14.508363,unit=('deg','deg'))
#aplpy.make_rgb_cube( ('W51-CBAND-feathered.fits','W51-X-ABCD-S1.VTESS.VTC.DAVID-MEH.fits','W51Ku_BDarray_continuum_2048_both_uniform.hires.clean.image.fits'), 'W51_CXU_rgb' )
pl.close(1)
figure = pl.figure(1)
figure.clf()
# clean the header of junk axes
hdu = fits.open(dpath(continua['11_cont_both_2048']))
for ii in [3,4]:
for kk in ['CRVAL','CTYPE','CDELT','CRPIX','CUNIT','NAXIS']:
k = kk+str(ii)
if k in hdu[0].header:
del hdu[0].header[k]
hdu[0].header['NAXIS'] = 2
hdu[0].data = hdu[0].data.squeeze()
F = aplpy.FITSFigure(hdu,convention='calabretta',figure=figure)
F.tick_labels.set_xformat('dd.dd')
F.tick_labels.set_yformat('dd.dd')
F.tick_labels.set_font(size=20)
F.axis_labels.set_font(size=20)
F.show_grayscale(stretch='arcsinh',vmin=-5e-4,vmax=0.011)
#e1 = coordinates.ICRS(290.93263,14.50745,unit=('deg','deg'))
import re
import pyspeckit
import glob
import paths
import aplpy
import pyregion
import pylab as pl
from astropy import units as u
pl.figure(1).clf()
pl.figure(2).clf()
# sanity check: are the regions in the right place?
F = aplpy.FITSFigure(
paths.dpath('longbaseline/W51e2cax.cont.image.pbcor.fits'),
figure=pl.figure(1))
F.show_grayscale(vmax=0.015)
region_list = pyregion.open(
paths.rpath("cores_longbaseline_spectralextractionregions.reg"))
F.show_regions(region_list)
F.recenter(290.9332, 14.509589, 0.5 / 3600.)
spectra_se_emission = pyspeckit.Spectra(
glob.glob(
paths.dpath('longbaseline/spectra/e2e_se_emission_W51e2_spw*fits')))
spectra_center = pyspeckit.Spectra(
glob.glob(paths.dpath('longbaseline/spectra/e2e_center_W51e2_spw*fits')))
spectra_left = pyspeckit.Spectra(
glob.glob(paths.dpath('longbaseline/spectra/e2e_left_W51e2_spw*fits')))
spectra_right = pyspeckit.Spectra(
glob.glob(paths.dpath('longbaseline/spectra/e2e_right_W51e2_spw*fits')))
import pylab as pl
from astropy.io import fits
from astropy.wcs import WCS
from astropy import wcs
from astropy.nddata import Cutout2D
from spectral_cube import SpectralCube
import numpy as np
from astropy import units as u
from outflow_meta import e2e, between_e2e_and_e8, e8fil, north
import aplpy
from get_m0 import get_mom0
#'CH3OH808-716':'CH$_3$OH $8_{0,8}-7_{1,6}$',
fn = paths.dpath('merge/W51_b6_7M_12M.CH3OH808-716.image.pbcor.fits')
cube = SpectralCube.read(fn)
m0 = get_mom0(fn)
blue_fits_fn = paths.dpath('moments/w51_12co2-1_blue0to45_masked.fits')
red_fits_fn = paths.dpath('moments/w51_12co2-1_red73to130_masked.fits')
red_fits = fits.open(red_fits_fn)
blue_fits = fits.open(blue_fits_fn)
redhead = red_fits[0].header
bluehead = blue_fits[0].header
red_wcs = wcs.WCS(redhead)
blue_wcs = wcs.WCS(bluehead)
#ax = fig1.add_axes([0.15, 0.1, 0.8, 0.8], projection=cube.wcs.celestial)
refval = lonmax
outheader = f3[0].header.copy()
outheader['NAXIS1'] = int(npix)
outheader['CRPIX1'] = refpix
outheader['CRVAL1'] = refval
outheader['EQUINOX'] = 2000
del outheader['CROTA1']
del outheader['CROTA2']
del outheader['CROTA3']
r1 = FITS_tools.cube_regrid.regrid_cube_hdu(f1[0], outheader, order=1)
r2 = FITS_tools.cube_regrid.regrid_cube_hdu(f2[0], outheader, order=1)
r3 = FITS_tools.cube_regrid.regrid_cube_hdu(f3[0], outheader, order=1)
stacked = fits.PrimaryHDU()
# assume ==0 means bad data
# cast out of boolean
addnan = lambda x,y: np.add(np.nan_to_num(x),np.nan_to_num(y),dtype='float')
add = lambda x,y: np.add(x,y,dtype='float')
weights = reduce(add, [((r1.data[212,:,:] != 0) & (np.isfinite(r1.data[212,:,:]))),
((r2.data[212,:,:] != 0) & (np.isfinite(r2.data[212,:,:]))),
((r3.data[212,:,:] != 0) & (np.isfinite(r3.data[212,:,:])))])
stacked.data = reduce(addnan, (r1.data, r2.data, r3.data))/weights
stacked.header = outheader
stacked.writeto(paths.dpath2('grs_48and50_cube.fits'), clobber=True)
outhead2 = fits.getheader(paths.dpath('W51_H2CO11_cube_supersampled.fits'))
stacked_reproj = FITS_tools.cube_regrid.regrid_cube_hdu(stacked, outhead2, order=1)
stacked_reproj.writeto(paths.dpath2('grs_48and50_cube_supersampledh2cogrid.fits'), clobber=True)
import numpy as np
from astropy import units as u
import os
import pylab as pl
import aplpy
import paths
from astropy.io import fits
from astropy.nddata import Cutout2D
from astropy import wcs
import paths
from outflow_meta import e2e, e2e_reference_vector, e8fil, north
from spectral_cube import SpectralCube
from astropy.visualization import SqrtStretch,AsinhStretch
from astropy.visualization.mpl_normalize import ImageNormalize
co21fn = paths.dpath('12m/w51_12CO_21_contsub_hires.image.pbcor.fits')
so65fn = paths.dpath('12m/w51_SO_65-54_contsub.fits')
# I manually did this, which was pointless, but 7 km/s slices look best
slabs = [#(-55,-48),
(-48,-41),
(-41,-34),
(-34,-27),
(-27,-24),
(-20,-13),
(-13,-6),
(-6,1),
(1,8),
(8,15),
(15,22),
pl.matplotlib.rc_file('pubfiguresrc')
h77a_freq = pyspeckit.spectrum.models.hydrogen.rrl(77)*u.GHz
he77a_freq = pyspeckit.spectrum.models.hydrogen.rrl(77, amu=4)*u.GHz
c77a_freq = pyspeckit.spectrum.models.hydrogen.rrl(77, amu=12)*u.GHz
# Read in all spectra extracted to the h77a directory matching the "best" h77a file
# May 18, 2015: I think H77a big2 is best, but I haven't inspected. EDIT: big2 is in velocity.
# September 9, 2015: I think I deleted big2
# Exclude "mol" files since they are molecular and should be extracted from the molecular cubes
# Exclude "?" files since they are misnamed and use the obsolete scheme from
# before I decided upon e9/e10
sp = [pyspeckit.Spectrum(x) for x in
ProgressBar(
glob.glob(
paths.dpath(
"spectra_h77/H77a_BDarray_speccube_uniform_contsub_cvel_big2*e[0-9]*.fits")))
if 'mol' not in x and '?' not in x
]
spectra = sp
# Also fit, but don't include in the table, the IRS 1 / IRS 2 / Lacy Jet spectra
# (important for inspecting for CRRLs)
sp_other = [pyspeckit.Spectrum(x) for x in
ProgressBar(
glob.glob(
paths.dpath(
"spectra_h77/H77a_BDarray_speccube_uniform_contsub_cvel_big_[ilr]*.fits")))
if 'mol' not in x and '?' not in x
]
# My manual inspection: which are detected?
# weakdetections are those that are not clearly believable
import pylab as pl
from astropy.io import fits
import paths
import numpy as np
ftemplate = '{line}_cube_smooth_bl_{ttype}.fits'
d322 = {'ttype':'wtdmeantemperature',
'line':'H2CO_322221_to_303202'}
t322 = fits.getdata(paths.dpath(ftemplate.format(**d322)))
d321 = {'ttype':'wtdmeantemperature',
'line':'H2CO_321220_to_303202'}
t321 = fits.getdata(paths.dpath(ftemplate.format(**d321)))
fig = pl.figure(1)
fig.clf()
histo321 = np.sort(t321, axis=0)
ax = fig.add_subplot(2,1,1)
im = ax.imshow(histo321, cmap='RdYlBu_r', vmin=20, vmax=120)
fig.colorbar(im)
histo322 = np.sort(t322, axis=0)
ax = fig.add_subplot(2,1,2)
im = ax.imshow(histo322, cmap='RdYlBu_r', vmin=20, vmax=120)
fig.colorbar(im)
fig2 = pl.figure(2)
#for threshold, sign, color in zip([20,30,40,50,50,80,100,120],
# [-1,-1,-1,-1, 1, 1, 1, 1],
fig5.savefig(paths.fpath("cont_max_slab_{0}{1}.{2}"
.format(sourcename, suffix, filetype)),
bbox_inches='tight', dpi=300)
if __name__ == "__main__":
linere = re.compile("W51_b6_12M.(.*).image.pbcor")
chem_plot_single(linere, yslice=slice(357,477), xslice=slice(104,224),
vrange=[51,60]*u.km/u.s, sourcename='e2', vmax_max=200,
contourlevels=[150,200,250,300],
filelist=glob.glob(paths.dpath('12m/cutouts/W51_b6_12M.*e2e8*fits')))
chem_plot_single(linere, yslice=slice(227,347), xslice=slice(119,239),
vrange=[52,63]*u.km/u.s, sourcename='e8', vmax_max=200,
contourlevels=[150,200,250,300],
filelist=glob.glob(paths.dpath('12m/cutouts/W51_b6_12M.*e2e8*fits')))
chem_plot_single(linere, yslice=slice(31,231), xslice=slice(152,350),
vrange=[54,64]*u.km/u.s, sourcename='north', vmax_max=200,
contourlevels=[150,200,250,300],
filelist=glob.glob(paths.dpath('12m/cutouts/W51_b6_12M.*north*fits')))
chem_plot_single(linere, yslice=slice(50,150), xslice=slice(80,180),
vrange=[58,67]*u.km/u.s, sourcename='ALMAmm14',
fpath = lambda x: os.path.join('moments',x)
for cubefn in glob.glob("full*fits"):
for (linename, freq_, dv, spw) in line_to_image_list:
freq = u.Quantity(float(freq_.strip('GHz')), unit=u.GHz)
try:
cube = SpectralCube.read(cubefn)
except Exception as ex:
print(cubefn, ex)
raise ex
continue
outfn = "{0}_{1}".format(linename, cubefn)
m0fn = paths.dpath("moments/{0}_medsub_moment0.fits".format(outfn))
m1fn = paths.dpath("moments/{0}_medsub_moment1.fits".format(outfn))
m2fn = paths.dpath("moments/{0}_medsub_moment2.fits".format(outfn))
maxfn = paths.dpath("moments/{0}_medsub_max.fits".format(outfn))
vcube = cube.with_spectral_unit(u.km/u.s, velocity_convention='radio',
rest_value=freq).spectral_slab(20*u.km/u.s,
95*u.km/u.s)
if vcube.shape[0] < 10:
print("Skipping {0} for line {1} because it's not in the cube".format(cubefn, linename))
continue
if hasattr(vcube, 'beams') and not any([bm.isfinite for bm in vcube.beams]):
print("Skipping {0} for line {1} because of bad beams".format(cubefn, linename))
continue
def chem_plot_single(linere, yslice=slice(367,467), xslice=slice(114,214),
vrange=[51,60]*u.km/u.s, sourcename='e2',
filelist=glob.glob(paths.dpath('12m/cutouts/*e2e8*fits')),
# 5,8 -> 12.8,8
# 6,8 -> 12.0,8.6
# 5,9 -> 15.0,8.0
# 6,9 -> 15,9.6
#plotgrid=(6,9), figsize=(15.0, 9.6),
figsize=(12.0, 8.6),
suffix="",
vmax_m0=5.0,
vmax_max=150,
maxbeam=0.5*u.arcsec,
contourlevels=None,
filetype='pdf',
):
text_fontsize = 4.5 if filetype=='png' else 9
for ii in range(1,7):
if not all(pl.figure(ii, figsize=figsize).get_size_inches() == figsize):
pl.close(ii)
fig1 = pl.figure(1, figsize=figsize)
fig1.clf()
fig2 = pl.figure(2, figsize=figsize)
fig2.clf()
fig3 = pl.figure(3, figsize=figsize)
fig3.clf()
fig4 = pl.figure(4, figsize=figsize)
fig4.clf()
fig5 = pl.figure(5, figsize=figsize)
fig5.clf()
fig6 = pl.figure(6, figsize=figsize)
fig6.clf()
figcounter = 0
for ii,fn in enumerate(ProgressBar(filelist)):
linename = linere.search(fn).groups()[0]
if linename not in labeldict:
print()
print("Skipping {0} because it's not in the label dict".format(linename))
continue
label = labeldict[linename]
# cache the results for use in other work, later use, ...
m0fitsfn = paths.dpath("chemslices/chemical_m0_slabs_{0}_{1}{2}.fits".format(sourcename, linename, suffix))
m1fitsfn = paths.dpath("chemslices/chemical_m1_slabs_{0}_{1}{2}.fits".format(sourcename, linename, suffix))
m2fitsfn = paths.dpath("chemslices/chemical_m2_slabs_{0}_{1}{2}.fits".format(sourcename, linename, suffix))
maxfitsfn = paths.dpath("chemslices/chemical_max_slabs_{0}_{1}{2}.fits".format(sourcename, linename, suffix))
maxsubfitsfn = paths.dpath("chemslices/chemical_max_sub_slabs_{0}_{1}{2}.fits".format(sourcename, linename, suffix))
madstdfitsfn = paths.dpath("chemslices/chemical_madstd_slabs_{0}_{1}{2}.fits".format(sourcename, linename, suffix))
if not (os.path.exists(m0fitsfn) and
os.path.exists(m2fitsfn) and
os.path.exists(maxfitsfn) and
os.path.exists(madstdfitsfn)):
print()
print("Extracting max/m0/m1/m2 for {0}".format(fn))
cube = SpectralCube.read(fn)[:,yslice,xslice]
goodbeams = np.array([bm.major < maxbeam for bm in cube.beams], dtype='bool')
if np.count_nonzero(goodbeams) < 5:
print()
print("Skipping {0} because it has too few good beams.".format(fn))
continue
cube = cube.with_mask(goodbeams[:,None,None])
cube = cube.minimal_subcube()
if cube.shape[0] == 0:
print()
print("Skipping {0} because it was masked out".format(fn))
continue
bm = cube.beams[0]
restfreq = cube.wcs.wcs.restfrq
cube = cube.to(u.K, bm.jtok_equiv(restfreq*u.Hz))
slab = cube.spectral_slab(*vrange)
cube.beam_threshold = 1
#contguess = cube.spectral_slab(0*u.km/u.s, 40*u.km/u.s).percentile(50, axis=0)
#contguess = cube.spectral_slab(70*u.km/u.s, 100*u.km/u.s).percentile(50, axis=0)
mask = (cube.spectral_axis<40*u.km/u.s) | (cube.spectral_axis > 75*u.km/u.s)
try:
contguess = cube.with_mask(mask[:,None,None]).percentile(30, axis=0)
except ValueError as ex:
print()
print("skipping {0}".format(fn))
print(ex)
continue
slabsub = (slab-contguess)
slab.beam_threshold = 0.25
slabsub.beam_threshold = 0.25
m0 = slabsub.moment0()
m1 = slabsub.moment1()
m2 = slabsub.moment2()
max_sub = slabsub.max(axis=0)
max = slab.max(axis=0)
madstd = cube.with_mask(mask[:,None,None]).apply_function(mad_std,
axis=0,
projection=True,
progressbar=True,
unit=cube.unit,)
m0.write(m0fitsfn, overwrite=True)
m1.write(m1fitsfn, overwrite=True)
m2.write(m2fitsfn, overwrite=True)
max.write(maxfitsfn, overwrite=True)
max_sub.write(maxsubfitsfn, overwrite=True)
madstd.write(madstdfitsfn, overwrite=True)
maxfh = max.hdu
else:
m0fh = fits.open(m0fitsfn)
m1fh = fits.open(m1fitsfn)
m2fh = fits.open(m2fitsfn)
maxfh = fits.open(maxfitsfn)[0]
maxsubfh = fits.open(maxsubfitsfn)
madstdfh = fits.open(madstdfitsfn)
m0 = Projection(value=m0fh[0].data, header=m0fh[0].header,
wcs=wcs.WCS(m0fh[0].header),
unit=u.Unit(m0fh[0].header['BUNIT']),)
m1 = Projection(value=m1fh[0].data, header=m1fh[0].header,
wcs=wcs.WCS(m1fh[0].header),
unit=u.Unit(m1fh[0].header['BUNIT']),)
m2 = Projection(value=m2fh[0].data, header=m2fh[0].header,
wcs=wcs.WCS(m2fh[0].header),
unit=u.Unit(m2fh[0].header['BUNIT']),)
max = Projection(value=maxfh.data, header=maxfh.header,
wcs=wcs.WCS(maxfh.header),
unit=u.Unit(maxfh.header['BUNIT']),)
max_sub = Projection(value=maxsubfh[0].data,
header=maxsubfh[0].header,
wcs=wcs.WCS(maxsubfh[0].header),
unit=u.Unit(maxsubfh[0].header['BUNIT']),)
madstd = Projection(value=madstdfh[0].data,
header=madstdfh[0].header,
wcs=wcs.WCS(madstdfh[0].header),
unit=u.Unit(madstdfh[0].header['BUNIT']),)
bm = radio_beam.Beam.from_fits_header(m0fh[0].header)
restfreq = m0fh[0].header['RESTFRQ']
jtok = bm.jtok(restfreq*u.Hz)
fig1 = pl.figure(1, figsize=figsize)
fig1.clf()
ax1 = fig1.gca()
im1 = ax1.imshow(m0.value, vmin=-1.25*jtok.value, vmax=vmax_m0*jtok.value,
cmap=pl.cm.bone_r, interpolation='nearest', origin='lower')
ax1.text(3, 0.87*m0.shape[0], label, fontsize=text_fontsize)
ax1.set_xticklabels([])
ax1.set_yticklabels([])
ax1.set_xticks([])
ax1.set_yticks([])
ax1.set_aspect('equal')
cb = pl.colorbar(mappable=im1)
cb.set_label("Flux Density (K km s$^{-1}$)", fontsize=12)
fig1.savefig(paths.fpath("chemical_slabs/{3}_chemical_m0_slab_{0}{1}.{2}"
.format(sourcename, suffix, filetype,
linename)),
bbox_inches='tight', dpi=300)
fig2 = pl.figure(2, figsize=figsize)
fig2.clf()
ax2 = fig2.gca()
im2 = ax2.imshow(m1.value, vmin=vrange[0].value, vmax=vrange[1].value,
cmap='seismic', interpolation='nearest', origin='lower')
ax2.text(3, 0.87*m0.shape[0], label, fontsize=text_fontsize, color='g')
ax2.set_xticklabels([])
ax2.set_yticklabels([])
ax2.set_xticks([])
ax2.set_yticks([])
ax2.set_aspect('equal')
cb = pl.colorbar(mappable=im2)
cb.set_label("Velocity (km s$^{-1}$)", fontsize=12)
fig2.savefig(paths.fpath("chemical_slabs/{3}_chemical_m1_slab_{0}{1}.{2}"
.format(sourcename, suffix, filetype,
linename)),
bbox_inches='tight', dpi=300)
fig3 = pl.figure(3, figsize=figsize)
fig3.clf()
ax3 = fig3.gca()
im3 = ax3.imshow(max_sub.value, vmin=-10, vmax=vmax_max,
cmap=pl.cm.bone_r, interpolation='nearest', origin='lower')
# add a contour to show the regions that are "saturated" above T_max
if contourlevels is None:
contourlevels = [vmax_max, 300, 400, 500]
qcs = ax3.contour(max_sub.value, levels=contourlevels, colors=['r','g','b','y'])
#print("levels: {0} = {1}".format(qcs.levels, contourlevels))
ax3.text(3, 0.87*m0.shape[0], label, fontsize=text_fontsize, color='r')
ax3.set_xticklabels([])
ax3.set_yticklabels([])
ax3.set_xticks([])
ax3.set_yticks([])
ax3.set_aspect('equal')
cb = pl.colorbar(mappable=im3)
cb.set_label("Peak Brightness (K)", fontsize=12)
fig3.savefig(paths.fpath("chemical_slabs/{3}_chemical_max_contsub_slab_{0}{1}.{2}"
.format(sourcename, suffix, filetype,
linename)),
bbox_inches='tight', dpi=300)
fig5 = pl.figure(5, figsize=figsize)
fig5.clf()
ax5 = fig5.gca()
im5 = ax5.imshow(max.value, vmin=-10, vmax=vmax_max,
cmap=pl.cm.bone_r, interpolation='nearest', origin='lower')
# add a contour to show the regions that are "saturated" above T_max
qcs = ax5.contour(max.value, levels=contourlevels, colors=['r','g','b','y'])
if False: # debug
print("levels: {0} = {1}".format(qcs.levels, contourlevels))
ax5.text(3, 0.87*m0.shape[0], label, fontsize=text_fontsize, color='r')
ax5.set_xticklabels([])
ax5.set_yticklabels([])
ax5.set_xticks([])
ax5.set_yticks([])
ax5.set_aspect('equal')
cb = pl.colorbar(mappable=im5)
cb.set_label("Peak Brightness (K)", fontsize=12)
fig5.savefig(paths.fpath("chemical_slabs/{3}_chemical_max_slab_{0}{1}.{2}"
.format(sourcename, suffix, filetype,
linename)),
bbox_inches='tight', dpi=300)
fig4 = pl.figure(4, figsize=figsize)
fig4.clf()
ax4 = fig4.gca()
im4 = ax4.imshow(madstd.value,
cmap=pl.cm.bone_r, interpolation='nearest', origin='lower')
ax4.text(3, 0.87*m0.shape[0], label, fontsize=text_fontsize, color='r')
ax4.set_xticklabels([])
ax4.set_yticklabels([])
ax4.set_xticks([])
ax4.set_yticks([])
ax4.set_aspect('equal')
cb = pl.colorbar(mappable=im4)
cb.set_label("MAD StdDev (K)", fontsize=12)
fig4.savefig(paths.fpath("chemical_slabs/{3}_chemical_madstd_slab_{0}{1}.{2}"
.format(sourcename, suffix, filetype,
linename)),
bbox_inches='tight', dpi=300)
fig6 = pl.figure(6, figsize=figsize)
fig6.clf()
ax6 = fig6.gca()
im6 = ax6.imshow((m2**0.5).to(u.km/u.s).value * SIGMA2FWHM, vmin=0, vmax=15,
cmap='viridis', interpolation='nearest', origin='lower')
ax6.text(3, 0.87*m0.shape[0], label, fontsize=text_fontsize, color='k')
ax6.set_xticklabels([])
ax6.set_yticklabels([])
ax6.set_xticks([])
ax6.set_yticks([])
ax6.set_aspect('equal')
cb = pl.colorbar(mappable=im6)
cb.set_label("Velocity Dispersion (km s$^{-1}$)", fontsize=12)
fig6.savefig(paths.fpath("chemical_slabs/{3}_chemical_m2_slab_{0}{1}.{2}"
.format(sourcename, suffix, filetype,
linename)),
bbox_inches='tight', dpi=300)
figcounter += 1
ax5 = fig5.gca()
ax5.cla()
cont = get_cont(maxfh.header)
im5 = ax5.imshow(cont.value, vmin=-10, vmax=vmax_max,
cmap=pl.cm.bone_r, interpolation='nearest', origin='lower')
# add a contour to show the regions that are "saturated" above T_max
ax5.contour(cont.value, levels=contourlevels, colors=['r','g','b','y'])
ax5.text(3, 0.87*m0.shape[0], 'Continuum', fontsize=text_fontsize, color='r')
ax5.set_xticklabels([])
ax5.set_yticklabels([])
ax5.set_aspect('equal')
fig5.savefig(paths.fpath("cont_max_slab_{0}{1}.{2}"
.format(sourcename, suffix, filetype)),
bbox_inches='tight', dpi=300)
import paths
from astropy.io import fits
from astropy.table import Column
import radio_beam
import astrodendro
from astropy import wcs
import masscalc
import photutils
from astropy.nddata.utils import Cutout2D
from astropy import coordinates
#contfile = fits.open(paths.dpath('selfcal_spw3_selfcal_4ampphase_mfs_tclean_deeper_10mJy.image.pbcor.fits'))
#ln selfcal_allspw_selfcal_4ampphase_mfs_tclean_deeper_5mJy.image.pbcor.fits W51_te_continuum_best.fits
#ln selfcal_allspw_selfcal_4ampphase_mfs_tclean_deeper_5mJy.residual.fits W51_te_continuum_best_residual.fits
contfile = fits.open(paths.dpath('W51_te_continuum_best.fits'))
data = contfile[0].data
radiofilename = os.path.join(paths.vlapath,
'data/W51Ku_BDarray_continuum_2048_both_uniform.hires.clean.image.fits')
radio_image = fits.open(radiofilename)
# estimate the noise from the local standard deviation of the residuals
residfile = fits.open(paths.dpath('12m/continuum/W51_te_continuum_best_residual.fits'))
resid = residfile[0].data
smresid = convolve_fft(np.nan_to_num(resid), Gaussian2DKernel(30))
resid[np.isnan(resid)] = 0.01 # make the noise outside very high
# NOT CORRECT noise = convolve_fft(np.abs(resid-smresid), Gaussian2DKernel(30))
noise = convolve_fft((resid-smresid)**2, Gaussian2DKernel(30))**0.5
residfile[0].data = noise
residfile.writeto(paths.dpath('W51_te_continuum_best_noise.fits'), clobber=True)
def freq(row):
return u.Quantity(row['Freq'], u.GHz)
linenames = [linename(row) for tbl in tables for row in tbl]
linetexnames = [linename(row) for tbl in tables for row in tbl] + ided_linetexnames
linefreqs = np.hstack([u.Quantity([freq(row) for tbl in tables for row in tbl], u.GHz).value,
ided_linefreqs.value])
linefreqs = u.Quantity(linefreqs, u.GHz)
detection_table = table.Table.read(paths.tpath('salts_in_band.ipac'), format='ascii.ipac')
nondetections = (detection_table['Flag'] == '-n') | (detection_table['Flag'] == 'cn')
detection_table = detection_table[~nondetections]
flist = [fn] if 'fn' in locals() else glob.glob(paths.dpath('stacked_spectra/OrionSourceI_*robust0.5.fits'))
for fn in flist:
print(fn)
sp_st = pyspeckit.Spectrum(fn)
pl.figure(0, figsize=(16,6)).clf()
sp_st.plotter(figure=pl.figure(0, figsize=(16,6)), clear=True)
basefn = os.path.split(fn)[-1]
sp_st.plotter(ymin=-0.0025, ymax=0.01)
sp_st.plotter.line_ids(linetexnames, linefreqs, velocity_offset=-vcen,
label1_size=16,
auto_yloc_fraction=0.75)
for txt in sp_st.plotter.axis.texts:
import paths
from common_constants import distance
import FITS_tools
pl.close(1)
figure = pl.figure(1)
figure.clf()
def set_tight_ticks(F):
F.tick_labels.set_yformat('dd:mm:ss.ss')
F.tick_labels.set_xformat('hh:mm:ss.ss')
F.ticks.set_xspacing(0.002)
F.ticks.set_yspacing(0.002)
F.tick_labels.set_x_full_label_side('left')
hdu = fits.open(paths.dpath('naco_Kband_W51.fits'))
w = wcs.WCS(hdu[0].header)
F = aplpy.FITSFigure(hdu,convention='calabretta',figure=figure)
F.set_auto_refresh(False)
#F = aplpy.FITSFigure(dpath+'W51Ku_BDarray_continuum_2048_both_uniform.hires.clean.image.rot45.fits',convention='calabretta',figure=figure)
#F.tick_labels.set_xformat('dd.ddd')
#F.tick_labels.set_yformat('dd.ddd')
F.tick_labels.set_font(size=20)
F.axis_labels.set_font(size=20)
F.show_grayscale(stretch='log',vmin=-1,vmid=-1.5,vmax=1e2,invert=True)
#e1 = coordinates.ICRS(290.93263,14.50745,unit=('deg','deg'))
#F.recenter(e1.ra.value,e1.dec.value,width=1/60.,height=1/60.)
#F.recenter(290.92633,14.514769,radius=1.4/60.)
F.add_scalebar(length=((0.5 * u.pc)/distance*u.radian).to(u.degree).value)
'north': detection_threshold_jykms*approximate_jytok,
'ALMAmm14': 0.001*approximate_jytok, # not real, just for better fits..
}
# use precomputed moments from medsub_moments
for sourcename, region in (('e2','e2e8'), ('e8','e2e8'), ('north','north'),
('ALMAmm14','ALMAmm14'),):
# use 3-sigma instead of arbitrary
# replace_bad = dthresh[sourcename]
replace_bad = False
_ = cutout_id_chem_map(source=sources[sourcename],
radius=radii[sourcename],
sourcename=sourcename,
filelist=glob.glob(paths.dpath('12m/moments/*medsub_moment0.fits')),
chem_name='.CH3OH', # use dot to exclude 13CH3OH
)
xaxis,cube,ecube,maps,map_error,energies,cubefrequencies,indices,degeneracies,header = _
pl.figure(2, figsize=(12,12)).clf()
sample_pos = np.linspace(0,1,7)[1:-1]
nx = len(sample_pos)
ny = len(sample_pos)
for ii,(spy,spx) in enumerate(itertools.product(sample_pos,sample_pos)):
rdx = int(spx*cube.shape[2])
rdy = int(spy*cube.shape[1])
plotnum = (nx*ny-(2*(ii//ny)*ny)+ii-ny)+1
pl.subplot(nx,ny,plotnum)
#uplims = nupper_of_kkms(replace_bad, cubefrequencies,
(nsio / cosmic_si_abundance * beam_area * u.Da / 0.739).to(u.M_sun),
(nsio / xsio * beam_area * 2.8 * u.Da).to(u.M_sun)))
peak_velocity = 115 * u.km / u.s
# assume ~2 beams...
distance = (0.07 * u.arcsec * dw51).to(u.km, u.dimensionless_angles())
timescale = distance / peak_velocity
print("north Mass rate = {0:0.3g} to {1:0.3g}".format(
(nsio / cosmic_si_abundance * beam_area * u.Da / 0.739).to(u.M_sun) /
timescale.to(u.yr),
(nsio / xsio * beam_area * 2.8 * u.Da).to(u.M_sun) /
timescale.to(u.yr)))
north_ds = paths.dpath('longbaseline/W51north_siocube_downsampled.fits')
if os.path.exists(north_ds):
sm_sio_cube_north = sm_sio_cube = SpectralCube.read(north_ds)
else:
siocube = (SpectralCube.read(
paths.dpath(
'longbaseline/linked/W51northcax.SPW0_ALL_medsub_cutout.fits')
).with_spectral_unit(u.km / u.s,
rest_value=ref_freq,
velocity_convention='radio').spectral_slab(
-140 * u.km / u.s, 260 * u.km / u.s))
fwhm_factor = np.sqrt(8 * np.log(2))
hanning_factor = 1129 / 977
current_resolution = np.mean(np.diff(
siocube.spectral_axis)) * hanning_factor
target_resolution = 10.0 * u.km / u.s
(100, 80),
(75, 80),
]),
('ALMAmm14', 'ALMAmm14', (80, 180), (50, 150), (58, 67), [
(65, 40),
(45, 40),
]),
):
_ = cutout_id_chem_map(
yslice=slice(*yslice),
xslice=slice(*xslice),
vrange=vrange * u.km / u.s,
sourcename=sourcename,
filelist=glob.glob(
paths.dpath(
'merge/cutouts/W51_b6_7M_12M.*{0}*fits'.format(region))),
linere=re.compile("W51_b6_7M_12M.(.*).image.pbcor"),
chem_name='HNCO',
)
xaxis, cube, maps, energies, cubefrequencies, indices, degeneracies, header = _
import pylab as pl
pl.matplotlib.rc_file('pubfiguresrc')
pl.figure(2).clf()
for rdx, rdy in rdposns:
fit_tex(xaxis,
nupper_of_kkms(cube[:, rdy, rdx], cubefrequencies,
einsteinAij[indices], degeneracies).value,
plot=True)
pl.ylabel("log($N_u / g_u$)")
from astropy.io import fits
from astropy import units as u
from h2co_modeling import lte_model
from constants import distance
import numpy as np
import paths
import reproject
import pylab as pl
import aplpy
import matplotlib
cm = matplotlib.cm.RdYlBu_r
cm.set_bad('#888888')
fn303merge = paths.dpath('merge/moments/W51_b6_7M_12M.H2CO303_202.image.pbcor_medsub_max.fits')
fn321merge = paths.dpath('merge/moments/W51_b6_7M_12M.H2CO321_220.image.pbcor_medsub_max.fits')
fn322merge = paths.dpath('merge/moments/W51_b6_7M_12M.H2CO322_221.image.pbcor_medsub_max.fits')
fn303_12m = paths.dpath('12m/moments/W51_b6_12M.H2CO303_202.image.pbcor_medsub_max.fits')
fn321_12m = paths.dpath('12m/moments/W51_b6_12M.H2CO321_220.image.pbcor_medsub_max.fits')
fn322_12m = paths.dpath('12m/moments/W51_b6_12M.H2CO322_221.image.pbcor_medsub_max.fits')
fh321merge = fits.open(fn321merge)
fh322merge = fits.open(fn322merge)
fh303merge = fits.open(fn303merge)
reproj321merge = reproject.reproject_interp(fh321merge[0], fh303merge[0].header)
ratio321merge_fh = fits.PrimaryHDU(data=reproj321merge[0]/fh303merge[0].data, header=fh303merge[0].header)
ratio321merge_fh.data[fh303merge[0].data < 0.02] = np.nan
ratio321merge_fh.data[ratio321merge_fh.data < 0.01] = np.nan
ratio321merge_fh.writeto(paths.dpath('merge/moments/H2CO_321_to_303_max_ratio.fits'), clobber=True)
import numpy as np
import os
import spectral_cube.analysis_utilities
from spectral_cube import SpectralCube
from astropy import units as u
from astropy.io import fits
import paths
from paths import fcp
import pylab as pl
import regions
import reproject
# step 1: create a velocity map
vmap_name = paths.dpath('disk_velocity_map.fits')
if not os.path.exists(vmap_name):
cube = SpectralCube.read(
paths.dpath(
'cubes/OrionSourceI_Unknown_4_robust0.5.maskedclarkclean10000_medsub_K.fits'
))
cube = SpectralCube.read(
paths.dpath(
'cubes/OrionSourceI_Unknown_4_robust0.5maskedclarkclean10000_medsub_K.fits'
))
m1 = cube.moment1()
m0 = cube.moment0()
mask = m0.value > 300
vmap = m1
vmap[~mask] = np.nan
import numpy as np
from astropy import coordinates
from astropy import units as u
from astropy.io import fits
from astropy import wcs
import pyregion
import paths
fh = fits.open(paths.dpath('longbaseline/W51e2cax.cont.image.pbcor.fits'))
mywcs = wcs.WCS(fh[0].header).sub([wcs.WCSSUB_CELESTIAL])
pixscale = (mywcs.pixel_scale_matrix**2).sum()**0.5
reg = pyregion.open(
paths.rpath('cores_longbaseline_spectralextractionregions_pix.reg'))
with open(paths.rpath('cores_longbaseline_spectralextractionregions.reg'),
'w') as rfh:
rfh.write("global color=red\n")
rfh.write("fk5\n")
for rr in reg:
if rr.name == 'circle':
x, y = mywcs.wcs_pix2world(rr.coord_list[0], rr.coord_list[1], 1)
r = pixscale * rr.coord_list[2]
rfh.write("circle({0}, {1}, {2}) # text={{{3}}}\n".format(
x, y, r, rr.attr[1]['text']))
elif rr.name == 'ellipse':
x, y = mywcs.wcs_pix2world(rr.coord_list[0], rr.coord_list[1], 1)
maj, min = pixscale * np.array(rr.coord_list[2:4])
pa = rr.coord_list[4]
rfh.write(
"ellipse({0}, {1}, {2}, {3}, {4}) # text={{{5}}}\n".format(
from astropy import convolution
from astropy import units as u
from astropy import wcs
from astropy.io import fits
from astropy import stats
import paths
import pylab as pl
from scipy.ndimage import map_coordinates
import scipy.signal
import reproject
from files import b3_hires_cont, b6_hires_cont, b7_hires_cont
from constants import source, extraction_path, origin, central_freqs
# vmap produced by stacked_line_search.py
vmap_name = paths.dpath('disk_velocity_map.fits')
hdu = fits.open(vmap_name)[0]
vmap = Projection.from_hdu(hdu)
b3beam = radio_beam.Beam.from_fits_header(
fits.getheader(paths.dpath(b3_hires_cont)))
print("per-band continuum measurements in the spectral extraction aperture: ")
for ii, contfn in enumerate((b3_hires_cont, b6_hires_cont, b7_hires_cont)):
band = contfn[14:16]
conthdu = fits.open(paths.dpath(contfn))[0]
ww = wcs.WCS(conthdu.header)
#vmap_proj,_ = reproject.reproject_interp(vmap.hdu,
#"Orion_SourceI_B6_continuum_r-2_automultithresh_1mJy.image.tt0.pbcor.fits",
#"Orion_SourceI_B6_continuum_r0.5.image.tt0.pbcor.fits",
#"Orion_SourceI_B6_continuum_r-2.clean5mJy.image.tt0.pbcor.fits",
#"Orion_SourceI_B6_continuum_r-2.clean4mJy.selfcal.phase0.image.tt0.pbcor.fits",
#"Orion_SourceI_B6_continuum_r-2.clean3mJy.selfcal.phase1.image.tt0.pbcor.fits",
#"Orion_SourceI_B6_continuum_r-2.clean2mJy.selfcal.phase2.image.tt0.pbcor.fits",
#"Orion_SourceI_B6_continuum_r-2.clean1mJy.selfcal.phase3.image.tt0.pbcor.fits",
#"Orion_SourceI_B6_continuum_r-2.clean0.5mJy.selfcal.phase4.image.tt0.pbcor.fits",
#"Orion_SourceI_B6_continuum_r-2.clean5mJy.automultithresh.image.tt0.pbcor.fits",
#"Orion_SourceI_B6_continuum_r-2.clean4mJy.automultithresh.selfcal.phase0.image.tt0.pbcor.fits",
#"Orion_SourceI_B6_continuum_r-2.clean3mJy.automultithresh.selfcal.phase1.image.tt0.pbcor.fits",
#"Orion_SourceI_B6_continuum_r-2.clean2mJy.automultithresh.selfcal.phase2.image.tt0.pbcor.fits",
"Orion_SourceI_B6_continuum_r-2.clean0.1mJy.selfcal.ampphase5.deepmask.image.tt0.pbcor.fits",
"Orion_SourceI_B3_continuum_r-2.clean0.25mJy.image.tt0.pbcor.fits",
):
figure = inset_overlays(paths.dpath(fn),
zoomregions=zoomregions,
psffn=paths.dpath(
fn.replace("image.tt0.pbcor", "psf.tt0")),
vmin=-0.0005,
vmax=0.005)
figure.savefig(paths.fpath('fullfield_zooms/' + fn).replace(
".fits", "_inset.pdf"),
bbox_inches='tight',
dpi=300)
zoomregions['SourceI']['min'] = -0.001
zoomregions['SourceI']['max'] = 0.004
#zoomregions['BN']['min'] = -0.001
#zoomregions['BN']['max'] = 0.004
#zoomregions['WMJ053514.797-052230.557']['min'] = -0.001
from astropy.io import fits
from astropy import units as u
import numpy as np
from paths import dpath
#f = fits.open('H2CO_11_speccube.fits')
f = fits.open(dpath('H2CO_11_speccube_contsub17_big_uniform.image.fits'))
beam = (np.pi*f[0].header['BMAJ']*f[0].header['BMAJ']*u.deg**2)
cont_offset = (2.7315*u.K).to(u.Jy,u.brightness_temperature(beam, 4.82966*u.GHz))
# try to fix NANs.... this definitely makes everything technically wrong, but more aesthetically useful
extra_cont_offset = 0.10
# 0.05 arbitrarily selected to get a decent match...
#cont = (f[0].data[0,100:300,:,:].sum(axis=0) + f[0].data[0,600:900,:,:].sum(axis=0)) / 500. + 0.05
cont = fits.getdata(dpath('H2CO_11_speccube_cont_16_18_big_uniform.image.fits')).squeeze() + cont_offset.value + extra_cont_offset
cspec = f[0].data[:70,:,:]
cspec[cspec > 0] = 0
spec = cspec + cont
# try to "subtract out" the negative continuum...
spec[:,cont<0] -= cont[cont<0]
cont[cont<0] = cont_offset.value + extra_cont_offset
# avoid huge NAN splotches
#spec[spec<0] = cont_offset.value
tau = -np.log((spec/cont))
tau[0,:,:] = cont # just so we have it... that first channel sucked anyway
("W51C_ACarray_continuum_4096_both_uniform_contsplit.clean.image.fits", 'C', [ (290.90023, 14.523703), (290.89873, 14.525156)], (2e-2, 0.3), 'd3', AsinhStretch()),
("W51C_ACarray_continuum_4096_both_uniform_contsplit.clean.image.fits", 'C', [ (290.93729, 14.485868), (290.93594, 14.487230)], (-2e-2, 0.3), 'e7', AsinhStretch()),
("W51C_ACarray_continuum_4096_both_uniform_contsplit.clean.image.fits", 'C', [ (290.93283, 14.506909), (290.93200, 14.507676)], (6e-2, 9), 'e1', AsinhStretch()),
("W51C_ACarray_continuum_4096_both_uniform_contsplit.clean.image.fits", 'C', [ (290.92402, 14.513314), (290.90971, 14.525246)], (-6e-2, 5), 'irs2_C_low', AsinhStretch()),
("W51Ku_BDarray_continuum_2048_both_uniform.hires.clean.image.fits", 'Ku', [ (290.92402, 14.513314), (290.90971, 14.525246)], (-6e-2, 5), 'irs2_Ku_low', AsinhStretch()),
("W51C_ACarray_continuum_4096_both_uniform_contsplit.clean.image.fits", 'C', [ (290.92402, 14.513314), (290.90971, 14.525246)], (0, 13), 'irs2_C_high', AsinhStretch()),
("W51C_ACarray_continuum_4096_both_uniform_contsplit.clean.image.fits", 'C', [ (290.93024, 14.506951), (290.92676, 14.509907)], (-0.02, 1), 'peak_cluster_C_high', LinearStretch()),
("W51Ku_BDarray_continuum_2048_both_uniform.hires.clean.image.fits", 'Ku', [ (290.92402, 14.513314), (290.90971, 14.525246)], (0, 52), 'irs2_Ku_high', AsinhStretch()),
("Cband_Epoch3sm-Epoch3.fits", 'C', [ (290.9304, 14.5083), (290.9194, 14.5189)], (-0.2, 1), 'w51main_peak_diff', LinearStretch()),
("Cband_Epoch3sm-Epoch3.fits", 'C', [ (290.92402, 14.513314), (290.90971, 14.525246)], (-0.2, 1.0), 'irs2_C_diff', LinearStretch()),
("Cband_Epoch3sm-Epoch3.fits", 'C', [ (290.93024, 14.506951), (290.92676, 14.509907)], (-0.02, 0.5), 'peak_cluster_C_diff', LinearStretch()),
):
log.info("file {0} name {1}".format(fn, name))
hdu = fits.open(paths.dpath(fn))[0]
mywcs = wcs.WCS(hdu.header).sub([wcs.WCSSUB_CELESTIAL])
wcsaxes = WCSaxes(mywcs.to_header())
fig = pl.figure(1, figsize=(10,10))
fig.clf()
F = aplpy.FITSFigure(hdu, subplot=[0.15, 0.1, 0.8, 0.8], figure=fig)
F.show_grayscale(invert=True, vmin=vmin/1e3, vmax=vmax/1e3, stretch='linear' if
stretch == LinearStretch() else 'arcsinh')
cx = (coord_limits[0][0] + coord_limits[1][0])/2.
cy = (coord_limits[0][1] + coord_limits[1][1])/2.
# radius = diamater / 2.
from astropy import units as u
from sdpy import makecube
from paths import dpath
flat_vrange = [45,75]
cubename_lores_supersampled = dpath('W51_H2CO22_pyproc_cube_lores_supersampled')
linefreq = 14.488479e9
makecube.make_taucube(cubename_lores_supersampled,
cubename_lores_supersampled+"_continuum.fits",
etamb=0.886, linefreq=linefreq*u.Hz, tex=0)
makecube.make_flats(cubename_lores_supersampled.replace("cube","taucube"),
vrange=flat_vrange,noisevrange=[-50,-1],suffix='.fits')
makecube.make_flats(cubename_lores_supersampled, vrange=[45,75],
noisevrange=[-15,30])
linefreq = 4.8296594e9
cubename_supersampled = dpath('W51_H2CO11_cube_supersampled')
makecube.make_taucube(cubename_supersampled,
continuum=cubename_supersampled+"_continuum.fits",
linefreq=linefreq, tex=0) # etamb accounted for already , etamb=0.51)
makecube.make_flats(cubename_supersampled.replace("cube","taucube"),
vrange=flat_vrange,noisevrange=[-50,-1],suffix='.fits')
from paths import dpath
from spectral_cube import SpectralCube
from astropy import units as u
from fnames import cube_names,rrl_cube_names
from astropy.table import Table,Column
from latex_info import latexdict, format_float
cube_names.update(rrl_cube_names)
errors = {}
cubes = {}
beams = {}
dv = {}
for name, fn in cube_names.items():
cube = SpectralCube.read(dpath(fn)).with_spectral_unit(u.km/u.s,
velocity_convention='radio')
print(cube)
err = cube.std().to(u.mJy)
print("{0} std: {1}".format(name, err))
errors[name] = err
cubes[name] = cube
beams[name] = cube.beam
dv[name] = np.diff(cube.spectral_axis).mean()
name_mapping = {'11_natural': '1-1 Natural', '11_uniform': '1-1 Uniform',
'22_briggs0': '2-2 Briggs 0', '22_natural': '2-2 Natural',
'H77a': 'H$77\\alpha$ Briggs 0'}
tbl = Table([Column(data=[name_mapping[name] for name in cube_names],
name="Cube ID"),
annotate_kwargs = {'color': 'r'}
pl.close(1)
velo = {
'ALMAmm24_W51n': 60 * u.km / u.s,
'd2_W51n': 60 * u.km / u.s,
'e2e_W51e2': 60 * u.km / u.s,
'e2nw_W51e2': 60 * u.km / u.s,
'e2w_W51e2': 60 * u.km / u.s,
'e8_W51e2': 60 * u.km / u.s,
'north_W51n': 60 * u.km / u.s,
}
for target in velo:
files = glob.glob(
paths.dpath("longbaseline/spectra/{0}*.fits".format(target)))
for fn in files:
sp = pyspeckit.Spectrum(fn)
sp.xarr.convert_to_unit(u.GHz)
print(fn, sp.xarr.min(), sp.xarr.max())
fpre = os.path.splitext(os.path.split(fn)[-1])[0]
species_names = [x[0] for x in line_to_image_list]
frequencies = u.Quantity(
[float(x[1].strip("GHz")) for x in line_to_image_list], unit=u.GHz)
splat = Splatalogue.query_lines(sp.xarr.min(),
sp.xarr.max(),
chemical_name='NaCl|KCl',
line_lists=['CDMS'])
import FITS_tools
from astropy.io import fits
import paths
neiir = FITS_tools.regrid_cube_hdu(fits.open(paths.dpath('w51.neii.fits'))[0], outheader=fits.Header.fromtextfile(paths.dpath('w51.neii.square.hdr')))
neiir.writeto(paths.dpath('w51.neii.square.fits'))
sivr = FITS_tools.regrid_cube_hdu(fits.open(paths.dpath('w51.siv.fits'))[0], outheader=fits.Header.fromtextfile(paths.dpath('w51.siv.square.hdr')))
sivr.writeto(paths.dpath('w51.siv.square.fits'))
import aplpy
from astropy import units as u
from astropy import coordinates
import paths
import pylab as pl
pl.matplotlib.rc_file('pubfiguresrc')
center = coordinates.SkyCoord('19:23:41.849 +14:30:56.70', frame='fk5', unit=(u.hour, u.deg))
ku_fn = '/Users/adam/work/w51/paper_w51_evla/data/W51Ku_BDarray_continuum_2048_both_uniform.hires.clean.image.fits'
fig = pl.figure(1)
fig.clf()
FF = aplpy.FITSFigure(paths.dpath('12m/continuum/selfcal_allspw_selfcal_3_mfs_deeper_r0.0.image.pbcor.fits'),
figure=fig)
FF.show_colorscale(cmap='bone_r', vmin=-0.005, vmax=0.025, stretch='log', vmid=-0.006)
FF.recenter(center.ra.deg, center.dec.deg, radius=0.0025)
FF.show_colorbar()
FF.add_scalebar((0.1*u.pc / (5400*u.pc)).to(u.deg,u.dimensionless_angles()))
FF.scalebar.set_color('w')
FF.scalebar.set_linewidth(4)
FF.scalebar.set_label("0.1 pc")
FF.scalebar.set_font_size(20)
FF.add_beam()
FF.beam.set_facecolor('none')
FF.beam.set_linewidth(2)
FF.beam.set_edgecolor('w')
FF.save(paths.fpath("e5_bubble.png"))
fig = pl.figure(1)
fig.clf()
import numpy as np
import pyregion
import paths
from astropy.io import fits
import radio_beam
from astropy import constants
from astropy import units as u
from astropy import wcs
import masscalc
fh = fits.open(paths.dpath('12m/continuum/selfcal_allspw_selfcal_3_mfs_deeper_r2.0.image.pbcor.fits'))
mywcs = wcs.WCS(fh[0].header)
beam = radio_beam.Beam.from_fits_header(fh[0].header)
pixscale = (mywcs.pixel_scale_matrix.diagonal()**2).sum()**0.5
ppbeam = (beam.sr/(pixscale**2*u.deg**2)).decompose().value / u.beam
for rpath in ('e5bubble_inclusive.reg', 'e5bubble_dustonly.reg'):
print(rpath)
reg = pyregion.open(paths.rpath(rpath))
mask = reg.get_mask(fh[0])
cutout = fh[0].data*mask
limits = [0.005, 0.015]
total_flux_perbeam = cutout[(cutout > limits[0]) & (cutout < limits[1])].sum()
total_flux = total_flux_perbeam / ppbeam.value
fig3.savefig(paths.fpath('coreplots/peakTB_vs_continuum.png'),
bbox_inches='tight')
fig4 = pl.figure(4)
fig4.clf()
ax5 = fig4.gca()
ax5.plot(cores_merge['peak_mass'], cores_merge['T_corrected_peakmass'], 's')
ylims = ax5.get_ylim()
ax5.plot([0, 250], [0, 250], 'k--')
ax5.set_ylim(ylims)
ax5.set_xlabel("Mass at 20K [M$_\\odot$]")
ax5.set_ylabel("Mass at peak $T_B$ [M$_\\odot$]")
fig4.savefig(paths.fpath('coreplots/mass20K_vs_massTB.png'),
bbox_inches='tight')
ffile = fits.open(paths.dpath('w51_te_continuum_best.fits'))
mywcs = wcs.WCS(ffile[0].header)
img = np.isfinite(ffile[0].data)
x, y = img.max(axis=0), img.max(axis=1)
xlim = np.where(x)[0].min(), np.where(x)[0].max()
ylim = np.where(y)[0].min(), np.where(y)[0].max()
ppbeam = cores_merge['beam_area'].to(u.deg**2) / np.abs(
np.product(mywcs.pixel_scale_matrix.diagonal()) * u.deg**2)
cores_merge['integrated'] = cores_merge['sum'] / ppbeam
fig2 = pl.figure(2)
fig2.clf()
ax2 = fig2.gca()
print()
both.plot_spectrum(x,y)
both.specfit(fittype='formaldehyde_radex',guesses=[4,13,-3,20,65,1,
cont11[y,x],
cont22[y,x]]*2,
fixed=[F,F,T,T,F,F,T,T]*2,
multifit=True,quiet=False,verbose=True,
use_window_limits=False,
fit_plotted_area=False)
if plot:
both.plot_spectrum(x,y, errstyle='fill', residfignum=5)
#both.specfit.add_sliders()
doextra=False
# Added 5/23/2014
mask = fits.getdata(paths.dpath('mask_h2co_signal.fits')).astype('bool')
both.maskmap = mask
twopar = True
if True:
warnings.warn("This code takes ~24.5 hours to run on a modern 4-core laptop.")
warnings.warn("The progressbar does not report accurately when run in parallel.")
warnings.warn("The last 3 lines I saw when running this:"
"""
Finished fit 3948 of 63140 at ( 77, 89) s/n= 8.4. Elapsed time is 88106.2 seconds. %6
Finished final fit 63139. Elapsed time was 88119.7 seconds
Overwriting existing file '/Users/adam/work/w51/h2co_singledish/W51_taucube_fit_parcube_try11.fits'.
"""
)
#fith2co.plotter_override(sp,vrange=[-50,10],fignum=5,reset_xlimits=True)
region_names = {'e2': 'e2_exclude_e2w.reg'}
for regfn, region, fignum, imtype, suffix in (
('e2_exclude_e2w.reg', 'e2', 1, 'm0', ''),
('e2_exclude_e2w.reg', 'e2', 2, 'm0', '_merge'),
('e2_exclude_e2w.reg', 'e2', 3, 'm0', '_merge_natural'),
('e2_exclude_e2w.reg', 'e2', 1, 'max', ''),
('e2_exclude_e2w.reg', 'e2', 2, 'max', '_merge'),
('e2_exclude_e2w.reg', 'e2', 3, 'max', '_merge_natural'),
):
reg = pyregion.open(paths.rpath(regfn))
path_template = paths.dpath(
"chemslices/chemical_{2}_slabs*_{0}*{1}.fits".format(
region, suffix, imtype))
files = glob.glob(path_template)
linestyles = {
name: itertools.cycle(['-'] + ['--'] + [':'] + ['-.'])
for name in region_names
}
linere = re.compile(
"chemical_{0}_slabs_[^_]*_(.*?)(_merge.fits|.fits)".format(imtype))
# start with continuum
files = [paths.dpath('W51_te_continuum_best.fits')] + files
F.show_rgb(paths.pdpath('W51_4096sq_WISE_bolo_mosaic_rotated_blackbg.png'),
wcs=hwcs)
#F.show_regions(paths.rpath('large_scale_regions.reg'))
regions = pyregion.open(paths.rpath('large_scale_regions.reg'))
#text = re.compile("text={([^}]*)}")
for reg in regions:
#t = text.search(reg.comment).groups()[0]
t = reg.attr[1]['text']
F.add_label(reg.coord_list[0], reg.coord_list[1], t, color='white',
size=16, weight='bold')
F.set_tick_labels_xformat('dd.d')
F.set_tick_labels_yformat('dd.d')
F.recenter(49.27, -0.32, width=0.9, height=0.4)
F.save(paths.fpath('W51_wisecolor_largescale_labeled.pdf'), dpi=72)
F.show_rgb(paths.dpath("make_pretty_picture/W51_modified.png",paths.datapath_w51),
wcs=hwcs)
F.save(paths.fpath('W51_wisecolor_modified_largescale_labeled.pdf'), dpi=72)
F.add_scalebar(((10*u.pc)/(5.1*u.kpc)*u.radian).to(u.deg).value)
F.scalebar.set_label("10 pc")
F.scalebar.set_font_size(18)
F.scalebar.set_font_weight('bold')
F.scalebar.set_color('w')
F.scalebar.set_linewidth(3)
F.save(paths.fpath('W51_wisecolor_modified_largescale_labeled_scalebar.pdf'), dpi=150)
F.scalebar.hide()
for L in list(F._layers.keys()):
if L in F._layers:
F.remove_layer(L)
log.exception(
"Skipping {0} because of a bad coordinate system.".
format(fn))
continue
# cube.allow_huge_operations=True
cube.beam_threshold = 5000
log.info("Calculating 25th percentile")
med = cube.percentile(25, axis=0)
medsub = cube - med
medsub.write(medsubfn)
# create full-scale PV diagram (all freqs)
outfn = paths.dpath(
os.path.join(
'pv',
os.path.split(
fn.replace(
".image.pbcor.fits",
"_medsub_diskpv_{0}.fits".format(width)))[-1]))
if not os.path.exists(outfn):
# width = 0.05 arcsec encompasses the disk; however, most
# of the actual line emission comes from just above/below...
#extraction_path = pvextractor.Path(diskycoords, width=0.05*u.arcsec)
extraction_path = pvextractor.Path(diskycoords,
width=width * u.arcsec)
log.info(
"Beginning extraction of path with width {0} for {1}".
format(extraction_path.width, outfn))
extracted = pvextractor.extract_pv_slice(
medsub, extraction_path)
log.info("Writing to {0}".format(outfn))
# see also: total_mass_analysis
import numpy as np
import pyregion
import dust_emissivity
from astropy import wcs
import paths
import radio_beam
from astropy.io import fits
from astropy import units as u
from astropy import constants
from masscalc import distance, centerfreq as freq
im = fits.getdata(paths.dpath('W51_te_continuum_best.fits'))
hd = fits.getheader(paths.dpath('W51_te_continuum_best.fits'))
beam = radio_beam.Beam.from_fits_header(hd)
e2e_peak_flux = im[1350:1400, 850:867].max() * u.Jy
e2e_peak_tb = e2e_peak_flux.to(u.K, beam.jtok_equiv(freq))
print("e2e peak brightness: {0}".format(e2e_peak_tb))
e2e_luminosity = (constants.sigma_sb * (e2e_peak_tb)**4 *
(4 * np.pi * (beam.major * distance) *
(beam.minor * distance) / (8 * np.log(2)))).to(
u.L_sun, u.dimensionless_angles())
print("e2e luminosity: {0}".format(e2e_luminosity))
e2e_dustmass = dust_emissivity.dust.massofsnu(freq,
e2e_peak_flux,
distance=distance,
temperature=e2e_peak_tb)
print("e2e dust mass: {0}".format(e2e_dustmass))
