def test_HDF5NodalSolutionStepDataIO(self):
with ControlledExecutionScope(os.path.dirname(os.path.realpath(__file__))):
current_model = Model()
write_model_part = current_model.CreateModelPart("write")
KratosMPI.ModelPartCommunicatorUtilities.SetMPICommunicator(write_model_part)
self._initialize_model_part(write_model_part)
hdf5_file = self._get_file()
hdf5_model_part_io = self._get_model_part_io(hdf5_file)
hdf5_model_part_io.WriteModelPart(write_model_part)
read_model_part = current_model.CreateModelPart("read")
KratosMPI.ModelPartCommunicatorUtilities.SetMPICommunicator(read_model_part)
hdf5_model_part_io.ReadModelPart(read_model_part)
KratosMPI.ParallelFillCommunicator(read_model_part.GetRootModelPart()).Execute()
hdf5_nodal_solution_step_data_io = self._get_nodal_solution_step_data_io(hdf5_file)
hdf5_nodal_solution_step_data_io.WriteNodalResults(write_model_part.Nodes, 0)
hdf5_nodal_solution_step_data_io.ReadNodalResults(read_model_part.Nodes, read_model_part.GetCommunicator(), 0)
read_model_part.GetCommunicator().SynchronizeNodalSolutionStepsData()
# Check data.
for read_node, write_node in zip(read_model_part.Nodes, write_model_part.Nodes):
self.assertEqual(read_node.GetSolutionStepValue(DISPLACEMENT_X), write_node.GetSolutionStepValue(DISPLACEMENT_X))
self.assertEqual(read_node.GetSolutionStepValue(DISPLACEMENT_Y), write_node.GetSolutionStepValue(DISPLACEMENT_Y))
self.assertEqual(read_node.GetSolutionStepValue(DISPLACEMENT_Z), write_node.GetSolutionStepValue(DISPLACEMENT_Z))
self.assertEqual(read_node.GetSolutionStepValue(VELOCITY_X), write_node.GetSolutionStepValue(VELOCITY_X))
self.assertEqual(read_node.GetSolutionStepValue(VELOCITY_Y), write_node.GetSolutionStepValue(VELOCITY_Y))
self.assertEqual(read_node.GetSolutionStepValue(VELOCITY_Z), write_node.GetSolutionStepValue(VELOCITY_Z))
self.assertEqual(read_node.GetSolutionStepValue(ACCELERATION_X), write_node.GetSolutionStepValue(ACCELERATION_X))
self.assertEqual(read_node.GetSolutionStepValue(ACCELERATION_Y), write_node.GetSolutionStepValue(ACCELERATION_Y))
self.assertEqual(read_node.GetSolutionStepValue(ACCELERATION_Z), write_node.GetSolutionStepValue(ACCELERATION_Z))
self.assertEqual(read_node.GetSolutionStepValue(PRESSURE), write_node.GetSolutionStepValue(PRESSURE))
self.assertEqual(read_node.GetSolutionStepValue(VISCOSITY), write_node.GetSolutionStepValue(VISCOSITY))
self.assertEqual(read_node.GetSolutionStepValue(DENSITY), write_node.GetSolutionStepValue(DENSITY))
self.assertEqual(read_node.GetSolutionStepValue(ACTIVATION_LEVEL), write_node.GetSolutionStepValue(ACTIVATION_LEVEL))
self.assertEqual(read_node.GetSolutionStepValue(PARTITION_INDEX), write_node.GetSolutionStepValue(PARTITION_INDEX))
kratos_utilities.DeleteFileIfExisting("test_hdf5_model_part_io_mpi.h5")
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 executeComputeArea_Task(pickled_model):
# Unpickling model
serialized_model = pickle.loads(pickled_model)
# Unserializing model
deserialized_model = KratosMultiphysics.Model()
serialized_model.Load("ModelSerialization", deserialized_model)
model_part = deserialized_model.GetModelPart("ModelPart").GetRootModelPart()
## Construct and execute the Parallel fill communicator
ParallelFillCommunicator = KratosMPI.ParallelFillCommunicator(model_part)
ParallelFillCommunicator.Execute()
communicator = model_part.GetCommunicator()
# Computing local areas
for node in model_part.Nodes:
node.SetValue(KratosMultiphysics.NODAL_AREA, 0.0)
for elem in model_part.Elements:
for node in elem.GetNodes():
current_nodal_area = node.GetValue(KratosMultiphysics.NODAL_AREA)
current_nodal_area += 1/3*elem.GetGeometry().Area()
node.SetValue(KratosMultiphysics.NODAL_AREA, current_nodal_area)
# Assembling nodal values
communicator.AssembleNonHistoricalData(KratosMultiphysics.NODAL_AREA)
# Computing sum of total area to check results.
local_sum = sum(node.GetValue(KratosMultiphysics.NODAL_AREA) for node in model_part.Nodes if node.GetSolutionStepValue(KratosMultiphysics.PARTITION_INDEX) == communicator.GetDataCommunicator().Rank())
total_sum = communicator.GetDataCommunicator().SumAll(local_sum)
return total_sum
def test_HDF5NodalFlagIO(self):
with ControlledExecutionScope(
os.path.dirname(os.path.realpath(__file__))):
current_model = Model()
write_model_part = current_model.CreateModelPart("write")
KratosMPI.ModelPartCommunicatorUtilities.SetMPICommunicator(
write_model_part)
self._initialize_model_part(write_model_part)
hdf5_file = self._get_file()
hdf5_model_part_io = self._get_model_part_io(hdf5_file)
hdf5_model_part_io.WriteModelPart(write_model_part)
read_model_part = current_model.CreateModelPart("read")
KratosMPI.ModelPartCommunicatorUtilities.SetMPICommunicator(
read_model_part)
hdf5_model_part_io.ReadModelPart(read_model_part)
KratosMPI.ParallelFillCommunicator(
read_model_part.GetRootModelPart()).Execute()
hdf5_nodal_flag_io = self._get_nodal_flag_io(hdf5_file)
hdf5_nodal_flag_io.WriteNodalFlags(write_model_part.Nodes)
hdf5_nodal_flag_io.ReadNodalFlags(
read_model_part.Nodes, read_model_part.GetCommunicator())
# # Check flag.
for read_node, write_node in zip(read_model_part.Nodes,
write_model_part.Nodes):
self.assertEqual(read_node.Is(SLIP), write_node.Is(SLIP))
self.assertEqual(read_node.Is(ACTIVE), write_node.Is(ACTIVE))
kratos_utilities.DeleteFileIfExisting(
"test_hdf5_model_part_io_mpi.h5")
def ImportChimeraModelparts(main_modelpart, chimera_mp_import_settings_list, material_file="", parallel_type="OpenMP"):
'''
This function extends the functionalities of the
mpda_manipulator from: https://github.com/philbucher/mdpa-manipulator
main_modelpart : The modelpart to which the new modelparts are appended to.
chimera_mp_import_settings_list : The list of import setting for all chimera modelparts. each entry has the following format:
{
"model_import_settings":{
"input_type": "mdpa",
"input_filename": "SOME"
},
"echo_level":1
}
'''
if parallel_type == "OpenMP":
for mp_import_setting in chimera_mp_import_settings_list:
mdpa_file_name = mp_import_setting["input_filename"].GetString()
if mdpa_file_name.endswith('.mdpa'):
mdpa_file_name = mdpa_file_name[:-5]
model = KratosMultiphysics.Model()
model_part = model.CreateModelPart("new_modelpart")
KratosChimera.TransferSolutionStepData(main_modelpart, model_part)
ReadModelPart(mdpa_file_name, model_part, material_file)
AddModelPart(main_modelpart, model_part)
elif(parallel_type == "MPI"):
input_settings = KratosMultiphysics.Parameters("""{
"model_import_settings":{
"input_type": "mdpa",
"input_filename": "SOME"
},
"echo_level":1
}""")
for mp_import_setting in chimera_mp_import_settings_list:
model = KratosMultiphysics.Model()
model_part = model.CreateModelPart("new_modelpart")
KratosChimera.TransferSolutionStepData(main_modelpart, model_part)
model_part.AddNodalSolutionStepVariable(KratosMultiphysics.PARTITION_INDEX)
mdpa_file_name = mp_import_setting["input_filename"].GetString()
if mdpa_file_name.endswith('.mdpa'):
mdpa_file_name = mdpa_file_name[:-5]
mp_import_setting["input_filename"].SetString(mdpa_file_name)
input_settings["model_import_settings"] = mp_import_setting
from KratosMultiphysics.mpi import distributed_import_model_part_utility
mpi_import_utility = distributed_import_model_part_utility.DistributedImportModelPartUtility(model_part, input_settings)
mpi_import_utility.ImportModelPart()
#mpi_import_utility.CreateCommunicators()
AddModelPart(main_modelpart, model_part, is_mpi=True)
## Construct and execute the Parallel fill communicator (also sets the MPICommunicator)
import KratosMultiphysics.mpi as KratosMPI
ParallelFillCommunicator = KratosMPI.ParallelFillCommunicator(main_modelpart.GetRootModelPart())
ParallelFillCommunicator.Execute()
def CreateCommunicators(self):
## Construct and execute the Parallel fill communicator (also sets the MPICommunicator)
ParallelFillCommunicator = KratosMPI.ParallelFillCommunicator(
self.main_model_part.GetRootModelPart())
ParallelFillCommunicator.Execute()
KratosMultiphysics.Logger.PrintInfo(
"::[DistributedImportModelPartUtility]::",
"MPI communicators constructed.")
def test_HDF5ModelPartIO(self):
with ControlledExecutionScope(os.path.dirname(os.path.realpath(__file__))):
current_model = Model()
write_model_part = current_model.CreateModelPart("write")
KratosMPI.ModelPartCommunicatorUtilities.SetMPICommunicator(write_model_part)
self._initialize_model_part(write_model_part)
hdf5_file = self._get_file()
hdf5_model_part_io = self._get_model_part_io(hdf5_file)
hdf5_model_part_io.WriteModelPart(write_model_part)
read_model_part = current_model.CreateModelPart("read")
KratosMPI.ModelPartCommunicatorUtilities.SetMPICommunicator(read_model_part)
hdf5_model_part_io.ReadModelPart(read_model_part)
KratosMPI.ParallelFillCommunicator(read_model_part.GetRootModelPart()).Execute()
read_model_part.GetCommunicator().SynchronizeNodalSolutionStepsData()
# Check nodes (node order should be preserved on read/write to ensure consistency with nodal results)
self.assertEqual(read_model_part.NumberOfNodes(), write_model_part.NumberOfNodes())
for read_node, write_node in zip(read_model_part.Nodes, write_model_part.Nodes):
self.assertEqual(read_node.Id, write_node.Id)
self.assertEqual(read_node.X, write_node.X)
self.assertEqual(read_node.Y, write_node.Y)
self.assertEqual(read_node.Z, write_node.Z)
# Check elements
self.assertEqual(read_model_part.NumberOfElements(), write_model_part.NumberOfElements())
first_elem_id = next(iter(read_model_part.Elements)).Id
read_model_part.GetElement(first_elem_id) # Force a sort since order is mixed by openmp.
for read_elem, write_elem in zip(read_model_part.Elements, write_model_part.Elements):
self.assertEqual(read_elem.Id, write_elem.Id)
self.assertEqual(read_elem.Properties.Id, write_elem.Properties.Id)
self.assertEqual(len(read_elem.GetNodes()), len(write_elem.GetNodes()))
for read_elem_node, write_elem_node in zip(read_elem.GetNodes(), write_elem.GetNodes()):
self.assertEqual(read_elem_node.Id, write_elem_node.Id)
# Check conditions
self.assertEqual(read_model_part.NumberOfConditions(), write_model_part.NumberOfConditions())
first_cond_id = next(iter(read_model_part.Conditions)).Id
read_model_part.GetCondition(first_cond_id) # Force a sort since order is mixed by openmp.
for read_cond, write_cond in zip(read_model_part.Conditions, write_model_part.Conditions):
self.assertEqual(read_cond.Id, write_cond.Id)
self.assertEqual(read_cond.Properties.Id, write_cond.Properties.Id)
self.assertEqual(len(read_cond.GetNodes()), len(write_cond.GetNodes()))
for read_cond_node, write_cond_node in zip(read_cond.GetNodes(), write_cond.GetNodes()):
self.assertEqual(read_cond_node.Id, write_cond_node.Id)
# Check process info
self.assertEqual(read_model_part.ProcessInfo[DOMAIN_SIZE], write_model_part.ProcessInfo[DOMAIN_SIZE])
self.assertEqual(read_model_part.ProcessInfo[TIME], write_model_part.ProcessInfo[TIME])
read_vector = read_model_part.ProcessInfo[INITIAL_STRAIN]
write_vector = write_model_part.ProcessInfo[INITIAL_STRAIN]
self.assertEqual(read_vector.Size(), write_vector.Size())
for i in range(len(read_vector)):
self.assertEqual(read_vector[i], write_vector[i])
read_matrix = read_model_part.ProcessInfo[GREEN_LAGRANGE_STRAIN_TENSOR]
write_matrix = write_model_part.ProcessInfo[GREEN_LAGRANGE_STRAIN_TENSOR]
self.assertEqual(read_matrix.Size1(), write_matrix.Size1())
self.assertEqual(read_matrix.Size2(), write_matrix.Size2())
for i in range(read_matrix.Size1()):
for j in range(read_matrix.Size2()):
self.assertEqual(read_matrix[i,j], write_matrix[i,j])
kratos_utilities.DeleteFileIfExisting("test_hdf5_model_part_io_mpi.h5")
def _read_model_part_mpi(self, main_model_part):
if self.communicator.Size() == 1:
self.skipTest(
"Test can be run only using more than one mpi process")
## Add variables to the model part
main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.DENSITY)
main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.VISCOSITY)
main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.DISPLACEMENT)
main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.PARTITION_INDEX)
## Serial partition of the original .mdpa file
input_filename = "test_mpi_communicator"
if self.communicator.Rank() == 0:
# Original .mdpa file reading
model_part_io = KratosMultiphysics.ModelPartIO(input_filename)
# Partition of the original .mdpa file
number_of_partitions = self.communicator.Size(
) # Number of partitions equals the number of processors
domain_size = main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE]
verbosity = 0
sync_conditions = True # Make sure that the condition goes to the same partition as the element is a face of
partitioner = KratosMetis.MetisDivideHeterogeneousInputProcess(
model_part_io, number_of_partitions, domain_size, verbosity,
sync_conditions)
partitioner.Execute()
KratosMultiphysics.Logger.PrintInfo("TestMPICommunicator",
"Metis divide finished.")
self.communicator.Barrier()
## Read the partitioned .mdpa files
mpi_input_filename = input_filename + "_" + str(
self.communicator.Rank())
model_part_io = KratosMultiphysics.ModelPartIO(mpi_input_filename)
model_part_io.ReadModelPart(main_model_part)
## Construct and execute the Parallel fill communicator
ParallelFillCommunicator = KratosMPI.ParallelFillCommunicator(
main_model_part.GetRootModelPart())
ParallelFillCommunicator.Execute()
## Check submodelpart of each main_model_part of each processor
self.assertTrue(main_model_part.HasSubModelPart("Skin"))
skin_sub_model_part = main_model_part.GetSubModelPart("Skin")
def setUp(self):
self.model = KM.Model()
self.root_model_part = self.model.CreateModelPart("root_mp")
self.root_model_part.AddNodalSolutionStepVariable(KM.PARTITION_INDEX)
self.dimension = 3
self.root_model_part.CreateNewProperties(0)
data_comm = KM.DataCommunicator.GetDefault()
my_pid = data_comm.Rank()
self.num_nodes = my_pid % 5 + 4 # num_nodes in range (4 ... 8)
if my_pid == 4:
self.num_nodes = 0 # in order to emulate one partition not having local nodes
smp_nodes_1 = self.root_model_part.CreateSubModelPart("smp_nodes_1")
smp_nodes_2 = self.root_model_part.CreateSubModelPart("smp_nodes_2")
smp_nodes_3 = self.root_model_part.CreateSubModelPart("smp_nodes_3")
scan_sum_num_nodes = data_comm.ScanSum(self.num_nodes)
if self.num_nodes > 0:
for i_node, id_node in enumerate(
range(scan_sum_num_nodes - self.num_nodes,
scan_sum_num_nodes)):
# this creates the same coords in different ranks, which does not matter for this test
if i_node < self.num_nodes - 2: # last two nodes go to other sub-model-part
smp_nodes_1.CreateNewNode(id_node + 1, 0.1 * i_node, 0.0,
0.0)
else:
smp_nodes_2.CreateNewNode(id_node + 1, 1.3, 0.1 * i_node,
0.0)
for node in self.root_model_part.Nodes:
node.SetSolutionStepValue(KM.PARTITION_INDEX, my_pid)
# adding the first node of each smp to another smp to emulate an "overlapping" interface
for node in smp_nodes_1.Nodes:
smp_nodes_3.AddNodes([node.Id])
break
for node in smp_nodes_2.Nodes:
smp_nodes_3.AddNodes([node.Id])
break
if KM.IsDistributedRun():
KratosMPI.ParallelFillCommunicator(self.root_model_part).Execute()
def ReadModelPart(self, filename):
model = KratosMultiphysics.Model()
model_part = model.CreateModelPart("Test ModelPart")
model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.PARTITION_INDEX)
model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.DISPLACEMENT)
model_part.AddNodalSolutionStepVariable(KratosMultiphysics.FORCE)
model_part.AddNodalSolutionStepVariable(KratosMultiphysics.REACTION)
model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.FSI_INTERFACE_RESIDUAL)
KratosMultiphysics.DataCommunicator.GetDefault().Barrier()
model_part_io = KratosMultiphysics.ModelPartIO(filename)
model_part_io.ReadModelPart(model_part)
model_part.SetBufferSize(2)
KratosMPI.ParallelFillCommunicator(model_part).Execute()
return model_part
def _ExecuteAfterLoad(self):
if self.set_mpi_communicator:
KratosMPI.ParallelFillCommunicator(self.main_model_part.GetRootModelPart()).Execute()
def _initialize_model_part(self, model_part):
# Add variables.
model_part.AddNodalSolutionStepVariable(DISPLACEMENT) # array_1d
model_part.AddNodalSolutionStepVariable(VELOCITY)
model_part.AddNodalSolutionStepVariable(ACCELERATION)
model_part.AddNodalSolutionStepVariable(PRESSURE) # double
model_part.AddNodalSolutionStepVariable(VISCOSITY)
model_part.AddNodalSolutionStepVariable(DENSITY)
model_part.AddNodalSolutionStepVariable(ACTIVATION_LEVEL) # int
model_part.AddNodalSolutionStepVariable(PARTITION_INDEX)
# Make a mesh out of two structured rings (inner triangles, outer quads).
num_proc = DataCommunicator.GetDefault().Size()
my_pid = DataCommunicator.GetDefault().Rank()
my_num_quad = 20 # user-defined.
my_num_tri = 2 * my_num_quad # splits each quad into 2 triangles.
num_local_nodes = 3 * my_num_quad
num_ghost_nodes = 3
local_start_index = num_local_nodes * my_pid + 1
ghost_start_index = local_start_index + num_local_nodes
local_node_ids = list(range(local_start_index, local_start_index + num_local_nodes))
ghost_node_ids = list(range(ghost_start_index, ghost_start_index + num_ghost_nodes))
partition_index = dict()
for i in local_node_ids:
partition_index[i] = my_pid
if (my_pid == num_proc - 1): # Connect ring start and ring end.
ghost_node_ids = [1, 2, 3]
for i in ghost_node_ids:
partition_index[i] = (my_pid + 1) % num_proc
node_ids = local_node_ids + ghost_node_ids
# Create nodes.
for i in node_ids:
radius = 0.5 + 0.5 * ((i - 1) % 3) / 2.0
phase = 2.0 * math.pi * ((i - 1) // 3) / float(my_num_quad * num_proc)
x = radius * math.cos(phase)
y = radius * math.sin(phase)
model_part.CreateNewNode(i, x, y, 0.0)
# Create elements and conditions.
for i in range(0, num_local_nodes, 3):
prop_id = 1
prop = model_part.GetProperties()[prop_id]
# First triangle.
eid = local_start_index + 3 * (i // 3)
nids = [node_ids[i], node_ids[i + 1], node_ids[i + 4]]
model_part.CreateNewElement("Element2D3N", eid, nids, prop)
model_part.CreateNewCondition("SurfaceCondition3D3N", eid, nids, prop)
# Second triangle.
eid = eid + 1
nids = [node_ids[i], node_ids[i + 4], node_ids[i + 3]]
model_part.CreateNewElement("Element2D3N", eid, nids, prop)
model_part.CreateNewCondition("SurfaceCondition3D3N", eid, nids, prop)
# Quad.
eid = eid + 1
nids = [node_ids[i + 1], node_ids[i + 2], node_ids[i + 5], node_ids[i + 4]]
model_part.CreateNewElement("Element2D4N", eid, nids, prop)
model_part.CreateNewCondition("SurfaceCondition3D4N", eid, nids, prop)
if my_pid == 0:
# Here we create a special condition that only exists on the first
# process. This is to test the collective write when at least one
# process has an empty set.
model_part.CreateNewCondition("LineCondition2D2N", eid + 1, [node_ids[i + 1], node_ids[i + 2]], prop)
model_part.SetBufferSize(2)
# Write some data to the nodal solution steps variables.
for node in model_part.Nodes:
node.SetSolutionStepValue(PARTITION_INDEX, partition_index[node.Id])
node.SetSolutionStepValue(DISPLACEMENT_X, random.random())
node.SetSolutionStepValue(DISPLACEMENT_Y, random.random())
node.SetSolutionStepValue(DISPLACEMENT_Z, random.random())
node.SetSolutionStepValue(VELOCITY_X, random.random())
node.SetSolutionStepValue(VELOCITY_Y, random.random())
node.SetSolutionStepValue(VELOCITY_Z, random.random())
node.SetSolutionStepValue(ACCELERATION_X, random.random())
node.SetSolutionStepValue(ACCELERATION_Y, random.random())
node.SetSolutionStepValue(ACCELERATION_Z, random.random())
node.SetSolutionStepValue(PRESSURE, random.random())
node.SetSolutionStepValue(VISCOSITY, random.random())
node.SetSolutionStepValue(DENSITY, random.random())
node.SetSolutionStepValue(ACTIVATION_LEVEL, random.randint(-100, 100))
KratosMPI.ParallelFillCommunicator(model_part.GetRootModelPart()).Execute()
model_part.GetCommunicator().SynchronizeNodalSolutionStepsData()
# Set some process info variables.
model_part.ProcessInfo[DOMAIN_SIZE] = 3 # int
model_part.ProcessInfo[TIME] = 1.2345 # float
initial_strain = Vector(6)
for i in range(6):
initial_strain[i] = math.cos(i)
model_part.ProcessInfo[INITIAL_STRAIN] = initial_strain # vector
gl_strain_tensor = Matrix(5,5)
for i in range(5):
for j in range(5):
gl_strain_tensor[i,j] = math.cos(i + j)
model_part.ProcessInfo[GREEN_LAGRANGE_STRAIN_TENSOR] = gl_strain_tensor # matrix
