ltbams 1.0.11__py3-none-any.whl → 1.0.13__py3-none-any.whl

tests/test_group.py

@@ -1,83 +0,0 @@
-"""
-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__())

tests/test_interface.py

@@ -1,238 +0,0 @@
-"""
-Test interface.
-"""
-
-import unittest
-import numpy as np
-
-import andes
-import ams
-
-from ams.interface import (build_group_table, make_link_table, to_andes,
-                           parse_addfile, verify_pf)
-
-
-class TestAndesConversion(unittest.TestCase):
-    """
-    Tests conversion from AMS to ANDES.
-    """
-    ad_cases = [
-        'ieee14/ieee14_exac1.json',
-        'ieee39/ieee39_full.xlsx',
-        'npcc/npcc.xlsx',
-    ]
-    am_cases = [
-        'ieee14/ieee14.json',
-        'ieee39/ieee39.xlsx',
-        'npcc/npcc_uced.xlsx',
-    ]
-
-    def setUp(self) -> None:
-        """
-        Test setup.
-        """
-
-    def test_basic_functions(self):
-        """
-        Test basic functions defined in ANDES Interop.
-        """
-        for ad_case in self.ad_cases:
-            sa = andes.load(andes.get_case(ad_case),
-                            setup=True, no_output=True, default_config=True,)
-            # --- test build_group_table ---
-            ssa_stg = build_group_table(adsys=sa,
-                                        grp_name='StaticGen',
-                                        param_name=['u', 'name', 'idx', 'bus'],
-                                        mdl_name=[])
-            self.assertEqual(ssa_stg.shape,
-                             (sa.StaticGen.n, 4))
-
-            ssa_gov = build_group_table(adsys=sa, grp_name='TurbineGov',
-                                        param_name=['idx', 'syn'],
-                                        mdl_name=[])
-            self.assertEqual(ssa_gov.shape,
-                             (sa.TurbineGov.n, 2))
-            # --- test make_link_table ---
-            link_table = make_link_table(adsys=sa)
-            stg_idx = [str(i) for i in sa.PV.idx.v + sa.Slack.idx.v]
-            self.assertSetEqual(set(stg_idx),
-                                set(link_table['stg_idx'].values))
-            bus_idx = [str(i) for i in sa.PV.bus.v + sa.Slack.bus.v]
-            self.assertSetEqual(set(bus_idx),
-                                set(link_table['bus_idx'].values))
-
-    def test_convert(self):
-        """
-        Test conversion from AMS case to ANDES case.
-        """
-        for ad_case, am_case in zip(self.ad_cases, self.am_cases):
-            sp = ams.load(ams.get_case(am_case),
-                          setup=True, no_output=True, default_config=True,)
-            # before addfile
-            sa = to_andes(sp, setup=False)
-            self.assertEqual(set(sp.PV.idx.v), set(sa.PV.idx.v))
-            self.assertEqual(set(sp.Bus.idx.v), set(sa.Bus.idx.v))
-            self.assertEqual(set(sp.Line.idx.v), set(sa.Line.idx.v))
-            self.assertEqual(np.sum(sp.PQ.p0.v), np.sum(sa.PQ.p0.v))
-
-            # after addfile
-            sa = parse_addfile(adsys=sa, amsys=sp,
-                               addfile=andes.get_case(ad_case))
-            sa.setup()
-            set1 = set(sa.GENROU.gen.v)
-            set2 = set(sp.StaticGen.get_all_idxes())
-            # set2 includes set1, ensure GENROU.gen are all in StaticGen.idx
-            self.assertEqual(set1, set1 & set2)
-
-            # ensure PFlow models consistency
-            pflow_mdls = list(sa.PFlow.models.keys())
-            for mdl in pflow_mdls:
-                self.assertTrue(sp.models[mdl].as_df().equals(sa.PFlow.models[mdl].as_df()))
-
-    def test_convert_after_update(self):
-        """
-        Test conversion from AMS case to ANDES case after updating parameters.
-        """
-        for am_case in self.am_cases:
-            sp = ams.load(ams.get_case(am_case),
-                          setup=True, no_output=True, default_config=True,)
-        # record initial values
-        pq_idx = sp.PQ.idx.v
-        p0 = sp.PQ.p0.v.copy()
-        sa = to_andes(sp, setup=False, no_output=True, default_config=True)
-        # before update
-        np.testing.assert_array_equal(sp.PQ.p0.v, sa.PQ.p0.v)
-        # after update
-        sp.PQ.alter(src='p0', idx=pq_idx, value=0.9*p0)
-        sa = to_andes(sp, setup=False, no_output=True, default_config=True)
-        np.testing.assert_array_equal(sp.PQ.p0.v, sa.PQ.p0.v)
-
-    def test_extra_dyn(self):
-        """
-        Test conversion when extra dynamic models exist.
-        """
-        sp = ams.load(ams.get_case('ieee14/ieee14_uced.xlsx'),
-                      setup=True, no_output=True, default_config=True,)
-        sa = to_andes(sp, addfile=andes.get_case('ieee14/ieee14_full.xlsx'),
-                      setup=True, no_output=True, default_config=True,
-                      verify=False, tol=1e-3)
-        self.assertGreaterEqual(sa.PVD1.n, 0)
-
-    def test_verify_pf(self):
-        """
-        Test verification of power flow results.
-        """
-        sp = ams.load(ams.get_case('matpower/case300.m'),
-                      setup=True, no_output=True, default_config=True,)
-        sa = to_andes(sp,
-                      setup=True, no_output=True, default_config=True,
-                      verify=False, tol=1e-3)
-        self.assertTrue(verify_pf(amsys=sp, adsys=sa, tol=1e-7))
-
-    def test_to_andes_toggle(self):
-        """
-        Test conversion when there is Toggle in ANDES case.
-        """
-        sp = ams.load(ams.get_case('5bus/pjm5bus_demo.json'),
-                      setup=True,
-                      no_output=True,
-                      default_config=True)
-        sa = sp.to_andes(setup=True,
-                         addfile=andes.get_case('5bus/pjm5bus.xlsx'),
-                         verify=False)
-        self.assertGreater(sa.Toggle.n, 0)
-
-    def test_to_andes_alter(self):
-        """
-        Test conversion when there is Alter in ANDES case.
-        """
-        sp = ams.load(ams.get_case('ieee14/ieee14_uced.xlsx'),
-                      setup=True,
-                      no_output=True,
-                      default_config=True)
-        sa = sp.to_andes(setup=True,
-                         addfile=andes.get_case('ieee14/ieee14_alter.xlsx'),
-                         verify=False)
-        self.assertGreater(sa.Alter.n, 0)
-
-    def test_to_andes_fault(self):
-        """
-        Test conversion when there is Toggle in ANDES case.
-        """
-        sp = ams.load(ams.get_case('ieee14/ieee14_uced.xlsx'),
-                      setup=True,
-                      no_output=True,
-                      default_config=True)
-        sa = sp.to_andes(setup=True,
-                         addfile=andes.get_case('ieee14/ieee14_fault.xlsx'),
-                         verify=False)
-        self.assertGreater(sa.Fault.n, 0)
-
-
-class TestDataExchange(unittest.TestCase):
-    """
-    Tests for data exchange between AMS and ANDES.
-    """
-
-    def setUp(self) -> None:
-        """
-        Test setup. This is executed before each test case.
-        """
-        self.sp = ams.load(ams.get_case('ieee14/ieee14_uced.xlsx'),
-                           setup=True,
-                           no_output=True,
-                           default_config=True,)
-        self.sp.RTED.run(solver='CLARABEL')
-        self.sp.RTED.dc2ac()
-        self.stg_idx = self.sp.RTED.pg.get_all_idxes()
-
-    def test_data_exchange(self):
-        """
-        Test data exchange between AMS and ANDES.
-        """
-        sa = to_andes(self.sp, setup=True,
-                      addfile=andes.get_case('ieee14/ieee14_full.xlsx'),
-                      no_output=True,
-                      default_config=True,)
-        # alleviate limiter
-        sa.TGOV1.set(src='VMAX', idx=sa.TGOV1.idx.v, attr='v', value=100*np.ones(sa.TGOV1.n))
-        sa.TGOV1.set(src='VMIN', idx=sa.TGOV1.idx.v, attr='v', value=np.zeros(sa.TGOV1.n))
-
-        # --- test before PFlow ---
-        self.sp.dyn.send(adsys=sa, routine='RTED')
-        p0 = sa.StaticGen.get(src='p0', attr='v', idx=self.stg_idx)
-        pg = self.sp.RTED.get(src='pg', attr='v', idx=self.stg_idx)
-        np.testing.assert_array_equal(p0, pg)
-
-        # --- test after TDS ---
-        self.assertFalse(self.sp.dyn.is_tds)
-        sa.PFlow.run()
-        sa.TDS.init()
-        self.assertTrue(self.sp.dyn.is_tds)
-
-        sa.TDS.config.tf = 1
-        sa.TDS.run()
-        self.sp.dyn.send(adsys=sa, routine='RTED')
-        self.sp.dyn.receive(adsys=sa, routine='RTED', no_update=False)
-
-
-class TestLoadANDESFile(unittest.TestCase):
-    """
-    Test loading ANDES file.
-    """
-
-    def test_no_dyn_models(self):
-        """
-        Test loading ANDES file without dynamic models.
-        """
-        sp1 = ams.load(andes.get_case('ieee14/ieee14_exac1.json'),
-                       setup=True,
-                       no_output=True,
-                       default_config=True,)
-        self.assertNotIn('EXAC1', sp1.models.keys())
-
-        sp2 = ams.load(andes.get_case('ieee14/ieee14_pvd1.json'),
-                       setup=True,
-                       no_output=True,
-                       default_config=True,)
-        self.assertIn('PVD1', sp2.models.keys())

tests/test_io.py

@@ -1,180 +0,0 @@
-"""
-Test file input/output.
-"""
-import os
-import unittest
-import numpy as np
-
-import ams
-
-
-class TestMATPOWER(unittest.TestCase):
-    """
-    Test IO functions for MATPOWER and PYPOWER.
-    """
-
-    def setUp(self):
-        self.mpc5 = ams.io.matpower.m2mpc(ams.get_case('matpower/case5.m'))
-        self.mpc14 = ams.io.matpower.m2mpc(ams.get_case('matpower/case14.m'))
-
-    def test_m2mpc(self):
-        """Test conversion from M file to mpc dict."""
-        # NOTE: when the keys are there, read them
-        self.assertTupleEqual(self.mpc5['gencost'].shape, (5, 6))
-        self.assertTupleEqual(self.mpc5['gentype'].shape, (5,))
-        self.assertTupleEqual(self.mpc5['genfuel'].shape, (5,))
-
-        # NOTE: when the keys are not there, the read mpc will not complete them
-        self.assertTupleEqual(self.mpc14['gencost'].shape, (5, 7))
-        self.assertNotIn('gentype', self.mpc14)
-        self.assertNotIn('genfuel', self.mpc14)
-
-    def test_mpc2system(self):
-        """Test conversion from MPC to AMS System."""
-        system5 = ams.system.System()
-        ams.io.matpower.mpc2system(self.mpc5, system5)
-        # In case5.m, the gencost has type 2 cost model, with 2 parameters.
-        np.testing.assert_array_equal(system5.GCost.c2.v,
-                                      np.zeros(system5.StaticGen.n))
-
-        # Check if Area is added
-        self.assertGreater(system5.Area.n, 0)
-
-        # Check if Zone is added
-        self.assertGreater(system5.Zone.n, 0)
-
-        system14 = ams.system.System()
-        # Test gentype length check
-        mpc14 = self.mpc14.copy()
-        mpc14['gentype'] = np.array(['WT'] * 6)
-        with self.assertRaises(ValueError, msg='gentype length check failed!'):
-            ams.io.matpower.mpc2system(mpc14, system14)
-
-        system14 = ams.system.System()
-        ams.io.matpower.mpc2system(self.mpc14, system14)
-        # In case14.m, the gencost has type 2 cost model, with 3 parameters.
-        np.testing.assert_array_less(np.zeros(system14.StaticGen.n),
-                                     system14.GCost.c2.v,)
-
-    def test_system2mpc(self):
-        """Test conversion from AMS System to MPC."""
-        system5 = ams.system.System()
-        ams.io.matpower.mpc2system(self.mpc5, system5)
-        mpc5 = ams.io.matpower.system2mpc(system5)
-
-        self.assertEqual(mpc5['baseMVA'], self.mpc5['baseMVA'])
-
-        # Bus
-        # type, PD, QD, GS,BS, VM, VA. BASE_KV, VMAX, VMIN
-        bus_cols = [1, 2, 3, 4, 5, 7, 8, 9, 11, 12]
-        np.testing.assert_array_equal(mpc5['bus'][:, bus_cols],
-                                      self.mpc5['bus'][:, bus_cols])
-
-        # Branch, Gen, Gencost, can have minor differences but is okay
-
-        # String type data
-        np.testing.assert_array_equal(mpc5['gentype'], self.mpc5['gentype'])
-        np.testing.assert_array_equal(mpc5['genfuel'], self.mpc5['genfuel'])
-        np.testing.assert_array_equal(mpc5['bus_name'], self.mpc5['bus_name'])
-
-        # Area quantity
-        self.assertEqual(np.unique(mpc5['bus'][:, 6]).shape[0],
-                         np.unique(self.mpc5['bus'][:, 6]).shape[0])
-
-        # Zone quantity
-        self.assertEqual(np.unique(mpc5['bus'][:, 10]).shape[0],
-                         np.unique(self.mpc5['bus'][:, 10]).shape[0])
-
-    def test_gencost1(self):
-        """Test when gencost is type 1."""
-        mpcgc1 = self.mpc14.copy()
-        mpcgc1['gencost'] = np.repeat(np.array([[1, 0, 0, 3, 0.01, 40, 0]]), 5, axis=0)
-
-        system = ams.system.System()
-        ams.io.matpower.mpc2system(mpcgc1, system)
-        self.assertEqual(system.GCost.n, 5)
-
-    def test_mpc2m(self):
-        """Test conversion from MPC to M file."""
-        mpc5 = ams.io.matpower.m2mpc(ams.get_case('matpower/case5.m'))
-        mpc14 = ams.io.matpower.m2mpc(ams.get_case('matpower/case14.m'))
-
-        # Test conversion to M file
-        mfile5 = ams.io.matpower.mpc2m(mpc5, './case5out.m')
-        mfile14 = ams.io.matpower.mpc2m(mpc14, './case14out.m')
-
-        # Check if the files exist
-        self.assertTrue(os.path.exists(mfile5))
-        self.assertTrue(os.path.exists(mfile14))
-
-        mpc5read = ams.io.matpower.m2mpc(mfile5)
-        mpc14read = ams.io.matpower.m2mpc(mfile14)
-
-        # Check if the numerical values are the same
-        for key in mpc5:
-            if key in ['bus_name', 'gentype', 'genfuel']:
-                continue
-            np.testing.assert_array_almost_equal(
-                mpc5[key], mpc5read[key], decimal=5,
-                err_msg=f"Mismatch in {key} when converting case5.m"
-            )
-        for key in mpc14:
-            if key in ['bus_name', 'gentype', 'genfuel']:
-                continue
-            np.testing.assert_array_almost_equal(
-                mpc14[key], mpc14read[key], decimal=5,
-                err_msg=f"Mismatch in {key} when converting case14.m"
-            )
-
-        # Clean up the generated files
-        os.remove(mfile5)
-        os.remove(mfile14)
-
-    def test_system2m(self):
-        """Test conversion from AMS System to M file."""
-        s5 = ams.load(ams.get_case('matpower/case5.m'),
-                      no_output=True)
-        mfile5 = './case5out.m'
-        ams.io.matpower.write(s5, mfile5)
-
-        # Clean up the generated file
-        os.remove(mfile5)
-
-
-class TestSystemExport(unittest.TestCase):
-    """
-    Test system export functions.
-    """
-
-    def test_system_to(self):
-        """Test conversion from AMS System to several formats."""
-        ss = ams.load(ams.get_case('matpower/case5.m'),
-                      no_output=True)
-
-        mpc = ss.to_mpc()
-
-        self.assertIsInstance(mpc, dict)
-        self.assertIn('bus', mpc)
-        self.assertIn('branch', mpc)
-        self.assertIn('gen', mpc)
-        self.assertIn('gencost', mpc)
-        self.assertIn('baseMVA', mpc)
-        self.assertIn('bus_name', mpc)
-        self.assertIn('gentype', mpc)
-        self.assertIn('genfuel', mpc)
-
-        ss.to_m("./case5_out.m")
-        self.assertTrue(os.path.exists("./case5_out.m"))
-        os.remove("./case5_out.m")
-
-        ss.to_json("./case5_out.json")
-        self.assertTrue(os.path.exists("./case5_out.json"))
-        os.remove("./case5_out.json")
-
-        ss.to_xlsx("./case5_out.xlsx")
-        self.assertTrue(os.path.exists("./case5_out.xlsx"))
-        os.remove("./case5_out.xlsx")
-
-        ss.to_raw("./case5_out.raw", overwrite=True)
-        self.assertTrue(os.path.exists("./case5_out.raw"))
-        os.remove("./case5_out.raw")

tests/test_jumper.py

@@ -1,27 +0,0 @@
-"""
-Test `Jumper` class.
-"""
-
-import unittest
-
-import ams
-
-
-class TessJumper(unittest.TestCase):
-    """
-    Test `Jumper` class.
-    """
-
-    def setUp(self) -> None:
-        """
-        Test setup.
-        """
-        self.sp = ams.load(ams.get_case("5bus/pjm5bus_jumper.xlsx"),
-                           setup=True, no_output=True, default_config=True)
-
-    def test_to_andes(self):
-        """
-        Test `to_andes` method when `Jumper` exists.
-        """
-        sa = self.sp.to_andes()
-        self.assertEqual(sa.Jumper.n, 1)