def test_rectifiedSED(self):
"""
Check for an extreme case that the SN seds are being rectified. This is
done by setting up an extreme case where there will be negative seds, and
checking that this is indeed the case, and checking that they are not
negative if rectified.
"""
snobj = SNObject(ra=30., dec=-60., source='salt2')
snobj.set(z=0.96, t0=self.mjdobs, x1=-3., x0=1.8e-6)
snobj.rectifySED = False
times = np.arange(self.mjdobs - 50., self.mjdobs + 150., 1.)
badTimes = []
for time in times:
sed = snobj.SNObjectSED(time=time,
bandpass=self.lsstBandPass['r'])
if any(sed.flambda < 0.):
badTimes.append(time)
# Check that there are negative SEDs
assert(len(badTimes) > 0)
snobj.rectifySED = True
for time in badTimes:
sed = snobj.SNObjectSED(time=time,
bandpass=self.lsstBandPass['r'])
self.assertGreaterEqual(sed.calcADU(bandpass=self.lsstBandPass['r'],
photParams=self.rectify_photParams), 0.)
self.assertFalse(any(sed.flambda < 0.))
def SNobj(fieldID, t0, snState=None, peakAbsMagBesselB=-19.3):
sn = SNObject(ra=np.degrees(so.ra(fieldID)),
dec=np.degrees(so.dec(fieldID)))
sn.set(t0=t0)
sn.set(z=0.5)
sn.set_source_peakabsmag(peakAbsMagBesselB, 'bessellB', 'ab')
return sn
def load_SNsed(self):
"""
returns a list of SN seds in `lsst.sims.photUtils.Sed` observed within
the spatio-temporal range specified by obs_metadata
"""
c, x1, x0, t0, _z, ra, dec = self.column_by_name('c'),\
self.column_by_name('x1'),\
self.column_by_name('x0'),\
self.column_by_name('t0'),\
self.column_by_name('redshift'),\
self.column_by_name('raJ2000'),\
self.column_by_name('decJ2000')
SNobject = SNObject()
raDeg = np.degrees(ra)
decDeg = np.degrees(dec)
sedlist = []
for i in range(self.numobjs):
SNobject.set(z=_z[i], c=c[i], x1=x1[i], t0=t0[i], x0=x0[i])
SNobject.setCoords(ra=raDeg[i], dec=decDeg[i])
SNobject.mwEBVfromMaps()
sed = SNobject.SNObjectSED(time=self.mjdobs,
bandpass=self.lsstBandpassDict,
applyExitinction=True)
sedlist.append(sed)
return sedlist
def astro_object(self, idValue, mjdOffset=59580.):
"""
instance of the catsim representation of the astrophysical object.
Parameters
----------
idValue : int, mandatory
index of the astro_object
mjdOffset : float, optional, defaults to 59580.
offset in time parameters in the database for the transient objects
Returns
-------
Instance of astro_object with parameters from the database
Examples
--------
>>> sn = reflc.astro_object(idValue=6001163623700)
"""
df = self.get_params(idValue)
sn = SNObject(ra=df.snra.values[0], dec=df.sndec.values[0])
paramDict = dict()
for param in ['t0', 'x0', 'x1', 'c']:
paramDict[param] = df[param].values
paramDict['t0'] += mjdOffset
paramDict['z'] = df.redshift.values[0]
sn.set(**paramDict)
return sn
def load_SNsed(self):
"""
returns a list of SN seds in `lsst.sims.photUtils.Sed` observed within
the spatio-temporal range specified by obs_metadata
"""
c, x1, x0, t0, _z, ra, dec = self.column_by_name('c'),\
self.column_by_name('x1'),\
self.column_by_name('x0'),\
self.column_by_name('t0'),\
self.column_by_name('redshift'),\
self.column_by_name('raJ2000'),\
self.column_by_name('decJ2000')
SNobject = SNObject()
raDeg = np.degrees(ra)
decDeg = np.degrees(dec)
sedlist = []
for i in range(self.numobjs):
SNobject.set(z=_z[i], c=c[i], x1=x1[i], t0=t0[i], x0=x0[i])
SNobject.setCoords(ra=raDeg[i], dec=decDeg[i])
SNobject.mwEBVfromMaps()
sed = SNobject.SNObjectSED(time=self.mjdobs,
bandpass=self.lsstBandpassDict,
applyExitinction=True)
sedlist.append(sed)
return sedlist
def SNobj(fieldID, t0, snState=None):
sn = SNObject(ra=np.degrees(so.ra(fieldID)),
dec=np.degrees(so.dec(fieldID)))
sn.set(t0=t0)
sn.set(z=0.5)
sn.set_source_peakabsmag(bessellBpeakabsmag, 'bessellB', 'ab')
return sn
def get_phosimVars(self):
"""
Obtain variables sedFilepath to be used to obtain unique filenames
for each SED for phoSim and MagNorm which is also used. Note that aside
from acting as a getter, this also writes spectra to
`self.sn_sedfile_prefix`snid_mjd_band.dat for each observation of
interest
"""
# construct the unique filename
# method: snid_mjd(to 4 places of decimal)_bandpassname
mjd = "_{:0.4f}_".format(self.mjdobs)
mjd += self.obs_metadata.bandpass + '.dat'
fnames = np.array([
self.sn_sedfile_prefix + str(int(elem)) + mjd if isinstance(
elem, numbers.Number) else self.sn_sedfile_prefix + str(elem) +
mjd for elem in self.column_by_name('snid')
],
dtype='str')
c, x1, x0, t0, z = self.column_by_name('c'),\
self.column_by_name('x1'),\
self.column_by_name('x0'),\
self.column_by_name('t0'),\
self.column_by_name('redshift')
bp = Bandpass()
bp.imsimBandpass()
magNorms = np.zeros(len(fnames))
snobject = SNObject()
snobject.rectifySED = True
for i in range(len(self.column_by_name('snid'))):
# if t0 is nan, this was set by the catalog for dim SN, or SN
# outside redshift range, We will not provide a SED file for these
if np.isnan(t0[i]):
magNorms[i] = np.nan
fnames[i] = None
else:
snobject.set(c=c[i], x1=x1[i], x0=x0[i], t0=t0[i], z=z[i])
if snobject.modelOutSideTemporalRange == 'zero':
if self.mjdobs > snobject.maxtime(
) or self.mjdobs < snobject.mintime():
magNorms[i] = np.nan
fnames[i] = None
# SED in rest frame
sed = snobject.SNObjectSourceSED(time=self.mjdobs)
try:
magNorms[i] = sed.calcMag(bandpass=bp)
except:
# sed.flambda = 1.0e-20
magNorms[i] = 1000. # sed.calcMag(bandpass=bp)
if self.writeSedFile:
sed.writeSED(fnames[i])
return (fnames, magNorms)
def get_phosimVars(self):
"""
Obtain variables sedFilepath to be used to obtain unique filenames
for each SED for phoSim and MagNorm which is also used. Note that aside
from acting as a getter, this also writes spectra to
`self.sn_sedfile_prefix`snid_mjd_band.dat for each observation of
interest
"""
# construct the unique filename
# method: snid_mjd(to 4 places of decimal)_bandpassname
mjd = "_{:0.4f}_".format(self.mjdobs)
mjd += self.obs_metadata.bandpass + '.dat'
fnames = np.array([self.sn_sedfile_prefix + str(int(elem)) + mjd
if isinstance(elem, numbers.Number) else
self.sn_sedfile_prefix + str(elem) + mjd
for elem in self.column_by_name('snid')], dtype='str')
c, x1, x0, t0, z = self.column_by_name('c'),\
self.column_by_name('x1'),\
self.column_by_name('x0'),\
self.column_by_name('t0'),\
self.column_by_name('redshift')
bp = Bandpass()
bp.imsimBandpass()
magNorms = np.zeros(len(fnames))
snobject = SNObject()
snobject.rectifySED = True
for i in range(len(self.column_by_name('snid'))):
# if t0 is nan, this was set by the catalog for dim SN, or SN
# outside redshift range, We will not provide a SED file for these
if np.isnan(t0[i]):
magNorms[i] = np.nan
fnames[i] = None
else:
snobject.set(c=c[i], x1=x1[i], x0=x0[i], t0=t0[i],
z=z[i])
if snobject.modelOutSideTemporalRange == 'zero':
if self.mjdobs > snobject.maxtime() or self.mjdobs < snobject.mintime():
magNorms[i] = np.nan
fnames[i] = None
# SED in rest frame
sed = snobject.SNObjectSourceSED(time=self.mjdobs)
try:
magNorms[i] = sed.calcMag(bandpass=bp)
except:
# sed.flambda = 1.0e-20
magNorms[i] = 1000. # sed.calcMag(bandpass=bp)
if self.writeSedFile:
sed.writeSED(fnames[i])
return (fnames, magNorms)
def getSNCosmomags(mjd, filt, snpars_table, snid_in='MS_9940_3541'):
asn = snpars_table.loc[snpars_table['snid_in'] == snid_in]
sn_mod = SNObject(ra=asn.snra_in[0], dec=asn.sndec_in[0])
sn_mod.set(z=asn.z_in[0],
t0=asn.t0_in[0],
x1=asn.x1_in[0],
c=asn.c_in[0],
x0=asn.x0_in[0])
# this is probably not the thing to do
flux = sn_mod.catsimBandFlux(mjd, LSST_BPass[filt])
mag = sn_mod.catsimBandMag(LSST_BPass[filt], mjd, flux)
return (flux, mag)
def calc_sne_mags(self, obs_mjd, obs_filter):
wavelen_max = 1800.
wavelen_min = 30.
wavelen_step = 0.1
sn_magnorm_list = []
sn_sed_names = []
add_to_cat_list = []
for idx in range(len(self.truth_cat)):
sed_mjd = obs_mjd - self.truth_cat['t_delay'].iloc[idx]
current_sn_obj = SNObject(ra=self.truth_cat['ra'].iloc[idx],
dec=self.truth_cat['dec'].iloc[idx])
current_sn_obj.set(z=self.truth_cat['redshift'].iloc[idx],
t0=self.truth_cat['t0'].iloc[idx],
x0=self.truth_cat['x0'].iloc[idx],
x1=self.truth_cat['x1'].iloc[idx],
c=self.truth_cat['c'].iloc[idx])
# Following follows from
# https://github.com/lsst/sims_catUtils/blob/master/python/lsst/sims/catUtils/mixins/sncat.py
sn_sed_obj = current_sn_obj.SNObjectSourceSED(
time=sed_mjd,
wavelen=np.arange(wavelen_min, wavelen_max, wavelen_step))
flux_500 = sn_sed_obj.flambda[np.where(
sn_sed_obj.wavelen >= 499.99)][0]
if flux_500 > 0.:
sn_magnorm = sn_sed_obj.calcMag(bandpass=self.imSimBand)
sn_name = None
if self.write_sn_sed:
sn_name = '%s/specFileGLSN_%s_%s_%.4f.txt' % (
self.sed_folder_name,
self.truth_cat['dc2_sys_id'].iloc[idx],
self.truth_cat['image_number'].iloc[idx], obs_mjd)
sed_filename = '%s/%s' % (self.out_dir, sn_name)
sn_sed_obj.writeSED(sed_filename)
with open(sed_filename, 'rb') as f_in, gzip.open(
str(sed_filename + '.gz'), 'wb') as f_out:
shutil.copyfileobj(f_in, f_out)
os.remove(sed_filename)
sn_magnorm_list.append(sn_magnorm)
sn_sed_names.append(sn_name + '.gz')
add_to_cat_list.append(idx)
return add_to_cat_list, np.array(sn_magnorm_list), sn_sed_names
def SN(self):
"""
`lsst.sims.catsim.SNObject` instance with peakMJD set to t0
"""
if self.snState is not None:
return SNObject.fromSNState(self.snState)
sn = SNObject(ra=self.radeg, dec=self.decdeg)
sn.set(t0=self.t0)
sn.set(z=0.5)
sn.set_source_peakabsmag(self.bessellBpeakabsmag, 'bessellB', 'ab')
return sn
def SN(self):
"""
`lsst.sims.catsim.SNObject` instance with peakMJD set to t0
"""
#if self.snState is not None:
# return SNObject.fromSNState(self.snState)
sn = SNObject(ra=self.radeg, dec=self.decdeg)
sn.set(t0=self.t0)
sn.set(**self._snState)
sn.set_source_peakabsmag(self._peakabsmagBessellB, 'bessellB', 'ab')
return sn
def SN(self):
"""
`lsst.sims.catsim.SNObject` instance with peakMJD set to t0
"""
if self._SN is not None:
pass
# return self._SN
elif self.snState is not None:
self._SN = SNObject.fromSNState(self.snState)
else :
sn = SNObject(ra=self.radeg, dec=self.decdeg)
sn.set(t0=self.t0)
sn.set(z=0.5)
sn.set_source_peakabsmag(self.peakAbsMagBesselB, 'bessellB', 'ab')
self._SN = sn
return self._SN
def SN(self):
"""
`lsst.sims.catsim.SNObject` instance with peakMJD set to t0
"""
if self._SN is not None:
pass
# return self._SN
elif self.snState is not None:
self._SN = SNObject.fromSNState(self.snState)
else:
sn = SNObject(ra=self.radeg, dec=self.decdeg)
sn.set(t0=self.t0)
sn.set(z=0.5)
sn.set_source_peakabsmag(self.peakAbsMagBesselB, 'bessellB', 'ab')
self._SN = sn
return self._SN
def get_snfluxes(self):
c, x1, x0, t0, _z, ra, dec = self.column_by_name('c'),\
self.column_by_name('x1'),\
self.column_by_name('x0'),\
self.column_by_name('t0'),\
self.column_by_name('redshift'),\
self.column_by_name('raJ2000'),\
self.column_by_name('decJ2000')
raDeg = np.degrees(ra)
decDeg = np.degrees(dec)
snobject = SNObject()
# Initialize return array
vals = np.zeros(shape=(self.numobjs, 19))
for i, _ in enumerate(vals):
snobject.set(z=_z[i], c=c[i], x1=x1[i], t0=t0[i], x0=x0[i])
snobject.setCoords(ra=raDeg[i], dec=decDeg[i])
snobject.mwEBVfromMaps()
# Calculate fluxes
vals[i, :6] = snobject.catsimManyBandFluxes(
time=self.mjdobs,
bandpassDict=self.lsstBandpassDict,
observedBandPassInd=None)
# Calculate magnitudes
vals[i, 6:12] = snobject.catsimManyBandMags(
time=self.mjdobs,
bandpassDict=self.lsstBandpassDict,
observedBandPassInd=None)
vals[i, 12:18] = snobject.catsimManyBandADUs(
time=self.mjdobs,
bandpassDict=self.lsstBandpassDict,
photParams=self.photometricparameters)
vals[i, 18] = snobject.ebvofMW
return (vals[:, 0], vals[:, 1], vals[:, 2], vals[:, 3], vals[:, 4],
vals[:, 5], vals[:, 6], vals[:, 7], vals[:, 8], vals[:, 9],
vals[:, 10], vals[:, 11], vals[:, 12], vals[:, 13],
vals[:, 14], vals[:, 15], vals[:, 16], vals[:, 17], vals[:,
18])
def get_snfluxes(self):
c, x1, x0, t0, _z, ra, dec = self.column_by_name('c'),\
self.column_by_name('x1'),\
self.column_by_name('x0'),\
self.column_by_name('t0'),\
self.column_by_name('redshift'),\
self.column_by_name('raJ2000'),\
self.column_by_name('decJ2000')
raDeg = np.degrees(ra)
decDeg = np.degrees(dec)
snobject = SNObject()
# Initialize return array
vals = np.zeros(shape=(self.numobjs, 19))
for i, _ in enumerate(vals):
snobject.set(z=_z[i], c=c[i], x1=x1[i], t0=t0[i], x0=x0[i])
snobject.setCoords(ra=raDeg[i], dec=decDeg[i])
snobject.mwEBVfromMaps()
# Calculate fluxes
vals[i, :6] = snobject.catsimManyBandFluxes(time=self.mjdobs,
bandpassDict=self.lsstBandpassDict,
observedBandPassInd=None)
# Calculate magnitudes
vals[i, 6:12] = snobject.catsimManyBandMags(time=self.mjdobs,
bandpassDict=self.lsstBandpassDict,
observedBandPassInd=None)
vals[i, 12:18] = snobject.catsimManyBandADUs(time=self.mjdobs,
bandpassDict=self.lsstBandpassDict,
photParams=self.photometricparameters)
vals[i, 18] = snobject.ebvofMW
return (vals[:, 0], vals[:, 1], vals[:, 2], vals[:, 3],
vals[:, 4], vals[:, 5], vals[:, 6], vals[:, 7],
vals[:, 8], vals[:, 9], vals[:, 10], vals[:, 11],
vals[:, 12], vals[:, 13], vals[:, 14], vals[:, 15],
vals[:, 16], vals[:, 17], vals[:, 18])
def get_snbrightness(self):
"""
getters for brightness related parameters of sn
"""
if self._sn_object_cache is None or len(self._sn_object_cache) > 1000000:
self._sn_object_cache = {}
c, x1, x0, t0, _z, ra, dec = self.column_by_name('c'),\
self.column_by_name('x1'),\
self.column_by_name('x0'),\
self.column_by_name('t0'),\
self.column_by_name('redshift'),\
self.column_by_name('raJ2000'),\
self.column_by_name('decJ2000')
raDeg = np.degrees(ra)
decDeg = np.degrees(dec)
ebv = self.column_by_name('EBV')
id_list = self.column_by_name('snid')
bandname = self.obs_metadata.bandpass
if isinstance(bandname, list):
raise ValueError('bandname expected to be string, but is list\n')
bandpass = self.lsstBandpassDict[bandname]
# Initialize return array so that it contains the values you would get
# if you passed through a t0=self.badvalues supernova
vals = np.array([[0.0]*len(t0), [np.inf]*len(t0),
[np.nan]*len(t0), [np.inf]*len(t0),
[0.0]*len(t0)]).transpose()
for i in np.where(np.logical_and(np.isfinite(t0),
np.abs(self.mjdobs - t0) < self.maxTimeSNVisible))[0]:
if id_list[i] in self._sn_object_cache:
SNobject = self._sn_object_cache[id_list[i]]
else:
SNobject = SNObject()
SNobject.set(z=_z[i], c=c[i], x1=x1[i], t0=t0[i], x0=x0[i])
SNobject.setCoords(ra=raDeg[i], dec=decDeg[i])
SNobject.set_MWebv(ebv[i])
self._sn_object_cache[id_list[i]] = SNobject
if self.mjdobs <= SNobject.maxtime() and self.mjdobs >= SNobject.mintime():
# Calculate fluxes
fluxinMaggies = SNobject.catsimBandFlux(time=self.mjdobs,
bandpassobject=bandpass)
mag = SNobject.catsimBandMag(time=self.mjdobs,
fluxinMaggies=fluxinMaggies,
bandpassobject=bandpass)
vals[i, 0] = fluxinMaggies
vals[i, 1] = mag
flux_err = SNobject.catsimBandFluxError(time=self.mjdobs,
bandpassobject=bandpass,
m5=self.obs_metadata.m5[
bandname],
photParams=self.photometricparameters,
fluxinMaggies=fluxinMaggies,
magnitude=mag)
mag_err = SNobject.catsimBandMagError(time=self.mjdobs,
bandpassobject=bandpass,
m5=self.obs_metadata.m5[
bandname],
photParams=self.photometricparameters,
magnitude=mag)
sed = SNobject.SNObjectSED(time=self.mjdobs,
bandpass=self.lsstBandpassDict,
applyExtinction=True)
adu = sed.calcADU(bandpass, photParams=self.photometricparameters)
vals[i, 2] = flux_err
vals[i, 3] = mag_err
vals[i, 4] = adu
return (vals[:, 0], vals[:, 1], vals[:, 2], vals[:, 3], vals[:, 4])
class SNObject_tests(unittest.TestCase):
def setUp(self):
"""
Setup tests
SN_blank: A SNObject with no MW extinction
"""
from astropy.config import get_config_dir
mydir = get_config_dir()
print '==============================='
print '==============================='
print (mydir)
print '==============================='
print '==============================='
# A range of wavelengths in Ang
self.wave = np.arange(3000., 12000., 50.)
# Equivalent wavelenths in nm
self.wavenm = self.wave / 10.
# Time to be used as Peak
self.mjdobs = 571190
# Check that we can set up a SED
# with no extinction
self.SN_blank = SNObject()
self.SN_blank.setCoords(ra=30., dec=-60.)
self.SN_blank.set(z=0.96, t0=571181, x1=2.66, c=0.353, x0=1.796e-6)
self.SN_blank.set_MWebv(0.)
self.SN_extincted = SNObject(ra=30., dec=-60.)
self.SN_extincted.set(z=0.96, t0=571181, x1=2.66, c=0.353,
x0=1.796112e-06)
self.SNCosmoModel = self.SN_extincted.equivalentSNCosmoModel()
self.lsstBandPass = BandpassDict.loadTotalBandpassesFromFiles()
self.SNCosmoBP = sncosmo.Bandpass(wave=self.lsstBandPass['r'].wavelen,
trans=self.lsstBandPass['r'].sb,
wave_unit=astropy.units.Unit('nm'),
name='lsst_r')
def tearDown(self):
pass
def test_SNstatenotEmpty(self):
"""
Check that the state of SNObject, stored in self.SNstate has valid
entries for all keys and does not contain keys with None type Values.
"""
myDict = self.SN_extincted.SNstate
for key in myDict.keys():
assert myDict[key] is not None
def test_ComparebandFluxes2photUtils(self):
"""
The SNObject.catsimBandFlux computation uses the sims.photUtils.sed
band flux computation under the hood. This test makes sure that these
definitions are in sync
"""
snobject_r = self.SN_extincted.catsimBandFlux(
bandpassobject=self.lsstBandPass['r'],
time=self.mjdobs)
# `sims.photUtils.Sed`
sed = self.SN_extincted.SNObjectSED(time=self.mjdobs,
bandpass=self.lsstBandPass['r'])
sedflux = sed.calcFlux(bandpass=self.lsstBandPass['r'])
np.testing.assert_allclose(snobject_r, sedflux / 3631.0)
def test_CompareBandFluxes2SNCosmo(self):
"""
Compare the r band flux at a particular time computed in SNObject and
SNCosmo for MW-extincted SEDs. While the underlying sed is obtained
from SNCosmo the integration with the bandpass is an independent
calculation in SNCosmo and catsim
"""
times = self.mjdobs
catsim_r = self.SN_extincted.catsimBandFlux(
bandpassobject=self.lsstBandPass['r'],
time=times)
sncosmo_r = self.SNCosmoModel.bandflux(band=self.SNCosmoBP,
time=times, zpsys='ab',
zp=0.)
np.testing.assert_allclose(sncosmo_r, catsim_r)
def test_CompareBandMags2SNCosmo(self):
"""
Compare the r band flux at a particular time computed in SNObject and
SNCosmo for MW-extincted SEDs. Should work whenever the flux comparison
above works.
"""
times = self.mjdobs
catsim_r = self.SN_extincted.catsimBandMag(
bandpassobject=self.lsstBandPass['r'],
time=times)
sncosmo_r = self.SNCosmoModel.bandmag(band=self.SNCosmoBP,
time=times, magsys='ab')
np.testing.assert_allclose(sncosmo_r, catsim_r)
def test_CompareExtinctedSED2SNCosmo(self):
"""
Compare the extincted SEDS in SNCosmo and SNObject. Slightly more
non-trivial than comparing unextincted SEDS, as the extinction in
SNObject uses different code from SNCosmo. However, this is still
using the same values of MWEBV, rather than reading it off a map.
"""
SNObjectSED = self.SN_extincted.SNObjectSED(time=self.mjdobs,
wavelen=self.wavenm)
SNCosmoSED = self.SNCosmoModel.flux(time=self.mjdobs, wave=self.wave) \
* 10.
np.testing.assert_allclose(SNObjectSED.flambda, SNCosmoSED,
rtol=1.0e-7)
def test_CompareUnextinctedSED2SNCosmo(self):
"""
Compares the unextincted flux Densities in SNCosmo and SNObject. This
is mereley a sanity check as SNObject uses SNCosmo under the hood.
"""
SNCosmoFluxDensity = self.SN_blank.flux(wave=self.wave,
time=self.mjdobs) * 10.
unextincted_sed = self.SN_blank.SNObjectSED(time=self.mjdobs,
wavelen=self.wavenm)
SNObjectFluxDensity = unextincted_sed.flambda
np.testing.assert_allclose(SNCosmoFluxDensity, SNObjectFluxDensity,
rtol=1.0e-7)
def get_snbrightness(self):
"""
getters for brightness related parameters of sn
"""
if self._sn_object_cache is None or len(
self._sn_object_cache) > 1000000:
self._sn_object_cache = {}
c, x1, x0, t0, _z, ra, dec = self.column_by_name('c'),\
self.column_by_name('x1'),\
self.column_by_name('x0'),\
self.column_by_name('t0'),\
self.column_by_name('redshift'),\
self.column_by_name('raJ2000'),\
self.column_by_name('decJ2000')
raDeg = np.degrees(ra)
decDeg = np.degrees(dec)
ebv = self.column_by_name('EBV')
id_list = self.column_by_name('snid')
bandname = self.obs_metadata.bandpass
if isinstance(bandname, list):
raise ValueError('bandname expected to be string, but is list\n')
bandpass = self.lsstBandpassDict[bandname]
# Initialize return array so that it contains the values you would get
# if you passed through a t0=self.badvalues supernova
vals = np.array([[0.0] * len(t0), [np.inf] * len(t0),
[np.nan] * len(t0), [np.inf] * len(t0),
[0.0] * len(t0)]).transpose()
for i in np.where(
np.logical_and(
np.isfinite(t0),
np.abs(self.mjdobs - t0) < self.maxTimeSNVisible))[0]:
if id_list[i] in self._sn_object_cache:
SNobject = self._sn_object_cache[id_list[i]]
else:
SNobject = SNObject()
SNobject.set(z=_z[i], c=c[i], x1=x1[i], t0=t0[i], x0=x0[i])
SNobject.setCoords(ra=raDeg[i], dec=decDeg[i])
SNobject.set_MWebv(ebv[i])
self._sn_object_cache[id_list[i]] = SNobject
if self.mjdobs <= SNobject.maxtime(
) and self.mjdobs >= SNobject.mintime():
# Calculate fluxes
fluxinMaggies = SNobject.catsimBandFlux(
time=self.mjdobs, bandpassobject=bandpass)
mag = SNobject.catsimBandMag(time=self.mjdobs,
fluxinMaggies=fluxinMaggies,
bandpassobject=bandpass)
vals[i, 0] = fluxinMaggies
vals[i, 1] = mag
flux_err = SNobject.catsimBandFluxError(
time=self.mjdobs,
bandpassobject=bandpass,
m5=self.obs_metadata.m5[bandname],
photParams=self.photometricparameters,
fluxinMaggies=fluxinMaggies,
magnitude=mag)
mag_err = SNobject.catsimBandMagError(
time=self.mjdobs,
bandpassobject=bandpass,
m5=self.obs_metadata.m5[bandname],
photParams=self.photometricparameters,
magnitude=mag)
sed = SNobject.SNObjectSED(time=self.mjdobs,
bandpass=self.lsstBandpassDict,
applyExtinction=True)
adu = sed.calcADU(bandpass,
photParams=self.photometricparameters)
vals[i, 2] = flux_err
vals[i, 3] = mag_err
vals[i, 4] = adu
return (vals[:, 0], vals[:, 1], vals[:, 2], vals[:, 3], vals[:, 4])
class SNObject_tests(unittest.TestCase):
@classmethod
def tearDownClass(cls):
sims_clean_up()
def setUp(self):
"""
Setup tests
SN_blank: A SNObject with no MW extinction
"""
mydir = get_config_dir()
print('===============================')
print('===============================')
print (mydir)
print('===============================')
print('===============================')
# A range of wavelengths in Ang
self.wave = np.arange(3000., 12000., 50.)
# Equivalent wavelenths in nm
self.wavenm = self.wave / 10.
# Time to be used as Peak
self.mjdobs = 571190
# Check that we can set up a SED
# with no extinction
self.SN_blank = SNObject()
self.SN_blank.setCoords(ra=30., dec=-60.)
self.SN_blank.set(z=0.96, t0=571181, x1=2.66, c=0.353, x0=1.796e-6)
self.SN_blank.set_MWebv(0.)
self.SN_extincted = SNObject(ra=30., dec=-60.)
self.SN_extincted.set(z=0.96, t0=571181, x1=2.66, c=0.353,
x0=1.796112e-06)
self.SNCosmoModel = self.SN_extincted.equivalentSNCosmoModel()
self.rectify_photParams = PhotometricParameters()
self.lsstBandPass = BandpassDict.loadTotalBandpassesFromFiles()
self.SNCosmoBP = sncosmo.Bandpass(wave=self.lsstBandPass['r'].wavelen,
trans=self.lsstBandPass['r'].sb,
wave_unit=astropy.units.Unit('nm'),
name='lsst_r')
def tearDown(self):
del self.SNCosmoBP
del self.SN_blank
del self.SN_extincted
def test_SNstatenotEmpty(self):
"""
Check that the state of SNObject, stored in self.SNstate has valid
entries for all keys and does not contain keys with None type Values.
"""
myDict = self.SN_extincted.SNstate
for key in myDict:
assert myDict[key] is not None
def test_attributeDefaults(self):
"""
Check the defaults and the setter properties for rectifySED and
modelOutSideRange
"""
snobj = SNObject(ra=30., dec=-60., source='salt2')
self.assertEqual(snobj.rectifySED, True)
self.assertEqual(snobj.modelOutSideTemporalRange, 'zero')
snobj.rectifySED = False
self.assertFalse(snobj.rectifySED, False)
self.assertEqual(snobj.modelOutSideTemporalRange, 'zero')
def test_raisingerror_forunimplementedmodelOutSideRange(self):
"""
check that correct error is raised if the user tries to assign an
un-implemented model value to
`sims.catUtils.supernovae.SNObject.modelOutSideTemporalRange`
"""
snobj = SNObject(ra=30., dec=-60., source='salt2')
assert snobj.modelOutSideTemporalRange == 'zero'
with self.assertRaises(ValueError) as context:
snobj.modelOutSideTemporalRange = 'False'
self.assertEqual('Model not implemented, defaulting to zero method\n',
context.exception.args[0])
def test_rectifiedSED(self):
"""
Check for an extreme case that the SN seds are being rectified. This is
done by setting up an extreme case where there will be negative seds, and
checking that this is indeed the case, and checking that they are not
negative if rectified.
"""
snobj = SNObject(ra=30., dec=-60., source='salt2')
snobj.set(z=0.96, t0=self.mjdobs, x1=-3., x0=1.8e-6)
snobj.rectifySED = False
times = np.arange(self.mjdobs - 50., self.mjdobs + 150., 1.)
badTimes = []
for time in times:
sed = snobj.SNObjectSED(time=time,
bandpass=self.lsstBandPass['r'])
if any(sed.flambda < 0.):
badTimes.append(time)
# Check that there are negative SEDs
assert(len(badTimes) > 0)
snobj.rectifySED = True
for time in badTimes:
sed = snobj.SNObjectSED(time=time,
bandpass=self.lsstBandPass['r'])
self.assertGreaterEqual(sed.calcADU(bandpass=self.lsstBandPass['r'],
photParams=self.rectify_photParams), 0.)
self.assertFalse(any(sed.flambda < 0.))
def test_ComparebandFluxes2photUtils(self):
"""
The SNObject.catsimBandFlux computation uses the sims.photUtils.sed
band flux computation under the hood. This test makes sure that these
definitions are in sync
"""
snobject_r = self.SN_extincted.catsimBandFlux(
bandpassobject=self.lsstBandPass['r'],
time=self.mjdobs)
# `sims.photUtils.Sed`
sed = self.SN_extincted.SNObjectSED(time=self.mjdobs,
bandpass=self.lsstBandPass['r'])
sedflux = sed.calcFlux(bandpass=self.lsstBandPass['r'])
np.testing.assert_allclose(snobject_r, sedflux / 3631.0)
def test_CompareBandFluxes2SNCosmo(self):
"""
Compare the r band flux at a particular time computed in SNObject and
SNCosmo for MW-extincted SEDs. While the underlying sed is obtained
from SNCosmo the integration with the bandpass is an independent
calculation in SNCosmo and catsim
"""
times = self.mjdobs
catsim_r = self.SN_extincted.catsimBandFlux(
bandpassobject=self.lsstBandPass['r'],
time=times)
sncosmo_r = self.SNCosmoModel.bandflux(band=self.SNCosmoBP,
time=times, zpsys='ab',
zp=0.)
np.testing.assert_allclose(sncosmo_r, catsim_r)
def test_CompareBandMags2SNCosmo(self):
"""
Compare the r band flux at a particular time computed in SNObject and
SNCosmo for MW-extincted SEDs. Should work whenever the flux comparison
above works.
"""
times = self.mjdobs
catsim_r = self.SN_extincted.catsimBandMag(
bandpassobject=self.lsstBandPass['r'],
time=times)
sncosmo_r = self.SNCosmoModel.bandmag(band=self.SNCosmoBP,
time=times, magsys='ab')
np.testing.assert_allclose(sncosmo_r, catsim_r)
def test_CompareExtinctedSED2SNCosmo(self):
"""
Compare the extincted SEDS in SNCosmo and SNObject. Slightly more
non-trivial than comparing unextincted SEDS, as the extinction in
SNObject uses different code from SNCosmo. However, this is still
using the same values of MWEBV, rather than reading it off a map.
"""
SNObjectSED = self.SN_extincted.SNObjectSED(time=self.mjdobs,
wavelen=self.wavenm)
SNCosmoSED = self.SNCosmoModel.flux(time=self.mjdobs, wave=self.wave) \
* 10.
np.testing.assert_allclose(SNObjectSED.flambda, SNCosmoSED,
rtol=1.0e-7)
def test_CompareUnextinctedSED2SNCosmo(self):
"""
Compares the unextincted flux Densities in SNCosmo and SNObject. This
is mereley a sanity check as SNObject uses SNCosmo under the hood.
"""
SNCosmoFluxDensity = self.SN_blank.flux(wave=self.wave,
time=self.mjdobs) * 10.
unextincted_sed = self.SN_blank.SNObjectSED(time=self.mjdobs,
wavelen=self.wavenm)
SNObjectFluxDensity = unextincted_sed.flambda
np.testing.assert_allclose(SNCosmoFluxDensity, SNObjectFluxDensity,
rtol=1.0e-7)
def test_redshift(self):
"""
test that the redshift method works as expected by checking that
if we redshift a SN from its original redshift orig_z to new_z where
new_z is smaller (larger) than orig_z:
- 1. x0 increases (decreases)
- 2. source peak absolute magnitude in BesselB band stays the same
"""
from astropy.cosmology import FlatLambdaCDM
cosmo = FlatLambdaCDM(H0=70., Om0=0.3)
orig_z = self.SN_extincted.get('z')
orig_x0 = self.SN_extincted.get('x0')
peakabsMag = self.SN_extincted.source_peakabsmag('BessellB', 'AB', cosmo=cosmo)
lowz = orig_z * 0.5
highz = orig_z * 2.0
# Test Case for lower redshift
self.SN_extincted.redshift(z=lowz, cosmo=cosmo)
low_x0 = self.SN_extincted.get('x0')
lowPeakAbsMag = self.SN_extincted.source_peakabsmag('BessellB', 'AB', cosmo=cosmo)
# Test 1.
self.assertGreater(low_x0, orig_x0)
# Test 2.
self.assertAlmostEqual(peakabsMag, lowPeakAbsMag, places=14)
# Test Case for higher redshift
self.SN_extincted.redshift(z=highz, cosmo=cosmo)
high_x0 = self.SN_extincted.get('x0')
HiPeakAbsMag = self.SN_extincted.source_peakabsmag('BessellB', 'AB', cosmo=cosmo)
# Test 1.
self.assertLess(high_x0, orig_x0)
# Test 2.
self.assertAlmostEqual(peakabsMag, HiPeakAbsMag, places=14)
def test_bandFluxErrorWorks(self):
"""
test that bandflux errors work even if the flux is negative
"""
times = self.mjdobs
e = self.SN_extincted.catsimBandFluxError(times,
self.lsstBandPass['r'],
m5=24.5, fluxinMaggies=-1.0)
assert isinstance(e, np.float)
print(e)
assert not(np.isinf(e) or np.isnan(e))
def validate_sne(cat_dir, obsid, fov_deg=2.1,
scatter_file=None, vanishing_file=None):
"""
Parameters
----------
cat_dir is the parent dir of $obsid
obsid is the obsHistID of the pointing (an int)
fov_deg is the radius of the field of view in degrees
"""
project_dir = os.path.join('/global/projecta/projectdirs',
'lsst/groups/SSim/DC2/cosmoDC2_v1.1.4')
sne_db_name = os.path.join(project_dir, 'sne_cosmoDC2_v1.1.4_MS_DDF.db')
if not os.path.isfile(sne_db_name):
raise RuntimeError("\n%s\nis not a file" % sne_db_name)
instcat_dir = os.path.join(cat_dir, '%.8d' % obsid)
if not os.path.isdir(instcat_dir):
raise RuntimeError("\n%s\nis not a dir" % instcat_dir)
sne_name = os.path.join(instcat_dir, 'sne_cat_%d.txt.gz' % obsid)
if not os.path.isfile(sne_name):
raise RuntimeError("\n%s\nis not a file" % sne_name)
phosim_name = os.path.join(instcat_dir, 'phosim_cat_%d.txt' % obsid)
if not os.path.isfile(phosim_name):
raise RuntimeError("\n%s\nis not a file" % phosim_name)
sed_dir = os.path.join(instcat_dir, "Dynamic")
if not os.path.isdir(sed_dir):
raise RuntimeError("\n%s\nis not a dir" % sed_dir)
opsim_db = os.path.join("/global/projecta/projectdirs",
"lsst/groups/SSim/DC2",
"minion_1016_desc_dithered_v4_sfd.db")
if not os.path.isfile(opsim_db):
raise RuntimeError("\n%s\nis not a file" % opsim_db)
band_from_int = 'ugrizy'
bandpass = None
with open(phosim_name, 'r') as in_file:
for line in in_file:
params = line.strip().split()
if params[0] == 'filter':
bandpass = band_from_int[int(params[1])]
break
if bandpass is None:
raise RuntimeError("Failed to read in bandpass")
bp_dict = photUtils.BandpassDict.loadTotalBandpassesFromFiles()
with sqlite3.connect(opsim_db) as conn:
c = conn.cursor()
r = c.execute("SELECT descDitheredRA, descDitheredDec, expMJD FROM Summary "
"WHERE obsHistID==%d" % obsid).fetchall()
pointing_ra = np.degrees(r[0][0])
pointing_dec = np.degrees(r[0][1])
expmjd = float(r[0][2])
with sqlite3.connect(sne_db_name) as conn:
c = conn.cursor()
query = "SELECT snid_in, snra_in, sndec_in, "
query += "c_in, mB, t0_in, x0_in, x1_in, z_in "
query += "FROM sne_params WHERE ("
where_clause = None
half_space = htm.halfSpaceFromRaDec(pointing_ra, pointing_dec, fov_deg)
bounds = half_space.findAllTrixels(6)
for bound in bounds:
if where_clause is not None:
where_clause += " OR ("
else:
where_clause = "("
if bound[0] == bound[1]:
where_clause += "htmid_level_6==%d" % bound[0]
else:
where_clause += "htmid_level_6>=%d AND htmid_level_6<=%d" % (bound[0],bound[1])
where_clause += ")"
query += where_clause+")"
sn_params = c.execute(query).fetchall()
sn_ra = np.array([sn[1] for sn in sn_params])
sn_dec = np.array([sn[2] for sn in sn_params])
sn_d = angularSeparation(pointing_ra, pointing_dec,
sn_ra, sn_dec)
valid = np.where(sn_d<=fov_deg)
sn_ra_dec = {}
sn_param_dict = {}
for i_sn in valid[0]:
sn = sn_params[i_sn]
sn_param_dict[sn[0]] = sn[3:]
sn_ra_dec[sn[0]] = sn[1:3]
sne_in_instcat = set()
d_mag_max = -1.0
with gzip.open(sne_name, 'rb') as sne_cat_file:
for sne_line in sne_cat_file:
instcat_params = sne_line.strip().split(b' ')
sne_id = instcat_params[1].decode('utf-8')
if sne_id not in sn_param_dict:
try:
sne_id_int = int(sne_id)
assert sne_id_int<1.5e10
except (ValueError, AssertionError):
raise RuntimeError("\n%s\nnot in SNe db" % sne_id)
sne_in_instcat.add(sne_id)
control_params = sn_param_dict[sne_id]
sed_name = os.path.join(instcat_dir, instcat_params[5].decode('utf-8'))
if not os.path.isfile(sed_name):
raise RuntimeError("\n%s\nis not a file" % sed_name)
sed = photUtils.Sed()
sed.readSED_flambda(sed_name, cache_sed=False)
fnorm = photUtils.getImsimFluxNorm(sed, float(instcat_params[4]))
sed.multiplyFluxNorm(fnorm)
sed.redshiftSED(float(instcat_params[6]), dimming=True)
a_x, b_x = sed.setupCCM_ab()
A_v = float(instcat_params[15])
R_v = float(instcat_params[16])
EBV = A_v/R_v
sed.addDust(a_x, b_x, A_v=A_v, R_v=R_v)
sn_object = SNObject()
sn_object.set_MWebv(EBV)
sn_object.set(c=control_params[0], x1=control_params[4],
x0=control_params[3], t0=control_params[2],
z=control_params[5])
sn_mag = sn_object.catsimBandMag(bp_dict[bandpass], expmjd)
instcat_flux = sed.calcFlux(bp_dict[bandpass])
instcat_mag = sed.magFromFlux(instcat_flux)
d_mag = (sn_mag-instcat_mag)
if not np.isfinite(d_mag):
if np.isfinite(sn_mag) or np.isfinite(instcat_mag):
msg = '%s\ngave magnitudes %e %e (diff %e)' % (sne_id,
sn_mag,
instcat_mag,
d_mag)
print(msg)
if scatter_file is not None:
scatter_file.write("%e %e %e\n" % (sn_mag, instcat_mag, d_mag))
d_mag = np.abs(d_mag)
if d_mag>d_mag_max:
d_mag_max = d_mag
#print('dmag %e -- %e (%e)' %
# (d_mag, instcat_mag,
# control_params[5]-float(instcat_params[6])))
msg = '\n%s\n' % sne_name
ct_missing = 0
for sn_id in sn_param_dict:
if sn_id in sne_in_instcat:
continue
control_params = sn_param_dict[sn_id]
sn_object = SNObject()
sn_object.set_MWebv(0.0)
cc = control_params[0]
x1 = control_params[4]
x0 = control_params[3]
t0 = control_params[2]
zz = control_params[5]
sn_object.set(c=cc, x1=x1, x0=x0, t0=t0, z=zz)
sn_mag = sn_object.catsimBandMag(bp_dict[bandpass], expmjd)
if vanishing_file is not None and np.isfinite(sn_mag):
vanishing_file.write('%d %s %s %e ' % (obsid, bandpass, sn_id, sn_mag))
vanishing_file.write('%e %e %e %.4f %e %.4f %e\n' %
(cc,x0,x1,t0,zz,expmjd,expmjd-t0))
def _light_curves_from_query(self, cat_dict, query_result, grp, lc_per_field=None):
t_dict = {}
gamma_dict = {}
m5_dict = {}
t_min = None
t_max = None
for bp_name in cat_dict:
self.lsstBandpassDict[bp_name].sbTophi()
# generate a 2-D numpy array containing MJDs, m5, and photometric gamma values
# for each observation in the given bandpass
raw_array = np.array([[obs.mjd.TAI, obs.m5[bp_name],
calcGamma(self.lsstBandpassDict[bp_name],
obs.m5[obs.bandpass],
self.phot_params)]
for obs in grp if obs.bandpass == bp_name]).transpose()
if len(raw_array) > 0:
t_dict[bp_name] = raw_array[0]
m5_dict[bp_name] = raw_array[1]
gamma_dict[bp_name] = raw_array[2]
local_t_min = t_dict[bp_name].min()
local_t_max = t_dict[bp_name].max()
if t_min is None or local_t_min < t_min:
t_min = local_t_min
if t_max is None or local_t_max > t_max:
t_max = local_t_max
snobj = SNObject()
cat = cat_dict[list(cat_dict.keys())[0]] # does not need to be associated with a bandpass
dummy_sed = Sed()
n_actual_sn = 0 # how many SN have we actually delivered?
for chunk in query_result:
if lc_per_field is not None and n_actual_sn >= lc_per_field:
break
t_start_chunk = time.time()
for sn in cat.iter_catalog(query_cache=[chunk]):
sn_rng = self.sn_universe.getSN_rng(sn[1])
sn_t0 = self.sn_universe.drawFromT0Dist(sn_rng)
if sn[5] <= self.z_cutoff and np.isfinite(sn_t0) and \
sn_t0 < t_max + cat.maxTimeSNVisible and \
sn_t0 > t_min - cat.maxTimeSNVisible:
sn_c = self.sn_universe.drawFromcDist(sn_rng)
sn_x1 = self.sn_universe.drawFromx1Dist(sn_rng)
sn_x0 = self.sn_universe.drawFromX0Dist(sn_rng, sn_x1, sn_c, sn[4])
snobj.set(t0=sn_t0, c=sn_c, x1=sn_x1, x0=sn_x0, z=sn[5])
for bp_name in t_dict:
t_list = t_dict[bp_name]
m5_list = m5_dict[bp_name]
gamma_list = gamma_dict[bp_name]
bandpass = self.lsstBandpassDict[bp_name]
if len(t_list) == 0:
continue
if snobj.maxtime() >= t_list[0] and snobj.mintime() <= t_list[-1]:
active_dexes = np.where(np.logical_and(t_list >= snobj.mintime(),
t_list <= snobj.maxtime()))
t_active = t_list[active_dexes]
m5_active = m5_list[active_dexes]
gamma_active = gamma_list[active_dexes]
if len(t_active) > 0:
wave_ang = bandpass.wavelen*10.0
mask = np.logical_and(wave_ang > snobj.minwave(),
wave_ang < snobj.maxwave())
wave_ang = wave_ang[mask]
snobj.set(mwebv=sn[6])
sn_ff_buffer = snobj.flux(time=t_active, wave=wave_ang)*10.0
flambda_grid = np.zeros((len(t_active), len(bandpass.wavelen)))
for ff, ff_sn in zip(flambda_grid, sn_ff_buffer):
ff[mask] = np.where(ff_sn > 0.0, ff_sn, 0.0)
fnu_grid = flambda_grid*bandpass.wavelen* \
bandpass.wavelen*dummy_sed._physParams.nm2m* \
dummy_sed._physParams.ergsetc2jansky/dummy_sed._physParams.lightspeed
flux_list = \
(fnu_grid*bandpass.phi).sum(axis=1)*(bandpass.wavelen[1]-bandpass.wavelen[0])
acceptable = np.where(flux_list>0.0)
flux_error_list = flux_list[acceptable]/ \
calcSNR_m5(dummy_sed.magFromFlux(flux_list[acceptable]),
bandpass,
m5_active[acceptable], self.phot_params,
gamma=gamma_active[acceptable])
if len(acceptable) > 0:
n_actual_sn += 1
if lc_per_field is not None and n_actual_sn > lc_per_field:
break
if sn[0] not in self.truth_dict:
self.truth_dict[sn[0]] = {}
self.truth_dict[sn[0]]['t0'] = sn_t0
self.truth_dict[sn[0]]['x1'] = sn_x1
self.truth_dict[sn[0]]['x0'] = sn_x0
self.truth_dict[sn[0]]['c'] = sn_c
self.truth_dict[sn[0]]['z'] = sn[5]
self.truth_dict[sn[0]]['E(B-V)'] = sn[6]
if sn[0] not in self.mjd_dict:
self.mjd_dict[sn[0]] = {}
self.bright_dict[sn[0]] = {}
self.sig_dict[sn[0]] = {}
if bp_name not in self.mjd_dict[sn[0]]:
self.mjd_dict[sn[0]][bp_name] = []
self.bright_dict[sn[0]][bp_name] = []
self.sig_dict[sn[0]][bp_name] = []
for tt, ff, ee in zip(t_active[acceptable], flux_list[acceptable],
flux_error_list[0]):
self.mjd_dict[sn[0]][bp_name].append(tt)
self.bright_dict[sn[0]][bp_name].append(ff/3631.0)
self.sig_dict[sn[0]][bp_name].append(ee/3631.0)
print("chunk of ", len(chunk), " took ", time.time()-t_start_chunk)
def main(ramax=58, ramin=56, decmin=-32, decmax=-31, t0=59215, tm=61406):
query = query_tmpl.format(ramin, ramax, decmin, decmax)
sntab = pd.read_sql_query(query, conn)
#sntab.to_csv('./catalogs+tables/sn_cat_rectangle.csv')
#if os.path.isfile('./catalogs+tables/full_t_visits_from_minion.csv'):
# visitab = pd.read_csv('./catalogs+tables/full_t_visits_from_minion.csv')
#else:
res = ObsMetaData.getObservationMetaData(boundLength=2,
boundType='circle',
fieldRA=(ramin - 3, ramax + 3),
fieldDec=(decmin - 3, decmax + 3),
expMJD=(t0, tm))
parsed = [Odict(obsmd.summary['OpsimMetaData']) for obsmd in res]
for obsmd, summ in zip(res, parsed):
ditherRa = np.rad2deg(summ['descDitheredRA'])
ditherDec = np.rad2deg(summ['descDitheredDec'])
ditherRot = np.rad2deg(summ['descDitheredRotTelPos'])
summ['descDitheredRotSkyPos'] = getRotSkyPos(ditherRa, ditherDec,
obsmd, ditherRot)
df = pd.DataFrame(parsed)
df = df[df['filter'].isin(('g', 'r', 'i', 'z'))]
X = df[[
'obsHistID', 'filter', 'FWHMeff', 'descDitheredRA', 'descDitheredDec',
'descDitheredRotTelPos', 'airmass', 'fiveSigmaDepth', 'expMJD',
'descDitheredRotSkyPos', 'fieldRA', 'fieldDec', 'rotSkyPos',
'rotTelPos'
]].copy()
X.descDitheredRA = np.rad2deg(X.descDitheredRA)
X.descDitheredDec = np.rad2deg(X.descDitheredDec)
X.descDitheredRotTelPos = np.rad2deg(X.descDitheredRotTelPos)
#X.descDitheredRotSkyPos = np.rad2deg(X.descDitheredRotSkyPos) already in deg
X.fieldRA = np.rad2deg(X.fieldRA)
X.fieldDec = np.rad2deg(X.fieldDec)
X.rotTelPos = np.rad2deg(X.rotTelPos)
X.rotSkyPos = np.rad2deg(X.rotSkyPos)
X['d1'] = angularSeparation(ramin, decmax, X.descDitheredRA.values,
X.descDitheredDec.values)
X['d2'] = angularSeparation(ramin, decmin, X.descDitheredRA.values,
X.descDitheredDec.values)
X['d3'] = angularSeparation(ramax, decmax, X.descDitheredRA.values,
X.descDitheredDec.values)
X['d4'] = angularSeparation(ramax, decmin, X.descDitheredRA.values,
X.descDitheredDec.values)
visitab = X.query('d1 < 1.75 | d2 < 1.75 | d3 < 1.75 |d4 < 1.75')
del (X)
del (df)
visitab.to_csv('./catalogs+tables/full_t_visits_from_minion.csv')
# setting the observation telescope status
boresight = []
orientation = []
wcs_list = []
for avisit in visitab.itertuples():
bsight = geom.SpherePoint(avisit.descDitheredRA * geom.degrees,
avisit.descDitheredDec * geom.degrees)
orient = (90 - avisit.descDitheredRotSkyPos) * geom.degrees
wcs_list.append([
makeSkyWcs(t,
orient,
flipX=False,
boresight=bsight,
projection='TAN') for t in trans
])
orientation.append(orient)
boresight.append(bsight)
times = visitab['expMJD']
bands = visitab['filter']
depths = visitab['fiveSigmaDepth']
#colnames = ['mjd', 'filter']
data_cols = {'mjd': times, 'filter': bands, 'visitn': visitab['obsHistID']}
n_observ = []
n_trueobserv = []
for asn in sntab.itertuples():
sn_mod = SNObject(ra=asn.snra_in, dec=asn.sndec_in)
sn_mod.set(z=asn.z_in,
t0=asn.t0_in,
x1=asn.x1_in,
c=asn.c_in,
x0=asn.x0_in)
sn_skyp = afwGeom.SpherePoint(asn.snra_in, asn.sndec_in,
afwGeom.degrees)
size = len(times)
sn_flxs = np.zeros(size)
sn_mags = np.zeros(size)
sn_flxe = np.zeros(size)
sn_mage = np.zeros(size)
sn_obsrvd = []
sn_observable = []
ii = 0
for mjd, filt, wcsl, m5 in zip(times, bands, wcs_list, depths):
flux = sn_mod.catsimBandFlux(mjd, LSST_BPass[filt])
mag = sn_mod.catsimBandMag(LSST_BPass[filt], mjd, flux)
flux_er = sn_mod.catsimBandFluxError(mjd, LSST_BPass[filt], m5,
flux)
mag_er = sn_mod.catsimBandMagError(mjd,
LSST_BPass[filt],
m5,
magnitude=mag)
# checking sensors containing this object
contain = [box.contains(afwGeom.Point2I(wcs.skyToPixel(sn_skyp))) \
for box, wcs in zip(boxes, wcsl)]
observed = np.sum(contain) > 0
observable = observed & (flux > 0.0
) #(mag + mag_er < 27.0) & (mag_er < 0.5)
# if observed:
# print('Overlaps ccd', names[np.where(contain)[0][0]])
sn_observable.append(observable)
sn_obsrvd.append(observed)
sn_flxs[ii] = flux # done
sn_mags[ii] = mag
sn_flxe[ii] = flux_er
sn_mage[ii] = mag_er
ii += 1
data_cols[asn.snid_in + '_observable'] = sn_observable
data_cols[asn.snid_in + '_observed'] = sn_obsrvd
data_cols[asn.snid_in + '_flux'] = sn_flxs
data_cols[asn.snid_in + '_fluxErr'] = sn_flxe
data_cols[asn.snid_in + '_mag'] = sn_mags
data_cols[asn.snid_in + '_magErr'] = sn_mage
n_observ.append(np.sum(sn_obsrvd))
n_trueobserv.append(np.sum(sn_observable))
sntab['Nobserv'] = n_observ
sntab['N_trueobserv'] = n_trueobserv
lightcurves = pd.DataFrame(data_cols)
dest_lc = './lightcurves/lightcurves_cat_rect_{}_{}_{}_{}.csv'
lightcurves.to_csv(dest_lc.format(ramax, ramin, decmax, decmin))
dest_snfile = './catalogs+tables/supernovae_cat_rect_{}_{}_{}_{}.csv'
sntab.to_csv(dest_snfile.format(ramax, ramin, decmax, decmin))
print("""Stored the lightcurves in {},
the SN catalog in {}""".format(
dest_lc.format(ramax, ramin, decmax, decmin),
dest_snfile.format(ramax, ramin, decmax, decmin)))
return
class SNSynthPhotFactory:
"""
Factory class to return the SyntheticPhotometry objects for a SN Ia
as a function of time. This uses the 'salt2-extended' model in
sncosmo as implemented in sims_catUtils.
"""
lsst_bp_dict = BandpassDict.loadTotalBandpassesFromFiles()
def __init__(self, z=0, t0=0, x0=1, x1=0, c=0, snra=0, sndec=0):
"""
Parameters
----------
z: float [0]
Redshift of the SNIa object to pass to sncosmo.
t0: float [0]
Time in mjd of phase=0, corresponding to the B-band
maximum.
x0: float [1]
Normalization factor for the lightcurves.
x1: float [0]
Empirical parameter controlling the stretch in time of the
light curves
c: float [0]
Empirical parameter controlling the colors.
snra: float [0]
RA in degrees of the SNIa.
sndec: float [0]
Dec in degrees of the SNIa.
"""
self.sn_obj = SNObject(snra, sndec)
self.sn_obj.set(z=z,
t0=t0,
x0=x0,
x1=x1,
c=c,
hostebv=0,
hostr_v=3.1,
mwebv=0,
mwr_v=3.1)
self.bp_dict = self.lsst_bp_dict
def set_bp_dict(self, bp_dict):
"""
Set the bandpass dictionary.
Parameters
----------
bp_dict: lsst.sims.photUtils.BandpassDict
Dictionary containing the bandpasses. If None, the standard
LSST total bandpasses will be used.
"""
self.bp_dict = bp_dict
def create(self, mjd):
"""
Return a SyntheticPhotometry object for the specified time in MJD.
Parameters
----------
mjd: float
Observation time in MJD.
Returns
-------
desc.sims_truthcatalog.SyntheticPhotometry
"""
# Create the Sed object. Milky Way extinction will be
# below, so set applyExtinction=False.
sed = self.sn_obj.SNObjectSED(mjd,
bandpass=self.bp_dict,
applyExtinction=False)
# The redshift was applied to the model SED computed by
# sncosmo in the __init__ function, so set redshift=0 here.
synth_phot = SyntheticPhotometry.create_from_sed(sed, redshift=0)
synth_phot.add_MW_dust(*np.degrees(self.sn_obj.skycoord).flatten())
return synth_phot
def __getattr__(self, attr):
# Pass any attribute access requests to the SNObject instance.
return getattr(self.sn_obj, attr)
