pyedb 0.41.0__py3-none-any.whl → 0.42.0__py3-none-any.whl

pyedb/configuration/cfg_setup.py

@@ -53,14 +53,9 @@ class CfgSetup(CfgBase):
     def _apply_freq_sweep(self, edb_setup):
         for i in self.freq_sweep:
             f_set = []
-            kw = {}
-            for attr in i.get_attributes(exclude="name"):
-                if attr == "frequencies":
-                    for f in i.frequencies:
-                        f_set.append([f.distribution, f.start, f.stop, f.increment])
-                else:
-                    kw[attr] = getattr(i, attr)
-            edb_setup.add_sweep(i.name, frequency_set=f_set, **kw)
+            for f in i.frequencies:
+                f_set.append([f.distribution, f.start, f.stop, f.increment])
+            edb_setup.add_sweep(i.name, frequency_set=f_set, sweep_type=i.type)
 
 
 class CfgSIwaveACSetup(CfgSetup):
@@ -183,62 +178,141 @@ class CfgSetups:
                     continue
 
             stp = {}
-            if s.type == "hfss":
-                for p_name in CfgHFSSSetup(self._pedb).__dict__:
-                    if p_name.startswith("_"):
-                        continue
-                    elif p_name == "type":
-                        stp[p_name] = s.type
-                    elif p_name == "f_adapt":
-                        stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[0].adaptive_frequency
-                    elif p_name == "max_num_passes":
-                        stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[0].max_passes
-                    elif p_name == "max_mag_delta_s":
-                        stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[0].max_delta
-                    elif p_name == "freq_sweep":
-                        f_sweep = []
-                        for _, sw in s.sweeps.items():
-                            sweep_data = {}
-                            for sw_p_name in CfgSweepData().__dict__:
-                                if sw_p_name == "frequencies":
-                                    pass  # Frequencies cannot be read from EDB
-                                else:
-                                    sweep_data[sw_p_name] = getattr(sw, sw_p_name)
-                            f_sweep.append(sweep_data)
-                        stp["freq_sweep"] = f_sweep
-                    elif p_name == "mesh_operations":
-                        mops = []
-                        for _, i in s.mesh_operations.items():
-                            mop = {}
-                            for mop_p_name in CfgLengthMeshOperation().__dict__:
-                                mop[mop_p_name] = getattr(i, mop_p_name)
-                            mops.append(mop)
-                        stp["mesh_operations"] = mops
-                    else:
-                        stp[p_name] = getattr(s, p_name)
-
-            elif s.type == "siwave_ac":
-                for p_name in CfgSIwaveACSetup(self._pedb).__dict__:
-                    if p_name.startswith("_"):
-                        continue
-                    elif p_name == "freq_sweep":
-                        pass  # Bug in EDB API
-                    else:
-                        stp[p_name] = getattr(s, p_name)
-            elif s.type == "siwave_dc":
-                for p_name in CfgSIwaveDCSetup(self._pedb).__dict__:
-                    if p_name.startswith("_"):
-                        continue
-                    elif p_name == "freq_sweep":
-                        pass
-                    elif p_name == "dc_ir_settings":
-                        dc_ir_s = {}
-                        for dcir_p_name in CfgDcIrSettings().__dict__:
-                            dc_ir_s[dcir_p_name] = getattr(s.dc_ir_settings, dcir_p_name)
-                        stp["dc_ir_settings"] = dc_ir_s
-                    elif p_name == "dc_slider_position":
-                        stp[p_name] = getattr(s.dc_settings, p_name)
-                    else:
-                        stp[p_name] = getattr(s, p_name)
+            if self._pedb.grpc:
+                from ansys.edb.core.simulation_setup.mesh_operation import (
+                    LengthMeshOperation as GrpcLengthMeshOperation,
+                )
+
+                s_type = s.type.name.lower()
+                if s_type == "hfss":
+                    for p_name in CfgHFSSSetup(self._pedb).__dict__:
+                        if p_name.startswith("_"):
+                            continue
+                        elif p_name == "type":
+                            stp[p_name] = s.type.name.lower()
+                        elif p_name == "f_adapt":
+                            stp[p_name] = s.settings.general.single_frequency_adaptive_solution.adaptive_frequency
+                        elif p_name == "max_num_passes":
+                            stp[p_name] = s.settings.general.single_frequency_adaptive_solution.max_passes
+                        elif p_name == "max_mag_delta_s":
+                            stp[p_name] = s.settings.general.single_frequency_adaptive_solution.max_delta
+                        elif p_name == "freq_sweep":
+                            f_sweep = []
+                            for sw in s.sweep_data:
+                                sweep_data = {}
+                                for sw_p_name in CfgSweepData().__dict__:
+                                    if sw_p_name == "frequencies":
+                                        pass  # Frequencies cannot be read from EDB
+                                    else:
+                                        sweep_data[sw_p_name] = getattr(sw, sw_p_name)
+                                f_sweep.append(sweep_data)
+                            stp["freq_sweep"] = f_sweep
+                        elif p_name == "mesh_operations":
+                            mops = []
+                            for i in s.mesh_operations:
+                                mop = {}
+                                for mop_p_name in CfgLengthMeshOperation().__dict__:
+                                    if mop_p_name == "type":
+                                        if isinstance(i, GrpcLengthMeshOperation):
+                                            mop[mop_p_name] = "length"
+                                    elif mop_p_name == "nets_layers_list":
+                                        mop[mop_p_name] = i.__dict__["_net_layer_info"]
+                                    elif mop_p_name == "restrict_length":
+                                        mop[mop_p_name] = i.__dict__["_restrict_max_length"]
+                                    else:
+                                        mop[mop_p_name] = i.__dict__[f"_{mop_p_name}"]
+                                mops.append(mop)
+                            stp["mesh_operations"] = mops
+                        else:
+                            stp[p_name] = getattr(s, p_name)
+
+                elif s_type == "siwave_ac":
+                    for p_name in CfgSIwaveACSetup(self._pedb).__dict__:
+                        if p_name.startswith("_"):
+                            continue
+                        elif p_name == "freq_sweep":
+                            pass  # Bug in EDB API
+                        else:
+                            stp[p_name] = getattr(s, p_name)
+                elif s_type == "siwave_dc":
+                    for p_name in CfgSIwaveDCSetup(self._pedb).__dict__:
+                        if p_name.startswith("_"):
+                            continue
+                        elif p_name == "freq_sweep":
+                            pass
+                        elif p_name == "dc_ir_settings":
+                            dc_ir_s = {}
+                            for dcir_p_name in CfgDcIrSettings().__dict__:
+                                dc_ir_s[dcir_p_name] = getattr(s.dc_ir_settings, dcir_p_name)
+                            stp["dc_ir_settings"] = dc_ir_s
+                        elif p_name == "dc_slider_position":
+                            stp[p_name] = getattr(s.dc_settings, p_name)
+                        else:
+                            stp[p_name] = getattr(s, p_name)
+            else:
+                for _, s in self._pedb.setups.items():
+                    if float(self._pedb.edbversion) < 2025.1:
+                        if not s.type == "hfss":
+                            self._pedb.logger.warning("Only HFSS setups are exported in 2024 R2 and earlier version.")
+                            continue
+                    if s.type == "hfss":
+                        for p_name in CfgHFSSSetup(self._pedb).__dict__:
+                            if p_name.startswith("_"):
+                                continue
+                            elif p_name == "type":
+                                stp[p_name] = s.type
+                            elif p_name == "f_adapt":
+                                stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[
+                                    0
+                                ].adaptive_frequency
+                            elif p_name == "max_num_passes":
+                                stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[0].max_passes
+                            elif p_name == "max_mag_delta_s":
+                                stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[0].max_delta
+                            elif p_name == "freq_sweep":
+                                f_sweep = []
+                                for sw in s.sweeps.items():
+                                    sweep_data = {}
+                                    for sw_p_name in CfgSweepData().__dict__:
+                                        if sw_p_name == "frequencies":
+                                            pass  # Frequencies cannot be read from EDB
+                                        else:
+                                            sweep_data[sw_p_name] = getattr(sw[1], sw_p_name)
+                                    f_sweep.append(sweep_data)
+                                stp["freq_sweep"] = f_sweep
+                            elif p_name == "mesh_operations":
+                                mops = []
+                                for _, i in s.mesh_operations.items():
+                                    mop = {}
+                                    for mop_p_name in CfgLengthMeshOperation().__dict__:
+                                        mop[mop_p_name] = getattr(i, mop_p_name)
+                                    mops.append(mop)
+                                stp["mesh_operations"] = mops
+                            else:
+                                stp[p_name] = getattr(s, p_name)
+
+                    elif s.type == "siwave_ac":
+                        for p_name in CfgSIwaveACSetup(self._pedb).__dict__:
+                            if p_name.startswith("_"):
+                                continue
+                            elif p_name == "freq_sweep":
+                                pass  # Bug in EDB API
+                            else:
+                                stp[p_name] = getattr(s, p_name)
+                    elif s.type == "siwave_dc":
+                        for p_name in CfgSIwaveDCSetup(self._pedb).__dict__:
+                            if p_name.startswith("_"):
+                                continue
+                            elif p_name == "freq_sweep":
+                                pass
+                            elif p_name == "dc_ir_settings":
+                                dc_ir_s = {}
+                                for dcir_p_name in CfgDcIrSettings().__dict__:
+                                    dc_ir_s[dcir_p_name] = getattr(s.dc_ir_settings, dcir_p_name)
+                                stp["dc_ir_settings"] = dc_ir_s
+                            elif p_name == "dc_slider_position":
+                                stp[p_name] = getattr(s.dc_settings, p_name)
+                            else:
+                                stp[p_name] = getattr(s, p_name)
             setups.append(stp)
         return setups

pyedb/configuration/configuration.py

@@ -147,19 +147,34 @@ class Configuration:
                 cfg_pdef.api.set_parameters_to_edb()
         else:
             temp_pdef_data = {}
-            for pdef_name, pdef in self._pedb.padstacks.definitions.items():
-                pdef_data = pdef._padstack_def_data
-                for lyr_name in list(pdef_data.GetLayerNames()):
-                    result = pdef_data.GetPadParametersValue(lyr_name, self._pedb._edb.Definition.PadType.RegularPad)
-                    flag, pad_shape, params, offset_x, offset_y, rotation = result
-                    if flag is False:
-                        result = pdef_data.GetPolygonalPadParameters(
+            if self._pedb.grpc:
+                from ansys.edb.core.definition.padstack_def_data import (
+                    PadType as GrpcPadType,
+                )
+
+                for pdef_name, pdef in self._pedb.padstacks.definitions.items():
+                    for layer in pdef.data.layer_names:
+                        result = pdef.data.get_pad_parameters(layer, GrpcPadType.REGULAR_PAD)
+                        if len(result) == 4:
+                            # polygon based
+                            temp_pdef_data[pdef_name] = pdef.data
+                            break
+            else:
+                for pdef_name, pdef in self._pedb.padstacks.definitions.items():
+                    pdef_data = pdef._padstack_def_data
+                    for lyr_name in list(pdef_data.GetLayerNames()):
+                        result = pdef_data.GetPadParametersValue(
                             lyr_name, self._pedb._edb.Definition.PadType.RegularPad
                         )
-                        flag, polygon_data, offset_x, offset_y, rotation = result
-                        if flag:
-                            temp_pdef_data[pdef_name] = pdef_data
-                            break
+                        flag, pad_shape, params, offset_x, offset_y, rotation = result
+                        if flag is False:
+                            result = pdef_data.GetPolygonalPadParameters(
+                                lyr_name, self._pedb._edb.Definition.PadType.RegularPad
+                            )
+                            flag, polygon_data, offset_x, offset_y, rotation = result
+                            if flag:
+                                temp_pdef_data[pdef_name] = pdef_data
+                                break
             self.cfg_data.stackup.apply()
             for pdef_name, pdef_data in temp_pdef_data.items():
                 pdef = self._pedb.padstacks.definitions[pdef_name]

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

@@ -43,6 +43,11 @@ class PadstackInstanceTerminal(Terminal):
             return EDBPadstackInstance(edb_padstack_instance[1], self._pedb).position
         return False
 
+    @property
+    def location(self):
+        """Location of the padstack instance."""
+        return self.position
+
     def create(self, padstack_instance, name=None, layer=None, is_ref=False):
         """Create an edge terminal.
 

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

@@ -78,3 +78,15 @@ class PointTerminal(Terminal):
         layer = self._pedb.stackup.layers[value]._edb_layer
         point_data = self._pedb.point_data(*self.location)
         self._edb_object.SetParameters(point_data, layer)
+
+    @property
+    def location(self):
+        """Location of the terminal."""
+
+        _, point_data, _ = self._edb_object.GetParameters()
+        return [point_data.X.ToDouble(), point_data.Y.ToDouble()]
+
+    @location.setter
+    def location(self, value):
+        layer = self.layer
+        self._edb_object.SetParameters(self._pedb.point_data(*value), layer._edb_object)

pyedb/dotnet/database/cell/terminal/terminal.py

@@ -107,20 +107,6 @@ class Terminal(Connectable):
         """Get layer of the terminal."""
         return self._pedb.logger.error("Cannot determine terminal layer")
 
-    @property
-    def location(self):
-        """Location of the terminal."""
-        try:
-            _, point_data, _ = self._edb_object.GetParameters()
-            return [point_data.X.ToDouble(), point_data.Y.ToDouble()]
-        except:
-            self._pedb.logger.error("Cannot determine terminal location")
-
-    @location.setter
-    def location(self, value):
-        layer = self.layer
-        self._edb_object.SetParameters(self._pedb.point_data(*value), layer._edb_object)
-
     @property
     def is_circuit_port(self):
         """Whether it is a circuit port."""

pyedb/dotnet/database/dotnet/database.py

@@ -861,6 +861,8 @@ class Database(EdbDotNet):
             db_path,
             read_only,
         )
+        if self._db.IsNull():
+            raise AttributeError(f"Failed to open edb file {db_path}")
         return self._db
 
     def delete(self, db_path):

pyedb/dotnet/database/siwave.py

@@ -811,6 +811,7 @@ class EdbSiwave(object):
 
     def add_siwave_syz_analysis(
         self,
+        name=None,
         accuracy_level=1,
         decade_count=10,
         sweeptype=1,
@@ -823,6 +824,8 @@ class EdbSiwave(object):
 
         Parameters
         ----------
+        name : str optional
+            Setup name.
         accuracy_level : int, optional
            Level of accuracy of SI slider. The default is ``1``.
         decade_count : int
@@ -849,7 +852,7 @@ class EdbSiwave(object):
         :class:`pyedb.dotnet.database.edb_data.siwave_simulation_setup_data.SiwaveSYZSimulationSetup`
             Setup object class.
         """
-        setup = self._pedb.create_siwave_syz_setup()
+        setup = self._pedb.create_siwave_syz_setup(name=name)
         sweep = "linear count"
         if sweeptype == 2:
             sweep = "log scale"

pyedb/dotnet/database/utilities/simulation_setup.py

@@ -239,7 +239,7 @@ class SimulationSetup(object):
         """List of frequency sweeps."""
         return {i.name: i for i in self.sim_setup_info.sweep_data_list}
 
-    def add_sweep(self, name, frequency_set: list = None, **kwargs):
+    def add_sweep(self, name, frequency_set: list = None, sweep_type: str = "interpolation", **kwargs):
         """Add frequency sweep.
 
         Parameters
@@ -248,7 +248,8 @@ class SimulationSetup(object):
             Name of the frequency sweep. The default is ``None``.
         frequency_set : list, optional
             List of frequency points. The default is ``None``.
-
+        sweep_type : str, optional
+            Sweep type. The default is ``"interpolation"``. Options are ``"discrete"``,"discrete"``.
         Returns
         -------
 
@@ -265,7 +266,7 @@ class SimulationSetup(object):
         for k, v in kwargs.items():
             if k in dir(sweep_data):
                 setattr(sweep_data, k, v)
-        sweep_data.freq_sweep_type = kwargs.get("sweep_type") if kwargs.get("sweep_type") else "interpolation"
+        sweep_data.type = sweep_type
 
         if frequency_set is None:
             sweep_type = "linear_scale"
@@ -285,6 +286,10 @@ class SimulationSetup(object):
         self._update_setup()
         return sweep_data
 
+    def delete(self):
+        """Delete current simulation setup."""
+        self._pedb.layout.cell.DeleteSimulationSetup(self.name)
+
     def _add_frequency_sweep(self, sweep_data):
         """Add a frequency sweep.
 

pyedb/dotnet/edb.py

@@ -278,7 +278,7 @@ class Edb(Database):
         if self.active_cell:
             self.logger.info("EDB initialized.")
         else:
-            self.logger.info("Failed to initialize DLLs.")
+            raise AttributeError("Failed to initialize DLLs.")
 
     def __enter__(self):
         return self
@@ -549,10 +549,7 @@ class Edb(Database):
         self.run_as_standalone(self.standalone)
 
         # self.logger.info("EDB Standalone %s", self.standalone)
-        try:
-            self.open(self.edbpath, self.isreadonly)
-        except Exception as e:
-            self.logger.error("Builder is not Initialized.")
+        self.open(self.edbpath, self.isreadonly)
         if not self.active_db:
             self.logger.warning("Error Opening db")
             self._active_cell = None

pyedb/grpc/database/components.py

@@ -2274,8 +2274,7 @@ class Components(object):
         pingroup = PinGroup.create(self._active_layout, group_name, pins)
 
         if pingroup.is_null:  # pragma: no cover
-            self._logger.error(f"Failed to create pin group {group_name}.")
-            return False
+            raise RuntimeError(f"Failed to create pin group {group_name}.")
         else:
             for pin in pins:
                 if not pin.net.is_null:

pyedb/grpc/database/hierarchy/component.py

@@ -41,6 +41,7 @@ from ansys.edb.core.hierarchy.pin_pair_model import PinPairModel as GrpcPinPairM
 from ansys.edb.core.hierarchy.sparameter_model import (
     SParameterModel as GrpcSParameterModel,
 )
+from ansys.edb.core.hierarchy.spice_model import SPICEModel as GrpcSPICEModel
 from ansys.edb.core.primitive.primitive import PadstackInstance as GrpcPadstackInstance
 from ansys.edb.core.terminal.terminals import (
     PadstackInstanceTerminal as GrpcPadstackInstanceTerminal,
@@ -49,6 +50,7 @@ from ansys.edb.core.utility.rlc import Rlc as GrpcRlc
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.grpc.database.hierarchy.pin_pair_model import PinPairModel
+from pyedb.grpc.database.hierarchy.s_parameter_model import SparamModel
 from pyedb.grpc.database.hierarchy.spice_model import SpiceModel
 from pyedb.grpc.database.layers.stackup_layer import StackupLayer
 from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
@@ -204,7 +206,13 @@ class Component(GrpcComponentGroup):
         :class:`Model <ansys.edb.core.hierarchy.model.Model>`
 
         """
-        return self.component_property.model
+
+        if isinstance(self.component_property.model, GrpcSPICEModel):
+            return SpiceModel(edb_object=self.component_property.model.msg)
+        elif isinstance(self.component_property.model, GrpcSParameterModel):
+            return SparamModel(edb_object=self.component_property.model.msg)
+        else:
+            return self.component_property.model
 
     @model.setter
     def model(self, value):

pyedb/grpc/database/hierarchy/s_parameter_model.py

@@ -28,6 +28,6 @@ from ansys.edb.core.hierarchy.sparameter_model import (
 class SparamModel(GrpcSParameterModel):  # pragma: no cover
     """Manage :class:`SParameterModel <ansys.edb.core.hierarchy.sparameter_model.SParameterModel>`"""
 
-    def __init__(self, edb_model):
+    def __init__(self, edb_object):
         super().__init__(self.msg)
-        self._edb_model = edb_model
+        self._edb_model = edb_object

pyedb/grpc/database/hierarchy/spice_model.py

@@ -46,3 +46,7 @@ class SpiceModel(GrpcSpiceModel):  # pragma: no cover
 
         """
         return self.model_name
+
+    @property
+    def spice_file_path(self):
+        return self.model_path

pyedb/grpc/database/utility/hfss_extent_info.py

@@ -81,12 +81,12 @@ class HfssExtentInfo(GrpcHfssExtentInfo):
         float
             Air box horizontal extent value.
         """
-        return self._hfss_extent_info.air_box_horizontal_extent[0]
+        return self._hfss_extent_info.airbox_horizontal[0]
 
     @air_box_horizontal_extent.setter
     def air_box_horizontal_extent(self, value):
         hfss_extent = self._hfss_extent_info
-        hfss_extent.air_box_horizontal_extent = float(value)
+        hfss_extent.airbox_horizontal = (float(value), True)
         self._update_hfss_extent_info(hfss_extent)
 
     @property
@@ -98,12 +98,12 @@ class HfssExtentInfo(GrpcHfssExtentInfo):
         bool.
 
         """
-        return self._hfss_extent_info.air_box_positive_vertical_extent[1]
+        return self._hfss_extent_info.airbox_vertical_positive[1]
 
     @air_box_positive_vertical_extent_enabled.setter
     def air_box_positive_vertical_extent_enabled(self, value):
         hfss_exent = self._hfss_extent_info
-        hfss_exent.air_box_positive_vertical_extent = value
+        hfss_exent.airbox_vertical_positive = (0.15, value)
         self._update_hfss_extent_info(hfss_exent)
 
     @property
@@ -116,12 +116,12 @@ class HfssExtentInfo(GrpcHfssExtentInfo):
             Air box positive vertical extent value.
 
         """
-        return self._hfss_extent_info.air_box_positive_vertical_extent[0]
+        return self._hfss_extent_info.airbox_vertical_positive[0]
 
     @air_box_positive_vertical_extent.setter
     def air_box_positive_vertical_extent(self, value):
         hfss_extent = self._hfss_extent_info
-        hfss_extent.air_box_positive_vertical_extent = float(value)
+        hfss_extent.airbox_vertical_positive = (float(value), True)
         self._update_hfss_extent_info(hfss_extent)
 
     @property
@@ -133,12 +133,12 @@ class HfssExtentInfo(GrpcHfssExtentInfo):
         bool.
 
         """
-        return self._hfss_extent_info.air_box_negative_vertical_extent[1]
+        return self._hfss_extent_info.airbox_vertical_negative[1]
 
     @air_box_negative_vertical_extent_enabled.setter
     def air_box_negative_vertical_extent_enabled(self, value):
         hfss_extent = self._hfss_extent_info
-        hfss_extent.air_box_negative_vertical_extent = value
+        hfss_extent.airbox_vertical_negative = (0.15, value)
         self._update_hfss_extent_info(hfss_extent)
 
     @property
@@ -151,12 +151,12 @@ class HfssExtentInfo(GrpcHfssExtentInfo):
             Air box negative vertical extent value.
 
         """
-        return self._hfss_extent_info.air_box_negative_vertical_extent[0]
+        return self._hfss_extent_info.airbox_vertical_negative[0]
 
     @air_box_negative_vertical_extent.setter
     def air_box_negative_vertical_extent(self, value):
         hfss_extent = self._hfss_extent_info
-        hfss_extent.air_box_negative_vertical_extent = float(value)
+        hfss_extent.airbox_vertical_negative = (float(value), True)
         self._update_hfss_extent_info(hfss_extent)
 
     @property
@@ -183,7 +183,7 @@ class HfssExtentInfo(GrpcHfssExtentInfo):
         -------
         :class:`Polygon <pyedb.grpc.database.primitive.polygon.Polygon>`
         """
-        return self._hfss_extent_info.dielectric_base_polygon
+        return super().dielectric_base_polygon
 
     @dielectric_base_polygon.setter
     def dielectric_base_polygon(self, value):
@@ -216,12 +216,12 @@ class HfssExtentInfo(GrpcHfssExtentInfo):
         float
             Dielectric extent size value.
         """
-        return self._hfss_extent_info.dielectric_extent_size[0]
+        return self._hfss_extent_info.dielectric[0]
 
     @dielectric_extent_size.setter
     def dielectric_extent_size(self, value):
         hfss_extent = self._hfss_extent_info
-        hfss_extent.dielectric_extent_size = value
+        hfss_extent.dielectric = (value, True)
         self._update_hfss_extent_info(hfss_extent)
 
     @property
@@ -256,6 +256,17 @@ class HfssExtentInfo(GrpcHfssExtentInfo):
     @extent_type.setter
     def extent_type(self, value):
         hfss_extent = self._hfss_extent_info
+        if isinstance(value, str):
+            if value.lower() == "bounding_box":
+                value = GrpcHfssExtentInfo.HFSSExtentInfoType.BOUNDING_BOX
+            elif value.lower() == "conforming":
+                value = GrpcHfssExtentInfo.HFSSExtentInfoType.CONFORMING
+            elif value.lower() == "convex_hul":
+                value = GrpcHfssExtentInfo.HFSSExtentInfoType.CONVEX_HUL
+            elif value.lower() == "polygon":
+                value = GrpcHfssExtentInfo.HFSSExtentInfoType.POLYGON
+            else:
+                raise f"Invalid extent type : {value}"
         hfss_extent.extent_type = value
         self._update_hfss_extent_info(hfss_extent)
 
@@ -328,7 +339,7 @@ class HfssExtentInfo(GrpcHfssExtentInfo):
         self._update_hfss_extent_info(hfss_extent)
 
     @property
-    def radiation_level(self):
+    def pml_radiation_factor(self):
         """PML Radiation level to calculate the thickness of boundary.
 
         Returns
@@ -337,12 +348,12 @@ class HfssExtentInfo(GrpcHfssExtentInfo):
             Boundary thickness value.
 
         """
-        return GrpcValue(self._hfss_extent_info.radiation_level).value
+        return self._hfss_extent_info.radiation_level.value
 
-    @radiation_level.setter
-    def radiation_level(self, value):
+    @pml_radiation_factor.setter
+    def pml_radiation_factor(self, value):
         hfss_extent = self._hfss_extent_info
-        hfss_extent.RadiationLevel = GrpcValue(value)
+        hfss_extent.radiation_level = GrpcValue(value)
         self._update_hfss_extent_info(hfss_extent)
 
     @property
@@ -373,12 +384,12 @@ class HfssExtentInfo(GrpcHfssExtentInfo):
             Truncate air box at ground.
 
         """
-        return self._hfss_extent_info.truncate_air_box_at_ground
+        return self._hfss_extent_info.airbox_truncate_at_ground
 
     @truncate_air_box_at_ground.setter
     def truncate_air_box_at_ground(self, value):
         hfss_extent = self._hfss_extent_info
-        hfss_extent.truncate_air_box_at_ground = value
+        hfss_extent.airbox_truncate_at_ground = value
         self._update_hfss_extent_info(hfss_extent)
 
     @property

{pyedb-0.41.0.dist-info → pyedb-0.42.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyedb
-Version: 0.41.0
+Version: 0.42.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>