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 get_communicator(self): if not hasattr(self, '_communicator'): self._communicator = TrilinosApplication.CreateCommunicator() return self._communicator
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.7904255118014996) self.assertAlmostEqual(min_distance, -0.11710292469993094)
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 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, 10, 10) (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 _GetEpetraCommunicator(self): if not hasattr(self, '_epetra_communicator'): self._epetra_communicator = KratosTrilinos.CreateCommunicator() return self._epetra_communicator
def _create_epetra_communicator(self): return TrilinosApplication.CreateCommunicator()
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) KratosMultiphysics.Logger.PrintInfo( "NavierStokesMPIEmbeddedMonolithicSolver", "Solver initialization finished.")
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._get_automatic_time_stepping_utility( ) #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 = KratosTrilinos.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 = KratosTrilinos.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( KratosTrilinos.TrilinosStrategyLabel.Velocity, self.velocity_linear_solver, self.settings["velocity_tolerance"].GetDouble(), self.settings["maximum_velocity_iterations"].GetInt()) self.solver_settings.SetStrategy( KratosTrilinos.TrilinosStrategyLabel.Pressure, self.pressure_linear_solver, self.settings["pressure_tolerance"].GetDouble(), self.settings["maximum_pressure_iterations"].GetInt()) self.solver = KratosTrilinos.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() (self.solver).Check() if self._IsPrintingRank(): #TODO: CHANGE THIS ONCE THE MPI LOGGER IS IMPLEMENTED KratosMultiphysics.Logger.PrintInfo( "TrilinosNavierStokesSolverFractionalStep", "Initialization TrilinosNavierStokesSolverFractionalStep 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() (self.solver).Check() self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.DYNAMIC_TAU, self.settings["dynamic_tau"].GetDouble())
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("""{ "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.ImportModelPart() 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 _CreateEpetraCommunicator(self): return KratosTrilinos.CreateCommunicator()
def _GetEpetraCommunicator(self): if not hasattr(self, '_epetra_communicator'): self._epetra_communicator = TrilinosApplication.CreateCommunicator( ) return self._epetra_communicator