tests/layers_with_snapping.py

   1 # -*- coding: utf-8 -*-
   2
   3 import sys
   4 import salome
   5
   6 salome.salome_init()
   7
   8 ###
   9 ### GEOM component
  10 ###
  11
  12 import GEOM
  13 from salome.geom import geomBuilder
  14 import math
  15 import SALOMEDS
  16
  17
  18 geompy = geomBuilder.New()
  19
  20 # first cylinder
  21 r1 = 0.5
  22 h1 = 5
  23
  24 # second cylinder
  25 r2 = 0.3
  26 h2 = 3
  27
  28 length_piquage = 1.5
  29
  30 O = geompy.MakeVertex(0, 0, 0)
  31 OX = geompy.MakeVectorDXDYDZ(1, 0, 0)
  32 OY = geompy.MakeVectorDXDYDZ(0, 1, 0)
  33 OZ = geompy.MakeVectorDXDYDZ(0, 0, 1)
  34 geompy.addToStudy( O, 'O' )
  35 geompy.addToStudy( OX, 'OX' )
  36 geompy.addToStudy( OY, 'OY' )
  37 geompy.addToStudy( OZ, 'OZ' )
  38
  39 Cylinder_1 = geompy.MakeCylinderRH(r1, h1)
  40 Cylinder_2 = geompy.MakeCylinderRH(r2, h2)
  41 Rotation_1 = geompy.MakeRotation(Cylinder_2, OY, -90*math.pi/180.0)
  42 Translation_1 = geompy.MakeTranslation(Rotation_1, 0, 0, length_piquage)
  43
  44 piquage = geompy.MakeFuseList([Cylinder_1, Translation_1], True, True)
  45 geompy.addToStudy( piquage, 'piquage' )
  46
  47 Inlet_z = geompy.GetFaceNearPoint(piquage, O)
  48 geompy.addToStudyInFather( piquage, Inlet_z, 'Inlet_z' )
  49
  50 p_inlet_x = geompy.MakeVertex(-h2, 0, length_piquage)
  51 Inlet_x = geompy.GetFaceNearPoint(piquage, p_inlet_x)
  52 geompy.addToStudyInFather( piquage, Inlet_x, 'Inlet_x' )
  53
  54 p_outlet = geompy.MakeVertex(0, 0, h1)
  55 Outlet = geompy.GetFaceNearPoint(piquage, p_outlet)
  56 geompy.addToStudyInFather( piquage, Outlet, 'Outlet' )
  57
  58 Wall = geompy.CreateGroup(piquage, geompy.ShapeType["FACE"])
  59 faces = geompy.SubShapeAll(piquage, geompy.ShapeType["FACE"])
  60 geompy.UnionList(Wall, faces)
  61 geompy.DifferenceList(Wall, [Inlet_x, Inlet_z, Outlet])
  62 geompy.addToStudyInFather( piquage, Wall, 'Wall' )
  63
  64 p_corner = geompy.MakeVertex(-r2, 0, length_piquage+r2)
  65 corner = geompy.GetVertexNearPoint(piquage, p_corner)
  66 geompy.addToStudyInFather( piquage, corner, 'corner' )
  67
  68 geom_groups = [Inlet_x, Inlet_z, Outlet, Wall]
  69 d_geom_groups = {}
  70
  71 ###
  72 ### SMESH component
  73 ###
  74
  75 import  SMESH, SALOMEDS
  76 from salome.smesh import smeshBuilder
  77
  78 from salome.StdMeshers import StdMeshersBuilder
  79 from salome.HYBRIDPlugin import HYBRIDPluginBuilder
  80
  81 smesh = smeshBuilder.New()
  82
  83 # Viscous layers with imprinting
  84 # ==============================
  85
  86 Mesh_1 = smesh.Mesh(piquage, "Mesh_with_imprinting")
  87
  88 NETGEN_2D = Mesh_1.Triangle(algo=smeshBuilder.NETGEN_1D2D)
  89 NETGEN_2D_Parameters = NETGEN_2D.Parameters()
  90
  91 NETGEN_2D_Parameters.SetMinSize( 0.01 )
  92 NETGEN_2D_Parameters.SetLocalSizeOnShape(corner, 0.01)
  93 NETGEN_2D_Parameters.SetFineness( 5 )
  94 NETGEN_2D_Parameters.SetGrowthRate( 0.1 )
  95 NETGEN_2D_Parameters.SetNbSegPerEdge( 2 )
  96 NETGEN_2D_Parameters.SetNbSegPerRadius( 3 )
  97
  98 wall_faces = geompy.SubShapeAll(Wall, geompy.ShapeType["FACE"])
  99 wall_ids = geompy.GetSubShapesIDs(piquage, wall_faces)
 100 Inlet_x_id, Inlet_z_id, Outlet_id = geompy.GetSubShapesIDs(piquage, [Inlet_x, Inlet_z, Outlet])
 101
 102 MG_Hybrid_2 = Mesh_1.Tetrahedron(algo=smeshBuilder.HYBRID)
 103 MG_Hybrid_Parameters_2 = MG_Hybrid_2.Parameters()
 104 MG_Hybrid_Parameters_2.SetLayersOnAllWrap( 0 )
 105 MG_Hybrid_Parameters_2.SetElementGeneration( HYBRIDPluginBuilder.Generation_Tetra_Dominant )
 106 MG_Hybrid_Parameters_2.SetHeightFirstLayer( 0.01 )
 107 MG_Hybrid_Parameters_2.SetBoundaryLayersProgression( 1.1 )
 108 MG_Hybrid_Parameters_2.SetNbOfBoundaryLayers( 3 )
 109 MG_Hybrid_Parameters_2.SetFacesWithLayers( wall_ids )
 110 MG_Hybrid_Parameters_2.SetFacesWithImprinting( [ Inlet_x_id, Inlet_z_id, Outlet_id ] )
 111
 112 isDone = Mesh_1.Compute()
 113
 114 if not isDone:
 115   raise Exception("Error when computing Mesh_with_imprinting")
 116
 117 assert Mesh_1.NbQuadrangles() > 0
 118
 119 d_groups_1 = {}
 120
 121 for geom_group in geom_groups:
 122   name = geom_group.GetName()
 123   gr = Mesh_1.Group(geom_group)
 124   d_groups_1[name] = gr
 125   d_geom_groups[name] = geom_group
 126
 127 faces_imprinted = ["Inlet_x", "Inlet_z", "Outlet"]
 128
 129 # Check viscous layers with imprinting
 130 for name in faces_imprinted:
 131   geom_area = geompy.BasicProperties(d_geom_groups[name])[1]
 132   gr_1 = d_groups_1[name]
 133   #assert gr_1.Size() > 0
 134   assert gr_1.Size() > 0
 135   # Nb of quadrangles is in 7th index of mesh info
 136   assert gr_1.GetMeshInfo()[7] > 0
 137
 138   # Compare mesh group and geom group
 139   area_error_1 = abs(geom_area-smesh.GetArea(gr_1))/geom_area
 140   assert area_error_1 < 0.025
 141
 142 # Compare whole mesh volume
 143 shape_volume = geompy.BasicProperties(piquage)[2]
 144 mesh_1_volume = Mesh_1.GetVolume()
 145 volume_error_1 = abs(shape_volume-mesh_1_volume)/shape_volume
 146
 147 assert volume_error_1 < 0.02
 148
 149 # Snapping
 150 # ========
 151
 152 Mesh_snap = smesh.Mesh(piquage, "Mesh_with_snapping")
 153
 154 HYBRID_3D = Mesh_snap.Tetrahedron(algo=smeshBuilder.HYBRID)
 155 HYBRID_Parameters_2 = HYBRID_3D.Parameters()
 156 HYBRID_Parameters_2.SetElementGeneration( 0 )
 157 HYBRID_Parameters_2.SetHeightFirstLayer( 0.01 )
 158 HYBRID_Parameters_2.SetBoundaryLayersProgression( 1.1 )
 159 HYBRID_Parameters_2.SetNbOfBoundaryLayers( 3 )
 160 HYBRID_Parameters_2.SetFacesWithLayers( wall_ids )
 161 HYBRID_Parameters_2.SetFacesWithSnapping([ Inlet_x_id, Inlet_z_id, Outlet_id ])
 162 HYBRID_Parameters_2.SetLayersOnAllWrap( 0 )
 163
 164 Import_1D2D = Mesh_snap.UseExisting2DElements(geom=Inlet_x)
 165 Source_Faces_1 = Import_1D2D.SourceFaces([ d_groups_1["Inlet_x"] ],0,0)
 166
 167 Import_1D2D_1 = Mesh_snap.UseExisting2DElements(geom=Inlet_z)
 168 Source_Faces_2 = Import_1D2D_1.SourceFaces([ d_groups_1["Inlet_z"] ],0,0)
 169
 170 Import_1D2D_2 = Mesh_snap.UseExisting2DElements(geom=Outlet)
 171 Source_Faces_3 = Import_1D2D_2.SourceFaces([ d_groups_1["Outlet"] ],0,0)
 172
 173 Import_1D2D_3 = Mesh_snap.UseExisting2DElements(geom=Wall)
 174 Source_Faces_4 = Import_1D2D_3.SourceFaces([ d_groups_1["Wall"] ],0,0)
 175
 176 isDone = Mesh_snap.Compute()
 177
 178 d_groups_2 = {}
 179
 180 for geom_group in geom_groups:
 181   name = geom_group.GetName()
 182   gr = Mesh_snap.Group(geom_group)
 183   d_groups_2[name] = gr
 184
 185 # Compare whole mesh volume
 186 mesh_2_volume = Mesh_snap.GetVolume()
 187 volume_error_2 = abs(mesh_1_volume-mesh_2_volume)/mesh_1_volume
 188
 189 assert volume_error_2 < 1e-4
 190
 191 # Check viscous layers with snapping
 192 for name in faces_imprinted:
 193   gr_1 = d_groups_1[name]
 194   gr_2 = d_groups_2[name]
 195   assert gr_2.Size() > 0
 196   # Nb of quadrangles is in 7th index of mesh info
 197   assert gr_1.GetMeshInfo()[7] == gr_1.GetMeshInfo()[7]
 198
 199   # Compare mesh group with imprinting set by ids and mesh group with imprinting set by geom group
 200   area_error_2 = abs(smesh.GetArea(gr_1)-smesh.GetArea(gr_2))/smesh.GetArea(gr_1)
 201   assert area_error_2 < 1e-10
 202
 203 # Snapping on group
 204 # =================
 205
 206 Mesh_snap_on_group = smesh.Mesh(piquage, "Mesh_with_snapping_on_groups")
 207
 208 HYBRID_3D_on_group = Mesh_snap_on_group.Tetrahedron(algo=smeshBuilder.HYBRID)
 209 HYBRID_Parameters_3 = HYBRID_3D_on_group.Parameters()
 210 HYBRID_Parameters_3.SetElementGeneration( 0 )
 211 HYBRID_Parameters_3.SetHeightFirstLayer( 0.01 )
 212 HYBRID_Parameters_3.SetBoundaryLayersProgression( 1.1 )
 213 HYBRID_Parameters_3.SetNbOfBoundaryLayers( 3 )
 214 HYBRID_Parameters_3.SetFacesWithLayers( wall_ids )
 215 HYBRID_3D_on_group.SetFacesWithSnapping([ Inlet_x, Inlet_z, Outlet ])
 216 HYBRID_Parameters_3.SetLayersOnAllWrap( 0 )
 217
 218 Import_1D2D = Mesh_snap_on_group.UseExisting2DElements(geom=Inlet_x)
 219 Source_Faces_1 = Import_1D2D.SourceFaces([ d_groups_1["Inlet_x"] ],0,0)
 220
 221 Import_1D2D_1 = Mesh_snap_on_group.UseExisting2DElements(geom=Inlet_z)
 222 Source_Faces_2 = Import_1D2D_1.SourceFaces([ d_groups_1["Inlet_z"] ],0,0)
 223
 224 Import_1D2D_2 = Mesh_snap_on_group.UseExisting2DElements(geom=Outlet)
 225 Source_Faces_3 = Import_1D2D_2.SourceFaces([ d_groups_1["Outlet"] ],0,0)
 226
 227 Import_1D2D_3 = Mesh_snap_on_group.UseExisting2DElements(geom=Wall)
 228 Source_Faces_4 = Import_1D2D_3.SourceFaces([ d_groups_1["Wall"] ],0,0)
 229
 230 isDone = Mesh_snap_on_group.Compute()
 231
 232 d_groups_3 = {}
 233
 234 for geom_group in geom_groups:
 235   name = geom_group.GetName()
 236   gr = Mesh_snap_on_group.Group(geom_group)
 237   d_groups_3[name] = gr
 238
 239 # Compare whole mesh volume
 240 mesh_3_volume = Mesh_snap_on_group.GetVolume()
 241 volume_error_3 = abs(mesh_2_volume-mesh_3_volume)/mesh_2_volume
 242
 243 assert volume_error_3 < 1e-10
 244
 245 # Check viscous layers with snapping
 246 for name in faces_imprinted:
 247   gr_2 = d_groups_2[name]
 248   gr_3 = d_groups_3[name]
 249   assert gr_3.Size() > 0
 250   # Nb of quadrangles is in 7th index of mesh info
 251   assert gr_2.GetMeshInfo()[7] == gr_3.GetMeshInfo()[7]
 252
 253   # Compare mesh group with imprinting set by ids and mesh group with imprinting set by geom group
 254   area_error_3 = abs(smesh.GetArea(gr_2)-smesh.GetArea(gr_3))/smesh.GetArea(gr_2)
 255   assert area_error_3 < 1e-10