pyedb 0.5.2__tar.gz → 0.7.0__tar.gz

{pyedb-0.5.2 → pyedb-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyedb
-Version: 0.5.2
+Version: 0.7.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>

{pyedb-0.5.2 → pyedb-0.7.0}/src/pyedb/__init__.py

@@ -44,10 +44,9 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.5.2"
+__version__ = "0.7.0"
 version = __version__
 
 #
 
-from pyedb.generic.design_types import Edb
-from pyedb.generic.design_types import Siwave
+from pyedb.generic.design_types import Edb, Siwave

{pyedb-0.5.2 → pyedb-0.7.0}/src/pyedb/dotnet/application/Variables.py

@@ -1,3 +1,25 @@
+# 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.
+
 """
 This module contains these classes: `CSVDataset`, `DataSet`, `Expression`, `Variable`, and `VariableManager`.
 

{pyedb-0.5.2 → pyedb-0.7.0}/src/pyedb/dotnet/edb.py

@@ -1,3 +1,25 @@
+# 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.
+
 """This module contains the ``Edb`` class.
 
 This module is implicitly loaded in HFSS 3D Layout when launched.
@@ -191,10 +213,21 @@ class Edb(Database):
                 os.path.dirname(edbpath),
                 "pyedb_" + os.path.splitext(os.path.split(edbpath)[-1])[0] + ".log",
             )
+            aedt_file = os.path.splitext(edbpath)[0] + ".aedt"
+            files = [aedt_file, aedt_file + ".lock"]
+            for file in files:
+                if os.path.isfile(file):
+                    try:
+                        shutil.rmtree(file)
+                        self.logger.info(f"Removing {file} to allow loading EDB file.")
+                    except:
+                        self.logger.info(
+                            f"Failed to delete {file} which is located at the same location as the EDB file."
+                        )
 
         if isaedtowned and (inside_desktop or settings.remote_rpc_session):
             self.open_edb_inside_aedt()
-        elif edbpath[-3:] in ["brd", "mcm", "sip", "gds", "xml", "dxf", "tgz"]:
+        elif edbpath[-3:] in ["brd", "mcm", "sip", "gds", "xml", "dxf", "tgz", "anf"]:
             self.edbpath = edbpath[:-4] + ".aedb"
             working_dir = os.path.dirname(edbpath)
             control_file = None
@@ -2290,9 +2323,9 @@ class Edb(Database):
                             list_prims = subtract(p, voids_data)
                             for prim in list_prims:
                                 if not prim.IsNull():
-                                    poly_to_create.append([prim, prim_1.layer_name, net, list_void])
+                                    poly_to_create.append([prim, prim_1.layer.name, net, list_void])
                         else:
-                            poly_to_create.append([p, prim_1.layer_name, net, list_void])
+                            poly_to_create.append([p, prim_1.layer.name, net, list_void])
 
                 prims_to_delete.append(prim_1)
 
@@ -2318,8 +2351,10 @@ class Edb(Database):
 
         for item in reference_paths:
             clip_path(item)
-        with ThreadPoolExecutor(number_of_threads) as pool:
-            pool.map(lambda item: clean_prim(item), reference_prims)
+        for prim in reference_prims:  # removing multithreading as failing with new layer from primitive
+            clean_prim(prim)
+        # with ThreadPoolExecutor(number_of_threads) as pool:
+        #    pool.map(lambda item: clean_prim(item), reference_prims)
 
         for el in poly_to_create:
             self.modeler.create_polygon(el[0], el[1], net_name=el[2], voids=el[3])
@@ -4141,7 +4176,7 @@ class Edb(Database):
                 if via_holes:  # pragma no cover
                     hole_variable = self._clean_string_for_variable_name("$hole_diam_{}".format(def_name))
                     if hole_variable not in self.variables:
-                        self.add_design_variable(hole_variable, padstack_def.hole_properties[0])
+                        self.add_design_variable(hole_variable, padstack_def.hole_diameter_string)
                     padstack_def.hole_properties = hole_variable
                     parameters.append(hole_variable)
             if pads:
@@ -4151,7 +4186,7 @@ class Edb(Database):
                             "$pad_diam_{}_{}".format(def_name, layer)
                         )
                         if pad_diameter_variable not in self.variables:
-                            self.add_design_variable(pad_diameter_variable, pad.parameters_values[0])
+                            self.add_design_variable(pad_diameter_variable, pad.parameters_values_string[0])
                         pad.parameters = {"Diameter": pad_diameter_variable}
                         parameters.append(pad_diameter_variable)
                     if pad.geometry_type == 2:  # pragma no cover
@@ -4159,7 +4194,7 @@ class Edb(Database):
                             "$pad_size_{}_{}".format(def_name, layer)
                         )
                         if pad_size_variable not in self.variables:
-                            self.add_design_variable(pad_size_variable, pad.parameters_values[0])
+                            self.add_design_variable(pad_size_variable, pad.parameters_values_string[0])
                         pad.parameters = {"Size": pad_size_variable}
                         parameters.append(pad_size_variable)
                     elif pad.geometry_type == 3:  # pragma no cover
@@ -4170,8 +4205,8 @@ class Edb(Database):
                             "$pad_size_y_{}_{}".format(def_name, layer)
                         )
                         if pad_size_variable_x not in self.variables and pad_size_variable_y not in self.variables:
-                            self.add_design_variable(pad_size_variable_x, pad.parameters_values[0])
-                            self.add_design_variable(pad_size_variable_y, pad.parameters_values[1])
+                            self.add_design_variable(pad_size_variable_x, pad.parameters_values_string[0])
+                            self.add_design_variable(pad_size_variable_y, pad.parameters_values_string[1])
                         pad.parameters = {"XSize": pad_size_variable_x, "YSize": pad_size_variable_y}
                         parameters.append(pad_size_variable_x)
                         parameters.append(pad_size_variable_y)
@@ -4182,7 +4217,7 @@ class Edb(Database):
                             "$antipad_diam_{}_{}".format(def_name, layer)
                         )
                         if antipad_diameter_variable not in self.variables:  # pragma no cover
-                            self.add_design_variable(antipad_diameter_variable, antipad.parameters_values[0])
+                            self.add_design_variable(antipad_diameter_variable, antipad.parameters_values_string[0])
                         antipad.parameters = {"Diameter": antipad_diameter_variable}
                         parameters.append(antipad_diameter_variable)
                     if antipad.geometry_type == 2:  # pragma no cover
@@ -4190,7 +4225,7 @@ class Edb(Database):
                             "$antipad_size_{}_{}".format(def_name, layer)
                         )
                         if antipad_size_variable not in self.variables:  # pragma no cover
-                            self.add_design_variable(antipad_size_variable, antipad.parameters_values[0])
+                            self.add_design_variable(antipad_size_variable, antipad.parameters_values_string[0])
                         antipad.parameters = {"Size": antipad_size_variable}
                         parameters.append(antipad_size_variable)
                     elif antipad.geometry_type == 3:  # pragma no cover
@@ -4204,8 +4239,8 @@ class Edb(Database):
                             antipad_size_variable_x not in self.variables
                             and antipad_size_variable_y not in self.variables
                         ):  # pragma no cover
-                            self.add_design_variable(antipad_size_variable_x, antipad.parameters_values[0])
-                            self.add_design_variable(antipad_size_variable_y, antipad.parameters_values[1])
+                            self.add_design_variable(antipad_size_variable_x, antipad.parameters_values_string[0])
+                            self.add_design_variable(antipad_size_variable_y, antipad.parameters_values_string[1])
                         antipad.parameters = {"XSize": antipad_size_variable_x, "YSize": antipad_size_variable_y}
                         parameters.append(antipad_size_variable_x)
                         parameters.append(antipad_size_variable_y)
@@ -4235,4 +4270,5 @@ class Edb(Database):
     def definitions(self):
         """Definitions class."""
         from pyedb.dotnet.edb_core.definition.definitions import Definitions
-        return Definitions(self)
+
+        return Definitions(self)

{pyedb-0.5.2 → pyedb-0.7.0}/src/pyedb/dotnet/edb_core/cell/hierarchy/model.py

@@ -1,3 +1,25 @@
+# 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.dotnet.edb_core.edb_data.obj_base import ObjBase
 from pyedb.generic.general_methods import pyedb_function_handler
 
@@ -64,3 +86,20 @@ class SParameterModel(Model):
 
     def component_model_name(self):
         self._edb_object.GetComponentModelName()
+
+
+class SPICEModel(Model):
+    """Manages SPICE model class."""
+
+    def __init__(self, pedb, edb_object=None):
+        super().__init__(pedb, edb_object)
+
+    @property
+    def model_name(self):
+        """SPICE model name."""
+        return self._edb_object.GetModelName()
+
+    @property
+    def spice_file_path(self):
+        """SPICE file path."""
+        return self._edb_object.GetSPICEFilePath()

{pyedb-0.5.2 → pyedb-0.7.0}/src/pyedb/dotnet/edb_core/components.py

@@ -1,3 +1,25 @@
+# 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.
+
 """This module contains the `Components` class.
 
 """
@@ -8,10 +30,10 @@ import re
 import warnings
 
 from pyedb.dotnet.clr_module import String
+from pyedb.dotnet.edb_core.definition.component_def import EDBComponentDef
 from pyedb.dotnet.edb_core.edb_data.components_data import EDBComponent
 from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
 from pyedb.dotnet.edb_core.edb_data.sources import Source, SourceType
-from pyedb.dotnet.edb_core.definition.component_def import EDBComponentDef
 from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 from pyedb.dotnet.edb_core.padstack import EdbPadstacks
 from pyedb.generic.general_methods import (

{pyedb-0.5.2 → pyedb-0.7.0}/src/pyedb/dotnet/edb_core/configuration.py

@@ -1,3 +1,25 @@
+# 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.
+
 import json
 from pathlib import Path
 
@@ -19,6 +41,8 @@ class Configuration:
         self._pedb = pedb
         self._components = self._pedb.components.components
         self.data = {}
+        self._s_parameter_library = ""
+        self._spice_model_library = ""
 
     @pyedb_function_handler
     def load(self, config_file, append=True, apply_file=False, output_file=None, open_at_the_end=True):
@@ -70,9 +94,22 @@ class Configuration:
             self._pedb.logger.error("No data loaded. Please load a configuration file.")
             return False
 
+        # Configure general settings
+        if "general" in self.data:
+            self._load_general()
+
+        # Configure nets
+        if "nets" in self.data:
+            self._load_nets()
+
+        # Configure components
         if "components" in self.data:
             self._load_components()
 
+        # Configure pin groups
+        if "pin_groups" in self.data:
+            self._load_pin_groups()
+
         # Configure ports
         if "ports" in self.data:
             self._load_ports()
@@ -93,15 +130,18 @@ class Configuration:
         if "s_parameters" in self.data:
             self._load_s_parameter()
 
-        return True
+        # Configure SPICE models
+        if "spice_models" in self.data:
+            self._load_spice_models()
 
+        return True
 
     @pyedb_function_handler
     def _load_components(self):
         """Imports component information from json."""
 
-        for comp in self.data["components"] :
-            refdes = comp["reference_designator"]
+        for comp in self.data["components"]:
+            ref_designator = comp["reference_designator"]
             part_type = comp["part_type"].lower()
             if part_type == "resistor":
                 part_type = "Resistor"
@@ -116,7 +156,7 @@ class Configuration:
             else:
                 part_type = "Other"
 
-            comp_layout = self._components[refdes]
+            comp_layout = self._components[ref_designator]
             comp_layout.type = part_type
 
             if part_type in ["Resistor", "Capacitor", "Inductor"]:
@@ -192,7 +232,7 @@ class Configuration:
                 height = solder_ball_properties["height"]
 
                 self._pedb.components.set_solder_ball(
-                    component=refdes,
+                    component=ref_designator,
                     sball_diam=diameter,
                     sball_mid_diam=mid_diameter,
                     sball_height=height,
@@ -208,38 +248,48 @@ class Configuration:
         """Imports port information from json."""
         for port in self.data["ports"]:
             port_type = port["type"]
-            refdes = port["reference_designator"]
-            comp_layout = self._components[refdes]
-            pos = port["from"]
-            if "pin" in pos:
-                pin_name = pos["pin"]
-                port_name = "{}_{}".format(refdes, pin_name)
-                pos_terminal = comp_layout.pins[pin_name].get_terminal(port_name, True)
-            else:  # Net
-                net_name = pos["net"]
-                port_name = "{}_{}".format(refdes, net_name)
-                if port_type == "circuit":
-                    pg_name = "pg_{}".format(port_name)
-                    _, pg = self._pedb.siwave.create_pin_group_on_net(refdes, net_name, pg_name)
-                    pos_terminal = pg.get_terminal(port_name, True)
-                else:  # Coax port
-                    for _, p in comp_layout.pins.items():
-                        if p.net_name == net_name:
-                            pos_terminal = p.get_terminal(port_name, True)
-                            break
+
+            positive_terminal_json = port["positive_terminal"]
+            pos_terminal = ""
+            if "pin_group" in positive_terminal_json:
+                pin_group = self._pedb.siwave.pin_groups[positive_terminal_json["pin_group"]]
+                pos_terminal = pin_group.get_terminal(pin_group.name, True)
+            else:
+                ref_designator = port["reference_designator"]
+                comp_layout = self._components[ref_designator]
+
+                if "pin" in positive_terminal_json:
+                    pin_name = positive_terminal_json["pin"]
+                    port_name = "{}_{}".format(ref_designator, pin_name)
+                    pos_terminal = comp_layout.pins[pin_name].get_terminal(port_name, True)
+                else:  # Net
+                    net_name = positive_terminal_json["net"]
+                    port_name = "{}_{}".format(ref_designator, net_name)
+                    if port_type == "circuit":
+                        pg_name = "pg_{}".format(port_name)
+                        _, pg = self._pedb.siwave.create_pin_group_on_net(ref_designator, net_name, pg_name)
+                        pos_terminal = pg.get_terminal(port_name, True)
+                    else:  # Coax port
+                        for _, p in comp_layout.pins.items():
+                            if p.net_name == net_name:
+                                pos_terminal = p.get_terminal(port_name, True)
+                                break
 
             if port_type == "circuit":
-                neg = port["to"]
-                if "pin" in neg:
-                    pin_name = neg["pin"]
-                    port_name = "{}_{}_ref".format(refdes, pin_name)
+                negative_terminal_json = port["negative_terminal"]
+                if "pin_group" in negative_terminal_json:
+                    pin_group = self._pedb.siwave.pin_groups[negative_terminal_json["pin_group"]]
+                    neg_terminal = pin_group.get_terminal(pin_group.name + "_ref", True)
+                elif "pin" in negative_terminal_json:
+                    pin_name = negative_terminal_json["pin"]
+                    port_name = "{}_{}_ref".format(ref_designator, pin_name)
                     neg_terminal = comp_layout.pins[pin_name].get_terminal(port_name, True)
                 else:
-                    net_name = neg["net"]
-                    port_name = "{}_{}_ref".format(refdes, net_name)
+                    net_name = negative_terminal_json["net"]
+                    port_name = "{}_{}_ref".format(ref_designator, net_name)
                     pg_name = "pg_{}".format(port_name)
                     if pg_name not in self._pedb.siwave.pin_groups:
-                        _, pg = self._pedb.siwave.create_pin_group_on_net(refdes, net_name, pg_name)
+                        _, pg = self._pedb.siwave.create_pin_group_on_net(ref_designator, net_name, pg_name)
                     else:
                         pg = self._pedb.siwave.pin_groups[pg_name]
                     neg_terminal = pg.get_terminal(port_name, True)
@@ -254,36 +304,47 @@ class Configuration:
 
         for src in self.data["sources"]:
             src_type = src["type"]
-            refdes = src["reference_designator"]
             name = src["name"]
-            comp_layout = self._components[refdes]
-
-            pos = src["from"]
-            if "pin" in pos:
-                pin_name = pos["pin"]
-                src_name = name
-                pos_terminal = comp_layout.pins[pin_name].get_terminal(src_name, True)
-            elif "net" in pos:  # Net
-                net_name = pos["net"]
-                src_name = "{}_{}".format(refdes, net_name)
-                pg_name = "pg_{}".format(src_name)
-                _, pg = self._pedb.siwave.create_pin_group_on_net(refdes, net_name, pg_name)
-                pos_terminal = pg.get_terminal(src_name, True)
-
-            neg = src["to"]
-            if "pin" in neg:
-                pin_name = neg["pin"]
-                src_name = name + "_ref"
-                neg_terminal = comp_layout.pins[pin_name].get_terminal(src_name, True)
-            elif "net" in neg:
-                net_name = neg["net"]
-                src_name = name + "_ref"
-                pg_name = "pg_{}".format(src_name)
-                if pg_name not in self._pedb.siwave.pin_groups:
-                    _, pg = self._pedb.siwave.create_pin_group_on_net(refdes, net_name, pg_name)
-                else:  # pragma no cover
-                    pg = self._pedb.siwave.pin_groups[pg_name]
-                neg_terminal = pg.get_terminal(src_name, True)
+
+            positive_terminal_json = src["positive_terminal"]
+            if "pin_group" in positive_terminal_json:
+                pin_group = self._pedb.siwave.pin_groups[positive_terminal_json["pin_group"]]
+                pos_terminal = pin_group.get_terminal(pin_group.name, True)
+            else:
+                ref_designator = src["reference_designator"]
+                comp_layout = self._components[ref_designator]
+
+                if "pin" in positive_terminal_json:
+                    pin_name = positive_terminal_json["pin"]
+                    src_name = name
+                    pos_terminal = comp_layout.pins[pin_name].get_terminal(src_name, True)
+                elif "net" in positive_terminal_json:  # Net
+                    net_name = positive_terminal_json["net"]
+                    src_name = "{}_{}".format(ref_designator, net_name)
+                    pg_name = "pg_{}".format(src_name)
+                    _, pg = self._pedb.siwave.create_pin_group_on_net(ref_designator, net_name, pg_name)
+                    pos_terminal = pg.get_terminal(src_name, True)
+
+            negative_terminal_json = src["negative_terminal"]
+            if "pin_group" in negative_terminal_json:
+                pin_group = self._pedb.siwave.pin_groups[negative_terminal_json["pin_group"]]
+                neg_terminal = pin_group.get_terminal(pin_group.name + "_ref", True)
+            else:
+                ref_designator = src["reference_designator"]
+                comp_layout = self._components[ref_designator]
+                if "pin" in negative_terminal_json:
+                    pin_name = negative_terminal_json["pin"]
+                    src_name = name + "_ref"
+                    neg_terminal = comp_layout.pins[pin_name].get_terminal(src_name, True)
+                elif "net" in negative_terminal_json:
+                    net_name = negative_terminal_json["net"]
+                    src_name = name + "_ref"
+                    pg_name = "pg_{}".format(src_name)
+                    if pg_name not in self._pedb.siwave.pin_groups:
+                        _, pg = self._pedb.siwave.create_pin_group_on_net(ref_designator, net_name, pg_name)
+                    else:  # pragma no cover
+                        pg = self._pedb.siwave.pin_groups[pg_name]
+                    neg_terminal = pg.get_terminal(src_name, True)
 
             if src_type == "voltage":
                 src_obj = self._pedb.create_voltage_source(pos_terminal, neg_terminal)
@@ -409,6 +470,8 @@ class Configuration:
 
         for sp in self.data["s_parameters"]:
             fpath = sp["file_path"]
+            if not Path(fpath).anchor:
+                fpath = str(Path(self._s_parameter_library) / fpath)
             sp_name = sp["name"]
             comp_def_name = sp["component_definition"]
             comp_def = self._pedb.definitions.component[comp_def_name]
@@ -421,3 +484,55 @@ class Configuration:
                 for refdes, comp in comp_def.components.items():
                     if refdes in sp["components"]:
                         comp.use_s_parameter_model(sp_name)
+
+    @pyedb_function_handler
+    def _load_spice_models(self):
+        """Imports SPICE information from json."""
+
+        for sp in self.data["spice_models"]:
+            fpath = sp["file_path"]
+            if not Path(fpath).anchor:
+                fpath = str(Path(self._spice_model_library) / fpath)
+            sp_name = sp["name"]
+            sub_circuit_name = sp.get("sub_circuit_name", None)
+            comp_def_name = sp["component_definition"]
+            comp_def = self._pedb.definitions.component[comp_def_name]
+            comps = comp_def.components
+            if sp["apply_to_all"]:
+                for refdes, comp in comps.items():
+                    if refdes not in sp["components"]:
+                        comp.assign_spice_model(fpath, sp_name, sub_circuit_name)
+            else:
+                for refdes, comp in comps.items():
+                    if refdes in sp["components"]:
+                        comp.assign_spice_model(fpath, sp_name, sub_circuit_name)
+
+    @pyedb_function_handler
+    def _load_pin_groups(self):
+        """Imports pin groups information from JSON."""
+        for pg in self.data["pin_groups"]:
+            name = pg["name"]
+            ref_designator = pg["reference_designator"]
+            if "pins" in pg:
+                self._pedb.siwave.create_pin_group(ref_designator, pg["pins"], name)
+            elif "net" in pg:
+                self._pedb.siwave.create_pin_group_on_net(ref_designator, pg["net"], name)
+
+    @pyedb_function_handler
+    def _load_nets(self):
+        """Imports nets information from JSON."""
+        nets = self._pedb.nets.nets
+        for i in self.data["nets"]["power_ground_nets"]:
+            nets[i].is_power_ground = True
+
+        for i in self.data["nets"]["signal_nets"]:
+            nets[i].is_power_ground = False
+
+    @pyedb_function_handler
+    def _load_general(self):
+        """Imports general information from JSON."""
+        general = self.data["general"]
+        if "s_parameter_library" in general:
+            self._s_parameter_library = general["s_parameter_library"]
+        if "spice_model_library" in general:
+            self._spice_model_library = general["spice_model_library"]

{pyedb-0.5.2 → pyedb-0.7.0}/src/pyedb/dotnet/edb_core/definition/component_def.py

@@ -1,10 +1,30 @@
+# 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.
+
 import os
 
+from pyedb.dotnet.edb_core.definition.component_model import NPortComponentModel
 from pyedb.dotnet.edb_core.edb_data.obj_base import ObjBase
 from pyedb.generic.general_methods import pyedb_function_handler
-from pyedb.dotnet.edb_core.definition.component_model import (
-    NPortComponentModel
-)
 
 
 class EDBComponentDef(ObjBase):
@@ -65,6 +85,7 @@ class EDBComponentDef(ObjBase):
         dict of :class:`EDBComponent`
         """
         from pyedb.dotnet.edb_core.edb_data.components_data import EDBComponent
+
         comp_list = [
             EDBComponent(self._pedb, l)
             for l in self._pedb.edb_api.cell.hierarchy.component.FindByComponentDef(