Merge branch 'main' into maxwell_refactoring

gmalinve · gmalinve · commit 83e93cebfecd · 2024-04-09T16:11:37.000+02:00
diff --git a/_unittest/test_01_3dlayout_edb.py b/_unittest/test_01_3dlayout_edb.py
@@ -186,13 +186,24 @@ def test_03C_voids(self):
 
     def test_04_add_mesh_operations(self):
         self.aedtapp.create_setup("HFSS")
-        setup1 = self.aedtapp.mesh.assign_length_mesh("HFSS", "PWR", "GND")
-        setup2 = self.aedtapp.mesh.assign_skin_depth("HFSS", "PWR", "GND")
+        setup1 = self.aedtapp.mesh.assign_length_mesh(
+            "HFSS",
+            "PWR",
+            "GND",
+        )
+        setup2 = self.aedtapp.mesh.assign_skin_depth(
+            "HFSS",
+            "PWR",
+            "GND",
+        )
         assert setup1
         assert setup2
         setup1.props["RestrictElem"] = False
         assert setup1.update()
-        assert self.aedtapp.mesh.delete_mesh_operations("HFSS", setup1.name)
+        assert self.aedtapp.mesh.delete_mesh_operations(
+            "HFSS",
+            setup1.name,
+        )
 
     def test_05_change_property(self):
         ports = self.aedtapp.create_ports_on_component_by_nets(
diff --git a/_unittest/test_01_Design.py b/_unittest/test_01_Design.py
@@ -46,7 +46,7 @@ def test_01_designname(self):
         assert self.aedtapp.design_name == design_names[1]
         self.aedtapp.design_name = design_names[0]  # Change current design back.
         assert len(self.aedtapp.design_list) == 2  # Make sure there are still 2 designs.
-        assert self.aedtapp.design_list[0] == design_names[0]  # Make sure the name is correct.
+        assert self.aedtapp.design_list[0] in design_names  # Make sure the name is correct.
         self.aedtapp.delete_design(design_names[1])  # Delete the 2nd design
         assert len(self.aedtapp.design_list) == 1
 
diff --git a/_unittest/test_05_Mesh.py b/_unittest/test_05_Mesh.py
@@ -61,7 +61,7 @@ def test_03_assign_surface_mesh_manual(self):
         udp = self.aedtapp.modeler.Position(20, 20, 0)
         coax_dimension = 200
         o = self.aedtapp.modeler.create_cylinder(self.aedtapp.PLANE.XY, udp, 3, coax_dimension, 0, "surface_manual")
-        surface = self.aedtapp.mesh.assign_surface_mesh_manual(o.id, 1e-6, aspect_ratio=3, meshop_name="Surface_Manual")
+        surface = self.aedtapp.mesh.assign_surface_mesh_manual(o.id, 1e-6, aspect_ratio=3, name="Surface_Manual")
         assert "Surface_Manual" in [i.name for i in self.aedtapp.mesh.meshoperations]
         assert surface.props["SurfDev"] == 1e-6
         surface.props["SurfDev"] = 1e-05
@@ -123,7 +123,7 @@ def test_06_curvature_extraction(self):
     def test_07_maxwell_mesh(self, add_app):
         m3d = add_app(application=Maxwell3d)
         o = m3d.modeler.create_box([0, 0, 0], [10, 10, 10], name="Box_Mesh")
-        rot = m3d.mesh.assign_rotational_layer(o.name, meshop_name="Rotational", total_thickness="5mm")
+        rot = m3d.mesh.assign_rotational_layer(o.name, total_thickness="5mm", name="Rotational")
         assert rot.props["Number of Layers"] == "3"
         rot.props["Number of Layers"] = 1
         assert str(rot.props["Number of Layers"]) == m3d.odesign.GetChildObject("Mesh").GetChildObject(
@@ -135,14 +135,14 @@ def test_07_maxwell_mesh(self, add_app):
             rot.name
         ).GetPropValue("Total Layer Thickness")
 
-        edge_cut = m3d.mesh.assign_edge_cut(o.name, meshop_name="Edge")
+        edge_cut = m3d.mesh.assign_edge_cut(o.name, name="Edge")
         assert edge_cut.props["Layer Thickness"] == "1mm"
         edge_cut.props["Layer Thickness"] = "2mm"
         assert edge_cut.props["Layer Thickness"] == m3d.odesign.GetChildObject("Mesh").GetChildObject(
             edge_cut.name
         ).GetPropValue("Layer Thickness")
 
-        dens = m3d.mesh.assign_density_control(o.name, maxelementlength=10000, meshop_name="Density")
+        dens = m3d.mesh.assign_density_control(o.name, maximum_element_length=10000, name="Density")
         assert dens.props["RestrictMaxElemLength"]
 
         assert dens.props["MaxElemLength"] == 10000
diff --git a/_unittest/test_20_HFSS.py b/_unittest/test_20_HFSS.py
@@ -830,6 +830,7 @@ def test_20_create_voltage_on_sheet(self):
 
     def test_21_create_open_region(self):
         assert self.aedtapp.create_open_region("1GHz")
+        assert len(self.aedtapp.field_setups) == 3
         assert self.aedtapp.create_open_region("1GHz", "FEBI")
         assert self.aedtapp.create_open_region("1GHz", "PML", True, "-z")
 
diff --git a/_unittest/test_27_Maxwell2D.py b/_unittest/test_27_Maxwell2D.py
@@ -420,15 +420,15 @@ def test_31_cylindrical_gap(self):
             for x in self.aedtapp.mesh.meshoperations[:]
             if x.type == "Cylindrical Gap Based" or x.type == "CylindricalGap"
         ]
-        assert self.aedtapp.mesh.assign_cylindrical_gap("Band", meshop_name="cyl_gap_test")
+        assert self.aedtapp.mesh.assign_cylindrical_gap("Band", name="cyl_gap_test")
         assert not self.aedtapp.mesh.assign_cylindrical_gap(["Band", "Region"])
         assert not self.aedtapp.mesh.assign_cylindrical_gap("Band")
         [
             x.delete()
             for x in self.aedtapp.mesh.meshoperations[:]
             if x.type == "Cylindrical Gap Based" or x.type == "CylindricalGap"
         ]
-        assert self.aedtapp.mesh.assign_cylindrical_gap("Band", meshop_name="cyl_gap_test", band_mapping_angle=2)
+        assert self.aedtapp.mesh.assign_cylindrical_gap("Band", name="cyl_gap_test", band_mapping_angle=2)
 
     def test_32_control_program(self):
         user_ctl_path = "user.ctl"
diff --git a/_unittest/test_28_Maxwell3D.py b/_unittest/test_28_Maxwell3D.py
@@ -267,7 +267,7 @@ def test_24_create_edge_cut(self):
         assert self.aedtapp.mesh.assign_edge_cut(["Coil"])
 
     def test_24_density_control(self):
-        assert self.aedtapp.mesh.assign_density_control(["Coil"], maxelementlength="2mm", layerNum="3")
+        assert self.aedtapp.mesh.assign_density_control(["Coil"], maximum_element_length="2mm", layers_number="3")
 
     def test_24_density_control(self):
         assert self.aedtapp.mesh.assign_rotational_layer(["Coil"])
@@ -776,37 +776,35 @@ def test_49_cylindrical_gap(self, cyl_gap):
             for x in cyl_gap.mesh.meshoperations[:]
             if x.type == "Cylindrical Gap Based" or x.type == "CylindricalGap"
         ]
-        assert cyl_gap.mesh.assign_cylindrical_gap("Band", meshop_name="cyl_gap_test")
+        assert cyl_gap.mesh.assign_cylindrical_gap("Band", name="cyl_gap_test")
         assert not cyl_gap.mesh.assign_cylindrical_gap(["Band", "Inner_Band"])
         assert not cyl_gap.mesh.assign_cylindrical_gap("Band")
         [
             x.delete()
             for x in cyl_gap.mesh.meshoperations[:]
             if x.type == "Cylindrical Gap Based" or x.type == "CylindricalGap"
         ]
-        assert cyl_gap.mesh.assign_cylindrical_gap(
-            "Band", meshop_name="cyl_gap_test", clone_mesh=True, band_mapping_angle=1
-        )
+        assert cyl_gap.mesh.assign_cylindrical_gap("Band", name="cyl_gap_test", band_mapping_angle=1, clone_mesh=True)
         [
             x.delete()
             for x in cyl_gap.mesh.meshoperations[:]
             if x.type == "Cylindrical Gap Based" or x.type == "CylindricalGap"
         ]
-        assert cyl_gap.mesh.assign_cylindrical_gap("Band", meshop_name="cyl_gap_test", clone_mesh=False)
+        assert cyl_gap.mesh.assign_cylindrical_gap("Band", name="cyl_gap_test", clone_mesh=False)
         [
             x.delete()
             for x in cyl_gap.mesh.meshoperations[:]
             if x.type == "Cylindrical Gap Based" or x.type == "CylindricalGap"
         ]
         assert cyl_gap.mesh.assign_cylindrical_gap("Band")
         assert not cyl_gap.mesh.assign_cylindrical_gap(
-            "Band", meshop_name="cyl_gap_test", clone_mesh=True, band_mapping_angle=7
+            "Band", name="cyl_gap_test", band_mapping_angle=7, clone_mesh=True
         )
         assert not cyl_gap.mesh.assign_cylindrical_gap(
-            "Band", meshop_name="cyl_gap_test", clone_mesh=True, band_mapping_angle=2, moving_side_layers=0
+            "Band", name="cyl_gap_test", band_mapping_angle=2, clone_mesh=True, moving_side_layers=0
         )
         assert not cyl_gap.mesh.assign_cylindrical_gap(
-            "Band", meshop_name="cyl_gap_test", clone_mesh=True, band_mapping_angle=2, static_side_layers=0
+            "Band", name="cyl_gap_test", band_mapping_angle=2, clone_mesh=True, static_side_layers=0
         )
 
     def test_50_objects_segmentation(self, cyl_gap):
diff --git a/_unittest/test_98_Icepak.py b/_unittest/test_98_Icepak.py
@@ -397,7 +397,7 @@ def test_31_automatic_mesh_pcb(self):
 
     def test_32_automatic_mesh_3d(self):
         self.aedtapp.set_active_design("IcepakDesign1")
-        assert self.aedtapp.mesh.automatic_mesh_3D(accuracy2=1)
+        assert self.aedtapp.mesh.automatic_mesh_3D(accuracy=1)
 
     def test_33_create_source(self):
         self.aedtapp.modeler.create_box([0, 0, 0], [20, 20, 20], name="boxSource")
@@ -1039,9 +1039,9 @@ def test_56_mesh_priority(self):
             custom_x_resolution=400,
             custom_y_resolution=500,
         )
-        assert self.aedtapp.mesh.add_priority(entity_type=1, obj_list=self.aedtapp.modeler.object_names, priority=2)
+        assert self.aedtapp.mesh.add_priority(entity_type=1, objects=self.aedtapp.modeler.object_names, priority=2)
         assert self.aedtapp.mesh.add_priority(
-            entity_type=2, comp_name=self.aedtapp.modeler.user_defined_component_names[0], priority=1
+            entity_type=2, component=self.aedtapp.modeler.user_defined_component_names[0], priority=1
         )
 
     def test_57_update_source(self):
@@ -1354,11 +1354,11 @@ def test_68_mesh_priority_3d_comp(self, add_app):
             design_name="IcepakDesign1",
             subfolder=test_subfolder,
         )
-        assert app.mesh.add_priority(entity_type=2, comp_name="IcepakDesign1_1", priority=3)
+        assert app.mesh.add_priority(entity_type=2, component="IcepakDesign1_1", priority=3)
 
-        assert app.mesh.add_priority(entity_type=2, comp_name="all_2d_objects1", priority=2)
+        assert app.mesh.add_priority(entity_type=2, component="all_2d_objects1", priority=2)
 
-        assert app.mesh.add_priority(entity_type=2, comp_name="all_3d_objects1", priority=2)
+        assert app.mesh.add_priority(entity_type=2, component="all_3d_objects1", priority=2)
 
         app.close_project(name="3d_comp_mesh_prio_test", save_project=False)
 
diff --git a/examples/02-HFSS/HFSS_Choke.py b/examples/02-HFSS/HFSS_Choke.py
@@ -180,7 +180,7 @@
 mesh_operation_cylinder = hfss.modeler.create_cylinder(
     "XY", cylinder_position, ground_radius, cylinder_height, numSides=36, name="mesh_cylinder"
 )
-hfss.mesh.assign_length_mesh([mesh_operation_cylinder], maxlength=15, maxel=None, meshop_name="choke_mesh")
+hfss.mesh.assign_length_mesh([mesh_operation_cylinder], maximum_length=15, maximum_elements=None, name="choke_mesh")
 
 
 ###############################################################################
diff --git a/examples/03-Maxwell/Maxwell2D_DCConduction.py b/examples/03-Maxwell/Maxwell2D_DCConduction.py
@@ -99,7 +99,7 @@
 # ~~~~~~~~~~~~~~~~~~~~~
 # 3mm on the conductor
 
-m2d.mesh.assign_length_mesh(["ANSYS_LOGO_2D_3"], meshop_name="conductor", maxlength=3, maxel=None)
+m2d.mesh.assign_length_mesh(["ANSYS_LOGO_2D_3"], maximum_length=3, maximum_elements=None, name="conductor")
 
 ##################################################################################
 # Create simulation setup and enable expression cache
diff --git a/examples/03-Maxwell/Maxwell2D_Electrostatic.py b/examples/03-Maxwell/Maxwell2D_Electrostatic.py
@@ -137,7 +137,7 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # Assign a surface mesh to the rectangle.
 
-M2D.mesh.assign_surface_mesh_manual(names=['Ground'], surf_dev=0.001)
+M2D.mesh.assign_surface_mesh_manual(objects=['Ground'], surface_deviation=0.001)
 
 ##################################################################################
 # Create, validate and analyze the setup
diff --git a/examples/03-Maxwell/Maxwell2D_PMSynchronousMotor.py b/examples/03-Maxwell/Maxwell2D_PMSynchronousMotor.py
@@ -535,9 +535,9 @@ def create_cs_magnets(pm_id, cs_name, point_direction):
 # ~~~~~~~~~~~~~~~~~~~~~~
 # Create the mesh operations.
 
-M2D.mesh.assign_length_mesh(id_coils, isinside=True, maxlength=3, maxel=None, meshop_name="coils")
-M2D.mesh.assign_length_mesh(stator_id, isinside=True, maxlength=3, maxel=None, meshop_name="stator")
-M2D.mesh.assign_length_mesh(rotor_id, isinside=True, maxlength=3, maxel=None, meshop_name="rotor")
+M2D.mesh.assign_length_mesh(id_coils, inside_selection=True, maximum_length=3, maximum_elements=None, name="coils")
+M2D.mesh.assign_length_mesh(stator_id, inside_selection=True, maximum_length=3, maximum_elements=None, name="stator")
+M2D.mesh.assign_length_mesh(rotor_id, inside_selection=True, maximum_length=3, maximum_elements=None, name="rotor")
 
 ##########################################################
 # Turn on eddy effects
diff --git a/examples/03-Maxwell/Maxwell3D_Choke.py b/examples/03-Maxwell/Maxwell3D_Choke.py
@@ -176,18 +176,10 @@
 # Create the mesh operation.
 
 mesh = m3d.mesh
-mesh.assign_skin_depth(
-    names=[first_winding_list[0], second_winding_list[0], third_winding_list[0]],
-    skindepth=0.20,
-    triangulation_max_length="10mm",
-    meshop_name="skin_depth",
-)
-mesh.assign_surface_mesh_manual(
-    [first_winding_list[0], second_winding_list[0], third_winding_list[0]],
-    surf_dev=None,
-    normal_dev="30deg",
-    meshop_name="surface_approx",
-)
+mesh.assign_skin_depth(objects=[first_winding_list[0], second_winding_list[0], third_winding_list[0]], skin_depth=0.20,
+                       triangulation_max_length="10mm", name="skin_depth")
+mesh.assign_surface_mesh_manual([first_winding_list[0], second_winding_list[0], third_winding_list[0]],
+                                surface_deviation=None, normal_dev="30deg", name="surface_approx")
 
 ###############################################################################
 # Create boundaries
diff --git a/examples/03-Maxwell/Maxwell3D_Team3_bath_plate.py b/examples/03-Maxwell/Maxwell3D_Team3_bath_plate.py
@@ -97,7 +97,7 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # Add a mesh refinement to the ladder plate.
 
-m3d.mesh.assign_length_mesh("LadderPlate", maxlength=3, maxel=None, meshop_name="Ladder_Mesh")
+m3d.mesh.assign_length_mesh("LadderPlate", maximum_length=3, maximum_elements=None, name="Ladder_Mesh")
 
 ################################################################################
 # Draw search coil and assign excitation
diff --git a/examples/04-Icepak/Icepak_Example.py b/examples/04-Icepak/Icepak_Example.py
@@ -72,7 +72,7 @@
 # ~~~~~~~~~~~~~~~~~~~
 # Assign a mesh region to the heat sink and CPU.
 
-mesh_region = ipk.mesh.assign_mesh_region(objectlist=["HEAT_SINK", "CPU"])
+mesh_region = ipk.mesh.assign_mesh_region(objects=["HEAT_SINK", "CPU"])
 mesh_region.UserSpecifiedSettings = True
 mesh_region.MaxElementSizeX = "3.35mm"
 mesh_region.MaxElementSizeY = "1.75mm"
diff --git a/examples/06-Multiphysics/Hfss_Icepak_Coupling.py b/examples/06-Multiphysics/Hfss_Icepak_Coupling.py
@@ -118,8 +118,8 @@
 # edit or review parameter values.
 
 aedtapp.mesh.assign_initial_mesh_from_slider(level=6)
-aedtapp.mesh.assign_model_resolution(names=[o1.name, o3.name], defeature_length=None)
-aedtapp.mesh.assign_length_mesh(names=o2.faces, isinside=False, maxlength=1, maxel=2000)
+aedtapp.mesh.assign_model_resolution(objects=[o1.name, o3.name], defeature_length=None)
+aedtapp.mesh.assign_length_mesh(objects=o2.faces, inside_selection=False, maximum_length=1, maximum_elements=2000)
 
 ###############################################################################
 # Create excitations
diff --git a/examples/06-Multiphysics/Maxwell3D_Icepak_2Way_Coupling.py b/examples/06-Multiphysics/Maxwell3D_Icepak_2Way_Coupling.py
@@ -109,12 +109,8 @@
 # Mesh operations are not necessary in eddy current solver because of auto-adaptive meshing.
 # However, with appropriate mesh operations, less adaptive passes are needed.
 
-m3d.mesh.assign_length_mesh(
-    ["Core"], maxlength=15, meshop_name="Inside_Core", maxel=None
-)
-m3d.mesh.assign_length_mesh(
-    ["Coil"], maxlength=30, meshop_name="Inside_Coil", maxel=None
-)
+m3d.mesh.assign_length_mesh(["Core"], maximum_length=15, maximum_elements=None, name="Inside_Core")
+m3d.mesh.assign_length_mesh(["Coil"], maximum_length=30, maximum_elements=None, name="Inside_Coil")
 
 ###############################################################################
 # Set conductivity temperature coefficient
diff --git a/pyaedt/generic/compliance.py b/pyaedt/generic/compliance.py
@@ -691,6 +691,7 @@ def _add_statistical_violations(self, report, pdf_report, image_name, local_conf
             self._desktop_class.logger.error(msg)
             return
         mag_data = {i: k for i, k in sols.full_matrix_real_imag[0][sols.expressions[0]].items() if k > 0}
+        # mag_data is a dictionary. The key isa tuple (__AMPLITUDE, __UI), and the value is the eye value.
         mystr = "Eye Mask Violation:"
         result_value = "PASS"
         points_to_check = [i[::-1] for i in local_config["eye_mask"]["points"]]
@@ -711,13 +712,14 @@ def _add_statistical_violations(self, report, pdf_report, image_name, local_conf
         if result_value == "FAIL":
             result_value = f"FAIL on {num_failed} points."
         pass_fail_table.append([mystr, result_value])
-
+        result_value = "PASS"
         if local_config["eye_mask"]["enable_limits"]:
             mystr = "Upper/Lower Mask Violation:"
             for point in mag_data:
+                # checking if amplitude is overcoming limits.
                 if (
-                    point[1] > local_config["eye_mask"]["upper_limit"]
-                    or point[1] < local_config["eye_mask"]["lower_limit"]
+                    point[0] > local_config["eye_mask"]["upper_limit"]
+                    or point[0] < local_config["eye_mask"]["lower_limit"]
                 ):
                     result_value = "FAIL"
                     break
diff --git a/pyaedt/hfss.py b/pyaedt/hfss.py
@@ -2848,6 +2848,7 @@ def create_open_region(self, Frequency="1GHz", Boundary="Radiation", ApplyInfini
 
         self.omodelsetup.CreateOpenRegion(vars)
         self.logger.info("Open Region correctly created.")
+        self.save_project()
         return True
 
     @pyaedt_function_handler()
diff --git a/pyaedt/modules/Mesh.py b/pyaedt/modules/Mesh.py
diff --git a/pyaedt/modules/Mesh3DLayout.py b/pyaedt/modules/Mesh3DLayout.py
diff --git a/pyaedt/modules/MeshIcepak.py b/pyaedt/modules/MeshIcepak.py

Original file line number	Diff line number	Diff line change
`@@ -420,15 +420,15 @@ def test_31_cylindrical_gap(self):`
`420`	`420`	`for x in self.aedtapp.mesh.meshoperations[:]`
`421`	`421`	`if x.type == "Cylindrical Gap Based" or x.type == "CylindricalGap"`
`422`	`422`	`]`
`423`		`- assert self.aedtapp.mesh.assign_cylindrical_gap("Band", meshop_name="cyl_gap_test")`
	`423`	`+ assert self.aedtapp.mesh.assign_cylindrical_gap("Band", name="cyl_gap_test")`
`424`	`424`	`assert not self.aedtapp.mesh.assign_cylindrical_gap(["Band", "Region"])`
`425`	`425`	`assert not self.aedtapp.mesh.assign_cylindrical_gap("Band")`
`426`	`426`	`[`
`427`	`427`	`x.delete()`
`428`	`428`	`for x in self.aedtapp.mesh.meshoperations[:]`
`429`	`429`	`if x.type == "Cylindrical Gap Based" or x.type == "CylindricalGap"`
`430`	`430`	`]`
`431`		`- assert self.aedtapp.mesh.assign_cylindrical_gap("Band", meshop_name="cyl_gap_test", band_mapping_angle=2)`
	`431`	`+ assert self.aedtapp.mesh.assign_cylindrical_gap("Band", name="cyl_gap_test", band_mapping_angle=2)`
`432`	`432`
`433`	`433`	`def test_32_control_program(self):`
`434`	`434`	`user_ctl_path = "user.ctl"`
Original file line number	Diff line number	Diff line change
`@@ -267,7 +267,7 @@ def test_24_create_edge_cut(self):`
`267`	`267`	`assert self.aedtapp.mesh.assign_edge_cut(["Coil"])`
`268`	`268`
`269`	`269`	`def test_24_density_control(self):`
`270`		`- assert self.aedtapp.mesh.assign_density_control(["Coil"], maxelementlength="2mm", layerNum="3")`
	`270`	`+ assert self.aedtapp.mesh.assign_density_control(["Coil"], maximum_element_length="2mm", layers_number="3")`
`271`	`271`
`272`	`272`	`def test_24_density_control(self):`
`273`	`273`	`assert self.aedtapp.mesh.assign_rotational_layer(["Coil"])`
`@@ -776,37 +776,35 @@ def test_49_cylindrical_gap(self, cyl_gap):`
`776`	`776`	`for x in cyl_gap.mesh.meshoperations[:]`
`777`	`777`	`if x.type == "Cylindrical Gap Based" or x.type == "CylindricalGap"`
`778`	`778`	`]`
`779`		`- assert cyl_gap.mesh.assign_cylindrical_gap("Band", meshop_name="cyl_gap_test")`
	`779`	`+ assert cyl_gap.mesh.assign_cylindrical_gap("Band", name="cyl_gap_test")`
`780`	`780`	`assert not cyl_gap.mesh.assign_cylindrical_gap(["Band", "Inner_Band"])`
`781`	`781`	`assert not cyl_gap.mesh.assign_cylindrical_gap("Band")`
`782`	`782`	`[`
`783`	`783`	`x.delete()`
`784`	`784`	`for x in cyl_gap.mesh.meshoperations[:]`
`785`	`785`	`if x.type == "Cylindrical Gap Based" or x.type == "CylindricalGap"`
`786`	`786`	`]`
`787`		`- assert cyl_gap.mesh.assign_cylindrical_gap(`
`788`		`- "Band", meshop_name="cyl_gap_test", clone_mesh=True, band_mapping_angle=1`
`789`		`- )`
	`787`	`+ assert cyl_gap.mesh.assign_cylindrical_gap("Band", name="cyl_gap_test", band_mapping_angle=1, clone_mesh=True)`
`790`	`788`	`[`
`791`	`789`	`x.delete()`
`792`	`790`	`for x in cyl_gap.mesh.meshoperations[:]`
`793`	`791`	`if x.type == "Cylindrical Gap Based" or x.type == "CylindricalGap"`
`794`	`792`	`]`
`795`		`- assert cyl_gap.mesh.assign_cylindrical_gap("Band", meshop_name="cyl_gap_test", clone_mesh=False)`
	`793`	`+ assert cyl_gap.mesh.assign_cylindrical_gap("Band", name="cyl_gap_test", clone_mesh=False)`
`796`	`794`	`[`
`797`	`795`	`x.delete()`
`798`	`796`	`for x in cyl_gap.mesh.meshoperations[:]`
`799`	`797`	`if x.type == "Cylindrical Gap Based" or x.type == "CylindricalGap"`
`800`	`798`	`]`
`801`	`799`	`assert cyl_gap.mesh.assign_cylindrical_gap("Band")`
`802`	`800`	`assert not cyl_gap.mesh.assign_cylindrical_gap(`
`803`		`- "Band", meshop_name="cyl_gap_test", clone_mesh=True, band_mapping_angle=7`
	`801`	`+ "Band", name="cyl_gap_test", band_mapping_angle=7, clone_mesh=True`
`804`	`802`	`)`
`805`	`803`	`assert not cyl_gap.mesh.assign_cylindrical_gap(`
`806`		`- "Band", meshop_name="cyl_gap_test", clone_mesh=True, band_mapping_angle=2, moving_side_layers=0`
	`804`	`+ "Band", name="cyl_gap_test", band_mapping_angle=2, clone_mesh=True, moving_side_layers=0`
`807`	`805`	`)`
`808`	`806`	`assert not cyl_gap.mesh.assign_cylindrical_gap(`
`809`		`- "Band", meshop_name="cyl_gap_test", clone_mesh=True, band_mapping_angle=2, static_side_layers=0`
	`807`	`+ "Band", name="cyl_gap_test", band_mapping_angle=2, clone_mesh=True, static_side_layers=0`
`810`	`808`	`)`
`811`	`809`
`812`	`810`	`def test_50_objects_segmentation(self, cyl_gap):`
Original file line number	Diff line number	Diff line change
`@@ -180,7 +180,7 @@`
`180`	`180`	`mesh_operation_cylinder = hfss.modeler.create_cylinder(`
`181`	`181`	`"XY", cylinder_position, ground_radius, cylinder_height, numSides=36, name="mesh_cylinder"`
`182`	`182`	`)`
`183`		`-hfss.mesh.assign_length_mesh([mesh_operation_cylinder], maxlength=15, maxel=None, meshop_name="choke_mesh")`
	`183`	`+hfss.mesh.assign_length_mesh([mesh_operation_cylinder], maximum_length=15, maximum_elements=None, name="choke_mesh")`
`184`	`184`
`185`	`185`
`186`	`186`	`###############################################################################`