GridCalEngine 5.2.5__tar.gz → 5.2.6__tar.gz

{gridcalengine-5.2.5 → gridcalengine-5.2.6}/GridCalEngine/Compilers/circuit_to_data.py

@@ -487,6 +487,7 @@ def get_generator_data(
         data.dispatchable[k] = elm.enabled_dispatch
         data.pmax[k] = elm.Pmax
         data.pmin[k] = elm.Pmin
+        data.snom[k] = elm.Snom
 
         if time_series:
 

{gridcalengine-5.2.5 → gridcalengine-5.2.6}/GridCalEngine/DataStructures/generator_data.py

@@ -37,6 +37,7 @@ class GeneratorData:
 
         self.qmin: Vec = np.zeros(nelm, dtype=float)
         self.qmax: Vec = np.zeros(nelm, dtype=float)
+        self.snom: Vec = np.zeros(nelm, dtype=float)
         self.q_share: Vec = np.zeros(nelm, dtype=float)
 
         # reliabilty
@@ -95,6 +96,7 @@ class GeneratorData:
 
         data.qmin = self.qmin[elm_idx]
         data.qmax = self.qmax[elm_idx]
+        data.snom = self.snom[elm_idx]
         data.q_share = self.q_share[elm_idx]
 
         data.mttf = self.mttf[elm_idx]
@@ -157,6 +159,7 @@ class GeneratorData:
 
         data.qmin = self.qmin.copy()
         data.qmax = self.qmax.copy()
+        data.snom = self.snom.copy()
         data.q_share = self.q_share.copy()
 
         data.mttf = self.mttf.copy()

{gridcalengine-5.2.5 → gridcalengine-5.2.6}/GridCalEngine/Devices/Branches/tap_changer.py

@@ -310,7 +310,7 @@ class TapChanger:
         :param tap_module: float value of the tap module
         """
         if self.tc_type != TapChangerTypes.NoRegulation:
-            _, val = find_closest_number(arr=self._tau_array, target=tap_module)
+            _, val = find_closest_number(arr=self._m_array, target=tap_module)
             return val
 
     def get_tap_module_min(self) -> float:
@@ -424,14 +424,14 @@ class TapChanger:
             high = self.total_positions - self.neutral_position
             normal = self.normal_position + low - 1
             neutral = self.neutral_position + low - 1
-            sVI = self.dV * 100
+            sVI = round(self.dV * 100, 6)
             step = self.tap_position + low - 1
         else:
             low = 0
             high = self.total_positions - 1
             normal = self.normal_position
             neutral = self.neutral_position
-            sVI = self.dV * 100
+            sVI = round(self.dV * 100, 6)
             step = self.tap_position
 
         return low, high, normal, neutral, sVI, step

{gridcalengine-5.2.5 → gridcalengine-5.2.6}/GridCalEngine/Devices/Injections/controllable_shunt.py

@@ -174,6 +174,26 @@ class ControllableShunt(ShuntParent):
                 for i in range(1, nn):
                     self._b_steps[i] = self._b_steps[i - 1] + n_list[i] * b_list[i]
 
+    def get_block_points(self):
+        """
+        Get B points for CGMES export.
+        :return:
+        :rtype:
+        """
+        b_points = []
+        g_points = []
+        b_points.append(self._b_steps[0])
+        g_points.append(self._g_steps[0])
+
+        for i in range(1, len(self._b_steps)):
+            delta_b = self._b_steps[i] - self._b_steps[i-1]
+            delta_g = self._g_steps[i] - self._g_steps[i-1]
+
+            b_points.append(delta_b)
+            g_points.append(delta_g)
+
+        return b_points, g_points
+
     @property
     def b_steps(self):
         """

{gridcalengine-5.2.5 → gridcalengine-5.2.6}/GridCalEngine/Devices/Parents/injection_parent.py

@@ -88,6 +88,8 @@ class InjectionParent(PhysicalDevice):
 
         self.technologies: Associations = Associations(device_type=DeviceType.Technology)
 
+        self.scalable: bool = True
+
         self.register(key='bus', units='', tpe=DeviceType.BusDevice, definition='Connection bus',
                       editable=False, profile_name="bus_prof")
 
@@ -115,6 +117,9 @@ class InjectionParent(PhysicalDevice):
         self.register(key='technologies', units='p.u.', tpe=SubObjectType.Associations,
                       definition='List of technologies', display=False)
 
+        self.register(key='scalable', units='', tpe=bool, definition='Is the load scalable?', editable=False,
+                      display=False)
+
     @property
     def bus(self) -> Bus:
         """

{gridcalengine-5.2.5 → gridcalengine-5.2.6}/GridCalEngine/Devices/Substation/substation.py

@@ -31,7 +31,7 @@ class Substation(GenericAreaGroup):
                  municipality: Union[Municipality, None] = None,
                  address: str = "",
                  irradiation: float = 0.0,
-                 temparature: float = 0.0,
+                 temperature: float = 0.0,
                  wind_speed: float = 0.0,
                  terrain_roughness: float = 0.20,
                  color: Union[str, None] = "#3d7d95"):
@@ -50,7 +50,7 @@ class Substation(GenericAreaGroup):
         :param municipality:
         :param address:
         :param irradiation:
-        :param temparature:
+        :param temperature:
         :param wind_speed:
         :param terrain_roughness:
         :param color: hexadecimal color string (i.e. #AA00FF)
@@ -75,8 +75,8 @@ class Substation(GenericAreaGroup):
         self.irradiation: float = float(irradiation)
         self._irradiation_prof = Profile(default_value=self.irradiation, data_type=float)
 
-        self.temparature: float = float(temparature)
-        self._temparature_prof = Profile(default_value=self.temparature, data_type=float)
+        self.temperature: float = float(temperature)
+        self._temperature_prof = Profile(default_value=self.temperature, data_type=float)
 
         self.wind_speed: float = float(wind_speed)
         self._wind_speed_prof = Profile(default_value=self.wind_speed, data_type=float)
@@ -108,9 +108,9 @@ class Substation(GenericAreaGroup):
                       definition="Substation solar irradiation",
                       profile_name="irradiation_prof")
 
-        self.register(key="temparature", units="ºC", tpe=float,
+        self.register(key="temperature", units="ºC", tpe=float,
                       definition="Substation temperature",
-                      profile_name="temparature_prof")
+                      profile_name="temperature_prof")
 
         self.register(key="wind_speed", units="m/s", tpe=float,
                       definition="Substation wind speed at 80m above the ground",
@@ -160,7 +160,7 @@ class Substation(GenericAreaGroup):
         if isinstance(val, Union[Zone, None]):
             self._zone = val
 
-            if val is not None:
+            if val is not None and self.auto_update_enabled:
                 if val.area is not None and self.area is None:
                     self.area = val.area
 
@@ -203,7 +203,7 @@ class Substation(GenericAreaGroup):
         if isinstance(val, Union[Community, None]):
             self._community = val
 
-            if val is not None:
+            if val is not None and self.auto_update_enabled:
                 if val.country is not None and self.country is None:
                     self.country = val.country
         else:
@@ -226,7 +226,7 @@ class Substation(GenericAreaGroup):
         if isinstance(val, Union[Region, None]):
             self._region = val
 
-            if val is not None:
+            if val is not None and self.auto_update_enabled:
                 if val.community is not None and self.community is None:
                     self.community = val.community
 
@@ -250,7 +250,7 @@ class Substation(GenericAreaGroup):
         if isinstance(val, Union[Municipality, None]):
             self._municipality = val
 
-            if val is not None:
+            if val is not None and self.auto_update_enabled:
                 if val.region is not None and self.region is None:
                     self.region = val.region
 
@@ -276,21 +276,21 @@ class Substation(GenericAreaGroup):
             raise Exception(str(type(val)) + 'not supported to be set into a irradiation_prof')
 
     @property
-    def temparature_prof(self) -> Profile:
+    def temperature_prof(self) -> Profile:
         """
         Temperature profile
         :return: Profile
         """
-        return self._temparature_prof
+        return self._temperature_prof
 
-    @temparature_prof.setter
-    def temparature_prof(self, val: Union[Profile, np.ndarray]):
+    @temperature_prof.setter
+    def temperature_prof(self, val: Union[Profile, np.ndarray]):
         if isinstance(val, Profile):
-            self._temparature_prof = val
+            self._temperature_prof = val
         elif isinstance(val, np.ndarray):
-            self._temparature_prof.set(arr=val)
+            self._temperature_prof.set(arr=val)
         else:
-            raise Exception(str(type(val)) + 'not supported to be set into a temparature_prof')
+            raise Exception(str(type(val)) + 'not supported to be set into a temperature_prof')
 
     @property
     def wind_speed_prof(self) -> Profile:

{gridcalengine-5.2.5 → gridcalengine-5.2.6}/GridCalEngine/Devices/multi_circuit.py

@@ -1917,9 +1917,9 @@ class MultiCircuit(Assets):
                                     value=v2,
                                     expected_value=v1)
                             else:
-                                if not np.isclose(v1, v2, atol=tolerance):
+                                if not np.all(np.isclose(v1, v2, atol=tolerance)):
                                     logger.add_error(
-                                        msg="Different snapshot values",
+                                        msg="Different array values",
                                         device_class=template_elm.device_type.value,
                                         device_property=prop.name,
                                         value=v2,

{gridcalengine-5.2.5 → gridcalengine-5.2.6}/GridCalEngine/IO/cim/cgmes/cgmes_create_instances.py

@@ -395,13 +395,12 @@ def create_cgmes_tap_changer_control(
     tcc.targetDeadband = 0.5
     tcc.targetValueUnitMultiplier = UnitMultiplier.k
     tcc.enabled = tcc_enabled
-    if tcc.enabled:
-        if mc_trafo:
-            tcc.targetValue = mc_trafo.vset * mc_trafo.get_max_bus_nominal_voltage()
-        else:
-            tcc.targetValue = mc_trafo.Pset
-    else:
-        tcc.targetValue = None
+    voltage = get_voltage_terminal(tcc.Terminal, logger)
+    tcc.targetValue = mc_trafo.vset * voltage
+
+    # TODO consider other control types
+    # if mc_trafo.tap_module_control_mode ...:
+    #     tcc.targetValue = mc_trafo.Pset
     # tcc.RegulatingCondEq not required .?
     # control_cn.Vnom ?
 
@@ -436,7 +435,7 @@ def create_cgmes_current_limit(terminal,
     current_rate = rate_mw * 1e3 / (voltage * sqrt_3)
     current_rate = np.round(current_rate, 4)
 
-    curr_lim.value = current_rate   # Current rate in Amps
+    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:
@@ -589,7 +588,7 @@ def create_cgmes_vsc_converter(cgmes_model: CgmesCircuit,
     vs_converter.maxValveCurrent = 99999
 
     # SSH
-    vs_converter.p = p_set   # hvdc_line.Pset or VSC.Pset
+    vs_converter.p = p_set  # hvdc_line.Pset or VSC.Pset
     vs_converter.q = 0.0
     vs_converter.targetPpcc = p_set
     vs_converter.targetUdc = 0
@@ -705,7 +704,7 @@ def create_cgmes_dc_line(cgmes_model: CgmesCircuit,
 
 def create_cgmes_dc_line_segment(cgmes_model: CgmesCircuit,
                                  mc_elm: Union[gcdev.HvdcLine,
-                                               gcdev.DcLine],
+                                 gcdev.DcLine],
                                  dc_tp_1: Base,
                                  dc_node_1: Base,
                                  dc_tp_2: Base,
@@ -941,12 +940,34 @@ def create_cgmes_conform_load_group(
     c_load_group.name = "_CLG_"
     c_load_group.description = "_CLG_"
     c_load_group.EnergyConsumers = []
-    c_load_group.SubLoadArea = create_cgmes_sub_load_area(cgmes_model, logger)
+    c_load_group.SubLoadArea = cgmes_model.cgmes_assets.SubLoadArea_list[0]
 
     cgmes_model.add(c_load_group)
     return c_load_group
 
 
+def create_cgmes_non_conform_load_group(
+        cgmes_model: CgmesCircuit,
+        logger: DataLogger):
+    """
+
+    :param mc_elm:
+    :param cgmes_model:
+    :param logger:
+    :return:
+    """
+    new_rdf_id = get_new_rdfid()
+    object_template = cgmes_model.get_class_type("NonConformLoadGroup")
+    nc_load_group = object_template(rdfid=new_rdf_id)
+    nc_load_group.name = "_NCLG_"
+    nc_load_group.description = "_NCLG_"
+    nc_load_group.EnergyConsumers = []
+    nc_load_group.SubLoadArea = cgmes_model.cgmes_assets.SubLoadArea_list[0]
+
+    cgmes_model.add(nc_load_group)
+    return nc_load_group
+
+
 def create_cgmes_sub_load_area(
         cgmes_model: CgmesCircuit,
         logger: DataLogger):
@@ -986,3 +1007,34 @@ def create_cgmes_load_area(
 
     cgmes_model.add(sub_load_area)
     return sub_load_area
+
+
+def create_cgmes_nonlinear_sc_point(
+        section_num: int,
+        b: float,
+        g: float,
+        nl_sc: Base,
+        cgmes_model: CgmesCircuit,
+    ):
+    """
+    
+    :param section_num: 
+    :param b: b in Siemens
+    :param g: g in 
+    :param nl_sc: NonlinearShuntCompensator object
+    :param cgmes_model: CgmesModel
+    :param logger: DataLogger
+    :return: 
+    """""
+    new_rdf_id = get_new_rdfid()
+    object_template = cgmes_model.get_class_type("NonlinearShuntCompensatorPoint")
+    nl_sc_p = object_template(rdfid=new_rdf_id)
+
+    nl_sc_p.sectionNumber = section_num
+    nl_sc_p.b = b
+    nl_sc_p.g = g
+    nl_sc_p.b0 = 0.0
+    nl_sc_p.g0 = 0.0
+    nl_sc_p.NonlinearShuntCompensator = nl_sc
+
+    cgmes_model.add(nl_sc_p)

{gridcalengine-5.2.5 → gridcalengine-5.2.6}/GridCalEngine/IO/cim/cgmes/cgmes_export.py

@@ -209,6 +209,9 @@ class CimExporter:
                         f_zip_ptr.writestr(f"{name}_{prof}_001.xml", buffer.getvalue())
 
     def serialize(self, stream, profile):
+        if not self.supports_profile(profile):
+            raise NotImplementedError("Unsupported CGMES profile to export: " + profile)
+
         root = Et.Element("rdf:RDF", self.namespaces)
         full_model_elements = self.generate_full_model_elements(profile)
         root.extend(full_model_elements)
@@ -232,6 +235,12 @@ class CimExporter:
 
         stream.seek(0)
 
+    def supports_profile(self, profile):
+        if profile in self.profile_uris:
+            return True
+        else:
+            return False
+
     def is_in_profile(self, instance_profiles, model_profile):
         if isinstance(instance_profiles, list):
             for profile in instance_profiles:

{gridcalengine-5.2.5 → gridcalengine-5.2.6}/GridCalEngine/IO/cim/cgmes/cgmes_to_gridcal.py

@@ -13,12 +13,13 @@ from GridCalEngine.IO.cim.cgmes.cgmes_utils import (get_nominal_voltage,
                                                     get_values_shunt,
                                                     get_pu_values_power_transformer,
                                                     get_pu_values_power_transformer3w,
-                                                    get_regulating_control,
+                                                    get_regulating_control_params,
                                                     get_pu_values_power_transformer_end,
                                                     get_slack_id,
                                                     find_object_by_idtag,
                                                     find_terms_connections,
-                                                    build_cgmes_limit_dicts)
+                                                    build_cgmes_limit_dicts,
+                                                    get_voltage_shunt)
 from GridCalEngine.data_logger import DataLogger
 from GridCalEngine.IO.cim.cgmes.base import Base
 from GridCalEngine.enumerations import TapChangerTypes, TapPhaseControl, TapModuleControl
@@ -913,6 +914,11 @@ def get_gcdev_loads(cgmes_model: CgmesCircuit,
                                        G=g,
                                        B=b)
 
+                if isinstance(cgmes_elm, cgmes_model.get_class_type("ConformLoad")):
+                    gcdev_elm.scalable = True
+                else:
+                    gcdev_elm.scalable = False
+
                 gcdev_model.add_load(bus=calc_node, api_obj=gcdev_elm, cn=cn)
 
             else:
@@ -983,7 +989,7 @@ def get_gcdev_generators(cgmes_model: CgmesCircuit,
                 if cgmes_elm.GeneratingUnit is not None:
 
                     v_set, is_controlled, controlled_bus, controlled_cn = (
-                        get_regulating_control(
+                        get_regulating_control_params(
                             cgmes_elm=cgmes_elm,
                             cgmes_enums=cgmes_enums,
                             calc_node_dict=calc_node_dict,
@@ -1072,11 +1078,12 @@ def get_gcdev_external_grids(cgmes_model: CgmesCircuit,
             if len(calc_nodes) == 1:
                 calc_node = calc_nodes[0]
                 cn = cns[0]
-
+                # TODO define ExternalGrid.mode
                 gcdev_elm = gcdev.ExternalGrid(idtag=cgmes_elm.uuid,
                                                code=cgmes_elm.description,
                                                name=cgmes_elm.name,
                                                active=True,
+                                               # mode=enum.PQ/PV/VD
                                                P=cgmes_elm.p,
                                                Q=cgmes_elm.q)
 
@@ -1564,6 +1571,7 @@ def get_transformer_tap_changers(cgmes_model: CgmesCircuit,
                                        device_class=tap_changer.tpe,
                                        device_property="control for TapChanger",
                                        value=type(tap_changer))
+
             elif isinstance(tap_changer, phase_sy_class):
                 tc_type = TapChangerTypes.Symmetrical
 
@@ -1599,7 +1607,7 @@ def get_transformer_tap_changers(cgmes_model: CgmesCircuit,
                                        value=type(tap_changer))
 
             else:
-                logger.add_warning(msg="No control found for TapChanger",
+                logger.add_warning(msg="TapChanger Class not recognized.",
                                    device=tap_changer.rdfid,
                                    device_class=tap_changer.tpe,
                                    device_property="control for TapChanger",
@@ -1632,9 +1640,14 @@ def get_transformer_tap_changers(cgmes_model: CgmesCircuit,
                     tc_type=tc_type
                 )
 
-                # SET tap_module and tap_phase from its own TapChanger object
-                gcdev_trafo.tap_module = gcdev_trafo.tap_changer.get_tap_module()
-                gcdev_trafo.tap_phase = gcdev_trafo.tap_changer.get_tap_phase()
+                if gcdev_trafo.tap_changer.tc_type == TapChangerTypes.NoRegulation:
+                    # SET tap_module and tap_phase from dV
+                    gcdev_trafo.tap_module = 1 - gcdev_trafo.tap_changer.dV
+                    gcdev_trafo.tap_phase = 0
+                else:
+                    # SET tap_module and tap_phase from its own TapChanger object
+                    gcdev_trafo.tap_module = gcdev_trafo.tap_changer.get_tap_module()
+                    gcdev_trafo.tap_phase = gcdev_trafo.tap_changer.get_tap_phase()
 
             elif isinstance(gcdev_trafo, gcdev.Transformer3W):
                 winding_id = tap_changer.TransformerEnd.uuid
@@ -1678,7 +1691,8 @@ def get_gcdev_shunts(cgmes_model: CgmesCircuit,
                      logger: DataLogger,
                      Sbase: float) -> None:
     """
-    Convert the CGMES shunts to gcdev
+    Convert the CGMES equivalent shunts to gcdev shunts,
+    simple shunts without control
 
     :param cgmes_model: CgmesCircuit
     :param gcdev_model: gcdevCircuit
@@ -1689,7 +1703,7 @@ def get_gcdev_shunts(cgmes_model: CgmesCircuit,
     :param Sbase:
     """
     # convert shunts
-    for device_list in [cgmes_model.cgmes_assets.LinearShuntCompensator_list]:
+    for device_list in [cgmes_model.cgmes_assets.EquivalentShunt_list]:
 
         for cgmes_elm in device_list:
 
@@ -1703,19 +1717,17 @@ def get_gcdev_shunts(cgmes_model: CgmesCircuit,
                 calc_node = calc_nodes[0]
                 cn = cns[0]
 
-                # conversion
-                G, B, G0, B0 = get_values_shunt(shunt=cgmes_elm,
-                                                logger=logger,
-                                                Sbase=Sbase)
+                Vnom = get_voltage_shunt(shunt=cgmes_elm, logger=logger)
+
+                G = cgmes_elm.g * (Vnom * Vnom)
+                B = cgmes_elm.b * (Vnom * Vnom)
 
                 gcdev_elm = gcdev.Shunt(
                     idtag=cgmes_elm.uuid,
                     name=cgmes_elm.name,
                     code=cgmes_elm.description,
-                    G=G * cgmes_elm.sections,
-                    B=B * cgmes_elm.sections,
-                    G0=G0 * cgmes_elm.sections,
-                    B0=B0 * cgmes_elm.sections,
+                    G=round(G, 4),
+                    B=round(B, 4),
                     active=True,
                 )
                 gcdev_model.add_shunt(bus=calc_node, api_obj=gcdev_elm, cn=cn)
@@ -1738,7 +1750,8 @@ def get_gcdev_controllable_shunts(
         logger: DataLogger,
         Sbase: float) -> None:
     """
-    Convert the CGMES non-linear shunt compensators to gcdev Controllable shunts.
+    Convert the CGMES linear and non-linear shunt compensators
+    to gcdev Controllable shunts.
 
     :param cgmes_model: CgmesCircuit
     :param gcdev_model: gcdevCircuit
@@ -1748,14 +1761,140 @@ def get_gcdev_controllable_shunts(
     :param Sbase: base power (100 MVA)
     :param logger:
     """
-    # comes later
-    for device_list in [cgmes_model.cgmes_assets.NonlinearShuntCompensator_list]:
-        # ...
-        # v_set, is_controlled = get_regulating_control(
-        #     cgmes_elm=cgmes_elm,
-        #     cgmes_enums=cgmes_enums,
-        #     logger=logger)
-        pass
+    # LINEAR
+    for cgmes_elm in cgmes_model.cgmes_assets.LinearShuntCompensator_list:
+
+        calc_nodes, cns = find_connections(cgmes_elm=cgmes_elm,
+                                           device_to_terminal_dict=device_to_terminal_dict,
+                                           calc_node_dict=calc_node_dict,
+                                           cn_dict=cn_dict,
+                                           logger=logger)
+
+        if len(calc_nodes) == 1:
+            calc_node = calc_nodes[0]
+            cn = cns[0]
+
+            # conversion
+            G, B, G0, B0 = get_values_shunt(shunt=cgmes_elm,
+                                            logger=logger,
+                                            Sbase=Sbase)
+
+            v_set, is_controlled, controlled_bus, controlled_cn = (
+                get_regulating_control_params(
+                    cgmes_elm=cgmes_elm,
+                    cgmes_enums=cgmes_enums,
+                    calc_node_dict=calc_node_dict,
+                    cn_dict=cn_dict,
+                    logger=logger
+                ))
+
+            gcdev_elm = gcdev.ControllableShunt(
+                idtag=cgmes_elm.uuid,
+                name=cgmes_elm.name,
+                code=cgmes_elm.description,
+                active=True,
+                is_nonlinear=False,                        # it is Linear!
+                number_of_steps=cgmes_elm.maximumSections,
+                step=cgmes_elm.sections,
+                g_per_step=G,
+                b_per_step=B,
+                G=G,
+                B=B,
+                G0=G0,
+                B0=B0,
+                vset=v_set,
+                is_controlled=is_controlled,
+                control_bus=controlled_bus,
+            )
+            # gcdev_elm = gcdev.Shunt(
+            #     idtag=cgmes_elm.uuid,
+            #     name=cgmes_elm.name,
+            #     code=cgmes_elm.description,
+            #     G=G * cgmes_elm.sections,
+            #     B=B * cgmes_elm.sections,
+            #     G0=G0 * cgmes_elm.sections,
+            #     B0=B0 * cgmes_elm.sections,
+            #     active=True,
+            # )
+            gcdev_model.add_controllable_shunt(bus=calc_node, api_obj=gcdev_elm, cn=cn)
+
+        else:
+            logger.add_error(msg='Not exactly one terminal',
+                             device=cgmes_elm.rdfid,
+                             device_class=cgmes_elm.tpe,
+                             device_property="number of associated terminals",
+                             value=len(calc_nodes),
+                             expected_value=1)
+
+    # NON - LINEAR
+    for cgmes_elm in cgmes_model.cgmes_assets.NonlinearShuntCompensator_list:
+
+        calc_nodes, cns = find_connections(cgmes_elm=cgmes_elm,
+                                           device_to_terminal_dict=device_to_terminal_dict,
+                                           calc_node_dict=calc_node_dict,
+                                           cn_dict=cn_dict,
+                                           logger=logger)
+
+        if len(calc_nodes) == 1:
+            calc_node = calc_nodes[0]
+            cn = cns[0]
+
+            # # conversion
+            # G, B, G0, B0 = get_values_shunt(shunt=cgmes_elm,
+            #                                 logger=logger,
+            #                                 Sbase=Sbase)
+
+            v_set, is_controlled, controlled_bus, controlled_cn = (
+                get_regulating_control_params(
+                    cgmes_elm=cgmes_elm,
+                    cgmes_enums=cgmes_enums,
+                    calc_node_dict=calc_node_dict,
+                    cn_dict=cn_dict,
+                    logger=logger
+                ))
+
+            gcdev_elm = gcdev.ControllableShunt(
+                idtag=cgmes_elm.uuid,
+                name=cgmes_elm.name,
+                code=cgmes_elm.description,
+                active=True,
+                is_nonlinear=True,                  # it is NonLinear!
+                number_of_steps=cgmes_elm.maximumSections,
+                step=cgmes_elm.sections,
+                # g_per_step=G,
+                # b_per_step=B,
+                # G=G,
+                # B=B,
+                vset=v_set,
+                is_controlled=is_controlled,
+                control_bus=controlled_bus,
+            )
+
+            point_list = []
+            for nl_sc_p in cgmes_model.cgmes_assets.NonlinearShuntCompensatorPoint_list:
+                if nl_sc_p.NonlinearShuntCompensator == cgmes_elm:
+                    point_list.append(nl_sc_p)
+            point_list.sort(key=lambda obj: obj.sectionNumber)
+
+            Vnom = get_voltage_shunt(shunt=cgmes_elm, logger=logger)
+
+            b_list = [point.b * (Vnom * Vnom) for point in point_list]
+            n_list = [1] * len(b_list)
+
+            gcdev_elm.set_blocks(n_list, b_list)
+
+            # gcdev_elm.B = b_list[0]     # how to consider Binit?
+            # gcdev_elm.G
+
+            gcdev_model.add_controllable_shunt(bus=calc_node, api_obj=gcdev_elm, cn=cn)
+
+        else:
+            logger.add_error(msg='Not exactly one terminal',
+                             device=cgmes_elm.rdfid,
+                             device_class=cgmes_elm.tpe,
+                             device_property="number of associated terminals",
+                             value=len(calc_nodes),
+                             expected_value=1)
 
 
 def get_gcdev_switches(cgmes_model: CgmesCircuit,
@@ -2230,8 +2369,15 @@ def cgmes_to_gridcal(cgmes_model: CgmesCircuit,
                      logger=logger,
                      Sbase=Sbase)
 
-    # get_gcdev_controllable_shunts()  TODO controllable shunts
-
+    get_gcdev_controllable_shunts(
+        cgmes_model=cgmes_model,
+        gcdev_model=gc_model,
+        calc_node_dict=calc_node_dict,
+        cn_dict=cn_dict,
+        device_to_terminal_dict=device_to_terminal_dict,
+        logger=logger,
+        Sbase=Sbase
+    )
     get_gcdev_switches(cgmes_model=cgmes_model,
                        gcdev_model=gc_model,
                        calc_node_dict=calc_node_dict,