lightweaver 0.15.0__cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

lightweaver/collisional_rates.py

@@ -0,0 +1,337 @@
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Sequence, cast
+
+import astropy.units as u
+import numpy as np
+from numba import njit
+from scipy.special import exp1
+from weno4 import weno4
+
+import lightweaver.constants as Const
+from .utils import sequence_repr
+
+if TYPE_CHECKING:
+    from .atmosphere import Atmosphere
+    from .atomic_model import AtomicModel
+    from .atomic_set import SpeciesStateTable
+
+@dataclass
+class CollisionalRates:
+    '''
+    Base class for all CollisionalRates.
+    '''
+    j: int
+    i: int
+    atom: 'AtomicModel' = field(init=False)
+
+    def __repr__(self):
+        s = 'CollisionalRates(j=%d, i=%d)' % (self.j, self.i)
+        return s
+
+    def setup(self, atom):
+        pass
+
+    def compute_rates(self, atmos: 'Atmosphere', eqPops: 'SpeciesStateTable',
+                      Cmat: np.ndarray):
+        raise NotImplementedError
+
+    def __eq__(self, other: object) -> bool:
+        if other is self:
+            return True
+
+        return repr(self) == repr(other)
+
+
+@dataclass(eq=False)
+class TemperatureInterpolationRates(CollisionalRates):
+    '''
+    Base class for rates defined by interpolating a coefficient on a
+    temperature grid.
+    '''
+    temperature: Sequence[float]
+    rates: Sequence[float]
+    def __repr__(self):
+        s = '%s(j=%d, i=%d, temperature=%s, rates=%s)' % (type(self).__name__,
+                                                          self.j, self.i,
+                                                          sequence_repr(self.temperature),
+                                                          sequence_repr(self.rates))
+        return s
+
+    def setup(self, atom):
+        i, j = self.i, self.j
+        self.i = min(i, j)
+        self.j = max(i, j)
+        self.atom = atom
+        self.jLevel = atom.levels[self.j]
+        self.iLevel = atom.levels[self.i]
+        self.temperature = np.asarray(self.temperature)
+        self.rates = np.asarray(self.rates)
+
+@dataclass(eq=False, repr=False)
+class Omega(TemperatureInterpolationRates):
+    '''
+    Collisional (de-)excitation of ions by electrons (dimensionless).
+    Omega as in Seaton's collision strength.
+    Rate scales as 1/(sqrt(T)) exp(DeltaE).
+    '''
+    def setup(self, atom):
+        super().setup(atom)
+        self.C0 = (Const.ERydberg / np.sqrt(Const.MElectron) * np.pi *
+                   Const.RBohr**2 * np.sqrt(8.0 / (np.pi * Const.KBoltzmann)))
+
+    def compute_rates(self, atmos: 'Atmosphere', eqPops: 'SpeciesStateTable',
+                      Cmat: np.ndarray):
+        C = weno4(atmos.temperature, self.temperature, self.rates)
+        C[C < 0.0] = 0.0
+        nstar = eqPops.atomicPops[self.atom.element].nStar
+        Cdown = self.C0 * atmos.ne * C / (self.jLevel.g * np.sqrt(atmos.temperature))
+        Cmat[self.i, self.j, :] += Cdown
+        Cmat[self.j, self.i, :] += Cdown * nstar[self.j] / nstar[self.i]
+
+@dataclass(eq=False, repr=False)
+class CI(TemperatureInterpolationRates):
+    '''
+    Collisional ionisation by electrons.
+    Units: s^-1 K^-1/2 m^3
+    Rate scales as sqrt(T) exp(DeltaE)
+    '''
+    def setup(self, atom):
+        super().setup(atom)
+        self.dE = self.jLevel.E_SI - self.iLevel.E_SI
+
+    def compute_rates(self, atmos: 'Atmosphere', eqPops: 'SpeciesStateTable',
+                     Cmat: np.ndarray):
+        C = weno4(atmos.temperature, self.temperature, self.rates)
+        C[C < 0.0] = 0.0
+        nstar = eqPops.atomicPops[self.atom.element].nStar
+        Cup = (C * atmos.ne * np.exp(-self.dE / (Const.KBoltzmann * atmos.temperature))
+               * np.sqrt(atmos.temperature))
+        Cmat[self.j, self.i, :] += Cup
+        Cmat[self.i, self.j, :] += Cup * nstar[self.i] / nstar[self.j]
+
+
+@dataclass(eq=False, repr=False)
+class CE(TemperatureInterpolationRates):
+    '''
+    Collisional (de-)excitation of neutrals by electrons.
+    Units: s^-1 K^-1/2 m^3
+    Rate scales as sqrt(T) exp(DeltaE)
+    '''
+    def setup(self, atom):
+        super().setup(atom)
+        self.gij = self.iLevel.g / self.jLevel.g
+
+    def compute_rates(self, atmos: 'Atmosphere', eqPops: 'SpeciesStateTable',
+                      Cmat: np.ndarray):
+        C = weno4(atmos.temperature, self.temperature, self.rates)
+        C[C < 0.0] = 0.0
+        nstar = eqPops.atomicPops[self.atom.element].nStar
+        Cdown = C * atmos.ne * self.gij * np.sqrt(atmos.temperature)
+        Cmat[self.i, self.j, :] += Cdown
+        Cmat[self.j, self.i, :] += Cdown * nstar[self.j] / nstar[self.i]
+
+@dataclass(eq=False, repr=False)
+class CP(TemperatureInterpolationRates):
+    '''
+    Collisional (de-)excitation by protons.
+    Units: s^-1 m^3
+    '''
+    def compute_rates(self, atmos: 'Atmosphere', eqPops: 'SpeciesStateTable',
+                      Cmat: np.ndarray):
+        C = weno4(atmos.temperature, self.temperature, self.rates)
+        C[C < 0.0] = 0.0
+        nProton = eqPops['H'][-1, :]
+        Cdown = C * nProton
+        nstar = eqPops.atomicPops[self.atom.element].nStar
+        Cmat[self.i, self.j, :] += Cdown
+        Cmat[self.j, self.i, :] += Cdown * nstar[self.j] / nstar[self.i]
+
+@dataclass(eq=False, repr=False)
+class CH(TemperatureInterpolationRates):
+    '''
+    Collisions with neutral hydrogen.
+    Units: s^-1 m^3
+    '''
+    def compute_rates(self, atmos: 'Atmosphere', eqPops: 'SpeciesStateTable',
+                      Cmat: np.ndarray):
+        C = weno4(atmos.temperature, self.temperature, self.rates)
+        C[C < 0.0] = 0.0
+        nh0 = eqPops['H'][0, :]
+        Cup = C * nh0
+        nstar = eqPops.atomicPops[self.atom.element].nStar
+        Cmat[self.j, self.i, :] += Cup
+        Cmat[self.i, self.j, :] += Cup * nstar[self.i] / nstar[self.j]
+
+@dataclass(eq=False, repr=False)
+class ChargeExchangeNeutralH(TemperatureInterpolationRates):
+    '''
+    Charge exchange with neutral hydrogen.
+    Units: s^-1 m^3
+    Note: downward rate only.
+    '''
+    def compute_rates(self, atmos: 'Atmosphere', eqPops: 'SpeciesStateTable',
+                      Cmat: np.ndarray):
+        C = weno4(atmos.temperature, self.temperature, self.rates)
+        C[C < 0.0] = 0.0
+        nh0 = eqPops['H'][0, :]
+        Cdown = C * nh0
+        nstar = eqPops.atomicPops[self.atom.element].nStar
+        Cmat[self.i, self.j, :] += Cdown
+
+@dataclass(eq=False, repr=False)
+class ChargeExchangeProton(TemperatureInterpolationRates):
+    '''
+    Charge exchange with protons.
+    Units: s^-1 m^3
+    Note: upward rate only.
+    '''
+    def compute_rates(self, atmos: 'Atmosphere', eqPops: 'SpeciesStateTable',
+                      Cmat: np.ndarray):
+        C = weno4(atmos.temperature, self.temperature, self.rates)
+        C[C < 0.0] = 0.0
+        nProton = eqPops['H'][-1, :]
+        Cup = C * nProton
+        Cmat[self.j, self.i, :] += Cup
+
+def fone(x):
+    # return np.where(x <= 50.0, np.exp(x) * exp1(x), 1.0/x)
+    return np.where(x <= 50.0, np.exp(x) * exp1(x), (1.0 - 1.0 / x + 2.0 / x**2) / x)
+
+@njit(cache=True)
+def ftwo(x):
+    p = np.array((1.0000e+00, 2.1658e+02, 2.0336e+04, 1.0911e+06, 3.7114e+07,
+                  8.3963e+08, 1.2889e+10, 1.3449e+11, 9.4002e+11, 4.2571e+12,
+                  1.1743e+13, 1.7549e+13, 1.0806e+13, 4.9776e+11, 0.0000))
+    q = np.array((1.0000e+00, 2.1958e+02, 2.0984e+04, 1.1517e+06, 4.0349e+07,
+                  9.4900e+08, 1.5345e+10, 1.7182e+11, 1.3249e+12, 6.9071e+12,
+                  2.3531e+13, 4.9432e+13, 5.7760e+13, 3.0225e+13, 3.3641e+12))
+
+    def ftwo_impl(x):
+        if x > 4.0:
+            px = p[0]
+            xFact = 1.0
+            for i in range(1, 15):
+                xFact /= x
+                px += p[i] * xFact
+
+            qx = q[0]
+            xFact = 1.0
+            for i in range(1, 15):
+                xFact /= x
+                qx += q[i] * xFact
+
+            return px / (qx * x**2)
+
+        else:
+            gamma = 0.5772156649
+            f0x = np.pi**2 / 12.0
+            term = 1.0
+            count = 0.0
+            fact = 1.0
+            xFact = 1.0
+
+            while abs(term / f0x) > 1e-8:
+                count += 1.0
+                fact *= count
+                xFact *= -x
+                term = xFact / (count**2 * fact)
+                f0x += term
+
+                if count > 100.0:
+                    raise ValueError('ftwo too slow to converge')
+
+            y = np.exp(x) * ((np.log(x) + gamma)**2 * 0.5 + f0x)
+            return y
+
+    y = np.empty_like(x)
+    for i in range(x.shape[0]):
+        y[i] = ftwo_impl(x[i])
+
+    return y
+
+@dataclass
+class Ar85Cdi(CollisionalRates):
+    '''
+    Collisional ionisation rates based on Arnaud & Rothenflug (1985, ApJS 60).
+    Units remain in CGS as per paper.
+    '''
+    cdi: Sequence[Sequence[float]]
+
+    def __repr__(self):
+        s = 'Ar85Cdi(j=%d, i=%d, cdi=%s)' % (self.j, self.i, sequence_repr(self.cdi))
+        return s
+
+    def setup(self, atom):
+        i, j = self.i, self.j
+        self.i = min(i, j)
+        self.j = max(i, j)
+        self.atom = atom
+        self.iLevel = atom.levels[self.i]
+        self.jLevel = atom.levels[self.j]
+        self.cdi = np.array(self.cdi)
+
+    def compute_rates(self, atmos: 'Atmosphere', eqPops: 'SpeciesStateTable',
+                      Cmat: np.ndarray):
+        nstar = eqPops.atomicPops[self.atom.element].nStar
+        Cup = np.zeros(atmos.Nspace)
+        cdi = cast(np.ndarray, self.cdi)
+        for m in range(cdi.shape[0]):
+            xj = cdi[m, 0] * Const.EV / (Const.KBoltzmann * atmos.temperature)
+            fac = np.exp(-xj) * np.sqrt(xj)
+            fxj = (cdi[m, 1] + cdi[m, 2] * (1.0 + xj)
+                   + (cdi[m, 3] - xj * (cdi[m, 1] + cdi[m, 2] * (2.0 + xj)))
+                   * fone(xj) + cdi[m, 4] * xj * ftwo(xj))
+
+            fxj *= fac
+            fac = 6.69e-7 / cdi[m, 0]**1.5
+            Cup += fac * (fxj << u.Unit('cm3')).to('m3').value
+        Cup[Cup < 0] = 0.0
+
+        Cup *= atmos.ne
+        Cdown = Cup * nstar[self.i] / nstar[self.j]
+        Cmat[self.i, self.j, :] += Cdown
+        Cmat[self.j, self.i, :] += Cup
+
+
+@dataclass
+class Burgess(CollisionalRates):
+    '''
+    Collisional ionisation from excited states from Burgess & Chidichimo
+    (1983, MNRAS 203, 1269).
+    Fudge parameter is dimensionless.
+    '''
+    fudge: float = 1.0
+
+    def __repr__(self):
+        s = 'Burgess(j=%d, i=%d, fudge=%g)' % (self.j, self.i, self.fudge)
+        return s
+
+    def setup(self, atom):
+        i, j = self.i, self.j
+        self.i = min(i, j)
+        self.j = max(i, j)
+        self.atom = atom
+        self.iLevel = atom.levels[self.i]
+        self.jLevel = atom.levels[self.j]
+
+    def compute_rates(self, atmos: 'Atmosphere', eqPops: 'SpeciesStateTable',
+                      Cmat: np.ndarray):
+        nstar = eqPops.atomicPops[self.atom.element].nStar
+        dE = (self.jLevel.E_SI - self.iLevel.E_SI) / Const.EV
+        zz = self.iLevel.stage
+        betaB = 0.25 * (np.sqrt((100.0 * zz + 91.0) / (4.0 * zz + 3.0)) - 5.0)
+        cbar = 2.3
+
+        dEkT = dE * Const.EV / (Const.KBoltzmann * atmos.temperature)
+        dEkT = np.minimum(dEkT, 500)
+        invdEkT = 1.0 / dEkT
+        wlog = np.log(1.0 + invdEkT)
+        wb = wlog**(betaB / (1.0 + invdEkT))
+        Cup = (2.1715e-8 * cbar * (13.6/dE)**1.5 * np.sqrt(dEkT)
+               * exp1(dEkT) * wb * (atmos.ne << u.Unit('m-3')).to('cm-3').value)
+
+        Cup *= self.fudge
+        Cdown = Cup * nstar[self.i, :] / nstar[self.j, :]
+
+        Cmat[self.j, self.i, :] += Cup
+        Cmat[self.i, self.j, :] += Cdown

lightweaver/config.py

@@ -0,0 +1,106 @@
+import warnings
+from copy import copy
+from os import path
+from typing import List, Optional
+
+import astropy.config as conf
+import yaml
+from lightweaver.simd_management import (LwSimdImplsAndFlags,
+                                         get_available_simd_suffixes)
+
+Defaults = {
+    'FormalSolver1d': 'piecewise_bezier3_1d',
+    'FormalSolver2d': 'piecewise_besser_2d',
+    'IterationScheme': 'mali_full_precond',
+    'SimdImpl': 'scalar',
+}
+
+params = copy(Defaults)
+
+def get_home_config_path() -> str:
+    '''
+    Return the location where the user's configuration data *should* be stored,
+    whether it is currently present or not.
+    '''
+    confDir = conf.get_config_dir('lightweaver')
+    homePath = path.join(confDir, 'lightweaverrc')
+    return homePath
+
+
+def get_config_path() -> Optional[str]:
+    '''
+    Returns the path to the `lightweaverrc` configuration file, or None if one
+    cannot be found.
+    '''
+    localPath = 'lightweaverrc'
+    if path.isfile(localPath):
+        return localPath
+    homePath = get_home_config_path()
+    if path.isfile(homePath):
+        return homePath
+
+    return None
+
+
+def set_most_advanced_simd_impl():
+    '''
+    Picks the most advanced SIMD extensions (as detected by NumPy), that can be
+    used on this system. This does not guarantee fastest (see the note in
+    `update_config_dict`).
+    '''
+    availableImpls = get_available_simd_suffixes()
+
+    def check_add_impl(simdType):
+        if simdType in availableImpls:
+            params['SimdImpl'] = simdType
+
+    for impl in LwSimdImplsAndFlags:
+        check_add_impl(impl)
+
+
+def update_config_dict(configPath: Optional[str]):
+    '''
+    Updates the configuration dict (`lightweaver.ConfigDict`), from the config
+    file. If there is no config file, the defaults are used, and the most
+    advanced instruction set is chosen for the SimdImpl. If the SimdImpl in the
+    config file is too advanced for the current CPU, the maximum available is
+    chosen.
+
+    Parameters
+    ----------
+    configPath :  str, optional
+        The path to the config file, or None.
+    '''
+    if configPath is None:
+        warnings.warn('No config file found, using defaults. For optimised vectorised code,'
+                      ' please run `lightweaver.benchmark()`, otherwise the most advanced'
+                      ' instruction set supported by your machine will be picked, which may'
+                      ' not be the fastest (due to e.g. aggressive AVX offsets).')
+        set_most_advanced_simd_impl()
+        return
+
+    with open(configPath, 'r') as f:
+        confDict = yaml.safe_load(f)
+    params.update(confDict)
+
+    availableSimd : List[str] = get_available_simd_suffixes()
+    if params['SimdImpl'] not in ['scalar'] + availableSimd:
+        set_most_advanced_simd_impl()
+        warnings.warn('SimdImpl was set to an overly advanced instruction set for the '
+                      'current CPU, setting to the maximum supported by your CPU.')
+
+
+def update_config_file(configPath: str):
+    '''
+    Updates the config file to the current values of the config dict.
+
+    Parameters
+    ----------
+    configPath : str
+        The path to the config file.
+    '''
+    with open(configPath, 'w') as f:
+        yaml.safe_dump(params, f)
+
+
+update_config_dict(get_config_path())

lightweaver/constants.py

@@ -0,0 +1,22 @@
+
+CLight = 2.99792458E+08     # Speed of light [m/s]      */
+HPlanck = 6.6260755E-34     # Planck's constant [Js]    */
+HC = HPlanck * CLight
+HC_CM = HC * 1e2            # HC with c in cm/s, for wavenumbers as cm-1
+KBoltzmann = 1.380658E-23   # Boltzman's constant [J/K] */
+Amu = 1.6605402E-27         # Atomic mass unit [kg]     */
+MElectron = 9.1093897E-31  # Electron mass [kg]        */
+QElectron = 1.60217733E-19 # Electron charge [C]       */
+Epsilon0 = 8.854187817E-12 # Vacuum permittivity [F/m] */
+Mu0 = 1.2566370614E-06     # Magnetic induct. of vac.  */
+RBohr = 5.29177349E-11      # Bohr radius [m]           */
+ERydberg = 2.1798741E-18   # Ion. pot. Hydrogen [J]    */
+EV = 1.60217733E-19         # One electronVolt [J]      */
+Theta0 = 5.03974756E+03     # log10(e) * eV/k [K^-1]    */
+ABarH = 7.42E-41            # polarizability of Hydrogen [Fm^2]
+E_ION_HMIN = 0.754*EV
+
+NM_TO_M = 1.0E-09
+
+VMICRO_CHAR=3.0e3
+B_CHAR=0.0 #TESLA

lightweaver/crtaf.py

@@ -0,0 +1,197 @@
+import warnings
+
+import astropy.units as u
+import crtaf
+from fractions import Fraction
+
+from lightweaver.atomic_model import AtomicModel, AtomicLevel, LineType, LinearQuadrature, TabulatedQuadrature, LinearCoreExpWings, VoigtLine, HydrogenicContinuum, ExplicitContinuum
+from lightweaver.broadening import LineBroadening, RadiativeBroadening, HydrogenLinearStarkBroadening, MultiplicativeStarkBroadening, QuadraticStarkBroadening, VdwUnsold, ScaledExponentBroadening
+from lightweaver.collisional_rates import Omega, CE, CI, CH, CP, ChargeExchangeProton, ChargeExchangeNeutralH
+from lightweaver.atomic_table import PeriodicTable
+
+def from_crtaf(model: crtaf.Atom) -> AtomicModel:
+    crtaf_labels = []
+    levels = {}
+    for label, level in model.levels.items():
+        crtaf_labels.append(label)
+        J = None
+        if level.J is not None:
+            J = Fraction(level.J.numerator, level.J.denominator)
+        L = None
+        if level.L is not None:
+            L = level.L
+        S = None
+        if level.S is not None:
+            S = Fraction(level.S.numerator, level.S.denominator)
+        lw_level = AtomicLevel(
+            E=level.energy.to("cm-1", equivalencies=u.spectral()).value.item(),
+            g=level.g,
+            label=level.label if level.label is not None else "",
+            stage=level.stage-1,
+            J=J,
+            L=L,
+            S=S,
+        )
+        levels[label] = lw_level
+
+    crtaf_labels = sorted(crtaf_labels, key=lambda x: levels[x].E)
+    levels = [levels[l] for l in crtaf_labels]
+    level_conversion_dict = {label: idx for idx, label in enumerate(crtaf_labels)}
+
+    lines = []
+    for line in model.lines:
+        if not isinstance(line, crtaf.VoigtBoundBound):
+            raise ValueError(f"Unexpected line type encountered {line!r}, can only handle Voigt/PRD-Voigt.")
+
+        ty = LineType.CRD
+        if isinstance(line, crtaf.PrdVoigtBoundBound):
+            ty = LineType.PRD
+
+        natural_broadening = []
+        elastic_broadening = []
+        for b in line.broadening:
+            if isinstance(b, crtaf.NaturalBroadening):
+                natural_broadening.append(RadiativeBroadening(b.value.to("s-1").value))
+            elif isinstance(b, crtaf.StarkLinearSutton):
+                elastic_broadening.append(HydrogenLinearStarkBroadening())
+            elif isinstance(b, crtaf.StarkMultiplicative):
+                elastic_broadening.append(MultiplicativeStarkBroadening(b.C_4.value))
+            elif isinstance(b, crtaf.StarkQuadratic):
+                elastic_broadening.append(QuadraticStarkBroadening(b.scaling))
+            elif isinstance(b, crtaf.VdWUnsold):
+                elastic_broadening.append(VdwUnsold(vals=[b.H_scaling, b.He_scaling]))
+            elif isinstance(b, crtaf.ScaledExponents):
+                lw_b = ScaledExponentBroadening(
+                    scaling=b.scaling,
+                    temperatureExp=b.temperature_exponent,
+                    hydrogenExp=b.hydrogen_exponent,
+                    electronExp=b.electron_exponent,
+                )
+                if b.elastic:
+                    elastic_broadening.append(lw_b)
+                else:
+                    natural_broadening.append(lw_b)
+            else:
+                raise ValueError(f"Unexpected broadening ({b}), can only handle core CRTAF types.")
+        broadening = LineBroadening(natural=natural_broadening, elastic=elastic_broadening)
+
+        q = line.wavelength_grid
+        if isinstance(q, crtaf.LinearGrid):
+            grid = LinearQuadrature(
+                Nlambda=q.n_lambda,
+                deltaLambda=q.delta_lambda.to(u.nm).value.item(),
+            )
+        elif isinstance(q, crtaf.TabulatedGrid):
+            grid = TabulatedQuadrature(
+                wavelengthGrid=q.wavelengths.to(u.nm).value.tolist(),
+            )
+        elif isinstance(q, crtaf.LinearCoreExpWings):
+            grid = LinearCoreExpWings(
+                qCore=q.q_core,
+                qWing=q.q_wing,
+                Nlambda=q.n_lambda,
+            )
+        else:
+            raise ValueError(f"Unexpected WavelengthGrid ({q}), can only handle core CRTAF types and LinearCoreExpWings.")
+
+        lw_line = VoigtLine(
+            j=level_conversion_dict[line.transition[0]],
+            i=level_conversion_dict[line.transition[1]],
+            f=line.f_value,
+            type=ty,
+            quadrature=grid,
+            broadening=broadening,
+        )
+        lines.append(lw_line)
+
+
+    continua = []
+    for cont in model.continua:
+        if isinstance(cont, crtaf.HydrogenicBoundFree):
+            lw_cont = HydrogenicContinuum(
+                j=level_conversion_dict[cont.transition[0]],
+                i=level_conversion_dict[cont.transition[1]],
+                NlambdaGen=cont.n_lambda,
+                alpha0=cont.sigma_peak.to("m2").value,
+                minWavelength=cont.lambda_min.to(u.nm).value,
+            )
+        elif isinstance(cont, crtaf.TabulatedBoundFree):
+            lw_cont = ExplicitContinuum(
+                j=level_conversion_dict[cont.transition[0]],
+                i=level_conversion_dict[cont.transition[1]],
+                wavelengthGrid=cont.wavelengths.to(u.nm).value,
+                alphaGrid=cont.sigma.to("m2").value,
+            )
+        else:
+            raise ValueError(f"Unexpected continuum ({cont}), can only handle Hydrogenic and Tabulated.")
+        continua.append(lw_cont)
+
+    collisions = []
+    for coll in model.collisions:
+        j = level_conversion_dict[coll.transition[0]]
+        i = level_conversion_dict[coll.transition[1]]
+        for process in coll.data:
+            if isinstance(process, crtaf.OmegaRate):
+                lw_coll = Omega(
+                    j=j,
+                    i=i,
+                    temperature=process.temperature.to(u.K).value.tolist(),
+                    rates=process.data.value.tolist(),
+                )
+            elif isinstance(process, crtaf.CIRate):
+                lw_coll = CI(
+                    j=j,
+                    i=i,
+                    temperature=process.temperature.to(u.K).value.tolist(),
+                    rates=process.data.to("m3 s-1 K(-1/2)").value.tolist(),
+                )
+            elif isinstance(process, crtaf.CERate):
+                lw_coll = CE(
+                    j=j,
+                    i=i,
+                    temperature=process.temperature.to(u.K).value.tolist(),
+                    rates=process.data.to("m3 s-1 K(-1/2)").value.tolist(),
+                )
+            elif isinstance(process, crtaf.CHRate):
+                lw_coll = CH(
+                    j=j,
+                    i=i,
+                    temperature=process.temperature.to(u.K).value.tolist(),
+                    rates=process.data.to("m3 s-1").value.tolist(),
+                )
+            elif isinstance(process, crtaf.CPRate):
+                lw_coll = CP(
+                    j=j,
+                    i=i,
+                    temperature=process.temperature.to(u.K).value.tolist(),
+                    rates=process.data.to("m3 s-1").value.tolist(),
+                )
+            elif isinstance(process, crtaf.ChargeExcHRate):
+                lw_coll = ChargeExchangeNeutralH(
+                    j=j,
+                    i=i,
+                    temperature=process.temperature.to(u.K).value.tolist(),
+                    rates=process.data.to("m3 s-1").value.tolist(),
+                )
+            elif isinstance(process, crtaf.ChargeExcPRate):
+                lw_coll = ChargeExchangeProton(
+                    j=j,
+                    i=i,
+                    temperature=process.temperature.to(u.K).value.tolist(),
+                    rates=process.data.to("m3 s-1").value.tolist(),
+                )
+            else:
+                raise ValueError(f"Unexpected collisional rate encountered ({coll}), expected one of [Omega, CI, CE, CH, CP, ChargeExcH, ChargeExcP].")
+            collisions.append(lw_coll)
+
+    if model.element.N is not None:
+        warnings.warn("N provided. Whilst Lightweaver has the ability to handle isotopes, the CRTAF parser currently does not.")
+    lw_model = AtomicModel(
+        element=PeriodicTable[model.element.symbol],
+        levels=levels,
+        lines=lines,
+        continua=continua,
+        collisions=collisions,
+    )
+    return lw_model
+