pyedb
Advanced tools
| # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| # SPDX-License-Identifier: MIT | ||
| # | ||
| # | ||
| # Permission is hereby granted, free of charge, to any person obtaining a copy | ||
| # of this software and associated documentation files (the "Software"), to deal | ||
| # in the Software without restriction, including without limitation the rights | ||
| # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
| # copies of the Software, and to permit persons to whom the Software is | ||
| # furnished to do so, subject to the following conditions: | ||
| # | ||
| # The above copyright notice and this permission notice shall be included in all | ||
| # copies or substantial portions of the Software. | ||
| # | ||
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
| # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
| # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
| # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
| # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
| # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
| # SOFTWARE. | ||
| class WirebondDef: | ||
| def __init__(self, edb, edb_object): | ||
| self._edb_object = edb_object | ||
| self._pedb = edb | ||
| @property | ||
| def name(self): | ||
| return self._edb_object.GetName() | ||
| def delete(self): | ||
| self._edb_object.delete() | ||
| @property | ||
| def height(self): | ||
| return self._edb_object.GetParameters().ToDouble() | ||
| @height.setter | ||
| def height(self, value: float): | ||
| self._edb_object.SetParameters(self._pedb.edb_value(value)) | ||
| class Jedec4BondwireDef(WirebondDef): | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(pedb, edb_object) | ||
| self._edb_object = edb_object | ||
| self._pedb = pedb | ||
| @classmethod | ||
| def find_by_name(cls, edb, name: str): | ||
| jedec4_def = next((wb_def for wb_def in list(edb._db.Jedec4BondwireDefs) if wb_def.GetName() == name), None) | ||
| if jedec4_def is None: | ||
| return None | ||
| return cls(edb, jedec4_def) | ||
| @classmethod | ||
| def create(cls, edb, name: str, top_to_die_distance: float = 30e-6): | ||
| jedec4_def = edb._db.Jedec4BondwireDefs.Create(edb._db, name, edb.edb_value(top_to_die_distance)) | ||
| return cls(edb, jedec4_def) | ||
| class Jedec5BondwireDef(WirebondDef): | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(pedb, edb_object) | ||
| self._pedb = pedb | ||
| self._edb_object = edb_object | ||
| @classmethod | ||
| def find_by_name(cls, edb, name: str): | ||
| jedec5_def = next((wb_def for wb_def in list(edb._db.Jedec5BondwireDefs) if wb_def.GetName() == name), None) | ||
| if jedec5_def is None: | ||
| return None | ||
| return cls(edb, jedec5_def) | ||
| @classmethod | ||
| def create(cls, edb, name: str, top_to_die_distance: float = 30e-6): | ||
| jedec5_def = edb._db.Jedec5BondwireDefs.Create(edb._db, name, edb.edb_value(top_to_die_distance)) | ||
| return cls(edb, jedec5_def) | ||
| class ApdBondwireDef(WirebondDef): | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(pedb, edb_object) | ||
| self._pedb = pedb | ||
| self._edb_object = edb_object | ||
| @classmethod | ||
| def find_by_name(cls, edb, name: str): | ||
| apd_def = next((wb_def for wb_def in list(edb._db.ApdBondwireDefs) if wb_def.GetName() == name), None) | ||
| if apd_def is None: | ||
| return None | ||
| return cls(edb, apd_def) | ||
| @classmethod | ||
| def create(cls, edb, name: str, top_to_die_distance: float = 30e-6): | ||
| apd_def = edb._db.ApdBondwireDefs.Create(edb._db, name, edb.edb_value(top_to_die_distance)) | ||
| return cls(edb, apd_def) |
| # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| # SPDX-License-Identifier: MIT | ||
| # | ||
| # | ||
| # Permission is hereby granted, free of charge, to any person obtaining a copy | ||
| # of this software and associated documentation files (the "Software"), to deal | ||
| # in the Software without restriction, including without limitation the rights | ||
| # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
| # copies of the Software, and to permit persons to whom the Software is | ||
| # furnished to do so, subject to the following conditions: | ||
| # | ||
| # The above copyright notice and this permission notice shall be included in all | ||
| # copies or substantial portions of the Software. | ||
| # | ||
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
| # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
| # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
| # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
| # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
| # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
| # SOFTWARE. | ||
| from ansys.edb.core.definition.bondwire_def import ( | ||
| ApdBondwireDef as GrpcApdBondwireDef, | ||
| Jedec4BondwireDef as GrpcJedec4BondwireDef, | ||
| Jedec5BondwireDef as GrpcJedec5BondwireDef, | ||
| ) | ||
| class BondwireDef: | ||
| def __init__(self, pedb, core=None): | ||
| self._pedb = pedb | ||
| self.core = core | ||
| @property | ||
| def name(self): | ||
| """Get the name of the bondwire definition.""" | ||
| return self.core.name.value | ||
| @name.setter | ||
| def name(self, value): | ||
| """Set the name of the bondwire definition.""" | ||
| self.core.name = self._pedb.value(value) | ||
| @property | ||
| def height(self): | ||
| """Get the bondwire top-to-die distance of the bondwire definition.""" | ||
| return self.get_parameters() | ||
| @height.setter | ||
| def height(self, value): | ||
| """Set the bondwire top-to-die distance of the bondwire definition.""" | ||
| self.set_parameters(value) | ||
| def delete(self): | ||
| self.core.delete() | ||
| def get_parameters(self): | ||
| """Get the bondwire top-to-die distance of the JEDEC 4 bondwire definition. | ||
| Returns | ||
| ------- | ||
| float | ||
| Bondwire top-to-die distance. | ||
| """ | ||
| return self.core.get_parameters().value | ||
| def set_parameters(self, parameters): | ||
| """Set the bondwire top-to-die distance of the JEDEC 4 bondwire definition. | ||
| Parameters | ||
| ---------- | ||
| parameters : float | ||
| Bondwire top-to-die distance. | ||
| """ | ||
| self.core.set_parameters(self._pedb.value(parameters)) | ||
| class Jedec4BondwireDef(BondwireDef): | ||
| """Class representing a JEDEC 4 bondwire definition.""" | ||
| def __init__(self, pedb, core=None): | ||
| super().__init__(pedb, core) | ||
| self._pedb = pedb | ||
| self.core = core | ||
| @classmethod | ||
| def create(cls, edb, name): | ||
| """Create a new JEDEC 4 bondwire definition. | ||
| Parameters | ||
| ---------- | ||
| edb : :class:`pyedb.edb` | ||
| Inherited AEDT object. | ||
| name : str | ||
| Name of the JEDEC 4 bondwire definition. | ||
| Returns | ||
| ------- | ||
| :class:`pyedb.grpc.database.definition.wirebond_def.Jedec4BondwireDef` | ||
| The created JEDEC 4 bondwire definition. | ||
| """ | ||
| grpc_bondwire_def = GrpcJedec4BondwireDef.create(edb._db, name) | ||
| return cls(edb, grpc_bondwire_def) | ||
| @staticmethod | ||
| def find_by_name(edb, name): | ||
| """Find a JEDEC 4 bondwire definition by name. | ||
| Parameters | ||
| ---------- | ||
| edb : :class:`pyedb.edb` | ||
| Inherited AEDT object. | ||
| name : str | ||
| Name of the JEDEC 4 bondwire definition. | ||
| Returns | ||
| ------- | ||
| :class:`pyedb.grpc.database.definition.wirebond_def.Jedec4BondwireDef` or None | ||
| The found JEDEC 4 bondwire definition or None if not found. | ||
| """ | ||
| grpc_bondwire_def = GrpcJedec4BondwireDef.find_by_name(edb._db, name) | ||
| if grpc_bondwire_def: | ||
| return Jedec4BondwireDef(edb, grpc_bondwire_def) | ||
| return None | ||
| class Jedec5BondwireDef(BondwireDef): | ||
| """Class representing a JEDEC 5 bondwire definition.""" | ||
| def __init__(self, pedb, core=None): | ||
| super().__init__(pedb, core) | ||
| self._pedb = pedb | ||
| self.core = core | ||
| @classmethod | ||
| def create(cls, edb, name): | ||
| """Create a new JEDEC 5 bondwire definition. | ||
| Parameters | ||
| ---------- | ||
| edb : :class:`pyedb.edb` | ||
| Inherited AEDT object. | ||
| name : str | ||
| Name of the JEDEC 5 bondwire definition. | ||
| Returns | ||
| ------- | ||
| :class:`pyedb.grpc.database.definition.wirebond_def.Jedec5BondwireDef` | ||
| The created JEDEC 5 bondwire definition. | ||
| """ | ||
| grpc_bondwire_def = GrpcJedec5BondwireDef.create(edb._db, name) | ||
| return cls(edb, grpc_bondwire_def) | ||
| @staticmethod | ||
| def find_by_name(edb, name): | ||
| """Find a JEDEC 5 bondwire definition by name. | ||
| Parameters | ||
| ---------- | ||
| edb : :class:`pyedb.edb` | ||
| Inherited AEDT object. | ||
| name : str | ||
| Name of the JEDEC 5 bondwire definition. | ||
| Returns | ||
| ------- | ||
| :class:`pyedb.grpc.database.definition.wirebond_def.Jedec5BondwireDef` or None | ||
| The found JEDEC 5 bondwire definition or None if not found. | ||
| """ | ||
| grpc_bondwire_def = GrpcJedec5BondwireDef.find_by_name(edb._db, name) | ||
| if grpc_bondwire_def: | ||
| return Jedec5BondwireDef(edb, grpc_bondwire_def) | ||
| return None | ||
| class ApdBondwireDef(BondwireDef): | ||
| """Class representing an Apd bondwire definition.""" | ||
| def __init__(self, pedb, core=None): | ||
| super().__init__(pedb, core) | ||
| self._pedb = pedb | ||
| self.core = core | ||
| @classmethod | ||
| def create(cls, edb, name): | ||
| """Create a new Apd bondwire definition. | ||
| Parameters | ||
| ---------- | ||
| edb : :class:`pyedb.edb` | ||
| Inherited AEDT object. | ||
| name : str | ||
| Name of the Apd bondwire definition. | ||
| Returns | ||
| ------- | ||
| :class:`pyedb.grpc.database.definition.wirebond_def.ApdBondwireDef` | ||
| The created Apd bondwire definition. | ||
| """ | ||
| grpc_bondwire_def = GrpcApdBondwireDef.create(edb._db, name) | ||
| return cls(edb, grpc_bondwire_def) | ||
| @staticmethod | ||
| def find_by_name(edb, name): | ||
| """Find an Apd bondwire definition by name. | ||
| Parameters | ||
| ---------- | ||
| edb : :class:`pyedb.edb` | ||
| Inherited AEDT object. | ||
| name : str | ||
| Name of the Apd bondwire definition. | ||
| Returns | ||
| ------- | ||
| :class:`pyedb.grpc.database.definition.wirebond_def.ApdBondwireDef` or None | ||
| The found Apd bondwire definition or None if not found. | ||
| """ | ||
| grpc_bondwire_def = GrpcApdBondwireDef.find_by_name(edb._db, name) | ||
| if grpc_bondwire_def: | ||
| return ApdBondwireDef(edb, grpc_bondwire_def) | ||
| return None |
| # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| # SPDX-License-Identifier: MIT | ||
| # | ||
| # | ||
| # Permission is hereby granted, free of charge, to any person obtaining a copy | ||
| # of this software and associated documentation files (the "Software"), to deal | ||
| # in the Software without restriction, including without limitation the rights | ||
| # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
| # copies of the Software, and to permit persons to whom the Software is | ||
| # furnished to do so, subject to the following conditions: | ||
| # | ||
| # The above copyright notice and this permission notice shall be included in all | ||
| # copies or substantial portions of the Software. | ||
| # | ||
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
| # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
| # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
| # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
| # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
| # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
| # SOFTWARE. | ||
| class ObjBase: | ||
| def __init__(self, pedb, core): | ||
| self.core = core | ||
| self._pedb = pedb | ||
| @property | ||
| def is_null(self): | ||
| """Check if the terminal is a null terminal. | ||
| Returns | ||
| ------- | ||
| bool | ||
| ``True`` if the terminal is a null terminal, ``False`` otherwise. | ||
| """ | ||
| return self.core.is_null |
| # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| # SPDX-License-Identifier: MIT | ||
| # | ||
| # | ||
| # Permission is hereby granted, free of charge, to any person obtaining a copy | ||
| # of this software and associated documentation files (the "Software"), to deal | ||
| # in the Software without restriction, including without limitation the rights | ||
| # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
| # copies of the Software, and to permit persons to whom the Software is | ||
| # furnished to do so, subject to the following conditions: | ||
| # | ||
| # The above copyright notice and this permission notice shall be included in all | ||
| # copies or substantial portions of the Software. | ||
| # | ||
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
| # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
| # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
| # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
| # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
| # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
| # SOFTWARE. | ||
| from pyedb.grpc.database.inner.layout_obj import LayoutObj | ||
| class ConnObj(LayoutObj): | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(pedb, edb_object) |
| # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| # SPDX-License-Identifier: MIT | ||
| # | ||
| # | ||
| # Permission is hereby granted, free of charge, to any person obtaining a copy | ||
| # of this software and associated documentation files (the "Software"), to deal | ||
| # in the Software without restriction, including without limitation the rights | ||
| # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
| # copies of the Software, and to permit persons to whom the Software is | ||
| # furnished to do so, subject to the following conditions: | ||
| # | ||
| # The above copyright notice and this permission notice shall be included in all | ||
| # copies or substantial portions of the Software. | ||
| # | ||
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
| # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
| # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
| # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
| # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
| # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
| # SOFTWARE. | ||
| from ansys.edb.core.database import ProductIdType as GrpcProductIdType | ||
| from pyedb.grpc.database.inner.base import ObjBase | ||
| class LayoutObj(ObjBase): | ||
| """Represents a layout object.""" | ||
| def __init__(self, pedb, core): | ||
| super().__init__(pedb, core) | ||
| @property | ||
| def _edb_properties(self): | ||
| p = self.core.get_product_property(GrpcProductIdType.DESIGNER, 18) | ||
| return p | ||
| @_edb_properties.setter | ||
| def _edb_properties(self, value): | ||
| self.core.set_product_property(GrpcProductIdType.DESIGNER, 18, value) |
+2
-1
| Metadata-Version: 2.4 | ||
| Name: pyedb | ||
| Version: 0.67.0 | ||
| Version: 0.67.1 | ||
| Summary: Higher-Level Pythonic Ansys Electronics Data Base | ||
@@ -36,2 +36,3 @@ Author-email: "ANSYS, Inc." <pyansys.core@ansys.com> | ||
| Requires-Dist: scipy>=1.13, <2.0 | ||
| Requires-Dist: xmltodict | ||
| Requires-Dist: ansys-sphinx-theme[autoapi]>=1.0.0,<1.7 ; extra == "doc" | ||
@@ -38,0 +39,0 @@ Requires-Dist: imageio>=2.30.0,<2.38 ; extra == "doc" |
+1
-0
@@ -45,2 +45,3 @@ [build-system] | ||
| "scipy>=1.13, <2.0", | ||
| "xmltodict" | ||
| ] | ||
@@ -47,0 +48,0 @@ |
@@ -62,3 +62,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| pyedb_path = os.path.dirname(__file__) | ||
| __version__ = "0.67.0" | ||
| __version__ = "0.67.1" | ||
| version = __version__ | ||
@@ -65,0 +65,0 @@ |
@@ -39,4 +39,10 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| auto_identify_nets: CfgAutoIdentifyNets | None = CfgAutoIdentifyNets() | ||
| signal_list: Optional[List[str]] = None | ||
| reference_list: Optional[List[str]] = None | ||
| signal_nets: Optional[List[str]] = Field( | ||
| default=None, | ||
| alias="signal_list", | ||
| ) | ||
| reference_nets: Optional[List[str]] = Field( | ||
| default=None, | ||
| alias="reference_list", | ||
| ) | ||
| extent_type: Optional[str] = "ConvexHull" | ||
@@ -49,3 +55,5 @@ expansion_size: Optional[Union[float, str]] = 0.002 | ||
| model_config = dict(populate_by_name=True) | ||
| class CfgOperations(BaseModel): | ||
@@ -52,0 +60,0 @@ cutout: Optional[CfgCutout] = None |
@@ -42,3 +42,5 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| phase: Optional[Union[float, int, str]] = 0 | ||
| terminal_to_ground: Optional[Literal["kNoGround", "kNegative", "kPositive"]] = "kNoGround" | ||
| terminal_to_ground: Literal["kNoGround", "kNegative", "kPositive", "no_ground", "negative", "positive"] | None = ( | ||
| "kNoGround" | ||
| ) | ||
| boundary_type: Literal[ | ||
@@ -55,2 +57,9 @@ "PortBoundary", | ||
| "InvalidBoundary", | ||
| "port", | ||
| "dc_terminal", | ||
| "voltage_probe", | ||
| "voltage_source", | ||
| "current_source", | ||
| "rlc", | ||
| "pec", | ||
| ] | ||
@@ -227,2 +236,3 @@ hfss_type: Literal["Wave", "Gap", None] | ||
| terminal_to_ground="kNoGround", | ||
| hfss_type="Wave", | ||
| ): | ||
@@ -244,3 +254,3 @@ terminal = CfgEdgeTerminal( | ||
| pec_launch_width=pec_launch_width, | ||
| hfss_type="Wave", | ||
| hfss_type=hfss_type, | ||
| ) | ||
@@ -247,0 +257,0 @@ self.terminals.append(terminal) |
@@ -626,3 +626,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| if auto_identify_nets["enabled"]: | ||
| reference_list = cutout_params.get("reference_list", []) | ||
| reference_nets = cutout_params.get("reference_nets", []) | ||
| if auto_identify_nets: | ||
@@ -637,3 +637,3 @@ self._pedb.nets.generate_extended_nets( | ||
| for i in self._pedb.terminals.values(): | ||
| if i.net_name in reference_list: | ||
| if i.net_name in reference_nets: | ||
| continue | ||
@@ -643,3 +643,3 @@ | ||
| if extended_net: | ||
| temp = [i2 for i2 in extended_net.nets.keys() if i2 not in reference_list] | ||
| temp = [i2 for i2 in extended_net.nets.keys() if i2 not in reference_nets] | ||
| temp = [i2 for i2 in temp if i2 not in signal_nets] | ||
@@ -650,3 +650,3 @@ signal_nets.extend(temp) | ||
| cutout_params["signal_list"] = signal_nets | ||
| cutout_params["signal_nets"] = signal_nets | ||
| polygon_points = self._pedb.cutout(**cutout_params) | ||
@@ -675,9 +675,7 @@ if "pyedb_cutout" not in self._pedb.stackup.all_layers: | ||
| net_names.append(name) | ||
| reference_list = [] | ||
| signal_list = net_names | ||
| self.cfg_data.operations.add_cutout( | ||
| custom_extent=custom_extent, | ||
| reference_list=reference_list, | ||
| signal_list=signal_list, | ||
| reference_nets=[], | ||
| signal_nets=net_names, | ||
| ) | ||
@@ -723,2 +721,3 @@ | ||
| terminal.do_renormalize = True | ||
| terminal.hfss_type = cfg_terminal.hfss_type | ||
| edge_terminals[cfg_terminal.name] = terminal | ||
@@ -754,3 +753,3 @@ elif cfg_terminal.terminal_type == "bundle": | ||
| for i in self._pedb.terminals.values(): | ||
| if i.terminal_type == "PadstackInstanceTerminal": | ||
| if i.terminal_type in ["PadstackInstanceTerminal", "padstack_inst"]: | ||
| manager.add_padstack_instance_terminal( | ||
@@ -769,5 +768,5 @@ padstack_instance=i.padstack_instance.aedt_name, | ||
| ) | ||
| elif i.terminal_type == "PinGroupTerminal": | ||
| elif i.terminal_type in ["PinGroupTerminal", "pin_group"]: | ||
| manager.add_pin_group_terminal( | ||
| pin_group=i.pin_group().name, | ||
| pin_group=i.pin_group.name, | ||
| name=i.name, | ||
@@ -781,3 +780,3 @@ impedance=i.impedance, | ||
| ) | ||
| elif i.terminal_type == "PointTerminal": | ||
| elif i.terminal_type in ["PointTerminal", "point"]: | ||
| manager.add_point_terminal( | ||
@@ -784,0 +783,0 @@ x=i.location[0], |
@@ -54,2 +54,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| Returns | ||
@@ -56,0 +57,0 @@ ------- |
@@ -217,3 +217,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| if name not in self._pedb.definitions.package: | ||
| self._pedb.definitions.add_package_def(name, component_part_name=component_part_name) | ||
| self._pedb.definitions.add_package(name, component_part_name=component_part_name) | ||
| self.package_def = name | ||
@@ -220,0 +220,0 @@ |
@@ -67,2 +67,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| @property | ||
| def pin_group(self): | ||
@@ -69,0 +70,0 @@ """Gets the pin group the terminal refers to.""" |
@@ -23,4 +23,7 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| import warnings | ||
| from pyedb.dotnet.database.definition.component_def import EDBComponentDef | ||
| from pyedb.dotnet.database.definition.package_def import PackageDef | ||
| from pyedb.dotnet.database.definition.wirebond_def import ApdBondwireDef, Jedec4BondwireDef, Jedec5BondwireDef | ||
@@ -34,3 +37,14 @@ | ||
| def component(self): | ||
| """Component definitions""" | ||
| """Component definitions. | ||
| .. deprecated:: 0.66.0 | ||
| Use :attr:`components` instead. | ||
| """ | ||
| warnings.warn("component is deprecated, use components instead", DeprecationWarning, stacklevel=2) | ||
| return self.components | ||
| @property | ||
| def components(self): | ||
| return {l.GetName(): EDBComponentDef(self._pedb, l) for l in list(self._pedb.active_db.ComponentDefs)} | ||
@@ -40,8 +54,53 @@ | ||
| def package(self): | ||
| """Package definitions. | ||
| .. deprecated:: 0.66.0 | ||
| Use :attr:`packages` instead. | ||
| """ | ||
| warnings.warn("package is deprecated, use packages instead", DeprecationWarning, stacklevel=2) | ||
| return self.packages | ||
| @property | ||
| def packages(self): | ||
| """Package definitions.""" | ||
| return {l.GetName(): PackageDef(self._pedb, l) for l in list(self._pedb.active_db.PackageDefs)} | ||
| def add_package_def(self, name, component_part_name=None, boundary_points=None): | ||
| @property | ||
| def jedec4_bondwires(self): | ||
| """Wirebond definitions.""" | ||
| objs = getattr(self._pedb.active_db, "Jedec4BondwireDefs", None) | ||
| if not objs: | ||
| return {} | ||
| return {l.GetName(): Jedec4BondwireDef(self._pedb, l) for l in list(objs)} | ||
| @property | ||
| def jedec5_bondwires(self): | ||
| objs = getattr(self._pedb.active_db, "Jedec5BondwireDefs", None) | ||
| if not objs: | ||
| return {} | ||
| return {l.GetName(): Jedec5BondwireDef(self._pedb, l) for l in list(objs)} | ||
| @property | ||
| def apd_bondwires(self): | ||
| objs = getattr(self._pedb.active_db, "ApdBondwireDefs", None) | ||
| if not objs: | ||
| return {} | ||
| return {l.GetName(): ApdBondwireDef(self._pedb, l) for l in list(objs)} | ||
| def add_packages(self, name, component_part_name=None, boundary_points=None): | ||
| """Add a package definition. | ||
| .. deprecated:: 0.66.0 | ||
| Use :meth:`add_package` instead. | ||
| """ | ||
| warnings.warn("add_packages is deprecated, use add_package instead", DeprecationWarning) | ||
| return self.add_package(name, component_part_name=component_part_name, boundary_points=boundary_points) | ||
| def add_package(self, name, component_part_name=None, boundary_points=None): | ||
| """Add a package definition. | ||
| Parameters | ||
@@ -64,1 +123,52 @@ ---------- | ||
| return package_def | ||
| def create_jedec4_bondwire_def(self, name: str, top_to_die_distance: float = 30e-6): | ||
| """Create a JEDEC 4 bondwire definition. | ||
| Parameters | ||
| ---------- | ||
| name : str | ||
| Name of the bondwire definition. | ||
| top_to_die_distance : float, optional | ||
| Top to die distance in meters. The default is 30e-6. | ||
| Returns | ||
| ------- | ||
| Jedec4BondwireDef | ||
| The created JEDEC 4 bondwire definition. | ||
| """ | ||
| return Jedec4BondwireDef.create(self._pedb, name, top_to_die_distance) | ||
| def create_jedec5_bondwire_def(self, name: str, top_to_die_distance: float = 30e-6): | ||
| """Create a JEDEC 5 bondwire definition. | ||
| Parameters | ||
| ---------- | ||
| name : str | ||
| Name of the bondwire definition. | ||
| top_to_die_distance : float, optional | ||
| Top to die distance in meters. The default is 30e-6. | ||
| Returns | ||
| ------- | ||
| Jedec5BondwireDef | ||
| The created JEDEC 5 bondwire definition. | ||
| """ | ||
| return Jedec5BondwireDef.create(self._pedb, name, top_to_die_distance) | ||
| def create_apd_bondwire_def(self, name: str, top_to_die_distance: float = 30e-6): | ||
| """Create an APD bondwire definition. | ||
| Parameters | ||
| ---------- | ||
| name : str | ||
| Name of the bondwire definition. | ||
| top_to_die_distance : float, optional | ||
| Top to die distance in meters. The default is 30e-6. | ||
| Returns | ||
| ------- | ||
| ApdBondwireDef | ||
| The created APD bondwire definition. | ||
| """ | ||
| return ApdBondwireDef.create(self._pedb, name, top_to_die_distance) |
@@ -40,4 +40,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| self.core = edb_object | ||
| def __init__(self, pedb, core): | ||
| self.core = core | ||
| self._pedb = pedb | ||
@@ -261,4 +261,6 @@ | ||
| """ | ||
| return self.core.component_models | ||
| from pyedb.grpc.database.definition.component_model import ComponentModel | ||
| return {model.name: ComponentModel(model) for model in self.core.component_models} | ||
| @property | ||
@@ -265,0 +267,0 @@ def name(self): |
@@ -23,4 +23,7 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| from typing import Union | ||
| from ansys.edb.core.definition.component_model import ( | ||
| ComponentModel as GrpcComponentModel, | ||
| NPortComponentModel as GrpcNPortComponentModel, | ||
| ) | ||
@@ -30,12 +33,142 @@ | ||
| class ComponentModel: | ||
| """Class managing :class:`ComponentModel <ansys.edb.core.definition.component_model.ComponentModel>`.""" | ||
| """Class managing :class:`ComponentModel <pyedb.grpc.database.definition.component_model.ComponentModel>`.""" | ||
| def __init__(self): | ||
| self.core = GrpcComponentModel.__init__(self.msg) | ||
| def __init__(self, core): | ||
| self.core = GrpcComponentModel(core.msg) | ||
| @property | ||
| def is_null(self): | ||
| """Check if the component model is null. | ||
| class NPortComponentModel(GrpcComponentModel): | ||
| """Class managing :class:`NPortComponentModel <ansys.edb.core.definition.component_model.ComponentModel>`""" | ||
| Returns | ||
| ------- | ||
| bool | ||
| True if the component model is null, False otherwise. | ||
| def __init__(self): | ||
| self.core = GrpcComponentModel.__init__(self.msg) | ||
| """ | ||
| return self.core.is_null | ||
| @property | ||
| def name(self): | ||
| """Get the name of the component model. | ||
| Returns | ||
| ------- | ||
| str | ||
| The name of the component model. | ||
| """ | ||
| return self.core.name | ||
| @property | ||
| def reference_file(self): | ||
| """Get the reference file of the component model. | ||
| Returns | ||
| ------- | ||
| str | ||
| The reference file of the component model. | ||
| """ | ||
| return self.core.reference_file | ||
| class NPortComponentModel: | ||
| """Class managing :class:`NPortComponentModel <pyedb.grpc.database.definition.component_model.ComponentModel>`""" | ||
| def __init__(self, core): | ||
| self.core = GrpcComponentModel(core.msg) | ||
| @classmethod | ||
| def create(cls, name: str) -> "NPortComponentModel": | ||
| """Create an N-Port component model. | ||
| Parameters | ||
| ---------- | ||
| name : str | ||
| Name of the N-Port component model. | ||
| Returns | ||
| ------- | ||
| NPortComponentModel | ||
| The created N-Port component model object. | ||
| """ | ||
| return cls(GrpcNPortComponentModel.create(name)) | ||
| @classmethod | ||
| def find_by_id(cls, component_definition, id: int) -> Union[None, "NPortComponentModel"]: | ||
| """Find an N-Port component model by IO count in a given component definition. | ||
| Parameters | ||
| ---------- | ||
| component_definition : :class:`ComponentDef <pyedb.grpc.database.definition.component_def.ComponentDef>` | ||
| Component definition to search for the N-Port component model. | ||
| id : int | ||
| IO count of the N-Port component model. | ||
| Returns | ||
| ------- | ||
| NPortComponentModel | ||
| N-Port component model that is found, ``None`` otherwise. | ||
| """ | ||
| core_nport_model = GrpcNPortComponentModel.find_by_id(component_definition.core, id) | ||
| if not core_nport_model.is_null: | ||
| return cls(core_nport_model) | ||
| return None | ||
| @classmethod | ||
| def find_by_name(cls, component_definition, name: str) -> Union[None, "NPortComponentModel"]: | ||
| """Find an N-Port component model by name in a given component definition. | ||
| Parameters | ||
| ---------- | ||
| component_definition : :class:`ComponentDef <pyedb.grpc.database.definition.component_def.ComponentDef>` | ||
| Component definition to search for the N-Port component model. | ||
| name : str | ||
| Name of the N-Port component model. | ||
| Returns | ||
| ------- | ||
| NPortComponentModel | ||
| N-Port component model that is found, ``None`` otherwise. | ||
| """ | ||
| core_nport_model = GrpcNPortComponentModel.find_by_name(component_definition.core, name) | ||
| if not core_nport_model.is_null: | ||
| return cls(core_nport_model) | ||
| return None | ||
| @property | ||
| def is_null(self): | ||
| """Check if the N-Port component model is null. | ||
| Returns | ||
| ------- | ||
| bool | ||
| True if the N-Port component model is null, False otherwise. | ||
| """ | ||
| return self.core.is_null | ||
| @property | ||
| def name(self): | ||
| """Get the name of the N-Port component model. | ||
| Returns | ||
| ------- | ||
| str | ||
| The name of the N-Port component model. | ||
| """ | ||
| return self.core.name | ||
| @property | ||
| def reference_file(self): | ||
| """Get the reference file of the N-Port component model. | ||
| Returns | ||
| ------- | ||
| str | ||
| The reference file of the N-Port component model. | ||
| """ | ||
| return self.core.reference_file |
@@ -29,4 +29,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, edb_object): | ||
| self.core = edb_object | ||
| def __init__(self, core): | ||
| self.core = core | ||
@@ -33,0 +33,0 @@ @classmethod |
@@ -123,7 +123,7 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, edb: Edb, edb_material_def): | ||
| self.core = edb_material_def | ||
| def __init__(self, edb: Edb, core): | ||
| self.core = core | ||
| self.__edb: Edb = edb | ||
| self.__name: str = edb_material_def.name | ||
| self.__material_def = edb_material_def | ||
| self.__name: str = core.name | ||
| self.__material_def = core | ||
| self.__dielectric_model = None | ||
@@ -130,0 +130,0 @@ |
@@ -32,4 +32,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, edb_object): | ||
| self.core = edb_object | ||
| def __init__(self, core): | ||
| self.core = core | ||
@@ -36,0 +36,0 @@ @classmethod |
@@ -48,4 +48,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object=None, name=None, component_part_name=None, extent_bounding_box=None): | ||
| if not edb_object: | ||
| def __init__(self, pedb, core=None, name=None, component_part_name=None, extent_bounding_box=None): | ||
| if not core: | ||
| if name: | ||
@@ -55,3 +55,3 @@ edb_object = GrpcPackageDef.create(db=pedb.active_db, name=name) | ||
| raise AttributeError("Name must be provided to create and instantiate a PackageDef object.") | ||
| self.core = edb_object | ||
| self.core = core | ||
| self._pedb = pedb | ||
@@ -58,0 +58,0 @@ self._heat_sink = None |
@@ -63,8 +63,8 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, edb_padstack, layer_name, pad_type, p_edb_padstack): | ||
| self._edb_object = edb_padstack | ||
| def __init__(self, core, layer_name, pad_type, p_edb_padstack): | ||
| self._edb_object = core | ||
| self._pedbpadstack = p_edb_padstack | ||
| self.layer_name = layer_name | ||
| self.pad_type = pad_type | ||
| self._edb_padstack = self._edb_object | ||
| self._edb_padstack = core | ||
@@ -71,0 +71,0 @@ @property |
@@ -24,2 +24,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| from typing import Dict, List, Optional, Union | ||
| import warnings | ||
@@ -37,3 +38,75 @@ from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData | ||
| @property | ||
| def component(self) -> Dict[str, ComponentDef]: | ||
| def component_defs(self) -> Dict[str, ComponentDef]: | ||
| """Component definitions. | ||
| .. deprecated:: 0.66.0 | ||
| Use :attr:`components` instead. | ||
| """ | ||
| warnings.warn("component_defs is deprecated, use components instead", DeprecationWarning) | ||
| return self.components | ||
| @property | ||
| def component(self): | ||
| """Component definitions. | ||
| .. deprecated:: 0.66.0 | ||
| Use :attr:`components` instead. | ||
| """ | ||
| warnings.warn("component is deprecated, use components instead", DeprecationWarning) | ||
| return self.components | ||
| @property | ||
| def apd_bondwire_defs(self): | ||
| """Get all APD bondwire definitions in this Database. | ||
| .. deprecated:: 0.66.0 | ||
| Use :attr:`apd_bondwires` instead. | ||
| """ | ||
| warnings.warn("apd_bondwire_defs is deprecated, use apd_bondwires instead", DeprecationWarning) | ||
| return self.apd_bondwires | ||
| @property | ||
| def jedec4_bondwire_defs(self): | ||
| """Get all JEDEC4 bondwire definitions in this Database. | ||
| .. deprecated:: 0.66.0 | ||
| Use :attr:`jedec4_bondwires` instead. | ||
| """ | ||
| warnings.warn("jedec4_bondwire_defs is deprecated, use jedec4_bondwires instead", DeprecationWarning) | ||
| return self.jedec4_bondwires | ||
| @property | ||
| def jedec5_bondwire_defs(self): | ||
| """Get all JEDEC5 bondwire definitions in this Database. | ||
| .. deprecated:: 0.66.0 | ||
| Use :attr:`jedec5_bondwires` instead. | ||
| """ | ||
| warnings.warn("jedec5_bondwire_defs is deprecated, use jedec5_bondwires instead", DeprecationWarning) | ||
| return self.jedec5_bondwires | ||
| @property | ||
| def package_defs(self) -> Dict[str, PackageDef]: | ||
| """Package definitions. | ||
| .. deprecated:: 0.66.0 | ||
| Use :attr:`packages` instead. | ||
| """ | ||
| warnings.warn("package_defs is deprecated, use packages instead", DeprecationWarning) | ||
| return self.packages | ||
| @property | ||
| def components(self) -> Dict[str, ComponentDef]: | ||
| """Component definitions | ||
@@ -52,5 +125,17 @@ | ||
| @property | ||
| def package(self) -> Dict[str, PackageDef]: | ||
| def package(self): | ||
| """Package definitions. | ||
| .. deprecated:: 0.66.0 | ||
| Use :attr:`packages` instead. | ||
| """ | ||
| warnings.warn("package is deprecated, use packages instead", DeprecationWarning) | ||
| return self.packages | ||
| @property | ||
| def packages(self) -> Dict[str, PackageDef]: | ||
| """Package definitions. | ||
| Examples | ||
@@ -66,2 +151,47 @@ -------- | ||
| @property | ||
| def apd_bondwires(self): | ||
| """Get all APD bondwire definitions in this Database. | ||
| Returns | ||
| ------- | ||
| list[:class:`ApdBondwireDef <ansys.edb.definition.ApdBondwireDef>`] | ||
| """ | ||
| from pyedb.grpc.database.definition.wirebond_def import ApdBondwireDef | ||
| return { | ||
| apd_def.name.value: ApdBondwireDef(self._pedb, apd_def) | ||
| for apd_def in self._pedb.active_db.apd_bondwire_defs | ||
| } | ||
| @property | ||
| def jedec4_bondwires(self): | ||
| """Get all JEDEC4 bondwire definitions in this Database. | ||
| Returns | ||
| ------- | ||
| list[:class:`Jedec4BondwireDef <ansys.edb.definition.Jedec4BondwireDef>`] | ||
| """ | ||
| from pyedb.grpc.database.definition.wirebond_def import Jedec4BondwireDef | ||
| return { | ||
| apd_def.name.value: Jedec4BondwireDef(self._pedb, apd_def) | ||
| for apd_def in self._pedb.active_db.jedec4_bondwire_defs | ||
| } | ||
| @property | ||
| def jedec5_bondwires(self): | ||
| """Get all JEDEC5 bondwire definitions in this Database. | ||
| Returns | ||
| ------- | ||
| list[:class:`Jedec5BondwireDef <ansys.edb.definition.Jedec5BondwireDef>`] | ||
| """ | ||
| from pyedb.grpc.database.definition.wirebond_def import Jedec5BondwireDef | ||
| return { | ||
| jedec5_def.name.value: Jedec5BondwireDef(self._pedb, jedec5_def) | ||
| for jedec5_def in self._pedb.active_db.jedec5_bondwire_defs | ||
| } | ||
| def add_package_def( | ||
@@ -72,2 +202,15 @@ self, name: str, component_part_name: Optional[str] = None, boundary_points: Optional[List[List[float]]] = None | ||
| .. deprecated:: 0.66.0 | ||
| Use :meth:`add_package` instead. | ||
| """ | ||
| warnings.warn("add_package_def is deprecated, use add_package instead", DeprecationWarning, stacklevel=2) | ||
| return self.add_package(name, component_part_name=component_part_name, boundary_points=boundary_points) | ||
| def add_package( | ||
| self, name: str, component_part_name: Optional[str] = None, boundary_points: Optional[List[List[float]]] = None | ||
| ) -> Union[PackageDef, bool]: | ||
| """Add a package definition. | ||
| Parameters | ||
@@ -102,13 +245,13 @@ ---------- | ||
| """ | ||
| if not name in self.package: | ||
| if not name in self.packages: | ||
| package_def = PackageDef.create(self._pedb, name) | ||
| if component_part_name in self.component: | ||
| definition = self.component[component_part_name] | ||
| if component_part_name in self.components: | ||
| definition = self.components[component_part_name] | ||
| if not boundary_points and not definition.is_null: | ||
| package_def.exterior_boundary = GrpcPolygonData( | ||
| points=list(definition.components.values())[0].bounding_box | ||
| points=list(definition.components.values())[0].bounding_box # type: ignore[arg-type] | ||
| ) | ||
| if boundary_points: | ||
| package_def.exterior_boundary = GrpcPolygonData(points=boundary_points) | ||
| package_def.exterior_boundary = GrpcPolygonData(points=boundary_points) # type: ignore[arg-type] | ||
| return package_def | ||
| return False |
@@ -32,4 +32,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, edb_object): | ||
| self.core = edb_object | ||
| def __init__(self, core): | ||
| self.core = core | ||
@@ -36,0 +36,0 @@ @property |
@@ -41,3 +41,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| class Hfss(object): | ||
| class Hfss: | ||
| """Manages EDB methods for HFSS setup configuration. | ||
@@ -44,0 +44,0 @@ |
@@ -329,3 +329,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| if value not in [package.name for package in self._pedb.package_defs]: | ||
| if value not in self._pedb.definitions.package_defs: | ||
| from ansys.edb.core.definition.package_def import ( | ||
@@ -341,5 +341,5 @@ PackageDef as GrpcPackageDef, | ||
| elif isinstance(value, str): | ||
| package = next(package for package in self._pedb.package_defs if package.name == value) | ||
| package = next(package for package in self._pedb.definitions.package_defs.values() if package.name == value) | ||
| comp_prop = self.component_property | ||
| comp_prop.package_def = package | ||
| comp_prop.package_def = package.core | ||
| self.core.component_property = comp_prop | ||
@@ -433,3 +433,3 @@ | ||
| name = f"{self.refdes}_{self.part_name}" | ||
| if name not in [package.name for package in self._pedb.package_defs]: | ||
| if name not in self._pedb.definitions.packages: | ||
| self._pedb.definitions.add_package_def(name, component_part_name=component_part_name) | ||
@@ -436,0 +436,0 @@ |
@@ -230,3 +230,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| ) | ||
| return PinGroupTerminal(self._pedb, term) | ||
| return term | ||
@@ -233,0 +233,0 @@ def _json_format(self) -> dict[str, any]: |
@@ -57,8 +57,8 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, edb_object=None, name="", layer_type="undefined", **kwargs): | ||
| self.core = edb_object | ||
| def __init__(self, core=None, name="", layer_type="undefined", **kwargs): | ||
| self.core = core | ||
| self._name = name | ||
| self._color = () | ||
| self._type = "" | ||
| if edb_object: | ||
| if core: | ||
| self._cloned_layer = self.core.clone() | ||
@@ -85,3 +85,3 @@ else: | ||
| layer = GrpcLayer.create(name=name, lyr_type=layer_type_mapping[layer_type]) | ||
| return cls(edb_object=layer) | ||
| return cls(core=layer) | ||
@@ -88,0 +88,0 @@ @property |
@@ -42,4 +42,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| class StackupLayer: | ||
| def __init__(self, pedb, edb_object=None): | ||
| self.core = edb_object | ||
| def __init__(self, pedb, core=None): | ||
| self.core = core | ||
| self._pedb = pedb | ||
@@ -46,0 +46,0 @@ |
@@ -59,2 +59,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| -------- | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("edb_file") | ||
@@ -161,6 +162,5 @@ >>> # Find shorts without fixing | ||
| -------- | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("edb_file") | ||
| >>> # Find disjoint nets on all nets | ||
| >>> new_nets = edb.layout_validation.disjoint_nets() | ||
| >>> | ||
| >>> # Clean disjoints on specific nets with advanced options | ||
@@ -200,4 +200,4 @@ >>> cleaned = edb.layout_validation.disjoint_nets( | ||
| for net in net_list: | ||
| net_groups = [] | ||
| obj_dict = {} | ||
| net_groups: List[List[int]] = [] | ||
| obj_dict: dict[int, Any] = {} | ||
| for i in _objects_list.get(net, []): | ||
@@ -213,5 +213,5 @@ obj_dict[i.id] = i | ||
| repetition = False | ||
| for net_list in net_groups: | ||
| if set(l1).intersection(net_list): | ||
| net_groups.append([i for i in l1 if i not in net_list]) | ||
| for group in net_groups: | ||
| if set(l1).intersection(group): | ||
| net_groups.append([i for i in l1 if i not in group]) | ||
| repetition = True | ||
@@ -224,15 +224,23 @@ if not repetition: | ||
| def area_calc(elem): | ||
| sum = 0 | ||
| for el in elem: | ||
| def area_calc(elem: List[int]) -> float: | ||
| """Calculate total area for a group of element ids. | ||
| The layout groups are stored as lists of element ids; resolve to | ||
| actual objects using ``obj_dict`` before computing area. | ||
| """ | ||
| total = 0.0 | ||
| for el_id in elem: | ||
| obj = obj_dict.get(el_id) | ||
| if obj is None: | ||
| continue | ||
| try: | ||
| if el.layout_obj.obj_type.value == 0: | ||
| if not el.is_void: | ||
| sum += el.area() | ||
| if obj.layout_obj.obj_type.value == 0: | ||
| if not getattr(obj, "is_void", False): | ||
| total += obj.area() | ||
| except Exception as e: | ||
| self._pedb._logger.warning( | ||
| f"A(n) {type(e).__name__} error occurred while calculating area " | ||
| f"for element {elem} - Default value of 0 is used: {str(e)}" | ||
| f"for element {el_id} - Default value of 0 is used: {str(e)}" | ||
| ) | ||
| return sum | ||
| return total | ||
@@ -300,2 +308,3 @@ if order_by_area: | ||
| -------- | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("edb_file") | ||
@@ -327,2 +336,3 @@ >>> # Fix self-intersections on all nets | ||
| -------- | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("edb_file") | ||
@@ -355,2 +365,3 @@ >>> # Identify illegal net names | ||
| -------- | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("edb_file") | ||
@@ -360,4 +371,4 @@ >>> # Identify components with illegal RLC values | ||
| >>> | ||
| >>> # Automatically fix invalid inductor values | ||
| >>> edb.layout_validation.illegal_rlc_values(fix=True) | ||
| # Automatically fix invalid inductor values | ||
| # edb.layout_validation.illegal_rlc_values(fix=True) | ||
| """ | ||
@@ -381,8 +392,7 @@ inductors = self._pedb.components.inductors | ||
| -------- | ||
| >>> edb = Edb("edb_file") | ||
| >>> # Report unnamed padstacks | ||
| >>> edb.layout_validation.padstacks_no_name() | ||
| # Use an Edb instance (see `dc_shorts` example above) and call: | ||
| # edb.layout_validation.padstacks_no_name() | ||
| >>> | ||
| >>> # Automatically assign names to unnamed padstacks | ||
| >>> edb.layout_validation.padstacks_no_name(fix=True) | ||
| # Automatically assign names to unnamed padstacks | ||
| # edb.layout_validation.padstacks_no_name(fix=True) | ||
| """ | ||
@@ -389,0 +399,0 @@ pds = list(self._pedb.layout.padstack_instances.values()) |
@@ -29,4 +29,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| self.core = edb_object | ||
| def __init__(self, pedb, core): | ||
| self.core = core | ||
| self._pedb = pedb |
@@ -39,4 +39,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| self.core = edb_object | ||
| def __init__(self, pedb, core): | ||
| self.core = core | ||
| self._pedb = pedb | ||
@@ -43,0 +43,0 @@ |
@@ -66,3 +66,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| if name in self.items: | ||
| self._pedb.logger.error("{} already exists.".format(name)) | ||
| self._pedb.logger.error(f"{name} already exists.") | ||
| return False | ||
@@ -69,0 +69,0 @@ extended_net = ExtendedNet.create(self._pedb.layout, name) |
@@ -27,4 +27,2 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| from ansys.edb.core.net.net_class import NetClass as GrpcNetClass | ||
| if TYPE_CHECKING: | ||
@@ -34,3 +32,3 @@ from pyedb.grpc.database.net.net import Net | ||
| class NetClass(GrpcNetClass): | ||
| class NetClass: | ||
| """Manages EDB functionalities for a primitives. | ||
@@ -42,11 +40,34 @@ It inherits EDB Object properties. | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb(myedb, edbversion="2025.1") | ||
| >>> myedb = "path_to_your_edb_file.edb" | ||
| >>> edb = Edb(myedb, version="2025.1") | ||
| >>> edb.net_classes | ||
| """ | ||
| def __init__(self, pedb, net_class): | ||
| super().__init__(net_class.msg) | ||
| def __init__(self, pedb, core): | ||
| self.core = core | ||
| self._pedb = pedb | ||
| @property | ||
| def name(self): | ||
| """Net class name. | ||
| Returns | ||
| ------- | ||
| str | ||
| Name of the net class. | ||
| """ | ||
| return self.core.name | ||
| @name.setter | ||
| def name(self, value: str): | ||
| """Set net class name. | ||
| Parameters | ||
| ---------- | ||
| value : str | ||
| Name of the net class. | ||
| """ | ||
| self.core.name = value | ||
| @property | ||
| def nets(self): | ||
@@ -62,3 +83,3 @@ """Net list. | ||
| return [Net(self._pedb, i) for i in super().nets] | ||
| return [Net(self._pedb, i) for i in self.core.nets] | ||
@@ -77,6 +98,17 @@ def add_net(self, net): | ||
| if isinstance(net, Net) and not net.is_null: | ||
| self.add_net(net) | ||
| self.core.add_net(net) | ||
| return True | ||
| return False | ||
| @property | ||
| def is_null(self): | ||
| """Check if the net class is a null net class. | ||
| Returns | ||
| ------- | ||
| bool | ||
| ``True`` if the net class is a null net class, ``False`` otherwise. | ||
| """ | ||
| return self.core.is_null | ||
| def contains_net(self, net) -> bool: | ||
@@ -100,3 +132,3 @@ """ | ||
| net = Net.find_by_name(self._pedb.active_layout, name=net) | ||
| return super().contains_net(net) | ||
| return self.core.contains_net(net) | ||
@@ -114,4 +146,4 @@ def remove_net(self, net): | ||
| if isinstance(net, Net) and not net.is_null: | ||
| self.remove_net(net) | ||
| self.core.remove_net(net) | ||
| return True | ||
| return False |
@@ -61,4 +61,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, raw_net): | ||
| self.core = raw_net | ||
| def __init__(self, pedb, core): | ||
| self.core = core | ||
| self._pedb = pedb | ||
@@ -65,0 +65,0 @@ self._core_components = pedb.components |
@@ -58,23 +58,23 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| >>> # Get all nets dictionary | ||
| >>> all_nets = nets.nets | ||
| >>> all_nets = edbapp.nets.nets | ||
| >>> print("All nets:", list(all_nets.keys())) | ||
| >>> # Get net names list | ||
| >>> net_names = nets.netlist | ||
| >>> net_names = edbapp.nets.netlist | ||
| >>> print("Net names:", net_names) | ||
| >>> # Get signal nets | ||
| >>> signal_nets = nets.signal | ||
| >>> signal_nets = edbapp.nets.signal | ||
| >>> print("Signal nets:", list(signal_nets.keys())) | ||
| >>> # Get power/ground nets | ||
| >>> power_nets = nets.power | ||
| >>> power_nets = edbapp.nets.power | ||
| >>> print("Power nets:", list(power_nets.keys())) | ||
| >>> # Get nets by components | ||
| >>> nets_by_comps = nets.nets_by_components | ||
| >>> nets_by_comps = edbapp.nets.nets_by_components | ||
| >>> print("Nets by components:", nets_by_comps) | ||
| >>> # Get components by nets | ||
| >>> comps_by_nets = nets.components_by_nets | ||
| >>> comps_by_nets = edbapp.nets.components_by_nets | ||
| >>> print("Components by nets:", comps_by_nets) | ||
@@ -87,3 +87,3 @@ | ||
| >>> # Get net by name | ||
| >>> net_obj = nets["GND"] | ||
| >>> net_obj = edbapp.nets["GND"] | ||
| >>> print(f"Net object: {net_obj.name}") | ||
@@ -96,45 +96,45 @@ | ||
| >>> # Identify eligible power nets | ||
| >>> eligible_pwr = nets.eligible_power_nets(threshold=0.25) | ||
| >>> eligible_pwr = edbapp.nets.eligible_power_nets(threshold=0.25) | ||
| >>> print("Eligible power nets:", [net.name for net in eligible_pwr]) | ||
| >>> # Generate extended nets (deprecated) | ||
| >>> nets.generate_extended_nets(resistor_below=5, inductor_below=0.5, capacitor_above=0.1) | ||
| >>> edbapp.nets.generate_extended_nets(resistor_below=5, inductor_below=0.5, capacitor_above=0.1) | ||
| >>> # Classify nets | ||
| >>> nets.classify_nets(power_nets=["VDD_CPU", "VDD_MEM"], signal_nets=["PCIe_TX", "ETH_RX"]) | ||
| >>> edbapp.nets.classify_nets(power_nets=["VDD_CPU", "VDD_MEM"], signal_nets=["PCIe_TX", "ETH_RX"]) | ||
| >>> # Check power/ground status | ||
| >>> is_power = nets.is_power_gound_net(["VDD_CPU", "PCIe_TX"]) | ||
| >>> is_power = edbapp.nets.is_power_gound_net(["VDD_CPU", "PCIe_TX"]) | ||
| >>> print("Is power net:", is_power) | ||
| >>> # Get DC-connected nets | ||
| >>> dc_connected = nets.get_dcconnected_net_list(ground_nets=["GND"], res_value=0.002) | ||
| >>> dc_connected = edbapp.nets.get_dcconnected_net_list(ground_nets=["GND"], res_value=0.002) | ||
| print("DC-connected nets:", dc_connected) | ||
| >>> # Get power tree | ||
| >>> comp_list, columns, net_group = nets.get_powertree(power_net_name="VDD_CPU", ground_nets=["GND"]) | ||
| >>> comp_list, columns, net_group = edbapp.nets.get_powertree(power_net_name="VDD_CPU", ground_nets=["GND"]) | ||
| >>> print("Power tree components:", comp_list) | ||
| >>> # Find net by name | ||
| >>> found_net = nets.get_net_by_name("PCIe_TX") | ||
| >>> found_net = edbapp.nets.get_net_by_name("PCIe_TX") | ||
| >>> print(f"Found net: {found_net.name}") | ||
| >>> # Delete nets | ||
| >>> deleted = nets.delete(["Unused_Net", "Test_Net"]) | ||
| >>> deleted = edbapp.nets.delete(["Unused_Net", "Test_Net"]) | ||
| >>> print("Deleted nets:", deleted) | ||
| >>> # Find or create net | ||
| >>> new_net = nets.find_or_create_net(net_name="New_Net") | ||
| >>> new_net = edbapp.nets.find_or_create_net(net_name="New_Net") | ||
| >>> print(f"Created net: {new_net.name}") | ||
| >>> # Check net-component association | ||
| >>> in_component = nets.is_net_in_component("U1", "VDD_CPU") | ||
| >>> in_component = edbapp.nets.is_net_in_component("U1", "VDD_CPU") | ||
| >>> print("Net in component:", in_component) | ||
| >>> # Find and fix disjoint nets (deprecated) | ||
| >>> fixed_nets = nets.find_and_fix_disjoint_nets(net_list=["PCIe_TX"], clean_disjoints_less_than=1e-6) | ||
| >>> fixed_nets = edbapp.nets.find_and_fix_disjoint_nets(net_list=["PCIe_TX"], clean_disjoints_less_than=1e-6) | ||
| >>> print("Fixed nets:", fixed_nets) | ||
| >>> # Merge net polygons | ||
| >>> merged = nets.merge_nets_polygons(["VDD_CPU", "VDD_MEM"]) | ||
| >>> merged = edbapp.nets.merge_nets_polygons(["VDD_CPU", "VDD_MEM"]) | ||
| >>> print("Polygons merged:", merged) | ||
@@ -161,3 +161,5 @@ | ||
| -------- | ||
| >>> gnd_net = edb_nets["GND"] | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> gnd_net = edb.nets["GND"] | ||
| >>> print(gnd_net.name) | ||
@@ -182,3 +184,5 @@ """ | ||
| -------- | ||
| >>> if "PCIe_RX" in edb_nets: | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> if "PCIe_RX" in edb.nets: | ||
| >>> print("Net exists") | ||
@@ -235,3 +239,5 @@ """ | ||
| -------- | ||
| >>> all_nets = edb_nets.nets | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> all_nets = edb.nets.nets | ||
| >>> for net_name, net_obj in all_nets.items(): | ||
@@ -253,3 +259,5 @@ ... print(net_name, net_obj.is_power_ground) | ||
| -------- | ||
| >>> net_names = edb_nets.netlist | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> net_names = edb.nets.netlist | ||
| >>> print("Total nets:", len(net_names)) | ||
@@ -270,3 +278,5 @@ """ | ||
| -------- | ||
| >>> signal_nets = edb_nets.signal | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> signal_nets = edb.nets.signal | ||
| >>> print("Signal nets:", list(signal_nets.keys())) | ||
@@ -291,3 +301,5 @@ """ | ||
| -------- | ||
| >>> power_nets = edb_nets.power | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> power_nets = edb.nets.power | ||
| >>> print("Power nets:", list(power_nets.keys())) | ||
@@ -319,3 +331,5 @@ """ | ||
| -------- | ||
| >>> eligible_pwr = edb_nets.eligible_power_nets(threshold=0.25) | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> eligible_pwr = edb.nets.eligible_power_nets(threshold=0.25) | ||
| >>> print([net.name for net in eligible_pwr]) | ||
@@ -354,3 +368,5 @@ """ | ||
| -------- | ||
| >>> nets_by_comps = edb_nets.nets_by_components | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> nets_by_comps = edb.nets.nets_by_components | ||
| >>> print("U1 nets:", nets_by_comps.get("U1", [])) | ||
@@ -373,3 +389,5 @@ """ | ||
| -------- | ||
| >>> comps_by_nets = edb_nets.components_by_nets | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> comps_by_nets = edb.nets.components_by_nets | ||
| >>> print("Components on GND:", comps_by_nets.get("GND", [])) | ||
@@ -421,6 +439,8 @@ """ | ||
| -------- | ||
| >>> edb_nets.generate_extended_nets(resistor_below=5, inductor_below=0.5, capacitor_above=0.1) | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> edb.extended_nets.generate_extended_nets(resistor_below=5, inductor_below=0.5, capacitor_above=0.1) | ||
| """ | ||
| warnings.warn("Use new method :func:`edb.extended_nets.generate_extended_nets` instead.", DeprecationWarning) | ||
| self._pedb.extended_nets.generate_extended_nets( | ||
| return self._pedb.extended_nets.generate_extended_nets( | ||
| resistor_below, inductor_below, capacitor_above, exception_list, include_signal, include_power | ||
@@ -483,3 +503,5 @@ ) | ||
| -------- | ||
| >>> edb_nets.classify_nets(power_nets=["VDD_CPU", "VDD_MEM"], signal_nets=["PCIe_TX", "ETH_RX"]) | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> edb.nets.classify_nets(power_nets=["VDD_CPU", "VDD_MEM"], signal_nets=["PCIe_TX", "ETH_RX"]) | ||
| """ | ||
@@ -517,3 +539,5 @@ if isinstance(power_nets, str): | ||
| -------- | ||
| >>> is_power = edb_nets.is_power_gound_net(["VDD_CPU", "PCIe_TX"]) | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> is_power = edb.nets.is_power_gound_net(["VDD_CPU", "PCIe_TX"]) | ||
| >>> print("Contains power net:", is_power) | ||
@@ -546,3 +570,5 @@ """ | ||
| -------- | ||
| >>> dc_connected = edb_nets.get_dcconnected_net_list(ground_nets=["GND"], res_value=0.002) | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> dc_connected = edb.nets.get_dcconnected_net_list(ground_nets=["GND"], res_value=0.002) | ||
| >>> for net_group in dc_connected: | ||
@@ -604,3 +630,5 @@ ... print("Connected nets:", net_group) | ||
| -------- | ||
| >>> comp_list, columns, net_group = edb_nets.get_powertree(power_net_name="VDD_CPU", ground_nets=["GND"]) | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> comp_list, columns, net_group = edb.nets.get_powertree(power_net_name="VDD_CPU", ground_nets=["GND"]) | ||
| >>> print("Power tree components:", comp_list) | ||
@@ -668,3 +696,5 @@ """ | ||
| -------- | ||
| >>> found_net = edb_nets.get_net_by_name("PCIe_TX") | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> found_net = edb.nets.get_net_by_name("PCIe_TX") | ||
| >>> if found_net: | ||
@@ -692,3 +722,5 @@ ... print("Net found:", found_net.name) | ||
| -------- | ||
| >>> deleted_nets = database.nets.delete(["Net1", "Net2"]) | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> deleted_nets = edb.active_db.nets.delete(["Net1", "Net2"]) | ||
| """ | ||
@@ -711,3 +743,3 @@ if isinstance(netlist, str): | ||
| self, net_name: str = "", start_with: str = "", contain: str = "", end_with: str = "" | ||
| ) -> Union[Net, List[Net]]: | ||
| ) -> Union[None, Net, List[Net]]: | ||
| """Find or create a net based on given criteria. | ||
@@ -733,13 +765,14 @@ | ||
| -------- | ||
| >>> # Create new net | ||
| >>> new_net = edb_nets.find_or_create_net(net_name="New_Net") | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> new_net = edb.nets.find_or_create_net(net_name="New_Net") | ||
| >>> | ||
| >>> # Find existing net | ||
| >>> existing_net = edb_nets.find_or_create_net(net_name="GND") | ||
| >>> existing_net = edb.nets.find_or_create_net(net_name="GND") | ||
| >>> | ||
| >>> # Find nets starting with "VDD" | ||
| >>> vdd_nets = edb_nets.find_or_create_net(start_with="VDD") | ||
| >>> vdd_nets = edb.nets.find_or_create_net(start_with="VDD") | ||
| >>> | ||
| >>> # Find nets ending with "_P" | ||
| >>> pos_nets = edb_nets.find_or_create_net(end_with="_P") | ||
| >>> pos_nets = edb.nets.find_or_create_net(end_with="_P") | ||
| """ | ||
@@ -768,3 +801,3 @@ if not net_name and not start_with and not contain and not end_with: | ||
| nets_found = [ | ||
| self.nets[net].net_object | ||
| self.nets[net] | ||
| for net in list(self.nets.keys()) | ||
@@ -812,3 +845,5 @@ if net.lower().startswith(start_with) and net.lower().endswith(end_with) and contain in net.lower() | ||
| -------- | ||
| >>> in_component = edb_nets.is_net_in_component("U1", "VDD_CPU") | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> in_component = edb.nets.is_net_in_component("U1", "VDD_CPU") | ||
| >>> print("Net in component:", in_component) | ||
@@ -855,3 +890,5 @@ """ | ||
| -------- | ||
| >>> fixed_nets = edb_nets.find_and_fix_disjoint_nets(net_list=["PCIe_TX"], clean_disjoints_less_than=1e-6) | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> fixed_nets = edb.layout_validation.disjoint_nets(net_list=["PCIe_TX"], clean_disjoints_less_than=1e-6) | ||
| >>> print("Fixed nets:", fixed_nets) | ||
@@ -880,3 +917,5 @@ """ | ||
| -------- | ||
| >>> merged = edb_nets.merge_nets_polygons(["VDD_CPU", "VDD_MEM"]) | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> merged = edb.nets.merge_nets_polygons(["VDD_CPU", "VDD_MEM"]) | ||
| >>> print("Merge successful:", merged) | ||
@@ -899,3 +938,3 @@ """ | ||
| >>> from pyedb import Edb | ||
| >>> edb = Edb(myedb, edbversion="2025.1") | ||
| >>> edb = Edb("my_design.edb") | ||
| >>> net_classes = edb.net_classes | ||
@@ -906,3 +945,3 @@ """ | ||
| self._pedb = pedb | ||
| self._net_classes = pedb.active_layout.net_classes | ||
| self.core = [net.core for net in pedb.active_layout.net_classes] | ||
@@ -929,4 +968,15 @@ def __getitem__(self, name: str) -> NetClass: | ||
| """ | ||
| return {i.name: i for i in self._pedb.layout.net_classes} | ||
| return {i.core.name: i for i in self._pedb.layout.net_classes} | ||
| @property | ||
| def name(self): | ||
| """Get the names of all net classes. | ||
| Returns | ||
| ------- | ||
| list[str] | ||
| List of net class names. | ||
| """ | ||
| return self.core.name | ||
| def create(self, name, net) -> Union[bool, NetClass]: | ||
@@ -933,0 +983,0 @@ """Create a new net class. |
@@ -50,28 +50,6 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(pedb, edb_object) | ||
| def __init__(self, pedb, core): | ||
| super().__init__(pedb, core) | ||
| @property | ||
| def magnitude(self) -> float: | ||
| """Magnitude. | ||
| Returns | ||
| ------- | ||
| float | ||
| Magnitude value. | ||
| """ | ||
| return Value(self.core.source_amplitude, self._pedb.active_cell) | ||
| @property | ||
| def phase(self) -> float: | ||
| """Phase. | ||
| Returns | ||
| ------- | ||
| float | ||
| Phase value. | ||
| """ | ||
| return Value(self.core.source_phase, self._pedb.active_cell) | ||
| @property | ||
| def renormalize(self) -> bool: | ||
@@ -111,13 +89,3 @@ """Whether renormalize is active. | ||
| @property | ||
| def terminal_type(self) -> str: | ||
| """Returns terminal type. | ||
| Returns | ||
| ------- | ||
| str | ||
| """ | ||
| return self.core.terminal_type | ||
| class CircuitPort(GapPort): | ||
@@ -124,0 +92,0 @@ """Manages gap port properties. |
@@ -35,4 +35,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, _pedb, edb_object): | ||
| self.core = edb_object | ||
| def __init__(self, _pedb, core): | ||
| self.core = core | ||
| self._pedb = _pedb | ||
@@ -39,0 +39,0 @@ |
@@ -35,6 +35,6 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| class Circle(Primitive): | ||
| def __init__(self, pedb, edb_object=None): | ||
| if edb_object: | ||
| self.core = edb_object | ||
| Primitive.__init__(self, pedb, edb_object) | ||
| def __init__(self, pedb, core=None): | ||
| if core: | ||
| self.core = core | ||
| Primitive.__init__(self, pedb, core) | ||
| self._pedb = pedb | ||
@@ -41,0 +41,0 @@ |
@@ -70,4 +70,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_instance): | ||
| self.core = edb_instance | ||
| def __init__(self, pedb, core): | ||
| self.core = core | ||
| self._pedb = pedb | ||
@@ -74,0 +74,0 @@ self._bounding_box = [] |
@@ -41,6 +41,6 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| class Path(Primitive): | ||
| def __init__(self, pedb, edb_object=None): | ||
| if edb_object: | ||
| self.core = edb_object | ||
| Primitive.__init__(self, pedb, edb_object) | ||
| def __init__(self, pedb, core=None): | ||
| if core: | ||
| self.core = core | ||
| Primitive.__init__(self, pedb, core) | ||
| self._pedb = pedb | ||
@@ -47,0 +47,0 @@ |
@@ -40,6 +40,6 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| class Polygon(Primitive): | ||
| def __init__(self, pedb, edb_object): | ||
| self.core = edb_object | ||
| def __init__(self, pedb, core): | ||
| self.core = core | ||
| self._pedb = pedb | ||
| Primitive.__init__(self, pedb, edb_object) | ||
| Primitive.__init__(self, pedb, core) | ||
@@ -46,0 +46,0 @@ @property |
@@ -68,4 +68,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| self.core = edb_object | ||
| def __init__(self, pedb, core): | ||
| self.core = core | ||
| self._pedb = pedb | ||
@@ -72,0 +72,0 @@ self._core_stackup = pedb.stackup |
@@ -39,6 +39,6 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object=None): | ||
| if edb_object: | ||
| Primitive.__init__(self, pedb, edb_object) | ||
| self.core = edb_object | ||
| def __init__(self, pedb, core=None): | ||
| if core: | ||
| Primitive.__init__(self, pedb, core) | ||
| self.core = core | ||
| self._pedb = pedb | ||
@@ -45,0 +45,0 @@ self._mapping_representation_type = { |
@@ -29,5 +29,5 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| class HFSSAdvancedMeshingSettings(GrpcHFSSAdvancedMeshingSettings): | ||
| def __init__(self, pedb, edb_object): | ||
| def __init__(self, pedb, core): | ||
| """EDB-core HFSS advanced meshing settings class.""" | ||
| super().__init__(edb_object) | ||
| super().__init__(core) | ||
| self._pedb = pedb |
@@ -31,4 +31,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| class HFSSAdvancedSettings(GrpcHFSSAdvancedSettings): | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(edb_object) | ||
| def __init__(self, pedb, core): | ||
| super().__init__(core) | ||
| self._pedb = pedb | ||
@@ -35,0 +35,0 @@ |
@@ -32,5 +32,5 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(edb_object) | ||
| self._edb_object = edb_object | ||
| def __init__(self, pedb, core): | ||
| super().__init__(core) | ||
| self._core = core | ||
| self._pedb = pedb |
@@ -33,4 +33,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(edb_object) | ||
| def __init__(self, pedb, core): | ||
| super().__init__(core) | ||
| self._pedb = pedb | ||
@@ -37,0 +37,0 @@ |
@@ -34,4 +34,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, _pedb, edb_object): | ||
| super().__init__(edb_object) | ||
| def __init__(self, _pedb, core): | ||
| super().__init__(core) | ||
| self._pedb = _pedb | ||
@@ -38,0 +38,0 @@ |
@@ -47,5 +47,5 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(edb_object) | ||
| self._edb_object = edb_object | ||
| def __init__(self, pedb, core): | ||
| super().__init__(core) | ||
| self._edb_object = core | ||
| self._pedb = pedb | ||
@@ -52,0 +52,0 @@ |
@@ -42,4 +42,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object, name: str = None): | ||
| super().__init__(edb_object.msg) | ||
| def __init__(self, pedb, core, name: str = None): | ||
| super().__init__(core.msg) | ||
| self._pedb = pedb | ||
@@ -46,0 +46,0 @@ self._name = name |
@@ -32,4 +32,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(edb_object) | ||
| def __init__(self, pedb, core): | ||
| super().__init__(core) | ||
| self._pedb = pedb |
@@ -32,4 +32,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(edb_object) | ||
| def __init__(self, pedb, core): | ||
| super().__init__(core) | ||
| self._pedb = pedb |
@@ -32,4 +32,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(edb_object) | ||
| def __init__(self, pedb, core): | ||
| super().__init__(core) | ||
| self._pedb = pedb |
@@ -31,4 +31,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(edb_object) | ||
| def __init__(self, pedb, core): | ||
| super().__init__(core) | ||
| self._pedb = pedb |
@@ -38,4 +38,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(edb_object) | ||
| def __init__(self, pedb, core): | ||
| super().__init__(core) | ||
| self._pedb = pedb | ||
@@ -42,0 +42,0 @@ |
@@ -35,4 +35,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(edb_object.msg) | ||
| def __init__(self, pedb, core): | ||
| super().__init__(core.msg) | ||
| self._pedb = pedb | ||
@@ -39,0 +39,0 @@ |
@@ -32,4 +32,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(edb_object.msg) | ||
| def __init__(self, pedb, core): | ||
| super().__init__(core.msg) | ||
| self._pedb = pedb |
@@ -36,4 +36,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object=None): | ||
| super().__init__(edb_object.msg) | ||
| def __init__(self, pedb, core=None): | ||
| super().__init__(core.msg if core else None) | ||
| self._pedb = pedb | ||
@@ -40,0 +40,0 @@ |
@@ -33,3 +33,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, name, distribution, start_f, end_f, step, edb_object=None): | ||
| def __init__(self, pedb, name, distribution, start_f, end_f, step, core=None): | ||
| super().__init__( | ||
@@ -41,3 +41,3 @@ name=name, | ||
| ) | ||
| self._edb_object = edb_object | ||
| self._edb_object = core | ||
| self._pedb = pedb |
@@ -730,3 +730,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| ) | ||
| return self._pedb.source_excitation.create_pin_group_terminal(source) | ||
| return self._pedb.source_excitation._create_pin_group_terminal2(source) | ||
@@ -733,0 +733,0 @@ def create_rlc_component( |
@@ -42,3 +42,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| class BundleTerminal: | ||
| class BundleTerminal(Terminal): | ||
| """Manages bundle terminal properties. | ||
@@ -54,8 +54,7 @@ | ||
| def __init__(self, pedb, edb_object): | ||
| self.core = edb_object | ||
| self._pedb = pedb | ||
| def __init__(self, pedb, core): | ||
| super().__init__(pedb, core) | ||
| @classmethod | ||
| def create(cls, terminals: list[Union[Terminal, WavePort]]) -> BundleTerminal: | ||
| def create(cls, pedb, name: str, terminals: list[Union[Terminal, WavePort]]) -> BundleTerminal: | ||
| """Create a bundle terminal. | ||
@@ -65,2 +64,4 @@ | ||
| ---------- | ||
| name : str | ||
| Bundle terminal name. | ||
| terminals : list[Union[Terminal, WavePort]] | ||
@@ -78,21 +79,11 @@ List of terminals to bundle. | ||
| raise ValueError("Terminals list cannot be empty.") | ||
| pedb = terminals[0]._pedb | ||
| for term in terminals[1:]: | ||
| if term._pedb is not pedb: | ||
| raise ValueError("All terminals must belong to the same EDB.") | ||
| terminals = [term.core for term in terminals] | ||
| term = GrpcBundleTerminal.create(terminals=terminals) | ||
| return cls(pedb, term) | ||
| terminals = [term.core for term in pedb.layout.terminals] | ||
| grpc_term = GrpcBundleTerminal.create(terminals=terminals) | ||
| terminal = cls(pedb, grpc_term) | ||
| terminal.name = name | ||
| for idx, i in enumerate(terminal.core.terminals): | ||
| i.name = f"{name}:T{idx + 1}" | ||
| return terminal | ||
| @property | ||
| def boundary_type(self) -> str: | ||
| """Boundary type. | ||
| Returns | ||
| ------- | ||
| str : boundary type. | ||
| """ | ||
| return self.core.boundary_type.name.lower() | ||
| @property | ||
| def is_reference_terminal(self) -> bool: | ||
@@ -128,17 +119,2 @@ """Check if the bundle terminal is a reference terminal. | ||
| @property | ||
| def impedance(self) -> float: | ||
| """Impedance value. | ||
| Returns | ||
| ------- | ||
| float | ||
| Impedance value. | ||
| """ | ||
| return self.core.impedance.value | ||
| @impedance.setter | ||
| def impedance(self, value): | ||
| self.core.impedance = self._pedb.value(value) | ||
| @property | ||
| def net(self) -> Net: | ||
@@ -178,34 +154,2 @@ """Returns Net object. | ||
| @property | ||
| def reference_layer(self) -> Layer: | ||
| """Returns reference layer. | ||
| Returns | ||
| ------- | ||
| :class:`Layer <pyedb.grpc.database.layers.layer.Layer>` | ||
| """ | ||
| return Layer(self._pedb, self.core.reference_layer) | ||
| @reference_layer.setter | ||
| def reference_layer(self, value): | ||
| if isinstance(value, Layer): | ||
| self.core.reference_layer = value.core | ||
| elif isinstance(value, str): | ||
| self.core.reference_layer = self._pedb.stackup.signal_layer[value].core | ||
| @property | ||
| def reference_terminal(self) -> Terminal: | ||
| """Returns reference terminal. | ||
| Returns | ||
| ------- | ||
| :class:`Terminal <pyedb.grpc.database.terminal.terminal.Terminal>` | ||
| """ | ||
| return Terminal(self._pedb, self.core.reference_terminal) | ||
| @reference_terminal.setter | ||
| def reference_terminal(self, value): | ||
| if isinstance(value, Terminal): | ||
| self.core.reference_terminal = value.core | ||
| @property | ||
| def rlc_boundary_parameters(self) -> Rlc: | ||
@@ -221,30 +165,2 @@ """Returns Rlc parameters | ||
| @property | ||
| def source_amplitude(self) -> float: | ||
| """Returns source amplitude. | ||
| Returns | ||
| ------- | ||
| float | ||
| """ | ||
| return self.core.source_amplitude.value | ||
| @source_amplitude.setter | ||
| def source_amplitude(self, value): | ||
| self.core.source_amplitude = self._pedb.value(value) | ||
| @property | ||
| def source_phase(self) -> float: | ||
| """Returns source phase. | ||
| Returns | ||
| ------- | ||
| float | ||
| """ | ||
| return self.core.source_phase.value | ||
| @source_phase.setter | ||
| def source_phase(self, value): | ||
| self.core.source_phase = self._pedb.value(value) | ||
| @property | ||
| def term_to_ground(self) -> str: | ||
@@ -271,2 +187,4 @@ """Returns terminal to ground. | ||
| def terminals(self) -> list[Terminal]: | ||
| from pyedb.grpc.database.terminal.edge_terminal import EdgeTerminal | ||
| """Returns terminals list. | ||
@@ -278,2 +196,2 @@ | ||
| """ | ||
| return [Terminal(self._pedb, terminal) for terminal in self.core.terminals] | ||
| return [EdgeTerminal(self._pedb, terminal) for terminal in self.core.terminals] |
@@ -29,2 +29,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| from pyedb.grpc.database.terminal.terminal import Terminal | ||
| if TYPE_CHECKING: | ||
@@ -34,6 +36,5 @@ from pyedb.grpc.database.hierarchy.component import Component | ||
| class EdgeTerminal: | ||
| def __init__(self, pedb, edb_object): | ||
| self.core = edb_object | ||
| self._pedb = pedb | ||
| class EdgeTerminal(Terminal): | ||
| def __init__(self, pedb, core): | ||
| super().__init__(pedb, core) | ||
| self._hfss_type = "Gap" | ||
@@ -88,85 +89,2 @@ | ||
| @property | ||
| def name(self): | ||
| """Terminal name. | ||
| Returns | ||
| ------- | ||
| str : terminal name. | ||
| """ | ||
| return self.core.name | ||
| @name.setter | ||
| def name(self, value): | ||
| self.core.name = value | ||
| @property | ||
| def source_amplitude(self): | ||
| """Source amplitude. | ||
| Returns | ||
| ------- | ||
| float : source amplitude. | ||
| """ | ||
| return self.core.source_amplitude | ||
| @source_amplitude.setter | ||
| def source_amplitude(self, value): | ||
| """Source amplitude.""" | ||
| self.core.source_amplitude = self._pedb.value(value) | ||
| @property | ||
| def source_phase(self): | ||
| """Source phase. | ||
| Returns | ||
| ------- | ||
| float : source phase. | ||
| """ | ||
| return self.core.source_phase | ||
| @property | ||
| def impedance(self): | ||
| """Impedance. | ||
| Returns | ||
| ------- | ||
| float : impedance. | ||
| """ | ||
| return self.core.impedance | ||
| @impedance.setter | ||
| def impedance(self, value): | ||
| self.core.impedance = self._pedb.value(value) | ||
| @source_phase.setter | ||
| def source_phase(self, value): | ||
| self.core.source_phase = self._pedb.value(value) | ||
| @property | ||
| def boundary_type(self) -> str: | ||
| """Boundary type. | ||
| Returns | ||
| ------- | ||
| str : boundary type. | ||
| """ | ||
| return self.core.boundary_type.name.lower() | ||
| @property | ||
| def reference_terminal(self): | ||
| """Reference terminal. | ||
| Returns | ||
| ------- | ||
| EdgeTerminal object. | ||
| """ | ||
| return EdgeTerminal(self._pedb, self.core.reference_terminal) | ||
| @reference_terminal.setter | ||
| def reference_terminal(self, value): | ||
| if isinstance(value, EdgeTerminal): | ||
| self.core.reference_terminal = value.core | ||
| @property | ||
| def is_circuit_port(self) -> bool: | ||
@@ -195,18 +113,2 @@ """Is circuit port. | ||
| @property | ||
| def _edb_properties(self): | ||
| from ansys.edb.core.database import ProductIdType as GrpcProductIdType | ||
| try: | ||
| p = self.core.get_product_property(GrpcProductIdType.DESIGNER, 1) | ||
| except: | ||
| p = "" | ||
| return p | ||
| @_edb_properties.setter | ||
| def _edb_properties(self, value): | ||
| from ansys.edb.core.database import ProductIdType as GrpcProductIdType | ||
| self.core.set_product_property(GrpcProductIdType.DESIGNER, 1, value) | ||
| @property | ||
| def is_wave_port(self) -> bool: | ||
@@ -218,48 +120,2 @@ if self._hfss_port_property: | ||
| @property | ||
| def _hfss_port_property(self): | ||
| """HFSS port property.""" | ||
| hfss_prop = re.search(r"HFSS\(.*?\)", self._edb_properties) | ||
| p = {} | ||
| if hfss_prop: | ||
| hfss_type = re.search(r"'HFSS Type'='([^']+)'", hfss_prop.group()) | ||
| orientation = re.search(r"'Orientation'='([^']+)'", hfss_prop.group()) | ||
| horizontal_ef = re.search(r"'Horizontal Extent Factor'='([^']+)'", hfss_prop.group()) | ||
| vertical_ef = re.search(r"'Vertical Extent Factor'='([^']+)'", hfss_prop.group()) | ||
| radial_ef = re.search(r"'Radial Extent Factor'='([^']+)'", hfss_prop.group()) | ||
| pec_w = re.search(r"'PEC Launch Width'='([^']+)'", hfss_prop.group()) | ||
| p["HFSS Type"] = hfss_type.group(1) if hfss_type else "" | ||
| p["Orientation"] = orientation.group(1) if orientation else "" | ||
| p["Horizontal Extent Factor"] = float(horizontal_ef.group(1)) if horizontal_ef else "" | ||
| p["Vertical Extent Factor"] = float(vertical_ef.group(1)) if vertical_ef else "" | ||
| p["Radial Extent Factor"] = float(radial_ef.group(1)) if radial_ef else "" | ||
| p["PEC Launch Width"] = pec_w.group(1) if pec_w else "" | ||
| else: | ||
| p["HFSS Type"] = "" | ||
| p["Orientation"] = "" | ||
| p["Horizontal Extent Factor"] = "" | ||
| p["Vertical Extent Factor"] = "" | ||
| p["Radial Extent Factor"] = "" | ||
| p["PEC Launch Width"] = "" | ||
| return p | ||
| @_hfss_port_property.setter | ||
| def _hfss_port_property(self, value): | ||
| txt = [] | ||
| for k, v in value.items(): | ||
| txt.append("'{}'='{}'".format(k, v)) | ||
| txt = ",".join(txt) | ||
| self._edb_properties = "HFSS({})".format(txt) | ||
| @property | ||
| def is_null(self) -> bool: | ||
| """Added for dotnet compatibility | ||
| Returns | ||
| ------- | ||
| bool | ||
| """ | ||
| return self.core.is_null | ||
| @property | ||
| def is_reference_terminal(self) -> bool: | ||
@@ -297,34 +153,1 @@ """Added for dotnet compatibility | ||
| return self._pedb.ports[bundle_terminal.name] | ||
| @property | ||
| def is_port(self) -> bool: | ||
| """Added for dotnet compatibility""" | ||
| return True | ||
| @property | ||
| def ref_terminal(self) -> any: | ||
| """Return refeference terminal. | ||
| ..deprecated:: 0.44.0 | ||
| Use: func:`reference_terminal` property instead. | ||
| """ | ||
| self._pedb.logger.warning("ref_terminal is deprecated, use reference_terminal property instead.") | ||
| return self.core.reference_terminal | ||
| @ref_terminal.setter | ||
| def ref_terminal(self, value): | ||
| self._pedb.logger.warning("ref_terminal is deprecated, use reference_terminal property instead.") | ||
| self.core.reference_terminal = value | ||
| @property | ||
| def hfss_type(self) -> str: | ||
| return self._hfss_type | ||
| @hfss_type.setter | ||
| def hfss_type(self, value): | ||
| self._hfss_type = value | ||
| @property | ||
| def terminal_type(self) -> str: | ||
| return "EdgeTerminal" |
@@ -36,2 +36,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance | ||
| from pyedb.grpc.database.terminal.terminal import Terminal | ||
| from pyedb.grpc.database.utility.value import Value | ||
@@ -41,8 +42,7 @@ from pyedb.misc.decorators import deprecated_property | ||
| class PadstackInstanceTerminal: | ||
| class PadstackInstanceTerminal(Terminal): | ||
| """Manages bundle terminal properties.""" | ||
| def __init__(self, pedb, edb_object): | ||
| self.core = edb_object | ||
| self._pedb = pedb | ||
| def __init__(self, pedb, core): | ||
| super().__init__(pedb, core) | ||
@@ -82,28 +82,2 @@ @classmethod | ||
| @property | ||
| def name(self) -> str: | ||
| """Terminal name. | ||
| Returns | ||
| ------- | ||
| str | ||
| Terminal name. | ||
| """ | ||
| return self.core.name | ||
| @name.setter | ||
| def name(self, value): | ||
| self.core.name = value | ||
| @property | ||
| def is_null(self) -> bool: | ||
| """Check if the terminal is null. | ||
| Returns | ||
| ------- | ||
| bool | ||
| True if the terminal is null, False otherwise. | ||
| """ | ||
| return self.core.is_null | ||
| @property | ||
| def is_circuit_port(self) -> bool: | ||
@@ -210,166 +184,1 @@ """Check if the terminal is a circuit port. | ||
| return Value(pos_x), Value(pos_y) | ||
| @property | ||
| def net_name(self) -> str: | ||
| """Net name. | ||
| Returns | ||
| ------- | ||
| str : name of the net. | ||
| """ | ||
| if self.core.is_null: | ||
| return "" | ||
| elif self.core.net.is_null: | ||
| return "" | ||
| else: | ||
| return self.core.net.name | ||
| @net_name.setter | ||
| def net_name(self, val): | ||
| if not self.core.is_null and self.core.net.is_null: | ||
| self.core.net.name = val | ||
| @property | ||
| def magnitude(self) -> float: | ||
| """Source amplitude. | ||
| Returns | ||
| ------- | ||
| float : amplitude value. | ||
| """ | ||
| return self.source_amplitude | ||
| @magnitude.setter | ||
| def magnitude(self, value): | ||
| self.source_amplitude = value | ||
| @property | ||
| def phase(self) -> float: | ||
| """Source phase. | ||
| Returns | ||
| ------- | ||
| float : phase value. | ||
| """ | ||
| return self.core.source_phase | ||
| @phase.setter | ||
| def phase(self, value): | ||
| self.core.source_phase = value | ||
| @property | ||
| def source_amplitude(self) -> float: | ||
| """Source amplitude. | ||
| Returns | ||
| ------- | ||
| float : amplitude value. | ||
| """ | ||
| return self.core.source_amplitude | ||
| @source_amplitude.setter | ||
| def source_amplitude(self, value): | ||
| self.core.source_amplitude = value | ||
| @property | ||
| def source_phase(self) -> float: | ||
| """Source phase. | ||
| Returns | ||
| ------- | ||
| float : phase value. | ||
| """ | ||
| return self.core.source_phase | ||
| @source_phase.setter | ||
| def source_phase(self, value): | ||
| self.core.source_phase = value | ||
| @property | ||
| def impedance(self) -> float: | ||
| """Impdeance value. | ||
| Returns | ||
| ------- | ||
| float : impedance value. | ||
| """ | ||
| return Value(self.core.impedance) | ||
| @impedance.setter | ||
| def impedance(self, value): | ||
| self.core.impedance = value | ||
| @property | ||
| def boundary_type(self) -> str: | ||
| """Boundary type. | ||
| Returns | ||
| ------- | ||
| str : Boundary type. | ||
| """ | ||
| return self.core.boundary_type.name.lower() | ||
| @boundary_type.setter | ||
| def boundary_type(self, value): | ||
| mapping = { | ||
| "port": GrpcBoundaryType.PORT, | ||
| "dc_terminal": GrpcBoundaryType.DC_TERMINAL, | ||
| "voltage_probe": GrpcBoundaryType.VOLTAGE_PROBE, | ||
| "voltage_source": GrpcBoundaryType.VOLTAGE_SOURCE, | ||
| "current_source": GrpcBoundaryType.CURRENT_SOURCE, | ||
| "rlc": GrpcBoundaryType.RLC, | ||
| "pec": GrpcBoundaryType.PEC, | ||
| } | ||
| if isinstance(value, str): | ||
| key = value.lower() | ||
| else: | ||
| key = value.name.lower() | ||
| new_boundary_type = mapping.get(key) | ||
| if new_boundary_type is None: | ||
| valid_types = ", ".join(mapping.keys()) | ||
| raise ValueError(f"Invalid boundary type '{value}'. Valid types are: {valid_types}") | ||
| self.core.boundary_type = new_boundary_type | ||
| @property | ||
| def is_port(self) -> bool: | ||
| if self.boundary_type == "port": | ||
| return True | ||
| return False | ||
| @property | ||
| @deprecated_property | ||
| def ref_terminal(self): | ||
| """Return reference terminal. | ||
| ..deprecated:: 0.43.0 | ||
| Use: func:`reference_terminal` property instead. | ||
| """ | ||
| self._pedb.logger.warning("ref_terminal property is deprecated, use reference_terminal property instead.") | ||
| return self.reference_terminal | ||
| @ref_terminal.setter | ||
| def ref_terminal(self, value): | ||
| self.reference_terminal = value | ||
| @property | ||
| def terminal_type(self) -> str: | ||
| return "PadstackInstanceTerminal" | ||
| @property | ||
| def reference_terminal(self) -> PadstackInstanceTerminal: | ||
| """Return reference terminal. | ||
| Returns | ||
| ------- | ||
| PadstackInstanceTerminal | ||
| Reference terminal object. | ||
| """ | ||
| return PadstackInstanceTerminal(self._pedb, self.core.reference_terminal) | ||
| @reference_terminal.setter | ||
| def reference_terminal(self, value): | ||
| try: | ||
| self.core.reference_terminal = value.core | ||
| except AttributeError: | ||
| raise ValueError("Failed to set reference terminal.") |
@@ -34,5 +34,2 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| from pyedb.grpc.database.utility.value import Value | ||
| from pyedb.misc.decorators import deprecated_property | ||
| boundary_type_mapping = { | ||
@@ -44,126 +41,12 @@ "voltage_source": GrpcBoundaryType.VOLTAGE_SOURCE, | ||
| } | ||
| from pyedb.grpc.database.terminal.terminal import Terminal | ||
| class PinGroupTerminal: | ||
| class PinGroupTerminal(Terminal): | ||
| """Manages pin group terminal properties.""" | ||
| def __init__(self, pedb, edb_object): | ||
| self.core = edb_object | ||
| self._pedb = pedb | ||
| def __init__(self, pedb, core): | ||
| super().__init__(pedb, core) | ||
| @property | ||
| def name(self) -> str: | ||
| """Terminal name. | ||
| Returns | ||
| ------- | ||
| str : terminal name. | ||
| """ | ||
| return self.core.name | ||
| @name.setter | ||
| def name(self, value): | ||
| self.core.name = value | ||
| @property | ||
| def boundary_type(self) -> str: | ||
| """Boundary type. | ||
| Returns | ||
| ------- | ||
| str : boundary type. | ||
| `"voltage_source"`, `"current_source"`, `"port"`, `"voltage_probe"`. | ||
| """ | ||
| return self.core.boundary_type.name.lower() | ||
| @boundary_type.setter | ||
| def boundary_type(self, value): | ||
| if isinstance(value, str): | ||
| value = boundary_type_mapping.get(value, None) | ||
| if value is None: | ||
| raise Exception(f"Unknown boundary type") | ||
| self.core.boundary_type = value | ||
| @property | ||
| def is_port(self) -> bool: | ||
| if self.boundary_type == "port": | ||
| return True | ||
| return False | ||
| @property | ||
| def magnitude(self) -> float: | ||
| """Source magnitude. | ||
| Returns | ||
| ------- | ||
| float : magnitude value. | ||
| """ | ||
| return Value(self.source_amplitude) | ||
| @magnitude.setter | ||
| def magnitude(self, value): | ||
| self.source_amplitude = Value(value) | ||
| @property | ||
| def phase(self) -> float: | ||
| """Source phase. | ||
| Returns | ||
| ------- | ||
| float : phase value. | ||
| """ | ||
| return Value(self.source_phase) | ||
| @phase.setter | ||
| def phase(self, value): | ||
| self.source_phase = Value(value) | ||
| @property | ||
| def source_amplitude(self) -> float: | ||
| """Source amplitude. | ||
| Returns | ||
| ------- | ||
| float : source magnitude. | ||
| """ | ||
| return Value(self.core.source_amplitude) | ||
| @source_amplitude.setter | ||
| def source_amplitude(self, value): | ||
| self.core.source_amplitude = Value(value) | ||
| @property | ||
| def source_phase(self) -> float: | ||
| """Source phase. | ||
| Returns | ||
| ------- | ||
| foat : source phase. | ||
| """ | ||
| return self.core.source_amplitude | ||
| @source_phase.setter | ||
| def source_phase(self, value): | ||
| self.core.source_phase = Value(value) | ||
| @property | ||
| def impedance(self) -> float: | ||
| """Terminal impedance. | ||
| Returns | ||
| ------- | ||
| float : terminal impedance. | ||
| """ | ||
| return self.core.impedance | ||
| @impedance.setter | ||
| def impedance(self, value): | ||
| self.core.impedance = Value(value) | ||
| @property | ||
| def net(self) -> Net: | ||
@@ -201,39 +84,2 @@ """Terminal net. | ||
| @property | ||
| def terminal_type(self) -> str: | ||
| return "PinGroupTerminal" | ||
| @property | ||
| def is_null(self) -> bool: | ||
| """Check if the terminal is a null terminal. | ||
| Returns | ||
| ------- | ||
| bool | ||
| True if the terminal is null, False otherwise. | ||
| """ | ||
| return self.core.is_null | ||
| @property | ||
| def reference_terminal(self) -> any: | ||
| """Reference terminal. | ||
| Returns | ||
| ------- | ||
| :class:`PinGroupTerminal <pyedb.grpc.database.terminal.pingroup_terminal.PinGroupTerminal>` | ||
| Reference terminal. | ||
| """ | ||
| return PinGroupTerminal(self._pedb, self.core.reference_terminal) | ||
| @reference_terminal.setter | ||
| def reference_terminal(self, value): | ||
| if isinstance(value, PinGroupTerminal): | ||
| self.core.reference_terminal = value.core | ||
| elif isinstance(value, GrpcPinGroupTerminal): | ||
| self.core.reference_terminal = value | ||
| else: | ||
| raise TypeError("Value must be a PinGroupTerminal or GrpcPinGroupTerminal object.") | ||
| @property | ||
| def is_reference_terminal(self) -> bool: | ||
@@ -250,35 +96,2 @@ """Check if the terminal is a reference terminal. | ||
| @property | ||
| @deprecated_property | ||
| def ref_terminal(self): | ||
| """Property keeping DotNet compatibility | ||
| ..deprecated:: 0.43.0 | ||
| Use: func:`reference_terminal` property instead. | ||
| """ | ||
| Exception("ref_terminal property is deprecated, use reference_terminal property instead.", DeprecationWarning) | ||
| return PinGroupTerminal(self._pedb, self.core.reference_terminal) | ||
| @ref_terminal.setter | ||
| def ref_terminal(self, value): | ||
| Exception("ref_terminal property is deprecated, use reference_terminal property instead.", DeprecationWarning) | ||
| self.core.reference_terminal = value | ||
| @property | ||
| def hfss_type(self) -> str: | ||
| return "circuit" | ||
| @property | ||
| def is_current_source(self) -> bool: | ||
| if self.boundary_type == "current_source": | ||
| return True | ||
| return False | ||
| @property | ||
| def is_voltage_source(self): | ||
| if self.boundary_type == "voltage_source": | ||
| return True | ||
| return False | ||
| @classmethod | ||
@@ -285,0 +98,0 @@ def create(cls, layout, name, pin_group, net=None, is_ref=False): |
@@ -42,10 +42,10 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| } | ||
| from pyedb.grpc.database.terminal.terminal import Terminal | ||
| class PointTerminal: | ||
| class PointTerminal(Terminal): | ||
| """Manages point terminal properties.""" | ||
| def __init__(self, pedb, edb_object): | ||
| self.core = edb_object | ||
| self._pedb = pedb | ||
| def __init__(self, pedb, core): | ||
| super().__init__(pedb, core) | ||
@@ -89,17 +89,2 @@ @classmethod | ||
| @property | ||
| def name(self) -> str: | ||
| """Terminal name. | ||
| Returns | ||
| ------- | ||
| str : terminal name. | ||
| """ | ||
| return self.core.name | ||
| @name.setter | ||
| def name(self, value): | ||
| self.core.name = value | ||
| @property | ||
| def is_reference_terminal(self) -> bool: | ||
@@ -128,21 +113,2 @@ """Whether the terminal is a reference terminal. | ||
| @property | ||
| def boundary_type(self): | ||
| """Boundary type. | ||
| Returns | ||
| ------- | ||
| str : boundary type. | ||
| """ | ||
| return self.core.boundary_type.name.lower() | ||
| @boundary_type.setter | ||
| def boundary_type(self, value): | ||
| if isinstance(value, str): | ||
| value = mapping_boundary_type.get(value.lower(), None) | ||
| if not isinstance(value, GrpcBoundaryType): | ||
| raise ValueError("Value must be a string or BoundaryType enum.") | ||
| self.core.boundary_type = value | ||
| @property | ||
| def location(self) -> tuple[float, float]: | ||
@@ -156,3 +122,3 @@ """Terminal position. | ||
| """ | ||
| return self.core.point | ||
| return Value(self.core.point.x), Value(self.core.point.y) | ||
@@ -167,56 +133,31 @@ @location.setter | ||
| @property | ||
| def layer(self) -> "StackupLayer": | ||
| """Terminal layer. | ||
| def reference_layer(self): | ||
| """Reference layer of the terminal. | ||
| Returns | ||
| ------- | ||
| :class:`StackupLayer <pyedb.grpc.database.layers.stackup_layer.StackupLayer>` | ||
| :class:`Layer <pyedb.grpc.database.layer.layer.Layer>` | ||
| """ | ||
| from pyedb.grpc.database.layers.stackup_layer import StackupLayer | ||
| try: | ||
| return self.core.reference_layer.name | ||
| except AttributeError: | ||
| self._pedb.logger.error("Cannot determine terminal layer") | ||
| return None | ||
| return StackupLayer(self._pedb, self.core.layer) | ||
| @reference_layer.setter | ||
| def reference_layer(self, value): | ||
| from ansys.edb.core.layer.layer import Layer as GrpcLayer | ||
| @layer.setter | ||
| def layer(self, value): | ||
| if value in self._pedb.stackup.layers: | ||
| self.core.layer = value | ||
| if isinstance(value, GrpcLayer): | ||
| self.core.reference_layer = value | ||
| if isinstance(value, str): | ||
| self.core.reference_layer = self._pedb.stackup.layers[value] | ||
| @property | ||
| def ref_terminal(self) -> "PointTerminal": | ||
| """Reference terminal. | ||
| def layer(self): | ||
| """Layer that the point terminal is placed on.""" | ||
| return self.core.layer | ||
| Returns | ||
| ------- | ||
| :class:`PointTerminal <pyedb.grpc.database.terminal.point_terminal.PointTerminal>` | ||
| """ | ||
| return PointTerminal(self._pedb, self.reference_terminal) | ||
| @ref_terminal.setter | ||
| def ref_terminal(self, value): | ||
| self.core.reference_terminal = value.core | ||
| @property | ||
| def reference_terminal(self) -> "PointTerminal": | ||
| """Reference terminal. | ||
| Returns | ||
| ------- | ||
| :class:`PointTerminal <pyedb.grpc.database.terminal.point_terminal.PointTerminal>` | ||
| """ | ||
| return PointTerminal(self._pedb, self.core.reference_terminal) | ||
| @reference_terminal.setter | ||
| def reference_terminal(self, value): | ||
| self.core.reference_terminal = value.core | ||
| @property | ||
| def terminal_type(self) -> str: | ||
| return "PointTerminal" | ||
| @property | ||
| def is_port(self) -> bool: | ||
| """Adding DotNet compatibility.""" | ||
| return True | ||
| @layer.setter | ||
| def layer(self, value): | ||
| self.core.layer = value |
@@ -27,2 +27,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| from pyedb.grpc.database.inner.conn_obj import ConnObj | ||
| if TYPE_CHECKING: | ||
@@ -35,3 +37,2 @@ from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance | ||
| BoundaryType as GrpcBoundaryType, | ||
| Terminal as GrpcTerminal, | ||
| TerminalType as GrpcTerminalType, | ||
@@ -51,23 +52,18 @@ ) | ||
| "pec": GrpcBoundaryType.PEC, | ||
| "portboundary": GrpcBoundaryType.PORT, | ||
| "kdcterminal": GrpcBoundaryType.DC_TERMINAL, | ||
| "kvoltageprobe": GrpcBoundaryType.VOLTAGE_PROBE, | ||
| "kvoltagesource": GrpcBoundaryType.VOLTAGE_SOURCE, | ||
| "kcurrentsource": GrpcBoundaryType.CURRENT_SOURCE, | ||
| "rlcboundary": GrpcBoundaryType.RLC, | ||
| "pecboundary": GrpcBoundaryType.PEC, | ||
| } | ||
| class Terminal: | ||
| def __init__(self, pedb, edb_object): | ||
| self.core = edb_object | ||
| self._pedb = pedb | ||
| class Terminal(ConnObj): | ||
| def __init__(self, pedb, core): | ||
| super().__init__(pedb, core) | ||
| self._reference_object = None | ||
| self._boundary_type_mapping = { | ||
| "port": GrpcBoundaryType.PORT, | ||
| "pec": GrpcBoundaryType.PEC, | ||
| "rlc": GrpcBoundaryType.RLC, | ||
| "current_source": GrpcBoundaryType.CURRENT_SOURCE, | ||
| "voltage_source": GrpcBoundaryType.VOLTAGE_SOURCE, | ||
| "nexxim_ground": GrpcBoundaryType.NEXXIM_GROUND, | ||
| "nxxim_port": GrpcBoundaryType.NEXXIM_PORT, | ||
| "dc_terminal": GrpcBoundaryType.DC_TERMINAL, | ||
| "voltage_probe": GrpcBoundaryType.VOLTAGE_PROBE, | ||
| } | ||
| self._terminal_type_mapping = { | ||
@@ -111,35 +107,7 @@ "edge": GrpcTerminalType.EDGE, | ||
| @property | ||
| def ref_terminal(self) -> any: | ||
| """Reference terminal. | ||
| Returns | ||
| ------- | ||
| :class:`PointTerminal <pyedb.grpc.database.terminal.point_terminal.PointTerminal>` | ||
| """ | ||
| return self.core.reference_terminal | ||
| @ref_terminal.setter | ||
| def ref_terminal(self, value): | ||
| self.core.reference_terminal = value | ||
| @property | ||
| def reference_layer(self): | ||
| """Reference layer of the terminal. | ||
| """Get layer of the terminal.""" | ||
| self._pedb.logger.error("Cannot determine terminal layer") | ||
| return None | ||
| Returns | ||
| ------- | ||
| :class:`Layer <pyedb.grpc.database.layer.layer.Layer>` | ||
| """ | ||
| return self.core.reference_layer.name | ||
| @reference_layer.setter | ||
| def reference_layer(self, value): | ||
| from ansys.edb.core.layer.layer import Layer as GrpcLayer | ||
| if isinstance(value, GrpcLayer): | ||
| self.core.reference_layer = value | ||
| if isinstance(value, str): | ||
| self.core.reference_layer = self._pedb.stackup.layers[value] | ||
| @_hfss_port_property.setter | ||
@@ -165,21 +133,2 @@ def _hfss_port_property(self, value): | ||
| @property | ||
| def layer(self) -> str: | ||
| """Get layer of the terminal. | ||
| Returns | ||
| ------- | ||
| str : layer name. | ||
| """ | ||
| return self.reference_layer.name | ||
| @layer.setter | ||
| def layer(self, value): | ||
| from ansys.edb.core.layer.layer import Layer | ||
| if isinstance(value, Layer): | ||
| self.reference_layer = value | ||
| if isinstance(value, str): | ||
| self.reference_layer = self._pedb.stackup.layers[value] | ||
| @property | ||
| def do_renormalize(self) -> bool: | ||
@@ -205,7 +154,16 @@ """Determine whether port renormalization is enabled. | ||
| ------- | ||
| str | ||
| Net name. | ||
| str : name of the net. | ||
| """ | ||
| return self.core.net.name | ||
| if self.core.is_null: | ||
| return "" | ||
| elif self.core.net.is_null: | ||
| return "" | ||
| else: | ||
| return self.core.net.name | ||
| @net_name.setter | ||
| def net_name(self, val): | ||
| if not self.core.is_null and self.core.net.is_null: | ||
| self.core.net.name = val | ||
| @property | ||
@@ -246,2 +204,30 @@ def terminal_type(self) -> str: | ||
| @property | ||
| def source_amplitude(self) -> float: | ||
| """Source amplitude. | ||
| Returns | ||
| ------- | ||
| float : amplitude value. | ||
| """ | ||
| return Value(self.core.source_amplitude) | ||
| @source_amplitude.setter | ||
| def source_amplitude(self, value): | ||
| self.core.source_amplitude = value | ||
| @property | ||
| def source_phase(self) -> float: | ||
| """Source phase. | ||
| Returns | ||
| ------- | ||
| float : phase value. | ||
| """ | ||
| return Value(self.core.source_phase) | ||
| @source_phase.setter | ||
| def source_phase(self, value): | ||
| self.core.source_phase = value | ||
| @property | ||
| def is_port(self) -> bool: | ||
@@ -288,3 +274,3 @@ """Whether it is a port. | ||
| """ | ||
| return Value(self.impedance) | ||
| return Value(self.core.impedance) | ||
@@ -339,16 +325,2 @@ @impedance.setter | ||
| @property | ||
| def is_null(self): | ||
| """Check if the terminal is a null terminal. | ||
| Returns | ||
| ------- | ||
| bool | ||
| ``True`` if the terminal is a null terminal, ``False`` otherwise. | ||
| """ | ||
| try: | ||
| return self.core.is_null | ||
| except: | ||
| return True | ||
| def get_padstack_terminal_reference_pin(self, gnd_net_name_preference=None) -> PadstackInstance: | ||
@@ -537,1 +509,45 @@ """Get a list of pad stacks instances and serves Coax wave ports, | ||
| self.core.source_phase = Value(value) | ||
| @property | ||
| def terminal_to_ground(self): | ||
| return self.core.term_to_ground.name.lower() | ||
| @terminal_to_ground.setter | ||
| def terminal_to_ground(self, value): | ||
| mapping = { | ||
| "kNoGround": "no_ground", | ||
| "kNegative": "negative", | ||
| "kPositive": "positive", | ||
| } | ||
| key = mapping.get(value, value) | ||
| self.core.term_to_ground = getattr(self.core.term_to_ground, key.upper()) | ||
| @property | ||
| def reference_terminal(self): | ||
| """Return reference terminal. | ||
| Returns | ||
| ------- | ||
| PadstackInstanceTerminal | ||
| Reference terminal object. | ||
| """ | ||
| if self.core.reference_terminal: | ||
| return self._pedb.terminals[self.core.reference_terminal.name] | ||
| else: | ||
| return None | ||
| @reference_terminal.setter | ||
| def reference_terminal(self, value): | ||
| try: | ||
| self.core.reference_terminal = value.core | ||
| except AttributeError: | ||
| raise ValueError("Failed to set reference terminal.") | ||
| @property | ||
| def name(self): | ||
| """Terminal name.""" | ||
| return self.core.name | ||
| @name.setter | ||
| def name(self, value): | ||
| self.core.name = value |
@@ -38,5 +38,5 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __init__(self, pedb, edb_object): | ||
| def __init__(self, pedb, core): | ||
| self._pedb = pedb | ||
| self._edb_object = edb_object | ||
| self._edb_object = core | ||
| self._fin_orientation_type = { | ||
@@ -43,0 +43,0 @@ "x_oriented": GrpcHeatSinkFinOrientation.X_ORIENTED, |
@@ -38,4 +38,4 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| class LayerMap: | ||
| def __init__(self, edb_object): | ||
| self.core = edb_object | ||
| def __init__(self, core): | ||
| self.core = core | ||
@@ -42,0 +42,0 @@ @classmethod |
@@ -29,6 +29,6 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| class Rlc(GrpcRlc): | ||
| def __init__(self, pedb, edb_object): | ||
| super().__init__(edb_object) | ||
| def __init__(self, pedb, core): | ||
| super().__init__(core) | ||
| self._pedb = pedb | ||
| self._edb_object = edb_object | ||
| self._edb_object = core | ||
@@ -35,0 +35,0 @@ @property |
@@ -28,3 +28,3 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| class Node(object): | ||
| class Node: | ||
| """Provides for handling nodes for Siwave sources.""" | ||
@@ -31,0 +31,0 @@ |
@@ -31,5 +31,5 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| def __new__(cls, val, owner=None) -> float: | ||
| edb_object = GrpcValue(val, owner) | ||
| inst = super().__new__(cls, float(edb_object.double)) | ||
| inst._edb_object = edb_object | ||
| core = GrpcValue(val, owner) | ||
| inst = super().__new__(cls, core.value) | ||
| inst._edb_object = core | ||
| inst._context = owner | ||
@@ -36,0 +36,0 @@ return inst |
@@ -437,81 +437,1 @@ # Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates. | ||
| return self._db.copy_cells(cells_to_copy) | ||
| @property | ||
| def apd_bondwire_defs(self): | ||
| """Get all APD bondwire definitions in this Database. | ||
| Returns | ||
| ------- | ||
| list[:class:`ApdBondwireDef <ansys.edb.definition.ApdBondwireDef>`] | ||
| """ | ||
| return list(self._db.apd_bondwire_defs) | ||
| @property | ||
| def jedec4_bondwire_defs(self): | ||
| """Get all JEDEC4 bondwire definitions in this Database. | ||
| Returns | ||
| ------- | ||
| list[:class:`Jedec4BondwireDef <ansys.edb.definition.Jedec4BondwireDef>`] | ||
| """ | ||
| return list(self._db.jedec4_bondwire_defs) | ||
| @property | ||
| def jedec5_bondwire_defs(self): | ||
| """Get all JEDEC5 bondwire definitions in this Database. | ||
| Returns | ||
| ------- | ||
| list[:class:`Jedec5BondwireDef <ansys.edb.definition.Jedec5BondwireDef>`] | ||
| """ | ||
| return list(self._db.jedec5_bondwire_defs) | ||
| @property | ||
| def padstack_defs(self): | ||
| """Get all Padstack definitions in this Database. | ||
| Returns | ||
| ------- | ||
| list[:class:`PadstackDef <ansys.edb.definition.PadstackDef>`] | ||
| """ | ||
| return list(self._db.padstack_defs) | ||
| @property | ||
| def package_defs(self): | ||
| """Get all Package definitions in this Database. | ||
| Returns | ||
| ------- | ||
| list[:class:`PackageDef <ansys.edb.definition.PackageDef>`] | ||
| """ | ||
| return list(self._db.package_defs) | ||
| @property | ||
| def component_defs(self): | ||
| """Get all component definitions in the database. | ||
| Returns | ||
| ------- | ||
| list[:class:`ComponentDef <ansys.edb.definition.ComponentDef>`] | ||
| """ | ||
| return list(self._db.component_defs) | ||
| @property | ||
| def material_defs(self): | ||
| """Get all material definitions in the database. | ||
| Returns | ||
| ------- | ||
| list[:class:`MaterialDef <ansys.edb.definition.MaterialDef>`] | ||
| """ | ||
| return list(self._db.material_defs) | ||
| @property | ||
| def dataset_defs(self): | ||
| """Get all dataset definitions in the database. | ||
| Returns | ||
| ------- | ||
| list[:class:`DatasetDef <ansys.edb.definition.DatasetDef>`] | ||
| """ | ||
| return list(self._db.dataset_defs) |
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Alert delta unavailable
Currently unable to show alert delta for PyPI packages.
4161767
0.32%274
1.86%97935
0.22%