def test_HDF5ModelPartIO(self): with ControlledExecutionScope( os.path.dirname(os.path.realpath(__file__))): write_model_part = ModelPart("write") KratosMetis.SetMPICommunicatorProcess(write_model_part).Execute() 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 = ModelPart("read") KratosMetis.SetMPICommunicatorProcess(read_model_part).Execute() hdf5_model_part_io.ReadModelPart(read_model_part) KratosTrilinos.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]) if KratosMPI.mpi.rank == 0: self._remove_file("test_hdf5_model_part_io_mpi.h5")
def get_communicator(self): if not hasattr(self, '_communicator'): self._communicator = TrilinosApplication.CreateCommunicator() return self._communicator
def Initialize(self): ## Construct the communicator self.EpetraCommunicator = KratosTrilinos.CreateCommunicator() ## Get the computing model part self.computing_model_part = self.GetComputingModelPart() KratosMultiphysics.NormalCalculationUtils().CalculateOnSimplex(self.computing_model_part, self.computing_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]) self.neighbour_search = KratosMultiphysics.FindNodalNeighboursProcess(self.computing_model_part) (self.neighbour_search).Execute() self.accelerationLimitationUtility = KratosMultiphysics.FluidDynamicsApplication.AccelerationLimitationUtilities(self.computing_model_part, 5.0) ## If needed, create the estimate time step utility if (self.settings["time_stepping"]["automatic_time_step"].GetBool()): self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility() # Set the time discretization utility to compute the BDF coefficients time_order = self.settings["time_order"].GetInt() if time_order == 2: self.time_discretization = KratosMultiphysics.TimeDiscretization.BDF(time_order) else: raise Exception("Only \"time_order\" equal to 2 is supported. Provided \"time_order\": " + str(time_order)) ## Creating the Trilinos convergence criteria self.conv_criteria = KratosTrilinos.TrilinosUPCriteria(self.settings["relative_velocity_tolerance"].GetDouble(), self.settings["absolute_velocity_tolerance"].GetDouble(), self.settings["relative_pressure_tolerance"].GetDouble(), self.settings["absolute_pressure_tolerance"].GetDouble()) (self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt()) #### ADDING NEW PROCESSES : level-set-convection and variational-distance-process self.level_set_convection_process = self._set_level_set_convection_process() self.variational_distance_process = self._set_variational_distance_process() ## Creating the Trilinos incremental update time scheme (the time integration is defined within the TwoFluidNavierStokes element) self.time_scheme = KratosTrilinos.TrilinosResidualBasedIncrementalUpdateStaticSchemeSlip(self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE], # Domain size (2,3) self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]+1) # DOFs (3,4) ## Set the guess_row_size (guess about the number of zero entries) for the Trilinos builder and solver if self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 3: guess_row_size = 20*4 elif self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2: guess_row_size = 10*3 ## Construct the Trilinos builder and solver if self.settings["consider_periodic_conditions"].GetBool() == True: self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolverPeriodic(self.EpetraCommunicator, guess_row_size, self.trilinos_linear_solver, KratosFluid.PATCH_INDEX) else: self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolver(self.EpetraCommunicator, guess_row_size, self.trilinos_linear_solver) ## Construct the Trilinos Newton-Raphson strategy self.solver = KratosTrilinos.TrilinosNewtonRaphsonStrategy(self.main_model_part, self.time_scheme, self.trilinos_linear_solver, self.conv_criteria, self.builder_and_solver, self.settings["maximum_iterations"].GetInt(), self.settings["compute_reactions"].GetBool(), self.settings["reform_dofs_at_each_step"].GetBool(), self.settings["move_mesh_flag"].GetBool()) (self.solver).SetEchoLevel(self.settings["echo_level"].GetInt()) (self.solver).Initialize() (self.solver).Check() self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DYNAMIC_TAU, self.settings["formulation"]["dynamic_tau"].GetDouble())
def _create_solution_scheme(self): return TrilinosApplication.TrilinosResidualBasedIncrementalUpdateStaticScheme()
def _GetEpetraCommunicator(self): if not hasattr(self, '_epetra_communicator'): self._epetra_communicator = KratosTrilinos.CreateEpetraCommunicator(self.main_model_part.GetCommunicator().GetDataCommunicator()) return self._epetra_communicator
def Initialize(self): ## Construct the communicator self.EpetraCommunicator = KratosTrilinos.CreateCommunicator() ## Get the computing model part self.computing_model_part = self.GetComputingModelPart() ## If needed, create the estimate time step utility if (self.settings["time_stepping"]["automatic_time_step"].GetBool()): self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility( ) ## Creating the Trilinos convergence criteria self.conv_criteria = KratosTrilinos.TrilinosUPCriteria( self.settings["relative_velocity_tolerance"].GetDouble(), self.settings["absolute_velocity_tolerance"].GetDouble(), self.settings["relative_pressure_tolerance"].GetDouble(), self.settings["absolute_pressure_tolerance"].GetDouble()) (self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt()) ## Creating the Trilinos time scheme if (self.element_integrates_in_time): # "Fake" scheme for those cases in where the element manages the time integration # It is required to perform the nodal update once the current time step is solved self.time_scheme = KratosTrilinos.TrilinosResidualBasedIncrementalUpdateStaticSchemeSlip( self.computing_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE], self.computing_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] + 1) # In case the BDF2 scheme is used inside the element, set the time discretization utility to compute the BDF coefficients if (self.settings["time_scheme"].GetString() == "bdf2"): time_order = self.settings["time_order"].GetInt() if time_order == 2: self.time_discretization = KratosMultiphysics.TimeDiscretization.BDF( time_order) else: raise Exception( "Only \"time_order\" equal to 2 is supported. Provided \"time_order\": " + str(time_order)) else: err_msg = "Requested elemental time scheme " + self.settings[ "time_scheme"].GetString() + " is not available.\n" err_msg += "Available options are: \"bdf2\"" raise Exception(err_msg) else: if (self.settings["turbulence_model"].GetString() == "None"): if self.settings["consider_periodic_conditions"].GetBool( ) == True: self.time_scheme = KratosTrilinos.TrilinosPredictorCorrectorVelocityBossakSchemeTurbulent( self.settings["alpha"].GetDouble(), self.computing_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE], KratosCFD.PATCH_INDEX) else: self.time_scheme = KratosTrilinos.TrilinosPredictorCorrectorVelocityBossakSchemeTurbulent( self.settings["alpha"].GetDouble(), self.settings["move_mesh_strategy"].GetInt(), self.computing_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE]) ## Set the guess_row_size (guess about the number of zero entries) for the Trilinos builder and solver if self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] == 3: guess_row_size = 20 * 4 elif self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] == 2: guess_row_size = 10 * 3 ## Construct the Trilinos builder and solver if self.settings["consider_periodic_conditions"].GetBool() == True: self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolverPeriodic( self.EpetraCommunicator, guess_row_size, self.trilinos_linear_solver, KratosCFD.PATCH_INDEX) else: self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolver( self.EpetraCommunicator, guess_row_size, self.trilinos_linear_solver) ## Construct the Trilinos Newton-Raphson strategy self.solver = KratosTrilinos.TrilinosNewtonRaphsonStrategy( self.main_model_part, self.time_scheme, self.trilinos_linear_solver, self.conv_criteria, self.builder_and_solver, self.settings["maximum_iterations"].GetInt(), self.settings["compute_reactions"].GetBool(), self.settings["reform_dofs_at_each_step"].GetBool(), self.settings["move_mesh_flag"].GetBool()) (self.solver).SetEchoLevel(self.settings["echo_level"].GetInt()) self.formulation.SetProcessInfo(self.computing_model_part) (self.solver).Initialize() KratosMultiphysics.Logger.Print( "Monolithic MPI solver initialization finished.")
def Initialize(self): ## Construct the communicator self.EpetraCommunicator = KratosTrilinos.CreateCommunicator() ## Get the computing model part self.computing_model_part = self.GetComputingModelPart() ## If needed, create the estimate time step utility if (self.settings["time_stepping"]["automatic_time_step"].GetBool()): self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility() ## Creating the Trilinos convergence criteria self.conv_criteria = KratosTrilinos.TrilinosUPCriteria(self.settings["relative_velocity_tolerance"].GetDouble(), self.settings["absolute_velocity_tolerance"].GetDouble(), self.settings["relative_pressure_tolerance"].GetDouble(), self.settings["absolute_pressure_tolerance"].GetDouble()) (self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt()) ## Creating the Trilinos time scheme if (self.settings["turbulence_model"].GetString() == "None"): if self.settings["consider_periodic_conditions"].GetBool() == True: self.time_scheme = KratosTrilinos.TrilinosPredictorCorrectorVelocityBossakSchemeTurbulent(self.settings["alpha"].GetDouble(), self.computing_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE], KratosCFD.PATCH_INDEX) else: self.time_scheme = KratosTrilinos.TrilinosPredictorCorrectorVelocityBossakSchemeTurbulent(self.settings["alpha"].GetDouble(), self.settings["move_mesh_strategy"].GetInt(), self.computing_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]) ## Set the guess_row_size (guess about the number of zero entries) for the Trilinos builder and solver if self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 3: guess_row_size = 20*4 elif self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2: guess_row_size = 10*3 ## Construct the Trilinos builder and solver if self.settings["consider_periodic_conditions"].GetBool() == True: self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolverPeriodic(self.EpetraCommunicator, guess_row_size, self.trilinos_linear_solver, KratosCFD.PATCH_INDEX) else: self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolver(self.EpetraCommunicator, guess_row_size, self.trilinos_linear_solver) ## Construct the Trilinos Newton-Raphson strategy self.solver = KratosTrilinos.TrilinosNewtonRaphsonStrategy(self.main_model_part, self.time_scheme, self.trilinos_linear_solver, self.conv_criteria, self.builder_and_solver, self.settings["maximum_iterations"].GetInt(), self.settings["compute_reactions"].GetBool(), self.settings["reform_dofs_at_each_step"].GetBool(), self.settings["move_mesh_flag"].GetBool()) (self.solver).SetEchoLevel(self.settings["echo_level"].GetInt()) self.formulation.SetProcessInfo(self.computing_model_part) (self.solver).Initialize() if self._IsPrintingRank(): #TODO: CHANGE THIS ONCE THE MPI LOGGER IS IMPLEMENTED KratosMultiphysics.Logger.Print("Monolithic MPI solver initialization finished.")
def TrilinosBlockBuilderAndSolver(linear_solver, communicator): return KratosTrilinos.TrilinosBlockBuilderAndSolver( communicator, 30, linear_solver)
def _GetEpetraCommunicator(self): if not hasattr(self, '_epetra_communicator'): self._epetra_communicator = TrilinosApplication.CreateCommunicator( ) return self._epetra_communicator
def _GetPartitionedFSIUtilities(self): if (self.domain_size == 2): return KratosTrilinos.TrilinosPartitionedFSIUtilities2D(self.epetra_communicator) else: return KratosTrilinos.TrilinosPartitionedFSIUtilities3D(self.epetra_communicator)
def TrilinosPeriodicBlockBuilderAndSolver(linear_solver, communicator): return KratosTrilinos.TrilinosBlockBuilderAndSolverPeriodic( communicator, 30, linear_solver, KratosCFD.PATCH_INDEX)
def __init__(self, convergence_criterion_parameters): # Note that all the convergence settings are introduced via a Kratos parameters object. D_RT = convergence_criterion_parameters[ "displacement_relative_tolerance"].GetDouble() D_AT = convergence_criterion_parameters[ "displacement_absolute_tolerance"].GetDouble() R_RT = convergence_criterion_parameters[ "residual_relative_tolerance"].GetDouble() R_AT = convergence_criterion_parameters[ "residual_absolute_tolerance"].GetDouble() convergence_crit = convergence_criterion_parameters[ "convergence_criterion"].GetString() echo_level = convergence_criterion_parameters["echo_level"].GetInt() rotation_dofs = False if convergence_criterion_parameters.Has("rotation_dofs"): rotation_dofs = convergence_criterion_parameters[ "rotation_dofs"].GetBool() volumetric_strain_dofs = False if convergence_criterion_parameters.Has("volumetric_strain_dofs"): volumetric_strain_dofs = convergence_criterion_parameters[ "volumetric_strain_dofs"].GetBool() if (echo_level >= 1): KratosMultiphysics.Logger.PrintInfo( "::[Mechanical Solver]::", "MPI CONVERGENCE CRITERION : " + convergence_criterion_parameters["convergence_criterion"]. GetString()) if (convergence_crit == "displacement_criterion"): if rotation_dofs: self.mechanical_convergence_criterion = TrilinosApplication.TrilinosMixedGenericCriteria( [(KratosMultiphysics.DISPLACEMENT, D_RT, D_AT), (KratosMultiphysics.ROTATION, D_RT, D_AT)]) elif volumetric_strain_dofs: self.mechanical_convergence_criterion = TrilinosApplication.TrilinosMixedGenericCriteria( [(KratosMultiphysics.DISPLACEMENT, D_RT, D_AT), (KratosMultiphysics.VOLUMETRIC_STRAIN, D_RT, D_AT)]) else: self.mechanical_convergence_criterion = TrilinosApplication.TrilinosDisplacementCriteria( D_RT, D_AT) self.mechanical_convergence_criterion.SetEchoLevel(echo_level) elif (convergence_crit == "residual_criterion"): self.mechanical_convergence_criterion = TrilinosApplication.TrilinosResidualCriteria( R_RT, R_AT) self.mechanical_convergence_criterion.SetEchoLevel(echo_level) elif (convergence_crit == "and_criterion"): Displacement = TrilinosApplication.TrilinosDisplacementCriteria( D_RT, D_AT) Displacement.SetEchoLevel(echo_level) Residual = TrilinosApplication.TrilinosResidualCriteria(R_RT, R_AT) Residual.SetEchoLevel(echo_level) self.mechanical_convergence_criterion = TrilinosApplication.TrilinosAndCriteria( Residual, Displacement) elif (convergence_crit == "or_criterion"): Displacement = TrilinosApplication.TrilinosDisplacementCriteria( D_RT, D_AT) Displacement.SetEchoLevel(echo_level) Residual = TrilinosApplication.TrilinosResidualCriteria(R_RT, R_AT) Residual.SetEchoLevel(echo_level) self.mechanical_convergence_criterion = TrilinosApplication.TrilinosOrCriteria( Residual, Displacement) else: err_msg = "The requested convergence criterion \"" + convergence_crit + "\" is not available!\n" err_msg += "Available options are: \"displacement_criterion\", \"residual_criterion\", \"and_criterion\", \"or_criterion\"" raise Exception(err_msg)
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 = KratosMPI.mpi.size my_pid = KratosMPI.mpi.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)) KratosTrilinos.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
def test_HDF5NodalSolutionStepDataIO(self): with ControlledExecutionScope( os.path.dirname(os.path.realpath(__file__))): write_model_part = ModelPart("write") KratosMetis.SetMPICommunicatorProcess(write_model_part).Execute() 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 = ModelPart("read") KratosMetis.SetMPICommunicatorProcess(read_model_part).Execute() hdf5_model_part_io.ReadModelPart(read_model_part) KratosTrilinos.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)) if KratosMPI.mpi.rank == 0: self._remove_file("test_hdf5_model_part_io_mpi.h5")
def test_trilinos_levelset_convection(self): self.model_part = KratosMultiphysics.ModelPart("Main") 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("""{ "echo_level" : 0, "model_import_settings" : { "input_type" : "mdpa", "input_filename" : "levelset_convection_process_mesh" } }""") import trilinos_import_model_part_utility TrilinosModelPartImporter = trilinos_import_model_part_utility.TrilinosImportModelPartUtility( self.model_part, import_settings) TrilinosModelPartImporter.ImportModelPart() TrilinosModelPartImporter.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 import trilinos_linear_solver_factory trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver( KratosMultiphysics.Parameters( """{"solver_type" : "AmesosSolver" }""")) 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) min_distance = self.model_part.GetCommunicator().MinAll(min_distance) max_distance = self.model_part.GetCommunicator().MaxAll(max_distance) self.assertAlmostEqual(max_distance, 0.7904255118014996) self.assertAlmostEqual(min_distance, -0.11710292469993094)
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.CreateEpetraCommunicator( KratosMultiphysics.DataCommunicator.GetDefault()) 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 _ExecuteAfterLoad(self): if self.set_mpi_communicator: KratosTrilinos.ParallelFillCommunicator( self.main_model_part.GetRootModelPart()).Execute()
def _CreateCuttingUtility(self): if not CheckIfApplicationsAvailable("TrilinosApplication"): raise Exception("Defining output cuts requires the TrilinosApplication, which appears to be unavailable.") self.epetra_comm = KratosTrilinos.CreateCommunicator() return KratosTrilinos.TrilinosCuttingApplication(self.epetra_comm)
def Initialize(self): # Construct the communicator self.EpetraCommunicator = TrilinosApplication.CreateCommunicator() # Set ProcessInfo variables self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.REFERENCE_TEMPERATURE, self.settings["reference_temperature"].GetDouble()) self.main_model_part.ProcessInfo.SetValue( KratosConvDiff.THETA, self.settings["thermal_solver_settings"] ["theta_scheme"].GetDouble()) # Get the computing model parts self.thermal_computing_model_part = self.main_model_part.GetSubModelPart( self.thermal_model_part_name) self.mechanical_computing_model_part = self.GetComputingModelPart() # Builder and solver creation thermal_builder_and_solver = self._ConstructBuilderAndSolver( self.settings["thermal_solver_settings"] ["block_builder"].GetBool(), self.thermal_linear_solver) mechanical_builder_and_solver = self._ConstructBuilderAndSolver( self.settings["mechanical_solver_settings"] ["block_builder"].GetBool(), self.mechanical_linear_solver) # Solution scheme creation thermal_scheme = TrilinosApplication.TrilinosResidualBasedIncrementalUpdateStaticScheme( ) mechanical_scheme = self._ConstructScheme( self.settings["mechanical_solver_settings"] ["scheme_type"].GetString(), self.settings["mechanical_solver_settings"] ["solution_type"].GetString()) # Get the convergence criterion convergence_criterion = self._ConstructConvergenceCriterion( self.settings["mechanical_solver_settings"] ["convergence_criterion"].GetString()) # Solver creation (Note: this could be TrilinosResidualBasedLinearStrategy, but there is no such strategy) self.Thermal_Solver = TrilinosApplication.TrilinosNewtonRaphsonStrategy( self.thermal_computing_model_part, thermal_scheme, self.thermal_linear_solver, convergence_criterion, thermal_builder_and_solver, self.settings["mechanical_solver_settings"] ["max_iteration"].GetInt(), self.settings["thermal_solver_settings"] ["compute_reactions"].GetBool(), self.settings["thermal_solver_settings"] ["reform_dofs_at_each_step"].GetBool(), self.settings["thermal_solver_settings"] ["move_mesh_flag"].GetBool()) self.Mechanical_Solver = self._ConstructSolver( mechanical_builder_and_solver, mechanical_scheme, convergence_criterion, self.settings["mechanical_solver_settings"] ["strategy_type"].GetString()) # Set echo_level self.Thermal_Solver.SetEchoLevel( self.settings["thermal_solver_settings"]["echo_level"].GetInt()) self.Mechanical_Solver.SetEchoLevel( self.settings["mechanical_solver_settings"]["echo_level"].GetInt()) # Check if everything is assigned correctly self.Thermal_Solver.Check() self.Mechanical_Solver.Check() print("Initialization MPI DamThermoMechanicSolver finished")
def _CreateEpetraCommunicator(self): return KratosTrilinos.CreateCommunicator()
def Initialize(self): ## Construct the communicator self.EpetraCommunicator = TrilinosApplication.CreateCommunicator() ## Get the computing model part self.computing_model_part = self.GetComputingModelPart() domain_size = self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] if self.settings["response_function_settings"][ "response_type"].GetString() == "drag": if (domain_size == 2): self.response_function = FluidDynamicsApplication.DragResponseFunction2D( self.settings["response_function_settings"] ["custom_settings"], self.main_model_part) elif (domain_size == 3): self.response_function = FluidDynamicsApplication.DragResponseFunction3D( self.settings["response_function_settings"] ["custom_settings"], self.main_model_part) else: raise Exception("Invalid DOMAIN_SIZE: " + str(domain_size)) else: raise Exception("invalid response_type: " + self.settings["response_function_settings"] ["response_type"].GetString()) self.sensitivity_builder = KratosMultiphysics.SensitivityBuilder( self.settings["sensitivity_settings"], self.main_model_part, self.response_function) if self.settings["scheme_settings"]["scheme_type"].GetString( ) == "bossak": self.time_scheme = TrilinosApplication.TrilinosResidualBasedAdjointBossakScheme( self.settings["scheme_settings"], self.response_function) elif self.settings["scheme_settings"]["scheme_type"].GetString( ) == "steady": self.time_scheme = TrilinosApplication.TrilinosResidualBasedAdjointSteadyScheme( self.response_function) else: raise Exception( "invalid scheme_type: " + self.settings["scheme_settings"]["scheme_type"].GetString()) if self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] == 3: guess_row_size = 20 * 4 elif self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] == 2: guess_row_size = 10 * 3 self.builder_and_solver = TrilinosApplication.TrilinosBlockBuilderAndSolver( self.EpetraCommunicator, guess_row_size, self.trilinos_linear_solver) self.solver = TrilinosApplication.TrilinosLinearStrategy( self.main_model_part, self.time_scheme, self.trilinos_linear_solver, self.builder_and_solver, False, False, False, False) (self.solver).SetEchoLevel(self.settings["echo_level"].GetInt()) (self.solver).Initialize() (self.response_function).Initialize() (self.sensitivity_builder).Initialize() self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.DYNAMIC_TAU, self.settings["dynamic_tau"].GetDouble()) self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.OSS_SWITCH, self.settings["oss_switch"].GetInt()) KratosMultiphysics.Logger.PrintInfo( self.__class__.__name__, "Monolithic MPI solver initialization finished.")
def Initialize(self): ## Construct the communicator self.EpetraCommunicator = KratosTrilinos.CreateCommunicator() ## Get the computing model part self.computing_model_part = self.GetComputingModelPart() ## If needed, create the estimate time step utility if (self.settings["time_stepping"]["automatic_time_step"].GetBool()): self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility( ) ## Creating the Trilinos convergence criteria self.conv_criteria = KratosTrilinos.TrilinosUPCriteria( self.settings["relative_velocity_tolerance"].GetDouble(), self.settings["absolute_velocity_tolerance"].GetDouble(), self.settings["relative_pressure_tolerance"].GetDouble(), self.settings["absolute_pressure_tolerance"].GetDouble()) (self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt()) ## Constructing the BDF process (time coefficients update) self.bdf_process = KratosMultiphysics.ComputeBDFCoefficientsProcess( self.computing_model_part, self.settings["time_order"].GetInt()) ## Creating the Trilinos incremental update time scheme (the time integration is defined within the embedded element) self.time_scheme = KratosTrilinos.TrilinosResidualBasedIncrementalUpdateStaticSchemeSlip( self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE], # Domain size (2,3) self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] + 1) # DOFs (3,4) ## Set the guess_row_size (guess about the number of zero entries) for the Trilinos builder and solver if self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] == 3: guess_row_size = 20 * 4 elif self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] == 2: guess_row_size = 10 * 3 ## Construct the Trilinos builder and solver if self.settings["consider_periodic_conditions"].GetBool() == True: self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolverPeriodic( self.EpetraCommunicator, guess_row_size, self.trilinos_linear_solver, KratosFluid.PATCH_INDEX) else: self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolver( self.EpetraCommunicator, guess_row_size, self.trilinos_linear_solver) ## Construct the Trilinos Newton-Raphson strategy self.solver = KratosTrilinos.TrilinosNewtonRaphsonStrategy( self.main_model_part, self.time_scheme, self.trilinos_linear_solver, self.conv_criteria, self.builder_and_solver, self.settings["maximum_iterations"].GetInt(), self.settings["compute_reactions"].GetBool(), self.settings["reform_dofs_at_each_step"].GetBool(), self.settings["move_mesh_flag"].GetBool()) (self.solver).SetEchoLevel(self.settings["echo_level"].GetInt()) (self.solver).Initialize() # For the primitive Ausas formulation, set the find nodal neighbours process # Recall that the Ausas condition requires the nodal neighbouts. if (self.settings["formulation"]["element_type"].GetString() == "embedded_ausas_navier_stokes"): number_of_avg_elems = 10 number_of_avg_nodes = 10 self.find_nodal_neighbours_process = KratosMultiphysics.FindNodalNeighboursProcess( self.GetComputingModelPart(), number_of_avg_elems, number_of_avg_nodes) if self._IsPrintingRank(): KratosMultiphysics.Logger.PrintInfo( "NavierStokesMPIEmbeddedMonolithicSolver", "Solver initialization finished.")
def _create_epetra_communicator(self): return TrilinosApplication.CreateCommunicator()
def test_trilinos_levelset_convection_BFECC(self): # 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.CreateEpetraCommunicator( KratosMultiphysics.DataCommunicator.GetDefault()) # Fake time advance self.model_part.CloneTimeStep(30.0) kratos_comm = KratosMultiphysics.DataCommunicator.GetDefault() KratosMultiphysics.FindGlobalNodalNeighboursProcess( kratos_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, "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 = kratos_comm.MinAll(min_distance) max_distance = kratos_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)
def _CreateConvergenceCriterion(self): convergence_criterion = KratosTrilinos.TrilinosMixedGenericCriteria( [(KratosMultiphysics.VELOCITY, self.settings["relative_velocity_tolerance"].GetDouble(), self.settings["absolute_velocity_tolerance"].GetDouble()), (KratosMultiphysics.PRESSURE, self.settings["relative_pressure_tolerance"].GetDouble(), self.settings["absolute_pressure_tolerance"].GetDouble())]) convergence_criterion.SetEchoLevel(self.settings["echo_level"].GetInt()) return convergence_criterion
def Initialize(self): ## Construct the communicator self.EpetraComm = KratosTrilinos.CreateCommunicator() ## Get the computing model part self.computing_model_part = self.GetComputingModelPart() ## If needed, create the estimate time step utility if (self.settings["time_stepping"]["automatic_time_step"].GetBool()): self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility( ) #TODO: next part would be much cleaner if we passed directly the parameters to the c++ if self.settings["consider_periodic_conditions"] == True: self.solver_settings = TrilinosFluid.TrilinosFractionalStepSettingsPeriodic( self.EpetraComm, self.computing_model_part, self.computing_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE], self.settings["time_order"].GetInt(), self.settings["use_slip_conditions"].GetBool(), self.settings["move_mesh_flag"].GetBool(), self.settings["reform_dofs_at_each_step]"].GetBool(), KratosFluid.PATCH_INDEX) else: self.solver_settings = TrilinosFluid.TrilinosFractionalStepSettings( self.EpetraComm, self.computing_model_part, self.computing_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE], self.settings["time_order"].GetInt(), self.settings["use_slip_conditions"].GetBool(), self.settings["move_mesh_flag"].GetBool(), self.settings["reform_dofs_at_each_step"].GetBool()) self.solver_settings.SetEchoLevel(self.settings["echo_level"].GetInt()) self.solver_settings.SetStrategy( TrilinosFluid.TrilinosStrategyLabel.Velocity, self.velocity_linear_solver, self.settings["velocity_tolerance"].GetDouble(), self.settings["maximum_velocity_iterations"].GetInt()) self.solver_settings.SetStrategy( TrilinosFluid.TrilinosStrategyLabel.Pressure, self.pressure_linear_solver, self.settings["pressure_tolerance"].GetDouble(), self.settings["maximum_pressure_iterations"].GetInt()) self.solver = TrilinosFluid.TrilinosFSStrategy( self.computing_model_part, self.solver_settings, self.settings["predictor_corrector"].GetBool(), KratosFluid.PATCH_INDEX) self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.DYNAMIC_TAU, self.settings["dynamic_tau"].GetDouble()) self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.OSS_SWITCH, self.settings["oss_switch"].GetInt()) (self.solver).Initialize() KratosMultiphysics.Logger.PrintInfo( "TrilinosNavierStokesSolverFractionalStep", "Initialization TrilinosNavierStokesSolverFractionalStep finished")
def testTrilinosRedistance(self): # Set the model part self.model_part = KratosMultiphysics.ModelPart("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("""{ "echo_level" : 0, "model_import_settings" : { "input_type" : "mdpa", "input_filename" : "coarse_sphere" } }""") import trilinos_import_model_part_utility TrilinosModelPartImporter = trilinos_import_model_part_utility.TrilinosImportModelPartUtility( self.model_part, import_settings) TrilinosModelPartImporter.ExecutePartitioningAndReading() TrilinosModelPartImporter.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 import trilinos_linear_solver_factory trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver( KratosMultiphysics.Parameters( """{"solver_type" : "AmesosSolver" }""")) epetra_comm = TrilinosApplication.CreateCommunicator() max_iterations = 2 TrilinosApplication.TrilinosVariationalDistanceCalculationProcess3D( epetra_comm, self.model_part, trilinos_linear_solver, max_iterations).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) min_distance = self.model_part.GetCommunicator().MinAll(min_distance) max_distance = self.model_part.GetCommunicator().MaxAll(max_distance) self.assertAlmostEqual(max_distance, 0.44556526310761013) # Serial max_distance self.assertAlmostEqual(min_distance, -0.504972246827639) # Serial min_distance
def _ExecuteAfterLoad(self): if self.set_mpi_communicator: import KratosMultiphysics.TrilinosApplication as KratosTrilinos KratosTrilinos.ParallelFillCommunicator( self.main_model_part.GetRootModelPart()).Execute()
def _GetEpetraCommunicator(self): if not hasattr(self, '_epetra_communicator'): self._epetra_communicator = KratosTrilinos.CreateCommunicator() return self._epetra_communicator
def ImportModelPart(self): if (self.settings["model_import_settings"]["input_type"].GetString() == "mdpa"): # here we read the already existing partitions from the primal solution. input_filename = self.settings["model_import_settings"][ "input_filename"].GetString() mpi_input_filename = input_filename + "_" + str(KratosMPI.mpi.rank) self.settings["model_import_settings"]["input_filename"].SetString( mpi_input_filename) KratosMultiphysics.ModelPartIO(mpi_input_filename).ReadModelPart( self.main_model_part) # here we shall check that the input read has the shape we like aux_params = KratosMultiphysics.Parameters("{}") aux_params.AddValue("volume_model_part_name", self.settings["volume_model_part_name"]) aux_params.AddValue("skin_parts", self.settings["skin_parts"]) # here we replace the dummy elements we read with proper elements self.settings.AddEmptyValue("element_replace_settings") if (self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] == 3): self.settings[ "element_replace_settings"] = KratosMultiphysics.Parameters( """ { "element_name": "VMSAdjointElement3D", "condition_name": "SurfaceCondition3D3N" } """) elif (self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] == 2): self.settings[ "element_replace_settings"] = KratosMultiphysics.Parameters( """ { "element_name": "VMSAdjointElement2D", "condition_name": "LineCondition2D2N" } """) else: raise Exception("domain size is not 2 nor 3") KratosMultiphysics.ReplaceElementsAndConditionsProcess( self.main_model_part, self.settings["element_replace_settings"]).Execute() import check_and_prepare_model_process_fluid check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess( self.main_model_part, aux_params).Execute() # here we read the KINEMATIC VISCOSITY and DENSITY and we apply it to the nodes for el in self.main_model_part.Elements: rho = el.Properties.GetValue(KratosMultiphysics.DENSITY) kin_viscosity = el.Properties.GetValue( KratosMultiphysics.VISCOSITY) break KratosMultiphysics.VariableUtils().SetScalarVar( KratosMultiphysics.DENSITY, rho, self.main_model_part.Nodes) KratosMultiphysics.VariableUtils().SetScalarVar( KratosMultiphysics.VISCOSITY, kin_viscosity, self.main_model_part.Nodes) else: raise Exception("Other input options are not yet implemented.") current_buffer_size = self.main_model_part.GetBufferSize() if (self.GetMinimumBufferSize() > current_buffer_size): self.main_model_part.SetBufferSize(self.GetMinimumBufferSize()) MetisApplication.SetMPICommunicatorProcess( self.main_model_part).Execute() ParallelFillCommunicator = TrilinosApplication.ParallelFillCommunicator( self.main_model_part.GetRootModelPart()) ParallelFillCommunicator.Execute() if KratosMPI.mpi.rank == 0: print("MPI communicators constructed.") print("MPI model reading finished.")