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