pypsa2smspp 0.0.1__py3-none-any.whl

pypsa2smspp/__init__.py

@@ -0,0 +1,63 @@
+
+"""
+pypsa2smspp package init
+
+Exposes high-level transformation and network correction utilities.
+"""
+
+import logging
+
+logger = logging.getLogger("pypsa2smspp")
+logger.setLevel(logging.INFO)
+
+if not logger.handlers:  # 👈 evita di aggiungere più handler
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.DEBUG)
+
+    formatter = logging.Formatter(
+        '[%(asctime)s] %(levelname)s - %(name)s - %(message)s'
+    )
+    console_handler.setFormatter(formatter)
+
+    logger.addHandler(console_handler)
+
+# opzionale ma consigliato in una libreria:
+logger.propagate = False
+
+
+
+# Transformation logic (PyPSA ↔ SMS++)
+from pypsa2smspp.transformation import Transformation
+from pypsa2smspp.transformation_config import TransformationConfig
+
+# PyPSA network correction tools
+from pypsa2smspp.network_correction import (
+    clean_marginal_cost,
+    clean_global_constraints,
+    clean_e_sum,
+    clean_efficiency_link,
+    clean_ciclicity_storage,
+    clean_marginal_cost_intermittent,
+    clean_storage_units,
+    clean_stores,
+    parse_txt_file,
+    clean_p_min_pu,
+    one_bus_network,
+)
+
+__all__ = [
+    "Transformation",
+    "TransformationConfig",
+    # network correction tools
+    "clean_marginal_cost",
+    "clean_global_constraints",
+    "clean_e_sum",
+    "clean_efficiency_link",
+    "clean_ciclicity_storage",
+    "clean_marginal_cost_intermittent",
+    "clean_storage_units",
+    "clean_stores",
+    "parse_txt_file",
+    "clean_p_min_pu",
+    "one_bus_network",
+]

pypsa2smspp/constants.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jun 26 15:50:01 2025
+
+@author: aless
+"""
+
+"""
+constants.py
+
+This module contains structural constants used throughout the PyPSA2SMSpp 
+transformation process. These values define generic mappings and categories
+used repeatedly in the Transformation class and related utilities.
+
+They are not meant to be modified by the user and do not depend on any 
+specific instance or configuration of the network.
+"""
+
+# Dictionary mapping internal shorthand dimensions to full SMS++ dimension names
+conversion_dict = {
+    "T": "TimeHorizon",
+    "NU": "NumberUnits",
+    "NE": "NumberElectricalGenerators",
+    "N": "NumberNodes",
+    "L": "NumberLines",
+    "Li": "Links",
+    "NA": "NumberArcs",
+    "NR": "NumberReservoirs",
+    "NP": "TotalNumberPieces",
+    "Nass": "NumAssets",
+    "NB": "NumberBranches",
+    "NDL": "NumberDesignLines",
+    "NDLL": "NumberDesignLines_lines",
+    "NDLLi": "NumberDesignLines_links",
+    "1": 1
+}
+
+# Mapping from PyPSA component types to their nominal attribute
+nominal_attrs = {
+    "Generator": "p_nom",
+    "Line": "s_nom",
+    "Transformer": "s_nom",
+    "Link": "p_nom",
+    "Store": "e_nom",
+    "StorageUnit": "p_nom",
+}
+
+# List of renewable carriers used to identify IntermittentUnitBlocks
+renewable_carriers = [
+    "solar",
+    "solar-hsat",
+    "onwind",
+    "offwind-ac",
+    "offwind-dc",
+    "offwind-float",
+    "PV",
+    "wind",
+    "ror"
+]

pypsa2smspp/data/config_default.yaml

@@ -0,0 +1,22 @@
+transformation:
+    merge_links: true
+    expansion_ucblock: false # To include with investmentblock... Collect everything with mode
+    max_hours_stores: 1
+
+run:
+    mode: investmentblock  # ucblock | investmentblock
+
+smspp:
+    ucblock:
+        output_prefix: uc
+        template: UCBlock/uc_solverconfig_grb
+    investmentblock:
+        output_prefix: inv
+        template: InvestmentBlock/BSPar.txt
+        inner_block_name: InvestmentBlock
+    log_executable_call: true
+
+io:
+    workdir: output
+    name: test_case
+    overwrite: true

pypsa2smspp/inverse.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jun 26 15:55:15 2025
+
+@author: aless
+"""
+
+"""
+inverse.py
+
+This module handles the inverse transformation from an SMS++ solution 
+back into a PyPSA-compatible xarray.Dataset. It reconstructs time-series 
+and scalar variables from SMS unit blocks and prepares them for use with 
+assign_solution in PyPSA.
+"""
+
+import numpy as np
+import xarray as xr
+
+
+def normalize_key(key: str) -> str:
+    """
+    Normalizes a key string by converting to lowercase and replacing spaces with underscores.
+    """
+    return key.lower().replace(" ", "_")
+
+
+def component_definition(n, unit_block: dict) -> str:
+    """
+    Maps a unit block type to its corresponding PyPSA component name.
+    """
+    block = unit_block['block']
+    match block:
+        case "IntermittentUnitBlock":
+            return "Generator"
+        case "ThermalUnitBlock":
+            return "Generator"
+        case "HydroUnitBlock":
+            return "StorageUnit"
+        case "BatteryUnitBlock":
+            return "StorageUnit" if unit_block['name'] in n.storage_units.index else "Store"
+        case "DCNetworkBlock_lines":
+            return "Line"
+        case "DCNetworkBlock_links":
+            return "Link"
+        case "SlackUnitBlock":
+            return "Generator"
+        case _:
+            raise ValueError(f"Unknown unit block type: {block}")
+
+
+def evaluate_function(func, normalized_keys, unit_block, df):
+    """
+    Evaluates a callable inverse function by extracting arguments from unit block or network.
+    """
+    param_names = func.__code__.co_varnames[:func.__code__.co_argcount]
+    args = []
+    for param in param_names:
+        param = normalize_key(param)
+        if param in normalized_keys:
+            args.append(unit_block[normalized_keys[param]])
+        else:
+            args.append(df.loc[unit_block['name']][param])
+    return func(*args)
+
+
+def dataarray_components(n, value, component, unit_block, key):
+    """
+    Build xarray dims/coords compliant with PyPSA 1.0 assign_solution():
+    - static per-unit: dims -> ('name',)
+    - time series:     dims -> ('snapshot','name')
+    """
+    # Unmask masked arrays; use NaN for masked scalars
+    if isinstance(value, np.ma.MaskedArray):
+        value = value.filled(np.nan)
+
+    value = np.asarray(value)
+    unit_name = unit_block["name"]
+
+    if value.ndim == 0:
+        # scalar -> one value for this unit: ('name',)
+        value = value.reshape(1)
+        dims = ["name"]
+        coords = {"name": [unit_name]}
+
+    elif value.ndim == 1:
+        if len(value) == len(n.snapshots):
+            # (T,) -> ('snapshot','name')
+            value = value[:, np.newaxis]  # (T,1)
+            dims = ["snapshot", "name"]
+            coords = {"snapshot": n.snapshots, "name": [unit_name]}
+        else:
+            # vector but not time-based -> treat as per-unit static ('name',)
+            # (se è un vettore con più elementi non-temporali, somma o valida prima)
+            value = np.array([value.sum()]) if value.size > 1 else value.reshape(1)
+            dims = ["name"]
+            coords = {"name": [unit_name]}
+
+    elif value.ndim == 2:
+        T = len(n.snapshots)
+        if value.shape == (T, 1):
+            dims = ["snapshot", "name"]
+            coords = {"snapshot": n.snapshots, "name": [unit_name]}
+        elif value.shape == (1, T):
+            value = value.T
+            dims = ["snapshot", "name"]
+            coords = {"snapshot": n.snapshots, "name": [unit_name]}
+        else:
+            raise ValueError(f"Unsupported shape for variable {key}: {value.shape}")
+    else:
+        raise ValueError(f"Unsupported ndim for variable {key}: {value.ndim}")
+
+    var_name = f"{component}-{key}"  # e.g., 'Generator-p', 'Store-e_nom', 'Link-p'
+    return value, dims, coords, var_name
+
+
+
+def block_to_dataarrays(n, unit_name, unit_block, component, config) -> dict:
+    """
+    Transforms a unit block into a dictionary of DataArrays.
+    """
+    attr_name = f"{unit_block['block']}_inverse"
+    converted_dict = {}
+    normalized_keys = {normalize_key(k): k for k in unit_block.keys()}
+
+    if hasattr(config, attr_name):
+        unitblock_parameters = getattr(config, attr_name)
+    else:
+        print(f"Block {unit_block['block']} not yet implemented")
+        return {}
+
+    df = getattr(n, config.component_mapping[component])
+
+    for key, func in unitblock_parameters.items():
+        if callable(func):
+            value = evaluate_function(func, normalized_keys, unit_block, df)
+            if isinstance(value, np.ndarray) and value.ndim == 2 and all(dim > 1 for dim in value.shape):
+                value = value.sum(axis=0)
+            value, dims, coords, var_name = dataarray_components(n, value, component, unit_block, key)
+            converted_dict[var_name] = xr.DataArray(value, dims=dims, coords=coords, name=var_name)
+
+    return converted_dict
+

pypsa2smspp/io_parser.py

@@ -0,0 +1,233 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jun 26 15:57:30 2025
+
+@author: aless
+"""
+
+"""
+io_parser.py
+
+This module handles the parsing of SMS++ output files (both .txt and NetCDF formats)
+and prepares data structures that can be used to populate the Transformation class 
+or to re-assign results into a PyPSA network.
+
+It includes:
+- parsing unit blocks from .txt file
+- parsing solution objects from SMSNetwork
+- conversion of parsed data into xarray or PyPSA structures
+"""
+
+import numpy as np
+import re
+import xarray as xr
+
+
+def parse_txt_to_unitblocks(file_path: str, unitblocks: dict) -> None:
+    """
+    Parses an SMS++ textual solution file and populates the unitblocks dictionary.
+
+    Parameters
+    ----------
+    file_path : str
+        Path to the text file.
+    unitblocks : dict
+        Dictionary of unitblocks to populate with parsed data.
+    """
+    current_block = None
+    current_block_key = None
+
+    with open(file_path, "r") as file:
+        for line in file:
+            match_time = re.search(r"Elapsed time:\s*([\deE\+\.-]+)\s*s", line)
+            if match_time:
+                continue  # Skip timing info
+
+            block_match = re.search(r"(ThermalUnitBlock|BatteryUnitBlock|IntermittentUnitBlock|HydroUnitBlock)\s*(\d+)", line)
+            if block_match:
+                block_type, number = block_match.groups()
+                number = int(number)
+                current_block = block_type
+                current_block_key = f"{block_type}_{number}"
+                unitblocks[current_block_key]["block"] = block_type
+                unitblocks[current_block_key]["enumerate"] = number
+                continue
+
+            match = re.match(r"([\w\s]+?)(?:\s*\[(\d+)\])?\s+=\s+\[([^\]]*)\]", line)
+            if match and current_block_key:
+                key_base, sub_index, values = match.groups()
+                key_base = key_base.strip()
+                values_array = np.array([float(x) for x in values.split()])
+
+                if sub_index is not None:
+                    sub_index = int(sub_index)
+                    if key_base in unitblocks[current_block_key] and not isinstance(unitblocks[current_block_key][key_base], dict):
+                        unitblocks[current_block_key][key_base] = {0: unitblocks[current_block_key][key_base]}
+                    if key_base not in unitblocks[current_block_key]:
+                        unitblocks[current_block_key][key_base] = {}
+                    unitblocks[current_block_key][key_base][sub_index] = values_array
+                else:
+                    unitblocks[current_block_key][key_base] = values_array
+
+
+def assign_design_variables_to_unitblocks(unitblocks, block_names_investment, design_vars):
+    """
+    Assigns design variable values to the corresponding unitblocks based on investment block mapping.
+
+    Parameters
+    ----------
+    unitblocks : dict
+        Dictionary of unitblocks.
+    block_names_investment : list of str
+        List of unitblock names that received investments.
+    design_vars : np.ndarray
+        Array of design variable values.
+
+    Raises
+    ------
+    ValueError or KeyError
+        If a mismatch in shapes or missing keys occurs.
+    """
+    if len(design_vars) != len(block_names_investment):
+        raise ValueError("Mismatch between design variables and investment blocks")
+
+    for name, value in zip(block_names_investment, design_vars):
+        if name not in unitblocks:
+            raise KeyError(f"DesignVariable refers to unknown unitblock '{name}'")
+        unitblocks[name]["DesignVariable"] = value
+
+
+def split_merged_dcnetworkblocks(unitblocks, delimiter="__", reuse_index_for_first=True, logger=print):
+    """
+    Split merged DCNetworkBlock_* entries in a unitblocks dict into two blocks.
+
+    Parameters
+    ----------
+    unitblocks : dict
+        Dictionary of unitblocks (as built by parse_solution_to_unitblocks).
+    delimiter : str, default="__"
+        String that separates the two original link names inside the merged name.
+    reuse_index_for_first : bool, default=True
+        If True, the first split block keeps the original index
+        (e.g., DCNetworkBlock_7), the second gets a new index.
+        If False, the original entry is removed and two new blocks are appended.
+    logger : callable, default=print
+        Logging function.
+
+    Returns
+    -------
+    unitblocks : dict
+        Modified dictionary with merged blocks split into two entries.
+    """
+    keys = list(unitblocks.keys())
+    candidates = []
+    for k in keys:
+        if not k.startswith("DCNetworkBlock_"):
+            continue
+        blk = unitblocks[k]
+        name = blk.get("name", "")
+        if isinstance(name, str) and delimiter in name:
+            candidates.append(k)
+
+    if not candidates:
+        logger("[split] No merged DCNetworkBlock entries found; nothing to do.")
+        return unitblocks
+
+    # Next fresh index for UnitBlock/DCNetworkBlock
+    def _next_index():
+        max_idx = -1
+        for kk in unitblocks.keys():
+            if "_" in kk and kk.split("_")[-1].isdigit():
+                max_idx = max(max_idx, int(kk.split("_")[-1]))
+        return max_idx + 1
+
+    for k in candidates:
+        blk = unitblocks[k]
+        merged_name = blk.get("name", "")
+        parts = merged_name.split(delimiter)
+        if len(parts) != 2:
+            logger(f"[split] Skipping '{k}' because name does not split cleanly: {merged_name}")
+            continue
+        name_ch, name_dis = parts[0].strip(), parts[1].strip()
+
+        flow = blk.get("FlowValue", None)
+        if flow is None:
+            logger(f"[split] Block '{k}' has no FlowValue; skipping.")
+            continue
+
+        flow_charge = np.maximum(flow, 0.0)
+        flow_dis    = np.maximum(-flow, 0.0)
+
+        base_charge = dict(blk)
+        base_dis    = dict(blk)
+
+        base_charge["name"] = name_ch
+        base_charge["FlowValue"] = flow_charge
+
+        base_dis["name"] = name_dis
+        base_dis["FlowValue"] = flow_dis
+
+        if reuse_index_for_first:
+            idx_first = int(k.split("_")[-1])
+            key_first = f"DCNetworkBlock_{idx_first}"
+            enum_first = f"UnitBlock_{idx_first}"
+
+            idx_second = _next_index()
+            key_second = f"DCNetworkBlock_{idx_second}"
+            enum_second = f"UnitBlock_{idx_second}"
+
+            base_charge["enumerate"] = enum_first
+            unitblocks[key_first] = base_charge
+
+            base_dis["enumerate"] = enum_second
+            unitblocks[key_second] = base_dis
+        else:
+            del unitblocks[k]
+            idx_first = _next_index()
+            idx_second = idx_first + 1
+            key_first = f"DCNetworkBlock_{idx_first}"
+            key_second = f"DCNetworkBlock_{idx_second}"
+            base_charge["enumerate"] = f"UnitBlock_{idx_first}"
+            base_dis["enumerate"] = f"UnitBlock_{idx_second}"
+            unitblocks[key_first] = base_charge
+            unitblocks[key_second] = base_dis
+
+        logger(f"[split] '{k}' -> '{name_ch}' + '{name_dis}'")
+
+    return unitblocks
+
+
+class FakeVariable:
+    """
+    A dummy wrapper used to emulate PyPSA-style model.variable.solution attributes.
+    """
+    def __init__(self, solution):
+        self.solution = solution
+
+
+def prepare_solution(n, ds: xr.Dataset, objective_smspp: float) -> None:
+    """
+    Prepares a fake PyPSA model that wraps the xarray Dataset as a PyPSA-compatible solution.
+
+    Parameters
+    ----------
+    n : pypsa.Network
+        The original PyPSA network.
+    ds : xarray.Dataset
+        The solution dataset to attach to the network.
+
+    Returns
+    -------
+    None (modifies n in place)
+    """
+    n._model = type("FakeModel", (), {})()
+    n._model.variables = {name: FakeVariable(solution=dataarray) for name, dataarray in ds.items()}
+
+    n._model.parameters = type("FakeParameters", (), {})()
+    n._model.parameters.snapshots = xr.DataArray(n.snapshots, dims=["snapshot"])
+
+    n._model.constraints = type("FakeConstraints", (), {})()
+    n._model.constraints.snapshots = xr.DataArray(n.snapshots, dims=["snapshot"])
+
+    n._model.objective = type("FakeObjective", (), {})()
+    n._model.objective.value = objective_smspp