doc/salome/examples/use_existing_faces.py

   1 # Usage of "Use Faces to be Created Manually" algorithm
   2
   3
   4 import salome
   5 salome.salome_init()
   6 import GEOM
   7 from salome.geom import geomBuilder
   8 geompy = geomBuilder.New()
   9
  10 import SMESH, SALOMEDS
  11 from salome.smesh import smeshBuilder
  12 smesh =  smeshBuilder.New()
  13 import salome_notebook
  14
  15 # define my 2D algorithm
  16 def my2DMeshing(geomFace, geom_builder, smesh_builder):
  17     import numpy as np
  18
  19     # find gravity center of geomFace
  20     gcXYZ = geom_builder.PointCoordinates( geom_builder.MakeCDG( geomFace ))
  21
  22     # define order and orientation of edges
  23     sortedEdges = []
  24     geomEdges = geom_builder.SubShapeAll( geomFace, geom_builder.ShapeType["EDGE"])
  25     sortedEdges.append(( geomEdges.pop(0), True ))
  26     while geomEdges:
  27         prevEdge_rev = sortedEdges[ -1 ]
  28         prevVV = geom_builder.SubShapeAll( prevEdge_rev[0], geom_builder.ShapeType["VERTEX"])
  29         prevV2 = prevVV[ prevEdge_rev[1] ]
  30         found = False
  31         for iE in range( len( geomEdges )):
  32             v1,v2 = geom_builder.SubShapeAll( geomEdges[ iE ], geom_builder.ShapeType["VERTEX"])
  33             same1,same2 = [( geom_builder.MinDistance( prevV2, v ) < 1e-7 ) for v in [v1,v2] ]
  34             if not same1 and not same2: continue
  35             sortedEdges.append(( geomEdges.pop( iE ), same1 ))
  36             found = True
  37             break
  38         assert found
  39     sortedEdges.reverse()
  40
  41     # put nodes on edges in a right order
  42     nodes = []
  43     for edge, isForward in sortedEdges:
  44         v1,v2 = geom_builder.SubShapeAll( edge, geom_builder.ShapeType["VERTEX"])
  45         edgeNodes = smesh_builder.GetSubMeshNodesId( v2,   all=False ) + \
  46                     smesh_builder.GetSubMeshNodesId( edge, all=False ) + \
  47                     smesh_builder.GetSubMeshNodesId( v1,   all=False )
  48         if not isForward: edgeNodes.reverse()
  49         nodes.extend( edgeNodes[:-1] )
  50
  51     # create nodes inside the geomFace
  52     r1 = 0.6
  53     r2 = 1 - r1
  54     nodesInside = []
  55     for n in nodes:
  56         nXYZ = smesh_builder.GetNodeXYZ( n )
  57         newXYZ = np.add( np.multiply( r1, gcXYZ ), np.multiply( r2, nXYZ ))
  58         nodesInside.append( smesh_builder.AddNode( newXYZ[0], newXYZ[1], newXYZ[2] ))
  59         smesh_builder.SetNodeOnFace( nodesInside[-1], geomFace, 0, 0 )
  60
  61     # find out orientation of faces to create
  62     #    geomFace normal
  63     faceNorm = geom_builder.GetNormal( geomFace )
  64     v1,v2 = [ geom_builder.PointCoordinates( v ) \
  65               for v in geom_builder.SubShapeAll( faceNorm, geom_builder.ShapeType["VERTEX"]) ]
  66     faceNormXYZ = np.subtract( v2, v1 )
  67     outDirXYZ   = np.subtract( v1, [ 50, 50, 50 ] )
  68     if np.dot( faceNormXYZ, outDirXYZ ) < 0: # reversed face
  69         faceNormXYZ = np.multiply( -1., faceNormXYZ )
  70     #   mesh face normal
  71     e1 = np.subtract( smesh_builder.GetNodeXYZ( nodes[0] ), smesh_builder.GetNodeXYZ( nodes[1] ))
  72     e2 = np.subtract( smesh_builder.GetNodeXYZ( nodes[0] ), smesh_builder.GetNodeXYZ( nodesInside[0] ))
  73     meshNorm = np.cross( e1, e2 )
  74     #   faces orientation
  75     reverse = ( np.dot( faceNormXYZ, meshNorm ) < 0 )
  76
  77     # create mesh faces
  78     iN = len( nodes )
  79     while iN:
  80         n1, n2, n3, n4 = nodes[iN-1], nodes[iN-2], nodesInside[iN-2], nodesInside[iN-1]
  81         iN -= 1
  82         if reverse:
  83             f = smesh_builder.AddFace( [n1, n2, n3, n4] )
  84         else:
  85             f = smesh_builder.AddFace( [n4, n3, n2, n1] )
  86         # new faces must be assigned to geometry to allow 3D algorithm finding them
  87         smesh_builder.SetMeshElementOnShape( f, geomFace )
  88
  89     if reverse:
  90         nodesInside.reverse()
  91     polygon = smesh_builder.AddPolygonalFace( nodesInside )
  92     smesh_builder.SetMeshElementOnShape( polygon, geomFace )
  93
  94     return
  95
  96 # create geometry and get faces to mesh with my2DMeshing()
  97 box = geompy.MakeBoxDXDYDZ( 100, 100, 100 )
  98 f1 = geompy.SubShapeAll( box, geompy.ShapeType["FACE"])[0]
  99 f2 = geompy.GetOppositeFace( box, f1 )
 100 geompy.addToStudy( box, "box" )
 101 geompy.addToStudy( f1, "f1" )
 102 geompy.addToStudy( f2, "f2" )
 103
 104 # compute 1D mesh
 105 mesh = smesh.Mesh( box )
 106 mesh.Segment().NumberOfSegments( 5 )
 107 mesh.Compute()
 108
 109 # compute 2D mesh
 110 mesh.Quadrangle()
 111 mesh.UseExistingFaces(f1) # UseExistingFaces() allows using my2DMeshing();
 112 mesh.UseExistingFaces(f2) # assign UseExistingFaces() BEFORE calling my2DMeshing()!
 113 my2DMeshing(f1, geom_builder=geompy, smesh_builder=mesh)
 114 my2DMeshing(f2, geom_builder=geompy, smesh_builder=mesh)
 115 assert mesh.Compute()
 116
 117 # compute 3D mesh
 118 mesh.Prism()
 119 assert mesh.Compute()