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
