Merge branch 'main' into chore/setup-ruff

Author: ecoussoux-ansys

.github/workflows/ci_cd.yml

@@ -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")

src/pyedb/configuration/cfg_operations.py

@@ -278,7 +278,7 @@ def __init__(self, pedb, **kwargs):
         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

src/pyedb/configuration/cfg_ports_sources.py

@@ -183,13 +183,15 @@ def __getitem__(self, item):  # pragma: no cover
                 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
@@ -224,7 +226,8 @@ def __iadd__(self, other):  # pragma: no cover
             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():
@@ -1348,9 +1351,10 @@ def __init__(
             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):
@@ -1737,9 +1741,10 @@ def rescale_to(self, units):  # pragma: no cover
 
         """
         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
 
@@ -1810,7 +1815,8 @@ def __mul__(self, other):  # pragma: no cover
         >>> 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
@@ -1854,10 +1860,10 @@ def __add__(self, other):  # pragma: no cover
         >>> 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
@@ -1895,10 +1901,10 @@ def __sub__(self, other):  # pragma: no cover
         >>> 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
@@ -1940,7 +1946,8 @@ def __truediv__(self, other):  # pragma: no cover
         >>> 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

src/pyedb/dotnet/database/Variables.py

@@ -1945,3 +1945,90 @@ def expand_cluster(point_idx, neighbors):
             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

src/pyedb/dotnet/database/padstack.py

@@ -4036,15 +4036,15 @@ def copy_zones(self, working_directory=None):
         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,
                 "{}_{}".format(zone_primitive.GetId(), os.path.basename(self.edbpath)),
             )
             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)