pathsim 0.2.0__py3-none-any.whl

pathsim/solvers/esdirk85.py

@@ -0,0 +1,200 @@
+########################################################################################
+##
+##                   EMBEDDED DIAGONALLY IMPLICIT RUNGE KUTTA METHOD
+##                                (solvers/esdirk85.py)
+##
+##                                  Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import numpy as np
+
+from ._solver import ImplicitSolver
+from ..utils.funcs import numerical_jacobian
+
+
+# SOLVERS ==============================================================================
+
+class ESDIRK85(ImplicitSolver):
+    """
+    16 stage 8-th order L-stable, stiffly accurate, stage order 2 ESDIRK method with 
+    embedded 5-th order method for stepsize control. This very high order integrator 
+    is suited for very stiff problems that require very high accuracy but is also 
+    relatively expensive due to the insane 15 implicit (1 explicit) stages.
+
+    This method is a real beast and it remains to be seen how practical it is.
+
+    FROM : 
+        VERY HIGH-ORDER A-STABLE STIFFLY ACCURATE DIAGONALLY 
+        IMPLICIT RUNGE-KUTTA METHODS WITH ERROR ESTIMATORS
+        YOUSEF ALAMRI AND DAVID I. KETCHESON
+        ESDIRK(16,8)[2]SAL-[(16,5)]
+    """
+
+    def __init__(self, initial_value=0, func=lambda x, u, t: u, jac=None, tolerance_lte=1e-6):
+        super().__init__(initial_value, func, jac, tolerance_lte)
+
+        #counter for runge kutta stages
+        self.stage = 0
+
+        #flag adaptive timestep solver
+        self.is_adaptive = True
+
+        #slope coefficients for stages
+        self.Ks = {}
+
+        #intermediate evaluation times
+        self.eval_stages = [0.0,
+                            0.234637638717043,
+                            0.558545926594724,
+                            0.562667638694992,
+                            0.697898381329126,
+                            0.956146958839776,
+                            0.812903043340468,
+                            0.148256733818785,
+                            0.944650387704291,
+                            0.428471803715736,
+                            0.984131639774509,
+                            0.320412672954752,
+                            0.974077670791771,
+                            0.852850433853921,
+                            0.823320301074444,
+                            1.0]
+
+        #butcher table
+        self.BT = {0:[0.0],
+                   1:[0.117318819358521,0.117318819358521],
+                   2:[0.0557014605974616,0.385525646638742,0.117318819358521],
+                   3:[0.063493276428895,0.373556126263681,0.0082994166438953,0.117318819358521],
+                   4:[0.0961351856230088,0.335558324517178,0.207077765910132,-0.0581917140797146,0.117318819358521],
+                   5:[0.0497669214238319,0.384288616546039,0.0821728117583936,0.120337007107103,0.202262782645888,0.117318819358521],
+                   6:[0.00626710666809847,0.496491452640725,-0.111303249827358,0.170478821683603,0.166517073971103,-0.0328669811542241,0.117318819358521],
+                   7:[0.0463439767281591,0.00306724391019652,-0.00816305222386205,-0.0353302599538294,0.0139313601702569,-0.00992014507967429,0.0210087909090165,0.117318819358521],
+                   8:[0.111574049232048,0.467639166482209,0.237773114804619,0.0798895699267508,0.109580615914593,0.0307353103825936,-0.0404391509541147,-0.16942110744293,0.117318819358521],
+                   9:[-0.0107072484863877,-0.231376703354252,0.017541113036611,0.144871527682418,-0.041855459769806,0.0841832168332261,-0.0850020937282192,0.486170343825899,-0.0526717116822739,0.117318819358521],
+                   10:[-0.0142238262314935,0.14752923682514,0.238235830732566,0.037950291904103,0.252075123381518,0.0474266904224567,-0.00363139069342027,0.274081442388563,-0.0599166970745255,-0.0527138812389185,0.117318819358521],
+                   11:[-0.11837020183211,-0.635712481821264,0.239738832602538,0.330058936651707,-0.325784087988237,-0.0506514314589253,-0.281914404487009,0.852596345144291,0.651444614298805,-0.103476387303591,-0.354835880209975,0.117318819358521,],
+                   12:[-0.00458164025442349,0.296219694015248,0.322146049419995,0.15917778285238,0.284864871688843,0.185509526463076,-0.0784621067883274,0.166312223692047,-0.284152486083397,-0.357125104338944,0.078437074055306,0.0884129667114481,0.117318819358521],
+                   13:[-0.0545561913848106,0.675785423442753,0.423066443201941,-0.000165300126841193,0.104252994793763,-0.105763019303021,-0.15988308809318,0.0515050001032011,0.56013979290924,-0.45781539708603,-0.255870699752664,0.026960254296416,-0.0721245985053681,0.117318819358521],
+                   14:[0.0649253995775223,-0.0216056457922249,-0.073738139377975,0.0931033310077225,-0.0194339577299149,-0.0879623837313009,0.057125517179467,0.205120850488097,0.132576503537441,0.489416890627328,-0.1106765720501,-0.081038793996096,0.0606031613503788,-0.00241467937442272,0.117318819358521],
+                   15:[0.0459979286336779,0.0780075394482806,0.015021874148058,0.195180277284195,-0.00246643310153235,0.0473977117068314,-0.0682773558610363,0.19568019123878,-0.0876765449323747,0.177874852409192,-0.337519251582222,-0.0123255553640736,0.311573291192553,0.0458604327754991,0.278352222645651,0.117318819358521]}
+
+        #coefficients for truncation error estimate
+        _A1 = [0.0459979286336779,
+               0.0780075394482806,
+               0.015021874148058,
+               0.195180277284195,
+               -0.00246643310153235,
+               0.0473977117068314,
+               -0.0682773558610363,
+               0.19568019123878,
+               -0.0876765449323747,
+               0.177874852409192,
+               -0.337519251582222,
+               -0.0123255553640736,
+               0.311573291192553,
+               0.0458604327754991,
+               0.278352222645651,
+               0.117318819358521]
+        _A2 = [0.0603373529853206,
+               0.175453809423998,
+               0.0537707777611352,
+               0.195309248607308,
+               0.0135893741970232,
+               -0.0221160259296707,
+               -0.00726526156430691,
+               0.102961059369124,
+               0.000900215457460583,
+               0.0547959465692338,
+               -0.334995726863153,
+               0.0464409662093384,
+               0.301388101652194,
+               0.00524851570622031,
+               0.229538601845236,
+               0.124643044573514]
+        self.TR = [_a1 - _a2 for _a1, _a2 in zip(_A1, _A2)]
+
+
+    def error_controller(self, dt):
+        """
+        compute scaling factor for adaptive timestep 
+        based on local truncation error estimate and returns both
+        """
+        if len(self.Ks)<len(self.TR): 
+            return True, 0.0, 1.0
+
+        #compute local truncation error slope
+        slope = 0.0
+        for i, b in enumerate(self.TR):
+            slope += self.Ks[i] * b
+
+        #compute and clip truncation error
+        truncation_error = np.max(np.clip(abs(dt*slope), 1e-18, None))
+        
+        #compute error ratio and success
+        error_ratio = self.tolerance_lte / truncation_error
+        success = error_ratio >= 1.0
+
+        #compute timestep scale
+        timestep_rescale = 0.9 * (error_ratio)**(1/6)        
+
+        return success, truncation_error, timestep_rescale
+
+
+    def solve(self, u, t, dt):
+        """
+        Solves the implicit update equation via anderson acceleration.
+        """
+
+        #first stage is explicit
+        if self.stage == 0:
+            return 0.0
+            
+        #update timestep weighted slope 
+        self.Ks[self.stage] = self.func(self.x, u, t)
+
+        #update fixed-point equation
+        slope = 0.0
+        for i, b in enumerate(self.BT[self.stage]):
+            slope += self.Ks[i] * b
+
+        #use the jacobian
+        if self.jac is not None:
+
+            #compute jacobian of fixed-point equation
+            jac_g = dt * b * self.jac(self.x, u, t)
+
+            #anderson acceleration step with local newton
+            self.x, err = self.acc.step(self.x, dt*slope + self.x_0, jac_g)
+
+        else:
+            #anderson acceleration step (pure)
+            self.x, err = self.acc.step(self.x, dt*slope + self.x_0, None)
+
+        #return the fixed-point residual
+        return err
+
+
+    def step(self, u, t, dt):
+        """
+        performs the timestep update
+        """
+
+        #first stage is explicit
+        if self.stage == 0:
+            self.Ks[self.stage] = self.func(self.x, u, t)
+
+        #restart anderson accelerator 
+        self.acc.reset()    
+
+        #error and step size control
+        if self.stage < 15:
+            self.stage += 1
+            return True, 0.0, 1.0
+        else: 
+            self.stage = 0
+            return self.error_controller(dt)
+
+        

pathsim/solvers/euler.py

@@ -0,0 +1,81 @@
+########################################################################################
+##
+##                      EXPLICIT and IMPLICIT EULER INTEGRATORS
+##                                (solvers/euler.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+from ._solver import ExplicitSolver, ImplicitSolver
+from ..utils.funcs import numerical_jacobian
+
+
+# SOLVERS ==============================================================================
+
+class EUF(ExplicitSolver):
+    """
+    Class that performs explicit (forward) euler integration
+    it holds the state and implements the timestep update.
+
+    Use this only if the function to integrate is super smooth 
+    or multistep/multistage methods cant be used. 
+    """
+
+    def step(self, u, t, dt):
+        """
+        performs the explicit forward timestep for (t+dt) 
+        based on the state and input at (t)
+        """
+
+        #update state with euler step
+        self.x = self.x_0 + dt * self.func(self.x, u, t)
+
+        #no error estimate available
+        return True, 0.0, 1.0
+
+
+class EUB(ImplicitSolver):
+    """
+    Class that performs implicit (backward) euler integration
+    it holds the state and implements the solution of the 
+    implicit update equation at each timestep.
+
+    Its an absolute classic and ok for moderately stiff problems 
+    that dont require super high accuracy.
+    """
+
+    def solve(self, u, t, dt):
+        """
+        Solves the implicit update equation via anderson acceleration.
+        """
+
+        #update the fixed point equation
+        g = self.x_0 + dt * self.func(self.x, u, t)
+
+        #use the numerical jacobian
+        if self.jac is not None:
+
+            #compute numerical jacobian
+            jac_g = dt * self.jac(self.x, u, t)
+
+            #anderson acceleration step with local newton
+            self.x, err = self.acc.step(self.x, g, jac_g)
+
+        else:
+            #anderson acceleration step (pure)
+            self.x, err = self.acc.step(self.x, g, None)
+
+        #return the fixed-point residual
+        return err
+
+
+    def step(self, u, t, dt):
+
+        #reset anderson accelerator
+        self.acc.reset()
+
+        #no error estimate available
+        return True, 0.0, 1.0

pathsim/solvers/rk4.py

@@ -0,0 +1,61 @@
+########################################################################################
+##
+##                       CLASSICAL EXPLICIT RUNGE-KUTTA INTEGRATOR
+##                                 (solvers/rk4.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+from ._solver import ExplicitSolver
+
+
+# SOLVERS ==============================================================================
+
+class RK4(ExplicitSolver):
+    """
+    'The' classical 4-th order 4-stage Runge-Kutta method.
+    """
+
+    def __init__(self, initial_value=0, func=lambda x, u, t: u, jac=None, tolerance_lte=1e-6):
+        super().__init__(initial_value, func, jac, tolerance_lte)
+
+        #counter for runge kutta stages
+        self.stage = 0
+
+        #slope coefficients for stages
+        self.Ks = {}
+
+        #intermediate evaluation times
+        self.eval_stages = [0.0, 0.5, 0.5, 1.0]
+
+        #butcher table
+        self.BT = {0:[1/2],
+                   1:[0.0, 1/2],
+                   2:[0.0, 0.0, 1.0], 
+                   3:[1/6, 2/6, 2/6, 1/6]}
+                   
+
+    def step(self, u, t, dt):
+        """
+        performs the (explicit) timestep for (t+dt) 
+        based on the state and input at (t)
+        """
+
+        #buffer intermediate slope
+        self.Ks[self.stage] = self.func(self.x, u, t)
+        
+        #update state at stage
+        slope = 0.0
+        for i, b in enumerate(self.BT[self.stage]):
+            slope += self.Ks[i] * b
+        self.x = dt * slope + self.x_0
+        
+        #wrap around stage counter
+        self.stage = (self.stage + 1) % 4
+
+        #no error estimate available
+        return True, 0.0, 1.0
+

pathsim/solvers/rkbs32.py

@@ -0,0 +1,101 @@
+########################################################################################
+##
+##                EXPLICIT ADAPTIVE TIMESTEPPING RUNGE-KUTTA INTEGRATORS
+##                                (solvers/rkbs32.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import numpy as np
+
+from ._solver import ExplicitSolver
+
+
+# SOLVERS ==============================================================================
+
+class RKBS32(ExplicitSolver):
+    """
+    The Bogacki–Shampine method is a Runge–Kutta method of order three with four stages.
+    It has an embedded second-order method which can be used to implement adaptive 
+    step size. The Bogacki–Shampine method is implemented in the 'ode3' for fixed 
+    step solver and 'ode23' for a variable step solver function in MATLAB.
+
+    This is the adaptive variant. It is a good choice of low accuracy is acceptable.
+    """
+
+    def __init__(self, initial_value=0, func=lambda x, u, t: u, jac=None, tolerance_lte=1e-6):
+        super().__init__(initial_value, func, jac, tolerance_lte)
+
+        #counter for runge kutta stages
+        self.stage = 0
+
+        #flag adaptive timestep solver
+        self.is_adaptive = True
+
+        #slope coefficients for stages
+        self.Ks = {}
+
+        #intermediate evaluation times
+        self.eval_stages = [0.0, 1/2, 3/4, 1.0]
+        
+        #extended butcher table
+        self.BT = {0:[1/2],
+                   1:[0.0 , 3/4],
+                   2:[2/9 , 1/3, 4/9]}
+
+        #coefficients for truncation error estimate
+        self.TR = [-5/72, 1/12, 1/9, -1/8]
+
+
+    def error_controller(self, dt):
+        """
+        compute scaling factor for adaptive timestep 
+        based on local truncation error estimate and returns both
+        """
+        if len(self.Ks)<len(self.TR): 
+            return True, 0.0, 1.0
+
+        #compute local truncation error slope
+        slope = 0.0
+        for i, b in enumerate(self.TR):
+            slope += self.Ks[i] * b
+
+        #compute and clip truncation error
+        truncation_error = np.max(np.clip(abs(dt*slope), 1e-18, None))
+        
+        #compute error ratio
+        error_ratio = self.tolerance_lte / truncation_error
+        success = error_ratio >= 1.0
+
+        #compute timestep scale
+        timestep_rescale = 0.9 * (error_ratio)**(1/3)        
+
+        return success, truncation_error, timestep_rescale
+
+
+    def step(self, u, t, dt):
+        """
+        performs the (explicit) timestep for (t+dt) 
+        based on the state and input at (t)
+        """
+        
+        #buffer intermediate slope
+        self.Ks[self.stage] = self.func(self.x, u, t)
+        
+        #error and step size control
+        if self.stage < 3:
+
+            #update state at stage
+            slope = 0.0
+            for i, b in enumerate(self.BT[self.stage]):
+                slope += self.Ks[i] * b
+            self.x = dt*slope + self.x_0
+
+            self.stage += 1
+            return True, 0.0, 1.0
+        else: 
+            self.stage = 0
+            return self.error_controller(dt)

pathsim/solvers/rkck54.py

@@ -0,0 +1,108 @@
+########################################################################################
+##
+##                EXPLICIT ADAPTIVE TIMESTEPPING RUNGE-KUTTA INTEGRATORS
+##                                (solvers/rkck54.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import numpy as np
+
+from ._solver import ExplicitSolver
+
+
+# SOLVERS ==============================================================================
+
+class RKCK54(ExplicitSolver):
+    """
+    6-stage 5-th order with embedded 4-th order Runge-Kutta method from Cash and Karp 
+    with 5-th order truncation error estimate for the 4-th order solution that can be 
+    used to adaptively control the timestep. The 5-th order method is used for 
+    timestepping (local extrapolation) and the difference to the 5-th order solution 
+    is used as an estimate for the local truncation error of the 4-th order solution.
+    
+    This is the fixed order Cash-Karp scheme without early quitting.
+
+    The method balances the accuracy of the 5-th and 4-th order solution and 
+    has enhanced stability properties compared to Fehlberg or Dormand-Prince 
+    methods. This makes it suitable for slightly stiff problems.
+    """
+
+    def __init__(self, initial_value=0, func=lambda x, u, t: u, jac=None, tolerance_lte=1e-6):
+        super().__init__(initial_value, func, jac, tolerance_lte)
+
+        #counter for runge kutta stages
+        self.stage = 0
+
+        #flag adaptive timestep solver
+        self.is_adaptive = True
+
+        #slope coefficients for stages
+        self.Ks = {}
+
+        #intermediate evaluation times
+        self.eval_stages = [0.0, 1/5, 3/10, 3/5, 1, 7/8]
+
+        #extended butcher table 
+        self.BT = {0:[       1/5],
+                   1:[      3/40,    9/40],
+                   2:[      3/10,   -9/10,       6/5],
+                   3:[    -11/54,     5/2,    -70/27,        35/27],
+                   4:[1631/55296, 175/512, 575/13824, 44275/110592, 253/4096],
+                   5:[    37/378,       0,   250/621,      125/594,        0, 512/1771]}
+
+        #coefficients for local truncation error estimate
+        self.TR = [-277/64512, 0, 6925/370944, -6925/202752, -277/14336, 277/7084]
+
+
+    def error_controller(self, dt):
+        """
+        compute scaling factor for adaptive timestep 
+        based on local truncation error estimate and returns both
+        """
+        if len(self.Ks)<len(self.TR): 
+            return True, 0.0, 1.0
+
+        #compute local truncation error slope
+        slope = 0.0
+        for i, b in enumerate(self.TR):
+            slope += self.Ks[i] * b
+
+        #compute and clip truncation error
+        truncation_error = np.max(np.clip(abs(dt*slope), 1e-18, None))
+        
+        #compute error ratio
+        error_ratio = self.tolerance_lte / truncation_error
+        success = error_ratio >= 1.0
+
+        #compute timestep scale
+        timestep_rescale = 0.9 * (error_ratio)**(1/5)        
+
+        return success, truncation_error, timestep_rescale
+
+
+    def step(self, u, t, dt):
+        """
+        performs the (explicit) timestep for (t+dt) 
+        based on the state and input at (t)
+        """
+
+        #buffer intermediate slope
+        self.Ks[self.stage] = self.func(self.x, u, t)
+        
+        #update state at stage
+        slope = 0.0
+        for i, b in enumerate(self.BT[self.stage]):
+            slope += self.Ks[i] * b
+        self.x = dt * slope + self.x_0
+
+        #error and step size control
+        if self.stage < 5:
+            self.stage += 1
+            return True, 0.0, 1.0
+        else: 
+            self.stage = 0
+            return self.error_controller(dt)

pathsim/solvers/rkdp54.py

@@ -0,0 +1,111 @@
+########################################################################################
+##
+##                EXPLICIT ADAPTIVE TIMESTEPPING RUNGE-KUTTA INTEGRATORS
+##                                (solvers/rkdp54.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import numpy as np
+
+from ._solver import ExplicitSolver
+
+
+# SOLVERS ==============================================================================
+
+class RKDP54(ExplicitSolver):
+    """
+    Dormand–Prince method with seven Runge-Kutta stages is 5-th order 
+    accurate with an embedded 4-th order method. The 5-th order method 
+    is used for timestepping (local extrapolation) and the difference 
+    to the 5-th order solution is used as an estimate for the local 
+    truncation error of the 4-th order solaution.
+    
+    Wikipedia:
+        As of 2023, Dormand–Prince is the default method 
+        in the 'ode45' solver for MATLAB
+
+    Great choice for all kinds of problems that require high accuracy 
+    and where the adaptive timestepping doesnt cause problems.
+    """
+
+    def __init__(self, initial_value=0, func=lambda x, u, t: u, jac=None, tolerance_lte=1e-6):
+        super().__init__(initial_value, func, jac, tolerance_lte)
+
+        #counter for runge kutta stages
+        self.stage = 0
+
+        #flag adaptive timestep solver
+        self.is_adaptive = True
+
+        #slope coefficients for stages
+        self.Ks = {}
+
+        #intermediate evaluation times
+        self.eval_stages = [0.0, 1/5, 3/10, 4/5, 8/9, 1.0, 1.0]
+        
+        #extended butcher table
+        self.BT = {0:[       1/5],
+                   1:[      3/40,        9/40],
+                   2:[     44/45,      -56/15,       32/9], 
+                   3:[19372/6561, -25360/2187, 64448/6561, -212/729],
+                   4:[ 9017/3168,     -355/33, 46732/5247,   49/176, -5103/18656],
+                   5:[    35/384,           0,   500/1113,  125/192,  -2187/6784, 11/84]}
+
+        #coefficients for local truncation error estimate
+        self.TR = [71/57600, 0, - 71/16695, 71/1920, -17253/339200, 22/525, -1/40]
+
+
+    def error_controller(self, dt):
+        """
+        compute scaling factor for adaptive timestep 
+        based on local truncation error estimate and returns both
+        """
+        if len(self.Ks)<len(self.TR): 
+            return True, 0.0, 1.0
+
+        #compute local truncation error slope
+        slope = 0.0
+        for i, b in enumerate(self.TR):
+            slope += self.Ks[i] * b
+
+        #compute and clip truncation error
+        truncation_error = np.max(np.clip(abs(dt*slope), 1e-18, None))
+        
+        #compute error ratio
+        error_ratio = self.tolerance_lte / truncation_error
+        success = error_ratio >= 1.0
+
+        #compute timestep scale
+        timestep_rescale = 0.9 * (error_ratio)**(1/5)        
+
+        return success, truncation_error, timestep_rescale
+
+
+    def step(self, u, t, dt):
+        """
+        performs the (explicit) timestep for (t+dt) 
+        based on the state and input at (t)
+        """
+
+        #buffer intermediate slope
+        self.Ks[self.stage] = self.func(self.x, u, t)
+
+        #error and step size control
+        if self.stage < 6:
+            
+            #update state at stage
+            slope = 0.0
+            for i, b in enumerate(self.BT[self.stage]):
+                slope += self.Ks[i] * b
+            self.x = dt * slope + self.x_0
+
+            #increment stage counter
+            self.stage += 1
+            return True, 0.0, 1.0
+        else: 
+            self.stage = 0
+            return self.error_controller(dt)