ltbams 0.9.12__tar.gz → 0.9.13__tar.gz

{ltbams-0.9.12/ltbams.egg-info → ltbams-0.9.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ltbams
-Version: 0.9.12
+Version: 0.9.13
 Summary: Python software for scheduling modeling and co-simulation with dynanics.
 Home-page: https://github.com/CURENT/ams
 Author: Jinning Wang
@@ -35,11 +35,12 @@ License-File: LICENSE
 
 # LTB AMS
 
-Python Software for Power System Scheduling Modeling and Co-Simulation with Dynanic, serving as the market simulator for the [CURENT Largescale Testbed][LTB Repository].
+Python Software for Power System Scheduling Modeling and Co-Simulation with Dynamics, serving as the market simulator for the [CURENT Largescale Testbed][LTB Repository].
 
 [![License: GPL-3.0](https://img.shields.io/badge/License-GPL--3.0-blue.svg)](https://github.com/CURENT/ams/blob/master/LICENSE)
 ![platforms](https://anaconda.org/conda-forge/ltbams/badges/platforms.svg)
 [![Python Versions](https://img.shields.io/badge/Python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)](https://www.python.org/)
+[![Project Status: Active – The project has reached a stable, usable state and is being actively developed.](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active)
 ![Repo Size](https://img.shields.io/github/repo-size/CURENT/ams)
 [![GitHub last commit (master)](https://img.shields.io/github/last-commit/CURENT/ams/master?label=last%20commit%20to%20master)](https://github.com/CURENT/ams/commits/master/)
 [![GitHub last commit (develop)](https://img.shields.io/github/last-commit/CURENT/ams/develop?label=last%20commit%20to%20develop)](https://github.com/CURENT/ams/commits/develop/)
@@ -66,6 +67,10 @@ Python Software for Power System Scheduling Modeling and Co-Simulation with Dyna
 With the built-in interface with ANDES, AMS enables **Dynamics Incorporated**
 **Stability-Constrained Scheduling**.
 
+This package can be helpful for power system engineers, researchers, and students
+who need to conduct scheduling studies and transient stability studies at given
+operating points.
+
 AMS is a **Modeling Framework** that provides a descriptive way to formulate
 scheduling problems. The optimization problems are then handled by **CVXPY**
 and solved with third-party solvers.
@@ -102,6 +107,7 @@ Use the following resources to get involved.
 - Version **0.9.9** has known issues and has been yanked from PyPI
 - `kvxopt` is recommended to install via `conda` as sometimes ``pip`` struggles to set the correct path for compiled libraries
 - `cvxpy` versions **below 1.5** are incompatible with `numpy` versions **2.0 and above**
+- If solver `SCIP` run into import error, try to reinstall its Python interface by running `pip install pyscipopt --no-binary scip --force`
 
 AMS is released as ``ltbams`` on PyPI and conda-forge.
 Install from PyPI using pip:
@@ -124,15 +130,23 @@ pip install git+https://github.com/CURENT/ams.git
 
 # Example Usage
 
-Using AMS to run a Real-Time Economic Dispatch (RTED) simulation:
-
 ```python
 import ams
+import andes
+
+ss = ams.load(ams.get_case('ieee14/ieee14_uced.xlsx'))
+
+# solve RTED
+ss.RTED.run(solver='CLARABEL')
 
-ss = ams.load(ams.get_case('ieee14_uced.xlsx'))
-ss.RTED.run()
+ss.RTED.pg.v
+>>> array([1.8743862, 0.3226138, 0.01     , 0.02     , 0.01     ])
 
-print(ss.RTED.pg.v)
+# convert to ANDES case
+sa = ss.to_andes(addfile=andes.get_case('ieee14/ieee14_full.xlsx'),
+                 setup=True, verify=False)
+sa
+>>> <andes.system.System at 0x14bd98190>
 ```
 
 # Sponsors and Contributors

{ltbams-0.9.12 → ltbams-0.9.13}/README.md

@@ -1,10 +1,11 @@
 # LTB AMS
 
-Python Software for Power System Scheduling Modeling and Co-Simulation with Dynanic, serving as the market simulator for the [CURENT Largescale Testbed][LTB Repository].
+Python Software for Power System Scheduling Modeling and Co-Simulation with Dynamics, serving as the market simulator for the [CURENT Largescale Testbed][LTB Repository].
 
 [![License: GPL-3.0](https://img.shields.io/badge/License-GPL--3.0-blue.svg)](https://github.com/CURENT/ams/blob/master/LICENSE)
 ![platforms](https://anaconda.org/conda-forge/ltbams/badges/platforms.svg)
 [![Python Versions](https://img.shields.io/badge/Python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)](https://www.python.org/)
+[![Project Status: Active – The project has reached a stable, usable state and is being actively developed.](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active)
 ![Repo Size](https://img.shields.io/github/repo-size/CURENT/ams)
 [![GitHub last commit (master)](https://img.shields.io/github/last-commit/CURENT/ams/master?label=last%20commit%20to%20master)](https://github.com/CURENT/ams/commits/master/)
 [![GitHub last commit (develop)](https://img.shields.io/github/last-commit/CURENT/ams/develop?label=last%20commit%20to%20develop)](https://github.com/CURENT/ams/commits/develop/)
@@ -31,6 +32,10 @@ Python Software for Power System Scheduling Modeling and Co-Simulation with Dyna
 With the built-in interface with ANDES, AMS enables **Dynamics Incorporated**
 **Stability-Constrained Scheduling**.
 
+This package can be helpful for power system engineers, researchers, and students
+who need to conduct scheduling studies and transient stability studies at given
+operating points.
+
 AMS is a **Modeling Framework** that provides a descriptive way to formulate
 scheduling problems. The optimization problems are then handled by **CVXPY**
 and solved with third-party solvers.
@@ -67,6 +72,7 @@ Use the following resources to get involved.
 - Version **0.9.9** has known issues and has been yanked from PyPI
 - `kvxopt` is recommended to install via `conda` as sometimes ``pip`` struggles to set the correct path for compiled libraries
 - `cvxpy` versions **below 1.5** are incompatible with `numpy` versions **2.0 and above**
+- If solver `SCIP` run into import error, try to reinstall its Python interface by running `pip install pyscipopt --no-binary scip --force`
 
 AMS is released as ``ltbams`` on PyPI and conda-forge.
 Install from PyPI using pip:
@@ -89,15 +95,23 @@ pip install git+https://github.com/CURENT/ams.git
 
 # Example Usage
 
-Using AMS to run a Real-Time Economic Dispatch (RTED) simulation:
-
 ```python
 import ams
+import andes
+
+ss = ams.load(ams.get_case('ieee14/ieee14_uced.xlsx'))
+
+# solve RTED
+ss.RTED.run(solver='CLARABEL')
 
-ss = ams.load(ams.get_case('ieee14_uced.xlsx'))
-ss.RTED.run()
+ss.RTED.pg.v
+>>> array([1.8743862, 0.3226138, 0.01     , 0.02     , 0.01     ])
 
-print(ss.RTED.pg.v)
+# convert to ANDES case
+sa = ss.to_andes(addfile=andes.get_case('ieee14/ieee14_full.xlsx'),
+                 setup=True, verify=False)
+sa
+>>> <andes.system.System at 0x14bd98190>
 ```
 
 # Sponsors and Contributors

{ltbams-0.9.12 → ltbams-0.9.13}/ams/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-11-23T17:09:40-0500",
+ "date": "2024-12-05T16:49:45-0500",
  "dirty": false,
  "error": null,
- "full-revisionid": "377b36f113e1e88f8c2d21d3c6ab8ff3728cffb0",
- "version": "0.9.12"
+ "full-revisionid": "db9279e8765429827062032b803c756025c018b2",
+ "version": "0.9.13"
 }
 '''  # END VERSION_JSON
 

{ltbams-0.9.12 → ltbams-0.9.13}/ams/interface.py

@@ -78,7 +78,6 @@ def sync_adsys(amsys, adsys):
                 ad_mdl.set(src=param, attr='v', idx=idx,
                            value=am_mdl.get(src=param, attr='v', idx=idx))
             except Exception:
-                logger.debug(f"Skip updating {mname}.{param}")
                 continue
     return True
 
@@ -333,6 +332,27 @@ def parse_addfile(adsys, amsys, addfile):
                 df[idxn] = df[idxn].replace(idx_map[mdl_guess])
                 logger.debug(f'Adjust {idxp.class_name} <{name}.{idxp.name}>')
 
+    # NOTE: Group TimedEvent needs special treatment
+    # adjust Toggle and Fault models
+    toggle_df = df_models.get('Toggle') or df_models.get('Toggler')
+    if toggle_df is not None:
+        toggle_df['dev'] = toggle_df.apply(replace_dev, axis=1,
+                                           mdl='model', dev='dev',
+                                           idx_map=idx_map)
+
+    alter_df = df_models.get('Alter')
+    if alter_df is not None:
+        alter_df['dev'] = alter_df.apply(replace_dev, axis=1,
+                                         mdl='model', dev='dev',
+                                         idx_map=idx_map)
+
+    # adjust Fault model
+    fault_df = df_models.get('Fault')
+    if fault_df is not None:
+        fault_df['bus'] = fault_df.apply(replace_dev, axis=1,
+                                         mdl='bus', dev='bus',
+                                         idx_map=idx_map)
+
     # add dynamic models
     for name, df in df_models.items():
         # drop rows that all nan
@@ -966,7 +986,7 @@ def make_link_table(adsys):
                         right=ssa_rg[['stg_idx', 'rg_idx']])
 
     # NOTE: use this instead of fillna to avoid type conversion
-    idxc = ['stg_idx', 'syg_idx', 'dg_idx', 'rg_idx']
+    idxc = ['syg_idx', 'dg_idx', 'rg_idx']
     ssa_key0[idxc] = ssa_key0[idxc].astype('str').replace({'nan': ''}).astype('bool')
 
     dyr = ssa_key0['syg_idx'] + ssa_key0['dg_idx'] + ssa_key0['rg_idx']
@@ -1037,3 +1057,27 @@ def verify_pf(amsys, adsys, tol=1e-3):
         logger.warning(msg)
         logger.warning(diff_msg)
     return check
+
+
+def replace_dev(row, mdl, dev, idx_map):
+    """
+    Replace the device idx in the row based on the idx_map.
+
+    Parameters
+    ----------
+    row : pd.Series
+        The row of the DataFrame.
+    mdl : str
+        The column name for the Model.
+    dev : str
+        The column name for the Device idx.
+    idx_map : dict
+        The index map for replacement.
+
+    Returns
+    -------
+    str
+        The new device idx.
+    """
+    old_idx = row[dev]
+    return idx_map.get(row[mdl], {}).get(old_idx, old_idx)

ltbams-0.9.13/ams/report.py

@@ -0,0 +1,356 @@
+"""
+Module for report generation.
+"""
+import logging
+from collections import OrderedDict
+from time import strftime
+from typing import List, Dict, Optional
+
+from andes.io.txt import dump_data
+from andes.shared import np
+from andes.utils.misc import elapsed
+
+from ams import __version__ as version
+from ams.shared import copyright_msg
+
+logger = logging.getLogger(__name__)
+
+
+DECIMALS = 6
+
+
+def report_info(system) -> list:
+    info = list()
+    info.append('AMS' + ' ' + version + '\n')
+    info.append(f'{copyright_msg}\n\n')
+    info.append('AMS comes with ABSOLUTELY NO WARRANTY\n')
+    info.append('Case file: ' + str(system.files.case) + '\n')
+    info.append('Report time: ' + strftime("%m/%d/%Y %I:%M:%S %p") + '\n\n')
+    return info
+
+
+class Report:
+    """
+    Report class to store routine analysis reports.
+
+    Notes
+    -----
+    Revised from the ANDES project (https://github.com/CURENT/andes).
+    Original author: Hantao Cui
+    License: GPL3
+    """
+
+    def __init__(self, system):
+        self.system = system
+        self.basic = OrderedDict()
+
+    @property
+    def info(self):
+        return report_info(self.system)
+
+    def update(self):
+        """
+        Update values based on the requested content
+        """
+        system = self.system
+        self.basic.update({
+            'Buses': system.Bus.n,
+            'Generators': system.PV.n + system.Slack.n,
+            'Loads': system.PQ.n,
+            'Shunts': system.Shunt.n,
+            'Lines': system.Line.n,
+            'Transformers': np.count_nonzero(system.Line.trans.v == 1),
+            'Areas': system.Area.n,
+            'Regions': system.Region.n,
+        })
+
+    def collect(self, rtn, horizon=None):
+        """
+        Collect report data.
+
+        Parameters
+        ----------
+        rtn : Routine
+            Routine object to collect data from.
+        horizon : str, optional
+            Timeslot to collect data from. Only single timeslot is supported.
+        """
+        text = list()
+        header = list()
+        row_name = list()
+        data = list()
+
+        if not rtn.converged:
+            return text, header, row_name, data
+
+        owners = collect_owners(rtn)
+        owners = collect_vars(owners, rtn, horizon, DECIMALS)
+        owners = collect_exprs(owners, rtn, horizon, DECIMALS)
+        owners = collect_exprcs(owners, rtn, horizon, DECIMALS)
+
+        dump_collected_data(owners, text, header, row_name, data)
+
+        return text, header, row_name, data
+
+    def write(self):
+        """
+        Write report to file.
+        """
+        system = self.system
+        if system.files.no_output is True:
+            return
+
+        text = list()
+        header = list()
+        row_name = list()
+        data = list()
+        self.update()
+
+        t, _ = elapsed()
+
+        # --- system info section ---
+        text.append(self.info)
+        header.append(None)
+        row_name.append(None)
+        data.append(None)
+
+        # --- system summary section ---
+        text.append(['='*10 + ' System Statistics ' + '='*10 + '\n'])
+        header.append(None)
+        row_name.append(self.basic.keys())
+        data.append(list(self.basic.values()))
+
+        # --- rountine data section ---
+        rtns_to_collect = [rtn for rtn in system.routines.values() if rtn.converged]
+        for rtn in rtns_to_collect:
+            # --- routine summary ---
+            text.append(['='*30 + f' {rtn.class_name} ' + '='*30])
+            header.append(None)
+            row_name.append(None)
+            data.append(None)
+            if hasattr(rtn, 'timeslot'):
+                for slot in rtn.timeslot.v:
+                    # --- timeslot summary ---
+                    text.append(['-'*28 + f' {slot} ' + '-'*28])
+                    header.append(None)
+                    row_name.append(None)
+                    data.append(None)
+                    text_sum, header_sum, row_name_sum, data_sum = self.collect(rtn, horizon=[slot])
+                    # --- timeslot data ---
+                    text.extend(text_sum)
+                    header.extend(header_sum)
+                    row_name.extend(row_name_sum)
+                    data.extend(data_sum)
+            else:
+                # single-period
+                text_sum, header_sum, row_name_sum, data_sum = self.collect(rtn)
+                # --- routine extended ---
+                text.append([''])
+                row_name.append(
+                    ['Generation', 'Load'])
+
+                if hasattr(rtn, 'pd'):
+                    pd = rtn.pd.v.sum().round(DECIMALS)
+                else:
+                    pd = rtn.system.PQ.p0.v.sum().round(DECIMALS)
+                if hasattr(rtn, 'qd'):
+                    qd = rtn.qd.v.sum().round(DECIMALS)
+                else:
+                    qd = rtn.system.PQ.q0.v.sum().round(DECIMALS)
+
+                if not hasattr(rtn, 'qg'):
+                    header.append(['P (p.u.)'])
+                    Pcol = [rtn.pg.v.sum().round(DECIMALS), pd]
+                    data.append([Pcol])
+                else:
+                    header.append(['P (p.u.)', 'Q (p.u.)'])
+                    Pcol = [rtn.pg.v.sum().round(DECIMALS), pd]
+                    Qcol = [rtn.qg.v.sum().round(DECIMALS), qd]
+                    data.append([Pcol, Qcol])
+
+                # --- routine data ---
+                text.extend(text_sum)
+                header.extend(header_sum)
+                row_name.extend(row_name_sum)
+                data.extend(data_sum)
+        dump_data(text, header, row_name, data, system.files.txt)
+
+        _, s = elapsed(t)
+        logger.info(f'Report saved to "{system.files.txt}" in {s}.')
+
+
+def dump_collected_data(owners: dict, text: List, header: List, row_name: List, data: List) -> None:
+    """
+    Dump collected data into the provided lists.
+
+    Parameters
+    ----------
+    owners : dict
+        Dictionary of owners.
+    text : list
+        List to append text data to.
+    header : list
+        List to append header data to.
+    row_name : list
+        List to append row names to.
+    data : list
+        List to append data to.
+    """
+    for key, val in owners.items():
+        text.append([f'{key} DATA:\n'])
+        row_name.append(val['idx'])
+        header.append(val['header'])
+        data.append(val['data'])
+
+
+def collect_exprcs(owners: Dict, rtn, horizon: Optional[str], decimals: int) -> Dict:
+    """
+    Collect expression calculations and populate the data dictionary.
+
+    Parameters
+    ----------
+    owners : dict
+        Dictionary of owners.
+    rtn : Routine
+        Routine object to collect data from.
+    horizon : str, optional
+        Timeslot to collect data from. Only single timeslot is supported.
+    decimals : int
+        Number of decimal places to round the data.
+
+    Returns
+    -------
+    dict
+        Updated dictionary of owners with collected ExpressionCalc data.
+    """
+    for key, exprc in rtn.exprcs.items():
+        if exprc.owner is None:
+            continue
+        owner_name = exprc.owner.class_name
+        idx_v = owners[owner_name]['idx']
+        header_v = key if exprc.unit is None else f'{key} ({exprc.unit})'
+        try:
+            data_v = rtn.get(src=key, attr='v', idx=idx_v, horizon=horizon).round(decimals)
+        except Exception:
+            data_v = [np.nan] * len(idx_v)
+        owners[owner_name]['header'].append(header_v)
+        owners[owner_name]['data'].append(data_v)
+
+    return owners
+
+
+def collect_exprs(owners: Dict, rtn, horizon: Optional[str], decimals: int) -> Dict:
+    """
+    Collect expressions and populate the data dictionary.
+
+    Parameters
+    ----------
+    owners : dict
+        Dictionary of owners.
+    rtn : Routine
+        Routine object to collect data from.
+    horizon : str, optional
+        Timeslot to collect data from. Only single timeslot is supported.
+    decimals : int
+        Number of decimal places to round the data.
+
+    Returns
+    -------
+    dict
+        Updated dictionary of owners with collected Expression data.
+    """
+    for key, expr in rtn.exprs.items():
+        if expr.owner is None:
+            continue
+        owner_name = expr.owner.class_name
+        idx_v = owners[owner_name]['idx']
+        header_v = key if expr.unit is None else f'{key} ({expr.unit})'
+        try:
+            data_v = rtn.get(src=key, attr='v', idx=idx_v, horizon=horizon).round(decimals)
+        except Exception:
+            data_v = [np.nan] * len(idx_v)
+        owners[owner_name]['header'].append(header_v)
+        owners[owner_name]['data'].append(data_v)
+
+    return owners
+
+
+def collect_vars(owners: Dict, rtn, horizon: Optional[str], decimals: int) -> Dict:
+    """
+    Collect variables and populate the data dictionary.
+
+    Parameters
+    ----------
+    owners : dict
+        Dictionary of owners.
+    rtn : Routine
+        Routine object to collect data from.
+    horizon : str, optional
+        Timeslot to collect data from. Only single timeslot is supported.
+    decimals : int
+        Number of decimal places to round the data.
+
+    Returns
+    -------
+    dict
+        Updated dictionary of owners with collected Var data.
+    """
+
+    for key, var in rtn.vars.items():
+        if var.owner is None:
+            continue
+        owner_name = var.owner.class_name
+        idx_v = owners[owner_name]['idx']
+        header_v = key if var.unit is None else f'{key} ({var.unit})'
+        try:
+            data_v = rtn.get(src=key, attr='v', idx=idx_v, horizon=horizon).round(decimals)
+        except Exception:
+            data_v = [np.nan] * len(idx_v)
+        owners[owner_name]['header'].append(header_v)
+        owners[owner_name]['data'].append(data_v)
+
+    return owners
+
+
+def collect_owners(rtn):
+    """
+    Initialize an owners dictionary for data collection.
+
+    Returns
+    -------
+    dict
+        A dictionary of initialized owners.
+    """
+    # initialize data section by model
+    owners_all = ['Bus', 'Line', 'StaticGen',
+                  'PV', 'Slack', 'RenGen',
+                  'DG', 'ESD1', 'PVD1',
+                  'StaticLoad']
+
+    # Filter owners that exist in the system
+    owners_e = list({
+        var.owner.class_name for var in rtn.vars.values() if var.owner is not None
+    }.union(
+        expr.owner.class_name for expr in rtn.exprs.values() if expr.owner is not None
+    ).union(
+        exprc.owner.class_name for exprc in rtn.exprcs.values() if exprc.owner is not None
+    ))
+
+    # Use a dictionary comprehension to create vars_by_owner
+    owners = {
+        name: {'idx': [],
+               'name': [],
+               'header': [],
+               'data': [], }
+        for name in owners_all if name in owners_e and getattr(rtn.system, name).n > 0
+    }
+
+    for key, val in owners.items():
+        owner = getattr(rtn.system, key)
+        idx_v = owner.get_idx()
+        val['idx'] = idx_v
+        val['name'] = owner.get(src='name', attr='v', idx=idx_v)
+        val['header'].append('Name')
+        val['data'].append(val['name'])
+
+    return owners

{ltbams-0.9.12 → ltbams-0.9.13}/ams/routines/acopf.py

@@ -34,14 +34,11 @@ class ACOPF(DCPF0):
         self.type = 'ACED'
 
         self.map1 = OrderedDict()   # ACOPF does not receive
-        self.map2 = OrderedDict([
-            ('Bus', {
-                'vBus': 'v0',
-            }),
-            ('StaticGen', {
-                'pg': 'p0',
-            }),
-        ])
+        self.map2.update({
+            'vBus': ('Bus', 'v0'),
+            'ug': ('StaticGen', 'u'),
+            'pg': ('StaticGen', 'p0'),
+        })
 
         # --- params ---
         self.c2 = RParam(info='Gen cost coefficient 2',

{ltbams-0.9.12 → ltbams-0.9.13}/ams/routines/dcopf.py

@@ -146,6 +146,53 @@ class DCOPF(DCPFBase):
                              info='total cost', unit='$',
                              sense='min', e_str=obj,)
 
+    def dc2ac(self, kloss=1.0, **kwargs):
+        """
+        Convert the RTED results with ACOPF.
+
+        Parameters
+        ----------
+        kloss : float, optional
+            The loss factor for the conversion. Defaults to 1.2.
+        """
+        exec_time = self.exec_time
+        if self.exec_time == 0 or self.exit_code != 0:
+            logger.warning(f'{self.class_name} is not executed successfully, quit conversion.')
+            return False
+
+        # --- ACOPF ---
+        # scale up load
+        pq_idx = self.system.StaticLoad.get_idx()
+        pd0 = self.system.StaticLoad.get(src='p0', attr='v', idx=pq_idx).copy()
+        qd0 = self.system.StaticLoad.get(src='q0', attr='v', idx=pq_idx).copy()
+        self.system.StaticLoad.set(src='p0', idx=pq_idx, attr='v', value=pd0 * kloss)
+        self.system.StaticLoad.set(src='q0', idx=pq_idx, attr='v', value=qd0 * kloss)
+        # run ACOPF
+        ACOPF = self.system.ACOPF
+        ACOPF.run()
+        # scale load back
+        self.system.StaticLoad.set(src='p0', idx=pq_idx, attr='v', value=pd0)
+        self.system.StaticLoad.set(src='q0', idx=pq_idx, attr='v', value=qd0)
+        if not ACOPF.exit_code == 0:
+            logger.warning('<ACOPF> did not converge, conversion failed.')
+            # NOTE: mock results to fit interface with ANDES
+            self.vBus = ACOPF.vBus
+            self.vBus.optz.value = np.ones(self.system.Bus.n)
+            self.aBus.optz.value = np.zeros(self.system.Bus.n)
+            return False
+        self.pg.optz.value = ACOPF.pg.v
+
+        # NOTE: mock results to fit interface with ANDES
+        self.vBus.optz.value = ACOPF.vBus.v
+        self.aBus.optz.value = ACOPF.aBus.v
+        self.exec_time = exec_time
+
+        # --- set status ---
+        self.system.recent = self
+        self.converted = True
+        logger.warning(f'<{self.class_name}> converted to AC.')
+        return True
+
     def run(self, **kwargs):
         """
         Run the routine.

{ltbams-0.9.12 → ltbams-0.9.13}/ams/routines/dcpf.py

@@ -88,6 +88,10 @@ class DCPFBase(RoutineBase):
                       v0=self.pg0)
 
         # --- bus ---
+        self.vBus = Var(info='Bus voltage magnitude, placeholder',
+                        unit='p.u.',
+                        name='vBus', tex_name=r'v_{Bus}',
+                        src='v', model='Bus',)
         self.aBus = Var(info='Bus voltage angle',
                         unit='rad',
                         name='aBus', tex_name=r'\theta_{bus}',

{ltbams-0.9.12 → ltbams-0.9.13}/ams/routines/dcpf0.py

@@ -35,6 +35,11 @@ class DCPF0(RoutineBase):
         self.info = 'DC Power Flow'
         self.type = 'PF'
 
+        self.ug = RParam(info='Gen connection status',
+                         name='ug', tex_name=r'u_{g}',
+                         model='StaticGen', src='u',
+                         no_parse=True)
+
         # --- routine data ---
         self.x = RParam(info="line reactance",
                         name='x', tex_name='x',
@@ -169,6 +174,7 @@ class DCPF0(RoutineBase):
             except Exception as e:
                 logger.error(f"Failed to unpack results from {self.class_name}.\n{e}")
                 return False
+            self.system.report()
             return True
         else:
             msg = f"{self.class_name} failed in "