Non-adiabatic Attoclock: Energy-Resolved Angular Streaking

A Julia-based implementation of the Strong-Field Approximation (SFA) for simulating energy-resolved angular streaking in tunneling ionization. This code models electron trajectories in intense, elliptically-polarized laser fields to study the attoclock technique in strong-field physics.

Overview

The attoclock uses elliptical laser polarization to encode tunneling time into the angular distribution of ionized electrons. This project implements:

1. Quantum orbit generation via saddle-point method
2. Classical trajectory propagation through laser + Coulomb fields
3. Momentum distribution analysis with Coulomb corrections

The code solves the fundamental question: How does elliptical laser polarization encode tunneling time into the angular distribution of ionized electrons?

Physics Background

• Strong-Field Approximation (SFA): Saddle-point method to find complex tunneling times and initial conditions
• Tunneling ionization: Electrons tunnel through the barrier created by laser + Coulomb potential
• Quantum orbits: Multiple electron trajectories contribute to ionization
• Energy-resolved streaking: Tracks final electron energy and momentum distributions
• Attoclock technique: Uses rotating electric field as ultrafast "clock" to measure tunneling dynamics

Project Structure

Non-adiabatic-Attoclock/
├── config.toml                          # Simulation parameters
├── InitialConditionGenerator.jl          # Core SFA initial condition generator
├── SimulationDistributed.jl              # Distributed trajectory simulation
├── test_initial_conditions.jl            # Validation script
├── initial_cond.ipynb                    # Analysis notebook
├── analysis/
│   └── analyze_results.jl                # Post-processing & momentum distribution
└── doc/
    └── TunnelingtimeANDlongitudinalmomentum.md  # Mathematical derivations

Key Components

1. InitialConditionGenerator.jl

Core SFA engine that generates initial conditions for electron trajectories.

Inputs: p_perp, p_z (transverse/longitudinal momenta), t_r (real tunneling time)

Outputs: r0, v0 (initial position/velocity), t_i (imaginary tunneling time), p_lab (lab-frame momentum), S_sub (sub-barrier action)

Algorithm:

• Solves saddle-point equations for complex tunneling time
• Computes initial position via Gaussian quadrature
• Calculates sub-barrier action
• Filters trajectories by action threshold

2. SimulationDistributed.jl

Runs 1 billion classical electron trajectories in parallel across 10 workers.

Workflow:

1. Generates random initial conditions uniformly
2. Calls InitialConditionGenerator for quantum initial state
3. Integrates equations of motion using Tsit5 ODE solver
4. Tracks action during propagation
5. Filters for ionized electrons
6. Outputs trajectory data

Equations of motion:

dr/dt = v
dv/dt = -∇V_Coulomb - E_field
dS/dt = -L (Lagrangian)

3. analyze_results.jl

Post-processes trajectory data to compute final momentum distributions.

Features:

• Applies Coulomb phase corrections
• Transforms to asymptotic momentum using Runge-Lenz vector
• Bins into 3D momentum grid
• Accumulates complex amplitude: dist[p] += exp(i·phase)
• Outputs 2D momentum distribution

Configuration

Edit config.toml to set simulation parameters (atomic units):

[laser]
omega = 0.058              # Angular frequency
E_peak = 0.03779           # Peak electric field
ellipticity = 0.66         # χ parameter
cep = 0.0                  # Carrier-envelope phase

[pulse]
n_cycles_total = 16        # Total pulse duration
n_cycles_constant = 10     # Flat-top duration

[atom]
ionization_potential = 0.5147  # I_p (hydrogen-like)
Z_eff = 1.0                    # Effective nuclear charge

[initial_conditions]
p_max = 2.0                    # Momentum sampling range
action_threshold = 22.98       # Filters exp(-2·Im(S)) > 10⁻¹⁰

Usage

1. Test Initial Conditions

julia test_initial_conditions.jl

Generates 100,000 test trajectories and outputs to test_initial_conditions.txt.

2. Run Full Simulation

julia SimulationDistributed.jl

Runs distributed simulation with 1 billion trajectories. Outputs worker files: sfa_phase_worker_*.txt.

3. Analyze Results

julia analysis/analyze_results.jl

Processes worker outputs and generates momentum_dist_2d.npy (2D momentum distribution).

4. Visualize

Open initial_cond.ipynb in Jupyter to analyze and visualize results.

Mathematical Foundation

See doc/TunnelingtimeANDlongitudinalmomentum.md for detailed derivations:

• Part I: Factorization of complex saddle-point equation
• Part II: Justification of envelope approximation
• Part III: Transformation to electric field frame
• Part IV: Compact notation
• Part V: Analytical solution algorithm
• Part VI: Back-transformation to lab frame

Key saddle-point equations:

Parallel momentum:

p_∥ = (A₀f(1-χ²)sin(2α)cosh(β)) / (2Γ)

Energy conservation (determines cosh(β)):

½(p_⊥ + χA₀f·cosh(β)/Γ)² + p_z²/2 + I_p = ½A₀²f²Γ²sinh²(β)

where α = ωt_r + φ_cep, β = ωt_i, Γ = √(cos²α + χ²sin²α).

Dependencies

• Julia 1.x
• DifferentialEquations.jl (ODE solver)
• Distributed.jl (parallel computing)
• FastGaussQuadrature.jl (numerical integration)
• TOML.jl (configuration)
• NPZ.jl (output format)

Output Format

Trajectory data (worker files)

tr  p_perp  p_z  r0_x  r0_y  r0_z  v0_x  v0_y  v0_z  rf_x  rf_y  rf_z  vf_x  vf_y  vf_z  S_sub_real  S_sub_imag  S_dyn

Momentum distribution

• momentum_dist_2d.npy: Complex 2D array (p_x, p_y) integrated over p_z
• Grid: 1001×1001 points, range ±1.5 a.u.

References

This implementation is based on the Strong-Field Approximation and saddle-point method for tunneling ionization. For theoretical background, see:

• Quantum theory of tunneling ionization in strong fields
• Attoclock technique for measuring tunneling time
• SFA with Coulomb corrections

License

MIT License — see LICENSE for details.

Authors

Tao Jianfei (jakiesumrain@163.com)