src/Tools/blocFissure/gmu/insereFissureLongue.py

   1 # -*- coding: utf-8 -*-
   2
   3 import logging
   4 import salome
   5 from geomsmesh import geompy
   6 from geomsmesh import smesh
   7 from salome.smesh import smeshBuilder
   8 import SMESH
   9 import math
  10
  11 from extractionOrientee import extractionOrientee
  12 from sortFaces import sortFaces
  13 from sortEdges import sortEdges
  14 from eliminateDoubles import eliminateDoubles
  15 from substractSubShapes import substractSubShapes
  16 from produitMixte import produitMixte
  17 from findWireEndVertices import findWireEndVertices
  18 from getSubshapeIds import getSubshapeIds
  19 from putName import putName
  20 from distance2 import distance2
  21 from enleveDefaut import enleveDefaut
  22 from shapeSurFissure import shapeSurFissure
  23 from regroupeSainEtDefaut import RegroupeSainEtDefaut
  24 from triedreBase import triedreBase
  25
  26 # -----------------------------------------------------------------------------
  27 # --- procedure complete fissure longue
  28
  29 def insereFissureLongue(geometriesSaines, maillagesSains,
  30                         shapesFissure, shapeFissureParams,
  31                         maillageFissureParams, elementsDefaut, step=-1):
  32   """
  33   TODO: a completer
  34   """
  35   logging.info('start')
  36
  37   #geometrieSaine    = geometriesSaines[0]
  38   #maillageSain      = maillagesSains[0]
  39   #isHexa            = maillagesSains[1]
  40   shapeDefaut       = shapesFissure[0] # face de fissure, debordant
  41   #tailleDefaut      = shapesFissure[2]
  42   wiretube          = shapesFissure[4] # wire fond de fissure, debordant
  43   planfiss          = shapesFissure[7] # plan de fissure
  44   pipefiss          = shapesFissure[8] # pipe, debordant
  45
  46   profondeur  = shapeFissureParams['profondeur']
  47   rayonPipe   = profondeur/4.0
  48
  49   nomRep            = maillageFissureParams['nomRep']
  50   nomFicSain        = maillageFissureParams['nomFicSain']
  51   nomFicFissure     = maillageFissureParams['nomFicFissure']
  52
  53   #nbsegExt          = maillageFissureParams['nbsegExt']      # 5
  54   #nbsegGen          = maillageFissureParams['nbsegGen']      # 25
  55   #nbsegRad          = maillageFissureParams['nbsegRad']      # 5
  56   #scaleRad          = maillageFissureParams['scaleRad']      # 4
  57   #nbsegCercle       = maillageFissureParams['nbsegCercle']   # 6
  58   #nbsegFis          = maillageFissureParams['nbsegFis']      # 20
  59   #lensegEllipsoide  = maillageFissureParams['lensegEllipso'] # 1.0
  60
  61   #fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
  62   fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
  63
  64   facesDefaut              = elementsDefaut[0]
  65   #centreDefaut             = elementsDefaut[1]
  66   #normalDefaut             = elementsDefaut[2]
  67   #extrusionDefaut          = elementsDefaut[3]
  68   #dmoyen                   = elementsDefaut[4]
  69   #bordsPartages            = elementsDefaut[5]
  70   #fillconts                = elementsDefaut[6]
  71   #idFilToCont              = elementsDefaut[7]
  72   maillageSain             = elementsDefaut[8]
  73   internalBoundary         = elementsDefaut[9]
  74   zoneDefaut               = elementsDefaut[10]
  75   zoneDefaut_skin          = elementsDefaut[11]
  76   zoneDefaut_internalFaces = elementsDefaut[12]
  77   zoneDefaut_internalEdges = elementsDefaut[13]
  78
  79   facePorteFissure =  shapeDefaut
  80   WirePorteFondFissure = wiretube
  81   fillingFaceExterne = facesDefaut[0]
  82   logging.debug("fillingFaceExterne %s", fillingFaceExterne)
  83   geompy.addToStudy(fillingFaceExterne, "fillingFaceExterne")
  84   edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
  85
  86   O, OX, OY, OZ = triedreBase()
  87
  88   # -----------------------------------------------------------------------------
  89   # --- peau et face de fissure
  90
  91   # --- partition peau defaut - face de fissure prolongee - wire de fond de fissure prolongée
  92   partitionPeauFissFond = geompy.MakePartition([facePorteFissure, WirePorteFondFissure, fillingFaceExterne], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
  93   geompy.addToStudy( partitionPeauFissFond, 'partitionPeauFissFond' )
  94
  95   edges = geompy.ExtractShapes(WirePorteFondFissure, geompy.ShapeType["EDGE"], False)
  96
  97   lgmax = 0
  98   imax = 0
  99   for i, edge in enumerate(edges):
 100     props = geompy.BasicProperties(edge)
 101     lg = props[0]
 102     if lg > lgmax:
 103       lgmax = lg
 104       imax = i
 105   edgemax = edges[imax]
 106   geompy.addToStudy(edgemax, 'edgemax')
 107   centreFondFiss = geompy.MakeVertexOnCurve(edgemax, 0.5)
 108   geompy.addToStudy(centreFondFiss, 'centreFondFiss')
 109   tangentFondFiss = geompy.MakeTangentOnCurve(edgemax, 0.5)
 110   geompy.addToStudy(tangentFondFiss, 'tangentFondFiss')
 111
 112   bord1FondFiss = geompy.MakeVertexOnCurve(edgemax, 0.0)
 113   geompy.addToStudy(bord1FondFiss, 'bord1FondFiss')
 114   tangentBord1FondFiss = geompy.MakeTangentOnCurve(edgemax, 0.0)
 115   geompy.addToStudy(tangentBord1FondFiss, 'tangentBord1FondFiss')
 116
 117   bord2FondFiss = geompy.MakeVertexOnCurve(edgemax, 1.0)
 118   geompy.addToStudy(bord2FondFiss, 'bord2FondFiss')
 119   tangentBord2FondFiss = geompy.MakeTangentOnCurve(edgemax, 1.0)
 120   geompy.addToStudy(tangentBord2FondFiss, 'tangentBord2FondFiss')
 121
 122   planBord1 = geompy.MakePlane(bord1FondFiss, tangentBord1FondFiss, 3*rayonPipe)
 123   planBord2 = geompy.MakePlane(bord2FondFiss, tangentBord2FondFiss, 3*rayonPipe)
 124   geompy.addToStudy(planBord1, 'planBord1')
 125   geompy.addToStudy(planBord2, 'planBord2')
 126
 127   [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
 128   [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
 129
 130   # --- partition peau -face fissure - pipe fond de fissure prolongé
 131   partitionPeauFissByPipe = geompy.MakePartition([facesInside[0], facesOnside[0]], [pipefiss], [], [], geompy.ShapeType["FACE"], 0, [], 0)
 132   geompy.addToStudy( partitionPeauFissByPipe, 'partitionPeauFissByPipe' )
 133
 134   # --- identification face de peau
 135   [facesPeauFissInside, facesPeauFissOutside, facesPeauFissOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissByPipe, centreFondFiss, "FACE", 0.1, "peauFiss_bord_")
 136   facesPeauSorted, minsur, maxsurf = sortFaces(facesPeauFissOnside) # 4 demi disques, une grande face
 137   facePeau = facesPeauSorted[-1] # la plus grande face
 138   geompy.addToStudyInFather(partitionPeauFissByPipe, facePeau, "facePeau")
 139
 140   # --- identification edges de bord face peau
 141   edgesBords = []
 142   for i, edge in enumerate(edgesFilling):
 143     edgepeau = geompy.GetInPlace(facePeau, edge)
 144     edgesBords.append(edgepeau)
 145   groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
 146   geompy.UnionList(groupEdgesBordPeau, edgesBords)
 147   geompy.addToStudyInFather(facePeau, groupEdgesBordPeau , "EdgesBords")
 148
 149   # --- identification face fissure externe au pipe et edge commune peau fissure
 150   for face in facesPeauFissInside:
 151     try:
 152       sharedEdges = geompy.GetSharedShapesMulti([facePeau, face], geompy.ShapeType["EDGE"])
 153       if sharedEdges is not None:
 154         faceFiss = face
 155         edgePeauFiss = sharedEdges[0]
 156         geompy.addToStudyInFather(partitionPeauFissByPipe, faceFiss, "faceFiss")
 157         geompy.addToStudyInFather(faceFiss, edgePeauFiss, "edgePeauFiss")
 158         geompy.addToStudyInFather(facePeau, edgePeauFiss, "edgePeauFiss")
 159         break
 160     except:
 161       pass
 162   verticesEdgePeauFiss = geompy.ExtractShapes(edgePeauFiss, geompy.ShapeType["VERTEX"], False)
 163
 164   # --- identification edges demi cercle dans face de peau
 165   edgesFacePeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
 166   edgesFacePeauSorted, minlg, maxlg = sortEdges(edgesFacePeau)
 167   demiCerclesPeau = edgesFacePeauSorted[0:4]
 168   verticesDemiCerclesPeau = []
 169   for i, edge in enumerate(demiCerclesPeau):
 170     name = "demiCerclePeau_%d"%i
 171     geompy.addToStudyInFather(facePeau, edge, name)
 172     verticesDemiCerclesPeau += geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False)
 173   verticesDemiCerclesPeau = eliminateDoubles(facePeau, verticesDemiCerclesPeau)
 174   for i, vertex in enumerate(verticesDemiCerclesPeau):
 175     name = "verticesDemiCerclesPeau_%d"%i
 176     geompy.addToStudyInFather(facePeau, vertex, name)
 177   verticesOutCercles = substractSubShapes(facePeau, verticesDemiCerclesPeau, verticesEdgePeauFiss)
 178   for i, vertex in enumerate(verticesOutCercles):
 179     name = "verticesOutCercles_%d"%i
 180     geompy.addToStudyInFather(facePeau, vertex, name)
 181
 182   # --- demi cercles  regroupés
 183   groupsDemiCerclesPeau = []
 184   for i, vertex in enumerate(verticesEdgePeauFiss):
 185     demis = []
 186     for edge in demiCerclesPeau:
 187       if geompy.MinDistance(vertex, edge) < 1.e-5:
 188         demis.append(edge)
 189     group = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
 190     geompy.UnionList(group, demis)
 191     name = "Cercle%d"%i
 192     geompy.addToStudyInFather(facePeau, group , name)
 193     groupsDemiCerclesPeau.append(group)
 194
 195   # --- identification edges commune pipe face fissure externe au pipe
 196   edgePeauFissId = geompy.GetSubShapeID(partitionPeauFissByPipe, edgePeauFiss)
 197   edgesFaceFiss = geompy.ExtractShapes(faceFiss, geompy.ShapeType["EDGE"], False)
 198   edgesFaceFissPipe = []
 199   for edge in edgesFaceFiss:
 200     if geompy.GetSubShapeID(partitionPeauFissByPipe, edge) != edgePeauFissId:
 201       edgesFaceFissPipe.append(edge)
 202       name = "edgeFaceFissPipe_%d"%len(edgesFaceFissPipe)
 203       geompy.addToStudyInFather(faceFiss, edge, name)
 204   groupEdgesFaceFissPipe = geompy.CreateGroup(faceFiss, geompy.ShapeType["EDGE"])
 205   geompy.UnionList(groupEdgesFaceFissPipe, edgesFaceFissPipe)
 206   geompy.addToStudyInFather(faceFiss, groupEdgesFaceFissPipe, "edgesFaceFissPipe")
 207
 208   # -----------------------------------------------------------------------------
 209   # --- pipe de fond de fissure
 210
 211   wireFondFiss = geompy.MakeWire(edgesInside, 1e-07)
 212
 213   disque = geompy.MakeDiskPntVecR(centreFondFiss, tangentFondFiss, rayonPipe)
 214   [vertex] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
 215   vertproj = geompy.MakeProjection(vertex, planfiss)
 216   vec1 = geompy.MakeVector(centreFondFiss, vertex)
 217   try:
 218     # si centreFondFiss et vertproj sont proches: exception. Angle = +- 90°
 219     vec2 = geompy.MakeVector(centreFondFiss, vertproj)
 220     angle = geompy.GetAngleRadians(vec1, vec2)
 221   except:
 222     # on utilise la projection du centre sur la peau pour avoir un vecteur non nul
 223     vertproj = geompy.MakeProjection(centreFondFiss, facePeau)
 224     vec2 = geompy.MakeVector(centreFondFiss, vertproj)
 225     angle = geompy.GetAngleRadians(vec1, vec2)
 226   sommetAxe = geompy.MakeTranslationVector(centreFondFiss, tangentFondFiss)
 227   pm = produitMixte(centreFondFiss, vertex, vertproj, sommetAxe)
 228   if pm > 0:
 229     disque = geompy.MakeRotation(disque, tangentFondFiss, angle)
 230   else:
 231     disque = geompy.MakeRotation(disque, tangentFondFiss, -angle)
 232   [vertexReference] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
 233
 234   pipeFondFiss = geompy.MakePipe(disque, wireFondFiss)
 235   pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
 236   #pipe = geompy.MakePipe(disque, WirePorteFondFissure)
 237   #pipe = geompy.MakePartition([pipe],[fillingFaceExterne], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
 238   #pipes = geompy.ExtractShapes(pipe, geompy.ShapeType["SOLID"], False)
 239   #pipesSorted, volmin, volmax = sortSolids(pipes)
 240   #pipeFondFiss = pipesSorted[-1]
 241   #pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
 242
 243   geompy.addToStudy( disque, 'disque')
 244   geompy.addToStudy( wireFondFiss, 'wireFondFiss')
 245   geompy.addToStudy( pipeFondFiss, 'pipeFondFiss')
 246
 247   VerticesEndFondFiss = findWireEndVertices(wireFondFiss)
 248   for i, v in enumerate(VerticesEndFondFiss):
 249     name = "vertexEndFondFiss_%d"%i
 250     geompy.addToStudyInFather(wireFondFiss, v, name)
 251   VerticesEndPipeFiss = []
 252   for v in VerticesEndFondFiss:
 253     VerticesEndPipeFiss.append(geompy.GetInPlace(pipeFondFiss, v))
 254   for i, v in enumerate(VerticesEndPipeFiss):
 255     name = "vertexEndPipeFiss_%d"%i
 256     geompy.addToStudyInFather(pipeFondFiss, v, name)
 257
 258   geompy.addToStudyInFather(pipeFondFiss, VerticesEndPipeFiss[0], "PFOR")
 259   geompy.addToStudyInFather(pipeFondFiss, VerticesEndPipeFiss[1], "PFEX")
 260   if geompy.MinDistance(VerticesEndPipeFiss[0], verticesOutCercles[0]) > geompy.MinDistance(VerticesEndPipeFiss[0], verticesOutCercles[1]):
 261     a = verticesOutCercles[0]
 262     verticesOutCercles[0] = verticesOutCercles[1]
 263     verticesOutCercles[1] = a
 264   geompy.addToStudyInFather(facePeau, verticesOutCercles[0], "THOR")
 265   geompy.addToStudyInFather(facePeau, verticesOutCercles[1], "THEX")
 266
 267   [facesPipeInside, facesPipeOutside, facesPipeOnside] = extractionOrientee(fillingFaceExterne, pipeFondFiss, centreFondFiss, "FACE", 0.1, "pipe_bord_")
 268   [edgesPipeInside, edgesPipeOutside, edgesPipeOnside] = extractionOrientee(fillingFaceExterne, pipeFondFiss, centreFondFiss, "EDGE", 0.1, "pipe_bord_")
 269   disqueInt1 = geompy.GetInPlaceByHistory(pipeFondFiss, planBord1)
 270   disqueInt2 = geompy.GetInPlaceByHistory(pipeFondFiss, planBord2)
 271   disques = facesPipeOnside + [disqueInt1, disqueInt2]
 272   edgesDiskInt = geompy.ExtractShapes(disqueInt1, geompy.ShapeType["EDGE"], False)
 273   edgesDiskInt = edgesDiskInt +geompy.ExtractShapes(disqueInt2, geompy.ShapeType["EDGE"], False)
 274   edgesSorted, minlg, maxlg = sortEdges(edgesDiskInt) # 4 rayons, 2 demi cercles
 275
 276   centre = geompy.MakeVertexOnSurface(planfiss, 0.5, 0.5)
 277   refpoint = geompy.MakeTranslationVector(centre, geompy.GetNormal(planfiss,centre))
 278   geompy.addToStudy(refpoint, 'refpoint')
 279   [facesPipeInplan, facesPipeOutplan, facesPipeOnplan] = extractionOrientee(planfiss, pipeFondFiss, refpoint, "FACE", 0.1, "pipe_plan_")
 280   [edgesPipeInplan, edgesPipeOutplan, edgesPipeOnplan] = extractionOrientee(planfiss, pipeFondFiss, refpoint, "EDGE", 0.1, "pipe_plan_")
 281
 282   # --- rayon disques = (edgesPipeOnside inter edgesPipeOnplan) + rayons disque internes
 283   #     demi cercles  = edgesPipeOnside moins edgesPipeOnplan + demi cercles disque internes
 284   #     generatrices  = edgesPipeOnplan moins rayon disques (3 grandes et 6 petites)
 285   edgesIdPipeOnside = getSubshapeIds(pipeFondFiss, edgesPipeOnside)
 286   edgesIdPipeOnplan = getSubshapeIds(pipeFondFiss, edgesPipeOnplan)
 287   rayons = []
 288   demiCercles = []
 289   for i, edgeId in enumerate(edgesIdPipeOnside):
 290     if edgeId in edgesIdPipeOnplan:
 291       rayons.append(edgesPipeOnside[i])
 292     else:
 293       demiCercles.append(edgesPipeOnside[i])
 294   demiCerclesExternes = demiCercles
 295   rayons = rayons + edgesSorted[:4]            # les 4 plus petits sont les rayons
 296   demiCercles = demiCercles  + edgesSorted[4:] # les suivants sont les arcs de cercle
 297   rayonsId = getSubshapeIds(pipeFondFiss, rayons)
 298   generatrices = []
 299   for i, edgeId in enumerate(edgesIdPipeOnplan):
 300     if edgeId not in rayonsId:
 301       generatrices.append(edgesPipeOnplan[i])
 302
 303   # --- generatrices en contact avec la face fissure externe au pipe
 304   generFiss = []
 305   for edge in generatrices:
 306     distance = geompy.MinDistance(vertexReference, edge)
 307     logging.debug("distance %s", distance)
 308     if distance < 1.e-5:
 309       generFiss.append(edge)
 310       break
 311   for edge in generatrices:
 312     distance = geompy.MinDistance(generFiss[0], edge)
 313     logging.debug("distance %s", distance)
 314     if distance < 1.e-5:
 315       generFiss.append(edge)
 316   groupGenerFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
 317   geompy.UnionList(groupGenerFiss, generFiss)
 318   geompy.addToStudyInFather(pipeFondFiss, groupGenerFiss, "GenFiss")
 319
 320   # --- demi cercles externes regroupés
 321   groupsDemiCerclesPipe = []
 322   for i, vertex in enumerate(verticesEdgePeauFiss):
 323     demis = []
 324     for edge in demiCerclesExternes:
 325       if geompy.MinDistance(vertex, edge) < 0.1:
 326         demis.append(edge)
 327     group = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
 328     geompy.UnionList(group, demis)
 329     name = "Cercle%d"%i
 330     geompy.addToStudyInFather(pipeFondFiss, group , name)
 331     groupsDemiCerclesPipe.append(group)
 332
 333   # --- faces fissure dans le pipe
 334
 335   facesFissinPipe = []
 336   generFissId = getSubshapeIds(pipeFondFiss, generFiss)
 337   logging.debug("generatrice fissure %s", generFissId)
 338   for face in facesPipeOnplan:
 339     edges =geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], False)
 340     edgesId = getSubshapeIds(pipeFondFiss, edges)
 341     logging.debug("  edges %s", edgesId)
 342     for i,edgeId in enumerate(edgesId):
 343       if edgeId in generFissId:
 344         logging.debug("face found")
 345         facesFissinPipe.append(face)
 346         name = "faceFissInPipe_%d"%i
 347         geompy.addToStudyInFather(pipeFondFiss, face, name)
 348         break
 349   groupFaceFissInPipe = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["FACE"])
 350   geompy.UnionList(groupFaceFissInPipe, facesFissinPipe)
 351   name = "FaceFissInPipe"
 352   geompy.addToStudyInFather(pipeFondFiss, groupFaceFissInPipe , name)
 353
 354   # --- edges de fond de fissure
 355
 356   edgesFondFiss = []
 357   for i, edge in enumerate(edgesInside):
 358     anEdge = geompy.GetInPlace(pipeFondFiss, edge)
 359     logging.debug("  edge %s ", anEdge)
 360     edgesFondFiss.append(anEdge)
 361     name ="edgeFondFissure_%d"%i
 362     geompy.addToStudyInFather(pipeFondFiss, anEdge, name)
 363   groupEdgeFondFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
 364   geompy.UnionList(groupEdgeFondFiss, edgesFondFiss)
 365   name = "FONDFISS"
 366   geompy.addToStudyInFather(pipeFondFiss, groupEdgeFondFiss , name)
 367
 368   # -------------------------------------------------------------------------
 369   # --- maillage
 370
 371   # --- edges de bord face defaut à respecter
 372
 373   aFilterManager = smesh.CreateFilterManager()
 374   nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [  ])
 375   criteres = []
 376   unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
 377   criteres.append(unCritere)
 378   filtre = smesh.GetFilterFromCriteria(criteres)
 379   bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
 380   smesh.SetName(bordsLibres, 'bordsLibres')
 381
 382   # --- pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
 383   #     on designe les faces de peau en quadrangles par le groupe "skinFaces"
 384
 385   skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
 386   nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
 387
 388   # --- maillage pipe fond fissure
 389
 390   meshFondFiss = smesh.Mesh(pipeFondFiss)
 391   algo2d = meshFondFiss.Quadrangle(algo=smeshBuilder.QUADRANGLE)
 392   algo3d = meshFondFiss.Prism()
 393   putName(algo3d.GetSubMesh(), "pipe")
 394   putName(algo3d, "algo3d_pipe")
 395   putName(algo2d, "algo2d_pipe")
 396
 397   for i, face in enumerate(disques):
 398     algo2d = meshFondFiss.Quadrangle(algo=smeshBuilder.RADIAL_QUAD,geom=face)
 399     putName(algo2d.GetSubMesh(), "disque", i)
 400     putName(algo2d, "algo2d_disque", i)
 401
 402   for i, edge in enumerate(rayons):
 403     algo1d = meshFondFiss.Segment(geom=edge)
 404     hypo1d = algo1d.NumberOfSegments(4)
 405     putName(algo1d.GetSubMesh(), "rayon", i)
 406     putName(algo1d, "algo1d_rayon", i)
 407     putName(hypo1d, "hypo1d_rayon", i)
 408
 409   for i, edge in enumerate(demiCercles):
 410     algo1d = meshFondFiss.Segment(geom=edge)
 411     hypo1d = algo1d.NumberOfSegments(6)
 412     putName(algo1d.GetSubMesh(), "demiCercle", i)
 413     putName(algo1d, "algo1d_demiCercle", i)
 414     putName(hypo1d, "hypo1d_demiCercle", i)
 415
 416   generSorted, minlg, maxlg = sortEdges(generatrices)
 417   nbSegGenLong = int(math.sqrt(3.0)*maxlg/(profondeur - rayonPipe)) # on veut 2 triangles equilateraux dans la largeur de la face
 418   nbSegGenBout = 6
 419   logging.info("min %s, max %s, nombre de segments %s, nombre de generatrices %s", minlg, maxlg, nbSegGenLong, len(generSorted))
 420   for i, edge in enumerate(generSorted):
 421     algo1d = meshFondFiss.Segment(geom=edge)
 422     if i < 6:
 423       hypo1d = algo1d.NumberOfSegments(nbSegGenBout)
 424     else:
 425       hypo1d = algo1d.NumberOfSegments(nbSegGenLong)
 426     putName(algo1d.GetSubMesh(), "generatrice", i)
 427     putName(algo1d, "algo1d_generatrice", i)
 428     putName(hypo1d, "hypo1d_generatrice", i)
 429   isDone = meshFondFiss.Compute()
 430   logging.info("meshFondFiss computed")
 431
 432   disks = []
 433   for i, face in enumerate(disques[:4]):
 434     name = "disk%d"%i
 435     disks.append(meshFondFiss.GroupOnGeom(face, name, SMESH.FACE))
 436   peauext_pipe = meshFondFiss.GetMesh().UnionListOfGroups( disks, 'PEAUEXT' )
 437
 438   grpPFOR = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[0], "PFOR", SMESH.NODE)
 439   grpPFEX = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[1], "PFEX", SMESH.NODE)
 440
 441   grp = meshFondFiss.GroupOnGeom(groupFaceFissInPipe, "fisInPi", SMESH.FACE)
 442   group_edgeFondFiss = meshFondFiss.GroupOnGeom(groupEdgeFondFiss, "FONDFISS", SMESH.EDGE)
 443   noeudsFondFissure = meshFondFiss.GroupOnGeom(groupEdgeFondFiss, "nfondfis", SMESH.NODE)
 444   groups_demiCercles = []
 445   groupnodes_demiCercles = []
 446   for i, group in enumerate(groupsDemiCerclesPipe):
 447     name = "Cercle%d"%i
 448     groups_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.EDGE))
 449     name = "nCercle%d"%i
 450     groupnodes_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.NODE))
 451   group_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.EDGE)
 452   groupnode_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.NODE)
 453   grpNode0 = meshFondFiss.IntersectGroups(groupnode_generFiss, groupnodes_demiCercles[0], "Node0")
 454   grpNode1 = meshFondFiss.IntersectGroups(groupnode_generFiss, groupnodes_demiCercles[1], "Node1")
 455   idNode0 = grpNode0.GetID(1)
 456   idNode1 = grpNode1.GetID(1)
 457   coordsMesh = []
 458   coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode0))
 459   coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode1))
 460   coordsGeom = []
 461   for vertex in verticesEdgePeauFiss:
 462     coord = geompy.PointCoordinates(vertex);
 463     if distance2(coord, coordsMesh[0]) < 0.1:
 464       meshFondFiss.MoveNode(idNode0, coord[0], coord[1], coord[2])
 465     if distance2(coord, coordsMesh[1]) < 0.1:
 466       meshFondFiss.MoveNode(idNode1, coord[0], coord[1], coord[2])
 467
 468   for groupNodes in groupnodes_demiCercles:
 469     for idNode in groupNodes.GetListOfID():
 470       coordMesh = meshFondFiss.GetNodeXYZ(idNode)
 471       vertex = geompy.MakeVertex(coordMesh[0], coordMesh[1], coordMesh[2])
 472       minDist = 100000
 473       minCoord = None
 474       imin = -1
 475       for i, edge in enumerate(demiCerclesPeau):
 476         discoord = geompy.MinDistanceComponents(vertex, edge)
 477         if discoord[0] <minDist:
 478           minDist = discoord[0]
 479           minCoord = discoord[1:]
 480           imin = i
 481       if imin >= 0 and minDist > 1.E-6:
 482         logging.debug("node id moved : %s distance=%s", idNode, minDist)
 483         meshFondFiss.MoveNode(idNode, coordMesh[0] + minCoord[0], coordMesh[1] + minCoord[1], coordMesh[2] + minCoord[2])
 484
 485
 486   # --- maillage face de peau
 487
 488   meshFacePeau = smesh.Mesh(facePeau)
 489   algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_2D)
 490   hypo2d = algo2d.Parameters()
 491   hypo2d.SetMaxSize( 1000 )
 492   hypo2d.SetOptimize( 1 )
 493   hypo2d.SetFineness( 2 )
 494   hypo2d.SetMinSize( 2 )
 495   hypo2d.SetQuadAllowed( 0 )
 496   putName(algo2d.GetSubMesh(), "facePeau")
 497   putName(algo2d, "algo2d_facePeau")
 498   putName(hypo2d, "hypo2d_facePeau")
 499   #
 500   lenEdgePeauFiss = geompy.BasicProperties(edgePeauFiss)[0]
 501   frac = profondeur/lenEdgePeauFiss
 502   nbSeg = nbSegGenLong +2*nbSegGenBout
 503   ratio = (nbSegGenBout/float(profondeur)) / (nbSegGenLong/lenEdgePeauFiss)
 504   logging.info("lenEdgePeauFiss %s, profondeur %s, nbSegGenLong %s, nbSegGenBout %s, frac %s, ratio %s", lenEdgePeauFiss, profondeur, nbSegGenLong, nbSegGenBout, frac, ratio)
 505   algo1d = meshFacePeau.Segment(geom=edgePeauFiss)
 506   hypo1d = algo1d.NumberOfSegments(nbSeg,[],[  ])
 507   hypo1d.SetDistrType( 2 )
 508   hypo1d.SetConversionMode( 1 )
 509   hypo1d.SetTableFunction( [ 0, ratio, frac, 1, (1.-frac), 1, 1, ratio ] )
 510   putName(algo1d.GetSubMesh(), "edgePeauFiss")
 511   putName(algo1d, "algo1d_edgePeauFiss")
 512   putName(hypo1d, "hypo1d_edgePeauFiss")
 513   #
 514   algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
 515   hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
 516   putName(algo1d.GetSubMesh(), "bordsLibres")
 517   putName(algo1d, "algo1d_bordsLibres")
 518   putName(hypo1d, "hypo1d_bordsLibres")
 519   #
 520   for i in range(2):
 521     algo1d = meshFacePeau.UseExisting1DElements(geom=groupsDemiCerclesPeau[i])
 522     hypo1d = algo1d.SourceEdges([ groups_demiCercles[i] ],0,0)
 523     putName(algo1d.GetSubMesh(), "DemiCercles", i)
 524     putName(algo1d, "algo1d_groupDemiCercles", i)
 525     putName(hypo1d, "hypo1d_groupDemiCercles", i)
 526   #
 527   isDone = meshFacePeau.Compute()
 528   logging.info("meshFacePeau computed")
 529   grpTHOR = meshFacePeau.GroupOnGeom(verticesOutCercles[0], "THOR", SMESH.NODE)
 530   grpTHEX = meshFacePeau.GroupOnGeom(verticesOutCercles[1], "THEX", SMESH.NODE)
 531
 532   groupEdgesPeauFiss = meshFacePeau.GroupOnGeom(edgePeauFiss, "PeauFis", SMESH.EDGE)
 533
 534   peauext_face = meshFacePeau.CreateEmptyGroup( SMESH.FACE, 'PEAUEXT' )
 535   nbAdd = peauext_face.AddFrom( meshFacePeau.GetMesh() )
 536
 537
 538   # --- maillage face de fissure
 539
 540   meshFaceFiss = smesh.Mesh(faceFiss)
 541   algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_2D)
 542   hypo2d = algo2d.Parameters()
 543   hypo2d.SetMaxSize( (profondeur - rayonPipe)/math.sqrt(3.0) ) # pour avoir deux couches de triangles equilateraux partout sur la fissure
 544   hypo2d.SetOptimize( 1 )
 545   hypo2d.SetFineness( 2 )
 546   hypo2d.SetMinSize( 2 )
 547   hypo2d.SetQuadAllowed( 0 )
 548   putName(algo2d.GetSubMesh(), "faceFiss")
 549   putName(algo2d, "algo2d_faceFiss")
 550   putName(hypo2d, "hypo2d_faceFiss")
 551   #
 552   algo1d = meshFaceFiss.UseExisting1DElements(geom=edgePeauFiss)
 553   hypo1d = algo1d.SourceEdges([ groupEdgesPeauFiss ],0,0)
 554   putName(algo1d.GetSubMesh(), "edgeFissPeau")
 555   putName(algo1d, "algo1d_edgeFissPeau")
 556   putName(hypo1d, "hypo1d_edgeFissPeau")
 557   #
 558   algo1d = meshFaceFiss.UseExisting1DElements(geom=groupEdgesFaceFissPipe)
 559   hypo1d = algo1d.SourceEdges([ group_generFiss ],0,0)
 560   putName(algo1d.GetSubMesh(), "edgeFissPeau")
 561   putName(algo1d, "algo1d_edgeFissPeau")
 562   putName(hypo1d, "hypo1d_edgeFissPeau")
 563   #
 564   isDone = meshFaceFiss.Compute()
 565   logging.info("meshFaceFiss computed")
 566
 567   grp = meshFaceFiss.GroupOnGeom(faceFiss, "fisOutPi", SMESH.FACE)
 568
 569   meshBoiteDefaut = smesh.Concatenate([internalBoundary.GetMesh(),
 570                                    meshFondFiss.GetMesh(),
 571                                    meshFacePeau.GetMesh(),
 572                                    meshFaceFiss.GetMesh()],
 573                                    1, 1, 1e-05,False)
 574   # pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
 575   # on designe les faces de peau en quadrangles par le groupe "skinFaces"
 576   group_faceFissOutPipe = None
 577   group_faceFissInPipe = None
 578   groups = meshBoiteDefaut.GetGroups()
 579   for grp in groups:
 580     if grp.GetType() == SMESH.FACE:
 581       #if "internalBoundary" in grp.GetName():
 582       #  grp.SetName("skinFaces")
 583       if grp.GetName() == "fisOutPi":
 584         group_faceFissOutPipe = grp
 585       elif grp.GetName() == "fisInPi":
 586         group_faceFissInPipe = grp
 587
 588   # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
 589   distene=True
 590   if distene:
 591     algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
 592   else:
 593     algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
 594     hypo3d = algo3d.MaxElementVolume(1000.0)
 595   putName(algo3d.GetSubMesh(), "boiteDefaut")
 596   putName(algo3d, "algo3d_boiteDefaut")
 597   isDone = meshBoiteDefaut.Compute()
 598   logging.info("meshBoiteDefaut computed")
 599   putName(meshBoiteDefaut, "boiteDefaut")
 600
 601   groups = maillageSain.GetGroups()
 602   grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
 603   grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
 604   coords1 = maillageSain.GetNodeXYZ(grps1[0].GetID(1))
 605   coords2 = maillageSain.GetNodeXYZ(grps2[0].GetID(1))
 606   logging.info("coords1 %s, coords2 %s",coords1, coords2)
 607
 608   faceFissure = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
 609   maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges)
 610   putName(maillageSain, nomFicSain+"_coupe")
 611   extrusionFaceFissure, normfiss = shapeSurFissure(facePorteFissure)
 612   maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut, extrusionFaceFissure, facePorteFissure, 'COUDE')
 613
 614   groups = maillageComplet.GetGroups()
 615   grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
 616   grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
 617   nodeid1 = maillageComplet.AddNode(coords1[0], coords1[1], coords1[2])
 618   nodeid2 = maillageComplet.AddNode(coords2[0], coords2[1], coords2[2])
 619   grps1[0].Add([nodeid1])
 620   grps2[0].Add([nodeid2])
 621   ma0d1 = maillageComplet.Add0DElement(nodeid1)
 622   ma0d2 = maillageComplet.Add0DElement(nodeid2)
 623   grpma0d1 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P1' )
 624   nbAdd = grpma0d1.Add( [ma0d1] )
 625   grpma0d2 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P2' )
 626   nbAdd = grpma0d2.Add( [ma0d2] )
 627
 628 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedEdges']
 629 #  grps[0].SetName('affEdges')
 630 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedFaces']
 631 #  grps[0].SetName('affFaces')
 632 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedVolumes']
 633 #  grps[0].SetName('affVols')
 634
 635   maillageComplet.ConvertToQuadratic( 1 )
 636   grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
 637   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
 638
 639   grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
 640   nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
 641
 642   plansim = geompy.MakePlane(O, normfiss, 10000)
 643   fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
 644   grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
 645   nb = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
 646   #isDone = maillageComplet.ReorientObject( grps[0] )
 647   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
 648
 649   maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
 650   putName(maillageComplet, nomFicFissure)
 651   logging.info("fichier maillage fissure %s", fichierMaillageFissure)
 652
 653   if salome.sg.hasDesktop():
 654     salome.sg.updateObjBrowser(1)
 655
 656   return  maillageComplet