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_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_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_basics(self):
settings_scal_hist = KM.Parameters("""{
"model_part_name" : "mp_4_test",
"variable_name" : "PRESSURE"
}""")
settings_vec_elem = KM.Parameters("""{
"model_part_name" : "mp_4_test",
"variable_name" : "DISPLACEMENT",
"location" : "element",
"dimension" : 2
}""")
coupling_data_scal = CouplingInterfaceData(settings_scal_hist,
self.model)
coupling_data_scal.Initialize()
coupling_data_vec = CouplingInterfaceData(settings_vec_elem,
self.model)
coupling_data_vec.Initialize()
self.assertEqual(coupling_data_scal.GetModelPart().Name, "mp_4_test")
self.assertEqual(coupling_data_vec.GetModelPart().Name, "mp_4_test")
self.assertFalse(coupling_data_scal.GetModelPart().IsDistributed())
self.assertFalse(coupling_data_vec.GetModelPart().IsDistributed())
self.assertEqual(coupling_data_scal.Size(),
5) # 5 nodes and scalar var
self.assertEqual(coupling_data_vec.Size(),
14) # 7 elements and vector var with dim==2
self.assertEqual(coupling_data_scal.GetBufferSize(), 2)
self.assertEqual(coupling_data_vec.GetBufferSize(), 1)
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_wrong_input_set_data(self):
settings = KM.Parameters("""{
"model_part_name" : "mp_4_test",
"variable_name" : "PRESSURE"
}""")
settings_model_part = KM.Parameters("""{
"model_part_name" : "mp_4_test",
"variable_name" : "PRESSURE",
"location" : "model_part"
}""")
coupling_data = CouplingInterfaceData(settings, self.model)
coupling_data.Initialize()
coupling_data_mp = CouplingInterfaceData(settings_model_part, self.model)
coupling_data_mp.Initialize()
wrong_data = [1,2,3]
correct_data = [1,2,3,4,5]
with self.assertRaisesRegex(Exception, "The sizes of the data are not matching, got: 3, expected: 5"):
coupling_data.SetData(wrong_data)
with self.assertRaisesRegex(Exception, "The buffer-size is not large enough: current buffer size: 2 | requested solution_step_index: 3"):
coupling_data.SetData(correct_data, 2)
with self.assertRaisesRegex(Exception, "accessing data from previous steps is only possible with historical nodal data!"):
coupling_data_mp.SetData(correct_data, 2)
def test_Export_ImportCouplingData(self):
p = self.__RunPythonInSubProcess("import_export_data")
model = KM.Model()
io_settings = KM.Parameters("""{
"connect_to" : "impExp"
}""")
solver_name = "ExpImp" # aka "my_name" for the CoSimIO
kratos_co_sim_io = CreateKratosCoSimIO(io_settings, model,
solver_name) # this connects
kratos_co_sim_io.Initialize()
model_part = model.CreateModelPart("for_test")
model_part.AddNodalSolutionStepVariable(KM.PRESSURE)
model_part.AddNodalSolutionStepVariable(KM.TEMPERATURE)
for i in range(5):
node = model_part.CreateNewNode(
i + 1, 0.0, 0.0,
0.0) # using same coord, doesn't matter for this test
node.SetSolutionStepValue(KM.PRESSURE, i * 1.7)
settings_pres = KM.Parameters("""{
"model_part_name" : "for_test",
"variable_name" : "PRESSURE"
}""")
settings_temp = KM.Parameters("""{
"model_part_name" : "for_test",
"variable_name" : "TEMPERATURE"
}""")
interface_data_pres = CouplingInterfaceData(settings_pres, model,
"data_exchange_1")
interface_data_temp = CouplingInterfaceData(settings_temp, model,
"data_exchange_2")
interface_data_pres.Initialize()
interface_data_temp.Initialize()
data_configuration_export = {
"type": "coupling_interface_data",
"interface_data": interface_data_pres
}
kratos_co_sim_io.ExportData(data_configuration_export)
data_configuration_import = {
"type": "coupling_interface_data",
"interface_data": interface_data_temp
}
kratos_co_sim_io.ImportData(data_configuration_import)
kratos_co_sim_io.Finalize() # this disconnects
# checking the values after disconnecting to avoid deadlock
for i, node in enumerate(model_part.Nodes):
self.assertAlmostEqual(node.GetSolutionStepValue(KM.TEMPERATURE),
i * 1.7)
self.__CheckSubProcess(p)
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_wrong_input_no_dim_vector(self):
settings = KM.Parameters("""{
"model_part_name" : "mp_4_test",
"variable_name" : "DISPLACEMENT"
}""")
coupling_data = CouplingInterfaceData(settings, self.model)
with self.assertRaisesRegex(Exception, '"dimension" has to be specifed for vector variables!'):
coupling_data.Initialize()
def test_printing(self):
settings = KM.Parameters("""{
"model_part_name" : "mp_4_test",
"variable_name" : "DISPLACEMENT",
"dimension" : 2
}""")
coupling_data = CouplingInterfaceData(settings, self.model)
coupling_data.Initialize()
self.assertMultiLineEqual(str(coupling_data), coupling_interface_data_str)
def test_non_existing_model_part(self):
settings = KM.Parameters("""{
"model_part_name" : "something",
"variable_name" : "PRESSURE",
"location" : "node_non_historical"
}""")
coupling_data = CouplingInterfaceData(settings, self.model)
with self.assertRaisesRegex(Exception, "The specified ModelPart is not in the Model, only the following ModelParts are available:"):
coupling_data.Initialize()
def test_wrong_input_dim_scalar(self):
settings = KM.Parameters("""{
"model_part_name" : "mp_4_test",
"variable_name" : "PRESSURE",
"dimension" : 2
}""")
coupling_data = CouplingInterfaceData(settings, self.model)
with self.assertRaisesRegex(Exception, '"dimension" cannot be specifed for scalar variables!'):
coupling_data.Initialize()
def test_wrong_input_variable_type(self):
settings = KM.Parameters("""{
"model_part_name" : "mp_4_test",
"variable_name" : "EXTERNAL_FORCES_VECTOR"
}""")
exp_error = 'The input for "variable" "EXTERNAL_FORCES_VECTOR" is of variable type "Vector" which is not allowed, only the following variable types are allowed:\nBool, Integer, Unsigned Integer, Double, Component, Array'
coupling_data = CouplingInterfaceData(settings, self.model)
with self.assertRaisesRegex(Exception, exp_error):
coupling_data.Initialize()
def test_wrong_input_missing_solutionstepvar_double(self):
settings = KM.Parameters("""{
"model_part_name" : "mp_4_test",
"variable_name" : "TEMPERATURE"
}""")
exp_error = '"TEMPERATURE" is missing as SolutionStepVariable in ModelPart "mp_4_test"'
coupling_data = CouplingInterfaceData(settings, self.model)
with self.assertRaisesRegex(Exception, exp_error):
coupling_data.Initialize()
def test_wrong_input_location(self):
settings = KM.Parameters("""{
"model_part_name" : "mp_4_test",
"variable_name" : "PRESSURE",
"location" : "dummy"
}""")
exp_error = '"dummy" is not allowed as "location", only the following options are possible:\nnode_historical, node_non_historical, element, condition, process_info, model_part'
coupling_data = CouplingInterfaceData(settings, self.model)
with self.assertRaisesRegex(Exception, exp_error):
coupling_data.Initialize()
def test_wrong_input_dim_array(self):
settings = KM.Parameters("""{
"model_part_name" : "mp_4_test",
"variable_name" : "DISPLACEMENT",
"dimension" : 4
}""")
exp_error = '"dimension" can only be 1,2,3 when using variables of type "Array"'
coupling_data = CouplingInterfaceData(settings, self.model)
with self.assertRaisesRegex(Exception, exp_error):
coupling_data.Initialize()
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 TestConvergenceCriteria(KratosUnittest.TestCase):
def setUp(self):
self.model = KM.Model()
self.model_part = self.model.CreateModelPart("default")
self.model_part.AddNodalSolutionStepVariable(KM.PRESSURE)
for i in range(
10): # using 10 nodes gives suitable values in the tests
node = self.model_part.CreateNewNode(
i + 1, 0.0, 0.0,
0.0) # position of nodes does not matter for this test
node.SetSolutionStepValue(KM.PRESSURE, 1.0)
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_RelativeNormInitialResidual_abs_tol(self):
conv_crit_settings = KM.Parameters("""{
"type" : "relative_norm_initial_residual",
"data_name" : "data_4_testing",
"abs_tolerance" : 1e-5,
"rel_tolerance" : 1e-12,
"echo_level" : 0
}""")
conv_crit = ConvergenceCriteriaWrapper(conv_crit_settings,
self.dummy_solver_wrapper)
sol_values = [(2e-1, False), (2e-4, False), (2e-6, False),
(2e-7, True), (2e-8, True), (2e-9, True), (2e-4, False),
(2e-6, False), (2e-7, True)]
self.__ExecuteTest(conv_crit, sol_values)
def test_RelativeNormInitialResidual_rel_tol(self):
conv_crit_settings = KM.Parameters("""{
"type" : "relative_norm_initial_residual",
"data_name" : "data_4_testing",
"abs_tolerance" : 1e-12,
"rel_tolerance" : 1e-5,
"echo_level" : 0
}""")
conv_crit = ConvergenceCriteriaWrapper(conv_crit_settings,
self.dummy_solver_wrapper)
sol_values = [
(2e-1, False),
(2e-2, False),
(2e-3, False),
(2e-4, False),
(2e-5, False),
(2e-6, False),
(1e-6, True),
(1e-7, True),
(2e-5, False),
(2e-6, False),
(1e-6, True),
]
self.__ExecuteTest(conv_crit, sol_values)
def test_RelativeNormPreviousResidual_abs_tol(self):
conv_crit_settings = KM.Parameters("""{
"type" : "relative_norm_previous_residual",
"data_name" : "data_4_testing",
"abs_tolerance" : 1e-5,
"rel_tolerance" : 1e-12,
"echo_level" : 0
}""")
conv_crit = ConvergenceCriteriaWrapper(conv_crit_settings,
self.dummy_solver_wrapper)
sol_values = [(2e-1, False), (2e-4, False), (2e-6, False),
(2e-7, True), (2e-8, True), (2e-9, True), (2e-4, False),
(2e-6, False), (2e-7, True)]
self.__ExecuteTest(conv_crit, sol_values)
def test_RelativeNormPreviousResidual_rel_tol(self):
conv_crit_settings = KM.Parameters("""{
"type" : "relative_norm_previous_residual",
"data_name" : "data_4_testing",
"abs_tolerance" : 1e-12,
"rel_tolerance" : 1e-5,
"echo_level" : 0
}""")
conv_crit = ConvergenceCriteriaWrapper(conv_crit_settings,
self.dummy_solver_wrapper)
sol_values = [
(2e-1, False),
(2e-2, False),
(2.00001e-2,
True), # small change in the values leads to convergence
(2e-4, False),
(8e-6, False),
(7e-6, False),
(7.00001e-6, True
) # small change in the values leads to convergence
]
self.__ExecuteTest(conv_crit, sol_values)
def __ExecuteTest(self, conv_crit, solution_values):
conv_crit.Initialize()
conv_crit.Check() # not yet implemented
conv_crit.InitializeSolutionStep()
for vals_tuple in solution_values:
conv_crit.InitializeNonLinearIteration()
KM.VariableUtils().SetScalarVar(KM.PRESSURE, vals_tuple[0],
self.model_part.Nodes)
self.assertEqual(vals_tuple[1], conv_crit.IsConverged())
conv_crit.FinalizeNonLinearIteration()
conv_crit.FinalizeSolutionStep()
conv_crit.Finalize()
class TestDataTransferOperators(KratosUnittest.TestCase):
def setUp(self):
self.model = KM.Model()
mp_o = self.model.CreateModelPart("mp_origin", 2)
mp_d_m = self.model.CreateModelPart("mp_destination_matching", 2)
mp_d_nm = self.model.CreateModelPart("mp_destination_non_matching", 2)
mp_one_n = self.model.CreateModelPart("mp_single_node", 2)
mp_o.AddNodalSolutionStepVariable(KM.PRESSURE)
mp_o.AddNodalSolutionStepVariable(KM.DISPLACEMENT)
mp_d_m.AddNodalSolutionStepVariable(KM.TEMPERATURE)
mp_d_m.AddNodalSolutionStepVariable(KM.FORCE)
mp_d_nm.AddNodalSolutionStepVariable(KM.TEMPERATURE)
mp_d_nm.AddNodalSolutionStepVariable(KM.FORCE)
mp_one_n.AddNodalSolutionStepVariable(KMC.SCALAR_DISPLACEMENT)
mp_one_n.AddNodalSolutionStepVariable(KMC.SCALAR_FORCE)
mp_o.ProcessInfo[KM.DOMAIN_SIZE] = 2
mp_d_m.ProcessInfo[KM.DOMAIN_SIZE] = 2
mp_d_nm.ProcessInfo[KM.DOMAIN_SIZE] = 2
mp_one_n.ProcessInfo[KM.DOMAIN_SIZE] = 2
num_nodes_matching = 5
num_nodes_non_matching = 8
for i in range(num_nodes_matching):
node_id = i + 1
node_o = mp_o.CreateNewNode(node_id, 0.0, 0.0, i + 1)
mp_d_m.CreateNewNode(node_id, 0.0, 0.0, i + 1)
node_o.SetSolutionStepValue(KM.PRESSURE, 0,
ScalarValueFromId(node_id))
node_o.SetSolutionStepValue(KM.DISPLACEMENT, 0,
VectorValueFromId(node_id))
for i in range(num_nodes_non_matching - 1, -1, -1):
node_id = i + 15
mp_d_nm.CreateNewNode(node_id, 0.0, 0.0, i + 1.1)
mp_one_n.CreateNewNode(1, 0.0, 0.0, 0.0)
origin_data_settings_scalar = KM.Parameters("""{
"model_part_name" : "mp_origin",
"variable_name" : "PRESSURE"
}""")
origin_data_settings_vector = KM.Parameters("""{
"model_part_name" : "mp_origin",
"variable_name" : "DISPLACEMENT",
"dimension" : 2
}""")
origin_data_settings_single_node = KM.Parameters("""{
"model_part_name" : "mp_single_node",
"variable_name" : "SCALAR_DISPLACEMENT"
}""")
self.origin_data_scalar = CouplingInterfaceData(
origin_data_settings_scalar, self.model)
self.origin_data_vector = CouplingInterfaceData(
origin_data_settings_vector, self.model)
self.origin_data_single_node = CouplingInterfaceData(
origin_data_settings_single_node, self.model)
self.origin_data_scalar.Initialize()
self.origin_data_vector.Initialize()
self.origin_data_single_node.Initialize()
destination_matching_data_settings_scalar = KM.Parameters("""{
"model_part_name" : "mp_destination_matching",
"variable_name" : "TEMPERATURE"
}""")
destination_matching_data_settings_vector = KM.Parameters("""{
"model_part_name" : "mp_destination_matching",
"variable_name" : "FORCE",
"dimension" : 2
}""")
destination_data_settings_single_node = KM.Parameters("""{
"model_part_name" : "mp_single_node",
"variable_name" : "SCALAR_FORCE"
}""")
self.destination_matching_data_scalar = CouplingInterfaceData(
destination_matching_data_settings_scalar, self.model)
self.destination_matching_data_vector = CouplingInterfaceData(
destination_matching_data_settings_vector, self.model)
self.destination_data_single_node = CouplingInterfaceData(
destination_data_settings_single_node, self.model)
self.destination_matching_data_scalar.Initialize()
self.destination_matching_data_vector.Initialize()
self.destination_data_single_node.Initialize()
destination_non_matching_data_settings_scalar = KM.Parameters("""{
"model_part_name" : "mp_destination_non_matching",
"variable_name" : "TEMPERATURE"
}""")
destination_non_matching_data_settings_vector = KM.Parameters("""{
"model_part_name" : "mp_destination_non_matching",
"variable_name" : "FORCE",
"dimension" : 2
}""")
self.destination_non_matching_data_scalar = CouplingInterfaceData(
destination_non_matching_data_settings_scalar, self.model)
self.destination_non_matching_data_vector = CouplingInterfaceData(
destination_non_matching_data_settings_vector, self.model)
self.destination_non_matching_data_scalar.Initialize()
self.destination_non_matching_data_vector.Initialize()
def test_copy_transfer_operator(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
self.__TestTransferMatching(data_transfer_op)
self.__TestTransferMatchingSwapSign(data_transfer_op)
self.__TestTransferMatchingAddValues(data_transfer_op)
self.__TestTransferMatchingAddValuesAndSwapSign(data_transfer_op)
transfer_options_empty = KM.Parameters(""" [] """)
exp_error = 'The sizes of the data are not matching: {} != {} for interface data "{}" of solver "{}" and interface data "{}" of solver "{}"!'.format(
self.origin_data_scalar.Size(),
self.destination_non_matching_data_scalar.Size(),
self.origin_data_scalar.name, self.origin_data_scalar.solver_name,
self.destination_non_matching_data_scalar.name,
self.destination_non_matching_data_scalar.solver_name)
with self.assertRaisesRegex(Exception, exp_error):
data_transfer_op.TransferData(
self.origin_data_scalar,
self.destination_non_matching_data_scalar,
transfer_options_empty)
def test_kratos_mapping_transfer_operator(self):
if not mapping_app_available:
self.skipTest("MappingApplication not available!")
data_transfer_op_settings_missing = KM.Parameters("""{
"type" : "kratos_mapping"
}""")
exp_error = 'No "mapper_settings" provided!'
with self.assertRaisesRegex(Exception, exp_error):
data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings_missing)
data_transfer_op_settings = KM.Parameters("""{
"type" : "kratos_mapping",
"mapper_settings" : {
"mapper_type" : "nearest_neighbor"
}
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
self.__TestTransferMatching(data_transfer_op)
self.__TestTransferMatchingSwapSign(data_transfer_op)
self.__TestTransferMatchingAddValues(data_transfer_op)
self.__TestTransferMatchingAddValuesAndSwapSign(data_transfer_op)
# with this we make sure that only one mapper is created (and not several ones for each mapping operation!)
# Hint: requires access to private member
self.assertEqual(
len(data_transfer_op._KratosMappingDataTransferOperator__mappers),
1)
self.__TestTransferMatchingInverse(data_transfer_op)
# here we check explicitly the InverseMap fct
self.assertEqual(
len(data_transfer_op._KratosMappingDataTransferOperator__mappers),
1)
transfer_options_empty = KM.Parameters(""" [] """)
data_transfer_op.TransferData(
self.origin_data_scalar, self.destination_non_matching_data_scalar,
transfer_options_empty)
# here we check explicitly the creation of a second mapper, which is required since the interfaces are not the same this time
self.assertEqual(
len(data_transfer_op._KratosMappingDataTransferOperator__mappers),
2)
data_settings_model_part = KM.Parameters("""{
"model_part_name" : "mp_single_node",
"variable_name" : "TEMPERATURE",
"location" : "model_part"
}""")
data_model_part = CouplingInterfaceData(data_settings_model_part,
self.model)
data_model_part.Initialize()
with self.assertRaisesRegex(
Exception,
'Currently only historical nodal values are supported'):
data_transfer_op.TransferData(self.origin_data_scalar,
data_model_part,
transfer_options_empty)
def test_copy_single_to_dist_transfer_operator(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy_single_to_distributed"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" [] """)
for node in self.origin_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_DISPLACEMENT, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, 1)
with self.assertRaisesRegex(
Exception,
'Interface data "default" of solver "default_solver" requires to be of size 1, got: 5'
):
data_transfer_op.TransferData(
self.origin_data_scalar, self.destination_matching_data_scalar,
transfer_options)
def test_copy_single_to_dist_transfer_operator_swap_sign(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy_single_to_distributed"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" ["swap_sign"] """)
for node in self.origin_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_DISPLACEMENT, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, -1)
def test_copy_single_to_dist_transfer_operator_distribute_values(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy_single_to_distributed"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" ["distribute_values"] """)
for node in self.origin_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_DISPLACEMENT, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, 0.2)
def test_copy_single_to_dist_transfer_operator_add_values(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy_single_to_distributed"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options_empty = KM.Parameters(""" [] """)
transfer_options_add = KM.Parameters(""" ["add_values"] """)
for node in self.origin_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_DISPLACEMENT, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options_empty)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, 1)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options_add)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, 2)
def test_copy_single_to_dist_transfer_operator_distribute_values_swap_sign(
self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy_single_to_distributed"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(
""" ["distribute_values", "swap_sign"] """)
for node in self.origin_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_DISPLACEMENT, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, -0.2)
def test_copy_single_to_dist_transfer_operator_distribute_values_swap_sign_add_values(
self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy_single_to_distributed"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(
""" ["distribute_values", "swap_sign"] """)
transfer_options_with_add_vals = KM.Parameters(
""" ["distribute_values", "swap_sign", "add_values"] """)
for node in self.origin_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_DISPLACEMENT, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, -0.2)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options_with_add_vals)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, -0.4)
def test_sum_dist_to_single(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "sum_distributed_to_single"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" [] """)
for node in self.origin_data_scalar.GetModelPart().Nodes:
node.SetSolutionStepValue(KM.PRESSURE, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_data_single_node,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_data_single_node.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KMC.SCALAR_FORCE,
KM.PRESSURE, 5)
with self.assertRaisesRegex(
Exception,
'Interface data "default" of solver "default_solver" requires to be of size 1, got: 5'
):
data_transfer_op.TransferData(
self.origin_data_scalar, self.destination_matching_data_scalar,
transfer_options)
def test_sum_dist_to_single_swap_sign(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "sum_distributed_to_single"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" ["swap_sign"] """)
for node in self.origin_data_scalar.GetModelPart().Nodes:
node.SetSolutionStepValue(KM.PRESSURE, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_data_single_node,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_data_single_node.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KMC.SCALAR_FORCE,
KM.PRESSURE, -5)
def test_sum_dist_to_single_add_values(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "sum_distributed_to_single"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" ["add_values"] """)
for node in self.origin_data_scalar.GetModelPart().Nodes:
node.SetSolutionStepValue(KM.PRESSURE, 0, 100.0)
for node in self.destination_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_FORCE, 0, 500.0)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_data_single_node,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_data_single_node.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KMC.SCALAR_FORCE,
KM.PRESSURE, 10.0)
def test_sum_dist_to_single_add_values_swap_sign(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "sum_distributed_to_single"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" ["add_values", "swap_sign"] """)
for node in self.origin_data_scalar.GetModelPart().Nodes:
node.SetSolutionStepValue(KM.PRESSURE, 0, 100.0)
for node in self.destination_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_FORCE, 0, 500.0)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_data_single_node,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_data_single_node.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KMC.SCALAR_FORCE,
KM.PRESSURE, 0.0)
def test_sum_dist_to_single_check_var(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "sum_distributed_to_single"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" [] """)
with self.assertRaisesRegex(
Exception,
'Variable of interface data "default" of solver "default_solver" has to be a scalar!'
):
data_transfer_op.TransferData(
self.destination_matching_data_vector,
self.destination_data_single_node, transfer_options)
def test_copy_single_to_dist_check_var(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy_single_to_distributed"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" [] """)
with self.assertRaisesRegex(
Exception,
'Variable of interface data "default" of solver "default_solver" has to be a scalar!'
):
data_transfer_op.TransferData(
self.destination_data_single_node,
self.destination_matching_data_vector, transfer_options)
def __TestTransferMatching(self, data_transfer_op):
transfer_options_empty = KM.Parameters(""" [] """)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_empty)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KM.TEMPERATURE,
KM.PRESSURE)
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_empty)
self.__CompareVectorNodalValues(
self.destination_matching_data_vector.GetModelPart().Nodes,
self.origin_data_vector.GetModelPart().Nodes, KM.FORCE,
KM.DISPLACEMENT, 2)
def __TestTransferMatchingInverse(self, data_transfer_op):
transfer_options_empty = KM.Parameters(""" [] """)
data_transfer_op.TransferData(self.destination_matching_data_scalar,
self.origin_data_scalar,
transfer_options_empty)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KM.TEMPERATURE,
KM.PRESSURE)
data_transfer_op.TransferData(self.destination_matching_data_vector,
self.origin_data_vector,
transfer_options_empty)
self.__CompareVectorNodalValues(
self.destination_matching_data_vector.GetModelPart().Nodes,
self.origin_data_vector.GetModelPart().Nodes, KM.FORCE,
KM.DISPLACEMENT, 2)
transfer_options_fail = KM.Parameters(
""" ["thisWillHopefullyNeverBeImplementedOtherWiseThisTestWillFail"] """
)
with self.assertRaisesRegex(Exception, ' not recognized for '):
data_transfer_op.TransferData(
self.origin_data_scalar, self.destination_matching_data_scalar,
transfer_options_fail)
def __TestTransferMatchingSwapSign(self, data_transfer_op):
transfer_options_swap_sign = KM.Parameters(""" ["swap_sign"] """)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_swap_sign)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KM.TEMPERATURE,
KM.PRESSURE, -1.0)
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_swap_sign)
self.__CompareVectorNodalValues(
self.destination_matching_data_vector.GetModelPart().Nodes,
self.origin_data_vector.GetModelPart().Nodes, KM.FORCE,
KM.DISPLACEMENT, 2, -1.0)
def __TestTransferMatchingAddValues(self, data_transfer_op):
transfer_options_empty = KM.Parameters(""" [] """)
transfer_options_add_values = KM.Parameters(""" ["add_values"] """)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_empty) # "resetting"
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_add_values)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KM.TEMPERATURE,
KM.PRESSURE, 2.0)
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_empty) # "resetting"
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_add_values)
self.__CompareVectorNodalValues(
self.destination_matching_data_vector.GetModelPart().Nodes,
self.origin_data_vector.GetModelPart().Nodes, KM.FORCE,
KM.DISPLACEMENT, 2, 2.0)
def __TestTransferMatchingAddValuesAndSwapSign(self, data_transfer_op):
transfer_options_empty = KM.Parameters(""" [] """)
transfer_options_add_values = KM.Parameters(""" ["add_values"] """)
transfer_options_add_values_swap_sign = KM.Parameters(
""" ["add_values", "swap_sign"] """)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_empty) # "resetting"
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_add_values)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_add_values)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_add_values_swap_sign)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KM.TEMPERATURE,
KM.PRESSURE, 2.0)
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_empty) # "resetting"
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_add_values)
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_add_values)
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_add_values_swap_sign)
self.__CompareVectorNodalValues(
self.destination_matching_data_vector.GetModelPart().Nodes,
self.origin_data_vector.GetModelPart().Nodes, KM.FORCE,
KM.DISPLACEMENT, 2, 2.0)
def __CompareScalarNodalValues(self,
nodes,
nodes_ref,
var,
var_ref,
factor=1.0):
for node, node_ref in zip(nodes, nodes_ref):
self.assertAlmostEqual(
node.GetSolutionStepValue(var),
node_ref.GetSolutionStepValue(var_ref) * factor, 10)
def __CompareVectorNodalValues(self,
nodes,
nodes_ref,
var,
var_ref,
dimension,
factor=1.0):
for node, node_ref in zip(nodes, nodes_ref):
val = node.GetSolutionStepValue(var)
val_ref = node_ref.GetSolutionStepValue(var_ref)
for i in range(dimension):
self.assertAlmostEqual(val[i], val_ref[i] * factor, 10)
def test_kratos_mapping_transfer_operator(self):
if not mapping_app_available:
self.skipTest("MappingApplication not available!")
data_transfer_op_settings_missing = KM.Parameters("""{
"type" : "kratos_mapping"
}""")
exp_error = 'No "mapper_settings" provided!'
with self.assertRaisesRegex(Exception, exp_error):
data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings_missing)
data_transfer_op_settings = KM.Parameters("""{
"type" : "kratos_mapping",
"mapper_settings" : {
"mapper_type" : "nearest_neighbor"
}
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
self.__TestTransferMatching(data_transfer_op)
self.__TestTransferMatchingSwapSign(data_transfer_op)
self.__TestTransferMatchingAddValues(data_transfer_op)
self.__TestTransferMatchingAddValuesAndSwapSign(data_transfer_op)
# with this we make sure that only one mapper is created (and not several ones for each mapping operation!)
# Hint: requires access to private member
self.assertEqual(
len(data_transfer_op._KratosMappingDataTransferOperator__mappers),
1)
self.__TestTransferMatchingInverse(data_transfer_op)
# here we check explicitly the InverseMap fct
self.assertEqual(
len(data_transfer_op._KratosMappingDataTransferOperator__mappers),
1)
transfer_options_empty = KM.Parameters(""" [] """)
data_transfer_op.TransferData(
self.origin_data_scalar, self.destination_non_matching_data_scalar,
transfer_options_empty)
# here we check explicitly the creation of a second mapper, which is required since the interfaces are not the same this time
self.assertEqual(
len(data_transfer_op._KratosMappingDataTransferOperator__mappers),
2)
data_settings_model_part = KM.Parameters("""{
"model_part_name" : "mp_single_node",
"variable_name" : "TEMPERATURE",
"location" : "model_part"
}""")
data_model_part = CouplingInterfaceData(data_settings_model_part,
self.model)
data_model_part.Initialize()
with self.assertRaisesRegex(
Exception,
'Currently only historical nodal values are supported'):
data_transfer_op.TransferData(self.origin_data_scalar,
data_model_part,
transfer_options_empty)
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())
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])
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 TestDataTransferOperators(KratosUnittest.TestCase):
def setUp(self):
self.model = KM.Model()
mp_o = self.model.CreateModelPart("mp_origin", 2)
mp_d_m = self.model.CreateModelPart("mp_destination_matching", 2)
mp_d_nm = self.model.CreateModelPart("mp_destination_non_matching", 2)
mp_one_n = self.model.CreateModelPart("mp_single_node", 2)
mp_o.AddNodalSolutionStepVariable(KM.PRESSURE)
mp_o.AddNodalSolutionStepVariable(KM.DISPLACEMENT)
mp_d_m.AddNodalSolutionStepVariable(KM.TEMPERATURE)
mp_d_m.AddNodalSolutionStepVariable(KM.FORCE)
mp_d_nm.AddNodalSolutionStepVariable(KM.TEMPERATURE)
mp_d_nm.AddNodalSolutionStepVariable(KM.FORCE)
mp_one_n.AddNodalSolutionStepVariable(KMC.SCALAR_DISPLACEMENT)
mp_one_n.AddNodalSolutionStepVariable(KMC.SCALAR_FORCE)
mp_o.ProcessInfo[KM.DOMAIN_SIZE] = 2
mp_d_m.ProcessInfo[KM.DOMAIN_SIZE] = 2
mp_d_nm.ProcessInfo[KM.DOMAIN_SIZE] = 2
mp_one_n.ProcessInfo[KM.DOMAIN_SIZE] = 2
num_nodes_matching = 5
num_nodes_non_matching = 8
for i in range(num_nodes_matching):
node_id = i + 1
node_o = mp_o.CreateNewNode(node_id, 0.0, 0.0, i + 1)
mp_d_m.CreateNewNode(node_id, 0.0, 0.0, i + 1)
node_o.SetSolutionStepValue(KM.PRESSURE, 0,
ScalarValueFromId(node_id))
node_o.SetSolutionStepValue(KM.DISPLACEMENT, 0,
VectorValueFromId(node_id))
for i in range(num_nodes_non_matching - 1, -1, -1):
node_id = i + 15
mp_d_nm.CreateNewNode(node_id, 0.0, 0.0, i + 1.1)
mp_one_n.CreateNewNode(1, 0.0, 0.0, 0.0)
origin_data_settings_scalar = KM.Parameters("""{
"model_part_name" : "mp_origin",
"variable_name" : "PRESSURE"
}""")
origin_data_settings_vector = KM.Parameters("""{
"model_part_name" : "mp_origin",
"variable_name" : "DISPLACEMENT",
"dimension" : 2
}""")
origin_data_settings_single_node = KM.Parameters("""{
"model_part_name" : "mp_single_node",
"variable_name" : "SCALAR_DISPLACEMENT"
}""")
self.origin_data_scalar = CouplingInterfaceData(
origin_data_settings_scalar, self.model)
self.origin_data_vector = CouplingInterfaceData(
origin_data_settings_vector, self.model)
self.origin_data_single_node = CouplingInterfaceData(
origin_data_settings_single_node, self.model)
self.origin_data_scalar.Initialize()
self.origin_data_vector.Initialize()
self.origin_data_single_node.Initialize()
destination_matching_data_settings_scalar = KM.Parameters("""{
"model_part_name" : "mp_destination_matching",
"variable_name" : "TEMPERATURE"
}""")
destination_matching_data_settings_vector = KM.Parameters("""{
"model_part_name" : "mp_destination_matching",
"variable_name" : "FORCE",
"dimension" : 2
}""")
destination_data_settings_single_node = KM.Parameters("""{
"model_part_name" : "mp_single_node",
"variable_name" : "SCALAR_FORCE"
}""")
self.destination_matching_data_scalar = CouplingInterfaceData(
destination_matching_data_settings_scalar, self.model)
self.destination_matching_data_vector = CouplingInterfaceData(
destination_matching_data_settings_vector, self.model)
self.destination_data_single_node = CouplingInterfaceData(
destination_data_settings_single_node, self.model)
self.destination_matching_data_scalar.Initialize()
self.destination_matching_data_vector.Initialize()
self.destination_data_single_node.Initialize()
destination_non_matching_data_settings_scalar = KM.Parameters("""{
"model_part_name" : "mp_destination_non_matching",
"variable_name" : "TEMPERATURE"
}""")
destination_non_matching_data_settings_vector = KM.Parameters("""{
"model_part_name" : "mp_destination_non_matching",
"variable_name" : "FORCE",
"dimension" : 2
}""")
self.destination_non_matching_data_scalar = CouplingInterfaceData(
destination_non_matching_data_settings_scalar, self.model)
self.destination_non_matching_data_vector = CouplingInterfaceData(
destination_non_matching_data_settings_vector, self.model)
self.destination_non_matching_data_scalar.Initialize()
self.destination_non_matching_data_vector.Initialize()
def test_copy_transfer_operator(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
self.__TestTransferMatching(data_transfer_op)
self.__TestTransferMatchingSwapSign(data_transfer_op)
self.__TestTransferMatchingAddValues(data_transfer_op)
self.__TestTransferMatchingAddValuesAdSwapSign(data_transfer_op)
transfer_options_empty = KM.Parameters(""" [] """)
exp_error = 'The sizes of the data are not matching: {} != {}!'.format(
self.origin_data_scalar.Size(),
self.destination_non_matching_data_scalar.Size())
with self.assertRaisesRegex(Exception, exp_error):
data_transfer_op.TransferData(
self.origin_data_scalar,
self.destination_non_matching_data_scalar,
transfer_options_empty)
def test_kratos_mapping_transfer_operator(self):
if using_pykratos:
self.skipTest("This test cannot be run with pyKratos!")
if not mapping_app_available:
self.skipTest("MappingApplication not available!")
data_transfer_op_settings_missing = KM.Parameters("""{
"type" : "kratos_mapping"
}""")
exp_error = 'No "mapper_settings" provided!'
with self.assertRaisesRegex(Exception, exp_error):
data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings_missing)
data_transfer_op_settings = KM.Parameters("""{
"type" : "kratos_mapping",
"mapper_settings" : {
"mapper_type" : "nearest_neighbor"
}
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
self.__TestTransferMatching(data_transfer_op)
self.__TestTransferMatchingSwapSign(data_transfer_op)
self.__TestTransferMatchingAddValues(data_transfer_op)
self.__TestTransferMatchingAddValuesAdSwapSign(data_transfer_op)
def test_copy_single_to_dist_transfer_operator(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy_single_to_distributed"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" [] """)
for node in self.origin_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_DISPLACEMENT, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, 1)
def test_copy_single_to_dist_transfer_operator_swap_sign(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy_single_to_distributed"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" ["swap_sign"] """)
for node in self.origin_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_DISPLACEMENT, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, -1)
def test_copy_single_to_dist_transfer_operator_distribute_values(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy_single_to_distributed"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" ["distribute_values"] """)
for node in self.origin_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_DISPLACEMENT, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, 0.2)
def test_copy_single_to_dist_transfer_operator_add_values(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy_single_to_distributed"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options_empty = KM.Parameters(""" [] """)
transfer_options_add = KM.Parameters(""" ["add_values"] """)
for node in self.origin_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_DISPLACEMENT, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options_empty)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, 1)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options_add)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, 2)
def test_copy_single_to_dist_transfer_operator_distribute_values_swap_sign(
self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy_single_to_distributed"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(
""" ["distribute_values", "swap_sign"] """)
for node in self.origin_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_DISPLACEMENT, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, -0.2)
def test_copy_single_to_dist_transfer_operator_distribute_values_swap_sign_add_values(
self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy_single_to_distributed"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(
""" ["distribute_values", "swap_sign"] """)
transfer_options_with_add_vals = KM.Parameters(
""" ["distribute_values", "swap_sign", "add_values"] """)
for node in self.origin_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_DISPLACEMENT, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, -0.2)
data_transfer_op.TransferData(self.origin_data_single_node,
self.destination_matching_data_scalar,
transfer_options_with_add_vals)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_single_node.GetModelPart().Nodes, KM.TEMPERATURE,
KMC.SCALAR_DISPLACEMENT, -0.4)
def test_sum_dist_to_single(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "sum_distributed_to_single"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" [] """)
for node in self.origin_data_scalar.GetModelPart().Nodes:
node.SetSolutionStepValue(KM.PRESSURE, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_data_single_node,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_data_single_node.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KMC.SCALAR_FORCE,
KM.PRESSURE, 5)
def test_sum_dist_to_single_swap_sign(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "sum_distributed_to_single"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" ["swap_sign"] """)
for node in self.origin_data_scalar.GetModelPart().Nodes:
node.SetSolutionStepValue(KM.PRESSURE, 0, 100.0)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_data_single_node,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_data_single_node.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KMC.SCALAR_FORCE,
KM.PRESSURE, -5)
def test_sum_dist_to_single_add_values(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "sum_distributed_to_single"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" ["add_values"] """)
for node in self.origin_data_scalar.GetModelPart().Nodes:
node.SetSolutionStepValue(KM.PRESSURE, 0, 100.0)
for node in self.destination_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_FORCE, 0, 500.0)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_data_single_node,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_data_single_node.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KMC.SCALAR_FORCE,
KM.PRESSURE, 10.0)
def test_sum_dist_to_single_add_values_swap_sign(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "sum_distributed_to_single"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" ["add_values", "swap_sign"] """)
for node in self.origin_data_scalar.GetModelPart().Nodes:
node.SetSolutionStepValue(KM.PRESSURE, 0, 100.0)
for node in self.destination_data_single_node.GetModelPart().Nodes:
node.SetSolutionStepValue(KMC.SCALAR_FORCE, 0, 500.0)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_data_single_node,
transfer_options)
self.__CompareScalarNodalValues(
self.destination_data_single_node.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KMC.SCALAR_FORCE,
KM.PRESSURE, 0.0)
def test_sum_dist_to_single_check_var(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "sum_distributed_to_single"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" [] """)
with self.assertRaisesRegex(
Exception,
'Variable of interface data "default" of solver "default_solver" has to be a scalar!'
):
data_transfer_op.TransferData(
self.destination_matching_data_vector,
self.destination_data_single_node, transfer_options)
def test_copy_single_to_dist_check_var(self):
data_transfer_op_settings = KM.Parameters("""{
"type" : "copy_single_to_distributed"
}""")
data_transfer_op = data_transfer_operator_factory.CreateDataTransferOperator(
data_transfer_op_settings)
transfer_options = KM.Parameters(""" [] """)
with self.assertRaisesRegex(
Exception,
'Variable of interface data "default" of solver "default_solver" has to be a scalar!'
):
data_transfer_op.TransferData(
self.destination_data_single_node,
self.destination_matching_data_vector, transfer_options)
def __TestTransferMatching(self, data_transfer_op):
transfer_options_empty = KM.Parameters(""" [] """)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_empty)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KM.TEMPERATURE,
KM.PRESSURE)
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_empty)
self.__CompareVectorNodalValues(
self.destination_matching_data_vector.GetModelPart().Nodes,
self.origin_data_vector.GetModelPart().Nodes, KM.FORCE,
KM.DISPLACEMENT, 2)
def __TestTransferMatchingSwapSign(self, data_transfer_op):
transfer_options_swap_sign = KM.Parameters(""" ["swap_sign"] """)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_swap_sign)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KM.TEMPERATURE,
KM.PRESSURE, -1.0)
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_swap_sign)
self.__CompareVectorNodalValues(
self.destination_matching_data_vector.GetModelPart().Nodes,
self.origin_data_vector.GetModelPart().Nodes, KM.FORCE,
KM.DISPLACEMENT, 2, -1.0)
def __TestTransferMatchingAddValues(self, data_transfer_op):
transfer_options_empty = KM.Parameters(""" [] """)
transfer_options_add_values = KM.Parameters(""" ["add_values"] """)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_empty) # "resetting"
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_add_values)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KM.TEMPERATURE,
KM.PRESSURE, 2.0)
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_empty) # "resetting"
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_add_values)
self.__CompareVectorNodalValues(
self.destination_matching_data_vector.GetModelPart().Nodes,
self.origin_data_vector.GetModelPart().Nodes, KM.FORCE,
KM.DISPLACEMENT, 2, 2.0)
def __TestTransferMatchingAddValuesAdSwapSign(self, data_transfer_op):
transfer_options_empty = KM.Parameters(""" [] """)
transfer_options_add_values = KM.Parameters(""" ["add_values"] """)
transfer_options_add_values_swap_sign = KM.Parameters(
""" ["add_values", "swap_sign"] """)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_empty) # "resetting"
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_add_values)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_add_values)
data_transfer_op.TransferData(self.origin_data_scalar,
self.destination_matching_data_scalar,
transfer_options_add_values_swap_sign)
self.__CompareScalarNodalValues(
self.destination_matching_data_scalar.GetModelPart().Nodes,
self.origin_data_scalar.GetModelPart().Nodes, KM.TEMPERATURE,
KM.PRESSURE, 2.0)
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_empty) # "resetting"
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_add_values)
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_add_values)
data_transfer_op.TransferData(self.origin_data_vector,
self.destination_matching_data_vector,
transfer_options_add_values_swap_sign)
self.__CompareVectorNodalValues(
self.destination_matching_data_vector.GetModelPart().Nodes,
self.origin_data_vector.GetModelPart().Nodes, KM.FORCE,
KM.DISPLACEMENT, 2, 2.0)
def __CompareScalarNodalValues(self,
nodes,
nodes_ref,
var,
var_ref,
factor=1.0):
for node, node_ref in zip(nodes, nodes_ref):
self.assertAlmostEqual(
node.GetSolutionStepValue(var),
node_ref.GetSolutionStepValue(var_ref) * factor, 10)
def __CompareVectorNodalValues(self,
nodes,
nodes_ref,
var,
var_ref,
dimension,
factor=1.0):
for node, node_ref in zip(nodes, nodes_ref):
val = node.GetSolutionStepValue(var)
val_ref = node_ref.GetSolutionStepValue(var_ref)
for i in range(dimension):
self.assertAlmostEqual(val[i], val_ref[i] * factor, 10)
