ltbams 0.9.10__tar.gz → 0.9.11__tar.gz

{ltbams-0.9.10 → ltbams-0.9.11}/LICENSE

@@ -670,7 +670,7 @@ Also add information on how to contact you by electronic and paper mail.
   If the program does terminal interaction, make it output a short
 notice like this when it starts in an interactive mode:
 
-    AMS  Copyright (C) 2023 Jinning Wang
+    AMS  Copyright (C) 2023 - 2024 Jinning Wang
     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
     This is free software, and you are welcome to redistribute it
     under certain conditions; type `show c' for details.

ltbams-0.9.11/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: ltbams
+Version: 0.9.11
+Summary: UNKNOWN
+Home-page: UNKNOWN
+License: UNKNOWN
+Platform: UNKNOWN
+License-File: LICENSE
+
+UNKNOWN
+

{ltbams-0.9.10 → ltbams-0.9.11}/README.md

@@ -4,7 +4,7 @@ Python Software for Power System Scheduling Modeling and Co-Simulation with Dyna
 
 [![License: GPL-3.0](https://img.shields.io/badge/License-GPL--3.0-blue.svg)](https://github.com/CURENT/ams/blob/master/LICENSE)
 ![platforms](https://anaconda.org/conda-forge/ltbams/badges/platforms.svg)
-[![Python Versions](https://img.shields.io/badge/Python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)](https://www.python.org/)
+[![Python Versions](https://img.shields.io/badge/Python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)](https://www.python.org/)
 ![Repo Size](https://img.shields.io/github/repo-size/CURENT/ams)
 [![GitHub last commit (master)](https://img.shields.io/github/last-commit/CURENT/ams/master?label=last%20commit%20to%20master)](https://github.com/CURENT/ams/commits/master/)
 [![GitHub last commit (develop)](https://img.shields.io/github/last-commit/CURENT/ams/develop?label=last%20commit%20to%20develop)](https://github.com/CURENT/ams/commits/develop/)
@@ -82,6 +82,19 @@ Install from GitHub source:
 pip install git+https://github.com/CURENT/ams.git
 ```
 
+# Example Usage
+
+Using AMS to run a Real-Time Economic Dispatch (RTED) simulation:
+
+```python
+import ams
+
+ss = ams.load(ams.get_case('ieee14_uced.xlsx'))
+ss.RTED.run()
+
+print(ss.RTED.pg.v)
+```
+
 # Sponsors and Contributors
 AMS is the scheduling simulation engine for the CURENT Largescale Testbed (LTB).
 More information about CURENT LTB can be found at the [LTB Repository][LTB Repository].

ltbams-0.9.11/ams/__init__.py

@@ -0,0 +1,13 @@
+from . import _version
+__version__ = _version.get_versions()['version']
+
+from ams import benchmarks  # NOQA
+
+from ams.main import config_logger, load, run  # NOQA
+from ams.system import System  # NOQA
+from ams.utils.paths import get_case, list_cases  # NOQA
+from ams.shared import ppc2df  # NOQA
+
+__author__ = 'Jining Wang'
+
+__all__ = ['System', 'get_case', 'System']

{ltbams-0.9.10 → ltbams-0.9.11}/ams/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-09-03T22:41:38-0400",
+ "date": "2024-11-14T16:34:57-0500",
  "dirty": false,
  "error": null,
- "full-revisionid": "8bc9504a8281c16236c73decd8e7365b682c706c",
- "version": "0.9.10"
+ "full-revisionid": "9dcd290dc6532149fcd0b4f26fb5e9af4bf4bf36",
+ "version": "0.9.11"
 }
 '''  # END VERSION_JSON
 

ltbams-0.9.11/ams/benchmarks.py

@@ -0,0 +1,302 @@
+"""
+Benchmark functions.
+"""
+
+import datetime
+import sys
+import importlib.metadata as importlib_metadata
+import logging
+
+try:
+    import pandapower as pdp
+    PANDAPOWER_AVAILABLE = True
+except ImportError:
+    PANDAPOWER_AVAILABLE = False
+    logging.warning("pandapower is not available. Some functionalities will be disabled.")
+
+from andes.utils.misc import elapsed
+
+import ams
+
+logger = logging.getLogger(__name__)
+
+_failed_time = -1
+_failed_obj = -1
+
+cols_pre = ['ams_mats', 'ams_parse', 'ams_eval', 'ams_final', 'ams_postinit']
+
+
+def get_tool_versions(tools=None):
+    """
+    Get the current time, Python version, and versions of specified tools.
+
+    Parameters
+    ----------
+    tools : list of str, optional
+        List of tool names to check versions. If None, a default list of tools is used.
+
+    Returns
+    -------
+    dict
+        A dictionary containing the tool names and their versions.
+    """
+    if tools is None:
+        tools = ['ltbams', 'andes', 'cvxpy',
+                 'gurobipy', 'mosek', 'piqp',
+                 'pandapower', 'numba']
+
+    # Get current time and Python version
+    last_run_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    python_version = sys.version
+
+    # Collect tool versions
+    tool_versions = {}
+    for tool in tools:
+        try:
+            version = importlib_metadata.version(tool)
+            tool_versions[tool] = version
+        except importlib_metadata.PackageNotFoundError:
+            logger.error(f"Package {tool} not found.")
+            tool_versions[tool] = "Not installed"
+
+    # Print the results in a formatted way
+    logger.warning(f"Last run time: {last_run_time}")
+    logger.warning(f"Python: {python_version}\n")
+
+    # Calculate the width of the columns
+    max_tool_length = max(len(tool) for tool in tool_versions)
+    max_version_length = max(len(version) for version in tool_versions.values())
+
+    # Print the header
+    logger.warning(f"{'Tool':<{max_tool_length}}  {'Version':<{max_version_length}}")
+    logger.warning(f"{'-' * max_tool_length}  {'-' * max_version_length}")
+
+    # Print each tool and its version
+    for tool, version in tool_versions.items():
+        logger.warning(f"{tool:<{max_tool_length}}  {version:<{max_version_length}}")
+
+    return tool_versions
+
+
+def time_routine_solve(system, routine='DCOPF', **kwargs):
+    """
+    Run the specified routine with the given solver and method.
+
+    Parameters
+    ----------
+    system : ams.System
+        The system object containing the routine.
+    routine : str, optional
+        The name of the routine to run. Defaults to 'DCOPF'.
+
+    Other Parameters
+    ----------------
+    solver : str, optional
+        The solver to use.
+    ignore_dpp : bool, optional
+        Whether to ignore DPP. Defaults to True.
+
+    Returns
+    -------
+    tuple
+        A tuple containing the elapsed time (s) and the objective value ($).
+    """
+    rtn = system.routines[routine]
+    solver = kwargs.get('solver', None)
+    try:
+        t, _ = elapsed()
+        rtn.run(**kwargs)
+        _, s0 = elapsed(t)
+        elapsed_time = float(s0.split(' ')[0])
+        obj_value = rtn.obj.v
+    except Exception as e:
+        logger.error(f"Error running routine {routine} with solver {solver}: {e}")
+        elapsed_time = _failed_time
+        obj_value = _failed_obj
+    return elapsed_time, obj_value
+
+
+def pre_solve(system, routine):
+    """
+    Time the routine preparation process.
+
+    Parameters
+    ----------
+    system : ams.System
+        The system object containing the routine.
+    routine : str
+        The name of the routine to prepare
+
+    Returns
+    -------
+    dict
+        A dictionary containing the preparation times in seconds for each step:
+        'mats', 'parse', 'evaluate', 'finalize', 'postinit'.
+    """
+    rtn = system.routines[routine]
+
+    # Initialize AMS
+    # --- matrices build ---
+    t_mats, _ = elapsed()
+    system.mats.build(force=True)
+    _, s_mats = elapsed(t_mats)
+
+    # --- code generation ---
+    t_parse, _ = elapsed()
+    rtn.om.parse(force=True)
+    _, s_parse = elapsed(t_parse)
+
+    # --- code evaluation ---
+    t_evaluate, _ = elapsed()
+    rtn.om.evaluate(force=True)
+    _, s_evaluate = elapsed(t_evaluate)
+
+    # --- problem finalization ---
+    t_finalize, _ = elapsed()
+    rtn.om.finalize(force=True)
+    _, s_finalize = elapsed(t_finalize)
+
+    # --- rest init process ---
+    t_postinit, _ = elapsed()
+    rtn.init()
+    _, s_postinit = elapsed(t_postinit)
+
+    s_float = [float(s.split(' ')[0]) for s in [s_mats, s_parse, s_evaluate, s_finalize, s_postinit]]
+
+    pre_time = dict(zip(cols_pre, s_float))
+    return pre_time
+
+
+def time_pdp_dcopf(ppn):
+    """
+    Test the execution time of DCOPF using pandapower.
+
+    Parameters
+    ----------
+    ppn : pandapowerNet
+        The pandapower network object.
+
+    Returns
+    -------
+    tuple
+        A tuple containing the elapsed time (s) and the objective value ($).
+    """
+    try:
+        t_pdp, _ = elapsed()
+        pdp.rundcopp(ppn)
+        _, s_pdp = elapsed(t_pdp)
+        elapsed_time = float(s_pdp.split(' ')[0])
+        obj_value = ppn.res_cost
+    except Exception as e:
+        logger.error(f"Error running pandapower: {e}")
+        elapsed_time = _failed_time
+        obj_value = _failed_obj
+    return elapsed_time, obj_value
+
+
+def time_routine(system, routine='DCOPF', solvers=['CLARABEL'],
+                 **kwargs):
+    """
+    Time the specified routine with the given solvers.
+
+    Parameters
+    ----------
+    system : ams.System
+        The system object containing the routine.
+    routine : str, optional
+        The name of the routine to run. Defaults to 'DCOPF'.
+    solvers : list of str, optional
+        List of solvers to use. Defaults to ['CLARABEL'].
+
+    Other Parameters
+    ----------------
+    ignore_dpp : bool, optional
+        Whether to ignore DPP. Defaults to True.
+
+    Returns
+    -------
+    tuple
+        A tuple containing the preparation times and the solution times in
+        seconds for each solver.
+    """
+    pre_time = pre_solve(system, routine)
+    sol = {f'{solver}': {'time': 0, 'obj': 0} for solver in solvers}
+
+    for solver in solvers:
+        if solver != 'pandapower':
+            s, obj = time_routine_solve(system, routine, solver=solver, **kwargs)
+            sol[solver]['time'] = s
+            sol[solver]['obj'] = obj
+        elif solver == 'pandapower' and PANDAPOWER_AVAILABLE and routine == 'DCOPF':
+            ppc = ams.io.pypower.system2ppc(system)
+            ppn = pdp.converter.from_ppc(ppc, f_hz=system.config.freq)
+            s, obj = time_pdp_dcopf(ppn)
+            sol[solver]['time'] = s
+            sol[solver]['obj'] = obj
+        else:
+            sol[solver]['time'] = _failed_time
+            sol[solver]['obj'] = _failed_obj
+
+    return pre_time, sol
+
+
+def time_dcopf_with_lf(system, solvers=['CLARABEL'], load_factors=[1], ignore_dpp=False):
+    """
+    Time the execution of DCOPF with varying load factors.
+
+    Parameters
+    ----------
+    system : ams.System
+        The system object containing the routine.
+    solvers : list of str, optional
+        List of solvers to use. Defaults to ['CLARABEL'].
+    load_factors : list of float, optional
+        List of load factors to apply. Defaults to None.
+    ignore_dpp : bool, optional
+        Whether to ignore DPP.
+
+    Returns
+    -------
+    tuple
+        A tuple containing the list of times and the list of objective values.
+    """
+    pre_time = pre_solve(system, 'DCOPF')
+    sol = {f'{solver}': {'time': 0, 'obj': 0} for solver in solvers}
+
+    pd0 = system.PQ.p0.v.copy()
+    pq_idx = system.PQ.idx.v
+
+    for solver in solvers:
+        if solver != 'pandapower':
+            obj_all = 0
+            t_all, _ = elapsed()
+            for lf_k in load_factors:
+                system.PQ.set(src='p0', attr='v', idx=pq_idx, value=lf_k * pd0)
+                system.DCOPF.update(params=['pd'])
+                _, obj = time_routine_solve(system, 'DCOPF',
+                                            solver=solver, ignore_dpp=ignore_dpp)
+                obj_all += obj
+            _, s_all = elapsed(t_all)
+            system.PQ.set(src='p0', attr='v', idx=pq_idx, value=pd0)
+            s = float(s_all.split(' ')[0])
+            sol[solver]['time'] = s
+            sol[solver]['obj'] = obj_all
+        elif solver == 'pandapower' and PANDAPOWER_AVAILABLE:
+            ppc = ams.io.pypower.system2ppc(system)
+            ppn = pdp.converter.from_ppc(ppc, f_hz=system.config.freq)
+            p_mw0 = ppn.load['p_mw'].copy()
+            t_all, _ = elapsed()
+            obj_all = 0
+            for lf_k in load_factors:
+                ppn.load['p_mw'] = lf_k * p_mw0
+                _, obj = time_pdp_dcopf(ppn)
+                obj_all += obj
+            _, s_all = elapsed(t_all)
+            s = float(s_all.split(' ')[0])
+            sol[solver]['time'] = s
+            sol[solver]['obj'] = obj_all
+        else:
+            sol[solver]['time'] = _failed_time
+            sol[solver]['obj'] = _failed_obj
+
+    return pre_time, sol

{ltbams-0.9.10 → ltbams-0.9.11}/ams/cli.py

@@ -29,6 +29,12 @@ def create_parser():
     -------
     argparse.ArgumentParser
         Parser with all AMS options
+
+    Notes
+    -----
+    Revised from the ANDES project (https://github.com/CURENT/andes).
+    Original author: Hantao Cui
+    License: GPL3
     """
 
     parser = argparse.ArgumentParser()

{ltbams-0.9.10 → ltbams-0.9.11}/ams/core/matprocessor.py

@@ -10,11 +10,11 @@ from typing import Optional
 import numpy as np
 
 from andes.thirdparty.npfunc import safe_div
-from andes.shared import pd, tqdm, tqdm_nb
+from andes.shared import tqdm, tqdm_nb
 from andes.utils.misc import elapsed, is_notebook
 
 from ams.opt.omodel import Param
-from ams.shared import sps
+from ams.shared import pd, sps
 
 logger = logging.getLogger(__name__)
 
@@ -186,19 +186,33 @@ class MatProcessor:
                            info='Line outage distribution factor',
                            v=None, sparse=False, owner=self)
 
-    def build(self):
+    def build(self, force=False):
         """
         Build the system matrices.
         It build connectivity matrices first: Cg, Cl, Csh, Cft, and CftT.
         Then build bus matrices: Bf, Bbus, Pfinj, and Pbusinj.
 
+        Parameters
+        ----------
+        force : bool, optional
+            If True, force to rebuild the matrices. Default is False.
+
+        Notes
+        -----
+        Generator online status is NOT considered in its connectivity matrix.
+        The same applies for load, line, and shunt.
+
         Returns
         -------
         initialized : bool
             True if the matrices are built successfully.
         """
-        t_mat, _ = elapsed()
+        if not force and self.initialized:
+            logger.debug("System matrices are already built.")
+            return self.initialized
 
+        t_mat, _ = elapsed()
+        logger.warning("Building system matrices")
         # --- connectivity matrices ---
         _ = self.build_cg()
         _ = self.build_cl()
@@ -212,7 +226,7 @@ class MatProcessor:
         _ = self.build_pbusinj()
         _, s_mat = elapsed(t_mat)
 
-        logger.debug(f"Built system matrices in {s_mat}.")
+        logger.debug(f" -> System matrices built in {s_mat}")
         self.initialized = True
         return self.initialized
 

{ltbams-0.9.10 → ltbams-0.9.11}/ams/core/param.py

@@ -139,7 +139,6 @@ class RParam(Param):
         self.expand_dims = expand_dims
         self.no_parse = no_parse
         self.owner = None  # instance of the owner model or group
-        self.rtn = None  # instance of the owner routine
         self.is_ext = False  # indicate if the value is set externally
         self._v = None  # external value
         if v is not None:
@@ -197,7 +196,12 @@ class RParam(Param):
         """
         Return the shape of the parameter.
         """
-        return np.shape(self.v)
+        if self.is_ext:
+            return np.shape(self._v)
+        elif self.no_parse:
+            return None
+        else:
+            return np.shape(self.v)
 
     @property
     def dtype(self):

{ltbams-0.9.10 → ltbams-0.9.11}/ams/core/service.py

@@ -178,7 +178,7 @@ class ROperationService(RBaseService):
 
 class LoadScale(ROperationService):
     """
-    Return load.
+    Get zonal load by scale nodal load given the corresponding load scale factor.
 
     Parameters
     ----------
@@ -218,11 +218,12 @@ class LoadScale(ROperationService):
     def v(self):
         sys = self.rtn.system
         u_idx = self.u.get_idx()
+        ue = self.u.owner.get(src='u', attr='v', idx=u_idx)
         u_bus = self.u.owner.get(src='bus', attr='v', idx=u_idx)
         u_zone = sys.Bus.get(src='zone', attr='v', idx=u_bus)
         u_yloc = np.array(sys.Region.idx2uid(u_zone))
         p0s = np.multiply(self.sd.v[:, u_yloc].transpose(),
-                          self.u.v[:, np.newaxis])
+                          (ue * self.u.v)[:, np.newaxis])
         if self.sparse:
             return spr.csr_matrix(p0s)
         return p0s

{ltbams-0.9.10 → ltbams-0.9.11}/ams/core/symprocessor.py

@@ -9,6 +9,7 @@ from collections import OrderedDict
 
 import sympy as sp
 
+from andes.utils.misc import elapsed
 from ams.core.matprocessor import MatProcessor
 
 logger = logging.getLogger(__name__)
@@ -85,6 +86,8 @@ class SymProcessor:
 
         # mapping dict for evaluating expressions
         self.val_map = OrderedDict([
+            (r'(== 0|<= 0)$', ''),  # remove the comparison operator
+            (r'cp\.(Minimize|Maximize)', r'float'),  # remove cp.Minimize/Maximize
             (r'\bcp.\b', 'np.'),
         ])
 
@@ -107,9 +110,12 @@ class SymProcessor:
         """
         Generate symbols for all variables.
         """
-        if not force_generate and self.parent._syms:
+        logger.debug(f'Entering symbol generation for <{self.parent.class_name}>')
+
+        if (not force_generate) and self.parent._syms:
+            logger.debug(' - Symbols already generated')
             return True
-        logger.debug(f'- Generating symbols for {self.parent.class_name}')
+        t, _ = elapsed()
 
         # process tex_names defined in routines
         # -----------------------------------------------------------
@@ -186,8 +192,10 @@ class SymProcessor:
         self.inputs_dict['sys_mva'] = sp.symbols('sys_mva')
 
         self.parent._syms = True
+        _, s = elapsed(t)
 
-        return True
+        logger.debug(f' - Symbols generated in {s}')
+        return self.parent._syms
 
     def _check_expr_symbols(self, expr):
         """