solrat 0.9.6__tar.gz

solrat-0.9.6/LICENSE.md

@@ -0,0 +1 @@
+Copyright (C) 2023, Ivan I. Yakovkin. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL Ivan I. Yakovkin BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of Ivan I. Yakovkin shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from Ivan I. Yakovkin.

solrat-0.9.6/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: solrat
+Version: 0.9.6
+Summary: Solar Radiative Transfer non-LTE forward-modeling code.
+Author: Ivan I. Yakovkin
+License: MIT
+Project-URL: Homepage, https://github.com/yakovkinii/solrat
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: tqdm
+Requires-Dist: yatools
+Requires-Dist: sympy
+Dynamic: license-file
+
+<H1>SolRaT</H1>
+
+SolRaT (Solar Radiative Transfer) is a forward modeling code for non-LTE (and optionally LTE) transfer of 
+radiation in stellar atmospheres.
+
+The code implements the multi-term atom model, described in 
+`Landi Degl’Innocenti, E., & Landolfi, M. 2004, Polarization in Spectral Lines (Dordrecht: Kluwer)`. 
+SolRaT supports atomic level polarization, arbitrary magnetic fields (intermediate Paschen-Back effect), 
+Hanle effect and many other features.
+
+The code is written in python, currently tested on Windows and Ubuntu Linux. 
+The code is expected to work on all systems that fully support python 3.11. 
+SolRaT is currently in beta testing. Journal article and detailed documentation are pending.
+Until then, if SolRaT has found use in your research, please cite it as 
+```
+Yakovkin I. I. SolRaT (2023) [computer software]. Retrieved from https://www.yakovkinii.com/solrat/
+```
+
+How to run:
+```bash
+git clone https://github.com/yakovkinii/SolRaT.git
+pip install -r requirements.txt
+python ./run_all_tests.py
+```
+
+Some examples of how to use SolRaT are available in the `_demos` directory.
+
+Keywords:
+Non-LTE, Stokes Profiles, Inversion, Synthesis, Paschen-Back, Hanle, Zeeman, 
+Magnetic Fields, Sun, Solar Atmosphere, Radiative Transfer, Polarization, 
+Spectral Lines, Two-Term Atom Model
+
+Copyright (2023) Ivan I. Yakovkin

solrat-0.9.6/README.md

@@ -0,0 +1,33 @@
+<H1>SolRaT</H1>
+
+SolRaT (Solar Radiative Transfer) is a forward modeling code for non-LTE (and optionally LTE) transfer of 
+radiation in stellar atmospheres.
+
+The code implements the multi-term atom model, described in 
+`Landi Degl’Innocenti, E., & Landolfi, M. 2004, Polarization in Spectral Lines (Dordrecht: Kluwer)`. 
+SolRaT supports atomic level polarization, arbitrary magnetic fields (intermediate Paschen-Back effect), 
+Hanle effect and many other features.
+
+The code is written in python, currently tested on Windows and Ubuntu Linux. 
+The code is expected to work on all systems that fully support python 3.11. 
+SolRaT is currently in beta testing. Journal article and detailed documentation are pending.
+Until then, if SolRaT has found use in your research, please cite it as 
+```
+Yakovkin I. I. SolRaT (2023) [computer software]. Retrieved from https://www.yakovkinii.com/solrat/
+```
+
+How to run:
+```bash
+git clone https://github.com/yakovkinii/SolRaT.git
+pip install -r requirements.txt
+python ./run_all_tests.py
+```
+
+Some examples of how to use SolRaT are available in the `_demos` directory.
+
+Keywords:
+Non-LTE, Stokes Profiles, Inversion, Synthesis, Paschen-Back, Hanle, Zeeman, 
+Magnetic Fields, Sun, Solar Atmosphere, Radiative Transfer, Polarization, 
+Spectral Lines, Two-Term Atom Model
+
+Copyright (2023) Ivan I. Yakovkin

solrat-0.9.6/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "solrat"
+dynamic = ["version"]
+description = "Solar Radiative Transfer non-LTE forward-modeling code."
+authors = [{name = "Ivan I. Yakovkin"}]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "numpy",
+    "pandas",
+    "matplotlib",
+    "tqdm",
+    "yatools",
+    "sympy",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/yakovkinii/solrat"
+
+[tool.setuptools.dynamic]
+version = {attr = "solrat.about.version"}
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["solrat*"]

solrat-0.9.6/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

solrat-0.9.6/solrat/about.py

@@ -0,0 +1 @@
+version = "0.9.6"

solrat-0.9.6/solrat/common/constants.py

@@ -0,0 +1,19 @@
+"""
+TODO
+TODO  This file needs improved documentation.
+TODO
+"""
+
+import numpy as np
+
+sqrt2 = np.sqrt(2)
+sqrt3 = np.sqrt(3)
+sqrt_pi = np.sqrt(np.pi)
+
+h_erg_s = 6.626196e-27  # erg s
+c_cm_sm1 = 2.99792458e10  # cm/s
+kB_erg_Km1 = 1.380658e-16  # erg/K
+# e0_cgs = 0.480321e-9  # StatCoulomb
+# me_g = 9.109390e-28  # g
+atomic_mass_unit_g = 1.660539e-24  # g
+mu0_erg_gaussm1 = 9.274e-21  # Bohr magneton in erg/G

solrat-0.9.6/solrat/common/functions.py

@@ -0,0 +1,44 @@
+"""
+TODO
+TODO  This file needs improved documentation.
+TODO
+"""
+
+from typing import Union
+
+import numpy as np
+from numpy import exp
+
+from solrat.common.constants import c_cm_sm1, h_erg_s, kB_erg_Km1, mu0_erg_gaussm1
+
+
+def get_planck_BP(nu_sm1: Union[float, np.ndarray], T_K: float) -> Union[float, np.ndarray]:
+    """
+    Planck function
+    Reference: (below 5.40)
+    """
+    return 2 * h_erg_s * nu_sm1**3 / c_cm_sm1**2 / (exp(h_erg_s * nu_sm1 / kB_erg_Km1 / T_K) - 1)
+
+
+def nu_larmor(magnetic_field_gauss: np.ndarray) -> np.ndarray:
+    """
+    Larmor frequency in Hz
+    Reference: (3.10)
+    """
+    return magnetic_field_gauss * mu0_erg_gaussm1 / h_erg_s
+
+
+def energy_cmm1_to_frequency_hz(energy_cmm1: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
+    return c_cm_sm1 * energy_cmm1
+
+
+def lambda_cm_to_frequency_hz(lambda_cm: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
+    return c_cm_sm1 / lambda_cm
+
+
+def frequency_hz_to_lambda_A(frequency_hz: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
+    return c_cm_sm1 / frequency_hz * 1e8
+
+
+def energy_cmm1_to_erg(energy_cmm1: float) -> float:
+    return h_erg_s * c_cm_sm1 * energy_cmm1

solrat-0.9.6/solrat/common/rotations.py

@@ -0,0 +1,120 @@
+"""
+TODO
+TODO  This file needs improved documentation.
+TODO
+"""
+
+from functools import lru_cache
+
+import numpy as np
+import sympy
+from numpy import cos, exp, sin
+from sympy.physics.wigner import wigner_d
+
+from solrat.common.constants import sqrt2, sqrt3
+from solrat.engine.functions.general import delta, m1p
+from solrat.engine.functions.looping import PROJECTION, fromto
+from solrat.engine.generators.nested_loops import nested_loops
+
+
+class WignerD:
+    """
+    Wigner D function.
+    alpha, beta, gamma are Euler angles in radians.
+    Typically, we have alpha = chi, beta = theta, gamma = gamma (see Fig. 5.14).
+    """
+
+    def __init__(self, alpha, beta, gamma, K_max):
+        self.d = {}
+        for K in fromto(0, K_max):
+            # Note: sympy uses a different convention for angles, so I perform under-the-hood conversion here.
+            self.d[K] = wigner_d(J=int(K), alpha=-alpha, beta=-beta, gamma=-gamma)
+
+    @lru_cache(maxsize=None)
+    def __call__(self, K, P, Q):
+        result = np.array(sympy.N(self.d[K][int(K - P), int(K - Q)])).astype(np.complex128)
+        return result
+
+
+def t_K_P(K, P, stokes_component_index):
+    """
+    t{K, P}(i)
+    Reference: Table 5.5
+    This is implemented primarily to validate Wigner D functions
+    """
+    if K == 0:
+        return delta(P, 0) * delta(stokes_component_index, 0)
+    if K == 1:
+        return sqrt3 / sqrt2 * delta(P, 0) * delta(stokes_component_index, 3)
+    return (
+        1 / sqrt2 * delta(P, 0) * delta(stokes_component_index, 0)
+        - sqrt3 / 2 * (delta(P, -2) + delta(P, 2)) * delta(stokes_component_index, 1)
+        + 1j * sqrt3 / 2 * (delta(P, -2) - delta(P, 2)) * delta(stokes_component_index, 2)
+    )
+
+
+# @lru_cache(maxsize=None)
+def T_K_Q_double_rotation(K, Q, stokes_component_index, D_inverse_omega: WignerD, D_magnetic: WignerD):
+    """
+    (5.159), (2.74), (5.122)
+    Two consecutive D rotations within T tensor.
+    """
+    result = 0
+    for P, Qʹ in nested_loops(P=PROJECTION(K), Qʹ=PROJECTION(K)):
+        result = result + t_K_P(
+            K=K,
+            P=P,
+            stokes_component_index=stokes_component_index,
+        ) * D_inverse_omega(
+            K=K, P=P, Q=Qʹ
+        ) * D_magnetic(K=K, P=Qʹ, Q=Q)
+
+    return result
+
+
+@lru_cache(maxsize=None)
+def T_K_Q(K, Q, stokes_component_index, chi, theta, gamma):
+    """
+    T{K, Q}(i, Omega)
+
+    Reference: Table 5.6
+    See also: (5.159), (5.160)
+    """
+    if Q < 0:
+        return m1p(Q) * T_K_Q(K, -Q, stokes_component_index, chi, theta, gamma).conjugate()
+
+    if stokes_component_index == 0:
+        if K == 0:
+            return 1 + 0j
+        if K == 1:
+            return 0 + 0j
+        if Q == 0:
+            return 0.5 / sqrt2 * (3 * cos(theta) ** 2 - 1) + 0j
+        if Q == 1:
+            return -0.5 * sqrt3 * sin(theta) * cos(theta) * exp(1j * chi)
+        return 0.25 * sqrt3 * sin(theta) ** 2 * exp(2j * chi)
+    if stokes_component_index == 1:
+        if K <= 1:
+            return 0 + 0j
+        if Q == 0:
+            return -1.5 / sqrt2 * cos(2 * gamma) * sin(theta) ** 2 + 0j
+        if Q == 1:
+            return -0.5 * sqrt3 * (cos(2 * gamma) * cos(theta) + 1j * sin(2 * gamma)) * sin(theta) * exp(1j * chi)
+        return (
+            -0.25 * sqrt3 * (cos(2 * gamma) * (1 + cos(theta) ** 2) + 2j * sin(2 * gamma) * cos(theta)) * exp(2j * chi)
+        )
+    if stokes_component_index == 2:
+        if K <= 1:
+            return 0 + 0j
+        if Q == 0:
+            return 1.5 / sqrt2 * sin(2 * gamma) * sin(theta) ** 2 + 0j
+        if Q == 1:
+            return 0.5 * sqrt3 * (sin(2 * gamma) * cos(theta) - 1j * cos(2 * gamma)) * sin(theta) * exp(1j * chi)
+        return (
+            0.25 * sqrt3 * (sin(2 * gamma) * (1 + cos(theta) ** 2) - 2j * cos(2 * gamma) * cos(theta)) * exp(2j * chi)
+        )
+    if K == 0 or K == 2:
+        return 0 + 0j
+    if Q == 0:
+        return sqrt3 / sqrt2 * cos(theta) + 0j
+    return -0.5 * sqrt3 * sin(theta) * exp(1j * chi)

solrat-0.9.6/solrat/common/voigt_profile.py

@@ -0,0 +1,45 @@
+"""
+TODO
+TODO  This file needs improved documentation.
+TODO
+"""
+
+import numpy as np
+from numpy import exp
+
+
+def _voigt(nu: np.ndarray, a: float) -> np.ndarray:
+    """
+    complex Voigt profile at relative frequency nu with damping factor a.
+    Reference: Humlíček, J. (1982). JQSRT, doi:10.1016/0022-4073(82)90078-4
+
+    Note: HAZEL2 for some reason uses an expansion in terms of the Dawson's integral for a < 1e-3, see
+    https://github.com/aasensio/hazel2/blob/master/src/hazel/maths.f90#L1076.
+    They motivate it by some numerical instabilities near a->0.
+
+    I didn't find any such issues here in SolRaT, and the Humlíček expansion approach matches the results from
+    Dawson's integral expansion very closely, so I decided to use the Humlíček expansion for all a.
+    """
+
+    t = a - 1j * nu
+    s = abs(nu) + a
+    u = t * t
+
+    if s >= 15:
+        return t * 0.5641896 / (0.5 + u)
+    if s >= 5.5:
+        return t * (1.410474 + u * 0.5641896) / (0.75 + u * (3 + u))
+    if a >= 0.195 * abs(nu) - 0.176:
+        return (16.4955 + t * (20.20933 + t * (11.96482 + t * (3.778987 + t * 0.5642236)))) / (
+            16.4955 + t * (38.82363 + t * (39.27121 + t * (21.69274 + t * (6.699398 + t))))
+        )
+    w4 = t * (
+        36183.31 - u * (3321.9905 - u * (1540.787 - u * (219.0313 - u * (35.76683 - u * (1.320522 - u * 0.56419)))))
+    )
+    v4 = 32066.6 - u * (
+        24322.84 - u * (9022.228 - u * (2186.181 - u * (364.2191 - u * (61.57037 - u * (1.841439 - u)))))
+    )
+    return exp(u) - w4 / v4
+
+
+voigt = np.vectorize(_voigt)

solrat-0.9.6/solrat/common/wigner_3j_6j_9j.py

@@ -0,0 +1,216 @@
+"""
+TODO
+TODO  This file needs improved documentation.
+TODO
+"""
+
+from functools import lru_cache
+
+import numpy as np
+from numpy import abs, sqrt
+
+from solrat.engine.functions.general import fact2
+
+
+def _w3j_doubled_argument(j1_doubled, j2_doubled, j3_doubled, m1_doubled, m2_doubled, m3_doubled):
+    """
+    float Wigner 3J symbol where all arguments are doubled to be integer
+
+    j1_doubled = 2 * J1: int
+    j2_doubled = 2 * J2: int
+    j3_doubled = 2 * J3: int
+    m1_doubled = 2 * M1: int
+    m2_doubled = 2 * M2: int
+    m3_doubled = 2 * M3: int
+
+    Reference: Appendix A1
+
+    ( J1 J2 J3 )
+    ( M1 M2 M3 )
+    """
+
+    assert m1_doubled + m2_doubled + m3_doubled == 0, "M1 + M2 + M3 != 0."
+
+    if (abs(m1_doubled) > j1_doubled) or (abs(m2_doubled) > j2_doubled) or (abs(m3_doubled) > j3_doubled):
+        return 0.0
+    a = j1_doubled + j2_doubled
+    if j3_doubled > a:
+        return 0.0
+    b = j1_doubled - j2_doubled
+    if j3_doubled < abs(b):
+        return 0.0
+    j_sum = j3_doubled + a
+    c = j1_doubled - m1_doubled
+    d = j2_doubled - m2_doubled
+
+    assert j_sum % 2 == 0, "J1 + J2 + J3 != even."
+    assert c % 2 == 0, "J1 - M1 != even."
+    assert d % 2 == 0, "J2 - M2 != even."
+
+    e = j3_doubled - j2_doubled + m1_doubled
+    f = j3_doubled - j1_doubled - m2_doubled
+    z_min = max(0, -e, -f)
+    g = a - j3_doubled
+    h = j2_doubled + m2_doubled
+    z_max = min(g, h, c)
+    result = 0.0
+    for z in range(int(z_min), int(z_max) + 1, 2):
+        denominator = fact2(z) * fact2(g - z) * fact2(c - z) * fact2(h - z) * fact2(e + z) * fact2(f + z)
+        if z % 4 != 0:
+            denominator = -denominator
+        result += 1 / denominator
+    cc1 = fact2(g) * fact2(j3_doubled + b) * fact2(j3_doubled - b) / fact2(j_sum + 2)
+    cc2 = (
+        fact2(j1_doubled + m1_doubled)
+        * fact2(c)
+        * fact2(h)
+        * fact2(d)
+        * fact2(j3_doubled - m3_doubled)
+        * fact2(j3_doubled + m3_doubled)
+    )
+    result *= sqrt(cc1 * cc2)
+    if (b - m3_doubled) % 4 != 0:
+        result = -result
+    return result
+
+
+def _w6j_doubled_argument(j1_doubled, j2_doubled, j3_doubled, l1_doubled, l2_doubled, l3_doubled):
+    """
+    float Wigner 6J symbol where all arguments are doubled to be integer
+
+    j1_doubled = 2 * J1: int
+    j2_doubled = 2 * J2: int
+    j3_doubled = 2 * J3: int
+    l1_doubled = 2 * L1: int
+    l2_doubled = 2 * L2: int
+    l3_doubled = 2 * L3: int
+
+    Reference: Appendix A1
+
+    { J1 J2 J3 }
+    { L1 L2 L3 }
+    """
+    a = j1_doubled + j2_doubled
+    b = j1_doubled - j2_doubled
+    c = j1_doubled + l2_doubled
+    d = j1_doubled - l2_doubled
+    e = l1_doubled + j2_doubled
+    f = l1_doubled - j2_doubled
+    g = l1_doubled + l2_doubled
+    h = l1_doubled - l2_doubled
+
+    if (a < j3_doubled) or (c < l3_doubled) or (e < l3_doubled) or (g < j3_doubled):
+        # logging.warning("Performance warning: J1 + J2 < J3 or L1 + L2 < L3 or L1 + J2 < L3 or L1 + L2 < J3")
+        return 0.0
+
+    if (abs(b) > j3_doubled) or (abs(d) > l3_doubled) or (abs(f) > l3_doubled) or (abs(h) > j3_doubled):
+        # logging.warning("Performance warning: J1 - J2 > J3 or J1 - L2 > L3 or L1 - J2 > L3 or L1 - L2 > J3")
+        return 0.0
+
+    sum_1 = a + j3_doubled
+    sum_2 = c + l3_doubled
+    sum_3 = e + l3_doubled
+    sum_4 = g + j3_doubled
+
+    assert sum_1 % 2 == 0, "J1 + J2 + J3 != even."
+    assert sum_2 % 2 == 0, "J1 + L2 + L3 != even."
+    assert sum_3 % 2 == 0, "L1 + J2 + L3 != even."
+
+    w_min = max(sum_1, sum_2, sum_3, sum_4)
+    i = a + g
+    j = j2_doubled + j3_doubled + l2_doubled + l3_doubled
+    k = j3_doubled + j1_doubled + l3_doubled + l1_doubled
+    w_max = min(i, j, k)
+
+    result = 0.0
+    for w in range(int(w_min), int(w_max) + 1, 2):
+        denominator = (
+            fact2(w - sum_1)
+            * fact2(w - sum_2)
+            * fact2(w - sum_3)
+            * fact2(w - sum_4)
+            * fact2(i - w)
+            * fact2(j - w)
+            * fact2(k - w)
+        )
+        if w % 4 != 0:
+            denominator = -denominator
+        result += fact2(w + 2) / denominator
+
+    theta1 = fact2(a - j3_doubled) * fact2(j3_doubled + b) * fact2(j3_doubled - b) / fact2(sum_1 + 2)
+    theta2 = fact2(c - l3_doubled) * fact2(l3_doubled + d) * fact2(l3_doubled - d) / fact2(sum_2 + 2)
+    theta3 = fact2(e - l3_doubled) * fact2(l3_doubled + f) * fact2(l3_doubled - f) / fact2(sum_3 + 2)
+    theta4 = fact2(g - j3_doubled) * fact2(j3_doubled + h) * fact2(j3_doubled - h) / fact2(sum_4 + 2)
+    result = result * sqrt(theta1 * theta2 * theta3 * theta4)
+    return result
+
+
+def _w9j_doubled_argument(
+    j1_doubled,
+    j2_doubled,
+    j3_doubled,
+    j4_doubled,
+    j5_doubled,
+    j6_doubled,
+    j7_doubled,
+    j8_doubled,
+    j9_doubled,
+):
+    """
+    float Wigner 9J symbol where all arguments are doubled to be integer
+
+    j1_doubled = 2 * J1: int
+    j2_doubled = 2 * J2: int
+    j3_doubled = 2 * J3: int
+    j4_doubled = 2 * J4: int
+    j5_doubled = 2 * J5: int
+    j6_doubled = 2 * J6: int
+    j7_doubled = 2 * J7: int
+    j8_doubled = 2 * J8: int
+    j9_doubled = 2 * J9: int
+
+    Reference: Appendix A1
+
+    { J1 J2 J3 }
+    { J4 J5 J6 }
+    { J7 J8 J9 }
+    """
+    k_min = max(
+        abs(j1_doubled - j9_doubled),
+        abs(j4_doubled - j8_doubled),
+        abs(j2_doubled - j6_doubled),
+    )
+
+    k_max = min(
+        abs(j1_doubled + j9_doubled),
+        abs(j4_doubled + j8_doubled),
+        abs(j2_doubled + j6_doubled),
+    )
+    result = 0
+    for k in range(int(k_min), int(k_max) + 1, 2):
+        s = -1 if k % 2 != 0 else 1
+        x1 = _w6j_doubled_argument(j1_doubled, j9_doubled, k, j8_doubled, j4_doubled, j7_doubled)
+        x2 = _w6j_doubled_argument(j2_doubled, j6_doubled, k, j4_doubled, j8_doubled, j5_doubled)
+        x3 = _w6j_doubled_argument(j1_doubled, j9_doubled, k, j6_doubled, j2_doubled, j3_doubled)
+        result += s * x1 * x2 * x3 * (k + 1)
+    return result
+
+
+# vectorize
+_w3j_doubled_argument_vec = np.vectorize(_w3j_doubled_argument)
+_w6j_doubled_argument_vec = np.vectorize(_w6j_doubled_argument)
+
+
+# @lru_cache(maxsize=None)
+def wigner_3j(j1, j2, j3, m1, m2, m3):
+    return _w3j_doubled_argument_vec(j1 * 2, j2 * 2, j3 * 2, m1 * 2, m2 * 2, m3 * 2)
+
+
+# @lru_cache(maxsize=None)
+def wigner_6j(j1, j2, j3, l1, l2, l3):
+    return _w6j_doubled_argument_vec(j1 * 2, j2 * 2, j3 * 2, l1 * 2, l2 * 2, l3 * 2)
+
+
+@lru_cache(maxsize=None)
+def wigner_9j(j1, j2, j3, j4, j5, j6, j7, j8, j9):
+    return _w9j_doubled_argument(j1 * 2, j2 * 2, j3 * 2, j4 * 2, j5 * 2, j6 * 2, j7 * 2, j8 * 2, j9 * 2)