1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2014-2020 EDF R&D
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License, or (at your option) any later version.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 from .geomsmesh import geompy
24 from .geomsmesh import geomPublish
25 from .geomsmesh import geomPublishInFather
28 from .geomsmesh import smesh
29 from salome.smesh import smeshBuilder
34 from .extractionOrientee import extractionOrientee
35 from .extractionOrienteeMulti import extractionOrienteeMulti
36 from .sortFaces import sortFaces
37 from .sortEdges import sortEdges
38 from .eliminateDoubles import eliminateDoubles
39 from .substractSubShapes import substractSubShapes
40 from .produitMixte import produitMixte
41 from .findWireEndVertices import findWireEndVertices
42 from .findWireIntermediateVertices import findWireIntermediateVertices
43 from .orderEdgesFromWire import orderEdgesFromWire
44 from .getSubshapeIds import getSubshapeIds
45 from .putName import putName
46 from .distance2 import distance2
47 from .enleveDefaut import enleveDefaut
48 from .shapeSurFissure import shapeSurFissure
49 from .regroupeSainEtDefaut import RegroupeSainEtDefaut
50 from .triedreBase import triedreBase
51 from .checkDecoupePartition import checkDecoupePartition
52 from .whichSide import whichSide
53 from .whichSideMulti import whichSideMulti
54 from .whichSideVertex import whichSideVertex
55 from .projettePointSurCourbe import projettePointSurCourbe
56 from .prolongeWire import prolongeWire
57 #from getCentreFondFiss import getCentreFondFiss
59 # -----------------------------------------------------------------------------
60 # --- procédure complète fissure générale
62 def insereFissureGenerale(maillagesSains,
63 shapesFissure, shapeFissureParams,
64 maillageFissureParams, elementsDefaut, step=-1):
70 shapeDefaut = shapesFissure[0] # faces de fissure, débordant
71 fondFiss = shapesFissure[4] # groupe d'edges de fond de fissure
73 rayonPipe = shapeFissureParams['rayonPipe']
74 if 'lenSegPipe' in shapeFissureParams:
75 lenSegPipe = shapeFissureParams['lenSegPipe']
77 lenSegPipe = rayonPipe
79 nomRep = maillageFissureParams['nomRep']
80 nomFicSain = maillageFissureParams['nomFicSain']
81 nomFicFissure = maillageFissureParams['nomFicFissure']
83 nbsegRad = maillageFissureParams['nbsegRad'] # nombre de couches selon un rayon du pipe
84 nbsegCercle = maillageFissureParams['nbsegCercle'] # nombre de secteur dans un cercle du pipe
85 areteFaceFissure = maillageFissureParams['areteFaceFissure']
90 isPointInterne = False
91 if 'pointIn_x' in shapeFissureParams:
92 pointIn_x = shapeFissureParams['pointIn_x']
94 if 'pointIn_y' in shapeFissureParams:
95 pointIn_y = shapeFissureParams['pointIn_y']
97 if 'pointIn_z' in shapeFissureParams:
98 pointIn_z = shapeFissureParams['pointIn_z']
101 pointInterne = geompy.MakeVertex(pointIn_x, pointIn_y, pointIn_z)
103 #fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
104 fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
106 # fillings des faces en peau
107 facesDefaut = elementsDefaut[0]
108 #centresDefaut = elementsDefaut[1]
109 #normalsDefaut = elementsDefaut[2]
110 #extrusionsDefaut = elementsDefaut[3]
111 dmoyen = elementsDefaut[4]
112 bordsPartages = elementsDefaut[5]
113 fillconts = elementsDefaut[6]
114 idFilToCont = elementsDefaut[7]
115 maillageSain = elementsDefaut[8]
116 internalBoundary = elementsDefaut[9]
117 zoneDefaut = elementsDefaut[10]
118 zoneDefaut_skin = elementsDefaut[11]
119 zoneDefaut_internalFaces = elementsDefaut[12]
120 zoneDefaut_internalEdges = elementsDefaut[13]
121 edgeFondExt = elementsDefaut[14]
122 centreFondFiss = elementsDefaut[15]
123 tgtCentre = elementsDefaut[16]
125 # --- restriction de la face de fissure au domaine solide :
126 # partition face fissure étendue par fillings, on garde la plus grande face
128 partShapeDefaut = geompy.MakePartition([shapeDefaut], facesDefaut, [], [], geompy.ShapeType["FACE"], 0, [], 0)
129 geomPublish(initLog.debug, partShapeDefaut, 'partShapeDefaut')
130 facesPartShapeDefaut = geompy.ExtractShapes(partShapeDefaut, geompy.ShapeType["FACE"], False)
132 distfaces = [(geompy.MinDistance(face,pointInterne), i, face) for i, face in enumerate(facesPartShapeDefaut)]
134 logging.debug("selection de la face la plus proche du point interne, distance=%s",distfaces[0][0])
135 facesPortFissure = distfaces[0][2]
137 facesPartShapeDefautSorted, minSurf, maxSurf = sortFaces(facesPartShapeDefaut) # la face de fissure dans le volume doit être la plus grande
138 logging.debug("surfaces faces fissure étendue, min %s, max %s", minSurf, maxSurf)
139 facesPortFissure = facesPartShapeDefautSorted[-1] #= global
141 geomPublish(initLog.debug, facesPortFissure, "facesPortFissure")
143 O, OX, OY, OZ = triedreBase()
145 # -----------------------------------------------------------------------------
146 # --- pipe de fond de fissure, prolongé, partition face fissure par pipe
147 # identification des edges communes pipe et face fissure
149 if geompy.NumberOfFaces(shapeDefaut) == 1:
150 plan = geompy.MakePlane(centreFondFiss, tgtCentre, 10000)
151 shapeDefaut = geompy.MakePartition([shapeDefaut], [plan], [], [], geompy.ShapeType["FACE"], 0, [], 0) #= local
152 #fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss) #= inutile
153 geomPublish(initLog.debug, shapeDefaut, 'shapeDefaut_coupe')
154 #geomPublishInFather(initLog.debug,shapeDefaut, fondFissCoupe, 'fondFiss_coupe')
156 extrem, norms = findWireEndVertices(fondFiss, True)
157 logging.debug("extrem: %s, norm: %s",extrem, norms)
158 cercle = geompy.MakeCircle(extrem[0], norms[0], rayonPipe)
159 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
160 geomPublish(initLog.debug, cercle, 'cercle')
161 fondFissProlonge = prolongeWire(fondFiss, extrem, norms, 2*rayonPipe)
162 pipeFiss = geompy.MakePipe(cercle, fondFissProlonge)
163 geomPublish(initLog.debug, pipeFiss, 'pipeFiss')
164 partFissPipe = geompy.MakePartition([shapeDefaut, pipeFiss], [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
165 geomPublish(initLog.debug, partFissPipe, 'partFissPipe')
166 fissPipe = geompy.GetInPlaceByHistory(partFissPipe, shapeDefaut) #= global
167 geomPublish(initLog.debug, fissPipe, 'fissPipe')
168 partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss) #= local
169 geomPublish(initLog.debug, partPipe, 'partPipe')
171 edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"]) #= global
172 for i, edge in enumerate(edgesPipeFiss):
173 name = "edgePipe%d"%i
174 geomPublishInFather(initLog.debug,fissPipe, edge, name)
176 wirePipeFiss = geompy.MakeWire(edgesPipeFiss) #= global
178 wirePipeFiss = geompy.MakeCompound(edgesPipeFiss)
179 logging.debug("wirePipeFiss construit sous forme de compound")
180 geomPublish(initLog.debug, wirePipeFiss, "wirePipeFiss")
182 wireFondFiss = geompy.GetInPlace(partFissPipe,fondFiss)
183 edgesFondFiss = geompy.GetSharedShapesMulti([fissPipe, wireFondFiss], geompy.ShapeType["EDGE"])
184 for i, edge in enumerate(edgesFondFiss):
185 name = "edgeFondFiss%d"%i
186 geomPublishInFather(initLog.debug,fissPipe, edge, name)
187 wireFondFiss = geompy.MakeWire(edgesFondFiss) #= global
188 geomPublish(initLog.debug, wireFondFiss,"wireFondFiss")
190 # -----------------------------------------------------------------------------
191 # --- peau et face de fissure
193 # --- partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée
194 # il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure
195 # liste de faces externes : facesDefaut
196 # liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
198 partitionsPeauFissFond = [] #= global
200 for filling in facesDefaut:
201 part = geompy.MakePartition([fissPipe, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
202 isPart = checkDecoupePartition([fissPipe, filling], part)
203 if isPart: # on recrée la partition avec toutes les faces filling en outil pour avoir une face de fissure correcte
204 otherFD = [fd for fd in facesDefaut if fd != filling]
206 fissPipePart = geompy.MakePartition([fissPipe], otherFD, [], [], geompy.ShapeType["FACE"], 0, [], 0)
208 fissPipePart = fissPipe
209 part = geompy.MakePartition([fissPipePart, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
210 partitionsPeauFissFond.append(part)
211 geomPublish(initLog.debug, part, 'partitionPeauFissFond%d'%ipart )
213 partitionsPeauFissFond.append(None)
217 # --- arêtes vives détectées (dans quadranglesToShapeNoCorner
218 # et quadranglesToShapeWithCorner)
221 aretesVivesCoupees = [] #= global
223 for a in bordsPartages:
224 if not isinstance(a, list):
225 aretesVives.append(a)
226 name = "areteVive%d"%ia
227 geomPublish(initLog.debug, a, name)
231 aretesVives.append(a[0])
232 name = "areteVive%d"%ia
233 geomPublish(initLog.debug, a[0], name)
236 aretesVivesC = None #= global
237 if len(aretesVives) > 0:
238 aretesVivesC =geompy.MakeCompound(aretesVives)
240 # -------------------------------------------------------
241 # --- inventaire des faces de peau coupées par la fissure
242 # pour chaque face de peau : 0, 1 ou 2 faces débouchante du fond de fissure
243 # 0, 1 ou plus edges de la face de fissure externe au pipe
245 nbFacesFilling = len(partitionsPeauFissFond)
246 ptEdgeFond = [ [] for i in range(nbFacesFilling)] # pour chaque face [points edge fond de fissure aux débouchés du pipe]
247 fsPipePeau = [ [] for i in range(nbFacesFilling)] # pour chaque face [faces du pipe débouchantes]
248 edRadFPiPo = [ [] for i in range(nbFacesFilling)] # pour chaque face [edge radiale des faces du pipe débouchantes ]
249 fsFissuExt = [ [] for i in range(nbFacesFilling)] # pour chaque face [faces de fissure externes au pipe]
250 edFisExtPe = [ [] for i in range(nbFacesFilling)] # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
251 edFisExtPi = [ [] for i in range(nbFacesFilling)] # pour chaque face [edge commun au pipe des faces de fissure externes]
252 facesPeaux = [None for i in range(nbFacesFilling)] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
253 edCircPeau = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
254 ptCircPeau = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
255 gpedgeBord = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
256 gpedgeVifs = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupes subshape des edges aux arêtes vives entre fillings
257 edFissPeau = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
258 ptFisExtPi = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [point commun edFissPeau edCircPeau]
260 for ifil, partitionPeauFissFond in enumerate(partitionsPeauFissFond):
261 if partitionPeauFissFond is not None:
262 fillingFaceExterne = facesDefaut[ifil]
263 #fillingSansDecoupe = fillconts[idFilToCont[ifil]]
264 logging.debug("traitement partitionPeauFissFond %s", ifil)
265 # -----------------------------------------------------------------------
266 # --- identification edges fond de fissure, edges pipe sur la face de fissure,
269 edgesPipeC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesPipeFiss)) #= local
270 geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesPipeC, "edgesPipeFiss")
271 edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss)) #= local
272 geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesFondC, "edgesFondFiss")
274 if aretesVivesC is None: #= global facesInside facesOnside
275 [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
276 [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
278 [edgesInside, edgesOutside, edgesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
279 [facesInside, facesOutside, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
281 edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"]) #= global
282 verticesPipePeau = [] #= global
284 for i, edge in enumerate(edgesPipeIn):
286 vertices = geompy.GetSharedShapesMulti([edge, geompy.MakeCompound(facesOnside)], geompy.ShapeType["VERTEX"])
287 verticesPipePeau.append(vertices[0])
288 name = "edgePipeIn%d"%i
289 geomPublishInFather(initLog.debug,partitionPeauFissFond, edge, name)
290 name = "verticePipePeau%d"%i
291 geomPublishInFather(initLog.debug,partitionPeauFissFond, vertices[0], name)
292 logging.debug("edgePipeIn%s coupe les faces OnSide", i)
294 logging.debug("edgePipeIn%s ne coupe pas les faces OnSide", i)
295 #edgesFondOut = [] #= inutile
296 edgesFondIn =[] #= global
297 if len(verticesPipePeau) > 0: # au moins une extrémité du pipe sur cette face de peau
298 #tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesOutside)], geompy.ShapeType["EDGE"])
299 #edgesFondOut = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
300 tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
301 edgesFondIn = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
303 verticesEdgesFondIn = [] # les points du fond de fissure au débouché du pipe sur la peau (indice de edgesFondIn)
304 pipexts = [] # les segments de pipe associés au points de fond de fissure débouchants (même indice)
305 cercles = [] # les cercles de generation des pipes débouchant (même indice)
306 facesFissExt = [] # les faces de la fissure externe associés au points de fond de fissure débouchants (même indice)
307 edgesFissExtPeau = [] # edges des faces de fissure externe sur la peau (même indice)
308 edgesFissExtPipe = [] # edges des faces de fissure externe sur le pipe (même indice)
309 #logging.debug("edgesFondIn %s", edgesFondIn)
311 edgesFondFiss, edgesIdByOrientation = orderEdgesFromWire(wireFondFiss)
312 for i,edge in enumerate(edgesFondFiss):
313 geomPublishInFather(initLog.debug,wireFondFiss, edge, "edgeFondFiss%d"%i)
315 for iedf, edge in enumerate(edgesFondIn):
316 name = "edgeFondIn%d"%iedf
317 geomPublishInFather(initLog.debug,partitionPeauFissFond, edge, name)
318 dist = [ geompy.MinDistance(pt, edge) for pt in verticesPipePeau]
319 ptPeau = verticesPipePeau[dist.index(min(dist))] # le point de verticesPipePeau a distance minimale de l'edge
320 [u, PointOnEdge, EdgeInWireIndex] = geompy.MakeProjectionOnWire(ptPeau, wireFondFiss)
321 logging.debug("u:%s, EdgeInWireIndex: %s, len(edgesFondFiss): %s", u, EdgeInWireIndex, len(edgesFondFiss))
322 localEdgeInFondFiss = edgesFondFiss[EdgeInWireIndex]
324 centre2 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, u)
325 geomPublishInFather(initLog.debug,partitionPeauFissFond, centre2, "centre2_%d"%iedf)
326 verticesEdgesFondIn.append(centre)
327 name = "verticeEdgesFondIn%d"%iedf
328 geomPublishInFather(initLog.debug,partitionPeauFissFond, centre, name)
329 norm = geompy.MakeTangentOnCurve(localEdgeInFondFiss, u)
330 geomPublishInFather(initLog.debug,partitionPeauFissFond, centre, "norm%d"%iedf)
331 cercle = geompy.MakeCircle(centre, norm, rayonPipe)
332 geomPublishInFather(initLog.debug,partitionPeauFissFond, cercle, "cerclorig%d"%iedf)
333 [vertex] = geompy.ExtractShapes(cercle, geompy.ShapeType["VERTEX"], False)
334 vec1 = geompy.MakeVector(centre, vertex)
335 vec2 = geompy.MakeVector(centre, ptPeau)
336 angle = geompy.GetAngleRadians(vec1, vec2)
337 # cas général : on reconstitue une portion de pipe, avec l'arête de couture qui coincide
338 # avec la face de fissure, au niveau du débouché sur la face externe
339 # cas dégénéré : le pipe débouche perpendiculairement à une surface plane à l'origine.
340 # La partition filling / pipe reconstruit échoue.
341 # - Si on partitionne le filling avec un simple pipe obtenu par extrusion droite du cercle,
342 # cela donne un point en trop sur le cercle.
343 # - Si on prend une vraie surface plane (pas un filling), on peut faire la partition avec
344 # les pipes reconstruits
345 logging.debug("angle=%s", angle)
346 #if abs(angle) > 1.e-7:
347 sommetAxe = geompy.MakeTranslationVector(centre, norm)
348 pm = produitMixte(centre, vertex, ptPeau, sommetAxe)
349 if pm > 0: # ajout de pi a (-)angle pour éviter des points confondus (partition échoue) dans les cas dégénérés
350 cercle = geompy.MakeRotation(cercle, norm, angle + math.pi)
352 cercle = geompy.MakeRotation(cercle, norm, -angle + math.pi)
353 name = "cercle%d"%iedf
354 geomPublishInFather(initLog.debug,partitionPeauFissFond, cercle, name)
355 cercles.append(cercle)
357 # --- estimation de la longueur du pipe necessaire de part et d'autre du point de sortie
358 if aretesVivesC is None:
359 faceTestPeau = fillingFaceExterne
361 faceTestPeau = facesDefaut[ifil]
362 sideCentre = whichSide(faceTestPeau, centre)
363 locPt0 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 0.0)
364 locPt1 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 1.0)
365 sidePt0 = whichSide(faceTestPeau, locPt0)
366 sidePt1 = whichSide(faceTestPeau, locPt1)
367 logging.debug("position centre cercle: %s, extremité edge u0: %s, u1: %s", sideCentre, sidePt0, sidePt1)
368 normFace = geompy.GetNormal(faceTestPeau, ptPeau)
369 inclPipe = abs(geompy.GetAngleRadians(norm, normFace))
370 lgp = max(rayonPipe/2., abs(3*rayonPipe*math.tan(inclPipe)))
371 logging.debug("angle inclinaison Pipe en sortie: %s degres, lgp: %s", inclPipe*180/math.pi, lgp)
373 # --- position des points extremite du pipe sur l'edge debouchante
374 # il faut la distance curviligne ofp du point central par rapport à une extrémité de l'edge débouchante
375 locEdgePart = geompy.MakePartition([localEdgeInFondFiss],[centre], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
376 edgesLoc = geompy.ExtractShapes(locEdgePart, geompy.ShapeType["EDGE"], False)
377 edgesLocSorted =[(geompy.MinDistance(edge, locPt0), kk, edge) for kk, edge in enumerate(edgesLoc)]
378 edgesLocSorted.sort()
379 ofp = geompy.BasicProperties(edgesLocSorted[0][2])[0] # distance curviligne centre locPt0
380 logging.debug("distance curviligne centre extremite0: %s", ofp)
381 p1 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp +lgp, locPt0)
382 p2 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp -lgp, locPt0)
383 geomPublishInFather(initLog.debug,wireFondFiss, p1, "p1_%d"%iedf)
384 geomPublishInFather(initLog.debug,wireFondFiss, p2, "p2_%d"%iedf)
386 edgePart = geompy.MakePartition([localEdgeInFondFiss], [p1,p2], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
387 edps = geompy.ExtractShapes(edgePart, geompy.ShapeType["EDGE"], True)
389 if geompy.MinDistance(centre, edp) < 1.e-3:
390 pipext = geompy.MakePipe(cercle, edp)
391 name = "pipeExt%d"%iedf
392 geomPublishInFather(initLog.debug,partitionPeauFissFond, pipext, name)
393 pipexts.append(pipext)
395 for face in facesInside:
396 logging.debug("recherche edges communes entre une face inside et (faces onside, edges pipe et fond débouchante)")
401 edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
402 logging.debug(" faces onside %s",edgesPeauFis)
403 edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
404 logging.debug(" edgesPipeIn %s", edgesPipeFis)
405 edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
406 logging.debug(" edgesFondIn %s ", edgesPipeFnd)
408 logging.debug(" pb edges communes %s %s %s",edgesPeauFis, edgesPipeFis, edgesPipeFnd)
410 if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
411 dist = geompy.MinDistance(geompy.MakeCompound(edgesPeauFis), ptPeau)
412 logging.debug(" test distance extrémité reference %s", dist)
413 if dist < 1.e-3: # c'est la face de fissure externe associée
414 logging.debug(" face %s inside ajoutée", i)
415 facesFissExt.append(face)
416 name="faceFissExt%d"%iedf
417 geomPublishInFather(initLog.debug,partitionPeauFissFond, face, name)
419 for ipe, edpe in enumerate(edgesPeauFis):
420 for ipi, edpi in enumerate(edgesPipeFis):
421 dist = geompy.MinDistance(edpe, edpi)
423 edgesFissExtPeau.append(edpe)
424 name="edgesFissExtPeau%d"%iedf
425 geomPublishInFather(initLog.debug,partitionPeauFissFond, edpe, name)
426 edgesFissExtPipe.append(edpi)
427 name="edgesFissExtPipe%d"%iedf
428 geomPublishInFather(initLog.debug,partitionPeauFissFond, edpi, name)
433 if len(verticesPipePeau) == 0: # aucune extrémité du pipe sur cette face de peau
434 # il faut recenser les edges de fissure sur la face de peau
436 for face in facesInside:
441 edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
442 edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
443 edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
446 if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
447 edgesFissExtPeau.append(edgesPeauFis[0])
448 name="edgesFissExtPeau%d"%j
449 geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesPeauFis[0], name)
452 # -----------------------------------------------------------------------
453 # --- identification faces de peau : face de peau percée du pipe, extrémités du pipe
454 # La partition avec le pipe peut créer un vertex (et un edge) de trop sur le cercle projeté,
455 # quand le cercle est très proche de la face.
456 # dans ce cas, la projection du cercle sur la face suivie d'une partition permet
457 # d'éviter le point en trop
459 facesAndFond = facesOnside
460 facesAndFond.append(wireFondFiss)
462 partitionPeauByPipe = geompy.MakePartition(facesAndFond, pipexts, [], [], geompy.ShapeType["FACE"], 0, [], 1)
464 logging.debug("probleme partition face pipe, contournement avec MakeSection")
466 for pipext in pipexts:
467 sections.append(geompy.MakeSection(facesOnside[0], pipext))
468 partitionPeauByPipe = geompy.MakePartition(facesAndFond, sections, [], [], geompy.ShapeType["FACE"], 0, [], 1)
470 # contrôle edge en trop sur edges circulaires
471 if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
474 facesPeau = geompy.ExtractShapes(partitionPeauByPipe, geompy.ShapeType["FACE"], False)
475 facesPeauSorted, minsur, maxsurf = sortFaces(facesPeau)
476 for i, face in enumerate(facesPeauSorted[:-1]): # on ne teste que la ou les petites faces "circulaires"
477 nbv = geompy.NumberOfEdges(face)
478 logging.debug("nombre d'edges sur face circulaire: %s", nbv)
480 edgeEnTrop.append(True) # TODO : distinguer les cas avec deux faces circulaires dont l'une est correcte
482 edgeEnTrop.append(False)
483 refaire = sum(edgeEnTrop)
485 dc = [(geompy.MinDistance(verticesEdgesFondIn[0], fac), i) for i, fac in enumerate(facesPeauSorted[:-1])]
487 logging.debug("dc sorted: %s", dc)
488 i0 = dc[0][1] # indice de facesPeauSorted qui correspond à verticesEdgesFondIn[0], donc 0 pour cercles
490 for i, bad in enumerate(edgeEnTrop):
496 outilPart[j] = geompy.MakeProjection(cercles[j],facesOnside[0])
498 partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, [], [], geompy.ShapeType["FACE"], 0, [], 1)
501 name="partitionPeauByPipe%d"%ifil
502 geomPublish(initLog.debug, partitionPeauByPipe, name)
503 [edgesPeauFondIn, edgesPeauFondOut, edgesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "EDGE", 1.e-3)
504 [facesPeauFondIn, facesPeauFondOut, facesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "FACE", 1.e-3)
506 if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
507 facesPeauSorted, minsur, maxsurf = sortFaces(facesPeauFondOn)
508 facePeau = facesPeauSorted[-1] # la plus grande face
510 facePeau =geompy.MakePartition(facesPeauFondOn, [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
511 name="facePeau%d"%ifil
512 geomPublish(initLog.debug, facePeau, name)
514 facesPipePeau = [None for i in range(len(edgesFissExtPipe))]
515 endsEdgeFond = [None for i in range(len(edgesFissExtPipe))]
516 edgeRadFacePipePeau = [None for i in range(len(edgesFissExtPipe))]
520 verticesCircPeau = []
521 if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
523 for face in facesPeauSorted[:-1]: # la ou les faces débouchantes, pas la grande face de peau
524 logging.debug("examen face debouchante circulaire")
525 for i,efep in enumerate(edgesFissExtPipe):
526 dist = geompy.MinDistance(face, efep)
527 logging.debug(" distance face circulaire edge %s", dist)
529 for ik, edpfi in enumerate(edgesPeauFondIn):
530 if geompy.MinDistance(face, edpfi) < 1e-3:
532 sharedVertices = geompy.GetSharedShapesMulti([face, edgesPeauFondIn[ik]], geompy.ShapeType["VERTEX"])
533 nameFace = "facePipePeau%d"%i
534 nameVert = "endEdgeFond%d"%i
535 nameEdge = "edgeRadFacePipePeau%d"%i
536 facesPipePeau[i] = face
537 endsEdgeFond[i] = sharedVertices[0]
538 geomPublish(initLog.debug, face, nameFace)
539 geomPublish(initLog.debug, sharedVertices[0], nameVert)
540 edgesFace = geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], True)
541 for edge in edgesFace:
542 if geompy.MinDistance(edge, sharedVertices[0]) < 1e-3:
543 edgeRadFacePipePeau[i] = edge
544 geomPublish(initLog.debug, edge, nameEdge)
551 # --- edges circulaires de la face de peau et points de jonction de la face externe de fissure
552 logging.debug("facesPipePeau: %s", facesPipePeau)
553 edgesCircPeau = [None for i in range(len(facesPipePeau))]
554 verticesCircPeau = [None for i in range(len(facesPipePeau))]
555 for i,fcirc in enumerate(facesPipePeau):
556 edges = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["EDGE"])
557 grpEdgesCirc = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
558 geompy.UnionList(grpEdgesCirc, edges)
559 edgesCircPeau[i] = grpEdgesCirc
560 name = "edgeCirc%d"%i
561 geomPublishInFather(initLog.debug,facePeau, grpEdgesCirc, name)
562 edgesListees = edgesListees + edges
563 vertices = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["VERTEX"])
564 grpVertCircPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["VERTEX"])
565 geompy.UnionList(grpVertCircPeau, vertices)
566 verticesCircPeau[i] = grpVertCircPeau
567 name = "pointEdgeCirc%d"%i
568 geomPublishInFather(initLog.debug,facePeau, grpVertCircPeau, name)
570 pass # --- au moins une extrémité du pipe sur cette face de peau
572 # --- edges de bord de la face de peau
574 edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
576 for i, edge in enumerate(edgesFilling):
577 edgepeau = geompy.GetInPlace(facePeau, edge)
578 name = "edgepeau%d"%i
579 geomPublishInFather(initLog.debug,facePeau,edgepeau, name)
580 logging.debug("edgepeau %s", geompy.ShapeInfo(edgepeau))
581 if geompy.ShapeInfo(edgepeau)['EDGE'] > 1:
582 logging.debug(" EDGES multiples")
583 edgs = geompy.ExtractShapes(edgepeau, geompy.ShapeType["EDGE"], False)
587 logging.debug(" EDGE")
588 edgesBords.append(edgepeau)
589 edgesListees.append(edgepeau)
590 groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
591 geompy.UnionList(groupEdgesBordPeau, edgesBords)
593 if aretesVivesC is not None:
594 bordsVifs = geompy.GetInPlace(facePeau, aretesVivesC)
595 if bordsVifs is not None:
596 geomPublishInFather(initLog.debug,facePeau, bordsVifs, "bordsVifs")
597 groupEdgesBordPeau = geompy.CutGroups(groupEdgesBordPeau, bordsVifs)
599 if len(aretesVivesCoupees) > 0:
600 grpC = geompy.MakeCompound(aretesVivesCoupees)
601 grptmp = geompy.GetInPlace(facePeau, grpC)
602 if grptmp is not None:
603 grpnew = geompy.CutGroups(bordsVifs, grptmp) # ce qui est nouveau dans bordsVifs
606 if grpnew is not None:
607 edv = geompy.ExtractShapes(grpnew, geompy.ShapeType["EDGE"], False)
608 aretesVivesCoupees += edv
609 logging.debug("aretesVivesCoupees %s",aretesVivesCoupees)
610 geomPublishInFather(initLog.debug,facePeau, groupEdgesBordPeau , "EdgesBords")
612 # --- edges de la face de peau partagées avec la face de fissure
614 edgesPeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
615 edges = substractSubShapes(facePeau, edgesPeau, edgesListees)
616 edgesFissurePeau = []
617 if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
618 edgesFissurePeau = [None for i in range(len(verticesCircPeau))] # edges associés aux extrémités du pipe, en premier
620 for i, grpVert in enumerate(verticesCircPeau):
621 if (geompy.MinDistance(grpVert, edge) < 1.e-3) and (edge not in edgesFissurePeau):
622 edgesFissurePeau[i] = edge
623 name = "edgeFissurePeau%d"%i
624 geomPublishInFather(initLog.debug,facePeau, edge, name)
625 for edge in edges: # on ajoute après les edges manquantes
626 if edge not in edgesFissurePeau:
627 edgesFissurePeau.append(edge)
629 for i, edge in enumerate(edges):
630 edgesFissurePeau.append(edge)
631 name = "edgeFissurePeau%d"%i
632 geomPublishInFather(initLog.debug,facePeau, edge, name)
635 ptEdgeFond[ifil] = endsEdgeFond # pour chaque face [points edge fond de fissure aux débouchés du pipe]
636 fsPipePeau[ifil] = facesPipePeau # pour chaque face [faces du pipe débouchantes]
637 edRadFPiPo[ifil] = edgeRadFacePipePeau # pour chaque face [edge radiale des faces du pipe débouchantes ]
638 fsFissuExt[ifil] = facesFissExt # pour chaque face [faces de fissure externes au pipe]
639 edFisExtPe[ifil] = edgesFissExtPeau # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
640 edFisExtPi[ifil] = edgesFissExtPipe # pour chaque face [edge commun au pipe des faces de fissure externes]
641 facesPeaux[ifil] = facePeau # pour chaque face : la face de peau finale a mailler (percee des faces débouchantes)
642 edCircPeau[ifil] = edgesCircPeau # pour chaque face de peau : [groupe subshapes edges circulaires aux débouchés du pipe]
643 ptCircPeau[ifil] = verticesCircPeau # pour chaque face de peau : [groupe subshapes points sur edges circulaires aux débouchés du pipe]
644 gpedgeBord[ifil] = groupEdgesBordPeau # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
645 gpedgeVifs[ifil] = bordsVifs # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
646 edFissPeau[ifil] = edgesFissurePeau # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
647 ptFisExtPi[ifil] = verticesPipePeau # pour chaque face de peau : [point commun edFissPeau edCircPeau]
649 # -----------------------------------------------------------------------
650 # fin de la boucle sur les faces de filling
651 # -----------------------------------------------------------------------
653 for i, avc in enumerate(aretesVivesCoupees):
654 name = "areteViveCoupee%d"%i
655 geomPublish(initLog.debug, avc, name)
657 # --- identification des faces et edges de fissure externe pour maillage
660 edgesFissExtPeau = []
661 edgesFissExtPipe = []
662 for ifil in range(nbFacesFilling): # TODO: éliminer les doublons (comparer tous les vertices triés, avec mesure de distance ?)
663 facesFissExt += fsFissuExt[ifil]
664 edgesFissExtPeau += edFisExtPe[ifil]
665 edgesFissExtPipe += edFisExtPi[ifil]
666 logging.debug("---------------------------- identification faces de fissure externes au pipe :%s ", len(facesFissExt))
667 # regroupement des faces de fissure externes au pipe.
669 if len(facesFissExt) > 1:
670 faceFissureExterne = geompy.MakePartition(facesFissExt, [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
671 edgesPipeFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesPipeFiss)) # edgesFissExtPipe peut ne pas couvrir toute la longueur
672 # edgesPeauFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesFissExtPeau))
673 # il peut manquer des edges de faceFissureExterne en contact avec la peau dans edgesFissExtPeau
674 (isDone, closedFreeBoundaries, openFreeBoundaries) = geompy.GetFreeBoundary(faceFissureExterne)
676 for bound in closedFreeBoundaries:
677 edgesBordFFE += geompy.ExtractShapes(bound, geompy.ShapeType["EDGE"], False)
678 edgesBordFFEid = [ (ed,geompy.GetSubShapeID(faceFissureExterne, ed)) for ed in edgesBordFFE]
679 logging.debug("edgesBordFFEid %s", edgesBordFFEid)
680 edgesPPE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
681 edgesPPEid = [ geompy.GetSubShapeID(faceFissureExterne, ed) for ed in edgesPPE]
682 logging.debug("edgesPPEid %s", edgesPPEid)
683 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
684 logging.debug("edgesPFE %s", edgesPFE)
685 edgesPeauFissureExterneC = geompy.MakeCompound(edgesPFE)
687 faceFissureExterne = facesFissExt[0]
688 edgesPeauFissureExterneC = geompy.MakeCompound(edgesFissExtPeau)
689 edgesPipeFissureExterneC = geompy.MakeCompound(edgesFissExtPipe)
690 wirePipeFissureExterne = geompy.MakeWire(geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False))
691 geomPublish(initLog.debug, faceFissureExterne, "faceFissureExterne")
692 geomPublishInFather(initLog.debug,faceFissureExterne, edgesPeauFissureExterneC, "edgesPeauFissureExterne")
693 geomPublishInFather(initLog.debug,faceFissureExterne, edgesPipeFissureExterneC, "edgesPipeFissureExterne")
695 logging.debug("---------------------------- Preparation Maillage du Pipe --------------")
696 # -----------------------------------------------------------------------
697 # --- preparation maillage du pipe :
698 # - détections des points a respecter : jonction des edges/faces constituant
699 # la face de fissure externe au pipe
700 # - points sur les edges de fond de fissure et edges pipe/face fissure,
701 # - vecteurs tangents au fond de fissure (normal au disque maillé)
703 # --- option de maillage selon le rayon de courbure du fond de fissure
705 for edff in edgesFondFiss:
706 lenEdgeFondExt += geompy.BasicProperties(edff)[0]
709 for filling in facesDefaut:
710 disfond.append(geompy.MinDistance(centreFondFiss, filling))
713 nbSegQuart = 5 # on veut 5 segments min sur un quart de cercle
714 alpha = math.pi/(4*nbSegQuart)
715 deflexion = rcourb*(1.0 -math.cos(alpha))
716 lgmin = lenSegPipe*0.25
717 lgmax = lenSegPipe*1.5
718 logging.debug("rcourb: %s, lenFond:%s, deflexion: %s, lgmin: %s, lgmax: %s", rcourb, lenEdgeFondExt, deflexion, lgmin, lgmax)
720 meshFondExt = smesh.Mesh(wireFondFiss)
721 algo1d = meshFondExt.Segment()
722 hypo1d = algo1d.Adaptive(lgmin, lgmax, deflexion) # a ajuster selon la profondeur de la fissure
723 isDone = meshFondExt.Compute()
725 ptGSdic = {} # dictionnaire [paramètre sur la courbe] --> point géométrique
726 allNodeIds = meshFondExt.GetNodesId()
727 for nodeId in allNodeIds:
728 xyz = meshFondExt.GetNodeXYZ(nodeId)
729 #logging.debug("nodeId %s, coords %s", nodeId, str(xyz))
730 pt = geompy.MakeVertex(xyz[0], xyz[1], xyz[2])
731 u, PointOnEdge, EdgeInWireIndex = geompy.MakeProjectionOnWire(pt, wireFondFiss) # u compris entre 0 et 1
732 edgeOrder = edgesIdByOrientation[EdgeInWireIndex]
733 ptGSdic[(edgeOrder, EdgeInWireIndex, u)] = pt
734 #logging.debug("nodeId %s, u %s", nodeId, str(u))
735 usort = sorted(ptGSdic)
736 logging.debug("nombre de points obtenus par deflexion %s",len(usort))
744 vertcx = ptGSdic[edu]
745 norm = geompy.MakeTangentOnCurve(edgesFondFiss[ied], u)
746 plan = geompy.MakePlane(vertcx, norm, 3*rayonPipe)
747 part = geompy.MakePartition([plan], [wirePipeFiss], [], [], geompy.ShapeType["VERTEX"], 0, [], 0)
748 liste = geompy.ExtractShapes(part, geompy.ShapeType["VERTEX"], True)
749 if len(liste) == 5: # 4 coins du plan plus intersection recherchée
751 if geompy.MinDistance(point, vertcx) < 1.1*rayonPipe: # les quatre coins sont plus loin
754 centres.append(vertcx)
755 origins.append(vertpx)
757 # name = "vertcx%d"%i
758 # geomPublishInFather(initLog.debug,wireFondFiss, vertcx, name)
759 # name = "vertpx%d"%i
760 # geomPublishInFather(initLog.debug,wireFondFiss, vertpx, name)
762 # geomPublishInFather(initLog.debug,wireFondFiss, plan, name)
764 # --- maillage du pipe étendu, sans tenir compte de l'intersection avec la face de peau
766 logging.debug("nbsegCercle %s", nbsegCercle)
768 # -----------------------------------------------------------------------
769 # --- points géométriques
771 gptsdisks = [] # vertices géométrie de tous les disques
772 raydisks = [[] for i in range(nbsegCercle)]
773 for i in range(len(centres)): # boucle sur les disques
774 gptdsk = [] # vertices géométrie d'un disque
778 vec1 = geompy.MakeVector(vertcx, vertpx)
780 points = [vertcx] # les points du rayon de référence
781 for j in range(nbsegRad):
782 pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, (j+1)*float(rayonPipe)/nbsegRad)
784 gptdsk.append(points)
785 pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, 1.5*rayonPipe)
786 rayon = geompy.MakeLineTwoPnt(vertcx, pt)
787 raydisks[0].append(rayon)
789 for k in range(nbsegCercle-1):
790 angle = (k+1)*2*math.pi/nbsegCercle
791 pts = [vertcx] # les points d'un rayon obtenu par rotation
792 for j in range(nbsegRad):
793 pt = geompy.MakeRotation(points[j+1], normal, angle)
796 ray = geompy.MakeRotation(rayon, normal, angle)
797 raydisks[k+1].append(ray)
799 gptsdisks.append(gptdsk)
801 # -----------------------------------------------------------------------
802 # --- recherche des points en trop (externes au volume à remailler)
803 # - on associe chaque extrémité du pipe à une face filling
804 # - on part des disques aux extrémités du pipe
805 # - pour chaque disque, on prend les vertices de géométrie,
806 # on marque leur position relative à la face.
807 # - on s'arrete quand tous les noeuds sont dedans
809 logging.debug("---------------------------- recherche des points du pipe a éliminer --------------")
813 idFillingFromBout = [None, None] # contiendra l'index du filling pour les extrémités 0 et 1
814 for ifil in range(nbFacesFilling):
815 for ipt, pt in enumerate(ptEdgeFond[ifil]): # il y a un ou deux points débouchant sur cette face
816 if geompy.MinDistance(pt,pt0) < geompy.MinDistance(pt,pt1): # TODO: trouver plus fiable pour les cas tordus...
817 idFillingFromBout[0] = ifil
819 idFillingFromBout[1] = ifil
820 logging.debug("association bouts du pipe - faces de filling: %s", idFillingFromBout)
823 edgeRadFacePipePeau = []
824 for ifil in range(nbFacesFilling):
825 facesPipePeau += fsPipePeau[ifil]
826 edgeRadFacePipePeau += edRadFPiPo[ifil]
828 logging.debug("recherche des disques de noeuds complètement internes")
829 idisklim = [] # indices des premier et dernier disques internes
830 idiskout = [] # indices des premier et dernier disques externes
831 for bout in range(2):
837 idisk = len(gptsdisks)
839 numout = len(gptsdisks)
844 logging.debug("examen disque %s", idisk)
845 gptdsk = gptsdisks[idisk]
847 for k in range(nbsegCercle):
849 for j, pt in enumerate(points):
850 side = whichSideVertex(facesDefaut[idFillingFromBout[bout]], pt)
852 if outside: # premier point detecté dedans
854 numout = idisk -inc # le disque précédent était dehors
856 inside = False # ce point est dehors
857 if not inside and not outside:
859 idisklim.append(idisk) # premier et dernier disques internes
860 idiskout.append(numout) # premier et dernier disques externes
862 # --- listes de nappes radiales en filling à chaque extrémité débouchante
863 facesDebouchantes = [False, False]
864 idFacesDebouchantes = [-1, -1] # contiendra les indices des faces disque débouchantes (facesPipePeau)
866 for i, idisk in enumerate(idisklim):
868 logging.debug("extremité %s, indices disques interne %s, externe %s",i, idisk, numout)
870 if (idisk != 0) and (idisk != len(gptsdisks)-1): # si extrémité débouchante
871 for k in range(nbsegCercle):
873 iddeb = max(0, numout)
874 idfin = max(iddeb+3,idisk+1) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
875 #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
876 comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
877 name='compoundRay%d'%k
878 geomPublish(initLog.debug, comp, name)
880 idfin = min(len(gptsdisks), numout+1)
881 iddeb = min(idfin-3, idisk) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
882 #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
883 comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
884 name='compoundRay%d'%k
885 geomPublish(initLog.debug, comp, name)
886 nappe = geompy.MakeFilling(comp, 2, 5, 0.0001, 0.0001, 0, GEOM.FOM_Default)
889 geomPublish(initLog.debug, nappe, name)
890 facesDebouchantes[i] = True
891 listNappes.append(nappes)
893 # --- mise en correspondance avec les indices des faces disque débouchantes (facesPipePeau)
894 for i, nappes in enumerate(listNappes):
895 if facesDebouchantes[i]:
896 for k, face in enumerate(facesPipePeau):
897 edge = geompy.MakeSection(face, nappes[0])
898 if geompy.NbShapes(edge, geompy.ShapeType["EDGE"]) > 0:
899 idFacesDebouchantes[i] = k
901 logging.debug("idFacesDebouchantes: %s", idFacesDebouchantes)
903 # --- construction des listes d'edges radiales sur chaque extrémité débouchante
905 for i, nappes in enumerate(listNappes):
906 id = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
910 face = facesPipePeau[id]
911 edges = [edgeRadFacePipePeau[id]]
912 for k, nappe in enumerate(nappes):
914 obj = geompy.MakeSection(face, nappes[k]) # normalement une edge, parfois un compound d'edges dont un tout petit
916 vs = geompy.ExtractShapes(obj, geompy.ShapeType["VERTEX"], False)
918 eds = geompy.ExtractShapes(obj, geompy.ShapeType["EDGE"], False)
919 [edsorted, minl,maxl] = sortEdges(eds)
922 maxl = geompy.BasicProperties(edge)[0]
923 if maxl < 0.01: # problème MakeSection
924 logging.debug("problème MakeSection recherche edge radiale %s, longueur trop faible: %s, utilisation partition", k, maxl)
925 partNappeFace = geompy.MakePartition([face, nappes[k]], [] , [], [], geompy.ShapeType["FACE"], 0, [], 0)
926 edps= geompy.ExtractShapes(partNappeFace, geompy.ShapeType["EDGE"], False)
928 for ii, ed in enumerate(edps):
929 vxs = geompy.ExtractShapes(ed, geompy.ShapeType["VERTEX"], False)
930 distx = [geompy.MinDistance(vx, face) for vx in vxs]
931 distx += [geompy.MinDistance(vx, nappes[k]) for vx in vxs]
933 logging.debug(" dmax %s",dmax)
936 logging.debug(" edges issues de la partition: %s", ednouv)
937 for ii, ed in enumerate(ednouv):
938 geomPublish(initLog.debug, ed, "ednouv%d"%ii)
939 [edsorted, minl,maxl] = sortEdges(ednouv)
940 logging.debug(" longueur edge trouvée: %s", maxl)
943 name = 'edgeEndPipe%d'%k
944 geomPublish(initLog.debug, edge, name)
945 listEdges.append(edges)
947 # --- création des points du maillage du pipe sur la face de peau
948 for i, edges in enumerate(listEdges):
949 id = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
952 if id > 0: # id vaut 0 ou 1
953 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)
954 centre = ptEdgeFond[idFillingFromBout[i]][id]
956 geomPublish(initLog.debug, centre, name)
957 vertPipePeau = ptFisExtPi[idFillingFromBout[i]][id]
958 geomPublishInFather(initLog.debug,centre, vertPipePeau, "vertPipePeau")
959 grpsEdgesCirc = edCircPeau[idFillingFromBout[i]] # liste de groupes
961 for grpEdgesCirc in grpsEdgesCirc:
962 edgesCirc += geompy.ExtractShapes(grpEdgesCirc, geompy.ShapeType["EDGE"], False)
963 for k, edge in enumerate(edges):
964 extrems = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], True)
965 if geompy.MinDistance(centre, extrems[0]) < geompy.MinDistance(centre, extrems[1]):
969 # ajustement du point extrémité (bout) sur l'edge circulaire en face de peau
970 logging.debug("edgesCirc: %s", edgesCirc)
971 distEdgeCirc = [(geompy.MinDistance(bout, edgeCirc), k2, edgeCirc) for k2, edgeCirc in enumerate(edgesCirc)]
973 logging.debug("distEdgeCirc: %s", distEdgeCirc)
974 u = projettePointSurCourbe(bout, distEdgeCirc[0][2])
975 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.
976 extrCircs = geompy.ExtractShapes(distEdgeCirc[0][2], geompy.ShapeType["VERTEX"], True)
977 if geompy.MinDistance(bout, extrCircs[0]) < geompy.MinDistance(bout, extrCircs[1]):
983 bout = geompy.MakeVertexOnCurve(distEdgeCirc[0][2], u)
985 geomPublishInFather(initLog.debug,centre, bout, name)
986 # enregistrement des points dans la structure
988 for j in range(nbsegRad +1):
989 u = j/float(nbsegRad)
990 points.append(geompy.MakeVertexOnCurve(edge, u))
991 if geompy.MinDistance(bout, points[0]) < geompy.MinDistance(centre, points[0]):
995 gptdsk.append(points)
997 gptsdisks[idisklim[0] -1] = gptdsk
998 idisklim[0] = idisklim[0] -1
1000 gptsdisks[idisklim[1] +1] = gptdsk
1001 idisklim[1] = idisklim[1] +1
1003 # --- ajustement precis des points sur edgesPipeFissureExterneC
1005 edgesPFE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
1006 verticesPFE = findWireIntermediateVertices(wirePipeFissureExterne) # vertices intermédiaires (des points en trop dans ptsInWireFissExtPipe)
1007 idiskmin = idisklim[0] + 1 # on ne prend pas le disque sur la peau, déjà ajusté
1008 idiskmax = idisklim[1] # on ne prend pas le disque sur la peau, déjà ajusté
1010 for vtx in verticesPFE:
1012 for idisk in range(idiskmin, idiskmax):
1013 gptdsk = gptsdisks[idisk]
1014 pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe
1015 distPtVt.append((geompy.MinDistance(pt, vtx), idisk))
1017 idiskint.append(distPtVt[0][1])
1018 gptsdisks[idiskint[-1]][0][-1] = vtx
1019 logging.debug("ajustement point sur edgePipeFissureExterne, vertex: %s %s", idiskint[-1], distPtVt[0][0])
1020 for idisk in range(idiskmin, idiskmax):
1021 if idisk in idiskint:
1023 logging.debug("ajustement point sur edgePipeFissureExterne: %s", idisk)
1024 gptdsk = gptsdisks[idisk]
1025 pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe
1026 distPtEd = [(geompy.MinDistance(pt, edgePFE), k, edgePFE) for k, edgePFE in enumerate(edgesPFE)]
1028 edgePFE = distPtEd[0][2]
1029 u = projettePointSurCourbe(pt, edgePFE)
1030 ptproj = geompy.MakeVertexOnCurve(edgePFE, u)
1031 gptsdisks[idisk][0][-1] = ptproj
1033 # -----------------------------------------------------------------------
1034 # --- maillage effectif du pipe
1036 logging.debug("---------------------------- maillage effectif du pipe --------------")
1037 meshPipe = smesh.Mesh(None, "meshPipe")
1038 fondFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "FONDFISS")
1039 nodesFondFissGroup = meshPipe.CreateEmptyGroup(SMESH.NODE, "nfondfis")
1040 faceFissGroup = meshPipe.CreateEmptyGroup(SMESH.FACE, "fisInPi")
1041 edgeFaceFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeFaceFiss")
1042 edgeCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe0")
1043 edgeCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe1")
1044 faceCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe0")
1045 faceCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe1")
1046 mptsdisks = [] # vertices maillage de tous les disques
1047 mEdges = [] # identifiants edges maillage fond de fissure
1048 mEdgeFaces = [] # identifiants edges maillage edge face de fissure externe
1049 mFaces = [] # identifiants faces maillage fissure
1050 mVols = [] # identifiants volumes maillage pipe
1053 for idisk in range(idisklim[0], idisklim[1]+1): # boucle sur les disques internes
1055 # -----------------------------------------------------------------------
1058 gptdsk = gptsdisks[idisk]
1059 if idisk > idisklim[0]:
1061 mptdsk = [] # vertices maillage d'un disque
1062 for k in range(nbsegCercle):
1065 for j, pt in enumerate(points):
1066 if j == 0 and k > 0:
1069 coords = geompy.PointCoordinates(pt)
1070 id = meshPipe.AddNode(coords[0], coords[1], coords[2])
1072 mptdsk.append(mptids)
1073 mptsdisks.append(mptdsk)
1075 # -----------------------------------------------------------------------
1076 # --- groupes edges cercles debouchants
1078 if idisk == idisklim[0]:
1080 for k in range(nbsegCercle):
1081 pts.append(mptdsk[k][-1])
1083 for k in range(len(pts)):
1085 idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
1086 edges.append(idEdge)
1087 edgeCircPipe0Group.Add(edges)
1089 if idisk == idisklim[1]:
1091 for k in range(nbsegCercle):
1092 pts.append(mptdsk[k][-1])
1094 for k in range(len(pts)):
1096 idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
1097 edges.append(idEdge)
1098 edgeCircPipe1Group.Add(edges)
1100 # -----------------------------------------------------------------------
1101 # --- groupes faces debouchantes
1103 if idisk == idisklim[0]:
1105 for j in range(nbsegRad):
1106 for k in range(nbsegCercle):
1108 if k == nbsegCercle-1:
1111 idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
1113 idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
1115 faceCircPipe0Group.Add(faces)
1117 if idisk == idisklim[1]:
1119 for j in range(nbsegRad):
1120 for k in range(nbsegCercle):
1122 if k == nbsegCercle-1:
1125 idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
1127 idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
1129 faceCircPipe1Group.Add(faces)
1131 # -----------------------------------------------------------------------
1132 # --- mailles volumiques, groupes noeuds et edges de fond de fissure, groupe de face de fissure
1134 if idisk == idisklim[0]:
1136 mEdgeFaces.append(0)
1139 nodesFondFissGroup.Add([mptdsk[0][0]])
1141 ide = meshPipe.AddEdge([oldmpts[0][0], mptdsk[0][0]])
1143 fondFissGroup.Add([ide])
1144 nodesFondFissGroup.Add([mptdsk[0][0]])
1145 ide2 = meshPipe.AddEdge([oldmpts[0][-1], mptdsk[0][-1]])
1146 mEdgeFaces.append(ide2)
1147 edgeFaceFissGroup.Add([ide2])
1151 for j in range(nbsegRad):
1152 idf = meshPipe.AddFace([oldmpts[0][j], mptdsk[0][j], mptdsk[0][j+1], oldmpts[0][j+1]])
1153 faceFissGroup.Add([idf])
1157 for k in range(nbsegCercle):
1159 if k == nbsegCercle-1:
1162 idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1],
1163 oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1]])
1165 idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j],
1166 oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1], oldmpts[k1][j]])
1167 idVolCercle.append(idv)
1168 idVols.append(idVolCercle)
1170 mFaces.append(idFaces)
1171 mVols.append(idVols)
1173 pipeFissGroup = meshPipe.CreateEmptyGroup( SMESH.VOLUME, 'PIPEFISS' )
1174 nbAdd = pipeFissGroup.AddFrom( meshPipe.GetMesh() )
1176 nb, new_mesh, new_group = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries")
1177 edgesCircPipeGroup = [edgeCircPipe0Group, edgeCircPipe1Group]
1179 # --- fin du maillage du pipe
1180 # -----------------------------------------------------------------------
1181 # --- edges de bord, faces défaut à respecter
1183 aFilterManager = smesh.CreateFilterManager()
1184 nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ])
1186 unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
1187 criteres.append(unCritere)
1188 filtre = smesh.GetFilterFromCriteria(criteres)
1189 bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
1190 smesh.SetName(bordsLibres, 'bordsLibres')
1192 # --- pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
1193 # on désigne les faces de peau en quadrangles par le groupe "skinFaces"
1195 skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
1196 nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
1198 # --- maillage des éventuelles arêtes vives entre faces reconstruites
1200 if len(aretesVivesCoupees) > 0:
1201 aretesVivesC = geompy.MakeCompound(aretesVivesCoupees)
1202 meshAretesVives = smesh.Mesh(aretesVivesC)
1203 algo1d = meshAretesVives.Segment()
1204 hypo1d = algo1d.LocalLength(dmoyen,[],1e-07)
1205 putName(algo1d.GetSubMesh(), "aretesVives")
1206 putName(algo1d, "algo1d_aretesVives")
1207 putName(hypo1d, "hypo1d_aretesVives")
1208 isDone = meshAretesVives.Compute()
1209 logging.info("aretesVives fini")
1210 grpAretesVives = meshAretesVives.CreateEmptyGroup( SMESH.EDGE, 'grpAretesVives' )
1211 nbAdd = grpAretesVives.AddFrom( meshAretesVives.GetMesh() )
1213 # -----------------------------------------------------------------------
1214 # --- maillage faces de fissure
1216 logging.debug("---------------------------- maillage faces de fissure externes au pipe :%s --------------", len(facesFissExt))
1218 meshFaceFiss = smesh.Mesh(faceFissureExterne)
1219 algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_1D2D)
1220 hypo2d = algo2d.Parameters()
1221 hypo2d.SetMaxSize( areteFaceFissure )
1222 hypo2d.SetSecondOrder( 0 )
1223 hypo2d.SetOptimize( 1 )
1224 hypo2d.SetFineness( 2 )
1225 hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
1226 hypo2d.SetQuadAllowed( 0 )
1227 putName(algo2d.GetSubMesh(), "faceFiss")
1228 putName(algo2d, "algo2d_faceFiss")
1229 putName(hypo2d, "hypo2d_faceFiss")
1231 algo1d = meshFaceFiss.UseExisting1DElements(geom=edgesPipeFissureExterneC)
1232 hypo1d = algo1d.SourceEdges([ edgeFaceFissGroup ],0,0)
1233 putName(algo1d.GetSubMesh(), "edgeFissPeau")
1234 putName(algo1d, "algo1d_edgeFissPeau")
1235 putName(hypo1d, "hypo1d_edgeFissPeau")
1237 isDone = meshFaceFiss.Compute()
1238 logging.info("meshFaceFiss fini")
1240 grpFaceFissureExterne = meshFaceFiss.GroupOnGeom(faceFissureExterne, "fisOutPi", SMESH.FACE)
1241 grpEdgesPeauFissureExterne = meshFaceFiss.GroupOnGeom(edgesPeauFissureExterneC,'edgesPeauFissureExterne',SMESH.EDGE)
1242 grpEdgesPipeFissureExterne = meshFaceFiss.GroupOnGeom(edgesPipeFissureExterneC,'edgesPipeFissureExterne',SMESH.EDGE)
1244 # --- maillage faces de peau
1246 boutFromIfil = [None for i in range(nbFacesFilling)]
1247 if idFillingFromBout[0] != idFillingFromBout[1]: # repérage des extremites du pipe quand elles débouchent sur des faces différentes
1248 boutFromIfil[idFillingFromBout[0]] = 0
1249 boutFromIfil[idFillingFromBout[1]] = 1
1251 logging.debug("---------------------------- maillage faces de peau --------------")
1252 meshesFacesPeau = []
1253 for ifil in range(nbFacesFilling):
1255 if partitionsPeauFissFond[ifil] is None: # face de peau maillage sain intacte
1257 # --- edges de bord de la face de filling
1258 filling = facesDefaut[ifil]
1259 edgesFilling = geompy.ExtractShapes(filling, geompy.ShapeType["EDGE"], False)
1260 groupEdgesBordPeau = geompy.CreateGroup(filling, geompy.ShapeType["EDGE"])
1261 geompy.UnionList(groupEdgesBordPeau, edgesFilling)
1262 geomPublishInFather(initLog.debug,filling, groupEdgesBordPeau , "EdgesBords")
1264 meshFacePeau = smesh.Mesh(facesDefaut[ifil])
1266 algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
1267 hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
1268 putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
1269 putName(algo1d, "algo1d_bordsLibres", ifil)
1270 putName(hypo1d, "hypo1d_bordsLibres", ifil)
1274 facePeau = facesPeaux[ifil] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
1275 edgesCircPeau = edCircPeau[ifil] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
1276 verticesCircPeau = ptCircPeau[ifil] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
1277 groupEdgesBordPeau = gpedgeBord[ifil] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
1278 bordsVifs = gpedgeVifs[ifil] # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
1279 edgesFissurePeau = edFissPeau[ifil] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
1281 meshFacePeau = smesh.Mesh(facePeau)
1283 algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
1284 hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
1285 putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
1286 putName(algo1d, "algo1d_bordsLibres", ifil)
1287 putName(hypo1d, "hypo1d_bordsLibres", ifil)
1289 algo1d = meshFacePeau.UseExisting1DElements(geom=geompy.MakeCompound(edgesFissurePeau))
1290 hypo1d = algo1d.SourceEdges([ grpEdgesPeauFissureExterne ],0,0)
1291 putName(algo1d.GetSubMesh(), "edgePeauFiss", ifil)
1292 putName(algo1d, "algo1d_edgePeauFiss", ifil)
1293 putName(hypo1d, "hypo1d_edgePeauFiss", ifil)
1295 if bordsVifs is not None:
1296 algo1d = meshFacePeau.UseExisting1DElements(geom=bordsVifs)
1297 hypo1d = algo1d.SourceEdges([ grpAretesVives ],0,0)
1298 putName(algo1d.GetSubMesh(), "bordsVifs", ifil)
1299 putName(algo1d, "algo1d_bordsVifs", ifil)
1300 putName(hypo1d, "hypo1d_bordsVifs", ifil)
1302 for i, edgeCirc in enumerate(edgesCircPeau):
1303 if edgeCirc is not None:
1304 algo1d = meshFacePeau.UseExisting1DElements(geom=edgeCirc)
1305 if boutFromIfil[ifil] is None:
1306 hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[i] ],0,0)
1308 hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[boutFromIfil[ifil]] ],0,0)
1310 putName(algo1d.GetSubMesh(), name, ifil)
1311 putName(algo1d, "algo1d_" + name, ifil)
1312 putName(hypo1d, "hypo1d_" + name, ifil)
1314 algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_1D2D)
1315 hypo2d = algo2d.Parameters()
1316 hypo2d.SetMaxSize( dmoyen )
1317 hypo2d.SetOptimize( 1 )
1318 hypo2d.SetFineness( 2 )
1319 hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
1320 hypo2d.SetQuadAllowed( 0 )
1321 putName(algo2d.GetSubMesh(), "facePeau", ifil)
1322 putName(algo2d, "algo2d_facePeau", ifil)
1323 putName(hypo2d, "hypo2d_facePeau", ifil)
1325 isDone = meshFacePeau.Compute()
1326 logging.info("meshFacePeau %d fini", ifil)
1327 GroupFaces = meshFacePeau.CreateEmptyGroup( SMESH.FACE, "facePeau%d"%ifil )
1328 nbAdd = GroupFaces.AddFrom( meshFacePeau.GetMesh() )
1329 meshesFacesPeau.append(meshFacePeau)
1331 # --- regroupement des maillages du défaut
1333 listMeshes = [internalBoundary.GetMesh(),
1335 meshFaceFiss.GetMesh()]
1336 for mp in meshesFacesPeau:
1337 listMeshes.append(mp.GetMesh())
1339 meshBoiteDefaut = smesh.Concatenate(listMeshes, 1, 1, 1e-05,False)
1340 # pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
1341 # on désigne les faces de peau en quadrangles par le groupe "skinFaces"
1342 group_faceFissOutPipe = None
1343 group_faceFissInPipe = None
1344 groups = meshBoiteDefaut.GetGroups()
1346 if grp.GetType() == SMESH.FACE:
1347 #if "internalBoundary" in grp.GetName():
1348 # grp.SetName("skinFaces")
1349 if grp.GetName() == "fisOutPi":
1350 group_faceFissOutPipe = grp
1351 elif grp.GetName() == "fisInPi":
1352 group_faceFissInPipe = grp
1354 # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
1357 algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
1359 algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
1360 hypo3d = algo3d.MaxElementVolume(1000.0)
1361 putName(algo3d.GetSubMesh(), "boiteDefaut")
1362 putName(algo3d, "algo3d_boiteDefaut")
1363 isDone = meshBoiteDefaut.Compute()
1364 putName(meshBoiteDefaut, "boiteDefaut")
1365 logging.info("meshBoiteDefaut fini")
1367 faceFissure = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
1368 maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin,
1369 zoneDefaut_internalFaces, zoneDefaut_internalEdges)
1370 putName(maillageSain, nomFicSain+"_coupe")
1371 extrusionFaceFissure, normfiss = shapeSurFissure(facesPortFissure)
1372 maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut,
1373 None, None, 'COMPLET', normfiss)
1375 logging.info("conversion quadratique")
1376 maillageComplet.ConvertToQuadratic( 1 )
1377 logging.info("groupes")
1378 groups = maillageComplet.GetGroups()
1379 grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
1380 fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
1382 logging.info("réorientation face de fissure FACE1")
1383 grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
1384 nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
1386 logging.info("réorientation face de fissure FACE2")
1387 plansim = geompy.MakePlane(O, normfiss, 10000)
1388 fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
1389 grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
1390 nb = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
1391 fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
1393 logging.info("export maillage fini")
1394 maillageComplet.ExportMED(fichierMaillageFissure)
1395 putName(maillageComplet, nomFicFissure)
1396 logging.info("fichier maillage fissure %s", fichierMaillageFissure)
1398 if salome.sg.hasDesktop():
1399 salome.sg.updateObjBrowser()
1401 logging.info("maillage fissure fini")
1403 return maillageComplet