def showcurve(sn, hml):
source=sncosmo.get_source('s11-2005hm')
model=sncosmo.Model(source=source)
z0 = float(redshifts[sn])
model.set(z=z0)
numofrows = len(hml[:,1])
#adding flux, fluxerr, mag and magerror columns
flux = [str(float(hml[i][1])*10**((-27-21.49)/2.5)) for i in range(numofrows)]
hml=np.column_stack((hml,flux))
fluxerr = [str(float(hml[i][2])*10**((-27-21.49)/2.5)) for i in range(numofrows)]
hml=np.column_stack((hml,fluxerr))
#adding zpsys and filter columns
ab = ['ab' for i in range(numofrows)]
hml=np.column_stack((hml,ab))
band = ['ptf48r' for i in range(numofrows)]
hml=np.column_stack((hml,band))
''''
'counts to flux eq', hml_dat[8][1]*10**((-27-21.49)/2.5)
'flux to mag eq', -2.5 *np.log10(flux)-21.49
'counts to mag eq', -2.5 *np.log10(hml_dat[8][1]) +27
'''
#plt.errorbar([float(i) for i in hml[:,0]], [float(i) for i in hml[:,1]], yerr = [float(i) for i in hml[:,2]], color = 'blue', fmt = 'o')
#plt.scatter(hml[:,0], hml[:,4], color = 'green')
#plt.show()
hml_dat=astropy.table.Table(data=hml, names=('mjd', 'counts', 'dcounts', 'zp', 'flux', 'fluxerr', 'zpsys', 'filter'), dtype=('float','float','float','float','float','float','str', 'str'))
#print hml_dat
mjdlimits = {'09': (55197-365, 55197),'10': (55197, 55562), '11': (55562, 55927), '12': (55927, 56293)}
res, fitted_model=sncosmo.fit_lc(hml_dat, model, ['t0','amplitude'], nburn=10000, nsamples=50000, bounds={'t0':mjdlimits[sn[:2]]})
#res, fitted_model=sncosmo.fit_lc(hml_dat, model, ['t0','amplitude'], nburn=10000, nsamples=50000, bounds={'t0':(55830,55960)})
# sncosmo.plot_lc(hml_dat, model=fitted_model, model_label=source.name, errors=res.errors, color='blue', figtext=str(sn+'\n'+'Model name: s11-2005hm'+ '\n'+'Reduced Chi Squared: ')+ str(res.chisq/res.ndof), xfigsize=18)
# plt.show()
hml2 = []
#print hml
#print res.parameters[1]
j = 0; k= 0
start = float(res.parameters[1])
peaktime = modellimit(z0)
for row in hml:
datestamp = row[0]
if peaktime + (40.0)*(1+z0) > float(datestamp)-start > peaktime - (20.0)*(1+z0) :
hml2.append(row)
if peaktime + (40.0)*(1+z0) > float(datestamp)-start > peaktime:
j+=1
if peaktime > float(datestamp)-start> peaktime-(20.0)*(1+z0):
k+=1
if j > 0 and k > 0:
hml2= np.array(hml2)
## print 'after', len(hml2)
hml_dat2=astropy.table.Table(data=hml2, names=('mjd', 'counts', 'dcounts', 'zp', 'flux', 'fluxerr', 'zpsys', 'filter'), dtype=('float','float','float','float','float','float','str', 'str'))
res2, fitted_model2=sncosmo.fit_lc(hml_dat2, model, ['t0','amplitude'], nburn=10000, nsamples=50000, bounds={'t0':mjdlimits[sn[:2]]})
#plot model
redchisqaured = res2.chisq/res2.ndof
#sncosmo.plot_lc(hml_dat2, model=fitted_model2, model_label=source.name, zp = 27.00, errors=res2.errors, color='blue', figtext=str(sn+'\n'+'Model name: s11-2005hm'+ '\n'+'Reduced Chi Squared: ')+ str(res2.chisq/res2.ndof), xfigsize=18)
# plt.show()
##print 'Done:', hml2[:,0][0], 'z:',float(res2.parameters[0]), 'Reduced chi^2:', res2.chisq/res2.ndof #'Data points:', len(hml[:,1]),' Type'+types[hml[:,0][0]]+'Model name: '+ source.name,'\n' #'Dof:', res.ndof
return redchisqaured, res2.parameters, z0, hml2 #, res.errors['amplitude']]
else:
print sn, 'didn\'t make the cut'
def test_wrong_param_names(self):
"""Supplying parameter names that are not part of the model should
raise an error."""
# a parameter not in the model
with pytest.raises(ValueError):
res, fitmodel = sncosmo.fit_lc(self.data, self.model, ["t0", "not_a_param"])
# no parameters
with pytest.raises(ValueError):
res, fitmodel = sncosmo.fit_lc(self.data, self.model, [])
def test_wrong_param_names(self):
"""Supplying parameter names that are not part of the model should
raise an error."""
# a parameter not in the model
with pytest.raises(ValueError):
res, fitmodel = sncosmo.fit_lc(self.data, self.model,
['t0', 'not_a_param'])
# no parameters
with pytest.raises(ValueError):
res, fitmodel = sncosmo.fit_lc(self.data, self.model, [])
def get_gaussian_fit(z, t0, x0, x1, c, lc, seed, temp_dir, interped, type="iminuit"):
model = sncosmo.Model(source='salt2-extended')
p = {'z': z, 't0': t0, 'x0': x0, 'x1': x1, 'c': c}
model.set(**p)
correct_model = sncosmo.Model(source='salt2-extended')
correct_model.set(**p)
if type == "iminuit":
res, fitted_model = sncosmo.fit_lc(lc, model, ['t0', 'x0', 'x1', 'c'],
guess_amplitude=False, guess_t0=False)
chain = np.random.multivariate_normal(res.parameters[1:], res.covariance, size=int(1e5))
fig = sncosmo.plot_lc(lc, model=[fitted_model, correct_model], errors=res.errors)
fig.savefig(temp_dir + os.sep + "lc_%d.png" % seed, bbox_inches="tight", dpi=300)
elif type == "mcmc":
res, fitted_model = sncosmo.mcmc_lc(lc, model, ['t0', 'x0', 'x1', 'c'], nburn=500, nwalkers=20,
nsamples=1500, guess_amplitude=False, guess_t0=False)
chain = np.random.multivariate_normal(res.parameters[1:], res.covariance, size=int(1e5))
elif type == "nestle":
bounds = {"t0": [980, 1020], "x0": [0.1e-6, 9e-3], "x1": [-10, 10], "c": [-1, 1]}
res, fitted_model = sncosmo.nest_lc(lc, model, ['t0', 'x0', 'x1', 'c'], bounds,
guess_amplitude=False, guess_t0=False)
chain = np.random.multivariate_normal(res.parameters[1:], res.covariance, size=int(1e5))
else:
raise ValueError("Type %s not recognised" % type)
map = {"x0": "$x_0$", "x1": "$x_1$", "c": "$c$", "t0": "$t_0$"}
parameters = [map[a] for a in res.vparam_names]
chain, parameters = add_mu_to_chain(interped, chain, parameters)
return chain, parameters, res.parameters[1:], res.covariance
def fit_curve(hml_dat, source, hml):
# Retrieving model from source, (requires internet access)
model = sncosmo.Model(source=source)
# Fitting model: model parameter z bound.
res, fitted_model = sncosmo.fit_lc(hml_dat, model, ['z', 't0', 'amplitude'], bounds={'z': (0.005, 0.35)})
# The following excludes data sets with fewer than 4 data points and not enough distribution..
# print 'peak', float(res.parameters[1])
j = 0
k = 0
for i in hml[:, 1]:
if float(i) > float(res.parameters[1]):
j += 1
else:
k += 1
if j >= 2 and k >= 2:
print len(hml[:, 1])
if len(hml[:, 1]) > 3:
# print res.errors
# print model
sncosmo.plot_lc(hml_dat, model=fitted_model, errors=res.errors, color='blue', figtext=str(
hml[:, 0][0] + ' Type' + types[hml[:, 0][0]] + '\n' + 'Model name: ' + source.name), xfigsize=10)
plt.show()
print 'Done:', hml[:, 0][0], 'z:', float(
res.parameters[0]), 'Reduced chi^2:', res.chisq / res.ndof, 'Data points:', len(
hml[:, 1]), '\n' # 'Dof:', res.ndof
else:
pass
def fitcurve(x, source_name, hml):
try:
source=sncosmo.get_source(source_name)
model=sncosmo.Model(source=source)
#adding zpsys and filter columns
ab=np.zeros(len(hml[:,1]), dtype='|S2')
for i in range(len(ab)):
ab[i]='ab'
hml=np.column_stack((hml,ab))
band=np.zeros(len(hml[:,1]), dtype='|S6')
for i in range(len(band)):
band[i]='ptf48r'
hml=np.column_stack((hml,band))
#fit to model
z0 = float(spec_z(x[:-7]))
hml_dat=astropy.table.Table(data=hml, names=('ptfname', 'time', 'magnitude', 'mag_err', 'flux', 'flux_err', 'zp_new', 'zp', 'ra', 'dec', 'zpsys', 'filter'), dtype=('str','float','float','float','float','float','float','float','float','float','str', 'str'))
res, fitted_model=sncosmo.fit_lc(hml_dat, model, ['z','t0','amplitude'], bounds={'z':(z0,z0 + 0.0001)}, nburn=10000, nsamples=50000)
#The following excludes data points not in the range of the model and data sets with fewer than 4 data points
limit = modellimit(source_name, x[:-7], res.parameters[1])
hml2 = []
for j in range(len(hml[:,1])):
datapoint = hml [:,1][j]
if (res.parameters[1]- limit[0])< float(datapoint) < (res.parameters[1]+limit[1]):
hml2.append(hml[j])
hml2 = np.array(hml2)
if len(hml2)>3:
return finalfitcurve(x, source_name, hml2)
except ValueError:
print 'error'
def fitting(self, sn_name):
"""Fit the light curve for a SN (data as Astropy table) using the model
SALT2 z and mwebv are setted, it returns the values of the SALT2 parameters
and their errors. We plot the fit on the notebook.
"""
self.read(sn_name)
self.source = sncosmo.get_source('salt2', version='2.4')
dust = sncosmo.CCM89Dust()
self.model = sncosmo.Model(source=self.source,
effects=[dust],
effect_names=['mw'],
effect_frames=['obs'])
self.model.set(mwebv=self.mwebv)
self.model.set(z=self.zhl)
#self.model.set(c=0)
try:
res, fitted_model = sncosmo.fit_lc(self.data,
self.model,
['t0', 'x1', 'c', 'x0'],
phase_range=(-15, 45))
#res, fitted_model = sncosmo.fit_lc(self.data, self.model, ['t0','x1', 'x0'])
#return res, fitted_model
except:
#except RuntimeError:
print('Fail:', sn_name)
res, fitted_model = 'fit fail', np.nan
return res, fitted_model
def fitting_z(self, sn_name):
"""SALT2 fit using SNCOSMO for the SN without => z free parameter of the
fit
"""
self.read(sn_name)
self.source = sncosmo.get_source('salt2', version='2.4')
dust = sncosmo.CCM89Dust()
self.model = sncosmo.Model(source=self.source,
effects=[dust],
effect_names=['mw'],
effect_frames=['obs'])
self.model.set(mwebv=self.mwebv)
#self.model.set(c=0)
try:
results, fit_model = sncosmo.fit_lc(self.data, self.model,
['t0', 'x1', 'c', 'x0'])
#res, fitted_model = sncosmo.fit_lc(self.data, self.model, ['t0','x1', 'x0'])
#return res, fitted_model
except:
#except RuntimeError:
print('Fail:', sn_name)
results, fit_model = 'fit fail', np.nan
return results, fit_model
def showcurve(sn, source_name):
try:
hml=np.load('/home/fcm1g13/Documents/Supernova/CorecollapseLC/ccdata/' + sn)
source=sncosmo.get_source(source_name)
model=sncosmo.Model(source=source)
# print len(hml[:,1]), 'data points'
# Adding zpsys and filter columns. zp system used is ab and filter used is ptf48r
ab = np.zeros(len(hml[:, 1]), dtype='|S2')
band = np.zeros(len(hml[:, 1]), dtype='|S6')
for i in range(len(ab)):
ab[i] = 'ab'
band[i] = 'ptf48r'
hml = np.column_stack((hml, ab, band))
hml_dat=astropy.table.Table(data=hml, names=('ptfname', 'time', 'magnitude', 'mag_err', 'flux', 'flux_err', 'zp_new', 'zp', 'ra', 'dec', 'zpsys', 'filter'), dtype=('str','float','float','float','float','float','float','float','float','float','str', 'str'))
###fitting model
res, fitted_model=sncosmo.fit_lc(hml_dat, model, ['z','t0','amplitude'], bounds={'z':(0.005,0.35)}, nburn=10000, nsamples=50000)
#print 'peak', float(res.parameters[1])
print res
sncosmo.plot_lc(hml_dat, model=fitted_model, errors=res.errors, color='blue', figtext=str(hml[:,0][0]+' Type'+types[hml[:,0][0]]+'\n'+'Model name: '+ source.name), xfigsize=10)
#plt.clfig()
plt.show()
#print #'### Parameters ###'
#print 'SN',str(hml[:,0][0]), 'z:',float(res.parameters[0])# float(res.errors['z']), float(res.parameters[1]), float(res.errors['t0']),float(res.parameters[2]), float(res.errors['x0']), float(res.parameters[3]), float(res.errors['x1']), float(res.parameters[4]), float(res.errors['c']), float(hml[:,8][0]), float(hml[:,9][0])
print 'Done:', hml[:,0][0], 'z:',float(res.parameters[0]), 'Reduced chi^2:', res.chisq/res.ndof,#'Data points:', len(hml[:,1]),' Type'+types[hml[:,0][0]]+'Model name: '+ source.name,'\n' #'Dof:', res.ndof
except ValueError:
sn, source_name, 'cannot be plotted'
def fit_lc(self, taxis, band): data = simlc().reals(taxis, band)[0] mod = self.model res, fitted_model = sncosmo.fit_lc(data, mod, ['t0']) return res, fitted_model
def fit_lc(self, taxis, band):
data = simlc().reals(taxis, band)[0]
mod = self.model
res, fitted_model = sncosmo.fit_lc(data, mod, ['t0'])
return res, fitted_model
def get_summary_stats(z, lc, method="emcee", convert_x0_to_mb=True):
model = sncosmo.Model(source="salt2-extended")
model.set(z=z)
if method == "emcee":
res, fitted_model = sncosmo.mcmc_lc(lc, model, ["t0", "x0", "x1", "c"])
elif method == "minuit":
res, fitted_model = sncosmo.fit_lc(lc, model, ["t0", "x0", "x1", "c"])
else:
raise ValueError("Method %s not recognised" % method)
parameters = res.parameters[2:]
if convert_x0_to_mb:
determined_parameters = {k: v for k, v in zip(res.param_names, res.parameters)}
model.set(**determined_parameters)
mb = fitted_model.source.peakmag("bessellb", "ab")
parameters = np.array([mb, parameters[1], parameters[2]])
x0, x1, c = 1, 2, 3
sigma_mb2 = 5 * np.sqrt(res.covariance[x0, x0]) / (2 * x0 * np.log(10))
sigma_mbx1 = -5 * res.covariance[x0, x1] / (2 * x0 * np.log(10))
sigma_mbc = -5 * res.covariance[x0, c] / (2 * x0 * np.log(10))
cov = res.covariance
cov = np.array(
[
[sigma_mb2, sigma_mbx1, sigma_mbc],
[sigma_mbx1, cov[x1, x1], cov[x1, c]],
[sigma_mbc, cov[x1, c], cov[c, c]],
]
)
else:
cov = res.covariance[1:, :][:, 1:]
return parameters, cov
def fit_all(self, modelcov=False):
"""
"""
if modelcov:
# TODO: Implement fitting with modelcov
# from hacked_sncosmo_fitting import fit_lc_hacked
raise NotImplementedError("Model covariance coming soon.")
param0 = self._get_current_model_param_()
self._derived_properties["raw_fit"] = []
self._derived_properties["idx_good"] = []
for k, lc in enumerate(self.lightcurves):
for pname in [name for name in self.model.param_names if name not in self.fit_param and name != "mwr_v"]:
if pname not in lc.meta.keys():
raise KeyError("Parameter '%s' not in lightcurve meta dict" % pname)
self.model.set(**{pname: lc.meta[pname]})
try:
if modelcov:
res, _ = fit_lc_hacked(lc, self.model, self.fit_param)
else:
res, _ = sncosmo.fit_lc(lc, self.model, self.fit_param)
if res["covariance"] is not None:
self._derived_properties["raw_fit"].append(res)
self._derived_properties["idx_good"].append(k)
else:
print "Light curve fit #%i failed" % k
except sncosmo.fitting.DataQualityError:
print "Light curve fit #%i failed because of data quality" % k
except RuntimeError:
print "Light curve fit #%i failed to converge" % k
self.model.set(**param0)
def finalfitcurve(x, source_name, hml):
try:
source = sncosmo.get_source(source_name)
model = sncosmo.Model(source=source)
#fit to model
z0 = float(spec_z(x[:-7]))
hml_dat = astropy.table.Table(
data=hml,
names=('ptfname', 'time', 'magnitude', 'mag_err', 'flux',
'flux_err', 'zp_new', 'zp', 'ra', 'dec', 'zpsys', 'filter'),
dtype=('str', 'float', 'float', 'float', 'float', 'float', 'float',
'float', 'float', 'float', 'str', 'str'))
res, fitted_model = sncosmo.fit_lc(hml_dat,
model, ['z', 't0', 'amplitude'],
bounds={'z': (z0, z0 + 0.0001)},
nburn=10000,
nsamples=50000)
#The following excludes data with not enough distribution..
##Ensuring at least 2 data points on either side of peak.
limit = modellimit(source_name, x[:-7], res.parameters[1])
j = 0
k = 0
for i in hml[:, 1]:
if float(i) > float(limit[2]):
j += 1
else:
k += 1
if j >= 2 and k >= 2:
return np.array([
float(res.chisq / res.ndof), hml[:, 0][0], source_name
]), hml #returns reduced chi squared, sn name and model name.
except ValueError:
print 'error'
def get_supernova(self, z, num_obs, tmin, tmax, cosmology, alpha, beta,
x0_mean=-19.3, x0_sigma=0.1):
t0 = np.random.uniform(tmin, tmax)
ts = np.linspace(t0 - 60, t0 + 60, num_obs)
times = np.array([[t, t + 0.1, t + 0.2] for t in ts]).flatten()
bands = [b for t in ts for b in ['desg', 'desr', 'desi']]
gains = np.ones(times.shape)
skynoise = 20 * np.ones(times.shape)
zp = 30 * np.ones(times.shape)
zpsys = ['ab'] * times.size
obs = Table({'time': times,
'band': bands,
'gain': gains,
'skynoise': skynoise,
'zp': zp,
'zpsys': zpsys})
model = sncosmo.Model(source='salt2')
mabs = np.random.normal(x0_mean, x0_sigma)
model.set(z=z)
x1 = np.random.normal(0., 1.)
c = np.random.normal(0., 0.2)
mabs = mabs - alpha * x1 + beta * c
model.set_source_peakabsmag(mabs, 'bessellb', 'ab', cosmo=cosmology)
x0 = model.get('x0')
p = {'z': z,
't0': t0,
'x0': x0,
'x1': x1,
'c': c
}
lcs = sncosmo.realize_lcs(obs, model, [p])
res, fitted_model = sncosmo.fit_lc(lcs[0], model, ['t0', 'x0', 'x1', 'c'])
determined_parameters = {k: v for k, v in zip(res.param_names, res.parameters)}
model.set(**determined_parameters)
mb = fitted_model.source.peakmag("bessellb", "ab")
x0_ind = res.vparam_names.index('x0')
x1_ind = res.vparam_names.index('x1')
c_ind = res.vparam_names.index('c')
x0 = res.parameters[res.param_names.index('x0')]
x1 = res.parameters[res.param_names.index('x1')]
c = res.parameters[res.param_names.index('c')]
sigma_mb2 = 5 * np.sqrt(res.covariance[x0_ind, x0_ind]) / (2 * x0 * np.log(10))
sigma_mbx1 = -5 * res.covariance[x0_ind, x1_ind] / (2 * x0 * np.log(10))
sigma_mbc = -5 * res.covariance[x0_ind, c_ind] / (2 * x0 * np.log(10))
covariance = np.array([[sigma_mb2, sigma_mbx1, sigma_mbc],
[sigma_mbx1, res.covariance[x1_ind, x1_ind],
res.covariance[x1_ind, c_ind]],
[sigma_mbc, res.covariance[x1_ind, c_ind],
res.covariance[c_ind, c_ind]]])
icov = np.linalg.inv(covariance)
return [mb, x1, c, covariance, icov]
def sncosmoFit(datacat_name='sncosmo_SN2018kp.txt'):
"""
z = 0.007166 ; NED
"""
import sncosmo
data = ascii.read(datacat_name)
magsys = sncosmo.CompositeMagSystem(
bands={
'standard::b': ('ab', 9.851778333549941),
'standard::v': ('ab', 10.165691850734973),
'standard::r': ('ab', 9.780891653643735),
'standard::i': ('ab', 10.00617773098994)
})
dust1 = sncosmo.F99Dust(r_v=3.1)
dust = sncosmo.F99Dust(r_v=1.766)
model = sncosmo.Model(source='salt2',
effects=[dust, dust1],
effect_names=['host', 'mw'],
effect_frames=['rest', 'obs'])
model.set(z=0.010142)
#model.set_source_peakabsmag(-19,'standard::b', 'ab')
model.param_names
model.parameters
print('Set the model like this;', model)
#source = sncosmo.SALT2Source(modeldir='/home/lim9/.astropy/cache/sncosmo/models/salt2/salt2-4')
### Applying cuts
minsnr = 3
tl = data['mjd'][0]
tu = data['mjd'][0] + 50.
#mask = (data['mjd'] >= tl) & (data['mjd'] < tu)
#mask = (data['mjd'] >= tl) & (data['mjd'] < tu) & (data['flux'] / data['fluxerr'] > minsnr)
#data = data[mask]
params_to_fit = ['t0', 'x0', 'x1', 'c', 'hostebv', 'mwebv']
bounds = {'hostebv': (0, 1.0), 't0': (58158, 58160), 'mwebv': (0, 1.0)}
#bounds = { 't0':(58618, 58620), 'x0':(0.01,0.05), 'x1':(-2,-0.5), 'c':(0.0, 0.15), 'hostebv':(0, 0.1)}
result, fitted_model = sncosmo.fit_lc(data,
model,
params_to_fit,
guess_amplitude=False,
guess_t0=True,
guess_z=False,
bounds=bounds,
method='minuit',
modelcov=True,
phase_range=(-20, 75),
verbose=True)
print("Number of chi^2 function calls :", result.ncall)
print("Number of degrees of freedom in fit :", result.ndof)
print("Chi^2 value at minimum :", result.chisq)
print("Reduced Chi^2 :", result.chisq / result.ndof)
print("Model parameters :", result.param_names)
print("Best-fit values :", result.parameters)
print("The result contains the following attributes:\n", result.keys())
sncosmo.plot_lc(data,
model=fitted_model,
errors=result.errors,
pulls=True,
figtext='SN 2018kp; SALT2',
show_model_params=True)
def fits(self):
"""
`sncosmo.fit_lc` return which is a tuple to fit results, and sncosmo
model set to best fit model.
"""
return sncosmo.fit_lc(self.SNCosmoLC(scattered=True,
nightlyCoadd=True, seed=0), model=self.sncosmoModel,
vparam_names=['t0', 'x0', 'x1', 'c'], minsnr=0.01)
def test_fit_lc(self):
res, fitmodel = sncosmo.fit_lc(self.data, self.model,
['z', 't0', 'amplitude'],
bounds={'z': (0., 1.0)})
# set model to true parameters
self.model.set(**self.params)
assert_allclose(res.parameters, self.model.parameters, rtol=1.e-3)
def fit_lcs(self):
self.fit_results = []
self.fitted_model = []
for jj, lc in enumerate(self.lcs):
self.model.set(z=self.totz[jj])
res, fitted_model = sncosmo.fit_lc(lc[0], self.model,['z','x0', 'x1', 'c','t0'],\
bounds={'x1':(-3.0, 3.0), 'c':(-0.3,0.3),'z':(0.0,1.2)}, minsnr =self.minSNR)
self.fit_results.append(res)
self.fitted_model.append(fitted_model)
def fitmodel(self, modeldir='/Users/rodney/Dropbox/WFIRST/SALT2IR',
salt2subdir='salt2ir', fitbands=None):
""" fit a new model to the data
:param modeldir:
:return:
"""
salt2irmodeldir = os.path.join(modeldir, salt2subdir)
salt2irsource = sncosmo.models.SALT2Source(
modeldir=salt2irmodeldir, name=salt2subdir)
salt2irmodel = sncosmo.Model(source=salt2irsource)
# limit the fit to specific bands if requested
if fitbands is None:
datatofit = self.lcdata
else:
if isinstance(fitbands, basestring):
fitbands = [fitbands]
itofit = np.array([], dtype=int)
for fitband in fitbands:
ithisband = np.where(self.band == fitband)[0]
itofit = np.append(itofit, ithisband)
datatofit = self.lcdata[itofit]
if 'salt2x1' not in self.__dict__:
print("No SALT2 fitres data available for this SN."
" No predefined model")
self.model_fixedx1c = None
salt2irmodel.set(z=self.z, x1=0, c=0.1)
else:
# evaluate the SALT2 model for the given redshift, x1, c
salt2irmodel.set(z=self.z, t0=self.TBmax,
x1=self.salt2x1, c=self.salt2c)
salt2irmodel.set_source_peakabsmag(-19.3, 'bessellb','AB')
# fit the model without allowing x1 and c to vary
res, model_fixedx1c = sncosmo.fit_lc(
datatofit, salt2irmodel, ['t0', 'x0'], bounds={})
self.model_fixedx1c = model_fixedx1c
# fit the model allowing all parameters to vary
res, model_fitted = sncosmo.fit_lc(
datatofit, salt2irmodel, ['t0', 'x0', 'x1', 'c'],
bounds={'x1':[-3,3], 'c':[-0.5,0.5]})
self.model_fitted = model_fitted
def fitcurve(x, source_name):
# Get data set needed
hml = np.load('/home/fcm1g13/Documents/Supernova/CorecollapseLC/ccdata/' +
x)
try:
# Import model
source = sncosmo.get_source(source_name)
model = sncosmo.Model(source=source)
# print len(hml[:,1]), 'data points'
# Adding zpsys and filter columns. zp system used is ab and filter used is ptf48r
ab = np.zeros(len(hml[:, 1]), dtype='|S2')
band = np.zeros(len(hml[:, 1]), dtype='|S6')
for i in range(len(ab)):
ab[i] = 'ab'
band[i] = 'ptf48r'
hml = np.column_stack((hml, ab, band))
# Converting into a table using astropy with titles: ptfname, time,
# magnitude, mag_err, flux, flux_err, zp_new, zp, ra, dec, zpsys and filter
hml_dat = astropy.table.Table(
data=hml,
names=('ptfname', 'time', 'magnitude', 'mag_err', 'flux',
'flux_err', 'zp_new', 'zp', 'ra', 'dec', 'zpsys', 'filter'),
dtype=('str', 'float', 'float', 'float', 'float', 'float', 'float',
'float', 'float', 'float', 'str', 'str'))
# Fitting model: model parameter z bound.
res, fitted_model = sncosmo.fit_lc(hml_dat,
model, ['z', 't0', 'amplitude'],
bounds={'z': (0.005, 0.35)})
#The following excludes data with fewer than 4 data points and not enough distribution..
j = 0
k = 0
for i in hml[:, 1]:
if float(i) > float(res.parameters[1]):
j += 1
else:
k += 1
# print hml[:,0][0],k,j
if j >= 2 and k >= 2:
if len(hml[:, 1]) > 3:
#sncosmo.plot_lc(hml_dat, model=fitted_model, errors=res.errors, color='blue', figtext=str(hml[:,0][0]+' Type'+types[hml[:,0][0]]+'\n'+'Model name: '+ source.name), xfigsize=10)
#plt.close()
return np.array([
float(res.chisq / res.ndof), hml[:, 0][0], source_name
]) #returns reduced chi squared, sn name and model name.
else:
pass
else:
pass
except ValueError:
pass
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 test_fit_lc(self):
"""Ensure that fit results match input model parameters (data are
noise-free)."""
res, fitmodel = sncosmo.fit_lc(self.data, self.model,
['z', 't0', 'amplitude'],
bounds={'z': (0., 1.0)})
# set model to true parameters and compare to fit results.
self.model.set(**self.params)
assert_allclose(res.parameters, self.model.parameters, rtol=1.e-3)
def fitmodel(self,
modeldir='/Users/rodney/Dropbox/WFIRST/SALT2IR',
salt2subdir='salt2ir',
useknownx1c=False):
""" fit a new model to the data
:param modeldir:
:return:
"""
salt2modeldir = os.path.join(modeldir, salt2subdir)
salt2source = sncosmo.models.SALT2Source(modeldir=salt2modeldir,
name=salt2subdir)
salt2model = sncosmo.Model(source=salt2source)
if useknownx1c:
if 'salt2x1' not in self.__dict__:
print(
"No SALT2 fitres data available for this SN."
" No predefined model")
self.model_fitted = None
salt2model.set(z=self.z, x1=0, c=0.1)
else:
# evaluate the SALT2 model for the given redshift, x1, c
salt2model.set(z=self.z,
t0=self.TBmax,
x1=self.salt2x1,
c=self.salt2c)
salt2model.set_source_peakabsmag(-19.3, 'bessellb', 'AB')
# fit the model without allowing x1 and c to vary
res, model_fixedx1c = sncosmo.fit_lc(self.datatofit,
salt2model, ['t0', 'x0'],
bounds={})
self.model_fitted = model_fixedx1c
else:
# fit the model allowing all parameters to vary
res, model_fitted = sncosmo.fit_lc(self.datatofit,
salt2model,
['t0', 'x0', 'x1', 'c'],
bounds={
'x1': [-5, 5],
'c': [-0.5, 1.5]
})
self.model_fitted = model_fitted
def fit_mag(
model: SNModel,
light_curves: Collection[Table],
vparams: List[str],
bands: Collection[str],
pwv_arr: Collection[types.Numeric] = None,
z_arr: Collection[types.Numeric] = None,
**kwargs
) -> Tuple[Dict[str, np.ndarray], ...]:
"""Determine apparent mag by fitting simulated light-curves
Returned arrays are shape (len(pwv_arr), len(z_arr)).
Args:
model: The sncosmo model to use when fitting
light_curves: Array of light-curves to fit
vparams: Parameters to vary with the fit
bands: Name of the bands to tabulate magnitudes for
pwv_arr: Array of PWV values
z_arr: Array of redshift values
Any arguments for ``sncosmo.fit_lc``.
Returns:
Dictionary with arrays for fitted magnitude at each PWV and redshift
Dictionary with arrays for fitted parameters at each PWV and redshift
"""
model = copy(model)
fitted_mag = {b: [] for b in bands}
fitted_params = {b: [] for b in bands}
for lc in light_curves:
# Use the true light-curve parameters as the initial guess
lc_parameters = deepcopy(lc.meta)
lc_parameters.pop('pwv', None)
lc_parameters.pop('res', None)
# Fit the model without PWV
model.update(lc_parameters)
_, fitted_model = sncosmo.fit_lc(lc, model, vparams, **kwargs)
for band in bands:
fitted_mag[band].append(fitted_model.bandmag(band, 'ab', 0))
fitted_params[band].append(fitted_model.parameters)
if pwv_arr is not None and z_arr is not None:
# We could have used a more complicated collection pattern, but reshaping
# after the fact is simpler.
shape = (len(pwv_arr), len(z_arr))
num_params = len(fitted_model.parameters)
for band in bands:
fitted_mag[band] = np.reshape(fitted_mag[band], shape)
fitted_params[band] = np.reshape(fitted_params[band], (*shape, num_params))
return fitted_mag, fitted_params
def test_fit_lc_spectra(self):
"""Check fit results for a single high-resolution spectrum."""
self.model.set(**self.start_params)
res, fitmodel = sncosmo.fit_lc(model=self.model,
spectra=self.bin_spectrum,
vparam_names=['amplitude', 'z', 't0'],
bounds={'z': (0., 0.3)})
# set model to true parameters and compare to fit results.
self.model.set(**self.params)
assert_allclose(res.parameters, self.model.parameters, rtol=1.e-3)
def test_flatten_result(self):
"""Ensure that the flatten_result function works correctly."""
res, fitmodel = sncosmo.fit_lc(self.data,
self.model, ['amplitude', 'z', 't0'],
bounds={'z': (0., 1.0)})
flat_result = sncosmo.flatten_result(res)
# Make sure that we got a dictionary of results back.
assert isinstance(flat_result, dict)
assert len(flat_result) > 0
def test_fit_lc_returns_correct_type(self) -> None:
"""Test the fit_lc function returns an ``SNModel`` instance for the fitted model"""
data = sncosmo.load_example_data()
model = SNModel('salt2')
with warnings.catch_warnings():
warnings.filterwarnings('ignore')
_, fitted_model = sncosmo.fit_lc(data, model, ['x0'])
self.assertIsInstance(fitted_model, SNModel)
def fits(self):
"""
`sncosmo.fit_lc` return which is a tuple to fit results, and sncosmo
model set to best fit model.
"""
return sncosmo.fit_lc(self.SNCosmoLC(scattered=True,
nightlyCoadd=True,
seed=0),
model=self.sncosmoModel,
vparam_names=['t0', 'x0', 'x1', 'c'],
minsnr=0.01)
def test_fit_lc(self):
"""Ensure that fit results match input model parameters (data are
noise-free).
Pass in parameter names in order different from that stored in
model; tests parameter re-ordering."""
res, fitmodel = sncosmo.fit_lc(self.data, self.model, ["amplitude", "z", "t0"], bounds={"z": (0.0, 1.0)})
# set model to true parameters and compare to fit results.
self.model.set(**self.params)
assert_allclose(res.parameters, self.model.parameters, rtol=1.0e-3)
def test_fit_lc_both(self):
"""Check fit results for both spectra and photometry."""
self.model.set(**self.start_params)
res, fitmodel = sncosmo.fit_lc(self.photometry,
model=self.model,
spectra=self.bin_spectrum,
vparam_names=['amplitude', 'z', 't0'],
bounds={'z': (0., 0.3)})
# set model to true parameters and compare to fit results.
self.model.set(**self.params)
assert_allclose(res.parameters, self.model.parameters, rtol=1.e-3)
def test_fit_lc(self):
"""Ensure that fit results match input model parameters (data are
noise-free).
Pass in parameter names in order different from that stored in
model; tests parameter re-ordering."""
res, fitmodel = sncosmo.fit_lc(self.data,
self.model, ['amplitude', 'z', 't0'],
bounds={'z': (0., 1.0)})
# set model to true parameters and compare to fit results.
self.model.set(**self.params)
assert_allclose(res.parameters, self.model.parameters, rtol=1.e-3)
def from_fit(cls, table, values={}, fixed={}, bounds=None):
""""""
model = get_saltmodel()
model.set(**{**values, **fixed})
parameters = [
p_ for p_ in ['z', 't0', 'x0', 'x1', 'c'] if p_ not in fixed
]
result, fitted_model = sncosmo.fit_lc(
table,
model,
parameters, # parameters of model to vary
bounds=bounds)
return cls(result=result, fitted_model=fitted_model, data=table)
def __init__(self, data, model, SaltModel):
self.data = data
test_data = photdata.photometric_data(deepcopy(data))
self.model = model
self.z = self.model.get('z')
self.bands = np.unique(self.data['band'])
self.x1_prior = (0, np.sqrt(2))
self.s_prior = (0, np.sqrt(2))
self.c_prior = (0, 0.15)
self.SaltModel = SaltModel
self.ndim = 5
self.nwalkers = 100
self.tmax_guess, self.x0_start = sncosmo.fitting.guess_t0_and_amplitude(
test_data, self.model, minsnr=3)
self.tmax_bounds = sncosmo.fitting.t0_bounds(test_data, self.model)
# try guess tmax ourselves
t = np.arange(self.tmax_bounds[0], self.tmax_bounds[1] + 1, 1)
test_chi = 1e20
test_time = 0
test_x0 = 0
x0arr = []
for time in t:
params = [self.x0_start, 0, 0, 0, time]
self.SaltModel.set(t0=time, x0=self.x0_start, x1=0, c=0, z=self.z)
res, fitted_model = sncosmo.fit_lc(deepcopy(self.data),
self.SaltModel, ['x0'],
guess_amplitude=False,
guess_t0=False,
modelcov=False)
c = res.chisq
x0arr.append(res.parameters[2])
if np.isnan(c) or np.isinf(c):
continue
if c < test_chi:
test_chi = c
test_time = time
test_x0 = res.parameters[2]
self.tmax_guess = test_time
self.x0_start = test_x0
self.nest_bounds = {
't0': self.tmax_bounds,
'x1': [-4, 4],
'c': [-1, 1],
'x0': [np.min(x0arr), np.max(x0arr)]
}
def showcurve(sn, source_name):
try:
hml = np.load(
'/home/fcm1g13/Documents/Supernova/CorecollapseLC/ccdata/' + sn)
source = sncosmo.get_source(source_name)
model = sncosmo.Model(source=source)
# print len(hml[:,1]), 'data points'
# Adding zpsys and filter columns. zp system used is ab and filter used is ptf48r
ab = np.zeros(len(hml[:, 1]), dtype='|S2')
band = np.zeros(len(hml[:, 1]), dtype='|S6')
for i in range(len(ab)):
ab[i] = 'ab'
band[i] = 'ptf48r'
hml = np.column_stack((hml, ab, band))
hml_dat = astropy.table.Table(
data=hml,
names=('ptfname', 'time', 'magnitude', 'mag_err', 'flux',
'flux_err', 'zp_new', 'zp', 'ra', 'dec', 'zpsys', 'filter'),
dtype=('str', 'float', 'float', 'float', 'float', 'float', 'float',
'float', 'float', 'float', 'str', 'str'))
###fitting model
res, fitted_model = sncosmo.fit_lc(hml_dat,
model, ['z', 't0', 'amplitude'],
bounds={'z': (0.005, 0.35)},
nburn=10000,
nsamples=50000)
#print 'peak', float(res.parameters[1])
print res
sncosmo.plot_lc(
hml_dat,
model=fitted_model,
errors=res.errors,
color='blue',
figtext=str(hml[:, 0][0] + ' Type' + types[hml[:, 0][0]] + '\n' +
'Model name: ' + source.name),
xfigsize=10)
#plt.clfig()
plt.show()
#print #'### Parameters ###'
#print 'SN',str(hml[:,0][0]), 'z:',float(res.parameters[0])# float(res.errors['z']), float(res.parameters[1]), float(res.errors['t0']),float(res.parameters[2]), float(res.errors['x0']), float(res.parameters[3]), float(res.errors['x1']), float(res.parameters[4]), float(res.errors['c']), float(hml[:,8][0]), float(hml[:,9][0])
print 'Done:', hml[:, 0][0], 'z:', float(
res.parameters[0]
), 'Reduced chi^2:', res.chisq / res.ndof, #'Data points:', len(hml[:,1]),' Type'+types[hml[:,0][0]]+'Model name: '+ source.name,'\n' #'Dof:', res.ndof
except ValueError:
sn, source_name, 'cannot be plotted'
def fitcurve(x, source_name):
# Get data set needed
hml=np.load('/home/fcm1g13/Documents/Supernova/CorecollapseLC/ccdata/' + x)
try:
# Import model
source=sncosmo.get_source(source_name)
model=sncosmo.Model(source=source)
# print len(hml[:,1]), 'data points'
# Adding zpsys and filter columns. zp system used is ab and filter used is ptf48r
ab = np.zeros(len(hml[:, 1]), dtype='|S2')
band = np.zeros(len(hml[:, 1]), dtype='|S6')
for i in range(len(ab)):
ab[i] = 'ab'
band[i] = 'ptf48r'
hml = np.column_stack((hml, ab, band))
# Converting into a table using astropy with titles: ptfname, time,
# magnitude, mag_err, flux, flux_err, zp_new, zp, ra, dec, zpsys and filter
hml_dat = astropy.table.Table(data=hml, names=(
'ptfname', 'time', 'magnitude', 'mag_err', 'flux', 'flux_err', 'zp_new', 'zp', 'ra', 'dec', 'zpsys',
'filter'),
dtype=(
'str', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float',
'float', 'str', 'str'))
# Fitting model: model parameter z bound.
res, fitted_model = sncosmo.fit_lc(hml_dat, model, ['z', 't0', 'amplitude'], bounds={'z': (0.005, 0.35)})
#The following excludes data with fewer than 4 data points and not enough distribution..
j=0; k=0
for i in hml[:,1]:
if float(i)>float(res.parameters[1]):
j+=1
else:
k+=1
# print hml[:,0][0],k,j
if j>=2 and k>=2:
if len(hml[:,1])>3:
#sncosmo.plot_lc(hml_dat, model=fitted_model, errors=res.errors, color='blue', figtext=str(hml[:,0][0]+' Type'+types[hml[:,0][0]]+'\n'+'Model name: '+ source.name), xfigsize=10)
#plt.close()
return np.array([float(res.chisq/res.ndof), hml[:,0][0], source_name]) #returns reduced chi squared, sn name and model name.
else:
pass
else:
pass
except ValueError:
pass
def Fit_LC(self,t):
select=t[np.where(np.logical_and(t['flux']/t['fluxerr']>5.,t['flux']>0.))]
#print 'fit',len(select)
if len(select)>=5:
#print 'data to be fitted',select
try:
#print 'before fit here'
#print 'SN parameters',self.SN.SN
#print 'fitting',select
z_sim=self.SN.z
#print 'hello z',z_sim
#print 'fit it',val,time.time()-self.thetime
res, fitted_model = sncosmo.fit_lc(select, self.SN.SN_fit_model,['z', 't0', 'x0', 'x1', 'c'],bounds={'z':(z_sim-0.01, z_sim+0.01)})
#res, fitted_model = sncosmo.fit_lc(select, self.SN.SN,['t0', 'x0', 'x1', 'c'])
#print 'after fit',res.keys()
#print res.keys()
"""
print 'after fit'
print res['parameters'],res['errors']
"""
mbfit=fitted_model._source.peakmag('bessellb','vega')
#print 'oooo test',-2.5*np.log10(res['parameters'][2])+10.635,fitted_model.bandmag('bessellb','vega',res['parameters'][1]),mbsim,mbfit,mbsim-mbfit
"""
sncosmo.plot_lc(t, model=fitted_model,color='k',pulls=False)
plt.show()
"""
#print 'fitted'
return res,fitted_model,mbfit,'ok'
except (RuntimeError, TypeError, NameError):
#print 'crashed'
return None,None,-1,'crash'
else:
return None,None,-1,'Noobs'
def dofitSCP0401(datfile='HST_SCP_0401.sncosmo.dat',
z=1.713,
t0=53080.0,
dt0=50.0):
# TODO : read in the redshift, etc from the header.
# read in the obs data
sn = ascii.read(datfile,
format='commented_header',
header_start=-1,
data_start=0)
# define SALT2 models and set initial guesses for z and t0
salt2ex = sncosmo.Model(source='salt2-extended')
salt2ex.source.set_peakmag(0., 'bessellb', 'ab')
x0_AB0 = salt2ex.get('x0')
x0_from_mB = lambda m: x0_AB0 * 10**(-0.4 * (m))
salt2ex.set(z=1.713, t0=53090.0, x0=x0_from_mB(26.14), x1=0.2, c=-0.1)
# salt2ex.set( z=1.33, t0=56814.6, hostebv=0.05, hostr_v=3.1 )
# Do a bounded fit :
#res, fit = sncosmo.fit_lc( sn, salt2ex, ['z','t0','x0','x1','c'],
# bounds={'z':(1.712,1.714),'t0':(t0-dt0,t0+dt0),
# 'x1':(-5.,5.), 'c':(-0.5,3.0) })
res, fit = sncosmo.fit_lc(sn,
salt2ex, ['z', 't0', 'x0'],
bounds={
'z': (1.712, 1.714),
't0': (t0 - dt0, t0 + dt0)
})
x0 = fit.get('x0')
mB = -2.5 * np.log10(x0 / x0_AB0)
distmod = mB - -19.19 # MBmodel from Rubin et al 2013
deltamuLCDM = distmod - dm(z)
print("mB = %.2f" % mB)
print("dist.mod. = %.2f" % distmod)
print("Delta.mu_LCDM = %.2f" % deltamuLCDM)
chi2 = res.chisq
ndof = res.ndof
pval = chisqprob(chi2, ndof)
print("chi2/dof= %.3f" % (chi2 / float(ndof)))
print("p-value = %.3f" % pval)
return (sn, fit, res)
def simple_fit(data, model, vparam_names, **kwargs):
"""Fit light curves using the basic ``fit_lc`` functionality in ``sncosmo``
Args:
data (Table): Table of photometric data
model (Model): The model to fit
vparam_names (iterable): Model parameters to vary
Any other parameters for ``sncosmo.fit_lc``
Returns:
- A dictionary like object with fit results
- A fitted ``Model`` instance
"""
data, model, vparam_names, kwargs = \
_copy_data(data, model, vparam_names, kwargs)
return sncosmo.fit_lc(data, model, vparam_names, **kwargs)
def showcurve(sn, source_name, hml):
try:
source=sncosmo.get_source(source_name)
model=sncosmo.Model(source=source)
#fit to model
z0 = float(spec_z(sn[:-7]))
hml_dat=astropy.table.Table(data=hml, names=('ptfname', 'time', 'magnitude', 'mag_err', 'flux', 'flux_err', 'zp_new', 'zp', 'ra', 'dec', 'zpsys', 'filter'), dtype=('str','float','float','float','float','float','float','float','float','float','str', 'str'))
res, fitted_model=sncosmo.fit_lc(hml_dat, model, ['z','t0','amplitude'], bounds={'z':(z0, z0+0.001)}, nburn=10000, nsamples=50000)
#plot model
sncosmo.plot_lc(hml_dat, model=fitted_model, errors=res.errors, color='blue', figtext=str(hml[:,0][0]+' Type'+types[hml[:,0][0]]+'\n'+'Model name: '+ source.name + '\n'+'Reduced Chi Squared: ')+ str(res.chisq/res.ndof), xfigsize=10)
plt.show()
#print 'Parameters:''z:',float(res.parameters[0]), float(res.errors['z']), float(res.parameters[1]), float(res.errors['t0']),float(res.parameters[2]), float(res.errors['x0']), float(res.parameters[3]), float(res.errors['x1']), float(res.parameters[4]), float(res.errors['c']), float(hml[:,8][0]), float(hml[:,9][0])'
print 'Done:', hml[:,0][0], 'z:',float(res.parameters[0]), 'Reduced chi^2:', res.chisq/res.ndof,#'Data points:', len(hml[:,1]),' Type'+types[hml[:,0][0]]+'Model name: '+ source.name,'\n' #'Dof:', res.ndof
except ValueError:
print sn, source_name, 'cannot be plotted'
def fitcurve(x, source_name, hml):
try:
source = sncosmo.get_source(source_name)
model = sncosmo.Model(source=source)
#adding zpsys and filter columns
ab = np.zeros(len(hml[:, 1]), dtype='|S2')
for i in range(len(ab)):
ab[i] = 'ab'
hml = np.column_stack((hml, ab))
band = np.zeros(len(hml[:, 1]), dtype='|S6')
for i in range(len(band)):
band[i] = 'ptf48r'
hml = np.column_stack((hml, band))
#fit to model
z0 = float(spec_z(x[:-7]))
hml_dat = astropy.table.Table(
data=hml,
names=('ptfname', 'time', 'magnitude', 'mag_err', 'flux',
'flux_err', 'zp_new', 'zp', 'ra', 'dec', 'zpsys', 'filter'),
dtype=('str', 'float', 'float', 'float', 'float', 'float', 'float',
'float', 'float', 'float', 'str', 'str'))
res, fitted_model = sncosmo.fit_lc(hml_dat,
model, ['z', 't0', 'amplitude'],
bounds={'z': (z0, z0 + 0.0001)},
nburn=10000,
nsamples=50000)
#The following excludes data points not in the range of the model and data sets with fewer than 4 data points
limit = modellimit(source_name, x[:-7], res.parameters[1])
hml2 = []
for j in range(len(hml[:, 1])):
datapoint = hml[:, 1][j]
if (res.parameters[1] - limit[0]) < float(datapoint) < (
res.parameters[1] + limit[1]):
hml2.append(hml[j])
hml2 = np.array(hml2)
if len(hml2) > 3:
return finalfitcurve(x, source_name, hml2)
except ValueError:
print 'error'
def lcFit(df_main):
df_main = df_main.rename({'mjd': 'time', 'passband': 'band'}, axis=1)
df_main['band'] = df_main['band'].map(pb_mapping)
df_main['zp'] = 25
df_main['zpsys'] = 'ab'
data = Table.from_pandas(df_main)
try:
res, fitted_model = sncosmo.fit_lc(data,
model, ['t0', 'x0', 'x1', 'c'],
minsnr=3)
except (RuntimeError, sncosmo.fitting.DataQualityError):
res = {}
res['parameters'] = [0, 0, 0, 0, 0]
res['param_names'] = ['z', 't0', 'x0', 'x1', 'c']
ret = pd.Series(res['parameters'], index=res['param_names'])
ret.drop('z', inplace=True)
ret.drop('t0', inplace=True)
return ret
def SALT2(x):
lsst_band = {
0: "lsstu",
1: "lsstg",
2: "lsstr",
3: "lssti",
4: "lsstz",
5: "lssty",
}
x['passband'].replace(lsst_band, inplace=True)
x['zp'] = 0
x['zpsys'] = 'ab'
x = x.rename(columns={'passband': 'band'})
x.loc[x['band'] == 'lsstu', 'zp'] = 9.17
x.loc[x['band'] == 'lsstg', 'zp'] = 50.7
x.loc[x['band'] == 'lsstr', 'zp'] = 43.7
x.loc[x['band'] == 'lssti', 'zp'] = 32.36
x.loc[x['band'] == 'lsstz', 'zp'] = 22.68
x.loc[x['band'] == 'lssty', 'zp'] = 10.58
# print(x)
x = Table.from_pandas(x)
# magsys = sncosmo.CompositeMagSystem(bands={'lsstu': ('ab', 9.16), 'lsstg': ('ab', 50.7), "lsstr": ('ab', 43.7), "lssti": ('ab', 32.36), "lsstz": ('ab', 22.68), "lssty": ("ab", 10.58)})
# sncosmo.registry.register(magsys, name="my")
# print(x)
try:
result, fitted_model = sncosmo.fit_lc(
x,
model,
['z', 't0', 'x0', 'x1', 'c'], # parameters of model to vary
bounds={'z': (0.3, 0.7)}) # bounds on parameters (if any)
print(result)
except:
return 0
return 0
def fit_curve(hml_dat, source, hml):
# Retrieving model from source, (requires internet access)
model = sncosmo.Model(source=source)
# Fitting model: model parameter z bound.
res, fitted_model = sncosmo.fit_lc(hml_dat,
model, ['z', 't0', 'amplitude'],
bounds={'z': (0.005, 0.35)})
# The following excludes data sets with fewer than 4 data points and not enough distribution..
# print 'peak', float(res.parameters[1])
j = 0
k = 0
for i in hml[:, 1]:
if float(i) > float(res.parameters[1]):
j += 1
else:
k += 1
if j >= 2 and k >= 2:
print len(hml[:, 1])
if len(hml[:, 1]) > 3:
# print res.errors
# print model
sncosmo.plot_lc(
hml_dat,
model=fitted_model,
errors=res.errors,
color='blue',
figtext=str(hml[:, 0][0] + ' Type' + types[hml[:, 0][0]] +
'\n' + 'Model name: ' + source.name),
xfigsize=10)
plt.show()
print 'Done:', hml[:, 0][0], 'z:', float(
res.parameters[0]
), 'Reduced chi^2:', res.chisq / res.ndof, 'Data points:', len(
hml[:, 1]), '\n' # 'Dof:', res.ndof
else:
pass
def test_fit_lc_vs_snfit():
"""Test fit_lc versus snfit result for one SN."""
# purposefully use CCM dust to match snfit
model = sncosmo.Model(source='salt2',
effects=[sncosmo.CCM89Dust()],
effect_names=['mw'],
effect_frames=['obs'])
fname = join(dirname(__file__), "data", "lc-03D4ag.list")
data = sncosmo.read_lc(fname,
format='salt2',
read_covmat=True,
expand_bands=True)
model.set(mwebv=data.meta['MWEBV'], z=data.meta['Z_HELIO'])
result, fitted_model = sncosmo.fit_lc(data,
model, ['t0', 'x0', 'x1', 'c'],
bounds={
'x1': (-3., 3.),
'c': (-0.4, 0.4)
},
modelcov=True,
phase_range=(-15., 45.),
wave_range=(3000., 7000.),
warn=False,
verbose=False)
print(result)
assert result.ndof == 25
assert result.nfit == 3
assert_allclose(fitted_model['t0'], 52830.9313, atol=0.01, rtol=0.)
assert_allclose(fitted_model['x0'], 5.6578663e-05, atol=0., rtol=0.005)
assert_allclose(fitted_model['x1'], 0.937399344, atol=0.005, rtol=0.)
assert_allclose(fitted_model['c'], -0.0851965244, atol=0.001, rtol=0.)
# errors
assert_allclose(result.errors['t0'], 0.0955792638, atol=0., rtol=0.01)
assert_allclose(result.errors['x0'], 1.52745001e-06, atol=0., rtol=0.01)
assert_allclose(result.errors['x1'], 0.104657847, atol=0., rtol=0.01)
assert_allclose(result.errors['c'], 0.0234763446, atol=0., rtol=0.01)
def fitcurve(x, source_name, hml):
try:
source = sncosmo.get_source(source_name)
model = sncosmo.Model(source=source)
# print len(hml[:,1]), 'data points'
# Adding zpsys and filter columns. zp system used is ab and filter used is ptf48r
ab = np.zeros(len(hml[:, 1]), dtype='|S2')
band = np.zeros(len(hml[:, 1]), dtype='|S6')
for i in range(len(ab)):
ab[i] = 'ab'
band[i] = 'ptf48r'
hml = np.column_stack((hml, ab, band))
# Converting into a table using astropy with titles: ptfname, time,
# magnitude, mag_err, flux, flux_err, zp_new, zp, ra, dec, zpsys and filter
hml_dat = astropy.table.Table(
data=hml,
names=('ptfname', 'time', 'magnitude', 'mag_err', 'flux',
'flux_err', 'zp_new', 'zp', 'ra', 'dec', 'zpsys', 'filter'),
dtype=('str', 'float', 'float', 'float', 'float', 'float', 'float',
'float', 'float', 'float', 'str', 'str'))
# Fitting model: model parameter z bound.
res, fitted_model = sncosmo.fit_lc(hml_dat,
model, ['z', 't0', 'amplitude'],
bounds={'z': (0.005, 0.35)})
#The following excludes data points not in the range of the model and data sets with fewer than 4 data points
limit = modellimit(source_name, res.parameters[0], res.parameters[1])
hml2 = []
for j in range(len(hml[:, 1])):
datapoint = hml[:, 1][j]
if (res.parameters[1] - limit[0]) < float(datapoint) < (
res.parameters[1] + limit[1]):
hml2.append(hml[j])
hml2 = np.array(hml2)
if len(hml2) > 3:
return finalfitcurve(x, source_name, hml2)
except ValueError:
pass
def dofitSCP0401( datfile='HST_SCP_0401.sncosmo.dat', z=1.713,
t0=53080.0, dt0=50.0 ) :
# TODO : read in the redshift, etc from the header.
# read in the obs data
sn = ascii.read( datfile, format='commented_header', header_start=-1, data_start=0 )
# define SALT2 models and set initial guesses for z and t0
salt2ex = sncosmo.Model( source='salt2-extended')
salt2ex.source.set_peakmag( 0., 'bessellb', 'ab' )
x0_AB0 = salt2ex.get('x0')
x0_from_mB = lambda m : x0_AB0 * 10**(-0.4*(m) )
salt2ex.set( z=1.713, t0=53090.0, x0=x0_from_mB(26.14), x1=0.2, c=-0.1 )
# salt2ex.set( z=1.33, t0=56814.6, hostebv=0.05, hostr_v=3.1 )
# Do a bounded fit :
#res, fit = sncosmo.fit_lc( sn, salt2ex, ['z','t0','x0','x1','c'],
# bounds={'z':(1.712,1.714),'t0':(t0-dt0,t0+dt0),
# 'x1':(-5.,5.), 'c':(-0.5,3.0) })
res, fit = sncosmo.fit_lc( sn, salt2ex, ['z','t0','x0'],
bounds={'z':(1.712,1.714),'t0':(t0-dt0,t0+dt0)})
x0 = fit.get( 'x0' )
mB = -2.5*np.log10( x0 / x0_AB0 )
distmod = mB - -19.19 # MBmodel from Rubin et al 2013
deltamuLCDM = distmod - dm(z)
print( "mB = %.2f"%mB )
print( "dist.mod. = %.2f"%distmod)
print( "Delta.mu_LCDM = %.2f"%deltamuLCDM)
chi2 = res.chisq
ndof = res.ndof
pval = chisqprob( chi2, ndof )
print( "chi2/dof= %.3f"% (chi2/float(ndof) ) )
print( "p-value = %.3f"% pval )
return( sn, fit, res )
def finalfitcurve(x, source_name, hml):
try:
source=sncosmo.get_source(source_name)
model=sncosmo.Model(source=source)
#fit to model
z0 = float(spec_z(x[:-7]))
hml_dat=astropy.table.Table(data=hml, names=('ptfname', 'time', 'magnitude', 'mag_err', 'flux', 'flux_err', 'zp_new', 'zp', 'ra', 'dec', 'zpsys', 'filter'), dtype=('str','float','float','float','float','float','float','float','float','float','str', 'str'))
res, fitted_model=sncosmo.fit_lc(hml_dat, model, ['z','t0','amplitude'], bounds={'z':(z0, z0+0.0001)}, nburn=10000, nsamples=50000)
#The following excludes data with not enough distribution..
##Ensuring at least 2 data points on either side of peak.
limit = modellimit(source_name, x[:-7], res.parameters[1])
j=0; k=0
for i in hml[:,1]:
if float(i)>float(limit[2]):
j+=1
else:
k+=1
if j>=2 and k>=2:
return np.array([float(res.chisq/res.ndof), hml[:,0][0], source_name]), hml #returns reduced chi squared, sn name and model name.
except ValueError:
print 'error'
def fitcurve(x, source_name, hml):
try:
source=sncosmo.get_source(source_name)
model=sncosmo.Model(source=source)
# print len(hml[:,1]), 'data points'
# Adding zpsys and filter columns. zp system used is ab and filter used is ptf48r
ab = np.zeros(len(hml[:, 1]), dtype='|S2')
band = np.zeros(len(hml[:, 1]), dtype='|S6')
for i in range(len(ab)):
ab[i] = 'ab'
band[i] = 'ptf48r'
hml = np.column_stack((hml, ab, band))
# Converting into a table using astropy with titles: ptfname, time,
# magnitude, mag_err, flux, flux_err, zp_new, zp, ra, dec, zpsys and filter
hml_dat = astropy.table.Table(data=hml, names=(
'ptfname', 'time', 'magnitude', 'mag_err', 'flux', 'flux_err', 'zp_new', 'zp', 'ra', 'dec', 'zpsys',
'filter'),
dtype=(
'str', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float',
'float', 'str', 'str'))
# Fitting model: model parameter z bound.
res, fitted_model = sncosmo.fit_lc(hml_dat, model, ['z', 't0', 'amplitude'], bounds={'z': (0.005, 0.35)})
#The following excludes data points not in the range of the model and data sets with fewer than 4 data points
limit = modellimit(source_name, res.parameters[0], res.parameters[1])
hml2 = []
for j in range(len(hml[:,1])):
datapoint = hml [:,1][j]
if (res.parameters[1]- limit[0])< float(datapoint) < (res.parameters[1]+limit[1]):
hml2.append(hml[j])
hml2 = np.array(hml2)
if len(hml2)>3:
return finalfitcurve(x, source_name, hml2)
except ValueError:
pass
def test_fit_lc_vs_snfit():
"""Test fit_lc versus snfit result for one SN."""
# purposefully use CCM dust to match snfit
model = sncosmo.Model(source='salt2',
effects=[sncosmo.CCM89Dust()],
effect_names=['mw'],
effect_frames=['obs'])
fname = join(dirname(__file__), "data", "lc-03D4ag.list")
data = sncosmo.read_lc(fname, format='salt2', read_covmat=True,
expand_bands=True)
model.set(mwebv=data.meta['MWEBV'], z=data.meta['Z_HELIO'])
result, fitted_model = sncosmo.fit_lc(
data, model, ['t0', 'x0', 'x1', 'c'],
bounds={'x1': (-3., 3.), 'c': (-0.4, 0.4)},
modelcov=True,
phase_range=(-15., 45.),
wave_range=(3000., 7000.),
warn=False,
verbose=False)
print(result)
assert result.ndof == 25
assert result.nfit == 3
assert_allclose(fitted_model['t0'], 52830.9313, atol=0.01, rtol=0.)
assert_allclose(fitted_model['x0'], 5.6578663e-05, atol=0., rtol=0.005)
assert_allclose(fitted_model['x1'], 0.937399344, atol=0.005, rtol=0.)
assert_allclose(fitted_model['c'], -0.0851965244, atol=0.001, rtol=0.)
# errors
assert_allclose(result.errors['t0'], 0.0955792638, atol=0., rtol=0.01)
assert_allclose(result.errors['x0'], 1.52745001e-06, atol=0., rtol=0.01)
assert_allclose(result.errors['x1'], 0.104657847, atol=0., rtol=0.01)
assert_allclose(result.errors['c'], 0.0234763446, atol=0., rtol=0.01)
model.set(hostebv=ebv)
model.set(hostr_v=r_v)
model.set(t0=lc.meta['t0'])
# Identify parameters to vary in the fit.
vparams = filter(lambda x: 'bump' in x or 'slope' in x, model._param_names)
vparams += ['t0', 's', 'amplitude']
# Set boundaries on the parameters to vary.
bounds = {b.name + "_bump_amp":(-1,2) for b in
model.source.bumps}
bounds['s'] = (0, 3.)
# Get an idea of where the mode of the posterior is by doing
# an MLE fit.
res, model = sncosmo.fit_lc(lc, model, vparams, bounds=bounds)
# Add bounds for MCMC fit.
bounds['t0'] = (model.get('t0') - 2, model.get('t0') + 2)
bounds['amplitude'] = (0.5 * model.get('amplitude'),
2 * model.get('amplitude'))
# Do MCMC.
fres, fitmod = sncosmo.mcmc_lc(lc, model, vparams,
bounds=bounds,
nwalkers=200,
nburn=1000,
nsamples=20,
guess_t0=False, guess_amplitude=False)
samples = fres.samples
band = np.zeros(len(hml[:, 1]), dtype='|S6')
for i in range(len(ab)):
ab[i] = 'ab'
band[i] = 'ptf48r'
hml = np.column_stack((hml, ab, band))
# Converting into a table using astropy with titles: ptfname, time,
# magnitude, mag_err, flux, flux_err, zp_new, zp, ra, dec, zpsys and filter
hml_dat = astropy.table.Table(data=hml, names=(
'ptfname', 'time', 'magnitude', 'mag_err', 'flux', 'flux_err', 'zp_new', 'zp', 'ra', 'dec', 'zpsys', 'filter'),
dtype=(
'str', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float',
'float', 'str', 'str'))
# Fitting model: model parameters of z, x1 and c are bound.
res, fitted_model = sncosmo.fit_lc(hml_dat, model, ['z', 't0', 'x0', 'x1', 'c'],
bounds={'z': (0.005, 0.35), 'x1': (-3.5, 3.5), 'c': (-0.35, 0.35)})
# Use sncosmo to plot data and error
sncosmo.plot_lc(hml_dat, model=fitted_model, errors=res.errors, color='blue', figtext=str(hml[:, 0][0]), xfigsize=10)
# The following information can be shown if wished :
# print 'chi^2 value at minimum:', res.chisq, ';', 'dof:', res.ndof
print 'Number of chi^2 function calls made:', res.ncall
print 'reduced chi^2:', res.chisq / res.ndof
print # '### Parameters ###'
print 'SN', str(hml[:, 0][0]), '; z:', float(res.parameters[0])
print 'Completed fit for supernova:', hml[:, 0][0]
# Displays plot
plt.show()
def showcurve(sn, hml, source_name):
try:
source = sncosmo.get_source(source_name)
model = sncosmo.Model(source=source)
z0 = specs[sn]
if z0 == "no data":
# pass
print sn[:-7], "cannot be plotted"
else:
z0 = float(z0)
model.set(z=z0)
# print z0
# adding zpsys and filter columns
ab = np.zeros(len(hml[:, 1]), dtype="|S2")
for i in range(len(ab)):
ab[i] = "ab"
hml = np.column_stack((hml, ab))
band = np.zeros(len(hml[:, 1]), dtype="|S6")
for i in range(len(band)):
band[i] = "ptf48r"
hml = np.column_stack((hml, band))
hml_dat = astropy.table.Table(
data=hml,
names=(
"ptfname",
"time",
"magnitude",
"mag_err",
"flux",
"flux_err",
"zp_new",
"zp",
"ra",
"dec",
"zpsys",
"filter",
),
dtype=(
"str",
"float",
"float",
"float",
"float",
"float",
"float",
"float",
"float",
"float",
"str",
"str",
),
)
res, fitted_model = sncosmo.fit_lc(hml_dat, model, ["t0", "amplitude"], nburn=10000, nsamples=50000)
##sncosmo.plot_lc(hml_dat, model=fitted_model, model_label=source.name, errors=res.errors, color='blue', figtext=str(hml[:,0][0]+'\n'+'Model name: nugent-sn1bc'+ '\n'+'Reduced Chi Squared: ')+ str(res.chisq/res.ndof), xfigsize=18)
##plt.show()
zp_new = [hml_dat[i][7] for i in range(len(hml))]
hml2 = []
# print hml
# print res.parameters[1]
j = 0
k = 0
for row in hml:
datestamp = row[1]
peaktime = float(res.parameters[1])
limits = modellimit(z0)
if peaktime + (40.0) * (1 + z0) > float(datestamp) > peaktime - (15.0) * (1 + z0):
hml2.append(row)
if peaktime + (40.0) * (1 + z0) > float(datestamp) > peaktime:
j += 1
if peaktime > float(datestamp) > peaktime - (15.0) * (1 + z0):
k += 1
if j > 1 and k > 1:
hml2 = np.array(hml2)
##print 'after', len(hml2)
hml_dat2 = astropy.table.Table(
data=hml2,
names=(
"ptfname",
"time",
"magnitude",
"mag_err",
"flux",
"flux_err",
"zp_new",
"zp",
"ra",
"dec",
"zpsys",
"filter",
),
dtype=(
"str",
"float",
"float",
"float",
"float",
"float",
"float",
"float",
"float",
"float",
"str",
"str",
),
)
res2, fitted_model2 = sncosmo.fit_lc(hml_dat2, model, ["t0", "amplitude"], nburn=10000, nsamples=50000)
# plot model
redchisqaured = res2.chisq / res2.ndof
if redchisqaured < 1:
pass
# sncosmo.plot_lc(hml_dat2, model=fitted_model2, model_label=source.name, zp = np.mean(zp_new), errors=res2.errors, color='blue', figtext=str(hml[:,0][0]+'\n'+'Model name: nugent-sn1bc'+ '\n'+'Reduced Chi Squared: ')+ str(res2.chisq/res2.ndof), xfigsize=18)
# plt.show()
##print 'Done:', hml2[:,0][0], 'z:',float(res2.parameters[0]), 'Reduced chi^2:', res2.chisq/res2.ndof #'Data points:', len(hml[:,1]),' Type'+types[hml[:,0][0]]+'Model name: '+ source.name,'\n' #'Dof:', res.ndof
return res2.parameters, np.mean(zp_new), redchisqaured, z0, hml2 # , res.errors['amplitude']]
else:
pass
# return res.parameters, np.mean(zp_new), res.chisq/res.ndof, z0, hml
except ValueError:
# pass
print sn, "cannot be plotted"
def do_sncosmo(catalog):
import warnings
warnings.filterwarnings("ignore", message="fcn returns Nan")
warnings.filterwarnings("ignore", message="overflow encountered in power")
warnings.filterwarnings(
"ignore", message="Dropping following bands from data:*")
warnings.filterwarnings("ignore", message="overflow encountered in square")
warnings.filterwarnings(
"ignore", message="invalid value encountered in multiply")
warnings.filterwarnings(
"ignore", message="overflow encountered in multiply")
task_str = catalog.get_current_task_str()
for event in pbar(catalog.entries, task_str):
catalog.add_entry(event, delete=False)
if (SUPERNOVA.PHOTOMETRY not in catalog.entries[event] # or
# SUPERNOVA.REDSHIFT in catalog.entries[event] or
# SUPERNOVA.LUM_DIST in catalog.entries[event]
):
catalog.entries[event] = catalog.entries[event].get_stub()
continue
photodat = []
for photo in catalog.entries[event][SUPERNOVA.PHOTOMETRY]:
if (photo.get(PHOTOMETRY.BAND_SET, '') == 'SDSS' and
PHOTOMETRY.TIME in photo and PHOTOMETRY.BAND in photo and
PHOTOMETRY.FLUX_DENSITY in photo and
PHOTOMETRY.E_FLUX_DENSITY in photo and
PHOTOMETRY.UPPER_LIMIT not in photo):
photodat.append(
(float(photo[PHOTOMETRY.TIME]),
'sdss' + photo[PHOTOMETRY.BAND].replace("'", ''),
float(photo[PHOTOMETRY.FLUX_DENSITY]),
float(photo[PHOTOMETRY.E_FLUX_DENSITY]),
float(photo[PHOTOMETRY.ZERO_POINT]), 'ab'))
elif (photo.get(PHOTOMETRY.BAND_SET, '') == 'MegaCam' and
PHOTOMETRY.TIME in photo and PHOTOMETRY.BAND in photo and
PHOTOMETRY.COUNT_RATE in photo and
PHOTOMETRY.E_COUNT_RATE in photo and
PHOTOMETRY.UPPER_LIMIT not in photo):
photodat.append(
(float(photo[PHOTOMETRY.TIME]),
'sdss' + photo[PHOTOMETRY.BAND].replace("'", ''),
float(photo[PHOTOMETRY.COUNT_RATE]),
float(photo[PHOTOMETRY.E_COUNT_RATE]),
float(photo[PHOTOMETRY.ZERO_POINT]), 'bd17'))
if len(photodat) < 20:
catalog.entries[event] = catalog.entries[event].get_stub()
continue
table = Table(
rows=photodat,
names=('time', 'band', 'flux', 'fluxerr', 'zp', 'zpsys'))
if (catalog.entries[event].get(SUPERNOVA.CLAIMED_TYPE, [{
QUANTITY.VALUE: ''
}])[0][QUANTITY.VALUE] == 'Ia'):
source = sncosmo.get_source('salt2', version='2.4')
model = sncosmo.Model(source=source)
mredchisq = np.inf
fm = None
for zmin in np.linspace(0.0, 1.0, 19):
zmax = zmin + 0.1 # Overlapping intervals
try:
resl, fml = sncosmo.fit_lc(
table,
model, ['z', 't0', 'x0', 'x1', 'c'],
bounds={'z': (zmin, zmax)})
except RuntimeError:
continue
except sncosmo.fitting.DataQualityError:
break
if resl.ndof < 15:
continue
redchiq = resl.chisq / resl.ndof
if (redchiq < mredchisq and redchiq < 2.0 and not np.isclose(
zmin, fml.get('z'), rtol=1.0e-3) and not np.isclose(
zmax, fml.get('z'), rtol=1.e-3)):
mredchisq = resl.chisq
res, fm = resl, fml
if fm:
print(event, res.chisq / res.ndof,
fm.get('z'),
catalog.entries[event][SUPERNOVA.REDSHIFT][0]['value']
if SUPERNOVA.REDSHIFT in catalog.entries[event] else
'no redshift')
# source = catalog.entries[event].add_source(
# bibcode='2014A&A...568A..22B')
# catalog.entries[event].add_quantity(SUPERNOVA.REDSHIFT,
# str(fm.get('z')), source)
catalog.journal_entries()
else:
catalog.entries[event] = catalog.entries[event].get_stub()
return
# No objects found so skip this one.
continue
objectId = obj.objectId.iloc[0]
# Get the ForcedSource light curves and select the data based
# on nominal time range of the model (and exclude the u band
# data).
lc = lc_factory.create(objectId)
data_mask = ((lc.data['bandpass'] != 'lsstu')
& (model.mintime() < lc.data['mjd'])
& (lc.data['mjd'] < model.maxtime()))
data = lc.data[data_mask]
# Fit the data using a redshift bounds of +/- 0.03 centered on
# the input model value.
try:
res, fitted_model = sncosmo.fit_lc(data, model,
'z t0 x0 x1 c'.split(),
bounds=dict(z=(model.z-0.03,
model.z+0.03)))
# Stuff everything into the results DataFrame.
row = [objectId, obj.ra.iloc[0], obj.dec.iloc[0]]
foo = sncosmo.flatten_result(res)
for key in 'z t0 x0 x1 c chisq ndof'.split():
row.append(foo[key])
row.extend([sourceId, model.ra, model.dec, model.z, model.t0,
model.x0, model.x1, model.c, chisq_catsim, ndof_catsim])
results = results.append(pd.DataFrame(data=[row], columns=columns),
ignore_index=True)
# sncosmo.plot_lc(data=ref_lc.lightcurve[mask], model=model)
# sncosmo.plot_lc(data=data, model=fitted_model, errors=res.errors)
results.to_pickle(outfile)
except (RuntimeError, sncosmo.fitting.DataQualityError, ValueError):
#####################################################################
# An important additional note: a table of photometric data has a
# ``band`` column and a ``zpsys`` column that use strings to identify
# the bandpass (e.g., ``'sdssg'``) and zeropoint system (``'ab'``) of
# each observation. If the bandpass and zeropoint systems in your data
# are *not* built-ins known to sncosmo, you must register the
# corresponding `~sncosmo.Bandpass` or `~sncosmo.MagSystem` to the
# right string identifier using the registry.
# create a model
model = sncosmo.Model(source='salt2')
# run the fit
result, fitted_model = sncosmo.fit_lc(
data, model,
['z', 't0', 'x0', 'x1', 'c'], # parameters of model to vary
bounds={'z':(0.3, 0.7)}) # bounds on parameters (if any)
#####################################################################
# The first object returned is a dictionary-like object where the keys
# can be accessed as attributes in addition to the typical dictionary
# lookup like ``result['ncall']``:
print("Number of chi^2 function calls:", result.ncall)
print("Number of degrees of freedom in fit:", result.ndof)
print("chi^2 value at minimum:", result.chisq)
print("model parameters:", result.param_names)
print("best-fit values:", result.parameters)
print("The result contains the following attributes:\n", result.keys())
##################################################################
# The second object returned is a shallow copy of the input model with
print irow
sys.stdout.flush()
row = results.iloc[irow]
objectId = int(row.objectId)
lc = desc.monitor.LightCurve()
lc.build_lightcurve_from_db(objectId, **db_info)
# t0.row may be previous iterations but could also be truth values
# if thse were fixed, we should not add them to the fit_lc call
model.set(t0=row.t0, z=row.z)
dustmap = sncosmo.SFD98Map()
# ra, dec in degrees from truth/DM evaluation of ra, dec
ebv = dustmap.get_ebv((row.ra, row.dec))
model.set(mwebv=ebv)
date_mask = np.where((model.mintime() < lc.lightcurve['mjd']) &
(lc.lightcurve['mjd'] < model.maxtime()) &
(lc.lightcurve['bandpass'] != 'lsstu'))
data = lc.lightcurve[date_mask]
try:
res, fitted_model = sncosmo.fit_lc(data, model,
['z', 't0', 'x0', 'x1', 'c'],
bounds=dict(z=(0.1, 0.4)))
for par, value in zip(res['param_names'], res['parameters']):
results[par].set_value(irow, value)
results['chisq'].set_value(irow, res.chisq)
results['ndof'].set_value(irow, res.ndof)
# sncosmo.plot_lc(data=data, model=fitted_model, errors=res.errors)
except Exception:
continue
results.iloc[imin:imax].to_pickle(outfile)
print str(x)
print str(len(relevantdata[0]))
# Write out to a file as this is how we will do things in a larger set by looping through, and then read in the file
model.set(**params[0])
# fig_relevant = sncosmo.plot_lc(relevantdata[0], model=model)
#print "Close Window to continute"
#pl.show()
sncosmo.write_lc(Table(relevantdata[0]), fname='lc.dat', format='ascii')
# sncosmo.write_lc(Table(relevantdata[0]), fname='lc.dat.json', format='json')
# sncosmo.write_lc(Table(relevantdata[0]), fname='lc.dat.fits', format='snana') # fits
lc = sncosmo.read_lc('lc.dat', format='ascii')
fmodel = sncosmo.Model(source='salt2-extended')
for z in zvals:
fmodel.set(z=z)
res, fitmodel = sncosmo.fit_lc(relevantdata[0], fmodel, ['t0', 'x0', 'x1', 'c'])
print res
print params[0]
from matplotlib import pyplot as plt
wave = np.linspace(2000.0, 10000.0, 500)
for w in (0.0, 0.2, 0.4, 0.6, 0.8, 1.0):
source.set(w=w)
plt.plot(wave, source.flux(10., wave), label='w={:3.1f}'.format(w))
plt.legend()
plt.show()
##########################################################################
# The w=0 spectrum is that of the Ia model, the w=1 spectrum is that of
# the IIp model, while intermediate spectra are weighted combinations.
#
# We can even fit the model to some data!
model = sncosmo.Model(source=source)
data = sncosmo.load_example_data()
result, fitted_model = sncosmo.fit_lc(data, model,
['z', 't0', 'amplitude', 'w'],
bounds={'z': (0.2, 1.0),
'w': (0.0, 1.0)})
sncosmo.plot_lc(data, model=fitted_model, errors=result.errors)
##########################################################################
# The fact that the fitted value of w is closer to 0 than 1 indicates that
# the light curve looks more like the Ia template than the IIp template.
# This is generally what we expected since the example data here was
# generated from a Ia template (although not the Nugent template!).
def lcfit(lightcurves,params,fitparams,truearray,sources):
models = []
for source in sources:
try:
models.append(sncosmo.Model(source=source))
except:
models.append('custom_bazin_model')
iatot = 0.
noniatot = 0.
iafailed = 0.
noniafailed= 0.
badrows = []
for i,lc in enumerate(lightcurves):
if truearray[i] == 0:
iatot += 1.
else:
noniatot += 1.
z = params[i]['hostz']
ze = params[i]['hostz_std']
fitparams[i,-2] = z
fitparams[i,-1] = ze
t0 = lc['time'][np.argmax(lc['flux'])]
print('Fitting LC '+str(i)+'/'+str(len(lightcurves)),'t0',t0,'z',z)
input_param_index = 3
saltworked = True
bazinworked = True
for j, model, source in zip(range(len(sources)), models, sources):
if source == 'salt2':
try:
#model.set(z=z)
res, fitted_model = sncosmo.fit_lc(lc, model,['z','t0', 'x0', 'x1', 'c'],
bounds={'z':(z-3.*ze,z+3.*ze ),'t0':(t0-50.,t0+50.)})
#print(res.keys())
print('Type',truearray[i],'Source', source,'Fit Chisq', res.chisq / res.ndof,
'Fit c',res.parameters[4],'Fit x0',res.parameters[2],'Fit x1',res.parameters[3])
#print('chisq/ndof',res.chisq/res.ndof)
#print('param names',res.param_names[:])
#print('params',res.parameters[:])
#print('-'*100)
fitparams[i,:4] = np.array([res.parameters[2], res.parameters[3], res.parameters[4], res.chisq/res.ndof])
t0 = res.parameters[1]
#fitparams[i, :] = np.array([res.parameters[4], res.chisq / res.ndof])
#sys.exit()
except sncosmo.fitting.DataQualityError:
#fitparams[i, :] = np.array([99, 99, 99, 99])
# if truearray[i] == 0:
# print('could not fit Type Ia')
# sys.exit()
print('fitting failed: SN Type ',truearray[i])
fitparams[i, :4] = np.array([0., 0., 0., 500.])
print('-'*100)
if truearray[i] == 0:
iafailed += 1.
else:
noniafailed += 1.
#badrows.append(i)
#saltworked = False
except RuntimeError:
# if truearray[i] == 0:
# print('could not fit Type Ia')
# sys.exit()
#fitparams[i, :] = np.array([99, 99, 99, 99])
fitparams[i, :4] = np.array([0., 0., 0., 500.])
print('fitting failed: SN Type ',truearray[i])
print('-'*100)
#badrows.append(i)
#saltworked = False
if truearray[i] == 0:
iafailed += 1.
else:
noniafailed += 1.
elif saltworked:
if source == 'bazin':
if True:
flux = lc['flux']
fluxerr = lc['fluxerr']
bands = lc['band']
mjds = lc['time']
input_param_index = 3
for band in np.sort(np.unique(bands)):
bflux = flux[bands==band]
bfluxerr = fluxerr[bands==band]
bmjds = mjds[bands==band]
try:
chisq,popt = bazin.lmfit(bmjds,bflux,bfluxerr)
if chisq > 500.:
chisq = 500.
print('Source Bazin',band,'Fit Chisq',chisq,'t0',popt[0],'tau_fall',popt[1],
'tau_rise',popt[2],'A',popt[3])
except:
print('BASIN FAILED ' * 10)
chisq, popt = 500.,[0,0,0,0,0]
fitparams[i,j+input_param_index] = chisq
input_param_index += 1
fitparams[i, j+input_param_index] = popt[1]
input_param_index += 1
fitparams[i, j+input_param_index] = popt[2]
input_param_index += 1
fitparams[i, j+input_param_index] = popt[3]
input_param_index += 1
fitparams[i, j+input_param_index] = popt[4]
input_param_index += 1
input_param_index -= 1
else:
if bazinworked:
if not source == 'mlcs2k2':
#print(model.param_names)
try:
res, fitted_model = sncosmo.fit_lc(lc, model, ['z', 't0', 'amplitude'],
bounds={'z':(z-3.*ze,z+3.*ze ),
't0': (t0 - 20., t0 + 20.)})
#bounds={'z': (z - .05 * z,
# z + .05 * z)}) # assume we know hostgal z to within 5%
print('Source',source,'Fit Chisq',res.chisq/res.ndof)
fitparams[i, j+input_param_index] = res.chisq/res.ndof
except:
print('Source', source, 'Could not Fit... Chisq', 300.)
fitparams[i, j+input_param_index] = 300.
else:
try:
res, fitted_model = sncosmo.fit_lc(lc, model, ['z', 't0', 'amplitude', 'delta',],
bounds={'z':(z-3.*ze,z+3.*ze ),
't0': (t0 - 20., t0 + 20.)})
#bounds={'z': (z - .05 * z,
# z + .05 * z)}) # assume we know hostgal z to within 5%
print('Source', source, 'Fit Chisq', res.chisq / res.ndof)
fitparams[i, j + input_param_index] = res.chisq / res.ndof
except:
print('Source', source, 'Could not Fit... Chisq', 300.)
fitparams[i, j + input_param_index] = 300.
print(fitparams[i,:])
print('-' * 100)
print('Percentage of Ia Failed',iafailed/iatot)
print('Percentage of NONIa Failed',noniafailed/noniatot)
fitparams = np.delete(fitparams,np.array(badrows),axis=0)
truetypes = np.delete(truearray,np.array(badrows))
return fitparams, truetypes
