pyedb 0.55.0__tar.gz → 0.56.0__tar.gz

{pyedb-0.55.0 → pyedb-0.56.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyedb
-Version: 0.55.0
+Version: 0.56.0
 Summary: Higher-Level Pythonic Ansys Electronics Data Base
 Author-email: "ANSYS, Inc." <pyansys.core@ansys.com>
 Maintainer-email: PyEDB developers <simon.vandenbrouck@ansys.com>

{pyedb-0.55.0 → pyedb-0.56.0}/src/pyedb/__init__.py

@@ -37,7 +37,7 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.55.0"
+__version__ = "0.56.0"
 version = __version__
 
 #

{pyedb-0.55.0 → pyedb-0.56.0}/src/pyedb/configuration/cfg_operations.py

@@ -20,7 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel, Field
 
@@ -37,7 +37,7 @@ class CfgCutout(BaseModel):
     signal_list: Optional[List[str]] = None
     reference_list: Optional[List[str]] = None
     extent_type: Optional[str] = "ConvexHull"
-    expansion_size: Optional[float] = 0.002
+    expansion_size: Optional[Union[float, str]] = 0.002
     number_of_threads: Optional[int] = 1
     custom_extent: Optional[Any] = None
     custom_extent_units: str = Field(default="meter")

{pyedb-0.55.0 → pyedb-0.56.0}/src/pyedb/configuration/cfg_ports_sources.py

@@ -278,7 +278,7 @@ class CfgCircuitElement(CfgBase):
         self._pedb = pedb
         self.name = kwargs["name"]
         self.type = kwargs["type"]
-        self.impedance = kwargs.get("impedance", 50)
+        self.impedance = kwargs.get("impedance", None)
         self.reference_designator = kwargs.get("reference_designator", None)
         self.distributed = kwargs.get("distributed", False)
         self._elem_num = 1

{pyedb-0.55.0 → pyedb-0.56.0}/src/pyedb/dotnet/database/Variables.py

@@ -181,13 +181,15 @@ class CSVDataset:
                 if variable in key_string:
                     found_variable = True
                     break
-            assert found_variable, "Input string {} is not a key of the data dictionary.".format(variable)
+            if not found_variable:
+                raise KeyError(f"Input string {variable} is not a key of the data dictionary.")
             data_out._data[variable] = self._data[key_string]
             data_out._header.append(variable)
         return data_out
 
     def __add__(self, other):  # pragma: no cover
-        assert self.number_of_columns == other.number_of_columns, "Inconsistent number of columns"
+        if self.number_of_columns != other.number_of_columns:
+            raise ValueError("Number of columns is inconsistent.")
         # Create a new object to return, avoiding changing the original inputs
         new_dataset = CSVDataset()
         # Add empty columns to new_dataset
@@ -222,7 +224,8 @@ class CSVDataset:
             for column in other.data:
                 self._data[column] = []
 
-        assert self.number_of_columns == other.number_of_columns, "Inconsistent number of columns"
+        if self.number_of_columns != other.number_of_columns:
+            raise ValueError("Number of columns is inconsistent.")
 
         # Append the data from 'other'
         for column, row_data in other.data.items():
@@ -1341,9 +1344,10 @@ class Variable(object):
             self._value = self._calculated_value
         # If units have been specified, check for a conflict and otherwise use the specified unit system
         if units:
-            assert not self._units, "The unit specification {} is inconsistent with the identified units {}.".format(
-                specified_units, self._units
-            )
+            if self._units and self._units != specified_units:
+                raise RuntimeError(
+                    f"The unit specification {specified_units} is inconsistent with the identified units {self._units}."
+                )
             self._units = specified_units
 
         if not si_value and is_number(self._value):
@@ -1730,9 +1734,10 @@ class Variable(object):
 
         """
         new_unit_system = unit_system(units)
-        assert (
-            new_unit_system == self.unit_system
-        ), "New unit system {0} is inconsistent with the current unit system {1}."
+        if new_unit_system != self.unit_system:
+            raise ValueError(
+                f"New unit system {new_unit_system} is inconsistent with the current unit system {self.unit_system}."
+            )
         self._units = units
         return self
 
@@ -1803,7 +1808,8 @@ class Variable(object):
         >>> assert result_3.unit_system == "Power"
 
         """
-        assert is_number(other) or isinstance(other, Variable), "Multiplier must be a scalar quantity or a variable."
+        if not is_number(other) and not isinstance(other, Variable):
+            raise ValueError("Multiplier must be a scalar quantity or a variable.")
         if is_number(other):
             result_value = self.numeric_value * other
             result_units = self.units
@@ -1847,10 +1853,10 @@ class Variable(object):
         >>> assert result.unit_system == "Current"
 
         """
-        assert isinstance(other, Variable), "You can only add a variable with another variable."
-        assert (
-            self.unit_system == other.unit_system
-        ), "Only ``Variable`` objects with the same unit system can be added."
+        if not isinstance(other, Variable):
+            raise ValueError("You can only add a variable with another variable.")
+        if self.unit_system != other.unit_system:
+            raise ValueError("Only Variable objects with the same unit system can be added.")
         result_value = self.value + other.value
         result_units = SI_UNITS[self.unit_system]
         # If the units of the two operands are different, return SI-Units
@@ -1888,10 +1894,10 @@ class Variable(object):
         >>> assert result_2.unit_system == "Current"
 
         """
-        assert isinstance(other, Variable), "You can only subtract a variable from another variable."
-        assert (
-            self.unit_system == other.unit_system
-        ), "Only ``Variable`` objects with the same unit system can be subtracted."
+        if not isinstance(other, Variable):
+            raise ValueError("You can only subtract a variable from another variable.")
+        if self.unit_system != other.unit_system:
+            raise ValueError("Only Variable objects with the same unit system can be subtracted.")
         result_value = self.value - other.value
         result_units = SI_UNITS[self.unit_system]
         # If the units of the two operands are different, return SI-Units
@@ -1933,7 +1939,8 @@ class Variable(object):
         >>> assert result_1.unit_system == "Current"
 
         """
-        assert is_number(other) or isinstance(other, Variable), "Divisor must be a scalar quantity or a variable."
+        if not is_number(other) and not isinstance(other, Variable):
+            raise ValueError("Divisor must be a scalar quantity or a variable.")
         if is_number(other):
             result_value = self.numeric_value / other
             result_units = self.units

{pyedb-0.55.0 → pyedb-0.56.0}/src/pyedb/dotnet/database/components.py

@@ -1002,12 +1002,6 @@ class Components(object):
         ]
         pin_layers = cmp_pins[0].GetPadstackDef().GetData().GetLayerNames()
         if port_type == SourceType.CoaxPort:
-            if not solder_balls_height:
-                solder_balls_height = self.instances[component.GetName()].solder_ball_height
-            if not solder_balls_size:
-                solder_balls_size = self.instances[component.GetName()].solder_ball_diameter[0]
-            if not solder_balls_mid_size:
-                solder_balls_mid_size = self.instances[component.GetName()].solder_ball_diameter[1]
             if not ref_pins:
                 self._logger.error(
                     "No reference pins found on component. You might consider"
@@ -1016,40 +1010,51 @@ class Components(object):
                 )
                 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
-                    sball_diam = min([self._pedb.edb_value(val).ToDouble() for val in pad_params[1]])
-                    sball_mid_diam = sball_diam
+
+            # If at least one of the solderball arguments is not None, calculate the rest and set solderballs
+            if not (not solder_balls_height and not solder_balls_size and not solder_balls_mid_size):
+                if not solder_balls_height:
+                    solder_balls_height = self.instances[component.GetName()].solder_ball_height
+                if not solder_balls_size:
+                    solder_balls_size = self.instances[component.GetName()].solder_ball_diameter[0]
+                if not solder_balls_mid_size:
+                    solder_balls_mid_size = self.instances[component.GetName()].solder_ball_diameter[1]
+
+                if not pad_params[0] == 7:
+                    if not solder_balls_size:  # pragma no cover
+                        sball_diam = min([self._pedb.edb_value(val).ToDouble() for val in pad_params[1]])
+                        sball_mid_diam = sball_diam
+                    else:  # pragma no cover
+                        sball_diam = solder_balls_size
+                        if solder_balls_mid_size:
+                            sball_mid_diam = solder_balls_mid_size
+                        else:
+                            sball_mid_diam = solder_balls_size
+                    if not solder_balls_height:  # pragma no cover
+                        solder_balls_height = 2 * sball_diam / 3
                 else:  # pragma no cover
-                    sball_diam = solder_balls_size
+                    if not solder_balls_size:
+                        bbox = pad_params[1]
+                        sball_diam = min([abs(bbox[2] - bbox[0]), abs(bbox[3] - bbox[1])]) * 0.8
+                    else:
+                        sball_diam = solder_balls_size
+                    if not solder_balls_height:
+                        solder_balls_height = 2 * sball_diam / 3
                     if solder_balls_mid_size:
                         sball_mid_diam = solder_balls_mid_size
                     else:
-                        sball_mid_diam = solder_balls_size
-                if not solder_balls_height:  # pragma no cover
-                    solder_balls_height = 2 * sball_diam / 3
-            else:  # pragma no cover
-                if not solder_balls_size:
-                    bbox = pad_params[1]
-                    sball_diam = min([abs(bbox[2] - bbox[0]), abs(bbox[3] - bbox[1])]) * 0.8
-                else:
-                    sball_diam = solder_balls_size
-                if not solder_balls_height:
-                    solder_balls_height = 2 * sball_diam / 3
-                if solder_balls_mid_size:
-                    sball_mid_diam = solder_balls_mid_size
-                else:
-                    sball_mid_diam = sball_diam
-            sball_shape = "Cylinder"
-            if not sball_diam == sball_mid_diam:
-                sball_shape = "Spheroid"
-            self.set_solder_ball(
-                component=component,
-                sball_height=solder_balls_height,
-                sball_diam=sball_diam,
-                sball_mid_diam=sball_mid_diam,
-                shape=sball_shape,
-            )
+                        sball_mid_diam = sball_diam
+                sball_shape = "Cylinder"
+                if not sball_diam == sball_mid_diam:
+                    sball_shape = "Spheroid"
+                self.set_solder_ball(
+                    component=component,
+                    sball_height=solder_balls_height,
+                    sball_diam=sball_diam,
+                    sball_mid_diam=sball_mid_diam,
+                    shape=sball_shape,
+                )
+
             for pin in cmp_pins:
                 self._padstack.create_coax_port(padstackinstance=pin, name=port_name)
 

{pyedb-0.55.0 → pyedb-0.56.0}/src/pyedb/dotnet/database/padstack.py

@@ -1943,3 +1943,90 @@ class EdbPadstacks(object):
             clusters[int(label)].append(padstack_ids[i])
 
         return dict(clusters)
+
+    def reduce_via_by_density(
+        self, padstacks: List[int], cell_size_x: float = 1e-3, cell_size_y: float = 1e-3, delete: bool = False
+    ) -> tuple[List[int], List[List[List[float]]]]:
+        """
+        Reduce the number of vias by density. Keep only one via which is closest to the center of the cell. The cells
+        are automatically populated based on the input vias.
+
+        Parameters
+        ----------
+        padstacks: List[int]
+            List of padstack ids to be reduced.
+
+        cell_size_x : float
+            Width of each grid cell (default is 1e-3).
+
+        cell_size_y : float
+            Height of each grid cell (default is 1e-3).
+
+        delete: bool
+            If True, delete vias that are not kept (default is False).
+
+        Returns
+        -------
+        List[int]
+            IDs of vias kept after reduction.
+
+        List[List[float]]
+            coordinates for grid lines (for plotting).
+
+        """
+        to_keep = set()
+
+        all_instances = self.instances
+        positions = np.array([all_instances[_id].position for _id in padstacks])
+
+        x_coords, y_coords = positions[:, 0], positions[:, 1]
+        x_min, x_max = np.min(x_coords), np.max(x_coords)
+        y_min, y_max = np.min(y_coords), np.max(y_coords)
+
+        padstacks_array = np.array(padstacks)
+        cell_map = {}  # {(cell_x, cell_y): [(id1, [x1, y1]), (id2, [x2, y2), ...]}
+        grid = []
+
+        for idx, pos in enumerate(positions):
+            i = int((pos[0] - x_min) // cell_size_x)
+            j = int((pos[1] - y_min) // cell_size_y)
+            cell_key = (i, j)
+            cell_map.setdefault(cell_key, []).append((padstacks_array[idx], pos))
+
+        for (i, j), items in cell_map.items():
+            # cell center
+            cell_x_min = x_min + i * cell_size_x
+            cell_y_min = y_min + j * cell_size_y
+            cell_x_mid = cell_x_min + 0.5 * cell_size_x
+            cell_y_mid = cell_y_min + 0.5 * cell_size_y
+
+            grid.append(
+                [
+                    [
+                        cell_x_min,
+                        cell_x_min + cell_size_x,
+                        cell_x_min + cell_size_x,
+                        cell_x_min,
+                        cell_x_min,
+                    ],
+                    [
+                        cell_y_min,
+                        cell_y_min,
+                        cell_y_min + cell_size_y,
+                        cell_y_min + cell_size_y,
+                        cell_y_min,
+                    ],
+                ]
+            )
+
+            # Find closest via to cell center
+            distances = [np.linalg.norm(pos - [cell_x_mid, cell_y_mid]) for _, pos in items]
+            closest_idx = np.argmin(distances)
+            to_keep.add(items[closest_idx][0])
+
+        if delete:
+            to_delete = set(padstacks) - to_keep
+            for _id in to_delete:
+                all_instances[_id].delete()
+
+        return list(to_keep), grid

{pyedb-0.55.0 → pyedb-0.56.0}/src/pyedb/dotnet/edb.py

@@ -4033,7 +4033,7 @@ class Edb:
         edb_zones = {}
         if not self.setups:
             self.siwave.add_siwave_syz_analysis()
-            self.save_edb()
+            self.save()
         for zone_primitive in zone_primitives:
             edb_zone_path = os.path.join(
                 working_directory,
@@ -4041,7 +4041,7 @@ class Edb:
             )
             shutil.copytree(self.edbpath, edb_zone_path)
             poly_data = zone_primitive.GetPolygonData()
-            if self.version[0] >= 10:
+            if self._db.GetVersion()[0] >= 10:
                 edb_zones[edb_zone_path] = (zone_primitive.GetZoneId(), poly_data)
             elif len(zone_primitives) == len(zone_ids):
                 edb_zones[edb_zone_path] = (zone_ids[0], poly_data)