🔬 optics

TurPy: a physics-based and differentiable optical turbulence simulator for algorithmic development and system optimization

This paper introduces TurPy, a GPU-accelerated, fully differentiable optical turbulence simulator that bridges high-fidelity physics-based modeling with end-to-end system optimization, enabling accurate validation against theoretical models and successful gradient-based design of turbulence-compensating optical systems.

Original authors: Joseph L. Greene, Alfred Moore, Iris Ochoa, Emily Kwan, Patrick Marano, Christopher R. Valenta

Published 2026-04-09

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Joseph L. Greene, Alfred Moore, Iris Ochoa, Emily Kwan, Patrick Marano, Christopher R. Valenta

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to send a laser beam from one mountain peak to another to transmit data. It sounds simple, but the air between them isn't empty; it's filled with invisible, swirling pockets of hot and cold air (turbulence). These pockets act like a wobbly, shifting lens, bending the laser beam, breaking it apart, and making the signal flicker wildly. This is the nightmare of "free-space optics."

To build better systems to fix this, engineers need to practice. But you can't just go outside and wait for the perfect storm of bad weather every day. You need a simulator.

Enter TurPy. Think of TurPy as a super-smart, high-speed flight simulator for light, but instead of a plane, it simulates a laser beam flying through a stormy atmosphere.

Here is what makes TurPy special, explained through simple analogies:

1. The "Smart Movie Maker" (Differentiability)

Most old simulators are like a black-and-white TV: they show you what happens, but if you want to know why it happened or how to fix it, you have to guess. You can't easily tweak the knobs to see how a small change affects the whole picture.

TurPy is different. It's like a smart movie editor where every single pixel knows its own history. If you change a tiny part of the "wind" or the "laser," TurPy can instantly tell you exactly how that change ripples through the whole system. This allows engineers to use "gradient-based optimization" (a fancy way of saying "automatic trial-and-error") to design perfect laser systems without human guesswork.

2. The "Infinite Zoom" (Subharmonics)

When simulating turbulence on a computer, you have to use a grid (like a pixelated image). If the grid is too small, you miss the big, slow-moving swirls of air (the "outer scale"). If the grid is too big, the computer crashes.

TurPy uses a trick called subharmonics. Imagine you are painting a giant mural. Instead of trying to paint the whole thing at once on a tiny canvas, TurPy paints the big, sweeping background strokes first, then adds the tiny, detailed brushstrokes on top. This lets it capture both the massive, slow-moving weather patterns and the tiny, fast flickers without needing a supercomputer the size of a city.

3. The "Time Machine" (Temporal Correlation)

Old simulators treated every frame of the "movie" as a brand new, random scene. But in real life, wind doesn't just jump randomly; it flows. A gust of wind today is related to the gust from a second ago.

TurPy uses autoregression, which is like a flowing river. It remembers the "shape" of the turbulence from the previous moment and gently shifts it forward, adding just enough new randomness to keep it realistic. This means the simulation feels like real, moving air, not a flickering strobe light.

4. The "Auto-Pilot" (Screen Placement)

To simulate a long journey, you have to break the path into small steps. If your steps are too big, the math breaks. If they are too small, it takes forever.

TurPy has an auto-pilot that figures out the perfect step size for you. It checks the "rules of physics" (like how much the air is bending the light) and automatically splits the journey into just the right number of steps to keep the math accurate but the speed fast. You don't have to be a math genius to use it; you just tell it where you are going, and it handles the details.

5. The "Magic Glasses" (The Real-World Test)

The researchers didn't just build TurPy; they tested it. They compared its predictions against known scientific laws for how light behaves in the air.

The Result: TurPy was 98% accurate. It predicted how much a laser beam would spread out and how much it would flicker almost perfectly, whether the air was calm or a violent storm.

The Grand Finale: The "Self-Healing" Laser

To show off its power, the team used TurPy to train a Diffractive Deep Neural Network (D2NN).

The Analogy: Imagine you have a pair of magic glasses (the D2NN) that you put in front of your camera.
The Training: TurPy acted as the "gym" where these glasses practiced thousands of times, looking at distorted laser beams and learning how to fix them.
The Result: The glasses learned to take a shattered, flickering laser beam and turn it back into a perfect, steady beam. They reduced the "flickering" (scintillation) by 20 times compared to a system with no glasses at all.

Why This Matters

TurPy is like a universal translator between physics and artificial intelligence. It allows engineers to design optical systems (for satellites, underwater comms, or even medical imaging) that can "learn" to see through the worst weather conditions, all before they ever build a single physical part. It's open-source, meaning anyone can use it to build the next generation of smart, self-correcting light systems.

1. Problem Statement

Developing robust free-space optical (FSO) systems requires accurate simulation of optical turbulence, which induces refractive index fluctuations that distort, break up, and refract propagating beams.

Limitations of Existing Tools:
- Time-averaged simulators: Use closed-form solutions to model aggregate effects (e.g., beam broadening) but fail to capture instantaneous wavefront distortions necessary for training deep learning models.
- Traditional Wave Optics Simulators: Capture instantaneous field distributions but are computationally expensive and often lack differentiability, making them unsuitable for end-to-end gradient-based optimization.
- Gap: No existing tool consolidates anisoplanatism, subharmonic generation, temporal correlation, and strong turbulence models within a GPU-accelerated, differentiable architecture suitable for optimizing optical systems and downstream algorithms simultaneously.

2. Methodology: The TurPy Framework

TurPy is a fully differentiable, GPU-accelerated wave optics simulator built on PyTorch. It utilizes a split-step method to decouple deterministic diffraction from stochastic phase accumulation.

Core Components:

Split-Step Propagation: The optical field $U(x,y)$ $U (x, y)$ is propagated through intervals $\Delta z$ $Δ z$ by alternating between:
1. Fourier Propagation: Using an Angular Spectrum Transfer Function (more accurate than Fresnel approximation for high turbulence) to handle diffraction.
2. Phase Modulation: Applying a real-space statistical phase screen $\varphi_n(x,y)$ representing turbulence.
Phase Screen Generation:
- PSD Parameterization: Screens are generated based on a media-specific Power Spectral Density (PSD), allowing the framework to model atmospheric, oceanic, and biological environments by simply changing the PSD and refractive index structure constant ( $C_n^2$ ).
- Subharmonics: To capture large-scale "outer scale" turbulence effects without inflating grid size, TurPy employs a recursive subharmonic generation method. This adds low-frequency information (tip-tilt) to the phase screen, effectively increasing resolution by a factor of $s^{N_p}$ (e.g., 27x) without computational overhead.
- Temporal Correlation (Autoregression): To simulate dynamic environments (e.g., wind), TurPy uses an autoregressive approach. It applies a Fourier space phase tilt for translation (wind) and blends the shifted screen with new random noise using a decorrelation factor $\alpha$ . This allows for realistic temporal evolution of turbulence.
Automated Screen Placement: A routine automatically determines optimal screen intervals along the propagation path. It balances two constraints:
1. Fourier Aliasing: Ensures the step size $\Delta z$ does not cause phase gradients to alias on the grid.
2. Weak-Turbulence Approximation: Ensures the Rytov variance ( $\sigma_R^2$ ) per interval remains below 1 to maintain physical validity. If an interval is too strong, it is split; if too weak, intervals are merged.

Training Application (D2NN):

The framework was used to train a Dual-Domain Diffractive Deep Neural Network (D2NN). This architecture consists of two static phase masks separated by lenses, operating in both real and Fourier domains. The system is trained end-to-end to recover a Gaussian beam from a turbulent path without active feedback loops or moving parts.

3. Key Contributions

Differentiable Physics Engine: TurPy is the first simulator to unify high-fidelity turbulence physics (subharmonics, temporal correlation, anisoplanatism) with GPU acceleration and automatic differentiation, enabling gradient-based optimization of optical hardware.
Unified Multi-Environment Framework: By parameterizing turbulence via PSD, TurPy supports atmospheric, oceanic, and biological propagation with minimal code modification.
Automated Physical Validity: The built-in routine for screen placement ensures simulations adhere to both Fourier sampling limits and weak-scattering approximations without manual tuning.
Open-Source Release: The package is released to facilitate synthetic data generation and algorithm development for turbulent environments.

4. Results and Validation

The authors validated TurPy against established atmospheric optics theory across weak to strong turbulence regimes.

PSD Recovery: TurPy successfully recovered user-defined turbulence Power Spectral Densities with high accuracy after averaging 4,000 independent realizations.
2nd Order Statistics (Beam Broadening): Simulated Gaussian beam broadening matched theoretical predictions with 99.7% accuracy in weak-to-moderate turbulence and within 2.5% in strong turbulence.
4th Order Statistics (Scintillation): Simulated plane wave scintillation matched closed-form models with 98% accuracy across the full range of Rytov variances ( $\sigma_R^2 = 0.235$ to $235.0$). The simulator correctly captured the transition from weak turbulence (hotspots) to strong turbulence (homogeneous speckle/saturation).
D2NN Optimization:
- A dual-domain D2NN was trained to compensate for weak turbulence ( $\sigma_R^2 = 0.2$ ) over a 1.5 km path.
- Performance: The trained system achieved a >20x reduction in scintillation compared to an uncompensated receiver.
- Mechanism: The first mask redirected off-axis energy to the optical axis, while the second mask corrected residual phase errors in the Fourier domain.

5. Significance

Bridging Simulation and Design: TurPy bridges the gap between high-fidelity physical simulation and end-to-end system design. It allows researchers to jointly optimize optical elements (hardware) and signal processing algorithms (software) in a single gradient-based loop.
Data-Limited Regimes: It provides a solution for training deep learning models where collecting real-world field data across all environmental conditions is impractical.
Passive Adaptive Optics: The successful training of the D2NN demonstrates the viability of all-passive, static optical systems for turbulence compensation, eliminating the need for power-hungry active adaptive optics (deformable mirrors) and feedback loops.
Future Applications: The framework is positioned to advance passive imaging, remote sensing, and directed energy systems by enabling the simulation of anisoplanatic and partially coherent scenarios.