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