pyedb 0.6.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

pyedb/dotnet/edb_core/configuration.py

@@ -21,17 +21,13 @@
 # SOFTWARE.
 
 import json
+import os
 from pathlib import Path
 
-from pyedb.generic.general_methods import pyedb_function_handler
-
+import toml
 
-def load_json(config_file):
-    if isinstance(config_file, (str, Path)):
-        with open(config_file, "r") as f:
-            return json.load(f)
-    elif isinstance(config_file, dict):
-        return config_file
+from pyedb.dotnet.edb_core.definition.package_def import PackageDef
+from pyedb.generic.general_methods import pyedb_function_handler
 
 
 class Configuration:
@@ -41,15 +37,17 @@ 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):
-        """Import configuration settings from a JSON file.
+        """Import configuration settings from a configure file.
 
         Parameters
         ----------
-        config_file : str
-            Full path to json file.
+        config_file : str, dict
+            Full path to configure file in JSON or TOML format. Dictionary is also supported.
         append : bool, optional
             Whether if the new file will append to existing properties or the properties will be cleared before import.
             Default is ``True`` to keep stored properties
@@ -65,12 +63,29 @@ class Configuration:
         dict
             Config dictionary.
         """
+        if isinstance(config_file, dict):
+            data = config_file
+        elif os.path.isfile(config_file):
+            with open(config_file, "r") as f:
+                if config_file.endswith(".json"):
+                    data = json.load(f)
+                elif config_file.endswith(".toml"):
+                    data = toml.load(f)
+        else:  # pragma: no cover
+            return False
 
-        data = load_json(config_file)
-        if not append:
+        if not append:  # pragma: no cover
             self.data = {}
         for k, v in data.items():
-            self.data[k] = v
+            if k in self.data:
+                if isinstance(v, list):
+                    self.data[k].extend(v)
+                elif isinstance(v, dict):  # pragma: no cover
+                    self.data[k].update(v)
+                else:  # pragma: no cover
+                    self.data[k] = v
+            else:
+                self.data[k] = v
         if apply_file:
             original_file = self._pedb.edbpath
             if output_file:
@@ -92,9 +107,30 @@ 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 boundary settings
+        if "boundaries" in self.data:
+            self._load_boundaries()
+
+        # Configure nets
+        if "nets" in self.data:
+            self._load_nets()
+
+        # Configure components
         if "components" in self.data:
             self._load_components()
 
+        # Configure padstacks
+        if "padstacks" in self.data:
+            self._load_padstacks()
+
+        # Configure pin groups
+        if "pin_groups" in self.data:
+            self._load_pin_groups()
+
         # Configure ports
         if "ports" in self.data:
             self._load_ports()
@@ -115,6 +151,18 @@ class Configuration:
         if "s_parameters" in self.data:
             self._load_s_parameter()
 
+        # Configure SPICE models
+        if "spice_models" in self.data:
+            self._load_spice_models()
+
+        # Configure package definitions
+        if "package_definitions" in self.data:
+            self._load_package_def()
+
+        # Configure operations
+        if "operations" in self.data:
+            self._load_operations()
+
         return True
 
     @pyedb_function_handler
@@ -122,7 +170,7 @@ class Configuration:
         """Imports component information from json."""
 
         for comp in self.data["components"]:
-            refdes = comp["reference_designator"]
+            ref_designator = comp["reference_designator"]
             part_type = comp["part_type"].lower()
             if part_type == "resistor":
                 part_type = "Resistor"
@@ -137,7 +185,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"]:
@@ -213,7 +261,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,
@@ -229,38 +277,50 @@ 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"]]
+                port_name = pin_group.name if "name" not in port else port["name"]
+                pos_terminal = pin_group.get_terminal(port_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) if "name" not in port else port["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 "name" not in port else port["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)
@@ -275,36 +335,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)
@@ -349,7 +420,10 @@ class Configuration:
                     else:
                         self._pedb.logger.warning("Setup {} already existing. Editing it.".format(name))
                         edb_setup = self._pedb.setups[name]
-                    edb_setup.si_slider_position = setup["si_slider_position"]
+                    if "si_slider_position" in setup:
+                        edb_setup.si_slider_position = setup["si_slider_position"]
+                    if "pi_slider_position" in setup:
+                        edb_setup.pi_slider_position = setup["pi_slider_position"]
 
                 if "freq_sweep" in setup:
                     for fsweep in setup["freq_sweep"]:
@@ -430,15 +504,210 @@ 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]
             comp_def.add_n_port_model(fpath, sp_name)
+            comp_list = dict()
+            if sp["apply_to_all"]:
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in sp["components"]}
+                )
+            else:
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes in sp["components"]}
+                )
+
+            for refdes, comp in comp_list.items():
+                if "reference_net_per_component" in sp:
+                    ref_net_per_comp = sp["reference_net_per_component"]
+                    ref_net = ref_net_per_comp[refdes] if refdes in ref_net_per_comp else sp["reference_net"]
+                else:
+                    ref_net = sp["reference_net"]
+                comp.use_s_parameter_model(sp_name, reference_net=ref_net)
+
+    @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 comp_def.components.items():
+                for refdes, comp in comps.items():
                     if refdes not in sp["components"]:
-                        comp.use_s_parameter_model(sp_name)
+                        comp.assign_spice_model(fpath, sp_name, sub_circuit_name)
             else:
-                for refdes, comp in comp_def.components.items():
+                for refdes, comp in comps.items():
                     if refdes in sp["components"]:
-                        comp.use_s_parameter_model(sp_name)
+                        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_function_handler
+    def _load_boundaries(self):
+        """Imports boundary information from JSON."""
+        boundaries = self.data["boundaries"]
+
+        open_region = boundaries.get("open_region", None)
+        if open_region:
+            self._pedb.hfss.hfss_extent_info.use_open_region = open_region
+
+        open_region_type = boundaries.get("open_region_type", None)
+        if open_region_type:
+            self._pedb.hfss.hfss_extent_info.open_region_type = open_region_type
+
+        pml_visible = boundaries.get("pml_visible", None)
+        if pml_visible:
+            self._pedb.hfss.hfss_extent_info.is_pml_visible = pml_visible
+
+        pml_operation_frequency = boundaries.get("pml_operation_frequency", None)
+        if pml_operation_frequency:
+            self._pedb.hfss.hfss_extent_info.operating_freq = pml_operation_frequency
+
+        pml_radiation_factor = boundaries.get("pml_radiation_factor", None)
+        if pml_radiation_factor:
+            self._pedb.hfss.hfss_extent_info.radiation_level = pml_radiation_factor
+
+        dielectric_extents_type = boundaries.get("dielectric_extents_type", None)
+        if dielectric_extents_type:
+            self._pedb.hfss.hfss_extent_info.extent_type = dielectric_extents_type
+
+        dielectric_base_polygon = boundaries.get("dielectric_base_polygon", None)
+        if dielectric_base_polygon:
+            self._pedb.hfss.hfss_extent_info.dielectric_base_polygon = dielectric_base_polygon
+
+        horizontal_padding = boundaries.get("horizontal_padding", None)
+        if horizontal_padding:
+            self._pedb.hfss.hfss_extent_info.dielectric_extent_size = horizontal_padding
+
+        honor_primitives_on_dielectric_layers = boundaries.get("honor_primitives_on_dielectric_layers", None)
+        if honor_primitives_on_dielectric_layers:
+            self._pedb.hfss.hfss_extent_info.honor_user_dielectric = honor_primitives_on_dielectric_layers
+
+        air_box_extents_type = boundaries.get("air_box_extents_type", None)
+        if air_box_extents_type:
+            self._pedb.hfss.hfss_extent_info.extent_type = air_box_extents_type
+
+        air_box_truncate_model_ground_layers = boundaries.get("air_box_truncate_model_ground_layers", None)
+        if air_box_truncate_model_ground_layers:
+            self._pedb.hfss.hfss_extent_info.truncate_air_box_at_ground = air_box_truncate_model_ground_layers
+
+        air_box_horizontal_padding = boundaries.get("air_box_horizontal_padding", None)
+        if air_box_horizontal_padding:
+            self._pedb.hfss.hfss_extent_info.air_box_horizontal_extent = air_box_horizontal_padding
+
+        air_box_positive_vertical_padding = boundaries.get("air_box_positive_vertical_padding", None)
+        if air_box_positive_vertical_padding:
+            self._pedb.hfss.hfss_extent_info.air_box_positive_vertical_extent = air_box_positive_vertical_padding
+
+        air_box_negative_vertical_padding = boundaries.get("air_box_negative_vertical_padding", None)
+        if air_box_positive_vertical_padding:
+            self._pedb.hfss.hfss_extent_info.air_box_negative_vertical_extent = air_box_negative_vertical_padding
+
+    @pyedb_function_handler
+    def _load_operations(self):
+        """Imports operation information from JSON."""
+        operations = self.data["operations"]
+        cutout = operations.get("cutout", None)
+        if cutout:
+            self._pedb.cutout(**cutout)
+
+    @pyedb_function_handler
+    def _load_padstacks(self):
+        """Imports padstack information from JSON."""
+        padstacks = self.data["padstacks"]
+        definitions = padstacks.get("definitions", None)
+        if definitions:
+            padstack_defs = self._pedb.padstacks.definitions
+            for value in definitions:
+                pdef = padstack_defs[value["name"]]
+                if "hole_diameter" in value:
+                    pdef.hole_diameter = value["hole_diameter"]
+                if "hole_plating_thickness" in value:
+                    pdef.hole_plating_thickness = value["hole_plating_thickness"]
+                if "hole_material" in value:
+                    pdef.material = value["hole_material"]
+                if "hole_range" in value:
+                    pdef.hole_range = value["hole_range"]
+        instances = padstacks.get("instances", None)
+        if instances:
+            padstack_instances = self._pedb.padstacks.instances_by_name
+            for value in instances:
+                inst = padstack_instances[value["name"]]
+                backdrill_top = value.get("backdrill_top", None)
+                if backdrill_top:
+                    inst.set_backdrill_top(
+                        backdrill_top["drill_to_layer"], backdrill_top["drill_diameter"], backdrill_top["stub_length"]
+                    )
+                backdrill_bottom = value.get("backdrill_bottom", None)
+                if backdrill_top:
+                    inst.set_backdrill_bottom(
+                        backdrill_bottom["drill_to_layer"],
+                        backdrill_bottom["drill_diameter"],
+                        backdrill_bottom["stub_length"],
+                    )
+
+    @pyedb_function_handler
+    def _load_package_def(self):
+        """Imports package definition information from JSON."""
+        comps = self._pedb.components.components
+        for pkgd in self.data["package_definitions"]:
+            name = pkgd["name"]
+            if name in self._pedb.definitions.package:
+                self._pedb.definitions.package[name].delete()
+            package_def = PackageDef(self._pedb, name=name)
+            package_def.maximum_power = pkgd["maximum_power"]
+            package_def.therm_cond = pkgd["therm_cond"]
+            package_def.theta_jb = pkgd["theta_jb"]
+            package_def.theta_jc = pkgd["theta_jc"]
+            package_def.height = pkgd["height"]
+
+            heatsink = pkgd.get("heatsink", None)
+            if heatsink:
+                package_def.set_heatsink(
+                    heatsink["fin_base_height"],
+                    heatsink["fin_height"],
+                    heatsink["fin_orientation"],
+                    heatsink["fin_spacing"],
+                    heatsink["fin_thickness"],
+                )
+            json_comps = pkgd["components"] if isinstance(pkgd["components"], list) else [pkgd["components"]]
+            for i in json_comps:
+                comps[i].package_def = name

pyedb/dotnet/edb_core/definition/component_def.py

@@ -152,6 +152,15 @@ class EDBComponentDef(ObjBase):
             comp.assign_spice_model(file_path, model_name)
         return True
 
+    @property
+    def reference_file(self):
+        ref_files = []
+        for comp_model in self._comp_model:
+            model_type = str(comp_model.GetComponentModelType())
+            if model_type == "NPortComponentModel" or model_type == "DynamicLinkComponentModel":
+                ref_files.append(comp_model.GetReferenceFile())
+        return ref_files
+
     @property
     def component_models(self):
         temp = {}

pyedb/dotnet/edb_core/definition/package_def.py

@@ -67,6 +67,11 @@ class PackageDef(ObjBase):
         edb_object.SetExteriorBoundary(polygon)
         return edb_object
 
+    @pyedb_function_handler
+    def delete(self):
+        """Delete a package definition object from the database."""
+        return self._edb_object.Delete()
+
     @property
     def maximum_power(self):
         """Maximum power of the package."""
@@ -116,3 +121,25 @@ class PackageDef(ObjBase):
     def height(self, value):
         value = self._pedb.edb_value(value)
         self._edb_object.SetHeight(value)
+
+    @pyedb_function_handler
+    def set_heatsink(self, fin_base_height, fin_height, fin_orientation, fin_spacing, fin_thickness):
+        from pyedb.dotnet.edb_core.utilities.heatsink import HeatSink
+
+        heatsink = HeatSink(self._pedb)
+        heatsink.fin_base_height = fin_base_height
+        heatsink.fin_height = fin_height
+        heatsink.fin_orientation = fin_orientation
+        heatsink.fin_spacing = fin_spacing
+        heatsink.fin_thickness = fin_thickness
+        self._edb_object.SetHeatSink(heatsink._edb_object)
+
+    @property
+    def heatsink(self):
+        from pyedb.dotnet.edb_core.utilities.heatsink import HeatSink
+
+        flag, edb_object = self._edb_object.GetHeatSink()
+        if flag:
+            return HeatSink(self._pedb, edb_object)
+        else:
+            return None

pyedb/dotnet/edb_core/edb_data/components_data.py

@@ -24,7 +24,7 @@ import logging
 import re
 import warnings
 
-from pyedb.dotnet.edb_core.cell.hierarchy.model import PinPairModel
+from pyedb.dotnet.edb_core.cell.hierarchy.model import PinPairModel, SPICEModel
 from pyedb.dotnet.edb_core.definition.package_def import PackageDef
 from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
 from pyedb.generic.general_methods import is_ironpython
@@ -222,6 +222,8 @@ class EDBComponent(object):
         model_type = edb_object.ToString().split(".")[-1]
         if model_type == "PinPairModel":
             return PinPairModel(self._pedb, edb_object)
+        elif model_type == "SPICEModel":
+            return SPICEModel(self._pedb, edb_object)
 
     @model.setter
     def model(self, value):
@@ -373,7 +375,7 @@ class EDBComponent(object):
 
     @property
     def solder_ball_diameter(self):
-        """Solder ball diameter"""
+        """Solder ball diameter."""
         if "GetSolderBallProperty" in dir(self.component_property):
             result = self.component_property.GetSolderBallProperty().GetDiameter()
             succeed = result[0]
@@ -848,6 +850,7 @@ class EDBComponent(object):
     @property
     def is_top_mounted(self):
         """Check if a component is mounted on top or bottom of the layout.
+
         Returns
         -------
         bool
@@ -912,7 +915,7 @@ class EDBComponent(object):
         return True
 
     @pyedb_function_handler()
-    def assign_spice_model(self, file_path, name=None):
+    def assign_spice_model(self, file_path, name=None, sub_circuit_name=None):
         """Assign Spice model to this component.
 
         Parameters
@@ -940,6 +943,8 @@ class EDBComponent(object):
             model = self._edb.cell.hierarchy._hierarchy.SPICEModel()
             model.SetModelPath(file_path)
             model.SetModelName(name)
+            if sub_circuit_name:
+                model.SetSubCkt(sub_circuit_name)
             terminal = 1
             for pn in pinNames:
                 model.AddTerminalPinPair(pn, str(terminal))