vesin-torch 0.2.0__tar.gz

vesin_torch-0.2.0/MANIFEST.in

@@ -0,0 +1,6 @@
+include pyproject.toml
+include LICENSE
+include VERSION
+
+recursive-include lib *
+recursive-include build-backend *.py

vesin_torch-0.2.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.1
+Name: vesin-torch
+Version: 0.2.0
+Summary: Computing neighbor lists for atomistic system, in TorchScript
+Author-email: Guillaume Fraux <guillaume.fraux@epfl.ch>
+License: BSD-3-Clause
+Project-URL: homepage, https://github.com/Luthaf/vesin/
+Project-URL: documentation, https://luthaf.fr/vesin/
+Project-URL: repository, https://github.com/Luthaf/vesin/
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: torch>=2.3
+
+# Vesin: fast neighbor lists for atomistic systems
+
+[![Documentation](https://img.shields.io/badge/docs-latest-brightgreen.svg)](http://luthaf.fr/vesin/)
+![Tests](https://img.shields.io/github/check-runs/Luthaf/vesin/main?logo=github&label=tests)
+
+| English 🇺🇸⁠/⁠🇬🇧 | Occitan <img src="./docs/src/static/images/Occitan.png" width=18> | French 🇫🇷 | Arpitan <img src="./docs/src/static/images/Arpitan.png" width=18> | Gallo‑Italic <img src="./docs/src/static/images/Lombardy.png" width=18> | Catalan <img src="./docs/src/static/images/Catalan.png" width=18> | Spanish 🇪🇸 | Italian 🇮🇹 |
+|------------------|----------|-----------|----------|--------------|---------|------------|------------|
+| neighbo(u)r      | vesin    | voisin    | vesin    | visin        | veí     | vecino     | vicino     |
+
+
+Vesin is a C library that computes neighbor lists for atomistic system, and tries
+to be fast and easy to use. We also provide a Python package to call the C
+library.
+
+### Installation
+
+To use the code from Python, you can install it with `pip`:
+
+```
+pip install vesin
+```
+
+See the [documentation](https://luthaf.fr/vesin/latest/index.html#installation)
+for more information on how to install the code to use it from C or C++.
+
+### Usage instruction
+
+You can either use the `NeighborList` calculator class:
+
+```py
+import numpy as np
+from vesin import NeighborList
+
+# positions can be anything compatible with numpy's ndarray
+positions = [
+    (0, 0, 0),
+    (0, 1.3, 1.3),
+]
+box = 3.2 * np.eye(3)
+
+calculator = NeighborList(cutoff=4.2, full_list=True)
+i, j, S, d = calculator.compute(
+    points=points,
+    box=box,
+    periodic=True,
+    quantities="ijSd"
+)
+```
+
+We also provide a function with drop-in compatibility to ASE's neighbor list:
+
+```py
+import ase
+from vesin import ase_neighbor_list
+
+atoms = ase.Atoms(...)
+
+i, j, S, d = ase_neighbor_list("ijSd", atoms, cutoff=4.2)
+```
+
+See the [documentation](https://luthaf.fr/vesin/latest/c-api.html) for more
+information on how to use the code from C or C++.
+
+### Benchmarks
+
+You can find below benchmark result computing neighbor lists for increasingly
+large diamond supercells, using an AMD 3955WX CPU and an NVIDIA 4070 Ti SUPER
+GPU. You can run this benchmark on your system with the script at
+`benchmarks/benchmark.py`. Missing points indicate that a specific code could
+not run the calculation (for example, NNPOps requires the cell to be twice the
+cutoff in size, and can't run with large cutoffs and small cells).
+
+![Benchmarks](./docs/src/benchmark.png)
+
+## License
+
+Vesin is is distributed under the [3 clauses BSD license](LICENSE). By
+contributing to this code, you agree to distribute your contributions under the
+same license.

vesin_torch-0.2.0/README.md

@@ -0,0 +1,79 @@
+# Vesin: fast neighbor lists for atomistic systems
+
+[![Documentation](https://img.shields.io/badge/docs-latest-brightgreen.svg)](http://luthaf.fr/vesin/)
+![Tests](https://img.shields.io/github/check-runs/Luthaf/vesin/main?logo=github&label=tests)
+
+| English 🇺🇸⁠/⁠🇬🇧 | Occitan <img src="./docs/src/static/images/Occitan.png" width=18> | French 🇫🇷 | Arpitan <img src="./docs/src/static/images/Arpitan.png" width=18> | Gallo‑Italic <img src="./docs/src/static/images/Lombardy.png" width=18> | Catalan <img src="./docs/src/static/images/Catalan.png" width=18> | Spanish 🇪🇸 | Italian 🇮🇹 |
+|------------------|----------|-----------|----------|--------------|---------|------------|------------|
+| neighbo(u)r      | vesin    | voisin    | vesin    | visin        | veí     | vecino     | vicino     |
+
+
+Vesin is a C library that computes neighbor lists for atomistic system, and tries
+to be fast and easy to use. We also provide a Python package to call the C
+library.
+
+### Installation
+
+To use the code from Python, you can install it with `pip`:
+
+```
+pip install vesin
+```
+
+See the [documentation](https://luthaf.fr/vesin/latest/index.html#installation)
+for more information on how to install the code to use it from C or C++.
+
+### Usage instruction
+
+You can either use the `NeighborList` calculator class:
+
+```py
+import numpy as np
+from vesin import NeighborList
+
+# positions can be anything compatible with numpy's ndarray
+positions = [
+    (0, 0, 0),
+    (0, 1.3, 1.3),
+]
+box = 3.2 * np.eye(3)
+
+calculator = NeighborList(cutoff=4.2, full_list=True)
+i, j, S, d = calculator.compute(
+    points=points,
+    box=box,
+    periodic=True,
+    quantities="ijSd"
+)
+```
+
+We also provide a function with drop-in compatibility to ASE's neighbor list:
+
+```py
+import ase
+from vesin import ase_neighbor_list
+
+atoms = ase.Atoms(...)
+
+i, j, S, d = ase_neighbor_list("ijSd", atoms, cutoff=4.2)
+```
+
+See the [documentation](https://luthaf.fr/vesin/latest/c-api.html) for more
+information on how to use the code from C or C++.
+
+### Benchmarks
+
+You can find below benchmark result computing neighbor lists for increasingly
+large diamond supercells, using an AMD 3955WX CPU and an NVIDIA 4070 Ti SUPER
+GPU. You can run this benchmark on your system with the script at
+`benchmarks/benchmark.py`. Missing points indicate that a specific code could
+not run the calculation (for example, NNPOps requires the cell to be twice the
+cutoff in size, and can't run with large cutoffs and small cells).
+
+![Benchmarks](./docs/src/benchmark.png)
+
+## License
+
+Vesin is is distributed under the [3 clauses BSD license](LICENSE). By
+contributing to this code, you agree to distribute your contributions under the
+same license.

vesin_torch-0.2.0/VERSION

@@ -0,0 +1 @@
+0.2.0

vesin_torch-0.2.0/build-backend/backend.py

@@ -0,0 +1,29 @@
+# This is a custom Python build backend wrapping setuptool's to add a build-time
+# dependencies on torch/cmake when building the wheel and not the sdist
+import os
+
+from setuptools import build_meta
+
+ROOT = os.path.realpath(os.path.dirname(__file__))
+
+FORCED_TORCH_VERSION = os.environ.get("VESIN_TORCH_BUILD_WITH_TORCH_VERSION")
+if FORCED_TORCH_VERSION is not None:
+    TORCH_DEP = f"torch =={FORCED_TORCH_VERSION}"
+else:
+    TORCH_DEP = "torch >=2.3"
+
+# ==================================================================================== #
+#                   Build backend functions definition                                 #
+# ==================================================================================== #
+
+# Use the default version of these
+prepare_metadata_for_build_wheel = build_meta.prepare_metadata_for_build_wheel
+get_requires_for_build_sdist = build_meta.get_requires_for_build_sdist
+build_wheel = build_meta.build_wheel
+build_sdist = build_meta.build_sdist
+
+
+# Special dependencies to build the wheels
+def get_requires_for_build_wheel(config_settings=None):
+    defaults = build_meta.get_requires_for_build_wheel(config_settings)
+    return defaults + ["cmake", TORCH_DEP]

vesin_torch-0.2.0/lib/CMakeLists.txt

@@ -0,0 +1,76 @@
+cmake_minimum_required(VERSION 3.16)
+
+file(READ "VERSION" VESIN_VERSION)
+string(STRIP ${VESIN_VERSION} VESIN_VERSION)
+
+project(vesin LANGUAGES C CXX VERSION ${VESIN_VERSION})
+
+if (${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR})
+    set(VESIN_MAIN_PROJECT ON)
+else()
+    set(VESIN_MAIN_PROJECT OFF)
+endif()
+
+if (VESIN_MAIN_PROJECT)
+    if("${CMAKE_BUILD_TYPE}" STREQUAL "" AND "${CMAKE_CONFIGURATION_TYPES}" STREQUAL "")
+        message(STATUS "Setting build type to 'release' as none was specified.")
+        set(
+            CMAKE_BUILD_TYPE "release"
+            CACHE STRING
+            "Choose the type of build, options are: none(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) debug release relwithdebinfo minsizerel."
+            FORCE
+        )
+        set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS release debug relwithdebinfo minsizerel none)
+    endif()
+endif()
+
+option(BUILD_SHARED_LIBS "Build shared libraries instead of static ones" OFF)
+option(VESIN_BUILD_TESTS "Build and run Vesin's unit tests" OFF)
+option(VESIN_INSTALL "Install Vesin's headers and libraries" ${VESIN_MAIN_PROJECT})
+option(VESIN_TORCH "Build the vesin_torch library" OFF)
+
+set(VESIN_SOURCES
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/vesin.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/cpu_cell_list.cpp
+)
+add_library(vesin ${VESIN_SOURCES})
+
+target_include_directories(vesin PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:${INCLUDE_INSTALL_DIR}>
+)
+
+target_compile_features(vesin PRIVATE cxx_std_17)
+
+set_target_properties(vesin PROPERTIES
+    # hide non-exported symbols by default
+    CXX_VISIBILITY_PRESET hidden
+    VISIBILITY_INLINES_HIDDEN ON
+)
+
+target_compile_definitions(vesin PRIVATE VESIN_EXPORTS)
+if (BUILD_SHARED_LIBS)
+    target_compile_definitions(vesin PUBLIC VESIN_SHARED)
+endif()
+
+if (VESIN_BUILD_TESTS)
+    enable_testing()
+    add_subdirectory(tests)
+endif()
+
+if (VESIN_TORCH)
+    add_subdirectory(torch)
+endif()
+
+#------------------------------------------------------------------------------#
+# Installation configuration
+#------------------------------------------------------------------------------#
+if (VESIN_INSTALL)
+    install(TARGETS vesin
+        ARCHIVE DESTINATION "lib"
+        LIBRARY DESTINATION "lib"
+        RUNTIME DESTINATION "bin"
+    )
+
+    install(FILES "include/vesin.h" DESTINATION "include")
+endif()

vesin_torch-0.2.0/lib/VERSION

@@ -0,0 +1 @@
+0.2.0

vesin_torch-0.2.0/lib/include/vesin.h

@@ -0,0 +1,156 @@
+#ifndef VESIN_H
+#define VESIN_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#if defined(VESIN_SHARED)
+    #if defined(VESIN_EXPORTS)
+        #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+            #define VESIN_API __attribute__((visibility("default")))
+        #elif defined(_MSC_VER)
+            #define VESIN_API __declspec(dllexport)
+        #else
+            #define VESIN_API
+        #endif
+    #else
+        #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+            #define VESIN_API __attribute__((visibility("default")))
+        #elif defined(_MSC_VER)
+            #define VESIN_API __declspec(dllimport)
+        #else
+            #define VESIN_API
+        #endif
+    #endif
+#else
+    #define VESIN_API
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Options for a neighbor list calculation
+struct VesinOptions {
+    /// Spherical cutoff, only pairs below this cutoff will be included
+    double cutoff;
+    /// Should the returned neighbor list be a full list (include both `i -> j`
+    /// and `j -> i` pairs) or a half list (include only `i -> j`)?
+    bool full;
+    // TODO: sort option?
+
+    /// Should the returned `VesinNeighborList` contain `shifts`?
+    bool return_shifts;
+    /// Should the returned `VesinNeighborList` contain `distances`?
+    bool return_distances;
+    /// Should the returned `VesinNeighborList` contain `vector`?
+    bool return_vectors;
+};
+
+/// Device on which the data can be
+enum VesinDevice {
+    /// Unknown device, used for default initialization and to indicate no
+    /// allocated data.
+    VesinUnknownDevice = 0,
+    /// CPU device
+    VesinCPU = 1,
+};
+
+
+/// The actual neighbor list
+///
+/// This is organized as a list of pairs, where each pair can contain the
+/// following data:
+///
+/// - indices of the points in the pair;
+/// - distance between points in the pair, accounting for periodic boundary
+///   conditions;
+/// - vector between points in the pair, accounting for periodic boundary
+///   conditions;
+/// - periodic shift that created the pair. This is only relevant when using
+///   periodic boundary conditions, and contains the number of bounding box we
+///   need to cross to create the pair. If the positions of the points are `r_i`
+///   and `r_j`, the bounding box is described by a matrix of three vectors `H`,
+///   and the periodic shift is `S`, the distance vector for a given pair will
+///   be given by `r_ij = r_j - r_i + S @ H`.
+///
+/// Under periodic boundary conditions, two atoms can be part of multiple pairs,
+/// each pair having a different periodic shift.
+struct VESIN_API VesinNeighborList {
+#ifdef __cplusplus
+    VesinNeighborList():
+        length(0),
+        device(VesinUnknownDevice),
+        pairs(nullptr),
+        shifts(nullptr),
+        distances(nullptr),
+        vectors(nullptr)
+    {}
+#endif
+
+    /// Number of pairs in this neighbor list
+    size_t length;
+    /// Device used for the data allocations
+    VesinDevice device;
+    /// Array of pairs (storing the indices of the first and second point in the
+    /// pair), containing `length` elements.
+    size_t (*pairs)[2];
+    /// Array of box shifts, one for each `pair`. This is only set if
+    /// `options.return_pairs` was `true` during the calculation.
+    int32_t (*shifts)[3];
+    /// Array of pair distance (i.e. distance between the two points), one for
+    /// each pair. This is only set if `options.return_distances` was `true`
+    /// during the calculation.
+    double *distances;
+    /// Array of pair vector (i.e. vector between the two points), one for
+    /// each pair. This is only set if `options.return_vector` was `true`
+    /// during the calculation.
+    double (*vectors)[3];
+
+    // TODO: custom memory allocators?
+};
+
+/// Free all allocated memory inside a `VesinNeighborList`, according the it's
+/// `device`.
+void VESIN_API vesin_free(struct VesinNeighborList* neighbors);
+
+/// Compute a neighbor list.
+///
+/// The data is returned in a `VesinNeighborList`. For an initial call, the
+/// `VesinNeighborList` should be zero-initialized (or default-initalized in
+/// C++). The `VesinNeighborList` can be re-used across calls to this functions
+/// to re-use memory allocations, and once it is no longer needed, users should
+/// call `vesin_free` to release the corresponding memory.
+///
+/// @param points positions of all points in the system;
+/// @param n_points number of elements in the `points` array
+/// @param box bounding box for the system. If the system is non-periodic,
+///     this is ignored. This should contain the three vectors of the bounding
+///     box, one vector per row of the matrix.
+/// @param periodic is the system using periodic boundary conditions?
+/// @param device device where the `points` and `box` data is allocated.
+/// @param options options for the calculation
+/// @param neighbors non-NULL pointer to `VesinNeighborList` that will be used
+///     to store the computed list of neighbors.
+/// @param error_message Pointer to a `char*` that wil be set to the error
+///     message if this function fails. This does not need to be freed when no
+///     longer needed.
+int VESIN_API vesin_neighbors(
+    const double (*points)[3],
+    size_t n_points,
+    const double box[3][3],
+    bool periodic,
+    VesinDevice device,
+    struct VesinOptions options,
+    struct VesinNeighborList* neighbors,
+    const char** error_message
+);
+
+
+#ifdef __cplusplus
+
+} // extern "C"
+
+#endif
+
+#endif