To find the (an) apparent horizon, i.e. an outermost MOTS, the starting surface should be outside the largest possible MOTS in the slice. In practice, it generally suffices to start with a 2-sphere of areal radius substantially greater than .
The global convergence property requires that a flow algorithm always flow from a large starting surface into the apparent horizon. This means that the algorithm gains no particular benefit from already knowing the approximate position of the apparent horizon. In particular, flow algorithms are no faster when “tracking” the apparent horizon (repeatedly finding it at frequent intervals) in a numerical time evolution. (In contrast, in this situation a local apparent horizon finding algorithm can use the most recent previously-found apparent horizon as an initial guess, greatly speeding the algorithm’s convergence55).
Flow algorithms were first proposed for apparent horizon finding by Tod . He initially considered the case of a time-symmetric slice (one where ). In this case, a MOTS (and thus an apparent horizon) is a surface of minimal area and may be found by a “mean curvature flow” has proven that if the slice contains a minimum-area surface, this will in fact be the stable limit of this flow. Unfortunately, this proof is valid only for the time-symmetric case.
For non-time-symmetric slices, Tod  proposed generalizing the mean curvature flow to the “expansion flow”
Numerical experiments by Bernstein , Shoemaker et al. [148, 149], and Pasch  show that in practice the expansion flow (39) does in fact converge robustly to the apparent horizon.
In the following I discuss a number of important implementation details for, and refinements of, this basic algorithm.
Assuming the Strahlkörper surface parameterization (4), the expansion flow (39) is a parabolic equation for the horizon shape function .57 This means that any fully explicit scheme to integrate it (in the pseudo-time ) must severely restrict its pseudo-time step for stability, and this restriction grows (quadratically) worse at higher spatial resolutions58. This makes the horizon finding process very slow.
To avoid this restriction, practical implementations of flow algorithms use implicit pseudo-time integration schemes; these can have large pseudo-time steps and still be stable. Because we only care about the limit, a highly accurate pseudo-time integration is not important; only the accuracy of approximating the spatial derivatives matters. Bernstein  used a modified Du Fort–Frankel scheme 59 but found some problems with the surface shape gradually developing high-spatial-frequency noise. Pasch  reports that an “exponential” integrator (Hochbruck et al. ) works well, provided the flow’s Jacobian matrix is computed accurately60. The most common choice is probably that of Shoemaker et al. [148, 149], who use the iterated Crank–Nicholson (“ICN”) scheme61. They report that this works very well; in particular, they do not report any noise problems.
By refining his finite-element grid (Section 2.3) in a hierarchical manner, Metzger  is able to use standard conjugate-gradient elliptic solvers in a multigrid-like fashion62, using each refinement level’s solution as an initial guess for the next higher refinement level’s iterative solution. This greatly speeds the flow integration: Metzger reports that the performance of the overall surface-finding algorithm is “of the same order of magnitude” as that of Thornburg’s AHFinderDirect  elliptic-PDE apparent horizon finder (described in Section 8.5.7).
In a more general context than numerical relativity, Osher and Sethian  have discussed a general class of numerical algorithms for integrating “fronts propagating with curvature-dependent speed”. These flow a level-set function (Section 2.1) which implicitly locates the actual “front”.
Another important performance optimization of the standard expansion flow (39) is to replace in the right-hand side by a suitable nonlinear function of , chosen so the surface shrinks faster when it is far from the apparent horizon. For example, Shoemaker et al. [148, 149] use the flow
Since a flow algorithm starts with (topologically) a single large 2-sphere, if there are multiple apparent horizons present the surface must change topology (bifurcate) at some point in the flow. Depending on how the surface is represented, this may be easy or difficult.
Pasch  and Shoemaker et al. [148, 149] use a level-set function approach (Section 2.1). This automatically handles any topology or topology change. However, it has the drawback of requiring the flow to be integrated throughout the entire volume of the slice (or at least in some neighborhood of each surface). This is likely to be much more expensive than only integrating the flow on the surface itself. Shoemaker et al. also generate an explicit Strahlkörper surface representation (Section 2.2), monitoring the surface shape to detect an imminent bifurcation and reparameterizing the shape into 2 separate surfaces if a bifurcation happens.
Metzger  uses a finite-element surface representation (Section 2.3), which can represent any topology. However, if the flow bifurcates, then to explicitly represent each apparent horizon the code must detect that the surface self-intersects, which may be expensive.
Gundlach  introduced the important concept of a “fast flow”. He observed that the subtraction and inversion of the flat-space Laplacian in the Nakamura–Kojima–Oohara spectral integral-iteration algorithm (Section 8.4) is an example of “a standard way of solving nonlinear elliptic problems numerically, namely subtracting a simple linear elliptic operator from the nonlinear one, inverting it by pseudo-spectral algorithms and iterating”. Gundlach then interpreted the Nakamura–Kojima–Oohara algorithm as a type of flow algorithm where each pseudo-time step of the flow corresponds to a single functional-iteration step of the Nakamura–Kojima–Oohara algorithm.
In this framework, Gundlach defines a 2-parameter family of flows interpolating between the Nakamura–Kojima–Oohara algorithm and Tod’s  expansion flow (39),
Alcubierre’s AHFinder  horizon finder includes an implementation of Gundlach’s fast flow algorithm63. AHFinder is implemented as a freely available module (“thorn”) in the Cactus computational toolkit (see Table 2) and has been used by many research groups.
Flow algorithms are the only truly global apparent horizon finding algorithms and, as such, can be much more robust than local algorithms. In particular, flow algorithms can guarantee convergence to the outermost MOTS in a slice. Unfortunately, these convergence guarantees hold only for time-symmetric slices.
In the forms which have strong convergence guarantees, flow algorithms tend to be very slow. (Metzger’s algorithm  is a notable exception: It is very fast.) There are modifications which can make flow algorithms much faster, but then their convergence is no longer guaranteed. In particular, practical experience has shown that in some binary black hole coalescence simulations (Alcubierre et al. , Diener et al. ), “fast flow” algorithms (Section 8.7.4) can miss common apparent horizons which are found by other (local) algorithms.
Alcubierre’s apparent horizon finder AHFinder  includes a “fast flow” algorithm based on the work of Gundlach 63. It is implemented as a freely available module (“thorn”) in the Cactus computational toolkit (see Table 2) and has been used by a number of research groups.
This work is licensed under a Creative Commons Attribution-Noncommercial-No Derivative Works 2.0 Germany License.