GridCalEngine 5.3.25__tar.gz → 5.3.26__tar.gz

{gridcalengine-5.3.25 → gridcalengine-5.3.26}/GridCalEngine/Compilers/circuit_to_data.py

@@ -655,6 +655,7 @@ def fill_generator_parent(
     data.min_time_down[k] = elm.MinTimeDown
 
     data.dispatchable[k] = elm.enabled_dispatch
+    data.capex[k] = elm.capex
 
     data.snom[k] = elm.Snom
 
@@ -1074,6 +1075,14 @@ def fill_controllable_branch(
                                  value=elm.vset,
                                  expected_value=bus_data.Vbus[bus_idx])
 
+        # modify the voltage angle guess using the phase
+        if ctrl_data.tap_angle[ii] != 0:
+            f = bus_dict[elm.bus_from]
+            t = bus_dict[elm.bus_to]
+            Vm = abs(bus_data.Vbus[f])
+            Va = np.angle(bus_data.Vbus[f], deg=False)
+            bus_data.Vbus[f] = Vm * np.exp(1j * (Va + ctrl_data.tap_angle[ii]))
+
 
 def get_branch_data(
         data: PassiveBranchData,
@@ -1913,6 +1922,7 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
                                  control_taps_modules: bool = True,
                                  control_taps_phase: bool = True,
                                  control_remote_voltage: bool = True,
+                                 fill_gep: bool = False,
                                  logger=Logger()) -> NumericalCircuit:
     """
     Compile a NumericalCircuit from a MultiCircuit
@@ -1927,6 +1937,7 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
     :param control_taps_modules: control taps modules?
     :param control_taps_phase: control taps phase?
     :param control_remote_voltage: control remote voltage?
+    :param fill_gep: fill generation expansion planning parameters?
     :param logger: Logger instance
     :return: NumericalCircuit instance
     """
@@ -1935,7 +1946,8 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
     time_series = t_idx is not None
 
     bus_voltage_used = np.zeros(circuit.get_bus_number(), dtype=bool)
-
+    ngen = circuit.get_generators_number()
+    nbatt = circuit.get_batteries_number()
     # declare the numerical circuit
     nc = NumericalCircuit(
         nbus=circuit.get_bus_number(),
@@ -1945,8 +1957,8 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
         nhvdc=circuit.get_hvdc_number(),
         nvsc=circuit.get_vsc_number(),
         nload=circuit.get_load_like_device_number(),
-        ngen=circuit.get_generators_number(),
-        nbatt=circuit.get_batteries_number(),
+        ngen=ngen,
+        nbatt=nbatt,
         nshunt=circuit.get_shunt_like_device_number(),
         nfluidnode=circuit.get_fluid_nodes_number(),
         nfluidturbine=circuit.get_fluid_turbines_number(),
@@ -2111,6 +2123,42 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
             t_idx=t_idx
         )
 
+
+    if fill_gep:
+
+        # formulate the investment
+        gen_dict = {elm.idtag: (idx, elm) for idx, elm in enumerate(circuit.generators)}
+        batt_dict = {elm.idtag: (idx, elm) for idx, elm in enumerate(circuit.batteries)}
+
+        for investment in circuit.investments:
+
+
+
+            # search in generators
+            data = gen_dict.get(investment.device_idtag, None)
+            if data is not None:
+                idx, elm = data
+
+                if investment.CAPEX != 0.0:  # overwrite the base capex
+                    nc.generator_data.capex[idx] = investment.CAPEX
+
+                nc.generator_data.is_candidate[idx] = True
+                nc.generator_data.discount_rate[idx] = investment.group.discount_rate
+            else:
+
+                # search in batteries
+                data = batt_dict.get(investment.device_idtag, None)
+                if data is not None:
+                    idx, elm = data
+
+                    if investment.CAPEX != 0.0:  # overwrite the base capex
+                        nc.battery_data.capex[idx] = investment.CAPEX
+
+                    nc.battery_data.is_candidate[idx] = True
+                    nc.battery_data.discount_rate[idx] = investment.group.discount_rate
+                else:
+                    logger.add_error("Could not find investment device", value=investment.device_idtag)
+
     nc.bus_dict = bus_dict
     nc.consolidate_information()
 

{gridcalengine-5.3.25 → gridcalengine-5.3.26}/GridCalEngine/DataStructures/generator_data.py

@@ -68,6 +68,10 @@ class GeneratorData:
         self.min_time_up: Vec = np.zeros(nelm, dtype=float)
         self.min_time_down: Vec = np.zeros(nelm, dtype=float)
 
+        self.capex: Vec = np.zeros(nelm, dtype=float)
+        self.discount_rate: Vec = np.zeros(nelm, dtype=float)
+        self.is_candidate: BoolVec = np.zeros(nelm, dtype=bool)
+
         self.original_idx = np.zeros(nelm, dtype=int)
 
         self.name_to_idx: dict = dict()
@@ -138,6 +142,10 @@ class GeneratorData:
         data.min_time_up = self.min_time_up[elm_idx]
         data.min_time_down = self.min_time_down[elm_idx]
 
+        data.capex = self.capex[elm_idx]
+        data.discount_rate = self.discount_rate[elm_idx]
+        data.is_candidate = self.is_candidate[elm_idx]
+
         data.original_idx = elm_idx
 
         return data
@@ -211,6 +219,10 @@ class GeneratorData:
         data.min_time_up = self.min_time_up.copy()
         data.min_time_down = self.min_time_down.copy()
 
+        data.capex = self.capex.copy()
+        data.discount_rate = self.discount_rate.copy()
+        data.is_candidate = self.is_candidate.copy()
+
         data.original_idx = self.original_idx
 
         return data

{gridcalengine-5.3.25 → gridcalengine-5.3.26}/GridCalEngine/Devices/Aggregation/investment.py

@@ -45,15 +45,16 @@ class Investment(EditableDevice):
         # Contingency type
         self.device_idtag: str = device_idtag
         self.CAPEX: float = CAPEX
-        self.OPEX: float = OPEX
+        # self.OPEX: float = OPEX
         self._group: InvestmentsGroup = group
         self.status: bool = status
 
         self.register(key='device_idtag', units='', tpe=str, definition='Unique ID')
         self.register(key='CAPEX', units='M€', tpe=float,
-                      definition='Capital expenditures. This is the initial investment.')
-        self.register(key='OPEX', units='M€', tpe=float,
-                      definition='Operation expenditures. Maintenance costs among other recurrent costs.')
+                      definition='Capital expenditures. This is the investment value, '
+                                 'it overrides the CAPEX value of the device if it exits.')
+        # self.register(key='OPEX', units='M€', tpe=float,
+        #               definition='Operation expenditures. Maintenance costs among other recurrent costs.')
         self.register(key='status', units='', tpe=bool,
                       definition='If true the investment activates when applied, otherwise is deactivated.')
         self.register(key='group', units='', tpe=DeviceType.InvestmentsGroupDevice, definition='Investment group')

{gridcalengine-5.3.25 → gridcalengine-5.3.26}/GridCalEngine/Devices/Aggregation/investments_group.py

@@ -16,13 +16,15 @@ class InvestmentsGroup(EditableDevice):
                  idtag: Union[str, None] = None,
                  name: str = "InvestmentGroup",
                  category: str = '',
-                 comment: str = ""):
+                 comment: str = "",
+                 discount_rate=5):
         """
         Contingency group
         :param idtag: Unique identifier
         :param name: contingency group name
         :param category: tag to category the group
         :param comment: comment
+        :param discount_rate: discount rate (%)
         """
 
         EditableDevice.__init__(self,
@@ -35,4 +37,7 @@ class InvestmentsGroup(EditableDevice):
         # Contingency type
         self.category = category
 
-        self.register(key='category', units='', tpe=str, definition='Some tag to category the contingency group')
+        self.discount_rate = discount_rate
+
+        self.register(key='category', units='', tpe=str, definition='Some tag to category the investment group')
+        self.register(key='discount_rate', units='%', tpe=float, definition='Investment group discount rate')

{gridcalengine-5.3.25 → gridcalengine-5.3.26}/GridCalEngine/Simulations/ContingencyAnalysis/Methods/optimal_linear_contingency_analysis.py

@@ -98,7 +98,7 @@ def optimal_linear_contingency_analysis(grid: MultiCircuit,
                                  skip_generation_limits=False,
                                  consider_contingencies=True,
                                  contingency_groups_used=linear_multiple_contingencies.contingency_groups_used,
-                                 unit_Commitment=False,
+                                 unit_commitment=False,
                                  ramp_constraints=False,
                                  all_generators_fixed=True,
                                  lodf_threshold=options.lin_options.lodf_threshold,

{gridcalengine-5.3.25 → gridcalengine-5.3.26}/GridCalEngine/Simulations/NodalCapacity/nodal_capacity_ts_driver.py

@@ -142,7 +142,7 @@ class NodalCapacityTimeSeriesDriver(TimeSeriesDriverTemplate):
                                      skip_generation_limits=self.opf_options.skip_generation_limits,
                                      consider_contingencies=self.opf_options.consider_contingencies,
                                      contingency_groups_used=self.opf_options.contingency_groups_used,
-                                     unit_Commitment=self.opf_options.unit_commitment,
+                                     unit_commitment=self.opf_options.unit_commitment,
                                      ramp_constraints=self.opf_options.unit_commitment,
                                      all_generators_fixed=False,
                                      lodf_threshold=self.opf_options.lodf_tolerance,

{gridcalengine-5.3.25 → gridcalengine-5.3.26}/GridCalEngine/Simulations/OPF/linear_opf_ts.py

@@ -195,8 +195,7 @@ class GenerationVars:
         self.starting_up = np.zeros((nt, n_elm), dtype=object)
         self.shutting_down = np.zeros((nt, n_elm), dtype=object)
         self.cost = np.zeros((nt, n_elm), dtype=object)
-        # self.fuel = np.zeros((nt, n_elm), dtype=object)
-        # self.emissions = np.zeros((nt, n_elm), dtype=object)
+        self.invested = np.zeros((nt, n_elm), dtype=object)
 
     def get_values(self,
                    Sbase: float,
@@ -222,8 +221,7 @@ class GenerationVars:
                 data.starting_up[t, i] = model.get_value(self.starting_up[t, i])
                 data.shutting_down[t, i] = model.get_value(self.shutting_down[t, i])
                 data.cost[t, i] = model.get_value(self.cost[t, i])
-                # data.fuel[t, i] = model.get_value(self.fuel[t, i])
-                # data.emissions[t, i] = model.get_value(self.emissions[t, i])
+                data.invested[t, i] = model.get_value(self.invested[t, i])
 
         # format the arrays appropriately
         data.p = data.p.astype(float, copy=False)
@@ -232,8 +230,7 @@ class GenerationVars:
         data.starting_up = data.starting_up.astype(bool, copy=False)
         data.shutting_down = data.shutting_down.astype(bool, copy=False)
         data.cost = data.cost.astype(float, copy=False)
-        # data.fuel = (gen_fuel_rates_matrix.T * data.p.T).T
-        # data.emissions = (gen_emissions_rates_matrix.T * data.p.T).T
+        data.invested = data.invested.astype(bool, copy=False)
 
         return data
 
@@ -271,6 +268,8 @@ class BatteryVars(GenerationVars):
                 data.producing[t, i] = model.get_value(self.producing[t, i])
                 data.starting_up[t, i] = model.get_value(self.starting_up[t, i])
                 data.shutting_down[t, i] = model.get_value(self.shutting_down[t, i])
+                data.cost[t, i] = model.get_value(self.cost[t, i])
+                data.invested[t, i] = model.get_value(self.invested[t, i])
 
             # format the arrays appropriately
             data.p = data.p.astype(float, copy=False)
@@ -279,6 +278,8 @@ class BatteryVars(GenerationVars):
             data.producing = data.producing.astype(int, copy=False)
             data.starting_up = data.starting_up.astype(int, copy=False)
             data.shutting_down = data.shutting_down.astype(int, copy=False)
+            data.cost = data.cost.astype(float, copy=False)
+            data.invested = data.invested.astype(bool, copy=False)
 
         return data
 
@@ -664,7 +665,8 @@ def add_linear_generation_formulation(t: Union[int, None],
                                       skip_generation_limits: bool,
                                       all_generators_fixed: bool,
                                       vd: IntVec,
-                                      nodal_capacity_active: bool):
+                                      nodal_capacity_active: bool,
+                                      generation_expansion_planning: bool):
     """
     Add MIP generation formulation
     :param t: time step
@@ -680,6 +682,7 @@ def add_linear_generation_formulation(t: Union[int, None],
                                  instead of resorting to dispatchable status
     :param vd: slack indices
     :param nodal_capacity_active: nodal capacity active?
+    :param generation_expansion_planning: generation expansion plan?
     :return objective function
     """
     f_obj = 0.0
@@ -691,6 +694,9 @@ def add_linear_generation_formulation(t: Union[int, None],
     else:
         id_gen_nonvd = []
 
+    year = time_array[t].year - time_array[0].year
+
+
     # add generation stuff
     for k in range(gen_data_t.nelm):
 
@@ -773,6 +779,30 @@ def add_linear_generation_formulation(t: Union[int, None],
                             prob.add_cst(
                                 cst=gen_vars.p[t, k] - gen_vars.p[t - 1, k] <= gen_data_t.ramp_up[k] / Sbase * dt
                             )
+
+                # Generation Expansion Planning
+                if gen_data_t.is_candidate[k] and generation_expansion_planning:
+
+                    money_factor = np.power(1.0 + gen_data_t.discount_rate[k] / 100.0, year)
+
+                    # declare the investment binary
+                    gen_vars.invested[t, k] = prob.add_int(lb=0, ub=1, name=join("Ig_", [t, k]))
+
+                    # add the investment cost to the objective
+                    f_obj += gen_vars.invested[t, k] * (gen_data_t.pmax[k] / Sbase) * gen_data_t.capex[k] * money_factor
+
+                    if t > 0:
+                        # installation persistence
+                        prob.add_cst(gen_vars.invested[t - 1, k] <= gen_vars.invested[t, k],
+                                      name=join("persist_", [t, k]))
+
+                    # maximum production constraint
+                    prob.add_cst(gen_vars.p[t, k] <= (gen_data_t.pmax[k] / Sbase) * gen_vars.invested[t, k],
+                                  name=join("max_prod_", [t, k]))
+                else:
+                    # is invested for already
+                    gen_vars.invested[t, k] = 1
+
             else:
 
                 # it is NOT dispatchable
@@ -827,6 +857,7 @@ def add_linear_battery_formulation(t: Union[int, None],
                                    unit_commitment: bool,
                                    ramp_constraints: bool,
                                    skip_generation_limits: bool,
+                                   generation_expansion_planning: bool,
                                    energy_0: Vec):
     """
     Add MIP generation formulation
@@ -839,6 +870,7 @@ def add_linear_battery_formulation(t: Union[int, None],
     :param unit_commitment: formulate unit commitment?
     :param ramp_constraints: formulate ramp constraints?
     :param skip_generation_limits: skip the generation limits?
+    :param generation_expansion_planning: generation expansion planning?
     :param energy_0: initial value of the energy stored
     :return objective function
     """
@@ -916,7 +948,7 @@ def add_linear_battery_formulation(t: Union[int, None],
                 if len(time_array) > 1:
                     dt = (time_array[t] - time_array[t - 1]).seconds / 3600.0
                 else:
-                    dt =  1.0
+                    dt = 1.0
 
                 if ramp_constraints and t is not None:
                     if t > 0:
@@ -1540,8 +1572,9 @@ def run_linear_opf_ts(grid: MultiCircuit,
                       skip_generation_limits: bool = False,
                       consider_contingencies: bool = False,
                       contingency_groups_used: Union[List[ContingencyGroup], None] = None,
-                      unit_Commitment: bool = False,
+                      unit_commitment: bool = False,
                       ramp_constraints: bool = False,
+                      generation_expansion_planning: bool = False,
                       all_generators_fixed: bool = False,
                       lodf_threshold: float = 0.001,
                       maximize_inter_area_flow: bool = False,
@@ -1566,10 +1599,11 @@ def run_linear_opf_ts(grid: MultiCircuit,
     :param skip_generation_limits: Skip the generation limits?
     :param consider_contingencies: Consider the contingencies?
     :param contingency_groups_used: List of contingency groups to use
-    :param unit_Commitment: Formulate unit commitment?
+    :param unit_commitment: Formulate unit commitment?
     :param ramp_constraints: Formulate ramp constraints?
+    :param generation_expansion_planning: Generation expansion planning?
     :param all_generators_fixed: All generators take their snapshot or profile values
-                                 instead of resorting to dispatcheable status
+                                 instead of resorting to dispatchable status
     :param lodf_threshold: LODF threshold value to consider contingencies
     :param maximize_inter_area_flow: Maximize the inter-area flow?
     :param inter_aggregation_info: Inter rea (or country, etc) information
@@ -1658,6 +1692,7 @@ def run_linear_opf_ts(grid: MultiCircuit,
             t_idx=global_t_idx,  # yes, this is not a bug
             bus_dict=bus_dict,
             areas_dict=areas_dict,
+            fill_gep=generation_expansion_planning,
             logger=logger
         )
 
@@ -1688,12 +1723,13 @@ def run_linear_opf_ts(grid: MultiCircuit,
             gen_data_t=nc.generator_data,
             gen_vars=mip_vars.gen_vars,
             prob=lp_model,
-            unit_commitment=unit_Commitment,
+            unit_commitment=unit_commitment,
             ramp_constraints=ramp_constraints,
             skip_generation_limits=skip_generation_limits,
             all_generators_fixed=all_generators_fixed,
             vd=indices.vd,
-            nodal_capacity_active=active_nodal_capacity
+            nodal_capacity_active=active_nodal_capacity,
+            generation_expansion_planning=generation_expansion_planning,
         )
 
         # formulate batteries --------------------------------------------------------------------------------------
@@ -1708,9 +1744,10 @@ def run_linear_opf_ts(grid: MultiCircuit,
             batt_data_t=nc.battery_data,
             batt_vars=mip_vars.batt_vars,
             prob=lp_model,
-            unit_commitment=unit_Commitment,
+            unit_commitment=unit_commitment,
             ramp_constraints=ramp_constraints,
             skip_generation_limits=skip_generation_limits,
+            generation_expansion_planning=generation_expansion_planning,
             energy_0=energy_0
         )
 

{gridcalengine-5.3.25 → gridcalengine-5.3.26}/GridCalEngine/Simulations/OPF/opf_driver.py

@@ -135,7 +135,7 @@ class OptimalPowerFlowDriver(TimeSeriesDriverTemplate):
                                          skip_generation_limits=self.options.skip_generation_limits,
                                          consider_contingencies=self.options.consider_contingencies,
                                          contingency_groups_used=self.options.contingency_groups_used,
-                                         unit_Commitment=self.options.unit_commitment,
+                                         unit_commitment=self.options.unit_commitment,
                                          ramp_constraints=False,
                                          all_generators_fixed=False,
                                          lodf_threshold=self.options.lodf_tolerance,

{gridcalengine-5.3.25 → gridcalengine-5.3.26}/GridCalEngine/Simulations/OPF/opf_options.py

@@ -32,6 +32,7 @@ class OptimalPowerFlowOptions(OptionsTemplate):
                  maximize_flows=False,
                  inter_aggregation_info: InterAggregationInfo | None = None,
                  unit_commitment=False,
+                 generation_expansion_planning: bool = False,
                  export_model_fname: Union[None, str] = None,
                  generate_report=False,
                  ips_method: SolverType = SolverType.NR,
@@ -95,6 +96,8 @@ class OptimalPowerFlowOptions(OptionsTemplate):
 
         self.unit_commitment = unit_commitment
 
+        self.generation_expansion_planning = generation_expansion_planning
+
         self.max_va = 6.28
 
         self.max_vm = 1.0

{gridcalengine-5.3.25 → gridcalengine-5.3.26}/GridCalEngine/Simulations/OPF/opf_ts_driver.py

@@ -117,8 +117,9 @@ class OptimalPowerFlowTimeSeriesDriver(TimeSeriesDriverTemplate):
                                          skip_generation_limits=self.options.skip_generation_limits,
                                          consider_contingencies=self.options.consider_contingencies,
                                          contingency_groups_used=self.options.contingency_groups_used,
-                                         unit_Commitment=self.options.unit_commitment,
+                                         unit_commitment=self.options.unit_commitment,
                                          ramp_constraints=self.options.unit_commitment,
+                                         generation_expansion_planning=self.options.generation_expansion_planning,
                                          all_generators_fixed=False,
                                          lodf_threshold=self.options.lodf_tolerance,
                                          maximize_inter_area_flow=self.options.maximize_flows,
@@ -146,6 +147,7 @@ class OptimalPowerFlowTimeSeriesDriver(TimeSeriesDriverTemplate):
             self.results.generator_producing = opf_vars.gen_vars.producing
             self.results.generator_starting_up = opf_vars.gen_vars.starting_up
             self.results.generator_shutting_down = opf_vars.gen_vars.shedding
+            self.results.generator_invested = opf_vars.gen_vars.invested
 
             self.results.Sf = opf_vars.branch_vars.flows
             self.results.St = -opf_vars.branch_vars.flows
@@ -286,8 +288,9 @@ class OptimalPowerFlowTimeSeriesDriver(TimeSeriesDriverTemplate):
                                          skip_generation_limits=self.options.skip_generation_limits,
                                          consider_contingencies=self.options.consider_contingencies,
                                          contingency_groups_used=self.options.contingency_groups_used,
-                                         unit_Commitment=self.options.unit_commitment,
+                                         unit_commitment=self.options.unit_commitment,
                                          ramp_constraints=self.options.unit_commitment,
+                                         generation_expansion_planning=self.options.generation_expansion_planning,
                                          all_generators_fixed=False,
                                          lodf_threshold=self.options.lodf_tolerance,
                                          maximize_inter_area_flow=self.options.maximize_flows,
@@ -314,6 +317,7 @@ class OptimalPowerFlowTimeSeriesDriver(TimeSeriesDriverTemplate):
             self.results.generator_producing[time_indices, :] = opf_vars.gen_vars.producing
             self.results.generator_starting_up[time_indices, :] = opf_vars.gen_vars.starting_up
             self.results.generator_shutting_down[time_indices, :] = opf_vars.gen_vars.shedding
+            self.results.generator_invested[time_indices, :] = opf_vars.gen_vars.invested
 
             self.results.Sf[time_indices, :] = opf_vars.branch_vars.flows
             self.results.St[time_indices, :] = -opf_vars.branch_vars.flows

{gridcalengine-5.3.25 → gridcalengine-5.3.26}/GridCalEngine/Simulations/OPF/opf_ts_results.py

@@ -91,13 +91,15 @@ class OptimalPowerFlowTimeSeriesResults(ResultsTemplate):
                                                                                    ResultTypes.GeneratorCost,
                                                                                    ResultTypes.GeneratorProducing,
                                                                                    ResultTypes.GeneratorStartingUp,
-                                                                                   ResultTypes.GeneratorShuttingDown
+                                                                                   ResultTypes.GeneratorShuttingDown,
+                                                                                   ResultTypes.GeneratorInvested,
                                                                                    ],
 
                                                     ResultTypes.ShuntResults: [ResultTypes.ShuntReactivePower],
 
                                                     ResultTypes.BatteryResults: [ResultTypes.BatteryPower,
-                                                                                 ResultTypes.BatteryEnergy],
+                                                                                 ResultTypes.BatteryEnergy,
+                                                                                 ResultTypes.BatteryInvested,],
 
                                                     ResultTypes.LoadResults: [ResultTypes.LoadShedding],
 
@@ -175,11 +177,13 @@ class OptimalPowerFlowTimeSeriesResults(ResultsTemplate):
         self.generator_producing = np.zeros((nt, ngen), dtype=bool)
         self.generator_starting_up = np.zeros((nt, ngen), dtype=bool)
         self.generator_shutting_down = np.zeros((nt, ngen), dtype=bool)
+        self.generator_invested = np.zeros((nt, ngen), dtype=bool)
 
         self.shunt_like_reactive_power = np.zeros((nt, nsh), dtype=float)
 
         self.battery_power = np.zeros((nt, nbat), dtype=float)
         self.battery_energy = np.zeros((nt, nbat), dtype=float)
+        self.battery_invested = np.zeros((nt, nbat), dtype=bool)
 
         self.fluid_node_current_level = np.zeros((nt, n_fluid_node), dtype=float)
         self.fluid_node_flow_in = np.zeros((nt, n_fluid_node), dtype=float)
@@ -244,6 +248,7 @@ class OptimalPowerFlowTimeSeriesResults(ResultsTemplate):
         self.register(name='generator_producing', tpe=Mat)
         self.register(name='generator_starting_up', tpe=Mat)
         self.register(name='generator_shutting_down', tpe=Mat)
+        self.register(name='generator_invested', tpe=Mat)
 
         self.register(name='shunt_like_reactive_power', tpe=Mat)
 
@@ -261,7 +266,7 @@ class OptimalPowerFlowTimeSeriesResults(ResultsTemplate):
 
         :param nc:
         """
-        rates = nc.Rates.T
+        rates = nc.passive_branch_data.rates.T
         self.loading = self.Sf / (rates + 1e-9)
 
     def set_at(self, t, res: OptimalPowerFlowResults):
@@ -632,6 +637,18 @@ class OptimalPowerFlowTimeSeriesResults(ResultsTemplate):
                                 xlabel='',
                                 units='')
 
+        elif result_type == ResultTypes.GeneratorInvested:
+
+            return ResultsTable(data=self.generator_invested,
+                                index=pd.to_datetime(self.time_array),
+                                idx_device_type=DeviceType.TimeDevice,
+                                columns=self.generator_names,
+                                cols_device_type=DeviceType.GeneratorDevice,
+                                title=str(result_type.value),
+                                ylabel='',
+                                xlabel='',
+                                units='')
+
         elif result_type == ResultTypes.ShuntReactivePower:
 
             return ResultsTable(data=self.shunt_like_reactive_power,
@@ -668,6 +685,18 @@ class OptimalPowerFlowTimeSeriesResults(ResultsTemplate):
                                 xlabel='',
                                 units='(MWh)')
 
+        elif result_type == ResultTypes.BatteryInvested:
+
+            return ResultsTable(data=self.battery_invested,
+                                index=pd.to_datetime(self.time_array),
+                                idx_device_type=DeviceType.TimeDevice,
+                                columns=self.battery_names,
+                                cols_device_type=DeviceType.BatteryDevice,
+                                title=str(result_type.value),
+                                ylabel='(MWh)',
+                                xlabel='',
+                                units='(MWh)')
+
         elif result_type == ResultTypes.SystemFuel:
 
             return ResultsTable(data=self.system_fuel,

{gridcalengine-5.3.25 → gridcalengine-5.3.26}/GridCalEngine/Simulations/PowerFlow/Formulations/pf_advanced_formulation.py

@@ -347,7 +347,7 @@ class PfAdvancedFormulation(PfFormulationTemplate):
 
     def x2var(self, x: Vec) -> None:
         """
-        Convert X to decission variables
+        Convert X to decision variables
         :param x: solution vector
         """
         a = len(self.idx_dVa)
@@ -363,7 +363,7 @@ class PfAdvancedFormulation(PfFormulationTemplate):
 
     def var2x(self) -> Vec:
         """
-        Convert the internal decission variables into the vector
+        Convert the internal decision variables into the vector
         :return: Vector
         """
         return np.r_[
@@ -456,7 +456,7 @@ class PfAdvancedFormulation(PfFormulationTemplate):
             Qt - self.nc.active_branch_data.Qset[self.idx_dQt]
         ]
 
-        # compute the rror
+        # compute the error
         return compute_fx_error(_f), x
 
     def update(self, x: Vec, update_controls: bool = False) -> Tuple[float, bool, Vec, Vec]:
@@ -630,7 +630,7 @@ class PfAdvancedFormulation(PfFormulationTemplate):
                 # recompute the error based on the new Scalc and S0
                 self._f = self.fx()
 
-                # compute the rror
+                # compute the error
                 self._error = compute_fx_error(self._f)
 
         # converged?