owlspec 0.1__tar.gz

owlspec-0.1/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.1
+Name: owlspec
+Version: 0.1
+Summary: Library for optical emission spectroscopy of low-temperature plasmas.
+Home-page: https://github.com/mimurrayy/owl
+Author: Julian Held
+Author-email: julian.held@umn.edu
+License: MIT
+Platform: any
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# owl
+  
+Library to calculate optical emission line shapes.
+
+## Usage
+The library has currently three main classes: 
+
+- spectrometer
+- transition
+- emission_line
+
+## Example
+```python
+#!/bin/python3
+import matplotlib.pyplot as plt
+import numpy as np
+
+import sys
+import os.path
+home = os.path.expanduser('~')
+sys.path.append(home + '/.local/lib/')
+import owl
+
+cw = central_wavelength = 453.37
+x = np.linspace(cw-0.1, cw+0.1, 1000)
+
+transition1 = owl.emitter.transition("Ti I", 453.324)
+transition2 = owl.emitter.transition("Ti II", 453.396)
+
+line1 = owl.emission_line(transition1,453.337,B=0.5)
+line2 = owl.emission_line(transition2,453.410,B=0.5)
+
+y1 = line1.get_profile(x, A=1, T=5000)
+y2 = line2.get_profile(x, A=1, T=5000)
+
+plt.plot(x,y1)
+plt.plot(x,y2)
+```    

owlspec-0.1/README.md

@@ -0,0 +1,38 @@
+# owl
+  
+Library to calculate optical emission line shapes.
+
+## Usage
+The library has currently three main classes: 
+
+- spectrometer
+- transition
+- emission_line
+
+## Example
+```python
+#!/bin/python3
+import matplotlib.pyplot as plt
+import numpy as np
+
+import sys
+import os.path
+home = os.path.expanduser('~')
+sys.path.append(home + '/.local/lib/')
+import owl
+
+cw = central_wavelength = 453.37
+x = np.linspace(cw-0.1, cw+0.1, 1000)
+
+transition1 = owl.emitter.transition("Ti I", 453.324)
+transition2 = owl.emitter.transition("Ti II", 453.396)
+
+line1 = owl.emission_line(transition1,453.337,B=0.5)
+line2 = owl.emission_line(transition2,453.410,B=0.5)
+
+y1 = line1.get_profile(x, A=1, T=5000)
+y2 = line2.get_profile(x, A=1, T=5000)
+
+plt.plot(x,y1)
+plt.plot(x,y2)
+```    

owlspec-0.1/owlspec/__init__.py

@@ -0,0 +1,11 @@
+#!/usr/bin/python
+from . import emitter
+from . import spectrometer
+from .util import *
+from .emission_line import *
+from .spectrum import *
+from .stark import gigosos_loader, gigosos_he_loader
+
+def download_stark_tables(redownload=False):
+    gigosos_loader.download_profiles(redownload)
+    gigosos_he_loader.download_profiles(redownload)

owlspec-0.1/owlspec/emission_line.py

@@ -0,0 +1,158 @@
+#!/bin/python3
+import numpy as np
+from scipy.signal import fftconvolve as convolve
+from scipy import constants as const
+from scipy import interpolate
+#from . import emitter
+from .util import zeeman, parse_spectroscopic_name, doppler_thompson,\
+                                    doppler_maxwell, interpol, gauss_function
+from . import stark
+from . import vdW
+import mendeleev 
+
+class emission_line():
+    def __init__(self, transition, wl, spectrometer = None,
+    T = None, Eb = None, gamma = None, B = None, ne = None, Te = None,
+    side=False, N = None, pert = None):
+        """ T in K, Eb,Te in eV, ne in m^-3, N in m^-3"""
+        self.wl = wl
+        self.transition = transition
+        particle = transition.particle
+        self.m  = particle.m
+        self.Ei = particle.Ei
+        self.T  = T
+        self.Eb = Eb
+        self.gamma = gamma
+        self.B  = B
+        self.ne = ne
+        self.Te = Te
+        self.N  = N
+        self.pert = pert
+        self.spectrometer = spectrometer
+        self.side = side # symmetric version of Thompson?
+        self.last_profiles = []
+
+        if pert:          
+            self.pert_name, self.pert_charge = parse_spectroscopic_name(pert)
+            self.pert = mendeleev.element(self.pert_name)
+            self.pert.charge = self.pert_charge
+            self.pert.m = self.pert.mass
+            self.pert.Ei = self.pert.ionenergies[1]
+            if T:
+                self.pert.T = T
+            elif Te:
+                self.pert.T = Te*const.eV/const.k
+
+
+
+    def get_profile(self, x, A = 1,
+            shift = False, wl=None, T = None, Eb = None, gamma = None, B = None,
+            N = None, ne = None, Te = None, pert = None):
+
+        if wl == None and self.wl:
+            wl = self.wl
+        if T == None and self.T:
+            T = self.T
+        if Eb == None and self.Eb:
+            Eb = self.Eb
+        if gamma == None and self.gamma:
+            gamma = self.gamma
+        if B == None and self.B:
+            B = self.B
+        if ne == None and self.ne:
+            ne = self.ne
+        if Te == None and self.Te:
+            Te = self.Te
+        if N == None and self.N:
+            N = self.N
+        if pert == None and self.pert:
+            pert = self.pert
+        
+        elif pert:
+            self.pert_name, self.pert_charge = parse_spectroscopic_name(pert)
+            self.pert = mendeleev.element(self.pert_name)
+            self.pert.charge = self.pert_charge
+            self.pert.m = self.pert.mass
+            self.pert.Ei = self.pert.ionenergies[1]
+            if T:
+                self.pert.T = T
+            elif Te:
+                self.pert.T = Te*const.eV/const.k
+            pert = self.pert
+
+
+        self.last_profiles = []
+        orig_x = x
+        s = 0 # lineshift in nm
+        try:
+            x = self.spectrometer.fine_x
+            if len(orig_x)<1024:
+                x = x[x>orig_x[0]]
+                x = x[x<orig_x[-1]]
+        except:
+            x = x
+
+        resolution = abs((x[-1]-x[0])/(len(x)-1))
+
+        middle_wl = x[int(len(x)/2)-1]
+        components = []
+
+        if T:
+            if Eb and gamma:
+                thompson = doppler_thompson(x, middle_wl, Eb, self.m, self.side)
+                maxwell = doppler_maxwell(x, middle_wl, T, self.m)
+                doppler = gamma*maxwell + (1-gamma)*thompson
+                self.last_profiles.append(gamma*maxwell)
+                self.last_profiles.append((1-gamma)*thompson)
+                self.last_profiles.append(doppler)
+                components.append(doppler)
+            else:
+                maxwell = doppler_maxwell(x, middle_wl, T, self.m)
+                self.last_profiles.append(maxwell)
+                components.append(maxwell)
+        if Eb and not T:
+            thompson = doppler_thompson(x, middle_wl, Eb, self.m, self.side)
+            self.last_profiles.append(thompson)
+            components.append(thompson)
+        if B:
+            t = self.transition
+            zeeman_pattern = zeeman(x, middle_wl, B, t.upperJ, t.lowerJ, t.upperG, t.lowerG)/resolution
+            self.last_profiles.append(zeeman_pattern)
+            components.append(zeeman_pattern)
+        if ne:
+            this_stark = stark.stark(self.transition)
+            stark_profile = this_stark.get_profile(x, ne, Te, pert)
+            self.last_profiles.append(stark_profile)
+            components.append(stark_profile)
+        if N:
+            this_vdW = vdW.vdW(self.transition, pert=pert)
+            vdW_profile = this_vdW.get_profile(x, T, N)
+            self.last_profiles.append(vdW_profile)
+            components.append(vdW_profile)
+            if shift:
+                s = s + this_vdW.get_shift(x, N, T)
+
+        # We let the instrumental profile determine center position.
+        # ALL other components are shifted to the middle!
+        if self.spectrometer:
+            instrumental_profile = self.spectrometer.instrument_function(x, wl+s, self.transition)
+            instrumental_profile = instrumental_profile/resolution/1024
+        else:
+            instrumental_profile = gauss_function(x, wl+s, x[0]-x[1])
+
+        profile = instrumental_profile
+        for component in components:
+            profile = convolve(profile, component, mode='same') * resolution
+        y = A*profile
+        self.last_profiles.append(y)
+        lowres_y = interpol(x, y, orig_x)
+        self.last_profiles.append(lowres_y)
+        # normalize intensity to A
+        y = A*lowres_y/np.sum(lowres_y)/resolution
+        return y
+
+
+    def get_instrumental_profile(self, x, wl=None):
+        if wl == None and self.wl:
+            wl = self.wl
+        return self.spectrometer.instrument_function(x, wl, self.transition)

owlspec-0.1/owlspec/emitter/__init__.py

@@ -0,0 +1,3 @@
+#!/usr/bin/python
+from .transition import *
+from .level import *

owlspec-0.1/owlspec/emitter/level.py

@@ -0,0 +1,139 @@
+#!/usr/bin/python
+
+import os
+import re
+from ..util import parse_spectroscopic_name
+import numpy as np
+import mendeleev 
+from astroquery.nist import Nist
+from ..nist_levels import NistLevels
+import astropy.units as u
+
+class level():
+    def __init__(self, emitter_name, energy, debug=False):
+        self.name, self.charge = parse_spectroscopic_name(emitter_name)
+        self.spec_name = emitter_name
+        self.emitter = self.particle = mendeleev.element(self.name)
+        self.emitter.charge = self.charge
+        self.emitter.m = self.emitter.mass
+        self.emitter.Ei = self.emitter.ionenergies[1]
+        self.charge = self.emitter.charge
+        
+        nist_levels = NistLevels.query(linename=emitter_name)
+
+        # clean up the energy column from NIST levels (e.g. remove '[')
+        non_decimal = re.compile(r'[^\d.]+')
+        level_energies = []
+
+        for entry in nist_levels['Level (eV)']:
+            this_entry = non_decimal.sub('', str(entry))
+            try: 
+                this_entry = float(this_entry)
+            except:
+                this_entry = np.nan
+            level_energies.append(this_entry)
+        level_energies = np.array(level_energies, dtype=float)
+
+        # select upper and lower energy levels
+        level_idx = np.argmin((np.nan_to_num(level_energies)-energy)**2)
+        row = nist_levels[level_idx]
+        
+        self.E = level_energies[level_idx] # Energy in eV
+        try:
+            self.J = float(eval(row['J'])) # Angular momentum, can be 5/2 or so...
+        except:
+            self.J = np.nan
+        
+        try:
+            conf_end = row['Configuration'].split('.')
+            if "(" in conf_end[-1]:
+                conf_end.pop()
+            self.l = int(self.l_name_to_num(conf_end[-1][1]))
+        except:
+            self.l = np.nan
+        
+        self.g = float(nist_levels[level_idx]['g']) # statistical weight
+        self.conf = row['Configuration'] # configuration and term string
+        
+        if 'Landé' in nist_levels.keys():
+            self.G = nist_levels[level_idx]['Landé'] #Lande g factor
+        else:
+            self.G = None
+        
+
+
+    def l_name_to_num(self, name):
+        chars = ["s","p","d","f","g","h","i","j"]
+        num = chars.index(name)
+        return num
+    
+    
+    def get_transitions(self, kind="all", debug=False):
+        """Return the transition objects that belong to the energy level
+        Type is a string and may be "from", "to" or "all", to select transitions
+        from the level, to the level or both."""
+        from .transition import transition # needed to avoid circular import
+
+        # clean up the wl column from NIST levels (e.g. remove '[') below
+        non_decimal = re.compile(r'[^\d.]+')
+
+        # Load data tables from NIST (+- 1 nm around requested wl)
+        nist_lines = Nist.query(1*u.nm, 99999*u.nm, 
+                                linename=self.spec_name, wavelength_type='vac+air')
+
+        transitions_to = []
+        transitions_from = []
+        transitions_all = []
+
+        for entry in nist_lines:
+            if not np.ma.is_masked(entry['Ei           Ek']) \
+                                    and not (np.ma.is_masked(entry['Observed']) and np.ma.is_masked(entry['Ritz']) ):
+                
+                if '-' in entry['Ei           Ek']:
+                    upperE = float(entry['Ei           Ek'].split('-')[1]) # Energy in eV
+                    lowerE = float(entry['Ei           Ek'].split('-')[0])
+                    if upperE == self.E:
+                        try:
+                            wl = float(entry['Observed'])
+                        except:
+                            try:
+                                wl = float(non_decimal.sub('', str(entry['Ritz'])))
+                            except:
+                                break
+                        if not np.isnan(wl):
+                            this_transition = transition(self.spec_name, wl, wl_type="either")
+                            transitions_from.append(this_transition)                    
+                            transitions_all.append(this_transition)
+                    
+                    if lowerE == self.E:
+                        try:
+                            wl = float(entry['Observed'])
+                            if np.isnan(wl):
+                                wl = float(non_decimal.sub('', str(entry['Ritz'])))
+                        except:
+                            try:
+                                wl = float(non_decimal.sub('', str(entry['Ritz'])))
+                            except:
+                                break
+                        if not np.isnan(wl):
+                            this_transition = transition(self.spec_name, wl, wl_type="either")
+                            transitions_to.append(this_transition)                    
+                            transitions_all.append(this_transition)
+
+        if kind=="all":
+            return transitions_all
+        if kind=="from":
+            return transitions_from        
+        if kind=="to":
+            return transitions_to
+        
+        return None
+
+
+    def get_lifetime(self, debug=False):
+        Aiks = []
+        for transition in self.get_transitions(kind="from", debug=debug):
+            if transition.Aik:
+                Aiks.append(transition.Aik)
+        sum_Aik = np.sum(Aiks)
+        return 1/sum_Aik

owlspec-0.1/owlspec/emitter/transition.py

@@ -0,0 +1,108 @@
+#!/usr/bin/python
+
+import os
+import numpy as np
+import re
+from ..util import parse_spectroscopic_name, get_spectroscopic_name
+from .level import level
+import mendeleev 
+from astroquery.nist import Nist
+import astropy.units as u
+
+class transition():
+    def __init__(self, emitter_name, wavelength, wl_type="Observed", debug=False):
+        """Return the closest transition for the specified emitter to the
+        specified wavelength.
+        emitter_name in spectroscopic notation, e.g. O I or Ar II
+        wl_type can be "Observed" or "Ritz" or "either"
+        
+        Returns a transition object with entries: upperE, lowerE, upperl, 
+        lowerl, upperg, lowerg, Aik, wl and the upper 
+        and lower levels of the transition: upper_level/lower_level."""
+        
+        self.name, self.charge = parse_spectroscopic_name(emitter_name)
+        self.spec_name = get_spectroscopic_name(self.name, self.charge)
+        self.emitter = self.particle = mendeleev.element(self.name)
+        self.emitter.charge = self.charge
+        self.emitter.m = self.emitter.mass
+        self.emitter.Ei = self.emitter.ionenergies[1]
+        self.charge = self.emitter.charge
+        # clean up the wl column from NIST levels (e.g. remove '[') below
+        non_decimal = re.compile(r'[^\d.]+')
+                
+        # Load data tables from NIST (+- 1 nm around requested wl)
+        nist_lines = Nist.query((wavelength-1)*u.nm, (wavelength+1)*u.nm, 
+                                linename=self.spec_name, wavelength_type='vac+air')
+        
+        # select closest line
+        if wl_type == "Observed":
+            line_idx = np.argmin((nist_lines['Observed']-wavelength)**2)
+            self.wl = nist_lines['Observed'][line_idx]
+
+        if wl_type == "Ritz":   
+            wls = []
+            for this_wl in nist_lines['Ritz']:
+                try:
+                    wls.append(float(non_decimal.sub('', str(this_wl))))
+                except:
+                    wls.append(0.0)
+            line_idx = np.argmin((wls-wavelength)**2)
+            self.wl = wls[line_idx]
+
+        if wl_type == "either":
+            wls = []
+            for this_wl in nist_lines['Ritz']:
+                try:
+                    wls.append(float(non_decimal.sub('', str(this_wl))))
+                except:
+                    wls.append(0.0)
+            this_wl = np.max((np.array(nist_lines['Observed'], dtype=float), wls), axis=0)
+            line_idx = np.argmin((this_wl-wavelength)**2)
+            self.wl = this_wl[line_idx]
+
+
+        row = nist_lines[line_idx]
+        
+        self.upperE = row['Ei           Ek'].split('-')[1]
+        self.upperE = float(non_decimal.sub('', str(self.upperE)))
+        self.lowerE = row['Ei           Ek'].split('-')[0]
+        self.lowerE = float(non_decimal.sub('', str(self.lowerE)))
+        # self.upperJ = row['Upper level'].split('|')[-1] # Angular momentum
+        # self.lowerJ = row['Lower level'].split('|')[-1]
+        
+        upper_conf_end = row['Upper level'].split('|')[0].split('.')
+        if "(" in upper_conf_end[-1]:
+            upper_conf_end.pop()
+        lower_conf_end = row['Lower level'].split('|')[0].split('.')
+        if "(" in lower_conf_end[-1]:
+            lower_conf_end.pop()
+        try:
+            self.upperl = self.l_name_to_num(upper_conf_end[-1][1])
+            self.lowerl = self.l_name_to_num(lower_conf_end[-1][1]) 
+        except:
+            self.upperl = None
+            self.lowerl = None
+        
+        self.Aik    = row['Aki']
+        self.upperg = float(row['gi   gk'].split('-')[1])
+        self.lowerg = float(row['gi   gk'].split('-')[0])
+        
+
+        self.upper_level, self.lower_level = self.levels()
+        self.upper, self.lower = self.upper_level, self.lower_level
+
+    def l_name_to_num(self, name):
+        chars = ["s","p","d","f","g","h","i","j"]
+        num = chars.index(name)
+        return num
+
+    def levels(self):
+        upper_level = level(self.spec_name, self.upperE)
+        lower_level = level(self.spec_name, self.lowerE)
+        self.upperJ = upper_level.J
+        self.upperG = upper_level.G
+        self.lowerJ = lower_level.J
+        self.lowerG = lower_level.G
+        return upper_level, lower_level
+
+    

owlspec-0.1/owlspec/nist_levels/__init__.py

@@ -0,0 +1,26 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+"""
+Fetches level information from the NIST Atomic Spectra Database.
+"""
+from astropy import config as _config
+
+
+class Conf(_config.ConfigNamespace):
+    """
+    Configuration parameters for `astroquery.nist_levels`.
+    """
+    server = _config.ConfigItem(
+        ['https://physics.nist.gov/cgi-bin/ASD/energy1.pl'],
+        'Name of the NIST URL to query.')
+    timeout = _config.ConfigItem(
+        30,
+        'Time limit for connecting to NIST server.')
+
+
+conf = Conf()
+
+from .core import NistLevels, NistLevelsClass
+
+__all__ = ['NistLevels', 'NistLevelsClass',
+           'Conf', 'conf',
+           ]

owlspec-0.1/owlspec/nist_levels/core.py

@@ -0,0 +1,151 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+
+import html
+import re
+
+import astropy.io.ascii as asciitable
+
+from astroquery.query import BaseQuery
+from astroquery.utils import async_to_sync, prepend_docstr_nosections
+from . import conf
+from astroquery.exceptions import TableParseError
+
+__all__ = ['NistLevels', 'NistLevelsClass']
+
+
+def _strip_blanks(table):
+    """
+    Remove blank lines from table (included for "human readability" but
+    useless to us...
+    returns a single string joined by \n newlines
+
+    Parameters
+    ----------
+    table : str
+       table to strip as a string
+
+    Returns
+    -------
+    single string joined by newlines.
+    """
+    numbersletters = re.compile("[0-9A-Za-z]")
+    if isinstance(table, str):
+        table = table.split('\n')
+    table = [line for line in table if numbersletters.search(line)]
+    return "\n".join(table)
+
+
+@async_to_sync
+class NistLevelsClass(BaseQuery):
+    URL = conf.server
+    TIMEOUT = conf.timeout
+    unit_code = {'Angstrom': 0,
+                 'nm': 1,
+                 'um': 2}
+    energy_level_code = {'cm-1': 0, 'invcm': 0, 'cm': 0,
+                         'ev': 1, 'eV': 1, 'EV': 1, 'electronvolt': 1,
+                         'R': 2, 'Rydberg': 2, 'rydberg': 2}
+
+    def _args_to_payload(self, *args, **kwargs):
+        """
+        Serves the same purpose as `~NistClass.query` but returns
+        the raw HTTP response rather than a `~astropy.table.Table` object.
+
+        Parameters
+        ----------
+        linename : str, optional
+            The spectrum to fetch. Defaults to "H I"
+        energy_level_unit : str, optional
+            The energy level units must be one of the following:
+            'R', 'Rydberg', 'rydberg', 'cm', 'cm-1', 'EV', 'eV',
+            'electronvolt', 'ev', 'invcm' Defaults to 'eV'.
+        get_query_payload : bool, optional
+            If true then returns the dictionary of query parameters, posted to
+            remote server. Defaults to `False`.
+
+        Returns
+        -------
+        request_payload : dict
+            The dictionary of parameters sent with the HTTP request
+
+        """
+        request_payload = {}
+        linename = kwargs["linename"]
+        request_payload["de"] = 0
+        request_payload["spectrum"] = linename
+        request_payload["submit"] = "Retrieve Data"
+        request_payload["units"] = NistLevels.energy_level_code[
+            kwargs["energy_level_unit"]]
+        request_payload["format"] = 1  # ascii
+        request_payload["output"] = 0  # entirely rather than pagewise
+        request_payload["page_size"] = 15
+        request_payload["multiplet_ordered"] = 0
+        request_payload["conf_out"] = "on"
+        request_payload["term_out"] = "on"
+        request_payload["level_out"] = "on"
+        request_payload["unc_out"] = "on"
+        request_payload["j_out"] = "on"
+        request_payload["g_out"] = "on"
+        request_payload["lande_out"] = "on"
+        request_payload["perc_out"] = "on"
+        request_payload["biblio"] = "on"
+        request_payload["splitting"] = 1
+        return request_payload
+
+    @prepend_docstr_nosections("\n" + _args_to_payload.__doc__)
+    def query_async(self, linename="H I", energy_level_unit='eV', get_query_payload=False):
+        """
+        Returns
+        -------
+        response : `requests.Response` object
+            The response of the HTTP request.
+        """
+        request_payload = self._args_to_payload(
+            linename=linename,
+            energy_level_unit=energy_level_unit)
+        if get_query_payload:
+            return request_payload
+
+        response = self._request("GET", url=NistLevels.URL, params=request_payload,
+                                 timeout=NistLevels.TIMEOUT)
+        return response
+
+    def _parse_result(self, response, *, verbose=False):
+        """
+        Parses the results from the HTTP response to `astropy.table.Table`.
+
+        Parameters
+        ----------
+        response : `requests.Response`
+            The HTTP response object
+
+        Returns
+        -------
+        table : `astropy.table.Table`
+        """
+
+        pre_re = re.compile("<PRE>(.*)</PRE>", flags=re.DOTALL)
+        links_re = re.compile(r"<\/?a(.|\n)*?>")
+        content = str(response.text)
+
+        try:
+            pre = pre_re.findall(content)[0]
+        except IndexError:
+            raise Exception("Result did not contain a table")
+        try:
+            table = _strip_blanks(pre)
+            table = links_re.sub(r'\1', table)
+            table = html.unescape(table)
+            table = asciitable.read(table, Reader=asciitable.FixedWidth,
+                                    data_start=1, delimiter='|')
+            return table
+        except Exception as ex:
+            self.response = response
+            self.table_parse_error = ex
+            raise TableParseError("Failed to parse asciitable! The raw "
+                                  "response can be found in self.response, "
+                                  "and the error in self.table_parse_error.")
+
+
+NistLevels = NistLevelsClass()