a. Governing equations

We formulate the model on a section of the sphere, transforming longitude λ and latitude ϕ to Cartesian coordinates x and y via the Mercator projection,

View Expanded

where a is the radius of the earth, so the projection is true at (λ_c, ϕ_c) where (x, y) = (0, 0). The model consists of the modified barotropic vorticity equation

View Expanded

where the relative vorticity ζ and streamfunction ψ are related by

m²²γ²ψζ.(3)

Here ∇² = ∂²/∂x² + ∂²/∂y², β = 2Ωa⁻¹ cosϕ (with Ω the rotation rate of the earth), and m = cosϕ_c/cosϕ is the map factor. The β-plane approximation is recovered by setting m = 1 and β = 2Ωa⁻¹ cosϕ_c. There are two quasi-physical parameters: the diffusion coefficient ν, and the parameter γ (inverse of the effective Rossby radius), which helps prevent retrogression of ultralong Rossby waves. The model domain is a rectangle in x and y centered at (x, y) = (0, 0). At the boundaries we specify the streamfunction ψ (and thus the normal component of the velocity); where there is inflow, we also specify the vorticity ζ. With these conditions the problem is well posed (Oliger and Sundström 1978).

b. Discretization

The space discretization uses second-order finite differences on uniform rectangular grids (as detailed below), approximating the advection terms by the Arakawa Jacobian (Arakawa 1966). Details of the boundary discretization are given in Fulton (1997). On a uniform grid with mesh size h in x and y, the space-discretized approximations to (2) and (3) can be represented in the form

View Expanded

where the grid functions ψ^h and ζ^h consist of the values of the approximate solution on the grid h.

The time discretization uses the classical fourth-order Runge–Kutta (RK4) scheme; this is highly accurate, allows relatively large time steps for stability, and—since it is a one-step scheme—is easy to implement and has no spurious computational modes. This scheme involves four stages per time step, each of which predicts a new value for ζ^h via (4) and solves (5) for the corresponding ψ^h.

c. Grid structure and local time stepping

The above discretizations are embedded in an adaptive method that includes local refinements in both space and time, superimposing nested uniform grids with different mesh sizes to adapt the resolution near the storm. The base grid G₁ with mesh size h₁ covers the entire computational domain, while successively finer patches G_l with mesh sizes h_l (l = 2, . . . , n) cover smaller nested areas as shown in the example in Fig. 1. We use the mesh ratio h_l−1/h_l = 2 (to facilitate multigrid processing), and require the patches to be strictly nested (fine grid contained in the interior of the next coarser grid) and aligned (patch boundaries coincide with coarse-grid lines). For simplicity, we allow only one region of refinement (i.e., one grid patch per mesh size), but this is not a fundamental limitation of the method.

The time stepping algorithm uses local time stepping, that is, smaller time steps on finer grids; this algorithm is similar to that used in most nested-grid models (e.g., Berger and Oliger 1984; DeMaria et al. 1992). Specifically, with two grids (coarse and fine) one full time step is executed as follows:

1. one step (length Δt) on the coarse grid;

2. two steps (length Δt/2) on the fine grid, using boundary values interpolated from the coarse grid in space (ζ^h linearly and ψ^h by cubic interpolation) and time (linear interpolation); and

3. transfer the fine-grid solution to the coarse grid where they overlap (ψ^h by injection and ζ^h by full weighting).

d. Multigrid solution for streamfunction

To solve (5) efficiently for the streamfunction ψ^h on any computational grid G_l we use a multigrid method. This uses point Gauss–Seidel relaxation with red–black ordering, full weighting of residuals, bilinear interpolation of corrections, and the full multigrid (FMG) algorithm with one V(1, 1)-cycle per level and bicubic initial interpolation. As these elements are all standard, the reader is referred to Fulton et al. (1986) and the references therein for details. The resulting algorithm solves accurately for the streamfunction, producing residuals smaller than the truncation error; the computational work is comparable to about eight relaxation sweeps on the finest grid and, overall, accounts for about two-thirds of the total execution time of the model.¹ Numerical results show that using more sweeps per cycle (or more cycles) produces smaller residuals but no significant improvement in the track error and, thus, is not worth the extra computational expense.

When used in the context of the adaptive grid structure described above, the standard multigrid approach is modified in several ways that deserve mention. First, with local time stepping, the next coarser grid G_l−1 may be at a different time t (e.g., at the end of time steps 2, 3, and 6 in Fig. 2). In this situation the main computational grids cannot be used for multigrid processing. Instead, for each computational grid G_l we use an additional set of coarse grids with mesh sizes 2h_l, 4h_l, 8h_l, etc., covering the same domain as G_l (Fulton 1997). These “local coarse grids” may be used in two ways. The Berger–Oliger (BO) method uses them at all times, resulting in only one-way interaction between the grids:the fine grid uses boundary values from the coarse grid (step 2 in the algorithm above), but its effect is felt on the coarse grid only through the solution transfer in the overlap region at the end of the time step (step 3 above). In contrast, the multigrid (MG) method uses the full computational grid G_l−1 instead of the first local coarse grid during multigrid cycling in the final RK4 stage of the second fine-grid time step (e.g., at the end of time steps 4, 5, and 7 in Fig. 2). This results in automatic two-way interaction between the computational grids, since fine-grid information can affect the entire coarse grid immediately through the relaxation process. Preliminary results (Fulton 1997) showed that the differences between these two methods are generally small; further experimentation (see section 4d) shows some improvement with the MG approach, so that is used in all other results presented here.

Third, to properly represent the net fine-grid vorticity on the coarse grid when the grids are nested, a correction must be applied at the grid interfaces. As shown by Bai and Brandt (1987), this correction is accomplished by setting the coarse-grid vorticity at the grid interface to be

View Expanded

Here B^2h_h is the one-dimensional full weighting operator along the boundary and D^2h_n is the one-sided difference approximation (over grid length 2h) to the outward normal derivative.² For example, at a point along the eastern boundary of a fine-grid patch indexed in x and y as (b, j) on the fine grid and (B, J) on the coarse grid, we have

View Expanded

where ψ̃^2h = Î^2h_hψ̃^h is the initial FAS approximation on the coarse grid. Other than the correction (8), no special treatment is required at the grid interfaces; in particular, no extended overlap or transition region is used or needed.

a. Basic regrid strategy

The MUDBAR model regrids, that is, chooses patch sizes and locations adaptively, by estimating the truncation error and placing the grid patches where the truncation error is large. The regridding algorithm is embedded in the local time stepping algorithm of section 2c as follows (see Fig. 3). Before starting a time step on a given grid with mesh size h—here considered to be the “coarse grid”—the truncation error is estimated (see section 3b). Points where the truncation error is large (see section 3c) are flagged for refinement, as indicated by × in Fig. 3a. Second, after the time step is complete the truncation error is again estimated and large values are flagged for refinement, as shown in Fig. 3b. Third, the smallest acceptable patches at the beginning and end of the step are determined (dotted and dashed outlines, respectively, in Fig. 3), and a suitable fine-grid patch with mesh size h/2 is chosen to cover both of these (solid outlines in Fig. 3b). Finally, that patch is “filled” with values of the vorticity ζ^h/2 and streamfunction ψ^h/2. The patch so constructed is then used for the two fine-grid time steps that coincide with the single time step originally taken on the coarse grid.

This process is repeated recursively; that is, during each of the two fine-grid steps a size and location are chosen for the next finer patch (if needed), proceeding to increasingly finer grids until either further refinement is not needed or a specified maximum number of grids is reached. This recursion is illustrated in Fig. 2, where the solid circles denote times at which the truncation error is estimated. For example, the truncation error on level l = 2 is computed before and after time step 5 (at t = Δt/2 and t = Δt, respectively) and used to determine the location and size of the next finer patch l = 3 for time steps 6 and 7 (from t = Δt/2 to t = Δt). Since grid patches are chosen “from scratch” at each time step, refinements are produced locally in both space and time:if at any time a new level of refinement is needed (or a current level is no longer needed), this is automatically detected and the grid patch is created (or deleted) as needed.

To fill a given patch, the vorticity ζ^h/2 is set by copying values from the previous version of that grid (if any) where they coincide and using bilinear interpolation from the coarse grid where the fine grid is new; at t = 0 the specified initial vorticity is used instead. The streamfunction ψ^h/2 is set likewise except that bicubic interpolation is used; if the patch is new (e.g., at t = 0), then ψ^h/2 is obtained instead by solving (5) with boundary values interpolated (cubically) from the coarse grid. During model initialization at t = 0, adaptive grids are constructed by starting with a specified base grid and constructing patches as dictated by the truncation error as outlined above. If the first patch covers most of the base grid (i.e., the base grid resolution is inadequate), this patch is extended to the full domain to replace the base grid and the process is repeated. Once the initial grids are set—and thus the fine-grid information has influenced the solution on all coarser levels—a second pass through the grid adaptation algorithm is made to take advantage of that fine-grid information.

Even though new grids are chosen for each time step on each level, the regridding process adds surprisingly little overhead to the execution time. All calculations required for regridding (estimating the truncation error, choosing the grid, and filling it by copying and/or interpolation) typically amount to less than 2% of the total execution time of the model. This slight overhead is more than made up for by the fact that the grid chosen at each step on each level is precisely the size needed for the entire step, and no larger. Indeed, a simpler scheme based on regridding on all levels only at the end of each base-grid time step regrids much less often but must choose larger patches (since they must be adequate for several fine-grid time steps) and thus takes more time (typically 20%–30% more).

The model also includes an option for using movable grids, that is, fixed patch sizes specified in advance. This differs from the preliminary version described in Fulton (1997) in that the patch locations are now chosen for an interval in time, rather than an instant. This is done by finding the vortex center at the beginning and end of the coarse-grid time step and centering the fine-grid patch for the corresponding two fine-grid time steps halfway between these two points. Except for this choice of patch location (and the fixed size); the regrid strategy with movable grids is identical to that described above for adaptive grids.

b. Truncation error estimates

The truncation error estimate needed for grid adaptation may be computed essentially for free using FAS processing; this idea was introduced by Brandt (1977) and is similar to that described by Skamarock (1989). Specifically, we want to base our grid refinement criterion on the truncation error

τ^hL^hÎ^hψÎ^hζ,(11)

where ψ and ζ represent the true solution of the continuous problem (3) and Î^h represents their pointwise restriction to grid h. It can be shown that the relative truncation error

τ^2h_hζ̂^2hÎ^2h_hζ^h(12)

provides an accurate approximation to the truncation error difference τ^2h − I^2h_hτ^h. In contrast to the analysis of Bernert (1997), we find that with injection as the fine-to-coarse transfer Î^2h_h in (12), this estimate is fourth-order accurate (e.g., Fulton 1989). Since τ^h = O(h²), we obtain the estimate

View Expanded

which has accuracy O(h⁴). Since ζ̂^2h is known only at the coarse-grid points, it is possible to compute τ^2h_h only at the coarse-grid points; however, the estimate (13) is scaled so it is indeed an estimate of the truncation error on the fine grid. Note that while τ^2h_h can be computed from (12) with essentially no work (only one subtraction per coarse-grid point) during the last V-cycle of the FMG method, computing it separately after completing that cycle adds very little work and produces a better estimate of τ^h, since it is based on the final solution for ψ^h (rather than the initial approximation).

c. Patch location and size

Once the points where the truncation error on the coarse grid (mesh spacing h) is large—in the sense of (14)—are located, the boundaries of the fine-grid patch (mesh spacing h/2) must be determined. For simplicity, the model currently uses only rectangular grids (and only one grid per value of h, so only one region is refined), so we can simply determine the smallest rectangles enclosing the large truncation errors before and after the step, as shown in Fig. 3. The tentative boundary of the patch for the full time step is simply the smallest rectangle enclosing both of these (i.e., their convex hull). This boundary may then be adjusted by adding a “buffer” of several grid intervals (usually two) to give some flexibility when the truncation error is highly localized. Finally, the patch size may be increased (or possibly slightly decreased) if needed to achieve good coarsenability, that is, so that the numbers of grid intervals in both directions contain many factors of 2 so the coarsest local coarse grid will be small, thus increasing the efficiency of solving for the streamfunction on the patch. The algorithm employed here uses simple work estimates as detailed in the appendix. In any case, strict nesting of the patch is enforced.

a. Initial conditions

Except as otherwise noted, we use the initial conditions of DeMaria (1985) and associated parameter values as follows. The initial vortex has tangential wind given by

View Expanded

where r = [(x − x₀)² + (y − y₀)²]^1/2 is the radial distance from the vortex center (x₀, y₀). Note that V has the approximate maximum value V_m near r = r_m (exact when a = 0); the exponential factor is included to make V vanish quickly for large r. The vortex can be made slightly elliptical [to introduce some small-scale structure, as in the spiral bands studied by Guinn and Schubert (1993)] by dividing the x or y factor in the definition of r by (1 − e²), where e is the desired ellipticity. We consider two cases: a “weak hurricane” with V_m = 30 m s⁻¹ and r_m = 80 km, and a “strong hurricane” with V_m = 60 m s⁻¹ and r_m = 20 km. For both we use the values a = 10⁻⁶, b = 6, and e = 0.8. The environmental flow is the zonal current with streamfunction given by

View Expanded

The computational domain is a square of side length 4096 km on a β plane centered at latitude 20°N. The vortex is centered initially at x₀ = 768 km and y₀ = −768 km, and we use the values u₀ = 10 m s⁻¹, L = 4096 km, and γ = 0 and ν = 0.

b. Sample solution

Figure 4 illustrates the solution of the model for the weak hurricane case. The left-hand panels of Fig. 4 show the streamfunction ψ and the right-hand panels show the corresponding vorticity ζ. For this run, the base grid has size 64 × 64 (h₁ = 64 km), the exchange rate is λ = 1000, and the grid refinement is limited to three patches, so the finest mesh used is h₄ = 8 km. The boundaries of the grid patches chosen by the adaptive algorithm are shown in the figures. It can be seen that the patch sizes tend to grow slightly during the model run; the apparent slight bias toward refining the grids behind the vortex is likely due to the larger truncation errors in the wake that are characteristic of centered finite differences. This effect could probably be lessened by including a small amount of dissipation; however, the model run shows that no dissipation is needed to achieve reasonable performance. In particular, no problems are observed at the grid interfaces.⁴

c. Accuracy and efficiency

To measure the accuracy of the model in the absence of an analytical solution, we compare the tropical cyclone track to that obtained in a high-resolution reference run with uniform resolution h = 4 km. The track error is defined as the distance between the location of the vortex center (vorticity maximum) and that of the reference run, with the center located by quadratic interpolation using four points surrounding the vorticity maximum on the finest grid (Smith et al. 1990); the mean forecast error is computed over a 72-h model run (using trapezoidal quadrature with a step size of 1 h). Previous experiments (Fulton 1997) showed that with uniform grids the forecast error is O(h²) as expected; with local refinement, the error (as a function of the finest mesh size) is somewhat larger, but still decreases at approximately the proper rate. Here we focus instead on the trade-off between accuracy and efficiency, measuring computational work by the CPU time required for the model run (on a Sun Ultra60 workstation with one 360-MHz processor).

Figure 5 shows the performance of the model for a large number of model runs for the weak hurricane case. Each point shows the mean forecast error obtained for a single run, plotted as a function of the computer time used for that run. The points plotted with plus signs are for uniform-resolution model runs (i.e., a base grid with no finer grid patches) with the indicated resolution. The line joining these points indicates a baseline (uniform grid) performance. The isolated points to the left of this line are for model runs with various combinations of movable grids (i.e., fixed size patches), using essentially every reasonable combination of patches with mesh sizes from h = 128 km to h = 4 km. The points plotted with × are for the adaptive model. These are connected by lines according to the finest mesh size allowed in the run; different points on each line correspond to different values of the exchange rate λ from 10⁴ to 10¹. As the execution time increases monotonically with λ, points on the left side (small time) correspond to large λ, and points on the right side (large time) correspond to small λ.

Figure 5 shows that using local mesh refinement can save a factor of 2 to 50 or more in execution time, depending on the choice of grids used. Some combinations of movable grids work very well; others lead to relatively little improvement. The adaptive grid results show that the errors generally decrease as λ decreases (and CPU time increases), as suggested by the refinement criterion (14). However, there are exceptions. For large λ the error is sometimes unexpectedly low (e.g., the first few points on the left for the h ≥ 16 km curve); these cases probably represent fortuitous combinations of grids obtained in the region before the asymptotic convergence rate O(h²) on which the criterion (14) is based sets in. Similarly, for small λ the convergence “stalls” (e.g., the last few points on the right for the h ≥ 8 km curve); in such cases, the error is as small as possible with the finest mesh size allowed, and obtaining increased accuracy requires allowing finer grids, rather than using smaller λ. Overall, the performance is not particularly sensitive to λ, with values in the range λ ≈ 200–1000 giving good results. The adaptive algorithm usually chooses reasonable grids, although not always as good as the best choices of movable grids shown.

Figure 6 shows analogous results for the strong hurricane case. Since the vortex is both smaller and stronger, errors for a given amount of work are generally larger than in the previous case. Again the adaptive multigrid method chooses reasonable grids; in some cases the savings of execution time (compared to using uniform resolution) approach a factor of 100. Since the vortex is small, adaptive runs limited to h ≥ 16 km and h ≥ 8 km produce little improvement with decreasing exchange rate λ; in order to obtain smaller errors one must allow finer grids. The apparently erratic behavior for the h ≥ 4 km curve is due to two points with particularly good combinations of grids that gave smaller errors than would be expected by the general trend.

Similar results are obtained in other cases. For example, for Fig. 7 the strong hurricane vortex is embedded in a different environmental flow with zonal wind

View Expanded

where u₀ = 10 m s⁻¹ and y₁ = 443.4 km. For this case the vortex is centered initially at x₀ = 768 km and y₀ = 768 km, where the positive Laplacian of the environmental vorticity leads to increased sensitivity of the vortex track to initial position errors (DeMaria 1985). For the small vortex used here, this sensitivity is not evident; the adaptive model performs as well or better than in the other cases.

These results show that the accuracy and efficiency of the adaptive model depends on two factors: the exchange rate λ and the finest mesh size h allowed. Indeed, one could eliminate the mesh size as a factor by simply allowing very fine meshes (e.g., h = 1 km) and leaving it for the algorithm to decide whether or not to actually use grids this fine. For example, in Fig. 5 the adaptive grid curves for h ≥ 4 km and h ≥ 8 km start out identical (for large λ), since the grid with h = 4 km is not needed until higher accuracy is requested (smaller λ). It would be ideal if there were a direct relation between λ and the resulting error, but that appears to be problem dependent. However, this leaves the adaptive model with only one parameter to adjust experimentally to get the desired combination of accuracy and efficiency; in contrast, with movable grids, there are many combinations of patch sizes from which to choose, and the model performance depends heavily on that choice.

d. Effect of two-way interaction

Figure 8 demonstrates the effect of including two-way interaction between the computational grids. Each point represents the difference in mean forecast error between the BO method and the MG method as described in section 2d. The points are plotted as a function of the error produced by the MG method for many runs with different choices of movable grids. The differences between the accuracy of the two methods are small—and can go either way—but when one method is noticeably better (e.g., with error at least one kilometer less), it is usually the multigrid method, which includes two-way interaction.

e. A barotropically unstable vortex

The adaptive multigrid method might be especially advantageous for modeling a vortex that not only moves but has small-scale structure that evolves with time. While the nondivergent barotropic model employed here is incapable of representing the baroclinic effects and convection related to tropical cyclone intensification, it can represent the basic physical process of potential vorticity (PV) mixing. Thus, we consider the case of a barotropically unstable vortex that develops small-scale asymmetries due to chaotic nonlinear PV mixing and evolves toward a smooth symmetric vortex as it moves.

As an initial condition we use the “PV ring” vortex of Schubert et al. (1999) embedded in the zonal current (16). All parameters have the values given in that paper, except for the diffusion parameter ν for which we use the larger value 300 m² s⁻¹, corresponding to an e-folding time of 338 s for a wavelength of 2 km. For this case we run the model with spherical geometry using the Mercator projection (1). We present results of two model runs: one using movable grids and the other using adaptive grid patches (with exchange rate λ = 20). In both cases we start with the base grid size 128 × 128 with mesh spacing h = 32 km and corresponding time step Δt = 20 min. The movable grid run uses six square patches with side lengths ranging from ¹/₄ to ¹/₃₂ of the domain size. The adaptive run is limited to six adaptive grid patches; however, the model rejects the base grid as inadequate and consequently uses the base grid mesh spacing h = 16 km and up to five adaptive grids. Thus, for both runs the model domain is 4096 km square and the finest mesh spacing is h = 0.5 km.

Figure 9 shows the details of the solution computed using movable grids (left panels) and adaptive grids (right panels). Only a region 256 km square centered on the vortex is shown. Since the vorticity is not always maximum at the center of the ring, we define the vortex center as the vorticity centroid (taken over the region where ζ > f, to eliminate bias from the environmental vorticity). These results are quite similar to those of Schubert et al. (1999) up to at least t = 6 h, verifying that the characteristic wavenumber-4 pattern observed in that study is due to the dynamics, and is not an artifact of the periodicity required for the spectral model used in that study. At later times, the solutions are qualitatively similar but differ in detail, as expected due to the chaotic nature of the PV mixing. Comparing the two solutions, we find that the details of the small-scale structure are quite similar; also, the vortex tracks (not shown) differ by only about 7 km over the course of the 72-h model run. However, the run using adaptive grids was six times faster (about 16 min on a Sun Ultra60), since as the solution evolves toward a smooth symmetric vortex the finest grid patches are no longer needed and are automatically discarded.