removed commented out code and simplified some docstrings

elenya-grant · elenya-grant · commit 102993095a0f · 2026-03-27T10:19:05.000-06:00
diff --git a/h2integrate/storage/battery/pysam_battery.py b/h2integrate/storage/battery/pysam_battery.py
@@ -21,11 +21,9 @@ class PySAMBatteryPerformanceModelConfig(StoragePerformanceBaseConfig):
     and reference module characteristics.
 
     Attributes:
-        max_capacity (float):
-            Maximum battery energy capacity in kilowatt-hours (kWh).
+        max_capacity (float): Maximum battery energy capacity in kilowatt-hours (kWh).
             Must be greater than zero.
-        max_charge_rate (float):
-            Rated power capacity of the battery in kilowatts (kW).
+        max_charge_rate (float): Rated power capacity of the battery in kilowatts (kW).
             Must be greater than zero.
         demand_profile (int | float | list): Demand values for each timestep, in
             the same units as `commodity_rate_units`. May be a scalar for constant
@@ -36,20 +34,14 @@ class PySAMBatteryPerformanceModelConfig(StoragePerformanceBaseConfig):
 
             - PySAM: ``"LFPGraphite"``, ``"LMOLTO"``, ``"LeadAcid"``, ``"NMCGraphite"``
 
-        min_soc_fraction (float):
-            Minimum allowable state of charge as a fraction (0 to 1).
-        max_soc_fraction (float):
-            Maximum allowable state of charge as a fraction (0 to 1).
-        init_soc_fraction (float):
-            Initial state of charge as a fraction (0 to 1).
-        control_variable (str):
-            Control mode for the PySAM battery, either ``"input_power"``
+        min_soc_fraction (float): Minimum allowable state of charge as a fraction (0 to 1).
+        max_soc_fraction (float): Maximum allowable state of charge as a fraction (0 to 1).
+        init_soc_fraction (float): Initial state of charge as a fraction (0 to 1).
+        control_variable (str): Control mode for the PySAM battery, either ``"input_power"``
             or ``"input_current"``.
-        ref_module_capacity (int | float, optional):
-            Reference module capacity in kilowatt-hours (kWh).
+        ref_module_capacity (int | float, optional): Reference module capacity in kWh.
             Defaults to 400.
-        ref_module_surface_area (int | float, optional):
-            Reference module surface area in square meters (m²).
+        ref_module_surface_area (int | float, optional): Reference module surface area in m².
             Defaults to 30.
         Cp (int | float, optional): Battery specific heat capacity [J/kg*K].
             Defaults to 900.
@@ -61,12 +53,11 @@ class PySAMBatteryPerformanceModelConfig(StoragePerformanceBaseConfig):
 
     max_capacity: float = field(validator=gt_zero)
     max_charge_rate: float = field(validator=gt_zero)
-    # demand_profile: int | float | list = field()
+
     chemistry: str = field(
         validator=contains(["LFPGraphite", "LMOLTO", "LeadAcid", "NMCGraphite"]),
     )
-    # min_soc_fraction: float = field(validator=range_val(0, 1))
-    # max_soc_fraction: float = field(validator=range_val(0, 1))
+
     init_soc_fraction: float = field(validator=range_val(0, 1))
     control_variable: str = field(
         default="input_power", validator=contains(["input_power", "input_current"])
@@ -90,68 +81,18 @@ class PySAMBatteryPerformanceModel(StoragePerformanceBase):
     bounds set by the user. It may exceed the bounds by up to 5% SOC.
 
     Attributes:
-        config (PySAMBatteryPerformanceModelConfig):
-            Configuration parameters for the battery performance model.
-        system_model (``BatteryStateful``):
-            Instance of the PySAM BatteryStateful model, initialized with
-            the selected chemistry and configuration parameters.
-        outputs (BatteryOutputs):
-            Container for simulation outputs such as SOC, chargeable/dischargeable
-            power, unmet demand, and unused commodities.
-        unmet_demand (float):
-            Tracks unmet demand during simulation (kW).
-        unused_commodity (float):
-            Tracks unused commodity during simulation (kW).
-
-    Inputs:
-        max_charge_rate (float):
-            Battery charge rate in kilowatts per hour (kW).
-        storage_capacity (float):
-            Total energy storage capacity in kilowatt-hours (kWh).
-        electricity_demand (ndarray):
-            Power demand time series (kW).
-        electricity_in (ndarray):
-            Commanded input electricity (kW), typically from dispatch.
-
-    Outputs:
-        unmet_demand_out (ndarray):
-            Remaining unmet demand after discharge (kW).
-        unused_commodity_out (ndarray):
-            Unused energy not absorbed by the battery (kW).
-        electricity_out (ndarray):
-            Dispatched electricity to meet demand (kW), including electricity from
-            electricity_in that was never used to charge the battery and
-            battery_electricity.
-        SOC (ndarray):
-            Battery state of charge (%).
-        battery_electricity (ndarray):
-            Electricity output from the battery model (kW).
+        system_model (``BatteryStateful``): Instance of the PySAM BatteryStateful model, initialized
+            with the selected chemistry and configuration parameters.
+
 
     Methods:
-        setup():
-            Defines model inputs, outputs, configuration, and connections
-            to plant-level dispatch (if applicable).
         compute(inputs, outputs, discrete_inputs, discrete_outputs):
             Runs the PySAM BatteryStateful model for a simulation timestep,
             updating outputs such as SOC, charge/discharge limits, unmet
             demand, and unused commodities.
-        simulate(electricity_in, electricity_demand, time_step_duration, control_variable,
-            sim_start_index=0):
-            Simulates the battery behavior across timesteps using either
-            input power or input current as control. This method is similar to what is
-            provided in typical compute methods in H2Integrate for running models, but
-            needs to be a separate method here to allow the dispatch function to call
-            and manage the performance model.
         _set_control_mode(control_mode=1.0, input_power=0.0, input_current=0.0,
             control_variable="input_power"):
             Sets the battery control mode (power or current).
-
-    Notes:
-        - Default timestep is 1 hour (``dt=1.0``).
-        - State of charge (SOC) bounds are set using the configuration's
-          ``min_soc_fraction`` and ``max_soc_fraction``.
-        - If a Pyomo dispatch solver is provided, the battery will simulate
-          dispatch decisions using solver inputs.
     """
 
     def initialize(self):
@@ -179,29 +120,12 @@ def setup(self):
         # Initialize the PySAM BatteryStateful model with defaults
         self.system_model = BatteryStateful.default(self.config.chemistry)
 
-        # Renaming outputs from battery to storage
-        # battery_electricity_discharge -> storage_electricity_discharge
-        # battery_electricity_charge -> storage_electricity_charge
-        # battery_electricity_out -> storage_electricity_out
-
     def compute(self, inputs, outputs, discrete_inputs=[], discrete_outputs=[]):
         """Run the PySAM Battery model for one simulation step.
 
         Configures the battery stateful model parameters (SOC limits, timestep,
         thermal properties, etc.), executes the simulation, and stores the
         results in OpenMDAO outputs.
-
-        Args:
-            inputs (dict):
-                Continuous input values (e.g., electricity_in, electricity_demand) or
-                battery design parameters.
-            outputs (dict):
-                Dictionary where model outputs (SOC, battery_discharge, unmet demand, etc.)
-                are written.
-            discrete_inputs (dict):
-                Discrete inputs such as control mode or Pyomo solver.
-            discrete_outputs (dict):
-                Discrete outputs (unused in this component).
         """
 
         # Size the battery based on inputs -> method brought from HOPP
@@ -241,7 +165,7 @@ def compute(self, inputs, outputs, discrete_inputs=[], discrete_outputs=[]):
         self.system_model.value("input_power", 0.0)
         self.system_model.execute(0)
 
-        self.run_storage(
+        outputs = self.run_storage(
             inputs["max_charge_rate"][0],
             inputs["max_charge_rate"][0],
             inputs["storage_capacity"][0],
@@ -384,8 +308,3 @@ def _set_control_mode(
             self.system_model.value("input_current", input_current)
             # Either `input_power` or `input_current`; need to adjust `control_mode` above
             self.control_variable = control_variable
-
-
-def dummy_function():
-    # this function is required for initializing the pyomo control input and nothing else
-    pass
diff --git a/h2integrate/storage/simple_storage_auto_sizing.py b/h2integrate/storage/simple_storage_auto_sizing.py
@@ -41,9 +41,6 @@ class StorageSizingModelConfig(StoragePerformanceBaseConfig):
     commodity: str = field(converter=(str.strip, str.lower))
     commodity_rate_units: str = field(converter=str.strip)
 
-    # min_soc_fraction: float = field(validator=range_val(0, 1))
-    # max_soc_fraction: float = field(validator=range_val(0, 1))
-
     # TODO: add in logic for having different discharge rate
     # charge_equals_discharge: bool = field(default=True)
     set_demand_as_avg_commodity_in: bool = field()
@@ -92,38 +89,6 @@ class StorageAutoSizingModel(StoragePerformanceBase):
 
     Then simulates performance of a basic storage component using the charge rate and
     capacity calculated.
-
-    Note: this storage performance model is intended to be used with the
-    `SimpleStorageOpenLoopController` controller and is not compatible with the
-    `DemandOpenLoopStorageController` controller.
-
-    Inputs:
-        {commodity}_in (float): Input commodity flow timeseries (e.g., hydrogen production)
-            used to estimate the demand if `commodity_demand_profile` is zero.
-            - Units: Defined in `commodity_rate_units` (e.g., "kg/h").
-        {commodity}_set_point (float): Input commodity flow timeseries (e.g., hydrogen production)
-            used as the available input commodity to meet the demand.
-        {commodity}_demand_profile (float): Demand profile of commodity.
-            - Units: Defined in `commodity_rate_units` (e.g., "kg/h").
-
-    Outputs:
-        max_capacity (float): Maximum storage capacity of the commodity.
-            - Units: in non-rate units, e.g., "kg" if `commodity_rate_units` is "kg/h"
-        max_charge_rate (float): Maximum rate at which the commodity can be charged
-            - Units: Defined in `commodity_rate_units` (e.g., "kg/h").
-            Assumed to also be the discharge rate.
-        {commodity}_out (np.ndarray): the commodity used to meet demand from the available
-            input commodity and storage component. Defined in `commodity_rate_units`.
-        total_{commodity}_produced (float): sum of commodity discharged from storage over
-            the simulation. Defined in `commodity_amount_units`
-        rated_{commodity}_production (float): maximum commodity that could be discharged
-            in a timestep. Defined in `commodity_rate_units`
-        annual_{commodity}_produced (np.ndarray): total commodity discharged per year.
-            Defined in `commodity_amount_units/year`
-        capacity_factor (np.ndarray): ratio of commodity discharged to the maximum
-            commodity that could be discharged over the simulation.
-            Defined as a ratio (units of `unitless`)
-
     """
 
     def setup(self):
@@ -192,12 +157,9 @@ def compute(self, inputs, outputs, discrete_inputs=[], discrete_outputs=[]):
         1) Estimate the starting SOC (as a fraction) at the start of the simulation.
             Take the first value in the SOC profile (in `commodity_amount_units`)
             and divide by the storage capacity
-        2) If `commodity_set_point` is an input, simulate the storage performance
-            using the `simulate()` method with the dispatch command input `commodity_set_point`.
-            Otherwise, make an input dictionary containing the calculated demand profile,
-            storage capacity, and storage fill rate, and run the input dispatch method.
-        3) Calculate the unmet demand, unused commodity, SOC, combined commodity output, etc.
-
+        2) Make an input dictionary containing the calculated demand profile,
+            storage capacity, and storage fill rate, and run the storage performance.
+        3) Calculate the outputs
         """
 
         # Part 0: get demand profile based on user input parameters
@@ -267,9 +229,7 @@ def compute(self, inputs, outputs, discrete_inputs=[], discrete_outputs=[]):
         outputs["max_discharge_rate"] = storage_max_empty_rate
         outputs["storage_capacity"] = rated_storage_capacity
 
-        # 2. Simulate the storage performance using the `simulate()`
-
-        # Make dictionary of inputs containing information to pass to the controller
+        # 2. Make dictionary of inputs containing information to pass to the controller
         # (such as demand profile, charge rate, and storage capacity)
         inputs_adjusted = dict(inputs.items())
         if self.config.set_demand_as_avg_commodity_in:
@@ -279,6 +239,7 @@ def compute(self, inputs, outputs, discrete_inputs=[], discrete_outputs=[]):
             inputs_adjusted["storage_capacity"] = np.array([rated_storage_capacity])
             inputs_adjusted["max_charge_rate"] = np.array([storage_max_fill_rate])
 
+        # 3. Simulate the storage performance and calculate outputs
         outputs = self.run_storage(
             storage_max_fill_rate,
             storage_max_empty_rate,
diff --git a/h2integrate/storage/storage_baseclass.py b/h2integrate/storage/storage_baseclass.py
@@ -24,65 +24,6 @@ class StoragePerformanceBaseConfig(BaseConfig):
     max_soc_fraction: float = field(validator=range_val(0, 1))
     demand_profile: int | float | list = field()
 
-    # Below is used in StoragePerformance and StorageAutoSizing
-    # commodity: str = field(converter=str.strip)
-    # commodity_rate_units: str = field(converter=str.strip)
-    # commodity_amount_units: str = field(default=None)
-    # charge_efficiency: float | None = field(default=None, validator=range_val_or_none(0, 1))
-    # discharge_efficiency: float | None = field(default=None, validator=range_val_or_none(0, 1))
-    # round_trip_efficiency: float | None = field(default=None, validator=range_val_or_none(0, 1))
-
-    # # Below is only used in StoragePerformance
-    # max_discharge_rate: float | None = field(default=None)
-    # charge_equals_discharge: bool = field(default=True)
-
-    # # Below is used in StoragePerformance and PySAMBattery
-    # max_capacity: float = field(validator=gt_zero)
-    # max_charge_rate: float = field(validator=gt_zero)
-    # init_soc_fraction: float = field(validator=range_val(0, 1))
-
-    # def __attrs_post_init__(self):
-    #     if (self.round_trip_efficiency is not None) and (
-    #         self.charge_efficiency is None and self.discharge_efficiency is None
-    #     ):
-    #         # Calculate charge and discharge efficiencies from round-trip efficiency
-    #         self.charge_efficiency = np.sqrt(self.round_trip_efficiency)
-    #         self.discharge_efficiency = np.sqrt(self.round_trip_efficiency)
-    #         self.round_trip_efficiency = None
-    #     if self.charge_efficiency is None or self.discharge_efficiency is None:
-    #         raise ValueError(
-    #             "Exactly one of the following sets of parameters must be set: (a) "
-    #             "`round_trip_efficiency`, or (b) both `charge_efficiency` "
-    #             "and `discharge_efficiency`."
-    #         )
-
-    ## Below only for StoragePerformance
-
-    # if self.charge_equals_discharge:
-    #     if (
-    #         self.max_discharge_rate is not None
-    #         and self.max_discharge_rate != self.max_charge_rate
-    #     ):
-    #         msg = (
-    #             "Max discharge rate does not equal charge rate but charge_equals_discharge"
-    #             f"is True. Discharge rate is {self.max_discharge_rate} and charge rate "
-    #             f"is {self.max_charge_rate}."
-    #         )
-    #         raise ValueError(msg)
-
-    #     self.max_discharge_rate = self.max_charge_rate
-
-    # if not self.charge_equals_discharge and self.max_discharge_rate is None:
-    #     msg = (
-    #         "max_discharge_rate is a required key when charge_equals_discharge is True."
-    #         "Please set a value for the max_discharge_rate."
-    #     )
-    #     raise ValueError(msg)
-
-    ## Below NOT used in PySAM battery
-    # if self.commodity_amount_units is None:
-    #     self.commodity_amount_units = f"({self.commodity_rate_units})*h"
-
 
 class StoragePerformanceBase(PerformanceModelBaseClass):
     """
@@ -123,6 +64,13 @@ class StoragePerformanceBase(PerformanceModelBaseClass):
     """
 
     def setup(self):
+        """Set up the storage performance model in OpenMDAO.
+
+        Initializes the configuration and defines inputs/outputs for OpenMDAO.
+        If dispatch connections are specified, it also sets up a discrete
+        input for Pyomo solver integration.
+        """
+
         # Below should be done in models that inherit it
         # self.commodity = self.config.commodity
         # self.commodity_rate_units = self.config.commodity_rate_units
@@ -288,7 +236,7 @@ def compute(self, inputs, outputs, discrete_inputs=[], discrete_outputs=[]):
         #     discharge_rate = inputs["max_discharge_rate"][0]
         # else:
         #     discharge_rate = inputs["max_charge_rate"][0]
-        # storage_capacity = inputs["storage_capacity"]
+        # storage_capacity = inputs["storage_capacity"][0]
         # outputs = self.run_storage(
         #     charge_rate, discharge_rate, storage_capacity, inputs, outputs, discrete_inputs
         # )
diff --git a/h2integrate/storage/storage_performance_model.py b/h2integrate/storage/storage_performance_model.py
