def test_TemporalController_CreateWithParameters(self):
model_part = _SurrogateModelPart()
io = file_io.Create(ParametersWrapper())
controller_settings = ParametersWrapper()
controller_settings['controller_type'] = 'temporal_controller'
controller_settings['time_frequency'] = 2.0
controller_settings['step_frequency'] = 3
controller = controllers.Create(model_part, io, controller_settings)
self.assertEqual(controller.time_frequency, 2.0)
self.assertEqual(controller.step_frequency, 3)
def test_TemporalController_CreateWithDefaults(self):
model_part = _SurrogateModelPart()
io = file_io.Create(ParametersWrapper())
controller_settings = ParametersWrapper()
controller_settings['controller_type'] = 'temporal_controller'
controller = controllers.Create(model_part, io, controller_settings)
self.assertEqual(controller.model_part, model_part)
self.assertEqual(controller.io, io)
self.assertEqual(controller.time_frequency, 1.0)
self.assertEqual(controller.step_frequency, 1)
self.assertEqual(controller.current_time, 0.0)
self.assertEqual(controller.current_step, 0)
def test_TemporalController_OperationCall(self):
model_part = _SurrogateModelPart()
controller_settings = ParametersWrapper()
controller_settings['controller_type'] = 'temporal_controller'
io = file_io.Create(ParametersWrapper())
operation = MagicMock(spec=operations.ModelPartOutput)
controller = controllers.Create(
model_part, io, controller_settings)
controller.Add(operation)
with patch('KratosMultiphysics.HDF5Application.core.file_io.KratosHDF5.HDF5FileSerial', autospec=True):
for _ in range(10):
controller()
self.assertEqual(operation.call_count, 10)
def test_TemporalController_StepFrequency(self):
model_part = _SurrogateModelPart()
controller_settings = ParametersWrapper()
controller_settings['step_frequency'] = 2
controller_settings['controller_type'] = 'temporal_controller'
with patch('KratosMultiphysics.HDF5Application.core.file_io._HDF5SerialFileIO', autospec=True):
io = file_io.Create(ParametersWrapper())
controller = controllers.Create(
model_part, io, controller_settings)
for i in range(10):
controller()
io.Get.assert_called_with(model_part)
self.assertEqual(io.Get.call_count, 5)
def test_ModelPartOutput(self):
settings = ParametersWrapper()
model_part_output = operations.Create(settings)
self.assertTrue(settings.Has('operation_type'))
self.assertTrue(settings.Has('prefix'))
self.assertEqual(settings['operation_type'], 'model_part_output')
with patch('KratosMultiphysics.HDF5Application.core.operations.KratosHDF5.HDF5ModelPartIO', autospec=True) as p:
model_part_io = p.return_value
model_part = _SurrogateModelPart()
hdf5_file = MagicMock(spec=KratosHDF5.HDF5FileSerial)
model_part_output(model_part, hdf5_file)
p.assert_called_once_with(hdf5_file, '/ModelData')
model_part_io.WriteModelPart.assert_called_once_with(model_part)
def test_ElementDataValueInput(self):
settings = ParametersWrapper()
settings['operation_type'] = 'element_data_value_input'
element_data_value_input = operations.Create(settings)
self.assertTrue(settings.Has('prefix'))
self.assertTrue(settings.Has('list_of_variables'))
self.assertTrue(settings['list_of_variables'].IsArray())
self.assertIsInstance(element_data_value_input, operations.VariableIO)
with patch('KratosMultiphysics.HDF5Application.core.operations.KratosHDF5.HDF5ElementDataValueIO', autospec=True) as p:
element_data_value_io = p.return_value
model_part = _SurrogateModelPart()
hdf5_file = MagicMock(spec=KratosHDF5.HDF5FileSerial)
element_data_value_input(model_part, hdf5_file)
self.assertEqual(p.call_count, 1)
self.assertEqual(element_data_value_io.ReadElementResults.call_count, 1)
def test_PrimalBossakInput(self):
settings = ParametersWrapper()
settings['operation_type'] = 'primal_bossak_input'
primal_bossak_input = operations.Create(settings)
self.assertTrue(settings.Has('prefix'))
self.assertTrue(settings.Has('list_of_variables'))
self.assertTrue(settings['list_of_variables'].IsArray())
self.assertIsInstance(primal_bossak_input, operations.VariableIO)
with patch('KratosMultiphysics.HDF5Application.core.operations.KratosHDF5.HDF5NodalSolutionStepBossakIO', autospec=True) as p:
nodal_solution_step_bossak_io = p.return_value
model_part = _SurrogateModelPart()
hdf5_file = MagicMock(spec=KratosHDF5.HDF5FileSerial)
primal_bossak_input(model_part, hdf5_file)
self.assertEqual(p.call_count, 1)
self.assertEqual(nodal_solution_step_bossak_io.ReadNodalResults.call_count, 1)
def test_DefaultProcess(self):
model = KratosMultiphysics.Model()
model_part = model.CreateModelPart('test')
parent_settings = KratosMultiphysics.Parameters('''
{
"list_of_controllers" : [
{
"model_part_name" : "test"
}
]
}
''')
parent_settings = ParametersWrapper(parent_settings)
process = core.Factory(parent_settings['list_of_controllers'], model)
patcher1 = patch(
'KratosMultiphysics.HDF5Application.core.file_io.KratosHDF5.HDF5FileSerial',
autospec=True)
patcher2 = patch(
'KratosMultiphysics.HDF5Application.core.operations.KratosHDF5.HDF5ModelPartIO',
autospec=True)
patcher1.start()
MockHDF5ModelPartIO = patcher2.start()
process.ExecuteInitialize()
model_part_io = MockHDF5ModelPartIO.return_value
model_part_io.WriteModelPart.assert_called_once_with(model_part)
patcher1.stop()
patcher2.stop()
def test_DefaultSettings(self):
model = KratosMultiphysics.Model()
model.CreateModelPart('test')
parent_settings = KratosMultiphysics.Parameters('''
{
"list_of_controllers" : [
{
"model_part_name" : "test"
}
]
}
''')
parent_settings = ParametersWrapper(parent_settings)
core.Factory(parent_settings['list_of_controllers'], model)
settings = parent_settings['list_of_controllers'][0]
self.assertTrue(settings.Has('model_part_name'))
self.assertTrue(settings.Has('process_step'))
self.assertTrue(settings.Has('controller_settings'))
self.assertTrue(settings.Has('io_settings'))
self.assertTrue(settings.Has('list_of_operations'))
self.assertTrue(settings['list_of_operations'].IsArray())
self.assertEqual(settings['list_of_operations'].size(), 1)
self.assertTrue(
settings['list_of_operations'][0].Has('operation_type'))
self.assertTrue(settings['list_of_operations'][0].Has('prefix'))
def test_PartitionedModelPartOutput(self):
settings = ParametersWrapper()
settings['operation_type'] = 'partitioned_model_part_output'
partitioned_model_part_output = operations.Create(settings)
self.assertTrue(settings.Has('operation_type'))
self.assertTrue(settings.Has('prefix'))
with patch(
'KratosMultiphysics.HDF5Application.core.operations.KratosHDF5.HDF5PartitionedModelPartIO'
) as p:
partitioned_model_part_io = p.return_value
model_part = test_hdf5_core._SurrogateModelPart()
hdf5_file = MagicMock(spec=KratosHDF5.HDF5FileParallel)
partitioned_model_part_output(model_part, hdf5_file)
p.assert_called_once_with(hdf5_file, '/ModelData')
partitioned_model_part_io.WriteModelPart.assert_called_once_with(
model_part)
def test_NodalFlagValueOutput(self):
settings = ParametersWrapper()
settings['operation_type'] = 'nodal_flag_value_output'
nodal_flag_value_output = operations.Create(settings)
self.assertTrue(settings.Has('prefix'))
self.assertTrue(settings.Has('list_of_variables'))
self.assertTrue(settings['list_of_variables'].IsArray())
self.assertIsInstance(nodal_flag_value_output, operations.VariableIO)
with patch(
'KratosMultiphysics.HDF5Application.core.operations.KratosHDF5.HDF5NodalFlagValueIO',
autospec=True) as p:
nodal_flag_value_io = p.return_value
model_part = _SurrogateModelPart()
hdf5_file = MagicMock(spec=KratosHDF5.HDF5FileSerial)
nodal_flag_value_output(model_part, hdf5_file)
self.assertEqual(p.call_count, 1)
self.assertEqual(nodal_flag_value_io.WriteNodalFlags.call_count, 1)
def test_TemporalController_OperationCall(self, mock_class):
mock_instance = mock_class.return_value
mock_instance.GetFileName.return_value = 'kratos.h5'
model_part = _SurrogateModelPart()
data_comm = model_part.GetCommunicator().GetDataCommunicator()
controller_settings = ParametersWrapper()
controller_settings['controller_type'] = 'temporal_controller'
io = file_io.Create(ParametersWrapper(), data_comm)
operation = MagicMock(spec=operations.ModelPartOutput)
controller = controllers.Create(model_part, io, controller_settings)
controller.Add(operation)
with patch(
'KratosMultiphysics.HDF5Application.core.file_io.KratosHDF5.HDF5FileSerial',
autospec=True):
for _ in range(10):
controller()
self.assertEqual(operation.call_count, 10)
def test_TemporalController_NearlyTheSameTimeFrequency(self):
model_part = _SurrogateModelPart()
data_comm = model_part.GetCommunicator().GetDataCommunicator()
controller_settings = ParametersWrapper()
controller_settings['step_frequency'] = 100
controller_settings['time_frequency'] = 0.2000001
controller_settings['controller_type'] = 'temporal_controller'
with patch(
'KratosMultiphysics.HDF5Application.core.file_io._HDF5SerialFileIO',
autospec=True):
io = file_io.Create(ParametersWrapper(), data_comm)
controller = controllers.Create(model_part, io,
controller_settings)
for _ in range(10):
controller()
io.Get.assert_called_with(model_part)
self.assertEqual(io.Get.call_count, 5)
def _FilenameGetterSettings(**kwargs):
settings = ParametersWrapper()
if 'file_name' in kwargs:
settings['file_name'] = kwargs['file_name']
else:
settings['file_name'] = 'kratos.h5'
if 'time_format' in kwargs:
settings['time_format'] = kwargs['time_format']
return settings
def test_DefaultController(self):
model_part = _SurrogateModelPart()
io_settings = ParametersWrapper()
controller_settings = ParametersWrapper()
with patch('KratosMultiphysics.HDF5Application.core.file_io.KratosHDF5.HDF5FileSerial', autospec=True):
io = file_io.Create(io_settings)
controller = controllers.Create(
model_part, io, controller_settings)
self.assertTrue(controller_settings.Has('controller_type'))
self.assertEqual(
controller_settings['controller_type'], 'default_controller')
self.assertEqual(controller.model_part, model_part)
self.assertEqual(controller.io, io)
operation = MagicMock(spec=operations.ModelPartOutput)
controller()
controller.Add(operation)
for i in range(10):
controller()
self.assertEqual(operation.call_count, 10)
def test_VariableIO_Settings(self):
settings1 = ParametersWrapper()
variable_io = operations.VariableIO(settings1)
settings2 = variable_io.GetSettings(_SurrogateModelPart())
for settings in [settings1, settings2]:
self.assertTrue(settings.Has('prefix'))
self.assertTrue(settings.Has('list_of_variables'))
self.assertEqual(settings['prefix'], '/ResultsData')
self.assertTrue(settings['list_of_variables'].IsArray())
self.assertEqual(len(settings['list_of_variables']), 0)
def test_VariableIO_GetSettingsWithNonTerminalPrefix(self):
input_settings = ParametersWrapper('''
{
"prefix": "/ModelData/<model_part_name>/<time>",
"time_format": "0.2f"
}
''')
variable_io = operations.VariableIO(input_settings)
settings = variable_io.GetSettings(_SurrogateModelPart())
self.assertEqual(settings['prefix'], '/ModelData/model_part/1.23')
def test_Create_Attributes(self):
settings = ParametersWrapper()
io = file_io.Create(settings)
self.assertIsInstance(io, file_io._HDF5SerialFileIO)
self.assertTrue(hasattr(io, 'filename_getter'))
self.assertEqual(io.file_access_mode, 'exclusive')
if os.name == 'posix':
self.assertEqual(io.file_driver, 'sec2')
elif os.name == 'nt':
self.assertEqual(io.file_driver, 'windows')
self.assertEqual(io.echo_level, 0)
def test_EmptyArraySettings(self):
model = KratosMultiphysics.Model()
settings = KratosMultiphysics.Parameters('''
{
"list_of_controllers" : []
}
''')
settings = ParametersWrapper(settings)
with self.assertRaisesRegex(
RuntimeError,
'"PLEASE_SPECIFY_MODEL_PART_NAME" was not found'):
core.Factory(settings['list_of_controllers'], model)
def test_Create_Attributes(self):
settings = ParametersWrapper()
data_comm = KratosMultiphysics.Testing.GetDefaultDataCommunicator()
io = file_io.Create(settings, data_comm)
self.assertIsInstance(io, file_io._HDF5SerialFileIO)
self.assertTrue(hasattr(io, 'filename_getter'))
self.assertEqual(io.file_access_mode, 'exclusive')
if os.name == 'posix':
self.assertEqual(io.file_driver, 'sec2')
elif os.name == 'nt':
self.assertEqual(io.file_driver, 'windows')
self.assertEqual(io.echo_level, 0)
def CreateOperationSettings(operation_type, user_settings):
"""Return core settings for an operation type.
See core.operations.
"""
core_settings = ParametersWrapper("""
{
"operation_type": "%s"
}
""" % operation_type)
for key in user_settings:
core_settings[key] = user_settings[key]
return core_settings
def test_SetDefaults(self):
settings = ParametersWrapper()
file_io._SetDefaults(settings)
self.assertTrue(settings.Has('io_type'))
self.assertTrue(settings.Has('file_name'))
self.assertFalse(settings.Has('time_format'))
self.assertTrue(settings.Has('file_access_mode'))
self.assertTrue(settings.Has('file_driver'))
self.assertTrue(settings.Has('echo_level'))
self.assertEqual(settings['io_type'], 'serial_hdf5_file_io')
self.assertEqual(settings['file_name'], 'kratos')
self.assertEqual(settings['file_access_mode'], 'exclusive')
if os.name == 'posix':
self.assertEqual(settings['file_driver'], 'sec2')
elif os.name == 'nt':
self.assertEqual(settings['file_driver'], 'windows')
self.assertEqual(settings['echo_level'], 0)
def test_DefaultController(self, mock_class):
mock_instance = mock_class.return_value
mock_instance.GetFileName.return_value = 'kratos.h5'
model_part = _SurrogateModelPart()
data_comm = model_part.GetCommunicator().GetDataCommunicator()
io_settings = ParametersWrapper()
controller_settings = ParametersWrapper()
with patch(
'KratosMultiphysics.HDF5Application.core.file_io.KratosHDF5.HDF5FileSerial',
autospec=True):
io = file_io.Create(io_settings, data_comm)
controller = controllers.Create(model_part, io,
controller_settings)
self.assertTrue(controller_settings.Has('controller_type'))
self.assertEqual(controller_settings['controller_type'],
'default_controller')
self.assertEqual(controller.model_part, model_part)
self.assertEqual(controller.io, io)
operation = MagicMock(spec=operations.ModelPartOutput)
controller()
controller.Add(operation)
for i in range(10):
controller()
self.assertEqual(operation.call_count, 10)
def test_ModelPartOutput_NonTerminalPrefix(self):
settings = ParametersWrapper('''
{
"operation_type": "model_part_output",
"prefix": "/ModelData/<model_part_name>/<time>",
"time_format": "0.2f"
}
''')
model_part_output = operations.Create(settings)
with patch('KratosMultiphysics.HDF5Application.core.operations.KratosHDF5.HDF5ModelPartIO', autospec=True) as p:
model_part = _SurrogateModelPart()
hdf5_file = MagicMock(spec=KratosHDF5.HDF5FileSerial)
model_part_output(model_part, hdf5_file)
args, _ = p.call_args
self.assertEqual(args[1], '/ModelData/model_part/1.23')
def test_Create_Settings(self):
settings = ParametersWrapper()
data_comm = KratosMultiphysics.Testing.GetDefaultDataCommunicator()
file_io.Create(settings, data_comm)
self.assertTrue(settings.Has('io_type'))
self.assertTrue(settings.Has('file_name'))
self.assertTrue(settings.Has('file_access_mode'))
self.assertTrue(settings.Has('file_driver'))
self.assertTrue(settings.Has('echo_level'))
self.assertEqual(settings['io_type'], 'serial_hdf5_file_io')
self.assertEqual(settings['file_access_mode'], 'exclusive')
if os.name == 'posix':
self.assertEqual(settings['file_driver'], 'sec2')
elif os.name == 'nt':
self.assertEqual(settings['file_driver'], 'windows')
self.assertEqual(settings['echo_level'], 0)
def test_SetDefaults_ParallelIO(self):
settings = ParametersWrapper()
settings.AddEmptyValue('io_type').SetString('parallel_hdf5_file_io')
file_io._SetDefaults(settings)
self.assertEqual(settings['file_driver'], 'mpio')
def test_SetDefaults_NonTerminalTime(self):
settings = ParametersWrapper()
settings['file_name'] = 'kratos-<time>.h5'
file_io._SetDefaults(settings)
self.assertTrue(settings.Has('time_format'))
self.assertEqual(settings['time_format'], '0.4f')
def test_nonarray_keys(self):
settings = ParametersWrapper(self.get_params)
for k in settings['parameters']:
self.assertEqual(k, 'double_value')
def test_array_keys(self):
settings = ParametersWrapper(self.get_params)
count = 0
for k in settings['array_of_double_values']:
self.assertEqual(k, count)
count += 1
def test_CreateNonExistingController(self):
settings = ParametersWrapper()
settings['controller_type'] = 'abcdefg'
with self.assertRaisesRegex(ValueError, r'"controller_type" has invalid value "abcdefg"'):
controllers.Create(MagicMock(), MagicMock(), settings)
