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_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_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_write_fistr_overwrite_error(self):
fem_data = FEMData.read_files('fistr', [
'tests/data/fistr/heat/hex.msh', 'tests/data/fistr/heat/hex.cnt',
'tests/data/fistr/heat/hex.res.0.100'
])
with self.assertRaises(ValueError):
fem_data.write('fistr', file_name='tests/data/fistr/heat/hex')
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_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_renew_section(self):
fem_data = FEMData.read_files('fistr',
[FISTR_MSH_FILE, FISTR_RES_FILE])
fem_data.sections.update_data('M1', {'EGRP': 'E2'},
allow_overwrite=True)
self.assertEqual(len(fem_data.sections['EGRP']), 2)
self.assertEqual(fem_data.sections['EGRP']['M1'], ['E2'])
def test_add_section(self):
fem_data = FEMData.read_files('fistr',
[FISTR_MSH_FILE, FISTR_RES_FILE])
fem_data.sections.update_data('M_ADDITIONAL', {'EGRP': 'E_ADDITIONAL'})
self.assertEqual(len(fem_data.sections['EGRP']), 3)
np.testing.assert_array_equal(
fem_data.sections['EGRP']['M_ADDITIONAL'], ['E_ADDITIONAL'])
def test_overwrite_alias_nodal_data(self):
fem_data = FEMData.read_files('fistr',
[FISTR_MSH_FILE, FISTR_RES_FILE])
fem_data.nodal_data.update_data([3], {'t_init': 1000.},
allow_overwrite=True)
np.testing.assert_almost_equal(
fem_data.nodal_data['t_init'].loc[3].values, 1000.)
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_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_extract_surface_fistr(self):
file_name = pathlib.Path('tests/data/fistr/tet/tet.msh')
fem_data = FEMData.read_files('fistr', [file_name])
surfs = fem_data.extract_surface_fistr()
expected = np.array([1, 1, 1, 2, 1, 4, 2, 2, 2, 4, 2, 3]).reshape(6, 2)
np.testing.assert_equal(surfs, expected)
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_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_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_hex(self):
file_name = Path('tests/data/vtk/hex/mesh.vtk')
fem_data = FEMData.read_files('vtk', [file_name])
desired_nodes = np.array([
[0.0, 0, 0],
[0.1, 0, 0],
[0.1, 0.1, 0],
[0.0, 0.1, 0],
[0.0, 0, 0.005],
[0.1, 0, 0.005],
[0.1, 0.1, 0.005],
[0.0, 0.1, 0.005],
[0.0, 0, 0.01],
[0.1, 0, 0.01],
[0.1, 0.1, 0.01],
[0.0, 0.1, 0.01],
])
np.testing.assert_almost_equal(
fem_data.nodes.data, desired_nodes)
desired_elements = np.array([
[1, 2, 3, 4, 5, 6, 7, 8],
[5, 6, 7, 8, 9, 10, 11, 12],
])
np.testing.assert_almost_equal(
fem_data.elements.data, desired_elements)
self.assertEqual(fem_data.elements.element_type, 'hex')
np.testing.assert_almost_equal(
fem_data.calculate_element_volumes(),
np.ones((2, 1)) * .1 * .1 * .005)
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_extract_surface_tet(self):
tet_data = FEMData.read_files('fistr',
['tests/data/fistr/tet/tet.msh'])
ids, _ = tet_data.extract_surface()
desired = [[0, 2, 1], [0, 1, 3], [0, 3, 2], [1, 2, 4], [1, 4, 3],
[2, 3, 4]]
np.testing.assert_array_equal(ids, desired)
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_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_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_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_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]]))
def test_fistr_elemental_mises_ids(self):
"""Elemental MISES IDs should be correctly stored."""
desired_nodal_mises_ids = np.array([1, 2])
fem_data = FEMData.read_files(
'fistr', [FISTR_MSH_FILE, FISTR_CNT_FILE, FISTR_RES_FILE])
np.testing.assert_almost_equal(
fem_data.elemental_data['ElementalMISES'].ids,
desired_nodal_mises_ids)
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_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_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_fistr_element_components(self):
"""Element compoments should be correctly stored."""
desired_element_components = np.array([[1, 2, 3, 4, 5, 6, 7, 8],
[5, 6, 7, 8, 9, 10, 11, 12]])
fem_data = FEMData.read_files(
'fistr', [FISTR_MSH_FILE, FISTR_CNT_FILE, FISTR_RES_FILE])
np.testing.assert_equal(fem_data.elements.data,
desired_element_components)
def test_fistr_displacement_ids(self):
"""Displacement IDs should be correctly stored."""
desired_displacement_ids = np.array(
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
fem_data = FEMData.read_files(
'fistr', [FISTR_MSH_FILE, FISTR_CNT_FILE, FISTR_RES_FILE])
np.testing.assert_equal(fem_data.nodal_data['DISPLACEMENT'].ids,
desired_displacement_ids)
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)
