physicskit 0.1.0__py3-none-any.whl

physicskit/relativity/tests/test_conservations.py

@@ -0,0 +1,54 @@
+import numpy as np
+
+from physicskit.relativity.chapters.kerr import KerrBlackHole
+from physicskit.relativity.chapters.schwarzschild import SchwarzschildBlackHole
+
+
+def test_circular_orbit_energy_and_angular_momentum_conserved():
+    bh = SchwarzschildBlackHole(M=1.0)
+    y0 = bh.circular_orbit_initial_state(r0=10.0)
+    traj = bh.integrate_geodesic(y0, dtau=0.02, n_steps=3000)
+    E0, L0 = traj["energy"][0], traj["angular_momentum"][0]
+    assert np.allclose(traj["energy"], E0, rtol=1e-5, atol=1e-5)
+    assert np.allclose(traj["angular_momentum"], L0, rtol=1e-5, atol=1e-5)
+
+
+def test_eccentric_orbit_energy_and_angular_momentum_conserved():
+    bh = SchwarzschildBlackHole(M=1.0)
+    y0 = bh.eccentric_orbit_initial_state(r0=20.0, eccentricity_boost=0.15)
+    traj = bh.integrate_geodesic(y0, dtau=0.02, n_steps=20000)
+    E0, L0 = traj["energy"][0], traj["angular_momentum"][0]
+    assert np.allclose(traj["energy"], E0, rtol=1e-5, atol=1e-5)
+    assert np.allclose(traj["angular_momentum"], L0, rtol=1e-5, atol=1e-5)
+    # a genuinely eccentric orbit should show radial oscillation
+    assert traj["r"].max() - traj["r"].min() > 1.0
+
+
+def test_null_geodesic_energy_and_angular_momentum_conserved():
+    bh = SchwarzschildBlackHole(M=1.0)
+    y0 = bh.null_geodesic_initial_state(r0=500.0, impact_parameter=20.0, ingoing=True)
+    traj = bh.integrate_geodesic(y0, dtau=0.5, n_steps=5000)
+    E0, L0 = traj["energy"][0], traj["angular_momentum"][0]
+    assert np.allclose(traj["energy"], E0, rtol=1e-5, atol=1e-5)
+    assert np.allclose(traj["angular_momentum"], L0, rtol=1e-5, atol=1e-5)
+
+
+def test_kerr_equatorial_circular_orbit_four_velocity_normalized():
+    bh = KerrBlackHole(M=1.0, a=0.7)
+    E, L = bh.circular_orbit_conserved_quantities(r0=10.0, prograde=True)
+    result = bh.integrate_equatorial_geodesic(r0=10.0, E=E, L=L, mu2=1.0, dtau=0.02, n_steps=3000)
+    assert np.allclose(result["norm"], -1.0, atol=1e-5)
+
+
+def test_kerr_equatorial_eccentric_orbit_four_velocity_normalized():
+    bh = KerrBlackHole(M=1.0, a=0.7)
+    E, L = bh.circular_orbit_conserved_quantities(r0=10.0, prograde=True)
+    result = bh.integrate_equatorial_geodesic(r0=10.0, E=E, L=L * 0.98, mu2=1.0, dtau=0.02, n_steps=6000)
+    assert np.allclose(result["norm"], -1.0, atol=1e-4)
+    assert result["r"].max() - result["r"].min() > 0.5
+
+
+def test_kerr_equatorial_null_geodesic_four_velocity_normalized():
+    bh = KerrBlackHole(M=1.0, a=0.5)
+    result = bh.integrate_equatorial_geodesic(r0=500.0, E=1.0, L=15.0, mu2=0.0, dtau=0.5, n_steps=5000)
+    assert np.allclose(result["norm"], 0.0, atol=1e-4)

physicskit/relativity/tests/test_constants.py

@@ -0,0 +1,34 @@
+"""Coverage for physicskit.relativity.utils.constants's simple geometrized-unit
+conversion functions (previously untested)."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from physicskit.relativity.utils.constants import (
+    C_SI,
+    geometrized_to_meters,
+    geometrized_to_seconds,
+    geometrized_to_solar_masses,
+    seconds_to_geometrized,
+    solar_masses_to_geometrized,
+)
+
+
+def test_geometrized_to_meters_is_the_identity():
+    assert geometrized_to_meters(5.0) == pytest.approx(5.0)
+
+
+def test_geometrized_to_seconds_divides_by_c():
+    assert geometrized_to_seconds(C_SI) == pytest.approx(1.0)
+
+
+def test_seconds_to_geometrized_is_the_inverse_of_geometrized_to_seconds():
+    t_s = 2.5
+    assert geometrized_to_seconds(seconds_to_geometrized(t_s)) == pytest.approx(t_s)
+    assert np.asarray(seconds_to_geometrized(t_s)).shape == ()
+
+
+def test_geometrized_to_solar_masses_is_the_inverse_of_solar_masses_to_geometrized():
+    assert geometrized_to_solar_masses(solar_masses_to_geometrized(30.0)) == pytest.approx(30.0, rel=1e-6)

physicskit/relativity/tests/test_cosmology.py

@@ -0,0 +1,61 @@
+import numpy as np
+import pytest
+
+from physicskit.relativity.chapters.cosmology import FLRWCosmology
+
+
+def test_flat_universe_omega_k_zero():
+    cosmo = FLRWCosmology(H0=70.0, Omega_m=0.3, Omega_r=0.0, Omega_Lambda=0.7)
+    assert cosmo.Omega_k == pytest.approx(0.0)
+
+
+def test_hubble_parameter_today_equals_H0():
+    cosmo = FLRWCosmology(H0=67.4, Omega_m=0.315, Omega_r=0.0, Omega_Lambda=0.685)
+    assert cosmo.hubble_parameter(1.0) == pytest.approx(67.4, rel=1e-6)
+
+
+def test_expansion_rate_decreases_going_back_from_matter_domination():
+    cosmo = FLRWCosmology(H0=70.0, Omega_m=0.3, Omega_r=0.0, Omega_Lambda=0.7)
+    # E(a) should be larger in the past (smaller a) for an expanding universe
+    assert cosmo.E(0.5) > cosmo.E(1.0)
+
+
+def test_redshift_scale_factor_roundtrip():
+    cosmo = FLRWCosmology()
+    z = 2.5
+    a = cosmo.redshift_to_scale_factor(z)
+    assert cosmo.scale_factor_to_redshift(a) == pytest.approx(z)
+
+
+def test_age_of_universe_is_physically_reasonable():
+    cosmo = FLRWCosmology(H0=70.0, Omega_m=0.3, Omega_r=0.0, Omega_Lambda=0.7)
+    age = cosmo.age_gyr()
+    assert 12.0 < age < 15.0
+
+
+def test_age_increases_with_scale_factor():
+    cosmo = FLRWCosmology(H0=70.0, Omega_m=0.3, Omega_r=0.0, Omega_Lambda=0.7)
+    assert cosmo.age_gyr(0.5) < cosmo.age_gyr(1.0) < cosmo.age_gyr(1.5)
+
+
+def test_comoving_distance_increases_with_redshift():
+    cosmo = FLRWCosmology(H0=70.0, Omega_m=0.3, Omega_r=0.0, Omega_Lambda=0.7)
+    d1 = cosmo.comoving_distance_mpc(0.5)
+    d2 = cosmo.comoving_distance_mpc(1.0)
+    d3 = cosmo.comoving_distance_mpc(2.0)
+    assert 0.0 < d1 < d2 < d3
+
+
+def test_luminosity_distance_exceeds_comoving_distance_at_nonzero_redshift():
+    cosmo = FLRWCosmology(H0=70.0, Omega_m=0.3, Omega_r=0.0, Omega_Lambda=0.7)
+    z = 1.0
+    assert cosmo.luminosity_distance_mpc(z) == pytest.approx((1.0 + z) * cosmo.comoving_distance_mpc(z))
+    assert cosmo.luminosity_distance_mpc(z) > cosmo.comoving_distance_mpc(z)
+
+
+def test_scale_factor_history_shape():
+    cosmo = FLRWCosmology(H0=70.0, Omega_m=0.3, Omega_r=0.0, Omega_Lambda=0.7)
+    t_gyr, a = cosmo.scale_factor_history(n_points=50)
+    assert t_gyr.shape == (50,)
+    assert a.shape == (50,)
+    assert np.all(np.diff(t_gyr) > 0.0)  # age monotonically increases with scale factor

physicskit/relativity/tests/test_gw_merger.py

@@ -0,0 +1,117 @@
+import numpy as np
+import pytest
+
+from physicskit.relativity.chapters.gw_merger import BinaryMerger
+
+
+def test_chirp_mass_equal_mass_case():
+    merger = BinaryMerger(m1=30.0, m2=30.0, distance=1000.0)
+    # for equal masses, chirp mass = m * 2^(-1/5)
+    assert merger.chirp_mass == pytest.approx(30.0 * 2.0 ** (-1.0 / 5.0), rel=1e-10)
+
+
+def test_symmetric_mass_ratio_bounds():
+    equal = BinaryMerger(m1=20.0, m2=20.0, distance=1.0)
+    unequal = BinaryMerger(m1=50.0, m2=5.0, distance=1.0)
+    assert equal.symmetric_mass_ratio == pytest.approx(0.25)
+    assert unequal.symmetric_mass_ratio < 0.25
+
+
+def test_inspiral_frequency_increases_toward_merger():
+    merger = BinaryMerger(m1=30.0, m2=25.0, distance=1000.0)
+    t = np.linspace(-2.0, -0.01, 200)
+    f = merger.inspiral_frequency(t, t_merger=0.0)
+    assert np.all(np.diff(f) > 0.0)
+
+
+def test_inspiral_phase_matches_frequency_derivative():
+    merger = BinaryMerger(m1=30.0, m2=25.0, distance=1000.0)
+    t = np.linspace(-2.0, -0.5, 1000)
+    dt = t[1] - t[0]
+    phase = merger.inspiral_phase(t, t_merger=0.0)
+    f_from_phase = np.gradient(phase, dt) / (2.0 * np.pi)
+    f_formula = merger.inspiral_frequency(t, t_merger=0.0)
+    assert np.allclose(f_from_phase, f_formula, rtol=1e-3)
+
+
+def test_inspiral_strain_shapes_and_finite():
+    merger = BinaryMerger(m1=30.0, m2=25.0, distance=1000.0, inclination=0.5)
+    t = np.linspace(-2.0, -0.1, 300)
+    hp, hc = merger.inspiral_strain(t, t_merger=0.0)
+    assert hp.shape == t.shape
+    assert hc.shape == t.shape
+    assert np.all(np.isfinite(hp))
+    assert np.all(np.isfinite(hc))
+
+
+def test_face_on_gives_constant_envelope_circular_polarization():
+    # face-on (inclination=0): h_plus and h_cross combine into a constant
+    # envelope (cos^2(phase) + sin^2(phase) = 1) equal to the raw amplitude.
+    merger = BinaryMerger(m1=30.0, m2=25.0, distance=1000.0, inclination=0.0)
+    t = np.array([-0.5])
+    hp, hc = merger.inspiral_strain(t, t_merger=0.0)
+    amp = (4.0 / merger.distance) * merger.chirp_mass ** (5.0 / 3.0) * (np.pi * merger.inspiral_frequency(t, 0.0)) ** (2.0 / 3.0)
+    assert np.hypot(hp, hc)[0] == pytest.approx(amp[0], rel=1e-6)
+
+
+def test_qnm_frequency_and_damping_positive():
+    merger = BinaryMerger(m1=30.0, m2=25.0, distance=1000.0)
+    f_qnm, tau_damp = merger.qnm_frequency_damping()
+    assert f_qnm > 0.0
+    assert tau_damp > 0.0
+
+
+def test_ringdown_strain_decays():
+    merger = BinaryMerger(m1=30.0, m2=25.0, distance=1000.0)
+    t = np.linspace(0.0, 500.0, 500)
+    hp, hc = merger.ringdown_strain(t, t_merger=0.0, amplitude=1.0)
+    envelope = np.hypot(hp, hc)
+    assert envelope[0] >= envelope[-1]
+    assert np.all(np.isfinite(envelope))
+
+
+def test_full_waveform_continuous_and_finite():
+    merger = BinaryMerger(m1=30.0, m2=25.0, distance=1000.0)
+    t = np.linspace(-1.0, 0.05, 500)
+    hp, hc = merger.full_waveform(t, t_merger=0.0)
+    assert np.all(np.isfinite(hp))
+    assert np.all(np.isfinite(hc))
+    assert hp.shape == t.shape
+
+
+def test_remnant_mass_less_than_total_mass():
+    merger = BinaryMerger(m1=30.0, m2=25.0, distance=1000.0)
+    M_f, a_f = merger.remnant_estimate()
+    assert 0.0 < M_f < merger.total_mass
+    assert 0.0 <= a_f < M_f
+
+
+def test_orbital_period_matches_keplers_third_law():
+    merger = BinaryMerger(m1=1.4, m2=1.4, distance=1.0)
+    a = 1.0e6
+    P = merger.orbital_period(a)
+    assert pytest.approx(2.0 * np.pi * np.sqrt(a**3 / merger.total_mass)) == P
+
+
+def test_semi_major_axis_decay_rate_is_negative_and_grows_with_eccentricity():
+    merger = BinaryMerger(m1=1.4, m2=1.4, distance=1.0)
+    a = 1.0e6
+    rate_circular = merger.semi_major_axis_decay_rate(a, eccentricity=0.0)
+    rate_eccentric = merger.semi_major_axis_decay_rate(a, eccentricity=0.6)
+    assert rate_circular < 0.0
+    assert abs(rate_eccentric) > abs(rate_circular)
+
+
+def test_hulse_taylor_pulsar_period_decay_matches_observation():
+    # PSR B1913+16: the discovery that won Hulse and Taylor the 1993 Nobel
+    # Prize. Predicted GR period decay should match the observed
+    # -2.4056e-12 (dimensionless, s/s) to within a few percent.
+    import physicskit.relativity.utils.constants as const
+
+    m1 = const.solar_masses_to_geometrized(1.4398)
+    m2 = const.solar_masses_to_geometrized(1.3886)
+    psr = BinaryMerger(m1=m1, m2=m2, distance=1.0)
+    period_s = 27906.98
+    a = (psr.total_mass * (period_s * const.C_SI) ** 2 / (4.0 * np.pi**2)) ** (1.0 / 3.0)
+    dPdt = psr.period_decay_rate(a, eccentricity=0.6171338)
+    assert dPdt == pytest.approx(-2.4056e-12, rel=0.05)

physicskit/relativity/tests/test_kerr.py

@@ -0,0 +1,116 @@
+import numpy as np
+import pytest
+
+from physicskit.relativity.chapters.kerr import KerrBlackHole
+
+
+def test_schwarzschild_limit_a_zero():
+    bh = KerrBlackHole(M=2.0, a=0.0)
+    assert bh.outer_horizon_radius == pytest.approx(4.0)
+    assert bh.inner_horizon_radius == pytest.approx(0.0)
+    assert bh.ergosphere_radius(np.pi / 2.0) == pytest.approx(4.0)
+    assert bh.isco_radius(prograde=True) == pytest.approx(12.0)
+    assert bh.isco_radius(prograde=False) == pytest.approx(12.0)
+
+
+def test_invalid_spin_raises():
+    with pytest.raises(ValueError):
+        KerrBlackHole(M=1.0, a=1.0)
+    with pytest.raises(ValueError):
+        KerrBlackHole(M=1.0, a=-0.1)
+
+
+def test_prograde_isco_smaller_than_retrograde():
+    bh = KerrBlackHole(M=1.0, a=0.9)
+    assert bh.isco_radius(prograde=True) < 6.0
+    assert bh.isco_radius(prograde=False) > 6.0
+    assert bh.isco_radius(prograde=True) < bh.isco_radius(prograde=False)
+
+
+def test_isco_approaches_horizon_for_extremal_spin():
+    # convergence to r_ISCO -> M is slow (a power law in 1-a/M) near extremality,
+    # so this only checks the qualitative trend, not tight numerical convergence.
+    moderate = KerrBlackHole(M=1.0, a=0.9)
+    near_extremal = KerrBlackHole(M=1.0, a=0.9999)
+    assert moderate.isco_radius(prograde=True) > near_extremal.isco_radius(prograde=True) > 1.0
+    assert near_extremal.isco_radius(prograde=True) == pytest.approx(1.0, abs=0.15)
+
+
+def test_ergosphere_contains_horizon_and_widest_at_equator():
+    bh = KerrBlackHole(M=1.0, a=0.8)
+    assert bh.ergosphere_radius(np.pi / 2.0) == pytest.approx(2.0)
+    assert bh.ergosphere_radius(0.0) == pytest.approx(bh.outer_horizon_radius)
+    assert bh.ergosphere_radius(np.pi / 2.0) > bh.outer_horizon_radius
+
+
+def test_is_inside_ergosphere():
+    bh = KerrBlackHole(M=1.0, a=0.8)
+    r_mid = (bh.outer_horizon_radius + bh.ergosphere_radius(np.pi / 2.0)) / 2.0
+    assert bh.is_inside_ergosphere(r_mid, np.pi / 2.0)
+    assert not bh.is_inside_ergosphere(bh.ergosphere_radius(np.pi / 2.0) + 1.0, np.pi / 2.0)
+
+
+def test_frame_dragging_positive_and_decays_at_large_r():
+    bh = KerrBlackHole(M=1.0, a=0.9)
+    r = np.array([3.0, 10.0, 100.0, 1000.0])
+    omega = bh.frame_dragging_angular_velocity(r)
+    assert np.all(omega > 0.0)
+    assert np.all(np.diff(omega) < 0.0)  # monotonically decreasing with r
+    # asymptotic Lense-Thirring rate omega ~ 2Ma/r^3
+    assert omega[-1] == pytest.approx(2.0 * bh.M * bh.a / r[-1] ** 3, rel=1e-3)
+
+
+def test_max_penrose_efficiency_bounds():
+    schwarzschild_limit = KerrBlackHole(M=1.0, a=0.0)
+    assert schwarzschild_limit.max_penrose_efficiency() == pytest.approx(0.0)
+
+    extremal = KerrBlackHole(M=1.0, a=0.999999)
+    assert extremal.max_penrose_efficiency() == pytest.approx(1.0 - 1.0 / np.sqrt(2.0), abs=1e-3)
+
+
+def test_penrose_energy_gain():
+    bh = KerrBlackHole(M=1.0, a=0.9)
+    e_out = bh.penrose_energy_gain(initial_energy=1.0, fragment_energy_infalling=-0.1)
+    assert e_out == pytest.approx(1.1)
+    with pytest.raises(ValueError):
+        bh.penrose_energy_gain(initial_energy=1.0, fragment_energy_infalling=0.1)
+
+
+def test_circular_orbit_conserved_quantities_reduce_to_schwarzschild():
+    bh = KerrBlackHole(M=1.0, a=1e-8)
+    E, L = bh.circular_orbit_conserved_quantities(r0=10.0, prograde=True)
+    r = 10.0
+    # Schwarzschild circular-orbit specific energy and angular momentum
+    E_schw = (1.0 - 2.0 / r) / np.sqrt(1.0 - 3.0 / r)
+    L_schw = np.sqrt(r) / np.sqrt(1.0 - 3.0 / r)
+    assert pytest.approx(E_schw, rel=1e-5) == E
+    assert pytest.approx(L_schw, rel=1e-5) == L
+
+
+def test_keplerian_angular_velocity_reduces_to_schwarzschild_at_zero_spin():
+    bh = KerrBlackHole(M=1.0, a=0.0)
+    r = 10.0
+    assert bh.keplerian_angular_velocity(r, prograde=True) == pytest.approx(np.sqrt(1.0 / r**3))
+
+
+def test_keplerian_angular_velocity_retrograde_requires_larger_magnitude():
+    # Frame dragging effectively supplies "free" angular velocity to a
+    # prograde orbiter, so it needs a smaller coordinate Omega to stay on a
+    # circular geodesic at the same r; a retrograde orbiter fights the
+    # dragging and needs a larger |Omega|.
+    bh = KerrBlackHole(M=1.0, a=0.9)
+    omega_pro = bh.keplerian_angular_velocity(10.0, prograde=True)
+    omega_retro = bh.keplerian_angular_velocity(10.0, prograde=False)
+    assert omega_pro > 0.0
+    assert omega_retro < 0.0
+    assert abs(omega_retro) > omega_pro
+
+
+def test_kerr_disk_redshift_factor_doppler_asymmetry():
+    bh = KerrBlackHole(M=1.0, a=0.7)
+    r = 10.0
+    g_receding = bh.disk_redshift_factor(r, impact_parameter=-5.0)
+    g_none = bh.disk_redshift_factor(r, impact_parameter=0.0)
+    g_approaching = bh.disk_redshift_factor(r, impact_parameter=5.0)
+    assert g_receding < g_none < g_approaching
+    assert g_none < 1.0

physicskit/relativity/tests/test_kerr_raytracer.py

@@ -0,0 +1,103 @@
+import numpy as np
+import pytest
+
+from physicskit.relativity.core.kerr_raytracer import render_kerr_shadow_image
+
+
+def test_zero_spin_shadow_matches_schwarzschild_theory():
+    outcomes, _hit_radii = render_kerr_shadow_image(
+        ny=90,
+        nx=90,
+        screen_half_width=15.0,
+        screen_half_height=15.0,
+        r_observer=200.0,
+        theta_observer=1.3,
+        a=0.0,
+        M=1.0,
+        r_disk_inner=1.0,
+        r_disk_outer=0.0,
+    )
+    captured_frac = np.mean(outcomes == 1)
+    expected = np.pi * (3.0 * np.sqrt(3.0)) ** 2 / (30.0**2)
+    assert captured_frac == pytest.approx(expected, rel=0.15)
+
+
+def test_central_ray_is_captured():
+    # a purely radial (alpha=beta=0) ray must plunge straight through the horizon;
+    # a 3x3 grid puts the exact center pixel (index [1, 1]) at alpha=beta=0.
+    outcomes, _ = render_kerr_shadow_image(
+        ny=3,
+        nx=3,
+        screen_half_width=1.0,
+        screen_half_height=1.0,
+        r_observer=200.0,
+        theta_observer=1.3,
+        a=0.7,
+        M=1.0,
+        r_disk_inner=1.0,
+        r_disk_outer=0.0,
+    )
+    assert outcomes[1, 1] == 1
+
+
+@pytest.mark.slow
+def test_shadow_area_shrinks_and_shifts_with_spin():
+    fractions = []
+    shifts = []
+    for a in [0.0, 0.5, 0.9]:
+        outcomes, _ = render_kerr_shadow_image(
+            ny=70,
+            nx=70,
+            screen_half_width=15.0,
+            screen_half_height=15.0,
+            r_observer=200.0,
+            theta_observer=1.3,
+            a=a,
+            M=1.0,
+            r_disk_inner=1.0,
+            r_disk_outer=0.0,
+        )
+        captured = outcomes == 1
+        fractions.append(np.mean(captured))
+        cols = np.where(captured.any(axis=0))[0]
+        shifts.append((cols.min() + cols.max()) / 2.0 - (outcomes.shape[1] - 1) / 2.0)
+
+    # known qualitative Kerr shadow behavior: shrinks and shifts toward
+    # positive alpha (the frame-dragging direction) as spin increases
+    assert fractions[0] > fractions[1] > fractions[2]
+    assert shifts[0] < shifts[1] < shifts[2]
+
+
+def test_disk_hits_stay_within_disk_bounds():
+    outcomes, hit_radii = render_kerr_shadow_image(
+        ny=90,
+        nx=90,
+        screen_half_width=20.0,
+        screen_half_height=20.0,
+        r_observer=200.0,
+        theta_observer=1.3,
+        a=0.9,
+        M=1.0,
+        r_disk_inner=2.32,
+        r_disk_outer=15.0,
+    )
+    disk_mask = outcomes == 3
+    assert np.any(disk_mask)
+    assert np.all(hit_radii[disk_mask] >= 2.32 - 1.0e-6)
+    assert np.all(hit_radii[disk_mask] <= 15.0 + 1.0e-6)
+
+
+def test_all_outcomes_are_valid_codes():
+    outcomes, _ = render_kerr_shadow_image(
+        ny=30,
+        nx=30,
+        screen_half_width=15.0,
+        screen_half_height=15.0,
+        r_observer=200.0,
+        theta_observer=1.0,
+        a=0.5,
+        M=1.0,
+        r_disk_inner=1.0,
+        r_disk_outer=0.0,
+    )
+    assert np.all((outcomes >= 0) & (outcomes <= 3))

physicskit/relativity/tests/test_lensing.py

@@ -0,0 +1,75 @@
+import numpy as np
+import pytest
+
+from physicskit.relativity.chapters.lensing import PointMassLens, exact_deflection_angle
+from physicskit.relativity.chapters.schwarzschild import SchwarzschildBlackHole
+
+
+def test_einstein_ring_at_perfect_alignment():
+    lens = PointMassLens(M=1.0, D_L=1000.0, D_S=2000.0)
+    theta_plus, theta_minus = lens.image_angles(beta=0.0)
+    assert theta_plus == pytest.approx(lens.einstein_angle())
+    assert theta_minus == pytest.approx(-lens.einstein_angle())
+
+
+def test_einstein_angle_formula():
+    lens = PointMassLens(M=1.0, D_L=1000.0, D_S=2000.0)
+    expected = np.sqrt(4.0 * 1.0 * 1000.0 / (1000.0 * 2000.0))
+    assert lens.einstein_angle() == pytest.approx(expected)
+
+
+def test_images_straddle_the_lens_for_any_offset():
+    lens = PointMassLens(M=1.0, D_L=1000.0, D_S=2000.0)
+    theta_plus, theta_minus = lens.image_angles(beta=0.01)
+    assert theta_plus > 0.0
+    assert theta_minus < 0.0
+
+
+def test_primary_image_approaches_source_position_far_from_lens():
+    lens = PointMassLens(M=1.0, D_L=1000.0, D_S=2000.0)
+    beta = 10.0 * lens.einstein_angle()
+    theta_plus, _ = lens.image_angles(beta)
+    assert theta_plus == pytest.approx(beta, rel=0.05)
+
+
+def test_magnification_diverges_toward_perfect_alignment():
+    lens = PointMassLens(M=1.0, D_L=1000.0, D_S=2000.0)
+    theta_E = lens.einstein_angle()
+    _, _, total_far = lens.magnification(1.0 * theta_E)
+    _, _, total_near = lens.magnification(0.01 * theta_E)
+    assert total_near > total_far > 1.0
+
+
+def test_magnification_canonical_value_at_u_equals_one():
+    lens = PointMassLens(M=1.0, D_L=1000.0, D_S=2000.0)
+    theta_E = lens.einstein_angle()
+    _, _, total = lens.magnification(theta_E)
+    assert total == pytest.approx(1.34164, abs=1.0e-4)
+
+
+def test_invalid_distances_raise():
+    with pytest.raises(ValueError):
+        PointMassLens(M=1.0, D_L=2000.0, D_S=1000.0)
+
+
+def test_exact_deflection_matches_weak_field_for_large_impact_parameter():
+    # A finite r_far leaves a small residual bias (the flat-space "straight
+    # line" total angle swept between two finite radii isn't exactly pi;
+    # see the light-bending example script), so allow a generous tolerance
+    # rather than an unrealistically tight one.
+    bh = SchwarzschildBlackHole(M=1.0)
+    b = 50.0
+    exact = exact_deflection_angle(bh, b)
+    weak = bh.light_deflection_angle(b)
+    assert exact == pytest.approx(weak, rel=0.1)
+
+
+def test_exact_deflection_exceeds_weak_field_closer_to_the_photon_sphere():
+    # n_steps is increased (at fixed default r_far) so the ray has enough
+    # affine-parameter budget to complete the round trip out to r_far; see
+    # exact_deflection_angle's default dtau = 3*r_far/n_steps.
+    bh = SchwarzschildBlackHole(M=1.0)
+    exact_far = exact_deflection_angle(bh, 200.0, n_steps=600000)
+    exact_near = exact_deflection_angle(bh, 15.0, n_steps=600000)
+    assert exact_near > bh.light_deflection_angle(15.0)
+    assert exact_near > exact_far

physicskit/relativity/tests/test_neutron_star.py

@@ -0,0 +1,48 @@
+import numpy as np
+import pytest
+
+from physicskit.relativity.chapters.neutron_star import NeutronStar
+
+
+def test_solve_gives_positive_mass_and_radius():
+    star = NeutronStar(K=100.0, Gamma=2.0)
+    M, R, sol = star.solve(central_density=1.28e-3)
+    assert M > 0.0
+    assert R > 0.0
+    assert sol.success
+
+
+def test_known_k100_gamma2_benchmark():
+    # Standard numerical-relativity textbook benchmark (e.g. Baumgarte &
+    # Shapiro): a K=100, Gamma=2 polytrope has a maximum mass of
+    # approximately 1.6-1.7 (geometrized units matching this convention),
+    # near a central density of a few x 1e-3.
+    star = NeutronStar(K=100.0, Gamma=2.0)
+    M, R, _ = star.solve(central_density=1.28e-3)
+    assert pytest.approx(1.4, abs=0.1) == M
+    assert pytest.approx(9.6, abs=1.0) == R
+
+
+def test_mass_radius_curve_has_a_maximum_mass_turning_point():
+    star = NeutronStar(K=100.0, Gamma=2.0)
+    central_densities = np.logspace(-3.3, -2.2, 14)
+    masses, radii = star.mass_radius_curve(central_densities)
+    assert np.all(masses > 0.0)
+    assert np.all(radii > 0.0)
+    # radius should decrease monotonically as central density increases
+    # (denser, more compact stars)
+    assert np.all(np.diff(radii) < 0.0)
+    # a genuine maximum mass exists strictly inside the scanned range
+    assert 0 < np.argmax(masses) < len(masses) - 1
+
+
+def test_higher_central_density_gives_smaller_radius():
+    star = NeutronStar(K=100.0, Gamma=2.0)
+    _M_low, R_low, _ = star.solve(central_density=5.0e-4)
+    _M_high, R_high, _ = star.solve(central_density=1.0e-3)
+    assert R_high < R_low
+
+
+def test_energy_density_reduces_to_rest_mass_at_zero_pressure():
+    star = NeutronStar(K=100.0, Gamma=2.0)
+    assert star.energy_density(0.0) == pytest.approx(0.0)

physicskit/relativity/tests/test_raytracer.py

@@ -0,0 +1,67 @@
+import numpy as np
+import pytest
+
+from physicskit.relativity.core.raytracer import OUTCOME_CAPTURED, OUTCOME_DISK, OUTCOME_ESCAPED, camera_basis
+from physicskit.relativity.visualizers.shadow_render import render_black_hole_image
+
+
+def test_camera_basis_is_orthonormal():
+    view_dir, right, up = camera_basis(inclination=1.2)
+    for v in (view_dir, right, up):
+        assert np.linalg.norm(v) == pytest.approx(1.0)
+    assert np.dot(view_dir, right) == pytest.approx(0.0, abs=1e-10)
+    assert np.dot(view_dir, up) == pytest.approx(0.0, abs=1e-10)
+    assert np.dot(right, up) == pytest.approx(0.0, abs=1e-10)
+
+
+def test_shadow_fraction_matches_critical_impact_parameter_without_disk():
+    M = 1.0
+    screen_half_width = 15.0
+    result = render_black_hole_image(
+        M=M,
+        ny=120,
+        nx=120,
+        screen_half_width=screen_half_width,
+        r_disk_inner=1.0,
+        r_disk_outer=0.0,
+        n_steps=2000,
+    )
+    outcomes = result["outcomes"]
+    captured_fraction = np.mean(outcomes == OUTCOME_CAPTURED)
+    b_crit = 3.0 * np.sqrt(3.0) * M
+    expected_fraction = np.pi * b_crit**2 / (2.0 * screen_half_width) ** 2
+    assert captured_fraction == pytest.approx(expected_fraction, rel=0.15)
+
+
+def test_all_pixels_produce_a_valid_outcome():
+    result = render_black_hole_image(M=1.0, ny=30, nx=30, n_steps=1500)
+    outcomes = result["outcomes"]
+    assert np.all(outcomes >= 0)
+    assert np.all(outcomes <= 3)
+
+
+def test_disk_pixels_report_radius_within_disk_bounds():
+    result = render_black_hole_image(M=1.0, ny=80, nx=80, r_disk_inner=6.0, r_disk_outer=20.0, n_steps=2000)
+    outcomes = result["outcomes"]
+    hit_radii = result["hit_radii"]
+    disk_mask = outcomes == OUTCOME_DISK
+    assert np.any(disk_mask)
+    assert np.all(hit_radii[disk_mask] >= 6.0 - 1e-6)
+    assert np.all(hit_radii[disk_mask] <= 20.0 + 1e-6)
+
+
+def test_face_on_view_is_rotationally_symmetric_without_disk():
+    # at inclination 0, the (diskless) shadow is a circle around the image center
+    result = render_black_hole_image(M=1.0, ny=61, nx=61, inclination=1e-6, r_disk_inner=1.0, r_disk_outer=0.0, n_steps=1500)
+    outcomes = result["outcomes"]
+    captured = outcomes == OUTCOME_CAPTURED
+    # symmetric under a vertical flip for a face-on, non-tilted view
+    assert np.array_equal(captured, captured[::-1, :]) or np.mean(captured == captured[::-1, :]) > 0.9
+
+
+def test_escaped_pixels_are_far_from_center_pixels_dominated_by_capture():
+    result = render_black_hole_image(M=1.0, ny=41, nx=41, r_disk_inner=1.0, r_disk_outer=0.0, n_steps=1500)
+    outcomes = result["outcomes"]
+    center = outcomes.shape[0] // 2
+    assert outcomes[center, center] == OUTCOME_CAPTURED
+    assert outcomes[0, 0] == OUTCOME_ESCAPED