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

pyedb/configuration/configuration.py

@@ -65,14 +65,16 @@ class Configuration:
         """
         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
+        else:
+            config_file = str(config_file)
+            if 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
 
         if not append:  # pragma: no cover
             self.data = {}
@@ -120,16 +122,13 @@ class Configuration:
             self.cfg_data.padstacks.apply()
 
         # Configure pin groups
-        for pin_group in self.cfg_data.pin_groups:
-            pin_group.apply()
+        self.cfg_data.pin_groups.apply()
 
         # Configure ports
-        for port in self.cfg_data.ports:
-            port.create()
+        self.cfg_data.ports.apply()
 
         # Configure sources
-        for source in self.cfg_data.sources:
-            source.create()
+        self.cfg_data.sources.apply()
 
         # Configure setup
         self.cfg_data.setups.apply()
@@ -271,12 +270,30 @@ class Configuration:
             data["package_definitions"] = self.cfg_data.package_definitions.get_data_from_db()
         if kwargs.get("setups", False):
             data["setups"] = self.cfg_data.setups.get_data_from_db()
+        if kwargs.get("sources", False):
+            data["sources"] = self.cfg_data.sources.get_data_from_db()
+        if kwargs.get("ports", False):
+            data["ports"] = self.cfg_data.ports.get_data_from_db()
         if kwargs.get("components", False):
             data["components"] = self.cfg_data.components.get_data_from_db()
+        if kwargs.get("nets", False):
+            data["nets"] = self.cfg_data.nets.get_data_from_db()
+        if kwargs.get("pin_groups", False):
+            data["pin_groups"] = self.cfg_data.pin_groups.get_data_from_db()
 
         return data
 
-    def export(self, file_path, stackup=True, package_definitions=True, setups=True):
+    def export(
+        self,
+        file_path,
+        stackup=True,
+        package_definitions=True,
+        setups=True,
+        sources=True,
+        ports=True,
+        nets=True,
+        pin_groups=True,
+    ):
         """Export the configuration data from layout to a file.
 
         Parameters
@@ -285,14 +302,31 @@ class Configuration:
             File path to export the configuration data.
         stackup : bool
             Whether to export stackup or not.
-
+        package_definitions : bool
+            Whether to export package definitions or not.
+        setups : bool
+            Whether to export setups or not.
+        sources : bool
+            Whether to export sources or not.
+        ports : bool
+            Whether to export ports or not.
+        nets : bool
+            Whether to export nets.
         Returns
         -------
         bool
         """
         file_path = file_path if isinstance(file_path, Path) else Path(file_path)
         file_path = file_path if file_path.suffix == ".json" else file_path.with_suffix(".json")
-        data = self.get_data_from_db(stackup=stackup, package_definitions=package_definitions, setups=setups)
+        data = self.get_data_from_db(
+            stackup=stackup,
+            package_definitions=package_definitions,
+            setups=setups,
+            sources=sources,
+            ports=ports,
+            nets=nets,
+            pin_groups=pin_groups,
+        )
         with open(file_path, "w") as f:
             json.dump(data, f, ensure_ascii=False, indent=4)
         return True if os.path.isfile(file_path) else False

pyedb/dotnet/edb.py

@@ -510,6 +510,7 @@ class Edb(Database):
     def sources(self):
         """Get all layout sources."""
         terms = [term for term in self.layout.terminals if int(term.GetBoundaryType()) in [3, 4, 7]]
+        terms = [term for term in terms if not term.IsReferenceTerminal()]
         return {ter.GetName(): ExcitationSources(self, ter) for ter in terms}
 
     @property
@@ -3743,7 +3744,7 @@ class Edb(Database):
         if float(self.edbversion) < 2024.2:
             self.logger.error("HFSSPI simulation only supported with Ansys release 2024R2 and higher")
             return False
-        return HFSSPISimulationSetup(self).create(name)
+        return HFSSPISimulationSetup(self, name=name)
 
     def create_siwave_syz_setup(self, name=None, **kwargs):
         """Create a setup from a template.

pyedb/dotnet/edb_core/cell/layout.py

@@ -23,9 +23,11 @@
 """
 This module contains these classes: `EdbLayout` and `Shape`.
 """
-
 from pyedb.dotnet.edb_core.cell.primitive import Bondwire
 from pyedb.dotnet.edb_core.edb_data.nets_data import EDBNetsData
+from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
+from pyedb.dotnet.edb_core.edb_data.sources import PinGroup
+from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 from pyedb.dotnet.edb_core.layout import EdbLayout
 
 
@@ -65,6 +67,11 @@ class Layout(EdbLayout):
             if i.GetPrimitiveType().ToString() == "Bondwire"
         ]
 
+    @property
+    def padstack_instances(self):
+        """Get all padstack instances in a list."""
+        return [EDBPadstackInstance(i, self._pedb) for i in self._edb_object.PadstackInstances]
+
     def create_bondwire(
         self,
         definition_name,
@@ -129,3 +136,43 @@ class Layout(EdbLayout):
             end_y=self._pedb.edb_value(end_y),
             net=self.nets[net]._edb_object,
         )
+
+    def find_object_by_id(self, value: int):
+        """Find a Connectable object by Database ID.
+
+        Parameters
+        ----------
+        value : int
+        """
+        obj = self._pedb._edb.Cell.Connectable.FindById(self._edb_object, value)
+        if obj.GetObjType().ToString() == "PadstackInstance":
+            return EDBPadstackInstance(obj, self._pedb)
+
+    def create_pin_group(self, name: str, pins_by_id: list[int] = None, pins_by_aedt_name: list[str] = None):
+        """Create a PinGroup.
+
+        Parameters
+        name : str,
+            Name of the PinGroup.
+        pins_by_id : list[int] or None
+            List of pins by ID.
+        pins_by_aedt_name : list[str] or None
+            List of pins by AEDT name.
+        """
+        pins = []
+
+        if pins_by_id is not None:
+            for p in pins_by_id:
+                pins.append(self.find_object_by_id(p._edb_object))
+        else:
+            p_inst = self.padstack_instances
+            while True:
+                p = p_inst.pop(0)
+                if p.aedt_name in pins_by_aedt_name:
+                    pins.append(p._edb_object)
+                    pins_by_aedt_name.remove(p.aedt_name)
+                if len(pins_by_aedt_name) == 0:
+                    break
+
+        obj = self._edb.cell.hierarchy.pin_group.Create(self._edb_object, name, convert_py_list_to_net_list(pins))
+        return PinGroup(name, obj, self._pedb)

pyedb/dotnet/edb_core/cell/terminal/padstack_instance_terminal.py

@@ -86,3 +86,13 @@ class PadstackInstanceTerminal(Terminal):
         terminal = PadstackInstanceTerminal(self._pedb, terminal)
 
         return terminal if not terminal.is_null else False
+
+    def _get_parameters(self):
+        """Gets the parameters of the padstack instance terminal."""
+        _, padstack_inst, layer_obj = self._edb_object.GetParameters()
+        return padstack_inst, layer_obj
+
+    @property
+    def padstack_instance(self):
+        p_inst, _ = self._get_parameters()
+        return self._pedb.modeler.find_object_by_id(p_inst.GetId())

pyedb/dotnet/edb_core/cell/terminal/pingroup_terminal.py

@@ -57,3 +57,8 @@ class PinGroupTerminal(Terminal):
         )
         term = PinGroupTerminal(self._pedb, term)
         return term if not term.is_null else False
+
+    def pin_group(self):
+        """Gets the pin group the terminal refers to."""
+        name = self._edb_object.GetPinGroup().GetName()
+        return self._pedb.siwave.pin_groups[name]

pyedb/dotnet/edb_core/cell/terminal/point_terminal.py

@@ -60,14 +60,3 @@ class PointTerminal(Terminal):
         )
         terminal = PointTerminal(self._pedb, terminal)
         return terminal if not terminal.is_null else False
-
-    @property
-    def ref_terminal(self):
-        """Get reference terminal."""
-
-        terminal = Terminal(self._pedb, self._edb_object.GetReferenceTerminal())
-        return terminal if not terminal.is_null else False
-
-    @ref_terminal.setter
-    def ref_terminal(self, value):
-        self._edb_object.SetReferenceTerminal(value._edb_object)

pyedb/dotnet/edb_core/cell/terminal/terminal.py

@@ -217,6 +217,21 @@ class Terminal(Connectable):
     def boundary_type(self, value):
         self._edb_object.SetBoundaryType(self._boundary_type_mapping[value])
 
+    @property
+    def is_port(self):
+        """Whether it is a port."""
+        return True if self.boundary_type == "PortBoundary" else False
+
+    @property
+    def is_current_source(self):
+        """Whether it is a current source."""
+        return True if self.boundary_type == "kCurrentSource" else False
+
+    @property
+    def is_voltage_source(self):
+        """Whether it is a voltage source."""
+        return True if self.boundary_type == "kVoltageSource" else False
+
     @property
     def impedance(self):
         """Impedance of the port."""
@@ -235,7 +250,8 @@ class Terminal(Connectable):
     def ref_terminal(self):
         """Get reference terminal."""
 
-        terminal = Terminal(self._pedb, self._edb_object.GetReferenceTerminal())
+        edb_terminal = self._edb_object.GetReferenceTerminal()
+        terminal = self._pedb.terminals[edb_terminal.GetName()]
         if not terminal.is_null:
             return terminal
 
@@ -444,3 +460,21 @@ class Terminal(Connectable):
                 pin_obj = pin
         if pin_obj:
             return EDBPadstackInstance(pin_obj, self._pedb)
+
+    @property
+    def magnitude(self):
+        """Get the magnitude of the source."""
+        return self._edb_object.GetSourceAmplitude().ToDouble()
+
+    @magnitude.setter
+    def magnitude(self, value):
+        self._edb_object.SetSourceAmplitude(self._edb.utility.value(value))
+
+    @property
+    def phase(self):
+        """Get the phase of the source."""
+        return self._edb_object.GetSourcePhase().ToDouble()
+
+    @phase.setter
+    def phase(self, value):
+        self._edb_object.SetSourcePhase(self._edb.utility.value(value))

pyedb/dotnet/edb_core/components.py

@@ -766,20 +766,44 @@ class Components(object):
         >>> edb.close_edb()
         """
 
-        if isinstance(pins, str) or isinstance(pins, EDBPadstackInstance):
+        if isinstance(pins, str):
             pins = [pins]
+        elif isinstance(pins, EDBPadstackInstance):
+            pins = [pins.name]
         if isinstance(reference_pins, str):
             reference_pins = [reference_pins]
-        if isinstance(refdes, str) or isinstance(refdes, EDBComponent):
+        if isinstance(reference_pins, list):
+            _temp = []
+            for ref_pin in reference_pins:
+                if isinstance(ref_pin, int):
+                    if ref_pin in self._padstack.instances:
+                        _temp.append(self._padstack.instances[ref_pin])
+                elif isinstance(ref_pin, str):
+                    if ref_pin in self.instances[refdes].pins:
+                        _temp.append(self.instances[refdes].pins[ref_pin])
+                    else:
+                        p = [pp for pp in list(self._padstack.instances.values()) if pp.name == ref_pin]
+                        if p:
+                            _temp.append(p)
+                elif isinstance(ref_pin, EDBPadstackInstance):
+                    _temp.append(ref_pin.name)
+            reference_pins = _temp
+        elif isinstance(reference_pins, int):
+            if reference_pins in self._padstack.instances:
+                reference_pins = self._padstack.instances[reference_pins]
+        if isinstance(refdes, str):
             refdes = self.instances[refdes]
+        elif isinstance(refdes, self._pedb._edb.Cell.Hierarchy.Component):
+            refdes = EDBComponent(self._pedb, refdes)
+        refdes_pins = refdes.pins
         if any(refdes.rlc_values):
             return self.deactivate_rlc_component(component=refdes, create_circuit_port=True)
         if len([pin for pin in pins if isinstance(pin, str)]) == len(pins):
             cmp_pins = []
             for pin_name in pins:
-                cmp_pin = [pin for pin in list(refdes.pins.values()) if pin_name == pin.name]
+                cmp_pin = [pin for pin in list(refdes_pins.values()) if pin_name == pin.name]
                 if not cmp_pin:
-                    cmp_pin = [pin for pin in list(refdes.pins.values()) if pin_name == pin.name.split("-")[1]]
+                    cmp_pin = [pin for pin in list(refdes_pins.values()) if pin_name == pin.name.split("-")[1]]
                 if cmp_pin:
                     cmp_pins.append(cmp_pin[0])
             if not cmp_pins:
@@ -793,15 +817,15 @@ class Components(object):
         if len([pin for pin in reference_pins if isinstance(pin, str)]) == len(reference_pins):
             ref_cmp_pins = []
             for ref_pin_name in reference_pins:
-                cmp_ref_pin = [pin for pin in list(refdes.pins.values()) if ref_pin_name == pin.name]
-                if not cmp_ref_pin:
-                    cmp_ref_pin = [pin for pin in list(refdes.pins.values()) if ref_pin_name == pin.name.split("-")[1]]
-                if cmp_ref_pin:
-                    ref_cmp_pins.append(cmp_ref_pin[0])
+                if ref_pin_name in refdes_pins:
+                    ref_cmp_pins.append(refdes_pins[ref_pin_name])
+                elif "-" in ref_pin_name and ref_pin_name.split("-")[1] in refdes_pins:
+                    ref_cmp_pins.append(refdes_pins[ref_pin_name.split("-")[1]])
             if not ref_cmp_pins:
                 return
             reference_pins = ref_cmp_pins
-        if not len([pin for pin in reference_pins if isinstance(pin, EDBPadstackInstance)]) == len(reference_pins):
+        if not reference_pins:
+            self._logger.error("No reference pins found.")
             return
         if len(pins) > 1:
             pec_boundary = False
@@ -883,7 +907,7 @@ class Components(object):
         solder_balls_size : float, optional
             Solder balls diameter. When provided auto evaluation based on padstack size will be disabled.
         solder_balls_mid_size : float, optional
-            Solder balls mid diameter. When provided if value is different than solder balls size, spheroid shape will
+            Solder balls mid-diameter. When provided if value is different than solder balls size, spheroid shape will
             be switched.
 
         Returns
@@ -904,11 +928,11 @@ class Components(object):
         if isinstance(component, str):
             component = self.instances[component].edbcomponent
         if not solder_balls_height:
-            solder_balls_height = self.components[component.GetName()].solder_ball_height
+            solder_balls_height = self.instances[component.GetName()].solder_ball_height
         if not solder_balls_size:
-            solder_balls_size = self.components[component.GetName()].solder_ball_diameter[0]
+            solder_balls_size = self.instances[component.GetName()].solder_ball_diameter[0]
         if not solder_balls_mid_size:
-            solder_balls_mid_size = self.components[component.GetName()].solder_ball_diameter[1]
+            solder_balls_mid_size = self.instances[component.GetName()].solder_ball_diameter[1]
         if not isinstance(net_list, list):
             net_list = [net_list]
         for net in net_list:
@@ -934,6 +958,18 @@ class Components(object):
             return False
         pin_layers = cmp_pins[0].GetPadstackDef().GetData().GetLayerNames()
         if port_type == SourceType.CoaxPort:
+            ref_pins = [
+                p
+                for p in list(component.LayoutObjs)
+                if int(p.GetObjType()) == 1 and p.GetNet().GetName() in reference_net
+            ]
+            if not ref_pins:
+                self._logger.error(
+                    "No reference pins found on component. You might consider"
+                    "using Circuit port instead since reference pins can be extended"
+                    "outside the component automatically when not found."
+                )
+                return False
             pad_params = self._padstack.get_pad_parameters(pin=cmp_pins[0], layername=pin_layers[0], pad_type=0)
             if not pad_params[0] == 7:
                 if not solder_balls_size:  # pragma no cover
@@ -981,17 +1017,25 @@ class Components(object):
             for p in ref_pins:
                 if not p.IsLayoutPin():
                     p.SetIsLayoutPin(True)
-            if len(ref_pins) == 0:
-                self._logger.info("No reference pin found on component {}.".format(component.GetName()))
+            if not ref_pins:
+                self._logger.warning("No reference pins found on component, the closest pin will be selected.")
+                do_pingroup = False
             if do_pingroup:
                 if len(ref_pins) == 1:
+                    ref_pins.is_pin = True
                     ref_pin_group_term = self._create_terminal(ref_pins[0])
                 else:
+                    for pin in ref_pins:
+                        pin.is_pin = True
                     ref_pin_group = self.create_pingroup_from_pins(ref_pins)
                     if not ref_pin_group:
+                        self._logger.error(f"Failed to create reference pin group on component {component.GetName()}.")
                         return False
-                    ref_pin_group_term = self._create_pin_group_terminal(ref_pin_group, isref=True)
+                    ref_pin_group_term = self._create_pin_group_terminal(ref_pin_group, isref=False)
                     if not ref_pin_group_term:
+                        self._logger.error(
+                            f"Failed to create reference pin group terminal on component {component.GetName()}"
+                        )
                         return False
                 for net in net_list:
                     pins = [pin for pin in cmp_pins if pin.GetNet().GetName() == net]
@@ -1013,7 +1057,19 @@ class Components(object):
                 for net in net_list:
                     pins = [pin for pin in cmp_pins if pin.GetNet().GetName() == net]
                     for pin in pins:
-                        self.create_port_on_pins(component, pin, ref_pins)
+                        if ref_pins:
+                            self.create_port_on_pins(component, pin, ref_pins)
+                        else:
+                            _pin = EDBPadstackInstance(pin, self._pedb)
+                            ref_pin = _pin.get_reference_pins(
+                                reference_net=reference_net[0], max_limit=1, component_only=False, search_radius=3e-3
+                            )
+                            if ref_pin:
+                                self.create_port_on_pins(
+                                    component,
+                                    [EDBPadstackInstance(pin, self._pedb).name],
+                                    [EDBPadstackInstance(ref_pin[0], self._pedb).id],
+                                )
         return True
 
     def _create_terminal(self, pin, term_name=None):

pyedb/dotnet/edb_core/dotnet/primitive.py

@@ -837,9 +837,8 @@ class PathDotNet(PrimitiveDotNet):
             net = net.api_object
         width = self._app.edb_api.utility.value(width)
         if isinstance(points, list):
-            points = self._app.edb_api.geometry.polygon_data.api_class(
-                convert_py_list_to_net_list([self._app.geometry.point_data(i) for i in points]), False
-            )
+            points = convert_py_list_to_net_list([self._app.point_data(i[0], i[1]) for i in points])
+            points = self._app.edb_api.geometry.polygon_data.dotnetobj(points)
         return PathDotNet(
             self._app, self.api.Path.Create(layout, layer, net, width, end_cap1, end_cap2, corner_style, points)
         )
@@ -847,11 +846,15 @@ class PathDotNet(PrimitiveDotNet):
     @property
     def center_line(self):
         """:class:`PolygonData <ansys.edb.geometry.PolygonData>`: Center line for this Path."""
-        return self.prim_obj.GetCenterLine()
+        edb_center_line = self.prim_obj.GetCenterLine()
+        return [[pt.X.ToDouble(), pt.Y.ToDouble()] for pt in list(edb_center_line.Points)]
 
     @center_line.setter
-    def center_line(self, center_line):
-        self.prim_obj.SetCenterLineMessage(center_line)
+    def center_line(self, value):
+        if isinstance(value, list):
+            points = [self._pedb.point_data(i[0], i[1]) for i in value]
+            polygon_data = self._edb.geometry.polygon_data.dotnetobj(convert_py_list_to_net_list(points), False)
+            self.prim_obj.SetCenterLine(polygon_data)
 
     @property
     def end_cap_style(self):

pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -1678,11 +1678,9 @@ class EDBPadstackInstance(Primitive):
     def name(self):
         """Padstack Instance Name. If it is a pin, the syntax will be like in AEDT ComponentName-PinName."""
         if self.is_pin:
-            comp_name = self._edb_padstackinstance.GetComponent().GetName()
-            pin_name = self._edb_padstackinstance.GetName()
-            return "-".join([comp_name, pin_name])
+            return self.aedt_name
         else:
-            return self._edb_padstackinstance.GetName()
+            return self.component_pin
 
     @name.setter
     def name(self, value):
@@ -1725,6 +1723,12 @@ class EDBPadstackInstance(Primitive):
     @property
     def pin_number(self):
         """Get pin number."""
+        warnings.warn("`pin_number` is deprecated. Use `component_pin` method instead.", DeprecationWarning)
+        return self.component_pin
+
+    @property
+    def component_pin(self):
+        """Get component pin."""
         return self._edb_padstackinstance.GetName()
 
     @property

pyedb/dotnet/edb_core/edb_data/ports.py

@@ -198,24 +198,6 @@ class ExcitationSources(Terminal):
     def __init__(self, pedb, edb_terminal):
         Terminal.__init__(self, pedb, edb_terminal)
 
-    @property
-    def magnitude(self):
-        """Get the magnitude of the source."""
-        return self._edb_object.GetSourceAmplitude().ToDouble()
-
-    @magnitude.setter
-    def magnitude(self, value):
-        self._edb_object.SetSourceAmplitude(self._edb.utility.value(value))
-
-    @property
-    def phase(self):
-        """Get the phase of the source."""
-        return self._edb_object.GetSourcePhase().ToDouble()
-
-    @phase.setter
-    def phase(self, value):
-        self._edb_object.SetSourcePhase(self._edb.utility.value(value))
-
 
 class BundleWavePort(BundleTerminal):
     """Manages bundle wave port properties.

pyedb/dotnet/edb_core/edb_data/primitives_data.py

@@ -631,7 +631,7 @@ class EdbPath(EDBPrimitives, PathDotNet):
         float
             Path length in meters.
         """
-        center_line_arcs = list(self.center_line.GetArcData())
+        center_line_arcs = list(self.api_object.GetCenterLine().GetArcData())
         path_length = 0.0
         for arc in center_line_arcs:
             path_length += arc.GetLength()

pyedb/dotnet/edb_core/padstack.py

@@ -241,6 +241,15 @@ class EdbPadstacks(object):
                 )
         return padstack_instances
 
+    def find_instance_by_id(self, value: int):
+        """Find a padstack instance by database id.
+
+        Parameters
+        ----------
+        value : int
+        """
+        return self._pedb.modeler.find_object_by_id(value)
+
     @property
     def pins(self):
         """Dictionary  of all pins instances (belonging to component).
@@ -1441,7 +1450,7 @@ class EdbPadstacks(object):
                 instances = [inst for inst in instances if inst.component.refdes in refdes]
                 if component_pin:
                     component_pin = component_pin if isinstance(component_pin, list) else [component_pin]
-                    instances = [inst for inst in instances if inst.pin_number in component_pin]
+                    instances = [inst for inst in instances if inst.component_pin in component_pin]
             return instances
 
     def get_padstack_instance_by_net_name(self, net_name):

pyedb/dotnet/edb_core/sim_setup_data/data/sim_setup_info.py

@@ -20,6 +20,9 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from pyedb.dotnet.edb_core.sim_setup_data.data.simulation_settings import (  # HFSSSimulationSettings
+    HFSSPISimulationSettings,
+)
 from pyedb.dotnet.edb_core.sim_setup_data.data.sweep_data import SweepData
 
 
@@ -58,17 +61,53 @@ class SimSetupInfo:
         else:
             self._edb_object = edb_object
 
+    @property
+    def name(self):
+        return self._edb_object.Name
+
+    @name.setter
+    def name(self, name):
+        self._edb_object.Name = name
+
     @property
     def position(self):
         return self._edb_object.Position
 
     @property
     def sim_setup_type(self):
-        return self._edb_object.SimSetupType
+        """
+        "kHFSS": self._pedb.simsetupdata.HFSSSimulationSettings,
+        "kPEM": None,
+        "kSIwave": self._pedb.simsetupdata.SIwave.SIWSimulationSettings,
+        "kLNA": None,
+        "kTransient": None,
+        "kQEye": None,
+        "kVEye": None,
+        "kAMI": None,
+        "kAnalysisOption": None,
+        "kSIwaveDCIR": self._pedb.simsetupdata.SIwave.SIWDCIRSimulationSettings,
+        "kSIwaveEMI": None,
+        "kHFSSPI": self._pedb.simsetupdata.HFSSPISimulationSettings,
+        "kDDRwizard": None,
+        "kQ3D": None,
+        "kNumSetupTypes": None,
+        """
+
+        return self._edb_object.SimSetupType.ToString()
 
     @property
     def simulation_settings(self):
-        return self._edb_object.SimulationSettings
+        if self.sim_setup_type == "kHFSS":
+            return self._edb_object.SimulationSettings
+            # todo refactor HFSS
+            # return HFSSSimulationSettings(self._pedb, self.sim_setup, self._edb_object.SimulationSettings)
+        elif self.sim_setup_type == "kHFSSPI":
+            return HFSSPISimulationSettings(self._pedb, self.sim_setup, self._edb_object.SimulationSettings)
+        elif self.sim_setup_type == "kSIwave":  # todo refactor
+            return self._edb_object.SimulationSettings
+
+        elif self.sim_setup_type == "kSIwaveDCIR":  # todo refactor
+            return self._edb_object.SimulationSettings
 
     @property
     def sweep_data_list(self):
@@ -77,5 +116,5 @@ class SimSetupInfo:
         ]
 
     def add_sweep_data(self, sweep_data):
-        sweep_data.sim_setup = self.sim_setup
+        sweep_data._sim_setup = self.sim_setup
         self._edb_object.SweepDataList.Add(sweep_data._edb_object)