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

pyedb/dotnet/edb.py

@@ -41,13 +41,13 @@ from zipfile import ZipFile as zpf
 import rtree
 
 from pyedb.configuration.configuration import Configuration
+import pyedb.dotnet
 from pyedb.dotnet.database.Variables import decompose_variable_value
 from pyedb.dotnet.database.cell.layout import Layout
 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 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 (
@@ -134,9 +134,17 @@ class Edb(Database):
         Reference to the AEDT project object.
     student_version : bool, optional
         Whether to open the AEDT student version. 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.
+    map_file : str, optional
+        Layer map .map file.
     technology_file : str, optional
         Full path to technology file to be converted to xml before importing or xml.
         Supported by GDS format only.
+    layer_filter:str,optional
+        Layer filter .txt file.
 
     Examples
     --------
@@ -182,7 +190,10 @@ class Edb(Database):
         oproject=None,
         student_version: bool = False,
         use_ppe: bool = False,
+        control_file: str = None,
+        map_file: str = None,
         technology_file: str = None,
+        layer_filter: str = None,
         remove_existing_aedt: bool = False,
     ):
         if isinstance(edbpath, Path):
@@ -232,27 +243,35 @@ class Edb(Database):
                 zipped_file.extractall(edbpath[:-4])
                 self.logger.info("ODB++ unzipped successfully.")
             zipped_file.close()
-            control_file = None
-            if technology_file:
-                if os.path.splitext(technology_file)[1] == ".xml":
-                    control_file = technology_file
-                else:
-                    control_file = convert_technology_file(technology_file, edbversion=edbversion)
             self.logger.info("Translating ODB++ to EDB...")
-            self.import_layout_file(edbpath[:-4], working_dir, use_ppe=use_ppe, control_file=control_file)
+            if not self.import_layout_file(
+                edbpath[:-4],
+                working_dir,
+                use_ppe=use_ppe,
+                control_file=control_file,
+                tech_file=technology_file,
+                layer_filter=layer_filter,
+                map_file=map_file,
+            ):
+                raise AttributeError("Translation was unsuccessful")
+                return False
             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)
         elif edbpath[-3:] in ["brd", "mcm", "sip", "gds", "xml", "dxf", "tgz", "anf"]:
             self.edbpath = edbpath[:-4] + ".aedb"
             working_dir = os.path.dirname(edbpath)
-            control_file = None
-            if technology_file:
-                if os.path.splitext(technology_file)[1] == ".xml":
-                    control_file = technology_file
-                else:
-                    control_file = convert_technology_file(technology_file, edbversion=edbversion)
-            self.import_layout_file(edbpath, working_dir, use_ppe=use_ppe, control_file=control_file)
+            if not self.import_layout_file(
+                edbpath,
+                working_dir,
+                use_ppe=use_ppe,
+                control_file=control_file,
+                tech_file=technology_file,
+                layer_filter=layer_filter,
+                map_file=map_file,
+            ):
+                raise AttributeError("Translation was unsuccessful")
+                return False
             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:])
@@ -371,6 +390,11 @@ class Edb(Database):
         self._stackup2 = self._stackup
         self._materials = Materials(self)
 
+    @property
+    def pedb_class(self):
+        if not self.grpc:
+            return pyedb.dotnet
+
     @property
     def grpc(self):
         """grpc flag."""
@@ -584,7 +608,7 @@ class Edb(Database):
         #     self.standalone = False
 
         self.run_as_standalone(self.standalone)
-        self.create(self.edbpath)
+        self._db = self.create(self.edbpath)
         if not self.active_db:
             self.logger.warning("Error creating the database.")
             self._active_cell = None
@@ -733,8 +757,7 @@ class Edb(Database):
             cmd_translator.append('-t="{}"'.format(tech_file))
         if layer_filter:
             cmd_translator.append('-f="{}"'.format(layer_filter))
-        p = subprocess.Popen(cmd_translator)
-        p.wait()
+        subprocess.run(cmd_translator)
         if not os.path.exists(os.path.join(working_dir, aedb_name)):
             self.logger.error("Translator failed to translate.")
             return False

pyedb/grpc/database/components.py

@@ -178,8 +178,7 @@ class Components(object):
     @property
     def nport_comp_definition(self):
         """Retrieve Nport component definition list."""
-        m = "Ansys.Ansoft.Edb.Definition.NPortComponentModel"
-        return {name: l for name, l in self.definitions.items() if m in [i for i in l.model]}
+        return {name: l for name, l in self.definitions.items() if l.reference_file}
 
     def import_definition(self, file_path):
         """Import component definition from json file.
@@ -2280,7 +2279,7 @@ class Components(object):
                 if not pin.net.is_null:
                     if pin.net.name:
                         pingroup.net = pin.net
-                        return group_name
+                        return group_name, PinGroup(self._pedb, pingroup)
         return False
 
     def create_pin_group_on_net(self, reference_designator, net_name, group_name=None):

pyedb/grpc/database/definition/component_def.py

@@ -216,3 +216,18 @@ class ComponentDef(GrpcComponentDef):
             n_port_model.reference_file = fpath
             self.add_component_model(n_port_model)
             return n_port_model
+
+    def get_properties(self):
+        data = {}
+        temp = []
+        for i in self.component_pins:
+            temp.append(i.name)
+        data["pin_order"] = temp
+        return data
+
+    def set_properties(self, **kwargs):
+        pin_order = kwargs.get("pin_order")
+        if pin_order:
+            old = {i.name: i for i in self.component_pins}
+            temp = [old[str(i)] for i in pin_order]
+            self.reorder_pins(temp)

pyedb/grpc/database/definition/component_pin.py

@@ -28,5 +28,5 @@ class ComponentPin(GrpcComponentPin):
     """Class managing :class:`ComponentPin <ansys.edb.core.definition.component_pin.ComponentPin>`."""
 
     def __init__(self, pedb, edb_object):
-        super().__init__(edb_object)
+        super().__init__(edb_object.msg)
         self._pedb = pedb

pyedb/grpc/database/definition/materials.py

@@ -587,6 +587,33 @@ class Material(GrpcMaterialDef):
 class Materials(object):
     """Manages EDB methods for material management accessible from `Edb.materials` property."""
 
+    default_conductor_property_values = {
+        "conductivity": 58000000,
+        "dielectric_loss_tangent": 0,
+        "magnetic_loss_tangent": 0,
+        "mass_density": 8933,
+        "permittivity": 1,
+        "permeability": 0.999991,
+        "poisson_ratio": 0.38,
+        "specific_heat": 385,
+        "thermal_conductivity": 400,
+        "youngs_modulus": 120000000000,
+        "thermal_expansion_coefficient": 1.77e-05,
+    }
+    default_dielectric_property_values = {
+        "conductivity": 0,
+        "dielectric_loss_tangent": 0.02,
+        "magnetic_loss_tangent": 0,
+        "mass_density": 1900,
+        "permittivity": 4.4,
+        "permeability": 1,
+        "poisson_ratio": 0.28,
+        "specific_heat": 1150,
+        "thermal_conductivity": 0.294,
+        "youngs_modulus": 11000000000,
+        "thermal_expansion_coefficient": 1.5e-05,
+    }
+
     def __init__(self, edb: Edb):
         self.__edb = edb
         self.__syslib = os.path.join(self.__edb.base_path, "syslib")

pyedb/grpc/database/definition/package_def.py

@@ -26,6 +26,7 @@ from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.edb_logger import pyedb_logger
 from pyedb.grpc.database.utility.heat_sink import HeatSink
+from pyedb.misc.misc import deprecated_property
 
 
 class PackageDef(GrpcPackageDef):
@@ -45,6 +46,11 @@ class PackageDef(GrpcPackageDef):
     """
 
     def __init__(self, pedb, edb_object=None, name=None, component_part_name=None, extent_bounding_box=None):
+        if not edb_object:
+            if name:
+                edb_object = GrpcPackageDef.create(db=pedb.active_db, name=name)
+            else:
+                raise AttributeError("Name must be provided to create and instantiate a PackageDef object.")
         super(GrpcPackageDef, self).__init__(edb_object.msg)
         self._pedb = pedb
         self._edb_object = edb_object
@@ -129,7 +135,6 @@ class PackageDef(GrpcPackageDef):
 
     @therm_cond.setter
     def therm_cond(self, value):
-        self.therm_cond = GrpcValue(value)
         super(PackageDef, self.__class__).thermal_conductivity.__set__(self, GrpcValue(value))
 
     @property
@@ -186,7 +191,20 @@ class PackageDef(GrpcPackageDef):
         :class:`HeatSink <pyedb.grpc.database.utility.heat_sink.HeatSink>`
             HeatSink object.
         """
-        return HeatSink(self._pedb, super().heat_sink)
+        try:
+            return HeatSink(self._pedb, super().heat_sink)
+        except:
+            pass
+
+    @property
+    @deprecated_property
+    def heatsink(self):
+        """Property added for .NET compatibility.
+        . deprecated:: pyedb 0.43.0
+        Use :func:`heat_sink` instead.
+
+        """
+        return self.heat_sink
 
     def set_heatsink(self, fin_base_height, fin_height, fin_orientation, fin_spacing, fin_thickness):
         """Set Heat sink.

pyedb/grpc/database/definition/padstack_def.py

@@ -34,7 +34,7 @@ import ansys.edb.core.geometry.polygon_data
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
 from ansys.edb.core.hierarchy.structure3d import MeshClosure as GrpcMeshClosure
 from ansys.edb.core.hierarchy.structure3d import Structure3D as GrpcStructure3D
-from ansys.edb.core.primitive.primitive import Circle as GrpcCircle
+from ansys.edb.core.primitive.circle import Circle as GrpcCircle
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.generic.general_methods import generate_unique_name
@@ -577,7 +577,10 @@ class PadstackDef(GrpcPadstackDef):
             Possible returned values are ``"through"``, ``"begin_on_upper_pad"``,
             ``"end_on_lower_pad"``, ``"upper_pad_to_lower_pad"``, and ``"undefined"``.
         """
-        return self.data.hole_range.name.lower()
+        try:
+            return self.data.hole_range.name.lower()
+        except:
+            return None
 
     @hole_range.setter
     def hole_range(self, value):

pyedb/grpc/database/hfss.py

@@ -1240,6 +1240,12 @@ class Hfss(object):
         from ansys.edb.core.simulation_setup.hfss_simulation_setup import (
             HfssSimulationSetup as GrpcHfssSimulationSetup,
         )
+        from ansys.edb.core.simulation_setup.simulation_setup import (
+            Distribution as GrpcDistribution,
+        )
+        from ansys.edb.core.simulation_setup.simulation_setup import (
+            FrequencyData as GrpcFrequencyData,
+        )
         from ansys.edb.core.simulation_setup.simulation_setup import (
             SweepData as GrpcSweepData,
         )
@@ -1267,7 +1273,10 @@ class Hfss(object):
         sweep_name = f"sweep_{len(setup.sweep_data) + 1}"
         sweep_data = [
             GrpcSweepData(
-                name=sweep_name, distribution=distribution, start_f=start_freq, end_f=stop_freq, step=step_freq
+                name=sweep_name,
+                frequency_data=GrpcFrequencyData(
+                    distribution=GrpcDistribution[distribution], start_f=start_freq, end_f=stop_freq, step=step_freq
+                ),
             )
         ]
         if discrete_sweep:

pyedb/grpc/database/hierarchy/component.py

@@ -42,8 +42,10 @@ 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 (
+from ansys.edb.core.primitive.padstack_instance import (
+    PadstackInstance as GrpcPadstackInstance,
+)
+from ansys.edb.core.terminal.padstack_instance_terminal import (
     PadstackInstanceTerminal as GrpcPadstackInstanceTerminal,
 )
 from ansys.edb.core.utility.rlc import Rlc as GrpcRlc

pyedb/grpc/database/hierarchy/pingroup.py

@@ -22,7 +22,7 @@
 
 
 from ansys.edb.core.hierarchy.pin_group import PinGroup as GrpcPinGroup
-from ansys.edb.core.terminal.terminals import BoundaryType as GrpcBoundaryType
+from ansys.edb.core.terminal.terminal import BoundaryType as GrpcBoundaryType
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.generic.general_methods import generate_unique_name
@@ -74,9 +74,9 @@ class PinGroup(GrpcPinGroup):
 
         Returns
         -------
-        List[:class:`PadstackInstance <pyedb.grpc.database.primitive.padstack_instance.PadstackInstance>`].
+        Dict[:class:`PadstackInstance <pyedb.grpc.database.primitive.padstack_instance.PadstackInstance>`].
         """
-        return [PadstackInstance(self._pedb, i) for i in super().pins]
+        return {i.name: PadstackInstance(self._pedb, i) for i in super().pins}
 
     @property
     def net(self):
@@ -105,11 +105,15 @@ class PinGroup(GrpcPinGroup):
         """
         return self.net.name
 
-    # @property
-    # def terminal(self):
-    #     """Terminal."""
-    #     term = PinGroupTerminal(self._pedb, self.get_pin_group_terminal())  # TODO check method is missing
-    #     return term if not term.is_null else None
+    @property
+    def terminal(self):
+        """Terminal."""
+        term = self.pin_group_terminal
+        if not term.is_null:
+            term = PinGroupTerminal(self._pedb, term)
+            return term
+        else:
+            return None
 
     def create_terminal(self, name=None):
         """Create a terminal.

pyedb/grpc/database/layers/layer.py

@@ -52,6 +52,34 @@ class Layer(GrpcLayer):
             else:
                 self._pedb.logger.error(f"{k} is not a valid layer attribute")
 
+    @property
+    def properties(self):
+        from ansys.edb.core.layer.stackup_layer import StackupLayer as GrpcStackupLayer
+
+        from pyedb.grpc.database.stackup import StackupLayer
+
+        if isinstance(self.cast(), GrpcStackupLayer):
+            return StackupLayer(self._pedb, self.cast()).properties
+        else:
+            data = {"name": self.name, "type": self.type, "color": self.color}
+            return data
+
+    @properties.setter
+    def properties(self, params):
+        name = params.get("name", "")
+        if name:
+            self.name = name
+        type = params.get("type", "")
+        if type:
+            self.type = type
+        color = params.get("color", "")
+        if color:
+            self.color = color
+
+    @property
+    def type(self):
+        return super().type.name.lower().split("_")[0]
+
     @property
     def _layer_name_mapping_reversed(self):
         return {j: i for i, j in self._layer_name_mapping.items()}