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