Propagation integral formulation

For the source flux in Eq (1) we consider a point source. When the point source has a constant flux j that does not vary in time so that (3) where δ(r) is the Dirac delta function, a simple closed form formula exists in terms of the complementary error function [3]: (4) where (5)

However, when the source is not constant over time, Eq (1) must be solved numerically.

One way to attack this problem is via classic finite difference or finite elements methods. Methods like FTCS, BTCS, and Crank-Nicolson produce matrix equations to be solved for the concentration at previously-defined spatial grid points. The choice of grid points is crucial since minimizing the number of points is critical for fast calculation, but accuracy may suffer if the number is too small. The goal of this paper is to provide an alternative solution method that is not based on finite differences or finite elements. This approach propagates the concentration profile in time with a sparse-matrix/vector multiplication, as compared to solving a sparse-matrix equation. Since the grid points in this paper are based on a Gaussian quadrature and an interpolation scheme that are both specifically developed for this diffusion problem, the number of grid points and their locations are optimized in the sense of producing a high-order solution with a minimum number of points.

The approach we use here involves decomposing the concentration into two parts, a source part that adds new particles from the point source during the discretized time interval T_n = (t_n, t_n+1) and a propagation part that diffuses the concentration profile of the last time step through the time interval T_n [3]. That is, (6) where (7) and (8) (9) where χ_n is 0 or 1 depending if the source is off or on during the time interval T_n, respectively, j_n is the flux during T_n, and Δt = t_n+1 − t_n is assumed to be the same for all n. These classic formulas may be found, for example, in Section 8.4 of the book by Barton [3]. (Note that for a half-space problem like flux through an ion channel on one side of a membrane, the denominator includes 2π not 4π because the surface area is half that of the whole sphere.)

Here, the source flux takes the form (10) and is assumed to be constant during the discretized time intervals: (11)

Similarly, χ_n, the on or off state of the source, is the same during the entire time interval [t_n, t_n+1). Note that here we do not assume that the χ_n are known beforehand; for that, an analytic solution of the diffusion equation exists (see Eq (54) later). Here, the on/off state of the source can vary due to random inputs that depend on the concentration profile produced by the source. For example, in CICR, the concentration profile produced by one channel affects the open state of its neighbors, which in turn produce Ca²⁺ profiles that affect the original channel.

It is also important to note that while we assume that j is constant over a time interval, that does not mean we are only considering fluxes that are either on or off or that j must be the same during all time intervals. Specifically, if the source flux is a smoothly varying function, the time intervals T_n should be chosen small enough so that j(t) is well-approximated by the piecewise-constant function j(t) = j_n ≡ j(t_n) if t ∈ T_n. In the notation used here, j_n is the flux during the n-th time interval and χ_n is a random variable that takes values 0 or 1. The χ function is convenient for the case of a randomly on or off source. For a smoothly varying source on the other hand, χ_n = 1 for all n and the j_n are different for different n.

Since the source term is the concentration profile due to the time-independent source flux during the time interval T_n, Eq (9) is just Eq (4) applied to this time interval. In Eqs (7) and (8), the vectors r and r′ (with lengths r and r′, respectively) are three-dimensional locations near the point source. The propagation integral can be simplified by using the relations (12) and (13) to give (14)

The accurate integration of this integral is computationally difficult because it requires knowing the function c(r′, t_n) for all r′ from 0 to ∞. This is generally difficult because one needs at least some prior knowledge about a reasonable finite upper limit and about acceptable grid spacings for the r′. One purpose of this paper is to develop an order N integration scheme for this propagation integral using a Gaussian quadrature.

One important thing to note is that Eqs (9) and (14) are exact solutions of the diffusion equation over a time step Δt. Therefore, Δt can be arbitrarily large. Importantly, it is not constrained by having to be small to numerically approximate a time derivative, as it must be in other methods like FTCS, BTCS, and Crank-Nicolson. Δt is then defined only by the time course of the flux source, the rate at which it turns on and off. This is one way that the propagation method provides an advantage over other existing alternatives. Moreover, because Δt can be anything, the propagation method is unconditionally stable.

Non-dimensionalization

The first step is non-dimensionalizing r with the diffusion lengthscale by defining (15) with a similar definition for R′. One can then define (16) (and similarly for ρ_prop(R, t_n) and ρ_source(R, t_n)) so that the propagator integral (14) becomes (17) with the weight function (18) (19)

For the source concentration, (20) where the flux factor F_n is defined as (21)

Then, (22)

Propagation algorithm

The integral in Eq (17) may be evaluated in a number of different ways (e.g., the Fast Gauss Transform [10]). The alternative approach taken here is to find a set of Gauss-diffusion quadrature (GDQ) points with corresponding weights that both depend on R. Then, (23)

This, however, leads to an infinite nesting of grid point evaluations: (24) (25) (26) This is, of course, not desirable because we want a finite, well-defined set of GDQ points {x_α}. One can overcome this problem by defining a set of grid points between which interpolation is used to evaluate the function at the GDQ points. Specifically, for each R_i, ρ(R_i, t_n+1) can be calculated from Eq (23) after the {x_α(R_i)} and {w_α(R_i)} have been calculated. The interpolation grid and the corresponding GDQ points and weights may be precalculated and saved.

The interpolation used here is a weighted sum of the interpolation points, so that (27)

The interpolation weights depend on z because the R_j are nonuniformly spaced. By Eqs (17) and (23), (28) (29) (30) with the combined weights (31)

In order to express the iteration process in matrix/vector notation, define the column vector (32) and the matrix (33)

Then, (34) for the source column vector (35)

One algorithm for evolving ρ(R, t_n) in time then is:

1. Overhead (before the simulation)
   1. (a) Choose the parameters Δt, the maximum time T of the simulation, and the number of GDQ points N.
   2. (b) Calculate the interpolation grid {R_i} for this T; details are discussed in Subsection Interpolation Grid and Weights.
   3. (c) Compute the source vector s in Eq (35).
   4. (d) For each R_i, compute the GDQ points and weights and ; details are discussed in Subsection GDQ Points and Appendix C.
   5. (e) For each i, compute the interpolation weights ; details are discussed in Subsection Interpolation Grid and Weights and Appendix A.
   6. (f) Compute the combined weights matrix W using Eq (31).
2. (optional) Perform an error checking simulation; details are discussed in Section Error Analysis.
3. Simulation. Starting with ρ(R,0) = c₀R for time t = 0,
   1. (a) evaluate the source state χ_n and flux j_n, possibly based on the concentrations ρ_n from the previous time step;
   2. (b) compute ρ_n+1 from ρ_n using Eq (34).

The overhead is where all the serious programming work goes, specifically to compute the Gaussian quadrature, the interpolation grid, and the interpolation weights. That having been said, however, none of these steps are as difficult as they first appear to be. First, a Mathematica notebook that computes the Gaussian quadrature grid points and weights is available in the Supporting Information (S1 File). Second, programs like Mathematica provide function interpolation routines that can be used in the interpolation grid building strategy described in Interpolation Grid and Weights, thereby requiring little actual programming by the user. Lastly, Fornberg [11] provides an easy-to-implement algorithm for interpolation that, with one tweak, is very fast to compute and easily allows the user to change the interpolation order. The overhead calculations are generally fast, taking a few seconds and, if parallelization is used, less than 1 sec.

At each simulation step, the iteration (Eq (34)) requires a matrix/vector multiplication with the I × I matrix W. However, W is both small and sparse. Generally, W is small because I < 200 is generally sufficient for accurate results. This is because the interpolation grid is nonuniformly spaced and chosen based on knowledge of the exact solution of the diffusion problem, thereby a priori putting extra points where they are needed (Section Interpolation Grid and Weights). W is also sparse because only a small number of neighboring points are used in the Fornberg interpolation. In sample calculations, W ranged from 3% to 42% filled, depending on the number of GDQ and Fornberg points, as well as on the spacing of the interpolation grid points (specifically, the number of near and far points, as defined in Interpolation Grid and Weights). The sparsity of W and the small size of W make the propagation scheme very fast.

Interpolation grid and weights

There are two components to the interpolation used in the propagation algorithm, namely choosing the points {R_i} and choosing an interpolation method. For the latter, we use a method by Fornberg [11] that uses polynomial interpolation between previously chosen points. This was chosen not only because it is easy to implement and quick to compute, but also because changing of the interpolation order N_F (i.e., the order of the interpolating polynomial or, equivalently, the number of nearest-neighbor points around each R_i) is effortless for the user. The technical details are given in Appendix A.

The interpolation grid points should be a minimal number of points, and therefore it would be best to have some knowledge of the mathematical structure of the solution ρ(R, t_n). Luckily, it is possible to derive an exact solution (see Appendix B). Specifically, (36) where (37) While one can use this exact solution, it is computationally impractical because no work from time t_n can be reused for time t_n+1. Therefore, if T timesteps have elapsed, it takes O(T²) operations per location R to compute ρ(R, T) via Eq (36), which becomes slower than the propagation method proposed here after ∼ 100 to 1000 timesteps.

Eq (36) does, however, provide useful information for making the interpolation grid. Specifically, one can find an interpolation grid for the functions e_m(R) for various m and taking their union. This will yield points that are located where they are needed most.

The first step is to find the largest possible distance R_max that could be needed in the simulation that ends at time T_max. This can be determined by considering the worst-case scenario where the current source is on the entire time. R_max should be chosen so that the concentration there is below some chosen threshold ɛ; that is, R_max is the r_max that satisfies (38) or, in nondimensionalized variables, (39) where F_max corresponds to the largest possible flux j_max encountered during the simulation. The interpolation grid then spans [0, R_max].

The second step is to analyze the functions e_m(R). For each m ≥ 1, e_m(0) = e_m(∞) = 0 and e_m(R) has one maximum. Moreover, as m → ∞, the maximum value decays to 0 and so the e_m(R) → 0 for all R. This is shown in Fig 1. The figure shows that the first few e_m(R) are the most important numerically and that their contribution is limited to the interval [0, 10] (approximately). We therefore divide the interval [0, R_max] into two parts, the near (R ≤ 10) and the far (R > 10) intervals. We start with the same uniform grid for each m, but the far interval is divided uniformly on a logarithmic scale while the near interval is divided on a linear scale. That is, [0, 10] is divided uniformly while it is [log(10), log(R_max)] that is divided uniformly. This serves two purposes. First, it focuses the points where e₁(R) has the most structure (Fig 1) and needs to be resolved the best, namely in the near interval. Second, it keeps the number of grid points to a minimum. Since one can have R_max > 5000, using the logarithmic scale places relatively few points in the far interval. More points (e.g., by linearly dividing the far interval) are not necessary because the e_m(R) have little structure in the far interval that needs to be resolved (Fig 1). Also, since R_max increases with T_max, the number of grid points grows logarithmically with T_max.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 1. The functions e_m(R) defined in Eq (37).

The hash marks above the main figure are the interpolation grid points for small I (Simulation 1 in Table 1).

https://doi.org/10.1371/journal.pone.0132273.g001

After dividing the near and far intervals uniformly, the next step is to interpolate the functions e_m(R) on these intervals separately. To do that, polynomial interpolation (usually third order) is used on each subinterval of the uniformly divided interval. Specifically, each subinterval is bisected and both e_m and the polynomial approximation are evaluated at this midpoint. Each interval is further bisected until e_m and the interpolation are within a specified tolerance. This is done for many m and the union of all these interpolation grids is taken. This does not add many points because each m starts with the same uniformly-spaced intervals that are then bisected. Some m (especially the small m) will have more bisection steps because they have more structure, but this does not affect the accuracy of the m that do not have many bisections; in fact it only increases their accuracy. In practice, doing this for m up to 500 suffices, with significantly larger m adding only a few extra points. Fig 1 shows an example grid. It was generated using the Mathematica function FunctionInterpolation, which uses this interpolation scheme.

GDQ points

Gaussian quadrature integration methods are very efficient when numerically integrating a smooth function f(R′) against a weight function Ω(R′) over integration limits a and b by using a weighted sum: (40)

The efficiency over standard integration methods (e.g., the trapezoidal rule) comes from being able to choose the locations R_α as well as the weights ω_α; standard integration methods prescribe the R_α, usually as uniformly-spaced points. With the appropriate choices of N Gaussian weights and points, a polynomial of degree 2N is integrated exactly [12]. In practice, even a small N gives very accurate results if f is a very smooth function like we have here (Eq (36) and Fig 1). For the diffusion problem, N between 10 and 20 works well (discussed in detail later).

The theory of Gaussian quadratures is well-established (see, for example, Ref. [12]) and for many specific choices of Ω, a, and b there are standard techniques for computing the Gaussian weights and points for a given N. These are generally referred to as, for example, Gauss-Legendre (Ω = 1, a = −1, b = 1) and Gauss-Laguerre (Ω = e^−R′, a = 0, b = ∞) quadratures, and so in our case we refer to it as Gauss-diffusion quadrature, or GDQ. Computing a Gaussian quadrature for non-standard weight functions is possible [12], and Appendix C describes in detail how for the diffusion weight function of Eq (18). A Mathematica notebook that computes the GDQ weights and points is included in the Supporting Information (S1 File).

Summary of error analysis

Knowing the accuracy of a simulation method is always important, but there are additional reasons for quantifying the error of the propagation method. First, by using interpolation we are introducing errors into the calculation of ρ_n at every time step and using those results to compute ρ_n+1. It is therefore a real concern that errors accumulate and lead to first-order errors after the many timesteps required for a simulation. Second, when the flux source is randomly on, ρ_n(R) can have local maxima and minima that must be resolved accurately. If they are not, then that error may can lead to spurious results at later times. With the example in the next section we show that neither of these occur when the simulation parameters are chosen well. For the vast majority of simulation parameter sets (i.e., N, N_F, I_near, and I_far) the propagation technique gives very accurate answers, although for some combinations of parameters the ρ_n can diverge. It is therefore important to run these kinds of test simulations.

There are two different checks one can do. The first is a simulation where the flux source is turned on and off randomly and the exact solution in Eq (36) is used to check the result. The second is a simulation where the flux source is always on with a constant flux and the exact solution in Eq (4) is used. Both have pros and cons. With the randomly-on source simulation only relatively small total simulation times T can be checked because the time to calculate the exact solution grows as T², as discussed above. However, with this technique one can explicitly see whether the fine details of the ρ_n(R) profile is reproduced. On the other hand, the advantage of the always-on simulation test is that simulations of arbitrary length can be checked to assure against error accumulation. In the next section, it is shown that the always-on test suffices because it bounds the error; its error is always larger than in the random-on test. One can therefore always run this test to assess simulation accuracy. Moreover, the propagation technique is fast enough that one can test which combination of simulation parameters gives a desired level of accuracy in the fastest time, thereby ensuring accurate results in minimal time. This is important for applications like calcium-induced calcium release were many similar simulations must be done.

Example

To illustrate this, we consider a specific example and examine the errors produced by different parameter choices. Specifically, the point source had a flux of 10⁷ particles per second, which is of the order of the flux through an ion channel (approximately 1.6 pA of current for a univalent ion). The initial concentration c₀ was 0. The time step was Δt = 10⁻⁷ seconds and the diffusion coefficient was 10⁻⁹ m/s², which gives F_n = 6.61 × 10⁻⁵ M for all time steps. A maximum of 10⁶ time steps were considered for all simulations. Solving Eq (39) with ɛ = 10⁻¹⁷ gives R_max = 5148.

All the errors shown here are the maximum absolute difference between the simulated result ρ_sim and the exact result ρ_exact over all R, scaled by F_n: (41)

With this scaling, the exact result is independent of the flux and diffusion coefficient (see Eq (36)). Also, ρ_exact(R, t)/F_n ≤ 1 for all R, and, because it is O(1), −log₁₀(ɛ_sim) is approximately the number of significant figures the simulation has correct. It is important to note, however, that this may not be the error metric of choice for a given problem. In this example, for instance, having a relatively large error with ɛ_sim = 10⁻³ corresponds to a concentration error of 66.1 nM (F_n ɛ_sim), and if nothing in the problem is sensitive to nanomolar concentrations, then having a stricter error requirement like ɛ_sim = 10⁻⁵ is overkill and probably a waste of computational time and effort.

As a first test, we consider different N (the number of Gaussian integration points) and N_F (the number of Fornberg interpolation points) using 173 interpolation grid points (80 near points for R ≤ 10 and 73 far points for R > 10). The results for simulations lasting 10⁴ time steps are shown in Fig 2. The flux source was always on. In general, as N increases, the error decreases. However, the same is not always true for N_F. Usually the error decreases for N_F ≤ 8, but for larger N_F the simulation ρ can diverge (e.g., values > 10¹⁰). This is not unexpected, however, as high interpolation order does not necessarily produce high interpolation accuracy. For example, a constant function is well-approximated by linear interpolation (N_F = 1), but poorly by high-order polynomials because these necessarily require oscillations between the grid points in order to be 0 at the grid points. This is, in fact, what occurs here; the interpolation oscillates far from the flux source where ρ is constant (at 0). As the simulation continues, these oscillations are either damped out for the best results (purple in Fig 2) or amplified for the diverged results (red) (data not shown). If divergence does occur, the user should be aware that small changes in N and N_F can alleviate this problem (Fig 2).

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 2. Error for different N_F (x-axis) and N (y-axis) for simulations lasting 10⁴ time steps.

The flux source was always on. The maximum difference between the simulated ρ and exact solution at all R over all 10⁴ time steps (max_t{ɛ_sim(t)}) is shown on a color-coded log₁₀ scale. Errors larger than 1 were truncated to 1 to make the graph more readable.

https://doi.org/10.1371/journal.pone.0132273.g002

With N = 20 and N_F = 9 that produce accurate results, as a second test we consider the number of interpolation grid points I. More specifically, we consider how the number of near points I_near (for 0 ≤ R ≤ 10, as discussed in Interpolation Grid and Weights) and the number of far points I_far (R > 10) affect the error. Table 1 lists the six cases that were considered, and Fig 3 shows ɛ_sim(t) for the first five cases; the results of Simulation 6 were identical to Simulation 5 except that in Fig 3A it did not have the upswing in error near the 10⁶-th time step that occurs in Simulation 5 (and overlaps with Simulation 2).

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 1. Parameters used in Fig 3.

The circled numbers in Fig 3 correspond to the simulation number (Sim.) in the Table. For each simulation, the number of near (I_near) and far (I_far) interpolation grid points are shown, as well as the sum (I). Simulation 6 is not shown in Fig 3 because it was the same as Simulation 5 except that it did not have the uptick in error at the end of the simulation. For all simulations, N = 20 and N_F = 9.

https://doi.org/10.1371/journal.pone.0132273.t001

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 3. Error versus simulation time for five of the six simulations listed in Table 1.

The circled numbers correspond to the Simulation listed in the table. (A) The flux source is always on. (B) The flux source is randomly on for 50000 time steps. The bars on the right side are the maximum error over 50000 time steps from panel A to show that the error in the always-on simulations bounds the error of the randomly-on simulations. For all simulations, N = 20 and N_F = 9.

https://doi.org/10.1371/journal.pone.0132273.g003

We first analyze the case where the flux source is on at all times (Fig 3A). To make sense of the results, consider Simulations 1, 2, and 3, which differ in the number of far points. At the beginning of the simulation, they overlap. At later times, they separate and eventually Simulations 1 and 2 begin to diverge. This indicates that increasing number of far points increases accuracy at later times. This is consistent with the results of Simulations 4, 5, and 6. Again, they overlap at early times and separate according to how many far points there are; the more far points, the smaller the late-time error. Conversely, the more near points, the smaller the early-time error. For example, compare Simulations 1 and 4 and Simulations 2 and 5. Intuitively, these results make sense: early in the simulation ρ is changing near the source so the near interval is most important, while late in the simulation ρ is changing in the far interval.

In the case just considered, the flux source is always on. However, the propagation technique is designed for fluctuating sources. Moreover, the always-on case does not require the specially-constructed interpolation grid. This is shown in Fig 4 where ρ profiles at different times are shown for a randomly-on flux source. For comparison, the dashed line shows the always-on result at the same time step as the red solid curve. The random-on profiles can have multiple local maxima and inflection points, something not seen for the monotonically decaying always-on profile. Because of the more complicated ρ profiles, it is possible that the error for the randomly-on case is much different than for the always-on case. For example, not resolving those maxima or minima at one time can propagate an error to later times.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 4. ρ(R) for a randomly-on flux source at various simulation times.

It illustrates both the complicated structure of these curves and to show how the interpolation grid points are more dense in the regions that need them. The points are the simulation results and the curves are the exact result. For comparison, the dashed curve is the always-on exact result at the same time step as the red curve. For clarity a very small number of interpolation grid points were used (I = 64).

https://doi.org/10.1371/journal.pone.0132273.g004

Fig 3B shows that this is not the case. In fact, for all six cases considered, the maximum error is always less for the random-on case than for the always-on case. This is very useful because the exact answer is much easier to compute for the always-on case; for the random-on case only about 5 × 10⁵ time steps can be computed in a reasonable amount of time. Bounding the error is also important because it makes it always possible to pre-compute the error; if the details of how the flux source turns on or off are unimportant for measuring simulation error, then one can use the always-on case.

Moreover, one can optimize accuracy versus computation speed by combining all of these error checks. The computation speed of the propagation method is dominated by the matrix/vector multiplication in Eq (34), and because W is sparse, the number of multiplications required is the number of nonzero entries in W. Therefore, one can vary all the parameters above (N, N_F, I_near, and I_far) and plot max_t{ɛ_sim(t)} versus the number of nonzero entries in W. The fastest and most accurate set of parameters can then be chosen for all future simulations. Fig 5 shows this for 336 parameter choices for 10⁶ time steps. The arrow points to the parameter set with the fastest computation time that still achieve high accuracy (max_t{ɛ_sim(t)} ≤ 10⁻⁵), in this case N = 10, N_F = 8, I_near = 25, and I_far = 90 with W having 1356 nonzero entries. Because the propagation method is fast, it is possible to scan this large set of parameters; Fig 5 took approximately 7 hours on a desktop computer with a 6-core 3.33 GHz i7-980X processor using Mathematica version 9 (Wolfram Research, Champaign, Illinois), which could have been significantly faster if done in parallel rather than in series. This time investment is well worth it for applications where a large number of simulations must be done because it guarantees both high accuracy and the fastest overall computation speed for production runs.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 5. Simulation error versus the number of nonzero elements in W (to represent computation time).

Each point is for a different parameter set (N, N_F, I_near, and I_far) for a long simulation of 10⁶ time steps for the example described in the main text with the flux source always on. The arrow points to the optimal balance of high accuracy and computation speed. Errors larger than 1 were truncated to 1 to make the graph more readable.

https://doi.org/10.1371/journal.pone.0132273.g005

To see how this compares to classical methods like BTCS and Crank-Nicolson, one must first consider their mathematical structure. Each discretizes both the time and space derivatives in Eq (1), almost always with uniform spacing Δt and Δr for the time and space coordinates, respectively. This creates a system of linear equations to be solved at each time step with a tridiagonal matrix [12]. Since tridiagonal systems can be solved with O(N_r) operations (N_r is the number of spatial grid points), to be comparable to the propagation method, N_r should be around 1000.

N_r is determined by both Δr and the maximum distance L to be considered. Since the diffusion equation requires both initial and boundary conditions at r = 0 and r = L, one must pick L large enough so that the concentration is (approximately) 0. For the example in this section, R_max = 5148 corresponds to L = 102.96 μm. From Fig 4 one can see that it takes a resolution in R of at least 0.25, which corresponds to 5 nm for the example in this section. Therefore, N_r ≡ ⌈L/Δr⌉ = 20592. Even for such a large system, a simple Crank-Nicolson implementation produced max_t{ɛ_sim(t)} > −4.1, significantly worse than many propagation implementations with suboptimal parameters (Fig 5) and 6 to 45 times as many nonzero matrix entries.