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

zen_garden/__init__.py

@@ -1,6 +1,7 @@
 from . import model
 from . import postprocess
 from . import preprocess
+from . import wrapper
 from .utils import get_inheritors
 from .model.element import Element
 from .optimization_setup import OptimizationSetup

zen_garden/cli/zen_garden_cli.py

@@ -51,11 +51,13 @@ def build_parser() -> argparse.ArgumentParser:
                                      add_help=True,
                                      usage="zen_garden [options]")
 
-    parser.add_argument("--config",
-                        type=str,
-                        required=False,
-                        default="./config.json",
-                        help="Path to a Python or JSON config file.")
+    parser.add_argument(
+        "--config",
+        type=str,
+        required=False,
+        default="./config.json",
+        help="Path to a Python or JSON config file."
+    )
     parser.add_argument(
         "--dataset",
         type=str,
@@ -69,19 +71,23 @@ def build_parser() -> argparse.ArgumentParser:
         required=False,
         default=None,
         help=
-        "Path to the output directory. Overrides output settings in config.")
+        "Path to the output directory. Overrides output settings in config."
+    )
     parser.add_argument(
         "--job_index",
         type=str,
         required=False,
         default=None,
         help="Comma-separated list of scenario indices. If omitted, the "
-        "environment variable specified by --job_index_var is used.")
-    parser.add_argument("--job_index_var",
-                        type=str,
-                        required=False,
-                        default="SLURM_ARRAY_TASK_ID",
-                        help="Environment variable for job index.")
+        "environment variable specified by --job_index_var is used."
+    )
+    parser.add_argument(
+        "--job_index_var",
+        type=str,
+        required=False,
+        default="SLURM_ARRAY_TASK_ID",
+        help="Environment variable for job index."
+    )
 
     return parser
 
@@ -155,10 +161,12 @@ def create_zen_garden_cli():
         Basic usage in a command line prompt:
 
         >>> zen-garden --config=".\\config.json" --dataset="1_base_case"
-
     """    
+    
     # parse command line arguments
     parser = build_parser()
+
+    # parse command line arguments
     args = parser.parse_args()
 
     ### get the job index

zen_garden/cli/zen_operation_cli.py

@@ -0,0 +1,89 @@
+from zen_garden.cli.zen_garden_cli import build_parser, resolve_job_index
+from zen_garden.wrapper.operation_scenarios import operation_scenarios
+import argparse
+
+def build_parser_op() -> argparse.ArgumentParser:
+
+    # load parser from zen-garden
+    parser = build_parser()
+    
+    parser.add_argument(
+        "--config_op",
+        required=False,
+        type=str,
+        default=None,
+        help=
+        "The config file used to run the operation-only model, defaults to " \
+        " --config."
+    )
+    parser.add_argument(
+        "--dataset_op",
+        required=False,
+        type=str,
+        default=None,
+        help=
+        "Name of the dataset used for the operation-only runs. The outputs " \
+        "will be saved under this dataset name"
+    )
+    parser.add_argument(
+        "--scenarios_op",
+        required=False,
+        type=str,
+        default=None,
+        help=
+        "Path to the scenarios.json file used in the operation-only runs. " \
+        "Defaults to the scenarios.json file from --dataset"
+    )
+    parser.add_argument(
+        "--delete_data",
+        action="store_true",
+        help=
+        "Deletes the created operation-only models upon termination to avoid " \
+        "cluttering the data directory"
+    )
+
+    # add parser description
+    parser.description = "Run ZEN garden with a given config file. Per default, the" \
+                  "config file will be read out from the current working " \
+                  "directory. You can specify a config file with the --config "\
+                  "argument. However, note that the output directory will " \
+                  "always be the current working directory, independent of " \
+                  "the dataset specified in the config file."
+    
+    parser.usage = "usage: python -m zen_garden.wrapper.operational_scenarios [-h] " \
+        "[--config CONFIG] [--dataset DATASET] [--folder_output FOLDER_OUTPUT] "\
+        "[--job_index JOB_INDEX] [--job_index_var JOB_INDEX_VAR] "\
+        "[--scenarios_op SCENARIOS_OP] " \
+        "[--delete_data] [--use_existing]"
+    
+    return parser
+
+
+def create_zen_operation_cli() -> None:
+
+    # create parser and parse command line argument
+    parser = build_parser_op()
+    args = parser.parse_args()
+
+    # Make dataset a required argument
+    if args.dataset is None:
+        raise argparse.ArgumentError(
+            "Missing required argument --dataset."
+        ) 
+      
+    # Resolve job index
+    job_index = resolve_job_index(args.job_index, args.job_index_var)
+
+    # run operation scenarios
+    operation_scenarios(
+        config=args.config,
+        dataset = args.dataset,
+        folder_output=args.folder_output,
+        job_index=job_index,
+        scenarios_op=args.scenarios_op,
+        delete_data=args.delete_data,
+    )
+
+if __name__ == "__main__":
+    
+    create_zen_operation_cli()

zen_garden/default_config.py

@@ -152,7 +152,6 @@ class System(Subscriptable):
     use_capacities_existing: bool = True
     allow_investment: bool = True
     storage_charge_discharge_binary: bool = False
-    include_operation_only_phase: bool = False
 
 
 
@@ -170,9 +169,7 @@ class Solver(Subscriptable):
     save_parameters: bool = True
     selected_saved_parameters: list = []  # if empty, all parameters are saved
     selected_saved_variables: list = []  # if empty, all variables are saved
-    selected_saved_variables_operation: list = []  # if empty, all variables are saved
     selected_saved_duals: list = []  # if empty, all duals are saved (if save_duals is True)
-    selected_saved_duals_operation: list = []  # if empty, all duals are saved (if save_duals is True)
     linear_regression_check: dict[str, float] = {
         "eps_intercept": 0.1,
         "epsRvalue": 1 - (1e-5),

zen_garden/optimization_setup.py

@@ -78,10 +78,6 @@ class OptimizationSetup(object):
         # step of optimization horizon
         self.step_horizon = 0
 
-        # flag marking whether the optimization is in capacity expansion or
-        # operations-only phase (only if `include_operation_only_phase` is true)
-        self.operation_only_phase = False
-
         # Init the energy system
         self.energy_system = EnergySystem(optimization_setup=self)
 
@@ -538,159 +534,51 @@ class OptimizationSetup(object):
             parser.write_parsed_output()
 
     def add_results_of_optimization_step(self, step_horizon):
-        """Adds capacity additions and carbon emissions to next optimization step
-
-        This function takes the capacity additions and carbon emissions of the 
-        current optimization step and adds them to the existing capacity and
-        existing emissions of the next optimization step. It is used for myopic 
-        foresight and for operation-only model runs. 
-
-        In myopic foresight, values from the currently simulated year are added 
-        as existing capacities and emissions for future steps.
-
-        In operation-only optimizations, installed capacities from the previous 
-        investment optimization are added as existing capacities.
-
-        In optimizations with both features, the capacity additions are taken from 
-        the investment phase while the emissions are taken from 
-        the operation phase. This allows model users to 
-        differentiate between how the system is planned and operated. 
-
-        :param step_horizon: year index of the current optimization step. 
-            In myopic foresight, capacities and emissions from this step are 
-            added to existing capacities and emissions.
-        :type step_horizon: int
-
-        :returns: None
-        """
-
-        if self.system.use_rolling_horizon:
-            if not self.system.include_operation_only_phase:
-                decision_horizon = self.get_decision_horizon(step_horizon)
-                self.add_new_capacity_addition(decision_horizon)
-                self.add_carbon_emission_cumulative(decision_horizon)
-
-            elif not self.operation_only_phase:
-                self.save_current_existing_capacity()
-                time_steps = self.energy_system.set_time_steps_yearly
-                self.add_new_capacity_addition(time_steps)
-
-            else:
-                self.reset_existing_capacity_to_previous_step()
-                decision_horizon = self.get_decision_horizon(step_horizon)
-                self.add_new_capacity_addition(decision_horizon, capacity_addition = self._old_capacity_addition, invest_capacity = self._old_invest_capacity, cost_capex_overnight = self._old_cost_capex_overnight)
-                self.add_carbon_emission_cumulative(decision_horizon)
-
-        else:
-            if  self.system.include_operation_only_phase and not self.operation_only_phase:
-                time_steps = self.energy_system.set_time_steps_yearly
-                self.add_new_capacity_addition(time_steps)
-
-    def save_current_existing_capacity(self):
         """
-        Stores current capacity values for each technology
-
-        This function saves a copy of the input 
-        paratmeters: capacity_existing, lifetime_existing, 
-        capex_capacity_existing, capacity_existing_energy,
-        and capex_capacity_existing_energy. The copies of these variables are
-        saved directly to the technology class in attributes named 
-        "_old_<parameter_name>".
+        Adds capacity additions and carbon emissions to the next optimization step.
 
-        :returns: None
-        """
-        for tech in self.get_all_elements(Technology):
-            # new capacity
-            tech._old_capacity_existing = tech.capacity_existing.copy(deep=True)
-            tech._old_capex_capacity_existing = (
-                tech.capex_capacity_existing.copy(deep=True)
-            )
-            tech._old_lifetime_existing = tech.lifetime_existing.copy(deep=True)
-            tech._old_set_technologies_existing = tech.set_technologies_existing
-            if hasattr(tech, 'capex_capacity_existing_energy'):
-                tech._old_capex_capacity_existing_energy = (
-                    tech.capex_capacity_existing_energy.copy(deep=True)
-                )
-            if hasattr(tech, 'capacity_existing_energy'):
-                tech._old_capacity_existing_energy = (
-                    tech.capacity_existing_energy.copy(deep=True)
-                )
-        
-        self._old_capacity_addition = self.model.solution["capacity_addition"].to_series().dropna()
-        self._old_invest_capacity = self.model.solution["capacity_investment"].to_series().dropna()
-        self._old_cost_capex_overnight = self.model.solution["cost_capex_overnight"].to_series().dropna()
+        This function takes the capacity additions and carbon emissions of the 
+        current optimization step and adds them to the existing capacity and 
+        existing emissions of the next optimization step. Values from the 
+        currently simulated year are added as existing capacities and 
+        emissions for future steps.
 
+        Args:
+            step_horizon (int): The year index of the current optimization step. 
+                In myopic foresight, capacities and emissions from this step are 
+                added to existing capacities and emissions.
 
+        Returns:
+            None
 
-    def reset_existing_capacity_to_previous_step(self):
         """
-        Resets existing capacities to saved values
+        decision_horizon = self.get_decision_horizon(step_horizon)
+        # add newly capacity_addition of first year to existing capacity
+        self.add_new_capacity_addition(decision_horizon)
+        # add cumulative carbon emissions to previous carbon emissions
+        self.add_carbon_emission_cumulative(decision_horizon)
 
-        This function resets capacity-related input parameters to
-        previously saved values. The following parameters are reset:
-        capacity_existing, lifetime_existing, capex_capacity_existing, 
-        capacity_existing_energy, and capex_capacity_existing_energy. The values 
-        are taken from the technology attributes "_old_<parameter_name>", as
-        saved by :meth:`OptimizationSetup.save_current_existing_capacity`. 
-
-        :returns: None
+    def add_new_capacity_addition(self, decision_horizon):
         """
-        for tech in self.get_all_elements(Technology):
-            # new capacity
-            tech.capacity_existing = tech._old_capacity_existing
-            tech.capex_capacity_existing = tech._old_capex_capacity_existing
-            tech.lifetime_existing = tech._old_capex_capacity_existing
-            tech.set_technologies_existing = tech._old_set_technologies_existing
-            if hasattr(tech, '_old_capex_capacity_existing_energy'):
-                tech.capex_capacity_existing_energy = (
-                    tech._old_capex_capacity_existing_energy
-                )
-            if hasattr(tech, '_old_capacity_existing_energy'):
-                tech.capacity_existing_energy = (
-                    tech._old_capacity_existing_energy
-                )
-
-    def add_new_capacity_addition(self, 
-                                  decision_horizon, 
-                                  capacity_addition = None,
-                                  invest_capacity = None,
-                                  cost_capex_overnight = None):
-        """ Adds the newly built capacity to the existing capacity
+        Adds the newly built capacity to the existing capacity.
 
         This function adds installed capacities from the current optimization 
-        step to existing capacities in the model. It also adds 
-        costs from the installed capacities to existing capacity investment. 
-        Capacity values whose magnitude is below that specified by the solver
-        setting "rounding_decimal_points_capacity" are set to zero.
-
-        :param decision_horizon: list of the years for to transfer installed 
-            capacities to existing capacities. 
-        :type decision_horizon: list or int
+        step to existing capacities in the model. It also adds costs from the 
+        installed capacities to existing capacity investment. Capacity values whose 
+        magnitude is below that specified by the solver setting 
+        "rounding_decimal_points_capacity" are set to zero.
 
-        :param capacity_addition: dataframe of capacity additions to add to 
-            existing capacities (optional). If blank, capacity additions are 
-            taken from the current modeling results.
-        :type capacity_addition: pandas.DataFrame
+        Args:
+            decision_horizon (list or int): A list of the years to transfer installed 
+                capacities to existing capacities.
 
-        :param invest_capacity: dataframe of capacity investments to add to 
-            existing investments (optional). If blank, capacity investments are 
-            taken from the current modeling results.
-        :type invest_capacity: pandas.DataFrame
-
-        :param cost_capex_overnight: dataframe of overnight capital costs to 
-            add to existing investments (optional). If blank, capital costs are 
-            taken from the current modeling results.
-        :type cost_capex_overnight: pandas.DataFrame
-
-        :returns: None
+        Returns:
+            None
 
         """
-        if capacity_addition is None:
-            capacity_addition = self.model.solution["capacity_addition"].to_series().dropna()
-        if invest_capacity is None:
-            invest_capacity = self.model.solution["capacity_investment"].to_series().dropna()
-        if cost_capex_overnight is None:
-            cost_capex_overnight = self.model.solution["cost_capex_overnight"].to_series().dropna()
+        capacity_addition = self.model.solution["capacity_addition"].to_series().dropna()
+        invest_capacity = self.model.solution["capacity_investment"].to_series().dropna()
+        cost_capex_overnight = self.model.solution["cost_capex_overnight"].to_series().dropna()
 
         if self.solver.round_parameters:
             rounding_value = 10 ** (-self.solver.rounding_decimal_points_capacity)
@@ -709,17 +597,19 @@ class OptimizationSetup(object):
             tech.add_new_capacity_investment(capacity_investment, decision_horizon)
 
     def add_carbon_emission_cumulative(self, decision_horizon):
-        """ Add current emissions to existing emissions.
+        """
+        Adds current emissions to existing emissions.
 
         This function adds carbon emissions from the current optimization 
         step to the existing carbon emissions.
 
-        :param decision_horizon: list of the years for to transfer installed 
-            capacities to existing capacities. 
-        :type decision_horizon: list or int
+        Args:
+            decision_horizon (list or int): A list of the years to transfer 
+                emissions to existing emissions.
 
-        :returns: None
-        
+        Returns:
+            None
+            
         """
         interval_between_years = self.energy_system.system.interval_between_years
         last_year = decision_horizon[-1]
@@ -793,30 +683,4 @@ class OptimizationSetup(object):
                 component_data.index = _custom_index
                 return component_data
             except KeyError:
-                raise KeyError(f"the custom set {custom_set} cannot be used as a subindex of {component_data.index}")
-
-    def set_phase_configurations(self, phase):
-        """ Sets proper configurations for operation-only problems.
-         
-        This function sets proper configurations for the current phase 
-        (capacity planning vs. operation only) of the model. 
-         
-        :param phase: current phase of the optimization. Must be either
-            `investment` (for capacity planning) or `operations` for
-            operations-only.
-        :type phase: str
-
-        :returns: None
-        """
-
-        if phase == 'investment':
-            logging.info(f"---- Optimizing investment ----")
-            self.system.allow_investment = True
-            self.operation_only_phase = False
-
-        elif phase == 'operation':
-            logging.info(f"---- Optimizing operation only ----")
-            self.system.allow_investment = False
-            self.operation_only_phase = True
-        else:
-            raise ValueError(f"Unrecognized phase: {phase}")
+                raise KeyError(f"the custom set {custom_set} cannot be used as a subindex of {component_data.index}")

zen_garden/postprocess/postprocess.py

@@ -295,13 +295,8 @@ class Postprocess:
 
             # skip variables not selected to be saved
             if (
-                not self.optimization_setup.operation_only_phase 
-                and self.solver.selected_saved_variables 
+                self.solver.selected_saved_variables 
                 and name not in self.solver.selected_saved_variables
-            ) or (
-                self.optimization_setup.operation_only_phase
-                and self.solver.selected_saved_variables_operation
-                and name not in self.solver.selected_saved_variables_operation
             ):
                 continue
             
@@ -326,24 +321,14 @@ class Postprocess:
 
             units = self._unit_df(units,df.index)
 
-            # rename for operations-only duals
-            if self.optimization_setup.operation_only_phase:
-                name = name + '_operation'
-
             # transform the dataframe to a json string and load it into the dictionary as dict
             data_frames[name] = self._transform_df(df,doc,units)
         
-        # choose whether to write new file or append to existing file
-        if self.optimization_setup.operation_only_phase:
-            mode = 'a'
-        else: 
-            mode = 'w'
-
         # write file
         self.write_file(
             self.name_dir.joinpath('var_dict'), 
             data_frames, 
-            mode = mode
+            mode = 'w'
         )
 
     def save_duals(self):
@@ -361,13 +346,8 @@ class Postprocess:
 
             # skip variables not selected to be saved
             if (
-                not self.optimization_setup.operation_only_phase 
-                and self.solver.selected_saved_duals
+                self.solver.selected_saved_duals 
                 and name not in self.solver.selected_saved_duals
-            ) or (
-                self.optimization_setup.operation_only_phase
-                and self.solver.selected_saved_duals_operation
-                and name not in self.solver.selected_saved_duals_operation
             ):
                 continue
             
@@ -394,24 +374,14 @@ class Postprocess:
             if len(df.index.names) == len(index_list):
                 df.index.names = index_list
 
-            # rename for operations-only duals
-            if self.optimization_setup.operation_only_phase:
-                name = name + '_operation'
-
             # we transform the dataframe to a json string and load it into the dictionary as dict
             data_frames[name] = self._transform_df(df,doc)
 
-        # choose whether to write new file or append to existing file
-        if self.optimization_setup.operation_only_phase:
-            mode = 'a'
-        else: 
-            mode = 'w'
-
         # write file
         self.write_file(
             self.name_dir.joinpath('dual_dict'), 
             data_frames, 
-            mode = mode
+            mode = 'w'
         )
 
     def save_system(self):

zen_garden/postprocess/results/solution_loader.py

@@ -178,6 +178,10 @@ class Scenario():
             return {}
 
     def _read_ureg(self,default_ureg) -> pint.UnitRegistry:
+
+        # suppress pint output about redefining units
+        logging.getLogger('pint').setLevel(logging.ERROR)
+        # load ureg
         ureg = copy.copy(default_ureg)
         unit_path = os.path.join(self.path, "unit_definitions.txt")
         if os.path.exists(unit_path):
@@ -379,6 +383,9 @@ class SolutionLoader():
                 series_to_concat.append(current_mf)
                 break
 
+        if len(series_to_concat) == 0:
+            return pd.Series(dtype=float)
+
         return pd.concat(series_to_concat)
 
     def _concatenate_raw_dataseries(