1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2014-2021 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
20 """procédure complète fissure générale"""
29 from salome.smesh import smeshBuilder
33 from .geomsmesh import geompy
34 from .geomsmesh import geomPublish
35 from .geomsmesh import geomPublishInFather
36 from .geomsmesh import smesh
38 from .extractionOrientee import extractionOrientee
39 from .extractionOrienteeMulti import extractionOrienteeMulti
40 from .sortFaces import sortFaces
41 from .sortEdges import sortEdges
42 from .substractSubShapes import substractSubShapes
43 from .produitMixte import produitMixte
44 from .findWireEndVertices import findWireEndVertices
45 from .findWireIntermediateVertices import findWireIntermediateVertices
46 from .orderEdgesFromWire import orderEdgesFromWire
47 from .putName import putName
48 from .enleveDefaut import enleveDefaut
49 from .shapeSurFissure import shapeSurFissure
50 from .regroupeSainEtDefaut import RegroupeSainEtDefaut
51 from .triedreBase import triedreBase
52 from .checkDecoupePartition import checkDecoupePartition
53 from .whichSide import whichSide
54 from .whichSideVertex import whichSideVertex
55 from .projettePointSurCourbe import projettePointSurCourbe
56 from .prolongeWire import prolongeWire
58 def insereFissureGenerale(maillagesSains,
59 shapesFissure, shapeFissureParams,
60 maillageFissureParams, elementsDefaut, \
61 step=-1, mailleur="MeshGems"):
62 """ TODO: a completer"""
65 shapeDefaut = shapesFissure[0] # faces de fissure, débordant
66 fondFiss = shapesFissure[4] # groupe d'edges de fond de fissure
68 rayonPipe = shapeFissureParams['rayonPipe']
69 if 'lenSegPipe' in shapeFissureParams:
70 lenSegPipe = shapeFissureParams['lenSegPipe']
72 lenSegPipe = rayonPipe
74 nomRep = maillageFissureParams['nomRep']
75 nomFicSain = maillageFissureParams['nomFicSain']
76 nomFicFissure = maillageFissureParams['nomFicFissure']
78 nbsegRad = maillageFissureParams['nbsegRad'] # nombre de couches selon un rayon du pipe
79 nbsegCercle = maillageFissureParams['nbsegCercle'] # nombre de secteur dans un cercle du pipe
80 areteFaceFissure = maillageFissureParams['areteFaceFissure']
85 isPointInterne = False
86 if 'pointIn_x' in shapeFissureParams:
87 pointIn_x = shapeFissureParams['pointIn_x']
89 if 'pointIn_y' in shapeFissureParams:
90 pointIn_y = shapeFissureParams['pointIn_y']
92 if 'pointIn_z' in shapeFissureParams:
93 pointIn_z = shapeFissureParams['pointIn_z']
96 pointInterne = geompy.MakeVertex(pointIn_x, pointIn_y, pointIn_z)
98 #fichierMaillageSain = os.path.join(nomRep, '{}.med'.format(nomFicSain))
99 fichierMaillageFissure = os.path.join(nomRep, '{}.med'.format(nomFicFissure))
101 # fillings des faces en peau
102 facesDefaut = elementsDefaut[0]
103 #centresDefaut = elementsDefaut[1]
104 #normalsDefaut = elementsDefaut[2]
105 #extrusionsDefaut = elementsDefaut[3]
106 dmoyen = elementsDefaut[4]
107 bordsPartages = elementsDefaut[5]
108 #fillconts = elementsDefaut[6]
109 #idFilToCont = elementsDefaut[7]
110 maillageSain = elementsDefaut[8]
111 internalBoundary = elementsDefaut[9]
112 zoneDefaut = elementsDefaut[10]
113 zoneDefaut_skin = elementsDefaut[11]
114 zoneDefaut_internalFaces = elementsDefaut[12]
115 zoneDefaut_internalEdges = elementsDefaut[13]
116 #edgeFondExt = elementsDefaut[14]
117 centreFondFiss = elementsDefaut[15]
118 tgtCentre = elementsDefaut[16]
120 # --- restriction de la face de fissure au domaine solide :
121 # partition face fissure étendue par fillings, on garde la plus grande face
123 partShapeDefaut = geompy.MakePartition([shapeDefaut], facesDefaut, list(), list(), geompy.ShapeType["FACE"], 0, [], 0)
124 geomPublish(initLog.debug, partShapeDefaut, 'partShapeDefaut')
125 facesPartShapeDefaut = geompy.ExtractShapes(partShapeDefaut, geompy.ShapeType["FACE"], False)
127 distfaces = [(geompy.MinDistance(face,pointInterne), i, face) for i, face in enumerate(facesPartShapeDefaut)]
129 logging.debug("selection de la face la plus proche du point interne, distance=%s",distfaces[0][0])
130 facesPortFissure = distfaces[0][2]
132 facesPartShapeDefautSorted, minSurf, maxSurf = sortFaces(facesPartShapeDefaut) # la face de fissure dans le volume doit être la plus grande
133 logging.debug("surfaces faces fissure étendue, min %s, max %s", minSurf, maxSurf)
134 facesPortFissure = facesPartShapeDefautSorted[-1] #= global
136 geomPublish(initLog.debug, facesPortFissure, "facesPortFissure")
138 O, _, _, _ = triedreBase()
140 # -----------------------------------------------------------------------------
141 # --- pipe de fond de fissure, prolongé, partition face fissure par pipe
142 # identification des edges communes pipe et face fissure
144 if geompy.NumberOfFaces(shapeDefaut) == 1:
145 plan = geompy.MakePlane(centreFondFiss, tgtCentre, 10000)
146 shapeDefaut = geompy.MakePartition([shapeDefaut], [plan], [], [], geompy.ShapeType["FACE"], 0, [], 0) #= local
147 #fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss) #= inutile
148 geomPublish(initLog.debug, shapeDefaut, 'shapeDefaut_coupe')
149 #geomPublishInFather(initLog.debug,shapeDefaut, fondFissCoupe, 'fondFiss_coupe')
151 extrem, norms = findWireEndVertices(fondFiss, True)
152 logging.debug("extrem: %s, norm: %s",extrem, norms)
153 cercle = geompy.MakeCircle(extrem[0], norms[0], rayonPipe)
154 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
155 geomPublish(initLog.debug, cercle, 'cercle')
156 fondFissProlonge = prolongeWire(fondFiss, extrem, norms, 2*rayonPipe)
157 pipeFiss = geompy.MakePipe(cercle, fondFissProlonge)
158 geomPublish(initLog.debug, pipeFiss, 'pipeFiss')
159 partFissPipe = geompy.MakePartition([shapeDefaut, pipeFiss], [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
160 geomPublish(initLog.debug, partFissPipe, 'partFissPipe')
161 fissPipe = geompy.GetInPlaceByHistory(partFissPipe, shapeDefaut) #= global
162 geomPublish(initLog.debug, fissPipe, 'fissPipe')
163 partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss) #= local
164 geomPublish(initLog.debug, partPipe, 'partPipe')
166 edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"]) #= global
167 for i, edge in enumerate(edgesPipeFiss):
168 name = "edgePipe%d"%i
169 geomPublishInFather(initLog.debug,fissPipe, edge, name)
171 wirePipeFiss = geompy.MakeWire(edgesPipeFiss) #= global
173 wirePipeFiss = geompy.MakeCompound(edgesPipeFiss)
174 logging.debug("wirePipeFiss construit sous forme de compound")
175 geomPublish(initLog.debug, wirePipeFiss, "wirePipeFiss")
177 wireFondFiss = geompy.GetInPlace(partFissPipe,fondFiss)
178 edgesFondFiss = geompy.GetSharedShapesMulti([fissPipe, wireFondFiss], geompy.ShapeType["EDGE"])
179 for i, edge in enumerate(edgesFondFiss):
180 name = "edgeFondFiss%d"%i
181 geomPublishInFather(initLog.debug,fissPipe, edge, name)
182 wireFondFiss = geompy.MakeWire(edgesFondFiss) #= global
183 geomPublish(initLog.debug, wireFondFiss,"wireFondFiss")
185 # -----------------------------------------------------------------------------
186 # --- peau et face de fissure
188 # --- partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée
189 # il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure
190 # liste de faces externes : facesDefaut
191 # liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
193 partitionsPeauFissFond = list() #= global
195 for filling in facesDefaut:
196 part = geompy.MakePartition([fissPipe, filling], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
197 isPart = checkDecoupePartition([fissPipe, filling], part)
198 if isPart: # on recrée la partition avec toutes les faces filling en outil pour avoir une face de fissure correcte
199 otherFD = [fd for fd in facesDefaut if fd != filling]
201 fissPipePart = geompy.MakePartition([fissPipe], otherFD, list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
203 fissPipePart = fissPipe
204 part = geompy.MakePartition([fissPipePart, filling], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
205 partitionsPeauFissFond.append(part)
206 geomPublish(initLog.debug, part, 'partitionPeauFissFond%d'%ipart )
208 partitionsPeauFissFond.append(None)
212 # --- arêtes vives détectées (dans quadranglesToShapeNoCorner
213 # et quadranglesToShapeWithCorner)
216 aretesVivesCoupees = list() #= global
218 for a in bordsPartages:
219 if not isinstance(a, list):
220 aretesVives.append(a)
221 name = "areteVive%d"%ia
222 geomPublish(initLog.debug, a, name)
226 aretesVives.append(a[0])
227 name = "areteVive%d"%ia
228 geomPublish(initLog.debug, a[0], name)
231 aretesVivesC = None #= global
232 if len(aretesVives) > 0:
233 aretesVivesC =geompy.MakeCompound(aretesVives)
235 # -------------------------------------------------------
236 # --- inventaire des faces de peau coupées par la fissure
237 # pour chaque face de peau : 0, 1 ou 2 faces débouchante du fond de fissure
238 # 0, 1 ou plus edges de la face de fissure externe au pipe
240 nbFacesFilling = len(partitionsPeauFissFond)
241 ptEdgeFond = [ list() for i in range(nbFacesFilling)] # pour chaque face [points edge fond de fissure aux débouchés du pipe]
242 fsPipePeau = [ list() for i in range(nbFacesFilling)] # pour chaque face [faces du pipe débouchantes]
243 edRadFPiPo = [ list() for i in range(nbFacesFilling)] # pour chaque face [edge radiale des faces du pipe débouchantes ]
244 fsFissuExt = [ list() for i in range(nbFacesFilling)] # pour chaque face [faces de fissure externes au pipe]
245 edFisExtPe = [ list() for i in range(nbFacesFilling)] # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
246 edFisExtPi = [ list() for i in range(nbFacesFilling)] # pour chaque face [edge commun au pipe des faces de fissure externes]
247 facesPeaux = [None for i in range(nbFacesFilling)] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
248 edCircPeau = [ list() for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
249 ptCircPeau = [ list() for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
250 gpedgeBord = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
251 gpedgeVifs = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupes subshape des edges aux arêtes vives entre fillings
252 edFissPeau = [ list() for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
253 ptFisExtPi = [ list() for i in range(nbFacesFilling)] # pour chaque face de peau : [point commun edFissPeau edCircPeau]
255 for ifil, partitionPeauFissFond in enumerate(partitionsPeauFissFond):
256 if partitionPeauFissFond is not None:
257 fillingFaceExterne = facesDefaut[ifil]
258 #fillingSansDecoupe = fillconts[idFilToCont[ifil]]
259 logging.debug("traitement partitionPeauFissFond %s", ifil)
260 # -----------------------------------------------------------------------
261 # --- identification edges fond de fissure, edges pipe sur la face de fissure,
264 edgesPipeC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesPipeFiss)) #= local
265 geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesPipeC, "edgesPipeFiss")
266 edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss)) #= local
267 geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesFondC, "edgesFondFiss")
269 if aretesVivesC is None: #= global facesInside facesOnside
270 [edgesInside, _, _] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
271 [facesInside, _, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
273 [edgesInside, _, _] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
274 [facesInside, _, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
276 edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"]) #= global
277 verticesPipePeau = list() #= global
279 for i, edge in enumerate(edgesPipeIn):
281 vertices = geompy.GetSharedShapesMulti([edge, geompy.MakeCompound(facesOnside)], geompy.ShapeType["VERTEX"])
282 verticesPipePeau.append(vertices[0])
283 name = "edgePipeIn%d"%i
284 geomPublishInFather(initLog.debug,partitionPeauFissFond, edge, name)
285 name = "verticePipePeau%d"%i
286 geomPublishInFather(initLog.debug,partitionPeauFissFond, vertices[0], name)
287 logging.debug("edgePipeIn%s coupe les faces OnSide", i)
289 logging.debug("edgePipeIn%s ne coupe pas les faces OnSide", i)
290 #edgesFondOut = list() #= inutile
291 edgesFondIn =list() #= global
292 if len(verticesPipePeau) > 0: # au moins une extrémité du pipe sur cette face de peau
293 #tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesOutside)], geompy.ShapeType["EDGE"])
294 #edgesFondOut = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
295 tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
296 edgesFondIn = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
298 verticesEdgesFondIn = list() # les points du fond de fissure au débouché du pipe sur la peau (indice de edgesFondIn)
299 pipexts = list() # les segments de pipe associés au points de fond de fissure débouchants (même indice)
300 cercles = list() # les cercles de generation des pipes débouchant (même indice)
301 facesFissExt = list() # les faces de la fissure externe associés au points de fond de fissure débouchants (même indice)
302 edgesFissExtPeau = list() # edges des faces de fissure externe sur la peau (même indice)
303 edgesFissExtPipe = list() # edges des faces de fissure externe sur le pipe (même indice)
304 #logging.debug("edgesFondIn %s", edgesFondIn)
306 edgesFondFiss, edgesIdByOrientation = orderEdgesFromWire(wireFondFiss)
307 for i,edge in enumerate(edgesFondFiss):
308 geomPublishInFather(initLog.debug,wireFondFiss, edge, "edgeFondFiss%d"%i)
310 for iedf, edge in enumerate(edgesFondIn):
311 name = "edgeFondIn%d"%iedf
312 geomPublishInFather(initLog.debug,partitionPeauFissFond, edge, name)
313 dist = [ geompy.MinDistance(pt, edge) for pt in verticesPipePeau]
314 ptPeau = verticesPipePeau[dist.index(min(dist))] # le point de verticesPipePeau a distance minimale de l'edge
315 [parametre, PointOnEdge, EdgeInWireIndex] = geompy.MakeProjectionOnWire(ptPeau, wireFondFiss)
316 logging.debug("parametre:%s, EdgeInWireIndex: %s, len(edgesFondFiss): %s", parametre, EdgeInWireIndex, len(edgesFondFiss))
317 localEdgeInFondFiss = edgesFondFiss[EdgeInWireIndex]
319 centre2 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, parametre)
320 geomPublishInFather(initLog.debug,partitionPeauFissFond, centre2, "centre2_%d"%iedf)
321 verticesEdgesFondIn.append(centre)
322 name = "verticeEdgesFondIn%d"%iedf
323 geomPublishInFather(initLog.debug,partitionPeauFissFond, centre, name)
324 norm = geompy.MakeTangentOnCurve(localEdgeInFondFiss, parametre)
325 geomPublishInFather(initLog.debug,partitionPeauFissFond, centre, "norm%d"%iedf)
326 cercle = geompy.MakeCircle(centre, norm, rayonPipe)
327 geomPublishInFather(initLog.debug,partitionPeauFissFond, cercle, "cerclorig%d"%iedf)
328 [vertex] = geompy.ExtractShapes(cercle, geompy.ShapeType["VERTEX"], False)
329 vec1 = geompy.MakeVector(centre, vertex)
330 vec2 = geompy.MakeVector(centre, ptPeau)
331 angle = geompy.GetAngleRadians(vec1, vec2)
332 # cas général : on reconstitue une portion de pipe, avec l'arête de couture qui coincide
333 # avec la face de fissure, au niveau du débouché sur la face externe
334 # cas dégénéré : le pipe débouche perpendiculairement à une surface plane à l'origine.
335 # La partition filling / pipe reconstruit échoue.
336 # - Si on partitionne le filling avec un simple pipe obtenu par extrusion droite du cercle,
337 # cela donne un point en trop sur le cercle.
338 # - Si on prend une vraie surface plane (pas un filling), on peut faire la partition avec
339 # les pipes reconstruits
340 logging.debug("angle=%s", angle)
341 #if abs(angle) > 1.e-7:
342 sommetAxe = geompy.MakeTranslationVector(centre, norm)
343 pm = produitMixte(centre, vertex, ptPeau, sommetAxe)
344 if pm > 0: # ajout de pi a (-)angle pour éviter des points confondus (partition échoue) dans les cas dégénérés
345 cercle = geompy.MakeRotation(cercle, norm, angle + math.pi)
347 cercle = geompy.MakeRotation(cercle, norm, -angle + math.pi)
348 name = "cercle%d"%iedf
349 geomPublishInFather(initLog.debug,partitionPeauFissFond, cercle, name)
350 cercles.append(cercle)
352 # --- estimation de la longueur du pipe necessaire de part et d'autre du point de sortie
353 if aretesVivesC is None:
354 faceTestPeau = fillingFaceExterne
356 faceTestPeau = facesDefaut[ifil]
357 sideCentre = whichSide(faceTestPeau, centre)
358 locPt0 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 0.0)
359 locPt1 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 1.0)
360 sidePt0 = whichSide(faceTestPeau, locPt0)
361 sidePt1 = whichSide(faceTestPeau, locPt1)
362 logging.debug("position centre cercle: %s, extremité edge u0: %s, u1: %s", sideCentre, sidePt0, sidePt1)
363 normFace = geompy.GetNormal(faceTestPeau, ptPeau)
364 inclPipe = abs(geompy.GetAngleRadians(norm, normFace))
365 lgp = max(rayonPipe/2., abs(3*rayonPipe*math.tan(inclPipe)))
366 logging.debug("angle inclinaison Pipe en sortie: %s degres, lgp: %s", inclPipe*180/math.pi, lgp)
368 # --- position des points extremite du pipe sur l'edge debouchante
369 # il faut la distance curviligne ofp du point central par rapport à une extrémité de l'edge débouchante
370 locEdgePart = geompy.MakePartition([localEdgeInFondFiss],[centre], list(), list(), geompy.ShapeType["EDGE"], 0, list(), 0)
371 edgesLoc = geompy.ExtractShapes(locEdgePart, geompy.ShapeType["EDGE"], False)
372 edgesLocSorted =[(geompy.MinDistance(edge, locPt0), kk, edge) for kk, edge in enumerate(edgesLoc)]
373 edgesLocSorted.sort()
374 ofp = geompy.BasicProperties(edgesLocSorted[0][2])[0] # distance curviligne centre locPt0
375 logging.debug("distance curviligne centre extremite0: %s", ofp)
376 p1 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp +lgp, locPt0)
377 p2 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp -lgp, locPt0)
378 geomPublishInFather(initLog.debug,wireFondFiss, p1, "p1_%d"%iedf)
379 geomPublishInFather(initLog.debug,wireFondFiss, p2, "p2_%d"%iedf)
381 edgePart = geompy.MakePartition([localEdgeInFondFiss], [p1,p2], list(), list(), geompy.ShapeType["EDGE"], 0, list(), 0)
382 edps = geompy.ExtractShapes(edgePart, geompy.ShapeType["EDGE"], True)
384 if geompy.MinDistance(centre, edp) < 1.e-3:
385 pipext = geompy.MakePipe(cercle, edp)
386 name = "pipeExt%d"%iedf
387 geomPublishInFather(initLog.debug,partitionPeauFissFond, pipext, name)
388 pipexts.append(pipext)
390 for face in facesInside:
391 logging.debug("recherche edges communes entre une face inside et (faces onside, edges pipe et fond débouchante)")
392 edgesPeauFis = list()
393 edgesPipeFis = list()
394 edgesPipeFnd = list()
396 edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
397 logging.debug(" faces onside %s",edgesPeauFis)
398 edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
399 logging.debug(" edgesPipeIn %s", edgesPipeFis)
400 edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
401 logging.debug(" edgesFondIn %s ", edgesPipeFnd)
403 logging.debug(" pb edges communes %s %s %s",edgesPeauFis, edgesPipeFis, edgesPipeFnd)
404 if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
405 dist = geompy.MinDistance(geompy.MakeCompound(edgesPeauFis), ptPeau)
406 logging.debug(" test distance extrémité reference %s", dist)
407 if dist < 1.e-3: # c'est la face de fissure externe associée
408 logging.debug(" face %s inside ajoutée", i)
409 facesFissExt.append(face)
410 name="faceFissExt%d"%iedf
411 geomPublishInFather(initLog.debug,partitionPeauFissFond, face, name)
413 for _, edpe in enumerate(edgesPeauFis):
414 for _, edpi in enumerate(edgesPipeFis):
415 dist = geompy.MinDistance(edpe, edpi)
417 edgesFissExtPeau.append(edpe)
418 name="edgesFissExtPeau%d"%iedf
419 geomPublishInFather(initLog.debug,partitionPeauFissFond, edpe, name)
420 edgesFissExtPipe.append(edpi)
421 name="edgesFissExtPipe%d"%iedf
422 geomPublishInFather(initLog.debug,partitionPeauFissFond, edpi, name)
427 if len(verticesPipePeau) == 0: # aucune extrémité du pipe sur cette face de peau
428 # il faut recenser les edges de fissure sur la face de peau
430 for face in facesInside:
431 edgesPeauFis = list()
432 edgesPipeFis = list()
433 edgesPipeFnd = list()
435 edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
436 edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
437 edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
440 if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
441 edgesFissExtPeau.append(edgesPeauFis[0])
442 name="edgesFissExtPeau%d"%j
443 geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesPeauFis[0], name)
446 # -----------------------------------------------------------------------
447 # --- identification faces de peau : face de peau percée du pipe, extrémités du pipe
448 # La partition avec le pipe peut créer un vertex (et un edge) de trop sur le cercle projeté,
449 # quand le cercle est très proche de la face.
450 # dans ce cas, la projection du cercle sur la face suivie d'une partition permet
451 # d'éviter le point en trop
453 facesAndFond = facesOnside
454 facesAndFond.append(wireFondFiss)
456 partitionPeauByPipe = geompy.MakePartition(facesAndFond, pipexts, list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
458 logging.debug("probleme partition face pipe, contournement avec MakeSection")
460 for pipext in pipexts:
461 sections.append(geompy.MakeSection(facesOnside[0], pipext))
462 partitionPeauByPipe = geompy.MakePartition(facesAndFond, sections, list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
464 # contrôle edge en trop sur edges circulaires
465 if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
468 facesPeau = geompy.ExtractShapes(partitionPeauByPipe, geompy.ShapeType["FACE"], False)
469 facesPeauSorted, _, _ = sortFaces(facesPeau)
470 for i, face in enumerate(facesPeauSorted[:-1]): # on ne teste que la ou les petites faces "circulaires"
471 nbv = geompy.NumberOfEdges(face)
472 logging.debug("nombre d'edges sur face circulaire: %s", nbv)
474 edgeEnTrop.append(True) # TODO : distinguer les cas avec deux faces circulaires dont l'une est correcte
476 edgeEnTrop.append(False)
477 refaire = sum(edgeEnTrop)
479 dc = [(geompy.MinDistance(verticesEdgesFondIn[0], fac), i) for i, fac in enumerate(facesPeauSorted[:-1])]
481 logging.debug("dc sorted: %s", dc)
482 i0 = dc[0][1] # indice de facesPeauSorted qui correspond à verticesEdgesFondIn[0], donc 0 pour cercles
484 for i, bad in enumerate(edgeEnTrop):
490 outilPart[j] = geompy.MakeProjection(cercles[j],facesOnside[0])
491 partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
493 name="partitionPeauByPipe%d"%ifil
494 geomPublish(initLog.debug, partitionPeauByPipe, name)
495 [edgesPeauFondIn, _, _] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "EDGE", 1.e-3)
496 [_, _, facesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "FACE", 1.e-3)
498 if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
499 facesPeauSorted, _, _ = sortFaces(facesPeauFondOn)
500 facePeau = facesPeauSorted[-1] # la plus grande face
502 facePeau =geompy.MakePartition(facesPeauFondOn, list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
503 name="facePeau%d"%ifil
504 geomPublish(initLog.debug, facePeau, name)
506 facesPipePeau = [None for i in range(len(edgesFissExtPipe))]
507 endsEdgeFond = [None for i in range(len(edgesFissExtPipe))]
508 edgeRadFacePipePeau = [None for i in range(len(edgesFissExtPipe))]
510 edgesListees = list()
511 edgesCircPeau = list()
512 verticesCircPeau = list()
513 if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
515 for face in facesPeauSorted[:-1]: # la ou les faces débouchantes, pas la grande face de peau
516 logging.debug("examen face debouchante circulaire")
517 for i,efep in enumerate(edgesFissExtPipe):
518 dist = geompy.MinDistance(face, efep)
519 logging.debug(" distance face circulaire edge %s", dist)
521 for ik, edpfi in enumerate(edgesPeauFondIn):
522 if geompy.MinDistance(face, edpfi) < 1e-3:
525 sharedVertices = geompy.GetSharedShapesMulti([face, edgesPeauFondIn[ikok]], geompy.ShapeType["VERTEX"])
526 nameFace = "facePipePeau%d"%i
527 nameVert = "endEdgeFond%d"%i
528 nameEdge = "edgeRadFacePipePeau%d"%i
529 facesPipePeau[i] = face
530 endsEdgeFond[i] = sharedVertices[0]
531 geomPublish(initLog.debug, face, nameFace)
532 geomPublish(initLog.debug, sharedVertices[0], nameVert)
533 edgesFace = geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], True)
534 for edge in edgesFace:
535 if geompy.MinDistance(edge, sharedVertices[0]) < 1e-3:
536 edgeRadFacePipePeau[i] = edge
537 geomPublish(initLog.debug, edge, nameEdge)
540 # --- edges circulaires de la face de peau et points de jonction de la face externe de fissure
541 logging.debug("facesPipePeau: %s", facesPipePeau)
542 edgesCircPeau = [None for i in range(len(facesPipePeau))]
543 verticesCircPeau = [None for i in range(len(facesPipePeau))]
544 for i,fcirc in enumerate(facesPipePeau):
545 edges = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["EDGE"])
546 grpEdgesCirc = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
547 geompy.UnionList(grpEdgesCirc, edges)
548 edgesCircPeau[i] = grpEdgesCirc
549 name = "edgeCirc%d"%i
550 geomPublishInFather(initLog.debug,facePeau, grpEdgesCirc, name)
551 edgesListees = edgesListees + edges
552 vertices = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["VERTEX"])
553 grpVertCircPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["VERTEX"])
554 geompy.UnionList(grpVertCircPeau, vertices)
555 verticesCircPeau[i] = grpVertCircPeau
556 name = "pointEdgeCirc%d"%i
557 geomPublishInFather(initLog.debug,facePeau, grpVertCircPeau, name)
558 # --- au moins une extrémité du pipe sur cette face de peau
560 # --- edges de bord de la face de peau
562 edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
564 for i, edge in enumerate(edgesFilling):
565 edgepeau = geompy.GetInPlace(facePeau, edge)
566 name = "edgepeau%d"%i
567 geomPublishInFather(initLog.debug,facePeau,edgepeau, name)
568 logging.debug("edgepeau %s", geompy.ShapeInfo(edgepeau))
569 if geompy.ShapeInfo(edgepeau)['EDGE'] > 1:
570 logging.debug(" EDGES multiples")
571 edgs = geompy.ExtractShapes(edgepeau, geompy.ShapeType["EDGE"], False)
575 logging.debug(" EDGE")
576 edgesBords.append(edgepeau)
577 edgesListees.append(edgepeau)
578 groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
579 geompy.UnionList(groupEdgesBordPeau, edgesBords)
581 if aretesVivesC is not None:
582 bordsVifs = geompy.GetInPlace(facePeau, aretesVivesC)
583 if bordsVifs is not None:
584 geomPublishInFather(initLog.debug,facePeau, bordsVifs, "bordsVifs")
585 groupEdgesBordPeau = geompy.CutGroups(groupEdgesBordPeau, bordsVifs)
587 if len(aretesVivesCoupees) > 0:
588 grpC = geompy.MakeCompound(aretesVivesCoupees)
589 grptmp = geompy.GetInPlace(facePeau, grpC)
590 if grptmp is not None:
591 grpnew = geompy.CutGroups(bordsVifs, grptmp) # ce qui est nouveau dans bordsVifs
594 if grpnew is not None:
595 edv = geompy.ExtractShapes(grpnew, geompy.ShapeType["EDGE"], False)
596 aretesVivesCoupees += edv
597 logging.debug("aretesVivesCoupees %s",aretesVivesCoupees)
598 geomPublishInFather(initLog.debug,facePeau, groupEdgesBordPeau , "EdgesBords")
600 # --- edges de la face de peau partagées avec la face de fissure
602 edgesPeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
603 edges = substractSubShapes(facePeau, edgesPeau, edgesListees)
604 edgesFissurePeau = list()
605 if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
606 edgesFissurePeau = [None for i in range(len(verticesCircPeau))] # edges associés aux extrémités du pipe, en premier
608 for i, grpVert in enumerate(verticesCircPeau):
609 if (geompy.MinDistance(grpVert, edge) < 1.e-3) and (edge not in edgesFissurePeau):
610 edgesFissurePeau[i] = edge
611 name = "edgeFissurePeau%d"%i
612 geomPublishInFather(initLog.debug,facePeau, edge, name)
613 for edge in edges: # on ajoute après les edges manquantes
614 if edge not in edgesFissurePeau:
615 edgesFissurePeau.append(edge)
617 for i, edge in enumerate(edges):
618 edgesFissurePeau.append(edge)
619 name = "edgeFissurePeau%d"%i
620 geomPublishInFather(initLog.debug,facePeau, edge, name)
622 ptEdgeFond[ifil] = endsEdgeFond # pour chaque face [points edge fond de fissure aux débouchés du pipe]
623 fsPipePeau[ifil] = facesPipePeau # pour chaque face [faces du pipe débouchantes]
624 edRadFPiPo[ifil] = edgeRadFacePipePeau # pour chaque face [edge radiale des faces du pipe débouchantes ]
625 fsFissuExt[ifil] = facesFissExt # pour chaque face [faces de fissure externes au pipe]
626 edFisExtPe[ifil] = edgesFissExtPeau # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
627 edFisExtPi[ifil] = edgesFissExtPipe # pour chaque face [edge commun au pipe des faces de fissure externes]
628 facesPeaux[ifil] = facePeau # pour chaque face : la face de peau finale a mailler (percee des faces débouchantes)
629 edCircPeau[ifil] = edgesCircPeau # pour chaque face de peau : [groupe subshapes edges circulaires aux débouchés du pipe]
630 ptCircPeau[ifil] = verticesCircPeau # pour chaque face de peau : [groupe subshapes points sur edges circulaires aux débouchés du pipe]
631 gpedgeBord[ifil] = groupEdgesBordPeau # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
632 gpedgeVifs[ifil] = bordsVifs # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
633 edFissPeau[ifil] = edgesFissurePeau # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
634 ptFisExtPi[ifil] = verticesPipePeau # pour chaque face de peau : [point commun edFissPeau edCircPeau]
636 # -----------------------------------------------------------------------
637 # fin de la boucle sur les faces de filling
638 # -----------------------------------------------------------------------
640 for i, avc in enumerate(aretesVivesCoupees):
641 name = "areteViveCoupee%d"%i
642 geomPublish(initLog.debug, avc, name)
644 # --- identification des faces et edges de fissure externe pour maillage
646 facesFissExt = list()
647 edgesFissExtPeau = list()
648 edgesFissExtPipe = list()
649 for ifil in range(nbFacesFilling): # TODO: éliminer les doublons (comparer tous les vertices triés, avec mesure de distance ?)
650 facesFissExt += fsFissuExt[ifil]
651 edgesFissExtPeau += edFisExtPe[ifil]
652 edgesFissExtPipe += edFisExtPi[ifil]
653 logging.debug("---------------------------- identification faces de fissure externes au pipe :%s ", len(facesFissExt))
654 # regroupement des faces de fissure externes au pipe.
656 if len(facesFissExt) > 1:
657 faceFissureExterne = geompy.MakePartition(facesFissExt, list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
658 edgesPipeFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesPipeFiss)) # edgesFissExtPipe peut ne pas couvrir toute la longueur
659 # edgesPeauFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesFissExtPeau))
660 # il peut manquer des edges de faceFissureExterne en contact avec la peau dans edgesFissExtPeau
661 (_, closedFreeBoundaries, _) = geompy.GetFreeBoundary(faceFissureExterne)
662 edgesBordFFE = list()
663 for bound in closedFreeBoundaries:
664 edgesBordFFE += geompy.ExtractShapes(bound, geompy.ShapeType["EDGE"], False)
665 edgesBordFFEid = [ (ed,geompy.GetSubShapeID(faceFissureExterne, ed)) for ed in edgesBordFFE]
666 logging.debug("edgesBordFFEid %s", edgesBordFFEid)
667 edgesPPE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
668 edgesPPEid = [ geompy.GetSubShapeID(faceFissureExterne, ed) for ed in edgesPPE]
669 logging.debug("edgesPPEid %s", edgesPPEid)
670 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
671 logging.debug("edgesPFE %s", edgesPFE)
672 edgesPeauFissureExterneC = geompy.MakeCompound(edgesPFE)
674 faceFissureExterne = facesFissExt[0]
675 edgesPeauFissureExterneC = geompy.MakeCompound(edgesFissExtPeau)
676 edgesPipeFissureExterneC = geompy.MakeCompound(edgesFissExtPipe)
677 wirePipeFissureExterne = geompy.MakeWire(geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False))
678 geomPublish(initLog.debug, faceFissureExterne, "faceFissureExterne")
679 geomPublishInFather(initLog.debug,faceFissureExterne, edgesPeauFissureExterneC, "edgesPeauFissureExterne")
680 geomPublishInFather(initLog.debug,faceFissureExterne, edgesPipeFissureExterneC, "edgesPipeFissureExterne")
682 logging.debug("---------------------------- Preparation Maillage du Pipe --------------")
683 # -----------------------------------------------------------------------
684 # --- preparation maillage du pipe :
685 # - détections des points a respecter : jonction des edges/faces constituant
686 # la face de fissure externe au pipe
687 # - points sur les edges de fond de fissure et edges pipe/face fissure,
688 # - vecteurs tangents au fond de fissure (normal au disque maillé)
690 # --- option de maillage selon le rayon de courbure du fond de fissure
692 for edff in edgesFondFiss:
693 lenEdgeFondExt += geompy.BasicProperties(edff)[0]
696 for filling in facesDefaut:
697 disfond.append(geompy.MinDistance(centreFondFiss, filling))
700 nbSegQuart = 5 # on veut 5 segments min sur un quart de cercle
701 alpha = math.pi/(4*nbSegQuart)
702 deflexion = rcourb*(1.0 -math.cos(alpha))
703 lgmin = lenSegPipe*0.25
704 lgmax = lenSegPipe*1.5
705 logging.debug("rcourb: %s, lenFond:%s, deflexion: %s, lgmin: %s, lgmax: %s", rcourb, lenEdgeFondExt, deflexion, lgmin, lgmax)
707 meshFondExt = smesh.Mesh(wireFondFiss)
708 algo1d = meshFondExt.Segment()
709 hypo1d = algo1d.Adaptive(lgmin, lgmax, deflexion) # a ajuster selon la profondeur de la fissure
711 is_done = meshFondExt.Compute()
712 text = "meshFondExt.Compute"
714 logging.info(text+" OK")
716 text = "Erreur au calcul du maillage.\n" + text
718 raise Exception(text)
720 ptGSdic = {} # dictionnaire [paramètre sur la courbe] --> point géométrique
721 allNodeIds = meshFondExt.GetNodesId()
722 for nodeId in allNodeIds:
723 xyz = meshFondExt.GetNodeXYZ(nodeId)
724 #logging.debug("nodeId %s, coords %s", nodeId, str(xyz))
725 pt = geompy.MakeVertex(xyz[0], xyz[1], xyz[2])
726 parametre, PointOnEdge, EdgeInWireIndex = geompy.MakeProjectionOnWire(pt, wireFondFiss) # parametre compris entre 0 et 1
727 edgeOrder = edgesIdByOrientation[EdgeInWireIndex]
728 ptGSdic[(edgeOrder, EdgeInWireIndex, parametre)] = pt
729 #logging.debug("nodeId %s, parametre %s", nodeId, str(parametre))
730 usort = sorted(ptGSdic)
731 logging.debug("nombre de points obtenus par deflexion %s",len(usort))
737 vertcx = ptGSdic[edu]
738 norm = geompy.MakeTangentOnCurve(edgesFondFiss[edu[1]], edu[2])
739 plan = geompy.MakePlane(vertcx, norm, 3*rayonPipe)
740 part = geompy.MakePartition([plan], [wirePipeFiss], list(), list(), geompy.ShapeType["VERTEX"], 0, list(), 0)
741 liste = geompy.ExtractShapes(part, geompy.ShapeType["VERTEX"], True)
742 if len(liste) == 5: # 4 coins du plan plus intersection recherchée
744 if geompy.MinDistance(point, vertcx) < 1.1*rayonPipe: # les quatre coins sont plus loin
747 centres.append(vertcx)
748 origins.append(vertpx)
750 # name = "vertcx%d"%i
751 # geomPublishInFather(initLog.debug,wireFondFiss, vertcx, name)
752 # name = "vertpx%d"%i
753 # geomPublishInFather(initLog.debug,wireFondFiss, vertpx, name)
755 # geomPublishInFather(initLog.debug,wireFondFiss, plan, name)
757 # --- maillage du pipe étendu, sans tenir compte de l'intersection avec la face de peau
759 logging.debug("nbsegCercle %s", nbsegCercle)
761 # -----------------------------------------------------------------------
762 # --- points géométriques
764 gptsdisks = list() # vertices géométrie de tous les disques
765 raydisks = [list() for i in range(nbsegCercle)]
766 for i, centres_i in enumerate(centres): # boucle sur les disques
767 gptdsk = list() # vertices géométrie d'un disque
771 vec1 = geompy.MakeVector(vertcx, vertpx)
773 points = [vertcx] # les points du rayon de référence
774 for j in range(nbsegRad):
775 pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, (j+1)*float(rayonPipe)/nbsegRad)
777 gptdsk.append(points)
778 pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, 1.5*rayonPipe)
779 rayon = geompy.MakeLineTwoPnt(vertcx, pt)
780 raydisks[0].append(rayon)
782 for k in range(nbsegCercle-1):
783 angle = (k+1)*2*math.pi/nbsegCercle
784 pts = [vertcx] # les points d'un rayon obtenu par rotation
785 for j in range(nbsegRad):
786 pt = geompy.MakeRotation(points[j+1], normal, angle)
789 ray = geompy.MakeRotation(rayon, normal, angle)
790 raydisks[k+1].append(ray)
792 gptsdisks.append(gptdsk)
794 # -----------------------------------------------------------------------
795 # --- recherche des points en trop (externes au volume à remailler)
796 # - on associe chaque extrémité du pipe à une face filling
797 # - on part des disques aux extrémités du pipe
798 # - pour chaque disque, on prend les vertices de géométrie,
799 # on marque leur position relative à la face.
800 # - on s'arrete quand tous les noeuds sont dedans
802 logging.debug("---------------------------- recherche des points du pipe a éliminer --------------")
806 idFillingFromBout = [None, None] # contiendra l'index du filling pour les extrémités 0 et 1
807 for ifil in range(nbFacesFilling):
808 for _, pt in enumerate(ptEdgeFond[ifil]): # il y a un ou deux points débouchant sur cette face
809 if geompy.MinDistance(pt,pt0) < geompy.MinDistance(pt,pt1): # TODO: trouver plus fiable pour les cas tordus...
810 idFillingFromBout[0] = ifil
812 idFillingFromBout[1] = ifil
813 logging.debug("association bouts du pipe - faces de filling: %s", idFillingFromBout)
815 facesPipePeau = list()
816 edgeRadFacePipePeau = list()
817 for ifil in range(nbFacesFilling):
818 facesPipePeau += fsPipePeau[ifil]
819 edgeRadFacePipePeau += edRadFPiPo[ifil]
821 logging.debug("recherche des disques de noeuds complètement internes")
822 idisklim = list() # indices des premier et dernier disques internes
823 idiskout = list() # indices des premier et dernier disques externes
824 for bout in range(2):
830 idisk = len(gptsdisks)
832 numout = len(gptsdisks)
837 logging.debug("examen disque %s", idisk)
838 gptdsk = gptsdisks[idisk]
840 for k in range(nbsegCercle):
842 for j, pt in enumerate(points):
843 side = whichSideVertex(facesDefaut[idFillingFromBout[bout]], pt)
845 if outside: # premier point detecté dedans
847 numout = idisk -inc # le disque précédent était dehors
849 inside = False # ce point est dehors
850 if not inside and not outside:
852 idisklim.append(idisk) # premier et dernier disques internes
853 idiskout.append(numout) # premier et dernier disques externes
855 # --- listes de nappes radiales en filling à chaque extrémité débouchante
856 facesDebouchantes = [False, False]
857 idFacesDebouchantes = [-1, -1] # contiendra les indices des faces disque débouchantes (facesPipePeau)
859 for i, idisk in enumerate(idisklim):
861 logging.debug("extremité %s, indices disques interne %s, externe %s",i, idisk, numout)
863 if (idisk != 0) and (idisk != len(gptsdisks)-1): # si extrémité débouchante
864 for k in range(nbsegCercle):
866 iddeb = max(0, numout)
867 idfin = max(iddeb+3,idisk+1) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
868 #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
869 comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
870 name='compoundRay%d'%k
871 geomPublish(initLog.debug, comp, name)
873 idfin = min(len(gptsdisks), numout+1)
874 iddeb = min(idfin-3, idisk) # 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)
879 nappe = geompy.MakeFilling(comp, 2, 5, 0.0001, 0.0001, 0, GEOM.FOM_Default)
882 geomPublish(initLog.debug, nappe, name)
883 facesDebouchantes[i] = True
884 listNappes.append(nappes)
886 # --- mise en correspondance avec les indices des faces disque débouchantes (facesPipePeau)
887 for i, nappes in enumerate(listNappes):
888 if facesDebouchantes[i]:
889 for k, face in enumerate(facesPipePeau):
890 edge = geompy.MakeSection(face, nappes[0])
891 if geompy.NbShapes(edge, geompy.ShapeType["EDGE"]) > 0:
892 idFacesDebouchantes[i] = k
894 logging.debug("idFacesDebouchantes: %s", idFacesDebouchantes)
896 # --- construction des listes d'edges radiales sur chaque extrémité débouchante
898 for i, nappes in enumerate(listNappes):
899 indice = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
901 listEdges.append(list())
903 face = facesPipePeau[indice]
904 edges = [edgeRadFacePipePeau[indice]]
905 for k, nappe in enumerate(nappes):
907 obj = geompy.MakeSection(face, nappes[k]) # normalement une edge, parfois un compound d'edges dont un tout petit
909 vs = geompy.ExtractShapes(obj, geompy.ShapeType["VERTEX"], False)
911 eds = geompy.ExtractShapes(obj, geompy.ShapeType["EDGE"], False)
912 [edsorted, _,maxl] = sortEdges(eds)
915 maxl = geompy.BasicProperties(edge)[0]
916 if maxl < 0.01: # problème MakeSection
917 logging.debug("problème MakeSection recherche edge radiale %s, longueur trop faible: %s, utilisation partition", k, maxl)
918 partNappeFace = geompy.MakePartition([face, nappes[k]], list() , list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
919 edps= geompy.ExtractShapes(partNappeFace, geompy.ShapeType["EDGE"], False)
921 for ii, ed in enumerate(edps):
922 vxs = geompy.ExtractShapes(ed, geompy.ShapeType["VERTEX"], False)
923 distx = [geompy.MinDistance(vx, face) for vx in vxs]
924 distx += [geompy.MinDistance(vx, nappes[k]) for vx in vxs]
926 logging.debug(" dmax %s",dmax)
929 logging.debug(" edges issues de la partition: %s", ednouv)
930 for ii, ed in enumerate(ednouv):
931 geomPublish(initLog.debug, ed, "ednouv%d"%ii)
932 [edsorted, _,maxl] = sortEdges(ednouv)
933 logging.debug(" longueur edge trouvée: %s", maxl)
936 name = 'edgeEndPipe%d'%k
937 geomPublish(initLog.debug, edge, name)
938 listEdges.append(edges)
940 # --- création des points du maillage du pipe sur la face de peau
941 for i, edges in enumerate(listEdges):
942 indice = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
945 if indice > 0: # indice vaut 0 ou 1
946 indice = -1 # si indice vaut 1, on prend le dernier élément de la liste (1 ou 2 extrémités débouchent sur la face)
947 centre = ptEdgeFond[idFillingFromBout[i]][indice]
948 name = "centre%d"%indice
949 geomPublish(initLog.debug, centre, name)
950 vertPipePeau = ptFisExtPi[idFillingFromBout[i]][indice]
951 geomPublishInFather(initLog.debug,centre, vertPipePeau, "vertPipePeau")
952 grpsEdgesCirc = edCircPeau[idFillingFromBout[i]] # liste de groupes
954 for grpEdgesCirc in grpsEdgesCirc:
955 edgesCirc += geompy.ExtractShapes(grpEdgesCirc, geompy.ShapeType["EDGE"], False)
956 for k, edge in enumerate(edges):
957 extrems = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], True)
958 if geompy.MinDistance(centre, extrems[0]) < geompy.MinDistance(centre, extrems[1]):
962 # ajustement du point extrémité (bout) sur l'edge circulaire en face de peau
963 logging.debug("edgesCirc: %s", edgesCirc)
964 distEdgeCirc = [(geompy.MinDistance(bout, edgeCirc), k2, edgeCirc) for k2, edgeCirc in enumerate(edgesCirc)]
966 logging.debug("distEdgeCirc: %s", distEdgeCirc)
967 u = projettePointSurCourbe(bout, distEdgeCirc[0][2])
968 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.
969 extrCircs = geompy.ExtractShapes(distEdgeCirc[0][2], geompy.ShapeType["VERTEX"], True)
970 if geompy.MinDistance(bout, extrCircs[0]) < geompy.MinDistance(bout, extrCircs[1]):
975 bout = geompy.MakeVertexOnCurve(distEdgeCirc[0][2], u)
977 geomPublishInFather(initLog.debug,centre, bout, name)
978 # enregistrement des points dans la structure
980 for j in range(nbsegRad +1):
981 u = j/float(nbsegRad)
982 points.append(geompy.MakeVertexOnCurve(edge, u))
983 if geompy.MinDistance(bout, points[0]) < geompy.MinDistance(centre, points[0]):
987 gptdsk.append(points)
989 gptsdisks[idisklim[0] -1] = gptdsk
990 idisklim[0] = idisklim[0] -1
992 gptsdisks[idisklim[1] +1] = gptdsk
993 idisklim[1] = idisklim[1] +1
995 # --- ajustement precis des points sur edgesPipeFissureExterneC
997 edgesPFE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
998 verticesPFE, _ = findWireIntermediateVertices(wirePipeFissureExterne) # vertices intermédiaires (des points en trop dans ptsInWireFissExtPipe)
999 idiskmin = idisklim[0] + 1 # on ne prend pas le disque sur la peau, déjà ajusté
1000 idiskmax = idisklim[1] # on ne prend pas le disque sur la peau, déjà ajusté
1002 for vtx in verticesPFE:
1004 for idisk in range(idiskmin, idiskmax):
1005 gptdsk = gptsdisks[idisk]
1006 pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe
1007 distPtVt.append((geompy.MinDistance(pt, vtx), idisk))
1009 idiskint.append(distPtVt[0][1])
1010 gptsdisks[idiskint[-1]][0][-1] = vtx
1011 logging.debug("ajustement point sur edgePipeFissureExterne, vertex: %s %s", idiskint[-1], distPtVt[0][0])
1012 for idisk in range(idiskmin, idiskmax):
1013 if idisk in idiskint:
1015 logging.debug("ajustement point sur edgePipeFissureExterne: %s", idisk)
1016 gptdsk = gptsdisks[idisk]
1017 pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe
1018 distPtEd = [(geompy.MinDistance(pt, edgePFE), k, edgePFE) for k, edgePFE in enumerate(edgesPFE)]
1020 edgePFE = distPtEd[0][2]
1021 u = projettePointSurCourbe(pt, edgePFE)
1022 ptproj = geompy.MakeVertexOnCurve(edgePFE, u)
1023 gptsdisks[idisk][0][-1] = ptproj
1025 # -----------------------------------------------------------------------
1026 # --- maillage effectif du pipe
1028 logging.debug("---------------------------- maillage effectif du pipe --------------")
1029 meshPipe = smesh.Mesh(None, "meshPipe")
1030 fondFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "FONDFISS")
1031 nodesFondFissGroup = meshPipe.CreateEmptyGroup(SMESH.NODE, "nfondfis")
1032 faceFissGroup = meshPipe.CreateEmptyGroup(SMESH.FACE, "fisInPi")
1033 edgeFaceFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeFaceFiss")
1034 edgeCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe0")
1035 edgeCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe1")
1036 faceCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe0")
1037 faceCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe1")
1038 mptsdisks = list() # vertices maillage de tous les disques
1039 mEdges = list() # identifiants edges maillage fond de fissure
1040 mEdgeFaces = list() # identifiants edges maillage edge face de fissure externe
1041 mFaces = list() # identifiants faces maillage fissure
1042 mVols = list() # identifiants volumes maillage pipe
1045 for idisk in range(idisklim[0], idisklim[1]+1): # boucle sur les disques internes
1047 # -----------------------------------------------------------------------
1050 gptdsk = gptsdisks[idisk]
1051 if idisk > idisklim[0]:
1053 mptdsk = list() # vertices maillage d'un disque
1054 for k in range(nbsegCercle):
1057 for j, pt in enumerate(points):
1058 if j == 0 and k > 0:
1059 indice = mptdsk[0][0]
1061 coords = geompy.PointCoordinates(pt)
1062 indice = meshPipe.AddNode(coords[0], coords[1], coords[2])
1063 mptids.append(indice)
1064 mptdsk.append(mptids)
1065 mptsdisks.append(mptdsk)
1067 # -----------------------------------------------------------------------
1068 # --- groupes edges cercles debouchants
1070 if idisk == idisklim[0]:
1072 for k in range(nbsegCercle):
1073 pts.append(mptdsk[k][-1])
1075 for k, pts_k in enumerate(pts):
1077 idEdge = meshPipe.AddEdge([pts_k, pts[k1]])
1078 edges.append(idEdge)
1079 edgeCircPipe0Group.Add(edges)
1081 if idisk == idisklim[1]:
1083 for k in range(nbsegCercle):
1084 pts.append(mptdsk[k][-1])
1086 for k, pts_k in enumerate(pts):
1088 idEdge = meshPipe.AddEdge([pts_k, pts[k1]])
1089 edges.append(idEdge)
1090 edgeCircPipe1Group.Add(edges)
1092 # -----------------------------------------------------------------------
1093 # --- groupes faces debouchantes
1095 if idisk == idisklim[0]:
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 faceCircPipe0Group.Add(faces)
1109 if idisk == idisklim[1]:
1111 for j in range(nbsegRad):
1112 for k in range(nbsegCercle):
1114 if k == nbsegCercle-1:
1117 idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
1119 idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
1121 faceCircPipe1Group.Add(faces)
1123 # -----------------------------------------------------------------------
1124 # --- mailles volumiques, groupes noeuds et edges de fond de fissure, groupe de face de fissure
1126 if idisk == idisklim[0]:
1128 mEdgeFaces.append(0)
1131 nodesFondFissGroup.Add([mptdsk[0][0]])
1133 ide = meshPipe.AddEdge([oldmpts[0][0], mptdsk[0][0]])
1135 fondFissGroup.Add([ide])
1136 nodesFondFissGroup.Add([mptdsk[0][0]])
1137 ide2 = meshPipe.AddEdge([oldmpts[0][-1], mptdsk[0][-1]])
1138 mEdgeFaces.append(ide2)
1139 edgeFaceFissGroup.Add([ide2])
1143 for j in range(nbsegRad):
1144 idf = meshPipe.AddFace([oldmpts[0][j], mptdsk[0][j], mptdsk[0][j+1], oldmpts[0][j+1]])
1145 faceFissGroup.Add([idf])
1148 idVolCercle = list()
1149 for k in range(nbsegCercle):
1151 if k == nbsegCercle-1:
1154 idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1],
1155 oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1]])
1157 idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j],
1158 oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1], oldmpts[k1][j]])
1159 idVolCercle.append(idv)
1160 idVols.append(idVolCercle)
1162 mFaces.append(idFaces)
1163 mVols.append(idVols)
1165 pipeFissGroup = meshPipe.CreateEmptyGroup( SMESH.VOLUME, 'PIPEFISS' )
1166 _ = pipeFissGroup.AddFrom( meshPipe.GetMesh() )
1168 _, _, _ = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries")
1169 edgesCircPipeGroup = [edgeCircPipe0Group, edgeCircPipe1Group]
1171 # --- fin du maillage du pipe
1172 # -----------------------------------------------------------------------
1173 # --- edges de bord, faces défaut à respecter
1175 _ = smesh.CreateFilterManager()
1176 _, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ])
1178 unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
1179 criteres.append(unCritere)
1180 filtre = smesh.GetFilterFromCriteria(criteres)
1181 bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
1182 smesh.SetName(bordsLibres, 'bordsLibres')
1184 # --- pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
1185 # on désigne les faces de peau en quadrangles par le groupe "skinFaces"
1187 skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
1188 _ = skinFaces.AddFrom( internalBoundary.GetMesh() )
1190 # --- maillage des éventuelles arêtes vives entre faces reconstruites
1192 if aretesVivesCoupees:
1194 aretesVivesC = geompy.MakeCompound(aretesVivesCoupees)
1195 meshAretesVives = smesh.Mesh(aretesVivesC)
1196 algo1d = meshAretesVives.Segment()
1197 hypo1d = algo1d.LocalLength(dmoyen,list(),1e-07)
1198 putName(algo1d.GetSubMesh(), "aretesVives")
1199 putName(algo1d, "algo1d_aretesVives")
1200 putName(hypo1d, "hypo1d_aretesVives")
1202 is_done = meshAretesVives.Compute()
1203 text = "meshAretesVives.Compute"
1205 logging.info(text+" OK")
1207 text = "Erreur au calcul du maillage.\n" + text
1209 raise Exception(text)
1210 grpAretesVives = meshAretesVives.CreateEmptyGroup( SMESH.EDGE, 'grpAretesVives' )
1211 _ = 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 logging.info("Maillage avec %s", mailleur)
1220 if ( mailleur == "MeshGems"):
1221 algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.MG_CADSurf)
1222 hypo2d = algo2d.Parameters()
1223 hypo2d.SetPhySize( areteFaceFissure )
1224 hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
1225 hypo2d.SetMaxSize( areteFaceFissure*3. )
1226 hypo2d.SetChordalError( areteFaceFissure*0.25 )
1227 hypo2d.SetVerbosity( 0 )
1229 algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_1D2D)
1230 hypo2d = algo2d.Parameters()
1231 hypo2d.SetMaxSize( areteFaceFissure )
1232 hypo2d.SetSecondOrder( 0 )
1233 hypo2d.SetOptimize( 1 )
1234 hypo2d.SetFineness( 2 )
1235 hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
1236 hypo2d.SetQuadAllowed( 0 )
1237 putName(algo2d.GetSubMesh(), "faceFiss")
1238 putName(algo2d, "algo2d_faceFiss")
1239 putName(hypo2d, "hypo2d_faceFiss")
1241 algo1d = meshFaceFiss.UseExisting1DElements(geom=edgesPipeFissureExterneC)
1242 hypo1d = algo1d.SourceEdges([ edgeFaceFissGroup ],0,0)
1243 putName(algo1d.GetSubMesh(), "edgeFissPeau")
1244 putName(algo1d, "algo1d_edgeFissPeau")
1245 putName(hypo1d, "hypo1d_edgeFissPeau")
1247 _ = meshFaceFiss.GroupOnGeom(faceFissureExterne, "fisOutPi", SMESH.FACE)
1248 grpEdgesPeauFissureExterne = meshFaceFiss.GroupOnGeom(edgesPeauFissureExterneC,'edgesPeauFissureExterne',SMESH.EDGE)
1249 _ = meshFaceFiss.GroupOnGeom(edgesPipeFissureExterneC,'edgesPipeFissureExterne',SMESH.EDGE)
1251 is_done = meshFaceFiss.Compute()
1252 text = "meshFaceFiss.Compute"
1254 logging.info(text+" OK")
1256 text = "Erreur au calcul du maillage.\n" + text
1258 raise Exception(text)
1260 # --- maillage faces de peau
1262 boutFromIfil = [None for i in range(nbFacesFilling)]
1263 if idFillingFromBout[0] != idFillingFromBout[1]: # repérage des extremites du pipe quand elles débouchent sur des faces différentes
1264 boutFromIfil[idFillingFromBout[0]] = 0
1265 boutFromIfil[idFillingFromBout[1]] = 1
1267 logging.debug("---------------------------- maillage faces de peau --------------")
1268 meshesFacesPeau = list()
1269 for ifil in range(nbFacesFilling):
1271 if partitionsPeauFissFond[ifil] is None: # face de peau maillage sain intacte
1273 # --- edges de bord de la face de filling
1274 filling = facesDefaut[ifil]
1275 edgesFilling = geompy.ExtractShapes(filling, geompy.ShapeType["EDGE"], False)
1276 groupEdgesBordPeau = geompy.CreateGroup(filling, geompy.ShapeType["EDGE"])
1277 geompy.UnionList(groupEdgesBordPeau, edgesFilling)
1278 geomPublishInFather(initLog.debug,filling, groupEdgesBordPeau , "EdgesBords")
1280 meshFacePeau = smesh.Mesh(facesDefaut[ifil])
1282 algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
1283 hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
1284 putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
1285 putName(algo1d, "algo1d_bordsLibres", ifil)
1286 putName(hypo1d, "hypo1d_bordsLibres", ifil)
1290 facePeau = facesPeaux[ifil] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
1291 edgesCircPeau = edCircPeau[ifil] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
1292 verticesCircPeau = ptCircPeau[ifil] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
1293 groupEdgesBordPeau = gpedgeBord[ifil] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
1294 bordsVifs = gpedgeVifs[ifil] # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
1295 edgesFissurePeau = edFissPeau[ifil] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
1297 meshFacePeau = smesh.Mesh(facePeau)
1299 algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
1300 hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
1301 putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
1302 putName(algo1d, "algo1d_bordsLibres", ifil)
1303 putName(hypo1d, "hypo1d_bordsLibres", ifil)
1305 algo1d = meshFacePeau.UseExisting1DElements(geom=geompy.MakeCompound(edgesFissurePeau))
1306 hypo1d = algo1d.SourceEdges([ grpEdgesPeauFissureExterne ],0,0)
1307 putName(algo1d.GetSubMesh(), "edgePeauFiss", ifil)
1308 putName(algo1d, "algo1d_edgePeauFiss", ifil)
1309 putName(hypo1d, "hypo1d_edgePeauFiss", ifil)
1311 if bordsVifs is not None:
1312 algo1d = meshFacePeau.UseExisting1DElements(geom=bordsVifs)
1313 hypo1d = algo1d.SourceEdges([ grpAretesVives ],0,0)
1314 putName(algo1d.GetSubMesh(), "bordsVifs", ifil)
1315 putName(algo1d, "algo1d_bordsVifs", ifil)
1316 putName(hypo1d, "hypo1d_bordsVifs", ifil)
1318 for i, edgeCirc in enumerate(edgesCircPeau):
1319 if edgeCirc is not None:
1320 algo1d = meshFacePeau.UseExisting1DElements(geom=edgeCirc)
1321 if boutFromIfil[ifil] is None:
1322 hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[i] ],0,0)
1324 hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[boutFromIfil[ifil]] ],0,0)
1326 putName(algo1d.GetSubMesh(), name, ifil)
1327 putName(algo1d, "algo1d_" + name, ifil)
1328 putName(hypo1d, "hypo1d_" + name, ifil)
1330 logging.info("Maillage avec %s", mailleur)
1331 if ( mailleur == "MeshGems"):
1332 algo2d = meshFacePeau.Triangle(algo=smeshBuilder.MG_CADSurf)
1333 hypo2d = algo2d.Parameters()
1334 hypo2d.SetPhySize( dmoyen )
1335 hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
1336 hypo2d.SetMaxSize( dmoyen*3. )
1337 hypo2d.SetChordalError( dmoyen*0.25 )
1338 hypo2d.SetVerbosity( 0 )
1340 algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_1D2D)
1341 hypo2d = algo2d.Parameters()
1342 hypo2d.SetMaxSize( dmoyen*0.75 )
1343 hypo2d.SetOptimize( 1 )
1344 hypo2d.SetFineness( 2 )
1345 hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
1346 hypo2d.SetQuadAllowed( 0 )
1347 putName(algo2d.GetSubMesh(), "facePeau", ifil)
1348 putName(algo2d, "algo2d_facePeau", ifil)
1349 putName(hypo2d, "hypo2d_facePeau", ifil)
1351 is_done = meshFacePeau.Compute()
1352 text = "meshFacePeau {} Compute".format(ifil)
1354 logging.info(text+" OK")
1356 text = "Erreur au calcul du maillage.\n" + text
1358 raise Exception(text)
1360 GroupFaces = meshFacePeau.CreateEmptyGroup( SMESH.FACE, "facePeau%d"%ifil )
1361 _ = GroupFaces.AddFrom( meshFacePeau.GetMesh() )
1362 meshesFacesPeau.append(meshFacePeau)
1364 # --- regroupement des maillages du défaut
1366 listMeshes = [internalBoundary.GetMesh(),
1368 meshFaceFiss.GetMesh()]
1369 for mp in meshesFacesPeau:
1370 listMeshes.append(mp.GetMesh())
1372 meshBoiteDefaut = smesh.Concatenate(listMeshes, 1, 1, 1e-05,False)
1373 # pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
1374 # on désigne les faces de peau en quadrangles par le groupe "skinFaces"
1375 group_faceFissOutPipe = None
1376 group_faceFissInPipe = None
1377 groups = meshBoiteDefaut.GetGroups()
1379 if grp.GetType() == SMESH.FACE:
1380 #if "internalBoundary" in grp.GetName():
1381 # grp.SetName("skinFaces")
1382 if grp.GetName() == "fisOutPi":
1383 group_faceFissOutPipe = grp
1384 elif grp.GetName() == "fisInPi":
1385 group_faceFissInPipe = grp
1387 # le maillage NETGEN ne passe pas toujours ==> on force l'usage de MG_Tetra
1388 mailleur = "MeshGems"
1389 logging.info("Maillage avec %s", mailleur)
1390 if ( mailleur == "MeshGems"):
1391 algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.MG_Tetra)
1393 algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
1394 hypo3d = algo3d.MaxElementVolume(1000.0)
1395 hypo3d.SetVerboseLevel( 0 )
1396 hypo3d.SetStandardOutputLog( 0 )
1397 hypo3d.SetRemoveLogOnSuccess( 1 )
1398 putName(algo3d.GetSubMesh(), "boiteDefaut")
1399 putName(algo3d, "algo3d_boiteDefaut")
1400 putName(meshBoiteDefaut, "boiteDefaut")
1402 is_done = meshBoiteDefaut.Compute()
1403 text = "meshBoiteDefaut.Compute"
1405 logging.info(text+" OK")
1407 text = "Erreur au calcul du maillage.\n" + text
1409 raise Exception(text)
1411 _ = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
1412 maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin,
1413 zoneDefaut_internalFaces, zoneDefaut_internalEdges)
1414 putName(maillageSain, nomFicSain+"_coupe")
1415 _, normfiss = shapeSurFissure(facesPortFissure)
1416 maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut,
1417 None, None, 'COMPLET', normfiss)
1419 logging.info("conversion quadratique")
1420 maillageComplet.ConvertToQuadratic( 1 )
1421 logging.info("groupes")
1422 groups = maillageComplet.GetGroups()
1423 grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
1424 _ = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
1426 logging.info("réorientation face de fissure FACE1")
1427 grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
1428 _ = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
1430 logging.info("réorientation face de fissure FACE2")
1431 plansim = geompy.MakePlane(O, normfiss, 10000)
1432 fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
1433 grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
1434 _ = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
1435 _ = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
1437 logging.info("export maillage fini")
1438 maillageComplet.ExportMED(fichierMaillageFissure)
1439 putName(maillageComplet, nomFicFissure)
1440 logging.info("fichier maillage fissure %s", fichierMaillageFissure)
1442 if salome.sg.hasDesktop():
1443 salome.sg.updateObjBrowser()
1445 logging.info("maillage fissure fini")
1447 return maillageComplet