GridCalEngine 5.3.0__tar.gz → 5.3.0a1__tar.gz

{gridcalengine-5.3.0 → gridcalengine-5.3.0a1}/GridCalEngine/Compilers/circuit_to_data.py

@@ -70,119 +70,11 @@ def set_bus_control_voltage(i: int,
     if bus_data.bus_types[i] != BusMode.Slack_tpe.value:  # if it is not Slack
         if remote_control and j > -1 and j != i:
             # remove voltage control
-            # bus_data.bus_types[j] = BusMode.PQV_tpe.value  # remote bus to PQV type
-            bus_data.set_bus_mode(j, BusMode.PQV_tpe)
-            # bus_data.bus_types[i] = BusMode.P_tpe.value  # local bus to P type
-            bus_data.set_bus_mode(i, BusMode.P_tpe)
+            bus_data.bus_types[j] = BusMode.PQV_tpe.value  # remote bus to PQV type
+            bus_data.bus_types[i] = BusMode.P_tpe.value  # local bus to P type
         else:
             # local voltage control
-            # bus_data.bus_types[i] = BusMode.PV_tpe.value  # set as PV
-            bus_data.set_bus_mode(i, BusMode.PV_tpe)
-
-    if not use_stored_guess:
-        if not bus_voltage_used[i]:
-            if remote_control and j > -1 and j != i:
-                # initialize the remote bus voltage to the control value
-                bus_data.Vbus[j] = complex(candidate_Vm, 0)
-                bus_voltage_used[j] = True
-            else:
-                # initialize the local bus voltage to the control value
-                bus_data.Vbus[i] = complex(candidate_Vm, 0)
-                bus_voltage_used[i] = True
-
-        elif candidate_Vm != bus_data.Vbus[i]:
-            logger.add_error(msg='Different control voltage set points',
-                             device=bus_name,
-                             value=candidate_Vm,
-                             expected_value=bus_data.Vbus[i])
-
-
-def set_bus_control_voltage_vsc(i: int,
-                                j: int,
-                                remote_control: bool,
-                                bus_name: str,
-                                bus_voltage_used: BoolVec,
-                                bus_data: BusData,
-                                candidate_Vm: float,
-                                use_stored_guess: bool,
-                                logger: Logger) -> None:
-    """
-    Set the bus control voltage
-    :param i: Bus index
-    :param j: Remote Bus index
-    :param remote_control: Using remote control?
-    :param bus_name: Bus name
-    :param bus_voltage_used: Array of flags indicating if a bus voltage has been modified before
-    :param bus_data: BusData
-    :param candidate_Vm: Voltage set point that you want to set
-    :param use_stored_guess: Use the stored seed values?
-    :param logger: Logger
-    """
-    if bus_data.bus_types[i] != BusMode.Slack_tpe.value:  # if it is not Slack
-        if remote_control and j > -1 and j != i:
-            # remove voltage control
-            # bus_data.bus_types[j] = BusMode.PQV_tpe.value  # remote bus to PQV type
-            # bus_data.set_bus_mode(j, BusMode.PQV_tpe)
-            bus_data.is_p_controlled[j] = True
-            bus_data.is_q_controlled[j] = True
-            bus_data.is_vm_controlled[j] = True
-
-            # bus_data.bus_types[i] = BusMode.P_tpe.value  # local bus to P type
-            # bus_data.set_bus_mode(i, BusMode.P_tpe)
-            bus_data.is_p_controlled[i] = True
-        else:
-            # local voltage control
-            # bus_data.bus_types[i] = BusMode.PV_tpe.value  # set as PV
-            # bus_data.set_bus_mode(i, BusMode.PV_tpe)
-            bus_data.is_p_controlled[i] = True
-            bus_data.is_vm_controlled[i] = True
-
-    if not use_stored_guess:
-        if not bus_voltage_used[i]:
-            if remote_control and j > -1 and j != i:
-                # initialize the remote bus voltage to the control value
-                bus_data.Vbus[j] = complex(candidate_Vm, 0)
-                bus_voltage_used[j] = True
-            else:
-                # initialize the local bus voltage to the control value
-                bus_data.Vbus[i] = complex(candidate_Vm, 0)
-                bus_voltage_used[i] = True
-
-        elif candidate_Vm != bus_data.Vbus[i]:
-            logger.add_error(msg='Different control voltage set points',
-                             device=bus_name,
-                             value=candidate_Vm,
-                             expected_value=bus_data.Vbus[i])
-
-
-def set_bus_control_voltage_hvdc(i: int,
-                                 j: int,
-                                 remote_control: bool,
-                                 bus_name: str,
-                                 bus_voltage_used: BoolVec,
-                                 bus_data: BusData,
-                                 candidate_Vm: float,
-                                 use_stored_guess: bool,
-                                 logger: Logger) -> None:
-    """
-    Set the bus control voltage
-    :param i: Bus index
-    :param j: Remote Bus index
-    :param remote_control: Using remote control?
-    :param bus_name: Bus name
-    :param bus_voltage_used: Array of flags indicating if a bus voltage has been modified before
-    :param bus_data: BusData
-    :param candidate_Vm: Voltage set point that you want to set
-    :param use_stored_guess: Use the stored seed values?
-    :param logger: Logger
-    """
-    if bus_data.bus_types[i] != BusMode.Slack_tpe.value:  # if it is not Slack
-        # local voltage control
-        bus_data.bus_types[i] = BusMode.PV_tpe.value  # set as PV
-        # bus_data.set_bus_mode(i, BusMode.PV_tpe)
-        bus_data.is_p_controlled[i] = True
-        bus_data.is_vm_controlled[i] = True
-        bus_data.is_q_controlled[i] = True
+            bus_data.bus_types[i] = BusMode.PV_tpe.value  # set as PV
 
     if not use_stored_guess:
         if not bus_voltage_used[i]:
@@ -218,15 +110,15 @@ def get_bus_data(bus_data: BusData,
     :param use_stored_guess:
     :return:
     """
-
     substation_dict = {sub: i for i, sub in enumerate(circuit.substations)}
 
     for i, bus in enumerate(circuit.buses):
 
         # bus parameters
-        bus_data.original_idx[i] = i
         bus_data.names[i] = bus.name
         bus_data.idtag[i] = bus.idtag
+        bus_data.Vmin[i] = bus.Vmin
+        bus_data.Vmax[i] = bus.Vmax
         bus_data.Vnom[i] = bus.Vnom
         bus_data.cost_v[i] = bus.Vm_cost
         bus_data.Vbus[i] = bus.get_voltage_guess(use_stored_guess=use_stored_guess)
@@ -236,13 +128,10 @@ def get_bus_data(bus_data: BusData,
         bus_data.angle_max[i] = bus.angle_max
 
         if bus.is_slack:
-            # bus_data.bus_types[i] = BusMode.Slack_tpe.value  # VD
-            bus_data.set_bus_mode(i, BusMode.Slack_tpe)
-
+            bus_data.bus_types[i] = BusMode.Slack_tpe.value  # VD
         else:
             # PQ by default, later it is modified by generators and batteries
-            # bus_data.bus_types[i] = BusMode.PQ_tpe.value
-            bus_data.set_bus_mode(i, BusMode.PQ_tpe)
+            bus_data.bus_types[i] = BusMode.PQ_tpe.value
 
         bus_data.substations[i] = substation_dict.get(bus.substation, 0)
 
@@ -250,12 +139,8 @@ def get_bus_data(bus_data: BusData,
 
         if time_series:
             bus_data.active[i] = bus.active_prof[t_idx]
-            bus_data.Vmin[i] = bus.Vmin_prof[t_idx]
-            bus_data.Vmax[i] = bus.Vmax_prof[t_idx]
         else:
             bus_data.active[i] = bus.active
-            bus_data.Vmin[i] = bus.Vmin
-            bus_data.Vmax[i] = bus.Vmax
 
     return None
 
@@ -293,7 +178,7 @@ def get_load_data(data: LoadData,
         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
 
@@ -326,7 +211,7 @@ def get_load_data(data: LoadData,
             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
+        data.C_bus_elm[i, ii] = 1
         ii += 1
 
     for elm in circuit.get_static_generators():
@@ -335,7 +220,6 @@ def get_load_data(data: LoadData,
         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])
@@ -353,7 +237,7 @@ def get_load_data(data: LoadData,
             # 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
+        data.C_bus_elm[i, ii] = 1
         ii += 1
 
     for elm in circuit.get_external_grids():
@@ -362,12 +246,10 @@ def get_load_data(data: LoadData,
         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)
+            bus_data.bus_types[i] = BusMode.Slack_tpe.value  # set as Slack
 
         elif elm.mode == ExternalGridMode.PV:
 
@@ -395,7 +277,7 @@ def get_load_data(data: LoadData,
             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
+        data.C_bus_elm[i, ii] = 1
         ii += 1
 
     for elm in circuit.get_current_injections():
@@ -404,7 +286,7 @@ def get_load_data(data: LoadData,
         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
 
@@ -424,7 +306,7 @@ def get_load_data(data: LoadData,
             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
+        data.C_bus_elm[i, ii] = 1
         ii += 1
 
     return data
@@ -464,7 +346,7 @@ def get_shunt_data(
         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
 
@@ -479,7 +361,7 @@ def get_shunt_data(
         if data.active[ii]:
             bus_data.b_fixed[i] += data.Y[ii].imag
 
-        # data.C_bus_elm[i, k] = 1
+        data.C_bus_elm[i, k] = 1
         ii += 1
 
     for elm in circuit.get_controllable_shunts():
@@ -488,7 +370,7 @@ def get_shunt_data(
         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
 
@@ -556,32 +438,32 @@ def get_shunt_data(
             else:
                 bus_data.b_fixed[i] += data.Y[ii].imag
 
-        # data.C_bus_elm[i, ii] = 1
+        data.C_bus_elm[i, ii] = 1
         ii += 1
 
 
-def fill_generator_parent(
-        k: int,
-        data: GeneratorData | BatteryData,
-        elm: dev.Generator | dev.Battery,
+def get_generator_data(
+        data: GeneratorData,
+        circuit: MultiCircuit,
         bus_dict,
         bus_voltage_used: BoolVec,
         logger: Logger,
         bus_data: BusData,
+        opf_results: VALID_OPF_RESULTS | None = None,
         t_idx=-1,
         time_series=False,
         use_stored_guess=False,
         control_remote_voltage: bool = True,
-) -> None:
+) -> Dict[str, int]:
     """
-    Fill the common ancestor of generation and batteries
-    :param k:
+
     :param data:
-    :param elm:
+    :param circuit:
     :param bus_dict:
     :param bus_voltage_used:
     :param logger:
     :param bus_data:
+    :param opf_results:
     :param t_idx:
     :param time_series:
     :param use_stored_guess:
@@ -589,185 +471,136 @@ def fill_generator_parent(
     :return:
     """
 
-    i = bus_dict[elm.bus]
-    data.bus_idx[k] = i
-    data.names[k] = elm.name
-    data.idtag[k] = elm.idtag
-    data.original_idx[k] = k
-    data.mttf[k] = elm.mttf
-    data.mttr[k] = elm.mttr
-
-    data.controllable[k] = elm.is_controlled
-    data.installed_p[k] = elm.Snom
-
-    # r0, r1, r2, x0, x1, x2
-    data.r0[k] = elm.R0
-    data.r1[k] = elm.R1
-    data.r2[k] = elm.R2
-    data.x0[k] = elm.X0
-    data.x1[k] = elm.X1
-    data.x2[k] = elm.X2
-
-    data.ramp_up[k] = elm.RampUp
-    data.ramp_down[k] = elm.RampDown
-    data.min_time_up[k] = elm.MinTimeUp
-    data.min_time_down[k] = elm.MinTimeDown
-
-    data.dispatchable[k] = elm.enabled_dispatch
+    gen_index_dict: Dict[str, int] = dict()
+    for k, elm in enumerate(circuit.get_generators()):
 
-    data.snom[k] = elm.Snom
+        gen_index_dict[elm.idtag] = k  # associate the idtag to the index
 
-    if time_series:
-        data.p[k] = elm.P_prof[t_idx]
-        data.active[k] = elm.active_prof[t_idx]
-        data.pf[k] = elm.Pf_prof[t_idx]
-        data.v[k] = elm.Vset_prof[t_idx]
-        data.pmax[k] = elm.Pmax_prof[t_idx]
-        data.pmin[k] = elm.Pmin_prof[t_idx]
+        i = bus_dict[elm.bus]
+        data.bus_idx[k] = i
+        data.names[k] = elm.name
+        data.idtag[k] = elm.idtag
 
-        if elm.use_reactive_power_curve:
-            data.qmin[k] = elm.q_curve.get_qmin(data.p[i])
-            data.qmax[k] = elm.q_curve.get_qmax(data.p[i])
-        else:
-            data.qmin[k] = elm.Qmin_prof[t_idx]
-            data.qmax[k] = elm.Qmax_prof[t_idx]
+        data.mttf[k] = elm.mttf
+        data.mttr[k] = elm.mttr
 
-        data.cost_0[k] = elm.Cost0_prof[t_idx]
-        data.cost_1[k] = elm.Cost_prof[t_idx]
-        data.cost_2[k] = elm.Cost2_prof[t_idx]
+        data.controllable[k] = elm.is_controlled
+        data.installed_p[k] = elm.Snom
 
-        if elm.active_prof[t_idx]:
+        # r0, r1, r2, x0, x1, x2
+        data.r0[k] = elm.R0
+        data.r1[k] = elm.R1
+        data.r2[k] = elm.R2
+        data.x0[k] = elm.X0
+        data.x1[k] = elm.X1
+        data.x2[k] = elm.X2
 
-            if elm.srap_enabled_prof[t_idx] and data.p[k] > 0.0:
-                bus_data.srap_availbale_power[i] += data.p[k]
+        data.availability[k] = 1.0
+        data.ramp_up[k] = elm.RampUp
+        data.ramp_down[k] = elm.RampDown
+        data.min_time_up[k] = elm.MinTimeUp
+        data.min_time_down[k] = elm.MinTimeDown
 
-            if elm.is_controlled:
-                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.dispatchable[k] = elm.enabled_dispatch
+        data.pmax[k] = elm.Pmax
+        data.pmin[k] = elm.Pmin
 
-                data.controllable_bus_idx[k] = j
+        if time_series:
 
-                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)
+            if opf_results is not None:
+                data.p[k] = opf_results.generator_power[t_idx, k] - opf_results.generator_shedding[t_idx, k]
+            else:
+                data.p[k] = elm.P_prof[t_idx]
 
-    else:
+            data.active[k] = elm.active_prof[t_idx]
+            data.pf[k] = elm.Pf_prof[t_idx]
+            data.v[k] = elm.Vset_prof[t_idx]
 
-        data.p[k] = elm.P
-        data.active[k] = elm.active
-        data.pf[k] = elm.Pf
-        data.v[k] = elm.Vset
-        data.pmax[k] = elm.Pmax
-        data.pmin[k] = elm.Pmin
+            data.cost_0[k] = elm.Cost0_prof[t_idx]
+            data.cost_1[k] = elm.Cost_prof[t_idx]
+            data.cost_2[k] = elm.Cost2_prof[t_idx]
 
-        # reactive power limits, for the given power value
-        if elm.use_reactive_power_curve:
-            data.qmin[k] = elm.q_curve.get_qmin(data.p[i])
-            data.qmax[k] = elm.q_curve.get_qmax(data.p[i])
-        else:
-            data.qmin[k] = elm.Qmin
-            data.qmax[k] = elm.Qmax
+            if elm.active_prof[t_idx]:
 
-        data.cost_0[k] = elm.Cost0
-        data.cost_1[k] = elm.Cost
-        data.cost_2[k] = elm.Cost2
+                if elm.srap_enabled_prof[t_idx] and data.p[k] > 0.0:
+                    bus_data.srap_availbale_power[i] += data.p[k]
 
-        if elm.active:
+                if elm.is_controlled:
+                    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.srap_enabled and data.p[k] > 0.0:
-                bus_data.srap_availbale_power[i] += data.p[k]
+                    data.controllable_bus_idx[k] = j
 
-            if elm.is_controlled:
-                if elm.control_bus is not None:
-                    remote_control = True
-                    j = bus_dict[elm.control_bus]
-                else:
-                    remote_control = False
-                    j = -1
+                    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)
 
-                data.controllable_bus_idx[k] = j
+        else:
+            if opf_results is not None:
+                data.p[k] = opf_results.generator_power[k] - opf_results.generator_shedding[k]
+            else:
+                data.p[k] = elm.P
 
-                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)
+            data.active[k] = elm.active
+            data.pf[k] = elm.Pf
+            data.v[k] = elm.Vset
 
-    # reactive power-sharing data
-    if data.active[k]:
-        if data.controllable[k]:
-            bus_data.q_shared_total[i] += data.p[k]
-            data.q_share[k] = data.p[k]
-        else:
-            bus_data.q_fixed[i] += data.get_q_at(k)
+            data.cost_0[k] = elm.Cost0
+            data.cost_1[k] = elm.Cost
+            data.cost_2[k] = elm.Cost2
 
+            if elm.active:
 
-def get_generator_data(
-        data: GeneratorData,
-        circuit: MultiCircuit,
-        bus_dict,
-        bus_voltage_used: BoolVec,
-        logger: Logger,
-        bus_data: BusData,
-        opf_results: VALID_OPF_RESULTS | None = None,
-        t_idx=-1,
-        time_series=False,
-        use_stored_guess=False,
-        control_remote_voltage: bool = True,
-) -> Dict[str, int]:
-    """
+                if elm.srap_enabled and data.p[k] > 0.0:
+                    bus_data.srap_availbale_power[i] += data.p[k]
 
-    :param data:
-    :param circuit:
-    :param bus_dict:
-    :param bus_voltage_used:
-    :param logger:
-    :param bus_data:
-    :param opf_results:
-    :param t_idx:
-    :param time_series:
-    :param use_stored_guess:
-    :param control_remote_voltage:
-    :return:
-    """
+                if elm.is_controlled:
+                    if elm.control_bus is not None:
+                        remote_control = True
+                        j = bus_dict[elm.control_bus]
+                    else:
+                        remote_control = False
+                        j = -1
 
-    gen_index_dict: Dict[str, int] = dict()
-    for k, elm in enumerate(circuit.get_generators()):
+                    data.controllable_bus_idx[k] = j
 
-        gen_index_dict[elm.idtag] = k  # associate the idtag to the index
+                    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)
 
-        fill_generator_parent(k=k,
-                              elm=elm,
-                              data=data,
-                              bus_data=bus_data,
-                              bus_dict=bus_dict,
-                              bus_voltage_used=bus_voltage_used,
-                              logger=logger,
-                              t_idx=t_idx,
-                              time_series=time_series,
-                              use_stored_guess=use_stored_guess,
-                              control_remote_voltage=control_remote_voltage)
+        # reactive power limits, for the given power value
+        if elm.use_reactive_power_curve:
+            data.qmin[k] = elm.q_curve.get_qmin(data.p[i])
+            data.qmax[k] = elm.q_curve.get_qmax(data.p[i])
+        else:
+            data.qmin[k] = elm.Qmin
+            data.qmax[k] = elm.Qmax
 
-        if opf_results is not None:
-            # overwrite P with the OPF results
-            if time_series:
-                data.p[k] = opf_results.generator_power[t_idx, k] - opf_results.generator_shedding[t_idx, k]
+        # reactive power sharing data
+        if data.active[k]:
+            if data.controllable[k]:
+                bus_data.q_shared_total[i] += data.p[k]
+                data.q_share[k] = data.p[k]
             else:
-                data.p[k] = opf_results.generator_power[k] - opf_results.generator_shedding[k]
+                bus_data.q_fixed[i] += data.get_q_at(k)
+
+        data.C_bus_elm[i, k] = 1
 
     return gen_index_dict
 
@@ -803,19 +636,37 @@ def get_battery_data(
 
     for k, elm in enumerate(circuit.get_batteries()):
 
-        fill_generator_parent(k=k,
-                              elm=elm,
-                              data=data,
-                              bus_data=bus_data,
-                              bus_dict=bus_dict,
-                              bus_voltage_used=bus_voltage_used,
-                              logger=logger,
-                              t_idx=t_idx,
-                              time_series=time_series,
-                              use_stored_guess=use_stored_guess,
-                              control_remote_voltage=control_remote_voltage)
+        i = bus_dict[elm.bus]
+        data.bus_idx[k] = i
 
+        data.names[k] = elm.name
+        data.idtag[k] = elm.idtag
+
+        data.mttf[k] = elm.mttf
+        data.mttr[k] = elm.mttr
+
+        data.controllable[k] = elm.is_controlled
+        data.installed_p[k] = elm.Snom
+
+        # r0, r1, r2, x0, x1, x2
+        data.r0[k] = elm.R0
+        data.r1[k] = elm.R1
+        data.r2[k] = elm.R2
+        data.x0[k] = elm.X0
+        data.x1[k] = elm.X1
+        data.x2[k] = elm.X2
+
+        data.dispatchable[k] = elm.enabled_dispatch
+        data.pmax[k] = elm.Pmax
+        data.pmin[k] = elm.Pmin
         data.enom[k] = elm.Enom
+
+        data.availability[k] = 1.0
+        data.ramp_up[k] = elm.RampUp
+        data.ramp_down[k] = elm.RampDown
+        data.min_time_up[k] = elm.MinTimeUp
+        data.min_time_down[k] = elm.MinTimeDown
+
         data.min_soc[k] = elm.min_soc
         data.max_soc[k] = elm.max_soc
         data.soc_0[k] = elm.soc_0
@@ -824,28 +675,125 @@ def get_battery_data(
         data.discharge_efficiency[k] = elm.discharge_efficiency
         data.charge_efficiency[k] = elm.charge_efficiency
 
-        if opf_results is not None:
-            # overwrite P with the OPF results
-            if time_series:
+        if time_series:
+            if opf_results is not None:
                 data.p[k] = opf_results.battery_power[t_idx, k]
             else:
+                data.p[k] = elm.P_prof[t_idx]
+
+            data.active[k] = elm.active_prof[t_idx]
+            data.pf[k] = elm.Pf_prof[t_idx]
+            data.v[k] = elm.Vset_prof[t_idx]
+
+            data.cost_0[k] = elm.Cost0_prof[t_idx]
+            data.cost_1[k] = elm.Cost_prof[t_idx]
+            data.cost_2[k] = elm.Cost2_prof[t_idx]
+
+            if elm.active_prof[t_idx]:
+
+                if elm.srap_enabled_prof[t_idx] and data.p[k] > 0.0:
+                    bus_data.srap_availbale_power[i] += data.p[k]
+
+                if elm.is_controlled:
+
+                    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[k] = 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)
+
+        else:
+            if opf_results is not None:
                 data.p[k] = opf_results.battery_power[k]
+            else:
+                data.p[k] = elm.P
+
+            data.active[k] = elm.active
+            data.pf[k] = elm.Pf
+            data.v[k] = elm.Vset
+
+            data.cost_0[k] = elm.Cost0
+            data.cost_1[k] = elm.Cost
+            data.cost_2[k] = elm.Cost2
+
+            if elm.active:
+
+                if elm.srap_enabled and data.p[k] > 0.0:
+                    bus_data.srap_availbale_power[i] += data.p[k]
+
+                if elm.is_controlled:
+
+                    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[k] = 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)
+
+        # reactive power limits, for the given power value
+        if elm.use_reactive_power_curve:
+            data.qmin[k] = elm.q_curve.get_qmin(data.p[i])
+            data.qmax[k] = elm.q_curve.get_qmax(data.p[i])
+        else:
+            data.qmin[k] = elm.Qmin
+            data.qmax[k] = elm.Qmax
+
+        # reactive power sharing data
+        if data.active[k]:
+            if data.controllable[k]:
+                bus_data.q_shared_total[i] += data.p[k]
+                data.q_share[k] = data.p[k]
+            else:
+                bus_data.q_fixed[i] += data.get_q_at(k)
+
+        data.C_bus_elm[i, k] = 1
 
 
 def fill_parent_branch(i: int,
                        elm: BRANCH_TYPES,
                        data: PassiveBranchData,
                        bus_dict: Dict[Bus, int],
+                       apply_temperature: bool,
+                       branch_tolerance_mode: BranchImpedanceMode,
                        t_idx: int = -1,
-                       time_series: bool = False, ):
+                       time_series: bool = False,
+                       is_dc_branch: bool = False, ):
     """
 
     :param i:
     :param elm:
     :param data:
     :param bus_dict:
+    :param apply_temperature:
+    :param branch_tolerance_mode:
     :param t_idx:
     :param time_series:
+    :param is_dc_branch:
     :return:
     """
     data.names[i] = elm.name
@@ -872,11 +820,35 @@ def fill_parent_branch(i: int,
 
     f = bus_dict[elm.bus_from]
     t = bus_dict[elm.bus_to]
+    data.C_branch_bus_f[i, f] = 1
+    data.C_branch_bus_t[i, t] = 1
     data.F[i] = f
     data.T[i] = t
 
-    data.original_idx[i] = i
-    data.reducible[i] = int(elm.reducible)
+    data.branch_idx[i] = i  # Correct?
+
+    if apply_temperature:
+        data.R[i] = elm.R_corrected
+    else:
+        data.R[i] = elm.R
+
+    if branch_tolerance_mode == BranchImpedanceMode.Lower:
+        data.R[i] *= (1 - elm.tolerance / 100.0)
+    elif branch_tolerance_mode == BranchImpedanceMode.Upper:
+        data.R[i] *= (1 + elm.tolerance / 100.0)
+
+    if not is_dc_branch:
+        data.X[i] = elm.X
+        data.B[i] = elm.B
+
+        data.R0[i] = elm.R0
+        data.X0[i] = elm.X0
+        data.B0[i] = elm.B0
+
+        data.R2[i] = elm.R2
+        data.X2[i] = elm.X2
+        data.B2[i] = elm.B2
+
     data.contingency_enabled[i] = int(elm.contingency_enabled)
     data.monitor_loading[i] = int(elm.monitor_loading)
 
@@ -892,6 +864,8 @@ def fill_controllable_branch(
         ctrl_data: ActiveBranchData,
         bus_data: BusData,
         bus_dict: Dict[Bus, int],
+        apply_temperature: bool,
+        branch_tolerance_mode: BranchImpedanceMode,
         t_idx: int,
         time_series: bool,
         opf_results: VALID_OPF_RESULTS | None,
@@ -900,6 +874,7 @@ def fill_controllable_branch(
         Sbase: float,
         control_taps_modules: bool,
         control_taps_phase: bool,
+        control_remote_voltage: bool,
         logger: Logger):
     """
 
@@ -909,6 +884,8 @@ def fill_controllable_branch(
     :param ctrl_data:
     :param bus_data:
     :param bus_dict:
+    :param apply_temperature:
+    :param branch_tolerance_mode:
     :param t_idx:
     :param time_series:
     :param opf_results:
@@ -917,15 +894,19 @@ def fill_controllable_branch(
     :param Sbase:
     :param control_taps_modules:
     :param control_taps_phase:
+    :param control_remote_voltage:
     :param logger:
     :return:
     """
-    fill_parent_branch(i=ii,
-                       elm=elm,
-                       data=data,
-                       bus_dict=bus_dict,
-                       t_idx=t_idx,
-                       time_series=time_series)
+    _, t = fill_parent_branch(i=ii,
+                              elm=elm,
+                              data=data,
+                              bus_dict=bus_dict,
+                              apply_temperature=apply_temperature,
+                              branch_tolerance_mode=branch_tolerance_mode,
+                              t_idx=t_idx,
+                              time_series=time_series,
+                              is_dc_branch=False)
 
     if time_series:
 
@@ -990,18 +971,9 @@ def fill_controllable_branch(
     ctrl_data.tap_angle_min[ii] = elm.tap_phase_min
     ctrl_data.tap_angle_max[ii] = elm.tap_phase_max
 
-    # if (ctrl_data.tap_module_control_mode[ii] not in (TapModuleControl.fixed, 0)
-    #         or ctrl_data.tap_phase_control_mode[ii] not in (TapPhaseControl.fixed, 0)):
-    #     ctrl_data.any_pf_control = True
-
-    if ctrl_data.tap_module_control_mode[ii] != 0:
-        if ctrl_data.tap_module_control_mode[ii] != TapModuleControl.fixed:
-            ctrl_data.any_pf_control = True
-
-    if not ctrl_data.any_pf_control:  # if true, we can skip this step
-        if ctrl_data.tap_phase_control_mode[ii] != 0:
-            if ctrl_data.tap_phase_control_mode[ii] != TapPhaseControl.fixed:
-                ctrl_data.any_pf_control = True
+    if (ctrl_data.tap_module_control_mode[ii] not in (TapModuleControl.fixed, 0)
+            or ctrl_data.tap_phase_control_mode[ii] not in (TapPhaseControl.fixed, 0)):
+        ctrl_data.any_pf_control = True
 
     if not use_stored_guess:
         if ctrl_data.tap_module_control_mode[ii] == TapModuleControl.Vm:
@@ -1068,37 +1040,19 @@ def get_branch_data(
     # Compile the lines
     for i, elm in enumerate(circuit.lines):
         # generic stuff
-        fill_parent_branch(i=ii,
+        fill_parent_branch(i=i,
                            elm=elm,
                            data=data,
                            bus_dict=bus_dict,
+                           apply_temperature=apply_temperature,
+                           branch_tolerance_mode=branch_tolerance_mode,
                            t_idx=t_idx,
-                           time_series=time_series)
-
-        data.R[ii] = elm.R_corrected if apply_temperature else elm.R
-
-        if branch_tolerance_mode == BranchImpedanceMode.Lower:
-            data.R[ii] *= (1 - elm.tolerance / 100.0)
-        elif branch_tolerance_mode == BranchImpedanceMode.Upper:
-            data.R[ii] *= (1 + elm.tolerance / 100.0)
-
-        data.X[ii] = elm.X
-        data.B[ii] = elm.B
-
-        data.R0[ii] = elm.R0
-        data.X0[ii] = elm.X0
-        data.B0[ii] = elm.B0
-
-        data.R2[ii] = elm.R2
-        data.X2[ii] = elm.X2
-        data.B2[ii] = elm.B2
+                           time_series=time_series,
+                           is_dc_branch=False)
 
         # store for later
         branch_dict[elm] = ii
 
-        # handle """superconductor branches"""
-        data.detect_superconductor_at(ii)
-
         ii += 1
 
     # DC-lines
@@ -1108,24 +1062,15 @@ def get_branch_data(
                            elm=elm,
                            data=data,
                            bus_dict=bus_dict,
+                           apply_temperature=apply_temperature,
+                           branch_tolerance_mode=branch_tolerance_mode,
                            t_idx=t_idx,
-                           time_series=time_series)
-
-        data.R[ii] = elm.R_corrected if apply_temperature else elm.R
-
-        if branch_tolerance_mode == BranchImpedanceMode.Lower:
-            data.R[ii] *= (1 - elm.tolerance / 100.0)
-        elif branch_tolerance_mode == BranchImpedanceMode.Upper:
-            data.R[ii] *= (1 + elm.tolerance / 100.0)
+                           time_series=time_series,
+                           is_dc_branch=True)
 
         # store for later
         branch_dict[elm] = ii
 
-        data.dc[ii] = 1
-
-        # handle """superconductor branches"""
-        data.detect_superconductor_at(ii)
-
         ii += 1
 
     # 2-winding transformers
@@ -1136,6 +1081,8 @@ def get_branch_data(
                                  ctrl_data=ctrl_data,
                                  bus_data=bus_data,
                                  bus_dict=bus_dict,
+                                 apply_temperature=apply_temperature,
+                                 branch_tolerance_mode=branch_tolerance_mode,
                                  t_idx=t_idx,
                                  time_series=time_series,
                                  opf_results=opf_results,
@@ -1144,29 +1091,9 @@ def get_branch_data(
                                  Sbase=circuit.Sbase,
                                  control_taps_modules=control_taps_modules,
                                  control_taps_phase=control_taps_phase,
+                                 control_remote_voltage=control_remote_voltage,
                                  logger=logger)
 
-        data.R[ii] = elm.R_corrected if apply_temperature else elm.R
-
-        if branch_tolerance_mode == BranchImpedanceMode.Lower:
-            data.R[ii] *= (1 - elm.tolerance / 100.0)
-        elif branch_tolerance_mode == BranchImpedanceMode.Upper:
-            data.R[ii] *= (1 + elm.tolerance / 100.0)
-
-        data.X[ii] = elm.X
-        data.G[ii] = elm.G
-        data.B[ii] = elm.B
-
-        data.R0[ii] = elm.R0
-        data.X0[ii] = elm.X0
-        data.G0[ii] = elm.G0
-        data.B0[ii] = elm.B0
-
-        data.R2[ii] = elm.R2
-        data.X2[ii] = elm.X2
-        data.G2[ii] = elm.G2
-        data.B2[ii] = elm.B2
-
         data.conn[ii] = elm.conn
         data.m_taps[ii] = elm.tap_changer.tap_modules_array
         data.tau_taps[ii] = elm.tap_changer.tap_angles_array
@@ -1174,9 +1101,6 @@ def get_branch_data(
         # store for later
         branch_dict[elm] = ii
 
-        # handle """superconductor branches"""
-        data.detect_superconductor_at(ii)
-
         ii += 1
 
     # windings
@@ -1190,6 +1114,8 @@ def get_branch_data(
                                      ctrl_data=ctrl_data,
                                      bus_data=bus_data,
                                      bus_dict=bus_dict,
+                                     apply_temperature=apply_temperature,
+                                     branch_tolerance_mode=branch_tolerance_mode,
                                      t_idx=t_idx,
                                      time_series=time_series,
                                      opf_results=opf_results,
@@ -1198,29 +1124,9 @@ def get_branch_data(
                                      Sbase=circuit.Sbase,
                                      control_taps_modules=control_taps_modules,
                                      control_taps_phase=control_taps_phase,
+                                     control_remote_voltage=control_remote_voltage,
                                      logger=logger)
 
-            data.R[ii] = elm.R_corrected if apply_temperature else elm.R
-
-            if branch_tolerance_mode == BranchImpedanceMode.Lower:
-                data.R[ii] *= (1 - elm.tolerance / 100.0)
-            elif branch_tolerance_mode == BranchImpedanceMode.Upper:
-                data.R[ii] *= (1 + elm.tolerance / 100.0)
-
-            data.X[ii] = elm.X
-            data.G[ii] = elm.G
-            data.B[ii] = elm.B
-
-            data.R0[ii] = elm.R0
-            data.X0[ii] = elm.X0
-            data.G0[ii] = elm.G0
-            data.B0[ii] = elm.B0
-
-            data.R2[ii] = elm.R2
-            data.X2[ii] = elm.X2
-            data.G2[ii] = elm.G2
-            data.B2[ii] = elm.B2
-
             data.conn[ii] = elm.conn
             data.m_taps[ii] = elm.tap_changer.tap_modules_array
             data.tau_taps[ii] = elm.tap_changer.tap_angles_array
@@ -1228,9 +1134,6 @@ def get_branch_data(
             # store for later
             branch_dict[elm] = ii
 
-            # handle """superconductor branches"""
-            data.detect_superconductor_at(ii)
-
             ii += 1
 
         else:
@@ -1245,6 +1148,8 @@ def get_branch_data(
                                  ctrl_data=ctrl_data,
                                  bus_data=bus_data,
                                  bus_dict=bus_dict,
+                                 apply_temperature=apply_temperature,
+                                 branch_tolerance_mode=branch_tolerance_mode,
                                  t_idx=t_idx,
                                  time_series=time_series,
                                  opf_results=opf_results,
@@ -1253,31 +1158,12 @@ def get_branch_data(
                                  Sbase=circuit.Sbase,
                                  control_taps_modules=control_taps_modules,
                                  control_taps_phase=control_taps_phase,
+                                 control_remote_voltage=control_remote_voltage,
                                  logger=logger)
-        ysh1 = elm.get_ysh1()
-        data.R[ii] = elm.R
-        data.X[ii] = elm.X
-        data.G[ii] = ysh1.real
-        data.B[ii] = ysh1.imag
-
-        ysh0 = elm.get_ysh0()
-        data.R0[ii] = elm.R0
-        data.X0[ii] = elm.X0
-        data.G0[ii] = ysh0.real
-        data.B0[ii] = ysh0.imag
-
-        ysh2 = elm.get_ysh2()
-        data.R2[ii] = elm.R2
-        data.X2[ii] = elm.X2
-        data.G2[ii] = ysh2.real
-        data.B2[ii] = ysh2.imag
 
         # store for later
         branch_dict[elm] = ii
 
-        # handle """superconductor branches"""
-        data.detect_superconductor_at(ii)
-
         ii += 1
 
     # Series reactance
@@ -1287,155 +1173,20 @@ def get_branch_data(
                            elm=elm,
                            data=data,
                            bus_dict=bus_dict,
+                           apply_temperature=apply_temperature,
+                           branch_tolerance_mode=branch_tolerance_mode,
                            t_idx=t_idx,
-                           time_series=time_series)
-
-        data.R[ii] = elm.R_corrected if apply_temperature else elm.R
-
-        if branch_tolerance_mode == BranchImpedanceMode.Lower:
-            data.R[ii] *= (1 - elm.tolerance / 100.0)
-        elif branch_tolerance_mode == BranchImpedanceMode.Upper:
-            data.R[ii] *= (1 + elm.tolerance / 100.0)
-
-        data.X[ii] = elm.X
-
-        data.R0[ii] = elm.R0
-        data.X0[ii] = elm.X0
-
-        data.R2[ii] = elm.R2
-        data.X2[ii] = elm.X2
+                           time_series=time_series,
+                           is_dc_branch=False)
 
         # store for later
         branch_dict[elm] = ii
 
-        # handle """superconductor branches"""
-        data.detect_superconductor_at(ii)
-
-        ii += 1
-
-    # Switches
-    for i, elm in enumerate(circuit.switch_devices):
-        # generic stuff
-        fill_parent_branch(i=ii,
-                           elm=elm,
-                           data=data,
-                           bus_dict=bus_dict,
-                           t_idx=t_idx,
-                           time_series=time_series)
-
-        data.R[ii] = elm.R
-        data.X[ii] = elm.X
-
-        # store for later
-        branch_dict[elm] = ii
-
-        # handle """superconductor branches"""
-        data.detect_superconductor_at(ii)
-
         ii += 1
 
     return branch_dict
 
 
-def set_control_dev(k: int,
-                    f: int,
-                    t: int,
-                    control: ConverterControlType,
-                    control_dev: Bus | BRANCH_TYPES | None,
-                    control_val: float,
-                    control_bus_idx: IntVec,
-                    control_branch_idx: IntVec,
-                    bus_dict: Dict[Bus, int],
-                    branch_dict: Dict[BRANCH_TYPES, int],
-                    bus_data: BusData,
-                    bus_voltage_used: BoolVec,
-                    use_stored_guess: bool,
-                    logger: Logger):
-    """
-
-    :param k: device index
-    :param f:
-    :param t:
-    :param control: ConverterControlType
-    :param control_dev: control device
-    :param control_val: control value
-    :param control_bus_idx: array to be filled in
-    :param control_branch_idx: array to be filled in
-    :param bus_dict: dictionary to be filled in
-    :param branch_dict: dictionary to be filled in
-    :param bus_data: bus data
-    :param bus_voltage_used: used bus voltage
-    :param use_stored_guess:
-    :param logger:
-    """
-    if control_dev is not None:
-        if control_dev.device_type == DeviceType.BusDevice:
-
-            bus_idx = bus_dict[control_dev]
-
-            control_bus_idx[k] = bus_idx
-
-            if control == ConverterControlType.Vm_ac:
-
-                set_bus_control_voltage_vsc(i=bus_idx,
-                                            j=-1,
-                                            remote_control=False,
-                                            bus_name=str(bus_data.names[bus_idx]),
-                                            bus_voltage_used=bus_voltage_used,
-                                            bus_data=bus_data,
-                                            candidate_Vm=control_val,
-                                            use_stored_guess=use_stored_guess,
-                                            logger=logger)
-
-            elif control == ConverterControlType.Vm_dc:
-
-                set_bus_control_voltage_vsc(i=bus_idx,
-                                            j=-1,
-                                            remote_control=False,
-                                            bus_name=str(bus_data.names[bus_idx]),
-                                            bus_voltage_used=bus_voltage_used,
-                                            bus_data=bus_data,
-                                            candidate_Vm=control_val,
-                                            use_stored_guess=use_stored_guess,
-                                            logger=logger)
-
-        else:
-            # TODO: the formulation does not allow for VSC remote control yet
-            # control_branch_idx[k] = branch_dict[control_dev]
-            control_branch_idx[k] = k
-
-    else:
-        if control == ConverterControlType.Vm_ac:
-            control_bus_idx[k] = t
-
-            set_bus_control_voltage_vsc(i=t,
-                                        j=-1,
-                                        remote_control=False,
-                                        bus_name=str(bus_data.names[t]),
-                                        bus_voltage_used=bus_voltage_used,
-                                        bus_data=bus_data,
-                                        candidate_Vm=control_val,
-                                        use_stored_guess=use_stored_guess,
-                                        logger=logger)
-
-        elif control == ConverterControlType.Vm_dc:
-            control_bus_idx[k] = f
-
-            set_bus_control_voltage_vsc(i=f,
-                                        j=-1,
-                                        remote_control=False,
-                                        bus_name=str(bus_data.names[f]),
-                                        bus_voltage_used=bus_voltage_used,
-                                        bus_data=bus_data,
-                                        candidate_Vm=control_val,
-                                        use_stored_guess=use_stored_guess,
-                                        logger=logger)
-
-        else:
-            # control_branch_idx[k] = len(branch_dict) + k  # TODO: why?
-            control_branch_idx[k] = k
-
-
 def get_vsc_data(
         data: VscData,
         circuit: MultiCircuit,
@@ -1467,6 +1218,42 @@ def get_vsc_data(
     :return: VscData
     """
 
+    def set_control_dev(k: int,
+                        control: ConverterControlType,
+                        control_dev: Bus | BRANCH_TYPES | None,
+                        control_val: float,
+                        control_bus_idx: IntVec,
+                        control_branch_idx: IntVec):
+        """
+
+        :param k: device index
+        :param control: ConverterControlType
+        :param control_dev: control device
+        :param control_val: control value
+        :param control_bus_idx: array to be filled in
+        :param control_branch_idx: array to be filled in
+        """
+        if control_dev is not None:
+            if control_dev.device_type == DeviceType.BusDevice:
+
+                bus_idx = bus_dict[control_dev]
+
+                control_bus_idx[k] = bus_idx
+
+                if control in (ConverterControlType.Vm_ac, ConverterControlType.Vm_dc):
+                    set_bus_control_voltage(i=bus_idx,
+                                            j=-1,
+                                            remote_control=False,
+                                            bus_name=bus_data.names[bus_idx],
+                                            bus_voltage_used=bus_voltage_used,
+                                            bus_data=bus_data,
+                                            candidate_Vm=control_val,
+                                            use_stored_guess=use_stored_guess,
+                                            logger=logger)
+
+            else:
+                control_branch_idx[k] = branch_dict[control_dev]
+
     ii = 0
 
     # VSC
@@ -1477,10 +1264,6 @@ def get_vsc_data(
 
         data.mttf[i] = elm.mttf
         data.mttr[i] = elm.mttr
-        f = bus_dict[elm.bus_from]
-        t = bus_dict[elm.bus_to]
-        data.F[i] = f
-        data.T[i] = t
 
         if time_series:
             data.active[i] = elm.active_prof[t_idx]
@@ -1494,30 +1277,10 @@ def get_vsc_data(
             data.control2[ii] = elm.control2_prof[t_idx]
             data.control1_val[ii] = elm.control1_val_prof[t_idx]
             data.control2_val[ii] = elm.control2_val_prof[t_idx]
-            set_control_dev(k=ii, f=f, t=t,
-                            control=data.control1[ii],
-                            control_dev=elm.control1_dev_prof[t_idx],
-                            control_val=data.control1_val[ii],
-                            control_bus_idx=data.control1_bus_idx,
-                            control_branch_idx=data.control1_branch_idx,
-                            bus_dict=bus_dict,
-                            branch_dict=branch_dict,
-                            bus_data=bus_data,
-                            bus_voltage_used=bus_voltage_used,
-                            use_stored_guess=use_stored_guess,
-                            logger=logger)
-            set_control_dev(k=ii, f=f, t=t,
-                            control=data.control2[ii],
-                            control_dev=elm.control2_dev_prof[t_idx],
-                            control_val=data.control2_val[ii],
-                            control_bus_idx=data.control2_bus_idx,
-                            control_branch_idx=data.control2_branch_idx,
-                            bus_dict=bus_dict,
-                            branch_dict=branch_dict,
-                            bus_data=bus_data,
-                            bus_voltage_used=bus_voltage_used,
-                            use_stored_guess=use_stored_guess,
-                            logger=logger)
+            set_control_dev(ii, data.control1[ii], elm.control1_dev_prof[t_idx], data.control1_val[ii],
+                            data.control1_bus_idx, data.control1_branch_idx)
+            set_control_dev(ii, data.control2[ii], elm.control2_dev_prof[t_idx], data.control2_val[ii],
+                            data.control2_bus_idx, data.control2_branch_idx)
 
         else:
             data.active[i] = elm.active
@@ -1531,31 +1294,17 @@ def get_vsc_data(
             data.control2[ii] = elm.control2
             data.control1_val[ii] = elm.control1_val
             data.control2_val[ii] = elm.control2_val
-            set_control_dev(k=ii, f=f, t=t,
-                            control=data.control1[ii],
-                            control_dev=elm.control1_dev,
-                            control_val=data.control1_val[ii],
-                            control_bus_idx=data.control1_bus_idx,
-                            control_branch_idx=data.control1_branch_idx,
-                            bus_dict=bus_dict,
-                            branch_dict=branch_dict,
-                            bus_data=bus_data,
-                            bus_voltage_used=bus_voltage_used,
-                            use_stored_guess=use_stored_guess,
-                            logger=logger)
-
-            set_control_dev(k=ii, f=f, t=t,
-                            control=data.control2[ii],
-                            control_dev=elm.control2_dev,
-                            control_val=data.control2_val[ii],
-                            control_bus_idx=data.control2_bus_idx,
-                            control_branch_idx=data.control2_branch_idx,
-                            bus_dict=bus_dict,
-                            branch_dict=branch_dict,
-                            bus_data=bus_data,
-                            bus_voltage_used=bus_voltage_used,
-                            use_stored_guess=use_stored_guess,
-                            logger=logger)
+            set_control_dev(ii, data.control1[ii], elm.control1_dev, data.control1_val[ii],
+                            data.control1_bus_idx, data.control1_branch_idx)
+            set_control_dev(ii, data.control2[ii], elm.control2_dev, data.control2_val[ii],
+                            data.control2_bus_idx, data.control2_branch_idx)
+
+        f = bus_dict[elm.bus_from]
+        t = bus_dict[elm.bus_to]
+        data.C_branch_bus_f[i, f] = 1
+        data.C_branch_bus_t[i, t] = 1
+        data.F[i] = f
+        data.T[i] = t
 
         data.contingency_enabled[i] = int(elm.contingency_enabled)
         data.monitor_loading[i] = int(elm.monitor_loading)
@@ -1612,8 +1361,8 @@ def get_hvdc_data(data: HvdcData,
 
         if time_series:
             data.active[i] = elm.active_prof[t_idx]
-            data.rates[i] = elm.rate_prof[t_idx]
-            data.contingency_rates[i] = elm.rate_prof[t_idx] * elm.contingency_factor_prof[t_idx]
+            data.rate[i] = elm.rate_prof[t_idx]
+            data.contingency_rate[i] = elm.rate_prof[t_idx] * elm.contingency_factor_prof[t_idx]
             data.protection_rates[i] = elm.rate_prof[t_idx] * elm.protection_rating_factor_prof[t_idx]
             data.angle_droop[i] = elm.angle_droop_prof[t_idx]
 
@@ -1630,30 +1379,30 @@ def get_hvdc_data(data: HvdcData,
 
             # hack the bus types to believe they are PV
             if elm.active_prof[t_idx]:
-                set_bus_control_voltage_hvdc(i=f,
-                                             j=-1,
-                                             remote_control=False,
-                                             bus_name=elm.bus_from.name,
-                                             bus_data=bus_data,
-                                             bus_voltage_used=bus_voltage_used,
-                                             candidate_Vm=elm.Vset_f_prof[t_idx],
-                                             use_stored_guess=use_stored_guess,
-                                             logger=logger)
-
-                set_bus_control_voltage_hvdc(i=t,
-                                             j=-1,
-                                             remote_control=False,
-                                             bus_name=elm.bus_to.name,
-                                             bus_data=bus_data,
-                                             bus_voltage_used=bus_voltage_used,
-                                             candidate_Vm=elm.Vset_t_prof[t_idx],
-                                             use_stored_guess=use_stored_guess,
-                                             logger=logger)
+                set_bus_control_voltage(i=f,
+                                        j=-1,
+                                        remote_control=False,
+                                        bus_name=elm.bus_from.name,
+                                        bus_data=bus_data,
+                                        bus_voltage_used=bus_voltage_used,
+                                        candidate_Vm=elm.Vset_f_prof[t_idx],
+                                        use_stored_guess=use_stored_guess,
+                                        logger=logger)
+
+                set_bus_control_voltage(i=t,
+                                        j=-1,
+                                        remote_control=False,
+                                        bus_name=elm.bus_to.name,
+                                        bus_data=bus_data,
+                                        bus_voltage_used=bus_voltage_used,
+                                        candidate_Vm=elm.Vset_t_prof[t_idx],
+                                        use_stored_guess=use_stored_guess,
+                                        logger=logger)
 
         else:
             data.active[i] = elm.active
-            data.rates[i] = elm.rate
-            data.contingency_rates[i] = elm.rate * elm.contingency_factor
+            data.rate[i] = elm.rate
+            data.contingency_rate[i] = elm.rate * elm.contingency_factor
             data.protection_rates[i] = elm.rate * elm.protection_rating_factor
             data.angle_droop[i] = elm.angle_droop
             data.r[i] = elm.r
@@ -1671,25 +1420,25 @@ def get_hvdc_data(data: HvdcData,
 
             # hack the bus types to believe they are PV
             if elm.active:
-                set_bus_control_voltage_hvdc(i=f,
-                                             j=-1,
-                                             remote_control=False,
-                                             bus_name=elm.bus_from.name,
-                                             bus_data=bus_data,
-                                             bus_voltage_used=bus_voltage_used,
-                                             candidate_Vm=elm.Vset_f,
-                                             use_stored_guess=use_stored_guess,
-                                             logger=logger)
-
-                set_bus_control_voltage_hvdc(i=t,
-                                             j=-1,
-                                             remote_control=False,
-                                             bus_name=elm.bus_to.name,
-                                             bus_data=bus_data,
-                                             bus_voltage_used=bus_voltage_used,
-                                             candidate_Vm=elm.Vset_t,
-                                             use_stored_guess=use_stored_guess,
-                                             logger=logger)
+                set_bus_control_voltage(i=f,
+                                        j=-1,
+                                        remote_control=False,
+                                        bus_name=elm.bus_from.name,
+                                        bus_data=bus_data,
+                                        bus_voltage_used=bus_voltage_used,
+                                        candidate_Vm=elm.Vset_f,
+                                        use_stored_guess=use_stored_guess,
+                                        logger=logger)
+
+                set_bus_control_voltage(i=t,
+                                        j=-1,
+                                        remote_control=False,
+                                        bus_name=elm.bus_to.name,
+                                        bus_data=bus_data,
+                                        bus_voltage_used=bus_voltage_used,
+                                        candidate_Vm=elm.Vset_t,
+                                        use_stored_guess=use_stored_guess,
+                                        logger=logger)
 
         data.Vnf[i] = elm.bus_from.Vnom
         data.Vnt[i] = elm.bus_to.Vnom
@@ -1699,6 +1448,10 @@ def get_hvdc_data(data: HvdcData,
         data.Qmin_t[i] = elm.Qmin_t
         data.Qmax_t[i] = elm.Qmax_t
 
+        # the bus-hvdc line connectivity
+        data.C_hvdc_bus_f[i, f] = 1
+        data.C_hvdc_bus_t[i, t] = 1
+
 
 def get_fluid_node_data(data: FluidNodeData,
                         circuit: MultiCircuit,
@@ -1878,6 +1631,10 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
     :return: NumericalCircuit instance
     """
 
+    if circuit.get_connectivity_nodes_number() + circuit.get_switches_number():
+        # process topology, this
+        circuit.process_topology_at(t_idx=t_idx, logger=logger)
+
     # if any valid time index is specified, then the data is compiled from the time series
     time_series = t_idx is not None
 
@@ -1888,7 +1645,7 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
         nbus=circuit.get_bus_number(),
         nbr=circuit.get_branch_number(add_vsc=False,
                                       add_hvdc=False,
-                                      add_switch=True),
+                                      add_switch=False),
         nhvdc=circuit.get_hvdc_number(),
         nvsc=circuit.get_vsc_number(),
         nload=circuit.get_load_like_device_number(),