Ejemplo n.º 1
0
def meiring06():
    '''Meiring et al. 2006, MNRAS, 370, 43
    Q1107+0003 
    Taken from Table 4 by JXP
    NHI from RTN06 (damping wings)
    RA/DEC from STIS header
    '''
    # Setup
    lls = LLSSystem(name='SDSSJ1107+0003_z0.954',
                    RA=166.90273 * u.deg,
                    Dec=0.05795000 * u.deg,
                    zem=1.726,
                    zabs=0.9542,
                    vlim=[-300., 300.] * u.km / u.s,
                    NHI=20.26,
                    sigNHI=np.array([0.14, 0.09]))
    #  Meiring06, Table 4
    ion_dict = {}
    ion_dict['Zn II'] = dict(clm=12.08, sig_clm=0., flg_clm=3, Z=30, ion=2)
    ion_dict['Ti II'] = dict(clm=13.01, sig_clm=0., flg_clm=3, Z=22, ion=2)
    ion_dict['Cr II'] = dict(clm=12.76, sig_clm=0., flg_clm=3, Z=24, ion=2)
    # Finish
    lls._ionclms = IonClms(idict=ion_dict)
    lls.Refs.append('Mei06')
    return lls
Ejemplo n.º 2
0
def kacprzak12():
    '''Kacprzak, G. et al. 2012, MNRAS, 427, 3029-3043
    TON 153
    Taken from Table 1 by JXP
    NHI from Churchill+2007
    RA/DEC from Simbad
    '''
    # Setup
    radec = xor.stod1('J131956.2209+272808.271')
    lls = LLSSystem(name='TON153_z1.002',
                    RA=radec[0],
                    Dec=radec[1],
                    zem=0.6610,
                    zabs=1.0023,
                    vlim=[-250., 200.] * u.km / u.s,
                    NHI=18.30,
                    sigNHI=np.array([0.30, 0.30]))
    # Table 1 (total)
    ion_dict = {}
    ion_dict['Mg II'] = dict(clm=13.11, sig_clm=0.07, flg_clm=1, Z=12, ion=2)
    ion_dict['Mg I'] = dict(clm=11.54, sig_clm=0.06, flg_clm=1, Z=12, ion=1)
    ion_dict['Si I'] = dict(clm=11.8, sig_clm=0.00, flg_clm=3, Z=14, ion=1)
    ion_dict['Si II'] = dict(clm=13.16, sig_clm=0.11, flg_clm=1, Z=14, ion=2)
    ion_dict['Si IV'] = dict(clm=12.4, sig_clm=0.0, flg_clm=3, Z=14, ion=4)
    ion_dict['C II'] = dict(clm=13.39, sig_clm=0.0, flg_clm=2, Z=6, ion=2)
    ion_dict['C III'] = dict(clm=14.20, sig_clm=0.05, flg_clm=1, Z=6, ion=3)
    ion_dict['C III'] = dict(clm=14.41, sig_clm=0.05, flg_clm=1, Z=6, ion=4)
    ion_dict['O VI'] = dict(clm=14.49, sig_clm=0.05, flg_clm=1, Z=8, ion=6)
    # Finish
    lls._ionclms = IonClms(idict=ion_dict)
    lls.Refs.append('Kcz12')
    return lls
Ejemplo n.º 3
0
def zonak2004():
    '''Zoank, S. et al. 2004, ApJ, 2004, 606, 196
    PG1634+706
    HST+Keck spectra
    MgII, SiIV, SiIII from Table 2.  Summing Subsystems A (Model 2) and B
       Errors estimated by JXP (not reported)
       SiIII in A may be a model
       SiIV in B may be a model
    Total NHI from LL. Taken from Fig 3 caption.  
       Error estimated by JXP 
    Not all EWs in Table 1 included
    Adopting their M/H
    '''
    # Setup
    radec = xor.stod1('J163428.9897+703132.422')  # SIMBAD
    lls = LLSSystem(name='PG1634+706_z1.041',
                    RA=radec[0],
                    Dec=radec[1],
                    zem=1.337,
                    zabs=1.0414,
                    vlim=[-200., 30.] * u.km / u.s,
                    NHI=17.23,
                    MH=-1.4,
                    sigNHI=np.array([0.15, 0.15]))
    # SubSystems
    lls.mk_subsys(2)
    # Abundances
    adict = dict(MgII={
        'clm': log_sum([11.45, 11.90, 12.02, 11.68]),
        'sig_clm': 0.05,
        'flg_clm': 1
    },
                 SiIII={
                     'clm': log_sum([12.5, 12.5, 12.8, 12.7]),
                     'sig_clm': 0.25,
                     'flg_clm': 1
                 },
                 SiIV={
                     'clm': log_sum([10.9, 10.8, 11.2, 11.1]),
                     'sig_clm': 0.15,
                     'flg_clm': 1
                 })
    lls.subsys['A']._ionclms = IonClms(idict=adict)
    bdict = dict(SiIII={
        'clm': log_sum([11.8, 12.8, 12.4]),
        'sig_clm': 0.15,
        'flg_clm': 1
    },
                 SiIV={
                     'clm': log_sum([11.2, 12.2, 11.8]),
                     'sig_clm': 0.15,
                     'flg_clm': 1
                 })
    lls.subsys['B']._ionclms = IonClms(idict=bdict)
    # Total
    lls._ionclms = lls.subsys['A']._ionclms.sum(lls.subsys['B']._ionclms)
    lls.Refs.append('Zon04')
    # Return
    return lls
Ejemplo n.º 4
0
def test_parse_ion():
    # JXP .ion file
    if os.getenv('LLSTREE') is None:
        assert True
    # Read
    datfil = 'Data/UM184.z2929.dat'
    lls = LLSSystem(dat_file=datfil, tree=os.getenv('LLSTREE'))
    #
    lls.get_ions()
    assert len(lls.lines) == 24
Ejemplo n.º 5
0
def test_parse_ion():
    # JXP .ion file
    if os.getenv('LLSTREE') is None:
        assert True
    # Read
    datfil = 'Data/UM184.z2929.dat'
    lls = LLSSystem(dat_file=datfil, tree=os.getenv('LLSTREE'))
    #    
    lls.get_ions()
    assert len(lls.lines) == 24
Ejemplo n.º 6
0
 def add_LLS(self,z,NHI=17.3,bval=20.*u.km/u.s):
     '''Generate a new LLS
     '''
     #
     new_sys = LLSSystem(NHI=NHI)
     new_sys.zabs = z
     new_sys.fill_lls_lines(bval=bval)
     # Name
     self.count_lls += 1
     new_sys.label = 'LLS_Sys_{:d}'.format(self.count_lls)
     # Add
     self.abssys_widg.add_fil(new_sys.label)
     self.abssys_widg.all_abssys.append(new_sys)
     self.abssys_widg.abslist_widget.item(
         len(self.abssys_widg.all_abssys)).setSelected(True)
Ejemplo n.º 7
0
def test_dat_init():
    # JXP .dat files
    if os.getenv('LLSTREE') is None:
        assert True
    # Read
    datfil = 'Data/UM184.z2929.dat'
    lls = LLSSystem(dat_file=datfil, tree=os.getenv('LLSTREE'))
    #
    np.testing.assert_allclose(lls.zabs, 2.93012)
Ejemplo n.º 8
0
def nestor08():
    '''Nestor, D. et al. 2008, MNRAS, 390, 1670-1682
    Q2149+212
    Taken from Table 1 by JXP
    NHI from RTN06 (damping wings)
    RA/DEC from STIS header
    '''
    # Setup
    lls = LLSSystem(name='SDSSJ2151+2130_z1.002',
                    RA=327.94096 * u.deg,
                    Dec=21.503750 * u.deg,
                    zem=1.534,
                    zabs=1.0023,
                    vlim=[-300., 300.] * u.km / u.s,
                    NHI=19.30,
                    sigNHI=np.array([0.10, 0.10]))
    #  Meiring06, Table 4
    ion_dict = {}
    ion_dict['Zn II'] = dict(clm=12.13, sig_clm=0., flg_clm=3, Z=30, ion=2)
    ion_dict['Cr II'] = dict(clm=12.59, sig_clm=0., flg_clm=3, Z=24, ion=2)
    # Finish
    lls._ionclms = IonClms(idict=ion_dict)
    lls.Refs.append('Nes08')
    return lls
Ejemplo n.º 9
0
 def add_LLS(self, z, NHI=17.3, bval=20. * u.km / u.s, comment='None'):
     '''Generate a new LLS
     '''
     #
     new_sys = LLSSystem(NHI=NHI)
     new_sys.zabs = z
     new_sys.bval = bval  # This is not standard, but for convenience
     new_sys.comment = comment
     new_sys.fill_lls_lines(bval=bval)
     # Name
     self.count_lls += 1
     new_sys.label = 'LLS_Sys_{:d}'.format(self.count_lls)
     # Add
     self.abssys_widg.add_fil(new_sys.label)
     self.abssys_widg.all_abssys.append(new_sys)
     self.abssys_widg.abslist_widget.item(len(
         self.abssys_widg.all_abssys)).setSelected(True)
Ejemplo n.º 10
0
 def add_LLS(self, z, NHI=17.3, bval=20.0 * u.km / u.s, comment="None"):
     """Generate a new LLS
     """
     #
     new_sys = LLSSystem(NHI=NHI)
     new_sys.zabs = z
     new_sys.bval = bval  # This is not standard, but for convenience
     new_sys.comment = comment
     new_sys.fill_lls_lines(bval=bval)
     # Name
     self.count_lls += 1
     new_sys.label = "LLS_Sys_{:d}".format(self.count_lls)
     # Add
     self.abssys_widg.add_fil(new_sys.label)
     self.abssys_widg.all_abssys.append(new_sys)
     self.abssys_widg.abslist_widget.item(len(self.abssys_widg.all_abssys)).setSelected(True)
Ejemplo n.º 11
0
 def add_LLS(self, z, NHI=17.3, bval=20. * u.km / u.s):
     '''Generate a new LLS
     '''
     #
     new_sys = LLSSystem(NHI=NHI)
     new_sys.zabs = z
     new_sys.fill_lls_lines(bval=bval)
     # Name
     self.count_lls += 1
     new_sys.label = 'LLS_Sys_{:d}'.format(self.count_lls)
     # Add
     self.abssys_widg.add_fil(new_sys.label)
     self.abssys_widg.all_abssys.append(new_sys)
     self.abssys_widg.abslist_widget.item(len(
         self.abssys_widg.all_abssys)).setSelected(True)
Ejemplo n.º 12
0
def dessauges09():
    '''Dessauges-Zavadsky et al. 2009, MNRAS, 396, L96
    SLLS with UVES
    Zn,Fe abundances from Table 1 from astro-ph (LateX) by JXP [AODM]
     Taken from the Zn/H and Fe/H assuming *no* ionization corrections
    RA/DEC from the 'other' name 
    '''
    # Solar abundances
    eZn = 4.63
    eFe = 7.45
    sol = [eFe, eZn]
    #
    all_lls = []
    # Table 1
    tab_fil = xa_path + "/data/LLS/dessauges09.tb1.ascii"
    with open(tab_fil, 'r') as f:
        flines1 = f.readlines()
    # Trim the first few lines
    flines1 = flines1[3:]
    ion_dict = {}
    for iline in flines1:
        # Parse
        isplit = iline.split('&')
        # QSO
        if iline[0:2] == 'QS':
            # QSO, RA/DEC, zem
            qso = isplit[0][4:].strip()
            radec = xor.stod1(isplit[1].strip().replace('$', ''))
            zem = float(isplit[3].strip())
        # NHI, zabs
        zabs = float(isplit[4].strip())
        is2 = isplit[6].strip()
        NHI = float(is2[1:6])
        sigNHI = np.array([float(is2[10:14])] * 2)
        # name
        name = qso + 'z_{:.3f}'.format(zabs)
        lls = LLSSystem(name=name,
                        RA=radec[0],
                        Dec=radec[1],
                        zem=zem,
                        zabs=zabs,
                        NHI=NHI,
                        sigNHI=sigNHI)
        # ADOM Columns
        ion_dict = {}
        for kk, ion in enumerate(['Fe II', 'Zn II']):
            Zion = xai.name_ion(ion)
            is2 = isplit[7 + kk].strip()
            if is2[0:2] == '$>':
                ion_dict[ion] = dict(sig_clm=0.,
                                     flg_clm=2,
                                     Z=Zion[0],
                                     ion=Zion[1])
                ion_dict[ion]['clm'] = float(is2[2:7]) + NHI - 12 + sol[kk]
            elif is2[0:2] == '$<':
                ion_dict[ion] = dict(sig_clm=0.,
                                     flg_clm=3,
                                     Z=Zion[0],
                                     ion=Zion[1])
                ion_dict[ion]['clm'] = float(is2[2:7]) + NHI - 12 + sol[kk]
            elif is2[0:2] == '..':
                pass
            else:
                ion_dict[ion] = dict(flg_clm=1, Z=Zion[0], ion=Zion[1])
                ion_dict[ion]['clm'] = float(is2[1:6]) + NHI - 12 + sol[kk]
                ion_dict[ion]['sig_clm'] = float(is2[10:14])
        #xdb.set_trace()
        # Finish
        lls._ionclms = IonClms(idict=ion_dict)
        lls.Refs.append('DZ09')
        all_lls.append(lls)

    # Return SLLS only
    fin_slls = [ills for ills in all_lls if ills.NHI < 20.3]
    return fin_slls
Ejemplo n.º 13
0
def meiring09():
    '''Meiring et al. 2009, MNRAS, 393, 1513
    SLLS with Magellan
    Abundances from Table 3 from astro-ph (LateX) by JXP [AODM]
    RA/DEC from Table 1
    '''
    all_lls = []
    # Table 1
    tab_fil = xa_path + "/data/LLS/meiring09.tb1.ascii"
    with open(tab_fil, 'r') as f:
        flines1 = f.readlines()
    # Grab RA/DEC
    qso_dict = {}
    for iline in flines1:
        if iline[0:3] in [' QS', '\hl', '$\\c', ' J2', '   ']:
            continue
        # Parse
        isplit = iline.split('&')
        #xdb.set_trace()
        if '$' in isplit[3].strip():
            isplit[3] = '-' + (isplit[3].strip())[3:]
        radec = xor.stod1((isplit[2], isplit[3]))
        # zem
        zem = float(isplit[5].strip())
        # Save
        qso_dict[isplit[0].strip()] = dict(RA=radec[0], Dec=radec[1], zem=zem)

    # Abundances (AODM)
    # Table 3
    tab_fil = xa_path + "/data/LLS/meiring09.tb3.ascii"
    with open(tab_fil, 'r') as f:
        flines3 = f.readlines()
    #
    ion_dict = {}
    for iline in flines3:
        if iline[0:2] in ['\h', '  ']:
            continue
        # Parse
        isplit = iline.split('&')
        # Ions
        if iline[0:2] == 'QS':
            ioncs = []
            Zions = []
            for iis in isplit[3:-1]:  # Skipping HI
                # Parse
                #is2 = iis.split('\\')
                #ip2 = is2[2].find('}')
                ionc = iis.strip()
                # Zion
                Zion = xai.name_ion(ionc)
                # Append
                ioncs.append(ionc)
                Zions.append(Zion)
            continue
        if iline[0] == 'Q':
            # QSO
            qso = isplit[0].strip()
            if qso[-1] in ['A', 'B', 'C']:
                qso = qso[0:-1]
            # zabs and name
            zabs = float(isplit[1].strip())
            qso_dict[qso]['name'] = qso + 'z_{:.3f}'.format(zabs)
            qso_dict[qso]['zabs'] = zabs
            # NHI
            is2 = isplit[2].strip()
            if is2[0] == '$':
                qso_dict[qso]['NHI'] = 99.99  # THROW OUT Q1436-0051B
                qso_dict[qso]['sigNHI'] = np.array([0., 0.])
            else:
                qso_dict[qso]['NHI'] = float(is2[0:5])
                qso_dict[qso]['sigNHI'] = np.array([float(is2[10:])] * 2)
            #if qso_dict[qso]['NHI'] >= 20.3:
            #    print('Uh oh.  DLA')
            # Generate LLS
            lls = LLSSystem(**qso_dict[qso])
            continue
        else:
            # ADOM Columns
            ion_dict = {}
            for kk, iis in enumerate(isplit[3:-1]):
                is2 = iis.strip()
                if is2[0:3] == '$>$':
                    ion_dict[ioncs[kk]] = dict(sig_clm=0.,
                                               flg_clm=2,
                                               Z=Zions[kk][0],
                                               ion=Zions[kk][1])
                    ion_dict[ioncs[kk]]['clm'] = float(is2[3:])
                elif is2[0:3] == '$<$':
                    ion_dict[ioncs[kk]] = dict(sig_clm=0.,
                                               flg_clm=3,
                                               Z=Zions[kk][0],
                                               ion=Zions[kk][1])
                    ion_dict[ioncs[kk]]['clm'] = float(is2[3:])
                elif len(is2) == 0:
                    pass
                else:
                    ion_dict[ioncs[kk]] = dict(flg_clm=1,
                                               Z=Zions[kk][0],
                                               ion=Zions[kk][1])
                    ion_dict[ioncs[kk]]['clm'] = float(is2[0:5])
                    ion_dict[ioncs[kk]]['sig_clm'] = float(is2[10:])
            # Finish
            lls._ionclms = IonClms(idict=ion_dict)
            lls.Refs.append('Mei09')
            all_lls.append(lls)

    # Return SLLS only
    fin_slls = [ills for ills in all_lls if ills.NHI < 20.3]
    return fin_slls
Ejemplo n.º 14
0
def peroux06b():
    '''Peroux, C. et al. 2006b, A&A, 450, 53
    SDSS J1323-0021
    Metal rich
    Metal columns copied by JXP from Table 1 
    Total NHI from damping wings
    '''
    # Setup
    radec = xor.stod1('J132323.78-002155.2')  # SDSS Name
    lls = LLSSystem(name='SDSSJ1323-0021_z0.716',
                    RA=radec[0],
                    Dec=radec[1],
                    zem=1.390,
                    zabs=0.716,
                    vlim=[-200., 200.] * u.km / u.s,
                    NHI=20.21,
                    sigNHI=np.array([0.20, 0.20]))
    # Parse table file
    tab_fil = xa_path + "/data/LLS/peroux06b.tb1.ascii"
    with open(tab_fil, 'r') as f:
        flines = f.readlines()
    ion_dict = {}
    for iline in flines:
        isplit = iline.split('\t')
        if len(isplit[0]) == 0:
            # Grab ions and init
            ions = isplit[3:10]
            for ion in ions:
                Zion = xai.name_ion(ion)
                ion_dict[ion] = dict(clm=0.,
                                     sig_clm=0.,
                                     flg_clm=1,
                                     Z=Zion[0],
                                     ion=Zion[1])
            continue
        # Column or sigma?
        if isplit[0][0] == 'N':  # Column
            for kk, iis in enumerate(isplit[3:10]):
                ion = ions[kk]
                if iis[0] == '>':
                    ion_dict[ion]['flg_clm'] = 2
                    ion_dict[ion]['clm'] += float(iis[1:])
                elif iis[0] == '<':
                    pass
                elif iis[0] == '.':
                    pass
                else:
                    ion_dict[ion]['clm'] += float(iis)
        else:  # Sigma
            for kk, iis in enumerate(isplit[3:10]):
                ion = ions[kk]
                if iis[0] == '.':
                    pass
                else:
                    ion_dict[ion]['sig_clm'] += float(iis)**2
    # Convert to log
    for ion in ions:
        N = ion_dict[ion]['clm']
        sig = np.sqrt(ion_dict[ion]['sig_clm'])
        #
        ion_dict[ion]['clm'] = np.log10(N)
        if ion_dict[ion]['flg_clm'] == 2:
            ion_dict[ion]['sig_clm'] = 0.
        else:
            ion_dict[ion]['sig_clm'] = sig / N / np.log(10)
    # Finish
    lls._ionclms = IonClms(idict=ion_dict)
    lls.Refs.append('Prx06b')
    return lls
Ejemplo n.º 15
0
def peroux06a():
    '''Peroux, C. et al. 2006a, MNRAS, 372, 369
    SDSS J0134+0051
    One of her sample
    Metal columns taken by JXP from Table 2 (no online data)
    Total NHI from damping wings
    '''
    # Setup
    radec = xor.stod1('J013405.75+005109.4')  # SDSS Name
    lls = LLSSystem(name='SDSSJ0134+0051_z0.842',
                    RA=radec[0],
                    Dec=radec[1],
                    zem=1.522,
                    zabs=0.842,
                    vlim=[-150., 150.] * u.km / u.s,
                    NHI=19.93,
                    sigNHI=np.array([0.15, 0.15]))
    #  Table 2
    ion_dict = {}
    N = np.sum(np.array([5.56, 12.6, 13.7, 23.5, 61.4, 39.8, 6, 9.14]) * 1e10)
    sig = np.sqrt(
        np.sum((np.array([2.32, 3.1, 3.68, 4.13, 8.02, 6.65, 3.37, 2.82]) *
                1e10)**2))
    ion_dict['Mg I'] = dict(clm=np.log10(N),
                            sig_clm=sig / N / np.log(10),
                            flg_clm=1,
                            Z=12,
                            ion=1)
    ion_dict['Mg II'] = dict(clm=np.log10(5e13),
                             sig_clm=0.,
                             flg_clm=2,
                             Z=12,
                             ion=2)
    N = np.sum(
        np.array([8.17, 4.28, 32.1, 125, 710, 301, 893, 600, 263, 65.7]) *
        1e11)
    sig = np.sqrt(
        np.sum((np.array(
            [2.63, 1.40, 2.37, 8.6, 53.2, 28.4, 73.5, 61.7, 14.0, 2.95]) *
                1e11)**2))
    ion_dict['Fe II'] = dict(clm=np.log10(N),
                             sig_clm=sig / N / np.log(10),
                             flg_clm=1,
                             Z=26,
                             ion=2)
    sig = np.sqrt(np.sum((np.array([3.72, 1.84, 2.36, 3.83]) * 1e11)**2))
    ion_dict['Zn II'] = dict(clm=np.log10(2 * sig),
                             sig_clm=0.,
                             flg_clm=3,
                             Z=30,
                             ion=2)
    sig = np.sqrt(np.sum((np.array([19.4, 9.79]) * 1e11)**2))
    ion_dict['Cr II'] = dict(clm=np.log10(2 * sig),
                             sig_clm=0.,
                             flg_clm=3,
                             Z=24,
                             ion=2)
    # Not including MnII.  Appears as a detection but also given as a limit..

    # Finish
    lls._ionclms = IonClms(idict=ion_dict)
    lls.Refs.append('Prx06a')
    return lls
Ejemplo n.º 16
0
def tripp2005():
    '''Tripp, T. et al. 2005, ApJ, 2005, 619, 714
    PG 1216+069 (LLS in Virgo)
    HST/STIS, FUSE
    Metal columns parsed from Tables 2 and 3
    Total NHI from damping wings
    M/H from O/H
    '''
    # Grab ASCII files from ApJ
    tab_fils = [
        xa_path + "/data/LLS/tripp2005.tb3.ascii",
        xa_path + "/data/LLS/tripp2005.tb2.ascii"
    ]
    urls = [
        'http://iopscience.iop.org/0004-637X/619/2/714/fulltext/60797.tb3.txt',
        'http://iopscience.iop.org/0004-637X/619/2/714/fulltext/60797.tb2.txt'
    ]
    for jj, tab_fil in enumerate(tab_fils):
        chk_fil = glob.glob(tab_fil)
        if len(chk_fil) > 0:
            tab_fil = chk_fil[0]
        else:
            url = urls[jj]
            print('LLSSurvey: Grabbing table file from {:s}'.format(url))
            f = urllib2.urlopen(url)
            with open(tab_fil, "wb") as code:
                code.write(f.read())
    # Setup
    radec = xor.stod1('J121920.9320+063838.476')  # SIMBAD
    lls = LLSSystem(name='PG1216+069_z0.006',
                    RA=radec[0],
                    Dec=radec[1],
                    zem=0.3313,
                    zabs=0.00632,
                    vlim=[-100., 100.] * u.km / u.s,
                    NHI=19.32,
                    MH=-1.6,
                    sigNHI=np.array([0.03, 0.03]))
    #lls.mk_subsys(2)

    # Columns
    # Start with Table 3 (VPFIT)
    with open(tab_fils[0], 'r') as f:
        flines3 = f.readlines()
    ion_dict = {}
    for iline in flines3:
        if (len(iline.strip()) == 0):
            continue
        isplit = iline.split('\t')
        # Ion
        flg = 2
        if (len(isplit[0].strip()) > 0):  # & (isplit[0][0] not in ['1','2']):
            ipos = isplit[0].find('1')
            ionc = isplit[0][0:ipos - 1].strip()
            try:
                Zion = xai.name_ion(ionc)
            except KeyError:
                xdb.set_trace()
            flg = 1
        # Column
        csplit = isplit[3].split(' ')
        clm = float(csplit[0])
        sig = float(csplit[2])
        if flg == 1:
            ion_dict[ionc] = dict(clm=clm,
                                  sig_clm=sig,
                                  flg_clm=1,
                                  Z=Zion[0],
                                  ion=Zion[1])
        else:  # Add it in
            tmp_dict = dict(clm=clm,
                            sig_clm=sig,
                            flg_clm=1,
                            Z=Zion[0],
                            ion=Zion[1])
            logN, siglogN = xiai.sum_logN(ion_dict[ionc], tmp_dict)
            ion_dict[ionc]['clm'] = logN
            ion_dict[ionc]['sig_clm'] = siglogN
    ions = ion_dict.keys()

    # Now Table 2 for the extras
    with open(tab_fils[1], 'r') as f:
        flines2 = f.readlines()
    # Trim the first 10 lines
    flines2 = flines2[10:]
    # Loop
    for iline in flines2:
        isplit = iline.split('\t')
        #
        ionc = isplit[0].strip()
        if (len(ionc) == 0) or (ionc in ions):
            continue
        #
        Zion = xai.name_ion(ionc)
        ion_dict[ionc] = dict(Z=Zion[0], ion=Zion[1], sig_clm=0.)
        if isplit[4][0] == '<':
            ion_dict[ionc]['clm'] = float(isplit[4][1:])
            ion_dict[ionc]['flg_clm'] = 3
        else:
            raise ValueError('Should not get here')

    # Finish
    lls._ionclms = IonClms(idict=ion_dict)
    lls.Refs.append('Tri05')
    return lls
Ejemplo n.º 17
0
def tumlinson11():
    '''Tumlinson, J. et al. 2011, ApJ, 733, 111
    J1009+0713
    HST/COS
    Metal columns parsed from Table 1
    NHI from LL+Lyman series (uncertain)
    '''
    # Grab ASCII file from ApJ
    tab_fil = xa_path + "/data/LLS/tumlinson11.tb1.ascii"
    url = 'http://iopscience.iop.org/0004-637X/733/2/111/suppdata/apj388927t1_ascii.txt'
    chk_fil = glob.glob(tab_fil)
    if len(chk_fil) > 0:
        tab_fil = chk_fil[0]
    else:
        print('LLSSurvey: Grabbing table file from {:s}'.format(url))
        f = urllib2.urlopen(url)
        with open(tab_fil, "wb") as code:
            code.write(f.read())
    # Setup
    radec = xor.stod1('J100902.06+071343.8')  # From paper
    lls = LLSSystem(name='J1009+0713_z0.356',
                    RA=radec[0],
                    Dec=radec[1],
                    zem=0.456,
                    zabs=0.3558,
                    vlim=[-200., 250.] * u.km / u.s,
                    NHI=18.4,
                    sigNHI=np.array([0.41, 0.41]))
    #lls.mk_subsys(2)

    # Columns
    # Start with Table 3 (VPFIT)
    with open(tab_fil, 'r') as f:
        flines1 = f.readlines()
    # Trim
    flines1 = flines1[18:]
    #
    ion_dict = {}
    line_dict = dict(OI='1302',
                     OVI='1038',
                     MgII='2803^b',
                     SiII='1190',
                     CaII='3934',
                     FeII='2586')
    ion = None
    for iline in flines1:
        isplit = iline.split('\t')
        if ion == 'FeIII':  # Last line
            break
        # Ion
        is2 = isplit[0].split(' ')
        ion = is2[0] + is2[1]
        try:
            gdl = line_dict[ion]
        except:
            pass
            #print('Taking {:s}'.format(isplit[0]))
        else:
            if is2[2] != gdl:
                continue
        Zion = xai.name_ion(ion)
        ion_dict[ion] = dict(clm=0.,
                             sig_clm=0.,
                             flg_clm=0,
                             Z=Zion[0],
                             ion=Zion[1])
        # Combine components [could replace with SubSystems some day]
        for iis in isplit[1:-1]:
            # Upper limit
            if (iis.strip()[0] == '<') & (ion_dict[ion]['flg_clm'] == 0):
                ion_dict[ion]['flg_clm'] = 3
                ion_dict[ion]['clm'] = float(iis[1:])
            elif (iis.strip()[0] == '>'):  # Saturated
                ion_dict[ion]['flg_clm'] = 2
                ion_dict[ion]['clm'] = log_sum(
                    [ion_dict[ion]['clm'],
                     float(iis[1:5])])
            elif iis.strip()[0] in ['.', '<']:
                pass
            else:
                if ion_dict[ion]['flg_clm'] == 2:  # Add to saturated
                    ion_dict[ion]['clm'] = log_sum(
                        [ion_dict[ion]['clm'],
                         float(iis[0:4])])
                else:
                    ion_dict[ion]['flg_clm'] = 1
                    obj = dict(clm=float(iis[0:4]), sig_clm=float(iis[-4:]))
                    # Add
                    N, sig = xiai.sum_logN(ion_dict[ion], obj)
                    ion_dict[ion]['clm'] = N
                    ion_dict[ion]['sig_clm'] = sig
    # Finish
    lls._ionclms = IonClms(idict=ion_dict)
    lls.Refs.append('Tum11')
    return lls
Ejemplo n.º 18
0
def jenkins2005():
    '''Jenkins, E. et al. 2005, ApJ, 2005, 623, 767
    PHL 1811
    HST/STIS, FUSE
    Metals parsed from Table 1
      OI taken from text
      Had to input error on columns by hand (JXP)
    Total NHI from Lyman series. see Fig 3
    M/H from O/H
    '''
    # Grab ASCII file from ApJ
    tab_fil = xa_path + "/data/LLS/jenkins2005.tb1.ascii"
    chk_fil = glob.glob(tab_fil)
    if len(chk_fil) > 0:
        tab_fil = chk_fil[0]
    else:
        url = 'http://iopscience.iop.org/0004-637X/623/2/767/fulltext/61520.tb1.txt'
        print('LLSSurvey: Grabbing table file from {:s}'.format(url))
        f = urllib2.urlopen(url)
        with open(tab_fil, "wb") as code:
            code.write(f.read())
    # Setup
    radec = xor.stod1('J215501.5152-092224.688')  # SIMBAD
    lls = LLSSystem(name='PHL1811_z0.081',
                    RA=radec[0],
                    Dec=radec[1],
                    zem=0.192,
                    zabs=0.080923,
                    vlim=[-100., 100.] * u.km / u.s,
                    NHI=17.98,
                    MH=-0.19,
                    sigNHI=np.array([0.05, 0.05]))

    # AbsLines
    ism = LineList('ISM')
    Nsig = {
        'C IV': 0.4,
        'N II': 0.4,
        'Si II': 0.05,
        'Si IV': 0.25,
        'S II': 0.2,
        'Fe II': 0.12,
        'H I': 0.05,
        'S III': 0.06
    }

    # Parse Table
    with open(tab_fil, 'r') as f:
        flines = f.readlines()
    ion_dict = {}
    for iline in flines:
        iline = iline.strip()
        if (len(iline) == 0):
            continue
        # Split on tabs
        isplit = iline.split('\t')
        # Offset?
        ioff = 0
        if isplit[0][0] in ['1', '2']:
            ioff = -1
        # Catch bad lines
        if (isplit[1 + ioff][0:6]
                in ['1442.0', '1443.7',
                    '1120.9']):  # Skip goofy CII line and CII*
            continue
        if len(isplit[2 + ioff]) == 0:
            continue
        # Ion
        if (len(isplit[0].strip()) > 0) & (isplit[0][0] not in ['1', '2']):
            ionc = isplit[0].strip()
            try:
                Zion = xai.name_ion(ionc)
            except KeyError:
                xdb.set_trace()
        # Generate the Line
        try:
            newline = AbsLine(float(isplit[2 + ioff]) * u.AA,
                              linelist=ism,
                              closest=True)
        except ValueError:
            xdb.set_trace()
        newline.attrib['z'] = lls.zabs
        # Spectrum
        newline.analy['datafile'] = 'STIS' if 'S' in isplit[1] else 'FUSE'
        # EW
        try:
            EWvals = isplit[4 + ioff].split(' ')
        except IndexError:
            xdb.set_trace()
        newline.attrib['EW'] = float(EWvals[0]) * u.AA / 1e3
        newline.attrib['EWsig'] = float(EWvals[2]) * u.AA / 1e3
        newline.attrib['flgEW'] = 1
        if len(isplit) < (5 + ioff + 1):
            continue
        # Colm?
        #xdb.set_trace()
        if (len(isplit[5 + ioff].strip()) > 0) & (isplit[5 + ioff].strip() !=
                                                  '\\ldots'):
            if isplit[5 + ioff][0] == '\\':
                ipos = isplit[5 + ioff].find(' ')
                newline.attrib['N'] = float(isplit[5 + ioff][ipos + 1:])
                newline.attrib['flagN'] = 2
            elif isplit[5 + ioff][0] == '<':
                ipos = 0
                newline.attrib['N'] = float(isplit[5 + ioff][ipos + 1:])
                newline.attrib['flagN'] = 3
            elif isplit[5 + ioff][0] == '1':
                try:
                    newline.attrib['N'] = float(isplit[5 + ioff][0:5])
                except ValueError:
                    xdb.set_trace()
                newline.attrib['flagN'] = 1
                try:
                    newline.attrib['Nsig'] = Nsig[ionc]
                except KeyError:
                    print('No error for {:s}'.format(ionc))
            else:
                raise ValueError('Bad character')
            # ion_dict
            ion_dict[ionc] = dict(clm=newline.attrib['N'],
                                  sig_clm=newline.attrib['Nsig'],
                                  flg_clm=newline.attrib['flagN'],
                                  Z=Zion[0],
                                  ion=Zion[1])
        # Append
        lls.lines.append(newline)
    # Fix NI, OI
    ion_dict['O I']['clm'] = 14.47
    ion_dict['O I']['sig_clm'] = 0.05
    ion_dict['N I']['flg_clm'] = 3
    lls._ionclms = IonClms(idict=ion_dict)

    lls.Refs.append('Jen05')
    # Return
    return lls
Ejemplo n.º 19
0
def xq100_plls_ex(outfil='fig_xq100_plls_ex.pdf'):

    # Load spectrum
    spec_fil = os.getenv('DROPBOX_DIR') + '/XQ-100/data/J0030-5159_uvb.fits'
    spec = load_spectrum(spec_fil)

    # Generate model
    model_file = os.getenv(
        'DROPBOX_DIR') + '/XQ-100/LLS/convg_J0030-5159_llsfit.json'
    with open(model_file) as data_file:
        lls_dict = json.load(data_file)
    # Continuum
    basec = Quantity(lls_dict['conti'])
    telfer_spec = XSpectrum1D.from_tuple((spec.dispersion.value, basec.value))

    # Start the plot
    if outfil is not None:
        pp = PdfPages(outfil)

    plt.figure(figsize=(8, 4))
    plt.clf()
    gs = gridspec.GridSpec(1, 1)
    fsz = 17.

    # Read and plot full spectrum
    ax_full = plt.subplot(gs[0])

    # Limits
    wvmnx = [3600., 5000.]
    gdpix = np.where(spec.dispersion < wvmnx[1] * u.AA)[0]
    perc = xsb.perc(spec.flux[gdpix])
    ax_full.set_xlim(wvmnx)
    #ax_full.set_ylim(-0.05*perc[1], 1.1*perc[1])
    ax_full.set_ylim(-1e-18, 4e-17)

    # Plot
    ax_full.plot(spec.dispersion, spec.flux, color='black', lw=1.0)
    ax_full.plot(wvmnx, [0., 0.], '--', color='green')

    # Label
    ax_full.set_xlabel('Wavelength')
    ax_full.set_ylabel('Relative Flux')
    ax_full.text(0.05,
                 0.9,
                 'XQ100 J0030-5159',
                 transform=ax_full.transAxes,
                 color='black',
                 size='x-large',
                 ha='left',
                 va='center',
                 bbox={'facecolor': 'white'})

    all_ills = []
    all_lls = []
    all_zlls = []
    for key in lls_dict['LLS'].keys():
        new_sys = LLSSystem(NHI=lls_dict['LLS'][key]['NHI'])
        new_sys.zabs = lls_dict['LLS'][key]['z']
        new_sys.fill_lls_lines(bval=lls_dict['LLS'][key]['bval'] * u.km / u.s)
        #
        all_ills.append(new_sys)
        all_lls.append(new_sys)
        all_zlls.append(new_sys.zabs)
    # Model
    norm_flux = lls_model(spec.dispersion, all_ills, smooth=lls_dict['smooth'])
    continuum = telfer_spec.flux * lls_dict['conti_model']['Norm'] * (
        spec.dispersion.value /
        lls_dict['conti_model']['piv_wv'])**lls_dict['conti_model']['tilt']

    #  Model
    ax_full.plot(spec.dispersion, continuum * norm_flux)

    # Font size
    xputils.set_fontsize(ax_full, fsz)

    # Finish page
    plt.tight_layout(pad=0.2, h_pad=0.3, w_pad=0.0)
    pp.savefig()
    plt.close()
    print('Wrote: {:s}'.format(outfil))
    # Finish
    pp.close()
Ejemplo n.º 20
0
def test_simple_init():
    # Init
    lls = LLSSystem(NHI=17.9)
    #
    np.testing.assert_allclose(lls.NHI, 17.9)
Ejemplo n.º 21
0
def battisti12():
    '''Battisti, A. et al. 2012, ApJ, 744, 93
    HST/COS
    QSO info from Table 1
    Metal columns parsed from Table 3
    NHI from Lya
    '''
    all_lls = []
    # Grab ASCII files from ApJ
    tab_fils = [
        xa_path + "/data/LLS/battisti12.tb1.ascii",
        xa_path + "/data/LLS/battisti12.tb3.ascii"
    ]
    urls = [
        'http://iopscience.iop.org/0004-637X/744/2/93/suppdata/apj413924t1_ascii.txt',
        'http://iopscience.iop.org/0004-637X/744/2/93/suppdata/apj413924t3_ascii.txt'
    ]
    for jj, tab_fil in enumerate(tab_fils):
        chk_fil = glob.glob(tab_fil)
        if len(chk_fil) > 0:
            tab_fil = chk_fil[0]
        else:
            url = urls[jj]
            print('LLSSurvey: Grabbing table file from {:s}'.format(url))
            f = urllib2.urlopen(url)
            with open(tab_fil, "wb") as code:
                code.write(f.read())
    # QSO info
    with open(tab_fils[0], 'r') as f:
        flines1 = f.readlines()
    # Grab RA/DEC
    all_idict = []
    for iline in flines1:
        if iline[0:2] != 'SD':
            continue
        # Parse
        isplit = iline.split('\t')
        name = isplit[0].split(' ')[1]
        radec = xor.stod1(name)
        zem = float(isplit[1].strip())
        zabs = float(isplit[2].strip())
        NHI = float(isplit[3].strip()[0:4])
        sigNHI = np.array([float(isplit[3].strip()[11:])] * 2)
        # Save
        lls = LLSSystem(name=name,
                        RA=radec[0],
                        Dec=radec[1],
                        zem=zem,
                        zabs=zabs,
                        NHI=NHI,
                        sigNHI=sigNHI)
        #
        all_lls.append(lls)
        all_idict.append({})

    # Abundances
    with open(tab_fils[1], 'r') as f:
        flines3 = f.readlines()
    flines3 = flines3[5:]
    ion = None
    for iline in flines3:
        if ion == 'Ni II':
            break
        isplit = iline.split('\t')
        if isplit[0] == 'C II*':  # Skipping CII*
            continue
        # ion
        ipos = -1
        while (isplit[0][ipos] not in ['I', 'V']):
            ipos -= 1
        ion = isplit[0][0:ipos + 1 + len(isplit[0])]
        Zion = xai.name_ion(ion)
        # Loop on systems
        for kk, iis in enumerate(isplit[1:-1]):
            if iis.strip()[0] == '.':
                continue
            all_idict[kk][ion] = dict(Z=Zion[0], ion=Zion[1], sig_clm=0.)
            if iis[0] == '>':
                all_idict[kk][ion]['flg_clm'] = 2
                all_idict[kk][ion]['clm'] = float(iis[1:6])
            elif iis[0] == '<':
                all_idict[kk][ion]['flg_clm'] = 3
                all_idict[kk][ion]['clm'] = float(iis[1:])
            else:
                all_idict[kk][ion]['flg_clm'] = 1
                all_idict[kk][ion]['clm'] = float(iis[0:5])
                all_idict[kk][ion]['sig_clm'] = float(iis[-4:])

    # Return SLLS only
    for kk, lls in enumerate(all_lls):
        try:
            lls._ionclms = IonClms(idict=all_idict[kk])
        except ValueError:
            xdb.set_trace()
        lls.Refs.append('Bat12')
    fin_slls = [ills for ills in all_lls if ills.NHI < 20.3]
    return fin_slls