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

ams/pypower/utils.py

@@ -1,293 +0,0 @@
-"""
-PYPOWER utility functions.
-"""
-import logging  # NOQA
-from copy import deepcopy  # NOQA
-
-import numpy as np  # NOQA
-from numpy import flatnonzero as find  # NOQA
-import scipy.sparse as sp  # NOQA
-from scipy.sparse import csr_matrix as c_sparse  # NOQA
-
-from ams.pypower.idx import IDX  # NOQA
-
-logger = logging.getLogger(__name__)
-
-
-def bustypes(bus, gen):
-    """
-    Builds index lists of each type of bus (REF, PV, PQ).
-
-    Generators with "out-of-service" status are treated as PQ buses with
-    zero generation (regardless of Pg/Qg values in gen). Expects bus
-    and gen have been converted to use internal consecutive bus numbering.
-
-    Parameters
-    ----------
-    bus : ndarray
-        Bus data.
-    gen : ndarray
-        Generator data.
-
-    Returns
-    -------
-    ref : ndarray
-        Index list of reference (REF) buses.
-    pv : ndarray
-        Index list of PV buses.
-    pq : ndarray
-        Index list of PQ buses.
-
-    Author
-    ------
-    Ray Zimmerman (PSERC Cornell)
-    """
-    # get generator status
-    nb = bus.shape[0]
-    ng = gen.shape[0]
-    # gen connection matrix, element i, j is 1 if, generator j at bus i is ON
-    Cg = c_sparse((gen[:, IDX.gen.GEN_STATUS] > 0,
-                   (gen[:, IDX.gen.GEN_BUS], range(ng))), (nb, ng))
-    # number of generators at each bus that are ON
-    bus_gen_status = (Cg * np.ones(ng, int)).astype(bool)
-
-    # form index lists for slack, PV, and PQ buses
-    ref = find((bus[:, IDX.bus.BUS_TYPE] == IDX.bus.REF) & bus_gen_status)  # ref bus index
-    pv = find((bus[:, IDX.bus.BUS_TYPE] == IDX.bus.PV) & bus_gen_status)  # PV bus indices
-    pq = find((bus[:, IDX.bus.BUS_TYPE] == IDX.bus.PQ) | ~bus_gen_status)  # PQ bus indices
-
-    # pick a new reference bus if for some reason there is none (may have been
-    # shut down)
-    if (len(ref) == 0) & (len(pv) > 0):
-        ref = np.zeros(1, dtype=int)
-        ref[0] = pv[0]      # use the first PV bus
-        pv = pv[1:]      # take it off PV list
-    return ref, pv, pq
-
-
-def sub2ind(shape, I, J, row_major=False):
-    """
-    Returns the linear indices of subscripts.
-
-    Parameters
-    ----------
-    shape : tuple
-        Shape of the grid or matrix.
-    I : int
-        Row subscript.
-    J : int
-        Column subscript.
-    row_major : bool, optional
-        If True, uses row-major order (default is False, using column-major order).
-
-    Returns
-    -------
-    ind : int
-        Linear index corresponding to the subscripts (I, J).
-    """
-    if row_major:
-        ind = (I % shape[0]) * shape[1] + (J % shape[1])
-    else:
-        ind = (J % shape[1]) * shape[0] + (I % shape[0])
-
-    return ind.astype(int)
-
-
-def feval(func, *args, **kw_args):
-    """
-    Evaluates the function func using positional arguments args
-    and keyword arguments kw_args.
-
-    Parameters
-    ----------
-    func : str
-        Name of the function to evaluate.
-    *args : list
-        Positional arguments for the function.
-    **kw_args : dict
-        Keyword arguments for the function.
-
-    Returns
-    -------
-    result : any
-        Result of evaluating the function.
-    """
-    return eval(func)(*args, **kw_args)
-
-
-def have_fcn(name):
-    """
-    Checks if a Python module with the given name exists.
-
-    Parameters
-    ----------
-    name : str
-        Name of the Python module.
-
-    Returns
-    -------
-    bool
-        True if the module exists, False otherwise.
-    """
-    try:
-        __import__(name)
-        return True
-    except ImportError:
-        return False
-
-
-def get_reorder(A, idx, dim=0):
-    """
-    Returns A with one of its dimensions indexed::
-
-        B = get_reorder(A, idx, dim)
-
-    Returns A[:, ..., :, idx, :, ..., :], where dim determines
-    in which dimension to place the idx.
-
-    @author: Ray Zimmerman (PSERC Cornell)
-    """
-    ndims = np.ndim(A)
-    if ndims == 1:
-        B = A[idx].copy()
-    elif ndims == 2:
-        if dim == 0:
-            B = A[idx, :].copy()
-        elif dim == 1:
-            B = A[:, idx].copy()
-        else:
-            raise ValueError('dim (%d) may be 0 or 1' % dim)
-    else:
-        raise ValueError('number of dimensions (%d) may be 1 or 2' % dim)
-
-    return B
-
-
-def set_reorder(A, B, idx, dim=0):
-    """
-    Assigns B to A with one of the dimensions of A indexed.
-
-    @return: A after doing A(:, ..., :, IDX, :, ..., :) = B
-    where DIM determines in which dimension to place the IDX.
-
-    @see: L{get_reorder}
-
-    @author: Ray Zimmerman (PSERC Cornell)
-    """
-    A = A.copy()
-    ndims = np.ndim(A)
-    A = A.astype(B.dtype)
-    if ndims == 1:
-        A[idx] = B
-    elif ndims == 2:
-        if dim == 0:
-            A[idx, :] = B
-        elif dim == 1:
-            A[:, idx] = B
-        else:
-            raise ValueError('dim (%d) may be 0 or 1' % dim)
-    else:
-        raise ValueError('number of dimensions (%d) may be 1 or 2' % dim)
-
-    return A
-
-
-def isload(gen):
-    """
-    Checks for dispatchable loads.
-
-    Parameters
-    ----------
-    gen: np.ndarray
-        The generator matrix.
-
-    Returns
-    -------
-    array
-        A column vector of 1's and 0's. The 1's correspond to rows of the
-        C{gen} matrix which represent dispatchable loads. The current test is
-        C{Pmin < 0 and Pmax == 0}. This may need to be revised to allow sensible
-        specification of both elastic demand and pumped storage units.
-    """
-    return (gen[:, IDX.gen.PMIN] < 0) & (gen[:, IDX.gen.PMAX] == 0)
-
-
-def hasPQcap(gen, hilo='B'):
-    """
-    Checks for P-Q capability curve constraints.
-
-    Parameters
-    ----------
-    gen: np.ndarray
-        The generator matrix.
-    hilo : str, optional
-        If 'U' this function returns C{True} only for rows corresponding to
-        generators that require the upper constraint on Q.
-        If 'L', only for those requiring the lower constraint.
-        If not specified or has any other value it returns true for rows
-        corresponding to gens that require either or both of the constraints.
-
-    Returns
-    -------
-    array
-        A column vector of 1's and 0's. The 1's correspond to rows of the
-        C{gen} matrix which correspond to generators which have defined a
-        capability curve (with sloped upper and/or lower bound on Q) and require
-        that additional linear constraints be added to the OPF.
-
-    Notes
-    -----
-        The C{gen} matrix in version 2 of the PYPOWER case format includes columns
-        for specifying a P-Q capability curve for a generator defined as the
-        intersection of two half-planes and the box constraints on P and Q.
-        The two half planes are defined respectively as the area below the line
-        connecting (Pc1, Qc1max) and (Pc2, Qc2max) and the area above the line
-        connecting (Pc1, Qc1min) and (Pc2, Qc2min).
-
-        It is smart enough to return C{True} only if the corresponding linear
-        constraint is not redundant w.r.t the box constraints.
-    """
-    # check for errors capability curve data
-    if np.any(gen[:, IDX.gen.PC1] > gen[:, IDX.gen.PC2]):
-        logger.debug('hasPQcap: Pc1 > Pc2')
-    if np.any(gen[:, IDX.gen.QC2MAX] > gen[:, IDX.gen.QC1MAX]):
-        logger.debug('hasPQcap: Qc2max > Qc1max')
-    if np.any(gen[:, IDX.gen.QC2MIN] < gen[:, IDX.gen.QC1MIN]):
-        logger.debug('hasPQcap: Qc2min < Qc1min')
-
-    L = np.zeros(gen.shape[0], bool)
-    U = np.zeros(gen.shape[0], bool)
-    k = np.nonzero(gen[:, IDX.gen.PC1] != gen[:, IDX.gen.PC2])
-
-    if hilo != 'U':  # include lower constraint
-        Qmin_at_Pmax = gen[k, IDX.gen.QC1MIN] + (gen[k, IDX.gen.PMAX] - gen[k, IDX.gen.PC1]) * (
-            gen[k, IDX.gen.QC2MIN] - gen[k, IDX.gen.QC1MIN]) / (gen[k, IDX.gen.PC2] - gen[k, IDX.gen.PC1])
-        L[k] = Qmin_at_Pmax > gen[k, IDX.gen.QMIN]
-
-    if hilo != 'L':  # include upper constraint
-        Qmax_at_Pmax = gen[k, IDX.gen.QC1MAX] + (gen[k, IDX.gen.PMAX] - gen[k, IDX.gen.PC1]) * (
-            gen[k, IDX.gen.QC2MAX] - gen[k, IDX.gen.QC1MAX]) / (gen[k, IDX.gen.PC2] - gen[k, IDX.gen.PC1])
-        U[k] = Qmax_at_Pmax < gen[k, IDX.gen.QMAX]
-
-    return L | U
-
-
-def fairmax(x):
-    """
-    Same as built-in C{max}, except breaks ties randomly.
-
-    Takes a vector as an argument and returns the same output as the
-    built-in function C{max} with two output parameters, except that
-    where the maximum value occurs at more than one position in the
-    vector, the index is chosen randomly from these positions as opposed
-    to just choosing the first occurance.
-
-    @see: C{max}
-
-    @author: Ray Zimmerman (PSERC Cornell)
-    """
-    val = max(x)  # find max value
-    i = np.nonzero(x == val)  # find all positions where this occurs
-    n = len(i)  # number of occurences
-    idx = i(np.fix(n * np.random()) + 1)  # select index randomly among occurances
-    return val, idx

ams/routines/cpf.py

@@ -1,65 +0,0 @@
-"""
-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/dcpf0.py

@@ -1,196 +0,0 @@
-"""
-DC power flow routines using PYPOWER.
-"""
-import logging
-
-from andes.shared import deg2rad
-from andes.utils.misc import elapsed
-
-from ams.routines.routine import RoutineBase
-from ams.opt import Var
-from ams.pypower import runpf
-from ams.pypower.core import ppoption
-
-from ams.io.pypower import system2ppc
-from ams.core.param import RParam
-
-logger = logging.getLogger(__name__)
-
-
-class DCPF0(RoutineBase):
-    """
-    DC power flow using PYPOWER.
-
-    This class is deprecated as of version 0.9.12 and will be removed in 1.1.0.
-
-    Notes
-    -----
-    1. DCPF is solved with PYPOWER ``runpf`` function.
-    2. DCPF formulation is not complete yet, but this does not affect the
-       results because the data are passed to PYPOWER for solving.
-    """
-
-    def __init__(self, system, config):
-        RoutineBase.__init__(self, system, config)
-        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',
-                        unit='p.u.',
-                        model='Line', src='x',)
-        self.tap = RParam(info="transformer branch tap ratio",
-                          name='tap', tex_name=r't_{ap}',
-                          model='Line', src='tap',
-                          unit='float',)
-        self.phi = RParam(info="transformer branch phase shift in rad",
-                          name='phi', tex_name=r'\phi',
-                          model='Line', src='phi',
-                          unit='radian',)
-
-        # --- load ---
-        self.pd = RParam(info='active deman',
-                         name='pd', tex_name=r'p_{d}',
-                         unit='p.u.',
-                         model='StaticLoad', src='p0')
-        # --- gen ---
-        self.pg = Var(info='Gen active power',
-                      unit='p.u.',
-                      name='pg', tex_name=r'p_{g}',
-                      model='StaticGen', src='p',)
-
-        # --- bus ---
-        self.aBus = Var(info='bus voltage angle',
-                        unit='rad',
-                        name='aBus', tex_name=r'a_{Bus}',
-                        model='Bus', src='a',)
-
-        # --- line flow ---
-        self.plf = Var(info='Line flow',
-                       unit='p.u.',
-                       name='plf', tex_name=r'p_{lf}',
-                       model='Line',)
-
-    def unpack(self, res):
-        """
-        Unpack results from PYPOWER.
-        """
-        system = self.system
-        mva = res['baseMVA']
-
-        # --- copy results from ppc into system algeb ---
-        # --- Bus ---
-        system.Bus.v.v = res['bus'][:, 7]               # voltage magnitude
-        system.Bus.a.v = res['bus'][:, 8] * deg2rad     # voltage angle
-
-        # --- PV ---
-        system.PV.p.v = res['gen'][system.Slack.n:, 1] / mva        # active power
-        system.PV.q.v = res['gen'][system.Slack.n:, 2] / mva        # reactive power
-
-        # --- Slack ---
-        system.Slack.p.v = res['gen'][:system.Slack.n, 1] / mva     # active power
-        system.Slack.q.v = res['gen'][:system.Slack.n, 2] / mva     # reactive power
-
-        # --- Line ---
-        self.plf.optz.value = res['branch'][:, 13] / mva  # line flow
-
-        # --- copy results from system algeb into routine algeb ---
-        for vname, var in self.vars.items():
-            owner = getattr(system, var.model)  # instance of owner, Model or Group
-            if var.src is None:          # skip if no source variable is specified
-                continue
-            elif hasattr(owner, 'group'):   # if owner is a Model instance
-                grp = getattr(system, owner.group)
-                idx = grp.get_all_idxes()
-            elif hasattr(owner, 'get_idx'):  # if owner is a Group instance
-                idx = owner.get_all_idxes()
-            else:
-                msg = f"Failed to find valid source variable `{owner.class_name}.{var.src}` for "
-                msg += f"{self.class_name}.{vname}, skip unpacking."
-                logger.warning(msg)
-                continue
-            try:
-                logger.debug(f"Unpacking {vname} into {owner.class_name}.{var.src}.")
-                var.optz.value = owner.get(src=var.src, attr='v', idx=idx)
-            except AttributeError:
-                logger.debug(f"Failed to unpack {vname} into {owner.class_name}.{var.src}.")
-                continue
-        self.system.recent = self.system.routines[self.class_name]
-        return True
-
-    def solve(self, method=None):
-        """
-        Solve DC power flow using PYPOWER.
-        """
-        ppc = system2ppc(self.system)
-        ppopt = ppoption(PF_DC=True)
-
-        res, sstats = runpf(casedata=ppc, ppopt=ppopt)
-        return res, sstats
-
-    def run(self, **kwargs):
-        """
-        Run DC pwoer flow.
-        *args and **kwargs go to `self.solve()`, which are not used yet.
-
-        Examples
-        --------
-        >>> ss = ams.load(ams.get_case('matpower/case14.m'))
-        >>> ss.DCPF.run()
-
-        Parameters
-        ----------
-        method : str
-            Placeholder for future use.
-
-        Returns
-        -------
-        exit_code : int
-            Exit code of the routine.
-        """
-        if not self.initialized:
-            self.init()
-        t0, _ = elapsed()
-
-        res, sstats = 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])
-        n_iter = int(sstats['num_iters'])
-        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}> solved in {s}, converged in "
-            msg += n_iter_str + f"with {sstats['solver_name']}."
-            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 in "
-            msg += f"{int(sstats['num_iters'])} iterations with "
-            msg += f"{sstats['solver_name']}!"
-            logger.warning(msg)
-            return False
-
-    def summary(self, **kwargs):
-        """
-        # TODO: Print power flow summary.
-        """
-        raise NotImplementedError
-
-    def enable(self, name):
-        raise NotImplementedError
-
-    def disable(self, name):
-        raise NotImplementedError

ams/routines/pflow0.py

@@ -1,113 +0,0 @@
-"""
-Power flow routines using PYPOWER.
-"""
-import logging
-from collections import OrderedDict
-
-from ams.pypower import runpf
-
-from ams.io.pypower import system2ppc
-from ams.pypower.core import ppoption
-from ams.core.param import RParam
-
-from ams.routines.dcpf0 import DCPF0
-from ams.opt import Var
-
-logger = logging.getLogger(__name__)
-
-
-class PFlow0(DCPF0):
-    """
-    AC Power Flow using PYPOWER.
-
-    This class is deprecated as of version 0.9.12 and will be removed in 1.1.0.
-
-    Notes
-    -----
-    1. AC pwoer flow is solved with PYPOWER ``runpf`` function.
-    2. AC power flow 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 Power Flow"
-        self.type = "PF"
-
-        self.config.add(OrderedDict((('qlim', 0),
-                                     )))
-        self.config.add_extra("_help",
-                              qlim="Enforce generator q limits",
-                              )
-        self.config.add_extra("_alt",
-                              qlim=(0, 1, 2),
-                              )
-
-        self.qd = RParam(info="reactive power load in system base",
-                         name="qd", tex_name=r"q_{d}",
-                         unit="p.u.",
-                         model="StaticLoad", src="q0",)
-
-        # --- bus ---
-        self.vBus = Var(info="bus voltage magnitude",
-                        unit="p.u.",
-                        name="vBus", tex_name=r"v_{Bus}",
-                        model="Bus", src="v",)
-        # --- gen ---
-        self.qg = Var(info="reactive power generation",
-                      unit="p.u.",
-                      name="qg", tex_name=r"q_{g}",
-                      model="StaticGen", src="q",)
-        # NOTE: omit AC power flow formulation here
-
-    def solve(self, method="newton", **kwargs):
-        """
-        Solve the AC power flow using PYPOWER.
-        """
-        ppc = system2ppc(self.system)
-
-        method_map = dict(newton=1, fdxb=2, fdbx=3, gauss=4)
-        alg = method_map.get(method)
-        if alg == 4:
-            msg = "Gauss method is not fully tested yet, not recommended!"
-            logger.warning(msg)
-        if alg is None:
-            msg = f"Invalid method `{method}` for PFlow."
-            raise ValueError(msg)
-        ppopt = ppoption(PF_ALG=alg, ENFORCE_Q_LIMS=self.config.qlim, **kwargs)
-
-        res, sstats = runpf(casedata=ppc, ppopt=ppopt)
-        return res, sstats
-
-    def run(self, **kwargs):
-        """
-        Run AC power flow using PYPOWER.
-
-        Currently, four methods are supported: 'newton', 'fdxb', 'fdbx', 'gauss',
-        for Newton's method, fast-decoupled, XB, fast-decoupled, BX, and Gauss-Seidel,
-        respectively.
-
-        Note that gauss method is not recommended because it seems to be much
-        more slower than the other three methods and not fully tested yet.
-
-        Examples
-        --------
-        >>> ss = ams.load(ams.get_case('matpower/case14.m'))
-        >>> ss.PFlow.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.
-        """
-        return super().run(**kwargs,)