Ionization Calculations
=======================

GASFIR provides three methods for computing strong-field ionization observables.
All methods accept a :class:`~gasfir.Pulse` object and a parameter dictionary,
including :class:`~gasfir.DataPulse` for numerical fields.

Non-Adiabatic Ionization Probability
-------------------------------------

:func:`~gasfir.get_diabatic_ionization_probability` integrates the time-dependent
ionization rate over the full pulse envelope::

    from gasfir import create_pulse, get_parameters, get_diabatic_ionization_probability

    laser  = create_pulse(800, 1e14, 0, 6)
    params = get_parameters("Hydrogen_SFA")

    prob = get_diabatic_ionization_probability(pulse=laser, param_dict=params)

Time-Resolved Rate
------------------

:func:`~gasfir.get_diabatic_ionization_rate` returns the instantaneous ionization
rate on a user-supplied time grid::

    from gasfir import get_diabatic_ionization_rate

    t    = laser.get_tgrid(dt=0.25)
    rate = get_diabatic_ionization_rate(t_grid=t, pulse=laser, param_dict=params)

Quasi-Static Limit
------------------

For validation against tunnel-ionization benchmarks::

    from gasfir import get_quasi_static_rate_for_field
    import numpy as np

    fields  = np.linspace(0.01, 0.2, 50)   # field amplitudes in atomic units
    qs_rate = get_quasi_static_rate_for_field(fields, params)

Batch Processing
----------------

To compute probabilities for many pulses in one parallelised call, use
:func:`~gasfir.get_diabatic_ionization_probability_vec`::

    from gasfir import get_diabatic_ionization_probability_vec

    pulses = [create_pulse(800, I, 0, 6) for I in intensities]
    probs  = get_diabatic_ionization_probability_vec(pulses, params)

Numerical / DataPulse Fields
-----------------------------

All calculation functions work transparently with :class:`~gasfir.DataPulse`::

    from gasfir import DataPulse, get_diabatic_ionization_probability, get_parameters
    import numpy as np

    # load or construct your field on a time grid
    t    = np.linspace(-300, 300, 4801)
    A    = my_simulation_result   # vector potential in a.u.

    dp   = DataPulse(t, A=A)
    prob = get_diabatic_ionization_probability(pulse=dp, param_dict=get_parameters("H_SFA"))