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

tests/test_matp.py

@@ -0,0 +1,437 @@
+"""
+Test module MatProcessor.
+"""
+
+import unittest
+import os
+
+import numpy as np
+
+import ams
+from ams.core.matprocessor import MatProcessor, MParam
+from ams.shared import sps
+
+
+class TestMatProcessorBasic(unittest.TestCase):
+    """
+    Test basic functionality of MatProcessor.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case("matpower/case300.m"),
+                           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.ng = self.ss.StaticGen.n
+        self.nsh = self.ss.Shunt.n
+        self.nD = self.ss.StaticLoad.n
+
+        self.mats = MatProcessor(self.ss)
+        self.mats.build()
+
+    def test_MParams_owner(self):
+        """
+        Tesst MParams owner before system initialization.
+        """
+        self.assertIs(self.mats.Cft.owner, self.mats)
+        self.assertIs(self.mats.CftT.owner, self.mats)
+        self.assertIs(self.mats.Cg.owner, self.mats)
+        self.assertIs(self.mats.Cl.owner, self.mats)
+        self.assertIs(self.mats.Csh.owner, self.mats)
+        self.assertIs(self.mats.Bbus.owner, self.mats)
+        self.assertIs(self.mats.Bf.owner, self.mats)
+        self.assertIs(self.mats.Pbusinj.owner, self.mats)
+        self.assertIs(self.mats.Pfinj.owner, self.mats)
+        self.assertIs(self.mats.PTDF.owner, self.mats)
+        self.assertIs(self.mats.LODF.owner, self.mats)
+
+    def test_MParam_export_csv(self):
+        """
+        Test MParams export.
+        """
+        # --- path is not given ---
+        exported_csv = self.mats.Cft.export_csv()
+        self.assertTrue(os.path.exists(exported_csv))
+        os.remove(exported_csv)
+
+        # --- path is given ---
+        path = 'CASE300_Cft.csv'
+        exported_csv = self.mats.Cft.export_csv(path)
+        self.assertTrue(os.path.exists(path))
+        os.remove(path)
+
+    def test_MParams_export(self) -> None:
+        """
+        Test MParams export.
+        """
+        cft = self.mats.Cft.export_csv()
+        self.assertTrue(os.path.exists(cft))
+        os.remove(cft)
+
+        cftt = self.mats.CftT.export_csv()
+        self.assertTrue(os.path.exists(cftt))
+        os.remove(cftt)
+
+        cg = self.mats.Cg.export_csv()
+        self.assertTrue(os.path.exists(cg))
+        os.remove(cg)
+
+        cl = self.mats.Cl.export_csv()
+        self.assertTrue(os.path.exists(cl))
+        os.remove(cl)
+
+        csh = self.mats.Csh.export_csv()
+        self.assertTrue(os.path.exists(csh))
+        os.remove(csh)
+
+        bbus = self.mats.Bbus.export_csv()
+        self.assertTrue(os.path.exists(bbus))
+        os.remove(bbus)
+
+        bf = self.mats.Bf.export_csv()
+        self.assertTrue(os.path.exists(bf))
+        os.remove(bf)
+
+        ptdf = self.mats.PTDF.export_csv()
+        self.assertTrue(os.path.exists(ptdf))
+        os.remove(ptdf)
+
+        lodf = self.mats.LODF.export_csv()
+        self.assertTrue(os.path.exists(lodf))
+        os.remove(lodf)
+
+    def test_MParam_instance(self):
+        """
+        Test `MParam` instantiate.
+        """
+        one_vec = MParam(v=sps.csr_matrix(np.ones(self.ss.Bus.n)))
+        # check if `_v` is `sps.csr_matrix` instance
+        self.assertIsInstance(one_vec._v, sps.csr_matrix)
+        # check if `v` is 1D-array
+        self.assertEqual(one_vec.v.shape, (self.ss.Bus.n,))
+
+    def test_c(self):
+        """
+        Test connectivity matrices.
+        """
+        # Test `Cg`
+        self.assertIsInstance(self.mats.Cg._v, (sps.csr_matrix, sps.lil_matrix))
+        self.assertIsInstance(self.mats.Cg.v, np.ndarray)
+        self.assertEqual(self.mats.Cg._v.max(), 1)
+        np.testing.assert_equal(self.mats.Cg._v.sum(axis=0), np.ones((1, self.ng)))
+
+        # Test `Cl`
+        self.assertIsInstance(self.mats.Cl._v, (sps.csr_matrix, sps.lil_matrix))
+        self.assertIsInstance(self.mats.Cl.v, np.ndarray)
+        self.assertEqual(self.mats.Cl._v.max(), 1)
+        np.testing.assert_equal(self.mats.Cl._v.sum(axis=0), np.ones((1, self.nD)))
+
+        # Test `Csh`
+        self.assertIsInstance(self.mats.Csh._v, (sps.csr_matrix, sps.lil_matrix))
+        self.assertIsInstance(self.mats.Csh.v, np.ndarray)
+        self.assertEqual(self.mats.Csh._v.max(), 1)
+        np.testing.assert_equal(self.mats.Csh._v.sum(axis=0), np.ones((1, self.nsh)))
+
+        # Test `Cft`
+        self.assertIsInstance(self.mats.Cft._v, (sps.csr_matrix, sps.lil_matrix))
+        self.assertIsInstance(self.mats.Cft.v, np.ndarray)
+        self.assertEqual(self.mats.Cft._v.max(), 1)
+        np.testing.assert_equal(self.mats.Cft._v.sum(axis=0), np.zeros((1, self.nl)))
+
+    def test_b_calc(self):
+        """
+        Test `b_calc`.
+        """
+        b = self.mats._calc_b()
+        self.assertIsInstance(b, np.ndarray)
+        self.assertEqual(b.shape, (self.nl,))
+
+    def test_bf(self):
+        """
+        Test `Bf`.
+        """
+        self.assertIsInstance(self.mats.Bf._v, (sps.csr_matrix, sps.lil_matrix))
+        np.testing.assert_equal(self.mats.Bf._v.shape, (self.nl, self.nb))
+
+    def test_bbus(self):
+        """
+        Test `Bbus`.
+        """
+        self.assertIsInstance(self.mats.Bbus._v, (sps.csr_matrix, sps.lil_matrix))
+        np.testing.assert_equal(self.mats.Bbus._v.shape, (self.nb, self.nb))
+
+    def test_pfinj(self):
+        """
+        Test `Pfinj`.
+        """
+        self.assertIsInstance(self.mats.Pfinj._v, np.ndarray)
+        np.testing.assert_equal(self.mats.Pfinj._v.shape, (self.nl,))
+
+    def test_pbusinj(self):
+        """
+        Test `Pbusinj`.
+        """
+        self.assertIsInstance(self.mats.Pbusinj._v, np.ndarray)
+        np.testing.assert_equal(self.mats.Pbusinj._v.shape, (self.nb,))
+
+
+class TestBuildPTDF(unittest.TestCase):
+    """
+    Test build PTDF.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case('matpower/case14.m'),
+                           setup=True, default_config=True, no_output=True)
+        self.nl = self.ss.Line.n
+        self.nb = self.ss.Bus.n
+
+        self.assertFalse(self.ss.mats.initialized)
+        # NOTE: here we test `no_store=True` option
+        self.ptdf_full = self.ss.mats.build_ptdf(no_store=True)
+        self.assertTrue(self.ss.mats.initialized)
+
+    def test_ptdf_before_mat_init(self):
+        """
+        Test PTDF before MatProcessor initialization `mats.init()`.
+        """
+        self.assertIsNone(self.ss.mats.PTDF._v)
+        _ = self.ss.mats.build_ptdf(no_store=False)
+        self.assertEqual(self.ss.mats.PTDF._v.shape, (self.nl, self.nb))
+
+    def test_ptdf_lines(self):
+        """
+        Test PTDF with `line` inputs.
+        """
+        # NOTE: when `line` is given, `PTDF` should not be stored even with `no_store=False`
+
+        # input str
+        ptdf_l2 = self.ss.mats.build_ptdf(line=self.ss.Line.idx.v[2], no_store=False)
+        self.assertIsNone(self.ss.mats.PTDF._v)
+        np.testing.assert_array_almost_equal(ptdf_l2, self.ptdf_full[2, :])
+
+        # input list with single element
+        ptdf_l2p = self.ss.mats.build_ptdf(line=[self.ss.Line.idx.v[2]], no_store=False)
+        self.assertIsNone(self.ss.mats.PTDF._v)
+        np.testing.assert_array_almost_equal(ptdf_l2p, self.ptdf_full[[2], :])
+
+        # input list with multiple elements
+        ptdf_l23 = self.ss.mats.build_ptdf(line=self.ss.Line.idx.v[2:4], no_store=False)
+        self.assertIsNone(self.ss.mats.PTDF._v)
+        np.testing.assert_array_almost_equal(ptdf_l23, self.ptdf_full[2:4, :])
+
+    def test_ptdf_incremental_lines(self):
+        """
+        Test PTDF incremental build with `line` inputs.
+        """
+        # input str
+        ptdf_l2 = self.ss.mats.build_ptdf(line=self.ss.Line.idx.v[2], incremental=True, no_store=False,
+                                          no_tqdm=True)
+        np.testing.assert_array_almost_equal(ptdf_l2.todense(),
+                                             self.ptdf_full[[2], :])
+        self.assertTrue(sps.isspmatrix_lil(ptdf_l2))
+        self.assertIsNone(self.ss.mats.PTDF._v)
+
+        # input list with single element
+        ptdf_l2p = self.ss.mats.build_ptdf(line=[self.ss.Line.idx.v[2]], incremental=True, no_store=False,
+                                           no_tqdm=False)
+        np.testing.assert_array_almost_equal(ptdf_l2p.todense(),
+                                             self.ptdf_full[[2], :])
+        self.assertTrue(sps.isspmatrix_lil(ptdf_l2p))
+        self.assertIsNone(self.ss.mats.PTDF._v)
+
+        # input list with multiple elements
+        ptdf_l23 = self.ss.mats.build_ptdf(line=self.ss.Line.idx.v[2:4], incremental=True, no_store=False)
+        np.testing.assert_array_almost_equal(ptdf_l23.todense(),
+                                             self.ptdf_full[2:4, :])
+
+    def test_ptdf_incremental_step(self):
+        """
+        Test PTDF incremental build with step.
+        """
+        # step < line length
+        ptdf_c1 = self.ss.mats.build_ptdf(line=self.ss.Line.idx.v[2:4], incremental=True,
+                                          no_store=False, step=1)
+        self.assertTrue(sps.isspmatrix_lil(ptdf_c1))
+        self.assertIsNone(self.ss.mats.PTDF._v)
+        np.testing.assert_array_almost_equal(ptdf_c1.todense(),
+                                             self.ptdf_full[2:4, :],)
+
+        # step = line length
+        ptdf_c2 = self.ss.mats.build_ptdf(line=self.ss.Line.idx.v[2:4], incremental=True,
+                                          no_store=False, step=2)
+        self.assertTrue(sps.isspmatrix_lil(ptdf_c2))
+        self.assertIsNone(self.ss.mats.PTDF._v)
+        np.testing.assert_array_almost_equal(ptdf_c2.todense(),
+                                             self.ptdf_full[2:4, :],)
+
+        # step > line length
+        ptdf_c5 = self.ss.mats.build_ptdf(line=self.ss.Line.idx.v[2:4], incremental=True,
+                                          no_store=False, step=5)
+        self.assertTrue(sps.isspmatrix_lil(ptdf_c5))
+        self.assertIsNone(self.ss.mats.PTDF._v)
+        np.testing.assert_array_almost_equal(ptdf_c5.todense(),
+                                             self.ptdf_full[2:4, :],)
+
+
+class TestBuildLODF(unittest.TestCase):
+    """
+    Test build LODF.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case('matpower/case14.m'),
+                           setup=True, default_config=True, no_output=True)
+        self.nl = self.ss.Line.n
+        self.nb = self.ss.Bus.n
+        self.dec = 4
+
+        self.assertFalse(self.ss.mats.initialized)
+        self.lodf_full = self.ss.mats.build_lodf(no_store=True)
+        self.assertTrue(self.ss.mats.initialized)
+
+    def test_lodf_before_ptdf(self):
+        """
+        Test LODF before PTDF.
+        """
+        self.assertIsNone(self.ss.mats.PTDF._v)
+        self.assertIsNone(self.ss.mats.LODF._v)
+        _ = self.ss.mats.build_lodf(no_store=False)
+        self.assertEqual(self.ss.mats.LODF._v.shape, (self.nl, self.nl))
+        # PTDF should not be stored for requested building
+        self.assertIsNone(self.ss.mats.PTDF._v)
+
+    def test_lodf_lines(self):
+        """
+        Test LODF with `line` inputs.
+        """
+        # input str
+        lodf_l2 = self.ss.mats.build_lodf(line=self.ss.Line.idx.v[2], no_store=False)
+        np.testing.assert_array_almost_equal(lodf_l2, self.lodf_full[:, 2], decimal=self.dec)
+
+        # input list with single element
+        lodf_l2p = self.ss.mats.build_lodf(line=[self.ss.Line.idx.v[2]], no_store=False)
+        np.testing.assert_array_almost_equal(lodf_l2p, self.lodf_full[:, [2]], decimal=self.dec)
+
+        # input list with multiple elements
+        lodf_l23 = self.ss.mats.build_lodf(line=self.ss.Line.idx.v[2:4], no_store=False)
+        np.testing.assert_array_almost_equal(lodf_l23, self.lodf_full[:, 2:4], decimal=self.dec)
+
+    def test_lodf_incremental_lines(self):
+        """
+        Test LODF incremental build with `line` inputs.
+        """
+        # input str
+        lodf_l2 = self.ss.mats.build_lodf(line=self.ss.Line.idx.v[2], incremental=True, no_store=False)
+        np.testing.assert_array_almost_equal(lodf_l2.todense(),
+                                             self.lodf_full[:, [2]],
+                                             decimal=self.dec)
+        self.assertTrue(sps.isspmatrix_lil(lodf_l2))
+
+        # input list with single element
+        lodf_l2p = self.ss.mats.build_lodf(line=[self.ss.Line.idx.v[2]], incremental=True, no_store=False)
+        np.testing.assert_array_almost_equal(lodf_l2p.todense(),
+                                             self.lodf_full[:, [2]],
+                                             decimal=self.dec)
+        self.assertTrue(sps.isspmatrix_lil(lodf_l2p))
+
+        # input list with multiple elements
+        lodf_l23 = self.ss.mats.build_lodf(line=self.ss.Line.idx.v[2:4], incremental=True, no_store=False)
+        np.testing.assert_array_almost_equal(lodf_l23.todense(),
+                                             self.lodf_full[:, 2:4],
+                                             decimal=self.dec)
+
+    def test_lodf_incremental_step(self):
+        """
+        Test LODF incremental build with step.
+        """
+        # step < line length
+        lodf_c1 = self.ss.mats.build_lodf(line=self.ss.Line.idx.v[2:4], incremental=True,
+                                          no_store=False, step=1)
+        self.assertTrue(sps.isspmatrix_lil(lodf_c1))
+        np.testing.assert_array_almost_equal(lodf_c1.todense(),
+                                             self.lodf_full[:, 2:4],
+                                             decimal=self.dec)
+
+        # step = line length
+        lodf_c2 = self.ss.mats.build_lodf(line=self.ss.Line.idx.v[2:4], incremental=True,
+                                          no_store=False, step=2)
+        self.assertTrue(sps.isspmatrix_lil(lodf_c2))
+        np.testing.assert_array_almost_equal(lodf_c2.todense(),
+                                             self.lodf_full[:, 2:4],
+                                             decimal=self.dec)
+
+        # step > line length
+        lodf_c5 = self.ss.mats.build_lodf(line=self.ss.Line.idx.v[2:4], incremental=True,
+                                          no_store=False, step=5)
+        self.assertTrue(sps.isspmatrix_lil(lodf_c5))
+        np.testing.assert_array_almost_equal(lodf_c5.todense(),
+                                             self.lodf_full[:, 2:4],
+                                             decimal=self.dec)
+
+
+class TestBuildOTDF(unittest.TestCase):
+    """
+    Test build OTDF.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.load(ams.get_case('matpower/case14.m'),
+                           setup=True, default_config=True, no_output=True)
+        self.nl = self.ss.Line.n
+        self.nb = self.ss.Bus.n
+        self.dec = 4
+        _ = self.ss.mats.build()
+
+    def test_otdf_dense_build(self):
+        _ = self.ss.mats.build_ptdf(no_store=False, incremental=False)
+        _ = self.ss.mats.build_lodf(no_store=False, incremental=False)
+        self.otdf_full = self.ss.mats.build_otdf()
+        self.assertEqual(self.otdf_full.shape, (self.nl, self.nb))
+
+    def test_otdf_sparse_build(self):
+        # --- both PTDF and LODF are dense ---
+        _ = self.ss.mats.build_ptdf(no_store=False, incremental=False)
+        _ = self.ss.mats.build_lodf(no_store=False, incremental=False)
+        otdf_dense = self.ss.mats.build_otdf()
+
+        _ = self.ss.mats.build_ptdf(no_store=False, incremental=True)
+        _ = self.ss.mats.build_lodf(no_store=False, incremental=True)
+        otdf_sparse = self.ss.mats.build_otdf()
+        np.testing.assert_array_almost_equal(otdf_sparse.todense(), otdf_dense,
+                                             decimal=self.dec)
+
+        # --- PTDF is dense and LODF is sparse ---
+        _ = self.ss.mats.build_ptdf(no_store=False, incremental=False)
+        _ = self.ss.mats.build_lodf(no_store=False, incremental=True)
+        otdf_sps1 = self.ss.mats.build_otdf()
+        np.testing.assert_array_almost_equal(otdf_sps1, otdf_dense,
+                                             decimal=self.dec)
+
+        # --- PTDF is sparse and LODF is dense ---
+        _ = self.ss.mats.build_ptdf(no_store=False, incremental=True)
+        _ = self.ss.mats.build_lodf(no_store=False, incremental=False)
+        otdf_sps2 = self.ss.mats.build_otdf()
+        np.testing.assert_array_almost_equal(otdf_sps2.todense(), otdf_dense,
+                                             decimal=self.dec)
+
+    def test_otdf_lines(self):
+        """
+        Test OTDF with `line` inputs.
+        """
+        # --- both PTDF and LODF are dense ---
+        _ = self.ss.mats.build_ptdf(no_store=False, incremental=False)
+        _ = self.ss.mats.build_lodf(no_store=False, incremental=False)
+
+        # input str
+        otdf_l2 = self.ss.mats.build_otdf(line=self.ss.Line.idx.v[2])
+        self.assertEqual(otdf_l2.shape, (self.nl, self.nb))
+
+        # input list with single element
+        otdf_l2p = self.ss.mats.build_otdf(line=[self.ss.Line.idx.v[2]])
+        self.assertEqual(otdf_l2p.shape, (self.nl, self.nb))
+
+        # input list with multiple elements
+        otdf_l23 = self.ss.mats.build_otdf(line=self.ss.Line.idx.v[2:4])
+        self.assertEqual(otdf_l23.shape, (self.nl, self.nb))

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)