pyedb 0.54.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

pyedb/configuration/cfg_setup.py

@@ -31,108 +31,34 @@ class CfgSetup:
 
     """
 
-    class Common:
-        class Grpc:
-            def __init__(self, parent):
-                self.parent = parent
-
-            def apply_freq_sweep(self, edb_setup):
-                for i in self.parent.parent.freq_sweep:
-                    f_set = []
-                    freq_string = []
-                    for f in i.get("frequencies", []):
-                        if isinstance(f, dict):
-                            increment = f.get("increment", f.get("points", f.get("samples", f.get("step"))))
-                            f_set.append([f["distribution"], f["start"], f["stop"], increment])
-                        else:
-                            freq_string.append(f)
-                    discrete_sweep = True
-                    if i["type"] == "interpolation":
-                        discrete_sweep = False
-                    if freq_string:
-                        for _sweep in freq_string:
-                            _sw = _sweep.split(" ")
-                            edb_setup.add_sweep(
-                                name=i["name"],
-                                distribution=_sw[0],
-                                start_freq=_sw[1],
-                                stop_freq=_sw[2],
-                                step=_sw[3],
-                                discrete=discrete_sweep,
-                            )
-                    else:
-                        edb_setup.add_sweep(i["name"], frequency_set=f_set, discrete=discrete_sweep)
-
-        class DotNet(Grpc):
-            def __init__(self, parent):
-                super().__init__(parent)
-
-            @staticmethod
-            def set_frequency_string(sweep, freq_string):
-                sweep.frequency_string = freq_string
-
-            def apply_freq_sweep(self, edb_setup):
-                for i in self.parent.parent.freq_sweep:
-                    f_set = []
-                    freq_string = []
-                    for f in i.get("frequencies", []):
-                        if isinstance(f, dict):
-                            increment = f.get("increment", f.get("points", f.get("samples", f.get("step"))))
-                            f_set.append([f["distribution"], f["start"], f["stop"], increment])
-                        else:
-                            freq_string.append(f)
-                    sweep = edb_setup.add_sweep(i["name"], frequency_set=f_set, sweep_type=i["type"])
-                    if len(freq_string) > 0:
-                        self.parent.api.set_frequency_string(sweep, freq_string)
-
-        @property
-        def pyedb_obj(self):
-            return self.parent.pyedb_obj
-
-        def __init__(self, parent):
-            self.parent = parent
-            self.pedb = parent.pedb
-            if self.pedb.grpc:
-                self.api = self.Grpc(self)
-            else:
-                self.api = self.DotNet(self)
-
-        def _retrieve_parameters_from_edb_common(self):
-            self.parent.name = self.pyedb_obj.name
-            self.parent.type = self.pyedb_obj.type
-
-        def _apply_freq_sweep(self, edb_setup):
-            self.api.apply_freq_sweep(edb_setup)
-
-    class Grpc(Common):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-        def set_parameters_to_edb(self):
-            pass
-
-        def retrieve_parameters_from_edb(self):
-            pass
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
+    @staticmethod
+    def set_frequency_string(sweep, freq_string):
+        sweep.frequency_string = freq_string
+
+    def apply_freq_sweep(self, edb_setup):
+        for i in self.freq_sweep:
+            f_set = []
+            freq_string = []
+            for f in i.get("frequencies", []):
+                if isinstance(f, dict):
+                    increment = f.get("increment", f.get("points", f.get("samples", f.get("step"))))
+                    f_set.append([f["distribution"], f["start"], f["stop"], increment])
+                else:
+                    freq_string.append(f)
+            sweep = edb_setup.add_sweep(i["name"], frequency_set=f_set, sweep_type=i["type"])
+            if len(freq_string) > 0:
+                self.set_frequency_string(sweep, freq_string)
 
     def __init__(self, pedb, pedb_obj, **kwargs):
         self.pedb = pedb
         self.pyedb_obj = pedb_obj
-        self.name = kwargs.get("name")
+        self.name = kwargs["name"]
         self.type = ""
 
         self.freq_sweep = []
 
         self.freq_sweep = kwargs.get("freq_sweep", [])
 
-        if self.pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
-
     def _to_dict_setup(self):
         return {
             "name": self.name,
@@ -141,30 +67,21 @@ class CfgSetup:
 
 
 class CfgSIwaveACSetup(CfgSetup):
-    class Grpc(CfgSetup.Common):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-        def set_parameters_to_edb(self):
-            if self.parent.name in self.pedb.setups:
-                raise "Setup {} already existing. Editing it.".format(self.parent.name)
-
-            edb_setup = self.pedb.create_siwave_syz_setup(name=self.parent.name)
-            if self.parent.si_slider_position is not None:
-                edb_setup.si_slider_position = self.parent.si_slider_position
-            else:
-                edb_setup.pi_slider_position = self.parent.pi_slider_position
-            self._apply_freq_sweep(edb_setup)
-
-        def retrieve_parameters_from_edb(self):
-            self._retrieve_parameters_from_edb_common()
-            self.parent.use_si_settings = self.pyedb_obj.use_si_settings
-            self.parent.si_slider_position = self.pyedb_obj.si_slider_position
-            self.parent.pi_slider_position = self.pyedb_obj.pi_slider_position
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
+    def set_parameters_to_edb(self):
+        if self.name in self.pedb.setups:
+            raise "Setup {} already existing. Editing it.".format(self.name)
+
+        edb_setup = self.pedb.create_siwave_syz_setup(name=self.name)
+        if self.si_slider_position is not None:
+            edb_setup.si_slider_position = self.si_slider_position
+        else:
+            edb_setup.pi_slider_position = self.pi_slider_position
+        self.apply_freq_sweep(edb_setup)
+
+    def retrieve_parameters_from_edb(self):
+        self.use_si_settings = self.pyedb_obj.use_si_settings
+        self.si_slider_position = self.pyedb_obj.si_slider_position
+        self.pi_slider_position = self.pyedb_obj.pi_slider_position
 
     def __init__(self, pedb, pyedb_obj, **kwargs):
         super().__init__(pedb, pyedb_obj, **kwargs)
@@ -186,35 +103,17 @@ class CfgSIwaveACSetup(CfgSetup):
 
 
 class CfgSIwaveDCSetup(CfgSetup):
-    class Grpc(CfgSetup.Common):
-        def __init__(self, parent):
-            super().__init__(parent)
+    def retrieve_parameters_from_edb(self):
+        self.dc_slider_position = self.pyedb_obj.dc_settings.dc_slider_position
+        dc_ir_settings = dict()
+        dc_ir_settings["export_dc_thermal_data"] = self.pyedb_obj.dc_ir_settings.export_dc_thermal_data
+        self.dc_ir_settings = dc_ir_settings
 
-        def set_parameters_to_edb(self):
-            edb_setup = self.pedb.create_siwave_dc_setup(
-                name=self.parent.name, dc_slider_position=self.parent.dc_slider_position
-            )
-            edb_setup.settings.dc.dc_slider_pos = self.parent.dc_slider_position
-            edb_setup.settings.export_dc_thermal_data = self.parent.dc_ir_settings.get("export_dc_thermal_data", False)
-
-        def retrieve_parameters_from_edb(self):
-            self._retrieve_parameters_from_edb_common()
-            self.parent.dc_slider_position = self.pyedb_obj.dc_settings.dc_slider_position
-            dc_ir_settings = dict()
-            dc_ir_settings["export_dc_thermal_data"] = self.pyedb_obj.dc_ir_settings.export_dc_thermal_data
-            self.parent.dc_ir_settings = dc_ir_settings
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-        def set_parameters_to_edb(self):
-            edb_setup = self.pedb.create_siwave_dc_setup(
-                name=self.parent.name, dc_slider_position=self.parent.dc_slider_position
-            )
-            edb_setup.dc_settings.dc_slider_position = self.parent.dc_slider_position
-            dc_ir_settings = self.parent.dc_ir_settings
-            edb_setup.dc_ir_settings.export_dc_thermal_data = dc_ir_settings.get("export_dc_thermal_data", False)
+    def set_parameters_to_edb(self):
+        edb_setup = self.pedb.create_siwave_dc_setup(name=self.name, dc_slider_position=self.dc_slider_position)
+        edb_setup.dc_settings.dc_slider_position = self.dc_slider_position
+        dc_ir_settings = self.dc_ir_settings
+        edb_setup.dc_ir_settings.export_dc_thermal_data = dc_ir_settings.get("export_dc_thermal_data", False)
 
     def __init__(self, pedb, pyedb_obj, **kwargs):
         super().__init__(pedb, pyedb_obj, **kwargs)
@@ -229,107 +128,49 @@ class CfgSIwaveDCSetup(CfgSetup):
 
 
 class CfgHFSSSetup(CfgSetup):
-    class Grpc(CfgSetup.Common):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-        def set_parameters_to_edb(self):
-            if self.parent.name in self.pedb.setups:
-                raise "Setup {} already existing. Editing it.".format(self.parent.name)
-
-            edb_setup = self.pedb.create_hfss_setup(self.parent.name)
-            edb_setup.set_solution_single_frequency(
-                self.parent.f_adapt, self.parent.max_num_passes, self.parent.max_mag_delta_s
+    def set_parameters_to_edb(self):
+        if self.name in self.pedb.setups:
+            raise "Setup {} already existing. Editing it.".format(self.name)
+
+        edb_setup = self.pedb.create_hfss_setup(self.name)
+        edb_setup.set_solution_single_frequency(self.f_adapt, self.max_num_passes, self.max_mag_delta_s)
+
+        self.apply_freq_sweep(edb_setup)
+
+        for i in self.mesh_operations:
+            edb_setup.add_length_mesh_operation(
+                name=i["name"],
+                max_elements=i.get("max_elements", 1000),
+                max_length=i.get("max_length", "1mm"),
+                restrict_length=i.get("restrict_length", True),
+                refine_inside=i.get("refine_inside", False),
+                # mesh_region=i.get(mesh_region),
+                net_layer_list=i.get("nets_layers_list", {}),
             )
 
-            self._apply_freq_sweep(edb_setup)
-
-            for i in self.parent.mesh_operations:
-                edb_setup.add_length_mesh_operation(
-                    name=i["name"],
-                    max_elements=i.get("max_elements", 1000),
-                    max_length=i.get("max_length", "1mm"),
-                    restrict_length=i.get("restrict_length", True),
-                    refine_inside=i.get("refine_inside", False),
-                    # mesh_region=i.get(mesh_region),
-                    net_layer_list=i.get("nets_layers_list", {}),
-                )
-
-        def retrieve_parameters_from_edb(self):
-            self._retrieve_parameters_from_edb_common()
-            single_frequency_adaptive_solution = self.pyedb_obj.settings.general.single_frequency_adaptive_solution
-            self.parent.f_adapt = single_frequency_adaptive_solution.adaptive_frequency
-            self.parent.max_num_passes = single_frequency_adaptive_solution.max_passes
-            self.parent.max_mag_delta_s = float(single_frequency_adaptive_solution.max_delta)
-            self.parent.freq_sweep = []
-            setup_sweeps = self.sort_sweep_data(self.pyedb_obj.sweep_data)
-            for setup_name, sweeps in setup_sweeps.items():
-                sw_name = sweeps[0].name
-                sw_type = sweeps[0].type.name.lower().split("_")[0]
-                freq_strings = [f.frequency_string for f in sweeps]
-                self.parent.freq_sweep.append({"name": sw_name, "type": sw_type, "frequencies": freq_strings})
-
-            self.parent.mesh_operations = []
-            from ansys.edb.core.simulation_setup.mesh_operation import (
-                LengthMeshOperation as GrpcLengthMeshOperation,
+    def retrieve_parameters_from_edb(self):
+        adaptive_frequency_data_list = list(self.pyedb_obj.adaptive_settings.adaptive_frequency_data_list)[0]
+        self.f_adapt = adaptive_frequency_data_list.adaptive_frequency
+        self.max_num_passes = adaptive_frequency_data_list.max_passes
+        self.max_mag_delta_s = adaptive_frequency_data_list.max_delta
+        self.freq_sweep = []
+        for name, sw in self.pyedb_obj.sweeps.items():
+            self.freq_sweep.append({"name": name, "type": sw.type, "frequencies": sw.frequency_string})
+
+        self.mesh_operations = []
+        for name, mop in self.pyedb_obj.mesh_operations.items():
+            self.mesh_operations.append(
+                {
+                    "name": name,
+                    "type": mop.type,
+                    "max_elements": mop.max_elements,
+                    "max_length": mop.max_length,
+                    "restrict_length": mop.restrict_length,
+                    "refine_inside": mop.refine_inside,
+                    "nets_layers_list": mop.nets_layers_list,
+                }
             )
 
-            for mesh_op in self.pyedb_obj.mesh_operations:
-                if isinstance(mesh_op, GrpcLengthMeshOperation):
-                    mop_type = "length"
-                else:
-                    mop_type = "skin"
-                self.parent.mesh_operations.append(
-                    {
-                        "name": mesh_op.name,
-                        "type": mop_type,
-                        "max_elements": mesh_op.max_elements,
-                        "max_length": mesh_op.max_length,
-                        "restrict_length": mesh_op.restrict_max_length,
-                        "refine_inside": mesh_op.refine_inside,
-                        "nets_layers_list": mesh_op.net_layer_info,
-                    }
-                )
-
-        @staticmethod
-        def sort_sweep_data(sweep_data):
-            """grpc sweep data contains all sweeps for each setup, we need to sort thwm by setup"""
-            setups = {}
-            for sweep in sweep_data:
-                if sweep.name not in setups:
-                    setups[sweep.name] = [sweep]
-                else:
-                    setups[sweep.name].append(sweep)
-            return setups
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-        def retrieve_parameters_from_edb(self):
-            self._retrieve_parameters_from_edb_common()
-            adaptive_frequency_data_list = list(self.pyedb_obj.adaptive_settings.adaptive_frequency_data_list)[0]
-            self.parent.f_adapt = adaptive_frequency_data_list.adaptive_frequency
-            self.parent.max_num_passes = adaptive_frequency_data_list.max_passes
-            self.parent.max_mag_delta_s = adaptive_frequency_data_list.max_delta
-            self.parent.freq_sweep = []
-            for name, sw in self.pyedb_obj.sweeps.items():
-                self.parent.freq_sweep.append({"name": name, "type": sw.type, "frequencies": sw.frequency_string})
-
-            self.parent.mesh_operations = []
-            for name, mop in self.pyedb_obj.mesh_operations.items():
-                self.parent.mesh_operations.append(
-                    {
-                        "name": name,
-                        "type": mop.type,
-                        "max_elements": mop.max_elements,
-                        "max_length": mop.max_length,
-                        "restrict_length": mop.restrict_length,
-                        "refine_inside": mop.refine_inside,
-                        "nets_layers_list": mop.nets_layers_list,
-                    }
-                )
-
     def __init__(self, pedb, pyedb_obj, **kwargs):
         super().__init__(pedb, pyedb_obj, **kwargs)
         self.type = "hfss"
@@ -354,70 +195,36 @@ class CfgHFSSSetup(CfgSetup):
 
 
 class CfgSetups:
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent.pedb
-
-        def retrieve_parameters_from_edb(self):
-            self.parent.setups = []
-            for _, setup in self._pedb.setups.items():
-                if setup.type.name.lower() == "hfss":
-                    hfss = CfgHFSSSetup(self._pedb, setup)
-                    hfss.api.retrieve_parameters_from_edb()
-                    self.parent.setups.append(hfss)
-                elif setup.type.name.lower() == "si_wave_dcir":
-                    siwave_dc = CfgSIwaveDCSetup(self._pedb, setup)
-                    siwave_dc.api.retrieve_parameters_from_edb()
-                    self.parent.setups.append(siwave_dc)
-                elif setup.type.name.lower() == "si_wave":
-                    siwave_ac = CfgSIwaveACSetup(self._pedb, setup)
-                    siwave_ac.api.retrieve_parameters_from_edb()
-                    self.parent.setups.append(siwave_ac)
-                elif setup.type.name.lower() == "raptor_x":
-                    pass
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-        def retrieve_parameters_from_edb(self):
-            self.parent.setups = []
-            for _, setup in self._pedb.setups.items():
-                if setup.type == "hfss":
-                    hfss = CfgHFSSSetup(self._pedb, setup)
-                    hfss.api.retrieve_parameters_from_edb()
-                    self.parent.setups.append(hfss)
-                elif setup.type == "siwave_dc":
-                    siwave_dc = CfgSIwaveDCSetup(self._pedb, setup)
-                    siwave_dc.api.retrieve_parameters_from_edb()
-                    self.parent.setups.append(siwave_dc)
-                elif setup.type == "siwave_ac":
-                    siwave_ac = CfgSIwaveACSetup(self._pedb, setup)
-                    siwave_ac.api.retrieve_parameters_from_edb()
-                    self.parent.setups.append(siwave_ac)
+    def retrieve_parameters_from_edb(self):
+        self.setups = []
+        for _, setup in self._pedb.setups.items():
+            if setup.type == "hfss":
+                hfss = CfgHFSSSetup(self._pedb, setup, name=setup.name)
+                hfss.retrieve_parameters_from_edb()
+                self.setups.append(hfss)
+            elif setup.type == "siwave_dc":
+                siwave_dc = CfgSIwaveDCSetup(self._pedb, setup, name=setup.name)
+                siwave_dc.retrieve_parameters_from_edb()
+                self.setups.append(siwave_dc)
+            elif setup.type == "siwave_ac":
+                siwave_ac = CfgSIwaveACSetup(self._pedb, setup, name=setup.name)
+                siwave_ac.retrieve_parameters_from_edb()
+                self.setups.append(siwave_ac)
 
     def __init__(self, pedb, setups_data):
-        self.pedb = pedb
+        self._pedb = pedb
         self.setups = []
-        if self.pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
         for stp in setups_data:
             if stp["type"].lower() == "hfss":
-                self.setups.append(CfgHFSSSetup(self.pedb, None, **stp))
+                self.setups.append(CfgHFSSSetup(self._pedb, None, **stp))
             elif stp["type"].lower() in ["siwave_ac", "siwave_syz"]:
-                self.setups.append(CfgSIwaveACSetup(self.pedb, None, **stp))
+                self.setups.append(CfgSIwaveACSetup(self._pedb, None, **stp))
             elif stp["type"].lower() == "siwave_dc":
-                self.setups.append(CfgSIwaveDCSetup(self.pedb, None, **stp))
+                self.setups.append(CfgSIwaveDCSetup(self._pedb, None, **stp))
 
     def apply(self):
         for s in self.setups:
-            s.api.set_parameters_to_edb()
+            s.set_parameters_to_edb()
 
     def to_dict(self):
         return [i.to_dict() for i in self.setups]
-
-    def retrieve_parameters_from_edb(self):
-        self.api.retrieve_parameters_from_edb()

pyedb/configuration/configuration.py

@@ -147,7 +147,7 @@ class Configuration:
         self.__apply_with_logging("Applying modeler", self.apply_modeler)
         self.__apply_with_logging("Placing ports", self.cfg_data.ports.apply)
         self.__apply_with_logging("Placing probes", self.cfg_data.probes.apply)
-        self.__apply_with_logging("Applying operations", self.cfg_data.operations.apply)
+        self.__apply_with_logging("Applying operations", self.apply_operations)
 
         return True
 
@@ -187,7 +187,7 @@ class Configuration:
                 pdef.SetData(pdata)
                 pdef = self._pedb.pedb_class.database.edb_data.padstacks_data.EDBPadstack(pdef, self._pedb.padstacks)
                 p.pyedb_obj = pdef
-                p.api.set_parameters_to_edb()
+                p.set_parameters_to_edb()
 
         if modeler.padstack_instances:
             for p in modeler.padstack_instances:
@@ -199,7 +199,7 @@ class Configuration:
                     rotation=p.rotation if p.rotation is not None else 0,
                 )
                 p.pyedb_obj = p_inst
-                p.api.set_parameters_to_edb()
+                p.set_parameters_to_edb()
 
         if modeler.planes:
             for p in modeler.planes:
@@ -244,7 +244,7 @@ class Configuration:
                     component_part_name=c.definition,
                 )
                 c.pyedb_obj = obj
-                c.api.set_parameters_to_edb()
+                c.set_parameters_to_edb()
 
         primitives = self._pedb.layout.find_primitive(**modeler.primitives_to_delete)
         for i in primitives:
@@ -418,6 +418,7 @@ class Configuration:
         self.get_variables()
         self.get_materials()
         self.get_stackup()
+        self.get_operations()
 
         data = {}
         if kwargs.get("general", False):
@@ -453,7 +454,7 @@ class Configuration:
         if kwargs.get("pin_groups", False):
             data["pin_groups"] = self.cfg_data.pin_groups.get_data_from_db()
         if kwargs.get("operations", False):
-            data["operations"] = self.cfg_data.operations.get_data_from_db()
+            data["operations"] = self.cfg_data.operations.model_dump()
         if kwargs.get("padstacks", False):
             self.cfg_data.padstacks.retrieve_parameters_from_edb()
             definitions = []
@@ -471,6 +472,64 @@ class Configuration:
 
         return data
 
+    def apply_operations(self):
+        """Apply operations to the current design."""
+        op_cutout = self.cfg_data.operations.cutout
+        if op_cutout:
+            cutout_params = op_cutout.model_dump()
+            auto_identify_nets = cutout_params.pop("auto_identify_nets")
+            if auto_identify_nets["enabled"]:
+                reference_list = cutout_params.get("reference_list", [])
+                if auto_identify_nets:
+                    self._pedb.nets.generate_extended_nets(
+                        auto_identify_nets["resistor_below"],
+                        auto_identify_nets["inductor_below"],
+                        auto_identify_nets["capacitor_above"],
+                        auto_identify_nets.get("exception_list", []),
+                    )
+                    signal_nets = []
+                    for i in self._pedb.terminals.values():
+                        if i.net_name in reference_list:
+                            continue
+
+                        extended_net = i.net.extended_net
+                        if extended_net:
+                            temp = [i2 for i2 in extended_net.nets.keys() if i2 not in reference_list]
+                            temp = [i2 for i2 in temp if i2 not in signal_nets]
+                            signal_nets.extend(temp)
+                        else:
+                            signal_nets.append(i.net_name)
+
+                    cutout_params["signal_list"] = signal_nets
+            polygon_points = self._pedb.cutout(**cutout_params)
+            if "pyedb_cutout" not in self._pedb.stackup.all_layers:
+                self._pedb.stackup.add_document_layer(name="pyedb_cutout")
+                self._pedb.modeler.create_polygon(polygon_points, layer_name="pyedb_cutout", net_name="pyedb_cutout")
+
+    def get_operations(self):
+        if "pyedb_cutout" not in self._pedb.stackup.all_layers:
+            return
+
+        polygons = self._pedb.layout.find_primitive(layer_name="pyedb_cutout")
+        if polygons:
+            poly = polygons[0]
+            custom_extent = poly.polygon_data.points
+            net_names = []
+            for name, obj in self._pedb.nets.nets.items():
+                if obj.primitives:
+                    if obj.primitives[0].layer.name == "pyedb_cutout":
+                        continue
+                    else:
+                        net_names.append(name)
+            reference_list = []
+            signal_list = net_names
+
+            self.cfg_data.operations.add_cutout(
+                custom_extent=custom_extent,
+                reference_list=reference_list,
+                signal_list=signal_list,
+            )
+
     def export(
         self,
         file_path,

pyedb/dotnet/database/cell/connectable.py

@@ -55,10 +55,11 @@ class Connectable(LayoutObj):
         -------
         str
         """
-        try:
-            return self._edb_object.GetNet().GetName()
-        except (KeyError, AttributeError):  # pragma: no cover
-            return None
+        net = self._edb_object.GetNet()
+        if net.IsNull():
+            return ""
+        else:
+            return net.GetName()
 
     @net_name.setter
     def net_name(self, name):
@@ -76,10 +77,38 @@ class Connectable(LayoutObj):
         -------
         :class:`dotnet.database.edb_data.nets_data.EDBComponent`
         """
-        from pyedb.dotnet.database.cell.hierarchy.component import EDBComponent
+        return self._pedb.layout.find_component_by_name(self.component_name) if self.component_name else ""
+
+    @component.setter
+    def component(self, value):
+        self._edb_object.SetGroup(self._pedb.components.instances[value]._edb_object)
 
-        edb_comp = self._edb_object.GetComponent()
-        if edb_comp.IsNull():
-            return None
+    @property
+    def component_name(self):
+        """Get the name of the component connected to this object."""
+        comp = self._edb_object.GetComponent()
+        if comp.IsNull():
+            return ""
         else:
-            return EDBComponent(self._pedb, edb_comp)
+            return comp.GetName()
+
+    def get_connected_objects(self):
+        """Get connected objects.
+
+        Returns
+        -------
+        list
+        """
+        return self._pedb.get_connected_objects(self._layout_obj_instance)
+
+    def get_connected_object_id_set(self):
+        """Produce a list of all geometries physically connected to a given layout object.
+
+        Returns
+        -------
+        list
+            Found connected objects IDs with Layout object.
+        """
+        layoutInst = self._edb_object.GetLayout().GetLayoutInstance()
+        layoutObjInst = layoutInst.GetLayoutObjInstance(self._edb_object, None)  # 2nd arg was []
+        return [loi.GetLayoutObj().GetId() for loi in layoutInst.GetConnectedObjects(layoutObjInst).Items]