def test_merge_01(self):
"""merges multiple bdfs into a single deck"""
log = SimpleLogger(level='error')
bdf_filename1 = os.path.join(MODEL_PATH, 'bwb', 'bwb_saero.bdf')
bdf_filename2 = os.path.join(MODEL_PATH, 'sol_101_elements',
'static_solid_shell_bar.bdf')
bdf_filename3 = os.path.join(MODEL_PATH, 'solid_bending',
'solid_bending.bdf')
bdf_filename4 = os.path.join(MODEL_PATH, 'iSat', 'ISat_Dploy_Sm.dat')
bdf_filename_out1 = os.path.join(MODEL_PATH, 'bwb',
'BWBsaero_staticbar_8.out')
bdf_filename_out2 = os.path.join(MODEL_PATH, 'bwb',
'BWBsaero_static_bar_16.out')
bdf_filename_out3 = os.path.join(MODEL_PATH, 'bwb',
'BWBsaero_staticbar_isat.out')
bdf_filenames1 = [bdf_filename1, bdf_filename2]
bdf_filenames2 = [
bdf_filename1, bdf_filename2, bdf_filename3, bdf_filename4
]
bdf_merge(bdf_filenames1,
bdf_filename_out=bdf_filename_out1,
renumber=True,
encoding=None,
size=8,
is_double=False,
cards_to_skip=None,
log=log)
bdf_merge(bdf_filenames1,
bdf_filename_out=bdf_filename_out2,
renumber=False,
encoding=None,
size=16,
is_double=False,
cards_to_skip=None,
log=log)
bdf_merge(bdf_filenames2,
bdf_filename_out=bdf_filename_out3,
renumber=False,
encoding=None,
size=16,
is_double=False,
cards_to_skip=None,
log=log)
read_bdf(bdf_filename_out1, log=log)
read_bdf(bdf_filename_out2, log=log)
read_bdf(bdf_filename_out3, log=log)
def test_bdf_aero_01(self):
"""checks aero/aerobeam.bdf"""
log = SimpleLogger(level='warning', encoding='utf-8')
bdf_filename = os.path.join(MODEL_PATH, 'aero', 'aerobeam.bdf')
fem1, fem2, diff_cards = self.run_bdf('', bdf_filename, log=log)
diff_cards2 = list(set(diff_cards))
diff_cards2.sort()
assert len(diff_cards2) == 0, diff_cards2
for fem in [fem1, fem2]:
assert fem.card_count['MAT1'] == 3, fem.card_count
assert fem.card_count['DCONADD'] == 2, fem.card_count
assert fem.card_count['MAT1'] == 3, fem.card_count
assert fem.card_count['DMI'] == 6, fem.card_count
assert fem.card_count['PAERO1'] == 1, fem.card_count
assert fem.card_count['EIGRL'] == 2, fem.card_count
assert fem.card_count['PBAR'] == 1, fem.card_count
assert fem.card_count['DESVAR'] == 3, fem.card_count
assert fem.card_count['DRESP1'] == 11, fem.card_count
assert fem.card_count['DRESP2'] == 6, fem.card_count
assert fem.card_count['SPC1'] == 4, fem.card_count
assert fem.card_count['AESTAT'] == 10, fem.card_count
assert fem.card_count['TRIM'] == 4, fem.card_count
assert fem.card_count['SPLINE2'] == 3, fem.card_count
assert fem.card_count['DVPREL1'] == 6, fem.card_count
assert fem.card_count['SUPORT1'] == 2, fem.card_count
assert fem.card_count['DCONSTR'] == 10, fem.card_count
assert fem.card_count['AELIST'] == 3, fem.card_count
assert fem.card_count['CORD2R'] == 6, fem.card_count
assert fem.card_count['CONM2'] == 10, fem.card_count
assert fem.card_count['ENDDATA'] == 1, fem.card_count
assert fem.card_count['AERO'] == 1, fem.card_count
assert fem.card_count['PARAM'] == 4, fem.card_count
assert fem.card_count['CBEAM'] == 3, fem.card_count
assert fem.card_count['GRID'] == 14, fem.card_count
assert fem.card_count['SET1'] == 5, fem.card_count
assert fem.card_count['MKAERO1'] == 1, fem.card_count
assert fem.card_count['PBEAML'] == 3, fem.card_count
assert fem.card_count['FLFACT'] == 5, fem.card_count
assert fem.card_count['AESURF'] == 3, fem.card_count
assert fem.card_count['DEQATN'] == 3, fem.card_count
assert fem.card_count['CBAR'] == 4, fem.card_count
assert fem.card_count['CAERO1'] == 3, fem.card_count
assert fem.card_count['AEROS'] == 1, fem.card_count
assert fem.card_count['FLUTTER'] == 4, fem.card_count
assert fem.card_count['DOPTPRM'] == 1, fem.card_count
def test_read_include_dir_1(self):
"""Tests various read methods using various include files"""
# fails correctly
log = SimpleLogger(level='info', encoding='utf-8')
model = BDF(log=log, debug=False)
bdf_name = os.path.join(TEST_PATH, 'test_include.bdf')
model.read_bdf(bdf_name, xref=True, punch=False)
#self.assertRaises(IOError, model.read_bdf, bdf_name, xref=True, punch=False)
# passes
#full_path = os.path.join(TEST_PATH, 'include_dir')
model2 = BDF(log=log, debug=False)
bdf_filename = 'test_include.bdf'
if not os.path.exists(bdf_filename):
bdf_filename = os.path.join(TEST_PATH, 'test_include.bdf')
model2.read_bdf(bdf_filename, xref=True, punch=False)
def test_bdf_superelement_4(self):
"""checks see101l8.bdf"""
bdf_filename = os.path.join(MODEL_PATH, 'superelements',
'see101l8.bdf')
log = SimpleLogger(level='error', encoding='utf-8')
(unused_fem1, unused_fem2, diff_cards) = self.run_bdf(
'',
bdf_filename,
xref=True,
run_extract_bodies=False,
save_file_structure=True,
log=log,
)
diff_cards2 = list(set(diff_cards))
diff_cards2.sort()
assert len(diff_cards2) == 0, diff_cards2
def _eq_header(self, table):
ScalarObject._eq_header(self, table)
is_nan = (self.nonlinear_factor is not None
and np.isnan(self.nonlinear_factor)
and np.isnan(table.nonlinear_factor))
if hasattr(self, 'element_name'):
if self.nonlinear_factor not in (None, np.nan) and not is_nan:
assert np.array_equal(
self._times,
table._times), 'ename=%s-%s times=%s table.times=%s' % (
self.element_name, self.element_type, self._times,
table._times)
log = SimpleLogger()
_check_element(self, table, log)
_check_element_node(self, table, log)
def test_shabp_1(self):
"""tests nose.mk5"""
log = SimpleLogger(level='info', encoding='utf-8')
shabp_filename = os.path.join(MODEL_PATH, 'nose', 'noseX_working.mk5')
model = read_shabp(shabp_filename, log=log)
npatches_expected = 1
assert len(
model.X
) == npatches_expected, f'npatches_expected={npatches_expected} len(model.X)={len(model.X)}'
assert len(
model.Y
) == npatches_expected, f'npatches_expected={npatches_expected} len(model.X)={len(model.Y)}'
assert len(
model.Z
) == npatches_expected, f'npatches_expected={npatches_expected} len(model.X)={len(model.Z)}'
#print(f'component_name_to_patch = {model.component_name_to_patch}')
#print(f'patch_to_component_num = {model.patch_to_component_num}')
#print(f'component_to_params = {model.component_to_params}')
#print(f'component_num_to_name = {model.component_num_to_name}')
#print(f'component_name_to_num = {model.component_name_to_num}')
assert model.component_name_to_patch == {
'ellipse': [1]
}, model.component_name_to_patch
assert model.patch_to_component_num == {
0: 1
}, model.patch_to_component_num
assert model.component_to_params == {
0: [5, 5, 1, 0, 0, 0.0, 1.0, 0.0, 1.0, 3.0, 3.0]
}, model.component_to_params
assert model.component_num_to_name == {
0: 'ellipse'
}, model.component_num_to_name
assert model.component_name_to_num == {
'ellipse': 0
}, model.component_name_to_num
areas = model.get_area_by_patch()
assert np.allclose(areas, [266.47640991]), areas
areas = model.get_area_by_component()
assert np.allclose(areas['ellipse'], 266.47640991), areas
areas, lengths = model.get_area_xlength_by_component()
assert np.allclose(areas['ellipse'], 266.47640991), areas
assert np.allclose(lengths['ellipse'], 20.0), lengths
def test_cut_plate_eids(self):
"""recover element ids"""
log = SimpleLogger(level='warning', encoding='utf-8', log_func=None)
bdf_filename = os.path.join(MODEL_PATH, 'plate_py', 'plate_py.dat')
model = read_bdf(bdf_filename, log=log)
nnodes = len(model.nodes)
nodal_result = np.ones(nnodes)
coord = CORD2R(1,
rid=0,
origin=[0., 0., 0.],
zaxis=[0., 0., 1],
xzplane=[1., 0., 0.],
comment='')
model.coords[1] = coord
ytol = 2.
unique_geometry_array, unique_results_array, unused_rods = cut_face_model_by_coord(
bdf_filename,
coord,
ytol,
nodal_result,
plane_atol=1e-5,
skip_cleanup=True,
csv_filename='cut_face.csv',
plane_bdf_filename='plane_face.bdf',
)
#print(unique_geometry_array)
#print(unique_results_array)
unique_geometry_array = np.array(unique_geometry_array)
unique_results_array = np.array(unique_results_array)
assert unique_geometry_array.shape == (1, 40,
4), unique_geometry_array.shape
assert unique_results_array.shape == (1, 40,
7), unique_results_array.shape
unique_geometry_array = unique_geometry_array[0, :, :]
unique_results_array = unique_results_array[0, :, :]
assert unique_geometry_array.shape == (40,
4), unique_geometry_array.shape
assert unique_results_array.shape == (40,
7), unique_results_array.shape
#print(unique_geometry_array)
#print(unique_results_array)
os.remove('cut_face.csv')
os.remove('plane_face.bdf')
def test_solid_bending(self):
"""tests solid_bending"""
log = SimpleLogger(level='warning')
bdf_filename = os.path.join(MODEL_PATH, 'solid_bending', 'solid_bending.bdf')
model = read_bdfv(bdf_filename, validate=True, xref=False, punch=False,
skip_cards=None, encoding=None, log=log, debug=False,
mode='msc')
#print(model.get_bdf_stats())
#model.grids[10] = GRID(10, [0., 0., 0.])
str(model.grid)
str(model.grid[10]) # nid or index?
str(model.grid.get_by_nid(10))
out_filename = 'spike.bdf'
model.write_bdf(out_filename, encoding=None, size=8, is_double=False,
interspersed=False, enddata=None,
close=True)
def _test_cut_box(self): # pragma: no cover
"""recover element ids"""
log = SimpleLogger(level='warning', encoding='utf-8', log_func=None)
#bdf_filename = r'SEction_1_box.bdf' # x-axis
#normal_plane = np.array([1., 0., 0.])
bdf_filename = 'SEction_1_box_4.bdf' # y-axis
normal_plane = np.array([0., 1., 0.])
dys, coords = get_coords_box()
y, A, I, J, EI, GJ, avg_centroid, plane_bdf_filenames = cut_and_plot_moi(
bdf_filename, normal_plane, log,
dys, coords,
ytol=0.0,
plot=True, show=True)
show = True
if IS_MATPLOTLIB:
plot_inertia(y, A, I, J, EI, GJ, avg_centroid, show=show)
def test_clear_out_solids(self):
"""tests clear_out_solids"""
deck = (
"$ pyNastran: punch=True\n"
"GRID,1\n"
"GRID,2\n"
"GRID,3\n"
"GRID,4\n"
"GRID,5\n"
"GRID,6\n"
"GRID,7\n"
"GRID,8\n"
"GRID,9\n"
"GRID,10\n"
"GRID,11\n"
"GRID,12\n"
"CHEXA,1,1, 5,6,7,8,9,10,\n"
",7,8\n"
"CQUAD4,2,200, 1,2,3,4\n"
# doesn't work
#"CHEXA,1,1, 1,2,3,4,5,6,\n"
#",7,8\n"
#"CQUAD4,2,200, 8,9,10,11\n"
"PSHELL,200,1000,0.1\n"
"PSOLID,100,1000\n"
"MAT1,1000,3.0e7,,0.3\n")
bdf_filename = 'deck.bdf'
bdf_clean_filename = 'clean.bdf'
with open(bdf_filename, 'w') as bdf_file:
bdf_file.write(deck)
log = SimpleLogger(level='warning', encoding='utf-8')
model = read_bdf(bdf_filename, xref=False, log=log)
clear_out_solids(model,
bdf_clean_filename,
renumber=True,
equivalence=False,
equivalence_tol=0.01)
model = read_bdf(bdf_clean_filename, log=log)
assert len(model.nodes) == 4, len(model.nodes)
assert len(model.elements) == 1, len(model.elements)
os.remove(bdf_filename)
os.remove(bdf_clean_filename)
def test_add_card_fail(self):
log = SimpleLogger(level='info', encoding='utf-8')
model = BDF(log=log, debug=False)
card_lines1 = ['GRID', 1, 'a', 'b', 'c']
card_lines2 = ['GRID', 1, 'd', 'e', 'f']
with self.assertRaises(SyntaxError):
model.add_card(card_lines1, 'GRID')
model.set_error_storage(nparse_errors=100,
stop_on_parsing_error=True,
nxref_errors=100,
stop_on_xref_error=True)
card_lines3 = ['GMSPC', 1, 'd', 'e', 'f']
model.add_card(card_lines3, 'GMSPC')
card_lines4 = ['GRDSET', 1, 'd2', 'e2', 'f2']
model.add_card(card_lines4, 'GRDSET')
def test_export_mcids(self):
"""creates material coordinate systems"""
log = SimpleLogger(level='error')
bdf_filename = os.path.join(MODEL_PATH, 'bwb', 'bwb_saero.bdf')
csv_filename = os.path.join(MODEL_PATH, 'bwb', 'mcids.csv')
export_mcids(bdf_filename, csv_filename,
export_xaxis=True, export_yaxis=True,
iply=9, log=log, debug=False)
model = read_bdf(bdf_filename, xref=False, debug=False)
model.safe_cross_reference()
#os.remove('mcids.csv')
argv = ['bdf', 'export_mcids', bdf_filename, '-o', csv_filename,
'--iplies', '0,1,2,3,4,5,6,7,8,9,10', '--no_x', '--no_y']
with self.assertRaises(DocoptExit):
# can't define both --no_x and --no_y
cmd_line(argv=argv, quiet=True)
argv = ['bdf', 'export_mcids', bdf_filename, '-o', csv_filename,
'--iplies', '0,1,2,3,4,5,6,7,8,9', '--no_x']
cmd_line(argv=argv, quiet=True)
eids = [1204, 1211]
export_mcids(model, csv_filename=None, eids=eids,
export_xaxis=True, export_yaxis=True,
iply=9, log=log, debug=False)
export_mcids(model, csv_filename=None, eids=eids,
export_xaxis=True, export_yaxis=False,
iply=9, log=log, debug=False)
export_mcids(model, csv_filename=None, eids=eids,
export_xaxis=False, export_yaxis=True,
iply=9, log=log, debug=False)
with self.assertRaises(AssertionError):
# export_xaxis and export_yaxis can't both be False
export_mcids(model, csv_filename=None, eids=eids,
export_xaxis=False, export_yaxis=False,
iply=9)
with self.assertRaises(RuntimeError):
# no iply=10
export_mcids(model, csv_filename, eids=eids,
export_xaxis=True, export_yaxis=True,
iply=10)
def test_encoding_write(self):
"""tests encodings in BDF header"""
log = SimpleLogger(level='info', encoding='utf-8')
mesh = BDF(log=log, debug=False)
mesh.add_card(['GRID', 100000, 0, 43.91715, -29., .8712984], 'GRID')
mesh.write_bdf('out.bdf')
lines_expected = [
'$pyNastran: version=msc',
'$pyNastran: punch=True',
'$pyNastran: encoding=utf-8\n',
'$pyNastran: nnodes=1',
'$pyNastran: nelements=0',
'$NODES',
'GRID 100000 43.91715 -29..8712984',
]
bdf_filename = 'out.bdf'
with open(bdf_filename, 'r', encoding='ascii') as bdf_file:
lines = bdf_file.readlines()
compare_lines(self, lines, lines_expected, has_endline=False)
def test_convert_02(self):
"""converts a full model units"""
log = SimpleLogger(level='error')
bdf_filename = os.path.abspath(
os.path.join(pkg_path, '..', 'models', 'bwb', 'bwb_saero.bdf'))
bdf_filename_out = os.path.abspath(
os.path.join(pkg_path, '..', 'models', 'bwb', 'bwb_saero.out'))
model = read_bdf(bdf_filename, log=log)
units_to = ['m', 'kg', 's']
units_from = ['in', 'lbm', 's']
#units_to = units_from
convert(model, units_to, units_from)
model.write_bdf(bdf_filename_out)
caero_bdf_filename = 'caero.bdf'
export_caero_mesh(model, caero_bdf_filename=caero_bdf_filename)
os.remove(bdf_filename_out)
os.remove(caero_bdf_filename)
def test_renumber_01(self):
"""renumber a bdf"""
log = SimpleLogger(level='warning')
bdf_filename = os.path.abspath(
os.path.join(pkg_path, '..', 'models', 'bwb', 'bwb_saero.bdf'))
bdf_filename_out1 = os.path.abspath(
os.path.join(pkg_path, '..', 'models', 'bwb', 'bwb_saero1.out'))
bdf_filename_out2 = os.path.abspath(
os.path.join(pkg_path, '..', 'models', 'bwb', 'bwb_saero2.out'))
bdf_filename_out3 = os.path.abspath(
os.path.join(pkg_path, '..', 'models', 'bwb', 'bwb_saero3.out'))
model = bdf_renumber(bdf_filename,
bdf_filename_out1,
size=8,
is_double=False,
starting_id_dict=None,
round_ids=False,
cards_to_skip=None)
model = read_bdf(bdf_filename, log=log)
bdf_renumber(model,
bdf_filename_out2,
size=16,
is_double=False,
starting_id_dict={
'eid': 1000,
'pid': 2000,
'mid': 3000,
'spc_id': 4000,
},
round_ids=False,
cards_to_skip=None)
bdf_renumber(bdf_filename,
bdf_filename_out3,
size=8,
is_double=False,
starting_id_dict=None,
round_ids=True,
cards_to_skip=None)
read_bdf(bdf_filename_out1, log=log)
read_bdf(bdf_filename_out2, log=log)
read_bdf(bdf_filename_out3, log=log)
def test_nastran_to_tecplot(self):
"""tests a large number of elements and results in SOL 101"""
bdf_filename = os.path.join(MODEL_PATH, 'elements',
'static_elements.bdf')
tecplot_filename = os.path.join(MODEL_PATH, 'elements',
'static_elements.plt')
tecplot_filename2 = os.path.join(MODEL_PATH, 'elements',
'static_elements2.plt')
log = SimpleLogger(level='warning', encoding='utf-8')
model = read_bdf(bdf_filename, log=log)
with self.assertRaises(RuntimeError):
nastran_to_tecplot(model)
nastran_to_tecplot_filename(bdf_filename, tecplot_filename, log=log)
argv = [
'format_converter', 'nastran', bdf_filename, 'tecplot',
tecplot_filename2
]
with self.assertRaises(RuntimeError):
cmd_line_format_converter(argv=argv, quiet=True)
def test_convert_isat(self):
"""converts a isat model"""
log = SimpleLogger(level='error')
model_path = os.path.join(pkg_path, '..', 'models', 'iSat')
bdf_filename = os.path.join(model_path, 'ISat_Dploy_Sm.dat')
bdf_filename_out = os.path.join(model_path, 'isat.bdf')
bdf_filename_out2 = os.path.join(model_path, 'isat_converted.bdf')
model = read_bdf(bdf_filename, log=log, validate=False)
#card_lines = ['EIGRL', 42, None, None, 20]
#model.add_card(card_lines, 'EIGRL')
#model.case_control_deck = CaseControlDeck(lines)
model.write_bdf(bdf_filename_out)
#units_from = ['in', 'lbm', 's']
units_from = ['mm', 'Mg', 's']
units_to = ['m', 'kg', 's']
convert(model, units_to, units=units_from)
model.write_bdf(bdf_filename_out2)
os.remove(bdf_filename_out)
os.remove(bdf_filename_out2)
def test_add_card_skip(self):
"""tests that a fake card 'JUNK' is skipped"""
log = SimpleLogger(level='info', encoding='utf-8')
model = BDF(log=log, debug=False)
card_name = 'JUNK'
card_lines1 = ['JUNK', 1, 2, 3]
card_lines2 = ['JUNK,a,b,c']
model.add_card(card_lines1, card_name)
model.add_card(card_lines2,
card_name,
comment='',
is_list=False,
has_none=True)
bdf_file = StringIO()
model.write_bdf(bdf_file, close=False)
msg = bdf_file.getvalue()
bdf_file.close()
assert 'JUNK 1 2 3' in msg, msg
assert 'JUNK a b c' in msg, msg
def test_convert_01(self):
"""converts the CONM2s units"""
log = SimpleLogger(level='error')
model = BDF(log=log)
eid = 1000
nid = 100
cid = 0
mass = 247200. # kg
X = [30.16, 0., 3.55] # m
I11 = 1.39e7 # kg-m^2
I22 = 3.66e7
I33 = 4.99e7
I13 = I12 = I23 = 0.
I = I11, I12, I22, I13, I23, I33
elem = CONM2(eid, nid, mass, cid=cid, X=X, I=I, comment='')
model.masses[eid] = elem
units_to = ['in', 'lbm', 's']
units_from = ['m', 'kg', 's']
convert(model, units_to, units=units_from)
def test_cut_plate(self):
"""mode 10 is a sine wave"""
log = SimpleLogger(level='warning', encoding='utf-8', log_func=None)
bdf_filename = os.path.join(MODEL_PATH, 'plate_py', 'plate_py.dat')
op2_filename = os.path.join(MODEL_PATH, 'plate_py', 'plate_py.op2')
model = read_bdf(bdf_filename, log=log)
op2_model = read_op2_geom(op2_filename, log=log)
title = 'Mode 10 Eigenvector'
p1 = None
p2 = None
zaxis = None
coord = CORD2R(1, rid=0, origin=[0., 0., 0.], zaxis=[0., 0., 1], xzplane=[1., 0., 0.],
comment='')
model.coords[1] = coord
ytol = 2.
# no result
nodal_result = None
cut_and_plot_model(title, p1, p2, zaxis,
model, coord, nodal_result, model.log, ytol,
plane_atol=1e-5, csv_filename=None, invert_yaxis=False,
cut_type='edge', plot=False, show=False)
# real
nodal_result = op2_model.eigenvectors[1].data[9, :, 2]
cut_and_plot_model(title, p1, p2, zaxis,
model, coord, nodal_result, model.log, ytol,
plane_atol=1e-5, csv_filename='real_result.csv', invert_yaxis=False,
cut_type='edge', plot=IS_MATPLOTLIB, show=False)
# complex
nodal_result2 = np.asarray(nodal_result, dtype='complex64')
nodal_result2.imag = -nodal_result.real
cut_and_plot_model(title, p1, p2, zaxis,
model, coord, nodal_result2, model.log, ytol,
plane_atol=1e-5, csv_filename='complex_result.csv', invert_yaxis=True,
cut_type='edge', plot=IS_MATPLOTLIB, show=False)
os.remove('real_result.csv')
os.remove('complex_result.csv')
def test_isat_02():
"""vectorized vs. standard test on ISat_Launch_Sm_4pt.dat"""
log = SimpleLogger(level='error')
bdf_filename = os.path.join(test_path, 'iSat',
'ISat_Launch_Sm_4pt.dat')
bdf_filename_outv = os.path.join(test_path, 'iSat',
'ISat_Launch_Sm_4ptv.dat')
bdf_filename_out = os.path.join(test_path, 'iSat',
'ISat_Launch_Sm_4pt2.dat')
vmodel = read_bdfv(bdf_filename)
vmodel.write_bdf(bdf_filename_outv)
model = read_bdf(bdf_filename, log=log)
model.write_bdf(bdf_filename_out)
run_and_compare_fems(
bdf_filename,
bdf_filename_outv,
debug=False,
xref=True,
check=True,
punch=False,
cid=None,
mesh_form=None,
print_stats=False,
encoding=None,
sum_load=False,
size=8,
is_double=False,
stop=False,
nastran='',
post=-1,
dynamic_vars=None,
quiet=False,
dumplines=False,
dictsort=False,
nerrors=0,
dev=False,
crash_cards=None,
)
os.remove(bdf_filename_out)
def test_cgen(self):
"""tests CGEN"""
log = SimpleLogger(level='warning')
model = BDF(log=log, debug=False)
model.add_grid(1, [0., 0., 0.])
model.add_grid(2, [1., 0., 0.])
model.add_grid(3, [1., 1., 0.])
model.add_grid(4, [0., 1., 0.])
#feedge = model.add_feedge()
Type = 10
field_eid = 'cat'
pid = 20
field_id = 30
th_geom_opt = 301.
eidl = 40
eidh = 50
cgen = CGEN(Type, field_eid, pid, field_id, th_geom_opt,
eidl, eidh)
cgen.raw_fields()
str(cgen)
def test_bdf_transfer_function_01(self):
"""checks transfer_function/actuator_tf_modeling.bdf"""
log = SimpleLogger(level='warning', encoding='utf-8')
bdf_filename = os.path.join(MODEL_PATH, 'transfer_function',
'actuator_tf_modeling.bdf')
fem1, fem2, diff_cards = self.run_bdf('', bdf_filename, log=log)
diff_cards2 = list(set(diff_cards))
diff_cards2.sort()
assert len(diff_cards2) == 0, diff_cards2
for fem in [fem1, fem2]:
assert fem.card_count['CONM2'] == 3, fem.card_count
assert fem.card_count['SPOINT'] == 1, fem.card_count
assert fem.card_count['EPOINT'] == 1, fem.card_count
assert fem.card_count['PARAM'] == 1, fem.card_count
assert fem.card_count['CELAS2'] == 2, fem.card_count
assert fem.card_count['GRID'] == 3, fem.card_count
assert fem.card_count['EIGR'] == 1, fem.card_count
assert fem.card_count['EIGC'] == 1, fem.card_count
assert fem.card_count['MPC'] == 1, fem.card_count
assert fem.card_count['TF'] == 2, fem.card_count
def test_tecplot_box(self):
"""simple UGRID3D box model"""
ugrid_filename = os.path.join(UGRID_PATH, 'box.b8.ugrid')
log = SimpleLogger(level='warning', encoding='utf-8')
tecplot_filename2 = os.path.join(TECPLOT_PATH, 'box.plt')
#ugrid_model = read_ugrid(ugrid_filename, log=log)
tecplot = ugrid3d_to_tecplot_filename(ugrid_filename,
tecplot_filename2,
log=log)
tecplot.write_tecplot(tecplot_filename2,
res_types=None,
adjust_nids=True)
test = TecplotGUI()
test.log = log
tecplot_filename = os.path.join(TECPLOT_PATH, 'models', 'ascii',
'point_fetri_2d_02.dat')
test.on_load_geometry(tecplot_filename,
geometry_format='tecplot',
raise_error=True)
def test_bdf_02(self):
"""checks plate_py.dat"""
log = SimpleLogger(level='warning', encoding='utf-8')
bdf_filename = os.path.join(MODEL_PATH, 'plate_py', 'plate_py.dat')
self.run_bdf('', bdf_filename, log=log)
fem1, fem2, diff_cards = self.run_bdf('', bdf_filename, xref=True)
etype_to_eids_pids_nids = fem1.get_elements_properties_nodes_by_element_type(
)
assert len(etype_to_eids_pids_nids) == 1, list(
etype_to_eids_pids_nids.keys())
#etype_to_eids_pids_nids[etype] : [eids, pids, nids]
unused_eids, pids, unused_node_ids = etype_to_eids_pids_nids['CQUAD4']
assert pids.min() == 1, pids.min()
assert pids.max() == 1, pids.max()
etype_pid_to_eids_nids, _etype_to_eids_pids_nids = fem1.get_elements_nodes_by_property_type(
dtype='int32', save_element_types=False)
#etype_pid_to_eids_nids[(etype, pid)] : [eids, nids]
assert _etype_to_eids_pids_nids is None, _etype_to_eids_pids_nids
assert len(etype_pid_to_eids_nids) == 1, list(
etype_pid_to_eids_nids.keys())
diff_cards2 = list(set(diff_cards))
diff_cards2.sort()
assert len(diff_cards2) == 0, diff_cards2
for fem in [fem1, fem2]:
assert len(fem.coords) == 3, 'len(coords) = %i' % len(fem.coords)
assert len(fem.params) == 6, 'len(params) = %i' % len(fem.params)
assert len(fem.nodes) == 231, 'len(nodes) = %i' % len(fem.nodes)
assert len(
fem.materials) == 1, 'len(materials) = %i' % len(fem.materials)
assert len(
fem.elements) == 200, 'len(elements) = %i' % len(fem.elements)
assert len(
fem.methods) == 1, 'len(methods) = %i' % len(fem.methods)
assert len(fem.properties) == 1, 'len(properties) = %i' % len(
fem.properties)
compare_mass_cg_inertia(fem1)
def test_eq1(self):
"""Collapse nodes 2 and 3; consider 1-3"""
log = SimpleLogger(level='error')
msg = ('CEND\n'
'BEGIN BULK\n'
'GRID,1,,0.,0.,0.\n'
'GRID,2,,0.,0.,0.5\n'
'GRID,3,,0.,0.,0.51\n'
'GRID,10,,0.,0.,1.\n'
'GRID,11,,0.,0.,1.\n'
'CTRIA3,1,1,1,2,11\n'
'CTRIA3,3,1,2,3,11\n'
'CTRIA3,4,1,1,2,10\n'
'PSHELL,1,1,0.1\n'
'MAT1,1,3.0,, 0.3\n'
'ENDDATA')
bdf_filename = 'nonunique.bdf'
bdf_filename_out = 'unique.bdf'
with open(bdf_filename, 'w') as bdf_file:
bdf_file.write(msg)
tol = 0.2
bdf_equivalence_nodes(bdf_filename,
bdf_filename_out,
tol,
renumber_nodes=False,
neq_max=4,
xref=True,
node_set=None,
crash_on_collapse=False,
log=log,
debug=False)
# model = BDF(debug=False)
# model.read_bdf(bdf_filename_out)
# assert len(model.nodes) == 3, len(model.nodes)
os.remove(bdf_filename)
os.remove(bdf_filename_out)
def test_renumber_05(self):
"""renumbers a deck in a couple ways"""
log = SimpleLogger(level='error')
bdf_filename = os.path.join(MODEL_PATH, 'bwb', 'bwb_saero.bdf')
bdf_filename_out1 = os.path.join(MODEL_PATH, 'bwb', 'bwb_saero1.out')
bdf_filename_out2 = os.path.join(MODEL_PATH, 'bwb', 'bwb_saero2.out')
bdf_filename_out3 = os.path.join(MODEL_PATH, 'bwb', 'bwb_saero3.out')
model = bdf_renumber(bdf_filename,
bdf_filename_out1,
size=8,
is_double=False,
starting_id_dict=None,
round_ids=False,
cards_to_skip=None,
debug=False)
model = read_bdf(bdf_filename, log=log)
bdf_renumber(model,
bdf_filename_out2,
size=16,
is_double=False,
starting_id_dict={
'eid': 1000,
'pid': 2000,
'mid': 3000,
'spc_id': 4000,
},
round_ids=False,
cards_to_skip=None)
bdf_renumber(bdf_filename,
bdf_filename_out3,
size=8,
is_double=False,
starting_id_dict=None,
round_ids=True,
cards_to_skip=None)
read_bdf(bdf_filename_out1, log=log)
read_bdf(bdf_filename_out2, log=log)
read_bdf(bdf_filename_out3, log=log)
def test_bdf_06(self):
"""checks bar3truss/vared_bar3.bdf"""
log = SimpleLogger(level='warning', encoding='utf-8')
bdf_filename = os.path.join(MODEL_PATH, 'bar3truss', 'vared_bar3.bdf')
dynamic_vars = {
'bar1_a': 1.0,
'bar2_a': 1.0,
'bar3_a': 1.0,
'loadx': 1.0,
'loady': 1.0,
'loadmag': 10000.,
'youngs': 1e7,
'rho': 0.01,
}
fem1, fem2, diff_cards = self.run_bdf('',
bdf_filename,
dynamic_vars=dynamic_vars,
log=log)
diff_cards2 = list(set(diff_cards))
diff_cards2.sort()
assert len(diff_cards2) == 0, diff_cards2
for fem in [fem1, fem2]:
assert len(fem.params) == 4, 'len(params) = %i' % len(fem.params)
assert len(fem.coords) == 1, 'len(coords) = %i' % len(fem.coords)
assert len(fem.nodes) == 4, 'len(nodes) = %i' % len(fem.nodes)
assert len(
fem.materials) == 1, 'len(materials) = %i' % len(fem.materials)
assert len(
fem.elements) == 3, 'len(elements) = %i' % len(fem.elements)
assert len(
fem.methods) == 0, 'len(methods) = %i' % len(fem.methods)
assert len(fem.properties) == 3, 'len(properties) = %i' % len(
fem.properties) # PBEAML issue
fem1.cross_reference()
fem1.pop_xref_errors()
compare_mass_cg_inertia(fem1)
def test_include_05(self):
log = SimpleLogger(level='info', encoding='utf-8')
with open('include5.bdf', 'w') as bdf_file:
bdf_file.write('$ pyNastran: punch=True\n')
bdf_file.write('$ pyNastran: dumplines=True\n')
bdf_file.write("INCLUDE 'include5b.inc'\n\n")
with open('include5b.inc', 'w') as bdf_file:
bdf_file.write('ECHOON\n')
bdf_file.write('$ GRID comment\n')
bdf_file.write('GRID,2,,2.0\n')
bdf_file.write('ECHOOFF\n')
bdf_file.write('GRID,3,,3.0\n')
bdf_file.write('grid,4,,4.0\n')
bdf_file.write('grid ,5,,5.0\n')
model = BDF(log=log, debug=False)
model.read_bdf('include5.bdf')
assert model.echo is False, model.echo
#model.write_bdf('include5.out.bdf')
# os.remove('c.bdf')
# os.remove('executive_control.inc')
# os.remove('case_control.inc')
self.assertEqual(len(model.nodes), 4)
self.assertEqual(model.nnodes, 4, 'nnodes=%s' % model.nnodes)
model2 = read_bdf(bdf_filename='include5.bdf',
xref=True,
punch=False,
log=log,
encoding=None)
self.assertEqual(len(model2.nodes), 4)
self.assertEqual(model2.nnodes, 4, 'nnodes=%s' % model.nnodes)
os.remove('include5.bdf')
#os.remove('include5.out.bdf')
os.remove('include5b.inc')
os.remove('pyNastran_dump.bdf')
def test_include_03(self):
"""tests executive/case control includes"""
log = SimpleLogger(level='info', encoding='utf-8')
with open('a.bdf', 'w') as bdf_file:
bdf_file.write("INCLUDE 'executive_control.inc'\n\n")
bdf_file.write('CEND\n')
bdf_file.write("INCLUDE 'case_control.inc'\n\n")
bdf_file.write('BEGIN BULK\n')
bdf_file.write('GRID,1,,1.0\n')
bdf_file.write("INCLUDE 'b.bdf'\n\n")
bdf_file.write('GRID,4,,4.0\n')
with open('executive_control.inc', 'w') as bdf_file:
bdf_file.write('SOL = 103\n')
with open('case_control.inc', 'w') as bdf_file:
bdf_file.write('DISP = ALL\n')
with open('b.bdf', 'w') as bdf_file:
bdf_file.write('GRID,2,,2.0\n')
bdf_file.write("INCLUDE 'c.bdf'\n\n")
bdf_file.write('GRID,5,,5.0\n')
with open('c.bdf', 'w') as bdf_file:
bdf_file.write('GRID,3,,3.0\n\n')
model = BDF(log=log, debug=False)
model.read_bdf('a.bdf')
model.write_bdf('a.out.bdf')
os.remove('a.bdf')
os.remove('b.bdf')
os.remove('c.bdf')
os.remove('executive_control.inc')
os.remove('case_control.inc')
os.remove('a.out.bdf')
self.assertEqual(len(model.nodes), 5)
self.assertEqual(model.nnodes, 5, 'nnodes=%s' % model.nnodes)
