def testVerboseSNR(self):
"""
Make sure that calcSNR_sed has everything it needs to run in verbose mode
"""
photParams = PhotometricParameters()
# create a cartoon spectrum to test on
spectrum = Sed()
spectrum.setFlatSED()
spectrum.multiplyFluxNorm(1.0e-9)
snr.calcSNR_sed(spectrum, self.bpList[0], self.skySed,
self.hardwareList[0], photParams, FWHMeff=0.7, verbose=True)
def testVerboseSNR(self):
"""
Make sure that calcSNR_sed has everything it needs to run in verbose mode
"""
defaults = LSSTdefaults()
photParams = PhotometricParameters()
#create a cartoon spectrum to test on
spectrum = Sed()
spectrum.setFlatSED()
spectrum.multiplyFluxNorm(1.0e-9)
snr.calcSNR_sed(spectrum, self.bpList[0], self.skySed,
self.hardwareList[0], photParams, seeing=0.7, verbose=True)
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 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 = [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 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 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 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
FWHM_Atm = seeing * Filter_Wavelength_Correction * Airmass_Correction
finSeeing = scaleToNeff * math.sqrt(
np.power(FWHM_Sys, 2) + atmNeffFactor * np.power(FWHM_Atm, 2))
#print 'flux_SN',band,flux_SN
if flux_SN > 0:
mag_SN = -2.5 * np.log10(flux_SN)
plt.show()
FWHMeff = SignalToNoise.FWHMgeom2FWHMeff(finSeeing)
photParams = PhotometricParameters()
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)
