def setUp(self):
communicator = KratosMultiphysics.DataCommunicator.GetDefault()
rank = communicator.Rank()
current_model = KratosMultiphysics.Model()
model_part_to_read = current_model.CreateModelPart("ModelPart")
model_part_to_read.AddNodalSolutionStepVariable(
KratosMultiphysics.PARTITION_INDEX)
importer_settings = KratosMultiphysics.Parameters("""{
"model_import_settings": {
"input_type": "mdpa",
"input_filename": "",
"partition_in_memory" : true
},
"echo_level" : 0
}""")
mdpa_name = GetFilePath(
"auxiliar_files_for_python_unnitest/mdpa_files/test_mpi_serializer"
)
importer_settings["model_import_settings"]["input_filename"].SetString(
mdpa_name)
model_part_import_util = distributed_import_model_part_utility.DistributedImportModelPartUtility(
model_part_to_read, importer_settings)
model_part_import_util.ImportModelPart()
## Serialize each model_part
serialized_model = KratosMultiphysics.MpiSerializer()
serialized_model.Save("ModelSerialization", current_model)
self.pickled_data = pickle.dumps(
serialized_model, protocol=2
) # Second argument is the protocol and is NECESSARY (according to pybind11 docs)
def ReadDistributedModelPart(mdpa_file_name,
model_part,
importer_settings=None):
"""Reads mdpa file
This method reads mdpa file and fills given model_part accordingly using MPI
Args:
mdpa_file_name (str): Name of the mdpa file (without ".mdpa" extension)
model_part (Kratos.ModelPart): ModelPart to be filled
"""
from KratosMultiphysics.mpi import distributed_import_model_part_utility
model_part.AddNodalSolutionStepVariable(Kratos.PARTITION_INDEX)
if importer_settings is None:
importer_settings = Kratos.Parameters("""{
"model_import_settings": {
"input_type": "mdpa",
"input_filename": \"""" + mdpa_file_name + """\",
"partition_in_memory" : true
},
"echo_level" : 0
}""")
model_part_import_util = distributed_import_model_part_utility.DistributedImportModelPartUtility(
model_part, importer_settings)
model_part_import_util.ImportModelPart()
model_part_import_util.CreateCommunicators()
def test_trilinos_levelset_convection(self):
current_model = KratosMultiphysics.Model()
self.model_part = current_model.CreateModelPart("Main",2)
self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISTANCE)
self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.VELOCITY)
self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.PARTITION_INDEX)
# Import the model part, perform the partitioning and create communicators
import_settings = KratosMultiphysics.Parameters(self.parameters)
DistributedModelPartImporter = distributed_import_model_part_utility.DistributedImportModelPartUtility(self.model_part, import_settings)
DistributedModelPartImporter.ImportModelPart()
DistributedModelPartImporter.CreateCommunicators()
# Recall to set the buffer size
self.model_part.SetBufferSize(2)
# Set the initial distance field and the convection velocity
for node in self.model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.DISTANCE, 0, BaseDistance(node.X,node.Y,node.Z))
node.SetSolutionStepValue(KratosMultiphysics.VELOCITY, 0, ConvectionVelocity(node.X,node.Y,node.Z))
# Fix the left side values
for node in self.model_part.Nodes:
if node.X < 0.001:
node.Fix(KratosMultiphysics.DISTANCE)
# Set the Trilinos linear solver and Epetra communicator
trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
KratosMultiphysics.Parameters("""{"solver_type" : "amesos" }""")
)
epetra_comm = TrilinosApplication.CreateCommunicator()
# Fake time advance
self.model_part.CloneTimeStep(40.0)
# Convect the distance field
TrilinosApplication.TrilinosLevelSetConvectionProcess2D(
epetra_comm,
KratosMultiphysics.DISTANCE,
self.model_part,
trilinos_linear_solver).Execute()
# Check the obtained values
max_distance = -1.0
min_distance = +1.0
for node in self.model_part.Nodes:
d = node.GetSolutionStepValue(KratosMultiphysics.DISTANCE)
max_distance = max(max_distance, d)
min_distance = min(min_distance, d)
comm = self.model_part.GetCommunicator().GetDataCommunicator()
min_distance = comm.MinAll(min_distance)
max_distance = comm.MaxAll(max_distance)
self.assertAlmostEqual(max_distance, 0.7333041045431626)
self.assertAlmostEqual(min_distance,-0.06371359024393104)
def ImportModelPart(self):
# Construct the import model part utility
from KratosMultiphysics.mpi import distributed_import_model_part_utility
self.distributed_model_part_importer = distributed_import_model_part_utility.DistributedImportModelPartUtility(
self.main_model_part, self.settings)
## Execute the Metis partitioning and reading
self.distributed_model_part_importer.ImportModelPart()
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 testTrilinosRedistance(self):
# Set the model part
current_model = KratosMultiphysics.Model()
self.model_part = current_model.CreateModelPart("Main")
self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISTANCE)
self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.FLAG_VARIABLE)
self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.PARTITION_INDEX)
# Import the model part, perform the partitioning and create communicators
import_settings = KratosMultiphysics.Parameters(self.parameters)
ModelPartImporter = distributed_import_model_part_utility.DistributedImportModelPartUtility(self.model_part, import_settings)
ModelPartImporter.ImportModelPart()
ModelPartImporter.CreateCommunicators()
# Recall to set the buffer size
self.model_part.SetBufferSize(2)
# Initialize the DISTANCE values
for node in self.model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.DISTANCE,0, self._ExpectedDistance(node.X,node.Y,node.Z))
# Fake time advance
self.model_part.CloneTimeStep(1.0)
# Set the utility and compute the variational distance values
trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
KratosMultiphysics.Parameters("""{"solver_type" : "amesos" }""")
)
epetra_comm = TrilinosApplication.CreateCommunicator()
max_iterations = 2
TrilinosApplication.TrilinosVariationalDistanceCalculationProcess3D(
epetra_comm,
self.model_part,
trilinos_linear_solver,
max_iterations,
(KratosMultiphysics.VariationalDistanceCalculationProcess3D.CALCULATE_EXACT_DISTANCES_TO_PLANE).AsFalse()
).Execute()
# Check the obtained values
max_distance = -1.0
min_distance = +1.0
for node in self.model_part.Nodes:
d = node.GetSolutionStepValue(KratosMultiphysics.DISTANCE)
max_distance = max(max_distance, d)
min_distance = min(min_distance, d)
comm = self.model_part.GetCommunicator().GetDataCommunicator()
min_distance = comm.MinAll(min_distance)
max_distance = comm.MaxAll(max_distance)
self.assertAlmostEqual(max_distance, 0.44556526310761013) # Serial max_distance
self.assertAlmostEqual(min_distance,-0.504972246827639) # Serial min_distance
def testTrilinosParallelRedistance(self):
# Set the model part
current_model = KratosMultiphysics.Model()
self.model_part = current_model.CreateModelPart("Main")
self.model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.DISTANCE)
self.model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.NODAL_AREA)
self.model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.FLAG_VARIABLE)
self.model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.PARTITION_INDEX)
# Import the model part, perform the partitioning and create communicators
import_settings = KratosMultiphysics.Parameters(self.parameters)
ModelPartImporter = distributed_import_model_part_utility.DistributedImportModelPartUtility(
self.model_part, import_settings)
ModelPartImporter.ImportModelPart()
ModelPartImporter.CreateCommunicators()
# Recall to set the buffer size
self.model_part.SetBufferSize(2)
# Initialize the DISTANCE values
x_zero_dist = 0.0
for node in self.model_part.Nodes:
node.SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0,
self._ExpectedLinearDistance(node.X, x_zero_dist))
# Fake time advance
self.model_part.CloneTimeStep(1.0)
# Calculate NODAL_AREA
domain_size = 3
nodal_area_process = KratosMultiphysics.CalculateNodalAreaProcess(
self.model_part, domain_size)
nodal_area_process.Execute()
# Set the parallel distance calculator
max_levels = 10
max_distance = 100.0
distance_calculator = KratosMultiphysics.ParallelDistanceCalculator3D()
distance_calculator.CalculateDistances(
self.model_part, KratosMultiphysics.DISTANCE,
KratosMultiphysics.NODAL_AREA, max_levels, max_distance,
KratosMultiphysics.ParallelDistanceCalculator3D.
CALCULATE_EXACT_DISTANCES_TO_PLANE)
# Check the obtained values
for node in self.model_part.Nodes:
self.assertAlmostEqual(
node.GetSolutionStepValue(KratosMultiphysics.DISTANCE),
self._ExpectedLinearDistance(node.X, x_zero_dist), 10)
def ImportModelPart(self):
# Construct the import model part utility
ModelPartImporter = distributed_import_model_part_utility.DistributedImportModelPartUtility(self.main_model_part, self.settings)
# Execute the Metis partitioning and reading
ModelPartImporter.ExecutePartitioningAndReading()
# Create computing_model_part, set constitutive law and buffer size
self._ExecuteAfterReading()
# Construct the communicators
ModelPartImporter.CreateCommunicators()
def _ReadDistributedModelPart(self,model_part, mdpa_file_name):
importer_settings = KratosMultiphysics.Parameters("""{
"model_import_settings": {
"input_type": "mdpa",
"input_filename": \"""" + mdpa_file_name + """\",
"partition_in_memory" : false
},
"echo_level" : 0
}""")
model_part_import_util = distributed_import_model_part_utility.DistributedImportModelPartUtility(model_part, importer_settings)
model_part_import_util.ImportModelPart()
model_part_import_util.CreateCommunicators()
def ReadDistributedModelPart(model_part, mdpa_file_name):
from KratosMultiphysics.mpi import distributed_import_model_part_utility
model_part.AddNodalSolutionStepVariable(KM.PARTITION_INDEX)
importer_settings = KM.Parameters("""{
"model_import_settings": {
"input_type": "mdpa",
"input_filename": \"""" + mdpa_file_name + """\",
"partition_in_memory" : true
},
"echo_level" : 0
}""")
model_part_import_util = distributed_import_model_part_utility.DistributedImportModelPartUtility(
model_part, importer_settings)
model_part_import_util.ImportModelPart()
model_part_import_util.CreateCommunicators()
def test_trilinos_levelset_convection_BFECC(self):
current_model = KratosMultiphysics.Model()
self.model_part = current_model.CreateModelPart("Main",2)
self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISTANCE)
self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.VELOCITY)
self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.PARTITION_INDEX)
# Import the model part, perform the partitioning and create communicators
import_settings = KratosMultiphysics.Parameters(self.parameters)
DistributedModelPartImporter = distributed_import_model_part_utility.DistributedImportModelPartUtility(self.model_part, import_settings)
DistributedModelPartImporter.ImportModelPart()
DistributedModelPartImporter.CreateCommunicators()
# Recall to set the buffer size
self.model_part.SetBufferSize(2)
self.model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, 2)
# Set the initial distance field and the convection velocity
for node in self.model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.DISTANCE, BaseJumpedDistance(node.X,node.Y,node.Z))
node.SetSolutionStepValue(KratosMultiphysics.VELOCITY, ConvectionVelocity(node.X,node.Y,node.Z))
# Fix the left side values
for node in self.model_part.Nodes:
if node.X < 0.001:
node.Fix(KratosMultiphysics.DISTANCE)
# Set the Trilinos linear solver and Epetra communicator
trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
KratosMultiphysics.Parameters("""{"solver_type" : "amesos" }""")
)
epetra_comm = TrilinosApplication.CreateCommunicator()
comm = ParallelEnvironment.GetDefaultDataCommunicator()
#self.model_part.GetCommunicator().GetDataCommunicator()
# Fake time advance
self.model_part.CloneTimeStep(30.0)
#kratos_comm = KratosMultiphysics.DataCommunicator.GetDefault()
KratosMultiphysics.FindGlobalNodalNeighboursProcess(
comm, self.model_part).Execute()
KratosMultiphysics.ComputeNonHistoricalNodalGradientProcess(
self.model_part,
KratosMultiphysics.DISTANCE,
KratosMultiphysics.DISTANCE_GRADIENT,
KratosMultiphysics.NODAL_AREA).Execute()
levelset_convection_settings = KratosMultiphysics.Parameters("""{
"levelset_variable_name" : "DISTANCE",
"levelset_convection_variable_name" : "VELOCITY",
"levelset_gradient_variable_name" : "DISTANCE_GRADIENT",
"max_CFL" : 1.0,
"max_substeps" : 0,
"levelset_splitting" : false,
"eulerian_error_compensation" : true,
"cross_wind_stabilization_factor" : 0.7
}""")
TrilinosApplication.TrilinosLevelSetConvectionProcess2D(
epetra_comm,
self.model_part,
trilinos_linear_solver,
levelset_convection_settings).Execute()
max_distance = -1.0
min_distance = +1.0
for node in self.model_part.Nodes:
d = node.GetSolutionStepValue(KratosMultiphysics.DISTANCE)
max_distance = max(max_distance, d)
min_distance = min(min_distance, d)
min_distance = comm.MinAll(min_distance)
max_distance = comm.MaxAll(max_distance)
# gid_output = GiDOutputProcess(model_part,
# "levelset_test_2D",
# KratosMultiphysics.Parameters("""
# {
# "result_file_configuration" : {
# "gidpost_flags": {
# "GiDPostMode": "GiD_PostBinary",
# "WriteDeformedMeshFlag": "WriteUndeformed",
# "WriteConditionsFlag": "WriteConditions",
# "MultiFileFlag": "SingleFile"
# },
# "nodal_results" : ["DISTANCE","VELOCITY"]
# }
# }
# """)
# )
# gid_output.ExecuteInitialize()
# gid_output.ExecuteBeforeSolutionLoop()
# gid_output.ExecuteInitializeSolutionStep()
# gid_output.PrintOutput()
# gid_output.ExecuteFinalizeSolutionStep()
# gid_output.ExecuteFinalize()
self.assertAlmostEqual(max_distance, 1.0617777301844604)
self.assertAlmostEqual(min_distance, -0.061745786561321375)
