def setUp(self):
self.input_file_1 = amfe_dir(
'tests/meshes/2_partitions_2quad_mesh.msh')
self.input_file_2 = amfe_dir('tests/meshes/gid_json_4_tets.json')
class DummyMaterial:
def __init__(self, name):
self.name = name
self.testmaterial = DummyMaterial('steel')
def clean_test_outputs():
directory = amfe_dir('results/.tests/')
check_dir(directory + 'test.txt')
directory = amfe_dir('results/.tests/')
for f in os.listdir(directory):
if f == 'hdf5_dummy.hdf5' or f == 'hdf5postprocessing.hdf5':
return
filename = directory + f
if os.path.isfile(filename):
os.remove(filename)
return
def test_hdf5_postprocessor_writer_and_reader(self):
self.timesteps, self.meshreader, self.fields_desired, \
self.fields_no_of_nodes, self.fields_no_of_timesteps = create_fields()
filename = amfe_dir('results/.tests/hdf5postprocessing.hdf5')
if os.path.isfile(filename):
os.remove(filename)
writer = Hdf5PostProcessorWriter(self.meshreader, filename,
'/myresults')
fields_desired = {
'Nodefield1': self.fields_desired['Nodefield1'],
'Nodefield2': self.fields_desired['Nodefield2'],
'Elementfield1': self.fields_desired['Elementfield1']
}
fields = copy(fields_desired)
for fieldname in fields:
field = fields[fieldname]
if field['data_type'] == PostProcessDataType.VECTOR:
data = field['data'].reshape(self.fields_no_of_nodes, 3,
self.fields_no_of_timesteps)
else:
data = field['data']
writer.write_field(fieldname, field['data_type'],
field['timesteps'], data, field['index'],
field['mesh_entity_type'])
self.timesteps, self.meshreader, self.fields_desired, \
self.fields_no_of_nodes, self.fields_no_of_timesteps = create_fields()
h5filename = amfe_dir('results/.tests/hdf5postprocessing.hdf5')
postprocessorreader = AmfeHdf5PostProcessorReader(
h5filename, meshrootpath='/mesh', resultsrootpath='/myresults')
meshreader = Hdf5MeshReader(h5filename, '/mesh')
postprocessorwriter = DummyPostProcessorWriter(meshreader)
postprocessorreader.parse(postprocessorwriter)
fields = postprocessorwriter.return_result()
# Check no of fields:
self.assertEqual(len(fields.keys()), len(fields_desired.keys()))
# Check each field:
for fieldname in fields_desired:
field_actual = fields[fieldname]
field_desired = fields_desired[fieldname]
assert_array_equal(field_actual['timesteps'],
field_desired['timesteps'])
assert_array_equal(field_actual['data_type'],
field_desired['data_type'])
assert_array_equal(field_actual['data'], field_desired['data'])
assert_array_equal(field_actual['index'], field_desired['index'])
assert_array_equal(field_actual['mesh_entity_type'],
field_desired['mesh_entity_type'])
def test_write_xdmf_from_hdf5(self):
self._create_fields()
filename = amfe_dir('results/.tests/hdf5postprocessing.hdf5')
with h5py.File(filename, mode='r') as hdf5_fp:
filename = amfe_dir('results/.tests/hdf5postprocessing.xdmf')
with open(filename, 'wb') as xdmf_fp:
fielddict = self.fields_desired
for key in fielddict:
fielddict[key].update(
{'hdf5path': '/myresults/{}'.format(key)})
timesteps = fielddict[key]['timesteps']
# timesteps = np.arange(0, 0.8, 0.2) # 4 timesteps
write_xdmf_from_hdf5(xdmf_fp, hdf5_fp, '/mesh/nodes',
'/mesh/topology', timesteps, fielddict)
def test_hdf5_to_dummy(self):
self.set_dummy_input()
h5filename = amfe_dir('results/.tests/hdf5_dummy.hdf5')
meshreader = Hdf5MeshReader(h5filename, '/mesh')
builder = DummyMeshConverter()
meshreader.parse(builder)
amfemesh = builder.return_mesh()
# compare nodes
for actual, desired in zip(amfemesh._nodes, self.nodes_input):
self.assertEqual(actual, desired)
# compare elements
for actual, desired in zip(amfemesh._elements, self.elements_input):
self.assertEqual(actual, desired)
# compare tags
self.assertEqual(amfemesh._tags.keys(), self.tags_input.keys())
for key in self.tags_input:
actual = amfemesh._tags[key]
desired = self.tags_input[key]
self.assertEqual(actual.keys(), desired.keys())
for desired_key_value in desired.keys():
self.assertEqual(len(actual[desired_key_value]),
len(desired[desired_key_value]))
actual_set = set(actual[desired_key_value])
desired_set = set(desired[desired_key_value])
self.assertEqual(actual_set, desired_set)
def test_dummy_to_hdf5_and_xdmf(self):
self.set_dummy_input()
filename = amfe_dir('results/.tests/hdf5_dummy')
if not os.path.exists(amfe_dir('results/.tests')):
os.makedirs(amfe_dir('results/.tests'))
hdf5filename = filename + '.hdf5'
if os.path.isfile(hdf5filename):
os.remove(hdf5filename)
converter = Hdf5MeshConverter(hdf5filename)
self.run_build_commands(converter)
converter.return_mesh()
write_xdmf_mesh_from_hdf5(filename + '.xdmf', filename + '.hdf5',
'/mesh')
def test_gmshascii_to_dummy_hexa20(self):
# Desired nodes
# old ordering: [5, 42, 60, 30, 21, 45, 75, 65, 44, 32, 22,
# 63, 47, 64, 76, 67, 49, 66, 77, 78]
element_57_desired = (57, 'Hexa20', [
5, 42, 60, 30, 21, 45, 75, 65, 44, 63, 64, 32, 49, 77, 78, 66, 22,
47, 76, 67
])
dimension_desired = 3
# Define input file path
file = amfe_dir('tests/meshes/gmsh_ascii_v2_hexa20.msh')
# Define Reader Object, initialized with AmfeMeshConverter
reader = GmshAsciiMeshReader(file)
# Parse dummy mesh
dummy = DummyMeshConverter()
reader.parse(dummy)
mesh = dummy.return_mesh()
# Check elements
self.assertEqual(
mesh._elements[mesh._elements.index(element_57_desired)],
element_57_desired)
# Check mesh dimension
self.assertEqual(mesh._no_of_nodes, 81)
self.assertEqual(mesh._no_of_elements, 64)
self.assertEqual(mesh._dimension, dimension_desired)
def test_dummy_to_vtk_wrong_fileextension(self):
self.set_dummy_input()
filename = amfe_dir('results/.tests/vtk_dummy.abc')
check_dir(filename)
converter = VtkMeshConverter(filename=filename)
# Build nodes
self.run_build_commands(converter)
converter.return_mesh()
def test_dummy_to_vtk(self):
self.set_dummy_input()
filename = amfe_dir('results/.tests/vtk_dummy.vtk')
check_dir(filename)
converter = VtkMeshConverter(filename=filename)
# Run build commands
self.run_build_commands(converter)
converter.return_mesh()
def test_gidjson_to_dummy(self):
# Desired nodes
nodes_desired = [
(1, 1.345600000e-02, 3.561675700e-02, 0.000000000e+00),
(2, 5.206839561e-01, 3.740820950e-02, 6.193195000e-04),
(3, 3.851982918e-02, 5.460016703e-01, 4.489461500e-03),
(4, 5.457667372e-01, 5.477935420e-01, 6.984401105e-04),
(5, 1.027911912e+00, 3.919966200e-02, 1.238639000e-03),
(6, 6.358365836e-02, 1.056386584e+00, 8.978923000e-03),
(7, 1.040469476e+00, 5.445628213e-01, 1.301993398e-03),
(8, 5.582746582e-01, 1.053154002e+00, 7.377279750e-03),
(9, 1.052965658e+00, 1.049921420e+00, 5.775636500e-03),
(10, 1.535139868e+00, 4.099111450e-02, 1.857958500e-03),
(11, 1.547697432e+00, 5.463542738e-01, 1.921312898e-03),
(12, 1.547656658e+00, 1.046688838e+00, 4.173993250e-03),
(13, 2.042367825e+00, 4.278256700e-02, 2.477278000e-03),
(14, 2.042357741e+00, 5.431194119e-01, 2.524814000e-03),
(15, 2.042347658e+00, 1.043456257e+00, 2.572350000e-03)
]
elements_desired = [(1, 'Tri6', [13, 15, 9, 14, 12, 11]),
(2, 'Tri6', [9, 6, 5, 8, 4, 7]),
(3, 'Tri6', [9, 5, 13, 7, 10, 11]),
(4, 'Tri6', [1, 5, 6, 2, 4, 3]),
(5, 'quadratic_line', [5, 13, 10]),
(6, 'quadratic_line', [1, 5, 2]),
(7, 'quadratic_line', [6, 1, 3]),
(8, 'quadratic_line', [9, 6, 8]),
(9, 'quadratic_line', [13, 15, 14]),
(10, 'quadratic_line', [15, 9, 12])]
dimension_desired = 2
groups_desired = [('left', [], [2, 4]), ('right', [], [1, 3]),
('left_boundary', [], [7]),
('right_boundary', [], [9]),
('top_boundary', [], [8, 10]),
('left_dirichlet', [1, 3, 6], [])]
# Define input file path
file = amfe_dir('tests/meshes/gid_json_4_tets.json')
# Define Reader Object, initialized with AmfeMeshConverter
reader = GidJsonMeshReader(file)
# Parse mesh
dummy = DummyMeshConverter()
reader.parse(dummy)
mesh = dummy.return_mesh()
# Check nodes
for i, node in enumerate(nodes_desired):
self.assertAlmostEqual(mesh._nodes[i], node)
# Check elements
for i, element in enumerate(elements_desired):
self.assertEqual(mesh._elements[mesh._elements.index(element)],
element)
# Check mesh dimension
self.assertEqual(mesh._dimension, dimension_desired)
self.assertEqual(mesh._groups, groups_desired)
self.assertEqual(mesh._no_of_nodes, 15)
self.assertEqual(mesh._no_of_elements, 10)
def test_import_mesh_from_file(self):
input_file_3 = amfe_dir('tests/meshes/not_a_mesh_for_testing.txt')
testmesh_1 = import_mesh_from_file(self.input_file_1)
testmesh_2 = import_mesh_from_file(self.input_file_2)
# check if raises error for no valid mesh file
self.assertRaises(ValueError, import_mesh_from_file, input_file_3)
# check for correct import
self.assertIsInstance(testmesh_1, Mesh)
self.assertIsInstance(testmesh_2, Mesh)
self.assertEqual(testmesh_1.no_of_elements, 2)
self.assertEqual(testmesh_2.no_of_elements, 4)
def test_dummy_to_vtk_with_preallocation_too_late(self):
self.set_dummy_input()
filename = amfe_dir('results/.tests/vtk_dummy.vtk')
check_dir(filename)
converter = VtkMeshConverter(filename=filename)
# Build nodes
self.run_build_commands(converter)
converter.build_no_of_nodes(len(self.nodes_input))
converter.build_no_of_elements(len(self.elements_input))
converter.return_mesh()
def setUp(self):
mesh_input = amfe_dir('tests/meshes/gid_json_4_tets.json')
mesh_reader = GidJsonMeshReader(mesh_input)
converter = AmfeMeshConverter()
mesh_reader.parse(converter)
self.mesh = converter.return_mesh()
self.amp = 1.0
my_comp = StructuralComponent(self.mesh)
my_material = KirchhoffMaterial()
my_comp.assign_material(my_material, ['left', 'right'], 'S')
neumann_bc = my_comp._neumann.create_fixed_direction_neumann((1, 0), lambda t: self.amp*t)
my_comp.assign_neumann('Right force', neumann_bc, ['right_boundary'])
self.my_comp = my_comp
def test_gmsh_parser_with_8_partitions(self):
msh_filename = amfe_dir(
'tests/meshes/retangule_5_by_2_quad_par_8_irreg.msh')
reader_obj = GmshAsciiMeshReader(msh_filename)
converter = AmfeMeshConverter()
reader_obj.parse(converter)
mesh_obj = converter.return_mesh()
self.assertTrue('no_of_mesh_partitions' in mesh_obj.el_df)
self.assertTrue('partition_id' in mesh_obj.el_df)
self.assertTrue('partitions_neighbors' in mesh_obj.el_df)
actual_list_1 = mesh_obj.el_df['no_of_mesh_partitions'].tolist()
actual_list_2 = mesh_obj.el_df['partition_id'].tolist()
actual_list_3 = mesh_obj.el_df['partitions_neighbors'].tolist()
desired_list_1 = load_object(amfe_dir('tests/pickle_obj/l1.pkl'))
desired_list_2 = load_object(amfe_dir('tests/pickle_obj/l2.pkl'))
desired_list_3 = load_object(amfe_dir('tests/pickle_obj/l3.pkl'))
self.assertListEqual(actual_list_1, desired_list_1)
self.assertListEqual(actual_list_2, desired_list_2)
self.assertListEqual(actual_list_3, desired_list_3)
def test_async_solve(self):
# Test Asnychronous solution
filename = amfe_dir('results/tests/amfe_solution_async_hdf5.h5')
check_dir(filename)
mysolver = DummySolver()
t0 = 0.0
tend = 1.0
dt = 0.1
# define task for asyncio
async def task(tfilename, tsolver, tt0, ttend, tdt):
no_of_buffer_slots = 3
print("Run Asynchronous HDF5 Version")
h5amfe = AmfeSolutionHdf5(tfilename, 'Sim1', 'asyncsolution')
with h5amfe as writer:
solverkwargs = {'t0': tt0, 'tend': ttend, 'dt': tdt}
await solve_async(no_of_buffer_slots, writer, tsolver, **solverkwargs)
return h5amfe
# Run asynchronous
_ = asyncio.run(task(filename, mysolver, t0, tend, dt))
# Test if results have been written into hdf5 correctly
with h5py.File(filename, mode='r') as fp:
# Get the desired results from solver
t, q, dq, ddq, strains, stresses = mysolver._initialize(t0, tend, dt, mysolver.ndof)
# Get dataset
dataset = fp['Sim1/asyncsolution']
# Test if the first two entries are correct
assert_array_equal(dataset[0]['q'], q[0, :])
assert_array_equal(dataset[1]['q'], q[1, :])
assert_array_equal(dataset[0]['dq'], dq[0, :])
assert_array_equal(dataset[1]['dq'], dq[1, :])
assert_array_equal(dataset[0]['ddq'], ddq[0, :])
assert_array_equal(dataset[1]['ddq'], ddq[1, :])
assert_array_equal(dataset[0]['strain'], strains[0, :, :])
assert_array_equal(dataset[1]['strain'], strains[1, :, :])
assert_array_equal(dataset[0]['stress'], stresses[0, :, :])
assert_array_equal(dataset[1]['stress'], stresses[1, :, :])
self.assertEqual(dataset[0]['t'], t[0])
self.assertEqual(dataset[1]['t'], t[1])
# test if all entries have been written
self.assertEqual(len(dataset), len(t))
def test_gmshascii_to_dummy(self):
# Desired nodes
nodes_desired = [(1, 0.0, 0.0, 0.0), (2, 2.0, 0.0, 0.0),
(3, 2.0, 1.0, 0.0), (4, 0.0, 1.0, 0.0),
(5, 0.999999999997388, 0.0, 0.0),
(6, 1.000000000004118, 1.0, 0.0),
(7, 0.5000000000003766, 0.5, 0.0),
(8, 1.500000000000857, 0.5, 0.0)]
# Desired elements
# (internal name of Triangle Nnode 3 is 'Tri3')
elements_desired = [(1, 'straight_line', [2, 3]),
(2, 'straight_line', [4, 1]),
(3, 'Tri3', [8, 6, 5]), (4, 'Tri3', [5, 6, 7]),
(5, 'Tri3', [4, 7, 6]), (6, 'Tri3', [2, 8, 5]),
(7, 'Tri3', [2, 3, 8]), (8, 'Tri3', [1, 7, 4]),
(9, 'Tri3', [1, 5, 7]), (10, 'Tri3', [3, 6, 8])]
dimension_desired = 2
groups_desired = [('right_boundary', [], [1]),
('left_boundary', [], [2]),
('volume', [], [3, 4, 5, 6, 7, 8, 9, 10])]
# Define input file path
file = amfe_dir('tests/meshes/gmsh_ascii_8_tets.msh')
# Define Reader Object, initialized with AmfeMeshConverter
reader = GmshAsciiMeshReader(file)
# Parse dummy mesh
dummy = DummyMeshConverter()
reader.parse(dummy)
mesh = dummy.return_mesh()
# Check nodes
for i, node in enumerate(nodes_desired):
self.assertAlmostEqual(mesh._nodes[i], node)
# Check elements
for i, element in enumerate(elements_desired):
self.assertEqual(mesh._elements[mesh._elements.index(element)],
element)
# Check mesh dimension
self.assertEqual(mesh._dimension, dimension_desired)
self.assertEqual(mesh._groups, groups_desired)
self.assertEqual(mesh._no_of_nodes, 8)
self.assertEqual(mesh._no_of_elements, 10)
def setUp(self):
# Define input file path
file = amfe_dir('tests/meshes/gid_json_4_tets.json')
# Define Reader Object, initialized with AmfeMeshConverter
reader = GidJsonMeshReader(file)
# Initialize component
converter = AmfeMeshConverter()
reader.parse(converter)
self.my_mesh = converter.return_mesh()
self.my_component = StructuralComponent(self.my_mesh)
my_material = KirchhoffMaterial()
self.my_component.assign_material(my_material, ['left', 'right'], 'S')
# Get number of dofs for snapshot generation
self.no_of_dofs = self.my_component.mapping.no_of_dofs
# create 2 random snapshots
self.no_of_snapshots = 2
self.S = np.random.rand(self.no_of_dofs, self.no_of_snapshots) * 0.05
self.W = np.eye(self.no_of_dofs)
self.timesteps = np.zeros(self.no_of_snapshots)
def test_gmsh_parser_with_2_partitions(self):
msh_filename = amfe_dir('tests/meshes/2_partitions_2quad_mesh.msh')
reader_obj = GmshAsciiMeshReader(msh_filename)
converter = AmfeMeshConverter()
reader_obj.parse(converter)
mesh_obj = converter.return_mesh()
self.assertTrue('no_of_mesh_partitions' in mesh_obj.el_df)
self.assertTrue('partition_id' in mesh_obj.el_df)
self.assertTrue('partitions_neighbors' in mesh_obj.el_df)
desired_list_1 = [1, 1, 2, 2]
desired_list_2 = [1, 1, 1, 2]
desired_list_3 = [None, None, 2, 1]
actual_list_1 = mesh_obj.el_df['no_of_mesh_partitions'].tolist()
actual_list_2 = mesh_obj.el_df['partition_id'].tolist()
actual_list_3 = mesh_obj.el_df['partitions_neighbors'].tolist()
self.assertListEqual(actual_list_1, desired_list_1)
self.assertListEqual(actual_list_2, desired_list_2)
self.assertListEqual(actual_list_3, desired_list_3)
def test_gmshascii_to_dummy_tet10(self):
element_65_desired = (65, 'Tet10',
[61, 9, 45, 72, 84, 85, 86, 87, 79, 88])
dimension_desired = 3
# Define input file path
file = amfe_dir('tests/meshes/gmsh_ascii_v2_tet10.msh')
# Define Reader Object, initialized with AmfeMeshConverter
reader = GmshAsciiMeshReader(file)
# Parse dummy mesh
dummy = DummyMeshConverter()
reader.parse(dummy)
mesh = dummy.return_mesh()
# Check elements
self.assertEqual(
mesh._elements[mesh._elements.index(element_65_desired)],
element_65_desired)
# Check mesh dimension
self.assertEqual(mesh._no_of_nodes, 113)
self.assertEqual(mesh._no_of_elements, 112)
self.assertEqual(mesh._dimension, dimension_desired)
def test_gidascii_to_dummy(self):
# Desired nodes
nodes_desired = [(1, 1.34560000e-02, 3.56167570e-02, 0.00000000e+00),
(2, 1.02791191e+00, 3.91996620e-02, 1.23863900e-03),
(3, 6.35836584e-02, 1.05638658e+00, 8.97892300e-03),
(4, 1.05296566e+00, 1.04992142e+00, 5.77563650e-03),
(5, 2.04236782e+00, 4.27825670e-02, 2.47727800e-03),
(6, 2.04234766e+00, 1.04345626e+00, 2.57235000e-03)]
# Desired elements
# (internal name of Triangle Nnode 3 is 'Tri3')
elements_desired = [(1, 'Tri3', [5, 6, 4]), (2, 'Tri3', [4, 3, 2]),
(3, 'Tri3', [4, 2, 5]), (4, 'Tri3', [1, 2, 3])]
dimension_desired = 3
# -------------------------------------------------------
# OTHER INFORMATION NOT AVAILABLE FROM ASCII MESH
# THEREFORE ONLY nodes, elements and dimension is tested
# -------------------------------------------------------
# Define input file path
file = amfe_dir('tests/meshes/gid_ascii_4_tets.msh')
# Define Reader Object, initialized with AmfeMeshConverter
reader = GidAsciiMeshReader(file)
# Parse mesh
dummy = DummyMeshConverter()
reader.parse(dummy)
mesh = dummy.return_mesh()
# Check nodes
for i, node in enumerate(nodes_desired):
self.assertAlmostEqual(mesh._nodes[i], node)
# Check elements
for i, element in enumerate(elements_desired):
self.assertEqual(mesh._elements[i], element)
# Check mesh dimension
self.assertEqual(mesh._dimension, dimension_desired)
import numpy as np
import amfe.ui as ui
from amfe.io.tools import amfe_dir
from amfe.forces import constant_force, triangular_force
###################################################
### Simple linear-elastic cantilever beam ###
###################################################
mesh_file = amfe_dir('meshes/gmsh/simple_beam_gmsh/simple_beam_gmsh.msh')
mesh = ui.import_mesh_from_file(mesh_file)
model = ui.create_structural_component(mesh)
material = ui.create_material('Kirchhoff',
E=210E9,
nu=0.3,
rho=1E4,
plane_stress=True)
ui.assign_material_by_group(model, material, 'material')
ui.set_dirichlet_by_group(model, 'dirichlet', ('ux'), 'Dirichlet_x')
ui.set_dirichlet_by_nodeids(model, [1], ('uy'), 'Dirichlet_y')
F = constant_force(5E7)
ui.set_neumann_by_group(model, 'neumann', np.array([0.0, -1.0]), 'Load', F)
solution_writer = ui.solve_linear_static(model)
ui.write_results_to_paraview(solution_writer, model,
def test_strains_and_stresses(self):
# Rigid body-movement not causing strains and stresses
q = np.array([
0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,
0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,
0.1, 0.1, 0.1, 0.1
])
dq = np.zeros(self.my_comp.constraints.no_of_dofs_unconstrained)
strains_actual, stresses_actual = self.my_comp.strains_and_stresses(
q, dq, 0.0)
strains_desired = np.zeros((15, 6))
stresses_desired = np.zeros((15, 6))
assert_array_almost_equal(strains_actual, strains_desired, 8)
assert_array_almost_equal(stresses_actual, stresses_desired, 4)
# 1D-deformation resulting in 1D-strains and -stresses
# 2 Quad4-Elements
mesh_input = amfe_dir('tests/meshes/gmsh_2_quads.msh')
mesh_reader = GmshAsciiMeshReader(mesh_input)
converter = AmfeMeshConverter()
mesh_reader.parse(converter)
mesh = converter.return_mesh()
amp = 1.0
my_comp = StructuralComponent(mesh)
my_material = KirchhoffMaterial(E=30e6, nu=0.0)
my_comp.assign_material(my_material, ['volume'], 'S')
q = np.array(
[0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1, 0.0, 0.2, 0.0, 0.2, 0.0])
dq = np.zeros(my_comp.constraints.no_of_dofs_unconstrained)
strains_actual, stresses_actual = my_comp.strains_and_stresses(
q, dq, 0.0)
strains_desired = np.array([[1.05e-1, 0, 0, 0, 0, 0],
[1.05e-1, 0, 0, 0, 0, 0],
[1.05e-1, 0, 0, 0, 0, 0],
[1.05e-1, 0, 0, 0, 0, 0],
[1.05e-1, 0, 0, 0, 0, 0],
[1.05e-1, 0, 0, 0, 0, 0]])
stresses_desired = np.array([[3.15e6, 0, 0, 0, 0, 0],
[3.15e6, 0, 0, 0, 0, 0],
[3.15e6, 0, 0, 0, 0, 0],
[3.15e6, 0, 0, 0, 0, 0],
[3.15e6, 0, 0, 0, 0, 0],
[3.15e6, 0, 0, 0, 0, 0]])
assert_array_almost_equal(strains_actual, strains_desired)
assert_array_almost_equal(stresses_actual, stresses_desired)
# 8 Tri3-Elements
mesh_input = amfe_dir('tests/meshes/gmsh_8_tris.msh')
mesh_reader = GmshAsciiMeshReader(mesh_input)
converter = AmfeMeshConverter()
mesh_reader.parse(converter)
mesh = converter.return_mesh()
amp = 1.0
my_comp = StructuralComponent(mesh)
my_material = KirchhoffMaterial(E=30e6, nu=0.0, plane_stress=True)
my_comp.assign_material(my_material, ['volume'], 'S')
q = np.array([
0.15, 0, 0.1, 0, 0.1, 0, 0.05, 0, 0, 0, 0.2, 0, 0.2, 0, 0, 0, 0, 0
])
dq = np.zeros(my_comp.constraints.no_of_dofs_unconstrained)
strains_actual, stresses_actual = my_comp.strains_and_stresses(
q, dq, 0.0)
strains_desired = np.array([[1.05e-1, 0, 0, 0, 0, 0],
[1.05e-1, 0, 0, 0, 0, 0],
[1.05e-1, 0, 0, 0, 0, 0],
[1.05e-1, 0, 0, 0, 0, 0],
[1.05e-1, 0, 0, 0, 0, 0],
[1.05e-1, 0, 0, 0, 0, 0],
[1.05e-1, 0, 0, 0, 0, 0],
[1.05e-1, 0, 0, 0, 0, 0]])
stresses_desired = np.array([[3.15e6, 0, 0, 0, 0, 0],
[3.15e6, 0, 0, 0, 0, 0],
[3.15e6, 0, 0, 0, 0, 0],
[3.15e6, 0, 0, 0, 0, 0],
[3.15e6, 0, 0, 0, 0, 0],
[3.15e6, 0, 0, 0, 0, 0],
[3.15e6, 0, 0, 0, 0, 0],
[3.15e6, 0, 0, 0, 0, 0]])
assert_array_almost_equal(strains_actual, strains_desired)
assert_array_almost_equal(stresses_actual, stresses_desired, 5)
def test_write_hdf5_timesteps(self):
filename = amfe_dir('results/tests/amfe_solution_hdf5.h5')
check_dir(filename)
q1 = np.arange(0, 60, dtype=float)
q2 = np.arange(10, 70, dtype=float)
dq1 = np.arange(20, 80, dtype=float)
dq2 = np.arange(30, 90, dtype=float)
ddq1 = np.arange(40, 100, dtype=float)
ddq2 = np.arange(50, 110, dtype=float)
strains1 = np.random.rand(60, 6)
strains2 = np.random.rand(60, 6)
stresses1 = np.random.rand(60, 6)
stresses2 = np.random.rand(60, 6)
t1 = 0.1
t2 = 0.5
# Only q
h5amfe = AmfeSolutionHdf5(filename, 'Sim1', tablename='testcase')
with h5amfe as writer:
# Only q
writer.write_timestep(t1, q1)
writer.write_timestep(t2, q2)
with h5py.File(filename, mode='r') as fp:
dataset = fp['Sim1/testcase']
assert_array_equal(dataset[0]['q'], q1)
assert_array_equal(dataset[1]['q'], q2)
self.assertEqual(dataset[0]['t'], t1)
self.assertEqual(dataset[1]['t'], t2)
self.assertEqual(len(dataset), 2)
# Only q and dq
h5amfe = AmfeSolutionHdf5(filename, 'Sim1', tablename='testcase')
with h5amfe as writer:
# Only q and dq
writer.write_timestep(t1, q1, dq1)
writer.write_timestep(t2, q2, dq2)
with h5py.File(filename, mode='r') as fp:
dataset = fp['Sim1/testcase']
assert_array_equal(dataset[0]['q'], q1)
assert_array_equal(dataset[1]['q'], q2)
assert_array_equal(dataset[0]['dq'], dq1)
assert_array_equal(dataset[1]['dq'], dq2)
self.assertEqual(dataset[0]['t'], t1)
self.assertEqual(dataset[1]['t'], t2)
self.assertEqual(len(dataset), 2)
# q, dq and ddq
h5amfe = AmfeSolutionHdf5(filename, 'Sim1', tablename='testcase')
with h5amfe as writer:
# q, dq and ddq
writer.write_timestep(t1, q1, dq1, ddq1)
writer.write_timestep(t2, q2, dq2, ddq2)
with h5py.File(filename, mode='r') as fp:
dataset = fp['Sim1/testcase']
assert_array_equal(dataset[0]['q'], q1)
assert_array_equal(dataset[1]['q'], q2)
assert_array_equal(dataset[0]['dq'], dq1)
assert_array_equal(dataset[1]['dq'], dq2)
assert_array_equal(dataset[0]['ddq'], ddq1)
assert_array_equal(dataset[1]['ddq'], ddq2)
self.assertEqual(dataset[0]['t'], t1)
self.assertEqual(dataset[1]['t'], t2)
self.assertEqual(len(dataset), 2)
# only q and ddq
h5amfe = AmfeSolutionHdf5(filename, 'Sim1', tablename='testcase')
with h5amfe as writer:
# only q and ddq
writer.write_timestep(t1, q1, ddq=ddq1)
writer.write_timestep(t2, q2, ddq=ddq2)
with h5py.File(filename, mode='r') as fp:
dataset = fp['Sim1/testcase']
assert_array_equal(dataset[0]['q'], q1)
assert_array_equal(dataset[1]['q'], q2)
assert_array_equal(dataset[0]['ddq'], ddq1)
assert_array_equal(dataset[1]['ddq'], ddq2)
self.assertEqual(dataset[0]['t'], t1)
self.assertEqual(dataset[1]['t'], t2)
self.assertEqual(len(dataset), 2)
# only q and strain
h5amfe = AmfeSolutionHdf5(filename, 'Sim1', tablename='testcase')
with h5amfe as writer:
# Only q and strain
writer.write_timestep(t1, q1, strain=strains1)
writer.write_timestep(t2, q2, strain=strains2)
with h5py.File(filename, mode='r') as fp:
dataset = fp['Sim1/testcase']
assert_array_equal(dataset[0]['q'], q1)
assert_array_equal(dataset[1]['q'], q2)
assert_array_equal(dataset[0]['strain'], strains1)
assert_array_equal(dataset[1]['strain'], strains2)
self.assertEqual(dataset[0]['t'], t1)
self.assertEqual(dataset[1]['t'], t2)
self.assertEqual(len(dataset), 2)
# only q and stress
h5amfe = AmfeSolutionHdf5(filename, 'Sim1', tablename='testcase')
with h5amfe as writer:
# Only q and stress
writer.write_timestep(t1, q1, stress=stresses1)
writer.write_timestep(t2, q2, stress=stresses2)
with h5py.File(filename, mode='r') as fp:
dataset = fp['Sim1/testcase']
assert_array_equal(dataset[0]['q'], q1)
assert_array_equal(dataset[1]['q'], q2)
assert_array_equal(dataset[0]['stress'], stresses1)
assert_array_equal(dataset[1]['stress'], stresses2)
self.assertEqual(dataset[0]['t'], t1)
self.assertEqual(dataset[1]['t'], t2)
self.assertEqual(len(dataset), 2)
# only q, dq, strain and stress
h5amfe = AmfeSolutionHdf5(filename, 'Sim1', tablename='testcase')
with h5amfe as writer:
# Only q, dq, strain and stress
writer.write_timestep(t1, q1, dq1, strain=strains1, stress=stresses1)
writer.write_timestep(t2, q2, dq2, strain=strains2, stress=stresses2)
with h5py.File(filename, mode='r') as fp:
dataset = fp['Sim1/testcase']
assert_array_equal(dataset[0]['q'], q1)
assert_array_equal(dataset[1]['q'], q2)
assert_array_equal(dataset[0]['dq'], dq1)
assert_array_equal(dataset[1]['dq'], dq2)
assert_array_equal(dataset[0]['strain'], strains1)
assert_array_equal(dataset[1]['strain'], strains2)
assert_array_equal(dataset[0]['stress'], stresses1)
assert_array_equal(dataset[1]['stress'], stresses2)
self.assertEqual(dataset[0]['t'], t1)
self.assertEqual(dataset[1]['t'], t2)
self.assertEqual(len(dataset), 2)
# q, dq, ddq, strain and stress
h5amfe = AmfeSolutionHdf5(filename, 'Sim1', tablename='testcase')
with h5amfe as writer:
# q, dq, ddq, strain and stress
writer.write_timestep(t1, q1, dq1, ddq1, strains1, stresses1)
writer.write_timestep(t2, q2, dq2, ddq2, strains2, stresses2)
with h5py.File(filename, mode='r') as fp:
dataset = fp['Sim1/testcase']
assert_array_equal(dataset[0]['q'], q1)
assert_array_equal(dataset[1]['q'], q2)
assert_array_equal(dataset[0]['dq'], dq1)
assert_array_equal(dataset[1]['dq'], dq2)
assert_array_equal(dataset[0]['ddq'], ddq1)
assert_array_equal(dataset[1]['ddq'], ddq2)
assert_array_equal(dataset[0]['strain'], strains1)
assert_array_equal(dataset[1]['strain'], strains2)
assert_array_equal(dataset[0]['stress'], stresses1)
assert_array_equal(dataset[1]['stress'], stresses2)
self.assertEqual(dataset[0]['t'], t1)
self.assertEqual(dataset[1]['t'], t2)
self.assertEqual(len(dataset), 2)
import numpy as np
import amfe.ui as ui
from amfe.io.tools import amfe_dir
from amfe.forces import constant_force, triangular_force, linearly_increasing_force
###################################################
# Simple linear-elastic cantilever beam #
###################################################
# Cantilever beam with dimensions 10m x 1m (L x H)
mesh_file = amfe_dir('meshes/gmsh/simple_beam_gmsh/simple_beam_gmsh.msh')
mesh = ui.import_mesh_from_file(mesh_file)
model = ui.create_structural_component(mesh)
material = ui.create_material('Kirchhoff',
E=210E9,
nu=0.3,
rho=7.85E3,
plane_stress=True,
thickness=0.1)
ui.assign_material_by_group(model, material, 'material')
ui.set_dirichlet_by_group(model, 'dirichlet', ('ux'), 'Dirichlet_x')
ui.set_dirichlet_by_nodeids(model, [1], ('uy'), 'Dirichlet_y')
F = constant_force(5E7)
ui.set_neumann_by_group(model,
'neumann',
def test_gmshascii_to_dummy_physical_surfaces_and_partitions(self):
# Desired nodes
nodes_desired = [(1, 0.0, 0.0, 0.0), (2, 0.0, 5.0, 0.0),
(3, 5.0, 5.0, 0.0), (4, 5.0, 0.0, 0.0),
(5, 10.0, 0.0, 0.0), (6, 10.0, 5.0, 0.0),
(7, 0.0, 10.0, 0.0), (8, 10.0, 10.0, 0.0),
(9, 2.499999999996199, 0.0, 0.0),
(10, 5, 2.499999999996199, 0), (11, 2.5, 5, 0),
(12, 0, 2.5, 0), (13, 7.176360840382222, 0, 0),
(14, 7.176360840382227, 5, 0), (15, 5, 2.5, 0),
(16, 2.499999999996199, 5, 0),
(17, 7.176360840382222, 5, 0), (18, 5, 10, 0),
(19, 0, 7.176360840382227, 0), (20, 2.5, 2.5, 0),
(21, 1.2499999999981, 1.25, 0), (22, 1.25, 3.75, 0),
(23, 3.7499999999981, 1.2499999999981, 0),
(24, 3.750000000001901, 3.749999999998099, 0),
(25, 8.22303669484285, 2.552255592639131, 0),
(26, 6.540735812640291, 1.811426457748249, 0),
(27, 6.3023563126068, 3.480526007198198, 0),
(28, 2.842729718643214, 7.449413862174849, 0),
(29, 6.088180420191112, 7.499999999999999, 0),
(30, 8.316135315143335, 6.875, 0),
(31, 1.335682429659853, 6.156443675639268, 0)]
# Desired elements
# (internal name of Triangle Nnode 3 is 'Tri3')
elements_desired = [
(1, 'straight_line', [2, 12]), (2, 'straight_line', [12, 1]),
(3, 'straight_line', [5, 6]), (4, 'straight_line', [6, 8]),
(5, 'straight_line', [7, 19]), (6, 'straight_line', [19, 2]),
(7, 'Tri3', [24, 23, 10]), (8, 'Tri3', [20, 23, 24]),
(9, 'Tri3', [4, 23, 9]), (10, 'Tri3', [3, 24, 10]),
(11, 'Tri3', [9, 23, 20]), (12, 'Tri3', [9, 20, 21]),
(13, 'Tri3', [1, 21, 12]), (14, 'Tri3', [12, 21, 20]),
(15, 'Tri3', [11, 20, 24]), (16, 'Tri3', [11, 22, 20]),
(17, 'Tri3', [12, 20, 22]), (18, 'Tri3', [3, 11, 24]),
(19, 'Tri3', [2, 22, 11]), (20, 'Tri3', [2, 12, 22]),
(21, 'Tri3', [4, 10, 23]), (22, 'Tri3', [1, 9, 21]),
(23, 'Tri3', [5, 25, 13]), (24, 'Tri3', [6, 14, 25]),
(25, 'Tri3', [14, 27, 25]), (26, 'Tri3', [13, 25, 26]),
(27, 'Tri3', [4, 13, 26]), (28, 'Tri3', [4, 26, 15]),
(29, 'Tri3', [25, 27, 26]), (30, 'Tri3', [3, 15, 27]),
(31, 'Tri3', [3, 27, 14]), (32, 'Tri3', [15, 26, 27]),
(33, 'Tri3', [5, 6, 25]), (34, 'Tri3', [7, 28, 18]),
(35, 'Tri3', [3, 28, 16]), (36, 'Tri3', [7, 19, 28]),
(37, 'Tri3', [3, 29, 28]), (38, 'Tri3', [8, 29, 30]),
(39, 'Tri3', [3, 17, 29]), (40, 'Tri3', [8, 18, 29]),
(41, 'Tri3', [19, 31, 28]), (42, 'Tri3', [2, 16, 31]),
(43, 'Tri3', [16, 28, 31]), (44, 'Tri3', [6, 30, 17]),
(45, 'Tri3', [2, 31, 19]), (46, 'Tri3', [17, 30, 29]),
(47, 'Tri3', [18, 28, 29]), (48, 'Tri3', [6, 8, 30])
]
dimension_desired = 2
groups_desired = [
('x_dirichlet-line', [], [1, 2, 5, 6]), ('x_neumann', [], [3, 4]),
('surface_left', [],
[7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]),
('surface_right', [], [23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
33]),
('surface_top', [],
[34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48])
]
tags_desired = {
'no_of_mesh_partitions': {
1: [
1, 2, 5, 6, 7, 9, 10, 20, 21, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
45, 46, 47, 48
],
2: [3, 4, 8, 11, 12, 13, 14, 15, 16, 17, 18, 19, 22]
},
'partition_id': {
2: [
1, 2, 4, 5, 6, 13, 14, 16, 17, 19, 20, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46, 47, 48
],
1: [
3, 7, 8, 9, 10, 11, 12, 15, 18, 21, 22, 23, 24, 25, 26, 27,
28, 29, 30, 31, 32, 33
]
},
'partitions_neighbors': {
(None, ): [
1, 2, 5, 6, 7, 9, 10, 20, 21, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
45, 46, 47, 48
],
(2, ): [3, 8, 11, 12, 15, 18, 22],
(1, ): [4, 13, 14, 16, 17, 19]
},
'elemental_group': {
4: [1, 2],
6: [3],
11: [4],
13: [5, 6],
1:
[7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22],
2: [23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33],
3:
[34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48]
}
}
# Define input file path
file = amfe_dir('tests/meshes/3_surfaces_2_partitions_mesh.msh')
# Define Reader Object, initialized with AmfeMeshConverter
reader = GmshAsciiMeshReader(file)
# Parse dummy mesh
dummy = DummyMeshConverter()
reader.parse(dummy)
mesh = dummy.return_mesh()
# Check nodes
for i, node in enumerate(nodes_desired):
self.assertEqual(mesh._nodes[i], node)
# Check elements
for i, element in enumerate(elements_desired):
self.assertEqual(mesh._elements[mesh._elements.index(element)],
element)
# Check mesh dimension
self.assertEqual(mesh._dimension, dimension_desired)
self.assertEqual(mesh._groups, groups_desired)
self.custom_asserter.assert_dict_almost_equal(mesh._tags, tags_desired)
self.assertEqual(mesh._no_of_nodes, 31)
self.assertEqual(mesh._no_of_elements, 48)
