GridCalEngine 5.3.27__tar.gz → 5.3.29__tar.gz

{gridcalengine-5.3.27 → gridcalengine-5.3.29}/GridCalEngine/Compilers/circuit_to_data.py

@@ -288,173 +288,189 @@ def get_load_data(data: LoadData,
     ii = 0
     for elm in circuit.get_loads():
 
-        i = bus_dict[elm.bus]
+        if elm.bus is None:
+            data.bus_idx[ii] = -1
+            data.active[ii] = False
+        else:
+            i = bus_dict[elm.bus]
 
-        data.names[ii] = elm.name
-        data.idtag[ii] = elm.idtag
-        data.bus_idx[ii] = i
-        data.original_idx[ii] = ii
-        data.mttf[ii] = elm.mttf
-        data.mttr[ii] = elm.mttr
+            data.names[ii] = elm.name
+            data.idtag[ii] = elm.idtag
+            data.bus_idx[ii] = i
+            data.original_idx[ii] = ii
+            data.mttf[ii] = elm.mttf
+            data.mttr[ii] = elm.mttr
 
-        if time_series:
-            if opf_results is not None:
-                data.S[ii] = complex(elm.P_prof[t_idx], elm.Q_prof[t_idx]) - opf_results.load_shedding[t_idx, ii]
-            else:
-                data.S[ii] = complex(elm.P_prof[t_idx], elm.Q_prof[t_idx])
+            if time_series:
+                if opf_results is not None:
+                    data.S[ii] = complex(elm.P_prof[t_idx], elm.Q_prof[t_idx]) - opf_results.load_shedding[t_idx, ii]
+                else:
+                    data.S[ii] = complex(elm.P_prof[t_idx], elm.Q_prof[t_idx])
 
-            data.I[ii] = complex(elm.Ir_prof[t_idx], elm.Ii_prof[t_idx])
-            data.Y[ii] = complex(elm.G_prof[t_idx], elm.B_prof[t_idx])
+                data.I[ii] = complex(elm.Ir_prof[t_idx], elm.Ii_prof[t_idx])
+                data.Y[ii] = complex(elm.G_prof[t_idx], elm.B_prof[t_idx])
 
-            data.active[ii] = elm.active_prof[t_idx]
-            data.cost[ii] = elm.Cost_prof[t_idx]
+                data.active[ii] = elm.active_prof[t_idx]
+                data.cost[ii] = elm.Cost_prof[t_idx]
 
-        else:
-            if opf_results is not None:
-                data.S[ii] = complex(elm.P, elm.Q) - opf_results.load_shedding[ii]
             else:
-                data.S[ii] = complex(elm.P, elm.Q)
-
-            data.I[ii] = complex(elm.Ir, elm.Ii)
-            data.Y[ii] = complex(elm.G, elm.B)
-            data.active[ii] = elm.active
-            data.cost[ii] = elm.Cost
-
-        if elm.use_kw:
-            # pass kW to MW
-            data.S[ii] /= 1000.0
-            data.I[ii] /= 1000.0
-            data.Y[ii] /= 1000.0
-            data.cost[ii] /= 1000.0
-
-        # reactive power sharing data
-        if data.active[ii]:
-            bus_data.q_fixed[i] -= data.S[ii].imag
-            bus_data.ii_fixed[i] -= data.I[ii].imag
-            bus_data.b_fixed[i] -= data.Y[ii].imag
+                if opf_results is not None:
+                    data.S[ii] = complex(elm.P, elm.Q) - opf_results.load_shedding[ii]
+                else:
+                    data.S[ii] = complex(elm.P, elm.Q)
+
+                data.I[ii] = complex(elm.Ir, elm.Ii)
+                data.Y[ii] = complex(elm.G, elm.B)
+                data.active[ii] = elm.active
+                data.cost[ii] = elm.Cost
+
+            if elm.use_kw:
+                # pass kW to MW
+                data.S[ii] /= 1000.0
+                data.I[ii] /= 1000.0
+                data.Y[ii] /= 1000.0
+                data.cost[ii] /= 1000.0
+
+            # reactive power sharing data
+            if data.active[ii]:
+                bus_data.q_fixed[i] -= data.S[ii].imag
+                bus_data.ii_fixed[i] -= data.I[ii].imag
+                bus_data.b_fixed[i] -= data.Y[ii].imag
 
         # data.C_bus_elm[i, ii] = 1
         ii += 1
 
     for elm in circuit.get_static_generators():
 
-        i = bus_dict[elm.bus]
-        data.bus_idx[ii] = i
-        data.names[ii] = elm.name
-        data.idtag[ii] = elm.idtag
-        data.original_idx[ii] = ii
+        if elm.bus is None:
+            data.bus_idx[ii] = -1
+            data.active[ii] = False
+        else:
+            i = bus_dict[elm.bus]
+            data.bus_idx[ii] = i
+            data.names[ii] = elm.name
+            data.idtag[ii] = elm.idtag
+            data.original_idx[ii] = ii
 
-        if time_series:
-            data.S[ii] -= complex(elm.P_prof[t_idx], elm.Q_prof[t_idx])
-            data.active[ii] = elm.active_prof[t_idx]
-            data.cost[ii] = elm.Cost_prof[t_idx]
+            if time_series:
+                data.S[ii] -= complex(elm.P_prof[t_idx], elm.Q_prof[t_idx])
+                data.active[ii] = elm.active_prof[t_idx]
+                data.cost[ii] = elm.Cost_prof[t_idx]
 
-        else:
-            data.S[ii] -= complex(elm.P, elm.Q)
-            data.active[ii] = elm.active
-            data.cost[ii] = elm.Cost
+            else:
+                data.S[ii] -= complex(elm.P, elm.Q)
+                data.active[ii] = elm.active
+                data.cost[ii] = elm.Cost
 
-        if elm.use_kw:
-            # pass kW to MW
-            data.S[ii] /= 1000.0
-            data.cost[ii] /= 1000.0
+            if elm.use_kw:
+                # pass kW to MW
+                data.S[ii] /= 1000.0
+                data.cost[ii] /= 1000.0
 
-        # reactive power sharing data
-        if data.active[ii]:
-            bus_data.q_fixed[i] += data.S[ii].imag
-            # bus_data.ii_fixed[i] += data.I[ii].imag
-            # bus_data.b_fixed[i] += data.Y[ii].imag
+            # reactive power sharing data
+            if data.active[ii]:
+                bus_data.q_fixed[i] += data.S[ii].imag
+                # bus_data.ii_fixed[i] += data.I[ii].imag
+                # bus_data.b_fixed[i] += data.Y[ii].imag
 
         # data.C_bus_elm[i, ii] = 1
         ii += 1
 
     for elm in circuit.get_external_grids():
 
-        i = bus_dict[elm.bus]
-        data.bus_idx[ii] = i
-        data.names[ii] = elm.name
-        data.idtag[ii] = elm.idtag
-        data.original_idx[ii] = ii
+        if elm.bus is None:
+            data.bus_idx[ii] = -1
+            data.active[ii] = False
+        else:
+            i = bus_dict[elm.bus]
+            data.bus_idx[ii] = i
+            data.names[ii] = elm.name
+            data.idtag[ii] = elm.idtag
+            data.original_idx[ii] = ii
 
-        # change stuff depending on the modes
-        if elm.mode == ExternalGridMode.VD:
-            # bus_data.bus_types[i] = BusMode.Slack_tpe.value  # set as Slack
-            bus_data.set_bus_mode(i, BusMode.Slack_tpe)
+            # change stuff depending on the modes
+            if elm.mode == ExternalGridMode.VD:
+                # bus_data.bus_types[i] = BusMode.Slack_tpe.value  # set as Slack
+                bus_data.set_bus_mode(i, BusMode.Slack_tpe)
 
-            set_bus_control_voltage(i=i,
-                                    j=-1,
-                                    remote_control=False,
-                                    bus_name=elm.bus.name,
-                                    bus_data=bus_data,
-                                    bus_voltage_used=bus_voltage_used,
-                                    candidate_Vm=elm.Vm_prof[t_idx] if time_series else elm.Vm,
-                                    use_stored_guess=use_stored_guess,
-                                    logger=logger)
-
-        elif elm.mode == ExternalGridMode.PV:
-
-            set_bus_control_voltage(i=i,
-                                    j=-1,
-                                    remote_control=False,
-                                    bus_name=elm.bus.name,
-                                    bus_data=bus_data,
-                                    bus_voltage_used=bus_voltage_used,
-                                    candidate_Vm=elm.Vm_prof[t_idx] if time_series else elm.Vm,
-                                    use_stored_guess=use_stored_guess,
-                                    logger=logger)
+                set_bus_control_voltage(i=i,
+                                        j=-1,
+                                        remote_control=False,
+                                        bus_name=elm.bus.name,
+                                        bus_data=bus_data,
+                                        bus_voltage_used=bus_voltage_used,
+                                        candidate_Vm=elm.Vm_prof[t_idx] if time_series else elm.Vm,
+                                        use_stored_guess=use_stored_guess,
+                                        logger=logger)
 
-        if time_series:
-            data.S[ii] += complex(elm.P_prof[t_idx], elm.Q_prof[t_idx])
-            data.active[ii] = elm.active_prof[t_idx]
+            elif elm.mode == ExternalGridMode.PV:
 
-        else:
-            data.S[ii] += complex(elm.P, elm.Q)
-            data.active[ii] = elm.active
+                set_bus_control_voltage(i=i,
+                                        j=-1,
+                                        remote_control=False,
+                                        bus_name=elm.bus.name,
+                                        bus_data=bus_data,
+                                        bus_voltage_used=bus_voltage_used,
+                                        candidate_Vm=elm.Vm_prof[t_idx] if time_series else elm.Vm,
+                                        use_stored_guess=use_stored_guess,
+                                        logger=logger)
+
+            if time_series:
+                data.S[ii] += complex(elm.P_prof[t_idx], elm.Q_prof[t_idx])
+                data.active[ii] = elm.active_prof[t_idx]
+
+            else:
+                data.S[ii] += complex(elm.P, elm.Q)
+                data.active[ii] = elm.active
 
-        if elm.use_kw:
-            # pass kW to MW
-            data.S[ii] /= 1000.0
-            data.cost[ii] /= 1000.0
+            if elm.use_kw:
+                # pass kW to MW
+                data.S[ii] /= 1000.0
+                data.cost[ii] /= 1000.0
 
-        # reactive power sharing data
-        if data.active[ii]:
-            bus_data.q_fixed[i] += data.S[ii].imag
-            bus_data.ii_fixed[i] += data.I[ii].imag
-            bus_data.b_fixed[i] += data.Y[ii].imag
+            # reactive power sharing data
+            if data.active[ii]:
+                bus_data.q_fixed[i] += data.S[ii].imag
+                bus_data.ii_fixed[i] += data.I[ii].imag
+                bus_data.b_fixed[i] += data.Y[ii].imag
 
         # data.C_bus_elm[i, ii] = 1
         ii += 1
 
     for elm in circuit.get_current_injections():
 
-        i = bus_dict[elm.bus]
-        data.bus_idx[ii] = i
-        data.names[ii] = elm.name
-        data.idtag[ii] = elm.idtag
-        data.original_idx[ii] = ii
-        data.mttf[ii] = elm.mttf
-        data.mttr[ii] = elm.mttr
-
-        if time_series:
-            data.I[ii] += complex(elm.Ir_prof[t_idx], elm.Ii_prof[t_idx])
-            data.active[ii] = elm.active_prof[t_idx]
-            data.cost[ii] = elm.Cost_prof[t_idx]
-
+        if elm.bus is None:
+            data.bus_idx[ii] = -1
+            data.active[ii] = False
         else:
-            data.I[ii] += complex(elm.Ir, elm.Ii)
-            data.active[ii] = elm.active
-            data.cost[ii] = elm.Cost
+            i = bus_dict[elm.bus]
+            data.bus_idx[ii] = i
+            data.names[ii] = elm.name
+            data.idtag[ii] = elm.idtag
+            data.original_idx[ii] = ii
+            data.mttf[ii] = elm.mttf
+            data.mttr[ii] = elm.mttr
 
-        if elm.use_kw:
-            # pass kW to MW
-            data.I[ii] /= 1000.0
-            data.cost[ii] /= 1000.0
+            if time_series:
+                data.I[ii] += complex(elm.Ir_prof[t_idx], elm.Ii_prof[t_idx])
+                data.active[ii] = elm.active_prof[t_idx]
+                data.cost[ii] = elm.Cost_prof[t_idx]
 
-            # reactive power sharing data
-        if data.active[ii]:
-            bus_data.q_fixed[i] += data.S[ii].imag
-            bus_data.ii_fixed[i] += data.I[ii].imag
-            bus_data.b_fixed[i] += data.Y[ii].imag
+            else:
+                data.I[ii] += complex(elm.Ir, elm.Ii)
+                data.active[ii] = elm.active
+                data.cost[ii] = elm.Cost
+
+            if elm.use_kw:
+                # pass kW to MW
+                data.I[ii] /= 1000.0
+                data.cost[ii] /= 1000.0
+
+                # reactive power sharing data
+            if data.active[ii]:
+                bus_data.q_fixed[i] += data.S[ii].imag
+                bus_data.ii_fixed[i] += data.I[ii].imag
+                bus_data.b_fixed[i] += data.Y[ii].imag
 
         # data.C_bus_elm[i, ii] = 1
         ii += 1
@@ -492,109 +508,118 @@ def get_shunt_data(
     ii = 0
     for k, elm in enumerate(circuit.get_shunts()):
 
-        i = bus_dict[elm.bus]
-        data.bus_idx[k] = i
-        data.names[k] = elm.name
-        data.idtag[k] = elm.idtag
-        data.original_idx[ii] = ii
-        data.mttf[k] = elm.mttf
-        data.mttr[k] = elm.mttr
-
-        if time_series:
-            data.active[k] = elm.active_prof[t_idx]
-            data.Y[k] = complex(elm.G_prof[t_idx], elm.B_prof[t_idx])
+        if elm.bus is None:
+            data.bus_idx[k] = -1
+            data.active[k] = False
         else:
-            data.active[k] = elm.active
-            data.Y[k] = complex(elm.G, elm.B)
 
-        if elm.use_kw:
-            # pass kW to MW
-            data.Y[ii] /= 1000.0
+            i = bus_dict[elm.bus]
+            data.bus_idx[k] = i
+            data.names[k] = elm.name
+            data.idtag[k] = elm.idtag
+            data.original_idx[ii] = ii
+            data.mttf[k] = elm.mttf
+            data.mttr[k] = elm.mttr
+
+            if time_series:
+                data.active[k] = elm.active_prof[t_idx]
+                data.Y[k] = complex(elm.G_prof[t_idx], elm.B_prof[t_idx])
+            else:
+                data.active[k] = elm.active
+                data.Y[k] = complex(elm.G, elm.B)
 
-        # reactive power sharing data
-        if data.active[ii]:
-            bus_data.b_fixed[i] += data.Y[ii].imag
+            if elm.use_kw:
+                # pass kW to MW
+                data.Y[ii] /= 1000.0
+
+            # reactive power sharing data
+            if data.active[ii]:
+                bus_data.b_fixed[i] += data.Y[ii].imag
 
         # data.C_bus_elm[i, k] = 1
         ii += 1
 
     for elm in circuit.get_controllable_shunts():
 
-        i = bus_dict[elm.bus]
-        data.bus_idx[ii] = i
-        data.names[ii] = elm.name
-        data.idtag[ii] = elm.idtag
-        data.original_idx[ii] = ii
-        data.mttf[ii] = elm.mttf
-        data.mttr[ii] = elm.mttr
+        if elm.bus is None:
+            data.bus_idx[ii] = -1
+            data.active[ii] = False
+        else:
+            i = bus_dict[elm.bus]
+            data.bus_idx[ii] = i
+            data.names[ii] = elm.name
+            data.idtag[ii] = elm.idtag
+            data.original_idx[ii] = ii
+            data.mttf[ii] = elm.mttf
+            data.mttr[ii] = elm.mttr
+
+            data.controllable[ii] = elm.is_controlled
+            data.vset[ii] = elm.Vset
+            data.qmin[ii] = elm.Bmin
+            data.qmax[ii] = elm.Bmax
 
-        data.controllable[ii] = elm.is_controlled
-        data.vset[ii] = elm.Vset
-        data.qmin[ii] = elm.Bmin
-        data.qmax[ii] = elm.Bmax
+            if time_series:
+                data.Y[ii] += complex(elm.G_prof[t_idx], elm.B_prof[t_idx])
+                data.active[ii] = elm.active_prof[t_idx]
+                data.cost[ii] = elm.Cost_prof[t_idx]
 
-        if time_series:
-            data.Y[ii] += complex(elm.G_prof[t_idx], elm.B_prof[t_idx])
-            data.active[ii] = elm.active_prof[t_idx]
-            data.cost[ii] = elm.Cost_prof[t_idx]
+                if elm.is_controlled and elm.active_prof[t_idx]:
 
-            if elm.is_controlled and elm.active_prof[t_idx]:
+                    if elm.control_bus_prof[t_idx] is not None:
+                        remote_control = True
+                        j = bus_dict[elm.control_bus_prof[t_idx]]
+                    else:
+                        remote_control = False
+                        j = -1
 
-                if elm.control_bus_prof[t_idx] is not None:
-                    remote_control = True
-                    j = bus_dict[elm.control_bus_prof[t_idx]]
-                else:
-                    remote_control = False
-                    j = -1
+                    data.controllable_bus_idx[ii] = j
 
-                data.controllable_bus_idx[ii] = j
+                    set_bus_control_voltage(i=i,
+                                            j=j,
+                                            remote_control=remote_control and control_remote_voltage,
+                                            bus_name=elm.bus.name,
+                                            bus_data=bus_data,
+                                            bus_voltage_used=bus_voltage_used,
+                                            candidate_Vm=elm.Vset_prof[t_idx],
+                                            use_stored_guess=use_stored_guess,
+                                            logger=logger)
 
-                set_bus_control_voltage(i=i,
-                                        j=j,
-                                        remote_control=remote_control and control_remote_voltage,
-                                        bus_name=elm.bus.name,
-                                        bus_data=bus_data,
-                                        bus_voltage_used=bus_voltage_used,
-                                        candidate_Vm=elm.Vset_prof[t_idx],
-                                        use_stored_guess=use_stored_guess,
-                                        logger=logger)
+            else:
+                data.Y[ii] += complex(elm.G, elm.B)
+                data.active[ii] = elm.active
+                data.cost[ii] = elm.Cost
+
+                if elm.is_controlled and elm.active:
+                    if elm.control_bus is not None:
+                        remote_control = True
+                        j = bus_dict[elm.control_bus]
+                    else:
+                        remote_control = False
+                        j = -1
+
+                    data.controllable_bus_idx[ii] = j
+
+                    set_bus_control_voltage(i=i,
+                                            j=j,
+                                            remote_control=remote_control and control_remote_voltage,
+                                            bus_name=elm.bus.name,
+                                            bus_data=bus_data,
+                                            bus_voltage_used=bus_voltage_used,
+                                            candidate_Vm=elm.Vset,
+                                            use_stored_guess=use_stored_guess,
+                                            logger=logger)
 
-        else:
-            data.Y[ii] += complex(elm.G, elm.B)
-            data.active[ii] = elm.active
-            data.cost[ii] = elm.Cost
+            if elm.use_kw:
+                # pass kW to MW
+                data.Y[ii] /= 1000.0
 
-            if elm.is_controlled and elm.active:
-                if elm.control_bus is not None:
-                    remote_control = True
-                    j = bus_dict[elm.control_bus]
+            # reactive power sharing data
+            if data.active[ii]:
+                if data.controllable[ii]:
+                    bus_data.q_shared_total[i] += data.Y[ii].imag
+                    data.q_share[ii] = data.Y[ii].imag
                 else:
-                    remote_control = False
-                    j = -1
-
-                data.controllable_bus_idx[ii] = j
-
-                set_bus_control_voltage(i=i,
-                                        j=j,
-                                        remote_control=remote_control and control_remote_voltage,
-                                        bus_name=elm.bus.name,
-                                        bus_data=bus_data,
-                                        bus_voltage_used=bus_voltage_used,
-                                        candidate_Vm=elm.Vset,
-                                        use_stored_guess=use_stored_guess,
-                                        logger=logger)
-
-        if elm.use_kw:
-            # pass kW to MW
-            data.Y[ii] /= 1000.0
-
-        # reactive power sharing data
-        if data.active[ii]:
-            if data.controllable[ii]:
-                bus_data.q_shared_total[i] += data.Y[ii].imag
-                data.q_share[ii] = data.Y[ii].imag
-            else:
-                bus_data.b_fixed[i] += data.Y[ii].imag
+                    bus_data.b_fixed[i] += data.Y[ii].imag
 
         # data.C_bus_elm[i, ii] = 1
         ii += 1
@@ -628,6 +653,10 @@ def fill_generator_parent(
     :param control_remote_voltage:
     :return:
     """
+    if elm.bus is None:
+        data.bus_idx[k] = -1
+        data.active[k] = False
+        return
 
     i = bus_dict[elm.bus]
     data.bus_idx[k] = i
@@ -2123,7 +2152,6 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
             t_idx=t_idx
         )
 
-
     if fill_gep:
 
         # formulate the investment
@@ -2132,8 +2160,6 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
 
         for investment in circuit.investments:
 
-
-
             # search in generators
             data = gen_dict.get(investment.device_idtag, None)
             if data is not None:

{gridcalengine-5.3.27 → gridcalengine-5.3.29}/GridCalEngine/Compilers/circuit_to_gslv.py

@@ -32,7 +32,7 @@ if TYPE_CHECKING:  # Only imports the below statements during type checking
     from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_options import ContingencyAnalysisOptions
     from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_results import ContingencyAnalysisResults
 
-GSLV_RECOMMENDED_VERSION = "0.0.4"
+GSLV_RECOMMENDED_VERSION = "0.1.1"
 GSLV_VERSION = ''
 GSLV_AVAILABLE = False
 try:
@@ -91,6 +91,12 @@ try:
         ContingencyOperationTypes.PowerPercentage: pg.ContingencyOperationTypes.PowerPercentage,
     }
 
+    contingency_method_dict = {
+        ContingencyMethod.PTDF: pg.ContingencyMethod.PTDF,
+        ContingencyMethod.PowerFlow: pg.ContingencyMethod.PowerFlow,
+        ContingencyMethod.HELM: pg.ContingencyMethod.HELM,
+    }
+
 except ImportError as e:
     pg = None
     GSLV_AVAILABLE = False
@@ -99,6 +105,7 @@ except ImportError as e:
     tap_module_control_mode_dict = dict()
     tap_phase_control_mode_dict = dict()
     contingency_ops_type_dict = dict()
+    contingency_method_dict = dict()
 
 
 def get_gslv_mip_solvers_list() -> List[str]:
@@ -541,8 +548,6 @@ def convert_contingencies(elm: dev.Contingency,
     :return:
     """
 
-
-
     return pg.Contingency(idtag=elm.idtag,
                           device_idtag=elm.device_idtag,
                           name=elm.name,
@@ -2434,3 +2439,66 @@ def translate_gslv_pf_results(grid: MultiCircuit, res: "pg.PowerFlowResults") ->
     #         results.convergence_reports.append(report)
 
     return results
+
+
+def gslv_contingencies(circuit: MultiCircuit,
+                       con_opt: ContingencyAnalysisOptions,
+                       time_series: bool = False,
+                       time_indices: Union[IntVec, None] = None) -> "pg.ContingencyAnalysisResults":
+    """
+    GSLV power flow
+    :param circuit: MultiCircuit instance
+    :param pf_opt: Power Flow Options
+    :param time_series: Compile with GridCal time series?
+    :param time_indices: Array of time indices
+    :param opf_results: Instance of
+    :return: GSLV Power flow results object
+    """
+    override_branch_controls = not (con_opt.pf_options.control_taps_modules and con_opt.pf_options.control_taps_phase)
+
+    gslv_grid, _ = to_gslv(circuit,
+                           use_time_series=time_series,
+                           time_indices=None,
+                           override_branch_controls=override_branch_controls,
+                           opf_results=None)
+
+    con_opt_gslv = pg.ContingencyAnalysisOptions(
+        use_provided_flows=con_opt.use_provided_flows,
+        Pf=con_opt.Pf,
+        pf_options=get_gslv_pf_options(con_opt.pf_options),
+        lin_options=pg.LinearAnalysisOptions(
+            distributeSlack=con_opt.lin_options.distribute_slack,
+            correctValues=con_opt.lin_options.correct_values,
+            ptdfThreshold=con_opt.lin_options.ptdf_threshold,
+            lodfThreshold=con_opt.lin_options.lodf_threshold,
+        ),
+        use_srap=con_opt.use_srap,
+        srap_max_power=con_opt.srap_max_power,
+        srap_top_n=con_opt.srap_top_n,
+        srap_dead_band=con_opt.srap_deadband,
+        srap_rever_to_nominal_rating=con_opt.srap_rever_to_nominal_rating,
+        detailed_massive_report=con_opt.detailed_massive_report,
+        contingency_dead_band=con_opt.contingency_deadband,
+        contingency_method=contingency_method_dict[con_opt.contingency_method],
+    )
+
+    if time_series:
+        # it is already sliced to the relevant time indices
+        if time_indices is None:
+            time_indices = [i for i in range(circuit.get_time_number())]
+        else:
+            time_indices = list(time_indices)
+        n_threads = 0  # max threads
+    else:
+        time_indices = [0]
+        n_threads = 1
+
+    logger = pg.Logger()
+
+    res = pg.run_contingencies(grid=gslv_grid,
+                                  options=con_opt_gslv,
+                                  n_threads=n_threads,
+                                  time_indices=time_indices,
+                                  logger=logger)
+
+    return res

{gridcalengine-5.3.27 → gridcalengine-5.3.29}/GridCalEngine/IO/cim/cgmes/gridcal_to_cgmes.py

@@ -357,10 +357,10 @@ def get_cgmes_cn_nodes_from_tp_nodes(multi_circuit_model: MultiCircuit,
         else:
             logger.add_error(
                 msg=f'TN has no ConnectivityNodeContainer, so cannot be assigned to CN',
-                device=tn.idtag,
-                device_class=tn.device_type.value,
+                device=tn.rdfid,
+                device_class=tn.tpe,
                 device_property="Bus.voltage_level.idtag",
-                value=tn.ConnectivityNodeContainer,
+                value="None",
                 comment="get_cgmes_cn_nodes_from_tp_nodes()"
             )