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)