physicskit 0.1.0__py3-none-any.whl

physicskit/optics/ray.py

@@ -0,0 +1,469 @@
+"""Geometric ray optics: paraxial ray transfer (ABCD) matrices and optical systems.
+
+In the paraxial approximation, a light ray at a given plane along the
+optical axis is fully described by two numbers -- its height above the
+axis, :math:`y`, and the angle it makes with the axis, :math:`\\theta`
+(in radians, small-angle/paraxial regime) -- collected into a state vector
+:math:`(y, \\theta)^T`. Every simple optical element (propagation through
+free space, refraction at an interface, a thin or thick lens, a curved
+mirror, a graded-index medium, ...) acts on this vector as a linear map, a
+:math:`2\\times 2` "ABCD" matrix:
+
+.. math::
+
+    \\begin{pmatrix} y_{\\text{out}} \\\\ \\theta_{\\text{out}} \\end{pmatrix}
+    = \\begin{pmatrix} A & B \\\\ C & D \\end{pmatrix}
+      \\begin{pmatrix} y_{\\text{in}} \\\\ \\theta_{\\text{in}} \\end{pmatrix}.
+
+This formalism -- developed piecemeal through the 19th century (Gauss's
+theory of optical systems) and formalized for laser resonator design by
+Kogelnik and Li in the 1960s -- reduces the analysis of an arbitrarily long
+chain of lenses, mirrors, and gaps to ordinary matrix multiplication: the
+matrix of a compound system is just the product of the matrices of its
+elements, applied in the order light encounters them (rightmost first).
+The same matrices reappear in :mod:`physicskit.optics.gaussian` to
+propagate the complex beam parameter of a Gaussian laser beam, and their
+trace controls whether a laser cavity is a stable resonator.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = [
+    "free_space",
+    "thin_lens",
+    "flat_interface",
+    "curved_interface",
+    "thick_lens",
+    "spherical_mirror",
+    "grin_medium",
+    "OpticalElement",
+    "OpticalSystem",
+    "cavity_round_trip_matrix",
+    "cavity_stability",
+]
+
+
+def free_space(d):
+    """ABCD matrix for propagation through a distance ``d`` of free space (or any homogeneous medium).
+
+    .. math::
+
+        M = \\begin{pmatrix} 1 & d \\\\ 0 & 1 \\end{pmatrix}
+
+    A ray's height changes in proportion to its angle and the distance
+    traveled; its angle is unchanged.
+
+    Parameters
+    ----------
+    d : float
+        Propagation distance.
+
+    Returns
+    -------
+    ndarray of shape (2, 2)
+
+    Examples
+    --------
+    >>> free_space(2.0)
+    array([[1., 2.],
+           [0., 1.]])
+    """
+    return np.array([[1.0, float(d)], [0.0, 1.0]])
+
+
+def thin_lens(f):
+    """ABCD matrix for a thin lens of focal length ``f``.
+
+    .. math::
+
+        M = \\begin{pmatrix} 1 & 0 \\\\ -1/f & 1 \\end{pmatrix}
+
+    Parameters
+    ----------
+    f : float
+        Focal length (positive for a converging lens, negative for
+        diverging).
+
+    Returns
+    -------
+    ndarray of shape (2, 2)
+
+    Examples
+    --------
+    >>> thin_lens(0.5)
+    array([[ 1.,  0.],
+           [-2.,  1.]])
+    """
+    return np.array([[1.0, 0.0], [-1.0 / f, 1.0]])
+
+
+def flat_interface(n1, n2):
+    """ABCD matrix for refraction at a flat interface, index ``n1`` to ``n2``.
+
+    .. math::
+
+        M = \\begin{pmatrix} 1 & 0 \\\\ 0 & n_1/n_2 \\end{pmatrix}
+
+    Parameters
+    ----------
+    n1 : float
+        Refractive index of the incident medium.
+    n2 : float
+        Refractive index of the transmitted medium.
+
+    Returns
+    -------
+    ndarray of shape (2, 2)
+
+    Examples
+    --------
+    >>> flat_interface(1.0, 1.5)
+    array([[1.        , 0.        ],
+           [0.        , 0.66666667]])
+    """
+    return np.array([[1.0, 0.0], [0.0, n1 / n2]])
+
+
+def curved_interface(R, n1, n2):
+    """ABCD matrix for refraction at a spherical interface of radius ``R``, index ``n1`` to ``n2``.
+
+    .. math::
+
+        M = \\begin{pmatrix} 1 & 0 \\\\ (n_1-n_2)/(R n_2) & n_1/n_2 \\end{pmatrix}
+
+    Parameters
+    ----------
+    R : float
+        Radius of curvature of the interface, positive if the center of
+        curvature lies on the outgoing (transmitted) side of the surface.
+    n1 : float
+        Refractive index of the incident medium.
+    n2 : float
+        Refractive index of the transmitted medium.
+
+    Returns
+    -------
+    ndarray of shape (2, 2)
+
+    See Also
+    --------
+    flat_interface : The :math:`R \\to \\infty` limit.
+
+    Examples
+    --------
+    >>> np.allclose(curved_interface(1.0e12, 1.0, 1.5), flat_interface(1.0, 1.5), atol=1e-6)
+    True
+    """
+    return np.array([[1.0, 0.0], [(n1 - n2) / (R * n2), n1 / n2]])
+
+
+def thick_lens(R1, R2, t, n, n_ext=1.0):
+    """ABCD matrix for a thick lens: two curved interfaces separated by thickness ``t``.
+
+    Composes, in the order light passes through them, refraction into the
+    lens at the first surface, propagation across the lens body, and
+    refraction back out at the second surface:
+
+    .. math::
+
+        M = M_{R_2}\\,M_t\\,M_{R_1}, \\qquad
+        M_{R_1} = \\text{curved\\_interface}(R_1, n_{\\text{ext}}, n), \\\\
+        M_t = \\text{free\\_space}(t) \\ \\text{(in medium } n\\text{)}, \\qquad
+        M_{R_2} = \\text{curved\\_interface}(R_2, n, n_{\\text{ext}}).
+
+    Parameters
+    ----------
+    R1 : float
+        Radius of curvature of the first (entrance) surface.
+    R2 : float
+        Radius of curvature of the second (exit) surface.
+    t : float
+        Center thickness of the lens.
+    n : float
+        Refractive index of the lens material.
+    n_ext : float, default=1.0
+        Refractive index of the surrounding medium (air, by default).
+
+    Returns
+    -------
+    ndarray of shape (2, 2)
+
+    Examples
+    --------
+    A symmetric biconvex lens in air; the resulting matrix has unit
+    determinant, as any lossless ABCD system must:
+
+    >>> M = thick_lens(R1=0.1, R2=-0.1, t=0.01, n=1.5)
+    >>> round(float(np.linalg.det(M)), 8)
+    1.0
+    """
+    m1 = curved_interface(R1, n_ext, n)
+    m2 = free_space(t)
+    m3 = curved_interface(R2, n, n_ext)
+    return m3 @ m2 @ m1
+
+
+def spherical_mirror(R):
+    """ABCD matrix for reflection from a spherical mirror of radius of curvature ``R``.
+
+    .. math::
+
+        M = \\begin{pmatrix} 1 & 0 \\\\ -2/R & 1 \\end{pmatrix}
+
+    Parameters
+    ----------
+    R : float
+        Radius of curvature, positive for a concave mirror as seen by the
+        incoming ray (i.e. a focusing mirror).
+
+    Returns
+    -------
+    ndarray of shape (2, 2)
+
+    Examples
+    --------
+    >>> spherical_mirror(2.0)
+    array([[ 1.,  0.],
+           [-1.,  1.]])
+    """
+    return np.array([[1.0, 0.0], [-2.0 / R, 1.0]])
+
+
+def grin_medium(n0, n2_coeff, d):
+    """ABCD matrix for a graded-index (GRIN) medium of length ``d``.
+
+    For the standard quadratic radial index profile
+
+    .. math::
+
+        n(r) = n_0\\left(1 - \\frac{n_2 r^2}{2}\\right),
+
+    paraxial rays oscillate sinusoidally about the axis, giving
+
+    .. math::
+
+        A = D = \\cos(\\sqrt{n_2}\\,d), \\qquad
+        B = \\frac{\\sin(\\sqrt{n_2}\\,d)}{n_0\\sqrt{n_2}}, \\qquad
+        C = -n_0\\sqrt{n_2}\\,\\sin(\\sqrt{n_2}\\,d).
+
+    As ``n2_coeff`` :math:`\\to 0` (a homogeneous medium of index
+    :math:`n_0`), :math:`A=D\\to 1`, :math:`C\\to 0`, and
+    :math:`B \\to d/n_0` -- matching :func:`free_space` exactly only for
+    :math:`n_0 = 1`. This ``d/n_0`` scaling (rather than plain ``d``) for
+    :math:`n_0 \\neq 1` is inherent to the standard GRIN formula quoted
+    above; callers comparing against :func:`free_space` in this limit
+    should do so at :math:`n_0 = 1`.
+
+    Parameters
+    ----------
+    n0 : float
+        On-axis refractive index.
+    n2_coeff : float
+        Quadratic index-gradient coefficient :math:`n_2` (units of
+        1/length^2). Must be non-negative; ``0`` gives a homogeneous
+        medium.
+    d : float
+        Length of the GRIN medium.
+
+    Returns
+    -------
+    ndarray of shape (2, 2)
+
+    Examples
+    --------
+    A tiny gradient barely distinguishable from a homogeneous medium of
+    index 1 reduces to plain free-space propagation:
+
+    >>> np.allclose(grin_medium(n0=1.0, n2_coeff=1e-8, d=2.0), free_space(2.0), atol=1e-4)
+    True
+    """
+    if n2_coeff <= 0.0:
+        return np.array([[1.0, float(d) / n0], [0.0, 1.0]])
+    sqrt_n2 = np.sqrt(n2_coeff)
+    arg = sqrt_n2 * d
+    A = np.cos(arg)
+    B = np.sin(arg) / (n0 * sqrt_n2)
+    C = -n0 * sqrt_n2 * np.sin(arg)
+    return np.array([[A, B], [C, A]])
+
+
+class OpticalElement:
+    """A single named optical element wrapping one ABCD matrix.
+
+    Parameters
+    ----------
+    matrix : array_like, shape (2, 2)
+        The element's ray transfer matrix, e.g. from :func:`thin_lens` or
+        :func:`free_space`.
+    name : str, default=""
+        Human-readable label (e.g. ``"f=50mm lens"``).
+    length : float, default=0.0
+        Physical length occupied by this element along the optical axis
+        (zero for a "thin" element such as a lens or mirror).
+
+    Examples
+    --------
+    >>> elem = OpticalElement(thin_lens(0.05), name="focusing lens", length=0.0)
+    >>> elem.name
+    'focusing lens'
+    """
+
+    def __init__(self, matrix, name="", length=0.0):
+        self.matrix = np.asarray(matrix, dtype=float)
+        self.name = name
+        self.length = length
+
+
+class OpticalSystem:
+    """An ordered sequence of :class:`OpticalElement` forming a compound optical system.
+
+    Parameters
+    ----------
+    elements : list of OpticalElement
+        The elements in the order light passes through them: ``elements[0]``
+        is hit first.
+
+    Examples
+    --------
+    A single thin lens followed by propagation over its focal length
+    focuses any parallel ray bundle back to the axis:
+
+    >>> f = 0.1
+    >>> sys = OpticalSystem([
+    ...     OpticalElement(thin_lens(f), name="lens"),
+    ...     OpticalElement(free_space(f), name="propagate to focus"),
+    ... ])
+    >>> trajectory = sys.trace_ray(y0=0.01, theta0=0.0)
+    >>> abs(float(trajectory[-1, 0])) < 1e-12
+    True
+    """
+
+    def __init__(self, elements):
+        self.elements = list(elements)
+
+    def system_matrix(self):
+        """Total ABCD matrix of the system, :math:`M = M_n \\cdots M_2 M_1`.
+
+        ``elements[0]`` is applied first (it is the rightmost factor), so
+        it acts on the incoming ray state before any later element.
+
+        Returns
+        -------
+        ndarray of shape (2, 2)
+        """
+        M = np.eye(2)
+        for element in self.elements:
+            M = element.matrix @ M
+        return M
+
+    def trace_ray(self, y0, theta0):
+        """Trace a single ray through every element, recording its state at each step.
+
+        Parameters
+        ----------
+        y0 : float
+            Initial height.
+        theta0 : float
+            Initial angle, in radians.
+
+        Returns
+        -------
+        ndarray of shape (n_elements + 1, 2)
+            Row 0 is the input state ``[y0, theta0]``; row ``i`` (for
+            ``i >= 1``) is the state after passing through
+            ``elements[0], ..., elements[i-1]``.
+        """
+        n = len(self.elements)
+        states = np.empty((n + 1, 2))
+        state = np.array([float(y0), float(theta0)])
+        states[0] = state
+        for i, element in enumerate(self.elements):
+            state = element.matrix @ state
+            states[i + 1] = state
+        return states
+
+    @property
+    def stability_parameter(self):
+        """Resonator stability parameter :math:`(A+D)/2` of the system matrix.
+
+        Returns
+        -------
+        float
+        """
+        M = self.system_matrix()
+        return (M[0, 0] + M[1, 1]) / 2.0
+
+    def is_stable(self):
+        """Whether the system satisfies the resonator stability condition :math:`|A+D| \\le 2`.
+
+        Returns
+        -------
+        bool
+        """
+        return cavity_stability(self.system_matrix())
+
+
+def cavity_round_trip_matrix(elements):
+    """Round-trip ABCD matrix of a laser cavity, given its elements in traversal order.
+
+    Equivalent to ``OpticalSystem(elements).system_matrix()``; provided as
+    a standalone function for cavities analyzed without constructing a full
+    :class:`OpticalSystem`.
+
+    Parameters
+    ----------
+    elements : list of OpticalElement
+        The elements encountered over one full round trip, in order.
+
+    Returns
+    -------
+    ndarray of shape (2, 2)
+
+    See Also
+    --------
+    cavity_stability : Test the resulting matrix for resonator stability.
+
+    Examples
+    --------
+    >>> M = cavity_round_trip_matrix([
+    ...     OpticalElement(spherical_mirror(2.0), name="M1"),
+    ...     OpticalElement(free_space(1.0), name="gap"),
+    ...     OpticalElement(spherical_mirror(2.0), name="M2"),
+    ...     OpticalElement(free_space(1.0), name="gap"),
+    ... ])
+    >>> cavity_stability(M)
+    True
+    """
+    M = np.eye(2)
+    for element in elements:
+        M = element.matrix @ M
+    return M
+
+
+def cavity_stability(M):
+    """Resonator stability test :math:`|A+D| \\le 2` (equivalently :math:`|\\operatorname{tr} M| \\le 2`).
+
+    A laser cavity with round-trip matrix ``M`` supports stable,
+    non-diverging paraxial ray bundles if and only if this holds.
+
+    Parameters
+    ----------
+    M : array_like, shape (2, 2)
+        A round-trip ABCD matrix, e.g. from :func:`cavity_round_trip_matrix`
+        or :meth:`OpticalSystem.system_matrix`.
+
+    Returns
+    -------
+    bool
+
+    Examples
+    --------
+    >>> cavity_stability(np.array([[1.0, 0.0], [0.0, 1.0]]))
+    True
+    >>> cavity_stability(np.array([[3.0, 0.0], [0.0, 3.0]]))
+    False
+    """
+    M = np.asarray(M, dtype=float)
+    return bool(abs(np.trace(M)) <= 2.0)

physicskit/optics/tests/test_diffraction_animation.py

@@ -0,0 +1,38 @@
+"""Animation smoke + sanity tests for physicskit.optics.visualizers.animate_diffraction_propagation."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+from matplotlib.animation import PillowWriter
+
+from physicskit.optics.visualizers import animate_diffraction_propagation
+from physicskit.optics.wave import angular_spectrum_propagate, double_slit_aperture, intensity
+
+
+@pytest.mark.slow
+def test_diffraction_propagation_animation(tmp_path):
+    dx = 1e-3
+    ap = double_slit_aperture((64, 64), dx=dx, width=2e-3, separation=1e-2).astype(complex)
+    z_values = np.linspace(0.01, 2.0, 6)
+    anim = animate_diffraction_propagation(ap, wavelength=0.5e-3, z_values=z_values, dx=dx)
+    out = tmp_path / "diffraction.gif"
+    anim.save(out, writer=PillowWriter(fps=10))
+    assert out.exists() and out.stat().st_size > 0
+
+
+def test_pattern_widens_as_z_increases_matching_angular_spectrum_directly():
+    """The animation just steps angular_spectrum_propagate over z -- sanity-check that the
+    interference pattern's spatial extent (its second moment) actually grows with z, as
+    expected of a diverging diffraction pattern developing from the near to the far field."""
+    dx = 1e-3
+    ap = double_slit_aperture((64, 64), dx=dx, width=2e-3, separation=1e-2).astype(complex)
+    z_small, z_large = 0.05, 3.0
+    x = (np.arange(64) - 32) * dx
+    X, _ = np.meshgrid(x, x)
+
+    def spread(z):
+        I = intensity(angular_spectrum_propagate(ap, wavelength=0.5e-3, z=z, dx=dx))
+        return np.sqrt(np.sum(I * X**2) / np.sum(I))
+
+    assert spread(z_large) > spread(z_small)

physicskit/optics/tests/test_gaussian.py

@@ -0,0 +1,170 @@
+import numpy as np
+import pytest
+
+from physicskit.optics.gaussian import (
+    GaussianBeam,
+    hermite_gaussian_mode,
+    laguerre_gaussian_mode,
+    m2_beam_waist,
+    propagate_q,
+    q_to_beam_params,
+)
+
+
+def _free_space(d):
+    return np.array([[1.0, d], [0.0, 1.0]])
+
+
+def _thin_lens(f):
+    return np.array([[1.0, 0.0], [-1.0 / f, 1.0]])
+
+
+def test_propagate_q_free_space_shifts_real_part():
+    q0 = 1j * 2.0
+    M = _free_space(3.0)
+    q1 = propagate_q(q0, M)
+    assert q1 == pytest.approx(3.0 + 2.0j)
+
+
+def test_propagate_q_thin_lens_leaves_flat_wavefront_flat():
+    # A collimated (plane-wave, R=inf) beam is represented by q real & huge;
+    # instead check a lens leaves an on-axis waist's q consistent with 1/q - 1/f rule.
+    q0 = 1j * 5.0
+    f = 10.0
+    q1 = propagate_q(q0, _thin_lens(f))
+    assert 1.0 / q1 == pytest.approx(1.0 / q0 - 1.0 / f)
+
+
+def test_q_to_beam_params_at_waist_gives_infinite_radius_of_curvature():
+    zR = 4.0
+    wavelength = 1.0e-3
+    w0 = np.sqrt(wavelength * zR / np.pi)
+    w, R = q_to_beam_params(1j * zR, wavelength)
+    assert R == np.inf
+    assert w == pytest.approx(w0)
+
+
+def test_symmetric_two_lens_imaging_system_reproduces_object_waist():
+    # Symmetric imaging system built directly from the ABCD matrices given
+    # in the house convention: free_space(f) -> lens(f) -> free_space(f) ->
+    # lens(f) -> free_space(f), starting from a beam waist at the object
+    # plane. This should reproduce the object-plane waist size at the image
+    # plane (unit magnification, by symmetry).
+    wavelength = 0.5e-3
+    w0 = 0.1
+    f = 50.0
+
+    beam = GaussianBeam(wavelength=wavelength, w0=w0, z0=0.0)
+    q0 = beam.q_parameter(0.0)
+
+    M = _free_space(f) @ _thin_lens(f) @ _free_space(f) @ _thin_lens(f) @ _free_space(f)
+    q_image = propagate_q(q0, M)
+    w_image, _ = q_to_beam_params(q_image, wavelength)
+
+    assert w_image == pytest.approx(w0, rel=1e-6)
+
+
+def test_waist_at_z0_equals_w0_exactly():
+    beam = GaussianBeam(wavelength=1.0e-3, w0=0.2, z0=1.5)
+    assert beam.waist(beam.z0) == pytest.approx(0.2)
+    assert beam.waist(beam.z0) == 0.2
+
+
+def test_radius_of_curvature_is_infinite_at_the_waist():
+    beam = GaussianBeam(wavelength=1.0e-3, w0=0.2, z0=1.5)
+    assert beam.radius_of_curvature(beam.z0) == np.inf
+
+
+def test_radius_of_curvature_far_from_waist_approaches_z_minus_z0():
+    beam = GaussianBeam(wavelength=1.0e-3, w0=0.05, z0=0.0)
+    z = 1.0e6  # z >> zR, so R(z) -> z - z0
+    assert beam.radius_of_curvature(z) == pytest.approx(z, rel=1e-3)
+
+
+def test_radius_of_curvature_accepts_an_array_of_positions():
+    beam = GaussianBeam(wavelength=1.0e-3, w0=0.2, z0=1.5)
+    z = np.array([1.5, 1.0e6])
+    R = beam.radius_of_curvature(z)
+    assert isinstance(R, np.ndarray)
+    assert R[0] == np.inf
+    assert R[1] == pytest.approx(z[1], rel=1e-3)
+
+
+def test_divergence_angle_matches_far_field_waist_slope():
+    beam = GaussianBeam(wavelength=1.0e-3, w0=0.02, z0=0.0)
+    z_far = 1000.0 * beam.rayleigh_range
+    slope = beam.waist(z_far) / (z_far - beam.z0)
+    assert slope == pytest.approx(beam.divergence_angle, rel=1e-3)
+
+
+def test_gouy_phase_is_zero_at_waist_and_approaches_pi_over_2_far_away():
+    beam = GaussianBeam(wavelength=1.0e-3, w0=0.05, z0=0.0)
+    assert beam.gouy_phase(0.0) == pytest.approx(0.0)
+    assert beam.gouy_phase(1.0e6) == pytest.approx(np.pi / 2.0, abs=1e-3)
+
+
+def test_hermite_gaussian_mode_shape_and_fundamental_matches_gaussian_beam():
+    beam = GaussianBeam(wavelength=1.0, w0=1.0, z0=0.0)
+    x = np.linspace(-2, 2, 9)
+    y = np.linspace(-2, 2, 9)
+    X, Y = np.meshgrid(x, y)
+    field = hermite_gaussian_mode(X, Y, 0.0, beam, 0, 0)
+    assert field.shape == X.shape
+    assert np.iscomplexobj(field)
+    expected_intensity = np.exp(-2.0 * (X**2 + Y**2) / beam.waist(0.0) ** 2)
+    assert np.allclose(np.abs(field) ** 2, expected_intensity)
+
+
+def test_hermite_gaussian_mode_gouy_phase_scales_with_mode_order():
+    # Use x=1 (rather than the axis) so H_0(sqrt2 x/w) and H_1(sqrt2 x/w)
+    # are both strictly positive real numbers, isolating the Gouy phase
+    # contribution (m+n+1)*zeta(z) from any sign flip of the real
+    # Hermite-polynomial amplitude factor.
+    beam = GaussianBeam(wavelength=1.0, w0=1.0, z0=0.0)
+    z = 3.0 * beam.rayleigh_range
+    u00 = hermite_gaussian_mode(1.0, 0.0, z, beam, 0, 0)
+    u10 = hermite_gaussian_mode(1.0, 0.0, z, beam, 1, 0)
+    phase_diff = np.angle(u10) - np.angle(u00)
+    expected = beam.gouy_phase(z)  # (1+0+1)*zeta - (0+0+1)*zeta = zeta
+    assert phase_diff == pytest.approx(expected, abs=1e-8)
+
+
+def test_laguerre_gaussian_mode_shape_and_ring_structure():
+    beam = GaussianBeam(wavelength=1.0, w0=1.0, z0=0.0)
+    r = np.linspace(0, 3, 50)
+    phi = np.zeros_like(r)
+    field = laguerre_gaussian_mode(r, phi, 0.0, beam, l=1, p=0)
+    assert field.shape == r.shape
+    # LG_0^1 has a phase singularity (zero amplitude) on-axis
+    assert abs(field[0]) == pytest.approx(0.0, abs=1e-12)
+    assert np.max(np.abs(field)) > 0.0
+
+
+def test_laguerre_gaussian_mode_orbital_phase_winds_by_2pi_l():
+    beam = GaussianBeam(wavelength=1.0, w0=1.0, z0=0.0)
+    r = np.full(9, 0.5)
+    phi = np.linspace(0.0, 2 * np.pi, 9, endpoint=False)
+    field = laguerre_gaussian_mode(r, phi, 0.0, beam, l=2, p=0)
+    phase = np.unwrap(np.angle(field))
+    total_winding = phase[-1] + (phase[-1] - phase[-2]) - phase[0]
+    assert np.round(total_winding / (2 * np.pi)) == pytest.approx(2.0, abs=0.2)
+
+
+def test_m2_beam_waist_reduces_to_ideal_at_M2_equals_1():
+    wavelength = 1.0e-3
+    w0 = 0.1
+    z = np.linspace(-5, 5, 11)
+    beam = GaussianBeam(wavelength=wavelength, w0=w0, z0=0.0)
+    ideal = beam.waist(z)
+    m2 = m2_beam_waist(z, wavelength, w0, M2=1.0)
+    assert np.allclose(ideal, m2)
+
+
+def test_m2_beam_waist_diverges_faster_for_larger_M2():
+    wavelength = 1.0e-3
+    w0 = 0.1
+    z = 10.0
+    w_ideal = m2_beam_waist(z, wavelength, w0, M2=1.0)
+    w_poor = m2_beam_waist(z, wavelength, w0, M2=3.0)
+    assert w_poor > w_ideal
+    assert m2_beam_waist(0.0, wavelength, w0, M2=3.0) == pytest.approx(w0)