From ca59a11baff433e3bf887d6921f412f22b0c70bf Mon Sep 17 00:00:00 2001 From: maxcapodi78 Date: Mon, 15 Jul 2024 10:57:34 +0200 Subject: [PATCH 1/8] Improved auto_parametrize_design method. Variable renaming and also the trace_net_filters now applies also to padstack definitions. --- src/pyedb/dotnet/edb.py | 152 +++++++++++++++++++++++----------------- 1 file changed, 87 insertions(+), 65 deletions(-) diff --git a/src/pyedb/dotnet/edb.py b/src/pyedb/dotnet/edb.py index 9e496f1165..7600a6bb09 100644 --- a/src/pyedb/dotnet/edb.py +++ b/src/pyedb/dotnet/edb.py @@ -4097,6 +4097,7 @@ def auto_parametrize_design( material_filter=None, padstack_definition_filter=None, trace_net_filter=None, + use_single_variable_for_padstack_definitions=True, ): """Assign automatically design and project variables with current values. @@ -4122,20 +4123,25 @@ def auto_parametrize_design( Enable padstack definition filter. Default value is ``None``, all padsatcks are parametrized. trace_net_filter : str, List(str), optional Enable nets filter for trace width parametrization. Default value is ``None``, all layers are parametrized. + use_single_variable_for_padstack_definitions : bool, optional + Whether to use a single design variable for each padstack definition or a variable per pad layer. + Default value is ``True``. Returns ------- List(str) List of all parameters name created. """ + if isinstance(trace_net_filter, str): + trace_net_filter = [trace_net_filter] parameters = [] if layers: if not layer_filter: - _layers = self.stackup.stackup_layers + _layers = self.stackup.layers else: if isinstance(layer_filter, str): layer_filter = [layer_filter] - _layers = {k: v for k, v in self.stackup.stackup_layers.items() if k in layer_filter} + _layers = {k: v for k, v in self.stackup.layers.items() if k in layer_filter} for layer_name, layer in _layers.items(): thickness_variable = "${}_thick".format(layer_name) thickness_variable = self._clean_string_for_variable_name(thickness_variable) @@ -4175,92 +4181,108 @@ def auto_parametrize_design( else: paths = [path for path in self.modeler.paths if path.net_name in trace_net_filter] for path in paths: - trace_width_variable = "trace_w_{}_{}".format(path.net_name, path.id) + net_name = path.net_name + if net_name: + trace_width_variable = f"{path.net_name}_{path.aedt_name}_width" + else: + trace_width_variable = f"{path.aedt_name}_width" trace_width_variable = self._clean_string_for_variable_name(trace_width_variable) if trace_width_variable not in self.variables: self.add_design_variable(trace_width_variable, path.width) path.width = trace_width_variable parameters.append(trace_width_variable) if not padstack_definition_filter: - used_padsatck_defs = list( - set([padstack_inst.padstack_definition for padstack_inst in list(self.padstacks.instances.values())]) - ) - padstack_defs = {k: v for k, v in self.padstacks.definitions.items() if k in used_padsatck_defs} + if trace_net_filter: + padstack_defs = {} + for net in trace_net_filter: + for via in self.nets[net].padstack_instances: + padstack_defs[via.padstack_definition] = self.padstacks.definitions[via.padstack_definition] + else: + used_padsatck_defs = list( + set([padstack_inst.padstack_definition for padstack_inst in list(self.padstacks.instances.values())]) + ) + padstack_defs = {k: v for k, v in self.padstacks.definitions.items() if k in used_padsatck_defs} else: padstack_defs = {k: v for k, v in self.padstacks.definitions.items() if k in padstack_definition_filter} + for def_name, padstack_def in padstack_defs.items(): + if not padstack_def.via_start_layer == padstack_def.via_stop_layer: if via_holes: # pragma no cover - hole_variable = self._clean_string_for_variable_name("$hole_diam_{}".format(def_name)) + hole_variable = self._clean_string_for_variable_name( f"${def_name}_hole_diam") if hole_variable not in self.variables: self.add_design_variable(hole_variable, padstack_def.hole_diameter_string) padstack_def.hole_properties = hole_variable parameters.append(hole_variable) if pads: + for layer, pad in padstack_def.pad_by_layer.items(): - if pad.geometry_type == 1: - pad_diameter_variable = self._clean_string_for_variable_name( - "$pad_diam_{}_{}".format(def_name, layer) - ) - if pad_diameter_variable not in self.variables: - self.add_design_variable(pad_diameter_variable, pad.parameters_values_string[0]) - pad.parameters = {"Diameter": pad_diameter_variable} - parameters.append(pad_diameter_variable) - if pad.geometry_type == 2: # pragma no cover - pad_size_variable = self._clean_string_for_variable_name( - "$pad_size_{}_{}".format(def_name, layer) - ) - if pad_size_variable not in self.variables: - self.add_design_variable(pad_size_variable, pad.parameters_values_string[0]) - pad.parameters = {"Size": pad_size_variable} - parameters.append(pad_size_variable) + if use_single_variable_for_padstack_definitions: + pad_name = f"${def_name}_pad" + else: + pad_name = f"${def_name}_{layer}_pad" + pad_variable = self._clean_string_for_variable_name(pad_name) + + if pad.geometry_type in [1,2] and pad_variable not in self.variables: + self.add_design_variable(pad_variable, pad.parameters_values_string[0]) + if pad.geometry_type == 1: + pad.parameters = {"Diameter": pad_variable} + else: + pad.parameters = {"Size": pad_variable} + parameters.append(pad_variable) elif pad.geometry_type == 3: # pragma no cover - pad_size_variable_x = self._clean_string_for_variable_name( - "$pad_size_x_{}_{}".format(def_name, layer) - ) - pad_size_variable_y = self._clean_string_for_variable_name( - "$pad_size_y_{}_{}".format(def_name, layer) - ) - if pad_size_variable_x not in self.variables and pad_size_variable_y not in self.variables: - self.add_design_variable(pad_size_variable_x, pad.parameters_values_string[0]) - self.add_design_variable(pad_size_variable_y, pad.parameters_values_string[1]) - pad.parameters = {"XSize": pad_size_variable_x, "YSize": pad_size_variable_y} - parameters.append(pad_size_variable_x) - parameters.append(pad_size_variable_y) + if use_single_variable_for_padstack_definitions: + pad_name_x = f"${def_name}_pad_x" + pad_name_y = f"${def_name}_pad_y" + else: + pad_name_x = f"${def_name}_{layer}_pad_x" + pad_name_y = f"${def_name}_pad_y" + + pad_name_x = self._clean_string_for_variable_name(pad_name_x) + pad_name_y = self._clean_string_for_variable_name(pad_name_y) + if pad_name_x not in self.variables and pad_name_y not in self.variables: + self.add_design_variable(pad_name_x, pad.parameters_values_string[0]) + self.add_design_variable(pad_name_y, pad.parameters_values_string[1]) + pad.parameters = {"XSize": pad_name_x, "YSize": pad_name_y} + parameters.append(pad_name_x) + parameters.append(pad_name_y) if antipads: for layer, antipad in padstack_def.antipad_by_layer.items(): - if antipad.geometry_type == 1: # pragma no cover - antipad_diameter_variable = self._clean_string_for_variable_name( - "$antipad_diam_{}_{}".format(def_name, layer) - ) - if antipad_diameter_variable not in self.variables: # pragma no cover - self.add_design_variable(antipad_diameter_variable, antipad.parameters_values_string[0]) - antipad.parameters = {"Diameter": antipad_diameter_variable} - parameters.append(antipad_diameter_variable) - if antipad.geometry_type == 2: # pragma no cover - antipad_size_variable = self._clean_string_for_variable_name( - "$antipad_size_{}_{}".format(def_name, layer) - ) - if antipad_size_variable not in self.variables: # pragma no cover - self.add_design_variable(antipad_size_variable, antipad.parameters_values_string[0]) - antipad.parameters = {"Size": antipad_size_variable} - parameters.append(antipad_size_variable) + if use_single_variable_for_padstack_definitions: + pad_name = f"${def_name}_antipad" + else: + pad_name = f"${def_name}_{layer}_antipad" + antipad_variable = self._clean_string_for_variable_name(pad_name) + + if antipad.geometry_type in [1,2] and antipad_variable not in self.variables: + self.add_design_variable(antipad_variable, antipad.parameters_values_string[0]) + if antipad.geometry_type == 1: # pragma no cover + antipad.parameters = {"Diameter": antipad_variable} + else: + antipad.parameters = {"Size": antipad_variable} + parameters.append(antipad_variable) elif antipad.geometry_type == 3: # pragma no cover - antipad_size_variable_x = self._clean_string_for_variable_name( - "$antipad_size_x_{}_{}".format(def_name, layer) - ) - antipad_size_variable_y = self._clean_string_for_variable_name( - "$antipad_size_y_{}_{}".format(def_name, layer) - ) + if use_single_variable_for_padstack_definitions: + pad_name_x = f"${def_name}_antipad_x" + pad_name_y = f"${def_name}_antipad_y" + else: + pad_name_x = f"${def_name}_{layer}_antipad_x" + pad_name_y = f"${def_name}_antipad_y" + + pad_name_x = self._clean_string_for_variable_name(pad_name_x) + pad_name_y = self._clean_string_for_variable_name(pad_name_y) + if pad_name_x not in self.variables and pad_name_y not in self.variables: + self.add_design_variable(pad_name_x, antipad.parameters_values_string[0]) + self.add_design_variable(pad_name_y, antipad.parameters_values_string[1]) if ( - antipad_size_variable_x not in self.variables - and antipad_size_variable_y not in self.variables + pad_name_x not in self.variables + and pad_name_y not in self.variables ): # pragma no cover - self.add_design_variable(antipad_size_variable_x, antipad.parameters_values_string[0]) - self.add_design_variable(antipad_size_variable_y, antipad.parameters_values_string[1]) - antipad.parameters = {"XSize": antipad_size_variable_x, "YSize": antipad_size_variable_y} - parameters.append(antipad_size_variable_x) - parameters.append(antipad_size_variable_y) + self.add_design_variable(pad_name_x, antipad.parameters_values_string[0]) + self.add_design_variable(pad_name_y, antipad.parameters_values_string[1]) + antipad.parameters = {"XSize": pad_name_x, "YSize": pad_name_y} + parameters.append(pad_name_x) + parameters.append(pad_name_y) return parameters def _clean_string_for_variable_name(self, variable_name): From 6cbba82c3853e413c21266eb56be55e2a9a6ac41 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 15 Jul 2024 08:58:43 +0000 Subject: [PATCH 2/8] MISC: Auto fixes from pre-commit.com hooks For more information, see https://pre-commit.ci --- src/pyedb/dotnet/edb.py | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/src/pyedb/dotnet/edb.py b/src/pyedb/dotnet/edb.py index 7600a6bb09..91856220a5 100644 --- a/src/pyedb/dotnet/edb.py +++ b/src/pyedb/dotnet/edb.py @@ -4199,23 +4199,23 @@ def auto_parametrize_design( padstack_defs[via.padstack_definition] = self.padstacks.definitions[via.padstack_definition] else: used_padsatck_defs = list( - set([padstack_inst.padstack_definition for padstack_inst in list(self.padstacks.instances.values())]) + set( + [padstack_inst.padstack_definition for padstack_inst in list(self.padstacks.instances.values())] + ) ) padstack_defs = {k: v for k, v in self.padstacks.definitions.items() if k in used_padsatck_defs} else: padstack_defs = {k: v for k, v in self.padstacks.definitions.items() if k in padstack_definition_filter} for def_name, padstack_def in padstack_defs.items(): - if not padstack_def.via_start_layer == padstack_def.via_stop_layer: if via_holes: # pragma no cover - hole_variable = self._clean_string_for_variable_name( f"${def_name}_hole_diam") + hole_variable = self._clean_string_for_variable_name(f"${def_name}_hole_diam") if hole_variable not in self.variables: self.add_design_variable(hole_variable, padstack_def.hole_diameter_string) padstack_def.hole_properties = hole_variable parameters.append(hole_variable) if pads: - for layer, pad in padstack_def.pad_by_layer.items(): if use_single_variable_for_padstack_definitions: pad_name = f"${def_name}_pad" @@ -4223,7 +4223,7 @@ def auto_parametrize_design( pad_name = f"${def_name}_{layer}_pad" pad_variable = self._clean_string_for_variable_name(pad_name) - if pad.geometry_type in [1,2] and pad_variable not in self.variables: + if pad.geometry_type in [1, 2] and pad_variable not in self.variables: self.add_design_variable(pad_variable, pad.parameters_values_string[0]) if pad.geometry_type == 1: pad.parameters = {"Diameter": pad_variable} @@ -4254,7 +4254,7 @@ def auto_parametrize_design( pad_name = f"${def_name}_{layer}_antipad" antipad_variable = self._clean_string_for_variable_name(pad_name) - if antipad.geometry_type in [1,2] and antipad_variable not in self.variables: + if antipad.geometry_type in [1, 2] and antipad_variable not in self.variables: self.add_design_variable(antipad_variable, antipad.parameters_values_string[0]) if antipad.geometry_type == 1: # pragma no cover antipad.parameters = {"Diameter": antipad_variable} @@ -4274,10 +4274,7 @@ def auto_parametrize_design( if pad_name_x not in self.variables and pad_name_y not in self.variables: self.add_design_variable(pad_name_x, antipad.parameters_values_string[0]) self.add_design_variable(pad_name_y, antipad.parameters_values_string[1]) - if ( - pad_name_x not in self.variables - and pad_name_y not in self.variables - ): # pragma no cover + if pad_name_x not in self.variables and pad_name_y not in self.variables: # pragma no cover self.add_design_variable(pad_name_x, antipad.parameters_values_string[0]) self.add_design_variable(pad_name_y, antipad.parameters_values_string[1]) antipad.parameters = {"XSize": pad_name_x, "YSize": pad_name_y} From 9ed079ca39552bd3920283f561db8d3f1079c2a3 Mon Sep 17 00:00:00 2001 From: maxcapodi78 Date: Mon, 15 Jul 2024 13:05:26 +0200 Subject: [PATCH 3/8] Improved auto_parametrize_design method. Variable renaming and also the trace_net_filters now applies also to padstack definitions. --- src/pyedb/dotnet/edb.py | 183 ++++++++++++++++----------- tests/legacy/system/test_edb_nets.py | 24 ++-- 2 files changed, 121 insertions(+), 86 deletions(-) diff --git a/src/pyedb/dotnet/edb.py b/src/pyedb/dotnet/edb.py index 7600a6bb09..2b30c1ad07 100644 --- a/src/pyedb/dotnet/edb.py +++ b/src/pyedb/dotnet/edb.py @@ -4098,6 +4098,11 @@ def auto_parametrize_design( padstack_definition_filter=None, trace_net_filter=None, use_single_variable_for_padstack_definitions=True, + use_relative_variables=True, + output_aedb_path=None, + open_aedb_at_end=True, + expand_polygons_size=0, + expand_voids_size=0, ): """Assign automatically design and project variables with current values. @@ -4126,15 +4131,41 @@ def auto_parametrize_design( use_single_variable_for_padstack_definitions : bool, optional Whether to use a single design variable for each padstack definition or a variable per pad layer. Default value is ``True``. + use_relative_variables : bool, optional + Whether if use an absolute variable for each trace, padstacks and layers or a delta variable instead. + Default value is ``True``. + output_aedb_path : str, optional + Full path and name for the new AEDB file. If None, then current aedb will be cutout. + open_aedb_at_end : bool, optional + Whether to open the cutout at the end. The default is ``True``. Returns ------- List(str) List of all parameters name created. """ + edb_original_path = self.edbpath + if output_aedb_path: + self.save_edb_as(output_aedb_path) if isinstance(trace_net_filter, str): trace_net_filter = [trace_net_filter] parameters = [] + def _apply_variable(orig_name, orig_value): + if use_relative_variables: + var = f"{orig_name}_delta" + else: + var = f"{orig_name}_value" + var = self._clean_string_for_variable_name(var) + if var not in self.variables: + if use_relative_variables: + self.add_design_variable(var, 0.0) + else: + self.add_design_variable(var, orig_value) + if use_relative_variables: + return f"{orig_value}+{var}", var + else: + return var, var + if layers: if not layer_filter: _layers = self.stackup.layers @@ -4143,12 +4174,9 @@ def auto_parametrize_design( layer_filter = [layer_filter] _layers = {k: v for k, v in self.stackup.layers.items() if k in layer_filter} for layer_name, layer in _layers.items(): - thickness_variable = "${}_thick".format(layer_name) - thickness_variable = self._clean_string_for_variable_name(thickness_variable) - if thickness_variable not in self.variables: - self.add_design_variable(thickness_variable, layer.thickness) - layer.thickness = thickness_variable - parameters.append(thickness_variable) + var, val = _apply_variable(f"${layer_name}", layer.thickness) + layer.thickness = var + parameters.append(val) if materials: if not material_filter: _materials = self.materials.materials @@ -4156,25 +4184,16 @@ def auto_parametrize_design( _materials = {k: v for k, v in self.materials.materials.items() if k in material_filter} for mat_name, material in _materials.items(): if material.conductivity < 1e4: - epsr_variable = "$epsr_{}".format(mat_name) - epsr_variable = self._clean_string_for_variable_name(epsr_variable) - if epsr_variable not in self.variables: - self.add_design_variable(epsr_variable, material.permittivity) - material.permittivity = epsr_variable - parameters.append(epsr_variable) - loss_tg_variable = "$loss_tangent_{}".format(mat_name) - loss_tg_variable = self._clean_string_for_variable_name(loss_tg_variable) - if not loss_tg_variable in self.variables: - self.add_design_variable(loss_tg_variable, material.dielectric_loss_tangent) - material.dielectric_loss_tangent = loss_tg_variable - parameters.append(loss_tg_variable) + var, val = _apply_variable(f"$epsr_{mat_name}", material.permittivity) + material.permittivity = var + parameters.append(val) + var, val = _apply_variable(f"$loss_tangent_{mat_name}", material.dielectric_loss_tangent) + material.dielectric_loss_tangent = var + parameters.append(val) else: - sigma_variable = "$sigma_{}".format(mat_name) - sigma_variable = self._clean_string_for_variable_name(sigma_variable) - if not sigma_variable in self.variables: - self.add_design_variable(sigma_variable, material.conductivity) - material.conductivity = sigma_variable - parameters.append(sigma_variable) + var, val = _apply_variable(f"$sigma_{mat_name}", material.conductivity) + material.conductivity = var + parameters.append(val) if traces: if not trace_net_filter: paths = self.modeler.paths @@ -4182,15 +4201,15 @@ def auto_parametrize_design( paths = [path for path in self.modeler.paths if path.net_name in trace_net_filter] for path in paths: net_name = path.net_name - if net_name: - trace_width_variable = f"{path.net_name}_{path.aedt_name}_width" + if use_relative_variables: + trace_width_variable = "trace" + elif net_name: + trace_width_variable = f"{path.net_name}_{path.aedt_name}" else: - trace_width_variable = f"{path.aedt_name}_width" - trace_width_variable = self._clean_string_for_variable_name(trace_width_variable) - if trace_width_variable not in self.variables: - self.add_design_variable(trace_width_variable, path.width) - path.width = trace_width_variable - parameters.append(trace_width_variable) + trace_width_variable = f"{path.aedt_name}" + var, val = _apply_variable(trace_width_variable, path.width) + path.width = var + parameters.append(val) if not padstack_definition_filter: if trace_net_filter: padstack_defs = {} @@ -4209,80 +4228,94 @@ def auto_parametrize_design( if not padstack_def.via_start_layer == padstack_def.via_stop_layer: if via_holes: # pragma no cover - hole_variable = self._clean_string_for_variable_name( f"${def_name}_hole_diam") - if hole_variable not in self.variables: - self.add_design_variable(hole_variable, padstack_def.hole_diameter_string) - padstack_def.hole_properties = hole_variable - parameters.append(hole_variable) + if use_relative_variables: + hole_variable = "$hole_diameter" + else: + hole_variable = f"${def_name}_hole_diameter" + var, val = _apply_variable(hole_variable, padstack_def.hole_diameter_string) + padstack_def.hole_properties = var + parameters.append(val) if pads: for layer, pad in padstack_def.pad_by_layer.items(): - if use_single_variable_for_padstack_definitions: + if use_relative_variables: + pad_name = "$pad" + elif use_single_variable_for_padstack_definitions: pad_name = f"${def_name}_pad" else: pad_name = f"${def_name}_{layer}_pad" - pad_variable = self._clean_string_for_variable_name(pad_name) - if pad.geometry_type in [1,2] and pad_variable not in self.variables: - self.add_design_variable(pad_variable, pad.parameters_values_string[0]) + if pad.geometry_type in [1,2]: + var, val = _apply_variable(pad_name, pad.parameters_values_string[0]) if pad.geometry_type == 1: - pad.parameters = {"Diameter": pad_variable} + pad.parameters = {"Diameter": var} else: - pad.parameters = {"Size": pad_variable} - parameters.append(pad_variable) + pad.parameters = {"Size": var} + parameters.append(val) elif pad.geometry_type == 3: # pragma no cover - if use_single_variable_for_padstack_definitions: + if use_relative_variables: + pad_name_x = "$pad_x" + pad_name_y = "$pad_y" + elif use_single_variable_for_padstack_definitions: pad_name_x = f"${def_name}_pad_x" pad_name_y = f"${def_name}_pad_y" else: pad_name_x = f"${def_name}_{layer}_pad_x" pad_name_y = f"${def_name}_pad_y" + var, val = _apply_variable(pad_name_x, pad.parameters_values_string[0]) + var2, val2 = _apply_variable(pad_name_y, pad.parameters_values_string[1]) - pad_name_x = self._clean_string_for_variable_name(pad_name_x) - pad_name_y = self._clean_string_for_variable_name(pad_name_y) - if pad_name_x not in self.variables and pad_name_y not in self.variables: - self.add_design_variable(pad_name_x, pad.parameters_values_string[0]) - self.add_design_variable(pad_name_y, pad.parameters_values_string[1]) - pad.parameters = {"XSize": pad_name_x, "YSize": pad_name_y} - parameters.append(pad_name_x) - parameters.append(pad_name_y) + pad.parameters = {"XSize": var, "YSize": var2} + parameters.append(val) + parameters.append(val2) if antipads: for layer, antipad in padstack_def.antipad_by_layer.items(): - if use_single_variable_for_padstack_definitions: + if use_relative_variables: + pad_name = "$antipad" + elif use_single_variable_for_padstack_definitions: pad_name = f"${def_name}_antipad" else: pad_name = f"${def_name}_{layer}_antipad" - antipad_variable = self._clean_string_for_variable_name(pad_name) - if antipad.geometry_type in [1,2] and antipad_variable not in self.variables: - self.add_design_variable(antipad_variable, antipad.parameters_values_string[0]) + if antipad.geometry_type in [1,2]: + var, val = _apply_variable(pad_name, antipad.parameters_values_string[0]) if antipad.geometry_type == 1: # pragma no cover - antipad.parameters = {"Diameter": antipad_variable} + antipad.parameters = {"Diameter": var} else: - antipad.parameters = {"Size": antipad_variable} - parameters.append(antipad_variable) + antipad.parameters = {"Size": var} + parameters.append(val) elif antipad.geometry_type == 3: # pragma no cover - if use_single_variable_for_padstack_definitions: + if use_relative_variables: + pad_name_x = "$antipad_x" + pad_name_y = "$antipad_y" + elif use_single_variable_for_padstack_definitions: pad_name_x = f"${def_name}_antipad_x" pad_name_y = f"${def_name}_antipad_y" else: pad_name_x = f"${def_name}_{layer}_antipad_x" pad_name_y = f"${def_name}_antipad_y" - pad_name_x = self._clean_string_for_variable_name(pad_name_x) - pad_name_y = self._clean_string_for_variable_name(pad_name_y) - if pad_name_x not in self.variables and pad_name_y not in self.variables: - self.add_design_variable(pad_name_x, antipad.parameters_values_string[0]) - self.add_design_variable(pad_name_y, antipad.parameters_values_string[1]) - if ( - pad_name_x not in self.variables - and pad_name_y not in self.variables - ): # pragma no cover - self.add_design_variable(pad_name_x, antipad.parameters_values_string[0]) - self.add_design_variable(pad_name_y, antipad.parameters_values_string[1]) - antipad.parameters = {"XSize": pad_name_x, "YSize": pad_name_y} - parameters.append(pad_name_x) - parameters.append(pad_name_y) + var, val = _apply_variable(pad_name_x, antipad.parameters_values_string[0]) + var2, val2 = _apply_variable(pad_name_y, antipad.parameters_values_string[1]) + antipad.parameters = {"XSize": var, "YSize": var2} + parameters.append(val) + parameters.append(val2) + if expand_polygons_size: + for poly in self.modeler.polygons: + if not poly.is_void: + poly.expand(expand_polygons_size) + if expand_voids_size: + for poly in self.modeler.polygons: + if poly.is_void: + poly.expand(expand_voids_size,round_corners=False) + elif poly.has_voids: + for void in poly.voids: + void.expand(expand_voids_size,round_corners=False) + if not open_aedb_at_end and self.edbpath != edb_original_path: + self.save_edb() + self.close_edb() + self.edbpath = edb_original_path + self.open_edb() return parameters def _clean_string_for_variable_name(self, variable_name): diff --git a/tests/legacy/system/test_edb_nets.py b/tests/legacy/system/test_edb_nets.py index 0f327c0757..a24d639ae0 100644 --- a/tests/legacy/system/test_edb_nets.py +++ b/tests/legacy/system/test_edb_nets.py @@ -151,9 +151,10 @@ def test_nets_merge_polygon(self): def test_layout_auto_parametrization(self): source_path = os.path.join(local_path, "example_models", test_subfolder, "ANSYS-HSD_V1.aedb") target_path = os.path.join(self.local_scratch.path, "test_auto_parameters", "test.aedb") + output_path = os.path.join(self.local_scratch.path, "test_auto_parameters", "test_absolute.aedb") self.local_scratch.copyfolder(source_path, target_path) edbapp = Edb(target_path, desktop_version) - edbapp.auto_parametrize_design( + parameters = edbapp.auto_parametrize_design( layers=True, layer_filter="1_Top", materials=False, @@ -161,8 +162,11 @@ def test_layout_auto_parametrization(self): pads=False, antipads=False, traces=False, + use_relative_variables=False, + output_aedb_path=output_path, + open_aedb_at_end=False, ) - assert "$1_Top_thick" in edbapp.variables + assert "$1_Top_value" in parameters edbapp.auto_parametrize_design( layers=True, materials=False, via_holes=False, pads=False, antipads=False, traces=False ) @@ -175,8 +179,10 @@ def test_layout_auto_parametrization(self): antipads=False, traces=False, material_filter=["copper"], + expand_voids_size=0.0001, + expand_polygons_size=0.0001, ) - assert "$sigma_copper" in edbapp.variables + assert "$sigma_copper_delta" in edbapp.variables edbapp.auto_parametrize_design( layers=False, materials=True, via_holes=False, pads=False, antipads=False, traces=False ) @@ -184,15 +190,15 @@ def test_layout_auto_parametrization(self): edbapp.auto_parametrize_design( layers=False, materials=False, via_holes=True, pads=False, antipads=False, traces=False ) - assert len(list(edbapp.variables.values())) == 65 + assert len(list(edbapp.variables.values())) == 27 edbapp.auto_parametrize_design( layers=False, materials=False, via_holes=False, pads=True, antipads=False, traces=False ) - assert len(list(edbapp.variables.values())) == 469 + assert len(list(edbapp.variables.values())) == 30 edbapp.auto_parametrize_design( layers=False, materials=False, via_holes=False, pads=False, antipads=True, traces=False ) - assert len(list(edbapp.variables.values())) == 469 + assert len(list(edbapp.variables.values())) == 30 edbapp.auto_parametrize_design( layers=False, materials=False, @@ -202,9 +208,5 @@ def test_layout_auto_parametrization(self): traces=True, trace_net_filter=["SFPA_Tx_Fault", "SFPA_Tx_Disable", "SFPA_SDA", "SFPA_SCL", "SFPA_Rx_LOS"], ) - assert len(list(edbapp.variables.keys())) == 474 - edbapp.auto_parametrize_design( - layers=False, materials=False, via_holes=False, pads=False, antipads=False, traces=True - ) - assert len(list(edbapp.variables.values())) == 2308 + assert len(list(edbapp.variables.keys())) == 31 edbapp.close_edb() From e01ac30064540794c3ef8dbc0842249480f2d499 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 15 Jul 2024 12:40:52 +0000 Subject: [PATCH 4/8] MISC: Auto fixes from pre-commit.com hooks For more information, see https://pre-commit.ci --- src/pyedb/dotnet/edb.py | 15 +++++++-------- tests/legacy/system/test_edb_nets.py | 2 +- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/src/pyedb/dotnet/edb.py b/src/pyedb/dotnet/edb.py index 8cf1a58a03..60ce9998a4 100644 --- a/src/pyedb/dotnet/edb.py +++ b/src/pyedb/dotnet/edb.py @@ -4150,6 +4150,7 @@ def auto_parametrize_design( if isinstance(trace_net_filter, str): trace_net_filter = [trace_net_filter] parameters = [] + def _apply_variable(orig_name, orig_value): if use_relative_variables: var = f"{orig_name}_delta" @@ -4164,7 +4165,7 @@ def _apply_variable(orig_name, orig_value): if use_relative_variables: return f"{orig_value}+{var}", var else: - return var, var + return var, var if layers: if not layer_filter: @@ -4227,18 +4228,16 @@ def _apply_variable(orig_name, orig_value): padstack_defs = {k: v for k, v in self.padstacks.definitions.items() if k in padstack_definition_filter} for def_name, padstack_def in padstack_defs.items(): - if not padstack_def.via_start_layer == padstack_def.via_stop_layer: if via_holes: # pragma no cover if use_relative_variables: hole_variable = "$hole_diameter" else: - hole_variable = f"${def_name}_hole_diameter" + hole_variable = f"${def_name}_hole_diameter" var, val = _apply_variable(hole_variable, padstack_def.hole_diameter_string) padstack_def.hole_properties = var parameters.append(val) if pads: - for layer, pad in padstack_def.pad_by_layer.items(): if use_relative_variables: pad_name = "$pad" @@ -4247,7 +4246,7 @@ def _apply_variable(orig_name, orig_value): else: pad_name = f"${def_name}_{layer}_pad" - if pad.geometry_type in [1,2]: + if pad.geometry_type in [1, 2]: var, val = _apply_variable(pad_name, pad.parameters_values_string[0]) if pad.geometry_type == 1: pad.parameters = {"Diameter": var} @@ -4279,7 +4278,7 @@ def _apply_variable(orig_name, orig_value): else: pad_name = f"${def_name}_{layer}_antipad" - if antipad.geometry_type in [1,2]: + if antipad.geometry_type in [1, 2]: var, val = _apply_variable(pad_name, antipad.parameters_values_string[0]) if antipad.geometry_type == 1: # pragma no cover antipad.parameters = {"Diameter": var} @@ -4309,10 +4308,10 @@ def _apply_variable(orig_name, orig_value): if expand_voids_size: for poly in self.modeler.polygons: if poly.is_void: - poly.expand(expand_voids_size,round_corners=False) + poly.expand(expand_voids_size, round_corners=False) elif poly.has_voids: for void in poly.voids: - void.expand(expand_voids_size,round_corners=False) + void.expand(expand_voids_size, round_corners=False) if not open_aedb_at_end and self.edbpath != edb_original_path: self.save_edb() self.close_edb() diff --git a/tests/legacy/system/test_edb_nets.py b/tests/legacy/system/test_edb_nets.py index a24d639ae0..3d85c9590c 100644 --- a/tests/legacy/system/test_edb_nets.py +++ b/tests/legacy/system/test_edb_nets.py @@ -151,7 +151,7 @@ def test_nets_merge_polygon(self): def test_layout_auto_parametrization(self): source_path = os.path.join(local_path, "example_models", test_subfolder, "ANSYS-HSD_V1.aedb") target_path = os.path.join(self.local_scratch.path, "test_auto_parameters", "test.aedb") - output_path = os.path.join(self.local_scratch.path, "test_auto_parameters", "test_absolute.aedb") + output_path = os.path.join(self.local_scratch.path, "test_auto_parameters", "test_absolute.aedb") self.local_scratch.copyfolder(source_path, target_path) edbapp = Edb(target_path, desktop_version) parameters = edbapp.auto_parametrize_design( From f22491c6cce33ba75d1dfbf6928c04d646ffa699 Mon Sep 17 00:00:00 2001 From: svandenb-dev Date: Tue, 16 Jul 2024 10:06:41 +0200 Subject: [PATCH 5/8] fixing bug with edbpath provided --- src/pyedb/dotnet/edb.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/pyedb/dotnet/edb.py b/src/pyedb/dotnet/edb.py index 60ce9998a4..4b42ae0280 100644 --- a/src/pyedb/dotnet/edb.py +++ b/src/pyedb/dotnet/edb.py @@ -4144,9 +4144,6 @@ def auto_parametrize_design( List(str) List of all parameters name created. """ - edb_original_path = self.edbpath - if output_aedb_path: - self.save_edb_as(output_aedb_path) if isinstance(trace_net_filter, str): trace_net_filter = [trace_net_filter] parameters = [] @@ -4312,6 +4309,9 @@ def _apply_variable(orig_name, orig_value): elif poly.has_voids: for void in poly.voids: void.expand(expand_voids_size, round_corners=False) + edb_original_path = self.edbpath + if output_aedb_path: + self.save_edb_as(output_aedb_path) if not open_aedb_at_end and self.edbpath != edb_original_path: self.save_edb() self.close_edb() From 1466aed6f0599b03e1cee8f473db8c173a4685cd Mon Sep 17 00:00:00 2001 From: svandenb-dev Date: Tue, 16 Jul 2024 10:22:23 +0200 Subject: [PATCH 6/8] fixing bug with edbpath provided --- src/pyedb/dotnet/edb.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/pyedb/dotnet/edb.py b/src/pyedb/dotnet/edb.py index 4b42ae0280..a2305d256d 100644 --- a/src/pyedb/dotnet/edb.py +++ b/src/pyedb/dotnet/edb.py @@ -4144,6 +4144,8 @@ def auto_parametrize_design( List(str) List of all parameters name created. """ + if output_aedb_path: + self.save_edb_as(output_aedb_path) if isinstance(trace_net_filter, str): trace_net_filter = [trace_net_filter] parameters = [] @@ -4310,13 +4312,13 @@ def _apply_variable(orig_name, orig_value): for void in poly.voids: void.expand(expand_voids_size, round_corners=False) edb_original_path = self.edbpath - if output_aedb_path: - self.save_edb_as(output_aedb_path) if not open_aedb_at_end and self.edbpath != edb_original_path: self.save_edb() self.close_edb() self.edbpath = edb_original_path self.open_edb() + else: + self.save() return parameters def _clean_string_for_variable_name(self, variable_name): From bb8d208fba5bff715a18f6dc173810a7ff855b5b Mon Sep 17 00:00:00 2001 From: svandenb-dev Date: Tue, 16 Jul 2024 10:31:22 +0200 Subject: [PATCH 7/8] fixing bug with edbpath provided --- src/pyedb/dotnet/edb.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/pyedb/dotnet/edb.py b/src/pyedb/dotnet/edb.py index a2305d256d..21d54a6811 100644 --- a/src/pyedb/dotnet/edb.py +++ b/src/pyedb/dotnet/edb.py @@ -4144,6 +4144,7 @@ def auto_parametrize_design( List(str) List of all parameters name created. """ + edb_original_path = self.edbpath if output_aedb_path: self.save_edb_as(output_aedb_path) if isinstance(trace_net_filter, str): @@ -4311,14 +4312,14 @@ def _apply_variable(orig_name, orig_value): elif poly.has_voids: for void in poly.voids: void.expand(expand_voids_size, round_corners=False) - edb_original_path = self.edbpath + if not open_aedb_at_end and self.edbpath != edb_original_path: self.save_edb() self.close_edb() self.edbpath = edb_original_path self.open_edb() - else: - self.save() + # elif open_aedb_at_end and self.edbpath != edb_original_path: + # self.save() return parameters def _clean_string_for_variable_name(self, variable_name): From 69851b0b8f5cb7303b2b659b88234043ed9ca8f9 Mon Sep 17 00:00:00 2001 From: svandenb-dev Date: Tue, 16 Jul 2024 10:38:16 +0200 Subject: [PATCH 8/8] fixing bug with edbpath provided --- src/pyedb/dotnet/edb.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/pyedb/dotnet/edb.py b/src/pyedb/dotnet/edb.py index 21d54a6811..c236a20646 100644 --- a/src/pyedb/dotnet/edb.py +++ b/src/pyedb/dotnet/edb.py @@ -4318,8 +4318,6 @@ def _apply_variable(orig_name, orig_value): self.close_edb() self.edbpath = edb_original_path self.open_edb() - # elif open_aedb_at_end and self.edbpath != edb_original_path: - # self.save() return parameters def _clean_string_for_variable_name(self, variable_name):