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_multiple_meshes(self):
mesh_description_3D = {
"elements": {
"Hexa": {
"MyFancyElement": 1
}
},
"conditions": {
"Hexa": {
"VolumeLoadCondition": 0
}
}
}
mesh_description_2D = {"conditions": {"Quadrangle": {"SideForce": 23}}}
mesh_description_1D = {
"conditions": {
"Edge": {
"LineSupportDisp": 63,
"LineSupportRot": 7
}
}
}
mesh_description_0D = {"elements": {"Ball": {"PointMassBall": 4}}}
meshes = [
create_kratos_input_tui.SalomeMesh(self.mesh_hexa,
mesh_description_3D, "domain"),
create_kratos_input_tui.SalomeMesh(self.sub_mesh_hexa_f_1,
mesh_description_2D,
"side_faces"),
create_kratos_input_tui.SalomeMesh(self.group_hexa_edges,
mesh_description_1D,
"supports"),
create_kratos_input_tui.SalomeMesh(self.group_hexa_ball_elements,
mesh_description_0D,
"domain.point_masses")
]
mdpa_file_name = "create_mdpa_multiple_meshes"
create_kratos_input_tui.CreateMdpaFile(meshes, mdpa_file_name)
CompareMdpaWithReferenceFile(mdpa_file_name, self)
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_one_mesh(self):
mesh_description_3D = {"elements": {"Hexa": {"MyFancyElement": 0}}}
meshes = [
create_kratos_input_tui.SalomeMesh(self.mesh_hexa,
mesh_description_3D, "domain")
]
mdpa_file_name = "create_mdpa_one_mesh"
create_kratos_input_tui.CreateMdpaFile(meshes, mdpa_file_name)
CompareMdpaWithReferenceFile(mdpa_file_name, self)
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 test_one_mesh(self):
mesh_description_3D = {"elements": {"Hexa": {"MyFancyElement": 0}}}
meshes = [
create_kratos_input_tui.SalomeMesh(self.mesh_hexa,
mesh_description_3D, "domain")
]
model_part = create_kratos_input_tui.CreateModelPart(meshes)
self.assertEqual(model_part.NumberOfSubModelParts(), 1)
self.assertEqual(model_part.NumberOfNodes(), 729)
self.assertEqual(model_part.NumberOfElements(), 512)
self.assertEqual(model_part.NumberOfConditions(), 0)
self.assertEqual(model_part.NumberOfProperties(), 1)
smp = model_part.GetSubModelPart("domain")
self.assertEqual(smp.NumberOfSubModelParts(), 0)
self.assertEqual(smp.NumberOfNodes(), 729)
self.assertEqual(smp.NumberOfElements(), 512)
self.assertEqual(smp.NumberOfConditions(), 0)
self.assertEqual(smp.NumberOfProperties(), 1)
# saving the study such that it can be loaded in Salome
salome.myStudy.SaveAs("Cantilever_Hexa.hdf", False,
False) # args: use_multifile, use_acsii
if salome.sg.hasDesktop():
salome.sg.updateObjBrowser()
# from here on using the plugin to create mdpa file
sys.path.append("../../") # adding root folder of plugin to path
import create_kratos_input_tui
mesh_description_3D = {
"elements": {
"Hexa": {
"SmallDisplacementElement3D8N": 0
}
}
}
mesh_description_0D = {"conditions": {"0D": {"PointLoadCondition3D1N": 0}}}
meshes = [
create_kratos_input_tui.SalomeMesh(domain_1, mesh_description_3D,
"domain"),
create_kratos_input_tui.SalomeMesh(
dirichlet_1, {}, "dirichlet"), # no elements / conditions needed
create_kratos_input_tui.SalomeMesh(group_0D_entities, mesh_description_0D,
"neumann")
]
create_kratos_input_tui.CreateMdpaFile(meshes, "cantilever")
smesh.SetName(structure_mesh.GetMesh(), 'structure_mesh')
for name, sub_mesh in structure_sub_meshes.items():
smesh.SetName(sub_mesh, name)
# from here on using the plugin to create mdpa file
sys.path.append("../../") # adding root folder of plugin to path
import create_kratos_input_tui
from kratos_salome_plugin.write_mdpa import WriteMdpa
# fluid mesh
fluid_mesh_description_domain = { "elements" : {"Triangle" : {"Element2D3N" : 1} } }
fluid_mesh_description_wall = { "conditions" : {"Edge" : {"WallCondition2D2N" : 0} } }
meshes_fl = [
create_kratos_input_tui.SalomeMesh(fluid_mesh, fluid_mesh_description_domain, "Parts_Fluid")
]
for name, sub_mesh in fluid_sub_meshes.items():
meshes_fl.append(create_kratos_input_tui.SalomeMesh(sub_mesh, fluid_mesh_description_wall, name))
model_part_fluid = create_kratos_input_tui.CreateModelPart(meshes_fl)
props = model_part_fluid.GetProperties(1)
props.SetValue("DENSITY", 956.0)
props.SetValue("DYNAMIC_VISCOSITY", 0.145)
mdpa_info_fluid = "mdpa for fluid model FSI Mok"
WriteMdpa(model_part_fluid, "Mok_CFD", mdpa_info_fluid)
# structure mesh
structure_mesh_description_domain = { "elements" : {"Quadrangle" : {"TotalLagrangianElement2D4N" : 0} } }
def test_unpermitted_object(self):
with self.assertRaisesRegex(
Exception, 'Type of argument "salome_mesh" not permitted: '):
create_kratos_input_tui.SalomeMesh(self.box, {})
def test_multiple_meshes(self):
mesh_description_3D = {
"elements": {
"Hexa": {
"MyFancyElement": 1
}
},
"conditions": {
"Hexa": {
"VolumeLoadCondition": 0
}
}
}
mesh_description_1D = {
"conditions": {
"Edge": {
"LineSupportDisp": 63,
"LineSupportRot": 7
}
}
}
mesh_description_0D = {"elements": {"Ball": {"PointMassBall": 4}}}
meshes = [
create_kratos_input_tui.SalomeMesh(self.mesh_hexa,
mesh_description_3D, "domain"),
create_kratos_input_tui.SalomeMesh(self.group_hexa_edges,
mesh_description_1D,
"supports"),
create_kratos_input_tui.SalomeMesh(self.group_hexa_ball_elements,
mesh_description_0D,
"domain.point_masses")
]
model_part = create_kratos_input_tui.CreateModelPart(meshes)
self.assertEqual(model_part.NumberOfSubModelParts(), 2)
self.assertEqual(model_part.NumberOfNodes(), 729)
self.assertEqual(model_part.NumberOfElements(), 518)
self.assertEqual(model_part.NumberOfConditions(), 704)
self.assertEqual(model_part.NumberOfProperties(), 5)
smp_domain = model_part.GetSubModelPart("domain")
self.assertEqual(smp_domain.NumberOfNodes(), 729)
self.assertEqual(smp_domain.NumberOfElements(), 518)
self.assertEqual(smp_domain.NumberOfConditions(), 512)
self.assertEqual(smp_domain.NumberOfSubModelParts(), 1)
self.assertEqual(smp_domain.NumberOfProperties(), 3)
smp_point_mass = smp_domain.GetSubModelPart("point_masses")
self.assertEqual(smp_point_mass.NumberOfSubModelParts(), 0)
self.assertEqual(smp_point_mass.NumberOfNodes(), 6)
self.assertEqual(smp_point_mass.NumberOfElements(), 6)
self.assertEqual(smp_point_mass.NumberOfConditions(), 0)
self.assertEqual(smp_point_mass.NumberOfProperties(), 1)
smp_supports = model_part.GetSubModelPart("supports")
self.assertEqual(smp_supports.NumberOfSubModelParts(), 0)
self.assertEqual(smp_supports.NumberOfNodes(), 92)
self.assertEqual(smp_supports.NumberOfElements(), 0)
self.assertEqual(smp_supports.NumberOfConditions(), 192)
self.assertEqual(smp_supports.NumberOfProperties(), 2)
smesh.SetName(domain_1.GetMesh(), 'domain')
smesh.SetName(Local_Length_outter_boundary, 'Local Length_outter_boundary')
smesh.SetName(Max_Size_domain_inner, 'Max Size_domain_inner')
smesh.SetName(Max_Size_domain, 'Max Size_domain')
smesh.SetName(Local_Length_cyl, 'Local Length_cyl')
smesh.SetName(mesh_outlet, 'mesh_outlet')
smesh.SetName(mesh_cyl_boundary, 'mesh_cyl_boundary')
smesh.SetName(mesh_inlet, 'mesh_inlet')
# https://docs.salome-platform.org/latest/tui/KERNEL/kernel_salome.html
# saving the study such that it can be loaded in Salome
salome.myStudy.SaveAs("flow_cylinder_{}.hdf".format(mesh_factor), False,
False) # args: use_multifile, use_acsii
meshes = [
create_kratos_input_tui.SalomeMesh(domain_1, mesh_description_domain,
"domain"),
create_kratos_input_tui.SalomeMesh(mesh_inlet, mesh_description_wall,
"inlet"),
create_kratos_input_tui.SalomeMesh(mesh_outlet, mesh_description_wall,
"outlet"),
create_kratos_input_tui.SalomeMesh(mesh_walls, mesh_description_wall,
"walls"),
create_kratos_input_tui.SalomeMesh(mesh_cyl_boundary,
mesh_description_wall,
"cyl_boundary"),
]
create_kratos_input_tui.CreateMdpaFile(
meshes, "flow_cylinder_{}".format(mesh_factor))
if salome.sg.hasDesktop():
