pathsim 0.2.0__py3-none-any.whl

pathsim/blocks/lti.py

@@ -0,0 +1,155 @@
+#########################################################################################
+##
+##               LINEAR TIME INVARIANT DYNAMICAL BLOCKS (blocks/lti.py)
+##
+##             This module defines linear time invariant dynamical blocks
+##
+##                                 Milan Rother 2024
+##
+#########################################################################################
+
+# IMPORTS ===============================================================================
+
+import numpy as np
+
+from ._block import Block
+
+from ..utils.funcs import (
+    max_error_dicts,
+    dict_to_array, 
+    array_to_dict
+    )
+
+from ..utils.gilbert import (
+    gilbert_realization
+    )
+
+
+# LTI BLOCKS ============================================================================
+
+class StateSpace(Block):
+    """
+    This block integrates a LTI MIMO state space model with the structure
+
+        d/dt x = A x + B u
+             y = C x + D u 
+
+    where A, B, C and D are the state space matrices, x is the state, 
+    u the input and y the output vector.
+
+    INPUTS : 
+        A, B, C, D    : (numpy arrays) state space matrices
+        initial_value : (array of floars) initial state / initial condition
+    """
+
+    def __init__(self, 
+                 A=-1.0, B=1.0, C=-1.0, D=1.0, 
+                 initial_value=None):
+        super().__init__()
+
+        #statespace matrices with input shape validation
+        self.A = np.atleast_2d(A)
+        self.B = np.atleast_1d(B)
+        self.C = np.atleast_1d(C)
+        self.D = np.atleast_1d(D)
+
+        #get statespace dimensions
+        n, _ = self.A.shape 
+        if self.B.ndim == 1: n_in = 1 
+        else: _, n_in = self.B.shape 
+        if self.C.ndim == 1: n_out = 1 
+        else: n_out, _ = self.C.shape
+
+        #set io channels
+        self.inputs  = {i:0.0 for i in range(n_in)}
+        self.outputs = {i:0.0 for i in range(n_out)}
+
+        #initial condition
+        self.initial_value = np.zeros(n) if initial_value is None else initial_value
+
+
+    def __len__(self):
+        #check if direct passthrough exists
+        return int(np.any(self.D))
+
+    
+    def set_solver(self, Solver, tolerance_lte=1e-6):
+        
+        if self.engine is None:
+
+            def _f(x, u, t): 
+                return np.dot(self.A, x) + np.dot(self.B, u) 
+            def _jac(x, u, t): 
+                return self.A
+
+            #initialize the integration engine with right hand side
+            self.engine = Solver(self.initial_value, _f, _jac, tolerance_lte)
+
+        else:
+
+            #change solver if already initialized
+            self.engine = self.engine.change(Solver, tolerance_lte)        
+
+
+    def update(self, t):
+        #compute implicit balancing update 
+        prev_outputs = self.outputs.copy()
+        u = dict_to_array(self.inputs)
+        y = np.dot(self.C, self.engine.get()) + np.dot(self.D, u)
+        self.outputs = array_to_dict(y)
+        return max_error_dicts(prev_outputs, self.outputs)
+
+
+    def solve(self, t, dt):
+        #advance solution of implicit update equation and update outputs
+        return self.engine.solve(dict_to_array(self.inputs), t, dt)
+
+
+    def step(self, t, dt):
+        #compute update step with integration engine and update outputs
+        return self.engine.step(dict_to_array(self.inputs), t, dt)
+
+
+class TransferFunction(StateSpace):
+    """
+    This block integrates a LTI (MIMO for pole residue) transfer function.
+
+    The transfer function is defined in pole-residue form
+    
+        H(s) = Const + sum( Residues / (s - Poles) )
+
+    where 'Poles' are the scalar poles of the transfer function and
+    'Residues' are the possibly matrix valued (in MIMO case) residues of
+    the transfer function. 'Const' has same shape as 'Residues'.
+
+    Upon initialization, the state space realization of the transfer 
+    function is computed using a minimal gilbert realization.
+
+    The resulting statespace model of the form
+
+        d/dt x = A x + B u
+             y = C x + D u 
+
+    is handled the same as the 'StateSpace' block, where A, B, C and D 
+    are the state space matrices, x is the internal state, u the input and 
+    y the output vector.
+
+    INPUTS : 
+        Poles    : (list or array of scalars) transfer function poles
+        Residues : (list or array of scalars or arrays) transfer function residues
+        Const    : (scalar or array) constant term of transfer function
+    """
+
+    def __init__(self, 
+                 Poles=[], 
+                 Residues=[], 
+                 Const=0.0):
+
+        #model parameters of transfer function in pole-residue form
+        self.Const, self.Poles, self.Residues = Const, Poles, Residues
+
+        #Statespace realization of transfer function
+        A, B, C, D = gilbert_realization(Poles, Residues, Const)
+
+        #initialize statespace model
+        super().__init__(A, B, C, D)

pathsim/blocks/multiplier.py

@@ -0,0 +1,30 @@
+#########################################################################################
+##
+##                        REDUCTION BLOCKS (blocks/multiplier.py)
+##
+##                     This module defines static 'Multiplier' block
+##
+##                                   Milan Rother 2024
+##
+#########################################################################################
+
+# IMPORTS ===============================================================================
+
+import numpy as np
+
+from ._block import Block
+
+from ..utils.funcs import dict_to_array
+
+
+# MISO BLOCKS ===========================================================================
+
+class Multiplier(Block):
+    """
+    multiplies / product of all input signals (MISO)
+    """
+
+    def update(self, t):
+        prev_output = self.outputs[0]
+        self.outputs[0] = np.prod(dict_to_array(self.inputs), axis=0)
+        return abs(prev_output - self.outputs[0])

pathsim/blocks/ode.py

@@ -0,0 +1,86 @@
+#########################################################################################
+##
+##                       ORDINARY DIFFERENTIAL EQUATION BLOCK 
+##                                 (blocks/ode.py)
+##
+##                                Milan Rother 2024
+##
+#########################################################################################
+
+# IMPORTS ===============================================================================
+
+import numpy as np
+
+from ._block import Block
+
+from ..utils.funcs import (
+    dict_to_array, 
+    array_to_dict,
+    auto_jacobian
+    )
+
+
+# BLOCKS ================================================================================
+
+class ODE(Block):
+    """
+    This block implements an ordinary differential equation (ODE) 
+    defined by its right hand side
+
+        d/dt x = func(x, u, t)
+    
+    with inhomogenity (input) u and state vector x. The function 
+    can be nonlinear and the ODE can be of arbitrary order. 
+    The block utilizes the integration engine to solve the ODE 
+    by integrating the 'func' right hand side function.
+
+    INPUTS : 
+        func          : (callable object) right hand side function of ODE
+        initial_value : (array of floats) initial state / initial condition
+        jac           : (callable or None) jacobian of 'func' or 'None'
+    """
+
+    def __init__(self,
+                 func=lambda x, u, t: -x,
+                 initial_value=0.0,
+                 jac=None):
+
+        super().__init__()
+          
+        #right hand side function of ODE
+        self.func = func
+
+        #initial condition
+        self.initial_value = initial_value
+
+        #jacobian of 'func'
+        self.jac = jac
+        
+
+    def __len__(self):
+        return 0
+
+
+    def set_solver(self, Solver, tolerance_lte=1e-6):
+        #change solver if already initialized
+        if self.engine is not None:
+            self.engine = self.engine.change(Solver, tolerance_lte)
+            return #quit early
+        #initialize the integration engine with right hand side
+        _jac = auto_jacobian(self.func) if self.jac is None else self.jac
+        self.engine = Solver(self.initial_value, self.func, _jac, tolerance_lte)
+
+
+    def update(self, t):
+        self.outputs = array_to_dict(self.engine.get())
+        return 0
+
+
+    def solve(self, t, dt):
+        #advance solution of implicit update equation and update block outputs
+        return self.engine.solve(dict_to_array(self.inputs), t, dt)
+
+
+    def step(self, t, dt):
+        #compute update step with integration engine and update block outputs
+        return self.engine.step(dict_to_array(self.inputs), t, dt)

pathsim/blocks/rf/__init__.py

@@ -0,0 +1,4 @@
+from .sources import *
+from .filters import *
+from .noise import *
+from .wienerhammerstein import *

pathsim/blocks/rf/filters.py

@@ -0,0 +1,169 @@
+#########################################################################################
+##
+##                              RF FILTERS (filters.py)
+##
+##                                Milan Rother 2024
+##
+#########################################################################################
+
+# IMPORTS ===============================================================================
+
+import numpy as np
+
+from scipy.signal import butter, tf2ss
+
+from math import factorial
+
+from ..lti import StateSpace
+
+
+
+# FILTER BLOCKS =========================================================================
+
+class ButterworthLowpassFilter(StateSpace):
+
+    """
+    Direct implementation of a low pass butterworth filter block.
+
+    Follows the same structure as the 'StateSpace' block in the 
+    'pathsim.blocks' module. The numerator and denominator of the 
+    filter transfer function are generated and then the transfer 
+    function is realized as a state space model. 
+    
+    INPUTS : 
+        Fc : (float) corner frequency of the filter in [Hz]
+        n  : (int) filter order
+    """
+
+    def __init__(self, Fc, n):
+
+        #filter parameters
+        self.Fc = Fc
+        self.n = n
+
+        #use scipy.signal for filter design
+        num, den = butter(n, 2*np.pi*Fc, btype="low", analog=True, output="ba")
+
+        #initialize parent block
+        super().__init__(*tf2ss(num, den))
+
+
+class ButterworthHighpassFilter(StateSpace):
+
+    """
+    Direct implementation of a high pass butterworth filter block.
+
+    Follows the same structure as the 'StateSpace' block in the 
+    'pathsim.blocks' module. The numerator and denominator of the 
+    filter transfer function are generated and then the transfer 
+    function is realized as a state space model. 
+    
+    INPUTS : 
+        Fc : (float) corner frequency of the filter in [Hz]
+        n  : (int) filter order
+    """
+
+    def __init__(self, Fc, n):
+
+        #filter parameters
+        self.Fc = Fc
+        self.n = n
+
+        #use scipy.signal for filter design
+        num, den = butter(n, 2*np.pi*Fc, btype="high", analog=True, output="ba")
+
+        #initialize parent block
+        super().__init__(*tf2ss(num, den))
+
+
+class ButterworthBandpassFilter(StateSpace):
+
+    """
+    Direct implementation of a bandpass butterworth filter block.
+
+    Follows the same structure as the 'StateSpace' block in the 
+    'pathsim.blocks' module. The numerator and denominator of the 
+    filter transfer function are generated and then the transfer 
+    function is realized as a state space model. 
+    
+    INPUTS : 
+        Fc : (list, tuple) corner frequencies of the filter in [Hz]
+        n  : (int) filter order
+    """
+
+    def __init__(self, Fc, n):
+
+        #filter parameters
+        self.Fc = np.asarray(Fc)
+        self.n = n
+
+        if len(Fc) != 2:
+            raise ValueError("'ButterworthBandpassFilter' requires two corner frequencies!")
+
+        #use scipy.signal for filter design
+        num, den = butter(n, 2*np.pi*self.Fc, btype="bandpass", analog=True, output="ba")
+
+        #initialize parent block
+        super().__init__(*tf2ss(num, den))
+
+
+class ButterworthBandstopFilter(StateSpace):
+
+    """
+    Direct implementation of a bandstop butterworth filter block.
+
+    Follows the same structure as the 'StateSpace' block in the 
+    'pathsim.blocks' module. The numerator and denominator of the 
+    filter transfer function are generated and then the transfer 
+    function is realized as a state space model. 
+    
+    INPUTS : 
+        Fc : (list, tuple) corner frequencies of the filter in [Hz]
+        n  : (int) filter order
+    """
+
+    def __init__(self, Fc, n):
+
+        #filter parameters
+        self.Fc = np.asarray(Fc)
+        self.n = n
+
+        if len(Fc) != 2:
+            raise ValueError("'ButterworthBandstopFilter' requires two corner frequencies!")
+
+        #use scipy.signal for filter design
+        num, den = butter(n, 2*np.pi*self.Fc, btype="bandstop", analog=True, output="ba")
+
+        #initialize parent block
+        super().__init__(*tf2ss(num, den))
+
+
+class AllpassFilter(StateSpace):
+
+    """
+    Direct implementation of an Allpass filter using Pade approximants. 
+    The transfer function of the ideal allpass is
+    
+        H(s) = exp(-sT) = exp(-sT/2) / exp(sT/2)
+
+    where T is the time delay. This implementation uses Pade approximation 
+    of the exponential to create a n-th order LTI statespace model that is 
+    used for the numerical integration internally.
+    
+    INPUTS : 
+        T : (float) time delay of the allpass in [s]
+        n : (int) order of the pade approximation
+    """
+
+    def __init__(self, T, n=1):
+
+        #filter parameters
+        self.T = T
+        self.n = n
+
+        #taylor approximations for numerator and denominator
+        num = [(-T/2)**i/factorial(i) for i in range(n+1)]
+        den = [ (T/2)**i/factorial(i) for i in range(n+1)]
+
+        #initialize parent block
+        super().__init__(*tf2ss(num, den))

pathsim/blocks/rf/noise.py

@@ -0,0 +1,218 @@
+#########################################################################################
+##
+##                             SPECIAL RF NOISE SOURCES 
+##                                (blocks/rf/noise.py)
+##
+##            this module implements some noise sources for RF simulations
+##
+##                                Milan Rother 2024
+##
+#########################################################################################
+
+# IMPORTS ===============================================================================
+
+import numpy as np
+
+from .._block import Block
+
+
+# NOISE SOURCE BLOCKS ===================================================================
+
+class WhiteNoise(Block):
+    """
+    White noise source with uniform spectral density. Samples from distribution 
+    with 'sampling_rate' and holds noise values constant for time bins.
+
+    If no 'sampling_rate' (None) is specified, every simulation timestep 
+    gets a new noise values. This is the default setting.
+
+    INPUTS : 
+        spectral_density : (float) noise spectral density
+        sampling_rate    : (float or None) frequency with which the noise is sampled 
+    """
+
+    def __init__(self, spectral_density=1, sampling_rate=None):
+        super().__init__()
+
+        self.spectral_density = spectral_density
+        self.sampling_rate = sampling_rate 
+        self.sigma = np.sqrt(spectral_density)
+        self.n_samples = 0
+
+    def reset(self):
+        #reset inputs and outputs
+        self.inputs  = {0:0.0}  
+        self.outputs = {0:0.0}
+
+        #reset noise samples
+        self.n_samples = 0
+
+    def sample(self, t):
+        """
+        Sample from a normal distribution after successful timestep.
+        """
+        if (self.sampling_rate is None or 
+            self.n_samples < t * self.sampling_rate):
+            self.outputs[0] = np.random.normal(scale=self.sigma) 
+            self.n_samples += 1
+
+
+class OneOverFNoise(Block):
+    """
+    1/f noise source that is realized by integrating white noise using a 
+    numerical integrator. Samples from distribution with 'sampling_rate' 
+    and holds noise values constant for time bins.
+
+    If no 'sampling_rate' (None) is specified, every simulation timestep 
+    gets a new noise values. This is the default setting.
+
+    INPUTS : 
+        spectral_density : (float) noise spectral density
+        sampling_rate     : (float or None) frequency with which the noise is sampled 
+    """
+
+    def __init__(self, spectral_density=1, sampling_rate=None):
+        super().__init__()
+
+        #parameters of noise signal
+        self.spectral_density = spectral_density
+        self.sampling_rate = sampling_rate 
+        self.sigma = np.sqrt(spectral_density)
+        self.white_noise_value = 0.0
+        self.n_samples = 0
+
+
+    def set_solver(self, Solver, tolerance_lte=1e-6):
+        
+        #change solver if already initialized
+        if self.engine is not None:
+            self.engine = self.engine.change(Solver, tolerance_lte)
+            return #quit early
+
+        #initialize the numerical integration engine with kernel
+        def _f(x, u, t): return u
+        self.engine = Solver(0.0, _f, None, tolerance_lte)
+
+
+    def reset(self):
+        #reset inputs and outputs
+        self.inputs  = {0:0.0}  
+        self.outputs = {0:0.0}
+
+        #reset noise samples
+        self.white_noise_value = 0.0
+        self.n_samples = 0
+
+        #reset engine
+        self.engine.reset()
+
+
+    def update(self, t):
+        #set outputs
+        self.outputs[0] = self.engine.get()
+        return 0.0
+
+
+    def sample(self, t):
+        """
+        Sample from a normal distribution after successful timestep.
+        """
+        if (self.sampling_rate is None or 
+            self.n_samples < t * self.sampling_rate):
+            self.white_noise_value = np.random.normal(scale=self.sigma) 
+            self.n_samples += 1
+
+
+    def solve(self, t, dt):
+        #advance solution of implicit update equation
+        self.engine.solve(self.white_noise_value, t, dt)
+        return 0.0
+
+
+    def step(self, t, dt):
+        #compute update step with integration engine
+        self.engine.step(self.white_noise_value, t, dt)
+
+        #no error control for noise source
+        return True, 0.0, 1.0
+
+
+class SinusoidalPhaseNoiseSource(Block):
+
+    def __init__(self, frequency=1, amplitude=1, phase=0, sig_cum=0, sig_white=0, sampling_rate=10):
+        super().__init__()
+
+        self.amplitude = amplitude
+        self.frequency = frequency
+        self.phase = phase
+        
+        self.sampling_rate = sampling_rate
+
+        self.omega = 2 * np.pi * self.frequency
+
+        self.sig_cum = sig_cum
+        self.sig_white = sig_white
+
+        #initial noise sampling
+        self.noise_1 = np.random.normal() 
+        self.noise_2 = np.random.normal() 
+
+
+    def set_solver(self, Solver, tolerance_lte=1e-6):
+        
+        #change solver if already initialized
+        if self.engine is not None:
+            self.engine = self.engine.change(Solver, tolerance_lte)
+            return #quit early
+
+        #initialize the numerical integration engine with kernel
+        def _f(x, u, t): return u
+        self.engine = Solver(0.0, _f, None, tolerance_lte)
+
+
+    def reset(self):
+        #reset inputs and outputs
+        self.inputs  = {0:0.0}  
+        self.outputs = {0:0.0}
+
+        #reset bin counter
+        self.n_samples = 0
+        self.t_max = 0
+
+        #reset engine
+        self.engine.reset()
+
+
+    def update(self, t):
+
+        #compute phase error
+        phase_error = self.sig_white * self.noise_1 + self.sig_cum * self.engine.get()
+
+        #set output
+        self.outputs[0] = self.amplitude * np.sin(self.omega*t + self.phase + phase_error)
+        return 0.0
+
+
+    def sample(self, t):
+        """
+        Sample from a normal distribution after successful timestep.
+        """
+        if (self.sampling_rate is None or 
+            self.n_samples < t * self.sampling_rate):
+            self.noise_1 = np.random.normal() 
+            self.noise_2 = np.random.normal() 
+            self.n_samples += 1
+
+
+    def solve(self, t, dt):
+        #advance solution of implicit update equation
+        self.engine.solve(self.noise_2, t, dt)
+        return 0.0
+
+
+    def step(self, t, dt):
+        #compute update step with integration engine
+        self.engine.step(self.noise_2, t, dt)
+
+        #no error control for noise source
+        return True, 0.0, 1.0