Comparison of Six Different Methods For Calculating Traveltimes

Geophysical Prospecting, 1999, 47, 269–297
Comparison of six different methods for calculating

traveltimes1
A. Leidenfrost,2 N. Ettrich,2 D. Gajewski2 and D. Kosloff 3
Abstract
We study six different methods for the calculation of seismic traveltimes. All methods
yield traveltimes at all points of a regular grid.
The methods examined comprise three different variants of finite-difference (FD)
eikonal solvers, the graph method, wavefront construction and a combined FD and
Runge–Kutta method.
The main points of investigation are computational time, accuracy and memory
requirements. We took measures to obtain a high level of both general validity and clear
understanding of the results. We used a profiling program to be able to measure the
time that the actual core algorithm needs, thus avoiding any overhead of highly system-
dependent in-/output operations.
The comparison shows that no single method is the most appropriate but that the
choice depends on the task to be fulfilled. The FD eikonal solver that uses expanding
squares proves to be best suited for models which are not too complicated because it
offers the best compromise between speed and accuracy, whereas wavefront
construction should be applied to complex media because of its superior reliability
which then justifies the much higher computational times.
Introduction
The calculation of traveltimes is a basic operation for several important fields of applied
geophysics and seismology, for instance tomography, earthquake location and prestack
Kirchhoff depth migration. With the advent of more and more powerful computer
systems with faster CPUs and growing amounts of core memory during the last years,
prestack Kirchhoff migration also became possible not merely for small (test) models
but also for real large-scale surveys. However, speed of computation is still a very
important factor, especially with respect to prestack Kirchhoff migration, since here
traveltime calculation is iterated as many times as there are surface locations. If we look
not only at large-scale two-dimensional (2D) surveys but move on to three dimensions
1
Received March 1997, revision accepted September 1998.
2
Universität Hamburg, Institut für Geophysik, Bundesstraße 55, 20146 Hamburg, Germany.
3
Tel Aviv University, Raymond and Beverly Sackler Faculty of Exact Sciences, Department of Geophysics
and Planetary Sciences, 69978 Tel Aviv, Israel.
q 1999 European Association of Geoscientists & Engineers 269

270 A. Leidenfrost et al.
(3D), the number of points for which traveltimes have to be computed increases
immensely and with it the CPU time required. Accuracy is another decisive factor as
inaccurate traveltimes result in an inaccurate image which, for example, may entail
costly mispositioned drillings. Memory requirements, finally, become interesting when
a number of traveltime arrays are to be computed simultaneously on a multiprocessor
system and also when considering the extension to 3D.
The tools available to fulfil the task of grid-based traveltime computation use a
variety of algorithms. Since we were looking for a fast and accurate traveltime
calculation method to carry out prestack Kirchhoff migration, we decided to compare a
variety of 2D methods. The selected methods are in detail:
X a finite-difference (FD) eikonal solver in Cartesian coordinates (Vidale 1988)
(referred to as FD method in Cartesian coordinates or FD Cartesian);

X a reimplementation of Vidale’s (1988) method in polar coordinates (referred to as
FD method in polar coordinates or FD polar);

X an FD eikonal solver whose formulae and computational scheme are based on
Huygens’ principle and which, therefore, is suitable for massive parallelization

(Podvin and Lecomte 1991) (referred to as parallelized FD method or FD parallel);
X the network ray-tracing method originally introduced by Saito (1989) and Moser
(1991) and improved by Klimes̆ and Kvasnic̆ka (1994) (referred to as graph method
or Graph);
X the wavefront construction method by Vinje, Iversen and Gjøstdal (1993) in a
reimplementation by Ettrich and Gajewski (1996) (referred to as wavefront

construction or WFC);
X a reimplementation of Reshef and Kosloff’s (1986) combined FD and Runge–Kutta
method in polar coordinates (referred to as FD Runge–Kutta method or FD R-K).

To achieve maximum comparability, all investigations are carried out on the same
platform, a Sun SPARC20 workstation with 128 MB of core memory. With the
exception of the FD Runge–Kutta method a profiler is used to measure the
computational times of the core algorithms independently of any overhead caused, e.g.
by in-/output activities. Accuracy is determined by comparison with either an available
analytical solution or with a solution for which an error estimation exists. However,
benchmarking of any kind has its limitations. Some remarks about the general
applicability of benchmarking follow in the next section.
All of the tested implementations are grid based, i.e. they take a regular gridded
velocity model as input and compute traveltimes to each point of the grid, not merely to
a number of receivers. The methods are applied to two different models. In the first
model, a constant-slowness square gradient model, we can compare the results with the
analytic solution. The second is a more realistic model, the Marmousi model (Versteeg
and Grau 1991).
Considerations on benchmarking
Before comparing the methods, we will make some general remarks about
q 1999 European Association of Geoscientists & Engineers, Geophysical Prospecting, 47, 269–297
Comparison of traveltime methods 271
benchmarking. This is in order to put the reader in a position to judge the results shown
here and their unavoidable limitations more objectively.
Benchmarking of numerical algorithms in general suffers from the lack of some
properties usually associated with an ‘experiment’ in natural sciences. First of all, there
is reproducibility of the results which requires an identical environment for the
benchmarking to take place. Environment here comprises both hard- and software.
The influence of a small change in computer hardware, e.g. a different hard disk drive,
or in software, e.g. the (version of the) operating system or compiler, may have a large
impact on the benchmarking results. As there exist only a few nearly identical computer
installations, the general acceptance of benchmarking results suffers. We have used a
Sun SPARC20 workstation, a fairly widely used platform. Moreover, we did some tests
with the GNU FORTRAN77 compiler on a Pentium PC running GNU/Linux, a free
UNIX clone. This cross-check yielded not only similar results in terms of numbers but
also, more importantly, an identical ranking of the tested methods.
Another aspect is the quality of implementation of the numerical methods: a good
algorithm can be programmed badly and (to an extent) vice versa. All of the
implementations used are available in source thus providing the opportunity to check
their qualities. In addition, four of the tested programs were written by the authors and
close contact was established with the developers of the remaining two programs.
A further important point concerns user-definable parameters of an implementation.
The main parameters here are steps in space and time and, additionally, the size of an
initialization zone (see the next section for more details). For a practical investigation, we
use a practical approach to dealing with parameters. Every method is applied to the same
model. This means that steps in space are identical for every method (the FD Runge–
Kutta method, however, uses a radius spacing of 25 m and wavefront construction steps
in time rather than in space). The methods that need an initialization zone (FD Cartesian
and FD parallel) use a zone of the size that yields the best results, i.e. the minimum
average error. The time step for wavefront construction, i.e. the difference in time
between two successively computed wavefronts, is set at 0.01 s, a value that gives a good
compromise between speed and accuracy. Other customizable parameters are set at
values suggested by the respective authors of the implementations.
In summary, we have made a completely practical approach to the comparison of the
different methods. Although certain limitations cannot be neglected, the kind of
investigation applied yielded the information that we were interested in.
Overview of the methods

All the methods take a gridded velocity model as input and give the traveltime at each
point of the grid. However, the physical or mathematical idea and the corresponding
numerical concept vary, as well as particular features and drawbacks.
Among the methods tested, four solve the eikonal equation (given here in 2D):
∂t ∂t 1
¼ ; i ¼ 1; 2 : ð1Þ
∂xi ∂xi v2
Two of the methods use Huygens’ principle and one uses, in addition, Fermat’s
principle. One, finally, is based on the kinematic ray-tracing system which in fact is the
solution of the eikonal equation (1) along the characteristics:
dxi
¼ v2 pi ; i ¼ 1; 2; ð2Þ
dt
dpi 1 ∂v
¼¹ ; i ¼ 1; 2 : ð3Þ
dt v ∂xi
With respect to their general applicability, the methods tested can be grouped into
two categories: causal and acausal. Causality in this context refers to a method’s ability
to handle strongly varying velocity distributions. The technical question behind this is
whether an algorithm is built around a (starting from the source) rigidly expanding
(arbitrarily shaped) closed curve where the current traveltime computation takes place
(the calculation front), or not. If this is the case, the model is divided into two regions.
One region (including the source) consists of all points for which traveltimes have
already been computed, the other contains all other points. As the traveltime at every
gridpoint is computed only once, the calculation front forms an impenetrable border
between these two regions such that a wavefront cannot re-enter the already computed
region. This means in practice that the algorithm breaks down for velocity distributions
such as high contrasts or gradients that force the wavefront back into the already
computed region. Three of the methods tested use the concept of a calculation front:
(a) the FD method in Cartesian coordinates, (b) the FD method in polar coordinates
and (c) the FD Runge–Kutta method in polar coordinates. On the one hand this limits
their general applicability to strongly varying models, on the other hand their
performance benefits from the high computational speed of the calculation-front
concept.
FD method in Cartesian coordinates (expanding squares)

The FD method in Cartesian coordinates was originally developed by Vidale (1988).
The basic concept of directly solving the eikonal equation on a gridded model with FD,
however, goes back to Reshef and Kosloff (1986). Vidale’s (1988) method can be
applied to non-smooth velocity models. The algorithm is based on a calculation
scheme of expanding squares starting at a given source location. The four sides of the
current square are timed separately, moving from each minimum to its neighbouring
maxima, thus trying to mimic the propagation of the real wavefront in a simple manner.
The actual traveltime calculation is carried out by numerically solving the eikonal
equation with an implicit second-order central finite-difference scheme. The main
formula assumes a locally plane wavefront.
The use of a rigid rectangular calculation front along which calculation proceeds
rather than tracking an actual wavefront makes the method very fast. However, for the
same reason it is not necessarily causal, i.e. the algorithm in general fails for velocity
√—
contrasts larger than 1 : 2 ; for example, head waves or turning rays (in the case of a
smooth model) with an angle of less than 458 to the vertical axis are not handled
properly. On the other hand, the algorithm can make use of alternative formulae to
proceed, for instance by assuming diffraction. This in turn has a large impact on the
(local) accuracy. Finally, the method is restricted exclusively to computing arrivals that
belong to the minimum traveltime (first arrivals) due to the mathematical properties of
FD solutions of the eikonal equation (Van Trier and Symes 1991).
(Implementation here used by N. Ettrich, Hamburg University, Germany.)
FD method in polar coordinates (expanding circles)

We implemented the FD method in polar coordinates to investigate the chances of
diminishing the problems of Vidale’s (1988) original algorithm in high-contrast
velocity models. The velocity model is remapped from a Cartesian grid to a source-
centred polar grid with a constant radius step of Dr and a variable angle step of Dv to
achieve an approximately constant spatial sampling density. Consequently, starting at
the source, the algorithm proceeds along expanding circles rather than squares. This
generally gives a better match between the calculation front and the actual wavefront
(in a homogeneous medium the match is exact) and additionally makes superfluous
any kind of initialization procedure near the source necessary for the other FD
methods described.
Moreover, if the calculation front impinges on a horizontal interface where a head
wave is generated, there is a chance that the scheme can handle this head wave even for
critical angles less than 458 (Fig. 1). Unfortunately, this behaviour decreases with
Figure 1. While the Cartesian version of Vidale’s (1988) method is strictly restricted to a
minimum critical angle of 458, the polar implementation can handle smaller critical angles bmin.
In the above drawing, bmin is smaller than 458. For a (uniform) Cartesian grid, P2 would lie on the
tangent t yielding bmin ¼ 458 (the diagonal in a square with P1 and P2 as two adjacent corner
points). In the case of a polar grid, however, P2 lies on an arc such that the connection between P1
and P2 is not the tangent t in P1 but the secant at arc c through P1 and P2 which allows for a
smaller bmin.
increasing distance from the source because the curvature of the circular calculation
front also diminishes with increasing distance.
This method has a significant computational overhead due to the necessity of
transforming the velocities from Cartesian to polar coordinates and the calculated
traveltimes vice versa. In addition, the transformations will yield inaccuracies because
the model representation in polar coordinates differs from that in Cartesian
coordinates (e.g. a line-shaped interface parallel to one of the coordinate axes in a
Cartesian grid cannot be described exactly in a polar grid). Nevertheless, it may
produce better results in high-contrast models where the original eikonal solver by
Vidale (1988) fails.
Parallelized FD method
The parallelized FD method by Podvin and Lecomte (1991) solves the eikonal
equation with a finite-difference scheme as in the two methods described above.
However, the numerical scheme, i.e. the formulae and the algorithm used, are based on
Huygens’ principle: the algorithm distinguishes between different propagation modes,
such as transmitted, diffracted or head waves, to time a point. Each of the (allowed)
modes is traced, and the one yielding the minimum traveltime is chosen. The algorithm
continues until none of the newly computed traveltimes are smaller than those already
computed.
On the one hand, this method is slow compared with Vidale’s (1988) algorithm
because each point may be calculated several times and also accuracy can be expected
to be worse as the finite differences applied are of first order only. On the other hand,
the method is highly applicable to parallel computing and does not break down for high
velocity contrasts but handles them by updating the already computed region of the
time field.
(This implementation is by M. Roth and S. Buske (pers. comm.).)
FD Runge–Kutta method in polar coordinates (expanding circles)

The FD Runge–Kutta method in polar coordinates is a transform of Reshef and
Kosloff’s combined FD and Runge–Kutta method (Reshef and Kosoff 1986) from
Cartesian to polar coordinates. The eikonal equation is solved in polar coordinates,
with steps in the radial coordinate r. The derivatives of angle v are calculated by the
one-sided first-order finite differences
∂t tðr; vi þ DvÞ ¹ tðr; vi Þ
¼ ð4Þ
∂viþ Dv
and
∂t tðr; vi Þt ¹ ðr; vi ¹ DvÞ
¼ : ð5Þ
∂vi¹ Dv
To ensure causality, (4) is used when t(r, vi) > t(r, vi þ Dv). Otherwise (5) is used. To
achieve an approximately constant aspect ratio Dr/(rDv), the number of radial grid lines
is increased with increasing radius (similar to the FD method in polar coordinates).
The eikonal equation is solved by the fourth-order Runge–Kutta method.
As the method requires variables on a polar grid, the velocities need to be
interpolated from the Cartesian to the polar grid while the calculated traveltimes need
to be interpolated back to the Cartesian grid as in the case of the FD method in polar
coordinates. For a single output time frame, the mapping procedure can be more time
consuming than the actual solution of the eikonal equation. However, migration
involves the calculation of many time frames, and the mapping weights need to be
calculated only once. This in turn diminishes the impact of the time needed for
mapping on the overall performance for practical applications like migration.
Graph method
The graph method (network ray tracing), originally proposed by Nakanishi and
Yamaguchi (1986), later implemented by Saito (1989) and Moser (1991) and finally
refined by Klimes̆ and Kvasnic̆ka (1994), finds first-arrival traveltimes by using
Fermat’s and Huygens’ principles in a gridded velocity model.
The basic idea is to consider a number of points (preferably but not necessarily
located on a regular, e.g. Cartesian, grid) with interconnections between them, such
that each point is directly connected to its neighbours via straight lines. Each of the
connections between two neighbouring points is weighted with the traveltime
between these two points calculated as a product of the Euclidean distance and the
average slowness between the points. It is possible to determine the traveltime
between two arbitrary points of the grid by simply summing the traveltime weights
of connections that form the path from the starting (source) point to the end
(target) point.
The number of possible paths between two points depends on the number of
gridpoints and on which points are considered to be neighbours. It is generally quite
large. According to Fermat’s principle, the path with the smallest traveltime is the one
best approximating the ray trajectory derived from ray theory, i.e. yielding the desired
first-arrival traveltime. To avoid having to check every possible path Huygens’
principle is used, leading to Dijkstra’s algorithm (Dijkstra 1959). To speed up
Dijkstra’s (1959) algorithm, more precisely implied searches, the data are organized in
a tree-like structure (heap) or split into intervals containing elements with very similar
value (bucketing), the latter being more efficient.
However, the remaining amount of calculation is still very significant, so the
computational time is long. On the other hand, the algorithm is reliable for calculating
first-arrival traveltimes in arbitrary velocity models. Moreover, the program that we
use, implemented by Klimes̆ and Kvasnic̆ka (1994), contains an error estimation (for
this to be accurate, positions of sharp interfaces have to be given to the estimation
algorithm) which proved to be very valuable for the comparison of the methods.
Wavefront construction
The wavefront construction method by Vinje et al. (1993) is essentially based on ray
tracing with all its advantages, such as causality, computation of arrivals that do not
belong to the minimum traveltime (later arrivals) and amplitudes, but it overcomes the
major drawback of standard ray shooting, the poor penetration into shadow zones.
The basic concept of wavefront construction is to propagate a wavefront as a
representation of the endpoints of a number of rays at a given time. To ensure a good
representation of the wavefront the distance between two neighbouring points on the
wavefront must not exceed an upper limit (Ettrich and Gajewski (1996) also
considered a second condition, the deviation in the direction of propagation at two
neighbouring points). If so, a new ray is introduced between these two points resulting
in a new endpoint at only half the distance from the two former neighbours.
Wavefront construction is performed starting at a source point with a sufficient
number of rays. They are propagated by integrating the kinematic ray-tracing system
(equations (2) and (3)) with a time step adapted to the actual velocity gradient that may
subdivide the difference in time between two wavefronts into several segments for the
integration process. The calculation itself can be done for instance by a Taylor
expansion, as proposed by Vinje et al. (1993), or by applying a Runge–Kutta scheme
as in the implementation by Ettrich and Gakewski (1996) used here. However, the way
the ray tracing is carried out is not relevant to the idea of wavefront construction itself.
With little additional (computational) effort, amplitudes can also be computed by
means of dynamic ray tracing. In addition, wavefront construction can deliver virtually
completely accurate data (within the limits of machine accuracy) by choosing very
small steps in both time and space.
However, to perform wavefront construction, the model has to be sufficiently
smooth, i.e. the first derivatives have to be continuous everywhere in the model for
kinematic ray tracing and additionally the second derivatives must be continuous for
dynamic ray tracing. To avoid a time-consuming spline representation as used by Vinje
et al. (1993), Ettrich and Gajewski (1996) computed first and second derivatives at the
gridpoints and interpolated velocities and velocity derivatives bilinearly. Nevertheless,
the method can be rather time consuming, partly due to the necessary interpolation
from calculated raypoints to gridpoints and the Runge–Kutta scheme used in the ray
tracing. However, the time consumption is highly dependent on both the time chosen
and space granularity on the one hand and the model on the other.
Application
We now investigate how the methods tested behave when applied to two different
models, an analytically solvable one and a more realistic one. As indicated above, we
focus on accuracy, computational time and memory usage. Whereas accuracy is
measured on different bases for the two models, the measuring methods for
computational time are identical.
The computational times as shown in Figs 10 and 19 are determined by means of a

profiler which makes it possible to measure accurately the time spent on each part of a
program. The only exception is the FD Runge–Kutta method which is implemented
in the C language and not in FORTRAN77 as were the other five algorithms. For
technical reasons specific to our installation, profiling programs written in the C
language do not work on the platform used, a Sun SPARC20 workstation with
128 MB of core memory. Instead, to measure the computational time used by the FD
Runge–Kutta method, a loop is put around the core algorithm in the program.
Comparisons on the above-mentioned alternative platform, a Pentium PC, with
working profiling for C programs show that the differences between the two
measuring methods are acceptable. The FD Runge–Kutta method is compiled with
GNU’s gcc-2.7.2; all other methods are compiled with Sun’s f77, version SC3.0.1 13.
As the test platform is equipped with two processors, it is important to mention that
all programs are compiled with maximum optimization but to run on one processor
only.
Memory requirements, finally, are treated together for both cases.
Analytically solvable model

The first model to which the methods are applied consists of a constant vertical
slowness square gradient of the form
1
v ¼ p : ð6Þ
a þ bz
This kind of gradient model is analytically solvable. The traveltime t at a given point
(x, z) is given as
2 hÿ 3=2 ÿ 3=2 i
tðx; zÞ ¼ bz þ a ¹ p2 ¹ a ¹ p2
3b
2p2 hppi
þ bz þ a ¹ p2 ¹ a ¹ p2 ; ð7Þ
b
with the square of the ray parameter p being given by
v
u 2 2
u x a 1
u þ bzx 2
b2 x4 x2 a 1 2
2 þ 4 bzx
p2 ¼ t ÿ
2 4
2
¹ ÿ 2 2
þ 2 2
: ð8Þ
x2 þ z2 16 x þ z x þz
Note that turning rays can only be traced up to their turning point since x(z) for
constant p is multivalued.
Computation was carried out on a model consisting of 201 × 201 samples with a 10 m
grid spacing along both the horizontal and the vertical axes, with the source being located
at the top left corner. Assuming that the samples are given on the gridpoints, the model
is a square of 2 km × 2 km. The parameters a and b were chosen as 0.50 s2/km2 and
¹0.22 s2/km3, respectively. Consequently, (6) becomes

1
v ¼ p ; z [ ½0:0 km; 2:0 kmÿ : ð9Þ
0:5 ¹ 0:22z
The time step for the ray tracing in wavefront construction was 0.01 s.
Accuracy
For the gradient model, the accuracy of the different methods is expressed as the
absolute value of the relative error errrel between the analytical solution tana and the
respective method tnum at every gridpoint:
ÿ ÿ
ÿ
errrel xi ; zi ¼ tana xi ; zi ÿ¹ tnum xi ; zi × 100% ; ð10Þ
tana xi ; zi
xi [ ½1; 201ÿ; zi [ ½1; 201ÿ:

The figures in this subsection do not cover the entire model, thus omitting regions
containing rays beyond their turning points for which no closed-form expressions are
available. The plots shown have the following range: xi [ [1, 185], zi [ [50 180].
The small differences between the numerically and analytically computed time fields
make it meaningless to show isochron plots for each method. Consequently, we restrict
ourselves to showing the traveltimes alone as they were computed analytically (Fig. 2).
The following error plots are more instructive showing relative errors as described
above. Note that the absolute value of the relative error is plotted and the error range in
each plot is adapted to the respective method’s error range.
Comparing the error for the FD method in Cartesian coordinates with that in polar
coordinates (see Fig. 9), it can be seen that the maximum error for polar coordinates is
twice that for Cartesian coordinates, whereas for the average error the situation is
reversed. Looking at the error plots of these two methods (Figs 3 and 4), the difference
in behaviour is quite obvious. The FD method in Cartesian coordinates shows two
typical club-shaped high-error regions due to the formulae used which are pure plane-
wave approximations. The error in the FD method in polar coordinates is more or less
restricted to the vertically propagated part of the wavefront (see Fig. 4). This is a
consequence of both the model’s remapping from Cartesian to polar coordinates and
the structure of the FD operators in polar coordinates. However, the maximum error is
still rather small, and the average error is only half that of the FD method in Cartesian
coordinates.
The FD Runge–Kutta method does not have this weakness concerning vertical
incidence (Fig. 6). On the other hand, the chart in Fig. 9 shows an average error more
than four times higher that of the FD method in polar coordinates. This is probably
due to the use of a coarser polar grid and, more importantly, single-sided finite
differences in the FD Runge–Kutta method.
The parallelized FD method has both the highest maximum and average error (see
Fig. 9). The error plot (Fig. 5) shows an error distribution in the shape of two clubs
Figure 2. Isochrons [s] for the gradient model as given by the analytical solution.
Grey-scale background represents the velocity model.
Figure 3. Absolute value of the relative error for the FD method in Cartesian coordinates applied
to the gradient model.
Figure 4. Absolute value of the relative error for the FD method in polar coordinates applied to
the gradient model.
Figure 5. Absolute value of the relative error for the parallelized FD method applied to the
gradient model.
Figure 6. Absolute value of the relative error for the FD Runge–Kutta method applied to the
gradient model.
Figure 7. Absolute value of the relative error for the graph method applied to the gradient model.
Figure 8. Absolute value of the relative error for the wavefront construction applied to the
gradient model.
Figure 9. Absolute values of the relative error for the different methods applied to the gradient
model.
Figure 10. Computational times required by the different methods for the gradient model.
similar to that for the FD method in Cartesian coordinates (Fig. 3) only on a much
higher level. This is due to the use of first-order FD operators only.
The graph method performs well, in terms of both maximum and average error.
Note a similar but much less marked tendency to propagate the maximum error in the
part of the wavefront with near-vertical incidence than in the case of the FD method in
polar coordinates (compare Figs 7 and 4). This is probably due to systematically long
connections between points along the shortest paths. Again, note that the error itself is
still very small.
Wavefront construction, finally, offers both the smallest maximum and average error
(see Fig. 9). However, there is an interference-pattern-like structure of the error (see
Fig. 8) which is strongest near the source. This becomes plausible when considering
the fact that to save computation time only every second point in both directions is
computed via wavefront construction whereas the times in between are derived from
bilinear interpolation.
Computational time
The time chart in Fig. 10 leads to a partly similar and partly different ranking of the
methods from the error chart in Fig. 9.
Here, the graph method is by far the slowest, followed at a distance by wavefront
construction and the parallelized FD method. The fastest method is the FD Runge–
Kutta method followed by the FD methods in Cartesian and polar coordinates.
The high speed of the three latter methods can be explained by their rigidness: every
point is computed directly and only once without checking any conditions. The more
intelligent methods either check the validity of traveltimes as does the parallelized FD
method or they even track the actual wavefront. Both are more time consuming. The
graph method, finally, generates a big overhead by computing a large quantity of virtual
raypaths for every gridpoint of which only one is chosen in the end.
Marmousi model
As a more realistic case we now choose a part of the Marmousi model (Versteeg and
Grau 1991). It ranges horizontally from 3000 m to 9000 m of the original model while
covering vertically the whole range from 0 m to 2990 m. The data set consists of
601 × 300 points and the samples are assumed to be taken at the gridpoints with a grid
spacing of 10 m. The model’s slowness s is smoothed by alternately applying the
following 1D smoothing operator 80 times in the horizontal and vertical directions.
(For the (n þ 1)th iteration,)
sðnÞ ði ¹ 1Þ sðnÞ ðiÞ sðnÞ ði þ 1Þ
sðnþ1Þ ðiÞ ¼ þ þ : ð11Þ
4 2 4
As for the gradient model, a time step of 0.01 s is chosen for the ray tracing in
wavefront construction.
Accuracy
For accuracy measurements in the Marmousi model, we use arrays of the absolute
value of relative errors errrel between traveltimes calculated using the graph method
tgraph and every other method tnum as defined by
ÿ ÿ
ÿ tgraph xi ; zi ¹ tnum xi ; zi
errrel xi ; zi ¼ ÿ × 100% ; ð12Þ
tgraph xi ; zi
xi [ ½1; 601ÿ; zi [ ½1; 300ÿ:

We ensured that we were actually comparing errors due to the respective method and
not, or at least only slightly, due to a differently interpreted model representation. We
did this assuming an appropriately sampled model representation, i.e. the velocity
function between two neighbouring samples is monotone. We then created a second
model representation by downsampling the model to the doubled grid spacing and
subsequently re-upsampling it to the original grid spacing by bilinear interpolation. We
compared the times computed with the FD method in Cartesian coordinates in both
models and found average deviations of about 0.03%, which is small in comparison
with the observed traveltime errors for the Marmousi model in Figs 12 to 17. This
result is also valid for the other algorithms as the FD method in Cartesian coordinates
uses the simplest possible approximation of the velocity within a cell, a constant value.
The implementation of the graph method contains an error estimation (see Klimes̆
and Kvasnic̆ka 1994) that yields the error distribution shown in Fig. 12 for the
Marmousi model. Note that, in contrast to the gradient model, the range is equal for
every error plot. From the error chart in Fig. 18, the graph method’s estimated
Figure 11. Isochrons [s] for the Marmousi model as calculated by the graph method.
Figure 12. Estimated absolute value of the relative error of the graph method for the Marmousi model.

Figure 13. Absolute value of the relative error between the graph method and the FD method in Cartesian coordinates for the
Marmousi model.
288
A. Leidenfrost et al.
Figure 14. Absolute value of the relative error between the graph method and the FD method in polar coordinates for the
Marmousi model.
Figure 15. Absolute value of the relative error between the graph method and the parallelized FD method for the
Marmousi model.
290
A. Leidenfrost et al.
Figure 16. Absolute value of the relative error between the graph method and the FD Runge–Kutta method for the
Marmousi model.
Figure 17. Absolute value of the relative error between the graph method and the wavefront construction for the
Marmousi model.
maximum error is 0.8%, the average error 0.3%. Although this indicates that the graph
method is not really accurate, the error estimation allows for independently dividing the
tested algorithms into at least equally accurate (with respect to the graph method) and
less accurate ones. Again, only the traveltimes for the reference solution are shown in
Fig. 11.
For the Marmousi model the error in the FD method in Cartesian coordinates (Fig.
13) is generally very small; in fact, it has the smallest average error of all the methods.
However, due to necessary initialization there is a rather large high-error area around
the source location. Moreover, there are two strips of higher error in the two bottom
corners of the model. In these areas, the real formula breaks down due to acausalities
caused by too high velocity contrasts making the use of a less accurate substitute
formula necessary.
Here, the FD method in polar coordinates proves to be superior (Fig. 14). Apart
from a spot at the right border, the error is small everywhere in the model. On the other
hand, the average error is nearly twice as high as for the FD method in Cartesian
coordinates. This, again, is due to necessary interpolation during coordinate
transformation.
The error in the parallelized FD method in Fig. 15 shows club-like structures
pointing away from the source containing high errors. They are due to initialization
and strong wavefront curvature near the source. The average error also exceeds that of
every other method except for the FD Runge–Kutta method, by at least two times.
For the error in the FD Runge–Kutta method as shown in Fig. 16, the average is
again doubled in relation to the average error for the parallelized FD method. By
contrast, the maximum error is smaller for the FD Runge–Kutta method than for the
parallelized FD method. It is still the second highest of all tested methods.
Finally, wavefront construction in Fig. 17 has an error distribution similar to that of
the FD method in polar coordinates but without the failure at the right border. Again,
there are two reasons for the amount of error still remaining: the interpolation of the
calculated traveltimes to the Cartesian grid plus the fact that only every second time
sample is calculated via wavefront construction whereas all remaining samples are
derived from bilinear interpolation for the sake of speed. The effect of interpolating
traveltimes can be seen very clearly at the source (see Fig. 17). Inside the rectangular
low-error region around the source, times at every gridpoint are directly computed via
wavefront construction. The edge of this box marks the beginning of the use of
interpolation. This is also the location of the fairly high maximum error (see Fig. 18).
Computational time
The time chart in Fig. 19 gives a rather different ranking compared with that obtained
from the accuracy considerations in the previous section.
Here, the fastest is the FD Runge–Kutta method followed by the FD method in
Cartesian and polar coordinates. However, when rating the numbers for the FD
methods in Cartesian and polar coordinates, it must be taken into account that only the
performance of the core algorithm is measured. Consequently, if we have a Cartesian
Figure 18. Absolute value of the relative errors between the graph method and every other
method for the Marmousi model. Bars for the graph method indicate error as estimated by the
error estimation included in the graph method.
Figure 19. Computational times required by the different methods for the Marmousi model.
velocity model and if we also want the traveltimes on a Cartesian grid, the FD method in
polar coordinates will have to transform the data once before and once after the actual
calculation. This, of course, will prolong the whole calculation thus largely diminishing the
method’s attractiveness. Basically, the situation is similar to the FD Runge–Kutta method.
The actual implementation, however, calculates a complete set of transformation weights
once, so that computation time is saved when a large number of shots have to be
computed as is the case, for example, in prestack Kirchhoff migration.
The next two methods, wavefront construction and parallelized FD method, are
about one order of magnitude slower. Between the fastest, the FD Runge–Kutta
method, and the slowest, the graph method, there is a difference of two orders of
magnitude.
Memory requirements
The memory requirements for a particular method can become important when
considering the calculation of large 2D or 3D time fields. Another point worth
mentioning is multithreading on multiprocessor workstations, for instance when
calculating traveltimes for prestack Kirchhoff migration from a large number of surface
locations. Each running process addresses its own memory (apart from the input
velocity model in the case of a shared memory architecture system), such that global
memory requirements can be considered. These depend nearly linearly on the per
thread requirements.
Memory used by a system is divided into memory used to store the actual program
code and memory used to store the necessary data. For larger problems the former is
generally negligible. It must also be taken into consideration that often only parts of the
program code as well as parts of the data are needed at a certain time during program
execution. This amount of memory has to be physically located in core memory to
enable the program run. It is the quantity we use to measure memory requirements as
they are shown in Fig. 20. The complete data set is kept in core memory during
program execution: there is no paging. This applies to every method tested here.
The measurements are not literally exact. They were not taken by means of a
memory profiler or the like, but by using a common UNIX tool called top, which gives
the amount of core memory in use when running a program. This information is
refreshed in selectable time intervals, such that changes during the execution of a
process become visible. Moreover, it is worth mentioning that memory requirements
may depend on the optimization level the compiler used while building the executable
code from the source code. As we use code compiled with maximum optimization, we
use the same code when examining memory requirements. The method’s memory
requirements when applied to the gradient and the Marmousi model (the difference in
size between the two models is about 0.5 MB) are shown in Fig. 20. The numbers are
peak values measured with the procedure described.
The most economic method with respect to memory requirements is the graph
method. On the other hand, it has a mid-range per-gridpoint memory demand similar
Figure 20. Memory usage of the different methods for the gradient and the Marmousi models.
to the parallelized FD method and the FD Runge–Kutta method. In terms of memory

per added gridpoint, the FD method in Cartesian coordinates clearly performs best,
although it has rather high base memory requirements. Both the FD Runge–Kutta
method and FD method in polar coordinates need memory to carry out the
transformation from Cartesian to polar coordinates and vice versa. This explains their
higher per-gridpoint requirements in comparison with the other FD methods.
Wavefront construction, finally, needs a large base memory and has fairly high per-
gridpoint demands. In the case of wavefront construction, however, it must be
remembered that additional information such as amplitudes can be obtained with
nearly no extra effort, at least in the case of the implementation by Ettrich and Gajewski
(1996) used here.
Conclusion
The methods investigated have very different features, qualities and disadvantages.
The measured quantities, i.e. accuracy, computational time and memory require-
ments, vary by up to two orders of magnitude. This emphasizes and enforces the fact
that the right choice of traveltime calculation algorithm is crucial in the framework of a
task such as prestack Kirchhoff migration for both accuracy and performance.
The FD method in Cartesian coordinates and the wavefront construction method
have proved to be the two most appropriate algorithms. The former is, in general,
sufficiently accurate although it fails for high velocity contrasts, and it is very fast. The
latter is especially appropriate for complex smooth media due to its particular precision
and robustness. In addition, wavefront construction can also be used to calculate later
arrival traveltimes which can have a large impact on image quality (Geoltrain and Brac
1993). Finally, there is a possibility of amplitude calculation leading to weights used in
true-amplitude migration. The effect of the smoothness of the input model on the
sensitivity of performance has not been investigated.
The FD Runge–Kutta method is even faster than the FD method in Cartesian
coordinates. However, the accuracy at least in certain regions of the Marmousi model is
rather poor. Nevertheless, this can be neglected if, for example, a cone-shaped aperture
is applied, because large inaccuracies mainly appear in the left and respectively right
top parts of the Marmousi model. On the other hand, the error in the method might
depend on the model, when high-error areas could be within an aperture cone.
The remaining three methods do not have significant advantages over the
aforementioned methods, either in accuracy or in performance.
Outlook
We are in the process of extending this comparison from 2D to 3D. First results show
that for instance Vidale’s (1988) method in 3D is slower than expected when simply
taking into account the number of gridpoints computed. This is due to the substantially
different algorithm for the 3D case. Other methods can be expected to behave in a
similar way or even with a much more dramatic loss of performance. For instance, we
expect wavefront construction to behave in this way. However, this is a subject for
further detailed investigations.
Acknowledgements
The authors are obliged to Ludĕk Klimes̆ and Michal Kvasnic̆ka as well as Stefan
Buske and Michael Roth for making available their programs.
Further thanks go to Ludĕk Klimes̆ for additional reference calculations with his
second-order method (Klimes̆ 1996) and interesting discussion.
The research was supported by the German Israeli Foundation within the
framework of the project ‘Computation of traveltime fields in 3D media’ under
grant I 0270-009.08/93.
References
Dijkstra, E.W. 1959. A note on two problems in connection with graphs. Numerical Mathematics
1, 269–271.
Ettrich, N. and Gajewski, D. 1996. Wavefront construction in smooth media for pre-stack depth
migration. Pageoph 148, 481–502.
Geoltrain, S. and Brac, J. 1993. Can we image complex structures with first-arrival traveltime?
Geophysics 58, 564–575.
Klimes̆, L. 1996. Grid travel-time tracing: Second-order method for the first arrvials in smooth
media. Pageoph 148, 539–563.
Klimes̆, L. and Kvasnic̆ka, M. 1994. 3-D network ray tracing. Geophysical Journal International
116, 726–738.
Moser, T.J. 1991. Shortest path calculation of seismic rays. Geophysics 56, 59–67.
Nakanishi, I. and Yamaguchi, K. 1986. A numerical experiment on nonlinear image
reconstruction from first-arrival times for two-dimensional island arc structures. Journal of
Physics of the Earth 34, 195–201.
Podvin, P. and Lecomte, I. 1991. Finite difference computation of traveltimes in very contrasted
velocity models: A massively parallel approach and its associated tools. Geophysical Journal
International 105, 271–284.
Reshef, M. and Kosloff, D. 1986. Migration of common shot gathers. Geophysics 51, 324–331.
Saito, H. 1989. Travel times and raypaths of first-arrival seismic waves: Computation method
based on Huygens’ principle. 59th SEG meeting, Dallas, USA, Expanded Abstracts, 244–
247.
Van Trier, J. and Symes, W.W. 1991. Upwind finite-difference calculation of seismic traveltimes.
Geophysics 58, 1157–1166.
Versteeg, R. and Grau G. (eds) 1991. The Marmousi Experience. Proceedings of 1990 EAEG
Workshop on Practical Aspects of Seismic Data Inversion, Zeist, The Netherlands. EAEG.
Vidale, J. 1988. Finite-difference calculation of traveltimes. Bulletin of the Seismological Society of
America 78, 2026–2076.
Vinje, V., Iversen, E. and Gjøstdal, H. 1993. Traveltime and amplitude estimation using
wavefront construction. Geophysics 58, 1157–1166.

Comparison of Six Different Methods For Calculating Traveltimes

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Comparison of Six Different Methods For Calculating Traveltimes

Uploaded by

Copyright:

Available Formats

Geophysical Prospecting, 1999, 47, 269–297

Comparison of six different methods for calculating

q 1999 European Association of Geoscientists & Engineers 269

(referred to as FD method in Cartesian coordinates or FD Cartesian);

FD method in polar coordinates or FD polar);

Huygens’ principle and which, therefore, is suitable for massive parallelization

reimplementation by Ettrich and Gajewski (1996) (referred to as wavefront

method in polar coordinates (referred to as FD Runge–Kutta method or FD R-K).

Overview of the methods

FD method in Cartesian coordinates (expanding squares)

FD method in polar coordinates (expanding circles)

FD Runge–Kutta method in polar coordinates (expanding circles)

The computational times as shown in Figs 10 and 19 are determined by means of a

Analytically solvable model

¹0.22 s2/km3, respectively. Consequently, (6) becomes

xi [ ½1; 201ÿ; zi [ ½1; 201ÿ:

xi [ ½1; 601ÿ; zi [ ½1; 300ÿ:

Comparison of traveltime methods 287

to the parallelized FD method and the FD Runge–Kutta method. In terms of memory

You might also like