physicskit 0.1.0__py3-none-any.whl

physicskit/particle/tests/test_collider.py

@@ -0,0 +1,119 @@
+import numpy as np
+import pytest
+
+from physicskit.particle.collider import (
+    charged_track_points,
+    cluster_into_jets,
+    flatten_shower,
+    parton_shower,
+    shower_leaves,
+    simple_shower,
+)
+from physicskit.particle.kinematics import FourVector
+
+
+def test_simple_shower_stops_immediately_when_daughter_masses_would_exceed_parent():
+    # daughter_fraction >= 0.5 means m1 + m2 >= m_parent for every split, so
+    # the shower must stop at the root without ever branching.
+    root = simple_shower(50.0, daughter_fraction=0.6, E_threshold=1.0, rng=np.random.default_rng(0))
+    assert root.is_leaf
+
+
+def test_simple_shower_conserves_energy_momentum_at_every_vertex():
+    rng = np.random.default_rng(0)
+    root = simple_shower(100.0, E_threshold=5.0, rng=rng)
+    for node in flatten_shower(root):
+        if not node.is_leaf:
+            c1, c2 = node.children
+            total = c1.four_vector + c2.four_vector
+            assert total.E == pytest.approx(node.four_vector.E, abs=1e-6)
+            assert total.p_vec == pytest.approx(node.four_vector.p_vec, abs=1e-6)
+
+
+def test_simple_shower_leaves_reconstruct_total_four_momentum():
+    rng = np.random.default_rng(1)
+    root = simple_shower(80.0, E_threshold=4.0, rng=rng)
+    leaves = shower_leaves(root)
+    assert len(leaves) >= 2
+    total_leaf = None
+    for leaf in leaves:
+        total_leaf = leaf.four_vector if total_leaf is None else total_leaf + leaf.four_vector
+    assert total_leaf.E == pytest.approx(root.four_vector.E, abs=1e-6)
+    assert total_leaf.p_vec == pytest.approx(root.four_vector.p_vec, abs=1e-6)
+
+
+def test_simple_shower_all_leaves_below_threshold_or_at_generation_cap():
+    rng = np.random.default_rng(2)
+    root = simple_shower(60.0, E_threshold=6.0, max_generations=6, rng=rng)
+    for leaf in shower_leaves(root):
+        assert leaf.four_vector.E < 6.0 or leaf.generation >= 6 or leaf.four_vector.mass < 1e-8
+
+
+def test_parton_shower_conserves_four_momentum():
+    rng = np.random.default_rng(3)
+    root = parton_shower(100.0, E_threshold=5.0, rng=rng)
+    leaves = shower_leaves(root)
+    total_leaf = None
+    for leaf in leaves:
+        total_leaf = leaf.four_vector if total_leaf is None else total_leaf + leaf.four_vector
+    assert total_leaf.E == pytest.approx(root.four_vector.E, abs=1e-6)
+    assert total_leaf.p_vec == pytest.approx(root.four_vector.p_vec, abs=1e-6)
+
+
+def test_parton_shower_flavor_conservation_rules():
+    rng = np.random.default_rng(4)
+    root = parton_shower(100.0, flavor0="q", E_threshold=5.0, rng=rng)
+    for node in flatten_shower(root):
+        if not node.is_leaf:
+            f1, f2 = node.children[0].flavor, node.children[1].flavor
+            if node.flavor in ("q", "qbar"):
+                assert node.flavor in (f1, f2)
+                assert "g" in (f1, f2)
+            elif node.flavor == "g":
+                assert {f1, f2} in ({"g"}, {"q", "qbar"})
+
+
+def test_cluster_into_jets_splits_back_to_back_particles_correctly():
+    rng = np.random.default_rng(5)
+    root = parton_shower(100.0, E_threshold=8.0, rng=rng)
+    leaves = shower_leaves(root)
+    jets = cluster_into_jets(leaves, n_jets=2)
+    assert len(jets) == 2
+    assert sum(len(j) for j in jets) == len(leaves)
+
+
+def test_charged_track_points_neutral_particle_is_a_straight_line():
+    p = FourVector(10.0, 3.0, 4.0, 5.0)
+    pts = charged_track_points(p, charge=0.0, B=1.0, path_length=2.5, n_points=10)
+    assert pts.shape == (10, 2)
+    direction = np.array([3.0, 4.0]) / 5.0
+    assert pts[-1] == pytest.approx(direction * 2.5)
+
+
+def test_charged_track_points_charged_particle_curves_with_correct_radius():
+    p = FourVector(10.0, 3.0, 0.0, 5.0)  # pT = 3
+    B = 2.0
+    charge = 1.0
+    r_expected = 3.0 / (charge * B)
+    pts = charged_track_points(p, charge=charge, B=B, path_length=r_expected * 0.5, n_points=50)
+
+    # reconstruct the radius of curvature from three points on the arc
+    # (the circumradius of any three points on a circle equals its radius).
+    def circumradius(a, b, c):
+        ab, bc, ca = np.linalg.norm(a - b), np.linalg.norm(b - c), np.linalg.norm(c - a)
+        s = (ab + bc + ca) / 2
+        area = max(s * (s - ab) * (s - bc) * (s - ca), 0.0) ** 0.5
+        return (ab * bc * ca) / (4 * area) if area > 0 else np.inf
+
+    r_reconstructed = circumradius(pts[0], pts[len(pts) // 2], pts[-1])
+    assert r_reconstructed == pytest.approx(r_expected, rel=1e-2)
+
+
+def test_charged_track_points_initial_direction_matches_momentum():
+    p = FourVector(10.0, 3.0, 4.0, 0.0)
+    for charge in (1.0, -1.0):
+        pts = charged_track_points(p, charge=charge, B=1.0, path_length=0.1, n_points=1000)
+        step = pts[1] - pts[0]
+        step_dir = step / np.linalg.norm(step)
+        expected_dir = np.array([3.0, 4.0]) / 5.0
+        assert step_dir == pytest.approx(expected_dir, abs=1e-2)

physicskit/particle/tests/test_confinement.py

@@ -0,0 +1,42 @@
+import numpy as np
+import pytest
+
+from physicskit.particle.confinement import string_break_chain, string_tension_energy
+
+
+def test_string_tension_energy_is_linear_in_r():
+    assert string_tension_energy(2.0, kappa=0.9) == pytest.approx(1.8)
+    assert string_tension_energy(-3.0, kappa=0.5) == pytest.approx(1.5)
+
+
+def test_string_break_chain_rejects_superluminal_speed():
+    with pytest.raises(ValueError):
+        string_break_chain(np.array([0.0, 1.0]), v=1.5, kappa=1.0, m_q=1.0)
+
+
+def test_string_break_chain_break_times_hit_exact_energy_threshold():
+    kappa, m_q, v = 1.0, 1.0, 0.5
+    fine_t = np.linspace(0, 20, 5000)
+    sim = string_break_chain(fine_t, v=v, kappa=kappa, m_q=m_q, n_breaks=3)
+    break_times = sim["break_times"]
+    assert len(break_times) == 3
+
+    # evaluate exactly at the analytic break times: total stored energy
+    # kappa*r must equal 2*m_q*k for the k-th break (k=1,2,3).
+    sim_at_breaks = string_break_chain(break_times, v=v, kappa=kappa, m_q=m_q, n_breaks=3)
+    for k in range(1, len(break_times) + 1):
+        assert sim_at_breaks["energy_total"][k - 1] == pytest.approx(2.0 * m_q * k, abs=1e-8)
+
+
+def test_string_break_chain_segment_count_increases_monotonically():
+    sim = string_break_chain(np.linspace(0, 20, 500), v=0.5, kappa=1.0, m_q=1.0, n_breaks=3)
+    assert np.all(np.diff(sim["n_segments"]) >= 0)
+    assert sim["n_segments"][0] == 1
+    assert sim["n_segments"][-1] <= 4
+
+
+def test_string_break_chain_energy_per_segment_never_much_exceeds_threshold():
+    sim = string_break_chain(np.linspace(0, 20, 2000), v=0.5, kappa=1.0, m_q=1.0, n_breaks=5)
+    # each segment's energy share should stay close to (at most a hair above) 2*m_q
+    # right up until the *next* break instantaneously resets the count.
+    assert np.all(sim["energy_per_segment"] <= 2.0 * sim["m_q"] + 1e-6)

physicskit/particle/tests/test_decays.py

@@ -0,0 +1,112 @@
+import numpy as np
+import pytest
+
+from physicskit.particle.decays import (
+    activity,
+    bateman_decay_chain,
+    decay_constant,
+    half_life,
+    michel_spectrum,
+    muon_decay_event,
+    radioactive_decay_number,
+    sample_michel_electron_energies,
+    two_body_decay,
+    two_body_decay_momentum,
+)
+from physicskit.particle.kinematics import invariant_mass
+
+
+def test_two_body_decay_momentum_forbidden_raises():
+    with pytest.raises(ValueError):
+        two_body_decay_momentum(1.0, 0.6, 0.6)
+
+
+def test_two_body_decay_reconstructs_parent_mass_and_is_back_to_back():
+    cases = [
+        (1.0, 0.4, 0.4, 1.0, 0.0),
+        (1.0, 0.4, 0.4, 0.0, 1.5),
+        (2.0, 0.5, 1.0, -0.3, 2.0),
+        (1.5, 0.1, 0.2, 0.7, 4.0),
+    ]
+    for M, m1, m2, cos_theta, phi in cases:
+        p1, p2 = two_body_decay(M, m1, m2, cos_theta, phi)
+        assert invariant_mass([p1, p2]) == pytest.approx(M)
+        assert (p1.p_vec + p2.p_vec) == pytest.approx([0.0, 0.0, 0.0], abs=1e-10)
+        assert p1.mass == pytest.approx(m1, abs=1e-8)
+        assert p2.mass == pytest.approx(m2, abs=1e-8)
+
+
+def test_decay_constant_half_life_roundtrip():
+    t_half = 5.0
+    lam = decay_constant(t_half)
+    assert half_life(lam) == pytest.approx(t_half)
+
+
+def test_radioactive_decay_number_matches_exponential_law():
+    N0, lam, t = 1000.0, 0.05, np.linspace(0, 20, 5)
+    N = radioactive_decay_number(N0, lam, t)
+    assert N == pytest.approx(N0 * np.exp(-lam * t))
+    assert radioactive_decay_number(N0, lam, 0.0) == pytest.approx(N0)
+
+
+def test_activity():
+    assert activity(200.0, 0.02) == pytest.approx(4.0)
+
+
+def test_bateman_chain_species_one_matches_simple_exponential():
+    N0, lam1, lam2 = 500.0, 0.3, 0.1
+    t = np.linspace(0, 10, 6)
+    N = bateman_decay_chain(N0, [lam1, lam2], t)
+    assert N[0] == pytest.approx(radioactive_decay_number(N0, lam1, t))
+
+
+def test_bateman_two_species_matches_textbook_closed_form():
+    N0, lam1, lam2 = 500.0, 0.3, 0.1
+    t = np.linspace(0, 10, 6)
+    N = bateman_decay_chain(N0, [lam1, lam2], t)
+    N2_expected = N0 * lam1 / (lam2 - lam1) * (np.exp(-lam1 * t) - np.exp(-lam2 * t))
+    assert N[1] == pytest.approx(N2_expected)
+
+
+def test_bateman_three_species_chain_shape_and_positivity():
+    N = bateman_decay_chain(1000.0, [0.5, 0.3, 0.1], np.linspace(0, 5, 10))
+    assert N.shape == (3, 10)
+    assert np.all(N >= -1e-8)
+
+
+def test_michel_spectrum_normalized_and_bounds():
+    x = np.linspace(0, 1, 200001)
+    assert np.trapezoid(michel_spectrum(x), x) == pytest.approx(1.0, abs=1e-4)
+    assert michel_spectrum(0.0) == pytest.approx(0.0)
+    assert michel_spectrum(1.0) == pytest.approx(2.0)
+    assert np.all(michel_spectrum(x) >= -1e-12)
+
+
+def test_sample_michel_electron_energies_matches_theoretical_mean():
+    rng = np.random.default_rng(42)
+    xs = sample_michel_electron_energies(50_000, rng=rng)
+    assert xs.min() >= 0.0
+    assert xs.max() <= 1.0
+    # <x> = integral x * 2x^2(3-2x) dx from 0 to 1 = 2*(3/4-2/5) = 7/10
+    assert xs.mean() == pytest.approx(0.7, abs=0.02)
+
+
+def test_muon_decay_event_conserves_energy_momentum_and_is_massless_neutrinos():
+    m_mu = 105.658
+    rng = np.random.default_rng(7)
+    for _ in range(20):
+        p_e, p_numu_bar, p_nue = muon_decay_event(m_mu, rng=rng)
+        total = p_e + p_numu_bar + p_nue
+        assert total.E == pytest.approx(m_mu, abs=1e-6)
+        assert total.p_vec == pytest.approx([0.0, 0.0, 0.0], abs=1e-6)
+        assert p_numu_bar.mass == pytest.approx(0.0, abs=1e-6)
+        assert p_nue.mass == pytest.approx(0.0, abs=1e-6)
+        assert 0.0 <= p_e.E <= m_mu / 2.0 + 1e-6
+
+
+def test_muon_decay_event_electron_energy_spectrum_matches_michel_mean():
+    m_mu = 105.658
+    rng = np.random.default_rng(3)
+    E_e = np.array([muon_decay_event(m_mu, rng=rng)[0].E for _ in range(20_000)])
+    x = 2.0 * E_e / m_mu
+    assert x.mean() == pytest.approx(0.7, abs=0.02)

physicskit/particle/tests/test_electroweak.py

@@ -0,0 +1,97 @@
+import numpy as np
+import pytest
+
+from physicskit.particle.electroweak import (
+    cp_asymmetry,
+    higgs_field_rollover,
+    higgs_potential,
+    higgs_vev,
+    meson_decay_rates_cp_eigenstate,
+    qed_dsigma_domega_mumu,
+    qed_total_cross_section_mumu,
+)
+from physicskit.particle.scattering import ALPHA_FS
+
+
+def test_higgs_potential_symmetric_and_zero_at_origin():
+    phi = np.linspace(-2, 2, 21)
+    assert higgs_potential(0.0, a=1.0, b=1.0) == pytest.approx(0.0)
+    assert higgs_potential(phi, a=1.0, b=1.0) == pytest.approx(higgs_potential(-phi, a=1.0, b=1.0))
+
+
+def test_higgs_vev_is_the_potential_minimum():
+    a, b = 2.0, 0.7
+    v = higgs_vev(a, b)
+    # V'(v) = -2a v + 4 b v^3 should vanish at the true minimum.
+    assert -2 * a * v + 4 * b * v**3 == pytest.approx(0.0, abs=1e-8)
+    assert higgs_potential(v, a, b) < higgs_potential(0.0, a, b)
+
+
+def test_higgs_field_rolls_from_unstable_point_into_a_true_vacuum():
+    a, b = 1.0, 1.0
+    t = np.linspace(0, 60, 600)
+    phi, phidot = higgs_field_rollover(1e-3, 0.0, a, b, t_eval=t, damping=0.08)
+    v = higgs_vev(a, b)
+    assert abs(phi[0]) < 1e-2
+    assert abs(abs(phi[-1]) - v) < 0.05
+    assert abs(phidot[-1]) < 0.1  # settled (small residual ringing), not still oscillating at full amplitude
+
+
+def test_higgs_field_symmetric_perturbation_sign_picks_the_side():
+    a, b = 1.0, 1.0
+    t = np.linspace(0, 60, 600)
+    phi_pos, _ = higgs_field_rollover(1e-3, 0.0, a, b, t_eval=t, damping=0.08)
+    phi_neg, _ = higgs_field_rollover(-1e-3, 0.0, a, b, t_eval=t, damping=0.08)
+    assert phi_pos[-1] > 0
+    assert phi_neg[-1] < 0
+
+
+def test_qed_dsigma_domega_symmetric_forward_backward():
+    vals_fwd = qed_dsigma_domega_mumu(np.array([0.3, 0.9]), sqrt_s=10.0)
+    vals_bwd = qed_dsigma_domega_mumu(np.array([-0.3, -0.9]), sqrt_s=10.0)
+    assert vals_fwd == pytest.approx(vals_bwd)
+
+
+def test_qed_dsigma_domega_integrates_to_total_cross_section():
+    sqrt_s = 15.0
+    cos_theta = np.linspace(-1, 1, 4001)
+    dsigma = qed_dsigma_domega_mumu(cos_theta, sqrt_s)
+    # integral over solid angle: 2*pi (azimuthal) * integral dcos_theta
+    sigma_numeric = 2 * np.pi * np.trapezoid(dsigma, cos_theta)
+    sigma_formula = qed_total_cross_section_mumu(sqrt_s)
+    assert sigma_numeric == pytest.approx(sigma_formula, rel=1e-4)
+
+
+def test_qed_total_cross_section_matches_alpha_fs_default():
+    sqrt_s = 20.0
+    expected = 4 * np.pi * ALPHA_FS**2 / (3 * sqrt_s**2)
+    assert qed_total_cross_section_mumu(sqrt_s) == pytest.approx(expected)
+
+
+def test_cp_asymmetry_vanishes_without_cp_violation():
+    t = np.linspace(0, 10, 50)
+    A = cp_asymmetry(t, delta_m=0.5, gamma_s=1.0, gamma_l=0.1, epsilon=0.0)
+    assert A == pytest.approx(np.zeros_like(t))
+
+
+def test_meson_decay_rates_are_equal_without_cp_violation():
+    t = np.linspace(0, 10, 50)
+    g, gbar = meson_decay_rates_cp_eigenstate(t, delta_m=0.5, gamma_s=1.0, gamma_l=0.1, epsilon=0.0)
+    assert g == pytest.approx(gbar)
+
+
+def test_cp_asymmetry_nonzero_and_bounded_with_cp_violation():
+    t = np.linspace(0, 10, 200)
+    eps = 0.002 * np.exp(1j * 0.7)
+    A = cp_asymmetry(t, delta_m=0.5, gamma_s=1.0, gamma_l=0.1, epsilon=eps)
+    assert np.any(np.abs(A) > 1e-6)
+    assert np.all(np.abs(A) <= 1.0 + 1e-8)
+
+
+def test_cp_asymmetry_decays_at_late_times_when_gamma_s_dominates():
+    t_early = np.array([0.1])
+    t_late = np.array([50.0])
+    eps = 0.01
+    A_early = cp_asymmetry(t_early, delta_m=1.0, gamma_s=5.0, gamma_l=0.05, epsilon=eps)
+    A_late = cp_asymmetry(t_late, delta_m=1.0, gamma_s=5.0, gamma_l=0.05, epsilon=eps)
+    assert abs(A_late[0]) < abs(A_early[0])

physicskit/particle/tests/test_kinematics.py

@@ -0,0 +1,138 @@
+import numpy as np
+import pytest
+
+from physicskit.particle.kinematics import FourVector, boost, boost_generic, boost_to_com, invariant_mass, rapidity
+
+
+def test_mass_of_rest_particle():
+    p = FourVector(1.5, 0.0, 0.0, 0.0)
+    assert p.mass == pytest.approx(1.5)
+    assert p.beta == pytest.approx(0.0)
+
+
+def test_boost_of_rest_frame_reproduces_boosted_energy_momentum():
+    m = 1.0
+    beta = 0.6
+    gamma = 1.0 / np.sqrt(1 - beta**2)
+    p_rest = FourVector(m, 0.0, 0.0, 0.0)
+    p_boosted = boost(p_rest, beta, axis="z")
+    assert p_boosted.E == pytest.approx(gamma * m)
+    assert p_boosted.pz == pytest.approx(gamma * m * beta)
+    assert p_boosted.mass == pytest.approx(m)
+
+
+def test_boost_is_invertible():
+    p = FourVector(3.0, 0.5, -0.2, 1.1)
+    beta = 0.4
+    for axis in ("x", "y", "z"):
+        p_back = boost(boost(p, beta, axis), -beta, axis)
+        assert p_back.E == pytest.approx(p.E)
+        assert p_back.px == pytest.approx(p.px)
+        assert p_back.py == pytest.approx(p.py)
+        assert p_back.pz == pytest.approx(p.pz)
+
+
+def test_invariant_mass_of_two_back_to_back_photons_like_particles():
+    p1 = FourVector(1.0, 0.0, 0.0, 0.6)
+    p2 = FourVector(1.0, 0.0, 0.0, -0.6)
+    assert invariant_mass([p1, p2]) == pytest.approx(2.0)
+
+
+def test_rapidity_is_additive_under_boost_along_same_axis():
+    p = FourVector(2.0, 0.1, 0.2, 1.0)
+    beta = 0.5
+    y0 = rapidity(p, axis="z")
+    y1 = rapidity(boost(p, beta, axis="z"), axis="z")
+    assert y1 == pytest.approx(y0 + np.arctanh(beta))
+
+
+def test_boost_to_com_of_symmetric_pair_is_zero():
+    p1 = FourVector(2.0, 0.0, 0.0, 1.0)
+    p2 = FourVector(2.0, 0.0, 0.0, -1.0)
+    beta_com = boost_to_com([p1, p2])
+    assert beta_com == pytest.approx([0.0, 0.0, 0.0])
+
+
+def test_boost_to_com_of_asymmetric_pair():
+    p1 = FourVector(2.0, 0.0, 0.0, 1.0)
+    p2 = FourVector(1.0, 0.0, 0.0, 0.0)
+    beta_com = boost_to_com([p1, p2])
+    assert beta_com == pytest.approx([0.0, 0.0, 1.0 / 3.0])
+
+
+def test_gamma_raises_for_massless_vector():
+    p = FourVector(1.0, 0.0, 0.0, 1.0)
+    assert p.mass == pytest.approx(0.0)
+    with pytest.raises(ZeroDivisionError):
+        _ = p.gamma
+
+
+def test_gamma_equals_energy_over_mass_for_massive_vector():
+    p = FourVector(2.0, 0.0, 0.0, 1.0)
+    assert p.gamma == pytest.approx(p.E / p.mass)
+
+
+def test_four_vector_repr_shows_components():
+    p = FourVector(1.0, 2.0, 3.0, 4.0)
+    assert repr(p) == "FourVector(E=1, px=2, py=3, pz=4)"
+
+
+def test_boost_rejects_invalid_beta_and_axis():
+    p = FourVector(1.0, 0.0, 0.0, 0.0)
+    with pytest.raises(ValueError, match="beta"):
+        boost(p, 1.5)
+    with pytest.raises(ValueError, match="axis"):
+        boost(p, 0.5, axis="w")
+
+
+def test_boost_generic_matches_axis_boost_when_aligned():
+    p = FourVector(3.0, 0.5, -0.2, 1.1)
+    beta = 0.45
+    for axis, vec in [("x", [beta, 0, 0]), ("y", [0, beta, 0]), ("z", [0, 0, beta])]:
+        pb_axis = boost(p, beta, axis=axis)
+        pb_generic = boost_generic(p, vec)
+        assert pb_generic.E == pytest.approx(pb_axis.E)
+        assert pb_generic.px == pytest.approx(pb_axis.px)
+        assert pb_generic.py == pytest.approx(pb_axis.py)
+        assert pb_generic.pz == pytest.approx(pb_axis.pz)
+
+
+def test_boost_generic_of_rest_particle_along_arbitrary_direction():
+    m = 2.0
+    beta_vec = np.array([0.3, -0.4, 0.2])
+    beta = np.linalg.norm(beta_vec)
+    gamma = 1.0 / np.sqrt(1 - beta**2)
+    p_rest = FourVector(m, 0.0, 0.0, 0.0)
+    pb = boost_generic(p_rest, beta_vec)
+    assert pb.E == pytest.approx(gamma * m)
+    assert pb.p_vec == pytest.approx(gamma * m * beta_vec)
+    assert pb.mass == pytest.approx(m)
+
+
+def test_boost_generic_is_invertible():
+    p = FourVector(3.0, 0.5, -0.2, 1.1)
+    beta_vec = np.array([0.1, 0.2, -0.3])
+    p_back = boost_generic(boost_generic(p, beta_vec), -beta_vec)
+    assert p_back.E == pytest.approx(p.E)
+    assert p_back.p_vec == pytest.approx(p.p_vec)
+
+
+def test_boost_generic_zero_velocity_is_identity():
+    p = FourVector(3.0, 0.5, -0.2, 1.1)
+    pb = boost_generic(p, [0.0, 0.0, 0.0])
+    assert pb.E == pytest.approx(p.E)
+    assert pb.p_vec == pytest.approx(p.p_vec)
+
+
+def test_boost_generic_rejects_superluminal_velocity():
+    with pytest.raises(ValueError):
+        boost_generic(FourVector(1.0, 0, 0, 0), [0.9, 0.9, 0.0])
+
+
+def test_add_and_sub():
+    p1 = FourVector(1.0, 0.1, 0.2, 0.3)
+    p2 = FourVector(2.0, -0.1, 0.0, 0.1)
+    s = p1 + p2
+    assert (s.E, s.px, s.py, s.pz) == pytest.approx((3.0, 0.0, 0.2, 0.4))
+    d = p1 - p2
+    assert (d.E, d.px, d.py, d.pz) == pytest.approx((-1.0, 0.2, 0.2, 0.2))

physicskit/particle/tests/test_neutrinos.py

@@ -0,0 +1,36 @@
+import numpy as np
+import pytest
+
+from physicskit.particle.neutrinos import oscillation_probability, survival_probability
+
+
+def test_oscillation_probability_vanishes_at_zero_baseline():
+    assert oscillation_probability(0.0, 1.0, theta=0.4, delta_m2=2.5e-3) == pytest.approx(0.0)
+
+
+def test_oscillation_probability_reaches_maximal_value_at_maximal_mixing():
+    theta = np.pi / 4  # sin^2(2 theta) = 1
+    delta_m2 = 2.5e-3
+    E = 1.0
+    L = (np.pi / 2) / (1.267 * delta_m2 / E)  # argument = pi/2 -> sin^2 = 1
+    assert oscillation_probability(L, E, theta, delta_m2) == pytest.approx(1.0, abs=1e-8)
+
+
+def test_probabilities_sum_to_one():
+    L = np.linspace(0, 2000, 50)
+    P_mu = oscillation_probability(L, E=1.0, theta=0.5, delta_m2=2.5e-3)
+    P_e = survival_probability(L, E=1.0, theta=0.5, delta_m2=2.5e-3)
+    assert P_mu + P_e == pytest.approx(np.ones_like(L))
+
+
+def test_no_mixing_gives_no_oscillation():
+    L = np.linspace(0, 1000, 20)
+    P_mu = oscillation_probability(L, E=1.0, theta=0.0, delta_m2=2.5e-3)
+    assert P_mu == pytest.approx(np.zeros_like(L))
+
+
+def test_oscillation_probability_is_periodic_in_L():
+    theta, delta_m2, E = 0.5, 2.5e-3, 1.0
+    period = np.pi * E / (1.267 * delta_m2)
+    L0 = 137.0
+    assert oscillation_probability(L0, E, theta, delta_m2) == pytest.approx(oscillation_probability(L0 + period, E, theta, delta_m2))

physicskit/particle/tests/test_nuclear.py

@@ -0,0 +1,45 @@
+import pytest
+
+from physicskit.particle.nuclear import binding_energy_per_nucleon, q_value, semf_binding_energy
+
+
+def test_iron_56_binding_energy_per_nucleon_near_known_maximum():
+    bpn = binding_energy_per_nucleon(26, 56)
+    assert 8.0 < bpn < 9.0
+
+
+def test_binding_energy_per_nucleon_lower_for_heavy_nucleus():
+    # Heavy nuclei (large Coulomb repulsion) are less tightly bound per
+    # nucleon than the iron-group peak.
+    bpn_fe = binding_energy_per_nucleon(26, 56)
+    bpn_u = binding_energy_per_nucleon(92, 238)
+    assert bpn_u < bpn_fe
+
+
+def test_binding_energy_per_nucleon_lower_for_very_light_nucleus():
+    bpn_fe = binding_energy_per_nucleon(26, 56)
+    bpn_he = binding_energy_per_nucleon(2, 4)
+    assert bpn_he < bpn_fe
+
+
+def test_pairing_term_sign():
+    # Even-even vs. odd-odd nuclei at the same A=14 differ only by the
+    # pairing term: Z=6 (N=8, even-even) should be more bound than
+    # Z=7 (N=7, odd-odd).
+    even_even = semf_binding_energy(6, 14)
+    odd_odd = semf_binding_energy(7, 14)
+    assert even_even > odd_odd
+
+
+def test_pairing_term_is_zero_for_odd_mass_number():
+    # A odd (mixed Z/N parity) takes the "no pairing correction" branch,
+    # unlike the even-even/odd-odd cases above.
+    N15 = semf_binding_energy(7, 15)  # Z=7 odd, N=8 even
+    O15 = semf_binding_energy(8, 15)  # Z=8 even, N=7 odd
+    assert N15 > 0 and O15 > 0
+
+
+def test_q_value_positive_for_dt_fusion():
+    Q = q_value([2.014102, 3.016049], [4.002602, 1.008665])
+    assert Q == pytest.approx(0.018884, abs=1e-6)
+    assert Q > 0

physicskit/particle/tests/test_scattering.py

@@ -0,0 +1,64 @@
+import numpy as np
+import pytest
+
+from physicskit.particle.kinematics import FourVector
+from physicskit.particle.scattering import (
+    ALPHA_FS,
+    impact_parameter,
+    mandelstam_s,
+    mandelstam_t,
+    mandelstam_u,
+    rutherford_dsigma_domega,
+)
+
+
+def test_mandelstam_sum_rule_for_a_2to2_process():
+    # elastic head-on-ish scattering: 1+2 -> 3+4, all equal mass m,
+    # constructed so that energy-momentum is manifestly conserved.
+    m = 0.5
+    E = 2.0
+    p = np.sqrt(E**2 - m**2)
+    p1 = FourVector(E, 0.0, 0.0, p)
+    p2 = FourVector(E, 0.0, 0.0, -p)
+    # outgoing particles rotated by some angle theta in the CM frame,
+    # same energy/momentum magnitude by symmetry (equal masses, elastic).
+    theta = 0.7
+    p3 = FourVector(E, p * np.sin(theta), 0.0, p * np.cos(theta))
+    p4 = FourVector(E, -p * np.sin(theta), 0.0, -p * np.cos(theta))
+
+    s = mandelstam_s(p1, p2)
+    t = mandelstam_t(p1, p3)
+    u = mandelstam_u(p1, p4)
+    mass_sum = p1.mass**2 + p2.mass**2 + p3.mass**2 + p4.mass**2
+    assert s + t + u == pytest.approx(mass_sum, abs=1e-8)
+
+
+def test_mandelstam_s_of_symmetric_pair():
+    p1 = FourVector(1.0, 0.0, 0.0, 0.6)
+    p2 = FourVector(1.0, 0.0, 0.0, -0.6)
+    assert mandelstam_s(p1, p2) == pytest.approx(4.0)
+
+
+def test_rutherford_functional_form_sin4_law():
+    thetas = np.linspace(0.2, 2.5, 8)
+    vals = rutherford_dsigma_domega(thetas, Z1=2, Z2=79, E_kin=5.0)
+    normalized = vals * np.sin(thetas / 2.0) ** 4
+    assert normalized == pytest.approx(normalized[0])
+
+
+def test_rutherford_diverges_at_zero_angle():
+    val = rutherford_dsigma_domega(0.0, Z1=1, Z2=1, E_kin=1.0)
+    assert np.isinf(val)
+
+
+def test_impact_parameter_limits():
+    b_head_on = impact_parameter(np.pi, Z1=1, Z2=79, E_kin=5.0)
+    assert b_head_on == pytest.approx(0.0, abs=1e-10)
+
+    b_small_angle = impact_parameter(1e-3, Z1=1, Z2=79, E_kin=5.0)
+    b_larger_angle = impact_parameter(1e-2, Z1=1, Z2=79, E_kin=5.0)
+    assert b_small_angle > b_larger_angle > 0
+
+
+def test_alpha_fs_value():
+    assert ALPHA_FS == pytest.approx(1 / 137.035999084)