Пример #1
0
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
Пример #4
0
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])))
Пример #5
0
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)
Пример #6
0
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
Пример #7
0
 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')
Пример #8
0
    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"))
Пример #9
0
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
Пример #10
0
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
Пример #11
0
     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)
Пример #12
0
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()


Пример #13
0
 ######################################################################
 # 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,
Пример #14
0
        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)
Пример #15
0
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
Пример #16
0
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))
Пример #17
0
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))