Event and Apparent Horizon Finders for 3 + 1 Numerical Relativity
 2k Downloads
 56 Citations
Abstract
Event and apparent horizons are key diagnostics for the presence and properties of black holes. In this article I review numerical algorithms and codes for finding event and apparent horizons in numericallycomputed spacetimes, focusing on calculations done using the 3 + 1 ADM formalism. The event horizon of an asymptoticallyflat spacetime is the boundary between those events from which a futurepointing null geodesic can reach future null infinity and those events from which no such geodesic exists. The event horizon is a (continuous) null surface in spacetime. The event horizon is defined nonlocally in time: it is a global property of the entire spacetime and must be found in a separate postprocessing phase after all (or at least the nonstationary part) of spacetime has been numerically computed.
There are three basic algorithms for finding event horizons, based on integrating null geodesics forwards in time, integrating null geodesics backwards in time, and integrating null surfaces backwards in time. The last of these is generally the most efficient and accurate.
In contrast to an event horizon, an apparent horizon is defined locally in time in a spacelike slice and depends only on data in that slice, so it can be (and usually is) found during the numerical computation of a spacetime. A marginally outer trapped surface (MOTS) in a slice is a smooth closed 2surface whose futurepointing outgoing null geodesics have zero expansion Θ. An apparent horizon is then defined as a MOTS not contained in any other MOTS. The MOTS condition is a nonlinear elliptic partial differential equation (PDE) for the surface shape, containing the ADM 3metric, its spatial derivatives, and the extrinsic curvature as coefficients. Most “apparent horizon” finders actually find MOTSs.
There are a large number of apparent horizon finding algorithms, with differing tradeoffs between speed, robustness, accuracy, and ease of programming. In axisymmetry, shooting algorithms work well and are fairly easy to program. In slices with no continuous symmetries, spectral integraliteration algorithms and ellipticPDE algorithms are fast and accurate, but require good initial guesses to converge. In many cases, Schnetter’s “pretracking” algorithm can greatly improve an ellipticPDE algorithm’s robustness. Flow algorithms are generally quite slow but can be very robust in their convergence. Minimization methods are slow and relatively inaccurate in the context of a finite differencing simulation, but in a spectral code they can be relatively faster and more robust.
1 Part I Introduction
Systems with strong gravitational fields, particularly systems which may contain event horizons and/or apparent horizons, are a major focus of numerical relativity. The usual output of a numerical relativity simulation is some (approximate, discrete) representation of the spacetime geometry (the 4metric and possibly its derivatives) and any matter fields, but not any explicit information about the existence, precise location, or other properties of any event/apparent horizons. To gain this information, we must explicitly find the horizons from the numericallycomputed spacetime geometry. The subject of this review is numerical algorithms and codes for doing this, focusing on calculations done using the 3 + 1 ADM formalism [14, 163]. Baumgarte and Shapiro [27, Section 6] have also recently reviewed event and apparent horizon finding algorithms. The scope of this review is limited to the finding of event/apparent horizons and omits any but the briefest mention of the many uses of this information in gaining physical understanding of numericallycomputed spacetimes.
In this review I distinguish between a numerical algorithm (an abstract description of a mathematical computation; also often known as a “method” or “scheme”), and a computer code (a “horizon finder”, a specific piece of computer software which implements a horizon finding algorithm or algorithms). My main focus is on the algorithms, but I also mention specific codes where they are freely available to other researchers.
In this review I have tried to cover all the major horizon finding algorithms and codes, and to accurately credit the earliest publication of important ideas. However, in a field as large and active as numerical relativity, it is not unlikely that I have overlooked and/or misdescribed some important research. I apologise to anyone whose work I’ve slighted, and I ask readers to help make this a truly “living” review by sending me corrections, updates, and/or pointers to additional work (either their own or others) that I should discuss in future revisions of this review.
The general outline of this review is as follows: In the remainder of Part I, I define notation and terminology (Section 1), discuss how 2surfaces should be parameterized (Section 2), and outline some of the softwareengineering issues that arise in modern numerical relativity codes (Section 3). I then discuss numerical algorithms and codes for finding event horizons (Part II) and apparent horizons (Part III). Finally, in the appendices I briefly outline some of the excellent numerical algorithms/codes available for two standard problems in numerical analysis, the solution of a single nonlinear algebraic equation (Appendix A) and the time integration of a system of ordinary differential equations (Appendix B).
2 Notation and Terminology
Except as noted below, I generally follow the sign and notation conventions of Wald [160]. I assume that all spacetimes are globally hyperbolic, and for eventhorizon finding I further assume asymptotic flatness; in this latter context \({{\mathcal J}^ +}\) is future null infinity. I use the Penrose abstractindex notation, with summation over all repeated indices. 4indices abc range over all spacetime coordinates {x^{a}}, and 3indices ijk range over the spatial coordinates {x^{i}} in a spacelike slice t = constant. The spacetime coordinates are thus x^{a} = (t, x^{i}).
Indices uvw range over generic angular coordinates (θ, ϕ) on S^{2} or on a horizon surface. Note that these coordinates are conceptually distinct from the 3dimensional spatial coordinates x^{i}. Depending on the context, (θ, ϕ) may or may not have the usual polarspherical topology. Indices ijk label angular grid points on S^{2} or on a horizon surface. These are 2dimensional indices: a single such index uniquely specifies an angular grid point. δ_{IJ} is the Kronecker delta on the space of these indices or, equivalently, on surface grid points.
For any indices p and q, ∂_{p} and ∂_{pq} are the coordinate partial derivatives ∂/∂x^{p} and ∂^{2}/∂x^{p}∂x^{q} respectively; for any coordinates µ and ν, ∂_{u} and ∂_{µν} are the coordinate partial derivatives ∂/∂/µ and ∂^{2}/∂µ∂ν respectively. Δ is the flatspace angular Laplacian operator on S^{2}, while Δx refers to a finitedifference grid spacing in some variable x.
g_{ab} is the spacetime 4metric, and g^{ab} the inverse spacetime 4metric; these are used to raise and lower 4indices. \(\Gamma _{ab}^c\) are the 4Christoffel symbols. \({{\mathcal L}_\upsilon}\) is the Lie derivative along the 4vector field v^{a}.
I often write a differential operator as F = F (y, ∂_{u}y, ∂_{uv}y; g_{ij}, ∂_{k}g_{ij}, K_{ij}), where the “;” notation means that F is a (generally nonlinear) algebraic function of the variable y and its 1st and 2nd angular derivatives, and that F also depends on the coefficients g_{ij}, ∂_{k}g_{ij}, and K_{ij} at the apparent horizon position.
There are three common types of spacetimes/slices where numerical event or apparent horizon finding is of interest: sphericallysymmetric spacetimes/slices, axisymmetric spacetimes/slices, and spacetimes/slices with no continuous spatial symmetries (no spacelike Killing vectors). I refer to the latter as “fully generic” spacetimes/slices.
In this review I use the abbreviations “ODE” for ordinary differential equation, “PDE” for partial differential equation, “CE surface” for constantexpansion surface, and “MOTS” for marginally outer trapped surface. Names in Small Capitals refer to horizon finders and other computer software.
When discussing iterative numerical algorithms, it is often convenient to use the concept of an algorithm’s “radius of convergence”. Suppose the solution space within which the algorithm is iterating is S. Then given some norm ‖ · ‖ on S, the algorithm’s radius of convergence about a solution s ∈ S is defined as the smallest r > 0 such that the algorithm will converge to the correct solution s for any initial guess g with ‖g − s‖ ≤ r. We only rarely know the exact radius of convergence of an algorithm, but practical experience often provides a rough estimate^{1}.
3 2Surface Parameterizations
3.1 Levelsetfunction parameterizations
This parameterization is valid for any surface topology including timedependent topologies. The 2surface itself can then be found by a standard isosurfacefinding algorithm such as the marchingcubes algorithm [105]. (This algorithm is widely used in computer graphics and is implemented in a number of widelyavailable software libraries.)
3.2 Strahlkörper parameterizations
Most apparent horizon finders, and some eventhorizon finders, assume that each connected component of the apparent (event) horizon has S^{2} topology. With the exception of toroidal event horizons (discussed in Section 4), this is generally a reasonable assumption.
a region in nD Euclidean space containing the origin and whose surface, as seen from the origin, exhibits only one point in any direction.
For eventhorizon finding, algorithms and codes are now available which allow an arbitrary horizon topology with no Strahlkörper assumption (see the discussion in Section 5.3.3 for details). For apparent horizon finding, the flow algorithms discussed in Section 8.7 theoretically allow any surface shape, although many implementations still make the Strahlkörper assumption. Removing this assumption for other apparent horizon finding algorithms might be a fruitful area for further research.

Spectral representation
Here we expand the horizon shape function h in an infinite series in some (typically orthonormal) set of basis functions such as spherical harmonics Y_{ℓm} or symmetric tracefree tensors^{2},This series can then be truncated at some finite order ℓ_{max}, and the N_{coeff} = ℓ_{max}(ℓ_{max}+1) coefficients {a_{ℓm}} used to represent (discretely approximate) the horizon shape. For reasonable accuracy, ℓ_{max} is typically on the order of 8 to 12.$$h(\theta, \phi) = \sum\limits_{\ell, m} {{a_{\ell m}}{Y_{\ell m}}(\theta, \phi).}$$(5) 
Finite difference representation
Here we choose some finite grid of angular coordinates {(θ_{K}, ϕ_{K})}, K = 1, 2, 3, …, N_{ang} on S^{2} (or equivalently on the surface)^{3}, and represent (discretely approximate) the surface shape by the N_{ang} valuesFor reasonable accuracy, N_{ang} is typically on the order of a few thousand.$$\{h({\theta _{\rm{K}}},{\phi _{\rm{K}}})\} \quad {\rm{K = 1,2,3,}} \ldots, {N_{{\rm{ang}}}}.$$(6)
3.3 Finiteelement parameterizations
Another way to parameterize a 2surface is via finite elements where the surface is modelled as a triangulated mesh, i.e. as a set of interlinked “vertices” (points in the slice, represented by their spatial coordinates {x^{i}}), “edges” (represented by ordered pairs of vertices), and faces. Typically only triangular faces are used (represented as oriented triples of vertices).
A key benefit of this representation is that it allows an arbitrary topology for the surface. However, determining the actual surface topology (e.g. testing for whether or not the surface selfintersects) is somewhat complicated.
This representation is similar to that of Regge calculus [128, 72]^{4}, and can similarly be expected to show 2nd order convergence with the surface resolution.
4 SoftwareEngineering Issues
Historically, numerical relativists wrote their own codes from scratch. As these became more complex, many researchers changed to working on “group codes” with multiple contributors.
4.1 Software libraries and toolkits
More recently, particularly in work on fully generic spacetimes, where all three spatial dimensions must be treated numerically, there has been a strong trend towards the use of higherlevel software libraries and modular “computational toolkits” such as Cactus [74] (http://www.cactuscode.org). These have a substantial learning overhead, but can allow researchers to work much more productively by focusing more on numerical relativity instead of computerscience and softwareengineering issues such as parameterfile parsing, parallelization, I/O, etc.
In this review I point out event and apparent horizon finders which have been written in particular frameworks and comment on whether they work with mesh refinement.
4.2 Code reuse and sharing
Another important issue is that of code reuse and sharing. It is common for codes to be shared within a research group but relatively uncommon for them to be shared between different (competing) research groups. Even apart from concerns about competitive advantage, without a modular structure and clear documentation it is difficult to reuse another group’s code. The use of a common computational toolkit can greatly simplify such reuse.
If such reuse can be accomplished, it becomes much easier for other researchers to build on existing work rather than having to “reinvent the wheel”. As well as the obvious ease of reusing existing code that (hopefully!) already works and has been thoroughly debugged and tested, there is another — less obvious — benefit of code sharing: It greatly eases the replication of past work, which is essential as a foundation for new development. That is, without access to another researcher’s code, it can be surprisingly difficult to replicate her results because the success or failure of a numerical algorithm frequently depends on subtle implementation details not described in even the most complete of published papers.
Event and apparent horizon finders are excellent candidates for software reuse: Many numericalrelativity researchers can benefit from using them, and they have a relatively simple interface to an underlying numericalrelativity simulation. Even if a standard computational toolkit is not used, this relatively simple interface makes it fairly easy to port an event or apparent horizon finder to a different code.
This table lists event and apparent horizon finders which are freely available to any researcher, along with the cvs repositories or web pages from which they may be obtained.
Toolkit/Program  References  Algorithm Type 

Cactus/EHFinder  [60]  Integrate null surfaces backwards in time (Section 5.3) 
cvs d:pserver:cvs_anon@cvs.aei.mpg.de:/numrelcvs checkout AEIThorns/EHFinder  
Cactus/AHFinder  [4]  
cvs d:pserver:cvs_anon@cvs.cactuscode.org:/cactusdevcvs checkout CactusEinstein/AHFinder  
Cactus/AHFinderDirect  [156]  EllipticPDE (Section 8.5) 
cvs d:pserver:cvs_anon@cvs.aei.mpg.de:/numrelcvs checkout AEIThorns/AHFinderDirect  
Modified by Schnetter [133, 135] to support pretracking (Section 8.6)  
cvs d:pserver:cvs_anon@cvs.aei.mpg.de:/numrelcvs r Erik checkout AEIThorns/AHFinderDirect  
Caotus/TGRapparentHorizon2D  EllipticPDE (Section 8.5)  
cvs d:pserver:cvs_anon@cvs.cactuscode.org:/arrangements checkout TAT_Archive/TGRapparentHorizon2D  
Lorene/AE_finder  [104]  spectral integraliteration algorithm (Section 8.4.2) 
4.3 Using multiple event/apparent horizon finders
It is useful to have multiple event or apparent horizon finders available: Their strengths and weaknesses may complement each other, and the extent of agreement or disagreement between their results can help to estimate the numerical accuracy. For example, Figure 11 shows a comparison between the irreducible masses of apparent horizons in a binary black hole coalescence simulation (Alcubierre et al. [5], [Figure 4b]), as computed by two different apparent horizon finders in the Cactus toolkit, AHFinder and AHFinderDireot. In this case the two agree to within about 2% for the individual horizons and 0.5% for the common horizon.
5 Part II Finding Event Horizons
6 Introduction
The black hole region of an asymptoticallyflat spacetime is defined [81, 82] as the set of events from which no futurepointing null geodesic can reach future null infinity (\({{\mathcal J}^ +}\)). The event horizon is defined as the boundary of the black hole region. The event horizon is a null surface in spacetime with (in the words of Hawking and Ellis [82, Page 319]) “a number of nice properties” for studying the causal stucture of spacetime.
The event horizon is a global property of an entire spacetime and is defined nonlocally in time: The event horizon in a slice is defined in terms of (and cannot be computed without knowing) the full future development of that slice.
In practice, to find an event horizon in a numericallycomputed spacetime, we typically instrument a numerical evolution code to write out data files of the 4metric. After the evolution (or at least the strongfield region) has reached an approximatelystationary final state, we then compute a numerical approximation to the event horizon in a separate postprocessing pass, using the 4metric data files as inputs.
As a null surface, the event horizon is necessarily continuous. In theory it need not be anywhere differentiable^{6}, but in practice this behavior rarely occurs^{7}: The event horizon is generally smooth except for possibly a finite set of “cusps” where new generators join the surface; the surface normal has a jump discontinuity across each cusp. (The classic example of such a cusp is the “inseam” of the “pair of pants” event horizon illustrated in Figures 4 and 5.)
A black hole is defined as a connected component of the black hole region in a 3 + 1 slice. The boundary of a black hole (the event horizon) in a slice is a 2dimensional set of events. Usually this has 2sphere (S^{2}) topology. However, numerically simulating rotating dust collapse, Abrahams et al. [1] found that in some cases the event horizon in a slice may be toroidal in topology. Lehner et al. [99], and Husa and Winicour [91] have used null (characteristic) algorithms to give a general analysis of the event horizon’s topology in black hole collisions; they find that there is generically a (possibly brief) toroidal phase before the final 2spherical state is reached. Lehner et al. [100] later calculated movies showing this behavior for several asymmetric black hole collisions.
7 Algorithms and Codes for Finding Event Horizons
7.1 Integrating null geodesics forwards in time
The first generation of eventhorizon finders were based directly on Hawking’s original definition of an event horizon: an event \({\mathcal P}\) is within the black hole region of spacetime if and only if there is no futurepointing “escape route” null geodesic from \({\mathcal P}\) to \({{\mathcal J}^ +}\); the event horizon is the boundary of the black hole region.
For numerical work it is straightforward to rewrite the null geodesic equation (8) as a coupled system of two firstorder equations, giving the time evolution of photon positions and 3momenta in terms of the 3 + 1 geometry variables α, β^{i}, g^{ij}, and their spatial derivatives. These can then be timeintegrated by standard numerical algorithms^{8}. However, in practice several factors complicate this algorithm.
We typically only know the 3 + 1 geometry variables on a discrete lattice of spacetime grid points, and we only know the 3 + 1 geometry variables themselves, not their spatial derivatives. Therefore we must numerically differentiate the field variables, then interpolate the field variables and their spacetime derivatives to each integration point along each null geodesic. This is straightforward to implement^{9}, but the numerical differentiation tends to amplify any numerical noise that may be present in the field variables.
Another complicating factor is that the numerical computations generally only span a finite region of spacetime, so it is not entirely obvious whether or not a given geodesic will eventually reach \({{\mathcal J}^ +}\). However, if the final numericallygenerated slice contains an apparent horizon, we can use this as an approximation: Any geodesic which is inside this apparent horizon will definitely not reach \({{\mathcal J}^ +}\), while any other geodesic may be assumed to eventually reach \({{\mathcal J}^ +}\) if its momentum is directed away from the apparent horizon. If the final slice (or at least its strongfield region) is approximately stationary, the error from this approximation should be small. I discuss this stationarity assumption further in Section 5.3.1.
7.1.1 Sphericallysymmetric spacetimes
7.1.2 Nonsphericallysymmetric spacetimes

Many trial events must be tried to accurately resolve the event horizon’s shape. (Hughes et al. [88] describe a 2stage adaptive numerical algorithm for choosing the trial events so as to accurately locate the event horizon as efficiently as possible.)

At each trial event we must try many different trialgeodesic starting directions to see if any of the geodesics escape to \({{\mathcal J}^ +}\) (or our numerical approximation to it). Hughes et al. [88] report needing only 48 geodesics per trial event in several nonrotating axisymmetric spacetimes, but about 750 geodesics per trial event in rotating axisymmetric spacetimes, with up to 3000 geodesics per trial event in some regions of the spacetimes.

Finally, each individual geodesic integration requires many (short) time steps for an accurate integration, particularly in the strongfield region near the event horizon.
Because of these limitations, for nonsphericallysymmetric spacetimes the “integrate null geodesics forwards” algorithm has generally been supplanted by the more efficient algorithms I describe in the following.
7.2 Integrating null geodesics backwards in time
Anninos et al. [7] and Libson et al. [103] observed that while this instability is a problem for the “integrate null geodesics forwards in time” algorithm (it forces that algorithm to take quite short time steps when integrating the geodesics), we can turn it to our advantage by integrating the geodesics backwards in time: The geodesics will now converge on to the horizon^{10}.
This eventhorizon finding algorithm thus integrates a large number of such (futurepointing outgoing) null geodesics backwards in time, starting on the final numericallygenerated slice. As the backwards integration proceeds, even geodesics which started far from the event horizon will quickly converge to it. This can be seen, for example, in Figures 2 and 3.
[…] for the general 3D case, when the two tangential directions of the EH are also considered, the situation becomes more complicated. Here normal and tangential are meant in the 3D spatial, not spacetime, sense. Whether or not a trajectory can eventually be “attracted” to the EH, and how long it takes for it to become “attracted,” depends on the photon’s starting direction of motion. We note that even for a photon which is already exactly on the EH at a certain instant, if its velocity at that point has some component tangential to the EH surface as generated by, say, numerical inaccuracy in integration, the photon will move outside of the EH when traced backward in time. For a small tangential velocity, the photon will eventually return to the EH […but] the position to which it returns will not be the original position.
This kind of tangential drifting is undesirable not just because it introduces inaccuracy in the location of the EH, but more importantly, because it can lead to spurious dynamics of the “EH” thus found. Neighboring generators may cross, leading to numerically artificial caustic points […].
Another consequence of the second order nature of the geodesic equation is that not just the positions but also the directions must be specified in starting the backward integration. Neighboring photons must have their starting direction well correlated in order to avoid tangential drifting across one another.
Because of these difficulties, this algorithm has generally been supplanted by the “backwards surface” algorithm I describe next.[…] is still quite demanding in finding an accurate history of the EH, although the difficulties are much milder than those arising from the instability of integrating forward in time.
7.3 Integrating null surfaces backwards in time
Surfaces near the event horizon share the same “attraction” property discussed in Section 5.2 for geodesics near the event horizon. Thus by integrating either surface representation (10) or (11) backwards in time, we can refine an initial guess into a very accurate approximation to the event horizon.
In contrast to the null geodesic equation (8), neither Equation (10) nor Equation (11) contain any derivatives of the 4metric (or equivalently the 3 + 1 geometry variables). This makes it much easier to integrate these latter equations accurately^{11}. This formulation of the eventhorizon finding problem also completely eliminates the tangentialdrifting problem discussed in Section 5.2, since the levelset function only parameterizes motion normal to the surface.
7.3.1 Error bounds: Integrating a pair of surfaces
For a practical algorithm, it is useful to integrate a pair of trial null surfaces backwards: an “innerbound” one which starts (and thus always remains) inside the event horizon and an “outerbound” one which starts (and thus always remains) outside the event horizon. If the final slice contains an apparent horizon then any 2surface inside this can serve as our innerbound surface. However, choosing an outerbound surface is more difficult.
It is this desire for a reliable outer bound on the event horizon position that motivates our requirement (Section 4) for the final slice (or at least its strongfield region) to be approximately stationary: In the absence of timedependent equations of state or external perturbations entering the system, this requirement ensures that, for example, any surface substantially outside the apparent horizon can serve as an outerbound surface.
Assuming we have an inner and an outerbound surface on the final slice, the spacing between these two surfaces after some period of backwards integration then gives an error bound for the computed event horizon position. Equivalently, a necessary (and, if there are no other numerical problems, sufficient) condition for the eventhorizon finding algorithm to be accurate is that the backwards integration must have proceeded far enough for the spacing between the two trial surfaces to be “small”. For a reasonable definition of “small”, this typically takes at least 15m_{ADM} of backwards integration, with 20m_{ADM} or more providing much higher accuracy.
In some cases it is difficult to obtain a long enough span of numerical data for this backwards integration. For example, in some simulations of binary black hole collisions, the evolution becomes unstable and crashes soon after a common apparent horizon forms. This means that we cannot compute an accurate event horizon for the most interesting region of the spacetime, that which is close to the blackhole merger. There is no good solution to this problem except for the obvious one of developing a stable (or lessunstable) simulation that can be continued for a longer time.
7.3.2 Explicit Strahlkörper surface representation
The initial implementations of the “integrate null surface backwards” algorithm by Anninos et al. [7], Libson et al. [103], and Walker [162] were based on the explicit Strahlkörper surface integration formula (11), further restricted to axisymmetry^{12}.

Since the cusp’s location is known a priori, it can be treated as a special case in the angular finite differencing, using onesided numerical derivatives as necessary.

Alternatively, in 1994 Thorne suggested calculating the union of the event horizon and all its null generators (including those which have not yet joined the surface)^{13}. This “surface” has a complicated topology (it selfintersects along the cusp), but it is smooth everywhere. This is illustrated by Figure 4, which shows a crosssection of this surface in a single slice, for a headon binary black hole collision. For comparison, Figure 5 shows a perspective view of part of the event horizon and some of its generators, for a similar headon binary black hole collision.
Caveny et al. [44, 46] implemented the “integrate null surfaces backwards” algorithm for fully generic numericallycomputed spacetimes using the explicit Strahlkörper surface integration formula (11). To handle moving black holes, they recentered each black hole’s Strahlkörper parameterization (4) on the black hole’s coordinate centroid at each time step.
7.3.3 Levelset parameterization
Caveny et al. [44, 45] and Diener [60] (independently) implemented the “integrate null surfaces backwards” algorithm for fully generic numericallycomputed spacetimes, using the levelset function integration formula (10). Here the levelset function F is initialized on the final slice of the evolution and evolved backwards in time using Equation (10) on (conceptually) the entire numerical grid. (In practice, only a smaller box containing the event horizon need be evolved.)
This surface parameterization has the advantage that the eventhorizon topology and (non) smoothness are completely unconstrained, allowing the numerical study of configurations such as toroidal event horizons (discussed in Section 4). It is also convenient that the levelset function F is defined on the same numerical grid as the spacetime geometry, so that no interpolation is needed for the evolution.
The major problem with this algorithm is that during the backwards evolution, spatial gradients in F tend to steepen into a jump discontinuity at the event horizon^{14}, eventually causing numerical difficulty.
EHFinder is implemented as a freely available module (“thorn”) in the Cactus computational toolkit (see Table 2). It originally worked only with the PUGH unigrid driver, but work is ongoing [61] to enhance it to work with the Carpet meshrefinement driver [134, 131].
8 Summary of Algorithms/Codes for Finding Event Horizons
In spherical symmetry the “integrate null geodesics forwards” algorithm (Section 5.1) can be used, although the “integrate null geodesics backwards” and “integrate null surfaces backwards” algorithms (Sections 5.2 and 5.3 respectively) are more efficient.
In nonsphericallysymmetric spacetimes the “integrate null surfaces backwards” algorithm (Section 5.3) is clearly the best algorithm known: It is efficient, accurate, and fairly easy to implement. For generic spacetimes, Diener’s eventhorizon finder EHFinder [60] is particularly notable as a freely available implementation of this algorithm as a module (“thorn”) in the widelyused Cactus computational toolkit (see Table 2).
9 Part III Finding Apparent Horizons
10 Introduction
10.1 Definition
Given a (spacelike) 3 + 1 slice, a “trapped surface” is defined as a smooth closed 2surface in the slice whose futurepointing outgoing null geodesics have negative expansion Θ. The “trapped region” in the slice is then defined as the union of all trapped surfaces, and the “apparent horizon” is defined as the outer boundary of the trapped region.
While mathematically elegant, this definition is not convenient for numerically finding apparent horizons. Instead, an alternate definition can be used: A MOTS is defined as a smooth (differentiable) closed orientable 2surface in the slice whose futurepointing outgoing null geodesics have zero expansion Θ.^{16} There may be multiple MOTSs in a slice, either nested within each other or intersecting^{17}. An apparent horizon is then defined as an outermost MOTS in a slice, i.e. a MOTS not contained in any other MOTS. Kriele and Hayward [98] have shown that subject to certain technical conditions, this definition is equivalent to the “outer boundary of the trapped region” one.
Notice that the apparent horizon is defined locally in time (it can be computed using only Cauchy data on a spacelike slice), but (because of the requirement that it be closed) nonlocally in space^{18}. Hawking and Ellis [82] discuss the general properties of MOTSs and apparent horizons in more detail.
Except for flow algorithms (Section 8.7), all numerical “apparent horizon” finding algorithms and codes actually find MOTSs, and hereinafter I generally follow the common (albeit sloppy) practice in numerical relativity of blurring the distinction between an MOTS and an apparent horizon.
10.2 General properties
Given certain technical assumptions (including energy conditions), the existence of any trapped surface (and hence any apparent horizon) implies that the slice contains a black hole^{19}. (The converse of this statement is not true: An arbitrary (spacelike) slice through a black hole need not contain any apparent horizon^{20}.) However, if an apparent horizon does exist, it necessarily coincides with, or is contained in, an event horizon. In a stationary spacetime the event and apparent horizons coincide.
It is this relation to the event horizon which makes apparent horizons valuable for numerical computation: An apparent horizon provides a useful approximation to the event horizon in a slice, but unlike the event horizon, an apparent horizon is defined locally in time and so can be computed “on the fly” during a numerical evolution.
Given a family of spacelike 3 + 1 slices which foliate part of spacetime, the union of the slices’ apparent horizons (assuming they exist) forms a worldtube^{21}. This worldtube is necessarily either null or spacelike. If it is null, this worldtube is slicingindependent (choosing a different family of slices gives the same worldtube, at least so long as each slice still intersects the worldtube in a surface with 2sphere topology). However, if the worldtube is spacelike, it is slicingdependent: Choosing a different family of slices will in general give a different worldtube^{22}.
10.3 Trapping, isolated, and dynamical horizons
Hayward [83] introduced the important concept of a “trapping horizon” (roughly speaking an apparent horizon worldtube where the expansion becomes negative if the surface is deformed in the inward null direction) along with several useful variants. Ashtekar, Beetle, and Fairhurst [16], and Ashtekar and Krishnan [18] later defined the related concepts of an “isolated horizon”, essentially an apparent horizon worldtube which is null, and a “dynamical horizon”, essentially an apparent horizon worldtube which is spacelike.
These worldtubes obey a variety of local and global conservation laws, and have many applications in analyzing numericallycomputed spacetimes. See the references cited above and also Dreyer et al. [63], Ashtekar and Krishnan [19, 20], Gourgoulhon and Jaramillo [76], Booth [36], and Schnetter, Krishnan, and Beyer [137] for further discussions, including applications to numerical relativity.
10.4 Description in terms of the 3 + 1 variables
10.5 Geometry interpolation
Θ depends on the slice geometry variables g_{ij}, ∂_{k}g_{ij}, and K_{ij} at the horizon position^{25}. In practice these variables are usually only known on the (3dimensional) numerical grid of the underlying numericalrelativity simulation^{26}, so they must be interpolated to the horizon position and, more generally, to the position of each intermediateiterate trial shape the apparent horizon finding algorithm tries in the process of (hopefully) converging to the horizon position.
Moreover, usually the underlying simulation gives only g_{ij} and K_{ij}, so g_{ij} must be numerically differentiated to obtain ∂_{k}g_{ij}. As discussed by Thornburg [156, Section 6.1], it is somewhat more efficient to combine the numerical differentiation and interpolation operations, essentially doing the differentiation inside the interpolator^{27}.
Thornburg [156, Section 6.1] argues that for an ellipticPDE algorithm (Section 8.5), for best convergence of the nonlinear elliptic solver the interpolated geometry variables should be smooth (differentiable) functions of the trial horizon surface position. He argues that that the usual Lagrange polynomial interpolation does not suffice here (in some cases his Newton’smethod iteration failed to converge) because this interpolation gives results which are only piecewise differentiable^{28}. He uses Hermite polynomial interpolation to avoid this problem. Cook and Abrahams [51], and Pfeiffer et al. [124] use bicubic spline interpolation; most other researchers either do not describe their interpolation scheme or use Lagrange polynomial interpolation.
10.6 Criteria for assessing algorithms

Robust: The algorithm/code should find an (the) apparent horizon in a wide range of numericallycomputed slices, without requiring extensive tuning of initial guesses, iteration parameters, etc. This is often relatively easy to achieve for “tracking” the time evolution of an existing apparent horizon (where the most recent previouslyfound apparent horizon provides an excellent initial guess for the new apparent horizon position) but may be difficult for detecting the appearance of a new (outermost) apparent horizon in an evolution, or for initialdata or other studies where there is no “previous time step”.

Accurate: The algorithm/code should find an (the) apparent horizon to high accuracy and should not report spurious “solutions” (“solutions” which are not actually good approximations to apparent horizons or, at least, to MOTSs).

Efficient: The algorithm/code should be efficient in terms of its memory use and CPU time; in practice CPU time is generally the major constraint. It is often desirable to find apparent horizons at each time step (or, at least, at frequent intervals) during a numerical evolution. For this to be practical the apparent horizon finder must be very fast.
In practice, no apparent horizon finder is perfect in all these dimensions, so tradeoffs are inevitable, particularly when ease of programming is considered.
10.7 Local versus global algorithms

Local algorithms are those whose convergence is only guaranteed in some (functional) neighborhood of a solution. These algorithms require a “good” initial guess in order to find the apparent horizon. Most apparent horizon finding algorithms are local.

Global algorithms are those which can (in theory, ignoring finitestepsize and other numerical effects) converge to the apparent horizon independent of any initial guess. Flow algorithms (Section 8.7) are the only truely global algorithms. Zerofinding in spherical symmetry (Section 8.1) and shooting in axisymmetry (Section 8.2) are “almost global” algorithms: They require only 1dimensional searches, which (as discussed in Appendix A) can be programmed to be very robust and efficient. In many cases horizon pretracking (Section 8.6) can semiautomatically find an initial guess for a local algorithm, essentially making the local algorithm behave like an “almost global” one.

In practice, local algorithms are much faster than global ones, particularly when “tracking” the time evolution of an existing apparent horizon.

Due to finitestepsize and other numerical effects, in practice even “global” algorithms may fail to converge to an apparent horizon. (That is, the algorithms may sometimes fail to find an apparent horizon even when one exists in the slice.)
11 Algorithms and Codes for Finding Apparent Horizons
Many researchers have studied the apparent horizon finding problem, and there are a large number of different apparent horizon finding algorithms and codes. Almost all of these require (assume) that any apparent horizon to be found is a Strahlkörper (Section 2) about some local coordinate origin; both finitedifference and spectral parameterizations of the Strahlkörper are common.

ZeroFinding in Spherical Symmetry (Section 8.1)
In spherical symmetry the apparent horizon equation (16) becomes a 1dimensional nonlinear algebraic equation, which can be solved by zerofinding.

The Shooting Algorithm in Axisymmetry (Section 8.2)
In axisymmetry the apparent horizon equation (16) becomes a nonlinear 2point boundary value ODE, which can be solved by a shooting algorithm.
Alternatively, all the algorithms described below for generic slices are also applicable to axisymmetric slices and can take advantage of the axisymmetry to simplify the implementation and boost performance.

Minimization Algorithms (Section 8.3)
These algorithms define a scalar norm on Θ over the space of possible trial surfaces. A generalpurpose scalarfunctionminimization routine is then used to search trialsurfaceshape space for a minimum of this norm (which should give Θ = 0).

Spectral IntegralIteration Algorithms (Section 8.4)
These algorithms expand the (Strahlkörper) apparent horizon shape function in a sphericalharmonic basis, use the orthogonality of spherical harmonics to write the apparent horizon equation as a set of integral equations for the spectral coefficients, and solve these equations using a functionaliteration algorithm.

EllipticPDE Algorithms (Section 8.5)
These algorithms write the apparent horizon equation (16) as a nonlinear elliptic (boundaryvalue) PDE for the horizon shape and solve this PDE using (typically) standard ellipticPDE numerical algorithms.

Horizon Pretracking (Section 8.6)
Horizon pretracking solves a slightly more general problem than apparent horizon finding: Roughly speaking, the determination of the smallest E ≥ 0 such that the equation Θ = E has a solution, and the determination of that solution. By monitoring the time evolution of E and of the surfaces satisfying this condition, we can determine — before it appears — approximately where (in space) and when (in time) a new MOTS will appear in a dynamic numericallyevolving spacetime. Horizon pretracking is implemented as a 1dimensional (binary) search using a slightlymodified ellipticPDE apparent horizon finding algorithm as a “subroutine”.

Flow Algorithms (Section 8.7)
These algorithms start with a large 2surface (larger than any possible apparent horizon in the slice) and shrink it inwards using an algorithm which ensures that the surface will stop shrinking when it coincides with the apparent horizon.
I describe the major algorithms and codes in these categories in detail in the following.
11.1 Zerofinding in spherical symmetry
11.2 The shooting algorithm in axisymmetry
 1.
Guess the value of h at one endpoint, say h(θ=0) ≡ h_{*}.
 2.
Use this guessed value of h(θ=0) together with the boundary condition (19) there as initial data to integrate (“shoot”) the ODE (18) from θ=0 to the other endpoint θ=θ_{max}. This can be done easily and efficiently using one of the ODE codes described in Appendix B.
 3.
If the numerically computed solution satisfies the other boundary condition (19) at θ=θ_{max} to within some tolerance, then the justcomputed h(θ) describes the (an) apparent horizon, and the algorithm is finished.
 4.
Otherwise, adjust the guessed value h(θ=θ) ≡ h_{*} and try again. Because there is only a single parameter (h_{*}) to be adjusted, this can be done using one of the 1dimensional zerofinding algorithms discussed in Appendix A.
This algorithm is fairly efficient and easy to program. By trying a sufficiently wide range of initial guesses h_{*} this algorithm can give a high degree of confidence that all apparent horizons have been located, although this, of course, increases the cost.
Shooting algorithms of this type have been used by many researchers, for example [159, 66, 2, 29, 30, 145, 3, 4].
11.3 Minimization algorithms
Assuming the horizon surface to be a Strahlkörper and adopting the spectral representation (5) for the horizon surface, we can view the norm (20) as being defined on the space of spectral coefficients {a_{ℓm}}.
This norm clearly has a global minimum ‖Θ‖ = 0 for each solution of the apparent horizon equation (16). To find the apparent horizon we numerically search the spectralcoefficient space for this (a) minimum, using a generalpurpose “functionminimization” algorithm (code) such as Powell’s algorithm^{32}.
Evaluating the norm (20) requires a numerical integration over the horizon surface: We choose some grid of N_{ang} points on the surface, interpolate the slice geometry fields (g_{ij}, ∂_{k}g_{ij}, and K_{ij}) to this grid (see Section 7.5), and use numerical quadrature to approximate the integral. In practice this must be done for many different trial surface shapes (see Section 8.3.2), so it is important that it be as efficient as possible. Anninos et al. [8] and Baumgarte et al. [26] discuss various ways to optimize and/or parallelize this calculation.
Unfortunately, minimization algorithms have two serious disadvantages for apparent horizon finding: They can be susceptible to spurious local minima, and they’re very slow at high angular resolutions. However, for the (fairly common) case where we want to find a common apparent horizon as soon as it appears in a binary blackhole (or neutronstar) simulation, minimization algorithms do have a useful ability to “anticipate” the formation of the common apparent horizon, in a manner similar to the pretracking algorithms discussed in Section 8.6. I discuss the properties of minimization algorithms further in the following.
11.3.1 Spurious local minima
While the norm (20) clearly has a single global minimum ‖Θ‖ = 0 for each MOTS Θ = 0, it typically also has a large number of other local minima with Θ ≠ 0, which are “spurious” in the sense that they do not correspond (even approximately) to MOTSs^{33}. Unfortunately, generalpurpose “functionminimization” routines only locate local minima and, thus, may easily converge to one of the spurious Θ ≠ 0 minima.
What this problem means in practice is that a minimization algorithm needs quite a good (accurate) initial guess for the horizon shape in order to ensure that the algorithm converges to the true global minimum Θ = 0 rather than to one of the spurious Θ ≠ 0 local minima.
To view this problem from a different perspective, once the functionminimization algorithm does converge, we must somehow determine whether the “solution” found is the true one, Θ = 0, or a spurious one, Θ ≠ 0. Due to numerical errors in the geometry interpolation and the evaluation of the integral (20), ‖Θ‖ will almost never evaluate to exactly zero; rather, we must set a tolerance level for how large ‖Θ‖ may be. Unfortunately, in practice it is hard to choose this tolerance: If it is too small, the genuine solution may be falsely rejected, while if it is too large, we may accept a spurious solution (which may be very different from any of the true solutions).
Anninos et al. [8] and Baumgarte et al. [26] suggest screening out spurious solutions by repeating the algorithm with varying resolutions of the horizonsurface grid and checking that O shows the proper convergence towards zero. This seems like a good strategy, but it is tricky to automate and, again, it may be difficult to choose the necessary error tolerances in advance.

The underlying spectral solution can inherently be “interpolated” (evaluated at arbitrary positions) to very high accuracy.

Pfeiffer et al. use a large number of quadrature points (typically an order of magnitude larger than the number of coefficients in the expansion (5)) in numerically evaluating the integral (20).
11.3.2 Performance
For convenience of exposition, suppose the spectral representation (5) of the horizonshape function h uses spherical harmonics Y_{ℓm}. (Symmetric tracefree tensors or other basis sets do not change the argument in any important way.) If we keep harmonics up to some maximum degree ℓ_{max}, the number of coefficients is then N_{coeff} = (ℓ_{max}+1)^{2}. ℓ_{max} is set by the desired accuracy (angular resolution) of the algorithm and is typically on the order of 6 to 12.
To find a minimum in an N_{coeff}dimensional space (here the space of surfaceshape coefficients {a_{ℓm}}), a generalpurpose functionminimization algorithm typically needs on the order of \(5N_{{\rm{coeff}}}^2\) to \(10N_{{\rm{coeff}}}^2\) iterations^{34}. Thus the number of iterations grows as \(\ell _{\max}^4\).
Each iteration requires an evaluation of the norm (20) for some trial set of surfaceshape coefficients {a_{ℓm}}, which requires \({\mathcal O}({N_{{\rm{coeff}}}}) = {\mathcal O}(\ell _{\max}^2)\) work to compute the surface positions, together with \({\mathcal O}({N_{{\rm{ang}}}})\) work to interpolate the geometry fields to the surface points and compute the numerical quadrature of the integral (20).
Thus the total work for a single horizon finding is \({\mathcal O}(\ell _{\max}^6 + {N_{{\rm{ang}}}}\ell _{max}^4)\). Fortunately, the accuracy with which the horizon is found generally improves rapidly with ℓ_{max}, sometimes even exponentially^{35}. Thus, relatively modest values of ℓ_{max} (typically in the range 8–12) generally suffice for adequate accuracy. Even so, minimization horizon finders tend to be slower than other methods, particularly if high accuracy is required (large ℓ_{max} and N_{ang}). The one exception is in axisymmetry, where only spherical harmonics Y_{ℓm} with m=0 need be considered. In this case minimization algorithms are much faster, though probably still slower than shooting or ellipticPDE algorithms.
11.3.3 Anticipating the formation of a common apparent horizon
Consider the case where we want to find a common apparent horizon as soon as it appears in a binary blackhole (or neutronstar) simulation. In Section 8.6 I discuss “horizon pretracking” algorithms which can determine — before it appears — approximately where (in space) and when (in time) the common apparent horizon will appear.
Minimization algorithms can provide a similar functionality: Before the common apparent horizon forms, trying to find it via a minimization algorithm will (hopefully) find the (a) surface which minimizes the error norm ∥Θ∥ (defined by Equation (20)). This surface can be viewed as the current slice’s closest approximation to a common apparent horizon, and as the evolution proceeds, it should converge to the actual common apparent horizon.
However, it is not clear whether minimization algorithms used in this way suffer from the problems discussed in Section 8.6.2. In particular, it is not clear whether, in a realistic binarycoalescence simulation, the minimum∥Θ∥ surfaces would remain smooth enough to be represented accurately with a reasonable ℓ_{max}.
11.3.4 Summary of minimization algorithms/codes
Minimization algorithms are fairly easy to program and have been used by many researchers, for example [43, 69, 102, 8, 26, 4]. However, at least when the underlying simulation uses finite differencing, minimization algorithms are susceptible to spurious local minima, have relatively poor accuracy, and tend to be quite slow. I believe that the other algorithms discussed in the following sections are generally preferable. If the underlying simulation uses spectral methods, then minimization algorithms may be (relatively) somewhat more efficient and robust.
Alcubierre’s apparent horizon finder AHFinder [4] includes a minimization algorithm based on the work of Anninos et al. [8]^{36}. It is implemented as a freely available module (“thorn”) in the Cactus computational toolkit (see Table 2).
11.4 Spectral integraliteration algorithms
Nakamura, Kojima, and Oohara [113] developed a functionaliteration spectral algorithm for solving the apparent horizon equation (16).
 1.
Start with some (initialguess) set of horizonshape coefficients {a_{ℓm}}. These determine a surface shape via Equation (5).
 2.
Interpolate the geometry variables to this surface shape (see Section 7.5).
 3.
For each ℓ and m except ℓ = m = 0, evaluate the integral (22) by numerical quadrature to obtain a nextiteration coefficient a_{ℓm}.
 4.Determine a nextiteration coefficient a_{00} by numerically solving (finding a root of) the equationThis can be done using any of the 1dimensional zerofinding algorithms discussed in Appendix A.$$\int {Y_{00}^{\ast}G\;d\Omega = 0.}$$(23)
 5.
Iterate until all the coefficients {a_{ℓm}} converge.
Gundlach [80] observed that the subtraction and inversion of the flatspace angular Laplacian operator in this algorithm is actually a standard technique for solving nonlinear elliptic PDEs by spectral methods. I discuss this observation and its implications further in Section 8.7.4.
Nakamura, Kojima, and Oohara [113] report that their algorithm works well, but Nakao (cited as personal communication in [146]) has argued that it tends to become inefficient (and possibly inaccurate) for large ℓ (high angular resolution) because the Y_{ℓm} fail to be numerically orthogonal due to the finite resolution of the numerical grid. I know of no other published work addressing Nakao’s criticism.
11.4.1 Kemball and Bishop’s modifications of the NakamuraKojimaOohara algorithm
Kemball and Bishop [93] investigated the behavior of the NakamuraKojimaOohara algorithm and found that its (only) major weakness seems to be that the a_{00}update equation (23) “may have multiple roots or minima even in the presence of a single marginally outer trapped surface, and all should be tried for convergence”.
Kemball and Bishop [93] suggested and tested several modifications to improve the algorithm’s convergence behavior. They verified that (either in its original form or with their modifications) the algorithm’s rate of convergence (number of iterations to reach a given error level) is roughly independent of the degree ℓ_{max} of sphericalharmonic expansion used. They also give an analysis that the algorithm’s cost is \({\mathcal O}(\ell _{\max}^4)\), and its accuracy \(\varepsilon = {\mathcal O}(1/{\ell _{\max}})\), i.e. the cost is \({\mathcal O}(1/{\varepsilon ^4})\). This accuracy is surprisingly low: Exponential convergence with ℓ_{max} is typical of spectral algorithms and would be expected here. I do not know of any published work which addresses this discrepancy.
11.4.2 Lin and Novak’s variant of the NakamuraKojimaOohara algorithm
Lin and Novak [104] find that this algorithm gives robust convergence and is quite fast, particularly at modest accuracy levels. For example, running on a 2 GHz processor, their implementation takes 3.1, 5.8, 17, 88, and 313 seconds to find the apparent horizon in a test slice to a relative error (measured in the horizon area) of 9 × 10^{−4}, 5 × 10^{−5}, 6 × 10^{−7}, 9 × 10^{−10}, and 3 × 10^{−12} respectively^{37}. This implementation is freely available as part of the Lorene toolkit for spectral computations in numerical relativity (see Table 2).
11.4.3 Summary of spectral integraliteration algorithms
Despite what appears to be fairly good numerical behavior and reasonable ease of implementation, the original NakamuraKojimaOohara algorithm has not been widely used apart from later work by its original developers (see, for example, [115, 114]). Kemball and Bishop [93] have proposed and tested several modifications to the basic NakamuraKojimaOohara algorithm. Lin and Novak [104] have develped a variant of the NakamuraKojimaOohara algorithm which avoids the need for a separate search for the a_{00} coefficient at each iteration. Their implementation of this variant is freely available as part of the Lorene toolkit for spectral computations in numerical relativity (see Table 2).
11.5 EllipticPDE algorithms
The basic concept of ellipticPDE algorithms is simple: We view the apparent horizon equation (16) as a nonlinear elliptic PDE for the horizon shape function h on the angularcoordinate space and solve this equation by standard finitedifferencing techniques^{38}, generally using Newton’s method to solve the resulting set of nonlinear algebraic (finitedifference) equations. Algorithms of this type have been widely used both in axisymmetry and in fully generic slices.
11.5.1 Angular coordinates, grid, and boundary conditions
In more detail, ellipticPDE algorithms assume that the horizon is a Strahlkörper about some local coordinate origin, and choose an angular coordinate system and a finitedifference grid of N_{ang} points on S^{2} in the manner discussed in Section 2.2.
The most common choices are the usual polarspherical coordinates (θ, ϕ) and a uniform “latitude/longitude” grid in these coordinates. Since these coordinates are “unwrapped” relative to the actual S^{2} trialhorizonsurface topology, the horizon shape function h satisfies periodic boundary conditions across the artificial grid boundary at ϕ = 0 and ϕ = 2π. The north and south poles θ = 0 and θ = π are trickier, but Huq et al. [89, 90], Shibata and Uryū [147], and Schnetter [132, 133]^{39} “reaching across the pole” boundary conditions for these artificial grid boundaries.
Alternatively, Thornburg [156] avoids the z axis coordinate singularity of polarspherical coordinates by using an “inflatedcube” system of six angular patches to cover S^{2}. Here each patch’s nominal grid is surrounded by a “ghost zone” of additional grid points where h is determined by interpolation from the neighboring patches. The interpatch interpolation thus serves to tie the patches together, enforcing the continuity and differentiability of h across patch boundaries. Thornburg reports that this scheme works well but was quite complicated to program.
Overall, the latitude/longitude grid seems to be the superior choice: it works well, is simple to program, and eases interoperation with other software.
11.5.2 Evaluating the expansion Θ
The next step in the algorithm is to evaluate the expansion Θ given by Equation (16) on the angular grid given a trial horizon surface shape function h on this same grid (6).
Most researchers compute Θ via 2dimensional angular finite differencing of Equation (16) on the trial horizon surface. 2nd order angular finite differencing is most common, but Thornburg [156] uses 4th order angular finite differencing for increased accuracy.
With a (θ, ϕ) latitude/longitude grid the Θ(h, ∂_{u}h, ∂_{uv}h) function in Equation (16) is singular on the z axis (at the north and south poles θ = 0 and θ = π) but can be regularized by applying L’Hôpital’s rule. Schnetter [132, 133] observes that using a Cartesian basis for all tensors greatly aids in this regularization.
 1.
They observe that the scalar field F defined by Equation (7) can be evaluated at any (3dimensional) position in the slice by computing the corresponding (r, θ, ϕ) using the usual flatspace formulas, then interpolating h in the 2dimensional (θ, ϕ) surface grid.
 2.Rewrite the apparent horizon condition (15) in terms of F and its (3dimensional) Cartesian derivatives,$$\Theta \equiv \Theta (F,{\partial _i}F,{\partial _{ij}}F;{g_{ij}},{\partial _k}{g_{ij}},{K_{ij}}) = 0.$$(27)
 3.
For each (latitude/longitude) grid point on the trial horizon surface, define a 3×3×3point local Cartesian grid centered at that point. The spacing of this grid should be such as to allow accurate finite differencing, i.e. in practice it should probably be roughly comparable to that of the underlying numericalrelativity simulation’s grid.
 4.
Evaluate F on the local Cartesian grid as described in Step 1 above.
 5.
Evaluate the Cartesian derivatives in Equation (27) by centered 2nd order Cartesian finite differencing of the F values on the local Cartesian grid.
Comparing the different ways of evaluating Θ, 2dimensional angular finite differencing of Equation (16) seems to me to be both simpler (easier to program) and likely more efficient than 3dimensional Cartesian finite differencing of Equation (27).
11.5.3 Solving the nonlinear elliptic PDE
A variety of algorithms are possible for actually solving the nonlinear elliptic PDE (16) (or (27) for the Huq et al. [89, 90] horizon finder).
The most common choice is to use some variant of Newton’s method. That is, finite differencing Equation (16) or (27) (as appropriate) gives a system of N_{ang} nonlinear algebraic equations for the horizon shape function h at the N_{ang} angular grid points; these can be solved by Newton’s method in N_{ang} dimensions. (As explained by Thornburg [153, Section VIII.C], this is usually equivalent to applying the NewtonKantorovich algorithm [37, Appendix C] to the original nonlinear elliptic PDE (16) or (27).)
Newton’s method converges very quickly once the trial horizon surface is sufficiently close to a solution (a MOTS). However, for a less accurate initial guess, Newton’s method may converge very slowly or even fail to converge at all. There is no usable way of determining a priori just how large the radius of convergence of the iteration will be, but in practice \({1 \over 4} \ {\rm to} \ {1 \over 3}\) of the horizon radius is often a reasonable estimate^{40}.
Thornburg [153] described the use of various “line search” modifications to Newton’s method to improve its radius and robustness of convergence, and reported that even fairly simple modifications of this sort roughly doubled the radius of convergence.
Schnetter [132, 133] used the PETSc generalpurpose ellipticsolver library [22, 23, 24] to solve the equations. This offers a wide variety of Newtonlike algorithms already implemented in a highly optimized form.
Rather than Newton’s method or one of its variants, Shibata et al. [146, 147] use a functionaliteration algorithm directly on the nonlinear elliptic PDE (16). This seems likely to be less efficient than Newton’s method but avoids having to compute and manipulate the Jacobian matrix.
11.5.4 The Jacobian matrix
Notice that J includes contributions both from the direct dependence of Θ on h, ∂_{u}h, and ∂_{uv}h, and also from the indirect dependence of Θ on h through the positiondependence of the geometry variables g_{ij}, ∂_{k}g_{ij}, and K_{ij} (since Θ depends on the geometry variables at the horizon surface position, and this position is determined by h). Thornburg [153] discusses this indirect dependence in detail.

Numerical Perturbation:
The simplest way to determine the Jacobian matrix is by “numerical perturbation”, where for each horizonsurface grid point j, h is perturbed by some (small) amount ε at the _{J} th grid point (that is, h_{I} → h_{I} + εδ_{IJ}), and the expansion Θ is recomputed^{41}. The _{J} th column of the Jacobian matrix (28) is then estimated asCurtis and Reid [53], and Stoer and Bulirsch [150, Section 5.4.3] discuss the optimum choice of ε in this algorithm^{42}.$${{\bf{J}}_{{\rm{IJ}}}} \approx {{{\Theta _{\rm{I}}}(h + \varepsilon {\delta _{{\rm{IJ}}}}){\Theta _{\rm{I}}}(h)} \over \varepsilon}.$$(29)This algorithm is easy to program but somewhat inefficient. It is used by a number of researchers including Schnetter [132, 133], and Huq et al. [89, 90].

Symbolic Differentiation:
A more efficient, although somewhat more complicated, way to determine the Jacobian matrix is the “symbolic differentiation” algorithm described by Thornburg [153] and also used by Pasch [118], Shibata et al. [146, 147], and Thornburg [156]. Here the internal structure of the finite differenced Θ(h) function is used to directly determine the Jacobian matrix elements.
This algorithm is best illustrated by an example which is simpler than the full apparent horizon equation: Consider the flatspace Laplacian in standard (θ, ϕ) polarspherical coordinates,$$\Delta h \equiv {\partial _{\theta \theta}}h + {{{\partial _\theta}h} \over {\tan \theta}} + {{{\partial _{\phi \phi}}h} \over {{{\sin}^2}\theta}}.$$(30)Suppose we discretize this with centered 2nd order finite differences in θ and ϕ. Then neglecting finitedifferencing truncation errors, and temporarily adopting the usual notation for 2dimensional grid functions, h_{i, j} = h(θ=θ_{i}, ϕ=ϕ_{j}), our discrete approximation to Δh is given by$${(\Delta h)_{i,j}} = {{{h_{i  1,j}}  2{h_{i,j}} + {h_{i + 1,j}}} \over {{{(\Delta \theta)}^2}}} + {1 \over {\tan \theta}}{{{h_{i + 1,j}}  {h_{i + 1,j}}  {h_{i  1,j}}} \over {2\Delta \theta}} + {1 \over {{{\sin}^2}\theta}}{{{h_{i,j  1}}  2{h_{i,j}} + {h_{i,j + 1}}} \over {{{(\Delta \phi)}^2}}}.$$(31)The Jacobian of Δh is thus given by$${{\partial {{(\Delta h)}_{(i,j)}}} \over {\partial {h_{(k,\ell)}}}} = \left\{{\begin{array}{*{20}c} {{1 \over {{{(\Delta \theta)}^2}}} \pm {1 \over {2\tan \theta \Delta \theta}}} & {{\rm{if}}\;(k,\ell) = (i \pm 1,j),} \\ {{1 \over {{{\sin}^2}\theta {{(\Delta \phi)}^2}}}} & {{\rm{if}}\;(k,\ell) = (i \pm 1,j),} \\ { {2 \over {{{(\Delta \theta)}^2}}}  {2 \over {{{\sin}^2}\theta {{(\Delta \phi)}^2}}}} & {{\rm{if}}\;(k,\ell) = (i,j),} \\ 0 & {{\rm{otherwise}}.} \\ \end{array}} \right.$$(32)Thornburg [153] describes how to generalize this to nonlinear differential operators without having to explicitly manipulate the nonlinear finite difference equations.
11.5.5 Solving the linear equations
All the algorithms described in Section 8.5.3 for treating nonlinear elliptic PDEs require solving a sequence of linear systems of N_{ang} equations in N_{ang} unknowns. N_{ang} is typically on the order of a few thousand, and the Jacobian matrices in question are sparse due to the locality of the angular finite differencing (see Section 8.5.4). Thus, for reasonable efficiency, it is essential to use linear solvers that exploit this sparsity. Unfortunately, many such algorithms/codes only handle symmetric positivedefinite matrices while, due to the angular boundary conditions^{43} (see Section 8.5.1), the Jacobian matrices that arise in apparent horizon finding are generally neither of these.
The numerical solution of large sparse linear systems is a whole subfield of numerical analysis. See, for example, Duff, Erisman, and Reid [65], and Saad [130] for extensive discussions^{44}. In practice, a numerical relativist is unlikely to write her own linear solver but, rather, will use an existing subroutine (library).
Kershaw’s [94] ILUCG iterative solver is often used; this is only moderately efficient, but is quite easy to program^{45}. Schnetter [132, 133] reports good results with an ILUpreconditioned GMRES solver from the PETSc library. Thornburg [156] experimented with both an ILUCG solver and a direct sparse LU decomposition solver (Davis’ UMFPACK library [57, 58, 56, 55, 54]), and found each to be more efficient in some situations; overall, he found the UMFPACK solver to be the best choice.
11.5.6 Sample results
As a final example, Figure 8 shows the numericallycomputed event and apparent horizons in the collapse of a rapidly rotating neutron star to a Kerr black hole. (The event horizons were computed using the EHFinder code described in Section 5.3.3.)
11.5.7 Summary of ellipticPDE algorithms/codes
EllipticPDE apparent horizon finders have been developed by many researchers, including Eardley [67]^{47}, Cook [50, 52, 51], and Thornburg [153] in axisymmetry, and Shibata et al. [146, 147], Huq et al. [89, 90], Schnetter [132, 133], and Thornburg [156] in fully generic slices.
EllipticPDE algorithms are (or can be implemented to be) among the fastest horizon finding algorithms. For example, running on a 1.7 GHz processor, Thornburg’s AHFinderDirect [156] averaged 1.7 s per horizon finding, as compared with 61 s for an alternate “fastflow” apparent horizon finder AHFinder (discussed in more detail in Section 8.7)^{48}. However, achieving maximum performance comes at some cost in implementation effort (e.g. the “symbolic differentiation” Jacobian computation discussed in Section 8.5.4).
EllipticPDE algorithms are probably somewhat more robust in their convergence (i.e. they have a slightly larger radius of convergence) than other types of local algorithms, particularly if the “line search” modifications of Newton’s method described by Thornburg [153] are implemented^{49}. Their typical radius of convergence is on the order of \({1 \over 3}\) of the horizon radius, but cases are known where it is much smaller. For example, Schnetter, Herrmann, and Pollney [135] report that (with no “line search” modifications) it is only about 10% for some slices in a binary black hole coalescence simulation.
Schnetter’s TGRapparentHorizon2D [132, 133] and Thornburg’s AHFinderDirect [156] are both ellipticPDE apparent horizon finders implemented as freely available modules (“thorns”) in the Cactus computational toolkit (see Table 2). Both work with either the PUGH unigrid driver or the Carpet meshrefinement driver for Cactus. TGRapparentHorizon2D is no longer maintained, but AHFinderDirect is actively supported and is now used by many different research groups^{50}.
11.6 Horizon pretracking
The common [apparent] horizon […] appears instantaneously at some late time and without a previous good guess for its location. In practice, an estimate of the surface location and shape can be put in by hand. The quality of this guess will determine the rate of convergence of the finder and, more seriously, also determines whether a horizon is found at all. Gauge effects in the strong field region can induce distortions that have a large influence on the shape of the common horizon, making them difficult to predict, particularly after a long evolution using dynamical coordinate conditions. As such, it can be a matter of some expensive trial and error to find the common apparent horizon at the earliest possible time. Further, if a common apparent horizon is not found, it is not clear whether this is because there is none, or whether there exists one which has only been missed due to unsuitable initial guesses — for a fast apparent horizon finder, a good initial guess is crucial.
Pretracking tries (usually successfully) to eliminate these difficulties by determining — before it appears — approximately where (in space) and when (in time) the common apparent horizon will appear.
11.6.1 Constantexpansion surfaces
In the binarycoalescence context, for each t = constant slice we define E_{*} to be the smallest E ≥ 0 for which a CE surface (containing both strongfield regions) exists with expansion E. If E_{*} = 0 this “minimumexpansion CE surface” is the common apparent horizon, while if E_{*} > 0 this surface is an approximation to where the common apparent horizon will appear. We expect the minimumexpansion CE surface to change continuously during the evolution and its expansion E_{*} to decrease towards 0. Essentially, horizon pretracking follows the time evolution of the minimumexpansion CE surface and uses it as an initial guess for (searching for) the common apparent horizon.
11.6.2 Generalized constantexpansion surfaces

While the expansion is zero for a common apparent horizon, it is also zero for a 2sphere at spatial infinity. Figure 12 illustrates this for Schwarzschild spacetime. Notice that for small positive E_{*} there will generally be two distinct CE surfaces with E = E_{*}, an inner surface just outside the horizon and an outer one far out in the weakfield region. The inner CE surface converges to the common apparent horizon as E_{*} decreases towards 0; this surface is the one we would like the pretracking algorithm to follow. Unfortunately, without measures such as those described below, there is nothing to prevent the algorithm from following the outer surface, which does not converge to the common apparent horizon as E_{*} decreases towards 0.

In a realistic binarycoalescence simulation, the actual minimumexpansion CE surface may be highly distorted and, thus, hard to represent accurately with a finiteresolution angular grid.
Note that unlike H_{1}, both H_{r} and H_{r}2 are typically monotonic with radius. Neither H_{r} nor H_{r}2 are 3covariantly defined, but they both still have the property that E = 0 in Equation (35) implies the surface is a MOTS, and in practice they work better for horizon pretracking.
11.6.3 Goal functions
11.6.4 The pretracking search
Schnetter’s [133] original implementation of horizon pretracking (which followed the evolution of the minimumexpansion CE surface) used a binary search on the desired expansion E. Because E appears only on the right hand side of the generalized CE condition (35), it is trivial to modify any apparent horizon finder to search for a surface of specified expansion E. (Schnetter used his TGRapparentHorizon2D ellipticPDE apparent horizon finder described in Section 8.5.7 for this.) A binary search on E can then be used to find the minimum value E_{*}.^{52}
Because \({\bar H}\) depends on H at all surface points, directly finite differencing Equation (37) would give a nonsparse Jacobian matrix, which would greatly slow the linearsolver phase of the ellipticPDE apparent horizon finder (Section 8.5.5). Schnetter et al. [135, Section III.B] show how this problem can be solved by introducing a single extra unknown into the discrete system. This gives a Jacobian which has a single nonsparse row and column, but is otherwise sparse, so the linear equations can still be solved efficiently.
When doing the pretracking search, the cost of a single binarysearch iteration is approximately the same as that of finding an apparent horizon. Schnetter et al. [135, Figure 5] report that their pretracking implementation (a modified version of Thornburg’s AHFinderDirect [156] ellipticPDE apparent horizon finder described in Section 8.5.7) typically takes on the order of 5 to 10 binarysearch iterations^{54}. The cost of pretracking is thus on the order of 5 to 10 times that of finding a single apparent horizon. This is substantial, but not prohibitive, particularly if the pretracking algorithm is not run at every time step.
11.6.5 Sample results
11.6.6 Summary of horizon pretracking
Pretracking is a very valuable addition to the horizon finding repertoire: It essentially gives a local algorithm (in this case, an ellipticPDE algorithm) most of the robustness of a global algorithm in terms of finding a common apparent horizon as soon as it appears. It is implemented as a higherlevel algorithm which uses a slightlymodified ellipticPDE apparent horizon finding algorithm as a “subroutine”.
The one significant disadvantage of pretracking is its cost: Each pretracking search typically takes 5 to 10 times as long as finding an apparent horizon. Further research to reduce the cost of pretracking would be useful.
Schnetter et al.’s pretracking implementation [135] is implemented as a set of modifications to Thornburg’s AHFinderDirect [156] apparent horizon finder. Like the original AHFinderDirect, the modified version is a freely available “thorn” in the Cactus toolkit (see Table 2).
11.7 Flow algorithms
Flow algorithms define a “flow” on 2surfaces, i.e. they define an evolution of 2surfaces in some pseudotime λ, such that the apparent horizon is the λ → ∞ limit of a (any) suitable starting surface. Flow algorithms are different from other apparent horizon finding algorithms (except for zerofinding in spherical symmetry) in that their convergence does not depend on having a good initial guess. In other words, flow algorithms are global algorithms (Section 7.7).
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 2sphere of areal radius substantially greater than 2 m_{adm}.
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 previouslyfound apparent horizon as an initial guess, greatly speeding the algorithm’s convergence^{55}).

The expansion flow is identical to the mean curvature flow (38) in the principal part.

The expansion flow’s velocity is clearly zero on an apparent horizon.

More generally, a simple argument due to Bartnik [25]^{56} shows that the expansion flow can never move a (smooth) test surface through an apparent horizon. Suppose, to the contrary, that the test surface \({\mathcal T}\) is about to move through an apparent horizon \({\mathcal H}\), i.e. since both surfaces are by assumption smooth, that \({\mathcal T}\) and \({\mathcal H}\) touch at single (isolated) point P. At that point, \({\mathcal T}\) and \({\mathcal H}\) obviously have the same gij and K_{ij}, and they also have the same s^{i} (because P is isolated). Hence the only term in Θ (as defined by Equation (15)) which differs between \({\mathcal T}\) and \({\mathcal H}\) is ∇_{i}s^{i}. Clearly, if \({\mathcal T}\) is outside \({\mathcal H}\) and they touch at the single isolated point P, then relative to \({\mathcal H},{\mathcal T}\) must be concave outwards at P, so that \({\nabla _i}{s^i}({\mathcal T}) < {\nabla _i}{s^i}({\mathcal H})\). Thus the expansion flow (39) will move \({\mathcal T}\) outwards, away from the apparent horizon. (If \({\mathcal T}\) lies inside \({\mathcal H}\) the same argument holds with signs reversed appropriately.)
Numerical experiments by Bernstein [28], Shoemaker et al. [148, 149], and Pasch [118] 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.
11.7.1 Implicit pseudotime stepping
Assuming the Strahlkörper surface parameterization (4), the expansion flow (39) is a parabolic equation for the horizon shape function h.^{57} This means that any fully explicit scheme to integrate it (in the pseudotime λ) must severely restrict its pseudotime step Δλ for stability, and this restriction grows (quadratically) worse at higher spatial resolutions^{58}. This makes the horizon finding process very slow.
To avoid this restriction, practical implementations of flow algorithms use implicit pseudotime integration schemes; these can have large pseudotime steps and still be stable. Because we only care about the λ → ∞ limit, a highly accurate pseudotime integration is not important; only the accuracy of approximating the spatial derivatives matters. Bernstein [28] used a modified Du FortFrankel scheme [64]^{59} but found some problems with the surface shape gradually developing highspatialfrequency noise. Pasch [118] reports that an “exponential” integrator (Hochbrucket al. [85]) works well, provided the flow’s Jacobian matrix is computed accurately^{60}. The most common choice is probably that of Shoemaker et al. [148, 149], who use the iterated CrankNicholson (“ICN”) scheme^{61}. They report that this works very well; in particular, they do not report any noise problems.
By refining his finiteelement grid (Section 2.3) in a hierarchical manner, Metzger [109] is able to use standard conjugategradient elliptic solvers in a multigridlike fashion^{62}, 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 surfacefinding algorithm is “of the same order of magnitude” as that of Thornburg’s AHFinderDirect [156] ellipticPDE apparent horizon finder (described in Section 8.5.7).
In a more general context than numerical relativity, Osher and Sethian [116] have discussed a general class of numerical algorithms for integrating “fronts propagating with curvaturedependent speed”. These flow a levelset function (Section 2.1) which implicitly locates the actual “front”.
11.7.2 Varying the flow speed
11.7.3 Surface representation and the handling of bifurcations
Since a flow algorithm starts with (topologically) a single large 2sphere, 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 [118] and Shoemaker et al. [148, 149] use a levelset 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 [109] uses a finiteelement 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 selfintersects, which may be expensive.
11.7.4 Gundlach’s “fast flow”
Gundlach [80] introduced the important concept of a “fast flow”. He observed that the subtraction and inversion of the flatspace Laplacian in the NakamuraKojimaOohara spectral integraliteration 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 pseudospectral algorithms and iterating”. Gundlach then interpreted the NakamuraKojimaOohara algorithm as a type of flow algorithm where each pseudotime step of the flow corresponds to a single functionaliteration step of the NakamuraKojimaOohara algorithm.
Alcubierre’s AHFinder [4] horizon finder includes an implementation of Gundlach’s fast flow algorithm^{63}. 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.
11.7.5 Summary of flow algorithms/codes
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 timesymmetric slices.
In the forms which have strong convergence guarantees, flow algorithms tend to be very slow. (Metzger’s algorithm [109] 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. [5], Diener et al. [62]), “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 [4] includes a “fast flow” algorithm based on the work of Gundlach [80]^{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.
12 Summary of Algorithms/Codes for Finding Apparent Horizons
There are many apparent horizon finding algorithms, with differing tradeoffs between speed, robustness of convergence, accuracy, and ease of programming.
In spherical symmetry, zerofinding (Section 8.1) is fast, robust, and easy to program. In axisymmetry, shooting algorithms (Section 8.2) work well and are fairly easy to program. Alternatively, any of the algorithms for generic slices (summarized below) can be used with implementations tailored to the axisymmetry.
Minimization algorithms (Section 8.3) are fairly easy to program, but when the underlying simulation uses finite differencing these algorithms are susceptible to spurious local minima, have relatively poor accuracy, and tend to be very slow unless axisymmetry is assumed. When the underlying simulation uses spectral methods, then minimization algorithms can be somewhat faster and more robust.
Spectral integraliteration algorithms (Section 8.4) and ellipticPDE algorithms (Section 8.5) are fast and accurate, but are moderately difficult to program. Their main disadvantage is the need for a fairly good initial guess for the horizon position/shape.
In many cases Schnetter’s “pretracking” algorithm (Section 8.6) can greatly improve an ellipticPDE algorithm’s robustness, by determining — before it appears — approximately where (in space) and when (in time) a new outermost apparent horizon will appear. Pretracking is implemented as a modification of an existing ellipticPDE algorithm and is moderately slow: It typically has a cost 5 to 10 times that of finding a single horizon with the ellipticPDE algorithm.
Finally, flow algorithms (Section 8.7) are generally quite slow (Metzger’s algorithm [109] is a notable exception) but can be very robust in their convergence. They are moderately easy to program. Flow algorithms are global algorithms, in that their convergence does not depend on having a good initial guess.
Table 2 lists freelyavailable apparent horizon finding codes.
Footnotes
 1.
An algorithm’s actual “convergence region” (the set of all initial guesses for which the algorithm converges to the correct solution) may even be fractal in shape. For example, the Julia set is the convergence region of Newton’s method on a simple nonlinear algebraic equation.
 2.
For convenience of exposition I use spherical harmonics here, but there are no essential differences if other basis sets are used.
 3.
I discuss the choice of this angular grid in more detail in Section 8.5.1.
 4.
There has been some controversy over whether, and if so how quickly, Regge calculus converges to the continuum Einstein equations. (See, for example, the debate between Brewin [40] and Miller [110], and the explicit convergence demonstration of Gentle and Miller [73].) However, Brewin and Gentle [41] seem to have resolved this: Regge calculus does, in fact, converge to the continuum solution, and this convergence is generically 2nd order in the resolution.
 5.
 6.
Chruściel and Galloway [49] showed that if a “cloud of sand” falls into a large black hole, each “sand grain” generates a nondifferentiable caustic in the event horizon.
 7.
This is a statement about the types of spacetimes usually studied by numerical relativists, not a statement about the mathematical properties of the event horizon itself.
 8.
I briefly review ODE integration algorithms and codes in Appendix B.
 9.
In practice the differentiation can usefully be combined with the interpolation; I outline how this can be done in Section 7.5.
 10.
This convergence is only true in a global sense: locally the event horizon has no special geometric properties, and the Riemann tensor components which govern geodesic convergence/divergence may have either sign.
 11.
Diener [60] describes how the algorithm can be enhanced to also determine (integrate) individual null generators of the event horizon. This requires interpolating the 4metric to the generator positions but (still) not taking any derivatives of the 4metric.
 12.
Walker [162] mentions an implementation for fully generic slices but only presents results for the axisymmetric case.
 13.
 14.
Equivalently, Diener [60] observed that the locus of any given nonzero value of the levelset function F is itself a null surface and tends to move (exponentially) closer and closer to the event horizon as the backwards evolution proceeds.
 15.
They describe how Richardson extrapolation can be used to improve the accuracy of the solutions from \({\mathcal O}(\varepsilon)\) to \({\mathcal O}({\varepsilon ^2})\), but it appears that this has not been done for their published results.
 16.
Note that the surface must be smooth everywhere. If this condition were not imposed, then MOTSs would lose many of their important properties. For example, even a standard t = constant slice of Minkowski spacetime contains many nonsmooth “MOTSs”: The surface of any closed polyhedron in such a slice satisfies all the other conditions to be an MOTS.
 17.
 18.
As an indication of the importance of the “closed” requirement, Hawking [81] observed that if we consider two spacelikeseparated events in Minkowski spacetime, the intersection of their backwards light cones satisfies all the conditions of the MOTS definition, except that it is not closed.
 19.
 20.
Wald and Iyer [161] proved this by explicitly constructing a family of angularly anisotropic slices in Schwarzschild spacetime which approach arbitrarily close to r = 0 yet contain no apparent horizons. However, Schnetter and Krishnan [136] have recently studied the behavior of apparent horizons in various anisotropic slices in Schwarzschild and Vaidya spacetimes, finding that the Wald and Iyer behavior seems to be rare.
 21.
This worldtube is sometimes called “the apparent horizon”, but this is not standard terminology. In this review I always use the terminology that an MOTS or apparent horizon is a 2surface contained in a (single) slice.
 22.
Ashtekar and Galloway [17] have recently proved “a number of physically interesting constraints” on this slicingdependence.
 23.
 24.
Notice that in order for the 3divergence in Equation (15) to be meaningful, s^{i} (defined only as a field on the MOTS) must be smoothly continued off the surface and extended to a field in some 3dimensional neighborhood of the surface. The offsurface continuation is nonunique, but it is easy to see that this does not affect the value of Θ on the surface.
 25.
 26.
If the underlying simulation uses spectral methods then the spectral series can be evaluated anywhere, so no actual interpolation need be done, although the term “spectral interpolation” is still often used. See Fornberg [70], Gottlieb and Orszag [75], and Boyd [37] for general discussions of spectral methods, and (for example) Ansorg et al. [12, 11, 10, 13], Bonazzola et al. [35, 33, 34], Grandclement et al. [77], Kidder et al. [95, 96, 97], and Pfeiffer et al. [120, 124, 123, 122] for applications to numerical relativity.
 27.
Conceptually, an interpolator generally works by locally fitting a fitting function (usually a lowdegree polynomial) to the data points in a neighborhood of the interpolation point, then evaluating the fitting function at the interpolation point. By evaluating the derivative of the fitting function, the ∂_{k}g_{ij} values can be obtained very cheaply at the same time as the g_{ij} values.
 28.
Thornburg [154, Appendix F] gives a more detailed discussion of the nonsmoothness of Lagrangepolynomial interpolation errors.
 29.
Note that ∂_{r}g_{θθ} is a known coefficient field here, not an unknown; if necessary, it can be obtained by numerically differentiating g_{θθ}. Therefore, despite the appearance of the derivative, Equation (17) is still an algebraic equation for the horizon radius h, not a differential equation.
 30.
See also the work of Bizoń, Malec, and Ó Murchadha [32] for an interesting analytical study giving necessary and sufficient conditions for apparent horizons to form in nonvacuum spherically symmetric spacetimes.
 31.
Ascher, Mattheij, and Russel [15, Chapter 4] give a more detailed discussion of shooting methods.
 32.
 33.
There is a simple heuristic argument (see, for example, Press et al. [125, Section 9.6]) that at least some spurious local minima should be expected. We are trying to solve a system of N_{ang} nonlinear equations, Θ_{I} = 0 (one equation for each horizonsurface grid point). Equivalently, we are trying to find the intersection of the N_{ang} codimensionone hypersurfaces Θ_{I} = 0 in surfaceshape space. The problem is that anywhere two or more of these hypersurfaces approach close to each other, but do not actually intersect, there is a spurious local minimum in ‖Θ‖.
 34.
A simple counting argument suffices to show that any generalpurpose functionminimization algorithm in n dimensions must involve at least \({\mathcal O}({n^2})\) function evaluations (see, for example, Press et al. [125, Section 10.6]): Suppose the function to be minimized is f: ℜ^{n} → ℜ, and suppose f has a local minimum near some point x_{0} ∈ ℜ^{n}. Taylorexpanding f in a neighborhood of x_{0} gives \(f(\times) = f({\times _0}) + {{\rm{a}}^T}(\times  {\times _0}) + {(\times  {\times _0})^T}{\rm{B(}} \times  {\times _0}) + {\mathcal O}(\Vert \times  {\times _0}{\Vert^3})\), where a ∈ ℜ^{n}, B ∈ ℜ^{n×n} is symmetric, and v^{T} denotes the transpose of the column vector v ∈ ℜ^{n}.
Neglecting the higher order terms (i.e. approximating f as a quadratic form in x in a neighborhood of x_{0}), and ignoring f(x_{0}) (which does not affect the position of the minimum), there are a total of \(N = n + {1 \over 2}n(n + 1)\) coefficients in this expression. Changing any of these coefficients may change the position of the minimum, and at each function evaluation the algorithm “learns” only a single number (the value of f at the selected evaluation point), so the algorithm must make at least \(N = {\mathcal O}({n^2})\) function evaluations to (implicitly) determine all the coefficients.
Actual functions are not exact quadratic forms, so in practice there are additional \({\mathcal O}(1)\) multiplicative factors in the number of function evaluations. Minimization algorithms may also make additional performance and/or spaceversustime tradeoffs to improve numerical robustness or to avoid explicitly manipulating n × n Jacobian matrices.
 35.
 36.
AHFinder also includes a “fast flow” algorithm (Section 8.7).
 37.
For comparison, the ellipticPDE AHFinderDirect horizon finder (discussed in Section 8.5.6), running on a roughly similar processor, takes about 1.8 seconds to find the apparent horizon in a similar test slice to a relative error of 4 × 10^{−4}.
 38.
In theory this equation could also be solved by a spectral method on using spectral differentiation to evaluate the angular derivatives. (See [70, 75, 37, 12, 11, 10, 13, 35, 33, 34, 77, 95, 96, 97, 120, 124, 123, 122] for further discussion of spectral methods.) This should yield a highly efficient apparent horizon finder. However, I know of no published work taking this approach.
 39.
 40.
Thornburg [153] used a MonteCarlo survey of horizonshape perturbations to quantify the radius of convergence of Newton’s method for apparent horizon finding. He found that if strong highspatialfrequency perturbations are present in the slice’s geometry then the radius of convergence may be very small. Fortunately, this problem rarely occurs in practice.
 41.
A very important optimization here is that Θ only needs to be recomputed within the finitedifference domain of dependence of the _{J} th grid point.
 42.
Because of the onesided finite differencing, the approximation (29) is only \({\mathcal O}(\varepsilon)\) accurate. However, in practice this does not seriously impair the convergence of a horizon finder, and the extra cost of a centeredfinitedifferencing \({\mathcal O}({\varepsilon ^2})\) approximation is not warranted.
 43.
Or the interpatch interpolation conditions in Thornburg’s multiplegridpatch scheme [156].
 44.
 45.
 46.
 47.
This paper does not say how the author finds apparent horizons, but [68, page 135] cites a preprint of this as treating the apparenthorizon equation as a 2point (ODE) boundary value problem: Eardley uses a ‘beads on a string’ technique to solve the set of simultaneous equations, i.e., imagining the curve to be defined as a bead on each ray of constant angle. He solves for the positions on each ray at which the relation is satisfied everywhere.
 48.
As another comparison, the Lorene apparent horizon finder (discussed in more detail in Section 8.4.2), running on a roughly similar processor, takes between 3 and 6 seconds to find apparent horizons to comparable accuracy.
 49.
The convergence problems, which Thornburg [153] noted when highspatialfrequency perturbations are present in the slice’s geometry, seem to be rare in practice.
 50.
In addition, at least two different research groups have now ported, or are in the process of porting, AHFinderDirect to their own (nonCactus) numerical relativity codes.
 51.
Schnetter et al. [135] use a simple arithmetic mean over all surface grid points. In theory this average could be defined 3covariantly by taking the induced metric on the surface into account, but in practice they found that this was not worth the added complexity.
 52.
There is one complication here: Any local apparent horizon finding algorithm may fail if the initial guess is not good enough, even if the desired surface is actually present. The solution is to use the constantexpansion surface for a slightly larger expansion E as an initial guess, gradually “walking down” the value of E to find the minimum value E_{*}. Thornburg [156, Appendix C] describes such a “continuationalgorithm binary search” algorithm in detail.
 53.
As far as I know this is the only case that has been considered for horizon pretracking. Extension to other types of apparent horizon finders might be a fruitful area for further research.
 54.
This refers to the period before a common apparent horizon is found. Once a common apparent horizon is found, then pretracking can be disabled as the apparent horizon finder can easily “track” the apparent horizon’s motion from one time step to the next. With a binary search the number of iterations depends only weakly (logarithmically) on the pretracking algorithm’s accuracy tolerance. It might be possible to replace the binary search by a more sophisticated 1dimensional search algorithm (I discuss such algorithms in Appendix A), potentially cutting the number of iterations substantially. This might be a fruitful area for further research.
 55.
Alternatively, a flow algorithm could use the most recent previouslyfound apparent horizon as an initial guess. In this case the algorithm would have only local convergence (in particular, it would probably fail to find a new outermost MOTS that appeared well outside the previouslyfound MOTS). However, the algorithm would only need to flow the surface a small distance, so the algorithm should be fairly fast.
 56.
 57.
Linearizing the Θ(h) function (16) gives a negative Laplacian in h as the principal part.
 58.
For a spatial resolution Δx, an explicit scheme is generally limited to a pseudotime step Δλ ≲ (Δx)^{2}.
 59.
Richtmyer and Morton [129, Section 7.5] give a very clear presentation and analysis of the Du FortFrankel scheme.
 60.
More precisely, Pasch [118] found that that an exponential integrator worked well when the flow’s Jacobian matrix was computed exactly (using the symbolicdifferentiation technique described in Section 8.5.4). However, when the Jacobian matrix was approximated using the numericalperturbation technique described in Section 8.5.4, Pasch found that the pseudotime integration became unstable at high numerical resolutions. Pasch [118] also notes that the exponential integrator uses a very large amount of memory.
 61.
 62.
 63.
AHFinder also includes a minimization algorithm (Section 8.3).
 64.
The parabola generically has two roots, but normally only one of them lies between x_{−} and x_{+}.
 65.
The numericalanalysis literature usually refers to this as the “initial value problem”. Unfortunately, in a relativity context this terminology often causes confusion with the “initial data problem” of solving the ADM constraint equations. I use the term “timeintegration problem for ODEs” to (try to) avoid this confusion. In this appendix, sansserif lowercase letters abc… z denote variables and functions in ℜ^{n} (for some fixed dimension n), and sansserif uppercase letters ABC … Z denote n × n realvalued matrices.
 66.
LSODA can also automatically detect stiff systems of ODEs and adjust its integration scheme so as to handle them efficiently.
Notes
Acknowledgements
I thank the many researchers who answered my email queries on various aspects of their work. I thank the anonymous referees for their careful reading of the manuscript and their many helpful comments. I thank Badri Krishnan for many useful conversations on the properties of apparent, isolated, and dynamical horizons. I thank Scott Caveny and Peter Diener for useful conversations on eventhorizon finders. I thank Peter Diener, Luciano Rezzolla, and Virginia J. Vitzthum for helpful comments on various drafts of this paper. I thank Peter Diener and Edward Seidel for providing unpublished figures.
I thank the many authors named in this review for granting permission to reprint figures from their published work. I thank the American Astronomical Society, the American Physical Society, and IOP Publishing for granting permission to reprint figures published in their journals. The American Physical Society requires the following disclaimer regarding such reprinted material:
Readers may view, browse, and/or download material for temporary copying purposes only, provided these uses are for noncommercial personal purposes. Except as provided by law, this material may not be further reproduced, distributed, transmitted, modified, adapted, performed, displayed, published, or sold in whole or part, without written permission from the publisher.
I thank the Alexander von Humboldt Foundation, the AEI visitors program, and the AEI postdoctoral fellowship program for financial support.
References
 [1]Abrahams, A.M., Cook, G.B., Shapiro, S.L., and Teukolsky, S.A., “Solving Einstein’s Equations for Rotating Spacetimes: Evolution of Relativistic Star Clusters”, Phys. Rev. D, 49, 5153–5164, (1994).ADSGoogle Scholar
 [2]Abrahams, A.M., and Evans, C.R., “Trapping a Geon: Black Hole Formation by an Imploding Gravitational Wave”, Phys. Rev. D, 46, R4117–R4121, (1992).ADSGoogle Scholar
 [3]Abrahams, A.M., Heiderich, K.H., Shapiro, S.L., and Teukolsky, S.A., “Vacuum initial data, singularities, and cosmic censorship”, Phys. Rev. D, 46, 2452–2463, (1992).ADSMathSciNetGoogle Scholar
 [4]Alcubierre, M., Brandt, S., Brügmann, B., Gundlach, C., Massó, J., Seidel, E., and Walker, P., “Testbeds and applications for apparent horizon finders in numerical relativity”, Class. Quantum Grav., 17, 2159–2190, (2000). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9809004.ADSMathSciNetzbMATHGoogle Scholar
 [5]Alcubierre, M., Brügmann, B., Diener, P., Guzmáan, F.S., Hawke, I., Hawley, S., Herrmann, F., Koppitz, M., Pollney, D., Seidel, E., and Thornburg, J., “Dynamical evolution of quasicircular binary black hole data”, Phys. Rev. D, 72, 044004, (2005). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0411149.ADSGoogle Scholar
 [6]Andersson, L., and Metzger, J., personal communication, (2007). Personal communication from Lars Andersson to Bela Sziláagyi.Google Scholar
 [7]Anninos, P., Bernstein, D., Brandt, S., Libson, J., Massoó, J., Seidel, E., Smarr, L.L., Suen, W.M., and Walker, P., “Dynamics of Apparent and Event Horizons”, Phys. Rev. Lett., 74, 630–633, (1995). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9403011.ADSGoogle Scholar
 [8]Anninos, P., Camarda, K., Libson, J., Massó, J., Seidel, E., and Suen, W.M., “Finding apparent horizons in dynamic 3D numerical spacetimes”, Phys. Rev. D, 58, 024003, 1–12, (1998).MathSciNetGoogle Scholar
 [9]Anninos, P., Daues, G., Massó, J., Seidel, E., and Suen, W.M., “Horizon boundary conditions for black hole spacetimes”, Phys. Rev. D, 51, 5562–5578, (1995).ADSMathSciNetGoogle Scholar
 [10]Ansorg, M., “A doubledomain spectral method for black hole excision data”, Phys. Rev. D, 72, 024018, 1–10, (2005). Related online version (cited on 30 January 2007): http://arxiv.org/abs/grqc/0505059.MathSciNetGoogle Scholar
 [11]Ansorg, M., Brügmann, B., and Tichy, W., “Singledomain spectral method for black hole puncture data”, Phys. Rev. D, 70, 064011, 1–13, (2004). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0404056.Google Scholar
 [12]Ansorg, M., Kleinwächter, A., and Meinel, R., “Highly accurate calculation of rotating neutron stars: Detailed description of the numerical methods”, Astron. Astrophys., 405, 711–721, (2003). Related online version (cited on 09 January 2006): http://arXiv.org/abs/astroph/0301173.ADSzbMATHGoogle Scholar
 [13]Ansorg, M., and Petroff, D., “Black holes surrounded by uniformly rotating rings”, Phys. Rev. D, 72, 024019, (2005). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0505060.ADSMathSciNetGoogle Scholar
 [14]Arnowitt, R., Deser, S., and Misner, C.W., “The dynamics of general relativity”, in Witten, L., ed., Gravitation: An Introduction to Current Research, 227–265, (Wiley, New York, U.S.A., 1962). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0405109.Google Scholar
 [15]Ascher, U.M., Mattheij, R.M.M., and Russell, R.D., Numerical Solution of Boundary Value Problems for Ordinary Differential Equations, (PrenticeHall, Englewood Cliffs, U.S.A., 1988).zbMATHGoogle Scholar
 [16]Ashtekar, A., Beetle, C., and Fairhurst, S., “Isolated horizons: a generalization of black hole mechanics”, Class. Quantum Grav., 16, L1–L7, (1999). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9812065.ADSMathSciNetzbMATHGoogle Scholar
 [17]Ashtekar, A., and Galloway, G., “Some uniqueness results for dynamical horizons”, Adv. Theor. Math. Phys., 9, 1–30, (2005). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0503109.MathSciNetzbMATHGoogle Scholar
 [18]Ashtekar, A., and Krishnan, B., “Dynamical Horizons: Energy, Angular Momentum, Fluxes, and Balance Laws”, Phys. Rev. Lett., 89, 261101, 1–4, (2002). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0207080.MathSciNetzbMATHGoogle Scholar
 [19]Ashtekar, A., and Krishnan, B., “Dynamical horizons and their properties”, Phys. Rev. D, 68, 104030, 1–25, (2003). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0308033.MathSciNetGoogle Scholar
 [20]Ashtekar, A., and Krishnan, B., “Isolated and Dynamical Horizons and Their Applications”, Living Rev. Relativity, 7, lrr200410, 10, (2004). URL (cited on 09 January 2006): http://www.livingreviews.org/lrr200410.
 [21]Baiotti, L., Hawke, I., Montero, P.J., Loftier, F., Rezzolla, L., Stergioulas, N., Font, J.A., and Seidel, E., “Threedimensional relativistic simulations of rotating neutron star collapse to a Kerr black hole”, Phys. Rev. D, 71, 024035, (2005). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0403029.ADSGoogle Scholar
 [22]Balay, S., Buschelman, K., Gropp, W.D., Kaushik, D., Knepley, M., Curfman McInnes, L., Smith, B.F., and Zhang, H., “PETSc: Portable, Extensible Toolkit for Scientific Computation”, project homepage, Argonne National Laboratory. URL (cited on 09 January 2006): http://www.mcs.anl.gov/petsc.
 [23]Balay, S., Buschelman, K., Gropp, W.D., Kaushik, D., Knepley, M., Curfman McInnes, L., Smith, B.F., and Zhang, H., PETSc Users Manual, ANL95/11 — Revision 2.1.5, (Argonne National Laboratory, Argonne, U.S.A., 2003). URL (cited on 20 August 2003): http://wwwunix.mcs.anl.gov/petsc/petscas/documentation/.Google Scholar
 [24]Balay, S., Gropp, W.D., Curfman McInnes, L., and Smith, B.F., “Efficient Management of Parallelism in ObjectOriented Numerical Software Libraries”, in Arge, E., Bruaset, A.M., and Langtangen, H.P., eds., Modern Software Tools for Scientific Computing, Proceedings of SciTools’ 96 Workshop held in Oslo, Norway, 163–202, (Birkhäuser, Boston, U.S.A., 1997).zbMATHGoogle Scholar
 [25]Bartnik, R., personal communication. Personal communication from Robert Bartnik to Carsten Gundlach.Google Scholar
 [26]Baumgarte, T.W., Cook, G.B., Scheel, M.A., Shapiro, S.L., and Teukolsky, S.A., “Implementing an apparenthorizon finder in three dimensions”, Phys. Rev. D, 54, 4849–4857, (1996). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9606010.ADSGoogle Scholar
 [27]Baumgarte, T.W., and Shapiro, S.L., “Numerical relativity and compact binaries”, Phys. Rep., 376, 41–131, (2003). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0211028.ADSMathSciNetzbMATHGoogle Scholar
 [28]Bernstein, D., Notes on the Mean Curvature Flow Method for Finding Apparent Horizons, (National Center for Supercomputing Applications, UrbanaChampaign, U.S.A., 1993).Google Scholar
 [29]Bishop, N.T., “The Closed Trapped Region and the Apparent Horizon of Two Schwarzschild Black Holes”, Gen. Relativ. Gravit., 14, 717–723, (1982).ADSMathSciNetzbMATHGoogle Scholar
 [30]Bishop, N.T., “The horizons of two Schwarzschild black holes”, Gen. Relativ. Gravit., 16, 589–593, (1984).ADSMathSciNetzbMATHGoogle Scholar
 [31]Bishop, N.T., “The Event Horizons of Two Schwarzschild black holes”, Gen. Relativ. Gravit., 20, 573–581, (1988).ADSMathSciNetGoogle Scholar
 [32]Bizoń, P., Malec, E., and Ó Murchadha, N., “Trapped Surfaces in Spherical Stars”, Phys. Rev. Lett., 61, 1147–1150, (1988).ADSMathSciNetGoogle Scholar
 [33]Bonazzola, S., Frieben, J., Gourgoulhon, E., and Marck, J.A., “Spectral methods in general relativity — toward the simulation of 3Dgravitational collapse of neutron stars”, in Ilin, A.V., and Scott, L.R., eds., ICOSAHOM’ 95, Proceedings of the Third International Conference on Spectral and High Order Methods: Houston, Texas, June 5–9, 1995, Houston Journal of Mathematics, 319, (University of Houston, Houston, U.S.A., 1996). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9604029.Google Scholar
 [34]Bonazzola, S., Gourgoulhon, E., and Marck, J.A., “Spectral methods in general relativistic astrophysics”, J. Comput. Appl. Math., 109, 433–473, (1999). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9811089.ADSzbMATHGoogle Scholar
 [35]Bonazzola, S., and Marck, J.A., “PseudoSpectral Methods Applied to Gravitational Collapse”, in Evans, C.R., Finn, L.S., and Hobill, D.W., eds., Frontiers in Numerical Relativity, Proceedings of the International Workshop on Numerical Relativity, University of Illinois at UrbanaChampaign, USA, May 9–13, 1988, 239–253, (Cambridge University Press, Cambridge, U.K.; New York, U.S.A., 1989).Google Scholar
 [36]Booth, I., “Black hole boundaries”, Can. J. Phys., 83, 1073–1099, (2005). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0508107.ADSGoogle Scholar
 [37]Boyd, J.P., Chebyshev and Fourier Spectral Methods, (Dover Publications, Mineola, U.S.A., 2001), 2nd edition.zbMATHGoogle Scholar
 [38]Brankin, R.W., Gladwell, I., and Shampine, L.F., “RKSUITE: A Suite of RungeKutta Codes for the Initial Value Problem for ODEs”, other, Dept. of Mathematics, Southern Methodist University, Dallas, TX, (1992). URL (cited on 09 January 2006): http://www.netlib.org/ode/rksuite/.zbMATHGoogle Scholar
 [39]Brent, R.P., Algorithms for Minimization Without Derivatives, (Dover Publications, Mineola, U.S.A., 2002). Reprint of 1973 original edition.zbMATHGoogle Scholar
 [40]Brewin, L.C., “Is the Regge Calculus a Consistent Approximation to General Relativity?”, Gen. Relativ. Gravit., 32, 897–918, (2000). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9502043.ADSMathSciNetzbMATHGoogle Scholar
 [41]Brewin, L.C., and Gentle, A.P., “On the Convergence of Regge Calculus to General Relativity”, Class. Quantum Grav., 18, 517–525, (2001). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0006017.ADSMathSciNetzbMATHGoogle Scholar
 [42]Briggs, W.L., Henson, V.E., and McCormick, S.F., A Multigrid Tutorial, (SIAM, Philadelphia, U.S.A., 2000), 2nd edition.zbMATHGoogle Scholar
 [43]Brill, D.R., and Lindquist, R.W., “Interaction Energy in Geometrostatics”, Phys. Rev., 131, 471–476, (1963).ADSMathSciNetzbMATHGoogle Scholar
 [44]Caveny, S.A., Tracking Black Holes in Numerical Relativity: Foundations and Applications, Ph.D. Thesis, (University of Texas at Austin, Austin, U.S.A., 2002).Google Scholar
 [45]Caveny, S.A., Anderson, M., and Matzner, R.A., “Tracking Black Holes in Numerical Relativity”, Phys. Rev. D, 68, 104009, (2003). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0303099.ADSMathSciNetGoogle Scholar
 [46]Caveny, S.A., and Matzner, R.A., “Adaptive event horizon tracking and critical phenomena in binary black hole coalescence”, Phys. Rev. D, 68, 104003–1–13, (2003). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0303109.ADSMathSciNetGoogle Scholar
 [47]Choptuik, M.W., A Study of Numerical Techniques for Radiative Problems in General Relativity, Ph.D. Thesis, (University of British Columbia, Vancouver, Canada, 1986).Google Scholar
 [48]Choptuik, M.W., “Experiences with an Adaptive Mesh Refinement Algorithm in Numerical Relativity”, in Evans, C.R., Finn, L.S., and Hobill, D.W., eds., Frontiers in Numerical Relativity, Proceedings of the International Workshop on Numerical Relativity, University of Illinois at UrbanaChampaign (UrbanaChampaign, Illinois, USA), May 9–13, 1988, 206–221, (Cambridge University Press, Cambridge, U.K.; New York, U.S.A., 1989).Google Scholar
 [49]Chruściel, P.T., and Galloway, G.J., “Horizons NonDifferentiable on a Dense Set”, Commun. Math. Phys., 193, 449–470, (1998). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9611032.ADSMathSciNetzbMATHGoogle Scholar
 [50]Cook, G.B., Initial Data for the TwoBody Problem of General Relativity, Ph.D. Thesis, (University of North Carolina at Chapel Hill, Chapel Hill, U.S.A., 1990).Google Scholar
 [51]Cook, G.B., and Abrahams, A.M., “Horizon Structure of InitialData Sets for Axisymmetric TwoBlackHole Collisions”, Phys. Rev. D, 46, 702–713, (1992).ADSMathSciNetGoogle Scholar
 [52]Cook, G.B., and York Jr, J.W., “Apparent Horizons for Boosted or Spinning Black Holes”, Phys. Rev. D, 41, 1077–1085, (1990).ADSGoogle Scholar
 [53]Curtis, A.R., and Reid, J.K., “The Choice of Step Lengths When Using Differences to Approximate Jacobian Matrices”, J. Inst. Math. Appl., 13, 121–126, (1974).zbMATHGoogle Scholar
 [54]Davis, T.A., “UMFPACK: unsymmetric multifrontal sparse LU factorization package”, project homepage, University of Florida (CISE). URL (cited on 6 January 2007): http://www.cise.ufl.edu/research/sparse/umfpack/.
 [55]Davis, T.A., “Algorithm 832: UMFPACK V4.3—an unsymmetricpattern multifrontal method”, ACM Trans. Math. Software, 30, 196–199, (2004). Related online version (cited on 09 January 2006): http://www.cise.ufl.edu/∼davis/. TR02002.MathSciNetzbMATHGoogle Scholar
 [56]Davis, T.A., “A column preordering strategy for the unsymmetricpattern multifrontal method”, ACM Trans. Math. Software, 30, 165–195, (2004). Related online version (cited on 09 January 2006): http://www.cise.ufl.edu/∼davis/. TR02001.MathSciNetzbMATHGoogle Scholar
 [57]Davis, T.A., and Duff, I.S., “An unsymmetricpattern multifrontal method for sparse LU factorization”, SIAM J. Matrix Anal. Appl., 18, 140–158, (1997).MathSciNetzbMATHGoogle Scholar
 [58]Davis, T.A., and Duff, I.S., “A combined unifrontal/multifrontal method for unsymmetric sparse matrices”, ACM Trans. Math. Software, 25, 1–19, (1999).MathSciNetzbMATHGoogle Scholar
 [59]Dennis Jr, J.E., and Schnabel, R.B., Numerical Methods for Unconstrained Optimization and Nonlinear Equations, (SIAM, Philadelphia, U.S.A., 1996).zbMATHGoogle Scholar
 [60]Diener, P., “A New General Purpose Event Horizon Finder for 3D”, Class. Quantum Grav., 20, 4901–4917, (2003). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0305039.ADSMathSciNetzbMATHGoogle Scholar
 [61]Diener, P., personal communication, (2007).Google Scholar
 [62]Diener, P., Herrmann, F., Pollney, D., Schnetter, E., Seidel, E., Takahashi, R., Thornburg, J., and Ventrella, J., “Accurate Evolution of Orbiting Binary Black Holes”, Phys. Rev. Lett., 96, 121101, (2006). Related online version (cited on 3 October 2006): http://arXiv.org/abs/grqc/0512108.ADSGoogle Scholar
 [63]Dreyer, O., Krishnan, B., Schnetter, E., and Shoemaker, D., “Introduction to isolated horizons in numerical relativity”, Phys. Rev. D, 67, 024018, 1–14, (2003). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0206008.MathSciNetGoogle Scholar
 [64]Du Fort, E.C., and Frankel, S.P., “Stability Conditions in the Numerical Treatment of Parabolic Differential Equations”, Math. Tables Aids Comput., 7, 135–152, (1953).MathSciNetzbMATHGoogle Scholar
 [65]Duff, I.S., Erisman, A.M., and Reid, J.K., Direct Methods for Sparse Matrices, (Oxford University Press, Oxford, U.K.; New York, U.S.A., 1986).zbMATHGoogle Scholar
 [66]Dykema, P.G., The Numerical Simulation of Axially Symmetric Gravitational Collapse, Ph.D. Thesis, (University of Texas at Austin, Austin, U.S.A., 1980).Google Scholar
 [67]Eardley, D.M., “Gravitational Collapse of Marginally Bound Spheroids: Initial Conditions”, Phys. Rev. D, 12, 3072–3076, (1975).ADSGoogle Scholar
 [68]Eppley, K.R., The numerical evolution of the collision of two black holes, Ph.D. Thesis, (Princeton University, Princeton, U.S.A., 1975).Google Scholar
 [69]Eppley, K.R., “Evolution of timesymmetric gravitational waves: Initial data and apparent horizons”, Phys. Rev. D, 16, 1609–1614, (1977).ADSMathSciNetGoogle Scholar
 [70]Fornberg, B., A Practical Guide to Pseudospectral Methods, Cambridge Monographs on Applied and Computational Mathematics, (Cambridge University Press, Cambridge, U.K.; New York, U.S.A., 1998).zbMATHGoogle Scholar
 [71]Forsythe, G.E., Malcolm, M.A., and Moler, C.B., Computer Methods for Mathematical Computations, (PrenticeHall, Englewood Cliffs, U.S.A., 1977). Related online version (cited on 09 January 2006): http://www.netlib.org/fmm/.zbMATHGoogle Scholar
 [72]Gentle, A.P., “Regge Calculus: A Unique Tool for Numerical Relativity”, Gen. Relativ. Gravit., 34, 1701–1718, (2002). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0408006.MathSciNetzbMATHGoogle Scholar
 [73]Gentle, A.P., and Miller, W.A., “A fully (3+1)dimensional Regge calculus model of the Kasner cosmology”, Class. Quantum Grav., 15, 389–405, (1998). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9706034.ADSMathSciNetzbMATHGoogle Scholar
 [74]Goodale, T., Allen, G., Lanfermann, G., Massó, J., Radke, T., Seidel, E., and Shalf, J., “The Cactus Framework and Toolkit: Design and Applications”, in Palma, J.M.L.M. and Dongarra, J., Hernández, V., and Sousa, A.A., eds., High Performance Computing for Computational Science (VECPAR 2002), 5th International Conference, Porto, Portugal, June 26–28, 2002: Selected papers and invited talks, vol. 2565 of Lecture Notes in Computer Science, 197–227, (Springer, Berlin, Germany; New York, U.S.A., 2003).Google Scholar
 [75]Gottlieb, D., and Orszag, S.A., Numerical Analysis of Spectral Methods: Theory and Applications, vol. 26 of Regional Conference Series in Applied Mathematics, (SIAM, Philadelphia, U.S.A., 1977). Based on a series of lectures presented at the NSFCBMS regional conference held at Old Dominion University from August 2–6, 1976.zbMATHGoogle Scholar
 [76]Gourgoulhon, E., and Jaramillo, J.L., “A 3+1 perspective on null hypersurfaces and isolated horizons”, Phys. Rep., 423, 159–294, (2006). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0503113.ADSMathSciNetGoogle Scholar
 [77]Grandclement, P., Bonazzola, S., Gourgoulhon, E., and Marck, J.A., “A Multidomain Spectral Method for Scalar and Vectorial Poisson Equations with Noncompact Sources”, J. Comput. Phys., 170, 231–260, (2001). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0003072.ADSMathSciNetzbMATHGoogle Scholar
 [78]Grandclément, P., Gourgoulhon, E., and Bonazzola, S., “Binary black holes in circular orbits. II. Numerical methods and first results”, Phys. Rev. D, 65, 044021, 1–18, (2002). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0106016.MathSciNetGoogle Scholar
 [79]Grayson, M.A., “The Heat Equation Shrinks Embedded Plane Curves to Round Points”, J. Differ. Geom., 26, 285–314, (1987).MathSciNetzbMATHGoogle Scholar
 [80]Gundlach, C., “Pseudospectral apparent horizon finders: An efficient new algorithm”, Phys. Rev. D, 57, 863–875, (1998). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9707050.ADSMathSciNetGoogle Scholar
 [81]Hawking, S.W., “The Event Horizon”, in DeWitt, C., and DeWitt, B.S., eds., Black Holes, Based on lectures given at the 23rd session of the Summer School of Les Houches, 1972, 1–56, (Gordon and Breach, New York, U.S.A., 1973).Google Scholar
 [82]Hawking, S.W., and Ellis, G.F.R., The Large Scale Structure of SpaceTime, Cambridge Monographs on Mathematical Physics, (Cambridge University Press, Cambridge, U.K., 1973).zbMATHGoogle Scholar
 [83]Hayward, S.A., “General laws of black hole dynamics”, Phys. Rev. D, 49, 6467–6474, (1994). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9306006.ADSMathSciNetGoogle Scholar
 [84]Hindmarsh, A.C., “ODEPACK, A Systematized Collection of ODE Solvers”, in Stepleman, R.S. et al., ed., Scientific Computing: Applications of Mathematics and Computing to the Physical Sciences, Based on papers presented at the Tenth IMACS World Congress on System Simulation and Scientific Computation, held in Montreal, Canada, August 8–13, 1982, vol. 1 of IMACS Transactions on Scientific Computing, 55–64, (NorthHolland, Amsterdam, Netherlands; New York, U.S.A., 1983). Related online version (cited on 09 January 2006): http://www.netlib.org/odepack/index.html.Google Scholar
 [85]Hochbruck, M., Lubich, C., and Selhofer, H., “Exponential Integrators for Large Systems of Differential Equations”, SIAM J. Sci. Comput., 19, 1552–1574, (1998).MathSciNetzbMATHGoogle Scholar
 [86]Hornung, R.D., and Kohn, S.R., “Managing application complexity in the SAMRAI objectoriented framework”, Concurr. Comput. Pract. Exp., 14, 347–368, (2002).zbMATHGoogle Scholar
 [87]Hornung, R.D., Wissink, A.M., and Kohn, S.R., “Managing complex data and geometry in parallel structured AMR applications”, Eng. Comput., 22, 181–195, (2006).Google Scholar
 [88]Hughes, S.A., Keeton II, C.R., Walker, P., Walsh, K.T., Shapiro, S.L., and Teukolsky, S.A., “Finding Black Holes in Numerical Spacetimes”, Phys. Rev. D, 49, 4004–4015, (1994).ADSGoogle Scholar
 [89]Huq, M.F., Apparent Horizon Location in Numerical Spacetimes, Ph.D. Thesis, (The University of Texas at Austin, Austin, U.S.A., 1996).Google Scholar
 [90]Huq, M.F., Choptuik, M.W., and Matzner, R.A., “Locating Boosted Kerr and Schwarzschild Apparent Horizons”, Phys. Rev. D, 66, 084024, (2002). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0002076.ADSMathSciNetGoogle Scholar
 [91]Husa, S., and Winicour, J., “Asymmetric merger of black holes”, Phys. Rev. D, 60, 084019, 1–13, (1999). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9905039.MathSciNetGoogle Scholar
 [92]Kahaner, D., Moler, C.B., and Nash, S., Numerical Methods and Software, (Prentice Hall, Englewood Cliffs, U.S.A., 1989). Revised and (greatly) expanded edition of Forsythe, G.E. and Malcolm, M.A. and Moler, C.B, “Computer methods for mathematical computations”(1977).zbMATHGoogle Scholar
 [93]Kemball, A.J., and Bishop, N.T., “The numerical determination of apparent horizons”, Class. Quantum Grav., 8, 1361–1367, (1991).ADSMathSciNetGoogle Scholar
 [94]Kershaw, D.S., “The Incomplete CholeskyConjugate Gradient Method for Interative Solution of Linear Equations”, J. Comput. Phys., 26, 43–65, (1978).ADSzbMATHGoogle Scholar
 [95]Kidder, L.E., and Finn, L.S., “Spectral Methods for Numerical Relativity. The Initial Data Problem”, Phys. Rev. D, 62, 084026, (2000). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9911014.ADSGoogle Scholar
 [96]Kidder, L.E., Scheel, M.A., Teukolsky, S.A., Carlson, E.D., and Cook, G.B., “Black hole evolution by spectral methods”, Phys. Rev. D, 62, 084032, (2000). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0005056.ADSMathSciNetGoogle Scholar
 [97]Kidder, L.E., Scheel, M.A., Teukolsky, S.A., and Cook, G.B., “Spectral Evolution of Einstein’s Equations”, Miniprogram on Colliding Black Holes: Mathematical Issues in Numerical Relativity, held at the Institute for Theoretical Physics, UC at Santa Barbara, 10–28 January 2000, conference paper, (2000).Google Scholar
 [98]Kriele, M., and Hayward, S.A., “Outer trapped surfaces and their apparent horizon”, J. Math. Phys., 38, 1593–1604, (1997).ADSMathSciNetzbMATHGoogle Scholar
 [99]Lehner, L., Bishop, N.T., Gómez, R., Szilágyi, B., and Winicour, J., “Exact solutions for the intrinsic geometry of black hole coalescence”, Phys. Rev. D, 60, 044005, 1–10, (1999).MathSciNetGoogle Scholar
 [100]Lehner, L., Gómez, R., Husa, S., Szilágyi, B., Bishop, N.T., and Winicour, J., “Bagels Form When Black Holes Collide”, institutional homepage, Pittsburgh Supercomputing Center. URL (cited on 09 January 2006): http://www.psc.edu/research/graphics/gallery/winicour.html.
 [101]Leiler, G., and Rezzolla, L., “On the iterated CrankNicolson method for hyperbolic and parabolic equations in numerical relativity”, Phys. Rev. D, 73, 044001, (2006). Related online version (cited on 3 October 2006): http://arXiv.org/abs/grqc/0601139.ADSMathSciNetGoogle Scholar
 [102]Libson, J., Massóo, J., Seidel, E., and Suen, W.M., “A 3D Apparent Horizon Finder”, in Jantzen, R.T., and Keiser, G.M., eds., The Seventh Marcel Grossmann Meeting: On recent developments in theoretical and experimental general relativity, gravitation, and relativistic field theories, Proceedings of the meeting held at Stanford University, July 24–30, 1994, 631, (World Scientific, Singapore; River Edge, U.S.A., 1996).Google Scholar
 [103]Libson, J., Massó, J., Seidel, E., Suen, W.M., and Walker, P., “Event horizons in numerical relativity: Methods and tests”, Phys. Rev. D, 53, 4335–4350, (1996).ADSMathSciNetGoogle Scholar
 [104]Lin, L.M., and Novak, J., “Threedimensional apparent horizon finder in LORENE”, personal communication, (2006). Personal communication from LapMing Lin to Jonathan Thornburg.Google Scholar
 [105]Lorensen, W.E., and Cline, H.E., “Marching cubes: A high resolution 3D surface construction algorithm”, SIGGRAPH Comput. Graph., 21, 163–169, (1987).Google Scholar
 [106]MacNeice, P., Olson, K.M., Mobarry, C., de Fainchtein, R., and Packer, C., “PARAMESH: A parallel adaptive mesh refinement community toolkit”, Computer Phys. Commun., 126, 330–354, (2000).ADSzbMATHGoogle Scholar
 [107]Madderom, P., “Incomplete LUDecomposition — Conjugate Gradient”, unknown format, (1984). Fortran 66 subroutine.Google Scholar
 [108]Matzner, R.A., Seidel, E., Shapiro, S.L., Smarr, L.L., Suen, W.M., Teukolsky, S.A., and Winicour, J., “Geometry of a Black Hole Collision”, Science, 270, 941–947, (1995).ADSGoogle Scholar
 [109]Metzger, J., “Numerical computation of constant mean curvature surfaces using finite elements”, Class. Quantum Grav., 21, 4625–4646, (2004). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0408059.ADSMathSciNetzbMATHGoogle Scholar
 [110]Miller, M.A., “Regge Calculus as a Fourth Order Method in Numerical Relativity”, Class. Quantum Grav., 12, 3037–3051, (1995). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9502044.ADSMathSciNetzbMATHGoogle Scholar
 [111]Misner, C.W., and Sharp, D.H., “Relativistic Equations for Adiabatic, Spherically Symmetric Gravitational Collapse”, Phys. Rev., 136, B571–B576, (1964).ADSMathSciNetzbMATHGoogle Scholar
 [112]Misner, C.W., Thorne, K.S., and Wheeler, J.A., Gravitation, (W.H. Freeman, San Francisco, U.S.A., 1973).Google Scholar
 [113]Nakamura, T., Kojima, Y., and Oohara, K., “A Method of Determining Apparent Horizons in ThreeDimensional Numerical Relativity”, Phys. Lett. A, 106, 235–238, (1984).ADSMathSciNetGoogle Scholar
 [114]Oohara, K., “Apparent Horizon of Initial Data for Black HoleCollisions”, in Sato, H., and Nakamura, T., eds., Gravitational Collapse and Relativity, Proceedings of Yamada Conference XIV, Kyoto International Conference Hall, Japan, April 7–11, 1986, 313–319, (World Scientific, Singapore; Philadelphia, U.S.A., 1986).Google Scholar
 [115]Oohara, K., Nakamura, T., and Kojima, Y., “Apparent Horizons of TimeSymmetric Initial Value for Three Black Holes”, Phys. Lett. A, 107, 452–455, (1985).ADSGoogle Scholar
 [116]Osher, S., and Sethian, J.A., “Fronts propagating with curvaturedependent speed: Algorithms based on HamiltonJacobi formulations”, J. Comput. Phys., 79, 12–49, (1988).ADSMathSciNetzbMATHGoogle Scholar
 [117]Parashar, M., and Browne, J.C., “System Engineering for High Performance Computing Software: The HDDA/DAGH Infrastructure for Implementation of Parallel Structured Adaptive Mesh Refinement”, in Baden, S.B., Chrisochoides, N.P., Gannon, D.B., and Norman, M.L., eds., Structured Adaptive Mesh Refinement (SAMR) Grid Methods, vol. 117 of IMA Volumes in Mathematics and its Applications, 1–18, (Springer, New York, U.S.A., 2000).Google Scholar
 [118]Pasch, E., The level set method for the mean curvature flow on (R^{3},g), SFB 382 Reports, 63, (University of Tübingen, Tübingen, Germany, 1997). URL (cited on 09 January 2006): http://www.unituebingen.de/uni/opx/reports.html.Google Scholar
 [119]Petrich, L.I., Shapiro, S.L., and Teukolsky, S.A., “OppenheimerSnyder Collapse with Maximal Time Slicing and Isotropic Coordinates”, Phys. Rev. D, 31, 2459–2469, (1985).ADSGoogle Scholar
 [120]Pfeiffer, H.P., Initial Data for Black Hole Evolutions, Ph.D. Thesis, (Cornell University, Ithaca, U.S.A., 2003). Related online version (cited on 1 October 2006): http://arXiv.org/abs/grqc/0510016.Google Scholar
 [121]Pfeiffer, H.P., personal communication, (2006).Google Scholar
 [122]Pfeiffer, H.P., Cook, G.B., and Teukolsky, S.A., “Comparing initialdata sets for binary black holes”, Phys. Rev. D, 66, 024047, 1–17, (2002). Related online version (cited on 1 October 2006): http://arXiv.org/abs/grqc/0203085.MathSciNetGoogle Scholar
 [123]Pfeiffer, H.P., Kidder, L.E., Scheel, M.A., and Teukolsky, S.A., “A multidomain spectral method for solving elliptic equations”, Computer Phys. Commun., 152, 253–273, (2003). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0202096.ADSMathSciNetzbMATHGoogle Scholar
 [124]Pfeiffer, H.P., Teukolsky, S.A., and Cook, G.B., “Quasicircular orbits for spinning binary black holes”, Phys. Rev. D, 62, 104018, 1–11, (2000). Related online version (cited on 1 October 2006): http://arXiv.org/abs/grqc/0006084.MathSciNetGoogle Scholar
 [125]Press, W.H., Flannery, B.P., Teukolsky, S.A., and Vetterling, W.T., Numerical Recipes, (Cambridge University Press, Cambridge, U.K.; New York, U.S.A., 1992), 2nd edition.zbMATHGoogle Scholar
 [126]Pretorius, F., and Choptuik, M.W., “Adaptive Mesh Refinement for Coupled EllipticHyperbolic Systems”, J. Comput. Phys., 218, 246–274, (2006). Related online version (cited on 3 October 2006): http://arXiv.org/abs/grqc/0508110.ADSMathSciNetzbMATHGoogle Scholar
 [127]Pretorius, F., and Lehner, L., “Adaptive mesh refinement for characteristic codes”, J. Comput. Phys., 198, 10–34, (2004). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0302003.ADSzbMATHGoogle Scholar
 [128]Regge, T., “General Relativity without Coordinates”, Nuovo Cimento A, 19, 558–571, (1961).MathSciNetGoogle Scholar
 [129]Richtmyer, R.D., and Morton, K.W., Difference Methods for InitialValue Problems, (Krieger, Malabar, U.S.A., 1994), 2nd edition. Reprinted second edition of 1967.zbMATHGoogle Scholar
 [130]Saad, Y., Iterative Methods for Sparse Linear Systems, (SIAM, Philadelphia, U.S.A., 2003), 2nd edition.zbMATHGoogle Scholar
 [131]Schnetter, E., “CarpetCode: A mesh refinement driver for Cactus”, project homepage, Center for Computation and Technology, Louisiana State University. URL (cited on 09 January 2006): http://www.carpetcode.org
 [132]Schnetter, E., “A fast apparent horizon algorithm”, (2002). URL (cited on 09 January 2006): http://arXiv.org/abs/grqc/0206003.
 [133]Schnetter, E., “Finding Apparent Horizons and other TwoSurfaces of Constant Expansion”, Class. Quantum Grav., 20, 4719–4737, (2003). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0306006.ADSMathSciNetzbMATHGoogle Scholar
 [134]Schnetter, E., Hawley, S.H., and Hawke, I., “Evolutions in 3D numerical relativity using fixed mesh refinement”, Class. Quantum Grav., 21, 1465–1488, (2004). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0310042.ADSMathSciNetzbMATHGoogle Scholar
 [135]Schnetter, E., Herrmann, F., and Pollney, D., “Horizon Pretracking”, Phys. Rev. D, 71, 044033, (2005). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0410081.ADSMathSciNetGoogle Scholar
 [136]Schnetter, E., and Krishnan, B., “Nonsymmetric trapped surfaces in the Schwarzschild Vaidya spacetimes”, Phys. Rev. D, 73, 021502, (2006). Related online version (cited on 3 October 2006): http://arXiv.org/abs/grqc/0511017.ADSMathSciNetGoogle Scholar
 [137]Schnetter, E., Krishnan, B., and Beyer, F., “Introduction to Dynamical Horizons in numerical relativity”, Phys. Rev. D, 74, 024028, (2006). Related online version (cited on 30 October 2006): http://arXiv.org/abs/grqc/0604015.ADSGoogle Scholar
 [138]Schroeder, M.R., Number Theory in Science and Communication: With Applications in Cryptography, Physics, Digital Information, Computing and SelfSimilarity, vol. 7 of Springer Series in Information Sciences, (Springer, Berlin, Germany; New York, U.S.A., 1986), 2nd edition.zbMATHGoogle Scholar
 [139]Seidel, E., and Suen, W.M., “Towards a SingularityProof Scheme in Numerical Relativity”, Phys. Rev. Lett., 69, 1845–1848, (1992).ADSGoogle Scholar
 [140]Shampine, L.F., and Gordon, M.K., Computer solution of Ordinary Differential Equations, (W.H. Freeman, San Francisco, U.S.A., 1975).zbMATHGoogle Scholar
 [141]Shapiro, S.L., and Teukolsky, S.A., “Gravitational Collapse of Supermassive Stars to Black Holes: Numerical Solution of the Einstein Equations”, Astrophys. J. Lett., 234, L177–L181, (1979).ADSGoogle Scholar
 [142]Shapiro, S.L., and Teukolsky, S.A., “Gravitational Collapse to Neutron Stars and Black Holes: Computer Generation of Spherical Spacetimes”, Astrophys. J., 235, 199–215, (1980). Related online version (cited on 05 February 2007): http://adsabs.harvard.edu/abs/1980ApJ...235..199S.ADSGoogle Scholar
 [143]Shapiro, S.L., and Teukolsky, S.A., “Relativistic stellar dynamics on the computer. I. Motivation and Numerical Method”, Astrophys. J., 298, 34–57, (1985).ADSGoogle Scholar
 [144]Shapiro, S.L., and Teukolsky, S.A., “Relativistic stellar dynamics on the computer. II. Physical applications”, Astrophys. J., 298, 58–79, (1985).ADSGoogle Scholar
 [145]Shapiro, S.L., and Teukolsky, S.A., “Collision of relativistic clusters and the formation of black holes”, Phys. Rev. D, 45, 2739–2750, (1992).ADSMathSciNetzbMATHGoogle Scholar
 [146]Shibata, M., “Apparent horizon finder for a special family of spacetimes in 3D numerical relativity”, Phys. Rev. D, 55, 2002–2013, (1997).ADSGoogle Scholar
 [147]Shibata, M., and Uryū, K., “Apparent Horizon Finder for General ThreeDimensional Spaces”, Phys. Rev. D, 62, 087501, (2000).ADSGoogle Scholar
 [148]Shoemaker, D.M., Apparent Horizons in Binary Black Hole Spacetimes, Ph.D. Thesis, (The University of Texas at Austin, Austin, U.S.A., 1999).Google Scholar
 [149]Shoemaker, D.M., Huq, M.F., and Matzner, R.A., “Generic tracking of multiple apparent horizons with level flow”, Phys. Rev. D, 62, 124005, (2000). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0006042.ADSMathSciNetGoogle Scholar
 [150]Stoer, J., and Bulirsch, R., Introduction to Numerical Analysis, (Springer, Berlin, Germany; New York, U.S.A., 1980).zbMATHGoogle Scholar
 [151]Sziláagyi, B., Pollney, D., Rezzolla, L., Thornburg, J., and Winicour, J., “An explicit harmonic code for blackhole evolution using excision”, (2007). URL (cited on 09 April 2007): http://arXiv.org/abs/grqc/0612150.
 [152]Teukolsky, S.A., “On the Stability of the Iterated CrankNicholson Method in Numerical Relativity”, Phys. Rev. D, 61, 087501, (2000).ADSGoogle Scholar
 [153]Thornburg, J., “Finding apparent horizons in numerical relativity”, Phys. Rev. D, 54, 4899–4918, (1996). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9508014.ADSMathSciNetGoogle Scholar
 [154]Thornburg, J., “A 3+1 Computational Scheme for Dynamic Spherically Symmetric Black Hole Spacetimes — I: Initial Data”, Phys. Rev. D, 59, 104007, (1999). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/9801087.ADSMathSciNetGoogle Scholar
 [155]Thornburg, J., “A 3+1 Computational Scheme for Dynamic Spherically Symmetric Black Hole Spacetimes — II: Time Evolution”, (1999). URL (cited on 09 January 2006): http://arXiv.org/abs/grqc/9906022.
 [156]Thornburg, J., “A fast apparent horizon finder for threedimensional Cartesian grids in numerical relativity”, Class. Quantum Grav., 21, 743–766, (2004). Related online version (cited on 09 January 2006): http://arXiv.org/abs/grqc/0306056.ADSMathSciNetzbMATHGoogle Scholar
 [157]Tod, K.P., “Looking for marginally trapped surfaces”, Class. Quantum Grav., 8, L115–L118, (1991).ADSMathSciNetzbMATHGoogle Scholar
 [158]Trottenberg, U., Oosterlee, C.W., and Schüller, A., Multigrid, (Academic Press, San Diego, U.S.A., 2001).zbMATHGoogle Scholar
 [159]Čadež, A., “Apparent Horizons in the TwoBlackHole Problem”, Ann. Phys. (N.Y.), 83, 449–457, (1974).ADSGoogle Scholar
 [160]Wald, R.M., General Relativity, (University of Chicago Press, Chicago, U.S.A., 1984).zbMATHGoogle Scholar
 [161]Wald, R.M., and Iyer, V., “Trapped surfaces in the Schwarzschild geometry and cosmic censorship”, Phys. Rev. D, 44, R3719–R3722, (1991).ADSMathSciNetGoogle Scholar
 [162]Walker, P., Horizons, Hyperbolic Systems, and Inner Boundary Conditions in Numerical Relativity, Ph.D. Thesis, (University of Illinois at UrbanaChampaign, Urbana, U.S.A., 1998).Google Scholar
 [163]York Jr, J.W., “Kinematics and Dynamics of General Relativity”, in Smarr, L.L., ed., Sources of Gravitational Radiation, Proceedings of the Battelle Seattle Workshop, July 24–August 4, 1978, 83–126, (Cambridge University Press, Cambridge, U.K.; New York, U.S.A., 1979)Google Scholar
 [164]York Jr, J.W., “Initial Data for Collisions of Black Holes and Other Gravitational Miscellany”, in Evans, C.R., Finn, L.S., and Hobill, D.W., eds., Frontiers in Numerical Relativity, Proceedings of the International Workshop on Numerical Relativity, University of Illinois at UrbanaChampaign, U.S.A., May 9–13, 1988, 89–109, (Cambridge University Press, Cambridge, U.K.; New York, U.S.A., 1989).Google Scholar
Copyright information
This article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.