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