psr-factory 5.0.0b16__py3-none-win_amd64.whl → 5.0.0b67__py3-none-win_amd64.whl

psr/factory/factorylib.py

@@ -29,10 +29,16 @@ def initialize():
     global lib
     lib = load_lib()
 
-    lib.psrd_initialize.restype = ctypes.c_int
-    lib.psrd_initialize.argtypes = [ctypes.c_char_p, ctypes.c_long, ctypes.c_void_p]
+    lib.psrd_check_license.restype = ctypes.c_int
+    lib.psrd_check_license.argtypes = [ctypes.c_void_p]
+    lib.psrd_initialize_basic_data.restype = ctypes.c_int
+    lib.psrd_initialize_basic_data.argtypes = [ctypes.c_void_p]
+    lib.psrd_initialize_study_data.restype = ctypes.c_int
+    lib.psrd_initialize_study_data.argtypes = [ctypes.c_char_p, ctypes.c_long, ctypes.c_void_p]
     lib.psrd_unload.restype = ctypes.c_int
     lib.psrd_unload.argtypes = [ctypes.c_void_p]
+    lib.psrd_get_constant.restype = ctypes.c_int
+    lib.psrd_get_constant.argtypes = [ctypes.c_char_p, ctypes.c_long, ctypes.c_void_p, ctypes.c_void_p]
     lib.psrd_set_global_setting.restype = ctypes.c_int
     lib.psrd_set_global_setting.argtypes = [ctypes.c_char_p, ctypes.c_long, ctypes.c_void_p, ctypes.c_void_p]
     lib.psrd_get_global_setting.restype = ctypes.c_int
@@ -89,6 +95,8 @@ def initialize():
     lib.psrd_study_property_description_count.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_long), ctypes.c_void_p]
     lib.psrd_study_get_property_description.restype = ctypes.c_void_p
     lib.psrd_study_get_property_description.argtypes = [ctypes.c_void_p, ctypes.c_long, ctypes.c_void_p]
+    lib.psrd_study_get_property_description_by_name.restype = ctypes.c_void_p
+    lib.psrd_study_get_property_description_by_name.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_long, ctypes.c_void_p]
     lib.psrd_study_set_value.restype = ctypes.c_int
     lib.psrd_study_set_value.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_long, ctypes.c_void_p, ctypes.c_void_p]
     lib.psrd_study_set_value_at.restype = ctypes.c_int
@@ -99,6 +107,8 @@ def initialize():
     lib.psrd_study_get_value.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_void_p, ctypes.c_void_p]
     lib.psrd_study_get_value_at.restype = ctypes.c_int
     lib.psrd_study_get_value_at.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p]
+    lib.psrd_study_has_property.restype = ctypes.c_int
+    lib.psrd_study_has_property.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_long, ctypes.POINTER(ctypes.c_bool), ctypes.c_void_p]
     lib.psrd_study_get_as_dict.restype = ctypes.c_void_p
     lib.psrd_study_get_as_dict.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
     lib.psrd_study_get_table.restype = ctypes.c_int
@@ -121,6 +131,8 @@ def initialize():
     lib.psrd_study_remove.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p]
     lib.psrd_study_get_all_objects.restype = ctypes.c_void_p
     lib.psrd_study_get_all_objects.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+    lib.psrd_study_get_key_object_map.restype = ctypes.c_void_p
+    lib.psrd_study_get_key_object_map.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
     lib.psrd_study_find.restype = ctypes.c_void_p
     lib.psrd_study_find.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_void_p]
     lib.psrd_study_find_by_id.restype = ctypes.c_void_p
@@ -141,6 +153,10 @@ def initialize():
     lib.psrd_object_get_parent.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
     lib.psrd_object_get_type.restype = ctypes.c_int
     lib.psrd_object_get_type.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_long, ctypes.c_void_p]
+    lib.psrd_object_get_key.restype = ctypes.c_int
+    lib.psrd_object_get_key.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_long, ctypes.c_void_p]
+    lib.psrd_object_set_key.restype = ctypes.c_int
+    lib.psrd_object_set_key.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_long, ctypes.c_void_p]
     lib.psrd_object_get_code.restype = ctypes.c_int
     lib.psrd_object_get_code.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_int), ctypes.c_void_p]
     lib.psrd_object_set_code.restype = ctypes.c_int
@@ -157,6 +173,8 @@ def initialize():
     lib.psrd_object_property_description_count.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_long), ctypes.c_void_p]
     lib.psrd_object_get_property_description.restype = ctypes.c_void_p
     lib.psrd_object_get_property_description.argtypes = [ctypes.c_void_p, ctypes.c_long, ctypes.c_void_p]
+    lib.psrd_object_get_property_description_by_name.restype = ctypes.c_void_p
+    lib.psrd_object_get_property_description_by_name.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_long, ctypes.c_void_p]
     lib.psrd_object_set_value.restype = ctypes.c_int
     lib.psrd_object_set_value.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_long, ctypes.c_void_p, ctypes.c_void_p]
     lib.psrd_object_set_value_at.restype = ctypes.c_int
@@ -167,6 +185,8 @@ def initialize():
     lib.psrd_object_get_value.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_void_p, ctypes.c_void_p]
     lib.psrd_object_get_value_at.restype = ctypes.c_int
     lib.psrd_object_get_value_at.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p]
+    lib.psrd_object_has_property.restype = ctypes.c_int
+    lib.psrd_object_has_property.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_long, ctypes.POINTER(ctypes.c_bool), ctypes.c_void_p]
     lib.psrd_object_get_as_dict.restype = ctypes.c_void_p
     lib.psrd_object_get_as_dict.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
     lib.psrd_object_get_table.restype = ctypes.c_int
@@ -273,6 +293,10 @@ def initialize():
     lib.psrd_property_description_get_dimension_size.argtypes = [ctypes.c_void_p, ctypes.c_long, ctypes.POINTER(ctypes.c_long), ctypes.c_void_p]
     lib.psrd_property_description_get_dimension_name.restype = ctypes.c_int
     lib.psrd_property_description_get_dimension_name.argtypes = [ctypes.c_void_p, ctypes.c_long, ctypes.c_char_p, ctypes.c_long, ctypes.c_void_p]
+    lib.psrd_property_description_is_reference.restype = ctypes.c_int
+    lib.psrd_property_description_is_reference.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_bool), ctypes.c_void_p]
+    lib.psrd_property_description_is_required.restype = ctypes.c_int
+    lib.psrd_property_description_is_required.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_bool), ctypes.c_void_p]
     lib.psrd_property_description_is_dynamic.restype = ctypes.c_int
     lib.psrd_property_description_is_dynamic.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_bool), ctypes.c_void_p]
     lib.psrd_property_description_is_indexed.restype = ctypes.c_int
@@ -297,6 +321,10 @@ def initialize():
     lib.psrd_table_is_indexed.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_bool), ctypes.c_void_p]
     lib.psrd_table_resize.restype = ctypes.c_int
     lib.psrd_table_resize.argtypes = [ctypes.c_void_p, ctypes.c_long, ctypes.c_void_p]
+    lib.psrd_table_get_as_dict.restype = ctypes.c_void_p
+    lib.psrd_table_get_as_dict.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+    lib.psrd_table_set_from_dict.restype = ctypes.c_int
+    lib.psrd_table_set_from_dict.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p]
     lib.psrd_table_configure_index.restype = ctypes.c_int
     lib.psrd_table_configure_index.argtypes = [ctypes.c_void_p, ctypes.c_long, ctypes.c_long, ctypes.c_void_p]
     lib.psrd_table_configure_column.restype = ctypes.c_int
@@ -371,4 +399,6 @@ def initialize():
     lib.psrd_date_iterator_at_end.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_bool), ctypes.c_void_p]
     lib.psrd_date_iterator_get_value.restype = ctypes.c_int
     lib.psrd_date_iterator_get_value.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_long, ctypes.c_void_p]
+    lib.psrd_convert_output.restype = ctypes.c_int
+    lib.psrd_convert_output.argtypes = [ctypes.c_char_p, ctypes.c_long, ctypes.c_char_p, ctypes.c_long, ctypes.c_void_p, ctypes.c_void_p]
 

psr/factory/samples/sddp_case01.py

@@ -28,7 +28,7 @@ def create_case01(legacy: bool = False) -> psr.factory.Study:
 
     # Study options
     study.from_dict({
-        "Type": 2,
+        "PARModel": 2,
         "InitialYearOfHydrology": 1996,
         "NumberOfSystems": 1,
         "AggregateInTheOperationPolicy": 0,
@@ -62,6 +62,7 @@ def create_case01(legacy: bool = False) -> psr.factory.Study:
     # Create a demand segment - it's required to add at least
     # an inelastic segment to a demand object.
     segment = psr.factory.create("DemandSegment", study.context)
+    segment.code = 1
     # Set demand and cost data.
     segment.set_at("EnergyPerBlock(:)", "01/2013", 8.928)
     # Add segment to the study.
@@ -113,7 +114,7 @@ def create_case01(legacy: bool = False) -> psr.factory.Study:
         "InstalledCapacity": 10.0,
         "ThermalType": 0,
         "Type": 0,
-        "NumberOfGeneratingUnits": 1,
+        "NumberOfUnits": 1,
         "NumberOfAlternativeFuels": 0,
         "CodeOfAlternativeFuels(:)": 0,
         "O&MCost": 0.0,

psr/factory/samples/sddp_case21.py

@@ -29,7 +29,7 @@ def create_case21(legacy: bool = False) -> psr.factory.Study:
     study.set("NumberOfSeries", 1)
 
     # Study options
-    study.set("Type", 2)
+    study.set("PARModel", 2)
     study.set("InitialYearOfHydrology", 2016)
     study.set("NumberOfSystems", 1)
     study.set("AggregateInTheOperationPolicy", 1)
@@ -118,7 +118,7 @@ def create_case21(legacy: bool = False) -> psr.factory.Study:
     plant1.set("InstalledCapacity", 12.0)
     plant1.set("ThermalType", 0)  # Standard operation mode.
     plant1.set("Type", 0)         # It's an existing plant.
-    plant1.set("NumberOfGeneratingUnits", 1)
+    plant1.set("NumberOfUnits", 1)
     plant1.set("NumberOfAlternativeFuels", 0)  # No alternative fuels
     plant1.set("CodeOfAlternativeFuels(:)", 0)
     plant1.set("O&MCost", 0.0)
@@ -141,7 +141,7 @@ def create_case21(legacy: bool = False) -> psr.factory.Study:
     plant2.set("InstalledCapacity", 8.0)
     plant2.set("ThermalType", 0)
     plant2.set("Type", 0)
-    plant2.set("NumberOfGeneratingUnits", 1)
+    plant2.set("NumberOfUnits", 1)
     plant2.set("NumberOfAlternativeFuels", 0)
     plant2.set("CodeOfAlternativeFuels(:)", 0)
     plant2.set("O&MCost", 0.0)

psr/{cloud/version.py → outputs/__init__.py}

@@ -1,5 +1,5 @@
-# PSR Cloud. Copyright (C) PSR, Inc - All Rights Reserved
+# PSR Factory. Copyright (C) PSR, Inc - All Rights Reserved
 # Unauthorized copying of this file, via any medium is strictly prohibited
 # Proprietary and confidential
 
-__version__ = "0.3.9"
+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

psr/outputs/resample.py

@@ -0,0 +1,289 @@
+import datetime as dt
+from typing import List, Dict, Optional, Tuple
+
+import numpy as np
+import pandas
+import pandas as pd
+import psr.factory
+
+HOURS_PER_DAY = 24
+DAYS_PER_WEEK = 7
+HOURS_PER_WEEK = HOURS_PER_DAY * DAYS_PER_WEEK  # 168 hours
+WEEKS_PER_YEAR = 52
+AR_STAGE_SAMPLES = 6
+
+_number_of_days_per_month = {1: 31, 2: 28, 3: 31, 4: 30, 5: 31, 6: 30, 7: 31, 8: 31, 9: 30, 10: 31, 11: 30, 12: 31}
+
+_g_week_start_date_by_year: Dict[int, List[dt.datetime]] = {}
+
+_week_max_hours = 7 * 24
+
+
+def get_sddp_stages_by_year(year: int) -> List[dt.datetime]:
+    global _g_week_start_date_by_year
+    if year not in _g_week_start_date_by_year:
+        _g_week_start_date_by_year[year] = [
+            dt.datetime(year, 1, 1),
+            dt.datetime(year, 1, 8),
+            dt.datetime(year, 1, 15),
+            dt.datetime(year, 1, 22),
+            dt.datetime(year, 1, 29),
+            dt.datetime(year, 2, 5),
+            dt.datetime(year, 2, 12),
+            dt.datetime(year, 2, 19),
+            dt.datetime(year, 2, 26),
+            dt.datetime(year, 3, 5),
+            dt.datetime(year, 3, 12),
+            dt.datetime(year, 3, 19),
+            dt.datetime(year, 3, 26),
+            dt.datetime(year, 4, 2),
+            dt.datetime(year, 4, 9),
+            dt.datetime(year, 4, 16),
+            dt.datetime(year, 4, 23),
+            dt.datetime(year, 4, 30),
+            dt.datetime(year, 5, 7),
+            dt.datetime(year, 5, 14),
+            dt.datetime(year, 5, 21),
+            dt.datetime(year, 5, 28),
+            dt.datetime(year, 6, 4),
+            dt.datetime(year, 6, 11),
+            dt.datetime(year, 6, 18),
+            dt.datetime(year, 6, 25),
+            dt.datetime(year, 7, 2),
+            dt.datetime(year, 7, 9),
+            dt.datetime(year, 7, 16),
+            dt.datetime(year, 7, 23),
+            dt.datetime(year, 7, 30),
+            dt.datetime(year, 8, 6),
+            dt.datetime(year, 8, 13),
+            dt.datetime(year, 8, 20),
+            dt.datetime(year, 8, 27),
+            dt.datetime(year, 9, 3),
+            dt.datetime(year, 9, 10),
+            dt.datetime(year, 9, 17),
+            dt.datetime(year, 9, 24),
+            dt.datetime(year, 10, 1),
+            dt.datetime(year, 10, 8),
+            dt.datetime(year, 10, 15),
+            dt.datetime(year, 10, 22),
+            dt.datetime(year, 10, 29),
+            dt.datetime(year, 11, 5),
+            dt.datetime(year, 11, 12),
+            dt.datetime(year, 11, 19),
+            dt.datetime(year, 11, 26),
+            dt.datetime(year, 12, 3),
+            dt.datetime(year, 12, 10),
+            dt.datetime(year, 12, 17),
+            dt.datetime(year, 12, 24)
+        ]
+    return _g_week_start_date_by_year[year]
+
+
+def get_closest_sddp_stage_date(y: int, m: int, d: int, previous_date: bool = True) -> Optional[dt.datetime]:
+    """Get the closest SDDP stage date for a given year, month, and day."""
+    dates = get_sddp_stages_by_year(y)
+    sdat = dt.datetime(y, m, d)
+    offset = 0 if previous_date else + 1
+    last_date = dates[-1]
+    if previous_date and sdat >= last_date:
+        return last_date
+    elif not previous_date and sdat >= last_date:
+        dates = get_sddp_stages_by_year(y + 1)
+        return dates[0]
+    else:
+        for index in range(len(dates)-1):
+            if dates[index] <= sdat < dates[index+1]:
+                return dates[index + offset]
+    return None
+
+
+def get_sddp_week(y: int, m: int, d: int) -> int:
+    dates = get_sddp_stages_by_year(y)
+    sdat = dt.datetime(y, m, d)
+    if dates[-1] <= sdat <= dt.datetime(y, 12, 31):
+        return WEEKS_PER_YEAR
+    else:
+        for index in range(len(dates)-1):
+            if dates[index] <= sdat < dates[index+1]:
+                return index + 1
+    return -1
+
+
+def get_sddp_start_date_and_stage(year, month, day) -> Tuple[dt.datetime, int]:
+    sddp_date = get_closest_sddp_stage_date(year, month, day, previous_date=True)
+    sddp_week = get_sddp_week(sddp_date.year, sddp_date.month, sddp_date.day)
+    return sddp_date, sddp_week
+
+
+def get_hour_block_map_from_study(study: psr.factory.Study) -> pandas.DataFrame:
+    """
+    Extract the HourBlockMap from the study and return as a DataFrame.
+    """
+    # FixedDurationOfBlocks(block)
+    stage_type = study.get("StageType")
+    hour_block_map_df = study.get_df("HourBlockMap")
+
+    if hour_block_map_df.empty:
+        initial_year = study.get("InitialYear")
+        end_year = initial_year + 10
+        total_blocks = study.get("NumberOfBlocks")
+        block_duration = {}
+        total_duration = 0
+        for block in range(1, total_blocks + 1):
+            # block duration is a percentage of total hours in a stage
+            block_duration[block] = study.get(f"FixedDurationOfBlocks({block})")
+            total_duration += block_duration[block]
+
+        if total_duration > 99.9:
+            # Group stage hours on blocks based on their relative durations to the total number of hours (total_duration)
+            if stage_type == 1:
+                total_duration = _week_max_hours
+                # weekly stages, fixed stage duration
+                mapping_data = []
+                for year in range(initial_year, end_year):
+                    start_date = pandas.Timestamp(f"{year}-01-01")
+                    for week in range(1, 53):
+                        accumulated_hours = total_duration
+                        for block in range(total_blocks, 0, -1):
+                            current_duration = int(block_duration[block] * total_duration // 100)
+                            if block != 1:
+                                current_hours = accumulated_hours - current_duration
+                            else:
+                                current_hours = 0
+                            for hour in range(current_hours, accumulated_hours):
+                                datetime_point = start_date + pandas.Timedelta(weeks=week - 1, hours=hour)
+                                formatted_datetime = f"{datetime_point.year}/{week:02d} {hour + 1}h"
+                                mapping_data.append({
+                                    'datetime': formatted_datetime,
+                                    'year': datetime_point.year,
+                                    'sddp_stage': week,
+                                    'sddp_block': block,
+                                    'stage_hour': hour + 1
+                                })
+                            accumulated_hours -= current_duration
+                hour_block_map_df = pandas.DataFrame(mapping_data).set_index('datetime')
+                # sort dataframe by year, sddp_stage, sddp_block, stage_hour
+                hour_block_map_df.sort_values(by=['year', 'sddp_stage', 'sddp_block', 'stage_hour'], inplace=True)
+            elif stage_type == 2:
+                # monthly stages, variable stage duration
+                mapping_data = []
+                for year in range(initial_year, end_year):
+                    for month in range(1, 13):
+                        start_date = pandas.Timestamp(f"{year}-{month:02d}-01")
+                        days_in_month = _number_of_days_per_month[month]
+                        total_duration = days_in_month * HOURS_PER_DAY
+                        accumulated_hours = total_duration
+                        for block in range(total_blocks, 0, -1):
+                            current_duration = int(block_duration[block] * total_duration // 100)
+                            if block != 1:
+                                current_hours = accumulated_hours - current_duration
+                            else:
+                                current_hours = 0
+                            for hour in range(current_hours, accumulated_hours):
+                                datetime_point = start_date + pandas.Timedelta(hours=hour)
+                                formatted_datetime = f"{datetime_point.year}/{datetime_point.month:02d} {hour + 1}h"
+                                mapping_data.append({
+                                    'datetime': formatted_datetime,
+                                    'year': datetime_point.year,
+                                    'sddp_stage': month,
+                                    'sddp_block': block,
+                                    'stage_hour': hour + 1
+                                })
+                            accumulated_hours -= current_duration
+                hour_block_map_df = pandas.DataFrame(mapping_data).set_index('datetime')
+                # sort dataframe by year, sddp_stage, sddp_block, stage_hour
+                hour_block_map_df.sort_values(by=['year', 'sddp_stage', 'sddp_block', 'stage_hour'], inplace=True)
+
+        else:
+            raise ValueError("Total duration of blocks must be 100% or more.")
+    else:
+        # format HourBlockMap dataframe to have year, sddp_week, sddp_block columns
+        # its index datetime column is in the following format: 'YYYY/WW HHHh', where WW is the week number (1-52) and HHH is the hour of the week (1-168)
+        # for weekly cases. for monthly cases, it is 'YYYY/MM HHHh', where MM is the month number (1-12) and HHH is the hour of the month (1-744).
+        hour_block_map_df = hour_block_map_df.reset_index()
+        hour_block_map_df['year'] = hour_block_map_df['datetime'].str.slice(0, 4).astype(int)
+        hour_block_map_df['sddp_stage'] = hour_block_map_df['datetime'].str.slice(5, 7).astype(int)
+        hour_block_map_df['stage_hour'] = hour_block_map_df['datetime'].str.slice(8, -1).astype(int)
+        hour_block_map_df['sddp_block'] = ((hour_block_map_df['hour_of_week'] - 1) // 6) + 1
+        hour_block_map_df = hour_block_map_df.set_index('datetime')[['year', 'sddp_week', 'sddp_block']]
+    return hour_block_map_df
+
+
+def remap_hourly_to_stage(hourly_df: pd.DataFrame, hour_block_map_df: pd.DataFrame, stage_type: int,
+                          aggregation_method: str = 'mean') -> pd.DataFrame:
+    """
+    Strategy to Map hourly data into weekly/monthly data:
+    - Merge the hourly data dataframe with the Study's hour block map dataframe
+    - Aggregate by stage and/or by block using avg, sum, max, etc
+    """
+    # create indices before merging
+    if stage_type == 1:
+        # weekly stages
+        hourly_df = hourly_df.copy()
+
+        hourly_df['year'] = hourly_df.index.year
+        hourly_df['sddp_stage'] = 0
+        hourly_df['stage_hour'] = 0
+        for irow, (index, row) in enumerate(hourly_df.iterrows()):
+            stage_start_date = get_closest_sddp_stage_date(index.year, index.month, index.day, previous_date=True)
+            week = get_sddp_week(index.year, index.month, index.day)
+            hour_of_week = ((index - stage_start_date).days * 24) + index.hour + 1
+            hourly_df.at[row.name, 'sddp_stage'] = week
+            hourly_df.at[row.name, 'stage_hour'] = hour_of_week
+    elif stage_type == 2:
+        # monthly stages
+        hourly_df = hourly_df.copy()
+        hourly_df['year'] = hourly_df.index.year
+        hourly_df['sddp_stage'] = hourly_df.index.month
+        hourly_df['stage_hour'] = ((hourly_df.index.day - 1) * 24) + hourly_df.index.hour + 1
+    else:
+        raise ValueError("Unsupported stage type. Only weekly (1) and monthly (2) are supported.")
+    hourly_df = hourly_df.set_index('year,sddp_stage,stage_hour'.split(','))
+    hour_block_map_df = hour_block_map_df.set_index('year,sddp_stage,stage_hour'.split(','))
+    merged_df = pd.merge(hourly_df, hour_block_map_df, left_index=True, right_index=True, how='inner')
+
+    numeric_cols = hourly_df.select_dtypes(include=[np.number]).columns.tolist()
+    result = merged_df.groupby(['year', 'sddp_stage'])[numeric_cols].agg(aggregation_method).reset_index()
+    result.sort_values(by=['year', 'sddp_stage'], inplace=True)
+    result.set_index(['year', 'sddp_stage'], inplace=True)
+    return result
+
+
+def remap_hourly_to_blocks(hourly_df: pd.DataFrame, hour_block_map_df: pd.DataFrame, stage_type: int,
+                          aggregation_method: str = 'mean') -> pd.DataFrame:
+    """
+    Strategy to Map hourly data into weekly/by block data:
+    - Merge the hourly data dataframe with the Study's hour block map dataframe
+    - Aggregate by stage and/or by block using avg, sum, max, etc
+    """
+    # create indices before merging
+    if stage_type == 1:
+        # weekly stages
+        hourly_df = hourly_df.copy()
+
+        hourly_df['year'] = hourly_df.index.year
+        hourly_df['sddp_stage'] = 0
+        hourly_df['stage_hour'] = 0
+        for irow, (index, row) in enumerate(hourly_df.iterrows()):
+            stage_start_date = get_closest_sddp_stage_date(index.year, index.month, index.day, previous_date=True)
+            week = get_sddp_week(index.year, index.month, index.day)
+            hour_of_week = ((index - stage_start_date).days * 24) + index.hour + 1
+            hourly_df.at[row.name, 'sddp_stage'] = week
+            hourly_df.at[row.name, 'stage_hour'] = hour_of_week
+    elif stage_type == 2:
+        # monthly stages
+        hourly_df = hourly_df.copy()
+        hourly_df['year'] = hourly_df.index.year
+        hourly_df['sddp_stage'] = hourly_df.index.month
+        hourly_df['stage_hour'] = ((hourly_df.index.day - 1) * 24) + hourly_df.index.hour + 1
+    else:
+        raise ValueError("Unsupported stage type. Only weekly (1) and monthly (2) are supported.")
+    hourly_df = hourly_df.set_index('year,sddp_stage,stage_hour'.split(','))
+    hour_block_map_df = hour_block_map_df.set_index('year,sddp_stage,stage_hour'.split(','))
+    merged_df = pd.merge(hourly_df, hour_block_map_df, left_index=True, right_index=True, how='inner')
+
+    numeric_cols = hourly_df.select_dtypes(include=[np.number]).columns.tolist()
+    result = merged_df.groupby(['year', 'sddp_stage', 'sddp_block'])[numeric_cols].agg(aggregation_method).reset_index()
+    result.sort_values(by=['year', 'sddp_stage', 'sddp_block'], inplace=True)
+    result.set_index(['year', 'sddp_stage', 'sddp_block'], inplace=True)
+    return result

psr/psrfcommon/psrfcommon.py

@@ -23,6 +23,9 @@ def change_cwd(new_dir: Union[str, pathlib.Path]):
 def exec_cmd(cmd: Union[str, List[str]], **kwargs) -> int:
     dry_run = kwargs.get("dry_run", False)
     print_progress = kwargs.get("show_progress", False)
+    env = kwargs.get("env", {})
+    proc_env = os.environ.copy()
+    proc_env.update(env)
 
     if print_progress or dry_run:
         sys.stdout.flush()
@@ -35,7 +38,7 @@ def exec_cmd(cmd: Union[str, List[str]], **kwargs) -> int:
         return_code = 0
     else:
         try:
-            return_code = subprocess.call(cmd, shell=True)
+            return_code = subprocess.call(cmd, shell=True, env=proc_env)
             if return_code > 0:
                 raise RuntimeError(f"Execution error, code {return_code}")
             else: