pyedb 0.52.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

pyedb/grpc/edb.py

@@ -70,6 +70,9 @@ import warnings
 from zipfile import ZipFile as zpf
 
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
+from ansys.edb.core.hierarchy.layout_component import (
+    LayoutComponent as GrpcLayoutComponent,
+)
 import ansys.edb.core.layout.cell
 from ansys.edb.core.simulation_setup.siwave_dcir_simulation_setup import (
     SIWaveDCIRSimulationSetup as GrpcSIWaveDCIRSimulationSetup,
@@ -111,6 +114,9 @@ from pyedb.grpc.database.simulation_setup.hfss_simulation_setup import (
 from pyedb.grpc.database.simulation_setup.raptor_x_simulation_setup import (
     RaptorXSimulationSetup,
 )
+from pyedb.grpc.database.simulation_setup.siwave_cpa_simulation_setup import (
+    SIWaveCPASimulationSetup,
+)
 from pyedb.grpc.database.simulation_setup.siwave_dcir_simulation_setup import (
     SIWaveDCIRSimulationSetup,
 )
@@ -125,6 +131,7 @@ from pyedb.grpc.database.terminal.padstack_instance_terminal import (
 )
 from pyedb.grpc.database.terminal.terminal import Terminal
 from pyedb.grpc.database.utility.constants import get_terminal_supported_boundary_types
+from pyedb.grpc.database.utility.value import Value
 from pyedb.grpc.edb_init import EdbInit
 from pyedb.ipc2581.ipc2581 import Ipc2581
 from pyedb.modeler.geometry_operators import GeometryOperators
@@ -196,14 +203,13 @@ class Edb(EdbInit):
         edbversion: str = None,
         isaedtowned: bool = False,
         oproject=None,
-        student_version: bool = False,
         use_ppe: bool = False,
         control_file: str = None,
         map_file: str = None,
         technology_file: str = None,
         layer_filter: str = None,
-        remove_existing_aedt: bool = False,
         restart_rpc_server=False,
+        **kwargs,
     ):
         edbversion = get_string_version(edbversion)
         self._clean_variables()
@@ -285,13 +291,13 @@ class Edb(EdbInit):
                 return False
         elif edbpath.endswith("edb.def"):
             self.edbpath = os.path.dirname(edbpath)
-            self.open_edb(restart_rpc_server=restart_rpc_server)
+            self.open(restart_rpc_server=restart_rpc_server)
         elif not os.path.exists(os.path.join(self.edbpath, "edb.def")):
-            self.create_edb(restart_rpc_server=restart_rpc_server)
+            self.create(restart_rpc_server=restart_rpc_server)
             self.logger.info("EDB %s created correctly.", self.edbpath)
         elif ".aedb" in edbpath:
             self.edbpath = edbpath
-            self.open_edb(restart_rpc_server=restart_rpc_server)
+            self.open(restart_rpc_server=restart_rpc_server)
         if self.active_cell:
             self.logger.info("EDB initialized.")
         else:
@@ -360,6 +366,11 @@ class Edb(EdbInit):
         if description:  # Add the variable description if a two-item list is passed for variable_value.
             self.__getitem__(variable_name).description = description
 
+    @property
+    def core(self) -> ansys.edb.core:
+        """Ansys Edb Core module."""
+        return ansys.edb.core
+
     def _check_remove_project_files(self, edbpath: str, remove_existing_aedt: bool) -> None:
         aedt_file = os.path.splitext(edbpath)[0] + ".aedt"
         files = [aedt_file, aedt_file + ".lock"]
@@ -391,6 +402,14 @@ class Edb(EdbInit):
         self._differential_pairs = DifferentialPairs(self)
         self._extended_nets = ExtendedNets(self)
 
+    def value(self, val):
+        """Convert a value into a pyedb value."""
+        if isinstance(val, GrpcValue):
+            return Value(val)
+        else:
+            context = self.active_cell if not str(val).startswith("$") else self.active_db
+            return Value(GrpcValue(val, context), context)
+
     @property
     def cell_names(self) -> [str]:
         """List of all cell names in the database.
@@ -411,7 +430,7 @@ class Edb(EdbInit):
         dict[str, float]
             Variable names and values.
         """
-        return {i: self.active_cell.get_variable_value(i).value for i in self.active_cell.get_all_variable_names()}
+        return {i: Value(self.active_cell.get_variable_value(i)) for i in self.active_cell.get_all_variable_names()}
 
     @property
     def project_variables(self) -> dict[str, float]:
@@ -422,7 +441,7 @@ class Edb(EdbInit):
         dict[str, float]
             Variable names and values.
         """
-        return {i: self.active_db.get_variable_value(i).value for i in self.active_db.get_all_variable_names()}
+        return {i: Value(self.active_db.get_variable_value(i)) for i in self.active_db.get_all_variable_names()}
 
     @property
     def layout_validation(self) -> LayoutValidation:
@@ -533,7 +552,11 @@ class Edb(EdbInit):
         dict[str, :class:`Terminal <pyedb.grpc.database.terminal.terminal.Terminal>`]
             Source names and objects.
         """
-        return self.terminals
+        return {
+            k: i
+            for k, i in self.terminals.items()
+            if "source" in i.boundary_type or "terminal" in i.boundary_type or i.is_reference_terminal
+        }
 
     @property
     def voltage_regulator_modules(self):
@@ -559,7 +582,7 @@ class Edb(EdbInit):
         dict[str, :class:`Terminal <pyedb.grpc.database.terminal.terminal.Terminal>`]
             Probe names and objects.
         """
-        terms = [term for term in self.layout.terminals if term.boundary_type.value == 8]
+        terms = [term for term in self.layout.terminals if term.boundary_type == "voltage_probe"]
         return {ter.name: ter for ter in terms}
 
     def open(self, restart_rpc_server=False) -> bool:
@@ -1279,7 +1302,7 @@ class Edb(EdbInit):
         func : str
             Command to execute.
         """
-        # return self.edb_api.utility.utility.Command.Execute(func)
+        # return self.core.utility.utility.Command.Execute(func)
         pass
 
     def import_cadence_file(self, inputBrd, WorkDir=None, anstranslator_full_path="", use_ppe=False) -> bool:
@@ -1553,7 +1576,7 @@ class Edb(EdbInit):
         for term in terms:
             if term.type == "PointTerminal" and term.net.name in reference_list:
                 pd = term.get_parameters()[1]
-                locations.append([pd.x.value, pd.y.value])
+                locations.append([Value(pd.x), Value(pd.y)])
         for point in locations:
             pointA = GrpcPointData([point[0] - expansion_size, point[1] - expansion_size])
             pointB = GrpcPointData([point[0] + expansion_size, point[1] + expansion_size])
@@ -1821,7 +1844,7 @@ class Edb(EdbInit):
         include_pingroups=True,
         inlcude_voids_in_extents=False,
     ):
-        expansion_size = GrpcValue(expansion_size).value
+        expansion_size = Value(expansion_size)
 
         # validate nets in layout
         net_signals = [net for net in self.layout.nets if net.name in signal_list]
@@ -1904,7 +1927,7 @@ class Edb(EdbInit):
                 self.components.delete_single_pin_rlc()
                 self.logger.info_timer("Single Pins components deleted")
                 self.components.refresh_components()
-        return [[pt.x.value, pt.y.value] for pt in _poly.without_arcs().points]
+        return [[Value(pt.x), Value(pt.y)] for pt in _poly.without_arcs().points]
 
     def _create_cutout_multithread(
         self,
@@ -1933,7 +1956,7 @@ class Edb(EdbInit):
         if output_aedb_path:
             self.save_edb_as(output_aedb_path)
         self.logger.info("Cutout Multithread started.")
-        expansion_size = GrpcValue(expansion_size).value
+        expansion_size = Value(expansion_size)
 
         timer_start = self.logger.reset_timer()
         if custom_extent:
@@ -1977,17 +2000,20 @@ class Edb(EdbInit):
         reference_pinsts = []
         reference_prims = []
         reference_paths = []
+        delete_list = []
         for i in self.padstacks.instances.values():
             net_name = i.net_name
             id = i.id
             if net_name not in all_list and id not in pins_to_preserve:
-                i.delete()
+                delete_list.append(i)
+                # i.delete()
             elif net_name in reference_list and id not in pins_to_preserve:
                 reference_pinsts.append(i)
         for i in self.modeler.primitives:
             if not i.is_null and not i.net.is_null:
                 if i.net.name not in all_list:
-                    i.delete()
+                    # i.delete()
+                    delete_list.append(i)
                 elif i.net.name in reference_list and not i.is_void:
                     if keep_lines_as_path and isinstance(i, Path):
                         reference_paths.append(i)
@@ -1995,7 +2021,8 @@ class Edb(EdbInit):
                         reference_prims.append(i)
         self.logger.info_timer("Net clean up")
         self.logger.reset_timer()
-
+        for i in delete_list:
+            i.delete()
         if custom_extent and isinstance(custom_extent, list):
             if custom_extent[0] != custom_extent[-1]:
                 custom_extent.append(custom_extent[0])
@@ -2027,7 +2054,7 @@ class Edb(EdbInit):
                 ExtentType as GrpcExtentType,
             )
 
-            if extent_type in ["Conforming", GrpcExtentType.CONFORMING, 1]:
+            if extent_type in ["Conformal", "Conforming", GrpcExtentType.CONFORMING, 1]:
                 if extent_defeature > 0:
                     _poly = _poly.defeature(extent_defeature)
                 _poly1 = GrpcPolygonData(arcs=_poly.arc_data, closed=True)
@@ -2150,7 +2177,7 @@ class Edb(EdbInit):
             self.save_edb()
         self.logger.info_timer("Cutout completed.", timer_start)
         self.logger.reset_timer()
-        return [[pt.x.value, pt.y.value] for pt in _poly.without_arcs().points]
+        return [[Value(pt.x), Value(pt.y)] for pt in _poly.without_arcs().points]
 
     def get_conformal_polygon_from_netlist(self, netlist=None) -> Union[bool, Polygon]:
         """Returns conformal polygon data based on a netlist.
@@ -2276,7 +2303,7 @@ class Edb(EdbInit):
             for p in p_missing:
                 position = GrpcPointData(p.position)
                 net = self.nets.find_or_create_net(p.net_name)
-                rotation = GrpcValue(p.rotation)
+                rotation = Value(p.rotation)
                 sign_layers = list(self.stackup.signal_layers.keys())
                 if not p.start_layer:  # pragma: no cover
                     fromlayer = self.stackup.signal_layers[sign_layers[0]]
@@ -2368,7 +2395,7 @@ class Edb(EdbInit):
                         self.logger.warning("aedb def file manually created.")
                     except:
                         pass
-        return [[pt.x.value, pt.y.value] for pt in polygon_data.without_arcs().points]
+        return [[Value(pt.x), Value(pt.y)] for pt in polygon_data.without_arcs().points]
 
     @staticmethod
     def write_export3d_option_config_file(path_to_output, config_dictionaries=None):
@@ -2651,12 +2678,12 @@ class Edb(EdbInit):
             Variable value if exists, else False.
         """
         if self.variable_exists(variable_name):
-            if "$" in variable_name:
-                if variable_name.index("$") == 0:
-                    variable = next(var for var in self.active_db.get_all_variable_names())
-                else:
-                    variable = next(var for var in self.active_cell.get_all_variable_names())
+            if variable_name.startswith("$"):
+                variable = next(var for var in self.active_db.get_all_variable_names())
                 return self.db.get_variable_value(variable)
+            else:
+                variable = next(var for var in self.active_cell.get_all_variable_names())
+                return self.active_cell.get_variable_value(variable)
         self.logger.info(f"Variable {variable_name} doesn't exists.")
         return False
 
@@ -2730,11 +2757,11 @@ class Edb(EdbInit):
         """
         if self.variable_exists(variable_name):
             if variable_name in self.db.get_all_variable_names():
-                self.db.set_variable_value(variable_name, GrpcValue(variable_value))
+                self.db.set_variable_value(variable_name, Value(variable_value))
             elif variable_name in self.active_cell.get_all_variable_names():
-                self.active_cell.set_variable_value(variable_name, GrpcValue(variable_value))
+                self.active_cell.set_variable_value(variable_name, Value(variable_value))
 
-    def get_bounding_box(self) -> list[list[float, float], list[float, float]]:
+    def get_bounding_box(self) -> tuple[tuple[float, float], tuple[float, float]]:
         """Get layout bounding box.
 
         Returns
@@ -2744,7 +2771,7 @@ class Edb(EdbInit):
         """
         lay_inst_polygon_data = [obj_inst.get_bbox() for obj_inst in self.layout_instance.query_layout_obj_instances()]
         layout_bbox = GrpcPolygonData.bbox_of_polygons(lay_inst_polygon_data)
-        return [[layout_bbox[0].x.value, layout_bbox[0].y.value], [layout_bbox[1].x.value, layout_bbox[1].y.value]]
+        return ((Value(layout_bbox[0].x), Value(layout_bbox[0].y)), (Value(layout_bbox[1].x), Value(layout_bbox[1].y)))
 
     def get_statistics(self, compute_area=False):
         """Get layout statistics.
@@ -2838,7 +2865,16 @@ class Edb(EdbInit):
     @property
     def setups(
         self,
-    ) -> Union[HfssSimulationSetup, SiwaveSimulationSetup, SIWaveDCIRSimulationSetup, RaptorXSimulationSetup]:
+    ) -> dict[
+        str,
+        Union[
+            HfssSimulationSetup,
+            SiwaveSimulationSetup,
+            SIWaveDCIRSimulationSetup,
+            RaptorXSimulationSetup,
+            SIWaveCPASimulationSetup,
+        ],
+    ]:
         """Get the dictionary of all EDB HFSS and SIwave setups.
 
         Returns
@@ -2847,21 +2883,34 @@ class Edb(EdbInit):
         Dict[str,:class:`SiwaveSimulationSetup`] or
         Dict[str,:class:`SIWaveDCIRSimulationSetup`] or
         Dict[str,:class:`RaptorXSimulationSetup`]
+        Dict[str,:class:`SIWaveCPASimulationSetup`]
 
         """
-        self._setups = {}
+        from ansys.edb.core.database import ProductIdType as GrpcProductIdType
+
+        from pyedb.siwave_core.product_properties import SIwaveProperties
+
+        setups = {}
         for setup in self.active_cell.simulation_setups:
             setup = setup.cast()
             setup_type = setup.type.name
             if setup_type == "HFSS":
-                self._setups[setup.name] = HfssSimulationSetup(self, setup)
+                setups[setup.name] = HfssSimulationSetup(self, setup)
             elif setup_type == "SI_WAVE":
-                self._setups[setup.name] = SiwaveSimulationSetup(self, setup)
+                setups[setup.name] = SiwaveSimulationSetup(self, setup)
             elif setup_type == "SI_WAVE_DCIR":
-                self._setups[setup.name] = SIWaveDCIRSimulationSetup(self, setup)
+                setups[setup.name] = SIWaveDCIRSimulationSetup(self, setup)
             elif setup_type == "RAPTOR_X":
-                self._setups[setup.name] = RaptorXSimulationSetup(self, setup)
-        return self._setups
+                setups[setup.name] = RaptorXSimulationSetup(self, setup)
+        try:
+            cpa_setup_name = self.active_cell.get_product_property(
+                GrpcProductIdType.SIWAVE, SIwaveProperties.CPA_SIM_NAME
+            ).value
+        except:
+            cpa_setup_name = ""
+        if cpa_setup_name:
+            setups[cpa_setup_name] = SIWaveCPASimulationSetup(self, cpa_setup_name)
+        return setups
 
     @property
     def hfss_setups(self) -> dict[str, HfssSimulationSetup]:
@@ -3409,7 +3458,7 @@ class Edb(EdbInit):
                 _layers = {k: v for k, v in self.stackup.layers.items() if k in layer_filter}
             for layer_name, layer in _layers.items():
                 var, val = _apply_variable(f"${layer_name}", layer.thickness)
-                layer.thickness = GrpcValue(var, self.active_db)
+                layer.thickness = Value(var, self.active_db)
                 parameters.append(val)
         if materials:
             if not material_filter:
@@ -3419,14 +3468,14 @@ class Edb(EdbInit):
             for mat_name, material in _materials.items():
                 if not material.conductivity or material.conductivity < 1e4:
                     var, val = _apply_variable(f"$epsr_{mat_name}", material.permittivity)
-                    material.permittivity = GrpcValue(var, self.active_db)
+                    material.permittivity = Value(var, self.active_db)
                     parameters.append(val)
                     var, val = _apply_variable(f"$loss_tangent_{mat_name}", material.dielectric_loss_tangent)
-                    material.dielectric_loss_tangent = GrpcValue(var, self.active_db)
+                    material.dielectric_loss_tangent = Value(var, self.active_db)
                     parameters.append(val)
                 else:
                     var, val = _apply_variable(f"$sigma_{mat_name}", material.conductivity)
-                    material.conductivity = GrpcValue(var, self.active_db)
+                    material.conductivity = Value(var, self.active_db)
                     parameters.append(val)
         if traces:
             if not trace_net_filter:
@@ -3442,7 +3491,7 @@ class Edb(EdbInit):
                 else:
                     trace_width_variable = f"{path.aedt_name}"
                 var, val = _apply_variable(trace_width_variable, path.width)
-                path.width = GrpcValue(var, self.active_cell)
+                path.width = Value(var, self.active_cell)
                 parameters.append(val)
         if not padstack_definition_filter:
             if trace_net_filter:
@@ -3469,7 +3518,7 @@ class Edb(EdbInit):
                         hole_variable = f"${def_name}_hole_diameter"
                     if padstack_def.hole_diameter:
                         var, val = _apply_variable(hole_variable, padstack_def.hole_diameter)
-                        padstack_def.hole_properties = GrpcValue(var, self.active_db)
+                        padstack_def.hole_properties = Value(var, self.active_db)
                         parameters.append(val)
             if pads:
                 for layer, pad in padstack_def.pad_by_layer.items():
@@ -3684,7 +3733,7 @@ class Edb(EdbInit):
             material="pec",
         )
         if launching_box_thickness:
-            launching_box_thickness = str(GrpcValue(launching_box_thickness))
+            launching_box_thickness = str(Value(launching_box_thickness))
         cloned_edb.stackup.add_layer(
             layer_name="ref",
             layer_type="signal",
@@ -3719,7 +3768,7 @@ class Edb(EdbInit):
                         .parameters_values
                     )
                 else:
-                    pad_diameter = GrpcValue(terminal_diameter).value
+                    pad_diameter = Value(terminal_diameter)
                 _temp_circle = cloned_edb.modeler.create_circle(
                     layer_name="ports",
                     x=inst.position[0],
@@ -3834,3 +3883,38 @@ class Edb(EdbInit):
         else:
             self.logger.info("Comparison correctly completed")
             return True
+
+    def import_layout_component(self, component_path) -> GrpcLayoutComponent:
+        """Import a layout component inside the current layout and place it at the origin.
+        This feature is only supported with PyEDB gRPC. Encryption is not yet supported.
+
+        Parameters
+        ----------
+        component_path : str
+            Layout component path (.aedbcomp file).
+
+        Returns
+        -------
+            class:`LayoutComponent <ansys.edb.core.hierarchy.layout_component.LayoutComponent>`.
+        """
+
+        return GrpcLayoutComponent.import_layout_component(layout=self.active_layout, aedb_comp_path=component_path)
+
+    def export_layout_component(self, component_path) -> bool:
+        """Export a layout component from the current layout.
+        This feature is only supported with PyEDB gRPC. Encryption is not yet supported.
+
+        Parameters
+        ----------
+        component_path : str
+            Layout component path (.aedbcomp file).
+
+        Returns
+        -------
+        bool
+            `True` if layout component is successfully exported, `False` otherwise.
+        """
+
+        return GrpcLayoutComponent.export_layout_component(
+            layout=self.active_layout, output_aedb_comp_path=component_path
+        )

pyedb/grpc/edb_init.py

@@ -34,7 +34,6 @@ from pyedb import __version__
 from pyedb.edb_logger import pyedb_logger
 from pyedb.generic.general_methods import env_path, env_value, is_linux
 from pyedb.grpc.rpc_session import RpcSession
-from pyedb.misc.misc import list_installed_ansysem
 
 
 class EdbInit(object):
@@ -43,12 +42,6 @@ class EdbInit(object):
     def __init__(self, edbversion):
         self.logger = pyedb_logger
         self._db = None
-        if not edbversion:  # pragma: no cover
-            try:
-                edbversion = "20{}.{}".format(list_installed_ansysem()[0][-3:-1], list_installed_ansysem()[0][-1:])
-                self.logger.info("Edb version " + edbversion)
-            except IndexError:
-                raise Exception("No ANSYSEM_ROOTxxx is found.")
         self.edbversion = edbversion
         self.logger.info("Logger is initialized in EDB.")
         self.logger.info("legacy v%s", __version__)

pyedb/siwave_core/cpa/simulation_setup_data_model.py

@@ -0,0 +1,132 @@
+from typing import Dict, List
+
+from pydantic import BaseModel, Field
+
+
+class SolverOptions(BaseModel):
+    """Configuration options for the SI-Wave solver.
+
+    Attributes:
+        extraction_mode (str): Mode of extraction, defaults to "si"
+        custom_refinement (bool): Enable custom refinement settings, defaults to False
+        extraction_frequency (str): Frequency for extraction, defaults to "10Ghz"
+        compute_capacitance (bool): Enable capacitance computation, defaults to True
+        compute_dc_parameters (bool): Enable DC parameters computation, defaults to True
+        compute_ac_rl (bool): Enable AC RL computation, defaults to True
+        ground_power_ground_nets_for_si (bool): Ground power/ground nets for SI analysis, defaults to False
+        small_hole_diameter (str): Small hole diameter setting, defaults to "auto"
+        cg_max_passes (int): Maximum passes for CG computation, defaults to 10
+        cg_percent_error (float): Percentage error threshold for CG computation, defaults to 0.02
+        cg_percent_refinement_per_pass (float): Refinement percentage per pass for CG, defaults to 0.33
+        rl_max_passes (int): Maximum passes for RL computation, defaults to 10
+        rl_percent_error (float): Percentage error threshold for RL computation, defaults to 0.02
+        rl_percent_refinement_per_pass (float): Refinement percentage per pass for RL, defaults to 0.33
+        compute_dc_rl (bool): Enable DC RL computation, defaults to True
+        compute_dc_cg (bool): Enable DC CG computation, defaults to True
+        return_path_net_for_loop_parameters (bool): Include return path net for loop parameters, defaults to True
+    """
+
+    extraction_mode: str = "si"
+    custom_refinement: bool = False
+    extraction_frequency: str = "10Ghz"
+    compute_capacitance: bool = True
+    compute_dc_parameters: bool = True
+    compute_ac_rl: bool = True
+    ground_power_ground_nets_for_si: bool = False
+    small_hole_diameter: str = "auto"
+    cg_max_passes: int = 10
+    cg_percent_error: float = 0.02
+    cg_percent_refinement_per_pass: float = 0.33
+    rl_max_passes: int = 10
+    rl_percent_error: float = 0.02
+    rl_percent_refinement_per_pass: float = 0.33
+    compute_dc_rl: bool = True
+    compute_dc_cg: bool = True
+    return_path_net_for_loop_parameters: bool = True
+
+
+class Vrm(BaseModel):
+    """Voltage Regulator Module configuration.
+
+    Attributes:
+        name (str): Name of the VRM, defaults to empty string
+        voltage (float): Voltage value, defaults to 0.0
+        power_net (str): Power net identifier, defaults to empty string
+        reference_net (str): Reference net identifier, defaults to empty string
+    """
+
+    name: str = ""
+    voltage: float = 0.0
+    power_net: str = ""
+    reference_net: str = ""
+
+
+class ChannelSetup(BaseModel):
+    """Channel configuration setup.
+
+    Attributes:
+        die_name (str): Name of the die, defaults to empty string
+        pin_grouping_mode (str): Mode for pin grouping, defaults to "perpin"
+        channel_component_exposure (Dict[str, bool]): Component exposure settings
+        vrm_setup (List[Vrm]): List of VRM configurations
+    """
+
+    die_name: str = ""
+    pin_grouping_mode: str = "perpin"
+    channel_component_exposure: Dict[str, bool] = Field(default_factory=dict)
+    vrm_setup: List[Vrm] = Field(default_factory=list)
+
+
+class SIwaveCpaSetup(BaseModel):
+    """Main configuration class for SI-Wave CPA (Channel Parameter Analyzer) setup.
+
+    Attributes:
+        name (str): Name of the setup, defaults to empty string
+        mode (str): Operation mode, defaults to "channel"
+        model_type (str): Type of model, defaults to "rlcg"
+        use_q3d_solver (bool): Use Q3D solver flag, defaults to True
+        net_processing_mode (str): Net processing mode, defaults to "userspecified"
+        return_path_net_for_loop_parameters (bool): Include return path net for loop parameters, defaults to True
+        channel_setup (ChannelSetup): Channel configuration settings
+        solver_options (SolverOptions): Solver configuration options
+        nets_to_process (List[str]): List of nets to process
+    """
+
+    name: str = ""
+    mode: str = "channel"
+    model_type: str = "rlcg"
+    use_q3d_solver: bool = True
+    net_processing_mode: str = "userspecified"
+    return_path_net_for_loop_parameters: bool = True
+    channel_setup: ChannelSetup = Field(default_factory=ChannelSetup)
+    solver_options: SolverOptions = Field(default_factory=SolverOptions)
+    nets_to_process: List[str] = Field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "SIwaveCpaSetup":
+        """Convert dictionary to SIwaveCpaSetup object.
+
+        Args:
+            data (Dict): Dictionary containing SIwaveCpaSetup configuration
+
+        Returns:
+            SIwaveCpaSetup: New instance created from the dictionary
+        """
+        if "channel_setup" in data:
+            data["channel_setup"] = ChannelSetup(**data["channel_setup"])
+        if "solver_options" in data:
+            data["solver_options"] = SolverOptions(**data["solver_options"])
+        return cls(**data)
+
+    def to_dict(self) -> Dict:
+        """Convert SIwaveCpaSetup object to dictionary.
+
+        Returns:
+            Dict: Dictionary representation of the SIwaveCpaSetup instance
+        """
+        data = self.model_dump()
+        if self.channel_setup:
+            data["channel_setup"] = self.channel_setup.model_dump()
+        if self.solver_options:
+            data["solver_options"] = self.solver_options.model_dump()
+        return data