def test_galaxy(wpoly, poly):
os.chdir(os.path.join(home, "single1"))
specs = ["fin1_n3311cen1_s27.fits", "fin1_n3311cen2_s30.fits",
"fin1_n3311inn1_s28.fits", "fin1_n3311inn2_s28.fits"]
kfile = "ppxf_results.dat"
kspecs = np.loadtxt(kfile, usecols=(0,), dtype=str)
v = np.loadtxt(kfile, usecols=(1,))
vs = dict([(x,y) for x,y in zip(kspecs, v)])
araw = np.zeros((len(specs), 25))
aflux = np.zeros_like(araw)
for i,spec in enumerate(specs):
galaxy = pf.getdata(spec)
w = wavelength_array(spec)
flux = lector.broad2lick(w, galaxy, 2.1, vel=vs[spec])
sn = snr(flux)
noise = np.ones_like(flux) * np.median(flux) / sn
lick, lickerrs = lector.lector(w, flux, noise, bands,
vel = vs[spec], cols=(0,8,2,3,4,5,6,7))
araw[i] = lick
galaxy2 = galaxy * poly(w)
flux2 = lector.broad2lick(w, galaxy2, 2.1, vel=0.)
lick2, lickerrs2 = lector.lector(w, flux2, noise, bands,
vel = vs[spec], cols=(0,8,2,3,4,5,6,7))
aflux[i] = lick2
araw = araw.T
aflux = aflux.T
for j,index in enumerate(indices):
if j < 12 or j>20:
continue
print indices[j],
# print aflux[j],
# print araw[j],
# print lims[j]
print "{0:10.2f}".format(np.median(aflux[j])),
print "{0:10.2f}".format(np.median(araw[j])),
print "{0:10.2f}".format(np.median((aflux[j] - araw[j])/(aflux[j])))
def run_mc(spec, i):
""" Run MC routine in single spectrum. """
outname = "mc_logs/{0}_nsim{1}.txt".format(spec.replace(".fits", ""),
Nsim)
output = os.path.join(wdir, outname)
if os.path.exists(output):
return
print "{0} ({1}/{2})".format(spec, i+1, len(specs))
pp = pPXF(spec, velscale)
sn = pp.calc_sn()
#####################################################################
# Extracting emission line spectra and subtracting from data
#####################################################################
if pp.has_emission:
em_weights = pp.weights[-3:]
em_matrix = pp.matrix[:,-3:]
em = em_matrix.dot(em_weights)
else:
em = np.zeros_like(pp.bestfit)
#########################################################################
# Handle cases where more than one component is used
if pp.ncomp > 1:
sol = pp.sol[0]
error = pp.error[0]
else:
sol = pp.sol
error = pp.error
##########################################################################
if error[1] == 0.0:
print "Skiped galaxy: unconstrained sigma."
return
##########################################################################
lick_sim = np.zeros((Nsim, 25))
vpert = np.random.normal(sol[0], error[0], Nsim)
sigpert = np.random.normal(sol[1], error[1], Nsim)
for j in np.arange(Nsim):
noise_sim = np.random.normal(0, pp.noise, len(pp.bestfit))
obs_sim = lector.broad2lick(pp.w, pp.bestfit + noise_sim - em,
2.54, vel=vpert[j])
l, err = lector.lector(pp.w, obs_sim, noise_sim, bands, vel = vpert[j],
cols=(0,8,2,3,4,5,6,7), keeplog=0)
lick_sim[j] = l * bcorr(sigpert[j], l)
with open(output, "w") as f:
np.savetxt(f, lick_sim)
print "Finished MC for {0}.".format(spec)
return
def test_star():
os.chdir(os.path.join(home, "data/star"))
specs = ['HD102070_spectra.fits', "HD102070_noflux.fits"]
a = np.zeros((2,25))
cs = ["k", "r"]
fs = []
for i, spec in enumerate(specs):
star = pf.getdata(spec)
w = wavelength_array(spec)
# plt.plot(w, star/np.nanmedian(star), "-{0}".format(cs[i]))
# check_ppxf(spec, velscale) # Velocity of stars is zero
flux = lector.broad2lick(w, star, 2.1, vel=0.)
sn = snr(flux)
noise = np.ones_like(flux) * np.median(flux) / sn
lick, lickerrs = lector.lector(w, flux, noise, bands,
vel = 0., cols=(0,8,2,3,4,5,6,7))
a[i] = lick
fs.append(interp1d(w, star/np.nanmedian(star), bounds_error=False, fill_value=0))
# plt.show()
# plt.clf()
w = np.linspace(4850, 5780, 1000)
p = np.poly1d(np.polyfit(w, fs[0](w) / fs[1](w), 20))
# plt.plot(w, fs[0](w) / fs[1](w), "-k" )
# plt.plot(w, p(w), "-r")
# plt.show()
cols = ["Index ", "Calib", "Raw", "Sch07", "Delta", "%", "offset"]
cols = ["{0:10s}".format(x) for x in cols]
sch = data_schiavon07()
model_table = os.path.join(tables_dir, \
"models_thomas_2010_metal_extrapolated.dat")
lims, ranges = get_model_lims(model_table, factor=0)
lims = np.diff(lims).T[0]
print "Results for the test on standard star HD 102070"
print "".join(cols)
for j,index in enumerate(indices):
if j < 12 or j>20:
continue
print "{0:6s}{1:10.2f}{2:10.2f}{6:10.2f}{3:10.2f}{4:10.2f}{5:10.2f}".format(index, \
a[0][j], a[1][j], (a[0][j] - a[1][j]),
(a[0][j] - a[1][j])/ a[0][j], offset[j], sch[j])
return w,p
# Check problem with broadening
bf = interp1d(pp.w_log,
pp.bestfit,
bounds_error=False,
fill_value="extrapolate")
bestfit = bf(pp.w)
bfu = interp1d(pp.w_log,
pp.bestfit_unbroad,
bounds_error=False,
fill_value="extrapolate")
bestfitunb = bfu(pp.w)
flux = pp.flux
######################################################################
# Broadening of the spectra to the Lick resolution
if broad2lick:
pp.flux = lector.broad2lick(pp.w, pp.flux, 2.1, vel=v)
pp.bestfit = lector.broad2lick(pp.w_log, pp.bestfit, 2.54, vel=v)
pp.bestfit_unbroad = lector.broad2lick(pp.w_log,
pp.bestfit_unbroad,
2.54,
vel=v)
flux = lector.broad2lick2(pp.w, pp.flux, 2.1, vel=v)
bestfit = lector.broad2lick2(pp.w, bestfit, 2.54, vel=v)
bestfitunb = lector.broad2lick2(pp.w, bestfitunb, 2.54, vel=v)
noise = pp.flux / pp.noise[0]
#####################################################################
# Make Lick indices measurements
#####################################################################
lick, lickerrs = lector.lector(pp.w,
pp.flux - pp.em_linear,
noise,
v, s, h3, h4 = pp.sol
print spec, v, s
goodindices = check_intervals(setupfile, bands, v)
######################################################################
# Check problem with broadening
bf = interp1d(pp.w_log, pp.bestfit, bounds_error=False,
fill_value="extrapolate")
bestfit = bf(pp.w)
bfu = interp1d(pp.w_log, pp.bestfit_unbroad, bounds_error=False,
fill_value="extrapolate")
bestfitunb = bfu(pp.w)
flux = pp.flux
######################################################################
# Broadening of the spectra to the Lick resolution
if broad2lick:
pp.flux = lector.broad2lick(pp.w, pp.flux, 2.1, vel=v)
pp.bestfit = lector.broad2lick(pp.w_log, pp.bestfit, 2.54, vel=v)
pp.bestfit_unbroad = lector.broad2lick(pp.w_log, pp.bestfit_unbroad,
2.54, vel=v)
flux = lector.broad2lick2(pp.w, pp.flux, 2.1, vel=v)
bestfit = lector.broad2lick2(pp.w, bestfit, 2.54, vel=v)
bestfitunb = lector.broad2lick2(pp.w, bestfitunb, 2.54, vel=v)
noise = pp.flux / pp.noise[0]
#####################################################################
# Make Lick indices measurements
#####################################################################
lick, lickerrs = lector.lector(pp.w, pp.flux-pp.em_linear, noise, bands,
vel = v, cols=(0,8,2,3,4,5,6,7),
keeplog=0, output="logs/lick_{0}".format(
spec.replace(".fits", ".pdf")), title=spec)
# Measuring Lick indices in the templates
def run_candidates_mc(velscale, bands, nsim=50):
""" Run MC to calculate errors on Lick indices. """
wdir = os.path.join(home, "data/candidates")
os.chdir(wdir)
specs = sorted([x for x in os.listdir(wdir) if x.endswith(".fits")])
offset, offerr = lick_offset()
lickout = []
for spec in specs:
try:
ppfile = "logs_ssps/{0}".format(spec.replace(".fits", ""))
if not os.path.exists(ppfile + ".pkl"):
print "Skiping spectrum: ", spec
continue
print ppfile
pp = ppload("logs_ssps/{0}".format(spec.replace(".fits", "")))
pp = pPXF(spec, velscale, pp)
ppkin = ppload("logs/{0}".format(spec.replace(".fits", "")))
ppkin = pPXF(spec, velscale, ppkin)
w = wavelength_array(spec, axis=1, extension=0)
if pp.ncomp > 1:
sol = ppkin.sol[0]
error = ppkin.error[0]
else:
sol = ppkin.sol
error = ppkin.error
###################################################################
# Produces composite stellar population of reference
if pp.ncomp == 1:
csp = pp.star.dot(pp.w_ssps)
else:
csp = pp.star[:,:-pp.ngas].dot(pp.w_ssps)
###################################################################
# Make unbroadened bestfit and measure Lick on it
best_unbroad_ln = pp.poly + pp.mpoly * losvd_convolve(csp,
np.array([sol[0], velscale/10.]), velscale)
b0 = interp1d(pp.w, best_unbroad_ln, kind="linear",
fill_value="extrapolate", bounds_error=False)
best_unbroad_lin = b0(w)
best_unbroad_lin = lector.broad2lick(w, best_unbroad_lin,
3.6, vel=sol[0])
lick_unb, tmp = lector.lector(w, best_unbroad_lin,
np.ones_like(w), bands, vel=sol[0])
###################################################################
# Setup simulations
vpert = np.random.normal(sol[0], error[0], nsim)
sigpert = np.random.normal(sol[1], error[1], nsim)
h3pert = np.random.normal(sol[2], error[2], nsim)
h4pert = np.random.normal(sol[3], error[3], nsim)
licksim = np.zeros((nsim, 25))
###################################################################
for i, (v,s,h3,h4) in enumerate(zip(vpert, sigpert, h3pert, h4pert)):
solpert = np.array([v,s,h3,h4])
noise = np.random.normal(0., pp.noise, len(w))
best_broad_ln = pp.poly + pp.mpoly * losvd_convolve(csp,
solpert, velscale)
b1 = interp1d(pp.w, best_broad_ln, kind="linear",
fill_value="extrapolate", bounds_error=False)
best_broad_lin = b1(w)
###############################################################
# Broadening to Lick system
best_broad_lin = lector.broad2lick(w, best_broad_lin, 3.6,
vel=solpert[0])
lick_br, tmp = lector.lector(w, best_broad_lin,
np.ones_like(w), bands, vel=solpert[0])
lick, lickerr = lector.lector(w, best_broad_lin + noise,
np.ones_like(w), bands, vel=sol[0])
licksim[i] = correct_lick(bands, lick, lick_unb, lick_br) + \
offset
stds = np.zeros(25)
for i in range(25):
stds[i] = np.std(sigma_clip(licksim[:,i], sigma=5))
stds = np.sqrt(stds**2 + offerr**2)
###################################################################
# Storing results
lickc = ["{0:.5g}".format(x) for x in stds]
line = "".join(["{0:35s}".format(spec)] + \
["{0:12s}".format(x) for x in lickc])
lickout.append(line)
###################################################################
except:
print "Problem with spectrum", spec
continue
# Saving to file
with open("lickerr_mc{0}.txt".format(nsim), "w") as f:
f.write("\n".join(lickout))
def run_candidates(velscale, bands):
""" Run lector on candidates. """
wdir = os.path.join(home, "data/candidates")
os.chdir(wdir)
specs = sorted([x for x in os.listdir(wdir) if x.endswith(".fits")])
obsres = hydra_resolution()
offset, offerr = lick_offset()
lickout = []
for spec in specs:
ppfile = "logs_ssps/{0}".format(spec.replace(".fits", ""))
if not os.path.exists(ppfile + ".pkl"):
print "Skiping spectrum: ", spec
continue
print ppfile
pp = ppload("logs_ssps/{0}".format(spec.replace(".fits", "")))
pp = pPXF(spec, velscale, pp)
galaxy = pf.getdata(spec)
w = wavelength_array(spec, axis=1, extension=0)
if pp.ncomp > 1:
sol = pp.sol[0]
else:
sol = pp.sol
if pp.ncomp == 1:
csp = pp.star.dot(pp.w_ssps) # composite stellar population
else:
csp = pp.star[:,:-pp.ngas].dot(pp.w_ssps)
######################################################################
# Produce bestfit templates convolved with LOSVD/redshifted
best_unbroad = pp.poly + pp.mpoly * losvd_convolve(csp,
np.array([sol[0], velscale/10.]), velscale)
best_broad = pp.poly + pp.mpoly * losvd_convolve(csp,
sol, velscale)
##################################################################
# Interpolate bestfit templates to obtain linear dispersion
b0 = interp1d(pp.w, best_unbroad, kind="linear",
fill_value="extrapolate", bounds_error=False)
b1 = interp1d(pp.w, best_broad, kind="linear",
fill_value="extrapolate", bounds_error=False)
sky = interp1d(pp.w, pp.bestsky, kind="linear",
fill_value="extrapolate", bounds_error=False)
emission = interp1d(pp.w, pp.gas, kind="linear",
fill_value="extrapolate", bounds_error=False)
best_unbroad = b0(w)
best_broad = b1(w)
######################################################################
# Test plot
# plt.plot(w, best_unbroad, "-b")
# plt.plot(w, best_broad, "-r")
# plt.plot(w, galaxy - sky(w), "-k")
# plt.show()
#######################################################################
# Broadening to Lick system
galaxy = lector.broad2lick(w, galaxy - sky(w) - emission(w), obsres(w),
vel=sol[0])
best_unbroad = lector.broad2lick(w, best_unbroad,
3.7, vel=sol[0])
best_broad = lector.broad2lick(w, best_broad, 3.7,
vel=sol[0])
##################################################################
lick, lickerr = lector.lector(w, galaxy, np.ones_like(w), bands,
vel=sol[0])
lick_unb, tmp = lector.lector(w, best_unbroad,
np.ones_like(w), bands, vel=sol[0])
lick_br, tmp = lector.lector(w, best_broad,
np.ones_like(w), bands, vel=sol[0])
lickc = correct_lick(bands, lick, lick_unb, lick_br) + offset
######################################################################
# Plot to check if corrections make sense
if False:
fig = plt.figure(1)
ax = plt.subplot(111)
ax.plot(lick, "ok")
ax.plot(lick_unb, "xb")
ax.plot(lick_br, "xr")
ax.plot(lick - (lick_br - lick_unb), "+k", ms=10)
ax.plot(lick * lick_unb / lick_br, "xk", ms=10)
ax.plot(lickc - offset, "o", c="none", markersize=10, mec="y")
ax.set_xticks(np.arange(25))
ax.set_xlim(-1, 25)
labels = np.loadtxt(bands, usecols=(0,), dtype=str).tolist()
labels = [x.replace("_", " ") for x in labels]
ax.set_xticklabels(labels, rotation=90)
plt.show()
######################################################################
# Storing results
lickc = ["{0:.5g}".format(x) for x in lickc]
line = "".join(["{0:30s}".format(spec)] + \
["{0:12s}".format(x) for x in lickc])
lickout.append(line)
######################################################################
# Saving to file
with open("lick.txt", "w") as f:
f.write("\n".join(lickout))
def run_standard_stars(velscale, bands):
""" Run lector on standard stars to study instrumental dependencies. """
stars_dir = os.path.join(home, "data/standards")
table = os.path.join(tables_dir, "lick_standards.txt")
ids = np.loadtxt(table, usecols=(0,), dtype=str).tolist()
lick_ref = np.loadtxt(table, usecols=np.arange(1,26))
ref, obsm, obsa = [], [], []
res = hydra_resolution()
for night in nights:
os.chdir(os.path.join(stars_dir, night))
stars = [x for x in os.listdir(".") if x.endswith(".fits")]
for star in stars:
ppfile = "logs/{0}".format(star.replace(".fits", ""))
if not os.path.exists(ppfile + ".pkl"):
continue
name = star.split(".")[0].upper()
if name not in ids:
continue
print name
idx = ids.index(name)
lick_star = lick_ref[idx]
pp = ppload("logs/{0}".format(star.replace(".fits", "")))
pp = pPXF(star, velscale, pp)
mpoly = np.interp(pp.wtemp, pp.w, pp.mpoly)
spec = pf.getdata(star)
w = wavelength_array(star, axis=1, extension=0)
best_unbroad_v0 = mpoly * pp.star.dot(pp.w_ssps)
best_broad_v0 = losvd_convolve(best_unbroad_v0,
np.array([0., pp.sol[1]]), velscale)
##################################################################
# Interpolate bestfit templates to obtain linear dispersion
b0 = interp1d(pp.wtemp, best_unbroad_v0, kind="linear",
fill_value="extrapolate", bounds_error=False)
b1 = interp1d(pp.wtemp, best_broad_v0, kind="linear",
fill_value="extrapolate", bounds_error=False)
best_unbroad_v0 = b0(w)
best_broad_v0 = b1(w)
#################################################################
# Broadening to Lick system
spec = lector.broad2lick(w, spec, res(w), vel=pp.sol[0])
best_unbroad_v0 = lector.broad2lick(w, best_unbroad_v0,
3.6, vel=0.)
best_broad_v0 = lector.broad2lick(w, best_broad_v0, 3.6,
vel=0.)
# plt.plot(w, spec, "-k")
# plt.plot(w, best_broad_v0, "-r")
# plt.show()
##################################################################
lick, lickerr = lector.lector(w, spec, np.ones_like(w), bands,
vel=pp.sol[0])
lick_unb, tmp = lector.lector(w, best_unbroad_v0,
np.ones_like(w), bands, vel=0.)
lick_br, tmp = lector.lector(w, best_broad_v0,
np.ones_like(w), bands, vel=0.)
lickm = multi_corr(lick, lick_unb, lick_br)
licka = add_corr(lick, lick_unb, lick_br)
ref.append(lick_star)
obsm.append(lickm)
obsa.append(licka)
with open(os.path.join(tables_dir, "stars_lick_val_corr.txt"), "w") as f:
np.savetxt(f, np.array(ref))
with open(os.path.join(tables_dir, "stars_lick_obs_mcorr.txt"), "w") as f:
np.savetxt(f, np.array(obsm))
with open(os.path.join(tables_dir, "stars_lick_obs_acorr.txt"), "w") as f:
np.savetxt(f, np.array(obsa))
return
