pyedb 0.17.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

pyedb/dotnet/edb_core/components.py

@@ -766,20 +766,44 @@ class Components(object):
         >>> edb.close_edb()
         """
 
-        if isinstance(pins, str) or isinstance(pins, EDBPadstackInstance):
+        if isinstance(pins, str):
             pins = [pins]
+        elif isinstance(pins, EDBPadstackInstance):
+            pins = [pins.name]
         if isinstance(reference_pins, str):
             reference_pins = [reference_pins]
-        if isinstance(refdes, str) or isinstance(refdes, EDBComponent):
+        if isinstance(reference_pins, list):
+            _temp = []
+            for ref_pin in reference_pins:
+                if isinstance(ref_pin, int):
+                    if ref_pin in self._padstack.instances:
+                        _temp.append(self._padstack.instances[ref_pin])
+                elif isinstance(ref_pin, str):
+                    if ref_pin in self.instances[refdes].pins:
+                        _temp.append(self.instances[refdes].pins[ref_pin])
+                    else:
+                        p = [pp for pp in list(self._padstack.instances.values()) if pp.name == ref_pin]
+                        if p:
+                            _temp.append(p)
+                elif isinstance(ref_pin, EDBPadstackInstance):
+                    _temp.append(ref_pin.name)
+            reference_pins = _temp
+        elif isinstance(reference_pins, int):
+            if reference_pins in self._padstack.instances:
+                reference_pins = self._padstack.instances[reference_pins]
+        if isinstance(refdes, str):
             refdes = self.instances[refdes]
+        elif isinstance(refdes, self._pedb._edb.Cell.Hierarchy.Component):
+            refdes = EDBComponent(self._pedb, refdes)
+        refdes_pins = refdes.pins
         if any(refdes.rlc_values):
             return self.deactivate_rlc_component(component=refdes, create_circuit_port=True)
         if len([pin for pin in pins if isinstance(pin, str)]) == len(pins):
             cmp_pins = []
             for pin_name in pins:
-                cmp_pin = [pin for pin in list(refdes.pins.values()) if pin_name == pin.name]
+                cmp_pin = [pin for pin in list(refdes_pins.values()) if pin_name == pin.name]
                 if not cmp_pin:
-                    cmp_pin = [pin for pin in list(refdes.pins.values()) if pin_name == pin.name.split("-")[1]]
+                    cmp_pin = [pin for pin in list(refdes_pins.values()) if pin_name == pin.name.split("-")[1]]
                 if cmp_pin:
                     cmp_pins.append(cmp_pin[0])
             if not cmp_pins:
@@ -793,15 +817,15 @@ class Components(object):
         if len([pin for pin in reference_pins if isinstance(pin, str)]) == len(reference_pins):
             ref_cmp_pins = []
             for ref_pin_name in reference_pins:
-                cmp_ref_pin = [pin for pin in list(refdes.pins.values()) if ref_pin_name == pin.name]
-                if not cmp_ref_pin:
-                    cmp_ref_pin = [pin for pin in list(refdes.pins.values()) if ref_pin_name == pin.name.split("-")[1]]
-                if cmp_ref_pin:
-                    ref_cmp_pins.append(cmp_ref_pin[0])
+                if ref_pin_name in refdes_pins:
+                    ref_cmp_pins.append(refdes_pins[ref_pin_name])
+                elif "-" in ref_pin_name and ref_pin_name.split("-")[1] in refdes_pins:
+                    ref_cmp_pins.append(refdes_pins[ref_pin_name.split("-")[1]])
             if not ref_cmp_pins:
                 return
             reference_pins = ref_cmp_pins
-        if not len([pin for pin in reference_pins if isinstance(pin, EDBPadstackInstance)]) == len(reference_pins):
+        if not reference_pins:
+            self._logger.error("No reference pins found.")
             return
         if len(pins) > 1:
             pec_boundary = False
@@ -883,7 +907,7 @@ class Components(object):
         solder_balls_size : float, optional
             Solder balls diameter. When provided auto evaluation based on padstack size will be disabled.
         solder_balls_mid_size : float, optional
-            Solder balls mid diameter. When provided if value is different than solder balls size, spheroid shape will
+            Solder balls mid-diameter. When provided if value is different than solder balls size, spheroid shape will
             be switched.
 
         Returns
@@ -904,11 +928,11 @@ class Components(object):
         if isinstance(component, str):
             component = self.instances[component].edbcomponent
         if not solder_balls_height:
-            solder_balls_height = self.components[component.GetName()].solder_ball_height
+            solder_balls_height = self.instances[component.GetName()].solder_ball_height
         if not solder_balls_size:
-            solder_balls_size = self.components[component.GetName()].solder_ball_diameter[0]
+            solder_balls_size = self.instances[component.GetName()].solder_ball_diameter[0]
         if not solder_balls_mid_size:
-            solder_balls_mid_size = self.components[component.GetName()].solder_ball_diameter[1]
+            solder_balls_mid_size = self.instances[component.GetName()].solder_ball_diameter[1]
         if not isinstance(net_list, list):
             net_list = [net_list]
         for net in net_list:
@@ -934,6 +958,18 @@ class Components(object):
             return False
         pin_layers = cmp_pins[0].GetPadstackDef().GetData().GetLayerNames()
         if port_type == SourceType.CoaxPort:
+            ref_pins = [
+                p
+                for p in list(component.LayoutObjs)
+                if int(p.GetObjType()) == 1 and p.GetNet().GetName() in reference_net
+            ]
+            if not ref_pins:
+                self._logger.error(
+                    "No reference pins found on component. You might consider"
+                    "using Circuit port instead since reference pins can be extended"
+                    "outside the component automatically when not found."
+                )
+                return False
             pad_params = self._padstack.get_pad_parameters(pin=cmp_pins[0], layername=pin_layers[0], pad_type=0)
             if not pad_params[0] == 7:
                 if not solder_balls_size:  # pragma no cover
@@ -981,17 +1017,25 @@ class Components(object):
             for p in ref_pins:
                 if not p.IsLayoutPin():
                     p.SetIsLayoutPin(True)
-            if len(ref_pins) == 0:
-                self._logger.info("No reference pin found on component {}.".format(component.GetName()))
+            if not ref_pins:
+                self._logger.warning("No reference pins found on component, the closest pin will be selected.")
+                do_pingroup = False
             if do_pingroup:
                 if len(ref_pins) == 1:
+                    ref_pins.is_pin = True
                     ref_pin_group_term = self._create_terminal(ref_pins[0])
                 else:
+                    for pin in ref_pins:
+                        pin.is_pin = True
                     ref_pin_group = self.create_pingroup_from_pins(ref_pins)
                     if not ref_pin_group:
+                        self._logger.error(f"Failed to create reference pin group on component {component.GetName()}.")
                         return False
-                    ref_pin_group_term = self._create_pin_group_terminal(ref_pin_group, isref=True)
+                    ref_pin_group_term = self._create_pin_group_terminal(ref_pin_group, isref=False)
                     if not ref_pin_group_term:
+                        self._logger.error(
+                            f"Failed to create reference pin group terminal on component {component.GetName()}"
+                        )
                         return False
                 for net in net_list:
                     pins = [pin for pin in cmp_pins if pin.GetNet().GetName() == net]
@@ -1013,7 +1057,19 @@ class Components(object):
                 for net in net_list:
                     pins = [pin for pin in cmp_pins if pin.GetNet().GetName() == net]
                     for pin in pins:
-                        self.create_port_on_pins(component, pin, ref_pins)
+                        if ref_pins:
+                            self.create_port_on_pins(component, pin, ref_pins)
+                        else:
+                            _pin = EDBPadstackInstance(pin, self._pedb)
+                            ref_pin = _pin.get_reference_pins(
+                                reference_net=reference_net[0], max_limit=1, component_only=False, search_radius=3e-3
+                            )
+                            if ref_pin:
+                                self.create_port_on_pins(
+                                    component,
+                                    [EDBPadstackInstance(pin, self._pedb).name],
+                                    [EDBPadstackInstance(ref_pin[0], self._pedb).id],
+                                )
         return True
 
     def _create_terminal(self, pin, term_name=None):

pyedb/dotnet/edb_core/dotnet/primitive.py

@@ -837,9 +837,8 @@ class PathDotNet(PrimitiveDotNet):
             net = net.api_object
         width = self._app.edb_api.utility.value(width)
         if isinstance(points, list):
-            points = self._app.edb_api.geometry.polygon_data.api_class(
-                convert_py_list_to_net_list([self._app.geometry.point_data(i) for i in points]), False
-            )
+            points = convert_py_list_to_net_list([self._app.point_data(i[0], i[1]) for i in points])
+            points = self._app.edb_api.geometry.polygon_data.dotnetobj(points)
         return PathDotNet(
             self._app, self.api.Path.Create(layout, layer, net, width, end_cap1, end_cap2, corner_style, points)
         )
@@ -847,11 +846,15 @@ class PathDotNet(PrimitiveDotNet):
     @property
     def center_line(self):
         """:class:`PolygonData <ansys.edb.geometry.PolygonData>`: Center line for this Path."""
-        return self.prim_obj.GetCenterLine()
+        edb_center_line = self.prim_obj.GetCenterLine()
+        return [[pt.X.ToDouble(), pt.Y.ToDouble()] for pt in list(edb_center_line.Points)]
 
     @center_line.setter
-    def center_line(self, center_line):
-        self.prim_obj.SetCenterLineMessage(center_line)
+    def center_line(self, value):
+        if isinstance(value, list):
+            points = [self._pedb.point_data(i[0], i[1]) for i in value]
+            polygon_data = self._edb.geometry.polygon_data.dotnetobj(convert_py_list_to_net_list(points), False)
+            self.prim_obj.SetCenterLine(polygon_data)
 
     @property
     def end_cap_style(self):

pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -1678,11 +1678,9 @@ class EDBPadstackInstance(Primitive):
     def name(self):
         """Padstack Instance Name. If it is a pin, the syntax will be like in AEDT ComponentName-PinName."""
         if self.is_pin:
-            comp_name = self._edb_padstackinstance.GetComponent().GetName()
-            pin_name = self._edb_padstackinstance.GetName()
-            return "-".join([comp_name, pin_name])
+            return self.aedt_name
         else:
-            return self._edb_padstackinstance.GetName()
+            return self.component_pin
 
     @name.setter
     def name(self, value):
@@ -1725,6 +1723,12 @@ class EDBPadstackInstance(Primitive):
     @property
     def pin_number(self):
         """Get pin number."""
+        warnings.warn("`pin_number` is deprecated. Use `component_pin` method instead.", DeprecationWarning)
+        return self.component_pin
+
+    @property
+    def component_pin(self):
+        """Get component pin."""
         return self._edb_padstackinstance.GetName()
 
     @property

pyedb/dotnet/edb_core/edb_data/ports.py

@@ -198,24 +198,6 @@ class ExcitationSources(Terminal):
     def __init__(self, pedb, edb_terminal):
         Terminal.__init__(self, pedb, edb_terminal)
 
-    @property
-    def magnitude(self):
-        """Get the magnitude of the source."""
-        return self._edb_object.GetSourceAmplitude().ToDouble()
-
-    @magnitude.setter
-    def magnitude(self, value):
-        self._edb_object.SetSourceAmplitude(self._edb.utility.value(value))
-
-    @property
-    def phase(self):
-        """Get the phase of the source."""
-        return self._edb_object.GetSourcePhase().ToDouble()
-
-    @phase.setter
-    def phase(self, value):
-        self._edb_object.SetSourcePhase(self._edb.utility.value(value))
-
 
 class BundleWavePort(BundleTerminal):
     """Manages bundle wave port properties.

pyedb/dotnet/edb_core/edb_data/primitives_data.py

@@ -631,7 +631,7 @@ class EdbPath(EDBPrimitives, PathDotNet):
         float
             Path length in meters.
         """
-        center_line_arcs = list(self.center_line.GetArcData())
+        center_line_arcs = list(self.api_object.GetCenterLine().GetArcData())
         path_length = 0.0
         for arc in center_line_arcs:
             path_length += arc.GetLength()

pyedb/dotnet/edb_core/padstack.py

@@ -241,6 +241,15 @@ class EdbPadstacks(object):
                 )
         return padstack_instances
 
+    def find_instance_by_id(self, value: int):
+        """Find a padstack instance by database id.
+
+        Parameters
+        ----------
+        value : int
+        """
+        return self._pedb.modeler.find_object_by_id(value)
+
     @property
     def pins(self):
         """Dictionary  of all pins instances (belonging to component).
@@ -1441,7 +1450,7 @@ class EdbPadstacks(object):
                 instances = [inst for inst in instances if inst.component.refdes in refdes]
                 if component_pin:
                     component_pin = component_pin if isinstance(component_pin, list) else [component_pin]
-                    instances = [inst for inst in instances if inst.pin_number in component_pin]
+                    instances = [inst for inst in instances if inst.component_pin in component_pin]
             return instances
 
     def get_padstack_instance_by_net_name(self, net_name):

pyedb/dotnet/edb_core/sim_setup_data/data/sim_setup_info.py

@@ -20,6 +20,9 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from pyedb.dotnet.edb_core.sim_setup_data.data.simulation_settings import (  # HFSSSimulationSettings
+    HFSSPISimulationSettings,
+)
 from pyedb.dotnet.edb_core.sim_setup_data.data.sweep_data import SweepData
 
 
@@ -58,17 +61,53 @@ class SimSetupInfo:
         else:
             self._edb_object = edb_object
 
+    @property
+    def name(self):
+        return self._edb_object.Name
+
+    @name.setter
+    def name(self, name):
+        self._edb_object.Name = name
+
     @property
     def position(self):
         return self._edb_object.Position
 
     @property
     def sim_setup_type(self):
-        return self._edb_object.SimSetupType
+        """
+        "kHFSS": self._pedb.simsetupdata.HFSSSimulationSettings,
+        "kPEM": None,
+        "kSIwave": self._pedb.simsetupdata.SIwave.SIWSimulationSettings,
+        "kLNA": None,
+        "kTransient": None,
+        "kQEye": None,
+        "kVEye": None,
+        "kAMI": None,
+        "kAnalysisOption": None,
+        "kSIwaveDCIR": self._pedb.simsetupdata.SIwave.SIWDCIRSimulationSettings,
+        "kSIwaveEMI": None,
+        "kHFSSPI": self._pedb.simsetupdata.HFSSPISimulationSettings,
+        "kDDRwizard": None,
+        "kQ3D": None,
+        "kNumSetupTypes": None,
+        """
+
+        return self._edb_object.SimSetupType.ToString()
 
     @property
     def simulation_settings(self):
-        return self._edb_object.SimulationSettings
+        if self.sim_setup_type == "kHFSS":
+            return self._edb_object.SimulationSettings
+            # todo refactor HFSS
+            # return HFSSSimulationSettings(self._pedb, self.sim_setup, self._edb_object.SimulationSettings)
+        elif self.sim_setup_type == "kHFSSPI":
+            return HFSSPISimulationSettings(self._pedb, self.sim_setup, self._edb_object.SimulationSettings)
+        elif self.sim_setup_type == "kSIwave":  # todo refactor
+            return self._edb_object.SimulationSettings
+
+        elif self.sim_setup_type == "kSIwaveDCIR":  # todo refactor
+            return self._edb_object.SimulationSettings
 
     @property
     def sweep_data_list(self):
@@ -77,5 +116,5 @@ class SimSetupInfo:
         ]
 
     def add_sweep_data(self, sweep_data):
-        sweep_data.sim_setup = self.sim_setup
+        sweep_data._sim_setup = self.sim_setup
         self._edb_object.SweepDataList.Add(sweep_data._edb_object)