ltbams 0.9.9__py3-none-any.whl → 1.0.0__py3-none-any.whl

tests/test_rtn_rted.py

@@ -0,0 +1,273 @@
+import unittest
+import numpy as np
+
+import ams
+from ams.shared import skip_unittest_without_MIP
+
+
+class TestRTED(unittest.TestCase):
+    """
+    Test methods of `RTED`.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case("5bus/pjm5bus_demo.xlsx"),
+                           setup=True, default_config=True, no_output=True)
+        # decrease load first
+        self.ss.PQ.set(src='p0', attr='v', idx=['PQ_1', 'PQ_2'], value=[0.3, 0.3])
+
+    def test_init(self):
+        """
+        Test `RTED.init()` method.
+        """
+        self.ss.RTED.init()
+        self.assertTrue(self.ss.RTED.initialized, "RTED initialization failed!")
+
+    def test_trip_gen(self):
+        """
+        Test generator tripping.
+        """
+        stg = 'PV_1'
+        self.ss.StaticGen.set(src='u', idx=stg, attr='v', value=0)
+
+        self.ss.RTED.update()
+        self.ss.RTED.run(solver='CLARABEL')
+        self.assertTrue(self.ss.RTED.converged, "RTED did not converge under generator trip!")
+        self.assertAlmostEqual(self.ss.RTED.get(src='pg', attr='v', idx=stg),
+                               0, places=6,
+                               msg="Generator trip does not take effect!")
+
+        self.ss.StaticGen.set(src='u', idx=stg, attr='v', value=1)  # reset
+
+    def test_trip_line(self):
+        """
+        Test line tripping.
+        """
+        self.ss.Line.set(src='u', attr='v', idx='Line_3', value=0)
+
+        self.ss.RTED.update()
+        self.ss.RTED.run(solver='CLARABEL')
+        self.assertTrue(self.ss.RTED.converged, "RTED did not converge under line trip!")
+        self.assertAlmostEqual(self.ss.RTED.get(src='plf', attr='v', idx='Line_3'),
+                               0, places=6,
+                               msg="Line trip does not take effect!")
+
+        self.ss.Line.alter(src='u', idx='Line_3', value=1)
+
+    def test_set_load(self):
+        """
+        Test setting and tripping load.
+        """
+        self.ss.RTED.run(solver='CLARABEL')
+        pgs = self.ss.RTED.pg.v.sum()
+
+        # --- set load ---
+        self.ss.PQ.set(src='p0', attr='v', idx='PQ_1', value=0.1)
+        self.ss.RTED.update()
+
+        self.ss.RTED.run(solver='CLARABEL')
+        pgs_pqt = self.ss.RTED.pg.v.sum()
+        self.assertLess(pgs_pqt, pgs, "Load set does not take effect!")
+
+        # --- trip load ---
+        self.ss.PQ.set(src='u', attr='v', idx='PQ_2', value=0)
+        self.ss.RTED.update()
+
+        self.ss.RTED.run(solver='CLARABEL')
+        pgs_pqt2 = self.ss.RTED.pg.v.sum()
+        self.assertLess(pgs_pqt2, pgs_pqt, "Load trip does not take effect!")
+
+    def test_dc2ac(self):
+        """
+        Test `RTED.dc2ac()` method.
+        """
+        self.ss.RTED.run(solver='CLARABEL')
+        self.ss.RTED.dc2ac()
+        self.assertTrue(self.ss.RTED.converted, "AC conversion failed!")
+        self.assertTrue(self.ss.RTED.exec_time > 0, "Execution time is not greater than 0.")
+
+        stg_idx = self.ss.StaticGen.get_all_idxes()
+        pg_rted = self.ss.RTED.get(src='pg', attr='v', idx=stg_idx)
+        pg_acopf = self.ss.ACOPF.get(src='pg', attr='v', idx=stg_idx)
+        np.testing.assert_almost_equal(pg_rted, pg_acopf, decimal=3)
+
+        bus_idx = self.ss.Bus.get_all_idxes()
+        v_rted = self.ss.RTED.get(src='vBus', attr='v', idx=bus_idx)
+        v_acopf = self.ss.ACOPF.get(src='vBus', attr='v', idx=bus_idx)
+        np.testing.assert_almost_equal(v_rted, v_acopf, decimal=3)
+
+        a_rted = self.ss.RTED.get(src='aBus', attr='v', idx=bus_idx)
+        a_acopf = self.ss.ACOPF.get(src='aBus', attr='v', idx=bus_idx)
+        np.testing.assert_almost_equal(a_rted, a_acopf, decimal=3)
+
+
+class TestRTEDDG(unittest.TestCase):
+    """
+    Test routine `RTEDDG`.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case("5bus/pjm5bus_demo.xlsx"),
+                           setup=True, default_config=True, no_output=True)
+        # decrease load first
+        self.ss.PQ.set(src='p0', attr='v', idx=['PQ_1', 'PQ_2'], value=[0.3, 0.3])
+
+    def test_init(self):
+        """
+        Test initialization.
+        """
+        self.ss.RTEDDG.init()
+        self.assertTrue(self.ss.RTEDDG.initialized, "RTEDDG initialization failed!")
+
+    def test_trip_gen(self):
+        """
+        Test generator tripping.
+        """
+        stg = 'PV_1'
+        self.ss.StaticGen.set(src='u', idx=stg, attr='v', value=0)
+
+        self.ss.RTEDDG.update()
+        self.ss.RTEDDG.run(solver='CLARABEL')
+        self.assertTrue(self.ss.RTEDDG.converged, "RTEDDG did not converge under generator trip!")
+        self.assertAlmostEqual(self.ss.RTEDDG.get(src='pg', attr='v', idx=stg),
+                               0, places=6,
+                               msg="Generator trip does not take effect!")
+
+        self.ss.StaticGen.set(src='u', idx=stg, attr='v', value=1)
+
+    def test_trip_line(self):
+        """
+        Test line tripping.
+        """
+        self.ss.Line.set(src='u', attr='v', idx='Line_3', value=0)
+
+        self.ss.RTEDDG.update()
+        self.ss.RTEDDG.run(solver='CLARABEL')
+        self.assertTrue(self.ss.RTEDDG.converged, "RTEDDG did not converge under line trip!")
+        self.assertAlmostEqual(self.ss.RTEDDG.get(src='plf', attr='v', idx='Line_3'),
+                               0, places=6,
+                               msg="Line trip does not take effect!")
+
+        self.ss.Line.alter(src='u', idx='Line_3', value=1)
+
+    def test_set_load(self):
+        """
+        Test setting and tripping load.
+        """
+        self.ss.RTEDDG.run(solver='CLARABEL')
+        pgs = self.ss.RTEDDG.pg.v.sum()
+
+        # --- set load ---
+        self.ss.PQ.set(src='p0', attr='v', idx='PQ_1', value=0.1)
+        self.ss.RTEDDG.update()
+
+        self.ss.RTEDDG.run(solver='CLARABEL')
+        pgs_pqt = self.ss.RTEDDG.pg.v.sum()
+        self.assertLess(pgs_pqt, pgs, "Load set does not take effect!")
+
+        # --- trip load ---
+        self.ss.PQ.set(src='u', attr='v', idx='PQ_2', value=0)
+        self.ss.RTEDDG.update()
+
+        self.ss.RTEDDG.run(solver='CLARABEL')
+        pgs_pqt2 = self.ss.RTEDDG.pg.v.sum()
+        self.assertLess(pgs_pqt2, pgs_pqt, "Load trip does not take effect!")
+
+    def test_dc2ac(self):
+        """
+        Test `RTEDDG.dc2ac()` method.
+        """
+        self.ss.RTEDDG.run(solver='CLARABEL')
+        self.ss.RTEDDG.dc2ac()
+        self.assertTrue(self.ss.RTEDDG.converted, "AC conversion failed!")
+        self.assertTrue(self.ss.RTEDDG.exec_time > 0, "Execution time is not greater than 0.")
+
+        stg_idx = self.ss.StaticGen.get_all_idxes()
+        pg_rted = self.ss.RTEDDG.get(src='pg', attr='v', idx=stg_idx)
+        pg_acopf = self.ss.ACOPF.get(src='pg', attr='v', idx=stg_idx)
+        np.testing.assert_almost_equal(pg_rted, pg_acopf, decimal=3)
+
+        bus_idx = self.ss.Bus.get_all_idxes()
+        v_rted = self.ss.RTEDDG.get(src='vBus', attr='v', idx=bus_idx)
+        v_acopf = self.ss.ACOPF.get(src='vBus', attr='v', idx=bus_idx)
+        np.testing.assert_almost_equal(v_rted, v_acopf, decimal=3)
+
+        a_rted = self.ss.RTEDDG.get(src='aBus', attr='v', idx=bus_idx)
+        a_acopf = self.ss.ACOPF.get(src='aBus', attr='v', idx=bus_idx)
+        np.testing.assert_almost_equal(a_rted, a_acopf, decimal=3)
+
+
+class TestRTEDES(unittest.TestCase):
+    """
+    Test routine `RTEDES`.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case("5bus/pjm5bus_uced_esd1.xlsx"),
+                           setup=True, default_config=True, no_output=True)
+        # decrease load first
+        self.ss.PQ.set(src='p0', attr='v', idx=['PQ_1', 'PQ_2'], value=[0.3, 0.3])
+
+    def test_init(self):
+        """
+        Test initialization.
+        """
+        self.ss.RTEDES.init()
+        self.assertTrue(self.ss.RTEDES.initialized, "RTEDES initialization failed!")
+
+    @skip_unittest_without_MIP
+    def test_trip_gen(self):
+        """
+        Test generator tripping.
+        """
+        stg = 'PV_1'
+        self.ss.StaticGen.set(src='u', idx=stg, attr='v', value=0)
+
+        self.ss.RTEDES.update()
+        self.ss.RTEDES.run(solver='SCIP')
+        self.assertTrue(self.ss.RTEDES.converged, "RTEDES did not converge under generator trip!")
+        self.assertAlmostEqual(self.ss.RTEDES.get(src='pg', attr='v', idx=stg),
+                               0, places=6,
+                               msg="Generator trip does not take effect!")
+
+        self.ss.StaticGen.set(src='u', idx=stg, attr='v', value=1)
+
+    @skip_unittest_without_MIP
+    def test_trip_line(self):
+        """
+        Test line tripping.
+        """
+        self.ss.Line.set(src='u', attr='v', idx=3, value=0)
+
+        self.ss.RTEDES.update()
+        self.ss.RTEDES.run(solver='SCIP')
+        self.assertTrue(self.ss.RTEDES.converged, "RTEDES did not converge under line trip!")
+        self.assertAlmostEqual(self.ss.RTEDES.get(src='plf', attr='v', idx=3),
+                               0, places=6,
+                               msg="Line trip does not take effect!")
+
+        self.ss.Line.alter(src='u', idx=3, value=1)
+
+    @skip_unittest_without_MIP
+    def test_set_load(self):
+        """
+        Test setting and tripping load.
+        """
+        self.ss.RTEDES.run(solver='SCIP')
+        pgs = self.ss.RTEDES.pg.v.sum()
+
+        # --- set load ---
+        self.ss.PQ.set(src='p0', attr='v', idx='PQ_1', value=0.05)
+        self.ss.RTEDES.update()
+
+        self.ss.RTEDES.run(solver='SCIP')
+        pgs_pqt = self.ss.RTEDES.pg.v.sum()
+        self.assertLess(pgs_pqt, pgs, "Load set does not take effect!")
+
+        # --- trip load ---
+        self.ss.PQ.set(src='u', attr='v', idx='PQ_2', value=0)
+        self.ss.RTEDES.update()
+
+        self.ss.RTEDES.run(solver='SCIP')
+        pgs_pqt2 = self.ss.RTEDES.pg.v.sum()
+        self.assertLess(pgs_pqt2, pgs_pqt, "Load trip does not take effect!")

tests/test_rtn_uc.py

@@ -0,0 +1,248 @@
+import unittest
+import numpy as np
+
+import ams
+from ams.shared import skip_unittest_without_MIP
+
+
+class TestUC(unittest.TestCase):
+    """
+    Test routine `UC`.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case("5bus/pjm5bus_demo.xlsx"),
+                           setup=True, default_config=True, no_output=True)
+        # decrease load first
+        self.ss.PQ.set(src='p0', attr='v', idx=['PQ_1', 'PQ_2'], value=[0.3, 0.3])
+        # run UC._initial_guess()
+        self.off_gen = self.ss.UC._initial_guess()
+
+    def test_initial_guess(self):
+        """
+        Test initial guess.
+        """
+        u_off_gen = self.ss.StaticGen.get(src='u', idx=self.off_gen)
+        np.testing.assert_equal(u_off_gen, np.zeros_like(u_off_gen),
+                                err_msg="UC._initial_guess() failed!")
+
+    def test_init(self):
+        """
+        Test initialization.
+        """
+        self.ss.UC.init()
+        self.assertTrue(self.ss.UC.initialized, "UC initialization failed!")
+
+    @skip_unittest_without_MIP
+    def test_trip_gen(self):
+        """
+        Test generator tripping.
+        """
+        self.ss.UC.run(solver='SCIP')
+        self.assertTrue(self.ss.UC.converged, "UC did not converge!")
+        pg_off_gen = self.ss.UC.get(src='pg', attr='v', idx=self.off_gen)
+        np.testing.assert_almost_equal(np.zeros_like(pg_off_gen),
+                                       pg_off_gen, decimal=6,
+                                       err_msg="Off generators are not turned off!")
+
+    @skip_unittest_without_MIP
+    def test_set_load(self):
+        """
+        Test setting and tripping load.
+        """
+        self.ss.UC.run(solver='SCIP')
+        pgs = self.ss.UC.pg.v.sum()
+
+        # --- set load ---
+        self.ss.PQ.set(src='p0', attr='v', idx='PQ_1', value=0.1)
+        self.ss.UC.update()
+
+        self.ss.UC.run(solver='SCIP')
+        pgs_pqt = self.ss.UC.pg.v.sum()
+        self.assertLess(pgs_pqt, pgs, "Load set does not take effect!")
+
+        # --- trip load ---
+        self.ss.PQ.alter(src='u', idx='PQ_2', value=0)
+        self.ss.UC.update()
+
+        self.ss.UC.run(solver='SCIP')
+        pgs_pqt2 = self.ss.UC.pg.v.sum()
+        self.assertLess(pgs_pqt2, pgs_pqt, "Load trip does not take effect!")
+
+    @skip_unittest_without_MIP
+    def test_trip_line(self):
+        """
+        Test line tripping.
+        """
+        self.ss.Line.set(src='u', attr='v', idx='Line_3', value=0)
+        self.ss.UC.update()
+
+        self.ss.UC.run(solver='SCIP')
+        self.assertTrue(self.ss.UC.converged, "UC did not converge under line trip!")
+        plf_l3 = self.ss.UC.get(src='plf', attr='v', idx='Line_3')
+        np.testing.assert_almost_equal(np.zeros_like(plf_l3),
+                                       plf_l3, decimal=6)
+
+        self.ss.Line.alter(src='u', idx='Line_3', value=1)
+
+
+class TestUCDG(unittest.TestCase):
+    """
+    Test routine `UCDG`.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case("5bus/pjm5bus_demo.xlsx"),
+                           setup=True, default_config=True, no_output=True)
+        # decrease load first
+        self.ss.PQ.set(src='p0', attr='v', idx=['PQ_1', 'PQ_2'], value=[0.3, 0.3])
+        # run `_initial_guess()`
+        self.off_gen = self.ss.UCDG._initial_guess()
+
+    def test_initial_guess(self):
+        """
+        Test initial guess.
+        """
+        u_off_gen = self.ss.StaticGen.get(src='u', idx=self.off_gen)
+        np.testing.assert_equal(u_off_gen, np.zeros_like(u_off_gen),
+                                err_msg="UCDG._initial_guess() failed!")
+
+    def test_init(self):
+        """
+        Test initialization.
+        """
+        self.ss.UCDG.init()
+        self.assertTrue(self.ss.UCDG.initialized, "UCDG initialization failed!")
+
+    @skip_unittest_without_MIP
+    def test_trip_gen(self):
+        """
+        Test generator tripping.
+        """
+        self.ss.UCDG.run(solver='SCIP')
+        self.assertTrue(self.ss.UCDG.converged, "UCDG did not converge!")
+        pg_off_gen = self.ss.UCDG.get(src='pg', attr='v', idx=self.off_gen)
+        np.testing.assert_almost_equal(np.zeros_like(pg_off_gen),
+                                       pg_off_gen, decimal=6,
+                                       err_msg="Off generators are not turned off!")
+
+    @skip_unittest_without_MIP
+    def test_set_load(self):
+        """
+        Test setting and tripping load.
+        """
+        self.ss.UCDG.run(solver='SCIP')
+        pgs = self.ss.UCDG.pg.v.sum()
+
+        # --- set load ---
+        self.ss.PQ.set(src='p0', attr='v', idx='PQ_1', value=0.1)
+        self.ss.UCDG.update()
+
+        self.ss.UCDG.run(solver='SCIP')
+        pgs_pqt = self.ss.UCDG.pg.v.sum()
+        self.assertLess(pgs_pqt, pgs, "Load set does not take effect!")
+
+        # --- trip load ---
+        self.ss.PQ.alter(src='u', idx='PQ_2', value=0)
+        self.ss.UCDG.update()
+
+        self.ss.UCDG.run(solver='SCIP')
+        pgs_pqt2 = self.ss.UCDG.pg.v.sum()
+        self.assertLess(pgs_pqt2, pgs_pqt, "Load trip does not take effect!")
+
+    @skip_unittest_without_MIP
+    def test_trip_line(self):
+        """
+        Test line tripping.
+        """
+        self.ss.Line.set(src='u', attr='v', idx='Line_3', value=0)
+        self.ss.UCDG.update()
+
+        self.ss.UCDG.run(solver='SCIP')
+        self.assertTrue(self.ss.UCDG.converged, "UCDG did not converge under line trip!")
+        plf_l3 = self.ss.UCDG.get(src='plf', attr='v', idx='Line_3')
+        np.testing.assert_almost_equal(np.zeros_like(plf_l3),
+                                       plf_l3, decimal=6)
+
+        self.ss.Line.alter(src='u', idx='Line_3', value=1)
+
+
+class TestUCES(unittest.TestCase):
+    """
+    Test routine `UCES`.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case("5bus/pjm5bus_uced_esd1.xlsx"),
+                           setup=True, default_config=True, no_output=True)
+        # decrease load first
+        self.ss.PQ.set(src='p0', attr='v', idx=['PQ_1', 'PQ_2'], value=[0.3, 0.3])
+        # run `_initial_guess()`
+        self.off_gen = self.ss.UCES._initial_guess()
+
+    def test_initial_guess(self):
+        """
+        Test initial guess.
+        """
+        u_off_gen = self.ss.StaticGen.get(src='u', idx=self.off_gen)
+        np.testing.assert_equal(u_off_gen, np.zeros_like(u_off_gen),
+                                err_msg="UCES._initial_guess() failed!")
+
+    def test_init(self):
+        """
+        Test initialization.
+        """
+        self.ss.UCES.init()
+        self.assertTrue(self.ss.UCES.initialized, "UCES initialization failed!")
+
+    @skip_unittest_without_MIP
+    def test_trip_gen(self):
+        """
+        Test generator tripping.
+        """
+        self.ss.UCES.run(solver='SCIP')
+        self.assertTrue(self.ss.UCES.converged, "UCES did not converge!")
+        pg_off_gen = self.ss.UCES.get(src='pg', attr='v', idx=self.off_gen)
+        np.testing.assert_almost_equal(np.zeros_like(pg_off_gen),
+                                       pg_off_gen, decimal=6,
+                                       err_msg="Off generators are not turned off!")
+
+    @skip_unittest_without_MIP
+    def test_set_load(self):
+        """
+        Test setting and tripping load.
+        """
+        self.ss.UCES.run(solver='SCIP')
+        pgs = self.ss.UCES.pg.v.sum()
+
+        # --- set load ---
+        self.ss.PQ.set(src='p0', attr='v', idx='PQ_1', value=0.1)
+        self.ss.UCES.update()
+
+        self.ss.UCES.run(solver='SCIP')
+        pgs_pqt = self.ss.UCES.pg.v.sum()
+        self.assertLess(pgs_pqt, pgs, "Load set does not take effect!")
+
+        # --- trip load ---
+        self.ss.PQ.alter(src='u', idx='PQ_2', value=0)
+        self.ss.UCES.update()
+
+        self.ss.UCES.run(solver='SCIP')
+        pgs_pqt2 = self.ss.UCES.pg.v.sum()
+        self.assertLess(pgs_pqt2, pgs_pqt, "Load trip does not take effect!")
+
+    @skip_unittest_without_MIP
+    def test_trip_line(self):
+        """
+        Test line tripping.
+        """
+        self.ss.Line.set(src='u', attr='v', idx=3, value=0)
+        self.ss.UCES.update()
+
+        self.ss.UCES.run(solver='SCIP')
+        self.assertTrue(self.ss.UCES.converged, "UCES did not converge under line trip!")
+        plf_l3 = self.ss.UCES.get(src='plf', attr='v', idx=3)
+        np.testing.assert_almost_equal(np.zeros_like(plf_l3),
+                                       plf_l3, decimal=6)
+
+        self.ss.Line.alter(src='u', idx=3, value=1)

tests/test_service.py

@@ -0,0 +1,73 @@
+import unittest
+import numpy as np
+
+import ams
+from ams.core.matprocessor import MParam
+from ams.core.service import NumOp, NumOpDual, ZonalSum
+
+
+class TestService(unittest.TestCase):
+    """
+    Test functionality of Services.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case("ieee39/ieee39_uced_esd1.xlsx"),
+                           default_config=True,
+                           no_output=True,)
+        self.nR = self.ss.Zone.n
+        self.nB = self.ss.Bus.n
+        self.nL = self.ss.Line.n
+        self.nD = self.ss.StaticLoad.n  # number of static loads
+
+    def test_NumOp_norfun(self):
+        """
+        Test `NumOp` without return function.
+        """
+        CftT = NumOp(u=self.ss.mats.Cft, fun=np.transpose)
+        np.testing.assert_array_equal(CftT.v.transpose(), self.ss.mats.Cft.v)
+
+    def test_NumOp_rfun(self):
+        """
+        Test `NumOp` with return function.
+        """
+        CftTT = NumOp(u=self.ss.mats.Cft, fun=np.transpose, rfun=np.transpose)
+        np.testing.assert_array_equal(CftTT.v, self.ss.mats.Cft.v)
+
+    def test_NumOp_ArrayOut(self):
+        """
+        Test `NumOp` non-array output.
+        """
+        M = NumOp(u=self.ss.PV.pmax,
+                  fun=np.max,
+                  rfun=np.dot, rargs=dict(b=10),
+                  array_out=True,)
+        M2 = NumOp(u=self.ss.PV.pmax,
+                   fun=np.max,
+                   rfun=np.dot, rargs=dict(b=10),
+                   array_out=False,)
+        self.assertIsInstance(M.v, np.ndarray)
+        self.assertIsInstance(M2.v, (int, float))
+
+    def test_NumOpDual(self):
+        """
+        Test `NumOpDual`.
+        """
+        p_vec = MParam(v=self.ss.DCOPF.pd.v)
+        one_vec = MParam(v=np.ones(self.ss.StaticLoad.n))
+        p_sum = NumOpDual(u=p_vec, u2=one_vec,
+                          fun=np.multiply, rfun=np.sum)
+        self.assertEqual(p_sum.v, self.ss.PQ.p0.v.sum())
+
+    def test_ZonalSum(self):
+        """
+        Test `ZonalSum`.
+        """
+        ds = ZonalSum(u=self.ss.RTED.zd, zone="Zone",
+                      name="ds", tex_name=r"S_{d}",
+                      info="Sum pl vector in shape of zone",)
+        ds.rtn = self.ss.RTED
+        # check if the shape is correct
+        np.testing.assert_array_equal(ds.v.shape, (self.nR, self.nD))
+        # check if the values are correct
+        self.assertTrue(np.all(ds.v.sum(axis=1) <= np.array([self.nB, self.nB])))