Package ptolemy.domains.continuous.kernel.solver

Class ExplicitRK45Solver

  • public class ExplicitRK45Solver
extends ContinuousODESolver
    This class implements a fourth-order Runge-Kutta ODE solving method. The algorithm was introduced in "A Variable Order Runge-Kutta Method for Initial Value Problems with Rapidly Varying Right-Hand Sides" by J. R. Cash and Alan H. Karp, ACM Transactions on Mathematical Software, vol 16, pp. 201-222, 1990. For completeness, a brief explanation of the algorithm is explained below.

    For an ODE of the form: 

     dx(t)/dt = f(x(t), t), x(0) = x0
    it does the following: 
     K0 = f(x(n), tn);
 K1 = f(x(n) + 0.2*K0*h, tn + 0.2*h);
 K2 = f(x(n) + (3.0/40*K0 + 9.0/40*K1)*h, tn + 0.3*h);
 K3 = f(x(n) + (0.3*K0 - 0.9*K1 + 1.2*K2)*h, tn + 0.6*h);
 K4 = f(x(n) + (-11/54*K0 + 5.0/2*K1 -70/27*K2 + 35/27*K3)*h, tn + 1.0*h);
 K5 = f(x(n) + (1631/55296*K0 + 175/512*K1 + 575/13824*K2 + 3544275/110592*K3 + 253/4096*K4)*h, tn + 7/8*h);
 x(n+1) = x(n)+(37/378*K0 + 250/621*K2 + 125.0/594*K3 + 512.0/1771*K5)*h;
    , and error control: 
     LTE = [(37.0/378 - 2825.0/27648)*K0 + (250.0/621 - 18575.0/48384)*K2 +
 (125.0/594 - 13525.0/55296)*K3 + (0.0 - 277.0/14336)*K4 +
 (512.0/1771 - 0.25)*K5]*h.

    If the LTE is less than the error tolerance, then this step size h is considered successful, and the next integration step size h' is predicted as: 

     h' = h * Math.pow((ErrorTolerance/LTE), 1.0/5.0)
    This is a fourth order method, but uses a fifth order procedure to estimate the local truncation error.

    It takes 6 steps for this solver to resolve a state with an integration step size.

    Since:
    Ptolemy II 6.0
    Version:
    $Id$
    Author:
    Haiyang Zheng, Edward A. Lee
    Pt.AcceptedRating:
    Green (hyzheng)
    Pt.ProposedRating:
    Green (hyzheng)

    • Field Detail

      • _TIME_INCREMENTS

        protected static final double[] _TIME_INCREMENTS
        The ratio of time increments within one integration step.

    • Constructor Detail

      • ExplicitRK45Solver

        public ExplicitRK45Solver()

    • Method Detail

      • getIntegratorAuxVariableCount

        public final int getIntegratorAuxVariableCount()
        Return the number of time increments plus one (to store the truncation error).
        Specified by:
        getIntegratorAuxVariableCount in class ContinuousODESolver
        Returns:
        The number of time increments plus one.

      • integratorIsAccurate

        public boolean integratorIsAccurate​(ContinuousIntegrator integrator)
        Return true if the integration is accurate for the given integrator. This estimates the local truncation error for that integrator and compare it with the error tolerance.
        Specified by:
        integratorIsAccurate in class ContinuousODESolver
        Parameters:
        integrator - The integrator of that calls this method.
        Returns:
        True if the integration is successful.

      • integratorSuggestedStepSize

        public double integratorSuggestedStepSize​(ContinuousIntegrator integrator)
        Predict the next step size for the integrators executed under this solver. This uses the algorithm in the class comments to predict the next step size based on the current estimation of the local truncation error.
        Specified by:
        integratorSuggestedStepSize in class ContinuousODESolver
        Parameters:
        integrator - The integrator that calls this method.
        Returns:
        The next step size suggested by the given integrator.

      • _getRound

        protected int _getRound()
        Return the current round.
        Specified by:
        _getRound in class ContinuousODESolver
        Returns:
        The current round.

      • _isStepFinished

        protected final boolean _isStepFinished()
        Return true if the current integration step is finished. This method will return true if _incrementRound() has been called 6 or more times since _reset().
        Specified by:
        _isStepFinished in class ContinuousODESolver
        Returns:
        Return true if the solver has finished an integration step.
        See Also:
        _reset()

      • _reset

        protected final void _reset()
        Reset the solver, indicating to it that we are starting an integration step. This method resets the round counter.
        Specified by:
        _reset in class ContinuousODESolver