Coreform-Cubit-Mesh-Export 1.0.4__py3-none-any.whl → 1.1.1__py3-none-any.whl

sample_script/cubit_mesh_export_2d_geo_lukas_format.py

@@ -0,0 +1,77 @@
+########################################################################
+###	Lukas FEM 2D file
+########################################################################
+
+def export_2D_geo_mesh(cubit, FileName):
+
+	import numpy
+	import scipy.io
+
+	nodes = []
+	node_list = []
+
+	N = cubit.get_node_count()
+	M = cubit.get_tri_count()
+
+	node_list = set()
+	for block_id in cubit.get_block_id_list():
+		elem_types = ["hex", "tet", "wedge", "pyramid"]
+		for elem_type in elem_types:
+			if elem_type == "hex":
+				func = getattr(cubit, f"get_block_{elem_type}es")
+			else:
+				func = getattr(cubit, f"get_block_{elem_type}s")
+			for element_id in func(block_id):
+				node_ids = cubit.get_connectivity(elem_type, element_id)
+				node_list.update(node_ids)
+	for node_id in node_list:
+		coord = cubit.get_nodal_coordinates(node_id)
+		nodes.append([coord[0],coord[1]])
+
+	for nodeset_id in cubit.get_nodeset_id_list():
+		name = cubit.get_exodus_entity_name("nodeset",nodeset_id)
+		curve_list = cubit.get_nodeset_curves(nodeset_id)
+		node_list = []
+		for curve_id in curve_list:
+			node_list += cubit.get_curve_nodes(curve_id)
+		nodeset = numpy.array([(name, node_list)], dtype=[('name', 'U20'), ('DBCnodes', 'O')])
+		try:
+			nodesets = append(nodesets,nodeset)
+		except:
+			nodesets = nodeset
+
+	conn_matrix = numpy.zeros((M,3))
+	center_x = numpy.zeros((M))
+	center_y = numpy.zeros((M))
+	block_count = cubit.get_block_count()
+	regions = numpy.rec.array([("", [], [])]*(block_count), dtype=[('name', 'U20'), ('Elements', 'O'), ('Nodes', 'O')])
+
+	for block_id in cubit.get_block_id_list():
+		Elements = []
+		name = cubit.get_exodus_entity_name("block",block_id)
+		surface_list = cubit.get_block_surfaces(block_id)
+		Nodes = []
+		Elements = []
+		for surface_id in surface_list:
+			tri_list = cubit.get_surface_tris(surface_id)
+			Elements	+= tri_list
+			for tri_id in tri_list:
+				x = []
+				y = []
+				node_list = cubit.get_connectivity('tri',tri_id)
+				Nodes += node_list
+				conn_matrix[tri_id-1,:] = node_list
+				for node_id in node_list:
+					coord = cubit.get_nodal_coordinates(node_id)
+					x.append(coord[0])
+					y.append(coord[1])
+				center_x[tri_id-1] = numpy.mean(x)
+				center_y[tri_id-1] = numpy.mean(y)
+		regions[block_id-1][0] = name
+		regions[block_id-1][1] = Elements
+		regions[block_id-1][2] = Nodes
+
+	geo = {'conn_matrix':conn_matrix, 'nodes':nodes, 'M':M, 'N':N, 'nodesets':nodesets , 'center_x':center_x, 'center_y':center_y, 'regions':regions }
+	scipy.io.savemat(FileName, {'geo': geo}, format='5', long_field_names=True)
+	return cubit
+

sample_script/cubit_mesh_export_3d_cdb.py

@@ -0,0 +1,115 @@
+########################################################################
+###	3D CDB file
+########################################################################
+
+def export_3D_CDB(cubit, FileName):
+
+	fid = open(FileName,'w',encoding='UTF-8')
+	fid.write(f'/COM,ANSYS RELEASE 15.0\n')
+	fid.write(f'! Exported from Coreform Cubit 2024.3\n')
+	fid.write(f'! {datetime.now().strftime("%Y/%m/%d %I:%M:%S %p")}\n')
+	fid.write(f'/PREP7\n')
+	fid.write(f'/TITLE,\n')
+	fid.write(f'*IF,_CDRDOFF,EQ,1,THEN\n')
+	fid.write(f'_CDRDOFF= \n')
+	fid.write(f'*ELSE\n')
+	fid.write(f'NUMOFF,NODE, {node_count:8d}\n')
+	fid.write(f'NUMOFF,ELEM, {elem_count:8d}\n')
+	fid.write(f'NUMOFF,TYPE,        1\n')
+	fid.write(f'*ENDIF\n')
+	fid.write(f'DOF,DELETE\n')
+	fid.write(f'ET,       1,185\n')
+	fid.write(f'NBLOCK,6,SOLID,  {node_count:8d},  {node_count:8d}\n')
+	fid.write(f'(3i9,6e20.13)\n')
+
+	node_list = set()
+	for block_id in cubit.get_block_id_list():
+		elem_types = ["hex", "tet", "wedge", "pyramid"]
+		for elem_type in elem_types:
+			if elem_type == "hex":
+				func = getattr(cubit, f"get_block_{elem_type}es")
+			else:
+				func = getattr(cubit, f"get_block_{elem_type}s")
+			for element_id in func(block_id):
+				node_ids = cubit.get_connectivity(elem_type, element_id)
+				node_list.update(node_ids)
+	fid.write(f'{len(node_list)}\n')
+	for node_id in node_list:
+		coord = cubit.get_nodal_coordinates(node_id)
+		fid.write(f'{node_id:9d}{0:9d}{0:9d}{coord[0]:20.13e}{coord[1]:20.13e}{coord[2]:20.13e}\n')
+
+	fid.write(f'N,R5.3,LOC, -1\n')
+	elem_count = 0
+	for block_id in cubit.get_block_id_list():
+		fid.write(f'EBLOCK, 19, SOLID\n')
+		fid.write(f'(19i9)\n')
+		for volume_id in cubit.get_block_volumes(block_id):
+			hex_list = cubit.get_volume_hexes(volume_id)
+			if len(hex_list)>0:
+				for hex_id in hex_list:
+					elem_count += 1
+					node_list = cubit.get_connectivity("hex", hex_id)
+					fid.write(f'{block_id:9d}{1:9d}{1:9d}{1:9d}{0:9d}{0:9d}{0:9d}{0:9d}{8:9d}{0:9d}{elem_count:9d}{node_list[0]:9d}{node_list[1]:9d}{node_list[2]:9d}{node_list[3]:9d}{node_list[4]:9d}{node_list[5]:9d}{node_list[6]:9d}{node_list[7]:9d}\n')
+			wedge_list = cubit.get_volume_wedges(volume_id)
+			if len(wedge_list)>0:
+				for wedge_id in wedge_list:
+					elem_count += 1
+					node_list = cubit.get_connectivity("wedge", wedge_id)
+					fid.write(f'{block_id:9d}{1:9d}{1:9d}{1:9d}{0:9d}{0:9d}{0:9d}{0:9d}{8:9d}{0:9d}{elem_count:9d}{node_list[0]:9d}{node_list[1]:9d}{node_list[2]:9d}{node_list[2]:9d}{node_list[3]:9d}{node_list[4]:9d}{node_list[5]:9d}{node_list[5]:9d}\n')
+			tet_list = cubit.get_volume_tets(volume_id)
+			if len(tet_list)>0:
+				for tet_id in tet_list:
+					elem_count += 1
+					node_list = cubit.get_connectivity("tet", tet_id)
+					fid.write(f'{block_id:9d}{1:9d}{1:9d}{1:9d}{0:9d}{0:9d}{0:9d}{0:9d}{8:9d}{0:9d}{elem_count:9d}{node_list[0]:9d}{node_list[1]:9d}{node_list[2]:9d}{node_list[2]:9d}{node_list[3]:9d}{node_list[3]:9d}{node_list[3]:9d}{node_list[3]:9d}\n')
+			pyramid_list = cubit.get_volume_pyramids(volume_id)
+			if len(pyramid_list)>0:
+				for pyramid_id in pyramid_list:
+					elem_count += 1
+					node_list = cubit.get_connectivity("pyramid", pyramid_id)
+					fid.write(f'{block_id:9d}{1:9d}{1:9d}{1:9d}{0:9d}{0:9d}{0:9d}{0:9d}{8:9d}{0:9d}{elem_count:9d}{node_list[0]:9d}{node_list[1]:9d}{node_list[2]:9d}{node_list[3]:9d}{node_list[4]:9d}{node_list[4]:9d}{node_list[4]:9d}{node_list[4]:9d}\n')
+		fid.write(f'       -1\n')
+
+	for block_id in cubit.get_block_id_list():
+		name = cubit.get_exodus_entity_name("block",block_id)
+		elem_list = []
+		volume_list = cubit.get_block_volumes(block_id)
+		for volume_id in volume_list:
+			hex_list = cubit.get_volume_hexes(volume_id)
+			elem_list.extend(hex_list)
+			wedge_list = cubit.get_volume_wedges(volume_id)
+			elem_list.extend(wedge_list)
+			tet_list = cubit.get_volume_tets(volume_id)
+			elem_list.extend(tet_list)
+			pyramid_list = cubit.get_volume_pyramids(volume_id)
+			elem_list.extend(pyramid_list)
+		fid.write(f'CMBLOCK,{name:<8},ELEM,{len(elem_list):8d}\n')
+		fid.write(f'(8i10)\n')
+		for n in range(0, len(elem_list), 8):
+			strLine = ""
+			for m in range(n, min(n+8, len(elem_list))):
+				strLine += f'{elem_list[m]:10d}'
+			fid.write(f'{strLine}\n')
+
+	for nodeset_id in cubit.get_nodeset_id_list():
+		name = cubit.get_exodus_entity_name("nodeset",nodeset_id)
+
+		node_list.clear()
+		for block_id in cubit.get_block_id_list():
+			elem_types = ["tri", "quad"]
+			for elem_type in elem_types:
+				func = getattr(cubit, f"get_block_{elem_type}s")
+				for element_id in func(block_id):
+					node_ids = cubit.get_connectivity(elem_type, element_id)
+					node_list.update(node_ids)
+
+		fid.write(f'CMBLOCK,{name:<8},NODE,{len(node_list):8d}\n')
+		fid.write(f'(8i10)\n')
+		node_list = list(node_list)
+		for n in range(0, len(node_list), 8):
+			strLine = ""
+			for m in range(n, min(n+8, len(node_list))):
+				strLine += f'{node_list[m]:10d}'
+			fid.write(f'{strLine}\n')
+	return cubit
+

sample_script/cubit_mesh_export_3d_freefem_mesh.py

@@ -0,0 +1,59 @@
+########################################################################
+###	FreeFEM mesh format
+########################################################################
+
+def export_3D_mesh(cubit, FileName):
+
+	block_count = cubit.get_block_count()
+	block_list = cubit.get_block_id_list()
+	node_count = cubit.get_node_count()
+
+	with open(FileName, 'w') as fid:
+		fid.write("MeshVersionFormatted 2\n")
+		fid.write("\n")
+		fid.write("Dimension 3\n")
+		fid.write("\n")
+		fid.write("Vertices\n")
+		fid.write(f'{node_count}\n')
+		node_list = set()
+		for block_id in cubit.get_block_id_list():
+			elem_types = ["hex", "tet", "wedge", "pyramid", "tri", "face"]
+			for elem_type in elem_types:
+				if elem_type == "hex":
+					func = getattr(cubit, f"get_block_{elem_type}es")
+				else:
+					func = getattr(cubit, f"get_block_{elem_type}s")
+				for element_id in func(block_id):
+					node_ids = cubit.get_connectivity(elem_type, element_id)
+					node_list.update(node_ids)
+		for node_id in node_list:
+			coord = cubit.get_nodal_coordinates(node_id)
+			fid.write(f'{coord[0]} {coord[1]} {coord[2]} {0}\n')
+		fid.write("\n")
+		fid.write("Tetrahedra\n")
+		tet_list = set()
+		for block_id in cubit.get_block_id_list():
+			tet_list.update(cubit.get_block_tets(block_id))
+		fid.write(f'{len(tet_list)}\n')
+		for block_id in cubit.get_block_id_list():
+			tet_list = cubit.get_block_tets(block_id)
+			if len(tet_list)>0:
+				for tet_id in tet_list:
+					node_list = cubit.get_connectivity("tet", tet_id)
+					fid.write(f'{node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {block_id}\n')
+
+		fid.write("Triangles\n")
+		tri_list = set()
+		for block_id in cubit.get_block_id_list():
+			tri_list.update(cubit.get_block_tris(block_id))
+		fid.write(f'{len(tri_list)}\n')
+		for block_id in cubit.get_block_id_list():
+			tet_list = cubit.get_block_tets(block_id)
+			if len(tri_list)>0:
+				for tri_id in tri_list:
+					node_list = cubit.get_connectivity("tri", tri_id)
+					fid.write(f'{node_list[0]} {node_list[1]} {node_list[2]} {block_id}\n')
+		fid.write("\n")
+		fid.write("End\n")
+		fid.close()
+	return cubit

sample_script/cubit_mesh_export_3d_gmesh_v4.py

@@ -0,0 +1,191 @@
+########################################################################
+###	Gmsh format version 4
+########################################################################
+
+def export_3D_gmsh_ver4(cubit, FileName):
+
+
+	with open(FileName, 'w') as fid:
+
+		fid.write('$MeshFormat\n')
+		fid.write('4.1 0 8\n')
+		fid.write('$EndMeshFormat\n')
+
+		n_block_1d = 0
+		n_block_2d = 0
+		n_block_3d = 0
+
+		fid.write('$PhysicalNames\n')
+		fid.write(f'{cubit.get_block_count()}\n')
+		for block_id in cubit.get_block_id_list():
+			if len(cubit.get_block_edgess(block_id)) > 0:
+				fid.write(f'1 {block_id} "{name}"\n')
+				n_block_1d += 1
+			elif len(cubit.get_block_tris(block_id)) + len(cubit.get_block_faces(block_id))> 0:
+				fid.write(f'2 {block_id} "{name}"\n')
+				n_block_2d += 1
+			else:
+				fid.write(f'3 {block_id} "{name}"\n')
+				n_block_3d += 1
+		fid.write('$EndPhysicalNames\n')
+		fid.write('$Entities\n')
+		fid.write(f'{0} {n_block_1d} {n_block_2d} {n_block_3d}\n')
+
+		for nodeset_id in cubit.get_nodeset_id_list():
+			surface_list = cubit.get_nodeset_surfaces(nodeset_id)
+			for surface_id in surface_list:
+				bounding_box = cubit.get_bounding_box("surface", surface_id)
+				minx = bounding_box[0]
+				maxx = bounding_box[1]
+				miny = bounding_box[3]
+				maxy = bounding_box[4]
+				minz = bounding_box[6]
+				maxz = bounding_box[7]
+				fid.write(f'{surface_id} {minx} {miny} {minz} {maxx} {maxy} {maxz} {1} {nodeset_id} {0}\n')
+
+		for block_id in cubit.get_block_id_list():
+			for volume_id in cubit.get_block_volumes(block_id):
+				bounding_box = cubit.get_bounding_box("volume", volume_id)
+				minx = bounding_box[0]
+				maxx = bounding_box[1]
+				miny = bounding_box[3]
+				maxy = bounding_box[4]
+				minz = bounding_box[6]
+				maxz = bounding_box[7]
+				fid.write(f'{volume_id} {minx} {miny} {minz} {maxx} {maxy} {maxz} {1} {block_id} {nodeset_surface_count}')
+				for nodeset_id in cubit.get_nodeset_id_list():
+					surface_list = cubit.get_nodeset_surfaces(nodeset_id)
+					for surface_id in surface_list:
+						fid.write(f' {surface_id}')
+				fid.write(f'\n')
+
+		fid.write('$EndEntities\n')
+
+		counts = 0
+		node_all_set = set()
+		for nodeset_id in cubit.get_nodeset_id_list():
+			surface_list = cubit.get_nodeset_surfaces(nodeset_id)
+			for surface_id in surface_list:
+				node_list = cubit.get_surface_nodes(surface_id)
+				if len(node_list) > 0:
+					node_all_set.update(node_list)
+					counts += 1
+
+		for block_id in cubit.get_block_id_list():
+			for volume_id in cubit.get_block_volumes(block_id):
+				node_list = cubit.parse_cubit_list( "node", f"in volume {volume_id}" )
+				if len(node_list) > 0:
+					node_all_set.update(node_list)
+					counts += 1
+
+		fid.write('$Nodes\n')
+		fid.write(f'{counts} {len(node_all_set)} {min(node_all_set)} {max(node_all_set)}\n')
+
+		node_all_set.clear()
+
+		for nodeset_id in cubit.get_nodeset_id_list():
+			surface_list = cubit.get_nodeset_surfaces(nodeset_id)
+			for surface_id in surface_list:
+				node_list = cubit.get_surface_nodes(surface_id)
+				node_list = set(node_list) - node_all_set
+				if len(node_list) > 0:
+					node_all_set.update(node_list)
+					fid.write(f'2 {surface_id} 0 {len(node_list)}\n')
+					for node_id in node_list:
+						fid.write(f'{node_id}\n')
+					for node_id in node_list:
+						coord = cubit.get_nodal_coordinates(node_id)
+						fid.write(f'{coord[0]} {coord[1]} {coord[2]}\n')
+
+		for block_id in cubit.get_block_id_list():
+			for volume_id in cubit.get_block_volumes(block_id):
+				node_list = cubit.parse_cubit_list( "node", f"in volume {volume_id}" )
+				node_list = set(node_list) - node_all_set
+				if len(node_list) > 0:
+					node_all_set.update(node_list)
+					fid.write(f'3 {volume_id} 0 {len(node_list)}\n')
+					for node_id in node_list:
+						fid.write(f'{node_id}\n')
+					for node_id in node_list:
+						coord = cubit.get_nodal_coordinates(node_id)
+						fid.write(f'{coord[0]} {coord[1]} {coord[2]}\n')
+
+		fid.write('$EndNodes\n')
+
+		tri_all_list = []
+		quad_all_list = []
+		tet_all_list = []
+		hex_all_list = []
+		wedge_all_list = []
+
+		fid.write('$Elements\n')
+
+		for nodeset_id in cubit.get_nodeset_id_list():
+			surface_list = cubit.get_nodeset_surfaces(nodeset_id)
+			for surface_id in surface_list:
+				tri_all_list += cubit.get_surface_tris(surface_id)
+				quad_all_list += cubit.get_surface_quads(surface_id)
+
+		for block_id in cubit.get_block_id_list():
+			for volume_id in cubit.get_block_volumes(block_id):
+				tet_all_list += cubit.get_volume_tets(volume_id)
+				hex_all_list += cubit.get_volume_hexes(volume_id)
+				wedge_all_list += cubit.get_volume_wedges(volume_id)
+
+		elementTag = 1
+
+		all_list =  quad_all_list + tri_all_list + hex_all_list + tet_all_list  + wedge_all_list
+		if len(all_list) > 0:
+			fid.write(f'{ nodeset_surface_count + block_volume_count} {len(all_list)} {min(all_list)} {max(all_list)}\n')
+		else:
+			fid.write(f'{ nodeset_surface_count + block_volume_count} 0 0 0\n')
+
+		for nodeset_id in cubit.get_nodeset_id_list():
+			surface_list = cubit.get_nodeset_surfaces(nodeset_id)
+			for surface_id in surface_list:
+				tri_list = cubit.get_surface_tris(surface_id)
+				if len(tri_list)>0:
+					fid.write(f'2 {surface_id} 2 {len(tri_list)}\n')
+					for tri_id in tri_list:
+						node_list = cubit.get_connectivity("tri", tri_id)
+						elementTag +=1
+						fid.write(f'{elementTag} {node_list[0]} {node_list[1]} {node_list[2]}\n')
+
+				quad_list = cubit.get_surface_quads(surface_id)
+				if len(quad_list)>0:
+					fid.write(f'2 {surface_id} 3 {len(quad_list)}\n')
+					for quad_id in quad_list:
+						node_list = cubit.get_connectivity("quad", quad_id)
+						elementTag +=1
+						fid.write(f'{elementTag} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]}\n')
+
+		for block_id in cubit.get_block_id_list():
+			for volume_id in cubit.get_block_volumes(block_id):
+				tet_list = cubit.get_volume_tets(volume_id)
+				if len(tet_list)>0:
+					fid.write(f'3 {volume_id} 4 {len(tet_list)}\n')
+					for tet_id in tet_list:
+						node_list = cubit.get_connectivity("tet", tet_id)
+						elementTag +=1
+						fid.write(f'{elementTag} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]}\n')
+
+				hex_list = cubit.get_volume_hexes(volume_id)
+				if len(hex_list)>0:
+					fid.write(f'3 {volume_id} 5 {len(hex_list)}\n')
+					for hex_id in hex_list:
+						node_list = cubit.get_connectivity("hex", hex_id)
+						elementTag +=1
+						fid.write(f'{elementTag} {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')
+
+				wedge_list = cubit.get_volume_wedges(volume_id)
+				if len(wedge_list)>0:
+					fid.write(f'3 {volume_id} 6 {len(wedge_list)}\n')
+					for wedge_id in wedge_list:
+						node_list = cubit.get_connectivity("wedge", wedge_id)
+						elementTag +=1
+						fid.write(f'{elementTag} {node_list[0]} {node_list[1]} {node_list[2]} {node_list[3]} {node_list[4]} {node_list[5]}\n')
+
+		fid.write('$EndElements\n')
+		fid.close()
+	return cubit
+

coreform_cubit_mesh_export-1.0.4.dist-info/RECORD

@@ -1,5 +0,0 @@
-cubit_mesh_export.py,sha256=4QF7fJbT-g7w2X0ZcI-5lShA8_oWSi7S92o2lN1rqXs,53053
-coreform_cubit_mesh_export-1.0.4.dist-info/METADATA,sha256=bYO5klM6mN10SCrosZ3a1KgYAZn9Neu3qazopVsWRjc,5408
-coreform_cubit_mesh_export-1.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-coreform_cubit_mesh_export-1.0.4.dist-info/top_level.txt,sha256=-K1cfrL0sGC26lWxEpEVcVu6kQQc0YQWy-noAn3rMRk,18
-coreform_cubit_mesh_export-1.0.4.dist-info/RECORD,,