def testNoSystematicUncertainty(self):
"""
Test that systematic uncertainty is handled correctly when set to None.
"""
m5 = [23.5, 24.3, 22.1, 20.0, 19.5, 21.7]
photParams = PhotometricParameters(sigmaSys=0.0)
obs_metadata = ObservationMetaData(
unrefractedRA=23.0, unrefractedDec=45.0, m5=m5, bandpassName=self.filterNameList
)
magnitudes = []
for bp in self.bpList:
mag = self.starSED.calcMag(bp)
magnitudes.append(mag)
skySedList = []
for bp, hardware, filterName in zip(self.bpList, self.hardwareList, self.filterNameList):
skyDummy = Sed()
skyDummy.readSED_flambda(os.path.join(lsst.utils.getPackageDir("throughputs"), "baseline", "darksky.dat"))
normalizedSkyDummy = setM5(
obs_metadata.m5[filterName],
skyDummy,
bp,
hardware,
seeing=LSSTdefaults().seeing(filterName),
photParams=photParams,
)
skySedList.append(normalizedSkyDummy)
sigmaList = snr.calcMagError_m5(numpy.array(magnitudes), numpy.array(self.bpList), numpy.array(m5), photParams)
for i in range(len(self.bpList)):
snrat = snr.calcSNR_sed(
self.starSED,
self.bpList[i],
skySedList[i],
self.hardwareList[i],
seeing=LSSTdefaults().seeing(self.filterNameList[i]),
photParams=PhotometricParameters(),
)
testSNR, gamma = snr.calcSNR_m5(
numpy.array([magnitudes[i]]),
[self.bpList[i]],
numpy.array([m5[i]]),
photParams=PhotometricParameters(sigmaSys=0.0),
)
self.assertAlmostEqual(
snrat, testSNR[0], 10, msg="failed on calcSNR_m5 test %e != %e " % (snrat, testSNR[0])
)
control = snr.magErrorFromSNR(testSNR)
msg = "%e is not %e; failed" % (sigmaList[i], control)
self.assertAlmostEqual(sigmaList[i], control, 10, msg=msg)
def testSystematicUncertainty(self):
"""
Test that systematic uncertainty is added correctly.
"""
sigmaSys = 0.002
m5_list = [23.5, 24.3, 22.1, 20.0, 19.5, 21.7]
photParams = PhotometricParameters(sigmaSys=sigmaSys)
obs_metadata = ObservationMetaData(pointingRA=23.0,
pointingDec=45.0,
m5=m5_list,
bandpassName=self.filterNameList)
magnitude_list = []
for bp in self.bpList:
mag = self.starSED.calcMag(bp)
magnitude_list.append(mag)
for bp, hardware, filterName, mm, m5 in \
zip(self.bpList, self.hardwareList, self.filterNameList, magnitude_list, m5_list):
skyDummy = Sed()
skyDummy.readSED_flambda(
os.path.join(lsst.utils.getPackageDir('throughputs'),
'baseline', 'darksky.dat'))
normalizedSkyDummy = setM5(
obs_metadata.m5[filterName],
skyDummy,
bp,
hardware,
FWHMeff=LSSTdefaults().FWHMeff(filterName),
photParams=photParams)
sigma, gamma = snr.calcMagError_m5(mm, bp, m5, photParams)
snrat = snr.calcSNR_sed(self.starSED,
bp,
normalizedSkyDummy,
hardware,
FWHMeff=LSSTdefaults().FWHMeff(filterName),
photParams=PhotometricParameters())
testSNR, gamma = snr.calcSNR_m5(
mm, bp, m5, photParams=PhotometricParameters(sigmaSys=0.0))
self.assertAlmostEqual(snrat,
testSNR,
10,
msg='failed on calcSNR_m5 test %e != %e ' %
(snrat, testSNR))
control = np.sqrt(
np.power(snr.magErrorFromSNR(testSNR), 2) +
np.power(sigmaSys, 2))
msg = '%e is not %e; failed' % (sigma, control)
self.assertAlmostEqual(sigma, control, 10, msg=msg)
def testSignalToNoise(self):
"""
Test that calcSNR_m5 and calcSNR_sed give similar results
"""
defaults = LSSTdefaults()
photParams = PhotometricParameters()
m5 = []
for i in range(len(self.hardwareList)):
m5.append(
snr.calcM5(
self.skySed,
self.bpList[i],
self.hardwareList[i],
photParams,
seeing=defaults.seeing(self.filterNameList[i]),
)
)
sedDir = lsst.utils.getPackageDir("sims_sed_library")
sedDir = os.path.join(sedDir, "starSED", "kurucz")
fileNameList = os.listdir(sedDir)
numpy.random.seed(42)
offset = numpy.random.random_sample(len(fileNameList)) * 2.0
for ix, name in enumerate(fileNameList):
if ix > 100:
break
spectrum = Sed()
spectrum.readSED_flambda(os.path.join(sedDir, name))
ff = spectrum.calcFluxNorm(m5[2] - offset[ix], self.bpList[2])
spectrum.multiplyFluxNorm(ff)
magList = []
controlList = []
magList = []
for i in range(len(self.bpList)):
controlList.append(
snr.calcSNR_sed(
spectrum,
self.bpList[i],
self.skySed,
self.hardwareList[i],
photParams,
defaults.seeing(self.filterNameList[i]),
)
)
magList.append(spectrum.calcMag(self.bpList[i]))
testList, gammaList = snr.calcSNR_m5(
numpy.array(magList), numpy.array(self.bpList), numpy.array(m5), photParams
)
for tt, cc in zip(controlList, testList):
msg = "%e != %e " % (tt, cc)
self.assertTrue(numpy.abs(tt / cc - 1.0) < 0.001, msg=msg)
def testSNR_arr(self):
"""
Test that calcSNR_m5 works on numpy arrays of magnitudes
"""
rng = np.random.RandomState(17)
mag_list = rng.random_sample(100) * 5.0 + 15.0
photParams = PhotometricParameters()
bp = self.bpList[0]
m5 = 24.0
control_list = []
for mm in mag_list:
ratio, gamma = snr.calcSNR_m5(mm, bp, m5, photParams)
control_list.append(ratio)
control_list = np.array(control_list)
test_list, gamma = snr.calcSNR_m5(mag_list, bp, m5, photParams)
np.testing.assert_array_equal(control_list, test_list)
def testSNR_arr(self):
"""
Test that calcSNR_m5 works on numpy arrays of magnitudes
"""
rng = np.random.RandomState(17)
mag_list = rng.random_sample(100)*5.0 + 15.0
photParams = PhotometricParameters()
bp = self.bpList[0]
m5 = 24.0
control_list = []
for mm in mag_list:
ratio, gamma = snr.calcSNR_m5(mm, bp, m5, photParams)
control_list.append(ratio)
control_list = np.array(control_list)
test_list, gamma = snr.calcSNR_m5(mag_list, bp, m5, photParams)
np.testing.assert_array_equal(control_list, test_list)
def Get_m5(self,filtre,mag_SN,msky,photParams,FWHMeff):
wavelen_min, wavelen_max, wavelen_step=self.transmission.lsst_system[filtre].getWavelenLimits(None,None,None)
flatSed = Sed()
flatSed.setFlatSED(wavelen_min, wavelen_max, wavelen_step)
flux0=np.power(10.,-0.4*msky)
flatSed.multiplyFluxNorm(flux0)
m5_calc=SignalToNoise.calcM5(flatSed,self.transmission.lsst_atmos_aerosol[filtre],self.transmission.lsst_system[filtre],photParams=photParams,FWHMeff=FWHMeff)
snr_m5_through,gamma_through=SignalToNoise.calcSNR_m5(mag_SN,self.transmission.lsst_atmos_aerosol[filtre],m5_calc,photParams)
return m5_calc,snr_m5_through
def testSNRexceptions(self):
"""
test that calcSNR_m5 raises an exception when arguments are not of the right shape.
"""
photParams = PhotometricParameters()
shortGamma = numpy.array([1.0, 1.0])
shortMagnitudes = numpy.array([22.0, 23.0])
magnitudes = 22.0*numpy.ones(6)
self.assertRaises(RuntimeError, snr.calcSNR_m5, magnitudes, self.bpList, shortMagnitudes, photParams)
self.assertRaises(RuntimeError, snr.calcSNR_m5, shortMagnitudes, self.bpList, magnitudes, photParams)
self.assertRaises(RuntimeError, snr.calcSNR_m5, magnitudes, self.bpList, magnitudes, photParams, gamma=shortGamma)
signalToNoise, gg = snr.calcSNR_m5(magnitudes, self.bpList, magnitudes, photParams)
def testSNRexceptions(self):
"""
test that calcSNR_m5 raises an exception when arguments are not of the right shape.
"""
photParams = PhotometricParameters()
shortGamma = numpy.array([1.0, 1.0])
shortMagnitudes = numpy.array([22.0, 23.0])
magnitudes = 22.0 * numpy.ones(6)
self.assertRaises(RuntimeError, snr.calcSNR_m5, magnitudes, self.bpList, shortMagnitudes, photParams)
self.assertRaises(RuntimeError, snr.calcSNR_m5, shortMagnitudes, self.bpList, magnitudes, photParams)
self.assertRaises(
RuntimeError, snr.calcSNR_m5, magnitudes, self.bpList, magnitudes, photParams, gamma=shortGamma
)
signalToNoise, gg = snr.calcSNR_m5(magnitudes, self.bpList, magnitudes, photParams)
def testSignalToNoise(self):
"""
Test that calcSNR_m5 and calcSNR_sed give similar results
"""
defaults = LSSTdefaults()
photParams = PhotometricParameters()
m5 = []
for i in range(len(self.hardwareList)):
m5.append(snr.calcM5(self.skySed, self.bpList[i],
self.hardwareList[i],
photParams, seeing=defaults.seeing(self.filterNameList[i])))
sedDir = lsst.utils.getPackageDir('sims_sed_library')
sedDir = os.path.join(sedDir, 'starSED', 'kurucz')
fileNameList = os.listdir(sedDir)
numpy.random.seed(42)
offset = numpy.random.random_sample(len(fileNameList))*2.0
for ix, name in enumerate(fileNameList):
if ix>100:
break
spectrum = Sed()
spectrum.readSED_flambda(os.path.join(sedDir, name))
ff = spectrum.calcFluxNorm(m5[2]-offset[ix], self.bpList[2])
spectrum.multiplyFluxNorm(ff)
magList = []
controlList = []
magList = []
for i in range(len(self.bpList)):
controlList.append(snr.calcSNR_sed(spectrum, self.bpList[i],
self.skySed,
self.hardwareList[i],
photParams, defaults.seeing(self.filterNameList[i])))
magList.append(spectrum.calcMag(self.bpList[i]))
testList, gammaList = snr.calcSNR_m5(numpy.array(magList),
numpy.array(self.bpList),
numpy.array(m5),
photParams)
for tt, cc in zip(controlList, testList):
msg = '%e != %e ' % (tt, cc)
self.assertTrue(numpy.abs(tt/cc - 1.0) < 0.001, msg=msg)
def testNoSystematicUncertainty(self):
"""
Test that systematic uncertainty is handled correctly when set to None.
"""
m5_list = [23.5, 24.3, 22.1, 20.0, 19.5, 21.7]
photParams= PhotometricParameters(sigmaSys=0.0)
obs_metadata = ObservationMetaData(pointingRA=23.0, pointingDec=45.0,
m5=m5_list, bandpassName=self.filterNameList)
magnitude_list = []
for bp in self.bpList:
mag = self.starSED.calcMag(bp)
magnitude_list.append(mag)
skySedList = []
for bp, hardware, filterName, mm, m5 in \
zip(self.bpList, self.hardwareList, self.filterNameList, magnitude_list, m5_list):
skyDummy = Sed()
skyDummy.readSED_flambda(os.path.join(lsst.utils.getPackageDir('throughputs'),
'baseline', 'darksky.dat'))
normalizedSkyDummy = setM5(obs_metadata.m5[filterName], skyDummy,
bp, hardware,
FWHMeff=LSSTdefaults().FWHMeff(filterName),
photParams=photParams)
sigma, gamma = snr.calcMagError_m5(mm, bp, m5, photParams)
snrat = snr.calcSNR_sed(self.starSED, bp, normalizedSkyDummy, hardware,
FWHMeff=LSSTdefaults().FWHMeff(filterName),
photParams=PhotometricParameters())
testSNR, gamma = snr.calcSNR_m5(mm, bp, m5, photParams=PhotometricParameters(sigmaSys=0.0))
self.assertAlmostEqual(snrat, testSNR, 10, msg = 'failed on calcSNR_m5 test %e != %e ' \
% (snrat, testSNR))
control = snr.magErrorFromSNR(testSNR)
msg = '%e is not %e; failed' % (sigma, control)
self.assertAlmostEqual(sigma, control, 10, msg=msg)
def testNoSystematicUncertainty(self):
"""
Test that systematic uncertainty is handled correctly when set to None.
"""
m5 = [23.5, 24.3, 22.1, 20.0, 19.5, 21.7]
photParams= PhotometricParameters(sigmaSys=0.0)
obs_metadata = ObservationMetaData(unrefractedRA=23.0, unrefractedDec=45.0, m5=m5, bandpassName=self.filterNameList)
magnitudes = []
for bp in self.bpList:
mag = self.starSED.calcMag(bp)
magnitudes.append(mag)
skySedList = []
for bp, hardware, filterName in zip(self.bpList, self.hardwareList, self.filterNameList):
skyDummy = Sed()
skyDummy.readSED_flambda(os.path.join(lsst.utils.getPackageDir('throughputs'), 'baseline', 'darksky.dat'))
normalizedSkyDummy = setM5(obs_metadata.m5[filterName], skyDummy,
bp, hardware,
seeing=LSSTdefaults().seeing(filterName),
photParams=photParams)
skySedList.append(normalizedSkyDummy)
sigmaList = snr.calcMagError_m5(numpy.array(magnitudes), numpy.array(self.bpList), \
numpy.array(m5), photParams)
for i in range(len(self.bpList)):
snrat = snr.calcSNR_sed(self.starSED, self.bpList[i], skySedList[i], self.hardwareList[i],
seeing=LSSTdefaults().seeing(self.filterNameList[i]),
photParams=PhotometricParameters())
testSNR, gamma = snr.calcSNR_m5(numpy.array([magnitudes[i]]), [self.bpList[i]],
numpy.array([m5[i]]), photParams=PhotometricParameters(sigmaSys=0.0))
self.assertAlmostEqual(snrat, testSNR[0], 10, msg = 'failed on calcSNR_m5 test %e != %e ' \
% (snrat, testSNR[0]))
control = snr.magErrorFromSNR(testSNR)
msg = '%e is not %e; failed' % (sigmaList[i], control)
self.assertAlmostEqual(sigmaList[i], control, 10, msg=msg)
def calcSNR_Flux(self, df, transm):
"""
Method to estimate SNRs and fluxes (in e.sec)
using lsst sims estimators
Parameters
---------------
df: pandas df
data to process
transm : array
throughputs
Returns
----------
original df plus the following cols:
gamma: gamma values
snr_m5: snr values
flux_e_sec: flux in pe/sec
"""
# estimate SNR
# Get photometric parameters to estimate SNR
photParams = [
PhotometricParameters(
exptime=vv[self.exptimeCol] / vv[self.nexpCol],
nexp=vv[self.nexpCol]) for index, vv in df.iterrows()
]
nvals = range(len(df))
calc = [
SignalToNoise.calcSNR_m5(df.iloc[i]['mag'], transm[i],
df.iloc[i][self.m5Col], photParams[i])
for i in nvals
]
df['snr_m5'] = [calc[i][0] for i in nvals]
df['gamma'] = [calc[i][1] for i in nvals]
# estimate the flux in elec.sec-1
df['flux_e_sec'] = self.telescope.mag_to_flux_e_sec(
df['mag'].values, df[self.filterCol].values,
df[self.exptimeCol] / df[self.nexpCol], df[self.nexpCol])[:, 1]
return df
def testSignalToNoise(self):
"""
Test that calcSNR_m5 and calcSNR_sed give similar results
"""
defaults = LSSTdefaults()
photParams = PhotometricParameters()
m5 = []
for i in range(len(self.hardwareList)):
m5.append(
snr.calcM5(self.skySed,
self.bpList[i],
self.hardwareList[i],
photParams,
FWHMeff=defaults.FWHMeff(self.filterNameList[i])))
sedDir = os.path.join(lsst.utils.getPackageDir('sims_photUtils'),
'tests/cartoonSedTestData/starSed/')
sedDir = os.path.join(sedDir, 'kurucz')
fileNameList = os.listdir(sedDir)
rng = np.random.RandomState(42)
offset = rng.random_sample(len(fileNameList)) * 2.0
for ix, name in enumerate(fileNameList):
if ix > 100:
break
spectrum = Sed()
spectrum.readSED_flambda(os.path.join(sedDir, name))
ff = spectrum.calcFluxNorm(m5[2] - offset[ix], self.bpList[2])
spectrum.multiplyFluxNorm(ff)
for i in range(len(self.bpList)):
control_snr = snr.calcSNR_sed(
spectrum, self.bpList[i], self.skySed,
self.hardwareList[i], photParams,
defaults.FWHMeff(self.filterNameList[i]))
mag = spectrum.calcMag(self.bpList[i])
test_snr, gamma = snr.calcSNR_m5(mag, self.bpList[i], m5[i],
photParams)
self.assertLess((test_snr - control_snr) / control_snr, 0.001)
def testSignalToNoise(self):
"""
Test that calcSNR_m5 and calcSNR_sed give similar results
"""
defaults = LSSTdefaults()
photParams = PhotometricParameters()
m5 = []
for i in range(len(self.hardwareList)):
m5.append(snr.calcM5(self.skySed, self.bpList[i],
self.hardwareList[i],
photParams, FWHMeff=defaults.FWHMeff(self.filterNameList[i])))
sedDir = os.path.join(lsst.utils.getPackageDir('sims_photUtils'),
'tests/cartoonSedTestData/starSed/')
sedDir = os.path.join(sedDir, 'kurucz')
fileNameList = os.listdir(sedDir)
rng = np.random.RandomState(42)
offset = rng.random_sample(len(fileNameList))*2.0
for ix, name in enumerate(fileNameList):
if ix > 100:
break
spectrum = Sed()
spectrum.readSED_flambda(os.path.join(sedDir, name))
ff = spectrum.calcFluxNorm(m5[2]-offset[ix], self.bpList[2])
spectrum.multiplyFluxNorm(ff)
for i in range(len(self.bpList)):
control_snr = snr.calcSNR_sed(spectrum, self.bpList[i],
self.skySed,
self.hardwareList[i],
photParams, defaults.FWHMeff(self.filterNameList[i]))
mag = spectrum.calcMag(self.bpList[i])
test_snr, gamma = snr.calcSNR_m5(mag, self.bpList[i], m5[i], photParams)
self.assertLess((test_snr-control_snr)/control_snr, 0.001)
def __call__(self,mjds,filtre,expTime,out_q):
fluxes=10.*self.SN.flux(mjds,self.wave)
wavelength=self.wave/10.
wavelength=np.repeat(wavelength[np.newaxis,:], len(fluxes), 0)
SED_time = Sed(wavelen=wavelength, flambda=fluxes)
r=[]
visittime=expTime
if self.airmass > 0.:
trans=self.transmission.atmosphere[filtre]
else:
trans=self.transmission.system[filtre]
photParams = PhotometricParameters(nexp=visittime/15.)
itemindex = np.where(mjds==0.)
#print 'hello',itemindex,mjds[itemindex]
for i in range(len(SED_time.wavelen)):
sed=Sed(wavelen=SED_time.wavelen[i],flambda=SED_time.flambda[i])
"""
if filtre == 'r' and i==itemindex[0]:
filtercolors = {'u':'b', 'g':'c', 'r':'g', 'i':'y', 'z':'r', 'y':'m'}
plt.plot(SED_time.wavelen[i],SED_time.flambda[i],ls='-',label='z ='+str(self.param['z']))
plt.ylabel('Flux density [$ergs/cm^2/s/nm$]')
plt.xlabel('$\lambda$ [nm]')
plt.legend(loc='upper right')
plt.title('x0= '+str(self.X0)+' x1= '+str(self.param['X1'])+' c= '+str(self.param['Color']))
#self.SED[self.param['z']]=(SED_time.wavelen[i],SED_time.flambda[i])
if self.param['z']==0.5:
ax = plt.gca().twinx()
for i,band in enumerate(['u','g','r','i','z','y']):
ax.plot(self.transmission.system[filtre].wavelen,self.transmission.system[filtre].sb,linestyle='--',color=filtercolors[filtre])
"""
flux_SN=sed.calcFlux(bandpass=self.transmission.system[filtre])
if flux_SN >0:
mag_SN=-2.5 * np.log10(flux_SN / 3631.0)
snr_m5_opsim,gamma_opsim=SignalToNoise.calcSNR_m5(mag_SN,trans,self.m5[filtre],photParams)
err_flux_SN=flux_SN/snr_m5_opsim
e_per_sec = sed.calcADU(bandpass=trans, photParams=photParams) #number of ADU counts for expTime
#e_per_sec = sed.calcADU(bandpass=self.transmission.lsst_atmos[filtre], photParams=photParams)
e_per_sec/=visittime/photParams.gain
#print 'ref',filtre,i,mjds[i],e_per_sec
#self.lc[filtre].append(e_per_sec)
r.append((e_per_sec,mjds[i],flux_SN))
self.table_for_fit.add_row((mjds[i],flux_SN,err_flux_SN,'LSST::'+filtre,25,'ab'))
#print 'hello',r
self.lc[filtre]=np.rec.fromrecords(r, names = ['flux','mjd','flux_SN'])
#print 'yyyy',len(self.lc[filtre]),self.lc[filtre]['flux_SN']
res=np.rec.fromrecords(r, names = ['flux','mjd','flux_SN'])
out_q.put({filtre :(res,self.table_for_fit)})
return res
def __call__(self, obs, out_q=None):
#print 'hello here',len(mjds),filtre
#time_begin=time.time()
"""
mjds=obs['mjd']
airmass=obs['airmass']
m5=obs['m5sigmadepth']
filtre=obs['band']
expTime=obs['exptime']
"""
fluxes = 10. * self.SN.flux(obs['mjd'], self.wave)
wavelength = self.wave / 10.
wavelength = np.repeat(wavelength[np.newaxis, :], len(fluxes), 0)
SED_time = Sed(wavelen=wavelength, flambda=fluxes)
#print 'total elapse time seds',time.time()-time_begin
"""
time_begin=time.time()
for i in range(len(SED_time.wavelen)):
photParams=PhotometricParameters(nexp=expTime[i]/15.)
sed=Sed(wavelen=SED_time.wavelen[i],flambda=SED_time.flambda[i])
self.transmission.Load_Atmosphere(airmass[i])
trans=self.transmission.atmosphere[filtre]
flux_SN=sed.calcFlux(bandpass=trans)
if flux_SN >0:
mag_SN=-2.5 * np.log10(flux_SN / 3631.0)
snr_m5_opsim,gamma_opsim=SignalToNoise.calcSNR_m5(mag_SN,trans,m5[i],photParams)
err_flux_SN=flux_SN/snr_m5_opsim
e_per_sec = sed.calcADU(bandpass=trans, photParams=photParams) #number of ADU counts for expTime
#e_per_sec = sed.calcADU(bandpass=self.transmission.lsst_atmos[filtre], photParams=photParams)
#print 'alors',e_per_sec,expTime[i],photParams.gain
e_per_sec/=expTime[i]/photParams.gain
#print 'alors b',e_per_sec
#print 'ref',filtre,i,mjds[i],e_per_sec
#self.lc[filtre].append(e_per_sec)
r.append((e_per_sec,mjds[i],flux_SN))
#self.table_for_fit.add_row((mjds[i],flux_SN,err_flux_SN,'LSST::'+filtre,25,'ab'))
#self.table_for_fit.add_row((mjds[i],mag_SN,mag_SN/snr_m5_opsim,'LSST::'+filtre,25,'ab'))
self.table_obs.add_row((mjds[i],flux_SN,err_flux_SN,'LSST::'+filtre,2.5*np.log10(3631),'ab',airmass[i],m5[i],expTime[i],e_per_sec,self.telescope.mag_to_flux(m5[i],filtre)))
#print 'there we go',filtre,e_per_sec,self.telescope.mag_to_flux(m5[i],filtre)
#print 'total elapse time GEN LC',time.time()-time_begin
"""
#time_begin=time.time()
fluxes = []
transes = []
seds = [
Sed(wavelen=SED_time.wavelen[i], flambda=SED_time.flambda[i])
for i in range(len(SED_time.wavelen))
]
#photParams=[]
#time_begin=time.time()
"""
for i in range(len(SED_time.wavelen)):
#photParams=PhotometricParameters(nexp=expTime[i]/15.)
#sed=Sed(wavelen=SED_time.wavelen[i],flambda=SED_time.flambda[i])
self.transmission.Load_Atmosphere(airmass[i])
trans=self.transmission.atmosphere[filtre]
#flux_SN=sed.calcFlux(bandpass=trans)
#fluxes.append(flux_SN)
transes.append(trans)
#seds.append(sed)
"""
transes = [
self.transmission.atmosphere[obs['band'][i][-1]]
for i in range(len(SED_time.wavelen))
]
#print 'total elapse time sed',time.time()-time_begin,len(transes)
fluxes = [
seds[i].calcFlux(bandpass=transes[i])
for i in range(len(SED_time.wavelen))
]
#print 'total elapse time sed',time.time()-time_begin
#print 'before',len(fluxes),len(seds),len(transes),len(m5),len(expTime),len(mjds),self.param['X1'],self.param['Color']
#print fluxes,mjds
#time_begin=time.time()
table_obs = Table(obs)
snr_m5 = []
e_per_sec_list = []
for i in range(len(SED_time.wavelen)):
photParams = PhotometricParameters(nexp=table_obs['exptime'][i] /
15.)
flux_SN = fluxes[i]
if flux_SN > 0:
trans = self.transmission.atmosphere[table_obs['band'][i][-1]]
mag_SN = -2.5 * np.log10(flux_SN / 3631.0)
snr_m5_opsim, gamma_opsim = SignalToNoise.calcSNR_m5(
mag_SN, trans, table_obs['m5sigmadepth'][i], photParams)
err_flux_SN = flux_SN / snr_m5_opsim
e_per_sec = seds[i].calcADU(
bandpass=trans,
photParams=photParams) #number of ADU counts for expTime
#e_per_sec = sed.calcADU(bandpass=self.transmission.lsst_atmos[filtre], photParams=photParams)
#print 'alors',e_per_sec,expTime[i],photParams.gain
e_per_sec /= table_obs['exptime'][i] / photParams.gain
#print('hello',mag_SN,flux_SN,e_per_sec,snr_m5_opsim)
snr_m5.append(snr_m5_opsim)
e_per_sec_list.append(e_per_sec)
#print fluxes,mags
else:
snr_m5.append(1)
e_per_sec_list.append(1)
#print('passed')
table_obs.add_column(Column(fluxes, name='flux'))
table_obs.add_column(Column(snr_m5, name='snr_m5'))
table_obs.add_column(Column(e_per_sec_list, name='flux_e'))
idx = table_obs['flux'] >= 0.
table_obs = table_obs[idx]
"""
mags=-2.5 * np.log10(table_obs['flux'] / 3631.0)
def snr(bands,mags,sky,seeing,expTime,ron):
pixel_scale=0.2
mag_sky=dict(zip('ugrizy',[22.95,22.24,21.20,20.47,19.60,18.63]))
FWHMeff = {'u':0.92, 'g':0.87, 'r':0.83, 'i':0.80, 'z':0.78, 'y':0.76}
neff=np.array(2.266*(seeing/pixel_scale)**2)
flux_e=self.telescope.mag_to_flux(mags,[band[-1] for band in bands])*expTime
#flux_sky=self.telescope.mag_to_flux([mag_sky[band[-1]] for band in bands],[band[-1] for band in bands])*expTime
flux_sky=self.telescope.mag_to_flux(sky,[band[-1] for band in bands])*expTime
#res=flux_e/np.sqrt((flux_sky*pixel_scale**2+ron**2)*neff)
res=flux_e/np.sqrt(flux_e+(flux_sky*pixel_scale**2+ron**2)*neff)
#for i in range(len(mags)):
#print mags[i],flux_e[i],res[i]
return res,flux_e/expTime
snrs,flux_e=snr(table_obs['band'],mags,table_obs['sky'],table_obs['seeing'],table_obs['exptime'],5.)
print('ici',flux_e,snrs)
"""
table_obs.add_column(
Column(table_obs['flux'] / table_obs['snr_m5'], name='fluxerr'))
#table_obs.add_column(Column(flux_e, name='flux_e'))
#table_obs.add_column(Column(flux_e/snrs, name='flux_e_err'))
table_obs.add_column(
Column(table_obs['flux_e'] / table_obs['snr_m5'],
name='flux_e_err'))
table_obs.add_column(
Column([2.5 * np.log10(3631)] * len(table_obs), name='zp'))
table_obs.add_column(Column(['ab'] * len(table_obs), name='zpsys'))
#table_obs.add_column(Column(self.telescope.mag_to_flux(mags,[band[-1] for band in table_obs['band']]),name='flux_e_sec'))
#table_obs.add_column(Column(self.telescope.mag_to_flux(obs['m5sigmadepth'],[band[-1] for band in table_obs['band']]),'flux_5sigma_e_sec'))
table_obs['band'][:] = np.array(
[b.replace('LSSTPG', 'LSST') for b in table_obs['band']])
table_obs.rename_column('mjd', 'time')
table_obs.rename_column('m5sigmadepth', 'm5')
for colname in [
'exptime', 'rawSeeing', 'seeing', 'moon_frac', 'sky', 'kAtm',
'airmass', 'm5', 'Nexp', 'Ra', 'Dec'
]:
if colname in table_obs.colnames:
table_obs.remove_column(colname)
#print(table_obs[['flux_e','snr_m5']])
"""
table_obs.remove_column('exptime')
table_obs.remove_column('rawSeeing')
table_obs.remove_column('seeing')
table_obs.remove_column('moon_frac')
table_obs.remove_column('sky')
table_obs.remove_column('kAtm')
table_obs.remove_column('airmass')
table_obs.remove_column('m5')
table_obs.remove_column('Nexp')
table_obs.remove_column('Ra')
table_obs.remove_column('Dec')
"""
#table_obs.remove_column('flux_e_sec')
#table_obs.remove_column('flux_5sigma_e_sec')
#print len(table_obs)
#print table_obs
#print len(table_obs),table_obs.dtype
#print np.array(np.sort(table_obs,order='band'))
"""
idx=fluxes > 0.
fluxes=fluxes[idx]
seds=np.array(seds)[idx]
transes=np.array(transes)[idx]
m5=m5[idx]
expTime=expTime[idx]
photParams=[PhotometricParameters(nexp=expTime[i]/15.) for i in range(len(expTime))]
airmass=airmass[idx]
mjds=mjds[idx]
filtre=filtre[idx]
#print 'allors',len(fluxes),len(seds),len(transes),len(m5),len(expTime),len(photParams),len(mjds)
#print fluxes,mjds
mags=-2.5 * np.log10(fluxes / 3631.0)
gamma = np.asarray([SignalToNoise.calcGamma(transes[i],m5[i],photParams[i]) for i in range(len(mags))])
x=np.power(10.,0.4*(mags-m5))
snr_m5_gamma=1./np.asarray(np.sqrt((0.04-gamma)*x+gamma*(x**2)))
#snr_m5_gamma_orig=[SignalToNoise.calcSNR_m5(mags[i],transes[i],m5[i],photParams[i]) for i in range(len(mags))]
#print 'hhh',snr_m5_gamma,snr_m5_gamma_orig
#snr_m5_opsim=[SignalToNoise.calcSNR_m5(mags[i],transes[i],m5[i],photParams[i]) for i in range(len(mags))]
err_fluxes=fluxes/snr_m5_gamma
#err_fluxes_orig=[fluxes[i]/snr_m5_gamma_orig[i][0] for i in range(len(fluxes))]
e_per_sec = [seds[i].calcADU(bandpass=transes[i], photParams=photParams[i]) for i in range(len(transes))] #number of ADU counts for expTime
e_per_sec=[e_per_sec[i]/(expTime[i]/photParams[i].gain) for i in range(len(e_per_sec))]
#mags_new=[self.telescope.flux_to_mag(e_per_sec[i],filtre[i][-1])[0] for i in range(len(e_per_sec))]
#print 10**(-0.4*(mags-mags_new))
print filtre[:]
print 'test',e_per_sec,self.telescope.mag_to_flux(mags,[band[-1] for band in filtre]),e_per_sec/self.telescope.mag_to_flux(mags,[band[-1] for band in filtre])
#snrs=snr(filtre,mags,obs['sky'],np.array([0.8]*len(mags)),obs['exptime'],5.)
print snr_m5_gamma,snrs,np.median(snr_m5_gamma/snrs),np.mean(snr_m5_gamma/snrs),np.min(snr_m5_gamma/snrs),np.max(snr_m5_gamma/snrs)
table_obs=Table()
table_obs.add_column(Column(mjds, name='time'))
table_obs.add_column(Column(fluxes, name='flux'))
table_obs.add_column(Column(err_fluxes, name='fluxerr'))
table_obs.add_column(Column(['LSST::'+filtre[i][-1] for i in range(len(filtre))], name='band'))
table_obs.add_column(Column([2.5*np.log10(3631)]*len(mjds),name='zp'))
table_obs.add_column(Column(['ab']*len(mjds),name='zpsys'))
table_obs.add_column(Column(airmass,name='airmass'))
table_obs.add_column(Column(m5,name='m5'))
table_obs.add_column(Column(expTime,name='expTime'))
table_obs.add_column(Column(e_per_sec,name='flux_e_sec'))
table_obs.add_column(Column(self.telescope.mag_to_flux(m5,[filtre[i][-1] for i in range(len(filtre))]),'flux_5sigma_e_sec'))
#print 'total elapse time GEN LC b',time.time()-time_begin
#print table_obs
"""
if out_q is not None:
out_q.put({filtre[0][-1]: table_obs})
return table_obs
def process_stellar_chunk(chunk, filter_obs, mjd_obs, m5_obs,
coadd_m5, m5_single, obs_md_list, proper_chip,
variability_cache, out_data, lock):
t_start_chunk = time.time()
#print('processing %d' % len(chunk))
ct_first = 0
ct_at_all = 0
ct_tot = 0
n_t = len(filter_obs)
n_obj = len(chunk)
coadd_visits = {}
coadd_visits['u'] = 6
coadd_visits['g'] = 8
coadd_visits['r'] = 18
coadd_visits['i'] = 18
coadd_visits['z'] = 16
coadd_visits['y'] = 16
gamma_coadd = {}
for bp in 'ugrizy':
gamma_coadd[bp] = None
gamma_single = {}
for bp in 'ugrizy':
gamma_single[bp] = [None]*n_t
dflux = np.zeros((n_obj,n_t), dtype=float)
dflux_for_mlt(chunk, filter_obs, mjd_obs, variability_cache, dflux)
dflux_for_kepler(chunk, filter_obs, mjd_obs, variability_cache, dflux)
dflux_for_rrly(chunk, filter_obs, mjd_obs, variability_cache, dflux)
dummy_sed = Sed()
lsst_bp = BandpassDict.loadTotalBandpassesFromFiles()
flux_q = np.zeros((6,n_obj), dtype=float)
flux_coadd = np.zeros((6,n_obj), dtype=float)
mag_coadd = np.zeros((6,n_obj), dtype=float)
snr_coadd = np.zeros((6,n_obj), dtype=float)
snr_single = {}
snr_single_mag_grid = np.arange(14.0, 30.0, 0.05)
phot_params_single = PhotometricParameters(nexp=1,
exptime=30.0)
t_start_snr = time.time()
photometry_mask = np.zeros((n_obj, n_t), dtype=bool)
photometry_mask_1d = np.zeros(n_obj, dtype=bool)
for i_bp, bp in enumerate('ugrizy'):
valid_obs = np.where(filter_obs == i_bp)
phot_params_coadd = PhotometricParameters(nexp=1,
exptime=30.0*coadd_visits[bp])
flux_q[i_bp] = dummy_sed.fluxFromMag(chunk['%smag' % bp])
dflux_sub = dflux[:,valid_obs[0]]
assert dflux_sub.shape == (n_obj, len(valid_obs[0]))
dflux_mean = np.mean(dflux_sub, axis=1)
assert dflux_mean.shape==(n_obj,)
flux_coadd[i_bp] = flux_q[i_bp]+dflux_mean
mag_coadd[i_bp] = dummy_sed.magFromFlux(flux_coadd[i_bp])
(snr_coadd[i_bp],
gamma) = SNR.calcSNR_m5(mag_coadd[i_bp],
lsst_bp[bp],
coadd_m5[bp],
phot_params_coadd)
(snr_single[bp],
gamma) = SNR.calcSNR_m5(snr_single_mag_grid,
lsst_bp[bp],
m5_single[bp],
phot_params_single)
#print('got all snr in %e' % (time.time()-t_start_snr))
t_start_obj = time.time()
snr_arr = np.zeros((n_obj, n_t), dtype=float)
for i_bp, bp in enumerate('ugrizy'):
valid_obs = np.where(filter_obs==i_bp)
if len(valid_obs[0])==0:
continue
n_bp = len(valid_obs[0])
dflux_bp = dflux[:,valid_obs[0]]
flux0_arr = flux_q[i_bp]
flux_tot = flux0_arr[:,None] + dflux_bp
mag_tot = dummy_sed.magFromFlux(flux_tot)
snr_single_val = np.interp(mag_tot,
snr_single_mag_grid,
snr_single[bp])
noise_coadd = flux_coadd[i_bp]/snr_coadd[i_bp]
noise_single = flux_tot/snr_single_val
noise = np.sqrt(noise_coadd[:,None]**2+noise_single**2)
dflux_thresh = 5.0*noise
dflux_bp = np.abs(dflux_bp)
detected = (dflux_bp>=dflux_thresh)
snr_arr[:,valid_obs[0]] = dflux_bp/noise
for i_obj in range(n_obj):
if detected[i_obj].any():
photometry_mask_1d[i_obj] = True
photometry_mask[i_obj,valid_obs[0]] = detected[i_obj]
t_before_chip = time.time()
chip_mask = apply_focal_plane(chunk['ra'], chunk['decl'],
photometry_mask_1d, obs_md_list,
filter_obs, proper_chip)
duration = (time.time()-t_before_chip)/3600.0
unq_out = -1*np.ones(n_obj, dtype=int)
mjd_out = -1.0*np.ones(n_obj, dtype=float)
snr_out = -1.0*np.ones(n_obj, dtype=float)
var_type_out = -1*np.ones(n_obj, dtype=int)
for i_obj in range(n_obj):
if photometry_mask_1d[i_obj]:
detected = photometry_mask[i_obj,:] & chip_mask[i_obj,:]
if detected.any():
unq_out[i_obj] = chunk['simobjid'][i_obj]
first_dex = np.where(detected)[0].min()
mjd_out[i_obj] = mjd_obs[first_dex]
snr_out[i_obj] = snr_arr[i_obj, first_dex]
var_type_out[i_obj] = chunk['var_type'][i_obj]
valid = np.where(unq_out>=0)
unq_out = unq_out[valid]
mjd_out = mjd_out[valid]
var_type_out = var_type_out[valid]
snr_out = snr_out[valid]
with lock:
existing_keys = list(out_data.keys())
key_val = 0
if len(existing_keys)>0:
key_val = max(existing_keys)
while key_val in existing_keys:
key_val += 1
out_data[key_val] = (None, None, None, None)
out_data[key_val] = (unq_out, mjd_out,
snr_out, var_type_out)
snr_SN = SignalToNoise.calcSNR_sed(
sed_SN,
transmission.lsst_atmos_aerosol[band],
transmission.darksky,
transmission.lsst_system[band],
photParams,
FWHMeff=FWHMeff,
verbose=False)
m5_calc = SignalToNoise.calcM5(
transmission.darksky,
transmission.lsst_atmos_aerosol[band],
transmission.lsst_system[band],
photParams=photParams,
FWHMeff=FWHMeff)
snr_m5_through, gamma_through = SignalToNoise.calcSNR_m5(
mag_SN, transmission.lsst_atmos_aerosol[band], m5_calc,
photParams)
snr_m5_opsim, gamma_opsim = SignalToNoise.calcSNR_m5(
mag_SN, transmission.lsst_atmos_aerosol[band], m5_opsim,
photParams)
err_flux_SN = flux_SN / snr_SN
table_for_fit['error_calc'].add_row(
(time, flux_SN, err_flux_SN, 'LSST::' + band, 25, 'ab'))
if flux_SNb > 0:
mag_SNb = -2.5 * np.log10(flux_SNb)
FWHMeff = SignalToNoise.FWHMgeom2FWHMeff(finSeeing)
def process_stellar_chunk(chunk, filter_obs, mjd_obs, m5_obs, coadd_m5,
obs_md_list, proper_chip, variability_cache,
out_data):
t_start_chunk = time.time()
#print('processing %d' % len(chunk))
ct_first = 0
ct_at_all = 0
ct_tot = 0
n_t = len(filter_obs)
n_obj = len(chunk)
coadd_visits = {}
coadd_visits['u'] = 6
coadd_visits['g'] = 8
coadd_visits['r'] = 18
coadd_visits['i'] = 18
coadd_visits['z'] = 16
coadd_visits['y'] = 16
# from the overview paper
# table 2; take m5 row and add Delta m5 row
# to get down to airmass 1.2
m5_single = {}
m5_single['u'] = 23.57
m5_single['g'] = 24.65
m5_single['r'] = 24.21
m5_single['i'] = 23.79
m5_single['z'] = 23.21
m5_single['y'] = 22.31
gamma_coadd = {}
for bp in 'ugrizy':
gamma_coadd[bp] = None
gamma_single = {}
for bp in 'ugrizy':
gamma_single[bp] = [None] * n_t
dflux = np.zeros((n_obj, n_t), dtype=float)
dflux_for_mlt(chunk, filter_obs, mjd_obs, variability_cache, dflux)
dflux_for_kepler(chunk, filter_obs, mjd_obs, variability_cache, dflux)
dflux_for_rrly(chunk, filter_obs, mjd_obs, variability_cache, dflux)
dummy_sed = Sed()
lsst_bp = BandpassDict.loadTotalBandpassesFromFiles()
flux_q = np.zeros((6, n_obj), dtype=float)
flux_coadd = np.zeros((6, n_obj), dtype=float)
mag_coadd = np.zeros((6, n_obj), dtype=float)
snr_coadd = np.zeros((6, n_obj), dtype=float)
snr_single = {}
snr_single_mag_grid = np.arange(14.0, 30.0, 0.05)
phot_params_single = PhotometricParameters(nexp=1, exptime=30.0)
t_start_snr = time.time()
photometry_mask = np.zeros((n_obj, n_t), dtype=bool)
photometry_mask_1d = np.zeros(n_obj, dtype=bool)
for i_bp, bp in enumerate('ugrizy'):
valid_obs = np.where(filter_obs == i_bp)
phot_params_coadd = PhotometricParameters(nexp=1,
exptime=30.0 *
coadd_visits[bp])
flux_q[i_bp] = dummy_sed.fluxFromMag(chunk['%smag' % bp])
dflux_sub = dflux[:, valid_obs[0]]
assert dflux_sub.shape == (n_obj, len(valid_obs[0]))
dflux_mean = np.mean(dflux_sub, axis=1)
assert dflux_mean.shape == (n_obj, )
flux_coadd[i_bp] = flux_q[i_bp] + dflux_mean
mag_coadd[i_bp] = dummy_sed.magFromFlux(flux_coadd[i_bp])
(snr_coadd[i_bp], gamma) = SNR.calcSNR_m5(mag_coadd[i_bp], lsst_bp[bp],
coadd_m5[bp],
phot_params_coadd)
(snr_single[bp], gamma) = SNR.calcSNR_m5(snr_single_mag_grid,
lsst_bp[bp], m5_single[bp],
phot_params_single)
#print('got all snr in %e' % (time.time()-t_start_snr))
t_start_obj = time.time()
snr_arr = np.zeros((n_obj, n_t), dtype=float)
for i_bp, bp in enumerate('ugrizy'):
valid_obs = np.where(filter_obs == i_bp)
if len(valid_obs[0]) == 0:
continue
n_bp = len(valid_obs[0])
dflux_bp = dflux[:, valid_obs[0]]
flux0_arr = flux_q[i_bp]
flux_tot = flux0_arr[:, None] + dflux_bp
mag_tot = dummy_sed.magFromFlux(flux_tot)
snr_single_val = np.interp(mag_tot, snr_single_mag_grid,
snr_single[bp])
noise_coadd = flux_coadd[i_bp] / snr_coadd[i_bp]
noise_single = flux_tot / snr_single_val
noise = np.sqrt(noise_coadd[:, None]**2 + noise_single**2)
dflux_thresh = 5.0 * noise
dflux_bp = np.abs(dflux_bp)
detected = (dflux_bp >= dflux_thresh)
snr_arr[:, valid_obs[0]] = dflux_bp / noise
for i_obj in range(n_obj):
if detected[i_obj].any():
photometry_mask_1d[i_obj] = True
photometry_mask[i_obj, valid_obs[0]] = detected[i_obj]
t_before_chip = time.time()
chip_mask = apply_focal_plane(chunk['ra'], chunk['decl'],
photometry_mask_1d, obs_md_list, filter_obs,
proper_chip)
duration = (time.time() - t_before_chip) / 3600.0
for i_obj in range(n_obj):
if photometry_mask_1d[i_obj]:
detected = photometry_mask[i_obj, :] & chip_mask[i_obj, :]
if detected.any():
unq = chunk['simobjid'][i_obj]
first_dex = np.where(detected)[0].min()
out_data[unq] = (mjd_obs[first_dex], snr_arr[i_obj, first_dex],
chunk['var_type'][i_obj])
if detected[0]:
ct_first += 1
else:
ct_at_all += 1
def Simulate_and_Fit_LC(self, observations, transmission, zmin, zmax):
#print 'start Simulation',time.time()-self.start_time
#print 'time',observations['expMJD'],observations['filter']
#print 'simulate and fit'
ra = observations[self.fieldRA][0]
dec = observations[self.fieldDec][0]
if self.SN.sn_type == 'Ia':
mbsim = self.SN.SN._source.peakmag('bessellb', 'vega')
else:
mbsim = -1
#This will be the data for sncosmo fitting
table_for_fit = {}
table_for_fit['error_coadd_opsim'] = Table(
names=('time', 'flux', 'fluxerr', 'band', 'zp', 'zpsys'),
dtype=('f8', 'f8', 'f8', 'S7', 'f4', 'S4'))
table_for_fit['error_coadd_through'] = Table(
names=('time', 'flux', 'fluxerr', 'band', 'zp', 'zpsys'),
dtype=('f8', 'f8', 'f8', 'S7', 'f4', 'S4'))
"""
table_for_fit['error_opsim'] = Table(names=('time','flux','fluxerr','band','zp','zpsys'), dtype=('f8', 'f8','f8','S7','f4','S4'))
table_for_fit['error_through'] = Table(names=('time','flux','fluxerr','band','zp','zpsys'), dtype=('f8', 'f8','f8','S7','f4','S4'))
"""
mytype = [('obsHistID', np.int), ('filtSkyBrightness', np.float),
('airmass', np.float), ('moonPhase', np.float),
('fieldRA', np.float), ('fieldDec', np.float),
('visitExpTime', np.float), ('expDate', np.int),
('filter', np.dtype('a15')), ('fieldID', np.int),
('fiveSigmaDepth', np.float), ('ditheredDec', np.float),
('expMJD', np.float), ('ditheredRA', np.float),
('rawSeeing', np.float), ('flux', np.float),
('err_flux', np.float), ('err_flux_opsim', np.float),
('err_flux_through', np.float), ('finSeeing', np.float),
('katm_opsim', np.float), ('katm_calc', np.float),
('m5_calc', np.float), ('Tb', np.float),
('Sigmab', np.float), ('Cm', np.float), ('dCm', np.float),
('mag_SN', np.float), ('snr_m5_through', np.float),
('snr_m5_opsim', np.float), ('gamma_through', np.float),
('gamma_opsim', np.float), ('snr_SED', np.float)]
myobservations = np.zeros((60, 1), dtype=mytype)
#print 'Nobservations',len(observations)
nobs = -1
for obs in observations:
nobs += 1
filtre = obs['filter']
if len(myobservations) <= nobs:
myobservations = np.resize(myobservations,
(len(myobservations) + 100, 1))
for name in self.cols_restricted:
myobservations[name][nobs] = obs[name]
seeing = obs['rawSeeing']
time_obs = obs['expMJD']
m5_opsim = obs['fiveSigmaDepth']
sed_SN = self.SN.get_SED(time_obs)
transmission.Load_Atmosphere(obs['airmass'])
flux_SN = sed_SN.calcFlux(
bandpass=transmission.lsst_atmos_aerosol[filtre])
myup = 0
Tb = 0
Sigmab = 0
katm = 0
mbsky_through = 0
"""
Filter_Wavelength_Correction = np.power(500.0 / self.params.filterWave[filtre], 0.3)
Airmass_Correction = math.pow(obs['airmass'],0.6)
FWHM_Sys = self.params.FWHM_Sys_Zenith * Airmass_Correction
FWHM_Atm = seeing * Filter_Wavelength_Correction * Airmass_Correction
finSeeing = self.params.scaleToNeff * math.sqrt(np.power(FWHM_Sys,2) + self.params.atmNeffFactor * np.power(FWHM_Atm,2))
Tscale = obs['visitExpTime']/ 30.0 * np.power(10.0, -0.4*(obs['filtSkyBrightness'] - self.params.msky[filtre]))
dCm = self.params.dCm_infinity[filtre] - 1.25*np.log10(1 + np.power(10.,0.8*self.params.dCm_infinity[filtre]- 1.)/Tscale)
m5_recalc=dCm+self.params.Cm[filtre]+0.5*(obs['filtSkyBrightness']-21.)+2.5*np.log10(0.7/finSeeing)-self.params.kAtm[filtre]*(obs['airmass']-1.)+1.25*np.log10(obs['visitExpTime']/30.)
"""
"""
myobservations['Cm'][nobs]=self.params.Cm[filtre]
myobservations['dCm'][nobs]=dCm
myobservations['finSeeing'][nobs]=finSeeing
myobservations['Tb'][nobs]=Tb
myobservations['Sigmab'][nobs]=Sigmab
myobservations['katm_calc'][nobs]=katm
myobservations['katm_opsim'][nobs]=self.params.kAtm[filtre]
"""
#print 'Flux',time.time()-self.start_time
if flux_SN > 0:
wavelen_min, wavelen_max, wavelen_step = transmission.lsst_system[
filtre].getWavelenLimits(None, None, None)
flatSed = Sed()
flatSed.setFlatSED(wavelen_min, wavelen_max, wavelen_step)
flux0 = np.power(10., -0.4 * obs['filtSkyBrightness'])
flatSed.multiplyFluxNorm(flux0)
mag_SN = -2.5 * np.log10(flux_SN / 3631.0)
#FWHMeff = SignalToNoise.FWHMgeom2FWHMeff(finSeeing)
FWHMeff = obs['FWHMeff']
photParams = PhotometricParameters(nexp=obs['visitExpTime'] /
15.)
m5_calc = SignalToNoise.calcM5(
flatSed,
transmission.lsst_atmos_aerosol[filtre],
transmission.lsst_system[filtre],
photParams=photParams,
FWHMeff=FWHMeff)
snr_m5_through, gamma_through = SignalToNoise.calcSNR_m5(
mag_SN, transmission.lsst_atmos_aerosol[filtre], m5_calc,
photParams)
m5_opsim += 1.25 * np.log10(obs['visitExpTime'] / 30.)
snr_m5_opsim, gamma_opsim = SignalToNoise.calcSNR_m5(
mag_SN, transmission.lsst_atmos_aerosol[filtre], m5_opsim,
photParams)
err_flux_SN = 0
err_flux_SN_opsim = flux_SN / snr_m5_opsim
err_flux_SN_through = flux_SN / snr_m5_through
myobservations['mag_SN'][nobs] = mag_SN
myobservations['flux'][nobs] = flux_SN
myobservations['err_flux'][nobs] = err_flux_SN
myobservations['err_flux_opsim'][nobs] = err_flux_SN_opsim
myobservations['err_flux_through'][nobs] = err_flux_SN_through
myobservations['m5_calc'][nobs] = m5_calc
myobservations['snr_m5_through'][nobs] = snr_m5_through
myobservations['snr_m5_opsim'][nobs] = snr_m5_opsim
myobservations['gamma_through'][nobs] = gamma_through
myobservations['gamma_opsim'][nobs] = gamma_opsim
#myobservations['snr_SED'][nobs]=snr_SN
#print 'SNR',flux_SN,flux_SN/err_flux_SN,flux_SN/err_flux_SN_opsim
#if flux_SN/err_flux_SN >=5:
#table_for_fit['error_calc'].add_row((time_obs,flux_SN,err_flux_SN,'LSST::'+filtre,25,'ab'))
#if flux_SN/err_flux_SN_opsim >=5.:
table_for_fit['error_coadd_opsim'].add_row(
(time_obs, flux_SN, err_flux_SN_opsim, 'LSST::' + filtre,
25, 'ab'))
table_for_fit['error_coadd_through'].add_row(
(time_obs, flux_SN, err_flux_SN_through, 'LSST::' + filtre,
25, 'ab'))
#print 'Getting fluxes and errors',time.time()-self.thetime,filtre,nobs
else:
err_flux_SN = -999.
err_flux_SN_opsim = -999.
myobservations['mag_SN'][nobs] = -999
myobservations['flux'][nobs] = flux_SN
myobservations['err_flux'][nobs] = -999.
myobservations['err_flux_opsim'][nobs] = -999.
myobservations['err_flux_through'][nobs] = -999.
myobservations['m5_calc'][nobs] = -999.
myobservations['snr_m5_through'][nobs] = -999
myobservations['snr_m5_opsim'][nobs] = -999
myobservations['gamma_through'][nobs] = -999
myobservations['gamma_opsim'][nobs] = -999
myobservations['snr_SED'][nobs] = -999
myobservations = np.resize(myobservations, (nobs + 1, 1))
"""
print 'Preparing table_for_fit',time.time()-self.start_time
for band in ['u','g','r','i','z','y']:
selb=table_for_fit['error_opsim'][np.where(table_for_fit['error_opsim']['band']=='LSST::'+band)]
selc=table_for_fit['error_through'][np.where(table_for_fit['error_through']['band']=='LSST::'+band)]
table_for_fit['error_coadd_opsim']=vstack([table_for_fit['error_coadd_opsim'],self.Get_coadd(selb)])
table_for_fit['error_coadd_through']=vstack([table_for_fit['error_coadd_through'],self.Get_coadd(selc)])
"""
#print 'There we go fitting',time.time()-self.thetime
dict_fit = {}
#for val in ['error_calc','error_coadd_calc','error_opsim','error_coadd_opsim']:
for val in ['error_coadd_opsim', 'error_coadd_through']:
#print 'Go for fit',time.time()-self.start_time
dict_fit[val] = {}
dict_fit[val]['sncosmo_fitted'] = {}
dict_fit[val]['table_for_fit'] = table_for_fit[val]
#print 'fit',val,time.time()-self.thetime
res, fitted_model, mbfit, fit_status = self.Fit_SN(
table_for_fit[val], zmin, zmax)
if res is not None:
dict_fit[val]['sncosmo_res'] = res
#self.dict_fit[val]['fitted_model']=fitted_model
for i, par in enumerate(fitted_model.param_names):
dict_fit[val]['sncosmo_fitted'][
par] = fitted_model.parameters[i]
dict_fit[val]['mbfit'] = mbfit
dict_fit[val]['fit_status'] = fit_status
#print 'end of Fit',time.time()-self.start_time
return dict_fit, mbsim, myobservations
def Simulate_LC(self):
for obs in self.obs:
filtre = obs['band'].split('::')[1]
#seeing=obs['rawSeeing']
time_obs = obs['mjd']
#m5_opsim=obs['fiveSigmaDepth']
m5_opsim = obs['m5sigmadepth']
sed_SN = self.SN.get_SED(time_obs)
self.transmission.Load_Atmosphere(obs['airmass'])
flux_SN = sed_SN.calcFlux(
bandpass=self.transmission.lsst_atmos_aerosol[filtre])
#visittime=obs['visitExpTime']
visittime = obs['exptime']
photParams = PhotometricParameters(nexp=visittime / 15.)
e_per_sec = sed_SN.calcADU(
bandpass=self.transmission.lsst_atmos_aerosol[filtre],
photParams=photParams) #number of ADU counts for expTime
e_per_sec /= visittime / photParams.gain
"""
Filter_Wavelength_Correction = np.power(500.0 / self.params.filterWave[filtre], 0.3)
Airmass_Correction = math.pow(obs['airmass'],0.6)
FWHM_Sys = self.params.FWHM_Sys_Zenith * Airmass_Correction
FWHM_Atm = seeing * Filter_Wavelength_Correction * Airmass_Correction
finSeeing = self.params.scaleToNeff * math.sqrt(np.power(FWHM_Sys,2) + self.params.atmNeffFactor * np.power(FWHM_Atm,2))
FWHMeff = SignalToNoise.FWHMgeom2FWHMeff(finSeeing)
"""
#print 'alors pal',finSeeing,FWHMeff,obs['FWHMgeom'],obs['FWHMeff'],SignalToNoise.FWHMgeom2FWHMeff(obs['FWHMgeom'])
FWHMeff = obs['FWHMeff']
if flux_SN > 0:
mag_SN = -2.5 * np.log10(flux_SN / 3631.0)
#print 'hello',finSeeing,FWHMeff
m5_calc, snr_m5_through = self.Get_m5(filtre, mag_SN,
obs['sky'], photParams,
FWHMeff)
m5_opsim += 1.25 * np.log10(visittime / 30.)
snr_m5_opsim, gamma_opsim = SignalToNoise.calcSNR_m5(
mag_SN, self.transmission.lsst_atmos_aerosol[filtre],
m5_opsim, photParams)
err_flux_SN_opsim = flux_SN / snr_m5_opsim
err_flux_SN_through = flux_SN / snr_m5_through
self.table_for_fit['error_coadd_opsim'].add_row(
(time_obs, flux_SN, err_flux_SN_opsim, 'LSST::' + filtre,
25, 'ab'))
self.table_for_fit['error_coadd_through'].add_row(
(time_obs, flux_SN, err_flux_SN_through, 'LSST::' + filtre,
25, 'ab'))
"""
flatSed_err = Sed()
flatSed_err.setFlatSED(wavelen_min, wavelen_max, wavelen_step)
#flatSed_err.multiplyFluxNorm(err_flux_SN_through)
err_mag_SN=-2.5 * np.log10( err_flux_SN_through/ 3631.0)
flux0_err=np.power(10.,-0.4*err_mag_SN)
flatSed_err.multiplyFluxNorm(flux0_err)
e_per_sec_err = flatSed_err.calcADU(bandpass=self.transmission.lsst_atmos_aerosol[filtre], photParams=photParams) #number of ADU counts for expTime
e_per_sec_err/=obs['visitExpTime']/2.3
"""
#print 'test',e_per_sec_err,e_per_sec/snr_m5_through
#print 'hello',filtre,obs['expMJD'],obs['visitExpTime'],obs['rawSeeing'],obs['moon_frac'],obs['filtSkyBrightness'],obs['kAtm'],obs['airmass'],obs['fiveSigmaDepth'],obs['Nexp'],e_per_sec,e_per_sec_err,flux_SN,err_flux_SN_through
self.table_LC.add_row(
('LSST::' + filtre, obs['mjd'], visittime, FWHMeff,
obs['moon_frac'], obs['sky'], obs['kAtm'], obs['airmass'],
obs['m5sigmadepth'], obs['Nexp'], e_per_sec,
e_per_sec / snr_m5_through))
if self.syste:
resu = [
'LSST::' + filtre, obs['mjd'], visittime, FWHMeff,
obs['moon_frac'], obs['sky'], obs['kAtm'],
obs['airmass'], m5_opsim, obs['Nexp'], e_per_sec,
e_per_sec / snr_m5_through, mag_SN,
mag_SN / snr_m5_through, m5_calc
]
for i in range(1, 6, 1):
m5_calc_plus, snr_m5_plus = self.Get_m5(
filtre, mag_SN, obs['sky'] + float(i) / 10.,
photParams, FWHMeff)
m5_calc_minus, snr_m5_minus = self.Get_m5(
filtre, mag_SN, obs['sky'] - float(i) / 10.,
photParams, FWHMeff)
resu.append(mag_SN / snr_m5_plus)
resu.append(mag_SN / snr_m5_minus)
resu.append(m5_calc_plus)
resu.append(m5_calc_minus)
resu.append(self.z)
self.table_LC_syste.add_row(tuple(resu))
else:
self.table_LC.add_row(
('LSST::' + filtre, obs['mjd'], visittime, FWHMeff,
obs['moon_frac'], obs['sky'], obs['kAtm'], obs['airmass'],
obs['m5sigmadepth'], obs['Nexp'], -1., -1.))
self.table_LC.sort(['filter', 'expMJD'])
def Simulate_and_Fit_LC(self, observations, transmission, zmin, zmax):
#print 'time',observations['expMJD'],observations['filter']
#print 'simulate and fit'
ra = observations[self.fieldRA][0]
dec = observations[self.fieldDec][0]
if self.SN.sn_type == 'Ia':
mbsim = self.SN.SN._source.peakmag('bessellb', 'vega')
else:
mbsim = -1
#This will be the data for sncosmo fitting
table_for_fit = {}
table_for_fit['error_calc'] = Table(names=('time', 'flux', 'fluxerr',
'band', 'zp', 'zpsys'),
dtype=('f8', 'f8', 'f8', 'S7',
'f4', 'S4'))
table_for_fit['error_coadd_calc'] = Table(
names=('time', 'flux', 'fluxerr', 'band', 'zp', 'zpsys'),
dtype=('f8', 'f8', 'f8', 'S7', 'f4', 'S4'))
table_for_fit['error_opsim'] = Table(names=('time', 'flux', 'fluxerr',
'band', 'zp', 'zpsys'),
dtype=('f8', 'f8', 'f8', 'S7',
'f4', 'S4'))
table_for_fit['error_coadd_opsim'] = Table(
names=('time', 'flux', 'fluxerr', 'band', 'zp', 'zpsys'),
dtype=('f8', 'f8', 'f8', 'S7', 'f4', 'S4'))
table_for_fit['error_through'] = Table(
names=('time', 'flux', 'fluxerr', 'band', 'zp', 'zpsys'),
dtype=('f8', 'f8', 'f8', 'S7', 'f4', 'S4'))
table_for_fit['error_coadd_through'] = Table(
names=('time', 'flux', 'fluxerr', 'band', 'zp', 'zpsys'),
dtype=('f8', 'f8', 'f8', 'S7', 'f4', 'S4'))
mytype = [('obsHistID', np.int), ('filtSkyBrightness', np.float),
('airmass', np.float), ('moonPhase', np.float),
('fieldRA', np.float), ('fieldDec', np.float),
('visitExpTime', np.float), ('expDate', np.int),
('filter', np.dtype('a15')), ('fieldID', np.int),
('fiveSigmaDepth', np.float), ('ditheredDec', np.float),
('expMJD', np.float), ('ditheredRA', np.float),
('rawSeeing', np.float), ('flux', np.float),
('err_flux', np.float), ('err_flux_opsim', np.float),
('err_flux_through', np.float), ('finSeeing', np.float),
('katm_opsim', np.float), ('katm_calc', np.float),
('m5_calc', np.float), ('Tb', np.float),
('Sigmab', np.float), ('Cm', np.float), ('dCm', np.float),
('mag_SN', np.float), ('snr_m5_through', np.float),
('snr_m5_opsim', np.float), ('gamma_through', np.float),
('gamma_opsim', np.float), ('snr_SED', np.float)]
myobservations = np.zeros((60, 1), dtype=mytype)
#print 'Nobservations',len(observations)
nobs = -1
for filtre in self.filterNames:
obs_filtre = observations[np.where(
observations['filter'] == filtre)]
#print 'ehehe',obs_filtre
for obs in obs_filtre:
nobs += 1
if len(myobservations) <= nobs:
myobservations = np.resize(myobservations,
(len(myobservations) + 100, 1))
for name in observations.dtype.names:
myobservations[name][nobs] = obs[name]
#print 'time uu',obs['expMJD']
seeing = obs['rawSeeing']
#seeing=obs['finSeeing']
time_obs = obs['expMJD']
m5_opsim = obs['fiveSigmaDepth']
#print 'getting SED'
sed_SN = self.SN.get_SED(time_obs)
#print 'got SED',sed_SN.wavelen,sed_SN.flambda,obs['expMJD']
"""
outf = open('SN_'+str(time)+'.dat', 'wb')
for i,wave in enumerate(sn.SEDfromSNcosmo.wavelen):
print >> outf,wave,sn.SEDfromSNcosmo.flambda[i]
outf.close()
"""
#print 'loading transmission airmass'
transmission.Load_Atmosphere(obs['airmass'])
flux_SN = sed_SN.calcFlux(
bandpass=transmission.lsst_atmos_aerosol[filtre])
#print 'this is my flux',flux_SN
#flux_SN=sed_SN.calcFlux(bandpass=transmission.lsst_system[filtre]) / 3631.0
myup = transmission.darksky.calcInteg(
transmission.lsst_system[filtre])
"""
wavelen, sb = transmission.lsst_system[filtre].multiplyThroughputs(transmission.lsst_atmos[filtre].wavelen, transmission.lsst_atmos[filtre].sb)
lsst_total= Bandpass(wavelen=wavelen, sb=sb)
"""
Tb = self.Calc_Integ(transmission.lsst_atmos[filtre])
Sigmab = self.Calc_Integ(transmission.lsst_system[filtre])
katm = -2.5 * np.log10(Tb / Sigmab)
mbsky_through = -2.5 * np.log10(myup / (3631. * Sigmab))
#print 'there mbsky',filtre,mbsky_through,obs['filtSkyBrightness'],katm,self.kAtm[filtre],Tb,Sigmab,obs['airmass']
Filter_Wavelength_Correction = np.power(
500.0 / self.params.filterWave[filtre], 0.3)
Airmass_Correction = math.pow(obs['airmass'], 0.6)
FWHM_Sys = self.params.FWHM_Sys_Zenith * Airmass_Correction
FWHM_Atm = seeing * Filter_Wavelength_Correction * Airmass_Correction
finSeeing = self.params.scaleToNeff * math.sqrt(
np.power(FWHM_Sys, 2) +
self.params.atmNeffFactor * np.power(FWHM_Atm, 2))
#print 'hello pal',filtre,finSeeing,obs['visitExpTime']
Tscale = obs['visitExpTime'] / 30.0 * np.power(
10.0, -0.4 *
(obs['filtSkyBrightness'] - self.params.msky[filtre]))
dCm = self.params.dCm_infinity[filtre] - 1.25 * np.log10(
1 + np.power(10., 0.8 * self.params.dCm_infinity[filtre] -
1.) / Tscale)
m5_recalc = dCm + self.params.Cm[filtre] + 0.5 * (
obs['filtSkyBrightness'] - 21.) + 2.5 * np.log10(
0.7 / finSeeing) - self.params.kAtm[filtre] * (
obs['airmass'] - 1.) + 1.25 * np.log10(
obs['visitExpTime'] / 30.)
myobservations['Cm'][nobs] = self.params.Cm[filtre]
myobservations['dCm'][nobs] = dCm
myobservations['finSeeing'][nobs] = finSeeing
myobservations['Tb'][nobs] = Tb
myobservations['Sigmab'][nobs] = Sigmab
myobservations['katm_calc'][nobs] = katm
myobservations['katm_opsim'][nobs] = self.params.kAtm[filtre]
wavelen_min, wavelen_max, wavelen_step = transmission.lsst_system[
filtre].getWavelenLimits(None, None, None)
flatSed = Sed()
flatSed.setFlatSED(wavelen_min, wavelen_max, wavelen_step)
flux0 = np.power(10., -0.4 * obs['filtSkyBrightness'])
flatSed.multiplyFluxNorm(flux0)
if flux_SN > 0:
#print 'positive flux',flux_SN
mag_SN = -2.5 * np.log10(flux_SN / 3631.0)
FWHMeff = SignalToNoise.FWHMgeom2FWHMeff(finSeeing)
#FWHMeff = SignalToNoise.FWHMgeom2FWHMeff(seeing)
photParams = PhotometricParameters()
snr_SN = SignalToNoise.calcSNR_sed(
sed_SN,
transmission.lsst_atmos_aerosol[filtre],
transmission.darksky,
transmission.lsst_system[filtre],
photParams,
FWHMeff=FWHMeff,
verbose=False)
#m5_calc=SignalToNoise.calcM5(transmission.darksky,transmission.lsst_atmos_aerosol[filtre],transmission.lsst_system[filtre],photParams=photParams,FWHMeff=FWHMeff)
m5_calc = SignalToNoise.calcM5(
flatSed,
transmission.lsst_atmos_aerosol[filtre],
transmission.lsst_system[filtre],
photParams=photParams,
FWHMeff=FWHMeff)
snr_m5_through, gamma_through = SignalToNoise.calcSNR_m5(
mag_SN, transmission.lsst_atmos_aerosol[filtre],
m5_calc, photParams)
snr_m5_opsim, gamma_opsim = SignalToNoise.calcSNR_m5(
mag_SN, transmission.lsst_atmos_aerosol[filtre],
m5_opsim, photParams)
#print 'm5 diff',filtre,m5_calc,m5_opsim,m5_calc/m5_opsim,m5_recalc,(m5_opsim/m5_recalc)
err_flux_SN = flux_SN / snr_SN
err_flux_SN_opsim = flux_SN / snr_m5_opsim
err_flux_SN_through = flux_SN / snr_m5_through
#print 'test errors',flux_SN,err_flux_SN,err_flux_SN_opsim,err_flux_SN_through,err_flux_SN_through/err_flux_SN_opsim,m5_opsim-m5_calc
myobservations['mag_SN'][nobs] = mag_SN
myobservations['flux'][nobs] = flux_SN
myobservations['err_flux'][nobs] = err_flux_SN
myobservations['err_flux_opsim'][nobs] = err_flux_SN_opsim
myobservations['err_flux_through'][
nobs] = err_flux_SN_through
myobservations['m5_calc'][nobs] = m5_calc
myobservations['snr_m5_through'][nobs] = snr_m5_through
myobservations['snr_m5_opsim'][nobs] = snr_m5_opsim
myobservations['gamma_through'][nobs] = gamma_through
myobservations['gamma_opsim'][nobs] = gamma_opsim
myobservations['snr_SED'][nobs] = snr_SN
#print 'SNR',flux_SN,flux_SN/err_flux_SN,flux_SN/err_flux_SN_opsim
#if flux_SN/err_flux_SN >=5:
#table_for_fit['error_calc'].add_row((time_obs,flux_SN,err_flux_SN,'LSST::'+filtre,25,'ab'))
#if flux_SN/err_flux_SN_opsim >=5.:
table_for_fit['error_opsim'].add_row(
(time_obs, flux_SN, err_flux_SN_opsim,
'LSST::' + filtre, 25, 'ab'))
table_for_fit['error_through'].add_row(
(time_obs, flux_SN, err_flux_SN_through,
'LSST::' + filtre, 25, 'ab'))
#print 'Getting fluxes and errors',time.time()-self.thetime,filtre,nobs
else:
err_flux_SN = -999.
err_flux_SN_opsim = -999.
myobservations['mag_SN'][nobs] = -999
myobservations['flux'][nobs] = flux_SN
myobservations['err_flux'][nobs] = -999.
myobservations['err_flux_opsim'][nobs] = -999.
myobservations['err_flux_through'][nobs] = -999.
myobservations['m5_calc'][nobs] = -999.
myobservations['snr_m5_through'][nobs] = -999
myobservations['snr_m5_opsim'][nobs] = -999
myobservations['gamma_through'][nobs] = -999
myobservations['gamma_opsim'][nobs] = -999
myobservations['snr_SED'][nobs] = -999
#print 'flux SN',flux_SN,err_flux_SN,mag_SN,snr_SN,snr_m5_through,snr_m5_opsim
#t.add_row((time,flux_SN,err_flux_SN,'LSST::'+filtre,0.,'vega'))
#break
#t = Table([list(data['time']), list(data['band']),data['flux'],data['fluxerr'],data['flux_aero'],data['fluxerr_aero'],data['fluxerr_new'],data['zp'],data['zpsys']], names=('time','band','flux','fluxerr','flux_aero','fluxerr_aero','fluxerr_new','zp','zpsys'), meta={'name': 'first table'})
#model.set(z=0.5)
#print SN.SN
myobservations = np.resize(myobservations, (nobs + 1, 1))
#print 'there obs',myobservations
#print 'Getting coadds',time.time()-self.thetime
for band in ['u', 'g', 'r', 'i', 'z', 'y']:
#sela=table_for_fit['error_calc'][np.where(table_for_fit['error_calc']['band']=='LSST::'+band)]
#sela=sela[np.where(np.logical_and(sela['flux']/sela['fluxerr']>5.,sela['flux']>0.))]
selb = table_for_fit['error_opsim'][np.where(
table_for_fit['error_opsim']['band'] == 'LSST::' + band)]
#selb=selb[np.where(np.logical_and(selb['flux']/selb['fluxerr']>5.,selb['flux']>0.))]
selc = table_for_fit['error_through'][np.where(
table_for_fit['error_through']['band'] == 'LSST::' + band)]
#table_for_fit['error_coadd_calc']=vstack([table_for_fit['error_coadd_calc'],self.Get_coadd(sela)])
table_for_fit['error_coadd_opsim'] = vstack(
[table_for_fit['error_coadd_opsim'],
self.Get_coadd(selb)])
table_for_fit['error_coadd_through'] = vstack(
[table_for_fit['error_coadd_through'],
self.Get_coadd(selc)])
#print 'There we go fitting',time.time()-self.thetime
dict_fit = {}
#for val in ['error_calc','error_coadd_calc','error_opsim','error_coadd_opsim']:
for val in ['error_coadd_opsim', 'error_coadd_through']:
dict_fit[val] = {}
dict_fit[val]['sncosmo_fitted'] = {}
dict_fit[val]['table_for_fit'] = table_for_fit[val]
#print 'fit',val,time.time()-self.thetime
res, fitted_model, mbfit, fit_status = self.Fit_SN(
table_for_fit[val], zmin, zmax)
if res is not None:
dict_fit[val]['sncosmo_res'] = res
#self.dict_fit[val]['fitted_model']=fitted_model
for i, par in enumerate(fitted_model.param_names):
dict_fit[val]['sncosmo_fitted'][
par] = fitted_model.parameters[i]
dict_fit[val]['mbfit'] = mbfit
dict_fit[val]['fit_status'] = fit_status
return dict_fit, mbsim, myobservations
def process_agn_chunk(chunk, filter_obs, mjd_obs, m5_obs,
coadd_m5, m5_single,
obs_md_list, proper_chip, out_data,
lock):
t_start_chunk = time.time()
#print('processing %d' % len(chunk))
ct_first = 0
ct_at_all = 0
ct_tot = 0
n_t = len(filter_obs)
n_obj = len(chunk)
agn_model = ExtraGalacticVariabilityModels()
dust_model = EBVbase()
with h5py.File('data/ebv_grid.h5', 'r') as in_file:
ebv_grid = in_file['ebv_grid'].value
extinction_grid = in_file['extinction_grid'].value
coadd_visits = {}
coadd_visits['u'] = 6
coadd_visits['g'] = 8
coadd_visits['r'] = 18
coadd_visits['i'] = 18
coadd_visits['z'] = 16
coadd_visits['y'] = 16
gamma_coadd = {}
for bp in 'ugrizy':
gamma_coadd[bp] = None
gamma_single = {}
for bp in 'ugrizy':
gamma_single[bp] = [None]*n_t
params = {}
params['agn_sfu'] = chunk['agn_sfu']
params['agn_sfg'] = chunk['agn_sfg']
params['agn_sfr'] = chunk['agn_sfr']
params['agn_sfi'] = chunk['agn_sfi']
params['agn_sfz'] = chunk['agn_sfz']
params['agn_sfy'] = chunk['agn_sfy']
params['agn_tau'] = chunk['agn_tau']
params['seed'] = chunk['id']+1
ebv = dust_model.calculateEbv(equatorialCoordinates=np.array([np.radians(chunk['ra']),
np.radians(chunk['dec'])]),
interp=True)
for i_bp, bp in enumerate('ugrizy'):
extinction_values = np.interp(ebv, ebv_grid, extinction_grid[i_bp])
chunk['%s_ab' % bp] += extinction_values
chunk['AGNLSST%s' % bp] += extinction_values
dmag = agn_model.applyAgn(np.where(np.array([True]*len(chunk))),
params, mjd_obs,
redshift=chunk['redshift'])
dmag_mean = np.mean(dmag, axis=2)
assert dmag_mean.shape == (6,n_obj)
dummy_sed = Sed()
lsst_bp = BandpassDict.loadTotalBandpassesFromFiles()
flux_gal = np.zeros((6,n_obj), dtype=float)
flux_agn_q = np.zeros((6,n_obj), dtype=float)
flux_coadd = np.zeros((6,n_obj), dtype=float)
mag_coadd = np.zeros((6,n_obj), dtype=float)
snr_coadd = np.zeros((6,n_obj), dtype=float)
snr_single = {}
snr_single_mag_grid = np.arange(14.0, 30.0, 0.05)
phot_params_single = PhotometricParameters(nexp=1,
exptime=30.0)
t_start_snr = time.time()
for i_bp, bp in enumerate('ugrizy'):
phot_params_coadd = PhotometricParameters(nexp=1,
exptime=30.0*coadd_visits[bp])
flux_gal[i_bp] = dummy_sed.fluxFromMag(chunk['%s_ab' % bp])
flux_agn_q[i_bp] = dummy_sed.fluxFromMag(chunk['AGNLSST%s' % bp] +
dmag_mean[i_bp,:])
flux_coadd[i_bp] = flux_gal[i_bp]+flux_agn_q[i_bp]
mag_coadd[i_bp] = dummy_sed.magFromFlux(flux_coadd[i_bp])
(snr_coadd[i_bp],
gamma) = SNR.calcSNR_m5(mag_coadd[i_bp],
lsst_bp[bp],
coadd_m5[bp],
phot_params_coadd)
(snr_single[bp],
gamma) = SNR.calcSNR_m5(snr_single_mag_grid,
lsst_bp[bp],
m5_single[bp],
phot_params_single)
#print('got all snr in %e' % (time.time()-t_start_snr))
t_start_obj = time.time()
photometry_mask = np.zeros((n_obj, n_t), dtype=bool)
photometry_mask_1d = np.zeros(n_obj, dtype=bool)
snr_arr = np.zeros((n_obj, n_t), dtype=float)
for i_bp, bp in enumerate('ugrizy'):
valid_obs = np.where(filter_obs==i_bp)
n_bp = len(valid_obs[0])
if n_bp == 0:
continue
mag0_arr = chunk['AGNLSST%s' % bp]
dmag_bp = dmag[i_bp][:,valid_obs[0]]
assert dmag_bp.shape == (n_obj, n_bp)
agn_flux_tot = dummy_sed.fluxFromMag(mag0_arr[:,None]+dmag_bp)
q_flux = flux_agn_q[i_bp]
agn_dflux = np.abs(agn_flux_tot-q_flux[:,None])
flux_tot = flux_gal[i_bp][:, None] + agn_flux_tot
assert flux_tot.shape == (n_obj, n_bp)
mag_tot = dummy_sed.magFromFlux(flux_tot)
snr_single_val = np.interp(mag_tot,
snr_single_mag_grid,
snr_single[bp])
noise_coadd = flux_coadd[i_bp]/snr_coadd[i_bp]
noise_single = flux_tot/snr_single_val
noise = np.sqrt(noise_coadd[:,None]**2 + noise_single**2)
dflux_thresh = 5.0*noise
detected = (agn_dflux>=dflux_thresh)
assert detected.shape == (n_obj, n_bp)
snr_arr[:,valid_obs[0]] = agn_dflux/noise
for i_obj in range(n_obj):
if detected[i_obj].any():
photometry_mask_1d[i_obj] = True
photometry_mask[i_obj, valid_obs[0]] = detected[i_obj]
t_before_chip = time.time()
chip_mask = apply_focal_plane(chunk['ra'], chunk['dec'],
photometry_mask_1d, obs_md_list,
filter_obs, proper_chip)
duration = (time.time()-t_before_chip)/3600.0
unq_out = -1*np.ones(n_obj, dtype=int)
mjd_out = -1.0*np.ones(n_obj, dtype=float)
snr_out = -1.0*np.ones(n_obj, dtype=float)
for i_obj in range(n_obj):
if photometry_mask_1d[i_obj]:
detected = photometry_mask[i_obj,:] & chip_mask[i_obj,:]
if detected.any():
unq_out[i_obj] = chunk['galtileid'][i_obj]
first_dex = np.where(detected)[0].min()
mjd_out[i_obj] = mjd_obs[first_dex]
snr_out[i_obj] = snr_arr[i_obj, first_dex]
valid = np.where(unq_out>=0)
unq_out = unq_out[valid]
mjd_out = mjd_out[valid]
snr_out = snr_out[valid]
with lock:
existing_keys = list(out_data.keys())
if len(existing_keys) == 0:
key_val = 0
else:
key_val = max(existing_keys)
while key_val in existing_keys:
key_val += 1
out_data[key_val] = (None, None, None)
out_data[key_val] = (unq_out, mjd_out, snr_out)
