src/TEST_PY/recettes/cuve.py

   1 # -*- coding: latin-1 -*-\r
   2 # Copyright (C) 2009-2013  CEA/DEN, EDF R&D
   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.
   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 \r
  21 # Francis KLOSS - 2011-2013 - CEA-Saclay, DEN, DM2S, SFME, LGLS, F-91191 Gif-sur-Yvette, France\r
  22 # =============================================================================================\r
  23 \r
  24 import math\r
  25 \r
  26 import geompy\r
  27 import hexablock\r
  28 \r
  29 # Charger la géométrie\r
  30 # ====================\r
  31 \r
  32 nom = "cuve"\r
  33 \r
  34 cuve = geompy.ImportBREP(nom+".brep")\r
  35 \r
  36 # Sélectionner des sommets de la géométrie\r
  37 # -----------------------------------------\r
  38 \r
  39 sommets = geompy.SubShapeAllSortedCentres(cuve, geompy.ShapeType["VERTEX"])\r
  40 \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
  45 \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
  50 \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
  55 \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
  60 \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
  65 \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
  70 \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
  73 \r
  74 # Sélectionner des arêtes de la géométrie\r
  75 # ---------------------------------------\r
  76 \r
  77 aretes = geompy.SubShapeAllSortedCentres(cuve, geompy.ShapeType["EDGE"])\r
  78 \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
  81 \r
  82 cote_a = aretes[41]\r
  83 cote_b = aretes[91]\r
  84 cote_c = aretes[59]\r
  85 cote_d = aretes[12]\r
  86 \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
  95 \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
 104 \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
 107 \r
 108 # Sélectionner des faces de la géométrie\r
 109 # --------------------------------------\r
 110 \r
 111 faces = geompy.SubShapeAllSortedCentres(cuve, geompy.ShapeType["FACE"])\r
 112 \r
 113 face_cylindrique_int = faces[21]\r
 114 face_cylindrique_ext = faces[22]\r
 115 \r
 116 # Construire le modèle de blocs\r
 117 # =============================\r
 118 \r
 119 # Créer le document\r
 120 # -----------------\r
 121 \r
 122 doc = hexablock.addDocument(nom)\r
 123 \r
 124 # Calculer l'angle défini par le centre de la cuve et 2 points (projeté dans le plan XY)\r
 125 # --------------------------------------------------------------------------------------\r
 126 \r
 127 centre_cuve = geompy.MakeVertex(externe_x, externe_y, 0)\r
 128 \r
 129 def calculer_angle(point1, point2):\r
 130   x1, y1, z1 = geompy.PointCoordinates(point1)\r
 131   x2, y2, z2 = geompy.PointCoordinates(point2)\r
 132 \r
 133   p1 = geompy.MakeVertex(x1, y1, 0)\r
 134   p2 = geompy.MakeVertex(x2, y2, 0)\r
 135 \r
 136   a1 = geompy.MakeEdge(centre_cuve, p1)\r
 137   a2 = geompy.MakeEdge(centre_cuve, p2)\r
 138 \r
 139   return geompy.GetAngle(a1, a2)\r
 140 \r
 141 # Construire les 8 points de la grille\r
 142 # ------------------------------------\r
 143 \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
 146 \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
 149 \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
 152 \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
 155 \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
 158 \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
 161 \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
 164 \r
 165 point_1 = coin_c\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
 169 point_5 = coin_a\r
 170 point_6 = coin_b\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
 173 \r
 174 # Construire la grille cylindrique\r
 175 # --------------------------------\r
 176 \r
 177 grille_hauteur = coin_z4-coin_z2\r
 178 \r
 179 centre = doc.addVertex(externe_x, externe_y, externe_z-grille_hauteur)\r
 180 \r
 181 grille_x = doc.addVector(1, 1, 0)\r
 182 grille_z = doc.addVector(0, 0, 1)\r
 183 \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
 186 \r
 187 rayons = [ petit_rayon, interne_rayon-petit_rayon, externe_rayon-interne_rayon, grand_rayon-externe_rayon ]\r
 188 \r
 189 points = [ point_1, point_2, point_3, point_4, point_5, point_6, point_7, point_8, point_1 ]\r
 190 \r
 191 angles = []\r
 192 for i in xrange(8):\r
 193   angle = calculer_angle(points[i], points[i+1])\r
 194   angles.append(angle)\r
 195 \r
 196 hauteurs = [ grille_hauteur ]\r
 197 \r
 198 grille = doc.makeCylindricals(centre, grille_x, grille_z, rayons, angles, hauteurs, False)\r
 199 \r
 200 # Ajouter le centre\r
 201 # -----------------\r
 202 \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
 206 \r
 207 centre_a = doc.addHexa3Quads(quad_0, quad_6, quad_7)\r
 208 \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
 212 \r
 213 centre_b = doc.addHexa3Quads(quad_2, quad_3, quad_4)\r
 214 \r
 215 quad_1 = grille.getQuadJK(0, 2, 0)\r
 216 quad_5 = grille.getQuadJK(0, 6, 0)\r
 217 \r
 218 quad_a = centre_a.getQuad(1)\r
 219 quad_b = centre_b.getQuad(1)\r
 220 \r
 221 centre_c = doc.addHexa4Quads(quad_1, quad_a, quad_5, quad_b)\r
 222 \r
 223 # Ajouter l'enceinte\r
 224 # ------------------\r
 225 \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
 229 \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
 234 \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
 238 \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
 243 \r
 244 enceinte_hauteurs = [ enceinte_h1, enceinte_h2, enceinte_h3, enceinte_h4 ]\r
 245 \r
 246 enceinte_pz = doc.addVector(oppo_x - base_x, oppo_y - base_y, enceinte_h4)\r
 247 \r
 248 enceinte = doc.prismQuadsVec(enceinte_quads, enceinte_pz, enceinte_hauteurs, 0)\r
 249 \r
 250 # Déconnecter via des arêtes, puis prismer, puis compléter (3) ou coller (1)\r
 251 # --------------------------------------------------------------------------\r
 252 \r
 253 periph_hexas     = []\r
 254 supports_quads_b = []\r
 255 supports_quads_h = []\r
 256 \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
 260 \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
 265 \r
 266   q1 = d.getQuad(0)\r
 267   q2 = grille.getQuadIK(2, j, 0)\r
 268   if j==1:\r
 269     h0 = doc.addHexa2Quads(q1, q2)\r
 270     q3 = grille.getQuadJK(3, j, 0)\r
 271     q4 = h0.getQuad(3)\r
 272     h1 = doc.addHexa2Quads(q3, q4)\r
 273     qb = h1.getQuad(hexablock.Q_E)\r
 274     qh = h1.getQuad(hexablock.Q_F)\r
 275   else:\r
 276     p = doc.prismQuad(q1, v, 2)\r
 277 \r
 278     h0 = p.getHexa(0)\r
 279     q3 = h0.getQuad(5)\r
 280     h1 = p.getHexa(1)\r
 281     q4 = h1.getQuad(5)\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
 286 \r
 287   supports_quads_b.append(qb)\r
 288   supports_quads_h.append(qh)\r
 289 \r
 290 # Piquer les 2 tuyaux sur l'enceinte\r
 291 # ----------------------------------\r
 292 \r
 293 piquage_centre = doc.addVertex(10, 0, 0)\r
 294 \r
 295 piquage_vx = doc.addVector(1, 0, 0)\r
 296 piquage_vz = doc.addVector(0, 0, 1)\r
 297 \r
 298 piquage = doc.makeCylindrical(piquage_centre, piquage_vx, piquage_vz,  1, 360, 1,  1, 4, 1,  False)\r
 299 \r
 300 piquage_quads = [ piquage.getQuadIJ(0, j, 0) for j in xrange(4) ]\r
 301 \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
 305 \r
 306 enceinte_ha = enceinte.getHexa( 6)\r
 307 enceinte_hb = enceinte.getHexa(25)\r
 308 \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
 312 \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
 316 \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
 319 \r
 320 # Nettoyer le template du piquage\r
 321 # -------------------------------\r
 322 \r
 323 doc.removeElements(piquage)\r
 324 \r
 325 # Associer le modèle de blocs avec la géométrie\r
 326 # =============================================\r
 327 \r
 328 doc.setShape(cuve)\r
 329 \r
 330 # Nettoyer les associations implicites du centre et de la périphérie\r
 331 # ------------------------------------------------------------------\r
 332 \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
 338 \r
 339 # Associer le centre de l'enceinte\r
 340 # --------------------------------\r
 341 \r
 342 for j, ig in [ [2, 30], [3, 28], [6, 32], [7, 34] ]:\r
 343   sm0 = grille.getVertexIJK(0, j, 0)\r
 344   sg0 = sommets[ig]\r
 345   sm0.setAssociation(sg0)\r
 346 \r
 347   sm1 = grille.getVertexIJK(0, j, 1)\r
 348   sg1 = geompy.MakeTranslation(sg0, 0, 0, grille_hauteur)\r
 349   sm1.setAssociation(sg1)\r
 350 \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
 355 \r
 356   sm1 = grille.getVertexIJK(0, j, 1)\r
 357   sg1 = geompy.MakeTranslation(sg0, 0, 0, grille_hauteur)\r
 358   sm1.setAssociation(sg1)\r
 359 \r
 360 # Associer les 16 sommets des 4 supports externes\r
 361 # -----------------------------------------------\r
 362 \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
 368 ]\r
 369 \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
 376     sgb = cs[i]\r
 377     smb.setAssociation(sgb)\r
 378 \r
 379     if s==1:\r
 380       ind = i\r
 381     else:\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
 386 \r
 387 # Associer les 7 sommets périphériques de la grille\r
 388 # -------------------------------------------------\r
 389 \r
 390 par_1 = 0.17\r
 391 par_2 = 1 - par_1\r
 392 \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
 394 \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
 399 \r
 400   smh = grille.getVertexIJK(3, j, 0)\r
 401   sgh = geompy.MakeTranslation(sgb, 0, 0, -grille_hauteur)\r
 402   smh.setAssociation(sgh)\r
 403 \r
 404 # Associer les 3 sommets liés aux déconnections sur la grille\r
 405 # -----------------------------------------------------------\r
 406 \r
 407 periph_deco = [ [cote_c, par_2], [cote_a, par_1], [cote_b, par_1] ]\r
 408 \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
 415 \r
 416   smh = hxa.getVertex(0)\r
 417   sgh = geompy.MakeTranslation(sgb, 0, 0, -grille_hauteur)\r
 418   smh.setAssociation(sgh)\r
 419 \r
 420 # Réparer les piquages\r
 421 # --------------------\r
 422 \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
 426 \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
 429 \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
 432 \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
 435 \r
 436 piquage_1_fi  = piquage_1_inter[0]\r
 437 \r
 438 piquage_2_fig = piquage_2_inter[0]\r
 439 piquage_2_fid = piquage_2_inter[1]\r
 440 \r
 441 # Associer les piquages\r
 442 # ---------------------\r
 443 \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
 447 ]\r
 448 \r
 449 for m_piq, a_int, p_int, a_ext, p_ext in piquages_devant:\r
 450 \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
 455 \r
 456   doc.associateClosedLine(i1.getVertex(1), i1, [ i2, i3, i4 ], a_int, p_int, True, [])\r
 457 \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
 462 \r
 463   doc.associateClosedLine(e1.getVertex(0), e1, [ e2, e3, e4 ], a_ext, p_ext, False, [])\r
 464 \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
 468 ]\r
 469 \r
 470 for m_piq, a_int1, a_int2, p_int, a_ext1, a_ext2, p_ext in piquages_milieu:\r
 471 \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
 476 \r
 477   doc.associateClosedLine(i1.getVertex(0), i1, [ i4, i3, i2 ], a_int1, p_int, False, [a_int2])\r
 478 \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
 483 \r
 484   doc.associateClosedLine(e1.getVertex(0), e1, [ e2, e3, e4 ], a_ext1, p_ext, False, [a_ext2])\r
 485 \r
 486 piquages_fond = [\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
 489 ]\r
 490 \r
 491 for m_piq, a_int1, a_int2, p_int, a_ext1, a_ext2, p_ext in piquages_fond:\r
 492 \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
 497 \r
 498   doc.associateClosedLine(i1.getVertex(0), i1, [ i4, i3, i2 ], a_int1, p_int, False, a_int2)\r
 499 \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
 504 \r
 505   doc.associateClosedLine(e1.getVertex(1), e1, [ e2, e3, e4 ], a_ext1, p_ext, False, [a_ext2])\r
 506 \r
 507 # Associer quelques faces\r
 508 # -----------------------\r
 509 \r
 510 for h in [ 2, 5, 7, 10,  21, 24, 26, 29 ]:\r
 511   enceinte_hc = enceinte.getHexa(h)\r
 512 \r
 513   enceinte_qc = enceinte_hc.getQuad(hexablock.Q_C)\r
 514   enceinte_qc.addAssociation(face_cylindrique_int)\r
 515 \r
 516   enceinte_qc = enceinte_hc.getQuad(hexablock.Q_D)\r
 517   enceinte_qc.addAssociation(face_cylindrique_ext)\r
 518 \r
 519 # Primer les 5 supports (finalisation du modèle de blocs)\r
 520 # -------------------------------------------------------\r
 521 \r
 522 supports_quads_b.append( centre_c.getQuad(hexablock.Q_E) )\r
 523 \r
 524 supports_z = doc.addVector(coin_x1 - coin_x3, coin_y1 - coin_y3, coin_z1 - coin_z3)\r
 525 \r
 526 supports = doc.prismQuads(supports_quads_b, supports_z, 1)\r
 527 \r
 528 # Mailler le modèle de blocs\r
 529 # ==========================\r
 530 \r
 531 # Définir les groupes volumiques\r
 532 # ------------------------------\r
 533 \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
 539 \r
 540 for i in xrange( doc.countUsedHexa() ):\r
 541   h = doc.getUsedHexa(i)\r
 542   groupe_fd.addElement(h)\r
 543 \r
 544 for i in xrange( enceinte.countHexa() ):\r
 545   h = enceinte.getHexa(i)\r
 546   if h != None:\r
 547     groupe_en.addElement(h)\r
 548     groupe_fd.removeElement(h)\r
 549 \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
 554 \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
 559 \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
 564 \r
 565 # Générer le maillage\r
 566 # -------------------\r
 567 \r
 568 hexablock.addLaws(doc, 0.015, False)\r
 569 \r
 570 maillage = hexablock.mesh(doc)\r
 571 \r
 572 muv, mue, muq, muh = hexablock.dump(doc, maillage)\r
 573 \r