def __init__(self, salome_mesh, mesh_description, model_part_name=""):
"""Keyword arguments:
salome_mesh -- the Salome mesh to access. Depending on the type the corresponding conversion is performed before creating a MeshInterface that is then passed to the base class
mesh_description -- see base class
model_part_name -- see base class
"""
if isinstance(salome_mesh, str):
mesh_identifier = salome_mesh
elif any([
salome_mesh_utilities.IsMeshProxy(salome_mesh),
salome_mesh_utilities.IsSubMeshProxy(salome_mesh),
salome_mesh_utilities.IsMeshGroup(salome_mesh)
]):
mesh_identifier = salome_utilities.GetSalomeID(salome_mesh)
elif salome_mesh_utilities.IsMesh(salome_mesh):
mesh_identifier = salome_utilities.GetSalomeID(
salome_mesh.GetMesh())
else:
err_msg = 'Type of argument "salome_mesh" not permitted: {}\n'.format(
type(salome_mesh))
err_msg += 'No mesh can be retrieved from this input!'.format(
type(salome_mesh))
raise Exception(err_msg)
mesh_interface = MeshInterface(mesh_identifier)
super().__init__(mesh_interface, mesh_description, model_part_name)
def test_GetObjectName(self):
identifier = salome_utilities.GetSalomeID(self.box)
self.assertEqual(salome_utilities.GetObjectName(identifier),
self.name_main_box)
identifier = salome_utilities.GetSalomeID(self.mesh_tetra.GetMesh())
self.assertEqual(salome_utilities.GetObjectName(identifier),
self.name_main_mesh_tetra)
identifier = salome_utilities.GetSalomeID(self.sub_mesh_hexa_g_2)
self.assertEqual(salome_utilities.GetObjectName(identifier),
self.name_mesh_group)
def test_ObjectExists(self):
identifier = salome_utilities.GetSalomeID(self.box)
self.assertTrue(salome_utilities.ObjectExists(identifier))
identifier = salome_utilities.GetSalomeID(self.mesh_tetra.GetMesh())
self.assertTrue(salome_utilities.ObjectExists(identifier))
identifier = salome_utilities.GetSalomeID(self.sub_mesh_hexa_g_2)
self.assertTrue(salome_utilities.ObjectExists(identifier))
self.assertFalse(
salome_utilities.ObjectExists("0:1:2:4:10:2:1:1:4:7:8")
) # random identifier, should not exist
self.assertFalse(salome_utilities.ObjectExists(
"0:15555")) # random identifier, should not exist
def setUp(self):
super().setUp()
# this also tests the "CheckMeshIsValid" function right here
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.domain_mesh.GetMesh())
self.mesh_interface_domain_mesh = MeshInterface(
existing_mesh_identifier)
self.assertTrue(self.mesh_interface_domain_mesh.CheckMeshIsValid())
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.neumann_mesh)
self.mesh_interface_neumann = MeshInterface(existing_mesh_identifier)
self.assertTrue(self.mesh_interface_neumann.CheckMeshIsValid())
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.dirichlet_mesh)
self.mesh_interface_dirichlet = MeshInterface(existing_mesh_identifier)
self.assertTrue(self.mesh_interface_dirichlet.CheckMeshIsValid())
def test_sub_mesh_proxy(self):
mesh_identifier = salome_utilities.GetSalomeID(self.sub_mesh_tetra_e_1)
sal_mesh = create_kratos_input_tui.SalomeMesh(self.sub_mesh_tetra_e_1,
{})
self.assertEqual(sal_mesh.mesh_interface.mesh_identifier,
mesh_identifier)
self.assertEqual(sal_mesh.mesh_description, {})
self.assertEqual(sal_mesh.model_part_name, "")
def test_DoMeshesBelongToSameMainMesh(self):
self.assertTrue(salome_mesh_utilities.DoMeshesBelongToSameMainMesh(
[])) # empty input should return True
meshes_same_main_mesh = [
self.mesh_tetra.GetMesh(), self.sub_mesh_tetra_f_1,
self.sub_mesh_tetra_g_1, self.sub_mesh_tetra_e_2,
self.group_tetra_f1_faces, self.group_tetra_0D_elements
]
meshes_not_same_main_mesh = [
self.mesh_hexa.GetMesh(), self.sub_mesh_tetra_f_1,
self.sub_mesh_tetra_g_1, self.sub_mesh_tetra_e_2,
self.group_tetra_f1_faces, self.group_tetra_0D_elements
]
meshes_not_meshes = [self.mesh_hexa.GetMesh(), self.box]
mesh_identifiers_same_main_mesh = [
salome_utilities.GetSalomeID(mesh)
for mesh in meshes_same_main_mesh
]
mesh_identifiers_not_same_main_mesh = [
salome_utilities.GetSalomeID(mesh)
for mesh in meshes_not_same_main_mesh
]
identifiers_not_meshes = [
salome_utilities.GetSalomeID(mesh) for mesh in meshes_not_meshes
]
self.assertTrue(
salome_mesh_utilities.DoMeshesBelongToSameMainMesh(
mesh_identifiers_same_main_mesh))
self.assertFalse(
salome_mesh_utilities.DoMeshesBelongToSameMainMesh(
mesh_identifiers_not_same_main_mesh))
with self.assertRaisesRegex(
Exception,
'Object with identifier "0:1:1:1" is not a mesh! Name: "main_box" , Type:'
):
salome_mesh_utilities.DoMeshesBelongToSameMainMesh(
identifiers_not_meshes)
def test_mesh(self):
mesh_identifier = salome_utilities.GetSalomeID(
self.mesh_hexa.GetMesh())
sal_mesh = create_kratos_input_tui.SalomeMesh(self.mesh_hexa, {},
"some_mp")
self.assertEqual(sal_mesh.mesh_interface.mesh_identifier,
mesh_identifier)
self.assertEqual(sal_mesh.mesh_description, {})
self.assertEqual(sal_mesh.model_part_name, "some_mp")
def test_mesh_group(self):
mesh_identifier = salome_utilities.GetSalomeID(
self.group_tetra_0D_elements)
sal_mesh = create_kratos_input_tui.SalomeMesh(
self.group_tetra_0D_elements, {}, "htars.abc")
self.assertEqual(sal_mesh.mesh_interface.mesh_identifier,
mesh_identifier)
self.assertEqual(sal_mesh.mesh_description, {})
self.assertEqual(sal_mesh.model_part_name, "htars.abc")
def test_GetSalomeID(self):
# this test might fail if salome orders the ids differently in different versions
# it should not, since the order in which the objects are added is always the same
object_id_list = [("0:1:2:3", self.mesh_tetra.GetMesh()),
("0:1:2:3:7:1", self.sub_mesh_tetra_f_1),
("0:1:2:3:10:1", self.sub_mesh_tetra_g_1),
("0:1:1:1", self.box), ("0:1:1:1:1", self.face_1),
("0:1:1:1:5", self.group_faces)]
for obj_id in object_id_list:
self.assertEqual(obj_id[0],
salome_utilities.GetSalomeID(obj_id[1]))
def test_mesh_identifier(self):
mesh_identifier = salome_utilities.GetSalomeID(
self.mesh_hexa.GetMesh())
# this is not the real format, only a dummy for testing
mesh_description = {"elements": "abc", "conditions": ["ddd"]}
sal_mesh = create_kratos_input_tui.SalomeMesh(mesh_identifier,
mesh_description,
"my_model_part_name")
self.assertEqual(sal_mesh.mesh_interface.mesh_identifier,
mesh_identifier)
self.assertDictEqual(sal_mesh.mesh_description, mesh_description)
self.assertEqual(sal_mesh.model_part_name, "my_model_part_name")
def setUp(self):
super().setUp()
# this also tests the "CheckMeshIsValid" function right here
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.mesh_tetra.GetMesh())
self.mesh_interface_main_mesh_tetra = MeshInterface(
existing_mesh_identifier)
self.assertTrue(self.mesh_interface_main_mesh_tetra.CheckMeshIsValid())
self.mesh_interface_non_exist_mesh = MeshInterface(
existing_mesh_identifier)
self.mesh_interface_non_exist_mesh.mesh_identifier = "1:55555:114777" # has to be overwritten, otherwise throws in constructor
self.assertFalse(self.mesh_interface_non_exist_mesh.CheckMeshIsValid())
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.mesh_hexa.GetMesh())
self.mesh_interface_main_mesh_hexa = MeshInterface(
existing_mesh_identifier)
self.assertTrue(self.mesh_interface_main_mesh_hexa.CheckMeshIsValid())
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.sub_mesh_tetra_e_1)
self.mesh_interface_sub_mesh_tetra_edge = MeshInterface(
existing_mesh_identifier)
self.assertTrue(
self.mesh_interface_sub_mesh_tetra_edge.CheckMeshIsValid())
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.sub_mesh_tetra_f_2)
self.mesh_interface_sub_mesh_tetra_face = MeshInterface(
existing_mesh_identifier)
self.assertTrue(
self.mesh_interface_sub_mesh_tetra_face.CheckMeshIsValid())
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.sub_mesh_tetra_g_1)
self.mesh_interface_sub_mesh_group_tetra_face = MeshInterface(
existing_mesh_identifier)
self.assertTrue(
self.mesh_interface_sub_mesh_group_tetra_face.CheckMeshIsValid())
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.sub_mesh_hexa_g_2)
self.mesh_interface_sub_mesh_group_hexa_edge = MeshInterface(
existing_mesh_identifier)
self.assertTrue(
self.mesh_interface_sub_mesh_group_hexa_edge.CheckMeshIsValid())
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.sub_mesh_hexa_g_1)
self.mesh_interface_sub_mesh_group_hexa_face = MeshInterface(
existing_mesh_identifier)
self.assertTrue(
self.mesh_interface_sub_mesh_group_hexa_face.CheckMeshIsValid())
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.sub_mesh_hexa_f_2)
self.mesh_interface_sub_mesh_hexa_face = MeshInterface(
existing_mesh_identifier)
self.assertTrue(
self.mesh_interface_sub_mesh_hexa_face.CheckMeshIsValid())
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.group_tetra_0D_elements)
self.mesh_interface_tetra_0D_elements = MeshInterface(
existing_mesh_identifier)
self.assertTrue(
self.mesh_interface_tetra_0D_elements.CheckMeshIsValid())
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.group_hexa_ball_elements)
self.mesh_interface_hexa_ball_elements = MeshInterface(
existing_mesh_identifier)
self.assertTrue(
self.mesh_interface_hexa_ball_elements.CheckMeshIsValid())
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.group_tetra_f1_nodes)
self.mesh_interface_tetra_mesh_group_f1_nodes = MeshInterface(
existing_mesh_identifier)
self.assertTrue(
self.mesh_interface_tetra_mesh_group_f1_nodes.CheckMeshIsValid())
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.group_tetra_f1_faces)
self.mesh_interface_tetra_mesh_group_f1_faces = MeshInterface(
existing_mesh_identifier)
self.assertTrue(
self.mesh_interface_tetra_mesh_group_f1_faces.CheckMeshIsValid())
existing_mesh_identifier = salome_utilities.GetSalomeID(
self.group_hexa_edges)
self.mesh_interface_hexa_mesh_group_edges = MeshInterface(
existing_mesh_identifier)
self.assertTrue(
self.mesh_interface_hexa_mesh_group_edges.CheckMeshIsValid())