VeraGridEngine 5.4.5__tar.gz → 5.4.6__tar.gz

{veragridengine-5.4.5 → veragridengine-5.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.4.5
+Version: 5.4.6
 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.5 → veragridengine-5.4.6}/VeraGridEngine/Devices/Diagrams/base_diagram.py

@@ -449,10 +449,7 @@ class BaseDiagram:
         # Add the electrical branches ----------------------------------------------------------------------------------
         tuples = list()
         for dev_type in [DeviceType.LineDevice,
-                         DeviceType.DCLineDevice,
-                         DeviceType.HVDCLineDevice,
                          DeviceType.Transformer2WDevice,
-                         DeviceType.VscDevice,
                          DeviceType.UpfcDevice]:
 
             groups = self.data.get(dev_type.value, None)
@@ -471,6 +468,62 @@ class BaseDiagram:
 
                         tuples.append((f, t, w))
 
+        for dev_type in [DeviceType.DCLineDevice]:
+
+            groups = self.data.get(dev_type.value, None)
+
+            if groups:
+                for i, (idtag, location) in enumerate(groups.locations.items()):
+                    branch = location.api_object
+                    f = graph_node_dictionary.get(branch.bus_from.idtag, None)
+                    t = graph_node_dictionary.get(branch.bus_to.idtag, None)
+
+                    if f is not None and t is not None:
+                        w = branch.R
+                        tuples.append((f, t, w))
+
+        for dev_type in [DeviceType.HVDCLineDevice]:
+
+            groups = self.data.get(dev_type.value, None)
+
+            if groups:
+                for i, (idtag, location) in enumerate(groups.locations.items()):
+                    branch = location.api_object
+                    f = graph_node_dictionary.get(branch.bus_from.idtag, None)
+                    t = graph_node_dictionary.get(branch.bus_to.idtag, None)
+
+                    if f is not None and t is not None:
+                        w = max(branch.r, 0.01)
+                        tuples.append((f, t, w))
+
+        for dev_type in [DeviceType.VscDevice]:
+
+            groups = self.data.get(dev_type.value, None)
+
+            if groups:
+                for i, (idtag, location) in enumerate(groups.locations.items()):
+                    branch = location.api_object
+                    f = graph_node_dictionary.get(branch.bus_from.idtag, None)
+                    t = graph_node_dictionary.get(branch.bus_to.idtag, None)
+
+                    if f is not None and t is not None:
+                        w = 0.01
+                        tuples.append((f, t, w))
+
+        for dev_type in [DeviceType.SwitchDevice]:
+
+            groups = self.data.get(dev_type.value, None)
+
+            if groups:
+                for i, (idtag, location) in enumerate(groups.locations.items()):
+                    branch = location.api_object
+                    f = graph_node_dictionary.get(branch.bus_from.idtag, None)
+                    t = graph_node_dictionary.get(branch.bus_to.idtag, None)
+
+                    if f is not None and t is not None:
+                        w = max(branch.R, 0.001)
+                        tuples.append((f, t, w))
+
         # Add fluid branches -------------------------------------------------------------------------------------------
         for dev_type in [DeviceType.FluidPathDevice]:
 

{veragridengine-5.4.5 → veragridengine-5.4.6}/VeraGridEngine/Devices/assets.py

@@ -1707,6 +1707,18 @@ class Assets:
             gen_index_dict[elm.idtag] = k  # associate the idtag to the index
         return gen_index_dict
 
+    def get_generator_bus_index_dict(self, bus_index_dict: Dict[dev.Bus, int] = None):
+        """
+        Get a dictionary of generators related to their bus index
+        :param bus_index_dict: bus object to bus index dictionary (optional)
+        :return: generator object to bus index dictionary
+
+        """
+        if bus_index_dict is None:
+            bus_index_dict = self.get_bus_index_dict()
+
+        return {g.idtag: bus_index_dict[g.bus] for g in self.get_generators() if g.bus is not None}
+
     # ------------------------------------------------------------------------------------------------------------------
     # External grid
     # ------------------------------------------------------------------------------------------------------------------

{veragridengine-5.4.5 → veragridengine-5.4.6}/VeraGridEngine/IO/others/pandapower_parser.py

@@ -203,20 +203,21 @@ class Panda2VeraGrid:
         """
 
         for idx, row in self.panda_net.ext_grid.iterrows():
-            bus = bus_dictionary[row['bus']]
-            elm = dev.ExternalGrid(
-                name=row['name'],
-                code=idx,
-                Vm=row['vm_pu'],
-                mode=ExternalGridMode.VD,
-                idtag=row.get('uuid', None)
-            )
+            if row["in_service"]:
+                bus = bus_dictionary[row['bus']]
+                elm = dev.ExternalGrid(
+                    name=row['name'],
+                    code=idx,
+                    Vm=row['vm_pu'],
+                    mode=ExternalGridMode.VD,
+                    idtag=row.get('uuid', None)
+                )
 
-            elm.rdfid = row.get('uuid', elm.idtag)
+                elm.rdfid = row.get('uuid', elm.idtag)
 
-            grid.add_external_grid(bus, elm)
+                grid.add_external_grid(bus, elm)
 
-            self.register(panda_type="ext_grid", panda_code=idx, api_obj=elm)
+                self.register(panda_type="ext_grid", panda_code=idx, api_obj=elm)
 
     def parse_loads(self, grid: dev.MultiCircuit, bus_dictionary: Dict[str, dev.Bus]):
         """
@@ -226,20 +227,21 @@ class Panda2VeraGrid:
         """
 
         for idx, row in self.panda_net.load.iterrows():
-            bus = bus_dictionary[row['bus']]
-            elm = dev.Load(
-                name=row['name'],
-                code=idx,
-                P=row['p_mw'] * self.load_scale,
-                Q=row['q_mvar'] * self.load_scale,
-                idtag=row.get('uuid', None)
-            )
+            if row["in_service"]:
+                bus = bus_dictionary[row['bus']]
+                elm = dev.Load(
+                    name=row['name'],
+                    code=idx,
+                    P=row['p_mw'] * self.load_scale,
+                    Q=row['q_mvar'] * self.load_scale,
+                    idtag=row.get('uuid', None)
+                )
 
-            elm.rdfid = row.get('uuid', elm.idtag)
+                elm.rdfid = row.get('uuid', elm.idtag)
 
-            grid.add_load(bus=bus, api_obj=elm)
+                grid.add_load(bus=bus, api_obj=elm)
 
-            self.register(panda_type="load", panda_code=idx, api_obj=elm)
+                self.register(panda_type="load", panda_code=idx, api_obj=elm)
 
     def parse_shunts(self, grid: dev.MultiCircuit, bus_dictionary: Dict[str, dev.Bus]):
         """
@@ -402,21 +404,22 @@ class Panda2VeraGrid:
         """
 
         for idx, row in self.panda_net.sgen.iterrows():
-            bus = bus_dictionary[row['bus']]
-            elm = dev.StaticGenerator(
-                name=row['name'],
-                code=idx,
-                P=row['p_mw'] * self.load_scale,
-                Q=row["q_mvar"],
-                active=row['in_service'],
-                idtag=row.get('uuid', None)
-            )
+            if row["in_service"]:
+                bus = bus_dictionary[row['bus']]
+                elm = dev.StaticGenerator(
+                    name=row['name'],
+                    code=idx,
+                    P=row['p_mw'] * self.load_scale,
+                    Q=row["q_mvar"],
+                    active=row['in_service'],
+                    idtag=row.get('uuid', None)
+                )
 
-            elm.rdfid = row.get('uuid', elm.idtag)
+                elm.rdfid = row.get('uuid', elm.idtag)
 
-            grid.add_static_generator(bus=bus, api_obj=elm)  # Add generator to the grid
+                grid.add_static_generator(bus=bus, api_obj=elm)  # Add generator to the grid
 
-            self.register(panda_type="sgen", panda_code=idx, api_obj=elm)
+                self.register(panda_type="sgen", panda_code=idx, api_obj=elm)
 
     def parse_transformers(self, grid: dev.MultiCircuit, bus_dictionary: Dict[str, dev.Bus]):
         """
@@ -789,39 +792,110 @@ class Panda2VeraGrid:
                         else:
                             self.logger.add_warning(f"PandaPower {m_tpe} measurement not implemented")
 
-                    elif elm_tpe in ['line', 'impedance', 'trafo']:
+                    elif elm_tpe in ['line', 'impedance', 'trafo','trafo3w']:
                         if m_tpe == 'p':
-                            if side == 1 or side == 'from':
-                                grid.add_pf_measurement(dev.PfMeasurement(
-                                    value=val * self.load_scale,
-                                    uncertainty=std,
-                                    api_obj=api_object,
-                                    name=name
-                                ))
-                            elif side == 2 or side == 'to':
+                            if side == 1 or side == 'from' or side == "hv":
+                                if elm_tpe=="trafo3w":
+                                    grid.add_pf_measurement(dev.PfMeasurement(
+                                        value=val * self.load_scale,
+                                        uncertainty=std,
+                                        api_obj=api_object.winding1,
+                                        name=name
+                                    ))
+                                else:
+                                    grid.add_pf_measurement(dev.PfMeasurement(
+                                        value=val * self.load_scale,
+                                        uncertainty=std,
+                                        api_obj=api_object,
+                                        name=name
+                                    ))
+                            elif side == 2 or side == 'to' or side == "lv":
+                                if elm_tpe=="trafo3w":
+                                    grid.add_pt_measurement(dev.PtMeasurement(
+                                        value=val * self.load_scale,
+                                        uncertainty=std,
+                                        api_obj=api_object.winding3, # winding3 corresponds to bus3 and LV side
+                                        name=name
+                                    ))
+                                else:
+                                    grid.add_pt_measurement(dev.PtMeasurement(
+                                        value=val * self.load_scale,
+                                        uncertainty=std,
+                                        api_obj=api_object,
+                                        name=name
+                                    ))
+                            elif side == "mv": # for trafo3w MV side
                                 grid.add_pt_measurement(dev.PtMeasurement(
                                     value=val * self.load_scale,
                                     uncertainty=std,
-                                    api_obj=api_object,
+                                    api_obj=api_object.winding2, # bus2 is MV and winding2
                                     name=name
                                 ))
+
                         elif m_tpe == 'q':
-                            if side == 1 or side == 'from':
-                                grid.add_qf_measurement(dev.QfMeasurement(
-                                    value=val * self.load_scale,
-                                    uncertainty=std,
-                                    api_obj=api_object,
-                                    name=name
-                                ))
-                            elif side == 2 or side == 'to':
+                            if side == 1 or side == 'from' or side == "hv":
+                                if elm_tpe=="trafo3w":
+                                    grid.add_qf_measurement(dev.QfMeasurement(
+                                        value=val * self.load_scale,
+                                        uncertainty=std,
+                                        api_obj=api_object.winding1,
+                                        name=name
+                                    ))
+                                else:
+                                    grid.add_qf_measurement(dev.QfMeasurement(
+                                        value=val * self.load_scale,
+                                        uncertainty=std,
+                                        api_obj=api_object,
+                                        name=name
+                                    ))
+
+                            elif side == 2 or side == 'to' or side == "lv":
+                                if elm_tpe=="trafo3w":
+                                    grid.add_qt_measurement(dev.QtMeasurement(
+                                        value=val * self.load_scale,
+                                        uncertainty=std,
+                                        api_obj=api_object.winding3,
+                                        name=name
+                                    ))
+                                else:
+                                    grid.add_qt_measurement(dev.QtMeasurement(
+                                        value=val * self.load_scale,
+                                        uncertainty=std,
+                                        api_obj=api_object,
+                                        name=name
+                                    ))
+                            elif side == "mv":
                                 grid.add_qt_measurement(dev.QtMeasurement(
                                     value=val * self.load_scale,
                                     uncertainty=std,
-                                    api_obj=api_object,
+                                    api_obj=api_object.winding2,
                                     name=name
                                 ))
                         elif m_tpe == "i":
-                            if elm_tpe == 'transformer':
+                            if elm_tpe == 'trafo':
+                                if side == 1 or side == "hv" or side == 'from':
+                                    vnom = api_object.bus_from.Vnom if hasattr(api_object.bus_from, 'Vnom') else 1.0
+                                    ibase = grid.Sbase / (vnom * math.sqrt(3))
+                                    value = val / ibase  # Convert kA to pu
+                                    grid.add_if_measurement(
+                                        dev.IfMeasurement(
+                                            value=value,
+                                            uncertainty=std,
+                                            api_obj=api_object,
+                                            name=name
+                                        ))
+                                if side == 2 or side == "lv" or side == 'to':
+                                    vnom = api_object.bus_to.Vnom if hasattr(api_object.bus_to, 'Vnom') else 1.0
+                                    ibase = grid.Sbase / (vnom * math.sqrt(3))
+                                    value = val / ibase  # Convert kA to pu
+                                    grid.add_it_measurement(
+                                        dev.ItMeasurement(
+                                            value=value,
+                                            uncertainty=std,
+                                            api_obj=api_object,
+                                            name=name
+                                        ))
+                            elif elm_tpe == 'trafo3w':
                                 if side == 1 or side == "hv":
                                     vnom = api_object.bus1.Vnom if hasattr(api_object.bus1, 'Vnom') else 1.0
                                     ibase = grid.Sbase / (vnom * math.sqrt(3))
@@ -830,10 +904,10 @@ class Panda2VeraGrid:
                                         dev.IfMeasurement(
                                             value=value,
                                             uncertainty=std,
-                                            api_obj=api_object,
+                                            api_obj=api_object.winding1,
                                             name=name
                                         ))
-                                if side == 2 or side == "lv":
+                                if side == 2 or side == "mv":
                                     vnom = api_object.bus2.Vnom if hasattr(api_object.bus2, 'Vnom') else 1.0
                                     ibase = grid.Sbase / (vnom * math.sqrt(3))
                                     value = val / ibase  # Convert kA to pu
@@ -841,7 +915,18 @@ class Panda2VeraGrid:
                                         dev.ItMeasurement(
                                             value=value,
                                             uncertainty=std,
-                                            api_obj=api_object,
+                                            api_obj=api_object.winding2,
+                                            name=name
+                                        ))
+                                if side == 3 or side == "lv":
+                                    vnom = api_object.bus3.Vnom if hasattr(api_object.bus3, 'Vnom') else 1.0
+                                    ibase = grid.Sbase / (vnom * math.sqrt(3))
+                                    value = val / ibase  # Convert kA to pu
+                                    grid.add_it_measurement(
+                                        dev.ItMeasurement(
+                                            value=value,
+                                            uncertainty=std,
+                                            api_obj=api_object.winding3,
                                             name=name
                                         ))
                             else:

{veragridengine-5.4.5 → veragridengine-5.4.6}/VeraGridEngine/Simulations/ContingencyAnalysis/Methods/optimal_linear_contingency_analysis.py

@@ -9,7 +9,7 @@ from VeraGridEngine.Compilers.circuit_to_data import compile_numerical_circuit_a
 from VeraGridEngine.Simulations.ContingencyAnalysis.contingency_analysis_results import ContingencyAnalysisResults
 from VeraGridEngine.Simulations.LinearFactors.linear_analysis import LinearAnalysis, LinearMultiContingencies
 from VeraGridEngine.Simulations.ContingencyAnalysis.contingency_analysis_options import ContingencyAnalysisOptions
-from VeraGridEngine.Simulations.OPF.linear_opf_ts import run_linear_opf_ts
+from VeraGridEngine.Simulations.OPF.Formulations.linear_opf_ts import run_linear_opf_ts
 from VeraGridEngine.Simulations.OPF.opf_options import OptimalPowerFlowOptions
 from VeraGridEngine.basic_structures import Logger
 

{veragridengine-5.4.5 → veragridengine-5.4.6}/VeraGridEngine/Simulations/LinearFactors/linear_analysis.py

@@ -747,7 +747,7 @@ class LinearMultiContingencies:
         self.__branches_dict = grid.get_branches_index_dict2(add_vsc=False, add_hvdc=False, add_switch=True)
         self.__hvdc_dict = grid.get_hvdc_index_dict()
         self.__vsc_dict = grid.get_vsc_index_dict()
-        self.__generator_bus_index_dict = {g.idtag: bus_index_dict[g.bus] for g in grid.get_generators()}
+        self.__generator_bus_index_dict = grid.get_generator_bus_index_dict(bus_index_dict=bus_index_dict)
 
         self.contingency_indices_list = list()
 
@@ -769,12 +769,16 @@ class LinearMultiContingencies:
 
     @property
     def contingency_group_dict(self) -> Dict[str, List[Contingency]]:
+        """
+        get the contingency grooups dictionary
+        :return: Dict[str, List[Contingency]]
+        """
         return self.__contingency_group_dict
 
     def get_contingency_group_names(self) -> List[str]:
         """
         Returns a list of the names of the used contingency groups
-        :return:
+        :return: List[str]
         """
         return [elm.name for elm in self.contingency_groups_used]
 

{veragridengine-5.4.5 → veragridengine-5.4.6}/VeraGridEngine/Simulations/NodalCapacity/nodal_capacity_ts_driver.py

@@ -10,8 +10,8 @@ from typing import Union, List
 from VeraGridEngine.Devices.multi_circuit import MultiCircuit
 from VeraGridEngine.enumerations import EngineType, SimulationTypes
 from VeraGridEngine.Simulations.OPF.opf_options import OptimalPowerFlowOptions
-from VeraGridEngine.Simulations.OPF.linear_opf_ts import run_linear_opf_ts
-from VeraGridEngine.Simulations.OPF.NumericalMethods.ac_opf import run_nonlinear_opf
+from VeraGridEngine.Simulations.OPF.Formulations.linear_opf_ts import run_linear_opf_ts
+from VeraGridEngine.Simulations.OPF.ac_opf_worker import run_nonlinear_opf
 from VeraGridEngine.Simulations.NodalCapacity.nodal_capacity_options import NodalCapacityOptions
 from VeraGridEngine.Simulations.NodalCapacity.nodal_capacity_ts_results import NodalCapacityTimeSeriesResults
 from VeraGridEngine.Simulations.PowerFlow.power_flow_options import PowerFlowOptions

{veragridengine-5.4.5 → veragridengine-5.4.6}/VeraGridEngine/Simulations/OPF/Formulations/ac_opf_problem.py

@@ -150,7 +150,6 @@ class NonlinearOPFResults:
         return self.Vm * np.exp(1j * self.Va)
 
 
-
 class NonLinearOptimalPfProblem:
 
     def __init__(self,
@@ -301,9 +300,9 @@ class NonLinearOptimalPfProblem:
         self.Cdispgen_t = self.Cdispgen.T
 
         self.Cdispgen_sh = csc_matrix((np.ones(self.n_gen_disp_sh),
-                                    (self.gen_bus_idx[self.gen_disp_idx_sh],
-                                     np.arange(self.n_gen_disp_sh))),
-                                   shape=(self.nbus, self.n_gen_disp_sh))
+                                       (self.gen_bus_idx[self.gen_disp_idx_sh],
+                                        np.arange(self.n_gen_disp_sh))),
+                                      shape=(self.nbus, self.n_gen_disp_sh))
         self.Cdispgen_sh_t = self.Cdispgen.T
 
         self.Inom = nc.generator_data.snom / self.Sbase
@@ -409,7 +408,7 @@ class NonLinearOptimalPfProblem:
                 np.zeros(self.nsh)
             ]
             self.Qg = np.r_[
-                (self.Qg_max[self.gen_disp_idx] + self.Qg_min[self.gen_disp_idx]) / 2 ,
+                (self.Qg_max[self.gen_disp_idx] + self.Qg_min[self.gen_disp_idx]) / 2,
                 np.zeros(self.nsh)
             ]
             self.Va = np.angle(nc.bus_data.Vbus)
@@ -727,7 +726,7 @@ class NonLinearOptimalPfProblem:
         :param mu:
         :param lam:
         :param compute_hessians:
-        :return:
+        :return: fx, Gx, Hx, fxx, Gxx, Hxx
         """
 
         # Number of variables of the typical power flow (V, th, P, Q). Used to ease readability
@@ -830,12 +829,11 @@ class NonLinearOptimalPfProblem:
         GSpg = - self.Cdispgen_sh
         GSqg = -1j * self.Cdispgen_sh
 
-        GTH = csc((len(self.slack), self.NV))
+        GTH = lil_matrix((len(self.slack), self.NV))
         for i, ss in enumerate(self.slack):
             GTH[i, ss] = 1.
 
-
-        Gvm = csc((len(self.pv), self.NV))
+        Gvm = lil_matrix((len(self.pv), self.NV))
         for i, ss in enumerate(self.pv):
             Gvm[i, self.nbus + ss] = 1.
 
@@ -852,14 +850,14 @@ class NonLinearOptimalPfProblem:
         else:
             Gtapt = csc((self.nbus, self.ntapt), dtype=complex)
 
-        GSpfdc = csc((self.nbus, self.n_disp_hvdc), dtype=complex)
+        GSpfdc = lil_matrix((self.nbus, self.n_disp_hvdc), dtype=complex)
         for k_link in range(self.n_disp_hvdc):
             GSpfdc[self.f_disp_hvdc[k_link], k_link] = 1.0  # TODO: check that this is correct
             GSpfdc[self.t_disp_hvdc[k_link], k_link] = -1.0  # TODO: check that this is correct
 
         Gslack = csc((self.nbus, self.nsl), dtype=complex)
 
-        Gslcap = csc((self.nbus, self.nslcap), dtype=complex)
+        Gslcap = lil_matrix((self.nbus, self.nslcap), dtype=complex)
         if self.nslcap != 0:
             for idslcap, capbus in enumerate(self.capacity_nodes_idx):
                 Gslcap[capbus, idslcap] = -1
@@ -1108,15 +1106,31 @@ class NonLinearOptimalPfProblem:
                  lil_matrix((nqct, self.nsl + self.nslcap + self.ntapm + self.ntapt + self.n_disp_hvdc))])
         else:
             Hqmax = lil_matrix((nqct, self.NV))
-            Hqmaxv = lil_matrix((nqct, self.nbus))
-
-        Hdcu = sp.hstack(
-            [lil_matrix((self.n_disp_hvdc, self.NV - self.n_disp_hvdc)), diags_disp_hvdc_ones])
-        Hdcl = sp.hstack(
-            [lil_matrix((self.n_disp_hvdc, self.NV - self.n_disp_hvdc)), - diags_disp_hvdc_ones])
 
-        Hx = sp.vstack([HSf, HSt, Hvu, Hpu, Hqu, Hvl, Hpl, Hql, Hslsf, Hslst, Hslvmax,
-                        Hslvmin, Htapmu, Htapml, Htaptu, Htaptl, Hqmax, Hdcu, Hdcl])
+        Hdcu = sp.hstack([lil_matrix((self.n_disp_hvdc, self.NV - self.n_disp_hvdc)), diags_disp_hvdc_ones])
+        Hdcl = sp.hstack([lil_matrix((self.n_disp_hvdc, self.NV - self.n_disp_hvdc)), - diags_disp_hvdc_ones])
+
+        Hx = sp.vstack([
+            HSf,
+            HSt,
+            Hvu,
+            Hpu,
+            Hqu,
+            Hvl,
+            Hpl,
+            Hql,
+            Hslsf,
+            Hslst,
+            Hslvmax,
+            Hslvmin,
+            Htapmu,
+            Htapml,
+            Htaptu,
+            Htaptl,
+            Hqmax,
+            Hdcu,
+            Hdcl
+        ])
 
         Hx = Hx.tocsc()
         te_hx = timeit.default_timer()
@@ -1297,12 +1311,16 @@ class NonLinearOptimalPfProblem:
                 if self.n_disp_hvdc != 0:
                     b = - 2 * self.n_disp_hvdc
 
-                Hqpgpg = diags(np.r_[np.array([2] * self.n_gen_disp) * mu[
-                                                                       - self.n_gen_disp - 2 * self.n_disp_hvdc:b], np.zeros(
-                    self.nsh)])
-                Hqqgqg = diags(np.r_[np.array([2] * self.n_gen_disp) * mu[
-                                                                       - self.n_gen_disp - 2 * self.n_disp_hvdc:b], np.zeros(
-                    self.nsh)])
+                Hqpgpg = diags(
+                    np.r_[np.array([2] * self.n_gen_disp) * mu[- self.n_gen_disp - 2 * self.n_disp_hvdc:b],
+                    np.zeros(self.nsh)]
+                )
+
+                Hqqgqg = diags(
+                    np.r_[np.array([2] * self.n_gen_disp) * mu[- self.n_gen_disp - 2 * self.n_disp_hvdc:b],
+                    np.zeros(self.nsh)]
+                )
+
                 Hqvmvm = (self.Cdispgen @ diags(mu[- self.n_gen_disp - 2 * self.n_disp_hvdc: b])
                           @ (- 2 * diags(np.power(self.Inom, 2.0)) * self.Cdispgen_t))
             else:
@@ -1368,13 +1386,17 @@ class NonLinearOptimalPfProblem:
                          self.n_gen_disp_sh + self.nsl + self.nslcap + self.ntapm + self.ntapt + self.n_disp_hvdc))])
 
                 H4 = sp.hstack(
-                    [lil_matrix((self.n_gen_disp_sh, 2 * self.nbus + self.n_gen_disp_sh)), Hqqgqg,
-                     lil_matrix(
-                         (self.n_gen_disp_sh, self.nsl + self.nslcap + self.ntapm + self.ntapt + self.n_disp_hvdc))])
-
-                H5 = sp.hstack([Hftapmva + Httapmva, Hftapmvm + Httapmvm,
+                    [lil_matrix((self.n_gen_disp_sh,
+                                 2 * self.nbus + self.n_gen_disp_sh)),
+                     Hqqgqg,
+                     lil_matrix((self.n_gen_disp_sh,
+                                 self.nsl + self.nslcap + self.ntapm + self.ntapt + self.n_disp_hvdc))])
+
+                H5 = sp.hstack([Hftapmva + Httapmva,
+                                Hftapmvm + Httapmvm,
                                 lil_matrix((self.ntapm, 2 * self.n_gen_disp_sh + self.nsl + self.nslcap)),
-                                Hftapmtapm + Httapmtapm, Hftapmtapt + Httapmtapt,
+                                Hftapmtapm + Httapmtapm,
+                                Hftapmtapt + Httapmtapt,
                                 lil_matrix((self.ntapm, self.n_disp_hvdc))])
 
                 H6 = sp.hstack([Hftaptva + Httaptva,
@@ -1388,22 +1410,26 @@ class NonLinearOptimalPfProblem:
                                  lil_matrix((self.n_disp_hvdc, self.NV))]).tocsc()
 
             else:
-                H1 = sp.hstack([Hfvava + Htvava, Hfvavm + Htvavm,
-                                lil_matrix(
-                                    (self.nbus, 2 * self.n_gen_disp_sh + self.nsl + self.nslcap + self.n_disp_hvdc))])
-                H2 = sp.hstack(
-                    [Hfvmva + Htvmva, Hfvmvm + Htvmvm + Hqvmvm,
-                     lil_matrix((self.nbus, 2 * self.n_gen_disp_sh + self.nsl + self.nslcap + self.n_disp_hvdc))])
-                H3 = sp.hstack([lil_matrix((self.n_gen_disp_sh, 2 * self.nbus)), Hqpgpg,
-                                lil_matrix(
-                                    (
-                                        self.n_gen_disp_sh,
-                                        self.n_gen_disp_sh + self.nsl + self.nslcap + self.n_disp_hvdc))])
+                H1 = sp.hstack([Hfvava + Htvava,
+                                Hfvavm + Htvavm,
+                                lil_matrix((self.nbus,
+                                            2 * self.n_gen_disp_sh + self.nsl + self.nslcap + self.n_disp_hvdc))])
+
+                H2 = sp.hstack([Hfvmva + Htvmva,
+                                Hfvmvm + Htvmvm + Hqvmvm,
+                                lil_matrix((self.nbus,
+                                            2 * self.n_gen_disp_sh + self.nsl + self.nslcap + self.n_disp_hvdc))])
+
+                H3 = sp.hstack([lil_matrix((self.n_gen_disp_sh, 2 * self.nbus)),
+                                Hqpgpg,
+                                lil_matrix((self.n_gen_disp_sh,
+                                            self.n_gen_disp_sh + self.nsl + self.nslcap + self.n_disp_hvdc))])
+
                 H4 = sp.hstack([lil_matrix((self.n_gen_disp_sh, 2 * self.nbus + self.n_gen_disp_sh)), Hqqgqg,
                                 lil_matrix((self.n_gen_disp_sh, self.nsl + self.nslcap + self.n_disp_hvdc))])
 
-                Hxx = sp.vstack(
-                    [H1, H2, H3, H4, lil_matrix((self.nsl + self.nslcap + self.n_disp_hvdc, self.NV))]).tocsc()
+                Hxx = sp.vstack([H1, H2, H3, H4,
+                                 lil_matrix((self.nsl + self.nslcap + self.n_disp_hvdc, self.NV))]).tocsc()
 
             te_hxx = timeit.default_timer()
         else:
@@ -1723,7 +1749,7 @@ class NonLinearOptimalPfProblem:
         Pcost = np.zeros(self.ngen + self.nsh)
 
         Pcost[self.gen_disp_idx_sh] = (self.c0 + self.c1 * Pg[self.gen_disp_idx_sh]
-                                    + self.c2 * np.power(Pg[self.gen_disp_idx_sh], 2.0))
+                                       + self.c2 * np.power(Pg[self.gen_disp_idx_sh], 2.0))
 
         Pcost[self.gen_nondisp_idx] = (self.c0n + self.c1n * np.real(self.Sg_undis)
                                        + self.c2n * np.power(np.real(self.Sg_undis), 2.0))

{veragridengine-5.4.5 → veragridengine-5.4.6}/VeraGridEngine/Simulations/OPF/NumericalMethods/ac_opf_derivatives.py

@@ -455,8 +455,9 @@ def eval_f(x: Vec, Cg: csc_matrix, k_m: Vec, k_tau: Vec, nll: int, c0: Vec, c1:
                                                                          nslcap=nslcap, acopf_mode=acopf_mode)
     # Obj. function:  Active power generation costs plus overloads and voltage deviation penalties
 
-    fval = 1e-4 * (np.sum((c0 + c1 * Pg * Sbase + c2 * np.power(Pg * Sbase, 2)))
-                   + np.sum(c_s * (sl_sf + sl_st)) + np.sum(c_v * (sl_vmax + sl_vmin))
+    fval = 1e-4 * (np.sum(c0 + c1 * Pg * Sbase + c2 * np.power(Pg * Sbase, 2.0))
+                   + np.sum(c_s * (sl_sf + sl_st))
+                   + np.sum(c_v * (sl_vmax + sl_vmin))
                    + np.sum(nodal_capacity_sign * slcap))
 
     return fval
@@ -636,7 +637,8 @@ def eval_h(x: Vec, Yf: csc_matrix, Yt: csc_matrix, from_idx: Vec, to_idx: Vec, n
 
 
 def jacobians_and_hessians(x: Vec, c1: Vec, c2: Vec, c_s: Vec, c_v: Vec, Cg: csc_matrix, Cf: csc, Ct: csc, Inom: Vec,
-                           Yf: csc_matrix, Yt: csc_matrix, Ybus: csc_matrix, Sbase: float, mon_br_idx: IntVec, ig: IntVec,
+                           Yf: csc_matrix, Yt: csc_matrix, Ybus: csc_matrix, Sbase: float, mon_br_idx: IntVec,
+                           ig: IntVec,
                            slack: Vec, nslcap: int, nodal_capacity_sign: float, capacity_nodes_idx: IntVec, pq: IntVec,
                            pv: IntVec, alltapm: Vec, alltapt: Vec, F_hvdc: IntVec, T_hvdc: IntVec, nsh: int,
                            k_m: IntVec, k_tau: IntVec, mu, lmbda, R: Vec, X: Vec, F: IntVec, T: IntVec,