Update tests related to addition of new element types (INTER and MPC) (#664)

* Update tests related to addition of new element types (INTER and MPC)

* Update the PR: run pre commit

* Update the PR: add a condition on server version

Author: MichaelNale

tests/conftest.py

@@ -204,6 +204,10 @@ def grpc_server():
     server.shutdown()
 
 
+SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_9_0 = meets_version(
+    get_server_version(core._global_server()), "9.0"
+)
+
 SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_8_0 = meets_version(
     get_server_version(core._global_server()), "8.0"
 )

tests/test_dpfresultwithkeywords.py

@@ -7,6 +7,7 @@
 
 from ansys import dpf
 from ansys.dpf import post
+from conftest import SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_9_0
 
 
 def test_displacement_with_scoping_verbose_api(allkindofcomplexity):
@@ -254,55 +255,61 @@ def test_stress_with_invariant_subresult(allkindofcomplexity):
     assert stress.result_fields_container[0].location == locations.elemental_nodal
 
 
-# def test_groupingelshape_nodallocation_verbose_api(allkindofcomplexity):
-#     result = post.load_solution(allkindofcomplexity)
-#     disp = result.misc.nodal_displacement(grouping=post.grouping.by_el_shape)
-#     assert disp.num_fields == 4
-#     assert disp.result_fields_container.get_label_space(3) == {"elshape": 3, "time": 1}
-#     assert len(disp.get_data_at_field(0)) == 14826
-#     assert len(disp.get_data_at_field(1)) == 1486
-#     assert len(disp.get_data_at_field(2)) == 19
-#     assert len(disp.get_data_at_field(3)) == 4
-#     assert np.isclose(disp.get_data_at_field(2)[0][0], 5.523488975819807e-20)
-#     assert disp[0].location == locations.nodal
-
-
-# def test_groupingelshape_nodallocation(allkindofcomplexity):
-#     result = post.load_solution(allkindofcomplexity)
-#     d = result.displacement(grouping=post.grouping.by_el_shape)
-#     disp = d.vector
-#     assert disp.num_fields == 4
-#     assert disp.result_fields_container.get_label_space(3) == {"elshape": 3, "time": 1}
-#     assert len(disp.get_data_at_field(0)) == 14826
-#     assert len(disp.get_data_at_field(1)) == 1486
-#     assert len(disp.get_data_at_field(2)) == 19
-#     assert len(disp.get_data_at_field(3)) == 4
-#     assert np.isclose(disp.get_data_at_field(2)[0][0], 5.523488975819807e-20)
-#     assert disp[0].location == locations.nodal
-#
-# with dpf.core operator
-# from ansys.dpf import core
-#
-# op = core.Operator("U")
-# # op.inputs.requested_location.connect(core.locations.nodal)
-# op.inputs.data_sources.connect(core.DataSources(allkindofcomplexity))
-# mesh_provider = core.Operator("MeshProvider")
-# mesh_provider.inputs.data_sources.connect(core.DataSources(allkindofcomplexity))
-# scop_op = core.Operator("scoping::by_property")
-# scop_op.inputs.mesh.connect(mesh_provider.outputs.mesh)
-# scop_op.inputs.requested_location.connect(core.locations.nodal)
-# scop_op.inputs.label1.connect("elshape")
-# op.inputs.mesh_scoping.connect(scop_op.outputs.mesh_scoping)
-# fc = op.outputs.fields_container()
-# assert len(fc) == disp.num_fields
-# assert fc[0].location == disp[0].location
-# assert len(fc[0].data) == len(disp[0].data)
-# assert np.allclose(disp[0].data.tolist(), fc[0].data.tolist())
-# comp = core.operators.logic.identical_fc()
-# comp.inputs.fields_containerA.connect(fc)
-# comp.inputs.fields_containerB.connect(disp.result_fields_container)
-# out = comp.outputs.boolean()
-# assert out == True
+def test_groupingelshape_nodallocation_verbose_api(allkindofcomplexity):
+    result = post.load_solution(allkindofcomplexity)
+    disp = result.misc.nodal_displacement(grouping=post.grouping.by_el_shape)
+    assert disp.num_fields == 4
+    assert disp.result_fields_container.get_label_space(3) == {"elshape": 3, "time": 1}
+    assert len(disp.get_data_at_field(0)) == 14826
+    assert len(disp.get_data_at_field(1)) == 1486
+    if SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_9_0:
+        assert len(disp.get_data_at_field(2)) == 21
+    else:
+        assert len(disp.get_data_at_field(2)) == 19
+    assert len(disp.get_data_at_field(3)) == 4
+    assert np.isclose(disp.get_data_at_field(2)[0][0], 5.523488975819807e-20)
+    assert disp[0].location == locations.nodal
+
+
+def test_groupingelshape_nodallocation(allkindofcomplexity):
+    result = post.load_solution(allkindofcomplexity)
+    d = result.displacement(grouping=post.grouping.by_el_shape)
+    disp = d.vector
+    assert disp.num_fields == 4
+    assert disp.result_fields_container.get_label_space(3) == {"elshape": 3, "time": 1}
+    assert len(disp.get_data_at_field(0)) == 14826
+    assert len(disp.get_data_at_field(1)) == 1486
+    if SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_9_0:
+        assert len(disp.get_data_at_field(2)) == 21
+    else:
+        assert len(disp.get_data_at_field(2)) == 19
+    assert len(disp.get_data_at_field(3)) == 4
+    assert np.isclose(disp.get_data_at_field(2)[0][0], 5.523488975819807e-20)
+    assert disp[0].location == locations.nodal
+
+    # with dpf.core operator
+    from ansys.dpf import core
+
+    op = core.Operator("U")
+    # op.inputs.requested_location.connect(core.locations.nodal)
+    op.inputs.data_sources.connect(core.DataSources(allkindofcomplexity))
+    mesh_provider = core.Operator("MeshProvider")
+    mesh_provider.inputs.data_sources.connect(core.DataSources(allkindofcomplexity))
+    scop_op = core.Operator("scoping::by_property")
+    scop_op.inputs.mesh.connect(mesh_provider.outputs.mesh)
+    scop_op.inputs.requested_location.connect(core.locations.nodal)
+    scop_op.inputs.label1.connect("elshape")
+    op.inputs.mesh_scoping.connect(scop_op.outputs.mesh_scoping)
+    fc = op.outputs.fields_container()
+    assert len(fc) == disp.num_fields
+    assert fc[0].location == disp[0].location
+    assert len(fc[0].data) == len(disp[0].data)
+    assert np.allclose(disp[0].data.tolist(), fc[0].data.tolist())
+    comp = core.operators.logic.identical_fc()
+    comp.inputs.fields_containerA.connect(fc)
+    comp.inputs.fields_containerB.connect(disp.result_fields_container)
+    out = comp.outputs.boolean()
+    assert out == True
 
 
 def test_groupingelshape_elemlocation_verbose_api(allkindofcomplexity):
@@ -364,55 +371,61 @@ def test_groupingelshape_elemlocation(allkindofcomplexity):
     assert out == True
 
 
-# def test_groupingmat_nodallocation_verbose_api(allkindofcomplexity):
-#     result = post.load_solution(allkindofcomplexity)
-#     disp = result.misc.nodal_displacement(grouping=post.grouping.by_material)
-#     assert disp.num_fields == 11
-#     assert len(disp[0]) == 6288
-#     assert len(disp[2]) == 744
-#     assert np.isclose(disp.get_data_at_field(2)[0][2], -6.649053654123576e-07)
-#     assert disp.result_fields_container.get_label_space(3) == {"time": 1, "mat": 10}
-#     for field in disp:
-#         assert len(field) != 0
-#         assert field.location == locations.nodal
-
-
-# def test_groupingmat_nodallocation(allkindofcomplexity):
-#     result = post.load_solution(allkindofcomplexity)
-#     d = result.displacement(grouping=post.grouping.by_material)
-#     disp = d.vector
-#     assert disp.num_fields == 11
-#     assert len(disp[0]) == 6288
-#     assert len(disp[2]) == 744
-#     assert np.isclose(disp.get_data_at_field(2)[0][2], -6.649053654123576e-07)
-#     assert disp.result_fields_container.get_label_space(3) == {"time": 1, "mat": 10}
-#     for field in disp:
-#         assert len(field) != 0
-#         assert field.location == locations.nodal
-#
-#     # with dpf.core operator
-#     from ansys.dpf import core
-#
-#     op = core.Operator("U")
-#     # op.inputs.requested_location.connect(core.locations.nodal)
-#     op.inputs.data_sources.connect(core.DataSources(allkindofcomplexity))
-#     mesh_provider = core.Operator("MeshProvider")
-#     mesh_provider.inputs.data_sources.connect(core.DataSources(allkindofcomplexity))
-#     scop_op = core.Operator("scoping::by_property")
-#     scop_op.inputs.mesh.connect(mesh_provider.outputs.mesh)
-#     scop_op.inputs.requested_location.connect(core.locations.nodal)
-#     scop_op.inputs.label1.connect("mat")
-#     op.inputs.mesh_scoping.connect(scop_op.outputs.mesh_scoping)
-#     fc = op.outputs.fields_container()
-#     assert len(fc) == disp.num_fields
-#     assert fc[0].location == disp[0].location
-#     assert len(fc[0].data) == len(disp[0].data)
-#     assert np.allclose(disp[0].data.tolist(), fc[0].data.tolist())
-#     comp = core.operators.logic.identical_fc()
-#     comp.inputs.fields_containerA.connect(fc)
-#     comp.inputs.fields_containerB.connect(disp.result_fields_container)
-#     out = comp.outputs.boolean()
-#     assert out is True
+def test_groupingmat_nodallocation_verbose_api(allkindofcomplexity):
+    result = post.load_solution(allkindofcomplexity)
+    disp = result.misc.nodal_displacement(grouping=post.grouping.by_material)
+    if SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_9_0:
+        assert disp.num_fields == 13
+    else:
+        assert disp.num_fields == 11
+    assert len(disp[0]) == 6288
+    assert len(disp[2]) == 744
+    assert np.isclose(disp.get_data_at_field(2)[0][2], -6.649053654123576e-07)
+    assert disp.result_fields_container.get_label_space(3) == {"time": 1, "mat": 10}
+    for field in disp:
+        assert len(field) != 0
+        assert field.location == locations.nodal
+
+
+def test_groupingmat_nodallocation(allkindofcomplexity):
+    result = post.load_solution(allkindofcomplexity)
+    d = result.displacement(grouping=post.grouping.by_material)
+    disp = d.vector
+    if SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_9_0:
+        assert disp.num_fields == 13
+    else:
+        assert disp.num_fields == 11
+    assert len(disp[0]) == 6288
+    assert len(disp[2]) == 744
+    assert np.isclose(disp.get_data_at_field(2)[0][2], -6.649053654123576e-07)
+    assert disp.result_fields_container.get_label_space(3) == {"time": 1, "mat": 10}
+    for field in disp:
+        assert len(field) != 0
+        assert field.location == locations.nodal
+
+    # with dpf.core operator
+    from ansys.dpf import core
+
+    op = core.Operator("U")
+    # op.inputs.requested_location.connect(core.locations.nodal)
+    op.inputs.data_sources.connect(core.DataSources(allkindofcomplexity))
+    mesh_provider = core.Operator("MeshProvider")
+    mesh_provider.inputs.data_sources.connect(core.DataSources(allkindofcomplexity))
+    scop_op = core.Operator("scoping::by_property")
+    scop_op.inputs.mesh.connect(mesh_provider.outputs.mesh)
+    scop_op.inputs.requested_location.connect(core.locations.nodal)
+    scop_op.inputs.label1.connect("mat")
+    op.inputs.mesh_scoping.connect(scop_op.outputs.mesh_scoping)
+    fc = op.outputs.fields_container()
+    assert len(fc) == disp.num_fields
+    assert fc[0].location == disp[0].location
+    assert len(fc[0].data) == len(disp[0].data)
+    assert np.allclose(disp[0].data.tolist(), fc[0].data.tolist())
+    comp = core.operators.logic.identical_fc()
+    comp.inputs.fields_containerA.connect(fc)
+    comp.inputs.fields_containerB.connect(disp.result_fields_container)
+    out = comp.outputs.boolean()
+    assert out is True
 
 
 def test_groupingmat_elemlocation_verbose_api(allkindofcomplexity):

tests/test_simulation.py

@@ -6,14 +6,14 @@
 from pytest import fixture
 
 from ansys.dpf import post
-from ansys.dpf.post.common import AvailableSimulationTypes  # elemental_properties
+from ansys.dpf.post.common import AvailableSimulationTypes, elemental_properties
 from ansys.dpf.post.index import ref_labels
-
-# from ansys.dpf.post.meshes import Meshes
+from ansys.dpf.post.meshes import Meshes
 from conftest import (
     SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_4_0,
     SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_6_2,
     SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_7_1,
+    SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_9_0,
 )
 
 
@@ -104,38 +104,41 @@ def test_simulation_plot(static_simulation):
     static_simulation.plot(cpos="xy")
 
 
-# def test_simulation_split_mesh_by_properties(allkindofcomplexity):
-#     simulation = post.StaticMechanicalSimulation(allkindofcomplexity)
-#     meshes = simulation.split_mesh_by_properties(
-#         properties=[
-#             elemental_properties.material,
-#             elemental_properties.element_shape,
-#         ]
-#     )
-#     assert isinstance(meshes, Meshes)
-#     assert len(meshes) == 16
-#     meshes = simulation.split_mesh_by_properties(
-#         properties={
-#             elemental_properties.material: 1,
-#             elemental_properties.element_shape: [0, 1],
-#         }
-#     )
-#     assert isinstance(meshes, Meshes)
-#     assert len(meshes) == 2
-#     meshes = simulation.split_mesh_by_properties(
-#         properties={
-#             elemental_properties.material: 1,
-#             elemental_properties.element_shape: [0, 2],
-#         }
-#     )
-#     assert isinstance(meshes, post.Mesh)
-#     meshes = simulation.split_mesh_by_properties(
-#         properties={
-#             elemental_properties.material: 22,
-#             elemental_properties.element_shape: [0, 2],
-#         }
-#     )
-#     assert meshes is None
+def test_simulation_split_mesh_by_properties(allkindofcomplexity):
+    simulation = post.StaticMechanicalSimulation(allkindofcomplexity)
+    meshes = simulation.split_mesh_by_properties(
+        properties=[
+            elemental_properties.material,
+            elemental_properties.element_shape,
+        ]
+    )
+    assert isinstance(meshes, Meshes)
+    if SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_9_0:
+        assert len(meshes) == 18
+    else:
+        assert len(meshes) == 16
+    meshes = simulation.split_mesh_by_properties(
+        properties={
+            elemental_properties.material: 1,
+            elemental_properties.element_shape: [0, 1],
+        }
+    )
+    assert isinstance(meshes, Meshes)
+    assert len(meshes) == 2
+    meshes = simulation.split_mesh_by_properties(
+        properties={
+            elemental_properties.material: 1,
+            elemental_properties.element_shape: [0, 2],
+        }
+    )
+    assert isinstance(meshes, post.Mesh)
+    meshes = simulation.split_mesh_by_properties(
+        properties={
+            elemental_properties.material: 22,
+            elemental_properties.element_shape: [0, 2],
+        }
+    )
+    assert meshes is None
 
 
 class TestStaticMechanicalSimulation: