nep-adapters 1.0.0__tar.gz

nep_adapters-1.0.0/.github/workflows/python-package.yml

@@ -0,0 +1,284 @@
+name: Build Python packages
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        description: Existing tag to validate/build, or empty for the current ref
+        required: false
+        default: ""
+        type: string
+      build_gpu:
+        description: Build combined Linux and Windows CPU+CUDA wheels
+        required: false
+        default: true
+        type: boolean
+      windows_cuda_only:
+        description: Build only the Windows CPython 3.10 CPU+CUDA validation wheel
+        required: false
+        default: false
+        type: boolean
+      linux_cuda_only:
+        description: Build only the Linux CPython 3.10 CPU+CUDA wheel
+        required: false
+        default: false
+        type: boolean
+
+permissions:
+  contents: read
+
+concurrency:
+  group: python-package-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: false
+
+env:
+  TARGET_REF: ${{ github.event_name == 'release' && github.event.release.tag_name || inputs.tag_name || github.ref }}
+
+jobs:
+  sdist:
+    name: Source distribution
+    if: >-
+      github.event_name != 'workflow_dispatch' ||
+      (!inputs.windows_cuda_only && !inputs.linux_cuda_only)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          ref: ${{ env.TARGET_REF }}
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+          cache: pip
+      - name: Validate release version
+        if: github.event_name == 'release' || inputs.tag_name != ''
+        env:
+          RELEASE_TAG: ${{ github.event_name == 'release' && github.event.release.tag_name || inputs.tag_name }}
+        run: |
+          python - <<'PY'
+          import os
+          import tomllib
+          from pathlib import Path
+
+          version = tomllib.loads(Path("pyproject.toml").read_text())["project"]["version"]
+          expected = f"v{version}"
+          actual = os.environ["RELEASE_TAG"]
+          if actual != expected:
+              raise SystemExit(f"release tag {actual!r} must equal {expected!r}")
+          PY
+      - name: Build and verify sdist
+        env:
+          NEP_CUDA: "0"
+        run: |
+          python -m pip install --upgrade pip build twine
+          python -m build --sdist
+          python -m twine check dist/*
+          python -m pip install dist/*.tar.gz
+          python -c "import nep_adapters"
+      - uses: actions/upload-artifact@v6
+        with:
+          name: python-sdist
+          path: dist/*.tar.gz
+          if-no-files-found: error
+
+  cpu_wheels:
+    name: CPU wheels (${{ matrix.label }})
+    if: >-
+      github.event_name != 'workflow_dispatch' ||
+      (!inputs.windows_cuda_only && !inputs.linux_cuda_only)
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: macos-15-intel
+            label: macos-x86_64
+            archs: x86_64
+            macos_target: "14.0"
+          - os: macos-14
+            label: macos-arm64
+            archs: arm64
+            macos_target: "14.0"
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          ref: ${{ env.TARGET_REF }}
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+      - name: Build platform wheels
+        uses: pypa/cibuildwheel@8d2b08b68458a16aeb24b64e68a09ab1c8e82084 # v3.4.1
+        env:
+          CIBW_ENVIRONMENT: NEP_CUDA=0
+          CIBW_ARCHS: ${{ matrix.archs }}
+          CIBW_BEFORE_ALL_MACOS: brew install libomp
+          CIBW_ENVIRONMENT_MACOS: >-
+            MACOSX_DEPLOYMENT_TARGET=${{ matrix.macos_target }}
+      - name: Audit platform wheel contents
+        run: python tools/check_wheel_contents.py --variant cpu --wheel-dir wheelhouse
+      - uses: actions/upload-artifact@v6
+        with:
+          name: python-platform-${{ matrix.label }}
+          path: wheelhouse/*.whl
+          if-no-files-found: error
+
+  gpu_wheels:
+    name: Combined CPU+CUDA wheels (Linux x86_64)
+    if: >-
+      (github.event_name == 'release' ||
+      inputs.tag_name != '' ||
+      inputs.build_gpu ||
+      inputs.linux_cuda_only) &&
+      !inputs.windows_cuda_only
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          ref: ${{ env.TARGET_REF }}
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+      - name: Build combined wheels
+        uses: pypa/cibuildwheel@8d2b08b68458a16aeb24b64e68a09ab1c8e82084 # v3.4.1
+        env:
+          CIBW_ARCHS_LINUX: x86_64
+          CIBW_BUILD: >-
+            ${{ inputs.linux_cuda_only &&
+            'cp310-manylinux_x86_64' ||
+            'cp310-manylinux_x86_64 cp311-manylinux_x86_64 cp312-manylinux_x86_64 cp313-manylinux_x86_64 cp314-manylinux_x86_64' }}
+          CIBW_BEFORE_ALL_LINUX: |
+            set -euxo pipefail
+            dnf install -y dnf-plugins-core
+            dnf config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/rhel8/x86_64/cuda-rhel8.repo
+            dnf install -y gcc-toolset-13-gcc-c++ cuda-compiler-12-4 cuda-cudart-devel-12-4
+            ln -sfn /usr/local/cuda-12.4 /usr/local/cuda
+          CIBW_ENVIRONMENT_LINUX: >-
+            PATH=/usr/local/cuda/bin:$PATH
+            CC=/opt/rh/gcc-toolset-13/root/usr/bin/gcc
+            CXX=/opt/rh/gcc-toolset-13/root/usr/bin/g++
+            CUDACXX=/usr/local/cuda/bin/nvcc
+            CUDAHOSTCXX=/opt/rh/gcc-toolset-13/root/usr/bin/g++
+            CMAKE_ARGS="-DNEP_ADAPTERS_CUDA_ENABLE_QNEP_PPPM=OFF
+            -DCMAKE_CUDA_HOST_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/g++
+            -DCMAKE_CUDA_ARCHITECTURES=60-real;89-real;60-virtual"
+          CIBW_TEST_COMMAND_LINUX: >-
+            NEP_ADAPTERS_EXPECT_GPU_MODULE=1
+            python {project}/frontends/python/tests/test_wheel_install.py
+      - name: Audit combined wheel contents
+        run: python tools/check_wheel_contents.py --variant combined --wheel-dir wheelhouse
+      - uses: actions/upload-artifact@v6
+        with:
+          name: python-combined-linux-x86_64
+          path: wheelhouse/*.whl
+          if-no-files-found: error
+
+  windows_cuda_wheels:
+    name: Combined CPU+CUDA wheels (Windows x86_64)
+    if: >-
+      (github.event_name == 'release' ||
+      inputs.tag_name != '' ||
+      inputs.build_gpu ||
+      inputs.windows_cuda_only) &&
+      !inputs.linux_cuda_only
+    runs-on: windows-2022
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          ref: ${{ env.TARGET_REF }}
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+      - name: Install CUDA 12.4
+        id: cuda-toolkit
+        uses: Jimver/cuda-toolkit@3d45d157f327c09c04b50ee6ccdea2d9d017ec76 # v0.2.35
+        with:
+          cuda: "12.4.1"
+          method: network
+          sub-packages: '["nvcc", "cudart", "visual_studio_integration"]'
+      - name: Build combined wheel
+        uses: pypa/cibuildwheel@8d2b08b68458a16aeb24b64e68a09ab1c8e82084 # v3.4.1
+        env:
+          CIBW_ARCHS_WINDOWS: AMD64
+          CIBW_BUILD: >-
+            ${{ inputs.windows_cuda_only &&
+            'cp310-win_amd64' ||
+            'cp310-win_amd64 cp311-win_amd64 cp312-win_amd64 cp313-win_amd64 cp314-win_amd64' }}
+          CIBW_ENVIRONMENT_WINDOWS: >-
+            CMAKE_GENERATOR="Visual Studio 17 2022"
+            CUDAToolkit_ROOT="${{ steps.cuda-toolkit.outputs.CUDA_PATH }}"
+            CMAKE_ARGS="-DNEP_ADAPTERS_CUDA_ENABLE_QNEP_PPPM=OFF
+            -DCMAKE_CUDA_ARCHITECTURES=60-real;89-real;60-virtual"
+          CIBW_TEST_ENVIRONMENT_WINDOWS: NEP_ADAPTERS_EXPECT_GPU_MODULE=1
+      - name: Audit combined wheel contents
+        run: python tools/check_wheel_contents.py --variant combined --wheel-dir wheelhouse
+      - uses: actions/upload-artifact@v6
+        with:
+          name: python-combined-windows-x86_64
+          path: wheelhouse/*.whl
+          if-no-files-found: error
+
+  release_assets:
+    name: Attach packages to GitHub release
+    needs: [sdist, cpu_wheels, gpu_wheels, windows_cuda_wheels]
+    if: >-
+      always() &&
+      github.event_name == 'release' &&
+      needs.sdist.result == 'success' &&
+      needs.cpu_wheels.result == 'success' &&
+      needs.gpu_wheels.result == 'success' &&
+      needs.windows_cuda_wheels.result == 'success'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/download-artifact@v7
+        with:
+          pattern: python-*
+          path: dist
+          merge-multiple: true
+      - name: Upload release assets
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ github.event_name == 'release' && github.event.release.tag_name || inputs.tag_name }}
+          files: dist/*
+          overwrite_files: true
+
+  publish_pypi:
+    name: Publish packages to PyPI
+    needs: [sdist, cpu_wheels, gpu_wheels, windows_cuda_wheels]
+    if: >-
+      always() &&
+      github.event_name == 'release' &&
+      needs.sdist.result == 'success' &&
+      needs.cpu_wheels.result == 'success' &&
+      needs.gpu_wheels.result == 'success' &&
+      needs.windows_cuda_wheels.result == 'success'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v7
+        with:
+          name: python-sdist
+          path: dist
+      - uses: actions/download-artifact@v7
+        with:
+          pattern: python-platform-*
+          path: dist
+          merge-multiple: true
+      - uses: actions/download-artifact@v7
+        if: needs.gpu_wheels.result == 'success'
+        with:
+          pattern: python-combined-*
+          path: dist
+          merge-multiple: true
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist

nep_adapters-1.0.0/.gitignore

@@ -0,0 +1,30 @@
+.DS_Store
+__pycache__/
+*.py[cod]
+
+/build*/
+/.build/
+/reports/
+/diagnostics/
+/tmp/
+/CMakeFiles/
+/CMakeCache.txt
+/Makefile
+/cmake_install.cmake
+/CTestTestfile.cmake
+/Testing/
+/install_manifest.txt
+
+/reports/
+/benchmarks/results/
+/tmp/hpc-platform/
+/analysis/scaling_tile16_20260706/
+/analysis/scaling_al_tile16_20260706/
+/dist/
+*.egg-info/
+
+*.o
+*.obj
+*.a
+*.so
+*.dylib

nep_adapters-1.0.0/AGENTS.md

@@ -0,0 +1,28 @@
+# Repository Agent Notes
+
+## Python Environment
+
+Use the `mysci` conda environment for Python-facing work:
+
+```sh
+source /Users/superbing/miniconda3/etc/profile.d/conda.sh
+conda activate mysci
+```
+
+For CMake builds that enable the Python frontend, pass:
+
+```sh
+-DPython3_EXECUTABLE=/Users/superbing/miniconda3/envs/mysci/bin/python
+```
+
+## Virial Ordering Contract
+
+Keep virial ordering explicit at public API boundaries:
+
+- `find_force_batch` follows `NEP::compute` raw9 order:
+  `xx, xy, xz, yx, yy, yz, zx, zy, zz`.
+- `find_force_lammps_neighbors` follows LAMMPS order. `total_virial6` is
+  `xx, yy, zz, xy, xz, yz`; per-atom raw9 is
+  `xx, yy, zz, xy, xz, yz, yx, zx, zy`.
+- Engine-internal storage may use a different layout, but copyback must convert
+  to the relevant public API order before returning results.

nep_adapters-1.0.0/CMakeLists.txt

@@ -0,0 +1,122 @@
+cmake_minimum_required(VERSION 3.24)
+
+include(cmake/NEPAdaptersCUDAAutoDetect.cmake)
+nep_adapters_resolve_cuda_default(NEP_ADAPTERS_ENABLE_CUDA_DEFAULT)
+option(NEP_ADAPTERS_ENABLE_CUDA
+  "Enable CUDA; auto-detects nvcc unless NEP_CUDA or this option is set"
+  ${NEP_ADAPTERS_ENABLE_CUDA_DEFAULT})
+unset(NEP_ADAPTERS_ENABLE_CUDA_DEFAULT)
+option(
+  NEP_ADAPTERS_CUDA_ENABLE_QNEP_PPPM
+  "Build the optional qNEP PPPM implementation and link cuFFT"
+  OFF)
+
+if(NEP_ADAPTERS_CUDA_ENABLE_QNEP_PPPM AND NOT NEP_ADAPTERS_ENABLE_CUDA)
+  message(FATAL_ERROR
+    "NEP_ADAPTERS_CUDA_ENABLE_QNEP_PPPM=ON requires NEP_ADAPTERS_ENABLE_CUDA=ON.")
+endif()
+
+if(NEP_ADAPTERS_ENABLE_CUDA AND
+   NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
+  set(CMAKE_CUDA_ARCHITECTURES native)
+endif()
+if(NEP_ADAPTERS_ENABLE_CUDA)
+  message(STATUS
+    "NEPAdapters CUDA architectures: ${CMAKE_CUDA_ARCHITECTURES}")
+endif()
+
+if(NEP_ADAPTERS_ENABLE_CUDA)
+  project(NEPAdapters VERSION 1.0.0 LANGUAGES CXX CUDA)
+else()
+  project(NEPAdapters VERSION 1.0.0 LANGUAGES CXX)
+endif()
+
+include(CMakePackageConfigHelpers)
+include(GNUInstallDirs)
+
+option(NEP_ADAPTERS_BUILD_TESTS "Build NEPAdapters tests" ON)
+option(NEP_ADAPTERS_BUILD_BENCHMARKS "Build NEPAdapters performance benchmarks" OFF)
+option(NEP_ADAPTERS_ENABLE_CPU "Enable the CPU engine" ON)
+option(NEP_ADAPTERS_ENABLE_PYTHON "Enable the Python frontend" OFF)
+option(NEP_ADAPTERS_ENABLE_LAMMPS "Enable the LAMMPS frontend" OFF)
+option(
+  NEP_ADAPTERS_INSTALL_DEVELOPMENT_FILES
+  "Install C/C++ libraries, headers, and CMake package metadata"
+  ON)
+
+set(NEP_ADAPTERS_PACKAGE_NEEDS_OPENMP OFF)
+set(NEP_ADAPTERS_PACKAGE_NEEDS_BLAS OFF)
+set(NEP_ADAPTERS_PACKAGE_NEEDS_CUDATOOLKIT OFF)
+
+if(NEP_ADAPTERS_BUILD_TESTS OR NEP_ADAPTERS_BUILD_BENCHMARKS)
+  include("${CMAKE_CURRENT_SOURCE_DIR}/cmake/NEPAdaptersTestData.cmake")
+  enable_testing()
+endif()
+
+add_subdirectory(src)
+
+if(NEP_ADAPTERS_ENABLE_CPU)
+  add_subdirectory(engines/cpu)
+endif()
+
+if(NEP_ADAPTERS_ENABLE_CUDA)
+  add_subdirectory(engines/cuda)
+endif()
+
+if(NEP_ADAPTERS_ENABLE_PYTHON)
+  add_subdirectory(frontends/python)
+endif()
+
+if(NEP_ADAPTERS_ENABLE_LAMMPS)
+  add_subdirectory(frontends/lammps)
+endif()
+
+if(NEP_ADAPTERS_BUILD_TESTS)
+  add_subdirectory(tests)
+endif()
+
+if(NEP_ADAPTERS_BUILD_BENCHMARKS)
+  add_subdirectory(benchmarks)
+endif()
+
+if(NEP_ADAPTERS_INSTALL_DEVELOPMENT_FILES)
+  install(
+    DIRECTORY include/
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+  )
+
+  install(
+    TARGETS nep_adapters
+    EXPORT NEPAdaptersTargets
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  )
+
+  install(
+    EXPORT NEPAdaptersTargets
+    NAMESPACE NEPAdapters::
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/NEPAdapters
+  )
+endif()
+
+configure_package_config_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/cmake/NEPAdaptersConfig.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/NEPAdaptersConfig.cmake
+  INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/NEPAdapters
+)
+
+write_basic_package_version_file(
+  ${CMAKE_CURRENT_BINARY_DIR}/NEPAdaptersConfigVersion.cmake
+  VERSION ${PROJECT_VERSION}
+  COMPATIBILITY SameMajorVersion
+)
+
+if(NEP_ADAPTERS_INSTALL_DEVELOPMENT_FILES)
+  install(
+    FILES
+      ${CMAKE_CURRENT_BINARY_DIR}/NEPAdaptersConfig.cmake
+      ${CMAKE_CURRENT_BINARY_DIR}/NEPAdaptersConfigVersion.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/NEPAdapters
+  )
+endif()