pyedb 0.34.3__py3-none-any.whl → 0.36.0__py3-none-any.whl

pyedb/__init__.py

@@ -44,7 +44,7 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.34.3"
+__version__ = "0.36.0"
 version = __version__
 
 #

pyedb/configuration/cfg_components.py

@@ -210,10 +210,10 @@ class CfgComponent(CfgBase):
         self._pyedb_obj.component_property = cp
 
     def set_parameters_to_edb(self):
-        if self.enabled:
-            self._pyedb_obj.enabled = self.enabled
         if self.type:
             self._pyedb_obj.type = self.type
+        if self.enabled:
+            self._pyedb_obj.enabled = self.enabled
 
         self._set_model_properties_to_edb()
         if self._pyedb_obj.type.lower() == "ic":

pyedb/configuration/cfg_modeler.py

@@ -97,6 +97,7 @@ class CfgModeler:
             for p in self.padstack_instances:
                 p_inst = self._pedb.padstacks.place(
                     via_name=p.name,
+                    net_name=p.net_name,
                     position=p.position,
                     definition_name=p.definition,
                 )

pyedb/configuration/cfg_padstacks.py

@@ -124,6 +124,15 @@ class CfgPadstackDefinition(CfgBase):
         if self.solder_ball_parameters:
             self._set_solder_parameters_to_edb(self.solder_ball_parameters)
 
+    def retrieve_parameters_from_edb(self):
+        self.name = self._pyedb_obj.name
+        self.hole_plating_thickness = self._pyedb_obj.hole_plating_thickness
+        self.material = self._pyedb_obj.material
+        self.hole_range = self._pyedb_obj.hole_range
+        self.pad_parameters = self._get_pad_parameters_from_edb()
+        self.hole_parameters = self._get_hole_parameters_from_edb()
+        self.solder_ball_parameters = self._get_solder_parameters_from_edb()
+
     def _set_solder_parameters_to_edb(self, parameters):
         pdef_data = self._pyedb_obj._padstack_def_data
 
@@ -158,15 +167,6 @@ class CfgPadstackDefinition(CfgBase):
         }
         return parameters
 
-    def retrieve_parameters_from_edb(self):
-        self.name = self._pyedb_obj.name
-        self.hole_plating_thickness = self._pyedb_obj.hole_plating_thickness
-        self.material = self._pyedb_obj.material
-        self.hole_range = self._pyedb_obj.hole_range
-        self.pad_parameters = self._get_pad_parameters_from_edb()
-        self.hole_parameters = self._get_hole_parameters_from_edb()
-        self.solder_ball_parameters = self._get_solder_parameters_from_edb()
-
     def _get_pad_parameters_from_edb(self):
         """Pad parameters.
 

pyedb/configuration/cfg_pin_groups.py

@@ -67,17 +67,16 @@ class CfgPinGroup(CfgBase):
     def create(self):
         """Apply pin group on layout."""
         if self.pins:
-            self._pedb.siwave.create_pin_group(self.reference_designator, list(self.pins), self.name)
+            pins = self.pins if isinstance(self.pins, list) else [self.pins]
+            self._pedb.siwave.create_pin_group(self.reference_designator, pins, self.name)
         elif self.net:
-            if self.reference_designator in self._pedb.components.instances:
-                comp = self._pedb.components.instances[self.reference_designator]
-            else:
-                raise f"Component not found for creating pin group {self.name}."
-            pins = [p for p, obj in comp.pins.items() if obj.net_name in self.net]
+            nets = self.net if isinstance(self.net, list) else [self.net]
+            comp = self._pedb.components.instances[self.reference_designator]
+            pins = [p for p, obj in comp.pins.items() if obj.net_name in nets]
             if not self._pedb.siwave.create_pin_group(self.reference_designator, pins, self.name):
-                self._pedb.logger.error(f"Failed to create pin group {self.name}")
+                raise RuntimeError(f"Failed to create pin group {self.name}")
         else:
-            self._pedb.logger.error(f"No net and pins defined for defining pin group {self.name}")
+            raise RuntimeError(f"No net and pins defined for defining pin group {self.name}")
 
     def export_properties(self):
         if self.pins:

pyedb/configuration/cfg_ports_sources.py

@@ -46,6 +46,7 @@ class CfgCoordianteTerminalInfo(CfgTerminalInfo):
         self.point_x = self.value["point"][0]
         self.point_y = self.value["point"][1]
         self.net = self.value["net"]
+        self.contact_radius = self.value.get("contact_radius", None)
 
     def export_properties(self):
         return {"coordinates": {"layer": self.layer, "point": [self.point_x, self.point_y], "net": self.net}}
@@ -244,6 +245,9 @@ class CfgCircuitElement(CfgBase):
             point = [self.positive_terminal_info.point_x, self.positive_terminal_info.point_y]
             net_name = self.positive_terminal_info.net
             pos_coor_terminal[self.name] = self._pedb.get_point_terminal(self.name, net_name, point, layer)
+            if self.positive_terminal_info.contact_radius:
+                pos_coor_terminal[self.name].contact_radius = self.positive_terminal_info.contact_radius
+
         elif pos_type == "pin_group":
             if self.distributed:
                 pins = self._get_pins(pos_type, pos_value)
@@ -265,7 +269,7 @@ class CfgCircuitElement(CfgBase):
             pins = {pos_value: self._pedb.components.instances[self.reference_designator].pins[pos_value]}
             pos_objs.update(pins)
         else:
-            raise f"Wrong positive terminal type {pos_type}"
+            raise Exception(f"Wrong positive terminal type {pos_type}.")
 
         self.pos_terminals = {i: j.create_terminal(i) for i, j in pos_objs.items()}
         self.pos_terminals.update(pos_coor_terminal)
@@ -276,7 +280,7 @@ class CfgCircuitElement(CfgBase):
 
             if neg_type == "coordinates":
                 layer = self.negative_terminal_info.layer
-                point = [self.negative_terminal_info.point_x, self.positive_terminal_info.point_y]
+                point = [self.negative_terminal_info.point_x, self.negative_terminal_info.point_y]
                 net_name = self.negative_terminal_info.net
                 self.neg_terminal = self._pedb.get_point_terminal(self.name + "_ref", net_name, point, layer)
             elif neg_type == "nearest_pin":
@@ -297,9 +301,12 @@ class CfgCircuitElement(CfgBase):
                     # create pin group
                     neg_obj = self._create_pin_group(pins, True)
                 elif neg_type == "pin":
-                    neg_obj = {neg_value: self._pedb.components.instances[self.reference_designator].pins[neg_value]}
+                    terminal_name = f"{self.reference_designator}_{neg_value}"
+                    neg_obj = {
+                        terminal_name: self._pedb.components.instances[self.reference_designator].pins[neg_value]
+                    }
                 else:
-                    raise f"Wrong negative terminal type {neg_type}"
+                    raise Exception(f"Wrong negative terminal type {neg_type}.")
                 self.neg_terminal = [
                     j.create_terminal(i) if not j.terminal else j.terminal for i, j in neg_obj.items()
                 ][0]
@@ -375,6 +382,7 @@ class CfgSource(CfgCircuitElement):
         super().__init__(pedb, **kwargs)
 
         self.magnitude = kwargs.get("magnitude", 0.001)
+        self.equipotential = kwargs.get("equipotential", False)
 
     def set_parameters_to_edb(self):
         """Create sources."""
@@ -394,6 +402,33 @@ class CfgSource(CfgCircuitElement):
                 elem.name = f"{self.name}_{elem.name}"
                 elem.magnitude = self.magnitude / self._elem_num
             circuit_elements.append(elem)
+        for terminal in circuit_elements:
+            if self.equipotential:
+                terms = [terminal, terminal.ref_terminal] if terminal.ref_terminal else [terminal]
+                for t in terms:
+                    pads = []
+                    if t.terminal_type == "PadstackInstanceTerminal":
+                        pads.append(t.reference_object)
+                        t._edb_object.dcir_equipotential_region = True
+                    elif t.terminal_type == "PinGroupTerminal":
+                        name = t._edb_object.GetPinGroup().GetName()
+                        pg = self._pedb.siwave.pin_groups[name]
+                        pads.extend([i for _, i in pg.pins.items()])
+                    elif t.terminal_type == "PointTerminal":
+                        temp = [i for i in self._pedb.layout.terminals if i.name == t.name][0]
+                        if not temp.is_reference_terminal:
+                            radius = self.positive_terminal_info.contact_radius
+                        else:
+                            radius = self.negative_terminal_info.contact_radius
+                        if radius is not None:
+                            prim = self._pedb.modeler.create_circle(
+                                temp.layer.name, temp.location[0], temp.location[1], radius, temp.net_name
+                            )
+                            prim.dcir_equipotential_region = True
+
+                    for i in pads:
+                        i._set_equipotential()
+
         return circuit_elements
 
     def export_properties(self):

pyedb/configuration/cfg_stackup.py

@@ -45,6 +45,7 @@ class CfgLayer(CfgBase):
         self.fill_material = kwargs.get("fill_material", None)
         self.thickness = kwargs.get("thickness", None)
         self.roughness = kwargs.get("roughness", None)
+        self.etching = kwargs.get("etching", None)
 
 
 class CfgStackup:

pyedb/configuration/configuration.py

@@ -134,13 +134,17 @@ class Configuration:
 
         # Configure stackup
         if kwargs.get("fix_padstack_def"):
+            from pyedb.configuration.cfg_padstacks import CfgPadstackDefinition
+
             pedb_defs = self._pedb.padstacks.definitions
-            temp = {}
-            for name, pdef in pedb_defs.items():
-                temp[name] = pdef.get_properties()
+            temp = []
+            for _, pdef in pedb_defs.items():
+                cfg_def = CfgPadstackDefinition(self._pedb, pdef)
+                cfg_def.retrieve_parameters_from_edb()
+                temp.append(cfg_def)
             self.cfg_data.stackup.apply()
-            for name, pdef_p in temp.items():
-                pedb_defs[name].set_properties(**pdef_p)
+            for cfg_pdef in temp:
+                cfg_pdef.set_parameters_to_edb()
         else:
             self.cfg_data.stackup.apply()
 

pyedb/dotnet/edb.py

@@ -603,7 +603,7 @@ class Edb(Database):
     def import_layout_pcb(
         self,
         input_file,
-        working_dir,
+        working_dir="",
         anstranslator_full_path="",
         use_ppe=False,
         control_file=None,
@@ -616,7 +616,7 @@ class Edb(Database):
         ----------
         input_file : str
             Full path to the board file.
-        working_dir : str
+        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
@@ -1510,6 +1510,13 @@ class Edb(Database):
             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"
 
@@ -1529,10 +1536,10 @@ class Edb(Database):
                     else:
                         self.logger.error("Unable to define control file.")
 
-                command = [anstranslator_full_path, inputGDS, f'-g="{map_file}"', f'-c="{control_file}"']
+                command = [path, inputGDS, f'-g="{map_file}"', f'-c="{control_file}"']
             else:
                 command = [
-                    anstranslator_full_path,
+                    path,
                     inputGDS,
                     f'-o="{control_file_temp}"' f'-t="{tech_file}"',
                     f'-g="{map_file}"',
@@ -4564,6 +4571,7 @@ class Edb(Database):
             port_poly = cloned_edb.modeler.create_polygon(
                 main_shape=void_info[0].polygon_data._edb_object, layer_name="ref", net_name="GND"
             )
+            port_poly.scale(1.1)
             pec_poly = cloned_edb.modeler.create_polygon(
                 main_shape=port_poly.polygon_data._edb_object, layer_name="port_pec", net_name="GND"
             )

pyedb/dotnet/edb_core/cell/hierarchy/pin_pair_model.py

@@ -66,7 +66,7 @@ class PinPair(object):  # pragma: no cover
     @resistance.setter
     def resistance(self, value):
         self._pin_pair_rlc.R = value
-        self._set_comp_prop(self._pin_pair_rlc)  # pragma: no cover
+        self._set_comp_prop()  # pragma: no cover
 
     @property
     def inductance(self):
@@ -75,7 +75,7 @@ class PinPair(object):  # pragma: no cover
     @inductance.setter
     def inductance(self, value):
         self._pin_pair_rlc.L = value
-        self._set_comp_prop(self._pin_pair_rlc)  # pragma: no cover
+        self._set_comp_prop()  # pragma: no cover
 
     @property
     def capacitance(self):
@@ -84,7 +84,7 @@ class PinPair(object):  # pragma: no cover
     @capacitance.setter
     def capacitance(self, value):
         self._pin_pair_rlc.C = value
-        self._set_comp_prop(self._pin_pair_rlc)  # pragma: no cover
+        self._set_comp_prop()  # pragma: no cover
 
     @property
     def rlc_values(self):  # pragma: no cover

pyedb/dotnet/edb_core/cell/primitive/primitive.py

@@ -19,6 +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
 
 from pyedb.dotnet.edb_core.cell.connectable import Connectable
 from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
@@ -787,3 +788,66 @@ class Primitive(Connectable):
                 self.polygon_data = polygon_data
                 return True
         return False
+
+    @property
+    def _em_properties(self):
+        """Get EM properties."""
+        default = (
+            r"$begin 'EM properties'\n"
+            r"\tType('Mesh')\n"
+            r"\tDataId='EM properties1'\n"
+            r"\t$begin 'Properties'\n"
+            r"\t\tGeneral=''\n"
+            r"\t\tModeled='true'\n"
+            r"\t\tUnion='true'\n"
+            r"\t\t'Use Precedence'='false'\n"
+            r"\t\t'Precedence Value'='1'\n"
+            r"\t\tPlanarEM=''\n"
+            r"\t\tRefined='true'\n"
+            r"\t\tRefineFactor='1'\n"
+            r"\t\tNoEdgeMesh='false'\n"
+            r"\t\tHFSS=''\n"
+            r"\t\t'Solve Inside'='false'\n"
+            r"\t\tSIwave=''\n"
+            r"\t\t'DCIR Equipotential Region'='false'\n"
+            r"\t$end 'Properties'\n"
+            r"$end 'EM properties'\n"
+        )
+
+        pid = self._pedb.edb_api.ProductId.Designer
+        _, p = self._edb_object.GetProductProperty(pid, 18, "")
+        if p:
+            return p
+        else:
+            return default
+
+    @_em_properties.setter
+    def _em_properties(self, em_prop):
+        """Set EM properties"""
+        pid = self._pedb.edb_api.ProductId.Designer
+        self._edb_object.SetProductProperty(pid, 18, em_prop)
+
+    @property
+    def dcir_equipotential_region(self):
+        """Check whether dcir equipotential region is enabled.
+
+        Returns
+        -------
+        bool
+        """
+        pattern = r"'DCIR Equipotential Region'='([^']+)'"
+        em_pp = self._em_properties
+        result = re.search(pattern, em_pp).group(1)
+        if result == "true":
+            return True
+        else:
+            return False
+
+    @dcir_equipotential_region.setter
+    def dcir_equipotential_region(self, value):
+        """Set dcir equipotential region."""
+        pp = r"'DCIR Equipotential Region'='true'" if value else r"'DCIR Equipotential Region'='false'"
+        em_pp = self._em_properties
+        pattern = r"'DCIR Equipotential Region'='([^']+)'"
+        new_em_pp = re.sub(pattern, pp, em_pp)
+        self._em_properties = new_em_pp

pyedb/dotnet/edb_core/cell/terminal/padstack_instance_terminal.py

@@ -101,3 +101,15 @@ class PadstackInstanceTerminal(Terminal):
     def padstack_instance(self):
         p_inst, _ = self._get_parameters()
         return self._pedb.layout.find_object_by_id(p_inst.GetId())
+
+    @property
+    def layer(self):
+        """Get layer of the terminal."""
+        _, _, layer = self._edb_object.GetParameters()
+        return self._pedb.stackup.all_layers[layer.GetName()]
+
+    @layer.setter
+    def layer(self, value):
+        layer = self._pedb.stackup.layers[value]._edb_layer
+        point_data = self._pedb.point_data(*self.location)
+        self._edb_object.SetParameters(point_data, layer)

pyedb/dotnet/edb_core/cell/terminal/point_terminal.py

@@ -66,3 +66,15 @@ class PointTerminal(Terminal):
             raise Exception(msg)
         else:
             return terminal
+
+    @property
+    def layer(self):
+        """Get layer of the terminal."""
+        _, _, layer = self._edb_object.GetParameters()
+        return self._pedb.stackup.all_layers[layer.GetName()]
+
+    @layer.setter
+    def layer(self, value):
+        layer = self._pedb.stackup.layers[value]._edb_layer
+        point_data = self._pedb.point_data(*self.location)
+        self._edb_object.SetParameters(point_data, layer)

pyedb/dotnet/edb_core/cell/terminal/terminal.py

@@ -105,25 +105,16 @@ class Terminal(Connectable):
     @property
     def layer(self):
         """Get layer of the terminal."""
-        point_data = self._pedb.point_data(0, 0)
-        layer = list(self._pedb.stackup.layers.values())[0]._edb_layer
-        if self._edb_object.GetParameters(point_data, layer):
-            return self._pedb.stackup.all_layers[layer.GetName()]
-        else:
-            self._pedb.logger.warning(f"No pad parameters found for terminal {self.name}")
-
-    @layer.setter
-    def layer(self, value):
-        layer = self._pedb.stackup.layers[value]._edb_layer
-        point_data = self._pedb.point_data(*self.location)
-        self._edb_object.SetParameters(point_data, layer)
+        return self._pedb.logger.error("Cannot determine terminal layer")
 
     @property
     def location(self):
         """Location of the terminal."""
-        layer = list(self._pedb.stackup.layers.values())[0]._edb_layer
-        _, point_data, _ = self._edb_object.GetParameters(None, layer)
-        return [point_data.X.ToDouble(), point_data.Y.ToDouble()]
+        try:
+            _, point_data, _ = self._edb_object.GetParameters()
+            return [point_data.X.ToDouble(), point_data.Y.ToDouble()]
+        except:
+            self._pedb.logger.error("Cannot determine terminal location")
 
     @location.setter
     def location(self, value):

pyedb/dotnet/edb_core/components.py

@@ -111,16 +111,9 @@ class Components(object):
 
     def __init__(self, p_edb):
         self._pedb = p_edb
-        self._cmp = {}
-        self._res = {}
-        self._cap = {}
-        self._ind = {}
-        self._ios = {}
-        self._ics = {}
-        self._others = {}
+        self.refresh_components()
         self._pins = {}
         self._comps_by_part = {}
-        self._init_parts()
         self._padstack = EdbPadstacks(self._pedb)
 
     @property
@@ -132,16 +125,6 @@ class Components(object):
     def _edb(self):
         return self._pedb.edb_api
 
-    def _init_parts(self):
-        a = self.instances
-        a = self.resistors
-        a = self.ICs
-        a = self.Others
-        a = self.inductors
-        a = self.IOs
-        a = self.components_by_partname
-        return True
-
     def _get_edb_value(self, value):
         return self._pedb.edb_value(value)
 
@@ -205,8 +188,6 @@ class Components(object):
         >>> edbapp.components.instances
 
         """
-        if not self._cmp:
-            self.refresh_components()
         return self._cmp
 
     @property
@@ -310,10 +291,29 @@ class Components(object):
 
     def refresh_components(self):
         """Refresh the component dictionary."""
-        # self._logger.info("Refreshing the Components dictionary.")
         self._cmp = {}
+        self._res = {}
+        self._ind = {}
+        self._cap = {}
+        self._ics = {}
+        self._ios = {}
+        self._others = {}
         for i in self._pedb.layout.groups:
             self._cmp[i.name] = i
+            if i.type == "Resistor":
+                self._res[i.name] = i
+            elif i.type == "Capacitor":
+                self._cap[i.name] = i
+            elif i.type == "Inductor":
+                self._ind[i.name] = i
+            elif i.type == "IC":
+                self._ics[i.name] = i
+            elif i.type == "IO":
+                self._ios[i.name] = i
+            elif i.type == "Other":
+                self._others[i.name] = i
+            else:
+                self._logger.warning(f"Unknown component type {i.name} found while refreshing components, will ignore")
         return True
 
     @property
@@ -332,10 +332,6 @@ class Components(object):
         >>> edbapp = Edb("myaedbfolder")
         >>> edbapp.components.resistors
         """
-        self._res = {}
-        for el, val in self.instances.items():
-            if val.type == "Resistor":
-                self._res[el] = val
         return self._res
 
     @property
@@ -354,10 +350,6 @@ class Components(object):
         >>> edbapp = Edb("myaedbfolder")
         >>> edbapp.components.capacitors
         """
-        self._cap = {}
-        for el, val in self.instances.items():
-            if val.type == "Capacitor":
-                self._cap[el] = val
         return self._cap
 
     @property
@@ -377,10 +369,6 @@ class Components(object):
         >>> edbapp.components.inductors
 
         """
-        self._ind = {}
-        for el, val in self.instances.items():
-            if val.type == "Inductor":
-                self._ind[el] = val
         return self._ind
 
     @property
@@ -400,10 +388,6 @@ class Components(object):
         >>> edbapp.components.ICs
 
         """
-        self._ics = {}
-        for el, val in self.instances.items():
-            if val.type == "IC":
-                self._ics[el] = val
         return self._ics
 
     @property
@@ -423,10 +407,6 @@ class Components(object):
         >>> edbapp.components.IOs
 
         """
-        self._ios = {}
-        for el, val in self.instances.items():
-            if val.type == "IO":
-                self._ios[el] = val
         return self._ios
 
     @property
@@ -446,10 +426,6 @@ class Components(object):
         >>> edbapp.components.others
 
         """
-        self._others = {}
-        for el, val in self.instances.items():
-            if val.type == "Other":
-                self._others[el] = val
         return self._others
 
     @property