2.6.1 Error Calculation

2.6.2 Computational Effort Calculation

Computational effort is determined by the total number of function evaluations required by a numerical method to complete the simulation.

The number of function evaluations required per time step varies across numerical methods. Explicit Euler and implicit Euler involve a single function evaluation per step. The implicit midpoint method requires two evaluations—one for approximating the midpoint and another for updating the solution. Similarly, the modified Euler or second-order Runge-Kutta method also needs two evaluations per step. In contrast, the fourth-order Runge-Kutta method involves four function evaluations per step, making it more computationally intensive.

2.6.3 Step Size Calculation

2.7.1 Accuracy and Error Evaluation

The accuracy of each method is assessed by comparing the numerical results with the exact solution of the water drainage problem. Both local and global errors are computed to evaluate how the methods perform with varying step sizes. The analysis examines how the error decreases as the step size decreases and explores the trade-offs between error reduction and computational effort.

2.7.2 Error Versus Computational Effort

This is quantified by evaluating the number of function evaluations and the time required by each method to achieve the desired accuracy. The computational cost is compared with the resulting error, providing insight into the efficiency of each method.

2.7.3 Error Versus Step Size

The relationship between error and step size is explored to understand how decreasing the step size improves accuracy and how it impacts computational effort.

2.7.4 Efficiency and Practical Application

The practical aspects of each method are considered, including the ease of implementation, flexibility in adjusting step sizes, and the overall programming effort required. The findings from the above comparison assist in selecting numerical methods for solving similar ODE problems, highlighting the importance of step size and the balance between accuracy and computational efficiency.

3.1.1 Explicit (or Forward) Method

3.1.2 Stability Region of Explicit Euler's Method

The stability of this method is analyzed using the equation is $$$ {y}_{n+1}={y}_n+ hf\left({t}_n,{y}_n\right) $$$. By substituting a test function and performing algebraic manipulation, the stability function, expressed as $$$ R(z)=1+z $$$, indicating stability when $$$ \mid 1+z\mid <1 $$$ as $$$ {y}_{n+1}\to 0 $$$.

3.1.3 Implicit (Backward) Euler Method

3.1.4 Stability Region of the Implicit Euler Method

The stability region of this method is analyzed using Equation (12). By substituting a test function and performing algebraic manipulation, the stability function $$$ R(z) $$$ for the implicit Euler method is derived, where $$$ z=\lambda h $$$ and $$$ \lambda $$$ represents the eigenvalue of the linearized ODE $$$ {y}^{\prime }=\lambda y $$$ [25]. This stability function is expressed as $$$ R(z)=\frac{1}{1-z} $$$, indicating stability when $$$ \mid 1-z\mid >1 $$$ as $$$ {y}_{n+1}\to 0 $$$.

Figure 4 illustrates the absolute stability regions of both the explicit and implicit Euler methods. Shaded areas denote stability, whereas unshaded areas indicate instability. The explicit Euler method exhibits conditional stability, meaning it can be stable for certain step sizes and unstable for others. In contrast, the stability region of the implicit Euler method encompasses the entire complex plane except for the unshaded region. The stability region of a numerical method has significant implications for its physical meaning and its impact on the solution of differential equations. It defines the range of step sizes and system characteristics (via eigenvalues of the system matrix) for which the method produces stable and accurate solutions. For the explicit Euler method, the stability region is a small circle centered at $$$ z=-1 $$$ in the complex plane. Physically, this indicates that the method is conditionally stable, it can only provide reliable solutions for systems where the eigenvalues, scaled by the step size $$$ h $$$, lie within this small region. Consequently, for problems involving fast dynamics or stiffness, where the eigenvalues are often far outside this region, explicit Euler becomes unstable unless an extremely small step size is used. This limitation makes it less suitable for stiff systems or long-term simulations, despite its computational simplicity.

In contrast, the implicit Euler method has a stability region that covers almost the entire complex plane, excluding a small area near $$$ z=1 $$$. This reflects its unconditional stability for most practical problems, even when large step sizes are used. Physically, this robustness allows implicit Euler to handle stiff systems effectively, where rapid changes or dynamics spanning multiple timescales are present. However, this method introduces numerical damping, which stabilizes the solution but can overly dampen oscillatory behavior, potentially reducing accuracy for non-stiff systems.

3.1.5 Implicit Midpoint Method

Consider the following first-order ODE:

$$$$ \frac{dy}{dt}=f\left(t,y(t)\right) $$$$

The implicit midpoint method for solving this ODE can be derived using the Butcher tableau [1]: The steps to derive the implicit midpoint method are as follows:

1. Compute the slope $$$ {k}_1 $$$ using the current values of time and state [23]:
   $$$$ {k}_1=f\left({t}_n+\frac{h}{2},{y}_n+\frac{h}{2}f\left({t}_n,{y}_n\right)\right) $$$$ (13)
   where $$$ h $$$ is the step size, $$$ {t}_n $$$ is the current time, and $$$ {y}_n $$$ is the current state.
2. Update the state using the computed slope $$$ {k}_1 $$$:
   $$y_{n+1}=y_n+h·k_1+𝒪(h^3)$$ (14)

The implicit midpoint method requires only a single starting value, which serves as the initial condition. However, it necessitates iterations to compute the solution at each step in this implementation and it requires evaluating function $$$ f $$$ twice per step.

3.1.6 Modified Euler's (Heun's) or RK2 Method

3.1.7 Stability Region of Heun's Method

The stability of the modified Euler's method, analyzed via above equation. The stability function $$$ R(z) $$$ for the RK2 can be expressed as $$$ R(z)=1+z+\frac{z^2}{2}+\frac{z^3}{3!}+\dots $$$. Stability necessitates $$$ \mid R(z)\mid \le 1 $$$, indicating the region in the stability plane where $$$ \mid R(z)\mid \le 1 $$$ defines the stability region for the RK2 method.

The modified Euler's or Heun's Method, combining the predictions from the predictor and corrector steps to improve the accuracy. It involves a two-step process: a predictor step and a corrector step.

Figure 5 compares the outcomes of water tank drainage system for all Euler methods for a step size of $$$ h=5 $$$. To highlight the differences among the methods, the local error is plotted, distinguishing the variations in the numerical solutions. As observed from the absolute error in Figure 5 and the summary of local errors in Table 2, which depicts the maximum errors of the four numerical methods applied to the water drainage system, it is evident that the implicit midpoint method outperforms the others with the lowest maximum error of 0.004103 m. This result underscores its superior accuracy in approximating the true solution. Conversely, both the explicit and implicit Euler's methods exhibit higher maximum local errors of 0.118394 and 0.112254 m, respectively, indicating reduced accuracy in their predictions. The modified Euler or RK2 method, as expected, yields better accuracy than both implicit and explicit Euler's methods (with a local error of 0.014896 m). When comparing implicit and explicit Euler's methods, implicit Euler's stability stands out, especially in handling stiff ODEs. A stiff ODE is a differential equation that requires an extremely small step size for certain numerical methods to be stable due to rapid variations in the solution [8, 27]. Implicit methods, similar to implicit Euler, are robust and offer accurate solutions for challenging differential equations, making them reliable for scenarios involving complex dynamics and stiff equations. Implicit methods, however, require more computations due to iterative processes, contrasting with the single iteration per step in explicit methods. While explicit Euler is computationally less intensive, modified Euler strikes a balance between accuracy and computational demand, making it popular for practical applications. Additionally, the choice of step size affects solution accuracy. A larger step size results in larger errors, while a smaller step size leads to smaller errors. This analysis is also discussed in the section on predictor-corrector methods in this article.

3.2.1 Stability Region of RK4 Method

The stability of this method is determined by analyzing the RK4 equation. To derive the stability region, a test function is substituted into the method and the function, $$$ R(z) $$$ for the RK4 method is obtained through back substitution into the above equation [8, 9, 11, 12]. For stability, it is essential that $$$ \mid R(z)\mid \le 1 $$$. Its stability region is the region where $$$ \mid R(z)\mid \le 1 $$$.

The absolute region of stability of the RK4 method is broader compared with that of the RK2 and Euler's methods, as illustrated Figure 6 and expands with the order of the RK method. Each shaded region corresponds to the stability region of a specific RK method, including explicit Euler, modified Euler or RK2, and RK4. These shaded areas visually represent where the numerical method maintains stability. The unshaded regions beyond these stability regions indicate areas where the numerical method may become unstable, leading to unbounded growth or oscillatory behavior in the solutions.

As shown in Figure 6, the stability regions: explicit Euler, modified Euler (or RK2), andRK4 provide insight into their behavior in solving ODEs. Each method has a specific stability function, which determines whether the numerical solution remains bounded for a given step size and problem dynamics. For explicit Euler, the stability region is a small circle centered at $$$ z=-1 $$$ in the complex plane, indicating that stability is only achieved for eigenvalues of the system's dynamics matrix (scaled by the step size) that fall within this limited area. Physically, this implies that explicit Euler is conditionally stable and can only handle systems with slow dynamics or non-stiff behavior effectively, as larger step sizes or fast-changing dynamics would lead to instability.

In contrast, modified Euler (or RK2) and RK4 methods exhibit larger stability regions, providing greater flexibility and stability for a wider range of problems. The modified Euler (or RK2) method's stability region is larger than that of explicit Euler but still limited compared with RK4. The RK4 method has the largest stability region among the three, making it suitable for problems requiring higher precision and stability over larger step sizes. However, neither modified Euler (or RK2) nor RK4 can handle stiff problems effectively, as their stability regions remain bounded, unlike implicit methods.

Figure 7 compares the outcomes of water tank drainage system for implicit midpoint Euler's method, modified Euler (or RK2) and RK4 for a step size of $$$ h=5 $$$. To highlight the differences among the methods, the local error is plotted, distinguishing the variations in the numerical solutions. When evaluating the accuracy of each numerical method, as depicted in Figure 7 and summarized in Table 3, the RK4 method demonstrates superior performance with a local error of 0.002099m, outperforming the implicit midpoint Euler's method with a local error of 0.004103m. The results from the implicit midpoint Euler's method are notably better than those of the modified Euler's (RK2) method, which has a local error of 0.014896m. Hence, the RK4 method, known for its higher accuracy, excels in delivering enhanced performance. In numerical methods, particularly for solving differential equations, computational effort and percent relative error are key factors considered when comparing different solution methods. The computational effort is primarily determined by the number of function evaluations required to compute the solution over a given time interval. For Runge-Kutta (RK) methods, the computational effort is proportional to the order of the method, as higher-order methods generally require more function evaluations per step. In this context, the effort is calculated as the number of steps (dependent on the time step size) multiplied by the number of function evaluations per step. For RK2, two function evaluations per step are needed. In RK4, four function evaluations are required per step. The implicit midpoint method, a second-order method, also requires two function evaluations per step, similar to RK2. These computational efforts are used to estimate the run time or time taken to compute the solution, a critical consideration for practical applications.

The percent relative error provides a measure of the accuracy of the numerical solution compared with the true solution (often derived analytically for comparison). It is computed as the average relative difference between the computed solution and the true solution, expressed as a percentage. A lower percent relative error indicates better accuracy of the numerical method.

3.3.1 Euler's Method (Adams-Bashforth One-Step Method)

3.3.2 Adams-Bashforth Two-Step Method

On the other hand, the two-step Adams-Bashforth method requires two starting values, one of which serves as the initial condition of the dependent variable, while the other is typically obtained using a single-step method such as the explicit Euler method. For this specific implementation, it requires evaluating function $$$ f $$$ twice per step for prediction purposes.

3.3.3 Adams-Bashforth Three-Step Method

The accuracy of the three-step Adams-Bashforth method is highly dependent on the precision of the initial values used for the first three steps. In fact, the initial values for higher-order multi-step methods are typically computed using lower-order multi-step methods or alternative one-step methods. Given that these initial values are generally obtained using a one-step method, such as the explicit Euler or RK4 method, any errors introduced during this initialization phase can propagate and adversely impact the overall accuracy of the solution. Consequently, using a more accurate method, such as RK4, to compute the starting values is crucial for enhancing the reliability and precision of the Adams-Bashforth method. Specifically, in the case of the water drainage problem analyzed in this study, the RK4 method was utilized to determine the initial values.

The choice of initialization method, therefore, plays a significant role in determining the performance of the multi-step Adams-Bashforth method. While Euler initialization is faster and simpler, it introduces larger errors, which tend to accumulate over time. Conversely, RK4 initialization provides a higher degree of accuracy, effectively reducing errors and yielding a more stable and reliable solution, as illustrated in Figure 8. Thus, for problems where accuracy is critical, particularly over extended time periods, RK4 initialization emerges as the preferred approach. This method leads to more accurate approximations with fewer errors compared with Euler initialization, underscoring its importance in applications demanding high precision.

3.3.4 Adams-Bashforth Four-Step Method

The fourth-order method uses the current and three previous points $$$ \left({t}_n,{y}_n\right) $$$, $$$ \left({t}_{n-1},{y}_{n-1}\right) $$$, $$$ \left({t}_{n-2},{y}_{n-2}\right) $$$, and $$$ \left({t}_{n-3},{y}_{n-3}\right) $$$. The coefficients $$$ 55,-59,37,-9 $$$ are chosen to achieve a higher-order approximation and requires four function evaluations per step. The four-step Adams-Bashforth method requires four starting values. The first value serves as the initial condition of the dependent variable, while the additional three values are typically obtained using a one-step method, such as the explicit Euler or RK4 method, to initialize the process. This method involves evaluating the function $$$ f $$$ four times per step for prediction. The accuracy of the four-step Adams-Bashforth method is heavily influenced by the precision of the initial values used for the first four steps. These initial values are typically computed using either a lower-order method (such as the three-step Adams-Bashforth) or a one-step method (such as the explicit Euler or RK4 method). However, any errors introduced during this initialization phase can propagate and significantly impact the overall accuracy of the solution. Therefore, using a more accurate method, such as RK4, to compute the starting values can greatly enhance the reliability and precision of the Adams-Bashforth method. In the context of the water drainage problem examined in this study, the RK4 method was utilized to calculate the initial values.

3.3.5 Adams-Bashforth Five-Step Method

This is the fifth-order method, which uses the current point $$$ \left({t}_n,{y}_n\right) $$$ and the four previous points $$$ \left({t}_{n-1},{y}_{n-1}\right) $$$, $$$ \left({t}_{n-2},{y}_{n-2}\right) $$$, $$$ \left({t}_{n-3},{y}_{n-3}\right) $$$, and $$$ \left({t}_{n-4},{y}_{n-4}\right) $$$. The coefficients $$$ 1901,-2774,2616,-1274,251 $$$ are specifically chosen and requires five function evaluations per step. Similarly, the five-step Adams-Bashforth method requires five starting values. The first value serves as the initial condition of the dependent variable, while the additional four values are typically obtained using a one-step method, such as the explicit Euler or RK4 method, to initialize the process. This method also requires evaluating the function $$$ f $$$ five times per step for prediction. The accuracy of the five-step Adams-Bashforth method depends on the accuracy of the initial values used for the first five steps. These initial values, computed using a one-step method, introduce errors that can propagate and impact the overall accuracy of the solution. Therefore, using a higher-order method such as RK4 to calculate the initial values can help improve the overall precision and reliability of the solution. For this study, the RK4 method was utilized to determine the initial values for the five-step Adams-Bashforth method. Theoretically, these methods are explicit and do not involve solving implicit equations, which typically makes them computationally less expensive.

3.3.6 Stability Region of Adams-Bashforth Explicit Methods

In the stability plots in Figure 9, the shaded regions represent the stable areas for each explicit Adams-Bashforth method, where the numerical solution remains bounded and converges. The unshaded areas outside these regions indicate potential instability, where the solution may diverge. As the order of the method increases, the stability region shrinks, meaning higher-order methods are less stable and may require smaller step sizes to maintain accuracy and avoid instability. This illustrates the trade-off between computational effort and stability when choosing an appropriate method for solving ODEs.

As shown in Figure 9, low-order methods (such as the first and second-step Adams-Bashforth methods) exhibit relatively larger stability regions, making them more tolerant of larger step sizes. In contrast, high-order methods (including the third, fourth, and fifth-step Adams-Bashforth methods) have smaller stability regions, necessitating smaller step sizes to maintain numerical stability. Figure 10 compares the outcomes of water tank drainage system for all steps of the explicit Adams-Bashforth method with a step size of $$$ h=5 $$$. To highlight the differences among the methods, the local error is plotted, distinguishing the variations in the numerical solutions. As shown in Figure 10 and Table 6, the results from all steps of the explicit Adams-Bashforth methods show robustness compared with previous methods. Particularly, the 3rd-order explicit Adams-Bashforth method stands out with an absolute error of $$$ 0.7934\times 1{0}^{-15}m $$$, offering the most accurate solution for this problem.

3.4.1 Adams-Moulton Implicit Method Stability

Adams-Moulton methods, being implicit, typically offer larger stability regions compared with explicit methods like Adams-Bashforth. Additionally, this expanded stability region allows Adams-Moulton methods to take larger time steps without losing stability, which can enhance computational efficiency for certain problems. However, their implicit nature requires solving nonlinear equations at each step, increasing memory consumption and computational effort. Furthermore, despite these additional computational costs, Adams-Moulton methods are particularly beneficial in scenarios where larger time steps are necessary to maintain efficiency without sacrificing stability.

The stability region comparison underscores the trade-offs between computational cost and stability as the method order increases. Multi-step methods offer enhanced stability within specific step size ranges (stability zones), which narrow with higher-order methods. Moreover, while implicit methods like Adams-Moulton provide superior stability, they demand greater computational resources, necessitating careful consideration of stability, memory usage, and computational effort, especially in complex systems requiring long simulations.

This discussion highlights the importance of selecting an appropriate numerical method based on the problem's stiffness, accuracy requirements, and available computational resources. Additionally, the balance between stability, accuracy, and computational intensity is crucial in ensuring the efficiency and reliability of numerical solutions in practical applications.

Figure 13 compares the outcomes of water tank drainage system for all implicit Adams-Moulton methods for a step size of $$$ h=5 $$$. To highlight the differences among the methods, the local error is plotted, distinguishing the variations in the numerical solutions. As shown in Figure 13 and summarized in the Table 9, the results obtained from all steps of the implicit Adams-Moulton methods prove to be robust in solving the problem when compared with the previously discussed methods. In the context of this specific problem, the 3rd-order implicit Adams-Moulton Method stands out an absolute error of $$$ 2.5769\times 1{0}^{-7}m $$$ providing the most accurate results compared with the other methods.

4.3.1 Error Versus Step Size

Figure 20 demonstrates the relationship between the error and the step size for each method. As the step size decreases, a reduction in the error is observed for most methods. Smaller step sizes result in more accurate approximations. The RK4 method exhibits a steady decrease in error with smaller step sizes, due to its higher order of accuracy. The implicit midpoint method, though stable for larger step sizes, shows a slower reduction in error compared with RK4, as implicit methods tend to be more stable but less efficient in reducing error. The 3-Step Adams-Bashforth method, being explicit, demonstrates a more significant decrease in error as the step size decreases, though the accuracy remains lower than RK4. Similarly, the 3-Step Adams-Moulton method, which is implicit, shows a comparable reduction in error, but it may perform slightly better than Adams-Bashforth, due to the correction factor. The 3rd-order predictor-corrector method combines both the Adams-Bashforth predictor and Adams-Moulton corrector, resulting in a more consistent and rapid reduction in error compared with the Adams methods, making it highly efficient for smaller step sizes.

4.3.2 Error Versus Computational Effort

Figure 21 compares the error with the computational effort, measured as the number of steps, for selected one-step and multi-step numerical methods applied to the water drainage problem with a fixed step size of $$$ h=1 $$$. For one-step methods, the explicit Euler and implicit Euler methods both require 127 computational units, with the explicit Euler method yielding a higher error of 0.193295 compared with the implicit Euler method's error of 0.192023. The implicit midpoint method, on the other hand, requires 254 units and delivers a much lower error of 0.000798. Among the multi-step methods, the 3rd-order Adams-Bashforth method requires 127 units, yielding an error of 0.003204, whereas the 3rd-order Adams-Moulton method needs 1270 units with an error of 0.003207. The 3rd-order predictor-corrector method demands 1408 units, producing an error of 0.003207. Thus, although the one-step methods such as the explicit and implicit Euler methods require fewer computational steps (127 units), they exhibit higher errors compared with the multi-step methods. The multi-step methods, though computationally more expensive, generally yield much lower errors, with the 3rd-order Adams-Moulton and predictor-corrector methods delivering comparable results at higher computational costs.

Table 11 presents a comparison of various selected one-step and multi-step numerical methods applied to the water drainage problem, with different step sizes ($$$ h $$$), computational effort, and associated errors. The step size ($$$ h $$$) plays a crucial role in determining the computational effort required for each method. As expected, larger step sizes, such as $$$ h=5.0 $$$, generally result in a lower computational effort. For example, Euler (explicit) and Euler (implicit) methods require only 25.4 computational units at $$$ h=5.0 $$$, compared with 254 units at $$$ h=0.5 $$$. However, this decrease in computational effort comes at the expense of accuracy, as seen in the increased $$$ {L}_2 $$$-norm error at larger step sizes. The Euler methods exhibit much larger errors at higher step sizes, with the error for Euler (Explicit) increasing from 0.136461 at $$$ h=0.5 $$$ to 0.437324 at $$$ h=5.0 $$$. This shows that larger step sizes compromise the accuracy of the solution.

On the other hand, the $$$ {L}_2 $$$-norm error generally increases with larger step sizes, a characteristic common to most numerical methods. For smaller step sizes, methods such as RK4, implicit midpoint, and 3rd-order Adams-Bashforth maintain relatively low errors. For instance, RK4 shows excellent accuracy with an error of 0.000002 at $$$ h=0.5 $$$, and still performs well at $$$ h=1.0 $$$ and $$$ h=2.0 $$$, with errors of 0.000030 and 0.000086, respectively. This demonstrates that RK4 is highly accurate, even at larger step sizes, while methods such as Euler (explicit) and Euler (implicit) show a substantial increase in error as the step size grows.

In terms of method performance, RK4 stands out for its consistent accuracy across various step sizes. Although RK4 requires moderate computational effort (1016 at $$$ h=0.5 $$$ and 508 at $$$ h=1.0 $$$), it provides remarkably low errors, making it an excellent choice for problems where accuracy is critical. The 3rd-order Adams-Bashforth, 3rd-order Adams-Moulton, and 3rd-order predictor-corrector methods, while offering good accuracy (with errors between 0.001132 and 0.001133 at $$$ h=0.5 $$$), require significantly higher computational effort, especially the 3rd-order Adams-Moulton method, which has a computational effort of 2540 at $$$ h=0.5 $$$, and 270 at $$$ h=5.0 $$$. These methods perform similarly to RK4 in terms of accuracy, but their computational cost is higher.

High-order methods such as the 3rd-order Adams-Bashforth, 3rd-order Adams-Moulton, and 3rd-order predictor-corrector provide a better balance between accuracy and computational effort at smaller step sizes. However, as the step size increases, the computational effort of these methods rises steeply, while their error remains relatively consistent. For instance, at $$$ h=5.0 $$$, the computational effort for the 3rd-order Adams-Moulton method is 270, and the error remains around 0.036245, similar to the error at $$$ h=0.5 $$$.