CLUEstering 2.2.0__tar.gz → 2.2.2__tar.gz

{CLUEstering-2.2.0 → CLUEstering-2.2.2}/CLUEstering/CLUEstering.py

@@ -20,17 +20,47 @@ path = dirname(__file__)
 sys.path.insert(1, join(path, 'lib'))
 import CLUE_Convolutional_Kernels as clue_kernels
 import CLUE_CPU_Serial as cpu_serial
+
+backends = ["cpu serial"]
 tbb_found = exists(str(*glob(join(path, 'lib/CLUE_CPU_TBB*.so'))))
 if tbb_found:
     import CLUE_CPU_TBB as cpu_tbb
+    backends.append("cpu tbb")
 cuda_found = exists(str(*glob(join(path, 'lib/CLUE_GPU_CUDA*.so'))))
 if cuda_found:
     import CLUE_GPU_CUDA as gpu_cuda
+    backends.append("gpu cuda")
 hip_found = exists(str(*glob(join(path, 'lib/CLUE_GPU_HIP*.so'))))
 if hip_found:
     import CLUE_GPU_HIP as gpu_hip
+    backends.append("gpu hip")
+
+
+def is_tbb_available():
+    """
+    Returns True if the library is compiled with TBB support, False otherwise.
+    """
+
+    return tbb_found
+
+
+def is_cuda_available():
+    """
+    Returns True if the library is compiled with CUDA support, False otherwise.
+    """
+
+    return cuda_found
+
+
+def is_hip_available():
+    """
+    Returns True if the library is compiled with HIP support, False otherwise.
+    """
+
+    return hip_found
 
-def test_blobs(n_samples: int, n_dim: int , n_blobs: int = 4, mean: float = 0,
+
+def test_blobs(n_samples: int, n_dim: int, n_blobs: int = 4, mean: float = 0,
                sigma: float = 0.5, x_max: float = 30, y_max: float = 30) -> pd.DataFrame:
     """
     Returns a dataframe containing randomly generated 2-dimensional or 3-dimensional blobs.
@@ -139,6 +169,10 @@ class cluster_properties:
     ----------
     n_clusters : int
         Number of clusters constructed.
+    n_seeds : int
+        Number of seeds found, which indicates the clusters excluding the group of outliers.
+    clusters : np.ndarray
+        Array containing the list of the clusters found.
     cluster_ids : np.ndarray
         Array containing the cluster_id of each point.
     is_seed : np.ndarray
@@ -153,6 +187,8 @@ class cluster_properties:
     """
 
     n_clusters : int
+    n_seeds : int
+    clusters : np.ndarray
     cluster_ids : np.ndarray
     is_seed : np.ndarray
     cluster_points : np.ndarray
@@ -162,6 +198,8 @@ class cluster_properties:
     def __eq__(self, other):
         if self.n_clusters != other.n_clusters:
             return False
+        if self.n_seeds != other.n_seeds:
+            return False
         if not (self.cluster_ids == other.cluster_ids).all():
             return False
         if not (self.is_seed == other.is_seed).all():
@@ -637,13 +675,17 @@ class clusterer:
 
         Modified attributes
         -------------------
+        n_clusters : int
+            Number of clusters reconstructed.
+        n_seeds : int
+            Number of seeds found, which indicates the clusters excluding the group of outliers.
+        clusters : ndarray
+            Array containing the list of the clusters found.
         cluster_ids : ndarray
             Contains the cluster_id corresponding to every point.
         is_seed : ndarray
             For every point the value is 1 if the point is a seed or an
             outlier and 0 if it isn't.
-        n_clusters : int
-            Number of clusters reconstructed.
         cluster_points : ndarray of lists
             Contains, for every cluster, the list of points associated to id.
         points_per_cluster : ndarray
@@ -693,7 +735,9 @@ class clusterer:
         finish = time.time_ns()
         cluster_ids = np.array(cluster_id_is_seed[0])
         is_seed = np.array(cluster_id_is_seed[1])
-        n_clusters = len(np.unique(cluster_ids))
+        clusters = np.unique(cluster_ids)
+        n_seeds = np.sum([1 for i in clusters if i > -1])
+        n_clusters = len(clusters)
 
         cluster_points = [[] for _ in range(n_clusters)]
         for i in range(self.clust_data.n_points):
@@ -705,6 +749,8 @@ class clusterer:
         output_df = pd.DataFrame(data)
 
         self.clust_prop = cluster_properties(n_clusters,
+                                             n_seeds,
+                                             clusters,
                                              cluster_ids,
                                              is_seed,
                                              np.asarray(cluster_points, dtype=object),
@@ -725,6 +771,22 @@ class clusterer:
 
         return self.clust_prop.n_clusters
 
+    @property
+    def n_seeds(self) -> int:
+        '''
+        Returns the number of seeds found.
+        '''
+
+        return self.clust_prop.n_seeds
+
+    @property
+    def clusters(self) -> np.ndarray:
+        '''
+        Returns the list of clusters found.
+        '''
+
+        return self.clust_prop.clusters
+
     @property
     def cluster_ids(self) -> np.ndarray:
         '''

{CLUEstering-2.2.0 → CLUEstering-2.2.2}/CLUEstering/alpaka/AlpakaCore/alpakaWorkDiv.h

@@ -361,6 +361,18 @@ namespace cms::alpakatools {
     }
   }
 
+  /* once_per_grid
+   *
+   * `once_per_grid(acc)` returns true for a single thread within the kernel execution grid.
+   *
+   * Usually the condition is true for block 0 and thread 0, but these indices should not be relied upon.
+   */
+  template <typename TAcc, typename = std::enable_if_t<alpaka::isAccelerator<TAcc>>>
+  ALPAKA_FN_ACC inline constexpr bool once_per_grid(TAcc const& acc) {
+    return alpaka::getIdx<alpaka::Grid, alpaka::Threads>(acc) ==
+           Vec<alpaka::Dim<TAcc>>::zeros();
+  }
+
   /*
    * Overload for elementIdxShift = 0
    */

CLUEstering-2.2.2/CLUEstering/alpaka/CLUE/binding.cc

@@ -0,0 +1,123 @@
+
+#include <alpaka/alpaka.hpp>
+#include <vector>
+
+#include "../CLUE/Run.h"
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+namespace ALPAKA_ACCELERATOR_NAMESPACE {
+  void listDevices(const std::string& backend) {
+    const char tab = '\t';
+    const std::vector<Device> devices = alpaka::getDevs<Platform>();
+    if (devices.empty()) {
+      std::cout << "No devices found for the " << backend << " backend." << std::endl;
+      return;
+    } else {
+      std::cout << backend << " devices found: \n";
+      for (size_t i{}; i < devices.size(); ++i) {
+        std::cout << tab << "device " << i << ": " << alpaka::getName(devices[i]) << '\n';
+      }
+    }
+  }
+
+  template <typename Kernel>
+  std::vector<std::vector<int>> mainRun(float dc,
+                                        float rhoc,
+                                        float outlier,
+                                        int pPBin,
+                                        const std::vector<std::vector<float>>& coords,
+                                        const std::vector<float>& weights,
+                                        const Kernel& kernel,
+                                        int Ndim,
+                                        size_t block_size,
+                                        size_t device_id) {
+    const auto dev_acc = alpaka::getDevByIdx<Acc1D>(device_id);
+
+    // Create the queue
+    Queue queue_(dev_acc);
+
+    // Running the clustering algorithm //
+    switch (Ndim) {
+      [[unlikely]] case (1):
+        return run<1, Kernel>(
+            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+      [[likely]] case (2):
+        return run<2, Kernel>(
+            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+      [[likely]] case (3):
+        return run<3, Kernel>(
+            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+      [[unlikely]] case (4):
+        return run<4, Kernel>(
+            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+      [[unlikely]] case (5):
+        return run<5, Kernel>(
+            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+      [[unlikely]] case (6):
+        return run<6, Kernel>(
+            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+      [[unlikely]] case (7):
+        return run<7, Kernel>(
+            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+      [[unlikely]] case (8):
+        return run<8, Kernel>(
+            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+      [[unlikely]] case (9):
+        return run<9, Kernel>(
+            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+      [[unlikely]] case (10):
+        return run<10, Kernel>(
+            dc, rhoc, outlier, pPBin, coords, weights, kernel, queue_, block_size);
+      [[unlikely]] default:
+        std::cout << "This library only works up to 10 dimensions\n";
+        return {};
+    }
+  }
+
+  PYBIND11_MODULE(CLUE_CPU_Serial, m) {
+    m.doc() = "Binding of the CLUE algorithm running serially on CPU";
+
+    m.def("listDevices",
+          &listDevices,
+          "List the available devices for the CPU serial backend");
+    m.def("mainRun",
+          pybind11::overload_cast<float,
+                                  float,
+                                  float,
+                                  int,
+                                  const std::vector<std::vector<float>>&,
+                                  const std::vector<float>&,
+                                  const FlatKernel&,
+                                  int,
+                                  size_t,
+                                  size_t>(&mainRun<FlatKernel>),
+          "mainRun");
+    m.def("mainRun",
+          pybind11::overload_cast<float,
+                                  float,
+                                  float,
+                                  int,
+                                  const std::vector<std::vector<float>>&,
+                                  const std::vector<float>&,
+                                  const ExponentialKernel&,
+                                  int,
+                                  size_t,
+                                  size_t>(&mainRun<ExponentialKernel>),
+          "mainRun");
+    m.def("mainRun",
+          pybind11::overload_cast<float,
+                                  float,
+                                  float,
+                                  int,
+                                  const std::vector<std::vector<float>>&,
+                                  const std::vector<float>&,
+                                  const GaussianKernel&,
+                                  int,
+                                  size_t,
+                                  size_t>(&mainRun<GaussianKernel>),
+          "mainRun");
+  }
+};  // namespace alpaka_serial_sync

{CLUEstering-2.2.0 → CLUEstering-2.2.2}/CLUEstering.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CLUEstering
-Version: 2.2.0
+Version: 2.2.2
 Summary: A library that generalizes the original 2-dimensional CLUE
 Author: Simone Balducci
 Author-email: simone.balducci00@gmail.com

{CLUEstering-2.2.0 → CLUEstering-2.2.2}/CLUEstering.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ CLUEstering/alpaka/CLUE/CLUEAlgoAlpaka.h
 CLUEstering/alpaka/CLUE/CLUEAlpakaKernels.h
 CLUEstering/alpaka/CLUE/ConvolutionalKernel.h
 CLUEstering/alpaka/CLUE/Run.h
+CLUEstering/alpaka/CLUE/binding.cc
 CLUEstering/alpaka/DataFormats/Points.h
 CLUEstering/alpaka/DataFormats/alpaka/AlpakaVecArray.h
 CLUEstering/alpaka/DataFormats/alpaka/PointsAlpaka.h
@@ -1404,6 +1405,7 @@ extern/pybind11/tests/test_virtual_functions.cpp
 extern/pybind11/tests/test_virtual_functions.py
 extern/pybind11/tests/valgrind-numpy-scipy.supp
 extern/pybind11/tests/valgrind-python.supp
+extern/pybind11/tests/__pycache__/conftest.cpython-312-pytest-8.1.1.pyc
 extern/pybind11/tests/extra_python_package/pytest.ini
 extern/pybind11/tests/extra_python_package/test_files.py
 extern/pybind11/tests/extra_setuptools/pytest.ini

CLUEstering-2.2.2/CMakeLists.txt

@@ -0,0 +1,215 @@
+cmake_minimum_required(VERSION 3.16.0)
+project(CLUEstering LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+if(${CMAKE_BUILD_TYPE} STREQUAL "Debug")
+  set(CMAKE_CXX_FLAGS "-Wall -Wextra -g -O0")
+elseif(${CMAKE_BUILD_TYPE} STREQUAL "Release")
+  set(CMAKE_CXX_FLAGS "-O2")
+endif()
+
+# include alpaka extern subfolder
+include_directories(extern/alpaka/include)
+# include pybind11 extern subfolder
+set(PYBIND11_FINDPYTHON ON)
+set(PYBIND11_PYTHON_VERSION ">=3.8")
+add_subdirectory(extern/pybind11)
+
+find_package(Boost 1.75.0)
+
+# if boost is not found, it's fetched from the official boost repository
+if(NOT Boost_FOUND)
+  include(FetchContent)
+  FetchContent_Declare(
+    boost
+    URL https://boostorg.jfrog.io/artifactory/main/release/1.76.0/source/boost_1_76_0.tar.gz
+  )
+
+  FetchContent_GetProperties(boost)
+  if(NOT boost_POPULATED)
+    FetchContent_Populate(boost)
+  endif()
+  set(Boost_PATH ./build/_deps/boost-src)
+else()
+  set(Boost_PATH ${Boost_INCLUDE_DIRS})
+endif()
+
+if(NOT DEFINED CPU_ONLY)
+  set(CPU_ONLY OFF)
+endif()
+if(NOT DEFINED SERIAL_ONLY)
+  set(SERIAL_ONLY OFF)
+endif()
+
+# create lib directory in CLUEstering folder
+execute_process(COMMAND mkdir -p ./CLUEstering/lib)
+
+# Convolutional Kernels compile convolutional kernel module
+pybind11_add_module(CLUE_Convolutional_Kernels SHARED
+                    ./CLUEstering/alpaka/BindingModules/binding_kernels.cc)
+# link boost
+target_link_libraries(CLUE_Convolutional_Kernels PRIVATE ${Boost_LIBRARIES})
+target_include_directories(CLUE_Convolutional_Kernels PRIVATE ${Boost_PATH})
+# alpaka build flags
+target_compile_options(
+  CLUE_Convolutional_Kernels
+  PRIVATE -DALPAKA_HOST_ONLY -DALPAKA_ACC_CPU_B_SEQ_T_SEQ_PRESENT
+          -DALPAKA_ACC_CPU_B_SEQ_T_SEQ_ENABLED
+          -DALPAKA_ACC_CPU_B_SEQ_T_SEQ_SYNC_BACKEND)
+# set output directory
+set_target_properties(
+  CLUE_Convolutional_Kernels PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+                                        ./lib/CLUEstering/lib/)
+# create link of shared object to lib folder inside CLUEstering directory
+file(GLOB CONV_MODULE
+     ./build/lib/CLUEstering/lib/CLUE_Convolutional_Kernels*.so)
+foreach(CONV_MODULE ${CONV_MODULE})
+  execute_process(COMMAND ln -sf ${CONV_MODULE}
+                          ./CLUEstering/lib/CLUE_Convolutional_Kernels.so)
+endforeach()
+
+# CPU Serial compile cpu serial module
+pybind11_add_module(CLUE_CPU_Serial SHARED
+                    ./CLUEstering/alpaka/BindingModules/binding_cpu.cc)
+# link boost
+target_link_libraries(CLUE_CPU_Serial PRIVATE ${Boost_LIBRARIES})
+target_include_directories(CLUE_CPU_Serial PRIVATE ${Boost_PATH})
+# alpaka build flags
+target_compile_options(
+  CLUE_CPU_Serial
+  PRIVATE -DALPAKA_HOST_ONLY -DALPAKA_ACC_CPU_B_SEQ_T_SEQ_PRESENT
+          -DALPAKA_ACC_CPU_B_SEQ_T_SEQ_ENABLED
+          -DALPAKA_ACC_CPU_B_SEQ_T_SEQ_SYNC_BACKEND)
+# set output directory
+set_target_properties(CLUE_CPU_Serial PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+                                                 ./lib/CLUEstering/lib/)
+# create link of shared object to lib folder inside CLUEstering directory
+file(GLOB CONV_MODULE ./build/lib/CLUEstering/lib/CLUE_CPU_Serial*.so)
+foreach(CONV_MODULE ${CONV_MODULE})
+  execute_process(COMMAND ln -sf ${CONV_MODULE}
+                          ./CLUEstering/lib/CLUE_CPU_Serial.so)
+endforeach()
+
+if(NOT ${SERIAL_ONLY})
+  find_package(TBB)
+
+  # CPU TBB
+  if(TBB_FOUND)
+    # compile cpu tbb module
+    pybind11_add_module(CLUE_CPU_TBB SHARED
+                        ./CLUEstering/alpaka/BindingModules/binding_cpu_tbb.cc)
+    target_link_libraries(CLUE_CPU_TBB PRIVATE ${Boost_LIBRARIES})
+    target_include_directories(CLUE_CPU_TBB PRIVATE ${Boost_PATH})
+    target_compile_options(
+      CLUE_CPU_TBB
+      PRIVATE -ltbb -DALPAKA_ACC_CPU_B_TBB_T_SEQ_PRESENT
+              -DALPAKA_ACC_CPU_B_TBB_T_SEQ_ENABLED
+              -DALPAKA_ACC_CPU_B_TBB_T_SEQ_ASYNC_BACKEND)
+    target_link_libraries(CLUE_CPU_TBB PRIVATE TBB::tbb)
+    set_target_properties(CLUE_CPU_TBB PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+                                                  ./lib/CLUEstering/lib/)
+    # create link of shared object to lib folder inside CLUEstering directory
+    file(GLOB CONV_MODULE ./build/lib/CLUEstering/lib/CLUE_CPU_TBB*.so)
+    foreach(CONV_MODULE ${CONV_MODULE})
+      execute_process(COMMAND ln -sf ${CONV_MODULE}
+                              ./CLUEstering/lib/CLUE_CPU_TBB.so)
+    endforeach()
+  endif()
+endif()
+
+if((NOT ${CPU_ONLY}) AND (NOT ${SERIAL_ONLY}))
+  # check if CUDA is available
+  include(CheckLanguage)
+  check_language(CUDA)
+
+  # GPU CUDA
+  if(CMAKE_CUDA_COMPILER)
+    # enable CUDA
+    enable_language(CUDA)
+    set(CMAKE_CUDA_HOST_COMPILER ${CMAKE_CUDA_COMPILER})
+
+    # set the CUDA standard
+    if(NOT DEFINED CMAKE_CUDA_STANDARD)
+      set(CMAKE_CUDA_STANDARD 17)
+      set(CMAKE_CUDA_STANDARD_REQUIRED ON)
+    endif()
+
+    # compile the file with .cc extension using nvcc
+    set_source_files_properties(
+      ./CLUEstering/alpaka/BindingModules/binding_gpu_cuda.cc
+      PROPERTIES LANGUAGE CUDA)
+    # compile gpu cuda module
+    pybind11_add_module(CLUE_GPU_CUDA SHARED
+                        ./CLUEstering/alpaka/BindingModules/binding_gpu_cuda.cc)
+    # link boost
+    target_link_libraries(CLUE_Convolutional_Kernels PRIVATE ${Boost_LIBRARIES})
+    target_include_directories(CLUE_Convolutional_Kernels PRIVATE ${Boost_PATH})
+    # set the cuda architectures
+    set_target_properties(CLUE_GPU_CUDA PROPERTIES CUDA_ARCHITECTURES
+                                                   "50;60;61;62;70")
+    # alpaka build flags
+    target_compile_options(
+      CLUE_GPU_CUDA
+      PRIVATE -DALPAKA_ACC_GPU_CUDA_PRESENT -DALPAKA_ACC_GPU_CUDA_ENABLED
+              -DALPAKA_ACC_GPU_CUDA_ASYNC_BACKEND)
+    # nvcc compilation flags
+    target_compile_options(
+      CLUE_GPU_CUDA PRIVATE --expt-relaxed-constexpr -gencode
+                            arch=compute_61,code=[sm_61,compute_61])
+    # set output directory
+    set_target_properties(CLUE_GPU_CUDA PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+                                                   ./lib/CLUEstering/lib/)
+    # create link of shared object to lib folder inside CLUEstering directory
+    file(GLOB CONV_MODULE ./build/lib/CLUEstering/lib/CLUE_GPU_CUDA*.so)
+    foreach(CONV_MODULE ${CONV_MODULE})
+      execute_process(COMMAND ln -sf ${CONV_MODULE}
+                              ./CLUEstering/lib/CLUE_GPU_CUDA.so)
+    endforeach()
+  endif()
+
+  # GPU HIP check if HIP is available
+  check_language(HIP)
+  if(CMAKE_HIP_COMPILER)
+    # enable HIP
+    enable_language(HIP)
+    set(CMAKE_HIP_HOST_COMPILER ${CMAKE_HIP_COMPILER})
+
+    # look for the hip package folder
+    find_package(hip)
+
+    set(hip_BASE "${hip_INCLUDE_DIRS}/..")
+    # set the hipcc compiler
+    set(CMAKE_CXX_COMPILER "${hip_BASE}/bin/hipcc")
+    # compile gpu hip module
+    pybind11_add_module(CLUE_GPU_HIP SHARED
+                        ./CLUEstering/alpaka/BindingModules/binding_gpu_hip.cc)
+    # link boost
+    target_link_libraries(CLUE_Convolutional_Kernels PRIVATE ${Boost_LIBRARIES})
+    target_include_directories(CLUE_Convolutional_Kernels PRIVATE ${Boost_PATH})
+    # alpaka build flags
+    target_compile_options(
+      CLUE_GPU_HIP
+      PRIVATE -DALPAKA_ACC_GPU_HIP_PRESENT -DALPAKA_ACC_GPU_HIP_ENABLED
+              -DALPAKA_ACC_GPU_HIP_ASYNC_BACKEND)
+    # link hip-rand libraries
+    target_include_directories(CLUE_GPU_HIP PRIVATE ${hip_INCLUDE_DIRS})
+    target_include_directories(CLUE_GPU_HIP PRIVATE ${hip_BASE}/hiprand/include)
+    target_include_directories(CLUE_GPU_HIP PRIVATE ${hip_BASE}/rocrand/include)
+    # set output directory
+    set_target_properties(CLUE_GPU_HIP PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+                                                  ./lib/CLUEstering/lib/)
+    # create link of shared object to lib folder inside CLUEstering directory
+    file(GLOB CONV_MODULE ./build/lib/CLUEstering/lib/CLUE_GPU_HIP*.so)
+    foreach(CONV_MODULE ${CONV_MODULE})
+      execute_process(COMMAND ln -sf ${CONV_MODULE}
+                              ./CLUEstering/lib/CLUE_GPU_HIP.so)
+    endforeach()
+  endif()
+endif()

{CLUEstering-2.2.0 → CLUEstering-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CLUEstering
-Version: 2.2.0
+Version: 2.2.2
 Summary: A library that generalizes the original 2-dimensional CLUE
 Author: Simone Balducci
 Author-email: simone.balducci00@gmail.com

{CLUEstering-2.2.0 → CLUEstering-2.2.2}/setup.py

@@ -4,7 +4,8 @@ import sys
 from pathlib import Path
 from setuptools import setup
 
-__version__ = "2.2.0"
+__version__ = "2.2.2"
+
 this_directory = Path(__file__).parent
 long_description = (this_directory/'README.md').read_text()