pyedb 0.60.0__py3-none-any.whl → 0.61.0__py3-none-any.whl

pyedb/__init__.py

@@ -59,7 +59,7 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.60.0"
+__version__ = "0.61.0"
 version = __version__
 
 #

pyedb/configuration/cfg_components.py

@@ -98,14 +98,42 @@ class CfgComponent(CfgBase):
             m = self._pedb._edb.Cell.Hierarchy.PinPairModel()
             for i in self.pin_pair_model:
                 p = self._pedb._edb.Utility.PinPair(str(i["first_pin"]), str(i["second_pin"]))
+                res = i.get("resistance")
+                if res is None:
+                    # If resistance is not defined, set it to 0 and disable it
+                    res = "0ohm"
+                    en_res = False
+                else:
+                    # If resistance is defined, use the provided value and enabled status
+                    res = i["resistance"]
+                    en_res = i.get("resistance_enabled", True)
+                ind = i.get("inductance")
+                if ind is None:
+                    # If inductance is not defined, set it to 0 and disable it
+                    ind = "0nH"
+                    en_ind = False
+                else:
+                    # If inductance is defined, use the provided value and enabled status
+                    ind = i["inductance"]
+                    en_ind = i.get("inductance_enabled", True)
+                cap = i.get("capacitance")
+                if cap is None:
+                    # If capacitance is not defined, set it to 0 and disable it
+                    cap = "0pF"
+                    en_cap = False
+                else:
+                    # If capacitance is defined, use the provided value and enabled status
+                    cap = i["capacitance"]
+                    en_cap = i.get("capacitance_enabled", True)
+
                 rlc = self._pedb._edb.Utility.Rlc(
-                    self._pedb.edb_value(i["resistance"]),
-                    i["resistance_enabled"],
-                    self._pedb.edb_value(i["inductance"]),
-                    i["inductance_enabled"],
-                    self._pedb.edb_value(i["capacitance"]),
-                    i["capacitance_enabled"],
-                    i["is_parallel"],
+                    self._pedb.edb_value(res),
+                    en_res,
+                    self._pedb.edb_value(ind),
+                    en_ind,
+                    self._pedb.edb_value(cap),
+                    en_cap,
+                    i.get("is_parallel", False),
                 )
                 m.SetPinPairRlc(p, rlc)
             c_p.SetModel(m)

pyedb/dotnet/database/cell/hierarchy/component.py

@@ -28,11 +28,11 @@ import warnings
 import numpy as np
 
 from pyedb.dotnet.database.cell.hierarchy.hierarchy_obj import Group
-from pyedb.dotnet.database.cell.hierarchy.model import PinPairModel, SPICEModel
+from pyedb.dotnet.database.cell.hierarchy.model import PinPairModel
 from pyedb.dotnet.database.cell.hierarchy.netlist_model import NetlistModel
 from pyedb.dotnet.database.cell.hierarchy.pin_pair_model import PinPair
-from pyedb.dotnet.database.cell.hierarchy.s_parameter_model import SparamModel
-from pyedb.dotnet.database.cell.hierarchy.spice_model import SpiceModel
+from pyedb.dotnet.database.cell.hierarchy.s_parameter_model import SParameterModel
+from pyedb.dotnet.database.cell.hierarchy.spice_model import SPICEModel
 from pyedb.dotnet.database.definition.package_def import PackageDef
 from pyedb.dotnet.database.edb_data.padstacks_data import EDBPadstackInstance
 from pyedb.generic.general_methods import get_filename_without_extension
@@ -148,11 +148,13 @@ class EDBComponent(Group):
     def model(self):
         """Component model."""
         edb_object = self.component_property.GetModel().Clone()
-        model_type = edb_object.ToString().split(".")[-1]
+        model_type = edb_object.GetModelType().ToString()
         if model_type == "PinPairModel":
             return PinPairModel(self._pedb, edb_object)
         elif model_type == "SPICEModel":
             return SPICEModel(self._pedb, edb_object)
+        elif model_type == "SParameterModel":
+            return SParameterModel(self._pedb, edb_object)
 
     @model.setter
     def model(self, value):
@@ -261,7 +263,7 @@ class EDBComponent(Group):
         if not self.model_type == "SPICEModel":
             return None
         else:
-            return SpiceModel(self._edb_model)
+            return SPICEModel(self._pedb, self._edb_model)
 
     @property
     def s_param_model(self):
@@ -269,7 +271,7 @@ class EDBComponent(Group):
         if not self.model_type == "SParameterModel":
             return None
         else:
-            return SparamModel(self._edb_model)
+            return SParameterModel(self._pedb, self._edb_model)
 
     @property
     def netlist_model(self):

pyedb/dotnet/database/cell/hierarchy/model.py

@@ -33,7 +33,7 @@ class Model(ObjBase):
     @property
     def model_type(self):
         """Component model type."""
-        return self._edb_object.GetModelType()
+        return self._edb_object.GetModelType().ToString()
 
 
 class PinPairModel(Model):
@@ -73,30 +73,3 @@ class PinPairModel(Model):
         bool
         """
         return self._edb_object.SetPinPairRlc(pin_pair, pin_par_rlc)
-
-
-class SParameterModel(Model):
-    """Manages S-parameter model class."""
-
-    def __init__(self, pedb, edb_object=None):
-        super().__init__(pedb, edb_object)
-
-    def component_model_name(self):
-        self._edb_object.GetComponentModelName()
-
-
-class SPICEModel(Model):
-    """Manages SPICE model class."""
-
-    def __init__(self, pedb, edb_object=None):
-        super().__init__(pedb, edb_object)
-
-    @property
-    def model_name(self):
-        """SPICE model name."""
-        return self._edb_object.GetModelName()
-
-    @property
-    def spice_file_path(self):
-        """SPICE file path."""
-        return self._edb_object.GetSPICEFilePath()

pyedb/dotnet/database/cell/hierarchy/s_parameter_model.py

@@ -20,22 +20,18 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from pyedb.dotnet.database.cell.hierarchy.model import Model
 
-class SparamModel(object):  # pragma: no cover
-    def __init__(self, edb_model):
-        self._edb_model = edb_model
 
-    @property
-    def name(self):
-        return self._edb_model.GetComponentModelName()
+class SParameterModel(Model):
+    """Manages S-parameter model class."""
 
-    @property
-    def reference_net(self):
-        return self._edb_model.GetReferenceNet()
+    def __init__(self, pedb, edb_object=None):
+        super().__init__(pedb, edb_object)
+
+    def component_model_name(self):
+        self._edb_object.GetComponentModelName()
 
     @property
-    def is_null(self):
-        """Adding this property to be compatible with grpc."""
-        if self.name:
-            return False
-        return True
+    def reference_net(self):
+        return self._edb_object.GetReferenceNet()

pyedb/dotnet/database/cell/hierarchy/spice_model.py

@@ -20,15 +20,21 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from pyedb.dotnet.database.cell.hierarchy.model import Model
 
-class SpiceModel(object):  # pragma: no cover
-    def __init__(self, edb_model):
-        self._edb_model = edb_model
+
+class SPICEModel(Model):
+    """Manages SPICE model class."""
+
+    def __init__(self, pedb, edb_object=None):
+        super().__init__(pedb, edb_object)
 
     @property
-    def file_path(self):
-        return self._edb_model.GetSPICEFilePath()
+    def model_name(self):
+        """SPICE model name."""
+        return self._edb_object.GetModelName()
 
     @property
-    def name(self):
-        return self._edb_model.GetSPICEName()
+    def spice_file_path(self):
+        """SPICE file path."""
+        return self._edb_object.GetSPICEFilePath()

pyedb/dotnet/database/components.py

@@ -2374,7 +2374,11 @@ class Components(object):
                     continue
                 part_name = comp.partname
                 comp_type = comp.type
-                if comp_type == "Resistor":
+                if not comp.model:
+                    print("")
+                elif comp.model.model_type != "PinPairModel":
+                    value = ""
+                elif comp_type == "Resistor":
                     value = str(comp.res_value)
                 elif comp_type == "Capacitor":
                     value = str(comp.cap_value)

pyedb/dotnet/database/edb_data/padstacks_data.py

@@ -1586,10 +1586,12 @@ class EDBPadstackInstance(Connectable):
                 False,
             )
 
-    def set_back_drill_by_layer(self, drill_to_layer, diameter, offset):
+    def set_back_drill_by_layer(self, drill_to_layer, diameter, offset, from_bottom=True):
         """Method added to bring compatibility with grpc."""
-
-        self.set_backdrill_bottom(drill_depth=drill_to_layer.name, drill_diameter=diameter, offset=offset)
+        if from_bottom:
+            if not isinstance(drill_to_layer, str):
+                drill_to_layer = drill_to_layer.name
+            self.set_backdrill_bottom(drill_depth=drill_to_layer, drill_diameter=diameter, offset=offset)
 
     def set_backdrill_bottom(self, drill_depth, drill_diameter, offset=0.0):
         """Set backdrill from bottom.

pyedb/dotnet/database/modeler.py

@@ -1474,7 +1474,8 @@ class Modeler(object):
         """Create a PinGroup.
 
         Parameters
-        name : str,
+        ----------
+        name : str
             Name of the PinGroup.
         pins_by_id : list[int] or None
             List of pins by ID.

pyedb/dotnet/database/padstack.py

@@ -26,7 +26,7 @@ This module contains the `EdbPadstacks` class.
 
 from collections import defaultdict
 import math
-from typing import Dict, List
+from typing import Dict, List, Optional, Union
 import warnings
 
 import numpy as np
@@ -442,6 +442,192 @@ class EdbPadstacks(object):
                 )
         PadStack.SetData(new_PadStackData)
 
+    def create_dielectric_filled_backdrills(
+        self,
+        layer: str,
+        diameter: Union[float, str],
+        material: str,
+        permittivity: float,
+        padstack_instances: Optional[List[EDBPadstackInstance]] = None,
+        padstack_definition: Optional[Union[str, List[str]]] = None,
+        dielectric_loss_tangent: Optional[float] = None,
+        nets: Optional[Union[str, List[str]]] = None,
+    ) -> bool:
+        r"""Create dielectric-filled back-drills for through-hole vias.
+
+        Back-drilling (a.k.a. controlled-depth drilling) is used to remove the
+        unused via stub that acts as an unterminated transmission-line segment,
+        thereby improving signal-integrity at high frequencies.  This routine
+        goes one step further: after the stub is removed the resulting cylindrical
+        cavity is **completely filled** with a user-specified dielectric.  The
+        fill material restores mechanical rigidity, prevents solder-wicking, and
+        keeps the original via’s electrical characteristics intact on the
+        remaining, still-plated, portion.
+
+        Selection criteria
+        ------------------
+        A via is processed only when **all** of the following are true:
+
+        1. It is a through-hole structure (spans at least three metal layers).
+        2. It includes the requested ``layer`` somewhere in its layer span.
+        3. It belongs to one of the supplied ``padstack_definition`` names
+           (or to *any* definition if the argument is omitted).
+        4. It is attached to one of the supplied ``nets`` (or to *any* net if
+           the argument is omitted).
+
+        Geometry that is created
+        ------------------------
+        For every qualified via the routine
+
+        * Generates a new pad-stack definition named ``<original_name>_BD``.
+          The definition is drilled from the **bottom-most signal layer** up to
+          and **including** ``layer``, uses the exact ``diameter`` supplied, and
+          is plated at 100 %.
+        * Places an additional pad-stack instance on top of the original via,
+          thereby filling the newly drilled cavity with the requested
+          ``material``.
+        * Leaves the original via untouched—only its unused stub is removed.
+
+        The back-drill is **not** subtracted from anti-pads or plane clearances;
+        the filling material is assumed to be electrically invisible at the
+        frequencies of interest.
+
+        Parameters
+        ----------
+        layer : :class:`str`
+            Signal layer name up to which the back-drill is performed (inclusive).
+            The drill always starts on the bottom-most signal layer of the stack-up.
+        diameter : :class:`float` or :class:`str`
+            Finished hole diameter for the back-drill.  A numeric value is
+            interpreted in the database length unit; a string such as
+            ``"0.3mm"`` is evaluated with units.
+        material : :class:`str`
+            Name of the dielectric material that fills the drilled cavity.  If the
+            material does not yet exist in the central material library it is
+            created on the fly.
+        permittivity : :class:`float`
+            Relative permittivity :math:`\varepsilon_{\mathrm{r}}` used when the
+            material has to be created.  Must be positive.
+        padstack_instances : :class:`list` [:class:`PadstackInstance` ], optional
+            Explicit list of via instances to process.  When provided,
+            ``padstack_definition`` and ``nets`` are ignored for filtering.
+        padstack_definition : :class:`str` or :class:`list` [:class:`str` ], optional
+            Pad-stack definition(s) to process.  If omitted, **all** through-hole
+            definitions are considered.
+        dielectric_loss_tangent : :class:`float`, optional
+            Loss tangent :math:`\tan\delta` used when the material has to be
+            created.  Defaults to ``0.0``.
+        nets : :class:`str` or :class:`list` [:class:`str` ], optional
+            Net name(s) used to filter vias.  If omitted, vias belonging to
+            **any** net are processed.
+
+        Returns
+        -------
+        :class:`bool`
+            ``True`` when at least one back-drill was successfully created.
+            ``False`` if no suitable via was found or any error occurred.
+
+        Raises
+        ------
+        ValueError
+            If ``material`` is empty or if ``permittivity`` is non-positive when a
+            new material must be created.
+
+        Notes
+        -----
+        * The routine is safe to call repeatedly: existing back-drills are **not**
+          duplicated because the ``*_BD`` definition name is deterministic.
+        * The original via keeps its pad-stack definition and net assignment; only
+          its unused stub is removed.
+        * The back-drill is **not** subtracted from anti-pads or plane clearances;
+          the filling material is assumed to be electrically invisible at the
+          frequencies of interest.
+
+        Examples
+        --------
+        Create back-drills on all vias belonging to two specific pad-stack
+        definitions and two DDR4 nets:
+
+        >>> edb.padstacks.create_dielectric_filled_backdrills(
+        ...     layer="L3",
+        ...     diameter="0.25mm",
+        ...     material="EPON_827",
+        ...     permittivity=3.8,
+        ...     dielectric_loss_tangent=0.015,
+        ...     padstack_definition=["VIA_10MIL", "VIA_16MIL"],
+        ...     nets=["DDR4_DQ0", "DDR4_DQ1"],
+        ... )
+        True
+        """
+        _padstack_instances = defaultdict(list)
+        if padstack_instances:
+            for inst in padstack_instances:
+                _padstack_instances[inst.padstack_definition].append(inst)
+        else:
+            if padstack_definition:
+                if isinstance(padstack_definition, str):
+                    padstack_definition = [padstack_definition]
+
+                padstack_definitions = [
+                    self.definitions.get(padstack_def, None) for padstack_def in padstack_definition
+                ]
+                if nets:
+                    if isinstance(nets, str):
+                        nets = [nets]
+                    for padstack_definition in padstack_definitions:
+                        _padstack_instances[padstack_definition.name] = self.get_instances(
+                            definition_name=padstack_definition.name, net_name=nets
+                        )
+                else:
+                    for padstack_definition in padstack_definitions:
+                        _padstack_instances[padstack_definition.name] = padstack_definition.instances
+            elif nets:
+                instances = self.get_instances(net_name=nets)
+                for inst in instances:
+                    padsatck_def_name = inst.padstack_definition
+                    padstack_def_layers = inst.layer_range_names
+                    if layer in padstack_def_layers and len(padstack_def_layers) >= 3:
+                        if not padsatck_def_name in _padstack_instances:
+                            _padstack_instances[padsatck_def_name] = [inst]
+                        else:
+                            _padstack_instances[padsatck_def_name].append(inst)
+                    else:
+                        self._pedb.logger.info(
+                            f"Drill layer {layer} not in padstack definition layers "
+                            f"or layer number = {len(padstack_def_layers)} "
+                            f"for padstack definition {padsatck_def_name}, skipping for backdrills"
+                        )
+        if not material:
+            raise ValueError("`material` must be specified")
+        if not material in self._pedb.materials:
+            if not dielectric_loss_tangent:
+                dielectric_loss_tangent = 0.0
+            self._pedb.materials.add_dielectric_material(
+                name=material, permittivity=permittivity, dielectric_loss_tangent=dielectric_loss_tangent
+            )
+        for def_name, instances in _padstack_instances.items():
+            padstack_def_backdrill_name = f"{def_name}_BD"
+            start_layer = list(self._pedb.stackup.signal_layers.keys())[-1]  # bottom layer
+            self.create(
+                padstackname=padstack_def_backdrill_name,
+                holediam=self._pedb.value(diameter),
+                paddiam="0.0",
+                antipaddiam="0.0",
+                start_layer=start_layer,
+                stop_layer=layer,
+            )
+            self.definitions[padstack_def_backdrill_name].material = material
+            self.definitions[padstack_def_backdrill_name].hole_plating_ratio = 100.0
+            for inst in instances:
+                inst.set_back_drill_by_layer(drill_to_layer=layer, offset=0.0, diameter=self._pedb.value(diameter))
+                self.place(
+                    position=inst.position,
+                    definition_name=padstack_def_backdrill_name,
+                    fromlayer=start_layer,
+                    tolayer=layer,
+                )
+        return True
+
     def delete_padstack_instances(self, net_names):  # pragma: no cover
         """Delete padstack instances by net names.
 

pyedb/dotnet/edb.py

@@ -102,6 +102,7 @@ from pyedb.misc.decorators import deprecate_argument_name, execution_timer
 from pyedb.modeler.geometry_operators import GeometryOperators
 from pyedb.siwave_core.product_properties import SIwaveProperties
 from pyedb.workflow import Workflow
+from pyedb.workflows.job_manager.backend.job_manager_handler import JobManagerHandler
 from pyedb.workflows.utilities.cutout import Cutout
 
 
@@ -429,11 +430,23 @@ class Edb:
         self._core_primitives = Modeler(self)
         self._stackup2 = self._stackup
         self._materials = Materials(self)
+        self._job_manager = JobManagerHandler(self)
 
     @property
     def pedb_class(self):
         return pyedb.dotnet
 
+    @property
+    def job_manager(self):
+        """Job manager for handling simulation tasks.
+
+        Returns
+        -------
+        :class:`JobManagerHandler <pyedb.workflows.job_manager.job_manager_handler.JobManagerHandler>`
+            Job manager instance for submitting and managing simulation jobs.
+        """
+        return self._job_manager
+
     def value(self, val):
         """Convert a value into a pyedb value."""
         val_ = val if isinstance(val, self._edb.Utility.Value) else self.edb_value(val)
@@ -668,7 +681,8 @@ class Edb:
         #     self.standalone = False
 
         self.core.Database.SetRunAsStandAlone(self.standalone)
-
+        if self._db:  # pragma no cover
+            self._db.Close()
         self._db = self.core.Database.Create(self.edbpath)
 
         if not self._db:
@@ -834,6 +848,61 @@ class Edb:
         self.edbpath = os.path.join(working_dir, aedb_name)
         return self.open_edb()
 
+    def import_vlctech_stackup(
+        self,
+        vlctech_file,
+        working_dir="",
+        export_xml=None,
+    ):
+        """Import a vlc.tech file and generate an ``edb.def`` file in the working directory containing only the stackup.
+
+        Parameters
+        ----------
+        vlctech_file : str
+            Full path to the technology stackup file. It must be vlc.tech.
+        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.
+        export_xml : str, optional
+            Export technology file in XML control file format.
+
+        Returns
+        -------
+        Full path to the AEDB file : str
+
+        """
+        if not working_dir:
+            working_dir = os.path.dirname(vlctech_file)
+        command = os.path.join(self.base_path, "helic", "tools", "raptorh", "bin", "make-edb")
+        if is_windows:
+            command += ".exe"
+        else:
+            os.environ["HELIC_ROOT"] = os.path.join(self.base_path, "helic")
+        cmd_make_edb = [
+            command,
+            "-t",
+            "{}".format(vlctech_file),
+            "-o",
+            "{}".format(os.path.join(working_dir, "vlctech")),
+        ]
+        if export_xml:
+            cmd_make_edb.extend(["-x", "{}".format(export_xml)])
+        try:
+            subprocess.run(cmd_make_edb, check=True)  # nosec
+        except subprocess.CalledProcessError as e:  # nosec
+            raise RuntimeError(
+                "Failed to create edb. Please check if the executable is present in the base path."
+            ) from e
+
+        if not os.path.exists(os.path.join(working_dir, "vlctech.aedb")):
+            self.logger.error("Failed to create edb. Please check if the executable is present in the base path.")
+            return False
+        else:
+            self.logger.info("edb successfully created.")
+        self.edbpath = os.path.join(working_dir, "vlctech.aedb")
+        self.open_edb()
+        return self.edbpath
+
     def export_to_ipc2581(self, ipc_path=None, units="MILLIMETER"):
         """Create an XML IPC2581 file from the active EDB.
 

pyedb/generic/general_methods.py

@@ -42,6 +42,7 @@ import sys
 import tempfile
 import time
 import traceback
+from typing import Dict
 
 from pyedb.generic.constants import CSS4_COLORS
 from pyedb.generic.settings import settings
@@ -135,6 +136,26 @@ def _exception(ex_info, func, args, kwargs, message="Type Error"):
         )
 
 
+def installed_ansys_em_versions() -> Dict[str, str]:
+    """
+    Scan environment variables and return a dict
+    {version: installation_path} for every ANSYS EM release found.
+    Versions are ordered from oldest → latest (latest appears last).
+    """
+    pattern = re.compile(r"^ANSYSEM_ROOT(\d{3})$", re.IGNORECASE)
+
+    # collect everything
+    versions = {}
+    for key, value in os.environ.items():
+        m = pattern.match(key)
+        if m:
+            version = m.group(1)
+            versions[version] = value.rstrip(os.sep)
+
+    # sort ascending so the latest is last
+    return dict(sorted(versions.items(), key=lambda kv: int(kv[0])))
+
+
 def get_filename_without_extension(path):
     """Get the filename without its extension.
 

pyedb/grpc/database/definition/materials.py

@@ -722,7 +722,7 @@ class Materials(object):
         :class:`Material <pyedb.grpc.database.definition.materials.Material>`
             Material object.
         """
-        extended_kwargs = {key: value for (key, value) in kwargs.items()}
+        extended_kwargs = {key: value for (key, value) in kwargs.items() if not key == "name"}
         extended_kwargs["permittivity"] = permittivity
         extended_kwargs["dielectric_loss_tangent"] = dielectric_loss_tangent
         material = self.add_material(name, **extended_kwargs)

pyedb/grpc/database/definition/padstack_def.py

@@ -366,6 +366,22 @@ class PadstackDef(GrpcPadstackDef):
         warnings.warn("via_stop_layer is deprecated. Use stop_layer instead.", DeprecationWarning)
         return self.stop_layer
 
+    @property
+    def material(self):
+        """Return hole material name.
+
+        Returns
+        -------
+        str
+            Hole material name.
+        """
+        return self.data.material.value
+
+    @material.setter
+    def material(self, value):
+        if isinstance(value, str):
+            self.data.material = value
+
     @property
     def hole_diameter(self) -> float:
         """Hole diameter.
@@ -647,15 +663,6 @@ class PadstackDef(GrpcPadstackDef):
             else:  # pragma no cover
                 self.data.hole_range = GrpcPadstackHoleRange.UNKNOWN_RANGE
 
-    @property
-    def material(self) -> str:
-        """Return hole material name."""
-        return self.data.material.value
-
-    @material.setter
-    def material(self, value):
-        self.data.material.value = value
-
     def convert_to_3d_microvias(
         self, convert_only_signal_vias=True, hole_wall_angle=15, delete_padstack_def=True
     ) -> bool: