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
25 from .geomsmesh import geompy
26 from .geomsmesh import geomPublish
27 from .geomsmesh import geomPublishInFather
29 from .geomsmesh import smesh
30 from salome.smesh import smeshBuilder
34 from .extractionOrientee import extractionOrientee
35 from .sortFaces import sortFaces
36 from .sortEdges import sortEdges
37 from .eliminateDoubles import eliminateDoubles
38 from .substractSubShapes import substractSubShapes
39 from .produitMixte import produitMixte
40 from .findWireEndVertices import findWireEndVertices
41 from .getSubshapeIds import getSubshapeIds
42 from .putName import putName
43 from .distance2 import distance2
44 from .enleveDefaut import enleveDefaut
45 from .shapeSurFissure import shapeSurFissure
46 from .regroupeSainEtDefaut import RegroupeSainEtDefaut
47 from .triedreBase import triedreBase
49 # -----------------------------------------------------------------------------
50 # --- procedure complete fissure longue
52 def insereFissureLongue(geometriesSaines, maillagesSains,
53 shapesFissure, shapeFissureParams,
54 maillageFissureParams, elementsDefaut, step=-1):
60 #geometrieSaine = geometriesSaines[0]
61 #maillageSain = maillagesSains[0]
62 #isHexa = maillagesSains[1]
63 shapeDefaut = shapesFissure[0] # face de fissure, debordant
64 #tailleDefaut = shapesFissure[2]
65 wiretube = shapesFissure[4] # wire fond de fissure, debordant
66 planfiss = shapesFissure[7] # plan de fissure
67 pipefiss = shapesFissure[8] # pipe, debordant
69 profondeur = shapeFissureParams['profondeur']
70 rayonPipe = profondeur/4.0
72 nomRep = maillageFissureParams['nomRep']
73 nomFicSain = maillageFissureParams['nomFicSain']
74 nomFicFissure = maillageFissureParams['nomFicFissure']
76 #nbsegExt = maillageFissureParams['nbsegExt'] # 5
77 #nbsegGen = maillageFissureParams['nbsegGen'] # 25
78 #nbsegRad = maillageFissureParams['nbsegRad'] # 5
79 #scaleRad = maillageFissureParams['scaleRad'] # 4
80 #nbsegCercle = maillageFissureParams['nbsegCercle'] # 6
81 #nbsegFis = maillageFissureParams['nbsegFis'] # 20
82 #lensegEllipsoide = maillageFissureParams['lensegEllipso'] # 1.0
84 #fichierMaillageSain = os.path.join(nomRep, '{}.med'.format(nomFicSain))
85 fichierMaillageFissure = os.path.join(nomRep, '{}.med'.format(nomFicFissure))
87 facesDefaut = elementsDefaut[0]
88 #centreDefaut = elementsDefaut[1]
89 #normalDefaut = elementsDefaut[2]
90 #extrusionDefaut = elementsDefaut[3]
91 #dmoyen = elementsDefaut[4]
92 #bordsPartages = elementsDefaut[5]
93 #fillconts = elementsDefaut[6]
94 #idFilToCont = elementsDefaut[7]
95 maillageSain = elementsDefaut[8]
96 internalBoundary = elementsDefaut[9]
97 zoneDefaut = elementsDefaut[10]
98 zoneDefaut_skin = elementsDefaut[11]
99 zoneDefaut_internalFaces = elementsDefaut[12]
100 zoneDefaut_internalEdges = elementsDefaut[13]
102 facePorteFissure = shapeDefaut
103 WirePorteFondFissure = wiretube
104 fillingFaceExterne = facesDefaut[0]
105 logging.debug("fillingFaceExterne %s", fillingFaceExterne)
106 geomPublish(initLog.debug, fillingFaceExterne, "fillingFaceExterne")
107 edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
109 O, OX, OY, OZ = triedreBase()
111 # -----------------------------------------------------------------------------
112 # --- peau et face de fissure
114 # --- partition peau defaut - face de fissure prolongee - wire de fond de fissure prolongée
115 partitionPeauFissFond = geompy.MakePartition([facePorteFissure, WirePorteFondFissure, fillingFaceExterne], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
116 geomPublish(initLog.debug, partitionPeauFissFond, 'partitionPeauFissFond' )
118 edges = geompy.ExtractShapes(WirePorteFondFissure, geompy.ShapeType["EDGE"], False)
122 for i, edge in enumerate(edges):
123 props = geompy.BasicProperties(edge)
128 edgemax = edges[imax]
129 geomPublish(initLog.debug, edgemax, 'edgemax')
130 centreFondFiss = geompy.MakeVertexOnCurve(edgemax, 0.5)
131 geomPublish(initLog.debug, centreFondFiss, 'centreFondFiss')
132 tangentFondFiss = geompy.MakeTangentOnCurve(edgemax, 0.5)
133 geomPublish(initLog.debug, tangentFondFiss, 'tangentFondFiss')
135 bord1FondFiss = geompy.MakeVertexOnCurve(edgemax, 0.0)
136 geomPublish(initLog.debug, bord1FondFiss, 'bord1FondFiss')
137 tangentBord1FondFiss = geompy.MakeTangentOnCurve(edgemax, 0.0)
138 geomPublish(initLog.debug, tangentBord1FondFiss, 'tangentBord1FondFiss')
140 bord2FondFiss = geompy.MakeVertexOnCurve(edgemax, 1.0)
141 geomPublish(initLog.debug, bord2FondFiss, 'bord2FondFiss')
142 tangentBord2FondFiss = geompy.MakeTangentOnCurve(edgemax, 1.0)
143 geomPublish(initLog.debug, tangentBord2FondFiss, 'tangentBord2FondFiss')
145 planBord1 = geompy.MakePlane(bord1FondFiss, tangentBord1FondFiss, 3*rayonPipe)
146 planBord2 = geompy.MakePlane(bord2FondFiss, tangentBord2FondFiss, 3*rayonPipe)
147 geomPublish(initLog.debug, planBord1, 'planBord1')
148 geomPublish(initLog.debug, planBord2, 'planBord2')
150 [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
151 [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
153 # --- partition peau -face fissure - pipe fond de fissure prolongé
154 partitionPeauFissByPipe = geompy.MakePartition([facesInside[0], facesOnside[0]], [pipefiss], [], [], geompy.ShapeType["FACE"], 0, [], 0)
155 geomPublish(initLog.debug, partitionPeauFissByPipe, 'partitionPeauFissByPipe' )
157 # --- identification face de peau
158 [facesPeauFissInside, facesPeauFissOutside, facesPeauFissOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissByPipe, centreFondFiss, "FACE", 0.1, "peauFiss_bord_")
159 facesPeauSorted, minsur, maxsurf = sortFaces(facesPeauFissOnside) # 4 demi disques, une grande face
160 facePeau = facesPeauSorted[-1] # la plus grande face
161 geomPublishInFather(initLog.debug,partitionPeauFissByPipe, facePeau, "facePeau")
163 # --- identification edges de bord face peau
165 for i, edge in enumerate(edgesFilling):
166 edgepeau = geompy.GetInPlace(facePeau, edge)
167 edgesBords.append(edgepeau)
168 groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
169 geompy.UnionList(groupEdgesBordPeau, edgesBords)
170 geomPublishInFather(initLog.debug,facePeau, groupEdgesBordPeau , "EdgesBords")
172 # --- identification face fissure externe au pipe et edge commune peau fissure
173 for face in facesPeauFissInside:
175 sharedEdges = geompy.GetSharedShapesMulti([facePeau, face], geompy.ShapeType["EDGE"])
176 if sharedEdges is not None:
178 edgePeauFiss = sharedEdges[0]
179 geomPublishInFather(initLog.debug,partitionPeauFissByPipe, faceFiss, "faceFiss")
180 geomPublishInFather(initLog.debug,faceFiss, edgePeauFiss, "edgePeauFiss")
181 geomPublishInFather(initLog.debug,facePeau, edgePeauFiss, "edgePeauFiss")
185 verticesEdgePeauFiss = geompy.ExtractShapes(edgePeauFiss, geompy.ShapeType["VERTEX"], False)
187 # --- identification edges demi cercle dans face de peau
188 edgesFacePeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
189 edgesFacePeauSorted, minlg, maxlg = sortEdges(edgesFacePeau)
190 demiCerclesPeau = edgesFacePeauSorted[0:4]
191 verticesDemiCerclesPeau = []
192 for i, edge in enumerate(demiCerclesPeau):
193 name = "demiCerclePeau_%d"%i
194 geomPublishInFather(initLog.debug,facePeau, edge, name)
195 verticesDemiCerclesPeau += geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False)
196 verticesDemiCerclesPeau = eliminateDoubles(facePeau, verticesDemiCerclesPeau)
197 for i, vertex in enumerate(verticesDemiCerclesPeau):
198 name = "verticesDemiCerclesPeau_%d"%i
199 geomPublishInFather(initLog.debug,facePeau, vertex, name)
200 verticesOutCercles = substractSubShapes(facePeau, verticesDemiCerclesPeau, verticesEdgePeauFiss)
201 for i, vertex in enumerate(verticesOutCercles):
202 name = "verticesOutCercles_%d"%i
203 geomPublishInFather(initLog.debug,facePeau, vertex, name)
205 # --- demi cercles regroupés
206 groupsDemiCerclesPeau = []
207 for i, vertex in enumerate(verticesEdgePeauFiss):
209 for edge in demiCerclesPeau:
210 if geompy.MinDistance(vertex, edge) < 1.e-5:
212 group = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
213 geompy.UnionList(group, demis)
215 geomPublishInFather(initLog.debug,facePeau, group , name)
216 groupsDemiCerclesPeau.append(group)
218 # --- identification edges commune pipe face fissure externe au pipe
219 edgePeauFissId = geompy.GetSubShapeID(partitionPeauFissByPipe, edgePeauFiss)
220 edgesFaceFiss = geompy.ExtractShapes(faceFiss, geompy.ShapeType["EDGE"], False)
221 edgesFaceFissPipe = []
222 for edge in edgesFaceFiss:
223 if geompy.GetSubShapeID(partitionPeauFissByPipe, edge) != edgePeauFissId:
224 edgesFaceFissPipe.append(edge)
225 name = "edgeFaceFissPipe_%d"%len(edgesFaceFissPipe)
226 geomPublishInFather(initLog.debug,faceFiss, edge, name)
227 groupEdgesFaceFissPipe = geompy.CreateGroup(faceFiss, geompy.ShapeType["EDGE"])
228 geompy.UnionList(groupEdgesFaceFissPipe, edgesFaceFissPipe)
229 geomPublishInFather(initLog.debug,faceFiss, groupEdgesFaceFissPipe, "edgesFaceFissPipe")
231 # -----------------------------------------------------------------------------
232 # --- pipe de fond de fissure
234 wireFondFiss = geompy.MakeWire(edgesInside, 1e-07)
236 disque = geompy.MakeDiskPntVecR(centreFondFiss, tangentFondFiss, rayonPipe)
237 [vertex] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
238 vertproj = geompy.MakeProjection(vertex, planfiss)
239 vec1 = geompy.MakeVector(centreFondFiss, vertex)
241 # si centreFondFiss et vertproj sont proches: exception. Angle = +- 90°
242 vec2 = geompy.MakeVector(centreFondFiss, vertproj)
243 angle = geompy.GetAngleRadians(vec1, vec2)
245 # on utilise la projection du centre sur la peau pour avoir un vecteur non nul
246 vertproj = geompy.MakeProjection(centreFondFiss, facePeau)
247 vec2 = geompy.MakeVector(centreFondFiss, vertproj)
248 angle = geompy.GetAngleRadians(vec1, vec2)
249 sommetAxe = geompy.MakeTranslationVector(centreFondFiss, tangentFondFiss)
250 pm = produitMixte(centreFondFiss, vertex, vertproj, sommetAxe)
252 disque = geompy.MakeRotation(disque, tangentFondFiss, angle)
254 disque = geompy.MakeRotation(disque, tangentFondFiss, -angle)
255 [vertexReference] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
257 pipeFondFiss = geompy.MakePipe(disque, wireFondFiss)
258 pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
259 #pipe = geompy.MakePipe(disque, WirePorteFondFissure)
260 #pipe = geompy.MakePartition([pipe],[fillingFaceExterne], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
261 #pipes = geompy.ExtractShapes(pipe, geompy.ShapeType["SOLID"], False)
262 #pipesSorted, volmin, volmax = sortSolids(pipes)
263 #pipeFondFiss = pipesSorted[-1]
264 #pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
266 geomPublish(initLog.debug, disque, 'disque')
267 geomPublish(initLog.debug, wireFondFiss, 'wireFondFiss')
268 geomPublish(initLog.debug, pipeFondFiss, 'pipeFondFiss')
270 VerticesEndFondFiss = findWireEndVertices(wireFondFiss)
271 for i, v in enumerate(VerticesEndFondFiss):
272 name = "vertexEndFondFiss_%d"%i
273 geomPublishInFather(initLog.debug,wireFondFiss, v, name)
274 VerticesEndPipeFiss = []
275 for v in VerticesEndFondFiss:
276 VerticesEndPipeFiss.append(geompy.GetInPlace(pipeFondFiss, v))
277 for i, v in enumerate(VerticesEndPipeFiss):
278 name = "vertexEndPipeFiss_%d"%i
279 geomPublishInFather(initLog.debug,pipeFondFiss, v, name)
281 geomPublishInFather(initLog.debug,pipeFondFiss, VerticesEndPipeFiss[0], "PFOR")
282 geomPublishInFather(initLog.debug,pipeFondFiss, VerticesEndPipeFiss[1], "PFEX")
283 if geompy.MinDistance(VerticesEndPipeFiss[0], verticesOutCercles[0]) > geompy.MinDistance(VerticesEndPipeFiss[0], verticesOutCercles[1]):
284 a = verticesOutCercles[0]
285 verticesOutCercles[0] = verticesOutCercles[1]
286 verticesOutCercles[1] = a
287 geomPublishInFather(initLog.debug,facePeau, verticesOutCercles[0], "THOR")
288 geomPublishInFather(initLog.debug,facePeau, verticesOutCercles[1], "THEX")
290 [facesPipeInside, facesPipeOutside, facesPipeOnside] = extractionOrientee(fillingFaceExterne, pipeFondFiss, centreFondFiss, "FACE", 0.1, "pipe_bord_")
291 [edgesPipeInside, edgesPipeOutside, edgesPipeOnside] = extractionOrientee(fillingFaceExterne, pipeFondFiss, centreFondFiss, "EDGE", 0.1, "pipe_bord_")
292 disqueInt1 = geompy.GetInPlaceByHistory(pipeFondFiss, planBord1)
293 disqueInt2 = geompy.GetInPlaceByHistory(pipeFondFiss, planBord2)
294 disques = facesPipeOnside + [disqueInt1, disqueInt2]
295 edgesDiskInt = geompy.ExtractShapes(disqueInt1, geompy.ShapeType["EDGE"], False)
296 edgesDiskInt = edgesDiskInt +geompy.ExtractShapes(disqueInt2, geompy.ShapeType["EDGE"], False)
297 edgesSorted, minlg, maxlg = sortEdges(edgesDiskInt) # 4 rayons, 2 demi cercles
299 centre = geompy.MakeVertexOnSurface(planfiss, 0.5, 0.5)
300 refpoint = geompy.MakeTranslationVector(centre, geompy.GetNormal(planfiss,centre))
301 geomPublish(initLog.debug, refpoint, 'refpoint')
302 [facesPipeInplan, facesPipeOutplan, facesPipeOnplan] = extractionOrientee(planfiss, pipeFondFiss, refpoint, "FACE", 0.1, "pipe_plan_")
303 [edgesPipeInplan, edgesPipeOutplan, edgesPipeOnplan] = extractionOrientee(planfiss, pipeFondFiss, refpoint, "EDGE", 0.1, "pipe_plan_")
305 # --- rayon disques = (edgesPipeOnside inter edgesPipeOnplan) + rayons disque internes
306 # demi cercles = edgesPipeOnside moins edgesPipeOnplan + demi cercles disque internes
307 # generatrices = edgesPipeOnplan moins rayon disques (3 grandes et 6 petites)
308 edgesIdPipeOnside = getSubshapeIds(pipeFondFiss, edgesPipeOnside)
309 edgesIdPipeOnplan = getSubshapeIds(pipeFondFiss, edgesPipeOnplan)
312 for i, edgeId in enumerate(edgesIdPipeOnside):
313 if edgeId in edgesIdPipeOnplan:
314 rayons.append(edgesPipeOnside[i])
316 demiCercles.append(edgesPipeOnside[i])
317 demiCerclesExternes = demiCercles
318 rayons = rayons + edgesSorted[:4] # les 4 plus petits sont les rayons
319 demiCercles = demiCercles + edgesSorted[4:] # les suivants sont les arcs de cercle
320 rayonsId = getSubshapeIds(pipeFondFiss, rayons)
322 for i, edgeId in enumerate(edgesIdPipeOnplan):
323 if edgeId not in rayonsId:
324 generatrices.append(edgesPipeOnplan[i])
326 # --- generatrices en contact avec la face fissure externe au pipe
328 for edge in generatrices:
329 distance = geompy.MinDistance(vertexReference, edge)
330 logging.debug("distance %s", distance)
332 generFiss.append(edge)
334 for edge in generatrices:
335 distance = geompy.MinDistance(generFiss[0], edge)
336 logging.debug("distance %s", distance)
338 generFiss.append(edge)
339 groupGenerFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
340 geompy.UnionList(groupGenerFiss, generFiss)
341 geomPublishInFather(initLog.debug,pipeFondFiss, groupGenerFiss, "GenFiss")
343 # --- demi cercles externes regroupés
344 groupsDemiCerclesPipe = []
345 for i, vertex in enumerate(verticesEdgePeauFiss):
347 for edge in demiCerclesExternes:
348 if geompy.MinDistance(vertex, edge) < 0.1:
350 group = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
351 geompy.UnionList(group, demis)
353 geomPublishInFather(initLog.debug,pipeFondFiss, group , name)
354 groupsDemiCerclesPipe.append(group)
356 # --- faces fissure dans le pipe
359 generFissId = getSubshapeIds(pipeFondFiss, generFiss)
360 logging.debug("generatrice fissure %s", generFissId)
361 for face in facesPipeOnplan:
362 edges =geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], False)
363 edgesId = getSubshapeIds(pipeFondFiss, edges)
364 logging.debug(" edges %s", edgesId)
365 for i,edgeId in enumerate(edgesId):
366 if edgeId in generFissId:
367 logging.debug("face found")
368 facesFissinPipe.append(face)
369 name = "faceFissInPipe_%d"%i
370 geomPublishInFather(initLog.debug,pipeFondFiss, face, name)
372 groupFaceFissInPipe = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["FACE"])
373 geompy.UnionList(groupFaceFissInPipe, facesFissinPipe)
374 name = "FaceFissInPipe"
375 geomPublishInFather(initLog.debug,pipeFondFiss, groupFaceFissInPipe , name)
377 # --- edges de fond de fissure
380 for i, edge in enumerate(edgesInside):
381 anEdge = geompy.GetInPlace(pipeFondFiss, edge)
382 logging.debug(" edge %s ", anEdge)
383 edgesFondFiss.append(anEdge)
384 name ="edgeFondFissure_%d"%i
385 geomPublishInFather(initLog.debug,pipeFondFiss, anEdge, name)
386 groupEdgeFondFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
387 geompy.UnionList(groupEdgeFondFiss, edgesFondFiss)
389 geomPublishInFather(initLog.debug,pipeFondFiss, groupEdgeFondFiss , name)
391 # -------------------------------------------------------------------------
394 # --- edges de bord face defaut à respecter
396 aFilterManager = smesh.CreateFilterManager()
397 nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ])
399 unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
400 criteres.append(unCritere)
401 filtre = smesh.GetFilterFromCriteria(criteres)
402 bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
403 smesh.SetName(bordsLibres, 'bordsLibres')
405 # --- pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
406 # on designe les faces de peau en quadrangles par le groupe "skinFaces"
408 skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
409 nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
411 # --- maillage pipe fond fissure
413 meshFondFiss = smesh.Mesh(pipeFondFiss)
414 algo2d = meshFondFiss.Quadrangle(algo=smeshBuilder.QUADRANGLE)
415 algo3d = meshFondFiss.Prism()
416 putName(algo3d.GetSubMesh(), "pipe")
417 putName(algo3d, "algo3d_pipe")
418 putName(algo2d, "algo2d_pipe")
420 for i, face in enumerate(disques):
421 algo2d = meshFondFiss.Quadrangle(algo=smeshBuilder.RADIAL_QUAD,geom=face)
422 putName(algo2d.GetSubMesh(), "disque", i)
423 putName(algo2d, "algo2d_disque", i)
425 for i, edge in enumerate(rayons):
426 algo1d = meshFondFiss.Segment(geom=edge)
427 hypo1d = algo1d.NumberOfSegments(4)
428 putName(algo1d.GetSubMesh(), "rayon", i)
429 putName(algo1d, "algo1d_rayon", i)
430 putName(hypo1d, "hypo1d_rayon", i)
432 for i, edge in enumerate(demiCercles):
433 algo1d = meshFondFiss.Segment(geom=edge)
434 hypo1d = algo1d.NumberOfSegments(6)
435 putName(algo1d.GetSubMesh(), "demiCercle", i)
436 putName(algo1d, "algo1d_demiCercle", i)
437 putName(hypo1d, "hypo1d_demiCercle", i)
439 generSorted, minlg, maxlg = sortEdges(generatrices)
440 nbSegGenLong = int(math.sqrt(3.0)*maxlg/(profondeur - rayonPipe)) # on veut 2 triangles equilateraux dans la largeur de la face
442 logging.info("min %s, max %s, nombre de segments %s, nombre de generatrices %s", minlg, maxlg, nbSegGenLong, len(generSorted))
443 for i, edge in enumerate(generSorted):
444 algo1d = meshFondFiss.Segment(geom=edge)
446 hypo1d = algo1d.NumberOfSegments(nbSegGenBout)
448 hypo1d = algo1d.NumberOfSegments(nbSegGenLong)
449 putName(algo1d.GetSubMesh(), "generatrice", i)
450 putName(algo1d, "algo1d_generatrice", i)
451 putName(hypo1d, "hypo1d_generatrice", i)
452 isDone = meshFondFiss.Compute()
453 logging.info("meshFondFiss computed")
456 for i, face in enumerate(disques[:4]):
458 disks.append(meshFondFiss.GroupOnGeom(face, name, SMESH.FACE))
459 peauext_pipe = meshFondFiss.GetMesh().UnionListOfGroups( disks, 'PEAUEXT' )
461 grpPFOR = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[0], "PFOR", SMESH.NODE)
462 grpPFEX = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[1], "PFEX", SMESH.NODE)
464 grp = meshFondFiss.GroupOnGeom(groupFaceFissInPipe, "fisInPi", SMESH.FACE)
465 group_edgeFondFiss = meshFondFiss.GroupOnGeom(groupEdgeFondFiss, "FONDFISS", SMESH.EDGE)
466 noeudsFondFissure = meshFondFiss.GroupOnGeom(groupEdgeFondFiss, "nfondfis", SMESH.NODE)
467 groups_demiCercles = []
468 groupnodes_demiCercles = []
469 for i, group in enumerate(groupsDemiCerclesPipe):
471 groups_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.EDGE))
473 groupnodes_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.NODE))
474 group_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.EDGE)
475 groupnode_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.NODE)
476 grpNode0 = meshFondFiss.IntersectGroups(groupnode_generFiss, groupnodes_demiCercles[0], "Node0")
477 grpNode1 = meshFondFiss.IntersectGroups(groupnode_generFiss, groupnodes_demiCercles[1], "Node1")
478 idNode0 = grpNode0.GetID(1)
479 idNode1 = grpNode1.GetID(1)
481 coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode0))
482 coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode1))
484 for vertex in verticesEdgePeauFiss:
485 coord = geompy.PointCoordinates(vertex);
486 if distance2(coord, coordsMesh[0]) < 0.1:
487 meshFondFiss.MoveNode(idNode0, coord[0], coord[1], coord[2])
488 if distance2(coord, coordsMesh[1]) < 0.1:
489 meshFondFiss.MoveNode(idNode1, coord[0], coord[1], coord[2])
491 for groupNodes in groupnodes_demiCercles:
492 for idNode in groupNodes.GetListOfID():
493 coordMesh = meshFondFiss.GetNodeXYZ(idNode)
494 vertex = geompy.MakeVertex(coordMesh[0], coordMesh[1], coordMesh[2])
498 for i, edge in enumerate(demiCerclesPeau):
499 discoord = geompy.MinDistanceComponents(vertex, edge)
500 if discoord[0] <minDist:
501 minDist = discoord[0]
502 minCoord = discoord[1:]
504 if imin >= 0 and minDist > 1.E-6:
505 logging.debug("node id moved : %s distance=%s", idNode, minDist)
506 meshFondFiss.MoveNode(idNode, coordMesh[0] + minCoord[0], coordMesh[1] + minCoord[1], coordMesh[2] + minCoord[2])
509 # --- maillage face de peau
511 meshFacePeau = smesh.Mesh(facePeau)
512 algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_2D)
513 hypo2d = algo2d.Parameters()
514 hypo2d.SetMaxSize( 1000 )
515 hypo2d.SetOptimize( 1 )
516 hypo2d.SetFineness( 2 )
517 hypo2d.SetMinSize( 2 )
518 hypo2d.SetQuadAllowed( 0 )
519 putName(algo2d.GetSubMesh(), "facePeau")
520 putName(algo2d, "algo2d_facePeau")
521 putName(hypo2d, "hypo2d_facePeau")
523 lenEdgePeauFiss = geompy.BasicProperties(edgePeauFiss)[0]
524 frac = profondeur/lenEdgePeauFiss
525 nbSeg = nbSegGenLong +2*nbSegGenBout
526 ratio = (nbSegGenBout/float(profondeur)) / (nbSegGenLong/lenEdgePeauFiss)
527 logging.info("lenEdgePeauFiss %s, profondeur %s, nbSegGenLong %s, nbSegGenBout %s, frac %s, ratio %s", lenEdgePeauFiss, profondeur, nbSegGenLong, nbSegGenBout, frac, ratio)
528 algo1d = meshFacePeau.Segment(geom=edgePeauFiss)
529 hypo1d = algo1d.NumberOfSegments(nbSeg,[],[ ])
530 hypo1d.SetDistrType( 2 )
531 hypo1d.SetConversionMode( 1 )
532 hypo1d.SetTableFunction( [ 0, ratio, frac, 1, (1.-frac), 1, 1, ratio ] )
533 putName(algo1d.GetSubMesh(), "edgePeauFiss")
534 putName(algo1d, "algo1d_edgePeauFiss")
535 putName(hypo1d, "hypo1d_edgePeauFiss")
537 algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
538 hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
539 putName(algo1d.GetSubMesh(), "bordsLibres")
540 putName(algo1d, "algo1d_bordsLibres")
541 putName(hypo1d, "hypo1d_bordsLibres")
544 algo1d = meshFacePeau.UseExisting1DElements(geom=groupsDemiCerclesPeau[i])
545 hypo1d = algo1d.SourceEdges([ groups_demiCercles[i] ],0,0)
546 putName(algo1d.GetSubMesh(), "DemiCercles", i)
547 putName(algo1d, "algo1d_groupDemiCercles", i)
548 putName(hypo1d, "hypo1d_groupDemiCercles", i)
550 isDone = meshFacePeau.Compute()
551 logging.info("meshFacePeau computed")
552 grpTHOR = meshFacePeau.GroupOnGeom(verticesOutCercles[0], "THOR", SMESH.NODE)
553 grpTHEX = meshFacePeau.GroupOnGeom(verticesOutCercles[1], "THEX", SMESH.NODE)
555 groupEdgesPeauFiss = meshFacePeau.GroupOnGeom(edgePeauFiss, "PeauFis", SMESH.EDGE)
557 peauext_face = meshFacePeau.CreateEmptyGroup( SMESH.FACE, 'PEAUEXT' )
558 nbAdd = peauext_face.AddFrom( meshFacePeau.GetMesh() )
561 # --- maillage face de fissure
563 meshFaceFiss = smesh.Mesh(faceFiss)
564 algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_2D)
565 hypo2d = algo2d.Parameters()
566 hypo2d.SetMaxSize( (profondeur - rayonPipe)/math.sqrt(3.0) ) # pour avoir deux couches de triangles equilateraux partout sur la fissure
567 hypo2d.SetOptimize( 1 )
568 hypo2d.SetFineness( 2 )
569 hypo2d.SetMinSize( 2 )
570 hypo2d.SetQuadAllowed( 0 )
571 putName(algo2d.GetSubMesh(), "faceFiss")
572 putName(algo2d, "algo2d_faceFiss")
573 putName(hypo2d, "hypo2d_faceFiss")
575 algo1d = meshFaceFiss.UseExisting1DElements(geom=edgePeauFiss)
576 hypo1d = algo1d.SourceEdges([ groupEdgesPeauFiss ],0,0)
577 putName(algo1d.GetSubMesh(), "edgeFissPeau")
578 putName(algo1d, "algo1d_edgeFissPeau")
579 putName(hypo1d, "hypo1d_edgeFissPeau")
581 algo1d = meshFaceFiss.UseExisting1DElements(geom=groupEdgesFaceFissPipe)
582 hypo1d = algo1d.SourceEdges([ group_generFiss ],0,0)
583 putName(algo1d.GetSubMesh(), "edgeFissPeau")
584 putName(algo1d, "algo1d_edgeFissPeau")
585 putName(hypo1d, "hypo1d_edgeFissPeau")
587 isDone = meshFaceFiss.Compute()
588 logging.info("meshFaceFiss computed")
590 grp = meshFaceFiss.GroupOnGeom(faceFiss, "fisOutPi", SMESH.FACE)
592 meshBoiteDefaut = smesh.Concatenate([internalBoundary.GetMesh(),
593 meshFondFiss.GetMesh(),
594 meshFacePeau.GetMesh(),
595 meshFaceFiss.GetMesh()],
597 # pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
598 # on designe les faces de peau en quadrangles par le groupe "skinFaces"
599 group_faceFissOutPipe = None
600 group_faceFissInPipe = None
601 groups = meshBoiteDefaut.GetGroups()
603 if grp.GetType() == SMESH.FACE:
604 #if "internalBoundary" in grp.GetName():
605 # grp.SetName("skinFaces")
606 if grp.GetName() == "fisOutPi":
607 group_faceFissOutPipe = grp
608 elif grp.GetName() == "fisInPi":
609 group_faceFissInPipe = grp
611 # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
614 algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
616 algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
617 hypo3d = algo3d.MaxElementVolume(1000.0)
618 putName(algo3d.GetSubMesh(), "boiteDefaut")
619 putName(algo3d, "algo3d_boiteDefaut")
620 isDone = meshBoiteDefaut.Compute()
621 logging.info("meshBoiteDefaut computed")
622 putName(meshBoiteDefaut, "boiteDefaut")
624 groups = maillageSain.GetGroups()
625 grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
626 grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
627 coords1 = maillageSain.GetNodeXYZ(grps1[0].GetID(1))
628 coords2 = maillageSain.GetNodeXYZ(grps2[0].GetID(1))
629 logging.info("coords1 %s, coords2 %s",coords1, coords2)
631 faceFissure = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
632 maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges)
633 putName(maillageSain, nomFicSain+"_coupe")
634 extrusionFaceFissure, normfiss = shapeSurFissure(facePorteFissure)
635 maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut, extrusionFaceFissure, facePorteFissure, 'COUDE')
637 groups = maillageComplet.GetGroups()
638 grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
639 grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
640 nodeid1 = maillageComplet.AddNode(coords1[0], coords1[1], coords1[2])
641 nodeid2 = maillageComplet.AddNode(coords2[0], coords2[1], coords2[2])
642 grps1[0].Add([nodeid1])
643 grps2[0].Add([nodeid2])
644 ma0d1 = maillageComplet.Add0DElement(nodeid1)
645 ma0d2 = maillageComplet.Add0DElement(nodeid2)
646 grpma0d1 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P1' )
647 nbAdd = grpma0d1.Add( [ma0d1] )
648 grpma0d2 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P2' )
649 nbAdd = grpma0d2.Add( [ma0d2] )
651 # grps = [ grp for grp in groups if grp.GetName() == 'affectedEdges']
652 # grps[0].SetName('affEdges')
653 # grps = [ grp for grp in groups if grp.GetName() == 'affectedFaces']
654 # grps[0].SetName('affFaces')
655 # grps = [ grp for grp in groups if grp.GetName() == 'affectedVolumes']
656 # grps[0].SetName('affVols')
658 maillageComplet.ConvertToQuadratic( 1 )
659 grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
660 fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
662 grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
663 nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
665 plansim = geompy.MakePlane(O, normfiss, 10000)
666 fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
667 grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
668 nb = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
669 #isDone = maillageComplet.ReorientObject( grps[0] )
670 fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
672 maillageComplet.ExportMED(fichierMaillageFissure)
673 putName(maillageComplet, nomFicFissure)
674 logging.info("fichier maillage fissure %s", fichierMaillageFissure)
676 if salome.sg.hasDesktop():
677 salome.sg.updateObjBrowser()
679 return maillageComplet