pathsim 0.2.0__py3-none-any.whl

pathsim/solvers/rkdp87.py

@@ -0,0 +1,116 @@
+########################################################################################
+##
+##                EXPLICIT ADAPTIVE TIMESTEPPING RUNGE-KUTTA INTEGRATORS
+##                                 (solvers/rkf78.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import numpy as np
+
+from ._solver import ExplicitSolver
+
+
+# SOLVERS ==============================================================================
+
+class RKDP87(ExplicitSolver):
+    """
+    13-stage 8-th order embedded Runge-Kutta method from Dormand and Prince
+    with embedded 7-th order method for 8-th order truncation error estimate 
+    that can be used to adaptively control the timestep. 
+
+    This solver is a great choice if extremely high accuracy is required.
+    """
+
+    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/18, 1/12, 1/8, 5/16, 3/8, 59/400, 93/200, 5490023248/9719169821, 13/20, 1201146811/1299019798, 1.0, 1.0]
+
+        #extended butcher table 
+        self.BT = {0:[1/18],
+                   1:[1/48, 1/16],
+                   2:[1/32, 0, 3/32],
+                   3:[5/16, 0, -75/64, 75/64],
+                   4:[3/80, 0, 0, 3/16, 3/20],
+                   5:[29443841/614563906, 0, 0, 77736538/692538347, -28693883/1125000000, 23124283/1800000000],
+                   6:[16016141/946692911, 0, 0, 61564180/158732637, 22789713/633445777, 545815736/2771057229, -180193667/1043307555],
+                   7:[39632708/573591083, 0, 0, -433636366/683701615, -421739975/2616292301, 100302831/723423059, 790204164/839813087, 800635310/3783071287],
+                   8:[246121993/1340847787, 0, 0, -37695042795/15268766246, -309121744/1061227803, -12992083/490766935, 6005943493/2108947869, 393006217/1396673457, 123872331/1001029789],
+                   9:[-1028468189/846180014, 0, 0, 8478235783/508512852, 1311729495/1432422823, -10304129995/1701304382, -48777925059/3047939560, 15336726248/1032824649, -45442868181/3398467696, 3065993473/597172653],
+                   10:[185892177/718116043, 0, 0, -3185094517/667107341, -477755414/1098053517, -703635378/230739211, 5731566787/1027545527, 5232866602/850066563, -4093664535/808688257, 3962137247/1805957418, 65686358/487910083],
+                   11:[403863854/491063109, 0, 0, -5068492393/434740067, -411421997/543043805, 652783627/914296604, 11173962825/925320556, -13158990841/6184727034, 3936647629/1978049680, -160528059/685178525, 248638103/1413531060, 0],
+                   12:[14005451/335480064, 0, 0, 0, 0, -59238493/1068277825, 181606767/758867731, 561292985/797845732, -1041891430/1371343529, 760417239/1151165299, 118820643/751138087, -528747749/2220607170, 1/4]}
+
+        #coefficients for lower order solution evaluation
+        self.bh = [13451932/455176623, 0, 0, 0, 0, -808719846/976000145, 1757004468/5645159321, 656045339/265891186, -3867574721/1518517206, 465885868/322736535, 53011238/667516719, 2/45, 0]
+
+        #lower order solution
+        self.xh = None
+
+
+    def error_controller(self, dt):
+        """
+        compute scaling factor for adaptive timestep 
+        based on local truncation error estimate and returns both
+        """
+        if self.xh is None: 
+            return True, 0.0, 1.0
+
+        #compute and clip truncation error
+        truncation_error = np.max(np.clip(abs(self.x-self.xh), 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/8)        
+
+        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 < 12:
+            self.stage += 1
+            return True, 0.0, 1.0        
+
+        else: 
+
+            #lower order solution
+            slope = 0.0
+            for i, bh in enumerate( self.bh):
+                slope += self.Ks[i] * bh
+            self.xh = dt * slope + self.x_0
+
+            #reset stage counter
+            self.stage = 0
+            return self.error_controller(dt)

pathsim/solvers/rkf45.py

@@ -0,0 +1,102 @@
+########################################################################################
+##
+##                EXPLICIT ADAPTIVE TIMESTEPPING RUNGE-KUTTA INTEGRATORS
+##                                 (solvers/rkf45.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import numpy as np
+
+from ._solver import ExplicitSolver
+
+
+# SOLVERS ==============================================================================
+
+class RKF45(ExplicitSolver):
+    """
+    6-stage 4-th order embedded Runge-Kutta-Fehlberg method 
+    with 5-th order truncation error estimate that can be used to 
+    adaptively control the timestep. 
+
+    Absolute classic but relatively slow.
+    """
+
+    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/4, 3/8, 12/13, 1, 1/2]
+
+        #extended butcher table 
+        self.BT = {0:[      1/4],
+                   1:[     3/32,       9/32],
+                   2:[1932/2197, -7200/2197,  7296/2197],
+                   3:[  439/216,         -8,   3680/513, -845/4104],
+                   4:[    -8/27,          2, -3554/2565, 1859/4104, -11/40],
+                   5:[   25/216,          0,  1408/2565, 2197/4104,   -1/5, 0]}
+
+        #coefficients for local truncation error estimate
+        self.TR = [1/360, 0, -128/4275, -2197/75240, 1/50, 2/55]
+
+
+    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/rkf78.py

@@ -0,0 +1,111 @@
+########################################################################################
+##
+##                EXPLICIT ADAPTIVE TIMESTEPPING RUNGE-KUTTA INTEGRATORS
+##                                 (solvers/rkf78.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import numpy as np
+
+from ._solver import ExplicitSolver
+
+
+# SOLVERS ==============================================================================
+
+class RKF78(ExplicitSolver):
+    """
+    13-stage 7-th order embedded Runge-Kutta-Fehlberg method 
+    with 8-th order truncation error estimate that can be used to 
+    adaptively control the timestep. 
+
+    This solver is a great choice if extremely high accuracy is required. 
+    It is also almost symplectic and therefore quite suitable for 
+    conservation systems such as celestial dynamics, etc.
+    """
+
+    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, 2/27, 1/9, 1/6, 5/12, 1/2, 5/6, 1/6, 2/3, 1/3, 1, 0, 1]
+
+        #extended butcher table 
+        self.BT = {0: [      2/27],
+                   1: [      1/36, 1/12],
+                   2: [      1/24,    0,    1/8],
+                   3: [      5/12,    0, -25/16,    25/16],
+                   4: [      1/20,    0,      0,      1/4,       1/5],
+                   5: [   -25/108,    0,      0,  125/108,    -65/27,  125/54],
+                   6: [    31/300,    0,      0,        0,    61/225,    -2/9,    13/900],
+                   7: [         2,    0,      0,    -53/6,    704/45,  -107/9,     67/90,     3],
+                   8: [   -91/108,    0,      0,   23/108,  -976/135,  311/54,    -19/60,  17/6,  -1/12],
+                   9: [ 2383/4100,    0,      0, -341/164, 4496/1025, -301/82, 2133/4100, 45/82, 45/164, 18/41],
+                   10:[     3/205,    0,      0,        0,         0,   -6/41,    -3/205, -3/41,   3/41,  6/41],
+                   11:[-1777/4100,    0,      0, -341/164, 4496/1025, -289/82, 2193/4100, 51/82, 33/164, 12/41,   0, 1],
+                   12:[    41/840,    0,      0,        0,         0,  34/105,      9/35,  9/35,  9/280, 9/280, 41/840]}
+
+        #coefficients for local truncation error estimate
+        self.TR = [41/840, 0, 0, 0, 0, 0, 0, 0, 0, 0, 41/840, -41/840, -41/840]
+
+
+    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/8)        
+
+        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 < 12:
+            self.stage += 1
+            return True, 0.0, 1.0
+        else: 
+            self.stage = 0
+            return self.error_controller(dt)

pathsim/solvers/rkv65.py

@@ -0,0 +1,103 @@
+########################################################################################
+##
+##                EXPLICIT ADAPTIVE TIMESTEPPING RUNGE-KUTTA INTEGRATORS
+##                                 (solvers/rkv65.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import numpy as np
+
+from ._solver import ExplicitSolver
+
+
+# SOLVERS ==============================================================================
+
+class RKV65(ExplicitSolver):
+    """
+    9-stage 6-th order with embedded 5-th order Runge-Kutta method from Verner 
+    with 6-th order truncation error estimate.
+
+    This is the 'most robust' 9, 6(5) pair of Jim Verner's Refuge for Runge-Kutta Pairs
+    URL: https://www.sfu.ca/~jverner/
+    """
+
+    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, 9/50, 1/6, 1/4, 53/100, 3/5, 4/5, 1.0, 1.0]
+
+        #extended butcher table 
+        self.BT = {0:[             9/50],
+                   1:[           29/324, 25/324],
+                   2:[             1/16,      0,           3/16],
+                   3:[     79129/250000,      0, -261237/250000,      19663/15625],
+                   4:[  1336883/4909125,      0,   -25476/30875,    194159/185250,       8225/78546],
+                   5:[-2459386/14727375,      0,    19504/30875, 2377474/13615875, -6157250/5773131,   902/735],
+                   6:[        2699/7410,      0,      -252/1235, -1393253/3993990,     236875/72618,   -135/49,   15/22], 
+                   7:[           11/144,      0,              0,          256/693,                0,   125/504, 125/528,        5/72], 
+                   8:[           28/477,      0,              0,          212/441,   -312500/366177, 2125/1764,       0, -2105/35532, 2995/17766]}
+
+        #5-th order solution at stage 9
+        self.xh = None
+
+
+    def error_controller(self, dt):
+        """
+        compute scaling factor for adaptive timestep 
+        based on local truncation error estimate and returns both
+        """
+        if self.xh is None: 
+            return True, 0.0, 1.0
+
+        #compute and clip truncation error
+        truncation_error = np.max(np.clip(abs(self.x-self.xh), 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/6)        
+
+        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)
+        
+        #compute slope at stage
+        slope = 0.0
+        for i, b in enumerate(self.BT[self.stage]):
+            slope += self.Ks[i] * b
+
+        #error and step size control
+        if self.stage < 8:
+            #stepping with 6-th order solution
+            self.x = dt * slope + self.x_0
+            self.stage += 1
+            return True, 0.0, 1.0
+        else: 
+            #save 5-th order solution for error control at last stage
+            self.xh = dt * slope + self.x_0
+            self.stage = 0
+            return self.error_controller(dt)

pathsim/solvers/ssprk22.py

@@ -0,0 +1,62 @@
+########################################################################################
+##
+##               EXPLICIT STRONG STABILITY PRESERVING RUNGE-KUTTA INTEGRATOR
+##                                (solvers/ssprk22.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+from ._solver import ExplicitSolver
+
+
+# SOLVERS ==============================================================================
+
+class SSPRK22(ExplicitSolver):
+    """
+    Strong Stability Preserving (SSP) 2-nd order two stage (2,2) Runge-Kutta method,
+    also known as the 'Heun-Method'.
+
+    This integrator has a good trade off between speed, accuracy and stability.
+    Especially for non-stiff linear systems, this is probably a great choice.
+    """
+
+    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, 1.0]
+
+        #butcher table
+        self.BT = {0:[1.0],
+                   1:[1/2, 1/2]}
+                   
+
+    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) % 2
+
+        #no error estimate available
+        return True, 0.0, 1.0

pathsim/solvers/ssprk33.py

@@ -0,0 +1,65 @@
+########################################################################################
+##
+##               EXPLICIT STRONG STABILITY PRESERVING RUNGE-KUTTA INTEGRATOR
+##                                (solvers/ssprk33.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+from ._solver import ExplicitSolver
+
+
+# SOLVERS ==============================================================================
+
+class SSPRK33(ExplicitSolver):
+    """
+    Strong Stability Preserving (SSP) 3-rd order 
+    three stage (3,3) Runge-Kutta method
+    
+    This integrator is more accurate and stable then SSPRK22 but 
+    also 50% more expensive due to 3 instead of 2 stages. 
+    Originally designed for hyperbolic PDEs, this is also a great 
+    choice if accuracy and stability and still good speed are important.
+    """
+
+    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, 1.0, 0.5]
+
+        #butcher table
+        self.BT = {0:[1.0],
+                   1:[1/4, 1/4],
+                   2:[1/6, 1/6, 2/3]}
+
+
+    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) % 3
+
+        #no error estimate available
+        return True, 0.0, 1.0

pathsim/solvers/ssprk34.py

@@ -0,0 +1,74 @@
+########################################################################################
+##
+##               EXPLICIT STRONG STABILITY PRESERVING RUNGE-KUTTA INTEGRATOR
+##                                (solvers/ssprk34.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+# import numpy as np
+
+from ._solver import ExplicitSolver
+
+
+# SOLVERS ==============================================================================
+
+class SSPRK34(ExplicitSolver):
+    """
+    Strong Stability Preserving (SSP) 3-rd order 4 stage 
+    (3,4) Runge-Kutta method
+    
+    This integrator has one stage more then SSPRK33 but is also
+    3-rd order. So in terms or accuracy, they are the same but 
+    the 4-th stage gives quite a lot more stability. 
+    The stability region includes the point -4 on the real axis 
+    and is even more stable then the classical 'RK4' method in 
+    this aspect. But again it is 33% more expensive then SSPRK33 
+    due to the additional stage. 
+
+    If super high stability is required, this might be a good 
+    choice.
+    """
+
+    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, 1/2, 1, 1/2]
+
+        #butcher table
+        self.BT = {0:[1/2],
+                   1:[1/2, 1/2],
+                   2:[1/6, 1/6, 1/6],
+                   3:[1/6, 1/6, 1/6, 1/2]}
+
+
+    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