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

tests/test_known_good.py

@@ -0,0 +1,267 @@
+import logging
+import unittest
+
+import json
+
+import numpy as np
+
+from andes.shared import rad2deg
+import ams
+from ams.shared import nan
+
+logger = logging.getLogger(__name__)
+
+
+class TestKnownResults(unittest.TestCase):
+
+    def setUp(self) -> None:
+        with open(ams.get_case('matpower/benchmark.json'), 'r') as file:
+            self.mpres = json.load(file)
+
+        self.sp = ams.load(ams.get_case('matpower/case14.m'),
+                           setup=True, no_output=True, default_config=True)
+
+    def test_DCPF_case14(self):
+        """
+        Test DC power flow for case14.
+        """
+        self.sp.DCPF.run()
+        np.testing.assert_allclose(self.sp.DCPF.aBus.v * rad2deg,
+                                   np.array(self.mpres['case14']['DCPF']['aBus']).reshape(-1),
+                                   rtol=1e-2, atol=1e-2)
+
+        np.testing.assert_allclose(self.sp.DCPF.pg.v * self.sp.config.mva,
+                                   np.array(self.mpres['case14']['DCPF']['pg']).reshape(-1),
+                                   rtol=1e-2, atol=1e-2)
+
+    def test_PFlow_case14(self):
+        """
+        Test power flow for case14.
+        """
+        self.sp.PFlow.run()
+        np.testing.assert_allclose(self.sp.PFlow.aBus.v * rad2deg,
+                                   np.array(self.mpres['case14']['PFlow']['aBus']).reshape(-1),
+                                   rtol=1e-2, atol=1e-2)
+        np.testing.assert_allclose(self.sp.PFlow.vBus.v,
+                                   np.array(self.mpres['case14']['PFlow']['vBus']).reshape(-1),
+                                   rtol=1e-2, atol=1e-2)
+        np.testing.assert_allclose(self.sp.PFlow.pg.v.sum() * self.sp.config.mva,
+                                   np.array(self.mpres['case14']['PFlow']['pg']).sum(),
+                                   rtol=1e-2, atol=1e-2)
+
+    def test_DCOPF_case14(self):
+        """
+        Test DCOPF for case14.
+        """
+        self.sp.DCOPF.run(solver='CLARABEL')
+        self.assertAlmostEqual(self.sp.DCOPF.obj.v,
+                               self.mpres['case14']['DCOPF']['obj'],
+                               places=4)
+        np.testing.assert_allclose(self.sp.DCOPF.pi.v / self.sp.config.mva,
+                                   np.array(self.mpres['case14']['DCOPF']['pi']).reshape(-1),
+                                   rtol=1e-2, atol=1e-2)
+
+    def test_Matrices_case14(self):
+        """
+        Test matrices for case14.
+        """
+        ptdf = self.sp.mats.build_ptdf()
+        lodf = self.sp.mats.build_lodf()
+
+        ptdf_mp = load_ptdf(self.mpres, 'case14')
+        lodf_mp = load_lodf(self.mpres, 'case14')
+
+        ptdf[np.isnan(ptdf_mp)] = nan
+        lodf[np.isnan(lodf_mp)] = nan
+
+        np.testing.assert_allclose(ptdf, ptdf_mp,
+                                   equal_nan=True, rtol=1e-2, atol=1e-2)
+
+        np.testing.assert_allclose(lodf, lodf_mp,
+                                   equal_nan=True, rtol=1e-2, atol=1e-2)
+
+
+class TestKnownResultsIEEE39(unittest.TestCase):
+
+    def setUp(self) -> None:
+        with open(ams.get_case('matpower/benchmark.json'), 'r') as file:
+            self.mpres = json.load(file)
+
+        self.sp = ams.load(ams.get_case('matpower/case39.m'),
+                           setup=True, no_output=True, default_config=True)
+
+    def test_DCPF_case39(self):
+        """
+        Test DC power flow for case39.
+        """
+        self.sp.DCPF.run()
+        np.testing.assert_allclose(self.sp.DCPF.aBus.v * rad2deg,
+                                   np.array(self.mpres['case39']['DCPF']['aBus']).reshape(-1),
+                                   rtol=1e-2, atol=1e-2)
+
+        np.testing.assert_allclose(self.sp.DCPF.pg.v.sum() * self.sp.config.mva,
+                                   np.array(self.mpres['case39']['DCPF']['pg']).sum(),
+                                   rtol=1e-2, atol=1e-2)
+
+    def test_PFlow_case39(self):
+        """
+        Test power flow for case39.
+        """
+        self.sp.PFlow.run()
+        np.testing.assert_allclose(self.sp.PFlow.aBus.v * rad2deg,
+                                   np.array(self.mpres['case39']['PFlow']['aBus']).reshape(-1),
+                                   rtol=1e-2, atol=1e-2)
+        np.testing.assert_allclose(self.sp.PFlow.vBus.v,
+                                   np.array(self.mpres['case39']['PFlow']['vBus']).reshape(-1),
+                                   rtol=1e-2, atol=1e-2)
+        np.testing.assert_allclose(self.sp.PFlow.pg.v.sum() * self.sp.config.mva,
+                                   np.array(self.mpres['case39']['PFlow']['pg']).sum(),
+                                   rtol=1e-2, atol=1e-2)
+
+    def test_DCOPF_case39(self):
+        """
+        Test DCOPF for case39.
+        """
+        self.sp.DCOPF.run(solver='CLARABEL')
+        self.assertAlmostEqual(self.sp.DCOPF.obj.v,
+                               self.mpres['case39']['DCOPF']['obj'],
+                               places=2)
+        np.testing.assert_allclose(self.sp.DCOPF.pi.v / self.sp.config.mva,
+                                   np.array(self.mpres['case39']['DCOPF']['pi']).reshape(-1),
+                                   rtol=1e-2, atol=1e-2)
+
+    def test_Matrices_case39(self):
+        """
+        Test matrices for case39.
+        """
+        ptdf = self.sp.mats.build_ptdf()
+        lodf = self.sp.mats.build_lodf()
+
+        ptdf_mp = load_ptdf(self.mpres, 'case39')
+        lodf_mp = load_lodf(self.mpres, 'case39')
+
+        ptdf[np.isnan(ptdf_mp)] = nan
+        lodf[np.isnan(lodf_mp)] = nan
+
+        np.testing.assert_allclose(ptdf, ptdf_mp,
+                                   equal_nan=True, rtol=1e-2, atol=1e-2)
+
+        np.testing.assert_allclose(lodf, lodf_mp,
+                                   equal_nan=True, rtol=1e-2, atol=10)
+
+
+class TestKnownResultsIEEE118(unittest.TestCase):
+
+    def setUp(self) -> None:
+        with open(ams.get_case('matpower/benchmark.json'), 'r') as file:
+            self.mpres = json.load(file)
+
+        self.sp = ams.load(ams.get_case('matpower/case118.m'),
+                           setup=True, no_output=True, default_config=True)
+
+    def test_DCPF_case118(self):
+        """
+        Test DC power flow for case118.
+        """
+        self.sp.DCPF.run()
+        aBus_mp = np.array(self.mpres['case118']['DCPF']['aBus']).reshape(-1)
+        aBus_mp -= aBus_mp[0]
+        np.testing.assert_allclose((self.sp.DCPF.aBus.v - self.sp.DCPF.aBus.v[0]) * rad2deg,
+                                   aBus_mp,
+                                   rtol=1e-2, atol=1e-2)
+
+        np.testing.assert_allclose(self.sp.DCPF.pg.v.sum() * self.sp.config.mva,
+                                   np.array(self.mpres['case118']['DCPF']['pg']).sum(),
+                                   rtol=1e-2, atol=1e-2)
+
+    def test_PFlow_case118(self):
+        """
+        Test power flow for case118.
+        """
+        self.sp.PFlow.run()
+        np.testing.assert_allclose(self.sp.PFlow.aBus.v * rad2deg,
+                                   np.array(self.mpres['case118']['PFlow']['aBus']).reshape(-1),
+                                   rtol=1e-2, atol=1e-2)
+        np.testing.assert_allclose(self.sp.PFlow.vBus.v,
+                                   np.array(self.mpres['case118']['PFlow']['vBus']).reshape(-1),
+                                   rtol=1e-2, atol=1e-2)
+        np.testing.assert_allclose(self.sp.PFlow.pg.v.sum() * self.sp.config.mva,
+                                   np.array(self.mpres['case118']['PFlow']['pg']).sum(),
+                                   rtol=1e-2, atol=1e-2)
+
+    def test_DCOPF_case118(self):
+        """
+        Test DCOPF for case118.
+        """
+        self.sp.DCOPF.run(solver='CLARABEL')
+        self.assertAlmostEqual(self.sp.DCOPF.obj.v,
+                               self.mpres['case118']['DCOPF']['obj'],
+                               places=2)
+        np.testing.assert_allclose(self.sp.DCOPF.pi.v / self.sp.config.mva,
+                                   np.array(self.mpres['case118']['DCOPF']['pi']).reshape(-1),
+                                   rtol=1e-2, atol=1e-2)
+
+    def test_Matrices_case118(self):
+        """
+        Test matrices for case118.
+        """
+        ptdf = self.sp.mats.build_ptdf()
+        lodf = self.sp.mats.build_lodf()
+
+        ptdf_mp = load_ptdf(self.mpres, 'case118')
+        lodf_mp = load_lodf(self.mpres, 'case118')
+
+        ptdf[np.isnan(ptdf_mp)] = nan
+        lodf[np.isnan(lodf_mp)] = nan
+
+        np.testing.assert_allclose(ptdf, ptdf_mp,
+                                   equal_nan=True, rtol=1e-2, atol=1e-2)
+
+        np.testing.assert_allclose(lodf, lodf_mp,
+                                   equal_nan=True, rtol=1e-2, atol=10)
+
+
+def load_ptdf(mpres, case):
+    """
+    Load PTDF from mpres.
+
+    Parameters
+    ----------
+    mpres : dict
+        The result dictionary.
+    case : str
+        The case name.
+
+    Returns
+    -------
+    ptdf : np.ndarray
+        The PTDF matrix.
+    """
+    ptdf_data = np.array(mpres[case]['PTDF'])
+    ptdf = np.array([[0 if val == "_NaN_" else val for val in row] for row in ptdf_data],
+                    dtype=float)
+    return ptdf
+
+
+def load_lodf(mpres, case):
+    """
+    Load LODF from mpres.
+
+    Parameters
+    ----------
+    mpres : dict
+        The result dictionary.
+    case : str
+        The case name.
+
+    Returns
+    -------
+    lodf : np.ndarray
+        The LODF matrix.
+    """
+    lodf_data = np.array(mpres[case]['LODF'])
+    lodf = np.array([[nan if val in ["_NaN_", "-_Inf_", "_Inf_"] else val for val in row] for row in lodf_data],
+                    dtype=float)
+    # NOTE: force the diagonal to be -1
+    np.fill_diagonal(lodf, -1)
+    return lodf

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))