GridCalEngine 5.2.1__tar.gz → 5.2.2__tar.gz

{GridCalEngine-5.2.1 → GridCalEngine-5.2.2}/GridCalEngine/DataStructures/hvdc_data.py

@@ -299,7 +299,7 @@ class HvdcData:
                 else:
                     Losses[i] = 0
                     Pf[i] = 0
-                    Pt[0] = 0
+                    Pt[i] = 0
 
                 # compute loading
                 loading[i] = Pf[i] / (self.rate[i] + 1e-20)

{GridCalEngine-5.2.1 → GridCalEngine-5.2.2}/GridCalEngine/Devices/Branches/hvdc_line.py

@@ -210,8 +210,6 @@ class HvdcLine(BranchParent):
 
         self.dc_link_voltage = float(dc_link_voltage)
 
-        # self.n_lines = int(n_lines)
-
         self.angle_droop = float(angle_droop)
 
         self.loss_factor = float(loss_factor)
@@ -245,11 +243,11 @@ class HvdcLine(BranchParent):
 
         self.control_mode: HvdcControlType = control_mode
 
-        self._Pset_prof: Vec = Profile(default_value=Pset, data_type=float)
-        self._active_prof: IntVec = Profile(default_value=active, data_type=bool)
-        self._Vset_f_prof: Vec = Profile(default_value=Vset_f, data_type=float)
-        self._Vset_t_prof: Vec = Profile(default_value=Vset_t, data_type=float)
-        self._angle_droop_prof: Vec = Profile(default_value=angle_droop, data_type=float)
+        self._Pset_prof: Profile = Profile(default_value=Pset, data_type=float)
+        self._active_prof: Profile = Profile(default_value=active, data_type=bool)
+        self._Vset_f_prof: Profile = Profile(default_value=Vset_f, data_type=float)
+        self._Vset_t_prof: Profile = Profile(default_value=Vset_t, data_type=float)
+        self._angle_droop_prof: Profile = Profile(default_value=angle_droop, data_type=float)
 
         # Line locations
         self._locations: LineLocations = LineLocations()

{GridCalEngine-5.2.1 → GridCalEngine-5.2.2}/GridCalEngine/Devices/Branches/line.py

@@ -103,17 +103,17 @@ class Line(BranchParent):
         self.fault_pos = float(fault_pos)
 
         # total impedance and admittance in p.u.
-        self.R = float(r)
-        self.X = float(x)
-        self.B = float(b)
+        self._R = float(r)
+        self._X = float(x)
+        self._B = float(b)
 
-        self.R0 = float(r0)
-        self.X0 = float(x0)
-        self.B0 = float(b0)
+        self._R0 = float(r0)
+        self._X0 = float(x0)
+        self._B0 = float(b0)
 
-        self.R2 = float(r2)
-        self.X2 = float(x2)
-        self.B2 = float(b2)
+        self._R2 = float(r2)
+        self._X2 = float(x2)
+        self._B2 = float(b2)
 
         # Conductor base and operating temperatures in ºC
         self.temp_base = float(temp_base)
@@ -146,7 +146,6 @@ class Line(BranchParent):
         self.register(key='tolerance', units='%', tpe=float,
                       definition='Tolerance expected for the impedance values % is expected '
                                  'for transformers0% for lines.')
-
         self.register(key='length', units='km', tpe=float, definition='Length of the line (not used for calculation)')
         self.register(key='temp_base', units='ºC', tpe=float, definition='Base temperature at which R was measured.')
         self.register(key='temp_oper', units='ºC', tpe=float, definition='Operation temperature to modify R.',
@@ -179,6 +178,78 @@ class Line(BranchParent):
                       definition='Possible sequence line types (>1 to denote association), - to denote no association',
                       display=False)
 
+    @property
+    def R(self):
+        return self._R
+
+    @R.setter
+    def R(self, value):
+        self._R = float(value)
+
+    @property
+    def X(self):
+        return self._X
+
+    @X.setter
+    def X(self, value):
+        self._X = float(value)
+
+    @property
+    def B(self):
+        return self._B
+
+    @B.setter
+    def B(self, value):
+        self._B = float(value)
+
+    @property
+    def R0(self):
+        return self._R0
+
+    @R0.setter
+    def R0(self, value):
+        self._R0 = float(value)
+
+    @property
+    def X0(self):
+        return self._X0
+
+    @X0.setter
+    def X0(self, value):
+        self._X0 = float(value)
+
+    @property
+    def B0(self):
+        return self._B0
+
+    @B0.setter
+    def B0(self, value):
+        self._B0 = float(value)
+
+    @property
+    def R2(self):
+        return self._R2
+
+    @R2.setter
+    def R2(self, value):
+        self._R2 = float(value)
+
+    @property
+    def X2(self):
+        return self._X2
+
+    @X2.setter
+    def X2(self, value):
+        self._X2 = float(value)
+
+    @property
+    def B2(self):
+        return self._B2
+
+    @B2.setter
+    def B2(self, value):
+        self._B2 = float(value)
+
     @property
     def length(self) -> float:
         """
@@ -194,18 +265,17 @@ class Line(BranchParent):
         :param val:
         :return:
         """
-        self.set_length(val, update_electrical_values=True)
+        self.set_length(val)
 
-    def set_length(self, val: float, update_electrical_values: bool = True):
+    def set_length(self, val: float):
         """
 
         :param val:
-        :param update_electrical_values:
         :return:
         """
         if isinstance(val, float):
             if val > 0.0:
-                if self._length != 0 and update_electrical_values:
+                if self._length != 0 and self.auto_update_enabled:
                     factor = np.round(val / self._length, 6)  # new length / old length
 
                     self.R *= factor
@@ -218,6 +288,7 @@ class Line(BranchParent):
                     self.X2 *= factor
                     self.B2 *= factor
 
+                # set the value
                 self._length = val
             else:
                 print('The length cannot be zero, ignoring value')
@@ -408,7 +479,7 @@ class Line(BranchParent):
         elm.temperature_prof = self.temp_oper_prof
         return elm
 
-    def fill_design_properties(self, r_ohm, x_ohm, c_nf, length, Imax, freq, Sbase, apply_to_profile: bool = True,):
+    def fill_design_properties(self, r_ohm, x_ohm, c_nf, length, Imax, freq, Sbase, apply_to_profile: bool = True, ):
         """
         Fill R, X, B from not-in-per-unit parameters
         :param r_ohm: Resistance per km in OHM/km

{GridCalEngine-5.2.1 → GridCalEngine-5.2.2}/GridCalEngine/Devices/Branches/series_reactance.py

@@ -20,7 +20,7 @@ class SeriesReactance(BranchParent):
                  r=1e-20, x=1e-20, rate=1.0, active=True, tolerance=0, cost=100.0,
                  mttf=0, mttr=0, r_fault=0.0, x_fault=0.0, fault_pos=0.5,
                  temp_base=20, temp_oper=20, alpha=0.00330,
-                 template=None, contingency_factor=1.0, protection_rating_factor: float = 1.4,
+                 contingency_factor=1.0, protection_rating_factor: float = 1.4,
                  contingency_enabled=True, monitor_loading=True,
                  r0=1e-20, x0=1e-20,  r2=1e-20, x2=1e-20,
                  capex=0, opex=0, build_status: BuildStatus = BuildStatus.Commissioned):
@@ -45,7 +45,6 @@ class SeriesReactance(BranchParent):
         :param temp_base: Base temperature at which `r` is measured in °C
         :param temp_oper: Operating temperature in °C
         :param alpha: Thermal constant of the material in °C
-        :param template: Basic branch template
         :param contingency_factor: Rating factor in case of contingency
         :param protection_rating_factor: Rating factor before the protections tripping
         :param contingency_enabled: enabled for contingencies (Legacy)

{GridCalEngine-5.2.1 → GridCalEngine-5.2.2}/GridCalEngine/Devices/Branches/switch.py

@@ -13,7 +13,7 @@ from GridCalEngine.Devices.Parents.editable_device import DeviceType
 class Switch(BranchParent):
     """
     The **Switch** class represents the connections between nodes (i.e.
-    :ref:`buses<bus>`) in **GridCal**. A Switch is an devices that cuts or allows the flow.
+    :ref:`buses<bus>`) in **GridCal**. A Switch is a devices that cuts or allows the flow.
     """
 
     def __init__(self, bus_from: Bus = None, bus_to: Bus = None,
@@ -22,7 +22,6 @@ class Switch(BranchParent):
                  rate=1.0,
                  active=True,
                  contingency_factor=1.0, protection_rating_factor: float = 1.4,
-                 # is_open=False,
                  retained=True,
                  normal_open=False,
                  rated_current=0.0):
@@ -81,7 +80,7 @@ class Switch(BranchParent):
 
         self.register(key='normal_open', units="", tpe=bool,
                       definition='Normal position of the switch')
-        self.register(key='rated_current', units="KA", tpe=float,
+        self.register(key='rated_current', units="kA", tpe=float,
                       definition='Rated current of the switch device.')
 
     def copy(self, bus_dict=None):

{GridCalEngine-5.2.1 → GridCalEngine-5.2.2}/GridCalEngine/Devices/Parents/branch_parent.py

@@ -403,7 +403,7 @@ class BranchParent(PhysicalDevice):
 
     def get_virtual_taps(self) -> Tuple[float, float]:
         """
-        Always unit vitual taps (unless proven otherwise)
+        Always unit virtual taps (unless proven otherwise)
         :return: tap_f, tap_t
         """
         return 1.0, 1.0

{GridCalEngine-5.2.1 → GridCalEngine-5.2.2}/GridCalEngine/Devices/Parents/editable_device.py

@@ -228,6 +228,10 @@ class EditableDevice:
         # dictionary with property name -> profile name
         self.properties_with_profile: Dict[str, str] = dict()
 
+        # some devices have an auto update of a property when another property changes
+        # (i.e. Line's R, X, B when the length changes) this controls that behaviour and disables it during loading
+        self.__auto_update_enabled = False
+
         self.register(key='idtag', units='', tpe=str, definition='Unique ID', editable=False)
         self.register(key='name', units='', tpe=str, definition='Name of the device.')
         self.register(key='code', units='', tpe=str, definition='Secondary ID')
@@ -236,6 +240,28 @@ class EditableDevice:
                       display=False)
         self.register(key='comment', units='', tpe=str, definition='User comment')
 
+    @property
+    def auto_update_enabled(self):
+        """
+
+        :return:
+        """
+        return self.__auto_update_enabled
+
+    def enable_auto_updates(self):
+        """
+
+        :return:
+        """
+        self.__auto_update_enabled = True
+
+    def disable_auto_updates(self):
+        """
+
+        :return:
+        """
+        self.__auto_update_enabled = False
+
     def get_uuid(self) -> str:
         """
         If the idtag property looks like a UUID, it adds the dashes

{GridCalEngine-5.2.1 → GridCalEngine-5.2.2}/GridCalEngine/Devices/assets.py

@@ -4463,7 +4463,10 @@ class Assets:
         Remove diagrams
         :param diagram: MapDiagram, SchematicDiagram device
         """
-        self.diagrams.remove(diagram)
+        try:
+            self.diagrams.remove(diagram)
+        except ValueError as e:
+            print(e)
 
     # ------------------------------------------------------------------------------------------------------------------
     #
@@ -5737,6 +5740,18 @@ class Assets:
 
         return found
 
+    def get_all_elements_iter(self) -> Generator[ALL_DEV_TYPES, None, None]:
+        """
+        Get all elements
+        :return: ALL_DEV_TYPES
+        """
+
+        for key, tpe in self.device_type_name_dict.items():
+            elements = self.get_elements_by_type(device_type=tpe)
+
+            for elm in elements:
+                yield elm
+
     def get_all_elements_dict(self, logger=Logger()) -> Tuple[Dict[str, ALL_DEV_TYPES], bool]:
         """
         Get a dictionary of all elements

{GridCalEngine-5.2.1 → GridCalEngine-5.2.2}/GridCalEngine/IO/cim/cgmes/cgmes_create_instances.py

@@ -16,7 +16,8 @@ from GridCalEngine.IO.cim.cgmes.cgmes_enums import (cgmesProfile,
                                                     DCConverterOperatingModeKind,
                                                     VsPpccControlKind,
                                                     VsQpccControlKind)
-from GridCalEngine.IO.cim.cgmes.cgmes_utils import find_object_by_uuid
+from GridCalEngine.IO.cim.cgmes.cgmes_utils import find_object_by_uuid, \
+    get_voltage_terminal
 from GridCalEngine.IO.cim.cgmes.cgmes_v2_4_15.devices.full_model import FullModel
 from GridCalEngine.IO.cim.cgmes.base import Base
 import GridCalEngine.Devices as gcdev
@@ -67,7 +68,7 @@ def create_cgmes_headers(cgmes_model: CgmesCircuit,
         fm.modelingAuthoritySet = []
         if len(mas_names):
             for mas_name in mas_names:
-                fm.modelingAuthoritySet.append(mas_name.__str__)
+                fm.modelingAuthoritySet.append(mas_name)
         else:
             fm.modelingAuthoritySet.append("http://www.ree.es/OperationalPlanning")
             logger.add_warning(msg="Missing Modeling Authority!",
@@ -347,11 +348,7 @@ def create_cgmes_regulating_control(cgmes_syn,
     rc.name = f'_RC_{mc_gen.name}'
     rc.shortName = rc.name
     rc.mode = RegulatingControlModeKind.voltage
-    rc.Terminal = create_cgmes_terminal(mc_bus=mc_gen.bus,
-                                        seq_num=1,
-                                        cond_eq=cgmes_syn,
-                                        cgmes_model=cgmes_model,
-                                        logger=logger)
+    rc.Terminal = cgmes_syn.Terminals
 
     rc.RegulatingCondEq = cgmes_syn
     rc.discrete = False
@@ -414,14 +411,14 @@ def create_cgmes_tap_changer_control(
 
 
 def create_cgmes_current_limit(terminal,
-                               rate: float,
+                               rate_mw: float,
                                op_limit_type: Base,
                                cgmes_model: CgmesCircuit,
                                logger: DataLogger):
     """
 
     :param terminal: Cgmes Terminal
-    :param rate: current rate for cgmes
+    :param rate_mw: rating in GridCal in MW/MVA
     :param op_limit_type: Operational Limit Type
     :param cgmes_model: CgmesModel
     :param logger: DataLogger
@@ -434,7 +431,12 @@ def create_cgmes_current_limit(terminal,
     curr_lim.shortName = f'CL-1'
     curr_lim.description = f'Ratings for element {terminal.ConductingEquipment.name} - Limit'
 
-    curr_lim.value = rate
+    voltage = get_voltage_terminal(terminal, logger)
+    sqrt_3 = 1.73205080756888
+    current_rate = rate_mw * 1e3 / (voltage * sqrt_3)
+    current_rate = np.round(current_rate, 4)
+
+    curr_lim.value = current_rate   # Current rate in Amps
 
     op_lim_set_1 = create_operational_limit_set(terminal, cgmes_model, logger)
     if op_lim_set_1 is not None:

{GridCalEngine-5.2.1 → GridCalEngine-5.2.2}/GridCalEngine/IO/cim/cgmes/cgmes_to_gridcal.py

@@ -18,7 +18,7 @@ from GridCalEngine.IO.cim.cgmes.cgmes_utils import (get_nominal_voltage,
                                                     get_slack_id,
                                                     find_object_by_idtag,
                                                     find_terms_connections,
-                                                    build_rates_dict)
+                                                    build_cgmes_limit_dicts)
 from GridCalEngine.data_logger import DataLogger
 from GridCalEngine.IO.cim.cgmes.base import Base
 from GridCalEngine.enumerations import TapChangerTypes, TapPhaseControl, TapModuleControl
@@ -1110,26 +1110,32 @@ def get_gcdev_ac_lines(cgmes_model: CgmesCircuit,
     """
 
     # build the ratings dictionary
-    rates_dict = dict()
-    acline_type = cgmes_model.get_class_type("ACLineSegment")
-    for e in cgmes_model.cgmes_assets.CurrentLimit_list:
-        if e.OperationalLimitSet is None:
-            logger.add_error(msg='OperationalLimitSet missing.',
-                             device=e.rdfid,
-                             device_class=e.tpe,
-                             device_property="OperationalLimitSet",
-                             value="None")
-            continue
-        if not isinstance(e.OperationalLimitSet, str):
-            if isinstance(e.OperationalLimitSet, list):
-                for ols in e.OperationalLimitSet:
-                    if isinstance(ols.Terminal.ConductingEquipment, acline_type):
-                        branch_id = ols.Terminal.ConductingEquipment.uuid
-                        rates_dict[branch_id] = e.value
-            else:
-                if isinstance(e.OperationalLimitSet.Terminal.ConductingEquipment, acline_type):
-                    branch_id = e.OperationalLimitSet.Terminal.ConductingEquipment.uuid
-                    rates_dict[branch_id] = e.value
+    (patl_dict, tatl_900_dict, tatl_60_dict) = build_cgmes_limit_dicts(
+        cgmes_model=cgmes_model,
+        device_type=cgmes_model.get_class_type("ACLineSegment"),
+        logger=logger
+    )
+    # # build the ratings dictionary
+    # rates_dict = dict()
+    # acline_type = cgmes_model.get_class_type("ACLineSegment")
+    # for e in cgmes_model.cgmes_assets.CurrentLimit_list:
+    #     if e.OperationalLimitSet is None:
+    #         logger.add_error(msg='OperationalLimitSet missing.',
+    #                          device=e.rdfid,
+    #                          device_class=e.tpe,
+    #                          device_property="OperationalLimitSet",
+    #                          value="None")
+    #         continue
+    #     if not isinstance(e.OperationalLimitSet, str):
+    #         if isinstance(e.OperationalLimitSet, list):
+    #             for ols in e.OperationalLimitSet:
+    #                 if isinstance(ols.Terminal.ConductingEquipment, acline_type):
+    #                     branch_id = ols.Terminal.ConductingEquipment.uuid
+    #                     rates_dict[branch_id] = e.value
+    #         else:
+    #             if isinstance(e.OperationalLimitSet.Terminal.ConductingEquipment, acline_type):
+    #                 branch_id = e.OperationalLimitSet.Terminal.ConductingEquipment.uuid
+    #                 rates_dict[branch_id] = e.value
 
     # convert ac lines
     for device_list in [cgmes_model.cgmes_assets.ACLineSegment_list]:
@@ -1146,17 +1152,24 @@ def get_gcdev_ac_lines(cgmes_model: CgmesCircuit,
                 cn_f = cns[0]
                 cn_t = cns[1]
 
-                # get per unit vlaues
+                # get per unit values
                 r, x, g, b, r0, x0, g0, b0 = get_pu_values_ac_line_segment(ac_line_segment=cgmes_elm, logger=logger,
                                                                            Sbase=Sbase)
 
-                current_rate = rates_dict.get(cgmes_elm.uuid, None)  # A
-                if current_rate and cgmes_elm.BaseVoltage is not None:
-                    # rate in MVA = kA * kV * sqrt(3)
-                    rate = np.round((current_rate / 1000.0) * cgmes_elm.BaseVoltage.nominalVoltage * 1.73205080756888,
-                                    4)
+                normal_rate_mva = patl_dict.get(cgmes_elm.uuid, 9999.0)
+                # min PATL rate in MW/MVA
+                cont_rate_mva = tatl_900_dict.get(cgmes_elm.uuid, 9999.0)
+                # min TATL900 rate in MW/MVA
+                if cont_rate_mva != 9999.0:
+                    cont_factor = cont_rate_mva / normal_rate_mva
                 else:
-                    rate = 1e-20
+                    cont_factor = 1.0
+                prot_rate_mva = tatl_60_dict.get(cgmes_elm.uuid, 9999.0)
+                # min TATL60 rate in MW/MVA
+                if prot_rate_mva != 9999.0:
+                    prot_factor = prot_rate_mva / normal_rate_mva
+                else:
+                    prot_factor = 1.4
 
                 if cgmes_elm.length is None:
                     length = 1.0
@@ -1164,22 +1177,26 @@ def get_gcdev_ac_lines(cgmes_model: CgmesCircuit,
                 else:
                     length = float(cgmes_elm.length)
 
-                gcdev_elm = gcdev.Line(idtag=cgmes_elm.uuid,
-                                       code=cgmes_elm.description,
-                                       name=cgmes_elm.name,
-                                       active=True,
-                                       cn_from=cn_f,
-                                       cn_to=cn_t,
-                                       bus_from=calc_node_f,
-                                       bus_to=calc_node_t,
-                                       r=r,
-                                       x=x,
-                                       b=b,
-                                       r0=r0,
-                                       x0=x0,
-                                       b0=b0,
-                                       rate=rate,
-                                       length=length)
+                gcdev_elm = gcdev.Line(
+                    idtag=cgmes_elm.uuid,
+                    code=cgmes_elm.description,
+                    name=cgmes_elm.name,
+                    active=True,
+                    cn_from=cn_f,
+                    cn_to=cn_t,
+                    bus_from=calc_node_f,
+                    bus_to=calc_node_t,
+                    r=r,
+                    x=x,
+                    b=b,
+                    r0=r0,
+                    x0=x0,
+                    b0=b0,
+                    rate=normal_rate_mva,
+                    contingency_factor=cont_factor,
+                    protection_rating_factor=prot_factor,
+                    length=length,
+                )
 
                 gcdev_model.add_line(gcdev_elm, logger=logger)
             else:
@@ -1301,7 +1318,7 @@ def get_gcdev_ac_transformers(cgmes_model: CgmesCircuit,
 
     # build the ratings dictionary
     trafo_type = cgmes_model.get_class_type("PowerTransformer")
-    rates_dict = build_rates_dict(cgmes_model, trafo_type, logger)
+    (patl_dict, tatl_900_dict, tatl_60_dict) = build_cgmes_limit_dicts(cgmes_model, trafo_type, logger)
 
     # convert transformers
     for device_list in [cgmes_model.cgmes_assets.PowerTransformer_list]:
@@ -1316,7 +1333,17 @@ def get_gcdev_ac_transformers(cgmes_model: CgmesCircuit,
                         windings[i - 1] = pte
             windings = [x for x in windings if x is not None]
 
-            rate_mva = rates_dict.get(cgmes_elm.uuid, 9999.0)  # min PATL rate in MW/MVA
+            normal_rate_mva = patl_dict.get(cgmes_elm.uuid, 9999.0)  # min PATL rate in MW/MVA
+            cont_rate_mva = tatl_900_dict.get(cgmes_elm.uuid, 9999.0)  # min TATL900 rate in MW/MVA
+            if cont_rate_mva != 9999.0:
+                cont_factor = cont_rate_mva / normal_rate_mva
+            else:
+                cont_factor = 1.0
+            prot_rate_mva = tatl_60_dict.get(cgmes_elm.uuid, 9999.0)  # min TATL60 rate in MW/MVA
+            if prot_rate_mva != 9999.0:
+                prot_factor = prot_rate_mva / normal_rate_mva
+            else:
+                prot_factor = 1.4
 
             calc_nodes, cns = find_connections(cgmes_elm=cgmes_elm,
                                                device_to_terminal_dict=device_to_terminal_dict,
@@ -1339,36 +1366,41 @@ def get_gcdev_ac_transformers(cgmes_model: CgmesCircuit,
                     r, x, g, b, r0, x0, g0, b0 = get_pu_values_power_transformer(cgmes_elm, Sbase)
                     rated_s = windings[0].ratedS
 
-                    gcdev_elm = gcdev.Transformer2W(idtag=cgmes_elm.uuid,
-                                                    code=cgmes_elm.description,
-                                                    name=cgmes_elm.name,
-                                                    active=True,
-                                                    cn_from=cn_f,
-                                                    cn_to=cn_t,
-                                                    bus_from=calc_node_f,
-                                                    bus_to=calc_node_t,
-                                                    nominal_power=rated_s,
-                                                    HV=HV,
-                                                    LV=LV,
-                                                    r=r,
-                                                    x=x,
-                                                    g=g,
-                                                    b=b,
-                                                    r0=r0,
-                                                    x0=x0,
-                                                    g0=g0,
-                                                    b0=b0,
-                                                    # tap_module=tap_m,
-                                                    # # tap_phase=0.0,
-                                                    # # tap_module_control_mode=,  # leave fixed
-                                                    # # tap_angle_control_mode=,
-                                                    # tc_total_positions=total_pos,
-                                                    # tc_neutral_position=neutral_pos,
-                                                    # tc_normal_position=normal_pos,
-                                                    # tc_dV=dV,
-                                                    # # tc_asymmetry_angle = 90,
-                                                    # tc_type=tc_type,
-                                                    rate=rate_mva)
+                    gcdev_elm = gcdev.Transformer2W(
+                        idtag=cgmes_elm.uuid,
+                        code=cgmes_elm.description,
+                        name=cgmes_elm.name,
+                        active=True,
+                        cn_from=cn_f,
+                        cn_to=cn_t,
+                        bus_from=calc_node_f,
+                        bus_to=calc_node_t,
+                        nominal_power=rated_s,
+                        HV=HV,
+                        LV=LV,
+                        r=r,
+                        x=x,
+                        g=g,
+                        b=b,
+                        r0=r0,
+                        x0=x0,
+                        g0=g0,
+                        b0=b0,
+                        # tap_module=tap_m,
+                        # # tap_phase=0.0,
+                        # # tap_module_control_mode=,  # leave fixed
+                        # # tap_angle_control_mode=,
+                        # tc_total_positions=total_pos,
+                        # tc_neutral_position=neutral_pos,
+                        # tc_normal_position=normal_pos,
+                        # tc_dV=dV,
+                        # # tc_asymmetry_angle = 90,
+                        # tc_type=tc_type,
+                        rate=normal_rate_mva,
+                        contingency_factor=cont_factor,
+                        protection_rating_factor=prot_factor,
+                    )
+
 
                     # # get Tap data from CGMES
                     # tap_m, total_pos, neutral_pos, normal_pos, dV, tc_type, tap_pos = get_tap_changer_values(windings)