minplascalc 1.0.1__tar.gz → 1.0.2__tar.gz

{minplascalc-1.0.1 → minplascalc-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minplascalc
-Version: 1.0.1
+Version: 1.0.2
 Summary: A simple set of tools for doing calculations of thermal plasma compositions relevant to metallurgical problems using Python 3
 Project-URL: Homepage, https://github.com/quinnreynolds/minplascalc
 Author-email: Quinn Reynolds <quinnr@mintek.co.za>
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Chemistry
 Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: >=3.11
+Requires-Dist: numba
 Requires-Dist: numpy
 Requires-Dist: scipy
 Description-Content-Type: text/x-rst
@@ -42,7 +43,7 @@ What is this repository for?
 * You're here because you want to calculate plasma compositions,
   thermodynamics, and physical and radiative properties. This package will
   do most of those things for LTE plasmas, to varying degrees of fidelity.
-* Version `v1.0.1 <https://github.com/quinnreynolds/minplascalc/releases/latest>`_.
+* Version `v1.0.2 <https://github.com/quinnreynolds/minplascalc/releases/latest>`_.
 
 
 Quick start

{minplascalc-1.0.1 → minplascalc-1.0.2}/README.rst

@@ -20,7 +20,7 @@ What is this repository for?
 * You're here because you want to calculate plasma compositions,
   thermodynamics, and physical and radiative properties. This package will
   do most of those things for LTE plasmas, to varying degrees of fidelity.
-* Version `v1.0.1 <https://github.com/quinnreynolds/minplascalc/releases/latest>`_.
+* Version `v1.0.2 <https://github.com/quinnreynolds/minplascalc/releases/latest>`_.
 
 
 Quick start

{minplascalc-1.0.1 → minplascalc-1.0.2}/minplascalc/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.0.1"
+__version__ = "1.0.2"
 
 from . import mixture, parsers, species
 

{minplascalc-1.0.1 → minplascalc-1.0.2}/minplascalc/data/species/C++.json

@@ -4212,7 +4212,7 @@
         ]
     ],
     "ionisation_energy": 7.672470887440893e-18,
-    "energylevels": [
+    "energy_levels": [
         [
             0.0,
             0.0

{minplascalc-1.0.1 → minplascalc-1.0.2}/minplascalc/data/species/C+.json

@@ -7172,7 +7172,7 @@
         ]
     ],
     "ionisation_energy": 3.90683772578823e-18,
-    "energylevels": [
+    "energy_levels": [
         [
             0.5,
             0.0

{minplascalc-1.0.1 → minplascalc-1.0.2}/minplascalc/data/species/C.json

@@ -8052,7 +8052,7 @@
         ]
     ],
     "ionisation_energy": 1.8040996647411364e-18,
-    "energylevels": [
+    "energy_levels": [
         [
             0.0,
             0.0

{minplascalc-1.0.1 → minplascalc-1.0.2}/minplascalc/data/species/O++.json

@@ -4822,7 +4822,7 @@
         ]
     ],
     "ionisation_energy": 8.801646544933729e-18,
-    "energylevels": [
+    "energy_levels": [
         [
             0.0,
             0.0

{minplascalc-1.0.1 → minplascalc-1.0.2}/minplascalc/data/species/O+.json

@@ -4297,7 +4297,7 @@
         ]
     ],
     "ionisation_energy": 5.627024923581859e-18,
-    "energylevels": [
+    "energy_levels": [
         [
             1.5,
             0.0

{minplascalc-1.0.1 → minplascalc-1.0.2}/minplascalc/data/species/O-.json

@@ -11,7 +11,7 @@
     "electron_cross_section": null,
     "emission_lines": [],
     "ionisation_energy": 2.340780062274e-19,
-    "energylevels": [
+    "energy_levels": [
         [
             0.5,
             0

{minplascalc-1.0.1 → minplascalc-1.0.2}/minplascalc/data/species/O.json

@@ -597,7 +597,7 @@
         ]
     ],
     "ionisation_energy": 2.1818536569480278e-18,
-    "energylevels": [
+    "energy_levels": [
         [
             2.0,
             0.0

{minplascalc-1.0.1 → minplascalc-1.0.2}/minplascalc/data/species/Si++.json

@@ -5222,7 +5222,7 @@
         ]
     ],
     "ionisation_energy": 5.3661727129011726e-18,
-    "energylevels": [
+    "energy_levels": [
         [
             0.0,
             0.0

{minplascalc-1.0.1 → minplascalc-1.0.2}/minplascalc/data/species/Si+.json

@@ -2132,7 +2132,7 @@
         ]
     ],
     "ionisation_energy": 2.6188941386449313e-18,
-    "energylevels": [
+    "energy_levels": [
         [
             0.5,
             0.0

{minplascalc-1.0.1 → minplascalc-1.0.2}/minplascalc/data/species/Si.json

@@ -2982,7 +2982,7 @@
         ]
     ],
     "ionisation_energy": 1.3060440877960931e-18,
-    "energylevels": [
+    "energy_levels": [
         [
             0.0,
             0.0

{minplascalc-1.0.1 → minplascalc-1.0.2}/minplascalc/functions_transport.py

@@ -3,8 +3,10 @@
 from typing import TYPE_CHECKING
 
 import numpy as np
-from scipy import constants  # type: ignore
-from scipy.special import gamma  # type: ignore
+import scipy.linalg as scl  # type: ignore[import-untyped]
+from numba import njit  # type: ignore[import-untyped]
+from scipy import constants  # type: ignore[import-untyped]
+from scipy.special import gamma  # type: ignore[import-untyped]
 
 from minplascalc import units as u
 
@@ -1076,6 +1078,7 @@ def sum2(s: int) -> float:
     return np.sum(1 / np.arange(1, s + 2) ** 2)
 
 
+@njit
 def delta(i: int, j: int) -> int:
     """Kronecker delta.
 
@@ -1715,6 +1718,124 @@ def q(mixture: "LTE") -> np.ndarray:
     Q35 = Qij_mix(mixture, 3, 5)
     Q44 = Qij_mix(mixture, 4, 4)
 
+    q00 = _q00_jit(Q11, masses, nb_species, number_densities)
+
+    q01 = _q01_jit(Q11, Q12, masses, nb_species, number_densities)
+
+    q11 = _q11_jit(Q11, Q12, Q13, Q22, masses, nb_species, number_densities)
+
+    q02 = _q02_jit(Q11, Q12, Q13, masses, nb_species, number_densities)
+
+    q12 = _q12_jit(
+        Q11, Q12, Q13, Q14, Q22, Q23, masses, nb_species, number_densities
+    )
+
+    q22 = _q22_jit(
+        Q11,
+        Q12,
+        Q13,
+        Q14,
+        Q15,
+        Q22,
+        Q23,
+        Q24,
+        Q33,
+        masses,
+        nb_species,
+        number_densities,
+    )
+
+    q03 = _q03_jit(Q11, Q12, Q13, Q14, masses, nb_species, number_densities)
+
+    q13 = _q13_jit(
+        Q11,
+        Q12,
+        Q13,
+        Q14,
+        Q15,
+        Q22,
+        Q23,
+        Q24,
+        masses,
+        nb_species,
+        number_densities,
+    )
+
+    q23 = _q23_jit(
+        Q11,
+        Q12,
+        Q13,
+        Q14,
+        Q15,
+        Q16,
+        Q22,
+        Q23,
+        Q24,
+        Q25,
+        Q33,
+        Q34,
+        masses,
+        nb_species,
+        number_densities,
+    )
+
+    q33 = _q33_jit(
+        Q11,
+        Q12,
+        Q13,
+        Q14,
+        Q15,
+        Q16,
+        Q17,
+        Q22,
+        Q23,
+        Q24,
+        Q25,
+        Q26,
+        Q33,
+        Q34,
+        Q35,
+        Q44,
+        masses,
+        nb_species,
+        number_densities,
+    )
+
+    mass_ratio = masses[np.newaxis, :] / masses[:, np.newaxis]
+
+    # Equation A5 of [Devoto1966]_.
+    q10 = mass_ratio * q01
+
+    # Equation A8 of [Devoto1966]_.
+    q20 = mass_ratio**2 * q02
+
+    # Equation A10 of [Devoto1966]_.
+    q21 = mass_ratio * q12
+
+    # Equation A13 of [Devoto1966]_.
+    q30 = mass_ratio**3 * q03
+
+    # Equation A15 of [Devoto1966]_.
+    q31 = mass_ratio**2 * q13
+
+    # Equation A17 of [Devoto1966]_.
+    q32 = mass_ratio * q23
+
+    # Combine the q-matrix elements into a single matrix.
+    qq = np.block(
+        [
+            [q00, q01, q02, q03],
+            [q10, q11, q12, q13],
+            [q20, q21, q22, q23],
+            [q30, q31, q32, q33],
+        ]
+    )
+
+    return qq
+
+
+@njit
+def _q00_jit(Q11, masses, nb_species, number_densities):
     # Equation A3 of [Devoto1966]_.
     q00 = np.zeros((nb_species, nb_species))
     for i in range(nb_species):
@@ -1733,7 +1854,11 @@ def q(mixture: "LTE") -> np.ndarray:
                 ) ** (1 / 2) / masses[i] * (1 - delta(i, l))
                 sumval += term1 * Q11[i, l] * term2
             q00[i, j] = 8 * sumval
+    return q00
+
 
+@njit
+def _q01_jit(Q11, Q12, masses, nb_species, number_densities):
     # Equation A4 of [Devoto1966]_.
     q01 = np.zeros((nb_species, nb_species))
     for i in range(nb_species):
@@ -1755,58 +1880,101 @@ def q(mixture: "LTE") -> np.ndarray:
                 * (masses[i] / masses[j]) ** (3 / 2)
                 * sumval
             )
+    return q01
 
-    # Equation A6 of [Devoto1966]_.
-    q11 = np.zeros((nb_species, nb_species))
+
+@njit
+def _q02_jit(Q11, Q12, Q13, masses, nb_species, number_densities):
+    # Equation A7 of [Devoto1966]_.
+    q02 = np.zeros((nb_species, nb_species))
     for i in range(nb_species):
         for j in range(nb_species):
             sumval = 0
             for l in range(nb_species):
                 term1 = (
                     number_densities[l]
-                    * masses[l] ** (1 / 2)
+                    * masses[l] ** (5 / 2)
                     / (masses[i] + masses[l]) ** (5 / 2)
                 )
                 term2 = (delta(i, j) - delta(j, l)) * (
-                    5
-                    / 4
-                    * (6 * masses[j] ** 2 + 5 * masses[l] ** 2)
-                    * Q11[i, l]
-                    - 15 * masses[l] ** 2 * Q12[i, l]
-                    + 12 * masses[l] ** 2 * Q13[i, l]
-                ) + (delta(i, j) + delta(j, l)) * 4 * masses[j] * masses[
-                    l
-                ] * Q22[i, l]
+                    35 / 8 * Q11[i, l] - 21 / 2 * Q12[i, l] + 6 * Q13[i, l]
+                )
                 sumval += term1 * term2
-            q11[i, j] = (
+            q02[i, j] = (
                 8
                 * number_densities[i]
-                * (masses[i] / masses[j]) ** (3 / 2)
+                * (masses[i] / masses[j]) ** (5 / 2)
                 * sumval
             )
+    return q02
 
-    # Equation A7 of [Devoto1966]_.
-    q02 = np.zeros((nb_species, nb_species))
+
+@njit
+def _q03_jit(Q11, Q12, Q13, Q14, masses, nb_species, number_densities):
+    # Equation A12 of [Devoto1966]_.
+    q03 = np.zeros((nb_species, nb_species))
     for i in range(nb_species):
         for j in range(nb_species):
             sumval = 0
             for l in range(nb_species):
                 term1 = (
                     number_densities[l]
-                    * masses[l] ** (5 / 2)
-                    / (masses[i] + masses[l]) ** (5 / 2)
+                    * masses[l] ** (7 / 2)
+                    / (masses[i] + masses[l]) ** (7 / 2)
                 )
                 term2 = (delta(i, j) - delta(j, l)) * (
-                    35 / 8 * Q11[i, l] - 21 / 2 * Q12[i, l] + 6 * Q13[i, l]
+                    105 / 16 * Q11[i, l]
+                    - 189 / 8 * Q12[i, l]
+                    + 27 * Q13[i, l]
+                    - 10 * Q14[i, l]
                 )
                 sumval += term1 * term2
-            q02[i, j] = (
+            q03[i, j] = (
                 8
                 * number_densities[i]
-                * (masses[i] / masses[j]) ** (5 / 2)
+                * (masses[i] / masses[j]) ** (7 / 2)
+                * sumval
+            )
+    return q03
+
+
+@njit
+def _q11_jit(Q11, Q12, Q13, Q22, masses, nb_species, number_densities):
+    # Equation A6 of [Devoto1966]_.
+    q11 = np.zeros((nb_species, nb_species))
+    for i in range(nb_species):
+        for j in range(nb_species):
+            sumval = 0
+            for l in range(nb_species):
+                term1 = (
+                    number_densities[l]
+                    * masses[l] ** (1 / 2)
+                    / (masses[i] + masses[l]) ** (5 / 2)
+                )
+                term2 = (delta(i, j) - delta(j, l)) * (
+                    5
+                    / 4
+                    * (6 * masses[j] ** 2 + 5 * masses[l] ** 2)
+                    * Q11[i, l]
+                    - 15 * masses[l] ** 2 * Q12[i, l]
+                    + 12 * masses[l] ** 2 * Q13[i, l]
+                ) + (delta(i, j) + delta(j, l)) * 4 * masses[j] * masses[
+                    l
+                ] * Q22[i, l]
+                sumval += term1 * term2
+            q11[i, j] = (
+                8
+                * number_densities[i]
+                * (masses[i] / masses[j]) ** (3 / 2)
                 * sumval
             )
+    return q11
+
 
+@njit
+def _q12_jit(
+    Q11, Q12, Q13, Q14, Q22, Q23, masses, nb_species, number_densities
+):
     # Equation A9 of [Devoto1966]_.
     q12 = np.zeros((nb_species, nb_species))
     for i in range(nb_species):
@@ -1840,7 +2008,74 @@ def q(mixture: "LTE") -> np.ndarray:
                 * (masses[i] / masses[j]) ** (5 / 2)
                 * sumval
             )
-
+    return q12
+
+
+@njit
+def _q13_jit(
+    Q11,
+    Q12,
+    Q13,
+    Q14,
+    Q15,
+    Q22,
+    Q23,
+    Q24,
+    masses,
+    nb_species,
+    number_densities,
+):
+    # Equation A14 of [Devoto1966]_.
+    q13 = np.zeros((nb_species, nb_species))
+    for i in range(nb_species):
+        for j in range(nb_species):
+            sumval = 0
+            for l in range(nb_species):
+                term1 = (
+                    number_densities[l]
+                    * masses[l] ** (5 / 2)
+                    / (masses[i] + masses[l]) ** (9 / 2)
+                )
+                term2 = (delta(i, j) - delta(j, l)) * (
+                    105
+                    / 32
+                    * (18 * masses[j] ** 2 + 5 * masses[l] ** 2)
+                    * Q11[i, l]
+                    - 63
+                    / 4
+                    * (9 * masses[j] ** 2 + 5 * masses[l] ** 2)
+                    * Q12[i, l]
+                    + 81 * (masses[j] ** 2 + 2 * masses[l] ** 2) * Q13[i, l]
+                    - 160 * masses[l] ** 2 * Q14[i, l]
+                    + 60 * masses[l] ** 2 * Q15[i, l]
+                ) + (delta(i, j) + delta(j, l)) * masses[j] * masses[l] * (
+                    63 / 2 * Q22[i, l] - 72 * Q23[i, l] + 40 * Q24[i, l]
+                )
+                sumval += term1 * term2
+            q13[i, j] = (
+                8
+                * number_densities[i]
+                * (masses[i] / masses[j]) ** (7 / 2)
+                * sumval
+            )
+    return q13
+
+
+@njit
+def _q22_jit(
+    Q11,
+    Q12,
+    Q13,
+    Q14,
+    Q15,
+    Q22,
+    Q23,
+    Q24,
+    Q33,
+    masses,
+    nb_species,
+    number_densities,
+):
     # Equation A11 of [Devoto1966]_.
     q22 = np.zeros((nb_species, nb_species))
     for i in range(nb_species):
@@ -1890,66 +2125,27 @@ def q(mixture: "LTE") -> np.ndarray:
                 * (masses[i] / masses[j]) ** (5 / 2)
                 * sumval
             )
-
-    # Equation A12 of [Devoto1966]_.
-    q03 = np.zeros((nb_species, nb_species))
-    for i in range(nb_species):
-        for j in range(nb_species):
-            sumval = 0
-            for l in range(nb_species):
-                term1 = (
-                    number_densities[l]
-                    * masses[l] ** (7 / 2)
-                    / (masses[i] + masses[l]) ** (7 / 2)
-                )
-                term2 = (delta(i, j) - delta(j, l)) * (
-                    105 / 16 * Q11[i, l]
-                    - 189 / 8 * Q12[i, l]
-                    + 27 * Q13[i, l]
-                    - 10 * Q14[i, l]
-                )
-                sumval += term1 * term2
-            q03[i, j] = (
-                8
-                * number_densities[i]
-                * (masses[i] / masses[j]) ** (7 / 2)
-                * sumval
-            )
-
-    # Equation A14 of [Devoto1966]_.
-    q13 = np.zeros((nb_species, nb_species))
-    for i in range(nb_species):
-        for j in range(nb_species):
-            sumval = 0
-            for l in range(nb_species):
-                term1 = (
-                    number_densities[l]
-                    * masses[l] ** (5 / 2)
-                    / (masses[i] + masses[l]) ** (9 / 2)
-                )
-                term2 = (delta(i, j) - delta(j, l)) * (
-                    105
-                    / 32
-                    * (18 * masses[j] ** 2 + 5 * masses[l] ** 2)
-                    * Q11[i, l]
-                    - 63
-                    / 4
-                    * (9 * masses[j] ** 2 + 5 * masses[l] ** 2)
-                    * Q12[i, l]
-                    + 81 * (masses[j] ** 2 + 2 * masses[l] ** 2) * Q13[i, l]
-                    - 160 * masses[l] ** 2 * Q14[i, l]
-                    + 60 * masses[l] ** 2 * Q15[i, l]
-                ) + (delta(i, j) + delta(j, l)) * masses[j] * masses[l] * (
-                    63 / 2 * Q22[i, l] - 72 * Q23[i, l] + 40 * Q24[i, l]
-                )
-                sumval += term1 * term2
-            q13[i, j] = (
-                8
-                * number_densities[i]
-                * (masses[i] / masses[j]) ** (7 / 2)
-                * sumval
-            )
-
+    return q22
+
+
+@njit
+def _q23_jit(
+    Q11,
+    Q12,
+    Q13,
+    Q14,
+    Q15,
+    Q16,
+    Q22,
+    Q23,
+    Q24,
+    Q25,
+    Q33,
+    Q34,
+    masses,
+    nb_species,
+    number_densities,
+):
     # Equation A16 of [Devoto1966]_.
     q23 = np.zeros((nb_species, nb_species))
     for i in range(nb_species):
@@ -2014,7 +2210,31 @@ def q(mixture: "LTE") -> np.ndarray:
                 * (masses[i] / masses[j]) ** (7 / 2)
                 * sumval
             )
-
+    return q23
+
+
+@njit
+def _q33_jit(
+    Q11,
+    Q12,
+    Q13,
+    Q14,
+    Q15,
+    Q16,
+    Q17,
+    Q22,
+    Q23,
+    Q24,
+    Q25,
+    Q26,
+    Q33,
+    Q34,
+    Q35,
+    Q44,
+    masses,
+    nb_species,
+    number_densities,
+):
     # Equation A18 of [Devoto1966]_.
     q33 = np.zeros((nb_species, nb_species))
     for i in range(nb_species):
@@ -2104,67 +2324,7 @@ def q(mixture: "LTE") -> np.ndarray:
                 * (masses[i] / masses[j]) ** (7 / 2)
                 * sumval
             )
-
-    # Equation A5 of [Devoto1966]_.
-    q10 = np.zeros((nb_species, nb_species))
-    for i in range(nb_species):
-        for j in range(nb_species):
-            q10[i, j] = masses[j] / masses[i] * q01[i, j]
-
-    # Equation A8 of [Devoto1966]_.
-    q20 = np.zeros((nb_species, nb_species))
-    for i in range(nb_species):
-        for j in range(nb_species):
-            q20[i, j] = (masses[j] / masses[i]) ** 2 * q02[i, j]
-
-    # Equation A10 of [Devoto1966]_.
-    q21 = np.zeros((nb_species, nb_species))
-    for i in range(nb_species):
-        for j in range(nb_species):
-            q21[i, j] = masses[j] / masses[i] * q12[i, j]
-
-    # Equation A13 of [Devoto1966]_.
-    q30 = np.zeros((nb_species, nb_species))
-    for i in range(nb_species):
-        for j in range(nb_species):
-            q30[i, j] = (masses[j] / masses[i]) ** 3 * q03[i, j]
-
-    # Equation A15 of [Devoto1966]_.
-    q31 = np.zeros((nb_species, nb_species))
-    for i in range(nb_species):
-        for j in range(nb_species):
-            q31[i, j] = (masses[j] / masses[i]) ** 2 * q13[i, j]
-
-    # Equation A17 of [Devoto1966]_.
-    q32 = np.zeros((nb_species, nb_species))
-    for i in range(nb_species):
-        for j in range(nb_species):
-            q32[i, j] = masses[j] / masses[i] * q23[i, j]
-
-    # Combine the q-matrix elements into a single matrix.
-    qq = np.zeros((4 * nb_species, 4 * nb_species))
-
-    qq[0 * nb_species : 1 * nb_species, 0 * nb_species : 1 * nb_species] = q00
-    qq[0 * nb_species : 1 * nb_species, 1 * nb_species : 2 * nb_species] = q01
-    qq[0 * nb_species : 1 * nb_species, 2 * nb_species : 3 * nb_species] = q02
-    qq[0 * nb_species : 1 * nb_species, 3 * nb_species : 4 * nb_species] = q03
-
-    qq[1 * nb_species : 2 * nb_species, 0 * nb_species : 1 * nb_species] = q10
-    qq[1 * nb_species : 2 * nb_species, 1 * nb_species : 2 * nb_species] = q11
-    qq[1 * nb_species : 2 * nb_species, 2 * nb_species : 3 * nb_species] = q12
-    qq[1 * nb_species : 2 * nb_species, 3 * nb_species : 4 * nb_species] = q13
-
-    qq[2 * nb_species : 3 * nb_species, 0 * nb_species : 1 * nb_species] = q20
-    qq[2 * nb_species : 3 * nb_species, 1 * nb_species : 2 * nb_species] = q21
-    qq[2 * nb_species : 3 * nb_species, 2 * nb_species : 3 * nb_species] = q22
-    qq[2 * nb_species : 3 * nb_species, 3 * nb_species : 4 * nb_species] = q23
-
-    qq[3 * nb_species : 4 * nb_species, 0 * nb_species : 1 * nb_species] = q30
-    qq[3 * nb_species : 4 * nb_species, 1 * nb_species : 2 * nb_species] = q31
-    qq[3 * nb_species : 4 * nb_species, 2 * nb_species : 3 * nb_species] = q32
-    qq[3 * nb_species : 4 * nb_species, 3 * nb_species : 4 * nb_species] = q33
-
-    return qq
+    return q33
 
 
 def qhat(mixture: "LTE") -> np.ndarray:
@@ -2197,6 +2357,31 @@ def qhat(mixture: "LTE") -> np.ndarray:
     Q24 = Qij_mix(mixture, 2, 4)
     Q33 = Qij_mix(mixture, 3, 3)
 
+    qhat00 = _qhat00_jit(Q11, Q22, masses, nb_species, number_densities)
+
+    qhat01 = _qhat01_jit(
+        Q11, Q12, Q22, Q23, masses, nb_species, number_densities
+    )
+
+    qhat11 = _qhat11_jit(
+        Q11, Q12, Q13, Q22, Q23, Q24, Q33, masses, nb_species, number_densities
+    )
+
+    # Equation A21 of [Devoto1966]_.
+    qhat10 = masses[np.newaxis, :] / masses[:, np.newaxis] * qhat01
+
+    qq = np.block(
+        [
+            [qhat00, qhat01],
+            [qhat10, qhat11],
+        ]
+    )
+
+    return qq
+
+
+@njit
+def _qhat00_jit(Q11, Q22, masses, nb_species, number_densities):
     # Equation A19 of [Devoto1966]_.
     qhat00 = np.zeros((nb_species, nb_species))
     for i in range(nb_species):
@@ -2215,7 +2400,11 @@ def qhat(mixture: "LTE") -> np.ndarray:
             qhat00[i, j] = (
                 8 * number_densities[i] * (masses[i] / masses[j]) * sumval
             )
+    return qhat00
+
 
+@njit
+def _qhat01_jit(Q11, Q12, Q22, Q23, masses, nb_species, number_densities):
     # Equation A20 of [Devoto1966]_.
     qhat01 = np.zeros((nb_species, nb_species))
     for i in range(nb_species):
@@ -2236,7 +2425,13 @@ def qhat(mixture: "LTE") -> np.ndarray:
             qhat01[i, j] = (
                 8 * number_densities[i] * (masses[i] / masses[j]) ** 2 * sumval
             )
+    return qhat01
 
+
+@njit
+def _qhat11_jit(
+    Q11, Q12, Q13, Q22, Q23, Q24, Q33, masses, nb_species, number_densities
+):
     # Equation A22 of [Devoto1966]_.
     qhat11 = np.zeros((nb_species, nb_species))
     for i in range(nb_species):
@@ -2266,30 +2461,7 @@ def qhat(mixture: "LTE") -> np.ndarray:
             qhat11[i, j] = (
                 8 * number_densities[i] * (masses[i] / masses[j]) ** 2 * sumval
             )
-
-    # Equation A21 of [Devoto1966]_.
-    qhat10 = np.zeros((nb_species, nb_species))
-    for i in range(nb_species):
-        for j in range(nb_species):
-            qhat10[i, j] = masses[j] / masses[i] * qhat01[i, j]
-
-    qq = np.zeros((2 * nb_species, 2 * nb_species))
-
-    qq[0 * nb_species : 1 * nb_species, 0 * nb_species : 1 * nb_species] = (
-        qhat00
-    )
-    qq[0 * nb_species : 1 * nb_species, 1 * nb_species : 2 * nb_species] = (
-        qhat01
-    )
-
-    qq[1 * nb_species : 2 * nb_species, 0 * nb_species : 1 * nb_species] = (
-        qhat10
-    )
-    qq[1 * nb_species : 2 * nb_species, 1 * nb_species : 2 * nb_species] = (
-        qhat11
-    )
-
-    return qq
+    return qhat11
 
 
 ### Transport property calculations ###########################################
@@ -2365,7 +2537,7 @@ def Dij(mixture: "LTE") -> np.ndarray:
     diffusion_matrix = np.zeros((nb_species, nb_species))
     qq = q(mixture)  # Size (4*nb_species, 4*nb_species)
 
-    inverse_q = np.linalg.inv(qq)
+    lu_piv_q = scl.lu_factor(qq)
     b_vec = np.zeros(4 * nb_species)  # 4 for 4th order approximation
 
     for i in range(nb_species):
@@ -2376,7 +2548,7 @@ def Dij(mixture: "LTE") -> np.ndarray:
                 [delta(h, i) - delta(h, j) for h in range(0, nb_species)]
             )
             b_vec[:nb_species] = 3 * np.sqrt(np.pi) * dij
-            cflat = inverse_q.dot(b_vec)
+            cflat = scl.lu_solve(lu_piv_q, b_vec)
             cip = cflat.reshape(4, nb_species)
 
             # Diffusion coefficient, equation 3 of [Devoto1966]_.
@@ -2451,14 +2623,12 @@ def DTi(mixture: "LTE") -> float:
     masses = np.array([sp.molar_mass / u.N_a for sp in mixture.species])
 
     qq = q(mixture)
-
-    inverse_q = np.linalg.inv(qq)
     b_vec = np.zeros(4 * nb_species)  # 4 for 4th order approximation
     # Only the first element is non-zero
     b_vec[nb_species : 2 * nb_species] = (
         -15 / 2 * np.sqrt(np.pi) * number_densities
     )
-    aflat = inverse_q.dot(b_vec)
+    aflat = np.linalg.solve(qq, b_vec)
     aip = aflat.reshape(4, nb_species)
 
     return (
@@ -2528,14 +2698,13 @@ def viscosity(mixture: "LTE") -> float:
 
     qqhat = qhat(mixture)
 
-    inverse_qhat = np.linalg.inv(qqhat)
     b_vec = np.zeros(2 * nb_species)  # 2 for 2nd order approximation
     b_vec[:nb_species] = (
         5
         * number_densities
         * np.sqrt(2 * np.pi * masses / (u.k_b * mixture.T))
     )
-    bflat = inverse_qhat.dot(b_vec)
+    bflat = np.linalg.solve(qqhat, b_vec)
     bip = bflat.reshape(2, nb_species)
 
     return 0.5 * u.k_b * mixture.T * np.sum(number_densities * bip[0])
@@ -2736,12 +2905,11 @@ def thermal_conductivity(
     # Solve equation 5 of [Devoto1966]_ to get the `a` matrix.
     qq = q(mixture)
 
-    inverse_q = np.linalg.inv(qq)
     b_vec = np.zeros(4 * nb_species)
     b_vec[nb_species : 2 * nb_species] = (
         -15 / 2 * np.sqrt(np.pi) * number_densities
     )
-    aflat = inverse_q.dot(b_vec)
+    aflat = np.linalg.solve(qq, b_vec)
     aip = aflat.reshape(4, nb_species)
     # Equation 13 of [Devoto1966]_.
     k_dash = (

{minplascalc-1.0.1 → minplascalc-1.0.2}/minplascalc/mixture.py

@@ -645,7 +645,7 @@ class LTE:
         * :math:`M_i` is the molar mass of species :math:`i`,
           in :math:`\text{kg.mol}^{-1}`.
         """
-        number_densities = self.calculate_composition()  # particules/m^3
+        number_densities = self.calculate_composition()  # particles/m^3
         molar_masses = [sp.molar_mass for sp in self.species]  # kg/mol
         return (
             sum(n_i * M_i for n_i, M_i in zip(number_densities, molar_masses))

{minplascalc-1.0.1 → minplascalc-1.0.2}/minplascalc/species.py

@@ -188,7 +188,7 @@ class Monatomic(Species):
         molar_mass: float,
         charge_number: int,
         ionisation_energy: float,
-        energylevels: list[tuple[float, float]],
+        energy_levels: list[tuple[float, float]],
         polarisability: float,
         multiplicity: float,
         effective_electrons: float | None,
@@ -213,7 +213,7 @@ class Monatomic(Species):
             Charge on the species (in integer units of the fundamental charge).
         ionisation_energy : float
             Ionisation energy of the species, in :math:`\text{J}`.
-        energylevels : list[tuple[float, float]]
+        energy_levels : list[tuple[float, float]]
             Atomic energy level data - each entry in the list contains a pair
             of values giving the level's quantum number and its energy
             respectively, with energy in :math:`\text{J}`.
@@ -253,7 +253,7 @@ class Monatomic(Species):
         )
 
         self.ionisation_energy = ionisation_energy
-        self.energylevels = deepcopy(energylevels)
+        self.energy_levels = deepcopy(energy_levels)
         self.sources = deepcopy(sources)
 
     def __repr__(self):
@@ -262,7 +262,7 @@ class Monatomic(Species):
             f"stoichiometry={self.stoichiometry},"
             f"molar_mass={self.molar_mass},charge_number={self.charge_number},"
             f"ionisation_energy={self.ionisation_energy},"
-            f"energylevels={self.energylevels},"
+            f"energy_levels={self.energy_levels},"
             f"polarisability={self.polarisability},"
             f"multiplicity={self.multiplicity},"
             f"effective_electrons={self.effective_electrons},"
@@ -281,7 +281,7 @@ class Monatomic(Species):
             f"Molar mass: {self.molar_mass} kg/mol\n"
             f"Charge number: {self.charge_number}\n"
             f"Ionisation energy: {self.ionisation_energy} J\n"
-            f"Energy levels: {len(self.energylevels)}\n"
+            f"Energy levels: {len(self.energy_levels)}\n"
             f"Polarisability: {self.polarisability} m^3\n"
             f"Multiplicity: {self.multiplicity}\n"
             f"Effective valence electrons: {self.effective_electrons}\n"
@@ -336,7 +336,7 @@ class Monatomic(Species):
         # Calculate the electronic partition function.
         electron_partition_function = 0.0
 
-        for J_i, E_i in self.energylevels:
+        for J_i, E_i in self.energy_levels:
             if E_i < (self.ionisation_energy - dE):
                 # Only include energy levels below the ionisation energy.
                 g_i = 2 * J_i + 1  # Degeneracy of the energy level.
@@ -399,7 +399,7 @@ class Monatomic(Species):
 
         # Calculate the electronic energy.
         electronic_energy = 0.0
-        for J_i, E_i in self.energylevels:
+        for J_i, E_i in self.energy_levels:
             if E_i < (self.ionisation_energy - dE):
                 # Only include energy levels below the ionisation energy.
                 g_i = 2 * J_i + 1  # Degeneracy of the energy level.
@@ -1162,7 +1162,7 @@ def from_file(datafile: str | Path) -> Monatomic | Diatomic | Polyatomic:
             species_data["molar_mass"],
             species_data["charge_number"],
             species_data["ionisation_energy"],
-            species_data["energylevels"],
+            species_data["energy_levels"],
             species_data["polarisability"],
             species_data["multiplicity"],
             species_data["effective_electrons"],

{minplascalc-1.0.1 → minplascalc-1.0.2}/pyproject.toml

@@ -41,6 +41,7 @@ classifiers = [
   "Programming Language :: Python :: 3.13"
 ]
 dependencies = [
+  "numba",
   "numpy",
   "scipy"
 ]
@@ -55,25 +56,20 @@ urls = {"Homepage" = "https://github.com/quinnreynolds/minplascalc"}
 
 [tool.hatch.build.targets.sdist]
 include = [
-  "minplascalc/*.py",
-  "minplascalc/data/*/*.json",
-  "minplascalc/data/demo/nist/*"
-]
-
-[tool.hatch.build.targets.wheel]
-packages = [
-  "minplascalc"
+  "src/minplascalc/*.py",
+  "src/minplascalc/data/*/*.json",
+  "src/minplascalc/data/demo/nist/*"
 ]
+packages = ["src/minplascalc"]
 
 [tool.hatch.metadata]
 allow-direct-references = true
 
 [tool.hatch.version]
-path = "minplascalc/__init__.py"
+path = "src/minplascalc/__init__.py"
 
 [tool.ruff]
 indent-width = 4
-# See https://github.com/quinnreynolds/minplascalc/pull/66#discussion_r1986715810
 line-length = 79
 
 [tool.ruff.lint]
@@ -95,8 +91,8 @@ select = [
 ]
 
 [tool.ruff.lint.pycodestyle]
-# See https://github.com/quinnreynolds/minplascalc/pull/66#discussion_r1986715810
 max-line-length = 79
 
 [tool.ruff.lint.pydocstyle]
-convention = "numpy"  # See https://numpydoc.readthedocs.io/en/latest/format.html
+# See https://numpydoc.readthedocs.io/en/latest/format.html
+convention = "numpy"