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)