-# Use existing faces algorithm
+# Usage of "Use Faces to be Created Manually" algorithm
-import smesh, geompy
-import numpy as np
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New()
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh = smeshBuilder.New()
+import salome_notebook
# define my 2D algorithm
-def my2DMeshing( geomFace ):
+def my2DMeshing(geomFace, geom_builder, smesh_builder):
+ import numpy as np
# find gravity center of geomFace
- gcXYZ = geompy.PointCoordinates( geompy.MakeCDG( geomFace ))
+ gcXYZ = geom_builder.PointCoordinates( geom_builder.MakeCDG( geomFace ))
# define order and orientation of edges
sortedEdges = []
- geomEdges = geompy.SubShapeAll( geomFace, geompy.ShapeType["EDGE"])
+ geomEdges = geom_builder.SubShapeAll( geomFace, geom_builder.ShapeType["EDGE"])
sortedEdges.append(( geomEdges.pop(0), True ))
while geomEdges:
prevEdge_rev = sortedEdges[ -1 ]
- prevVV = geompy.SubShapeAll( prevEdge_rev[0], geompy.ShapeType["VERTEX"])
+ prevVV = geom_builder.SubShapeAll( prevEdge_rev[0], geom_builder.ShapeType["VERTEX"])
prevV2 = prevVV[ prevEdge_rev[1] ]
found = False
for iE in range( len( geomEdges )):
- v1,v2 = geompy.SubShapeAll( geomEdges[ iE ], geompy.ShapeType["VERTEX"])
- same1,same2 = [( geompy.MinDistance( prevV2, v ) < 1e-7 ) for v in [v1,v2] ]
+ v1,v2 = geom_builder.SubShapeAll( geomEdges[ iE ], geom_builder.ShapeType["VERTEX"])
+ same1,same2 = [( geom_builder.MinDistance( prevV2, v ) < 1e-7 ) for v in [v1,v2] ]
if not same1 and not same2: continue
sortedEdges.append(( geomEdges.pop( iE ), same1 ))
found = True
# put nodes on edges in a right order
nodes = []
for edge, isForward in sortedEdges:
- v1,v2 = geompy.SubShapeAll( edge, geompy.ShapeType["VERTEX"])
- edgeNodes = mesh.GetSubMeshNodesId( v2, all=False ) + \
- mesh.GetSubMeshNodesId( edge, all=False ) + \
- mesh.GetSubMeshNodesId( v1, all=False )
+ v1,v2 = geom_builder.SubShapeAll( edge, geom_builder.ShapeType["VERTEX"])
+ edgeNodes = smesh_builder.GetSubMeshNodesId( v2, all=False ) + \
+ smesh_builder.GetSubMeshNodesId( edge, all=False ) + \
+ smesh_builder.GetSubMeshNodesId( v1, all=False )
if not isForward: edgeNodes.reverse()
nodes.extend( edgeNodes[:-1] )
r2 = 1 - r1
nodesInside = []
for n in nodes:
- nXYZ = mesh.GetNodeXYZ( n )
+ nXYZ = smesh_builder.GetNodeXYZ( n )
newXYZ = np.add( np.multiply( r1, gcXYZ ), np.multiply( r2, nXYZ ))
- nodesInside.append( mesh.AddNode( newXYZ[0], newXYZ[1], newXYZ[2] ))
- mesh.SetNodeOnFace( nodesInside[-1], geomFace, 0, 0 )
+ nodesInside.append( smesh_builder.AddNode( newXYZ[0], newXYZ[1], newXYZ[2] ))
+ smesh_builder.SetNodeOnFace( nodesInside[-1], geomFace, 0, 0 )
# find out orientation of faces to create
# geomFace normal
- faceNorm = geompy.GetNormal( geomFace )
- v1,v2 = [ geompy.PointCoordinates( v ) \
- for v in geompy.SubShapeAll( faceNorm, geompy.ShapeType["VERTEX"]) ]
+ faceNorm = geom_builder.GetNormal( geomFace )
+ v1,v2 = [ geom_builder.PointCoordinates( v ) \
+ for v in geom_builder.SubShapeAll( faceNorm, geom_builder.ShapeType["VERTEX"]) ]
faceNormXYZ = np.subtract( v2, v1 )
outDirXYZ = np.subtract( v1, [ 50, 50, 50 ] )
if np.dot( faceNormXYZ, outDirXYZ ) < 0: # reversed face
faceNormXYZ = np.multiply( -1., faceNormXYZ )
# mesh face normal
- e1 = np.subtract( mesh.GetNodeXYZ( nodes[0] ), mesh.GetNodeXYZ( nodes[1] ))
- e2 = np.subtract( mesh.GetNodeXYZ( nodes[0] ), mesh.GetNodeXYZ( nodesInside[0] ))
+ e1 = np.subtract( smesh_builder.GetNodeXYZ( nodes[0] ), smesh_builder.GetNodeXYZ( nodes[1] ))
+ e2 = np.subtract( smesh_builder.GetNodeXYZ( nodes[0] ), smesh_builder.GetNodeXYZ( nodesInside[0] ))
meshNorm = np.cross( e1, e2 )
# faces orientation
reverse = ( np.dot( faceNormXYZ, meshNorm ) < 0 )
n1, n2, n3, n4 = nodes[iN-1], nodes[iN-2], nodesInside[iN-2], nodesInside[iN-1]
iN -= 1
if reverse:
- f = mesh.AddFace( [n1, n2, n3, n4] )
+ f = smesh_builder.AddFace( [n1, n2, n3, n4] )
else:
- f = mesh.AddFace( [n4, n3, n2, n1] )
+ f = smesh_builder.AddFace( [n4, n3, n2, n1] )
# new faces must be assigned to geometry to allow 3D algorithm finding them
- mesh.SetMeshElementOnShape( f, geomFace )
+ smesh_builder.SetMeshElementOnShape( f, geomFace )
if reverse:
nodesInside.reverse()
- polygon = mesh.AddPolygonalFace( nodesInside )
- mesh.SetMeshElementOnShape( polygon, geomFace )
+ polygon = smesh_builder.AddPolygonalFace( nodesInside )
+ smesh_builder.SetMeshElementOnShape( polygon, geomFace )
return
# compute 2D mesh
mesh.Quadrangle()
-mesh.UseExistingFaces(f1) # UseExistingFaces() allows using my2DMeshing()
-mesh.UseExistingFaces(f2)
-my2DMeshing( f1 )
-my2DMeshing( f2 )
+mesh.UseExistingFaces(f1) # UseExistingFaces() allows using my2DMeshing();
+mesh.UseExistingFaces(f2) # assign UseExistingFaces() BEFORE calling my2DMeshing()!
+my2DMeshing(f1, geom_builder=geompy, smesh_builder=mesh)
+my2DMeshing(f2, geom_builder=geompy, smesh_builder=mesh)
assert mesh.Compute()
# compute 3D mesh