def __init__(self, parameters): super().__init__() self.parameters = parameters self.settings = parameters['settings'] # create solver tools.pass_on_parameters(self.settings, self.settings['solver_wrapper']['settings'], ['timestep_start', 'delta_t', 'save_restart']) self.solver_wrapper = create_instance(self.settings['solver_wrapper']) # create mappers self.mapper_interface_input = create_instance( self.settings['mapper_interface_input']) self.mapper_interface_output = create_instance( self.settings['mapper_interface_output']) self.interface_input_from = None self.interface_input_to = None self.interface_output_to = None # time self.init_time = 0.0 self.run_time = 0.0
def test_instantiation(self): create_instance(self.parameters) self.parameters['settings']['direction_axial'] = 'X' self.assertRaises(ValueError, create_instance, self.parameters) self.parameters['settings']['direction_axial'] = 'x' self.parameters['settings']['direction_radial'] = 2 self.assertRaises(ValueError, create_instance, self.parameters)
def __init__(self, parameters): super().__init__(parameters) self.model_f = create_instance(self.parameters['settings']['model_f']) self.model_s = create_instance(self.parameters['settings']['model_s']) self.omega = self.settings['omega'] self.atol = self.settings['absolute_tolerance_gmres'] self.rtol = self.settings['relative_tolerance_gmres'] self.xtemp = self.ytemp = None self.dxtemp = self.dytemp = None self.u = self.w = None self.ready = None
def test_coupled_solver(self): with cd(self.working_dir): coupled_solver = create_instance(self.parameters) coupled_solver.initialize() coupled_solver.initialize_solution_step() coupled_solver.solve_solution_step() sol_x = [ 0.00000e+00, 3.09851e-07, 0.00000e+00, 0.00000e+00, 3.00094e-07, 0.00000e+00, 0.00000e+00, 2.90572e-07, 0.00000e+00, 0.00000e+00, 2.81238e-07, 0.00000e+00, 0.00000e+00, 2.72094e-07, 0.00000e+00, 0.00000e+00, 2.63131e-07, 0.00000e+00, 0.00000e+00, 2.54343e-07, 0.00000e+00, 0.00000e+00, 2.45726e-07, 0.00000e+00, 0.00000e+00, 2.37273e-07, 0.00000e+00, 0.00000e+00, 2.28979e-07, 0.00000e+00 ] # TODO: The reference solution has to be modified. Future work: mock solver np.testing.assert_allclose(coupled_solver.x.get_interface_data(), sol_x, rtol=1e-5) coupled_solver.finalize_solution_step() coupled_solver.output_solution_step() coupled_solver.finalize()
def mock_create_instance(settings): object_type = settings['type'] if 'dummy' not in object_type: return create_instance(settings) else: object_module = __import__('coconut.tests.solver_wrappers.combined.' + object_type, fromlist=[object_type]) return object_module.create(settings)
def __init__(self, parameters): """ This mapper combines 1 interpolator mapper with 0 or more transformer mappers, in arbitrary order. If more than 1 mapper is present, inner ModelParts are created and stored in the attribute model_parts. """ super().__init__() self.settings = parameters['settings'] # create all mappers self.mappers = [] for par in self.settings['mappers']: self.mappers.append(create_instance(par)) # initialization self.interfaces = None # check that exactly one mapper is an interpolator counter = 0 for i, mapper in enumerate(self.mappers): if isinstance(mapper, MapperInterpolator): self.index = i counter += 1 if counter != 1: raise ValueError(f'{counter} interpolators found instead of 1')
def __init__(self, parameters): super().__init__() settings = parameters['settings'] self.convergence_criteria = [] for criterion in settings['criteria_list']: self.convergence_criteria.append(create_instance(criterion))
def test_call_3d_var(self): var = 'displacement' mp_name_in = 'wall_in' mp_name_out = 'wall_out' n = 10 x, y, z = np.random.rand(n), np.random.rand(n), np.random.rand(n) v_in = np.random.rand(n, 3) model = data_structure.Model() model.create_model_part(mp_name_in, x, y, z, np.arange(n)) parameters_in = [{'model_part': mp_name_in, 'variables': [var]}] interface_in = data_structure.Interface(parameters_in, model) interface_in.set_variable_data(mp_name_in, var, v_in) mapper = create_instance(self.parameters) mapper.initialize(model, mp_name_in, mp_name_out, forward=True) parameters_out = [{'model_part': mp_name_out, 'variables': [var]}] interface_out = data_structure.Interface(parameters_out, model) mapper((interface_in, mp_name_in, var), (interface_out, mp_name_out, var)) v_out = interface_out.get_variable_data(mp_name_out, var) np.testing.assert_array_equal(v_in[:, 0], v_out[:, 1]) np.testing.assert_array_equal(v_in[:, 1], v_out[:, 2]) np.testing.assert_array_equal(v_in[:, 2], v_out[:, 0])
def test_displacement_on_nodes(self, create_instance): # test if nodes are moved to the correct position comb_solver = create_instance(self.comb_sol_par) model_part = comb_solver.get_interface_input().get_model_part(self.mp_name_in) x0, y0, z0 = model_part.x0, model_part.y0, model_part.z0 displacement = self.get_displacement(x0, y0, z0) comb_solver.get_interface_input().set_variable_data(self.mp_name_in, 'displacement', displacement) # update position by iterating once in solver comb_solver.initialize() comb_solver.initialize_solution_step() comb_solver.solve_solution_step(comb_solver.get_interface_input()) comb_solver.finalize_solution_step() comb_solver.finalize() interface_input = comb_solver.master_solver_wrapper.get_interface_input() out_disp = interface_input.get_interface_data() np.testing.assert_allclose(out_disp, displacement.ravel(), rtol=1e-12) for index, mapped_sol_wrapper in enumerate(comb_solver.solver_wrapper_list): if not index == comb_solver.master_sol_index: interface_input = mapped_sol_wrapper.solver_wrapper.get_interface_input() out_disp = interface_input.get_interface_data() np.testing.assert_allclose(out_disp, displacement.ravel(), rtol=1e-12)
def test_output(self, create_instance): # test if nodes are moved to the correct position comb_solver = create_instance(self.comb_sol_par) model_part = comb_solver.get_interface_input().get_model_part(self.mp_name_in) x0, y0, z0 = model_part.x0, model_part.y0, model_part.z0 displacement = self.get_displacement(x0, y0, z0) comb_solver.get_interface_input().set_variable_data(self.mp_name_in, 'displacement', displacement) # update position by iterating once in solver comb_solver.initialize() comb_solver.initialize_solution_step() output_interface = comb_solver.solve_solution_step(comb_solver.get_interface_input()) comb_solver.finalize_solution_step() comb_solver.finalize() pressure = output_interface.get_variable_data(self.mp_name_out, 'pressure') traction = output_interface.get_variable_data(self.mp_name_out, 'traction') pres_ref, trac_ref = comb_solver.master_solver_wrapper.calculate_output(displacement.ravel(), comb_solver.get_interface_output(), self.mp_name_out) for index, mapped_sol_wrapper in enumerate(comb_solver.solver_wrapper_list): if not index == comb_solver.master_sol_index: pres_other, trac_other = mapped_sol_wrapper.solver_wrapper.calculate_output(displacement.ravel(), comb_solver.get_interface_output(), self.mp_name_out) pres_ref += pres_other trac_ref += trac_other np.testing.assert_allclose(pressure, pres_ref, rtol=1e-12) np.testing.assert_allclose(traction, trac_ref, rtol=1e-12) print('\n') comb_solver.print_components_info('├─')
def test_move_nodes(self): # test if nodes are moved to the correct position # adapt parameters, create solver self.parameters['settings']['flow_iterations'] = 1 solver = create_instance(self.parameters) solver.initialize() # set displacement interface_input = solver.get_interface_input() model_part = interface_input.get_model_part(self.mp_name_in) x0, y0 = model_part.x0, model_part.y0 dy = self.get_dy(x0) displacement = interface_input.get_variable_data( self.mp_name_in, 'displacement') displacement[:, 1] = dy interface_input.set_variable_data(self.mp_name_in, 'displacement', displacement) # update position by iterating once in solver solver.initialize_solution_step() solver.solve_solution_step(interface_input) solver.finalize_solution_step() coord_data = solver.get_coordinates() solver.finalize() # check if correct displacement was given y = coord_data[self.mp_name_in]['coords'][:, 1] np.testing.assert_allclose(y, y0 + dy, rtol=1e-15)
def setUpClass(cls): dir_tmp = join(os.path.dirname(__file__), f'test_v614/tube{int(cls.dimension)}d') # perform reference calculation with open(join(dir_tmp, 'parameters.json')) as parameter_file: parameters = json.load(parameter_file) solver_name = parameters['type'].replace('solver_wrappers.', '') env = get_solver_env(solver_name, dir_tmp) if cls.setup_case: p_setup_abaqus = subprocess.Popen('sh ' + join(dir_tmp, 'setup_abaqus.sh'), cwd=dir_tmp, shell=True, env=env) p_setup_abaqus.wait() # create the solver solver = create_instance(parameters) interface_input = solver.get_interface_input() # give value to variables pressure = interface_input.get_variable_data(cls.mp_name_in, 'pressure') pressure[:] = cls.p interface_input.set_variable_data(cls.mp_name_in, 'pressure', pressure) traction = interface_input.get_variable_data(cls.mp_name_in, 'traction') traction[:, :] = cls.shear interface_input.set_variable_data(cls.mp_name_in, 'traction', traction) solver.initialize() # step 1, coupling 1 solver.initialize_solution_step() output1_1 = solver.solve_solution_step(interface_input) # step 1, coupling 2 output1_2 = solver.solve_solution_step(interface_input) solver.finalize_solution_step() # save output for comparison, as input hasn't changed these should be the same cls.a1_1 = output1_1.get_variable_data(cls.mp_name_out, 'displacement') cls.a2_1 = output1_2.get_variable_data(cls.mp_name_out, 'displacement') # step 2 to 4 for i in range(3): solver.initialize_solution_step() solver.solve_solution_step(interface_input) solver.finalize_solution_step() solver.finalize() # get data for solver without restart cls.interface_y_single_run = solver.get_interface_input() cls.interface_x_single_run = solver.get_interface_output() output_single_run = solver.get_interface_output() cls.a1 = output_single_run.get_variable_data(cls.mp_name_out, 'displacement') print(f"Max disp a1: {np.max(np.abs(cls.a1), axis=0)}")
def test_pressure_traction(self): # test if same coordinates always give same pressure & traction # adapt parameters, create solver max_cores = multiprocessing.cpu_count() # max available cores # fix cores based on available cores if max_cores >= 8: cores = 8 elif max_cores >= 4: cores = 4 elif max_cores >= 2: cores = 2 else: cores = 1 self.parameters['settings']['cores'] = cores self.parameters['settings']['flow_iterations'] = 500 solver = create_instance(self.parameters) solver.initialize() solver.initialize_solution_step() interface_input = solver.get_interface_input() # set displacement model_part = interface_input.get_model_part(self.mp_name_in) x0, y0, z0 = model_part.x0, model_part.y0, model_part.z0 dy, dz = self.get_dy_dz(x0, y0, z0) dydz = np.column_stack((dy, dz)) dydzs = [dydz, np.zeros_like(dydz), dydz] displacement = interface_input.get_variable_data( self.mp_name_in, 'displacement') # run solver for three displacements (first one = last one) pressure = [] traction = [] for dydz in dydzs: displacement[:, 1:] = dydz interface_input.set_variable_data(self.mp_name_in, 'displacement', displacement) interface_output = solver.solve_solution_step(interface_input) pressure.append( interface_output.get_variable_data(self.mp_name_out, 'pressure')) traction.append( interface_output.get_variable_data(self.mp_name_out, 'traction')) solver.finalize_solution_step() solver.finalize() # check if same position gives same pressure & traction np.testing.assert_allclose(pressure[0], pressure[2], rtol=1e-10) np.testing.assert_allclose(traction[0], traction[2], rtol=1e-10) # check if different position gives different pressure & traction p01 = np.linalg.norm(pressure[0] - pressure[1]) p02 = np.linalg.norm(pressure[0] - pressure[2]) self.assertTrue(p02 / p01 < 1e-12) t01 = np.linalg.norm(traction[0] - traction[1]) t02 = np.linalg.norm(traction[0] - traction[2]) self.assertTrue(t02 / t01 < 1e-12)
def __init__(self, parameters): self.parameters = parameters self.settings = parameters["settings"] self.number_of_timesteps = self.settings["number_of_timesteps"] self.coupled_solver = create_instance( self.parameters["coupled_solver"])
def test_partitioning(self): """ Test whether using 4 CPUs yields the same results as using a single one. A constant pressure is applied and no shear, on the tube examples. For the test the relative difference between displacements is checked, but it is required to also use a small absolute tolerance, otherwise the test will fail in the symmetry planes (i.e. whenever one of the original coordinates is 0), because those have a near-zero displacement after applying a uniform pressure an no shear. This near-zero value is a noise and has large relative differences between runs, but a very low absolute value, they are successfully filtered with an absolute tolerance. """ # adapt Parameters, create solver self.parameters['settings']['cores'] = 4 solver = create_instance(self.parameters) interface_input = solver.get_interface_input() # give value to variables pressure = interface_input.get_variable_data(self.mp_name_in, 'pressure') pressure[:] = self.p interface_input.set_variable_data(self.mp_name_in, 'pressure', pressure) traction = interface_input.get_variable_data(self.mp_name_in, 'traction') traction[:, :] = self.shear interface_input.set_variable_data(self.mp_name_in, 'traction', traction) # do 4 steps solver.initialize() for i in range(4): solver.initialize_solution_step() solver.solve_solution_step(interface_input) solver.finalize_solution_step() solver.finalize() # compare output, as input hasn't changed these should be the same output_4cores = solver.get_interface_output() self.a4 = output_4cores.get_variable_data(self.mp_name_out, 'displacement') print(f"\nMax disp a4: {np.max(np.abs(self.a4), axis=0)}") print( f"Max diff between a1 and a4: {np.abs(self.a1 - self.a4).max(axis=0)}" ) indices = sorted( [self.axial_dir] + self.radial_dirs) # columns that contain non-zero data a4_extra = np.delete(self.a4, indices, axis=1) # remove columns containing data np.testing.assert_array_equal( a4_extra, a4_extra * 0.0) # if a column remains it should be all zeroes np.testing.assert_allclose(self.a4[:, indices], self.a1[:, indices], rtol=1e-10, atol=1e-17) # non-zero columns
def test_instantiation(self): self.parameters['settings']['directions'] = ['z'] mapper = create_instance(self.parameters) self.assertListEqual(mapper.directions, ['z0']) self.parameters['settings']['directions'] = ['z', 'y', 'x'] mapper = create_instance(self.parameters) self.assertListEqual(mapper.directions, ['z0', 'y0', 'x0']) self.parameters['settings']['directions'] = ['Z'] self.assertRaises(ValueError, create_instance, self.parameters) self.parameters['settings']['directions'] = ['z0'] self.assertRaises(ValueError, create_instance, self.parameters) self.parameters['settings']['directions'] = ['z', 'y', 'x', 'z'] self.assertRaises(ValueError, create_instance, self.parameters) self.parameters['settings']['directions'] = 'z' self.assertRaises(TypeError, create_instance, self.parameters)
def test_shear(self): """ Test whether shear is also applied. """ # create solver solver = create_instance(self.parameters) interface_input = solver.get_interface_input() # apply non-zero shear in axial_dir (y for 2D, x for 3D) local_shear = self.shear.copy() local_shear[self.axial_dir] = 5 # give value to variables pressure = interface_input.get_variable_data(self.mp_name_in, 'pressure') pressure[:] = self.p interface_input.set_variable_data(self.mp_name_in, 'pressure', pressure) traction = interface_input.get_variable_data(self.mp_name_in, 'traction') traction[:, :] = local_shear interface_input.set_variable_data(self.mp_name_in, 'traction', traction) # do 4 steps solver.initialize() for i in range(4): solver.initialize_solution_step() solver.solve_solution_step(interface_input) solver.finalize_solution_step() solver.finalize() # compare output, as shear input has changed these should be different output_shear = solver.get_interface_output() self.a5 = output_shear.get_variable_data(self.mp_name_out, 'displacement') # calculate mean displacement # no absolute value is used on purpose to filter out the axial displacement due to pressure only self.mean_displacement_shear = np.mean(self.a5[:, self.axial_dir]) self.mean_displacement_no_shear = np.mean(self.a1[:, self.axial_dir]) print( f'Mean displacement in axial direction without shear = {self.mean_displacement_no_shear} m' ) print( f'Mean displacement in axial direction with shear = {self.mean_displacement_shear} m' ) self.assertNotAlmostEqual(self.mean_displacement_no_shear - self.mean_displacement_shear, 0., delta=1e-12)
def initialize(self, interface_from, interface_to): super().initialize() # loop over ModelParts and create mappers for item_from, item_to in zip(interface_from.parameters, interface_to.parameters): mp_from = interface_from.get_model_part(item_from['model_part']) mp_to = interface_to.get_model_part(item_to['model_part']) mapper = create_instance(self.settings) mapper.initialize(mp_from, mp_to) mapper.model_part_names = (mp_from.name, mp_to.name) self.mappers[mp_from.name + '_to_' + mp_to.name] = mapper
def test_convergence_criterion_relative_norm(self): m = 10 dz = 2 a0 = 10 a1 = 1e-4 a2 = 1e-6 variable = 'area' model_part_name = 'wall' interface_settings = [{'model_part': model_part_name, 'variables': [variable]}] # create model and model_part model = data_structure.Model() ids = np.arange(0, m) x0 = np.zeros(m) y0 = np.zeros(m) z0 = np.arange(0, m * dz, dz) model.create_model_part(model_part_name, x0, y0, z0, ids) a0_array = np.full((m, 1), a0) a1_array = np.full((m, 1), a1) a2_array = np.full((m, 1), a2) # create interface interface = Interface(interface_settings, model) # create convergence criterion parameters = {'type': 'convergence_criteria.relative_norm', 'settings': {'tolerance': 1e-6, 'order': 2}} convergence_criterion_relative_norm = create_instance(parameters) convergence_criterion_relative_norm.initialize() # test convergence criterion for i in range(3): convergence_criterion_relative_norm.initialize_solution_step() is_satisfied = convergence_criterion_relative_norm.is_satisfied() self.assertFalse(is_satisfied) interface.set_variable_data(model_part_name, variable, a0_array) convergence_criterion_relative_norm.update(interface) is_satisfied = convergence_criterion_relative_norm.is_satisfied() self.assertFalse(is_satisfied) interface.set_variable_data(model_part_name, variable, a1_array) convergence_criterion_relative_norm.update(interface) is_satisfied = convergence_criterion_relative_norm.is_satisfied() self.assertFalse(is_satisfied) interface.set_variable_data(model_part_name, variable, a2_array) convergence_criterion_relative_norm.update(interface) is_satisfied = convergence_criterion_relative_norm.is_satisfied() self.assertTrue(is_satisfied) interface.set_variable_data(model_part_name, variable, a1_array) convergence_criterion_relative_norm.update(interface) is_satisfied = convergence_criterion_relative_norm.is_satisfied() self.assertFalse(is_satisfied) convergence_criterion_relative_norm.finalize_solution_step()
def test_predictor_linear(self): m = 10 dz = 3 a0 = 1 p1 = 1 a1 = 2 p2 = 3 variable = 'area' model_part_name = 'wall' interface_settings = [{ 'model_part': model_part_name, 'variables': [variable] }] # create model and model_part model = data_structure.Model() ids = np.arange(0, m) x0 = np.zeros(m) y0 = np.zeros(m) z0 = np.arange(0, m * dz, dz) model.create_model_part(model_part_name, x0, y0, z0, ids) a0_array = np.full((m, 1), a0) # create interface interface = Interface(interface_settings, model) interface.set_variable_data(model_part_name, variable, a0_array) # create predictor parameters = {'type': 'predictors.linear'} predictor_linear = create_instance(parameters) predictor_linear.initialize(interface) # first prediction needs to be equal to initialized value predictor_linear.initialize_solution_step() prediction = predictor_linear.predict(interface) self.assertIsInstance(prediction, Interface) prediction_as_array = prediction.get_interface_data() for i in range(m): self.assertAlmostEqual(p1, prediction_as_array[i]) interface_as_array = a1 * prediction_as_array interface.set_interface_data(interface_as_array) predictor_linear.update(interface) predictor_linear.finalize_solution_step() # second prediction needs to be linear predictor_linear.initialize_solution_step() prediction = predictor_linear.predict(interface) self.assertIsInstance(prediction, Interface) prediction_as_array = prediction.get_interface_data() for i in range(m): self.assertAlmostEqual(p2, prediction_as_array[i])
def map(self, parameters): mapper = create_instance(parameters) mapper.initialize(self.model.get_model_part(self.mp_name_from), self.model.get_model_part(self.mp_name_to)) args_from = (self.interface_from, self.mp_name_from, self.var) args_to = (self.interface_to, self.mp_name_to, self.var) mapper(args_from, args_to) self.v_to_fun = self.fun(self.z_to) self.v_to = self.interface_to.get_variable_data(self.mp_name_to, self.var) self.v_error = np.abs(self.v_to.flatten() - self.v_to_fun)
def test_convergence_criterion_and(self): m = 10 dz = 2 a0 = 1 variable = 'area' model_part_name = 'wall' interface_settings = [{'model_part': model_part_name, 'variables': [variable]}] # create model and model_part model = data_structure.Model() ids = np.arange(0, m) x0 = np.zeros(m) y0 = np.zeros(m) z0 = np.arange(0, m * dz, dz) model.create_model_part(model_part_name, x0, y0, z0, ids) a0_array = np.full((m, 1), a0) # create interface interface = Interface(interface_settings, model) interface.set_variable_data(model_part_name, variable, a0_array) # read settings parameter_file_name = os.path.join(os.path.dirname(__file__), 'test_and.json') with open(parameter_file_name, 'r') as parameter_file: parameters = json.load(parameter_file) convergence_criterion_and = create_instance(parameters) convergence_criterion_and.initialize() for i in range(3): convergence_criterion_and.initialize_solution_step() is_satisfied = convergence_criterion_and.is_satisfied() self.assertFalse(is_satisfied) convergence_criterion_and.update(interface) is_satisfied = convergence_criterion_and.is_satisfied() self.assertFalse(is_satisfied) convergence_criterion_and.update(interface) is_satisfied = convergence_criterion_and.is_satisfied() self.assertFalse(is_satisfied) convergence_criterion_and.update(interface) is_satisfied = convergence_criterion_and.is_satisfied() self.assertFalse(is_satisfied) convergence_criterion_and.update(interface) is_satisfied = convergence_criterion_and.is_satisfied() self.assertTrue(is_satisfied) convergence_criterion_and.update(interface) is_satisfied = convergence_criterion_and.is_satisfied() self.assertTrue(is_satisfied) convergence_criterion_and.finalize_solution_step()
def test_initialize(self): mp_name_in = 'wall_in' mp_name_out_f = 'wall_out_f' mp_name_out_b = 'wall_out_b' n = 10 x, y, z = np.random.rand(n), np.random.rand(n), np.random.rand(n) model = data_structure.Model() model.create_model_part(mp_name_in, x, y, z, np.arange(n)) # model_part_from given mapper = create_instance(self.parameters) mapper.initialize(model, mp_name_in, mp_name_out_f, forward=True) mp_out = model.get_model_part(mp_name_out_f) coords_out = np.column_stack((mp_out.x0, mp_out.y0, mp_out.z0)) np.testing.assert_array_equal(coords_out, np.column_stack((z, x, y))) # model_part_to given mapper = create_instance(self.parameters) mapper.initialize(model, mp_name_in, mp_name_out_b, forward=False) mp_out = model.get_model_part(mp_name_out_b) coords_out = np.column_stack((mp_out.x0, mp_out.y0, mp_out.z0)) np.testing.assert_array_equal(coords_out, np.column_stack((y, z, x)))
def test_check_duplicate_points(self): self.parameters['settings']['directions'] = ['x', 'y', 'z'] mapper = create_instance(self.parameters) model = data_structure.Model() coords = np.array([[0, 0, 0], [1, 0, 0]]) mp_to = model.create_model_part('mp_to_1', *split(coords), np.arange(2)) coords = np.vstack((coords, np.array([[1e-10, 0., 0.]]))) mp_from = model.create_model_part('mp_from_1', *split(coords), np.arange(3)) self.assertRaises(Warning, mapper.initialize, *(mp_from, mp_to)) mapper.finalize() coords = np.vstack((coords, np.array([[1e-14, 0., 0.]]))) mp_from = model.create_model_part('mp_from_2', *split(coords), np.arange(4)) self.assertRaises(ValueError, mapper.initialize, *(mp_from, mp_to)) mapper.finalize()
def test_mapper_combined(self): parameter_file_name = os.path.join(os.path.dirname(__file__), 'test_combined.json') with open(parameter_file_name, 'r') as parameter_file: parameters = json.load(parameter_file) # compare 3 mappers: nearest, combined_a, combined_b for var in ['pressure', 'displacement']: mp_name_from = 'wall_from' mp_name_to = 'wall_to' model = data_structure.Model() n = 100 tmp = np.linspace(0, 1, n) x, y, z = tmp, tmp**1.1, tmp**1.2 v_from = np.random.rand(n, data_structure.variables_dimensions[var]) mp_from = model.create_model_part(mp_name_from, x, y, z, np.arange(n)) mp_to = model.create_model_part(mp_name_to, np.flip(x), np.flip(y), np.flip(z), np.arange(n)) parameters_from = [{ 'model_part': mp_name_from, 'variables': [var] }] int_from = data_structure.Interface(parameters_from, model) int_from.set_variable_data(mp_name_from, var, v_from) parameters_to = [{'model_part': mp_name_to, 'variables': [var]}] int_to = data_structure.Interface(parameters_to, model) # create mappers, get output data data = [] for mapper_name in [ 'mapper_nearest', 'mapper_combined_a', 'mapper_combined_b' ]: mapper = create_instance(parameters[mapper_name]) mapper.initialize(mp_from, mp_to) mapper((int_from, mp_name_from, var), (int_to, mp_name_to, var)) data.append(int_to.get_variable_data(mp_name_to, var)) # check output data np.testing.assert_array_equal(data[0], data[1]) np.testing.assert_array_equal(data[0], data[2])
def test_initialize(self): mp_name_in = 'wall_in' mp_name_out = 'wall_out' # create model_part_in n_in = 10 x_in = np.linspace(0, 2 * np.pi, n_in) y_in = 1. + 0.2 * np.sin(x_in) z_in = np.zeros(10) model = data_structure.Model() model.create_model_part(mp_name_in, x_in, y_in, z_in, np.arange(n_in)) # create reference geometry for 3D model_part_out n_t = self.parameters['settings']['n_tangential'] n_out_ref = n_in * n_t x_out_ref = np.zeros(n_out_ref) y_out_ref = np.zeros(n_out_ref) z_out_ref = np.zeros(n_out_ref) for i_t in range(n_t): for i_from in range(n_in): start = i_t * n_in end = (i_t + 1) * n_in theta = i_t * 2 * np.pi / n_t x_out_ref[start:end] = x_in y_out_ref[start:end] = np.cos(theta) * y_in z_out_ref[start:end] = np.sin(theta) * y_in # initialize mapper to get model_part_out mapper = create_instance(self.parameters) mapper.initialize(model, mp_name_in, mp_name_out, forward=False) # get mapped geometry from 3D model_part_out mp_out = model.get_model_part(mp_name_out) n_out = mp_out.size x_out = mp_out.x0 y_out = mp_out.y0 z_out = mp_out.z0 # compare mapped and reference geometries self.assertEqual(n_out, n_out_ref) np.testing.assert_array_equal(x_out, x_out_ref) np.testing.assert_array_equal(y_out, y_out_ref) np.testing.assert_array_equal(z_out, z_out_ref)
def map(self, parameters): mapper = create_instance(parameters) mapper.initialize(self.model.get_model_part(self.mp_name_from), self.model.get_model_part(self.mp_name_to)) args_from = (self.interface_from, self.mp_name_from, self.var) args_to = (self.interface_to, self.mp_name_to, self.var) mapper(args_from, args_to) self.v_to_fun = self.fun(self.x_to, self.y_to, self.z_to) tmp = self.interface_to.get_variable_data(self.mp_name_to, self.var) shape_to = self.v_to_fun[0].shape self.v_to = [tmp[:, 0].reshape(shape_to), tmp[:, 1].reshape(shape_to), tmp[:, 2].reshape(shape_to)] self.v_error = [] for j in range(3): self.v_error.append(np.abs(self.v_to[j] - self.v_to_fun[j]))
def test_partitioning(self): # test if different partitioning gives the same ModelParts # create two solvers with different partitioning x0, y0, z0, ids = [], [], [], [] for cores in [0, 1]: self.parameters['settings']['cores'] = cores solver = create_instance(self.parameters) solver.initialize() solver.finalize() mp = solver.model.get_model_part(self.mp_name_in) x0.append(mp.x0) y0.append(mp.y0) z0.append(mp.z0) ids.append(mp.id) # compare ModelParts of both solvers for attr in [x0, y0, z0, ids]: np.testing.assert_array_equal(attr[0], attr[1])
def __init__(self, parameters): super().__init__() self.parameters = parameters self.settings = parameters["settings"] # create solvers for sol_wrapper_param in self.settings["solver_wrappers"]: tools.pass_on_parameters(self.settings, sol_wrapper_param["settings"], ["timestep_start", "delta_t"]) nr_mapped_sol_wrappers = 0 for index, sol_wrapper_param in enumerate( self.settings["solver_wrappers"]): if sol_wrapper_param["type"] == "solver_wrappers.mapped": nr_mapped_sol_wrappers += 1 else: self.master_sol_index = index nr_sol_wrappers = len(self.settings["solver_wrappers"]) if not nr_mapped_sol_wrappers == nr_sol_wrappers - 1: raise RuntimeError( f'Required number of mapped solver wrappers: {nr_sol_wrappers - 1}, ' f'but {nr_mapped_sol_wrappers} is provided.') self.solver_wrapper_list = [] for sol_wrapper_param in self.settings["solver_wrappers"]: self.solver_wrapper_list.append(create_instance(sol_wrapper_param)) self.mapped_solver_wrapper_list = [] for index, sol_wrapper in enumerate(self.solver_wrapper_list): if not index == self.master_sol_index: self.mapped_solver_wrapper_list.append(sol_wrapper) self.master_solver_wrapper = self.solver_wrapper_list[ self.master_sol_index] self.interface_output = None # run time self.run_time = 0.0
def test_restart(self): # test if restart option works correctly # adapt parameters, create solver self.parameters['settings']['cores'] = 1 self.parameters['settings']['flow_iterations'] = 30 solver = create_instance(self.parameters) solver.initialize() interface_input = solver.get_interface_input() # set displacement model_part = interface_input.get_model_part(self.mp_name_in) x0, y0, z0 = model_part.x0, model_part.y0, model_part.z0 dy, dz = self.get_dy_dz(x0, y0, z0) displacement = interface_input.get_variable_data( self.mp_name_in, 'displacement') displacement[:, 1] = dy displacement[:, 2] = dz # run solver for 4 timesteps for i in range(4): solver.initialize_solution_step() interface_input.set_variable_data(self.mp_name_in, 'displacement', i * displacement) solver.solve_solution_step(interface_input) solver.finalize_solution_step() interface_x_1 = solver.get_interface_input() interface_y_1 = solver.get_interface_output() coords_1 = solver.get_coordinates()[self.mp_name_in]['coords'] solver.finalize() # get data for solver without restart interface_output = solver.get_interface_output() pressure_1 = interface_output.get_variable_data( self.mp_name_out, 'pressure') traction_1 = interface_output.get_variable_data( self.mp_name_out, 'traction') # create solver which restarts at timestep 2 self.parameters['settings']['timestep_start'] = 2 solver = create_instance(self.parameters) solver.initialize() interface_input = solver.get_interface_input() # run solver for 2 more timesteps for i in range(2, 4): solver.initialize_solution_step() interface_input.set_variable_data(self.mp_name_in, 'displacement', i * displacement) solver.solve_solution_step(interface_input) solver.finalize_solution_step() interface_x_2 = solver.get_interface_input() interface_y_2 = solver.get_interface_output() coords_2 = solver.get_coordinates()[self.mp_name_in]['coords'] solver.finalize() # get data for solver with restart interface_output = solver.get_interface_output() pressure_2 = interface_output.get_variable_data( self.mp_name_out, 'pressure') traction_2 = interface_output.get_variable_data( self.mp_name_out, 'traction') # check if undeformed coordinate (coordinates of model part) are equal self.assertTrue(interface_x_1.has_same_model_parts(interface_x_2)) self.assertTrue(interface_y_1.has_same_model_parts(interface_y_2)) # check if coordinates of ModelParts are equal # ==> check if deformed coordinates are equal np.testing.assert_allclose(coords_1, coords_2, rtol=1e-15) # check if pressure and traction are equal np.testing.assert_allclose(pressure_1, pressure_2, rtol=1e-14) np.testing.assert_allclose(traction_1, traction_2, rtol=1e-14)