1 # -*- coding: utf-8 -*-
5 from geomsmesh import geompy
6 from geomsmesh import smesh
7 from salome.smesh import smeshBuilder
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
26 # -----------------------------------------------------------------------------
27 # --- procedure complete fissure longue
29 def insereFissureLongue(geometriesSaines, maillagesSains,
30 shapesFissure, shapeFissureParams,
31 maillageFissureParams, elementsDefaut, step=-1):
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
46 profondeur = shapeFissureParams['profondeur']
47 rayonPipe = profondeur/4.0
49 nomRep = maillageFissureParams['nomRep']
50 nomFicSain = maillageFissureParams['nomFicSain']
51 nomFicFissure = maillageFissureParams['nomFicFissure']
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
61 #fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
62 fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
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]
79 facePorteFissure = shapeDefaut
80 WirePorteFondFissure = wiretube
81 fillingFaceExterne = facesDefaut[0]
82 print fillingFaceExterne
83 geompy.addToStudy(fillingFaceExterne, "fillingFaceExterne")
84 edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
86 O, OX, OY, OZ = triedreBase()
88 # -----------------------------------------------------------------------------
89 # --- peau et face de fissure
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' )
95 edges = geompy.ExtractShapes(WirePorteFondFissure, geompy.ShapeType["EDGE"], False)
99 for i, edge in enumerate(edges):
100 props = geompy.BasicProperties(edge)
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')
112 bord1FondFiss = geompy.MakeVertexOnCurve(edgemax, 0.0)
113 geompy.addToStudy(bord1FondFiss, 'bord1FondFiss')
114 tangentBord1FondFiss = geompy.MakeTangentOnCurve(edgemax, 0.0)
115 geompy.addToStudy(tangentBord1FondFiss, 'tangentBord1FondFiss')
117 bord2FondFiss = geompy.MakeVertexOnCurve(edgemax, 1.0)
118 geompy.addToStudy(bord2FondFiss, 'bord2FondFiss')
119 tangentBord2FondFiss = geompy.MakeTangentOnCurve(edgemax, 1.0)
120 geompy.addToStudy(tangentBord2FondFiss, 'tangentBord2FondFiss')
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')
127 [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
128 [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
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' )
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")
140 # --- identification edges de bord face peau
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")
149 # --- identification face fissure externe au pipe et edge commune peau fissure
150 for face in facesPeauFissInside:
152 sharedEdges = geompy.GetSharedShapesMulti([facePeau, face], geompy.ShapeType["EDGE"])
153 if sharedEdges is not None:
155 edgePeauFiss = sharedEdges[0]
156 geompy.addToStudyInFather(partitionPeauFissByPipe, faceFiss, "faceFiss")
157 geompy.addToStudyInFather(faceFiss, edgePeauFiss, "edgePeauFiss")
158 geompy.addToStudyInFather(facePeau, edgePeauFiss, "edgePeauFiss")
162 verticesEdgePeauFiss = geompy.ExtractShapes(edgePeauFiss, geompy.ShapeType["VERTEX"], False)
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)
182 # --- demi cercles regroupés
183 groupsDemiCerclesPeau = []
184 for i, vertex in enumerate(verticesEdgePeauFiss):
186 for edge in demiCerclesPeau:
187 if geompy.MinDistance(vertex, edge) < 1.e-5:
189 group = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
190 geompy.UnionList(group, demis)
192 geompy.addToStudyInFather(facePeau, group , name)
193 groupsDemiCerclesPeau.append(group)
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")
208 # -----------------------------------------------------------------------------
209 # --- pipe de fond de fissure
211 wireFondFiss = geompy.MakeWire(edgesInside, 1e-07)
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)
218 # si centreFondFiss et vertproj sont proches: exception. Angle = +- 90°
219 vec2 = geompy.MakeVector(centreFondFiss, vertproj)
220 angle = geompy.GetAngleRadians(vec1, vec2)
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)
229 disque = geompy.MakeRotation(disque, tangentFondFiss, angle)
231 disque = geompy.MakeRotation(disque, tangentFondFiss, -angle)
232 [vertexReference] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
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)
243 geompy.addToStudy( disque, 'disque')
244 geompy.addToStudy( wireFondFiss, 'wireFondFiss')
245 geompy.addToStudy( pipeFondFiss, 'pipeFondFiss')
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)
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")
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
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_")
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)
289 for i, edgeId in enumerate(edgesIdPipeOnside):
290 if edgeId in edgesIdPipeOnplan:
291 rayons.append(edgesPipeOnside[i])
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)
299 for i, edgeId in enumerate(edgesIdPipeOnplan):
300 if edgeId not in rayonsId:
301 generatrices.append(edgesPipeOnplan[i])
303 # --- generatrices en contact avec la face fissure externe au pipe
305 for edge in generatrices:
306 distance = geompy.MinDistance(vertexReference, edge)
307 logging.debug("distance %s", distance)
309 generFiss.append(edge)
311 for edge in generatrices:
312 distance = geompy.MinDistance(generFiss[0], edge)
313 logging.debug("distance %s", distance)
315 generFiss.append(edge)
316 groupGenerFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
317 geompy.UnionList(groupGenerFiss, generFiss)
318 geompy.addToStudyInFather(pipeFondFiss, groupGenerFiss, "GenFiss")
320 # --- demi cercles externes regroupés
321 groupsDemiCerclesPipe = []
322 for i, vertex in enumerate(verticesEdgePeauFiss):
324 for edge in demiCerclesExternes:
325 if geompy.MinDistance(vertex, edge) < 0.1:
327 group = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
328 geompy.UnionList(group, demis)
330 geompy.addToStudyInFather(pipeFondFiss, group , name)
331 groupsDemiCerclesPipe.append(group)
333 # --- faces fissure dans le pipe
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)
349 groupFaceFissInPipe = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["FACE"])
350 geompy.UnionList(groupFaceFissInPipe, facesFissinPipe)
351 name = "FaceFissInPipe"
352 geompy.addToStudyInFather(pipeFondFiss, groupFaceFissInPipe , name)
354 # --- edges de fond de fissure
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)
366 geompy.addToStudyInFather(pipeFondFiss, groupEdgeFondFiss , name)
368 # -------------------------------------------------------------------------
371 # --- edges de bord face defaut à respecter
373 aFilterManager = smesh.CreateFilterManager()
374 nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ])
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')
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"
385 skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
386 nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
388 # --- maillage pipe fond fissure
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")
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)
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)
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)
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
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)
423 hypo1d = algo1d.NumberOfSegments(nbSegGenBout)
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")
433 for i, face in enumerate(disques[:4]):
435 disks.append(meshFondFiss.GroupOnGeom(face, name, SMESH.FACE))
436 peauext_pipe = meshFondFiss.GetMesh().UnionListOfGroups( disks, 'PEAUEXT' )
438 grpPFOR = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[0], "PFOR", SMESH.NODE)
439 grpPFEX = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[1], "PFEX", SMESH.NODE)
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):
448 groups_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.EDGE))
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)
458 coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode0))
459 coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode1))
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])
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])
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:]
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])
486 # --- maillage face de peau
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")
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")
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")
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)
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)
532 groupEdgesPeauFiss = meshFacePeau.GroupOnGeom(edgePeauFiss, "PeauFis", SMESH.EDGE)
534 peauext_face = meshFacePeau.CreateEmptyGroup( SMESH.FACE, 'PEAUEXT' )
535 nbAdd = peauext_face.AddFrom( meshFacePeau.GetMesh() )
538 # --- maillage face de fissure
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")
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")
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")
564 isDone = meshFaceFiss.Compute()
565 logging.info("meshFaceFiss computed")
567 grp = meshFaceFiss.GroupOnGeom(faceFiss, "fisOutPi", SMESH.FACE)
569 meshBoiteDefaut = smesh.Concatenate([internalBoundary.GetMesh(),
570 meshFondFiss.GetMesh(),
571 meshFacePeau.GetMesh(),
572 meshFaceFiss.GetMesh()],
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()
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
588 # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
591 algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
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")
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)
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')
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] )
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')
635 maillageComplet.ConvertToQuadratic( 1 )
636 grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
637 fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
639 grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
640 nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
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' )
649 maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
650 putName(maillageComplet, nomFicFissure)
651 logging.info("fichier maillage fissure %s", fichierMaillageFissure)
653 if salome.sg.hasDesktop():
654 salome.sg.updateObjBrowser(1)
656 return maillageComplet