ltbams 0.9.9__py3-none-any.whl → 1.0.0__py3-none-any.whl

ams/routines/acopf.py

@@ -0,0 +1,117 @@
+"""
+ACOPF routines using PYPOWER.
+"""
+import logging
+from collections import OrderedDict
+
+from ams.pypower import runopf
+from ams.pypower.core import ppoption
+
+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):
+    """
+    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.
+    """
+
+    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)

ams/routines/cpf.py

@@ -0,0 +1,65 @@
+"""
+Continuous power flow routine.
+"""
+import logging
+
+from ams.pypower import runcpf
+
+from ams.io.pypower import system2ppc
+from ams.pypower.core import ppoption
+
+from ams.routines.pflow import PFlow
+
+logger = logging.getLogger(__name__)
+
+
+class CPF(PFlow):
+    """
+    Continuous power flow.
+
+    Still under development, not ready for use.
+    """
+
+    def __init__(self, system, config):
+        PFlow.__init__(self, system, config)
+        self.info = 'AC continuous power flow'
+        self.type = 'PF'
+
+    def solve(self, method=None, **kwargs):
+        """
+        Solve the CPF using PYPOWER.
+        """
+        ppc = system2ppc(self.system)
+        ppopt = ppoption()
+        res, success, sstats = runcpf(casedata=ppc, ppopt=ppopt, **kwargs)
+        return res, success, sstats
+
+    # FIXME: unpack results?
+
+    def run(self, force_init=False, no_code=True,
+            method='newton', **kwargs):
+        """
+        Run continuous power flow using PYPOWER.
+
+        Examples
+        --------
+        >>> ss = ams.load(ams.get_case('matpower/case14.m'))
+        >>> ss.CPF.run()
+
+        Parameters
+        ----------
+        force_init : bool
+            Force initialization.
+        no_code : bool
+            Disable showing code.
+        method : str
+            Method for solving the power flow.
+
+        Returns
+        -------
+        exit_code : int
+            Exit code of the routine.
+        """
+        super().run(force_init=force_init,
+                    no_code=no_code, method=method,
+                    **kwargs, )

ams/routines/dcopf.py

@@ -0,0 +1,241 @@
+"""
+DCOPF routines.
+"""
+import logging
+
+import numpy as np
+from ams.core.param import RParam
+from ams.core.service import NumOp, NumOpDual
+
+from ams.routines.dcpf import DCPFBase
+
+from ams.opt import Constraint, Objective, ExpressionCalc, Expression
+
+
+logger = logging.getLogger(__name__)
+
+
+class DCOPF(DCPFBase):
+    """
+    DC optimal power flow (DCOPF).
+
+    The nodal price is calculated as ``pi`` in ``pic``.
+
+    References
+    ----------
+    1. R. D. Zimmerman, C. E. Murillo-Sanchez, and R. J. Thomas, “MATPOWER: Steady-State Operations, Planning, and
+    Analysis Tools for Power Systems Research and Education,” IEEE Trans. Power Syst., vol. 26, no. 1, pp. 12–19,
+    Feb. 2011
+    """
+
+    def __init__(self, system, config):
+        DCPFBase.__init__(self, system, config)
+        self.info = 'DC Optimal Power Flow'
+        self.type = 'DCED'
+
+        # --- Mapping Section ---
+        # --- from map ---
+        self.map1.update({
+            'ug': ('StaticGen', 'u'),
+        })
+        # --- to map ---
+        self.map2.update({
+            'vBus': ('Bus', 'v0'),
+            'ug': ('StaticGen', 'u'),
+            'pg': ('StaticGen', 'p0'),
+        })
+
+        # --- Data Section ---
+        # --- generator cost ---
+        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, no_parse=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)
+        # --- generator ---
+        self.ctrl = RParam(info='Gen controllability',
+                           name='ctrl', tex_name=r'c_{trl}',
+                           model='StaticGen', src='ctrl',
+                           no_parse=True)
+        self.ctrle = NumOpDual(info='Effective Gen controllability',
+                               name='ctrle', tex_name=r'c_{trl, e}',
+                               u=self.ctrl, u2=self.ug,
+                               fun=np.multiply, no_parse=True)
+        self.nctrl = NumOp(u=self.ctrl, fun=np.logical_not,
+                           name='nctrl', tex_name=r'c_{trl,n}',
+                           info='Effective Gen uncontrollability',
+                           no_parse=True,)
+        self.nctrle = NumOpDual(info='Effective Gen uncontrollability',
+                                name='nctrle', tex_name=r'c_{trl,n,e}',
+                                u=self.nctrl, u2=self.ug,
+                                fun=np.multiply, no_parse=True)
+        self.pmax = RParam(info='Gen maximum active power',
+                           name='pmax', tex_name=r'p_{g, max}',
+                           unit='p.u.', model='StaticGen',
+                           no_parse=False,)
+        self.pmin = RParam(info='Gen minimum active power',
+                           name='pmin', tex_name=r'p_{g, min}',
+                           unit='p.u.', model='StaticGen',
+                           no_parse=False,)
+
+        # --- line ---
+        self.ul = RParam(info='Line connection status',
+                         name='ul', tex_name=r'u_{l}',
+                         model='Line', src='u',
+                         no_parse=True,)
+        self.rate_a = RParam(info='long-term flow limit',
+                             name='rate_a', tex_name=r'R_{ATEA}',
+                             unit='p.u.', model='Line',)
+        # --- line angle difference ---
+        self.amax = RParam(model='Line', src='amax',
+                           name='amax', tex_name=r'\theta_{bus, max}',
+                           info='max line angle difference',
+                           no_parse=True,)
+        self.amin = RParam(model='Line', src='amin',
+                           name='amin', tex_name=r'\theta_{bus, min}',
+                           info='min line angle difference',
+                           no_parse=True,)
+
+        # --- Model Section ---
+        self.pmaxe = Expression(info='Effective pmax',
+                                name='pmaxe', tex_name=r'p_{g, max, e}',
+                                e_str='mul(nctrle, pg0) + mul(ctrle, pmax)',
+                                model='StaticGen', src=None, unit='p.u.',)
+        self.pmine = Expression(info='Effective pmin',
+                                name='pmine', tex_name=r'p_{g, min, e}',
+                                e_str='mul(nctrle, pg0) + mul(ctrle, pmin)',
+                                model='StaticGen', src=None, unit='p.u.',)
+        self.pglb = Constraint(name='pglb', info='pg min',
+                               e_str='-pg + pmine', is_eq=False,)
+        self.pgub = Constraint(name='pgub', info='pg max',
+                               e_str='pg - pmaxe', is_eq=False,)
+
+        # --- line flow ---
+        self.plflb = Constraint(info='line flow lower bound',
+                                name='plflb', is_eq=False,
+                                e_str='-plf - mul(ul, rate_a)',)
+        self.plfub = Constraint(info='line flow upper bound',
+                                name='plfub', is_eq=False,
+                                e_str='plf - mul(ul, rate_a)',)
+        self.alflb = Constraint(info='line angle difference lower bound',
+                                name='alflb', is_eq=False,
+                                e_str='-CftT@aBus + amin',)
+        self.alfub = Constraint(info='line angle difference upper bound',
+                                name='alfub', is_eq=False,
+                                e_str='CftT@aBus - amax',)
+        # NOTE: in CVXPY, dual_variables returns a list
+        self.pi = ExpressionCalc(info='LMP, dual of <pb>',
+                                 name='pi', unit='$/p.u.',
+                                 model='Bus', src=None,
+                                 e_str='pb.dual_variables[0]')
+
+        # --- objective ---
+        obj = 'sum(mul(c2, pg**2))'
+        obj += '+ sum(mul(c1, pg))'
+        obj += '+ sum(mul(ug, c0))'
+        self.obj = Objective(name='obj',
+                             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_all_idxes()
+        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.
+
+        Following kwargs go to `self.init()`: `force`, `force_mats`, `force_constr`, `force_om`.
+
+        Following kwargs go to `self.solve()`: `solver`, `verbose`, `gp`, `qcp`, `requires_grad`,
+        `enforce_dpp`, `ignore_dpp`, `method`, and all rest.
+
+        Parameters
+        ----------
+        force : bool, optional
+            If True, force re-initialization. Defaults to False.
+        force_mats : bool, optional
+            If True, force re-generating matrices. Defaults to False.
+        force_constr : bool, optional
+            Whether to turn on all constraints.
+        force_om : bool, optional
+            If True, force re-generating optimization model. Defaults to False.
+        solver: str, optional
+            The solver to use. For example, 'GUROBI', 'ECOS', 'SCS', or 'OSQP'.
+        verbose : bool, optional
+            Overrides the default of hiding solver output and prints logging
+            information describing CVXPY's compilation process.
+        gp : bool, optional
+            If True, parses the problem as a disciplined geometric program
+            instead of a disciplined convex program.
+        qcp : bool, optional
+            If True, parses the problem as a disciplined quasiconvex program
+            instead of a disciplined convex program.
+        requires_grad : bool, optional
+            Makes it possible to compute gradients of a solution with respect to Parameters
+            by calling problem.backward() after solving, or to compute perturbations to the variables
+            given perturbations to Parameters by calling problem.derivative().
+            Gradients are only supported for DCP and DGP problems, not quasiconvex problems.
+            When computing gradients (i.e., when this argument is True), the problem must satisfy the DPP rules.
+        enforce_dpp : bool, optional
+            When True, a DPPError will be thrown when trying to solve a
+            non-DPP problem (instead of just a warning).
+            Only relevant for problems involving Parameters. Defaults to False.
+        ignore_dpp : bool, optional
+            When True, DPP problems will be treated as non-DPP, which may speed up compilation. Defaults to False.
+        method : function, optional
+            A custom solve method to use.
+        """
+        return super().run(**kwargs)

ams/routines/dcpf.py

@@ -0,0 +1,209 @@
+"""
+Power flow routines.
+"""
+import logging
+
+from ams.opt import Var, Constraint, Expression, Objective
+from ams.routines.routine import RoutineBase
+
+from ams.core.param import RParam
+from ams.core.service import VarSelect
+
+logger = logging.getLogger(__name__)
+
+
+class DCPFBase(RoutineBase):
+    """
+    Base class for DC power flow.
+    """
+
+    def __init__(self, system, config):
+        RoutineBase.__init__(self, system, config)
+
+        self.ug = RParam(info='Gen connection status',
+                         name='ug', tex_name=r'u_{g}',
+                         model='StaticGen', src='u',
+                         no_parse=True)
+        self.pg0 = RParam(info='Gen initial active power',
+                          name='pg0', tex_name=r'p_{g, 0}',
+                          unit='p.u.', model='StaticGen',
+                          src='p0', no_parse=False,)
+        # --- shunt ---
+        self.gsh = RParam(info='shunt conductance',
+                          name='gsh', tex_name=r'g_{sh}',
+                          model='Shunt', src='g',
+                          no_parse=True,)
+
+        self.buss = RParam(info='Bus slack',
+                           name='buss', tex_name=r'B_{us,s}',
+                           model='Slack', src='bus',
+                           no_parse=True,)
+        # --- load ---
+        self.pd = RParam(info='active demand',
+                         name='pd', tex_name=r'p_{d}',
+                         model='StaticLoad', src='p0',
+                         unit='p.u.',)
+
+        # --- connection matrix ---
+        self.Cg = RParam(info='Gen connection matrix',
+                         name='Cg', tex_name=r'C_{g}',
+                         model='mats', src='Cg',
+                         no_parse=True, sparse=True,)
+        self.Cl = RParam(info='Load connection matrix',
+                         name='Cl', tex_name=r'C_{l}',
+                         model='mats', src='Cl',
+                         no_parse=True, sparse=True,)
+        self.CftT = RParam(info='Transpose of line connection matrix',
+                           name='CftT', tex_name=r'C_{ft}^T',
+                           model='mats', src='CftT',
+                           no_parse=True, sparse=True,)
+        self.Csh = RParam(info='Shunt connection matrix',
+                          name='Csh', tex_name=r'C_{sh}',
+                          model='mats', src='Csh',
+                          no_parse=True, sparse=True,)
+
+        # --- system matrix ---
+        self.Bbus = RParam(info='Bus admittance matrix',
+                           name='Bbus', tex_name=r'B_{bus}',
+                           model='mats', src='Bbus',
+                           no_parse=True, sparse=True,)
+        self.Bf = RParam(info='Bf matrix',
+                         name='Bf', tex_name=r'B_{f}',
+                         model='mats', src='Bf',
+                         no_parse=True, sparse=True,)
+        self.Pbusinj = RParam(info='Bus power injection vector',
+                              name='Pbusinj', tex_name=r'P_{bus}^{inj}',
+                              model='mats', src='Pbusinj',
+                              no_parse=True,)
+        self.Pfinj = RParam(info='Line power injection vector',
+                            name='Pfinj', tex_name=r'P_{f}^{inj}',
+                            model='mats', src='Pfinj',
+                            no_parse=True,)
+
+        # --- generation ---
+        self.pg = Var(info='Gen active power',
+                      unit='p.u.',
+                      name='pg', tex_name=r'p_g',
+                      model='StaticGen', src='p',
+                      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}',
+                        model='Bus', src='a',)
+
+        # --- power balance ---
+        pb = 'Bbus@aBus + Pbusinj + Cl@pd + Csh@gsh - Cg@pg'
+        self.pb = Constraint(name='pb', info='power balance',
+                             e_str=pb, is_eq=True,)
+
+        # --- bus ---
+        self.csb = VarSelect(info='select slack bus',
+                             name='csb', tex_name=r'c_{sb}',
+                             u=self.aBus, indexer='buss',
+                             no_parse=True,)
+        self.sba = Constraint(info='align slack bus angle',
+                              name='sbus', is_eq=True,
+                              e_str='csb@aBus',)
+
+        # --- line flow ---
+        self.plf = Expression(info='Line flow',
+                              name='plf', tex_name=r'p_{lf}',
+                              unit='p.u.',
+                              e_str='Bf@aBus + Pfinj',
+                              model='Line', src=None,)
+
+    def solve(self, **kwargs):
+        """
+        Solve the routine optimization model.
+        args and kwargs go to `self.om.prob.solve()` (`cvxpy.Problem.solve()`).
+        """
+        return self.om.prob.solve(**kwargs)
+
+    def unpack(self, **kwargs):
+        """
+        Unpack the results from CVXPY model.
+        """
+        # --- solver Var results to routine algeb ---
+        for _, var in self.vars.items():
+            # --- copy results from routine algeb into system algeb ---
+            if var.model is None:          # if no owner
+                continue
+            if var.src is None:            # if no source
+                continue
+            else:
+                try:
+                    idx = var.owner.get_all_idxes()
+                except AttributeError:
+                    idx = var.owner.idx.v
+
+                # NOTE: only unpack the variables that are in the model or group
+                try:
+                    var.owner.set(src=var.src, idx=idx, attr='v', value=var.v)
+                except (KeyError, TypeError):
+                    logger.error(f'Failed to unpack <{var}> to <{var.owner.class_name}>.')
+
+        # --- solver ExpressionCalc results to routine algeb ---
+        for _, exprc in self.exprcs.items():
+            if exprc.model is None:
+                continue
+            if exprc.src is None:
+                continue
+            else:
+                try:
+                    idx = exprc.owner.get_all_idxes()
+                except AttributeError:
+                    idx = exprc.owner.idx.v
+
+                try:
+                    exprc.owner.set(src=exprc.src, idx=idx, attr='v', value=exprc.v)
+                except (KeyError, TypeError):
+                    logger.error(f'Failed to unpack <{exprc}> to <{exprc.owner.class_name}>.')
+
+        # label the most recent solved routine
+        self.system.recent = self.system.routines[self.class_name]
+        return True
+
+    def _post_solve(self):
+        """
+        Post-solve calculations.
+        """
+        # NOTE: unpack Expressions if owner and arc are available
+        for expr in self.exprs.values():
+            if expr.owner and expr.src:
+                expr.owner.set(src=expr.src, attr='v',
+                               idx=expr.get_all_idxes(), value=expr.v)
+        return True
+
+
+class DCPF(DCPFBase):
+    """
+    DC power flow.
+    """
+
+    def __init__(self, system, config):
+        DCPFBase.__init__(self, system, config)
+        self.info = 'DC Power Flow'
+        self.type = 'PF'
+
+        self.genpv = RParam(info='gen of PV',
+                            name='genpv', tex_name=r'g_{DG}',
+                            model='PV', src='idx',
+                            no_parse=True,)
+        self.cpv = VarSelect(u=self.pg, indexer='genpv',
+                             name='cpv', tex_name=r'C_{PV}',
+                             info='Select PV from pg',
+                             no_parse=True,)
+
+        self.pvb = Constraint(name='pvb', info='PV generator',
+                              e_str='cpv @ (pg - mul(ug, pg0))',
+                              is_eq=True,)
+
+        self.obj = Objective(name='obj',
+                             info='place holder', unit='$',
+                             sense='min', e_str='0',)