def model_for_fit(self): #print 'there man, to fit' dust = sncosmo.OD94Dust() self.fit_model = 'salt2-extended' self.fit_version = '1.0' source = sncosmo.get_source(self.fit_model, version=self.fit_version) self.SN_fit_model = sncosmo.Model(source=source, effects=[dust, dust], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) self.SN_fit_model.set(z=self.z) self.SN_fit_model.set_source_peakabsmag(self.peakAbsMagBesselB, 'bessellB', 'vega', cosmo=cosmology.WMAP9) self.lsstmwebv = EBVbase() self.ebvofMW = self.lsstmwebv.calculateEbv( equatorialCoordinates=np.array([[np.radians(self.radeg)], [np.radians(self.decdeg)]]))[0] self.SN_fit_model.set(mwebv=self.ebvofMW) self.SN_fit_model.set(mwebv=0.)
def Plot_LC(lc,sn): dust = sncosmo.OD94Dust() fitted_model=sncosmo.Model(source='salt2-extended', effects=[dust, dust], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) fitted_model.set(z=sn['z']) fitted_model.set(t0=sn['salt2.T0']) fitted_model.set(x0=sn['salt2.X0']) fitted_model.set(x1=sn['salt2.X1']) fitted_model.set(c=sn['salt2.Color']) errors={} errors['t0']=np.sqrt(sn['salt2.CovT0T0']) errors['x0']=np.sqrt(sn['salt2.CovX0X0']) errors['x1']=np.sqrt(sn['salt2.CovX1X1']) errors['c']=np.sqrt(sn['salt2.CovColorColor']) print 'Phases : first',(lc['time'][0]-sn['salt2.T0'])/(1.+sn['z']),'last',(lc['time'][-1]-sn['salt2.T0'])/(1.+sn['z']) """ res, fitted_modelb = sncosmo.fit_lc(lc, fitted_model,['t0', 'x0', 'x1', 'c'],bounds={'z':(sn['z']-0.001, sn['z']+0.001)}) print 'ooo',res.errors print 'bbb',errors """ sncosmo.plot_lc(lc, model=fitted_model,pulls=True)
def __init__(self, model='salt2-extended', version='1.0', z=0.1, telescope=None, Plot=False, bands='ugrizy'): self.Plot = Plot #transmission=telescope.throughputs self.z = z #bands=[b[-1:] for b in np.unique(select['band'])] self.model = model self.version = version #print 'hello',bands,telescope.airmass """ for filtre in bands: if telescope.airmass > 0: band=sncosmo.Bandpass(transmission.atmosphere[filtre].wavelen,transmission.atmosphere[filtre].sb, name='LSST::'+filtre,wave_unit=u.nm) else: band=sncosmo.Bandpass(transmission.system[filtre].wavelen,transmission.system[filtre].sb, name='LSST::'+filtre,wave_unit=u.nm) sncosmo.registry.register(band, force=True) """ source = sncosmo.get_source(model, version=version) dust = sncosmo.OD94Dust() self.SN_fit_model = sncosmo.Model(source=source) self.SN_fit_model.set(z=self.z)
def extinction(self, eb_v, dust_law, r_v=3.1): """ Given eb-v and r-v return the dust extinction in a particular BAND It can use: Cardelli dust law (CCM), ODonneal (OD94) Fitzpatrick (F99) KEEP IN MIND: _minwave = 909.09 _maxwave = 33333.33 """ if dust_law == 'OD94': dust = sncosmo.OD94Dust() elif dust_law == 'CCM': dust = sncosmo.CCM89Dust() elif dust_law == 'F99': dust = sncosmo.F99Dust() else: print('Add this dust law! I dont know it') dust.parameters = [eb_v, r_v] w = self.wave t = self.transmission ext = dust.propagate(w, t) correction_extinction = np.trapz((ext)[1:-1], w[1:-1]) / np.trapz( (t)[1:-1], w[1:-1]) return correction_extinction
def Fit(self): #print self.table_for_fit t=self.table_for_fit select=t[np.where(np.logical_and(t['flux']/t['fluxerr']>5.,t['flux']>0.))] idx=select['band']!='LSST::u' select=select[idx] if self.z > 0.35: idx=select['band']!='LSST::g' select=select[idx] for filtre in bands: band=sncosmo.Bandpass(self.transmission.atmosphere[filtre].wavelen, self.transmission.atmosphere[filtre].sb, name='LSST::'+filtre,wave_unit=u.nm) sncosmo.registry.register(band, force=True) source=sncosmo.get_source(self.model,version=self.version) dust = sncosmo.OD94Dust() """ SN_fit_model=sncosmo.Model(source=source,effects=[dust, dust], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) """ SN_fit_model=sncosmo.Model(source=source) SN_fit_model.set(z=self.z) SN_fit_model.set_source_peakabsmag(self.peakAbsMagBesselB, 'bessellB', 'vega',cosmo=self.astropy_cosmo) """ lsstmwebv = EBVbase() ebvofMW = lsstmwebv.calculateEbv( equatorialCoordinates=np.array([[np.radians(self.radeg)], [np.radians(self.decdeg)]]))[0] SN_fit_model.set(mwebv=ebvofMW) """ z_sim=self.z self.sigma_c=0. try: res, fitted_model = sncosmo.fit_lc(select, SN_fit_model,['t0', 'x0', 'x1', 'c'],bounds={'z':(z_sim-0.1, z_sim+0.1)}) self.sigma_c=res['errors']['c'] """ print z_sim,self.sigma_c if z_sim>=0.409 and z_sim<0.411: sncosmo.plot_lc(select, model=fitted_model,color='k',pulls=True,errors=res.errors) plt.show() """ except (RuntimeError, TypeError, NameError): print 'crashed' for sel in select: print sel print self.z self.Plot_bands(select) plt.show() print 'crashed'
def mkcirclepoints(z=2.0, avrange=[0.0, 2.0], colorselect=[0, 1], source='hsiao', **plotargs): import numpy as np from matplotlib import pyplot as pl from mpltools import color from matplotlib import cm import sncosmo from sncosmohst import hstbandpasses, ccsnmodels # load the O'Donnell 1994 dust model dust = sncosmo.OD94Dust() sn = sncosmo.Model(source='hsiao', effects=[dust], effect_names=['host'], effect_frames=['rest']) avsteps = np.arange(avrange[0], avrange[1], 0.05) color.cycle_cmap(length=len(avsteps), cmap=cm.jet) f127m, f139m, f153m = [], [], [] f125w, f140w, f160w = [], [], [] for av in avsteps: sn.set(z=z, t0=0, hostr_v=3.1, hostebv=av / 3.1) f127m.append(sn.bandmag('wfc3f127m', 'ab', 0.)) f139m.append(sn.bandmag('wfc3f139m', 'ab', 0.)) f153m.append(sn.bandmag('wfc3f153m', 'ab', 0.)) f125w.append(sn.bandmag('wfc3f125w', 'ab', 0.)) f140w.append(sn.bandmag('wfc3f140w', 'ab', 0.)) f160w.append(sn.bandmag('wfc3f160w', 'ab', 0.)) med = np.array([f127m, f139m, f153m]) broad = np.array([f125w, f140w, f160w]) color = med - broad pl.plot(color[colorselect[0]], color[colorselect[1]], **plotargs) colorlabel = ['F127M-F125W', 'F139M-F140W', 'F153M-F160W'] ax = pl.gca() ax.set_xlabel(colorlabel[colorselect[0]]) ax.set_ylabel(colorlabel[colorselect[1]]) labelcolors = ['darkmagenta', 'teal', 'darkorange'] colorlabel = ['F127M-F125W', 'F139M-F140W', 'F153M-F160W'] ax = pl.gca() ax.set_xlabel(colorlabel[colorselect[0]], color=labelcolors[colorselect[0]]) ax.set_ylabel(colorlabel[colorselect[1]], color=labelcolors[colorselect[1]])
def equivalentSNCosmoModel(self): """ returns an SNCosmo Model which is equivalent to SNObject """ snState = self.SNstate dust = sncosmo.OD94Dust() sncosmoModel = sncosmo.Model(source=snState['ModelSource'], effects=[dust, dust], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) sncosmoParams = self.sncosmoParamDict(snState, sncosmoModel) sncosmoParams['mwebv'] = snState['MWE(B-V)'] sncosmoModel.set(**sncosmoParams) return sncosmoModel
def fromSNState(cls, snState): """ creates an instance of SNObject with a state described by snstate. Parameters ---------- snState: Dictionary summarizing the state of SNObject Returns ------- Instance of SNObject class with attributes set by snstate Example ------- """ # Separate into SNCosmo parameters and SNObject parameters dust = sncosmo.OD94Dust() sncosmoModel = sncosmo.Model(source=snState['ModelSource'], effects=[dust, dust], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) sncosmoParams = cls.sncosmoParamDict(snState, sncosmoModel) # Now create the class cls = SNObject(source=snState['ModelSource']) # Set the SNObject coordinate properties # Have to be careful to not convert `None` type objects to degrees setdec, setra = False, False if snState['_ra'] is not None: ra = np.degrees(snState['_ra']) setra = True if snState['_dec'] is not None: dec = np.degrees(snState['_dec']) setdec = True if setdec and setra: cls.setCoords(ra, dec) # Set the SNcosmo parameters cls.set(**sncosmoParams) # Set the ebvofMW by hand cls.ebvofMW = snState['MWE(B-V)'] return cls
def Plot_LC_sncosmo(table, telescope): print('What will be plotted', table) prefix = 'LSST::' print(table.dtype) for band in 'ugrizy': name_filter = prefix + band if telescope.airmass > 0: bandpass = sncosmo.Bandpass(telescope.atmosphere[band].wavelen, telescope.atmosphere[band].sb, name=name_filter, wave_unit=u.nm) else: bandpass = sncosmo.Bandpass(telescope.system[band].wavelen, telescope.system[band].sb, name=name_filter, wave_unit=u.nm) # print('registering',name_filter) sncosmo.registry.register(bandpass, force=True) source = sncosmo.get_source('salt2-extended', version='1.0') dust = sncosmo.OD94Dust() model = sncosmo.Model(source=source) print('metadata', table.meta) model.set(z=table.meta['z'], c=table.meta['Color'], t0=table.meta['DayMax'], x1=table.meta['X1']) z = table.meta['z'] tab = table[['flux', 'fluxerr', 'band', 'zp', 'zpsys', 'time']] res, fitted_model = sncosmo.fit_lc(tab, model, ['t0', 'x0', 'x1', 'c'], bounds={'z': (z - 0.001, z + 0.001)}) print(res) print('jjj', fitted_model) sncosmo.plot_lc(data=tab, model=fitted_model, errors=res['errors']) plt.draw() plt.pause(20.) plt.close()
def __init__(self, model='salt2-extended', version=1.0, telescope=None, display=False, bands='ugrizy'): self.display = display self.bands = bands # get the bands for sncosmo registration - with and without airmass for band in bands: if telescope.airmass > 0: band = sncosmo.Bandpass(telescope.atmosphere[band].wavelen, telescope.atmosphere[band].sb, name='LSST::' + band, wave_unit=u.nm) else: band = sncosmo.Bandpass(telescope.system[band].wavelen, telescope.system[band].sb, name='LSST::' + band, wave_unit=u.nm) sncosmo.registry.register(band, force=True) # get the source source = sncosmo.get_source(model, version=str(version)) # get the dust dust = sncosmo.OD94Dust() # sn_fit_model instance self.SN_fit_model = sncosmo.Model(source=source) # name parameters self.parNames = dict( zip(['z', 't0', 'x0', 'x1', 'c'], ['z', 't0', 'x0', 'x1', 'color']))
def __init__(self, ra=None, dec=None, source='salt2-extended'): """ Instantiate object Parameters ---------- ra : float ra of the SN in degrees dec : float dec of the SN in degrees source : instance of `sncosmo.SALT2Source`, optional, defaults to using salt2-extended source class to define the model """ dust = sncosmo.OD94Dust() sncosmo.Model.__init__(self, source=source, effects=[dust, dust], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) # Current implementation of Model has a default value of mwebv = 0. # ie. no extinction, but this is not part of the API, so should not # depend on it, set explicitly in order to unextincted SED from # SNCosmo. We will use catsim extinction from `lsst.sims.photUtils`. self.ModelSource = source self.set(mwebv=0.) # self._ra, self._dec is initialized as None for cases where ra, dec # is not provided self._ra = None self._dec = None # ra, dec is input in degrees # If provided, set _ra, _dec in radians self._hascoords = True if dec is None: self._hascoords = False if ra is None: self._hascoords = False # Satisfied that coordinates provided are floats if self._hascoords: self.setCoords(ra, dec) # For values of ra, dec, the E(B-V) is calculated directly # from DustMaps self.lsstmwebv = EBVbase() self.ebvofMW = None if self._hascoords: self.mwEBVfromMaps() # Behavior of model outside temporal range : # if 'zero' then all fluxes outside the temporal range of the model # are set to 0. self._modelOutSideTemporalRange = 'zero' # SED will be rectified to 0. for negative values of SED if this # attribute is set to True self.rectifySED = True return
def mksedplot(z=1.8, Av=0, color='k'): """ make a set of plots showing the SN Ia SED (Hsiao template) at various redshifts, with bandpasses overlaid. :return: """ import numpy as np import sncosmo from sncosmohst import hstbandpasses, ccsnmodels from matplotlib import pyplot as pl from matplotlib import ticker from pytools import plotsetup from scipy import interpolate as scint # load the O'Donnell 1994 dust model dust = sncosmo.OD94Dust() snIa = sncosmo.Model(source='hsiao', effects=[dust], effect_names=['host'], effect_frames=['rest']) snIa.set(z=z, t0=0, hostr_v=3.1, hostebv=Av / 3.1) snwave = np.arange(6000., 20000., 10.) snflux = snIa.flux(0, snwave) snwave = snwave / 10000. snflux = 0.5 * snflux / snflux.max() pl.plot(snwave, snflux, color=color, ls='-') f105w = sncosmo.get_bandpass('wfc3f105w') f098m = sncosmo.get_bandpass('wfc3f098m') f127m = sncosmo.get_bandpass('wfc3f127m') f139m = sncosmo.get_bandpass('wfc3f139m') f153m = sncosmo.get_bandpass('wfc3f153m') wf127m = f127m.wave / 10000. wf139m = f139m.wave / 10000. wf153m = f153m.wave / 10000. pl.plot(wf127m, f127m.trans, color='darkmagenta', ls='-') pl.plot(wf139m, f139m.trans, color='teal', ls='-') pl.plot(wf153m, f153m.trans, color='darkorange', ls='-') intf127m = scint.interp1d(wf127m, f127m.trans, bounds_error=False, fill_value=0) overlap = np.min([snflux, intf127m(snwave)], axis=0) pl.fill_between(snwave, np.zeros(len(snwave)), overlap, color='darkmagenta') intf139m = scint.interp1d(wf139m, f139m.trans, bounds_error=False, fill_value=0) overlap = np.min([snflux, intf139m(snwave)], axis=0) pl.fill_between(snwave, np.zeros(len(snwave)), overlap, color='teal') intf153m = scint.interp1d(wf153m, f153m.trans, bounds_error=False, fill_value=0) overlap = np.min([snflux, intf153m(snwave)], axis=0) pl.fill_between(snwave, np.zeros(len(snwave)), overlap, color='darkorange')
def mkExtinctionDemoFigSmall(z=2.0): """ make a set of plots showing the SN Ia SED (Hsiao template) at three extinction values, with bandpasses overlaid. :return: """ import numpy as np import sncosmo # from sncosmost import hstbandpasses, ccsnmodels from matplotlib import rc rc('text', usetex=True) rc('text.latex', preamble='\usepackage[usenames]{xcolor}') from matplotlib import pyplot as pl from matplotlib import ticker from pytools import plotsetup from scipy import interpolate as scint fig = plotsetup.fullpaperfig(1, [8, 3]) # load the O'Donnell 1994 dust model dust = sncosmo.OD94Dust() snIa = sncosmo.Model(source='hsiao', effects=[dust], effect_names=['host'], effect_frames=['rest']) ax1 = pl.gca() f127m = sncosmo.get_bandpass('f127m') f139m = sncosmo.get_bandpass('f139m') f153m = sncosmo.get_bandpass('f153m') f125w = sncosmo.get_bandpass('f125w') f140w = sncosmo.get_bandpass('f140w') f160w = sncosmo.get_bandpass('f160w') wf127m = f127m.wave / 10000. wf139m = f139m.wave / 10000. wf153m = f153m.wave / 10000. wf125w = f125w.wave / 10000. wf140w = f140w.wave / 10000. wf160w = f160w.wave / 10000. # ax2 = ax1.twinx() ax2 = ax1 ax2.plot(wf127m, f127m.trans, color='darkmagenta', ls='-', lw=2) ax2.plot(wf153m, f153m.trans, color='darkorange', ls='-', lw=2) ax2.plot(wf125w, f125w.trans, color='darkmagenta', ls='--', lw=2) ax2.plot(wf160w, f160w.trans, color='darkorange', ls='--', lw=2) intf127m = scint.interp1d(wf127m, f127m.trans, bounds_error=False, fill_value=0) intf153m = scint.interp1d(wf153m, f153m.trans, bounds_error=False, fill_value=0) colorlist1, colorlist2 = [], [] for Av, ls, alpha in zip([2, 1, 0], [':', '--', '-'], [0.1, 0.3, 0.5]): snIa.set(z=z, t0=0, hostr_v=3.1, hostebv=Av / 3.1) colorlist1.append( snIa.bandmag('f127m', 'ab', 0) - snIa.bandmag('f125w', 'ab', 0)) colorlist2.append( snIa.bandmag('f153m', 'ab', 0) - snIa.bandmag('f160w', 'ab', 0)) snwave = np.arange(6000., 20000., 10.) snflux = snIa.flux(0, snwave) snwave = snwave / 10000. snflux = 0.12 * snflux / snflux[400] ax1.plot(snwave, snflux, color='k', ls=ls, lw=1, label='%.1f' % Av) overlap127 = np.min([snflux, intf127m(snwave)], axis=0) ax2.fill_between(snwave, np.zeros(len(snwave)), overlap127, color='darkmagenta', alpha=alpha) overlap153 = np.min([snflux, intf153m(snwave)], axis=0) pl.fill_between(snwave, np.zeros(len(snwave)), overlap153, color='darkorange', alpha=alpha) ax1.legend(loc='upper left', bbox_to_anchor=(0.0, 0.9), frameon=False, fontsize=11) ax1.text(0.08, 0.88, 'A$_V$', transform=ax1.transAxes, ha='left', va='bottom', fontsize=11) ax1.text(0.13, 0.88, '$\Delta$m$_{127}$', color='darkmagenta', transform=ax1.transAxes, ha='left', va='bottom', fontsize=11) ax1.text(0.23, 0.88, '$\Delta$m$_{153}$', color='darkorange', transform=ax1.transAxes, ha='left', va='bottom', fontsize=11) ax1.text(0.14, 0.78, '%.3f' % colorlist1[0], color='darkmagenta', transform=ax1.transAxes, ha='left', va='bottom', fontsize=11) ax1.text(0.23, 0.78, '%.3f' % colorlist2[0], color='darkorange', transform=ax1.transAxes, ha='left', va='bottom', fontsize=11) ax1.text(0.14, 0.68, '%.3f' % colorlist1[1], color='darkmagenta', transform=ax1.transAxes, ha='left', va='bottom', fontsize=11) ax1.text(0.23, 0.68, '%.3f' % colorlist2[1], color='darkorange', transform=ax1.transAxes, ha='left', va='bottom', fontsize=11) ax1.text(0.14, 0.58, '%.3f' % colorlist1[2], color='darkmagenta', transform=ax1.transAxes, ha='left', va='bottom', fontsize=11) ax1.text(0.23, 0.58, '%.3f' % colorlist2[2], color='darkorange', transform=ax1.transAxes, ha='left', va='bottom', fontsize=11) # title=+ # '\\textcolor{DarlMagenta}{W}' + # '\\textcolor{F153M-F160W')#, handlelength=0.5, numpoints=3) # ax1.text( 0.15,0.95,,ha='left',va='bottom') ax1.yaxis.set_major_locator(ticker.MultipleLocator(0.1)) ax1.yaxis.set_minor_locator(ticker.MultipleLocator(0.05)) ax1.xaxis.set_major_locator(ticker.MultipleLocator(0.2)) ax1.xaxis.set_minor_locator(ticker.MultipleLocator(0.1)) ax1.set_xlabel('wavelength ($\mu$m)') ax1.set_ylabel('SN Flux or Filter Transmission\n (arbitrary units)') ax1.set_xlim(0.6, 2.0) ax1.set_ylim(0.0, 0.7) ax1.set_yticklabels([]) ax1.text(1.27, 0.6, 'F127M,F125W', color='darkmagenta', fontsize=9, ha='center', va='center') ax1.text(1.53, 0.6, 'F153M,F160W', color='darkorange', fontsize=9, ha='center', va='center') fig.subplots_adjust(left=0.12, right=0.95, bottom=0.18, top=0.92)
def __init__(self, parameters, fit=False, model='salt2-extended', version='1.0', telescope=None, ra=6.0979440, dec=-1.1051600, airmass=1.2, X0=None, dL=None): #time_begin=time.time() self.lc = [] self.m5 = { 'u': 23.61, 'g': 24.83, 'r': 24.35, 'i': 23.88, 'z': 23.30, 'y': 22.43 } self.radeg = np.rad2deg(ra) self.decdeg = np.rad2deg(dec) self.model = model self.version = version self.peakAbsMagBesselB = -19.0906 if self.model == 'salt2-extended': model_min = 300. model_max = 180000. wave_min = 3000. wave_max = 11501. if self.model == 'salt2': model_min = 3400. model_max = 11501. wave_min = model_min wave_max = model_max self.wave = np.arange(wave_min, wave_max, 1.) self.sn_type = 'Ia' source = sncosmo.get_source(self.model, version=self.version) #self.mycosmology=FlatLambdaCDM(H0=70, Om0=0.25) #astropy_cosmo=FlatLambdaCDM(H0= self.mycosmology.H0, Om0=self.mycosmology.Om0) dust = sncosmo.OD94Dust() #self.transmission=Throughputs(through_dir='FAKE_THROUGH',atmos_dir='FAKE_THROUGH',atmos=False,aerosol=False) self.transmission = telescope.throughputs #self.transmission.Load_Atmosphere(airmass) #print 'total elapse time init a',time.time()-time_begin self.telescope = telescope """ for band in self.bands: themax=np.max(self.transmission.lsst_system[band].sb) idx = self.transmission.lsst_system[band].sb >= 0.2*themax sel=self.transmission.lsst_system[band].wavelen[idx] print band,np.min(sel),np.max(sel) """ """ self.airmass=airmass if self.airmass > 0: self.transmission.Load_Atmosphere(airmass) """ #self.lc={} #print 'there we go',parameters,len(parameters),parameters.dtype self.param = parameters """ SN=sncosmo.Model(source=source,effects=[dust, dust], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) """ self.SN = sncosmo.Model(source=source) self.z = self.param['z'] if X0 is None: self.Cosmology() lumidist = self.astropy_cosmo.luminosity_distance( self.param['z']).value * 1.e3 self.dL = lumidist #X0_snsim = self.X0_norm_snsim() / lumidist** 2 X0 = self.X0_norm() / lumidist**2 #print 'before alpha beta',X0 alpha = 0.13 beta = 3. X0 *= np.power( 10., 0.4 * (alpha * self.param['X1'] - beta * self.param['Color'])) self.X0 = X0 else: self.X0 = X0 self.dL = dL #print 'llla',X0,alpha,beta,param['X1'],param['Color'],param['z'],lumidist #self.X0=X0 #print 'hello x0',X0,lumidist #SN=sncosmo.Model(source=source) self.SN.set(z=self.param['z']) self.SN.set(t0=self.param['DayMax']) self.SN.set(c=self.param['Color']) self.SN.set(x1=self.param['X1']) self.SN.set(x0=self.X0) #print 'total elapse time init b',time.time()-time_begin #self.SED={} #print 'sncosmo parameters',self.SN.param_names,self.SN.parameters lsstmwebv = EBVbase() ebvofMW = lsstmwebv.calculateEbv(equatorialCoordinates=np.array( [[np.radians(self.radeg)], [np.radians(self.decdeg)]]))[0] #self.SN.set(mwebv=ebvofMW) #self.SN.set_source_peakabsmag(self.peakAbsMagBesselB, 'bessellB', 'vega',cosmo=self.astropy_cosmo) if self.sn_type == 'Ia': self.mbsim = self.SN._source.peakmag('bessellb', 'vega')
all_obs = [] for filename in filenames: print 'opening', filename pkl_file = open(filename, 'rb') objs = [] while 1: try: objs.append(pkl.load(pkl_file)) except EOFError: break all_obs.append(objs) val = 'error_coadd_through' dust = sncosmo.OD94Dust() fitted_model = sncosmo.Model(source='salt2-extended', effects=[dust, dust], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) fitted_model_coadd = sncosmo.Model(source='salt2-extended', effects=[dust, dust], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) # Read throughputs transmission = Throughputs() # Register LSST band pass (system) in sncosmo bands = ['u', 'g', 'r', 'i', 'z', 'y']
matplotlib.use('Agg') from copy import copy import sncosmo import numpy as np from bolomc import bump from bolomc import burns from bolomc.distributions import TruncNorm lc = sncosmo.read_lc('../data/CSP_Photometry_DR2/SN2005elopt+nir_photo.dat', format='csp') model = sncosmo.Model(bump.BumpSource(), effect_names=['host', 'mw'], effect_frames=['rest', 'obs'], effects=[sncosmo.OD94Dust(), sncosmo.F99Dust()]) model2 = copy(model) model2.set( UV_bump_amp=1., #blue_bump_amp=0.2, blue_bump_amp=-0.2, i1_bump_amp=0.1, i2_bump_amp=-0.2, y1_bump_amp=-0.2, y2_bump_amp=0.2, y3_bump_amp=-0.1, j1_bump_amp=-0.2, j2_bump_amp=0.2, h1_bump_amp=-0.2, h2_bump_amp=0.2,
def __init__(self,parameters,fit=False,model='salt2-extended',version='1.0',telescope=None,airmass=-1): self.lc=[] self.m5={'u':23.61,'g':24.83,'r':24.35,'i':23.88,'z':23.30,'y':22.43} self.radeg=np.rad2deg(6.0979440) self.decdeg=np.rad2deg(-1.1051600) self.params=Table(names=('t0','c','x1','z','ra','dec','status','fit','sn_type','sn_model','sn_version','mbsim','x0','dL'),dtype=('f8','f8','f8','f8','f8','S8','S8','f8','S8','S8','S8','f8','f8','f8')) self.table_for_fit = Table(names=('time','flux','fluxerr','band','zp','zpsys'), dtype=('f8', 'f8','f8','S7','f4','S4')) self.model=model self.version=version self.peakAbsMagBesselB=-19.0906 if self.model == 'salt2-extended': model_min=300. model_max=180000. wave_min=3000. wave_max=11501. if self.model=='salt2': model_min=3400. model_max=11501. wave_min=model_min wave_max=model_max self.wave= np.arange(wave_min,wave_max,1.) sn_type='Ia' source=sncosmo.get_source(self.model,version=self.version) #self.mycosmology=FlatLambdaCDM(H0=70, Om0=0.25) #astropy_cosmo=FlatLambdaCDM(H0= self.mycosmology.H0, Om0=self.mycosmology.Om0) dust = sncosmo.OD94Dust() #self.transmission=Throughputs(through_dir='FAKE_THROUGH',atmos_dir='FAKE_THROUGH',atmos=False,aerosol=False) self.transmission=telescope.throughputs """ for band in self.bands: themax=np.max(self.transmission.lsst_system[band].sb) idx = self.transmission.lsst_system[band].sb >= 0.2*themax sel=self.transmission.lsst_system[band].wavelen[idx] print band,np.min(sel),np.max(sel) """ self.airmass=airmass if self.airmass > 0: self.transmission.Load_Atmosphere(airmass) self.lc={} #print 'there we go',parameters,len(parameters),parameters.dtype self.param=parameters """ SN=sncosmo.Model(source=source,effects=[dust, dust], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) """ self.SN=sncosmo.Model(source=source) self.z=self.param['z'] self.Cosmology() lumidist=self.astropy_cosmo.luminosity_distance(self.param['z']).value*1.e3 X0 = self.X0_norm() / lumidist** 2 #print 'before alpha beta',X0 alpha=0.13 beta=3. X0 *= np.power(10., 0.4*(alpha*self.param['X1'] -beta*self.param['Color'])) #print 'llla',X0,alpha,beta,param['X1'],param['Color'],param['z'],lumidist self.X0=X0 #SN=sncosmo.Model(source=source) self.SN.set(z=self.param['z']) self.SN.set(t0=self.param['DayMax']) self.SN.set(c=self.param['Color']) self.SN.set(x1=self.param['X1']) self.SN.set(x0=self.X0) #self.SED={} print 'sncosmo parameters',self.SN.param_names,self.SN.parameters #lsstmwebv = EBVbase() """
def __init__(self,logobs,parameters,model,version): self.mjd_name='mjd' self.FWHMeff='seeing' peakAbsMagBesselB=-19.0906 alpha=0.13 beta=3. mycosmology=FlatLambdaCDM(H0=70, Om0=0.25) self.astropy_cosmo=FlatLambdaCDM(H0= mycosmology.H0, Om0=mycosmology.Om0) instrument = instruments.InstrumentModel("STANDARD") B = instrument.EffectiveFilterByBand("B") magsys = instruments.MagSys('VEGA') zp = magsys.ZeroPoint(B) print 'zeropoint for b-band',zp flux_at_10pc = np.power(10., -0.4 * (peakAbsMagBesselB-zp)) fs = salt2.load_filters(['STANDARD::B']) mc = salt2.ModelComponents('salt2.npz') s = salt2.SALT2([0.], ['STANDARD::B'], mc, fs, z=0.) raw_model_norm = s()[0] # (10pc)^2 in kpc^2 self.X0_norm = flux_at_10pc * 1.E-4 / raw_model_norm table_obs=ascii.read(logobs,fast_reader=False) colnames=[] sfile=open(logobs,'r') for line in sfile.readlines(): if line.count('#'): colnames.append(line[1:].split(':')[0].strip()) for i,val in enumerate(table_obs.colnames): #if val.count('#') >= 1: table_obs.rename_column(val, colnames[i]) self.lc=[] print table_obs self.params=Table(names=('t0','c','x1','z','ra','dec','status','fit','sn_type','sn_model','sn_version','mbsim','x0','dL'),dtype=('f8','f8','f8','f8','f8','S8','S8','f8','S8','S8','S8','f8','f8','f8')) self.transmission=Throughputs() dust = sncosmo.OD94Dust() model=model version=version if model == 'salt2-extended': model_min=300. model_max=180000. wave_min=3000. wave_max=11501. if model=='salt2': model_min=2000. model_max=9200.0 wave_min=model_min wave_max=model_max wave= np.arange(wave_min,wave_max,1.) sn_type='Ia' source=sncosmo.get_source(model,version=version) ra_field=0. dec_field=0. table_obs.sort(self.mjd_name) for iv,param in enumerate(parameters): #mysn=Simul_Fit_SN(param['DayMax'],param['Color'],param['X1'],param['z'],table_obs,ra=param['ra'],dec=param['dec']) table_LC=Table(names=('idSN','filter','expMJD','visitExpTime','FWHMeff','moon_frac','filtSkyBrightness','kAtm','airmass','fiveSigmaDepth','Nexp','e_per_sec','e_per_sec_err'), dtype=('i8','S7','f8', 'f8','f8','f8', 'f8','f8','i8','f8','f8','f8','f8')) lumidist=self.astropy_cosmo.luminosity_distance(param['z']).value*1.e3 X0 = self.X0_norm / lumidist** 2 X0 *= np.power(10., 0.4*(alpha*param['X1'] -beta*param['Color'])) print 'X0 val',X0 SN=sncosmo.Model(source=source,effects=[dust, dust], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) SN.set(z=param['z']) SN.set(t0=param['DayMax']) SN.set(c=param['Color']) SN.set(x1=param['X1']) SN.set(x0=X0) #SN.set_source_peakabsmag(peakAbsMagBesselB, 'bessellB', 'vega',cosmo=mycosmology) fluxes=10.*SN.flux(table_obs[self.mjd_name],wave) wavelength=wave/10. wavelength=np.repeat(wavelength[np.newaxis,:], len(fluxes), 0) SED_time = Sed(wavelen=wavelength, flambda=fluxes) self.params.add_row((param['DayMax'],param['Color'],param['X1'],param['z'],ra_field,dec_field,'unkown',None,sn_type,model,version,SN._source.peakmag('bessellb','vega'),SN.get('x0'),lumidist)) for i in range(len(SED_time.wavelen)): obs=table_obs[i] sed=Sed(wavelen=SED_time.wavelen[i],flambda=SED_time.flambda[i]) visittime=obs['exptime'] filtre=obs['band'][-1] photParams = PhotometricParameters(nexp=visittime/15.) e_per_sec = sed.calcADU(bandpass=self.transmission.lsst_atmos_aerosol[filtre], photParams=photParams) #number of ADU counts for expTime e_per_sec/=visittime/photParams.gain flux_SN=sed.calcFlux(bandpass=self.transmission.lsst_atmos_aerosol[filtre]) FWHMeff=obs[self.FWHMeff] if flux_SN >0: #print 'hello flux',flux_SN,fluxes[i] mag_SN=-2.5 * np.log10(flux_SN / 3631.0) m5_calc,snr_m5_through=self.Get_m5(filtre,mag_SN,obs['sky'],photParams,FWHMeff) table_LC.add_row((iv,'LSST::'+filtre,obs[self.mjd_name],visittime,FWHMeff,obs['moon_frac'],obs['sky'],obs['kAtm'],obs['airmass'],obs['m5sigmadepth'],obs['Nexp'],e_per_sec,e_per_sec/snr_m5_through)) self.lc.append(table_LC)
def __init__(self, ra, dec, z, t0, c=0, x1=0, peakAbsMagBesselB=-19.0906, model='salt2-extended', version='1.0', sn_type='Ia', mwdust=True): self.radeg = ra self.decdeg = dec self.z = z self.t0 = t0 self.c = c self.x1 = x1 self.peakAbsMagBesselB = peakAbsMagBesselB self.model = model self.version = version self.sn_type = sn_type self.id_SED = '' self.cosmology = cosmology.WMAP9 self.cosmology = FlatLambdaCDM(H0=70, Om0=0.25) astropy_cosmo = FlatLambdaCDM(H0=self.cosmology.H0, Om0=self.cosmology.Om0) self.lumidist = astropy_cosmo.luminosity_distance(self.z).value * 1.e6 #print 'SN Lumidist',self.lumidist,self.cosmology.H0,self.cosmology.Om0 #print 'sntype',self.sn_type dust = sncosmo.OD94Dust() self.lsstmwebv = EBVbase() self.ebvofMW = self.lsstmwebv.calculateEbv( equatorialCoordinates=np.array([[np.radians(self.radeg)], [np.radians(self.decdeg)]]))[0] if self.sn_type == 'Ia': if version == '': source = sncosmo.get_source(self.model) else: source = sncosmo.get_source(self.model, version=self.version) self.SN = sncosmo.Model(source=source, effects=[dust, dust], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) #self.SN=sncosmo.Model(source=self.source) #self.SN=sncosmo.Model(source=self.source) #print 'blabla',self.SN.minwave(),self.SN.maxwave() lowrange = -30. highrange = 50. self.SN.set(z=self.z) self.SN.set(t0=self.t0) self.SN.set(c=self.c) self.SN.set(x1=self.x1) self.SN.set_source_peakabsmag(self.peakAbsMagBesselB, 'bessellB', 'vega', cosmo=self.cosmology) #self.SN.set(mwebv=self.ebvofMW) #self.SN.set(mwebv=0.) else: self.Fill_nonIa_ID() resu = self.Get_nonIa_Template_ID() #id_SED='SDSS-018109' #id_SED='SDSS-018457' """ if id_SED != None: self.id_SED=id_SED print 'tagged',self.id_SED #self.SED_all_phases=self.Load_SED('NON1A/'+id_SED+'.SED') phase, wave, values = read_griddata_ascii('NON1A/'+id_SED+'.SED') print 'min max',np.min(wave),np.max(wave) self.SED_template = Spline2d(phase, wave, values, kx=2, ky=2) """ self.model = thename = resu[0] self.version = resu[1] #print 'the choice',resu[0],resu[1] """ thename='snana-2007kw' theversion='1.0' """ if thename != None: #print 'Getting the source' source = sncosmo.get_source(self.model, self.version) #print 'Getting the model' self.SN = sncosmo.Model(source=source, effects=[dust, dust], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) #print 'Setting z and T0' self.SN.set(z=self.z) self.SN.set(t0=self.t0) #print 'SN here',self.z,self.t0,thename,theversion self.SN.set_source_peakabsmag(-18., 'bessellB', 'vega', cosmo=self.cosmology) #MW extinction if mwdust: self.SN.set(mwebv=self.ebvofMW) self.SN.set(mwebv=0.) self.model_for_fit()
qual = f.split('__')[1].split('.pkl')[0] ebv = float(qual.split('_')[1]) rv = float(qual.split('_')[-1]) nvparams.append([ebv, rv]) dicts = [] for samps, (ebv, rv) in zip(samples, nvparams): dicts.append(make_dictionaries(snname, samps, ebv, rv)) dicts = list(chain(*dicts)) samples = np.vstack(samples) pruned = samples[np.random.choice(range(len(dicts)), replace=False, size=1000)] model = sncosmo.Model(bump.BumpSource(), effect_names=['host','mw'], effect_frames=['rest','obs'], effects=[sncosmo.OD94Dust(), sncosmo.F99Dust()]) mods = [copy(model) for sample in pruned] for d, mod in zip(dicts, mods): mod.set(**d) bolos = [bolometric(mod) for mod in mods] stack = bolo.LCStack(mod.source._phase, bolos) ax = stack.plot() m2 = sncosmo.Model(sncosmo.get_source('hsiao')) m2.set(z=mod.get('z'), amplitude=mod.get('amplitude')) m3 = copy(mod) m3.set(**{p:0 for p in m3._param_names if 'bump' in p}) ax.plot(m2.source._phase, bolometric(m2), ls='--') ax.plot(m3.source._phase, bolometric(m3), ls='-.') ax.figure.savefig('combined.pdf')
def __init__(self, sntype, observations=None, z_range=[1.8,2.2], t0_range=[0,0], nsim=100, perfect=True, Om=0.3, H0=70, filterset='hst' ): """ Run a monte carlo sim using sncosmo to simulate <nsim> SNe of the given <sntype> over the given <z_range>. Simulates Type Ia SNe with the SALT2 model, and CC SNe with the SNANA CC templates. Observations are done at time t=0, unless specified otherwise in a user-defined observations table. Set perfect=True for noiseless "observations" of the simulated SNe. :return: """ from astropy import cosmology import sncosmo from numpy.random import normal, uniform, choice import numpy as np self.sntype = sntype self.z_range = z_range self.nsim = nsim self.perfect = perfect if observations is None : observations = mkobservationsTable( filterset=filterset ) self.observations = observations # Make a list of all the unique sncosmo source models available, # and assign a relative probability that any given simulated SN of this # type (CC or Ia) belongs to that subclass if sntype.lower() in ['cc','ii','ibc'] : subClassDict = SubClassDict_SNANA[sntype.lower()] subClassProbs = ccSubClassProbs[sntype.lower()] self.SourcenameSet = np.array( subClassDict.keys() ) self.SubclassSet = np.array([ subClassDict[source] for source in self.SourcenameSet ]) self.SubclassCount = np.array([ len(np.where(self.SubclassSet==subclass)[0]) for subclass in self.SubclassSet ], dtype=float) self.SourceprobSet = np.array([ subClassProbs[subclass] for subclass in self.SubclassSet ]) / self.SubclassCount self.SourceprobSet /= self.SourceprobSet.sum() elif sntype.lower()=='ia' : # No sub-class divisions for SNIa self.SourcenameSet = np.array(['salt2-extended']) self.SubclassSet = np.array( ['Ia'] ) self.SourceprobSet = np.array( [1] ) self.SubclassCount = np.array( [1] ) # load the O'Donnell 1994 dust model self.dust = sncosmo.OD94Dust() # Define an sncosmo SN model for each available source modelset = np.array([ sncosmo.Model(source=source, effects=[self.dust], effect_names=['host'], effect_frames=['rest']) for source in self.SourcenameSet ]) # Define a cosmology # self.Om = Om # self.H0 = H0 self.cosmo = cosmology.FlatLambdaCDM(Om0=Om, H0=H0) # For each simulated SN, draw random Av from distributions # as defined in Rodney et al 2014a : # For SN Ia : P(Av) = exp(-Av/0.33) # For CC SN : P(Av) = 4 * gauss(0.6) + exp(-Rv/1.7) if sntype=='Ia': tau,sigma,R0 = 0.33, 0, 0 else : tau,sigma,R0 = 1.7, 0.6, 4 self.Av = mcsample( pAv, nsim, tau=tau, sigma=sigma, R0=R0 ) # For each simulated SN, draw a random Rv from a normal # distribution centered on 3.1 with width 0.5 self.Rv = normal( 3.1, 0.5, nsim ) self.Rv = np.where( self.Rv>0, self.Rv, 0.01 ) # Convert Av and Rv to E(B-V) : # Rv = Av/EBV ==> EBV = Av/Rv self.EBV = self.Av / self.Rv # TODO : draw the redshifts with a metropolis-hastings sampler to match # a distribution defined based on the expected SN rate # Disabled : uniform redshift spacing # zlist = np.linspace( z_range[0], z_range[1], nsim ) # Draw a random redshift from a uniform distribution self.z = uniform( low=z_range[0], high=z_range[1], size=nsim ) lightcurvelist = [] peakabsmagRlist = [] modelparamlist = [] subclasslist = [] modelindexlist = [] sourcenamelist = [] t0list = [] if sntype=='Ia': x0list = [] x1list = [] clist = [] else : amplitudelist = [] for isim in range(self.nsim): # Randomly draw an sncosmo model from the available list, according to # the predefined probability list, setting the SN sub-class for this # simulated SN imodel = choice( np.arange(len(modelset)), replace=True, p=self.SourceprobSet ) model = modelset[imodel] subclass = self.SubclassSet[imodel] z = self.z[isim] EBV = self.EBV[isim] Rv = self.Rv[isim] # Set the peak absolute magnitude according to the observed # luminosity functions, as defined in Table 3 of Graur:2014a; # and set the host extinction according to the 'mid' dust model # of Rodney:2014a. if subclass == 'Ia' : MR = normal( -19.37, 0.47 ) elif subclass == 'Ib' : MR = normal( -17.90, 0.90 ) elif subclass == 'Ic' : MR = normal( -18.30, 0.60 ) elif subclass == 'IIP' : MR = normal( -16.56, 0.80 ) elif subclass == 'IIL' : MR = normal( -17.66, 0.42 ) elif subclass == 'IIn' : MR = normal( -18.25, 1.00 ) model.set(z=z) model.set_source_peakabsmag( MR, 'bessellr', 'vega', cosmo=self.cosmo) modelindexlist.append( imodel ) subclasslist.append( subclass ) peakabsmagRlist.append( MR ) sourcenamelist.append( self.SourcenameSet[imodel] ) if subclass =='Ia' : x0 = model.get('x0') # TODO : use bifurcated gaussians for more realistic x1,c dist'ns x1 = normal(0., 1.) c = normal(0., 0.1) t0 = uniform( t0_range[0], t0_range[1] ) modelparams = {'z':z, 't0':t0, 'x0':x0, 'x1':x1, 'c':c, 'hostebv':EBV, 'hostr_v':Rv} t0list.append( t0 ) x0list.append( x0 ) x1list.append( x1 ) clist.append( c ) t0list.append( t0 ) else : amplitude = model.get('amplitude') t0 = uniform( t0_range[0], t0_range[1] ) modelparams = {'z':z, 't0':t0, 'amplitude':amplitude, 'hostebv':EBV, 'hostr_v':Rv } amplitudelist.append( amplitude ) t0list.append( t0 ) modelparamlist.append( modelparams ) # Generate one simulated SN: snlc = sncosmo.realize_lcs(self.observations, model, [ modelparams ], thresh=None)#, perfect=perfect ) lightcurvelist.append( snlc[0] ) self.lightcurves = lightcurvelist self.t0 = np.array( t0list ) self.modelindex = np.array( modelindexlist ) self.sourcename = np.array( sourcenamelist ) self.subclass = np.array( subclasslist ) self.modelparam = np.array( modelparamlist ) self.peakabsmagR = np.array( peakabsmagRlist ) if sntype=='Ia': self.x0 = np.array( x0list ) self.x1 = np.array( x1list ) self.c = np.array( clist ) else : self.amplitude = np.array( amplitudelist ) return
def task(filename, i, j, nrv, nebv, kind='mcmc'): lc = sncosmo.read_lc(filename, format='csp') model = sncosmo.Model(bump.BumpSource(), effect_names=['host', 'mw'], effect_frames=['rest', 'obs'], effects=[sncosmo.OD94Dust(), sncosmo.F99Dust()]) rv_prior = burns.get_hostrv_prior(lc.meta['name'], 'gmm', sncosmo.OD94Dust) host_ebv, err = burns.get_hostebv(lc.meta['name']) ebv_prior = TruncNorm(-np.inf, np.inf, host_ebv, err) rv_prior, low, high = burns.get_hostrv_prior(lc.meta['name'], 'gmm', sncosmo.OD94Dust, retlims=True) host_ebv, err = burns.get_hostebv(lc.meta['name']) rv = np.linspace(low if low >= 0 else 0, high, nrv)[i] ebvlo = host_ebv - err ebvhi = host_ebv + err ebv = np.linspace(ebvlo if ebvlo >= 0 else 0, ebvhi, nebv)[j] model.set(z=lc.meta['zcmb']) model.set(mwebv=burns.get_mwebv(lc.meta['name'])[0]) model.set(hostebv=ebv) model.set(hostr_v=rv) model.set(t0=burns.get_t0(lc.meta['name'])) vparams = filter(lambda x: 'bump' in x, model._param_names) vparams += ['t0', 's'] bounds = {b.name + "_bump_amp": (-1, 2) for b in model.source.bumps} #bounds['hostr_v'] = (rv_prior.mean - 0.5, rv_prior.mean + 0.5) #bounds['hostebv'] = (0, 0.2) bounds['s'] = (0, 3.) res, model = sncosmo.fit_lc(lc, model, ['amplitude'] + vparams, bounds=bounds) bounds['t0'] = (model.get('t0') - 2, model.get('t0') + 2) vparams.append('amplitude') bounds['amplitude'] = (0.5 * model.get('amplitude'), 2 * model.get('amplitude')) qualifier = '_ebv_%.2f_rv_%.2f' % (ebv, rv) if kind != 'fit': if kind == 'mcmc': result = sncosmo.mcmc_lc(lc, model, vparams, bounds=bounds, nwalkers=500, nburn=1000, nsamples=20) elif kind == 'nest': result = sncosmo.nest_lc(lc, model, vparams, bounds=bounds, method='multi', npoints=800) samples = result[0].samples.reshape(500, 20, -1) vparams = result[0].vparam_names plot_arg = np.rollaxis(samples, 2) plotting.plot_chains(plot_arg, param_names=vparams, filename='fits/%s_samples%s.pdf' % (lc.meta['name'], qualifier)) dicts = [ dict(zip(vparams, samp)) for samp in samples.reshape(500 * 20, -1) ] thinned = samples.reshape(500, 20, -1)[:, [0, -1]].reshape(1000, -1) pickle.dump( samples, open('fits/%s_samples%s.pkl' % (lc.meta['name'], qualifier), 'wb')) models = [copy(result[1]) for i in range(len(thinned))] for d, m in zip(dicts, models): m.set(**d) fig = sncosmo.plot_lc(data=lc, model=models, ci=(50 - 68 / 2., 50., 50 + 68 / 2.), model_label=lc.meta['name']) fig.savefig('fits/%s%s.pdf' % (lc.meta['name'], qualifier)) else: fitres, model = sncosmo.fit_lc(lc, model, vparams, bounds=bounds) fig = sncosmo.plot_lc(data=lc, model=model) fig.savefig('fits/%s_fit%s.pdf' % (lc.meta['name'], qualifier))
def __init__(self, param, simu_param, reference_lc=None, gamma=None, mag_to_flux=None, dustcorr=None, snr_fluxsec='interp', error_model=True): super().__init__(param.name, param.sn_parameters, param.gen_parameters, param.cosmology, param.telescope, param.SNID, param.area, param.x0_grid, mjdCol=param.mjdCol, RACol=param.RACol, DecCol=param.DecCol, filterCol=param.filterCol, exptimeCol=param.exptimeCol, nexpCol=param.nexpCol, m5Col=param.m5Col, seasonCol=param.seasonCol, seeingEffCol=param.seeingEffCol, seeingGeomCol=param.seeingGeomCol, airmassCol=param.airmassCol, skyCol=param.skyCol, moonCol=param.moonCol, salt2Dir=param.salt2Dir) """ SN class - inherits from SN_Object Parameters -------------- param: dict parameters requested for the simulation (SN_Object) simu_param : dict parameters for the simulation: name: simulator name (str) model: model name for SN (exempla: salt2-extended) (str) version: version of the model (str) reference_lc : griddata,opt reference_light curves (default: None) gamma: griddata, opt reference gamma values (default: None) mag_to_flux: griddata, opt reference mag->flux values (default: None) snr_fluxsec: str, opt type of method to estimate snr and flux in pe.s-1: lsstsim: estimated from lsstsims tools interp: estimated from interpolation (default) all : estimated from the two above-mentioned methods """ model = simu_param['model'] version = str(simu_param['version']) self.model = model self.version = version self.gamma = gamma self.mag_to_flux = mag_to_flux self.snr_fluxsec = snr_fluxsec self.error_model = error_model if model == 'salt2-extended': model_min = 300. model_max = 180000. wave_min = 3000. wave_max = 11501. if model == 'salt2': model_min = 3400. model_max = 11501. wave_min = model_min wave_max = model_max self.wave = np.arange(wave_min, wave_max, 1.) if not self.error_model: source = sncosmo.get_source(model, version=version) else: SALT2Dir = 'SALT2.Guy10_UV2IR' self.SALT2Templates(SALT2Dir=SALT2Dir, blue_cutoff=10. * self.sn_parameters['blue_cutoff']) source = sncosmo.SALT2Source(modeldir=SALT2Dir) self.dustmap = sncosmo.OD94Dust() self.lsstmwebv = EBV.EBVbase() self.SN = sncosmo.Model(source=source, effects=[self.dustmap, self.dustmap], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) self.SN.set(z=self.sn_parameters['z']) self.SN.set(t0=self.sn_parameters['daymax'] + self.gen_parameters['epsilon_daymax']) self.SN.set(c=self.sn_parameters['color'] + self.gen_parameters['epsilon_color']) self.SN.set(x1=self.sn_parameters['x1'] + self.gen_parameters['epsilon_x1']) # need to correct X0 for alpha and beta lumidist = self.cosmology.luminosity_distance( self.sn_parameters['z']).value * 1.e3 self.X0 = self.x0(lumidist) self.dL = lumidist self.SN.set(x0=self.X0) """ self.SN.set_source_peakabsmag(self.sn_parameters['absmag'], self.sn_parameters['band'], self.sn_parameters['magsys']) self.X0 = self.SN.get('x0') """ self.defname = dict( zip(['healpixID', 'pixRA', 'pixDec'], ['observationId', param.RACol, param.DecCol])) # names for metadata self.names_meta = [ 'RA', 'Dec', 'x0', 'epsilon_x0', 'x1', 'epsilon_x1', 'color', 'epsilon_color', 'daymax', 'epsilon_daymax', 'z', 'survey_area', 'healpixID', 'pixRA', 'pixDec', 'season', 'dL', 'ptime', 'snr_fluxsec_meth', 'status', 'ebvofMW' ] self.mag_inf = 100. # mag values to replace infs # band registery in sncosmo for band in 'grizy': throughput = self.telescope.atmosphere[band] bandcosmo = sncosmo.Bandpass(throughput.wavelen, throughput.sb, name='LSST::' + band, wave_unit=u.nm) sncosmo.registry.register(bandcosmo, force=True)
def __init__(self, x1=-2.0, color=0.2, daymax=0.0, blue_cutoff=380., redcutoff=800., mjdCol='observationStartMJD', filterCol='filter', SALT2Dir=''): model = 'salt2-extended' version = '1.0' source = sncosmo.get_source(model, version=version) if SALT2Dir != '': source = sncosmo.SALT2Source(modeldir=SALT2Dir) dustmap = sncosmo.OD94Dust() lsstmwebv = EBV.EBVbase() self.mjdCol = mjdCol self.filterCol = filterCol self.x1 = x1 self.color = color self.daymax = daymax # SN model self.SN = sncosmo.Model(source=source, effects=[dustmap, dustmap], effect_names=['host', 'mw'], effect_frames=['rest', 'obs']) # SN parameters self.SN.set(t0=daymax) self.SN.set(c=color) self.SN.set(x1=x1) # SN normalisation # cosmology H0 = 72.0 Omega_m = 0.3 Omega_l = 0.70 w0 = -1.0 wa = 0.0 self.cosmo = self.cosmology(H0, Omega_m, Omega_l, w0, wa) # x0 normalisation self.x0_grid = self.x0(-19.0906) self.x0_from_grid = griddata( (self.x0_grid['x1'], self.x0_grid['color']), self.x0_grid['x0_norm'], (x1, color), method='nearest') # wavelength for the model wave_min = 3000. wave_max = 11501. self.wave = np.arange(wave_min, wave_max, 1.) # telescope self.telescope = Telescope(airmass=1.2) lambda_min = dict(zip('grizy', [300., 670., 300., 300., 300.])) # band registery in sncosmo for band in 'grizy': throughput = self.telescope.atmosphere[band] print(band, lambda_min[band]) idx = throughput.wavelen <= lambda_min[band] # throughput.sb[idx] = 0. bandcosmo = sncosmo.Bandpass(throughput.wavelen, throughput.sb, name='LSST::' + band, wave_unit=u.nm) sncosmo.registry.register(bandcosmo, force=True)