pyedb 0.47.1__py3-none-any.whl → 0.49.0__py3-none-any.whl

pyedb/dotnet/database/siwave.py

@@ -261,21 +261,25 @@ class EdbSiwave(object):
         >>> edbapp.siwave.create_circuit_port_on_pin(pins[0], pins[1], 50, "port_name")
         """
         circuit_port = CircuitPort()
-        circuit_port.positive_node.net = pos_pin.GetNet().GetName()
-        circuit_port.negative_node.net = neg_pin.GetNet().GetName()
+        if not isinstance(pos_pin, EDBPadstackInstance):
+            pos_pin = EDBPadstackInstance(pos_pin, self._pedb)
+        if not isinstance(neg_pin, EDBPadstackInstance):
+            neg_pin = EDBPadstackInstance(neg_pin, self._pedb)
+        circuit_port.positive_node.net = pos_pin.net_name
+        circuit_port.negative_node.net = neg_pin.net_name
         circuit_port.impedance = impedance
 
         if not port_name:
             port_name = "Port_{}_{}_{}_{}".format(
-                pos_pin.GetComponent().GetName(),
-                pos_pin.GetNet().GetName(),
-                neg_pin.GetComponent().GetName(),
-                neg_pin.GetNet().GetName(),
+                pos_pin.component.name,
+                pos_pin.net_name,
+                neg_pin.component.name,
+                neg_pin.net_name,
             )
         circuit_port.name = port_name
-        circuit_port.positive_node.component_node = pos_pin.GetComponent()
+        circuit_port.positive_node.component_node = pos_pin.component
         circuit_port.positive_node.node_pins = pos_pin
-        circuit_port.negative_node.component_node = neg_pin.GetComponent()
+        circuit_port.negative_node.component_node = neg_pin.component
         circuit_port.negative_node.node_pins = neg_pin
         return self._create_terminal_on_pins(circuit_port)
 
@@ -386,22 +390,22 @@ class EdbSiwave(object):
         """
 
         voltage_source = VoltageSource()
-        voltage_source.positive_node.net = pos_pin.GetNet().GetName()
-        voltage_source.negative_node.net = neg_pin.GetNet().GetName()
+        voltage_source.positive_node.net = pos_pin.net_name
+        voltage_source.negative_node.net = neg_pin.net_name
         voltage_source.magnitude = voltage_value
         voltage_source.phase = phase_value
         if not source_name:
             source_name = "VSource_{}_{}_{}_{}".format(
-                pos_pin.GetComponent().GetName(),
-                pos_pin.GetNet().GetName(),
-                neg_pin.GetComponent().GetName(),
-                neg_pin.GetNet().GetName(),
+                pos_pin.component.name,
+                pos_pin.net_name,
+                neg_pin.component.name,
+                neg_pin.net_name,
             )
         voltage_source.name = source_name
-        voltage_source.positive_node.component_node = pos_pin.GetComponent()
+        voltage_source.positive_node.component_node = pos_pin.component
         voltage_source.positive_node.node_pins = pos_pin
-        voltage_source.negative_node.component_node = neg_pin.GetComponent()
-        voltage_source.negative_node.node_pins = pos_pin
+        voltage_source.negative_node.component_node = neg_pin.component
+        voltage_source.negative_node.node_pins = neg_pin
         return self._create_terminal_on_pins(voltage_source)
 
     def create_current_source_on_pin(self, pos_pin, neg_pin, current_value=0.1, phase_value=0, source_name=""):
@@ -434,21 +438,21 @@ class EdbSiwave(object):
         >>> edbapp.siwave.create_current_source_on_pin(pins[0], pins[1], 50, "source_name")
         """
         current_source = CurrentSource()
-        current_source.positive_node.net = pos_pin.GetNet().GetName()
-        current_source.negative_node.net = neg_pin.GetNet().GetName()
+        current_source.positive_node.net = pos_pin.net_name
+        current_source.negative_node.net = neg_pin.net_name
         current_source.magnitude = current_value
         current_source.phase = phase_value
         if not source_name:
             source_name = "ISource_{}_{}_{}_{}".format(
-                pos_pin.GetComponent().GetName(),
-                pos_pin.GetNet().GetName(),
-                neg_pin.GetComponent().GetName(),
-                neg_pin.GetNet().GetName(),
+                pos_pin.component.name,
+                pos_pin.net_name,
+                neg_pin.component.name,
+                neg_pin.net_name,
             )
         current_source.name = source_name
-        current_source.positive_node.component_node = pos_pin.GetComponent()
+        current_source.positive_node.component_node = pos_pin.component
         current_source.positive_node.node_pins = pos_pin
-        current_source.negative_node.component_node = neg_pin.GetComponent()
+        current_source.negative_node.component_node = neg_pin.component
         current_source.negative_node.node_pins = neg_pin
         return self._create_terminal_on_pins(current_source)
 
@@ -480,20 +484,20 @@ class EdbSiwave(object):
         >>> edbapp.siwave.create_resistor_on_pin(pins[0], pins[1],50,"res_name")
         """
         resistor = ResistorSource()
-        resistor.positive_node.net = pos_pin.GetNet().GetName()
-        resistor.negative_node.net = neg_pin.GetNet().GetName()
+        resistor.positive_node.net = pos_pin.net_name
+        resistor.negative_node.net = neg_pin.net_name
         resistor.rvalue = rvalue
         if not resistor_name:
             resistor_name = "Res_{}_{}_{}_{}".format(
-                pos_pin.GetComponent().GetName(),
-                pos_pin.GetNet().GetName(),
-                neg_pin.GetComponent().GetName(),
-                neg_pin.GetNet().GetName(),
+                pos_pin.component.name,
+                pos_pin.net_name,
+                neg_pin.component.name,
+                neg_pin.net_name,
             )
         resistor.name = resistor_name
-        resistor.positive_node.component_node = pos_pin.GetComponent()
+        resistor.positive_node.component_node = pos_pin.component
         resistor.positive_node.node_pins = pos_pin
-        resistor.negative_node.component_node = neg_pin.GetComponent()
+        resistor.negative_node.component_node = neg_pin.component
         resistor.negative_node.node_pins = neg_pin
         return self._create_terminal_on_pins(resistor)
 

pyedb/dotnet/database/utilities/simulation_setup.py

@@ -109,6 +109,11 @@ class SimulationSetup(object):
         warnings.warn("Use new property :func:`sim_setup_info` instead.", DeprecationWarning)
         return self.sim_setup_info._edb_object
 
+    @property
+    def is_null(self):
+        """Adding this property for compatibility with grpc."""
+        return self._edb_object.IsNull()
+
     def get_simulation_settings(self):
         sim_settings = self.sim_setup_info.simulation_settings
         properties = {}
@@ -237,13 +242,43 @@ class SimulationSetup(object):
         """List of frequency sweeps."""
         return {i.name: i for i in self.sim_setup_info.sweep_data_list}
 
-    def add_sweep(self, name: str = None, frequency_set: list = None, sweep_type: str = "interpolation", **kwargs):
+    @property
+    def sweep_data(self):
+        """Adding property for compatibility with grpc."""
+        return list(self.sweeps.values())
+
+    @sweep_data.setter
+    def sweep_data(self, sweep_data):
+        for sweep in self.sweep_data:
+            self.delete_frequency_sweep(sweep)
+        for sweep in sweep_data:
+            self._add_frequency_sweep(sweep)
+
+    def add_sweep(
+        self,
+        name: str = None,
+        distribution: str = None,
+        start_freq: str = None,
+        stop_freq: str = None,
+        step=None,
+        frequency_set: list = None,
+        sweep_type: str = "interpolation",
+        **kwargs,
+    ):
         """Add frequency sweep.
 
         Parameters
         ----------
         name : str, optional
             Name of the frequency sweep. The default is ``None``.
+        distribution : str, optional
+            Added for grpc compatibility.
+        start_freq : str, optional
+            Added for rpc compatibility.
+        stop_freq : str, optional
+            Added for grpc compatibility.
+        step : optional
+            Added for grpc compatibility.
         frequency_set : list, optional
             List of frequency points. The default is ``None``.
         sweep_type : str, optional
@@ -261,21 +296,28 @@ class SimulationSetup(object):
             raise ValueError("Sweep {} already exists.".format(name))
 
         sweep_data = SweepData(self._pedb, name=name, sim_setup=self)
-        for k, v in kwargs.items():
-            if k in dir(sweep_data):
-                setattr(sweep_data, k, v)
-        sweep_data.type = sweep_type
+        # adding grpc compatibility
+        if distribution and start_freq and stop_freq and step:
+            if distribution == "linear":
+                distribution = "linear_scale"  # to be compatible with grpc
+            frequency_set = [[distribution, start_freq, stop_freq, step]]
 
         if frequency_set in [None, []]:
-            sweep_type = "linear_scale"
+            distribution = "linear_scale"
             start, stop, increment = "50MHz", "5GHz", "50MHz"
-            frequency_set = [[sweep_type, start, stop, increment]]
+            frequency_set = [[distribution, start, stop, increment]]
         elif not isinstance(frequency_set[0], list):
             frequency_set = [frequency_set]
 
         for fs in frequency_set:
-            sweep_type, start, stop, increment = fs
-            sweep_data.add(sweep_type, start, stop, increment)
+            distribution, start, stop, increment = fs
+            sweep_data.add(distribution, start, stop, increment)
+
+        for k, v in kwargs.items():
+            if k in dir(sweep_data):
+                setattr(sweep_data, k, v)
+        sweep_data.type = sweep_type
+
         return sweep_data
 
     def delete(self):

pyedb/dotnet/database/utilities/siwave_simulation_setup.py

@@ -269,7 +269,9 @@ class SiwaveSimulationSetup(SimulationSetup):
         >>> setup1 = edbapp.create_siwave_syz_setup("setup1")
         >>> setup1.add_sweep(name="sw1", frequency_set=["linear count", "1MHz", "100MHz", 10])
         """
-        sweep_data = SimulationSetup.add_sweep(self, name, frequency_set, sweep_type, **kwargs)
+        sweep_data = SimulationSetup.add_sweep(
+            self, name=name, frequency_set=frequency_set, sweep_type=sweep_type, **kwargs
+        )
         self._siwave_sweeps_list.append(sweep_data)
         return sweep_data
 

pyedb/dotnet/edb.py

@@ -1451,13 +1451,28 @@ class Edb(Database):
     def close_edb(self):
         """Close EDB and cleanup variables.
 
+        . deprecated:: pyedb 0.47.0
+        Use: func:`close` instead.
+
+        Returns
+        -------
+        bool
+            ``True`` when successful, ``False`` when failed.
+
+        """
+        warnings.warn("Use new property :func:`close` instead.", DeprecationWarning)
+        return self.close()
+
+    def close(self):
+        """Close EDB and cleanup variables.
+
         Returns
         -------
         bool
             ``True`` when successful, ``False`` when failed.
 
         """
-        self.close()
+        Database.close(self)
 
         if self.log_name and settings.enable_local_log_file:
             self._logger.remove_all_file_loggers()
@@ -1471,25 +1486,62 @@ class Edb(Database):
     def save_edb(self):
         """Save the EDB file.
 
+        . deprecated:: pyedb 0.47.0
+        Use: func:`save` instead.
+
+        Returns
+        -------
+        bool
+            ``True`` when successful, ``False`` when failed.
+
+        """
+        warnings.warn("Use new method :func:`save` instead.", DeprecationWarning)
+        return self.save()
+
+    def save(self):
+        """Save the EDB file.
+
         Returns
         -------
         bool
             ``True`` when successful, ``False`` when failed.
 
         """
-        self.save()
+
+        Database.save(self)
         start_time = time.time()
         self._wait_for_file_release()
         elapsed_time = time.time() - start_time
         self.logger.info("EDB file save time: {0:.2f}ms".format(elapsed_time * 1000.0))
         return True
 
-    def save_edb_as(self, fname):
+    def save_edb_as(self, path):
+        """Save the EDB file as another file.
+
+        . deprecated:: pyedb 0.47.0
+        Use: func:`save_as` instead.
+
+
+        Parameters
+        ----------
+        path : str
+            Name of the new file to save to.
+
+        Returns
+        -------
+        bool
+            ``True`` when successful, ``False`` when failed.
+
+        """
+        warnings.warn("Use new property :func:`save_as` instead.", DeprecationWarning)
+        return self.save_as(path)
+
+    def save_as(self, path, version=""):
         """Save the EDB file as another file.
 
         Parameters
         ----------
-        fname : str
+        path : str
             Name of the new file to save to.
 
         Returns
@@ -1499,7 +1551,7 @@ class Edb(Database):
 
         """
         origin_name = "pyedb_" + os.path.splitext(os.path.split(self.edbpath)[-1])[0]
-        self.save_as(fname)
+        Database.save_as(self, path)
         start_time = time.time()
         self._wait_for_file_release()
         elapsed_time = time.time() - start_time
@@ -1509,8 +1561,8 @@ class Edb(Database):
             self._logger.remove_file_logger(os.path.splitext(os.path.split(self.log_name)[-1])[0])
 
         self.log_name = os.path.join(
-            os.path.dirname(fname),
-            "pyedb_" + os.path.splitext(os.path.split(fname)[-1])[0] + ".log",
+            os.path.dirname(path),
+            "pyedb_" + os.path.splitext(os.path.split(path)[-1])[0] + ".log",
         )
         if settings.enable_local_log_file:
             self._logger.add_file_logger(self.log_name, "Edb")
@@ -1800,7 +1852,7 @@ class Edb(Database):
         output_aedb_path=None,
         open_cutout_at_end=True,
         use_pyaedt_cutout=True,
-        number_of_threads=4,
+        number_of_threads=1,
         use_pyaedt_extent_computing=True,
         extent_defeature=0,
         remove_single_pin_components=False,
@@ -4668,3 +4720,10 @@ class Edb(Database):
         ET.indent(tree, space="\t", level=0)
         tree.write(control_path)
         return True if os.path.exists(control_path) else False
+
+    def get_variable_value(self, variable_name):
+        """Added to get closer architecture as for grpc."""
+        if variable_name in self.variables:
+            return self.variables[variable_name].value
+        else:
+            return False

pyedb/grpc/database/components.py

@@ -276,20 +276,26 @@ class Components(object):
         self._others = {}
         for i in self._pedb.layout.groups:
             self._cmp[i.name] = i
-            if i.type == "resistor":
-                self._res[i.name] = i
-            elif i.type == "capacitor":
-                self._cap[i.name] = i
-            elif i.type == "inductor":
-                self._ind[i.name] = i
-            elif i.type == "ic":
-                self._ics[i.name] = i
-            elif i.type == "io":
-                self._ios[i.name] = i
-            elif i.type == "other":
+            try:
+                if i.type == "resistor":
+                    self._res[i.name] = i
+                elif i.type == "capacitor":
+                    self._cap[i.name] = i
+                elif i.type == "inductor":
+                    self._ind[i.name] = i
+                elif i.type == "ic":
+                    self._ics[i.name] = i
+                elif i.type == "io":
+                    self._ios[i.name] = i
+                elif i.type == "other":
+                    self._others[i.name] = i
+                else:
+                    self._logger.warning(
+                        f"Unknown component type {i.name} found while refreshing components, will ignore"
+                    )
+            except:
+                self._logger.warning(f"Assigning component {i.name} as default type other.")
                 self._others[i.name] = i
-            else:
-                self._logger.warning(f"Unknown component type {i.name} found while refreshing components, will ignore")
         return True
 
     @property

pyedb/grpc/database/hfss.py

@@ -527,7 +527,7 @@ class Hfss(object):
             "`pyedb.grpc.core.excitations.create_differential_wave_port` instead.",
             DeprecationWarning,
         )
-        return self._pedb.excitations.create_differential_wave_port(
+        return self._pedb.source_excitation.create_differential_wave_port(
             positive_primitive_id,
             positive_points_on_edge,
             negative_primitive_id,
@@ -579,7 +579,7 @@ class Hfss(object):
             "`pyedb.grpc.core.excitations.create_bundle_wave_port` instead.",
             DeprecationWarning,
         )
-        self._pedb.excitations.create_bundle_wave_port(
+        return self._pedb.source_excitation.create_bundle_wave_port(
             primitives_id, points_on_edge, port_name, horizontal_extent_factor, vertical_extent_factor, pec_launch_width
         )
 
@@ -720,7 +720,7 @@ class Hfss(object):
             "`pyedb.grpc.core.excitations.create_source_on_component` instead.",
             DeprecationWarning,
         )
-        self._pedb.source_excitation.create_wave_port(
+        return self._pedb.source_excitation.create_wave_port(
             prim_id,
             point_on_edge,
             port_name,

pyedb/grpc/database/modeler.py

@@ -1272,7 +1272,7 @@ class Modeler(object):
         stat_model.num_resistors = len(self._pedb.components.resistors)
         stat_model.num_inductors = len(self._pedb.components.inductors)
         bbox = self._pedb._hfss.get_layout_bounding_box(self._active_layout)
-        stat_model._layout_size = bbox[2] - bbox[0], bbox[3] - bbox[1]
+        stat_model._layout_size = round(bbox[2] - bbox[0], 6), round(bbox[3] - bbox[1], 6)
         stat_model.num_discrete_components = (
             len(self._pedb.components.Others) + len(self._pedb.components.ICs) + len(self._pedb.components.IOs)
         )
@@ -1283,7 +1283,7 @@ class Modeler(object):
         stat_model.num_traces = len(self._pedb.modeler.paths)
         stat_model.num_polygons = len(self._pedb.modeler.polygons)
         stat_model.num_vias = len(self._pedb.padstacks.instances)
-        stat_model.stackup_thickness = self._pedb.stackup.get_layout_thickness()
+        stat_model.stackup_thickness = round(self._pedb.stackup.get_layout_thickness(), 6)
         if evaluate_area:
             outline_surface = stat_model.layout_size[0] * stat_model.layout_size[1]
             if net_list:
@@ -1298,8 +1298,8 @@ class Modeler(object):
                             surface += Path(self._pedb, prim).length * prim.cast().width.value
                         if prim.primitive_type.name == "POLYGON":
                             surface += prim.polygon_data.area()
-                            stat_model.occupying_surface[layer] = surface
-                            stat_model.occupying_ratio[layer] = surface / outline_surface
+                            stat_model.occupying_surface[layer] = round(surface, 6)
+                            stat_model.occupying_ratio[layer] = round(surface / outline_surface, 6)
         return stat_model
 
     def create_bondwire(

pyedb/grpc/database/padstacks.py

@@ -506,7 +506,9 @@ class Padstacks(object):
             "`pyedb.grpc.core.excitations.create_coax_port` instead.",
             DeprecationWarning,
         )
-        self._pedb.excitations.create_coax_port(self, padstackinstance, use_dot_separator=use_dot_separator, name=name)
+        self._pedb.source_excitation.create_coax_port(
+            self, padstackinstance, use_dot_separator=use_dot_separator, name=name
+        )
 
     def get_pin_from_component_and_net(self, refdes=None, netname=None):
         """Retrieve pins given a component's reference designator and net name.

pyedb/grpc/database/ports/ports.py

@@ -108,6 +108,10 @@ class GapPort(EdgeTerminal):
             self._edb_object.port_post_processing_prop.renormalizion_z0[1],
         )
 
+    @property
+    def terminal_type(self):
+        return self._edb_object.terminal_type
+
 
 class CircuitPort(GapPort):
     """Manages gap port properties.

pyedb/grpc/database/primitive/path.py

@@ -62,7 +62,7 @@ class Path(GrpcPath, Primitive):
         """
         center_line_arcs = self._edb_object.cast().center_line.arc_data
         path_length = 0.0
-        for arc in center_line_arcs:
+        for arc in center_line_arcs[: int(len(center_line_arcs) / 2)]:
             path_length += arc.length
         end_cap_style = self.get_end_cap_style()
         if end_cap_style:
@@ -181,7 +181,7 @@ class Path(GrpcPath, Primitive):
         #     )
         # else:
         return self._pedb.hfss.create_edge_port_vertical(
-            self.id,
+            self.edb_uid,
             pos,
             name,
             50,

pyedb/grpc/database/primitive/primitive.py

@@ -253,7 +253,12 @@ class Primitive(GrpcPrimitive):
 
         """
         bbox = self.cast().polygon_data.bbox()
-        return [bbox[0].x.value, bbox[0].y.value, bbox[1].x.value, bbox[1].y.value]
+        return [
+            round(bbox[0].x.value, 6),
+            round(bbox[0].y.value, 6),
+            round(bbox[1].x.value, 6),
+            round(bbox[1].y.value, 6),
+        ]
 
     def convert_to_polygon(self):
         """Convert path to polygon.

pyedb/grpc/database/source_excitations.py

@@ -353,6 +353,14 @@ class SourceExcitation:
         >>> port_type=SourceType.CoaxPort, do_pingroup=False, refnet="GND")
 
         """
+        if isinstance(port_type, int):
+            # Adding DotNet backward compatibility with SourceType
+            type_mapping = {0: "coax_port", 1: "circuit_port"}
+            if port_type in type_mapping:
+                port_type = type_mapping[port_type]
+            else:
+                self._logger.error(f"unsupported port type with method.")
+                return False
         if isinstance(component, str):
             component = self._pedb.components.instances[component]
         if not isinstance(net_list, list):
@@ -395,7 +403,7 @@ class SourceExcitation:
                     "outside the component when not found if argument extend_reference_pins_outside_component is True."
                 )
                 return False
-            pad_params = self._pedb.padstack.get_pad_parameters(pin=cmp_pins[0], layername=pin_layers[0], pad_type=0)
+            pad_params = self._pedb.padstacks.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
                     sball_diam = min([GrpcValue(val).value for val in pad_params[1]])
@@ -431,7 +439,7 @@ class SourceExcitation:
                 shape=sball_shape,
             )
             for pin in cmp_pins:
-                self._pedb.padstack.create_coax_port(padstackinstance=pin, name=port_name)
+                self._pedb.source_excitation.create_coax_port(padstackinstance=pin, name=port_name)
 
         elif port_type == "circuit_port":  # pragma no cover
             ref_pins = [p for p in list(component.pins.values()) if p.net_name in reference_net]
@@ -794,7 +802,7 @@ class SourceExcitation:
             port_name = generate_unique_name(port_name, n=2)
             self._logger.info("An existing port already has this same name. Renaming to {}.".format(port_name))
         PadstackInstanceTerminal.create(
-            layout=self._pedb._active_layout,
+            layout=self._pedb.active_layout,
             name=port_name,
             padstack_instance=padstackinstance,
             layer=terminal_layer,
@@ -831,7 +839,7 @@ class SourceExcitation:
             terminal_name = generate_unique_name("Terminal_")
         if isinstance(point_on_edge, tuple):
             point_on_edge = GrpcPointData(point_on_edge)
-        prim = [i for i in self._pedb.modeler.primitives if i.id == prim_id]
+        prim = [i for i in self._pedb.modeler.primitives if i.edb_uid == prim_id]
         if not prim:
             self._pedb.logger.error(f"No primitive found for ID {prim_id}")
             return False
@@ -1580,10 +1588,10 @@ class SourceExcitation:
             port_name = generate_unique_name("diff")
 
         if isinstance(positive_primitive_id, Primitive):
-            positive_primitive_id = positive_primitive_id.id
+            positive_primitive_id = positive_primitive_id.edb_uid
 
         if isinstance(negative_primitive_id, Primitive):
-            negative_primitive_id = negative_primitive_id.id
+            negative_primitive_id = negative_primitive_id.edb_uid
 
         _, pos_term = self.create_wave_port(
             positive_primitive_id,
@@ -1652,7 +1660,7 @@ class SourceExcitation:
             port_name = generate_unique_name("Terminal_")
 
         if isinstance(prim_id, Primitive):
-            prim_id = prim_id.id
+            prim_id = prim_id.edb_uid
         pos_edge_term = self._create_edge_terminal(prim_id, point_on_edge, port_name)
         pos_edge_term.impedance = GrpcValue(impedance)
         wave_port = WavePort(self._pedb, pos_edge_term)
@@ -2027,7 +2035,7 @@ class SourceExcitation:
             port_name = generate_unique_name("bundle_port")
 
         if isinstance(primitives_id[0], Primitive):
-            primitives_id = [i.id for i in primitives_id]
+            primitives_id = [i.edb_uid for i in primitives_id]
 
         terminals = []
         _port_name = port_name

pyedb/grpc/database/terminal/bundle_terminal.py

@@ -46,7 +46,7 @@ class BundleTerminal(GrpcBundleTerminal):
     """
 
     def __init__(self, pedb, edb_object):
-        super().__init__(edb_object)
+        super().__init__(edb_object.msg)
         self._pedb = pedb
         self._edb_object = edb_object