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)