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

{ltbams-0.9.9.dist-info → ltbams-1.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.1.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ltbams-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,5 @@
+ams
+docs
+examples
+icebar
+tests

tests/test_1st_system.py

@@ -0,0 +1,33 @@
+import unittest
+
+import ams
+
+
+class TestCodegen(unittest.TestCase):
+    """
+    Test code generation.
+    """
+
+    def test_1_docs(self) -> None:
+        sp = ams.system.System()
+        out = ''
+        for tp in sp.types.values():
+            out += tp.doc_all()
+
+        out = ''
+        for group in sp.groups.values():
+            out += group.doc_all()
+
+    def test_docum(self) -> None:
+        sp = ams.load(ams.get_case('5bus/pjm5bus_demo.xlsx'),
+                      setup=True, no_output=True)
+        sp.DCOPF.init()
+        docum = sp.DCOPF.docum
+        for export in ['plain', 'rest']:
+            docum._obj_doc(max_width=78, export=export)
+            docum._constr_doc(max_width=78, export=export)
+            docum._exprc_doc(max_width=78, export=export)
+            docum._var_doc(max_width=78, export=export)
+            docum._service_doc(max_width=78, export=export)
+            docum._param_doc(max_width=78, export=export)
+            docum.config.doc(max_width=78, export=export)

tests/test_addressing.py

@@ -0,0 +1,40 @@
+import unittest
+import numpy as np
+
+import ams
+
+ams.config_logger(stream_level=40)
+
+
+class TestAddressing(unittest.TestCase):
+    """
+    Tests for addressing.
+    """
+
+    def test_ieee14_address(self):
+        """
+        Test IEEE14 address.
+        """
+
+        # FIXME: why there will be case parsing information using ams.system.example()?
+        ss = ams.system.example()
+
+        # bus variable indices (internal)
+        np.testing.assert_array_equal(ss.Bus.a.a,
+                                      np.arange(0, ss.Bus.n, 1))
+        np.testing.assert_array_equal(ss.Bus.v.a,
+                                      np.arange(ss.Bus.n, 2*ss.Bus.n, 1))
+
+        # external variable indices
+        np.testing.assert_array_equal(ss.PV.ud.a,
+                                      np.array([31, 32, 33, 34]))
+        np.testing.assert_array_equal(ss.PV.p.a,
+                                      np.array([35, 36, 37, 38]))
+        np.testing.assert_array_equal(ss.PV.q.a,
+                                      np.array([39, 40, 41, 42]))
+        np.testing.assert_array_equal(ss.Slack.ud.a,
+                                      np.array([28]))
+        np.testing.assert_array_equal(ss.Slack.p.a,
+                                      np.array([29]))
+        np.testing.assert_array_equal(ss.Slack.q.a,
+                                      np.array([30]))

tests/test_andes_mats.py

@@ -0,0 +1,61 @@
+"""
+Test ANDES matrices.
+"""
+
+import unittest
+import numpy as np
+import importlib.metadata
+from packaging.version import parse as parse_version
+
+import ams
+
+
+class TestMatrices(unittest.TestCase):
+    """
+    Tests for system matrices consistency.
+    """
+
+    andes_version = importlib.metadata.version("andes")
+    if parse_version(andes_version) < parse_version('1.9.2'):
+        raise unittest.SkipTest("Requires ANDES version >= 1.9.2")
+
+    sp = ams.load(ams.get_case('5bus/pjm5bus_demo.xlsx'),
+                  setup=True, no_output=True, default_config=True,)
+    sa = sp.to_andes(setup=True, no_output=True, default_config=True,)
+
+    def setUp(self) -> None:
+        """
+        Test setup.
+        """
+
+    def test_build_y(self):
+        """
+        Test build_y consistency.
+        """
+        ysp = self.sp.Line.build_y()
+        ysa = self.sa.Line.build_y()
+        np.testing.assert_equal(np.array(ysp.V), np.array(ysa.V))
+
+    def test_build_Bp(self):
+        """
+        Test build_Bp consistency.
+        """
+        Bp_sp = self.sp.Line.build_Bp()
+        Bp_sa = self.sa.Line.build_Bp()
+        np.testing.assert_equal(np.array(Bp_sp.V), np.array(Bp_sa.V))
+
+    def test_build_Bpp(self):
+        """
+        Test build_Bpp consistency.
+        """
+        Bpp_sp = self.sp.Line.build_Bpp()
+        Bpp_sa = self.sa.Line.build_Bpp()
+        np.testing.assert_equal(np.array(Bpp_sp.V), np.array(Bpp_sa.V))
+
+    def test_build_Bdc(self):
+        """
+        Test build_Bdc consistency.
+        """
+        Bdc_sp = self.sp.Line.build_Bdc()
+        Bdc_sa = self.sa.Line.build_Bdc()
+        np.testing.assert_equal(np.array(Bdc_sp.V), np.array(Bdc_sa.V))

tests/test_case.py

@@ -0,0 +1,266 @@
+import os
+import unittest
+
+import numpy as np
+
+import ams
+from ams.utils.paths import get_case
+
+
+class Test5Bus(unittest.TestCase):
+    """
+    Tests for the 5-bus system.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.main.load(
+            get_case("5bus/pjm5bus_uced.xlsx"),
+            default_config=True,
+            no_output=True,
+        )
+
+    def test_essential(self):
+        """
+        Test essential functionalities of Model and System.
+        """
+
+        # --- test model names
+        self.assertTrue("Bus" in self.ss.models)
+        self.assertTrue("PQ" in self.ss.models)
+
+        # --- test device counts
+        self.assertEqual(self.ss.Bus.n, 5)
+        self.assertEqual(self.ss.PQ.n, 3)
+        self.assertEqual(self.ss.PV.n, 3)
+        self.assertEqual(self.ss.Slack.n, 1)
+        self.assertEqual(self.ss.Line.n, 7)
+        self.assertEqual(self.ss.Zone.n, 2)
+        self.assertEqual(self.ss.SFR.n, 2)
+        self.assertEqual(self.ss.SR.n, 2)
+        self.assertEqual(self.ss.NSR.n, 2)
+        self.assertEqual(self.ss.GCost.n, 4)
+        self.assertEqual(self.ss.SFRCost.n, 4)
+        self.assertEqual(self.ss.SRCost.n, 4)
+        self.assertEqual(self.ss.NSRCost.n, 4)
+        self.assertEqual(self.ss.EDTSlot.n, 24)
+        self.assertEqual(self.ss.UCTSlot.n, 24)
+
+        # test idx values
+        self.assertSequenceEqual(self.ss.Bus.idx.v, ['Bus_1', 'Bus_2', 'Bus_3', 'Bus_4', 'Bus_5'])
+        self.assertSequenceEqual(self.ss.Area.idx.v, [1, 2, 3])
+
+        # test cache refreshing
+        self.ss.Bus.cache.refresh()  # used in ANDES but not in AMS
+
+        # test conversion to dataframe
+        self.ss.Bus.as_df()
+        self.ss.Bus.as_df(vin=True)
+
+        # test conversion to dataframe of ``Horizon`` model
+        self.ss.EDTSlot.as_df()
+        self.ss.EDTSlot.as_df(vin=True)
+
+        self.ss.UCTSlot.as_df()
+        self.ss.UCTSlot.as_df(vin=True)
+
+    def test_pflow_reset(self):
+        """
+        Test resetting power flow.
+        """
+
+        self.ss.PFlow.run()
+        self.ss.reset()
+        self.ss.PFlow.run()
+
+    def test_alter_param(self):
+        """
+        Test altering parameter for power flow.
+        """
+
+        self.ss.PV.alter("v0", "PV_3", 0.98)
+        self.assertEqual(self.ss.PV.v0.v[1], 0.98)
+        self.ss.PFlow.run()
+
+    def test_alter_param_before_routine(self):
+        """
+        Test altering parameter before running routine.
+        """
+
+        self.ss.GCost.alter("c1", ['GCost_1', 'GCost_2'], [1500., 3100.])
+        np.testing.assert_array_equal(self.ss.GCost.c1.v, [1500., 3100., 0.4, 0.1])
+        self.ss.ACOPF.run()
+        np.testing.assert_array_equal(self.ss.GCost.c1.v, [1500., 3100., 0.4, 0.1])
+
+    def test_alter_param_after_routine(self):
+        """
+        Test altering parameter after running routine.
+        """
+
+        self.ss.ACOPF.run()
+        self.ss.GCost.alter("c1", ['GCost_1', 'GCost_2'], [1500., 3100.])
+        np.testing.assert_array_equal(self.ss.GCost.c1.v, [1500., 3100., 0.4, 0.1])
+        self.ss.ACOPF.run()
+        np.testing.assert_array_equal(self.ss.GCost.c1.v, [1500., 3100., 0.4, 0.1])
+
+    def test_multiple_disconnected_line(self):
+        """
+        Test connectivity check for systems with disconnected lines.
+
+        These disconnected lines (zeros) was not excluded when counting
+        connected buses, causing an out-of-bound error.
+        """
+        # TODO: need to add `connectivity` in `system`
+        pass
+        # self.ss.Line.u.v[[0, 6]] = 0
+        # self.ss.PFlow.run()
+        # self.assertEqual(len(self.ss.Bus.islands), 1)
+        # self.assertEqual(self.ss.Bus.n_islanded_buses, 0)
+
+
+class TestIEEE14RAW(unittest.TestCase):
+    """
+    Test IEEE14 system in the RAW format.
+    """
+
+    # TODO: after add `run` in `system`, improve this part
+    def test_ieee14_raw(self):
+        ss = ams.load(
+            get_case("ieee14/ieee14.raw"),
+            default_config=True,
+            no_output=True,
+        )
+        ss.PFlow.run()
+        self.assertEqual(ss.PFlow.exit_code, 0, "Exit code is not 0.")
+
+    def test_ieee14_raw_convert(self):
+        ss = ams.run(
+            get_case("ieee14/ieee14.raw"),
+            convert=True,
+            default_config=True,
+        )
+        os.remove(ss.files.dump)
+        self.assertEqual(ss.exit_code, 0, "Exit code is not 0.")
+
+    def test_ieee14_raw2xlsx(self):
+        ss = ams.load(
+            get_case("ieee14/ieee14.raw"),
+            setup=True,
+            no_output=True,
+            default_config=True,
+        )
+        ams.io.xlsx.write(ss, "ieee14.xlsx", overwrite=True)
+        self.assertTrue(os.path.exists("ieee14.xlsx"))
+        os.remove("ieee14.xlsx")
+
+    def test_ieee14_raw2json(self):
+        ss = ams.load(
+            get_case("ieee14/ieee14.raw"),
+            setup=True,
+            no_output=True,
+            default_config=True,
+        )
+        ams.io.json.write(ss, "ieee14.json", overwrite=True)
+        self.assertTrue(os.path.exists("ieee14.json"))
+        os.remove("ieee14.json")
+
+    def test_ieee14_raw2json_convert(self):
+        ss = ams.run(
+            get_case("ieee14/ieee14.raw"),
+            convert="json",
+            default_config=True,
+        )
+
+        ss2 = ams.run(
+            "ieee14.json",
+            default_config=True,
+            no_output=True,
+        )
+
+        os.remove(ss.files.dump)
+        self.assertEqual(ss2.exit_code, 0, "Exit code is not 0.")
+
+    def test_read_json_from_memory(self):
+        fd = open(get_case("ieee14/ieee14.json"), "r")
+
+        ss = ams.main.System(
+            default_config=True,
+            no_output=True,
+        )
+        ams.io.json.read(ss, fd)
+        ss.setup()
+        ss.PFlow.run()
+
+        fd.close()
+        self.assertEqual(ss.exit_code, 0, "Exit code is not 0.")
+
+    def test_read_mpc_from_memory(self):
+        fd = open(get_case("matpower/case14.m"), "r")
+
+        ss = ams.main.System(
+            default_config=True,
+            no_output=True,
+        )
+        ams.io.matpower.read(ss, fd)
+        ss.setup()
+        ss.PFlow.run()
+
+        fd.close()
+        self.assertEqual(ss.exit_code, 0, "Exit code is not 0.")
+
+    def test_read_psse_from_memory(self):
+        fd_raw = open(get_case("ieee14/ieee14.raw"), "r")
+
+        ss = ams.main.System(
+            default_config=True,
+            no_output=True,
+        )
+        # suppress out-of-normal info
+        ss.config.warn_limits = 0
+        ss.config.warn_abnormal = 0
+
+        ams.io.psse.read(ss, fd_raw)
+        ss.setup()
+        ss.PFlow.run()
+
+        fd_raw.close()
+        self.assertEqual(ss.exit_code, 0, "Exit code is not 0.")
+
+
+class TestCaseInit(unittest.TestCase):
+    """
+    Test if initializations pass.
+    """
+
+    def test_ieee39_init(self):
+        """
+        Test if ieee39 initialization works.
+        """
+        ss = ams.load(
+            get_case("ieee39/ieee39_uced.xlsx"),
+            default_config=True,
+            no_output=True,
+        )
+        ss.DCOPF.init()
+        ss.RTED.init()
+        ss.ED.init()
+        ss.UC.init()
+
+        self.assertEqual(ss.DCOPF.exit_code, 0, "Exit code is not 0.")
+        self.assertEqual(ss.RTED.exit_code, 0, "Exit code is not 0.")
+        self.assertEqual(ss.ED.exit_code, 0, "Exit code is not 0.")
+        self.assertEqual(ss.UC.exit_code, 0, "Exit code is not 0.")
+
+    def test_ieee39_esd1_init(self):
+        """
+        Test if ieee39 with ESD1 initialization works.
+        """
+        ss = ams.load(
+            get_case("ieee39/ieee39_uced_esd1.xlsx"),
+            default_config=True,
+            no_output=True,
+        )
+        ss.EDES.init()
+        ss.UCES.init()
+
+        self.assertEqual(ss.EDES.exit_code, 0, "Exit code is not 0.")
+        self.assertEqual(ss.UCES.exit_code, 0, "Exit code is not 0.")

tests/test_cli.py

@@ -0,0 +1,34 @@
+import unittest
+import os
+
+import ams.main
+import ams.cli
+
+
+class TestCLI(unittest.TestCase):
+
+    def test_cli_parser(self):
+        ams.cli.create_parser()
+
+    def test_cli_preamble(self):
+        ams.cli.preamble()
+
+    def test_main_doc(self):
+        ams.main.doc('Bus')
+        ams.main.doc(list_supported=True)
+
+    def test_versioninfo(self):
+        ams.main.versioninfo()
+
+    def test_misc(self):
+        ams.main.misc(show_license=True)
+        ams.main.misc(save_config=None, overwrite=True)
+
+    def test_profile_run(self):
+        _ = ams.main.run(ams.get_case('matpower/case5.m'),
+                         no_output=False,
+                         profile=True,)
+        self.assertTrue(os.path.exists('case5_prof.prof'))
+        self.assertTrue(os.path.exists('case5_prof.txt'))
+        os.remove('case5_prof.prof')
+        os.remove('case5_prof.txt')

tests/test_export_csv.py

@@ -0,0 +1,89 @@
+"""
+Test routine export to CSV.
+"""
+import unittest
+import os
+import csv
+
+import numpy as np
+
+import ams
+
+
+class TestExportCSV(unittest.TestCase):
+    """
+    Tests for Routine export to CSV.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.main.load(
+            ams.get_case("5bus/pjm5bus_demo.xlsx"),
+            default_config=True,
+            no_output=True,
+        )
+        self.expected_csv_DCOPF = 'pjm5bus_demo_DCOPF.csv'
+        self.expected_csv_ED = 'pjm5bus_demo_ED.csv'
+
+    def test_no_export(self):
+        """
+        Test no export when routine is not converged.
+        """
+        self.assertIsNone(self.ss.DCOPF.export_csv())
+
+    def test_export_DCOPF(self):
+        """
+        Test export DCOPF to CSV.
+        """
+        self.ss.DCOPF.run(solver='CLARABEL')
+        self.ss.DCOPF.export_csv()
+        self.assertTrue(os.path.exists(self.expected_csv_DCOPF))
+
+        n_rows = 0
+        n_cols = 0
+        with open(self.expected_csv_DCOPF, 'r') as csv_file:
+            csv_reader = csv.reader(csv_file)
+            for row in csv_reader:
+                n_rows += 1
+                # Check if this row has more columns than the previous rows
+                if n_cols == 0 or len(row) > n_cols:
+                    n_cols = len(row)
+
+        n_cols_expected = np.sum([v.owner.n for v in self.ss.DCOPF.vars.values()])
+        n_cols_expected += np.sum([v.owner.n for v in self.ss.DCOPF.exprs.values()])
+        n_cols_expected += np.sum([v.owner.n for v in self.ss.DCOPF.exprcs.values()])
+        # cols number plus one for the index column
+        self.assertEqual(n_cols, n_cols_expected + 1)
+        # header row plus data row
+        n_rows_expected = 2
+        self.assertEqual(n_rows, n_rows_expected)
+
+        os.remove(self.expected_csv_DCOPF)
+
+    def test_export_ED(self):
+        """
+        Test export ED to CSV.
+        """
+        self.ss.ED.run(solver='CLARABEL')
+        self.ss.ED.export_csv()
+        self.assertTrue(os.path.exists(self.expected_csv_ED))
+
+        n_rows = 0
+        n_cols = 0
+        with open(self.expected_csv_ED, 'r') as csv_file:
+            csv_reader = csv.reader(csv_file)
+            for row in csv_reader:
+                n_rows += 1
+                # Check if this row has more columns than the previous rows
+                if n_cols == 0 or len(row) > n_cols:
+                    n_cols = len(row)
+
+        n_cols_expected = np.sum([v.owner.n for v in self.ss.ED.vars.values()])
+        n_cols_expected += np.sum([v.owner.n for v in self.ss.ED.exprs.values()])
+        n_cols_expected += np.sum([v.owner.n for v in self.ss.ED.exprcs.values()])
+        # cols number plus one for the index column
+        self.assertEqual(n_cols, n_cols_expected + 1)
+        # header row plus data row
+        n_rows_expected = len(self.ss.ED.timeslot.v) + 1
+        self.assertTrue(n_rows, n_rows_expected)
+
+        os.remove(self.expected_csv_ED)

tests/test_group.py

@@ -0,0 +1,83 @@
+"""
+Tests for group functions.
+"""
+import unittest
+
+import numpy as np
+
+import ams
+
+
+class TestGroup(unittest.TestCase):
+    """
+    Test the group class functions.
+    """
+
+    def setUp(self):
+        self.ss = ams.run(ams.get_case("ieee39/ieee39_uced_esd1.xlsx"),
+                          default_config=True,
+                          no_output=True,
+                          )
+
+    def test_group_access(self):
+        """
+        Test methods such as `idx2model`
+        """
+        ss = self.ss
+
+        # --- idx2uid ---
+        self.assertIsNone(ss.DG.idx2uid(None))
+        self.assertListEqual(ss.DG.idx2uid([None]), [None])
+
+        # --- idx2model ---
+        # what works
+        self.assertIs(ss.DG.idx2model('ESD1_1'), ss.ESD1)
+        self.assertListEqual(ss.DG.idx2model(['ESD1_1']), [ss.ESD1])
+
+        # what does not work
+        self.assertRaises(KeyError, ss.DG.idx2model, idx='1')
+        self.assertRaises(KeyError, ss.DG.idx2model, idx=88)
+        self.assertRaises(KeyError, ss.DG.idx2model, idx=[1, 88])
+
+        # --- get ---
+        self.assertRaises(KeyError, ss.DG.get, 'EtaC', 999)
+
+        np.testing.assert_equal(ss.DG.get('EtaC', 'ESD1_1',), 1.0)
+
+        np.testing.assert_equal(ss.DG.get('EtaC', ['ESD1_1'], allow_none=True,),
+                                [1.0])
+        np.testing.assert_equal(ss.DG.get('EtaC', ['ESD1_1', None],
+                                          allow_none=True, default=0.95),
+                                [1.0, 0.95])
+
+        # --- set ---
+        ss.DG.set('EtaC', 'ESD1_1', 'v', 0.95)
+        np.testing.assert_equal(ss.DG.get('EtaC', 'ESD1_1',), 0.95)
+
+        ss.DG.set('EtaC', ['ESD1_1'], 'v', 0.97)
+        np.testing.assert_equal(ss.DG.get('EtaC', ['ESD1_1'],), [0.97])
+
+        ss.DG.set('EtaC', ['ESD1_1'], 'v', [0.99])
+        np.testing.assert_equal(ss.DG.get('EtaC', ['ESD1_1'],), [0.99])
+
+        # --- find_idx ---
+        self.assertListEqual(ss.DG.find_idx('name', ['ESD1_1']),
+                             ss.ESD1.find_idx('name', ['ESD1_1']),
+                             )
+
+        self.assertListEqual(ss.DG.find_idx(['name', 'Sn'],
+                                            [('ESD1_1',),
+                                             (100.0,)]),
+                             ss.ESD1.find_idx(['name', 'Sn'],
+                                              [('ESD1_1',),
+                                               (100.0,)]),)
+
+        # --- get group idx ---
+        self.assertListEqual(ss.DG.get_all_idxes(), ss.ESD1.idx.v)
+
+    def test_group_repr(self):
+        """
+        Test `Group.__repr__()` method.
+        """
+        for grp in self.ss.groups.items():
+            print(grp.__repr__())