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

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.

ams/routines/grbopt.py

@@ -0,0 +1,150 @@
+"""
+Routines using gurobi-optimods.
+"""
+import logging
+
+import io
+
+import scipy.io
+
+from andes.shared import np, pd
+from andes.utils.misc import elapsed
+
+from ams.io.pypower import system2ppc
+
+from ams.opt import Var, Objective
+
+from ams.routines.pypower import DCPF1
+from ams.shared import opf
+
+logger = logging.getLogger(__name__)
+
+
+class OPF(DCPF1):
+    """
+    Optimal Power Flow (OPF) routine using gurobi-optimods.
+
+    This class provides an interface for performing optimal power flow analysis
+    with gurobi-optimods, supporting both AC and DC OPF formulations.
+
+    In addition to optimizing generator dispatch, this routine can also optimize
+    transmission line statuses (branch switching), enabling topology optimization.
+    Refer to the gurobi-optimods documentation for further details:
+
+    https://gurobi-optimods.readthedocs.io/en/stable/mods/opf/opf.html
+    """
+
+    def __init__(self, system, config):
+        DCPF1.__init__(self, system, config)
+        self.info = 'Optimal Power Flow'
+        self.type = 'ACED'
+
+        self.obj = Objective(name='obj',
+                             info='total cost, placeholder',
+                             e_str='sum(c2 * pg**2 + c1 * pg + c0)',
+                             sense='min',)
+
+        self.pi = Var(info='Lagrange multiplier on real power mismatch',
+                      name='pi', unit='$/p.u.',
+                      model='Bus', src=None,)
+
+        self.uld = Var(info='Line commitment decision',
+                       name='uld', tex_name=r'u_{l,d}',
+                       model='Line', src='u',)
+
+    def solve(self, **kwargs):
+        ppc = system2ppc(self.system)
+        mat = io.BytesIO()
+        scipy.io.savemat(mat, {'mpc': ppc})
+        mat.seek(0)
+        res = opf.solve_opf(opf.read_case_matpower(mat), **kwargs)
+        return res
+
+    def unpack(self, res, **kwargs):
+        """
+        Unpack the results from the gurobi-optimods.
+        """
+        # NOTE: Map gurobi-optimods results to PPC-compatible format.
+        # Only relevant columns are populated, as required by `DCOPF.unpack()`.
+        # If future versions of gurobi-optimods provide additional outputs,
+        # this mapping may need to be updated to extract and assign new fields.
+
+        res_new = dict()
+        res_new['success'] = res['success']
+        res_new['et'] = res['et']
+        res_new['f'] = res['f']
+        res_new['baseMVA'] = res['baseMVA']
+
+        bus = pd.DataFrame(res['bus'])
+        res_new['bus'] = np.zeros((self.system.Bus.n, 17))
+        res_new['bus'][:, 7] = bus['Vm'].values
+        res_new['bus'][:, 8] = bus['Va'].values
+        # NOTE: As of v2.3.2, gurobi-optimods does not return LMP
+
+        gen = pd.DataFrame(res['gen'])
+        res_new['gen'] = np.zeros((self.system.StaticGen.n, 14))
+        res_new['gen'][:, 1] = gen['Pg'].values
+        res_new['gen'][:, 2] = gen['Qg'].values
+
+        branch = pd.DataFrame(res['branch'])
+        res_new['branch'] = np.zeros((self.system.Line.n, 14))
+        res_new['branch'][:, 13] = branch['Pf'].values
+        # NOTE: unpack branch_switching decision
+        res_new['branch'][:, 10] = branch['switching'].values
+        return super().unpack(res_new)
+
+    def run(self, **kwargs):
+        """
+        Run the OPF routine using gurobi-optimods.
+
+        This method invokes `self.solve(**kwargs)`, which internally utilizes
+        `gurobi-optimods` to solve the OPF problem.
+
+        Keyword arguments
+        -------------------
+        - ``opftype`` : str
+            Type of OPF to solve (default: 'AC').
+        - ``branch_switching`` : bool
+            Enable branch switching (default: False).
+        - ``min_active_branches`` : float
+            Defines the minimum number of branches that must be turned on when
+            branch switching is active, i.e. the minimum number of turned on
+            branches is equal to ``numbranches * min_active_branches``. Has no
+            effect if ``branch_switching`` is set to False.
+        - ``use_mip_start`` : bool
+            Use MIP start (default: False).
+        - ``time_limit`` : float
+            Time limit for the solver (default: 0.0, no limit).
+        """
+        if not self.initialized:
+            self.init()
+        t0, _ = elapsed()
+
+        # --- solve optimization ---
+        t0, _ = elapsed()
+        res = self.solve(**kwargs)
+        self.converged = res['success']
+        self.exit_code = 0 if res['success'] else 1
+        _, s = elapsed(t0)
+        self.exec_time = float(s.split(" ")[0])
+        try:
+            n_iter = res['raw']['output']['iterations']
+        except Exception:
+            n_iter = -1
+        n_iter_str = f"{n_iter} iterations " if n_iter > 1 else f"{n_iter} iteration "
+        if self.exit_code == 0:
+            msg = f"<{self.class_name}> converged in {s}, "
+            msg += n_iter_str + "with gurobi-optimods."
+            logger.warning(msg)
+            try:
+                self.unpack(res)
+            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 to converge in {s}, "
+            msg += n_iter_str + "with gurobi-optimods."
+            logger.warning(msg)
+            return False

ams/routines/pflow.py

@@ -130,7 +130,7 @@ class PFlow(RoutineBase):
         _, s = elapsed(t0)
         self.exec_time = float(s.split(" ")[0])
 
-        self.unpack()
+        self.unpack(res=None)
         return self.converged
 
     def _post_solve(self):
@@ -139,7 +139,7 @@ class PFlow(RoutineBase):
         """
         return True
 
-    def unpack(self, **kwargs):
+    def unpack(self, res, **kwargs):
         """
         Unpack the results from ANDES PFlow routine.
         """