pyedb 0.12.2__py3-none-any.whl → 0.13.dev0__py3-none-any.whl

pyedb/configuration/cfg_stackup.py

@@ -20,34 +20,68 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-
+from pyedb.configuration.cfg_common import CfgBase
 from pyedb.generic.general_methods import pyedb_function_handler
 
 
+class CfgMaterial(CfgBase):
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name", None)
+        self.permittivity = kwargs.get("permittivity", None)
+        self.conductivity = kwargs.get("conductivity", None)
+        self.dielectric_loss_tangent = kwargs.get("dielectric_loss_tangent", None)
+        self.magnetic_loss_tangent = kwargs.get("magnetic_loss_tangent", None)
+        self.mass_density = kwargs.get("mass_density", None)
+        self.permeability = kwargs.get("permeability", None)
+        self.poisson_ratio = kwargs.get("poisson_ratio", None)
+        self.specific_heat = kwargs.get("specific_heat", None)
+        self.thermal_conductivity = kwargs.get("thermal_conductivity", None)
+
+
+class CfgLayer(CfgBase):
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name", None)
+        self.type = kwargs.get("type", None)
+        self.material = kwargs.get("material", None)
+        self.fill_material = kwargs.get("fill_material", None)
+        self.thickness = kwargs.get("thickness", None)
+
+
 class CfgStackup:
     def __init__(self, pedb, data):
         self._pedb = pedb
 
-        self.materials = [CfgMaterial(self._pedb, **mat) for mat in data.get("materials", [])]
-        self.layers = [CfgLayer(self._pedb, **lay) for lay in data.get("layers", [])]
+        self.materials = [CfgMaterial(**mat) for mat in data.get("materials", [])]
+        self.layers = [CfgLayer(**lay) for lay in data.get("layers", [])]
 
     @pyedb_function_handler
     def apply(self):
         """Apply configuration settings to the current design"""
         if len(self.materials):
             self.__apply_materials()
+
+        input_signal_layers = [i for i in self.layers if i.type.lower() == "signal"]
+
         if len(self.layers):
-            self.__apply_layers()
+            if len(self._pedb.stackup.signal_layers) == 0:
+                self.__create_stackup()
+            elif not len(input_signal_layers) == len(self._pedb.stackup.signal_layers):
+                raise Exception(f"Input signal layer count do not match.")
+            else:
+                self.__apply_layers()
+
+    def __create_stackup(self):
+        layers = list()
+        layers.extend(self.layers)
+        for l_attrs in layers:
+            attrs = l_attrs.get_attributes()
+            self._pedb.stackup.add_layer_bottom(**attrs)
 
     @pyedb_function_handler
     def __apply_layers(self):
         """Apply layer settings to the current design"""
         layers = list()
         layers.extend(self.layers)
-        input_signal_layers = [i for i in layers if i.type.lower() == "signal"]
-        if not len(input_signal_layers) == len(self._pedb.stackup.signal_layers):
-            self._pedb.logger.error("Input signal layer count do not match.")
-            return False
 
         removal_list = []
         lc_signal_layers = []
@@ -66,9 +100,7 @@ class CfgStackup:
             if l.type == "signal":
                 layer_id = lc_signal_layers[signal_idx]
                 layer_name = id_name[layer_id]
-                attrs = {
-                    i: j for i, j in l.__dict__.items() if not i.startswith("_") and isinstance(j, (int, float, str))
-                }
+                attrs = l.get_attributes()
                 self._pedb.stackup.layers[layer_name].update(**attrs)
                 signal_idx = signal_idx + 1
 
@@ -79,13 +111,11 @@ class CfgStackup:
         if l.type == "signal":
             prev_layer_clone = self._pedb.stackup.layers[l.name]
         else:
-            attrs = {i: j for i, j in l.__dict__.items() if not i.startswith("_") and isinstance(j, (int, float, str))}
+            attrs = l.get_attributes()
             prev_layer_clone = self._pedb.stackup.add_layer_top(**attrs)
         for idx, l in enumerate(layers):
             if l.type == "dielectric":
-                attrs = {
-                    i: j for i, j in l.__dict__.items() if not i.startswith("_") and isinstance(j, (int, float, str))
-                }
+                attrs = l.get_attributes()
                 prev_layer_clone = self._pedb.stackup.add_layer_below(base_layer_name=prev_layer_clone.name, **attrs)
             elif l.type == "signal":
                 prev_layer_clone = self._pedb.stackup.layers[l.name]
@@ -98,38 +128,42 @@ class CfgStackup:
             if mat_in_cfg.name.lower() in materials_in_db:
                 self._pedb.materials.delete_material(materials_in_db[mat_in_cfg.name.lower()])
 
-            attrs = {
-                i: j
-                for i, j in mat_in_cfg.__dict__.items()
-                if not i.startswith("_") and isinstance(j, (int, float, str))
-            }
+            attrs = mat_in_cfg.get_attributes()
             mat = self._pedb.materials.add_material(**attrs)
 
+    @pyedb_function_handler
+    def __get_materials_from_db(self):
+        materials = []
+        for name, p in self._pedb.materials.materials.items():
+            mat = {}
+            for p_name in CfgMaterial().__dict__:
+                mat[p_name] = getattr(p, p_name)
+            materials.append(mat)
+        return materials
 
-class CfgMaterial:
-    def __init__(self, pedb, **kwargs):
-        self._pedb = pedb
-        self.name = kwargs.get("name")
-        self.permittivity = kwargs.get("permittivity", None)
-        self.conductivity = kwargs.get("conductivity", None)
-        self.dielectric_loss_tangent = kwargs.get("dielectric_loss_tangent", None)
-        self.magnetic_loss_tangent = kwargs.get("magnetic_loss_tangent", None)
-        self.mass_density = kwargs.get("mass_density", None)
-        self.permeability = kwargs.get("permeability", None)
-        self.poisson_ratio = kwargs.get("poisson_ratio", None)
-        self.specific_heat = kwargs.get("specific_heat", None)
-        self.thermal_conductivity = kwargs.get("thermal_conductivity", None)
-        self.youngs_modulus = kwargs.get("youngs_modulus", None)
-        self.thermal_expansion_coefficient = kwargs.get("thermal_expansion_coefficient", None)
-
+    @pyedb_function_handler
+    def __get_layers_from_db(self):
+        layers = []
+        for name, obj in self._pedb.stackup.all_layers.items():
+            layer = {}
+            for p_name in CfgLayer().__dict__:
+                p_value = getattr(obj, p_name, None)
+                if p_value is not None:
+                    layer[p_name] = getattr(obj, p_name)
+            layers.append(layer)
+        return layers
 
-class CfgLayer:
-    def __init__(self, pedb, **kwargs):
-        self._pedb = pedb
-        self.name = kwargs.get("name", None)
-        self.type = kwargs.get("type", None)
-        self.material = kwargs.get("material", None)
-        self.fill_material = kwargs.get("fill_material", None)
-        self.thickness = kwargs.get("thickness", None)
-        self.etch_factor = kwargs.get("etch_factor", None)
-        self.lower_elevation = kwargs.get("lower_elevation", None)
+    @pyedb_function_handler
+    def get_data_from_db(self):
+        """Get configuration data from layout.
+
+        Returns
+        -------
+        dict
+        """
+        stackup = {}
+        materials = self.__get_materials_from_db()
+        stackup["materials"] = materials
+        layers = self.__get_layers_from_db()
+        stackup["layers"] = layers
+        return stackup

pyedb/configuration/configuration.py

@@ -22,6 +22,7 @@
 
 import json
 import os
+from pathlib import Path
 
 import toml
 
@@ -115,9 +116,7 @@ class Configuration:
             self.cfg_data.nets.apply()
 
         # Configure components
-        if self.cfg_data.components:
-            for comp in self.cfg_data.components:
-                comp.apply()
+        self.cfg_data.components.apply()
 
         # Configure padstacks
         if self.cfg_data.padstacks:
@@ -151,12 +150,10 @@ class Configuration:
             spice_model.apply()
 
         # Configure package definitions
-        if "package_definitions" in self.data:
-            self._load_package_def()
+        self.cfg_data.package_definitions.apply()
 
         # Configure operations
-        if "operations" in self.data:
-            self._load_operations()
+        self.cfg_data.operations.apply()
 
         return True
 
@@ -217,14 +214,6 @@ class Configuration:
                 elif l["type"] == "signal":
                     prev_layer_clone = self._pedb.stackup.layers[l["name"]]
 
-    @pyedb_function_handler
-    def _load_operations(self):
-        """Imports operation information from JSON."""
-        operations = self.data["operations"]
-        cutout = operations.get("cutout", None)
-        if cutout:
-            self._pedb.cutout(**cutout)
-
     @pyedb_function_handler
     def _load_package_def(self):
         """Imports package definition information from JSON."""
@@ -268,3 +257,44 @@ class Configuration:
                 )
             for _, i in comp_list.items():
                 i.package_def = name
+
+    def get_data_from_db(self, **kwargs):
+        """Get configuration data from layout.
+
+        Parameters
+        ----------
+        stackup
+
+        Returns
+        -------
+
+        """
+        data = {}
+        if kwargs.get("stackup", False):
+            data["stackup"] = self.cfg_data.stackup.get_data_from_db()
+        if kwargs.get("package_definitions", False):
+            data["package_definitions"] = self.cfg_data.package_definitions.get_data_from_db()
+
+        return data
+
+    @pyedb_function_handler
+    def export(self, file_path, stackup=True, package_definitions=True):
+        """Export the configuration data from layout to a file.
+
+        Parameters
+        ----------
+        file_path : str, Path
+            File path to export the configuration data.
+        stackup : bool
+            Whether to export stackup or not.
+
+        Returns
+        -------
+        bool
+        """
+        file_path = file_path if isinstance(file_path, Path) else Path(file_path)
+        file_path = file_path if file_path.suffix == ".json" else file_path.with_suffix(".json")
+        data = self.get_data_from_db(stackup=stackup, package_definitions=package_definitions)
+        with open(file_path, "w") as f:
+            json.dump(data, f, ensure_ascii=False, indent=4)
+        return True if os.path.isfile(file_path) else False

pyedb/dotnet/edb.py

@@ -27,12 +27,14 @@ This module is implicitly loaded in HFSS 3D Layout when launched.
 """
 from itertools import combinations
 import os
+from pathlib import Path
 import re
 import shutil
 import sys
 import tempfile
 import time
 import traceback
+from typing import Union
 import warnings
 
 from pyedb.configuration.configuration import Configuration
@@ -111,6 +113,8 @@ if is_linux and is_ironpython:
 else:
     import subprocess
 
+import rtree
+
 
 class Edb(Database):
     """Provides the EDB application interface.
@@ -180,7 +184,7 @@ class Edb(Database):
 
     def __init__(
         self,
-        edbpath: str = None,
+        edbpath: Union[str, Path] = None,
         cellname: str = None,
         isreadonly: bool = False,
         edbversion: str = None,
@@ -191,6 +195,9 @@ class Edb(Database):
         technology_file: str = None,
         remove_existing_aedt: bool = False,
     ):
+        if isinstance(edbpath, Path):
+            edbpath = str(edbpath)
+
         edbversion = get_string_version(edbversion)
         self._clean_variables()
         Database.__init__(self, edbversion=edbversion, student_version=student_version)
@@ -315,7 +322,9 @@ class Edb(Database):
             if os.path.isfile(file):
                 if not remove_existing_aedt:
                     self.logger.warning(
-                        f"AEDT project-related file {file} exists and may need to be deleted before opening the EDB in HFSS 3D Layout."  # noqa: E501
+                        f"AEDT project-related file {file} exists and may need to be deleted before opening the EDB in "
+                        f"HFSS 3D Layout."
+                        # noqa: E501
                     )
                 else:
                     try:
@@ -1523,12 +1532,11 @@ class Edb(Database):
             ``True`` when successful, ``False`` when failed.
 
         """
-        if tech_file or map_file:
-            control_file_temp = os.path.join(tempfile.gettempdir(), os.path.split(inputGDS)[-1][:-3] + "xml")
-            ControlFile(xml_input=control_file, tecnhology=tech_file, layer_map=map_file).write_xml(control_file_temp)
-        elif tech_file:
+        if not is_linux and tech_file:
             self.logger.error("Technology files are supported only in Linux. Use control file instead.")
             return False
+        control_file_temp = os.path.join(tempfile.gettempdir(), os.path.split(inputGDS)[-1][:-3] + "xml")
+        ControlFile(xml_input=control_file, tecnhology=tech_file, layer_map=map_file).write_xml(control_file_temp)
         if self.import_layout_pcb(
             inputGDS,
             working_dir=WorkDir,
@@ -4314,7 +4322,7 @@ class Edb(Database):
     @pyedb_function_handler
     def _clean_string_for_variable_name(self, variable_name):
         """Remove forbidden character for variable name.
-        Parameter
+        Parameters
         ----------
         variable_name : str
                 Variable name.
@@ -4331,6 +4339,158 @@ class Edb(Database):
 
         return variable_name
 
+    def create_model_for_arbitrary_wave_ports(
+        self,
+        temp_directory,
+        mounting_side="top",
+        signal_nets=None,
+        terminal_diameter=None,
+        output_edb=None,
+        launching_box_thickness="100um",
+    ):
+        """Generate EDB design to be consumed by PyAEDT to generate arbitrary wave ports shapes.
+        This model has to be considered as merged onto another one. The current opened design must have voids
+        surrounding the pad-stacks where wave ports terminal will be created. THe open design won't be edited, only
+        primitives like voids and pads-stack definition included in the voids are collected to generate a new design.
+
+        Parameters
+        ----------
+        temp_directory : str
+            Temporary directory used during the method execution.
+
+        mounting_side : str
+            Gives the orientation to be considered for the current design. 2 options are available ``"top"`` and
+            ``"bottom". Default value is ``"top"``. If ``"top"`` is selected the method will voids at the top signal
+            layer, and the bottom layer if ``"bottom"`` is used.
+
+        signal_nets : List[str], optional
+            Provides the nets to be included for the model creation. Default value is ``None``. If None is provided,
+            all nets will be included.
+
+        terminal_diameter : float, str, optional
+            When ``None``, the terminal diameter is evaluated at each pads-tack instance found inside the voids. The top
+            or bottom layer pad diameter will be taken, depending on ``mounting_side`` selected. If value is provided,
+            it will overwrite the evaluated diameter.
+
+        output_edb : str, optional
+            The output EDB absolute. If ``None`` the edb is created in the ``temp_directory`` as default name
+            `"waveport_model.aedb"``
+
+        launching_box_thickness : float, str, optional
+            Launching box thickness  used for wave ports. Default value is ``"100um"``.
+
+        Returns
+        -------
+        bool
+            ``True`` when succeeded, ``False`` if failed.
+        """
+        if not temp_directory:
+            self.logger.error("Temp directory must be provided when creating model foe arbitrary wave port")
+            return False
+        if not output_edb:
+            output_edb = os.path.join(temp_directory, "waveport_model.aedb")
+        if os.path.isdir(temp_directory):
+            shutil.rmtree(temp_directory)
+        reference_layer = list(self.stackup.signal_layers.keys())[0]
+        if mounting_side.lower == "bottom":
+            reference_layer = list(self.stackup.signal_layers.keys())[-1]
+        if not signal_nets:
+            signal_nets = list(self.nets.signal.keys())
+
+        used_padstack_defs = []
+        padstack_instances_index = rtree.index.Index()
+        for padstack_inst in list(self.padstacks.instances.values()):
+            if not reference_layer in [padstack_inst.start_layer, padstack_inst.stop_layer]:
+                padstack_inst.delete()
+            else:
+                if padstack_inst.net_name in signal_nets:
+                    padstack_instances_index.insert(padstack_inst.id, padstack_inst.position)
+                    if not padstack_inst.padstack_definition in used_padstack_defs:
+                        used_padstack_defs.append(padstack_inst.padstack_definition)
+
+        polys = [
+            poly
+            for poly in self.modeler.primitives
+            if poly.layer_name == reference_layer and poly.type == "Polygon" and poly.has_voids
+        ]
+        if not polys:
+            self.logger.error(
+                f"No polygon found with voids on layer {reference_layer} during model creation for "
+                f"arbitrary wave ports"
+            )
+            return False
+        void_padstacks = []
+        for poly in polys:
+            for void in poly.voids:
+                void_bbox = (
+                    void.polygon_data.edb_api.GetBBox().Item1.X.ToDouble(),
+                    void.polygon_data.edb_api.GetBBox().Item1.Y.ToDouble(),
+                    void.polygon_data.edb_api.GetBBox().Item2.X.ToDouble(),
+                    void.polygon_data.edb_api.GetBBox().Item2.Y.ToDouble(),
+                )
+                included_instances = list(padstack_instances_index.intersection(void_bbox))
+                if included_instances:
+                    void_padstacks.append((void, [self.padstacks.instances[edb_id] for edb_id in included_instances]))
+
+        if not void_padstacks:
+            self.logger.error(
+                "No padstack instances found inside evaluated voids during model creation for arbitrary" "waveports"
+            )
+            return False
+        cloned_edb = Edb(edbpath=output_edb, edbversion=self.edbversion)
+        cloned_edb.stackup.add_layer(layer_name="ref", layer_type="signal", thickness=0.0, material="pec")
+        cloned_edb.stackup.add_layer(
+            layer_name="ports",
+            layer_type="signal",
+            thickness=self.stackup.signal_layers[reference_layer].thickness,
+            material="pec",
+        )
+        box_thick = "100um"
+        if launching_box_thickness:
+            box_thick = self.edb_value(launching_box_thickness).ToString()
+        if mounting_side == "top":
+            cloned_edb.stackup.add_layer(
+                layer_name="port_pec", layer_type="signal", thickness=box_thick, method="add_on_bottom", material="pec"
+            )
+        else:
+            cloned_edb.stackup.add_layer(
+                layer_name="port_pec", layer_type="signal", thickness=box_thick, method="add_on_top", material="pec"
+            )
+
+        for void_info in void_padstacks:
+            port_poly = cloned_edb.modeler.create_polygon(
+                main_shape=void_info[0].polygon_data.edb_api, layer_name="ref", net_name="GND"
+            )
+            pec_poly = cloned_edb.modeler.create_polygon(
+                main_shape=port_poly.polygon_data.edb_api, layer_name="port_pec", net_name="GND"
+            )
+            pec_poly.scale(1.5)
+
+        for void_info in void_padstacks:
+            for inst in void_info[1]:
+                if not terminal_diameter:
+                    pad_diameter = (
+                        self.padstacks.definitions[inst.padstack_definition]
+                        .pad_by_layer[reference_layer]
+                        .parameters_values[0]
+                    )
+                else:
+                    pad_diameter = self.edb_value(terminal_diameter).ToDouble()
+                _temp_circle = cloned_edb.modeler.create_circle(
+                    layer_name="ports",
+                    x=inst.position[0],
+                    y=inst.position[1],
+                    radius=pad_diameter / 2,
+                    net_name=inst.net_name,
+                )
+                if not _temp_circle:
+                    self.logger.error(
+                        f"Failed to create circle for terminal during create_model_for_arbitrary_wave_ports"
+                    )
+        cloned_edb.save_as(output_edb)
+        cloned_edb.close()
+        return True
+
     @property
     def definitions(self):
         """Definitions class."""

pyedb/dotnet/edb_core/cell/hierarchy/model.py

@@ -20,7 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from pyedb.dotnet.edb_core.obj_base import ObjBase
+from pyedb.dotnet.edb_core.utilities.obj_base import ObjBase
 from pyedb.generic.general_methods import pyedb_function_handler
 
 

pyedb/dotnet/edb_core/{edb_data/connectable.py → cell/layout_obj.py}

@@ -20,7 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from pyedb.dotnet.edb_core.obj_base import ObjBase
+from pyedb.dotnet.edb_core.utilities.obj_base import ObjBase
 from pyedb.generic.general_methods import pyedb_function_handler
 
 

pyedb/dotnet/edb_core/cell/primitive.py

@@ -0,0 +1,142 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from pyedb.dotnet.edb_core.cell.layout_obj import Connectable
+
+
+class Primitive(Connectable):
+    """Manages EDB functionalities for a primitives.
+
+    It inherits EDB Object properties.
+
+    Examples
+    --------
+    >>> from pyedb import Edb
+    >>> edb = Edb(myedb, edbversion="2021.2")
+    >>> edb_prim = edb.modeler.primitives[0]
+    >>> edb_prim.is_void # Class Property
+    >>> edb_prim.IsVoid() # EDB Object Property
+    """
+
+    def __init__(self, pedb, edb_object):
+        super().__init__(pedb, edb_object)
+        self._app = self._pedb
+        self._core_stackup = pedb.stackup
+        self._core_net = pedb.nets
+        self.primitive_object = self._edb_object
+
+    @property
+    def type(self):
+        """Return the type of the primitive.
+
+        Expected output is among ``"Circle"``, ``"Rectangle"``,``"Polygon"``,``"Path"`` or ``"Bondwire"``.
+
+        Returns
+        -------
+        str
+        """
+        try:
+            return self._edb_object.GetPrimitiveType().ToString()
+        except AttributeError:  # pragma: no cover
+            return ""
+
+    @property
+    def net_name(self):
+        """Get the primitive net name.
+
+        Returns
+        -------
+        str
+        """
+        return self.net.GetName()
+
+    @net_name.setter
+    def net_name(self, name):
+        if isinstance(name, str):
+            net = self._app.nets.nets[name].net_object
+            self.primitive_object.SetNet(net)
+        else:
+            try:
+                self.net = name.name
+            except:  # pragma: no cover
+                self._app.logger.error("Failed to set net name.")
+
+    @property
+    def layer(self):
+        """Get the primitive edb layer object."""
+        try:
+            layer_name = self.primitive_object.GetLayer().GetName()
+            return self._pedb.stackup.layers[layer_name]
+        except (KeyError, AttributeError):  # pragma: no cover
+            return None
+
+    @property
+    def layer_name(self):
+        """Get the primitive layer name.
+
+        Returns
+        -------
+        str
+        """
+        try:
+            return self.layer.name
+        except (KeyError, AttributeError):  # pragma: no cover
+            return None
+
+    @layer_name.setter
+    def layer_name(self, val):
+        layer_list = list(self._core_stackup.layers.keys())
+        if isinstance(val, str) and val in layer_list:
+            layer = self._core_stackup.layers[val]._edb_layer
+            if layer:
+                self.primitive_object.SetLayer(layer)
+            else:
+                raise AttributeError("Layer {} not found.".format(val))
+        elif isinstance(val, type(self._core_stackup.layers[layer_list[0]])):
+            try:
+                self.primitive_object.SetLayer(val._edb_layer)
+            except:
+                raise AttributeError("Failed to assign new layer on primitive.")
+        else:
+            raise AttributeError("Invalid input value")
+
+    @property
+    def is_void(self):
+        """Either if the primitive is a void or not.
+
+        Returns
+        -------
+        bool
+        """
+        try:
+            return self._edb_object.IsVoid()
+        except AttributeError:  # pragma: no cover
+            return None
+
+    def get_connected_objects(self):
+        """Get connected objects.
+
+        Returns
+        -------
+        list
+        """
+        return self._pedb.get_connected_objects(self._layout_obj_instance)

pyedb/dotnet/edb_core/components.py

@@ -1983,7 +1983,7 @@ class Components(object):
         if not sball_mid_diam:
             sball_mid_diam = sball_diam
 
-        if shape == "Cylinder":
+        if shape.lower() == "cylinder":
             sball_shape = self._edb.definition.SolderballShape.Cylinder
         else:
             sball_shape = self._edb.definition.SolderballShape.Spheroid