1 # -*- coding: latin-1 -*-
2 # Copyright (C) 2009-2016 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, or (at your option) any later version.
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
30 STEP_PATH = os.path.expandvars("$HEXABLOCK_ROOT_DIR/bin/salome/crank.stp")
33 #=============================
35 #=============================
37 doc = hexablock.addDocument("Bielle:hexas")
39 #=============================
41 #=============================
43 # For the connecting rod, two cylindrical grids have to be build and
44 # the quadrangles have to be prismed between these wo grids
46 #=============================
48 #=============================
51 R = 0.095168291790720005
57 xgrand = 1.35739 + 0.1595
58 longueur = (xgrand - xpetit)/2.0
59 hauteur = 0.019999999553*2
70 #=============================
72 #=============================
74 dx = doc.addVector(longueur, 0, 0)
75 dy = doc.addVector(0, longueur, 0)
76 dz = doc.addVector(0, 0, longueur)
78 #=================================================
79 # Creation of cylindrical grid centers
80 #=================================================
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)
86 #=================================================
87 # small cylindrical grid creation
88 #=================================================
90 grille_cyl_pte = doc.makeCylindrical(c_pte, dx, dz, dr_pte, da_pte, dl_pte, nr_pte, na_pte, nl_pte, False)
92 # We obtain a liste containing 6 equal hexaedra
99 alpha_x = 2*R*math.cos(math.pi/3)
100 alpha_y = 2*R*math.sin(math.pi/3)
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)
107 quad_11 = doc.findQuad(x1, x2)
108 quad_12 = doc.findQuad(x1, x3)
110 #=================================
111 # Small cylindrical grid creation
112 #=================================
114 grille_cyl_grd = doc.makeTranslation(grille_cyl_pte, dx_prime)
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)
122 quad_21 = doc.findQuad(y1, y2)
123 quad_22 = doc.findQuad(y1, y3)
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)
130 #=======================================================
131 # Recover vertices of the hexa model for the association
132 #=======================================================
141 bielle_geom = geompy.ImportFile(STEP_PATH, "STEP")
143 geompy.addToStudy(bielle_geom, "bielle_geom")
145 pt_a = geompy.MakeVertex(0, 0, hauteur/2.)
146 face_haut = geompy.GetFaceNearPoint(bielle_geom, pt_a)
148 pt_b = geompy.MakeVertex(0, 0, -hauteur/2.)
149 face_bas = geompy.GetFaceNearPoint(bielle_geom, pt_b)
151 edge_haut_droite = geompy.GetEdgesByLength(face_haut, 0.136, 0.137)
152 edge_haut_gauche = geompy.GetEdgesByLength(face_haut, 0.131, 0.132)
155 # - r�cup�ration des points.
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,
165 # 1. vertex internes (trou),
166 # 2. puis vertex du bas (externes puis internes)
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
180 # 1. grand cylindre :
181 geom_vert_grd = [] # liste des vertex du grand cylindre
184 # 1.1.1 sommets externes :
185 # la cr�ation des vertex de la geometrie se fait obligatoirement
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
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))
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)
210 # pour l'utilisation :
211 # geom_vert_grd[dic_vert_names["y_h_t"]] # par exemple
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
220 # 2.1.1 sommets externes :
222 # la cr�ation des vertex de la geometrie se fait obligatoirement
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
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))
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)
249 #=======================
250 # CREATION ASSOCIATION
251 #=======================
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
262 all_edges_bielle = geompy.SubShapeAllSorted(bielle_geom, geompy.ShapeType["EDGE"])
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
278 # 1. ligne du trou haut du petit cylindre
279 # =======================================
282 mod_start = grille_cyl_pte.getEdgeJ(0, 0, 1)
283 mod_first = mod_start.getVertex(1)
285 mod_line = [grille_cyl_pte.getEdgeJ(0, j, 1) for j in range(1, 6)]
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],
293 [], [], geompy.ShapeType["EDGE"], 0, [], 0)
294 all_edge_part_trou_pte_haut = geompy.SubShapeAllSorted(part_trou_pte_haut, geompy.ShapeType["EDGE"])
296 geo_start = all_edge_part_trou_pte_haut[5] # [y_h_t_p; x_h_t_p]
298 geo_line = [all_edge_part_trou_pte_haut[i] for i in [3, 1, 0, 2, 4]]
301 ier = doc.associateClosedLine(mod_first, mod_start, mod_line,
302 geo_start, par_start, geo_line)
304 # 2. ligne du trou bas du petit cylindre
305 # =======================================
308 mod_start = grille_cyl_pte.getEdgeJ(0, 0, 0)
309 mod_first = mod_start.getVertex(1)
312 mod_line = [grille_cyl_pte.getEdgeJ(0, j, 0) for j in range(1, 6)]
315 e_t_p_b = all_edges_bielle[dic_edge_names["edge_trou_pte_b"]]
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],
321 [], [], geompy.ShapeType["EDGE"], 0, [], 0)
322 all_edge_part_trou_pte_bas = geompy.SubShapeAllSorted(part_trou_pte_bas, geompy.ShapeType["EDGE"])
324 geo_start = all_edge_part_trou_pte_bas[5]
327 geo_line = [all_edge_part_trou_pte_bas[i] for i in [3, 1, 0, 2, 4]]
330 ier = doc.associateClosedLine(mod_first, mod_start, mod_line,
331 geo_start, par_start, geo_line)
333 # 3. ligne du trou haut du grand cylindre
334 # =======================================
337 mod_start = grille_cyl_grd.getEdgeJ(0, 0, 1) # 1er edge
338 mod_first = mod_start.getVertex(1) # 1er vertex
341 mod_line = [grille_cyl_grd.getEdgeJ(0, j, 1) for j in range(1, 6)]
344 e_t_g_h = all_edges_bielle[dic_edge_names["edge_trou_grd_h"]]
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],
350 [], [], geompy.ShapeType["EDGE"], 0, [], 0)
351 all_edge_part_trou_grd_haut = geompy.SubShapeAllSorted(part_trou_grd_haut, geompy.ShapeType["EDGE"])
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
356 geo_line = [all_edge_part_trou_grd_haut[i] for i in [3, 1, 0, 2, 4]]
359 ier = doc.associateClosedLine(mod_first, mod_start, mod_line,
360 geo_start, par_start, geo_line)
362 # 4. ligne du trou bas du grand cylindre
363 # =======================================
366 mod_start = grille_cyl_grd.getEdgeJ(0, 0, 0)
367 mod_first = mod_start.getVertex(1)
370 mod_line = [grille_cyl_grd.getEdgeJ(0, j, 0) for j in range(1, 6)]
373 e_t_g_b = all_edges_bielle[dic_edge_names["edge_trou_grd_b"]]
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],
379 [], [], geompy.ShapeType["EDGE"], 0, [], 0)
380 all_edge_part_trou_grd_bas = geompy.SubShapeAllSorted(part_trou_grd_bas, geompy.ShapeType["EDGE"])
382 geo_start = all_edge_part_trou_grd_bas[5]
383 par_start = 0.0 # entre 0 et 1 (abscisse curviligne)
385 geo_line = [all_edge_part_trou_grd_bas[i] for i in [3, 1, 0, 2, 4]]
388 ier = doc.associateClosedLine(mod_first, mod_start, mod_line,
389 geo_start, par_start, geo_line)
391 # 5 : Les lignes "externes" de la bielle
392 # 5. ligne "externe" de la bielle, en haut
393 # ========================================
395 mod_start = grille_cyl_grd.getEdgeJ(1, 1, 1)
396 mod_first = mod_start.getVertex(1)
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))
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
413 geo_start = all_edges_bielle[dic_edge_names["edge_arr_grd_d_h"]]
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 :
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],
424 [], [], geompy.ShapeType["EDGE"], 0, [], 0)
425 all_edge_part_ray_grd_haut = geompy.SubShapeAllSorted(part_ray_grd_haut, geompy.ShapeType["EDGE"])
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"]])
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 :
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],
448 [], [], geompy.ShapeType["EDGE"], 0, [], 0)
449 all_edge_part_ray_pte_haut = geompy.SubShapeAllSorted(part_ray_pte_haut, geompy.ShapeType["EDGE"])
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"]])
457 ier = doc.associateClosedLine(mod_first, mod_start, mod_line,
458 geo_start, par_start, geo_line)
460 # 6. ligne "externe" de la bielle, en bas
461 # ========================================
463 mod_start = grille_cyl_grd.getEdgeJ(1, 1, 0)
464 mod_first = mod_start.getVertex(1)
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))
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
481 geo_start = all_edges_bielle[dic_edge_names["edge_arr_grd_d_b"]]
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 :
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],
492 [], [], geompy.ShapeType["EDGE"], 0, [], 0)
493 all_edge_part_ray_grd_bas = geompy.SubShapeAllSorted(part_ray_grd_bas, geompy.ShapeType["EDGE"])
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"]])
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 :
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],
516 [], [], geompy.ShapeType["EDGE"], 0, [], 0)
517 all_edge_part_ray_pte_bas = geompy.SubShapeAllSorted(part_ray_pte_bas, geompy.ShapeType["EDGE"])
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"]])
525 ier = doc.associateClosedLine(mod_first, mod_start, mod_line,
526 geo_start, par_start, geo_line)
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)
534 v1.setX(v2.getX() + v3.getX() - v4.getX())
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()
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)
549 v4.setX(v3.getX() + v2.getX() - v1.getX())
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()
559 file_name = os.path.join(os.environ['TMP'], 'bielle2.vtk')
560 doc.saveVtk(file_name)
562 ## #=================================================
563 ## # VERTEX, EDGES, FACES DANS L'ARBRE D'ETUDE SALOME
564 ## #=================================================
567 for key, value in dic_vert_names.iteritems():
568 geompy.addToStudy(geom_vert_grd[value], key + '_g')
569 geompy.addToStudy(geom_vert_pte[value], key + '_p')
572 for key, value in dic_edge_names.iteritems():
573 geompy.addToStudy(all_edges_bielle[value], key)
575 #====================================
577 #====================================
580 #=================================================
581 # Definir les groupes d elements pour le maillage
582 #=================================================
584 # On definit 3 groupes de mailles
586 # JPL (le 09/05/2011) :
587 # @todo a revoir : apres correction des bugs "countXXX()" dans le moteur
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))
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))
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))
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))
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)
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
620 #====================================
621 # G�n�rer des maillages
622 #====================================
624 print " --- MAILLAGE HEXAHEDRIQUE --- "
625 mesh_hexas = hexablock.mesh(doc)
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()