pathsim 0.4.2__tar.gz → 0.4.3__tar.gz

{pathsim-0.4.2 → pathsim-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pathsim
-Version: 0.4.2
+Version: 0.4.3
 Summary: A block based time domain system simulation framework.
 Home-page: https://github.com/milanofthe/pathsim
 Author: Milan Rother

{pathsim-0.4.2 → pathsim-0.4.3}/pathsim/diff/value.py

@@ -46,8 +46,6 @@ FUNC_GRAD = {
     np.cbrt    : lambda x: 1/(3*np.cbrt(x)**2),
 
     # Complex functions
-    np.real    : lambda x: np.real(x),
-    np.imag    : lambda x: np.imag(x),
     np.conj    : lambda x: np.conj(x),
     np.abs     : lambda x: x/np.abs(x),  
     np.angle   : lambda x: -1j/x,
@@ -118,6 +116,18 @@ class Value:
         return self.grad.get(other, 0.0)
 
 
+    @property
+    def real(self):
+        return Value(val=np.real(self.val), 
+                     grad={k: np.real(v) for k, v in self.grad.items()}) 
+
+
+    @property
+    def imag(self):
+        return Value(val=np.imag(self.val), 
+                     grad={k: np.imag(v) for k, v in self.grad.items()}) 
+
+
     def __hash__(self):
         return id(self)
 
@@ -332,6 +342,9 @@ if __name__ == "__main__":
 
     A = np.array([x, Value(3), Value(0.5)])
 
+    C = np.array([[x, Value(3), Value(0.5)], 
+                  [Value(-1.09), y, Value(2.3)]])
+
     B = A**2 - y
     print(B[0].d(x))
 
@@ -347,7 +360,11 @@ if __name__ == "__main__":
     b = np.linalg.norm(B)
     print(b.d(x), b.d(y))
 
-    d = np.sign(np.sin(2*np.pi*x))
+    print(np.real(b))
+
+    c = np.dot(C, A)
+    print(c[0].d(x))
 
-    print(np.sign(d))
+    c = x + C
+    print(c[0, 0].d(x))
 

pathsim-0.4.3/pathsim/solvers/_rungekutta.py

@@ -0,0 +1,302 @@
+########################################################################################
+##
+##                       BASE CLASS FOR RUNGE-KUTTA INTEGRATORS
+##                              (solvers/_rungekutta.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import numpy as np
+
+from ._solver import ExplicitSolver, ImplicitSolver
+
+
+# SOLVERS ==============================================================================
+
+class ExplicitRungeKutta(ExplicitSolver):
+    """
+    Base class for explicit Runge-Kutta integrators which implements 
+    the timestepping at intermediate stages and the error control if 
+    the coefficients for the local truncation error estimate are defined.        
+    
+    NOTE:
+        This class is not intended to be used directly!!!
+    """
+
+    def __init__(self, *solver_args, **solver_kwargs):
+        super().__init__(*solver_args, **solver_kwargs)
+
+        #order of the integration scheme and embedded method (if available)
+        self.n = 0
+        self.m = 0
+
+        #number of stages in RK scheme
+        self.s = 0
+
+        #safety factor for error controller (if available)
+        self.beta = 0.9
+
+        #slope coefficients for stages
+        self.Ks = {}
+
+        #extended butcher tableau
+        self.BT = None
+
+        #coefficients for local truncation error estimate
+        self.TR = None
+
+
+    def error_controller(self, dt):
+        """
+        compute scaling factor for adaptive timestep based on 
+        absolute and relative local truncation error estimate, 
+        also checks if the error tolerance is achieved and returns 
+        a success metric.
+
+        INPUTS:
+            dt : (float) integration timestep
+        """
+
+        #early exit of not enough slopes or no error estimate at all
+        if self.TR is None or len(self.Ks) < len(self.TR): 
+            return True, 0.0, 0.0, 1.0
+
+        #compute local truncation error slope (this is faster then 'sum' comprehension)
+        slope = 0.0
+        for i, b in enumerate(self.TR):
+            slope = slope + self.Ks[i] * b
+        tr = dt * slope
+
+        #compute and clip truncation error, error ratio abs
+        truncation_error_abs = float(np.max(np.clip(abs(tr), 1e-18, None)))
+        error_ratio_abs = self.tolerance_lte_abs / truncation_error_abs
+
+        #compute and clip truncation error, error ratio rel
+        if np.any(self.x == 0.0): 
+            truncation_error_rel = 1.0
+            error_ratio_rel = 0.0
+        else:
+            truncation_error_rel = float(np.max(np.clip(abs(tr/self.x), 1e-18, None)))
+            error_ratio_rel = self.tolerance_lte_rel / truncation_error_rel
+        
+        #compute error ratio and success check
+        error_ratio = max(error_ratio_abs, error_ratio_rel)
+        success = error_ratio >= 1.0
+
+        #compute timestep scale factor using accuracy order of truncation error
+        timestep_rescale = self.beta * error_ratio**(1/(min(self.m, self.n) + 1))     
+
+        return success, truncation_error_abs, truncation_error_rel, timestep_rescale
+
+
+    def step(self, u, t, dt):
+        """
+        performs the (explicit) timestep at the intermediate RK stages 
+        for (t+dt) based on the state and input at (t)
+
+        INPUTS:
+            u  : (float) non-autonomous external component for integration
+            t  : (float) evaluation time for right-hand-side function
+            dt : (float) integration timestep
+        """
+
+        #buffer intermediate slope
+        self.Ks[self.stage] = self.func(self.x, u, t)
+
+        #compute slope and update state at stage (this is faster then 'sum' comprehension)
+        slope = 0.0
+        for i, b in enumerate(self.BT[self.stage]):
+            slope = slope + self.Ks[i] * b
+        self.x = self.x_0 + dt * slope
+
+        #error and step size control
+        if self.stage < self.s - 1:
+
+            #increment stage counter
+            self.stage += 1
+
+            #no error control for intermediate stages
+            return True, 0.0, 0.0, 1.0
+        
+        else: 
+
+            #reset stage counter
+            self.stage = 0
+
+            #compute truncation error estimate in final stage
+            return self.error_controller(dt)
+
+
+
+class DiagonallyImplicitRungeKutta(ImplicitSolver):
+    """
+    Base class for diagonally implicit Runge-Kutta (DIRK) integrators 
+    which implements the timestepping at intermediate stages, involving
+    the numerical solution of the implicit update equation and the 
+    error control if the coefficients for the local truncation error 
+    estimate are defined.
+
+    Extensions and checks to also handle explicit first stages (ESDIRK) 
+    and additional final evaluation coefficients (not stiffly accurate)
+    
+    NOTE:
+        This class is not intended to be used directly!!!
+    """
+
+    def __init__(self, *solver_args, **solver_kwargs):
+        super().__init__(*solver_args, **solver_kwargs)
+
+        #order of the integration scheme and embedded method (if available)
+        self.n = 0
+        self.m = 0
+
+        #number of stages in RK scheme
+        self.s = 0
+
+        #safety factor for error controller (if available)
+        self.beta = 0.9
+
+        #slope coefficients for stages
+        self.Ks = {}
+
+        #extended butcher tableau
+        self.BT = None
+
+        #final evaluation (if not stiffly accurate)
+        self.A = None
+
+        #coefficients for local truncation error estimate
+        self.TR = None
+
+
+    def error_controller(self, dt):
+        """
+        compute scaling factor for adaptive timestep based on 
+        absolute and relative local truncation error estimate, 
+        also checks if the error tolerance is achieved and returns 
+        a success metric.
+
+        INPUTS:
+            dt : (float) integration timestep
+        """
+
+        #early exit of not enough slopes or no error estimate at all
+        if self.TR is None or len(self.Ks) < len(self.TR): 
+            return True, 0.0, 0.0, 1.0
+
+        #compute local truncation error slope (this is faster then 'sum' comprehension)
+        slope = 0.0
+        for i, b in enumerate(self.TR):
+            slope = slope + self.Ks[i] * b
+        tr = dt * slope
+
+        #compute and clip truncation error, error ratio abs
+        truncation_error_abs = float(np.max(np.clip(abs(tr), 1e-18, None)))
+        error_ratio_abs = self.tolerance_lte_abs / truncation_error_abs
+
+        #compute and clip truncation error, error ratio rel
+        if np.any(self.x == 0.0): 
+            truncation_error_rel = 1.0
+            error_ratio_rel = 0.0
+        else:
+            truncation_error_rel = float(np.max(np.clip(abs(tr/self.x), 1e-18, None)))
+            error_ratio_rel = self.tolerance_lte_rel / truncation_error_rel
+        
+        #compute error ratio and success check
+        error_ratio = max(error_ratio_abs, error_ratio_rel)
+        success = error_ratio >= 1.0
+
+        #compute timestep scale factor using accuracy order of truncation error
+        timestep_rescale = self.beta * error_ratio**(1/(min(self.m, self.n) + 1))   
+
+        return success, truncation_error_abs, truncation_error_rel, timestep_rescale
+
+
+    def solve(self, u, t, dt):
+        """
+        Solves the implicit update equation via anderson acceleration.
+
+        INPUTS:
+            u  : (float) non-autonomous external component for integration
+            t  : (float) evaluation time for right-hand-side function
+            dt : (float) integration timestep
+        """
+
+        #first stage is explicit -> ESDIRK -> early exit
+        if self.stage == 0 and self.BT[self.stage] is None:
+            return 0.0
+            
+        #update timestep weighted slope 
+        self.Ks[self.stage] = self.func(self.x, u, t)
+
+        #compute slope (this is faster then 'sum' comprehension)
+        slope = 0.0
+        for i, a in enumerate(self.BT[self.stage]):
+            slope = slope + self.Ks[i] * a
+
+        #use the jacobian
+        if self.jac is not None:
+
+            #most recent butcher coefficient
+            b = self.BT[self.stage][self.stage]
+
+            #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 (explicit) timestep at the intermediate RK stages 
+        for (t+dt) based on the state and input at (t)
+
+        INPUTS:
+            u  : (float) non-autonomous external component for integration
+            t  : (float) evaluation time for right-hand-side function
+            dt : (float) integration timestep
+        """
+
+        #first stage is explicit -> ESDIRK
+        if self.stage == 0 and self.BT[self.stage] is None:
+            self.Ks[self.stage] = self.func(self.x, u, t)
+
+        #restart anderson accelerator 
+        self.acc.reset()
+
+        #error and step size control
+        if self.stage < self.s - 1:
+
+            #increment stage counter
+            self.stage += 1
+
+            #no error estimate for intermediate stages
+            return True, 0.0, 0.0, 1.0
+
+        else: 
+
+            #compute final output if not stiffly accurate
+            if self.A is not None:
+
+                #compute slope (this is faster then 'sum' comprehension)
+                slope = 0.0
+                for i, a in enumerate(self.A):
+                    slope = slope + self.Ks[i] * a
+                self.x = self.x_0 + dt * slope
+            
+            #reset stage counter
+            self.stage = 0
+
+            #compute truncation error estimate in final stage
+            return self.error_controller(dt)

{pathsim-0.4.2 → pathsim-0.4.3}/pathsim/solvers/_solver.py

@@ -56,6 +56,9 @@ class Solver:
         #flag to identify adaptive/fixed timestep solvers
         self.is_adaptive = False
 
+        #order of the integration scheme
+        self.n = 1
+
         #current evaluation stage for multistage solvers
         self.stage = 0
 
@@ -186,7 +189,7 @@ class ExplicitSolver(Solver):
     """
     Base class for explicit solver definition.
 
-    INPUTS : 
+    INPUTS (*solver_args, **solver_kwargs) : 
         initial_value     : (float or array) initial condition / integration constant
         func              : (callable) function to integrate with state 'x', input 'u' and time 't' dependency
         jac               : (callable or None) jacobian of 'func' with respect to 'x', depending on 'x', 'u' and 't', if 'None', no jacobian is used
@@ -194,17 +197,8 @@ class ExplicitSolver(Solver):
         tolerance_lte_rel : (float) relative tolerance for local truncation error (for solvers with error estimate)
     """
 
-    def __init__(self, 
-                 initial_value=0, 
-                 func=lambda x, u, t: u, 
-                 jac=None, 
-                 tolerance_lte_abs=1e-6, 
-                 tolerance_lte_rel=1e-3):
-        super().__init__(initial_value, 
-                         func, 
-                         jac, 
-                         tolerance_lte_abs, 
-                         tolerance_lte_rel)
+    def __init__(self, *solver_args, **solver_kwargs):
+        super().__init__(*solver_args, **solver_kwargs)
 
         #flag to identify implicit/explicit solvers
         self.is_explicit = True
@@ -292,7 +286,7 @@ class ImplicitSolver(Solver):
     """
     Base class for implicit solver definition. 
 
-    INPUTS : 
+    INPUTS (*solver_args, **solver_kwargs) :  
         initial_value     : (float or array) initial condition / integration constant
         func              : (callable) function to integrate with state 'x', input 'u' and time 't' dependency
         jac               : (callable or None) jacobian of 'func' with respect to 'x', depending on 'x', 'u' and 't', if 'None', no jacobian is used
@@ -300,17 +294,8 @@ class ImplicitSolver(Solver):
         tolerance_lte_rel : (float) relative tolerance for local truncation error (for solvers with error estimate)
     """
 
-    def __init__(self, 
-                 initial_value=0, 
-                 func=lambda x, u, t: u, 
-                 jac=None, 
-                 tolerance_lte_abs=1e-6, 
-                 tolerance_lte_rel=1e-3):
-        super().__init__(initial_value, 
-                         func, 
-                         jac, 
-                         tolerance_lte_abs, 
-                         tolerance_lte_rel)
+    def __init__(self, *solver_args, **solver_kwargs):
+        super().__init__(*solver_args, **solver_kwargs)
 
         #flag to identify implicit/explicit solvers
         self.is_explicit = False

{pathsim-0.4.2 → pathsim-0.4.3}/pathsim/solvers/bdf.py

@@ -10,7 +10,6 @@
 # IMPORTS ==============================================================================
 
 from ._solver import ImplicitSolver
-from ..utils.funcs import numerical_jacobian
 
 
 # SOLVERS ==============================================================================
@@ -21,17 +20,11 @@ class BDF2(ImplicitSolver):
     with order ramp up for the initial steps.
     """
 
-    def __init__(self, 
-                 initial_value=0, 
-                 func=lambda x, u, t: u, 
-                 jac=None, 
-                 tolerance_lte_abs=1e-6, 
-                 tolerance_lte_rel=1e-3):
-        super().__init__(initial_value, 
-                         func, 
-                         jac, 
-                         tolerance_lte_abs, 
-                         tolerance_lte_rel)
+    def __init__(self, *solver_args, **solver_kwargs):
+        super().__init__(*solver_args, **solver_kwargs)
+
+        #integration order (local)
+        self.n = 2
 
         #bdf coefficients
         self.K = {1:[1.0], 2:[-1/3, 4/3]}
@@ -103,17 +96,11 @@ class BDF3(ImplicitSolver):
     with order ramp up for the initial steps.
     """
 
-    def __init__(self, 
-                 initial_value=0, 
-                 func=lambda x, u, t: u, 
-                 jac=None, 
-                 tolerance_lte_abs=1e-6, 
-                 tolerance_lte_rel=1e-3):
-        super().__init__(initial_value, 
-                         func, 
-                         jac, 
-                         tolerance_lte_abs, 
-                         tolerance_lte_rel)
+    def __init__(self, *solver_args, **solver_kwargs):
+        super().__init__(*solver_args, **solver_kwargs)
+
+        #integration order (local)
+        self.n = 3
 
         #bdf coefficients
         self.K = {1:[1.0], 
@@ -165,7 +152,6 @@ class BDF3(ImplicitSolver):
         return err
 
 
-
     def step(self, u, t, dt):
         """
         Performs the timestep by buffereing the previous state.
@@ -188,17 +174,11 @@ class BDF4(ImplicitSolver):
     with order ramp up for the initial steps.
     """
 
-    def __init__(self, 
-                 initial_value=0, 
-                 func=lambda x, u, t: u, 
-                 jac=None, 
-                 tolerance_lte_abs=1e-6, 
-                 tolerance_lte_rel=1e-3):
-        super().__init__(initial_value, 
-                         func, 
-                         jac, 
-                         tolerance_lte_abs, 
-                         tolerance_lte_rel)
+    def __init__(self, *solver_args, **solver_kwargs):
+        super().__init__(*solver_args, **solver_kwargs)
+
+        #integration order (local)
+        self.n = 4
 
         #bdf coefficients
         self.K = {1:[1.0], 

pathsim-0.4.3/pathsim/solvers/dirk2.py

@@ -0,0 +1,47 @@
+########################################################################################
+##
+##                       DIAGONALLY IMPLICIT RUNGE KUTTA METHOD
+##                                (solvers/dirk2.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+from ._rungekutta import DiagonallyImplicitRungeKutta
+
+
+# SOLVERS ==============================================================================
+
+class DIRK2(DiagonallyImplicitRungeKutta):
+    """
+    The 2-stage SSP-optimal Diagonally Implicit Runge–Kutta (DIRK) method 
+    of second order, namely the second order RK with the largest radius 
+    of absolute monotonicity. 
+    It is also symplectic and the optimal 2-stage second order implicit RK.
+    
+    FROM : 
+        L. Ferracina and M.N. Spijker. 
+        Strong stability of singlydiagonally-implicit Runge-Kutta methods. 
+        Applied Numerical Mathematics, 58:1675–1686, 2008.
+    """
+
+    def __init__(self, *solver_args, **solver_kwargs):
+        super().__init__(*solver_args, **solver_kwargs)
+
+        #number of stages in RK scheme
+        self.s = 2
+
+        #order of scheme
+        self.n = 2
+
+        #intermediate evaluation times
+        self.eval_stages = [1/4, 3/4]
+
+        #butcher table
+        self.BT = {0:[1/4],
+                   1:[1/2, 1/4]}
+
+        #final evaluation
+        self.A = [1/2, 1/2]

pathsim-0.4.3/pathsim/solvers/dirk3.py

@@ -0,0 +1,40 @@
+########################################################################################
+##
+##                       DIAGONALLY IMPLICIT RUNGE KUTTA METHOD
+##                                (solvers/dirk3.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+from ._rungekutta import DiagonallyImplicitRungeKutta
+
+
+# SOLVERS ==============================================================================
+
+class DIRK3(DiagonallyImplicitRungeKutta):
+    """
+    Four-stage, 3rd order, L-stable Diagonally Implicit Runge–Kutta (DIRK) method.
+
+    (from Wikipedia)
+    """
+
+    def __init__(self, *solver_args, **solver_kwargs):
+        super().__init__(*solver_args, **solver_kwargs)
+
+        #number of stages in RK scheme
+        self.s = 4
+
+        #order of scheme
+        self.n = 3
+
+        #intermediate evaluation times
+        self.eval_stages = [1/2, 2/3, 1/2, 1.0]
+
+        #butcher table
+        self.BT = {0:[1/2],
+                   1:[1/6, 1/2], 
+                   2:[-1/2, 1/2, 1/2], 
+                   3:[3/2, -3/2, 1/2, 1/2]}

pathsim-0.4.3/pathsim/solvers/esdirk32.py

@@ -0,0 +1,47 @@
+########################################################################################
+##
+##                   EMBEDDED DIAGONALLY IMPLICIT RUNGE KUTTA METHOD
+##                                (solvers/esdirk32.py)
+##
+##                                  Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+from ._rungekutta import DiagonallyImplicitRungeKutta
+
+
+# SOLVERS ==============================================================================
+
+class ESDIRK32(DiagonallyImplicitRungeKutta):
+    """
+    Williams et.al constructed an ESDIRK method of order 3 with four stages.
+    This method is constructed such that it is applicable to index-2 
+    differential algebraic systems.
+    """
+
+    def __init__(self, *solver_args, **solver_kwargs):
+        super().__init__(*solver_args, **solver_kwargs)
+
+        #number of stages in RK scheme
+        self.s = 4
+
+        #order of scheme and embedded method
+        self.n = 3
+        self.m = 2
+
+        #flag adaptive timestep solver
+        self.is_adaptive = True
+
+        #intermediate evaluation times
+        self.eval_stages = [0.0, 1.0, 3/2, 1.0]
+
+        #butcher table
+        self.BT = {0:None, #explicit first stage
+                   1:[1/2, 1/2],
+                   2:[5/8, 3/8, 1/2],
+                   3:[7/18, 1/3, -2/9, 1/2]}
+
+        #coefficients for truncation error estimate
+        self.TR = [-1/9, -1/6, -2/9, 1/2]

pathsim-0.4.3/pathsim/solvers/esdirk4.py

@@ -0,0 +1,42 @@
+########################################################################################
+##
+##                       DIAGONALLY IMPLICIT RUNGE KUTTA METHOD
+##                                (solvers/esdirk4.py)
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+from ._rungekutta import DiagonallyImplicitRungeKutta
+
+
+# SOLVERS ==============================================================================
+
+class ESDIRK4(DiagonallyImplicitRungeKutta):
+    """
+    6-stage, 4th order Diagonally Implicit Runge–Kutta (DIRK) method 
+    with explicit first stage that is specifically designed to handle 
+    differential algebraic equations of indices up to two or three.
+    """
+
+    def __init__(self, *solver_args, **solver_kwargs):
+        super().__init__(*solver_args, **solver_kwargs)
+
+        #number of stages in RK scheme
+        self.s = 6
+
+        #order of scheme
+        self.n = 4
+
+        #intermediate evaluation times
+        self.eval_stages = [0.0, 1/2, 1/6, 37/40, 1/2, 1.0]
+
+        #butcher table
+        self.BT = {0:None, #explicit first stage
+                   1:[1/4, 1/4],
+                   2:[-1/36, -1/18, 1/4],
+                   3:[-21283/32000, -5143/64000, 90909/64000, 1/4],
+                   4:[46010759/749250000, -737693/40500000, 10931269/45500000, -1140071/34090875, 1/4],
+                   5:[89/444, 89/804756, -27/364, -20000/171717, 843750/1140071, 1/4]}