psr-factory 5.0.0b69__py3-none-manylinux_2_28_x86_64.whl

psr/factory/samples/sddp_case21.py

@@ -0,0 +1,242 @@
+"""Creates SDDP 12 stages Case21 example."""
+import copy
+import os
+
+import psr.factory
+
+
+def _get_case_path() -> str:
+    return os.path.join(os.path.splitext(os.path.basename(__file__))[0], "")
+
+
+def create_case21(legacy: bool = False) -> psr.factory.Study:
+    # Create a study object and define its basic settings.
+    blocks = 1
+    model = "SDDP" if not legacy else "SDDP17"
+    # A context defines the dimensions of the study and the meaning of
+    # its stages. You can only share or copy data from one study to another
+    # if they share the same context.
+    context = psr.factory.get_new_context()
+    context.set("Models", [model, ])  # Default model: Sddp
+    context.set("Blocks", blocks)   # Default number of blocks: 3
+    context.set("StageType", 2)     # Weekly: 1, Monthly: 2 (default)
+
+    study = psr.factory.create_study(context)
+    study.set("Description", "SDDP")
+    study.set("InitialYear", 2016)
+    study.set("InitialStage", 1)
+    study.set("NumberOfStages", 12)
+    study.set("NumberOfSeries", 1)
+
+    # Study options
+    study.set("PARModel", 2)
+    study.set("InitialYearOfHydrology", 2016)
+    study.set("NumberOfSystems", 1)
+    study.set("AggregateInTheOperationPolicy", 1)
+    study.set("DeficitSegment", [100.0, 0.0, 0.0, 0.0])
+    study.set("DeficitCost", [1000.0, 0.0, 0.0, 0.0])
+    study.set("UMON", "$")
+
+    # Study duration
+    study.set("FixedDurationOfBlocks(1)", 100.0)
+
+    # By default, a study comes with one system.
+    system = study.get("System")[0]
+    system.code = 1
+    system.id = "s1"
+    system.name = "S1"
+    # System's currency
+    system.set("SystemCurrency", "$")
+    # It's not required to add an existing object to the study.
+
+    # Set study to run with this unique system
+    study.set("CodesOfPowerSystems", [1, ])
+
+    # Create a demand segment - it's required to add at least
+    # inelastic segment to a demand object.
+    segment = psr.factory.create("DemandSegment", context)
+    # Set demand and cost data.
+    segment.set_at("EnergyPerBlock(:)", "01/2016", 11.7)
+    segment.set_at("EnergyPerBlock(:)", "02/2016", 10.8)
+    segment.set_at("EnergyPerBlock(:)", "03/2016", 12.5)
+    segment.set_at("EnergyPerBlock(:)", "04/2016", 13.7)
+    segment.set_at("EnergyPerBlock(:)", "05/2016", 14.6)
+    segment.set_at("EnergyPerBlock(:)", "06/2016", 14.8)
+    segment.set_at("EnergyPerBlock(:)", "07/2016", 15.8)
+    segment.set_at("EnergyPerBlock(:)", "08/2016", 16.2)
+    segment.set_at("EnergyPerBlock(:)", "09/2016", 15.3)
+    segment.set_at("EnergyPerBlock(:)", "10/2016", 14.5)
+    segment.set_at("EnergyPerBlock(:)", "11/2016", 12.9)
+    segment.set_at("EnergyPerBlock(:)", "12/2016", 12.5)
+
+    segment.set_at("PricePerBlock(:)", "01/2016", 0.0)
+    # Add segment to the study.
+    study.add(segment)
+
+    # Create a system demand.
+    demand = psr.factory.create("Demand", context)
+    demand.code = 1
+    demand.name = "S1"
+    # Associate it with the only system in the case.
+    demand.set("RefSystem", system)
+    # Add segment to the demand.
+    demand.set("RefSegments", [segment, ])
+    # Add demand to the study.
+    study.add(demand)
+
+    # Create all fuels - Thermal plants requires them.
+    fuel1 = psr.factory.create("Fuel", context)
+    fuel1.code = 1
+    fuel1.name = "C1"
+    fuel1.set("Unit", "MWh")
+    fuel1.set("Price", 8.0)
+    fuel1.set("RefSystem", system)
+    study.add(fuel1)
+
+    fuel2 = psr.factory.create("Fuel", context)
+    fuel2.code = 2
+    fuel2.name = "C2"
+    fuel2.set("Unit", "MWh")
+    fuel2.set("Price", 12.0)
+    fuel2.set("RefSystem", system)
+    study.add(fuel2)
+
+    fuel3 = psr.factory.create("Fuel", context)
+    fuel3.code = 3
+    fuel3.name = "C3"
+    fuel3.set("Unit", "MWh")
+    fuel3.set("Price", 14.4)
+    fuel3.set("RefSystem", system)
+    study.add(fuel3)
+
+    # Create all thermal plants.
+    plant1 = psr.factory.create("ThermalPlant", context)
+    plant1.code = 1
+    plant1.name = "T1"
+    # Set plant's properties
+    plant1.set("MaximumGenerationCapacity", 12.0)
+    plant1.set("InstalledCapacity", 12.0)
+    plant1.set("ThermalType", 0)  # Standard operation mode.
+    plant1.set("Type", 0)         # It's an existing plant.
+    plant1.set("NumberOfUnits", 1)
+    plant1.set("NumberOfAlternativeFuels", 0)  # No alternative fuels
+    plant1.set("CodeOfAlternativeFuels(:)", 0)
+    plant1.set("O&MCost", 0.0)
+    plant1.set("FuelTransportationCost", 0.0)
+    plant1.set("SpecificConsumptionSegment(1)", 100.0)
+    plant1.set("SpecificConsumptionSegment(2:3)", 0.0)
+    plant1.set("SpecificConsumption(1:3,1)", 1.0)
+    plant1.set("Co2EmissionCoefficient", 1.0)
+    # It's required to associate a thermal plant to a fuel.
+    plant1.set("RefFuels", [fuel1, ])
+    plant1.set("RefSystem", system)
+    # These references are optional and can be set as None.
+    plant1.set("RefGasNode", None)
+    study.add(plant1)
+
+    plant2 = psr.factory.create("ThermalPlant", context)
+    plant2.code = 2
+    plant2.name = "T2"
+    plant2.set("MaximumGenerationCapacity", 8.0)
+    plant2.set("InstalledCapacity", 8.0)
+    plant2.set("ThermalType", 0)
+    plant2.set("Type", 0)
+    plant2.set("NumberOfUnits", 1)
+    plant2.set("NumberOfAlternativeFuels", 0)
+    plant2.set("CodeOfAlternativeFuels(:)", 0)
+    plant2.set("O&MCost", 0.0)
+    plant2.set("FuelTransportationCost", 0.0)
+    plant2.set("SpecificConsumptionSegment(1)", 100.0)
+    plant2.set("SpecificConsumptionSegment(2:3)", 0.0)
+    plant2.set("SpecificConsumption(1:3,1)", 1.0)
+    plant2.set("Co2EmissionCoefficient", 1.0)
+    plant2.set("RefFuels", [fuel2, ])
+    plant2.set("RefSystem", system)
+    study.add(plant2)
+
+    plant3 = plant2.clone()
+    plant3.code = 3
+    plant3.name = "T3"
+    plant3.set("MaximumGenerationCapacity", 4.0)
+    plant3.set("InstalledCapacity", 4.0)
+    plant3.set("RefFuels", [fuel3, ])
+    plant3.set("RefSystem", system)
+    study.add(plant3)
+
+    # Define gauging station for hydro plants inflows
+    station1 = psr.factory.create("HydroStation", context)
+    station1.code = 1
+    station1.name = "Estacion 1"
+
+    station2 = psr.factory.create("HydroStation", context)
+    station2.code = 2
+    station2.name = "Estacion 2"
+
+    for year in (2014, 2015, 2016):
+        station1.set_at("Inflow", f"01/{year}", 13.5)
+        station1.set_at("Inflow", f"02/{year}", 40.7)
+        station1.set_at("Inflow", f"03/{year}", 28.8)
+        station1.set_at("Inflow", f"04/{year}", 25.6)
+        station1.set_at("Inflow", f"05/{year}", 23.8)
+        station1.set_at("Inflow", f"06/{year}", 27.8)
+        station1.set_at("Inflow", f"07/{year}", 28.8)
+        station1.set_at("Inflow", f"08/{year}", 18.8)
+        station1.set_at("Inflow", f"09/{year}", 18.2)
+        station1.set_at("Inflow", f"10/{year}", 29.6)
+        station1.set_at("Inflow", f"11/{year}", 17.7)
+        station1.set_at("Inflow", f"12/{year}", 26.3)
+
+        for month in range(1, 12 + 1):
+            station2.set_at("Vazao", f"{month:02d}/{year}", 0.0)
+
+    study.add(station1)
+    study.add(station2)
+
+    # Define hydroplants
+    hydro1 = psr.factory.create("HydroPlant", context)
+    hydro1.code = 1
+    hydro1.name = "H1"
+    hydro1.set("Type", 0)
+    hydro1.set("NumberOfUnits", 1)
+    hydro1.set("InstalledCapacity", 5.5)
+    hydro1.set("MaximumTurbinedOutflow", 55.0)
+    hydro1.set("MeanProductionCoefficient", 0.1)
+    hydro1.set("MinimumStorage", 0.0)
+    hydro1.set("MaximumStorage", 50.0)
+    hydro1.set("InitialCondition", 0.2)
+    hydro1.set("RefSystem", system)
+    hydro1.set("RefStation", station1)
+    study.add(hydro1)
+
+    hydro2 = hydro1.clone()
+    hydro2.code = 2
+    hydro2.name = "H2"
+    hydro2.set("MaximumStorage", 0.0)
+    hydro2.set("InitialCondition", 1.0)
+    hydro2.set("RefSystem", system)
+    hydro2.set("RefStation", station2)
+    study.add(hydro2)
+
+    # Connect hydro plants
+    connection_spill = psr.factory.create("HydroPlantConnection", context)
+    connection_spill.set("IsVertimento", 1)
+    connection_spill.set("RefPlants", [hydro1, hydro2])
+    study.add(connection_spill)
+
+    connection_turb = psr.factory.create("HydroPlantConnection", context)
+    connection_turb.set("IsTurbinamento", 1)
+    connection_turb.set("RefPlants", [hydro1, hydro2])
+    study.add(connection_turb)
+
+    return study
+
+
+if __name__ == "__main__":
+    case_path = _get_case_path()
+    os.makedirs(case_path, exist_ok=True)
+    print("Creating example case... ", end="")
+    study = create_case21(False)
+    print(" OK.")
+    print("Saving example case in \"{}\"... ".format(case_path), end="")
+    study.save(case_path)
+    print(" OK.")

psr/outputs/__init__.py

@@ -0,0 +1,5 @@
+# PSR Factory. Copyright (C) PSR, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+from .outputs import *

psr/outputs/outputs.py

@@ -0,0 +1,179 @@
+# PSR Factory. Copyright (C) PSR, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+import csv
+import os
+from pathlib import Path
+from typing import (List)
+import pandas
+import psr.factory
+
+
+_language_dict_map = {
+    0: 'ENG',
+    1: 'ESP',
+    2: 'POR',
+}
+
+_default_language = 0
+
+
+def __rename_lang_columns(df: pandas.DataFrame) -> pandas.DataFrame:
+    default_language_code = _language_dict_map.get(_default_language, 'ENG')
+    languages = list(_language_dict_map.values())
+    languages.remove(default_language_code)
+    lang_cols = [col for col in df.columns if col.startswith(tuple(languages))]
+    df = df.drop(columns=lang_cols)
+    # Rename the default language column to remove prefix ENG-
+    for column in df.columns:
+        if column.startswith(f"{default_language_code}-"):
+            new_col = column[len(f"{default_language_code}-"):]
+            df = df.rename(columns={column: new_col})
+    return df
+
+
+def get_available_outputs_by_model(tool_path: str) -> pandas.DataFrame:
+    dat_file = os.path.join(tool_path, "indexdat.fmt")
+    if not os.path.exists(dat_file):
+        raise FileNotFoundError(f"Could not find {dat_file}")
+    cls_file = os.path.join(tool_path, "indexcls.fmt")
+    if not os.path.exists(cls_file):
+        raise FileNotFoundError(f"Could not find {cls_file}")
+    typ_file = os.path.join(tool_path, "indextyp.fmt")
+    if not os.path.exists(typ_file):
+        raise FileNotFoundError(f"Could not find {typ_file}")
+
+    dat_df = pandas.read_csv(dat_file, delimiter=',', encoding='latin1', skiprows=1)
+    dat_df = __rename_lang_columns(dat_df)
+    dat_df.drop(columns=["PSRIO"], inplace=True)
+
+    cls_df = pandas.read_csv(cls_file, delimiter=',', encoding='latin1', skiprows=1)
+    cls_df = __rename_lang_columns(cls_df)
+    cls_df.rename(columns={"Name": "ClassName"}, inplace=True)
+    cls_df.drop(columns=["Description", "PSRIO-Class"], inplace=True)
+
+    typ_df = pandas.read_csv(typ_file, delimiter=',', encoding='latin1', skiprows=1)
+    typ_df = __rename_lang_columns(typ_df)
+    typ_df.rename(columns={"Name": "TypeName"}, inplace=True)
+
+    # merge class names and type names
+    dat_df = dat_df.merge(cls_df, how='left', left_on='Class', right_on='!Class')
+    dat_df = dat_df.merge(typ_df, how='left', left_on='Type', right_on='!Type')
+    dat_df.drop(columns=["!Class", "!Type"], inplace=True)
+    dat_df.rename(columns={"!Num": "Number", "TypeName": "Type", "ClassName": "Class"}, inplace=True)
+
+    return dat_df
+
+
+class AvailableOutput:
+    def __init__(self):
+        self.filename = ""
+        self.file_type = ""
+        self.description = ""
+        self.unit = ""
+        self.attribute_class = ""
+        self.case_path = ""
+    def load_dataframe(self) -> psr.factory.DataFrame:
+        full_file_name = str(self)
+        return psr.factory.load_dataframe(full_file_name)
+
+    def __str__(self):
+        return os.path.join(self.case_path, f"{self.filename}.{self.file_type}")
+
+    def __repr__(self):
+        return f"AvailableOutput(path='{str(self)}', description='{self.description}', unit='{self.unit}', attribute_class={self.attribute_class})"
+
+
+def get_available_outputs(case_path: str) -> List[AvailableOutput]:
+    indice_grf_path = os.path.join(case_path, "indice.grf")
+    outputs = []
+    with open(indice_grf_path, 'r', encoding='latin1') as f:
+        next(f)  # Skip header
+        next(f)
+        reader = csv.reader(f, delimiter=',')
+        for row in reader:
+            if len(row) >= 4:
+                output = AvailableOutput()
+                full_file_name = row[0].strip()
+                output.filename, output.file_type = os.path.splitext(full_file_name)
+                output.filename = output.filename.strip()
+                output.file_type = output.file_type.lstrip('.').strip()
+                output.description = row[1].strip()
+                output.unit = row[2].strip()
+                output.attribute_class = row[3].strip()
+                output.case_path = case_path
+                outputs.append(output)
+    return outputs
+
+
+class OutputsDataFrame(pandas.DataFrame):
+    def __setitem__(self, key, value):
+        if isinstance(value, bool):
+            self.loc[key, 'Active'] = value
+        else:
+            super().__setitem__(key, value)
+            
+    def save(self, case_path: str) -> None:
+        save(self, case_path)
+
+
+def save(df: pandas.DataFrame, case_path: str) -> None:
+    index_df = load_index_dat(case_path)
+
+    for filename, row in df.iterrows():
+        mask = index_df['Num'] == row['Num']
+        if any(mask):
+            index_df.loc[mask, 'YN'] = 1 if row['Active'] else 0
+
+    output_lines = ['Num Graph...........................|...Unid Type  Y/N']
+    for _, row in index_df.iterrows():
+        line = f"{row['Num']:>3d} {row['Description']:<33}{row['Unit']:7} {int(row['Type']):>4d} {row['YN']:>4d}"
+        output_lines.append(line)
+        
+    index_file = os.path.join(case_path, "index.dat")
+    with open(index_file, 'w', encoding='utf-8') as f:
+        for line in output_lines:
+            f.write(f"{line}\n")
+
+
+def load_index_dat(case_path: str) -> pandas.DataFrame:
+    index_file = os.path.join(case_path, "index.dat")
+    if not os.path.exists(index_file):
+        raise FileNotFoundError(f"Could not find {index_file}")
+    
+    widths = [4, 33, 8, 5, 4]
+    names = ['Num', 'Description', 'Unit', 'Type', 'YN']
+    
+    return pandas.read_fwf(
+        index_file,
+        widths=widths,
+        names=names,
+        skiprows=1
+    )
+
+
+def load(case_path: str) -> OutputsDataFrame:
+    sddp_path = Path("C:/PSR")
+    sddp_dirs = [d for d in sddp_path.iterdir() if d.name.startswith("Sddp")]
+    if not sddp_dirs:
+        raise FileNotFoundError("Could not find SDDP installation")
+    sddp_path = sorted(sddp_dirs)[-1]
+            
+    fmt_file = Path(sddp_path) / "Oper" / "indexdat.fmt"
+    if not fmt_file.exists():
+        raise FileNotFoundError(f"Could not find {fmt_file}")
+        
+    fmt_df = pandas.read_csv(fmt_file, delimiter=',', encoding='latin1', skiprows=1)
+    index_df = load_index_dat(case_path)
+    
+    outputs_df = OutputsDataFrame()
+    for _, row in fmt_df.iterrows():
+        num = row['!Num']
+        filename = row['Filename']
+        index_row = index_df[index_df['Num'] == num]
+        if not index_row.empty:
+            outputs_df.loc[filename, 'Num'] = num
+            outputs_df.loc[filename, 'Active'] = bool(index_row['YN'].iloc[0])
+            
+    return outputs_df