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

pyedb/dotnet/database/sim_setup_data/data/sweep_data.py

@@ -19,7 +19,7 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
-
+import re
 import warnings
 
 
@@ -524,23 +524,76 @@ class SweepData(object):
 
     def add(self, sweep_type, start, stop, increment):
         sweep_type = sweep_type.replace(" ", "_")
-        start = start.upper().replace("Z", "z") if isinstance(start, str) else str(start)
-        stop = stop.upper().replace("Z", "z") if isinstance(stop, str) else str(stop)
-        increment = increment.upper().replace("Z", "z") if isinstance(increment, str) else int(increment)
-        if sweep_type in ["linear_count", "linear_scale"]:
-            freqs = list(self._edb_object.SetFrequencies(start, stop, increment))
-        elif sweep_type == "log_scale":
-            freqs = list(self._edb_object.SetLogFrequencies(start, stop, increment))
+        start = f"{self._pedb.edb_value(start).ToDouble() / 1e9}GHz"
+        stop = f"{self._pedb.edb_value(stop).ToDouble() / 1e9}GHz"
+
+        if sweep_type == "linear_scale":
+            increment = f"{self._pedb.edb_value(increment).ToDouble() / 1e9}GHz"
+            frequencty_string = f"LIN {start} {stop} {increment}"
         else:
-            raise ValueError("sweep_type must be either 'linear_count', 'linear_scale' or 'log_scale")
-        return self.add_frequencies(freqs)
+            increment = int(increment)
+            if sweep_type == "log_scale":
+                frequencty_string = f"DEC {start} {stop} {increment}"
+            elif sweep_type == "linear_count":
+                frequencty_string = f"LINC {start} {stop} {increment}"
+            else:
+                raise ValueError("sweep_type must be either 'linear_count', 'linear_scale' or 'log_scale")
+        temp = self.frequency_string
+        temp.append(frequencty_string)
+        self.frequency_string = temp
+        return self.frequencies
+
+    @property
+    def frequency_string(self):
+        """A string describing the frequency sweep. Below is an example.
+        ['LIN 0GHz 20GHz 0.05GHz', 'LINC 20GHz 30GHz 10', 'DEC 40GHz 50GHz 10']
+        """
+        pattern = r"(?:LIN[C]?|DEC) [^ ]+ [^ ]+ [^ ]+"
+        grouped = re.findall(pattern, self._edb_object.FrequencyString)
+        return grouped
+
+    @frequency_string.setter
+    def frequency_string(self, value):
+        value = value if isinstance(value, list) else [value]
+        temp = []
+        for i in value:
+            sweep_type, start, stop, increment = i.split(" ")
+            start = start.replace("k", "K").replace("h", "H").replace("Z", "z").replace("g", "G")
+            stop = stop.replace("k", "K").replace("h", "H").replace("Z", "z").replace("g", "G")
+            temp.append(" ".join([sweep_type, start, stop, increment]))
+        value = temp
+        self._edb_object.FrequencyString = " ".join(value)
+
+        frequencies = []
+        for i in value:
+            sweep_type, start, stop, increment = i.split(" ")
+            if sweep_type == "LIN":
+                frequencies.extend(self._edb_object.SetFrequencies(start, stop, increment))
+            else:
+                increment = int(increment)
+                if sweep_type == "DEC":
+                    frequencies.extend(self._edb_object.SetLogFrequencies(start, stop, increment))
+                elif sweep_type == "LINC":
+                    frequencies.extend(self._edb_object.SetFrequencies(start, stop, increment))
+
+        self.clear()
+        self.add_frequencies(frequencies)
 
     def add_frequencies(self, frequencies):
         if not isinstance(frequencies, list):
             frequencies = [frequencies]
+
+        temp = []
+        for i in frequencies:
+            i = self._pedb.edb_value(i).ToDouble()
+            if i not in temp and i not in self.frequencies:
+                temp.append(i)
+        frequencies = temp
+
         for i in frequencies:
             i = self._pedb.edb_value(i).ToString()
             self._edb_object.Frequencies.Add(i)
+        self._update_sweep()
         return list(self._edb_object.Frequencies)
 
     def clear(self):

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,26 +266,24 @@ 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:
+        if frequency_set in [None, []]:
             sweep_type = "linear_scale"
             start, stop, increment = "50MHz", "5GHz", "50MHz"
+            frequency_set = [[sweep_type, start, stop, increment]]
+        elif not isinstance(frequency_set[0], list):
+            frequency_set = [frequency_set]
+
+        for fs in frequency_set:
+            sweep_type, start, stop, increment = fs
             sweep_data.add(sweep_type, start, stop, increment)
-        elif len(frequency_set) == 0:
-            pass
-        else:
-            if not isinstance(frequency_set[0], list):
-                frequency_set = [frequency_set]
-            for fs in frequency_set:
-                sweep_data.add(*fs)
-
-        ss_info = self.sim_setup_info
-        ss_info.add_sweep_data(sweep_data)
-        self.set_sim_setup_info(ss_info)
-        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

@@ -32,7 +32,6 @@ import re
 import shutil
 import subprocess
 import sys
-import tempfile
 import time
 import traceback
 from typing import Union
@@ -48,10 +47,7 @@ from pyedb.dotnet.database.cell.terminal.terminal import Terminal
 from pyedb.dotnet.database.components import Components
 import pyedb.dotnet.database.dotnet.database
 from pyedb.dotnet.database.dotnet.database import Database
-from pyedb.dotnet.database.edb_data.control_file import (
-    ControlFile,
-    convert_technology_file,
-)
+from pyedb.dotnet.database.edb_data.control_file import convert_technology_file
 from pyedb.dotnet.database.edb_data.design_options import EdbDesignOptions
 from pyedb.dotnet.database.edb_data.edbvalue import EdbValue
 from pyedb.dotnet.database.edb_data.ports import (
@@ -243,7 +239,7 @@ class Edb(Database):
                 else:
                     control_file = convert_technology_file(technology_file, edbversion=edbversion)
             self.logger.info("Translating ODB++ to EDB...")
-            self.import_layout_pcb(edbpath[:-4], working_dir, use_ppe=use_ppe, control_file=control_file)
+            self.import_layout_file(edbpath[:-4], working_dir, use_ppe=use_ppe, control_file=control_file)
             if settings.enable_local_log_file and self.log_name:
                 self._logger.add_file_logger(self.log_name, "Edb")
             self.logger.info("EDB %s was created correctly from %s file.", self.edbpath, edbpath)
@@ -256,7 +252,7 @@ class Edb(Database):
                     control_file = technology_file
                 else:
                     control_file = convert_technology_file(technology_file, edbversion=edbversion)
-            self.import_layout_pcb(edbpath, working_dir, use_ppe=use_ppe, control_file=control_file)
+            self.import_layout_file(edbpath, working_dir, use_ppe=use_ppe, control_file=control_file)
             if settings.enable_local_log_file and self.log_name:
                 self._logger.add_file_logger(self.log_name, "Edb")
             self.logger.info("EDB %s was created correctly from %s file.", self.edbpath, edbpath[-2:])
@@ -278,7 +274,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 +545,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
@@ -613,6 +606,65 @@ class Edb(Database):
         anstranslator_full_path="",
         use_ppe=False,
         control_file=None,
+        map_file=None,
+        tech_file=None,
+        layer_filter=None,
+    ):
+        """Import a board file and generate an ``edb.def`` file in the working directory.
+
+        .. deprecated:: 0.42.0
+           Use :func:`import_layout_file` method instead.
+
+        This function supports all AEDT formats, including DXF, GDS, SML (IPC2581), BRD, MCM, SIP, ZIP and TGZ.
+
+        Parameters
+        ----------
+        input_file : str
+            Full path to the board file.
+        working_dir : str, optional
+            Directory in which to create the ``aedb`` folder. The name given to the AEDB file
+            is the same as the name of the board file.
+        anstranslator_full_path : str, optional
+            Full path to the Ansys translator. The default is ``""``.
+        use_ppe : bool
+            Whether to use the PPE License. The default is ``False``.
+        control_file : str, optional
+            Path to the XML file. The default is ``None``, in which case an attempt is made to find
+            the XML file in the same directory as the board file. To succeed, the XML file and board file
+            must have the same name. Only the extension differs.
+        tech_file : str, optional
+            Technology file. The file can be *.ircx, *.vlc.tech, or *.itf
+        map_file : str, optional
+            Layer map .map file.
+        layer_filter:str,optional
+            Layer filter .txt file.
+
+        Returns
+        -------
+        Full path to the AEDB file : str
+        """
+        self.logger.warning("import_layout_pcb method is deprecated, use import_layout_file instead.")
+        return self.import_layout_file(
+            input_file,
+            working_dir,
+            anstranslator_full_path,
+            use_ppe,
+            control_file,
+            map_file,
+            tech_file,
+            layer_filter,
+        )
+
+    def import_layout_file(
+        self,
+        input_file,
+        working_dir="",
+        anstranslator_full_path="",
+        use_ppe=False,
+        control_file=None,
+        map_file=None,
+        tech_file=None,
+        layer_filter=None,
     ):
         """Import a board file and generate an ``edb.def`` file in the working directory.
 
@@ -633,6 +685,12 @@ class Edb(Database):
             Path to the XML file. The default is ``None``, in which case an attempt is made to find
             the XML file in the same directory as the board file. To succeed, the XML file and board file
             must have the same name. Only the extension differs.
+        tech_file : str, optional
+            Technology file. The file can be *.ircx, *.vlc.tech, or *.itf
+        map_file : str, optional
+            Layer map .map file.
+        layer_filter:str,optional
+            Layer filter .txt file.
 
         Returns
         -------
@@ -669,6 +727,12 @@ class Edb(Database):
                 cmd_translator.append("-c={}".format(control_file))
             else:
                 cmd_translator.append('-c="{}"'.format(control_file))
+        if map_file:
+            cmd_translator.append('-g="{}"'.format(map_file))
+        if tech_file:
+            cmd_translator.append('-t="{}"'.format(tech_file))
+        if layer_filter:
+            cmd_translator.append('-f="{}"'.format(layer_filter))
         p = subprocess.Popen(cmd_translator)
         p.wait()
         if not os.path.exists(os.path.join(working_dir, aedb_name)):
@@ -1469,7 +1533,7 @@ class Edb(Database):
             ``True`` when successful, ``False`` when failed.
 
         """
-        if self.import_layout_pcb(
+        if self.import_layout_file(
             inputBrd,
             working_dir=WorkDir,
             anstranslator_full_path=anstranslator_full_path,
@@ -1479,103 +1543,6 @@ class Edb(Database):
         else:
             return False
 
-    def import_gds_file(
-        self,
-        inputGDS,
-        anstranslator_full_path="",
-        use_ppe=False,
-        control_file=None,
-        tech_file=None,
-        map_file=None,
-        layer_filter=None,
-    ):
-        """Import a GDS file and generate an ``edb.def`` file in the working directory.
-
-        ..note::
-            `ANSYSLMD_LICENSE_FILE` is needed to run the translator.
-
-        Parameters
-        ----------
-        inputGDS : str
-            Full path to the GDS file.
-        anstranslator_full_path : str, optional
-            Full path to the Ansys translator.
-        use_ppe : bool, optional
-            Whether to use the PPE License. The default is ``False``.
-        control_file : str, optional
-            Path to the XML file. The default is ``None``, in which case an attempt is made to find
-            the XML file in the same directory as the GDS file. To succeed, the XML file and GDS file must
-            have the same name. Only the extension differs.
-        tech_file : str, optional
-            Technology file. For versions<2024.1 it uses Helic to convert tech file to xml and then imports
-            the gds. Works on Linux only.
-            For versions>=2024.1 it can directly parse through supported foundry tech files.
-        map_file : str, optional
-            Layer map file.
-        layer_filter:str,optional
-            Layer filter file.
-
-        """
-        control_file_temp = os.path.join(tempfile.gettempdir(), os.path.split(inputGDS)[-1][:-3] + "xml")
-        if float(self.edbversion) < 2024.1:
-            if not is_linux and tech_file:
-                self.logger.error("Technology files are supported only in Linux. Use control file instead.")
-                return False
-
-            ControlFile(xml_input=control_file, tecnhology=tech_file, layer_map=map_file).write_xml(control_file_temp)
-            if self.import_layout_pcb(
-                inputGDS,
-                anstranslator_full_path=anstranslator_full_path,
-                use_ppe=use_ppe,
-                control_file=control_file_temp,
-            ):
-                return True
-            else:
-                return False
-        else:
-            if anstranslator_full_path and os.path.exists(anstranslator_full_path):
-                path = anstranslator_full_path
-            else:
-                path = os.path.join(self.base_path, "anstranslator")
-                if is_windows:
-                    path += ".exe"
-
-            temp_map_file = os.path.splitext(inputGDS)[0] + ".map"
-            temp_layermap_file = os.path.splitext(inputGDS)[0] + ".layermap"
-
-            if map_file is None:
-                if os.path.isfile(temp_map_file):
-                    map_file = temp_map_file
-                elif os.path.isfile(temp_layermap_file):
-                    map_file = temp_layermap_file
-                else:
-                    self.logger.error("Unable to define map file.")
-
-            if tech_file is None:
-                if control_file is None:
-                    temp_control_file = os.path.splitext(inputGDS)[0] + ".xml"
-                    if os.path.isfile(temp_control_file):
-                        control_file = temp_control_file
-                    else:
-                        self.logger.error("Unable to define control file.")
-
-                command = [path, inputGDS, f'-g="{map_file}"', f'-c="{control_file}"']
-            else:
-                command = [
-                    path,
-                    inputGDS,
-                    f'-o="{control_file_temp}"' f'-t="{tech_file}"',
-                    f'-g="{map_file}"',
-                    f'-f="{layer_filter}"',
-                ]
-
-            result = subprocess.run(command, capture_output=True, text=True, shell=True)
-            print(result.stdout)
-            print(command)
-            temp_inputGDS = inputGDS.split(".gds")[0]
-            self.edbpath = temp_inputGDS + ".aedb"
-            return self.open_edb()
-
     def _create_extent(
         self,
         net_signals,

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.43.0.dist-info}/METADATA

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