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

ams/io/psse.py

@@ -3,4 +3,281 @@ PSS/E .raw reader for AMS.
 This module is the existing module in ``andes.io.psse``.
 """
 
-from andes.io.psse import (read, testlines)  # NOQA
+from andes.io.psse import testlines  # NOQA
+from andes.io.psse import read as ad_read
+from andes.io.xlsx import confirm_overwrite
+from andes.shared import rad2deg, pd
+
+from ams import __version__ as version
+from ams.shared import copyright_msg, nowarranty_msg, report_time
+
+
+def read(system, file):
+    """
+    Read PSS/E RAW file v32/v33 formats.
+
+    Revised from ``andes.io.psse.read`` to complete model ``Zone`` when necessary.
+    """
+    ret = ad_read(system, file)
+    # Extract zone data
+    zone = system.Bus.zone.v
+    zone_map = {}
+
+    # Check if there are zones to process
+    # NOTE: since `Zone` and `Area` below to group `Collection`, we add
+    # numerical Zone idx after the last Area idx.
+    if zone:
+        n_zone = system.Area.n
+        for z in set(zone):
+            # Add new zone and update the mapping
+            z_new = system.add(
+                'Zone',
+                param_dict=dict(idx=n_zone + 1, name=f'{n_zone + 1}')
+            )
+            zone_map[z] = z_new
+            n_zone += 1
+
+        # Update the zone values in the system
+        system.Bus.zone.v = [zone_map[z] for z in zone]
+    return ret
+
+
+def write_raw(system, outfile: str, overwrite: bool = None):
+    """
+    Convert AMS system to PSS/E RAW file.
+
+    Parameters
+    ----------
+    system : System
+        The AMS system to be converted.
+    outfile : str
+        The output file path.
+    overwrite : bool, optional
+        If True, overwrite the file if it exists. If False, do not overwrite.
+    """
+    if not confirm_overwrite(outfile, overwrite=overwrite):
+        return False
+
+    mva = system.config.mva
+    freq = system.config.freq
+    name = system.files.name
+
+    with open(outfile, 'w') as f:
+        # PSS/E version and date
+        f.write(f"0, {mva:.2f}, 33, 0, 1, {freq:.2f}     ")
+
+        f.write(f"/ PSS/E 33 RAW, {report_time}\n")
+        f.write(f"Created by AMS {version}\n")
+        f.write(f"{copyright_msg}\n")
+        f.write(f"{nowarranty_msg}\n")
+        f.write(f"{name.upper()} \n")
+
+        # --- Bus ---
+        bus = system.Bus.cache.df_in
+        # 0,  1,    2,      3,    4,    5,    6,     7,  8,  9,    10
+        # ID, Name, BaseKV, Type, Area, Zone, Owner, Vm, Va, Vmax, Vmin
+        # Define column widths for alignment
+        column_widths = [6, 8, 8, 2, 3, 3, 3, 8, 8, 8, 8]
+        bus_owner = {}
+        for i, o in enumerate(set(bus['owner'])):
+            bus_owner[o] = i + 1
+        for row in bus.itertuples():
+            # Prepare the data for each column
+            data = [
+                int(row.idx), row.name, row.Vn, int(row.type),
+                int(system.Collection.idx2uid(row.area) + 1),
+                int(system.Collection.idx2uid(row.zone) + 1),
+                int(bus_owner[row.owner]),
+                float(row.v0), float(row.a0 * rad2deg),
+                float(row.vmax), float(row.vmin)]
+            # Format each column with ',' as the delimiter
+            formatted_row = ",".join(
+                f"{value:>{width}}" if isinstance(value, (int, float)) else f"'{value:>{width - 2}}'"
+                for value, width in zip(data, column_widths)
+            ) + "\n"
+            # Write the formatted row to the file
+            f.write(formatted_row)
+
+        # --- Load ---
+        f.write("0 / END OF BUS DATA, BEGIN LOAD DATA\n")
+        load = system.PQ.cache.df_in
+        # 0,   1,  2,      3,    4,    5,      6,       7,  8,  9,  10, 11
+        # Bus, Id, Status, Area, Zone, PL(MW), QL (MW), IP, IQ, YP, YQ, Owner
+        # NOTE: load are converted to constant load, IP, IQ, YP, YQ are ignored by setting to 0
+        column_widths = [6, 8, 2, 3, 3, 10, 10, 2, 2, 10, 10, 3]
+        for row in load.itertuples():
+            # Prepare the data for each column
+            data = [
+                int(row.bus),  # Bus number
+                int(system.PQ.idx2uid(row.idx) + 1),  # Load ID (unique index + 1)
+                int(row.u),  # Status
+                int(system.Collection.idx2uid(system.PQ.get('area', row.idx, 'v')) + 1),  # Area number
+                int(system.Collection.idx2uid(system.PQ.get('zone', row.idx, 'v')) + 1),  # Zone number
+                float(row.p0 * mva),  # PL (MW)
+                float(row.q0 * mva),  # QL (MVar)
+                0.0,  # IP (ignored, set to 0)
+                0.0,  # IQ (ignored, set to 0)
+                0.0,  # YP (ignored, set to 0)
+                0.0,  # YQ (ignored, set to 0)
+                int(bus_owner[row.owner])  # Owner
+            ]
+            # Format each column with ',' as the delimiter
+            formatted_row = ",".join(
+                f"{value:>{width}}" if isinstance(value, (int, float)) else f"'{value:>{width - 2}}'"
+                for value, width in zip(data, column_widths)
+            ) + "\n"
+            # Write the formatted row to the file
+            f.write(formatted_row)
+
+        # --- Fixed Shunt ---
+        f.write("0 / END OF LOAD DATA, BEGIN FIXED SHUNT DATA\n")
+        shunt = system.Shunt.cache.df_in
+        # 0,   1,  2,      3,      4
+        # Bus, Id, Status, G (MW), B (Mvar)
+        # NOTE: ANDES parse v33 swshunt into fixed shunt
+        column_widths = [6, 8, 2, 10, 10]
+        for row in shunt.itertuples():
+            # Prepare the data for each column
+            data = [
+                int(row.bus),                                   # Bus number
+                int(system.Shunt.idx2uid(row.idx) + 1),         # Shunt ID (unique index + 1)
+                int(row.u),                                     # Status
+                float(row.g * mva),                             # Conductance (MW at system base)
+                float(row.b * mva)                              # Susceptance (Mvar at system base)
+            ]
+
+            # Format each column with ',' as the delimiter
+            formatted_row = ",".join(
+                f"{value:>{width}}" if isinstance(value, (int, float)) else f"'{value:>{width - 2}}'"
+                for value, width in zip(data, column_widths)
+            ) + "\n"
+            # Write the formatted row to the file
+            f.write(formatted_row)
+
+        # --- Generator ---
+        f.write("0 / END OF FIXED SHUNT DATA, BEGIN GENERATOR DATA\n")
+        pv = system.PV.cache.df_in
+        slack = system.Slack.cache.df_in
+
+        gen = pd.concat([pv, slack.drop(columns=['a0'])], axis=0)
+        gen["subidx"] = gen.groupby('bus').cumcount() + 1
+
+        column_widths = [6, 8, 2, 3, 3, 3, 3, 8, 8, 8, 8, 8, 8]
+        # 0,  1,  2,  3,  4,  5,  6,    7,     8,  9, 10, 11, 12,   13,   14,
+        # I, ID, PG, QG, QT, QB, VS, IREG, MBASE, ZR, ZX, RT, XT, GTAP, STAT,
+        #    15, 16, 17, 18, 19, ...,           26,  27
+        # RMPCT, PT, PB, O1, F1, ..., O4, F4, WMOD, WPF
+        # The columns above for v33 is different from the manual of v34.5, which includes two new columns:
+        # `NREG`` at 8 and `BSLOD` before `O1`
+        for row in gen.itertuples():
+            # Prepare the data for each column
+            data = [
+                int(row.bus),                  # I: Bus number
+                int(row.subidx),               # ID: Generator ID (subindex)
+                float(row.p0 * mva),           # PG: Generated MW
+                float(row.q0 * mva),           # QG: Generated MVar
+                float(row.qmax * mva),         # QT: Max Q (MVar)
+                float(row.qmin * mva),         # QB: Min Q (MVar)
+                float(row.v0),                 # VS: Setpoint voltage (p.u.)
+                int(0),                        # IREG: Regulated bus (not tracked)
+                float(row.Sn if hasattr(row, 'Sn') else mva),  # MBASE: Machine base MVA
+                float(row.ra),                 # ZR: Armature resistance (p.u.)
+                float(row.xs),                 # ZX: Synchronous reactance (p.u.)
+                float(0),                      # RT: Step-up transformer resistance (not tracked)
+                float(0),                      # XT: Step-up transformer reactance (not tracked)
+                int(0),                        # GTAP: Step-up transformer off-nominal turns ratio (not tracked)
+                int(row.u)                     # STAT: Status
+            ]
+            # Format each column with ',' as the delimiter
+            formatted_row = ",".join(
+                f"{value:>{width}}" if isinstance(value, (int, float)) else f"'{value:>{width - 2}}'"
+                for value, width in zip(data, column_widths)
+            ) + "\n"
+            # Write the formatted row to the file
+            f.write(formatted_row)
+
+        # --- Line ---
+        f.write("0 / END OF GENERATOR DATA, BEGIN BRANCH DATA\n")
+        line = system.Line.cache.df_in
+        branch = line[line['trans'] == 0].reset_index(drop=True)
+        transf = line[line['trans'] == 1].reset_index(drop=True)
+        # 1) branch
+        # 0,  1,   2,   3,   4,   5,     6,     7,     8,   9,  10, 11, 12, 13,  14, 15, 16
+        # I,  J,  CKT,  R,   X,   B,  RATEA, RATEB, RATEC, GI,  BI, GJ, BJ, ST, LEN, O1, F1, ..., O4, F4
+        column_widths = [6, 6, 4, 10, 10, 10, 8, 8, 8, 8, 8, 8, 8, 3, 8]
+        for row in branch.itertuples():
+            data = [
+                int(row.bus1),                      # I: From bus number
+                int(row.bus2),                      # J: To bus number
+                "'1'",                              # CKT: Circuit ID (default '1')
+                float(row.r),                       # R: Resistance (p.u.)
+                float(row.x),                       # X: Reactance (p.u.)
+                float(row.b),                       # B: Total line charging (p.u.)
+                float(row.rate_a),                  # RATEA: Rating A (MVA)
+                float(row.rate_b),                  # RATEB: Rating B (MVA)
+                float(row.rate_c),                  # RATEC: Rating C (MVA)
+                0.0,                                # GI: From bus conductance (not tracked)
+                0.0,                                # BI: From bus susceptance (not tracked)
+                0.0,                                # GJ: To bus conductance (not tracked)
+                0.0,                                # BJ: To bus susceptance (not tracked)
+                int(row.u),                         # ST: Status
+                0.0                                 # LEN: Line length (not tracked)
+                # O1, F1, ..., O4, F4 omitted for v33
+            ]
+            formatted_row = ",".join(
+                f"{value:>{width}}" if isinstance(value, (int, float)) else f"{value:>{width}}"
+                for value, width in zip(data, column_widths)
+            ) + "\n"
+            f.write(formatted_row)
+        # 2) transformer
+        f.write("0 / END OF BRANCH DATA, BEGIN TRANSFORMER DATA\n")
+        for row in transf.itertuples():
+            # Map AMS Line (trans) fields to PSSE RAW transformer columns
+            # Only 2-winding transformers are supported here
+            # 0,  1,   2,   3,   4,   5,     6,     7,     8,   9,  10, 11, 12, 13,  14, 15, 16
+            # I,  J,  CKT,  R,   X,   B,  RATEA, RATEB, RATEC, GI,  BI, GJ, BJ, ST, LEN
+            data = [
+                int(row.bus1),                      # I: From bus number
+                int(row.bus2),                      # J: To bus number
+                "'1'",                              # CKT: Circuit ID (default '1')
+                float(row.r),                       # R: Resistance (p.u.)
+                float(row.x),                       # X: Reactance (p.u.)
+                float(row.b),                       # B: Total line charging (p.u.)
+                float(row.rate_a),                  # RATEA: Rating A (MVA)
+                float(row.rate_b),                  # RATEB: Rating B (MVA)
+                float(row.rate_c),                  # RATEC: Rating C (MVA)
+                0.0,                                # GI: From bus conductance (not tracked)
+                0.0,                                # BI: From bus susceptance (not tracked)
+                0.0,                                # GJ: To bus conductance (not tracked)
+                0.0,                                # BJ: To bus susceptance (not tracked)
+                int(row.u),                         # ST: Status
+                0.0                                 # LEN: Line length (not tracked)
+                # O1, F1, ..., O4, F4 omitted for v33
+            ]
+            formatted_row = ",".join(
+                f"{value:>{width}}" if isinstance(value, (int, float)) else f"{value:>{width}}"
+                for value, width in zip(data, column_widths)
+            ) + "\n"
+            f.write(formatted_row)
+
+            # --- Area ---
+            f.write("0 / END OF TRANSFORMER DATA, BEGIN AREA DATA\n")
+            area = system.Area.cache.df_in
+            for row in area.itertuples():
+                # PSSE expects: ID, ISW, PDES, PTOL, NAME
+                # Here, ISW, PDES, PTOL are set to 0 by default
+                f.write(f"{int(system.Area.idx2uid(row.idx) + 1):6d}, 0, 0.0, 0.0, '{row.name}'\n")
+
+            # --- Zone ---
+            f.write("0 / END OF AREA DATA, BEGIN ZONE DATA\n")
+            zone = system.Zone.cache.df_in
+            # 0,    1
+            # ID, Name
+            for row in zone.itertuples():
+                f.write(f"{int(system.Zone.idx2uid(row.idx) + 1):6d}, '{row.name}'\n")
+            f.write("0 / END OF ZONE DATA\n")
+
+        # End of file
+        f.write("Q\n")
+
+    return True

ams/io/pypower.py

@@ -101,3 +101,17 @@ def system2ppc(system) -> dict:
     mpc['branch'][:, 0] = np.array([bus_map[busi0] for busi0 in mpc['branch'][:, 0].astype(int)])
     mpc['branch'][:, 1] = np.array([bus_map[busi0] for busi0 in mpc['branch'][:, 1].astype(int)])
     return mpc
+
+
+def ppc2py(ppc: dict, outfile: str) -> str:
+    """
+    Placeholder.
+    """
+    return NotImplemented
+
+
+def write(system, outfile: str) -> bool:
+    """
+    Placeholder.
+    """
+    return NotImplemented

ams/main.py

@@ -105,8 +105,8 @@ def config_logger(stream_level=logging.INFO, *,
 
     else:
         # update the handlers
-        set_logger_level(logger, logging.StreamHandler, stream_level)
-        set_logger_level(logger, logging.FileHandler, file_level)
+        set_logger_level(lg, logging.StreamHandler, stream_level)
+        set_logger_level(lg, logging.FileHandler, file_level)
 
     if not is_interactive():
         coloredlogs.install(logger=lg, level=stream_level, fmt=sh_formatter_str)

ams/models/group.py

@@ -179,75 +179,6 @@ class StaticGen(GroupBase):
 
     The generator types and fuel types are referenced from MATPOWER.
 
-    Generator Types
-    ---------------
-    The following codes represent the types of generators:
-        - BA  : Energy Storage, Battery
-        - CE  : Energy Storage, Compressed Air
-        - CP  : Energy Storage, Concentrated Solar Power
-        - FW  : Energy Storage, Flywheel
-        - PS  : Hydraulic Turbine, Reversible (pumped storage)
-        - ES  : Energy Storage, Other
-        - ST  : Steam Turbine (includes nuclear, geothermal, and solar steam)
-        - GT  : Combustion (Gas) Turbine
-        - IC  : Internal Combustion Engine (diesel, piston, reciprocating)
-        - CA  : Combined Cycle Steam Part
-        - CT  : Combined Cycle Combustion Turbine Part
-        - CS  : Combined Cycle Single Shaft
-        - CC  : Combined Cycle Total Unit
-        - HA  : Hydrokinetic, Axial Flow Turbine
-        - HB  : Hydrokinetic, Wave Buoy
-        - HK  : Hydrokinetic, Other
-        - HY  : Hydroelectric Turbine
-        - BT  : Turbines Used in a Binary Cycle
-        - PV  : Photovoltaic
-        - WT  : Wind Turbine, Onshore
-        - WS  : Wind Turbine, Offshore
-        - FC  : Fuel Cell
-        - OT  : Other
-        - UN  : Unknown
-        - JE  : Jet Engine
-        - NB  : ST - Boiling Water Nuclear Reactor
-        - NG  : ST - Graphite Nuclear Reactor
-        - NH  : ST - High Temperature Gas Nuclear Reactor
-        - NP  : ST - Pressurized Water Nuclear Reactor
-        - IT  : Internal Combustion Turbo Charged
-        - SC  : Synchronous Condenser
-        - DC  : DC ties
-        - MP  : Motor/Pump
-        - W1  : Wind Turbine, Type 1
-        - W2  : Wind Turbine, Type 2
-        - W3  : Wind Turbine, Type 3
-        - W4  : Wind Turbine, Type 4
-        - SV  : Static Var Compensator
-        - DL  : Dispatchable Load
-
-    Fuel Types
-    ----------
-    The following codes represent the fuel types:
-        - biomass     : Biomass
-        - coal        : Coal
-        - dfo         : Distillate Fuel Oil
-        - geothermal  : Geothermal
-        - hydro       : Hydro
-        - hydrops     : Hydro Pumped Storage
-        - jetfuel     : Jet Fuel
-        - lng         : Liquefied Natural Gas
-        - ng          : Natural Gas
-        - nuclear     : Nuclear
-        - oil         : Unspecified Oil
-        - refuse      : Refuse, Municipal Solid Waste
-        - rfo         : Residual Fuel Oil
-        - solar       : Solar
-        - syncgen     : Synchronous Condenser
-        - wasteheat   : Waste Heat
-        - wind        : Wind
-        - wood        : Wood or Wood Waste
-        - other       : Other
-        - unknown     : Unknown
-        - dl          : Dispatchable Load
-        - ess         : Energy Storage System
-
     Notes
     -----
     For co-simulation with ANDES, refer to the `ANDES StaticGen Documentation
@@ -289,7 +220,8 @@ class StaticShunt(GroupBase):
     """
     Static shunt compensator group.
     """
-    pass
+    def __init__(self):
+        super().__init__()
 
 
 class Information(GroupBase):

ams/models/static/pq.py

@@ -53,9 +53,13 @@ class PQ(PQData, Model):
                               q2z=r"\gamma_{q2z}",
                               )
 
-        self.area = ExtParam(model='Bus', src='area', indexer=self.bus, export=False,
-                             info='Retrieved area idx', vtype=str, default=None,
-                             )
         self.ctrl = NumParam(default=1,
                              info="load controllability",
                              tex_name=r'c_{trl}',)
+
+        self.area = ExtParam(model='Bus', src='area', indexer=self.bus, export=False,
+                             info='Retrieved area idx', vtype=str, default=None,
+                             )
+        self.zone = ExtParam(model='Bus', src='zone', indexer=self.bus, export=False,
+                             info='Retrieved zone idx', vtype=str, default=None,
+                             )

ams/opt/param.py

@@ -9,10 +9,9 @@ import re
 
 import numpy as np
 
-from andes.core.common import Config
-
 import cvxpy as cp
 
+from ams.core import Config
 from ams.shared import sps
 
 from ams.opt import OptzBase, ensure_symbols, ensure_mats_and_parsed

ams/report.py

@@ -3,7 +3,6 @@ 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
@@ -11,7 +10,7 @@ from andes.shared import np
 from andes.utils.misc import elapsed
 
 from ams import __version__ as version
-from ams.shared import copyright_msg
+from ams.shared import copyright_msg, nowarranty_msg, report_time
 
 logger = logging.getLogger(__name__)
 
@@ -23,9 +22,9 @@ 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(f"{nowarranty_msg}\n")
     info.append('Case file: ' + str(system.files.case) + '\n')
-    info.append('Report time: ' + strftime("%m/%d/%Y %I:%M:%S %p") + '\n\n')
+    info.append(f'Report time: {report_time}\n\n')
     return info
 
 

ams/routines/__init__.py

@@ -8,7 +8,6 @@ from andes.utils.func import list_flatten
 all_routines = OrderedDict([
     ('dcpf', ['DCPF']),
     ('pflow', ['PFlow']),
-    ('cpf', ['CPF']),
     ('acopf', ['ACOPF']),
     ('dcopf', ['DCOPF']),
     ('dcopf2', ['DCOPF2']),
@@ -16,8 +15,8 @@ all_routines = OrderedDict([
     ('rted', ['RTED', 'RTEDDG', 'RTEDES', 'RTEDVIS']),
     ('uc', ['UC', 'UCDG', 'UCES']),
     ('dopf', ['DOPF', 'DOPFVIS']),
-    ('pflow0', ['PFlow0']),
-    ('dcpf0', ['DCPF0']),
+    ('pypower', ['DCPF1', 'PFlow1', 'DCOPF1', 'ACOPF1']),
+    ('grbopt', ['OPF']),
 ])
 
 class_names = list_flatten(list(all_routines.values()))

ams/routines/acopf.py

@@ -1,117 +1,14 @@
 """
-ACOPF routines using PYPOWER.
+ACOPF routines.
 """
-import logging
-from collections import OrderedDict
 
-from ams.pypower import runopf
-from ams.pypower.core import ppoption
+from ams.routines.pypower import ACOPF1
 
-from ams.io.pypower import system2ppc
-from ams.core.param import RParam
 
-from ams.routines.dcpf0 import DCPF0
-from ams.opt import Var, Constraint, Objective
-
-logger = logging.getLogger(__name__)
-
-
-class ACOPF(DCPF0):
+class ACOPF(ACOPF1):
     """
-    Standard AC optimal power flow.
-
-    Notes
-    -----
-    1. ACOPF is solved with PYPOWER ``runopf`` function.
-    2. ACOPF formulation in AMS style is NOT DONE YET,
-       but this does not affect the results
-       because the data are passed to PYPOWER for solving.
+    Alias for ACOPF1.
     """
 
     def __init__(self, system, config):
-        DCPF0.__init__(self, system, config)
-        self.info = 'AC Optimal Power Flow'
-        self.type = 'ACED'
-
-        self.map1 = OrderedDict()   # ACOPF does not receive
-        self.map2.update({
-            'vBus': ('Bus', 'v0'),
-            'ug': ('StaticGen', 'u'),
-            'pg': ('StaticGen', 'p0'),
-        })
-
-        # --- params ---
-        self.c2 = RParam(info='Gen cost coefficient 2',
-                         name='c2', tex_name=r'c_{2}',
-                         unit=r'$/(p.u.^2)', model='GCost',
-                         indexer='gen', imodel='StaticGen',
-                         nonneg=True)
-        self.c1 = RParam(info='Gen cost coefficient 1',
-                         name='c1', tex_name=r'c_{1}',
-                         unit=r'$/(p.u.)', model='GCost',
-                         indexer='gen', imodel='StaticGen',)
-        self.c0 = RParam(info='Gen cost coefficient 0',
-                         name='c0', tex_name=r'c_{0}',
-                         unit=r'$', model='GCost',
-                         indexer='gen', imodel='StaticGen',
-                         no_parse=True)
-        self.qd = RParam(info='reactive demand',
-                         name='qd', tex_name=r'q_{d}',
-                         model='StaticLoad', src='q0',
-                         unit='p.u.',)
-        # --- bus ---
-        self.vBus = Var(info='Bus voltage magnitude',
-                        unit='p.u.',
-                        name='vBus', tex_name=r'v_{Bus}',
-                        src='v', model='Bus',)
-        # --- gen ---
-        self.qg = Var(info='Gen reactive power',
-                      unit='p.u.',
-                      name='qg', tex_name=r'q_{g}',
-                      model='StaticGen', src='q',)
-        # --- constraints ---
-        self.pb = Constraint(name='pb',
-                             info='power balance',
-                             e_str='sum(pd) - sum(pg)',
-                             is_eq=True,)
-        # TODO: ACOPF formulation
-        # --- objective ---
-        self.obj = Objective(name='obj',
-                             info='total cost',
-                             e_str='sum(c2 * pg**2 + c1 * pg + c0)',
-                             sense='min',)
-
-    def solve(self, method=None, **kwargs):
-        """
-        Solve ACOPF using PYPOWER with PIPS.
-        """
-        ppc = system2ppc(self.system)
-        ppopt = ppoption()
-        res, sstats = runopf(casedata=ppc, ppopt=ppopt, **kwargs)
-        return res, sstats
-
-    def run(self, **kwargs):
-        """
-        Run ACOPF using PYPOWER with PIPS.
-        *args and **kwargs go to `self.solve()`, which are not used yet.
-
-        Examples
-        --------
-        >>> ss = ams.load(ams.get_case('matpower/case14.m'))
-        >>> ss.ACOPF.run()
-
-        Parameters
-        ----------
-        force_init : bool
-            Force initialization.
-        no_code : bool
-            Disable showing code.
-        method : str
-            Placeholder for future use.
-
-        Returns
-        -------
-        exit_code : int
-            Exit code of the routine.
-        """
-        super().run(**kwargs)
+        super().__init__(system, config)

ams/routines/dcopf.py

@@ -141,6 +141,14 @@ class DCOPF(DCPFBase):
                                  name='pi', unit='$/p.u.',
                                  model='Bus', src=None,
                                  e_str='pb.dual_variables[0]')
+        self.mu1 = ExpressionCalc(info='Lagrange multipliers, dual of <plflb>',
+                                  name='mu1', unit='$/p.u.',
+                                  model='Line', src=None,
+                                  e_str='plflb.dual_variables[0]')
+        self.mu2 = ExpressionCalc(info='Lagrange multipliers, dual of <plfub>',
+                                  name='mu2', unit='$/p.u.',
+                                  model='Line', src=None,
+                                  e_str='plfub.dual_variables[0]')
 
         # --- objective ---
         obj = 'sum(mul(c2, pg**2))'

ams/routines/dcpf.py

@@ -125,7 +125,7 @@ class DCPFBase(RoutineBase):
         """
         return self.om.prob.solve(**kwargs)
 
-    def unpack(self, **kwargs):
+    def unpack(self, res, **kwargs):
         """
         Unpack the results from CVXPY model.
         """

ams/routines/ed.py

@@ -104,6 +104,8 @@ class MPBase:
         self.vBus.horizon = self.timeslot
         self.vBus.info = '2D Bus voltage'
         self.pi.horizon = self.timeslot
+        self.mu1.horizon = self.timeslot
+        self.mu2.horizon = self.timeslot
 
 
 class ED(RTED, MPBase, SRBase):
@@ -214,14 +216,14 @@ class ED(RTED, MPBase, SRBase):
         cost += '+ sum(mul(ugt, mul(c0, tlv)))'
         self.obj.e_str = cost
 
-    def dc2ac(self, **kwargs):
+    def dc2ac(self, kloss=1.0, **kwargs):
         """
         AC conversion ``dc2ac`` is not implemented yet for
         multi-period scheduling.
         """
         return NotImplementedError
 
-    def unpack(self, **kwargs):
+    def unpack(self, res, **kwargs):
         """
         Multi-period scheduling will not unpack results from
         solver into devices.