pathsim 0.2.0__py3-none-any.whl

tests/test_simulation.py

@@ -0,0 +1,271 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                               'simulation.py'
+##
+##                              Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.simulation import Simulation
+
+#for testing
+from pathsim.blocks._block import Block
+from pathsim.connection import Connection
+
+
+
+# TESTS ================================================================================
+
+class TestSimulation(unittest.TestCase):
+    """
+    Test the implementation of the 'Simulation' class
+
+    only very minimal functonality
+    """
+
+    def test_init(self):
+
+        #test default initialization
+        Sim = Simulation(log=False)
+        self.assertEqual(Sim.blocks, [])
+        self.assertEqual(Sim.connections, [])
+        self.assertEqual(Sim.dt, 0.01)
+        self.assertEqual(Sim.dt_min, 0.0)
+        self.assertEqual(Sim.dt_max, None)
+        self.assertEqual(str(Sim.Solver()), "SSPRK22")
+        self.assertEqual(Sim.tolerance_fpi, 1e-12)
+        self.assertEqual(Sim.tolerance_lte, 1e-8)
+        self.assertEqual(Sim.iterations_min, 1) # <-- determined from internal path length
+        self.assertEqual(Sim.iterations_max, 200)
+        self.assertFalse(Sim.log)
+
+        #test specific initialization
+        B1, B2, B3 = Block(), Block(), Block()
+        C1 = Connection(B1, B2)
+        C2 = Connection(B2, B3)
+        C3 = Connection(B3, B1)
+        Sim = Simulation(blocks=[B1, B2, B3], 
+                         connections=[C1, C2, C3], 
+                         dt=0.02, 
+                         dt_min=0.001, 
+                         dt_max=0.1, 
+                         tolerance_fpi=1e-9, 
+                         tolerance_lte=1e-6, 
+                         iterations_min=None, 
+                         iterations_max=100, 
+                         log=False)
+        self.assertEqual(len(Sim.blocks), 3)
+        self.assertEqual(len(Sim.connections), 3)
+        self.assertEqual(Sim.dt, 0.02)
+        self.assertEqual(Sim.dt_min, 0.001)
+        self.assertEqual(Sim.dt_max, 0.1)
+        self.assertEqual(Sim.tolerance_fpi, 1e-9)
+        self.assertEqual(Sim.tolerance_lte, 1e-6)
+        self.assertEqual(Sim.iterations_min, 3) # <-- determined from internal path length
+        self.assertEqual(Sim.iterations_max, 100)
+
+        #test specific initialization with connection override
+        B1, B2, B3 = Block(), Block(), Block()
+        C1 = Connection(B1, B2)
+        C2 = Connection(B2, B3)
+        C3 = Connection(B3, B2) # <-- overrides B2
+        with self.assertRaises(ValueError):
+            Sim = Simulation(blocks=[B1, B2, B3], 
+                             connections=[C1, C2, C3],
+                             log=False)
+
+
+    def test_add_block(self):
+        
+        Sim = Simulation(log=False)
+
+        self.assertEqual(Sim.blocks, [])
+
+        #test adding a block
+        B1 = Block()
+        Sim.add_block(B1)
+        self.assertEqual(Sim.blocks, [B1])
+
+        #test adding the same block again
+        with self.assertRaises(ValueError):
+            Sim.add_block(B1)
+
+
+    def test_add_connection(self): 
+
+        B1, B2, B3 = Block(), Block(), Block()
+        C1 = Connection(B1, B2)
+
+        Sim = Simulation(blocks=[B1, B2, B3], 
+                         connections=[C1],
+                         log=False)
+
+        self.assertEqual(Sim.connections, [C1])
+
+        #test adding a connection
+        C2 = Connection(B2, B3)
+        Sim.add_connection(C2)
+        self.assertEqual(Sim.connections, [C1, C2])
+
+        #test adding the same connection again
+        with self.assertRaises(ValueError):
+            Sim.add_connection(C2)
+        self.assertEqual(Sim.connections, [C1, C2])
+
+        #test adding a connection that overrides B3
+        C3 = Connection(B1, B3) 
+        with self.assertRaises(ValueError):
+            Sim.add_connection(C3)
+        self.assertEqual(Sim.connections, [C1, C2])
+
+
+    def test_set_solver(self): pass
+    def test_update(self): pass
+    def test_step(self): pass
+    def test_run(self): pass
+
+
+class TestSimulationIVP(unittest.TestCase):
+    """
+    special test case:
+    linear feedback initial value problem with default solver (SSPRK22)
+    """
+
+    def setUp(self):
+
+        #modules from pathsim for test case
+        from pathsim.blocks import (
+            Integrator, Scope, 
+            Amplifier, Adder
+            )
+
+        #blocks that define the system
+        self.Int = Integrator(1.0)
+        self.Amp = Amplifier(-1)
+        self.Add = Adder()
+        self.Sco = Scope(labels=["response"])
+
+        blocks = [self.Int, self.Amp, self.Add, self.Sco]
+
+        #the connections between the blocks
+        connections = [
+            Connection(self.Amp, self.Add[1]),
+            Connection(self.Add, self.Int),
+            Connection(self.Int, self.Amp, self.Sco)
+            ]
+
+        #initialize simulation with the blocks, connections, timestep and logging enabled
+        self.Sim = Simulation(blocks, connections, dt=0.02, log=False)
+
+
+    def test_init(self):
+
+        from pathsim.solvers import SSPRK22
+
+        #test initialization of simulation
+        self.assertEqual(len(self.Sim.blocks), 4)
+        self.assertEqual(len(self.Sim.connections), 3)
+        self.assertEqual(self.Sim.dt, 0.02)
+        self.assertEqual(self.Sim.iterations_min, 2)
+        self.assertTrue(isinstance(self.Sim.engine, SSPRK22))
+        self.assertTrue(self.Sim.is_explicit)
+        self.assertFalse(self.Sim.is_adaptive)
+
+        #test if engine setup was correct
+        self.assertTrue(isinstance(self.Int.engine, SSPRK22)) # <-- only the Integrator needs an engine
+        self.assertTrue(self.Amp.engine is None)
+        self.assertTrue(self.Add.engine is None)
+        self.assertTrue(self.Sco.engine is None)
+
+
+    def test_step(self):
+
+        #reset first
+        self.Sim.reset()
+
+        #check if reset was sucecssful
+        self.assertEqual(self.Sim.time, 0.0)
+        self.assertEqual(self.Int.get(0), self.Int.initial_value)
+
+        #step using global timestep
+        success, err, scl, te, ts = self.Sim.step()
+        self.assertEqual(self.Sim.time, self.Sim.dt)
+        self.assertEqual(err, 0.0) #fixed solver
+        self.assertEqual(scl, 1.0) #fixed solver
+        self.assertEqual(ts, 0) #no implicit solver
+        self.assertGreaterEqual(te, self.Sim.iterations_min)
+        
+        #step again using custom timestep
+        self.Sim.step(dt=2.2*self.Sim.dt)
+        self.assertEqual(self.Sim.time, 3.2*self.Sim.dt)
+        self.assertLess(self.Int.get(0), self.Int.initial_value)
+
+        #test if scope recorded correctly
+        time, data = self.Sco.read()
+        for a, b in zip(time, [self.Sim.dt, 3.2*self.Sim.dt]):
+            self.assertEqual(a, b)
+
+        #reset again
+        self.Sim.reset()
+
+        #check if reset was sucecssful
+        self.assertEqual(self.Sim.time, 0.0)
+        self.assertEqual(self.Int.get(0), self.Int.initial_value)
+
+
+    def test_run(self):
+
+        #reset first
+        self.Sim.reset()
+
+        #check if reset was sucecssful
+        self.assertEqual(self.Sim.time, 0.0)
+        self.assertEqual(self.Int.get(0), self.Int.initial_value)
+
+        #test running for some time
+        self.Sim.run(duration=2, reset=True)
+        self.assertEqual(self.Sim.time, 2)
+        
+        time, data = self.Sco.read()
+        _time = np.arange(0, 2.02, 0.02)
+
+        #time recording matches and solution decays
+        self.assertLess(np.linalg.norm(time - _time), 1e-13) 
+        self.assertTrue(np.all(np.diff(data) < 0.0))
+
+        #test running for some time with reset
+        self.Sim.run(duration=1, reset=True)
+        self.assertEqual(self.Sim.time, 1)
+
+        time, data = self.Sco.read()
+        _time = np.arange(0, 1.02, 0.02)
+
+        #time recording matches and solution decays
+        self.assertLess(np.linalg.norm(time - _time), 1e-13) 
+
+        #test running for some time without reset
+        self.Sim.run(duration=2, reset=False)
+        self.assertEqual(self.Sim.time, 3)
+
+        time, data = self.Sco.read()
+        _time = np.arange(0, 3.02, 0.02)
+
+        #time recording matches and solution decays
+        self.assertLess(np.linalg.norm(time - _time), 1e-13) 
+
+
+
+
+
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/test_subsystem.py

@@ -0,0 +1,182 @@
+########################################################################################
+##
+##                                  TESTS FOR 
+##                                'subsystem.py'
+##
+##                               Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.subsystem import Subsystem, Interface
+
+#for testing
+from pathsim.blocks._block import Block
+from pathsim.connection import Connection
+
+
+# TESTS ================================================================================
+
+class TestInterface(unittest.TestCase):
+    """
+    Test the implementation of the 'Interface' class
+    """
+
+    def test_set_output(self):
+        I = Interface()
+
+        #test that outputs are zero
+        self.assertEqual(I.outputs, {0: 0.0})
+
+        #test if output is correctly set
+        I.set_output(0, 0.2)
+        I.set_output(1, 1.3)
+        I.set_output(2, 2.4)
+        I.set_output(3, 3.5)
+        
+        self.assertEqual(I.get(0), 0.2)
+        self.assertEqual(I.get(1), 1.3)
+        self.assertEqual(I.get(2), 2.4)
+        self.assertEqual(I.get(3), 3.5)
+
+
+    def test_get_input(self):
+
+        I = Interface()
+
+        #test that inputs are zero
+        self.assertEqual(I.inputs, {0: 0.0})
+
+        #test default retrieval        
+        self.assertEqual(I.get_input(2), 0.0)
+
+        #test if input is correctly retrieved
+        I.set(0, 0.2)
+        I.set(1, 1.3)
+        I.set(2, 2.4)
+        I.set(3, 3.5)
+        
+        self.assertEqual(I.get_input(0), 0.2)
+        self.assertEqual(I.get_input(1), 1.3)
+        self.assertEqual(I.get_input(2), 2.4)
+        self.assertEqual(I.get_input(3), 3.5)
+
+
+class TestSubsystem(unittest.TestCase):
+    """
+    test implementation of the 'Subsystem' class
+    """
+
+    def test_init(self):
+
+        #test default initialization
+        with self.assertRaises(ValueError):
+            S = Subsystem()
+
+        #test initialization without interface
+        with self.assertRaises(ValueError):
+            S = Subsystem(blocks=[Block(), Block()])
+
+        #test specific initialization with interface
+        B1, B2, B3 = Block(), Block(), Block()
+        I1 = Interface()
+        C1 = Connection(I1, B1, B2, B3)
+        C2 = Connection(B1, I1)
+        S = Subsystem(blocks=[B1, B2, B3, I1], connections=[C1, C2])
+        self.assertEqual(len(S.blocks), 3)
+        self.assertEqual(len(S.connections), 2)
+
+
+    def test_check_connections(self):
+
+        #test specific initialization with connecion override
+        B1, B2, B3 = Block(), Block(), Block()
+        I1 = Interface()
+        C1 = Connection(I1, B1, B2, B3)
+        C2 = Connection(B1, I1)
+        C3 = Connection(B2, B3) # <-- this one overrides B3
+        with self.assertRaises(ValueError):
+            S = Subsystem(blocks=[B1, B2, B3, I1], connections=[C1, C2, C3])
+
+
+    def test_len(self):
+
+        #test the len method for internal signal path estimation
+
+        I1 = Interface()
+        S = Subsystem(blocks=[I1],)
+        self.assertEqual(len(S), 1)
+
+        B1 = Block()
+        I1 = Interface()
+        C1 = Connection(I1, B1)
+        S = Subsystem(blocks=[I1, B1], connections=[C1])
+        self.assertEqual(len(S), 2)
+
+        B1, B2 = Block(), Block()
+        I1 = Interface()
+        C1 = Connection(I1, B1)
+        C2 = Connection(B1, B2)
+        S = Subsystem(blocks=[I1, B1, B2], connections=[C1, C2])
+        self.assertEqual(len(S), 3)
+
+        B1, B2, B3 = Block(), Block(), Block()
+        I1 = Interface()
+        C1 = Connection(I1, B1, B2, B3)
+        C2 = Connection(B1, B2[1])
+        C3 = Connection(B2, B1[1], B3[1])
+        C4 = Connection(B3, I1)
+        S = Subsystem(blocks=[I1, B1, B2, B3], connections=[C1, C2, C3, C4])
+        self.assertEqual(len(S), 5)
+
+
+    def test_set(self): 
+
+        B1 = Block()
+        I1 = Interface()
+        C1 = Connection(I1, B1, I1)
+        S = Subsystem(blocks=[I1, B1], connections=[C1])
+
+        self.assertEqual(S.interface.outputs, {0:0.0})
+
+        S.set(0, 1.1)
+        S.set(1, 2.2)
+        S.set(2, 3.3)
+
+        self.assertEqual(S.interface.outputs, {0:1.1, 1:2.2, 2:3.3})
+
+
+    def test_get(self): 
+
+        B1 = Block()
+        I1 = Interface()
+        C1 = Connection(I1, B1, I1)
+        S = Subsystem(blocks=[I1, B1], connections=[C1])
+
+        S.interface.inputs = {0:1.1, 1:2.2, 2:3.3}
+
+        self.assertEqual(S.get(0), 1.1)
+        self.assertEqual(S.get(1), 2.2)
+        self.assertEqual(S.get(2), 3.3)
+
+
+    def test_update(self): 
+
+        B1 = Block()
+        I1 = Interface()
+        C1 = Connection(I1, B1)
+        S = Subsystem(blocks=[I1, B1], connections=[C1])
+
+        err = S.update(0)
+
+        self.assertEqual(err, 0.0)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/utils/test_adaptivebuffer.py

@@ -0,0 +1,111 @@
+########################################################################################
+##
+##                                     TESTS FOR 
+##                             'utils/adaptivebuffer.py'
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.utils.adaptivebuffer import (
+    AdaptiveBuffer
+    )
+
+
+# TESTS ================================================================================
+
+class TestAdaptiveBuffer(unittest.TestCase):
+    """
+    test the implementation of the 'AdaptiveBuffer' class 
+    """
+
+    def test_init(self):
+
+        d = 100
+
+        buffer = AdaptiveBuffer(d)
+
+        #test initialization
+        self.assertEqual(buffer.delay, d)
+        self.assertEqual(len(buffer.buffer), 0)
+        self.assertEqual(buffer.counter, 0)
+
+
+    def test_add(self):
+
+        d = 100
+
+        buffer = AdaptiveBuffer(d)
+
+        for i in range(10*d):
+
+            #test the counter
+            self.assertLessEqual(buffer.counter, buffer.clean_every+1)
+
+            buffer.add(i, i)
+
+
+    def test_get_empty(self):
+
+        d = 100
+
+        buffer = AdaptiveBuffer(d)
+
+        #test default empty buffer
+        self.assertEqual(buffer.get(123), 0)
+
+
+    def test_get(self):
+
+        d = 100
+
+        buffer = AdaptiveBuffer(d)
+
+        for i in range(10*d):
+
+            buffer.add(i, i)
+
+            #test buffer readout
+            self.assertEqual(buffer.get(i), 0 if i < d else i-d)
+
+
+    def test_get_too_large(self):
+
+        d = 100
+
+        buffer = AdaptiveBuffer(d)
+
+        for i in range(10*d):
+
+            buffer.add(i, i)
+
+            #test buffer readout out of bounds (most recent value)
+            self.assertEqual(buffer.get(100*d), i)
+
+
+    def test_clear(self):
+
+        d = 100
+
+        buffer = AdaptiveBuffer(d)
+
+        for i in range(10*d):
+
+            buffer.add(i, i)
+
+        buffer.clear()
+
+        #test buffer clearing
+        self.assertEqual(len(buffer.buffer), 0)
+        self.assertEqual(buffer.counter, 0)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/utils/test_anderson.py

@@ -0,0 +1,142 @@
+########################################################################################
+##
+##                                     TESTS FOR 
+##                                'utils/anderson.py'
+##
+##                                 Milan Rother 2024
+##
+########################################################################################
+
+# IMPORTS ==============================================================================
+
+import unittest
+import numpy as np
+
+from pathsim.utils.anderson import (
+    AndersonAcceleration, 
+    NewtonAndersonAcceleration
+    )
+
+
+# TESTS ================================================================================
+
+class TestAndersonAcceleration(unittest.TestCase):
+    """
+    test the implementation of the 'AndersonAcceleration' class 
+    """
+
+    def test_init(self):
+        m = 5
+        aa = AndersonAcceleration(m)
+        # test initialization
+        self.assertEqual(aa.m, m)
+        self.assertTrue(aa.restart)
+        self.assertEqual(len(aa.x_buffer), 0)
+        self.assertEqual(len(aa.f_buffer), 0)
+        self.assertEqual(aa.counter, 0)
+
+    def test_reset(self):
+        aa = AndersonAcceleration(5)
+        aa.x_buffer = [1, 2, 3]
+        aa.f_buffer = [4, 5, 6]
+        aa.counter = 10
+        aa.reset()
+        # test reset
+        self.assertEqual(len(aa.x_buffer), 0)
+        self.assertEqual(len(aa.f_buffer), 0)
+        self.assertEqual(aa.counter, 0)
+
+    def test_step_scalar(self):
+        aa = AndersonAcceleration(2)
+        x, g = 1.0, 2.0
+        result, residual = aa.step(x, g)
+        # test scalar step
+        self.assertEqual(result, g)
+        self.assertEqual(residual, abs(g - x))
+
+    def test_step_vector(self):
+        aa = AndersonAcceleration(2)
+        x = np.array([1.0, 2.0])
+        g = np.array([2.0, 3.0])
+        result, residual = aa.step(x, g)
+        # test vector step
+        np.testing.assert_array_equal(result, g)
+        self.assertAlmostEqual(residual, np.linalg.norm(g - x))
+
+    def test_solve_scalar_equation(self):
+        # Solve x = cos(x)
+        aa = AndersonAcceleration(m=3)
+        x = 0.0
+        for _ in range(100):
+            g = np.cos(x)
+            x, residual = aa.step(x, g)
+            if residual < 1e-8:
+                break
+        self.assertAlmostEqual(x, 0.7390851332151607, places=7)
+
+
+    def test_solve_vector_equation(self):
+        # Solve the system:
+        # x^2 + y^2 = 1
+        aa = AndersonAcceleration(m=3)
+        x = np.array([1.0, 0.0])  # Start from a point on the circle
+        for _ in range(100):
+            g = x / np.linalg.norm(x)  # Project back onto the unit circle
+            x, residual = aa.step(x, g)
+            if residual < 1e-8:
+                break
+        # Check if the solution lies on the unit circle
+        self.assertAlmostEqual(np.linalg.norm(x), 1.0, places=7)
+
+
+class TestNewtonAndersonAcceleration(unittest.TestCase):
+    """
+    test the implementation of the 'NewtonAndersonAcceleration' class 
+    """
+
+    def test_init(self):
+        m = 5
+        naa = NewtonAndersonAcceleration(m)
+        # test initialization
+        self.assertEqual(naa.m, m)
+        self.assertTrue(naa.restart)
+        self.assertEqual(len(naa.x_buffer), 0)
+        self.assertEqual(len(naa.f_buffer), 0)
+        self.assertEqual(naa.counter, 0)
+
+    def test_step_no_jacobian(self):
+        naa = NewtonAndersonAcceleration(2)
+        x = np.array([1.0, 2.0])
+        g = np.array([2.0, 3.0])
+        result, residual = naa.step(x, g)
+        # test step without jacobian (should be same as AndersonAcceleration)
+        np.testing.assert_array_equal(result, g)
+        self.assertAlmostEqual(residual, np.linalg.norm(g - x))
+
+    def test_step_with_jacobian(self):
+        naa = NewtonAndersonAcceleration(2)
+        x = np.array([1.0, 2.0])
+        g = np.array([2.0, 3.0])
+        jac = np.array([[2.0, 0.0], [0.0, 2.0]])
+        result, residual = naa.step(x, g, jac)
+        # test step with jacobian
+        self.assertIsNotNone(result)
+        self.assertIsNotNone(residual)
+
+    def test_solve_scalar_equation(self):
+        # Solve x = cos(x)
+        naa = NewtonAndersonAcceleration(m=5)
+        x = 0.0
+        for i in range(100):
+            g = np.cos(x)
+            jac = -np.sin(x)
+            x, residual = naa.step(x, g, jac)
+            if residual < 1e-8:
+                break
+        self.assertAlmostEqual(x, 0.7390851332151607, places=7)
+
+
+# RUN TESTS LOCALLY ====================================================================
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)