ltbams 1.0.8__py3-none-any.whl → 1.0.10__py3-none-any.whl

ams/core/__init__.py

@@ -1,2 +1,3 @@
 from ams.core.model import Model  # NOQA
 from ams.core.var import Algeb  # NOQA
+from ams.core.common import Config  # NOQA

ams/core/common.py

@@ -0,0 +1,30 @@
+import logging
+
+from andes.core.common import Config as AndesConfig
+
+logger = logging.getLogger(__name__)
+
+
+class Config(AndesConfig):
+    """
+    A class for storing configuration, can be used in system,
+    model, routine, and other modules.
+
+    Revised from `andes.core.common.Config`.
+    """
+
+    def __init__(self, name, dct=None, **kwargs):
+        super().__init__(name, dct, **kwargs)
+
+    def update(self, dct: dict = None, **kwargs):
+        """
+        Update the configuration from a file.
+        """
+        if dct is not None:
+            kwargs.update(dct)
+
+        for key, val in kwargs.items():
+            self._set(key, val)
+            self._dict[key] = val
+
+        self.check()

ams/core/model.py

@@ -7,13 +7,13 @@ from collections import OrderedDict
 from typing import Iterable
 
 import numpy as np
-from andes.core.common import Config
 from andes.core.param import ExtParam
 from andes.core.service import BaseService, BackRef
 from andes.utils.func import list_flatten
 
 from ams.core.documenter import Documenter
 from ams.core.var import Algeb
+from ams.core.common import Config
 
 from ams.utils.misc import deprec_get_idx
 

ams/core/symprocessor.py

@@ -174,7 +174,7 @@ class SymProcessor:
         # Constraints
         # NOTE: constraints are included in sub_map for ExpressionCalc
         # thus, they don't have the suffix `.v`
-        for cname, constraint in self.parent.constrs.items():
+        for cname, _ in self.parent.constrs.items():
             self.sub_map[rf"\b{cname}\b"] = f'self.rtn.{cname}.optz'
 
         # store tex names defined in `self.config`

ams/extension/eva.py

@@ -17,7 +17,6 @@ from collections import OrderedDict
 
 import scipy.stats as stats
 
-from andes.core import Config
 from andes.core.param import NumParam
 from andes.core.model import ModelData
 from andes.shared import np, pd
@@ -25,6 +24,7 @@ from andes.utils.misc import elapsed
 
 from ams.core.model import Model
 from ams.utils.paths import ams_root
+from ams.core import Config
 
 logger = logging.getLogger(__name__)
 

ams/interface.py

@@ -3,6 +3,7 @@ Module for interfacing ANDES
 """
 
 import os
+import json
 import logging
 from collections import OrderedDict, Counter
 
@@ -81,7 +82,8 @@ def sync_adsys(amsys, adsys):
             try:
                 ad_mdl.set(src=param, attr='v', idx=idx,
                            value=am_mdl.get(src=param, attr='v', idx=idx))
-            except Exception:
+            except Exception as e:
+                logger.warning(f"Failed to sync parameter '{param}' for model '{mname}': {e}")
                 continue
     return True
 
@@ -242,24 +244,43 @@ def parse_addfile(adsys, amsys, addfile):
             logger.debug('Addfile format guessed as %s.', key)
             break
 
-    if key != 'xlsx':
-        logger.error('Addfile format "%s" is not supported yet.', add_format)
-        # FIXME: xlsx input file with dyr addfile result into KeyError: 'Toggle'
-        # add_parser = importlib.import_module('andes.io.' + add_format)
-        # if not add_parser.read_add(system, addfile):
-        #     logger.error('Error parsing addfile "%s" with %s parser.', addfile, add_format)
-        return adsys
+    # FIXME: xlsx input file with dyr addfile result into KeyError: 'Toggle'
+    # add_parser = importlib.import_module('andes.io.' + add_format)
+    # if not add_parser.read_add(system, addfile):
+    #     logger.error('Error parsing addfile "%s" with %s parser.', addfile, add_format)
 
     # Try parsing the addfile
     logger.info('Parsing additional file "%s"...', addfile)
 
-    reader = pd.ExcelFile(addfile)
+    if add_format == 'xlsx':
+        reads = pd.read_excel(addfile,
+                              sheet_name=None,
+                              index_col=0,
+                              engine='openpyxl',
+                              )
+    elif add_format == 'json':
+        if isinstance(addfile, str):
+            f = open(addfile, 'r')
+        else:
+            f = addfile
+
+        json_in = json.load(f)
+
+        if f is not addfile:
+            f.close()
+
+        reads = dict()
+        for keys, dct in json_in.items():
+            reads[keys] = pd.DataFrame(dct)
+    else:
+        logger.error("Unsupported addfile format, only 'xlsx' and 'json' formats are supported.")
+        return adsys
 
     pflow_mdl = list(pflow_dict.keys())
 
     pflow_mdls_overlap = []
     for mdl_name in pflow_dict.keys():
-        if mdl_name in reader.sheet_names:
+        if mdl_name in reads.keys():
             pflow_mdls_overlap.append(mdl_name)
 
     if len(pflow_mdls_overlap) > 0:
@@ -269,14 +290,10 @@ def parse_addfile(adsys, amsys, addfile):
 
     pflow_mdl_nonempty = [mdl for mdl in pflow_mdl if amsys.models[mdl].n > 0]
     logger.debug(f"Non-empty PFlow models: {pflow_mdl}")
-    pflow_df_models = pd.read_excel(addfile,
-                                    sheet_name=pflow_mdl_nonempty,
-                                    index_col=0,
-                                    engine='openpyxl',
-                                    )
-    # drop rows that all nan
-    for name, df in pflow_df_models.items():
-        df.dropna(axis=0, how='all', inplace=True)
+    pflow_df_models = {}
+    for key, df in reads.items():
+        if key in pflow_mdl_nonempty:
+            pflow_df_models[key] = df.dropna(axis=0, how='all', inplace=False)
 
     # collect idx_map if difference exists
     idx_map = OrderedDict([])
@@ -290,13 +307,12 @@ def parse_addfile(adsys, amsys, addfile):
             idx_map[name] = dict(zip(ad_idx, am_idx))
 
     # --- dynamic models to be added ---
-    mdl_to_keep = list(set(reader.sheet_names) - set(pflow_mdl))
+    mdl_to_keep = list(set(reads.keys()) - set(pflow_mdl))
     mdl_to_keep.sort(key=str.lower)
-    df_models = pd.read_excel(addfile,
-                              sheet_name=mdl_to_keep,
-                              index_col=0,
-                              engine='openpyxl',
-                              )
+    df_models = {}
+    for key, df in reads.items():
+        if key in mdl_to_keep:
+            df_models[key] = df.dropna(axis=0, how='all', inplace=False)
 
     # adjust models index
     for name, df in df_models.items():

ams/io/matpower.py

@@ -6,8 +6,12 @@ import re
 import numpy as np
 
 from andes.io import read_file_like
+from andes.io.xlsx import confirm_overwrite
 from andes.shared import deg2rad, rad2deg
 
+from ams import __version__ as version
+from ams.shared import copyright_msg, nowarranty_msg, report_time
+
 logger = logging.getLogger(__name__)
 
 
@@ -184,6 +188,9 @@ def mpc2system(mpc: dict, system) -> bool:
     Note that `mbase` in mpc is converted to `Sn`, but it is not actually used in
     MATPOWER nor AMS.
 
+    In converted AMS system, StaticGen idxes are 1-based, while the sequence follow
+    the order of the original MATPOWER data.
+
     Parameters
     ----------
     system : ams.system.System
@@ -396,14 +403,29 @@ def mpc2system(mpc: dict, system) -> bool:
                        c2=c2, c1=c1, c0=c0
                        )
 
+    # --- Area ---
+    area = system.Bus.area.v
+    area_map = {}
+    if area:
+        for a in set(area):
+            a_new = system.add('Area',
+                               param_dict=dict(idx=a, name=a))
+            area_map[a] = a_new
+        system.Bus.area.v = [area_map[a] for a in area]
+
     # --- Zone ---
-    zone_id = np.unique(system.Bus.zone.v).astype(int)
-    for zone in zone_id:
-        zone_idx = f'ZONE_{zone}'
-        system.add('Zone', idx=zone_idx, name=None)
-    bus_zone = system.Bus.zone.v
-    bus_zone = [f'ZONE_{int(zone)}' for zone in bus_zone]
-    system.Bus.zone.v = bus_zone
+    zone = system.Bus.zone.v
+    zone_map = {}
+    if zone:
+        n_zone = system.Area.n
+        for z in set(zone):
+            z_new = system.add('Zone',
+                               param_dict=dict(idx=int(n_zone + 1),
+                                               name=f'{n_zone + 1}'))
+            zone_map[z] = z_new
+            n_zone += 1
+        system.Bus.zone.v = [zone_map[z] for z in zone]
+
     return True
 
 
@@ -429,25 +451,29 @@ def _get_bus_id_caller(bus):
 
 def system2mpc(system) -> dict:
     """
-    Convert data from an AMS system to an mpc dict.
+    Convert a **setup** AMS system to a MATPOWER mpc dictionary.
+
+    This function is revised from ``andes.io.matpower.system2mpc``.
 
-    In the ``gen`` section, slack generators preceeds PV generators.
+    In the ``gen`` section, slack generators are listed before PV generators.
 
-    Compared to the ``andes.io.matpower.system2mpc``,
-    this function includes the generator cost data in the ``gencost``
-    section.
-    Additionally, ``c2`` and ``c1`` are scaled by ``base_mva`` to match
-    MATPOWER unit ``MW``.
+    In the converted MPC, the indices of area (bus[:, 6]) and zone (bus[:, 10])
+    may differ from the original MPC. However, the mapping relationship is preserved.
+    For example, if the original MPC numbers areas starting from 1, the converted
+    MPC may number them starting from 0.
+
+    The coefficients ``c2`` and ``c1`` in the generator cost data are scaled by
+    ``base_mva`` to match MATPOWER's unit convention (MW).
 
     Parameters
     ----------
     system : ams.core.system.System
-        AMS system
+        The AMS system to be converted.
 
     Returns
     -------
-    mpc: dict
-        MATPOWER mpc dict
+    mpc : dict
+        A dictionary in MATPOWER format representing the converted AMS system.
     """
 
     mpc = dict(version='2',
@@ -458,12 +484,16 @@ def system2mpc(system) -> dict:
                gencost=np.zeros((system.GCost.n, 7), dtype=np.float64),
                )
 
+    if not system.is_setup:
+        logger.warning("System is not setup and will be setup now.")
+        system.setup()
+
     if system.Bus.name.v is not None:
         mpc['bus_name'] = system.Bus.name.v
 
     base_mva = system.config.mva
 
-    # --- bus ---
+    # --- Bus ---
     bus = mpc['bus']
     gen = mpc['gen']
 
@@ -471,23 +501,22 @@ def system2mpc(system) -> dict:
 
     bus[:, 0] = to_busid(system.Bus.idx.v)
     bus[:, 1] = 1
+    if system.Area.n > 0:
+        bus[:, 6] = system.Area.idx2uid(system.Bus.area.v)
     bus[:, 7] = system.Bus.v0.v
     bus[:, 8] = system.Bus.a0.v * rad2deg
     bus[:, 9] = system.Bus.Vn.v
+    if system.Zone.n > 0:
+        bus[:, 10] = system.Zone.idx2uid(system.Bus.zone.v)
     bus[:, 11] = system.Bus.vmax.v
     bus[:, 12] = system.Bus.vmin.v
 
-    # --- zone ---
-    ZONE_I = system.Zone.idx.v
-    if len(ZONE_I) > 0:
-        mapping = {busi0: i for i, busi0 in enumerate(ZONE_I)}
-        bus[:, 10] = np.array([mapping[busi0] for busi0 in system.Bus.zone.v])
-
     # --- PQ ---
     if system.PQ.n > 0:
         pq_pos = system.Bus.idx2uid(system.PQ.bus.v)
-        bus[pq_pos, 2] = system.PQ.p0.v * base_mva
-        bus[pq_pos, 3] = system.PQ.q0.v * base_mva
+        u = system.PQ.u.v
+        bus[pq_pos, 2] = u * system.PQ.p0.v * base_mva
+        bus[pq_pos, 3] = u * system.PQ.q0.v * base_mva
 
     # --- Shunt ---
     if system.Shunt.n > 0:
@@ -568,4 +597,141 @@ def system2mpc(system) -> dict:
     else:
         mpc.pop('gencost')
 
+    # --- gentype ---
+    stg = system.StaticGen.get_all_idxes()
+    gentype = system.StaticGen.get(src='gentype', attr='v', idx=stg)
+    if any(gentype):
+        mpc['gentype'] = np.array(gentype)
+
+    # --- genfuel ---
+    genfuel = system.StaticGen.get(src='genfuel', attr='v', idx=stg)
+    if any(genfuel):
+        mpc['genfuel'] = np.array(genfuel)
+
+    # --- Bus Name ---
+    if any(system.Bus.name.v):
+        mpc['bus_name'] = np.array(system.Bus.name.v)
+
     return mpc
+
+
+def mpc2m(mpc: dict, outfile: str) -> str:
+    """
+    Write a MATPOWER mpc dict to a M-file.
+
+    Parameters
+    ----------
+    mpc : dict
+        MATPOWER mpc dictionary.
+    outfile : str
+        Path to the output M-file.
+    """
+    with open(outfile, 'w') as f:
+        # Add version info
+        f.write(f"%% Converted by AMS {version}\n")
+        f.write(f"%% {copyright_msg}\n\n")
+        f.write(f"%% {nowarranty_msg}\n")
+        f.write(f"%% Convert time: {report_time}\n\n")
+
+        f.write("function mpc = mpc_case\n")
+        f.write("mpc.version = '2';\n\n")
+
+        # Write baseMVA
+        f.write(f"%% system MVA base\nmpc.baseMVA = {mpc['baseMVA']};\n\n")
+
+        # Write bus data
+        f.write("%% bus data\n")
+        f.write("%% bus_i type Pd Qd Gs Bs area Vm Va baseKV zone Vmax Vmin\n")
+        f.write("mpc.bus = [\n")
+        for row in mpc['bus']:
+            f.write("    " + "\t".join(f"{val:.6g}" for val in row) + ";\n")
+        f.write("];\n\n")
+
+        # Write generator data
+        f.write("%% generator data\n")
+        f.write("%% bus Pg Qg Qmax Qmin Vg mBase status Pmax Pmin\n")
+        f.write("%% Pc1 Pc2 Qc1min Qc1max Qc2min Qc2max ramp_agc ramp_10 ramp_30 ramp_q apf\n")
+        f.write("mpc.gen = [\n")
+        for row in mpc['gen']:
+            f.write("    " + "\t".join(f"{val:.6g}" for val in row) + ";\n")
+        f.write("];\n\n")
+
+        # Write branch data
+        f.write("%% branch data\n")
+        f.write("%% fbus tbus r x b rateA rateB rateC ratio angle status angmin angmax PF QF PT QT\n")
+        f.write("mpc.branch = [\n")
+        for row in mpc['branch']:
+            f.write("    " + "\t".join(f"{val:.6g}" for val in row) + ";\n")
+        f.write("];\n\n")
+
+        # Write generator cost data if available
+        if 'gencost' in mpc:
+            f.write("%% generator cost data\n")
+            f.write("%% 1 startup shutdown n x1 y1 ... xn yn\n")
+            f.write("%% 2 startup shutdown n c(n-1) ... c0\n")
+            f.write("mpc.gencost = [\n")
+            for row in mpc['gencost']:
+                f.write("    " + "\t".join(f"{val:.6g}" for val in row) + ";\n")
+            f.write("];\n\n")
+
+        # Write bus names if available and not all None
+        if 'bus_name' in mpc and any(mpc['bus_name']):
+            f.write("%% bus names\n")
+            f.write("mpc.bus_name = {\n")
+            for name in mpc['bus_name']:
+                f.write(f"    '{name}';\n")
+            f.write("};\n\n")
+
+        # Write generator types if available and not all None
+        if 'gentype' in mpc and any(mpc['gentype']):
+            f.write("%% generator types\n")
+            f.write("mpc.gentype = {\n")
+            for gentype in mpc['gentype']:
+                f.write(f"    '{gentype}';\n")
+            f.write("};\n\n")
+
+        # Write generator fuels if available and not all None
+        if 'genfuel' in mpc and any(mpc['genfuel']):
+            f.write("%% generator fuels\n")
+            f.write("mpc.genfuel = {\n")
+            for genfuel in mpc['genfuel']:
+                f.write(f"    '{genfuel}';\n")
+            f.write("};\n\n")
+
+    logger.info(f"Finished writing MATPOWER case to {outfile}")
+    return outfile
+
+
+def write(system, outfile: str, overwrite: bool = None) -> bool:
+    """
+    Export an AMS system to a MATPOWER M-file.
+
+    This function converts an AMS system object into a MATPOWER-compatible
+    mpc dictionary and writes it to a specified output file in MATPOWER format.
+
+    In the converted MPC, the indices of area (bus[:, 6]) and zone (bus[:, 10])
+    may differ from the original MPC. However, the mapping relationship is preserved.
+    For example, if the original MPC numbers areas starting from 1, the converted
+    MPC may number them starting from 0.
+
+    Parameters
+    ----------
+    system : ams.system.System
+        A loaded system.
+    outfile : str
+        Path to the output file.
+    overwrite : bool, optional
+        None to prompt for overwrite selection; True to overwrite; False to not overwrite.
+
+    Returns
+    -------
+    bool
+        True if the file was successfully written, False otherwise.
+    """
+    if not confirm_overwrite(outfile, overwrite=overwrite):
+        return False
+
+    mpc = system2mpc(system)
+    mpc2m(mpc, outfile)
+    logger.info('MATPOWER m case file written to "%s"', outfile)
+    return True