1 # -*- coding: utf-8 -*-
3 from geomsmesh import geompy, smesh
14 from fissureGenerique import fissureGenerique
16 from triedreBase import triedreBase
17 from genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
18 from creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
19 from insereFissureGenerale import insereFissureGenerale
20 from sortEdges import sortEdges
22 O, OX, OY, OZ = triedreBase()
24 class fissureCoude(fissureGenerique):
26 problème de fissure du Coude : version de base
30 nomProbleme = "tuyau_Coude"
32 # ---------------------------------------------------------------------------
33 def setParamGeometrieSaine(self):
35 Paramètres géométriques du tuyau coudé sain:
43 self.geomParams = dict(angleCoude = 60,
50 # ---------------------------------------------------------------------------
51 def genereGeometrieSaine(self, geomParams):
52 logging.info("genereGeometrieSaine %s", self.nomCas)
54 angleCoude = geomParams['angleCoude']
55 r_cintr = geomParams['r_cintr']
56 l_tube_p1 = geomParams['l_tube_p1']
57 l_tube_p2 = geomParams['l_tube_p2']
58 epais = geomParams['epais']
61 centre = geompy.MakeVertex(0, 0, -l_tube_p1)
62 diskext = geompy.MakeDiskPntVecR(centre, OZ, de/2.)
63 diskint = geompy.MakeDiskPntVecR(centre, OZ, de/2. -epais)
64 couronne = geompy.MakeCut(diskext, diskint)
65 tube_1 = geompy.MakePrismVecH(couronne, OZ, l_tube_p1)
66 axe = geompy.MakeTranslation(OY, -r_cintr, 0, -l_tube_p1)
67 coude = geompy.MakeRevolution(couronne, axe, angleCoude*math.pi/180.0)
68 Rotation_1 = geompy.MakeRotation(couronne, axe, angleCoude*math.pi/180.0)
69 Rotation_2 = geompy.MakeRotation(OZ, OY, angleCoude*math.pi/180.0)
70 tube_2 = geompy.MakePrismVecH(Rotation_1, Rotation_2, -l_tube_p2)
71 plan_y = geompy.MakePlaneLCS(None, 100000, 3)
72 geompy.addToStudy( plan_y, "plan_y" )
73 geompy.addToStudy( tube_1, "tube_1" )
74 geompy.addToStudy( coude, "coude" )
75 geompy.addToStudy( tube_2, "tube_2" )
78 geompy.addToStudy( P1, "P1" )
79 op2 = geompy.MakeVertex(0, 0, -l_tube_p1)
80 P2 = geompy.MakeRotation(op2, axe, angleCoude*math.pi/180.0)
81 P2 = geompy.MakeTranslationVectorDistance(P2, Rotation_2, -l_tube_p2)
82 geompy.addToStudy( P2, "P2" )
86 geometrieSaine = geompy.MakePartition([tube_1, coude, tube_2, P1, P2], [plan_y], [], [], geompy.ShapeType["SOLID"], 0, [], 1)
87 geompy.addToStudy( geometrieSaine, self.nomCas )
88 [P1, P2] = geompy.RestoreGivenSubShapes(geometrieSaine, [P1, P2], GEOM.FSM_GetInPlaceByHistory, False, True)
90 xmin = -de -r_cintr -l_tube_p2
91 zmin = -l_tube_p1 -r_cintr -l_tube_p2 -de
93 boxypos = geompy.MakeBox(xmin, 0, zmin, ymax, ymax, 100, "boxypos")
94 boxyneg = geompy.MakeBox(xmin, 0, zmin, ymax, -ymax, 100, "boxyneg")
95 edgesypos = geompy.GetShapesOnShape(boxypos, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
96 edgesyneg = geompy.GetShapesOnShape(boxyneg, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
97 circ_g = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
98 geompy.UnionList(circ_g, edgesyneg)
99 circ_d = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
100 geompy.UnionList(circ_d, edgesypos)
101 edgesy0pos = geompy.GetShapesOnShape(boxypos, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_ONIN)
102 grpedpos = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
103 geompy.UnionList(grpedpos, edgesy0pos)
104 grpedy0 = geompy.CutGroups(grpedpos, circ_d, "edges_y0")
105 boxtub1 = geompy.MakeBox(-de/2.0 -1, -1, -l_tube_p1, de, de, 0, "boxtub1")
106 edgestub1 = geompy.GetShapesOnShape(boxtub1, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
107 grped = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
108 geompy.UnionList(grped, edgestub1)
109 long_p1 = geompy.IntersectGroups(grped, grpedy0)
110 boxtub = geompy.MakeBox(-de/2.0 -1, -1, -l_tube_p1 -l_tube_p2, de, de, -l_tube_p1)
111 boxtub2 = geompy.MakeRotation(boxtub, axe, angleCoude*math.pi/180.0, "boxttub2")
112 edgestub2 = geompy.GetShapesOnShape(boxtub2, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
113 grped = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
114 geompy.UnionList(grped, edgestub2)
115 long_p2 = geompy.IntersectGroups(grped, grpedy0)
116 boxtub1t = geompy.MakeTranslationVectorDistance(boxtub1, OZ, -l_tube_p1)
117 facer = geompy.GetShapesOnShape(boxtub1t, boxtub1, geompy.ShapeType["FACE"], GEOM.ST_ONIN, "facer")
118 boxcoud = geompy.MakeRevolution(facer[0], axe, angleCoude*math.pi/180.0, "boxcoud")
119 edgescoud = geompy.GetShapesOnShape(boxcoud, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
120 grped = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
121 geompy.UnionList(grped, edgescoud)
122 long_coude = geompy.IntersectGroups(grped, grpedy0)
123 grped = geompy.CutGroups(grpedy0, long_p1)
124 grped = geompy.CutGroups(grped, long_p2)
125 ep = geompy.CutGroups(grped, long_coude)
126 geompy.addToStudyInFather( geometrieSaine, long_p1, 'long_p1' )
127 geompy.addToStudyInFather( geometrieSaine, ep, 'ep' )
128 geompy.addToStudyInFather( geometrieSaine, long_coude, 'long_coude' )
129 geompy.addToStudyInFather( geometrieSaine, circ_g, 'circ_g' )
130 geompy.addToStudyInFather( geometrieSaine, circ_d, 'circ_d' )
131 geompy.addToStudyInFather( geometrieSaine, long_p2, 'long_p2' )
133 # --- face extremite tube (EXTUBE)
135 facesIds = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["FACE"], OZ, GEOM.ST_ON)
136 EXTUBE = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
137 geompy.UnionIDs(EXTUBE, facesIds)
138 geompy.addToStudyInFather( geometrieSaine, EXTUBE, 'EXTUBE' )
140 # --- edge bord extremite tube (BORDTU)
142 edge1Ids = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["EDGE"], OZ, GEOM.ST_ON)
143 edge2Ids = geompy.GetShapesOnCylinderIDs(geometrieSaine, geompy.ShapeType["EDGE"], OZ, de/2. -epais, GEOM.ST_ON)
145 for edge in edge1Ids:
147 edgesIds.append(edge)
148 BORDTU = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
149 geompy.UnionIDs(BORDTU, edgesIds)
150 geompy.addToStudyInFather( geometrieSaine, BORDTU, 'BORDTU' )
152 # --- face origine tube (CLGV)
154 pp2 = geompy.MakeTranslationVectorDistance(P2, Rotation_2, 10)
155 vec2 = geompy.MakeVector(P2, pp2)
156 #geompy.addToStudy(vec2, 'vec2')
157 facesIds = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["FACE"], vec2, GEOM.ST_ON)
158 CLGV = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
159 geompy.UnionIDs(CLGV, facesIds)
160 geompy.addToStudyInFather( geometrieSaine, CLGV, 'CLGV' )
162 # --- peau tube interieur (PEAUINT)
164 extru1 = geompy.MakePrismVecH(diskint, OZ, l_tube_p1)
165 revol1 = geompy.MakeRevolution(diskint, axe, angleCoude*math.pi/180.0)
166 rot1 = geompy.MakeRotation(diskint, axe, angleCoude*math.pi/180.0)
167 extru2 = geompy.MakePrismVecH(rot1, Rotation_2, -l_tube_p2)
168 interne = geompy.MakeFuse(extru1, revol1)
169 interne = geompy.MakeFuse(extru2, interne)
170 geompy.addToStudy(interne, 'interne')
171 facesIds = geompy.GetShapesOnShapeIDs(interne, geometrieSaine, geompy.ShapeType["FACE"], GEOM.ST_ONIN)
172 PEAUINT = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
173 geompy.UnionIDs(PEAUINT, facesIds)
174 geompy.addToStudyInFather( geometrieSaine, PEAUINT, 'PEAUINT' )
176 # --- peau tube exterieur (PEAUEXT)
178 cercle1 = geompy.MakeCircle(centre, OZ, de/2.)
179 extru1 = geompy.MakePrismVecH(cercle1, OZ, l_tube_p1)
180 revol1 = geompy.MakeRevolution(cercle1, axe, angleCoude*math.pi/180.0)
181 rot1 = geompy.MakeRotation(cercle1, axe, angleCoude*math.pi/180.0)
182 extru2 = geompy.MakePrismVecH(rot1, Rotation_2, -l_tube_p2)
183 externe = geompy.MakeFuse(extru1, revol1)
184 externe = geompy.MakeFuse(extru2, externe)
185 geompy.addToStudy(externe, 'externe')
186 facesIds = geompy.GetShapesOnShapeIDs(externe, geometrieSaine, geompy.ShapeType["FACE"], GEOM.ST_ON)
187 PEAUEXT = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
188 geompy.UnionIDs(PEAUEXT, facesIds)
189 geompy.addToStudyInFather( geometrieSaine, PEAUEXT, 'PEAUEXT' )
193 volIds = geompy.SubShapeAllIDs(geometrieSaine, geompy.ShapeType["SOLID"])
194 COUDE = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["SOLID"])
195 geompy.UnionIDs(COUDE, volIds)
196 geompy.addToStudyInFather( geometrieSaine, COUDE, 'COUDSAIN' )
198 geometriesSaines = [geometrieSaine, long_p1, ep, long_coude, circ_g, circ_d, long_p2, P1, P2, EXTUBE, BORDTU, CLGV, PEAUINT, PEAUEXT, COUDE]
200 return geometriesSaines
202 # ---------------------------------------------------------------------------
203 def setParamMaillageSain(self):
204 self.meshParams = dict(n_long_p1 = 16,
211 # ---------------------------------------------------------------------------
212 def genereMaillageSain(self, geometriesSaines, meshParams):
213 logging.info("genereMaillageSain %s", self.nomCas)
215 geometrieSaine = geometriesSaines[0]
216 long_p1 = geometriesSaines[1]
217 ep = geometriesSaines[2]
218 long_coude = geometriesSaines[3]
219 circ_g = geometriesSaines[4]
220 circ_d = geometriesSaines[5]
221 long_p2 = geometriesSaines[6]
222 P1 = geometriesSaines[7]
223 P2 = geometriesSaines[8]
224 EXTUBE = geometriesSaines[9]
225 BORDTU = geometriesSaines[10]
226 CLGV = geometriesSaines[11]
227 PEAUINT = geometriesSaines[12]
228 PEAUEXT = geometriesSaines[13]
229 COUDE = geometriesSaines[14]
231 n_long_p1 = meshParams['n_long_p1']
232 n_ep = meshParams['n_ep']
233 n_long_coude = meshParams['n_long_coude']
234 n_circ_g = meshParams['n_circ_g']
235 n_circ_d = meshParams['n_circ_d']
236 n_long_p2 = meshParams['n_long_p2']
238 maillageSain = smesh.Mesh(geometrieSaine)
240 algo3d = maillageSain.Hexahedron()
241 algo2d = maillageSain.Quadrangle()
242 smesh.SetName(algo3d, "algo3d_maillageSain")
243 smesh.SetName(algo2d, "algo2d_maillageSain")
245 algo1d_long_p1 = maillageSain.Segment(geom=long_p1)
246 hypo1d_long_p1 = algo1d_long_p1.NumberOfSegments(n_long_p1)
247 smesh.SetName(algo1d_long_p1, "algo1d_long_p1")
248 smesh.SetName(hypo1d_long_p1, "hypo1d_long_p1")
250 algo1d_ep = maillageSain.Segment(geom=ep)
251 hypo1d_ep = algo1d_ep.NumberOfSegments(n_ep)
252 smesh.SetName(algo1d_ep, "algo1d_ep")
253 smesh.SetName(hypo1d_ep, "hypo1d_ep")
255 algo1d_long_coude = maillageSain.Segment(geom=long_coude)
256 hypo1d_long_coude = algo1d_long_coude.NumberOfSegments(n_long_coude)
257 smesh.SetName(algo1d_long_coude, "algo1d_long_coude")
258 smesh.SetName(hypo1d_long_coude, "hypo1d_long_coude")
260 algo1d_circ_g = maillageSain.Segment(geom=circ_g)
261 hypo1d_circ_g = algo1d_circ_g.NumberOfSegments(n_circ_g)
262 smesh.SetName(algo1d_circ_g, "algo1d_circ_g")
263 smesh.SetName(hypo1d_circ_g, "hypo1d_circ_g")
265 algo1d_circ_d = maillageSain.Segment(geom=circ_d)
266 hypo1d_circ_d = algo1d_circ_d.NumberOfSegments(n_circ_d)
267 smesh.SetName(algo1d_circ_d, "algo1d_circ_d")
268 smesh.SetName(hypo1d_circ_d, "hypo1d_circ_d")
270 algo1d_long_p2 = maillageSain.Segment(geom=long_p2)
271 hypo1d_long_p2 = algo1d_long_p2.NumberOfSegments(n_long_p2)
272 smesh.SetName(algo1d_long_p2, "algo1d_long_p2")
273 smesh.SetName(hypo1d_long_p2, "hypo1d_long_p2")
275 isDone = maillageSain.Compute()
277 mp1 = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE)
278 mp2 = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE)
279 ext = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE)
280 btu = maillageSain.GroupOnGeom(BORDTU,'BORDTU',SMESH.EDGE)
281 clg = maillageSain.GroupOnGeom(CLGV,'CLGV',SMESH.FACE)
282 pei = maillageSain.GroupOnGeom(PEAUINT,'PEAUINT',SMESH.FACE)
283 pex = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE)
284 cou = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME)
286 return [maillageSain, True] # True : maillage hexa
288 # ---------------------------------------------------------------------------
289 def setParamShapeFissure(self):
291 paramètres de la fissure pour le tuyau coude
292 profondeur : 0 < profondeur <= épaisseur
293 rayonPipe : rayon du pipe correspondant au maillage rayonnant
294 lenSegPipe : longueur des mailles rayonnantes le long du fond de fissure (= rayonPipe par défaut)
295 azimut : entre 0 et 360°
296 alpha : 0 < alpha < angleCoude
297 longueur : <=2*profondeur ==> force une fissure elliptique (longueur/profondeur = grand axe/petit axe).
298 orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
299 lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
300 elliptique : True : fissure elliptique (longueur/profondeur = grand axe/petit axe); False : fissure longue (fond de fissure de profondeur constante, demi-cercles aux extrémites)
301 pointIn_x : optionnel coordonnées x d'un point dans le solide, pas trop loin du centre du fond de fissure (idem y,z)
302 externe : True : fissure face externe, False : fissure face interne
304 logging.info("setParamShapeFissure %s", self.nomCas)
305 self.shapeFissureParams = dict(profondeur = 10,
316 # ---------------------------------------------------------------------------
317 def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
318 logging.info("genereShapeFissure %s", self.nomCas)
319 logging.info("shapeFissureParams %s", shapeFissureParams)
321 angleCoude = geomParams['angleCoude']
322 r_cintr = geomParams['r_cintr']
323 l_tube_p1 = geomParams['l_tube_p1']
324 l_tube_p2 = geomParams['l_tube_p2']
325 epais = geomParams['epais']
326 de = geomParams['de']
328 profondeur = shapeFissureParams['profondeur']
329 azimut = shapeFissureParams['azimut']
330 alpha = shapeFissureParams['alpha']
331 longueur = shapeFissureParams['longueur']
332 orientation = shapeFissureParams['orientation']
333 externe = shapeFissureParams['externe']
334 lgInfluence = shapeFissureParams['lgInfluence']
335 self.elliptique = False
336 if shapeFissureParams.has_key('elliptique'):
337 self.elliptique = shapeFissureParams['elliptique']
341 azimut = -azimut # axe inverse / ASCOUF
342 axe = geompy.MakeTranslation(OY, -r_cintr, 0, -l_tube_p1)
343 geompy.addToStudy(axe,"axe")
346 lgInfluence = profondeur
348 if longueur > 2*profondeur:
349 self.fissureLongue=True
351 self.fissureLongue=False
352 self.elliptique = True
354 self.circonferentielle = False
355 self.longitudinale = False
356 if self.fissureLongue and not self.elliptique:
357 if abs(orientation) < 45 :
358 self.longitudinale = True
360 self.circonferentielle = True
363 if self.circonferentielle:
367 rayint = raybor - profondeur
368 rayext = raybor + profondeur/5.0
371 raybor = de/2. - epais
372 rayint = raybor + profondeur
373 rayext = raybor - profondeur/5.0
374 lgfond = longueur -2*profondeur
375 angle = lgfond/(2*raybor)
376 pb = geompy.MakeVertex(raybor, 0, 0)
377 pi = geompy.MakeVertex(rayint, 0, 0)
378 pbl = geompy.MakeRotation(pb, OZ, angle)
379 pbr = geompy.MakeRotation(pb, OZ, -angle)
380 geompy.addToStudy(pbl,"pbl")
381 geompy.addToStudy(pbr,"pbr")
382 pal = geompy.MakeTranslationVector(pbl, OZ)
383 par = geompy.MakeTranslationVector(pbr, OZ)
384 axl = geompy.MakeVector(pbl,pal)
385 axr = geompy.MakeVector(pbr,par)
386 pil = geompy.MakeRotation(pi, OZ, angle)
387 pir = geompy.MakeRotation(pi, OZ, -angle)
391 angi = dp*(nbp -i)*(2.0*math.pi/3.0)/nbp
392 pt = geompy.MakeRotation(pil, axl, angi)
395 angi = angle -2.0*i*angle/nbp
396 pt = geompy.MakeRotation(pi, OZ, angi)
398 for i in range(nbp+1):
399 angi = -dp*i*(2.0*math.pi/3.0)/nbp
400 pt = geompy.MakeRotation(pir, axr, angi)
402 for i, pt in enumerate(points):
403 pt = geompy.MakeRotation(pt, OZ, azimut*math.pi/180.)
404 pt = geompy.MakeTranslation(pt, 0, 0, -l_tube_p1)
405 pt = geompy.MakeRotation(pt, axe, alpha*math.pi/180.)
407 wire0 = geompy.MakeInterpol(points[0:nbp+1])
408 wire1 = geompy.MakeInterpol(points[nbp:2*nbp+1])
409 wire2 = geompy.MakeInterpol(points[2*nbp:3*nbp+1])
410 #wiretube = geompy.MakeInterpol(points)
411 wiretube=geompy.MakeWire([wire0,wire1,wire2])
412 geompy.addToStudy(wiretube,"wiretube")
414 pe = geompy.MakeVertex(rayext, 0, 0)
415 pe = geompy.MakeRotation(pe, OZ, azimut*math.pi/180.)
416 pe = geompy.MakeTranslation(pe, 0, 0, -l_tube_p1)
417 pe = geompy.MakeRotation(pe, axe, alpha*math.pi/180.)
419 arce = geompy.MakeArc(points[0], pe, points[-1])
420 geompy.addToStudy(arce,"arce")
422 facefiss = geompy.MakeFaceWires([arce, wiretube], 1)
423 geompy.addToStudy( facefiss, 'facefissPlace' )
425 pc = geompy.MakeVertex((raybor + rayint)/2.0, 0, 0)
426 centre = geompy.MakeRotation(pc, OZ, azimut*math.pi/180.)
427 centre = geompy.MakeTranslation(centre, 0, 0, -l_tube_p1)
428 centre = geompy.MakeRotation(centre, axe, alpha*math.pi/180.)
429 geompy.addToStudy( centre, 'centrefissPlace' )
431 wiretube = geompy.GetInPlace(facefiss, wiretube)
432 geompy.addToStudy(wiretube, 'wiretubePlace' )
434 edgetube = geompy.MakeEdgeWire(wiretube)
435 geompy.addToStudy(edgetube,"edgetube")
437 logging.debug("erreur MakeEdgeWire sur fond de fissure, on fait sans")
440 # ---------------------------------------------------------
442 elif self.longitudinale:
447 raybor = de/2. - epais
449 prof = dp * profondeur
450 lgfond = longueur -2*profondeur
451 cosaz = math.cos(azimut*math.pi/180.)
452 sinaz = math.sin(azimut*math.pi/180.)
453 alfrd = alpha*math.pi/180.
454 rayxy = r_cintr + raybor*cosaz
455 angle = lgfond/(2.*rayxy)
456 logging.debug("longueur: %s, angle: %s, rayon: %s",lgfond, angle, rayxy)
457 pb = geompy.MakeVertex(raybor*cosaz, raybor*sinaz, -l_tube_p1, "pb")
458 pi = geompy.MakeTranslation(pb, prof*cosaz, prof*sinaz, 0., "pi")
459 pbv = geompy.MakeTranslation(pb, -sinaz, cosaz, 0., "pbv")
460 axb = geompy.MakeVector(pb,pbv, "axb")
461 pbl = geompy.MakeRotation(pb, axe, alfrd -angle, "pbl")
462 pbr = geompy.MakeRotation(pb, axe, alfrd +angle, "pbr")
463 axl = geompy.MakeRotation(axb, axe, alfrd -angle, "axl")
464 axr = geompy.MakeRotation(axb, axe, alfrd +angle, "axr")
465 pil = geompy.MakeRotation(pi, axe, alfrd -angle, "pil")
466 pir = geompy.MakeRotation(pi, axe, alfrd +angle, "pir")
474 for i in range(nbp+2):
475 x = math.sin(i*math.pi/(nbp+1)) # fonction de répartition des points : distance relative
479 logging.debug("x2: %s, totx: %s", x2, totx)
480 for i in range(nbp+1):
481 #posi = nbp -i # répartition équidistante des points sur la courbe
482 posi = nbp*(1 -xs[i]/totx) # points plus resserrés aux extrémités de la courbe
483 angi = -dp*posi*(5.0*math.pi/8.0)/nbp
484 pt = geompy.MakeRotation(pil, axl, angi)
486 curves.append(geompy.MakeInterpol(points))
488 geompy.addToStudy(curves[-1],"curve0")
489 # for i, pt in enumerate(points):
491 # geompy.addToStudyInFather(curves[-1], pt, name)
497 for i in range(nbp+1):
498 x = math.sin(i*math.pi/nbp)
499 #x = 1.0 # répartition équidistante des points sur la courbe
500 x2 = x*x # points plus resserrés aux extrémités de la courbe
503 logging.debug("x2: %s, totx: %s", x2, totx)
505 angi = alfrd -angle +2.0*angle*xs[i]/totx
506 pt = geompy.MakeRotation(pi, axe, angi)
508 curves.append(geompy.MakeInterpol(points))
509 geompy.addToStudy(curves[-1],"curve1")
510 # for i, pt in enumerate(points):
512 # geompy.addToStudyInFather(curves[-1], pt, name)
518 for i in range(nbp+2):
519 x = math.sin(i*math.pi/(nbp+1))
523 logging.debug("x2: %s, totx: %s", x2, totx)
524 for i in range(nbp+1):
525 #posi = nbp -i # répartition équidistante des points sur la courbe
526 posi = nbp*xs[i]/totx # points plus resserrés aux extrémités de la courbe
527 angi = dp*posi*(5.0*math.pi/8.0)/nbp
528 pt = geompy.MakeRotation(pir, axr, angi)
530 curves.append(geompy.MakeInterpol(points))
532 geompy.addToStudy(curves[-1],"curve2")
533 # for i, pt in enumerate(points):
535 # geompy.addToStudyInFather(curves[-1], pt, name)
537 wiretube = geompy.MakeWire(curves)
538 geompy.addToStudy(wiretube,"wiretube")
540 edgetube = geompy.MakeEdgeWire(wiretube)
541 geompy.addToStudy(edgetube,"edgetube")
543 logging.debug("erreur MakeEdgeWire sur fond de fissure, on fait sans")
548 dpr = prof*math.cos(5.0*math.pi/8.0)
549 pe = geompy.MakeTranslation(pb, dpr*cosaz, dpr*sinaz, 0., "pe")
551 angi = alfrd -angle +2.0*i*angle/nbp
552 pt = geompy.MakeRotation(pe, axe, angi)
555 arce = geompy.MakeInterpol(pts)
556 geompy.addToStudy(arce,"arce")
558 facefiss = geompy.MakeFaceWires([arce, wiretube], 0)
559 geompy.addToStudy( facefiss, 'facefissPlace' )
561 pc = geompy.MakeTranslation(pb, 0.5*prof*cosaz, 0.5*prof*sinaz, 0.)
562 centre = geompy.MakeRotation(pc, axe, alfrd)
563 geompy.addToStudy( centre, 'centrefissPlace' )
565 edges = geompy.ExtractShapes(facefiss, geompy.ShapeType["EDGE"], True)
566 edgesTriees, minl, maxl = sortEdges(edges)
567 edges = edgesTriees[:-1] # la plus grande correspond à arce, on l'elimine
568 wiretube = geompy.MakeWire(edges)
569 #wiretube = edgesTriees[-1]
570 geompy.addToStudy(wiretube, 'wiretubePlace' )
572 # ---------------------------------------------------------
574 else: # fissure elliptique, longue ou courte
579 raybor = de/2. - epais
581 prof = dp * profondeur
582 cosaz = math.cos(azimut*math.pi/180.)
583 sinaz = math.sin(azimut*math.pi/180.)
584 alfrd = alpha*math.pi/180.
585 pb = geompy.MakeVertex(raybor*cosaz, raybor*sinaz, -l_tube_p1, "pb")
586 pi = geompy.MakeTranslation(pb, prof*cosaz, prof*sinaz, 0., "pi")
587 pbv = geompy.MakeTranslation(pb, -profondeur*sinaz, profondeur*cosaz, 0., "pbv")
588 ayb = geompy.MakeVector(pb,pbv, "ayb")
589 pb0 = geompy.MakeRotation(pb, axe, alfrd, "pb0")
590 ay0 = geompy.MakeRotation(ayb, axe, alfrd, "ay0")
591 pi0 = geompy.MakeRotation(pi, axe, alfrd, "pi0")
592 az_ = geompy.MakeVector(pi0, pb0, "az_")
593 az0 = geompy.MakeTranslationVector(az_, az_, "az0") #normale sortante
594 ax0 = geompy.MakeRotation(ay0, az0, -math.pi/2.0, "ax0")
595 ax1 = geompy.MakeRotation(ax0, az0, orientation*math.pi/180., "ax1")
596 ay1 = geompy.MakeRotation(ay0, az0, orientation*math.pi/180., "ay1")
597 originLCS = geompy.MakeMarker(0, 0, 0, 1, 0, 0, 0, 1, 0, "originLCS")
598 coo = geompy.PointCoordinates(pb0)
599 cox = geompy.VectorCoordinates(ax1)
600 coy = geompy.VectorCoordinates(ay1)
601 localLCS = geompy.MakeMarker(coo[0], coo[1], coo[2], cox[0], cox[1], cox[2], coy[0], coy[1], coy[2], "localLCS")
603 pco = geompy.MakeVertex(0, 0, -profondeur, "pco")
604 pao = geompy.MakeRotation(pco, OY, 0.6*math.pi, "pao")
605 pbo = geompy.MakeRotation(pco, OY, -0.6*math.pi, "pbo")
606 pce = geompy.MakeVertex(0, 0, 0.1*profondeur,"pce")
607 arcoo = geompy.MakeArc(pao, pco, pbo, "arcoo")
608 linoo = geompy.MakeArc(pao, pce, pbo, "linoo")
609 scalex = longueur/profondeur
610 arco =geompy.MakeScaleAlongAxes(arcoo, O, scalex, 1., 1., "arco")
611 lino =geompy.MakeScaleAlongAxes(linoo, O, scalex, 1., 1., "lino")
612 arci = geompy.MakePosition(arco, originLCS, localLCS, "arci")
613 arce = geompy.MakePosition(lino, originLCS, localLCS, "arce")
614 facefiss = geompy.MakeFaceWires([arce, arci], 0)
615 geompy.addToStudy( facefiss, 'facefissPlace' )
616 edges = geompy.ExtractShapes(facefiss, geompy.ShapeType["EDGE"], True)
617 edgesTriees, minl, maxl = sortEdges(edges)
618 edgetube = edgesTriees[-1] # la plus grande correspond à arci
621 pc = geompy.MakeTranslation(pb, 0.5*prof*cosaz, 0.5*prof*sinaz, 0.)
622 centre = geompy.MakeRotation(pc, axe, alfrd)
623 geompy.addToStudy( centre, 'centrefissPlace' )
625 coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, profondeur/2. ,profondeur)
627 return [facefiss, centre, lgInfluence, coordsNoeudsFissure, wiretube, edgetube]
629 # ---------------------------------------------------------------------------
630 def setParamMaillageFissure(self):
632 Paramètres du maillage de la fissure pour le tuyau coudé
633 Voir également setParamShapeFissure, paramètres rayonPipe et lenSegPipe.
634 nbSegRad = nombre de couronnes
635 nbSegCercle = nombre de secteurs
636 areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
638 self.maillageFissureParams = dict(nomRep = '.',
639 nomFicSain = self.nomCas,
640 nomFicFissure = 'fissure_' + self.nomCas,
643 areteFaceFissure = 5)
645 # ---------------------------------------------------------------------------
646 def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
647 elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
648 return elementsDefaut
650 # ---------------------------------------------------------------------------
651 def genereMaillageFissure(self, geometriesSaines, maillagesSains,
652 shapesFissure, shapeFissureParams,
653 maillageFissureParams, elementsDefaut, step):
654 maillageFissure = insereFissureGenerale(maillagesSains,
655 shapesFissure, shapeFissureParams,
656 maillageFissureParams, elementsDefaut, step)
657 return maillageFissure
659 # ---------------------------------------------------------------------------
660 def setReferencesMaillageFissure(self):
661 self.referencesMaillageFissure = dict(Entity_Node = 77917,
662 Entity_Quad_Edge = 975,
663 Entity_Quad_Triangle = 2182,
664 Entity_Quad_Quadrangle = 6842,
665 Entity_Quad_Tetra = 20135,
666 Entity_Quad_Hexa = 8994,
667 Entity_Quad_Penta = 972,
668 Entity_Quad_Pyramid = 1038)