def load_tecplot_geometry(self,
tecplot_filename,
dirname,
name='main',
plot=True):
#key = self.case_keys[self.icase]
#case = self.result_cases[key]
skip_reading = self._remove_old_cart3d_geometry(tecplot_filename)
if skip_reading:
return
if 0:
fnames = os.listdir('time20000')
fnames = [os.path.join('time20000', fname) for fname in fnames]
model = merge_tecplot_files(fnames,
tecplot_filename_out=None,
log=self.log)
else:
model = Tecplot(log=self.log, debug=False)
model.read_tecplot(tecplot_filename)
self.model_type = 'tecplot'
#self.model_type = model.model_type
self.nNodes = model.nnodes
#self._make_tecplot_geometry(model, self.nNodes, quads_only=True) # cart3d
is_surface = self._make_tecplot_geometry(model, quads_only=False)
#self._create_cart3d_free_edegs(model, nodes, elements)
# loadCart3dResults - regions/loads
self.turn_text_on()
self.scalarBar.VisibilityOn()
self.scalarBar.Modified()
loads = []
assert loads is not None
if 'Mach' in loads:
avgMach = mean(loads['Mach'])
note = ': avg(Mach)=%g' % avgMach
else:
note = ''
self.iSubcaseNameMap = {1: ['Tecplot%s' % note, '']}
cases = {}
ID = 1
form, cases = self._fill_tecplot_case(cases, ID, model, is_surface)
self._finish_results_io2(form, cases)
if 0:
# http://www.vtk.org/Wiki/VTK/Examples/Cxx/Filtering/AppendFilter
points = vtkAppendFilter()
#if VTK_MAJOR_VERSION <= 5:
#appendFilter.AddInput(polydata)
#appendFilter.AddInput(ug)
#else:
appendFilter.AddInputData(polydata)
appendFilter.AddInputData()
appendFilter.Update()
def load_tecplot_geometry(self, tecplot_filename, dirname, plot=True):
#key = self.caseKeys[self.iCase]
#case = self.resultCases[key]
skip_reading = self._remove_old_cart3d_geometry(tecplot_filename)
if skip_reading:
return
if 0:
fnames = os.listdir('time20000')
fnames = [os.path.join('time20000', fname) for fname in fnames]
model = merge_tecplot_files(fnames, tecplot_filename_out=None, log=self.log)
else:
model = Tecplot(log=self.log, debug=False)
model.read_tecplot(tecplot_filename)
self.modelType = 'tecplot'
#self.modelType = model.modelType
self.nNodes = model.nnodes
#self._make_tecplot_geometry(model, self.nNodes, quads_only=True) # cart3d
is_surface = self._make_tecplot_geometry(model, quads_only=False)
#self._create_cart3d_free_edegs(model, nodes, elements)
# loadCart3dResults - regions/loads
self.TurnTextOn()
self.scalarBar.VisibilityOn()
self.scalarBar.Modified()
loads = []
assert loads is not None
if 'Mach' in loads:
avgMach = mean(loads['Mach'])
note = ': avg(Mach)=%g' % avgMach
else:
note = ''
self.iSubcaseNameMap = {1: ['Tecplot%s' % note, '']}
cases = {}
ID = 1
form, cases = self._fill_tecplot_case(cases, ID, model, is_surface)
self._finish_results_io2(form, cases)
if 0:
# http://www.vtk.org/Wiki/VTK/Examples/Cxx/Filtering/AppendFilter
points = vtkAppendFilter()
#if VTK_MAJOR_VERSION <= 5:
#appendFilter.AddInput(polydata)
#appendFilter.AddInput(ug)
#else:
appendFilter.AddInputData(polydata)
appendFilter.AddInputData()
appendFilter.Update()
def cart3d_to_tecplot(cart3d_filename, tecplot_filename):
"""
Converts Cart3d to Tecplot
"""
model = Cart3D()
model.read_cart3d(cart3d_filename)
tecplot = Tecplot()
tecplot.xyz = model.points
tecplot.tri_elements = model.elements
tecplot.write_tecplot(tecplot_filename, adjust_nids=False)
return tecplot
def cart3d_to_tecplot(cart3d_filename, tecplot_filename, log=None, debug=False):
"""
Converts Cart3d to Tecplot
"""
if isinstance(cart3d_filename, Cart3D):
model = cart3d_filename
else:
model = read_cart3d(cart3d_filename, log=log, debug=debug)
tecplot = Tecplot()
tecplot.xyz = model.points
tecplot.tri_elements = model.elements
tecplot.write_tecplot(tecplot_filename, adjust_nids=False)
return tecplot
def nastran_to_tecplot_filename(bdf_filename, tecplot_filename, log=None):
model = BDF(log=log)
model.read_bdf(bdf_filename)
# tecplot = nastran_to_tecplot(model)
#log.info('card_count = %s' % model.card_count)
nnodes = len(model.nodes)
nodes = zeros((nnodes, 3), dtype='float64')
elements = []
i = 0
nodeid_to_i_map = {}
for node_id, node in sorted(iteritems(model.nodes)):
xyz = node.get_position()
nodes[i, :] = xyz
nodeid_to_i_map[node_id] = i
i += 1
assert len(model.nodes) == i, 'model.nodes=%s i=%s' % (len(model.nodes), i)
for eid, element in sorted(iteritems(model.elements)):
if element.type in ['CTETRA']:
n1, n2, n3, n4 = element.node_ids
i1, i2, i3, i4 = nodeid_to_i_map[n1], nodeid_to_i_map[
n2], nodeid_to_i_map[n3], nodeid_to_i_map[n4]
elements.append([i1, i2, i3, i4, i4, i4, i4, i4])
elif element.type in ['CPENTA']:
n1, n2, n3, n4, n5, n6 = element.node_ids
i1, i2, i3, i4, i5, i6 = (nodeid_to_i_map[n1], nodeid_to_i_map[n2],
nodeid_to_i_map[n3], nodeid_to_i_map[n4],
nodeid_to_i_map[n5], nodeid_to_i_map[n6])
elements.append([i1, i2, i3, i4, i5, i6, i6, i6])
elif element.type in ['CPYRAM']:
n1, n2, n3, n4, n5 = element.node_ids
i1, i2, i3, i4, i5 = (nodeid_to_i_map[n1], nodeid_to_i_map[n2],
nodeid_to_i_map[n3], nodeid_to_i_map[n4],
nodeid_to_i_map[n5])
elements.append([i1, i2, i3, i4, i5, i5, i5, i5])
elif element.type in ['CHEXA']:
n1, n2, n3, n4, n5, n6, n7, n8 = element.node_ids
i1, i2, i3, i4, i5, i6, i7, i8 = (nodeid_to_i_map[n1],
nodeid_to_i_map[n2],
nodeid_to_i_map[n3],
nodeid_to_i_map[n4],
nodeid_to_i_map[n5],
nodeid_to_i_map[n6],
nodeid_to_i_map[n7],
nodeid_to_i_map[n8])
elements.append([i1, i2, i3, i4, i5, i6, i7, i8])
else:
self.log.info('skip etype=%r' % element.type)
self.log.info(element)
elements = array(elements, dtype='int32')
tecplot = Tecplot()
tecplot.xyz = nodes
tecplot.hexa_elements = elements
tecplot.write_tecplot(tecplot_filename)
tecplot.results = array([], dtype='float32')
return tecplot
def ugrid_to_tecplot(ugrid_model, tecplot_filename=None, log=None, debug=False):
"""
Converts a UGRID to a Tecplot ASCII file.
Parameters
----------
ugrid_filename : varies
str : the input UGRID filename
UGRID : the UGRID object
tecplot_filename : str
the output Tecplot filename
log : logger; default=None
a logger object
"""
nnodes = len(ugrid_model.nodes)
nodes = zeros((nnodes, 3), dtype='float64')
ugrid_model.check_hanging_nodes()
elements = []
ntets = len(ugrid_model.tets)
non_tets = len(ugrid_model.penta5s) + len(ugrid_model.penta6s) + len(ugrid_model.hexas)
assert ntets + non_tets > 0, 'nsolids=%s' % (ntets + non_tets)
tecplot = Tecplot(log=log, debug=debug)
tecplot.xyz = ugrid_model.nodes
if ntets and non_tets == 0:
elements = ugrid_model.tets
tecplot.tet_elements = elements - 1
elif non_tets:
for element in ugrid_model.tets:
n1, n2, n3, n4 = element
elements.append([n1, n2, n3, n4,
n4, n4, n4, n4])
for element in ugrid_model.penta5s:
n1, n2, n3, n4, n5 = element
elements.append([n1, n2, n3, n4,
n5, n5, n5, n5])
for element in ugrid_model.penta6s:
n1, n2, n3, n4, n5, n6 = element
elements.append([n1, n2, n3, n4,
n5, n6, n6, n6])
for element in ugrid_model.hexas:
n1, n2, n3, n4, n5, n6, n7, n8 = element
elements.append([n1, n2, n3, n4,
n5, n6, n7, n8])
elements = array(elements, dtype='int32') - 1
tecplot.hexa_elements = elements
else:
raise RuntimeError()
if tecplot_filename is not None:
tecplot.write_tecplot(tecplot_filename)
return tecplot
def ugrid_to_tecplot(ugrid_model):
nnodes = len(ugrid_model.nodes)
nodes = zeros((nnodes, 3), dtype='float64')
ugrid_model.check_hanging_nodes()
elements = []
ntets = len(ugrid_model.tets)
non_tets = len(ugrid_model.penta5s) + len(ugrid_model.penta6s) + len(ugrid_model.hexas)
assert ntets + non_tets > 0, 'nsolids=%s' % (ntets + non_tets)
tecplot = Tecplot()
tecplot.xyz = ugrid_model.nodes
if ntets and non_tets == 0:
elements = ugrid_model.tets
tecplot.tet_elements = elements - 1
elif non_tets:
for element in ugrid_model.tets:
n1, n2, n3, n4 = element
elements.append([n1, n2, n3, n4,
n4, n4, n4, n4])
for element in ugrid_model.penta5s:
n1, n2, n3, n4, n5 = element
elements.append([n1, n2, n3, n4,
n5, n5, n5, n5])
for element in ugrid_model.penta6s:
n1, n2, n3, n4, n5, n6 = element
elements.append([n1, n2, n3, n4,
n5, n6, n6, n6])
for element in ugrid_model.hexas:
n1, n2, n3, n4, n5, n6, n7, n8 = element
elements.append([n1, n2, n3, n4,
n5, n6, n7, n8])
elements = array(elements, dtype='int32') - 1
tecplot.hexa_elements = elements
else:
raise RuntimeError()
return tecplot
def nastran_to_tecplot_filename(bdf_filename, tecplot_filename, log=None):
model = BDF(log=log)
model.read_bdf(bdf_filename)
# tecplot = nastran_to_tecplot(model)
#log.info('card_count = %s' % model.card_count)
nnodes = len(model.nodes)
nodes = zeros((nnodes, 3), dtype='float64')
elements = []
i = 0
nodeid_to_i_map = {}
for node_id, node in sorted(iteritems(model.nodes)):
xyz = node.get_position()
nodes[i, :] = xyz
nodeid_to_i_map[node_id] = i
i += 1
assert len(model.nodes) == i, 'model.nodes=%s i=%s' % (len(model.nodes), i)
for eid, element in sorted(iteritems(model.elements)):
if element.type in ['CTETRA']:
n1, n2, n3, n4 = element.node_ids
i1, i2, i3, i4 = nodeid_to_i_map[n1], nodeid_to_i_map[n2], nodeid_to_i_map[n3], nodeid_to_i_map[n4]
elements.append([i1, i2, i3, i4,
i4, i4, i4, i4])
elif element.type in ['CPENTA']:
n1, n2, n3, n4, n5, n6 = element.node_ids
i1, i2, i3, i4, i5, i6 = (
nodeid_to_i_map[n1], nodeid_to_i_map[n2], nodeid_to_i_map[n3], nodeid_to_i_map[n4],
nodeid_to_i_map[n5], nodeid_to_i_map[n6])
elements.append([i1, i2, i3, i4,
i5, i6, i6, i6])
elif element.type in ['CPYRAM']:
n1, n2, n3, n4, n5 = element.node_ids
i1, i2, i3, i4, i5 = (
nodeid_to_i_map[n1], nodeid_to_i_map[n2], nodeid_to_i_map[n3], nodeid_to_i_map[n4],
nodeid_to_i_map[n5])
elements.append([i1, i2, i3, i4,
i5, i5, i5, i5])
elif element.type in ['CHEXA']:
n1, n2, n3, n4, n5, n6, n7, n8 = element.node_ids
i1, i2, i3, i4, i5, i6, i7, i8 = (
nodeid_to_i_map[n1], nodeid_to_i_map[n2], nodeid_to_i_map[n3], nodeid_to_i_map[n4],
nodeid_to_i_map[n5], nodeid_to_i_map[n6], nodeid_to_i_map[n7], nodeid_to_i_map[n8])
elements.append([i1, i2, i3, i4,
i5, i6, i7, i8])
else:
self.log.info('skip etype=%r' % element.type)
self.log.info(element)
elements = array(elements, dtype='int32')
tecplot = Tecplot()
tecplot.xyz = nodes
tecplot.hexa_elements = elements
tecplot.write_tecplot(tecplot_filename)
tecplot.results = array([], dtype='float32')
return tecplot
def cart3d_to_tecplot(cart3d_filename,
tecplot_filename,
log=None,
debug=False):
"""
Converts Cart3d to Tecplot
"""
if isinstance(cart3d_filename, Cart3D):
model = cart3d_filename
else:
model = read_cart3d(cart3d_filename, log=log, debug=debug)
tecplot = Tecplot()
tecplot.log = model.log
tecplot.xyz = model.points
tecplot.tri_elements = model.elements + 1
tecplot.write_tecplot(tecplot_filename, adjust_nids=False)
return tecplot
def cart3d_to_tecplot(cart3d_filename,
tecplot_filename,
log=None,
debug=False):
"""
Converts Cart3d to Tecplot
"""
if isinstance(cart3d_filename, Cart3D):
model = cart3d_filename
else:
model = read_cart3d(cart3d_filename, log=log, debug=debug)
tecplot = Tecplot()
tecplot.log = model.log
zone = Zone(model.log)
zone.headers_dict['VARIABLES'] = ['X', 'Y', 'Z']
zone.xyz = model.points
zone.tri_elements = model.elements + 1
tecplot.zones = [zone]
tecplot.write_tecplot(tecplot_filename, adjust_nids=False)
return tecplot
def nastran_to_tecplot(model):
"""assumes sequential nodes"""
tecplot = Tecplot()
nnodes = len(model.nodes)
inode_max = max(model.nodes)
if nnodes == inode_max:
xyz = zeros((nnodes, 3), dtype='float64')
i = 0
for nid, node in sorted(iteritems(model.nodes)):
xyz[i, :] = node.get_position()
i += 1
else:
raise RuntimeError('sequential node IDs required; nnodes=%s inode_max=%s' % (nnodes, inode_max))
tecplot.xyz = xyz
nquads = model.card_count['CQUAD4'] if 'CQUAD4' in model.card_count else 0
ntets = model.card_count['CTETRA'] if 'CTETRA' in model.card_count else 0
#ntrias = model.card_count['CTRIA3'] if 'CTRIA3' in model.card_count else 0
nhexas = model.card_count['CHEXA'] if 'CHEXA' in model.card_count else 0
nelements = len(model.elements)
tris = []
quads = []
tets = []
hexas = []
pentas = []
#i = 0
#pids = zeros(nelements, dtype='int32')
#mids = zeros(nelements, dtype='int32')
unhandled_types = set([])
for eid, element in iteritems(model.elements):
if element.type in ['CTRIA3']:
tris.append(element.node_ids)
elif element.type in ['CQUAD4']:
quads.append(element.node_ids)
elif element.type == 'CTETRA':
tets.append(element.node_ids[:4])
elif element.type == 'CPENTA':
pentas.append(element.node_ids[:6])
elif element.type == 'CHEXA':
hexas.append(element.node_ids[:8])
else:
unhandled_types.add(element.type)
#pid = element.Pid()
#mid = element.Mid()
#pids[i] = pid
#mids[i] = mid
#i += 1
for etype in unhandled_types:
print('ignoring %s' % etype)
# only supports nodal results
#tecplot.results = vstack([pids, mids])#.T
#print(tecplot.results.shape)
#tecplot.result_names = ['PropertyID', 'MaterialID']
ntris = len(tris)
nquads = len(quads)
nshells = ntris + nquads
ntets = len(tets)
npentas = len(pentas)
nhexas = len(hexas)
nsolids = ntets + npentas + nhexas
nnot_tris = nquads
nnot_quads = ntris
nnot_tets = npentas + nhexas
nnot_hexas = ntets + npentas
if ntris and not nnot_tris and not nsolids:
tecplot.tri_elements = array(tris, dtype='int32')
elif nquads and not nnot_quads and not nsolids:
tecplot.quad_elements = array(quads, dtype='int32')
elif ntets and not nnot_tets and not nshells:
tecplot.tet_elements = array(tets, dtype='int32')
elif nhexas and not nnot_hexas and not nshells:
tecplot.hexa_elements = array(hexas, dtype='int32')
elif not nshells:
elements = zeros((nelements, 8), dtype='int32')
if ntets:
tets = array(tets, dtype='int32')
elements[:ntets, :4] = tets
elements[:ntets, 4] = elements[:ntets, 3]
elements[:ntets, 5] = elements[:ntets, 3]
elements[:ntets, 6] = elements[:ntets, 3]
elements[:ntets, 7] = elements[:ntets, 3]
if npentas:
# penta6
pentas = array(pentas, dtype='int32')
elements[ntets:ntets + npentas, :6] = pentas
elements[ntets:ntets + npentas, 6] = elements[:ntets, 5]
elements[ntets:ntets + npentas, 7] = elements[:ntets, 5]
if nhexas:
hexas = array(hexas, dtype='int32')
elements[ntets + npentas:ntets + npentas + nhexas, :6] = pentas
elements[ntets + npentas:ntets + npentas + nhexas, 6] = elements[:ntets, 5]
elements[ntets + npentas:ntets + npentas + nhexas, 7] = elements[:ntets, 5]
tecplot.hexa_elements = array(elements)
elif not nsolids:
elements = zeros((nelements, 4), dtype='int32')
tris = array(tris, dtype='int32')
elements[:ntris, :3] = tris
elements[:ntris, 4] = elements[:ntets, 3]
quads = array(quads, dtype='int32')
elements[ntris:, :] = quads
else:
msg = 'Only solids or shells are allowed (not both)\n'
msg += ' nsolids=%s nshells=%s\n' % (nsolids, nshells)
msg += ' ntris=%s nquads=%s\n' % (ntris, nquads)
msg += ' ntets=%s npentas=%s nhexas=%s\n' % (ntets, npentas, nhexas)
raise NotImplementedError(msg)
return tecplot
def nastran_to_tecplot(model):
"""assumes sequential nodes"""
tecplot = Tecplot()
nnodes = len(model.nodes)
inode_max = max(model.nodes)
if nnodes == inode_max:
xyz = zeros((nnodes, 3), dtype='float64')
i = 0
for nid, node in sorted(iteritems(model.nodes)):
xyz[i, :] = node.get_position()
i += 1
else:
raise RuntimeError(
'sequential node IDs required; nnodes=%s inode_max=%s' %
(nnodes, inode_max))
tecplot.xyz = xyz
nquads = model.card_count['CQUAD4'] if 'CQUAD4' in model.card_count else 0
ntets = model.card_count['CTETRA'] if 'CTETRA' in model.card_count else 0
#ntrias = model.card_count['CTRIA3'] if 'CTRIA3' in model.card_count else 0
nhexas = model.card_count['CHEXA'] if 'CHEXA' in model.card_count else 0
nelements = len(model.elements)
tris = []
quads = []
tets = []
hexas = []
pentas = []
#i = 0
#pids = zeros(nelements, dtype='int32')
#mids = zeros(nelements, dtype='int32')
unhandled_types = set([])
for eid, element in iteritems(model.elements):
if element.type in ['CTRIA3']:
tris.append(element.node_ids)
elif element.type in ['CQUAD4']:
quads.append(element.node_ids)
elif element.type == 'CTETRA':
tets.append(element.node_ids[:4])
elif element.type == 'CPENTA':
pentas.append(element.node_ids[:6])
elif element.type == 'CHEXA':
hexas.append(element.node_ids[:8])
else:
unhandled_types.add(element.type)
#pid = element.Pid()
#mid = element.Mid()
#pids[i] = pid
#mids[i] = mid
#i += 1
for etype in unhandled_types:
print('ignoring %s' % etype)
# only supports nodal results
#tecplot.results = vstack([pids, mids])#.T
#print(tecplot.results.shape)
#tecplot.result_names = ['PropertyID', 'MaterialID']
ntris = len(tris)
nquads = len(quads)
nshells = ntris + nquads
ntets = len(tets)
npentas = len(pentas)
nhexas = len(hexas)
nsolids = ntets + npentas + nhexas
nnot_tris = nquads
nnot_quads = ntris
nnot_tets = npentas + nhexas
nnot_hexas = ntets + npentas
if ntris and not nnot_tris and not nsolids:
tecplot.tri_elements = array(tris, dtype='int32')
elif nquads and not nnot_quads and not nsolids:
tecplot.quad_elements = array(quads, dtype='int32')
elif ntets and not nnot_tets and not nshells:
tecplot.tet_elements = array(tets, dtype='int32')
elif nhexas and not nnot_hexas and not nshells:
tecplot.hexa_elements = array(hexas, dtype='int32')
elif not nshells:
elements = zeros((nelements, 8), dtype='int32')
if ntets:
tets = array(tets, dtype='int32')
elements[:ntets, :4] = tets
elements[:ntets, 4] = elements[:ntets, 3]
elements[:ntets, 5] = elements[:ntets, 3]
elements[:ntets, 6] = elements[:ntets, 3]
elements[:ntets, 7] = elements[:ntets, 3]
if npentas:
# penta6
pentas = array(pentas, dtype='int32')
elements[ntets:ntets + npentas, :6] = pentas
elements[ntets:ntets + npentas, 6] = elements[:ntets, 5]
elements[ntets:ntets + npentas, 7] = elements[:ntets, 5]
if nhexas:
hexas = array(hexas, dtype='int32')
elements[ntets + npentas:ntets + npentas + nhexas, :6] = pentas
elements[ntets + npentas:ntets + npentas + nhexas,
6] = elements[:ntets, 5]
elements[ntets + npentas:ntets + npentas + nhexas,
7] = elements[:ntets, 5]
tecplot.hexa_elements = array(elements)
elif not nsolids:
elements = zeros((nelements, 4), dtype='int32')
tris = array(tris, dtype='int32')
elements[:ntris, :3] = tris
elements[:ntris, 4] = elements[:ntets, 3]
quads = array(quads, dtype='int32')
elements[ntris:, :] = quads
else:
msg = 'Only solids or shells are allowed (not both)\n'
msg += ' nsolids=%s nshells=%s\n' % (nsolids, nshells)
msg += ' ntris=%s nquads=%s\n' % (ntris, nquads)
msg += ' ntets=%s npentas=%s nhexas=%s\n' % (ntets, npentas, nhexas)
raise NotImplementedError(msg)
return tecplot
remove_unused(bdf_model)
def nastran_table_to_tecplot(bdf_model: BDF, case,
variables: List[str]) -> Tecplot:
"""assumes only triangles"""
xyz = []
tris = []
nid_map = {}
for inid, (nid, node) in enumerate(sorted(bdf_model.nodes.items())):
xyz.append(node.get_position())
nid_map[nid] = inid
for eid, elem in sorted(bdf_model.elements.items()):
tris.append([nid_map[nid] for nid in elem.node_ids])
tecplot_model = Tecplot(log=bdf_model.log, debug=bdf_model.debug)
zone = Zone(bdf_model.log)
zone.xyz = np.array(xyz, dtype='float64')
zone.tri_elements = tris = np.array(tris, dtype='int32') + 1
tecplot_model.title = ('%s; %s' % (case.title, case.subtitle)).strip(' ;')
zone.headers_dict['VARIABLES'] = variables
zone.variables = variables
tecplot_model.zones = [zone]
return tecplot_model
def nastran_tables_to_tecplot_filenames(
tecplot_filename_base: str,
bdf_model: BDF,
case,
def merge_tecplot_files(tecplot_filenames,
tecplot_filename_out=None,
log=None):
"""merges one or more tecplot files"""
assert isinstance(tecplot_filenames,
(list, tuple)), type(tecplot_filenames)
assert len(tecplot_filenames) > 0, tecplot_filenames
xyz = []
tri_elements = []
quad_elements = []
tet_elements = []
hexa_elements = []
results = []
nnodes = 0
model = Tecplot(log=log)
if len(tecplot_filenames) == 1:
model.read_tecplot(tecplot_filenames[0])
if tecplot_filename_out is not None:
model.write_tecplot(tecplot_filename_out)
return model
for tecplot_filename in tecplot_filenames:
model.log.info('reading %s' % tecplot_filename)
model.read_tecplot(tecplot_filename)
xyz.append(model.xyz)
if len(model.tri_elements):
tri_elements.append(model.tri_elements + nnodes)
if len(model.quad_elements):
quad_elements.append(model.quad_elements + nnodes)
if len(model.tet_elements):
tet_elements.append(model.tet_elements + nnodes)
if len(model.hexa_elements):
hexa_elements.append(model.hexa_elements + nnodes)
results.append(model.results)
nnodes += model.nnodes
model.xyz = vstack(xyz)
if tri_elements:
model.tri_elements = vstack(tri_elements)
if quad_elements:
model.quad_elements = vstack(quad_elements)
if tet_elements:
model.tet_elements = vstack(tet_elements)
if hexa_elements:
model.hexa_elements = vstack(hexa_elements)
model.results = vstack(results)
if tecplot_filename_out is not None:
model.write_tecplot(tecplot_filename_out)
return model
bdf_model.read_bdf(bdf_filename)
remove_unused(bdf_model)
def nastran_table_to_tecplot(bdf_model, case, variables):
"""assumes only triangles"""
xyz = []
tris = []
nid_map = {}
for inid, (nid, node) in enumerate(sorted(bdf_model.nodes.items())):
xyz.append(node.get_position())
nid_map[nid] = inid
for eid, elem in sorted(bdf_model.elements.items()):
tris.append([nid_map[nid] for nid in elem.node_ids])
tecplot_model = Tecplot(log=bdf_model.log, debug=bdf_model.debug)
tecplot_model.xyz = np.array(xyz, dtype='float64')
tecplot_model.tri_elements = tris = np.array(tris, dtype='int32') + 1
tecplot_model.title = ('%s; %s' % (case.title, case.subtitle)).strip(' ;')
tecplot_model.variables = variables
return tecplot_model
def nastran_tables_to_tecplot_filenames(tecplot_filename_base: str, bdf_model: BDF, case, variables=None, ivars=None):
if variables is None:
variables = case.headers
if ivars is None:
ivars = np.arange(0, len(variables))
tecplot_model = nastran_table_to_tecplot(bdf_model, case, variables)
for itime, time in enumerate(case._times):
def ugrid_to_tecplot(ugrid_filename,
tecplot_filename=None,
log=None,
debug=False):
"""
Converts a UGRID to a Tecplot ASCII file.
Parameters
----------
ugrid_filename : varies
str : the input UGRID filename
UGRID : the UGRID object
tecplot_filename : str
the output Tecplot filename
log : logger; default=None
a logger object
debug : bool; default=False
developer debug
Returns
-------
tecplot_model : Tecplot()
the Tecplot object
"""
ugrid_model = get_ugrid_model(ugrid_filename, log=log, debug=debug)
#nnodes = len(ugrid_model.nodes)
#nodes = zeros((nnodes, 3), dtype='float64')
ugrid_model.check_hanging_nodes()
elements = []
ntets = len(ugrid_model.tets)
non_tets = len(ugrid_model.penta5s) + len(ugrid_model.penta6s) + len(
ugrid_model.hexas)
assert ntets + non_tets > 0, 'nsolids=%s' % (ntets + non_tets)
tecplot = Tecplot(log=ugrid_model.log, debug=debug)
zone = Zone(ugrid_model.log)
zone.headers_dict['VARIABLES'] = ['X', 'Y', 'Z']
zone.xyz = ugrid_model.nodes
if ntets and non_tets == 0:
elements = ugrid_model.tets
zone.tet_elements = elements - 1
elif non_tets:
for element in ugrid_model.tets:
n1, n2, n3, n4 = element
elements.append([n1, n2, n3, n4, n4, n4, n4, n4])
for element in ugrid_model.penta5s:
n1, n2, n3, n4, n5 = element
elements.append([n1, n2, n3, n4, n5, n5, n5, n5])
for element in ugrid_model.penta6s:
n1, n2, n3, n4, n5, n6 = element
elements.append([n1, n2, n3, n4, n5, n6, n6, n6])
for element in ugrid_model.hexas:
n1, n2, n3, n4, n5, n6, n7, n8 = element
elements.append([n1, n2, n3, n4, n5, n6, n7, n8])
elements = np.array(elements, dtype='int32') - 1
zone.hexa_elements = elements
else:
raise RuntimeError()
if tecplot_filename is not None:
tecplot.write_tecplot(tecplot_filename)
tecplot.zones = [zone]
return tecplot, zone
def nastran_to_tecplot_filename(bdf_filename, tecplot_filename, log=None, debug=False):
"""converts a BDF file to Tecplot format; supports solid elements"""
model = BDF(log=log, debug=debug)
model.read_bdf(bdf_filename)
# tecplot = nastran_to_tecplot(model)
#log.info('card_count = %s' % model.card_count)
nnodes = len(model.nodes)
nodes = np.zeros((nnodes, 3), dtype='float64')
elements = []
i = 0
nodeid_to_i_map = {}
for node_id, node in sorted(model.nodes.items()):
xyz = node.get_position()
nodes[i, :] = xyz
nodeid_to_i_map[node_id] = i
i += 1
assert len(model.nodes) == i, 'model.nodes=%s i=%s' % (len(model.nodes), i)
for unused_eid, element in sorted(model.elements.items()):
if element.type in ['CTETRA']:
n1, n2, n3, n4 = element.node_ids
i1, i2, i3, i4 = (nodeid_to_i_map[n1], nodeid_to_i_map[n2],
nodeid_to_i_map[n3], nodeid_to_i_map[n4])
elements.append([i1, i2, i3, i4,
i4, i4, i4, i4])
elif element.type in ['CPENTA']:
n1, n2, n3, n4, n5, n6 = element.node_ids
i1, i2, i3, i4, i5, i6 = (
nodeid_to_i_map[n1], nodeid_to_i_map[n2], nodeid_to_i_map[n3], nodeid_to_i_map[n4],
nodeid_to_i_map[n5], nodeid_to_i_map[n6])
elements.append([i1, i2, i3, i4,
i5, i6, i6, i6])
elif element.type in ['CPYRAM']:
n1, n2, n3, n4, n5 = element.node_ids
i1, i2, i3, i4, i5 = (
nodeid_to_i_map[n1], nodeid_to_i_map[n2], nodeid_to_i_map[n3], nodeid_to_i_map[n4],
nodeid_to_i_map[n5])
elements.append([i1, i2, i3, i4,
i5, i5, i5, i5])
elif element.type in ['CHEXA']:
n1, n2, n3, n4, n5, n6, n7, n8 = element.node_ids
i1, i2, i3, i4, i5, i6, i7, i8 = (
nodeid_to_i_map[n1], nodeid_to_i_map[n2], nodeid_to_i_map[n3], nodeid_to_i_map[n4],
nodeid_to_i_map[n5], nodeid_to_i_map[n6], nodeid_to_i_map[n7], nodeid_to_i_map[n8])
elements.append([i1, i2, i3, i4,
i5, i6, i7, i8])
else:
model.log.info('skip etype=%r' % element.type)
model.log.info(element)
elements = np.array(elements, dtype='int32')
tecplot = Tecplot(log=model.log)
zone = Zone(model.log)
zone.headers_dict['VARIABLES'] = ['X', 'Y', 'Z']
zone.xyz = nodes
zone.hexa_elements = elements
zone.nodal_results = np.array([], dtype='float32')
tecplot.zones = [zone]
tecplot.write_tecplot(tecplot_filename)
return tecplot
def merge_tecplot_files(tecplot_filenames, tecplot_filename_out=None, log=None):
assert isinstance(tecplot_filenames, (list, tuple)), type(tecplot_filenames)
assert len(tecplot_filenames) > 0, tecplot_filenames
xyz = []
tri_elements = []
quad_elements = []
tet_elements = []
hexa_elements = []
results = []
nnodes = 0
model = Tecplot(log=log)
if len(tecplot_filenames) == 1:
model.read_tecplot(tecplot_filenames[0])
if tecplot_filename_out is not None:
model.write_tecplot(tecplot_filename_out)
return model
for tecplot_filename in tecplot_filenames:
model.log.info('reading %s' % tecplot_filename)
model.read_tecplot(tecplot_filename)
xyz.append(model.xyz)
if len(model.tri_elements):
tri_elements.append(model.tri_elements + nnodes)
if len(model.quad_elements):
quad_elements.append(model.quad_elements + nnodes)
if len(model.tet_elements):
tet_elements.append(model.tet_elements + nnodes)
if len(model.hexa_elements):
hexa_elements.append(model.hexa_elements + nnodes)
results.append(model.results)
nnodes += model.nnodes
model.xyz = vstack(xyz)
if tri_elements:
model.tri_elements = vstack(tri_elements)
if quad_elements:
model.quad_elements = vstack(quad_elements)
if tet_elements:
model.tet_elements = vstack(tet_elements)
if hexa_elements:
model.hexa_elements = vstack(hexa_elements)
model.results = vstack(results)
if tecplot_filename_out is not None:
model.write_tecplot(tecplot_filename_out)
return model
def tecplot_to_nastran_filename(tecplot_filename, bdf_filename):
"""
Converts a Tecplot file to Nastran.
"""
if isinstance(tecplot_filename, str):
model = Tecplot()
model.read_tecplot(tecplot_filename)
else:
model = tecplot_filename
removed_nodes = False
shell_pid = 1
solid_pid = 2
mid = 1
istart = 1
bdf_file = open(bdf_filename, 'wb')
bdf_file.write('$pyNastran : punch=True\n')
for inode, node in enumerate(model.xyz):
card = ['GRID', inode + 1, None,] + list(node)
bdf_file.write(print_card_8(card))
if len(model.tri_elements):
# tris only
for itri, tri in enumerate(model.tri_elements):
card = ['CTRIA3', itri + 1, shell_pid] + list(tri)
bdf_file.write(print_card_8(card))
istart += itri
if len(model.quad_elements):
if len(model.tri_elements) != 0:
# if there are tris, then we assume the quads are good
for iquad, quad in enumerate(model.quad_elements):
card = ['CQUAD4', iquad + 1, shell_pid] + list(quad)
bdf_file.write(print_card_8(card))
else:
# need to split out the CQUAD4 elements
istart = itri + 1
for iquad, quad in enumerate(model.quad_elements):
if quad[2] == quad[3]:
# if it's a tri
card = ['CTRIA3', istart + iquad, shell_pid] + list(quad[:3])
else:
card = ['CQUAD4', istart + iquad, shell_pid] + list(quad)
bdf_file.write(print_card_8(card))
istart += iquad
if len(model.tri_elements) + len(model.quad_elements):
card = ['PSHELL', shell_pid, mid, 0.1]
bdf_file.write(print_card_8(card))
if len(model.tet_elements) + len(model.hexa_elements):
card = ['PSOLID', solid_pid, mid]
bdf_file.write(print_card_8(card))
if len(model.tet_elements):
for itet, tet in enumerate(model.tet_elements):
card = ['CTETRA', istart + itet, solid_pid] + list(tet)
bdf_file.write(print_card_8(card))
if len(model.hexa_elements):
# need to split out the CTETRA and CPENTA elements
for ihex, hexa in enumerate(model.hexa_elements):
uhexa = unique(hexa)
nnodes_unique = len(uhexa)
nids = hexa[:nnodes_unique]
centroid_y = model.xyz[nids, 1].max()
if centroid_y < 0:
removed_nodes = True
continue
if nnodes_unique == 4:
card = ['CTETRA', istart + ihex, solid_pid] + list(nids)
assert len(card) == 7, len(card)
elif nnodes_unique == 5:
card = ['CPYRAM', istart + ihex, solid_pid] + list(nids)
assert len(card) == 8, len(card)
elif nnodes_unique == 6:
card = ['CPENTA', istart + ihex, solid_pid] + list(nids)
assert len(card) == 9, len(card)
elif nnodes_unique == 8:
card = ['CHEXA', istart + ihex, solid_pid] + list(hexa)
bdf_file.write(print_card_8(card))
E = 3.0e7
G = None
nu = 0.3
card = ['MAT1', mid, E, G, nu]
bdf_file.write(print_card_8(card))
bdf_file.close()
if removed_nodes:
model = BDF()
model.read_bdf(bdf_filename)
remove_unassociated_nodes(bdf_filename, bdf_filename,
renumber=True)
