1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2014-2020 EDF R&D
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License, or (at your option) any later version.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 from .geomsmesh import geompy
24 from .geomsmesh import geomPublish
25 from .geomsmesh import geomPublishInFather
27 from .geomsmesh import smesh
28 from salome.smesh import smeshBuilder
32 from .extractionOrientee import extractionOrientee
33 from .sortFaces import sortFaces
34 from .sortEdges import sortEdges
35 from .eliminateDoubles import eliminateDoubles
36 from .substractSubShapes import substractSubShapes
37 from .produitMixte import produitMixte
38 from .findWireEndVertices import findWireEndVertices
39 from .getSubshapeIds import getSubshapeIds
40 from .putName import putName
41 from .distance2 import distance2
42 from .enleveDefaut import enleveDefaut
43 from .shapeSurFissure import shapeSurFissure
44 from .regroupeSainEtDefaut import RegroupeSainEtDefaut
45 from .triedreBase import triedreBase
47 # -----------------------------------------------------------------------------
48 # --- procedure complete fissure longue
50 def insereFissureLongue(geometriesSaines, maillagesSains,
51 shapesFissure, shapeFissureParams,
52 maillageFissureParams, elementsDefaut, step=-1):
58 #geometrieSaine = geometriesSaines[0]
59 #maillageSain = maillagesSains[0]
60 #isHexa = maillagesSains[1]
61 shapeDefaut = shapesFissure[0] # face de fissure, debordant
62 #tailleDefaut = shapesFissure[2]
63 wiretube = shapesFissure[4] # wire fond de fissure, debordant
64 planfiss = shapesFissure[7] # plan de fissure
65 pipefiss = shapesFissure[8] # pipe, debordant
67 profondeur = shapeFissureParams['profondeur']
68 rayonPipe = profondeur/4.0
70 nomRep = maillageFissureParams['nomRep']
71 nomFicSain = maillageFissureParams['nomFicSain']
72 nomFicFissure = maillageFissureParams['nomFicFissure']
74 #nbsegExt = maillageFissureParams['nbsegExt'] # 5
75 #nbsegGen = maillageFissureParams['nbsegGen'] # 25
76 #nbsegRad = maillageFissureParams['nbsegRad'] # 5
77 #scaleRad = maillageFissureParams['scaleRad'] # 4
78 #nbsegCercle = maillageFissureParams['nbsegCercle'] # 6
79 #nbsegFis = maillageFissureParams['nbsegFis'] # 20
80 #lensegEllipsoide = maillageFissureParams['lensegEllipso'] # 1.0
82 #fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
83 fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
85 facesDefaut = elementsDefaut[0]
86 #centreDefaut = elementsDefaut[1]
87 #normalDefaut = elementsDefaut[2]
88 #extrusionDefaut = elementsDefaut[3]
89 #dmoyen = elementsDefaut[4]
90 #bordsPartages = elementsDefaut[5]
91 #fillconts = elementsDefaut[6]
92 #idFilToCont = elementsDefaut[7]
93 maillageSain = elementsDefaut[8]
94 internalBoundary = elementsDefaut[9]
95 zoneDefaut = elementsDefaut[10]
96 zoneDefaut_skin = elementsDefaut[11]
97 zoneDefaut_internalFaces = elementsDefaut[12]
98 zoneDefaut_internalEdges = elementsDefaut[13]
100 facePorteFissure = shapeDefaut
101 WirePorteFondFissure = wiretube
102 fillingFaceExterne = facesDefaut[0]
103 logging.debug("fillingFaceExterne %s", fillingFaceExterne)
104 geomPublish(initLog.debug, fillingFaceExterne, "fillingFaceExterne")
105 edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
107 O, OX, OY, OZ = triedreBase()
109 # -----------------------------------------------------------------------------
110 # --- peau et face de fissure
112 # --- partition peau defaut - face de fissure prolongee - wire de fond de fissure prolongée
113 partitionPeauFissFond = geompy.MakePartition([facePorteFissure, WirePorteFondFissure, fillingFaceExterne], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
114 geomPublish(initLog.debug, partitionPeauFissFond, 'partitionPeauFissFond' )
116 edges = geompy.ExtractShapes(WirePorteFondFissure, geompy.ShapeType["EDGE"], False)
120 for i, edge in enumerate(edges):
121 props = geompy.BasicProperties(edge)
126 edgemax = edges[imax]
127 geomPublish(initLog.debug, edgemax, 'edgemax')
128 centreFondFiss = geompy.MakeVertexOnCurve(edgemax, 0.5)
129 geomPublish(initLog.debug, centreFondFiss, 'centreFondFiss')
130 tangentFondFiss = geompy.MakeTangentOnCurve(edgemax, 0.5)
131 geomPublish(initLog.debug, tangentFondFiss, 'tangentFondFiss')
133 bord1FondFiss = geompy.MakeVertexOnCurve(edgemax, 0.0)
134 geomPublish(initLog.debug, bord1FondFiss, 'bord1FondFiss')
135 tangentBord1FondFiss = geompy.MakeTangentOnCurve(edgemax, 0.0)
136 geomPublish(initLog.debug, tangentBord1FondFiss, 'tangentBord1FondFiss')
138 bord2FondFiss = geompy.MakeVertexOnCurve(edgemax, 1.0)
139 geomPublish(initLog.debug, bord2FondFiss, 'bord2FondFiss')
140 tangentBord2FondFiss = geompy.MakeTangentOnCurve(edgemax, 1.0)
141 geomPublish(initLog.debug, tangentBord2FondFiss, 'tangentBord2FondFiss')
143 planBord1 = geompy.MakePlane(bord1FondFiss, tangentBord1FondFiss, 3*rayonPipe)
144 planBord2 = geompy.MakePlane(bord2FondFiss, tangentBord2FondFiss, 3*rayonPipe)
145 geomPublish(initLog.debug, planBord1, 'planBord1')
146 geomPublish(initLog.debug, planBord2, 'planBord2')
148 [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
149 [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
151 # --- partition peau -face fissure - pipe fond de fissure prolongé
152 partitionPeauFissByPipe = geompy.MakePartition([facesInside[0], facesOnside[0]], [pipefiss], [], [], geompy.ShapeType["FACE"], 0, [], 0)
153 geomPublish(initLog.debug, partitionPeauFissByPipe, 'partitionPeauFissByPipe' )
155 # --- identification face de peau
156 [facesPeauFissInside, facesPeauFissOutside, facesPeauFissOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissByPipe, centreFondFiss, "FACE", 0.1, "peauFiss_bord_")
157 facesPeauSorted, minsur, maxsurf = sortFaces(facesPeauFissOnside) # 4 demi disques, une grande face
158 facePeau = facesPeauSorted[-1] # la plus grande face
159 geomPublishInFather(initLog.debug,partitionPeauFissByPipe, facePeau, "facePeau")
161 # --- identification edges de bord face peau
163 for i, edge in enumerate(edgesFilling):
164 edgepeau = geompy.GetInPlace(facePeau, edge)
165 edgesBords.append(edgepeau)
166 groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
167 geompy.UnionList(groupEdgesBordPeau, edgesBords)
168 geomPublishInFather(initLog.debug,facePeau, groupEdgesBordPeau , "EdgesBords")
170 # --- identification face fissure externe au pipe et edge commune peau fissure
171 for face in facesPeauFissInside:
173 sharedEdges = geompy.GetSharedShapesMulti([facePeau, face], geompy.ShapeType["EDGE"])
174 if sharedEdges is not None:
176 edgePeauFiss = sharedEdges[0]
177 geomPublishInFather(initLog.debug,partitionPeauFissByPipe, faceFiss, "faceFiss")
178 geomPublishInFather(initLog.debug,faceFiss, edgePeauFiss, "edgePeauFiss")
179 geomPublishInFather(initLog.debug,facePeau, edgePeauFiss, "edgePeauFiss")
183 verticesEdgePeauFiss = geompy.ExtractShapes(edgePeauFiss, geompy.ShapeType["VERTEX"], False)
185 # --- identification edges demi cercle dans face de peau
186 edgesFacePeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
187 edgesFacePeauSorted, minlg, maxlg = sortEdges(edgesFacePeau)
188 demiCerclesPeau = edgesFacePeauSorted[0:4]
189 verticesDemiCerclesPeau = []
190 for i, edge in enumerate(demiCerclesPeau):
191 name = "demiCerclePeau_%d"%i
192 geomPublishInFather(initLog.debug,facePeau, edge, name)
193 verticesDemiCerclesPeau += geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False)
194 verticesDemiCerclesPeau = eliminateDoubles(facePeau, verticesDemiCerclesPeau)
195 for i, vertex in enumerate(verticesDemiCerclesPeau):
196 name = "verticesDemiCerclesPeau_%d"%i
197 geomPublishInFather(initLog.debug,facePeau, vertex, name)
198 verticesOutCercles = substractSubShapes(facePeau, verticesDemiCerclesPeau, verticesEdgePeauFiss)
199 for i, vertex in enumerate(verticesOutCercles):
200 name = "verticesOutCercles_%d"%i
201 geomPublishInFather(initLog.debug,facePeau, vertex, name)
203 # --- demi cercles regroupés
204 groupsDemiCerclesPeau = []
205 for i, vertex in enumerate(verticesEdgePeauFiss):
207 for edge in demiCerclesPeau:
208 if geompy.MinDistance(vertex, edge) < 1.e-5:
210 group = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
211 geompy.UnionList(group, demis)
213 geomPublishInFather(initLog.debug,facePeau, group , name)
214 groupsDemiCerclesPeau.append(group)
216 # --- identification edges commune pipe face fissure externe au pipe
217 edgePeauFissId = geompy.GetSubShapeID(partitionPeauFissByPipe, edgePeauFiss)
218 edgesFaceFiss = geompy.ExtractShapes(faceFiss, geompy.ShapeType["EDGE"], False)
219 edgesFaceFissPipe = []
220 for edge in edgesFaceFiss:
221 if geompy.GetSubShapeID(partitionPeauFissByPipe, edge) != edgePeauFissId:
222 edgesFaceFissPipe.append(edge)
223 name = "edgeFaceFissPipe_%d"%len(edgesFaceFissPipe)
224 geomPublishInFather(initLog.debug,faceFiss, edge, name)
225 groupEdgesFaceFissPipe = geompy.CreateGroup(faceFiss, geompy.ShapeType["EDGE"])
226 geompy.UnionList(groupEdgesFaceFissPipe, edgesFaceFissPipe)
227 geomPublishInFather(initLog.debug,faceFiss, groupEdgesFaceFissPipe, "edgesFaceFissPipe")
229 # -----------------------------------------------------------------------------
230 # --- pipe de fond de fissure
232 wireFondFiss = geompy.MakeWire(edgesInside, 1e-07)
234 disque = geompy.MakeDiskPntVecR(centreFondFiss, tangentFondFiss, rayonPipe)
235 [vertex] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
236 vertproj = geompy.MakeProjection(vertex, planfiss)
237 vec1 = geompy.MakeVector(centreFondFiss, vertex)
239 # si centreFondFiss et vertproj sont proches: exception. Angle = +- 90°
240 vec2 = geompy.MakeVector(centreFondFiss, vertproj)
241 angle = geompy.GetAngleRadians(vec1, vec2)
243 # on utilise la projection du centre sur la peau pour avoir un vecteur non nul
244 vertproj = geompy.MakeProjection(centreFondFiss, facePeau)
245 vec2 = geompy.MakeVector(centreFondFiss, vertproj)
246 angle = geompy.GetAngleRadians(vec1, vec2)
247 sommetAxe = geompy.MakeTranslationVector(centreFondFiss, tangentFondFiss)
248 pm = produitMixte(centreFondFiss, vertex, vertproj, sommetAxe)
250 disque = geompy.MakeRotation(disque, tangentFondFiss, angle)
252 disque = geompy.MakeRotation(disque, tangentFondFiss, -angle)
253 [vertexReference] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
255 pipeFondFiss = geompy.MakePipe(disque, wireFondFiss)
256 pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
257 #pipe = geompy.MakePipe(disque, WirePorteFondFissure)
258 #pipe = geompy.MakePartition([pipe],[fillingFaceExterne], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
259 #pipes = geompy.ExtractShapes(pipe, geompy.ShapeType["SOLID"], False)
260 #pipesSorted, volmin, volmax = sortSolids(pipes)
261 #pipeFondFiss = pipesSorted[-1]
262 #pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
264 geomPublish(initLog.debug, disque, 'disque')
265 geomPublish(initLog.debug, wireFondFiss, 'wireFondFiss')
266 geomPublish(initLog.debug, pipeFondFiss, 'pipeFondFiss')
268 VerticesEndFondFiss = findWireEndVertices(wireFondFiss)
269 for i, v in enumerate(VerticesEndFondFiss):
270 name = "vertexEndFondFiss_%d"%i
271 geomPublishInFather(initLog.debug,wireFondFiss, v, name)
272 VerticesEndPipeFiss = []
273 for v in VerticesEndFondFiss:
274 VerticesEndPipeFiss.append(geompy.GetInPlace(pipeFondFiss, v))
275 for i, v in enumerate(VerticesEndPipeFiss):
276 name = "vertexEndPipeFiss_%d"%i
277 geomPublishInFather(initLog.debug,pipeFondFiss, v, name)
279 geomPublishInFather(initLog.debug,pipeFondFiss, VerticesEndPipeFiss[0], "PFOR")
280 geomPublishInFather(initLog.debug,pipeFondFiss, VerticesEndPipeFiss[1], "PFEX")
281 if geompy.MinDistance(VerticesEndPipeFiss[0], verticesOutCercles[0]) > geompy.MinDistance(VerticesEndPipeFiss[0], verticesOutCercles[1]):
282 a = verticesOutCercles[0]
283 verticesOutCercles[0] = verticesOutCercles[1]
284 verticesOutCercles[1] = a
285 geomPublishInFather(initLog.debug,facePeau, verticesOutCercles[0], "THOR")
286 geomPublishInFather(initLog.debug,facePeau, verticesOutCercles[1], "THEX")
288 [facesPipeInside, facesPipeOutside, facesPipeOnside] = extractionOrientee(fillingFaceExterne, pipeFondFiss, centreFondFiss, "FACE", 0.1, "pipe_bord_")
289 [edgesPipeInside, edgesPipeOutside, edgesPipeOnside] = extractionOrientee(fillingFaceExterne, pipeFondFiss, centreFondFiss, "EDGE", 0.1, "pipe_bord_")
290 disqueInt1 = geompy.GetInPlaceByHistory(pipeFondFiss, planBord1)
291 disqueInt2 = geompy.GetInPlaceByHistory(pipeFondFiss, planBord2)
292 disques = facesPipeOnside + [disqueInt1, disqueInt2]
293 edgesDiskInt = geompy.ExtractShapes(disqueInt1, geompy.ShapeType["EDGE"], False)
294 edgesDiskInt = edgesDiskInt +geompy.ExtractShapes(disqueInt2, geompy.ShapeType["EDGE"], False)
295 edgesSorted, minlg, maxlg = sortEdges(edgesDiskInt) # 4 rayons, 2 demi cercles
297 centre = geompy.MakeVertexOnSurface(planfiss, 0.5, 0.5)
298 refpoint = geompy.MakeTranslationVector(centre, geompy.GetNormal(planfiss,centre))
299 geomPublish(initLog.debug, refpoint, 'refpoint')
300 [facesPipeInplan, facesPipeOutplan, facesPipeOnplan] = extractionOrientee(planfiss, pipeFondFiss, refpoint, "FACE", 0.1, "pipe_plan_")
301 [edgesPipeInplan, edgesPipeOutplan, edgesPipeOnplan] = extractionOrientee(planfiss, pipeFondFiss, refpoint, "EDGE", 0.1, "pipe_plan_")
303 # --- rayon disques = (edgesPipeOnside inter edgesPipeOnplan) + rayons disque internes
304 # demi cercles = edgesPipeOnside moins edgesPipeOnplan + demi cercles disque internes
305 # generatrices = edgesPipeOnplan moins rayon disques (3 grandes et 6 petites)
306 edgesIdPipeOnside = getSubshapeIds(pipeFondFiss, edgesPipeOnside)
307 edgesIdPipeOnplan = getSubshapeIds(pipeFondFiss, edgesPipeOnplan)
310 for i, edgeId in enumerate(edgesIdPipeOnside):
311 if edgeId in edgesIdPipeOnplan:
312 rayons.append(edgesPipeOnside[i])
314 demiCercles.append(edgesPipeOnside[i])
315 demiCerclesExternes = demiCercles
316 rayons = rayons + edgesSorted[:4] # les 4 plus petits sont les rayons
317 demiCercles = demiCercles + edgesSorted[4:] # les suivants sont les arcs de cercle
318 rayonsId = getSubshapeIds(pipeFondFiss, rayons)
320 for i, edgeId in enumerate(edgesIdPipeOnplan):
321 if edgeId not in rayonsId:
322 generatrices.append(edgesPipeOnplan[i])
324 # --- generatrices en contact avec la face fissure externe au pipe
326 for edge in generatrices:
327 distance = geompy.MinDistance(vertexReference, edge)
328 logging.debug("distance %s", distance)
330 generFiss.append(edge)
332 for edge in generatrices:
333 distance = geompy.MinDistance(generFiss[0], edge)
334 logging.debug("distance %s", distance)
336 generFiss.append(edge)
337 groupGenerFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
338 geompy.UnionList(groupGenerFiss, generFiss)
339 geomPublishInFather(initLog.debug,pipeFondFiss, groupGenerFiss, "GenFiss")
341 # --- demi cercles externes regroupés
342 groupsDemiCerclesPipe = []
343 for i, vertex in enumerate(verticesEdgePeauFiss):
345 for edge in demiCerclesExternes:
346 if geompy.MinDistance(vertex, edge) < 0.1:
348 group = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
349 geompy.UnionList(group, demis)
351 geomPublishInFather(initLog.debug,pipeFondFiss, group , name)
352 groupsDemiCerclesPipe.append(group)
354 # --- faces fissure dans le pipe
357 generFissId = getSubshapeIds(pipeFondFiss, generFiss)
358 logging.debug("generatrice fissure %s", generFissId)
359 for face in facesPipeOnplan:
360 edges =geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], False)
361 edgesId = getSubshapeIds(pipeFondFiss, edges)
362 logging.debug(" edges %s", edgesId)
363 for i,edgeId in enumerate(edgesId):
364 if edgeId in generFissId:
365 logging.debug("face found")
366 facesFissinPipe.append(face)
367 name = "faceFissInPipe_%d"%i
368 geomPublishInFather(initLog.debug,pipeFondFiss, face, name)
370 groupFaceFissInPipe = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["FACE"])
371 geompy.UnionList(groupFaceFissInPipe, facesFissinPipe)
372 name = "FaceFissInPipe"
373 geomPublishInFather(initLog.debug,pipeFondFiss, groupFaceFissInPipe , name)
375 # --- edges de fond de fissure
378 for i, edge in enumerate(edgesInside):
379 anEdge = geompy.GetInPlace(pipeFondFiss, edge)
380 logging.debug(" edge %s ", anEdge)
381 edgesFondFiss.append(anEdge)
382 name ="edgeFondFissure_%d"%i
383 geomPublishInFather(initLog.debug,pipeFondFiss, anEdge, name)
384 groupEdgeFondFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
385 geompy.UnionList(groupEdgeFondFiss, edgesFondFiss)
387 geomPublishInFather(initLog.debug,pipeFondFiss, groupEdgeFondFiss , name)
389 # -------------------------------------------------------------------------
392 # --- edges de bord face defaut à respecter
394 aFilterManager = smesh.CreateFilterManager()
395 nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ])
397 unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
398 criteres.append(unCritere)
399 filtre = smesh.GetFilterFromCriteria(criteres)
400 bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
401 smesh.SetName(bordsLibres, 'bordsLibres')
403 # --- pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
404 # on designe les faces de peau en quadrangles par le groupe "skinFaces"
406 skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
407 nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
409 # --- maillage pipe fond fissure
411 meshFondFiss = smesh.Mesh(pipeFondFiss)
412 algo2d = meshFondFiss.Quadrangle(algo=smeshBuilder.QUADRANGLE)
413 algo3d = meshFondFiss.Prism()
414 putName(algo3d.GetSubMesh(), "pipe")
415 putName(algo3d, "algo3d_pipe")
416 putName(algo2d, "algo2d_pipe")
418 for i, face in enumerate(disques):
419 algo2d = meshFondFiss.Quadrangle(algo=smeshBuilder.RADIAL_QUAD,geom=face)
420 putName(algo2d.GetSubMesh(), "disque", i)
421 putName(algo2d, "algo2d_disque", i)
423 for i, edge in enumerate(rayons):
424 algo1d = meshFondFiss.Segment(geom=edge)
425 hypo1d = algo1d.NumberOfSegments(4)
426 putName(algo1d.GetSubMesh(), "rayon", i)
427 putName(algo1d, "algo1d_rayon", i)
428 putName(hypo1d, "hypo1d_rayon", i)
430 for i, edge in enumerate(demiCercles):
431 algo1d = meshFondFiss.Segment(geom=edge)
432 hypo1d = algo1d.NumberOfSegments(6)
433 putName(algo1d.GetSubMesh(), "demiCercle", i)
434 putName(algo1d, "algo1d_demiCercle", i)
435 putName(hypo1d, "hypo1d_demiCercle", i)
437 generSorted, minlg, maxlg = sortEdges(generatrices)
438 nbSegGenLong = int(math.sqrt(3.0)*maxlg/(profondeur - rayonPipe)) # on veut 2 triangles equilateraux dans la largeur de la face
440 logging.info("min %s, max %s, nombre de segments %s, nombre de generatrices %s", minlg, maxlg, nbSegGenLong, len(generSorted))
441 for i, edge in enumerate(generSorted):
442 algo1d = meshFondFiss.Segment(geom=edge)
444 hypo1d = algo1d.NumberOfSegments(nbSegGenBout)
446 hypo1d = algo1d.NumberOfSegments(nbSegGenLong)
447 putName(algo1d.GetSubMesh(), "generatrice", i)
448 putName(algo1d, "algo1d_generatrice", i)
449 putName(hypo1d, "hypo1d_generatrice", i)
450 isDone = meshFondFiss.Compute()
451 logging.info("meshFondFiss computed")
454 for i, face in enumerate(disques[:4]):
456 disks.append(meshFondFiss.GroupOnGeom(face, name, SMESH.FACE))
457 peauext_pipe = meshFondFiss.GetMesh().UnionListOfGroups( disks, 'PEAUEXT' )
459 grpPFOR = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[0], "PFOR", SMESH.NODE)
460 grpPFEX = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[1], "PFEX", SMESH.NODE)
462 grp = meshFondFiss.GroupOnGeom(groupFaceFissInPipe, "fisInPi", SMESH.FACE)
463 group_edgeFondFiss = meshFondFiss.GroupOnGeom(groupEdgeFondFiss, "FONDFISS", SMESH.EDGE)
464 noeudsFondFissure = meshFondFiss.GroupOnGeom(groupEdgeFondFiss, "nfondfis", SMESH.NODE)
465 groups_demiCercles = []
466 groupnodes_demiCercles = []
467 for i, group in enumerate(groupsDemiCerclesPipe):
469 groups_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.EDGE))
471 groupnodes_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.NODE))
472 group_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.EDGE)
473 groupnode_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.NODE)
474 grpNode0 = meshFondFiss.IntersectGroups(groupnode_generFiss, groupnodes_demiCercles[0], "Node0")
475 grpNode1 = meshFondFiss.IntersectGroups(groupnode_generFiss, groupnodes_demiCercles[1], "Node1")
476 idNode0 = grpNode0.GetID(1)
477 idNode1 = grpNode1.GetID(1)
479 coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode0))
480 coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode1))
482 for vertex in verticesEdgePeauFiss:
483 coord = geompy.PointCoordinates(vertex);
484 if distance2(coord, coordsMesh[0]) < 0.1:
485 meshFondFiss.MoveNode(idNode0, coord[0], coord[1], coord[2])
486 if distance2(coord, coordsMesh[1]) < 0.1:
487 meshFondFiss.MoveNode(idNode1, coord[0], coord[1], coord[2])
489 for groupNodes in groupnodes_demiCercles:
490 for idNode in groupNodes.GetListOfID():
491 coordMesh = meshFondFiss.GetNodeXYZ(idNode)
492 vertex = geompy.MakeVertex(coordMesh[0], coordMesh[1], coordMesh[2])
496 for i, edge in enumerate(demiCerclesPeau):
497 discoord = geompy.MinDistanceComponents(vertex, edge)
498 if discoord[0] <minDist:
499 minDist = discoord[0]
500 minCoord = discoord[1:]
502 if imin >= 0 and minDist > 1.E-6:
503 logging.debug("node id moved : %s distance=%s", idNode, minDist)
504 meshFondFiss.MoveNode(idNode, coordMesh[0] + minCoord[0], coordMesh[1] + minCoord[1], coordMesh[2] + minCoord[2])
507 # --- maillage face de peau
509 meshFacePeau = smesh.Mesh(facePeau)
510 algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_2D)
511 hypo2d = algo2d.Parameters()
512 hypo2d.SetMaxSize( 1000 )
513 hypo2d.SetOptimize( 1 )
514 hypo2d.SetFineness( 2 )
515 hypo2d.SetMinSize( 2 )
516 hypo2d.SetQuadAllowed( 0 )
517 putName(algo2d.GetSubMesh(), "facePeau")
518 putName(algo2d, "algo2d_facePeau")
519 putName(hypo2d, "hypo2d_facePeau")
521 lenEdgePeauFiss = geompy.BasicProperties(edgePeauFiss)[0]
522 frac = profondeur/lenEdgePeauFiss
523 nbSeg = nbSegGenLong +2*nbSegGenBout
524 ratio = (nbSegGenBout/float(profondeur)) / (nbSegGenLong/lenEdgePeauFiss)
525 logging.info("lenEdgePeauFiss %s, profondeur %s, nbSegGenLong %s, nbSegGenBout %s, frac %s, ratio %s", lenEdgePeauFiss, profondeur, nbSegGenLong, nbSegGenBout, frac, ratio)
526 algo1d = meshFacePeau.Segment(geom=edgePeauFiss)
527 hypo1d = algo1d.NumberOfSegments(nbSeg,[],[ ])
528 hypo1d.SetDistrType( 2 )
529 hypo1d.SetConversionMode( 1 )
530 hypo1d.SetTableFunction( [ 0, ratio, frac, 1, (1.-frac), 1, 1, ratio ] )
531 putName(algo1d.GetSubMesh(), "edgePeauFiss")
532 putName(algo1d, "algo1d_edgePeauFiss")
533 putName(hypo1d, "hypo1d_edgePeauFiss")
535 algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
536 hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
537 putName(algo1d.GetSubMesh(), "bordsLibres")
538 putName(algo1d, "algo1d_bordsLibres")
539 putName(hypo1d, "hypo1d_bordsLibres")
542 algo1d = meshFacePeau.UseExisting1DElements(geom=groupsDemiCerclesPeau[i])
543 hypo1d = algo1d.SourceEdges([ groups_demiCercles[i] ],0,0)
544 putName(algo1d.GetSubMesh(), "DemiCercles", i)
545 putName(algo1d, "algo1d_groupDemiCercles", i)
546 putName(hypo1d, "hypo1d_groupDemiCercles", i)
548 isDone = meshFacePeau.Compute()
549 logging.info("meshFacePeau computed")
550 grpTHOR = meshFacePeau.GroupOnGeom(verticesOutCercles[0], "THOR", SMESH.NODE)
551 grpTHEX = meshFacePeau.GroupOnGeom(verticesOutCercles[1], "THEX", SMESH.NODE)
553 groupEdgesPeauFiss = meshFacePeau.GroupOnGeom(edgePeauFiss, "PeauFis", SMESH.EDGE)
555 peauext_face = meshFacePeau.CreateEmptyGroup( SMESH.FACE, 'PEAUEXT' )
556 nbAdd = peauext_face.AddFrom( meshFacePeau.GetMesh() )
559 # --- maillage face de fissure
561 meshFaceFiss = smesh.Mesh(faceFiss)
562 algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_2D)
563 hypo2d = algo2d.Parameters()
564 hypo2d.SetMaxSize( (profondeur - rayonPipe)/math.sqrt(3.0) ) # pour avoir deux couches de triangles equilateraux partout sur la fissure
565 hypo2d.SetOptimize( 1 )
566 hypo2d.SetFineness( 2 )
567 hypo2d.SetMinSize( 2 )
568 hypo2d.SetQuadAllowed( 0 )
569 putName(algo2d.GetSubMesh(), "faceFiss")
570 putName(algo2d, "algo2d_faceFiss")
571 putName(hypo2d, "hypo2d_faceFiss")
573 algo1d = meshFaceFiss.UseExisting1DElements(geom=edgePeauFiss)
574 hypo1d = algo1d.SourceEdges([ groupEdgesPeauFiss ],0,0)
575 putName(algo1d.GetSubMesh(), "edgeFissPeau")
576 putName(algo1d, "algo1d_edgeFissPeau")
577 putName(hypo1d, "hypo1d_edgeFissPeau")
579 algo1d = meshFaceFiss.UseExisting1DElements(geom=groupEdgesFaceFissPipe)
580 hypo1d = algo1d.SourceEdges([ group_generFiss ],0,0)
581 putName(algo1d.GetSubMesh(), "edgeFissPeau")
582 putName(algo1d, "algo1d_edgeFissPeau")
583 putName(hypo1d, "hypo1d_edgeFissPeau")
585 isDone = meshFaceFiss.Compute()
586 logging.info("meshFaceFiss computed")
588 grp = meshFaceFiss.GroupOnGeom(faceFiss, "fisOutPi", SMESH.FACE)
590 meshBoiteDefaut = smesh.Concatenate([internalBoundary.GetMesh(),
591 meshFondFiss.GetMesh(),
592 meshFacePeau.GetMesh(),
593 meshFaceFiss.GetMesh()],
595 # pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
596 # on designe les faces de peau en quadrangles par le groupe "skinFaces"
597 group_faceFissOutPipe = None
598 group_faceFissInPipe = None
599 groups = meshBoiteDefaut.GetGroups()
601 if grp.GetType() == SMESH.FACE:
602 #if "internalBoundary" in grp.GetName():
603 # grp.SetName("skinFaces")
604 if grp.GetName() == "fisOutPi":
605 group_faceFissOutPipe = grp
606 elif grp.GetName() == "fisInPi":
607 group_faceFissInPipe = grp
609 # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
612 algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
614 algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
615 hypo3d = algo3d.MaxElementVolume(1000.0)
616 putName(algo3d.GetSubMesh(), "boiteDefaut")
617 putName(algo3d, "algo3d_boiteDefaut")
618 isDone = meshBoiteDefaut.Compute()
619 logging.info("meshBoiteDefaut computed")
620 putName(meshBoiteDefaut, "boiteDefaut")
622 groups = maillageSain.GetGroups()
623 grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
624 grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
625 coords1 = maillageSain.GetNodeXYZ(grps1[0].GetID(1))
626 coords2 = maillageSain.GetNodeXYZ(grps2[0].GetID(1))
627 logging.info("coords1 %s, coords2 %s",coords1, coords2)
629 faceFissure = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
630 maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges)
631 putName(maillageSain, nomFicSain+"_coupe")
632 extrusionFaceFissure, normfiss = shapeSurFissure(facePorteFissure)
633 maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut, extrusionFaceFissure, facePorteFissure, 'COUDE')
635 groups = maillageComplet.GetGroups()
636 grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
637 grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
638 nodeid1 = maillageComplet.AddNode(coords1[0], coords1[1], coords1[2])
639 nodeid2 = maillageComplet.AddNode(coords2[0], coords2[1], coords2[2])
640 grps1[0].Add([nodeid1])
641 grps2[0].Add([nodeid2])
642 ma0d1 = maillageComplet.Add0DElement(nodeid1)
643 ma0d2 = maillageComplet.Add0DElement(nodeid2)
644 grpma0d1 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P1' )
645 nbAdd = grpma0d1.Add( [ma0d1] )
646 grpma0d2 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P2' )
647 nbAdd = grpma0d2.Add( [ma0d2] )
649 # grps = [ grp for grp in groups if grp.GetName() == 'affectedEdges']
650 # grps[0].SetName('affEdges')
651 # grps = [ grp for grp in groups if grp.GetName() == 'affectedFaces']
652 # grps[0].SetName('affFaces')
653 # grps = [ grp for grp in groups if grp.GetName() == 'affectedVolumes']
654 # grps[0].SetName('affVols')
656 maillageComplet.ConvertToQuadratic( 1 )
657 grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
658 fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
660 grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
661 nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
663 plansim = geompy.MakePlane(O, normfiss, 10000)
664 fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
665 grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
666 nb = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
667 #isDone = maillageComplet.ReorientObject( grps[0] )
668 fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
670 maillageComplet.ExportMED(fichierMaillageFissure)
671 putName(maillageComplet, nomFicFissure)
672 logging.info("fichier maillage fissure %s", fichierMaillageFissure)
674 if salome.sg.hasDesktop():
675 salome.sg.updateObjBrowser()
677 return maillageComplet