def test_GetSetModelPartData(self): settings_scal = KM.Parameters("""{ "model_part_name" : "mp_4_test", "location" : "model_part", "variable_name" : "NODAL_MASS" }""") settings_vec = KM.Parameters("""{ "model_part_name" : "mp_4_test", "variable_name" : "TORQUE", "location" : "model_part", "dimension" : 1 }""") self.mp.ProcessInfo[KM.DOMAIN_SIZE] = 1 coupling_data_scal = CouplingInterfaceData(settings_scal, self.model) coupling_data_vec = CouplingInterfaceData(settings_vec, self.model) coupling_data_scal.Initialize() coupling_data_vec.Initialize() # 1. check the initial values self.__CheckData([model_part_scalar_value], coupling_data_scal.GetData()) self.__CheckData([model_part_vector_value[0]], coupling_data_vec.GetData()) # 2. check setting and getting works set_data_scal = [model_part_scalar_value_2] set_data_vec = [model_part_vector_value_2[0]] self.__CheckSetGetData(set_data_scal, coupling_data_scal) self.__CheckSetGetData(set_data_vec, coupling_data_vec)
def test_GetSetConditionalData(self): if using_pykratos: self.skipTest("This test cannot be run with pyKratos!") settings_scal = KM.Parameters("""{ "model_part_name" : "mp_4_test", "location" : "condition", "variable_name" : "YOUNG_MODULUS" }""") settings_vec = KM.Parameters("""{ "model_part_name" : "mp_4_test", "variable_name" : "ROTATION", "location" : "condition", "dimension" : 2 }""") coupling_data_scal = CouplingInterfaceData(settings_scal, self.model) coupling_data_vec = CouplingInterfaceData(settings_vec, self.model) coupling_data_scal.Initialize() coupling_data_vec.Initialize() # 1. check the initial values exp_data_scal = [ConditionScalarValue(cond.Id) for cond in self.mp.Conditions] exp_data_vec = GetVectorValues(self.mp.Conditions, ConditionVectorValue, 2) self.__CheckData(exp_data_scal, coupling_data_scal.GetData()) self.__CheckData(exp_data_vec, coupling_data_vec.GetData()) # 2. check setting and getting works set_data_scal = [NodeScalarHistValuePrevious(cond.Id) for cond in self.mp.Conditions] set_data_vec = GetVectorValues(self.mp.Conditions, NodeVectorHistValuePrevious, 2) self.__CheckSetGetData(set_data_scal, coupling_data_scal) self.__CheckSetGetData(set_data_vec, coupling_data_vec)
def test_GetSetNodalNonHistoricalData(self): settings_scal = KM.Parameters("""{ "model_part_name" : "mp_4_test", "location" : "node_non_historical", "variable_name" : "TEMPERATURE" }""") settings_vec = KM.Parameters("""{ "model_part_name" : "mp_4_test", "variable_name" : "VELOCITY", "location" : "node_non_historical", "dimension" : 3 }""") self.mp.ProcessInfo[KM.DOMAIN_SIZE] = 3 coupling_data_scal = CouplingInterfaceData(settings_scal, self.model) coupling_data_vec = CouplingInterfaceData(settings_vec, self.model) coupling_data_scal.Initialize() coupling_data_vec.Initialize() # 1. check the initial values exp_data_scal = [NodeScalarNonHistValue(node.Id) for node in self.mp.Nodes] exp_data_vec = GetVectorValues(self.mp.Nodes, NodeVectorNonHistValue, 3) self.__CheckData(exp_data_scal, coupling_data_scal.GetData()) self.__CheckData(exp_data_vec, coupling_data_vec.GetData()) # 2. check setting and getting works set_data_scal = [ConditionScalarValue(node.Id) for node in self.mp.Nodes] set_data_vec = GetVectorValues(self.mp.Nodes, ConditionVectorValue, 3) self.__CheckSetGetData(set_data_scal, coupling_data_scal) self.__CheckSetGetData(set_data_vec, coupling_data_vec)
def test_GetSetElementalData(self): settings_scal = KM.Parameters("""{ "model_part_name" : "mp_4_test", "location" : "element", "variable_name" : "DENSITY" }""") settings_vec = KM.Parameters("""{ "model_part_name" : "mp_4_test", "variable_name" : "FORCE", "location" : "element", "dimension" : 2 }""") coupling_data_scal = CouplingInterfaceData(settings_scal, self.model) coupling_data_vec = CouplingInterfaceData(settings_vec, self.model) coupling_data_scal.Initialize() coupling_data_vec.Initialize() # 1. check the initial values exp_data_scal = [ElementScalarValue(elem.Id) for elem in self.mp.Elements] exp_data_vec = GetVectorValues(self.mp.Elements, ElementVectorValue, 2) self.__CheckData(exp_data_scal, coupling_data_scal.GetData()) self.__CheckData(exp_data_vec, coupling_data_vec.GetData()) # 2. check setting and getting works set_data_scal = [NodeScalarNonHistValue(elem.Id) for elem in self.mp.Elements] set_data_vec = GetVectorValues(self.mp.Elements, NodeVectorNonHistValue, 2) self.__CheckSetGetData(set_data_scal, coupling_data_scal) self.__CheckSetGetData(set_data_vec, coupling_data_vec)
def test_GetSetProcessInfoData(self): settings_scal = KM.Parameters("""{ "model_part_name" : "mp_4_test", "location" : "process_info", "variable_name" : "NODAL_ERROR" }""") settings_vec = KM.Parameters("""{ "model_part_name" : "mp_4_test", "variable_name" : "NORMAL", "location" : "process_info", "dimension" : 2 }""") coupling_data_scal = CouplingInterfaceData(settings_scal, self.model) coupling_data_vec = CouplingInterfaceData(settings_vec, self.model) coupling_data_scal.Initialize() coupling_data_vec.Initialize() # 1. check the initial values self.__CheckData([process_info_scalar_value], coupling_data_scal.GetData()) self.__CheckData( [process_info_vector_value[0], process_info_vector_value[1]], coupling_data_vec.GetData()) # 2. check setting and getting works set_data_scal = [model_part_scalar_value] set_data_vec = [model_part_vector_value[0], model_part_vector_value[1]] self.__CheckSetGetData(set_data_scal, coupling_data_scal) self.__CheckSetGetData(set_data_vec, coupling_data_vec)
def test_GetSetNodalHistoricalData(self): settings_scal = KM.Parameters("""{ "model_part_name" : "mp_4_test", "variable_name" : "PRESSURE" }""") settings_vec = KM.Parameters("""{ "model_part_name" : "mp_4_test", "variable_name" : "DISPLACEMENT", "dimension" : 2 }""") coupling_data_scal = CouplingInterfaceData(settings_scal, self.model) coupling_data_vec = CouplingInterfaceData(settings_vec, self.model) coupling_data_scal.Initialize() coupling_data_vec.Initialize() # 1. check the initial values exp_data_scal_cur = [ NodeScalarHistValueCurrent(node.Id) for node in self.mp.Nodes ] exp_data_scal_prev = [ NodeScalarHistValuePrevious(node.Id) for node in self.mp.Nodes ] exp_data_vec_cur = GetVectorValues(self.mp.Nodes, NodeVectorHistValueCurrent, 2) exp_data_vec_prev = GetVectorValues(self.mp.Nodes, NodeVectorHistValuePrevious, 2) self.__CheckData(exp_data_scal_cur, coupling_data_scal.GetData()) self.__CheckData(exp_data_vec_cur, coupling_data_vec.GetData()) self.__CheckData(exp_data_scal_prev, coupling_data_scal.GetData(1)) self.__CheckData(exp_data_vec_prev, coupling_data_vec.GetData(1)) # 2. check setting and getting works set_data_scal_cur = [ ElementScalarValue(node.Id) for node in self.mp.Nodes ] set_data_scal_prev = [ ConditionScalarValue(node.Id) for node in self.mp.Nodes ] set_data_vec_cur = GetVectorValues(self.mp.Nodes, ElementVectorValue, 2) set_data_vec_prev = GetVectorValues(self.mp.Nodes, ConditionVectorValue, 2) self.__CheckSetGetData(set_data_scal_cur, coupling_data_scal) self.__CheckSetGetData(set_data_vec_cur, coupling_data_vec) self.__CheckSetGetData(set_data_scal_prev, coupling_data_scal, 1) self.__CheckSetGetData(set_data_vec_prev, coupling_data_vec, 1)
def test_without_initialization(self): settings = KM.Parameters("""{ "model_part_name" : "mp_4_test", "variable_name" : "DISPLACEMENT", "dimension" : 2 }""") coupling_data = CouplingInterfaceData(settings, self.model) # coupling_data.Initialize() # intentially commented to raise error with self.assertRaisesRegex(Exception, ' can onyl be called after initializing the CouplingInterfaceData!'): self.assertMultiLineEqual(str(coupling_data), coupling_interface_data_str) with self.assertRaisesRegex(Exception, ' can onyl be called after initializing the CouplingInterfaceData!'): coupling_data.PrintInfo() with self.assertRaisesRegex(Exception, ' can onyl be called after initializing the CouplingInterfaceData!'): coupling_data.GetModelPart() with self.assertRaisesRegex(Exception, ' can onyl be called after initializing the CouplingInterfaceData!'): coupling_data.IsDistributed() with self.assertRaisesRegex(Exception, ' can onyl be called after initializing the CouplingInterfaceData!'): coupling_data.Size() with self.assertRaisesRegex(Exception, ' can onyl be called after initializing the CouplingInterfaceData!'): coupling_data.GetBufferSize() with self.assertRaisesRegex(Exception, ' can onyl be called after initializing the CouplingInterfaceData!'): coupling_data.GetData() with self.assertRaisesRegex(Exception, ' can onyl be called after initializing the CouplingInterfaceData!'): coupling_data.SetData([])
def test_inplace_mult(self): settings = KM.Parameters("""{ "model_part_name" : "mp_4_test", "variable_name" : "PRESSURE" }""") coupling_data = CouplingInterfaceData(settings, self.model) coupling_data.Initialize() factor = 1.55 data_init = coupling_data.GetData() coupling_data.InplaceMultiply(factor) data_mod = coupling_data.GetData() for v_old, v_new in zip(data_init, data_mod): self.assertAlmostEqual(v_old * factor, v_new)
class TestScalingOperation(KratosUnittest.TestCase): def setUp(self): self.model = KM.Model() self.model_part = self.model.CreateModelPart("default") self.model_part.AddNodalSolutionStepVariable(KM.PRESSURE) self.model_part.ProcessInfo[KM.TIME] = 0.0 self.model_part.ProcessInfo[KM.STEP] = 0 for i in range(5): new_node = self.model_part.CreateNewNode(i + 1, i * 0.1, 0.0, 0.0) new_node.SetSolutionStepValue(KM.PRESSURE, 0, i + 1.3) data_settings = KM.Parameters("""{ "model_part_name" : "default", "variable_name" : "PRESSURE" }""") self.interface_data = CouplingInterfaceData(data_settings, self.model) self.interface_data.Initialize() self.solver_wrappers = { "dummy_solver": DummySolverWrapper({"data_4_testing": self.interface_data}) } self.solver_process_info = KM.ProcessInfo() def test_constant_scaling(self): scaling_op_settings = KM.Parameters("""{ "type" : "scaling", "solver" : "dummy_solver", "data_name" : "data_4_testing", "scaling_factor" : 1.5, "echo_level" : 0 }""") scaling_op = coupling_operation_factory.CreateCouplingOperation( scaling_op_settings, self.solver_wrappers, self.solver_process_info) factors = [1.5] * 3 self.__ExecuteTest(scaling_op, factors) def test_constant_scaling_from_string(self): scaling_op_settings = KM.Parameters("""{ "type" : "scaling", "solver" : "dummy_solver", "data_name" : "data_4_testing", "scaling_factor" : "1.5", "echo_level" : 0 }""") scaling_op = coupling_operation_factory.CreateCouplingOperation( scaling_op_settings, self.solver_wrappers, self.solver_process_info) factors = [1.5] * 3 self.__ExecuteTest(scaling_op, factors) def test_variable_scaling_time(self): scaling_op_settings = KM.Parameters("""{ "type" : "scaling", "solver" : "dummy_solver", "data_name" : "data_4_testing", "scaling_factor" : "1.5*t", "echo_level" : 0 }""") scaling_op = coupling_operation_factory.CreateCouplingOperation( scaling_op_settings, self.solver_wrappers, self.solver_process_info) factors = [1.5 * 0.25, 1.5 * 0.5, 1.5 * 0.75] self.__ExecuteTest(scaling_op, factors) def test_variable_scaling_step(self): scaling_op_settings = KM.Parameters("""{ "type" : "scaling", "solver" : "dummy_solver", "data_name" : "data_4_testing", "scaling_factor" : "1.5*sqrt(step)*pi", "echo_level" : 0 }""") scaling_op = coupling_operation_factory.CreateCouplingOperation( scaling_op_settings, self.solver_wrappers, self.solver_process_info) factors = [ 1.5 * pi * sqrt(1), 1.5 * pi * sqrt(2), 1.5 * pi * sqrt(3), 1.5 * pi * sqrt(4), 1.5 * pi * sqrt(5) ] self.__ExecuteTest(scaling_op, factors) def test_scaling_in_interval(self): if using_pykratos: self.skipTest( "This test can only be run with pyKratos after the IntervalUtility is implemented!" ) scaling_op_settings = KM.Parameters("""{ "type" : "scaling", "solver" : "dummy_solver", "data_name" : "data_4_testing", "scaling_factor" : 1.22, "interval" : [0.0, 0.3] }""") scaling_op = coupling_operation_factory.CreateCouplingOperation( scaling_op_settings, self.solver_wrappers, self.solver_process_info) factors = [1.0] * 5 factors[0] = 1.22 self.__ExecuteTest(scaling_op, factors) def test_scaling_in_interval_2(self): if using_pykratos: self.skipTest( "This test can only be run with pyKratos after the IntervalUtility is implemented!" ) scaling_op_settings = KM.Parameters("""{ "type" : "scaling", "solver" : "dummy_solver", "data_name" : "data_4_testing", "scaling_factor" : 1.22, "interval" : [0.8, "End"] }""") scaling_op = coupling_operation_factory.CreateCouplingOperation( scaling_op_settings, self.solver_wrappers, self.solver_process_info) factors = [1.0] * 3 factors.extend([1.22] * 3) self.__ExecuteTest(scaling_op, factors) def __ExecuteTest(self, scaling_operation, factors): scaling_operation.Check() for fac in factors: self.model_part.ProcessInfo[KM.TIME] += 0.25 self.model_part.ProcessInfo[KM.STEP] += 1 old_data = self.interface_data.GetData() scaling_operation.Execute() new_data = self.interface_data.GetData() self.__CompareValues(old_data, new_data, fac) def __CompareValues(self, old_data, new_data, factor): for old_val, new_val in zip(old_data, new_data): self.assertAlmostEqual(old_val * factor, new_val)
class TestConvergenceCriteriaWrapper(KratosUnittest.TestCase): def setUp(self): self.model = KM.Model() self.model_part = self.model.CreateModelPart("default") self.model_part.AddNodalSolutionStepVariable(KM.PRESSURE) self.model_part.AddNodalSolutionStepVariable(KM.PARTITION_INDEX) self.dimension = 3 self.model_part.ProcessInfo[KM.DOMAIN_SIZE] = self.dimension self.my_pid = KM.DataCommunicator.GetDefault().Rank() self.num_nodes = self.my_pid % 5 + 3 # num_nodes in range (3 ... 7) if self.my_pid == 4: self.num_nodes = 0 # in order to emulate one partition not having local nodes for i in range(self.num_nodes): node = self.model_part.CreateNewNode( i, 0.1 * i, 0.0, 0.0 ) # this creates the same coords in different ranks, which does not matter for this test node.SetSolutionStepValue(KM.PARTITION_INDEX, self.my_pid) node.SetSolutionStepValue(KM.PRESSURE, uniform(-10, 50)) if KM.IsDistributedRun(): KratosMPI.ParallelFillCommunicator(self.model_part).Execute() data_settings = KM.Parameters("""{ "model_part_name" : "default", "variable_name" : "PRESSURE" }""") self.interface_data = CouplingInterfaceData(data_settings, self.model) self.interface_data.Initialize() self.dummy_solver_wrapper = DummySolverWrapper( {"data_4_testing": self.interface_data}) def test_wrapper(self): conv_acc_settings = KM.Parameters("""{ "type" : "relative_norm_previous_residual", "data_name" : "data_4_testing" }""") conv_crit_wrapper = ConvergenceCriteriaWrapper( conv_acc_settings, self.dummy_solver_wrapper) data_init = self.interface_data.GetData() conv_crit_mock = Mock() is_converged = True attrs = {'IsConverged.return_value': is_converged} conv_crit_mock.configure_mock(**attrs) conv_crit_wrapper.conv_crit = conv_crit_mock conv_crit_wrapper.InitializeSolutionStep() conv_crit_wrapper.InitializeNonLinearIteration() # setting new solution for computing the residual rand_data = [uniform(-10, 50) for _ in range(self.num_nodes)] self.interface_data.SetData(rand_data) exp_res = rand_data - data_init self.assertEqual(conv_crit_wrapper.IsConverged(), is_converged) self.assertEqual( conv_crit_mock.IsConverged.call_count, int(self.my_pid == 0)) # only one rank calls "IsConverged" global_exp_res = np.array( np.concatenate(KM.DataCommunicator.GetDefault().GathervDoubles( exp_res, 0))) global_rand_data_inp = np.array( np.concatenate(KM.DataCommunicator.GetDefault().GathervDoubles( rand_data, 0))) if self.my_pid == 0: # numpy arrays cannot be compared using the mock-functions, hence using the numpy functions np.testing.assert_array_equal( global_exp_res, conv_crit_mock.IsConverged.call_args[0][0]) np.testing.assert_array_equal( global_rand_data_inp, conv_crit_mock.IsConverged.call_args[0][1])
def test_elemental_to_nodal_conversion(self): self.model = KM.Model() self.model_part = self.model.CreateModelPart("default") self.model_part.AddNodalSolutionStepVariable(KM.FORCE) self.model_part.ProcessInfo[KM.DOMAIN_SIZE] = 3 props = self.model_part.CreateNewProperties(1) self.model_part.CreateNewNode(1, 0.0, 0.0, 0.0) self.model_part.CreateNewNode(2, 1.0, 0.0, 0.0) self.model_part.CreateNewNode(3, 1.0, 1.0, 0.0) self.model_part.CreateNewNode(4, 0.0, 1.0, 0.0) new_element = self.model_part.CreateNewElement("Element2D4N", 1, [1, 2, 3, 4], props) new_element.SetValue(KM.FORCE, [12.0, 8.0, 0.0]) self.model_part.CreateNewNode(5, 2.0, 0.0, 0.0) self.model_part.CreateNewNode(6, 2.0, 1.0, 0.0) new_element = self.model_part.CreateNewElement("Element2D4N", 2, [2, 5, 6, 3], props) new_element.SetValue(KM.FORCE, [16.0, 4.0, 0.0]) elemental_data = KM.Parameters("""{ "model_part_name" : "default", "location" : "element", "variable_name" : "FORCE", "dimension" : 3 }""") self.interface_data = CouplingInterfaceData(elemental_data, self.model) self.solver_wrappers = { "dummy_solver": DummySolverWrapper({"elemental_data": self.interface_data}) } self.solver_process_info = KM.ProcessInfo() conversion_op_settings = KM.Parameters("""{ "type" : "elemental_data_to_nodal_data", "solver" : "dummy_solver", "data_name" : "elemental_data", "echo_level" : 0 }""") conversion_operation = coupling_operation_factory.CreateCouplingOperation( conversion_op_settings, self.solver_wrappers, self.solver_process_info) conversion_operation.Check() conversion_operation.Execute() nodal_data_output_setting = KM.Parameters("""{ "model_part_name" : "default", "variable_name" : "FORCE", "location" : "node_historical", "dimension" : 3 }""") nodal_data_output = CouplingInterfaceData(nodal_data_output_setting, self.model) expected_nodal_values = [ 3, 2, 0, 7, 3, 0, 7, 3, 0, 3, 2, 0, 4, 1, 0, 4, 1, 0 ] self.assertVectorAlmostEqual(expected_nodal_values, nodal_data_output.GetData())
class TestConvergenceAcceleratorWrapper(KratosUnittest.TestCase): def setUp(self): self.model = KM.Model() self.model_part = self.model.CreateModelPart("default") self.model_part.AddNodalSolutionStepVariable(KM.PRESSURE) self.model_part.AddNodalSolutionStepVariable(KM.PARTITION_INDEX) self.dimension = 3 self.model_part.ProcessInfo[KM.DOMAIN_SIZE] = self.dimension self.my_pid = KM.DataCommunicator.GetDefault().Rank() self.num_nodes = self.my_pid % 5 + 3 # num_nodes in range (3 ... 7) if self.my_pid == 4: self.num_nodes = 0 # in order to emulate one partition not having local nodes for i in range(self.num_nodes): node = self.model_part.CreateNewNode( i, 0.1 * i, 0.0, 0.0 ) # this creates the same coords in different ranks, which does not matter for this test node.SetSolutionStepValue(KM.PARTITION_INDEX, self.my_pid) node.SetSolutionStepValue(KM.PRESSURE, uniform(-10, 50)) if KM.IsDistributedRun(): KratosMPI.ParallelFillCommunicator(self.model_part).Execute() data_settings = KM.Parameters("""{ "model_part_name" : "default", "variable_name" : "PRESSURE" }""") self.interface_data = CouplingInterfaceData(data_settings, self.model) self.interface_data.Initialize() self.dummy_solver_wrapper = DummySolverWrapper( {"data_4_testing": self.interface_data}) def test_accelerator_without_support_for_distributed_data(self): conv_acc_settings = KM.Parameters("""{ "type" : "constant_relaxation", "data_name" : "data_4_testing" }""") conv_acc_wrapper = ConvergenceAcceleratorWrapper( conv_acc_settings, self.dummy_solver_wrapper) exp_inp = self.interface_data.GetData() update_solution_return_value = [ uniform(-10, 50) for _ in range(self.num_nodes) ] global_update_solution_return_value = np.array( np.concatenate(KM.DataCommunicator.GetDefault().GathervDoubles( update_solution_return_value, 0))) conv_acc_mock = Mock() attrs = { 'SupportsDistributedData.return_value': False, 'UpdateSolution.return_value': global_update_solution_return_value } conv_acc_mock.configure_mock(**attrs) conv_acc_wrapper.conv_acc = conv_acc_mock conv_acc_wrapper.InitializeSolutionStep() self.assertEqual(conv_acc_mock.SupportsDistributedData.call_count, 1) self.assertEqual( conv_acc_wrapper.gather_scatter_required, self.interface_data.IsDistributed( )) # gather-scatter is only required in case of distributed data self.assertEqual(conv_acc_wrapper.executing_rank, self.my_pid == 0) conv_acc_wrapper.InitializeNonLinearIteration() # setting new solution for computing the residual rand_data = [uniform(-10, 50) for _ in range(self.num_nodes)] self.interface_data.SetData(rand_data) exp_res = rand_data - exp_inp conv_acc_wrapper.ComputeAndApplyUpdate() self.assertEqual( conv_acc_mock.UpdateSolution.call_count, int(self.my_pid == 0)) # only one rank calls "UpdateSolution" global_exp_res = np.array( np.concatenate(KM.DataCommunicator.GetDefault().GathervDoubles( exp_res, 0))) global_exp_inp = np.array( np.concatenate(KM.DataCommunicator.GetDefault().GathervDoubles( exp_inp, 0))) if self.my_pid == 0: # numpy arrays cannot be compared using the mock-functions, hence using the numpy functions np.testing.assert_array_equal( global_exp_res, conv_acc_mock.UpdateSolution.call_args[0][0]) np.testing.assert_array_equal( global_exp_inp, conv_acc_mock.UpdateSolution.call_args[0][1]) np.testing.assert_array_equal(exp_inp + update_solution_return_value, self.interface_data.GetData()) def test_accelerator_with_support_for_distributed_data(self): conv_acc_settings = KM.Parameters("""{ "type" : "constant_relaxation", "data_name" : "data_4_testing" }""") conv_acc_wrapper = ConvergenceAcceleratorWrapper( conv_acc_settings, self.dummy_solver_wrapper) exp_inp = self.interface_data.GetData() update_solution_return_value = [ uniform(-10, 50) for _ in range(self.num_nodes) ] conv_acc_mock = Mock() attrs = { 'SupportsDistributedData.return_value': True, 'UpdateSolution.return_value': update_solution_return_value } conv_acc_mock.configure_mock(**attrs) conv_acc_wrapper.conv_acc = conv_acc_mock conv_acc_wrapper.InitializeSolutionStep() self.assertEqual(conv_acc_mock.SupportsDistributedData.call_count, 1) self.assertFalse(conv_acc_wrapper.gather_scatter_required) self.assertTrue(conv_acc_wrapper.executing_rank) conv_acc_wrapper.InitializeNonLinearIteration() # setting new solution for computing the residual rand_data = [uniform(-10, 50) for _ in range(self.num_nodes)] self.interface_data.SetData(rand_data) exp_res = rand_data - exp_inp conv_acc_wrapper.ComputeAndApplyUpdate() self.assertEqual(conv_acc_mock.UpdateSolution.call_count, 1) # numpy arrays cannot be compared using the mock-functions, hence using the numpy functions np.testing.assert_array_equal( exp_res, conv_acc_mock.UpdateSolution.call_args[0][0]) np.testing.assert_array_equal( exp_inp, conv_acc_mock.UpdateSolution.call_args[0][1]) np.testing.assert_array_equal(exp_inp + update_solution_return_value, self.interface_data.GetData())