예제 #1
0
파일: LTE.py 프로젝트: pirg/PyLTE
 def trimmed_query(self, *args, **kwargs):
     S = Splatalogue(energy_max=500,
                     energy_type='eu_k',
                     energy_levels=['el4'],
                     line_strengths=['ls4'],
                     only_NRAO_recommended=True,
                     show_upper_degeneracy=True)
     columns = [
         'Species', 'Chemical Name', 'Resolved QNs', 'Freq-GHz',
         'Log<sub>10</sub> (A<sub>ij</sub>)', 'E_U (K)',
         'Upper State Degeneracy'
     ]
     table = S.query_lines(*args, **kwargs)
     table.rename_column('Log<sub>10</sub> (A<sub>ij</sub>)', 'log10(Aij)')
     table['Aij'] = pow(10, table['log10(Aij)'])
     #table.remove_column('log10(Aij)')
     table.rename_column('E_U (K)', 'EU_K')
     table.rename_column('Resolved QNs', 'QNs')
     table.rename_column('Upper State Degeneracy', 'g_u')
     table['Freq-MHz'] = table['Freq-GHz'] * 1000.
     table.remove_column('Freq-GHz')
     table.sort('Freq-MHz')
     self.remove_hfs(table)
     if self.idx_obs:
         table = table[self.idx_obs]
     return table
예제 #2
0
    def query(low_freq,
              high_freq,
              chemical_name=None,
              line_list=[LineList.JPL, LineList.CDMS]):
        """ Class method for querying splatalogue.

            Wraps the query_lines function from astroquery.
        """

        columns = [
            'Species', 'Chemical Name', 'Freq-GHz(rest frame,redshifted)',
            'Meas Freq-GHz(rest frame,redshifted)', 'CDMS/JPL Intensity',
            'Lovas/AST Intensity', 'Linelist'
        ]

        try:
            # TODO-Dynamic Frequency Units
            # Query splatalogue and convert into pandas dataframes
            if chemical_name:
                df = Splatalogue.query_lines(
                    low_freq * u.MHz,
                    high_freq * u.MHz,
                    chemical_name=chemical_name).to_pandas()
            else:
                df = Splatalogue.query_lines(low_freq * u.MHz,
                                             high_freq * u.MHz,
                                             line_lists=line_list).to_pandas()
            df = df[columns]

        except TimeoutError:
            return []

        return df
예제 #3
0
    def __init__(
        self,
        chemical_name,
        energy_max=2500,
        nu_min=216 * u.GHz,
        nu_max=235 * u.GHz,
        line_lists=['SLAIM'],
        freq_type='Freq-GHz',
        linelimit=100000,
    ):
        Splatalogue.LINES_LIMIT = linelimit
        line_ids = Splatalogue.get_species_ids().find(chemical_name)
        if len(line_ids) > 1:
            mwts = [int(lid[:3]) for lid in line_ids]
            if len(set(mwts)) != 1:
                raise ValueError("Chemical name {0} matches too many "
                                 "different lines: {1}".format(
                                     chemical_name, line_ids))
            self.molwt = mwts[0]
        elif len(line_ids) == 1:
            self.molwt = int(list(line_ids.keys())[0][:3])
        else:
            raise ValueError("No matching molecules")
        linecat = Splatalogue.query_lines(
            nu_min,
            nu_max,
            chemical_name=chemical_name,
            energy_max=energy_max,
            energy_type='eu_k',
            line_strengths=['ls1', 'ls2', 'ls3', 'ls4', 'ls5'],
            line_lists=line_lists,
            show_upper_degeneracy=True)
        self.linecat = linecat
        self.freqs = np.array(linecat[freq_type]) * u.GHz
        self.aij = linecat['Log<sub>10</sub> (A<sub>ij</sub>)']
        self.deg = [
            x if x > 0 else 1 for x in linecat['Upper State Degeneracy']
        ]
        self.SijMu2 = linecat[
            'S<sub>ij</sub>&#956;<sup>2</sup> (D<sup>2</sup>)']
        self.EU = (np.array(linecat['E_U (K)']) * u.K * constants.k_B).to(
            u.erg).value

        ## crappy debug hack
        #if 'OSU' in line_lists:
        #    self.EU = (np.array(linecat['E_L (K)'])*u.K*constants.k_B).to(u.erg).value

        slaim_query = Splatalogue.query_lines(1 * u.Hz,
                                              10000 * u.GHz,
                                              chemical_name=chemical_name,
                                              energy_max=energy_max,
                                              energy_type='eu_k',
                                              line_lists=['SLAIM'],
                                              show_upper_degeneracy=True)
        self.slaim = slaim_query
        self.all_EU = (slaim_query['E_U (K)'] * u.K * constants.k_B).to(
            u.erg).value
        self.all_freq = slaim_query['Freq-GHz']
        self.all_deg = slaim_query['Upper State Degeneracy']
예제 #4
0
 def findSpeciesSource(self, sourceName, redshift, DV, flag = False):
     """
     Try to identify the lines for a given source with redshift using the splatalogue DB. 
     If flag = True search only for lines w/o flagging (EDGE, TELURIC, ...)
     DV : uncertainty on the velocity in km/s
     """
     
     lines = self.findSource(sourceName, flag)
     
     if len(lines) == 0:
         print("## Species - No lines found for source %s"%(sourceName))
         return(0)
     
     for li in lines:
         freq1 = li[4] * (1. + redshift)
         freq2 = li[5] * (1. + redshift)
         
         df = freq1 * u.GHz * DV * 1e3 * u.m / u.s /  const.c
         print df
         
         columns = ('Species','Chemical Name','Resolved QNs','Freq-GHz','Meas Freq-GHz','Log<sub>10</sub> (A<sub>ij</sub>)','E_U (K)','Linelist')
         
         transitions = spla.query_lines(freq1*u.GHz-df,freq2*u.GHz+df)[columns]
         
         transitions.rename_column('Log<sub>10</sub> (A<sub>ij</sub>)','log10(Aij)')
         transitions.rename_column('E_U (K)','EU_K')
         transitions.rename_column('Resolved QNs','QNs')
         transitions.sort('EU_K')
         
     
         transitions.pprint(100)
    def get_composition(self, full_name):
        columns = ('Species')
        rows = Splatalogue.query_lines_async(chemical_name=full_name)[columns]
        row = rows[0]
        name = row[0]

        return name
예제 #6
0
def query_splatalogue(spikes):
    # from a spike to the splatalogue (linelist, tag, moleculename)
    # verify this is right
    spacing = (spikes.data[1:, 0] - spikes.data[:-1, 0]).mean()
    bounds = (
        np.column_stack([spikes.frequency - spacing, spikes.frequency + spacing])
        * u.GHz
    )
    out = []
    for i in range(spikes.frequency.shape[0]):
        res = Splatalogue.query_lines(
            *bounds[i, :].T,
            show_molecule_tag=True,
            line_lists=["CDMS", "JPL"],
            exclude=None,
            line_strengths="ls1",
        )
        if "Molecule<br>Tag" in res.keys():
            tag = list(
                map(lambda x: str(x).zfill(6).replace("-", "0"), res["Molecule<br>Tag"])
            )
            db = list(res["Linelist"])
            mname = list(res["Chemical Name"])
            species = list(res["Species"])
            molecule = [f"{m} ({s})" for m, s in zip(mname, species)]
            if res:
                out.append(splat_query(db, tag, molecule))
    # tuple transpositions!
    return set(zip(*[sum(o, []) for o in zip(*out)]))
예제 #7
0
def search_center_frequency(frequency: float, width=0.5):
    """
    Function for wrapping the astroquery Splatalogue API for looking up a frequency and finding candidate molecules
    for assignment. The width parameter adjusts the +/- range to include in the search: for high frequency surveys,
    it's probably preferable to use a percentage to accommodate for the typically larger uncertainties (sub-mm
    experiments).

    Parameters
    ----------
    frequency: float
        Frequency in MHz to search Splatalogue for.
    width: float, optional
        Absolute frequency offset in MHz to include in the search.

    Returns
    -------
    dataframe or None
        Pandas dataframe containing frequency matches, or None if no matches are found.
    """
    min_freq = frequency - width
    max_freq = frequency + width
    try:
        splat_df = Splatalogue.query_lines(
            min_freq*u.MHz,
            max_freq*u.MHz,
            line_lists=["CDMS", "JPL"]
        ).to_pandas()
        # These are the columns wanted
        columns = [
            "Species",
            "Chemical Name",
            "Meas Freq-GHz(rest frame,redshifted)",
            "Freq-GHz(rest frame,redshifted)",
            "Resolved QNs",
            "CDMS/JPL Intensity",
            "E_U (K)",
            "E_L (K)"
            ]
        # Take only what we want
        splat_df = splat_df[columns]
        splat_df.columns = [
            "Species",
            "Chemical Name",
            "Meas Freq-GHz",
            "Freq-GHz",
            "Resolved QNs",
            "CDMS/JPL Intensity",
            "E_U (K)",
            "E_L (K)"
            ]
        # Now we combine the frequency measurements
        splat_df["Frequency"] = splat_df["Meas Freq-GHz"].values
        # Replace missing experimental data with calculated
        splat_df["Frequency"].fillna(splat_df["Freq-GHz"], inplace=True)
        # Convert to MHz
        splat_df["Frequency"] *= 1000.
        return splat_df
    except IndexError:
        print("Could not parse Splatalogue table at {:,.4f}".format(frequency))
        return None
예제 #8
0
    def get_composition(self, full_name):
        columns = ('Species')
        rows = Splatalogue.query_lines_async(chemical_name=full_name)[columns]
        row = rows[0]
        name = row[0]

        return name
    def query(low_freq, high_freq, chemical_name=None, line_list=[LineList.JPL, LineList.CDMS]):

        columns = ('Species', 'Chemical Name', 'Freq-GHz', 'Meas Freq-GHz', 'CDMS/JPL Intensity', 'Lovas/AST Intensity',
                   'Linelist')

        try:
            # TODO-Dynamic Frequency Units
            if chemical_name is not None:
                lines = Splatalogue.query_lines(low_freq * u.MHz, high_freq * u.MHz,
                                                chemical_name=chemical_name)[columns]
            else:
                lines = Splatalogue.query_lines(low_freq * u.MHz, high_freq * u.MHz,
                                                line_lists=line_list)[columns]
        except TimeoutError:
            return []

        return lines
    def __init__(self, chemical_name, energy_max=2500,
                 nu_min=216*u.GHz, nu_max=235*u.GHz, line_lists=['SLAIM'],
                 freq_type='Freq-GHz',
                 linelimit=100000,
                ):
        Splatalogue.LINES_LIMIT=linelimit
        line_ids = Splatalogue.get_species_ids().find(chemical_name)
        if len(line_ids) > 1:
            mwts = [int(lid[:3]) for lid in line_ids]
            if len(set(mwts)) != 1:
                raise ValueError("Chemical name {0} matches too many "
                                 "different lines: {1}".format(chemical_name,
                                                               line_ids))
            self.molwt = mwts[0]
        elif len(line_ids) == 1:
            self.molwt = int(list(line_ids.keys())[0][:3])
        else:
            raise ValueError("No matching molecules")
        linecat = Splatalogue.query_lines(nu_min, nu_max,
                                          chemical_name=chemical_name,
                                          energy_max=energy_max,
                                          energy_type='eu_k',
                                          line_strengths=['ls1','ls2','ls3','ls4','ls5'],
                                          line_lists=line_lists,
                                          show_upper_degeneracy=True)
        self.linecat = linecat
        self.freqs = np.array(linecat[freq_type])*u.GHz
        self.aij = linecat['Log<sub>10</sub> (A<sub>ij</sub>)']
        self.deg = [x if x > 0 else 1 for x in linecat['Upper State Degeneracy']]
        self.SijMu2 = linecat['S<sub>ij</sub>&#956;<sup>2</sup> (D<sup>2</sup>)']
        self.EU = (np.array(linecat['E_U (K)'])*u.K*constants.k_B).to(u.erg).value

        ## crappy debug hack
        #if 'OSU' in line_lists:
        #    self.EU = (np.array(linecat['E_L (K)'])*u.K*constants.k_B).to(u.erg).value

        slaim_query = Splatalogue.query_lines(1*u.Hz, 10000*u.GHz,
                                              chemical_name=chemical_name,
                                              energy_max=energy_max,
                                              energy_type='eu_k',
                                              line_lists=['SLAIM'],
                                              show_upper_degeneracy=True)
        self.slaim = slaim_query
        self.all_EU = (slaim_query['E_U (K)']*u.K*constants.k_B).to(u.erg).value
        self.all_freq = slaim_query['Freq-GHz']
        self.all_deg = slaim_query['Upper State Degeneracy']
예제 #11
0
def specmaker(plot, x, y, xmin, xmax, center, trans, ymax, ymin, moddata,
              thickmoddata):
    plot.set_xlim(xmin.value, xmax.value)
    plot.axvline(x=center,
                 color='green',
                 linestyle='--',
                 linewidth=2.0,
                 label='CH3OH')
    plot.set_ylim(ymin, ymax)
    plot.plot(x, y, drawstyle='steps')
    plot.plot(x, moddata, color='brown', label=(r'$\tau<<1$'))
    plot.plot(x, thickmoddata, color='cyan', label=(r'$\tau>1'))
    plot.set_title(trans)
    for mols in range(len(contaminants)):
        contamlabel = 0
        linelistcheck = 0
        for lis in linelistlist:
            if linelistcheck > 0:
                #print(contaminants[mols]+' already plotted.')
                break
            else:
                contamtable = Splatalogue.query_lines(
                    (mins[col + rowoffset] * (1 + z)),
                    (maxs[col + rowoffset] * (1 + z)),
                    energy_max=1840,
                    energy_type='eu_k',
                    chemical_name=contaminants[mols],
                    line_lists=[lis],
                    show_upper_degeneracy=True)
                if len(contamtable) == 0:
                    print('No ' + contaminants[mols] + ' lines in ' + lis +
                          ' frequency range ' + str(mins[col + rowoffset]) +
                          '-' + str(maxs[col + rowoffset]) + '.')
                    continue
                else:
                    linelistcheck += 1
                    print('(' + lis + ') ' + contaminants[mols] +
                          ' contaminants identified for CH3OH ' +
                          mqns[col + rowoffset] + ' at ' +
                          str(mins[col + rowoffset] + linewidth) + ' GHz.')
                    table = utils.minimize_table(contamtable)
                    line = (table['Freq'] * 10**9) / (1 + z)  #Redshifted
                    qns = table['QNs']
                    for g in range(len(table)):
                        if g == 0 and contamlabel == 0:
                            contamline = ax[row, col].axvline(
                                x=line[g],
                                color=colors[mols],
                                label=contaminants[mols])
                            print(contaminants[mols])
                            contamlabel += 1
                        else:
                            ax[row, col].axvline(x=line[g], color=colors[mols])
    '''
예제 #12
0
 def lines(species,
           min_frequency,
           max_frequency,
           show_upper_degeneracy=True,
           transition=None):
     query = Splatalogue.query_lines(
         min_frequency=min_frequency,
         max_frequency=max_frequency,
         chemical_name=str(" " + species + " "),
         transition=str(transition),
         show_upper_degeneracy=show_upper_degeneracy)
     return query
예제 #13
0
    def query(low_freq,
              high_freq,
              chemical_name=None,
              line_list=[LineList.JPL, LineList.CDMS]):

        columns = ('Species', 'Chemical Name', 'Freq-GHz', 'Meas Freq-GHz',
                   'CDMS/JPL Intensity', 'Lovas/AST Intensity', 'Linelist')

        try:
            # TODO-Dynamic Frequency Units
            if chemical_name is not None:
                lines = Splatalogue.query_lines(
                    low_freq * u.MHz,
                    high_freq * u.MHz,
                    chemical_name=chemical_name)[columns]
            else:
                lines = Splatalogue.query_lines(low_freq * u.MHz,
                                                high_freq * u.MHz,
                                                line_lists=line_list)[columns]
        except TimeoutError:
            return []

        return lines
예제 #14
0
파일: LTE.py 프로젝트: pirg/PyLTE
 def trimmed_query(self, *args,**kwargs):
         S = Splatalogue(energy_max=500,
            energy_type='eu_k',energy_levels=['el4'],
            line_strengths=['ls4'],
            only_NRAO_recommended=True,
            show_upper_degeneracy=True)
         columns = ['Species','Chemical Name','Resolved QNs','Freq-GHz',
                    'Log<sub>10</sub> (A<sub>ij</sub>)',
                    'E_U (K)','Upper State Degeneracy' ]
         table = S.query_lines(*args, **kwargs)
         table.rename_column('Log<sub>10</sub> (A<sub>ij</sub>)','log10(Aij)')
         table['Aij'] = pow(10,table['log10(Aij)'])
         #table.remove_column('log10(Aij)')
         table.rename_column('E_U (K)','EU_K')
         table.rename_column('Resolved QNs','QNs')
         table.rename_column('Upper State Degeneracy','g_u')
         table['Freq-MHz'] = table['Freq-GHz']*1000.
         table.remove_column('Freq-GHz')        
         table.sort('Freq-MHz')
         self.remove_hfs(table)
         if self.idx_obs:
           table = table[self.idx_obs]
         return table
    def get_all_lines(self, min_freq, max_freq, line_list=[LineList.JPL, LineList.CDMS]):
        columns = ('Species', 'Chemical Name', 'Freq-GHz', 'Meas Freq-GHz',
                   'CDMS/JPL Intensity', 'Lovas/AST Intensity', 'Linelist')

        rows = Splatalogue.query_lines(min_freq * u.MHz, max_freq * u.MHz,
                                       chemical_name=self.full_name,
                                       line_lists=line_list)[columns]
        lines = []
        for row in rows:
            name, full_name, frequency, intensity, line_list = SplatalogueAnalysis.get_row_data(row)
            if min_freq < frequency < max_freq:
                line = Line(frequency, line_list, intensity)
                lines.append(line)

        return lines
    def get_full_frequency_intensity_list(full_name, min_freq, max_freq, line_list=[LineList.JPL, LineList.CDMS]):
        columns = ('Species', 'Chemical Name', 'Freq-GHz', 'Meas Freq-GHz',
                   'CDMS/JPL Intensity', 'Lovas/AST Intensity', 'Linelist')

        rows = Splatalogue.query_lines(min_freq * u.MHz, max_freq * u.MHz,
                                       chemical_name=full_name,
                                       line_lists=line_list)[columns]
        frequencies = []
        intensities = []
        for row in rows:
            name, full_name, frequency, intensity, line_list = SplatalogueAnalysis.get_row_data(row)
            if min_freq < frequency < max_freq:
                frequencies.append(frequency * 1000)  # convert to MHz
                intensities.append(intensity)

        return frequencies, intensities
def find_lines_in_header(header, return_pixels=False, **kwargs):
    """
    Create a dictionary of line name: line position (in pixel units or
    frequency) for later extraction

    Parameters
    ----------
    header: astropy.io.fits.Header
    return_pixels: bool
        Return the line dictionary with pixel units in the header?
        Otherwises, returns frequency (in GHz)

    Examples
    --------
    >>> from astropy.io import fits
    >>> header = fits.getheader('cubefile.fits')
    >>> linedict = find_lines_in_header(header, energy_max=50,
    ...                                 energy_type='eu_k')
    """

    naxis3 = header["NAXIS3"]
    wcs = WCS(header)

    xarr = np.arange(naxis3)

    r, d = wcs.wcs.crval[:2]
    frequencies = wcs.wcs_pix2world([(r, d, z) for z in xarr], 0)[:, 2]
    unit = u.Unit(header["CUNIT3"])

    lines = splatutils.minimize_table(
        Splatalogue.query_lines(frequencies.min() * unit, frequencies.max() * unit, **kwargs)
    )

    if return_pixels:

        def nearest(x):
            return np.argmin(np.abs(frequencies - x))

        linedict = {row["Species"]: nearest(row["Freq"] * 1e9) for row in lines}
    else:
        linedict = {row["Species"]: row["Freq"] for row in lines}

    return linedict
예제 #18
0
    def get_all_lines(self,
                      min_freq,
                      max_freq,
                      line_list=[LineList.JPL, LineList.CDMS]):
        columns = ('Species', 'Chemical Name', 'Freq-GHz', 'Meas Freq-GHz',
                   'CDMS/JPL Intensity', 'Lovas/AST Intensity', 'Linelist')

        rows = Splatalogue.query_lines(min_freq * u.MHz,
                                       max_freq * u.MHz,
                                       chemical_name=self.full_name,
                                       line_lists=line_list)[columns]
        lines = []
        for row in rows:
            name, full_name, frequency, intensity, line_list = SplatalogueAnalysis.get_row_data(
                row)
            if min_freq < frequency < max_freq:
                line = Line(frequency, line_list, intensity)
                lines.append(line)

        return lines
예제 #19
0
def find_molecules():
    """ Classify the molecules from their frequency for each dataset """
    for id, dataset in enumerate(data):
        # Locate the indices where the flux is greater than 3 standard deviations
        # There are 4 datasets.  Column 0 is the frequency, column 1 is the flux
        # Splatalogue appears to be accurate up to 5 decimal places
        molecules = {}  # An empty dictionary to store the results of each detected molecule and rest frequency
        delta = 0.00005 # +/- when searching frequencies
        frequencies = np.round(dataset[np.where( dataset[:, 1] >= 3 * np.std(dataset[:, 1])), 0], 5)[0]
        for freq in frequencies:
            results = Splatalogue.query_lines( (freq - delta)*u.GHz, (freq + delta)*u.GHz,
                                                show_molecule_tag = True,
                                                top20 = 'planet',
                                                line_lists = ['CDMS', 'JPL'],
                                                line_strengths = 'ls1')
            # Append the chemical names corresponding to the searched frequency.
            if len(results) > 0:
                molecules[freq] = {"Chemical Name": results["Chemical Name"].tolist(),
                                   "Molecule Tag": results["Molecule<br>Tag"].tolist()}
            else:
                molecules[freq] = {"Chemical Name": "Unknown",
                                   "Molecule Tag": None}
            # Append the chemical name and frequency to the dictionary of all molecules found
            if len(results) > 0:
                for i, molecule in enumerate(results["Chemical Name"].tolist()):
                    if molecule in all_molecules.keys():
                        all_molecules[molecule]["Occurances"].append(freq)
                    else:
                        molecule_tag = "0" + str(results["Molecule<br>Tag"][i]) if len(str(results["Molecule<br>Tag"][i])) < 6 else str(results["Molecule<br>Tag"][i])
                        all_molecules[molecule] = {"Molecule Tag": molecule_tag,
                                                   "Linelist": results["Linelist"][i],
                                                   "Occurances": [freq]}
            else:
                if "Unknown" in all_molecules.keys():
                    all_molecules["Unknown"]["Occurances"].append(freq)
                else:
                    all_molecules["Unknown"] = {"Molecule Tag": "None",
                                                "Linelist": "None",
                                                "Occurances": [freq]}
        add_lines(id, molecules)
예제 #20
0
    def getLines(self,lower, upper, location):
        print("Downloading From "+ str(lower) + " to " + str(upper))
        lines = Splatalogue.query_lines_async(
            lower,
            upper,
            export=True,
            export_limit=999999999,
            line_strengths=('ls1', 'ls2', 'ls3', 'ls4', 'ls5'),
            displayHFS=True,
            show_unres_qn=True,
            show_upper_degeneracy=True,
            show_molecule_tag=True,
            show_qn_code=True,
            show_lovas_labref=True,
            show_lovas_obsref=True,
            show_orderedfreq_only=None,
            show_nrao_recommended=True
        )
        print("Downloadg From " + str(lower) + " to " + str(upper) + " Completed | ") + lines.content.split("\n")[1]
        Container[location] = lines.content

        return lines
예제 #21
0
    def get_full_frequency_intensity_list(full_name,
                                          min_freq,
                                          max_freq,
                                          line_list=[
                                              LineList.JPL, LineList.CDMS
                                          ]):
        columns = ('Species', 'Chemical Name', 'Freq-GHz', 'Meas Freq-GHz',
                   'CDMS/JPL Intensity', 'Lovas/AST Intensity', 'Linelist')

        rows = Splatalogue.query_lines(min_freq * u.MHz,
                                       max_freq * u.MHz,
                                       chemical_name=full_name,
                                       line_lists=line_list)[columns]
        frequencies = []
        intensities = []
        for row in rows:
            name, full_name, frequency, intensity, line_list = SplatalogueAnalysis.get_row_data(
                row)
            if min_freq < frequency < max_freq:
                frequencies.append(frequency * 1000)  # convert to MHz
                intensities.append(intensity)

        return frequencies, intensities
예제 #22
0
                limits=[(0, 1), (xmin.value, xmax.value), (0, 15)],
                limited=[(True, True)] * 3,
            )

            if doplot:
                slc.plotter.savefig(
                    paths.fpath(
                        'spectral_fits/{linename}_{band}_{spw}_{freq}.png'.
                        format(linename=linename,
                               band=band,
                               freq=freq,
                               spw=spw)))

            frq = u.Quantity(slc.specfit.parinfo['SHIFT0'], u.GHz)
            result = Splatalogue.query_lines(
                freq - (dv_linesearch) / constants.c * freq,
                freq + (dv_linesearch) / constants.c * freq,
                chemical_name=chem_re)
            for tbl in salt_tables:
                match = ((tbl['Freq'].quantity > freq -
                          (dv_linesearch) / constants.c * freq) &
                         (tbl['Freq'].quantity < freq +
                          (dv_linesearch) / constants.c * freq))
                result = tbl[match]
                #print(match.any())
                if match.any():
                    #print("Matched {0}".format(linename))
                    break

            #if len(result) > 0:
            #    result = mt(result)
            if len(result) >= 1:
import numpy as np
import line_to_image_list
from astropy import units as u
from astropy import constants
from astropy import log
import pylab as pl

from ch3oh_rotational_diagram_maps import nupper_of_kkms, fit_tex
from ch3oh_model import show_modelfit

from astroquery.splatalogue import Splatalogue, utils

slaim = Splatalogue.query_lines(218*u.GHz, 235*u.GHz, chemical_name=' CH3OH vt = 0 ',
                                energy_max=3500, energy_type='eu_k',
                                line_lists=['SLAIM'],
                                show_upper_degeneracy=True)
slaimfreqs = np.array(slaim['Freq-GHz'])*u.GHz

def fit_each_line_with_a_gaussian(spectra, ampguess, vguess_kms, widthguess,
                                  fixed_velo=False, fixed_width=False,
                                  wrange_GHz=(0,0.01), plot=False,
                                  separation_tolerance=0.005*u.GHz,
                                  fignum_start=1):
    assert spectra.unit == 'K'

    sp = spectra
    sp.plotter.plotkwargs = {}
    sp.xarr.convert_to_unit(u.GHz)
    # assume baselined already
    # sp.data -= np.nanpercentile(sp.data, 10)
    #sp.data *= beam.jtok(sp.xarr)
예제 #24
0
def search_molecule(species: str, freq_range=[0., 40e3], **kwargs):
    """
    Function to search Splatalogue for a specific molecule. Technically I'd prefer to
    download entries from CDMS instead, but this is probably the most straight
    forward way.

    The main use for this function is to verify line identifications - if a line is
    tentatively assigned to a U-line, then other transitions for the molecule that
    are stronger or comparatively strong should be visible.

    Parameters
    ----------
    species: str
        Chemical name of the molecule
    freq_range: list
        The frequency range to perform the lookup

    Returns
    -------
    DataFrame or None
        Pandas dataframe containing transitions for the given molecule. If no matches are found, returns None.
    """
    default_param = {
        "line_lists": ["CDMS", "JPL"],
        "export_limit": 20000
    }
    default_param.update(**kwargs)
    splat_df = Splatalogue.query_lines(
        min(freq_range) * u.MHz,
        max(freq_range) * u.MHz,
        chemical_name=species,
        **default_param
    ).to_pandas()
    if len(splat_df)> 0:
        # These are the columns wanted
        columns = [
            "Species",
            "Chemical Name",
            "Meas Freq-GHz(rest frame,redshifted)",
            "Freq-GHz(rest frame,redshifted)",
            "Resolved QNs",
            "CDMS/JPL Intensity",
            "E_U (K)"
        ]
        # Take only what we want
        splat_df = splat_df[columns]
        splat_df.columns = [
            "Species",
            "Chemical Name",
            "Meas Freq-GHz",
            "Freq-GHz",
            "Resolved QNs",
            "CDMS/JPL Intensity",
            "E_U (K)"
        ]
        # Now we combine the frequency measurements
        splat_df["Frequency"] = splat_df["Meas Freq-GHz"].values
        # Replace missing experimental data with calculated
        splat_df["Frequency"].fillna(splat_df["Freq-GHz"], inplace=True)
        # Convert to MHz
        splat_df["Frequency"] *= 1000.
        return splat_df
    else:
        return None
예제 #25
0
def line_ids(fn):
    results = []
    Ulines = []

    sp = pyspeckit.Spectrum(fn)

    # this is a bit hackier than I like
    # we'll do all our measurements in Kelvin!
    beams = Beams.from_fits_bintable(fits.open(fn)[1])
    factors = jtok_factors(beams, sp.xarr.to(u.GHz))
    sp.data = sp.data * factors
    sp.unit = u.K

    # want km/s - reference will be ~middle of SPW
    sp.xarr.convert_to_unit(u.km / u.s)

    med = np.nanmedian(sp.data)

    mad = stats.mad_std(sp.data - med)
    detections = (sp.data - med) > 5 * mad

    labels, ct = label(detections)

    for labelid in range(1, ct + 1):
        ssp = sp[labels == labelid]
        try:
            ssp.xarr.convert_to_unit(u.GHz)
            ssp.specfit()
            ssp.specfit.parinfo
            frq = ssp.specfit.parinfo['SHIFT0'].value * ssp.xarr.unit
        except Exception as ex:
            print(ex)
            frq = ssp.xarr.to(u.GHz).mean()
        sq = Splatalogue.query_lines(
            frq * (1 + 0 / 3e5),
            frq * (1 + 75 / 3e5),  # 30/3e5 original lower bound
            only_astronomically_observed=True)
        if len(sq) > 0:
            tbl = utils.minimize_table(sq)
            try:
                total_intensity = ssp.data.sum() * np.abs(
                    ssp.xarr.to(u.km / u.s).cdelt())
            except ValueError:
                total_intensity = ssp.data.sum() * np.abs(
                    sp.xarr.to(u.km / u.s).cdelt())
            peak_intensity = ssp.data.max()
            tbl.add_column(Column(data=total_intensity, name='TotalIntensity'))
            tbl.add_column(Column(data=peak_intensity, name='PeakIntensity'))
            tbl.add_column(Column(data=mad, name='RMS'))
            tbl.add_column(
                Column(data=u.Quantity((-(frq.to(u.GHz).value - tbl['Freq']) /
                                        tbl['Freq'] * constants.c),
                                       u.km / u.s),
                       name='Velocity'))
            #             print(tbl.pprint(max_width=200))
            results.append(tbl)
        else:
            log.warning(f"Frequency {frq.to(u.GHz)} had no hits")
            Ulines.append(frq)

    try:
        match_table = table.vstack(results)
    except ValueError:
        pass
    else:
        #         match_table.remove_column('QNs')
        match_table = table.unique(match_table, keys='Species')
    match_table.sort('Freq')
    print(match_table.pprint(max_width=200))
    print(match_table['Species', 'Freq', 'Velocity'])
    #     match_table.write(f"line_fit_table_{suffix}.ipac", format='ascii.ipac', overwrite=True)
    return match_table
예제 #26
0
    print('Corrected decreasing frequency axis')
else:
    pass

freq_min = freqs[0] * (1 + z)  #215*u.GHz
freq_max = freqs[(len(freqs) - 1)] * (1 + z)  #235*u.GHz

assert freq_max > freq_min, 'Decreasing frequency axis'

linewidth = 0.00485 * u.GHz  #Half of original 0.0097GHz
lw2 = linewidth / 4
'''Generate methanol table for contaminant search'''
methanol_table = Splatalogue.query_lines(freq_min,
                                         freq_max,
                                         chemical_name=' CH3OH ',
                                         energy_max=1840,
                                         energy_type='eu_k',
                                         line_lists=['JPL'],
                                         show_upper_degeneracy=True)

minmethtable = utils.minimize_table(methanol_table)

mlines = (minmethtable['Freq'] * 10**9) / (1 + z) * u.Hz
mqns = minmethtable['QNs']
meuks = minmethtable['EU_K'] * u.K
meujs = []
for euk in meuks:
    meujs.append(KtoJ(euk))
mdegs = methanol_table['Upper State Degeneracy']

testline = 8
import line_to_image_list
from astropy import table
from astroquery.splatalogue import Splatalogue
from astropy import units as u

tbl_list = []
tbl_dict = {}

for linename, freq, _, _ in line_to_image_list.line_to_image_list:
    frq = float(freq.strip("GHz"))*u.GHz

    tbl = Splatalogue.query_lines(frq*(1-0.25/3e5), frq*(1+0.25/3e5), line_lists=['SLAIM'], noHFS=True)
    if len(tbl) > 0:
        if len(tbl) > 1:
            print("Contaminants for {0}: ".format(linename))
            print(tbl)
            selected = tbl['E_U (K)'].argmin()
            tbl = tbl[selected:selected+1]
            print("Selected: ",tbl)
        col = tbl['Lovas/AST Intensity']
        if col.dtype.kind != 'U':
            col = col.astype(str)
            tbl.replace_column(col.name, col)
        tbl_list.append(tbl)
        tbl_dict[linename] = tbl

final_tbl = table.vstack(tbl_list)

final_tbl.write("full_line_table.csv", overwrite=True)
예제 #28
0
from astropy import units as u
from astroquery.splatalogue import Splatalogue

from config import conn
from tables import peaks_table

line_ids = Splatalogue.get_species_ids()

# --- Find species that have CO --- #
# CO_containing_species = Splatalogue.get_species_ids('CHS')
# print CO_containing_species

# -- Find Species within lines -- #
# CO1to0 = Splatalogue.query_lines(115.271 * u.GHz, 115.273 * u.GHz, top20='top20')
# CO1to0.pprint()
# row = CO1to0[0]
# print row[1]

mid = 142
threshold = 0.02
frequencies, intensities = peaks_table.get_frequency_intensity_list(conn, mid)


class Chemical:
    def __init__(self, name):
        self.name = name
        self.lines = []
        self.matched_lines = []
        self.N = 0

    def add_line(self, line, match):
}

pl.figure(1).clf()

for target, species_list in spectra_to_species.items():
    spectra = pyspeckit.Spectra(glob.glob(paths.spath("*{0}*fits".format(target))))

    for species_tuple in species_list:
        species_name, chemid, tmax = species_tuple

        for ii in range(4):
            cat = Splatalogue.query_lines(
                spectra[ii].xarr.min(),
                spectra[ii].xarr.max(),
                chemical_name=chemid,
                energy_max=tmax,
                energy_type="eu_k",
                noHFS=True,
                line_lists=["SLAIM"],
            )
            spectra[ii].plotter(figure=pl.figure(1))
            spectra[ii].plotter.axis.set_ylim(snu_min[target], spectra[ii].plotter.axis.get_ylim()[1])
            spectra[ii].plotter.line_ids(
                cat["Resolved QNs"],
                cat["Freq-GHz"] * u.GHz,
                velocity_offset=velo[target],
                plot_kwargs=plot_kwargs,
                annotate_kwargs=annotate_kwargs,
            )
            spectra[ii].plotter.savefig(
                paths.fpath(
예제 #30
0
for target in velo:
    files = glob.glob(
        paths.dpath("longbaseline/spectra/{0}*.fits".format(target)))
    for fn in files:
        sp = pyspeckit.Spectrum(fn)
        sp.xarr.convert_to_unit(u.GHz)
        print(fn, sp.xarr.min(), sp.xarr.max())

        fpre = os.path.splitext(os.path.split(fn)[-1])[0]

        species_names = [x[0] for x in line_to_image_list]
        frequencies = u.Quantity(
            [float(x[1].strip("GHz")) for x in line_to_image_list], unit=u.GHz)

        splat = Splatalogue.query_lines(sp.xarr.min(),
                                        sp.xarr.max(),
                                        chemical_name='NaCl|KCl',
                                        line_lists=['CDMS'])
        if len(splat) > 0:
            splat = utils.minimize_table(splat)
            species_names = [row['Species'] + row['QNs'] for row in splat]
            frequencies = u.Quantity(splat['Freq'], u.GHz)
        else:
            species_names = []
            frequencies = []

        sp.plotter(figure=pl.figure(1))
        sp.plotter(figure=pl.figure(1))

        outname = paths.dpath(
            'longbaseline/spectra/pngs/{target}_{0}.png'.format(fpre,
                                                                target=target))
import re
import numpy as np
from astropy import units as u
from astropy import constants
from astroquery.splatalogue import Splatalogue, utils

# Query splatalogue, keeping all of the line strength columns
# Both Lovas and CDMS/JPL can be used
nh3 = Splatalogue.query_lines(20 * u.GHz,
                              40 * u.GHz,
                              chemical_name=' NH3 ',
                              show_upper_degeneracy=True,
                              line_strengths=['ls1', 'ls2', 'ls3', 'ls4'])

numbers = {
    1: 'one',
    2: 'two',
    3: 'three',
    4: 'four',
    5: 'five',
    6: 'six',
    7: 'seven',
    8: 'eight',
    9: 'nine',
}

tbls = {}

for line in (1, 2, 3, 4, 5, 6, 7, 8, 9):

    reline = re.compile('^{n}\({n}\).*-{n}'.format(n=line))
def get_molecular_parameters(molecule_name,
                             molecule_name_vamdc=None,
                             tex=50,
                             fmin=1 * u.GHz,
                             fmax=1 * u.THz,
                             line_lists=['SLAIM'],
                             chem_re_flags=0,
                             **kwargs):
    """
    Get the molecular parameters for a molecule from the CDMS database using
    vamdclib

    Parameters
    ----------
    molecule_name : string
        The string name of the molecule (normal name, like CH3OH or CH3CH2OH)
    molecule_name_vamdc : string or None
        If specified, gives this name to vamdc instead of the normal name.
        Needed for some molecules, like CH3CH2OH -> C2H5OH.
    tex : float
        Optional excitation temperature (basically checks if the partition
        function calculator works)
    fmin : quantity with frequency units
    fmax : quantity with frequency units
        The minimum and maximum frequency to search over
    line_lists : list
        A list of Splatalogue line list catalogs to search.  Valid options
        include SLAIM, CDMS, JPL.  Only a single catalog should be used to
        avoid repetition of transitions and species
    chem_re_flags : int
        An integer flag to be passed to splatalogue's chemical name matching
        tool

    Examples
    --------
    >>> freqs, aij, deg, EU, partfunc = get_molecular_parameters(molecule_name='CH2CHCN',
    ...                                                          fmin=220*u.GHz,
    ...                                                          fmax=222*u.GHz,
    ...                                                          molecule_name_vamdc='C2H3CN')
    >>> freqs, aij, deg, EU, partfunc = get_molecular_parameters('CH3OH',
    ...                                                          fmin=90*u.GHz,
    ...                                                          fmax=100*u.GHz)
    """
    from astroquery.vamdc import load_species_table
    from astroquery.splatalogue import Splatalogue

    from vamdclib import nodes
    from vamdclib import request
    from vamdclib import specmodel

    lut = load_species_table.species_lookuptable()
    species_id_dict = lut.find(molecule_name_vamdc or molecule_name,
                               flags=chem_re_flags)
    if len(species_id_dict) == 1:
        species_id = list(species_id_dict.values())[0]
    elif len(species_id_dict) == 0:
        raise ValueError("No matches for {0}".format(molecule_name))
    else:
        raise ValueError(
            "Too many species matched: {0}".format(species_id_dict))

    # do this here, before trying to compute the partition function, because
    # this query could fail
    tbl = Splatalogue.query_lines(fmin,
                                  fmax,
                                  chemical_name=molecule_name,
                                  line_lists=line_lists,
                                  show_upper_degeneracy=True,
                                  **kwargs)

    nl = nodes.Nodelist()
    nl.findnode('cdms')
    cdms = nl.findnode('cdms')

    request = request.Request(node=cdms)
    query_string = "SELECT ALL WHERE VAMDCSpeciesID='%s'" % species_id
    request.setquery(query_string)
    result = request.dorequest()
    Q = list(
        specmodel.calculate_partitionfunction(result.data['States'],
                                              temperature=tex).values())[0]

    def partfunc(tem):
        Q = list(
            specmodel.calculate_partitionfunction(result.data['States'],
                                                  temperature=tem).values())[0]
        return Q

    freqs = np.array(tbl['Freq-GHz']) * u.GHz
    aij = tbl['Log<sub>10</sub> (A<sub>ij</sub>)']
    deg = tbl['Upper State Degeneracy']
    EU = (np.array(tbl['E_U (K)']) * u.K * constants.k_B).to(u.erg).value

    return freqs, aij, deg, EU, partfunc
}

pl.figure(1).clf()

for target, species_list in spectra_to_species.items():
    spectra = pyspeckit.Spectra(
        glob.glob(paths.spath("*{0}*fits".format(target))))

    for species_tuple in species_list:
        species_name, chemid, tmax = species_tuple

        for ii in range(4):
            cat = Splatalogue.query_lines(spectra[ii].xarr.min(),
                                          spectra[ii].xarr.max(),
                                          chemical_name=chemid,
                                          energy_max=tmax,
                                          energy_type='eu_k',
                                          noHFS=True,
                                          line_lists=['SLAIM'])
            spectra[ii].plotter(figure=pl.figure(1))
            spectra[ii].plotter.axis.set_ylim(
                snu_min[target], spectra[ii].plotter.axis.get_ylim()[1])
            spectra[ii].plotter.line_ids(cat['Resolved QNs'],
                                         cat['Freq-GHz'] * u.GHz,
                                         velocity_offset=velo[target],
                                         plot_kwargs=plot_kwargs,
                                         annotate_kwargs=annotate_kwargs)
            spectra[ii].plotter.savefig(paths.fpath(
                'line_id_spectra/{target}_{species_name}_{chemid}_spw{0}.png'.
                format(
                    ii,
        }
eupper = {'66': 409,
          '77': 539,
          '99': 853,
          '1010': 1037,
          '1313': 1693,
         }
degeneracy = {'66': 2*(2*6+1),
              '77': 1*(2*7+1),
              '99': 2*(2*9+1),
              '1010': 1*(2*10+1),
              '1313': 1*(2*13+1),
             }

nh3tables = {line:Splatalogue.query_lines(freqs[line]*0.99999,
                                          freqs[line]*1.00001,
                                          line_strengths=['ls1','ls2','ls3','ls4','ls5'],
                                          chemical_name=' NH3 ')
             for line in freqs}
linestrengths = {'66':float(nh3tables['66'][nh3tables['66']['Linelist']=='JPL']['S<sub>ij</sub>&#956;<sup>2</sup> (D<sup>2</sup>)'])*1e-18*u.esu*u.cm,
                 '77':float(nh3tables['77'][nh3tables['77']['Linelist']=='JPL']['S<sub>ij</sub>&#956;<sup>2</sup> (D<sup>2</sup>)'])*1e-18*u.esu*u.cm,
                 '99':float(nh3tables['99'][nh3tables['99']['Linelist']=='JPL']['S<sub>ij</sub>&#956;<sup>2</sup> (D<sup>2</sup>)'])*1e-18*u.esu*u.cm,
                 '1010':float(nh3tables['1010'][nh3tables['1010']['Linelist']=='JPL']['S<sub>ij</sub>&#956;<sup>2</sup> (D<sup>2</sup>)'])*1e-18*u.esu*u.cm,
                 '1313':float(nh3tables['1313'][nh3tables['1313']['Linelist']=='JPL']['S<sub>ij</sub>&#956;<sup>2</sup> (D<sup>2</sup>)'])*1e-18*u.esu*u.cm,
                }

FWHM = np.sqrt(8*np.log(2))

def tbl_vals(pi):
    """
    Compute the average amplitude, average width, and respective errors from the hyperfine fits
    """
예제 #35
0
def get_molecular_parameters(molecule_name,
                             molecule_name_vamdc=None,
                             tex=50, fmin=1*u.GHz, fmax=1*u.THz,
                             line_lists=['SLAIM'],
                             chem_re_flags=0, **kwargs):
    """
    Get the molecular parameters for a molecule from the CDMS database using
    vamdclib

    Parameters
    ----------
    molecule_name : string
        The string name of the molecule (normal name, like CH3OH or CH3CH2OH)
    molecule_name_vamdc : string or None
        If specified, gives this name to vamdc instead of the normal name.
        Needed for some molecules, like CH3CH2OH -> C2H5OH.
    tex : float
        Optional excitation temperature (basically checks if the partition
        function calculator works)
    fmin : quantity with frequency units
    fmax : quantity with frequency units
        The minimum and maximum frequency to search over
    line_lists : list
        A list of Splatalogue line list catalogs to search.  Valid options
        include SLAIM, CDMS, JPL.  Only a single catalog should be used to
        avoid repetition of transitions and species
    chem_re_flags : int
        An integer flag to be passed to splatalogue's chemical name matching
        tool

    Examples
    --------
    >>> freqs, aij, deg, EU, partfunc = get_molecular_parameters(molecule_name='CH2CHCN',
    ...                                                          fmin=220*u.GHz,
    ...                                                          fmax=222*u.GHz,
    ...                                                          molecule_name_vamdc='C2H3CN')
    >>> freqs, aij, deg, EU, partfunc = get_molecular_parameters('CH3OH',
    ...                                                          fmin=90*u.GHz,
    ...                                                          fmax=100*u.GHz)
    """
    from astroquery.vamdc import load_species_table
    from astroquery.splatalogue import Splatalogue

    from vamdclib import nodes
    from vamdclib import request
    from vamdclib import specmodel

    lut = load_species_table.species_lookuptable()
    species_id_dict = lut.find(molecule_name_vamdc or molecule_name,
                               flags=chem_re_flags)
    if len(species_id_dict) == 1:
        species_id = list(species_id_dict.values())[0]
    elif len(species_id_dict) == 0:
        raise ValueError("No matches for {0}".format(molecule_name))
    else:
        raise ValueError("Too many species matched: {0}"
                         .format(species_id_dict))

    # do this here, before trying to compute the partition function, because
    # this query could fail
    tbl = Splatalogue.query_lines(fmin, fmax, chemical_name=molecule_name,
                                  line_lists=line_lists,
                                  show_upper_degeneracy=True, **kwargs)

    nl = nodes.Nodelist()
    nl.findnode('cdms')
    cdms = nl.findnode('cdms')

    request = request.Request(node=cdms)
    query_string = "SELECT ALL WHERE VAMDCSpeciesID='%s'" % species_id
    request.setquery(query_string)
    result = request.dorequest()
    # run it once to test that it works
    Q = list(specmodel.calculate_partitionfunction(result.data['States'],
                                                   temperature=tex).values())[0]

    def partfunc(tem):
        Q = list(specmodel.calculate_partitionfunction(result.data['States'],
                                                       temperature=tem).values())[0]
        return Q


    freqs = (np.array(tbl['Freq-GHz'])*u.GHz if 'Freq-GHz' in tbl else
             np.array(tbl['Freq-GHz(rest frame,redshifted)'])*u.GHz)
    aij = tbl['Log<sub>10</sub> (A<sub>ij</sub>)']
    deg = tbl['Upper State Degeneracy']
    EU = (np.array(tbl['E_U (K)'])*u.K*constants.k_B).to(u.erg).value

    return freqs, aij, deg, EU, partfunc
from __future__ import print_function
import re
import numpy as np
from astropy import units as u
from astropy import constants
from astroquery.splatalogue import Splatalogue, utils

# Query splatalogue, keeping all of the line strength columns
# Both Lovas and CDMS/JPL can be used
nh3 = Splatalogue.query_lines(20*u.GHz, 40*u.GHz, chemical_name=' NH3 ',
                              show_upper_degeneracy=True,
                              line_strengths=['ls1','ls2','ls3','ls4'])

numbers = {1:'one',
           2:'two',
           3:'three',
           4:'four',
           5:'five',
           6:'six',
           7:'seven',
           8:'eight',
           9:'nine',}

tbls = {}


for line in (1,2,3,4,5,6,7,8,9):

    reline = re.compile('^{n}\({n}\).*-{n}'.format(n=line))

    tbl = utils.minimize_table(nh3[np.array([bool(reline.search(x))
예제 #37
0
from astropy import units as u
from astroquery.splatalogue import Splatalogue

name = "2,4-Pentadiynylidyne"

columns = ('Species', 'Chemical Name')

freq = 11935.48
# freq *= 1000
max_freq = 11936.0
min_freq = 11935.0

rows = Splatalogue.query_lines(min_freq * u.GHz,
                               max_freq * u.GHz,
                               chemical_name=name)

rows.pprint()
for row in rows:
    print str(row[0]) + "  " + str(row[2])
from astropy import units as u
from latex_info import latexdict
from astroquery.splatalogue import Splatalogue

from line_to_image_list import line_to_image_list, labeldict

for spwid in (0,1,2,3):
    label_col = Column(data=[labeldict[name] for name,_,_,spw in line_to_image_list
                             if spw==spwid],
                       name='Line Name')
    freq_col = Column(data=[float(freq.strip('GHz')) for _,freq,_,spw in line_to_image_list
                            if spw==spwid],
                      name='Frequency',
                      unit=u.GHz,)

    EU = [set(Splatalogue.query_lines(freq*(1-0.001/3e5),
                                      freq*(1+0.001/3e5))['E_U (K)'])
          for freq in u.Quantity(freq_col)]

    #spw_col = Column(data=[spw for _,_,_,spw in line_to_image_list
    #                       if spw==spwid],
    #                 name='Spectral Window',)

    tbl = Table([label_col, freq_col,])# spw_col])


    latexdict['header_start'] = '\label{{tab:linesspw{0}}}'.format(spwid)
    latexdict['caption'] = 'Spectral Lines in SPW {0}'.format(spwid)
    latexdict['tablefoot'] = ''
    #latexdict['tablefoot'] = ('\par\nJy-Kelvin gives the conversion factor from Jy '
    #                          'to Kelvin given the synthesized beam size and '
    #                          'observation frequency.')
        slc = sp.slice(xmin, xmax)
        if len(slc) == 0:
            continue

        guesses = [
            slc.data.max(), (freq * (1 + v / constants.c)).to(u.GHz).value,
            (2 * u.km / u.s / constants.c * freq).to(u.GHz).value
        ]
        #print(guesses)

        slc.specfit(guesses=guesses)
        #print(slc.specfit.parinfo)

        frq = u.Quantity(slc.specfit.parinfo['SHIFT0'], u.GHz)
        result = Splatalogue.query_lines(
            frq + (v - dv_linesearch) / constants.c * frq,
            frq + (v + dv_linesearch) / constants.c * frq)
        ref = np.array(result['Freq-GHz']) * u.GHz
        result.add_column(
            table.Column(name='velocity',
                         data=-((frq - ref) /
                                (ref) * constants.c).to(u.km / u.s)))
        linesearch = result['Species', 'Chemical Name', 'Resolved QNs',
                            'Freq-GHz', 'Meas Freq-GHz', 'velocity', 'E_U (K)']

        fits[linename] = {
            'pars':
            slc.specfit.parinfo,
            'vel':
            ((u.Quantity(slc.specfit.parinfo['SHIFT0'].value, u.GHz) - freq) /
             freq * constants.c.to(u.km / u.s)),
from pyspeckit.spectrum.models import model
from pyspeckit.spectrum.models import lte_molecule
from spectral_cube import SpectralCube
from astropy import units as u
from astropy import constants
from astropy import log
from astropy.io import fits
from astroquery.splatalogue import Splatalogue
from astropy import modeling

from vamdclib import nodes
from vamdclib import request as r
from vamdclib import specmodel as m
from vamdclib import specmodel

tbl = Splatalogue.query_lines(210*u.GHz, 235*u.GHz, chemical_name='CH3CN',
                              energy_max=1840, energy_type='eu_k')
freqs = np.unique(tbl['Freq-GHz'])
vdiff = (np.array((freqs-freqs[0])/freqs[0])*constants.c).to(u.km/u.s)
slaim = Splatalogue.query_lines(210*u.GHz, 235*u.GHz, chemical_name='CH3CN',
                                energy_max=1840, energy_type='eu_k',
                                line_lists=['SLAIM'],
                                show_upper_degeneracy=True)
freqs = np.array(slaim['Freq-GHz'])*u.GHz
aij = slaim['Log<sub>10</sub> (A<sub>ij</sub>)']
deg = slaim['Upper State Degeneracy']
EU = (np.array(slaim['E_U (K)'])*u.K*constants.k_B).to(u.erg).value
ref_freq = 220.74726*u.GHz
vdiff = (np.array(-(freqs-ref_freq)/ref_freq)*constants.c).to(u.km/u.s).value


예제 #41
0
from astropy import units as u
from astroquery.splatalogue import Splatalogue

from config import conn
from tables import peaks_table

line_ids = Splatalogue.get_species_ids()

# --- Find species that have CO --- #
# CO_containing_species = Splatalogue.get_species_ids('CHS')
# print CO_containing_species

# -- Find Species within lines -- #
# CO1to0 = Splatalogue.query_lines(115.271 * u.GHz, 115.273 * u.GHz, top20='top20')
# CO1to0.pprint()
# row = CO1to0[0]
# print row[1]

mid = 142
threshold = 0.02
frequencies, intensities = peaks_table.get_frequency_intensity_list(conn, mid)


class Chemical:
    def __init__(self, name):
        self.name = name
        self.lines = []
        self.matched_lines = []
        self.N = 0

    def add_line(self, line, match):
예제 #42
0
"""
import numpy as np
import pyspeckit
from pyspeckit.spectrum.models import model
from pyspeckit.spectrum.models import lte_molecule
from spectral_cube import SpectralCube
from astropy import units as u
from astropy import constants
from astropy.io import fits
from astroquery.splatalogue import Splatalogue, utils

from vamdclib import nodes
from vamdclib import request
from vamdclib import specmodel

tbl = Splatalogue.query_lines(210*u.GHz, 235*u.GHz, chemical_name=' HNCO ',
                              energy_max=2500, energy_type='eu_k')
freqs = np.unique(tbl['Freq-GHz'])
#vdiff = (np.array((freqs-freqs[0])/freqs[0])*constants.c).to(u.km/u.s)

# SLAIM is missing an important (10,5) transition
slaim = Splatalogue.query_lines(210*u.GHz, 235*u.GHz, chemical_name=' HNCO ',
                                energy_max=2500, energy_type='eu_k',
                                line_lists=['SLAIM'],
                                show_upper_degeneracy=True)
freqs = np.array(slaim['Freq-GHz'])*u.GHz
aij = slaim['Log<sub>10</sub> (A<sub>ij</sub>)']
deg = slaim['Upper State Degeneracy']
EU = (np.array(slaim['E_U (K)'])*u.K*constants.k_B).to(u.erg).value

cdmsplat_ = Splatalogue.query_lines(210*u.GHz, 235*u.GHz, chemical_name=' HNCO ',
                                    energy_max=2500, energy_type='eu_k',
예제 #43
0
from astroquery.splatalogue import Splatalogue
line_ids = Splatalogue.get_species_ids()
print line_ids
"""
import numpy as np
import pyspeckit
from pyspeckit.spectrum.models import model
from pyspeckit.spectrum.models import lte_molecule
from spectral_cube import SpectralCube
from astropy import units as u
from astropy import constants
from astropy.io import fits
from astroquery.splatalogue import Splatalogue, utils

from vamdclib import nodes
from vamdclib import request
from vamdclib import specmodel

tbl = Splatalogue.query_lines(210 * u.GHz, 235 * u.GHz, chemical_name=" HNCO ", energy_max=2500, energy_type="eu_k")
freqs = np.unique(tbl["Freq-GHz"])
# vdiff = (np.array((freqs-freqs[0])/freqs[0])*constants.c).to(u.km/u.s)

# SLAIM is missing an important (10,5) transition
slaim = Splatalogue.query_lines(
    210 * u.GHz,
    235 * u.GHz,
    chemical_name=" HNCO ",
    energy_max=2500,
    energy_type="eu_k",
    line_lists=["SLAIM"],
    show_upper_degeneracy=True,
)
freqs = np.array(slaim["Freq-GHz"]) * u.GHz
aij = slaim["Log<sub>10</sub> (A<sub>ij</sub>)"]
예제 #45
0
    freqs = cube.spectral_axis

    numchans = int(
        round(
            np.abs((linewidth.to('Hz')).value /
                   (freqs[1].value - freqs[0].value))))

    freq_max = freqs[np.argmin(freqs)] * (1 + z)  #215*u.GHz
    freq_min = freqs[np.argmax(freqs)] * (1 + z)  #235*u.GHz

    methanol_table = utils.minimize_table(
        Splatalogue.query_lines(freq_min,
                                freq_max,
                                chemical_name=' CH3OH ',
                                energy_max=1840,
                                energy_type='eu_k',
                                line_lists=[linelist],
                                show_upper_degeneracy=True))

    mlines = (methanol_table['Freq'] * 10**9) / (1 + z)
    mqns = methanol_table['QNs']

    temptable = Splatalogue.query_lines(freq_min,
                                        freq_max,
                                        chemical_name=chem,
                                        energy_max=1840,
                                        energy_type='eu_k',
                                        line_lists=[linelist],
                                        show_upper_degeneracy=True)
    if len(temptable) == 0:
예제 #46
0
from astropy import units as u
from latex_info import latexdict
from astroquery.splatalogue import Splatalogue

from line_to_image_list import line_to_image_list, labeldict

for spwid in (0,1,2,3):
    label_col = Column(data=[labeldict[name] for name,_,_,spw in line_to_image_list
                             if spw==spwid],
                       name='Line Name')
    freq_col = Column(data=[float(freq.strip('GHz')) for _,freq,_,spw in line_to_image_list
                            if spw==spwid],
                      name='Frequency',
                      unit=u.GHz,)

    EU = [set(Splatalogue.query_lines(freq*(1-0.001/3e5),
                                      freq*(1+0.001/3e5))['E_U (K)'])
          for freq in u.Quantity(freq_col)]

    #spw_col = Column(data=[spw for _,_,_,spw in line_to_image_list
    #                       if spw==spwid],
    #                 name='Spectral Window',)

    tbl = Table([label_col, freq_col,])# spw_col])


    latexdict['header_start'] = '\label{{tab:linesspw{0}}}'.format(spwid)
    latexdict['caption'] = 'Spectral Lines in SPW {0}'.format(spwid)
    latexdict['tablefoot'] = ''
    #latexdict['tablefoot'] = ('\par\nJy-Kelvin gives the conversion factor from Jy '
    #                          'to Kelvin given the synthesized beam size and '
    #                          'observation frequency.')
예제 #47
0
    pl.rcParams['font.size'] = 10
    pl.rcParams['axes.labelsize'] = 12
    pl.rcParams['axes.titlesize'] = 14
    major_labelsize = 10
    minor_labelsize = 8
elif filetype == 'pdf':
    annotation_fontsize = 8
    pl.rcParams['font.size'] = 14
    pl.rcParams['axes.labelsize'] = 14
    pl.rcParams['axes.titlesize'] = 14
    major_labelsize = 10
    minor_labelsize = 8

tbl = Splatalogue.query_lines(210 * u.GHz,
                              235 * u.GHz,
                              chemical_name=' CH3OH',
                              energy_max=1840,
                              energy_type='eu_k')
freqs = np.unique(tbl['Freq-GHz'])
#vdiff = (np.array((freqs-freqs[0])/freqs[0])*constants.c).to(u.km/u.s)
slaim = Splatalogue.query_lines(210 * u.GHz,
                                235 * u.GHz,
                                chemical_name=' CH3OH',
                                energy_max=1840,
                                energy_type='eu_k',
                                line_lists=['SLAIM'],
                                show_upper_degeneracy=True)
freqs = np.array(slaim['Freq-GHz']) * u.GHz
aij = slaim['Log<sub>10</sub> (A<sub>ij</sub>)']
deg = slaim['Upper State Degeneracy']
EU = (np.array(slaim['E_U (K)']) * u.K * constants.k_B).to(u.erg).value
예제 #48
0
    else:
        pass

    freq_min = freqs[0] * (1 + z)  #215*u.GHz
    freq_max = freqs[(len(freqs) - 1)] * (1 + z)  #235*u.GHz

    assert freq_max > freq_min, 'Decreasing frequency axis'

    #linewidth=0.00485*u.GHz#Half of original 0.0097GHz
    #lw2=linewidth/8
    originallinewidth = (11231152.36688232 * u.Hz / 2)
    '''Generate methanol table for use during contaminant search'''
    methanol_table = Splatalogue.query_lines(
        freq_min,
        freq_max,
        chemical_name=' CH3OH ',
        energy_max=1840,
        energy_type='eu_k',
        line_lists=['JPL', 'CDMS', 'SLAIM', 'ToyoMA', 'OSU', 'RFI', 'Lisa'],
        show_upper_degeneracy=True)
    minmethtable = utils.minimize_table(methanol_table)
    mlines = ((minmethtable['Freq'] * 10**9) / (1 + z) * u.Hz).to('MHz')
    mqns = minmethtable['QNs']
    meuks = minmethtable['EU_K'] * u.K
    meujs = []
    for euk in meuks:
        meujs.append(KtoJ(euk))
    mdegs = methanol_table['Upper State Degeneracy']
    mlog10aijs = minmethtable['log10_Aij']
    maijs = 10**mlog10aijs * u.s**-1
    '''Generate species table for contaminant search'''
    species_table = Splatalogue.query_lines(
            sp.data *= beam.jtok(sp.xarr)
            sp.unit='K'

        plot_whole_spectrum(speclist,
                            title=row['source'],
                            figname='fullspectra/{0}.png'.format(row['source']),
                            velocity=row['velocity']*u.km/u.s,
                           )


    # Methanol lines (for identification purposes - similar to ch3oh spectral
    # fit overlays...)
    from astroquery.splatalogue import Splatalogue
    Splatalogue.LINES_LIMIT=50000
    methanol_lines = Splatalogue.query_lines(218*u.GHz, 235*u.GHz,
                                             energy_max=3000,
                                             energy_type='eu_k',
                                             chemical_name='032.*Methanol')

    from generic_lte_molecule_model import LTEModel
    methanolmodel = LTEModel(chemical_name='032.*Methanol')
    # REQUIRES USING INTENSITY, not Aij
    methanolmodel_osu = LTEModel(chemical_name='032.*Methanol', line_lists=['OSU'],
                                 freq_type='Meas Freq-GHz', energy_max=500000)

    for row in myvtbl:

        speclist = [pyspeckit.Spectrum(fn) for fn in
                    glob.glob(paths.spath("{0}_spw*_peak.fits".format(row['source'])))]
        if len(speclist) == 0:
            continue
예제 #50
0
def get_molecular_parameters(molecule_name,
                             molecule_name_jpl=None,
                             tex=50,
                             fmin=1 * u.GHz,
                             fmax=1 * u.THz,
                             line_lists=['SLAIM'],
                             chem_re_flags=0,
                             **kwargs):
    """
    Get the molecular parameters for a molecule from the CDMS database using
    vamdclib

    Parameters
    ----------
    molecule_name : string
        The string name of the molecule (normal name, like CH3OH or CH3CH2OH)
    molecule_name_jpl : string or None
        Default to molecule_name, but if jplspec doesn't have your molecule
        by the right name, specify it here
    tex : float
        Optional excitation temperature (basically checks if the partition
        function calculator works)
    fmin : quantity with frequency units
    fmax : quantity with frequency units
        The minimum and maximum frequency to search over
    line_lists : list
        A list of Splatalogue line list catalogs to search.  Valid options
        include SLAIM, CDMS, JPL.  Only a single catalog should be used to
        avoid repetition of transitions and species
    chem_re_flags : int
        An integer flag to be passed to splatalogue's chemical name matching
        tool

    Examples
    --------
    >>> freqs, aij, deg, EU, partfunc = get_molecular_parameters(molecule_name='CH2CHCN',
    ...                                                          fmin=220*u.GHz,
    ...                                                          fmax=222*u.GHz,
                                                                )
    >>> freqs, aij, deg, EU, partfunc = get_molecular_parameters('CH3OH',
    ...                                                          fmin=90*u.GHz,
    ...                                                          fmax=100*u.GHz)
    """
    from astroquery.splatalogue import Splatalogue
    from astroquery.jplspec import JPLSpec

    # do this here, before trying to compute the partition function, because
    # this query could fail
    tbl = Splatalogue.query_lines(fmin,
                                  fmax,
                                  chemical_name=molecule_name,
                                  line_lists=line_lists,
                                  show_upper_degeneracy=True,
                                  **kwargs)

    if molecule_name_jpl is None:
        molecule_name_jpl = molecule_name

    jpltable = JPLSpec.get_species_table()[JPLSpec.get_species_table()['NAME']
                                           == molecule_name_jpl]
    if len(jpltable) != 1:
        raise ValueError(f"Too many or too few matches to {molecule_name_jpl}")

    def partfunc(tem):
        """
        interpolate the partition function
        WARNING: this can be very wrong
        """
        tem = u.Quantity(tem, u.K).value
        tems = np.array(jpltable.meta['Temperature (K)'])
        logQs = jpltable['QLOG1 QLOG2 QLOG3 QLOG4 QLOG5 QLOG6 QLOG7'.split()]
        logQs = np.array(list(logQs[0]))
        inds = np.argsort(tems)
        logQ = np.interp(tem, tems[inds], logQs[inds])
        return 10**logQ

    freqs = (np.array(tbl['Freq-GHz']) * u.GHz if 'Freq-GHz' in tbl.colnames
             else np.array(tbl['Freq-GHz(rest frame,redshifted)']) * u.GHz)
    aij = tbl['Log<sub>10</sub> (A<sub>ij</sub>)']
    deg = tbl['Upper State Degeneracy']
    EU = (np.array(tbl['E_U (K)']) * u.K * constants.k_B).to(u.erg).value

    return freqs, aij, deg, EU, partfunc
예제 #51
0
outfile = open('sio_column_estimate_results.txt', 'w')
sys.stdout = outfile

dw51 = 5.4 * u.kpc

warnings.filterwarnings(
    'ignore',
    message='This function (.*) requires loading the entire cube',
    append=True)
warnings.filterwarnings('ignore', message='All-NaN slice encountered')
warnings.filterwarnings('ignore',
                        message='invalid value encountered in true_divide')

tbl = Splatalogue.query_lines(210 * u.GHz,
                              235 * u.GHz,
                              chemical_name='SiO',
                              energy_max=1840,
                              energy_type='eu_k')
freqs = np.unique(tbl['Freq-GHz'])
vdiff = (np.array((freqs - freqs[0]) / freqs[0]) * constants.c).to(u.km / u.s)
slaim = Splatalogue.query_lines(
    210 * u.GHz,
    235 * u.GHz,
    chemical_name='SiO',
    energy_max=1840,
    energy_type='eu_k',
    line_lists=['SLAIM'],
    noHFS=True,  # there seems to be a problem where HFS
    # for K >= 6 is included *incorrectly*
    show_upper_degeneracy=True)
freqs = np.array(slaim['Freq-GHz']) * u.GHz
예제 #52
0
Simbad.add_votable_fields('rv_value')
m83simbad = Simbad.query_object('M83')
rvel = m83simbad['RV_VALUE'][0]*u.Unit(m83simbad['RV_VALUE'].unit)

for fn in m83files:
    if 'line' in fn:
        cube = SpectralCube.read(fn)
        # Convert frequencies to their rest frequencies
        frange = u.Quantity([cube.spectral_axis.min(),
                             cube.spectral_axis.max()]) * (1+rvel/constants.c)

        # Query the top 20 most common species in the frequency range of the
        # cube with an upper energy state <= 50K
        lines = Splatalogue.query_lines(frange[0], frange[1], top20='top20',
                                        energy_max=50, energy_type='eu_k',
                                        only_NRAO_recommended=True)
        lines.pprint()

        # Change the cube coordinate system to be in velocity with respect
        # to the rest frequency (in the M83 rest frame)
        rest_frequency = lines['Freq-GHz'][0]*u.GHz / (1+rvel/constants.c)
        vcube = cube.with_spectral_unit(u.km/u.s,
                                        rest_value=rest_frequency,
                                        velocity_convention='radio')

        # Write the cube with the specified line name
        fmt = "{Species}{Resolved QNs}"
        row = lines[0]
        linename = fmt.format(**dict(zip(row.colnames, row.data)))
        vcube.write('M83_ALMA_{linename}.fits'.format(linename=linename))