def test_write_fistr_lte_full(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/thermal_full',
read_npy=False,
save=False)
write_dir_name = 'tests/data/fistr/write_thermal_full'
if os.path.exists(write_dir_name):
shutil.rmtree(write_dir_name)
fem_data.write('fistr', write_dir_name + '/mesh')
written_fem_data = FEMData.read_directory('fistr',
write_dir_name,
read_npy=False,
save=False)
np.testing.assert_almost_equal(
written_fem_data.elemental_data.get_attribute_data('lte_full'),
fem_data.elemental_data.get_attribute_data('lte_full'),
)
if RUN_FISTR:
subprocess.check_call("fistr1", cwd=write_dir_name, shell=True)
written_fem_data_with_res = FEMData.read_directory('fistr',
write_dir_name,
read_npy=False,
save=False)
np.testing.assert_almost_equal(
written_fem_data_with_res.nodal_data['DISPLACEMENT'].data,
fem_data.nodal_data['DISPLACEMENT'].data,
decimal=5)
def test_write_fistr_convert_lte_full_to_lte_local_1(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/thermal_full_easy',
read_npy=False,
save=False)
write_dir_name = 'tests/data/fistr/write_thermal_convert_easy'
if os.path.exists(write_dir_name):
shutil.rmtree(write_dir_name)
fem_data.convert_lte_global2local()
np.testing.assert_almost_equal(
fem_data.elemental_data.get_attribute_data('lte')[0] * 1e7,
np.array([1.0, 2.0, 3.0]))
fem_data.write('fistr', write_dir_name + '/mesh')
if RUN_FISTR:
subprocess.check_call("fistr1", cwd=write_dir_name, shell=True)
written_fem_data_with_res = FEMData.read_directory('fistr',
write_dir_name,
read_npy=False,
save=False)
np.testing.assert_almost_equal(
written_fem_data_with_res.elemental_data.get_attribute_data(
'ElementalSTRAIN'),
fem_data.elemental_data.get_attribute_data('ElementalSTRAIN'),
decimal=5)
def test_read_heat_nl_tensor_material(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/heat_nl_tensor',
read_npy=False,
save=False)
heat_res = FEMData.read_files(
'ucd', 'tests/data/fistr/heat_nl_tensor/hex_vis_psf.0100.inp')
write_dir_name = Path('tests/data/fistr/write_heat_nl_tensor')
if os.path.exists(write_dir_name):
shutil.rmtree(write_dir_name)
fem_data.write('fistr', file_name=write_dir_name / 'mesh')
written_fem_data = FEMData.read_directory('fistr',
write_dir_name,
read_npy=False,
save=False)
np.testing.assert_almost_equal(
written_fem_data.materials['thermal_conductivity_full'].values[0,
0],
fem_data.materials['thermal_conductivity_full'].values[0, 0])
if RUN_FISTR:
subprocess.check_call("fistr1", cwd=write_dir_name, shell=True)
written_res_data = FEMData.read_files(
'ucd', write_dir_name / 'mesh_vis_psf.0100.inp')
np.testing.assert_almost_equal(
written_res_data.nodal_data.get_attribute_data('TEMPERATURE'),
heat_res.nodal_data.get_attribute_data('TEMPERATURE'))
def test_read_heat_nl_tensor_material_long_value(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/heat_nl_tensor',
read_npy=False,
save=False)
write_dir_name = Path('tests/data/fistr/write_heat_nl_tensor_long')
if os.path.exists(write_dir_name):
shutil.rmtree(write_dir_name)
raw_conductivity = np.array([
[1., 2., 3., .01, .02, .03, -1.],
[2., 4., 6., .02, .04, .06, 1.],
]) * 1e-3 * np.random.rand()
conductivity = np.array([[raw_conductivity, 0]], dtype=object)[:, [0]]
fem_data.materials.update_data(
'STEEL', {'thermal_conductivity_full': conductivity},
allow_overwrite=True)
fem_data.write('fistr', file_name=write_dir_name / 'mesh')
written_fem_data = FEMData.read_directory('fistr',
write_dir_name,
read_npy=False,
save=False)
np.testing.assert_almost_equal(
written_fem_data.materials['thermal_conductivity_full'].values[0,
0],
conductivity[0, 0])
if RUN_FISTR:
subprocess.check_call("fistr1", cwd=write_dir_name, shell=True)
self.assertTrue(
(write_dir_name / 'mesh_vis_psf.0100.inp').exists())
def test_write_fistr_overwrite_material(self):
fem_data = FEMData.read_directory(
'fistr',
'tests/data/fistr/thermal_to_overwrite',
read_npy=False,
save=False)
mean_pos = fem_data.convert_nodal2elemental(
fem_data.nodal_data.get_attribute_data('node'), calc_average=True)
new_lte_full = np.einsum(
'ij,i->ij', fem_data.elemental_data.get_attribute_data('lte_full'),
mean_pos[:, 0] + mean_pos[:, 1])
fem_data.elemental_data.overwrite('lte_full', new_lte_full)
write_dir_name = Path('tests/data/fistr/write_overtewrite')
if os.path.exists(write_dir_name):
shutil.rmtree(write_dir_name)
fem_data.write('fistr', file_name=write_dir_name / 'mesh')
written_fem_data = FEMData.read_directory('fistr',
write_dir_name,
read_npy=False,
save=False)
np.testing.assert_almost_equal(
written_fem_data.elemental_data.get_attribute_data('lte_full'),
new_lte_full)
if RUN_FISTR:
subprocess.check_call("fistr1", cwd=write_dir_name, shell=True)
vis_files = glob(str(write_dir_name / '*.inp'))
self.assertTrue(len(vis_files) == 2)
def test_write_spring_from_array(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/tet_3',
read_npy=False,
save=False)
fem_data.constraints = {
'spring':
FEMAttribute('spring', fem_data.elements.data[0, :3],
np.ones((3, 3)) * 1e-6)
}
write_dir_name = Path('tests/data/fistr/write_spring_from_array')
if os.path.exists(write_dir_name):
shutil.rmtree(write_dir_name)
fem_data.write('fistr', file_name=write_dir_name / 'mesh')
written_fem_data = FEMData.read_directory('fistr',
write_dir_name,
read_npy=False,
save=False)
original_constraints_data = fem_data.constraints['spring'].data
written_constraints_data = written_fem_data.constraints['spring'].data
np.testing.assert_almost_equal(
original_constraints_data[~np.isnan(original_constraints_data)],
written_constraints_data[~np.isnan(written_constraints_data)])
if RUN_FISTR:
subprocess.check_call("fistr1", cwd=write_dir_name, shell=True)
vis_files = glob(str(write_dir_name / '*.inp'))
self.assertTrue(len(vis_files) > 0)
def test_write_fistr_thermal_wo_density_material_overwritten(self):
fem_data = FEMData.read_directory(
'fistr',
'tests/data/fistr/thermal_wo_density',
read_npy=False,
save=False)
write_dir_name = 'tests/data/fistr/write_thermal_wo_density_overwrite'
if os.path.exists(write_dir_name):
shutil.rmtree(write_dir_name)
fem_data.elemental_data.overwrite(
'Young_modulus',
fem_data.elemental_data.get_attribute_data('Young_modulus') + .1)
fem_data.write('fistr', file_name=os.path.join(write_dir_name, 'mesh'))
written_fem_data = FEMData.read_directory('fistr',
write_dir_name,
read_npy=False,
save=False)
np.testing.assert_almost_equal(
written_fem_data.elemental_data.get_attribute_data('lte'),
fem_data.elemental_data.get_attribute_data('lte'))
if RUN_FISTR:
subprocess.check_call("fistr1", cwd=write_dir_name, shell=True)
written_fem_data_with_res = FEMData.read_directory('fistr',
write_dir_name,
read_npy=False,
save=False)
np.testing.assert_almost_equal(
written_fem_data_with_res.nodal_data['DISPLACEMENT'].data,
fem_data.nodal_data['DISPLACEMENT'].data,
decimal=5)
def test_write_fistr_6dof_boundary(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/mixture_shell',
read_npy=False,
save=False)
disp = np.random.rand(3, 6)
fem_data.constraints.pop('boundary')
fem_data.constraints.update_data(np.array([1, 2, 3]),
{'boundary': disp})
write_dir_name = 'tests/data/fistr/write_6dof_boundary'
if os.path.exists(write_dir_name):
shutil.rmtree(write_dir_name)
fem_data.write('fistr', write_dir_name + '/mesh', overwrite=True)
written_fem_data = FEMData.read_directory('fistr',
write_dir_name,
read_npy=False,
save=False)
np.testing.assert_almost_equal(written_fem_data.nodes.data,
fem_data.nodes.data)
if RUN_FISTR:
subprocess.check_call("fistr1", cwd=write_dir_name, shell=True)
written_fem_data_with_res = FEMData.read_directory('fistr',
write_dir_name,
read_npy=False,
save=False)
np.testing.assert_almost_equal(
written_fem_data_with_res.nodal_data['DISPLACEMENT'].data[:3],
disp,
decimal=5)
def test_write_fistr_from_npy(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/npy/mixture_solid',
read_npy=True,
save=False)
write_dir_name = 'tests/data/fistr/write_from_npy'
if os.path.exists(write_dir_name):
shutil.rmtree(write_dir_name)
fem_data.write('fistr', write_dir_name + '/mesh', overwrite=True)
written_fem_data = FEMData.read_directory('fistr',
write_dir_name,
read_npy=False,
save=False)
np.testing.assert_almost_equal(written_fem_data.nodes.data,
fem_data.nodes.data)
if RUN_FISTR:
subprocess.check_call("fistr1", cwd=write_dir_name, shell=True)
written_fem_data_with_res = FEMData.read_directory('fistr',
write_dir_name,
read_npy=False,
save=False)
np.testing.assert_almost_equal(
written_fem_data_with_res.nodal_data['DISPLACEMENT'].data,
fem_data.nodal_data['DISPLACEMENT'].data,
decimal=5)
def test_fistr_read_new_res_format(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/tet2_3_new_res',
read_npy=False,
save=False)
old_fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/tet2_3',
read_npy=False,
save=False)
np.testing.assert_almost_equal(
fem_data.nodal_data.get_attribute_data('displacement'),
old_fem_data.nodal_data.get_attribute_data('displacement'))
def test_fistr_res_multilines(self):
fem_data = FEMData.read_directory(
'fistr',
'tests/data/fistr/thermal_res_multilines',
read_npy=False,
save=False)
desired_nodal_mises = np.array([[
1.0898350105447997E+04,
1.3781943598714706E+04,
1.4294185117208786E+04,
1.8647204885291405E+04,
9.3792804821633508E+03,
7.3153108344243292E+03,
6.7785975728721169E+03,
5.1787984147854413E+03,
7.4483454706158540E+01,
6.4159304887717994E+01,
4.9329405740780402E+01,
2.9528125358349683E+01,
]]).T
np.testing.assert_almost_equal(fem_data.nodal_data['NodalMISES'].data,
desired_nodal_mises)
desired_elemental_mises = np.array([
[1.2858939470519477E+01],
[5.7457980475401499E+01],
])
np.testing.assert_almost_equal(
fem_data.elemental_data['ElementalMISES'].data,
desired_elemental_mises)
def test_filter_first_order_nodes_disordered(self):
fem_data = FEMData.read_directory(
'fistr', 'tests/data/fistr/tet2_3_node_disordered', read_npy=False)
filter_ = fem_data.filter_first_order_nodes()
desired_nodes = [1, 2, 3, 14, 5, 6, 7] # Respecting the order
np.testing.assert_array_equal(fem_data.nodes.ids[filter_],
desired_nodes)
def test_calculate_adjacency_matrix_element_hex_hexprism(self):
data_directory = pathlib.Path('tests/data/vtk/mix_hex_hexprism')
fem_data = FEMData.read_directory('vtk',
data_directory,
save=False,
read_npy=False)
adj = fem_data.calculate_adjacency_matrix_element()
desired_adj = {
0: [0, 5, 10, 11, 14, 15],
1: [1, 6, 10, 12, 14, 16],
2: [2, 7, 10, 11, 12, 13, 14, 15, 16, 17],
3: [3, 8, 11, 13, 15, 17],
4: [4, 9, 12, 13, 16, 17],
5: [0, 5, 10, 11, 14, 15],
6: [1, 6, 10, 12, 14, 16],
7: [2, 7, 10, 11, 12, 13, 14, 15, 16, 17],
8: [3, 8, 11, 13, 15, 17],
9: [4, 9, 12, 13, 16, 17],
10: [0, 1, 2, 5, 6, 7, 10, 11, 12, 14, 15, 16],
11: [0, 2, 3, 5, 7, 8, 10, 11, 13, 14, 15, 17],
12: [1, 2, 4, 6, 7, 9, 10, 12, 13, 14, 16, 17],
13: [2, 3, 4, 7, 8, 9, 11, 12, 13, 15, 16, 17],
14: [0, 1, 2, 5, 6, 7, 10, 11, 12, 14, 15, 16],
15: [0, 2, 3, 5, 7, 8, 10, 11, 13, 14, 15, 17],
16: [1, 2, 4, 6, 7, 9, 10, 12, 13, 14, 16, 17],
17: [2, 3, 4, 7, 8, 9, 11, 12, 13, 15, 16, 17],
}
np.testing.assert_array_equal(
adj.toarray().astype(int),
nx.convert_matrix.to_numpy_array(
nx.from_dict_of_lists(desired_adj)).astype(int))
def test_calculate_adjacency_matrix_element_tet2(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/graph_tet2',
read_npy=False)
adjacency_matrix = fem_data.calculate_adjacency_matrix_element()
desired = np.array([[1, 1], [1, 1]], dtype=bool)
np.testing.assert_array_equal(adjacency_matrix.toarray(), desired)
def test_read_data_with_useless_nodes_2(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/useless_nodes_2',
read_npy=False,
save=False)
np.testing.assert_array_equal(fem_data.nodes.ids,
np.unique(fem_data.elements.data))
def test_translation_and_rotation(self):
data_directory = 'tests/data/obj/tri'
fem_data = FEMData.read_directory('obj',
data_directory,
read_npy=False,
save=False)
fem_data.nodal_data.reset()
fem_data.rotation(1, 1, 1, np.pi / 2)
a, b, c = 1 / 3, (1 + 3**.5) / 3, (1 - 3**.5) / 3
desired = np.array([0, 0, 0, a, b, c, c, a, b, b, c, a]).reshape(4, 3)
np.testing.assert_almost_equal(fem_data.nodes.data, desired)
fem_data.translation(1, 2, 3)
desired = np.array([
1, 2, 3, a + 1, b + 2, c + 3, c + 1, a + 2, b + 3, b + 1, c + 2,
a + 3
]).reshape(4, 3)
np.testing.assert_almost_equal(fem_data.nodes.data, desired)
vx, vy, vz = np.random.random(3)
theta = np.random.random() * np.pi * 2
fem_data.rotation(vx, vy, vz, theta)
vx, vy, vz = np.random.random(3)
fem_data.translation(vx, vy, vz)
X, Y, Z = fem_data.nodes.data.T
dist = np.empty((4, 4))
for i in range(4):
for j in range(4):
dist[i, j] = (X[i] - X[j])**2 + (Y[i] - Y[j])**2 + (Z[i] -
Z[j])**2
desired = np.array([0, 1, 1, 1, 1, 0, 2, 2, 1, 2, 0, 2, 1, 2, 2, 0],
np.float64).reshape(4, 4)
np.testing.assert_almost_equal(dist, desired)
def test_obj(self):
data_directory = 'tests/data/obj/mixture_shell'
fem_data = FEMData.read_directory('obj',
data_directory,
read_npy=False,
save=False)
desired_node_ids = np.array([1, 2, 3, 4, 5, 6, 7])
np.testing.assert_array_equal(fem_data.nodes.ids, desired_node_ids)
desired_node_positions = np.array([
[0.0000000e+00, 0.0000000e+00, 0.0000000e+00],
[1.0000000e+00, 0.0000000e+00, 0.0000000e+00],
[1.0000000e+00, 1.0000000e+00, 0.0000000e+00],
[0.0000000e+00, 1.0000000e+00, 0.0000000e+00],
[2.0000000e+00, 0.0000000e+00, 1.0000000e+00],
[1.0000000e+00, 1.0000000e+00, 1.0000000e+00],
[0.0000000e+00, 1.0000000e+00, 1.0000000e+00],
])
np.testing.assert_almost_equal(fem_data.nodes.data,
desired_node_positions)
desired_element_ids = np.array([1, 2, 3])
np.testing.assert_array_equal(fem_data.elements.ids,
desired_element_ids)
np.testing.assert_array_equal(fem_data.elements['tri'].data,
np.array([
[2, 3, 5],
]))
np.testing.assert_array_equal(fem_data.elements['quad'].data,
np.array([
[1, 2, 3, 4],
[3, 6, 7, 4],
]))
def test_read_mixture_solid_elements(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/mixture_solid',
read_npy=False,
save=True)
np.testing.assert_array_equal(
fem_data.elements['hex'].data,
np.array([
[1, 2, 4, 3, 5, 6, 8, 7],
[13, 3, 4, 14, 15, 7, 8, 16],
]))
np.testing.assert_array_equal(fem_data.elements['tet'].data,
np.array([
[12, 2, 6, 9],
]))
np.testing.assert_array_equal(fem_data.elements.ids, [1, 3, 4, 8])
desired_elements = [
np.array([1, 2, 4, 3, 5, 6, 8, 7]),
np.array([12, 2, 6, 9]),
np.array([1, 5, 17, 2, 6, 12]),
np.array([13, 3, 4, 14, 15, 7, 8, 16]),
]
for e, de in zip(fem_data.elements.data, desired_elements):
np.testing.assert_array_equal(e.data, de)
desired_modulus = np.array([[10., 30., 40., 80.]]).T
np.testing.assert_almost_equal(
fem_data.elemental_data.get_attribute_data('Young_modulus'),
desired_modulus)
def test_stl(self):
data_directory = 'tests/data/stl/simple'
fem_data = FEMData.read_directory('stl',
data_directory,
read_npy=False,
save=False)
desired_node_ids = np.array([1, 2, 3, 4])
np.testing.assert_array_equal(fem_data.nodes.ids, desired_node_ids)
desired_node_positions = np.array([
[0., 0., 0.],
[.2, 3., 0.],
[2., .1, 0.],
[4., 5., 0.],
])
np.testing.assert_almost_equal(fem_data.nodes.data,
desired_node_positions)
desired_element_ids = np.array([1, 2])
np.testing.assert_array_equal(fem_data.elements.ids,
desired_element_ids)
np.testing.assert_array_equal(fem_data.elements.data,
np.array([
[1, 3, 2],
[4, 2, 3],
]))
def test_generate_brick_quad(self):
n_x_element = 4
n_y_element = 20
x_length = 1.
y_length = 4.
fem_data = brick_generator.generate_brick('quad',
n_x_element,
n_y_element,
x_length=x_length,
y_length=y_length)
np.testing.assert_almost_equal(np.max(fem_data.nodes.data, axis=0),
[x_length, y_length, 0.])
np.testing.assert_almost_equal(np.min(fem_data.nodes.data, axis=0),
[0., 0., 0.])
self.assertEqual(len(fem_data.elements), n_x_element * n_y_element)
if WRITE_TEST_DATA:
fem_data.write('ucd',
'tests/data/ucd/brick_quad/mesh.inp',
overwrite=True)
areas = fem_data.calculate_element_areas()
np.testing.assert_almost_equal(areas, (x_length / n_x_element) *
(y_length / n_y_element))
ref_fem_data = FEMData.read_directory('ucd',
'tests/data/ucd/brick_quad',
read_npy=False,
save=False)
np.testing.assert_almost_equal(fem_data.nodes.data,
ref_fem_data.nodes.data)
np.testing.assert_array_equal(fem_data.elements.data,
ref_fem_data.elements.data)
def test_cut_with_element_type(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/mixture_solid',
read_npy=False)
cut_fem_data = fem_data.cut_with_element_type('hex')
desired_node_data = np.array([
[0.0, 0.0, 0.0],
[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[1.0, 1.0, 0.0],
[0.0, 0.0, 1.0],
[1.0, 0.0, 1.0],
[0.0, 1.0, 1.0],
[1.0, 1.0, 1.0],
[0.0, 2.0, 0.0],
[1.0, 2.0, 0.0],
[0.0, 2.0, 1.0],
[1.0, 2.0, 1.0],
])
desired_node_ids = np.array([1, 2, 3, 4, 5, 6, 7, 8, 13, 14, 15, 16])
desired_element_ids = np.array([1, 8])
desired_element_data = [
np.array([1, 2, 4, 3, 5, 6, 8, 7]),
np.array([13, 3, 4, 14, 15, 7, 8, 16]),
]
np.testing.assert_array_equal(cut_fem_data.nodes.ids, desired_node_ids)
np.testing.assert_almost_equal(cut_fem_data.nodes.data,
desired_node_data)
np.testing.assert_array_equal(cut_fem_data.elements.ids,
desired_element_ids)
for ae, de in zip(cut_fem_data.elements.data, desired_element_data):
np.testing.assert_array_equal(ae, de)
def test_calculate_adjacency_materix_node_obj(self):
fem_data = FEMData.read_directory('obj',
'tests/data/obj/mixture_graph',
read_npy=False,
save=False)
adjacency_matrix = fem_data.calculate_adjacency_matrix_node()
desired = np.array([
[1, 1, 0, 1, 1, 0, 0, 0, 1],
[1, 1, 1, 1, 1, 1, 0, 0, 0],
[0, 1, 1, 0, 1, 1, 1, 1, 0],
[1, 1, 0, 1, 1, 0, 0, 0, 1],
[1, 1, 1, 1, 1, 1, 0, 0, 0],
[0, 1, 1, 0, 1, 1, 1, 1, 0],
[0, 0, 1, 0, 0, 1, 1, 1, 0],
[0, 0, 1, 0, 0, 1, 1, 1, 0],
[1, 0, 0, 1, 0, 0, 0, 0, 1],
],
dtype=bool)
np.testing.assert_array_equal(adjacency_matrix.toarray(), desired)
elemental_adjacency_matrix = \
fem_data.calculate_adjacency_matrix_element()
elemental_desired = np.array([
[1, 1, 0, 1],
[1, 1, 1, 0],
[0, 1, 1, 0],
[1, 0, 0, 1],
],
dtype=bool)
np.testing.assert_array_equal(elemental_adjacency_matrix.toarray(),
elemental_desired)
def test_to_surface(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/tet_w_node_inside',
read_npy=False,
save=False)
surface_fem_data = fem_data.to_surface()
desired_nodes = np.array([
[0., 0., 0.],
[4., 0., 0.],
[0., 4., 0.],
[0., 0., 4.],
])
desired_elements = np.array([
[1, 3, 2],
[1, 2, 4],
[1, 4, 3],
[2, 3, 4],
])
desired_normals = np.array([
[0., 0., -1.],
[0., -1., 0.],
[-1., 0., 0.],
[1 / 3**.5, 1 / 3**.5, 1 / 3**.5],
])
desired_initial_temperature = np.array([[10., 20., 30., 40.]]).T
np.testing.assert_almost_equal(surface_fem_data.nodes.data,
desired_nodes)
np.testing.assert_array_equal(surface_fem_data.elements.data,
desired_elements)
np.testing.assert_almost_equal(
surface_fem_data.calculate_element_normals(), desired_normals)
np.testing.assert_almost_equal(
surface_fem_data.nodal_data.get_attribute_data(
'INITIAL_TEMPERATURE'), desired_initial_temperature)
def test_separate(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/mixture_separate',
read_npy=False,
save=False)
list_fem_data = fem_data.separate()
for i, fd in enumerate(list_fem_data):
if i == 0:
np.testing.assert_array_equal(
fd.nodes.ids,
[1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 16, 17])
np.testing.assert_almost_equal(
fd.nodal_data.get_attribute_data('t_init')[:, 0], [
1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 2., 2., 2., 2.,
2.
])
np.testing.assert_array_equal(
fd.elements['hex'].data,
[[1, 2, 4, 3, 5, 6, 8, 7], [13, 3, 4, 14, 15, 7, 8, 16]])
np.testing.assert_array_equal(fd.elements['tet'].data,
[[12, 2, 6, 9]])
np.testing.assert_array_equal(fd.elements['prism'].data,
[[1, 5, 17, 2, 6, 12]])
elif i == 1:
np.testing.assert_array_equal(fd.nodes.ids, [
101,
102,
103,
104,
105,
106,
107,
108,
109,
112,
113,
114,
115,
116,
117,
])
np.testing.assert_almost_equal(
fd.nodal_data.get_attribute_data('t_init')[:, 0], [
3., 3., 3., 3., 3., 3., 3., 3., 3., 4., 4., 4., 4., 4.,
4.
])
np.testing.assert_array_equal(
fd.elements['hex'].data,
[[101, 102, 104, 103, 105, 106, 108, 107],
[113, 103, 104, 114, 115, 107, 108, 116]])
np.testing.assert_array_equal(fd.elements['tet'].data,
[[112, 102, 106, 109]])
np.testing.assert_array_equal(fd.elements['prism'].data,
[[101, 105, 117, 102, 106, 112]])
else:
raise ValueError('Separation failed')
def test_calculate_volume_tet(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/tet_volume',
read_npy=False,
save=False)
actual_volumes = fem_data.calculate_element_volumes()
desired_volumes = np.array([[1 / 6], [1 / 2], [1 / 3], [1.]])
np.testing.assert_almost_equal(actual_volumes, desired_volumes)
def test_calculate_volume_hex(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/hex_cross',
read_npy=False,
save=False)
actual_volumes = fem_data.calculate_element_volumes(linear=True)
desired_volumes = np.ones((7, 1)) * 8.
np.testing.assert_almost_equal(actual_volumes, desired_volumes)
def test_calculate_volume_tet_negative_raise_valueerror(self):
fem_data = FEMData.read_directory(
'fistr',
'tests/data/fistr/tet_volume_negative',
read_npy=False,
save=False)
with self.assertRaises(ValueError):
fem_data.calculate_element_volumes(raise_negative_volume=True)
def test_read_data_with_useless_nodes(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/useless_nodes',
read_npy=False,
save=False)
np.testing.assert_array_equal(
fem_data.nodes.ids,
np.array([1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13]))
def test_filter_first_order_nodes_mixture(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/mixture_solid_2',
read_npy=False)
filter_ = fem_data.filter_first_order_nodes()
desired_nodes = [1, 2, 3, 4, 5, 6, 7, 8, 21, 22]
np.testing.assert_array_equal(fem_data.nodes.ids[filter_],
desired_nodes)
def test_fistr_tri(self):
fem_data = FEMData.read_directory('fistr',
'tests/data/fistr/tri',
read_npy=False,
save=False)
self.assertEqual(fem_data.elements.element_type, 'tri')
np.testing.assert_array_equal(fem_data.elements.data,
np.array([[1, 2, 3], [2, 3, 4]]))