pyedb 0.50.1__py3-none-any.whl → 0.52.0__py3-none-any.whl

pyedb/__init__.py

@@ -44,7 +44,7 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.50.1"
+__version__ = "0.52.0"
 version = __version__
 
 #

pyedb/configuration/cfg_ports_sources.py

@@ -19,7 +19,6 @@
 # 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.
-import os
 
 import numpy as np
 
@@ -33,29 +32,11 @@ from pyedb.dotnet.database.geometry.point_data import PointData
 class CfgTerminalInfo(CfgBase):
     CFG_TERMINAL_TYPES = ["pin", "net", "pin_group", "nearest_pin", "coordinates"]
 
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
-
-        def update_contact_radius(self, radius):
-            from ansys.edb.core.utility.value import Value as GrpcValue
-
-            self.parent.contact_radius = GrpcValue(radius).value
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-        def update_contact_radius(self, radius):
-            self.parent.contact_radius = self._pedb.edb_value(radius).ToDouble()
+    def update_contact_radius(self, radius):
+        self.contact_radius = self._pedb.edb_value(radius).ToDouble()
 
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
 
         if kwargs.get("padstack"):
             self.type = "padstack"
@@ -76,7 +57,8 @@ class CfgTerminalInfo(CfgBase):
 
         self.contact_type = kwargs.get("contact_type", "default")  # options are full, center, quad, inline
         contact_radius = "0.1mm" if kwargs.get("contact_radius") is None else kwargs.get("contact_radius")
-        self.api.update_contact_radius(contact_radius)
+
+        self.contact_radius = self._pedb.edb_value(contact_radius).ToDouble()
         self.num_of_contact = kwargs.get("num_of_contact", 4)
         self.contact_expansion = kwargs.get("contact_expansion", 1)
 
@@ -108,27 +90,11 @@ class CfgNearestPinTerminalInfo(CfgTerminalInfo):
 
 
 class CfgSources:
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
-
-        def get_pin_group_name(self, src):
-            return src.pin_group.name
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-        def get_pin_group_name(self, src):
-            return src._edb_object.GetPinGroup().GetName()
+    def get_pin_group_name(self, src):
+        return src._edb_object.GetPinGroup().GetName()
 
     def __init__(self, pedb, sources_data):
         self._pedb = pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
         self.sources = [CfgSource(self._pedb, **src) for src in sources_data]
 
     def apply(self):
@@ -147,7 +113,7 @@ class CfgSources:
 
             if src.terminal_type == "PinGroupTerminal":
                 refdes = ""
-                pg = self._pedb.siwave.pin_groups[self.api.get_pin_group_name(src)]
+                pg = self._pedb.siwave.pin_groups[self.get_pin_group_name(src)]
                 pos_term_info = {"pin_group": pg.name}
             elif src.terminal_type == "PadstackInstanceTerminal":
                 refdes = src.component.refdes if src.component else ""
@@ -155,7 +121,7 @@ class CfgSources:
 
             neg_term = self._pedb.terminals[src.ref_terminal.name]
             if neg_term.terminal_type == "PinGroupTerminal":
-                pg = self._pedb.siwave.pin_groups[self.api.get_pin_group_name(neg_term)]
+                pg = self._pedb.siwave.pin_groups[self.get_pin_group_name(neg_term)]
                 neg_term_info = {"pin_group": pg.name}
             elif neg_term.terminal_type == "PadstackInstanceTerminal":
                 neg_term_info = {"padstack": neg_term.padstack_instance.aedt_name}
@@ -180,68 +146,29 @@ class CfgSources:
 
 
 class CfgPorts:
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
-
-        def get_pin_group(self, port):
-            return self._pedb.siwave.pin_groups[port._edb_object.pin_group.name]
-
-        def get_edge_info(self, port):
-            return port._edb_object.GetEdges()[0].GetParameters()
-
-        def _get_edge_port_from_edb(self, p, port_type):
-            # primitive, point = p._edb_object.GetEdges()[0].GetParameters()
-            edges = p.edges
-            primitive = None
-            point = None
-            primitive = Primitive(self._pedb, primitive)
-            point = PointData(self._pedb, point)
-
-            cfg_port = CfgEdgePort(
-                self._pedb,
-                name=p.name,
-                type=port_type,
-                primitive_name=primitive.aedt_name,
-                point_on_edge=[point._edb_object.X.ToString(), point._edb_object.Y.ToString()],
-                horizontal_extent_factor=p.horizontal_extent_factor,
-                vertical_extent_factor=p.vertical_extent_factor,
-                pec_launch_width=p.pec_launch_width,
-            )
-            return cfg_port
+    def get_pin_group(self, port):
+        return self._pedb.siwave.pin_groups[port._edb_object.GetPinGroup().GetName()]
 
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
+    def _get_edge_port_from_edb(self, p, port_type):
+        _, primitive, point = p._edb_object.GetEdges()[0].GetParameters()
 
-        def get_pin_group(self, port):
-            return self._pedb.siwave.pin_groups[port._edb_object.GetPinGroup().GetName()]
+        primitive = Primitive(self._pedb, primitive)
+        point = PointData(self._pedb, point)
 
-        def _get_edge_port_from_edb(self, p, port_type):
-            _, primitive, point = p._edb_object.GetEdges()[0].GetParameters()
-
-            primitive = Primitive(self._pedb, primitive)
-            point = PointData(self._pedb, point)
-
-            cfg_port = CfgEdgePort(
-                self._pedb,
-                name=p.name,
-                type=port_type,
-                primitive_name=primitive.aedt_name,
-                point_on_edge=[point._edb_object.X.ToString(), point._edb_object.Y.ToString()],
-                horizontal_extent_factor=p.horizontal_extent_factor,
-                vertical_extent_factor=p.vertical_extent_factor,
-                pec_launch_width=p.pec_launch_width,
-            )
-            return cfg_port
+        cfg_port = CfgEdgePort(
+            self._pedb,
+            name=p.name,
+            type=port_type,
+            primitive_name=primitive.aedt_name,
+            point_on_edge=[point._edb_object.X.ToString(), point._edb_object.Y.ToString()],
+            horizontal_extent_factor=p.horizontal_extent_factor,
+            vertical_extent_factor=p.vertical_extent_factor,
+            pec_launch_width=p.pec_launch_width,
+        )
+        return cfg_port
 
     def __init__(self, pedb, ports_data):
         self._pedb = pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
         self.ports = []
         for p in ports_data:
             if p["type"] == "wave_port":
@@ -256,18 +183,8 @@ class CfgPorts:
                 raise ValueError("Unknown port type")
 
     def apply(self):
-        edb_primitives = {}
-        for i in self._pedb.layout.primitives:
-            if i.aedt_name:
-                edb_primitives[i.aedt_name] = i
-        for i in self._pedb.layout.padstack_instances:
-            if i.aedt_name:
-                edb_primitives[i.aedt_name] = i
         for p in self.ports:
-            if p.type in ["wave_port", "diff_wave_port", "gap_port"]:
-                p.set_parameters_to_edb(edb_primitives)
-            else:
-                p.set_parameters_to_edb()
+            p.set_parameters_to_edb()
 
     def get_data_from_db(self):
         self.ports = []
@@ -289,7 +206,7 @@ class CfgPorts:
 
             if p.terminal_type == "PinGroupTerminal":
                 refdes = ""
-                pg = self.api.get_pin_group(p)
+                pg = self.get_pin_group(p)
                 pos_term_info = {"pin_group": pg.name}
             elif p.terminal_type == "PadstackInstanceTerminal":
                 refdes = p.component.refdes if p.component else ""
@@ -301,7 +218,7 @@ class CfgPorts:
             if port_type == "circuit":
                 neg_term = self._pedb.terminals[p.ref_terminal.name]
                 if neg_term.terminal_type == "PinGroupTerminal":
-                    pg = self.api.get_pin_group(neg_term)
+                    pg = self.get_pin_group(neg_term)
                     # pg = self._pedb.siwave.pin_groups[neg_term._edb_object.GetPinGroup().GetName()]
                     neg_term_info = {"pin_group": pg.name}
                 elif neg_term.terminal_type == "PadstackInstanceTerminal":
@@ -332,7 +249,7 @@ class CfgPorts:
                     positive_terminal=pos_term_info,
                 )
             else:
-                cfg_port = self.api._get_edge_port_from_edb(p, port_type)
+                cfg_port = self._get_edge_port_from_edb(p, port_type)
             self.ports.append(cfg_port)
         return self.export_properties()
 
@@ -350,7 +267,7 @@ class CfgProbes:
 
     def apply(self):
         for probe in self.probes:
-            probe.api.set_parameters_to_edb()
+            probe.set_parameters_to_edb()
 
 
 class CfgCircuitElement(CfgBase):
@@ -740,134 +657,63 @@ class CfgSource(CfgCircuitElement):
 
 
 class CfgProbe(CfgCircuitElement):
-    class Common:
-        def __init__(self, parent):
-            self.parent = parent
-            self.pedb = parent._pedb
-
-        def set_parameters_to_edb(self):
-            self.parent.create_terminals()
-            circuit_elements = []
-            for name, j in self.parent.pos_terminals.items():
-                if isinstance(self.parent.neg_terminal, dict):
-                    elem = self.pedb.create_voltage_probe(j, self.parent.neg_terminal[name])
-                else:
-                    elem = self.pedb.create_voltage_probe(j, self.parent.neg_terminal)
-                elem.name = self.parent.name
-                circuit_elements.append(elem)
-            return circuit_elements
-
-    class Grpc(Common):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
+    def set_parameters_to_edb(self):
+        self.create_terminals()
+        circuit_elements = []
+        for name, j in self.pos_terminals.items():
+            if isinstance(self.neg_terminal, dict):
+                elem = self._pedb.create_voltage_probe(j, self.neg_terminal[name])
+            else:
+                elem = self._pedb.create_voltage_probe(j, self.neg_terminal)
+            elem.name = self.name
+            circuit_elements.append(elem)
+        return circuit_elements
 
     def __init__(self, pedb, **kwargs):
         kwargs["type"] = "probe"
         super().__init__(pedb, **kwargs)
-        if os.environ["PYEDB_USE_DOTNET"] == "0":
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
 
 
 class CfgEdgePort:
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
-
-        def set_parameters_to_edb(self, edb_primitives):
-            from ansys.edb.core.geometry.point_data import PointData as GrpcPointData
-            from ansys.edb.core.terminal.edge_terminal import (
-                EdgeTerminal as GrpcEdgeTerminal,
-            )
-            from ansys.edb.core.terminal.edge_terminal import (
-                PrimitiveEdge as GrpcPrimitiveEdge,
-            )
-            from ansys.edb.core.utility.value import Value as GrpcValue
-
-            from pyedb.grpc.database.ports.ports import WavePort
-
-            point_on_edge = GrpcPointData(self.parent.point_on_edge)
-            primitive = edb_primitives[self.parent.primitive_name]
-            pos_edge = GrpcPrimitiveEdge.create(primitive, point_on_edge)
-            edge_term = GrpcEdgeTerminal.create(
-                layout=primitive.layout, name=self.parent.name, net=primitive.net, edges=[pos_edge], is_ref=False
-            )
-            edge_term.impedance = GrpcValue(50)
-            wave_port = WavePort(self._pedb, edge_term)
-            wave_port.horizontal_extent_factor = self.parent.horizontal_extent_factor
-            wave_port.vertical_extent_factor = self.parent.vertical_extent_factor
-            wave_port.pec_launch_width = self.parent.pec_launch_width
-            if self.parent.type == "wave_port":
-                wave_port.hfss_type = "Wave"
-            else:
-                wave_port.hfss_type = "Gap"
-            wave_port.do_renormalize = True
-            return wave_port
-
-        def export_properties(self):
-            return {
-                "name": self.name,
-                "type": self.type,
-                "primitive_name": self.primitive_name,
-                "point_on_edge": self.point_on_edge,
-                "horizontal_extent_factor": self.horizontal_extent_factor,
-                "vertical_extent_factor": self.vertical_extent_factor,
-                "pec_launch_width": self.pec_launch_width,
-            }
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
+    def set_parameters_to_edb(self):
+        point_on_edge = PointData(self._pedb, x=self.point_on_edge[0], y=self.point_on_edge[1])
+        primitive = self._pedb.layout.primitives_by_aedt_name[self.primitive_name]
+        pos_edge = self._pedb.edb_api.cell.terminal.PrimitiveEdge.Create(
+            primitive._edb_object, point_on_edge._edb_object
+        )
+        pos_edge = convert_py_list_to_net_list(pos_edge, self._pedb.edb_api.cell.terminal.Edge)
+        edge_term = self._pedb.edb_api.cell.terminal.EdgeTerminal.Create(
+            primitive._edb_object.GetLayout(),
+            primitive._edb_object.GetNet(),
+            self.name,
+            pos_edge,
+            isRef=False,
+        )
+        edge_term.SetImpedance(self._pedb.edb_value(50))
+        wave_port = WavePort(self._pedb, edge_term)
+        wave_port.horizontal_extent_factor = self.horizontal_extent_factor
+        wave_port.vertical_extent_factor = self.vertical_extent_factor
+        wave_port.pec_launch_width = self.pec_launch_width
+        if self.type == "wave_port":
+            wave_port.hfss_type = "Wave"
+        else:
+            wave_port.hfss_type = "Gap"
+        wave_port.do_renormalize = True
+        return wave_port
 
-        def set_parameters_to_edb(self, edb_primitives):
-            point_on_edge = PointData(self._pedb, x=self.parent.point_on_edge[0], y=self.parent.point_on_edge[1])
-            primitive = edb_primitives[self.parent.primitive_name]
-            pos_edge = self._pedb.edb_api.cell.terminal.PrimitiveEdge.Create(
-                primitive._edb_object, point_on_edge._edb_object
-            )
-            pos_edge = convert_py_list_to_net_list(pos_edge, self._pedb.edb_api.cell.terminal.Edge)
-            edge_term = self._pedb.edb_api.cell.terminal.EdgeTerminal.Create(
-                primitive._edb_object.GetLayout(),
-                primitive._edb_object.GetNet(),
-                self.parent.name,
-                pos_edge,
-                isRef=False,
-            )
-            edge_term.SetImpedance(self._pedb.edb_value(50))
-            wave_port = WavePort(self._pedb, edge_term)
-            wave_port.horizontal_extent_factor = self.parent.horizontal_extent_factor
-            wave_port.vertical_extent_factor = self.parent.vertical_extent_factor
-            wave_port.pec_launch_width = self.parent.pec_launch_width
-            if self.parent.type == "wave_port":
-                wave_port.hfss_type = "Wave"
-            else:
-                wave_port.hfss_type = "Gap"
-            wave_port.do_renormalize = True
-            return wave_port
-
-        def export_properties(self):
-            return {
-                "name": self.parent.name,
-                "type": self.parent.type,
-                "primitive_name": self.parent.primitive_name,
-                "point_on_edge": self.parent.point_on_edge,
-                "horizontal_extent_factor": self.parent.horizontal_extent_factor,
-                "vertical_extent_factor": self.parent.vertical_extent_factor,
-                "pec_launch_width": self.parent.pec_launch_width,
-            }
+    def export_properties(self):
+        return {
+            "name": self.name,
+            "type": self.type,
+            "primitive_name": self.primitive_name,
+            "point_on_edge": self.point_on_edge,
+            "horizontal_extent_factor": self.horizontal_extent_factor,
+            "vertical_extent_factor": self.vertical_extent_factor,
+            "pec_launch_width": self.pec_launch_width,
+        }
 
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
         self.name = kwargs["name"]
         self.type = kwargs["type"]
         self.primitive_name = kwargs["primitive_name"]
@@ -876,12 +722,6 @@ class CfgEdgePort:
         self.vertical_extent_factor = kwargs.get("vertical_extent_factor", 3)
         self.pec_launch_width = kwargs.get("pec_launch_width", "0.01mm")
 
-    def set_parameters_to_edb(self, edb_primitives):
-        return self.api.set_parameters_to_edb(edb_primitives)
-
-    def export_properties(self):
-        return self.api.export_properties()
-
 
 class CfgDiffWavePort:
     def __init__(self, pedb, **kwargs):
@@ -911,9 +751,9 @@ class CfgDiffWavePort:
             **kwargs["negative_terminal"],
         )
 
-    def set_parameters_to_edb(self, edb_primitives):
-        pos_term = self.positive_port.set_parameters_to_edb(edb_primitives)
-        neg_term = self.negative_port.set_parameters_to_edb(edb_primitives)
+    def set_parameters_to_edb(self):
+        pos_term = self.positive_port.set_parameters_to_edb()
+        neg_term = self.negative_port.set_parameters_to_edb()
         edb_list = convert_py_list_to_net_list(
             [pos_term._edb_object, neg_term._edb_object], self._pedb.edb_api.cell.terminal.Terminal
         )