enum class BroadPhaseMethod

Author: Huangzizhou

src/ipc/broad_phase/broad_phase.cpp

@@ -11,6 +11,29 @@
 
 namespace ipc {
 
+std::shared_ptr<ipc::BroadPhase> build_broad_phase(const BroadPhaseMethod& broad_phase_method)
+{
+    switch(broad_phase_method)
+    {
+    case BroadPhaseMethod::HASH_GRID:
+        return std::make_shared<ipc::HashGrid>();
+    case BroadPhaseMethod::BRUTE_FORCE:
+        return std::make_shared<ipc::BruteForce>();
+    case BroadPhaseMethod::SPATIAL_HASH:
+        return std::make_shared<ipc::SpatialHash>();
+    case BroadPhaseMethod::BVH:
+        return std::make_shared<ipc::BVH>();
+#ifdef IPC_TOOLKIT_WITH_CUDA
+    case BroadPhaseMethod::SWEEP_AND_TINIEST_QUEUE:
+        return std::make_shared<ipc::SweepAndTiniestQueue>();
+#endif
+    default:
+        log_and_throw_error("Unknown broad phase type!");
+    }
+
+    return std::make_shared<ipc::HashGrid>();
+}
+
 void BroadPhase::build(
     Eigen::ConstRef<Eigen::MatrixXd> vertices,
     Eigen::ConstRef<Eigen::MatrixXi> edges,

src/ipc/broad_phase/broad_phase.hpp

@@ -15,6 +15,8 @@ namespace ipc {
 
 class Candidates; // Forward declaration
 
+enum class BroadPhaseMethod { HASH_GRID, BRUTE_FORCE, SPATIAL_HASH, BVH, SWEEP_AND_TINIEST_QUEUE };
+
 class BroadPhase {
 public:
     BroadPhase() { }
@@ -104,4 +106,5 @@ class BroadPhase {
     std::vector<AABB> face_boxes;
 };
 
+std::shared_ptr<BroadPhase> build_broad_phase(const BroadPhaseMethod& broad_phase_method);
 } // namespace ipc

src/ipc/potentials/potential.tpp

@@ -8,7 +8,6 @@
 #include <tbb/combinable.h>
 #include <tbb/enumerable_thread_specific.h>
 #include <ipc/utils/MaybeParallelFor.hpp>
-#include <igl/Timer.h>
 
 namespace ipc {
 
@@ -101,9 +100,6 @@ Eigen::SparseMatrix<double> Potential<TCollisions>::hessian(
     const int dim = X.cols();
     const int ndof = X.size();
 
-    igl::Timer timer;
-    timer.start();
-
     const int max_triplets_size = int(1e7);
     const int buffer_size = std::min(max_triplets_size, ndof);
     auto storage = ipc::utils::create_thread_storage(LocalThreadMatStorage(buffer_size, ndof, ndof));
@@ -127,9 +123,6 @@ Eigen::SparseMatrix<double> Potential<TCollisions>::hessian(
                     local_hess, vids, dim, *(hess_triplets.cache));
             }
         });
-    
-    timer.stop();
-    logger().trace("done separate assembly {}s...", timer.getElapsedTime());
 
     Eigen::SparseMatrix<double> hess(ndof, ndof);
 
@@ -143,12 +136,9 @@ Eigen::SparseMatrix<double> Potential<TCollisions>::hessian(
         storages[index++] = &local_storage;
     }
 
-    timer.start();
     utils::maybe_parallel_for(storages.size(), [&](int i) {
         storages[i]->cache->prune();
     });
-    timer.stop();
-    logger().trace("done pruning triplets {}s...", timer.getElapsedTime());
 
     if (storage.size() == 0)
     {
@@ -171,42 +161,28 @@ Eigen::SparseMatrix<double> Potential<TCollisions>::hessian(
     assert(storages.size() >= 1);
     if (storages[0]->cache->is_dense())
     {
-        timer.start();
         // Serially merge local storages
         Eigen::MatrixXd tmp(hess);
         for (const auto &local_storage : storage)
             tmp += dynamic_cast<const DenseMatrixCache &>(*local_storage.cache).mat();
         hess = tmp.sparseView();
         hess.makeCompressed();
-        timer.stop();
-
-        logger().trace("Serial assembly time: {}s...", timer.getElapsedTime());
     }
     else if (triplet_count >= triplets.max_size())
     {
         // Serial fallback version in case the vector of triplets cannot be allocated
 
         logger().warn("Cannot allocate space for triplets, switching to serial assembly.");
 
-        timer.start();
         // Serially merge local storages
         for (LocalThreadMatStorage &local_storage : storage)
             hess += local_storage.cache->get_matrix(false); // will also prune
         hess.makeCompressed();
-        timer.stop();
-
-        logger().trace("Serial assembly time: {}s...", timer.getElapsedTime());
     }
     else
     {
-        timer.start();
         triplets.resize(triplet_count);
-        timer.stop();
 
-        logger().trace("done allocate triplets {}s...", timer.getElapsedTime());
-        logger().trace("Triplets Count: {}", triplet_count);
-
-        timer.start();
         // Parallel copy into triplets
         utils::maybe_parallel_for(storages.size(), [&](int i) {
             const SparseMatrixCache &cache = dynamic_cast<const SparseMatrixCache &>(*storages[i]->cache);
@@ -229,15 +205,8 @@ Eigen::SparseMatrix<double> Potential<TCollisions>::hessian(
             }
         });
 
-        timer.stop();
-        logger().trace("done concatenate triplets {}s...", timer.getElapsedTime());
-
-        timer.start();
         // Sort and assemble
         hess.setFromTriplets(triplets.begin(), triplets.end());
-        timer.stop();
-
-        logger().trace("done setFromTriplets assembly {}s...", timer.getElapsedTime());
     }
 
     return hess;

src/ipc/utils/math.tpp

@@ -36,7 +36,7 @@ namespace {
         return scalar(1.);
     }
 
-    double smooth_heaviside_standard_grad(const double& x)
+    [[maybe_unused]] double smooth_heaviside_standard_grad(const double& x)
     {
         if (x <= -3 || x >= 0)
             return 0.;
@@ -48,7 +48,7 @@ namespace {
         return Math<double>::sqr(x) / 2.;
     }
 
-    double smooth_heaviside_standard_hess(const double& x)
+    [[maybe_unused]] double smooth_heaviside_standard_hess(const double& x)
     {
         if (x <= -3 || x >= 0)
             return 0.;