src/Tools/blocFissure/gmu/insereFissureLongue.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2014-2020  EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License, or (at your option) any later version.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21 import os
  22
  23 import logging
  24 import salome
  25 from .geomsmesh import geompy
  26 from .geomsmesh import geomPublish
  27 from .geomsmesh import geomPublishInFather
  28 from . import initLog
  29 from .geomsmesh import smesh
  30 from salome.smesh import smeshBuilder
  31 import SMESH
  32 import math
  33
  34 from .extractionOrientee import extractionOrientee
  35 from .sortFaces import sortFaces
  36 from .sortEdges import sortEdges
  37 from .eliminateDoubles import eliminateDoubles
  38 from .substractSubShapes import substractSubShapes
  39 from .produitMixte import produitMixte
  40 from .findWireEndVertices import findWireEndVertices
  41 from .getSubshapeIds import getSubshapeIds
  42 from .putName import putName
  43 from .distance2 import distance2
  44 from .enleveDefaut import enleveDefaut
  45 from .shapeSurFissure import shapeSurFissure
  46 from .regroupeSainEtDefaut import RegroupeSainEtDefaut
  47 from .triedreBase import triedreBase
  48
  49 from blocFissure.gmu.insereFissureLongue_a import insereFissureLongue_a
  50 from blocFissure.gmu.insereFissureLongue_b import insereFissureLongue_b
  51 from blocFissure.gmu.insereFissureLongue_c import insereFissureLongue_c
  52 from blocFissure.gmu.insereFissureLongue_d import insereFissureLongue_d
  53
  54 # -----------------------------------------------------------------------------
  55 # --- procedure complete fissure longue
  56
  57 def insereFissureLongue(geometriesSaines, maillagesSains,
  58                         shapesFissure, shapeFissureParams,
  59                         maillageFissureParams, elementsDefaut, step=-1):
  60   """
  61   TODO: a completer
  62   """
  63   logging.info('start')
  64
  65   #geometrieSaine    = geometriesSaines[0]
  66   #maillageSain      = maillagesSains[0]
  67   #isHexa            = maillagesSains[1]
  68   shapeDefaut       = shapesFissure[0] # face de fissure, debordant
  69   #tailleDefaut      = shapesFissure[2]
  70   wiretube          = shapesFissure[4] # wire fond de fissure, debordant
  71   planfiss          = shapesFissure[7] # plan de fissure
  72   pipefiss          = shapesFissure[8] # pipe, debordant
  73
  74   profondeur  = shapeFissureParams['profondeur']
  75   rayonPipe   = profondeur/4.0
  76
  77   nomRep            = maillageFissureParams['nomRep']
  78   nomFicSain        = maillageFissureParams['nomFicSain']
  79   nomFicFissure     = maillageFissureParams['nomFicFissure']
  80
  81   #nbsegExt          = maillageFissureParams['nbsegExt']      # 5
  82   #nbsegGen          = maillageFissureParams['nbsegGen']      # 25
  83   #nbsegRad          = maillageFissureParams['nbsegRad']      # 5
  84   #scaleRad          = maillageFissureParams['scaleRad']      # 4
  85   #nbsegCercle       = maillageFissureParams['nbsegCercle']   # 6
  86   #nbsegFis          = maillageFissureParams['nbsegFis']      # 20
  87   #lensegEllipsoide  = maillageFissureParams['lensegEllipso'] # 1.0
  88
  89   #fichierMaillageSain = os.path.join(nomRep, '{}.med'.format(nomFicSain))
  90   fichierMaillageFissure = os.path.join(nomRep, '{}.med'.format(nomFicFissure))
  91
  92   facesDefaut              = elementsDefaut[0]
  93   #centreDefaut             = elementsDefaut[1]
  94   #normalDefaut             = elementsDefaut[2]
  95   #extrusionDefaut          = elementsDefaut[3]
  96   #dmoyen                   = elementsDefaut[4]
  97   #bordsPartages            = elementsDefaut[5]
  98   #fillconts                = elementsDefaut[6]
  99   #idFilToCont              = elementsDefaut[7]
 100   maillageSain             = elementsDefaut[8]
 101   internalBoundary         = elementsDefaut[9]
 102   zoneDefaut               = elementsDefaut[10]
 103   zoneDefaut_skin          = elementsDefaut[11]
 104   zoneDefaut_internalFaces = elementsDefaut[12]
 105   zoneDefaut_internalEdges = elementsDefaut[13]
 106
 107   facePorteFissure =  shapeDefaut
 108   WirePorteFondFissure = wiretube
 109   fillingFaceExterne = facesDefaut[0]
 110   logging.debug("fillingFaceExterne %s", fillingFaceExterne)
 111   geomPublish(initLog.debug, fillingFaceExterne, "fillingFaceExterne")
 112   edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
 113
 114   O, OX, OY, OZ = triedreBase()
 115
 116   # -----------------------------------------------------------------------------
 117   # --- peau et face de fissure
 118
 119   # --- partition peau defaut - face de fissure prolongee - wire de fond de fissure prolongée
 120   partitionPeauFissFond = geompy.MakePartition([facePorteFissure, WirePorteFondFissure, fillingFaceExterne], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
 121   geomPublish(initLog.debug,  partitionPeauFissFond, 'partitionPeauFissFond' )
 122
 123   edges = geompy.ExtractShapes(WirePorteFondFissure, geompy.ShapeType["EDGE"], False)
 124
 125   lgmax = 0
 126   imax = 0
 127   for i, edge in enumerate(edges):
 128     props = geompy.BasicProperties(edge)
 129     lg = props[0]
 130     if lg > lgmax:
 131       lgmax = lg
 132       imax = i
 133   edgemax = edges[imax]
 134   geomPublish(initLog.debug, edgemax, 'edgemax')
 135   centreFondFiss = geompy.MakeVertexOnCurve(edgemax, 0.5)
 136   geomPublish(initLog.debug, centreFondFiss, 'centreFondFiss')
 137   tangentFondFiss = geompy.MakeTangentOnCurve(edgemax, 0.5)
 138   geomPublish(initLog.debug, tangentFondFiss, 'tangentFondFiss')
 139
 140   bord1FondFiss = geompy.MakeVertexOnCurve(edgemax, 0.0)
 141   geomPublish(initLog.debug, bord1FondFiss, 'bord1FondFiss')
 142   tangentBord1FondFiss = geompy.MakeTangentOnCurve(edgemax, 0.0)
 143   geomPublish(initLog.debug, tangentBord1FondFiss, 'tangentBord1FondFiss')
 144
 145   bord2FondFiss = geompy.MakeVertexOnCurve(edgemax, 1.0)
 146   geomPublish(initLog.debug, bord2FondFiss, 'bord2FondFiss')
 147   tangentBord2FondFiss = geompy.MakeTangentOnCurve(edgemax, 1.0)
 148   geomPublish(initLog.debug, tangentBord2FondFiss, 'tangentBord2FondFiss')
 149
 150   planBord1 = geompy.MakePlane(bord1FondFiss, tangentBord1FondFiss, 3*rayonPipe)
 151   planBord2 = geompy.MakePlane(bord2FondFiss, tangentBord2FondFiss, 3*rayonPipe)
 152   geomPublish(initLog.debug, planBord1, 'planBord1')
 153   geomPublish(initLog.debug, planBord2, 'planBord2')
 154
 155   [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
 156   [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
 157
 158   # --- partition peau -face fissure - pipe fond de fissure prolongé
 159   partitionPeauFissByPipe = geompy.MakePartition([facesInside[0], facesOnside[0]], [pipefiss], list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
 160   geomPublish(initLog.debug,  partitionPeauFissByPipe, 'partitionPeauFissByPipe' )
 161
 162   # --- identification face de peau
 163   [facesPeauFissInside, facesPeauFissOutside, facesPeauFissOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissByPipe, centreFondFiss, "FACE", 0.1, "peauFiss_bord_")
 164   facesPeauSorted, minsur, maxsurf = sortFaces(facesPeauFissOnside) # 4 demi disques, une grande face
 165   facePeau = facesPeauSorted[-1] # la plus grande face
 166   geomPublishInFather(initLog.debug,partitionPeauFissByPipe, facePeau, "facePeau")
 167
 168   # --- identification edges de bord face peau
 169   edgesBords = list()
 170   for i, edge in enumerate(edgesFilling):
 171     edgepeau = geompy.GetInPlace(facePeau, edge)
 172     edgesBords.append(edgepeau)
 173   groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
 174   geompy.UnionList(groupEdgesBordPeau, edgesBords)
 175   geomPublishInFather(initLog.debug,facePeau, groupEdgesBordPeau , "EdgesBords")
 176
 177   # --- identification face fissure externe au pipe et edge commune peau fissure
 178   for face in facesPeauFissInside:
 179     try:
 180       sharedEdges = geompy.GetSharedShapesMulti([facePeau, face], geompy.ShapeType["EDGE"])
 181       if sharedEdges is not None:
 182         faceFiss = face
 183         edgePeauFiss = sharedEdges[0]
 184         geomPublishInFather(initLog.debug,partitionPeauFissByPipe, faceFiss, "faceFiss")
 185         geomPublishInFather(initLog.debug,faceFiss, edgePeauFiss, "edgePeauFiss")
 186         geomPublishInFather(initLog.debug,facePeau, edgePeauFiss, "edgePeauFiss")
 187         break
 188     except:
 189       pass
 190   verticesEdgePeauFiss = geompy.ExtractShapes(edgePeauFiss, geompy.ShapeType["VERTEX"], False)
 191
 192   # --- identification edges demi cercle dans face de peau
 193   edgesFacePeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
 194   edgesFacePeauSorted, minlg, maxlg = sortEdges(edgesFacePeau)
 195   demiCerclesPeau = edgesFacePeauSorted[0:4]
 196   verticesDemiCerclesPeau = list()
 197   for i, edge in enumerate(demiCerclesPeau):
 198     name = "demiCerclePeau_%d"%i
 199     geomPublishInFather(initLog.debug,facePeau, edge, name)
 200     verticesDemiCerclesPeau += geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False)
 201   verticesDemiCerclesPeau = eliminateDoubles(facePeau, verticesDemiCerclesPeau)
 202   for i, vertex in enumerate(verticesDemiCerclesPeau):
 203     name = "verticesDemiCerclesPeau_%d"%i
 204     geomPublishInFather(initLog.debug,facePeau, vertex, name)
 205   verticesOutCercles = substractSubShapes(facePeau, verticesDemiCerclesPeau, verticesEdgePeauFiss)
 206   for i, vertex in enumerate(verticesOutCercles):
 207     name = "verticesOutCercles_%d"%i
 208     geomPublishInFather(initLog.debug,facePeau, vertex, name)
 209
 210   # --- demi cercles  regroupés
 211   groupsDemiCerclesPeau = list()
 212   for i, vertex in enumerate(verticesEdgePeauFiss):
 213     demis = list()
 214     for edge in demiCerclesPeau:
 215       if geompy.MinDistance(vertex, edge) < 1.e-5:
 216         demis.append(edge)
 217     group = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
 218     geompy.UnionList(group, demis)
 219     name = "Cercle%d"%i
 220     geomPublishInFather(initLog.debug,facePeau, group , name)
 221     groupsDemiCerclesPeau.append(group)
 222
 223   # --- identification edges commune pipe face fissure externe au pipe
 224   edgePeauFissId = geompy.GetSubShapeID(partitionPeauFissByPipe, edgePeauFiss)
 225   edgesFaceFiss = geompy.ExtractShapes(faceFiss, geompy.ShapeType["EDGE"], False)
 226   edgesFaceFissPipe = list()
 227   for edge in edgesFaceFiss:
 228     if geompy.GetSubShapeID(partitionPeauFissByPipe, edge) != edgePeauFissId:
 229       edgesFaceFissPipe.append(edge)
 230       name = "edgeFaceFissPipe_%d"%len(edgesFaceFissPipe)
 231       geomPublishInFather(initLog.debug,faceFiss, edge, name)
 232   groupEdgesFaceFissPipe = geompy.CreateGroup(faceFiss, geompy.ShapeType["EDGE"])
 233   geompy.UnionList(groupEdgesFaceFissPipe, edgesFaceFissPipe)
 234   geomPublishInFather(initLog.debug,faceFiss, groupEdgesFaceFissPipe, "edgesFaceFissPipe")
 235
 236   # -----------------------------------------------------------------------------
 237   # --- pipe de fond de fissure
 238
 239   wireFondFiss = geompy.MakeWire(edgesInside, 1e-07)
 240
 241   disque = geompy.MakeDiskPntVecR(centreFondFiss, tangentFondFiss, rayonPipe)
 242   [vertex] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
 243   vertproj = geompy.MakeProjection(vertex, planfiss)
 244   vec1 = geompy.MakeVector(centreFondFiss, vertex)
 245   try:
 246     # si centreFondFiss et vertproj sont proches: exception. Angle = +- 90°
 247     vec2 = geompy.MakeVector(centreFondFiss, vertproj)
 248     angle = geompy.GetAngleRadians(vec1, vec2)
 249   except:
 250     # on utilise la projection du centre sur la peau pour avoir un vecteur non nul
 251     vertproj = geompy.MakeProjection(centreFondFiss, facePeau)
 252     vec2 = geompy.MakeVector(centreFondFiss, vertproj)
 253     angle = geompy.GetAngleRadians(vec1, vec2)
 254   sommetAxe = geompy.MakeTranslationVector(centreFondFiss, tangentFondFiss)
 255   pm = produitMixte(centreFondFiss, vertex, vertproj, sommetAxe)
 256   if pm > 0:
 257     disque = geompy.MakeRotation(disque, tangentFondFiss, angle)
 258   else:
 259     disque = geompy.MakeRotation(disque, tangentFondFiss, -angle)
 260   [vertexReference] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
 261
 262   pipeFondFiss = geompy.MakePipe(disque, wireFondFiss)
 263   pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], list(), list(), geompy.ShapeType["SOLID"], 0, list(), 0)
 264   #pipe = geompy.MakePipe(disque, WirePorteFondFissure)
 265   #pipe = geompy.MakePartition([pipe],[fillingFaceExterne], list(), list(), geompy.ShapeType["SOLID"], 0, list(), 0)
 266   #pipes = geompy.ExtractShapes(pipe, geompy.ShapeType["SOLID"], False)
 267   #pipesSorted, volmin, volmax = sortSolids(pipes)
 268   #pipeFondFiss = pipesSorted[-1]
 269   #pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], list(), list(), geompy.ShapeType["SOLID"], 0, list(), 0)
 270
 271   geomPublish(initLog.debug,  disque, 'disque')
 272   geomPublish(initLog.debug,  wireFondFiss, 'wireFondFiss')
 273   geomPublish(initLog.debug,  pipeFondFiss, 'pipeFondFiss')
 274
 275   VerticesEndFondFiss = findWireEndVertices(wireFondFiss)
 276   for i, v in enumerate(VerticesEndFondFiss):
 277     name = "vertexEndFondFiss_%d"%i
 278     geomPublishInFather(initLog.debug,wireFondFiss, v, name)
 279   VerticesEndPipeFiss = list()
 280   for v in VerticesEndFondFiss:
 281     VerticesEndPipeFiss.append(geompy.GetInPlace(pipeFondFiss, v))
 282   for i, v in enumerate(VerticesEndPipeFiss):
 283     name = "vertexEndPipeFiss_%d"%i
 284     geomPublishInFather(initLog.debug,pipeFondFiss, v, name)
 285
 286   geomPublishInFather(initLog.debug,pipeFondFiss, VerticesEndPipeFiss[0], "PFOR")
 287   geomPublishInFather(initLog.debug,pipeFondFiss, VerticesEndPipeFiss[1], "PFEX")
 288   if geompy.MinDistance(VerticesEndPipeFiss[0], verticesOutCercles[0]) > geompy.MinDistance(VerticesEndPipeFiss[0], verticesOutCercles[1]):
 289     a = verticesOutCercles[0]
 290     verticesOutCercles[0] = verticesOutCercles[1]
 291     verticesOutCercles[1] = a
 292   geomPublishInFather(initLog.debug,facePeau, verticesOutCercles[0], "THOR")
 293   geomPublishInFather(initLog.debug,facePeau, verticesOutCercles[1], "THEX")
 294
 295   [facesPipeInside, facesPipeOutside, facesPipeOnside] = extractionOrientee(fillingFaceExterne, pipeFondFiss, centreFondFiss, "FACE", 0.1, "pipe_bord_")
 296   [edgesPipeInside, edgesPipeOutside, edgesPipeOnside] = extractionOrientee(fillingFaceExterne, pipeFondFiss, centreFondFiss, "EDGE", 0.1, "pipe_bord_")
 297   disqueInt1 = geompy.GetInPlaceByHistory(pipeFondFiss, planBord1)
 298   disqueInt2 = geompy.GetInPlaceByHistory(pipeFondFiss, planBord2)
 299   disques = facesPipeOnside + [disqueInt1, disqueInt2]
 300   edgesDiskInt = geompy.ExtractShapes(disqueInt1, geompy.ShapeType["EDGE"], False)
 301   edgesDiskInt = edgesDiskInt +geompy.ExtractShapes(disqueInt2, geompy.ShapeType["EDGE"], False)
 302   edgesSorted, minlg, maxlg = sortEdges(edgesDiskInt) # 4 rayons, 2 demi cercles
 303
 304   centre = geompy.MakeVertexOnSurface(planfiss, 0.5, 0.5)
 305   refpoint = geompy.MakeTranslationVector(centre, geompy.GetNormal(planfiss,centre))
 306   geomPublish(initLog.debug, refpoint, 'refpoint')
 307   [facesPipeInplan, facesPipeOutplan, facesPipeOnplan] = extractionOrientee(planfiss, pipeFondFiss, refpoint, "FACE", 0.1, "pipe_plan_")
 308   [edgesPipeInplan, edgesPipeOutplan, edgesPipeOnplan] = extractionOrientee(planfiss, pipeFondFiss, refpoint, "EDGE", 0.1, "pipe_plan_")
 309
 310   # --- rayon disques = (edgesPipeOnside inter edgesPipeOnplan) + rayons disque internes
 311   #     demi cercles  = edgesPipeOnside moins edgesPipeOnplan + demi cercles disque internes
 312   #     generatrices  = edgesPipeOnplan moins rayon disques (3 grandes et 6 petites)
 313   edgesIdPipeOnside = getSubshapeIds(pipeFondFiss, edgesPipeOnside)
 314   edgesIdPipeOnplan = getSubshapeIds(pipeFondFiss, edgesPipeOnplan)
 315   rayons = list()
 316   demiCercles = list()
 317   for i, edgeId in enumerate(edgesIdPipeOnside):
 318     if edgeId in edgesIdPipeOnplan:
 319       rayons.append(edgesPipeOnside[i])
 320     else:
 321       demiCercles.append(edgesPipeOnside[i])
 322   demiCerclesExternes = demiCercles
 323   rayons = rayons + edgesSorted[:4]            # les 4 plus petits sont les rayons
 324   demiCercles = demiCercles  + edgesSorted[4:] # les suivants sont les arcs de cercle
 325   rayonsId = getSubshapeIds(pipeFondFiss, rayons)
 326   generatrices = list()
 327   for i, edgeId in enumerate(edgesIdPipeOnplan):
 328     if edgeId not in rayonsId:
 329       generatrices.append(edgesPipeOnplan[i])
 330
 331   # --- generatrices en contact avec la face fissure externe au pipe
 332   generFiss = list()
 333   for edge in generatrices:
 334     distance = geompy.MinDistance(vertexReference, edge)
 335     logging.debug("distance %s", distance)
 336     if distance < 1.e-5:
 337       generFiss.append(edge)
 338       break
 339   for edge in generatrices:
 340     distance = geompy.MinDistance(generFiss[0], edge)
 341     logging.debug("distance %s", distance)
 342     if distance < 1.e-5:
 343       generFiss.append(edge)
 344   groupGenerFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
 345   geompy.UnionList(groupGenerFiss, generFiss)
 346   geomPublishInFather(initLog.debug,pipeFondFiss, groupGenerFiss, "GenFiss")
 347
 348   # --- demi cercles externes regroupés
 349   groupsDemiCerclesPipe = list()
 350   for i, vertex in enumerate(verticesEdgePeauFiss):
 351     demis = list()
 352     for edge in demiCerclesExternes:
 353       if geompy.MinDistance(vertex, edge) < 0.1:
 354         demis.append(edge)
 355     group = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
 356     geompy.UnionList(group, demis)
 357     name = "Cercle%d"%i
 358     geomPublishInFather(initLog.debug,pipeFondFiss, group , name)
 359     groupsDemiCerclesPipe.append(group)
 360
 361   # --- faces fissure dans le pipe
 362
 363   facesFissinPipe = list()
 364   generFissId = getSubshapeIds(pipeFondFiss, generFiss)
 365   logging.debug("generatrice fissure %s", generFissId)
 366   for face in facesPipeOnplan:
 367     edges =geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], False)
 368     edgesId = getSubshapeIds(pipeFondFiss, edges)
 369     logging.debug("  edges %s", edgesId)
 370     for i,edgeId in enumerate(edgesId):
 371       if edgeId in generFissId:
 372         logging.debug("face found")
 373         facesFissinPipe.append(face)
 374         name = "faceFissInPipe_%d"%i
 375         geomPublishInFather(initLog.debug,pipeFondFiss, face, name)
 376         break
 377   groupFaceFissInPipe = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["FACE"])
 378   geompy.UnionList(groupFaceFissInPipe, facesFissinPipe)
 379   name = "FaceFissInPipe"
 380   geomPublishInFather(initLog.debug,pipeFondFiss, groupFaceFissInPipe , name)
 381
 382   # --- edges de fond de fissure
 383
 384   edgesFondFiss = list()
 385   for i, edge in enumerate(edgesInside):
 386     anEdge = geompy.GetInPlace(pipeFondFiss, edge)
 387     logging.debug("  edge %s ", anEdge)
 388     edgesFondFiss.append(anEdge)
 389     name ="edgeFondFissure_%d"%i
 390     geomPublishInFather(initLog.debug,pipeFondFiss, anEdge, name)
 391   groupEdgeFondFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
 392   geompy.UnionList(groupEdgeFondFiss, edgesFondFiss)
 393   name = "FONDFISS"
 394   geomPublishInFather(initLog.debug,pipeFondFiss, groupEdgeFondFiss , name)
 395
 396   # -------------------------------------------------------------------------
 397   # --- maillage
 398
 399   # --- edges de bord face defaut à respecter
 400
 401   aFilterManager = smesh.CreateFilterManager()
 402   nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [  ])
 403   criteres = list()
 404   unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
 405   criteres.append(unCritere)
 406   filtre = smesh.GetFilterFromCriteria(criteres)
 407   bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
 408   smesh.SetName(bordsLibres, 'bordsLibres')
 409
 410   # --- pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
 411   #     on designe les faces de peau en quadrangles par le groupe "skinFaces"
 412
 413   skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
 414   nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
 415
 416   # --- maillage pipe fond fissure
 417
 418   meshFondFiss, groups_demiCercles, group_generFiss, nbSegGenLong, nbSegGenBout = \
 419             insereFissureLongue_a (pipeFondFiss, disques, rayons, demiCercles, demiCerclesPeau, generatrices, \
 420             VerticesEndPipeFiss, verticesEdgePeauFiss, \
 421             groupFaceFissInPipe, groupEdgeFondFiss, groupsDemiCerclesPipe, groupGenerFiss, \
 422             profondeur, rayonPipe, distance2)
 423
 424   # --- maillage face de peau
 425
 426   meshFacePeau, groupEdgesPeauFiss = \
 427             insereFissureLongue_b (facePeau, edgePeauFiss, groupEdgesBordPeau, bordsLibres, \
 428             groupsDemiCerclesPeau, groups_demiCercles, verticesOutCercles, \
 429             nbSegGenLong, nbSegGenBout, profondeur)
 430
 431   # --- maillage face de fissure
 432
 433   meshFaceFiss = \
 434             insereFissureLongue_c (faceFiss, edgePeauFiss, groupEdgesPeauFiss, group_generFiss, groupEdgesFaceFissPipe, \
 435             profondeur, rayonPipe)
 436
 437   # --- maillage meshBoiteDefaut
 438
 439   distene=True
 440   meshBoiteDefaut, group_faceFissInPipe, group_faceFissOutPipe = \
 441             insereFissureLongue_d (internalBoundary, meshFondFiss, meshFacePeau, meshFaceFiss, \
 442             distene)
 443
 444
 445   groups = maillageSain.GetGroups()
 446   grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
 447   grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
 448   coords1 = maillageSain.GetNodeXYZ(grps1[0].GetID(1))
 449   coords2 = maillageSain.GetNodeXYZ(grps2[0].GetID(1))
 450   logging.info("coords1 %s, coords2 %s",coords1, coords2)
 451
 452   faceFissure = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
 453   maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges)
 454   putName(maillageSain, nomFicSain+"_coupe")
 455   extrusionFaceFissure, normfiss = shapeSurFissure(facePorteFissure)
 456   maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut, extrusionFaceFissure, facePorteFissure, 'COUDE')
 457
 458   groups = maillageComplet.GetGroups()
 459   grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
 460   grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
 461   nodeid1 = maillageComplet.AddNode(coords1[0], coords1[1], coords1[2])
 462   nodeid2 = maillageComplet.AddNode(coords2[0], coords2[1], coords2[2])
 463   grps1[0].Add([nodeid1])
 464   grps2[0].Add([nodeid2])
 465   ma0d1 = maillageComplet.Add0DElement(nodeid1)
 466   ma0d2 = maillageComplet.Add0DElement(nodeid2)
 467   grpma0d1 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P1' )
 468   nbAdd = grpma0d1.Add( [ma0d1] )
 469   grpma0d2 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P2' )
 470   nbAdd = grpma0d2.Add( [ma0d2] )
 471
 472 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedEdges']
 473 #  grps[0].SetName('affEdges')
 474 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedFaces']
 475 #  grps[0].SetName('affFaces')
 476 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedVolumes']
 477 #  grps[0].SetName('affVols')
 478
 479   maillageComplet.ConvertToQuadratic( 1 )
 480   grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
 481   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
 482
 483   grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
 484   nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
 485
 486   plansim = geompy.MakePlane(O, normfiss, 10000)
 487   fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
 488   grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
 489   nb = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
 490   #isDone = maillageComplet.ReorientObject( grps[0] )
 491   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
 492
 493   maillageComplet.ExportMED(fichierMaillageFissure)
 494   putName(maillageComplet, nomFicFissure)
 495   logging.info("fichier maillage fissure %s", fichierMaillageFissure)
 496
 497   if salome.sg.hasDesktop():
 498     salome.sg.updateObjBrowser()
 499
 500   return  maillageComplet