def main():
w, h = (2056, 1024)
l_0 = 0.
# Create a grid of coordinates
print('Creating grid of coordinates...')
l = np.linspace(-180. + l_0, 180. + l_0, 2 * w)
b = np.linspace(-90., 90., 2 * h + 2)
b = b[1:-1]
l, b = np.meshgrid(l, b)
l += (np.random.random(l.shape) - 0.5) * 360. / (2. * w)
b += (np.random.random(l.shape) - 0.5) * 180. / (2. * h)
coords = SkyCoord(l * u.deg, b * u.deg, frame='galactic')
# Set up SFD query object
print('Loading SFD map...')
sfd = SFDQuery()
print('Querying map...')
ebv = sfd.query(coords)
# Convert the output array to a PIL image and save
print('Saving image...')
img = numpy2pil(ebv[::-1, ::-1], 0., 1.5)
img = img.resize((w, h), resample=PIL.Image.LANCZOS)
fname = 'sfd.png'
img.save(fname)
return 0
def main():
w,h = (2056,1024)
l_0 = 0.
# Create a grid of coordinates
print('Creating grid of coordinates...')
l = np.linspace(-180.+l_0, 180.+l_0, 2*w)
b = np.linspace(-90., 90., 2*h+2)
b = b[1:-1]
l,b = np.meshgrid(l, b)
l += (np.random.random(l.shape) - 0.5) * 360./(2.*w)
b += (np.random.random(l.shape) - 0.5) * 180./(2.*h)
coords = SkyCoord(l*u.deg, b*u.deg, frame='galactic')
# Set up SFD query object
print('Loading SFD map...')
sfd = SFDQuery()
print('Querying map...')
ebv = sfd.query(coords)
# Convert the output array to a PIL image and save
print('Saving image...')
img = numpy2pil(ebv[::-1,::-1], 0., 1.5)
img = img.resize((w,h), resample=PIL.Image.LANCZOS)
fname = 'sfd.png'
img.save(fname)
return 0
def getebv(ra, dec, mapname='planck', mode=None):
"""
Query the dust map with "dustmaps" to get the line-of-sight
E(B-V) value for a given object.
Parameters:
----------
mapname : str
One of ['sfd', 'planck']. Other maps are
avaliable in "dustmaps" but not implemented here:
['bayestar', 'iphas', 'marshall', chen2014',
'lenz2017', 'pg2010', 'leike_ensslin_2019', 'leike2020']
Default: 'planck'.
mode : str
One of ['local', 'web']. Applicable only when
mapname == 'sfd'. When 'local', query the local map
on disk. When 'web', query the web server.
Default: 'local'.
"""
coord = SkyCoord(ra=ra * u.deg, dec=dec * u.deg, frame='icrs')
if mapname.lower() == 'planck':
from dustmaps.planck import PlanckQuery
planck = PlanckQuery()
ebv = planck(coord)
elif mapname.lower() == 'sfd' and mode == 'local':
from dustmaps.sfd import SFDQuery
sfd = SFDQuery()
ebv = sfd(coord)
elif mapname.lower == 'sfd' and mode == 'web':
from dustmaps.sfd import SFDWebQuery
sfd = SFDWebQuery()
ebv = sfd(coord)
return ebv
def __init__(self, with_extinction_maps=False):
self.redd_maps = {}
with open(dir_path + 'extinction/extinction_coeffs_2017.dat') as f:
self.R_V_grid = np.fromstring(f.readline(),
dtype=np.float64,
sep=' ')
for l in f.readlines():
spl = l.split(" ", 1)
self.redd_maps[spl[0]] = np.fromstring(spl[1],
dtype=np.float64,
sep=' ')
self.interp_maps = {
n: interp1d(self.R_V_grid, self.redd_maps[n])
for n in self.redd_maps
}
self.R_G = np.zeros((75, len(self.R_V_grid)))
with open(dir_path + 'extinction/extinction_coeffs_G_2017.dat') as f:
self.logTeffgrid = np.fromstring(f.readline(),
dtype=np.float64,
sep=' ')
for n, l in enumerate(f.readlines()):
self.R_G[n] = np.fromstring(l, dtype=np.float64, sep=' ')
self.interp_G_maps = interp2d(self.R_V_grid, self.logTeffgrid,
self.R_G)
if (with_extinction_maps):
self.sfd = SFDQuery()
self.bayestar = BayestarQuery(max_samples=10)
self.marshall = MarshallQuery()
self.drimmel = mwdust.Drimmel03(filter='Landolt V')
def sbsextinction(self):
#ra and dec variables set from class attributes for ease
ra = self.ra
dec = self.dec
#astropy skycoord called, units and frame set
coords = SkyCoord(ra, dec, unit='deg', frame='icrs')
#sfd map chosen
sfd = SFDQuery()
#E(B-V) for each star loaded into array from map
sfdred = sfd(coords)
#corrections from table 6 of Schlafly and Finkbeiner(2011) made
jext = sfdred * 0.709
hext = sfdred * 0.449
kext = sfdred * 0.302
#extinction corrections carried out on class attributes
self.jmag = self.jmag - jext
self.hmag = self.hmag - hext
self.kmag = self.kmag - kext
#method to carry out star by star extinction on object using SFD dustmap. Takes object target as input
print('UKIRT Extinction corrections done')
def sbsextinction_on_frame(self, target):
#attributes set as variables for ease
ra = target.ra
dec = target.dec
#astropy skycoord called, units and frame set
coords = SkyCoord(ra, dec, unit='deg', frame='icrs')
#sfd map chosen
sfd = SFDQuery()
#E(B-V) for each star loaded into array from map
sfdred = sfd(coords)
#corrections from table 6 of Schlafly and Finkbeiner(2011) made
jext = sfdred * 0.709
hext = sfdred * 0.449
kext = sfdred * 0.302
#extinction corrections carried out on class attributes
target.jmag = target.jmag - jext
target.hmag = target.hmag - hext
target.kmag = target.kmag - kext
def dust(l, b, distance, plot=False, max_samples=2, mode='median', model='bayes'):
if model == 'sfd':
c = SkyCoord(l, b,
frame='galactic')
sfd = SFDQuery()
dust = sfd(c)
if model == 'bayes':
c = SkyCoord(l, b,
distance = distance,
frame='galactic')
bayes = BayestarQuery(max_samples=max_samples)
dust = bayes(c, mode=mode)
if model == 'iphas':
c = SkyCoord(l, b,
distance = distance,
frame='galactic')
iphas = IPHASQuery()
dust = iphas(c, mode=mode)
if model == 'marshall':
c = SkyCoord(l, b,
distance = distance,
frame='galactic')
marshall = MarshallQuery()
dust = marshall(c)
if model == 'chen':
c = SkyCoord(l, b,
distance = distance,
frame='galactic')
chen = Chen2014Query()
dust = chen(c)
#cNoDist = SkyCoord(l, b,
# frame='galactic')
#bayesDustNoDist = bayes(cNoDist, mode=mode)
#!!!!! Do something else than setting it equal to 0 !!!!!
#if len(bayesDust) > 1: bayesDust[np.isnan(bayesDust)] = 0.0
if plot:
fig, ax = plt.subplots(3, figsize=(5, 7.5))
ax[0].hist(np.log10(sfd(c)), bins=100, log=True, histtype='step')
ax[1].hist(np.log10(bayesDustNoDist[bayesDustNoDist>0]), bins=100, log=True, histtype='step')
ax[2].hist(np.log10(bayesDust[bayesDust >0]), bins=100, log=True, histtype='step')
ax[0].set_xlabel('SFD Dust Attenuation')
ax[1].set_xlabel('Bayestar Dust Attenuation No Distance')
ax[2].set_xlabel('Bayestar Dust Attenuation')
for a in ax: a.set_xlim(-4, 0.0)
hist, bins = np.histogram(magsMatched['bmag'], bins=100)
plt.hist(magsMatched['bmag'], bins=bins, histtype='step')
plt.hist(magsMatched['bmag'] - B_RedCoeff*bayesDust, bins=bins, histtype='step')
plt.tight_layout()
return dust
def getDustMap(nside=64):
"""
Method to estimate the dust map
Parameters
---------------
nside: int, opt
healpix nside parameters
Returns
-----------
dustmap: pandas df
with the following columns: healpixID, RA, Dec, ebvofMW
"""
# get the total number of pixels
npixels = hp.nside2npix(nside)
# pixels = hp.get_all_neighbours(nside, 0.0, 0.0, nest=True, lonlat=Tru)
# get the (RA, Dec) of the pixel centers
vec = hp.pix2ang(nside, range(npixels), nest=True, lonlat=True)
dustmap = pd.DataFrame(range(npixels), columns=['healpixID'])
dustmap['RA'] = vec[0]
dustmap['Dec'] = vec[1]
coords = SkyCoord(vec[0], vec[1], unit='deg')
try:
sfd = SFDQuery()
except Exception as err:
from dustmaps.config import config
config['data_dir'] = 'dustmaps'
import dustmaps.sfd
dustmaps.sfd.fetch()
sfd = SFDQuery()
ebvofMW = sfd(coords)
dustmap['ebvofMW'] = ebvofMW
dustmap['npixels'] = npixels
return dustmap
def generateLightcurve(self,
p_c,
p_o,
partial_QC_df,
QC_columns,
do_extinction=False):
cyan_partial_QC_df = partial_QC_df.query('%s == "c"' %
QC_columns['qc_filters'])
orange_partial_QC_df = partial_QC_df.query('%s == "o"' %
QC_columns['qc_filters'])
phase_c = cyan_partial_QC_df[QC_columns['qc_time']] - self.expl_epoch
phase_o = orange_partial_QC_df[QC_columns['qc_time']] - self.expl_epoch
mag_c = abs2app(p_c(phase_c), self.redshift)
mag_o = abs2app(p_o(phase_o), self.redshift)
if do_extinction:
dustmaps_path = os.path.dirname(os.path.abspath(dustmaps.__file__))
# print(dustmaps_path)
if not os.path.exists(os.path.join(dustmaps_path, "DustMaps/")):
config["data_dir"] = "{pathToSource}/DustMaps/".format(
pathToSource=dustmaps_path)
#Downloading dustmap for galactic extinction from Schlafly & Finkbeiner (SFD; 2011)
dustmaps.sfd.fetch()
else:
config["data_dir"] = "{pathToSource}/DustMaps/".format(
pathToSource=dustmaps_path)
#Setting the extraction query for the SFD Dustmap
coords = SkyCoord(self.ra * u.deg, self.dec * u.deg, frame='icrs')
extinction_map = SFDQuery()
ebv = extinction_map(coords)
A_g = ebv * 3.172
A_r = ebv * 2.271
A_i = ebv * 1.682
A_c = (A_g + A_r) / 2.
A_o = (A_r + A_i) / 2.
else:
A_c = 0.0
A_o = 0.0
self.timeline_c = phase_c + self.expl_epoch
self.timeline_o = phase_o + self.expl_epoch
self.mag_c = mag_c + A_c
self.mag_o = mag_o + A_o
self.extinction_c = A_c
self.extinction_o = A_o
def get_dustmaps_dust(ra, dec, web=True, **kwargs):
"Use https://github.com/gregreen/dustmaps"
from dustmaps.sfd import SFDQuery, SFDWebQuery
from astropy.coordinates import SkyCoord
coords = SkyCoord(ra, dec, unit='deg', frame='icrs')
if web:
sfd = SFDWebQuery()
else:
sfd = SFDQuery()
ebv = sfd(coords)
return ebv
def extinction_correct(self, overwrite=False):
"""
INPUT: overwrite (True) filter mag column with corrected magnitudes
FUNC: using SFDQuery finds E(B-V) for each ra,dec in catalog and
corrects the filter magnitudes using this value
"""
Messier33.info("*Correcting Dust Extinction\n")
coords = SkyCoord(self['ra'], self['dec'], unit=u.deg)
ebv = SFDQuery()(coords)
for band in self.bands:
Messier33.info(
"**R_%s=%.4f (%s)\n" %
(band, self.config.Rv3_1[band], self.config.Rv3_1['ref']))
o = self[band] - (self.config.Rv3_1[band] * ebv)
self.append(o, key="%so" % band)
self.indices["d%so" % band] = self.indices["d%s" % band]
if (overwrite): self.delete(band)
self.history.append("Extinction Correction in bands %s" % self.bands)
def main():
c0 = SkyCoord.from_name('orion a', frame='galactic')
print(c0)
# l = np.arange(c0.l.deg - 5., c0.l.deg + 5., 0.05)
# b = np.arange(c0.b.deg - 5., c0.b.deg + 5., 0.05)
l0, b0 = (37., -16.)
l = np.arange(l0 - 5., l0 + 5., 0.05)
b = np.arange(b0 - 5., b0 + 5., 0.05)
l, b = np.meshgrid(l, b)
coords = SkyCoord(l * units.deg,
b * units.deg,
distance=1. * units.kpc,
frame='galactic')
sfd = SFDQuery()
Av_sfd = 2.742 * sfd(coords)
planck = PlanckQuery()
Av_planck = 3.1 * planck(coords)
bayestar = BayestarQuery(max_samples=1)
Av_bayestar = 2.742 * bayestar(coords)
fig = plt.figure(figsize=(12, 4), dpi=150)
for k, (Av, title) in enumerate([(Av_sfd, 'SFD'), (Av_planck, 'Planck'),
(Av_bayestar, 'Bayestar')]):
ax = fig.add_subplot(1, 3, k + 1)
ax.imshow(np.sqrt(Av)[::, ::-1],
vmin=0.,
vmax=2.,
origin='lower',
interpolation='nearest',
cmap='binary',
aspect='equal')
ax.axis('off')
ax.set_title(title)
fig.subplots_adjust(wspace=0., hspace=0.)
plt.savefig('comparison.png', dpi=150)
return 0
def do_dust(catalog):
task_str = catalog.get_current_task_str()
# Set preferred names, calculate some columns based on imported data,
# sanitize some fields
keys = list(catalog.entries.keys())
check_dustmaps(catalog.get_current_task_repo())
sfd = SFDQuery()
for oname in pbar(keys, task_str):
# Some events may be merged in cleanup process, skip them if
# non-existent.
try:
name = catalog.add_entry(oname)
except Exception:
catalog.log.warning(
'"{}" was not found, suggests merge occurred in cleanup '
'process.'.format(oname))
continue
if (FASTSTARS.RA not in catalog.entries[name]
or FASTSTARS.DEC not in catalog.entries[name]):
continue
else:
Mname = name
Mradec = str(
catalog.entries[name][FASTSTARS.RA][0]['value']) + str(
catalog.entries[name][FASTSTARS.DEC][0]['value'])
Mdist = '-1'
c = coord(Mradec, unit=(un.hourangle, un.deg), frame='icrs')
reddening = sfd(c)
source = catalog.entries[name].add_source(
bibcode='1998ApJ...500..525S')
catalog.entries[name].add_quantity(FASTSTARS.EBV,
str(reddening),
source,
upperlimit=True,
derived=True)
catalog.journal_entries()
return
def getEBV_effect(rtAs_n,dec_n):
'''
Generates E(B-V) i.e magnitude of Extinction effect with sky coordinates.
parameters
----------
rightAscension: angular distance of a particular point measured eastward along equator
declination: angular distance of a point north or south of the celestial equator
source: https://en.wikipedia.org/wiki/International_Celestial_Reference_System
'''
rt_As=rightAscension*au.degree
dec=declination*au.degree
sk_loc = SkyCoord(rt_As, dec, frame='icrs')
sfd = SFDQuery()
ebv = sfd(sk_loc)
'''
sdf():returns reddening in a unit that is similar to magnitudes of E(B-V).
'''
return (ebv)
def deredden_spectra(wave, coords):
"""
Apply S&F 2011 Extinction from SFD Map
https://iopscience.iop.org/article/10.1088/0004-637X/737/2/103#apj398709t6
Paramters
---------
wave array
wavelength to apply correction
coords SkyCoord object
sky coordinates
"""
Rv = 3.1
corr_SF2011 = 2.742 # Landolt V
sfd = SFDQuery()
ebv = sfd(coords)
Av = corr_SF2011 * ebv
ext = extinction.fitzpatrick99(np.array(wave, dtype=np.double), Av, Rv)
deredden = 10**(0.4*np.array(ext))
return deredden
def ext_corr(self):
galaxy_data = self.galaxy_data
# attributes set as variables for ease
ra = galaxy_data.RA
dec = galaxy_data.DEC
# astropy skycoord called, units and galaxy_data set
coords = SkyCoord(ra, dec, unit='deg')
# sfd map chosen
sfd = SFDQuery()
# E(B-V) for each star loaded into array from map
sfdred = sfd(coords)
# print(sfdred)
# corrections from table 6 of Schlafly and Finkbeiner(2011) made
jext = sfdred * 0.709
hext = sfdred * 0.449
kext = sfdred * 0.302
# extinction corrections carried out on class attributes
galaxy_data.jmag = galaxy_data.jmag - jext
galaxy_data.hmag = galaxy_data.hmag - hext
galaxy_data.kmag = galaxy_data.kmag - kext
self.galaxy_data = galaxy_data
print('UKIRT extinction corrections done')
def extinction_corr(catalog, bands):
# Extinction coefficients for HSC filters for conversion from E(B-V) to extinction, A_filter.
# Numbers provided by Masayuki Tanaka (NAOJ).
#
# Band, A_filter/E(B-V)
extinctionCoeffs_HSC = {
"g": 3.240,
"r": 2.276,
"i": 1.633,
"z": 1.263,
"y": 1.075,
"HSC-G": 3.240,
"HSC-R": 2.276,
"HSC-I": 1.633,
"HSC-Z": 1.263,
"HSC-Y": 1.075,
"NB0387": 4.007,
"NB0816": 1.458,
"NB0921": 1.187,
}
bands = list(bands)
sfd = SFDQuery()
coord_string_ra = 'coord_ra_'+str(bands[0])
coord_string_dec = 'coord_dec_'+str(bands[0])
coords = SkyCoord(catalog[coord_string_ra], catalog[coord_string_dec])
ebvValues = sfd(coords)
extinction_dict = {'E(B-V)': ebvValues}
# Create a dict with the extinction values for each band (and E(B-V), too):
for band in bands:
coeff_name = 'A_'+str(band)
extinction_dict[coeff_name] = ebvValues*extinctionCoeffs_HSC[band]
return(extinction_dict)
def test_sdss_halpha(fname,
fluxkey,
magkey,
magerrprefix,
bands,
scatter_density=True,
zkey="z",
xmin=-17,
xmax=-13,
output=None,
bands_ebv=None,
wline=6562.8 * u.AA):
bands_ebv = ["G", "I"] if bands_ebv is None else bands_ebv
############################################################################
# Reading transmission curves for S-PLUS
filters_dir = os.path.join(os.getcwd(), "filter_curves-master")
filenames = sorted([os.path.join(filters_dir, _) for _ in os.listdir( \
filters_dir)])
filternames = [os.path.split(_)[1].replace(".dat", "") for _ in filenames]
filternames = [
_.replace("F0", "F").replace("JAVA", "") for _ in filternames
]
filternames = [_.replace("SDSS", "").upper() for _ in filternames]
fcurves = [np.loadtxt(f) for f in filenames]
wcurves = [curve[:, 0] * u.AA for curve in fcurves]
trans = [curve[:, 1] for curve in fcurves]
wcurves = dict(zip(filternames, wcurves))
trans = dict(zip(filternames, trans))
halpha = EmLine3Filters(wline, [_.upper() for _ in bands], wcurves, trans)
############################################################################
# Reading catalog and remove objects out of z-range
wdir = os.path.join(context.home_dir, "catalogs")
filename = os.path.join(wdir, fname)
table = Table.read(filename)
if zkey in table.colnames:
table = table[table[zkey] < 0.02]
############################################################################
# Cleaning table against large errors in mgnitudes
magerrs = np.array([
table["{}{}{}".format(magerrprefix, band, magkey)].data
for band in bands
])
idx = np.where(np.nanmax(magerrs, axis=0) < 0.2)[0]
table = table[idx]
############################################################################
# Estimating the extinction
gi = np.array(
[table["{}{}".format(band, magkey)].data for band in bands_ebv])
g_i = gi[0] - gi[1]
ebvs = np.clip(0.206 * np.power(g_i, 1.68) - 0.0457, 0, np.infty)
Rv = 4.1
Avs = Rv * ebvs
corr = np.array([
extinction.remove(
extinction.calzetti00(np.atleast_1d(wline), Av, Rv)[0], 1)
for Av in Avs
])
############################################################################
# Correcting observations for Galactic extinction
coords = SkyCoord(table["ra"] * u.degree, table["dec"] * u.degree)
sfd = SFDQuery()
ebv_mw = sfd(coords)
Rv_mw = 3.1
Av_mw = Rv_mw * ebv_mw
corr_mw = np.array([
extinction.remove(
extinction.ccm89(halpha.wpiv, Av, Rv_mw)[0], np.ones(3))
for Av in Av_mw
]).T
############################################################################
# Calculating H-alpha
mags = np.array(
[table["{}{}".format(band, magkey)].data for band in bands])
flam = mag2flux(mags, halpha.wpiv) * corr_mw
flux_halpha_nii = halpha.flux_3F(flam)
log_halpha = np.where(g_i <= 0.5,
0.989 * np.log10(flux_halpha_nii.value) - 0.193,
0.954 * np.log10(flux_halpha_nii.value) - 0.753)
halpha_sdss = np.log10((table[fluxkey]) * np.power(10., -17))
halpha_splus = log_halpha + np.log10(corr)
############################################################################
# Selecting only regions within limits of flux
idx = np.where(
np.isfinite(halpha_sdss * halpha_splus) & (halpha_sdss > xmin)
& (halpha_splus < xmax))
halpha_sdss = halpha_sdss[idx]
halpha_splus = halpha_splus[idx]
############################################################################
fig = plt.figure()
if scatter_density:
ax = fig.add_subplot(1, 1, 1, projection='scatter_density')
density = ax.scatter_density(halpha_sdss, halpha_splus, cmap="magma_r")
fig.colorbar(density, label='Number of points per pixel')
else:
ax = fig.add_subplot(1, 1, 1)
label = "mag_key={}".format(magkey)
counts, xedges, yedges, im = ax.hist2d(halpha_sdss,
halpha_splus,
bins=(50, 50),
cmap="bone_r")
plt.legend(title=label)
fig.colorbar(im, ax=ax)
ax.set_aspect("equal")
plt.xlim(xmin, xmax)
plt.ylim(xmin, xmax)
plt.plot(np.linspace(xmin, xmax, 100), np.linspace(xmin, xmax, 100), "--r")
plt.xlabel(r"$\log$ H$\alpha$ (erg / s / cm$^2$) -- SDSS")
plt.ylabel(r"$\log$ H$\alpha$ (erg / s / cm$^2$) -- SPLUS")
axins = inset_axes(ax,
width="80%",
height="80%",
bbox_to_anchor=(.65, .05, .38, .38),
bbox_transform=ax.transAxes,
loc=3)
diff = halpha_splus - halpha_sdss
median = np.nanmedian(diff)
std = np.nanstd(diff)
title = "med: {:.2f} std: {:.2f}".format(median, std)
axins.hist(diff, bins=20)
axins.set_title(title)
plt.tight_layout()
if "output" is not None:
plt.savefig(
output,
dpi=250,
)
plt.show()
'r') as f:
catalogue = np.array(f['a'])
z = catalogue[0]
ra = catalogue[1]
dec = catalogue[2]
d_file = '/mnt/ddnfs/data_users/cxkttwl/ICL/wget_data/'
#d_file = '/mnt/ddnfs/data_users/cxkttwl/ICL/data/sky_sub_img/' # add sky information
load = '/mnt/ddnfs/data_users/cxkttwl/ICL/data/'
band = ['r', 'g', 'i', 'u', 'z']
l_wave = np.array([6166, 4686, 7480, 3551, 8932])
mag_add = np.array([0, 0, 0, -0.04, 0.02])
zopt = np.array([22.5, 22.5, 22.5, 22.46, 22.52])
sb_lim = np.array([24.5, 25, 24, 24.35, 22.9])
Rv = 3.1
sfd = SFDQuery()
def mask_A(band_id, z_set, ra_set, dec_set):
kk = np.int(band_id)
Nz = len(z_set)
param_A = 'default_mask_A.sex'
out_cat = 'default_mask_A.param'
out_load_A = '/mnt/ddnfs/data_users/cxkttwl/PC/A_mask_%d_cpus.cat' % rank
## size test
r_res = 1. # 2.8 for larger R setting
for q in range(Nz):
z_g = z_set[q]
ra_g = ra_set[q]
dec_g = dec_set[q]
def get_MW_EBV(args):
'''
This function reads the input file to obtain the coordinates for
the source objects. It is called only when ISM_correct_coords is not None,
since the only thing that depends on coordinates is the Milky Way dust
correction. Note: The program will assume degrees; this can be manually
changed here if the user wishes.
The columns for coordinates should be named "C1" and "C2" if the sources
are not in the Skelton Catalog. For sources in Skelton, coordinates are
optional (since they will be automatically read from the Skelton catalog).
Note: The program will assume degrees; this can be manually
changed here if the user wishes.
Parameters
----------
args : class
The args class is carried from function to function with information
from command line input and config.py
Returns
-------
E(B-V) for Milky Way : 1D array
'''
F = Table.read(args.filename, format='ascii')
Fcols = F.colnames
nobj = len(F['Field'])
try:
C1 = F['C1']
C2 = F['C2']
except:
# Skelton catalogs
fields = ['aegis', 'cosmos', 'goodsn', 'goodss', 'uds']
name_base = '_3dhst.v4.1.cat.FITS'
if F['Field'][0].lower() in fields:
for fd in F['Field']:
#Make sure the input isn't a mix of Skelton and non-Skelton
assert fd.lower() in fields, "%s not in Skelton" % (fd)
C1, C2 = np.zeros(nobj), np.zeros(nobj)
field_dict = {}
for field in fields:
field_dict[field] = fits.open(
op.join('3dhst_catalogs', field + name_base))[1]
for i, datum in enumerate(F):
# assumes first element is field name and second is ID
loc = datum[0].lower()
C1[i] = field_dict[loc].data['ra'][int(datum[1]) - 1]
C2[i] = field_dict[loc].data['dec'][int(datum[1]) - 1]
args.ISM_correct_coords = 'FK5' #Skelton coordinates are RA and Dec
else:
print("No coordinates given and no match to Skelton Catalog")
return np.array([np.nan] * nobj)
from dustmaps.sfd import SFDQuery
from astropy.coordinates import SkyCoord
coords = SkyCoord(C1,
C2,
unit='deg',
frame=args.ISM_correct_coords.lower())
sfd = SFDQuery()
ebv = sfd(coords)
return ebv
def __init__(self,
starname,
ra,
dec,
g_id=None,
plx=None,
plx_e=None,
rad=None,
rad_e=None,
temp=None,
temp_e=None,
lum=None,
lum_e=None,
dist=None,
dist_e=None,
Av=None,
offline=False,
mag_dict=None,
verbose=True,
ignore=None):
"""See class docstring."""
# MISC
self.verbose = verbose
self.offline = offline
# Star stuff
self.starname = starname
self.ra_dec_to_deg(ra, dec)
c = random.choice(self.colors)
display_star_init(self, c)
if verbose:
if plx is not None:
StarWarning('Parallax', 0).warn()
if rad is not None:
StarWarning('Radius', 0).warn()
if temp is not None:
StarWarning('Temperature', 0).warn()
if lum is not None:
StarWarning('Luminosity', 0).warn()
if mag_dict is not None:
StarWarning('Magnitudes', 0).warn()
self.get_plx = True if plx is None else False
self.get_dist = True if dist is None and plx is None else False
self.get_rad = True if rad is None else False
self.get_temp = True if temp is None else False
self.get_lum = True if lum is None else False
self.get_mags = True if mag_dict is None else False
self.get_logg = False # This is set to True after self.estimate_logg
self.g_id = g_id
# Lookup archival magnitudes, radius, temperature, luminosity
# and parallax
lookup = self.get_rad + self.get_temp + self.get_plx \
+ self.get_mags + self.get_dist
if lookup:
if not offline:
if verbose:
print(
colored('\t\t*** LOOKING UP ARCHIVAL INFORMATION ***',
c))
lib = Librarian(starname,
self.ra,
self.dec,
g_id=self.g_id,
mags=self.get_mags,
ignore=ignore)
self.g_id = lib.g_id
self.tic = lib.tic
self.kic = lib.kic
else:
print(colored('\t\t*** ARCHIVAL LOOKUP OVERRIDDEN ***', c))
if self.get_mags:
StarWarning('', 1).__raise__()
lib = None
self.tic = False
self.kic = False
# [plx, plx_e, dist, dist_e, rad, rad_e, temp, temp_e, lum, lum_e]
libouts = extract_from_lib(lib)
if self.get_plx:
self.plx = libouts[0]
self.plx_e = libouts[1]
else:
self.plx = plx
self.plx_e = plx_e
if self.get_dist:
self.dist = libouts[2]
self.dist_e = libouts[3]
elif dist is not None:
self.dist = dist
self.dist_e = dist_e
else:
self.calculate_distance()
if self.get_rad:
self.rad = libouts[4]
self.rad_e = libouts[5]
else:
self.rad = rad
self.rad_e = rad_e
if self.get_temp:
self.temp = libouts[6]
self.temp_e = libouts[7]
else:
self.temp = temp
self.temp_e = temp_e
if self.get_lum:
self.lum = libouts[8]
self.lum_e = libouts[9]
else:
self.lum = lum
self.lum_e = lum_e
if self.get_mags:
self.used_filters = lib.used_filters
self.mags = lib.mags
self.mag_errs = lib.mag_errs
else:
filters = []
self.used_filters = np.zeros(self.filter_names.shape[0])
self.mags = np.zeros(self.filter_names.shape[0])
self.mag_errs = np.zeros(self.filter_names.shape[0])
for k in mag_dict.keys():
filt_idx = np.where(k == self.filter_names)[0]
self.used_filters[filt_idx] = 1
self.mags[filt_idx] = mag_dict[k][0]
self.mag_errs[filt_idx] = mag_dict[k][1]
filters.append(k)
self.filter_mask = np.where(self.used_filters == 1)[0]
# Get max Av
if Av is None:
sfd = SFDQuery()
coords = SkyCoord(self.ra,
self.dec,
unit=(u.deg, u.deg),
frame='icrs')
ebv = sfd(coords)
self.Av = ebv * 2.742
else:
self.Av = Av
# Get the wavelength and fluxes of the retrieved magnitudes.
wave, flux, flux_er, bandpass = extract_info(
self.mags[self.filter_mask], self.mag_errs[self.filter_mask],
self.filter_names[self.filter_mask])
self.wave = np.zeros(self.filter_names.shape[0])
self.flux = np.zeros(self.filter_names.shape[0])
self.flux_er = np.zeros(self.filter_names.shape[0])
self.bandpass = np.zeros(self.filter_names.shape[0])
for k in wave.keys():
filt_idx = np.where(k == self.filter_names)[0]
self.wave[filt_idx] = wave[k]
self.flux[filt_idx] = flux[k]
self.flux_er[filt_idx] = flux_er[k]
self.bandpass[filt_idx] = bandpass[k]
rel_er = self.flux_er[self.filter_mask] / self.flux[self.filter_mask]
mx_rel_er = rel_er.max() + 0.1
upper = self.flux_er[self.filter_mask] == 0
flx = self.flux[self.filter_mask][upper]
for i, f in zip(self.filter_mask[upper], flx):
self.flux_er[i] = mx_rel_er * f
# self.calculate_distance()
c = random.choice(self.colors)
display_star_fin(self, c)
c = random.choice(self.colors)
self.print_mags(c)
def __call__(self, obs, display=False, time_display=0):
""" Simulation of the light curve
We use multiprocessing (one band per process) to increase speed
Parameters
---------
obs: array
array of observations
gen_par: array
simulation parameters
display: bool,opt
to display LC as they are generated (default: False)
time_display: float, opt
time persistency of the displayed window (defalut: 0 sec)
Returns
---------
astropy table with:
columns: band, flux, fluxerr, snr_m5,flux_e,zp,zpsys,time
metadata : SNID,RA,Dec,DayMax,X1,Color,z
"""
RA = np.mean(obs[self.RACol])
Dec = np.mean(obs[self.DecCol])
pixRA = np.mean(obs['pixRA'])
pixDec = np.mean(obs['pixDec'])
pixID = np.unique(obs['healpixID']).item()
dL = -1
# get ebvofMW from dust maps
ebvofMW = self.sn_parameters['ebvofMW']
if ebvofMW < 0.:
# in that case ebvofMW value is taken from a map
coords = SkyCoord(pixRA, pixDec, unit='deg')
try:
sfd = SFDQuery()
except Exception as err:
from dustmaps.config import config
config['data_dir'] = 'dustmaps'
import dustmaps.sfd
dustmaps.sfd.fetch()
sfd = SFDQuery()
ebvofMW = sfd(coords)
# start timer
ti = SNTimer(time.time())
# Are there observations with the filters?
goodFilters = np.in1d(obs[self.filterCol],
np.array([b for b in 'grizy']))
if len(obs[goodFilters]) == 0:
return [self.nosim(ra, dec, pixRA, pixDec, pixID, season, ti, -1)]
tab_tot = self.lcFast(obs, ebvofMW, self.gen_parameters)
"""
# apply dust correction here
tab_tot = self.dust_corrections(tab_tot, pixRA, pixDec)
"""
ptime = ti.finish(time.time())['ptime'].item()
self.premeta.update(
dict(
zip([
'RA', 'Dec', 'pixRA', 'pixDec', 'healpixID', 'dL', 'ptime',
'status'
], [RA, Dec, pixRA, pixDec, pixID, dL, ptime, 1])))
"""
ii = tab_tot['band'] == 'LSST::z'
sel = tab_tot[ii]
for io, row in sel.iterrows():
print(row[['phase', 'z', 'band', 'flux',
'old_flux', 'fluxerr', 'old_fluxerr']].values)
"""
list_tables = self.transform(tab_tot)
# if the user chooses to display the results...
if display:
for table_lc in list_tables:
self.plotLC(
table_lc['time', 'band', 'flux', 'fluxerr', 'zp', 'zpsys'],
time_display)
return list_tables
def __init__(
self,
survey=LATEST_HDR_NAME,
catalog_type="lines",
curated_version=None,
loadtable=True,
):
"""
Initialize the detection catalog class for a given data release
Input
-----
survey : string
Data release you would like to load, i.e., 'hdr2','HDR1'
This is case insensitive.
catalog_type : string
Catalog to laod up. Either 'lines' or 'continuum'. Default is
'lines'.
load_table : bool
Boolean flag to load all detection table info upon initialization.
For example, if you just want to grab a spectrum this isn't needed.
"""
survey_options = ["hdr1", "hdr2", "hdr2.1"]
catalog_type_options = ["lines", "continuum", "broad"]
if survey.lower() not in survey_options:
print("survey not in survey options")
print(survey_options)
return None
if catalog_type.lower() not in catalog_type_options:
print("catalog_type not in catalog_type options")
print(catalog_type_options)
return None
# store to class
if curated_version is not None:
self.version = curated_version
self.loadtable = False
self.survey = "hdr" + curated_version[0:3]
else:
self.version = None
self.survey = survey
self.loadtable = loadtable
global config
config = HDRconfig(survey=self.survey)
if catalog_type == "lines":
self.filename = config.detecth5
elif catalog_type == "continuum":
self.filename = config.contsourceh5
elif catalog_type == "broad":
try:
self.filename = config.detectbroadh5
except:
print("Could not locate broad line catalog")
self.hdfile = tb.open_file(self.filename, mode="r")
# store to class
if curated_version is not None:
self.version = curated_version
self.loadtable = False
self.survey = "hdr" + curated_version[0:3]
else:
self.survey = survey
self.loadtable = loadtable
if self.version is not None:
try:
catfile = op.join(config.detect_dir, "catalogs",
"detect_hdr" + self.version + ".fits")
det_table = Table.read(catfile)
for col in det_table.colnames:
if isinstance(det_table[col][0], str):
setattr(self, col,
np.array(det_table[col]).astype(str))
else:
setattr(self, col, np.array(det_table[col]))
self.vis_class = -1 * np.ones(np.size(self.detectid))
except:
print("Could not open curated catalog version: " +
self.version)
return None
elif self.loadtable:
colnames = self.hdfile.root.Detections.colnames
for name in colnames:
if isinstance(
getattr(self.hdfile.root.Detections.cols, name)[0],
np.bytes_):
setattr(
self,
name,
getattr(self.hdfile.root.Detections.cols,
name)[:].astype(str),
)
else:
setattr(self, name,
getattr(self.hdfile.root.Detections.cols, name)[:])
if self.survey == "hdr2.1":
# Fix fluxes and continuum values for aperture corrections
wave = self.hdfile.root.Detections.cols.wave[:]
apcor = self.hdfile.root.Spectra.cols.apcor[:]
wave_spec = self.hdfile.root.Spectra.cols.wave1d[:]
apcor_array = np.ones_like(wave)
for idx in np.arange(0, np.size(wave)):
sel_apcor = np.where(wave_spec[idx, :] > wave[idx])[0][0]
apcor_array[idx] = apcor[idx, sel_apcor]
self.apcor = apcor_array
if catalog_type == "lines":
# remove E(B-V)=0.02 screen extinction
fix = get_2pt1_extinction_fix()
self.flux /= fix(wave)
self.flux_err /= fix(wave)
self.continuum /= fix(wave)
self.continuum_err /= fix(wave)
# store observed flux values in new columns
self.flux_obs = self.flux.copy()
self.flux_err_obs = self.flux_err.copy()
self.continuum_obs = self.continuum.copy()
self.continuum_err_obs = self.continuum_err.copy()
# apply extinction to observed values to get
# dust corrected values
# Apply S&F 2011 Extinction correction from SFD Map
# https://iopscience.iop.org/article/10.1088/0004-637X/737/2/103#apj398709t6
self.coords = SkyCoord(self.ra * u.degree,
self.dec * u.degree,
frame="icrs")
sfd = SFDQuery()
self.ebv = sfd(self.coords)
Rv = 3.1
corr_SF2011 = 2.742 # Landolt V
ext = []
self.Av = corr_SF2011 * self.ebv
for index in np.arange(np.size(self.detectid)):
src_wave = np.array([np.double(self.wave[index])])
ext_i = extinction.fitzpatrick99(
src_wave, self.Av[index], Rv)[0]
ext.append(ext_i)
deredden = 10**(0.4 * np.array(ext))
self.flux *= deredden
self.flux_err *= deredden
self.continuum *= deredden
self.continuum_err *= deredden
# add in the elixer probabilties and associated info:
if self.survey == "hdr1" and catalog_type == "lines":
self.hdfile_elix = tb.open_file(config.elixerh5, mode="r")
colnames2 = self.hdfile_elix.root.Classifications.colnames
for name2 in colnames2:
if name2 == "detectid":
setattr(
self,
"detectid_elix",
self.hdfile_elix.root.Classifications.cols.
detectid[:],
)
else:
if isinstance(
getattr(
self.hdfile_elix.root.Classifications.cols,
name2)[0],
np.bytes_,
):
setattr(
self,
name2,
getattr(
self.hdfile_elix.root.Classifications.cols,
name2)[:].astype(str),
)
else:
setattr(
self,
name2,
getattr(
self.hdfile_elix.root.Classifications.cols,
name2)[:],
)
else:
# add elixer info if node exists
try:
colnames = self.hdfile.root.Elixer.colnames
for name in colnames:
if name == "detectid":
continue
if isinstance(
getattr(self.hdfile.root.Elixer.cols, name)[0],
np.bytes_):
setattr(
self,
name,
getattr(self.hdfile.root.Elixer.cols,
name)[:].astype(str),
)
else:
setattr(
self,
name,
getattr(self.hdfile.root.Elixer.cols, name)[:],
)
self.gmag = self.mag_sdss_g
self.gmag_err = self.mag_sdss_g
except:
print("No Elixer table found")
# also assign a field and some QA identifiers
self.field = np.chararray(np.size(self.detectid), 12, unicode=True)
self.fwhm = np.zeros(np.size(self.detectid))
if self.survey == "hdr1":
self.fluxlimit_4550 = np.zeros(np.size(self.detectid))
else:
self.fluxlimit_4540 = np.zeros(np.size(self.detectid))
self.throughput = np.zeros(np.size(self.detectid))
self.n_ifu = np.zeros(np.size(self.detectid), dtype=int)
S = Survey(self.survey)
for index, shot in enumerate(S.shotid):
ix = np.where(self.shotid == shot)
self.field[ix] = S.field[index].astype(str)
# NOTE: python2 to python3 strings now unicode
if self.survey == "hdr1":
self.fwhm[ix] = S.fwhm_moffat[index]
self.fluxlimit_4550[ix] = S.fluxlimit_4550[index]
else:
self.fwhm[ix] = S.fwhm_virus[index]
try:
self.fluxlimit_4540[ix] = S.fluxlimit_4540[index]
except:
pass
self.throughput[ix] = S.response_4540[index]
self.n_ifu[ix] = S.n_ifu[index]
# assign a vis_class field for future classification
# -2 = ignore (bad detectid, shot)
# -1 = no assignemnt
# 0 = artifact
# 1 = OII emitter
# 2 = LAE emitter
# 3 = star
# 4 = nearby galaxies (HBeta, OIII usually)
# 5 = other line
# close the survey HDF5 file
S.close()
self.vis_class = -1 * np.ones(np.size(self.detectid))
if self.survey == "hdr1":
self.add_hetdex_gmag(loadpickle=True, picklefile=config.gmags)
if self.survey == "hdr1":
if PYTHON_MAJOR_VERSION < 3:
self.plae_poii_hetdex_gmag = np.array(
pickle.load(open(config.plae_poii_hetdex_gmag, "rb")))
else:
self.plae_poii_hetdex_gmag = np.array(
pickle.load(open(config.plae_poii_hetdex_gmag, "rb"),
encoding="bytes"))
else:
# just get coordinates, wavelength and detectid
self.detectid = self.hdfile.root.Detections.cols.detectid[:]
self.ra = self.hdfile.root.Detections.cols.ra[:]
self.dec = self.hdfile.root.Detections.cols.dec[:]
self.wave = self.hdfile.root.Detections.cols.wave[:]
# set the SkyCoords
self.coords = SkyCoord(self.ra * u.degree,
self.dec * u.degree,
frame="icrs")
def dust(l, b):
c = SkyCoord(l, b, frame='galactic')
sfd = SFDQuery()
dust = sfd(c)
return dust
def main(self):
hpx_path = "%s/%s" % (self.options.healpix_dir, self.options.healpix_file)
# If you specify a telescope that's not in the default list, you must provide the rest of the information
detector = None
is_error = False
is_custom_percentile = False
custom_percentile = None
# Check the inputs for errors...
if self.options.telescope_abbreviation not in self.telescope_mapping.keys():
print("Running for custom telescope. Checking required parameters...")
if self.options.telescope_abbreviation == "":
is_error = True
print("For custom telescope, `telescope_abbreviation` is required!")
if self.options.telescope_name == "":
is_error = True
print("For custom telescope, `telescope_name` is required!")
if self.options.detector_width_deg <= 0.0:
is_error = True
print("For custom telescope, `detector_width_deg` is required, and must be > 0!")
if self.options.detector_height_deg <= 0.0:
is_error = True
print("For custom telescope, `detector_height_deg` is required, and must be > 0!")
if not is_error:
detector = Detector(self.options.telescope_name, self.options.detector_width_deg,
self.options.detector_height_deg)
else:
detector = self.telescope_mapping[self.options.telescope_abbreviation]
if self.options.percentile > 0.9:
is_error = True
print("User-defined percentile must be <= 0.90")
elif self.options.percentile > 0.0:
is_custom_percentile = True
custom_percentile = self.options.percentile
if is_error:
print("Exiting...")
return 1
print("\n\nTelescope: `%s -- %s`, width: %s [deg]; height %s [deg]" % (self.options.telescope_abbreviation,
detector.name, detector.deg_width,
detector.deg_height))
fov_area = (detector.deg_width * detector.deg_height)
print("%s FOV area: %s" % (detector.name, fov_area))
print("Loading base cartography...")
base_cartography = None
with open('%s/%s_base_cartography.pkl' % (self.options.working_dir, self.options.gw_id), 'rb') as handle:
base_cartography = pickle.load(handle)
# print("Loading sql pixel map...")
# sql_pixel_map = None
# with open('%s/%s_sql_pixel_map.pkl' % (self.options.working_dir, self.options.gw_id), 'rb') as handle:
# sql_pixel_map = pickle.load(handle)
# print("Loading sql cartography...")
# sql_tile_cartography = None
# with open('%s/%s_sql_cartography.pkl' % (self.options.working_dir, self.options.gw_id), 'rb') as handle:
# sql_tile_cartography = pickle.load(handle)
# print("Loading galaxy query...")
# query = None
# with open('%s/%s_query.pkl' % (self.options.working_dir, self.options.gw_id), 'rb') as handle:
# query = pickle.load(handle)
if not self.options.skip_completeness:
print("Loading sql multipolygon...")
sql_poly = None
with open('%s/%s_sql_poly.pkl' % (self.options.working_dir, self.options.gw_id), 'rb') as handle:
sql_poly = pickle.load(handle)
# print("Loading contained galaxies...")
# contained_galaxies = None
# with open('%s/%s_contained_galaxies.pkl' % (self.options.working_dir, self.options.gw_id), 'rb') as handle:
# contained_galaxies = pickle.load(handle)
# for g in (sorted(contained_galaxies, key=lambda x: x.relative_prob, reverse=True))[:99]:
# print(g.relative_prob)
print("Loading redistributed cartography...")
redistributed_cartography = None
with open('%s/%s_redstributed_cartography.pkl' % (self.options.working_dir, self.options.gw_id),
'rb') as handle:
redistributed_cartography = pickle.load(handle)
# print("Loading observed tiles file...")
# observed_tiles = {
# "S190728q":{"Thacher":{"ut190728":[]},
# "Swope":{"ut190728":[]}
# }
# }
# running_prob = 0
# unique_pixels = []
# # Thacher
# thacher_width = 2048*0.609/3600. #arcseconds -> deg
# thacher_height = 2048*0.609/3600.
# with open('%s/ut190727_28_Thacher_observed.txt' % self.options.working_dir,'r') as csvfile:
# csvreader = csv.reader(csvfile, delimiter=',',skipinitialspace=True)
# for row in csvreader:
# name = row[0]
# t = Tile(coord.SkyCoord(row[1], row[2], unit=(u.hour, u.deg)), thacher_width, thacher_height, redistributed_cartography.unpacked_healpix.nside)
# t.field_name = name
# t_prob = t.enclosed_pixel_indices
# for ti in t_prob:
# if ti not in unique_pixels:
# unique_pixels.append(ti)
# t.net_prob = np.sum(redistributed_cartography.unpacked_healpix.prob[t_prob])
# running_prob += t.net_prob
# print("%s - net prob: %s" % (name, t.net_prob))
# observed_tiles["S190728q"]["Thacher"]["ut190728"].append(t)
# print("\n")
# swope_width = 4096*0.435/3600. #arcseconds -> deg
# swope_height = 4112*0.435/3600.
# with open('%s/ut190727_28_Swope_observed.txt' % self.options.working_dir,'r') as csvfile:
# csvreader = csv.reader(csvfile, delimiter=',',skipinitialspace=True)
# for row in csvreader:
# name = row[0]
# t = Tile(coord.SkyCoord(row[1], row[2], unit=(u.hour, u.deg)), swope_width, swope_height, redistributed_cartography.unpacked_healpix.nside)
# t.field_name = name
# t_prob = t.enclosed_pixel_indices
# for ti in t_prob:
# if ti not in unique_pixels:
# unique_pixels.append(ti)
# t.net_prob = np.sum(redistributed_cartography.unpacked_healpix.prob[t_prob])
# running_prob += t.net_prob
# print("%s - net prob: %s" % (name, t.net_prob))
# observed_tiles["S190728q"]["Swope"]["ut190728"].append(t)
# tile_set = [
# ("Thacher_0728",observed_tiles["S190728q"]["Thacher"]["ut190728"],('royalblue','None')),
# ("Swope_0728",observed_tiles["S190728q"]["Swope"]["ut190728"],('green','None')),
# ]
# print("Total non-corrected prob captured by observed Thacher+Swope tiles: %s" % running_prob)
# print("Total corrected prob captured by observed Thacher+Swope tiles: %s" % np.sum(redistributed_cartography.unpacked_healpix.prob[np.asarray(unique_pixels)]))
print("\n\nBuilding MWE...")
config["data_dir"] = "./DataIngestion"
print("Initializing MWE n128 pix...")
f99_r = 2.285
nside128 = 128
nside128_npix = hp.nside2npix(nside128)
nside128_pixels = []
nside128_RA = []
nside128_DEC = []
mw_pixels = []
for i in range(nside128_npix):
pe = Pixel_Element(i, nside128, 0.0)
nside128_pixels.append(pe)
theta, phi = hp.pix2ang(pe.nside, pe.index)
dec = np.degrees(0.5 * np.pi - theta)
ra = np.degrees(phi)
nside128_RA.append(ra)
nside128_DEC.append(dec)
c1 = coord.SkyCoord(nside128_RA, nside128_DEC, unit=(u.deg, u.deg))
sfd = SFDQuery()
ebv1 = sfd(c1)
for i, e in enumerate(ebv1):
if e * f99_r >= 0.5:
mw_pixels.append(nside128_pixels[i])
tiles_to_plot = None
pixels_to_plot = None
sql_poly_to_plot = None
if not self.options.skip_completeness:
tiles_to_plot = redistributed_cartography.tiles
pixels_to_plot = redistributed_cartography.unpacked_healpix.pixels_90
sql_poly_to_plot = sql_poly
else:
tiles_to_plot = base_cartography.tiles
pixels_to_plot = base_cartography.unpacked_healpix.pixels_90
ra_tiles = []
dec_tiles = []
for i, t in enumerate(tiles_to_plot):
field_name = "%s%s%sE%s" % (self.options.telescope_abbreviation,
str(self.options.event_number).zfill(3),
self.options.schedule_designation,
str(i + 1).zfill(5))
t.field_name = field_name
# ra_tiles.append(t.coord.ra.degree)
# dec_tiles.append(t.coord.dec.degree)
ra_tiles.append(t.ra_deg)
dec_tiles.append(t.dec_deg)
c = coord.SkyCoord(ra_tiles, dec_tiles, unit=(u.deg, u.deg))
sfd = SFDQuery()
ebv = sfd(c)
new_tiles = []
for i, e in enumerate(ebv):
t = tiles_to_plot[i]
# if e*f99_r < 0.5 and t.coord.dec.degree > -30.0:
if e * f99_r < 0.5 and t.dec_deg < 30.0:
new_tiles.append(t)
# if t.coord.dec.degree > -30.0:
# t.mwe = e
# new_tiles.append(t)
print(len(new_tiles))
prob = 0.0
for t in new_tiles:
prob += t.net_prob
print("Enclosed prob = %s" % prob)
def GetSexigesimalString(c):
ra = c.ra.hms
dec = c.dec.dms
ra_string = "%02d:%02d:%05.2f" % (ra[0], ra[1], ra[2])
if dec[0] >= 0:
dec_string = "+%02d:%02d:%05.2f" % (dec[0], np.abs(dec[1]), np.abs(dec[2]))
else:
dec_string = "%03d:%02d:%05.2f" % (dec[0], np.abs(dec[1]), np.abs(dec[2]))
# Python has a -0.0 object. If the deg is this (because object lies < 60 min south), the string formatter will drop the negative sign
if c.dec < 0.0 and dec[0] == 0.0:
dec_string = "-00:%02d:%05.2f" % (np.abs(dec[1]), np.abs(dec[2]))
return (ra_string, dec_string)
with open('%s/%s_%s_MWE_below_30_AA.txt' % (self.options.working_dir, self.options.gw_id, detector.name),
'w') as csvfile:
csvwriter = csv.writer(csvfile)
cols = []
cols.append('# FieldName')
cols.append('FieldRA')
cols.append('FieldDec')
cols.append('Telscope')
cols.append('Filter')
cols.append('ExpTime')
cols.append('Priority')
cols.append('Status')
# cols.append('A_R')
csvwriter.writerow(cols)
for i, st in enumerate(new_tiles):
# coord_str = GetSexigesimalString(st.coord)
c = coord.SkyCoord(st.ra_deg, st.dec_deg, unit=(u.deg, u.deg))
coord_str = GetSexigesimalString(c)
cols = []
cols.append(st.field_name)
cols.append(coord_str[0])
cols.append(coord_str[1])
cols.append(detector.name)
cols.append(self.options.filter)
cols.append(self.options.exp_time)
cols.append(st.net_prob)
cols.append('False')
# cols.append(st.mwe)
csvwriter.writerow(cols)
print("Done")
# return 0;
# raise("Stop!")
# swope_width = 4096*0.435/3600. #arcseconds -> deg
# swope_height = 4112*0.435/3600.
# thacher_width = 2048*0.609/3600. #arcseconds -> deg
# thacher_height = 2048*0.609/3600.
# nickel_width = 2048*0.368/3600. #arcseconds -> deg
# nickel_height = 2048*0.368/3600.
# nickel_width = 2048*0.368/3600. #arcseconds -> deg
# nickel_height = 2048*0.368/3600.
# andicam_ccd_width = 1024*0.371/3600. #arcseconds -> deg
# andicam_ccd_height = 1024*0.371/3600.
# swift_uvot_width = 2048*0.502/3600. #arcseconds -> deg
# swift_uvot_height = 2048*0.502/3600.
# saguaro_width = 2.26 #deg
# saguaro_height = 2.26
# observed_tiles = {
# "S190425z":{"Swope":{"ut190425":[], "ut190428":[], "ut190429":[]},
# "Thacher":{"ut190425":[]},
# "ANDICAM":{"ut190425":[], "ut190428":[]},
# "Nickel":{"ut190425":[], "ut190429":[]},
# "Swift":{"ut190425":[]},
# "SAGUARO":{"ut190425":[]}
# }
# }
# # Just do S190425z for now...
# # SWOPE
# with open('../O3_Alerts/GW190408/GW190425_2/S190425z_ut190425_Swope_Tiles_Observed.csv','r') as csvfile:
# csvreader = csv.reader(csvfile, delimiter=' ',skipinitialspace=True)
# next(csvreader)
# for row in csvreader:
# t = Tile(coord.SkyCoord(row[1], row[2], unit=(u.hour, u.deg)), swope_width, swope_height, redistributed_cartography.unpacked_healpix.nside)
# (observed_tiles["S190425z"]["Swope"]["ut190425"]).append(t)
# with open('../O3_Alerts/GW190408/GW190425_2/S190425z_ut190428_Swope_Tiles_Observed.csv','r') as csvfile:
# csvreader = csv.reader(csvfile, delimiter=' ',skipinitialspace=True)
# next(csvreader)
# for row in csvreader:
# t = Tile(coord.SkyCoord(row[1], row[2], unit=(u.hour, u.deg)), swope_width, swope_height, redistributed_cartography.unpacked_healpix.nside)
# (observed_tiles["S190425z"]["Swope"]["ut190428"]).append(t)
# with open('../O3_Alerts/GW190408/GW190425_2/S190425z_ut190429_Swope_Tiles_Observed.csv','r') as csvfile:
# csvreader = csv.reader(csvfile, delimiter=' ',skipinitialspace=True)
# next(csvreader)
# for row in csvreader:
# t = Tile(coord.SkyCoord(row[1], row[2], unit=(u.hour, u.deg)), swope_width, swope_height, redistributed_cartography.unpacked_healpix.nside)
# (observed_tiles["S190425z"]["Swope"]["ut190429"]).append(t)
# # THACHER
# with open('../O3_Alerts/GW190408/GW190425_2/S190425z_ut190425_Thacher_Tiles_Observed.csv','r') as csvfile:
# csvreader = csv.reader(csvfile, delimiter=' ',skipinitialspace=True)
# next(csvreader)
# for row in csvreader:
# t = Tile(coord.SkyCoord(row[1], row[2], unit=(u.hour, u.deg)), thacher_width, thacher_height, redistributed_cartography.unpacked_healpix.nside)
# (observed_tiles["S190425z"]["Thacher"]["ut190425"]).append(t)
# # ANDICAM
# with open('../O3_Alerts/GW190408/GW190425_2/S190425z_ut190425_ANDICAM_Tiles_Observed.csv','r') as csvfile:
# csvreader = csv.reader(csvfile, delimiter=' ',skipinitialspace=True)
# next(csvreader)
# for row in csvreader:
# t = Tile(coord.SkyCoord(row[1], row[2], unit=(u.hour, u.deg)), andicam_ccd_width, andicam_ccd_height, redistributed_cartography.unpacked_healpix.nside)
# (observed_tiles["S190425z"]["ANDICAM"]["ut190425"]).append(t)
# with open('../O3_Alerts/GW190408/GW190425_2/S190425z_ut190428_ANDICAM_Tiles_Observed.csv','r') as csvfile:
# csvreader = csv.reader(csvfile, delimiter=' ',skipinitialspace=True)
# next(csvreader)
# for row in csvreader:
# t = Tile(coord.SkyCoord(row[1], row[2], unit=(u.hour, u.deg)), andicam_ccd_width, andicam_ccd_height, redistributed_cartography.unpacked_healpix.nside)
# (observed_tiles["S190425z"]["ANDICAM"]["ut190428"]).append(t)
# # NICKEL
# with open('../O3_Alerts/GW190408/GW190425_2/S190425z_ut190425_Nickel_Tiles_Observed.csv','r') as csvfile:
# csvreader = csv.reader(csvfile, delimiter=' ',skipinitialspace=True)
# next(csvreader)
# for row in csvreader:
# t = Tile(coord.SkyCoord(row[1], row[2], unit=(u.hour, u.deg)), nickel_width, nickel_height, redistributed_cartography.unpacked_healpix.nside)
# (observed_tiles["S190425z"]["Nickel"]["ut190425"]).append(t)
# with open('../O3_Alerts/GW190408/GW190425_2/S190425z_ut190429_Nickel_Tiles_Observed.csv','r') as csvfile:
# csvreader = csv.reader(csvfile, delimiter=' ',skipinitialspace=True)
# next(csvreader)
# for row in csvreader:
# t = Tile(coord.SkyCoord(row[1], row[2], unit=(u.hour, u.deg)), nickel_width, nickel_height, redistributed_cartography.unpacked_healpix.nside)
# (observed_tiles["S190425z"]["Nickel"]["ut190429"]).append(t)
# # Swift
# with open('../O3_Alerts/GW190408/GW190425_2/S190425z_ut190425_Swift_Tiles_Observed.csv','r') as csvfile:
# csvreader = csv.reader(csvfile, delimiter=' ',skipinitialspace=True)
# next(csvreader)
# for row in csvreader:
# t = Tile(coord.SkyCoord(row[1], row[2], unit=(u.deg, u.deg)), swift_uvot_width, swift_uvot_height, redistributed_cartography.unpacked_healpix.nside)
# (observed_tiles["S190425z"]["Swift"]["ut190425"]).append(t)
# for k1,v1 in observed_tiles.items():
# print("%s" % k1)
# for k2,v2 in observed_tiles[k1].items():
# print("\t%s" % k2)
# for k3,v3 in observed_tiles[k1][k2].items():
# print("\t\t%s - # of tiles: %s" % (k3, len(observed_tiles[k1][k2][k3])))
# print("\n")
# tile_set = [
# ("Swope_0425",observed_tiles["S190425z"]["Swope"]["ut190425"],('r','None')),
# ("Swope_0428",observed_tiles["S190425z"]["Swope"]["ut190428"],('r','None')),
# ("Swope_0429",observed_tiles["S190425z"]["Swope"]["ut190429"],('r','None')),
# ("Thacher_0425",observed_tiles["S190425z"]["Thacher"]["ut190425"],('royalblue','None')),
# ("ANDICAM_0425",observed_tiles["S190425z"]["ANDICAM"]["ut190425"],('forestgreen','None')),
# ("ANDICAM_0428",observed_tiles["S190425z"]["ANDICAM"]["ut190428"],('forestgreen','None')),
# ("Nickel_0425",observed_tiles["S190425z"]["Nickel"]["ut190425"],('mediumorchid','None')),
# ("Nickel_0429",observed_tiles["S190425z"]["Nickel"]["ut190429"],('mediumorchid','None')),
# ("Swift_0425",observed_tiles["S190425z"]["Swift"]["ut190425"],('k','None'))
# ]
# # In case you want to plot contours...
# print("Computing contours for '%s'...\n" % base_cartography.unpacked_healpix.file_name)
# base_cartography.unpacked_healpix.compute_contours()
# print("Computing contours for '%s'...\n" % redistributed_cartography.unpacked_healpix.file_name)
# redistributed_cartography.unpacked_healpix.compute_contours()
# # Thacher
# thacher_tiles = []
# with open('%s/S190521g_AA_THACHER_Tiles.txt' % self.options.working_dir,'r') as csvfile:
# csvreader = csv.reader(csvfile, delimiter=',')
# next(csvreader)
# for row in csvreader:
# t = Tile(coord.SkyCoord(row[1], row[2], unit=(u.hour, u.deg)), detector.deg_width, detector.deg_height,
# redistributed_cartography.unpacked_healpix.nside)
# t.field_name = row[0]
# t.net_prob = np.sum(redistributed_cartography.unpacked_healpix.prob[t.enclosed_pixel_indices])
# print("Tile #: %s; Net prob: %0.4f" % (t.field_name, t.net_prob))
# thacher_tiles.append(t)
# above_30 = []
# for t in thacher_tiles:
# if t.coord.dec.degree > -30.0:
# above_30.append(t)
# sorted_tiles = sorted(above_30, key=lambda t: t.net_prob, reverse=True)
# print("Number of northern tiles: %s" % len(sorted_tiles))
# top_200 = sorted_tiles[0:199]
# top_200_prob = np.sum([t.net_prob for t in top_200])
# print("Prob of northern, top 200: %s" % top_200_prob)
# top_200_area = fov_area*200
# print("Area of northern, top 200: %s" % top_200_area)
# with open('%s/S190521g_AA_THACHER_Tiles_Northern_200.txt' % self.options.working_dir,'w') as csvfile:
# csvwriter = csv.writer(csvfile)
# cols = []
# cols.append('# FieldName')
# cols.append('FieldRA')
# cols.append('FieldDec')
# cols.append('Telscope')
# cols.append('Filter')
# cols.append('ExpTime')
# cols.append('Priority')
# cols.append('Status')
# csvwriter.writerow(cols)
# for i, st in enumerate(top_200):
# coord_str = GetSexigesimalString(st.coord)
# cols = []
# cols.append(st.field_name)
# cols.append(coord_str[0])
# cols.append(coord_str[1])
# cols.append(detector.name)
# cols.append(self.options.filter)
# cols.append(self.options.exp_time)
# print(st.net_prob)
# cols.append(st.net_prob)
# cols.append('False')
# csvwriter.writerow(cols)
# print("Done")
# test = []
# for t in base_cartography.tiles:
# test.append(t.polygon)
# # print("here")
# # print(list(test[0].exterior.coords))
# # print("\n\n")
# test2 = unary_union(test)
# # print(type(test2))
# eps = 0.00001
# test3 = test2.buffer(eps, 1, join_style=JOIN_STYLE.mitre).buffer(-eps, 1, join_style=JOIN_STYLE.mitre)
# plot_probability_map("%s/%s_SQL_Pixels" % (self.options.working_dir, self.options.gw_id),
# pixels_filled=base_cartography.unpacked_healpix.pixels_90,
# # tiles=base_cartography.tiles,
# # pixels_empty=base_cartography.unpacked_healpix.pixels_90,
# colormap=plt.cm.viridis,
# linear_rings=test3)
# pixels_90 = [Pixel_Element(i90, redistributed_cartography.unpacked_healpix.nside,
# redistributed_cartography.unpacked_healpix.prob[i90])
# for i90 in redistributed_cartography.unpacked_healpix.indices_of_90]
plot_probability_map(
"%s/%s_%s_Redistributed_90th_Tiles" % (self.options.working_dir, self.options.gw_id, detector.name),
# pixels_filled=redistributed_cartography.unpacked_healpix.pixels_90,
pixels_filled=pixels_to_plot,
# galaxies=contained_galaxies,
galaxies=mw_pixels,
tiles=new_tiles,
# tiles=redistributed_cartography.tiles,
# tiles=base_cartography.tiles,
# sql_poly=sql_poly,
# sql_poly=sql_poly_to_plot,
# linear_rings=sql_poly.polygon,
# healpix_obj_for_contours=base_cartography.unpacked_healpix,
# tile_set=tile_set
)
#distance = 2.3
#print(source_ra, source_dec, distance)
print('Estimating E(B-V) using dust maps:')
coords = SkyCoord(source_ra, source_dec, distance=distance*units.kpc, frame='icrs')
bayestar = BayestarQuery(max_samples=5, version='bayestar2017')
print('## Bayestar (3D):', bayestar(coords, mode='median'))
chen = Chen2014Query()
print('## Chen 2014 (3D):', chen(coords))
iphas = IPHASQuery()
print('## IPHAS (3D):', iphas(coords, mode='median'))
marshal = MarshallQuery()
print('## Marshall 2006 (3D):', marshal(coords))
sfdebv = SFDQuery()
print('## SFD 1998/2011 (2D):', sfdebv(coords))
lenz = Lenz2017Query()
print('## Lenz 2017 (2D):', lenz(coords))
bh = BHQuery()
print('## Burstein 1982 (2D):', bh(coords))
print('\n WARNING: REMEMBER TO USE APPROPRIATE BAND CONVERSION FACTORS.\nSEE http://iopscience.iop.org/article/10.1088/0004-637X/737/2/103/meta#apj398709t6')
