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)
