quvac 0.1.2__tar.gz

quvac-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Maksim Valialshchikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

quvac-0.1.2/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: quvac
+Version: 0.1.2
+Summary: Calculate quantum vacuum signal from the interaction of electromagnetic fields.
+Author-email: Maksim Valialshchikov <maksim.valialshchikov@uni-jena.de>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/maxbalrog/quvac
+Project-URL: Repository, https://github.com/maxbalrog/quvac
+Keywords: quantum,vacuum,qed,maxwell,electrodynamics
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pip>=25.0
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: numexpr
+Requires-Dist: pyfftw
+Requires-Dist: tqdm
+Requires-Dist: submitit
+Requires-Dist: pyyaml
+Provides-Extra: optimization
+Requires-Dist: ax-platform; extra == "optimization"
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.10.1; extra == "plot"
+Requires-Dist: jupyterlab>=4.5.3; extra == "plot"
+Provides-Extra: test
+Requires-Dist: pytest>=8.3.5; extra == "test"
+Requires-Dist: pytest-cov>=6.1.0; extra == "test"
+Provides-Extra: docs
+Requires-Dist: astroid==3.3.8; extra == "docs"
+Requires-Dist: sphinx>=8.2.1; extra == "docs"
+Requires-Dist: jinja2>=3.1.0; extra == "docs"
+Requires-Dist: furo==2024.8.6; extra == "docs"
+Requires-Dist: sphinx-autoapi==3.6.0; extra == "docs"
+Requires-Dist: sphinx-copybutton==0.5.2; extra == "docs"
+Provides-Extra: light
+Requires-Dist: quvac[docs,plot,test]; extra == "light"
+Provides-Extra: all
+Requires-Dist: quvac[docs,optimization,plot,test]; extra == "all"
+Dynamic: license-file
+
+# quvac
+
+![Tests](https://github.com/maxbalrog/quantum-vacuum/actions/workflows/tests.yml/badge.svg)
+![Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/maxbalrog/d6b0645fa035119a53bb6356d169c98b/raw/quvac_coverage_badge.json)
+
+<img src="images/logo.jpg" alt="Alt Text" width="250" height="230">
+
+Quvac (from quantum vacuum, pronounced as qu-ack 🐸) allows to calculate quantum vacuum signals produced during light-by-light scattering.
+
+Documentation is available [here](https://maxbalrog.github.io/quvac/).
+
+> [!IMPORTANT]
+> This project is still in development!
+
+## Installation
+
+It is recommended to create a separate Python environment for this package, e.g.
+
+```bash
+micromamba create -n quvac python=3.12
+```
+
+After cloning the git repository and entering it, choose relevant optional dependencies
+
+- `[test]` allows to run tests
+- `[plot]` installs `matplotlib` and `jupyterlab`
+- `[docs]` installs `sphinx` and everything necessary for documentation generation
+- `[optimization]` installs Bayesian optimization package
+- `[light]` is a shorthand for `[test,plot,docs]`
+
+To install all dependencies, run
+
+```bash
+pip install .[all]
+```
+
+> [!NOTE]
+> For example, if you do not require optimization capabilities, run
+> 
+> ```bash
+> pip install .[test,plot]
+> ```
+
+After successfull installation with `[all]` or `[test]` option, run ``pytest`` to make sure the installation was
+successfull (it takes some time).
+
+```bash
+pytest
+```
+
+### Using `uv`
+
+If you prefer using `uv` package manager then the installation follows similar steps. After cloning the git repository and entering 
+it, create the environment and install `quvac`
+
+```bash
+uv venv
+uv pip install .[light]
+```
+
+You can test the installation with
+
+```bash
+uv run pytest
+```
+
+Launch the jupyterlab (e.g. tutorial notebooks) with
+
+```bash
+uv run jupyter lab
+```
+
+Generate the documentation with
+
+```bash
+uv run python -m sphinx -b html docs/source docs/build/html
+```
+
+## Contribution
+
+If you noticed a bug or have a feature request, open a new [issue](https://github.com/maxbalrog/quvac/issues).
+
+## Acknowledgements
+
+If you use this code and/or consider it useful, please cite our article.
+
+```bibtex
+@article{valialshchikov2025back,
+  title={Back-reflection in dipole fields and beyond},
+  author={Valialshchikov, Maksim and Karbstein, Felix and Seipt, Daniel and Zepf, Matt},
+  journal={arXiv preprint arXiv:2510.11764},
+  year={2025}
+}
+```
+
+## References
+
+[1] - F. Karbstein, and R. Shaisultanov. "Stimulated photon emission from the vacuum." PRD 91.11 (2015): 113002 [[article]](https://arxiv.org/abs/1412.6050).
+
+[2] - A. Blinne, et al. "All-optical signatures of quantum vacuum nonlinearities in generic laser fields." PRD 99.1 (2019): 016006 [[article]](https://arxiv.org/abs/1811.08895).

quvac-0.1.2/README.md

@@ -0,0 +1,100 @@
+# quvac
+
+![Tests](https://github.com/maxbalrog/quantum-vacuum/actions/workflows/tests.yml/badge.svg)
+![Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/maxbalrog/d6b0645fa035119a53bb6356d169c98b/raw/quvac_coverage_badge.json)
+
+<img src="images/logo.jpg" alt="Alt Text" width="250" height="230">
+
+Quvac (from quantum vacuum, pronounced as qu-ack 🐸) allows to calculate quantum vacuum signals produced during light-by-light scattering.
+
+Documentation is available [here](https://maxbalrog.github.io/quvac/).
+
+> [!IMPORTANT]
+> This project is still in development!
+
+## Installation
+
+It is recommended to create a separate Python environment for this package, e.g.
+
+```bash
+micromamba create -n quvac python=3.12
+```
+
+After cloning the git repository and entering it, choose relevant optional dependencies
+
+- `[test]` allows to run tests
+- `[plot]` installs `matplotlib` and `jupyterlab`
+- `[docs]` installs `sphinx` and everything necessary for documentation generation
+- `[optimization]` installs Bayesian optimization package
+- `[light]` is a shorthand for `[test,plot,docs]`
+
+To install all dependencies, run
+
+```bash
+pip install .[all]
+```
+
+> [!NOTE]
+> For example, if you do not require optimization capabilities, run
+> 
+> ```bash
+> pip install .[test,plot]
+> ```
+
+After successfull installation with `[all]` or `[test]` option, run ``pytest`` to make sure the installation was
+successfull (it takes some time).
+
+```bash
+pytest
+```
+
+### Using `uv`
+
+If you prefer using `uv` package manager then the installation follows similar steps. After cloning the git repository and entering 
+it, create the environment and install `quvac`
+
+```bash
+uv venv
+uv pip install .[light]
+```
+
+You can test the installation with
+
+```bash
+uv run pytest
+```
+
+Launch the jupyterlab (e.g. tutorial notebooks) with
+
+```bash
+uv run jupyter lab
+```
+
+Generate the documentation with
+
+```bash
+uv run python -m sphinx -b html docs/source docs/build/html
+```
+
+## Contribution
+
+If you noticed a bug or have a feature request, open a new [issue](https://github.com/maxbalrog/quvac/issues).
+
+## Acknowledgements
+
+If you use this code and/or consider it useful, please cite our article.
+
+```bibtex
+@article{valialshchikov2025back,
+  title={Back-reflection in dipole fields and beyond},
+  author={Valialshchikov, Maksim and Karbstein, Felix and Seipt, Daniel and Zepf, Matt},
+  journal={arXiv preprint arXiv:2510.11764},
+  year={2025}
+}
+```
+
+## References
+
+[1] - F. Karbstein, and R. Shaisultanov. "Stimulated photon emission from the vacuum." PRD 91.11 (2015): 113002 [[article]](https://arxiv.org/abs/1412.6050).
+
+[2] - A. Blinne, et al. "All-optical signatures of quantum vacuum nonlinearities in generic laser fields." PRD 99.1 (2019): 016006 [[article]](https://arxiv.org/abs/1811.08895).

quvac-0.1.2/pyproject.toml

@@ -0,0 +1,126 @@
+[build-system]
+requires = ["setuptools >= 61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quvac"
+dynamic = ["version"]
+dependencies = [
+  "pip>=25.0",
+  "numpy",
+  "scipy",
+  "numexpr",
+  "pyfftw",
+  "tqdm",
+  "submitit",
+  "pyyaml",
+]
+requires-python = ">=3.12"
+authors = [
+  {name = "Maksim Valialshchikov", email = "maksim.valialshchikov@uni-jena.de"},
+]
+maintainers = [
+]
+description = "Calculate quantum vacuum signal from the interaction of electromagnetic fields."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = ["quantum", "vacuum", "qed", "maxwell", "electrodynamics"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Programming Language :: Python",
+]
+
+[project.scripts]
+quvac-simulation = "quvac.simulation:main_simulation"
+quvac-simulation-parallel = "quvac.simulation_parallel:main_simulation_parallel"
+quvac-gridscan = "quvac.cluster.gridscan:main_gridscan"
+quvac-optimization = "quvac.cluster.optimization:main_optimization"
+
+[project.optional-dependencies]
+optimization = [
+    "ax-platform",
+]
+plot = [
+    "matplotlib>=3.10.1",
+    "jupyterlab>=4.5.3",
+]
+test = [
+    "pytest>=8.3.5",
+    "pytest-cov>=6.1.0",
+]
+docs = [
+    "astroid==3.3.8",
+    "sphinx>=8.2.1",
+    "jinja2>=3.1.0",
+    "furo==2024.8.6",
+    "sphinx-autoapi==3.6.0",
+    "sphinx-copybutton==0.5.2",
+]
+light = [
+    "quvac[test,plot,docs]",
+]
+all = [
+    "quvac[test,plot,optimization,docs]",
+]
+
+[project.urls]
+Homepage = "https://github.com/maxbalrog/quvac"
+Repository = "https://github.com/maxbalrog/quvac"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.dynamic]
+version = {attr = "quvac.__version__"}
+
+[tool.uv]
+default-groups = "all"
+
+[tool.pytest.ini_options]
+markers = [
+    "slow: marks tests as slow (deselect with `-m 'not slow'`)",
+    "benchmark: marks tests as becnhmarks",
+]
+addopts = "-m 'not slow' -m 'not benchmark' --ignore=tests/bench_optimization.py"
+python_files = [
+    "bench_*.py",
+    "test_*.py",
+]
+
+# exclude certain scripts from coverage report
+[tool.coverage.run]
+omit = [
+    "*/cluster/*",
+    "src/quvac/analytic_scalings.py",
+    "src/quvac/plotting.py",
+]
+
+[tool.ruff]
+extend-exclude = ["*.ipynb"]
+
+[tool.ruff.lint]
+select = [
+    "F", # pyflakes
+    "E", # pycodestyle
+    "I", # isort
+    "UP", # pyupgrade
+    "B", # flake8-bugbear
+    "C4", # flake8-comprehensions
+]
+unfixable = [
+    "F401",
+]
+
+[tool.ruff.lint.isort]
+force-sort-within-sections = true
+split-on-trailing-comma = false
+
+[dependency-groups]
+dev = [
+    "ruff>=0.11.2",
+]
+test = [
+    "pytest>=8.3.5",
+    "pytest-cov>=6.1.0",
+]

quvac-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

quvac-0.1.2/src/quvac/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.2"

quvac-0.1.2/src/quvac/analytic_scalings.py

@@ -0,0 +1,168 @@
+"""
+Calculation of analytic scalings from articles.
+
+Currently supports:
+
+1. Total signal and perpendicular signal for two colliding 
+paraxial gaussian beams (off-axis).
+
+2. More exact scaling for on-axis collision of two beams.
+
+----
+
+.. [1] F. Karbstein, et al. "Vacuum birefringence at x-ray free-electron 
+    lasers." NJP 23.9 (2021): 095001.
+
+.. [2] E. Mosman, F.Karbstein "Vacuum birefringence and diffraction at 
+    XFEL: from analytical estimates to optimal parameters." PRD 104.1 
+    (2021): 013006.
+"""
+
+import numpy as np
+from scipy.constants import alpha, c, hbar, m_e, pi
+from scipy.integrate import quad
+from scipy.special import erfc
+
+W_e = m_e * c**2  # electron's rest energy
+lam_C = hbar / (m_e * c)  # reduced Compton wavelength
+
+
+def get_two_paraxial_scaling(fields, channels="both"):
+    """
+    Calculate the total signal and perpendicular signal for two colliding 
+    paraxial Gaussian beams (off-axis).
+
+    Parameters
+    ----------
+    fields : list of dict
+        List of dictionaries containing the field parameters.
+    channels : str, optional
+        Channels to iterate through, by default "both".
+
+    Returns
+    -------
+    N_signal : float
+        Total signal.
+    N_perp : float
+        Perpendicular signal.
+
+    Notes
+    -----
+    We introduced additional polarization-dependent factors (beta). The 
+    formula should work for theta not close to 180, loose focusing and 
+    short pulse duration. Result for N_perp should be used only for beta=45.
+
+    This is a variation of Eq.(25) from [1]_.
+    """
+    theta_c = (fields[1]["theta"] - fields[0]["theta"]) * pi / 180
+    beta = (fields[1]["beta"] - fields[0]["beta"]) * pi / 180
+
+    omega = 2 * pi * c / fields[0]["lam"]
+    N_signal, N_perp = 0, 0
+    # Iterate through pump/probe channels
+    match channels:
+        case "first":
+            fields_to_iterate = [fields]
+        case "second":
+            fields_to_iterate = [fields[::-1]]
+        case _:
+            fields_to_iterate = [fields, fields[::-1]]
+
+    for field1, field2 in fields_to_iterate:
+        tau1, tau2 = field1["tau"], field2["tau"]
+        w01, w02 = field1["w0"], field2["w0"]
+        W1, W2 = field1["W"], field2["W"]
+
+        # Define additional parameters
+        T1 = tau1 * np.sqrt(1 + 2 * (tau1 / tau2) ** 2)
+        T2 = tau2 * np.sqrt(1 + 0.5 * (tau2 / tau1) ** 2)
+        w1 = w01 * np.sqrt(1 + 2 * (w01 / w02) ** 2)
+        w2 = w02 * np.sqrt(1 + 0.5 * (w02 / w01) ** 2)
+        sin_term = T1 * T2 * c**2 / (w1 * w2) * np.sin(theta_c) ** 2
+        cos_term = 4 * (1 - np.cos(theta_c)) ** 2
+
+        # Calculate N_signal and N_perp
+        theta_term = (1 - np.cos(theta_c)) ** 4 / np.sqrt(cos_term + sin_term)
+        theta_term *= 1 / np.sqrt((T1 / tau1 * w01 / w1) ** 2 * cos_term + sin_term)
+        dims = hbar * omega / W_e
+        prefactor = 8 * pi**2 / 225 * (alpha / pi) ** 4 * W1 * W2**2 / W_e**3 * dims
+        prefactor *= T1 / tau1 * w1 / w01 * lam_C**4 / (w1 * w2) ** 2 / 9
+        N_perp += prefactor * theta_term * 9 * np.sin(2 * beta) ** 2
+        N_signal += prefactor * theta_term * (130 - 66 * np.cos(2 * beta))
+    return N_signal, N_perp
+
+
+def _onaxis_function(x, r, k0=20):
+    """
+    Calculate the integral for the function defined in [2]_.
+
+    Parameters
+    ----------
+    x : float
+        Parameter x.
+    r : float
+        Parameter r.
+    k0 : float, optional
+        Integration limit for the integral, by default 20.
+
+    Returns
+    -------
+    result : float
+        Result of the integral.
+    """
+    def integrand(k):
+        s = 0
+        for n in [-1, 1]:
+            s += np.exp(2*n*r*x*k) * erfc(n*r*k + x)
+        s = np.abs(s)**2
+        return np.exp(-k**2) * s
+        
+    prefactor = np.sqrt((1 + 2*r**2)/3) * x**2 * np.exp(2*x**2)
+    result = quad(integrand, -k0, k0)
+    return prefactor * result[0]
+
+
+def get_onaxis_scaling(fields, k0=20):
+    """
+    Calculate the more exact scaling for on-axis collision of two beams.
+
+    Parameters
+    ----------
+    fields : list of dict
+        List of dictionaries containing the field parameters.
+    k0 : float, optional
+        Integration limit for the integral in F function, by default 20.
+
+    Returns
+    -------
+    N_signal : float
+        Total signal.
+    N_perp : float
+        Perpendicular signal.
+
+    Notes
+    -----
+    We assume that the 1st field in the list is x-ray.
+
+    This is an integrated version of Eq.(11) [Eq. (13)] from [2]_.
+    """
+    wx, w0 = fields[0]["w0"], fields[1]["w0"]
+    beta = wx / w0
+    Wx, W = fields[0]["W"], fields[1]["W"]
+    lam_x, lam = fields[0]["lam"], fields[1]["lam"]
+    omega_x = 2 * pi * c / lam_x
+    Nx = Wx / (hbar * omega_x)
+    T, tau = fields[0]["tau"], fields[1]["tau"]
+    zR = pi * w0**2 / lam
+
+    x0 = 4 * zR / (c * np.sqrt(T**2 + 1/2*tau**2))
+    r0 = T / tau
+    Fbeta = _onaxis_function(x0 * np.sqrt(1+2*beta**2), r0, k0=k0)
+    F0 = _onaxis_function(x0, r0, k0=k0)
+
+    prefactor = 4 * alpha**4 / (3*pi)**1.5 * W**2 * (hbar * omega_x)**2 / W_e**4
+    result = prefactor * (lam_C / w0)**4 / (1 + 2*beta**2) * np.sqrt(Fbeta*F0) * Nx
+
+    N_signal = 26/45 * result
+    N_perp = 1/25 * result
+    return N_signal, N_perp

quvac-0.1.2/src/quvac/cluster/config.py

@@ -0,0 +1,6 @@
+DEFAULT_SUBMITIT_PARAMS = {
+    "slurm_partition": "hij-gpu",
+    "cpus_per_task": 16,
+    "slurm_mem": "20GB",
+    "timeout_min": 240,
+}

quvac-0.1.2/src/quvac/cluster/fields.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""
+Script to create images of participating fields
+"""
+import argparse
+from copy import deepcopy
+import gc
+import os
+from pathlib import Path
+
+from quvac.field.external_field import ExternalField
+from quvac.grid import setup_grids
+from quvac.plotting import plot_fields
+from quvac.simulation import set_precision
+from quvac.utils import read_yaml
+
+
+def parse_args():
+    description = "Plot fields present in the simulation"
+    argparser = argparse.ArgumentParser(description=description)
+    argparser.add_argument(
+        "--input", "-i", default=None, help="Input yaml file with field and grid params"
+    )
+    argparser.add_argument(
+        "--output", "-o", default=None, help="Path to save simulation data to"
+    )
+    return argparser.parse_args()
+
+
+def image_fields(ini_file, save_path=None):
+    if save_path is None:
+        save_path = os.path.join(os.path.dirname(ini_file), 'imgs')
+    Path(save_path).mkdir(parents=True, exist_ok=True)
+
+    ini_config = read_yaml(ini_file)
+    fields_params = ini_config['fields']
+    grid_params = ini_config["grid"]
+
+    perf_params = ini_config.get("performance", {})
+    precision = perf_params.get("precision", "float32")
+    set_precision(precision)
+
+    # Setup grids
+    grid_xyz, grid_t = setup_grids(deepcopy(fields_params), deepcopy(grid_params))
+    grid_xyz.get_k_grid()
+    grid_shape = grid_xyz.grid_shape
+    print(f"Grid shape: {grid_shape}")
+    print(f"Time steps: {len(grid_t)}")
+
+    plot_keys = ["Intensity"]
+    # Setup fields and plot
+    for idx,field_param in enumerate(fields_params.values()):
+        field = ExternalField([field_param], grid_xyz)
+        for t0 in [0, grid_t[-1]]:
+            save_loc = os.path.join(save_path, f"field_{idx+1}_t0_{t0*1e15:.1f}fs")
+            plot_fields(field, t=t0, plot_keys=plot_keys, norm_lim=1e-10,
+                        save_path=save_loc)
+        del field
+        gc.collect()
+    print("Plotting finished successfully")
+    
+
+if __name__ == "__main__":
+    args = parse_args()
+    image_fields(args.input, args.output)