def __init__(self, model, custom_settings): # Note: deliberately calling the constructor of the base python solver (the parent of my parent) super( navier_stokes_solver_fractionalstep. NavierStokesSolverFractionalStep, self).__init__(model, custom_settings) self.element_name = "FractionalStep" self.condition_name = "WallCondition" self.min_buffer_size = 3 self._is_printing_rank = (KratosMPI.mpi.rank == 0) ## Construct the linear solvers import trilinos_linear_solver_factory self.pressure_linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["pressure_linear_solver_settings"]) self.velocity_linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["velocity_linear_solver_settings"]) self.compute_reactions = self.settings["compute_reactions"].GetBool() if self._IsPrintingRank(): #TODO: CHANGE THIS ONCE THE MPI LOGGER IS IMPLEMENTED KratosMultiphysics.Logger.PrintInfo( "TrilinosNavierStokesSolverFractionalStep", "Construction of TrilinosNavierStokesSolverFractionalStep solver finished." )
def CreateSolver(model_part, config): fluid_solver = IncompressibleFluidSolver(model_part, config.domain_size) # default settings fluid_solver.vel_toll = config.vel_toll if(hasattr(config, "vel_toll")): fluid_solver.vel_toll = config.vel_toll if(hasattr(config, "press_toll")): fluid_solver.press_toll = config.press_toll if(hasattr(config, "max_vel_its")): fluid_solver.max_vel_its = config.max_vel_its if(hasattr(config, "max_press_its")): fluid_solver.max_press_its = config.max_press_its if(hasattr(config, "time_order")): fluid_solver.time_order = config.time_order if(hasattr(config, "compute_reactions")): fluid_solver.compute_reactions = config.compute_reactions if(hasattr(config, "ReformDofAtEachIteration")): fluid_solver.ReformDofAtEachIteration = config.ReformDofAtEachIteration if(hasattr(config, "predictor_corrector")): fluid_solver.predictor_corrector = config.predictor_corrector if(hasattr(config, "echo_level")): fluid_solver.echo_level = config.echo_level if(hasattr(config, "dynamic_tau")): fluid_solver.dynamic_tau = config.dynamic_tau # linear solver settings import trilinos_linear_solver_factory if(hasattr(config, "pressure_linear_solver_config")): fluid_solver.pressure_linear_solver = trilinos_linear_solver_factory.ConstructSolver( config.pressure_linear_solver_config) if(hasattr(config, "velocity_linear_solver_config")): fluid_solver.velocity_linear_solver = trilinos_linear_solver_factory.ConstructSolver( config.velocity_linear_solver_config) if(hasattr(config, "divergence_cleareance_step")): fluid_solver.divergence_clearance_steps = config.divergence_cleareance_step # RANS or DES settings if hasattr(config, "TurbulenceModel"): if config.TurbulenceModel == "Spalart-Allmaras": fluid_solver.use_spalart_allmaras = True elif config.TurbulenceModel == "Smagorinsky-Lilly": if hasattr(config, "SmagorinskyConstant"): fluid_solver.activate_smagorinsky(config.SmagorinskyConstant) else: msg = """Fluid solver error: Smagorinsky model requested, but the value for the Smagorinsky constant is undefined.""" raise Exception(msg) return fluid_solver
def testTrilinosRedistance(self): # Set the model part current_model = KratosMultiphysics.Model() self.model_part = current_model.CreateModelPart( "RedistanceCalculationPart") 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) 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 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 __init__(self, model, custom_settings): # Note: deliberately calling the constructor of the base python solver (the parent of my parent) super( navier_stokes_embedded_solver.NavierStokesEmbeddedMonolithicSolver, self).__init__(model, custom_settings) self.element_name = "EmbeddedNavierStokes" self.condition_name = "NavierStokesWallCondition" self.min_buffer_size = 3 self._is_printing_rank = (KratosMPI.mpi.rank == 0) # TODO: Remove this once we finish the new implementations if (self.settings["solver_type"].GetString() == "EmbeddedDevelopment"): self.element_name = "EmbeddedSymbolicNavierStokes" ## Construct the linear solver import trilinos_linear_solver_factory self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) if self._IsPrintingRank(): KratosMultiphysics.Logger.PrintInfo( "NavierStokesMPIEmbeddedMonolithicSolver", "Construction of NavierStokesMPIEmbeddedMonolithicSolver finished." )
def __init__(self, main_model_part, custom_settings): #TODO: shall obtain the computing_model_part from the MODEL once the object is implemented self.main_model_part = main_model_part ##settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "trilinos_structural_mechanics_implicit_dynamic_solver", "echo_level": 0, "buffer_size": 2, "solution_type": "Dynamic", "time_integration_method": "Implicit", "scheme_type": "Newmark", "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name", "input_file_label": 0 }, "rotation_dofs": false, "pressure_dofs": false, "stabilization_factor": 1.0, "reform_dofs_at_each_step": false, "line_search": false, "implex": false, "compute_reactions": false, "compute_contact_forces": false, "block_builder": true, "clear_storage": false, "component_wise": false, "move_mesh_flag": true, "convergence_criterion": "Residual_criteria", "displacement_relative_tolerance": 1.0e-4, "displacement_absolute_tolerance": 1.0e-9, "residual_relative_tolerance": 1.0e-4, "residual_absolute_tolerance": 1.0e-9, "max_iteration": 10, "linear_solver_settings":{ "solver_type" : "Klu", "scaling": false }, "bodies_list": [], "problem_domain_sub_model_part_list": ["solid_model_part"], "processes_sub_model_part_list": [""] } """) ##overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) #construct the linear solver import trilinos_linear_solver_factory self.linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) print("Construction of Implicit Mechanical MPI Solver finished")
def __init__(self, model, custom_settings): super(AdjointVMSMonolithicSolver, self).__init__(model, custom_settings) self.element_name = "VMSAdjointElement" if self.settings["domain_size"].GetInt() == 2: self.condition_name = "LineCondition" elif self.settings["domain_size"].GetInt() == 3: self.condition_name = "SurfaceCondition" self.min_buffer_size = 2 # construct the linear solver import trilinos_linear_solver_factory self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"]) KratosMultiphysics.Logger.PrintInfo(self.__class__.__name__, "Construction of AdjointVMSMonolithicMPISolver finished.")
def CreateSolver(model_part, config): fluid_solver = MonolithicSolver(model_part, config.domain_size) if(hasattr(config, "alpha")): fluid_solver.alpha = config.alpha # definition of the convergence criteria if(hasattr(config, "velocity_relative_tolerance")): fluid_solver.rel_vel_tol = config.velocity_relative_tolerance if(hasattr(config, "velocity_absolute_tolerance")): fluid_solver.abs_vel_tol = config.velocity_absolute_tolerance if(hasattr(config, "pressure_relative_tolerance")): fluid_solver.rel_pres_tol = config.pressure_relative_tolerance if(hasattr(config, "pressure_absolute_tolerance")): fluid_solver.abs_pres_tol = config.pressure_absolute_tolerance if(hasattr(config, "dynamic_tau")): fluid_solver.dynamic_tau = config.dynamic_tau if(hasattr(config, "oss_switch")): fluid_solver.oss_switch = config.oss_switch if(hasattr(config, "max_iteration")): fluid_solver.max_iter = config.max_iteration if(hasattr(config, "echo_level")): fluid_solver.echo_level = config.echo_level if(hasattr(config, "compute_reactions")): fluid_solver.compute_reactions = config.compute_reactions if(hasattr(config, "ReformDofSetAtEachStep")): fluid_solver.ReformDofSetAtEachStep = config.ReformDofSetAtEachStep if(hasattr(config, "divergence_cleareance_step")): fluid_solver.divergence_clearance_steps = config.divergence_cleareance_step import trilinos_linear_solver_factory if(hasattr(config, "linear_solver_config")): fluid_solver.linear_solver = trilinos_linear_solver_factory.ConstructSolver( config.linear_solver_config) if hasattr(config, "TurbulenceModel"): if config.TurbulenceModel == "Spalart-Allmaras": fluid_solver.use_spalart_allmaras = True elif config.TurbulenceModel == "Smagorinsky-Lilly": if hasattr(config, "SmagorinskyConstant"): fluid_solver.activate_smagorinsky(config.SmagorinskyConstant) else: msg = """Fluid solver error: Smagorinsky model requested, but the value for the Smagorinsky constant is undefined.""" raise Exception(msg) return fluid_solver
def __init__(self, model, custom_settings): # Note: deliberately calling the constructor of the base python solver (the parent of my parent) super(navier_stokes_embedded_solver.NavierStokesEmbeddedMonolithicSolver, self).__init__(model,custom_settings) self._is_printing_rank = (KratosMPI.mpi.rank == 0) self.min_buffer_size = 3 self.embedded_formulation = navier_stokes_embedded_solver.EmbeddedFormulation(self.settings["formulation"]) self.element_name = self.embedded_formulation.element_name self.condition_name = self.embedded_formulation.condition_name ## Construct the linear solver import trilinos_linear_solver_factory self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"]) if self._IsPrintingRank(): KratosMultiphysics.Logger.PrintInfo("NavierStokesMPIEmbeddedMonolithicSolver","Construction of NavierStokesMPIEmbeddedMonolithicSolver finished.")
def __init__(self, model, custom_settings): self._is_printing_rank = (KratosMPI.mpi.rank == 0) # Note: deliberately calling the constructor of the base python solver (the parent of my parent) super(navier_stokes_solver_vmsmonolithic.NavierStokesSolverMonolithic, self).__init__(model,custom_settings) self.formulation = navier_stokes_solver_vmsmonolithic.StabilizedFormulation(self.settings["formulation"]) self.element_name = self.formulation.element_name self.condition_name = self.formulation.condition_name self.min_buffer_size = 2 ## Construct the linear solver import trilinos_linear_solver_factory self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"]) if self._IsPrintingRank(): #TODO: CHANGE THIS ONCE THE MPI LOGGER IS IMPLEMENTED KratosMultiphysics.Logger.Print("Construction of TrilinosNavierStokesSolverMonolithic finished.")
def __init__(self, model, custom_settings): # Note: deliberately calling the constructor of the base python solver (the parent of my parent) super(navier_stokes_solver_vmsmonolithic.NavierStokesSolverMonolithic, self).__init__(model, custom_settings) self.formulation = navier_stokes_solver_vmsmonolithic.StabilizedFormulation( self.settings["formulation"]) self.element_name = self.formulation.element_name self.condition_name = self.formulation.condition_name self.min_buffer_size = 2 ## Construct the linear solver import trilinos_linear_solver_factory self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) KratosMultiphysics.Logger.Print( "Construction of TrilinosNavierStokesSolverMonolithic finished.")
def __init__(self, model, custom_settings): super(AdjointVMSMonolithicSolver, self).__init__(model, custom_settings) # There is only a single rank in OpenMP, we always print self._is_printing_rank = (KratosMPI.mpi.rank == 0) self.element_name = "VMSAdjointElement" if self.settings["domain_size"].GetInt() == 2: self.condition_name = "LineCondition" elif self.settings["domain_size"].GetInt() == 3: self.condition_name = "SurfaceCondition" self.min_buffer_size = 2 # construct the linear solver import trilinos_linear_solver_factory self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"]) if self._IsPrintingRank(): KratosMultiphysics.Logger.PrintInfo(self.__class__.__name__, "Construction of AdjointVMSMonolithicMPISolver finished.")
def __init__(self, model, custom_settings): # the constructor of the "grand-parent" (jumping constructor of parent) is called to avoid conflicts in attribute settings super(navier_stokes_two_fluids_solver.NavierStokesTwoFluidsSolver, self).__init__(model, custom_settings) self.element_name = "TwoFluidNavierStokes" self.condition_name = "NavierStokesWallCondition" self.min_buffer_size = 3 if (self.settings["solver_type"].GetString() == "TwoFluids"): self.element_name = "TwoFluidNavierStokes" ## Construct the linear solver import trilinos_linear_solver_factory self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) KratosMultiphysics.Logger.PrintInfo( "NavierStokesMPITwoFluidsSolver", "Construction of NavierStokesMPITwoFluidsSolver finished.")
def __init__(self, main_model_part, custom_settings): self.main_model_part = main_model_part # default settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "trilinos_adjoint_vmsmonolithic_solver", "scheme_settings" : { "scheme_type": "bossak" }, "response_function_settings" : { "response_type" : "drag" }, "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "linear_solver_settings" : { "solver_type" : "MultiLevelSolver" }, "volume_model_part_name" : "volume_model_part", "skin_parts": [""], "dynamic_tau": 0.0, "oss_switch": 0, "echo_level": 0 }""") # overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) # construct the linear solver import trilinos_linear_solver_factory self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) if KratosMPI.mpi.rank == 0: print("Construction of AdjointVMSMonolithicMPISolver finished.")
def __init__(self, main_model_part, custom_settings): #TODO: shall obtain the computing_model_part from the MODEL once the object is implemented self.main_model_part = main_model_part ##settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "dam_MPI_mechanical_solver", "model_import_settings":{ "input_type": "mdpa", "input_filename": "unknown_name", "input_file_label": 0 }, "buffer_size": 2, "echo_level": 0, "processes_sub_model_part_list": [""], "mechanical_solver_settings":{ "echo_level": 0, "reform_dofs_at_each_step": false, "clear_storage": false, "compute_reactions": false, "move_mesh_flag": true, "solution_type": "Quasi-Static", "scheme_type": "Newmark", "rayleigh_m": 0.0, "rayleigh_k": 0.0, "strategy_type": "Newton-Raphson", "convergence_criterion": "Displacement_criterion", "displacement_relative_tolerance": 1.0e-4, "displacement_absolute_tolerance": 1.0e-9, "residual_relative_tolerance": 1.0e-4, "residual_absolute_tolerance": 1.0e-9, "max_iteration": 15, "desired_iterations": 4, "max_radius_factor": 20.0, "min_radius_factor": 0.5, "block_builder": true, "nonlocal_damage": false, "characteristic_length": 0.05, "search_neighbours_step": false, "linear_solver_settings":{ "solver_type": "AMGCL", "tolerance": 1.0e-6, "max_iteration": 100, "scaling": false, "verbosity": 0, "preconditioner_type": "ILU0Preconditioner", "smoother_type": "ilu0", "krylov_type": "gmres", "coarsening_type": "aggregation" }, "problem_domain_sub_model_part_list": [""], "body_domain_sub_model_part_list": [], "mechanical_loads_sub_model_part_list": [], "loads_sub_model_part_list": [], "loads_variable_list": [] } } """) # Overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) # Construct the linear solver import trilinos_linear_solver_factory self.linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["mechanical_solver_settings"] ["linear_solver_settings"]) print("Construction of Dam_MPI_MechanicalSolver finished")
def _ConstructLinearSolver(self): import trilinos_linear_solver_factory linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) return linear_solver
def _auxiliary_test_function(self, settings, matrix_name="A.mm", absolute_norm=False): comm = KratosMultiphysics.TrilinosApplication.CreateCommunicator() space = KratosMultiphysics.TrilinosApplication.TrilinosSparseSpace() #read the matrices pA = space.ReadMatrixMarketMatrix(GetFilePath(matrix_name), comm) n = space.Size1(pA.GetReference()) pAoriginal = space.ReadMatrixMarketMatrix(GetFilePath(matrix_name), comm) pb = space.CreateEmptyVectorPointer(comm) space.ResizeVector(pb, n) space.SetToZeroVector(pb.GetReference()) space.SetValue(pb.GetReference(), 0, 1.0) #pb[1] = 1.0 px = space.CreateEmptyVectorPointer(comm) space.ResizeVector(px, n) pboriginal = space.CreateEmptyVectorPointer(comm) #create a copy of b space.ResizeVector(pboriginal, n) space.SetToZeroVector(pboriginal.GetReference()) space.UnaliasedAdd(pboriginal.GetReference(), 1.0, pb.GetReference()) space.SetToZeroVector(px.GetReference()) #space.SetToZeroVector(boriginal) #space.UnaliasedAdd(boriginal, 1.0, b) #boriginal=1*bs #construct the solver import trilinos_linear_solver_factory linear_solver = trilinos_linear_solver_factory.ConstructSolver( settings) #solve linear_solver.Solve(pA.GetReference(), px.GetReference(), pb.GetReference()) #test the results ptmp = space.CreateEmptyVectorPointer(comm) space.ResizeVector(ptmp, n) space.SetToZeroVector(ptmp.GetReference()) space.Mult(pAoriginal.GetReference(), px.GetReference(), ptmp.GetReference()) pcheck = space.CreateEmptyVectorPointer(comm) space.ResizeVector(pcheck, n) space.SetToZeroVector(pcheck.GetReference()) space.UnaliasedAdd(pcheck.GetReference(), 1.0, pboriginal.GetReference()) space.UnaliasedAdd(pcheck.GetReference(), -1.0, ptmp.GetReference()) achieved_norm = space.TwoNorm(pcheck.GetReference()) tolerance = 1e-9 if (settings.Has("tolerance")): tolerance = settings["tolerance"].GetDouble() nproc = KratosMultiphysics.mpi.mpi.size target_norm = tolerance * space.TwoNorm( pboriginal.GetReference() ) * nproc #multiplying by nproc the target tolerance to give some slack. Not really nice :-( if (achieved_norm > target_norm): print("target_norm :", target_norm) print("achieved_norm :", achieved_norm) self.assertTrue(achieved_norm <= target_norm) #destroy the preconditioner - this is needed since the solver should be destroyed before the destructor of the system matrix is called del linear_solver
def __init__(self, main_model_part, custom_settings): self.element_name = "FractionalStep" self.condition_name = "WallCondition" self.min_buffer_size = 3 self._is_printing_rank = (KratosMPI.mpi.rank == 0) #TODO: shall obtain the compute_model_part from the MODEL once the object is implemented self.main_model_part = main_model_part ## Default settings string in Json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "FractionalStep", "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "predictor_corrector": false, "maximum_velocity_iterations": 3, "maximum_pressure_iterations": 3, "velocity_tolerance": 1e-3, "pressure_tolerance": 1e-2, "dynamic_tau": 0.01, "oss_switch": 0, "echo_level": 0, "consider_periodic_conditions": false, "time_order": 2, "compute_reactions": false, "reform_dofs_at_each_step": false, "pressure_linear_solver_settings": { "solver_type" : "MultiLevelSolver", "max_iteration" : 200, "tolerance" : 1e-6, "symmetric" : true, "scaling" : true, "reform_preconditioner_at_each_step" : true, "verbosity" : 0 }, "velocity_linear_solver_settings": { "solver_type" : "MultiLevelSolver", "max_iteration" : 200, "tolerance" : 1e-6, "symmetric" : false, "scaling" : true, "reform_preconditioner_at_each_step" : true, "verbosity" : 0 }, "volume_model_part_name" : "volume_model_part", "skin_parts":[""], "no_skin_parts":[""], "time_stepping": { "automatic_time_step" : true, "CFL_number" : 1, "minimum_delta_time" : 1e-4, "maximum_delta_time" : 0.01 }, "move_mesh_flag": false, "use_slip_conditions": true }""") ## Overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) ## Construct the linear solvers import trilinos_linear_solver_factory self.pressure_linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["pressure_linear_solver_settings"]) self.velocity_linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["velocity_linear_solver_settings"]) self.compute_reactions = self.settings["compute_reactions"].GetBool() if self._IsPrintingRank(): #TODO: CHANGE THIS ONCE THE MPI LOGGER IS IMPLEMENTED KratosMultiphysics.Logger.PrintInfo( "TrilinosNavierStokesSolverFractionalStep", "Construction of TrilinosNavierStokesSolverFractionalStep solver finished." )
def _create_linear_solver(self): import trilinos_linear_solver_factory linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["mesh_motion_linear_solver_settings"]) return linear_solver
def __init__(self, main_model_part, custom_settings): #TODO: shall obtain the compute_model_part from the MODEL once the object is implemented self.main_model_part = main_model_part ## Default settings string in Json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "trilinos_navier_stokes_solver_fractionalstep", "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "predictor_corrector": false, "maximum_velocity_iterations": 3, "maximum_pressure_iterations": 3, "velocity_tolerance": 1e-3, "pressure_tolerance": 1e-2, "dynamic_tau": 0.01, "oss_switch": 0, "echo_level": 0, "consider_periodic_conditions": false, "time_order": 2, "compute_reactions": false, "reform_dofs_at_each_step": false, "pressure_linear_solver_settings": { "solver_type" : "MultiLevelSolver", "max_iteration" : 200, "tolerance" : 1e-6, "symmetric" : true, "scaling" : true, "reform_preconditioner_at_each_step" : true, "verbosity" : 0 }, "velocity_linear_solver_settings": { "solver_type" : "MultiLevelSolver", "max_iteration" : 200, "tolerance" : 1e-6, "symmetric" : false, "scaling" : true, "reform_preconditioner_at_each_step" : true, "verbosity" : 0 }, "volume_model_part_name" : "volume_model_part", "skin_parts":[""], "no_skin_parts":[""], "time_stepping": { "automatic_time_step" : true, "CFL_number" : 1, "minimum_delta_time" : 1e-4, "maximum_delta_time" : 0.01 }, "move_mesh_flag": false, "use_slip_conditions": true }""") ## Overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) self.compute_reactions = self.settings["compute_reactions"].GetBool() ## Construct the linear solvers import trilinos_linear_solver_factory self.settings["pressure_linear_solver_settings"].PrettyPrintJsonString( ) self.pressure_linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["pressure_linear_solver_settings"]) self.velocity_linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["velocity_linear_solver_settings"]) ## Set the element replace settings if main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2: default_element = "FractionalStep2D3N" default_condition = "WallCondition2D2N" elif main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 3: default_element = "FractionalStep3D4N" default_condition = "WallCondition3D3N" else: Msg = 'Trilinos_NavierStokesSolver_FractionalStep Error:\n' Msg += 'Unsupported number of dimensions: {0}\n'.format( main_model_part.ProcessInfo[DOMAIN_SIZE]) raise Exception(Msg) self.settings.AddEmptyValue("element_replace_settings") self.settings["element_replace_settings"].AddEmptyValue("element_name") self.settings["element_replace_settings"]["element_name"].SetString( default_element) self.settings["element_replace_settings"].AddEmptyValue( "condition_name") self.settings["element_replace_settings"]["condition_name"].SetString( default_condition) print( "Construction of Trilinos_NavierStokesSolver_FractionalStep finished" )
def __init__(self, main_model_part, custom_settings): self.element_name = "VMS" self.condition_name = "MonolithicWallCondition" self.min_buffer_size = 2 self._is_printing_rank = (KratosMPI.mpi.rank == 0) #TODO: shall obtain the compute_model_part from the MODEL once the object is implemented self.main_model_part = main_model_part ## Default settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "trilinos_navier_stokes_solver_vmsmonolithic", "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "maximum_iterations": 10, "dynamic_tau": 0.01, "oss_switch": 0, "echo_level": 0, "consider_periodic_conditions": false, "time_order": 2, "compute_reactions": false, "reform_dofs_at_each_step": false, "relative_velocity_tolerance": 1e-5, "absolute_velocity_tolerance": 1e-7, "relative_pressure_tolerance": 1e-5, "absolute_pressure_tolerance": 1e-7, "linear_solver_settings" : { "solver_type" : "MultiLevelSolver", "max_iteration" : 200, "tolerance" : 1e-8, "max_levels" : 3, "symmetric" : false, "reform_preconditioner_at_each_step" : true, "scaling" : true }, "volume_model_part_name" : "volume_model_part", "skin_parts": [""], "no_skin_parts":[""], "time_stepping": { "automatic_time_step" : true, "CFL_number" : 1, "minimum_delta_time" : 1e-4, "maximum_delta_time" : 0.01 }, "time_scheme": "bossak", "alpha":-0.3, "move_mesh_strategy": 0, "periodic": "periodic", "regularization_coef": 1000, "move_mesh_flag": false, "turbulence_model": "None" }""") ## Overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) ## Construct the linear solver import trilinos_linear_solver_factory self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) if self._IsPrintingRank(): #TODO: CHANGE THIS ONCE THE MPI LOGGER IS IMPLEMENTED KratosMultiphysics.Logger.Print( "Construction of TrilinosNavierStokesSolverMonolithic finished." )
def __init__(self, main_model_part, custom_settings): self.element_name = "EmbeddedAusasNavierStokes" self.condition_name = "EmbeddedAusasNavierStokesWallCondition" self.min_buffer_size = 3 self._is_printing_rank = (KratosMPI.mpi.rank == 0) #TODO: shall obtain the compute_model_part from the MODEL once the object is implemented self.main_model_part = main_model_part ##settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "EmbeddedAusas", "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "distance_reading_settings" : { "import_mode" : "from_GID_file", "distance_file_name" : "distance_file" }, "maximum_iterations": 7, "dynamic_tau": 1.0, "echo_level": 0, "consider_periodic_conditions": false, "time_order": 2, "compute_reactions": false, "reform_dofs_at_each_step": false, "relative_velocity_tolerance": 1e-3, "absolute_velocity_tolerance": 1e-5, "relative_pressure_tolerance": 1e-3, "absolute_pressure_tolerance": 1e-5, "linear_solver_settings" : { "solver_type" : "MultiLevelSolver", "max_iteration" : 200, "tolerance" : 1e-6, "max_levels" : 3, "symmetric" : false, "reform_preconditioner_at_each_step" : true, "scaling" : true }, "volume_model_part_name" : "volume_model_part", "skin_parts": [""], "no_skin_parts":[""], "time_stepping": { "automatic_time_step" : true, "CFL_number" : 1, "minimum_delta_time" : 1e-4, "maximum_delta_time" : 0.01 }, "periodic": "periodic", "move_mesh_flag": false }""") ## Overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) ## Construct the linear solver import trilinos_linear_solver_factory self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) ## Set the distance reading filename # TODO: remove the manual "distance_file_name" set as soon as the problem type one has been tested. if (self.settings["distance_reading_settings"] ["import_mode"].GetString() == "from_GiD_file"): self.settings["distance_reading_settings"][ "distance_file_name"].SetString( self.settings["model_import_settings"] ["input_filename"].GetString() + ".post.res") if self._IsPrintingRank(): KratosMultiphysics.Logger.PrintInfo( "NavierStokesMPIEmbeddedAusasMonolithicSolver", "Construction of NavierStokesEmbeddedAusasSolver finished.")
def __init__(self, main_model_part, custom_settings): #TODO: shall obtain the compute_model_part from the MODEL once the object is implemented self.main_model_part = main_model_part ## Default settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "trilinos_navier_stokes_solver_vmsmonolithic", "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "maximum_iterations": 10, "dynamic_tau": 0.01, "oss_switch": 0, "echo_level": 0, "consider_periodic_conditions": false, "time_order": 2, "compute_reactions": false, "divergence_clearance_steps": 0, "reform_dofs_at_each_step": false, "relative_velocity_tolerance": 1e-5, "absolute_velocity_tolerance": 1e-7, "relative_pressure_tolerance": 1e-5, "absolute_pressure_tolerance": 1e-7, "linear_solver_settings" : { "solver_type" : "MultiLevelSolver", "max_iteration" : 200, "tolerance" : 1e-8, "max_levels" : 3, "symmetric" : false, "reform_preconditioner_at_each_step" : true, "scaling" : true }, "volume_model_part_name" : "volume_model_part", "skin_parts": [""], "no_skin_parts":[""], "time_stepping": { "automatic_time_step" : true, "CFL_number" : 1, "minimum_delta_time" : 1e-4, "maximum_delta_time" : 0.01 }, "alpha":-0.3, "move_mesh_strategy": 0, "periodic": "periodic", "regularization_coef": 1000, "move_mesh_flag": false, "turbulence_model": "None" }""") ## Overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) ## Construct the linear solver import trilinos_linear_solver_factory self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"]) ## Set the element replace settings 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":"VMS3D4N", "condition_name": "MonolithicWallCondition3D" } """) elif(self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2): self.settings["element_replace_settings"] = KratosMultiphysics.Parameters(""" { "element_name":"VMS2D3N", "condition_name": "MonolithicWallCondition2D" } """) else: raise Exception("Domain size is neither 2 nor 3!!") print("Construction of NavierStokesMPISolver_VMSMonolithic finished.")
def _create_linear_solver(self): import trilinos_linear_solver_factory # TODO: Is new_trilinos_linear_solver_factory or trilinos_linear_solver_factory? linear_solver = trilinos_linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) return linear_solver
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)