doc/pyplots/bielle.py

   1 # -*- coding: latin-1 -*-
   2 # Copyright (C) 2009-2023  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 import os
  22 import GEOM
  23 import geompy
  24 import smesh
  25 import hexablock
  26 import math
  27 import SALOMEDS
  28
  29
  30 STEP_PATH = os.path.expandvars("$HEXABLOCK_ROOT_DIR/bin/salome/crank.stp")
  31
  32
  33 #=============================
  34 # CREATION DOCUMENT
  35 #=============================
  36
  37 doc = hexablock.addDocument("Bielle:hexas")
  38
  39 #=============================
  40 # MODEL CREATION
  41 #=============================
  42
  43 # For the connecting rod, two cylindrical grids have to be build and
  44 # the quadrangles have to be prismed between these wo grids
  45
  46 #=============================
  47 # PARAMETRES
  48 #=============================
  49
  50 #R = 40.0
  51 R = 0.095168291790720005
  52
  53 r_pte = R
  54 r_pte_t = R/2.0
  55
  56 xpetit = 0.0
  57 xgrand = 1.35739 + 0.1595
  58 longueur = (xgrand - xpetit)/2.0
  59 hauteur = 0.019999999553*2
  60
  61 dr_pte = R
  62 da_pte = 360
  63 dl_pte = hauteur
  64
  65 nr_pte = 1
  66 na_pte = 6
  67 nl_pte = 1
  68
  69
  70 #=============================
  71 # Vectors Creation
  72 #=============================
  73
  74 dx = doc.addVector(longueur, 0, 0)
  75 dy = doc.addVector(0, longueur, 0)
  76 dz = doc.addVector(0, 0, longueur)
  77
  78 #=================================================
  79 # Creation of cylindrical grid centers
  80 #=================================================
  81
  82 c_pte = doc.addVertex(xpetit, 0, 0)
  83 c_grd = doc.addVertex(2*longueur, 0, 0)
  84 dx_prime = doc.addVectorVertices(c_pte, c_grd)
  85
  86 #=================================================
  87 # small cylindrical grid creation
  88 #=================================================
  89
  90 grille_cyl_pte = doc.makeCylindrical(c_pte, dx, dz, dr_pte, da_pte, dl_pte, nr_pte, na_pte, nl_pte, False)
  91
  92 # We obtain a liste containing 6 equal hexaedra
  93 # 30 = pi/6
  94 # 60 = pi/3
  95 # 45 = pi/4
  96 # 90 = pi/2
  97 # 180 = pi
  98
  99 alpha_x = 2*R*math.cos(math.pi/3)
 100 alpha_y = 2*R*math.sin(math.pi/3)
 101
 102 x1 = doc.findVertex(2*R, 0, hauteur)
 103 x2 = doc.findVertex(alpha_x, alpha_y, 0)
 104 x3 = doc.findVertex(alpha_x, -alpha_y, 0)
 105 x4 = doc.findVertex(2*R, 0, 0)
 106
 107 quad_11 = doc.findQuad(x1, x2)
 108 quad_12 = doc.findQuad(x1, x3)
 109
 110 #=================================
 111 #  Small cylindrical grid creation
 112 #=================================
 113
 114 grille_cyl_grd = doc.makeTranslation(grille_cyl_pte, dx_prime)
 115
 116 # We obtain a liste containing 6 equal hexaedra
 117 y1 = doc.findVertex(2*longueur - 2*R, 0 , hauteur)
 118 y2 = doc.findVertex(2*longueur - alpha_x, alpha_y, 0)
 119 y3 = doc.findVertex(2*longueur - alpha_x, -alpha_y, 0)
 120 y4 = doc.findVertex(2*longueur - 2*R, 0, 0)
 121
 122 quad_21 = doc.findQuad(y1, y2)
 123 quad_22 = doc.findQuad(y1, y3)
 124
 125 #==================================
 126 # Joining the two cylindrical grids
 127 #==================================
 128 model_biell_fin = doc.joinQuads([quad_11, quad_12], quad_21, x1, y1, x4, y4, 1)
 129
 130 #=======================================================
 131 # Recover vertices of the hexa model for the association
 132 #=======================================================
 133
 134 # NB:
 135 # h = top (haut)
 136 # b = bottom (bas)
 137 # g = big (grand)
 138 # p = small (petit)
 139 # t = hole (trou)
 140
 141 bielle_geom = geompy.ImportFile(STEP_PATH, "STEP")
 142
 143 geompy.addToStudy(bielle_geom, "bielle_geom")
 144
 145 pt_a = geompy.MakeVertex(0, 0, hauteur/2.)
 146 face_haut = geompy.GetFaceNearPoint(bielle_geom, pt_a)
 147
 148 pt_b = geompy.MakeVertex(0, 0, -hauteur/2.)
 149 face_bas = geompy.GetFaceNearPoint(bielle_geom, pt_b)
 150
 151 edge_haut_droite = geompy.GetEdgesByLength(face_haut, 0.136, 0.137)
 152 edge_haut_gauche = geompy.GetEdgesByLength(face_haut, 0.131, 0.132)
 153
 154 # Param�tres pour :
 155 # - r�cup�ration des points.
 156 # - et associations.
 157
 158 u_1 = 1.0
 159 u_3 = 0.0
 160
 161 # dictionnaire des vertices de la g�om�trie (grande et petite grilles) :
 162 # key = nom, value = indice dans geom_vert_grd (resp. geom_vert_pte)
 163 # on commence par les vertex externes du haut du grand (resp. petit) cylindre,
 164 # ensuite :
 165 # 1. vertex internes (trou),
 166 # 2. puis vertex du bas (externes puis internes)
 167 dic_vert_names = {}
 168 ind = 0
 169 for z in ['h', 'b']:  # haut/bas
 170     for x in ['e', 't']:  # externe/interne(trou)
 171         for y in ['y', 'x', 'u', 'v', 'w', 'z']:  #
 172             key = '_'.join([y, z, x])
 173             dic_vert_names[key] = ind
 174             ind += 1
 175             pass
 176         pass
 177     pass
 178
 179
 180 # 1. grand cylindre :
 181 geom_vert_grd = []  # liste des vertex du grand cylindre
 182
 183 # 1.1 face du haut :
 184 # 1.1.1 sommets externes :
 185 # la cr�ation des vertex de la geometrie se fait obligatoirement
 186 # dans cet ordre :
 187 geom_vert_grd.append(geompy.MakeVertexOnSurface(face_haut, 1, 0.5))  # y_h_e_g
 188 edge_haut_grd = geompy.GetEdgeNearPoint(bielle_geom, geom_vert_grd[0])
 189 geom_vert_grd.append(geompy.MakeVertexOnCurve(edge_haut_grd, u_3))  # x_h_e_g
 190 geom_vert_grd.append(geompy.MakeVertexOnCurve(edge_haut_grd, u_1))  # z_h_e_g
 191 geom_vert_grd.insert(2, geompy.MakeVertexOnCurve(edge_haut_droite, 1))  # u_h_e_g
 192 geom_vert_grd.insert(3, geompy.MakeVertexOnCurve(edge_haut_gauche, 0))  # w_h_e_g
 193 edge_v_grd = geompy.MakeLineTwoPnt(geom_vert_grd[2], geom_vert_grd[3])
 194 geom_vert_grd.insert(3, geompy.MakeVertexOnCurve(edge_v_grd, 0.5))  # v_h_e_g
 195 # les vertex sont rang�s dans cet ordre :
 196 # y_h_e_g, x_h_e_g, u_h_e_g, v_h_e_g, w_h_e_g, z_h_e_g
 197
 198 # 1.1.2 sommets internes (trou) :
 199 edge_haut_grd_trou = geompy.GetEdgesByLength(face_haut, 0.147, 0.148)
 200 # y_h_t_g, x_h_t_g, u_h_t_g, v_h_t_g, w_h_t_g, z_h_t_g
 201 for val in [0, 0.8, 0.6, 0.5, 0.4, 0.2]:
 202     geom_vert_grd.append(geompy.MakeVertexOnCurve(edge_haut_grd_trou, val))
 203
 204 # 1.2 face du bas :
 205 # pour tous les vertex de la face du bas, on les cr�e par r�f�rence � ceux d�j� cr�es (dans le meme ordre :
 206 # sommets externes puis internes) :
 207 geom_vert_grd_bas = [geompy.MakeVertexWithRef(vertex, 0.0, 0.0, -hauteur) for vertex in geom_vert_grd]
 208 geom_vert_grd.extend(geom_vert_grd_bas)
 209
 210 # pour l'utilisation :
 211 # geom_vert_grd[dic_vert_names["y_h_t"]] # par exemple
 212
 213 # 2. petit cylindre :
 214 # REM : le modele grand cylindre a ete cree par translation / au petit
 215 # cylindre. Les vertices de la geometrie sont donc ete cr�es de mani�re
 216 # similaire
 217 geom_vert_pte = []
 218
 219 # 2.1 face du haut :
 220 # 2.1.1 sommets externes :
 221
 222 # la cr�ation des vertex de la geometrie se fait obligatoirement
 223 # dans cet ordre :
 224 geom_vert_pte.append(geompy.MakeVertexOnSurface(face_haut, 0, 0.5))  # v_h_e_p
 225 edge_haut_pte = geompy.GetEdgeNearPoint(bielle_geom, geom_vert_pte[0])
 226 geom_vert_pte.append(geompy.MakeVertexOnCurve(edge_haut_pte, u_3))  # w_h_e_p
 227 geom_vert_pte.insert(0, geompy.MakeVertexOnCurve(edge_haut_pte, u_1))  # u_h_e_p
 228 geom_vert_pte.insert(0, geompy.MakeVertexOnCurve(edge_haut_droite, 0))  # x_h_e_p
 229 geom_vert_pte.append(geompy.MakeVertexOnCurve(edge_haut_gauche, 1))  # z_h_e_p
 230 edge_v_pte = geompy.MakeLineTwoPnt(geom_vert_pte[0], geom_vert_pte[4])
 231 geom_vert_pte.insert(0, geompy.MakeVertexOnCurve(edge_v_pte, 0.5))  # y_h_e_p
 232 # les vertex sont rang�s dans cet ordre :
 233 # y_h_e_p, x_h_e_p, u_h_e_p, v_h_e_p, w_h_e_p, z_h_e_p
 234
 235
 236 # 2.1.2 sommets internes (trou) :
 237 edge_haut_pte_trou = geompy.GetEdgesByLength(face_haut, 0.094, 0.095)
 238 # y_h_t_p, x_h_t_p, u_h_t_p, v_h_t_p, w_h_t_p, z_h_t_p
 239 for val in [0, 0.9, 0.65, 0.5, 0.35, 0.1]:
 240     geom_vert_pte.append(geompy.MakeVertexOnCurve(edge_haut_pte_trou, val))
 241
 242 # 2.2 face du bas :
 243 # pour tous les vertex de la face du bas, on les cr�e par r�f�rence � ceux d�j� cr�es (dans le meme ordre :
 244 # sommets externes puis internes) :
 245 geom_vert_pte_bas = [geompy.MakeVertexWithRef(vertex, 0.0, 0.0, -hauteur) for vertex in geom_vert_pte]
 246 geom_vert_pte.extend(geom_vert_pte_bas)
 247
 248
 249 #=======================
 250 # CREATION ASSOCIATION
 251 #=======================
 252
 253 # pour l'association, il suffit de faire 6 appels � la m�thode
 254 # associateClosedLine() :
 255 # 1 pour la ligne du trou haut du grand cylindre
 256 # 1 pour la ligne du trou bas du grand cylindre
 257 # 1 pour la ligne du trou haut du petit cylindre
 258 # 1 pour la ligne du trou bas du petit cylindre
 259 # 1 pour la ligne "externe" de la bielle, en haut
 260 # 1 pour la ligne "externe" de la bielle, en bas
 261
 262 all_edges_bielle = geompy.SubShapeAllSorted(bielle_geom, geompy.ShapeType["EDGE"])
 263
 264 # dictionnaire des edges de la g�om�trie :
 265 # key = nom, value = indice dans all_edges_bielle
 266 dic_edge_names = {"edge_ray_pte_b": 0, "edge_ray_pte_h": 1,
 267                   "edge_trou_pte_b": 2, "edge_trou_pte_h" :3,
 268                   "edge_arr_pte_g_b": 7, "edge_arr_pte_g_h": 8,
 269                   "edge_arr_pte_d_b": 9, "edge_arr_pte_d_h": 10,
 270                   "edge_arr_grd_g_b": 19, "edge_arr_grd_g_h": 20,
 271                   "edge_arr_grd_d_b": 21, "edge_arr_grd_d_h": 22,
 272                   "edge_trou_grd_b": 25, "edge_trou_grd_h": 26,
 273                   "edge_ray_grd_b": 27, "edge_ray_grd_h": 28,
 274                   "edge_long_g_b": 13, "edge_long_g_h": 14,
 275                   "edge_long_d_b": 15, "edge_long_d_h": 16
 276                   }
 277
 278 # 1. ligne du trou haut du petit cylindre
 279 # =======================================
 280
 281 # modele de blocs :
 282 mod_start = grille_cyl_pte.getEdgeJ(0, 0, 1)
 283 mod_first = mod_start.getVertex(1)
 284 # table des edges :
 285 mod_line = [grille_cyl_pte.getEdgeJ(0, j, 1) for j in range(1, 6)]
 286
 287 # geometrie :
 288 e_t_p_h = all_edges_bielle[dic_edge_names["edge_trou_pte_h"]]
 289 li_vert = geom_vert_pte[dic_vert_names['x_h_t']:dic_vert_names['z_h_t']+1]
 290 li_vert.reverse()  # z_h_t_p, w_h_t_p, v_h_t_p, u_h_t_p, x_h_t_p
 291 part_trou_pte_haut = geompy.MakePartition([e_t_p_h],
 292                                           li_vert,
 293                                           [], [], geompy.ShapeType["EDGE"], 0, [], 0)
 294 all_edge_part_trou_pte_haut = geompy.SubShapeAllSorted(part_trou_pte_haut, geompy.ShapeType["EDGE"])
 295
 296 geo_start = all_edge_part_trou_pte_haut[5]  # [y_h_t_p; x_h_t_p]
 297 par_start = 0.0
 298 geo_line  = [all_edge_part_trou_pte_haut[i] for i in [3, 1, 0, 2, 4]]
 299
 300 # association :
 301 ier = doc.associateClosedLine(mod_first, mod_start, mod_line,
 302                               geo_start, par_start, geo_line)
 303
 304 # 2. ligne du trou bas du petit cylindre
 305 # =======================================
 306
 307 # modele de blocs :
 308 mod_start = grille_cyl_pte.getEdgeJ(0, 0, 0)
 309 mod_first = mod_start.getVertex(1)
 310 del(mod_line[:])
 311 # table des edges :
 312 mod_line = [grille_cyl_pte.getEdgeJ(0, j, 0) for j in range(1, 6)]
 313
 314 # geometrie :
 315 e_t_p_b = all_edges_bielle[dic_edge_names["edge_trou_pte_b"]]
 316 del(li_vert[:])
 317 li_vert = geom_vert_pte[dic_vert_names['x_b_t']:dic_vert_names['z_b_t']+1]
 318 li_vert.reverse()  # z_b_t_p, w_b_t_p, v_b_t_p, u_b_t_p, x_b_t_p
 319 part_trou_pte_bas = geompy.MakePartition([e_t_p_b],
 320                                          li_vert,
 321                                          [], [], geompy.ShapeType["EDGE"], 0, [], 0)
 322 all_edge_part_trou_pte_bas = geompy.SubShapeAllSorted(part_trou_pte_bas, geompy.ShapeType["EDGE"])
 323
 324 geo_start = all_edge_part_trou_pte_bas[5]
 325 par_start = 0.0
 326 del(geo_line[:])
 327 geo_line = [all_edge_part_trou_pte_bas[i] for i in [3, 1, 0, 2, 4]]
 328
 329 # association :
 330 ier = doc.associateClosedLine(mod_first, mod_start, mod_line,
 331                               geo_start, par_start, geo_line)
 332
 333 # 3. ligne du trou haut du grand cylindre
 334 # =======================================
 335
 336 # modele de blocs :
 337 mod_start = grille_cyl_grd.getEdgeJ(0, 0, 1)  # 1er edge
 338 mod_first = mod_start.getVertex(1)  # 1er vertex
 339 # table des edges :
 340 del(mod_line[:])
 341 mod_line = [grille_cyl_grd.getEdgeJ(0, j, 1) for j in range(1, 6)]
 342
 343 # geometrie :
 344 e_t_g_h = all_edges_bielle[dic_edge_names["edge_trou_grd_h"]]
 345 del(li_vert[:])
 346 li_vert = geom_vert_grd[dic_vert_names['x_h_t']:dic_vert_names['z_h_t']+1]
 347 li_vert.reverse()  # z_h_t_g, w_h_t_g, v_h_t_g, u_h_t_g, x_h_t_g
 348 part_trou_grd_haut = geompy.MakePartition([e_t_g_h],
 349                                           li_vert,
 350                                           [], [], geompy.ShapeType["EDGE"], 0, [], 0)
 351 all_edge_part_trou_grd_haut = geompy.SubShapeAllSorted(part_trou_grd_haut, geompy.ShapeType["EDGE"])
 352
 353 geo_start = all_edge_part_trou_grd_haut[5]  # [y_h_t_g; x_h_t_g]
 354 par_start = 0.0  # param 1ere ligne
 355 del(geo_line[:])
 356 geo_line = [all_edge_part_trou_grd_haut[i] for i in [3, 1, 0, 2, 4]]
 357
 358 # association :
 359 ier = doc.associateClosedLine(mod_first, mod_start, mod_line,
 360                               geo_start, par_start, geo_line)
 361
 362 # 4. ligne du trou bas du grand cylindre
 363 # =======================================
 364
 365 # modele de blocs :
 366 mod_start = grille_cyl_grd.getEdgeJ(0, 0, 0)
 367 mod_first = mod_start.getVertex(1)
 368 del(mod_line[:])
 369 # table des edges :
 370 mod_line = [grille_cyl_grd.getEdgeJ(0, j, 0) for j in range(1, 6)]
 371
 372 # geometrie :
 373 e_t_g_b = all_edges_bielle[dic_edge_names["edge_trou_grd_b"]]
 374 del(li_vert[:])
 375 li_vert = geom_vert_grd[dic_vert_names['x_b_t']:dic_vert_names['z_b_t']+1]
 376 li_vert.reverse()  # z_b_t_g, w_b_t_g, v_b_t_g, u_b_t_g, x_b_t_g
 377 part_trou_grd_bas = geompy.MakePartition([e_t_g_b],
 378                                          li_vert,
 379                                          [], [], geompy.ShapeType["EDGE"], 0, [], 0)
 380 all_edge_part_trou_grd_bas = geompy.SubShapeAllSorted(part_trou_grd_bas, geompy.ShapeType["EDGE"])
 381
 382 geo_start = all_edge_part_trou_grd_bas[5]
 383 par_start = 0.0  # entre 0 et 1 (abscisse curviligne)
 384 del(geo_line[:])
 385 geo_line = [all_edge_part_trou_grd_bas[i] for i in [3, 1, 0, 2, 4]]
 386
 387 # association :
 388 ier = doc.associateClosedLine(mod_first, mod_start, mod_line,
 389                               geo_start, par_start, geo_line)
 390
 391 # 5    : Les lignes "externes" de la bielle
 392 # 5. ligne "externe" de la bielle, en haut
 393 # ========================================
 394
 395 mod_start = grille_cyl_grd.getEdgeJ(1, 1, 1)
 396 mod_first = mod_start.getVertex(1)
 397 del(mod_line[:])
 398 mod_line = [grille_cyl_grd.getEdgeJ(1, j, 1) for j in [4, 5, 0]]
 399 mod_line.extend([grille_cyl_pte.getEdgeJ(1, j, 1) for j in [1, 2, 3, 4]])
 400 v1 = grille_cyl_grd.getVertexIJK(1, 2, 1)
 401 v2 = grille_cyl_pte.getVertexIJK(1, 1, 1)
 402 mod_line.append(doc.findEdge(v1, v2))
 403 v1 = grille_cyl_grd.getVertexIJK(1, 4, 1)
 404 v2 = grille_cyl_pte.getVertexIJK(1, 5, 1)
 405 mod_line.append(doc.findEdge(v1, v2))
 406
 407 # geometrie :
 408 # les edges de la geometrie a prendre en compte sont :
 409 # (en partant du grand cylindre)
 410 # edge_arr_grd_d_h, edge_ray_grd_h, edge_arr_grd_g_h, edge_long_g_h,
 411 # edge_arr_pte_g_h, edge_ray_pte_h, edge_arr_pte_d_h, edge_long_d_h
 412
 413 geo_start = all_edges_bielle[dic_edge_names["edge_arr_grd_d_h"]]
 414 par_start = 0.0
 415
 416 e_r_g_h = all_edges_bielle[dic_edge_names["edge_ray_grd_h"]]
 417 # x_h_e_g, y_h_e_g, z_h_e_g :
 418 del(li_vert[:])
 419 li_vert.append(geom_vert_grd[dic_vert_names['x_h_e']])
 420 li_vert.append(geom_vert_grd[dic_vert_names['y_h_e']])
 421 li_vert.append(geom_vert_grd[dic_vert_names['z_h_e']])
 422 part_ray_grd_haut = geompy.MakePartition([e_r_g_h],
 423                                          li_vert,
 424                                          [], [], geompy.ShapeType["EDGE"], 0, [], 0)
 425 all_edge_part_ray_grd_haut = geompy.SubShapeAllSorted(part_ray_grd_haut, geompy.ShapeType["EDGE"])
 426
 427 del(geo_line[:])
 428 all_edge_part_ray_grd_haut.reverse()
 429 geo_line = all_edge_part_ray_grd_haut[:]
 430 geo_line.append(all_edges_bielle[dic_edge_names["edge_arr_grd_g_h"]])
 431 geo_line.append(all_edges_bielle[dic_edge_names["edge_long_g_h"]])
 432 geo_line.append(all_edges_bielle[dic_edge_names["edge_arr_pte_g_h"]])
 433
 434 e_r_p_h = all_edges_bielle[dic_edge_names["edge_ray_pte_h"]]
 435 # w_h_e_p, v_h_e_p, u_h_e_p :
 436 del(li_vert[:])
 437 li_vert.append(geom_vert_pte[dic_vert_names['w_h_e']])
 438 # JPL (le 09/05/2011) :
 439 # normalement, on devrait pouvoir utiliser ici le vertex v_h_e_p pour
 440 # faire la partition de l'edge, mais ca ne fonctionne pas...
 441 # on cree donc un vertex supplementaire :
 442 ## li_vert.append(geom_vert_pte[dic_vert_names['v_h_e']])
 443 v_h_e_p_bis = geompy.MakeVertexOnCurve(e_r_p_h, 0.5)
 444 li_vert.append(v_h_e_p_bis)
 445 li_vert.append(geom_vert_pte[dic_vert_names['u_h_e']])
 446 part_ray_pte_haut = geompy.MakePartition([e_r_p_h],
 447                                          li_vert,
 448                                          [], [], geompy.ShapeType["EDGE"], 0, [], 0)
 449 all_edge_part_ray_pte_haut = geompy.SubShapeAllSorted(part_ray_pte_haut, geompy.ShapeType["EDGE"])
 450
 451 all_edge_part_ray_pte_haut.reverse()
 452 geo_line.extend(all_edge_part_ray_pte_haut[:])
 453 geo_line.append(all_edges_bielle[dic_edge_names["edge_arr_pte_d_h"]])
 454 geo_line.append(all_edges_bielle[dic_edge_names["edge_long_d_h"]])
 455
 456 # association :
 457 ier = doc.associateClosedLine(mod_first, mod_start, mod_line,
 458                               geo_start, par_start, geo_line)
 459
 460 # 6. ligne "externe" de la bielle, en bas
 461 # ========================================
 462
 463 mod_start = grille_cyl_grd.getEdgeJ(1, 1, 0)
 464 mod_first = mod_start.getVertex(1)
 465 del(mod_line[:])
 466 mod_line = [grille_cyl_grd.getEdgeJ(1, j, 0) for j in [4, 5, 0]]
 467 mod_line.extend([grille_cyl_pte.getEdgeJ(1, j, 0) for j in [1, 2, 3, 4]])
 468 v1 = grille_cyl_grd.getVertexIJK(1, 2, 0)
 469 v2 = grille_cyl_pte.getVertexIJK(1, 1, 0)
 470 mod_line.append(doc.findEdge(v1, v2))
 471 v1 = grille_cyl_grd.getVertexIJK(1, 4, 0)
 472 v2 = grille_cyl_pte.getVertexIJK(1, 5, 0)
 473 mod_line.append(doc.findEdge(v1, v2))
 474
 475 # geometrie :
 476 # les edges de la geometrie a prendre en compte sont :
 477 # (en partant du grand cylindre)
 478 # edge_arr_grd_d_h, edge_ray_grd_h, edge_arr_grd_g_h, edge_long_g_h,
 479 # edge_arr_pte_g_h, edge_ray_pte_h, edge_arr_pte_d_h, edge_long_d_h
 480
 481 geo_start = all_edges_bielle[dic_edge_names["edge_arr_grd_d_b"]]
 482 par_start = 0.0
 483
 484 e_r_g_b = all_edges_bielle[dic_edge_names["edge_ray_grd_b"]]
 485 # x_b_e_g, y_b_e_g, z_b_e_g :
 486 del(li_vert[:])
 487 li_vert.append(geom_vert_grd[dic_vert_names['x_b_e']])
 488 li_vert.append(geom_vert_grd[dic_vert_names['y_b_e']])
 489 li_vert.append(geom_vert_grd[dic_vert_names['z_b_e']])
 490 part_ray_grd_bas = geompy.MakePartition([e_r_g_b],
 491                                          li_vert,
 492                                          [], [], geompy.ShapeType["EDGE"], 0, [], 0)
 493 all_edge_part_ray_grd_bas = geompy.SubShapeAllSorted(part_ray_grd_bas, geompy.ShapeType["EDGE"])
 494
 495 del(geo_line[:])
 496 all_edge_part_ray_grd_bas.reverse()
 497 geo_line = all_edge_part_ray_grd_bas[:]
 498 geo_line.append(all_edges_bielle[dic_edge_names["edge_arr_grd_g_b"]])
 499 geo_line.append(all_edges_bielle[dic_edge_names["edge_long_g_b"]])
 500 geo_line.append(all_edges_bielle[dic_edge_names["edge_arr_pte_g_b"]])
 501
 502 e_r_p_b = all_edges_bielle[dic_edge_names["edge_ray_pte_b"]]
 503 # w_h_e_p, v_h_e_p, u_h_e_p :
 504 del(li_vert[:])
 505 li_vert.append(geom_vert_pte[dic_vert_names['w_b_e']])
 506 # JPL (le 09/05/2011) :
 507 # normalement, on devrait pouvoir utiliser ici le vertex v_h_e_p pour
 508 # faire la partition de l'edge, mais ca ne fonctionne pas...
 509 # on cree donc un vertex supplementaire :
 510 ## li_vert.append(geom_vert_pte[dic_vert_names['v_b_e']])
 511 v_b_e_p_bis = geompy.MakeVertexOnCurve(e_r_p_b, 0.5)
 512 li_vert.append(v_b_e_p_bis)
 513 li_vert.append(geom_vert_pte[dic_vert_names['u_b_e']])
 514 part_ray_pte_bas = geompy.MakePartition([e_r_p_b],
 515                                          li_vert,
 516                                          [], [], geompy.ShapeType["EDGE"], 0, [], 0)
 517 all_edge_part_ray_pte_bas = geompy.SubShapeAllSorted(part_ray_pte_bas, geompy.ShapeType["EDGE"])
 518
 519 all_edge_part_ray_pte_bas.reverse()
 520 geo_line.extend(all_edge_part_ray_pte_bas[:])
 521 geo_line.append(all_edges_bielle[dic_edge_names["edge_arr_pte_d_b"]])
 522 geo_line.append(all_edges_bielle[dic_edge_names["edge_long_d_b"]])
 523
 524 # association :
 525 ier = doc.associateClosedLine(mod_first, mod_start, mod_line,
 526                               geo_start, par_start, geo_line)
 527
 528 for nz in range (2):
 529     v1 = grille_cyl_grd.getVertexIJK(1, 3, nz)
 530     v2 = grille_cyl_grd.getVertexIJK(0, 3, nz)
 531     v3 = grille_cyl_grd.getVertexIJK(0, 0, nz)
 532     v4 = grille_cyl_grd.getVertexIJK(1, 0, nz)
 533
 534     v1.setX(v2.getX() + v3.getX() - v4.getX())
 535     v1.setY(v4.getY())
 536     v1.setZ(v4.getZ())
 537     v1.setScalar(7)
 538
 539 ##     print "Coord en x (grd) : ", v1.getX(), v2.getX(), v3.getX(), v4.getX()
 540 ##     print "Coord en y (grd) : ", v1.getY(), v2.getY(), v3.getY(), v4.getY()
 541 ##     print "Coord en z (grd) : ", v1.getZ(), v2.getZ(), v3.getZ(), v4.getZ()
 542 ##     print
 543
 544     v1 = grille_cyl_pte.getVertexIJK(1, 3, nz)
 545     v2 = grille_cyl_pte.getVertexIJK(0, 3, nz)
 546     v3 = grille_cyl_pte.getVertexIJK(0, 0, nz)
 547     v4 = grille_cyl_pte.getVertexIJK(1, 0, nz)
 548
 549     v4.setX(v3.getX() + v2.getX() - v1.getX())
 550     v4.setY(v1.getY())
 551     v4.setZ(v1.getZ())
 552
 553 ##     print "Coord en x (pte) : ", v1.getX(), v2.getX(), v3.getX(), v4.getX()
 554 ##     print "Coord en y (pte) : ", v1.getY(), v2.getY(), v3.getY(), v4.getY()
 555 ##     print "Coord en z (pte) : ", v1.getZ(), v2.getZ(), v3.getZ(), v4.getZ()
 556 ##     print
 557
 558 # TEST :
 559 file_name = os.path.join(os.environ['TMP'], 'bielle2.vtk')
 560 doc.saveVtk(file_name)
 561
 562 ## #=================================================
 563 ## # VERTEX, EDGES, FACES DANS L'ARBRE D'ETUDE SALOME
 564 ## #=================================================
 565
 566 # vertices :
 567 for key, value in list(dic_vert_names.items()):
 568     geompy.addToStudy(geom_vert_grd[value], key + '_g')
 569     geompy.addToStudy(geom_vert_pte[value], key + '_p')
 570
 571 # edges :
 572 for key, value in list(dic_edge_names.items()):
 573     geompy.addToStudy(all_edges_bielle[value], key)
 574
 575 #====================================
 576 # CREATION MAILLAGE
 577 #====================================
 578
 579
 580 #=================================================
 581 # Definir les groupes d elements pour le maillage
 582 #=================================================
 583
 584 # On definit 3 groupes de mailles
 585
 586 # JPL (le 09/05/2011) :
 587 # @todo a revoir : apres correction des bugs "countXXX()" dans le moteur
 588
 589 # groupe d edges (arretes)
 590 edge_grp = doc.addEdgeGroup("Edge_grp")
 591 for i in range(doc.countEdge()):
 592     edge_grp.addElement(doc.getEdge(i))
 593
 594 # groupe de quads (faces)
 595 quad_grp = doc.addQuadGroup("Quad_grp")
 596 for i in range(doc.countQuad()):
 597     quad_grp.addElement(doc.getQuad(i))
 598
 599 # groupe d hexas (solids)
 600 hexa_grp = doc.addHexaGroup("Hexa_grp")
 601 for i in range(doc.countHexa()):
 602     hexa_grp.addElement(doc.getHexa(i))
 603
 604 # groupe de noeuds de vertex pour tout le modele
 605 vertex_nod_grp = doc.addVertexNodeGroup("Vertex_Nod_Grp")
 606 for i in range(doc.countVertex()):
 607     vertex_nod_grp.addElement(doc.getVertex(i))
 608
 609 #====================================
 610 # Definir une loi de discretisation
 611 #====================================
 612 # definir une loi: le choix de la loi reste aux utilisateurs
 613 law = doc.addLaw("Uniform", 4)
 614
 615 # chercher les propagations du modele
 616 for j in range(doc.countPropagation()):
 617     propa = doc.getPropagation(j)
 618     propa.setLaw(law)  # appliquer la loi de discretisation sur tout le modele et generer le maillage
 619
 620 #====================================
 621 # G�n�rer des maillages
 622 #====================================
 623
 624 print(" --- MAILLAGE HEXAHEDRIQUE --- ")
 625 mesh_hexas = hexablock.mesh(doc)
 626
 627 ## print "Nombre d hexaedres:", mesh_hexas.NbHexas()
 628 ## print "Nombre de quadrangles:", mesh_hexas.NbQuadrangles()
 629 ## print "Nombre de segments:", mesh_hexas.NbEdges()
 630 ## print "Nombre de noeuds:", mesh_hexas.NbNodes()