pyedb 0.17.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

pyedb/__init__.py

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

pyedb/configuration/cfg_data.py

@@ -28,8 +28,8 @@ from pyedb.configuration.cfg_nets import CfgNets
 from pyedb.configuration.cfg_operations import CfgOperations
 from pyedb.configuration.cfg_package_definition import CfgPackageDefinitions
 from pyedb.configuration.cfg_padstacks import CfgPadstacks
-from pyedb.configuration.cfg_pin_groups import CfgPinGroup
-from pyedb.configuration.cfg_ports_sources import CfgPort, CfgSources
+from pyedb.configuration.cfg_pin_groups import CfgPinGroups
+from pyedb.configuration.cfg_ports_sources import CfgPorts, CfgSources
 from pyedb.configuration.cfg_s_parameter_models import CfgSParameterModel
 from pyedb.configuration.cfg_setup import CfgSetups
 from pyedb.configuration.cfg_spice_models import CfgSpiceModel
@@ -41,28 +41,25 @@ class CfgData(object):
 
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb
-        self.edb_comps = self._pedb.components.components
         self.general = CfgGeneral(self, kwargs.get("general", None))
 
         self.boundaries = {}
         if kwargs.get("boundaries", None):
             self.boundaries = CfgBoundaries(self, kwargs.get("boundaries", None))
 
-        self.nets = None
-        if kwargs.get("nets"):
-            self.nets = CfgNets(
-                self, kwargs.get("nets", {}).get("signal_nets", []), kwargs.get("nets", {}).get("power_ground_nets", [])
-            )
+        self.nets = CfgNets(
+            self, kwargs.get("nets", {}).get("signal_nets", []), kwargs.get("nets", {}).get("power_ground_nets", [])
+        )
 
         self.components = CfgComponents(self._pedb, components_data=kwargs.get("components", []))
 
         self.padstacks = CfgPadstacks(self, kwargs.get("padstacks", None))
 
-        self.pin_groups = [CfgPinGroup(self, pin_group) for pin_group in kwargs.get("pin_groups", [])]
+        self.pin_groups = CfgPinGroups(self._pedb, pingroup_data=kwargs.get("pin_groups", []))
 
-        self.ports = [CfgPort(self, **port) for port in kwargs.get("ports", [])]
+        self.ports = CfgPorts(self._pedb, ports_data=kwargs.get("ports", []))
 
-        self.sources = [CfgSources(self, **source) for source in kwargs.get("sources", [])]
+        self.sources = CfgSources(self._pedb, sources_data=kwargs.get("sources", []))
 
         self.setups = CfgSetups(self._pedb, setups_data=kwargs.get("setups", []))
 

pyedb/configuration/cfg_nets.py

@@ -41,3 +41,17 @@ class CfgNets:
         for power_net in self.power_nets:
             if power_net in self._pedb.nets:
                 self._pedb.nets.nets[power_net].is_power_ground = True
+
+    def _load_data_from_db(self):
+        self.signal_nets = []
+        self.power_nets = []
+        for net in self._pedb.nets.signal:
+            self.signal_nets.append(net)
+        for net in self._pedb.nets.power:
+            self.power_nets.append(net)
+
+    def get_data_from_db(self):
+        """Get net information."""
+        self._load_data_from_db()
+        data = {"signal_nets": self.signal_nets, "power_ground_nets": self.power_nets}
+        return data

pyedb/configuration/cfg_pin_groups.py

@@ -20,39 +20,76 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from pyedb.configuration.cfg_common import CfgBase
 
-class CfgPinGroup:
+
+class CfgPinGroups:
     """Manage configuration pin group class."""
 
-    def __init__(self, pdata, pingroup_dict):
-        self._pedb = pdata._pedb
-        self._pingroup_dict = pingroup_dict
-        self.name = self._pingroup_dict.get("name", "")
-        self.reference_designator = self._pingroup_dict.get("reference_designator", "")
-        self.pins = self._pingroup_dict.get("pins", [])
-        self.net = self._pingroup_dict.get("net", [])
+    def __init__(self, pedb, pingroup_data):
+        self._pedb = pedb
+        self.pin_groups = [CfgPinGroup(self._pedb, **pg) for pg in pingroup_data]
 
     def apply(self):
+        for pg in self.pin_groups:
+            pg.create()
+
+    def get_data_from_db(self):
+        self.pin_groups = []
+        for name, pg in self._pedb.siwave.pin_groups.items():
+            pins = [p.aedt_name for p in pg.pins.values()]
+            cfg_pg = CfgPinGroup(
+                self._pedb,
+                name=name,
+                reference_designator=None,
+                pins=pins,
+            )
+            self.pin_groups.append(cfg_pg)
+        return self.export_properties()
+
+    def export_properties(self):
+        pin_groups = []
+        for pg in self.pin_groups:
+            pin_groups.append(pg.export_properties())
+        return pin_groups
+
+
+class CfgPinGroup(CfgBase):
+    def __init__(self, pedb, **kwargs):
+        self._pedb = pedb
+        self.name = kwargs["name"]
+        self.reference_designator = kwargs.get("reference_designator")
+        self.pins = kwargs.get("pins")
+        self.net = kwargs.get("net")
+
+    def create(self):
         """Apply pin group on layout."""
         if self.pins:
-            if not self._pedb.siwave.create_pin_group(self.reference_designator, list(self.pins), self.name):
-                self._pedb.logger.error(f"Failed to create pin group on pins {self.pins}")
-                return False
-            self._pedb.logger.info(f"Pin group {self.name} created.")
-            return True
+            if self.reference_designator is None:
+                self._pedb.modeler.create_pin_group(self.name, pins_by_aedt_name=self.pins)
+            else:
+                self._pedb.siwave.create_pin_group(self.reference_designator, list(self.pins), self.name)
         elif self.net:
             if self.reference_designator in self._pedb.components.instances:
                 comp = self._pedb.components.instances[self.reference_designator]
             else:
-                self._pedb.logger.error("Component not found for creating pin group.")
-                return False
+                raise f"Component not found for creating pin group {self.name}."
             pins = [p for p, obj in comp.pins.items() if obj.net_name in self.net]
             if not self._pedb.siwave.create_pin_group(self.reference_designator, pins, self.name):
                 self._pedb.logger.error(f"Failed to create pin group {self.name}")
-                return False
-            else:
-                self._pedb.logger.info(f"Pin group {self.name} created.")
-                return True
         else:
             self._pedb.logger.error(f"No net and pins defined for defining pin group {self.name}")
-            return False
+
+    def export_properties(self):
+        if self.pins:
+            return {
+                "name": self.name,
+                "reference_designator": self.reference_designator,
+                "pins": self.pins,
+            }
+        else:
+            return {
+                "name": self.name,
+                "reference_designator": self.reference_designator,
+                "net": self.net,
+            }

pyedb/configuration/cfg_ports_sources.py

@@ -20,92 +20,261 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from pyedb.configuration.cfg_common import CfgBase
 
-class CfgCircuitElement:
-    @property
-    def pedb(self):
-        """Edb."""
-        return self._pdata._pedb
 
-    def __init__(self, pdata, **kwargs):
-        self._pdata = pdata
-        self._data = kwargs
+class CfgTerminalInfo(CfgBase):
+    CFG_TERMINAL_TYPES = ["pin", "net", "pin_group", "nearest_pin", "coordinates"]
+
+    def __init__(self, pedb, **kwargs):
+        self._pedb = pedb
+        self.type = list(kwargs.keys())[0]
+        self.value = kwargs[self.type]
+
+    def export_properties(self):
+        return {self.type: self.value}
+
+
+class CfgCoordianteTerminalInfo(CfgTerminalInfo):
+    def __init__(self, pedb, **kwargs):
+        super().__init__(pedb, **kwargs)
+
+        self.layer = self.value["layer"]
+        self.point_x = self.value["point"][0]
+        self.point_y = self.value["point"][1]
+        self.net = self.value["net"]
+
+    def export_properties(self):
+        return {"layer": self.layer, "point_x": self.point_x, "point_y": self.point_y, "net": self.net}
+
+
+class CfgNearestPinTerminalInfo(CfgTerminalInfo):
+    def __init__(self, pedb, **kwargs):
+        super().__init__(pedb, **kwargs)
+        self.reference_net = self.value["reference_net"]
+        self.search_radius = self.value["search_radius"]
+
+    def export_properties(self):
+        return {"reference_net": self.reference_net, "search_radius": self.search_radius}
+
+
+class CfgSources:
+    def __init__(self, pedb, sources_data):
+        self._pedb = pedb
+        self.sources = [CfgSource(self._pedb, **src) for src in sources_data]
+
+    def apply(self):
+        for src in self.sources:
+            src.create()
+
+    def get_data_from_db(self):
+        self.sources = []
+        sources = {name: t for name, t in self._pedb.terminals.items() if not t.is_reference_terminal}
+        sources = {name: t for name, t in sources.items() if t.is_current_source or t.is_voltage_source}
+
+        for _, src in sources.items():
+            src_type = "voltage" if "voltage" in src.boundary_type.lower() else "current"
+            name = src.name
+            magnitude = src.magnitude
+
+            if src.terminal_type == "PinGroupTerminal":
+                refdes = ""
+                pg = self._pedb.siwave.pin_groups[src._edb_object.GetPinGroup().GetName()]
+                pos_term_info = {"pin_group": pg.name}
+            elif src.terminal_type == "PadstackInstanceTerminal":
+                refdes = src.component.refdes if src.component else ""
+                pos_term_info = {"pin": src.padstack_instance.component_pin}
+
+            neg_term = self._pedb.terminals[src.ref_terminal.name]
+            if neg_term.terminal_type == "PinGroupTerminal":
+                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":
+                neg_term_info = {"pin": neg_term.padstack_instance.component_pin}
+
+            cfg_src = CfgSource(
+                self._pedb,
+                name=name,
+                type=src_type,
+                magnitude=magnitude,
+                reference_designator=refdes,
+                positive_terminal=pos_term_info,
+                negative_terminal=neg_term_info,
+            )
+            self.sources.append(cfg_src)
+        return self.export_properties()
+
+    def export_properties(self):
+        sources = []
+        for src in self.sources:
+            sources.append(src.export_properties())
+        return sources
+
+
+class CfgPorts:
+    def __init__(self, pedb, ports_data):
+        self._pedb = pedb
+        self.ports = [CfgPort(self._pedb, **p) for p in ports_data]
+
+    def apply(self):
+        for p in self.ports:
+            p.create()
+
+    def get_data_from_db(self):
+        self.ports = []
+        ports = {name: t for name, t in self._pedb.terminals.items() if not t.is_reference_terminal}
+        ports = {name: t for name, t in ports.items() if t.is_port}
+
+        for _, p in ports.items():
+            port_type = "circuit" if p.is_circuit_port else "coax"
+
+            if p.terminal_type == "PinGroupTerminal":
+                refdes = ""
+                pg = self._pedb.siwave.pin_groups[p._edb_object.GetPinGroup().GetName()]
+                pos_term_info = {"pin_group": pg.name}
+            elif p.terminal_type == "PadstackInstanceTerminal":
+                refdes = p.component.refdes if p.component else ""
+                pos_term_info = {"pin": p.padstack_instance.component_pin}
+
+            if port_type == "circuit":
+                neg_term = self._pedb.terminals[p.ref_terminal.name]
+                if neg_term.terminal_type == "PinGroupTerminal":
+                    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":
+                    neg_term_info = {"pin": neg_term.padstack_instance.component_pin}
+
+                cfg_port = CfgPort(
+                    self._pedb,
+                    name=p.name,
+                    type=port_type,
+                    reference_designator=refdes,
+                    positive_terminal=pos_term_info,
+                    negative_terminal=neg_term_info,
+                )
+            else:
+                cfg_port = CfgPort(
+                    self._pedb,
+                    name=p.name,
+                    type=port_type,
+                    reference_designator=refdes,
+                    positive_terminal=pos_term_info,
+                )
+
+            self.ports.append(cfg_port)
+        return self.export_properties()
+
+    def export_properties(self):
+        ports = []
+        for p in self.ports:
+            ports.append(p.export_properties())
+        return ports
+
+
+class CfgCircuitElement(CfgBase):
+    def __init__(self, pedb, **kwargs):
+        self._pedb = pedb
         self.name = kwargs.get("name", None)
         self.type = kwargs.get("type", None)
         self.reference_designator = kwargs.get("reference_designator", None)
         self.distributed = kwargs.get("distributed", False)
-        self.pos_term_info = kwargs.get("positive_terminal", None)  # {"pin" : "A1"}
-        self.neg_term_info = kwargs.get("negative_terminal", None)
+
+        pos = kwargs["positive_terminal"]  # {"pin" : "A1"}
+        if list(pos.keys())[0] == "coordinates":
+            self.positive_terminal_info = CfgCoordianteTerminalInfo(self._pedb, **pos)
+        else:
+            self.positive_terminal_info = CfgTerminalInfo(self._pedb, **pos)
+
+        neg = kwargs.get("negative_terminal", {})
+        if len(neg) == 0:
+            self.negative_terminal_info = None
+        elif list(neg.keys())[0] == "coordinates":
+            self.negative_terminal_info = CfgCoordianteTerminalInfo(self._pedb, **neg)
+        elif list(neg.keys())[0] == "nearest_pin":
+            self.negative_terminal_info = CfgNearestPinTerminalInfo(self._pedb, **neg)
+        else:
+            self.negative_terminal_info = CfgTerminalInfo(self._pedb, **neg)
 
     def _create_terminals(self):
         """Create step 1. Collect positive and negative terminals."""
-        pos_term_info = self.pos_term_info
-        if pos_term_info:
-            pos_type, pos_value = [[i, j] for i, j in pos_term_info.items()][0]
-            pos_objs = dict()
-            pos_coor_terminal = dict()
-            if self.type == "coax":
+
+        pos_type, pos_value = self.positive_terminal_info.type, self.positive_terminal_info.value
+        pos_objs = dict()
+        pos_coor_terminal = dict()
+        if self.type == "coax":
+            pins = self._get_pins(pos_type, pos_value)
+            pins = {f"{self.name}_{self.reference_designator}": i for _, i in pins.items()}
+            pos_objs.update(pins)
+        elif pos_type == "coordinates":
+            layer = self.positive_terminal_info.layer
+            point = [self.positive_terminal_info.point_x, self.positive_terminal_info.point_y]
+            net_name = self.positive_terminal_info.net
+            pos_coor_terminal[self.name] = self._pedb.get_point_terminal(self.name, net_name, point, layer)
+        elif pos_type == "pin_group":
+            if self.distributed:
                 pins = self._get_pins(pos_type, pos_value)
-                pins = {f"{self.name}_{self.reference_designator}": i for _, i in pins.items()}
                 pos_objs.update(pins)
-            elif pos_type == "coordinates":
-                layer = pos_value["layer"]
-                point = pos_value["point"]
-                net_name = pos_value["net"]
-                pos_coor_terminal[self.name] = self.pedb.get_point_terminal(self.name, net_name, point, layer)
-            elif pos_type == "pin_group":
-                pos_objs[pos_value] = self.pedb.siwave.pin_groups[pos_value]
-            elif not self.distributed:
-                # get pins
-                pins = self._get_pins(pos_type, pos_value)  # terminal type pin or net
-                # create pin group
-                pin_group = self._create_pin_group(pins)
-                pos_objs.update(pin_group)
+                self._elem_num = len(pos_objs)
             else:
-                # get pins
-                pins = self._get_pins(pos_type, pos_value)  # terminal type pin or net or pin group
+                pos_objs[pos_value] = self._pedb.siwave.pin_groups[pos_value]
+        elif pos_type == "net":
+            if self.distributed:
+                pins = self._get_pins(pos_type, pos_value)
                 pos_objs.update(pins)
                 self._elem_num = len(pos_objs)
+            else:
+                pins = self._get_pins(pos_type, pos_value)
+                # create pin group
+                neg_obj = self._create_pin_group(pins)
+                pos_objs.update(neg_obj)
+        elif pos_type == "pin":
+            pins = {pos_value: self._pedb.components.components[self.reference_designator].pins[pos_value]}
+            pos_objs.update(pins)
+        else:
+            raise f"Wrong positive terminal type {pos_type}"
 
-            self.pos_terminals = {i: j.create_terminal(i) for i, j in pos_objs.items()}
-            self.pos_terminals.update(pos_coor_terminal)
+        self.pos_terminals = {i: j.create_terminal(i) for i, j in pos_objs.items()}
+        self.pos_terminals.update(pos_coor_terminal)
 
-        neg_term_info = self.neg_term_info
         self.neg_terminal = None
-        if neg_term_info:
-            neg_type, neg_value = [[i, j] for i, j in neg_term_info.items()][0]
+        if self.negative_terminal_info:
+            neg_type, neg_value = self.negative_terminal_info.type, self.negative_terminal_info.value
 
             if neg_type == "coordinates":
-                layer = neg_value["layer"]
-                point = neg_value["point"]
-                net_name = neg_value["net"]
-                self.neg_terminal = self.pedb.get_point_terminal(self.name + "_ref", net_name, point, layer)
+                layer = self.negative_terminal_info.layer
+                point = [self.negative_terminal_info.point_x, self.positive_terminal_info.point_y]
+                net_name = self.negative_terminal_info.net
+                self.neg_terminal = self._pedb.get_point_terminal(self.name + "_ref", net_name, point, layer)
             elif neg_type == "nearest_pin":
                 ref_net = neg_value.get("reference_net", "GND")
                 search_radius = neg_value.get("search_radius", "5e-3")
                 temp = dict()
                 for i, j in pos_objs.items():
-                    temp[i] = self._pdata._pedb.padstacks.get_reference_pins(j, ref_net, search_radius, max_limit=1)[0]
+                    temp[i] = self._pedb.padstacks.get_reference_pins(j, ref_net, search_radius, max_limit=1)[0]
                 self.neg_terminal = {
                     i: j.create_terminal(i + "_ref") if not j.terminal else j.terminal for i, j in temp.items()
                 }
             else:
                 if neg_type == "pin_group":
-                    pin_group = {neg_value: self.pedb.siwave.pin_groups[neg_value]}
-                else:
+                    neg_obj = {neg_value: self._pedb.siwave.pin_groups[neg_value]}
+                elif neg_type == "net":
                     # Get pins
                     pins = self._get_pins(neg_type, neg_value)  # terminal type pin or net
                     # create pin group
-                    pin_group = self._create_pin_group(pins, True)
+                    neg_obj = self._create_pin_group(pins, True)
+                elif neg_type == "pin":
+                    neg_obj = {neg_value: self._pedb.components.components[self.reference_designator].pins[neg_value]}
+                else:
+                    raise f"Wrong negative terminal type {neg_type}"
                 self.neg_terminal = [
-                    j.create_terminal(i) if not j.terminal else j.terminal for i, j in pin_group.items()
+                    j.create_terminal(i) if not j.terminal else j.terminal for i, j in neg_obj.items()
                 ][0]
 
     def _get_pins(self, terminal_type, terminal_value):
         terminal_value = terminal_value if isinstance(terminal_value, list) else [terminal_value]
 
         def get_pin_obj(pin_name):
-            return {pin_name: self._pdata.edb_comps[self.reference_designator].pins[pin_name]}
+            return {pin_name: self._pedb.components.components[self.reference_designator].pins[pin_name]}
 
         pins = dict()
         if terminal_type == "pin":
@@ -113,9 +282,9 @@ class CfgCircuitElement:
                 pins.update(get_pin_obj(i))
         else:
             if terminal_type == "net":
-                temp = self._pdata._pedb.components.get_pins(self.reference_designator, terminal_value[0])
+                temp = self._pedb.components.get_pins(self.reference_designator, terminal_value[0])
             elif terminal_type == "pin_group":
-                pin_group = self.pedb.siwave.pin_groups[terminal_value[0]]
+                pin_group = self._pedb.siwave.pin_groups[terminal_value[0]]
                 temp = pin_group.pins
             pins.update({f"{self.reference_designator}_{terminal_value[0]}_{i}": j for i, j in temp.items()})
         return pins
@@ -125,8 +294,8 @@ class CfgCircuitElement:
             pg_name = f"pg_{self.name}_{self.reference_designator}_ref"
         else:
             pg_name = f"pg_{self.name}_{self.reference_designator}"
-        pin_names = [i.pin_number for i in pins.values()]
-        name, temp = self._pdata._pedb.siwave.create_pin_group(self.reference_designator, pin_names, pg_name)
+        pin_names = [i.component_pin for i in pins.values()]
+        name, temp = self._pedb.siwave.create_pin_group(self.reference_designator, pin_names, pg_name)
         return {name: temp}
 
 
@@ -135,8 +304,8 @@ class CfgPort(CfgCircuitElement):
 
     CFG_PORT_TYPE = {"circuit": [str], "coax": [str]}
 
-    def __init__(self, pdata, **kwargs):
-        super().__init__(pdata, **kwargs)
+    def __init__(self, pedb, **kwargs):
+        super().__init__(pedb, **kwargs)
 
     def create(self):
         """Create port."""
@@ -145,29 +314,38 @@ class CfgPort(CfgCircuitElement):
         circuit_elements = []
         for name, j in self.pos_terminals.items():
             if isinstance(self.neg_terminal, dict):
-                elem = self.pedb.create_port(j, self.neg_terminal[name], is_circuit_port)
+                elem = self._pedb.create_port(j, self.neg_terminal[name], is_circuit_port)
             else:
-                elem = self.pedb.create_port(j, self.neg_terminal, is_circuit_port)
+                elem = self._pedb.create_port(j, self.neg_terminal, is_circuit_port)
             if not self.distributed:
                 elem.name = self.name
             circuit_elements.append(elem)
         return circuit_elements
 
+    def export_properties(self):
+        return {
+            "name": self.name,
+            "type": self.type,
+            "reference_designator": self.reference_designator,
+            "positive_terminal": self.positive_terminal_info.export_properties(),
+            "negative_terminal": self.negative_terminal_info.export_properties(),
+        }
 
-class CfgSources(CfgCircuitElement):
+
+class CfgSource(CfgCircuitElement):
     CFG_SOURCE_TYPE = {"current": [int, float], "voltage": [int, float]}
 
-    def __init__(self, pdata, **kwargs):
-        super().__init__(pdata, **kwargs)
+    def __init__(self, pedb, **kwargs):
+        super().__init__(pedb, **kwargs)
 
         self.magnitude = kwargs.get("magnitude", 0.001)
 
     def create(self):
         """Create sources."""
         self._create_terminals()
-        is_circuit_port = True if self.type == "circuit" else False
+        # is_circuit_port = True if self.type == "circuit" else False
         circuit_elements = []
-        method = self.pedb.create_current_source if self.type == "current" else self.pedb.create_voltage_source
+        method = self._pedb.create_current_source if self.type == "current" else self._pedb.create_voltage_source
         for name, j in self.pos_terminals.items():
             if isinstance(self.neg_terminal, dict):
                 elem = method(j, self.neg_terminal[name])
@@ -181,3 +359,13 @@ class CfgSources(CfgCircuitElement):
                 elem.magnitude = self.magnitude / self._elem_num
             circuit_elements.append(elem)
         return circuit_elements
+
+    def export_properties(self):
+        return {
+            "name": self.name,
+            "reference_designator": self.reference_designator,
+            "type": self.type,
+            "magnitude": self.magnitude,
+            "positive_terminal": self.positive_terminal_info.export_properties(),
+            "negative_terminal": self.negative_terminal_info.export_properties(),
+        }