Update docs

zfergus · zfergus · commit 8d59acaa125d · 2023-11-01T23:50:12.000-04:00
diff --git a/cmake/recipes/simple_bvh.cmake b/cmake/recipes/simple_bvh.cmake
@@ -1,4 +1,4 @@
-# BVH
+# BVH (https://github.com/geometryprocessing/SimpleBVH)
 # License: MIT
 
 if(TARGET simple_bvh::simple_bvh)
@@ -8,4 +8,4 @@ endif()
 message(STATUS "Third-party: creating target 'simple_bvh::simple_bvh'")
 
 include(CPM)
-CPMAddPackage("gh:ipc-sim/SimpleBVH#2117898eb366647d6aacdb82860b9315fb42d6ad")
+CPMAddPackage("gh:geometryprocessing/SimpleBVH#e1a931337a9e07e8bd2d2e8bbdfd7e54bc850df5")
diff --git a/docs/source/tutorial/getting_started.rst b/docs/source/tutorial/getting_started.rst
@@ -372,12 +372,12 @@ where we define the operator :math:`\setminus_r: \mathcal{P}(\mathbb{R}^2) \time
 
 with :math:`r \rightarrow 0`.
 
-We then define our surface discretization with a triangulated boundary mesh geometry. As in the smooth case, we can parameterize the domain across all polylines with :math:`u \in \tilde{M}` so that :math:`p(u): \tilde{M} \mapsto \mathbb{R}^3` traverses all material points, across all triangles :math:`t ∈ T` in the triangle mesh contiguously. The corresponding surface contact potential is then
+We then define our surface discretization with a triangulated boundary mesh geometry. As in the smooth case, we can parameterize the domain across all triangles with :math:`u \in \tilde{M}` so that :math:`p(u): \tilde{M} \mapsto \mathbb{R}^3` traverses all material points, across all triangles :math:`t ∈ T` in the triangle mesh contiguously. The corresponding surface contact potential is then
 
 .. math::
     \frac{1}{2} \int_{u \in \tilde{M}} \max_{t \in T \backslash p(u)} b(d(p(u), t), \hat{d})~\mathrm{d} u,
 
-where :math:`T \setminus p` is the set of boundary faces that do not contain the point p.
+where :math:`T \setminus p` is the set of boundary faces that do not contain the point :math:`p`.
 
 Applying mesh vertices as nodes (and quadrature points), we numerically integrate the surface contact potential. For each nodal position :math:`x \in V` we then have a corresponding material space coordinate :math:`\bar{x} \in \bar{V}`. Piecewise linear integration of the surface barrier is then
 
@@ -399,7 +399,9 @@ where :math:`V_{\text{int}} \subseteq V` is the subset of internal surface nodes
 The corresponding discrete barrier potential is then simply
 
 .. math::
-    P_s(V)= \frac{1}{2} \sum_{x \in V} w_x \Psi_s(x).
+    P_s(V)= \frac{1}{2} \sum_{x \in V} w_x \Psi_s(x),
+
+where we simplify with :math:`w_x = w_{\bar{x}}` defined appropriately, per domain, as covered above.
 
 Please, see the `paper <https://arxiv.org/abs/2307.15908>`_ for more details (including the formulation for 2D curves and edge-edge contact) and evaluation.
 
@@ -642,12 +644,13 @@ The ``Candidates`` class represents the culled set of candidate pairs and is bui
                 mesh, vertices_t0, vertices_t1,
                 broad_phase_method=ipctk.BroadPhaseMethod.HASH_GRID)
 
-Possible values for ``broad_phase_method`` are: ``BRUTE_FORCE`` (parallel brute force culling), ``HASH_GRID`` (default), ``SPATIAL_HASH`` (implementation from the original IPC codebase), ``SWEEP_AND_TINIEST_QUEUE`` (method of :cite:t:`Belgrod2023Time`), or ``SWEEP_AND_TINIEST_QUEUE_GPU`` (requires CUDA).
+Possible values for ``broad_phase_method`` are: ``BRUTE_FORCE`` (parallel brute force culling), ``HASH_GRID`` (default), ``SPATIAL_HASH`` (implementation from the original IPC codebase),
+``BVH`` (`SimpleBVH <https://github.com/geometryprocessing/SimpleBVH>`_), ``SWEEP_AND_TINIEST_QUEUE`` (method of :cite:t:`Belgrod2023Time`), or ``SWEEP_AND_TINIEST_QUEUE_GPU`` (requires CUDA).
 
 Narrow-Phase
 ^^^^^^^^^^^^
 
-The narrow-phase computes the time of impact between two primitives (e.g., a point and a triangle or two edges in 3D). To do this we utilize the Tight Inclusion CCD method of :cite:t:`Wang2021TightInclusion` for the narrow phase as it is provably conservative (i.e., never misses collisions), accurate (i.e., rarely reports false positives), and efficient.
+The narrow phase computes the time of impact between two primitives (e.g., a point and a triangle or two edges in 3D). To do this we utilize the Tight Inclusion CCD method of :cite:t:`Wang2021TightInclusion` for the narrow phase as it is provably conservative (i.e., never misses collisions), accurate (i.e., rarely reports false positives), and efficient.
 
 The following example shows how to use the narrow phase to determine if a point is colliding with a triangle (static in this case).
 
diff --git a/docs/source/tutorial/misc.rst b/docs/source/tutorial/misc.rst
@@ -66,7 +66,7 @@ You can also set the log level:
 Multi-threading
 ---------------
 
-The IPC Toolkit utilizes `TBB <https://oneapi-src.github.io/oneTBB>`_ to enable multi-threading functionality. This is enabled by default, and significantly improves performance.
+The IPC Toolkit utilizes `oneTBB <https://oneapi-src.github.io/oneTBB>`_ to enable multi-threading functionality. This is enabled by default, and significantly improves performance.
 However, with multi-threading enabled, it is expected that the results can be non-deterministic because of rounding differences when adding numbers in different orders. To make the results deterministic you can limit TBB's maximum number of threads to one. The following code shows how to do this:
 
 .. md-tab-set::
diff --git a/docs/source/tutorial/simulation.rst b/docs/source/tutorial/simulation.rst
@@ -130,7 +130,7 @@ While IPC cannot directly handle nonlinear finite element bases and/or curved me
             collision_mesh = CollisionMesh(
                 proxy_rest_positions, proxy_edges, proxy_faces, displacement_map)
 
-We can then map the displacements using ``collision_mesh.map_displacement(fe_displacements)`` or directly get the displaced proxy mesh vertices using ``collision_mesh.displace_vertices(fe_displacements)``. Similarly, we can map forces/gradients using ``collision_mesh.to_full_dof(contact_forces)`` or force jacobians/potential hessians using ``collision_mesh.to_full_dof(potential_hessian)``.
+We can then map the displacements using ``collision_mesh.map_displacement(fe_displacements)`` or directly get the displaced proxy mesh vertices using ``collision_mesh.displace_vertices(fe_displacements)``. Similarly, we can map forces/gradients using ``collision_mesh.to_full_dof(contact_forces)`` or force Jacobians/potential Hessians using ``collision_mesh.to_full_dof(potential_hessian)``.
 
 .. warning::
     The function ``CollisionMesh::vertices(full_positions)`` should not be used in this case because the rest positions used to construct the ``CollisionMesh`` are not the same as the finite element mesh's rest positions. Instead, use ``CollisionMesh::displace_vertices(fe_displacements)`` where ``fe_displacements`` is already the solution of the PDE or can be computed as ``fe_displacements = fe_positions - fe_rest_positions`` from deformed and rest positions.
