def run_mc(field, bin, w, spec, wssps, ssps, Nsim, redo=False): """ Run MC routine in single spectrum. """ outname = "mclick_{0}_bin{1:04d}_nsim{2}.txt".format(field, bin, Nsim) if os.path.exists(outname) and redo: return pp = ppload("{0}_bin{1}".format(field, bin)) pp = pPXF(pp, velscale) ########################################################################## if pp.has_emission: # Correct for emission line if present em = interp1d(pp.w, pp.gas, kind="linear", bounds_error=False, fill_value=0.) emission = em(w) spec -= emission ########################################################################## # Make the V=0 spectra poly = interp(wssps, pp.w, pp.poly) ssps_unbroad_v0 = ssps.dot(pp.w_ssps) ssps_unbroad = losvd_convolve(ssps_unbroad_v0, np.array([pp.sol[0], 0.1*velscale, 0, 0])) ssps_broad = losvd_convolve(ssps_unbroad_v0, pp.sol) bestfit = ssps_broad + poly # Extrapolated in wavelength and no emission bestfit_unbroad = ssps_unbroad + poly ########################################################################## # Calculate arrays with perturbed LOSVD if pp.ncomp == 1: sol = pp.sol error = pp.error nmoments = pp.moments else: sol = pp.sol[0] error = pp.error[0] nmoments = pp.moments[0] losvdpert = np.zeros((Nsim, int(nmoments))) for i in range(nmoments): losvdpert[:,i] = np.random.normal(sol[i], error[i], Nsim) ########################################################################## sim = np.zeros((Nsim, 25)) # Start the simulations for j in np.arange(Nsim): losvd = losvdpert[j] noise = np.random.normal(0, pp.noise, bestfit_unbroad.size) galaxy = bestfit + noise lick, lerr = lector.lector(wssps, galaxy, noise, bands, vel=losvd[0]) lick_bestfit, err = lector.lector(wssps, bestfit, noise, bands, vel=losvd[0]) lick_bestfit_unbroad, err = lector.lector(wssps, bestfit_unbroad, noise, bands, vel=losvd[0]) lickc, err = correct_indices(lick, lerr, lick_bestfit_unbroad, lick_bestfit) sim[j] = lickc print "Saving table ", outname with open(outname, "w") as f: np.savetxt(f, sim) return
def __init__(self): self.errores = [] self.lexico = lex(self.__construirTexto()) self.pila = [] self.__tablaValores = TablaValores() # Leemos el archivo lado derecho y lo asignamos l = lector(self.PATH_LADO_DERECHO) self.__ladoDerechoGramatica = l.leer() # Leemos el archivo simbolosTerminales y lo asignamos l = lector(self.PATH_SIMBOLOS_TERMINALES) self.__simbolosTerminales = l.leer() # Leemos el archivo simbolosNoTerminales y lo asignamos l = lector(self.PATH_SIMBOLOS_NOTERMINALES) self.__simbolosNoTerminales = l.leer() # Leemos el archivo simbolo inicial y lo asignamos l = lector(self.PATH_SIMBOLO_INICIAL) self.__simboloInicial = l.leer()[0]
def __construirTexto(self): #obtengo la ruta absoluta del archivo l = lector( os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/analizadorLexico/archivoPrograma.txt") # Construimos el texto texto = "" for renglon in l.leer(): texto += renglon + "\n" return texto
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 test_lector(): os.chdir(os.path.join(home, "MILES")) bands = os.path.join(tables_dir, "bands.txt") filename = "lector_tmputH9bu.list_LINE" stars = np.loadtxt(filename, usecols=(0,), dtype=str) ref = np.loadtxt(filename, usecols=(2,3,4,5,6,7,8,9,14,15,16,17,18,24,25,26, 27,28,29,30,31,32,33,34,35)) obs = [] from lick import Lick for i, star in enumerate(stars): print star + ".fits" spec = pf.getdata(star + ".fits") h = pf.getheader(star + ".fits") w = h["CRVAL1"] + h["CDELT1"] * \ (np.arange(h["NAXIS1"]) + 1 - h["CRPIX1"]) lick, tmp = lector.lector(w, spec, np.ones_like(w), bands, interp_kind="linear") ll = Lick(w, spec, np.loadtxt(bands, usecols=(2,3,4,5,6,7,))) obs.append(ll.classic) obs = np.array(obs) fig = plt.figure(1, figsize=(20,12)) gs = GridSpec(5,5) gs.update(left=0.08, right=0.98, top=0.98, bottom=0.06, wspace=0.25, hspace=0.4) obs = obs.T ref = ref.T names = np.loadtxt(bands, usecols=(0,), dtype=str) units = np.loadtxt(bands, usecols=(9,), dtype=str).tolist() # units = [x.replace("Ang", "\AA") for x in units] for i in range(25): ax = plt.subplot(gs[i]) plt.locator_params(axis="x", nbins=6) ax.minorticks_on() ax.plot(obs[i], (obs[i] - ref[i]) / ref[i], "o", color="0.5") ax.axhline(y=0, ls="--", c="k") lab = "median $= {0:.3f}$".format( np.nanmedian(obs[i] - ref[i])).replace("-0.00", "0.00") ax.axhline(y=np.nanmedian(obs[i] - ref[i]), ls="--", c="r", label=lab) ax.set_xlabel("{0} ({1})".format(names[i].replace("_", " "), units[i])) ax.legend(loc=1,prop={'size':15}) ax.set_ylim(-0.01, 0.01) fig.text(0.02, 0.5, 'I$_{{\\rm pylector}}$ - I$_{{\\rm lector}}$', va='center', rotation='vertical', size=40) output = os.path.join(home, "plots/test_lector.png") plt.show() plt.savefig(output)
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 pruebaAnalizador(): try: l = lector(os.path.dirname(os.path.dirname(os.path.abspath( __file__))) + "/analizadorLexico/archivoPrograma.txt") # Construimos el texto texto = "" for renglon in l.leer(): texto += renglon + "\n" # Pasamos el texto al analizador lexico a = AnalizadorLexico(texto) token = a.obtenerSiguienteToken() while(token.getPalabra() is not "$"): #print(token) token = a.obtenerSiguienteToken() print("Analisis lexico completo\n") except Exception as ex: print("Error garrafal en clase: AnalizadorLexico.pruebaAnalizador()") print(str(ex)+'\n')
def lectorGramatica(): try: print("Iniciando\n") #Lee la gramatica y la almacena texto = lector("lectorGramatica/Gramatica.txt") #Se determinan las producciones, simbolo inicial, #simbolos terminales y no terminales c = conversorGram(texto.leer()) #El programa que se va a leer programa = "archivoPrograma.txt" #Se indica el fin del programa #print(input("\nProceso terminado\nPulsa cualquier tecla para salir")) except Exception as ex: print("\nError garrafal en: lectorGramatica.lectorGramatica()") print(str(ex) + '\n') print(input("Pulsa cualquier tecla para salir"))
def example(): import os import pyfits as pf from config import data_dir, tables_dir from run_ppxf import wavelength_array os.chdir(data_dir) filename = "hcg22_023_blanco11an2.fits" v = 2.74319141e+03 # km/s bandsfile = os.path.join(tables_dir, "bands.txt") bands = np.loadtxt(bandsfile, usecols=np.arange(2,8)) spec = pf.getdata(filename) noise = np.ones_like(spec) wave = wavelength_array(filename) lick, err = lector(wave, spec, noise, bandsfile, vel=v) print lick ll = Lick(wave, spec, bands, vel=v) print ll.classic 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
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 noise2 = pp.bestfit / pp.noise[0] lick_bf, tmp = lector.lector(pp.w_log, pp.bestfit - pp.em, noise2, bands, vel=v, cols=(0, 8, 2, 3, 4, 5, 6, 7), keeplog=0, output="a1.pdf", title=spec)
import sys import os from AnalizadorLexico import AnalizadorLexico # agregamos la carpeta lector sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/lectorGramatica") from lector import lector import string print (AnalizadorLexico) #obtengo la ruta absoluta del archivo l = lector(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/analizadorLexico/archivoPrograma.txt") # Construimos el texto texto = "" for renglon in l.leer(): texto += renglon + "\n" # Pasamos el texto al analizador lexico a = AnalizadorLexico(texto) token = a.obtenerSiguienteToken() while(token.getPalabra() is not "$"): print(token) token = a.obtenerSiguienteToken()
###################################################################### # 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 noise2 = pp.bestfit / pp.noise[0] lick_bf, tmp = lector.lector(pp.w_log, pp.bestfit - pp.em, noise2, bands, vel = v, cols=(0,8,2,3,4,5,6,7), keeplog=0, output="a1.pdf", title=spec) noise3 = pp.bestfit_unbroad / pp.noise[0] lick_bf_unb, tmp = lector.lector(pp.w_log, pp.bestfit_unbroad - pp.em, noise3, bands, vel = v, cols=(0,8,2,3,4,5,6,7), keeplog=0, title=spec) #################################################################### # Measure in new specs noise2 = pp.bestfit / pp.noise[0] lnew, tmp = lector.lector(pp.w, flux-pp.em_linear, noise, bands,
if it[1] != ' ': if it[1][0] == '#': it[1] = it[1][1:] if it[1][0] == '$': it[1] = it[1][1:] return instrucciones """ instrucciones1 = [j for i in instrucciones for j in i] print(instrucciones1) """ if __name__ == '__main__': compa = compilador() lector = lector() mnemonicos = compa.get_mnenomicos() text = procesar_texto(adquirir_texto()) # obtener_operadores(text) constantes = adquirir_constantes_operador(text) subrutinas_num = lector.adquirir_subrutinas_numero(text) inst = lector.instrucciones_operando(text) subrutinas = lector.adquirir_subrutinas(text) hexa = cambiar_hexa(cambiar_constantes(inst, constantes), compa.get_mnenomicos_opcode(), subrutinas) inste = imprimir_chido(hexa) lol = instrucciones_operando_num(text, subrutinas_num) constantes_s = lector.adquirir_constantes(text) # Errores lector.error_identacion(text, subrutinas, constantes_s)
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
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))