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 # fillings des faces en peau
86 facesDefaut = elementsDefaut[0]
87 #centresDefaut = elementsDefaut[1]
88 #normalsDefaut = elementsDefaut[2]
89 #extrusionsDefaut = elementsDefaut[3]
90 dmoyen = elementsDefaut[4]
91 bordsPartages = elementsDefaut[5]
92 fillconts = elementsDefaut[6]
93 idFilToCont = elementsDefaut[7]
94 maillageSain = elementsDefaut[8]
95 internalBoundary = elementsDefaut[9]
96 zoneDefaut = elementsDefaut[10]
97 zoneDefaut_skin = elementsDefaut[11]
98 zoneDefaut_internalFaces = elementsDefaut[12]
99 zoneDefaut_internalEdges = elementsDefaut[13]
100 edgeFondExt = elementsDefaut[14]
101 centreFondFiss = elementsDefaut[15]
102 tgtCentre = elementsDefaut[16]
104 # --- restriction de la face de fissure au domaine solide :
105 # partition face fissure étendue par fillings, on garde la plus grande face
107 partShapeDefaut = geompy.MakePartition([shapeDefaut], facesDefaut, [], [], geompy.ShapeType["FACE"], 0, [], 0)
108 geompy.addToStudy(partShapeDefaut, 'partShapeDefaut')
109 facesPartShapeDefaut = geompy.ExtractShapes(partShapeDefaut, geompy.ShapeType["FACE"], False)
111 distfaces = [(geompy.MinDistance(face,pointInterne), i, face) for i, face in enumerate(facesPartShapeDefaut)]
113 logging.debug("selection de la face la plus proche du point interne, distance=%s",distfaces[0][0])
114 facesPortFissure = distfaces[0][2]
116 facesPartShapeDefautSorted, minSurf, maxSurf = sortFaces(facesPartShapeDefaut) # la face de fissure dans le volume doit être la plus grande
117 logging.debug("surfaces faces fissure étendue, min %s, max %s", minSurf, maxSurf)
118 facesPortFissure = facesPartShapeDefautSorted[-1]
120 geompy.addToStudy(facesPortFissure, "facesPortFissure")
122 O, OX, OY, OZ = triedreBase()
124 # -----------------------------------------------------------------------------
125 # --- pipe de fond de fissure, prolongé, partition face fissure par pipe
126 # identification des edges communes pipe et face fissure
128 if geompy.NumberOfFaces(shapeDefaut) == 1:
129 plan = geompy.MakePlane(centreFondFiss, tgtCentre, 10000)
130 shapeDefaut = geompy.MakePartition([shapeDefaut], [plan], [], [], geompy.ShapeType["FACE"], 0, [], 0)
131 fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss)
132 geompy.addToStudy(shapeDefaut, 'shapeDefaut_coupe')
133 geompy.addToStudyInFather(shapeDefaut, fondFissCoupe, 'fondFiss_coupe')
135 extrem, norms = findWireEndVertices(fondFiss, True)
136 logging.debug("extrem: %s, norm: %s",extrem, norms)
137 cercle = geompy.MakeCircle(extrem[0], norms[0], rayonPipe)
138 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
139 geompy.addToStudy(cercle, 'cercle')
140 fondFissProlonge = prolongeWire(fondFiss, extrem, norms, 2*rayonPipe)
141 pipeFiss = geompy.MakePipe(cercle, fondFissProlonge)
142 geompy.addToStudy(pipeFiss, 'pipeFiss')
143 partFissPipe = geompy.MakePartition([shapeDefaut, pipeFiss], [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
144 geompy.addToStudy(partFissPipe, 'partFissPipe')
145 fissPipe = geompy.GetInPlaceByHistory(partFissPipe, shapeDefaut)
146 geompy.addToStudy(fissPipe, 'fissPipe')
147 partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss)
148 geompy.addToStudy(partPipe, 'partPipe')
150 edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"])
151 for i, edge in enumerate(edgesPipeFiss):
152 name = "edgePipe%d"%i
153 geompy.addToStudyInFather(fissPipe, edge, name)
155 wirePipeFiss = geompy.MakeWire(edgesPipeFiss)
157 wirePipeFiss = geompy.MakeCompound(edgesPipeFiss)
158 logging.debug("wirePipeFiss construit sous forme de compound")
159 geompy.addToStudy(wirePipeFiss, "wirePipeFiss")
161 wireFondFiss = geompy.GetInPlace(partFissPipe,fondFiss)
162 edgesFondFiss = geompy.GetSharedShapesMulti([fissPipe, wireFondFiss], geompy.ShapeType["EDGE"])
163 for i, edge in enumerate(edgesFondFiss):
164 name = "edgeFondFiss%d"%i
165 geompy.addToStudyInFather(fissPipe, edge, name)
166 wireFondFiss = geompy.MakeWire(edgesFondFiss)
167 geompy.addToStudy(wireFondFiss,"wireFondFiss")
169 # -----------------------------------------------------------------------------
170 # --- peau et face de fissure
172 # --- partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée
173 # il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure
174 # liste de faces externes : facesDefaut
175 # liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
177 partitionsPeauFissFond = []
179 for filling in facesDefaut:
180 part = geompy.MakePartition([fissPipe, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
181 isPart = checkDecoupePartition([fissPipe, filling], part)
182 if isPart: # on recrée la partition avec toutes les faces filling en outil pour avoir une face de fissure correcte
183 otherFD = [fd for fd in facesDefaut if fd != filling]
185 fissPipePart = geompy.MakePartition([fissPipe], otherFD, [], [], geompy.ShapeType["FACE"], 0, [], 0)
187 fissPipePart = fissPipe
188 part = geompy.MakePartition([fissPipePart, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
189 partitionsPeauFissFond.append(part)
190 geompy.addToStudy( part, 'partitionPeauFissFond%d'%ipart )
192 partitionsPeauFissFond.append(None)
196 # --- arêtes vives détectées (dans quadranglesToShapeNoCorner
197 # et quadranglesToShapeWithCorner)
200 aretesVivesCoupees = []
202 for a in bordsPartages:
203 if not isinstance(a, list):
204 aretesVives.append(a)
205 name = "areteVive%d"%ia
206 geompy.addToStudy(a, name)
210 aretesVives.append(a[0])
211 name = "areteVive%d"%ia
212 geompy.addToStudy(a[0], name)
216 if len(aretesVives) > 0:
217 aretesVivesC =geompy.MakeCompound(aretesVives)
219 # -------------------------------------------------------
220 # --- inventaire des faces de peau coupées par la fissure
221 # pour chaque face de peau : 0, 1 ou 2 faces débouchante du fond de fissure
222 # 0, 1 ou plus edges de la face de fissure externe au pipe
224 nbFacesFilling = len(partitionsPeauFissFond)
225 ptEdgeFond = [ [] for i in range(nbFacesFilling)] # pour chaque face [points edge fond de fissure aux débouchés du pipe]
226 fsPipePeau = [ [] for i in range(nbFacesFilling)] # pour chaque face [faces du pipe débouchantes]
227 edRadFPiPo = [ [] for i in range(nbFacesFilling)] # pour chaque face [edge radiale des faces du pipe débouchantes ]
228 fsFissuExt = [ [] for i in range(nbFacesFilling)] # pour chaque face [faces de fissure externes au pipe]
229 edFisExtPe = [ [] for i in range(nbFacesFilling)] # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
230 edFisExtPi = [ [] for i in range(nbFacesFilling)] # pour chaque face [edge commun au pipe des faces de fissure externes]
231 facesPeaux = [None for i in range(nbFacesFilling)] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
232 edCircPeau = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
233 ptCircPeau = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
234 gpedgeBord = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
235 gpedgeVifs = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupes subshape des edges aux arêtes vives entre fillings
236 edFissPeau = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
237 ptFisExtPi = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [point commun edFissPeau edCircPeau]
239 for ifil, partitionPeauFissFond in enumerate(partitionsPeauFissFond):
240 fillingFaceExterne = facesDefaut[ifil]
241 #fillingSansDecoupe = fillconts[idFilToCont[ifil]]
242 if partitionPeauFissFond is not None:
243 logging.debug("traitement partitionPeauFissFond %s", ifil)
244 # -----------------------------------------------------------------------
245 # --- identification edges fond de fissure, edges pipe sur la face de fissure,
248 edgesPipeC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesPipeFiss))
249 geompy.addToStudyInFather(partitionPeauFissFond, edgesPipeC, "edgesPipeFiss")
250 edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss))
251 geompy.addToStudyInFather(partitionPeauFissFond, edgesFondC, "edgesFondFiss")
253 if aretesVivesC is None:
254 [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
255 [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
257 [edgesInside, edgesOutside, edgesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
258 [facesInside, facesOutside, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
260 edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
261 verticesPipePeau = []
263 for i, edge in enumerate(edgesPipeIn):
265 vertices = geompy.GetSharedShapesMulti([edge, geompy.MakeCompound(facesOnside)], geompy.ShapeType["VERTEX"])
266 verticesPipePeau.append(vertices[0])
267 name = "edgePipeIn%d"%i
268 geompy.addToStudyInFather(partitionPeauFissFond, edge, name)
269 name = "verticePipePeau%d"%i
270 geompy.addToStudyInFather(partitionPeauFissFond, vertices[0], name)
271 logging.debug("edgePipeIn%s coupe les faces OnSide", i)
273 logging.debug("edgePipeIn%s ne coupe pas les faces OnSide", i)
276 if len(verticesPipePeau) > 0: # au moins une extrémité du pipe sur cette face de peau
277 tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesOutside)], geompy.ShapeType["EDGE"])
278 edgesFondOut = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
279 tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
280 edgesFondIn = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
281 verticesEdgesFondIn = [] # les points du fond de fissure au débouché du pipe sur la peau (indice de edgesFondIn)
282 pipexts = [] # les segments de pipe associés au points de fond de fissure débouchants (même indice)
283 cercles = [] # les cercles de generation des pipes débouchant (même indice)
284 facesFissExt = [] # les faces de la fissure externe associés au points de fond de fissure débouchants (même indice)
285 edgesFissExtPeau = [] # edges des faces de fissure externe sur la peau (même indice)
286 edgesFissExtPipe = [] # edges des faces de fissure externe sur le pipe (même indice)
287 #logging.debug("edgesFondIn %s", edgesFondIn)
289 edgesFondFiss, edgesIdByOrientation = orderEdgesFromWire(wireFondFiss)
290 for i,edge in enumerate(edgesFondFiss):
291 geompy.addToStudyInFather(wireFondFiss, edge, "edgeFondFiss%d"%i)
293 for iedf, edge in enumerate(edgesFondIn):
294 name = "edgeFondIn%d"%iedf
295 geompy.addToStudyInFather(partitionPeauFissFond, edge, name)
296 dist = [ geompy.MinDistance(pt, edge) for pt in verticesPipePeau]
297 ptPeau = verticesPipePeau[dist.index(min(dist))] # le point de verticesPipePeau a distance minimale de l'edge
298 [u, PointOnEdge, EdgeInWireIndex] = geompy.MakeProjectionOnWire(ptPeau, wireFondFiss)
299 logging.debug("u:%s, EdgeInWireIndex: %s, len(edgesFondFiss): %s", u, EdgeInWireIndex, len(edgesFondFiss))
300 localEdgeInFondFiss = edgesFondFiss[EdgeInWireIndex]
302 centre2 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, u)
303 geompy.addToStudyInFather(partitionPeauFissFond, centre2, "centre2_%d"%iedf)
304 verticesEdgesFondIn.append(centre)
305 name = "verticeEdgesFondIn%d"%iedf
306 geompy.addToStudyInFather(partitionPeauFissFond, centre, name)
307 norm = geompy.MakeTangentOnCurve(localEdgeInFondFiss, u)
308 geompy.addToStudyInFather(partitionPeauFissFond, centre, "norm%d"%iedf)
309 cercle = geompy.MakeCircle(centre, norm, rayonPipe)
310 geompy.addToStudyInFather(partitionPeauFissFond, cercle, "cerclorig%d"%iedf)
311 [vertex] = geompy.ExtractShapes(cercle, geompy.ShapeType["VERTEX"], False)
312 vec1 = geompy.MakeVector(centre, vertex)
313 vec2 = geompy.MakeVector(centre, ptPeau)
314 angle = geompy.GetAngleRadians(vec1, vec2)
315 # cas général : on reconstitue une portion de pipe, avec l'arête de couture qui coincide
316 # avec la face de fissure, au niveau du débouché sur la face externe
317 # cas dégénéré : le pipe débouche perpendiculairement à une surface plane à l'origine.
318 # La partition filling / pipe reconstruit échoue.
319 # - Si on partitionne le filling avec un simple pipe obtenu par extrusion droite du cercle,
320 # cela donne un point en trop sur le cercle.
321 # - Si on prend une vraie surface plane (pas un filling), on peut faire la partition avec
322 # les pipes reconstruits
323 logging.debug("angle=%s", angle)
324 #if abs(angle) > 1.e-7:
325 sommetAxe = geompy.MakeTranslationVector(centre, norm)
326 pm = produitMixte(centre, vertex, ptPeau, sommetAxe)
327 if pm > 0: # ajout de pi a (-)angle pour éviter des points confondus (partition échoue) dans les cas dégénérés
328 cercle = geompy.MakeRotation(cercle, norm, angle + math.pi)
330 cercle = geompy.MakeRotation(cercle, norm, -angle + math.pi)
331 name = "cercle%d"%iedf
332 geompy.addToStudyInFather(partitionPeauFissFond, cercle, name)
333 cercles.append(cercle)
335 # --- estimation de la longueur du pipe necessaire de part et d'autre du point de sortie
336 if aretesVivesC is None:
337 faceTestPeau = fillingFaceExterne
339 faceTestPeau = facesDefaut[ifil]
340 sideCentre = whichSide(faceTestPeau, centre)
341 locPt0 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 0.0)
342 locPt1 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 1.0)
343 sidePt0 = whichSide(faceTestPeau, locPt0)
344 sidePt1 = whichSide(faceTestPeau, locPt1)
345 logging.debug("position centre cercle: %s, extremité edge u0: %s, u1: %s", sideCentre, sidePt0, sidePt1)
346 normFace = geompy.GetNormal(faceTestPeau, ptPeau)
347 inclPipe = abs(geompy.GetAngleRadians(norm, normFace))
348 lgp = max(rayonPipe/2., abs(3*rayonPipe*math.tan(inclPipe)))
349 logging.debug("angle inclinaison Pipe en sortie: %s degres, lgp: %s", inclPipe*180/math.pi, lgp)
351 # --- position des points extremite du pipe sur l'edge debouchante
352 # il faut la distance curviligne ofp du point central par rapport à une extrémité de l'edge débouchante
353 locEdgePart = geompy.MakePartition([localEdgeInFondFiss],[centre], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
354 edgesLoc = geompy.ExtractShapes(locEdgePart, geompy.ShapeType["EDGE"], False)
355 edgesLocSorted =[(geompy.MinDistance(edge, locPt0), kk, edge) for kk, edge in enumerate(edgesLoc)]
356 edgesLocSorted.sort()
357 ofp = geompy.BasicProperties(edgesLocSorted[0][2])[0] # distance curviligne centre locPt0
358 logging.debug("distance curviligne centre extremite0: %s", ofp)
359 p1 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp +lgp, locPt0)
360 p2 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp -lgp, locPt0)
361 geompy.addToStudyInFather(wireFondFiss, p1, "p1_%d"%iedf)
362 geompy.addToStudyInFather(wireFondFiss, p2, "p2_%d"%iedf)
364 edgePart = geompy.MakePartition([localEdgeInFondFiss], [p1,p2], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
365 edps = geompy.ExtractShapes(edgePart, geompy.ShapeType["EDGE"], True)
367 if geompy.MinDistance(centre, edp) < 1.e-3:
368 pipext = geompy.MakePipe(cercle, edp)
369 name = "pipeExt%d"%iedf
370 geompy.addToStudyInFather(partitionPeauFissFond, pipext, name)
371 pipexts.append(pipext)
373 for face in facesInside:
374 logging.debug("recherche edges communes entre une face inside et (faces onside, edges pipe et fond débouchante)")
379 edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
380 logging.debug(" faces onside %s",edgesPeauFis)
381 edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
382 logging.debug(" edgesPipeIn %s", edgesPipeFis)
383 edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
384 logging.debug(" edgesFondIn %s ", edgesPipeFnd)
386 logging.debug(" pb edges communes %s %s %s",edgesPeauFis, edgesPipeFis, edgesPipeFnd)
388 if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
389 dist = geompy.MinDistance(geompy.MakeCompound(edgesPeauFis), ptPeau)
390 logging.debug(" test distance extrémité reference %s", dist)
391 if dist < 1.e-3: # c'est la face de fissure externe associée
392 logging.debug(" face %s inside ajoutée", i)
393 facesFissExt.append(face)
394 name="faceFissExt%d"%iedf
395 geompy.addToStudyInFather(partitionPeauFissFond, face, name)
397 for ipe, edpe in enumerate(edgesPeauFis):
398 for ipi, edpi in enumerate(edgesPipeFis):
399 dist = geompy.MinDistance(edpe, edpi)
401 edgesFissExtPeau.append(edpe)
402 name="edgesFissExtPeau%d"%iedf
403 geompy.addToStudyInFather(partitionPeauFissFond, edpe, name)
404 edgesFissExtPipe.append(edpi)
405 name="edgesFissExtPipe%d"%iedf
406 geompy.addToStudyInFather(partitionPeauFissFond, edpi, name)
411 if len(verticesPipePeau) == 0: # aucune extrémité du pipe sur cette face de peau
412 # il faut recenser les edges de fissure sur la face de peau
414 for face in facesInside:
419 edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
420 edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
421 edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
424 if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
425 edgesFissExtPeau.append(edgesPeauFis[0])
426 name="edgesFissExtPeau%d"%j
427 geompy.addToStudyInFather(partitionPeauFissFond, edgesPeauFis[0], name)
430 # -----------------------------------------------------------------------
431 # --- identification faces de peau : face de peau percée du pipe, extrémités du pipe
432 # La partition avec le pipe peut créer un vertex (et un edge) de trop sur le cercle projeté,
433 # quand le cercle est très proche de la face.
434 # dans ce cas, la projection du cercle sur la face suivie d'une partition permet
435 # d'éviter le point en trop
437 facesAndFond = facesOnside
438 facesAndFond.append(wireFondFiss)
440 partitionPeauByPipe = geompy.MakePartition(facesAndFond, pipexts, [], [], geompy.ShapeType["FACE"], 0, [], 1)
442 logging.debug("probleme partition face pipe, contournement avec MakeSection")
444 for pipext in pipexts:
445 sections.append(geompy.MakeSection(facesOnside[0], pipext))
446 partitionPeauByPipe = geompy.MakePartition(facesAndFond, sections, [], [], geompy.ShapeType["FACE"], 0, [], 1)
448 # contrôle edge en trop sur edges circulaires
449 if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
452 facesPeau = geompy.ExtractShapes(partitionPeauByPipe, geompy.ShapeType["FACE"], False)
453 facesPeauSorted, minsur, maxsurf = sortFaces(facesPeau)
454 for i, face in enumerate(facesPeauSorted[:-1]): # on ne teste que la ou les petites faces "circulaires"
455 nbv = geompy.NumberOfEdges(face)
456 logging.debug("nombre d'edges sur face circulaire: %s", nbv)
458 edgeEnTrop.append(True) # TODO : distinguer les cas avec deux faces circulaires dont l'une est correcte
460 edgeEnTrop.append(False)
461 refaire = sum(edgeEnTrop)
463 dc = [(geompy.MinDistance(verticesEdgesFondIn[0], fac), i) for i, fac in enumerate(facesPeauSorted[:-1])]
465 logging.debug("dc sorted: %s", dc)
466 i0 = dc[0][1] # indice de facesPeauSorted qui correspond à verticesEdgesFondIn[0], donc 0 pour cercles
468 for i, bad in enumerate(edgeEnTrop):
474 outilPart[j] = geompy.MakeProjection(cercles[j],facesOnside[0])
476 partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, [], [], geompy.ShapeType["FACE"], 0, [], 1)
479 name="partitionPeauByPipe%d"%ifil
480 geompy.addToStudy(partitionPeauByPipe, name)
481 [edgesPeauFondIn, edgesPeauFondOut, edgesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "EDGE", 1.e-3)
482 [facesPeauFondIn, facesPeauFondOut, facesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "FACE", 1.e-3)
484 if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
485 facesPeauSorted, minsur, maxsurf = sortFaces(facesPeauFondOn)
486 facePeau = facesPeauSorted[-1] # la plus grande face
488 facePeau =geompy.MakePartition(facesPeauFondOn, [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
489 name="facePeau%d"%ifil
490 geompy.addToStudy(facePeau, name)
492 facesPipePeau = [None for i in range(len(edgesFissExtPipe))]
493 endsEdgeFond = [None for i in range(len(edgesFissExtPipe))]
494 edgeRadFacePipePeau = [None for i in range(len(edgesFissExtPipe))]
498 verticesCircPeau = []
499 if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
501 for face in facesPeauSorted[:-1]: # la ou les faces débouchantes, pas la grande face de peau
502 logging.debug("examen face debouchante circulaire")
503 for i,efep in enumerate(edgesFissExtPipe):
504 dist = geompy.MinDistance(face, efep)
505 logging.debug(" distance face circulaire edge %s", dist)
507 for ik, edpfi in enumerate(edgesPeauFondIn):
508 if geompy.MinDistance(face, edpfi) < 1e-3:
510 sharedVertices = geompy.GetSharedShapesMulti([face, edgesPeauFondIn[ik]], geompy.ShapeType["VERTEX"])
511 nameFace = "facePipePeau%d"%i
512 nameVert = "endEdgeFond%d"%i
513 nameEdge = "edgeRadFacePipePeau%d"%i
514 facesPipePeau[i] = face
515 endsEdgeFond[i] = sharedVertices[0]
516 geompy.addToStudy(face, nameFace)
517 geompy.addToStudy(sharedVertices[0], nameVert)
518 edgesFace = geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], True)
519 for edge in edgesFace:
520 if geompy.MinDistance(edge, sharedVertices[0]) < 1e-3:
521 edgeRadFacePipePeau[i] = edge
522 geompy.addToStudy(edge, nameEdge)
529 # --- edges circulaires de la face de peau et points de jonction de la face externe de fissure
530 logging.debug("facesPipePeau: %s", facesPipePeau)
531 edgesCircPeau = [None for i in range(len(facesPipePeau))]
532 verticesCircPeau = [None for i in range(len(facesPipePeau))]
533 for i,fcirc in enumerate(facesPipePeau):
534 edges = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["EDGE"])
535 grpEdgesCirc = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
536 geompy.UnionList(grpEdgesCirc, edges)
537 edgesCircPeau[i] = grpEdgesCirc
538 name = "edgeCirc%d"%i
539 geompy.addToStudyInFather(facePeau, grpEdgesCirc, name)
540 edgesListees = edgesListees + edges
541 vertices = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["VERTEX"])
542 grpVertCircPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["VERTEX"])
543 geompy.UnionList(grpVertCircPeau, vertices)
544 verticesCircPeau[i] = grpVertCircPeau
545 name = "pointEdgeCirc%d"%i
546 geompy.addToStudyInFather(facePeau, grpVertCircPeau, name)
548 pass # --- au moins une extrémité du pipe sur cette face de peau
550 # --- edges de bord de la face de peau
552 edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
554 for i, edge in enumerate(edgesFilling):
555 edgepeau = geompy.GetInPlace(facePeau, edge)
556 name = "edgepeau%d"%i
557 geompy.addToStudyInFather(facePeau,edgepeau, name)
558 logging.debug("edgepeau %s", geompy.ShapeInfo(edgepeau))
559 if geompy.ShapeInfo(edgepeau)['EDGE'] > 1:
560 logging.debug(" EDGES multiples")
561 edgs = geompy.ExtractShapes(edgepeau, geompy.ShapeType["EDGE"], False)
565 logging.debug(" EDGE")
566 edgesBords.append(edgepeau)
567 edgesListees.append(edgepeau)
568 groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
569 geompy.UnionList(groupEdgesBordPeau, edgesBords)
571 if aretesVivesC is not None:
572 bordsVifs = geompy.GetInPlace(facePeau, aretesVivesC)
573 if bordsVifs is not None:
574 geompy.addToStudyInFather(facePeau, bordsVifs, "bordsVifs")
575 groupEdgesBordPeau = geompy.CutGroups(groupEdgesBordPeau, bordsVifs)
577 if len(aretesVivesCoupees) > 0:
578 grpC = geompy.MakeCompound(aretesVivesCoupees)
579 grptmp = geompy.GetInPlace(facePeau, grpC)
580 if grptmp is not None:
581 grpnew = geompy.CutGroups(bordsVifs, grptmp) # ce qui est nouveau dans bordsVifs
584 if grpnew is not None:
585 edv = geompy.ExtractShapes(grpnew, geompy.ShapeType["EDGE"], False)
586 aretesVivesCoupees += edv
587 logging.debug("aretesVivesCoupees %s",aretesVivesCoupees)
588 geompy.addToStudyInFather(facePeau, groupEdgesBordPeau , "EdgesBords")
590 # --- edges de la face de peau partagées avec la face de fissure
592 edgesPeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
593 edges = substractSubShapes(facePeau, edgesPeau, edgesListees)
594 edgesFissurePeau = []
595 if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
596 edgesFissurePeau = [None for i in range(len(verticesCircPeau))] # edges associés aux extrémités du pipe, en premier
598 for i, grpVert in enumerate(verticesCircPeau):
599 if (geompy.MinDistance(grpVert, edge) < 1.e-3) and (edge not in edgesFissurePeau):
600 edgesFissurePeau[i] = edge
601 name = "edgeFissurePeau%d"%i
602 geompy.addToStudyInFather(facePeau, edge, name)
603 for edge in edges: # on ajoute après les edges manquantes
604 if edge not in edgesFissurePeau:
605 edgesFissurePeau.append(edge)
607 for i, edge in enumerate(edges):
608 edgesFissurePeau.append(edge)
609 name = "edgeFissurePeau%d"%i
610 geompy.addToStudyInFather(facePeau, edge, name)
613 ptEdgeFond[ifil] = endsEdgeFond # pour chaque face [points edge fond de fissure aux débouchés du pipe]
614 fsPipePeau[ifil] = facesPipePeau # pour chaque face [faces du pipe débouchantes]
615 edRadFPiPo[ifil] = edgeRadFacePipePeau # pour chaque face [edge radiale des faces du pipe débouchantes ]
616 fsFissuExt[ifil] = facesFissExt # pour chaque face [faces de fissure externes au pipe]
617 edFisExtPe[ifil] = edgesFissExtPeau # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
618 edFisExtPi[ifil] = edgesFissExtPipe # pour chaque face [edge commun au pipe des faces de fissure externes]
619 facesPeaux[ifil] = facePeau # pour chaque face : la face de peau finale a mailler (percee des faces débouchantes)
620 edCircPeau[ifil] = edgesCircPeau # pour chaque face de peau : [groupe subshapes edges circulaires aux débouchés du pipe]
621 ptCircPeau[ifil] = verticesCircPeau # pour chaque face de peau : [groupe subshapes points sur edges circulaires aux débouchés du pipe]
622 gpedgeBord[ifil] = groupEdgesBordPeau # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
623 gpedgeVifs[ifil] = bordsVifs # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
624 edFissPeau[ifil] = edgesFissurePeau # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
625 ptFisExtPi[ifil] = verticesPipePeau # pour chaque face de peau : [point commun edFissPeau edCircPeau]
627 # -----------------------------------------------------------------------
628 # fin de la boucle sur les faces de filling
629 # -----------------------------------------------------------------------
631 for i, avc in enumerate(aretesVivesCoupees):
632 name = "areteViveCoupee%d"%i
633 geompy.addToStudy(avc, name)
635 # --- identification des faces et edges de fissure externe pour maillage
638 edgesFissExtPeau = []
639 edgesFissExtPipe = []
640 for ifil in range(nbFacesFilling): # TODO: éliminer les doublons (comparer tous les vertices triés, avec mesure de distance ?)
641 facesFissExt += fsFissuExt[ifil]
642 edgesFissExtPeau += edFisExtPe[ifil]
643 edgesFissExtPipe += edFisExtPi[ifil]
644 logging.debug("---------------------------- identification faces de fissure externes au pipe :%s ", len(facesFissExt))
645 # regroupement des faces de fissure externes au pipe.
647 if len(facesFissExt) > 1:
648 faceFissureExterne = geompy.MakePartition(facesFissExt, [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
649 edgesPipeFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesPipeFiss)) # edgesFissExtPipe peut ne pas couvrir toute la longueur
650 # edgesPeauFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesFissExtPeau))
651 # il peut manquer des edges de faceFissureExterne en contact avec la peau dans edgesFissExtPeau
652 (isDone, closedFreeBoundaries, openFreeBoundaries) = geompy.GetFreeBoundary(faceFissureExterne)
654 for bound in closedFreeBoundaries:
655 edgesBordFFE += geompy.ExtractShapes(bound, geompy.ShapeType["EDGE"], False)
656 edgesBordFFEid = [ (ed,geompy.GetSubShapeID(faceFissureExterne, ed)) for ed in edgesBordFFE]
657 logging.debug("edgesBordFFEid %s", edgesBordFFEid)
658 edgesPPE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
659 edgesPPEid = [ geompy.GetSubShapeID(faceFissureExterne, ed) for ed in edgesPPE]
660 logging.debug("edgesPPEid %s", edgesPPEid)
661 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
662 logging.debug("edgesPFE %s", edgesPFE)
663 edgesPeauFissureExterneC = geompy.MakeCompound(edgesPFE)
665 faceFissureExterne = facesFissExt[0]
666 edgesPeauFissureExterneC = geompy.MakeCompound(edgesFissExtPeau)
667 edgesPipeFissureExterneC = geompy.MakeCompound(edgesFissExtPipe)
668 wirePipeFissureExterne = geompy.MakeWire(geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False))
669 geompy.addToStudy(faceFissureExterne, "faceFissureExterne")
670 geompy.addToStudyInFather(faceFissureExterne, edgesPeauFissureExterneC, "edgesPeauFissureExterne")
671 geompy.addToStudyInFather(faceFissureExterne, edgesPipeFissureExterneC, "edgesPipeFissureExterne")
673 logging.debug("---------------------------- Preparation Maillage du Pipe --------------")
674 # -----------------------------------------------------------------------
675 # --- preparation maillage du pipe :
676 # - détections des points a respecter : jonction des edges/faces constituant
677 # la face de fissure externe au pipe
678 # - points sur les edges de fond de fissure et edges pipe/face fissure,
679 # - vecteurs tangents au fond de fissure (normal au disque maillé)
681 # --- option de maillage selon le rayon de courbure du fond de fissure
683 for edff in edgesFondFiss:
684 lenEdgeFondExt += geompy.BasicProperties(edff)[0]
687 for filling in facesDefaut:
688 disfond.append(geompy.MinDistance(centreFondFiss, filling))
691 nbSegQuart = 5 # on veut 5 segments min sur un quart de cercle
692 alpha = math.pi/(4*nbSegQuart)
693 deflexion = rcourb*(1.0 -math.cos(alpha))
694 lgmin = lenSegPipe*0.25
695 lgmax = lenSegPipe*1.5
696 logging.debug("rcourb: %s, lenFond:%s, deflexion: %s, lgmin: %s, lgmax: %s", rcourb, lenEdgeFondExt, deflexion, lgmin, lgmax)
698 meshFondExt = smesh.Mesh(wireFondFiss)
699 algo1d = meshFondExt.Segment()
700 hypo1d = algo1d.Adaptive(lgmin, lgmax, deflexion) # a ajuster selon la profondeur de la fissure
701 isDone = meshFondExt.Compute()
703 ptGSdic = {} # dictionnaire [paramètre sur la courbe] --> point géométrique
704 allNodeIds = meshFondExt.GetNodesId()
705 for nodeId in allNodeIds:
706 xyz = meshFondExt.GetNodeXYZ(nodeId)
707 #logging.debug("nodeId %s, coords %s", nodeId, str(xyz))
708 pt = geompy.MakeVertex(xyz[0], xyz[1], xyz[2])
709 u, PointOnEdge, EdgeInWireIndex = geompy.MakeProjectionOnWire(pt, wireFondFiss) # u compris entre 0 et 1
710 edgeOrder = edgesIdByOrientation[EdgeInWireIndex]
711 ptGSdic[(edgeOrder, EdgeInWireIndex, u)] = pt
712 #logging.debug("nodeId %s, u %s", nodeId, str(u))
713 usort = sorted(ptGSdic)
714 logging.debug("nombre de points obtenus par deflexion %s",len(usort))
722 vertcx = ptGSdic[edu]
723 norm = geompy.MakeTangentOnCurve(edgesFondFiss[ied], u)
724 plan = geompy.MakePlane(vertcx, norm, 3*rayonPipe)
725 part = geompy.MakePartition([plan], [wirePipeFiss], [], [], geompy.ShapeType["VERTEX"], 0, [], 0)
726 liste = geompy.ExtractShapes(part, geompy.ShapeType["VERTEX"], True)
727 if len(liste) == 5: # 4 coins du plan plus intersection recherchée
729 if geompy.MinDistance(point, vertcx) < 1.1*rayonPipe: # les quatre coins sont plus loin
732 centres.append(vertcx)
733 origins.append(vertpx)
735 # name = "vertcx%d"%i
736 # geompy.addToStudyInFather(wireFondFiss, vertcx, name)
737 # name = "vertpx%d"%i
738 # geompy.addToStudyInFather(wireFondFiss, vertpx, name)
740 # geompy.addToStudyInFather(wireFondFiss, plan, name)
742 # --- maillage du pipe étendu, sans tenir compte de l'intersection avec la face de peau
744 logging.debug("nbsegCercle %s", nbsegCercle)
746 # -----------------------------------------------------------------------
747 # --- points géométriques
749 gptsdisks = [] # vertices géométrie de tous les disques
750 raydisks = [[] for i in range(nbsegCercle)]
751 for i in range(len(centres)): # boucle sur les disques
752 gptdsk = [] # vertices géométrie d'un disque
756 vec1 = geompy.MakeVector(vertcx, vertpx)
758 points = [vertcx] # les points du rayon de référence
759 for j in range(nbsegRad):
760 pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, (j+1)*float(rayonPipe)/nbsegRad)
762 gptdsk.append(points)
763 pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, 1.5*rayonPipe)
764 rayon = geompy.MakeLineTwoPnt(vertcx, pt)
765 raydisks[0].append(rayon)
767 for k in range(nbsegCercle-1):
768 angle = (k+1)*2*math.pi/nbsegCercle
769 pts = [vertcx] # les points d'un rayon obtenu par rotation
770 for j in range(nbsegRad):
771 pt = geompy.MakeRotation(points[j+1], normal, angle)
774 ray = geompy.MakeRotation(rayon, normal, angle)
775 raydisks[k+1].append(ray)
777 gptsdisks.append(gptdsk)
779 # -----------------------------------------------------------------------
780 # --- recherche des points en trop (externes au volume à remailler)
781 # - on associe chaque extrémité du pipe à une face filling
782 # - on part des disques aux extrémités du pipe
783 # - pour chaque disque, on prend les vertices de géométrie,
784 # on marque leur position relative à la face.
785 # - on s'arrete quand tous les noeuds sont dedans
787 logging.debug("---------------------------- recherche des points du pipe a éliminer --------------")
791 idFillingFromBout = [None, None] # contiendra l'index du filling pour les extrémités 0 et 1
792 for ifil in range(nbFacesFilling):
793 for ipt, pt in enumerate(ptEdgeFond[ifil]): # il y a un ou deux points débouchant sur cette face
794 if geompy.MinDistance(pt,pt0) < geompy.MinDistance(pt,pt1): # TODO: trouver plus fiable pour les cas tordus...
795 idFillingFromBout[0] = ifil
797 idFillingFromBout[1] = ifil
798 logging.debug("association bouts du pipe - faces de filling: %s", idFillingFromBout)
801 edgeRadFacePipePeau = []
802 for ifil in range(nbFacesFilling):
803 facesPipePeau += fsPipePeau[ifil]
804 edgeRadFacePipePeau += edRadFPiPo[ifil]
806 logging.debug("recherche des disques de noeuds complètement internes")
807 idisklim = [] # indices des premier et dernier disques internes
808 idiskout = [] # indices des premier et dernier disques externes
809 for bout in range(2):
815 idisk = len(gptsdisks)
817 numout = len(gptsdisks)
822 logging.debug("examen disque %s", idisk)
823 gptdsk = gptsdisks[idisk]
825 for k in range(nbsegCercle):
827 for j, pt in enumerate(points):
828 side = whichSideVertex(facesDefaut[idFillingFromBout[bout]], pt)
830 if outside: # premier point detecté dedans
832 numout = idisk -inc # le disque précédent était dehors
834 inside = False # ce point est dehors
835 if not inside and not outside:
837 idisklim.append(idisk) # premier et dernier disques internes
838 idiskout.append(numout) # premier et dernier disques externes
840 # --- listes de nappes radiales en filling à chaque extrémité débouchante
841 facesDebouchantes = [False, False]
842 idFacesDebouchantes = [-1, -1] # contiendra les indices des faces disque débouchantes (facesPipePeau)
844 for i, idisk in enumerate(idisklim):
846 logging.debug("extremité %s, indices disques interne %s, externe %s",i, idisk, numout)
848 if (idisk != 0) and (idisk != len(gptsdisks)-1): # si extrémité débouchante
849 for k in range(nbsegCercle):
851 iddeb = max(0, numout)
852 idfin = max(iddeb+3,idisk+1) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
853 #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
854 comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
855 name='compoundRay%d'%k
856 geompy.addToStudy(comp, name)
858 idfin = min(len(gptsdisks), numout+1)
859 iddeb = min(idfin-3, idisk) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
860 #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
861 comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
862 name='compoundRay%d'%k
863 geompy.addToStudy(comp, name)
864 nappe = geompy.MakeFilling(comp, 2, 5, 0.0001, 0.0001, 0, GEOM.FOM_Default)
867 geompy.addToStudy(nappe, name)
868 facesDebouchantes[i] = True
869 listNappes.append(nappes)
871 # --- mise en correspondance avec les indices des faces disque débouchantes (facesPipePeau)
872 for i, nappes in enumerate(listNappes):
873 if facesDebouchantes[i]:
874 for k, face in enumerate(facesPipePeau):
875 edge = geompy.MakeSection(face, nappes[0])
876 if geompy.NbShapes(edge, geompy.ShapeType["EDGE"]) > 0:
877 idFacesDebouchantes[i] = k
879 logging.debug("idFacesDebouchantes: %s", idFacesDebouchantes)
881 # --- construction des listes d'edges radiales sur chaque extrémité débouchante
883 for i, nappes in enumerate(listNappes):
884 id = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
888 face = facesPipePeau[id]
889 edges = [edgeRadFacePipePeau[id]]
890 for k, nappe in enumerate(nappes):
892 obj = geompy.MakeSection(face, nappes[k]) # normalement une edge, parfois un compound d'edges dont un tout petit
894 vs = geompy.ExtractShapes(obj, geompy.ShapeType["VERTEX"], False)
896 eds = geompy.ExtractShapes(obj, geompy.ShapeType["EDGE"], False)
897 [edsorted, minl,maxl] = sortEdges(eds)
900 maxl = geompy.BasicProperties(edge)[0]
901 if maxl < 0.01: # problème MakeSection
902 logging.debug("problème MakeSection recherche edge radiale %s, longueur trop faible: %s, utilisation partition", k, maxl)
903 partNappeFace = geompy.MakePartition([face, nappes[k]], [] , [], [], geompy.ShapeType["FACE"], 0, [], 0)
904 edps= geompy.ExtractShapes(partNappeFace, geompy.ShapeType["EDGE"], False)
906 for ii, ed in enumerate(edps):
907 vxs = geompy.ExtractShapes(ed, geompy.ShapeType["VERTEX"], False)
908 distx = [geompy.MinDistance(vx, face) for vx in vxs]
909 distx += [geompy.MinDistance(vx, nappes[k]) for vx in vxs]
911 logging.debug(" dmax %s",dmax)
914 logging.debug(" edges issues de la partition: %s", ednouv)
915 for ii, ed in enumerate(ednouv):
916 geompy.addToStudy(ed, "ednouv%d"%ii)
917 [edsorted, minl,maxl] = sortEdges(ednouv)
918 logging.debug(" longueur edge trouvée: %s", maxl)
921 name = 'edgeEndPipe%d'%k
922 geompy.addToStudy(edge, name)
923 listEdges.append(edges)
925 # --- création des points du maillage du pipe sur la face de peau
926 for i, edges in enumerate(listEdges):
927 id = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
930 if id > 0: # id vaut 0 ou 1
931 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)
932 centre = ptEdgeFond[idFillingFromBout[i]][id]
934 geompy.addToStudy(centre, name)
935 vertPipePeau = ptFisExtPi[idFillingFromBout[i]][id]
936 geompy.addToStudyInFather(centre, vertPipePeau, "vertPipePeau")
937 grpsEdgesCirc = edCircPeau[idFillingFromBout[i]] # liste de groupes
939 for grpEdgesCirc in grpsEdgesCirc:
940 edgesCirc += geompy.ExtractShapes(grpEdgesCirc, geompy.ShapeType["EDGE"], False)
941 for k, edge in enumerate(edges):
942 extrems = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], True)
943 if geompy.MinDistance(centre, extrems[0]) < geompy.MinDistance(centre, extrems[1]):
947 # ajustement du point extrémité (bout) sur l'edge circulaire en face de peau
948 logging.debug("edgesCirc: %s", edgesCirc)
949 distEdgeCirc = [(geompy.MinDistance(bout, edgeCirc), k2, edgeCirc) for k2, edgeCirc in enumerate(edgesCirc)]
951 logging.debug("distEdgeCirc: %s", distEdgeCirc)
952 u = projettePointSurCourbe(bout, distEdgeCirc[0][2])
953 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.
954 extrCircs = geompy.ExtractShapes(distEdgeCirc[0][2], geompy.ShapeType["VERTEX"], True)
955 if geompy.MinDistance(bout, extrCircs[0]) < geompy.MinDistance(bout, extrCircs[1]):
961 bout = geompy.MakeVertexOnCurve(distEdgeCirc[0][2], u)
963 geompy.addToStudyInFather(centre, bout, name)
964 # enregistrement des points dans la structure
966 for j in range(nbsegRad +1):
967 u = j/float(nbsegRad)
968 points.append(geompy.MakeVertexOnCurve(edge, u))
969 if geompy.MinDistance(bout, points[0]) < geompy.MinDistance(centre, points[0]):
973 gptdsk.append(points)
975 gptsdisks[idisklim[0] -1] = gptdsk
976 idisklim[0] = idisklim[0] -1
978 gptsdisks[idisklim[1] +1] = gptdsk
979 idisklim[1] = idisklim[1] +1
981 # --- ajustement precis des points sur edgesPipeFissureExterneC
983 edgesPFE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
984 verticesPFE = findWireIntermediateVertices(wirePipeFissureExterne) # vertices intermédiaires (des points en trop dans ptsInWireFissExtPipe)
985 idiskmin = idisklim[0] + 1 # on ne prend pas le disque sur la peau, déjà ajusté
986 idiskmax = idisklim[1] # on ne prend pas le disque sur la peau, déjà ajusté
988 for vtx in verticesPFE:
990 for idisk in range(idiskmin, idiskmax):
991 gptdsk = gptsdisks[idisk]
992 pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe
993 distPtVt.append((geompy.MinDistance(pt, vtx), idisk))
995 idiskint.append(distPtVt[0][1])
996 gptsdisks[idiskint[-1]][0][-1] = vtx
997 logging.debug("ajustement point sur edgePipeFissureExterne, vertex: %s %s", idiskint[-1], distPtVt[0][0])
998 for idisk in range(idiskmin, idiskmax):
999 if idisk in idiskint:
1001 logging.debug("ajustement point sur edgePipeFissureExterne: %s", idisk)
1002 gptdsk = gptsdisks[idisk]
1003 pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe
1004 distPtEd = [(geompy.MinDistance(pt, edgePFE), k, edgePFE) for k, edgePFE in enumerate(edgesPFE)]
1006 edgePFE = distPtEd[0][2]
1007 u = projettePointSurCourbe(pt, edgePFE)
1008 ptproj = geompy.MakeVertexOnCurve(edgePFE, u)
1009 gptsdisks[idisk][0][-1] = ptproj
1011 # -----------------------------------------------------------------------
1012 # --- maillage effectif du pipe
1014 logging.debug("---------------------------- maillage effectif du pipe --------------")
1015 meshPipe = smesh.Mesh(None, "meshPipe")
1016 fondFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "FONDFISS")
1017 nodesFondFissGroup = meshPipe.CreateEmptyGroup(SMESH.NODE, "nfondfis")
1018 faceFissGroup = meshPipe.CreateEmptyGroup(SMESH.FACE, "fisInPi")
1019 edgeFaceFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeFaceFiss")
1020 edgeCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe0")
1021 edgeCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe1")
1022 faceCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe0")
1023 faceCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe1")
1024 mptsdisks = [] # vertices maillage de tous les disques
1025 mEdges = [] # identifiants edges maillage fond de fissure
1026 mEdgeFaces = [] # identifiants edges maillage edge face de fissure externe
1027 mFaces = [] # identifiants faces maillage fissure
1028 mVols = [] # identifiants volumes maillage pipe
1031 for idisk in range(idisklim[0], idisklim[1]+1): # boucle sur les disques internes
1033 # -----------------------------------------------------------------------
1036 gptdsk = gptsdisks[idisk]
1037 if idisk > idisklim[0]:
1039 mptdsk = [] # vertices maillage d'un disque
1040 for k in range(nbsegCercle):
1043 for j, pt in enumerate(points):
1044 if j == 0 and k > 0:
1047 coords = geompy.PointCoordinates(pt)
1048 id = meshPipe.AddNode(coords[0], coords[1], coords[2])
1050 mptdsk.append(mptids)
1051 mptsdisks.append(mptdsk)
1053 # -----------------------------------------------------------------------
1054 # --- groupes edges cercles debouchants
1056 if idisk == idisklim[0]:
1058 for k in range(nbsegCercle):
1059 pts.append(mptdsk[k][-1])
1061 for k in range(len(pts)):
1063 idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
1064 edges.append(idEdge)
1065 edgeCircPipe0Group.Add(edges)
1067 if idisk == idisklim[1]:
1069 for k in range(nbsegCercle):
1070 pts.append(mptdsk[k][-1])
1072 for k in range(len(pts)):
1074 idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
1075 edges.append(idEdge)
1076 edgeCircPipe1Group.Add(edges)
1078 # -----------------------------------------------------------------------
1079 # --- groupes faces debouchantes
1081 if idisk == idisklim[0]:
1083 for j in range(nbsegRad):
1084 for k in range(nbsegCercle):
1086 if k == nbsegCercle-1:
1089 idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
1091 idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
1093 faceCircPipe0Group.Add(faces)
1095 if idisk == idisklim[1]:
1097 for j in range(nbsegRad):
1098 for k in range(nbsegCercle):
1100 if k == nbsegCercle-1:
1103 idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
1105 idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
1107 faceCircPipe1Group.Add(faces)
1109 # -----------------------------------------------------------------------
1110 # --- mailles volumiques, groupes noeuds et edges de fond de fissure, groupe de face de fissure
1112 if idisk == idisklim[0]:
1114 mEdgeFaces.append(0)
1117 nodesFondFissGroup.Add([mptdsk[0][0]])
1119 ide = meshPipe.AddEdge([oldmpts[0][0], mptdsk[0][0]])
1121 fondFissGroup.Add([ide])
1122 nodesFondFissGroup.Add([mptdsk[0][0]])
1123 ide2 = meshPipe.AddEdge([oldmpts[0][-1], mptdsk[0][-1]])
1124 mEdgeFaces.append(ide2)
1125 edgeFaceFissGroup.Add([ide2])
1129 for j in range(nbsegRad):
1130 idf = meshPipe.AddFace([oldmpts[0][j], mptdsk[0][j], mptdsk[0][j+1], oldmpts[0][j+1]])
1131 faceFissGroup.Add([idf])
1135 for k in range(nbsegCercle):
1137 if k == nbsegCercle-1:
1140 idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1],
1141 oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1]])
1143 idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j],
1144 oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1], oldmpts[k1][j]])
1145 idVolCercle.append(idv)
1146 idVols.append(idVolCercle)
1148 mFaces.append(idFaces)
1149 mVols.append(idVols)
1151 pipeFissGroup = meshPipe.CreateEmptyGroup( SMESH.VOLUME, 'PIPEFISS' )
1152 nbAdd = pipeFissGroup.AddFrom( meshPipe.GetMesh() )
1154 nb, new_mesh, new_group = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries")
1155 edgesCircPipeGroup = [edgeCircPipe0Group, edgeCircPipe1Group]
1157 # --- fin du maillage du pipe
1158 # -----------------------------------------------------------------------
1159 # --- edges de bord, faces défaut à respecter
1161 aFilterManager = smesh.CreateFilterManager()
1162 nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ])
1164 unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
1165 criteres.append(unCritere)
1166 filtre = smesh.GetFilterFromCriteria(criteres)
1167 bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
1168 smesh.SetName(bordsLibres, 'bordsLibres')
1170 # --- pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
1171 # on désigne les faces de peau en quadrangles par le groupe "skinFaces"
1173 skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
1174 nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
1176 # --- maillage des éventuelles arêtes vives entre faces reconstruites
1178 if len(aretesVivesCoupees) > 0:
1179 aretesVivesC = geompy.MakeCompound(aretesVivesCoupees)
1180 meshAretesVives = smesh.Mesh(aretesVivesC)
1181 algo1d = meshAretesVives.Segment()
1182 hypo1d = algo1d.LocalLength(dmoyen,[],1e-07)
1183 putName(algo1d.GetSubMesh(), "aretesVives")
1184 putName(algo1d, "algo1d_aretesVives")
1185 putName(hypo1d, "hypo1d_aretesVives")
1186 isDone = meshAretesVives.Compute()
1187 logging.info("aretesVives fini")
1188 grpAretesVives = meshAretesVives.CreateEmptyGroup( SMESH.EDGE, 'grpAretesVives' )
1189 nbAdd = grpAretesVives.AddFrom( meshAretesVives.GetMesh() )
1191 # -----------------------------------------------------------------------
1192 # --- maillage faces de fissure
1194 logging.debug("---------------------------- maillage faces de fissure externes au pipe :%s --------------", len(facesFissExt))
1196 meshFaceFiss = smesh.Mesh(faceFissureExterne)
1197 algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_1D2D)
1198 hypo2d = algo2d.Parameters()
1199 hypo2d.SetMaxSize( areteFaceFissure )
1200 hypo2d.SetSecondOrder( 0 )
1201 hypo2d.SetOptimize( 1 )
1202 hypo2d.SetFineness( 2 )
1203 hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
1204 hypo2d.SetQuadAllowed( 0 )
1205 putName(algo2d.GetSubMesh(), "faceFiss")
1206 putName(algo2d, "algo2d_faceFiss")
1207 putName(hypo2d, "hypo2d_faceFiss")
1209 algo1d = meshFaceFiss.UseExisting1DElements(geom=edgesPipeFissureExterneC)
1210 hypo1d = algo1d.SourceEdges([ edgeFaceFissGroup ],0,0)
1211 putName(algo1d.GetSubMesh(), "edgeFissPeau")
1212 putName(algo1d, "algo1d_edgeFissPeau")
1213 putName(hypo1d, "hypo1d_edgeFissPeau")
1215 isDone = meshFaceFiss.Compute()
1216 logging.info("meshFaceFiss fini")
1218 grpFaceFissureExterne = meshFaceFiss.GroupOnGeom(faceFissureExterne, "fisOutPi", SMESH.FACE)
1219 grpEdgesPeauFissureExterne = meshFaceFiss.GroupOnGeom(edgesPeauFissureExterneC,'edgesPeauFissureExterne',SMESH.EDGE)
1220 grpEdgesPipeFissureExterne = meshFaceFiss.GroupOnGeom(edgesPipeFissureExterneC,'edgesPipeFissureExterne',SMESH.EDGE)
1222 # --- maillage faces de peau
1224 boutFromIfil = [None for i in range(nbFacesFilling)]
1225 if idFillingFromBout[0] != idFillingFromBout[1]: # repérage des extremites du pipe quand elles débouchent sur des faces différentes
1226 boutFromIfil[idFillingFromBout[0]] = 0
1227 boutFromIfil[idFillingFromBout[1]] = 1
1229 logging.debug("---------------------------- maillage faces de peau --------------")
1230 meshesFacesPeau = []
1231 for ifil in range(nbFacesFilling):
1233 if partitionsPeauFissFond[ifil] is None: # face de peau maillage sain intacte
1235 # --- edges de bord de la face de filling
1236 filling = facesDefaut[ifil]
1237 edgesFilling = geompy.ExtractShapes(filling, geompy.ShapeType["EDGE"], False)
1238 groupEdgesBordPeau = geompy.CreateGroup(filling, geompy.ShapeType["EDGE"])
1239 geompy.UnionList(groupEdgesBordPeau, edgesFilling)
1240 geompy.addToStudyInFather(filling, groupEdgesBordPeau , "EdgesBords")
1242 meshFacePeau = smesh.Mesh(facesDefaut[ifil])
1244 algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
1245 hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
1246 putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
1247 putName(algo1d, "algo1d_bordsLibres", ifil)
1248 putName(hypo1d, "hypo1d_bordsLibres", ifil)
1252 facePeau = facesPeaux[ifil] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
1253 edgesCircPeau = edCircPeau[ifil] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
1254 verticesCircPeau = ptCircPeau[ifil] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
1255 groupEdgesBordPeau = gpedgeBord[ifil] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
1256 bordsVifs = gpedgeVifs[ifil] # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
1257 edgesFissurePeau = edFissPeau[ifil] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
1259 meshFacePeau = smesh.Mesh(facePeau)
1261 algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
1262 hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
1263 putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
1264 putName(algo1d, "algo1d_bordsLibres", ifil)
1265 putName(hypo1d, "hypo1d_bordsLibres", ifil)
1267 algo1d = meshFacePeau.UseExisting1DElements(geom=geompy.MakeCompound(edgesFissurePeau))
1268 hypo1d = algo1d.SourceEdges([ grpEdgesPeauFissureExterne ],0,0)
1269 putName(algo1d.GetSubMesh(), "edgePeauFiss", ifil)
1270 putName(algo1d, "algo1d_edgePeauFiss", ifil)
1271 putName(hypo1d, "hypo1d_edgePeauFiss", ifil)
1273 if bordsVifs is not None:
1274 algo1d = meshFacePeau.UseExisting1DElements(geom=bordsVifs)
1275 hypo1d = algo1d.SourceEdges([ grpAretesVives ],0,0)
1276 putName(algo1d.GetSubMesh(), "bordsVifs", ifil)
1277 putName(algo1d, "algo1d_bordsVifs", ifil)
1278 putName(hypo1d, "hypo1d_bordsVifs", ifil)
1280 for i, edgeCirc in enumerate(edgesCircPeau):
1281 if edgeCirc is not None:
1282 algo1d = meshFacePeau.UseExisting1DElements(geom=edgeCirc)
1283 if boutFromIfil[ifil] is None:
1284 hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[i] ],0,0)
1286 hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[boutFromIfil[ifil]] ],0,0)
1288 putName(algo1d.GetSubMesh(), name, ifil)
1289 putName(algo1d, "algo1d_" + name, ifil)
1290 putName(hypo1d, "hypo1d_" + name, ifil)
1292 algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_1D2D)
1293 hypo2d = algo2d.Parameters()
1294 hypo2d.SetMaxSize( dmoyen )
1295 hypo2d.SetOptimize( 1 )
1296 hypo2d.SetFineness( 2 )
1297 hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
1298 hypo2d.SetQuadAllowed( 0 )
1299 putName(algo2d.GetSubMesh(), "facePeau", ifil)
1300 putName(algo2d, "algo2d_facePeau", ifil)
1301 putName(hypo2d, "hypo2d_facePeau", ifil)
1303 isDone = meshFacePeau.Compute()
1304 logging.info("meshFacePeau %d fini", ifil)
1305 GroupFaces = meshFacePeau.CreateEmptyGroup( SMESH.FACE, "facePeau%d"%ifil )
1306 nbAdd = GroupFaces.AddFrom( meshFacePeau.GetMesh() )
1307 meshesFacesPeau.append(meshFacePeau)
1309 # --- regroupement des maillages du défaut
1311 listMeshes = [internalBoundary.GetMesh(),
1313 meshFaceFiss.GetMesh()]
1314 for mp in meshesFacesPeau:
1315 listMeshes.append(mp.GetMesh())
1317 meshBoiteDefaut = smesh.Concatenate(listMeshes, 1, 1, 1e-05,False)
1318 # pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
1319 # on désigne les faces de peau en quadrangles par le groupe "skinFaces"
1320 group_faceFissOutPipe = None
1321 group_faceFissInPipe = None
1322 groups = meshBoiteDefaut.GetGroups()
1324 if grp.GetType() == SMESH.FACE:
1325 #if "internalBoundary" in grp.GetName():
1326 # grp.SetName("skinFaces")
1327 if grp.GetName() == "fisOutPi":
1328 group_faceFissOutPipe = grp
1329 elif grp.GetName() == "fisInPi":
1330 group_faceFissInPipe = grp
1332 # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
1335 algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
1337 algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
1338 hypo3d = algo3d.MaxElementVolume(1000.0)
1339 putName(algo3d.GetSubMesh(), "boiteDefaut")
1340 putName(algo3d, "algo3d_boiteDefaut")
1341 isDone = meshBoiteDefaut.Compute()
1342 putName(meshBoiteDefaut, "boiteDefaut")
1343 logging.info("meshBoiteDefaut fini")
1345 faceFissure = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
1346 maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin,
1347 zoneDefaut_internalFaces, zoneDefaut_internalEdges)
1348 putName(maillageSain, nomFicSain+"_coupe")
1349 extrusionFaceFissure, normfiss = shapeSurFissure(facesPortFissure)
1350 maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut,
1351 None, None, 'COMPLET', normfiss)
1353 logging.info("conversion quadratique")
1354 maillageComplet.ConvertToQuadratic( 1 )
1355 logging.info("groupes")
1356 groups = maillageComplet.GetGroups()
1357 grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
1358 fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
1360 logging.info("réorientation face de fissure FACE1")
1361 grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
1362 nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
1364 logging.info("réorientation face de fissure FACE2")
1365 plansim = geompy.MakePlane(O, normfiss, 10000)
1366 fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
1367 grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
1368 nb = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
1369 fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
1371 logging.info("export maillage fini")
1372 maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
1373 putName(maillageComplet, nomFicFissure)
1374 logging.info("fichier maillage fissure %s", fichierMaillageFissure)
1376 if salome.sg.hasDesktop():
1377 salome.sg.updateObjBrowser(1)
1379 logging.info("maillage fissure fini")
1381 return maillageComplet