Fill-in section on level sets and free surfaces.

  - Added parallel Hopf-Lax reference

Author: abisner

paper/paper.bib

@@ -9,7 +9,7 @@ @article{copa:2021
   doi = {10.1177/10943420211022829}
 }
 
-@article{Slattery2022, 
+@article{Slattery2022,
     doi = {10.21105/joss.04115},
     url = {https://doi.org/10.21105/joss.04115},
     year = {2022},
@@ -19,7 +19,7 @@ @article{Slattery2022
     pages = {4115},
     author = {Stuart Slattery and Samuel Temple Reeve and Christoph Junghans and Damien Lebrun-Grandié and Robert Bird and Guangye Chen and Shane Fogerty and Yuxing Qiu and Stephan Schulz and Aaron Scheinberg and Austin Isner and Kwitae Chong and Stan Moore and Timothy Germann and James Belak and Susan Mniszewski},
     title = {Cabana: A Performance Portable Library for Particle-Based Simulations},
-    journal = {Journal of Open Source Software} } 
+    journal = {Journal of Open Source Software} }
 
 @article{kokkos:2022,
     title = {Kokkos 3: {Programming} {Model} {Extensions} for the {Exascale} {Era}},
@@ -98,8 +98,8 @@ @inproceedings{ippl
 
 @ARTICLE{vpic,
   author={Bird, Robert and Tan, Nigel and Luedtke, Scott V. and Harrell, Stephen Lien and Taufer, Michela and Albright, Brian},
-  journal={IEEE Transactions on Parallel and Distributed Systems}, 
-  title={VPIC 2.0: Next Generation Particle-in-Cell Simulations}, 
+  journal={IEEE Transactions on Parallel and Distributed Systems},
+  title={VPIC 2.0: Next Generation Particle-in-Cell Simulations},
   year={2022},
   volume={33},
   number={4},
@@ -140,3 +140,16 @@ @inproceedings{ipic
   year={2024},
   organization={Wiley Online Library}
 }
+
+@article{Royston:2018,
+	author = {Michael Royston and Andre Pradhana and Byungjoon Lee and Yat Tin Chow and Wotao Yin and Joseph Teran and Stanley Osher},
+	doi = {https://doi.org/10.1016/j.jcp.2018.01.035},
+	issn = {0021-9991},
+	journal = {Journal of Computational Physics},
+	keywords = {Level set methods, Eikonal equation, Hamilton Jacobi, Hopf--Lax},
+	pages = {7-17},
+	title = {Parallel redistancing using the {Hopf--Lax} formula},
+	url = {https://www.sciencedirect.com/science/article/pii/S0021999118300457},
+	volume = {365},
+	year = {2018}
+}

paper/paper.md

@@ -70,7 +70,7 @@ The order of the dependency templates (if there are any dependencies) is defined
 `Picasso` provides two modes for initializing particles on a background grid: `InitUniform` and `InitRandom`. In addition to requiring parameters (particles per dimension for `InitUniform` or particles per cell for `InitRandom`), a user-defined predicate functor must also be provided that returns true or false based on certain criteria of the candidate particle, such as position. The design for a custom user-hook during the creation phase allows for flexible and arbitrary particle initialization.
 
 ### Batched Linear Algebra
-Matrix-vector and matrix-matrix operations are nearly ubiquitous in particle-to-grid and grid-to-particle mappings, function space projections, and other common operations wherein support for writing concise vectorial expressions is benefitial for both code readability, as well as exposing algorithmic parallelism.  The `Picasso` library also implements kernel-level dense linear algebra operations in a corresponding `LinearAlgebra` namespace using a combination of expression templates for lazy evaluation and data structures to hold intermediates for eager evaluations when necessary. The general concept in the `Picasso` implementation for lazy vs. eager evaluations disencumbers the algorithm author from considering additional performance factors such as overhead incurred from excessive copies or total operation counts in otherwise unoptimized code. Using built-in operator overloading with support for expression templates, users can build complex nested tensorial expressions that are a mixture of both eager and lazy evaluations. For example, if `A` and `B` are NxN and `x` is length N:
+Matrix-vector and matrix-matrix operations are nearly ubiquitous in particle-to-grid and grid-to-particle mappings, function space projections, and other common operations wherein support for writing concise vectorial expressions is benefitial for both code readability, as well as exposing algorithmic parallelism.  The `Picasso` library also implements kernel-level dense linear algebra operations in a corresponding `LinearAlgebra` namespace using a combination of expression templates for lazy evaluation and data structures to hold intermediates for eager evaluations when necessary. The general concept in the `Picasso` implementation for lazy vs. eager evaluations alleviates the consideration of additional performance factors such as overhead incurred from excessive copies or total operation counts in otherwise unoptimized code. Using built-in operator overloading with support for expression templates, users can build complex nested tensorial expressions that are a mixture of both eager and lazy evaluations. For example, if `A` and `B` are NxN and `x` is length N:
 ```cpp
   auto C = 0.5 * (A + ~A) * B + (x * ~x);
 ```
@@ -79,10 +79,10 @@ where the returned `C` is an NxN matrix, `~` is the transpose operator, and the
 `Picasso` provides an interface for various supported linear algebra types defined in `FieldTypes`: `Scalar`, `Vector`, `Matrix`, as well as specialized support for higher-rank `Tensor3`, `Tensor4`, and `Quaternion` types. Field tags need only derive from these types in order to make use of `Picasso` linear algebra features. Although all basic operations on vectors and matrices are implemented, several specialized operations are also available, including matrix determinant, inverse, exponential, LU, and SVD decompositions, higher-order tensor contractions, and quaternion-matrix conjugation.
 
 ## Interpolation
+The core facility of the `Picasso` library lies in
 
-
-## Free surfaces
-
+## Level Sets and Boundaries
+The `Picasso::LevelSet` and `Picasso::ParticleLevelSet` are fast parallel implementations of grid-based signed distance fields (SDF), which are relevant to level-set based approaches in interface reconstruction and boundary tracking. In particular, the `ParticleLevelSet` class relies on functionality from [ArborX::BVH](https://github.com/arborx/ArborX) (bounding volume hiererarchy) for nearest point queries to compute a level set signed distance estimate, $\phi_i^{0}$, on the mesh using analytic spherical particle level sets $\phi_p$ as proxy. A parallel Hopf-Lax redistancing algorithm is also implemented that properly reinitializes the level set estimate $\phi$ into a final SDF ($|\nabla\phi_i|=1$). Additionally, the `Picasso::MarchingCubes` namespace provides methods and data structures for triangulating the resulting SDF. The computed mesh facets may be serialized to disk in STL format or used for further processing, for instance in convex hull initialization or embedded free surface tracking algorithms.
 
 ## Examples and performance testing