TransitionListener 2.0.0__py3-none-any.whl

transitionlistener/check_installation.py

@@ -0,0 +1,309 @@
+"""Installation self-test for TransitionListener.
+
+Called by ``tl --check`` (via src/transitionlistener/interface/check.py).
+Can also be run directly: ``python tests/check_installation.py``.
+
+The quick checks (~300 ms) use only code that ships inside the package.
+They are followed automatically by an end-to-end physics smoke test
+(~1-2 min) that runs ``example_point.yaml`` and validates key physical
+outputs.
+"""
+
+from __future__ import annotations
+
+import math
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+
+def _result(label: str, ok: bool, detail: str = "") -> None:
+    from transitionlistener import console
+    status = "[bold green]PASS[/bold green]" if ok else "[bold red]FAIL[/bold red]"
+    line = f"  {status}  {label}"
+    if detail:
+        line += f"  ({detail})"
+    console.print(line)
+
+
+def _find_examples_root() -> Path | None:
+    """Return the directory that contains both examples/ and models/.
+
+    Works for repo clones (this file lives at tests/check_installation.py,
+    so the repo root is one level up) and for pip installs where hatchling
+    has bundled examples/ as transitionlistener/examples/.
+    """
+    # Repo clone: tests/check_installation.py → repo root is parents[1]
+    candidate = Path(__file__).resolve().parents[1]
+    if (candidate / "examples" / "example_point.yaml").exists():
+        return candidate
+    # pip install: hatchling bundled examples/ as transitionlistener/examples/
+    try:
+        import importlib.resources as ir
+        pkg_root = Path(str(ir.files("transitionlistener")))
+        if (pkg_root / "examples" / "example_point.yaml").exists():
+            return pkg_root
+    except Exception:
+        pass
+    return None
+
+
+def _run_smoke(console, failures: int) -> int:
+    """Run the end-to-end physics smoke test. Returns updated failure count."""
+    from rich.panel import Panel
+
+    console.print()
+    console.print(Panel.fit("[bold]End-to-end physics check[/bold]", border_style="cyan"))
+    console.print()
+
+    repo_root = _find_examples_root()
+    if repo_root is None:
+        console.print("  [bold yellow]SKIP[/bold yellow]  smoke test  (examples/ directory not found)")
+        return failures
+
+    yaml_src = repo_root / "examples" / "example_point.yaml"
+    model_src = repo_root / "models" / "TL_conformal_dark_u1.py"
+
+    with tempfile.TemporaryDirectory() as _tmp:
+        tmpdir = Path(_tmp)
+        (tmpdir / "examples").mkdir()
+        (tmpdir / "models").mkdir()
+        shutil.copy(yaml_src, tmpdir / "examples" / "example_point.yaml")
+        shutil.copy(model_src, tmpdir / "models" / "TL_conformal_dark_u1.py")
+
+        env = os.environ.copy()
+        env.update({"OMP_NUM_THREADS": "1", "OPENBLAS_NUM_THREADS": "1", "MKL_NUM_THREADS": "1"})
+
+        console.print("  Running example_point.yaml  [dim](conformal U(1), SinglePoint — takes ~1-2 min)[/dim]")
+        t0 = time.perf_counter()
+        # Prefer the `tl` script from the same env as sys.executable.
+        tl_script = Path(sys.executable).parent / "tl"
+        if not tl_script.exists():
+            tl_script = Path(sys.executable).parent / "tl.exe"  # Windows
+        cmd = (
+            [str(tl_script), "-c", "examples/example_point.yaml", "-j", "1"]
+            if tl_script.exists()
+            else [sys.executable, "-c",
+                  "from transitionlistener.interface import main; main()",
+                  "-c", "examples/example_point.yaml", "-j", "1"]
+        )
+        try:
+            proc = subprocess.run(
+                cmd,
+                cwd=tmpdir,
+                env=env,
+                capture_output=True,
+                text=True,
+                timeout=300,
+            )
+        except subprocess.TimeoutExpired:
+            _result("smoke test", False, "timed out after 300 s")
+            return failures + 1
+        elapsed = time.perf_counter() - t0
+
+        if proc.returncode != 0:
+            _result("smoke test", False, f"exit code {proc.returncode}")
+            console.print(f"  [dim]{proc.stderr[-500:]}[/dim]")
+            return failures + 1
+
+        out_file = tmpdir / "scans" / "example_point" / "1_All_params.txt"
+        if not out_file.exists():
+            _result("smoke test", False, "output file not created")
+            return failures + 1
+
+        # Parse key-value output table
+        values: dict[str, float] = {}
+        for line in out_file.read_text().splitlines():
+            m = re.match(r"^\s*(\S+)\s+(\S.*?)\s*$", line)
+            if m:
+                try:
+                    values[m.group(1)] = float(m.group(2))
+                except ValueError:
+                    pass
+
+        EXPECTED = {
+            "Tperc_SM_GeV":    (1.0e-3, 5.0e-2),
+            "alpha":           (1.0e+1, 1.0e+4),
+            "RH":              (1.0e-6, 1.0e+0),
+        }
+
+        smoke_ok = True
+        for key, (lo, hi) in EXPECTED.items():
+            if key not in values:
+                _result(f"  {key}", False, "missing from output")
+                smoke_ok = False
+                failures += 1
+            elif not math.isfinite(values[key]) or not (lo <= values[key] <= hi):
+                _result(f"  {key}", False, f"{values[key]:.3e} outside [{lo:.0e}, {hi:.0e}]")
+                smoke_ok = False
+                failures += 1
+            else:
+                _result(f"  {key}", True, f"{values[key]:.3e}")
+
+        _result("smoke test (example_point.yaml)", smoke_ok, f"{elapsed:.0f} s")
+        if not smoke_ok:
+            failures += 1
+
+    return failures
+
+
+def run_checks() -> int:
+    """Run all installation checks. Returns 0 on success, 1 on failure."""
+    from transitionlistener import console
+    from rich.panel import Panel
+
+    console.print(Panel.fit("[bold]TransitionListener installation check[/bold]", border_style="cyan"))
+    console.print()
+
+    failures = 0
+
+    # ------------------------------------------------------------------
+    # 1. Core scientific imports
+    # ------------------------------------------------------------------
+    for name in ("numpy", "scipy", "matplotlib", "pandas", "rich", "tqdm", "yaml"):
+        t0 = time.perf_counter()
+        try:
+            __import__(name)
+            _result(f"import {name}", True, f"{(time.perf_counter()-t0)*1e3:.0f} ms")
+        except ImportError as exc:
+            _result(f"import {name}", False, str(exc))
+            failures += 1
+
+    # ------------------------------------------------------------------
+    # 2. Thermodynamics (reads tab_data shipped with the package)
+    # ------------------------------------------------------------------
+    try:
+        t0 = time.perf_counter()
+        from transitionlistener.thermodynamics import e_geffSM, p_geffSM, s_geffSM
+        import numpy as np
+        T, CF = 10.0, 1.0
+        e = (math.pi**2 / 30) * e_geffSM(T, CF) * T**4
+        p = (math.pi**2 / 90) * p_geffSM(T, CF) * T**4
+        s = (2 * math.pi**2 / 45) * s_geffSM(T, CF) * T**3
+        residual = abs(s - (e + p) / T)
+        ok = residual < 1e-4
+        _result("thermodynamics (e+p=sT)", ok, f"residual={residual:.2e}, {(time.perf_counter()-t0)*1e3:.0f} ms")
+        if not ok:
+            failures += 1
+    except Exception as exc:
+        _result("thermodynamics", False, str(exc))
+        failures += 1
+
+    # ------------------------------------------------------------------
+    # 3. Percolation integral (ODE solver, no model file needed)
+    # ------------------------------------------------------------------
+    try:
+        t0 = time.perf_counter()
+        import numpy as np
+        from transitionlistener.bubbledynamics import percIntegralODE, percIntegral
+        T = np.geomspace(50.0, 0.5, 80)
+        s_over_t = 120.0 * (T / T[0]) ** 0.5 + 5.0
+        S = s_over_t * T
+        H = T**2 / 1e6
+        I_ode = percIntegralODE(T, H, S, vw=1.0)
+        ok = I_ode.shape == T.shape and float(I_ode[-1]) > 0.0
+        _result("percolation ODE integral", ok, f"{(time.perf_counter()-t0)*1e3:.0f} ms")
+        if not ok:
+            failures += 1
+    except Exception as exc:
+        _result("percolation ODE integral", False, str(exc))
+        failures += 1
+
+    # ------------------------------------------------------------------
+    # 4. Bounce action (asymmetric double-well: V = (x^2-1)^2/4 - eps*x)
+    # Minima at x≈±1; tiny eps=0.01 makes x≈+1 the true vacuum.
+    # Barrier at x≈0 sits well above both minima.
+    # ------------------------------------------------------------------
+    try:
+        t0 = time.perf_counter()
+        import numpy as np
+        from transitionlistener import pathDeformation
+
+        def V(x):
+            phi = np.asarray(x, dtype=float).ravel()
+            vals = 0.25 * (phi**2 - 1.0)**2 - 0.01 * phi
+            return float(vals[0]) if vals.size == 1 else vals
+
+        def dV(x):
+            x = np.asarray(x, dtype=float)
+            phi = x.ravel()
+            return (phi**3 - phi - 0.01).reshape(x.shape)
+
+        x_true = np.array([1.0])
+        x_false = np.array([-1.0])
+        tobj = pathDeformation.fullTunneling(
+            [x_true, x_false], V, dV,
+            callback_data=1.0,
+        )
+        finite = math.isfinite(float(tobj.action))
+        _result("bounce action (synthetic 1D)", finite, f"S3={tobj.action:.4f}, {(time.perf_counter()-t0)*1e3:.0f} ms")
+        if not finite:
+            failures += 1
+    except Exception as exc:
+        _result("bounce action (synthetic 1D)", False, str(exc))
+        failures += 1
+
+    # ------------------------------------------------------------------
+    # 5. Optional: MPI (informational — never fails)
+    # ------------------------------------------------------------------
+    try:
+        t0 = time.perf_counter()
+        from mpi4py import MPI  # noqa: F401
+        size = MPI.COMM_WORLD.Get_size()
+        console.print(f"  [bold cyan]INFO[/bold cyan]  mpi4py  [green]found[/green]  (MPI size={size}, {(time.perf_counter()-t0)*1e3:.0f} ms)")
+    except Exception:
+        console.print("  [bold cyan]INFO[/bold cyan]  mpi4py  [yellow]not installed[/yellow]  (MPI parallelism disabled)")
+
+    # ------------------------------------------------------------------
+    # 6. Optional: ptarcade / enterprise (informational — never fails)
+    # ------------------------------------------------------------------
+    try:
+        t0 = time.perf_counter()
+        import ptarcade  # noqa: F401
+        from enterprise.signals.parameter import Uniform  # noqa: F401
+        console.print(f"  [bold cyan]INFO[/bold cyan]  ptarcade + enterprise  [green]found[/green]  ({(time.perf_counter()-t0)*1e3:.0f} ms)")
+    except Exception:
+        console.print("  [bold cyan]INFO[/bold cyan]  ptarcade + enterprise  [yellow]not installed[/yellow]  (PTA likelihood disabled)")
+
+    # ------------------------------------------------------------------
+    # Quick-check summary
+    # ------------------------------------------------------------------
+    console.print()
+    if failures == 0:
+        console.print(Panel.fit(
+            f"[bold green]Quick checks passed[/bold green]  "
+            f"(Python {sys.version.split()[0]}, TL on {sys.platform})",
+            border_style="green",
+        ))
+    else:
+        console.print(Panel.fit(
+            f"[bold red]{failures} quick check(s) failed[/bold red] — see above",
+            border_style="red",
+        ))
+
+    # ------------------------------------------------------------------
+    # 7. End-to-end physics smoke test (automatic follow-up)
+    # ------------------------------------------------------------------
+    failures = _run_smoke(console, failures)
+
+    # ------------------------------------------------------------------
+    # Final summary
+    # ------------------------------------------------------------------
+    console.print()
+    if failures == 0:
+        console.print(Panel.fit("[bold green]All checks passed[/bold green]", border_style="green"))
+    else:
+        console.print(Panel.fit(
+            f"[bold red]{failures} check(s) failed[/bold red] — see above",
+            border_style="red",
+        ))
+    return 0 if failures == 0 else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(run_checks())

transitionlistener/ckm.py

@@ -0,0 +1,91 @@
+r"""
+Cabibbo–Kobayashi–Maskawa matrix helpers.
+
+The functions defined here provide ready-to-use parametrisations of the CKM
+matrix that can be shared between models.  The default implementation follows
+the Wolfenstein expansion,
+
+.. math::
+   V_{\mathrm{CKM}} \approx
+   \begin{pmatrix}
+     1 - \tfrac{1}{2}\lambda^2 & \lambda &
+     A \lambda^3 (\rho - i \eta) \\
+     -\lambda & 1 - \tfrac{1}{2}\lambda^2 & A \lambda^2 \\
+     A \lambda^3 \left(1 - \rho - i \eta\right) &
+     -A \lambda^2 & 1
+   \end{pmatrix},
+
+with higher-order terms resummed to guarantee unitarity.  The phases are
+returned as complex numbers so that downstream code can keep track of CP
+violating effects without additional bookkeeping.
+
+Part of TransitionListener v2.0
+Documentation: https://tasillo.de/TransitionListener/
+
+Authors:
+    Jonas Matuszak <jonas.matuszak@kit.edu>
+    Carlo Tasillo <carlo.tasillo@ific.uv.es>
+"""
+
+from __future__ import annotations
+
+import cmath
+import math
+from typing import Dict
+
+CKMElementMap = Dict[str, complex]
+
+
+def wolfenstein_ckm(
+    lambda_w: float = 0.22537,
+    A: float = 0.814,
+    rho: float = 0.117,
+    eta: float = 0.353,
+) -> CKMElementMap:
+    r"""
+    Return the CKM matrix elements in the Wolfenstein parametrisation.
+
+    Parameters
+    ----------
+    lambda_w:
+        Cabibbo angle expansion parameter :math:`\\lambda`.
+    A:
+        Overall strength of the 2–3 mixing.
+    rho:
+        Real part of the complex phase.
+    eta:
+        Imaginary part of the complex phase.
+
+    Returns
+    -------
+    dict[str, complex]
+        Mapping ``Vxy -> V_{xy}`` covering all nine CKM entries.
+    """
+
+    theta12 = math.asin(lambda_w)
+    theta23 = math.asin(A * lambda_w**2)
+    complex_phase = A * (lambda_w**3) * (rho + 1j * eta)
+    delta = cmath.phase(complex_phase)
+    theta13 = math.asin(abs(complex_phase))
+
+    Vud = math.cos(theta12) * math.cos(theta13)
+    Vus = math.sin(theta12) * math.cos(theta13)
+    Vub = math.sin(theta13) * cmath.exp(-1j * delta)
+    Vcd = -math.sin(theta12) * math.cos(theta23) - math.cos(theta12) * math.sin(theta23) * math.sin(theta13) * cmath.exp(1j * delta)
+    Vcs = math.cos(theta12) * math.cos(theta23) - math.sin(theta12) * math.sin(theta23) * math.sin(theta13) * cmath.exp(1j * delta)
+    Vcb = math.sin(theta23) * math.cos(theta13)
+    Vtd = math.sin(theta12) * math.sin(theta23) - math.cos(theta12) * math.cos(theta23) * math.sin(theta13) * cmath.exp(1j * delta)
+    Vts = -math.cos(theta12) * math.sin(theta23) - math.sin(theta12) * math.cos(theta23) * math.sin(theta13) * cmath.exp(1j * delta)
+    Vtb = math.cos(theta23) * math.cos(theta13)
+
+    return {
+        "Vud": Vud,
+        "Vus": Vus,
+        "Vub": Vub,
+        "Vcd": Vcd,
+        "Vcs": Vcs,
+        "Vcb": Vcb,
+        "Vtd": Vtd,
+        "Vts": Vts,
+        "Vtb": Vtb,
+    }

transitionlistener/colors.py

@@ -0,0 +1,288 @@
+"""Color palettes and Matplotlib helpers used across TransitionListener plots.
+
+The constants exposed here encode the corporate identity color palettes that the
+project uses for plots in the documentation as well as publication-quality
+figures. A couple of helper utilities are provided to make it easy to size
+figures consistently and to configure Matplotlib's global font settings.
+
+Part of TransitionListener v2.0
+Documentation: https://tasillo.de/TransitionListener/
+
+Authors:
+    Jonas Matuszak <jonas.matuszak@kit.edu>
+    Carlo Tasillo <carlo.tasillo@ific.uv.es>
+"""
+
+import matplotlib.pyplot as plt
+from matplotlib.colors import LinearSegmentedColormap
+from cycler import cycler
+
+RWTHblau = (0 / 255, 84 / 255, 159 / 255)
+RWTHblau75 = (0 / 255, 84 / 255, 159 / 255, 0.75)
+RWTHblau50 = (0 / 255, 84 / 255, 159 / 255, 0.5)
+RWTHblau25 = (0 / 255, 84 / 255, 159 / 255, 0.25)
+RWTHblau10 = (0 / 255, 84 / 255, 159 / 255, 0.1)
+RWTHblau20 = (0 / 255, 84 / 255, 159 / 255, 0.2)
+RWTHblau40 = (0 / 255, 84 / 255, 159 / 255, 0.4)
+RWTHblau30 = (0 / 255, 84 / 255, 159 / 255, 0.3)
+RWTHblau60 = (0 / 255, 84 / 255, 159 / 255, 0.6)
+RWTHschwarz = (0 / 255, 0 / 255, 0 / 255)
+RWTHmagenta = (227 / 255, 0 / 255, 102 / 255)
+RWTHgelb = (255 / 255, 237 / 255, 0 / 255)
+RWTHpetrol = (0 / 255, 97 / 255, 101 / 255)
+RWTHpetrol25 = (0 / 255, 97 / 255, 101 / 255, 0.25)
+RWTHtuerkis = (0 / 255, 152 / 255, 161 / 255)
+RWTHgruen = (87 / 255, 171 / 255, 39 / 255)
+RWTHgruen10 = (87 / 255, 171 / 255, 39 / 255, 0.1)
+RWTHgruen25 = (87 / 255, 171 / 255, 39 / 255, 0.25)
+RWTHmaigruen = (189 / 255, 205 / 255, 0 / 255)
+RWTHmaigruen25 = (189 / 255, 205 / 255, 0 / 255, 0.25)
+RWTHmaigruen50 = (189 / 255, 205 / 255, 0 / 255, 0.5)
+RWTHorange = (246 / 255, 168 / 255, 0 / 255)
+RWTHorange25 = (246 / 255, 168 / 255, 0 / 255, 0.25)
+RWTHorange50 = (246 / 255, 168 / 255, 0 / 255, 0.5)
+RWTHrot = (204 / 255, 7 / 255, 30 / 255)
+RWTHrot25 = (204 / 255, 7 / 255, 30 / 255, 0.25)
+RWTHrot50 = (204 / 255, 7 / 255, 30 / 255, 0.5)
+RWTHbordeaux = (161 / 255, 16 / 255, 53 / 255)
+RWTHbordeaux50 = (161 / 255, 16 / 255, 53 / 255, 0.5)
+RWTHbordeaux25 = (161 / 255, 16 / 255, 53 / 255, 0.25)
+RWTHbordeaux10 = (161 / 255, 16 / 255, 53 / 255, 0.1)
+RWTHviolett = (97 / 255, 33 / 255, 88 / 255)
+RWTHviolett50 = (97 / 255, 33 / 255, 88 / 255, 0.5)
+RWTHlila = (122 / 255, 111 / 255, 172 / 255)
+
+DESYcyan = (0 / 255, 159 / 255, 223 / 255)
+DESYcyan50 = (0 / 255, 159 / 255, 223 / 255, 0.5)
+DESYcyan25 = (0 / 255, 159 / 255, 223 / 255, 0.25)
+DESYcyan75 = (0 / 255, 159 / 255, 223 / 255, 0.75)
+DESYcyan10 = (0 / 255, 159 / 255, 223 / 255, 0.10)
+DESYrot = (230 / 255, 65 / 255, 35 / 255)
+DESYrot50 = (230 / 255, 65 / 255, 35 / 255, 0.5)
+DESYdunkelrot = (153 / 255, 0 / 255, 0 / 255)
+DESYorange = (241 / 255, 143 / 255, 31 / 255)
+DESYorange25 = (241 / 255, 143 / 255, 31 / 255, 0.25)
+DESYdunkelblau = (0 / 255, 74 / 255, 110 / 255)
+DESYaubergine = (139 / 255, 60 / 255, 126 / 255)
+DESYaubergine50 = (139 / 255, 60 / 255, 126 / 255, 0.5)
+DESYviolett = (146 / 255, 124 / 255, 184 / 255)
+DESYviolett50 = (146 / 255, 124 / 255, 184 / 255, 0.5)
+DESYlila = (82 / 255, 78 / 255, 156 / 255)
+DESYlila50 = (82 / 255, 78 / 255, 156 / 255, 0.5)
+DESYhellgruen = (122 / 255, 158 / 255, 31 / 255)
+DESYhellgruen50 = (122 / 255, 158 / 255, 31 / 255, 0.5)
+DESYtuerkis = (45 / 255, 164 / 255, 164 / 255)
+DESYmagenta = (208 / 255, 0 / 255, 111 / 255)
+DESYolive = (158 / 255, 150 / 255, 0 / 255)
+DESYhellbraun = (170 / 255, 132 / 255, 106 / 255)
+DESYdunkelbraun = (133 / 255, 88 / 255, 62 / 255)
+DESYdunkelolive = (89 / 255, 98 / 255, 29 / 255)
+DESYpetrol = (0 / 255, 106 / 255, 133 / 255)
+DESYgruen = (0 / 255, 168 / 255, 62 / 255)
+DESYgelb = (230 / 255, 169 / 255, 15 / 255)
+
+HumboldtGreen = (129 / 255, 238 / 255, 169 / 255)
+
+invisible = (255 / 255, 255 / 255, 255 / 255, 0)
+
+colors = [DESYcyan, DESYcyan25]
+cmapDESYcyan = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = [DESYorange, DESYorange25]
+cmapDESYorange = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = [DESYcyan25, DESYcyan]
+cmapNG = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = [DESYorange25, DESYorange]
+cmapIPTA = LinearSegmentedColormap.from_list("mycmap", colors)
+
+NG = DESYcyan
+IPTA = DESYorange
+
+
+colors = [DESYorange, DESYcyan]
+cmapDESYcyanorange = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = [
+    DESYpetrol,
+    DESYtuerkis,
+    DESYgruen,
+    DESYhellgruen,
+    DESYorange,
+    DESYrot,
+    DESYdunkelrot,
+    DESYviolett,
+    DESYlila,
+]
+cmapDESYrainbow = LinearSegmentedColormap.from_list("DESYrainbow", colors)
+
+colors = [
+    DESYorange,
+    HumboldtGreen
+]
+cmapTL = LinearSegmentedColormap.from_list("TL", colors)
+
+colors = [
+    DESYorange,
+    HumboldtGreen,
+    DESYcyan
+]
+cmapTL2 = LinearSegmentedColormap.from_list("TL2", colors)
+
+colors = [RWTHblau10, RWTHblau]
+cmapRWTHblau = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = [RWTHblau25, RWTHblau]
+cmapRWTHblau2 = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = [RWTHblau50, RWTHblau]
+cmapRWTHblau3 = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = [RWTHgruen10, RWTHgruen]
+cmapRWTHgruen = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = [DESYhellgruen, invisible]
+cmapDESYhellgruen = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = [RWTHbordeaux10, RWTHbordeaux]
+cmapRWTHbordeaux = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = [
+    RWTHpetrol,
+    RWTHtuerkis,
+    RWTHgruen,
+    RWTHmaigruen,
+    RWTHorange,
+    RWTHrot,
+    RWTHbordeaux,
+    RWTHviolett,
+    RWTHlila,
+]
+cmapRWTHrainbow = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = [
+    RWTHtuerkis,
+    RWTHgruen,
+    RWTHmaigruen,
+    RWTHorange,
+    RWTHrot,
+    RWTHbordeaux,
+    RWTHviolett,
+]
+cmapRWTHrainbow2 = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = [RWTHgruen, RWTHmaigruen, RWTHorange, RWTHrot, RWTHbordeaux, RWTHviolett]
+cmapRWTHrainbow3 = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = [RWTHblau, RWTHrot]
+cmapRWTHtemp = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = ["white", "white"]
+cmapWhite = LinearSegmentedColormap.from_list("mycmap", colors)
+
+colors = [
+    (255 / 255, 255 / 255, 255 / 255, 0),
+    (200 / 255, 200 / 255 / 255, 200 / 255, 0.1),
+    (150 / 255, 150 / 255, 150 / 255, 0.4),
+    (100 / 255, 100 / 255, 100 / 255, 0.5),
+    (50 / 255, 50 / 255, 50 / 255, 0.6),
+    (0, 0, 0, 0.75),
+]
+cmapGreyshade = LinearSegmentedColormap.from_list("mycmap", colors)
+
+
+def set_size(width: float | str, fraction : float = 1, subplots: tuple[int, int] = (1, 1)) -> tuple[float, float]:
+    """Return figure dimensions that avoid downstream scaling artefacts.
+
+    Parameters
+    ----------
+    width: float | str
+        Either the Matplotlib figure width in points or a preset identifier
+        such as ``\"JCAP\"`` or ``\"beamer\"`` that maps to a known text width.
+    fraction: float, optional
+        Fraction of the available width the figure should occupy. Defaults to
+        ``1`` which uses the full width.
+    subplots: tuple[int, int], optional
+        Tuple describing the subplot layout (rows, columns). The information is
+        used to slightly enlarge multi-panel figures so that axis labels do not
+        overlap.
+
+    Returns
+    -------
+    fig_dim: tuple[float, float]
+        Figure width and height in inches.
+    """
+    if width == "JCAP":
+        width_pt = 440.0
+    elif width == "beamer":
+        width_pt = 307.28987
+    else:
+        width_pt = width
+
+    # Width of figure (in pts)
+    fig_width_pt = width_pt * fraction
+
+    # Convert from pt to inches
+    inches_per_pt = 1 / 72.27
+
+    # Golden ratio to set aesthetic figure height
+    # https://disq.us/p/2940ij3
+    golden_ratio = (5**0.5 - 1) / 2
+
+    # Figure width in inches
+    fig_width_in = fig_width_pt * inches_per_pt
+
+    # Figure height in inches
+    if subplots == (1, 3):
+        fig_height_in = fig_width_in * golden_ratio / 2 * 1.2
+    elif subplots != (1, 1):
+        fig_height_in = (
+            fig_width_in * golden_ratio * 1.2
+        )  # to include title, some extra space
+    else:  # (1,1) case
+        fig_height_in = fig_width_in * golden_ratio
+
+    fig_dim = (fig_width_in, fig_height_in)
+
+    return fig_dim
+
+
+def set_font():
+    """Update Matplotlib's global ``rcParams`` with the project's stylistic defaults.
+
+    The configuration mirrors the publication layout used in the documentation:
+    LaTeX-rendered text, a sans-serif font family, harmonised font sizes for titles
+    and axis labels, and a colour cycle based on the DESY palette defined in this
+    module. Calling this function is idempotent and affects figures created
+    afterwards.
+    """
+    plt.rcParams.update(
+        {
+            "text.usetex": True,
+            "font.family": "sans-serif",
+            "font.sans-serif": ["DejaVu Sans", "Arial", "Liberation Sans"],
+            "mathtext.fontset": "dejavusans",
+            "axes.labelsize": 10,
+            "font.size": 10,
+            "axes.titlesize": 10,
+            "figure.titlesize": 10,
+            "legend.fontsize": 8,
+            "xtick.labelsize": 8,
+            "ytick.labelsize": 8,
+            "lines.markersize": 5,
+            "axes.prop_cycle": cycler(
+                color=[
+                    DESYcyan,
+                    DESYorange,
+                    DESYmagenta,
+                    DESYgruen,
+                    DESYrot,
+                    DESYdunkelblau,
+                    DESYviolett,
+                    DESYhellgruen,
+                    DESYgelb,
+                ]
+            ),
+        }
+    )