test/netgen_runner_2D.py

   1 #!/usr/bin/env python
   2 import sys
   3 import salome
   4
   5 salome.salome_init()
   6
   7 from os import path
   8 import tempfile
   9 import subprocess
  10
  11 import GEOM, SMESH, SALOMEDS
  12
  13 from salome.geom import geomBuilder
  14 from salome.smesh import smeshBuilder
  15
  16 import math
  17
  18 smesh = smeshBuilder.New()
  19 geompy = geomBuilder.New()
  20
  21 import medcoupling as mc
  22
  23 def create_param_file(param_file):
  24     """ Create a parameter file for runner """
  25     param = """1
  26 34.641
  27 0.14
  28 16
  29 0.15
  30 1.5
  31 0
  32 0
  33 1
  34 5
  35 1
  36 1
  37 -1
  38 3
  39 3
  40 0.2
  41 2
  42 1
  43 0
  44 0
  45 2
  46 2
  47 0
  48
  49 0
  50 0
  51 0"""
  52     with open(param_file, "w") as ffile:
  53         ffile.write(param)
  54
  55 def create_maxarea_param_file_2D(param_file,maxArea):
  56     """ Create a parameter file for runner """
  57     param = """1
  58 {}
  59 """.format(maxArea)
  60     with open(param_file, "w") as ffile:
  61         ffile.write(param)
  62
  63 def create_lenghtFromEdges_param_file_2D(param_file):
  64     """ Create a parameter file for runner """
  65     param = """1
  66 """
  67
  68     with open(param_file, "w") as ffile:
  69         ffile.write(param)
  70
  71 def CommonFunction(netgen,case,numberOfEdges1D,hypo,maxArea):
  72     # Building geometry
  73     geometry = geompy.MakeBoxDXDYDZ(200, 200, 200)
  74     # Create 1D regular elements
  75     mesh_1d = smesh.Mesh(geometry, 'Maillage_1')
  76     mesh_1d.Segment().NumberOfSegments(numberOfEdges1D)
  77     isDone = mesh_1d.Compute()
  78
  79     if not isDone:
  80         raise Exception("Error when computing Mesh")
  81
  82     smesh.SetName(mesh_1d, 'Maillage_1')
  83     nb_points = 0
  84     nb_segments = 0
  85     nb_triangles = 0
  86     nb_tetras = 0
  87     with tempfile.TemporaryDirectory() as tmp_dir:
  88         mesh_file = path.join(tmp_dir, "mesh.med")
  89         shape_file = path.join(tmp_dir, "shape.brep")
  90
  91         if ( hypo == 0 ):
  92             param_file = path.join(tmp_dir, "param.txt")
  93             create_param_file(param_file )
  94
  95         if ( hypo == 1 ):
  96             param_file = path.join(tmp_dir, "param_lenghtfromedge.txt")
  97             create_lenghtFromEdges_param_file_2D(param_file )
  98
  99         if ( hypo == 2 ):
 100             param_file = path.join(tmp_dir, "param_maxarea.txt")
 101             create_maxarea_param_file_2D(param_file,maxArea)
 102
 103         bin_file    =  path.join(tmp_dir, "mesh.bin")
 104         output_mesh = path.join(tmp_dir, "meshout.med")
 105
 106         print("Running in folder: ", tmp_dir)
 107
 108         mesh_1d.ExportMED(mesh_file, 0, 41, 1, mesh_1d, 1, [], '', -1, 1)
 109         geompy.ExportBREP( geometry, shape_file )
 110
 111         runner = path.join("${NETGENPLUGIN_ROOT_DIR}",
 112                             "bin",
 113                             "salome",
 114                             "NETGENPlugin_Runner")
 115
 116         if sys.platform == 'win32':
 117             runner += ".exe"
 118
 119         cmd = "{runner} {NETGEN} {mesh_file} {shape_file} "\
 120                 "{param_file} NONE {bin_file} {output_mesh}"\
 121                 .format(runner=runner,
 122                         NETGEN=netgen,
 123                         mesh_file=mesh_file,
 124                         shape_file=shape_file,
 125                         param_file=param_file,
 126                         bin_file=bin_file,
 127                         output_mesh=output_mesh)
 128         print(cmd)
 129         subprocess.check_call(cmd, shell=True)
 130         mesh_read = mc.ReadUMeshFromFile(output_mesh, "MESH", 0)
 131         nb_points = mesh_read.getNumberOfNodes()
 132         if (case == 2):
 133             nb_triangles = mesh_read.getNumberOfCellsWithType(mc.NORM_TRI3)
 134             mesh_read    = mc.ReadUMeshFromFile(output_mesh, "MESH", -1)
 135             nb_segments  = mesh_read.getNumberOfCellsWithType(mc.NORM_SEG2)
 136
 137     return [nb_points,nb_segments,nb_triangles,nb_tetras]
 138
 139
 140 def test_netgen2d():
 141     """ Test netgen2d mesher """
 142     [nb_points,nb_segments,nb_triangles,nb_tetras] = CommonFunction( "NETGEN2D", 2, 3, 0, 0.0 )
 143
 144     print("Nb Triangles:", nb_triangles)
 145     print("Nb Segments:", nb_segments)
 146     print("Nb Points:", nb_points)
 147
 148     assert nb_triangles > 12
 149     assert nb_points > 8
 150     assert nb_segments > 12
 151
 152 def test_netgen2dMaxArea():
 153     """ Test netgen2d mesher """
 154     [nb_points,nb_segments,nb_triangles,nb_tetras] = CommonFunction( "NETGEN2D", 2, 3, 2, 75.0 )
 155
 156     print("Nb Triangles:", nb_triangles)
 157     print("Nb Segments:", nb_segments)
 158     print("Nb Points:", nb_points)
 159
 160     assert nb_triangles > 12
 161     assert nb_points > 8
 162     assert nb_segments > 12
 163
 164 def test_netgen2dLenghtFromEdge():
 165     """ Test netgen2d mesher """
 166     [nb_points,nb_segments,nb_triangles,nb_tetras] = CommonFunction( "NETGEN2D", 2, 1, 1, 0.0 )
 167
 168     print("Nb Triangles:", nb_triangles)
 169     print("Nb Segments:", nb_segments)
 170     print("Nb Points:", nb_points)
 171
 172     assert nb_triangles == 12
 173     assert nb_points == 8
 174     assert nb_segments == 12
 175
 176 if __name__ == "__main__":
 177     if sys.platform == "win32":
 178         print("Disabled on windows")
 179         sys.exit(0)
 180     test_netgen2d()
 181     test_netgen2dMaxArea()
 182     test_netgen2dLenghtFromEdge()