def get_SED(self, time): if self.sn_type == 'Ia': if self.model == 'salt2' and self.version == '2.4': model_min = 2000. model_max = 9200.0 wave_min = model_min * (1. + self.z) wave_max = model_max * (1. + self.z) if self.model == 'salt2-extended': model_min = 300. model_max = 180000. wave_min = 3000. wave_max = 11501. wave = np.arange(wave_min, wave_max, 1.) self.fluxes = 10. * self.SN.flux(time, wave) self.wavelength = wave / 10. #SED_time = 10.*self.SN.flux(time,wave) #print 'hohoho',len(self.wavelength),len(self.fluxes),type(self.wavelength) wavelength = np.repeat(self.wavelength[np.newaxis, :], len(self.fluxes), 0) #print 'hrlll',len(wavelength),type(wavelength[0]) SED_time = Sed(wavelen=wavelength, flambda=self.fluxes) """ ax, bx = self.SEDfromSNcosmo.setupCCMab() self.SEDfromSNcosmo.addCCMDust(a_x=ax, b_x=bx, ebv=self.ebvofMW) """ else: wave_min = 3000. wave_max = 11501. wave = np.arange(wave_min, wave_max, 1.) #print 'getting the flux' self.fluxes = 10. * self.SN.flux(time, wave) self.wavelength = wave / 10. #SED_time = Sed(wavelen=self.wavelength, flambda=self.fluxes/np.power(self.lumidist,2.)) #/np.power(self.lumidist,2.)) SED_time = Sed(wavelen=self.wavelength, flambda=self.fluxes) """ a=1./(1.+self.z) phase=(time-self.t0)*a restwave=wave*a flambda=self.SED_template(phase, restwave)[0] #print 'alors',len(wave),len(flambda),flambda SED_time=Sed(wavelen=wave/10., flambda=10.*a*flambda /np.power(self.lumidist,2.)) """ return SED_time
def testFluxListForSedList(self): """ Test that fluxListForSedList calculates the correct fluxes """ nBandpasses = 7 bpNameList, bpList = self.getListOfBandpasses(nBandpasses) testBpDict = BandpassDict(bpList, bpNameList) nSed = 20 sedNameList = self.getListOfSedNames(nSed) magNormList = self.rng.random_sample(nSed)*5.0 + 15.0 internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1 redshiftList = self.rng.random_sample(nSed)*5.0 galacticAvList = self.rng.random_sample(nSed)*0.3 + 0.1 # first, test on an SedList without a wavelenMatch testSedList = SedList(sedNameList, magNormList, fileDir=self.sedDir, internalAvList=internalAvList, redshiftList=redshiftList, galacticAvList=galacticAvList) fluxList = testBpDict.fluxListForSedList(testSedList) self.assertEqual(fluxList.shape[0], nSed) self.assertEqual(fluxList.shape[1], nBandpasses) for ix, sedObj in enumerate(testSedList): dummySed = Sed(wavelen=copy.deepcopy(sedObj.wavelen), flambda=copy.deepcopy(sedObj.flambda)) for iy, bp in enumerate(testBpDict): flux = dummySed.calcFlux(bpList[iy]) self.assertAlmostEqual(flux/fluxList[ix][iy], 1.0, 2) # now use wavelenMatch testSedList = SedList(sedNameList, magNormList, fileDir=self.sedDir, internalAvList=internalAvList, redshiftList=redshiftList, galacticAvList=galacticAvList, wavelenMatch=testBpDict.wavelenMatch) fluxList = testBpDict.fluxListForSedList(testSedList) self.assertEqual(fluxList.shape[0], nSed) self.assertEqual(fluxList.shape[1], nBandpasses) for ix, sedObj in enumerate(testSedList): dummySed = Sed(wavelen=copy.deepcopy(sedObj.wavelen), flambda=copy.deepcopy(sedObj.flambda)) for iy, bp in enumerate(testBpDict): flux = dummySed.calcFlux(bpList[iy]) self.assertAlmostEqual(flux/fluxList[ix][iy], 1.0, 2)
def Get_SED_Restframe(self, Sed_time): a = 1. / (1. + self.z) bandpass_besselb = Bandpass( wavelen=sncosmo.get_bandpass('bessellB').wave, sb=sncosmo.get_bandpass('bessellB').trans) print 'before', Sed_time.wavelen, Sed_time.flambda #print 'there we go',Sed_time.wavelen,Sed_time.flambda SED_rest = Sed(wavelen=Sed_time.wavelen * a * 10., flambda=Sed_time.flambda * np.power(self.lumidist, 2.) / a / 10. / HC_ERG_AA) print 'hello', Sed_time.wavelen * a * 10, Sed_time.flambda * np.power( self.lumidist, 2.) / a / 10. / HC_ERG_AA print 'heelp', SED_rest.wavelen, SED_rest.flambda SED_new = Sed(wavelen=SED_rest.wavelen / a, flambda=a * SED_rest.flambda / np.power(self.lumidist, 2.)) #print 'ici',SED_new.wavelen,SED_new.flambda #estimate the flux in the B band bessellb flux_B_rest = SED_rest.calcFlux(bandpass=bandpass_besselb) flux_B_new = SED_new.calcFlux(bandpass=bandpass_besselb) #now the magnitudes (apparent and absolute) vega_SED = Sed() vega_SED.readSED_flambda('vega.txt') flux_vega = vega_SED.calcFlux(bandpass=bandpass_besselb) mag_B_rest = -2.5 * np.log10(flux_B_rest / flux_vega) mag_B_new = -2.5 * np.log10(flux_B_new / 3631.) print 'hello', len(vega_SED.wavelen), len(vega_SED.flambda), len( bandpass_besselb.sb), flux_vega, flux_B_rest bwave = bandpass_besselb.wavelen btrans = bandpass_besselb.sb vega_wave = vega_SED.wavelen vega_flambda = vega_SED.flambda mask = ((vega_wave > bwave[0]) & (vega_wave < bwave[-1])) d = vega_wave[mask] f = vega_flambda[mask] trans = np.interp(d, bwave, btrans) binw = np.gradient(d) ftot = np.sum(f * trans * binw) print 'vega flux', flux_vega, ftot return SED_rest, mag_B_rest, mag_B_new
def testMagArrayForSedList(self): """ Test that magArrayForSedList calculates the correct magnitude """ nBandpasses = 7 bpNameList, bpList = self.getListOfBandpasses(nBandpasses) testBpDict = BandpassDict(bpList, bpNameList) nSed = 20 sedNameList = self.getListOfSedNames(nSed) magNormList = self.rng.random_sample(nSed)*5.0 + 15.0 internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1 redshiftList = self.rng.random_sample(nSed)*5.0 galacticAvList = self.rng.random_sample(nSed)*0.3 + 0.1 # first, test on an SedList without a wavelenMatch testSedList = SedList(sedNameList, magNormList, fileDir=self.sedDir, internalAvList=internalAvList, redshiftList=redshiftList, galacticAvList=galacticAvList) magArray = testBpDict.magArrayForSedList(testSedList) for ix, sedObj in enumerate(testSedList): dummySed = Sed(wavelen=copy.deepcopy(sedObj.wavelen), flambda=copy.deepcopy(sedObj.flambda)) for iy, bp in enumerate(bpNameList): mag = dummySed.calcMag(bpList[iy]) self.assertAlmostEqual(mag, magArray[bp][ix], 2) # now use wavelenMatch testSedList = SedList(sedNameList, magNormList, fileDir=self.sedDir, internalAvList=internalAvList, redshiftList=redshiftList, galacticAvList=galacticAvList, wavelenMatch=testBpDict.wavelenMatch) magArray = testBpDict.magArrayForSedList(testSedList) for ix, sedObj in enumerate(testSedList): dummySed = Sed(wavelen=copy.deepcopy(sedObj.wavelen), flambda=copy.deepcopy(sedObj.flambda)) for iy, bp in enumerate(bpNameList): mag = dummySed.calcMag(bpList[iy]) self.assertAlmostEqual(mag, magArray[bp][ix], 2)
def Calc_m5(self, filtre): filtre_trans = self.system[filtre] wavelen_min, wavelen_max, wavelen_step = filtre_trans.getWavelenLimits( None, None, None) bandpass = Bandpass(wavelen=filtre_trans.wavelen, sb=filtre_trans.sb) flatSedb = Sed() flatSedb.setFlatSED(wavelen_min, wavelen_max, wavelen_step) flux0b = np.power(10., -0.4 * self.mag_sky[filtre]) flatSedb.multiplyFluxNorm(flux0b) photParams = PhotometricParameters(bandpass=filtre) norm = photParams.platescale**2 / 2. * photParams.exptime / photParams.gain if self.atmos: self.data['m5'][filtre] = SignalToNoise.calcM5( flatSedb, self.atmosphere[filtre], self.system[filtre], photParams=photParams, FWHMeff=self.FWHMeff[filtre]) adu_int = flatSedb.calcADU(bandpass=self.atmosphere[filtre], photParams=photParams) self.data['flux_sky'][filtre] = adu_int * norm else: self.data['m5'][filtre] = SignalToNoise.calcM5( flatSedb, self.system[filtre], self.system[filtre], photParams=photParams, FWHMeff=self.FWHMeff[filtre]) adu_int = flatSedb.calcADU(bandpass=self.system[filtre], photParams=photParams) self.data['flux_sky'][filtre] = adu_int * norm
def ZP_filtre(self, filtre): photParams = PhotometricParameters(bandpass=filtre) Diameter = 2. * np.sqrt( photParams.effarea * 1.e-4 / np.pi) # diameter in meter Cte = 3631. * np.pi * Diameter**2 * 2. * photParams.exptime / 4 / h / 1.e36 #print('hello Cte',Cte,Diameter,h,photParams.exptime) self.data['Skyb'][filtre] = Cte * np.power( Diameter / 6.5, 2.) * np.power( 2. * photParams.exptime / 30., 2.) * np.power( photParams.platescale, 2.) * np.power( 10., 0.4 * (25. - self.mag_sky[filtre])) * self.Sigmab[filtre] Zb = 181.8 * np.power(Diameter / 6.5, 2.) * self.Tb[filtre] mbZ = 25. + 2.5 * np.log10(Zb) filtre_trans = self.system[filtre] wavelen_min, wavelen_max, wavelen_step = filtre_trans.getWavelenLimits( None, None, None) bandpass = Bandpass(wavelen=filtre_trans.wavelen, sb=filtre_trans.sb) flatSed = Sed() flatSed.setFlatSED(wavelen_min, wavelen_max, wavelen_step) flux0 = np.power(10., -0.4 * mbZ) flatSed.multiplyFluxNorm(flux0) photParams = PhotometricParameters(bandpass=filtre) counts = flatSed.calcADU( bandpass, photParams=photParams) #number of counts for exptime self.data['zp'][filtre] = mbZ #print 'hello',counts/self.photParams.exptime self.data['counts_zp'][filtre] = counts / 2. * photParams.exptime
def magListForSed(self, sedobj, indices=None): """ Return a list of magnitudes for a single Sed object. @param [in] sedobj is an Sed object. Its wavelength grid can be arbitrary. If necessary, a copy will be created and resampled onto the wavelength grid of the Bandpasses before magnitudes are calculated. The original Sed will be unchanged. @param [in] indices is an optional list of indices indicating which bandpasses to actually calculate magnitudes for. Other magnitudes will be listed as numpy.NaN (i.e. this method will return as many magnitudes as were loaded with the loadBandpassesFromFiles methods; it will just return numpy.NaN for magnitudes you did not actually ask for) @param [out] magList is a list of magnitudes in the bandpasses stored in this BandpassDict """ if sedobj.wavelen is not None: # If the Sed's wavelength grid agrees with self._wavelen_match to one part in # 10^6, just use the Sed as-is. Otherwise, copy it and resample it onto # self._wavelen_match if sedobj._needResample(wavelen_match=self._wavelen_match): dummySed = Sed(wavelen=sedobj.wavelen, flambda=sedobj.flambda) dummySed.resampleSED( force=True, wavelen_match=self._bandpassDict.values()[0].wavelen) else: dummySed = sedobj return numpy.array(self._magListForSed(dummySed, indices=indices)) else: return numpy.array([numpy.NaN] * len(self._bandpassDict))
def mCalcs(airmass, bandName, ra, dec, expMJD, FWHMeff, hwbpdict, photparams=None, sm=None): """ sm : """ if photparams is None: photparams = PhotometricParameters() if sm is None: sm = SkyModel(observatory='LSST', mags=False, preciseAltAz=True) # Obtain full sky transmission at airmass # Note that this method is not interpolating but choosing the atmospheric transmission from # Modtran simulations of the closest airmass in a sequence of np.arange(1., 2.51, 0.1) fname = atmTransName(airmass) print(fname) atmTrans = np.loadtxt(fname) wave, trans = hwbpdict[bandName].multiplyThroughputs(atmTrans[:, 0], atmTrans[:, 1]) bp = Bandpass(wavelen=wave, sb=trans) # Set the observing condition sm.setRaDecMjd(lon=[ra], lat=[dec], filterNames=[bandName], mjd=expMJD, degrees=False, azAlt=False) # Get the sky sed wave, spec = sm.returnWaveSpec() sed = Sed(wavelen=wave, flambda=spec[0]) sed.writeSED('skySED_laptop.csv') m5 = calcM5(sed, bp, hwbpdict[bandName], photparams, FWHMeff) # Get the sky magnitude only in the band concerned m = sm.returnMags(bandpasses=hwbpdict)[bandName][0] return m5, m
def CalcMyABMagnitude_filter(self, band): """ CalcMyABMagnitudes_filter() - author : Sylvie Dagoret-Campagne - affiliation : LAL/IN2P3/CNRS/FRANCE - date : July 4th 2018 Calculate the magnitude in AB system unit for all bands. """ filter = self.lsst_atmos[band] # resample the wavelength each time for the filter wl, fnu = self.sed.getSED_fnu() wavelen, fnu = self.sed.resampleSED(wl, fnu, wavelen_match=filter.wavelen) fnu = np.nan_to_num( fnu) # SDC(29/06/18) reset to 0 out of band where there are nan self.sed = Sed(wavelen=wavelen, fnu=fnu, name=self.sed.name) mag1 = -2.5 * np.log10(self.Calc_Integ_Sed(self.sed, filter)) mag2 = -2.5 * np.log10(self.Calc_Integ_Sed(self.sedAB0, filter)) mag3 = self.sed.calcMag(bandpass=filter, wavelen=wavelen, fnu=fnu) #print('CalcMyABMagnitude_filter :: band = {}, mag1={} , mag2={} , deltaM(me)={}, mag3(lsst)={}'.format(band,mag1,mag2,mag1-mag2,mag3)) return mag3
def __init__(self, metricName='plasticc_transient', mjdCol='observationStartMJD', m5Col='fiveSigmaDepth', filterCol='filter', color_gap=0.5, pre_slope_range=0.3, days_around_peak=200, r_mag_limit=28, nbins=10, nsamples=5, maps=['DustMap'], apply_dust=True, units='fraction', **kwargs): self.mjdCol = mjdCol self.m5Col = m5Col self.filterCol = filterCol self.color_gap = color_gap self.pre_slope_range = pre_slope_range self.days_around_peak = days_around_peak self.rmag_limit = r_mag_limit self.nbins = nbins self.nsamples = nsamples self.apply_dust = apply_dust super(Plasticc_metric, self).__init__(col=[self.mjdCol, self.m5Col, self.filterCol], metricName=metricName, maps=maps, units=units, **kwargs) # Let's set up the dust stuff waveMins = {'u': 330., 'g': 403., 'r': 552., 'i': 691., 'z': 818., 'y': 950.} waveMaxes = {'u': 403., 'g': 552., 'r': 691., 'i': 818., 'z': 922., 'y': 1070.} self.a_extinc = {} self.b_extinc = {} for filtername in waveMins: testsed = Sed() testsed.setFlatSED(wavelen_min=waveMins[filtername], wavelen_max=waveMaxes[filtername], wavelen_step=1) self.a_extinc[filtername], self.b_extinc[filtername] = testsed.setupCCM_ab() self.R_v = 3.1
def __call__(self, filter_name='u', magNorm=None): """ This method calls the SkyCountsPerSec object and calculates the sky counts. @param [in] filter_name is a string that indicates the name of the filter for which to make the calculation. @param [in] magNorm is an option to calculate the sky counts for a given magnitude. When calculating the counts from just the information in skyModel this should be set as MagNorm=None. """ bandpass = self.bandpassdic[filter_name] wave, spec = self.skyModel.returnWaveSpec() skymodel_Sed = Sed(wavelen=wave, flambda=spec[0, :]) if magNorm: skymodel_fluxNorm = skymodel_Sed.calcFluxNorm(magNorm, bandpass) skymodel_Sed.multiplyFluxNorm(skymodel_fluxNorm) sky_counts = skymodel_Sed.calcADU(bandpass=bandpass, photParams=self.photParams) expTime = self.photParams.nexp * self.photParams.exptime * u.s sky_counts_persec = sky_counts * 0.2**2 / expTime return sky_counts_persec
def _fluxes(sed_name, mag_norm, redshift): """ Find the fluxes for a galaxy component Parameters ---------- sed_name is an SED file name mag_norm is a float redshift is a float Returns ------- array of fluxes in ugrizy order """ if not hasattr(_fluxes, '_bp_dict'): bp_dir = getPackageDir('throughputs') bp_dir = os.path.join(bp_dir, 'imsim', 'goal') _fluxes._bp_dict = BandpassDict.loadTotalBandpassesFromFiles( bandpassDir=bp_dir) _fluxes._sed_dir = getPackageDir('sims_sed_library') spec = Sed() full_sed_name = os.path.join(_fluxes._sed_dir, sed_name) if not os.path.isfile(full_sed_name): full_sed_name = os.path.join(_fluxes._sed_dir, defaultSpecMap[sed_name]) spec.readSED_flambda(full_sed_name) fnorm = getImsimFluxNorm(spec, mag_norm) spec.multiplyFluxNorm(fnorm) spec.redshiftSED(redshift, dimming=True) return _fluxes._bp_dict.fluxListForSed(spec)
def __init__(self, metricName='TDEsPopMetric', mjdCol='observationStartMJD', m5Col='fiveSigmaDepth', filterCol='filter', nightCol='night', ptsNeeded=2, file_list=None, mjd0=59853.5, **kwargs): maps = ['DustMap'] self.mjdCol = mjdCol self.m5Col = m5Col self.filterCol = filterCol self.nightCol = nightCol self.ptsNeeded = ptsNeeded self.lightcurves = Tde_lc(file_list=file_list) self.mjd0 = mjd0 waveMins = {'u': 330., 'g': 403., 'r': 552., 'i': 691., 'z': 818., 'y': 950.} waveMaxes = {'u': 403., 'g': 552., 'r': 691., 'i': 818., 'z': 922., 'y': 1070.} self.a = {} self.b = {} for filtername in waveMins.keys(): testsed = Sed() testsed.setFlatSED(wavelen_min=waveMins[filtername], wavelen_max=waveMaxes[filtername], wavelen_step=1) self.a[filtername], self.b[filtername] = testsed.setupCCM_ab() self.R_v = 3.1 cols = [self.mjdCol, self.m5Col, self.filterCol, self.nightCol] super(TdePopMetric, self).__init__(col=cols, units='Detected, 0 or 1', metricName=metricName, maps=maps, **kwargs)
def fiveSigmaDepth(self, bandName, FWHMeff, ra=None, dec=None, mjd=None, sm=None, provided_airmass=None, use_provided_airmass=True): """ """ if sm is None: sm = self.sm if ra is not None: sm.setRaDecMjd(lon=ra, lat=dec, filterNames=bandName, mjd=mjd, degrees=False, azAlt=False) airmass = sm.airmass # SED wave, spec = sm.returnWaveSpec() sed = Sed(wavelen=wave, flambda=spec[0]) amass = airmass if use_provided_airmass and provided_airmass is not None: amass = provided_airmass else: amass = airmass bp = self.adb.bandpassForAirmass(bandName, amass) fieldmags = calcM5(sed, bp, self.adb.hwbandpassDict[bandName], self.photparams, FWHMeff) return fieldmags