pyedb 0.55.0__py3-none-any.whl → 0.57.0__py3-none-any.whl

pyedb/__init__.py

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

pyedb/configuration/cfg_data.py

@@ -36,6 +36,7 @@ from pyedb.configuration.cfg_s_parameter_models import CfgSParameters
 from pyedb.configuration.cfg_setup import CfgSetups
 from pyedb.configuration.cfg_spice_models import CfgSpiceModel
 from pyedb.configuration.cfg_stackup import CfgStackup
+from pyedb.configuration.cfg_terminals import CfgTerminals
 
 
 class CfgData(object):
@@ -59,6 +60,8 @@ class CfgData(object):
 
         self.pin_groups = CfgPinGroups(self._pedb, pingroup_data=kwargs.get("pin_groups", []))
 
+        self.terminals = CfgTerminals.create(terminals=kwargs.get("terminals", []))
+
         self.ports = CfgPorts(self._pedb, ports_data=kwargs.get("ports", []))
 
         self.sources = CfgSources(self._pedb, sources_data=kwargs.get("sources", []))

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/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/configuration/cfg_terminals.py

@@ -0,0 +1,232 @@
+from typing import List, Literal, Optional, Union
+
+from pydantic import BaseModel
+
+
+class CfgBase(BaseModel):
+    model_config = {
+        "populate_by_name": True,
+        "extra": "forbid",
+    }
+
+
+class CfgTerminal(CfgBase):
+    name: str
+    impedance: Union[float, int, str]
+    is_circuit_port: bool
+    reference_terminal: Optional[str] = None
+    amplitude: Optional[Union[float, int, str]] = 1
+    phase: Optional[Union[float, int, str]] = 0
+    terminal_to_ground: Optional[Literal["kNoGround", "kNegative", "kPositive"]] = "kNoGround"
+    boundary_type: Literal[
+        "PortBoundary",
+        "PecBoundary",
+        "RlcBoundary",
+        "kCurrentSource",
+        "kVoltageSource",
+        "kNexximGround",
+        "kNexximPort",
+        "kDcTerminal",
+        "kVoltageProbe",
+        "InvalidBoundary",
+    ]
+    hfss_type: Literal["Wave", "Gap", None]
+
+
+class CfgPadstackInstanceTerminal(CfgTerminal):
+    terminal_type: str = "padstack_instance"
+    padstack_instance: str
+    padstack_instance_id: Optional[int] = None
+    layer: Optional[Union[str, None]] = None
+
+
+class CfgPinGroupTerminal(CfgTerminal):
+    terminal_type: str = "pin_group"
+    is_circuit_port: bool = True
+    pin_group: str
+
+
+class CfgPointTerminal(CfgTerminal):
+    terminal_type: str = "point"
+    x: Union[float, int, str]
+    y: Union[float, int, str]
+    layer: str
+    net: str
+
+
+class CfgEdgeTerminal(CfgTerminal):
+    terminal_type: str = "edge"
+    name: str
+    primitive: str
+    point_on_edge_x: Union[float, int, str]
+    point_on_edge_y: Union[float, int, str]
+    horizontal_extent_factor: Union[int, str]
+    vertical_extent_factor: Union[int, str]
+    pec_launch_width: Union[int, str]
+
+
+class CfgBundleTerminal(CfgBase):
+    terminal_type: str = "bundle"
+    terminals: List[str]
+    name: str
+
+
+class CfgTerminals(CfgBase):
+    terminals: List[
+        Union[
+            CfgPadstackInstanceTerminal, CfgPinGroupTerminal, CfgPointTerminal, CfgEdgeTerminal, CfgBundleTerminal, dict
+        ]
+    ]
+
+    @classmethod
+    def create(cls, terminals: List[dict]):
+        manager = cls(terminals=[])
+        for i in terminals:
+            terminal_type = i.pop("terminal_type")
+            if terminal_type == "padstack_instance":
+                manager.add_padstack_instance_terminal(**i)
+            elif terminal_type == "pin_group":
+                manager.add_pin_group_terminal(**i)
+            elif terminal_type == "point":
+                manager.add_point_terminal(**i)
+            elif terminal_type == "edge":
+                manager.add_edge_terminal(**i)
+            elif terminal_type == "bundle":
+                manager.add_bundle_terminal(**i)
+            else:  # pragma: no cover
+                raise ValueError(f"Unknown terminal type: {terminal_type}")
+        return manager
+
+    def add_padstack_instance_terminal(
+        self,
+        padstack_instance,
+        name,
+        impedance,
+        is_circuit_port,
+        boundary_type,
+        hfss_type,
+        reference_terminal=None,
+        amplitude=1,
+        phase=0,
+        terminal_to_ground="kNoGround",
+        padstack_instance_id=None,
+        layer=None,
+    ):
+        terminal = CfgPadstackInstanceTerminal(
+            padstack_instance=padstack_instance,
+            name=name,
+            impedance=impedance,
+            is_circuit_port=is_circuit_port,
+            boundary_type=boundary_type,
+            reference_terminal=reference_terminal,
+            amplitude=amplitude,
+            phase=phase,
+            terminal_to_ground=terminal_to_ground,
+            layer=layer,
+            hfss_type=hfss_type,
+            padstack_instance_id=padstack_instance_id,
+        )
+        self.terminals.append(terminal)
+
+    def add_pin_group_terminal(
+        self,
+        pin_group,
+        name,
+        impedance,
+        boundary_type,
+        reference_terminal=None,
+        amplitude=1,
+        phase=0,
+        terminal_to_ground="kNoGround",
+    ):
+        terminal = CfgPinGroupTerminal(
+            pin_group=pin_group,
+            name=name,
+            impedance=impedance,
+            is_circuit_port=True,
+            boundary_type=boundary_type,
+            reference_terminal=reference_terminal,
+            amplitude=amplitude,
+            phase=phase,
+            terminal_to_ground=terminal_to_ground,
+            hfss_type=None,
+        )
+        self.terminals.append(terminal)
+
+    def add_point_terminal(
+        self,
+        x,
+        y,
+        layer,
+        name,
+        impedance,
+        boundary_type,
+        net,
+        reference_terminal=None,
+        amplitude=1,
+        phase=0,
+        terminal_to_ground="kNoGround",
+    ):
+        terminal = CfgPointTerminal(
+            x=x,
+            y=y,
+            layer=layer,
+            name=name,
+            impedance=impedance,
+            is_circuit_port=True,
+            boundary_type=boundary_type,
+            reference_terminal=reference_terminal,
+            amplitude=amplitude,
+            phase=phase,
+            net=net,
+            terminal_to_ground=terminal_to_ground,
+            hfss_type=None,
+        )
+        self.terminals.append(terminal)
+
+    def add_edge_terminal(
+        self,
+        name,
+        impedance,
+        is_circuit_port,
+        boundary_type,
+        primitive,
+        point_on_edge_x,
+        point_on_edge_y,
+        horizontal_extent_factor=6,
+        vertical_extent_factor=8,
+        pec_launch_width="0.02mm",
+        reference_terminal=None,
+        amplitude=1,
+        phase=0,
+        terminal_to_ground="kNoGround",
+    ):
+        terminal = CfgEdgeTerminal(
+            name=name,
+            impedance=impedance,
+            is_circuit_port=is_circuit_port,
+            boundary_type=boundary_type,
+            reference_terminal=reference_terminal,
+            amplitude=amplitude,
+            phase=phase,
+            terminal_to_ground=terminal_to_ground,
+            primitive=primitive,
+            point_on_edge_x=point_on_edge_x,
+            point_on_edge_y=point_on_edge_y,
+            horizontal_extent_factor=horizontal_extent_factor,
+            vertical_extent_factor=vertical_extent_factor,
+            pec_launch_width=pec_launch_width,
+            hfss_type="Wave",
+        )
+        self.terminals.append(terminal)
+
+    def add_bundle_terminal(
+        self,
+        terminals,
+        name,
+    ):
+        terminal = CfgBundleTerminal(
+            terminals=terminals,
+            name=name,
+        )
+        self.terminals.append(terminal)

pyedb/configuration/configuration.py

@@ -29,6 +29,8 @@ import toml
 
 from pyedb import Edb
 from pyedb.configuration.cfg_data import CfgData
+from pyedb.dotnet.database.general import convert_py_list_to_net_list
+from pyedb.misc.decorators import execution_timer
 
 
 class Configuration:
@@ -146,8 +148,9 @@ class Configuration:
         self.__apply_with_logging("Applying package definitions", self.cfg_data.package_definitions.apply)
         self.__apply_with_logging("Applying modeler", self.apply_modeler)
         self.__apply_with_logging("Placing ports", self.cfg_data.ports.apply)
+        self.apply_terminals()
         self.__apply_with_logging("Placing probes", self.cfg_data.probes.apply)
-        self.__apply_with_logging("Applying operations", self.apply_operations)
+        self.apply_operations()
 
         return True
 
@@ -433,6 +436,9 @@ class Configuration:
             setups = self.cfg_data.setups
             setups.retrieve_parameters_from_edb()
             data["setups"] = setups.to_dict()
+        if kwargs.get("terminals", False):
+            self.get_terminals()
+            data.update(self.cfg_data.terminals.model_dump(exclude_none=True))
         if kwargs.get("sources", False):
             data["sources"] = self.cfg_data.sources.get_data_from_db()
         if kwargs.get("ports", False):
@@ -472,6 +478,7 @@ class Configuration:
 
         return data
 
+    @execution_timer("Applying operations")
     def apply_operations(self):
         """Apply operations to the current design."""
         op_cutout = self.cfg_data.operations.cutout
@@ -530,6 +537,138 @@ class Configuration:
                 signal_list=signal_list,
             )
 
+    @execution_timer("Placing terminals")
+    def apply_terminals(self):
+        terminals_dict = {}
+        bungle_terminals = []
+        edge_terminals = {}
+        for cfg_terminal in self.cfg_data.terminals.terminals:
+            if cfg_terminal.terminal_type == "padstack_instance":
+                if cfg_terminal.padstack_instance_id:
+                    pds = self._pedb.layout.find_padstack_instances(
+                        instance_id=cfg_terminal.padstack_instance_id,
+                        aedt_name=None,
+                        component_name=None,
+                        component_pin_name=None,
+                    )[0]
+                else:
+                    pds = self._pedb.layout.find_padstack_instances(
+                        instance_id=None,
+                        aedt_name=cfg_terminal.padstack_instance,
+                        component_name=None,
+                        component_pin_name=None,
+                    )[0]
+                terminal = pds.create_terminal(name=cfg_terminal.name)
+
+            elif cfg_terminal.terminal_type == "pin_group":
+                pg = self._pedb.siwave.pin_groups[cfg_terminal.pin_group]
+                terminal = pg.create_terminal(name=cfg_terminal.name)
+            elif cfg_terminal.terminal_type == "point":
+                terminal = self._pedb.get_point_terminal(
+                    cfg_terminal.name, cfg_terminal.net, [cfg_terminal.x, cfg_terminal.y], cfg_terminal.layer
+                )
+            elif cfg_terminal.terminal_type == "edge":
+                pt = self._pedb.pedb_class.database.geometry.point_data.PointData.create_from_xy(
+                    self._pedb, x=cfg_terminal.point_on_edge_x, y=cfg_terminal.point_on_edge_y
+                )
+                primitive = self._pedb.layout.primitives_by_aedt_name[cfg_terminal.primitive]
+                edge = self._pedb.core.Cell.Terminal.PrimitiveEdge.Create(primitive._edb_object, pt._edb_object)
+                edge = convert_py_list_to_net_list(edge, self._pedb.core.Cell.Terminal.Edge)
+                _terminal = self._pedb.core.Cell.Terminal.EdgeTerminal.Create(
+                    primitive._edb_object.GetLayout(),
+                    primitive._edb_object.GetNet(),
+                    cfg_terminal.name,
+                    edge,
+                    isRef=False,
+                )
+                terminal = self._pedb.pedb_class.database.cell.terminal.edge_terminal.EdgeTerminal(
+                    self._pedb, _terminal
+                )
+                terminal.horizontal_extent_factor = terminal.horizontal_extent_factor
+                terminal.vertical_extent_factor = terminal.vertical_extent_factor
+                terminal.pec_launch_width = terminal.pec_launch_width
+                terminal.do_renormalize = True
+                edge_terminals[cfg_terminal.name] = terminal
+            elif cfg_terminal.terminal_type == "bundle":
+                bungle_terminals.append(cfg_terminal)
+                continue
+            else:
+                self._pedb.logger.warning(f"Terminal type {cfg_terminal.terminal_type} not supported.")
+                continue
+
+            terminal.impedance = cfg_terminal.impedance
+            terminal.is_circuit_port = cfg_terminal.is_circuit_port
+            terminal.boundary_type = cfg_terminal.boundary_type
+            terminal.source_amplitude = cfg_terminal.amplitude
+            terminal.source_phase = cfg_terminal.phase
+            terminal.terminal_to_ground = cfg_terminal.terminal_to_ground
+
+            terminals_dict[cfg_terminal.name] = cfg_terminal, terminal
+
+        for _, obj in terminals_dict.items():
+            cfg, obj = obj
+            if cfg.reference_terminal:
+                obj.reference_terminal = terminals_dict[cfg.reference_terminal][1]
+
+        for i in bungle_terminals:
+            boundle_terminal = self._pedb.pedb_class.database.cell.terminal.bundle_terminal.BundleTerminal.create(
+                self._pedb, i.name, i.terminals
+            )
+            bundle_term = boundle_terminal.terminals
+            bundle_term[0].name = i.name + ":T1"
+            bundle_term[1].mame = i.name + ":T2"
+
+    @execution_timer("Retrieving terminal information")
+    def get_terminals(self):
+        manager = self.cfg_data.terminals
+        manager.terminals = []
+        for i in self._pedb.terminals.values():
+            if i.terminal_type == "PadstackInstanceTerminal":
+                manager.add_padstack_instance_terminal(
+                    padstack_instance=i.padstack_instance.aedt_name,
+                    padstack_instance_id=i.padstack_instance.id,
+                    name=i.name,
+                    impedance=i.impedance,
+                    is_circuit_port=i.is_circuit_port,
+                    boundary_type=i.boundary_type,
+                    amplitude=i.source_amplitude,
+                    phase=i.source_phase,
+                    terminal_to_ground=i.terminal_to_ground,
+                    reference_terminal=i.reference_terminal.name if i.reference_terminal else None,
+                    hfss_type=i.hfss_type if i.hfss_type else "Wave",
+                )
+            elif i.terminal_type == "PinGroupTerminal":
+                manager.add_pin_group_terminal(
+                    pin_group=i.pin_group().name,
+                    name=i.name,
+                    impedance=i.impedance,
+                    boundary_type=i.boundary_type,
+                    reference_terminal=i.reference_terminal.name if i.reference_terminal else None,
+                    amplitude=i.source_amplitude,
+                    phase=i.source_phase,
+                    terminal_to_ground=i.terminal_to_ground,
+                )
+            elif i.terminal_type == "PointTerminal":
+                manager.add_point_terminal(
+                    x=i.location[0],
+                    y=i.location[1],
+                    layer=i.layer.name,
+                    name=i.name,
+                    impedance=i.impedance,
+                    boundary_type=i.boundary_type,
+                    reference_terminal=i.reference_terminal.name if i.reference_terminal else None,
+                    amplitude=i.source_amplitude,
+                    phase=i.source_phase,
+                    terminal_to_ground=i.terminal_to_ground,
+                    net=i.net_name,
+                )
+            elif i.terminal_type == "EdgeTerminal":
+                pass
+            elif i.terminal_type == "BundleTerminal":
+                pass
+            else:  # pragma: no cover
+                raise RuntimeError(f"Terminal type {i.terminal_type} not supported.")
+
     def export(
         self,
         file_path,
@@ -547,6 +686,7 @@ class Configuration:
         padstacks=True,
         general=True,
         variables=True,
+        terminals=False,
     ):
         """Export the configuration data from layout to a file.
 
@@ -561,9 +701,9 @@ class Configuration:
         setups : bool
             Whether to export setups or not.
         sources : bool
-            Whether to export sources or not.
+            Whether to export sources or not. Alternative to terminals.
         ports : bool
-            Whether to export ports or not.
+            Whether to export ports or not. Alternative to terminals.
         nets : bool
             Whether to export nets.
         pin_groups : bool
@@ -582,6 +722,8 @@ class Configuration:
             Whether to export general information.
         variables : bool
             Whether to export variable.
+        terminals : bool
+            Whether to export terminals. Alternative to ports and sources.
         Returns
         -------
         bool
@@ -601,6 +743,7 @@ class Configuration:
             padstacks=padstacks,
             general=general,
             variables=variables,
+            terminals=terminals,
         )
 
         file_path = file_path if isinstance(file_path, Path) else Path(file_path)

pyedb/dotnet/clr_module.py

@@ -51,8 +51,7 @@ if is_linux:  # pragma: no cover
         # TODO: Fall backing to dotnetcore2 should be removed in a near future.
         except Exception:
             warnings.warn(
-                "Unable to set .NET root and locate the runtime configuration file. "
-                "Falling back to using dotnetcore2."
+                "Unable to set .NET root and locate the runtime configuration file. Falling back to using dotnetcore2."
             )
             warnings.warn(LINUX_WARNING)