def load_usm3d_results(self, flo_filename, dirname):
model = Usm3d(log=self.log, debug=False)
#self.result_cases = {}
npoints = self.nNodes
node_ids_volume, loads = model.read_flo(flo_filename, n=npoints)
cases = self.result_cases
bcs = None
mapbc = None
bcmap_to_bc_name = None
self._fill_usm3d_results(cases, bcs, mapbc, bcmap_to_bc_name, loads)
def load_usm3d_results(self, flo_filename):
model = Usm3d(log=self.gui.log, debug=False)
npoints = self.gui.nnodes
unused_node_ids_volume, loads = model.read_flo(flo_filename, n=npoints)
cases = self.gui.result_cases
form = self.gui.get_form()
bcs = None
mapbc = None
bcmap_to_bc_name = None
self._fill_usm3d_results(cases, form,
bcs, mapbc, bcmap_to_bc_name, loads,
is_geometry=False)
def cogsg_bc_to_nastran(cogsg_filename,
bc_filename,
nastran_filename,
include_shells=True,
include_solids=False):
"""
converts a *.cogsg and a *.bc file to a *.bdf file
"""
model = Usm3d(log=None, debug=None)
nodes, tets = model.read_cogsg(cogsg_filename, stop_after_header=False)
assert tets.min() == 0, tets.min()
if not include_shells or include_solids:
msg = 'include_shells=%r include_solids=%r; one/both must be True' % (
include_shells, include_solids)
raise RuntimeError(msg)
bcs = [0]
if include_shells:
header, tris, bcs = model.read_bc(bc_filename)
with open(nastran_filename, 'w') as bdf_file:
bdf_file.write('$ pyNastran : punch=True\n')
if include_solids:
for nid, (x, y, z) in zip(count(), nodes):
bdf_file.write(print_card_16(['GRID', nid + 1, '', x, y, z]))
else:
nids = np.unique(tris.ravel())
for nid in nids:
x, y, z = nodes[nid, :]
bdf_file.write(print_card_16(['GRID', nid + 1, '', x, y, z]))
if include_shells:
for itri, tri, bc in zip(count(), tris + 1, bcs):
bdf_file.write(
print_card_8(['CTRIA3', itri + 1, bc] + list(tri)))
mid = 1
for bc in np.unique(bcs):
bdf_file.write(print_card_8(['PSHELL', bc, mid, 0.1]))
bdf_file.write(print_card_8(['MAT1', mid, 3.0e7, None, 0.3]))
if include_solids:
pid = max(bcs) + 1
mid = 2
for itet, tet in zip(count(), tets + 1):
print_card_8(['CTETRA', itet + 1, pid] + list(tet))
bdf_file.write(print_card_8(['PSOLID', pid, mid]))
bdf_file.write(print_card_8(['MAT1', mid, 3.0e7, None, 0.3]))
def load_usm3d_geometry(self, cogsg_filename, name='main', plot=True):
skip_reading = self._remove_old_geometry(cogsg_filename)
if skip_reading:
return
self.eid_maps[name] = {}
self.nid_maps[name] = {}
model = Usm3d(log=self.log, debug=False)
base_filename, ext = os.path.splitext(cogsg_filename)
#node_filename = base_filename + '.node'
#ele_filename = base_filename + '.ele'
if '.cogsg' == ext:
dimension_flag = 3
#elif '.ele' == ext:
#dimension_flag = 3
else:
raise RuntimeError(
'unsupported extension. Use "cogsg" or "front".')
read_loads = True
nodes, tris_tets, tris, bcs, mapbc, loads, flo_filename = model.read_usm3d(
base_filename, dimension_flag, read_loads=read_loads)
del tris_tets
nodes = model.nodes
tris = model.tris
tets = model.tets
bcs = model.bcs
mapbc = model.mapbc
loads = model.loads
self.out_filename = None
if flo_filename is not None:
self.out_filename = flo_filename
bcmap_to_bc_name = model.bcmap_to_bc_name
self.nNodes = nodes.shape[0]
ntris = 0
ntets = 0
if tris is not None:
ntris = tris.shape[0]
if dimension_flag == 2:
pass
elif dimension_flag == 3:
ntets = tets.shape[0]
ntets = 0
else:
raise RuntimeError()
self.nElements = ntris + ntets
self.log.debug("nNodes = %i" % self.nNodes)
self.log.debug("nElements = %i" % self.nElements)
grid = self.grid
grid.Allocate(self.nElements, 1000)
#self.gridResult.SetNumberOfComponents(self.nElements)
self.nid_map = {}
self.eid_map = {}
#elem.SetNumberOfPoints(nNodes)
#if 0:
#fraction = 1. / self.nNodes # so you can color the nodes by ID
#for nid, node in sorted(iteritems(nodes)):
#points.InsertPoint(nid - 1, *node)
#self.gridResult.InsertNextValue(nid * fraction)
#print(str(element))
#elem = vtk.vtkVertex()
#elem.GetPointIds().SetId(0, i)
#self.aQuadGrid.InsertNextCell(elem.GetCellType(), elem.GetPointIds())
#vectorResult.InsertTuple3(0, 0.0, 0.0, 1.0)
assert nodes is not None
nnodes = nodes.shape[0]
points = self.numpy_to_vtk_points(nodes)
if ntris:
self.element_ids = np.arange(1, ntris + 1, dtype='int32')
etype = 5 # vtkTriangle().GetCellType()
self.create_vtk_cells_of_constant_element_type(grid, tris, etype)
#for (n0, n1, n2) in tris:
#elem = vtkTriangle()
#elem.GetPointIds().SetId(0, n0)
#elem.GetPointIds().SetId(1, n1)
#elem.GetPointIds().SetId(2, n2)
#grid.InsertNextCell(5, elem.GetPointIds()) #elem.GetCellType() = 5 # vtkTriangle
else:
ntets = tets.shape[0]
self.element_ids = np.arange(1, ntets + 1, dtype='int32')
if dimension_flag == 2:
pass
elif dimension_flag == 3:
if ntets:
for (n0, n1, n2, n3) in tets:
elem = vtkTetra()
#assert elem.GetCellType() == 10, elem.GetCellType()
elem.GetPointIds().SetId(0, n0)
elem.GetPointIds().SetId(1, n1)
elem.GetPointIds().SetId(2, n2)
elem.GetPointIds().SetId(3, n3)
grid.InsertNextCell(10, elem.GetPointIds(
)) #elem.GetCellType() = 5 # vtkTriangle
else:
raise RuntimeError('dimension_flag=%r' % dimension_flag)
grid.SetPoints(points)
grid.Modified()
if hasattr(grid, 'Update'):
grid.Update()
# regions/loads
self.scalarBar.Modified()
cases = {}
form = []
form, cases = self._fill_usm3d_results(cases,
form,
bcs,
mapbc,
bcmap_to_bc_name,
loads,
is_geometry=True)
self._finish_results_io2(form, cases)
def load_usm3d_geometry(self, cogsg_filename, name='main', plot=True):
skip_reading = self.parent._remove_old_geometry(cogsg_filename)
if skip_reading:
return
self.parent.eid_maps[name] = {}
self.parent.nid_maps[name] = {}
model = Usm3d(log=self.parent.log, debug=False)
base_filename, ext = os.path.splitext(cogsg_filename)
#node_filename = base_filename + '.node'
#ele_filename = base_filename + '.ele'
if ext == '.cogsg':
dimension_flag = 3
#elif ext == '.ele':
#dimension_flag = 3
else:
raise RuntimeError(
'unsupported extension. Use "cogsg" or "front".')
read_loads = True
nodes, tris_tets, tris, bcs, mapbc, loads, flo_filename = model.read_usm3d(
base_filename, dimension_flag, read_loads=read_loads)
del tris_tets
nodes = model.nodes
tris = model.tris
tets = model.tets
bcs = model.bcs
mapbc = model.mapbc
loads = model.loads
self.parent.out_filename = None
if flo_filename is not None:
self.parent.out_filename = flo_filename
bcmap_to_bc_name = model.bcmap_to_bc_name
self.parent.nnodes = nodes.shape[0]
ntris = 0
ntets = 0
if tris is not None:
ntris = tris.shape[0]
if dimension_flag == 2:
pass
elif dimension_flag == 3:
ntets = tets.shape[0]
ntets = 0
else:
raise RuntimeError()
self.parent.nelements = ntris + ntets
self.parent.log.debug("nnodes = %i" % self.parent.nnodes)
self.parent.log.debug("nelements = %i" % self.parent.nelements)
grid = self.parent.grid
grid.Allocate(self.parent.nelements, 1000)
self.parent.nid_map = {}
self.parent.eid_map = {}
assert nodes is not None
unused_nnodes = nodes.shape[0]
points = numpy_to_vtk_points(nodes)
if ntris:
self.parent.element_ids = np.arange(1, ntris + 1, dtype='int32')
etype = 5 # vtkTriangle().GetCellType()
create_vtk_cells_of_constant_element_type(grid, tris, etype)
else:
ntets = tets.shape[0]
self.parent.element_ids = np.arange(1, ntets + 1, dtype='int32')
if dimension_flag == 2:
pass
elif dimension_flag == 3:
if ntets:
etype = 10 # vtkTetra().GetCellType()
assert tets.max() > 0, tets.min()
create_vtk_cells_of_constant_element_type(grid, tets, etype)
else:
raise RuntimeError('dimension_flag=%r' % dimension_flag)
grid.SetPoints(points)
grid.Modified()
if hasattr(grid, 'Update'): # pragma: no cover
grid.Update()
# regions/loads
self.parent.scalarBar.Modified()
cases = OrderedDict()
form = []
form, cases = self._fill_usm3d_results(cases,
form,
bcs,
mapbc,
bcmap_to_bc_name,
loads,
is_geometry=True)
self.parent._finish_results_io2(form, cases)
def run_time_acc(dirname,
model_name,
node_ids,
nstart=0,
nlimit=None,
num_cpus=8):
"""
node ids start at index=0
"""
model = Usm3d()
n_list, flo_filenames = get_flo_files(dirname, model_name, nstart, nlimit)
nlimit = len(flo_filenames)
assert nlimit > 0, 'nfiles=%s' % (nlimit)
#print("nmax =", nlimit)
Cp = {}
Mach = {}
T = {}
U = {}
V = {}
W = {}
p = {}
rhoU = {}
# initialize the arrays
for node_id in node_ids:
Cp[node_id] = zeros(nlimit, 'float64')
Mach[node_id] = zeros(nlimit, 'float64')
T[node_id] = zeros(nlimit, 'float64')
U[node_id] = zeros(nlimit, 'float64')
V[node_id] = zeros(nlimit, 'float64')
W[node_id] = zeros(nlimit, 'float64')
p[node_id] = zeros(nlimit, 'float64')
rhoU[node_id] = zeros(nlimit, 'float64')
#flo_filenames = flo_filenames[:10]
#num_cpus = 1
if num_cpus == 1:
model = Usm3d()
for flo_filename in flo_filenames:
node_ids2, loads = model.read_flo(flo_filename, node_ids=node_ids)
for i, node_id in enumerate(node_ids):
Cp[node_id][i] = loads['Cp'][i]
Mach[node_id][i] = loads['Mach'][i]
T[node_id][i] = loads['T'][i]
U[node_id][i] = loads['U'][i]
V[node_id][i] = loads['V'][i]
W[node_id][i] = loads['W'][i]
p[node_id][i] = loads['p'][i]
rhoU[node_id][i] = loads['rhoU'][i]
else:
pool = mp.Pool(num_cpus)
result = pool.imap(_loads_func, [(flo_filename, node_ids)
for flo_filename in flo_filenames])
n = 0
for j, loads in enumerate(result):
if j % 500 == 0:
print("n =", j, flo_filenames[j])
for i, node_id in enumerate(node_ids):
#print("Cp[node=%s] =%s" % (node_id, loads['Cp'][i]))
Cp[node_id][j] = loads['Cp'][i]
Mach[node_id][j] = loads['Mach'][i]
T[node_id][j] = loads['T'][i]
U[node_id][j] = loads['U'][i]
V[node_id][j] = loads['V'][i]
W[node_id][j] = loads['W'][i]
p[node_id][j] = loads['p'][i]
rhoU[node_id][j] = loads['rhoU'][i]
n += 1
pool.close()
pool.join()
return n_list, Cp, Mach, T, U, V, W, p, rhoU
def _loads_func(data):
flo_filename, node_ids = data
model = Usm3d()
node_ids2, loads = model.read_flo(flo_filename, node_ids=node_ids)
return loads
