Skip to content

LASY-org/lasy

This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Folders and files

NameName
Last commit message
Last commit date

Latest commit

author
“Emily
Oct 9, 2024
dfbb025 · Oct 9, 2024
Aug 8, 2023
Sep 2, 2024
Jul 16, 2024
Oct 9, 2024
Oct 9, 2024
Feb 10, 2023
Oct 7, 2024
May 24, 2023
Aug 23, 2023
Aug 9, 2024
Feb 4, 2023
Feb 6, 2023
Feb 6, 2023
Aug 30, 2024
Sep 3, 2024
Jul 16, 2024

Repository files navigation

lasy

Overview

lasy is a Python library that facilitates the initialization of complex laser pulses, in simulations of laser-plasma interactions.

More specifically, lasy offers many ways to define complex laser pulses (e.g. from commonly-known analytical formulas, from experimental measurements, etc.) and offers pre-processing functionalities (e.g. propagation, re-normalization, geometry conversion). The laser field is then exported in a standardized file, that can be read by external simulation codes.

Documentation

LASY manipulates laser pulses, and operates on the laser envelope. In 3D (x,y,t) Cartesian coordinates, the definition used is:

E x ( x , y , t ) = Re ( E ( x , y , t ) e i ω 0 t p x )   E y ( x , y , t ) = Re ( E ( x , y , t ) e i ω 0 t p y )

where Re stands for real part, E x (resp. E y ) is the laser electric field in the x (resp. y) direction, E is the complex laser envelope stored and used in lasy, ω 0 = 2 π c / λ 0 is the angular frequency defined from the laser wavelength λ 0 and ( p x , p y ) is the (complex and normalized) polarization vector.

In cylindrical coordinates, the envelope is decomposed in N m azimuthal modes ( see Ref. [A. Lifschitz et al., J. Comp. Phys. 228.5: 1803-1814 (2009)]). Each mode is stored on a 2D grid (r,t), using the following definition:

E x ( r , θ , t ) = Re ( N m + 1 N m 1 E m ( r , t ) e i m θ e i ω 0 t p x )   E y ( r , θ , t ) = Re ( N m + 1 N m 1 E m ( r , t ) e i m θ e i ω 0 t p y ) .

For more information, please check our arXiv preprint.

Workflow

How to contribute

All contributions are welcome! For a new contribution, we use pull requests from forks. Below is a very rough summary, please have a look at the appropriate documentation at https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/about-forks and around.

First, setup your fork workflow (only once):

  • Fork the repo by clicking the Fork button on the top right, and follow the prompts. This will create your own (remote) copy of the main https://github.com/LASY-org/LASY repo, located at https://github.com/[yourusername]/LASY.
  • Make your local copy aware of your fork: from your local repository, do git remote add [some-name] https://github.com/[your username]/LASY. For [some-name] it can be convenient to use e.g. your username.

Then, for each contribution:

  • Get the last version of branch development from the main repo (e.g. git checkout development && git pull).
  • Create a new branch (e.g. git checkout -b my_contribution).
  • Do usual git add and git commit operations.
  • Push your branch to your own fork: git push -u [some-name] my_contribution
  • Whenever you're ready, open a PR from branch my_contribution on your fork to branch development on the main repo. Github typically suggests this very well.

Style conventions

  • Docstrings are written using the Numpy style.
  • Functions in utils/laser_utils.py only depend on standard types (Python & Numpy) and on the Grid class. That way, they are relatively stand-alone and can be used on different data structures. A simple Grid factory is provided for that purpose.
  • A PR should be open for any contribution: the description helps to explain the code and open dicussion.

Install

python3 -m pip install lasy

For tests, you need to have a few extra packages, such as pytest and openpmd-viewer installed:

python3 -m pip install -r tests/requirements.txt

Test

After successful installation, you can run the unit tests:

# Run all tests
python3 -m pytest tests/

# Run tests from a single file
python3 -m pytest tests/test_laser_profiles.py

# Run a single test (useful during debugging)
python3 -m pytest tests/test_laser_profiles.py::test_profile_gaussian_3d_cartesian

# Run all tests, do not capture "print" output and be verbose
python3 -m pytest -s -vvvv tests/

Creating Documentation

Install sphinx (https://www.sphinx-doc.org/en/master/usage/installation.html)

python -m pip install --upgrade -r docs/requirements.txt
cd docs
sphinx-build -b html source _build