pyedb 0.15.dev0__py3-none-any.whl → 0.17.0__py3-none-any.whl

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

@@ -20,6 +20,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+import warnings
+
 
 class SweepData(object):
     """Manages EDB methods for a frequency sweep.
@@ -29,58 +31,42 @@ class SweepData(object):
     sim_setup : :class:`pyedb.dotnet.edb_core.edb_data.siwave_simulation_setup_data.SiwaveSYZSimulationSetup`
     name : str, optional
         Name of the frequency sweep.
-    edb_sweep_data : :class:`Ansys.Ansoft.Edb.Utility.SIWDCIRSimulationSettings`, optional
+    edb_object : :class:`Ansys.Ansoft.Edb.Utility.SIWDCIRSimulationSettings`, optional
         EDB object. The default is ``None``.
     """
 
-    def __init__(self, sim_setup, frequency_sweep=None, name=None, edb_sweep_data=None):
-        self._sim_setup = sim_setup
+    def __init__(self, pedb, edb_object=None, name: str = None, sim_setup=None):
+        self._pedb = pedb
+        self.sim_setup = sim_setup
 
-        if edb_sweep_data:
-            self._edb_sweep_data = edb_sweep_data
-            self._name = self._edb_sweep_data.Name
+        if edb_object is not None:
+            self._edb_object = edb_object
+            self._name = self._edb_object.Name
         else:
-            if not name:
-                self._name = generate_unique_name("sweep")
-            else:
-                self._name = name
-            self._edb_sweep_data = self._pedb.simsetupdata.SweepData(self._name)
-            self.set_frequencies(frequency_sweep)
-
-    @property
-    def _edb_object(self):
-        return self._edb_sweep_data
-
-    @property
-    def _pedb(self):
-        """EDB."""
-        return self._sim_setup._pedb
+            self._name = name
+            self._edb_object = self._pedb.simsetupdata.SweepData(self._name)
+            self.clear()
 
     def _update_sweep(self):
         """Update the sweep."""
-        self._sim_setup.delete_frequency_sweep(self)
-        self._sim_setup._add_frequency_sweep(self)
+        self.sim_setup.delete_frequency_sweep(self)
+        self.sim_setup._add_frequency_sweep(self)
         return
 
     @property
     def name(self):
         """Name of the sweep."""
-        return self._edb_sweep_data.Name
+        return self._edb_object.Name
 
     @name.setter
     def name(self, value):
-        self._edb_sweep_data.Name = value
+        self._edb_object.Name = value
         self._update_sweep()
 
-    @property
-    def sweep_type(self):
-        """Sweep type."""
-        return
-
     @property
     def frequencies(self):
         """List of frequency points."""
-        return list(self._edb_sweep_data.Frequencies)
+        return [float(i) for i in list(self._edb_object.Frequencies)]
 
     @property
     def adaptive_sampling(self):
@@ -91,7 +77,7 @@ class SweepData(object):
         bool
             ``True`` if adaptive sampling is used, ``False`` otherwise.
         """
-        return self._edb_sweep_data.AdaptiveSampling
+        return self._edb_object.AdaptiveSampling
 
     @property
     def adv_dc_extrapolation(self):
@@ -102,22 +88,22 @@ class SweepData(object):
         bool
             ``True`` if advanced DC Extrapolation is used, ``False`` otherwise.
         """
-        return self._edb_sweep_data.AdvDCExtrapolation
+        return self._edb_object.AdvDCExtrapolation
 
     @property
     def compute_dc_point(self):
         """Flag indicating if computing the exact DC point is turned on."""
-        return self._edb_sweep_data.ComputeDCPoint
+        return self._edb_object.ComputeDCPoint
 
     @compute_dc_point.setter
     def compute_dc_point(self, value):
-        self._edb_sweep_data.ComputeDCPoint = value
+        self._edb_object.ComputeDCPoint = value
         self._update_sweep()
 
     @property
     def auto_s_mat_only_solve(self):
         """Flag indicating if Auto SMatrix only solve is turned on."""
-        return self._edb_sweep_data.AutoSMatOnlySolve
+        return self._edb_object.AutoSMatOnlySolve
 
     @property
     def enforce_causality(self):
@@ -128,7 +114,7 @@ class SweepData(object):
         bool
             ``True`` if enforce causality is used, ``False`` otherwise.
         """
-        return self._edb_sweep_data.EnforceCausality
+        return self._edb_object.EnforceCausality
 
     @property
     def enforce_dc_and_causality(self):
@@ -139,7 +125,7 @@ class SweepData(object):
         bool
             ``True`` if enforce dc point and causality is used, ``False`` otherwise.
         """
-        return self._edb_sweep_data.EnforceDCAndCausality
+        return self._edb_object.EnforceDCAndCausality
 
     @property
     def enforce_passivity(self):
@@ -150,7 +136,7 @@ class SweepData(object):
         bool
             ``True`` if enforce passivity is used, ``False`` otherwise.
         """
-        return self._edb_sweep_data.EnforcePassivity
+        return self._edb_object.EnforcePassivity
 
     @property
     def freq_sweep_type(self):
@@ -166,7 +152,40 @@ class SweepData(object):
         str
             Sweep type.
         """
-        return self._edb_sweep_data.FreqSweepType.ToString()
+        return self._edb_object.FreqSweepType.ToString()
+
+    @freq_sweep_type.setter
+    def freq_sweep_type(self, value):
+        edb_freq_sweep_type = self._edb_object.TFreqSweepType
+        if value in [0, "kInterpolatingSweep"]:
+            self._edb_object.FreqSweepType = edb_freq_sweep_type.kInterpolatingSweep
+        elif value in [1, "kDiscreteSweep"]:
+            self._edb_object.FreqSweepType = edb_freq_sweep_type.kDiscreteSweep
+        elif value in [2, "kBroadbandFastSweep"]:
+            self._edb_object.FreqSweepType = edb_freq_sweep_type.kBroadbandFastSweep
+        elif value in [3, "kNumSweepTypes"]:
+            self._edb_object.FreqSweepType = edb_freq_sweep_type.kNumSweepTypes
+        self._edb_object.FreqSweepType.ToString()
+
+    @property
+    def type(self):
+        """Sweep type."""
+        sw_type = self.freq_sweep_type
+        if sw_type == "kInterpolatingSweep":
+            return "interpolation"
+        elif sw_type == "kDiscreteSweep":
+            return "discrete"
+        elif sw_type == "kBroadbandFastSweep":
+            return "broadband"
+
+    @type.setter
+    def type(self, value):
+        if value == "interpolation":
+            self.freq_sweep_type = "kInterpolatingSweep"
+        elif value == "discrete":
+            self.freq_sweep_type = "kDiscreteSweep"
+        elif value == "broadband":
+            self.freq_sweep_type = "kBroadbandFastSweep"
 
     @property
     def interpolation_use_full_basis(self):
@@ -177,7 +196,7 @@ class SweepData(object):
         bool
             ``True`` if full basis interpolation is used, ``False`` otherwise.
         """
-        return self._edb_sweep_data.InterpUseFullBasis
+        return self._edb_object.InterpUseFullBasis
 
     @property
     def interpolation_use_port_impedance(self):
@@ -188,7 +207,7 @@ class SweepData(object):
         bool
             ``True`` if port impedance is used, ``False`` otherwise.
         """
-        return self._edb_sweep_data.InterpUsePortImpedance
+        return self._edb_object.InterpUsePortImpedance
 
     @property
     def interpolation_use_prop_const(self):
@@ -199,7 +218,7 @@ class SweepData(object):
         bool
             ``True`` if propagation constants are used, ``False`` otherwise.
         """
-        return self._edb_sweep_data.InterpUsePropConst
+        return self._edb_object.InterpUsePropConst
 
     @property
     def interpolation_use_s_matrix(self):
@@ -210,7 +229,7 @@ class SweepData(object):
         bool
             ``True`` if S matrix are used, ``False`` otherwise.
         """
-        return self._edb_sweep_data.InterpUseSMatrix
+        return self._edb_object.InterpUseSMatrix
 
     @property
     def max_solutions(self):
@@ -220,7 +239,7 @@ class SweepData(object):
         -------
         int
         """
-        return self._edb_sweep_data.MaxSolutions
+        return self._edb_object.MaxSolutions
 
     @property
     def min_freq_s_mat_only_solve(self):
@@ -231,7 +250,7 @@ class SweepData(object):
         str
             Frequency with units.
         """
-        return self._edb_sweep_data.MinFreqSMatOnlySolve
+        return self._edb_object.MinFreqSMatOnlySolve
 
     @property
     def min_solved_freq(self):
@@ -242,7 +261,7 @@ class SweepData(object):
         str
             Frequency with units.
         """
-        return self._edb_sweep_data.MinSolvedFreq
+        return self._edb_object.MinSolvedFreq
 
     @property
     def passivity_tolerance(self):
@@ -252,7 +271,7 @@ class SweepData(object):
         -------
         float
         """
-        return self._edb_sweep_data.PassivityTolerance
+        return self._edb_object.PassivityTolerance
 
     @property
     def relative_s_error(self):
@@ -262,7 +281,7 @@ class SweepData(object):
         -------
         float
         """
-        return self._edb_sweep_data.RelativeSError
+        return self._edb_object.RelativeSError
 
     @property
     def save_fields(self):
@@ -273,7 +292,7 @@ class SweepData(object):
         bool
             ``True`` if save fields is enabled, ``False`` otherwise.
         """
-        return self._edb_sweep_data.SaveFields
+        return self._edb_object.SaveFields
 
     @property
     def save_rad_fields_only(self):
@@ -284,7 +303,7 @@ class SweepData(object):
         bool
             ``True`` if save radiated field only is used, ``False`` otherwise.
         """
-        return self._edb_sweep_data.SaveRadFieldsOnly
+        return self._edb_object.SaveRadFieldsOnly
 
     @property
     def use_q3d_for_dc(self):
@@ -295,113 +314,101 @@ class SweepData(object):
         bool
             ``True`` if Q3d for DC point is used, ``False`` otherwise.
         """
-        return self._edb_sweep_data.UseQ3DForDC
+        return self._edb_object.UseQ3DForDC
 
     @adaptive_sampling.setter
     def adaptive_sampling(self, value):
-        self._edb_sweep_data.AdaptiveSampling = value
+        self._edb_object.AdaptiveSampling = value
         self._update_sweep()
 
     @adv_dc_extrapolation.setter
     def adv_dc_extrapolation(self, value):
-        self._edb_sweep_data.AdvDCExtrapolation = value
+        self._edb_object.AdvDCExtrapolation = value
         self._update_sweep()
 
     @auto_s_mat_only_solve.setter
     def auto_s_mat_only_solve(self, value):
-        self._edb_sweep_data.AutoSMatOnlySolve = value
+        self._edb_object.AutoSMatOnlySolve = value
         self._update_sweep()
 
     @enforce_causality.setter
     def enforce_causality(self, value):
-        self._edb_sweep_data.EnforceCausality = value
+        self._edb_object.EnforceCausality = value
         self._update_sweep()
 
     @enforce_dc_and_causality.setter
     def enforce_dc_and_causality(self, value):
-        self._edb_sweep_data.EnforceDCAndCausality = value
+        self._edb_object.EnforceDCAndCausality = value
         self._update_sweep()
 
     @enforce_passivity.setter
     def enforce_passivity(self, value):
-        self._edb_sweep_data.EnforcePassivity = value
+        self._edb_object.EnforcePassivity = value
         self._update_sweep()
 
-    @freq_sweep_type.setter
-    def freq_sweep_type(self, value):
-        edb_freq_sweep_type = self._edb_sweep_data.TFreqSweepType
-        if value in [0, "kInterpolatingSweep"]:
-            self._edb_sweep_data.FreqSweepType = edb_freq_sweep_type.kInterpolatingSweep
-        elif value in [1, "kDiscreteSweep"]:
-            self._edb_sweep_data.FreqSweepType = edb_freq_sweep_type.kDiscreteSweep
-        elif value in [2, "kBroadbandFastSweep"]:
-            self._edb_sweep_data.FreqSweepType = edb_freq_sweep_type.kBroadbandFastSweep
-        elif value in [3, "kNumSweepTypes"]:
-            self._edb_sweep_data.FreqSweepType = edb_freq_sweep_type.kNumSweepTypes
-        self._edb_sweep_data.FreqSweepType.ToString()
-
     @interpolation_use_full_basis.setter
     def interpolation_use_full_basis(self, value):
-        self._edb_sweep_data.InterpUseFullBasis = value
+        self._edb_object.InterpUseFullBasis = value
         self._update_sweep()
 
     @interpolation_use_port_impedance.setter
     def interpolation_use_port_impedance(self, value):
-        self._edb_sweep_data.InterpUsePortImpedance = value
+        self._edb_object.InterpUsePortImpedance = value
         self._update_sweep()
 
     @interpolation_use_prop_const.setter
     def interpolation_use_prop_const(self, value):
-        self._edb_sweep_data.InterpUsePropConst = value
+        self._edb_object.InterpUsePropConst = value
         self._update_sweep()
 
     @interpolation_use_s_matrix.setter
     def interpolation_use_s_matrix(self, value):
-        self._edb_sweep_data.InterpUseSMatrix = value
+        self._edb_object.InterpUseSMatrix = value
         self._update_sweep()
 
     @max_solutions.setter
     def max_solutions(self, value):
-        self._edb_sweep_data.MaxSolutions = value
+        self._edb_object.MaxSolutions = value
         self._update_sweep()
 
     @min_freq_s_mat_only_solve.setter
     def min_freq_s_mat_only_solve(self, value):
-        self._edb_sweep_data.MinFreqSMatOnlySolve = value
+        self._edb_object.MinFreqSMatOnlySolve = value
         self._update_sweep()
 
     @min_solved_freq.setter
     def min_solved_freq(self, value):
-        self._edb_sweep_data.MinSolvedFreq = value
+        self._edb_object.MinSolvedFreq = value
         self._update_sweep()
 
     @passivity_tolerance.setter
     def passivity_tolerance(self, value):
-        self._edb_sweep_data.PassivityTolerance = value
+        self._edb_object.PassivityTolerance = value
         self._update_sweep()
 
     @relative_s_error.setter
     def relative_s_error(self, value):
-        self._edb_sweep_data.RelativeSError = value
+        self._edb_object.RelativeSError = value
         self._update_sweep()
 
     @save_fields.setter
     def save_fields(self, value):
-        self._edb_sweep_data.SaveFields = value
+        self._edb_object.SaveFields = value
         self._update_sweep()
 
     @save_rad_fields_only.setter
     def save_rad_fields_only(self, value):
-        self._edb_sweep_data.SaveRadFieldsOnly = value
+        self._edb_object.SaveRadFieldsOnly = value
         self._update_sweep()
 
     @use_q3d_for_dc.setter
     def use_q3d_for_dc(self, value):
-        self._edb_sweep_data.UseQ3DForDC = value
+        self._edb_object.UseQ3DForDC = value
         self._update_sweep()
 
     def _set_frequencies(self, freq_sweep_string="Linear Step: 0GHz to 20GHz, step=0.05GHz"):
-        self._edb_sweep_data.SetFrequencies(freq_sweep_string)
+        warnings.warn("Use new property :func:`add` instead.", DeprecationWarning)
+        self._edb_object.SetFrequencies(freq_sweep_string)
         self._update_sweep()
 
     def set_frequencies_linear_scale(self, start="0.1GHz", stop="20GHz", step="50MHz"):
@@ -421,7 +428,8 @@ class SweepData(object):
         bool
             ``True`` if correctly executed, ``False`` otherwise.
         """
-        self._edb_sweep_data.Frequencies = self._edb_sweep_data.SetFrequencies(start, stop, step)
+        warnings.warn("Use new property :func:`add` instead.", DeprecationWarning)
+        self._edb_object.Frequencies = self._edb_object.SetFrequencies(start, stop, step)
         return self._update_sweep()
 
     def set_frequencies_linear_count(self, start="1kHz", stop="0.1GHz", count=10):
@@ -441,9 +449,10 @@ class SweepData(object):
         bool
             ``True`` if correctly executed, ``False`` otherwise.
         """
-        start = self._sim_setup._pedb.arg_to_dim(start, "Hz")
-        stop = self._sim_setup._pedb.arg_to_dim(stop, "Hz")
-        self._edb_sweep_data.Frequencies = self._edb_sweep_data.SetFrequencies(start, stop, count)
+        warnings.warn("Use new property :func:`add` instead.", DeprecationWarning)
+        start = self.sim_setup._pedb.arg_to_dim(start, "Hz")
+        stop = self.sim_setup._pedb.arg_to_dim(stop, "Hz")
+        self._edb_object.Frequencies = self._edb_object.SetFrequencies(start, stop, count)
         return self._update_sweep()
 
     def set_frequencies_log_scale(self, start="1kHz", stop="0.1GHz", samples=10):
@@ -463,9 +472,10 @@ class SweepData(object):
         bool
             ``True`` if correctly executed, ``False`` otherwise.
         """
-        start = self._sim_setup._pedb.arg_to_dim(start, "Hz")
-        stop = self._sim_setup._pedb.arg_to_dim(stop, "Hz")
-        self._edb_sweep_data.Frequencies = self._edb_sweep_data.SetLogFrequencies(start, stop, samples)
+        warnings.warn("Use new property :func:`add` instead.", DeprecationWarning)
+        start = self.sim_setup._pedb.arg_to_dim(start, "Hz")
+        stop = self.sim_setup._pedb.arg_to_dim(stop, "Hz")
+        self._edb_object.Frequencies = self._edb_object.SetLogFrequencies(start, stop, samples)
         return self._update_sweep()
 
     def set_frequencies(self, frequency_list=None, update=True):
@@ -484,6 +494,7 @@ class SweepData(object):
         bool
             ``True`` if correctly executed, ``False`` otherwise.
         """
+        warnings.warn("Use new property :func:`add` instead.", DeprecationWarning)
         if not frequency_list:
             frequency_list = [
                 ["linear count", "0", "1kHz", 1],
@@ -495,15 +506,39 @@ class SweepData(object):
             frequency_list = [frequency_list]
         for i in frequency_list:
             if i[0] == "linear count":
-                temp.extend(list(self._edb_sweep_data.SetFrequencies(i[1], i[2], i[3])))
+                temp.extend(list(self._edb_object.SetFrequencies(i[1], i[2], i[3])))
             elif i[0] == "linear scale":
-                temp.extend(list(self._edb_sweep_data.SetFrequencies(i[1], i[2], i[3])))
+                temp.extend(list(self._edb_object.SetFrequencies(i[1], i[2], i[3])))
             elif i[0] == "log scale":
-                temp.extend(list(self._edb_sweep_data.SetLogFrequencies(i[1], i[2], i[3])))
+                temp.extend(list(self._edb_object.SetLogFrequencies(i[1], i[2], i[3])))
             else:
                 return False
-        self._edb_sweep_data.Frequencies.Clear()
+        self._edb_object.Frequencies.Clear()
         for i in temp:
-            self._edb_sweep_data.Frequencies.Add(i)
+            self._edb_object.Frequencies.Add(i)
         if update:
             return self._update_sweep()
+
+    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))
+        else:
+            raise ValueError("sweep_type must be either 'linear_count', 'linear_scale' or 'log_scale")
+        return self.add_frequencies(freqs)
+
+    def add_frequencies(self, frequencies):
+        if not isinstance(frequencies, list):
+            frequencies = [frequencies]
+        for i in frequencies:
+            i = self._pedb.edb_value(i).ToString()
+            self._edb_object.Frequencies.Add(i)
+        return list(self._edb_object.Frequencies)
+
+    def clear(self):
+        self._edb_object.Frequencies.Clear()

pyedb/dotnet/edb_core/siwave.py

@@ -43,6 +43,7 @@ from pyedb.dotnet.edb_core.edb_data.sources import (
 from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 from pyedb.generic.constants import SolverType, SweepType
 from pyedb.generic.general_methods import _retry_ntimes, generate_unique_name
+from pyedb.misc.siw_feature_config.xtalk_scan.scan_config import SiwaveScanConfig
 from pyedb.modeler.geometry_operators import GeometryOperators
 
 
@@ -113,6 +114,11 @@ class EdbSiwave(object):
         """Get all probes."""
         return self._pedb.probes
 
+    @property
+    def voltage_regulator_modules(self):
+        """Get all voltage regulator modules"""
+        return self._pedb.voltage_regulator_modules
+
     @property
     def pin_groups(self):
         """All Layout Pin groups.
@@ -1429,6 +1435,50 @@ class EdbSiwave(object):
         n_terminal = self._pedb.get_point_terminal(name + "_ref", negative_net_name, negative_location, negative_layer)
         return self._pedb.create_voltage_probe(p_terminal, n_terminal)
 
+    def create_vrm_module(
+        self,
+        name=None,
+        is_active=True,
+        voltage="3V",
+        positive_sensor_pin=None,
+        negative_sensor_pin=None,
+        load_regulation_current="1A",
+        load_regulation_percent=0.1,
+    ):
+        """Create a voltage regulator module.
+
+        Parameters
+        ----------
+        name : str
+            Name of the voltage regulator.
+        is_active : bool optional
+            Set the voltage regulator active or not. Default value is ``True``.
+        voltage ; str, float
+            Set the voltage value.
+        positive_sensor_pin : int, .class pyedb.dotnet.edb_core.edb_data.padstacks_data.EDBPadstackInstance
+            defining the positive sensor pin.
+        negative_sensor_pin : int, .class pyedb.dotnet.edb_core.edb_data.padstacks_data.EDBPadstackInstance
+            defining the negative sensor pin.
+        load_regulation_current : str or float
+            definition the load regulation current value.
+        load_regulation_percent : float
+            definition the load regulation percent value.
+        """
+        from pyedb.dotnet.edb_core.cell.voltage_regulator import VoltageRegulator
+
+        voltage = self._pedb.edb_value(voltage)
+        load_regulation_current = self._pedb.edb_value(load_regulation_current)
+        load_regulation_percent = self._pedb.edb_value(load_regulation_percent)
+        edb_vrm = self._edb_object = self._pedb._edb.Cell.VoltageRegulator.Create(
+            self._pedb.active_layout, name, is_active, voltage, load_regulation_current, load_regulation_percent
+        )
+        vrm = VoltageRegulator(self._pedb, edb_vrm)
+        if positive_sensor_pin:
+            vrm.positive_remote_sense_pin = positive_sensor_pin
+        if negative_sensor_pin:
+            vrm.negative_remote_sense_pin = negative_sensor_pin
+        return vrm
+
     @property
     def icepak_use_minimal_comp_defaults(self):
         """Icepak default setting. If "True", only resistor are active in Icepak simulation.
@@ -1439,6 +1489,19 @@ class EdbSiwave(object):
         _, value = cell.GetProductProperty(siwave_id, 422, "")
         return bool(value)
 
+    def create_impedance_crosstalk_scan(self, scan_type="impedance"):
+        """Create Siwave crosstalk scan object
+
+        Parameters
+        ----------
+        scan_type : str
+            Scan type to be analyzed. 3 options are available, ``impedance`` for frequency impedance scan,
+            ``frequency_xtalk`` for frequency domain crosstalk and ``time_xtalk`` for time domain crosstalk.
+            Default value is ``frequency``.
+
+        """
+        return SiwaveScanConfig(self._pedb, scan_type)
+
     @icepak_use_minimal_comp_defaults.setter
     def icepak_use_minimal_comp_defaults(self, value):
         value = "True" if bool(value) else ""