VeraGridEngine 5.4.10__tar.gz → 5.4.11__tar.gz

{veragridengine-5.4.10 → veragridengine-5.4.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.4.10
+Version: 5.4.11
 Summary: VeraGrid is a Power Systems simulation program intended for professional use and research
 Home-page: https://github.com/SanPen/VeraGrid
 Author: Santiago Peñate Vera et. Al.

{veragridengine-5.4.10 → veragridengine-5.4.11}/VeraGridEngine/DataStructures/branch_parent_data.py

@@ -297,7 +297,7 @@ class BranchParentData:
     def get_3ph_names(self):
         names3: StrVec = np.empty(self.nelm * 3, dtype=object)
         for i in range(self.nelm):
-            names3[3 * i + 0] = self.names[i] + "_A"
-            names3[3 * i + 1] = self.names[i] + "_B"
-            names3[3 * i + 2] = self.names[i] + "_C"
+            names3[3 * i + 0] = str(self.names[i]) + "_A"
+            names3[3 * i + 1] = str(self.names[i]) + "_B"
+            names3[3 * i + 2] = str(self.names[i]) + "_C"
         return names3

{veragridengine-5.4.10 → veragridengine-5.4.11}/VeraGridEngine/Devices/multi_circuit.py

@@ -20,7 +20,7 @@ from VeraGridEngine.Devices.Parents.editable_device import EditableDevice
 from VeraGridEngine.basic_structures import IntVec, Vec, Mat, CxVec, IntMat, CxMat
 
 import VeraGridEngine.Devices as dev
-from VeraGridEngine.Devices.types import ALL_DEV_TYPES, INJECTION_DEVICE_TYPES, FLUID_TYPES, AREA_TYPES
+from VeraGridEngine.Devices.types import ALL_DEV_TYPES, INJECTION_DEVICE_TYPES, FLUID_TYPES, AREA_TYPES, BRANCH_TYPES
 from VeraGridEngine.basic_structures import Logger
 from VeraGridEngine.Topology.topology import find_different_states
 from VeraGridEngine.enumerations import DeviceType, ActionType, SubObjectType, ConverterControlType
@@ -853,6 +853,20 @@ class MultiCircuit(Assets):
         """
         return self.snapshot_time.strftime("%Y-%m-%d %H:%M:%S")
 
+    def get_bus_branch_dict(self) -> Dict[dev.Bus, List[BRANCH_TYPES]]:
+        """
+        Get the branch-bus dictionary
+        :return: dict[bus] -> list of branches
+        """
+        d: Dict[dev.Bus, List[dev.BranchType]] = {b: list() for b in self._buses}
+
+        for branch_list in self.get_branch_lists(add_vsc=True, add_hvdc=True, add_switch=True):
+            for br in branch_list:
+                d[br.bus_from].append(br)
+                d[br.bus_to].append(br)
+
+        return d
+
     def get_bus_branch_connectivity_matrix(self) -> Tuple[csc_matrix, csc_matrix, csc_matrix]:
         """
         Get the branch-bus connectivity

{veragridengine-5.4.10 → veragridengine-5.4.11}/VeraGridEngine/IO/veragrid/excel_interface.py

@@ -2,14 +2,16 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.  
 # SPDX-License-Identifier: MPL-2.0
+from __future__ import annotations
 
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Sequence
 from warnings import warn
 import numpy as np
 import pandas as pd
 from VeraGridEngine.basic_structures import Logger
 from VeraGridEngine.Devices.multi_circuit import MultiCircuit
 import VeraGridEngine.Devices as dev
+from VeraGridEngine.Devices.types import ALL_DEV_TYPES
 from VeraGridEngine.enumerations import DeviceType
 from VeraGridEngine.IO.veragrid.pack_unpack import gather_model_as_data_frames, get_objects_dictionary
 
@@ -676,7 +678,9 @@ def interpret_excel_v3(circuit: MultiCircuit,
     circuit.comments = data['Comments'] if 'Comments' in data.keys() else ''
 
     # common function
-    def set_object_attributes(obj_, attr_list, values):
+    def set_object_attributes(obj_: ALL_DEV_TYPES,
+                              attr_list: List[str],
+                              values: Sequence[float | int | str]):
         """
 
         :param obj_:
@@ -1145,7 +1149,7 @@ def save_excel(circuit: MultiCircuit, file_path):
         for key in dfs.keys():
             key2 = str(key)
             if len(key2) > 30:
-                key2 = key2[:30] # excel sheet names have a max of 30 chars
+                key2 = key2[:30]  # excel sheet names have a max of 30 chars
             dfs[key].to_excel(excel_writer=writer, sheet_name=key2)
 
     return logger

{veragridengine-5.4.10 → veragridengine-5.4.11}/VeraGridEngine/Simulations/OPF/Formulations/ac_opf_problem.py

@@ -1716,8 +1716,8 @@ class NonLinearOptimalPfProblem:
         # pd.DataFrame(Pg_dis).transpose().to_csv('REEresP.csv')
         # pd.DataFrame(Qg_dis).transpose().to_csv('REEresQ.csv')
 
-        Pg = np.zeros(self.n_gen_disp_sh)
-        Qg = np.zeros(self.n_gen_disp_sh)
+        Pg = np.zeros(self.ngen + self.nsh)
+        Qg = np.zeros(self.ngen + self.nsh)
 
         Pg[self.gen_disp_idx_sh] = self.Pg
         Qg[self.gen_disp_idx_sh] = self.Qg

{veragridengine-5.4.10 → veragridengine-5.4.11}/VeraGridEngine/Simulations/OPF/Formulations/linear_opf_ts.py

@@ -35,7 +35,8 @@ from VeraGridEngine.DataStructures.fluid_pump_data import FluidPumpData
 from VeraGridEngine.DataStructures.fluid_p2x_data import FluidP2XData
 from VeraGridEngine.basic_structures import Logger, Vec, IntVec, DateVec, Mat
 from VeraGridEngine.Utils.MIP.selected_interface import LpExp, LpVar, LpModel, lpDot, join
-from VeraGridEngine.enumerations import HvdcControlType, ZonalGrouping, MIPSolvers, TapPhaseControl, ConverterControlType
+from VeraGridEngine.enumerations import HvdcControlType, ZonalGrouping, MIPSolvers, TapPhaseControl, \
+    ConverterControlType
 from VeraGridEngine.Simulations.LinearFactors.linear_analysis import (LinearAnalysis, LinearMultiContingency,
                                                                       LinearMultiContingencies)
 
@@ -308,6 +309,8 @@ class BranchVars:
         :param n_elm: Number of branches
         """
         self.flows = np.zeros((nt, n_elm), dtype=object)
+        self.z_flows = np.zeros((nt, n_elm), dtype=object)  # absolute used with add_losses_approximation
+        self.losses = np.zeros((nt, n_elm), dtype=object)  # absolute used with add_losses_approximation
         self.flow_slacks_pos = np.zeros((nt, n_elm), dtype=object)
         self.flow_slacks_neg = np.zeros((nt, n_elm), dtype=object)
         self.tap_angles = np.zeros((nt, n_elm), dtype=object)
@@ -339,6 +342,7 @@ class BranchVars:
                 data.flow_constraints_ub[t, i] = model.get_value(self.flow_constraints_ub[t, i])
                 data.flow_constraints_lb[t, i] = model.get_value(self.flow_constraints_lb[t, i])
                 data.overload_cost[t, i] = model.get_value(self.overload_cost[t, i]) * Sbase
+                data.losses[t, i] = model.get_value(self.losses[t, i]) * Sbase
 
         for i in range(len(self.contingency_flow_data)):
             t, m, c, var, neg_slack, pos_slack = self.contingency_flow_data[i]
@@ -853,8 +857,8 @@ def add_linear_generation_formulation(t: Union[int, None],
 
                     if not skip_generation_limits:
                         prob.set_var_bounds(var=gen_vars.p[t, k],
-                                       lb=gen_data_t.pmin[k] / Sbase,
-                                       ub=gen_data_t.pmax[k] / Sbase)
+                                            lb=gen_data_t.pmin[k] / Sbase,
+                                            ub=gen_data_t.pmax[k] / Sbase)
 
                 # add the ramp constraints
                 if ramp_constraints and t is not None:
@@ -1240,7 +1244,8 @@ def add_linear_branches_formulation(t: int,
                                     branch_vars: BranchVars,
                                     bus_vars: BusVars,
                                     prob: LpModel,
-                                    inf=1e20):
+                                    inf=1e20,
+                                    add_losses_approximation: bool = False):
     """
     Formulate the branches
     :param t: time index
@@ -1252,6 +1257,7 @@ def add_linear_branches_formulation(t: int,
     :param bus_vars: BusVars
     :param prob: OR problem
     :param inf: number considered infinite
+    :param add_losses_approximation: If true the distribution factors losses approximation is used
     :return objective function
     """
     f_obj = 0.0
@@ -1318,6 +1324,39 @@ def add_linear_branches_formulation(t: int,
             bus_vars.Pbalance[t, fr] -= branch_vars.flows[t, m]
             bus_vars.Pbalance[t, to] += branch_vars.flows[t, m]
 
+            if add_losses_approximation:
+                # declare the abs flow LPVar
+                branch_vars.z_flows[t, m] = prob.add_var(lb=0,
+                                                         ub=inf,
+                                                         name=join("z_flow_", [t, m], "_"))
+
+                # zij ≥ Fij
+                prob.add_cst(cst=branch_vars.flows[t, m] <= branch_vars.z_flows[t, m],
+                             name=join("z_flow_u_lim_", [t, m]))
+
+                # zij ≥ -Fij
+                prob.add_cst(cst=-branch_vars.flows[t, m] <= branch_vars.z_flows[t, m],
+                             name=join("z_flow_l_lim_", [t, m]))
+
+                # add to the objective (αij =rij * ∣Fij0∣/V2)
+                # insetad of the rates, the literature suggests an absolute initial value of the flow
+                V = bus_data_t.Vnom[branch_data_t.F[m]]
+                if V > 0.0:
+                    factor = branch_data_t.R[m] * branch_data_t.rates[m] / (V ** 2)
+                else:
+                    factor = branch_data_t.R[m]
+
+                # store the values for later retrieval
+                branch_vars.losses[t, m] = branch_vars.z_flows[t, m] * factor
+
+                # add the losses to the objective
+                f_obj += branch_vars.losses[t, m]
+
+                # divide the losses contribution equally among the from and to buses as new loads
+                l_inj = 0.5 * branch_vars.losses[t, m]
+                bus_vars.Pbalance[t, fr] -= l_inj
+                bus_vars.Pbalance[t, to] -= l_inj
+
             # add the flow constraint if monitored
             if branch_data_t.monitor_loading[m]:
                 branch_vars.flow_slacks_pos[t, m] = prob.add_var(0, inf,
@@ -1793,6 +1832,7 @@ def run_linear_opf_ts(grid: MultiCircuit,
                       nodal_capacity_sign: float = 1.0,
                       capacity_nodes_idx: Union[IntVec, None] = None,
                       use_glsk_as_cost: bool = False,
+                      add_losses_approximation: bool = False,
                       logger: Logger = Logger(),
                       progress_text: Union[None, Callable[[str], None]] = None,
                       progress_func: Union[None, Callable[[float], None]] = None,
@@ -1821,6 +1861,8 @@ def run_linear_opf_ts(grid: MultiCircuit,
     :param optimize_nodal_capacity: Optimize the nodal capacity? (optional)
     :param nodal_capacity_sign: if > 0 the generation is maximized, if < 0 the load is maximized
     :param capacity_nodes_idx: Array of bus indices to optimize their nodal capacity for
+    :param use_glsk_as_cost: If true the generators use the GLSK as dispatch values
+    :param add_losses_approximation: If true the distribution factors losses approximation is used
     :param logger: logger instance
     :param progress_text: Text progress callback
     :param progress_func: Numerical progress callback
@@ -2034,7 +2076,8 @@ def run_linear_opf_ts(grid: MultiCircuit,
                 branch_vars=mip_vars.branch_vars,
                 bus_vars=mip_vars.bus_vars,
                 prob=lp_model,
-                inf=1e20
+                inf=1e20,
+                add_losses_approximation=add_losses_approximation
             )
 
             # formulate nodes ------------------------------------------------------------------------------------------

{veragridengine-5.4.10 → veragridengine-5.4.11}/VeraGridEngine/Simulations/OPF/opf_driver.py

@@ -129,26 +129,29 @@ class OptimalPowerFlowDriver(TimeSeriesDriverTemplate):
                 self.report_text('Formulating problem...')
 
             # DC optimal power flow
-            opf_vars = run_linear_opf_ts(grid=self.grid,
-                                         time_indices=None,
-                                         solver_type=self.options.mip_solver,
-                                         zonal_grouping=self.options.zonal_grouping,
-                                         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,
-                                         ramp_constraints=False,
-                                         all_generators_fixed=False,
-                                         lodf_threshold=self.options.lodf_tolerance,
-                                         maximize_inter_area_flow=self.options.maximize_flows,
-                                         inter_aggregation_info=self.options.inter_aggregation_info,
-                                         energy_0=None,
-                                         fluid_level_0=None,
-                                         use_glsk_as_cost=self.options.use_glsk_as_cost,
-                                         logger=self.logger,
-                                         export_model_fname=self.options.export_model_fname,
-                                         verbose=self.options.verbose,
-                                         robust=self.options.robust)
+            opf_vars = run_linear_opf_ts(
+                grid=self.grid,
+                time_indices=None,
+                solver_type=self.options.mip_solver,
+                zonal_grouping=self.options.zonal_grouping,
+                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,
+                ramp_constraints=False,
+                all_generators_fixed=False,
+                lodf_threshold=self.options.lodf_tolerance,
+                maximize_inter_area_flow=self.options.maximize_flows,
+                inter_aggregation_info=self.options.inter_aggregation_info,
+                energy_0=None,
+                fluid_level_0=None,
+                use_glsk_as_cost=self.options.use_glsk_as_cost,
+                add_losses_approximation=self.options.add_losses_approximation,
+                logger=self.logger,
+                export_model_fname=self.options.export_model_fname,
+                verbose=self.options.verbose,
+                robust=self.options.robust
+            )
 
             self.results.voltage = opf_vars.bus_vars.Vm[0, :] * np.exp(1j * opf_vars.bus_vars.Va[0, :])
             self.results.bus_shadow_prices = opf_vars.bus_vars.shadow_prices[0, :]
@@ -167,6 +170,8 @@ class OptimalPowerFlowDriver(TimeSeriesDriverTemplate):
                                       - opf_vars.branch_vars.flow_slacks_neg[0, :])
             self.results.loading = opf_vars.branch_vars.loading[0, :]
             self.results.phase_shift = opf_vars.branch_vars.tap_angles[0, :]
+            self.results.losses = opf_vars.branch_vars.losses[0, :]
+
             # self.results.Sbus = problem.get_power_injections()[0, :]
             self.results.hvdc_Pf = opf_vars.hvdc_vars.flows[0, :]
             self.results.hvdc_loading = opf_vars.hvdc_vars.loading[0, :]

{veragridengine-5.4.10 → veragridengine-5.4.11}/VeraGridEngine/Simulations/OPF/opf_options.py

@@ -34,6 +34,7 @@ class OptimalPowerFlowOptions(OptionsTemplate):
                  inter_aggregation_info: InterAggregationInfo | None = None,
                  unit_commitment=False,
                  use_glsk_as_cost: bool = False,
+                 add_losses_approximation: bool = False,
                  generation_expansion_planning: bool = False,
                  export_model_fname: Union[None, str] = None,
                  generate_report=False,
@@ -105,6 +106,8 @@ class OptimalPowerFlowOptions(OptionsTemplate):
 
         self.use_glsk_as_cost = use_glsk_as_cost
 
+        self.add_losses_approximation = add_losses_approximation
+
         self.generation_expansion_planning = generation_expansion_planning
 
         self.max_va = 6.28
@@ -141,6 +144,8 @@ class OptimalPowerFlowOptions(OptionsTemplate):
         self.register(key="contingency_groups_used", tpe=SubObjectType.Array)
         self.register(key="lodf_tolerance", tpe=float)
         self.register(key="maximize_flows", tpe=bool)
+        self.register(key="add_losses_approximation", tpe=bool)
+        self.register(key="use_glsk_as_cost", tpe=bool)
         self.register(key="inter_aggregation_info", tpe=DeviceType.InterAggregationInfo)
         self.register(key="unit_commitment", tpe=bool)
         self.register(key="export_model_fname", tpe=str)

{veragridengine-5.4.10 → veragridengine-5.4.11}/VeraGridEngine/Simulations/OPF/opf_ts_driver.py

@@ -105,27 +105,30 @@ class OptimalPowerFlowTimeSeriesDriver(TimeSeriesDriverTemplate):
         if self.options.solver == SolverType.LINEAR_OPF:
 
             # DC optimal power flow
-            opf_vars = run_linear_opf_ts(grid=self.grid,
-                                         time_indices=self.time_indices,
-                                         solver_type=self.options.mip_solver,
-                                         zonal_grouping=self.options.zonal_grouping,
-                                         skip_generation_limits=self.options.skip_generation_limits,
-                                         consider_contingencies=self.options.consider_contingencies,
-                                         contingency_groups_used=self.grid.contingency_groups,
-                                         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,
-                                         inter_aggregation_info=self.options.inter_aggregation_info,
-                                         use_glsk_as_cost=self.options.use_glsk_as_cost,
-                                         logger=self.logger,
-                                         progress_text=self.report_text,
-                                         progress_func=self.report_progress,
-                                         export_model_fname=self.options.export_model_fname,
-                                         verbose=self.options.verbose,
-                                         robust=self.options.robust)
+            opf_vars = run_linear_opf_ts(
+                grid=self.grid,
+                time_indices=self.time_indices,
+                solver_type=self.options.mip_solver,
+                zonal_grouping=self.options.zonal_grouping,
+                skip_generation_limits=self.options.skip_generation_limits,
+                consider_contingencies=self.options.consider_contingencies,
+                contingency_groups_used=self.grid.contingency_groups,
+                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,
+                inter_aggregation_info=self.options.inter_aggregation_info,
+                use_glsk_as_cost=self.options.use_glsk_as_cost,
+                add_losses_approximation=self.options.add_losses_approximation,
+                logger=self.logger,
+                progress_text=self.report_text,
+                progress_func=self.report_progress,
+                export_model_fname=self.options.export_model_fname,
+                verbose=self.options.verbose,
+                robust=self.options.robust
+            )
 
             self.results.voltage = opf_vars.bus_vars.Vm * np.exp(1j * opf_vars.bus_vars.Va)
             self.results.bus_shadow_prices = opf_vars.bus_vars.shadow_prices
@@ -151,6 +154,7 @@ class OptimalPowerFlowTimeSeriesDriver(TimeSeriesDriverTemplate):
             self.results.St = -opf_vars.branch_vars.flows
             self.results.overloads = opf_vars.branch_vars.flow_slacks_pos - opf_vars.branch_vars.flow_slacks_neg
             self.results.overloads_cost = opf_vars.branch_vars.overload_cost
+            self.results.losses = opf_vars.branch_vars.losses
 
             self.results.loading = opf_vars.branch_vars.loading
             self.results.phase_shift = opf_vars.branch_vars.tap_angles
@@ -300,27 +304,30 @@ class OptimalPowerFlowTimeSeriesDriver(TimeSeriesDriverTemplate):
 
                 # run an opf for the group interval only if the group is within the start:end boundaries
                 # DC optimal power flow
-                opf_vars = run_linear_opf_ts(grid=self.grid,
-                                             time_indices=time_indices,
-                                             solver_type=self.options.mip_solver,
-                                             zonal_grouping=self.options.zonal_grouping,
-                                             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,
-                                             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,
-                                             inter_aggregation_info=self.options.inter_aggregation_info,
-                                             energy_0=energy_0,
-                                             fluid_level_0=fluid_level_0,
-                                             use_glsk_as_cost=self.options.use_glsk_as_cost,
-                                             logger=self.logger,
-                                             export_model_fname=self.options.export_model_fname,
-                                             verbose=self.options.verbose,
-                                             robust=self.options.robust)
+                opf_vars = run_linear_opf_ts(
+                    grid=self.grid,
+                    time_indices=time_indices,
+                    solver_type=self.options.mip_solver,
+                    zonal_grouping=self.options.zonal_grouping,
+                    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,
+                    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,
+                    inter_aggregation_info=self.options.inter_aggregation_info,
+                    energy_0=energy_0,
+                    fluid_level_0=fluid_level_0,
+                    use_glsk_as_cost=self.options.use_glsk_as_cost,
+                    add_losses_approximation=self.options.add_losses_approximation,
+                    logger=self.logger,
+                    export_model_fname=self.options.export_model_fname,
+                    verbose=self.options.verbose,
+                    robust=self.options.robust
+                )
 
                 self.results.voltage[time_indices, :] = opf_vars.bus_vars.Vm * np.exp(1j * opf_vars.bus_vars.Va)
                 self.results.bus_shadow_prices[time_indices, :] = opf_vars.bus_vars.shadow_prices
@@ -345,6 +352,7 @@ class OptimalPowerFlowTimeSeriesDriver(TimeSeriesDriverTemplate):
                 self.results.overloads[time_indices, :] = (opf_vars.branch_vars.flow_slacks_pos
                                                            - opf_vars.branch_vars.flow_slacks_neg)
                 self.results.overloads_cost[time_indices, :] = opf_vars.branch_vars.overload_cost
+                self.results.losses[time_indices, :] = opf_vars.branch_vars.losses
 
                 self.results.loading[time_indices, :] = opf_vars.branch_vars.loading
                 self.results.phase_shift[time_indices, :] = opf_vars.branch_vars.tap_angles

{veragridengine-5.4.10 → veragridengine-5.4.11}/VeraGridEngine/Simulations/OPF/opf_ts_results.py

@@ -839,31 +839,5 @@ class OptimalPowerFlowTimeSeriesResults(ResultsTemplate):
                                 ylabel='(MW)',
                                 units='(MW)')
 
-        # elif result_type == ResultTypes.OpfTechnologyPlot:
-        #     # the generation already accounts for the shedding
-        #     generation = self.generator_power.sum(axis=1) + self.battery_power.sum(axis=1)
-        #     load = self.load_power.sum(axis=1) - self.load_shedding.sum(axis=1)
-        #
-        #     if self.plotting_allowed():
-        #         plt.ion()
-        #         fig = plt.figure(figsize=(8, 6))
-        #         ax3 = plt.subplot(1, 1, 1)
-        #
-        #         # for i in range(self.power_by_technology.shape[1]):
-        #         ax3.stackplot(x=self.time_array, y=self.power_by_technology, labels=self.technology_names)
-        #
-        #         ax3.legend()
-        #         fig.suptitle(str(result_type.value))
-        #         plt.tight_layout()
-        #         plt.show()
-        #
-        #     return ResultsTable(data=np.c_[generation, load],
-        #                         index=pd.to_datetime(self.time_array),
-        #                         idx_device_type=DeviceType.TimeDevice,
-        #                         columns=np.array(['Generation (MW)', 'Load (MW)']),
-        #                         cols_device_type=DeviceType.NoDevice,
-        #                         title=result_type.value,
-        #                         ylabel='(MW)',
-        #                         units='(MW)')
         else:
             raise Exception('Result type not understood:' + str(result_type))

{veragridengine-5.4.10 → veragridengine-5.4.11}/VeraGridEngine/Simulations/results_table.py

@@ -121,7 +121,7 @@ class ResultsTable:
         """
         Transpose the results in-place
         """
-        self.data_c = self.data_c.transpose()
+        self.data_c = self.data_c.copy().transpose()
         self.r, self.c = self.data_c.shape
         self.x_label, self.y_label = self.y_label, self.x_label
         self.cols_c, self.index_c = self.index_c, self.cols_c
@@ -302,7 +302,7 @@ class ResultsTable:
             self.index_c = np.arange(n, dtype=float)
 
         for i in range(self.data_c.shape[1]):
-            self.data_c[:, i] = np.sort(self.data_c[:, i], axis=0)
+            self.data_c[:, i] = np.sort(self.data_c[:, i].copy(), axis=0)
 
         self.x_label = 'Probability of value<=x'
 

veragridengine-5.4.11/VeraGridEngine/Topology/Procedural/__init__.py

@@ -0,0 +1,4 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0

veragridengine-5.4.11/VeraGridEngine/Topology/Procedural/procedural_grid_creation.py

@@ -0,0 +1,102 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+from __future__ import annotations
+from typing import Dict, List, TYPE_CHECKING
+
+import numpy as np
+import VeraGridEngine.Devices as dev
+from VeraGridEngine.Devices.types import BRANCH_TYPES
+from VeraGridEngine.enumerations import DeviceType
+from VeraGridEngine.basic_structures import Mat
+
+if TYPE_CHECKING:
+    from VeraGridEngine.Devices.multi_circuit import MultiCircuit
+
+
+class ProceduralGrid:
+    """
+    Class to chracterize and create grids procedurally
+    """
+
+    def __init__(self):
+        # list of states, ony buses and branches for now
+        self.states: List[DeviceType] = [
+            DeviceType.BusDevice,
+            DeviceType.LineDevice,
+            DeviceType.DCLineDevice,
+            DeviceType.Transformer2WDevice,
+            DeviceType.SeriesReactanceDevice,
+            DeviceType.HVDCLineDevice,
+            DeviceType.VscDevice,
+            DeviceType.SwitchDevice,
+            # DeviceType.LoadDevice,
+            # DeviceType.GeneratorDevice,
+            # DeviceType.ShuntDevice,
+        ]
+
+        ns = len(self.states)
+
+        self.state_index: Dict[DeviceType, int] = {s: i for i, s in enumerate(self.states)}
+
+        # Transition probabilities: row-> state I'm at | col -> state I will be
+        self.transition_probabilities: Mat = np.zeros((ns, ns))
+
+    def train(self, grid: MultiCircuit):
+        """
+        Fill the transition probabilities with the grid information
+        :param grid:
+        :return:
+        """
+
+        ns = len(self.states)
+
+        # at the beginning, these will be the simple frequency counts
+        self.transition_probabilities = np.zeros((ns, ns))
+
+        # get dictionary of branches connected to each bus
+        d: Dict[dev.Bus, List[BRANCH_TYPES]] = grid.get_bus_branch_dict()
+
+        pool = [grid.buses[0]]
+        used_buses = set()
+
+        while len(pool) > 0:
+
+            # get the firts out of the cue
+            bus = pool.pop(0)
+
+            # get the device index
+            row = self.state_index[bus.device_type]
+
+            # add the popeddevice to the used buses
+            used_buses.add(bus)
+
+            # get the list of branches of the bus
+            br_list = d.get(bus, list())
+
+            # for every connected brnach...
+            for branch in br_list:
+
+                if branch.bus_from not in used_buses:
+                    pool.append(branch.bus_from)
+
+                if branch.bus_to not in used_buses:
+                    pool.append(branch.bus_to)
+
+                # get the device type column in the states matrix
+                col = self.state_index[branch.device_type]
+
+                # increase the frequency
+                self.transition_probabilities[row, col] += 1
+                self.transition_probabilities[col, row] += 1
+
+        # normalize
+        for i in len(self.states):
+            s = np.sum(self.transition_probabilities[i, :])
+            self.transition_probabilities[i, :] /= s
+
+
+if __name__ == '__main__':
+
+    pass

{veragridengine-5.4.10 → veragridengine-5.4.11}/VeraGridEngine/__version__.py

@@ -6,7 +6,7 @@ import datetime
 _current_year_ = datetime.datetime.now().year
 
 # remember to keep a three-number version!!!
-__VeraGridEngine_VERSION__ = "5.4.10"
+__VeraGridEngine_VERSION__ = "5.4.11"
 
 url = 'https://github.com/SanPen/VeraGrid'