1 # -*- coding: latin-1 -*-
\r
2 # Copyright (C) 2009-2013 CEA/DEN, 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.
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
21 # Francis KLOSS - 2011-2013 - CEA-Saclay, DEN, DM2S, SFME, LGLS, F-91191 Gif-sur-Yvette, France
\r
22 # =============================================================================================
\r
29 # Charger la géométrie
\r
30 # ====================
\r
34 cuve = geompy.ImportBREP(nom+".brep")
\r
36 # Sélectionner des sommets de la géométrie
\r
37 # -----------------------------------------
\r
39 sommets = geompy.SubShapeAllSortedCentres(cuve, geompy.ShapeType["VERTEX"])
\r
41 coin_a = sommets[ 4]
\r
42 coin_b = sommets[43]
\r
43 coin_c = sommets[62]
\r
44 coin_d = sommets[15]
\r
46 support_a_o = sommets[ 3]
\r
47 support_a_x = sommets[ 8]
\r
48 support_a_y = sommets[ 6]
\r
49 support_a_d = sommets[10]
\r
51 support_b_o = sommets[42]
\r
52 support_b_x = sommets[36]
\r
53 support_b_y = sommets[47]
\r
54 support_b_d = sommets[38]
\r
56 support_c_o = sommets[61]
\r
57 support_c_x = sommets[51]
\r
58 support_c_y = sommets[59]
\r
59 support_c_d = sommets[49]
\r
61 support_d_o = sommets[14]
\r
62 support_d_x = sommets[19]
\r
63 support_d_y = sommets[12]
\r
64 support_d_d = sommets[17]
\r
66 coin_x1, coin_y1, coin_z1 = geompy.PointCoordinates(sommets[ 2])
\r
67 coin_x2, coin_y2, coin_z2 = geompy.PointCoordinates(support_a_d)
\r
68 coin_x3, coin_y3, coin_z3 = geompy.PointCoordinates(support_a_o)
\r
69 coin_x4, coin_y4, coin_z4 = geompy.PointCoordinates(coin_c)
\r
71 base_x, base_y, base_z = geompy.PointCoordinates(sommets[52])
\r
72 oppo_x, oppo_y, oppo_z = geompy.PointCoordinates(sommets[57])
\r
74 # Sélectionner des arêtes de la géométrie
\r
75 # ---------------------------------------
\r
77 aretes = geompy.SubShapeAllSortedCentres(cuve, geompy.ShapeType["EDGE"])
\r
79 interne0, interne_x, interne_y, interne_z, interne_dx, interne_dy, interne_dz, interne_rayon = geompy.KindOfShape(aretes[48])
\r
80 externe0, externe_x, externe_y, externe_z, externe_dx, externe_dy, externe_dz, externe_rayon = geompy.KindOfShape(aretes[49])
\r
87 piquage_1_int = aretes[ 0]
\r
88 piquage_1_ext = aretes[ 1]
\r
89 piquage_1_feb = aretes[ 36]
\r
90 piquage_1_feh = aretes[ 38]
\r
91 piquage_1_eeb = aretes[ 33]
\r
92 piquage_1_eeh = aretes[ 37]
\r
93 piquage_1_eib = aretes[ 34]
\r
94 piquage_1_eih = aretes[ 35]
\r
96 piquage_2_int = aretes[103]
\r
97 piquage_2_ext = aretes[104]
\r
98 piquage_2_feg = aretes[ 68]
\r
99 piquage_2_fed = aretes[ 73]
\r
100 piquage_2_eeg = aretes[ 79]
\r
101 piquage_2_eed = aretes[ 88]
\r
102 piquage_2_eig = aretes[ 80]
\r
103 piquage_2_eid = aretes[ 89]
\r
105 support_l, support_a, support_v = geompy.BasicProperties(aretes[43])
\r
106 cote_lgr, cote_aire, cote_vol = geompy.BasicProperties(cote_a)
\r
108 # Sélectionner des faces de la géométrie
\r
109 # --------------------------------------
\r
111 faces = geompy.SubShapeAllSortedCentres(cuve, geompy.ShapeType["FACE"])
\r
113 face_cylindrique_int = faces[21]
\r
114 face_cylindrique_ext = faces[22]
\r
116 # Construire le modèle de blocs
\r
117 # =============================
\r
119 # Créer le document
\r
120 # -----------------
\r
122 doc = hexablock.addDocument(nom)
\r
124 # Calculer l'angle défini par le centre de la cuve et 2 points (projeté dans le plan XY)
\r
125 # --------------------------------------------------------------------------------------
\r
127 centre_cuve = geompy.MakeVertex(externe_x, externe_y, 0)
\r
129 def calculer_angle(point1, point2):
\r
130 x1, y1, z1 = geompy.PointCoordinates(point1)
\r
131 x2, y2, z2 = geompy.PointCoordinates(point2)
\r
133 p1 = geompy.MakeVertex(x1, y1, 0)
\r
134 p2 = geompy.MakeVertex(x2, y2, 0)
\r
136 a1 = geompy.MakeEdge(centre_cuve, p1)
\r
137 a2 = geompy.MakeEdge(centre_cuve, p2)
\r
139 return geompy.GetAngle(a1, a2)
\r
141 # Construire les 8 points de la grille
\r
142 # ------------------------------------
\r
144 p1_int0, p1_int_x, p1_int_y, p1_int_z, p1_int_dx, p1_int_dy, p1_int_dz, p1_int_rayon = geompy.KindOfShape(piquage_1_int)
\r
145 p2_int0, p2_int_x, p2_int_y, p2_int_z, p2_int_dx, p2_int_dy, p2_int_dz, p2_int_rayon = geompy.KindOfShape(piquage_2_int)
\r
147 p1_int_c = geompy.MakeVertex(p1_int_x, p1_int_y, p1_int_z)
\r
148 p2_int_c = geompy.MakeVertex(p2_int_x, p2_int_y, p2_int_z)
\r
150 p1_int_e = geompy.MakePrismDXDYDZ2Ways(p1_int_c, p1_int_dx*cote_lgr, p1_int_dy*cote_lgr, p1_int_dz*cote_lgr)
\r
151 p2_int_e = geompy.MakePrismDXDYDZ2Ways(p2_int_c, p2_int_dx*cote_lgr, p2_int_dy*cote_lgr, p2_int_dz*cote_lgr)
\r
153 plan_2 = geompy.MakePrismDXDYDZ(p1_int_e, +cote_lgr, +cote_lgr, -cote_lgr)
\r
154 plan_3 = geompy.MakePrismDXDYDZ(p1_int_e, -cote_lgr, -cote_lgr, -cote_lgr)
\r
156 plan_7 = geompy.MakePrismDXDYDZ(p2_int_e, 0, -cote_lgr, -cote_lgr)
\r
157 plan_8 = geompy.MakePrismDXDYDZ(p2_int_e, 0, +cote_lgr, -cote_lgr)
\r
159 part_2 = geompy.MakePartition([piquage_1_eeb], [plan_2], [], [], geompy.ShapeType["VERTEX"])
\r
160 part_3 = geompy.MakePartition([piquage_1_eeb], [plan_3], [], [], geompy.ShapeType["VERTEX"])
\r
162 part_7 = geompy.MakePartition([piquage_2_feg], [plan_7], [], [], geompy.ShapeType["VERTEX"])
\r
163 part_8 = geompy.MakePartition([piquage_2_fed], [plan_8], [], [], geompy.ShapeType["VERTEX"])
\r
166 point_2 = geompy.SubShapeAllSortedCentres(part_2, geompy.ShapeType["VERTEX"])[1]
\r
167 point_3 = geompy.SubShapeAllSortedCentres(part_3, geompy.ShapeType["VERTEX"])[1]
\r
168 point_4 = geompy.MakeVertexOnCurve(cote_d, 0.55)
\r
171 point_7 = geompy.SubShapeAllSortedCentres(part_7, geompy.ShapeType["VERTEX"])[0]
\r
172 point_8 = geompy.SubShapeAllSortedCentres(part_8, geompy.ShapeType["VERTEX"])[2]
\r
174 # Construire la grille cylindrique
\r
175 # --------------------------------
\r
177 grille_hauteur = coin_z4-coin_z2
\r
179 centre = doc.addVertex(externe_x, externe_y, externe_z-grille_hauteur)
\r
181 grille_x = doc.addVector(1, 1, 0)
\r
182 grille_z = doc.addVector(0, 0, 1)
\r
184 petit_rayon = interne_rayon * 0.2
\r
185 grand_rayon = math.sqrt( (coin_x1-externe_x)**2 + (coin_y1-externe_y)**2 )
\r
187 rayons = [ petit_rayon, interne_rayon-petit_rayon, externe_rayon-interne_rayon, grand_rayon-externe_rayon ]
\r
189 points = [ point_1, point_2, point_3, point_4, point_5, point_6, point_7, point_8, point_1 ]
\r
192 for i in xrange(8):
\r
193 angle = calculer_angle(points[i], points[i+1])
\r
194 angles.append(angle)
\r
196 hauteurs = [ grille_hauteur ]
\r
198 grille = doc.makeCylindricals(centre, grille_x, grille_z, rayons, angles, hauteurs, False)
\r
200 # Ajouter le centre
\r
201 # -----------------
\r
203 quad_0 = grille.getQuadJK(0, 7, 0)
\r
204 quad_6 = grille.getQuadJK(0, 0, 0)
\r
205 quad_7 = grille.getQuadJK(0, 1, 0)
\r
207 centre_a = doc.addHexa3Quads(quad_0, quad_6, quad_7)
\r
209 quad_2 = grille.getQuadJK(0, 3, 0)
\r
210 quad_3 = grille.getQuadJK(0, 4, 0)
\r
211 quad_4 = grille.getQuadJK(0, 5, 0)
\r
213 centre_b = doc.addHexa3Quads(quad_2, quad_3, quad_4)
\r
215 quad_1 = grille.getQuadJK(0, 2, 0)
\r
216 quad_5 = grille.getQuadJK(0, 6, 0)
\r
218 quad_a = centre_a.getQuad(1)
\r
219 quad_b = centre_b.getQuad(1)
\r
221 centre_c = doc.addHexa4Quads(quad_1, quad_a, quad_5, quad_b)
\r
223 # Ajouter l'enceinte
\r
224 # ------------------
\r
226 plan_0 = geompy.MakePrismDXDYDZ(p1_int_e, +cote_lgr, +cote_lgr, +cote_lgr)
\r
227 part_0 = geompy.MakePartition([piquage_1_feh], [plan_0], [], [], geompy.ShapeType["VERTEX"])
\r
228 point_0 = geompy.SubShapeAllSortedCentres(part_0, geompy.ShapeType["VERTEX"])[1]
\r
230 enceinte_quads = []
\r
231 for j in xrange(8):
\r
232 q = grille.getQuadIJ(1, j, 1)
\r
233 enceinte_quads.append(q)
\r
235 point_7x, point_7y, point_7z = geompy.PointCoordinates(point_7)
\r
236 point_2x, point_2y, point_2z = geompy.PointCoordinates(point_2)
\r
237 point_0x, point_0y, point_0z = geompy.PointCoordinates(point_0)
\r
239 enceinte_h1 = point_7z - base_z
\r
240 enceinte_h2 = point_2z - base_z
\r
241 enceinte_h3 = point_0z - base_z
\r
242 enceinte_h4 = oppo_z - base_z
\r
244 enceinte_hauteurs = [ enceinte_h1, enceinte_h2, enceinte_h3, enceinte_h4 ]
\r
246 enceinte_pz = doc.addVector(oppo_x - base_x, oppo_y - base_y, enceinte_h4)
\r
248 enceinte = doc.prismQuadsVec(enceinte_quads, enceinte_pz, enceinte_hauteurs, 0)
\r
250 # Déconnecter via des arêtes, puis prismer, puis compléter (3) ou coller (1)
\r
251 # --------------------------------------------------------------------------
\r
254 supports_quads_b = []
\r
255 supports_quads_h = []
\r
257 v1 = doc.addVector( 0, +0.1, 0)
\r
258 v2 = doc.addVector( 0, -0.1, 0)
\r
259 v3 = doc.addVector(+0.2, -0.1, 0)
\r
261 for j, v in [ [0, v1], [1, v1], [4, v2], [5, v3] ]:
\r
262 h = grille.getHexaIJK(2, j, 0)
\r
263 a = grille.getEdgeK(3, j, 0)
\r
264 d = doc.disconnectEdge(h, a)
\r
267 q2 = grille.getQuadIK(2, j, 0)
\r
269 h0 = doc.addHexa2Quads(q1, q2)
\r
270 q3 = grille.getQuadJK(3, j, 0)
\r
272 h1 = doc.addHexa2Quads(q3, q4)
\r
273 qb = h1.getQuad(hexablock.Q_E)
\r
274 qh = h1.getQuad(hexablock.Q_F)
\r
276 p = doc.prismQuad(q1, v, 2)
\r
282 doc.addHexa3Quads(q2, q3, q4)
\r
283 periph_hexas.append(h0)
\r
284 qb = h1.getQuad(hexablock.Q_C)
\r
285 qh = h1.getQuad(hexablock.Q_D)
\r
287 supports_quads_b.append(qb)
\r
288 supports_quads_h.append(qh)
\r
290 # Piquer les 2 tuyaux sur l'enceinte
\r
291 # ----------------------------------
\r
293 piquage_centre = doc.addVertex(10, 0, 0)
\r
295 piquage_vx = doc.addVector(1, 0, 0)
\r
296 piquage_vz = doc.addVector(0, 0, 1)
\r
298 piquage = doc.makeCylindrical(piquage_centre, piquage_vx, piquage_vz, 1, 360, 1, 1, 4, 1, False)
\r
300 piquage_quads = [ piquage.getQuadIJ(0, j, 0) for j in xrange(4) ]
\r
302 piquage_s1 = piquage.getVertexIJK(1, 0, 0)
\r
303 piquage_s2 = piquage.getVertexIJK(1, 1, 0)
\r
304 piquage_s3 = piquage.getVertexIJK(1, 2, 0)
\r
306 enceinte_ha = enceinte.getHexa( 6)
\r
307 enceinte_hb = enceinte.getHexa(25)
\r
309 enceinte_s11 = enceinte_ha.getVertex(2)
\r
310 enceinte_s12 = enceinte_ha.getVertex(3)
\r
311 enceinte_s13 = enceinte_ha.getVertex(7)
\r
313 enceinte_s21 = enceinte_hb.getVertex(2)
\r
314 enceinte_s22 = enceinte_hb.getVertex(3)
\r
315 enceinte_s23 = enceinte_hb.getVertex(7)
\r
317 piquage_1 = doc.replace(piquage_quads, piquage_s1, enceinte_s11, piquage_s2, enceinte_s12, piquage_s3, enceinte_s13)
\r
318 piquage_2 = doc.replace(piquage_quads, piquage_s1, enceinte_s21, piquage_s2, enceinte_s22, piquage_s3, enceinte_s23)
\r
320 # Nettoyer le template du piquage
\r
321 # -------------------------------
\r
323 doc.removeElements(piquage)
\r
325 # Associer le modèle de blocs avec la géométrie
\r
326 # =============================================
\r
330 # Nettoyer les associations implicites du centre et de la périphérie
\r
331 # ------------------------------------------------------------------
\r
333 for i in xrange(0, 4, 3):
\r
334 for j in xrange(8):
\r
335 for k in xrange(2):
\r
336 e = grille.getEdgeJ(i, j, k)
\r
337 e.clearAssociation()
\r
339 # Associer le centre de l'enceinte
\r
340 # --------------------------------
\r
342 for j, ig in [ [2, 30], [3, 28], [6, 32], [7, 34] ]:
\r
343 sm0 = grille.getVertexIJK(0, j, 0)
\r
345 sm0.setAssociation(sg0)
\r
347 sm1 = grille.getVertexIJK(0, j, 1)
\r
348 sg1 = geompy.MakeTranslation(sg0, 0, 0, grille_hauteur)
\r
349 sm1.setAssociation(sg1)
\r
351 for j, ig, sens in [ [0, 34, +1], [1, 30, +1], [4, 28, -1], [5, 32, -1] ]:
\r
352 sm0 = grille.getVertexIJK(0, j, 0)
\r
353 sg0 = geompy.MakeTranslation(sommets[ig], 0, sens*support_l, 0)
\r
354 sm0.setAssociation(sg0)
\r
356 sm1 = grille.getVertexIJK(0, j, 1)
\r
357 sg1 = geompy.MakeTranslation(sg0, 0, 0, grille_hauteur)
\r
358 sm1.setAssociation(sg1)
\r
360 # Associer les 16 sommets des 4 supports externes
\r
361 # -----------------------------------------------
\r
363 supports_points = [
\r
364 [ support_c_o, support_c_y, support_c_d, support_c_x ],
\r
365 [ support_d_d, support_d_y, support_d_o, support_d_x ],
\r
366 [ support_a_o, support_a_y, support_a_d, support_a_x ],
\r
367 [ support_b_o, support_b_x, support_b_d, support_b_y ]
\r
370 for s in xrange(4):
\r
371 qb = supports_quads_b[s]
\r
372 qh = supports_quads_h[s]
\r
373 cs = supports_points[s]
\r
374 for i in xrange(4):
\r
375 smb = qb.getVertex(i)
\r
377 smb.setAssociation(sgb)
\r
382 ind = [1, 0, 3, 2][i]
\r
383 smh = qh.getVertex(ind)
\r
384 sgh = geompy.MakeTranslation(sgb, 0, 0, grille_hauteur)
\r
385 smh.setAssociation(sgh)
\r
387 # Associer les 7 sommets périphériques de la grille
\r
388 # -------------------------------------------------
\r
393 periph_grille = [ [0, cote_b, par_2], [1, cote_c, 0.22], [3, cote_d, 0.548], [4, cote_d, par_1], [5, cote_a, par_2], [6, cote_b, 0.44], [7, cote_b, 0.555] ]
\r
395 for j, ag, p in periph_grille:
\r
396 smb = grille.getVertexIJK(3, j, 1)
\r
397 sgb = geompy.MakeVertexOnCurve(ag, p)
\r
398 smb.setAssociation(sgb)
\r
400 smh = grille.getVertexIJK(3, j, 0)
\r
401 sgh = geompy.MakeTranslation(sgb, 0, 0, -grille_hauteur)
\r
402 smh.setAssociation(sgh)
\r
404 # Associer les 3 sommets liés aux déconnections sur la grille
\r
405 # -----------------------------------------------------------
\r
407 periph_deco = [ [cote_c, par_2], [cote_a, par_1], [cote_b, par_1] ]
\r
409 for i in xrange(3):
\r
410 hxa = periph_hexas[i]
\r
411 ag, p = periph_deco[i]
\r
412 smb = hxa.getVertex(2)
\r
413 sgb = geompy.MakeVertexOnCurve(ag, p)
\r
414 smb.setAssociation(sgb)
\r
416 smh = hxa.getVertex(0)
\r
417 sgh = geompy.MakeTranslation(sgb, 0, 0, -grille_hauteur)
\r
418 smh.setAssociation(sgh)
\r
420 # Réparer les piquages
\r
421 # --------------------
\r
423 piquage_e_base = geompy.MakeVertex(interne_x, interne_y, interne_z)
\r
424 piquage_e_axe = geompy.MakeVectorDXDYDZ(interne_dx, interne_dy, interne_dz)
\r
425 piquage_e_cyl = geompy.MakeCylinder(piquage_e_base, piquage_e_axe, interne_rayon, enceinte_h4)
\r
427 piquage_1_axe = geompy.MakeVectorDXDYDZ(p1_int_dx, p1_int_dy, p1_int_dz)
\r
428 piquage_1_cyl = geompy.MakeCylinder(p1_int_c, piquage_1_axe, p1_int_rayon, cote_lgr)
\r
430 piquage_2_axe = geompy.MakeVectorDXDYDZ(p2_int_dx, p2_int_dy, p2_int_dz)
\r
431 piquage_2_cyl = geompy.MakeCylinder(p2_int_c, piquage_2_axe, p2_int_rayon, cote_lgr)
\r
433 piquage_1_inter = geompy.SubShapeAllSortedCentres(geompy.MakeSection(piquage_e_cyl, piquage_1_cyl), geompy.ShapeType["EDGE"])
\r
434 piquage_2_inter = geompy.SubShapeAllSortedCentres(geompy.MakeSection(piquage_e_cyl, piquage_2_cyl), geompy.ShapeType["EDGE"])
\r
436 piquage_1_fi = piquage_1_inter[0]
\r
438 piquage_2_fig = piquage_2_inter[0]
\r
439 piquage_2_fid = piquage_2_inter[1]
\r
441 # Associer les piquages
\r
442 # ---------------------
\r
444 piquages_devant = [
\r
445 [ piquage_1, piquage_1_int, 0.375, piquage_1_ext, 0.125 ],
\r
446 [ piquage_2, piquage_2_int, 0.125, piquage_2_ext, 0.875 ]
\r
449 for m_piq, a_int, p_int, a_ext, p_ext in piquages_devant:
\r
451 i1 = m_piq.getEdge(2)
\r
452 i2 = m_piq.getEdge(5)
\r
453 i3 = m_piq.getEdge(7)
\r
454 i4 = m_piq.getEdge(10)
\r
456 doc.associateClosedLine(i1.getVertex(1), i1, [ i2, i3, i4 ], a_int, p_int, True, [])
\r
458 e1 = m_piq.getEdge(0)
\r
459 e2 = m_piq.getEdge(1)
\r
460 e3 = m_piq.getEdge(9)
\r
461 e4 = m_piq.getEdge(11)
\r
463 doc.associateClosedLine(e1.getVertex(0), e1, [ e2, e3, e4 ], a_ext, p_ext, False, [])
\r
465 piquages_milieu = [
\r
466 [ piquage_1, piquage_1_eib, piquage_1_eih, 0.30, piquage_1_eeb, piquage_1_eeh, 0.30 ],
\r
467 [ piquage_2, piquage_2_eid, piquage_2_eig, 0.75, piquage_2_eed, piquage_2_eeg, 0.75 ]
\r
470 for m_piq, a_int1, a_int2, p_int, a_ext1, a_ext2, p_ext in piquages_milieu:
\r
472 i1 = m_piq.getEdge(22)
\r
473 i2 = m_piq.getEdge(25)
\r
474 i3 = m_piq.getEdge(27)
\r
475 i4 = m_piq.getEdge(30)
\r
477 doc.associateClosedLine(i1.getVertex(0), i1, [ i4, i3, i2 ], a_int1, p_int, False, [a_int2])
\r
479 e1 = m_piq.getEdge(20)
\r
480 e2 = m_piq.getEdge(21)
\r
481 e3 = m_piq.getEdge(29)
\r
482 e4 = m_piq.getEdge(31)
\r
484 doc.associateClosedLine(e1.getVertex(0), e1, [ e2, e3, e4 ], a_ext1, p_ext, False, [a_ext2])
\r
487 [ piquage_1, piquage_1_fi , [] , 0.125, piquage_1_feb, piquage_1_feh, 0.30 ],
\r
488 [ piquage_2, piquage_2_fid, [piquage_2_fig], 0.75 , piquage_2_fed, piquage_2_feg, 0.75 ]
\r
491 for m_piq, a_int1, a_int2, p_int, a_ext1, a_ext2, p_ext in piquages_fond:
\r
493 i1 = m_piq.getEdge(42)
\r
494 i2 = m_piq.getEdge(45)
\r
495 i3 = m_piq.getEdge(47)
\r
496 i4 = m_piq.getEdge(50)
\r
498 doc.associateClosedLine(i1.getVertex(0), i1, [ i4, i3, i2 ], a_int1, p_int, False, a_int2)
\r
500 e1 = m_piq.getEdge(40)
\r
501 e2 = m_piq.getEdge(41)
\r
502 e3 = m_piq.getEdge(49)
\r
503 e4 = m_piq.getEdge(51)
\r
505 doc.associateClosedLine(e1.getVertex(1), e1, [ e2, e3, e4 ], a_ext1, p_ext, False, [a_ext2])
\r
507 # Associer quelques faces
\r
508 # -----------------------
\r
510 for h in [ 2, 5, 7, 10, 21, 24, 26, 29 ]:
\r
511 enceinte_hc = enceinte.getHexa(h)
\r
513 enceinte_qc = enceinte_hc.getQuad(hexablock.Q_C)
\r
514 enceinte_qc.addAssociation(face_cylindrique_int)
\r
516 enceinte_qc = enceinte_hc.getQuad(hexablock.Q_D)
\r
517 enceinte_qc.addAssociation(face_cylindrique_ext)
\r
519 # Primer les 5 supports (finalisation du modèle de blocs)
\r
520 # -------------------------------------------------------
\r
522 supports_quads_b.append( centre_c.getQuad(hexablock.Q_E) )
\r
524 supports_z = doc.addVector(coin_x1 - coin_x3, coin_y1 - coin_y3, coin_z1 - coin_z3)
\r
526 supports = doc.prismQuads(supports_quads_b, supports_z, 1)
\r
528 # Mailler le modèle de blocs
\r
529 # ==========================
\r
531 # Définir les groupes volumiques
\r
532 # ------------------------------
\r
534 groupe_fd = doc.addHexaGroup("fond")
\r
535 groupe_en = doc.addHexaGroup("enceinte")
\r
536 groupe_p1 = doc.addHexaGroup("piquage:1")
\r
537 groupe_p2 = doc.addHexaGroup("piquage:2")
\r
538 groupe_su = doc.addHexaGroup("supports")
\r
540 for i in xrange( doc.countUsedHexa() ):
\r
541 h = doc.getUsedHexa(i)
\r
542 groupe_fd.addElement(h)
\r
544 for i in xrange( enceinte.countHexa() ):
\r
545 h = enceinte.getHexa(i)
\r
547 groupe_en.addElement(h)
\r
548 groupe_fd.removeElement(h)
\r
550 for i in xrange( piquage_1.countHexa() ):
\r
551 h = piquage_1.getHexa(i)
\r
552 groupe_p1.addElement(h)
\r
553 groupe_fd.removeElement(h)
\r
555 for i in xrange( piquage_2.countHexa() ):
\r
556 h = piquage_2.getHexa(i)
\r
557 groupe_p2.addElement(h)
\r
558 groupe_fd.removeElement(h)
\r
560 for i in xrange( supports.countHexa() ):
\r
561 h = supports.getHexa(i)
\r
562 groupe_su.addElement(h)
\r
563 groupe_fd.removeElement(h)
\r
565 # Générer le maillage
\r
566 # -------------------
\r
568 hexablock.addLaws(doc, 0.015, False)
\r
570 maillage = hexablock.mesh(doc)
\r
572 muv, mue, muq, muh = hexablock.dump(doc, maillage)
\r