ArborX neighbor search

CMakeLists.txt

@@ -80,6 +80,18 @@ else() # Raw CMake Project
   SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
   SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
   SET(CMAKE_INSTALL_RPATH ${CMAKE_INSTALL_LIBDIR} ${CMAKE_INSTALL_RPATH})
+  if (NOT(CMAKE_BUILD_TYPE))
+    set(CMAKE_BUILD_TYPE "")
+  endif()
+  if (CMAKE_BUILD_TYPE STREQUAL "")
+    if (NOT(CMAKE_CXX_FLAGS) OR (CMAKE_CXX_FLAGS STREQUAL ""))
+      set(CMAKE_CXX_FLAGS " -O3 -g")
+    endif()
+    message(STATUS "CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
+  else()
+      string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_UPPER)
+      message(STATUS "CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${CMAKE_CXX_FLAGS}")
+  endif()
 
   # RPATH should always include the folder it is called from
   bob_option(PYTHON_CALLING_BUILD "Python setuptools calling build" OFF)
@@ -352,7 +364,6 @@ else() # Raw CMake Project
   endif()
 
 
-
   #MPI (Not really needed, only used so that if a kokkos-tool was built with MPI, it won't segfault)
   if (Compadre_USE_MPI)
     FIND_PACKAGE(MPI QUIET)
@@ -378,6 +389,7 @@ else() # Raw CMake Project
 
   bob_option(Compadre_TESTS "Compile Compadre tests" ON)
   bob_option(Compadre_EXAMPLES "Compile Compadre examples" "${Compadre_TESTS}")
+  bob_option(Compadre_USE_ARBORX "Use ArborX for neighbor search" OFF)
 
 
 endif() 
@@ -400,6 +412,7 @@ set(Compadre_KEY_BOOLS
     Compadre_USE_CUDA
     Compadre_USE_MPI
     Compadre_USE_PYTHON
+    Compadre_USE_ARBORX
    )
 
 set(Compadre_KEY_INTS

examples/GMLS_Device.cpp

@@ -200,15 +200,12 @@ bool all_passed = true;
     double epsilon_multiplier = 1.4;
 
     // neighbor_lists_device will contain all neighbor lists (for each target site) in a compressed row format
-    // Initially, we do a dry-run to calculate neighborhood sizes before actually storing the result. This is 
-    // why we can start with a neighbor_lists_device size of 0.
-    Kokkos::View<int*> neighbor_lists_device("neighbor lists", 
-            0); // first column is # of neighbors
+    Kokkos::View<int*> neighbor_lists_device("neighbor lists", 0); 
     Kokkos::View<int*>::HostMirror neighbor_lists = Kokkos::create_mirror_view(neighbor_lists_device);
+
     // number_of_neighbors_list must be the same size as the number of target sites so that it can be populated
     // with the number of neighbors for each target site.
-    Kokkos::View<int*> number_of_neighbors_list_device("number of neighbor lists", 
-            number_target_coords); // first column is # of neighbors
+    Kokkos::View<int*> number_of_neighbors_list_device("number of neighbor lists", number_target_coords);
     Kokkos::View<int*>::HostMirror number_of_neighbors_list = Kokkos::create_mirror_view(number_of_neighbors_list_device);
 
     // each target site has a window size
@@ -218,17 +215,7 @@ bool all_passed = true;
     // query the point cloud to generate the neighbor lists using a kdtree to produce the n nearest neighbor
     // to each target site, adding (epsilon_multiplier-1)*100% to whatever the distance away the further neighbor used is from
     // each target to the view for epsilon
-    //
-    // This dry run populates number_of_neighbors_list with neighborhood sizes
-    size_t storage_size = point_cloud_search.generateCRNeighborListsFromKNNSearch(true /*dry run*/, target_coords, neighbor_lists, 
-            number_of_neighbors_list, epsilon, min_neighbors, epsilon_multiplier);
-
-    // resize neighbor_lists_device so as to be large enough to contain all neighborhoods
-    Kokkos::resize(neighbor_lists_device, storage_size);
-    neighbor_lists = Kokkos::create_mirror_view(neighbor_lists_device);
-
-    // query the point cloud a second time, but this time storing results into neighbor_lists
-    point_cloud_search.generateCRNeighborListsFromKNNSearch(false /*not dry run*/, target_coords, neighbor_lists, 
+    point_cloud_search.generateCRNeighborListsFromKNNSearch(target_coords, neighbor_lists, 
             number_of_neighbors_list, epsilon, min_neighbors, epsilon_multiplier);
 
     //! [Performing Neighbor Search]
@@ -244,6 +231,7 @@ bool all_passed = true;
     // We could have filled Kokkos Views with memory space on the host
     // and used these instead, and then the copying of data to the device
     // would be performed in the GMLS class
+    Kokkos::resize(neighbor_lists_device, neighbor_lists.extent(0));
     Kokkos::deep_copy(neighbor_lists_device, neighbor_lists);
     Kokkos::deep_copy(number_of_neighbors_list_device, number_of_neighbors_list);
     Kokkos::deep_copy(epsilon_device, epsilon);

examples/GMLS_DivergenceFree.cpp

@@ -177,11 +177,8 @@ bool all_passed = true;
     // the number of neighbors for that rows corresponding target site
     // for the default values in this test, the multiplier is suggested to be 2.2
     double epsilon_multiplier = 2.2;
-    int estimated_upper_bound_number_neighbors =
-        point_cloud_search.getEstimatedNumberNeighborsUpperBound(min_neighbors, dimension, epsilon_multiplier);
 
-    Kokkos::View<int**, Kokkos::DefaultExecutionSpace> neighbor_lists_device("neighbor lists",
-            number_target_coords, estimated_upper_bound_number_neighbors); // first column is # of neighbors
+    Kokkos::View<int**, Kokkos::DefaultExecutionSpace> neighbor_lists_device("neighbor lists", 0, 0);
     Kokkos::View<int**>::HostMirror neighbor_lists = Kokkos::create_mirror_view(neighbor_lists_device);
 
     // each target site has a window size
@@ -191,7 +188,7 @@ bool all_passed = true;
     // query the point cloud to generate the neighbor lists using a kdtree to produce the n nearest neighbor
     // to each target site, adding (epsilon_multiplier-1)*100% to whatever the distance away the further neighbor used is from
     // each target to the view for epsilon
-    point_cloud_search.generate2DNeighborListsFromKNNSearch(false /*not dry run*/, target_coords, neighbor_lists, 
+    point_cloud_search.generate2DNeighborListsFromKNNSearch(target_coords, neighbor_lists, 
             epsilon, min_neighbors, epsilon_multiplier);
 
     //! [Performing Neighbor Search]
@@ -207,6 +204,7 @@ bool all_passed = true;
     // We could have filled Kokkos Views with memory space on the host
     // and used these instead, and then the copying of data to the device
     // would be performed in the GMLS class
+    Kokkos::resize(neighbor_lists_device, neighbor_lists.extent(0), neighbor_lists.extent(1));
     Kokkos::deep_copy(neighbor_lists_device, neighbor_lists);
     Kokkos::deep_copy(epsilon_device, epsilon);
 

examples/GMLS_Manifold.cpp

@@ -225,15 +225,8 @@ Kokkos::initialize(argc, args);
     Kokkos::View<double*, Kokkos::DefaultExecutionSpace> epsilon_device("h supports", number_target_coords);
     Kokkos::View<double*>::HostMirror epsilon = Kokkos::create_mirror_view(epsilon_device);
 
-    size_t storage_size = point_cloud_search.generateCRNeighborListsFromKNNSearch(true /*dry run*/, target_coords, neighbor_lists, 
-            number_of_neighbors_list, epsilon, min_neighbors, epsilon_multiplier);
-
-    // resize neighbor_lists_device so as to be large enough to contain all neighborhoods
-    Kokkos::resize(neighbor_lists_device, storage_size);
-    neighbor_lists = Kokkos::create_mirror_view(neighbor_lists_device);
-
-    // query the point cloud a second time, but this time storing results into neighbor_lists
-    point_cloud_search.generateCRNeighborListsFromKNNSearch(false /*not dry run*/, target_coords, neighbor_lists, 
+    // search
+    point_cloud_search.generateCRNeighborListsFromKNNSearch(target_coords, neighbor_lists, 
             number_of_neighbors_list, epsilon, min_neighbors, epsilon_multiplier);
 
     // Diagnostic for neighbors found
@@ -259,6 +252,7 @@ Kokkos::initialize(argc, args);
     // We could have filled Kokkos Views with memory space on the host
     // and used these instead, and then the copying of data to the device
     // would be performed in the GMLS class
+    Kokkos::resize(neighbor_lists_device, neighbor_lists.extent(0));
     Kokkos::deep_copy(neighbor_lists_device, neighbor_lists);
     Kokkos::deep_copy(number_of_neighbors_list_device, number_of_neighbors_list);
     Kokkos::deep_copy(epsilon_device, epsilon);

examples/GMLS_Manifold_Multiple_Evaluation_Sites.cpp

@@ -240,11 +240,8 @@ Kokkos::initialize(argc, args);
     // each row is a neighbor list for a target site, with the first column of each row containing
     // the number of neighbors for that rows corresponding target site
     double epsilon_multiplier = 1.7;
-    int estimated_upper_bound_number_neighbors = 
-        point_cloud_search.getEstimatedNumberNeighborsUpperBound(min_neighbors, dimension, epsilon_multiplier);
 
-    Kokkos::View<int**, Kokkos::DefaultExecutionSpace> neighbor_lists_device("neighbor lists", 
-            number_target_coords, estimated_upper_bound_number_neighbors); // first column is # of neighbors
+    Kokkos::View<int**, Kokkos::DefaultExecutionSpace> neighbor_lists_device("neighbor lists", 0, 0);
     Kokkos::View<int**>::HostMirror neighbor_lists = Kokkos::create_mirror_view(neighbor_lists_device);
 
     // each target site has a window size
@@ -254,7 +251,7 @@ Kokkos::initialize(argc, args);
     // query the point cloud to generate the neighbor lists using a kdtree to produce the n nearest neighbor
     // to each target site, adding (epsilon_multiplier-1)*100% to whatever the distance away the further neighbor used is from
     // each target to the view for epsilon
-    point_cloud_search.generate2DNeighborListsFromKNNSearch(false /*not dry run*/, target_coords, neighbor_lists, 
+    point_cloud_search.generate2DNeighborListsFromKNNSearch(target_coords, neighbor_lists, 
             epsilon, min_neighbors, epsilon_multiplier);
 
     //! [Performing Neighbor Search]
@@ -270,6 +267,7 @@ Kokkos::initialize(argc, args);
     // We could have filled Kokkos Views with memory space on the host
     // and used these instead, and then the copying of data to the device
     // would be performed in the GMLS class
+    Kokkos::resize(neighbor_lists_device, neighbor_lists.extent(0), neighbor_lists.extent(1));
     Kokkos::deep_copy(neighbor_lists_device, neighbor_lists);
     Kokkos::deep_copy(epsilon_device, epsilon);
 

examples/GMLS_Multiple_Evaluation_Sites.cpp

@@ -228,11 +228,8 @@ bool all_passed = true;
     // each row is a neighbor list for a target site, with the first column of each row containing
     // the number of neighbors for that rows corresponding target site
     double epsilon_multiplier = 1.5;
-    int estimated_upper_bound_number_neighbors = 
-        point_cloud_search.getEstimatedNumberNeighborsUpperBound(min_neighbors, dimension, epsilon_multiplier);
 
-    Kokkos::View<int**, Kokkos::DefaultExecutionSpace> neighbor_lists_device("neighbor lists", 
-            number_target_coords, estimated_upper_bound_number_neighbors); // first column is # of neighbors
+    Kokkos::View<int**, Kokkos::DefaultExecutionSpace> neighbor_lists_device("neighbor lists", 0, 0);
     Kokkos::View<int**>::HostMirror neighbor_lists = Kokkos::create_mirror_view(neighbor_lists_device);
 
     // each target site has a window size
@@ -242,7 +239,7 @@ bool all_passed = true;
     // query the point cloud to generate the neighbor lists using a kdtree to produce the n nearest neighbor
     // to each target site, adding (epsilon_multiplier-1)*100% to whatever the distance away the further neighbor used is from
     // each target to the view for epsilon
-    point_cloud_search.generate2DNeighborListsFromKNNSearch(false /*not dry run*/, target_coords, neighbor_lists, 
+    point_cloud_search.generate2DNeighborListsFromKNNSearch(target_coords, neighbor_lists, 
             epsilon, min_neighbors, epsilon_multiplier);
 
 
@@ -259,6 +256,7 @@ bool all_passed = true;
     // We could have filled Kokkos Views with memory space on the host
     // and used these instead, and then the copying of data to the device
     // would be performed in the GMLS class
+    Kokkos::resize(neighbor_lists_device, neighbor_lists.extent(0), neighbor_lists.extent(1));
     Kokkos::deep_copy(neighbor_lists_device, neighbor_lists);
     Kokkos::deep_copy(epsilon_device, epsilon);
 

examples/GMLS_NeumannGradScalar.cpp

@@ -200,11 +200,8 @@ bool all_passed = true;
     // each row is a neighbor list for a target site, with the first column of each row containing
     // the number of neighbors for that rows corresponding target site
     double epsilon_multiplier = 1.8;
-    int estimated_upper_bound_number_neighbors = 
-        point_cloud_search.getEstimatedNumberNeighborsUpperBound(min_neighbors, dimension, epsilon_multiplier);
 
-    Kokkos::View<int**, Kokkos::DefaultExecutionSpace> neighbor_lists_device("neighbor lists", 
-            number_target_coords, estimated_upper_bound_number_neighbors); // first column is # of neighbors
+    Kokkos::View<int**, Kokkos::DefaultExecutionSpace> neighbor_lists_device("neighbor lists", 0, 0);
     Kokkos::View<int**>::HostMirror neighbor_lists = Kokkos::create_mirror_view(neighbor_lists_device);
 
     // each target site has a window size
@@ -214,7 +211,7 @@ bool all_passed = true;
     // query the point cloud to generate the neighbor lists using a kdtree to produce the n nearest neighbor
     // to each target site, adding (epsilon_multiplier-1)*100% to whatever the distance away the further neighbor used is from
     // each target to the view for epsilon
-    point_cloud_search.generate2DNeighborListsFromKNNSearch(false /*not dry run*/, target_coords, neighbor_lists, 
+    point_cloud_search.generate2DNeighborListsFromKNNSearch(target_coords, neighbor_lists, 
             epsilon, min_neighbors, epsilon_multiplier);
 
     //! [Performing Neighbor Search]
@@ -230,6 +227,7 @@ bool all_passed = true;
     // We could have filled Kokkos Views with memory space on the host
     // and used these instead, and then the copying of data to the device
     // would be performed in the GMLS class
+    Kokkos::resize(neighbor_lists_device, neighbor_lists.extent(0), neighbor_lists.extent(1));
     Kokkos::deep_copy(neighbor_lists_device, neighbor_lists);
     Kokkos::deep_copy(epsilon_device, epsilon);
 

examples/GMLS_SmallBatchReuse_Device.cpp

@@ -256,11 +256,8 @@ bool all_passed = true;
         // each row is a neighbor list for a target site, with the first column of each row containing
         // the number of neighbors for that rows corresponding target site
         double epsilon_multiplier = 1.5;
-        int estimated_upper_bound_number_neighbors = 
-            point_cloud_search.getEstimatedNumberNeighborsUpperBound(min_neighbors, dimension, epsilon_multiplier);
 
-        Kokkos::View<int**, Kokkos::DefaultExecutionSpace> single_neighbor_lists_device("neighbor lists", 
-                1, estimated_upper_bound_number_neighbors); // first column is # of neighbors
+        Kokkos::View<int**, Kokkos::DefaultExecutionSpace> single_neighbor_lists_device("neighbor lists", 0, 0);
         Kokkos::View<int**>::HostMirror single_neighbor_lists = Kokkos::create_mirror_view(single_neighbor_lists_device);
 
         // each target site has a window size
@@ -270,16 +267,18 @@ bool all_passed = true;
         // query the point cloud to generate the neighbor lists using a kdtree to produce the n nearest neighbor
         // to each target site, adding (epsilon_multiplier-1)*100% to whatever the distance away the further neighbor used is from
         // each target to the view for epsilon
-        point_cloud_search.generate2DNeighborListsFromKNNSearch(false /*not dry run*/, single_target_coords, 
+        point_cloud_search.generate2DNeighborListsFromKNNSearch(single_target_coords, 
                 single_neighbor_lists, single_epsilon, min_neighbors, epsilon_multiplier);
 
+
         //! [Performing Neighbor Search]
 
 
         // Copy data back to device (they were filled on the host)
         // We could have filled Kokkos Views with memory space on the host
         // and used these instead, and then the copying of data to the device
         // would be performed in the GMLS class
+        Kokkos::resize(single_neighbor_lists_device, single_neighbor_lists.extent(0), single_neighbor_lists.extent(1));
         Kokkos::deep_copy(single_neighbor_lists_device, single_neighbor_lists);
         Kokkos::deep_copy(single_epsilon_device, single_epsilon);
         Kokkos::fence(); // let call to build neighbor lists complete before copying back to device

examples/GMLS_Staggered.cpp

@@ -194,11 +194,8 @@ bool all_passed = true;
     // the number of neighbors for that rows corresponding target site
     // for the default values in this test, the multiplier is suggested to be 2.2
     double epsilon_multiplier = 2.2;
-    int estimated_upper_bound_number_neighbors =
-        point_cloud_search.getEstimatedNumberNeighborsUpperBound(min_neighbors, dimension, epsilon_multiplier);
 
-    Kokkos::View<int**, Kokkos::DefaultExecutionSpace> neighbor_lists_device("neighbor lists",
-            number_target_coords, estimated_upper_bound_number_neighbors); // first column is # of neighbors
+    Kokkos::View<int**, Kokkos::DefaultExecutionSpace> neighbor_lists_device("neighbor lists", 0, 0);
     Kokkos::View<int**>::HostMirror neighbor_lists = Kokkos::create_mirror_view(neighbor_lists_device);
 
     // each target site has a window size
@@ -208,7 +205,7 @@ bool all_passed = true;
     // query the point cloud to generate the neighbor lists using a kdtree to produce the n nearest neighbor
     // to each target site, adding (epsilon_multiplier-1)*100% to whatever the distance away the further neighbor used is from
     // each target to the view for epsilon
-    point_cloud_search.generate2DNeighborListsFromKNNSearch(false /*not dry run*/, target_coords, neighbor_lists, 
+    point_cloud_search.generate2DNeighborListsFromKNNSearch(target_coords, neighbor_lists, 
             epsilon, min_neighbors, epsilon_multiplier);
 
     //! [Performing Neighbor Search]
@@ -224,6 +221,7 @@ bool all_passed = true;
     // We could have filled Kokkos Views with memory space on the host
     // and used these instead, and then the copying of data to the device
     // would be performed in the GMLS class
+    Kokkos::resize(neighbor_lists_device, neighbor_lists.extent(0), neighbor_lists.extent(1));
     Kokkos::deep_copy(neighbor_lists_device, neighbor_lists);
     Kokkos::deep_copy(epsilon_device, epsilon);
 

examples/GMLS_Staggered_Manifold.cpp

@@ -184,11 +184,8 @@ Kokkos::initialize(argc, args);
     // each row is a neighbor list for a target site, with the first column of each row containing
     // the number of neighbors for that rows corresponding target site
     double epsilon_multiplier = 1.5;
-    int estimated_upper_bound_number_neighbors = 
-        point_cloud_search.getEstimatedNumberNeighborsUpperBound(min_neighbors, dimension, epsilon_multiplier);
 
-    Kokkos::View<int**, Kokkos::DefaultExecutionSpace> neighbor_lists_device("neighbor lists", 
-            number_target_coords, estimated_upper_bound_number_neighbors); // first column is # of neighbors
+    Kokkos::View<int**, Kokkos::DefaultExecutionSpace> neighbor_lists_device("neighbor lists", 0, 0);
     Kokkos::View<int**>::HostMirror neighbor_lists = Kokkos::create_mirror_view(neighbor_lists_device);
 
     // each target site has a window size
@@ -198,7 +195,7 @@ Kokkos::initialize(argc, args);
     // query the point cloud to generate the neighbor lists using a kdtree to produce the n nearest neighbor
     // to each target site, adding (epsilon_multiplier-1)*100% to whatever the distance away the further neighbor used is from
     // each target to the view for epsilon
-    point_cloud_search.generate2DNeighborListsFromKNNSearch(false /*not dry run*/, target_coords, neighbor_lists, 
+    point_cloud_search.generate2DNeighborListsFromKNNSearch(target_coords, neighbor_lists, 
             epsilon, min_neighbors, epsilon_multiplier);
 
 
@@ -215,6 +212,7 @@ Kokkos::initialize(argc, args);
     // We could have filled Kokkos Views with memory space on the host
     // and used these instead, and then the copying of data to the device
     // would be performed in the GMLS class
+    Kokkos::resize(neighbor_lists_device, neighbor_lists.extent(0), neighbor_lists.extent(1));
     Kokkos::deep_copy(neighbor_lists_device, neighbor_lists);
     Kokkos::deep_copy(epsilon_device, epsilon);