🎆eTraj.jl

Implementation of classical/semiclassical trajectory-based methods in strong-field ionization of atoms and molecules.

• 🎆eTraj.jl
• • Background
  • Installation
  • Contributors
  • License

Background

The interaction between light and matter has been a subject of widespread investigation since the inception of quantum mechanics. The development of laser technology has led to remarkable advances in both light intensity and spectroscopic precision, enabling unprecedented exploration of light-matter interactions under extreme conditions.

When laser intensities exceed TW/cm², the light-matter interaction enters a non-perturbative regime where conventional perturbation theory becomes inadequate, giving rise to various novel strong-field phenomena such as above-threshold ionization (ATI), tunneling ionization, high-harmonic generation (HHG) and non-sequential double ionization (NSDI). Theoretical investigations of these non-perturbative phenomena have progressed substantially over recent decades. The most rigorous approach involves numerical solution of the time-dependent Schrödinger equation (TDSE); however, its computational complexity restricts applications primarily to few-dimensional systems. Furthermore, the abstract nature of TDSE calculations often obscures the underlying physical mechanisms. An alternative approach is the strong-field approximation (SFA), which relies on two key assumptions: first, that the initial state remains unperturbed by the laser field until ionization occurs; and second, that the photoelectron's post-ionization dynamics proceed without influence from the binding potential (effectively treating it as short-range). These approximations enable analytical treatment of the problem, thereby providing valuable physical insights into the underlying mechanisms. Nevertheless, the SFA framework exhibits limitations, particularly in scenarios where Coulomb interactions play a significant role, potentially leading to qualitative discrepancies with experimental observations.

A substitute strategy to overcome these limitations is the Classical-Trajectory Monte-Carlo (CTMC) method ^{[Abrines_1966] [Olson_1977]}, which employs an ensemble of classical electrons evolving under combined laser and Coulomb fields. This methodology has been extended to incorporate tunneling ionization effects by initializing electron trajectories at the tunnel exit coordinate ^{[Corkum_1989] [Corkum_1993] [Hu_1997]}. The photoelectron momentum distribution (PMD) is subsequently obtained through statistical analysis of these classical trajectories. Although the CTMC approach is fundamentally classical in nature, quantum mechanical effects can be effectively incorporated through the introduction of trajectory-dependent phases. Examples include the Trajectory-based Coulomb-SFA (TC-SFA) ^{[Yan_2010] [Yan_2012]}, the Quantum-Trajectory Monte Carlo (QTMC) ^{[Li_2014] [Liu_2016]}, and the Semiclassical Two-Step Model (SCTS) ^{[ShvetsovShilovski_2016] [ShvetsovShilovski_2021]}. Another approach, the Coulomb Quantum-orbit SFA (CQSFA) ^{[Lai_2015] [Maxwell_2017]}, addresses the inverse problem by identifying all trajectories that result in the same final momenta. These trajectory-based semiclassical methods offer notable advantages over the TDSE and direct SFA methods due to their lower demand on computational resources, as well as the clarity they provide in understanding the physical picture.

After years of development, various trajectory-based classical/semiclassical methods have emerged; however, a unified theoretical framework remains to be established. In addition, developing a library that not only implements existing methods but also does so in a way that is both computationally efficient and easy to maintain can significantly enhance research in strong-field ionization. To meet these challenges, we introduce eTraj.jl, a program package written in Julia. Julia was chosen for its extraordinary balance of performance, ease of use, and simplicity in deployment, which are crucial for scientific computing. It combines Python-like syntax with C-like speed due to its just-in-time (JIT) compilation; offers a user-friendly syntax that simplifies coding and enhances productivity, enabling researchers to focus on the working problem; includes built-in support for parallel computing, allowing efficient multicore utilization without complex setup; what's more, programs written in Julia are easy to deploy across different environments, ensuring accessibility and broad applicability. eTraj leverages these features to provide an efficient, versatile, flexible, and out-of-the-box solution for classical/semiclassical trajectory simulations, advancing research in strong-field ionization.

Installation

Prerequisites

• Minimum prerequisites : Julia ≥ 1.9

• MO-ADK/MO-SFA and WFAT molecular calculations : Data for some small molecules are available in the molecule database (see the get_mol method). If the user wants to perform molecular calculations with customized parameters, the platform should be Linux or macOS, and having Python 3 with the PySCF python package installed and the PyCall.jl julia package successfully built.

Installing the package

This package is currently not in julia's general registry, but can be added through the repository URL:

using Pkg
Pkg.add(url="https://github.com/TheStarAlight/eTraj.jl.git")
# In pkg mode of REPL:
# (@v1.9) pkg> add https://github.com/TheStarAlight/eTraj.jl.git

To enter the pkg mode of REPL, type ] in REPL, and the pkg> prompt will appear, replacing the julia>.

For offline installation:

using Pkg
Pkg.add(url="/path/to/eTraj/")
# In pkg mode of REPL:
# (@v1.9) pkg> add /path/to/eTraj/

It is suggested to test the package to check if the functions (especially molecular calculations) work on your platform:

Pkg.test("eTraj")
# In pkg mode of REPL:
# (@v1.9) pkg> test eTraj

Configuring Python and PySCF

Currently, the calculation of molecules' asymptotic coefficients (for MO-ADK/MO-SFA) and WFAT coefficients rely on the PySCF python package. eTraj calls the PySCF using the PyCall.jl package.

There are two ways to set up the Python environment used by PyCall:

1. using your local Python environment by specifying the path of your Python executable in ENV["PYTHON"] and build the PyCall package.
2. using a private Python environment managed by the Conda.jl, which is implicitly installed by the PyCall package by default;

Using the local Python environment

To correctly set up the configuration of PyCall, first, set the PYTHON environment variable to the path your Python executable, and build the PyCall package:

ENV["PYTHON"] = "path/to/python_exec"
using Pkg
Pkg.build("PyCall")
# In pkg mode of REPL:
# (@v1.9) pkg> build PyCall

And don't forget to install PySCF via pip in your system shell:

$ pip install pyscf==2.3.0

Using Conda.jl

Before installing eTraj, install Conda first:

using Pkg
Pkg.add("Conda")

Then call pip within Conda to install PySCF:

using Conda
Conda.pip_interop(true)
Conda.pip("install", "pyscf==2.3.0")

Contributors

• Mingyu Zhu @ ECNU
• Hongcheng Ni @ ECNU

License

This package is licensed under the Apache 2.0 license, and is copyrighted by Mingyu Zhu and the other contributors.