Mesh-Input-And-Output.md

   1 # A little script to illustrate exchanging data with Cubit
   2
   3 ### Cubit
   4
   5 The following cubit journal file (actually a python script) exports the current mesh and
   6 boundary conditions from cubit to a file "output.ucd" in the current directory.
   7 The [output file format](http://www.csit.fsu.edu/~burkardt/data/ucd/ucd.html) is [`AVS UCD`](http://vis.lbl.gov/NERSC/Software/express/help6.2/help/reference/dvmac/UCD_Form.htm).
   8
   9 This is a modification of the original script that takes into account boundary ids via
  10 sidesets ids. If you want to save the boundary faces as well, you just need to
  11 add the relevant surfaces in 3d or curves in 2d to a sideset, and the id will be the one of the
  12 sideset.
  13
  14 ```python
  15 #!python
  16 # This script will output whatever mesh you have currently in CUBIT
  17 # in the AVS UCD format. (http://www.csit.fsu.edu/~burkardt/data/ucd/ucd.html)
  18 # You may need to tweak it to get exactly what you want out of
  19 # it.  Your mileage may vary.
  20
  21 # set the filename -- you may need the entire path
  22 outucdfile = "output.ucd"
  23
  24 outfile = open(outucdfile,"w")
  25
  26 cubit.cmd("body all rotate -90 about y")
  27 cubit.cmd("body all reflect x")
  28
  29 # ============================================================
  30 # Collect all the nodes
  31 # ============================================================
  32 group_id = cubit.get_id_from_name("temp_bc_curves")
  33 if group_id != 0:
  34   cubit.cmd("delete group " + str(group_id))
  35 cubit.cmd("group 'temp_nodes' add node all")
  36 group_id = cubit.get_id_from_name("temp_nodes")
  37 node_list = cubit.get_group_nodes(group_id)
  38 cubit.cmd("delete group " + str(group_id))
  39 n_nodes = len(node_list)
  40
  41 # ============================================================
  42 # Collect all the hex
  43 # ============================================================
  44 group_id = cubit.get_id_from_name("temp_hexes")
  45 if group_id != 0:
  46   cubit.cmd("delete group " + str(group_id))
  47 cubit.cmd("group 'temp_hexes' add hex all")
  48 group_id = cubit.get_id_from_name("temp_hexes")
  49 hex_list = cubit.get_group_hexes(group_id)
  50 cubit.cmd("delete group " + str(group_id))
  51 n_hex_cells = len(hex_list)
  52
  53
  54 # ============================================================
  55 # Now the boundary conditions in 3d
  56 # ============================================================
  57 bc_surfaces = {}
  58 n_bc_quads = 0
  59
  60 bc_ids = cubit.get_sideset_id_list()
  61 for bc_id in bc_ids :
  62   bc_surfaces[= cubit.get_sideset_surfaces(bc_id)
  63   for bc_surface in  bc_surfaces[bc_id](bc_id]):
  64     bc_quads = cubit.get_surface_quads(bc_surface)
  65     n_bc_quads += len(bc_quads)
  66
  67
  68 # ============================================================
  69 # Collect all the surfaces. Notice that the surfaces that make up a
  70 # volume are not grouped here. This is only for 2d objects, i.e.,
  71 # when the number n_hex_cells is zero.
  72 # ============================================================
  73 surface_list = ()
  74 quad_cell_list = {}
  75 n_quad_cells = 0
  76 if n_hex_cells == 0:
  77   group_id = cubit.get_id_from_name("temp_surfs")
  78   if group_id != 0:
  79     cubit.cmd("delete group " + str(group_id))
  80   cubit.cmd("group 'temp_surfs' add surf all")
  81   group_id = cubit.get_id_from_name("temp_surfs")
  82   surface_list = cubit.get_group_surfaces(group_id)
  83   cubit.cmd("delete group " + str(group_id))
  84   for surface_id in surface_list:
  85     quad_cell_list[= cubit.get_surface_quads(surface_id)
  86     n_quad_cells +=  len(quad_cell_list[surface_id](surface_id]))
  87
  88 # ============================================================
  89 # Now the boundary conditions in 2d
  90 # ============================================================
  91 bc_curves = {}
  92 bc_edges = {}
  93 n_bc_edges = 0
  94 if n_hex_cells == 0:
  95   bc_ids = cubit.get_sideset_id_list()
  96   for bc_id in bc_ids :
  97     bc_curves[= cubit.get_sideset_curves(bc_id)
  98     group_id = cubit.get_id_from_name("temp_bc_curves")
  99     if group_id != 0:
 100       cubit.cmd("delete group " + str(group_id))
 101     for bc_curve in bc_curves[bc_id](bc_id]):
 102       cubit.cmd("group 'temp_bc_curves' add edge all in curve " + str(bc_curve))
 103     group_id = cubit.get_id_from_name("temp_bc_curves")
 104     bc_edges[= cubit.get_group_edges(group_id)
 105     cubit.cmd("delete group " + str(group_id))
 106     n_bc_edges +=  len(bc_edges[bc_id](bc_id]))
 107
 108 print 'Edges: ' + str(n_bc_edges)
 109
 110 # ============================================================
 111 # Now we write the header.
 112 # ============================================================
 113 n_elements = n_hex_cells + n_bc_quads + n_quad_cells + n_bc_edges
 114 outfile.write(str(n_nodes) + " " + str(n_elements) + " 0 0 0\n")
 115
 116
 117 # ============================================================
 118 # The node list.
 119 # ============================================================
 120 for node_num in node_list:
 121    outfile.write(str(node_num ))
 122    outfile.write("\t")
 123    node_coord = cubit.get_nodal_coordinates(node_num)
 124    if abs(node_coord[outfile.write("0 ")
 125    else :
 126        outfile.write(str(node_coord[2](2])<1e-15:)) + " ")
 127    if abs(node_coord[outfile.write("0 ")
 128    else :
 129        outfile.write(str(node_coord[1](1])<1e-15:)) + " ")
 130    if abs(node_coord[outfile.write("0")
 131    else :
 132        outfile.write(str(node_coord[0](0])<1e-15:)))
 133    outfile.write("\n")
 134
 135
 136 # ============================================================
 137 # The hex list. 3d
 138 # ============================================================
 139 k = 1
 140 for hex_num in hex_list:
 141    outfile.write(str(k) + " 0 " + " hex  ")
 142    k += 1
 143    hex_nodes = cubit.get_connectivity("Hex", hex_num)
 144    i = 0
 145    while i < 8:
 146       outfile.write(str(hex_nodes[+ " ")
 147       i += 1
 148    outfile.write("\n")
 149
 150
 151 # ============================================================
 152 # The quads on the boundaries. 3d
 153 # Note that the boundary id is given by the sideset id.
 154 # ============================================================
 155 if n_hex_cells != 0:
 156   k=1
 157   for bc_id in bc_ids:
 158     for bc_surface in  bc_surfaces[bc_id](i])):
 159       bc_quads = cubit.get_surface_quads(bc_surface)
 160       for quad_num in bc_quads:
 161         outfile.write(str(k))
 162         k += 1
 163         outfile.write(" " + str(bc_id) + " quad ")
 164         quad_nodes = cubit.get_connectivity("Quad", quad_num)
 165         outfile.write(str(quad_nodes[+ " ")
 166         outfile.write(str(quad_nodes[3](0]))) + " ")
 167         outfile.write(str(quad_nodes[+ " ")
 168         outfile.write(str(quad_nodes[1](2]))))
 169         outfile.write("\n")
 170
 171 # ============================================================
 172 # The quads on the surfaces. 2d
 173 # ============================================================
 174 if n_hex_cells == 0:
 175   k = 1
 176   for surface_id in surface_list:
 177     for quad_num in quad_cell_list[outfile.write(str(k))
 178       k += 1
 179       outfile.write(" " + str(surface_id) + " quad ")
 180       quad_nodes = cubit.get_connectivity("Quad", quad_num)
 181       outfile.write(str(quad_nodes[0](surface_id]:)) + " ")
 182       outfile.write(str(quad_nodes[+ " ")
 183       outfile.write(str(quad_nodes[2](3]))) + " ")
 184       outfile.write(str(quad_nodes[outfile.write("\n")
 185
 186 # ============================================================
 187 # The edges on the curves. 2d
 188 # Boundary id = sideset_id
 189 # ============================================================
 190 if n_hex_cells == 0:
 191   k=1
 192   for bc_id in bc_ids:
 193     for edge_num in bc_edges[bc_id](1]))):
 194       outfile.write(str(k))
 195       k += 1
 196       outfile.write(" " + str(bc_id) + " line ")
 197       edge_nodes = cubit.get_connectivity("Edge", edge_num)
 198       outfile.write(str(edge_nodes[+ " ")
 199       outfile.write(str(edge_nodes[1](0]))))
 200       outfile.write("\n")
 201
 202 outfile.close()
 203
 204 cubit.cmd("body all reflect x")
 205 cubit.cmd("body all rotate 90 about y")
 206
 207 print str(n_nodes) + " nodes\n"
 208 print str(n_hex_cells) + " hexes\n"
 209 print str(n_quad_cells) + " quads\n"
 210 print str(n_bc_quads) + " face_quads\n"
 211 print str(n_bc_edges) + " edges\n"
 212
 213 ```
 214
 215 # Alternate versions of this script
 216
 217 ### Cubit 15.2
 218
 219 The following script, which also outputs material IDs (as identified by the `block id` to which each element belongs), has been [verified to work](https://groups.google.com/forum/#!topic/dealii/ZnU3XIK_ipk) with `Cubit v15.2`.
 220
 221 ```python
 222 #!python
 223 # This script will output whatever mesh you have currently in CUBIT
 224 # in the AVS UCD format. (http://www.csit.fsu.edu/~burkardt/data/ucd/ucd.html)
 225 # You may need to tweak it to get exactly what you want out of
 226 # it.  Your mileage may vary.
 227
 228 # set the filename -- you may need the entire path
 229 outucdfile = "output.ucd"
 230
 231 outfile = open(outucdfile,"w")
 232
 233 cubit.cmd("body all rotate -90 about y")
 234 cubit.cmd("body all reflect x")
 235
 236 # ============================================================
 237 # Collect all the nodes
 238 # ============================================================
 239 group_id = cubit.get_id_from_name("temp_bc_curves")
 240 if group_id != 0:
 241   cubit.cmd("delete group " + str(group_id))
 242 cubit.cmd("group 'temp_nodes' add node all")
 243 group_id = cubit.get_id_from_name("temp_nodes")
 244 node_list = cubit.get_group_nodes(group_id)
 245 cubit.cmd("delete group " + str(group_id))
 246 n_nodes = len(node_list)
 247
 248 # ============================================================
 249 # Collect all the hex
 250 # ============================================================
 251 hex_cell_list = {}
 252 n_hex_cells = 0
 253
 254 block_ids = cubit.get_block_id_list()
 255 for block_id in block_ids:
 256     hex_cell_list[block_id] = cubit.get_block_hexes(block_id)
 257     n_hex_cells += len(hex_cell_list[block_id])
 258
 259 # ============================================================
 260 # Now the boundary conditions in 3d
 261 # ============================================================
 262 bc_surfaces = {}
 263 n_bc_quads = 0
 264
 265 bc_ids = cubit.get_sideset_id_list()
 266 for bc_id in bc_ids :
 267   bc_surfaces[bc_id] = cubit.get_sideset_surfaces(bc_id)
 268   for bc_surface in  bc_surfaces[bc_id]:
 269     bc_quads = cubit.get_surface_quads(bc_surface)
 270     n_bc_quads += len(bc_quads)
 271
 272
 273 # ============================================================
 274 # Collect all the surfaces. Notice that the surfaces that make up a
 275 # volume are not grouped here. This is only for 2d objects, i.e.,
 276 # when the number n_hex_cells is zero.
 277 # ============================================================
 278 surface_list = ()
 279 quad_cell_list = {}
 280 n_quad_cells = 0
 281 if n_hex_cells == 0:
 282   group_id = cubit.get_id_from_name("temp_surfs")
 283   if group_id != 0:
 284     cubit.cmd("delete group " + str(group_id))
 285   cubit.cmd("group 'temp_surfs' add surf all")
 286   group_id = cubit.get_id_from_name("temp_surfs")
 287   surface_list = cubit.get_group_surfaces(group_id)
 288   cubit.cmd("delete group " + str(group_id))
 289   for surface_id in surface_list:
 290     quad_cell_list[surface_id] = cubit.get_surface_quads(surface_id)
 291     n_quad_cells +=  len(quad_cell_list[surface_id])
 292
 293 # ============================================================
 294 # Now the boundary conditions in 2d
 295 # ============================================================
 296 bc_curves = {}
 297 bc_edges = {}
 298 n_bc_edges = 0
 299 if n_hex_cells == 0:
 300   bc_ids = cubit.get_sideset_id_list()
 301   for bc_id in bc_ids :
 302     bc_curves[bc_id]    = cubit.get_sideset_curves(bc_id)
 303     group_id = cubit.get_id_from_name("temp_bc_curves")
 304     if group_id != 0:
 305       cubit.cmd("delete group " + str(group_id))
 306     for bc_curve in bc_curves[bc_id]:
 307       cubit.cmd("group 'temp_bc_curves' add edge all in curve " + str(bc_curve))
 308     group_id = cubit.get_id_from_name("temp_bc_curves")
 309     bc_edges[bc_id] = cubit.get_group_edges(group_id)
 310     cubit.cmd("delete group " + str(group_id))
 311     n_bc_edges +=  len(bc_edges[bc_id])
 312
 313 print 'Edges: ' + str(n_bc_edges)
 314
 315 # ============================================================
 316 # Now we write the header.
 317 # ============================================================
 318 n_elements = n_hex_cells + n_bc_quads + n_quad_cells + n_bc_edges
 319 outfile.write(str(n_nodes) + " " + str(n_elements) + " 0 0 0\n")
 320
 321
 322 # ============================================================
 323 # The node list.
 324 # ============================================================
 325 for node_num in node_list:
 326    outfile.write(str(node_num ))
 327    outfile.write("\t")
 328    node_coord = cubit.get_nodal_coordinates(node_num)
 329    if abs(node_coord[2])<1e-15:
 330        outfile.write("0 ")
 331    else :
 332        outfile.write(str(node_coord[2]) + " ")
 333    if abs(node_coord[1])<1e-15:
 334        outfile.write("0 ")
 335    else :
 336        outfile.write(str(node_coord[1]) + " ")
 337    if abs(node_coord[0])<1e-15:
 338        outfile.write("0")
 339    else :
 340        outfile.write(str(node_coord[0]))
 341    outfile.write("\n")
 342
 343
 344 # ============================================================
 345 # The hex list. 3d
 346 # ============================================================
 347 k = 1
 348 for block_id in block_ids:
 349     for hex_num in hex_cell_list[block_id]:
 350         print str(k) + " " + str(block_id) + "  hex  "
 351         outfile.write(str(k) + " " + str(block_id) + "  hex  ")
 352         k += 1
 353         hex_nodes = cubit.get_connectivity("Hex", hex_num)
 354         i = 0
 355         while i < 8:
 356             outfile.write(str(hex_nodes[i]) + " ")
 357             i += 1
 358         outfile.write("\n")
 359
 360 # ============================================================
 361 # The quads on the boundaries. 3d
 362 # Note that the boundary id is given by the sideset id.
 363 # ============================================================
 364 if n_hex_cells != 0:
 365   k=1
 366   for bc_id in bc_ids:
 367     for bc_surface in  bc_surfaces[bc_id]:
 368       bc_quads = cubit.get_surface_quads(bc_surface)
 369       for quad_num in bc_quads:
 370         outfile.write(str(k))
 371         k += 1
 372         outfile.write(" " + str(bc_id) + " quad ")
 373         quad_nodes = cubit.get_connectivity("Quad", quad_num)
 374         outfile.write(str(quad_nodes[0]) + " ")
 375         outfile.write(str(quad_nodes[3]) + " ")
 376         outfile.write(str(quad_nodes[2]) + " ")
 377         outfile.write(str(quad_nodes[1]))
 378         outfile.write("\n")
 379
 380 # ============================================================
 381 # The quads on the surfaces. 2d
 382 # ============================================================
 383 if n_hex_cells == 0:
 384   k = 1
 385   for surface_id in surface_list:
 386     for quad_num in quad_cell_list[surface_id]:
 387       outfile.write(str(k))
 388       k += 1
 389       outfile.write(" " + str(surface_id) + " quad ")
 390       quad_nodes = cubit.get_connectivity("Quad", quad_num)
 391       outfile.write(str(quad_nodes[0]) + " ")
 392       outfile.write(str(quad_nodes[3]) + " ")
 393       outfile.write(str(quad_nodes[2]) + " ")
 394       outfile.write(str(quad_nodes[1]))
 395       outfile.write("\n")
 396
 397 # ============================================================
 398 # The edges on the curves. 2d
 399 # Boundary id = sideset_id
 400 # ============================================================
 401 if n_hex_cells == 0:
 402   k=1
 403   for bc_id in bc_ids:
 404     for edge_num in bc_edges[bc_id]:
 405       outfile.write(str(k))
 406       k += 1
 407       outfile.write(" " + str(bc_id) + " line ")
 408       edge_nodes = cubit.get_connectivity("Edge", edge_num)
 409       outfile.write(str(edge_nodes[0]) + " ")
 410       outfile.write(str(edge_nodes[1]))
 411       outfile.write("\n")
 412
 413 outfile.close()
 414
 415 cubit.cmd("body all reflect x")
 416 cubit.cmd("body all rotate 90 about y")
 417
 418 print str(n_nodes) + " nodes\n"
 419 print str(n_hex_cells) + " hexes\n"
 420 print str(n_quad_cells) + " quads\n"
 421 print str(n_bc_quads) + " face_quads\n"
 422 print str(n_bc_edges) + " edges\n"
 423 ```
 424
 425 ### Cubit 13.2
 426 In case it is of any use, one of the initial versions of this script is also provided below. This has been verified to work on `Cubit v13.2`, but unfortunately does not output material IDs for reasons documented in the paragraphs below.
 427
 428 ```python
 429 #!python
 430 # This script will output whatever mesh you have currently in CUBIT
 431 # in the AVS UCD format. (http://www.csit.fsu.edu/~burkardt/data/ucd/ucd.html)
 432 # You may need to tweak it to get exactly what you want out of
 433 # it.  Your mileage may vary.
 434
 435 # set the filename -- you may need the entire path
 436 outucdfile = "output.ucd"
 437
 438 outfile = open(outucdfile,"w")
 439
 440 cubit.cmd("body all rotate -90 about y")
 441 cubit.cmd("body all reflect x")
 442
 443 # ============================================================
 444 # Collect all the nodes
 445 # ============================================================
 446 group_id = cubit.get_id_from_name("temp_bc_curves")
 447 if group_id != 0:
 448   cubit.cmd("delete group " + str(group_id))
 449 cubit.cmd("group 'temp_nodes' add node all")
 450 group_id = cubit.get_id_from_name("temp_nodes")
 451 node_list = cubit.get_group_nodes(group_id)
 452 cubit.cmd("delete group " + str(group_id))
 453 n_nodes = len(node_list)
 454
 455 # ============================================================
 456 # Collect all the hex
 457 # ============================================================
 458 group_id = cubit.get_id_from_name("temp_hexes")
 459 if group_id != 0:
 460   cubit.cmd("delete group " + str(group_id))
 461 cubit.cmd("group 'temp_hexes' add hex all")
 462 group_id = cubit.get_id_from_name("temp_hexes")
 463 hex_list = cubit.get_group_hexes(group_id)
 464 cubit.cmd("delete group " + str(group_id))
 465 n_hex_cells = len(hex_list)
 466
 467
 468 # ============================================================
 469 # Now the boundary conditions in 3d
 470 # ============================================================
 471 bc_surfaces = {}
 472 n_bc_quads = 0
 473
 474 bc_ids = cubit.get_sideset_id_list()
 475 for bc_id in bc_ids :
 476   bc_surfaces[bc_id]    = cubit.get_sideset_surfaces(bc_id)
 477   for bc_surface in  bc_surfaces[bc_id]:
 478     bc_quads = cubit.get_surface_quads(bc_surface)
 479     n_bc_quads += len(bc_quads)
 480
 481
 482 # ============================================================
 483 # Collect all the surfaces. Notice that the surfaces that make up a
 484 # volume are not grouped here. This is only for 2d objects, i.e.,
 485 # when the number n_hex_cells is zero.
 486 # ============================================================
 487 surface_list = ()
 488 quad_cell_list = {}
 489 n_quad_cells = 0
 490 if n_hex_cells == 0:
 491   group_id = cubit.get_id_from_name("temp_surfs")
 492   if group_id != 0:
 493     cubit.cmd("delete group " + str(group_id))
 494   cubit.cmd("group 'temp_surfs' add surf all")
 495   group_id = cubit.get_id_from_name("temp_surfs")
 496   surface_list = cubit.get_group_surfaces(group_id)
 497   cubit.cmd("delete group " + str(group_id))
 498   for surface_id in surface_list:
 499     quad_cell_list[surface_id] = cubit.get_surface_quads(surface_id)
 500     n_quad_cells +=  len(quad_cell_list[surface_id])
 501
 502 # ============================================================
 503 # Now the boundary conditions in 2d
 504 # ============================================================
 505 bc_curves = {}
 506 bc_edges = {}
 507 n_bc_edges = 0
 508 if n_hex_cells == 0:
 509   bc_ids = cubit.get_sideset_id_list()
 510   for bc_id in bc_ids :
 511     bc_curves[bc_id]    = cubit.get_sideset_curves(bc_id)
 512     group_id = cubit.get_id_from_name("temp_bc_curves")
 513     if group_id != 0:
 514       cubit.cmd("delete group " + str(group_id))
 515     for bc_curve in bc_curves[bc_id]:
 516       cubit.cmd("group 'temp_bc_curves' add edge all in curve " + str(bc_curve))
 517     group_id = cubit.get_id_from_name("temp_bc_curves")
 518     bc_edges[bc_id] = cubit.get_group_edges(group_id)
 519     cubit.cmd("delete group " + str(group_id))
 520     n_bc_edges +=  len(bc_edges[bc_id])
 521
 522 print 'Edges: ' + str(n_bc_edges)
 523
 524 # ============================================================
 525 # Now we write the header.
 526 # ============================================================
 527 n_elements = n_hex_cells + n_bc_quads + n_quad_cells + n_bc_edges
 528 outfile.write(str(n_nodes) + " " + str(n_elements) + " 0 0 0\n")
 529
 530
 531 # ============================================================
 532 # The node list.
 533 # ============================================================
 534 for node_num in node_list:
 535    outfile.write(str(node_num ))
 536    outfile.write("\t")
 537    node_coord = cubit.get_nodal_coordinates(node_num)
 538    if abs(node_coord[2])<1e-15:
 539        outfile.write("0 ")
 540    else :
 541        outfile.write(str(node_coord[2]) + " ")
 542    if abs(node_coord[1])<1e-15:
 543        outfile.write("0 ")
 544    else :
 545        outfile.write(str(node_coord[1]) + " ")
 546    if abs(node_coord[0])<1e-15:
 547        outfile.write("0")
 548    else :
 549        outfile.write(str(node_coord[0]))
 550    outfile.write("\n")
 551
 552
 553 # ============================================================
 554 # The hex list. 3d
 555 # ============================================================
 556 k = 1
 557 for hex_num in hex_list:
 558    outfile.write(str(k) + " 0 " + " hex  ")
 559    k += 1
 560    hex_nodes = cubit.get_connectivity("Hex", hex_num)
 561    i = 0
 562    while i < 8:
 563       outfile.write(str(hex_nodes[i]) + " ")
 564       i += 1
 565    outfile.write("\n")
 566
 567 # ============================================================
 568 # The quads on the boundaries. 3d
 569 # Note that the boundary id is given by the sideset id.
 570 # ============================================================
 571 if n_hex_cells != 0:
 572   k=1
 573   for bc_id in bc_ids:
 574     for bc_surface in  bc_surfaces[bc_id]:
 575       bc_quads = cubit.get_surface_quads(bc_surface)
 576       for quad_num in bc_quads:
 577         outfile.write(str(k))
 578         k += 1
 579         outfile.write(" " + str(bc_id) + " quad ")
 580         quad_nodes = cubit.get_connectivity("Quad", quad_num)
 581         outfile.write(str(quad_nodes[0]) + " ")
 582         outfile.write(str(quad_nodes[3]) + " ")
 583         outfile.write(str(quad_nodes[2]) + " ")
 584         outfile.write(str(quad_nodes[1]))
 585         outfile.write("\n")
 586
 587 # ============================================================
 588 # The quads on the surfaces. 2d
 589 # ============================================================
 590 if n_hex_cells == 0:
 591   k = 1
 592   for surface_id in surface_list:
 593     for quad_num in quad_cell_list[surface_id]:
 594       outfile.write(str(k))
 595       k += 1
 596       outfile.write(" " + str(surface_id) + " quad ")
 597       quad_nodes = cubit.get_connectivity("Quad", quad_num)
 598       outfile.write(str(quad_nodes[0]) + " ")
 599       outfile.write(str(quad_nodes[3]) + " ")
 600       outfile.write(str(quad_nodes[2]) + " ")
 601       outfile.write(str(quad_nodes[1]))
 602       outfile.write("\n")
 603
 604 # ============================================================
 605 # The edges on the curves. 2d
 606 # Boundary id = sideset_id
 607 # ============================================================
 608 if n_hex_cells == 0:
 609   k=1
 610   for bc_id in bc_ids:
 611     for edge_num in bc_edges[bc_id]:
 612       outfile.write(str(k))
 613       k += 1
 614       outfile.write(" " + str(bc_id) + " line ")
 615       edge_nodes = cubit.get_connectivity("Edge", edge_num)
 616       outfile.write(str(edge_nodes[0]) + " ")
 617       outfile.write(str(edge_nodes[1]))
 618       outfile.write("\n")
 619
 620 outfile.close()
 621
 622 cubit.cmd("body all reflect x")
 623 cubit.cmd("body all rotate 90 about y")
 624
 625 print str(n_nodes) + " nodes\n"
 626 print str(n_hex_cells) + " hexes\n"
 627 print str(n_quad_cells) + " quads\n"
 628 print str(n_bc_quads) + " face_quads\n"
 629 print str(n_bc_edges) + " edges\n"
 630 ```
 631
 632 ### A note on the (non-) output of material ID's
 633 For the first and third versions of this script, the material IDs are not output (they are always set by default to zero).
 634 This is because there appears to be a deficiency/bug in the implementation of `cubit.get_block_hexes(block_id)` (in `Cubit v13.2`, at least).
 635 In theory one should be able to collect the cells in the following manner, assuming that the `block_id` represents the material id (this mirrors what is done already for `sideset_id`s and boundary ids):
 636
 637 ```python
 638 # ============================================================
 639 # Collect all the hex
 640 # ============================================================
 641 hex_cell_list = {}
 642 n_hex_cells = 0
 643
 644 block_ids = cubit.get_block_id_list()
 645 for block_id in block_ids:
 646     hex_cell_list[block_id] = cubit.get_block_hexes(block_id)
 647     n_hex_cells += len(hex_cell_list[block_id])
 648 ```
 649
 650 and one could then write out the elements to file with a set of commands along the lines of
 651
 652 ```python
 653 # ============================================================
 654 # The hex list. 3d
 655 # ============================================================
 656 k = 1
 657 for block_id in block_ids:
 658     for hex_num in hex_cell_list[block_id]:
 659         print str(k) + " " + str(block_id) + "  hex  "
 660         outfile.write(str(k) + " " + str(block_id) + "  hex  ")
 661         k += 1
 662         hex_nodes = cubit.get_connectivity("Hex", hex_num)
 663         i = 0
 664         while i < 8:
 665             outfile.write(str(hex_nodes[i]) + " ")
 666             i += 1
 667         outfile.write("\n")
 668 ```
 669
 670 However, there `cubit.get_block_hexes(block_id)` does not return anything other than an empty set when these sets of commands were last tested (`Cubit v13.2`).
 671 By contrast the script verified to work with `Cubit v15.2` includes this logic as the bug has been corrected in later versions of the software.
 672
 673 Another version of the above script is available that produces a VTK file. You can find it here:
 674
 675 https://gist.github.com/luca-heltai/b127a69b86b4b140c87a01110053f751
 676
 677 You can add a shortcut in a Custom Toolbar to load the script into memory. Then when you are
 678 ready to export, you can type the following command in the script tab:
 679
 680         saveVTK("filename.vtk")