src/TEST_PY/recettes/cuve.py

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