def test_assign_neumann_by_tags(self): component = StructuralComponent(self.testmesh) tagvalue = 1 tagname = 'tag_boundaries' time_func = lambda t: 3.0*t direction = (1, 0) condition = component._neumann.create_fixed_direction_neumann(direction, time_func) component.assign_neumann('TestCondition', condition, [tagvalue], tagname) # It must be set: # - neumann_df # - neumann_obj_df neumann_obj_df = component._neumann._neumann_obj_df neumann_obj_array = neumann_obj_df[['neumann_obj', 'fk_mesh']].values self.assertIsInstance(neumann_obj_array[0, 0]._boundary_element, LineLinearBoundary) self.assertEqual(neumann_obj_array[0, 1], 4) self.assertEqual(neumann_obj_array.shape, (1, 2)) neumann_df_actual = component._neumann._neumann_df df_dict = { 'name': {0: 'TestCondition'}, 'tag': {0: tagname}, 'property_names': {0: np.array([1])}, 'neumann_obj': {0: condition} } neumann_df_desired = pd.DataFrame.from_dict(df_dict) assert_frame_equal(neumann_df_actual, neumann_df_desired, check_like=True)
def test_get_materials(self): component = StructuralComponent(self.testmesh) eleids1 = np.array([1, 2], dtype=int) eleids2 = np.array([3], dtype=int) component.assign_material(self.mat1, eleids1, 'S', '_eleids') component.assign_material(self.mat2, eleids2, 'S', '_eleids') materials_desired = [self.mat1, self.mat2] materials_actual = component.get_materials() assert_array_equal(materials_desired, materials_actual)
def test_get_elementids_by_physics(self): component = StructuralComponent(self.testmesh) eleids1 = np.array([1, 2], dtype=int) eleids2 = np.array([3], dtype=int) component.assign_material(self.mat1, eleids1, 'S', '_eleids') component.assign_material(self.mat2, eleids2, 'S', '_eleids') eleids_actual = component.get_elementids_by_physics('S') eleids_desired = np.array([1, 2, 3], dtype=int) assert_array_equal(eleids_actual, eleids_desired)
def test_assign_neumann_by_groups_nonexistent_group(self): # Test, that nothing happens if group is wrong and switch is set True component = StructuralComponent(self.testmesh) group = 'wrong_group' time_func = lambda t: 3.0 * t direction = (1, 0) condition = component._neumann.create_fixed_direction_neumann(direction, time_func) component.assign_neumann('TestCondition', condition, [group], '_groups', True) # It must be set: # - neumann_df # - neumann_obj_df neumann_obj_df = component._neumann._neumann_obj_df neumann_obj_array = neumann_obj_df[['neumann_obj', 'fk_mesh']].values self.assertEqual(neumann_obj_array.shape, (0, 2)) neumann_df_actual = component._neumann._neumann_df neumann_df_desired = pd.DataFrame(columns=['name', 'tag', 'property_names', 'neumann_obj']) assert_frame_equal(neumann_df_actual, neumann_df_desired, check_like=True) # Test, that error is thrown for a wrong group in the default case with self.assertRaises(ValueError): component.assign_neumann('TestCondition', condition, ['left_boundary', group]) # Test in case of multiple passed groups, that only existing groups are handled and nothing happens for wrong # ones component = StructuralComponent(self.testmesh) time_func = lambda t: 3.0 * t direction = (1, 0) condition = component._neumann.create_fixed_direction_neumann(direction, time_func) component.assign_neumann('TestCondition', condition, ['right_boundary', 'wrong_group', 'left_boundary'], '_groups', True) # It must be set: # - neumann_df # - neumann_obj_df neumann_obj_df = component._neumann._neumann_obj_df neumann_obj_array = neumann_obj_df[['neumann_obj', 'fk_mesh']].values self.assertIsInstance(neumann_obj_array[0, 0]._boundary_element, LineLinearBoundary) self.assertEqual(neumann_obj_array[0, 1], 5) self.assertEqual(neumann_obj_array[1, 1], 4) self.assertEqual(neumann_obj_array.shape, (2, 2)) neumann_df_actual = component._neumann._neumann_df df_dict = { 'name': {0: 'TestCondition'}, 'tag': {0: '_groups'}, 'property_names': {0: np.array(['right_boundary', 'left_boundary'])}, 'neumann_obj': {0: condition} } neumann_df_desired = pd.DataFrame.from_dict(df_dict) assert_frame_equal(neumann_df_actual, neumann_df_desired, check_like=True)
def test_amfe_solution_reader(self): self._create_fields() amfesolution = AmfeSolution() sol = self.fields_desired['Nodefield1'] for t, q in zip(sol['timesteps'], sol['data'].T): amfesolution.write_timestep(t, q) mesh = create_amfe_obj() meshcomponent = StructuralComponent(mesh) # Set a material to get a mapping material = KirchhoffMaterial() meshcomponent.assign_material(material, 'Tri6', 'S', 'shape') postprocessorreader = AmfeSolutionReader(amfesolution, meshcomponent)
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 setUp(self): self.timesteps, self.meshreader, self.fields_desired, \ self.fields_no_of_nodes, self.fields_no_of_timesteps = create_fields(2) amfesolution = AmfeSolution() sol = self.fields_desired['Nodefield1'] strains = copy(self.fields_desired['NodefieldStrains']) stresses = copy(self.fields_desired['NodefieldStresses']) for i in range(len(sol['timesteps'])): t = sol['timesteps'][i] q = sol['data'][:, i].T strain = strains['data'][:, :, i].T stress = stresses['data'][:, :, i].T amfesolution.write_timestep(t, q, q, q, strain, stress) self.mesh = create_amfe_obj() self.meshcomponent = StructuralComponent(self.mesh) # Set a material to get a mapping material = KirchhoffMaterial() self.meshcomponent.assign_material(material, 'Tri6', 'S', 'shape') self.postprocessorreader = AmfeSolutionReader(amfesolution, self.meshcomponent)
def test_assign_material_by_groups(self): # 2 Groups # component = StructuralComponent(self.testmesh) # assign materials component.assign_material(self.mat1, ['left', 'right'], 'S', '_groups') ele_obj_actual = component.ele_obj # check ele_obj is instance array self.assertIsInstance(ele_obj_actual, np.ndarray) # check each object ele_obj_df = component._ele_obj_df mask1 = (ele_obj_df['physics'] == 'S') & (ele_obj_df['fk_mesh'] == 1) mask2 = (ele_obj_df['physics'] == 'S') & (ele_obj_df['fk_mesh'] == 2) mask3 = (ele_obj_df['physics'] == 'S') & (ele_obj_df['fk_mesh'] == 3) self.assertIsInstance(ele_obj_df.loc[mask1, 'ele_obj'].values[0], Tri3) self.assertIsInstance(ele_obj_df.loc[mask2, 'ele_obj'].values[0], Tri3) self.assertIsInstance(ele_obj_df.loc[mask3, 'ele_obj'].values[0], Quad4) # check materials # check materials self.assertEqual(ele_obj_df.loc[mask1, 'ele_obj'].values[0].material.name, 'steel') self.assertEqual(ele_obj_df.loc[mask2, 'ele_obj'].values[0].material.name, 'steel') self.assertEqual(ele_obj_df.loc[mask3, 'ele_obj'].values[0].material.name, 'steel') # 1 Group # component = StructuralComponent(self.testmesh) # assign materials component.assign_material(self.mat1, ['left'], 'T') ele_obj_actual = component.ele_obj # check ele_obj is instance array self.assertIsInstance(ele_obj_actual, np.ndarray) # check each object ele_obj_df = component._ele_obj_df with self.assertRaises(IndexError): mask1 = (ele_obj_df['physics'] == 'T') & (ele_obj_df['fk_mesh'] == 1) temp = ele_obj_df.loc[mask1, 'ele_obj'].values[0] with self.assertRaises(IndexError): mask2 = (ele_obj_df['physics'] == 'T') & (ele_obj_df['fk_mesh'] == 2) temp = ele_obj_df.loc[mask2, 'ele_obj'].values[0] mask3 = (ele_obj_df['physics'] == 'T') & (ele_obj_df['fk_mesh'] == 3) self.assertIsInstance(ele_obj_df.loc[mask3, 'ele_obj'].values[0], Quad4) # check materials self.assertEqual(ele_obj_df.loc[mask3, 'ele_obj'].values[0].material.name, 'steel')
def test_assign_material_by_eleids(self): component = StructuralComponent(self.testmesh) eleids1 = np.array([1, 2], dtype=int) eleids2 = np.array([3], dtype=int) component.assign_material(self.mat1, eleids1, 'S', '_eleids') ele_obj_actual = component.ele_obj # check ele_obj is instance array self.assertIsInstance(ele_obj_actual, np.ndarray) # check each object ele_obj_df = component._ele_obj_df mask1 = (ele_obj_df['physics'] == 'S') & (ele_obj_df['fk_mesh'] == 1) mask2 = (ele_obj_df['physics'] == 'S') & (ele_obj_df['fk_mesh'] == 2) self.assertEqual(len(ele_obj_df.loc[mask1, 'ele_obj'].values), 1) self.assertIsInstance(ele_obj_df.loc[mask1, 'ele_obj'].values[0], Tri3) self.assertIsInstance(ele_obj_df.loc[mask2, 'ele_obj'].values[0], Tri3) # check materials self.assertEqual(ele_obj_df.loc[mask1, 'ele_obj'].values[0].material.name, 'steel') self.assertEqual(ele_obj_df.loc[mask2, 'ele_obj'].values[0].material.name, 'steel') # check mapping nodal2global_desired = pd.DataFrame({'ux': {1: -1, 2: 6, 3: 4, 4: -1, 5: 0, 6: 2}, 'uy': {1: -1, 2: 7, 3: 5, 4: -1, 5: 1, 6: 3}}) elements2global_desired = [np.array([0, 1, 2, 3, 4, 5], dtype=int), np.array([4, 5, 6, 7, 0, 1], dtype=int)] assert_frame_equal(component.mapping.nodal2global, nodal2global_desired) for actual, desired in zip(component.mapping.elements2global, elements2global_desired): assert_array_equal(actual, desired) # assign second material component.assign_material(self.mat2, eleids2, 'S', '_eleids') ele_obj_df = component._ele_obj_df # check each object mask1 = (ele_obj_df['physics'] == 'S') & (ele_obj_df['fk_mesh'] == 1) mask2 = (ele_obj_df['physics'] == 'S') & (ele_obj_df['fk_mesh'] == 2) mask3 = (ele_obj_df['physics'] == 'S') & (ele_obj_df['fk_mesh'] == 3) self.assertIsInstance(ele_obj_df.loc[mask1, 'ele_obj'].values[0], Tri3) self.assertIsInstance(ele_obj_df.loc[mask2, 'ele_obj'].values[0], Tri3) self.assertIsInstance(ele_obj_df.loc[mask3, 'ele_obj'].values[0], Quad4) # check materials self.assertEqual(ele_obj_df.loc[mask1, 'ele_obj'].values[0].material.name, 'steel') self.assertEqual(ele_obj_df.loc[mask2, 'ele_obj'].values[0].material.name, 'steel') self.assertEqual(ele_obj_df.loc[mask3, 'ele_obj'].values[0].material.name, 'rubber') nodal2global_desired = pd.DataFrame({'ux': {1: 8, 2: 6, 3: 4, 4: 10, 5: 0, 6: 2}, 'uy': {1: 9, 2: 7, 3: 5, 4: 11, 5: 1, 6: 3}}) elements2global_desired = [np.array([0, 1, 2, 3, 4, 5], dtype=int), np.array([4, 5, 6, 7, 0, 1], dtype=int), np.array([8, 9, 6, 7, 4, 5, 10, 11], dtype=int)] assert_frame_equal(component.mapping.nodal2global, nodal2global_desired) for actual, desired in zip(component.mapping.elements2global, elements2global_desired): assert_array_equal(actual, desired) component = StructuralComponent(self.testmesh) eleids3 = np.array([3, 1], dtype=int) component.assign_material(self.mat1, eleids3, 'S', '_eleids') ele_obj_actual = component.ele_obj # check ele_obj is instance array self.assertIsInstance(ele_obj_actual, np.ndarray) # check each object ele_obj_df = component._ele_obj_df mask1 = (ele_obj_df['physics'] == 'S') & (ele_obj_df['fk_mesh'] == 1) mask3 = (ele_obj_df['physics'] == 'S') & (ele_obj_df['fk_mesh'] == 3) self.assertIsInstance(ele_obj_df.loc[mask1, 'ele_obj'].values[0], Tri3) self.assertIsInstance(ele_obj_df.loc[mask3, 'ele_obj'].values[0], Quad4) with self.assertRaises(IndexError): mask2 = (ele_obj_df['physics'] == 'S') & (ele_obj_df['fk_mesh'] == 2) temp = ele_obj_df.loc[mask2, 'ele_obj'].values[0] # check materials self.assertEqual(ele_obj_df.loc[mask1, 'ele_obj'].values[0].material.name, 'steel') self.assertEqual(ele_obj_df.loc[mask3, 'ele_obj'].values[0].material.name, 'steel') nodal2global_desired = pd.DataFrame({'ux': {1: 0, 2: 2, 3: 4, 4: 6, 5: 8, 6: 10}, 'uy': {1: 1, 2: 3, 3: 5, 4: 7, 5: 9, 6: 11}}) elements2global_desired = [np.array([0, 1, 2, 3, 4, 5, 6, 7], dtype=int), np.array([8, 9, 10, 11, 4, 5], dtype=int)] assert_frame_equal(component.mapping.nodal2global, nodal2global_desired) for actual, desired in zip(component.mapping.elements2global, elements2global_desired): assert_array_equal(actual, desired)
def test_no_of_elements(self): component = StructuralComponent(self.testmesh) eleids1 = np.array([1, 2], dtype=int) component.assign_material(self.mat1, eleids1, 'S', '_eleids') no_of_elements_actual = component.no_of_elements self.assertEqual(no_of_elements_actual, 2)
def test_assembly_setter(self): component = StructuralComponent(self.testmesh) new_assembly = Assembly() component.assembly = new_assembly self.assertEqual(id(component.assembly), id(new_assembly))
def test_assembly_getter(self): component = StructuralComponent(self.testmesh) self.assertIsInstance(component.assembly, Assembly)
def test_str(self): component = StructuralComponent(self.testmesh) print(component)
E_alu = 70e6 nu_alu = 0.34 rho_alu = 2.7e-3 logging.basicConfig(level=logging.DEBUG) input_file = amfe_dir( 'meshes/gmsh/simple_beam_metis_10/simple_beam_metis_10.msh') mesh_reader = GmshAsciiMeshReader(input_file) mesh_converter = AmfeMeshConverter() mesh_reader.parse(mesh_converter) my_mesh = mesh_converter.return_mesh() my_material = KirchhoffMaterial(E_alu, nu_alu, rho_alu, thickness=10) my_component = StructuralComponent(my_mesh) material_tag = ['material'] my_component.assign_material(my_material, material_tag, 'S', '_groups') glo_dofs_x = my_component.mapping.get_dofs_by_nodeids( my_component.mesh.get_nodeids_by_groups(['dirichlet']), ('ux')) glo_dofs_y = my_component.mapping.get_dofs_by_nodeids( my_component.mesh.get_nodeid_by_coordinates(0.0, 0.0, 0.0), ('uy')) my_composite = MeshComponentComposite(my_component) # Decomposition of component tree_builder = TreeBuilder() tree_builder.add([0], [my_composite]) leaf_id = tree_builder.leaf_paths.max_leaf_id tree_builder.separate_partitioned_component_by_leafid(leaf_id)
from amfe.io.postprocessing.tools import write_xdmf_from_hdf5 from amfe.io.postprocessing.reader import AmfeSolutionReader from amfe.io.postprocessing.writer import Hdf5PostProcessorWriter from amfe.solver.translators import * times = dict([]) input_file = amfe_dir('meshes/gmsh/bar.msh') output_file = amfe_dir('results/test_refactoring/nonlinear_beam_new_translators') mesh_reader = GmshAsciiMeshReader(input_file) mesh_converter = AmfeMeshConverter() mesh_reader.parse(mesh_converter) mesh = mesh_converter.return_mesh() my_component = StructuralComponent(mesh) my_material = KirchhoffMaterial(E=210E9, nu=0.3, rho=1E4, plane_stress=True) my_component.assign_material(my_material, [7], 'S', '_groups') dirichlet = my_component.constraints.create_dirichlet_constraint() # Variant A # (xy, direction) #nodeids = mesh.get_nodeids_by_groups([8]) #dofs = my_component.mapping.get_dofs_by_nodeids(nodeids, ('ux', 'uy')) #for dof in dofs.reshape(-1): #my_component.assign_constraint('Leftfixation', dirichlet, np.array([dof], dtype=int), np.array([], dtype=int)) #neumann = my_component.neumann.create_fixed_direction_neumann((0, -1),
class TestEcsw(TestCase): 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 tearDown(self): pass def test_assemble_g_b(self): # store an example for f_int for later comparison to check if the old assembly is recovered # after ecsw_assemble_G_and_b has finished no_of_dofs = self.S.shape[0] dq = ddq = np.zeros(no_of_dofs) t = 0.0 f_old = self.my_component.f_int(self.S[:, 0], dq, t) # run ecsw_assemble_G_and_b G, b = ecsw_assemble_G_and_b(self.my_component, self.S, self.W, self.timesteps) # test shape of G and b no_of_elements = self.my_component.no_of_elements self.assertEqual( G.shape, (self.no_of_dofs * self.no_of_snapshots, no_of_elements)) # ---------------------------------- # Check if G is correct # Test first entry of G g11_actual = G[0:self.no_of_dofs, 0] connectivity = self.my_mesh.get_connectivity_by_elementids([1])[0] X_local = self.my_mesh.nodes_df.loc[connectivity].values.reshape(-1) u_local_indices = self.my_component.mapping.nodal2global.loc[ connectivity].values.reshape(-1) u_local = self.S[u_local_indices, 0] fe_local = self.my_component.ele_obj[0].f_int(X_local, u_local) global_dofs = self.my_component.mapping.elements2global[0] g11_desired = np.zeros(self.no_of_dofs) g11_desired[global_dofs] = fe_local assert_allclose(g11_actual, g11_desired) # Test second entry of G g21_actual = G[self.no_of_dofs:, 0] connectivity = self.my_mesh.get_connectivity_by_elementids([1])[0] X_local = self.my_mesh.nodes_df.loc[connectivity].values.reshape(-1) u_local_indices = self.my_component.mapping.nodal2global.loc[ connectivity].values.reshape(-1) u_local = self.S[u_local_indices, 1] fe_local = self.my_component.ele_obj[0].f_int(X_local, u_local) global_dofs = self.my_component.mapping.elements2global[0] g21_desired = np.zeros(self.no_of_dofs) g21_desired[global_dofs] = fe_local assert_allclose(g21_actual, g21_desired) # Test third entry of G g12_actual = G[0:self.no_of_dofs, 1] connectivity = self.my_mesh.get_connectivity_by_elementids([2])[0] X_local = self.my_mesh.nodes_df.loc[connectivity].values.reshape(-1) u_local_indices = self.my_component.mapping.nodal2global.loc[ connectivity].values.reshape(-1) u_local = self.S[u_local_indices, 0] fe_local = self.my_component.ele_obj[1].f_int(X_local, u_local) global_dofs = self.my_component.mapping.elements2global[1] g12_desired = np.zeros(self.no_of_dofs) g12_desired[global_dofs] = fe_local assert_allclose(g12_actual, g12_desired) # -------------------------------------- # check if b is correct: b_desired = np.sum(G, 1) assert_allclose(b, b_desired) # -------------------------------------- # Check if old assembly is recovered # get f_new for comparison to f_old f_new = self.my_component.f_int(self.S[:, 0], dq, t) # test if old assembly is recovered in the component assert_allclose(f_new, f_old) def test_reduce_with_ecsw(self): # store old ids: comp_id_old = id(self.my_component) mesh_id_old = id(self.my_component.mesh) # first mode: deepcopy weights, indices, stats = ecsw_get_weights_by_component( self.my_component, self.S, self.W, self.timesteps, tau=0.01) ecsw_component = create_ecsw_hyperreduced_component_from_weights( self.my_component, weights, indices, copymode='deep') self.assertNotEqual(id(ecsw_component), comp_id_old) self.assertNotEqual(id(ecsw_component.mesh), mesh_id_old) self.assertIsInstance(ecsw_component.assembly, EcswAssembly) # second mode: shallow weights, indices, stats = ecsw_get_weights_by_component( self.my_component, self.S, self.W, self.timesteps, tau=0.01) ecsw_component = create_ecsw_hyperreduced_component_from_weights( self.my_component, weights, indices, copymode='shallow') self.assertNotEqual(id(ecsw_component), comp_id_old) self.assertEqual(id(ecsw_component.mesh), mesh_id_old) self.assertIsInstance(ecsw_component.assembly, EcswAssembly) # third mode: overwrite weights, indices, stats = ecsw_get_weights_by_component( self.my_component, self.S, self.W, self.timesteps, tau=0.01) ecsw_component = create_ecsw_hyperreduced_component_from_weights( self.my_component, weights, indices, copymode='overwrite') self.assertEqual(id(ecsw_component), comp_id_old) self.assertEqual(id(ecsw_component.mesh), mesh_id_old) self.assertIsInstance(ecsw_component.assembly, EcswAssembly) # test wrong copymode with self.assertRaises(ValueError): weights, indices, stats = ecsw_get_weights_by_component( self.my_component, self.S, self.W, self.timesteps, tau=0.01, conv_stats=False) ecsw_component = create_ecsw_hyperreduced_component_from_weights( self.my_component, weights, indices, copymode='foo') # test if function with option stats = false is executable weights, indices, stats = ecsw_get_weights_by_component( self.my_component, self.S, self.W, self.timesteps, tau=0.01, conv_stats=False) ecsw_component = create_ecsw_hyperreduced_component_from_weights( self.my_component, weights, indices) self.assertIsInstance(ecsw_component.assembly, EcswAssembly)
# Force: g mm s-2 = µN # Stiffness: g s-2 mm-1 = Pa # velocity: mm/s # acceleration: mm/s^2 # density: g/mm3 E_alu = 70e6 nu_alu = 0.34 rho_alu = 2.7e-3 logging.basicConfig(level=logging.DEBUG) input_file = amfe_dir('meshes/amfe_json/simple_beam/simple_beam.json') my_mesh = GidJsonMeshReader(input_file, AmfeMeshConverter()).parse() my_material = KirchhoffMaterial(E_alu, nu_alu, rho_alu, thickness=10) my_component = StructuralComponent(my_mesh) my_component.assign_material(my_material, 'Quad8', 'S', 'shape') my_neumann = FixedDirectionNeumann(np.array([0, 1]), time_func = lambda t: 2) my_component.assign_neumann('Neumann0', my_neumann, ['right_boundary'], '_groups') my_constraint = my_component.constraints.create_dirichlet_constraint() fixed_nodeids = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], dtype=int) my_component.assign_constraint('Dirichlet0', my_constraint, fixed_nodeids, '_nodeids', 'elim') print('END')
from amfe.ui import * from amfe.material import KirchhoffMaterial from amfe.component import StructuralComponent from amfe.solver import SolverFactory, AmfeSolution from amfe.solver.translators import create_constrained_mechanical_system_from_component from amfe.structural_dynamics import vibration_modes meshfile = amfe_dir('meshes/gmsh/AMFE_logo.msh') output_file = amfe_dir('results/AMFE_logo/logo_5_v2.xdmf') material_1 = KirchhoffMaterial(E=5E6, rho=1E4) material_2 = KirchhoffMaterial(E=5E7, rho=1E4) mesh = import_mesh_from_file(meshfile) my_component = StructuralComponent(mesh) my_component.assign_material(material_1, [299, 300], 'S') my_component.assign_material(material_2, [301, 302], 'S') set_dirichlet_by_group(my_component, 298, ('ux', 'uy', 'uz')) no_of_dofs = my_component.mapping.no_of_dofs q0 = np.zeros(no_of_dofs) nodeids = my_component.mesh.nodes_df.index.to_list() dofnumbers = my_component.mapping.get_dofs_by_nodeids(nodeids, ('uy', )) M_unconstr = my_component.M(q0, q0, 0.0) g = np.zeros_like(q0) for dofnumber in dofnumbers: g[dofnumber] = -9.81
# we specify the path for the input mesh and an output path, # where we will save the solutions input_file = '/meshes/3d_truss_with_slope.msh' output_path = '/results/linear_static_3d_example' """ We are setting up the material properties and defining our component with the mesh file. It's important to remember to set the parameter of ``surface2partition`` to ``True`` when reading the mesh. """ # Reading the .msh file and defining a structural component reader = GmshAsciiMeshReader(input_file) converter = AmfeMeshConverter() reader.parse(converter, surface2partition=True) my_mesh = converter.return_mesh() my_component = StructuralComponent(my_mesh) """ We proceed by assigning the material properties and mapping the global degrees of freedom for the Dirichlet boundary conditions. """ # Assigning material properties on physical group called "material" ui.assign_material_by_group(my_component, my_material, 'material') # Mapping the degrees of freedom for nodes belonging to the physical group called "dirichlet" glo_dofs_x = my_component.mapping.get_dofs_by_nodeids( my_component.mesh.get_nodeids_by_groups(['dirichlet']), 'ux') glo_dofs_y = my_component.mapping.get_dofs_by_nodeids( my_component.mesh.get_nodeids_by_groups(['dirichlet']), 'uy') glo_dofs_z = my_component.mapping.get_dofs_by_nodeids( my_component.mesh.get_nodeids_by_groups(['dirichlet']), 'uz')
class AmfeSolutionReaderTest(TestCase): def setUp(self): self.timesteps, self.meshreader, self.fields_desired, \ self.fields_no_of_nodes, self.fields_no_of_timesteps = create_fields(2) amfesolution = AmfeSolution() sol = self.fields_desired['Nodefield1'] strains = copy(self.fields_desired['NodefieldStrains']) stresses = copy(self.fields_desired['NodefieldStresses']) for i in range(len(sol['timesteps'])): t = sol['timesteps'][i] q = sol['data'][:, i].T strain = strains['data'][:, :, i].T stress = stresses['data'][:, :, i].T amfesolution.write_timestep(t, q, q, q, strain, stress) self.mesh = create_amfe_obj() self.meshcomponent = StructuralComponent(self.mesh) # Set a material to get a mapping material = KirchhoffMaterial() self.meshcomponent.assign_material(material, 'Tri6', 'S', 'shape') self.postprocessorreader = AmfeSolutionReader(amfesolution, self.meshcomponent) def tearDown(self): pass def test_parse(self): #meshreader = AmfeMeshObjMeshReader(self.mesh) postprocessorwriter = DummyPostProcessorWriter(self.meshreader) self.postprocessorreader.parse(postprocessorwriter) fields_actual = postprocessorwriter.return_result() field_desired = self.fields_desired['Nodefield1'] q = field_desired['data'] dofs_x = self.meshcomponent.mapping.get_dofs_by_nodeids( self.meshcomponent.mesh.nodes_df.index.values, ('ux')) dofs_y = self.meshcomponent.mapping.get_dofs_by_nodeids( self.meshcomponent.mesh.nodes_df.index.values, ('uy')) q_x = q[dofs_x, :] q_y = q[dofs_y, :] data = np.empty((0, 3, 4), dtype=float) for node in self.meshcomponent.mesh.get_nodeidxs_by_all(): data = np.concatenate( (data, np.array([[q_x[node], q_y[node], np.zeros(q_x.shape[1])]])), axis=0) field_desired['data'] = data def _get_desired_strain_stress_fields(nodeidxs, field): normal_desired = copy(field) shear_desired = copy(field) values = field['data'] data1 = np.empty((0, 3, 4), dtype=float) data2 = np.empty((0, 3, 4), dtype=float) for node in nodeidxs: data1 = np.concatenate( (data1, np.array([[ values[0, node], values[1, node], values[2, node] ]])), axis=0) data2 = np.concatenate( (data2, np.array([[ values[3, node], values[4, node], values[5, node] ]])), axis=0) normal_desired['data'] = data1 shear_desired['data'] = data2 return normal_desired, shear_desired strains_normal_desired, strains_shear_desired = \ _get_desired_strain_stress_fields(self.meshcomponent.mesh.get_nodeidxs_by_all(), self.fields_desired['NodefieldStrains']) stresses_normal_desired, stresses_shear_desired = \ _get_desired_strain_stress_fields(self.meshcomponent.mesh.get_nodeidxs_by_all(), self.fields_desired['NodefieldStresses']) # Check no of fields: self.assertEqual(len(fields_actual.keys()), 7) # Check each field: field_displacement_actual = fields_actual['displacement'] assert_array_equal(field_displacement_actual['timesteps'], field_desired['timesteps']) assert_array_equal(field_displacement_actual['data_type'], field_desired['data_type']) assert_array_equal(field_displacement_actual['data'], field_desired['data']) assert_array_equal(field_displacement_actual['index'], field_desired['index']) assert_array_equal(field_displacement_actual['mesh_entity_type'], field_desired['mesh_entity_type']) field_velocity_actual = fields_actual['velocity'] assert_array_equal(field_velocity_actual['timesteps'], field_desired['timesteps']) assert_array_equal(field_velocity_actual['data_type'], field_desired['data_type']) assert_array_equal(field_velocity_actual['data'], field_desired['data']) assert_array_equal(field_velocity_actual['index'], field_desired['index']) assert_array_equal(field_velocity_actual['mesh_entity_type'], field_desired['mesh_entity_type']) field_acceleration_actual = fields_actual['acceleration'] assert_array_equal(field_acceleration_actual['timesteps'], field_desired['timesteps']) assert_array_equal(field_acceleration_actual['data_type'], field_desired['data_type']) assert_array_equal(field_acceleration_actual['data'], field_desired['data']) assert_array_equal(field_acceleration_actual['index'], field_desired['index']) assert_array_equal(field_acceleration_actual['mesh_entity_type'], field_desired['mesh_entity_type']) field_acceleration_actual = fields_actual['strains_normal'] assert_array_equal(field_acceleration_actual['timesteps'], strains_normal_desired['timesteps']) assert_array_equal(field_acceleration_actual['data_type'], strains_normal_desired['data_type']) assert_array_equal(field_acceleration_actual['data'], strains_normal_desired['data']) assert_array_equal(field_acceleration_actual['index'], strains_normal_desired['index']) assert_array_equal(field_acceleration_actual['mesh_entity_type'], strains_normal_desired['mesh_entity_type']) field_acceleration_actual = fields_actual['strains_shear'] assert_array_equal(field_acceleration_actual['timesteps'], strains_shear_desired['timesteps']) assert_array_equal(field_acceleration_actual['data_type'], strains_shear_desired['data_type']) assert_array_equal(field_acceleration_actual['data'], strains_shear_desired['data']) assert_array_equal(field_acceleration_actual['index'], strains_shear_desired['index']) assert_array_equal(field_acceleration_actual['mesh_entity_type'], strains_shear_desired['mesh_entity_type']) field_acceleration_actual = fields_actual['stresses_normal'] assert_array_equal(field_acceleration_actual['timesteps'], stresses_normal_desired['timesteps']) assert_array_equal(field_acceleration_actual['data_type'], stresses_normal_desired['data_type']) assert_array_equal(field_acceleration_actual['data'], stresses_normal_desired['data']) assert_array_equal(field_acceleration_actual['index'], stresses_normal_desired['index']) assert_array_equal(field_acceleration_actual['mesh_entity_type'], stresses_normal_desired['mesh_entity_type']) field_acceleration_actual = fields_actual['stresses_shear'] assert_array_equal(field_acceleration_actual['timesteps'], stresses_shear_desired['timesteps']) assert_array_equal(field_acceleration_actual['data_type'], stresses_shear_desired['data_type']) assert_array_equal(field_acceleration_actual['data'], stresses_shear_desired['data']) assert_array_equal(field_acceleration_actual['index'], stresses_shear_desired['index']) assert_array_equal(field_acceleration_actual['mesh_entity_type'], stresses_shear_desired['mesh_entity_type']) def test_convert_data_2_field(self): sol = self.fields_desired['Nodefield1'] data_test = sol['data'] field_actual = self.postprocessorreader._convert_data_2_field( data_test) dofs_x = self.meshcomponent.mapping.get_dofs_by_nodeids( self.meshcomponent.mesh.nodes_df.index.values, ('ux')) dofs_y = self.meshcomponent.mapping.get_dofs_by_nodeids( self.meshcomponent.mesh.nodes_df.index.values, ('uy')) q_x = data_test[dofs_x, :] q_y = data_test[dofs_y, :] field_desired = np.empty((0, 3, 4), dtype=float) for node in self.meshcomponent.mesh.get_nodeidxs_by_all(): field_desired = np.concatenate( (field_desired, np.array([[q_x[node], q_y[node], np.zeros(q_x.shape[1])]])), axis=0) assert_array_equal(field_actual, field_desired) def test_convert_data_2_normal(self): sol = self.fields_desired['NodefieldStrains'] data_test = sol['data'] field_actual = self.postprocessorreader._convert_data_2_normal( data_test) field_desired = np.empty((0, 3, 4), dtype=float) for node in self.meshcomponent.mesh.get_nodeidxs_by_all(): field_desired = np.concatenate( (field_desired, np.array([[ data_test[0, node], data_test[1, node], data_test[2, node] ]])), axis=0) assert_array_equal(field_actual, field_desired) def test_convert_data_2_shear(self): sol = self.fields_desired['NodefieldStrains'] data_test = sol['data'] field_actual = self.postprocessorreader._convert_data_2_shear( data_test) field_desired = np.empty((0, 3, 4), dtype=float) for node in self.meshcomponent.mesh.get_nodeidxs_by_all(): field_desired = np.concatenate( (field_desired, np.array([[ data_test[3, node], data_test[4, node], data_test[5, node] ]])), axis=0) assert_array_equal(field_actual, field_desired)