1 # -*- coding: utf-8 -*-
5 from .geomsmesh import geompy
6 from .geomsmesh import geomPublish
7 from .geomsmesh import geomPublishInFather
10 from .geomsmesh import smesh
11 from salome.smesh import smeshBuilder
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
41 # -----------------------------------------------------------------------------
42 # --- procédure complète fissure générale
44 def insereFissureGenerale(maillagesSains,
45 shapesFissure, shapeFissureParams,
46 maillageFissureParams, elementsDefaut, step=-1):
52 shapeDefaut = shapesFissure[0] # faces de fissure, débordant
53 fondFiss = shapesFissure[4] # groupe d'edges de fond de fissure
55 rayonPipe = shapeFissureParams['rayonPipe']
56 if 'lenSegPipe' in shapeFissureParams:
57 lenSegPipe = shapeFissureParams['lenSegPipe']
59 lenSegPipe = rayonPipe
61 nomRep = maillageFissureParams['nomRep']
62 nomFicSain = maillageFissureParams['nomFicSain']
63 nomFicFissure = maillageFissureParams['nomFicFissure']
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']
72 isPointInterne = False
73 if 'pointIn_x' in shapeFissureParams:
74 pointIn_x = shapeFissureParams['pointIn_x']
76 if 'pointIn_y' in shapeFissureParams:
77 pointIn_y = shapeFissureParams['pointIn_y']
79 if 'pointIn_z' in shapeFissureParams:
80 pointIn_z = shapeFissureParams['pointIn_z']
83 pointInterne = geompy.MakeVertex(pointIn_x, pointIn_y, pointIn_z)
85 #fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
86 fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
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]
107 # --- restriction de la face de fissure au domaine solide :
108 # partition face fissure étendue par fillings, on garde la plus grande face
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)
114 distfaces = [(geompy.MinDistance(face,pointInterne), i, face) for i, face in enumerate(facesPartShapeDefaut)]
116 logging.debug("selection de la face la plus proche du point interne, distance=%s",distfaces[0][0])
117 facesPortFissure = distfaces[0][2]
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
123 geomPublish(initLog.debug, facesPortFissure, "facesPortFissure")
125 O, OX, OY, OZ = triedreBase()
127 # -----------------------------------------------------------------------------
128 # --- pipe de fond de fissure, prolongé, partition face fissure par pipe
129 # identification des edges communes pipe et face fissure
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')
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')
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)
158 wirePipeFiss = geompy.MakeWire(edgesPipeFiss) #= global
160 wirePipeFiss = geompy.MakeCompound(edgesPipeFiss)
161 logging.debug("wirePipeFiss construit sous forme de compound")
162 geomPublish(initLog.debug, wirePipeFiss, "wirePipeFiss")
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")
172 # -----------------------------------------------------------------------------
173 # --- peau et face de fissure
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)
180 partitionsPeauFissFond = [] #= global
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]
188 fissPipePart = geompy.MakePartition([fissPipe], otherFD, [], [], geompy.ShapeType["FACE"], 0, [], 0)
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 )
195 partitionsPeauFissFond.append(None)
199 # --- arêtes vives détectées (dans quadranglesToShapeNoCorner
200 # et quadranglesToShapeWithCorner)
203 aretesVivesCoupees = [] #= global
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)
213 aretesVives.append(a[0])
214 name = "areteVive%d"%ia
215 geomPublish(initLog.debug, a[0], name)
218 aretesVivesC = None #= global
219 if len(aretesVives) > 0:
220 aretesVivesC =geompy.MakeCompound(aretesVives)
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
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]
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,
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")
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)
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)
263 edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"]) #= global
264 verticesPipePeau = [] #= global
266 for i, edge in enumerate(edgesPipeIn):
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)
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]
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)
293 edgesFondFiss, edgesIdByOrientation = orderEdgesFromWire(wireFondFiss)
294 for i,edge in enumerate(edgesFondFiss):
295 geomPublishInFather(initLog.debug,wireFondFiss, edge, "edgeFondFiss%d"%i)
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]
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)
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)
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
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)
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)
368 edgePart = geompy.MakePartition([localEdgeInFondFiss], [p1,p2], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
369 edps = geompy.ExtractShapes(edgePart, geompy.ShapeType["EDGE"], True)
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)
377 for face in facesInside:
378 logging.debug("recherche edges communes entre une face inside et (faces onside, edges pipe et fond débouchante)")
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)
390 logging.debug(" pb edges communes %s %s %s",edgesPeauFis, edgesPipeFis, edgesPipeFnd)
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)
401 for ipe, edpe in enumerate(edgesPeauFis):
402 for ipi, edpi in enumerate(edgesPipeFis):
403 dist = geompy.MinDistance(edpe, edpi)
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)
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
418 for face in facesInside:
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"])
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)
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
441 facesAndFond = facesOnside
442 facesAndFond.append(wireFondFiss)
444 partitionPeauByPipe = geompy.MakePartition(facesAndFond, pipexts, [], [], geompy.ShapeType["FACE"], 0, [], 1)
446 logging.debug("probleme partition face pipe, contournement avec MakeSection")
448 for pipext in pipexts:
449 sections.append(geompy.MakeSection(facesOnside[0], pipext))
450 partitionPeauByPipe = geompy.MakePartition(facesAndFond, sections, [], [], geompy.ShapeType["FACE"], 0, [], 1)
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
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)
462 edgeEnTrop.append(True) # TODO : distinguer les cas avec deux faces circulaires dont l'une est correcte
464 edgeEnTrop.append(False)
465 refaire = sum(edgeEnTrop)
467 dc = [(geompy.MinDistance(verticesEdgesFondIn[0], fac), i) for i, fac in enumerate(facesPeauSorted[:-1])]
469 logging.debug("dc sorted: %s", dc)
470 i0 = dc[0][1] # indice de facesPeauSorted qui correspond à verticesEdgesFondIn[0], donc 0 pour cercles
472 for i, bad in enumerate(edgeEnTrop):
478 outilPart[j] = geompy.MakeProjection(cercles[j],facesOnside[0])
480 partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, [], [], geompy.ShapeType["FACE"], 0, [], 1)
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)
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
492 facePeau =geompy.MakePartition(facesPeauFondOn, [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
493 name="facePeau%d"%ifil
494 geomPublish(initLog.debug, facePeau, name)
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))]
502 verticesCircPeau = []
503 if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
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)
511 for ik, edpfi in enumerate(edgesPeauFondIn):
512 if geompy.MinDistance(face, edpfi) < 1e-3:
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)
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)
552 pass # --- au moins une extrémité du pipe sur cette face de peau
554 # --- edges de bord de la face de peau
556 edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
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)
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)
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)
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
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")
594 # --- edges de la face de peau partagées avec la face de fissure
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
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)
611 for i, edge in enumerate(edges):
612 edgesFissurePeau.append(edge)
613 name = "edgeFissurePeau%d"%i
614 geomPublishInFather(initLog.debug,facePeau, edge, name)
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]
631 # -----------------------------------------------------------------------
632 # fin de la boucle sur les faces de filling
633 # -----------------------------------------------------------------------
635 for i, avc in enumerate(aretesVivesCoupees):
636 name = "areteViveCoupee%d"%i
637 geomPublish(initLog.debug, avc, name)
639 # --- identification des faces et edges de fissure externe pour maillage
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.
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)
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)
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")
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é)
685 # --- option de maillage selon le rayon de courbure du fond de fissure
687 for edff in edgesFondFiss:
688 lenEdgeFondExt += geompy.BasicProperties(edff)[0]
691 for filling in facesDefaut:
692 disfond.append(geompy.MinDistance(centreFondFiss, filling))
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)
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()
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))
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
733 if geompy.MinDistance(point, vertcx) < 1.1*rayonPipe: # les quatre coins sont plus loin
736 centres.append(vertcx)
737 origins.append(vertpx)
739 # name = "vertcx%d"%i
740 # geomPublishInFather(initLog.debug,wireFondFiss, vertcx, name)
741 # name = "vertpx%d"%i
742 # geomPublishInFather(initLog.debug,wireFondFiss, vertpx, name)
744 # geomPublishInFather(initLog.debug,wireFondFiss, plan, name)
746 # --- maillage du pipe étendu, sans tenir compte de l'intersection avec la face de peau
748 logging.debug("nbsegCercle %s", nbsegCercle)
750 # -----------------------------------------------------------------------
751 # --- points géométriques
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
760 vec1 = geompy.MakeVector(vertcx, vertpx)
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)
766 gptdsk.append(points)
767 pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, 1.5*rayonPipe)
768 rayon = geompy.MakeLineTwoPnt(vertcx, pt)
769 raydisks[0].append(rayon)
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)
778 ray = geompy.MakeRotation(rayon, normal, angle)
779 raydisks[k+1].append(ray)
781 gptsdisks.append(gptdsk)
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
791 logging.debug("---------------------------- recherche des points du pipe a éliminer --------------")
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
801 idFillingFromBout[1] = ifil
802 logging.debug("association bouts du pipe - faces de filling: %s", idFillingFromBout)
805 edgeRadFacePipePeau = []
806 for ifil in range(nbFacesFilling):
807 facesPipePeau += fsPipePeau[ifil]
808 edgeRadFacePipePeau += edRadFPiPo[ifil]
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):
819 idisk = len(gptsdisks)
821 numout = len(gptsdisks)
826 logging.debug("examen disque %s", idisk)
827 gptdsk = gptsdisks[idisk]
829 for k in range(nbsegCercle):
831 for j, pt in enumerate(points):
832 side = whichSideVertex(facesDefaut[idFillingFromBout[bout]], pt)
834 if outside: # premier point detecté dedans
836 numout = idisk -inc # le disque précédent était dehors
838 inside = False # ce point est dehors
839 if not inside and not outside:
841 idisklim.append(idisk) # premier et dernier disques internes
842 idiskout.append(numout) # premier et dernier disques externes
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)
848 for i, idisk in enumerate(idisklim):
850 logging.debug("extremité %s, indices disques interne %s, externe %s",i, idisk, numout)
852 if (idisk != 0) and (idisk != len(gptsdisks)-1): # si extrémité débouchante
853 for k in range(nbsegCercle):
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)
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)
871 geomPublish(initLog.debug, nappe, name)
872 facesDebouchantes[i] = True
873 listNappes.append(nappes)
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
883 logging.debug("idFacesDebouchantes: %s", idFacesDebouchantes)
885 # --- construction des listes d'edges radiales sur chaque extrémité débouchante
887 for i, nappes in enumerate(listNappes):
888 id = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
892 face = facesPipePeau[id]
893 edges = [edgeRadFacePipePeau[id]]
894 for k, nappe in enumerate(nappes):
896 obj = geompy.MakeSection(face, nappes[k]) # normalement une edge, parfois un compound d'edges dont un tout petit
898 vs = geompy.ExtractShapes(obj, geompy.ShapeType["VERTEX"], False)
900 eds = geompy.ExtractShapes(obj, geompy.ShapeType["EDGE"], False)
901 [edsorted, minl,maxl] = sortEdges(eds)
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)
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]
915 logging.debug(" dmax %s",dmax)
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)
925 name = 'edgeEndPipe%d'%k
926 geomPublish(initLog.debug, edge, name)
927 listEdges.append(edges)
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)
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]
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
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]):
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)]
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]):
965 bout = geompy.MakeVertexOnCurve(distEdgeCirc[0][2], u)
967 geomPublishInFather(initLog.debug,centre, bout, name)
968 # enregistrement des points dans la structure
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]):
977 gptdsk.append(points)
979 gptsdisks[idisklim[0] -1] = gptdsk
980 idisklim[0] = idisklim[0] -1
982 gptsdisks[idisklim[1] +1] = gptdsk
983 idisklim[1] = idisklim[1] +1
985 # --- ajustement precis des points sur edgesPipeFissureExterneC
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é
992 for vtx in verticesPFE:
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))
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:
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)]
1010 edgePFE = distPtEd[0][2]
1011 u = projettePointSurCourbe(pt, edgePFE)
1012 ptproj = geompy.MakeVertexOnCurve(edgePFE, u)
1013 gptsdisks[idisk][0][-1] = ptproj
1015 # -----------------------------------------------------------------------
1016 # --- maillage effectif du pipe
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
1035 for idisk in range(idisklim[0], idisklim[1]+1): # boucle sur les disques internes
1037 # -----------------------------------------------------------------------
1040 gptdsk = gptsdisks[idisk]
1041 if idisk > idisklim[0]:
1043 mptdsk = [] # vertices maillage d'un disque
1044 for k in range(nbsegCercle):
1047 for j, pt in enumerate(points):
1048 if j == 0 and k > 0:
1051 coords = geompy.PointCoordinates(pt)
1052 id = meshPipe.AddNode(coords[0], coords[1], coords[2])
1054 mptdsk.append(mptids)
1055 mptsdisks.append(mptdsk)
1057 # -----------------------------------------------------------------------
1058 # --- groupes edges cercles debouchants
1060 if idisk == idisklim[0]:
1062 for k in range(nbsegCercle):
1063 pts.append(mptdsk[k][-1])
1065 for k in range(len(pts)):
1067 idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
1068 edges.append(idEdge)
1069 edgeCircPipe0Group.Add(edges)
1071 if idisk == idisklim[1]:
1073 for k in range(nbsegCercle):
1074 pts.append(mptdsk[k][-1])
1076 for k in range(len(pts)):
1078 idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
1079 edges.append(idEdge)
1080 edgeCircPipe1Group.Add(edges)
1082 # -----------------------------------------------------------------------
1083 # --- groupes faces debouchantes
1085 if idisk == idisklim[0]:
1087 for j in range(nbsegRad):
1088 for k in range(nbsegCercle):
1090 if k == nbsegCercle-1:
1093 idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
1095 idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
1097 faceCircPipe0Group.Add(faces)
1099 if idisk == idisklim[1]:
1101 for j in range(nbsegRad):
1102 for k in range(nbsegCercle):
1104 if k == nbsegCercle-1:
1107 idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
1109 idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
1111 faceCircPipe1Group.Add(faces)
1113 # -----------------------------------------------------------------------
1114 # --- mailles volumiques, groupes noeuds et edges de fond de fissure, groupe de face de fissure
1116 if idisk == idisklim[0]:
1118 mEdgeFaces.append(0)
1121 nodesFondFissGroup.Add([mptdsk[0][0]])
1123 ide = meshPipe.AddEdge([oldmpts[0][0], mptdsk[0][0]])
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])
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])
1139 for k in range(nbsegCercle):
1141 if k == nbsegCercle-1:
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]])
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)
1152 mFaces.append(idFaces)
1153 mVols.append(idVols)
1155 pipeFissGroup = meshPipe.CreateEmptyGroup( SMESH.VOLUME, 'PIPEFISS' )
1156 nbAdd = pipeFissGroup.AddFrom( meshPipe.GetMesh() )
1158 nb, new_mesh, new_group = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries")
1159 edgesCircPipeGroup = [edgeCircPipe0Group, edgeCircPipe1Group]
1161 # --- fin du maillage du pipe
1162 # -----------------------------------------------------------------------
1163 # --- edges de bord, faces défaut à respecter
1165 aFilterManager = smesh.CreateFilterManager()
1166 nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ])
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')
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"
1177 skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
1178 nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
1180 # --- maillage des éventuelles arêtes vives entre faces reconstruites
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() )
1195 # -----------------------------------------------------------------------
1196 # --- maillage faces de fissure
1198 logging.debug("---------------------------- maillage faces de fissure externes au pipe :%s --------------", len(facesFissExt))
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")
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")
1219 isDone = meshFaceFiss.Compute()
1220 logging.info("meshFaceFiss fini")
1222 grpFaceFissureExterne = meshFaceFiss.GroupOnGeom(faceFissureExterne, "fisOutPi", SMESH.FACE)
1223 grpEdgesPeauFissureExterne = meshFaceFiss.GroupOnGeom(edgesPeauFissureExterneC,'edgesPeauFissureExterne',SMESH.EDGE)
1224 grpEdgesPipeFissureExterne = meshFaceFiss.GroupOnGeom(edgesPipeFissureExterneC,'edgesPipeFissureExterne',SMESH.EDGE)
1226 # --- maillage faces de peau
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
1233 logging.debug("---------------------------- maillage faces de peau --------------")
1234 meshesFacesPeau = []
1235 for ifil in range(nbFacesFilling):
1237 if partitionsPeauFissFond[ifil] is None: # face de peau maillage sain intacte
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")
1246 meshFacePeau = smesh.Mesh(facesDefaut[ifil])
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)
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]
1263 meshFacePeau = smesh.Mesh(facePeau)
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)
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)
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)
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)
1290 hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[boutFromIfil[ifil]] ],0,0)
1292 putName(algo1d.GetSubMesh(), name, ifil)
1293 putName(algo1d, "algo1d_" + name, ifil)
1294 putName(hypo1d, "hypo1d_" + name, ifil)
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)
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)
1313 # --- regroupement des maillages du défaut
1315 listMeshes = [internalBoundary.GetMesh(),
1317 meshFaceFiss.GetMesh()]
1318 for mp in meshesFacesPeau:
1319 listMeshes.append(mp.GetMesh())
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()
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
1336 # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
1339 algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
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")
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)
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' )
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))
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' )
1375 logging.info("export maillage fini")
1376 maillageComplet.ExportMED(fichierMaillageFissure)
1377 putName(maillageComplet, nomFicFissure)
1378 logging.info("fichier maillage fissure %s", fichierMaillageFissure)
1380 if salome.sg.hasDesktop():
1381 salome.sg.updateObjBrowser()
1383 logging.info("maillage fissure fini")
1385 return maillageComplet