ltbams 0.9.9__py3-none-any.whl → 1.0.2a1__py3-none-any.whl

tests/test_model.py

@@ -0,0 +1,54 @@
+import unittest
+import numpy as np
+
+import ams
+
+
+class TestModelMethods(unittest.TestCase):
+    """
+    Test methods of Model.
+    """
+
+    def setUp(self):
+        self.ss = ams.run(
+            ams.get_case("ieee14/ieee14.json"),
+            default_config=True,
+            no_output=True,
+        )
+
+    def test_model_set(self):
+        """
+        Test `Model.set()` method.
+        """
+
+        # set a single value
+        self.ss.PQ.set("p0", "PQ_1", "v", 0.25)
+        self.assertEqual(self.ss.PQ.p0.v[0], 0.25)
+
+        # set a list of values
+        self.ss.PQ.set("p0", ["PQ_1", "PQ_2"], "v", [0.26, 0.51])
+        np.testing.assert_equal(self.ss.PQ.p0.v[[0, 1]], [0.26, 0.51])
+
+        # set a list of values
+        self.ss.PQ.set("p0", ["PQ_3", "PQ_5"], "v", [0.52, 0.16])
+        np.testing.assert_equal(self.ss.PQ.p0.v[[2, 4]], [0.52, 0.16])
+
+        # set a list of idxes with a single element to an array of values
+        self.ss.PQ.set("p0", ["PQ_4"], "v", np.array([0.086]))
+        np.testing.assert_equal(self.ss.PQ.p0.v[3], 0.086)
+
+        # set an array of idxes with a single element to an array of values
+        self.ss.PQ.set("p0", np.array(["PQ_4"]), "v", np.array([0.096]))
+        np.testing.assert_equal(self.ss.PQ.p0.v[3], 0.096)
+
+        # set an array of idxes with a list of single value
+        self.ss.PQ.set("p0", np.array(["PQ_4"]), "v", 0.097)
+        np.testing.assert_equal(self.ss.PQ.p0.v[3], 0.097)
+
+    def test_model_repr(self):
+        """
+        Test `Model.__repr__()` method.
+        """
+
+        for mdl in self.ss.models.items():
+            print(mdl.__repr__())

tests/test_omodel.py

@@ -0,0 +1,119 @@
+import unittest
+
+import ams
+
+
+class TestOModelWrappers(unittest.TestCase):
+    """
+    Test wrappers in module `omodel`.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case("matpower/case5.m"),
+                           setup=True,
+                           default_config=True,
+                           no_output=True,
+                           )
+
+    def test_ensure_symbols(self):
+        """
+        Test `ensure_symbols` wrapper.
+        """
+        self.assertFalse(self.ss.DCOPF._syms, "Symbols should not be ready before generation!")
+        self.ss.DCOPF.pd.parse()
+        self.assertTrue(self.ss.DCOPF._syms, "Symbols should be ready after generation!")
+
+    def test_ensure_mats_and_parsed(self):
+        """
+        Test `ensure_mats_and_parsed` wrapper.
+        """
+        self.assertFalse(self.ss.mats.initialized, "MatProcessor should not be initialized before initialization!")
+        self.assertFalse(self.ss.DCOPF.om.parsed, "OModel should be parsed after parsing!")
+        self.ss.DCOPF.pd.evaluate()
+        self.assertTrue(self.ss.mats.initialized, "MatProcessor should be initialized after parsing!")
+        self.assertTrue(self.ss.DCOPF.om.parsed, "OModle should be parsed after parsing!")
+
+
+class TestOModel(unittest.TestCase):
+    """
+    Test class `OModel`.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case("matpower/case5.m"),
+                           setup=True,
+                           default_config=True,
+                           no_output=True,
+                           )
+
+    def test_initialized(self):
+        """
+        Test `OModel` initialization.
+        """
+        self.assertFalse(self.ss.DCOPF.om.initialized, "OModel shoud not be initialized before initialziation!")
+        self.ss.DCOPF.om.init()
+        self.assertTrue(self.ss.DCOPF.om.initialized, "OModel should be initialized!")
+
+    def test_uninitialized_after_nonparametric_update(self):
+        """
+        Test `OModel` initialization after nonparametric update.
+        """
+        self.ss.DCOPF.om.init()
+        self.assertTrue(self.ss.DCOPF.om.initialized, "OModel should be initialized after initialization!")
+        self.ss.DCOPF.update('ug')
+        self.assertTrue(self.ss.DCOPF.om.initialized, "OModel should be initialized after nonparametric update!")
+
+
+class TestOModelrepr(unittest.TestCase):
+    """
+    Test __repr__ in module `omodel`.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case("5bus/pjm5bus_demo.xlsx"),
+                           setup=True,
+                           default_config=True,
+                           no_output=True,
+                           )
+
+    def test_dcopf(self):
+        """
+        Test `DCOPF.om` __repr__().
+        """
+        self.ss.DCOPF.om.parse()
+        self.assertIsInstance(self.ss.DCOPF.pg.__repr__(), str)
+        self.assertIsInstance(self.ss.DCOPF.pmax.__repr__(), str)
+        self.assertIsInstance(self.ss.DCOPF.pb.__repr__(), str)
+        self.assertIsInstance(self.ss.DCOPF.plflb.__repr__(), str)
+        self.assertIsInstance(self.ss.DCOPF.obj.__repr__(), str)
+
+    def test_rted(self):
+        """
+        Test `RTED.om` __repr__().
+        """
+        self.ss.RTED.om.parse()
+        self.assertIsInstance(self.ss.RTED.pru.__repr__(), str)
+        self.assertIsInstance(self.ss.RTED.R10.__repr__(), str)
+        self.assertIsInstance(self.ss.RTED.pru.__repr__(), str)
+        self.assertIsInstance(self.ss.RTED.rru.__repr__(), str)
+        self.assertIsInstance(self.ss.RTED.obj.__repr__(), str)
+
+    def test_ed(self):
+        """
+        Test `ED.om` __repr__().
+        """
+        self.ss.ED.om.parse()
+        self.assertIsInstance(self.ss.ED.prs.__repr__(), str)
+        self.assertIsInstance(self.ss.ED.R30.__repr__(), str)
+        self.assertIsInstance(self.ss.ED.prsb.__repr__(), str)
+        self.assertIsInstance(self.ss.ED.obj.__repr__(), str)
+
+    def test_uc(self):
+        """
+        Test `UC.om` __repr__().
+        """
+        self.ss.UC.om.parse()
+        self.assertIsInstance(self.ss.UC.prns.__repr__(), str)
+        self.assertIsInstance(self.ss.UC.cdp.__repr__(), str)
+        self.assertIsInstance(self.ss.UC.prnsb.__repr__(), str)
+        self.assertIsInstance(self.ss.UC.obj.__repr__(), str)

tests/test_paths.py

@@ -0,0 +1,22 @@
+import unittest
+
+import ams
+from ams.utils.paths import list_cases
+
+
+class TestPaths(unittest.TestCase):
+    def setUp(self) -> None:
+        self.npcc = 'npcc/'
+        self.matpower = 'matpower/'
+        self.ieee14 = ams.get_case("ieee14/ieee14.raw")
+
+    def test_tree(self):
+        list_cases(self.npcc, no_print=True)
+        list_cases(self.matpower, no_print=True)
+
+    def test_relative_path(self):
+        ss = ams.run('ieee14.raw',
+                     input_path=ams.get_case('ieee14/', check=False),
+                     no_output=True, default_config=True,
+                     )
+        self.assertNotEqual(ss, None)

tests/test_report.py

@@ -0,0 +1,251 @@
+"""
+Test system report.
+"""
+import unittest
+import os
+
+import ams
+from ams.shared import skip_unittest_without_MISOCP
+
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class TestReport(unittest.TestCase):
+    """
+    Tests for Report class.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.main.load(
+            ams.get_case("5bus/pjm5bus_demo.xlsx"),
+            default_config=True,
+            no_output=True,
+        )
+        self.expected_report = 'pjm5bus_demo_out.txt'
+
+    def test_no_output(self):
+        """
+        Test no output.
+        """
+        self.assertTrue(self.ss.files.no_output)
+        self.assertFalse(self.ss.report())
+
+    def test_no_report(self):
+        """
+        Test report with no solved routine.
+        """
+        self.ss.files.no_output = False
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertNotIn("DCOPF", file_contents)
+
+        os.remove(self.expected_report)
+
+    def test_DCOPF_report(self):
+        """
+        Test report with DCOPF solved.
+        """
+        self.ss.files.no_output = False
+        self.ss.DCOPF.run(solver='CLARABEL')
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertIn("DCOPF", file_contents)
+        os.remove(self.expected_report)
+
+        self.ss.DCOPF.export_csv()
+        self.assertTrue(os.path.exists('pjm5bus_demo_DCOPF.csv'))
+        os.remove('pjm5bus_demo_DCOPF.csv')
+
+    def test_DCPF_report(self):
+        """
+        Test report with DCPF solved.
+        """
+        self.ss.files.no_output = False
+        self.ss.DCPF.run(solver='CLARABEL')
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertIn("DCPF", file_contents)
+        os.remove(self.expected_report)
+
+        self.ss.DCPF.export_csv()
+        self.assertTrue(os.path.exists('pjm5bus_demo_DCPF.csv'))
+        os.remove('pjm5bus_demo_DCPF.csv')
+
+    def test_RTED_report(self):
+        """
+        Test report with RTED solved.
+        """
+        self.ss.files.no_output = False
+        self.ss.RTED.run(solver='CLARABEL')
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertIn("RTED", file_contents)
+        os.remove(self.expected_report)
+
+        self.ss.RTED.export_csv()
+        self.assertTrue(os.path.exists('pjm5bus_demo_RTED.csv'))
+        os.remove('pjm5bus_demo_RTED.csv')
+
+    def test_RTEDDG_report(self):
+        """
+        Test report with RTEDDG solved.
+        """
+        self.ss.files.no_output = False
+        self.ss.RTEDDG.run(solver='CLARABEL')
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertIn("RTEDDG", file_contents)
+        os.remove(self.expected_report)
+
+        self.ss.RTEDDG.export_csv()
+        self.assertTrue(os.path.exists('pjm5bus_demo_RTEDDG.csv'))
+        os.remove('pjm5bus_demo_RTEDDG.csv')
+
+    @skip_unittest_without_MISOCP
+    def test_RTEDES_report(self):
+        """
+        Test report with RTEDES solved.
+        """
+        self.ss.files.no_output = False
+        self.ss.RTEDES.run()
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertIn("RTEDES", file_contents)
+        os.remove(self.expected_report)
+
+        self.ss.RTEDES.export_csv()
+        self.assertTrue(os.path.exists('pjm5bus_demo_RTEDES.csv'))
+        os.remove('pjm5bus_demo_RTEDES.csv')
+
+    def test_ED_report(self):
+        """
+        Test report with ED solved.
+        """
+        self.ss.files.no_output = False
+        self.ss.ED.run(solver='CLARABEL')
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertIn("ED", file_contents)
+        os.remove(self.expected_report)
+
+        self.ss.ED.export_csv()
+        self.assertTrue(os.path.exists('pjm5bus_demo_ED.csv'))
+        os.remove('pjm5bus_demo_ED.csv')
+
+    def test_EDDG_report(self):
+        """
+        Test report with EDDG solved.
+        """
+        self.ss.files.no_output = False
+        self.ss.EDDG.run(solver='CLARABEL')
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertIn("EDDG", file_contents)
+        os.remove(self.expected_report)
+
+        self.ss.EDDG.export_csv()
+        self.assertTrue(os.path.exists('pjm5bus_demo_EDDG.csv'))
+        os.remove('pjm5bus_demo_EDDG.csv')
+
+    @skip_unittest_without_MISOCP
+    def test_EDES_report(self):
+        """
+        Test report with EDES solved.
+        """
+        self.ss.files.no_output = False
+        self.ss.EDES.run()
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertIn("EDES", file_contents)
+        os.remove(self.expected_report)
+
+        self.ss.EDES.export_csv()
+        self.assertTrue(os.path.exists('pjm5bus_demo_EDES.csv'))
+        os.remove('pjm5bus_demo_EDES.csv')
+
+    @skip_unittest_without_MISOCP
+    def test_UC_report(self):
+        """
+        Test report with UC solved.
+        """
+        self.ss.files.no_output = False
+        self.ss.UC.run()
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertIn("UC", file_contents)
+        os.remove(self.expected_report)
+
+        self.ss.UC.export_csv()
+        self.assertTrue(os.path.exists('pjm5bus_demo_UC.csv'))
+        os.remove('pjm5bus_demo_UC.csv')
+
+    @skip_unittest_without_MISOCP
+    def test_UCDG_report(self):
+        """
+        Test report with UCDG solved.
+        """
+        self.ss.files.no_output = False
+        self.ss.UCDG.run()
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertIn("UCDG", file_contents)
+        os.remove(self.expected_report)
+
+        self.ss.UCDG.export_csv()
+        self.assertTrue(os.path.exists('pjm5bus_demo_UCDG.csv'))
+        os.remove('pjm5bus_demo_UCDG.csv')
+
+    @skip_unittest_without_MISOCP
+    def test_UCES_report(self):
+        """
+        Test report with UCES solved.
+        """
+        self.ss.files.no_output = False
+        self.ss.UCES.run()
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertIn("UCES", file_contents)
+        os.remove(self.expected_report)
+
+        self.ss.UCES.export_csv()
+        self.assertTrue(os.path.exists('pjm5bus_demo_UCES.csv'))
+        os.remove('pjm5bus_demo_UCES.csv')

tests/test_repr.py

@@ -0,0 +1,21 @@
+import contextlib
+import unittest
+
+import ams
+
+
+class TestRepr(unittest.TestCase):
+    """Test __repr__"""
+    def setUp(self):
+        self.ss = ams.run(ams.get_case("ieee39/ieee39_uced.xlsx"),
+                          no_output=True,
+                          default_config=True,
+                          )
+
+    def test_print_model_repr(self):
+        """
+        Print out Model ``cache``'s fields and values.
+        """
+        with contextlib.redirect_stdout(None):
+            for model in self.ss.models.values():
+                print(model.cache.__dict__)

tests/test_routine.py

@@ -0,0 +1,178 @@
+import unittest
+import numpy as np
+
+
+import ams
+from ams.shared import pd
+
+
+class TestRoutineMethods(unittest.TestCase):
+    """
+    Test methods of `Routine`.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case("ieee39/ieee39_uced.xlsx"),
+                           default_config=True,
+                           no_output=True,
+                           )
+
+    def test_data_check(self):
+        """
+        Test `Routine._data_check()` method.
+        """
+
+        self.assertTrue(self.ss.DCOPF._data_check())
+        self.assertFalse(self.ss.RTEDES._data_check())
+
+    def test_get_off_constrs(self):
+        """
+        Test `Routine._get_off_constrs()` method.
+        """
+
+        self.assertIsInstance(self.ss.DCOPF._get_off_constrs(), list)
+
+    def test_routine_set(self):
+        """
+        Test `Routine.set()` method.
+        """
+
+        self.ss.DCOPF.set('c2', 'GCost_1', 'v', 10)
+        np.testing.assert_equal(self.ss.GCost.get('c2', 'GCost_1', 'v'), 10)
+
+    def test_routine_get(self):
+        """
+        Test `Routine.get()` method.
+        """
+        # --- single period routine ---
+        # get an rparam value
+        np.testing.assert_equal(self.ss.DCOPF.get('ug', 'PV_30'), 1)
+
+        # get an unpacked var value
+        self.ss.DCOPF.run(solver='CLARABEL')
+        self.assertEqual(self.ss.DCOPF.exit_code, 0, "Exit code is not 0.")
+        np.testing.assert_equal(self.ss.DCOPF.get('pg', 'PV_30', 'v'),
+                                self.ss.StaticGen.get('p', 'PV_30', 'v'))
+
+        # test input type
+        self.assertIsInstance(self.ss.DCOPF.get('pg', pd.Series(['PV_30']), 'v'), np.ndarray)
+
+        # test return type
+        self.assertIsInstance(self.ss.DCOPF.get('pg', 'PV_30', 'v'), float)
+        self.assertIsInstance(self.ss.DCOPF.get('pg', ['PV_30'], 'v'), np.ndarray)
+
+        # --- multi period routine ---
+        self.ss.ED.run(solver='CLARABEL')
+        self.assertEqual(self.ss.ED.exit_code, 0, "Exit code is not 0.")
+        np.testing.assert_equal(self.ss.ED.get('pg', 'PV_30', 'v').ndim, 1)
+        np.testing.assert_equal(self.ss.ED.get('pg', ['PV_30'], 'v').ndim, 2)
+
+    def test_rouine_init(self):
+        """
+        Test `Routine.init()` method.
+        """
+
+        self.assertTrue(self.ss.DCOPF.init(), "DCOPF initialization failed!")
+
+    def test_generate_symbols(self):
+        """
+        Test symbol generation.
+        """
+
+        self.ss.DCOPF.syms.generate_symbols()
+        self.assertTrue(self.ss.DCOPF._syms, "Symbol generation failed!")
+
+    def test_value_method(self):
+        """
+        Test Contraint and Objective values.
+        """
+
+        self.ss.DCOPF.run(solver='CLARABEL')
+        self.assertTrue(self.ss.DCOPF.converged, "DCOPF did not converge!")
+
+        # --- constraint values ---
+        for constr in self.ss.DCOPF.constrs.values():
+            np.testing.assert_almost_equal(constr.v, constr.e, decimal=6)
+
+        # --- objective value ---
+        self.assertAlmostEqual(self.ss.DCOPF.obj.v, self.ss.DCOPF.obj.e, places=6)
+
+
+class TestSetOptzValueACOPF(unittest.TestCase):
+    """
+    Test value settings of `OptzBase` series in `ACOPF`.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case("5bus/pjm5bus_demo.xlsx"),
+                           setup=True,
+                           default_config=True,
+                           no_output=True,
+                           )
+
+    def test_vset_before_init(self):
+        """
+        Test value setting before routine initialization.
+        """
+        # set values to `Var` before initialization is not doable
+        v_ext = np.ones(self.ss.ACOPF.pg.n)
+        self.ss.ACOPF.pg.v = v_ext
+        self.assertIsNone(self.ss.ACOPF.pg.v)
+        # set values to `Constraint` is not allowed
+        self.assertRaises(AttributeError, lambda: setattr(self.ss.ACOPF.plfub, 'v', 1))
+        # set values to `Objective` is not allowed
+        self.assertRaises(AttributeError, lambda: setattr(self.ss.ACOPF.obj, 'v', 1))
+
+    def test_vset_after_init(self):
+        """
+        Test value setting after routine initialization.
+        """
+        self.ss.ACOPF.init()
+        # set values to `Var` after initialization is allowed
+        v_ext = np.ones(self.ss.ACOPF.pg.n)
+        self.ss.ACOPF.pg.v = v_ext
+        np.testing.assert_equal(self.ss.ACOPF.pg.v, v_ext)
+        # set values to `Constraint` is not allowed
+        self.assertRaises(AttributeError, lambda: setattr(self.ss.ACOPF.plfub, 'v', 1))
+        # set values to `Objective` is not allowed
+        self.assertRaises(AttributeError, lambda: setattr(self.ss.ACOPF.obj, 'v', 1))
+
+
+class TestSetOptzValueDCOPF(unittest.TestCase):
+    """
+    Test value settings of `OptzBase` series in `DCOPF`.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case("5bus/pjm5bus_demo.xlsx"),
+                           setup=True,
+                           default_config=True,
+                           no_output=True,
+                           )
+
+    def test_vset_before_init(self):
+        """
+        Test value setting before routine initialization.
+        """
+        # set values to `Var` before initialization is not doable
+        v_ext = np.ones(self.ss.DCOPF.pg.n)
+        self.ss.DCOPF.pg.v = v_ext
+        self.assertIsNone(self.ss.DCOPF.pg.v)
+        # set values to `Constraint` is not allowed
+        self.assertRaises(AttributeError, lambda: setattr(self.ss.DCOPF.plfub, 'v', 1))
+        # set values to `Objective` is not allowed
+        self.assertRaises(AttributeError, lambda: setattr(self.ss.DCOPF.obj, 'v', 1))
+
+    def test_vset_after_init(self):
+        """
+        Test value setting after routine initialization.
+        """
+        self.ss.DCOPF.init()
+        # set values to `Var` after initialization is allowed
+        v_ext = np.ones(self.ss.DCOPF.pg.n)
+        self.ss.DCOPF.pg.v = v_ext
+        np.testing.assert_equal(self.ss.DCOPF.pg.v, v_ext)
+        # set values to `Constraint` is not allowed
+        self.assertRaises(AttributeError, lambda: setattr(self.ss.DCOPF.plfub, 'v', 1))
+        # set values to `Objective` is not allowed
+        self.assertRaises(AttributeError, lambda: setattr(self.ss.DCOPF.obj, 'v', 1))