pyedb 0.10.dev0__py3-none-any.whl → 0.11.0__py3-none-any.whl

pyedb/dotnet/edb.py

@@ -46,6 +46,9 @@ from pyedb.dotnet.edb_core.edb_data.control_file import (
 )
 from pyedb.dotnet.edb_core.edb_data.design_options import EdbDesignOptions
 from pyedb.dotnet.edb_core.edb_data.edbvalue import EdbValue
+from pyedb.dotnet.edb_core.edb_data.hfss_pi_simulation_setup_data import (
+    HFSSPISimulationSetup,
+)
 from pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data import (
     HfssSimulationSetup,
 )
@@ -1525,9 +1528,7 @@ class Edb(Database):
         """
         if tech_file or map_file:
             control_file_temp = os.path.join(tempfile.gettempdir(), os.path.split(inputGDS)[-1][:-3] + "xml")
-            control_file = ControlFile(xml_input=control_file, tecnhology=tech_file, layer_map=map_file).write_xml(
-                control_file_temp
-            )
+            ControlFile(xml_input=control_file, tecnhology=tech_file, layer_map=map_file).write_xml(control_file_temp)
         elif tech_file:
             self.logger.error("Technology files are supported only in Linux. Use control file instead.")
             return False
@@ -1536,7 +1537,7 @@ class Edb(Database):
             working_dir=WorkDir,
             anstranslator_full_path=anstranslator_full_path,
             use_ppe=use_ppe,
-            control_file=control_file,
+            control_file=control_file_temp,
         ):
             return True
         else:
@@ -3597,6 +3598,8 @@ class Edb(Database):
                 setups[i.GetName()] = SiwaveDCSimulationSetup(self, i)
             elif i.GetType() == self.edb_api.utility.utility.SimulationSetupType.kRaptorX:
                 setups[i.GetName()] = RaptorXSimulationSetup(self, i)
+            elif i.GetType() == self.edb_api.utility.utility.SimulationSetupType.kHFSSPI:
+                setups[i.GetName()] = HFSSPISimulationSetup(self, i)
         return setups
 
     @property
@@ -3682,6 +3685,31 @@ class Edb(Database):
             self.logger.error("RaptorX simulation only supported with Ansys release 2024R2 and higher")
             return False
 
+    def create_hfsspi_setup(self, name=None):
+        """Create an HFSS PI simulation setup from a template.
+
+        Parameters
+        ----------
+        name : str, optional
+            Setup name.
+
+        Returns
+        -------
+        :class:`legacy.edb_core.edb_data.hfss_pi_simulation_setup_data.HFSSPISimulationSetup when succeeded, ``False``
+        when failed.
+
+        """
+        if name in self.setups:
+            self.logger.error("Setup name already used in the layout")
+            return False
+        version = self.edbversion.split(".")
+        if int(version[0]) == 2024 and int(version[-1]) >= 2 or int(version[0]) > 2024:
+            setup = HFSSPISimulationSetup(self).create(name)
+            return setup
+        else:
+            self.logger.error("HFSSPI simulation only supported with Ansys release 2024R2 and higher")
+            return False
+
     @pyedb_function_handler()
     def create_siwave_syz_setup(self, name=None):
         """Create a setup from a template.

pyedb/dotnet/edb_core/components.py

@@ -785,6 +785,8 @@ class Components(object):
             reference_pins = [reference_pins]
         if isinstance(refdes, str) or isinstance(refdes, EDBComponent):
             refdes = self.instances[refdes]
+        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:
@@ -2289,6 +2291,18 @@ class Components(object):
                 f.writelines([delimiter.join([refdes, part_name, comp_type, value + "\n"])])
         return True
 
+    @pyedb_function_handler
+    def find_by_reference_designator(self, reference_designator):
+        """Find a component.
+
+        Parameters
+        ----------
+        reference_designator : str
+            Reference designator of the component.
+        """
+        obj = self._pedb.edb_api.cell.hierarchy.component.FindByName(self._active_layout, reference_designator)
+        return EDBComponent(self._pedb, obj)
+
     @pyedb_function_handler()
     def get_pin_from_component(self, component, netName=None, pinName=None):
         """Retrieve the pins of a component.
@@ -2317,6 +2331,7 @@ class Components(object):
         >>> edbapp.components.get_pin_from_component("R1", refdes)
 
         """
+        warnings.warn("Use new property :func:`edb.padstacks.get_instances` instead.", DeprecationWarning)
         if not isinstance(component, self._pedb.edb_api.cell.hierarchy.component):
             component = self._pedb.edb_api.cell.hierarchy.component.FindByName(self._active_layout, component)
         if netName:
@@ -2373,6 +2388,34 @@ class Components(object):
         name = str(name).strip("'")
         return name
 
+    @pyedb_function_handler
+    def get_pins(self, reference_designator, net_name=None, pin_name=None):
+        """Get component pins.
+
+        Parameters
+        ----------
+        reference_designator : str
+            Reference designator of the component.
+        net_name : str, optional
+            Name of the net.
+        pin_name : str, optional
+            Name of the pin.
+
+        Returns
+        -------
+
+        """
+        comp = self.find_by_reference_designator(reference_designator)
+
+        pins = comp.pins
+        if net_name:
+            pins = {i: j for i, j in pins.items() if j.net_name == net_name}
+
+        if pin_name:
+            pins = {i: j for i, j in pins.items() if i == pin_name}
+
+        return pins
+
     @pyedb_function_handler()
     def get_pin_position(self, pin):
         """Retrieve the pin position in meters.

pyedb/dotnet/edb_core/edb_data/hfss_pi_simulation_setup_data.py

@@ -0,0 +1,465 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNE SS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
+from pyedb.dotnet.edb_core.utilities.simulation_setup import (
+    BaseSimulationSetup,
+    EdbFrequencySweep,
+)
+from pyedb.generic.data_handlers import pyedb_function_handler
+from pyedb.generic.general_methods import generate_unique_name
+
+
+class HFSSPISimulationSetup(BaseSimulationSetup):
+    """Manages EDB methods for HFSSPI simulation setup."""
+
+    def __init__(self, pedb, edb_object=None):
+        super().__init__(pedb, edb_object)
+        self._pedb = pedb
+        self._setup_type = "kHFSSPI"
+        self._edb_setup_info = None
+        self.logger = self._pedb.logger
+
+    @pyedb_function_handler
+    def create(self, name=None):
+        """Create an HFSS setup."""
+        self._name = name
+        self._create(name)
+        return self
+
+    @property
+    def setup_type(self):
+        return self._setup_type
+
+    @property
+    def settings(self):
+        return HFSSPISimulationSettings(self._edb_setup_info, self._pedb)
+
+    @property
+    def enabled(self):
+        return self.settings.enabled
+
+    @enabled.setter
+    def enabled(self, value):
+        if isinstance(value, bool):
+            self.settings.enabled = value
+        else:
+            self.logger.error(f"Property enabled expects a boolean value while the provided value is {value}.")
+
+    @property
+    def position(self):
+        return self._edb_setup_info.Position
+
+    @position.setter
+    def position(self, value):
+        if isinstance(value, int):
+            self._edb_setup_info.Position = value
+        else:
+            self.logger.error(f"Property position expects an integer value while the provided value is {value}.")
+
+    @pyedb_function_handler()
+    def add_frequency_sweep(self, name=None, frequency_sweep=None):
+        """Add frequency sweep.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the frequency sweep.
+        frequency_sweep : list, optional
+            List of frequency points.
+
+        Returns
+        -------
+        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.EdbFrequencySweep`wheen succeeded, ``False``
+        when failed.
+
+        Examples
+        --------
+        >>> setup1 = edbapp.create_hfss_setup("setup1")
+        >>> setup1.add_frequency_sweep(frequency_sweep=[
+        ...                           ["linear count", "0", "1kHz", 1],
+        ...                           ["log scale", "1kHz", "0.1GHz", 10],
+        ...                           ["linear scale", "0.1GHz", "10GHz", "0.1GHz"],
+        ...                           ])
+        """
+        if name in self.frequency_sweeps:
+            self.logger.error("Frequency sweep with same name already defined.")
+            return False
+        if not name:
+            name = generate_unique_name("sweep")
+        return EdbFrequencySweep(self, frequency_sweep, name)
+
+
+class HFSSPISimulationSettings(object):
+    def __init__(self, edb_setup_info, pedb):
+        self._pedb = pedb
+        self.logger = self._pedb.logger
+        self._edb_setup_info = edb_setup_info
+        self._simulation_settings = edb_setup_info.SimulationSettings
+
+    @property
+    def auto_select_nets_for_simulation(self):
+        """Auto select nets for simulation.
+
+        Returns
+        -------
+            bool
+        """
+        return self._simulation_settings.AutoSelectNetsForSimulation
+
+    @auto_select_nets_for_simulation.setter
+    def auto_select_nets_for_simulation(self, value):
+        if isinstance(value, bool):
+            self._simulation_settings.AutoSelectNetsForSimulation = value
+        else:
+            self.logger.error(
+                "Property auto_select_nets_for_simulation expects a boolean "
+                f"value while the provided value is {value}."
+            )
+
+    @property
+    def enabled(self):
+        return self._simulation_settings.Enabled
+
+    @enabled.setter
+    def enabled(self, value):
+        if isinstance(value, bool):
+            self._simulation_settings.Enabled = value
+        else:
+            self.logger.error(f"Property enabled expects a boolean value while the provided value is {value}.")
+
+    @property
+    def ignore_dummy_nets_for_selected_nets(self):
+        """Auto select Nets for simulation
+
+        Returns
+        -------
+            bool
+        """
+        return self._simulation_settings.IgnoreDummyNetsForSelectedNets
+
+    @ignore_dummy_nets_for_selected_nets.setter
+    def ignore_dummy_nets_for_selected_nets(self, value):
+        if isinstance(value, bool):
+            self._simulation_settings.IgnoreDummyNetsForSelectedNets = value
+        else:
+            self.logger.error(
+                "Property ignore_dummy_nets_for_selected_nets expects a boolean "
+                f"value while the provided value is {value}."
+            )
+
+    @property
+    def ignore_small_holes(self):
+        """Ignore small holes choice.
+
+        Returns
+        -------
+            bool
+        """
+        return self._simulation_settings.IgnoreSmallHoles
+
+    @ignore_small_holes.setter
+    def ignore_small_holes(self, value):
+        if isinstance(value, bool):
+            self._simulation_settings.IgnoreSmallHoles = value
+        else:
+            self.logger.error(
+                f"Property ignore_small_holes expects a boolean value while the provided value is {value}."
+            )
+
+    @property
+    def ignore_small_holes_min_diameter(self):
+        """Min diameter to ignore small holes.
+
+        Returns
+        -------
+            str
+        """
+        return self._simulation_settings.IgnoreSmallHolesMinDiameter
+
+    @ignore_small_holes_min_diameter.setter
+    def ignore_small_holes_min_diameter(self, value):
+        self._simulation_settings.IgnoreSmallHolesMinDiameter = self._pedb.edb_value(value).ToString()
+
+    @property
+    def improved_loss_model(self):
+        """Improved Loss Model on power ground nets option.
+
+        Returns
+        -------
+            str
+            ``Level1``, ``Level2``, ``Level3``
+        """
+        return self._simulation_settings.ImprovedLossModel
+
+    @improved_loss_model.setter
+    def improved_loss_model(self, value):
+        expected_values = ["Level1", "Level2", "Level3"]
+        if isinstance(value, str) and value in expected_values:
+            self._simulation_settings.ImprovedLossModel = value
+        else:
+            self.logger.error(
+                "Property improved_loss_model expects a string value among "
+                f"'Level1', 'Level2' or 'Level3' while the provided value is {value}."
+            )
+
+    @property
+    def include_enhanced_bond_wire_modeling(self):
+        """Enhance Bond wire modeling.
+
+        Returns
+        -------
+            bool
+        """
+        return self._simulation_settings.IncludeEnhancedBondWireModeling
+
+    @include_enhanced_bond_wire_modeling.setter
+    def include_enhanced_bond_wire_modeling(self, value):
+        if isinstance(value, bool):
+            self._simulation_settings.IncludeEnhancedBondWireModeling = value
+        else:
+            self.logger.error(
+                "Property include_enhanced_bond_wire_modeling expects a "
+                f"boolean value while the provided value is {value}."
+            )
+
+    @property
+    def include_nets(self):
+        """Add Additional Nets for simulation.
+
+        Returns
+        -------
+            [str]
+            List of net name.
+        """
+        return list(self._simulation_settings.IncludeNets)
+
+    @include_nets.setter
+    def include_nets(self, value):
+        if isinstance(value, str):
+            value = [value]
+        if isinstance(value, list):
+            self._simulation_settings.IncludeNets = convert_py_list_to_net_list(value)
+        else:
+            self.logger.error(
+                f"Property include_nets expects a string or list of string while the provided value is {value}."
+            )
+
+    @property
+    def min_plane_area_to_mesh(self):
+        """The minimum area below which geometry is ignored.
+
+        Returns
+        -------
+            str
+        """
+        return self._simulation_settings.MinPlaneAreaToMesh
+
+    @min_plane_area_to_mesh.setter
+    def min_plane_area_to_mesh(self, value):
+        self._simulation_settings.MinPlaneAreaToMesh = self._pedb.edb_value(value).ToString()
+
+    @property
+    def min_void_area_to_mesh(self):
+        """The minimum area below which voids are ignored.
+
+        Returns
+        -------
+            str
+        """
+        return self._simulation_settings.MinVoidAreaToMesh
+
+    @min_void_area_to_mesh.setter
+    def min_void_area_to_mesh(self, value):
+        self._simulation_settings.MinVoidAreaToMesh = self._pedb.edb_value(value).ToString()
+
+    @property
+    def model_type(self):
+        """Model Type setting.
+
+        Returns
+        -------
+            int
+        Model type: ``0``=RDL, ``1``=Package, ``2``=PCB
+        """
+        return self._simulation_settings.ModelType
+
+    @model_type.setter
+    def model_type(self, value):
+        if isinstance(value, int) and value in range(3):
+            self._simulation_settings.ModelType = value
+        else:
+            self.logger.error(
+                f"Property model_type expects an integer value among 0, 1 or 2 while the provided value is {value}."
+            )
+
+    @property
+    def perform_erc(self):
+        """Perform ERC
+
+        Returns
+        -------
+            bool
+        """
+        return self._simulation_settings.PerformERC
+
+    @perform_erc.setter
+    def perform_erc(self, value):
+        if isinstance(value, bool):
+            self._simulation_settings.PerformERC = value
+        else:
+            self.logger.error(f"Property perform_erc expects a boolean value while the provided value is {value}.")
+
+    @property
+    def pi_slider_pos(self):
+        """The Simulation Preference Slider setting
+
+        Returns
+        -------
+            int
+        Model type: ``0``= balanced, ``1``=Accuracy.
+        """
+        return self._simulation_settings.PISliderPos
+
+    @pi_slider_pos.setter
+    def pi_slider_pos(self, value):
+        if isinstance(value, int) and value in range(2):
+            self._simulation_settings.PISliderPos = value
+        else:
+            self.logger.error(
+                f"Property pi_slider_pos expects an integer value among 0 or 1 while the provided value is {value}."
+            )
+
+    @property
+    def rms_surface_roughness(self):
+        """RMS Surface Roughness setting
+
+        Returns
+        -------
+            str
+        """
+        return self._simulation_settings.RMSSurfaceRoughness
+
+    @rms_surface_roughness.setter
+    def rms_surface_roughness(self, value):
+        self._simulation_settings.RMSSurfaceRoughness = self._pedb.edb_value(value).ToString()
+
+    @property
+    def signal_nets_conductor_modeling(self):
+        """Conductor Modeling
+
+        Returns
+        -------
+            str
+        Value: ``"MeshInside"`` or ``"ImpedanceBoundary"``.
+        """
+        return self._simulation_settings.SignalNetsConductorModeling
+
+    @signal_nets_conductor_modeling.setter
+    def signal_nets_conductor_modeling(self, value):
+        expected_values = ["MeshInside", "ImpedanceBoundary"]
+        if isinstance(value, str) and value in expected_values:
+            self._simulation_settings.SignalNetsConductorModeling = value
+        else:
+            self.logger.error(
+                "Property signal_nets_conductor_modeling expects a string value among "
+                f"'MeshInside' or 'ImpedanceBoundary' while the provided value is {value}."
+            )
+
+    @property
+    def signal_nets_error_tolerance(self):
+        """Error Tolerance
+
+        Returns
+        -------
+            str
+        Value between 0.02 and 1.
+        """
+        return self._simulation_settings.SignalNetsErrorTolerance
+
+    @signal_nets_error_tolerance.setter
+    def signal_nets_error_tolerance(self, value):
+        self._simulation_settings.SignalNetsErrorTolerance = self._pedb.edb_value(value).ToString()
+
+    @property
+    def signal_nets_include_improved_dielectric_fill_refinement(self):
+        return self._simulation_settings.SignalNetsIncludeImprovedDielectricFillRefinement
+
+    @signal_nets_include_improved_dielectric_fill_refinement.setter
+    def signal_nets_include_improved_dielectric_fill_refinement(self, value):
+        if isinstance(value, bool):
+            self._simulation_settings.SignalNetsIncludeImprovedDielectricFillRefinement = value
+        else:
+            self.logger.error(
+                "Property signal_nets_include_improved_dielectric_fill_refinement "
+                f"expects a boolean value while the provided value is {value}."
+            )
+
+    @property
+    def signal_nets_include_improved_loss_handling(self):
+        """Improved Dielectric Fill Refinement choice.
+
+        Returns
+        -------
+            bool
+        """
+        return self._simulation_settings.SignalNetsIncludeImprovedLossHandling
+
+    @signal_nets_include_improved_loss_handling.setter
+    def signal_nets_include_improved_loss_handling(self, value):
+        if isinstance(value, bool):
+            self._simulation_settings.SignalNetsIncludeImprovedLossHandling = value
+        else:
+            self.logger.error(
+                "Property signal_nets_include_improved_loss_handling "
+                f"expects a boolean value while the provided value is {value}."
+            )
+
+    @property
+    def snap_length_threshold(self):
+        return self._simulation_settings.SnapLengthThreshold
+
+    @snap_length_threshold.setter
+    def snap_length_threshold(self, value):
+        self._simulation_settings.SnapLengthThreshold = self._pedb.edb_value(value).ToString()
+
+    @property
+    def surface_roughness_model(self):
+        """Chosen Model setting
+
+        Returns
+        -------
+            str
+        Model allowed, ``"None"``, ``"Exponential"`` or ``"Hammerstad"``.
+        """
+        return self._simulation_settings.SurfaceRoughnessModel
+
+    @surface_roughness_model.setter
+    def surface_roughness_model(self, value):
+        expected_values = ["None", "Exponential", "Hammerstad"]
+        if isinstance(value, str) and value in expected_values:
+            self._simulation_settings.SurfaceRoughnessModel = value
+        else:
+            self.logger.error(
+                "Property surface_roughness_model expects a string value among "
+                f"'None', 'Exponential' or 'Hammerstad' while the provided value is {value}."
+            )

pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -60,11 +60,13 @@ class EDBPadProperties(object):
     """
 
     def __init__(self, edb_padstack, layer_name, pad_type, p_edb_padstack):
-        self._edb_padstack = edb_padstack
+        self._edb_object = edb_padstack
         self._pedbpadstack = p_edb_padstack
         self.layer_name = layer_name
         self.pad_type = pad_type
 
+        self._edb_padstack = self._edb_object
+
     @property
     def _padstack_methods(self):
         return self._pedbpadstack._padstack_methods
@@ -1195,6 +1197,12 @@ class EDBPadstackInstance(EDBPrimitivesMain):
 
     @pyedb_function_handler()
     def _create_terminal(self, name=None):
+        """Create a padstack instance terminal"""
+        warnings.warn("`_create_terminal` is deprecated. Use `create_terminal` instead.", DeprecationWarning)
+        return self.create_terminal(name)
+
+    @pyedb_function_handler
+    def create_terminal(self, name=None):
         """Create a padstack instance terminal"""
         from pyedb.dotnet.edb_core.edb_data.terminals import PadstackInstanceTerminal
 
@@ -1618,6 +1626,14 @@ class EDBPadstackInstance(EDBPrimitivesMain):
         """
         self._edb_padstackinstance.SetIsLayoutPin(pin)
 
+    @property
+    def component(self):
+        """Component."""
+        from pyedb.dotnet.edb_core.edb_data.components_data import EDBComponent
+
+        comp = EDBComponent(self._pedb, self._edb_object.GetComponent())
+        return comp if not comp.is_null else False
+
     @property
     def position(self):
         """Padstack instance position.

pyedb/dotnet/edb_core/edb_data/raptor_x_simulation_setup_data.py

@@ -74,10 +74,6 @@ class RaptorXSimulationSetup(BaseSimulationSetup):
         else:
             self.logger.error(f"RaptorX setup position input setter must be an integer. Provided value {value}")
 
-    @property
-    def frequency_sweeps(self):
-        return list(self._edb_setup_info.SweepDataList)
-
     @pyedb_function_handler()
     def add_frequency_sweep(self, name=None, frequency_sweep=None):
         """Add frequency sweep.

pyedb/dotnet/edb_core/edb_data/siwave_simulation_setup_data.py

@@ -26,8 +26,10 @@ from pyedb.dotnet.edb_core.general import (
     convert_netdict_to_pydict,
     convert_pydict_to_netdict,
 )
+from pyedb.dotnet.edb_core.sim_setup_data.data.siw_dc_ir_settings import (
+    SiwaveDCIRSettings,
+)
 from pyedb.dotnet.edb_core.utilities.simulation_setup import BaseSimulationSetup
-from pyedb.dotnet.sim_setup_data.data.siw_dc_ir_settings import SiwaveDCIRSettings
 from pyedb.generic.general_methods import is_linux, pyedb_function_handler
 
 
@@ -986,7 +988,7 @@ class SiwaveSYZSimulationSetup(BaseSimulationSetup):
                 val = val.replace("SourceTermsToGround(", "").replace(")", "").split(",")
                 for v in val:
                     source = v.split("=")
-                    sources[source[0]] = source[1]
+                    sources[source[0]] = int(source[1].replace("'", ""))
                 edb_sim_setup_info.SimulationSettings.DCIRSettings.SourceTermsToGround = convert_pydict_to_netdict(
                     sources
                 )