Exemplo n.º 1
0
def species_lookuptable(cache=True):
    """
    Get a lookuptable from chemical name + OrdinaryStructuralFormula to VAMDC
    id
    """

    if not os.path.exists(Conf.cache_location):
        os.makedirs(Conf.cache_location)

    lut_path = os.path.join(Conf.cache_location, 'species_lookuptable.json')
    if os.path.exists(lut_path) and cache:
        log.info("Loading cached molecular line ID database")
        with open(lut_path, 'r') as fh:
            lutdict = json.load(fh)
        lookuptable = SpeciesLookuptable(lutdict)
    else:
        log.info("Loading molecular line ID database")

        from vamdclib import nodes as vnodes
        from vamdclib import request as vrequest

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

        request = vrequest.Request(node=cdms)

        # Retrieve all species from CDMS
        result = request.getspecies()
        molecules = result.data['Molecules']

        lutdict = {
            "{0} {1}".format(molecules[key].ChemicalName,
                             molecules[key].OrdinaryStructuralFormula):
            molecules[key].VAMDCSpeciesID
            for key in molecules
        }
        lookuptable = SpeciesLookuptable(lutdict)
        if cache:
            with open(lut_path, 'w') as fh:
                json.dump(lookuptable, fh)

    return lookuptable
Exemplo n.º 2
0
    def __init__(self, doimport=True):
        super(VamdcClass, self).__init__()

        if not doimport:
            # this is a hack to allow the docstrings to be produced without
            # importing the necessary modules
            return

        from vamdclib import nodes as vnodes
        from vamdclib import request as vrequest
        from vamdclib import results as vresults
        from vamdclib import specmodel

        self._vnodes = vnodes
        self._vrequest = vrequest
        self._vresults = vresults

        self._nl = vnodes.Nodelist()
        self._cdms = self._nl.findnode('cdms')

        self.specmodel = specmodel
Exemplo n.º 3
0
    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
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 = 217.10498 * u.GHz
vdiff = (np.array(-(freqs - ref_freq) / ref_freq) * constants.c).to(u.km /
                                                                    u.s).value

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

request = r.Request(node=cdms)

# Retrieve all species from CDMS
result = request.getspecies()
molecules = result.data['Molecules']

sio = [
    x for x in molecules.values() if (x.StoichiometricFormula) == ('OSi') and (
        x.OrdinaryStructuralFormula == 'SiO')
][0]

sio_inchikey = sio.InChIKey
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