zen-garden 2.8.13__py3-none-any.whl → 2.9.0__py3-none-any.whl

zen_garden/wrapper/utils.py

@@ -0,0 +1,438 @@
+import os
+import shutil
+from pathlib import Path
+import pandas as pd
+import json
+import numpy as np
+from zen_garden.postprocess.results.results import Results
+from zen_garden.preprocess.unit_handling import UnitHandling
+
+
+def ensure_dir_exists(path: Path):
+    """
+    Ensure that a directory exists. If it doesn't, create it.
+
+    Args:
+        path (Path): The directory path to check and create.
+    """
+    if not path.exists():
+        path.mkdir(parents=True)
+
+
+def copy_file(src: Path, dest: Path):
+    """
+    Copy a single file from the source to the destination.
+
+    Args:
+        src (Path): The source file path.
+        dest (Path): The destination file path.
+    """
+    if not src.exists():
+        raise FileNotFoundError(f"Source file {src} not found.")
+    shutil.copy(src, dest)
+
+
+def copy_dir(src: Path, dest: Path):
+    """
+    Copy an entire directory from the source to the destination.
+
+    Args:
+        src (Path): The source directory path.
+        dest (Path): The destination directory path.
+    """
+    if not src.exists():
+        raise FileNotFoundError(f"Source directory {src} not found.")
+    shutil.copytree(src, dest)
+
+
+def remove_existing_dir(dest: Path):
+    """
+    Delete directory and all subdirectories if they exist.
+
+    Args:
+        dest (Path): Directory to be deleted.
+    """
+    # create new dataset for operational scenarios
+    if os.path.exists(dest):
+        shutil.rmtree(dest)
+
+
+def copy_dataset(old_dataset: Path, new_dataset: Path, scenarios=None):
+    """
+    Copy the entire dataset from the old directory to a new directory.
+
+    Args:
+        old_dataset (Path): The path to the old dataset.
+        new_dataset (Path): The path to the new dataset.
+        scenarios (str, optional): A specific scenario file to copy. Defaults 
+            to None.
+    """
+    remove_existing_dir(new_dataset)
+    ensure_dir_exists(new_dataset)
+    copy_dir(old_dataset / "energy_system", new_dataset / "energy_system")
+    copy_dir(old_dataset / "set_carriers", new_dataset / "set_carriers")
+    copy_dir(old_dataset / "set_technologies",
+             new_dataset / "set_technologies")
+    copy_file(old_dataset / "system.json", new_dataset / "system.json")
+
+    if scenarios:
+        copy_file(old_dataset / scenarios, new_dataset / "scenarios.json")
+
+
+def load_results(out_dir: Path, scenario: str) -> dict:
+    """
+    Load simulation results from the specified directory and scenario.
+
+    Args:
+        out_dir (Path): Directory where the results are stored.
+        scenario (str): Name of the scenario to load results for.
+
+    Returns:
+        dict: A dictionary containing various results data, such as capacity 
+            addition, nodes, edges, and technologies.
+    """
+    r = Results(path=out_dir)
+
+    assert 'capacity_addition' in r.get_component_names(
+        'variable'), "Results have no variable named capacity addition"
+
+    system = r.get_system()
+    solver = r.get_solver()
+    capacity_addition = r.get_total('capacity_addition',
+                                    scenario_name=scenario)
+    capacity_units = r.get_unit('capacity_addition', scenario_name=scenario)
+
+    # Get conversion technologies excluding retrofitting
+    set_conversion_not_retrofitting = list(
+        set(system.set_conversion_technologies) -
+        set(system.set_retrofitting_technologies))
+
+    # Get edges from results
+    edges = r.get_total('set_nodes_on_edges',
+                        scenario_name=scenario).index.values
+
+    # Reformat the results
+    capacity_addition.columns.name = "year"
+    capacity_addition = capacity_addition.stack().unstack("capacity_type")
+
+    return {
+        "capacity_addition": capacity_addition,
+        "capacity_units": capacity_units,
+        "system": system,
+        "solver": solver,
+        "nodes": system.set_nodes,
+        "edges": edges,
+        "technologies": {
+            "set_conversion_technologies": set_conversion_not_retrofitting,
+            "set_transport_technologies": system.set_transport_technologies,
+            "set_storage_technologies": system.set_storage_technologies,
+            "set_retrofitting_technologies":
+            system.set_retrofitting_technologies
+        }
+    }
+
+
+def get_element_location(element_name: str, raw_results: dict):
+    """
+    Get the location (nodes or edges) and the corresponding name for a given 
+    element.
+
+    Args:
+        element_name (str): The name of the technology set (e.g., 
+            'set_transport_technologies').
+        raw_results (dict): The dictionary containing results data.
+
+    Returns:
+        tuple: A tuple containing the location (nodes or edges) and the 
+            location name.
+    """
+    if element_name == "set_transport_technologies":
+        location = raw_results["edges"]
+        location_name = "edge"
+    else:
+        location = raw_results["nodes"]
+        location_name = "node"
+    return location, location_name
+
+
+def get_element_folder(dataset_op: Path, element_name: str, tech: str) -> Path:
+    """
+    Get the folder path for a specific technology within a given element.
+
+    Args:
+        dataset_op (Path): The dataset output directory.
+        element_name (str): The name of the technology set (e.g., 
+            'set_conversion_technologies').
+        tech (str): The name of the technology.
+
+    Returns:
+        Path: The path to the technology folder.
+    """
+    if element_name == "set_retrofitting_technologies":
+        tech_folder_op = dataset_op / "set_technologies" / \
+            "set_conversion_technologies" / element_name / tech
+    else:
+        tech_folder_op = dataset_op / "set_technologies" / element_name / tech
+    return tech_folder_op
+
+
+def format_capacity_addition(capacity_addition_tech: pd.DataFrame,
+                             capacity_type: str,
+                             suffix: str,
+                             location_name: str) -> pd.DataFrame:
+    """
+    Format the capacity addition DataFrame for consistency in column names.
+
+    Args:
+        capacity_addition_tech (pd.DataFrame): The DataFrame with capacity 
+            addition data.
+        capacity_type (str): The type of capacity (e.g., 'power', 'energy').
+        suffix (str): File suffix corresponding to capacity_type.
+        location_name (str): The name of the location (either 'node' or 'edge').
+
+    Returns:
+        pd.DataFrame: The formatted DataFrame with the correct column names.
+    """
+    return capacity_addition_tech.rename(
+        columns={
+            "location": location_name,
+            capacity_type: f"capacity_existing{suffix}",
+            "year": "year_construction"
+        })
+
+
+def aggregate_capacity(capacity_existing: pd.DataFrame,
+                       location_name: str) -> pd.DataFrame:
+    """
+    Aggregate capacity data by grouping it by location and year of construction.
+
+    Args:
+        capacity_existing (pd.DataFrame): The DataFrame with existing capacity 
+            data.
+        location_name (str): The name of the location (either 'node' or 'edge').
+
+    Returns:
+        pd.DataFrame: The aggregated DataFrame with summed capacities.
+    """
+    return capacity_existing.groupby([location_name, "year_construction"
+                                      ]).sum().reset_index()
+
+
+def save_capacity_existing(tech_folder_op: Path,
+                           capacity_existing: pd.DataFrame, suffix: str):
+    """
+    Save the aggregated capacity data to a CSV file.
+
+    Args:
+        tech_folder_op (Path): The path to the technology folder.
+        capacity_existing (pd.DataFrame): The aggregated capacity data.
+        suffix (str): The suffix to append to the file name (e.g., '_energy').
+    """
+    capacity_existing.to_csv(tech_folder_op / f"capacity_existing{suffix}.csv",
+                             mode='w',
+                             header=True,
+                             index=False)
+
+
+def convert_to_original_units(capacity_addition_tech, capacity_units, capacity_type, unit_handling, tech, tech_folder_op, suffix):
+    """
+    Convert the capacity addition to the original units of the existing 
+    capacity.
+
+    Args:
+        capacity_addition_tech (pd.DataFrame): The DataFrame containing capacity 
+            addition data.
+        capacity_units (pd.DataFrame): DataFrame containing unit information 
+            for capacities.
+        capacity_type (str): The type of capacity ('power' or 'energy').
+        unit_handling (UnitHandling): The unit handling object for unit 
+            conversions.
+        tech (str): The technology name.
+        tech_folder_op (Path): The path to the technology folder.
+        suffix (str): Suffix to differentiate between 'power' and 'energy'.
+
+    Returns:
+        pd.DataFrame: The converted capacity addition data in the correct units.
+    """
+    # Get units for capacity addition
+    capacity_addition_unit = capacity_units.loc[(tech, capacity_type)]
+
+    # Ensure capacity addition is in base units
+    if not np.isclose(unit_handling.get_unit_multiplier(capacity_addition_unit, tech), 1):
+        raise AssertionError("Model output is not in base units")
+
+    # Get capacity_existing units from attributes file
+    fp_attributes = tech_folder_op / "attributes.json"
+    with open(fp_attributes, 'r') as f:
+        attributes = json.load(f)
+        capacity_existing_unit = attributes[f'capacity_existing{suffix}']['unit']
+
+    # Convert capacity addition to units of capacity_existing
+    unit_multiplier = unit_handling.get_unit_multiplier(
+        capacity_existing_unit, tech)
+    capacity_addition_tech[f"capacity_existing{suffix}"] = capacity_addition_tech[
+        f"capacity_existing{suffix}"] / unit_multiplier
+
+    # Print output if necessary
+    if not np.isclose(unit_multiplier, 1):
+        print(
+            f"Multiplying capacity addition (unit:{capacity_addition_unit}) "
+            f"by a scale factor of {1/unit_multiplier} to convert to units "
+            f"{capacity_existing_unit}"
+        )
+
+    return capacity_addition_tech
+
+
+def round_capacity(results: dict, rounding_decimal_points: int, has_energy: bool) -> dict:
+    """
+    Round the capacities in the results to remove values below a certain 
+    threshold.
+
+    Args:
+        results (dict): The dictionary containing results data.
+        rounding_decimal_points (int): Number of decimal points after which to 
+            round capacity values to zero. For example, if 
+            ``rounding_decimal_points=6``, then all capacities below 10^-6 are 
+            rounded to zero.
+        has_energy (bool): Boolean whether the capacity addition has energy 
+            column
+    Returns:
+        dict: The updated results dictionary with rounded capacity values.
+    """
+    capacity_addition = results["capacity_addition"]
+    rounding_value = 10**(-rounding_decimal_points)
+    idx_keep = capacity_addition["power"] > rounding_value
+
+    if has_energy:
+        idx_keep_energy = (
+            capacity_addition["energy"] > rounding_value) | capacity_addition["energy"].isna()
+        idx_keep = idx_keep | idx_keep_energy
+
+    results["capacity_addition"] = capacity_addition.loc[idx_keep, :]
+
+    return results
+
+
+def add_capacity_additions(dataset_op: Path, results: dict, element_name: str,
+                           capacity_type: str, unit_handling):
+    """
+    Transfer capacity additions from the results to the dataset for a given 
+        element and capacity type.
+
+    Args:
+        dataset_op (Path): The output directory of the dataset.
+        results (dict): The raw simulation results.
+        element_name (str): The name of the technology set (e.g., 
+            'set_conversion_technologies').
+        capacity_type (str): The type of capacity ('power' or 'energy').
+        unit_handling (UnitHandling): The unit handling object for unit 
+            conversions.
+    """
+    print(f"Transferring capacity for {element_name}")
+    location, location_name = get_element_location(element_name, results)
+    elements = results["technologies"][element_name]
+    capacity_addition = results["capacity_addition"]
+    capacity_units = results["capacity_units"]
+
+    for tech in elements:
+
+        if tech not in capacity_addition.index.get_level_values(0):
+            continue
+
+        suffix = "" if capacity_type == "power" else "_energy"
+        tech_folder_op = get_element_folder(dataset_op, element_name, tech)
+        fp_capacity_existing = tech_folder_op / \
+            f"capacity_existing{suffix}.csv"
+
+        capacity_addition_tech = capacity_addition.loc[(
+            tech, capacity_type)].reset_index()
+        capacity_addition_tech = format_capacity_addition(
+            capacity_addition_tech, capacity_type, suffix, location_name)
+
+        capacity_addition_tech = convert_to_original_units(
+            capacity_addition_tech, capacity_units, capacity_type,
+            unit_handling, tech, tech_folder_op, suffix)
+
+        # Read or initialize the 'capacity_existing' CSV
+        if os.path.exists(fp_capacity_existing):
+            capacity_existing = pd.read_csv(fp_capacity_existing,
+                                            dtype={
+                                                location_name:
+                                                object,
+                                                "year_construction":
+                                                np.int64,
+                                                f"capacity_existing{suffix}":
+                                                np.float64
+                                            })
+            capacity_existing = pd.concat(
+                [capacity_existing,
+                 capacity_addition_tech]).reset_index(drop=True)
+        else:
+            capacity_existing = capacity_addition_tech
+
+        # Aggregate capacity data
+        capacity_existing = aggregate_capacity(capacity_existing,
+                                               location_name)
+
+        # Save updated data
+        save_capacity_existing(tech_folder_op, capacity_existing, suffix)
+
+
+def modify_json(file_path: Path, change_dict: dict):
+    """
+    Modify a JSON file according to a change dictionary.
+
+    Args:
+        file_path (Path): Path to the JSON file.
+        change_dict (dict): Dictionary with attributes to change in the JSON 
+            file.
+    """
+    with open(file_path, 'r+') as f:
+        data = json.load(f)
+        data.update(change_dict)  # Update dictionary with changes
+        f.seek(0)  # Move cursor to the beginning of the file
+        json.dump(data, f, indent=4)
+        f.truncate()  # Remove leftover pieces if old file was longer
+
+
+def capacity_addition_2_existing_capacity(out_dir: Path,
+                                          dataset: Path,
+                                          dataset_op: Path,
+                                          scenario: str):
+    """
+    Add capacity additions from the simulation results to the existing 
+    capacity dataset.
+
+    Args:
+        out_dir (Path): Directory of simulation outputs.
+        dataset (Path): Original model dataset.
+        dataset_op (Path): New model dataset to which to add capacity additions 
+            as existing capacities.
+        scenario (str): The scenario name to load.
+        rounding_value (int, optional): Threshold for rounding capacity 
+            additions to zero. Defaults to None.
+    """
+    # Load raw results
+    results = load_results(out_dir, scenario)
+
+    # Initialize unit handling class
+    unit_handling = UnitHandling(
+        dataset / "energy_system",
+        results["solver"].rounding_decimal_points_units)
+
+    has_energy = ("energy" in results["capacity_addition"].columns.values)
+    # Round capacities below tolerance to zero
+    results = round_capacity(results,
+                             results["solver"].rounding_decimal_points_units,
+                             has_energy
+                             )
+
+    # Add power capacity additions for different technology sets
+    for element_name in results["technologies"].keys():
+        add_capacity_additions(dataset_op, results, element_name,
+                               "power", unit_handling)
+    # add energy capacity additions if present
+    if has_energy:
+        add_capacity_additions(dataset_op, results, "set_storage_technologies",
+                               "energy", unit_handling)

{zen_garden-2.8.13.dist-info → zen_garden-2.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zen_garden
-Version: 2.8.13
+Version: 2.9.0
 Summary: ZEN-garden is an optimization model of energy systems and value chains.
 Author: Alissa Ganter, Johannes Burger, Francesco De Marco, Lukas Kunz, Lukas Schmidt-Engelbertz, Christoph Funke, Paolo Gabrielli, Giovanni Sansavini
 Author-email: Jacob Mannhardt <zen-garden@ethz.ch>
@@ -10,7 +10,7 @@ License-File: LICENSE.txt
 Requires-Dist: xarray
 Requires-Dist: cython
 Requires-Dist: numpy
-Requires-Dist: pandas
+Requires-Dist: pandas<3.0.0
 Requires-Dist: scipy
 Requires-Dist: pint
 Requires-Dist: tables

{zen_garden-2.8.13.dist-info → zen_garden-2.9.0.dist-info}/RECORD

@@ -1,12 +1,13 @@
-zen_garden/__init__.py,sha256=WBclzn3dV9EIAu5idZiGHaEj8SQGr_q2IaUz9qPrQSw,700
+zen_garden/__init__.py,sha256=vFEb5EpCLlaX_sxgqcwQge-HUzdq7nUGyXcol6F7dhE,722
 zen_garden/__main__.py,sha256=Zrz6zr81gXN3_NLPwWz3a-8HiiRgqGx_OzQHarBcxtQ,2508
-zen_garden/default_config.py,sha256=ozz2LBSGSaMH8alEAzh-6ziM9IE9zXM9PfRD3nulAIs,8663
-zen_garden/optimization_setup.py,sha256=Rv_IciR_Y9GF-OaPDDAvTQ2huTuAt94jrWpcDJCQgWQ,42176
-zen_garden/runner.py,sha256=gLjHh3DZbgUAiz5lsnDiSwAZT5RFw52-Pnr1K_nPaMM,7207
+zen_garden/default_config.py,sha256=vys7xf_s0GrH9SSLCkDF3im6FONb15JE73wLT9yZ3_o,8426
+zen_garden/optimization_setup.py,sha256=--nxXr28v2p1EHwqFIREXAhesUg5MfOTPwHWImFSOnM,35441
+zen_garden/runner.py,sha256=8wGfLhevbeMMf5qDDsLdfI3fO78KCHFwSk23_xDcBVc,6739
 zen_garden/utils.py,sha256=GFR-LBIkMA7pDQ46J07mr0ujqyIfNPlI0UVnvBDfHRw,60529
 zen_garden/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zen_garden/cli/zen_example_cli.py,sha256=hCYlAxM5BdphMzXA5LyHmTN3UiYIhMlG7G9sxYi0G_s,1411
-zen_garden/cli/zen_garden_cli.py,sha256=ikiJZoIP4_D-eoNuo4m2f2Z4ydU0sHLDUpCEWn93nnU,6505
+zen_garden/cli/zen_garden_cli.py,sha256=dU1vZMCHz8mZK1rJCEcxnvgmKN9ivN8XZf3jm7Juo1g,6455
+zen_garden/cli/zen_operation_cli.py,sha256=GVjkzkmtfhVCL2uFeR0AtQ3bbx5_g9a3WAw0eiiDy-4,2872
 zen_garden/cli/zen_visualization_cli.py,sha256=vSK2jbe6rNguXwLDMpU3-boreRtjjuDncCkZDCy7CSA,760
 zen_garden/model/__init__.py,sha256=7QIygxkUlNsOBbJPr5VdAxcJQCz6t_FSlD1uytUhuDE,48
 zen_garden/model/component.py,sha256=NeMV47l6Ec_ij_jburCx4cz6lI5k1-b6t0_DfuWFhhY,40488
@@ -24,18 +25,21 @@ zen_garden/model/technology/transport_technology.py,sha256=lxtlVYwlHe3NoDhNHPtvL
 zen_garden/postprocess/.gitkeep,sha256=5QMkCfv_4482uc1E0M66B8-bVZtyQmV0O2OeJJR4VJU,19
 zen_garden/postprocess/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zen_garden/postprocess/comparisons.py,sha256=uyEtV0Q8_YPzJi4b12DWiqYU-kKJz6I3Li-I7_6RURY,13239
-zen_garden/postprocess/postprocess.py,sha256=0_1iy028iZmvf2egXUFO2ZS13HmkacMt7A5eTI0iCE4,29644
+zen_garden/postprocess/postprocess.py,sha256=r8aQf1oXX2SwKj1tj_Wc186RQtAF-G4fKH_qBtTIFHg,28377
 zen_garden/postprocess/results/__init__.py,sha256=363lzC0uRJ5F42cOEhD9jxMPCioTt8WRt0qwZG0IizY,49
 zen_garden/postprocess/results/cache.py,sha256=t-1P7k9EVkSxR1oB1NIodux3JbfhBhxxwgRytcQ8vjQ,1592
 zen_garden/postprocess/results/results.py,sha256=S21h0Unf4l3a8WD0UFvn8IeMgDxKitZRaiX7iLvJnL0,41012
-zen_garden/postprocess/results/solution_loader.py,sha256=ASteApg4IYAATfPI91w9VLISq9Z51bcP-QDZi4tX-QQ,31567
+zen_garden/postprocess/results/solution_loader.py,sha256=VfmkEipLG5im3wm0aYA5qqg1ZvRutfZbvFeUvwZRoh8,31700
 zen_garden/preprocess/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zen_garden/preprocess/extract_input_data.py,sha256=PWKdel7s488SELseyAaoFkwXpzJU4MZg0pW0wO2ZHoI,51523
 zen_garden/preprocess/parameter_change_log.py,sha256=WNhLYTyuaFkUl_e4QH36W1chpqg00m7zg__PawPogAY,387
 zen_garden/preprocess/time_series_aggregation.py,sha256=5FeH4F0Hw37bY8HZscjPbYaOs3qn0OQOmmklUZg65tw,32644
-zen_garden/preprocess/unit_handling.py,sha256=y78oxoPVqcA3y9aEiyr0MU5zITf2BPNGVKOfyMhhCvY,63040
-zen_garden-2.8.13.dist-info/entry_points.txt,sha256=FkXXB0MgvdZG_p_zPifgXc0G2GSPJi0NncG3hZ8TXkU,232
-zen_garden-2.8.13.dist-info/licenses/LICENSE.txt,sha256=_kEtxPe9gWOwMzdiy8nLzgABiPdMvUS0kaSCOIrEA_E,1101
-zen_garden-2.8.13.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-zen_garden-2.8.13.dist-info/METADATA,sha256=i9cA867HUgEqvoXhESSyHBLrcmvidTMH5irk9MatJJc,5791
-zen_garden-2.8.13.dist-info/RECORD,,
+zen_garden/preprocess/unit_handling.py,sha256=08sFQMR6hjKos_ANgfGIc3BLm3lCMmpuu196WRBioHs,74585
+zen_garden/wrapper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+zen_garden/wrapper/operation_scenarios.py,sha256=qfEMqnEc5qA10lO-rVGzVqvz_6MBNDIjZlrCncCpNJo,8499
+zen_garden/wrapper/utils.py,sha256=YY-HSPQ2UPwws5PAumvBzq4tp-yUcbUqILkTyI_Z2TU,16352
+zen_garden-2.9.0.dist-info/entry_points.txt,sha256=xtDb4g8Mho0X9g55niFwiJlajN8XGdTrLkhgyBz5hhs,304
+zen_garden-2.9.0.dist-info/licenses/LICENSE.txt,sha256=_kEtxPe9gWOwMzdiy8nLzgABiPdMvUS0kaSCOIrEA_E,1101
+zen_garden-2.9.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+zen_garden-2.9.0.dist-info/METADATA,sha256=cbzz6CgzUOOrk4tYepRyEAWhbUA3gpi8vwYglryQ8wQ,5796
+zen_garden-2.9.0.dist-info/RECORD,,

{zen_garden-2.8.13.dist-info → zen_garden-2.9.0.dist-info}/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 zen-example=zen_garden.cli.zen_example_cli:create_zen_example_cli
 zen-garden=zen_garden.cli.zen_garden_cli:create_zen_garden_cli
+zen-operation=zen_garden.cli.zen_operation_cli:create_zen_operation_cli
 zen-visualization=zen_garden.cli.zen_visualization_cli:create_zen_visualization_cli