ltbams 0.9.9__py3-none-any.whl → 1.0.2a1__py3-none-any.whl

ams/opt/param.py

@@ -0,0 +1,156 @@
+"""
+Module for optimization Param.
+"""
+import logging
+
+from typing import Optional
+from collections import OrderedDict
+import re
+
+import numpy as np
+
+from andes.core.common import Config
+
+import cvxpy as cp
+
+from ams.shared import sps
+
+from ams.opt import OptzBase, ensure_symbols, ensure_mats_and_parsed
+
+logger = logging.getLogger(__name__)
+
+
+class Param(OptzBase):
+    """
+    Base class for parameters used in a routine.
+
+    Parameters
+    ----------
+    no_parse: bool, optional
+        True to skip parsing the parameter.
+    nonneg: bool, optional
+        True to set the parameter as non-negative.
+    nonpos: bool, optional
+        True to set the parameter as non-positive.
+    cplx: bool, optional
+        True to set the parameter as complex, avoiding the use of `complex`.
+    imag: bool, optional
+        True to set the parameter as imaginary.
+    symmetric: bool, optional
+        True to set the parameter as symmetric.
+    diag: bool, optional
+        True to set the parameter as diagonal.
+    hermitian: bool, optional
+        True to set the parameter as hermitian.
+    boolean: bool, optional
+        True to set the parameter as boolean.
+    integer: bool, optional
+        True to set the parameter as integer.
+    pos: bool, optional
+        True to set the parameter as positive.
+    neg: bool, optional
+        True to set the parameter as negative.
+    sparse: bool, optional
+        True to set the parameter as sparse.
+    """
+
+    def __init__(self,
+                 name: Optional[str] = None,
+                 info: Optional[str] = None,
+                 unit: Optional[str] = None,
+                 no_parse: Optional[bool] = False,
+                 nonneg: Optional[bool] = False,
+                 nonpos: Optional[bool] = False,
+                 cplx: Optional[bool] = False,
+                 imag: Optional[bool] = False,
+                 symmetric: Optional[bool] = False,
+                 diag: Optional[bool] = False,
+                 hermitian: Optional[bool] = False,
+                 boolean: Optional[bool] = False,
+                 integer: Optional[bool] = False,
+                 pos: Optional[bool] = False,
+                 neg: Optional[bool] = False,
+                 sparse: Optional[bool] = False,
+                 ):
+        OptzBase.__init__(self, name=name, info=info, unit=unit)
+        self.no_parse = no_parse  # True to skip parsing the parameter
+        self.sparse = sparse
+
+        self.config = Config(name=self.class_name)  # `config` that can be exported
+
+        self.config.add(OrderedDict((('nonneg', nonneg),
+                                     ('nonpos', nonpos),
+                                     ('complex', cplx),
+                                     ('imag', imag),
+                                     ('symmetric', symmetric),
+                                     ('diag', diag),
+                                     ('hermitian', hermitian),
+                                     ('boolean', boolean),
+                                     ('integer', integer),
+                                     ('pos', pos),
+                                     ('neg', neg),
+                                     )))
+
+    @ensure_symbols
+    def parse(self):
+        """
+        Parse the parameter.
+
+        Returns
+        -------
+        bool
+            Returns True if the parsing is successful, False otherwise.
+        """
+        sub_map = self.om.rtn.syms.sub_map
+        code_param = "param(**config)"
+        for pattern, replacement, in sub_map.items():
+            try:
+                code_param = re.sub(pattern, replacement, code_param)
+            except Exception as e:
+                raise Exception(f"Error in parsing param <{self.name}>.\n{e}")
+        self.code = code_param
+        return True
+
+    @ensure_mats_and_parsed
+    def evaluate(self):
+        """
+        Evaluate the parameter.
+        """
+        if self.no_parse:
+            return True
+
+        config = self.config.as_dict()
+        try:
+            msg = f"Parameter <{self.name}> is set as sparse, "
+            msg += "but the value is not sparse."
+            if self.sparse:
+                self.v = sps.csr_matrix(self.v)
+
+            # Create the cvxpy.Parameter object
+            if isinstance(self.v, np.ndarray):
+                self.optz = cp.Parameter(shape=self.v.shape, **config)
+            else:
+                self.optz = cp.Parameter(**config)
+            self.optz.value = self.v
+        except ValueError:
+            msg = f"Parameter <{self.name}> has non-numeric value, "
+            msg += "set `no_parse=True`."
+            logger.warning(msg)
+            self.no_parse = True
+            return True
+        except Exception as e:
+            raise Exception(f"Error in evaluating Param <{self.name}>.\n{e}")
+        return True
+
+    def update(self):
+        """
+        Update the Parameter value.
+        """
+        # NOTE: skip no_parse parameters
+        if self.optz is None:
+            return None
+        self.optz.value = self.v
+        return True
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}: {self.name}'

ams/opt/var.py

@@ -0,0 +1,233 @@
+"""
+Module for optimization Var.
+"""
+import logging
+
+from typing import Optional, Union
+from collections import OrderedDict
+import re
+
+import numpy as np
+
+from andes.core.common import Config
+
+import cvxpy as cp
+
+from ams.utils import pretty_long_message
+from ams.shared import _prefix, _max_length
+
+from ams.opt import OptzBase, ensure_symbols, ensure_mats_and_parsed
+
+logger = logging.getLogger(__name__)
+
+
+class Var(OptzBase):
+    """
+    Base class for variables used in a routine.
+
+    When `horizon` is provided, the variable will be expanded to a matrix,
+    where rows are indexed by the source variable index and columns are
+    indexed by the horizon index.
+
+    Parameters
+    ----------
+    info : str, optional
+        Descriptive information
+    unit : str, optional
+        Unit
+    tex_name : str
+        LaTeX-formatted variable symbol. Defaults to the value of ``name``.
+    name : str, optional
+        Variable name. One should typically assigning the name directly because
+        it will be automatically assigned by the model. The value of ``name``
+        will be the symbol name to be used in expressions.
+    src : str, optional
+        Source variable name. Defaults to the value of ``name``.
+    model : str, optional
+        Name of the owner model or group.
+    horizon : ams.routines.RParam, optional
+        Horizon idx.
+    nonneg : bool, optional
+        Non-negative variable
+    nonpos : bool, optional
+        Non-positive variable
+    cplx : bool, optional
+        Complex variable
+    imag : bool, optional
+        Imaginary variable
+    symmetric : bool, optional
+        Symmetric variable
+    diag : bool, optional
+        Diagonal variable
+    psd : bool, optional
+        Positive semi-definite variable
+    nsd : bool, optional
+        Negative semi-definite variable
+    hermitian : bool, optional
+        Hermitian variable
+    boolean : bool, optional
+        Boolean variable
+    integer : bool, optional
+        Integer variable
+    pos : bool, optional
+        Positive variable
+    neg : bool, optional
+        Negative variable
+
+    Attributes
+    ----------
+    a : np.ndarray
+        Variable address.
+    _v : np.ndarray
+        Local-storage of the variable value.
+    rtn : ams.routines.Routine
+        The owner routine instance.
+    """
+
+    def __init__(self,
+                 name: Optional[str] = None,
+                 tex_name: Optional[str] = None,
+                 info: Optional[str] = None,
+                 src: Optional[str] = None,
+                 unit: Optional[str] = None,
+                 model: Optional[str] = None,
+                 shape: Optional[Union[tuple, int]] = None,
+                 v0: Optional[str] = None,
+                 horizon: Optional[str] = None,
+                 nonneg: Optional[bool] = False,
+                 nonpos: Optional[bool] = False,
+                 cplx: Optional[bool] = False,
+                 imag: Optional[bool] = False,
+                 symmetric: Optional[bool] = False,
+                 diag: Optional[bool] = False,
+                 psd: Optional[bool] = False,
+                 nsd: Optional[bool] = False,
+                 hermitian: Optional[bool] = False,
+                 boolean: Optional[bool] = False,
+                 integer: Optional[bool] = False,
+                 pos: Optional[bool] = False,
+                 neg: Optional[bool] = False,
+                 ):
+        self.name = name
+        self.info = info
+        self.unit = unit
+
+        self.tex_name = tex_name if tex_name else name
+        # variable internal index inside a model (assigned in run time)
+        self.id = None
+        OptzBase.__init__(self, name=name, info=info, unit=unit, model=model)
+        self.src = src
+        self.v0 = v0
+        self.horizon = horizon
+        self._shape = shape
+        self._v = None
+        self.a: np.ndarray = np.array([], dtype=int)
+
+        self.config = Config(name=self.class_name)  # `config` that can be exported
+
+        self.config.add(OrderedDict((('nonneg', nonneg),
+                                     ('nonpos', nonpos),
+                                     ('complex', cplx),
+                                     ('imag', imag),
+                                     ('symmetric', symmetric),
+                                     ('diag', diag),
+                                     ('psd', psd),
+                                     ('nsd', nsd),
+                                     ('hermitian', hermitian),
+                                     ('boolean', boolean),
+                                     ('integer', integer),
+                                     ('pos', pos),
+                                     ('neg', neg),
+                                     )))
+
+    @property
+    def v(self):
+        """
+        Return the CVXPY variable value.
+        """
+        if self.optz is None:
+            return None
+        if self.optz.value is None:
+            try:
+                shape = self.optz.shape
+                return np.zeros(shape)
+            except AttributeError:
+                return None
+        else:
+            return self.optz.value
+
+    @v.setter
+    def v(self, value):
+        if self.optz is None:
+            logger.info(f"Variable <{self.name}> is not initialized yet.")
+        else:
+            self.optz.value = value
+
+    @ensure_symbols
+    def parse(self):
+        """
+        Parse the variable.
+        """
+        sub_map = self.om.rtn.syms.sub_map
+        # NOTE: number of rows is the size of the source variable
+        if self.owner is not None:
+            nr = self.owner.n
+            nc = 0
+            if self.horizon:
+                # NOTE: numer of columns is the horizon if exists
+                nc = int(self.horizon.n)
+                shape = (nr, nc)
+            else:
+                shape = (nr,)
+        elif isinstance(self._shape, int):
+            shape = (self._shape,)
+            nr = shape
+            nc = 0
+        elif isinstance(self._shape, tuple):
+            shape = self._shape
+            nr = shape[0]
+            nc = shape[1] if len(shape) > 1 else 0
+        else:
+            raise ValueError(f"Invalid shape {self._shape}.")
+        code_var = f"var({shape}, **config)"
+        logger.debug(f" - Var <{self.name}>: {self.code}")
+        for pattern, replacement, in sub_map.items():
+            try:
+                code_var = re.sub(pattern, replacement, code_var)
+            except Exception as e:
+                raise Exception(f"Error in parsing var <{self.name}>.\n{e}")
+        self.code = code_var
+        return True
+
+    @ensure_mats_and_parsed
+    def evaluate(self):
+        """
+        Evaluate the variable.
+
+        Returns
+        -------
+        bool
+            Returns True if the evaluation is successful, False otherwise.
+        """
+        # NOTE: in CVXPY, Config only allow lower case letters
+        config = {}  # used in `self.code`
+        for k, v in self.config.as_dict().items():
+            if k == 'psd':
+                config['PSD'] = v
+            elif k == 'nsd':
+                config['NSD'] = v
+            elif k == 'bool':
+                config['boolean'] = v
+            else:
+                config[k] = v
+        msg = f" - Var <{self.name}>: {self.code}"
+        logger.debug(pretty_long_message(msg, _prefix, max_length=_max_length))
+        try:
+            local_vars = {'self': self, 'config': config, 'cp': cp}
+            self.optz = eval(self.code, {}, local_vars)
+        except Exception as e:
+            raise Exception(f"Error in evaluating Var <{self.name}>.\n{e}")
+        return True
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}: {self.owner.__class__.__name__}.{self.name}'

ams/pypower/__init__.py

@@ -0,0 +1,8 @@
+"""
+Revised PYPOWER module.
+"""
+
+from ams.pypower import utils, make, routines  # NOQA
+from ams.pypower.routines.opf import runopf, runuopf  # NOQA
+from ams.pypower.routines import runpf  # NOQA
+from ams.pypower.routines.cpf import runcpf  # NOQA

ams/pypower/_compat.py

@@ -0,0 +1,9 @@
+
+"""
+Compatibility helpers for older Python versions.
+
+"""
+import sys
+
+
+PY2 = sys.version_info[0] == 2

ams/pypower/core/__init__.py

@@ -0,0 +1,8 @@
+"""
+Module for the core of PYPOWER.
+"""
+
+from ams.pypower.core.ppoption import ppoption  # NOQA
+from ams.pypower.core.pips import pips, pipsver, pipsopf_solver  # NOQA
+from ams.pypower.core.ppver import ppver  # NOQA
+from ams.pypower.core.solver import ipoptopf_solver  # NOQA