vacspin 0.1.0__py3-none-any.whl

vacspin/__init__.py

@@ -0,0 +1,47 @@
+"""vacspin: group-IV colour-centre spin-photon interfaces, end to end.
+
+From the strained spin Hamiltonian of a vacancy centre in diamond
+(SiV-, GeV-, SnV-, PbV-), through its optical transitions and
+cyclicity, the transition-resolved Purcell budget of a coupled
+cavity, to exact single-shot readout statistics and remote-
+entanglement rates -- with every physics claim in the test suite
+pinned to a closed form, a measured anchor, or two independent code
+paths.
+
+Methodological basis: T. M. Mahim, M. M. Rahman and A. S. M. Mohsin,
+"Fast single-shot readout of tin-vacancy spins with an overcoupled
+diamond nanocavity on thin-film lithium niobate" (submitted to Optics
+Express, 2026), and the effective-Hamiltonian and readout formalism of
+Rosenthal et al., PRX 13, 031022 (2023) and arXiv:2403.13110.
+"""
+from .params import (EmissionBudget, SpinParameters, siv_hepp2014,
+                     snv_emission, snv_rosenthal2023)
+from .hamiltonian import (GAMMA_GHZ_PER_T, h_manifold, lab_to_spin,
+                          qubit_frequency, qubit_frequency_perpendicular,
+                          solve, zero_field_splitting)
+from .transitions import (cyclicity, field_on_circle, rabi_rate,
+                          transition_strength, transition_table)
+from .cavity import (CavityInterface, lorentzian_suppression,
+                     purcell_max, xi_pol_overlap)
+from .readout import (fidelity, fidelity_threshold1, geometric_pmf,
+                      poisson_pmf, polarization_rate, readout_counts,
+                      required_efficiency, required_window)
+from .remote import barrett_kok_success, entanglement_rate
+
+__version__ = "0.1.0"
+__all__ = [
+    "SpinParameters", "EmissionBudget", "snv_rosenthal2023",
+    "snv_emission", "siv_hepp2014",
+    "GAMMA_GHZ_PER_T", "h_manifold", "lab_to_spin", "solve",
+    "zero_field_splitting", "qubit_frequency",
+    "qubit_frequency_perpendicular",
+    "transition_strength", "transition_table", "cyclicity", "rabi_rate",
+    "field_on_circle",
+    "purcell_max", "lorentzian_suppression", "xi_pol_overlap",
+    "CavityInterface",
+    "polarization_rate", "readout_counts", "fidelity_threshold1",
+    "geometric_pmf", "poisson_pmf", "fidelity", "required_efficiency",
+    "required_window",
+    "barrett_kok_success", "entanglement_rate",
+    "__version__",
+]

vacspin/cavity.py

@@ -0,0 +1,174 @@
+"""The cavity-coupled interface: transition-resolved Purcell budget.
+
+Everything between the spin and the detector, in the bad-cavity
+(Purcell) regime, following the transition-resolved conventions of
+Lee et al., arXiv:2511.05740 (Eqs. 1-10) as used by Mahim et al.
+(Optics Express, 2026) for the SnV-on-TFLN interface:
+
+    F_max = (3 / 4 pi^2) (lam/n)^3 Q_L / V         ideal Purcell factor
+    F_C   = 1 + (F_max - 1) xi_pol xi_pos          the coupled transition
+    F_C2  = same, suppressed by the cavity Lorentzian at the qubit
+            detuning (the spin-flipping partner)
+    zeta  = 1 + eta_q eta_DW eta_BR (F_C - 1)      lifetime reduction
+    beta  = eta_q eta_DW eta_BR F_C / zeta         photons into the mode
+    eta   = beta eta_wg T_link eta_chip eta_det    detected per decay
+    Lambda_cav = Lambda_0 zeta / zeta_flip         cavity-boosted cyclicity
+    g     = (1/2) sqrt(F_C kappa gamma_rad,C)      coupling rate, so that
+            F_C = 4 g^2 / (kappa gamma_rad,C) holds as an identity
+
+with V in units of (lam/n)^3 and kappa = f_cav / Q_L. `xi_pol_overlap`
+gives the polarisation overlap sin^2(theta) (1 + sin 2 psi)/2 of a
+<111> dipole with a linearly polarised cavity mode (2/3 at psi = 45 deg
+for <100>-oriented diamond).
+
+Validity is physics, not paperwork, so it is computed rather than
+assumed: the `validity` dict carries the bad-cavity, weak-coupling and
+spin-selectivity conditions, and `require_valid()` refuses -- with the
+failing conditions named -- instead of returning numbers whose
+derivation no longer applies.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+from .params import EmissionBudget
+
+__all__ = ["purcell_max", "lorentzian_suppression", "xi_pol_overlap",
+           "CavityInterface"]
+
+
+def purcell_max(q_loaded, v_rel):
+    """Ideal Purcell factor F = (3/4 pi^2) Q/V, V in (lam/n)^3."""
+    q, v = float(q_loaded), float(v_rel)
+    if q <= 0 or v <= 0:
+        raise ValueError("Q and V must be positive")
+    return 3.0 / (4.0 * np.pi ** 2) * q / v
+
+
+def lorentzian_suppression(delta_hz, f_cav_hz, q_loaded):
+    """Purcell reduction of a transition detuned by delta from the
+    cavity: L = 1 / (1 + (2 Q delta / f_cav)^2). Exactly 1 on
+    resonance and exactly 1/2 at delta = f_cav / (2 Q) = kappa/2."""
+    if f_cav_hz <= 0 or q_loaded <= 0:
+        raise ValueError("f_cav_hz and Q must be positive")
+    x = 2.0 * float(q_loaded) * float(delta_hz) / float(f_cav_hz)
+    return 1.0 / (1.0 + x * x)
+
+
+def xi_pol_overlap(theta_deg=54.7356, psi_deg=45.0):
+    """Polarisation overlap |mu_hat . e_cav|^2 of a <111> dipole with a
+    linearly polarised in-plane cavity mode:
+    sin^2(theta) (1 + sin 2 psi) / 2, equal to 2/3 at psi = 45 deg for
+    theta = arccos(1/sqrt 3) (a <100>-oriented sample)."""
+    th = np.deg2rad(float(theta_deg))
+    ps = np.deg2rad(float(psi_deg))
+    return float(np.sin(th) ** 2 * (1.0 + np.sin(2.0 * ps)) / 2.0)
+
+
+class CavityInterface:
+    """All derived quantities of one cavity-coupled colour centre.
+
+    Parameters
+    ----------
+    q_loaded : loaded quality factor of the cavity.
+    v_rel : mode volume in units of (lam/n)^3.
+    eta_wg : fraction of cavity decay leaving through the collection
+        port (kappa_wg / kappa_total), in [0, 1].
+    budget : `EmissionBudget` of the emitter (cited).
+    lambda0 : bare (no-cavity) cyclicity of the operating point --
+        compute it with `vacspin.cyclicity` from your spin parameters
+        and field, or measure it.
+    omega_q_hz : qubit frequency (Hz), the detuning of the
+        spin-flipping partner transition.
+    xi_pol, xi_pos : polarisation and position overlap of the emitter
+        with the cavity field, each in [0, 1].
+    t_link, eta_chip, eta_det : downstream transfer, routing and
+        detector efficiencies, each in [0, 1] (defaults 1: the
+        cavity-only budget).
+    delta_partner_hz : optional detuning of a competing SAME-spin
+        transition (e.g. the D line); when given, its Purcell factor
+        F_partner and the selectivity condition kappa < delta are
+        reported.
+
+    Everything is computed in __init__; `validity` holds the regime
+    checks and `require_valid()` refuses when any fails.
+    """
+
+    def __init__(self, q_loaded, v_rel, eta_wg, budget: EmissionBudget,
+                 lambda0, omega_q_hz, xi_pol, xi_pos=1.0,
+                 t_link=1.0, eta_chip=1.0, eta_det=1.0,
+                 delta_partner_hz=None):
+        for name, v in (("eta_wg", eta_wg), ("xi_pol", xi_pol),
+                        ("xi_pos", xi_pos), ("t_link", t_link),
+                        ("eta_chip", eta_chip), ("eta_det", eta_det)):
+            if not (0.0 <= float(v) <= 1.0):
+                raise ValueError(f"{name} must be in [0, 1]")
+        if lambda0 <= 0 or not np.isfinite(lambda0):
+            raise ValueError("lambda0 must be a finite positive "
+                             "cyclicity (compute or measure it)")
+        if omega_q_hz <= 0:
+            raise ValueError("omega_q_hz must be positive")
+        self.q = float(q_loaded)
+        self.v = float(v_rel)
+        self.budget = budget
+        self.f_cav_hz = 299792458.0 / (budget.zpl_nm * 1e-9)
+        self.kappa_hz = self.f_cav_hz / self.q
+        self.omega_q_hz = float(omega_q_hz)
+
+        a = budget.radiative_fraction
+        self.f_max = purcell_max(q_loaded, v_rel)
+        self.f_c = 1.0 + (self.f_max - 1.0) * xi_pol * xi_pos
+        lc2 = lorentzian_suppression(omega_q_hz, self.f_cav_hz, self.q)
+        self.f_c2 = 1.0 + (self.f_max - 1.0) * xi_pol * xi_pos * lc2
+        self.zeta = 1.0 + a * (self.f_c - 1.0)
+        zeta_flip = 1.0 + a * (self.f_c2 - 1.0)
+        self.gamma_cav = budget.gamma0 * self.zeta        # 1/s
+        self.tau_cav_s = 1.0 / self.gamma_cav
+        self.lambda_cav = float(lambda0) * self.zeta / zeta_flip
+        self.beta = a * self.f_c / self.zeta
+        self.eta_wg = float(eta_wg)
+        self.eta = (self.beta * self.eta_wg * float(t_link)
+                    * float(eta_chip) * float(eta_det))
+        # coupling rate defined so F_C = 4 g^2 / (kappa gamma_rad,C)
+        gamma_rad_c = budget.gamma0 * a                   # 1/s
+        self.g_hz = 0.5 * np.sqrt(self.f_c * self.kappa_hz * gamma_rad_c)
+        self.cooperativity = (4.0 * self.g_hz ** 2
+                              / (self.kappa_hz * budget.gamma0))
+        gamma_cav_hz = self.gamma_cav / (2.0 * np.pi)
+        self.validity = dict(
+            spin_selectivity=bool(gamma_cav_hz < omega_q_hz / 5.0),
+            bad_cavity=bool(gamma_cav_hz < self.kappa_hz / 10.0),
+            weak_coupling=bool(self.g_hz < self.kappa_hz / 10.0),
+        )
+        self.f_partner = None
+        if delta_partner_hz is not None:
+            self.f_partner = 1.0 + (self.f_max - 1.0) * xi_pol * xi_pos \
+                * lorentzian_suppression(delta_partner_hz,
+                                         self.f_cav_hz, self.q)
+            self.validity["partner_selectivity"] = \
+                bool(self.kappa_hz < float(delta_partner_hz))
+
+    def require_valid(self):
+        """Refuse -- naming the failed conditions -- unless every
+        regime assumption behind the formulas above holds."""
+        bad = [k for k, ok in self.validity.items() if not ok]
+        if bad:
+            raise ValueError(
+                "interface outside its regime of validity: "
+                f"{', '.join(bad)} failed. The Purcell/rate formulas "
+                "assume the bad-cavity, weak-coupling, spin-selective "
+                "regime; change Q_L, V or the operating point.")
+        return self
+
+    def summary(self):
+        out = dict(q_loaded=self.q, v_rel=self.v, f_max=self.f_max,
+                   f_c=self.f_c, f_c2=self.f_c2, zeta=self.zeta,
+                   tau_cav_ns=self.tau_cav_s * 1e9,
+                   lambda_cav=self.lambda_cav, beta=self.beta,
+                   eta=self.eta, g_mhz=self.g_hz / 1e6,
+                   kappa_ghz=self.kappa_hz / 1e9,
+                   cooperativity=self.cooperativity,
+                   validity=dict(self.validity))
+        if self.f_partner is not None:
+            out["f_partner"] = self.f_partner
+        return out

vacspin/hamiltonian.py

@@ -0,0 +1,132 @@
+"""The group-IV effective Hamiltonian: 4x4 per manifold, pure NumPy.
+
+Implements the effective ground/excited-manifold Hamiltonian shared by
+all group-IV vacancy centres in diamond, exactly as written for the
+SnV- in Rosenthal et al., Phys. Rev. X 13, 031022 (2023), Appendix B
+(Eqs. B1-B5), in the basis {|ex up>, |ex dn>, |ey up>, |ey dn>}
+(orbital doublet x spin 1/2):
+
+    H = H_SO + H_JT + H_Z + H_L
+
+    H_SO = -(lam/2) [[0, i], [-i, 0]] (x) sigma_z          (spin-orbit)
+    H_JT = [[Ux, Uy], [Uy, -Ux]] (x) 1                     (strain/JT)
+    H_Z  = (gamma/2) 1 (x) [[(1+2 delta) Bz, Bx - i By],
+                            [Bx + i By, -(1+2 delta) Bz]]  (spin Zeeman)
+    H_L  = (gamma f/2) Bz [[0, i], [-i, 0]] (x) 1     (orbital Zeeman)
+
+with all energies in GHz (angular frequency over 2 pi), fields in
+tesla, and gamma/2pi = 28.0 GHz/T the electron gyromagnetic ratio. The
+field enters in the SPIN FRAME whose z axis lies along the centre's
+<111> high-symmetry axis; `lab_to_spin` performs the exact rotation
+from your lab frame using the (theta, phi) of the parameter set.
+
+Exact structure this module's tests lean on rather than stored
+numbers: the Hamiltonian is Hermitian for every input; at zero field
+each manifold consists of two exact Kramers doublets split by the
+closed form Delta = sqrt(lam^2 + 4 (Ux^2 + Uy^2)); the perturbative
+qubit frequency for a purely transverse field (Rosenthal Eq. B9),
+f = 2 gamma B_perp Ups / Delta, agrees with full diagonalisation; and
+the frame rotation is exactly orthonormal, so |B| is preserved to
+machine precision.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+from .params import SpinParameters
+
+__all__ = ["GAMMA_GHZ_PER_T", "h_manifold", "lab_to_spin", "solve",
+           "zero_field_splitting", "qubit_frequency",
+           "qubit_frequency_perpendicular"]
+
+# electron gyromagnetic ratio gamma/2pi (GHz/T), gamma = g_s mu_B / hbar
+# with g_s ~ 2: the standard value used by Rosenthal et al. (2023).
+GAMMA_GHZ_PER_T = 28.0
+
+_I2 = np.eye(2)
+_SZ = np.array([[1.0, 0.0], [0.0, -1.0]])
+_ORB_Y = np.array([[0.0, 1j], [-1j, 0.0]])   # orbital angular momentum
+
+
+def h_manifold(lam, ups_x, ups_y, f, delta, b_spin):
+    """4x4 manifold Hamiltonian (GHz) for a field b_spin = (Bx, By, Bz)
+    in tesla, given in the spin frame."""
+    bx, by, bz = (float(b) for b in b_spin)
+    h_so = -0.5 * lam * np.kron(_ORB_Y, _SZ)
+    h_jt = np.kron(np.array([[ups_x, ups_y], [ups_y, -ups_x]]), _I2)
+    zee = np.array([[(1 + 2 * delta) * bz, bx - 1j * by],
+                    [bx + 1j * by, -(1 + 2 * delta) * bz]])
+    h_z = 0.5 * GAMMA_GHZ_PER_T * np.kron(_I2, zee)
+    h_l = 0.5 * GAMMA_GHZ_PER_T * f * bz * np.kron(_ORB_Y, _I2)
+    return h_so + h_jt + h_z + h_l
+
+
+def lab_to_spin(v_lab, theta_rad, phi_rad):
+    """Rotate a lab-frame vector into the spin frame whose z axis
+    points along the centre's <111> axis at polar angle theta, azimuth
+    phi. Rows of the rotation are the spin-frame basis vectors in the
+    lab frame; the rotation is exactly orthonormal."""
+    ct, st = np.cos(theta_rad), np.sin(theta_rad)
+    cp, sp = np.cos(phi_rad), np.sin(phi_rad)
+    ex = np.array([ct * cp, ct * sp, -st])
+    ey = np.array([-sp, cp, 0.0])
+    ez = np.array([st * cp, st * sp, ct])
+    return np.vstack([ex, ey, ez]) @ np.asarray(v_lab, dtype=float)
+
+
+def zero_field_splitting(lam, ups_x, ups_y=0.0):
+    """Exact zero-field splitting of one manifold:
+    Delta = sqrt(lam^2 + 4 (Ux^2 + Uy^2))."""
+    return float(np.sqrt(lam ** 2 + 4.0 * (ups_x ** 2 + ups_y ** 2)))
+
+
+def solve(params: SpinParameters, b_lab, strain_scale=1.0):
+    """Eigenstructure of both manifolds at a lab-frame field (tesla).
+
+    strain_scale multiplies the strain of both manifolds (the strain-
+    engineering axis); the strain axis is taken along x, which fixes
+    the azimuthal origin of the spin frame.
+
+    Returns (evals_g, evecs_g, evals_e, evecs_e): energies in GHz
+    sorted ascending, eigenvectors as columns.
+    """
+    if not np.all(np.isfinite(b_lab)):
+        raise ValueError("magnetic field must be finite")
+    s = float(strain_scale)
+    if s < 0:
+        raise ValueError("strain_scale must be >= 0")
+    bs = lab_to_spin(b_lab, params.theta_rad, params.phi_rad)
+    hg = h_manifold(params.lam_g, s * params.ups_g, 0.0,
+                    params.f_g, params.delta_g, bs)
+    he = h_manifold(params.lam_e, s * params.ups_e, 0.0,
+                    params.f_e, params.delta_e, bs)
+    eg, vg = np.linalg.eigh(hg)
+    ee, ve = np.linalg.eigh(he)
+    return eg, vg, ee, ve
+
+
+def qubit_frequency(params: SpinParameters, b_lab, strain_scale=1.0):
+    """Ground-state qubit frequency (GHz): the splitting of the lowest
+    Kramers doublet at the given lab-frame field."""
+    eg, _, _, _ = solve(params, b_lab, strain_scale)
+    return float(eg[1] - eg[0])
+
+
+def qubit_frequency_perpendicular(params: SpinParameters, b_perp_t,
+                                  manifold="ground"):
+    """Perturbative qubit frequency for a purely TRANSVERSE field
+    (Rosenthal et al. Eq. B9): f = 2 gamma B_perp Ups / Delta, valid
+    for gamma B_perp << Delta. The tests hold this against full
+    diagonalisation; use `qubit_frequency` for anything quantitative.
+    """
+    b = float(b_perp_t)
+    if b < 0:
+        raise ValueError("b_perp_t must be >= 0")
+    if manifold == "ground":
+        lam, ups = params.lam_g, params.ups_g
+    elif manifold == "excited":
+        lam, ups = params.lam_e, params.ups_e
+    else:
+        raise ValueError('manifold must be "ground" or "excited"')
+    delta = zero_field_splitting(lam, ups)
+    return 2.0 * GAMMA_GHZ_PER_T * b * ups / delta

vacspin/params.py

@@ -0,0 +1,188 @@
+"""Cited parameter sets for group-IV colour-centre spin-photon interfaces.
+
+No physical number in this package is made up, and none is accepted
+without a source: both dataclasses refuse to exist without a
+`reference`. Two sets ship, and each ships only what its source states:
+
+* `snv_rosenthal2023` / `snv_emission`: the negatively charged
+  tin-vacancy (SnV-) centre in diamond, the device-fit values of
+  Table I of J. A. Rosenthal et al., Phys. Rev. X 13, 031022 (2023)
+  (arXiv:2306.13199), with the ab initio orbital-quenching reduction
+  factors of G. Thiering and A. Gali, Phys. Rev. X 8, 021063 (2018),
+  and the emission budget of Rosenthal et al., arXiv:2403.13110
+  (lifetime, quantum efficiency) with the Debye-Waller factor of
+  Goerlitz et al. and the C/D branching ratio of Lee et al.,
+  arXiv:2511.05740. This set is validated against measured numbers in
+  the test suite (zero-field splittings, qubit frequency, cyclicity,
+  Rabi rate) with no free parameters.
+* `siv_hepp2014`: the silicon-vacancy (SiV-) centre, unstrained
+  spin-orbit splittings of C. Hepp et al., Phys. Rev. Lett. 112,
+  036405 (2014) (arXiv:1310.3106): 50 GHz ground, 260 GHz excited,
+  737 nm zero-phonon line. Strain and orbital quenching are
+  sample-specific and deliberately NOT shipped for SiV: the set
+  carries zero strain and zero quenching, stated in its reference
+  string, and you supply your measured values for field-dependent
+  work.
+
+For any other centre (GeV-, PbV-, or your own SnV sample), populate the
+dataclasses from your measurements or the literature; the mandatory
+`reference` field keeps the provenance attached to every prediction.
+"""
+from __future__ import annotations
+
+import dataclasses
+
+import numpy as np
+
+__all__ = ["SpinParameters", "EmissionBudget", "snv_rosenthal2023",
+           "snv_emission", "siv_hepp2014"]
+
+
+def _check_ref(reference):
+    if not isinstance(reference, str) or len(reference.strip()) < 8:
+        raise ValueError("a real `reference` string is required: every "
+                         "physical number in this package carries its "
+                         "source")
+
+
+@dataclasses.dataclass(frozen=True)
+class SpinParameters:
+    """Effective-Hamiltonian parameters of one group-IV centre.
+
+    All group-IV vacancy centres (SiV-, GeV-, SnV-, PbV-) share the
+    same D3d level structure: an orbital doublet times spin 1/2 in
+    each manifold, split by spin-orbit coupling and strain. Units:
+    every energy in GHz (angular frequency over 2 pi), fields in
+    tesla.
+
+    lam_g, lam_e : spin-orbit constants of ground/excited manifold.
+    ups_g, ups_e : Jahn-Teller/strain energies (the x component; the
+        strain axis fixes the azimuthal origin of the spin frame).
+    f_g, f_e : orbital Zeeman quenching factors (gL * p).
+    delta_g, delta_e : spin g-factor anisotropies (gL * delta_p).
+    theta_rad, phi_rad : polar and azimuthal angle of the centre's
+        high-symmetry <111> axis in your lab frame.
+    reference : where every number comes from. Required, on purpose.
+    """
+
+    lam_g: float
+    ups_g: float
+    lam_e: float
+    ups_e: float
+    f_g: float
+    f_e: float
+    delta_g: float
+    delta_e: float
+    theta_rad: float
+    phi_rad: float
+    reference: str
+
+    def __post_init__(self):
+        _check_ref(self.reference)
+        for name in ("lam_g", "lam_e"):
+            if getattr(self, name) <= 0:
+                raise ValueError(f"{name} must be positive (GHz)")
+        for name in ("ups_g", "ups_e"):
+            if getattr(self, name) < 0:
+                raise ValueError(f"{name} must be >= 0 (GHz); the strain "
+                                 "axis convention absorbs the sign")
+
+
+@dataclasses.dataclass(frozen=True)
+class EmissionBudget:
+    """Optical emission budget of one centre (bulk values).
+
+    tau0_s : total excited-state lifetime (s).
+    eta_q : radiative quantum efficiency in [0, 1].
+    eta_dw : Debye-Waller (zero-phonon) fraction in [0, 1].
+    eta_br : branching ratio into the cavity-coupled transition, [0, 1].
+    zpl_nm : zero-phonon-line wavelength (nm).
+    reference : where the numbers come from. Required.
+    """
+
+    tau0_s: float
+    eta_q: float
+    eta_dw: float
+    eta_br: float
+    zpl_nm: float
+    reference: str
+
+    def __post_init__(self):
+        _check_ref(self.reference)
+        if not (self.tau0_s > 0 and np.isfinite(self.tau0_s)):
+            raise ValueError("tau0_s must be a positive lifetime in s")
+        if not (self.zpl_nm > 0 and np.isfinite(self.zpl_nm)):
+            raise ValueError("zpl_nm must be a positive wavelength in nm")
+        for name in ("eta_q", "eta_dw", "eta_br"):
+            v = getattr(self, name)
+            if not (0.0 < v <= 1.0):
+                raise ValueError(f"{name} must be in (0, 1]")
+
+    @property
+    def gamma0(self):
+        """Total decay rate 1/tau0 (1/s)."""
+        return 1.0 / self.tau0_s
+
+    @property
+    def radiative_fraction(self):
+        """eta_q * eta_dw * eta_br: the fraction of decays that emit a
+        zero-phonon photon on the cavity-coupled transition."""
+        return self.eta_q * self.eta_dw * self.eta_br
+
+
+def snv_rosenthal2023() -> SpinParameters:
+    """SnV- device values, Table I of Rosenthal et al., Phys. Rev. X
+    13, 031022 (2023), with quenching reduction factors from Thiering
+    and Gali, Phys. Rev. X 8, 021063 (2018):
+    f = gL p, delta = gL delta_p. The dipole angles are the same
+    paper's device fit (theta fixed at 125.3 deg, phi fitted 37.33
+    deg). Validated against measured splittings, qubit frequency,
+    cyclicity and Rabi rate in this package's test suite."""
+    gL_g, gL_e = 0.363, 0.581
+    p_g, p_e = 0.471, 0.125
+    dp_g, dp_e = 0.042, 0.303
+    return SpinParameters(
+        lam_g=830.15, ups_g=177.67, lam_e=2988.0, ups_e=134.00,
+        f_g=gL_g * p_g, f_e=gL_e * p_e,
+        delta_g=gL_g * dp_g, delta_e=gL_e * dp_e,
+        theta_rad=np.deg2rad(125.3), phi_rad=np.deg2rad(37.33),
+        reference="Rosenthal et al., PRX 13, 031022 (2023), Table I "
+                  "(device values); quenching: Thiering & Gali, PRX 8, "
+                  "021063 (2018)")
+
+
+def snv_emission() -> EmissionBudget:
+    """SnV- emission budget: lifetime 4.5 ns and quantum efficiency
+    0.8 from Rosenthal et al., arXiv:2403.13110 (Table II);
+    Debye-Waller factor 0.57 (Goerlitz et al. 2020, as used by Lee et
+    al.); C/D branching ratio 0.75 (Lee et al., arXiv:2511.05740);
+    zero-phonon line 619 nm."""
+    return EmissionBudget(
+        tau0_s=4.5e-9, eta_q=0.80, eta_dw=0.57, eta_br=0.75,
+        zpl_nm=619.0,
+        reference="Rosenthal et al., arXiv:2403.13110 (tau, eta_q); "
+                  "Goerlitz et al. 2020 (eta_DW); Lee et al., "
+                  "arXiv:2511.05740 (eta_BR)")
+
+
+def siv_hepp2014(theta_rad=None, phi_rad=None) -> SpinParameters:
+    """SiV- unstrained model values of Hepp et al., PRL 112, 036405
+    (2014): spin-orbit splittings 50 GHz (ground) and 260 GHz
+    (excited) at zero strain. Strain and orbital quenching are
+    sample-specific and NOT shipped: this set carries ups = 0 and
+    f = delta = 0, stated here on purpose -- supply your measured
+    values for quantitative field-dependent work. Default orientation:
+    the <111> axis of a (001)-oriented sample (theta = arccos(1/sqrt 3),
+    phi = 45 deg), exact crystallography, overridable."""
+    if theta_rad is None:
+        theta_rad = float(np.arccos(1.0 / np.sqrt(3.0)))
+    if phi_rad is None:
+        phi_rad = float(np.pi / 4)
+    return SpinParameters(
+        lam_g=50.0, ups_g=0.0, lam_e=260.0, ups_e=0.0,
+        f_g=0.0, f_e=0.0, delta_g=0.0, delta_e=0.0,
+        theta_rad=theta_rad, phi_rad=phi_rad,
+        reference="Hepp et al., PRL 112, 036405 (2014): unstrained "
+                  "splittings 50/260 GHz, ZPL 737 nm; strain and "
+                  "orbital quenching deliberately not shipped (sample-"
+                  "specific) -- supply measured values")