vmecpp 0.5.2__tar.gz → 0.5.4__tar.gz

{vmecpp-0.5.2 → vmecpp-0.5.4}/.clang-tidy

@@ -34,7 +34,7 @@ CheckOptions:
   - { key: readability-identifier-naming.StructCase,             value: CamelCase  }
   - { key: readability-identifier-naming.TemplateParameterCase,  value: CamelCase  }
   - { key: readability-identifier-naming.FunctionCase,           value: aNy_CasE  }
-  - { key: readability-identifier-naming.VariableCase,           value: lower_case }
+#  - { key: readability-identifier-naming.VariableCase,           value: lower_case }
   - { key: readability-identifier-naming.ClassMemberCase,        value: lower_case }
   - { key: readability-identifier-naming.ClassMemberSuffix,      value: _          }
   - { key: readability-identifier-naming.PrivateMemberSuffix,    value: _          }

{vmecpp-0.5.2 → vmecpp-0.5.4}/CMakeLists.txt

@@ -113,12 +113,42 @@ target_link_libraries(vmecpp_core PRIVATE ${HDF5_CXX_LIBRARIES} ${HDF5_LIBRARIES
 target_link_libraries(vmecpp_core PRIVATE ${netCDF_LIBRARIES})
 target_link_libraries(vmecpp_core PRIVATE nlohmann_json::nlohmann_json)
 target_link_libraries(vmecpp_core PRIVATE LAPACK::LAPACK)
+
+# FFTX (SPIRAL-generated batched IPRDFT/PRDFT) for the toroidal FFT hot path.
+# The codelets are vendored under src/vmecpp/cpp/third_party/fftx_codelets/;
+# see that directory's README.md for what they cover and how to regenerate.
+# Pass -DVMECPP_USE_FFTX=OFF to fall back to the partial-DFT path.
+option(VMECPP_USE_FFTX "Use FFTX/SPIRAL kernels for toroidal transforms" ON)
+if(VMECPP_USE_FFTX)
+  set(_fftx_dir "${PROJECT_SOURCE_DIR}/src/vmecpp/cpp/third_party/fftx_codelets")
+  file(GLOB _fftx_iprdft_srcs CONFIGURE_DEPENDS
+       "${_fftx_dir}/lib_fftx_iprdftbat_cpu_srcs/*.cpp")
+  file(GLOB _fftx_prdft_srcs  CONFIGURE_DEPENDS
+       "${_fftx_dir}/lib_fftx_prdftbat_cpu_srcs/*.cpp")
+  add_library(fftx_codelets STATIC ${_fftx_iprdft_srcs} ${_fftx_prdft_srcs})
+  target_include_directories(fftx_codelets PUBLIC
+    "${_fftx_dir}"                                                 # for <include/omega64.h>
+    "${_fftx_dir}/include"                                         # for fftx_minimal.hpp
+    "${_fftx_dir}/lib_fftx_iprdftbat_cpu_srcs"
+    "${_fftx_dir}/lib_fftx_prdftbat_cpu_srcs")
+  # Match vmecpp's release flags; codelets are >30k lines and benefit from -O3.
+  target_compile_options(fftx_codelets PRIVATE -fPIC)
+  target_link_libraries(vmecpp_core PRIVATE fftx_codelets)
+  target_compile_definitions(vmecpp_core PUBLIC VMECPP_USE_FFTX)
+  list(LENGTH _fftx_iprdft_srcs _n_iprdft)
+  list(LENGTH _fftx_prdft_srcs  _n_prdft)
+  message(STATUS "FFTX vendored codelets: ${_n_iprdft} iprdft + ${_n_prdft} prdft sources")
+endif()
 target_link_libraries(vmecpp_core PRIVATE absl::algorithm absl::base absl::synchronization absl::strings absl::str_format absl::log absl::string_view absl::check absl::status absl::statusor)
 
 if(OpenMP_CXX_FOUND)
   target_link_libraries(vmecpp_core PRIVATE OpenMP::OpenMP_CXX)
 endif()
 
+# We multithread at the outer loop level, not for the individual Eigen operations
+# https://libeigen.gitlab.io/eigen/docs-3.3/TopicMultiThreading.html
+target_compile_definitions(vmecpp_core PRIVATE EIGEN_DONT_PARALLELIZE)
+
 
 # Now also add the vmec_standalone executable.
 add_executable(vmec_standalone ${PROJECT_SOURCE_DIR}/src/vmecpp/cpp/vmecpp/vmec/vmec_standalone/vmec_standalone.cc)

{vmecpp-0.5.2 → vmecpp-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vmecpp
-Version: 0.5.2
+Version: 0.5.4
 Summary: Proxima Fusion's reimplementation of the Variational Moments Equilibrium Code (VMEC), a free-boundary ideal-MHD equilibrium solver for stellarators and Tokamaks.
 Author-Email: Jonathan Schilling <jons@proximafusion.com>, Enrico Guiraud <eguiraud@proximafusion.com>, Philipp Jurasic <jurasic@proximafusion.com>
 License-Expression: MIT
@@ -21,6 +21,7 @@ Requires-Python: <3.14,>=3.10
 Requires-Dist: netCDF4
 Requires-Dist: numpy
 Requires-Dist: pydantic>=2.11
+Requires-Dist: pydantic<2.13
 Requires-Dist: jaxtyping>=0.2.6
 Requires-Dist: jax!=0.5.2
 Requires-Dist: jax!=0.5.1
@@ -96,6 +97,7 @@ See [below](#differences-with-respect-to-parvmecvmec2000) for more details.
   - [Arch](#arch-linux)
   - [Fedora](#fedora)
   - [MacOS](#macos)
+  - [With Nix](#with-nix)
   - [As part of a conda environment](#as-part-of-a-conda-environment)
   - [C++ build from source](#c-build-from-source)
 - [Hot restart](#hot-restart)
@@ -260,6 +262,20 @@ export HDF5_ROOT=$(brew --prefix hdf5)
 python3.10 -m pip install git+https://github.com/proximafusion/vmecpp
 ```
 
+### With Nix (Community support)
+
+For a Linux development shell with the latest supported Python version:
+
+```shell
+nix develop
+python --version
+python -m pip install -e .[test]
+```
+
+The shell provides Python 3.13 together with the native build dependencies needed
+to build and test VMEC++, including CMake, GCC, GFortran, HDF5, NetCDF, LAPACK,
+OpenMPI, and Git LFS.
+
 ### As part of a conda environment
 
 VMEC++ is currently not packaged for conda, but all its dependencies are and VMEC++
@@ -341,6 +357,7 @@ VMEC++:
 - allows hot-restarting a run from a previous converged state (see [Hot restart](#hot-restart))
 - supports inputs in the classic INDATA format as well as simpler-to-parse JSON files; it is also simple to construct input objects programmatically in Python
 - employs the same parallelization strategy as Fortran VMEC, but VMEC++ leverages OpenMP for a multi-thread implementation rather than Fortran VMEC's MPI parallelization: as a consequence it cannot parallelize over multiple nodes
+- Uses FFT kernels optimized for small mode numbers [generated using FFTX](github.com/spiral-software/fftx) instead of DFT for supported resolutions. They give a 10-20% speedup relative to the DFT counterparts.
 - implements the iteration algorithm of Fortran VMEC 8.52, which sometimes has different convergence behavior from (PAR)VMEC 9.0: some configurations might converge with VMEC++ and not with (PAR)VMEC 9.0, and vice versa
 
 ### Limitations with respect to the Fortran implementations
@@ -372,7 +389,7 @@ VMEC++:
    * `xnpot` - not declared yet
 - 2D preconditioning using block-tridiagonal solver ([`BCYCLIC`](https://www.sciencedirect.com/science/article/abs/pii/S0021999110002536)) is not implemented;
   neither are the associated input fields `precon_type` and `prec2d_threshold`
-- VMEC++ only computes the output quantities if the run converged
+- VMEC++ only computes the output quantities if the run converged (can be overridden via `return_outputs_even_if_not_converged` input)
 - The Fortran version falls back to fixed-boundary computation if the `mgrid` file cannot be found; VMEC++ (gracefully) errors out instead.
 - The Fortran version accepts both the full path or filename of the input file as well as the "extension", i.e., the part after `input.`; VMEC++ only supports a valid filename or full path to an existing input file.
 

{vmecpp-0.5.2 → vmecpp-0.5.4}/README.md

@@ -55,6 +55,7 @@ See [below](#differences-with-respect-to-parvmecvmec2000) for more details.
   - [Arch](#arch-linux)
   - [Fedora](#fedora)
   - [MacOS](#macos)
+  - [With Nix](#with-nix)
   - [As part of a conda environment](#as-part-of-a-conda-environment)
   - [C++ build from source](#c-build-from-source)
 - [Hot restart](#hot-restart)
@@ -219,6 +220,20 @@ export HDF5_ROOT=$(brew --prefix hdf5)
 python3.10 -m pip install git+https://github.com/proximafusion/vmecpp
 ```
 
+### With Nix (Community support)
+
+For a Linux development shell with the latest supported Python version:
+
+```shell
+nix develop
+python --version
+python -m pip install -e .[test]
+```
+
+The shell provides Python 3.13 together with the native build dependencies needed
+to build and test VMEC++, including CMake, GCC, GFortran, HDF5, NetCDF, LAPACK,
+OpenMPI, and Git LFS.
+
 ### As part of a conda environment
 
 VMEC++ is currently not packaged for conda, but all its dependencies are and VMEC++
@@ -300,6 +315,7 @@ VMEC++:
 - allows hot-restarting a run from a previous converged state (see [Hot restart](#hot-restart))
 - supports inputs in the classic INDATA format as well as simpler-to-parse JSON files; it is also simple to construct input objects programmatically in Python
 - employs the same parallelization strategy as Fortran VMEC, but VMEC++ leverages OpenMP for a multi-thread implementation rather than Fortran VMEC's MPI parallelization: as a consequence it cannot parallelize over multiple nodes
+- Uses FFT kernels optimized for small mode numbers [generated using FFTX](github.com/spiral-software/fftx) instead of DFT for supported resolutions. They give a 10-20% speedup relative to the DFT counterparts.
 - implements the iteration algorithm of Fortran VMEC 8.52, which sometimes has different convergence behavior from (PAR)VMEC 9.0: some configurations might converge with VMEC++ and not with (PAR)VMEC 9.0, and vice versa
 
 ### Limitations with respect to the Fortran implementations
@@ -331,7 +347,7 @@ VMEC++:
    * `xnpot` - not declared yet
 - 2D preconditioning using block-tridiagonal solver ([`BCYCLIC`](https://www.sciencedirect.com/science/article/abs/pii/S0021999110002536)) is not implemented;
   neither are the associated input fields `precon_type` and `prec2d_threshold`
-- VMEC++ only computes the output quantities if the run converged
+- VMEC++ only computes the output quantities if the run converged (can be overridden via `return_outputs_even_if_not_converged` input)
 - The Fortran version falls back to fixed-boundary computation if the `mgrid` file cannot be found; VMEC++ (gracefully) errors out instead.
 - The Fortran version accepts both the full path or filename of the input file as well as the "extension", i.e., the part after `input.`; VMEC++ only supports a valid filename or full path to an existing input file.
 

{vmecpp-0.5.2 → vmecpp-0.5.4}/benchmarks/test_benchmarks.py

@@ -127,6 +127,19 @@ def test_bench_fixed_boundary_cma(benchmark, cma_input):
     assert result.wout.volume == pytest.approx(0.5014, rel=1e-3)
 
 
+def test_bench_fixed_boundary_cma_6x8(benchmark, cma_input):
+    """Benchmark CMA equilibrium (stellarator, ntor=6, mpol=8)."""
+    cma_input_6x8 = cma_input.model_copy(update={"mpol": 8})
+    result = benchmark.pedantic(
+        vmecpp.run,
+        args=(cma_input_6x8,),
+        kwargs={"max_threads": 2},
+        rounds=3,
+        warmup_rounds=0,
+    )
+    assert result.wout.volume == pytest.approx(0.5014, rel=1e-3)
+
+
 # ---------------------------------------------------------------------------
 # Free-boundary benchmarks
 # ---------------------------------------------------------------------------

{vmecpp-0.5.2 → vmecpp-0.5.4}/environment.yml

@@ -28,6 +28,7 @@ dependencies:
   - gfortran_impl_linux-64=14.2.0=hc73f493_1
   - gxx=14.2.0=h96c4ede_1
   - gxx_impl_linux-64=14.2.0=h2c03514_1
+  - fftw>=3.3
   - hdf4=4.2.15=h2a13503_7
   - hdf5=1.14.3=nompi_hdf9ad27_105
   - kernel-headers_linux-64=5.14.0=h8bc681e_0

vmecpp-0.5.4/flake.lock

@@ -0,0 +1,27 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1751274312,
+        "narHash": "sha256-/bVBlRpECLVzjV19t5KMdMFWSwKLtb5RyXdjz3LJT+g=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "50ab793786d9de88ee30ec4e4c24fb4236fc2674",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-24.11",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

vmecpp-0.5.4/flake.nix

@@ -0,0 +1,95 @@
+{
+  description = "Nix development shell for vmecpp";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.11";
+  };
+
+  outputs = { nixpkgs, ... }:
+    let
+      lib = nixpkgs.lib;
+      supportedSystems = [
+        "x86_64-linux"
+        "aarch64-linux"
+      ];
+      forAllSystems = lib.genAttrs supportedSystems;
+    in
+    {
+      devShells = forAllSystems (
+        system:
+        let
+          pkgs = import nixpkgs { inherit system; };
+          python = pkgs.python313;
+          hdf5 = pkgs.hdf5-fortran;
+          hdf5Merged = pkgs.symlinkJoin {
+            name = "hdf5-merged";
+            paths = [
+              hdf5
+              hdf5.dev
+              hdf5.bin
+            ];
+            postBuild = ''
+              rm "$out/lib/cmake/hdf5-config.cmake"
+              sed \
+                -e 's|"''${CMAKE_CURRENT_LIST_DIR}/\.\./\.\./\.\./[^"]*"|"'"$out"'"|' \
+                -e 's|''${PACKAGE_PREFIX_DIR}//nix/store/[a-z0-9]*-hdf5-cpp-fortran-[^/]*/|''${PACKAGE_PREFIX_DIR}/|g' \
+                -e 's|"//nix/store/[a-z0-9]*-hdf5-cpp-fortran-[^/]*/|"'"$out"'/|g' \
+                "${hdf5.dev}/lib/cmake/hdf5-config.cmake" \
+                > "$out/lib/cmake/hdf5-config.cmake"
+
+              for f in "$out"/lib/cmake/hdf5-targets*.cmake; do
+                rm "$f"
+                sed \
+                  -e 's|${hdf5}|'"$out"'|g' \
+                  -e 's|${hdf5.dev}|'"$out"'|g' \
+                  "${hdf5.dev}/lib/cmake/$(basename "$f")" \
+                  > "$f"
+              done
+            '';
+          };
+        in
+        {
+          default = pkgs.mkShell {
+            packages = with pkgs; [
+              python
+              cmake
+              ninja
+              gcc
+              gfortran
+              pkg-config
+              hdf5Merged
+              netcdf
+              netcdffortran
+              blis
+              lapack-reference
+              nodejs
+              openmpi
+              git
+              git-lfs
+            ];
+
+            shellHook = ''
+              export CC=${pkgs.gcc}/bin/gcc
+              export CXX=${pkgs.gcc}/bin/g++
+              export FC=${pkgs.gfortran}/bin/gfortran
+              export CMAKE_GENERATOR=Ninja
+              export HDF5_DIR=${hdf5Merged}/lib/cmake
+              export CMAKE_ARGS="-DHDF5_DIR=${hdf5Merged}/lib/cmake -DCMAKE_DISABLE_FIND_PACKAGE_netCDF=TRUE -DBLAS_LIBRARIES=${pkgs.blis}/lib/libblas.so -DLAPACK_LIBRARIES=${pkgs.lapack-reference}/lib/liblapack.so"
+              export LD_LIBRARY_PATH=${lib.makeLibraryPath [
+                pkgs.stdenv.cc.cc
+                pkgs.blis
+                pkgs.lapack-reference
+              ]}:''${LD_LIBRARY_PATH:-}
+              vmecpp_pip_constraints="''${TMPDIR:-/tmp}/vmecpp-pip-constraints.txt"
+              cat > "$vmecpp_pip_constraints" <<EOF
+pydantic<2.13
+EOF
+              export PIP_CONSTRAINT="$vmecpp_pip_constraints"
+              export PIP_BUILD_CONSTRAINT="$vmecpp_pip_constraints"
+              export SKIP="pyright"
+            '';
+          };
+        }
+      );
+    };
+}

{vmecpp-0.5.2 → vmecpp-0.5.4}/pyproject.toml

@@ -31,6 +31,7 @@ dependencies = [
   "netCDF4",
   "numpy",
   "pydantic>=2.11", # Introduced support for by_alias validation
+  "pydantic<2.13", # Breaking change currently under investigation
   "jaxtyping>=0.2.6",
   "jax!=0.5.2", # To prevent a circular import bug in jax on arch Linux
   "jax!=0.5.1", # To prevent a circular import bug in jax on arch Linux

{vmecpp-0.5.2 → vmecpp-0.5.4}/src/vmecpp/__init__.py

@@ -679,6 +679,8 @@ class VmecWOut(BaseModelWithNumpy):
         "bsubvmns",
         "bsupumns",
         "bsupvmns",
+        "currumns",
+        "currvmns",
     ]
     """If quantities are not exactly the same in C++ WoutFileContents and this class,
     add them to this list and implement the conversion logic in _to_cpp_wout and
@@ -969,6 +971,18 @@ class VmecWOut(BaseModelWithNumpy):
     r"""Fourier coefficients (cos) of the contravariant magnetic field component
     :math:`B^{\phi}` on the half-grid."""
 
+    # Defaulted for backwards compatibility with old wout files
+    currumnc: jt.Float[np.ndarray, "mn_mode_nyq n_surfaces"] = pydantic.Field(
+        default_factory=lambda: np.array([])
+    )
+    r"""Fourier coefficients (cos) of :math:`\sqrt{g} J^{\theta}` on the full-grid."""
+
+    # Defaulted for backwards compatibility with old wout files
+    currvmnc: jt.Float[np.ndarray, "mn_mode_nyq n_surfaces"] = pydantic.Field(
+        default_factory=lambda: np.array([])
+    )
+    r"""Fourier coefficients (cos) of :math:`\sqrt{g} J^{\zeta}` on the full-grid."""
+
     rmnc: jt.Float[np.ndarray, "mn_mode n_surfaces"]
     """Fourier coefficients (cos) for ``R`` of the geometry of the flux surfaces on the
     full- grid."""
@@ -1038,6 +1052,14 @@ class VmecWOut(BaseModelWithNumpy):
     r"""Fourier coefficients (sin) of the contravariant magnetic field component
     :math:`B^{\phi}` on the half-grid; non-stellarator-symmetric."""
 
+    currumns: jt.Float[np.ndarray, "mn_mode_nyq n_surfaces"] | None = None
+    r"""Fourier coefficients (sin) of :math:`\sqrt{g} J^{\theta}` on the full-grid; non-
+    stellarator-symmetric."""
+
+    currvmns: jt.Float[np.ndarray, "mn_mode_nyq n_surfaces"] | None = None
+    r"""Fourier coefficients (sin) of :math:`\sqrt{g} J^{\zeta}` on the full-grid; non-
+    stellarator-symmetric."""
+
     pcurr_type: ProfileType
     """Parametrization of toroidal current profile (copied from input)."""
 
@@ -1186,7 +1208,7 @@ class VmecWOut(BaseModelWithNumpy):
     """Mercier stability criterion contribution due to geodesic curvature."""
 
     niter: int
-    """Maximum number of force-balance iterations allowed."""
+    """Number of force-balance iterations taken to converge."""
 
     beta_vol: jt.Float[np.ndarray, "n_surfaces"]
     """Flux-surface averaged plasma beta on half-grid."""
@@ -1409,6 +1431,8 @@ class VmecWOut(BaseModelWithNumpy):
             attrs["bsubvmns"] = cpp_wout.bsubvmns
             attrs["bsupumns"] = cpp_wout.bsupumns
             attrs["bsupvmns"] = cpp_wout.bsupvmns
+            attrs["currumns"] = cpp_wout.currumns
+            attrs["currvmns"] = cpp_wout.currvmns
             attrs["gmns"] = cpp_wout.gmns
 
         return VmecWOut(**attrs)
@@ -1438,6 +1462,8 @@ class VmecWOut(BaseModelWithNumpy):
                 "bsubvmns",
                 "bsupumns",
                 "bsupvmns",
+                "currumns",
+                "currvmns",
             ]:
                 value = getattr(self, field)
                 if value is not None:

{vmecpp-0.5.2 → vmecpp-0.5.4}/src/vmecpp/cpp/.bazelrc

@@ -1,5 +1,5 @@
 # general compilation options
-build --cxxopt="-std=c++20" --copt="-fdiagnostics-color=always"
+build --cxxopt="-std=c++20" --copt="-fdiagnostics-color=always" --copt="-DEIGEN_DONT_PARALLELIZE"
 
 # workaround for a Bazel 7 issue with rules_foreign_cc: https://github.com/bazelbuild/rules_foreign_cc/issues/1129
 build --sandbox_add_mount_pair=/tmp
@@ -23,7 +23,8 @@ build:tsan_archer_in_docker --crosstool_top=//docker/tsan/llvm_toolchain:clang_s
                             --cpu=k8 \
                             --host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
                             --copt="-O3" --copt="-fopenmp" --copt="-fsanitize=thread" --copt="-g" --strip=never \
-                            --linkopt="-fopenmp" --linkopt="-fsanitize=thread" --linkopt="-L/usr/local/lib" --linkopt="-L/usr/local/lib/x86_64-unknown-linux-gnu"  --linkopt="-larcher" \
+                            --linkopt="-fopenmp" --linkopt="-fsanitize=thread" --linkopt="-L/usr/local/lib" --linkopt="-L/usr/local/lib/x86_64-unknown-linux-gnu" --linkopt="-larcher" \
+                            --test_env=LD_LIBRARY_PATH=/usr/local/lib/x86_64-unknown-linux-gnu \
                             --test_env=ARCHER_OPTIONS="verbose=1" --test_env=TSAN_OPTIONS="ignore_noninstrumented_modules=1"
 
 # We observe CPU overloads when having too many OpenMP threads in parallel on the CI machines.

{vmecpp-0.5.2 → vmecpp-0.5.4}/src/vmecpp/cpp/docker/tsan/Dockerfile

@@ -9,8 +9,9 @@ RUN apt-get install -y git
 # Setup the LLVM sources in /llvm.
 WORKDIR /llvm
 
-# Make a shallow clone of the LLVM repo.
-RUN git clone --depth 1 https://github.com/llvm/llvm-project.git
+# Pin to llvmorg-18.1.8 so the installed clang is version 18, matching the
+# hardcoded include path /usr/local/lib/clang/18/include in the Bazel toolchain.
+RUN git clone --depth 1 --branch llvmorg-18.1.8 https://github.com/llvm/llvm-project.git
 
 # Install more packages.
 # Split up to allow caching of above step of cloning the llvm repo.
@@ -21,19 +22,21 @@ RUN apt-get install -y \
     ninja-build
 
 # Build clang and libomp with TSan/Archer support.
+# install-clang installs the compiler to /usr/local/bin/clang (required by the
+# Bazel toolchain config). install-runtimes installs libarcher and libomp with
+# TSan support to /usr/local/lib.
 RUN cd llvm-project && \
     mkdir build && \
     cmake -G Ninja -S llvm -B build \
     -DCMAKE_BUILD_TYPE=Release \
+    -DCMAKE_INSTALL_PREFIX=/usr/local \
     -DLLVM_TARGETS_TO_BUILD="X86" \
     -DLLVM_ENABLE_PROJECTS="clang" \
     -DLLVM_ENABLE_RUNTIMES="compiler-rt;libcxx;libcxxabi;libunwind;openmp" && \
-    ninja -C build runtimes && \
-    ninja -C build install \
-    install-runtimes
+    ninja -C build install-clang install-runtimes
 
 # Install Bazel to be able to compile projects in the bind-mounted repo.
-RUN apt-get install -y curl && curl -L "https://github.com/bazelbuild/bazelisk/releases/download/v1.19.0/bazelisk-linux-amd64" --output "/usr/bin/bazel" \
+RUN apt-get install -y curl && curl -L "https://github.com/bazelbuild/bazelisk/releases/download/v1.24.1/bazelisk-linux-amd64" --output "/usr/bin/bazel" \
     && chmod a+x "/usr/bin/bazel"
 
 # Install packages required for building VMEC++.

{vmecpp-0.5.2 → vmecpp-0.5.4}/src/vmecpp/cpp/docker/tsan/README.md

@@ -38,16 +38,7 @@ support for being able to check OpenMP-parallelized C/C++ code.
    bazel clean --expunge
    ```
 
-5. Make sure the `LD_LIBRARY_PATH` environment variable is set to the location of
-   the `libarcher.so` library in the docker container:
-
-   ```bash
-   export LD_LIBRARY_PATH=/usr/local/lib/x86_64-unknown-linux-gnu
-   ```
-
-   TODO(jons): fix this - should not be needed (?)
-
-6. Run the unit tests for VMEC++ under TSan/Archer:
+5. Run the unit tests for VMEC++ under TSan/Archer:
 
    ```bash
    bazel test --config=tsan_archer_in_docker --test_output=streamed --nocache_test_results -- //vmecpp/... -//vmecpp/vmec/pybind11/...
@@ -56,7 +47,7 @@ support for being able to check OpenMP-parallelized C/C++ code.
    `pybind11` is disabled for now, as it does not compile yet with the new
    `clang`.
 
-7. Run example cases using the TSan-enabled executable:
+6. Run example cases using the TSan-enabled executable:
 
    ```bash
    export ARCHER_OPTIONS="verbose=1"
@@ -69,7 +60,7 @@ support for being able to check OpenMP-parallelized C/C++ code.
    bazel-bin/vmecpp/vmec/vmec_standalone/vmec_standalone vmecpp/example_inputs/w7x_ref_167_12_12.json
    ```
 
-8. Clean up the Bazel cache after the TSan/Archer work is done:
+7. Clean up the Bazel cache after the TSan/Archer work is done:
 
    ```bash
    docker> exit

{vmecpp-0.5.2 → vmecpp-0.5.4}/src/vmecpp/cpp/makegrid/makegrid/makegrid.cc

@@ -54,25 +54,6 @@ int main(int argc, char** argv) {
   const MagneticConfiguration& magnetic_configuration =
       *maybe_magnetic_configuration;
 
-  // make first internal copy to be able to
-  // migrate num_windings into circuit currents
-  MagneticConfiguration m_magnetic_configuration = magnetic_configuration;
-
-  // Normalized mode actually means in MAKEGRID-speak
-  // that the data from the 4-th column in the `coils.` file is divided out,
-  // and that is parsed here into the number of windings in each Coil.
-  // Hence, need to:
-  // a) make sure that num_windings is the same
-  //    for all Coils in a given SerialCircuit
-  // b) "migrate" the num_windings factor into
-  //    the circuit current, so that
-  //    num_windings can be 1
-  // c) set the number of windings to 1.0
-  //    if normalize_by_currents is true
-  if (makegrid_parameters.normalize_by_currents) {
-    CHECK_OK(NumWindingsToCircuitCurrents(m_magnetic_configuration));
-  }
-
   absl::StatusOr<Eigen::VectorXd> maybe_circuit_currents =
       GetCircuitCurrents(magnetic_configuration);
   CHECK_OK(maybe_circuit_currents);
@@ -81,14 +62,13 @@ int main(int argc, char** argv) {
   // compute the magnetic field cache and the vector potential cache
   absl::StatusOr<MagneticFieldResponseTable> maybe_magnetic_response_table =
       ComputeMagneticFieldResponseTable(makegrid_parameters,
-                                        m_magnetic_configuration);
+                                        magnetic_configuration);
   CHECK_OK(maybe_magnetic_response_table);
   const MagneticFieldResponseTable& magnetic_response_table =
       *maybe_magnetic_response_table;
 
   absl::StatusOr<MakegridCachedVectorPotential> maybe_vector_potential_cache =
-      ComputeVectorPotentialCache(makegrid_parameters,
-                                  m_magnetic_configuration);
+      ComputeVectorPotentialCache(makegrid_parameters, magnetic_configuration);
   CHECK_OK(maybe_vector_potential_cache);
   const MakegridCachedVectorPotential& vector_potential_cache =
       *maybe_vector_potential_cache;

vmecpp-0.5.4/src/vmecpp/cpp/third_party/fftx_codelets/BUILD.bazel

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: 2024-present Proxima Fusion GmbH <info@proximafusion.com>
+#
+# SPDX-License-Identifier: MIT
+#
+# Vendored FFTX/SPIRAL codelets for vmecpp's toroidal FFT path.
+# See README.md for what shapes are covered and how to regenerate.
+
+cc_library(
+    name = "fftx_codelets",
+    srcs = glob([
+        "lib_fftx_iprdftbat_cpu_srcs/*.cpp",
+        "lib_fftx_prdftbat_cpu_srcs/*.cpp",
+    ]),
+    hdrs = glob([
+        "lib_fftx_iprdftbat_cpu_srcs/*.h",
+        "lib_fftx_prdftbat_cpu_srcs/*.h",
+        "include/*.h",
+        "include/*.hpp",
+    ]),
+    includes = [
+        # SPIRAL kernels include <include/omega64.h>; this directory ends up on
+        # the search path so that resolves to "include/omega64.h" relative to
+        # the package root.
+        ".",
+        # Direct includes for fftx_minimal.hpp and the kernel public/decls
+        # headers.  Bazel adds the package-relative paths via "includes" so
+        # `#include "fftx_minimal.hpp"` works without a leading directory.
+        "include",
+        "lib_fftx_iprdftbat_cpu_srcs",
+        "lib_fftx_prdftbat_cpu_srcs",
+    ],
+    visibility = ["//visibility:public"],
+)