]> SALOME platform Git repositories - modules/smesh.git/blob - src/Tools/blocFissure/gmu/insereFissureGenerale.py
Salome HOME
Allow saving groups with non-ascii names.
[modules/smesh.git] / src / Tools / blocFissure / gmu / insereFissureGenerale.py
1 # -*- coding: utf-8 -*-
2
3 import logging
4 import salome
5 from .geomsmesh import geompy
6 from .geomsmesh import geomPublish
7 from .geomsmesh import geomPublishInFather
8 from . import initLog
9 import GEOM
10 from .geomsmesh import smesh
11 from salome.smesh import smeshBuilder
12 import SMESH
13 import math
14 import bisect
15
16 from .extractionOrientee import extractionOrientee
17 from .extractionOrienteeMulti import extractionOrienteeMulti
18 from .sortFaces import sortFaces
19 from .sortEdges import sortEdges
20 from .eliminateDoubles import eliminateDoubles
21 from .substractSubShapes import substractSubShapes
22 from .produitMixte import produitMixte
23 from .findWireEndVertices import findWireEndVertices
24 from .findWireIntermediateVertices import findWireIntermediateVertices
25 from .orderEdgesFromWire import orderEdgesFromWire
26 from .getSubshapeIds import getSubshapeIds
27 from .putName import putName
28 from .distance2 import distance2
29 from .enleveDefaut import enleveDefaut
30 from .shapeSurFissure import shapeSurFissure
31 from .regroupeSainEtDefaut import RegroupeSainEtDefaut
32 from .triedreBase import triedreBase
33 from .checkDecoupePartition import checkDecoupePartition
34 from .whichSide import whichSide
35 from .whichSideMulti import whichSideMulti
36 from .whichSideVertex import whichSideVertex
37 from .projettePointSurCourbe import projettePointSurCourbe
38 from .prolongeWire import prolongeWire
39 #from getCentreFondFiss import getCentreFondFiss
40
41 # -----------------------------------------------------------------------------
42 # --- procédure complète fissure générale
43
44 def insereFissureGenerale(maillagesSains,
45                           shapesFissure, shapeFissureParams,
46                           maillageFissureParams, elementsDefaut, step=-1):
47   """
48   TODO: a completer
49   """
50   logging.info('start')
51   
52   shapeDefaut       = shapesFissure[0] # faces de fissure, débordant
53   fondFiss          = shapesFissure[4] # groupe d'edges de fond de fissure
54
55   rayonPipe = shapeFissureParams['rayonPipe']
56   if 'lenSegPipe' in shapeFissureParams:
57     lenSegPipe = shapeFissureParams['lenSegPipe']
58   else:
59     lenSegPipe = rayonPipe
60
61   nomRep            = maillageFissureParams['nomRep']
62   nomFicSain        = maillageFissureParams['nomFicSain']
63   nomFicFissure     = maillageFissureParams['nomFicFissure']
64
65   nbsegRad          = maillageFissureParams['nbsegRad']      # nombre de couches selon un rayon du pipe
66   nbsegCercle       = maillageFissureParams['nbsegCercle']   # nombre de secteur dans un cercle du pipe
67   areteFaceFissure  = maillageFissureParams['areteFaceFissure']
68
69   pointIn_x = 0.0
70   pointIn_y = 0.0
71   pointIn_z = 0.0
72   isPointInterne = False
73   if 'pointIn_x' in shapeFissureParams:
74     pointIn_x = shapeFissureParams['pointIn_x']
75     isPointInterne = True
76   if 'pointIn_y' in shapeFissureParams:
77     pointIn_y = shapeFissureParams['pointIn_y']
78     isPointInterne = True
79   if 'pointIn_z' in shapeFissureParams:
80     pointIn_z = shapeFissureParams['pointIn_z']
81     isPointInterne = True
82   if isPointInterne:
83     pointInterne = geompy.MakeVertex(pointIn_x, pointIn_y, pointIn_z)
84
85   #fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
86   fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
87
88   # fillings des faces en peau
89   facesDefaut = elementsDefaut[0]
90   #centresDefaut            = elementsDefaut[1]
91   #normalsDefaut            = elementsDefaut[2]
92   #extrusionsDefaut         = elementsDefaut[3]
93   dmoyen                   = elementsDefaut[4]
94   bordsPartages = elementsDefaut[5]
95   fillconts                = elementsDefaut[6]
96   idFilToCont              = elementsDefaut[7]
97   maillageSain             = elementsDefaut[8]
98   internalBoundary         = elementsDefaut[9]
99   zoneDefaut               = elementsDefaut[10]
100   zoneDefaut_skin          = elementsDefaut[11]
101   zoneDefaut_internalFaces = elementsDefaut[12]
102   zoneDefaut_internalEdges = elementsDefaut[13]
103   edgeFondExt              = elementsDefaut[14]
104   centreFondFiss           = elementsDefaut[15]
105   tgtCentre                = elementsDefaut[16]
106
107   # --- restriction de la face de fissure au domaine solide :
108   #     partition face fissure étendue par fillings, on garde la plus grande face
109
110   partShapeDefaut = geompy.MakePartition([shapeDefaut], facesDefaut, [], [], geompy.ShapeType["FACE"], 0, [], 0)
111   geomPublish(initLog.debug, partShapeDefaut, 'partShapeDefaut')
112   facesPartShapeDefaut = geompy.ExtractShapes(partShapeDefaut, geompy.ShapeType["FACE"], False)
113   if isPointInterne:
114     distfaces = [(geompy.MinDistance(face,pointInterne), i, face) for i, face in enumerate(facesPartShapeDefaut)]
115     distfaces.sort()
116     logging.debug("selection de la face la plus proche du point interne, distance=%s",distfaces[0][0])
117     facesPortFissure = distfaces[0][2]
118   else:
119     facesPartShapeDefautSorted, minSurf, maxSurf = sortFaces(facesPartShapeDefaut) # la face de fissure dans le volume doit être la plus grande
120     logging.debug("surfaces faces fissure étendue, min %s, max %s", minSurf, maxSurf)
121     facesPortFissure = facesPartShapeDefautSorted[-1] #= global
122   
123   geomPublish(initLog.debug, facesPortFissure, "facesPortFissure")
124
125   O, OX, OY, OZ = triedreBase()
126   
127   # -----------------------------------------------------------------------------
128   # --- pipe de fond de fissure, prolongé, partition face fissure par pipe
129   #     identification des edges communes pipe et face fissure
130   
131   if geompy.NumberOfFaces(shapeDefaut) == 1:
132     plan = geompy.MakePlane(centreFondFiss, tgtCentre, 10000)
133     shapeDefaut = geompy.MakePartition([shapeDefaut], [plan], [], [], geompy.ShapeType["FACE"], 0, [], 0) #= local
134     #fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss) #= inutile
135     geomPublish(initLog.debug, shapeDefaut, 'shapeDefaut_coupe')
136     #geomPublishInFather(initLog.debug,shapeDefaut, fondFissCoupe, 'fondFiss_coupe')
137   
138   extrem, norms = findWireEndVertices(fondFiss, True)
139   logging.debug("extrem: %s, norm: %s",extrem, norms)
140   cercle = geompy.MakeCircle(extrem[0], norms[0], rayonPipe)
141   cercle = geompy.MakeRotation(cercle, norms[0], math.pi/3.0 ) # éviter d'avoir l'arête de couture du pipe presque confondue avec la face fissure
142   geomPublish(initLog.debug, cercle, 'cercle')
143   fondFissProlonge = prolongeWire(fondFiss, extrem, norms, 2*rayonPipe)
144   pipeFiss = geompy.MakePipe(cercle, fondFissProlonge)
145   geomPublish(initLog.debug, pipeFiss, 'pipeFiss')
146   partFissPipe = geompy.MakePartition([shapeDefaut, pipeFiss], [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
147   geomPublish(initLog.debug, partFissPipe, 'partFissPipe')
148   fissPipe = geompy.GetInPlaceByHistory(partFissPipe, shapeDefaut) #= global
149   geomPublish(initLog.debug, fissPipe, 'fissPipe')
150   partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss) #= local
151   geomPublish(initLog.debug, partPipe, 'partPipe')
152   
153   edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"]) #= global
154   for i, edge in enumerate(edgesPipeFiss):
155     name = "edgePipe%d"%i
156     geomPublishInFather(initLog.debug,fissPipe, edge, name)
157   try:
158     wirePipeFiss = geompy.MakeWire(edgesPipeFiss) #= global
159   except:
160     wirePipeFiss = geompy.MakeCompound(edgesPipeFiss)
161     logging.debug("wirePipeFiss construit sous forme de compound")
162   geomPublish(initLog.debug, wirePipeFiss, "wirePipeFiss")
163   
164   wireFondFiss = geompy.GetInPlace(partFissPipe,fondFiss)
165   edgesFondFiss = geompy.GetSharedShapesMulti([fissPipe, wireFondFiss], geompy.ShapeType["EDGE"])
166   for i, edge in enumerate(edgesFondFiss):
167     name = "edgeFondFiss%d"%i
168     geomPublishInFather(initLog.debug,fissPipe, edge, name)
169   wireFondFiss = geompy.MakeWire(edgesFondFiss) #= global
170   geomPublish(initLog.debug, wireFondFiss,"wireFondFiss")  
171
172   # -----------------------------------------------------------------------------
173   # --- peau et face de fissure
174   #
175   # --- partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée
176   #     il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure
177   #     liste de faces externes : facesDefaut
178   #     liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
179
180   partitionsPeauFissFond = [] #= global
181   ipart = 0
182   for filling in facesDefaut: 
183     part = geompy.MakePartition([fissPipe, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
184     isPart = checkDecoupePartition([fissPipe, filling], part)
185     if isPart: # on recrée la partition avec toutes les faces filling en outil pour avoir une face de fissure correcte
186       otherFD = [fd for fd in facesDefaut if fd != filling]
187       if len(otherFD) > 0:
188         fissPipePart = geompy.MakePartition([fissPipe], otherFD, [], [], geompy.ShapeType["FACE"], 0, [], 0)
189       else:
190         fissPipePart = fissPipe
191       part = geompy.MakePartition([fissPipePart, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
192       partitionsPeauFissFond.append(part)
193       geomPublish(initLog.debug,  part, 'partitionPeauFissFond%d'%ipart )
194     else:
195       partitionsPeauFissFond.append(None)
196     ipart = ipart +1
197  
198   
199   # --- arêtes vives détectées (dans quadranglesToShapeNoCorner
200   #                             et quadranglesToShapeWithCorner)
201   
202   aretesVives = []
203   aretesVivesCoupees = []  #= global
204   ia = 0
205   for a in bordsPartages:
206     if not isinstance(a, list):
207         aretesVives.append(a)
208         name = "areteVive%d"%ia
209         geomPublish(initLog.debug, a, name)
210         ia += 1
211     else:
212         if a[0] is not None:
213             aretesVives.append(a[0])
214             name = "areteVive%d"%ia
215             geomPublish(initLog.debug, a[0], name)
216             ia += 1
217
218   aretesVivesC = None #= global
219   if len(aretesVives) > 0:
220     aretesVivesC =geompy.MakeCompound(aretesVives)
221     
222   # -------------------------------------------------------
223   # --- inventaire des faces de peau coupées par la fissure
224   #     pour chaque face de peau : 0, 1 ou 2 faces débouchante du fond de fissure
225   #                                0, 1 ou plus edges de la face de fissure externe au pipe
226   
227   nbFacesFilling = len(partitionsPeauFissFond)
228   ptEdgeFond = [ []  for i in range(nbFacesFilling)] # pour chaque face [points edge fond de fissure aux débouchés du pipe]
229   fsPipePeau = [ []  for i in range(nbFacesFilling)] # pour chaque face [faces du pipe débouchantes]
230   edRadFPiPo = [ []  for i in range(nbFacesFilling)] # pour chaque face [edge radiale des faces du pipe débouchantes ]
231   fsFissuExt = [ []  for i in range(nbFacesFilling)] # pour chaque face [faces de fissure externes au pipe]
232   edFisExtPe = [ []  for i in range(nbFacesFilling)] # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
233   edFisExtPi = [ []  for i in range(nbFacesFilling)] # pour chaque face [edge commun au pipe des faces de fissure externes]
234   facesPeaux = [None for i in range(nbFacesFilling)] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
235   edCircPeau = [ []  for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
236   ptCircPeau = [ []  for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
237   gpedgeBord = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
238   gpedgeVifs = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupes subshape des edges aux arêtes vives entre fillings
239   edFissPeau = [ []  for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
240   ptFisExtPi = [ []  for i in range(nbFacesFilling)] # pour chaque face de peau : [point commun edFissPeau edCircPeau]
241   
242   for ifil, partitionPeauFissFond in enumerate(partitionsPeauFissFond):
243     if partitionPeauFissFond is not None:
244       fillingFaceExterne = facesDefaut[ifil]
245       #fillingSansDecoupe = fillconts[idFilToCont[ifil]]
246       logging.debug("traitement partitionPeauFissFond %s", ifil)
247       # -----------------------------------------------------------------------
248       # --- identification edges fond de fissure, edges pipe sur la face de fissure,
249       #     edges prolongées
250       
251       edgesPipeC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesPipeFiss)) #= local
252       geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesPipeC, "edgesPipeFiss")
253       edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss)) #= local
254       geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesFondC, "edgesFondFiss")
255       
256       if aretesVivesC is None: #= global facesInside facesOnside
257         [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
258         [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
259       else:
260         [edgesInside, edgesOutside, edgesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
261         [facesInside, facesOutside, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
262         
263       edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"]) #= global
264       verticesPipePeau = [] #= global
265
266       for i, edge in enumerate(edgesPipeIn):
267         try:
268           vertices = geompy.GetSharedShapesMulti([edge, geompy.MakeCompound(facesOnside)], geompy.ShapeType["VERTEX"])
269           verticesPipePeau.append(vertices[0])
270           name = "edgePipeIn%d"%i
271           geomPublishInFather(initLog.debug,partitionPeauFissFond, edge, name)
272           name = "verticePipePeau%d"%i
273           geomPublishInFather(initLog.debug,partitionPeauFissFond, vertices[0], name)
274           logging.debug("edgePipeIn%s coupe les faces OnSide", i)
275         except:
276           logging.debug("edgePipeIn%s ne coupe pas les faces OnSide", i)
277       #edgesFondOut = []     #= inutile
278       edgesFondIn =[] #= global
279       if len(verticesPipePeau) > 0: # au moins une extrémité du pipe sur cette face de peau  
280         #tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesOutside)], geompy.ShapeType["EDGE"])
281         #edgesFondOut = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3] 
282         tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
283         edgesFondIn = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
284
285       verticesEdgesFondIn = [] # les points du fond de fissure au débouché du pipe sur la peau (indice de edgesFondIn)
286       pipexts = []             # les segments de pipe associés au points de fond de fissure débouchants (même indice)
287       cercles = []             # les cercles de generation des pipes débouchant (même indice)
288       facesFissExt = []        # les faces de la fissure externe associés au points de fond de fissure débouchants (même indice)
289       edgesFissExtPeau = []    # edges des faces de fissure externe sur la peau (même indice)
290       edgesFissExtPipe = []    # edges des faces de fissure externe sur le pipe (même indice)
291       #logging.debug("edgesFondIn %s", edgesFondIn)
292
293       edgesFondFiss, edgesIdByOrientation = orderEdgesFromWire(wireFondFiss)
294       for i,edge in enumerate(edgesFondFiss):
295         geomPublishInFather(initLog.debug,wireFondFiss, edge, "edgeFondFiss%d"%i)
296
297       for iedf, edge in enumerate(edgesFondIn):
298         name = "edgeFondIn%d"%iedf
299         geomPublishInFather(initLog.debug,partitionPeauFissFond, edge, name)
300         dist = [ geompy.MinDistance(pt, edge) for pt in verticesPipePeau]
301         ptPeau = verticesPipePeau[dist.index(min(dist))] # le point de verticesPipePeau a distance minimale de l'edge
302         [u, PointOnEdge, EdgeInWireIndex]  = geompy.MakeProjectionOnWire(ptPeau, wireFondFiss)
303         logging.debug("u:%s, EdgeInWireIndex: %s, len(edgesFondFiss): %s", u, EdgeInWireIndex, len(edgesFondFiss))
304         localEdgeInFondFiss = edgesFondFiss[EdgeInWireIndex]
305         centre = PointOnEdge
306         centre2 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, u)
307         geomPublishInFather(initLog.debug,partitionPeauFissFond, centre2, "centre2_%d"%iedf)
308         verticesEdgesFondIn.append(centre)
309         name = "verticeEdgesFondIn%d"%iedf
310         geomPublishInFather(initLog.debug,partitionPeauFissFond, centre, name)
311         norm = geompy.MakeTangentOnCurve(localEdgeInFondFiss, u)
312         geomPublishInFather(initLog.debug,partitionPeauFissFond, centre, "norm%d"%iedf)
313         cercle = geompy.MakeCircle(centre, norm, rayonPipe)
314         geomPublishInFather(initLog.debug,partitionPeauFissFond, cercle, "cerclorig%d"%iedf)
315         [vertex] = geompy.ExtractShapes(cercle, geompy.ShapeType["VERTEX"], False)
316         vec1 = geompy.MakeVector(centre, vertex)
317         vec2 = geompy.MakeVector(centre, ptPeau)
318         angle = geompy.GetAngleRadians(vec1, vec2)
319         # cas général : on reconstitue une portion de pipe, avec l'arête de couture qui coincide
320         #   avec la face de fissure, au niveau du débouché sur la face externe
321         # cas dégénéré : le pipe débouche perpendiculairement à une surface plane à l'origine.
322         #   La partition filling / pipe reconstruit échoue.
323         #   - Si on partitionne le filling avec un simple pipe obtenu par extrusion droite du cercle,
324         #     cela donne un point en trop sur le cercle.
325         #   - Si on prend une vraie surface plane (pas un filling), on peut faire la partition avec 
326         #     les pipes reconstruits              
327         logging.debug("angle=%s", angle)
328         #if abs(angle) > 1.e-7:
329         sommetAxe = geompy.MakeTranslationVector(centre, norm)
330         pm = produitMixte(centre, vertex, ptPeau, sommetAxe)
331         if pm > 0:  # ajout de pi a (-)angle pour éviter des points confondus (partition échoue) dans les cas dégénérés
332           cercle = geompy.MakeRotation(cercle, norm, angle + math.pi)
333         else:
334           cercle = geompy.MakeRotation(cercle, norm, -angle + math.pi)
335         name = "cercle%d"%iedf
336         geomPublishInFather(initLog.debug,partitionPeauFissFond, cercle, name)
337         cercles.append(cercle)
338
339         # --- estimation de la longueur du pipe necessaire de part et d'autre du point de sortie
340         if aretesVivesC is None:
341           faceTestPeau = fillingFaceExterne
342         else:
343           faceTestPeau = facesDefaut[ifil]
344         sideCentre = whichSide(faceTestPeau, centre)
345         locPt0 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 0.0)
346         locPt1 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 1.0)
347         sidePt0 = whichSide(faceTestPeau, locPt0)
348         sidePt1 = whichSide(faceTestPeau, locPt1)
349         logging.debug("position centre cercle: %s, extremité edge u0: %s, u1: %s", sideCentre, sidePt0, sidePt1) 
350         normFace = geompy.GetNormal(faceTestPeau, ptPeau)
351         inclPipe = abs(geompy.GetAngleRadians(norm, normFace))
352         lgp = max(rayonPipe/2., abs(3*rayonPipe*math.tan(inclPipe)))
353         logging.debug("angle inclinaison Pipe en sortie: %s degres, lgp: %s", inclPipe*180/math.pi, lgp)
354         
355         # --- position des points extremite du pipe sur l'edge debouchante
356         #     il faut la distance curviligne ofp du point central par rapport à une extrémité de l'edge débouchante
357         locEdgePart = geompy.MakePartition([localEdgeInFondFiss],[centre], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
358         edgesLoc = geompy.ExtractShapes(locEdgePart, geompy.ShapeType["EDGE"], False)
359         edgesLocSorted =[(geompy.MinDistance(edge, locPt0), kk, edge) for kk, edge in enumerate(edgesLoc)]
360         edgesLocSorted.sort()
361         ofp = geompy.BasicProperties(edgesLocSorted[0][2])[0] # distance curviligne centre locPt0
362         logging.debug("distance curviligne centre extremite0: %s", ofp)
363         p1 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp +lgp, locPt0)
364         p2 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp -lgp, locPt0)
365         geomPublishInFather(initLog.debug,wireFondFiss, p1, "p1_%d"%iedf)
366         geomPublishInFather(initLog.debug,wireFondFiss, p2, "p2_%d"%iedf)
367
368         edgePart = geompy.MakePartition([localEdgeInFondFiss], [p1,p2], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
369         edps = geompy.ExtractShapes(edgePart, geompy.ShapeType["EDGE"], True)
370         for edp in edps:
371           if geompy.MinDistance(centre, edp) < 1.e-3:
372             pipext = geompy.MakePipe(cercle, edp)
373             name = "pipeExt%d"%iedf
374             geomPublishInFather(initLog.debug,partitionPeauFissFond, pipext, name)
375             pipexts.append(pipext)
376
377         for face in facesInside:
378           logging.debug("recherche edges communes entre une face inside et (faces onside, edges pipe et fond débouchante)")
379           edgesPeauFis = []
380           edgesPipeFis = []
381           edgesPipeFnd = []
382           try:
383             edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
384             logging.debug("    faces onside %s",edgesPeauFis)
385             edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
386             logging.debug("    edgesPipeIn %s", edgesPipeFis)
387             edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
388             logging.debug("    edgesFondIn %s ", edgesPipeFnd)
389           except:
390             logging.debug("  pb edges communes %s %s %s",edgesPeauFis, edgesPipeFis, edgesPipeFnd)
391             pass
392           if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
393             dist = geompy.MinDistance(geompy.MakeCompound(edgesPeauFis), ptPeau)
394             logging.debug("    test distance extrémité reference %s", dist)
395             if dist < 1.e-3: # c'est la face de fissure externe associée
396               logging.debug("    face %s inside ajoutée", i)
397               facesFissExt.append(face)
398               name="faceFissExt%d"%iedf
399               geomPublishInFather(initLog.debug,partitionPeauFissFond, face, name)
400               dist = 1.
401               for ipe, edpe in enumerate(edgesPeauFis):
402                 for ipi, edpi in enumerate(edgesPipeFis):
403                   dist = geompy.MinDistance(edpe, edpi)
404                   if dist < 1.e-3:
405                     edgesFissExtPeau.append(edpe)
406                     name="edgesFissExtPeau%d"%iedf
407                     geomPublishInFather(initLog.debug,partitionPeauFissFond, edpe, name)
408                     edgesFissExtPipe.append(edpi)
409                     name="edgesFissExtPipe%d"%iedf
410                     geomPublishInFather(initLog.debug,partitionPeauFissFond, edpi, name)
411                     break
412                 if dist < 1.e-3:
413                   break
414
415       if len(verticesPipePeau) == 0: # aucune extrémité du pipe sur cette face de peau
416                                      # il faut recenser les edges de fissure sur la face de peau
417         j = 0
418         for face in facesInside:
419           edgesPeauFis = []
420           edgesPipeFis = []
421           edgesPipeFnd = []
422           try:
423             edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
424             edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
425             edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
426           except:
427             pass
428           if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
429             edgesFissExtPeau.append(edgesPeauFis[0])
430             name="edgesFissExtPeau%d"%j
431             geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesPeauFis[0], name)
432             j += 1
433      
434       # -----------------------------------------------------------------------
435       # --- identification faces de peau : face de peau percée du pipe, extrémités du pipe
436       #     La partition avec le pipe peut créer un vertex (et un edge) de trop sur le cercle projeté,
437       #     quand le cercle est très proche de la face.
438       #     dans ce cas, la projection du cercle sur la face suivie d'une partition permet
439       #     d'éviter le point en trop
440       
441       facesAndFond = facesOnside
442       facesAndFond.append(wireFondFiss)
443       try:
444         partitionPeauByPipe = geompy.MakePartition(facesAndFond, pipexts, [], [], geompy.ShapeType["FACE"], 0, [], 1)
445       except:
446         logging.debug("probleme partition face pipe, contournement avec MakeSection")
447         sections = []
448         for pipext in pipexts:
449           sections.append(geompy.MakeSection(facesOnside[0], pipext))
450         partitionPeauByPipe = geompy.MakePartition(facesAndFond, sections, [], [], geompy.ShapeType["FACE"], 0, [], 1)
451         
452       # contrôle edge en trop sur edges circulaires
453       if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
454         edgeEnTrop = []
455         outilPart = pipexts
456         facesPeau = geompy.ExtractShapes(partitionPeauByPipe, geompy.ShapeType["FACE"], False)
457         facesPeauSorted, minsur, maxsurf = sortFaces(facesPeau)
458         for i, face in enumerate(facesPeauSorted[:-1]): # on ne teste que la ou les petites faces "circulaires"
459           nbv = geompy.NumberOfEdges(face)
460           logging.debug("nombre d'edges sur face circulaire: %s", nbv)
461           if nbv > 3:
462             edgeEnTrop.append(True) # TODO : distinguer les cas avec deux faces circulaires dont l'une est correcte
463           else:
464             edgeEnTrop.append(False)
465         refaire = sum(edgeEnTrop)
466         if refaire > 0:
467           dc = [(geompy.MinDistance(verticesEdgesFondIn[0], fac), i)  for i, fac in enumerate(facesPeauSorted[:-1])]
468           dc.sort()
469           logging.debug("dc sorted: %s", dc)
470           i0 = dc[0][1] # indice de facesPeauSorted qui correspond à verticesEdgesFondIn[0], donc 0 pour cercles
471           direct = (i0 == 0)
472           for i, bad in enumerate(edgeEnTrop):
473             if direct:
474               j = i
475             else:
476               j = 1-i
477             if bad:
478               outilPart[j] = geompy.MakeProjection(cercles[j],facesOnside[0])
479             pass
480           partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, [], [], geompy.ShapeType["FACE"], 0, [], 1)
481           pass
482           
483       name="partitionPeauByPipe%d"%ifil
484       geomPublish(initLog.debug, partitionPeauByPipe, name)
485       [edgesPeauFondIn, edgesPeauFondOut, edgesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "EDGE", 1.e-3)
486       [facesPeauFondIn, facesPeauFondOut, facesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "FACE", 1.e-3)
487         
488       if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
489         facesPeauSorted, minsur, maxsurf = sortFaces(facesPeauFondOn)
490         facePeau = facesPeauSorted[-1] # la plus grande face
491       else:
492         facePeau =geompy.MakePartition(facesPeauFondOn, [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
493       name="facePeau%d"%ifil
494       geomPublish(initLog.debug, facePeau, name)
495       
496       facesPipePeau = [None for i in range(len(edgesFissExtPipe))]
497       endsEdgeFond = [None for i in range(len(edgesFissExtPipe))]
498       edgeRadFacePipePeau = [None for i in range(len(edgesFissExtPipe))]
499       
500       edgesListees = []
501       edgesCircPeau = []
502       verticesCircPeau = []
503       if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
504         
505         for face in facesPeauSorted[:-1]: # la ou les faces débouchantes, pas la grande face de peau
506           logging.debug("examen face debouchante circulaire")
507           for i,efep in enumerate(edgesFissExtPipe):
508             dist = geompy.MinDistance(face, efep)
509             logging.debug("  distance face circulaire edge %s", dist)
510             if dist < 1e-3:
511               for ik, edpfi in enumerate(edgesPeauFondIn):
512                 if geompy.MinDistance(face, edpfi) < 1e-3:
513                   break
514               sharedVertices = geompy.GetSharedShapesMulti([face, edgesPeauFondIn[ik]], geompy.ShapeType["VERTEX"])
515               nameFace = "facePipePeau%d"%i
516               nameVert = "endEdgeFond%d"%i
517               nameEdge = "edgeRadFacePipePeau%d"%i
518               facesPipePeau[i] = face
519               endsEdgeFond[i] = sharedVertices[0]
520               geomPublish(initLog.debug, face, nameFace)
521               geomPublish(initLog.debug, sharedVertices[0], nameVert)
522               edgesFace = geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], True)
523               for edge in edgesFace:
524                 if geompy.MinDistance(edge, sharedVertices[0]) < 1e-3:
525                   edgeRadFacePipePeau[i] = edge
526                   geomPublish(initLog.debug, edge, nameEdge)
527                   break
528                 pass
529               pass
530             pass
531           pass
532         
533         # --- edges circulaires de la face de peau et points de jonction de la face externe de fissure
534         logging.debug("facesPipePeau: %s", facesPipePeau)
535         edgesCircPeau = [None for i in range(len(facesPipePeau))]
536         verticesCircPeau = [None for i in range(len(facesPipePeau))]        
537         for i,fcirc in enumerate(facesPipePeau):
538           edges = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["EDGE"])
539           grpEdgesCirc = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
540           geompy.UnionList(grpEdgesCirc, edges)
541           edgesCircPeau[i] = grpEdgesCirc
542           name = "edgeCirc%d"%i
543           geomPublishInFather(initLog.debug,facePeau, grpEdgesCirc, name)
544           edgesListees = edgesListees + edges
545           vertices = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["VERTEX"])
546           grpVertCircPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["VERTEX"])
547           geompy.UnionList(grpVertCircPeau, vertices)
548           verticesCircPeau[i] = grpVertCircPeau
549           name = "pointEdgeCirc%d"%i
550           geomPublishInFather(initLog.debug,facePeau, grpVertCircPeau, name)
551           pass
552         pass # --- au moins une extrémité du pipe sur cette face de peau
553
554       # --- edges de bord de la face de peau
555
556       edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
557       edgesBords = []
558       for i, edge in enumerate(edgesFilling):
559         edgepeau = geompy.GetInPlace(facePeau, edge)
560         name = "edgepeau%d"%i
561         geomPublishInFather(initLog.debug,facePeau,edgepeau, name)
562         logging.debug("edgepeau %s", geompy.ShapeInfo(edgepeau))
563         if geompy.ShapeInfo(edgepeau)['EDGE'] > 1:
564           logging.debug("  EDGES multiples")
565           edgs = geompy.ExtractShapes(edgepeau, geompy.ShapeType["EDGE"], False)
566           edgesBords += edgs
567           edgesListees += edgs
568         else:
569           logging.debug("  EDGE")
570           edgesBords.append(edgepeau)
571           edgesListees.append(edgepeau)
572       groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
573       geompy.UnionList(groupEdgesBordPeau, edgesBords)
574       bordsVifs = None
575       if aretesVivesC is not None:
576         bordsVifs = geompy.GetInPlace(facePeau, aretesVivesC)
577       if bordsVifs is not None:
578         geomPublishInFather(initLog.debug,facePeau, bordsVifs, "bordsVifs")
579         groupEdgesBordPeau = geompy.CutGroups(groupEdgesBordPeau, bordsVifs)
580         grptmp = None
581         if len(aretesVivesCoupees) > 0:
582           grpC = geompy.MakeCompound(aretesVivesCoupees)
583           grptmp = geompy.GetInPlace(facePeau, grpC)
584         if grptmp is not None:
585           grpnew = geompy.CutGroups(bordsVifs, grptmp) # ce qui est nouveau dans bordsVifs
586         else:
587           grpnew = bordsVifs
588         if grpnew is not None:
589           edv = geompy.ExtractShapes(grpnew, geompy.ShapeType["EDGE"], False)
590           aretesVivesCoupees += edv
591       logging.debug("aretesVivesCoupees %s",aretesVivesCoupees)
592       geomPublishInFather(initLog.debug,facePeau, groupEdgesBordPeau , "EdgesBords")
593         
594       # ---  edges de la face de peau partagées avec la face de fissure
595       
596       edgesPeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
597       edges = substractSubShapes(facePeau, edgesPeau, edgesListees)
598       edgesFissurePeau = []
599       if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
600         edgesFissurePeau = [None for i in range(len(verticesCircPeau))] # edges associés aux extrémités du pipe, en premier
601         for edge in edges:
602           for i, grpVert in enumerate(verticesCircPeau):
603             if (geompy.MinDistance(grpVert, edge) < 1.e-3) and (edge not in edgesFissurePeau):
604               edgesFissurePeau[i] = edge
605               name = "edgeFissurePeau%d"%i
606               geomPublishInFather(initLog.debug,facePeau,  edge, name)
607         for edge in edges: # on ajoute après les edges manquantes
608           if edge not in edgesFissurePeau:
609             edgesFissurePeau.append(edge)
610       else:
611         for i, edge in enumerate(edges):
612           edgesFissurePeau.append(edge)
613           name = "edgeFissurePeau%d"%i
614           geomPublishInFather(initLog.debug,facePeau,  edge, name)
615         
616
617       ptEdgeFond[ifil] = endsEdgeFond        # pour chaque face [points edge fond de fissure aux débouchés du pipe]
618       fsPipePeau[ifil] = facesPipePeau       # pour chaque face [faces du pipe débouchantes]
619       edRadFPiPo[ifil] = edgeRadFacePipePeau # pour chaque face [edge radiale des faces du pipe débouchantes ]
620       fsFissuExt[ifil] = facesFissExt        # pour chaque face [faces de fissure externes au pipe]
621       edFisExtPe[ifil] = edgesFissExtPeau    # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
622       edFisExtPi[ifil] = edgesFissExtPipe    # pour chaque face [edge commun au pipe des faces de fissure externes]
623       facesPeaux[ifil] = facePeau            # pour chaque face : la face de peau finale a mailler (percee des faces débouchantes)
624       edCircPeau[ifil] = edgesCircPeau       # pour chaque face de peau : [groupe subshapes edges circulaires aux débouchés du pipe]
625       ptCircPeau[ifil] = verticesCircPeau    # pour chaque face de peau : [groupe subshapes points sur edges circulaires aux débouchés du pipe]
626       gpedgeBord[ifil] = groupEdgesBordPeau  # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
627       gpedgeVifs[ifil] = bordsVifs           # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
628       edFissPeau[ifil] = edgesFissurePeau    # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
629       ptFisExtPi[ifil] = verticesPipePeau    # pour chaque face de peau : [point commun edFissPeau edCircPeau]
630
631   # -----------------------------------------------------------------------
632   # fin de la boucle sur les faces de filling
633   # -----------------------------------------------------------------------
634   
635   for i, avc in enumerate(aretesVivesCoupees):
636     name = "areteViveCoupee%d"%i
637     geomPublish(initLog.debug, avc, name)
638   
639   # --- identification des faces et edges de fissure externe pour maillage
640   
641   facesFissExt = []
642   edgesFissExtPeau = []
643   edgesFissExtPipe = []
644   for ifil in range(nbFacesFilling): # TODO: éliminer les doublons (comparer tous les vertices triés, avec mesure de distance ?)
645     facesFissExt += fsFissuExt[ifil]
646     edgesFissExtPeau += edFisExtPe[ifil]
647     edgesFissExtPipe += edFisExtPi[ifil]
648   logging.debug("---------------------------- identification faces de fissure externes au pipe :%s ", len(facesFissExt))
649   # regroupement des faces de fissure externes au pipe.
650   
651   if len(facesFissExt) > 1:
652     faceFissureExterne = geompy.MakePartition(facesFissExt, [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
653     edgesPipeFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesPipeFiss))    # edgesFissExtPipe peut ne pas couvrir toute la longueur
654     # edgesPeauFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesFissExtPeau))
655     # il peut manquer des edges de faceFissureExterne en contact avec la peau dans edgesFissExtPeau
656     (isDone, closedFreeBoundaries, openFreeBoundaries) = geompy.GetFreeBoundary(faceFissureExterne)
657     edgesBordFFE = []
658     for bound in closedFreeBoundaries:
659       edgesBordFFE += geompy.ExtractShapes(bound, geompy.ShapeType["EDGE"], False)
660     edgesBordFFEid = [ (ed,geompy.GetSubShapeID(faceFissureExterne, ed)) for ed in edgesBordFFE]
661     logging.debug("edgesBordFFEid %s", edgesBordFFEid)
662     edgesPPE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
663     edgesPPEid = [ geompy.GetSubShapeID(faceFissureExterne, ed) for ed in edgesPPE]
664     logging.debug("edgesPPEid %s", edgesPPEid)
665     edgesPFE = [ edid[0] for edid in edgesBordFFEid if edid[1] not in edgesPPEid] # on garde toutes les edges de bord non en contact avec le pipe
666     logging.debug("edgesPFE %s", edgesPFE)
667     edgesPeauFissureExterneC = geompy.MakeCompound(edgesPFE)
668   else:
669     faceFissureExterne = facesFissExt[0]
670     edgesPeauFissureExterneC = geompy.MakeCompound(edgesFissExtPeau)
671     edgesPipeFissureExterneC = geompy.MakeCompound(edgesFissExtPipe)
672   wirePipeFissureExterne = geompy.MakeWire(geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False))
673   geomPublish(initLog.debug, faceFissureExterne, "faceFissureExterne")
674   geomPublishInFather(initLog.debug,faceFissureExterne, edgesPeauFissureExterneC, "edgesPeauFissureExterne")
675   geomPublishInFather(initLog.debug,faceFissureExterne, edgesPipeFissureExterneC, "edgesPipeFissureExterne")
676   
677   logging.debug("---------------------------- Preparation Maillage du Pipe --------------")
678   # -----------------------------------------------------------------------
679   # --- preparation maillage du pipe :
680   #     - détections des points a respecter : jonction des edges/faces constituant
681   #       la face de fissure externe au pipe
682   #     - points sur les edges de fond de fissure et edges pipe/face fissure,
683   #     - vecteurs tangents au fond de fissure (normal au disque maillé)
684
685   # --- option de maillage selon le rayon de courbure du fond de fissure 
686   lenEdgeFondExt = 0
687   for edff in edgesFondFiss:
688     lenEdgeFondExt += geompy.BasicProperties(edff)[0]
689   
690   disfond = []
691   for filling in facesDefaut:
692     disfond.append(geompy.MinDistance(centreFondFiss, filling))
693   disfond.sort()
694   rcourb = disfond[0]
695   nbSegQuart = 5 # on veut 5 segments min sur un quart de cercle
696   alpha = math.pi/(4*nbSegQuart)
697   deflexion = rcourb*(1.0 -math.cos(alpha))
698   lgmin = lenSegPipe*0.25
699   lgmax = lenSegPipe*1.5               
700   logging.debug("rcourb: %s, lenFond:%s, deflexion: %s, lgmin: %s, lgmax: %s", rcourb, lenEdgeFondExt, deflexion, lgmin, lgmax)  
701
702   meshFondExt = smesh.Mesh(wireFondFiss)
703   algo1d = meshFondExt.Segment()
704   hypo1d = algo1d.Adaptive(lgmin, lgmax, deflexion) # a ajuster selon la profondeur de la fissure
705   isDone = meshFondExt.Compute()
706   
707   ptGSdic = {} # dictionnaire [paramètre sur la courbe] --> point géométrique
708   allNodeIds = meshFondExt.GetNodesId()
709   for nodeId in allNodeIds:
710     xyz = meshFondExt.GetNodeXYZ(nodeId)
711     #logging.debug("nodeId %s, coords %s", nodeId, str(xyz))
712     pt = geompy.MakeVertex(xyz[0], xyz[1], xyz[2])
713     u, PointOnEdge, EdgeInWireIndex = geompy.MakeProjectionOnWire(pt, wireFondFiss) # u compris entre 0 et 1
714     edgeOrder = edgesIdByOrientation[EdgeInWireIndex]
715     ptGSdic[(edgeOrder, EdgeInWireIndex, u)] = pt
716     #logging.debug("nodeId %s, u %s", nodeId, str(u))
717   usort = sorted(ptGSdic)  
718   logging.debug("nombre de points obtenus par deflexion %s",len(usort))
719      
720   centres = []
721   origins = []
722   normals = []      
723   for edu in usort:
724     ied = edu[1]
725     u = edu[2]
726     vertcx = ptGSdic[edu]
727     norm = geompy.MakeTangentOnCurve(edgesFondFiss[ied], u)
728     plan = geompy.MakePlane(vertcx, norm, 3*rayonPipe)
729     part = geompy.MakePartition([plan], [wirePipeFiss], [], [], geompy.ShapeType["VERTEX"], 0, [], 0)
730     liste = geompy.ExtractShapes(part, geompy.ShapeType["VERTEX"], True)
731     if len(liste) == 5: # 4 coins du plan plus intersection recherchée
732       for point in liste:
733         if geompy.MinDistance(point, vertcx) < 1.1*rayonPipe: # les quatre coins sont plus loin
734           vertpx = point
735           break
736       centres.append(vertcx)
737       origins.append(vertpx)
738       normals.append(norm)
739 #      name = "vertcx%d"%i
740 #      geomPublishInFather(initLog.debug,wireFondFiss, vertcx, name)
741 #      name = "vertpx%d"%i
742 #      geomPublishInFather(initLog.debug,wireFondFiss, vertpx, name)
743 #      name = "plan%d"%i
744 #      geomPublishInFather(initLog.debug,wireFondFiss, plan, name)
745
746   # --- maillage du pipe étendu, sans tenir compte de l'intersection avec la face de peau
747       
748   logging.debug("nbsegCercle %s", nbsegCercle)
749   
750   # -----------------------------------------------------------------------
751   # --- points géométriques
752   
753   gptsdisks = [] # vertices géométrie de tous les disques
754   raydisks = [[] for i in range(nbsegCercle)]
755   for i in range(len(centres)): # boucle sur les disques
756     gptdsk = [] # vertices géométrie d'un disque
757     vertcx = centres[i]
758     vertpx = origins[i]
759     normal = normals[i]
760     vec1 = geompy.MakeVector(vertcx, vertpx)
761     
762     points = [vertcx] # les points du rayon de référence
763     for j in range(nbsegRad):
764       pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, (j+1)*float(rayonPipe)/nbsegRad)
765       points.append(pt)
766     gptdsk.append(points)
767     pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, 1.5*rayonPipe)
768     rayon = geompy.MakeLineTwoPnt(vertcx, pt)
769     raydisks[0].append(rayon)
770     
771     for k in range(nbsegCercle-1):
772       angle = (k+1)*2*math.pi/nbsegCercle
773       pts = [vertcx] # les points d'un rayon obtenu par rotation
774       for j in range(nbsegRad):
775         pt = geompy.MakeRotation(points[j+1], normal, angle)
776         pts.append(pt)
777       gptdsk.append(pts)
778       ray = geompy.MakeRotation(rayon, normal, angle)
779       raydisks[k+1].append(ray)
780       
781     gptsdisks.append(gptdsk) 
782  
783   # -----------------------------------------------------------------------
784   # --- recherche des points en trop (externes au volume à remailler)
785   #     - on associe chaque extrémité du pipe à une face filling 
786   #     - on part des disques aux extrémités du pipe
787   #     - pour chaque disque, on prend les vertices de géométrie,
788   #       on marque leur position relative à la face.
789   #     - on s'arrete quand tous les noeuds sont dedans
790   
791   logging.debug("---------------------------- recherche des points du pipe a éliminer --------------")
792
793   pt0 = centres[0]
794   pt1 = centres[-1]
795   idFillingFromBout = [None, None]                 # contiendra l'index du filling pour les extrémités 0 et 1
796   for ifil in range(nbFacesFilling):
797     for ipt, pt in enumerate(ptEdgeFond[ifil]): # il y a un ou deux points débouchant sur cette face
798       if geompy.MinDistance(pt,pt0) < geompy.MinDistance(pt,pt1): # TODO: trouver plus fiable pour les cas tordus...
799         idFillingFromBout[0] = ifil
800       else: 
801         idFillingFromBout[1] = ifil
802   logging.debug("association bouts du pipe - faces de filling: %s", idFillingFromBout)
803   
804   facesPipePeau = []
805   edgeRadFacePipePeau = []
806   for ifil in range(nbFacesFilling):
807     facesPipePeau += fsPipePeau[ifil]
808     edgeRadFacePipePeau += edRadFPiPo[ifil]
809     
810   logging.debug("recherche des disques de noeuds complètement internes")
811   idisklim = [] # indices des premier et dernier disques internes
812   idiskout = [] # indices des premier et dernier disques externes
813   for bout in range(2):
814     if bout == 0:
815       idisk = -1
816       inc = 1
817       numout = -1
818     else:
819       idisk = len(gptsdisks)
820       inc = -1
821       numout = len(gptsdisks)
822     inside = False
823     outside = True
824     while not inside:
825       idisk = idisk + inc
826       logging.debug("examen disque %s", idisk)
827       gptdsk = gptsdisks[idisk]
828       inside = True
829       for k in range(nbsegCercle):
830         points = gptdsk[k]
831         for j, pt in enumerate(points):
832           side = whichSideVertex(facesDefaut[idFillingFromBout[bout]], pt)
833           if side < 0:
834             if outside: # premier point detecté dedans
835               outside = False
836               numout = idisk -inc # le disque précédent était dehors
837           else:
838             inside = False # ce point est dehors              
839         if not inside and not outside:
840           break
841     idisklim.append(idisk)  # premier et dernier disques internes
842     idiskout.append(numout) # premier et dernier disques externes
843     
844   # --- listes de nappes radiales en filling à chaque extrémité débouchante
845   facesDebouchantes = [False, False]
846   idFacesDebouchantes = [-1, -1] # contiendra les indices des faces disque débouchantes (facesPipePeau)
847   listNappes =[]
848   for i, idisk in enumerate(idisklim):
849     numout = idiskout[i]
850     logging.debug("extremité %s, indices disques interne %s, externe %s",i, idisk, numout)
851     nappes = []
852     if  (idisk != 0) and (idisk != len(gptsdisks)-1): # si extrémité débouchante
853       for k in range(nbsegCercle):
854         if i == 0:
855           iddeb = max(0, numout)
856           idfin = max(iddeb+3,idisk+1) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
857           #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
858           comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
859           name='compoundRay%d'%k
860           geomPublish(initLog.debug, comp, name)
861         else:
862           idfin = min(len(gptsdisks), numout+1)
863           iddeb = min(idfin-3, idisk) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
864           #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
865           comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
866           name='compoundRay%d'%k
867           geomPublish(initLog.debug, comp, name)
868         nappe = geompy.MakeFilling(comp, 2, 5, 0.0001, 0.0001, 0, GEOM.FOM_Default)
869         nappes.append(nappe)
870         name='nappe%d'%k
871         geomPublish(initLog.debug, nappe, name)
872         facesDebouchantes[i] = True
873     listNappes.append(nappes)
874       
875   # --- mise en correspondance avec les indices des faces disque débouchantes (facesPipePeau)
876   for i, nappes in enumerate(listNappes):
877     if facesDebouchantes[i]:
878       for k, face in enumerate(facesPipePeau):
879         edge = geompy.MakeSection(face, nappes[0])
880         if geompy.NbShapes(edge, geompy.ShapeType["EDGE"]) > 0:
881           idFacesDebouchantes[i] = k
882           break
883   logging.debug("idFacesDebouchantes: %s", idFacesDebouchantes)
884
885   # --- construction des listes d'edges radiales sur chaque extrémité débouchante
886   listEdges = []
887   for i, nappes in enumerate(listNappes):
888     id = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
889     if id < 0:
890       listEdges.append([])
891     else:
892       face = facesPipePeau[id]
893       edges = [edgeRadFacePipePeau[id]]
894       for k, nappe in enumerate(nappes):
895         if k > 0:
896           obj = geompy.MakeSection(face, nappes[k]) # normalement une edge, parfois un compound d'edges dont un tout petit
897           edge = obj
898           vs = geompy.ExtractShapes(obj, geompy.ShapeType["VERTEX"], False)
899           if len(vs) > 2:
900             eds = geompy.ExtractShapes(obj, geompy.ShapeType["EDGE"], False)
901             [edsorted, minl,maxl] = sortEdges(eds)
902             edge = edsorted[-1]
903           else:
904             maxl = geompy.BasicProperties(edge)[0]
905           if maxl < 0.01: # problème MakeSection
906             logging.debug("problème MakeSection recherche edge radiale %s, longueur trop faible: %s, utilisation partition", k, maxl)
907             partNappeFace = geompy.MakePartition([face, nappes[k]], [] , [], [], geompy.ShapeType["FACE"], 0, [], 0)
908             edps= geompy.ExtractShapes(partNappeFace, geompy.ShapeType["EDGE"], False)
909             ednouv = []
910             for ii, ed in enumerate(edps):
911               vxs = geompy.ExtractShapes(ed, geompy.ShapeType["VERTEX"], False)
912               distx = [geompy.MinDistance(vx, face) for vx in vxs]
913               distx += [geompy.MinDistance(vx, nappes[k]) for vx in vxs]
914               dmax = max(distx)
915               logging.debug("  dmax %s",dmax)
916               if dmax < 0.01:
917                 ednouv.append(ed)
918             logging.debug("  edges issues de la partition: %s", ednouv)
919             for ii, ed in enumerate(ednouv):
920               geomPublish(initLog.debug, ed, "ednouv%d"%ii)
921             [edsorted, minl,maxl] = sortEdges(ednouv)
922             logging.debug("  longueur edge trouvée: %s", maxl) 
923             edge = edsorted[-1]
924           edges.append(edge)
925           name = 'edgeEndPipe%d'%k
926           geomPublish(initLog.debug, edge, name)
927       listEdges.append(edges)
928
929   # --- création des points du maillage du pipe sur la face de peau
930   for i, edges in enumerate(listEdges):
931     id = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
932     if id >= 0:
933       gptdsk = []
934       if id > 0: # id vaut 0 ou 1
935         id = -1  # si id vaut 1, on prend le dernier élément de la liste (1 ou 2 extrémités débouchent sur la face)
936       centre = ptEdgeFond[idFillingFromBout[i]][id]
937       name = "centre%d"%id
938       geomPublish(initLog.debug, centre, name)
939       vertPipePeau = ptFisExtPi[idFillingFromBout[i]][id]
940       geomPublishInFather(initLog.debug,centre, vertPipePeau, "vertPipePeau")
941       grpsEdgesCirc = edCircPeau[idFillingFromBout[i]] # liste de groupes
942       edgesCirc = []
943       for grpEdgesCirc in grpsEdgesCirc:
944         edgesCirc += geompy.ExtractShapes(grpEdgesCirc, geompy.ShapeType["EDGE"], False)
945       for k, edge in enumerate(edges):
946         extrems = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], True)
947         if geompy.MinDistance(centre, extrems[0]) < geompy.MinDistance(centre, extrems[1]):
948           bout = extrems[1]
949         else:
950           bout = extrems[0]
951         # ajustement du point extrémité (bout) sur l'edge circulaire en face de peau
952         logging.debug("edgesCirc: %s", edgesCirc)
953         distEdgeCirc = [(geompy.MinDistance(bout, edgeCirc), k2, edgeCirc) for k2, edgeCirc in enumerate(edgesCirc)]
954         distEdgeCirc.sort()
955         logging.debug("distEdgeCirc: %s", distEdgeCirc)
956         u = projettePointSurCourbe(bout, distEdgeCirc[0][2])
957         if (abs(u) < 0.02) or (abs(1-u) < 0.02): # les points très proches d'une extrémité doivent y être mis précisément.
958           extrCircs = geompy.ExtractShapes(distEdgeCirc[0][2], geompy.ShapeType["VERTEX"], True)
959           if geompy.MinDistance(bout, extrCircs[0]) < geompy.MinDistance(bout, extrCircs[1]):
960             bout = extrCircs[0]
961           else:
962             bout = extrCircs[1]
963           pass
964         else:
965           bout = geompy.MakeVertexOnCurve(distEdgeCirc[0][2], u)
966         name ="bout%d"%k
967         geomPublishInFather(initLog.debug,centre, bout, name)
968         # enregistrement des points dans la structure
969         points = []
970         for j in range(nbsegRad +1):
971           u = j/float(nbsegRad)
972           points.append(geompy.MakeVertexOnCurve(edge, u))
973         if geompy.MinDistance(bout, points[0]) < geompy.MinDistance(centre, points[0]):
974           points.reverse()
975         points[0] = centre
976         points[-1] = bout
977         gptdsk.append(points)
978       if i == 0:
979         gptsdisks[idisklim[0] -1] = gptdsk
980         idisklim[0] = idisklim[0] -1
981       else:
982         gptsdisks[idisklim[1] +1] = gptdsk
983         idisklim[1] = idisklim[1] +1
984
985   # --- ajustement precis des points sur edgesPipeFissureExterneC
986   
987   edgesPFE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
988   verticesPFE = findWireIntermediateVertices(wirePipeFissureExterne)  # vertices intermédiaires (des points en trop dans ptsInWireFissExtPipe)
989   idiskmin = idisklim[0] + 1 # on ne prend pas le disque sur la peau, déjà ajusté
990   idiskmax = idisklim[1]     # on ne prend pas le disque sur la peau, déjà ajusté
991   idiskint = []
992   for vtx in verticesPFE:
993     distPtVt = []
994     for idisk in range(idiskmin, idiskmax):
995       gptdsk = gptsdisks[idisk]
996       pt = gptdsk[0][-1]       # le point sur l'edge de la fissure externe au pipe
997       distPtVt.append((geompy.MinDistance(pt, vtx), idisk))
998     distPtVt.sort()
999     idiskint.append(distPtVt[0][1])
1000     gptsdisks[idiskint[-1]][0][-1] = vtx
1001     logging.debug("ajustement point sur edgePipeFissureExterne, vertex: %s %s", idiskint[-1], distPtVt[0][0])
1002   for idisk in range(idiskmin, idiskmax):
1003     if idisk in idiskint:
1004       break
1005     logging.debug("ajustement point sur edgePipeFissureExterne: %s", idisk)
1006     gptdsk = gptsdisks[idisk]
1007     pt = gptdsk[0][-1]       # le point sur l'edge de la fissure externe au pipe
1008     distPtEd = [(geompy.MinDistance(pt, edgePFE), k, edgePFE) for k, edgePFE in enumerate(edgesPFE)]
1009     distPtEd.sort()
1010     edgePFE = distPtEd[0][2]
1011     u = projettePointSurCourbe(pt, edgePFE)
1012     ptproj = geompy.MakeVertexOnCurve(edgePFE, u)
1013     gptsdisks[idisk][0][-1] = ptproj
1014   
1015   # -----------------------------------------------------------------------
1016   # --- maillage effectif du pipe
1017
1018   logging.debug("---------------------------- maillage effectif du pipe --------------")
1019   meshPipe = smesh.Mesh(None, "meshPipe")
1020   fondFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "FONDFISS")
1021   nodesFondFissGroup = meshPipe.CreateEmptyGroup(SMESH.NODE, "nfondfis")
1022   faceFissGroup = meshPipe.CreateEmptyGroup(SMESH.FACE, "fisInPi")
1023   edgeFaceFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeFaceFiss")
1024   edgeCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe0")
1025   edgeCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe1")
1026   faceCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe0")
1027   faceCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe1")
1028   mptsdisks = []  # vertices maillage de tous les disques
1029   mEdges = []     # identifiants edges maillage fond de fissure
1030   mEdgeFaces = [] # identifiants edges maillage edge face de fissure externe
1031   mFaces = []     # identifiants faces maillage fissure
1032   mVols  = []     # identifiants volumes maillage pipe
1033
1034   mptdsk = None
1035   for idisk in range(idisklim[0], idisklim[1]+1): # boucle sur les disques internes
1036     
1037     # -----------------------------------------------------------------------
1038     # --- points
1039     
1040     gptdsk = gptsdisks[idisk]
1041     if idisk > idisklim[0]:
1042       oldmpts = mptdsk
1043     mptdsk = [] # vertices maillage d'un disque
1044     for k in range(nbsegCercle):
1045       points = gptdsk[k]
1046       mptids = []
1047       for j, pt in enumerate(points):
1048         if j == 0 and k > 0:
1049           id = mptdsk[0][0]
1050         else:
1051           coords = geompy.PointCoordinates(pt)
1052           id = meshPipe.AddNode(coords[0], coords[1], coords[2])
1053         mptids.append(id)
1054       mptdsk.append(mptids)
1055     mptsdisks.append(mptdsk)
1056     
1057     # -----------------------------------------------------------------------
1058     # --- groupes edges cercles debouchants
1059     
1060     if idisk == idisklim[0]:
1061       pts = []
1062       for k in range(nbsegCercle):
1063         pts.append(mptdsk[k][-1])
1064       edges = []
1065       for k in range(len(pts)):
1066         k1 = (k+1)%len(pts)
1067         idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
1068         edges.append(idEdge)
1069       edgeCircPipe0Group.Add(edges)
1070        
1071     if idisk == idisklim[1]:
1072       pts = []
1073       for k in range(nbsegCercle):
1074         pts.append(mptdsk[k][-1])
1075       edges = []
1076       for k in range(len(pts)):
1077         k1 = (k+1)%len(pts)
1078         idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
1079         edges.append(idEdge)
1080       edgeCircPipe1Group.Add(edges)
1081     
1082     # -----------------------------------------------------------------------
1083     # --- groupes faces  debouchantes
1084     
1085     if idisk == idisklim[0]:
1086       faces = []
1087       for j in range(nbsegRad):
1088         for k in range(nbsegCercle):
1089           k1 = k+1
1090           if k ==  nbsegCercle-1:
1091             k1 = 0
1092           if j == 0:
1093             idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
1094           else:
1095             idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
1096           faces.append(idf)
1097       faceCircPipe0Group.Add(faces)
1098
1099     if idisk == idisklim[1]:
1100       faces = []
1101       for j in range(nbsegRad):
1102         for k in range(nbsegCercle):
1103           k1 = k+1
1104           if k ==  nbsegCercle-1:
1105             k1 = 0
1106           if j == 0:
1107             idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
1108           else:
1109             idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
1110           faces.append(idf)
1111       faceCircPipe1Group.Add(faces)
1112           
1113     # -----------------------------------------------------------------------
1114     # --- mailles volumiques, groupes noeuds et edges de fond de fissure, groupe de face de fissure
1115     
1116     if idisk == idisklim[0]:
1117       mEdges.append(0)
1118       mEdgeFaces.append(0)
1119       mFaces.append([0])
1120       mVols.append([[0]])
1121       nodesFondFissGroup.Add([mptdsk[0][0]])
1122     else:
1123       ide = meshPipe.AddEdge([oldmpts[0][0], mptdsk[0][0]])
1124       mEdges.append(ide)
1125       fondFissGroup.Add([ide])
1126       nodesFondFissGroup.Add([mptdsk[0][0]])
1127       ide2 = meshPipe.AddEdge([oldmpts[0][-1], mptdsk[0][-1]])
1128       mEdgeFaces.append(ide2)
1129       edgeFaceFissGroup.Add([ide2])
1130       idFaces = []
1131       idVols = []
1132       
1133       for j in range(nbsegRad):
1134         idf = meshPipe.AddFace([oldmpts[0][j], mptdsk[0][j], mptdsk[0][j+1], oldmpts[0][j+1]])
1135         faceFissGroup.Add([idf])
1136         idFaces.append(idf)
1137         
1138         idVolCercle = []
1139         for k in range(nbsegCercle):
1140           k1 = k+1
1141           if k ==  nbsegCercle-1:
1142             k1 = 0
1143           if j == 0:
1144             idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1],
1145                                       oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1]])
1146           else:
1147             idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j],
1148                                       oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1], oldmpts[k1][j]])
1149           idVolCercle.append(idv)
1150         idVols.append(idVolCercle)  
1151         
1152       mFaces.append(idFaces)
1153       mVols.append(idVols)
1154
1155   pipeFissGroup = meshPipe.CreateEmptyGroup( SMESH.VOLUME, 'PIPEFISS' )
1156   nbAdd = pipeFissGroup.AddFrom( meshPipe.GetMesh() )
1157
1158   nb, new_mesh, new_group = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries")
1159   edgesCircPipeGroup = [edgeCircPipe0Group, edgeCircPipe1Group]
1160
1161   # --- fin du maillage du pipe
1162   # -----------------------------------------------------------------------
1163   # --- edges de bord, faces défaut à respecter
1164
1165   aFilterManager = smesh.CreateFilterManager()
1166   nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [  ])
1167   criteres = []
1168   unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
1169   criteres.append(unCritere)
1170   filtre = smesh.GetFilterFromCriteria(criteres)
1171   bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
1172   smesh.SetName(bordsLibres, 'bordsLibres')
1173
1174   # --- pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
1175   #     on désigne les faces de peau en quadrangles par le groupe "skinFaces"
1176
1177   skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
1178   nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
1179
1180   # --- maillage des éventuelles arêtes vives entre faces reconstruites
1181   
1182   if len(aretesVivesCoupees) > 0:
1183     aretesVivesC = geompy.MakeCompound(aretesVivesCoupees)
1184     meshAretesVives = smesh.Mesh(aretesVivesC)
1185     algo1d = meshAretesVives.Segment()
1186     hypo1d = algo1d.LocalLength(dmoyen,[],1e-07)
1187     putName(algo1d.GetSubMesh(), "aretesVives")
1188     putName(algo1d, "algo1d_aretesVives")
1189     putName(hypo1d, "hypo1d_aretesVives")
1190     isDone = meshAretesVives.Compute()
1191     logging.info("aretesVives fini")
1192     grpAretesVives = meshAretesVives.CreateEmptyGroup( SMESH.EDGE, 'grpAretesVives' )
1193     nbAdd = grpAretesVives.AddFrom( meshAretesVives.GetMesh() )
1194
1195   # -----------------------------------------------------------------------
1196   # --- maillage faces de fissure
1197   
1198   logging.debug("---------------------------- maillage faces de fissure externes au pipe :%s --------------", len(facesFissExt))
1199
1200   meshFaceFiss = smesh.Mesh(faceFissureExterne)
1201   algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_1D2D)
1202   hypo2d = algo2d.Parameters()
1203   hypo2d.SetMaxSize( areteFaceFissure )
1204   hypo2d.SetSecondOrder( 0 )
1205   hypo2d.SetOptimize( 1 )
1206   hypo2d.SetFineness( 2 )
1207   hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
1208   hypo2d.SetQuadAllowed( 0 )
1209   putName(algo2d.GetSubMesh(), "faceFiss")
1210   putName(algo2d, "algo2d_faceFiss")
1211   putName(hypo2d, "hypo2d_faceFiss")
1212   
1213   algo1d = meshFaceFiss.UseExisting1DElements(geom=edgesPipeFissureExterneC)
1214   hypo1d = algo1d.SourceEdges([ edgeFaceFissGroup ],0,0)
1215   putName(algo1d.GetSubMesh(), "edgeFissPeau")
1216   putName(algo1d, "algo1d_edgeFissPeau")
1217   putName(hypo1d, "hypo1d_edgeFissPeau")
1218   
1219   isDone = meshFaceFiss.Compute()
1220   logging.info("meshFaceFiss fini")
1221
1222   grpFaceFissureExterne = meshFaceFiss.GroupOnGeom(faceFissureExterne, "fisOutPi", SMESH.FACE)
1223   grpEdgesPeauFissureExterne = meshFaceFiss.GroupOnGeom(edgesPeauFissureExterneC,'edgesPeauFissureExterne',SMESH.EDGE)
1224   grpEdgesPipeFissureExterne = meshFaceFiss.GroupOnGeom(edgesPipeFissureExterneC,'edgesPipeFissureExterne',SMESH.EDGE)
1225
1226   # --- maillage faces de peau
1227     
1228   boutFromIfil = [None for i in range(nbFacesFilling)]
1229   if idFillingFromBout[0] != idFillingFromBout[1]: # repérage des extremites du pipe quand elles débouchent sur des faces différentes
1230     boutFromIfil[idFillingFromBout[0]] = 0
1231     boutFromIfil[idFillingFromBout[1]] = 1
1232   
1233   logging.debug("---------------------------- maillage faces de peau --------------")
1234   meshesFacesPeau = []
1235   for ifil in range(nbFacesFilling):
1236     meshFacePeau = None
1237     if partitionsPeauFissFond[ifil] is None: # face de peau maillage sain intacte
1238       
1239       # --- edges de bord de la face de filling
1240       filling = facesDefaut[ifil]
1241       edgesFilling = geompy.ExtractShapes(filling, geompy.ShapeType["EDGE"], False)
1242       groupEdgesBordPeau = geompy.CreateGroup(filling, geompy.ShapeType["EDGE"])
1243       geompy.UnionList(groupEdgesBordPeau, edgesFilling)
1244       geomPublishInFather(initLog.debug,filling, groupEdgesBordPeau , "EdgesBords")
1245       
1246       meshFacePeau = smesh.Mesh(facesDefaut[ifil])
1247       
1248       algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
1249       hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
1250       putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
1251       putName(algo1d, "algo1d_bordsLibres", ifil)
1252       putName(hypo1d, "hypo1d_bordsLibres", ifil)
1253       
1254     else:
1255       
1256       facePeau           = facesPeaux[ifil] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
1257       edgesCircPeau      = edCircPeau[ifil] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
1258       verticesCircPeau   = ptCircPeau[ifil] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
1259       groupEdgesBordPeau = gpedgeBord[ifil] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
1260       bordsVifs          = gpedgeVifs[ifil] # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
1261       edgesFissurePeau   = edFissPeau[ifil] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
1262
1263       meshFacePeau = smesh.Mesh(facePeau)
1264       
1265       algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
1266       hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
1267       putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
1268       putName(algo1d, "algo1d_bordsLibres", ifil)
1269       putName(hypo1d, "hypo1d_bordsLibres", ifil)
1270       
1271       algo1d = meshFacePeau.UseExisting1DElements(geom=geompy.MakeCompound(edgesFissurePeau))
1272       hypo1d = algo1d.SourceEdges([ grpEdgesPeauFissureExterne ],0,0)
1273       putName(algo1d.GetSubMesh(), "edgePeauFiss", ifil)
1274       putName(algo1d, "algo1d_edgePeauFiss", ifil)
1275       putName(hypo1d, "hypo1d_edgePeauFiss", ifil)
1276       
1277       if bordsVifs is not None:
1278         algo1d = meshFacePeau.UseExisting1DElements(geom=bordsVifs)
1279         hypo1d = algo1d.SourceEdges([ grpAretesVives ],0,0)
1280         putName(algo1d.GetSubMesh(), "bordsVifs", ifil)
1281         putName(algo1d, "algo1d_bordsVifs", ifil)
1282         putName(hypo1d, "hypo1d_bordsVifs", ifil)
1283         
1284       for i, edgeCirc in enumerate(edgesCircPeau):
1285         if edgeCirc is not None:
1286           algo1d = meshFacePeau.UseExisting1DElements(geom=edgeCirc)
1287           if boutFromIfil[ifil] is None:
1288             hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[i] ],0,0)
1289           else:
1290             hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[boutFromIfil[ifil]] ],0,0)
1291           name = "cercle%d"%i
1292           putName(algo1d.GetSubMesh(), name, ifil)
1293           putName(algo1d, "algo1d_" + name, ifil)
1294           putName(hypo1d, "hypo1d_" + name, ifil)
1295    
1296     algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_1D2D)
1297     hypo2d = algo2d.Parameters()
1298     hypo2d.SetMaxSize( dmoyen )
1299     hypo2d.SetOptimize( 1 )
1300     hypo2d.SetFineness( 2 )
1301     hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
1302     hypo2d.SetQuadAllowed( 0 )
1303     putName(algo2d.GetSubMesh(), "facePeau", ifil)
1304     putName(algo2d, "algo2d_facePeau", ifil)
1305     putName(hypo2d, "hypo2d_facePeau", ifil)
1306       
1307     isDone = meshFacePeau.Compute()
1308     logging.info("meshFacePeau %d fini", ifil)
1309     GroupFaces = meshFacePeau.CreateEmptyGroup( SMESH.FACE, "facePeau%d"%ifil )
1310     nbAdd = GroupFaces.AddFrom( meshFacePeau.GetMesh() )
1311     meshesFacesPeau.append(meshFacePeau)
1312
1313   # --- regroupement des maillages du défaut
1314
1315   listMeshes = [internalBoundary.GetMesh(),
1316                 meshPipe.GetMesh(),
1317                 meshFaceFiss.GetMesh()]
1318   for mp in meshesFacesPeau:
1319     listMeshes.append(mp.GetMesh())
1320
1321   meshBoiteDefaut = smesh.Concatenate(listMeshes, 1, 1, 1e-05,False)
1322   # pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
1323   # on désigne les faces de peau en quadrangles par le groupe "skinFaces"
1324   group_faceFissOutPipe = None
1325   group_faceFissInPipe = None
1326   groups = meshBoiteDefaut.GetGroups()
1327   for grp in groups:
1328     if grp.GetType() == SMESH.FACE:
1329       #if "internalBoundary" in grp.GetName():
1330       #  grp.SetName("skinFaces")
1331       if grp.GetName() == "fisOutPi":
1332         group_faceFissOutPipe = grp
1333       elif grp.GetName() == "fisInPi":
1334         group_faceFissInPipe = grp
1335
1336   # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
1337   distene=True
1338   if distene:
1339     algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
1340   else:
1341     algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
1342     hypo3d = algo3d.MaxElementVolume(1000.0)
1343   putName(algo3d.GetSubMesh(), "boiteDefaut")
1344   putName(algo3d, "algo3d_boiteDefaut")
1345   isDone = meshBoiteDefaut.Compute()
1346   putName(meshBoiteDefaut, "boiteDefaut")
1347   logging.info("meshBoiteDefaut fini")
1348   
1349   faceFissure = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
1350   maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin,
1351                               zoneDefaut_internalFaces, zoneDefaut_internalEdges)
1352   putName(maillageSain, nomFicSain+"_coupe")
1353   extrusionFaceFissure, normfiss = shapeSurFissure(facesPortFissure)
1354   maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut,
1355                                          None, None, 'COMPLET', normfiss)
1356
1357   logging.info("conversion quadratique")
1358   maillageComplet.ConvertToQuadratic( 1 )
1359   logging.info("groupes")
1360   groups = maillageComplet.GetGroups()
1361   grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
1362   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
1363
1364   logging.info("réorientation face de fissure FACE1")
1365   grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
1366   nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
1367
1368   logging.info("réorientation face de fissure FACE2")
1369   plansim = geompy.MakePlane(O, normfiss, 10000)
1370   fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
1371   grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
1372   nb = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
1373   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
1374
1375   logging.info("export maillage fini")
1376   maillageComplet.ExportMED(fichierMaillageFissure)
1377   putName(maillageComplet, nomFicFissure)
1378   logging.info("fichier maillage fissure %s", fichierMaillageFissure)
1379
1380   if salome.sg.hasDesktop():
1381     salome.sg.updateObjBrowser()
1382
1383   logging.info("maillage fissure fini")
1384   
1385   return maillageComplet