test/gmsh_runner.py

   1 #!/usr/bin/env python
   2 import sys
   3 import salome
   4
   5 salome.salome_init()
   6
   7 import time
   8 from os import path
   9 import tempfile
  10 import subprocess
  11
  12 import GEOM, SMESH, SALOMEDS
  13
  14 from salome.geom import geomBuilder
  15 from salome.smesh import smeshBuilder
  16
  17 import math
  18
  19 smesh = smeshBuilder.New()
  20 geompy = geomBuilder.New()
  21
  22 import medcoupling as mc
  23
  24 def create_gmsh_empty_param_file(param_file):
  25     """ Create a parameter file for runner """
  26     param = """0"""
  27     with open(param_file, "w") as ffile:
  28         ffile.write(param)
  29
  30 def create_gmsh_param_file(param_file):
  31     """ Create a parameter file for runner """
  32     param = """1
  33 0
  34 0
  35 0
  36 0
  37 0
  38 0
  39 2
  40 1.0
  41 0.0
  42 1e22
  43 0.0
  44 0
  45 0
  46 0"""
  47     with open(param_file, "w") as ffile:
  48         ffile.write(param)
  49
  50
  51 def runTheMesher( mesh_2d, geo, emptyParam=False ):
  52     nb_tetras = 0
  53     nb_points = 0
  54     nb_triangles = 0
  55     nb_segments = 0
  56     with tempfile.TemporaryDirectory() as tmp_dir:
  57         mesh_file = path.join(tmp_dir, "mesh.med")
  58         shape_file = path.join(tmp_dir, "shape.brep")
  59         param_file = path.join(tmp_dir, "gmsh_param.txt")
  60         new_elementsbinary = path.join(tmp_dir, "nodesAndElements.bin")
  61         output_mesh = path.join(tmp_dir, "mesh3D.med")
  62
  63         print("Running in folder: ", tmp_dir)
  64         if not ( emptyParam ):
  65             create_gmsh_param_file(param_file)
  66         else:
  67             create_gmsh_empty_param_file(param_file)
  68         mesh_2d.ExportMED(mesh_file, 0, 41, 1, mesh_2d, 1, [], '', -1, 1)
  69         geompy.ExportBREP( geo, shape_file )
  70
  71         runner = path.join("${GMSHPLUGIN_ROOT_DIR}",
  72                            "bin",
  73                            "salome",
  74                            "GMSHPlugin_Runner")
  75
  76         if sys.platform == 'win32':
  77             runner += ".exe"
  78
  79         cmd = "{runner} GMSH3D {mesh_file} {shape_file} "\
  80               "{param_file} NONE {new_elementsbinary} {output_mesh}"\
  81               .format(runner=runner,
  82                       mesh_file=mesh_file,
  83                       shape_file=shape_file,
  84                       param_file=param_file,
  85                       new_elementsbinary=new_elementsbinary,
  86                       output_mesh=output_mesh)
  87         print(cmd)
  88         subprocess.check_call(cmd, shell=True)
  89
  90         mesh_read = mc.ReadUMeshFromFile(output_mesh, "MESH", 0)
  91
  92         nb_tetras = mesh_read.getNumberOfCellsWithType(mc.NORM_TETRA4)
  93         nb_points = mesh_read.getNumberOfNodes()
  94
  95         mesh_read = mc.ReadUMeshFromFile(output_mesh, "MESH", -1)
  96         nb_triangles = mesh_read.getNumberOfCellsWithType(mc.NORM_TRI3)
  97
  98         mesh_read = mc.ReadUMeshFromFile(output_mesh, "MESH", -2)
  99         nb_segments = mesh_read.getNumberOfCellsWithType(mc.NORM_SEG2)
 100
 101     return [nb_points, nb_segments, nb_triangles, nb_tetras]
 102
 103 def test_gmsh3dDefault():
 104     """ Test gmsh3d """
 105     # Building geometry
 106     box = geompy.MakeBoxDXDYDZ(200, 200, 200)
 107
 108     geompy.ExtractShapes(box, geompy.ShapeType["FACE"], True)
 109     groupe_1 = geompy.CreateGroup(box, geompy.ShapeType["FACE"] )
 110     geompy.UnionIDs(groupe_1, [3, 13, 23, 27, 31, 33])
 111
 112     [_, _, _, _, _, _, groupe_1] = geompy.GetExistingSubObjects(box, False)
 113
 114     shape_faces = geompy.SubShapeAllSorted(box, geompy.ShapeType["FACE"])
 115
 116     mesh_2d = smesh.Mesh(box, 'Maillage_1')
 117
 118     mesh_2d.Triangle(algo=smeshBuilder.NETGEN_1D2D)
 119     isDone = mesh_2d.Compute()
 120     premeshedTriangles  = mesh_2d.NbFaces()
 121     premeshedTetras     = mesh_2d.NbVolumes()
 122
 123     if not isDone:
 124         raise Exception("Error when computing Mesh")
 125
 126     smesh.SetName(mesh_2d, 'Maillage_1')
 127
 128     [nb_points, nb_segments, nb_triangles, nb_tetras] = runTheMesher( mesh_2d, box )
 129
 130
 131     print("Nb Tetras:", nb_tetras)
 132     print("Nb Triangles:", nb_triangles)
 133     print("Nb Segments:", nb_segments)
 134     print("Nb Points:", nb_points)
 135
 136     assert premeshedTetras == 0
 137     assert nb_triangles == premeshedTriangles
 138     assert nb_tetras == 6 # number of tetras for normalized 2D premesh (update if default 2D netgen change!)
 139     assert nb_points == 8 # one node in each vertex of the cube
 140     assert nb_segments > 0
 141
 142 def test_gmsh3d():
 143     """ Test gmsh3d """
 144     # Building geometry
 145     box = geompy.MakeBoxDXDYDZ(200, 200, 200)
 146
 147     geompy.ExtractShapes(box, geompy.ShapeType["FACE"], True)
 148     groupe_1 = geompy.CreateGroup(box, geompy.ShapeType["FACE"] )
 149     geompy.UnionIDs(groupe_1, [3, 13, 23, 27, 31, 33])
 150
 151     [_, _, _, _, _, _, groupe_1] = geompy.GetExistingSubObjects(box, False)
 152
 153     shape_faces = geompy.SubShapeAllSorted(box, geompy.ShapeType["FACE"])
 154
 155     # Creating 2D mesh
 156     netgen_2d_parameters_1 = smesh.CreateHypothesisByAverageLength(
 157         'NETGEN_Parameters_2D', 'NETGENEngine', 34.641,  0 )
 158
 159     mesh_2d = smesh.Mesh(box, 'Maillage_1')
 160     mesh_2d.AddHypothesis(box, netgen_2d_parameters_1)
 161
 162     mesh_2d.Triangle(algo=smeshBuilder.NETGEN_1D2D)
 163     isDone = mesh_2d.Compute()
 164     premeshedTriangles  = mesh_2d.NbFaces()
 165     premeshedTetras     = mesh_2d.NbVolumes()
 166
 167     if not isDone:
 168         raise Exception("Error when computing Mesh")
 169
 170     smesh.SetName(mesh_2d, 'Maillage_1')
 171
 172     [nb_points, nb_segments, nb_triangles, nb_tetras] = runTheMesher( mesh_2d, box )
 173
 174
 175     print("Nb Tetras:", nb_tetras)
 176     print("Nb Triangles:", nb_triangles)
 177     print("Nb Segments:", nb_segments)
 178     print("Nb Points:", nb_points)
 179
 180     assert premeshedTetras == 0
 181     assert nb_triangles == premeshedTriangles
 182     assert nb_tetras > 6
 183     assert nb_points > 8
 184     assert nb_segments > 0
 185
 186 def test_gmsh3d_empty_parameters():
 187     """ Test gmsh3d """
 188     # Building geometry
 189     box = geompy.MakeBoxDXDYDZ(200, 200, 200)
 190
 191     geompy.ExtractShapes(box, geompy.ShapeType["FACE"], True)
 192     groupe_1 = geompy.CreateGroup(box, geompy.ShapeType["FACE"] )
 193     geompy.UnionIDs(groupe_1, [3, 13, 23, 27, 31, 33])
 194
 195     [_, _, _, _, _, _, groupe_1] = geompy.GetExistingSubObjects(box, False)
 196
 197     shape_faces = geompy.SubShapeAllSorted(box, geompy.ShapeType["FACE"])
 198
 199     # Creating 2D mesh
 200     netgen_2d_parameters_1 = smesh.CreateHypothesisByAverageLength(
 201         'NETGEN_Parameters_2D', 'NETGENEngine', 34.641,  0 )
 202
 203     mesh_2d = smesh.Mesh(box, 'Maillage_1')
 204     mesh_2d.AddHypothesis(box, netgen_2d_parameters_1)
 205
 206     mesh_2d.Triangle(algo=smeshBuilder.NETGEN_1D2D)
 207     isDone = mesh_2d.Compute()
 208     premeshedTriangles  = mesh_2d.NbFaces()
 209     premeshedTetras     = mesh_2d.NbVolumes()
 210
 211     if not isDone:
 212         raise Exception("Error when computing Mesh")
 213
 214     smesh.SetName(mesh_2d, 'Maillage_1')
 215
 216     [nb_points, nb_segments, nb_triangles, nb_tetras] = runTheMesher( mesh_2d, box, True )
 217
 218
 219     print("Nb Tetras:", nb_tetras)
 220     print("Nb Triangles:", nb_triangles)
 221     print("Nb Segments:", nb_segments)
 222     print("Nb Points:", nb_points)
 223
 224     assert premeshedTetras == 0
 225     assert nb_triangles == premeshedTriangles
 226     assert nb_tetras > 6
 227     assert nb_points > 8
 228     assert nb_segments > 0
 229
 230 if __name__ == "__main__":
 231     if sys.platform == "win32":
 232         print("Disabled on windows")
 233         sys.exit(0)
 234
 235     test_gmsh3dDefault()
 236     test_gmsh3d()
 237     test_gmsh3d_empty_parameters()
 238