pyedb 0.17.0__tar.gz → 0.19.0__tar.gz

{pyedb-0.17.0 → pyedb-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyedb
-Version: 0.17.0
+Version: 0.19.0
 Summary: Higher-Level Pythonic Ansys Electronics Data Base
 Author-email: "ANSYS, Inc." <pyansys.core@ansys.com>
 Maintainer-email: PyEDB developers <simon.vandenbrouck@ansys.com>
@@ -19,16 +19,19 @@ Requires-Dist: cffi>=1.16.0,<1.17; platform_system=='Linux'
 Requires-Dist: pywin32 >= 303;platform_system=='Windows'
 Requires-Dist: ansys-pythonnet >= 3.1.0rc3
 Requires-Dist: dotnetcore2 ==3.1.23;platform_system=='Linux'
-Requires-Dist: pydantic>=2.6.4,<2.8
-Requires-Dist: toml == 0.10.2
-Requires-Dist: Rtree >= 1.2.0
 Requires-Dist: numpy>=1.20.0,<2
+Requires-Dist: pandas>=1.1.0,<2.3
+Requires-Dist: pydantic>=2.6.4,<2.9
+Requires-Dist: Rtree >= 1.2.0
+Requires-Dist: toml == 0.10.2
 Requires-Dist: ansys-sphinx-theme>=0.10.0,<0.17 ; extra == "doc"
 Requires-Dist: imageio>=2.30.0,<2.35 ; extra == "doc"
-Requires-Dist: ipython>=8.13.0,<8.26 ; extra == "doc"
+Requires-Dist: ipython>=8.13.0,<8.27 ; extra == "doc"
 Requires-Dist: jupyterlab>=4.0.0,<4.3 ; extra == "doc"
+Requires-Dist: jupytext>=1.16.0,<1.17 ; extra == "doc"
 Requires-Dist: matplotlib>=3.5.0,<3.10 ; extra == "doc"
 Requires-Dist: nbsphinx>=0.9.0,<0.10 ; extra == "doc"
+Requires-Dist: nbconvert < 7.14 ; extra == "doc"
 Requires-Dist: numpydoc>=1.5.0,<1.8 ; extra == "doc"
 Requires-Dist: pypandoc>=1.10.0,<1.14 ; extra == "doc"
 Requires-Dist: recommonmark ; extra == "doc"
@@ -39,11 +42,8 @@ Requires-Dist: sphinx-copybutton>=0.5.0,<0.6 ; extra == "doc"
 Requires-Dist: sphinx-gallery>=0.14.0,<0.17 ; extra == "doc"
 Requires-Dist: sphinx_design>=0.4.0,<0.7 ; extra == "doc"
 Requires-Dist: matplotlib>=3.5.0,<3.10 ; extra == "full"
-Requires-Dist: pandas>=1.1.0,<2.3 ; extra == "full"
 Requires-Dist: matplotlib>=3.5.0,<3.10 ; extra == "tests"
-Requires-Dist: numpy>=1.20.0,<2 ; extra == "tests"
 Requires-Dist: mock>=5.1.0,<5.2 ; extra == "tests"
-Requires-Dist: pandas>=1.1.0,<2.3 ; extra == "tests"
 Requires-Dist: pytest>=7.4.0,<8.3 ; extra == "tests"
 Requires-Dist: pytest-cov>=4.0.0,<5.1 ; extra == "tests"
 Requires-Dist: pytest-xdist>=3.5.0,<3.7 ; extra == "tests"

{pyedb-0.17.0 → pyedb-0.19.0}/pyproject.toml

@@ -29,18 +29,17 @@ dependencies = [
     "pywin32 >= 303;platform_system=='Windows'",
     "ansys-pythonnet >= 3.1.0rc3",
     "dotnetcore2 ==3.1.23;platform_system=='Linux'",
-    "pydantic>=2.6.4,<2.8",
-    "toml == 0.10.2",
-    "Rtree >= 1.2.0",
     "numpy>=1.20.0,<2",
+    "pandas>=1.1.0,<2.3",
+    "pydantic>=2.6.4,<2.9",
+    "Rtree >= 1.2.0",
+    "toml == 0.10.2",
     ]
 
 [project.optional-dependencies]
 tests = [
     "matplotlib>=3.5.0,<3.10",
-    "numpy>=1.20.0,<2",
     "mock>=5.1.0,<5.2",
-    "pandas>=1.1.0,<2.3",
     "pytest>=7.4.0,<8.3",
     "pytest-cov>=4.0.0,<5.1",
     "pytest-xdist>=3.5.0,<3.7",
@@ -48,10 +47,12 @@ tests = [
 doc = [
     "ansys-sphinx-theme>=0.10.0,<0.17",
     "imageio>=2.30.0,<2.35",
-    "ipython>=8.13.0,<8.26",
+    "ipython>=8.13.0,<8.27",
     "jupyterlab>=4.0.0,<4.3",
+    "jupytext>=1.16.0,<1.17",
     "matplotlib>=3.5.0,<3.10",
     "nbsphinx>=0.9.0,<0.10",
+    "nbconvert < 7.14",
     "numpydoc>=1.5.0,<1.8",
     "pypandoc>=1.10.0,<1.14",
     # NOTE: Remove recommonmark once examples are reworked.
@@ -65,7 +66,6 @@ doc = [
 ]
 full = [
     "matplotlib>=3.5.0,<3.10",
-    "pandas>=1.1.0,<2.3",
 ]
 
 

{pyedb-0.17.0 → pyedb-0.19.0}/src/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-0.17.0 → pyedb-0.19.0}/src/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-0.17.0 → pyedb-0.19.0}/src/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-0.19.0/src/pyedb/configuration/cfg_pin_groups.py

@@ -0,0 +1,95 @@
+# Copyright (C) 2023 - 2024 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.configuration.cfg_common import CfgBase
+
+
+class CfgPinGroups:
+    """Manage configuration pin group class."""
+
+    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 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:
+                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}")
+        else:
+            self._pedb.logger.error(f"No net and pins defined for defining pin group {self.name}")
+
+    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-0.19.0/src/pyedb/configuration/cfg_ports_sources.py

@@ -0,0 +1,371 @@
+# Copyright (C) 2023 - 2024 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.configuration.cfg_common import CfgBase
+
+
+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)
+
+        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_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)
+                pos_objs.update(pins)
+                self._elem_num = len(pos_objs)
+            else:
+                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.neg_terminal = None
+        if self.negative_terminal_info:
+            neg_type, neg_value = self.negative_terminal_info.type, self.negative_terminal_info.value
+
+            if neg_type == "coordinates":
+                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._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":
+                    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
+                    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 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._pedb.components.components[self.reference_designator].pins[pin_name]}
+
+        pins = dict()
+        if terminal_type == "pin":
+            for i in terminal_value:
+                pins.update(get_pin_obj(i))
+        else:
+            if terminal_type == "net":
+                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]]
+                temp = pin_group.pins
+            pins.update({f"{self.reference_designator}_{terminal_value[0]}_{i}": j for i, j in temp.items()})
+        return pins
+
+    def _create_pin_group(self, pins, is_ref=False):
+        if is_ref:
+            pg_name = f"pg_{self.name}_{self.reference_designator}_ref"
+        else:
+            pg_name = f"pg_{self.name}_{self.reference_designator}"
+        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}
+
+
+class CfgPort(CfgCircuitElement):
+    """Manage port."""
+
+    CFG_PORT_TYPE = {"circuit": [str], "coax": [str]}
+
+    def __init__(self, pedb, **kwargs):
+        super().__init__(pedb, **kwargs)
+
+    def create(self):
+        """Create port."""
+        self._create_terminals()
+        is_circuit_port = True if self.type == "circuit" else False
+        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)
+            else:
+                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 CfgSource(CfgCircuitElement):
+    CFG_SOURCE_TYPE = {"current": [int, float], "voltage": [int, float]}
+
+    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
+        circuit_elements = []
+        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])
+            else:
+                elem = method(j, self.neg_terminal)
+            if not self.distributed:
+                elem.name = self.name
+                elem.magnitude = self.magnitude
+            else:
+                elem.name = f"{self.name}_{elem.name}"
+                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(),
+        }