Coreform-Cubit-Mesh-Export 1.3__py3-none-any.whl → 1.4.1__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of Coreform-Cubit-Mesh-Export might be problematic. Click here for more details.

Files changed (8) hide show
  1. coreform_cubit_mesh_export-1.4.1.dist-info/METADATA +124 -0
  2. coreform_cubit_mesh_export-1.4.1.dist-info/RECORD +10 -0
  3. coreform_cubit_mesh_export-1.4.1.dist-info/licenses/LICENSE +504 -0
  4. cubit_mesh_export.py +632 -558
  5. coreform_cubit_mesh_export-1.3.dist-info/METADATA +0 -156
  6. coreform_cubit_mesh_export-1.3.dist-info/RECORD +0 -9
  7. {coreform_cubit_mesh_export-1.3.dist-info → coreform_cubit_mesh_export-1.4.1.dist-info}/WHEEL +0 -0
  8. {coreform_cubit_mesh_export-1.3.dist-info → coreform_cubit_mesh_export-1.4.1.dist-info}/top_level.txt +0 -0
cubit_mesh_export.py CHANGED
@@ -1,558 +1,632 @@
1
- ########################################################################
2
- ### Gmsh format version 2
3
- ########################################################################
4
-
5
- def export_Gmsh_ver2(cubit, FileName):
6
-
7
- with open(FileName, 'w') as fid:
8
-
9
- fid.write("$MeshFormat\n")
10
- fid.write("2.2 0 8\n")
11
- fid.write("$EndMeshFormat\n")
12
-
13
- fid.write("$PhysicalNames\n")
14
- fid.write(f'{cubit.get_block_count()}\n')
15
- for block_id in cubit.get_block_id_list():
16
- name = cubit.get_exodus_entity_name("block", block_id)
17
- if len(cubit.get_block_nodes(block_id)) > 0:
18
- fid.write(f'0 {block_id} "{name}"\n')
19
- elif len(cubit.get_block_edges(block_id)) > 0:
20
- fid.write(f'1 {block_id} "{name}"\n')
21
- elif len(cubit.get_block_tris(block_id)) + len(cubit.get_block_faces(block_id))> 0:
22
- fid.write(f'2 {block_id} "{name}"\n')
23
- else:
24
- fid.write(f'3 {block_id} "{name}"\n')
25
- fid.write('$EndPhysicalNames\n')
26
-
27
- fid.write("$Nodes\n")
28
- node_list = set()
29
- for block_id in cubit.get_block_id_list():
30
- elem_types = ["hex", "tet", "wedge", "pyramid", "tri", "face", "edge", "node"]
31
- for elem_type in elem_types:
32
- if elem_type == "hex":
33
- func = getattr(cubit, f"get_block_{elem_type}es")
34
- else:
35
- func = getattr(cubit, f"get_block_{elem_type}s")
36
- for element_id in func(block_id):
37
- node_ids = cubit.get_expanded_connectivity(elem_type, element_id)
38
- node_list.update(node_ids)
39
-
40
- fid.write(f'{len(node_list)}\n')
41
- for node_id in node_list:
42
- coord = cubit.get_nodal_coordinates(node_id)
43
- fid.write(f'{node_id} {coord[0]} {coord[1]} {coord[2]}\n')
44
- fid.write('$EndNodes\n')
45
-
46
- hex_list = set()
47
- tet_list = set()
48
- wedge_list = set()
49
- pyramid_list = set()
50
- tri_list = set()
51
- quad_list = set()
52
- edge_list = set()
53
- node_list = set()
54
-
55
- for block_id in cubit.get_block_id_list():
56
- tet_list.update(cubit.get_block_tets(block_id))
57
- hex_list.update(cubit.get_block_hexes(block_id))
58
- wedge_list.update(cubit.get_block_wedges(block_id))
59
- pyramid_list.update(cubit.get_block_pyramids(block_id))
60
- tri_list.update(cubit.get_block_tris(block_id))
61
- quad_list.update(cubit.get_block_faces(block_id))
62
- edge_list.update(cubit.get_block_edges(block_id))
63
- node_list.update(cubit.get_block_nodes(block_id))
64
-
65
- element_id = 0
66
- fid.write('$Elements\n')
67
- fid.write(f'{len(hex_list) + len(tet_list) + len(wedge_list) + len(pyramid_list) + len(tri_list) + len(quad_list) + len(edge_list) + len(node_list)}\n')
68
-
69
- for block_id in cubit.get_block_id_list():
70
-
71
- tet_list = cubit.get_block_tets(block_id)
72
- for tet_id in tet_list:
73
- element_id += 1
74
- node_list = cubit.get_expanded_connectivity("tet", tet_id)
75
- if len(node_list)==4:
76
- fid.write(f'{element_id} { 4} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]}\n')
77
- if len(node_list)==10:
78
- fid.write(f'{element_id} {11} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[7]} {node_list[9]} {node_list[8]}\n')
79
- if len(node_list)==11:
80
- fid.write(f'{element_id} {35} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[7]} {node_list[9]} {node_list[8]} {node_list[10]}\n')
81
-
82
- hex_list = cubit.get_block_hexes(block_id)
83
- for hex_id in hex_list:
84
- element_id += 1
85
- node_list = cubit.get_expanded_connectivity("hex", hex_id)
86
- if len(node_list)==8:
87
- fid.write(f'{element_id} { 5} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[7]}\n')
88
- if len(node_list)==20:
89
- fid.write(f'{element_id} {17} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[7]} {node_list[8]} {node_list[11]} {node_list[12]} {node_list[9]} {node_list[13]} {node_list[10]} {node_list[14]} {node_list[15]} {node_list[16]} {node_list[19]} {node_list[17]} {node_list[18]}\n')
90
-
91
- wedge_list = cubit.get_block_wedges(block_id)
92
- for wedge_id in wedge_list:
93
- element_id += 1
94
- node_list = cubit.get_expanded_connectivity("wedge", wedge_id)
95
- if len(node_list)==6:
96
- fid.write(f'{element_id} { 6} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]}\n')
97
- if len(node_list)==15:
98
- fid.write(f'{element_id} {18} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[8]} {node_list[9]} {node_list[7]} {node_list[10]} {node_list[11]} {node_list[12]} {node_list[14]} {node_list[13]}\n')
99
-
100
- pyramid_list = cubit.get_block_pyramids(block_id)
101
- for pyramid_id in pyramid_list:
102
- element_id += 1
103
- node_list = cubit.get_expanded_connectivity("pyramid", pyramid_id)
104
- if len(node_list)==6:
105
- fid.write(f'{element_id} { 7} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]}\n')
106
- if len(node_list)==13:
107
- fid.write(f'{element_id} {19} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[8]} {node_list[9]} {node_list[6]} {node_list[10]} {node_list[7]} {node_list[11]} {node_list[12]} \n')
108
-
109
- tri_list = cubit.get_block_tris(block_id)
110
- for tri_id in tri_list:
111
- element_id += 1
112
- node_list = cubit.get_expanded_connectivity("tri", tri_id)
113
- if len(node_list)==3:
114
- fid.write(f'{element_id} { 2} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]}\n')
115
- if len(node_list)==6:
116
- fid.write(f'{element_id} { 9} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]}\n')
117
- if len(node_list)==7:
118
- fid.write(f'{element_id} {42} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]}\n')
119
-
120
- quad_list = cubit.get_block_faces(block_id)
121
- for quad_id in quad_list:
122
- element_id += 1
123
- node_list = cubit.get_expanded_connectivity("quad", quad_id)
124
- if len(node_list)==4:
125
- fid.write(f'{element_id} { 3} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]}\n')
126
- if len(node_list)==8:
127
- fid.write(f'{element_id} {16} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[7]}\n')
128
- if len(node_list)==9:
129
- fid.write(f'{element_id} {10} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[7]} {node_list[8]}\n')
130
-
131
- edge_list = cubit.get_block_edges(block_id)
132
- for edge_id in edge_list:
133
- element_id += 1
134
- node_list = cubit.get_expanded_connectivity("edge", edge_id)
135
- if len(node_list)==2:
136
- fid.write(f'{element_id} {1} {2} {block_id} {block_id} {node_list[0]} {node_list[1]}\n')
137
- if len(node_list)==3:
138
- fid.write(f'{element_id} {8} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]}\n')
139
-
140
- node_list = cubit.get_block_nodes(block_id)
141
- for node_id in node_list:
142
- element_id += 1
143
- fid.write(f'{element_id} {15} {2} {block_id} {block_id} {node_id}\n')
144
-
145
- fid.write('$EndElements\n')
146
- fid.close()
147
- return cubit
148
-
149
- ########################################################################
150
- ### Nastran file
151
- ########################################################################
152
-
153
- def export_Nastran(cubit, FileName, DIM="3D", PYRAM=True):
154
-
155
- import datetime
156
- formatted_date_time = datetime.datetime.now().strftime("%d-%b-%y at %H:%M:%S")
157
- fid = open(FileName,'w',encoding='UTF-8')
158
- fid.write("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n")
159
- fid.write("$\n")
160
- fid.write("$ CUBIT NX Nastran Translator\n")
161
- fid.write("$\n")
162
- fid.write(f"$ File: {FileName}\n")
163
- fid.write(f"$ Time Stamp: {formatted_date_time}\n")
164
- fid.write("$\n")
165
- fid.write("$\n")
166
- fid.write("$ PLEASE CHECK YOUR MODEL FOR UNITS CONSISTENCY.\n")
167
- fid.write("$\n")
168
- fid.write("$ It should be noted that load ID's from CUBIT may NOT correspond to Nastran SID's\n")
169
- fid.write("$ The SID's for the load and restraint sets start at one and increment by one:i.e.,1,2,3,4...\n")
170
- fid.write("$\n")
171
- fid.write("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n")
172
- fid.write("$\n")
173
- fid.write("$\n")
174
- fid.write("$ -------------------------\n")
175
- fid.write("$ Executive Control Section\n")
176
- fid.write("$ -------------------------\n")
177
- fid.write("$\n")
178
- fid.write("SOL 101\n")
179
- fid.write("CEND\n")
180
- fid.write("$\n")
181
- fid.write("$\n")
182
- fid.write("$ --------------------\n")
183
- fid.write("$ Case Control Section\n")
184
- fid.write("$ --------------------\n")
185
- fid.write("$\n")
186
- fid.write("ECHO = SORT\n")
187
- fid.write("$\n")
188
- fid.write("$\n")
189
- fid.write("$ Name: Initial\n")
190
- fid.write("$\n")
191
- fid.write("$\n")
192
- fid.write("$ Name: Default Set\n")
193
- fid.write("$\n")
194
- fid.write("SUBCASE = 1\n")
195
- fid.write("$\n")
196
- fid.write("LABEL = Default Set\n")
197
- fid.write("$\n")
198
- fid.write("$ -----------------\n")
199
- fid.write("$ Bulk Data Section\n")
200
- fid.write("$ -----------------\n")
201
- fid.write("$\n")
202
- fid.write("BEGIN BULK\n")
203
- fid.write("$\n")
204
- fid.write("$ Params\n")
205
- fid.write("$\n")
206
- fid.write("$\n")
207
- fid.write("$ Node cards\n")
208
- fid.write("$\n")
209
-
210
- node_list = set()
211
- for block_id in cubit.get_block_id_list():
212
- elem_types = ["hex", "tet", "wedge", "pyramid", "tri", "face", "edge", "node"]
213
- for elem_type in elem_types:
214
- if elem_type == "hex":
215
- func = getattr(cubit, f"get_block_{elem_type}es")
216
- else:
217
- func = getattr(cubit, f"get_block_{elem_type}s")
218
- for element_id in func(block_id):
219
- node_ids = cubit.get_connectivity(elem_type, element_id)
220
- node_list.update(node_ids)
221
- for node_id in node_list:
222
- coord = cubit.get_nodal_coordinates(node_id)
223
- if DIM == "3D":
224
- fid.write(f"GRID* {node_id:>16}{0:>16}{coord[0]:>16.5f}{coord[1]:>16.5f}\n* {coord[2]:>16.5f}\n")
225
- else:
226
- fid.write(f"GRID* {node_id:>16}{0:>16}{coord[0]:>16.5f}{coord[1]:>16.5f}\n* {0}\n")
227
-
228
- element_id = 0
229
- fid.write("$\n")
230
- fid.write("$ Element cards\n")
231
- fid.write("$\n")
232
- for block_id in cubit.get_block_id_list():
233
- name = cubit.get_exodus_entity_name("block",block_id)
234
- fid.write("$\n")
235
- fid.write(f"$ Name: {name}\n")
236
- fid.write("$\n")
237
- tet_list = cubit.get_block_tets(block_id)
238
-
239
- if DIM=="3D":
240
- for tet_id in tet_list:
241
- node_list = cubit.get_connectivity('tet',tet_id)
242
- element_id += 1
243
- fid.write(f"CTETRA {element_id:>8}{block_id:>8}{node_list[0]:>8}{node_list[1]:>8}{node_list[2]:>8}{node_list[3]:>8}\n")
244
- hex_list = cubit.get_block_hexes(block_id)
245
- for hex_id in hex_list:
246
- node_list = cubit.get_connectivity('hex',hex_id)
247
- element_id += 1
248
- fid.write(f"CHEXA {element_id:>8}{block_id:>8}{node_list[0]:>8}{node_list[1]:>8}{node_list[2]:>8}{node_list[3]:>8}{node_list[4]:>8}{node_list[5]:>8}+\n+ {node_list[6]:>8}{node_list[7]:>8}\n")
249
- wedge_list = cubit.get_block_wedges(block_id)
250
- for wedge_id in wedge_list:
251
- node_list = cubit.get_connectivity('wedge',wedge_id)
252
- element_id += 1
253
- fid.write(f"CPENTA {element_id:>8}{block_id:>8}{node_list[0]:>8}{node_list[1]:>8}{node_list[2]:>8}{node_list[3]:>8}{node_list[4]:>8}{node_list[5]:>8}\n")
254
- pyramid_list = cubit.get_block_pyramids(block_id)
255
- for pyramid_id in pyramid_list:
256
- node_list = cubit.get_connectivity('pyramid',pyramid_id)
257
- if PYRAM:
258
- element_id += 1
259
- fid.write(f"CPYRAM {element_id:>8}{block_id:>8}{node_list[0]:>8}{node_list[1]:>8}{node_list[2]:>8}{node_list[3]:>8}{node_list[4]:>8}\n")
260
- else:
261
- element_id += 1
262
- fid.write(f"CHEXA {element_id:>8}{block_id:>8}{node_list[0]:>8}{node_list[1]:>8}{node_list[2]:>8}{node_list[3]:>8}{node_list[4]:>8}{node_list[4]:>8}+\n+ {node_list[4]:>8}{node_list[4]:>8}\n")
263
-
264
- tri_list = cubit.get_block_tris(block_id)
265
- for tri_id in tri_list:
266
- node_list = cubit.get_connectivity('tri',tri_id)
267
- element_id += 1
268
- if DIM=="3D":
269
- fid.write(f"CTRIA3 {element_id:<8}{block_id:<8}{node_list[0]:<8}{node_list[1]:<8}{node_list[2]:<8}\n")
270
- else:
271
- surface_id = int(cubit.get_geometry_owner("tri", tri_id).split()[1])
272
- normal = cubit.get_surface_normal(surface_id)
273
- if normal[2] > 0:
274
- fid.write(f"CTRIA3 {element_id:<8}{block_id:<8}{node_list[0]:<8}{node_list[1]:<8}{node_list[2]:<8}\n")
275
- else:
276
- fid.write(f"CTRIA3 {element_id:<8}{block_id:<8}{node_list[0]:<8}{node_list[2]:<8}{node_list[1]:<8}\n")
277
- quad_list = cubit.get_block_faces(block_id)
278
- for quad_id in quad_list:
279
- node_list = cubit.get_connectivity('quad',quad_id)
280
- element_id += 1
281
- if DIM=="3D":
282
- fid.write(f"CQUAD4 {element_id:<8}{block_id:<8}{node_list[0]:<8}{node_list[1]:<8}{node_list[2]:<8}{node_list[3]:<8}\n")
283
- else:
284
- surface_id = int(cubit.get_geometry_owner("quad", quad_id).split()[1])
285
- normal = cubit.get_surface_normal(surface_id)
286
- node_list = cubit.get_connectivity('quad',quad_id)
287
- if normal[2] > 0:
288
- fid.write(f"CQUAD4 {element_id:<8}{block_id:<8}{node_list[0]:<8}{node_list[1]:<8}{node_list[2]:<8}{node_list[3]:<8}\n")
289
- else:
290
- fid.write(f"CQUAD4 {element_id:<8}{block_id:<8}{node_list[0]:<8}{node_list[3]:<8}{node_list[2]:<8}{node_list[1]:<1}\n")
291
- edge_list = cubit.get_block_edges(block_id)
292
- for edge_id in edge_list:
293
- element_id += 1
294
- node_list = cubit.get_connectivity('edge', edge_id)
295
- fid.write(f"CROD {element_id:<8}{block_id:<8}{node_list[0]:<8}{node_list[1]:<8}\n")
296
- node_list = cubit.get_block_nodes(block_id)
297
- for node_id in node_list:
298
- element_id += 1
299
- fid.write(f"CMASS {element_id:<8}{block_id:<8}{node_id:<8}\n")
300
- fid.write("$\n")
301
- fid.write("$ Property cards\n")
302
- fid.write("$\n")
303
-
304
- for block_id in cubit.get_block_id_list():
305
- name = cubit.get_exodus_entity_name("block",block_id)
306
- fid.write("$\n")
307
- fid.write(f"$ Name: {name}\n")
308
- if len(cubit.get_block_nodes(block_id)) > 0:
309
- fid.write(f"PMASS {block_id:< 8}{block_id:< 8}\n")
310
- elif len(cubit.get_block_edges(block_id)) > 0:
311
- fid.write(f"PROD {block_id:< 8}{block_id:< 8}\n")
312
- elif len(cubit.get_block_tris(block_id)) + len(cubit.get_block_faces(block_id))> 0:
313
- fid.write(f"PSHELL {block_id:< 8}{block_id:< 8}\n")
314
- else:
315
- fid.write(f"PSOLID {block_id:< 8}{block_id:< 8}\n")
316
- fid.write("$\n")
317
-
318
- fid.write("ENDDATA\n")
319
- fid.close()
320
- return cubit
321
-
322
- ########################################################################
323
- ### ELF meg file
324
- ########################################################################
325
-
326
- def export_meg(cubit, FileName, DIM='T', MGR2=[]):
327
-
328
- fid = open(FileName,'w',encoding='UTF-8')
329
- fid.write("BOOK MEP 3.50\n")
330
- fid.write("* ELF/MESH VERSION 7.3.0\n")
331
- fid.write("* SOLVER = ELF/MAGIC\n")
332
- fid.write("MGSC 0.001\n")
333
- fid.write("* NODE\n")
334
-
335
- node_list = set()
336
- for block_id in cubit.get_block_id_list():
337
- elem_types = ["hex", "tet", "wedge", "pyramid", "tri", "face", "edge"]
338
- for elem_type in elem_types:
339
- if elem_type == "hex":
340
- func = getattr(cubit, f"get_block_{elem_type}es")
341
- else:
342
- func = getattr(cubit, f"get_block_{elem_type}s")
343
- for element_id in func(block_id):
344
- node_ids = cubit.get_connectivity(elem_type, element_id)
345
- node_list.update(node_ids)
346
- for node_id in node_list:
347
- coord = cubit.get_nodal_coordinates(node_id)
348
- if DIM=='T':
349
- fid.write(f"MGR1 {node_id} 0 {coord[0]} {coord[1]} {coord[2]}\n")
350
- if DIM=='K':
351
- fid.write(f"MGR1 {node_id} 0 {coord[0]} {coord[1]} {0}\n")
352
- if DIM=='R':
353
- fid.write(f"MGR1 {node_id} 0 {coord[0]} {0} {coord[2]}\n")
354
-
355
- element_id = 0
356
- fid.write("* ELEMENT K\n")
357
- for block_id in cubit.get_block_id_list():
358
- name = cubit.get_exodus_entity_name("block",block_id)
359
-
360
- if DIM=='T':
361
- tet_list = cubit.get_block_tets(block_id)
362
- for tet_id in tet_list:
363
- node_list = cubit.get_connectivity('tet',tet_id)
364
- element_id += 1
365
- fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]}\n")
366
-
367
- hex_list = cubit.get_block_hexes(block_id)
368
- for hex_id in hex_list:
369
- node_list = cubit.get_connectivity('hex',hex_id)
370
- element_id += 1
371
- fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[7]}\n")
372
-
373
- wedge_list = cubit.get_block_wedges(block_id)
374
- for wedge_id in wedge_list:
375
- node_list = cubit.get_connectivity('wedge',wedge_id)
376
- element_id += 1
377
- fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]}\n")
378
-
379
- pyramid_list = cubit.get_block_pyramids(block_id)
380
- for pyramid_id in pyramid_list:
381
- node_list = cubit.get_connectivity('pyramid',pyramid_id)
382
- element_id += 1
383
- fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[4]} {node_list[4]} {node_list[4]}\n")
384
-
385
- tri_list = cubit.get_block_tris(block_id)
386
- for tri_id in tri_list:
387
- node_list = cubit.get_connectivity('tri',tri_id)
388
- element_id += 1
389
- fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_list[0]} {node_list[1]} {node_list[2]}\n")
390
-
391
- quad_list = cubit.get_block_faces(block_id)
392
- for quad_id in quad_list:
393
- node_list = cubit.get_connectivity('quad',quad_id)
394
- element_id += 1
395
- fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]}\n")
396
-
397
- edge_list = cubit.get_block_edges(block_id)
398
- for edge_id in edge_list:
399
- node_list = cubit.get_connectivity('edge',edge_id)
400
- element_id += 1
401
- fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_list[0]} {node_list[1]}\n")
402
-
403
- node_list = cubit.get_block_nodes(block_id)
404
- for node_id in node_list:
405
- element_id += 1
406
- fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_id}\n")
407
-
408
- fid.write("* NODE\n")
409
- for node_id in range(len(MGR2)):
410
- fid.write(f"MGR2 {node_id+1} 0 {MGR2[node_id][0]} {MGR2[node_id][1]} {MGR2[node_id][2]}\n")
411
- fid.write("BOOK END\n")
412
- fid.close()
413
- return cubit
414
-
415
- ########################################################################
416
- ### vtk format
417
- ########################################################################
418
-
419
- def export_vtk(cubit, FileName, ORDER="2nd"):
420
-
421
- fid = open(FileName,'w')
422
- fid.write('# vtk DataFile Version 3.0\n')
423
- fid.write(f'Unstructured Grid {FileName}\n')
424
- fid.write('ASCII\n')
425
- fid.write('DATASET UNSTRUCTURED_GRID\n')
426
- fid.write(f'POINTS {cubit.get_node_count()} float\n')
427
-
428
- for node_id in range(cubit.get_node_count()+1):
429
- if cubit.get_node_exists(node_id):
430
- coord = cubit.get_nodal_coordinates(node_id)
431
- fid.write(f'{coord[0]} {coord[1]} {coord[2]}\n')
432
-
433
- hex_list = set()
434
- tet_list = set()
435
- wedge_list = set()
436
- pyramid_list = set()
437
- tri_list = set()
438
- quad_list = set()
439
- edge_list = set()
440
- nodes_list = set()
441
-
442
- for block_id in cubit.get_block_id_list():
443
- tet_list.update(cubit.get_block_tets(block_id))
444
- hex_list.update(cubit.get_block_hexes(block_id))
445
- wedge_list.update(cubit.get_block_wedges(block_id))
446
- pyramid_list.update(cubit.get_block_pyramids(block_id))
447
- tri_list.update(cubit.get_block_tris(block_id))
448
- quad_list.update(cubit.get_block_faces(block_id))
449
- edge_list.update(cubit.get_block_edges(block_id))
450
- nodes_list.update(cubit.get_block_nodes(block_id))
451
-
452
- if ORDER=="2nd":
453
- fid.write(f'CELLS {len(tet_list) + len(hex_list) + len(wedge_list) + len(pyramid_list) + len(tri_list) + len(quad_list) + len(edge_list) + len(nodes_list)} {11*len(tet_list) + 21*len(hex_list) + 16*len(wedge_list) + 14*len(pyramid_list) + 7*len(tri_list) + 9*len(quad_list) + 4*len(edge_list) + 2*len(nodes_list)}\n' )
454
- else:
455
- fid.write(f'CELLS {len(tet_list) + len(hex_list) + len(wedge_list) + len(pyramid_list) + len(tri_list) + len(quad_list) + len(edge_list) + len(nodes_list)} { 5*len(tet_list) + 9*len(hex_list) + 7*len(wedge_list) + 6*len(pyramid_list) + 4*len(tri_list) + 5*len(quad_list) + 3*len(edge_list) + 2*len(nodes_list)}\n' )
456
-
457
- for tet_id in tet_list:
458
- node_list = cubit.get_expanded_connectivity("tet", tet_id)
459
- if len(node_list)==4:
460
- fid.write(f'4 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1}\n')
461
- if len(node_list)==10:
462
- fid.write(f'10 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} {node_list[6]-1} {node_list[7]-1} {node_list[8]-1} {node_list[9]-1}\n')
463
- for hex_id in hex_list:
464
- node_list = cubit.get_expanded_connectivity("hex", hex_id)
465
- if len(node_list)==8:
466
- fid.write(f'8 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} {node_list[6]-1} {node_list[7]-1}\n')
467
- if len(node_list)==20:
468
- fid.write(f'20 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} {node_list[6]-1} {node_list[7]-1} {node_list[8]-1} {node_list[9]-1} {node_list[10]-1} {node_list[11]-1} {node_list[16]-1} {node_list[17]-1} {node_list[18]-1} {node_list[19]-1} {node_list[12]-1} {node_list[13]-1} {node_list[14]-1} {node_list[15]-1}\n')
469
- for wedge_id in wedge_list:
470
- node_list = cubit.get_expanded_connectivity("wedge", wedge_id)
471
- if len(node_list)==6:
472
- fid.write(f'6 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} \n')
473
- if len(node_list)==15:
474
- fid.write(f'15 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} {node_list[6]-1} {node_list[7]-1} {node_list[8]-1} {node_list[12]-1} {node_list[13]-1} {node_list[14]-1} {node_list[9]-1} {node_list[10]-1} {node_list[11]-1} \n')
475
-
476
- for pyramid_id in pyramid_list:
477
- node_list = cubit.get_expanded_connectivity("pyramid", pyramid_id)
478
- if len(node_list)==5:
479
- fid.write(f'5 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} \n')
480
- if len(node_list)==13:
481
- fid.write(f'13 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} {node_list[6]-1} {node_list[7]-1} {node_list[8]-1} {node_list[9]-1} {node_list[10]-1} {node_list[11]-1} {node_list[12]-1} \n')
482
- for tri_id in tri_list:
483
- node_list = cubit.get_expanded_connectivity("tri", tri_id)
484
- if len(node_list)==3:
485
- fid.write(f'3 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} \n')
486
- if len(node_list)==6:
487
- fid.write(f'6 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} \n')
488
- for quad_id in quad_list:
489
- node_list = cubit.get_expanded_connectivity("quad", quad_id)
490
- if len(node_list)==4:
491
- fid.write(f'4 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} \n')
492
- if len(node_list)==8:
493
- fid.write(f'8 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} {node_list[6]-1} {node_list[7]-1}\n')
494
- for edge_id in edge_list:
495
- node_list = cubit.get_expanded_connectivity("edge", edge_id)
496
- if len(node_list)==2:
497
- fid.write(f'2 {node_list[0]-1} {node_list[1]-1} \n')
498
- if len(node_list)==3:
499
- fid.write(f'3 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} \n')
500
- for node_id in nodes_list:
501
- fid.write(f'1 {node_id-1} \n')
502
-
503
- fid.write(f'CELL_TYPES {len(tet_list) + len(hex_list) + len(wedge_list) + len(pyramid_list) + len(tri_list) + len(quad_list) + len(edge_list) + len(nodes_list)}\n')
504
- if ORDER=="2nd":
505
- for tet_id in tet_list:
506
- fid.write('24\n')
507
- for hex_id in hex_list:
508
- fid.write('25\n')
509
- for wedge_id in wedge_list:
510
- fid.write('26\n')
511
- for pyramid_id in pyramid_list:
512
- fid.write('27\n')
513
- for tri_id in tri_list:
514
- fid.write('22\n')
515
- for quad_id in quad_list:
516
- fid.write('23\n')
517
- for edge_id in edge_list:
518
- fid.write('21\n')
519
- for node_id in nodes_list:
520
- fid.write('1\n')
521
- else:
522
- for tet_id in tet_list:
523
- fid.write('10\n')
524
- for hex_id in hex_list:
525
- fid.write('12\n')
526
- for wedge_id in wedge_list:
527
- fid.write('13\n')
528
- for pyramid_id in pyramid_list:
529
- fid.write('14\n')
530
- for tri_id in tri_list:
531
- fid.write('5\n')
532
- for quad_id in quad_list:
533
- fid.write('9\n')
534
- for edge_id in edge_list:
535
- fid.write('3\n')
536
- for node_id in nodes_list:
537
- fid.write('1\n')
538
- fid.write(f'CELL_DATA {len(tet_list) + len(hex_list) + len(wedge_list) + len(pyramid_list) + len(tri_list) + len(quad_list) + len(edge_list) + len(nodes_list)}\n')
539
- fid.write('SCALARS scalars float\n')
540
- fid.write('LOOKUP_TABLE default\n')
541
- for tet_id in tet_list:
542
- fid.write('1\n')
543
- for hex_id in hex_list:
544
- fid.write('2\n')
545
- for wedge_id in wedge_list:
546
- fid.write('3\n')
547
- for pyramid_id in pyramid_list:
548
- fid.write('4\n')
549
- for tri_id in tri_list:
550
- fid.write('5\n')
551
- for quad_id in quad_list:
552
- fid.write('6\n')
553
- for edge_id in edge_list:
554
- fid.write('0\n')
555
- for node_id in nodes_list:
556
- fid.write('-1\n')
557
- return cubit
558
-
1
+ ########################################################################
2
+ ### Gmsh format version 2
3
+ ########################################################################
4
+
5
+ def export_Gmsh_ver2(cubit, FileName: str):
6
+ """Export mesh to Gmsh format version 2.2.
7
+
8
+ Exports 1D, 2D, and 3D mesh elements from Cubit to Gmsh v2.2 format.
9
+ Supports both first-order and second-order elements.
10
+
11
+ Args:
12
+ cubit: Cubit Python interface object
13
+ FileName: Output file path for the .msh file
14
+
15
+ Returns:
16
+ cubit: The cubit object (for method chaining)
17
+
18
+ Supported elements:
19
+ - 1st order: Point, Line, Triangle, Quad, Tetrahedron, Hexahedron, Wedge, Pyramid
20
+ - 2nd order: Line3, Triangle6, Quad8/9, Tetrahedron10/11, Hexahedron20, Wedge15, Pyramid13
21
+ """
22
+ with open(FileName, 'w') as fid:
23
+
24
+ fid.write("$MeshFormat\n")
25
+ fid.write("2.2 0 8\n")
26
+ fid.write("$EndMeshFormat\n")
27
+
28
+ fid.write("$PhysicalNames\n")
29
+ fid.write(f'{cubit.get_block_count()}\n')
30
+ for block_id in cubit.get_block_id_list():
31
+ name = cubit.get_exodus_entity_name("block", block_id)
32
+ if len(cubit.get_block_nodes(block_id)) > 0:
33
+ fid.write(f'0 {block_id} "{name}"\n')
34
+ elif len(cubit.get_block_edges(block_id)) > 0:
35
+ fid.write(f'1 {block_id} "{name}"\n')
36
+ elif len(cubit.get_block_tris(block_id)) + len(cubit.get_block_faces(block_id)) > 0:
37
+ fid.write(f'2 {block_id} "{name}"\n')
38
+ else:
39
+ fid.write(f'3 {block_id} "{name}"\n')
40
+ fid.write('$EndPhysicalNames\n')
41
+
42
+ fid.write("$Nodes\n")
43
+ node_list = set()
44
+ for block_id in cubit.get_block_id_list():
45
+ elem_types = ["hex", "tet", "wedge", "pyramid", "tri", "face", "edge", "node"]
46
+ for elem_type in elem_types:
47
+ if elem_type == "hex":
48
+ func = getattr(cubit, f"get_block_{elem_type}es")
49
+ else:
50
+ func = getattr(cubit, f"get_block_{elem_type}s")
51
+ for element_id in func(block_id):
52
+ node_ids = cubit.get_expanded_connectivity(elem_type, element_id)
53
+ node_list.update(node_ids)
54
+
55
+ fid.write(f'{len(node_list)}\n')
56
+ for node_id in node_list:
57
+ coord = cubit.get_nodal_coordinates(node_id)
58
+ fid.write(f'{node_id} {coord[0]} {coord[1]} {coord[2]}\n')
59
+ fid.write('$EndNodes\n')
60
+
61
+ hex_list = set()
62
+ tet_list = set()
63
+ wedge_list = set()
64
+ pyramid_list = set()
65
+ tri_list = set()
66
+ quad_list = set()
67
+ edge_list = set()
68
+ node_list = set()
69
+
70
+ for block_id in cubit.get_block_id_list():
71
+ tet_list.update(cubit.get_block_tets(block_id))
72
+ hex_list.update(cubit.get_block_hexes(block_id))
73
+ wedge_list.update(cubit.get_block_wedges(block_id))
74
+ pyramid_list.update(cubit.get_block_pyramids(block_id))
75
+ tri_list.update(cubit.get_block_tris(block_id))
76
+ quad_list.update(cubit.get_block_faces(block_id))
77
+ edge_list.update(cubit.get_block_edges(block_id))
78
+ node_list.update(cubit.get_block_nodes(block_id))
79
+
80
+ element_id = 0
81
+ fid.write('$Elements\n')
82
+ fid.write(f'{len(hex_list) + len(tet_list) + len(wedge_list) + len(pyramid_list) + len(tri_list) + len(quad_list) + len(edge_list) + len(node_list)}\n')
83
+
84
+ for block_id in cubit.get_block_id_list():
85
+
86
+ tet_list = cubit.get_block_tets(block_id)
87
+ for tet_id in tet_list:
88
+ element_id += 1
89
+ node_list = cubit.get_expanded_connectivity("tet", tet_id)
90
+ if len(node_list)==4:
91
+ fid.write(f'{element_id} { 4} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]}\n')
92
+ elif len(node_list)==10:
93
+ fid.write(f'{element_id} {11} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[7]} {node_list[9]} {node_list[8]}\n')
94
+ elif len(node_list)==11:
95
+ fid.write(f'{element_id} {35} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[7]} {node_list[9]} {node_list[8]} {node_list[10]}\n')
96
+
97
+ hex_list = cubit.get_block_hexes(block_id)
98
+ for hex_id in hex_list:
99
+ element_id += 1
100
+ node_list = cubit.get_expanded_connectivity("hex", hex_id)
101
+ if len(node_list)==8:
102
+ fid.write(f'{element_id} { 5} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[7]}\n')
103
+ elif len(node_list)==20:
104
+ fid.write(f'{element_id} {17} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[7]} {node_list[8]} {node_list[11]} {node_list[12]} {node_list[9]} {node_list[13]} {node_list[10]} {node_list[14]} {node_list[15]} {node_list[16]} {node_list[19]} {node_list[17]} {node_list[18]}\n')
105
+
106
+ wedge_list = cubit.get_block_wedges(block_id)
107
+ for wedge_id in wedge_list:
108
+ element_id += 1
109
+ node_list = cubit.get_expanded_connectivity("wedge", wedge_id)
110
+ if len(node_list)==6:
111
+ fid.write(f'{element_id} { 6} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]}\n')
112
+ elif len(node_list)==15:
113
+ fid.write(f'{element_id} {18} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[8]} {node_list[9]} {node_list[7]} {node_list[10]} {node_list[11]} {node_list[12]} {node_list[14]} {node_list[13]}\n')
114
+
115
+ pyramid_list = cubit.get_block_pyramids(block_id)
116
+ for pyramid_id in pyramid_list:
117
+ element_id += 1
118
+ node_list = cubit.get_expanded_connectivity("pyramid", pyramid_id)
119
+ if len(node_list)==5:
120
+ fid.write(f'{element_id} { 7} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]}\n')
121
+ elif len(node_list)==13:
122
+ fid.write(f'{element_id} {19} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[8]} {node_list[9]} {node_list[6]} {node_list[10]} {node_list[7]} {node_list[11]} {node_list[12]} \n')
123
+
124
+ tri_list = cubit.get_block_tris(block_id)
125
+ for tri_id in tri_list:
126
+ element_id += 1
127
+ node_list = cubit.get_expanded_connectivity("tri", tri_id)
128
+ if len(node_list)==3:
129
+ fid.write(f'{element_id} { 2} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]}\n')
130
+ elif len(node_list)==6:
131
+ fid.write(f'{element_id} { 9} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]}\n')
132
+ elif len(node_list)==7:
133
+ fid.write(f'{element_id} {42} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]}\n')
134
+
135
+ quad_list = cubit.get_block_faces(block_id)
136
+ for quad_id in quad_list:
137
+ element_id += 1
138
+ node_list = cubit.get_expanded_connectivity("quad", quad_id)
139
+ if len(node_list)==4:
140
+ fid.write(f'{element_id} { 3} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]}\n')
141
+ elif len(node_list)==8:
142
+ fid.write(f'{element_id} {16} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[7]}\n')
143
+ elif len(node_list)==9:
144
+ fid.write(f'{element_id} {10} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[7]} {node_list[8]}\n')
145
+
146
+ edge_list = cubit.get_block_edges(block_id)
147
+ for edge_id in edge_list:
148
+ element_id += 1
149
+ node_list = cubit.get_expanded_connectivity("edge", edge_id)
150
+ if len(node_list)==2:
151
+ fid.write(f'{element_id} {1} {2} {block_id} {block_id} {node_list[0]} {node_list[1]}\n')
152
+ elif len(node_list)==3:
153
+ fid.write(f'{element_id} {8} {2} {block_id} {block_id} {node_list[0]} {node_list[1]} {node_list[2]}\n')
154
+
155
+ node_list = cubit.get_block_nodes(block_id)
156
+ for node_id in node_list:
157
+ element_id += 1
158
+ fid.write(f'{element_id} {15} {2} {block_id} {block_id} {node_id}\n')
159
+
160
+ fid.write('$EndElements\n')
161
+ return cubit
162
+
163
+ ########################################################################
164
+ ### Nastran file
165
+ ########################################################################
166
+
167
+ def export_Nastran(cubit, FileName: str, DIM: str = "3D", PYRAM: bool = True):
168
+ """Export mesh to Nastran format.
169
+
170
+ Exports mesh elements from Cubit to NX Nastran bulk data format.
171
+ Supports 2D and 3D meshes with first-order elements only.
172
+
173
+ Args:
174
+ cubit: Cubit Python interface object
175
+ FileName: Output file path for the .nas or .bdf file
176
+ DIM: Dimension mode - "2D" for 2D meshes, "3D" for 3D meshes (default: "3D")
177
+ PYRAM: If True, export pyramids as CPYRAM; if False, convert to degenerate hex (default: True)
178
+
179
+ Returns:
180
+ cubit: The cubit object (for method chaining)
181
+
182
+ Supported elements:
183
+ - 3D: CTETRA (tet4), CHEXA (hex8), CPENTA (wedge6), CPYRAM (pyramid5)
184
+ - 2D: CTRIA3 (tri3), CQUAD4 (quad4)
185
+ - 1D: CROD (edge/bar)
186
+ - 0D: CMASS (point mass)
187
+
188
+ Note:
189
+ Only first-order elements are supported. Second-order elements are not exported.
190
+ """
191
+ import datetime
192
+ formatted_date_time = datetime.datetime.now().strftime("%d-%b-%y at %H:%M:%S")
193
+ with open(FileName,'w',encoding='UTF-8') as fid:
194
+ fid.write("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n")
195
+ fid.write("$\n")
196
+ fid.write("$ CUBIT NX Nastran Translator\n")
197
+ fid.write("$\n")
198
+ fid.write(f"$ File: {FileName}\n")
199
+ fid.write(f"$ Time Stamp: {formatted_date_time}\n")
200
+ fid.write("$\n")
201
+ fid.write("$\n")
202
+ fid.write("$ PLEASE CHECK YOUR MODEL FOR UNITS CONSISTENCY.\n")
203
+ fid.write("$\n")
204
+ fid.write("$ It should be noted that load ID's from CUBIT may NOT correspond to Nastran SID's\n")
205
+ fid.write("$ The SID's for the load and restraint sets start at one and increment by one:i.e.,1,2,3,4...\n")
206
+ fid.write("$\n")
207
+ fid.write("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n")
208
+ fid.write("$\n")
209
+ fid.write("$\n")
210
+ fid.write("$ -------------------------\n")
211
+ fid.write("$ Executive Control Section\n")
212
+ fid.write("$ -------------------------\n")
213
+ fid.write("$\n")
214
+ fid.write("SOL 101\n")
215
+ fid.write("CEND\n")
216
+ fid.write("$\n")
217
+ fid.write("$\n")
218
+ fid.write("$ --------------------\n")
219
+ fid.write("$ Case Control Section\n")
220
+ fid.write("$ --------------------\n")
221
+ fid.write("$\n")
222
+ fid.write("ECHO = SORT\n")
223
+ fid.write("$\n")
224
+ fid.write("$\n")
225
+ fid.write("$ Name: Initial\n")
226
+ fid.write("$\n")
227
+ fid.write("$\n")
228
+ fid.write("$ Name: Default Set\n")
229
+ fid.write("$\n")
230
+ fid.write("SUBCASE = 1\n")
231
+ fid.write("$\n")
232
+ fid.write("LABEL = Default Set\n")
233
+ fid.write("$\n")
234
+ fid.write("$ -----------------\n")
235
+ fid.write("$ Bulk Data Section\n")
236
+ fid.write("$ -----------------\n")
237
+ fid.write("$\n")
238
+ fid.write("BEGIN BULK\n")
239
+ fid.write("$\n")
240
+ fid.write("$ Params\n")
241
+ fid.write("$\n")
242
+ fid.write("$\n")
243
+ fid.write("$ Node cards\n")
244
+ fid.write("$\n")
245
+
246
+ node_list = set()
247
+ for block_id in cubit.get_block_id_list():
248
+ elem_types = ["hex", "tet", "wedge", "pyramid", "tri", "face", "edge", "node"]
249
+ for elem_type in elem_types:
250
+ if elem_type == "hex":
251
+ func = getattr(cubit, f"get_block_{elem_type}es")
252
+ else:
253
+ func = getattr(cubit, f"get_block_{elem_type}s")
254
+ for element_id in func(block_id):
255
+ node_ids = cubit.get_connectivity(elem_type, element_id)
256
+ node_list.update(node_ids)
257
+ for node_id in node_list:
258
+ coord = cubit.get_nodal_coordinates(node_id)
259
+ if DIM == "3D":
260
+ fid.write(f"GRID* {node_id:>16}{0:>16}{coord[0]:>16.5f}{coord[1]:>16.5f}\n* {coord[2]:>16.5f}\n")
261
+ else:
262
+ fid.write(f"GRID* {node_id:>16}{0:>16}{coord[0]:>16.5f}{coord[1]:>16.5f}\n* {0}\n")
263
+
264
+ element_id = 0
265
+ fid.write("$\n")
266
+ fid.write("$ Element cards\n")
267
+ fid.write("$\n")
268
+ for block_id in cubit.get_block_id_list():
269
+ name = cubit.get_exodus_entity_name("block",block_id)
270
+ fid.write("$\n")
271
+ fid.write(f"$ Name: {name}\n")
272
+ fid.write("$\n")
273
+ tet_list = cubit.get_block_tets(block_id)
274
+
275
+ if DIM=="3D":
276
+ for tet_id in tet_list:
277
+ node_list = cubit.get_connectivity('tet',tet_id)
278
+ element_id += 1
279
+ fid.write(f"CTETRA {element_id:>8}{block_id:>8}{node_list[0]:>8}{node_list[1]:>8}{node_list[2]:>8}{node_list[3]:>8}\n")
280
+ hex_list = cubit.get_block_hexes(block_id)
281
+ for hex_id in hex_list:
282
+ node_list = cubit.get_connectivity('hex',hex_id)
283
+ element_id += 1
284
+ fid.write(f"CHEXA {element_id:>8}{block_id:>8}{node_list[0]:>8}{node_list[1]:>8}{node_list[2]:>8}{node_list[3]:>8}{node_list[4]:>8}{node_list[5]:>8}+\n+ {node_list[6]:>8}{node_list[7]:>8}\n")
285
+ wedge_list = cubit.get_block_wedges(block_id)
286
+ for wedge_id in wedge_list:
287
+ node_list = cubit.get_connectivity('wedge',wedge_id)
288
+ element_id += 1
289
+ fid.write(f"CPENTA {element_id:>8}{block_id:>8}{node_list[0]:>8}{node_list[1]:>8}{node_list[2]:>8}{node_list[3]:>8}{node_list[4]:>8}{node_list[5]:>8}\n")
290
+ pyramid_list = cubit.get_block_pyramids(block_id)
291
+ for pyramid_id in pyramid_list:
292
+ node_list = cubit.get_connectivity('pyramid',pyramid_id)
293
+ if PYRAM:
294
+ element_id += 1
295
+ fid.write(f"CPYRAM {element_id:>8}{block_id:>8}{node_list[0]:>8}{node_list[1]:>8}{node_list[2]:>8}{node_list[3]:>8}{node_list[4]:>8}\n")
296
+ else:
297
+ element_id += 1
298
+ fid.write(f"CHEXA {element_id:>8}{block_id:>8}{node_list[0]:>8}{node_list[1]:>8}{node_list[2]:>8}{node_list[3]:>8}{node_list[4]:>8}{node_list[4]:>8}+\n+ {node_list[4]:>8}{node_list[4]:>8}\n")
299
+
300
+ tri_list = cubit.get_block_tris(block_id)
301
+ for tri_id in tri_list:
302
+ node_list = cubit.get_connectivity('tri',tri_id)
303
+ element_id += 1
304
+ if DIM=="3D":
305
+ fid.write(f"CTRIA3 {element_id:<8}{block_id:<8}{node_list[0]:<8}{node_list[1]:<8}{node_list[2]:<8}\n")
306
+ else:
307
+ surface_id = int(cubit.get_geometry_owner("tri", tri_id).split()[1])
308
+ normal = cubit.get_surface_normal(surface_id)
309
+ if normal[2] > 0:
310
+ fid.write(f"CTRIA3 {element_id:<8}{block_id:<8}{node_list[0]:<8}{node_list[1]:<8}{node_list[2]:<8}\n")
311
+ else:
312
+ fid.write(f"CTRIA3 {element_id:<8}{block_id:<8}{node_list[0]:<8}{node_list[2]:<8}{node_list[1]:<8}\n")
313
+ quad_list = cubit.get_block_faces(block_id)
314
+ for quad_id in quad_list:
315
+ node_list = cubit.get_connectivity('quad',quad_id)
316
+ element_id += 1
317
+ if DIM=="3D":
318
+ fid.write(f"CQUAD4 {element_id:<8}{block_id:<8}{node_list[0]:<8}{node_list[1]:<8}{node_list[2]:<8}{node_list[3]:<8}\n")
319
+ else:
320
+ surface_id = int(cubit.get_geometry_owner("quad", quad_id).split()[1])
321
+ normal = cubit.get_surface_normal(surface_id)
322
+ node_list = cubit.get_connectivity('quad',quad_id)
323
+ if normal[2] > 0:
324
+ fid.write(f"CQUAD4 {element_id:<8}{block_id:<8}{node_list[0]:<8}{node_list[1]:<8}{node_list[2]:<8}{node_list[3]:<8}\n")
325
+ else:
326
+ fid.write(f"CQUAD4 {element_id:<8}{block_id:<8}{node_list[0]:<8}{node_list[3]:<8}{node_list[2]:<8}{node_list[1]:<8}\n")
327
+ edge_list = cubit.get_block_edges(block_id)
328
+ for edge_id in edge_list:
329
+ element_id += 1
330
+ node_list = cubit.get_connectivity('edge', edge_id)
331
+ fid.write(f"CROD {element_id:<8}{block_id:<8}{node_list[0]:<8}{node_list[1]:<8}\n")
332
+ node_list = cubit.get_block_nodes(block_id)
333
+ for node_id in node_list:
334
+ element_id += 1
335
+ fid.write(f"CMASS {element_id:<8}{block_id:<8}{node_id:<8}\n")
336
+ fid.write("$\n")
337
+ fid.write("$ Property cards\n")
338
+ fid.write("$\n")
339
+
340
+ for block_id in cubit.get_block_id_list():
341
+ name = cubit.get_exodus_entity_name("block",block_id)
342
+ fid.write("$\n")
343
+ fid.write(f"$ Name: {name}\n")
344
+ if len(cubit.get_block_nodes(block_id)) > 0:
345
+ fid.write(f"PMASS {block_id:< 8}{block_id:< 8}\n")
346
+ elif len(cubit.get_block_edges(block_id)) > 0:
347
+ fid.write(f"PROD {block_id:< 8}{block_id:< 8}\n")
348
+ elif len(cubit.get_block_tris(block_id)) + len(cubit.get_block_faces(block_id)) > 0:
349
+ fid.write(f"PSHELL {block_id:< 8}{block_id:< 8}\n")
350
+ else:
351
+ fid.write(f"PSOLID {block_id:< 8}{block_id:< 8}\n")
352
+ fid.write("$\n")
353
+
354
+ fid.write("ENDDATA\n")
355
+ return cubit
356
+
357
+ ########################################################################
358
+ ### ELF meg file
359
+ ########################################################################
360
+
361
+ def export_meg(cubit, FileName: str, DIM: str = 'T', MGR2=None):
362
+ """Export mesh to ELF/MESH MEG format.
363
+
364
+ Exports mesh elements from Cubit to ELF/MAGIC MEG format for finite element analysis.
365
+
366
+ Args:
367
+ cubit: Cubit Python interface object
368
+ FileName: Output file path for the .meg file
369
+ DIM: Dimension mode - 'T' for 3D, 'R' for axisymmetric, 'K' for 2D (default: 'T')
370
+ MGR2: Optional list of spatial nodes [[x1,y1,z1], [x2,y2,z2], ...] (default: None)
371
+
372
+ Returns:
373
+ cubit: The cubit object (for method chaining)
374
+
375
+ Supported elements:
376
+ - 3D: Tetrahedron, Hexahedron, Wedge, Pyramid
377
+ - 2D: Triangle, Quadrilateral
378
+ - 1D: Edge
379
+ - 0D: Node
380
+ """
381
+ if MGR2 is None:
382
+ MGR2 = []
383
+
384
+ with open(FileName,'w',encoding='UTF-8') as fid:
385
+ fid.write("BOOK MEP 3.50\n")
386
+ fid.write("* ELF/MESH VERSION 7.3.0\n")
387
+ fid.write("* SOLVER = ELF/MAGIC\n")
388
+ fid.write("MGSC 0.001\n")
389
+ fid.write("* NODE\n")
390
+
391
+ node_list = set()
392
+ for block_id in cubit.get_block_id_list():
393
+ elem_types = ["hex", "tet", "wedge", "pyramid", "tri", "face", "edge"]
394
+ for elem_type in elem_types:
395
+ if elem_type == "hex":
396
+ func = getattr(cubit, f"get_block_{elem_type}es")
397
+ else:
398
+ func = getattr(cubit, f"get_block_{elem_type}s")
399
+ for element_id in func(block_id):
400
+ node_ids = cubit.get_connectivity(elem_type, element_id)
401
+ node_list.update(node_ids)
402
+ for node_id in node_list:
403
+ coord = cubit.get_nodal_coordinates(node_id)
404
+ if DIM=='T':
405
+ fid.write(f"MGR1 {node_id} 0 {coord[0]} {coord[1]} {coord[2]}\n")
406
+ if DIM=='K':
407
+ fid.write(f"MGR1 {node_id} 0 {coord[0]} {coord[1]} {0}\n")
408
+ if DIM=='R':
409
+ fid.write(f"MGR1 {node_id} 0 {coord[0]} {0} {coord[2]}\n")
410
+
411
+ element_id = 0
412
+ fid.write("* ELEMENT K\n")
413
+ for block_id in cubit.get_block_id_list():
414
+ name = cubit.get_exodus_entity_name("block",block_id)
415
+
416
+ if DIM=='T':
417
+ tet_list = cubit.get_block_tets(block_id)
418
+ for tet_id in tet_list:
419
+ node_list = cubit.get_connectivity('tet',tet_id)
420
+ element_id += 1
421
+ fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]}\n")
422
+
423
+ hex_list = cubit.get_block_hexes(block_id)
424
+ for hex_id in hex_list:
425
+ node_list = cubit.get_connectivity('hex',hex_id)
426
+ element_id += 1
427
+ fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]} {node_list[6]} {node_list[7]}\n")
428
+
429
+ wedge_list = cubit.get_block_wedges(block_id)
430
+ for wedge_id in wedge_list:
431
+ node_list = cubit.get_connectivity('wedge',wedge_id)
432
+ element_id += 1
433
+ fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]}\n")
434
+
435
+ pyramid_list = cubit.get_block_pyramids(block_id)
436
+ for pyramid_id in pyramid_list:
437
+ node_list = cubit.get_connectivity('pyramid',pyramid_id)
438
+ element_id += 1
439
+ fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[4]} {node_list[4]} {node_list[4]}\n")
440
+
441
+ tri_list = cubit.get_block_tris(block_id)
442
+ for tri_id in tri_list:
443
+ node_list = cubit.get_connectivity('tri',tri_id)
444
+ element_id += 1
445
+ fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_list[0]} {node_list[1]} {node_list[2]}\n")
446
+
447
+ quad_list = cubit.get_block_faces(block_id)
448
+ for quad_id in quad_list:
449
+ node_list = cubit.get_connectivity('quad',quad_id)
450
+ element_id += 1
451
+ fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]}\n")
452
+
453
+ edge_list = cubit.get_block_edges(block_id)
454
+ for edge_id in edge_list:
455
+ node_list = cubit.get_connectivity('edge',edge_id)
456
+ element_id += 1
457
+ fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_list[0]} {node_list[1]}\n")
458
+
459
+ node_list = cubit.get_block_nodes(block_id)
460
+ for node_id in node_list:
461
+ element_id += 1
462
+ fid.write(f"{name[0:4]}{DIM} {element_id} 0 {block_id} {node_id}\n")
463
+
464
+ fid.write("* NODE\n")
465
+ for node_id in range(len(MGR2)):
466
+ fid.write(f"MGR2 {node_id+1} 0 {MGR2[node_id][0]} {MGR2[node_id][1]} {MGR2[node_id][2]}\n")
467
+ fid.write("BOOK END\n")
468
+ return cubit
469
+
470
+ ########################################################################
471
+ ### vtk format
472
+ ########################################################################
473
+
474
+ def export_vtk(cubit, FileName: str, ORDER: str = "2nd"):
475
+ """Export mesh to Legacy VTK format.
476
+
477
+ Exports mesh elements from Cubit to VTK (Visualization Toolkit) Legacy format.
478
+ Supports both first-order and second-order elements.
479
+
480
+ Args:
481
+ cubit: Cubit Python interface object
482
+ FileName: Output file path for the .vtk file
483
+ ORDER: Element order - "2nd" for second-order elements, "1st" for first-order (default: "2nd")
484
+
485
+ Returns:
486
+ cubit: The cubit object (for method chaining)
487
+
488
+ Supported elements:
489
+ - 1st order: Tet4, Hex8, Wedge6, Pyramid5, Triangle3, Quad4, Line2, Point
490
+ - 2nd order: Tet10, Hex20, Wedge15, Pyramid13, Triangle6, Quad8, Line3
491
+
492
+ Note:
493
+ VTK cell data includes scalar values to distinguish element types.
494
+ """
495
+ with open(FileName,'w') as fid:
496
+ fid.write('# vtk DataFile Version 3.0\n')
497
+ fid.write(f'Unstructured Grid {FileName}\n')
498
+ fid.write('ASCII\n')
499
+ fid.write('DATASET UNSTRUCTURED_GRID\n')
500
+ fid.write(f'POINTS {cubit.get_node_count()} float\n')
501
+
502
+ for node_id in range(cubit.get_node_count()+1):
503
+ if cubit.get_node_exists(node_id):
504
+ coord = cubit.get_nodal_coordinates(node_id)
505
+ fid.write(f'{coord[0]} {coord[1]} {coord[2]}\n')
506
+
507
+ hex_list = set()
508
+ tet_list = set()
509
+ wedge_list = set()
510
+ pyramid_list = set()
511
+ tri_list = set()
512
+ quad_list = set()
513
+ edge_list = set()
514
+ nodes_list = set()
515
+
516
+ for block_id in cubit.get_block_id_list():
517
+ tet_list.update(cubit.get_block_tets(block_id))
518
+ hex_list.update(cubit.get_block_hexes(block_id))
519
+ wedge_list.update(cubit.get_block_wedges(block_id))
520
+ pyramid_list.update(cubit.get_block_pyramids(block_id))
521
+ tri_list.update(cubit.get_block_tris(block_id))
522
+ quad_list.update(cubit.get_block_faces(block_id))
523
+ edge_list.update(cubit.get_block_edges(block_id))
524
+ nodes_list.update(cubit.get_block_nodes(block_id))
525
+
526
+ if ORDER=="2nd":
527
+ fid.write(f'CELLS {len(tet_list) + len(hex_list) + len(wedge_list) + len(pyramid_list) + len(tri_list) + len(quad_list) + len(edge_list) + len(nodes_list)} {11*len(tet_list) + 21*len(hex_list) + 16*len(wedge_list) + 14*len(pyramid_list) + 7*len(tri_list) + 9*len(quad_list) + 4*len(edge_list) + 2*len(nodes_list)}\n' )
528
+ else:
529
+ fid.write(f'CELLS {len(tet_list) + len(hex_list) + len(wedge_list) + len(pyramid_list) + len(tri_list) + len(quad_list) + len(edge_list) + len(nodes_list)} { 5*len(tet_list) + 9*len(hex_list) + 7*len(wedge_list) + 6*len(pyramid_list) + 4*len(tri_list) + 5*len(quad_list) + 3*len(edge_list) + 2*len(nodes_list)}\n' )
530
+
531
+ for tet_id in tet_list:
532
+ node_list = cubit.get_expanded_connectivity("tet", tet_id)
533
+ if len(node_list)==4:
534
+ fid.write(f'4 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1}\n')
535
+ elif len(node_list)==10:
536
+ fid.write(f'10 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} {node_list[6]-1} {node_list[7]-1} {node_list[8]-1} {node_list[9]-1}\n')
537
+ for hex_id in hex_list:
538
+ node_list = cubit.get_expanded_connectivity("hex", hex_id)
539
+ if len(node_list)==8:
540
+ fid.write(f'8 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} {node_list[6]-1} {node_list[7]-1}\n')
541
+ elif len(node_list)==20:
542
+ fid.write(f'20 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} {node_list[6]-1} {node_list[7]-1} {node_list[8]-1} {node_list[9]-1} {node_list[10]-1} {node_list[11]-1} {node_list[16]-1} {node_list[17]-1} {node_list[18]-1} {node_list[19]-1} {node_list[12]-1} {node_list[13]-1} {node_list[14]-1} {node_list[15]-1}\n')
543
+ for wedge_id in wedge_list:
544
+ node_list = cubit.get_expanded_connectivity("wedge", wedge_id)
545
+ if len(node_list)==6:
546
+ fid.write(f'6 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} \n')
547
+ elif len(node_list)==15:
548
+ fid.write(f'15 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} {node_list[6]-1} {node_list[7]-1} {node_list[8]-1} {node_list[12]-1} {node_list[13]-1} {node_list[14]-1} {node_list[9]-1} {node_list[10]-1} {node_list[11]-1} \n')
549
+
550
+ for pyramid_id in pyramid_list:
551
+ node_list = cubit.get_expanded_connectivity("pyramid", pyramid_id)
552
+ if len(node_list)==5:
553
+ fid.write(f'5 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} \n')
554
+ elif len(node_list)==13:
555
+ fid.write(f'13 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} {node_list[6]-1} {node_list[7]-1} {node_list[8]-1} {node_list[9]-1} {node_list[10]-1} {node_list[11]-1} {node_list[12]-1} \n')
556
+ for tri_id in tri_list:
557
+ node_list = cubit.get_expanded_connectivity("tri", tri_id)
558
+ if len(node_list)==3:
559
+ fid.write(f'3 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} \n')
560
+ elif len(node_list)==6:
561
+ fid.write(f'6 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} \n')
562
+ for quad_id in quad_list:
563
+ node_list = cubit.get_expanded_connectivity("quad", quad_id)
564
+ if len(node_list)==4:
565
+ fid.write(f'4 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} \n')
566
+ elif len(node_list)==8:
567
+ fid.write(f'8 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} {node_list[3]-1} {node_list[4]-1} {node_list[5]-1} {node_list[6]-1} {node_list[7]-1}\n')
568
+ for edge_id in edge_list:
569
+ node_list = cubit.get_expanded_connectivity("edge", edge_id)
570
+ if len(node_list)==2:
571
+ fid.write(f'2 {node_list[0]-1} {node_list[1]-1} \n')
572
+ elif len(node_list)==3:
573
+ fid.write(f'3 {node_list[0]-1} {node_list[1]-1} {node_list[2]-1} \n')
574
+ for node_id in nodes_list:
575
+ fid.write(f'1 {node_id-1} \n')
576
+
577
+ fid.write(f'CELL_TYPES {len(tet_list) + len(hex_list) + len(wedge_list) + len(pyramid_list) + len(tri_list) + len(quad_list) + len(edge_list) + len(nodes_list)}\n')
578
+ if ORDER=="2nd":
579
+ for tet_id in tet_list:
580
+ fid.write('24\n')
581
+ for hex_id in hex_list:
582
+ fid.write('25\n')
583
+ for wedge_id in wedge_list:
584
+ fid.write('26\n')
585
+ for pyramid_id in pyramid_list:
586
+ fid.write('27\n')
587
+ for tri_id in tri_list:
588
+ fid.write('22\n')
589
+ for quad_id in quad_list:
590
+ fid.write('23\n')
591
+ for edge_id in edge_list:
592
+ fid.write('21\n')
593
+ for node_id in nodes_list:
594
+ fid.write('1\n')
595
+ else:
596
+ for tet_id in tet_list:
597
+ fid.write('10\n')
598
+ for hex_id in hex_list:
599
+ fid.write('12\n')
600
+ for wedge_id in wedge_list:
601
+ fid.write('13\n')
602
+ for pyramid_id in pyramid_list:
603
+ fid.write('14\n')
604
+ for tri_id in tri_list:
605
+ fid.write('5\n')
606
+ for quad_id in quad_list:
607
+ fid.write('9\n')
608
+ for edge_id in edge_list:
609
+ fid.write('3\n')
610
+ for node_id in nodes_list:
611
+ fid.write('1\n')
612
+ fid.write(f'CELL_DATA {len(tet_list) + len(hex_list) + len(wedge_list) + len(pyramid_list) + len(tri_list) + len(quad_list) + len(edge_list) + len(nodes_list)}\n')
613
+ fid.write('SCALARS scalars float\n')
614
+ fid.write('LOOKUP_TABLE default\n')
615
+ for tet_id in tet_list:
616
+ fid.write('1\n')
617
+ for hex_id in hex_list:
618
+ fid.write('2\n')
619
+ for wedge_id in wedge_list:
620
+ fid.write('3\n')
621
+ for pyramid_id in pyramid_list:
622
+ fid.write('4\n')
623
+ for tri_id in tri_list:
624
+ fid.write('5\n')
625
+ for quad_id in quad_list:
626
+ fid.write('6\n')
627
+ for edge_id in edge_list:
628
+ fid.write('0\n')
629
+ for node_id in nodes_list:
630
+ fid.write('-1\n')
631
+ return cubit
632
+