def CreateSolver(model_part, config): structural_solver = StructuralSolver(model_part, config.domain_size) # definition of the convergence criteria if(hasattr(config, "convergence_criterion")): structural_solver.convergence_criterion_type = config.convergence_criterion if(hasattr(config, "displacement_relative_tolerance")): structural_solver.rel_disp_tol = config.displacement_relative_tolerance if(hasattr(config, "displacement_absolute_tolerance")): structural_solver.abs_disp_tol = config.displacement_absolute_tolerance if(hasattr(config, "residual_relative_tolerance")): structural_solver.rel_res_tol = config.residual_relative_tolerance if(hasattr(config, "residual_absolute_tolerance")): structural_solver.abs_res_tol = config.residual_absolute_tolerance if(hasattr(config, "max_iteration")): structural_solver.max_iters = config.max_iteration # definition of the global solver type if(hasattr(config, "scheme_type")): structural_solver.scheme_type = config.scheme_type # definition of the solver parameters if(hasattr(config, "ComputeReactions")): structural_solver.compute_reactions = config.ComputeReactions # bool if(hasattr(config, "ComputeContactForces")): structural_solver.compute_contact_forces = config.ComputeContactForces # bool if(hasattr(config, "ReformDofSetAtEachStep")): structural_solver.reform_step_dofs = config.ReformDofSetAtEachStep # bool if(hasattr(config, "RotationDofs")): structural_solver.rotation_dofs = config.RotationDofs # bool if(hasattr(config, "PressureDofs")): structural_solver.pressure_dofs = config.PressureDofs # bool if(hasattr(config, "LineSearch")): structural_solver.line_search = config.LineSearch # bool if(hasattr(config, "Implex")): structural_solver.implex = config.Implex # bool if(hasattr(config, "ComponentWise")): structural_solver.component_wise = config.ComponentWise # bool # definition of the echo level if(hasattr(config, "echo_level")): structural_solver.echo_level = config.echo_level # definition of the linear solver import linear_solver_factory if(hasattr(config, "linear_solver_config")): print("Linear Solver Set", config.linear_solver_config.solver_type) structural_solver.linear_solver = linear_solver_factory.ConstructSolver(config.linear_solver_config) if(config.linear_solver_config.solver_type == "AMGCL"): structural_solver.block_builder = True else: structural_solver.block_builder = False return structural_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 ##settings string in json format default_settings = Parameters(""" { "solver_type": "solid_mechanics_implicit_dynamic_solver", "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "echo_level": 0, "time_integration_method": "Implicit", "analysis_type": "nonlinear", "rotation_dofs": false, "pressure_dofs": false, "stabilization_factor": 1.0, "reform_dofs_at_each_iteration": false, "line_search": false, "compute_reactions": true, "compute_contact_forces": false, "block_builder": false, "component_wise": false, "move_mesh_flag": true, "solution_type": "Dynamic", "scheme_type": "Newmark", "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-4, "max_iteration": 10, "linear_solver_settings":{ "solver_type": "Super LU", "max_iteration": 500, "tolerance": 1e-9, "scaling": false, "verbosity": 1 }, "processes_sub_model_part_list": [""], "problem_domain_sub_model_part_list": ["solid_model_part"] } """) ##overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) #construct the linear solver import linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) print("Construction of MechanicalSolver finished")
def CreateSolver(model_part, config): convection_solver = PFEM2ConvectionDiffusionSolver(model_part, config.domain_size) # linear solver settings import linear_solver_factory if (hasattr(config, "convection_linear_solver_config")): self.linear_solver = linear_solver_factory.ConstructSolver( config.convection_linear_solver_config) return convection_solver
def CreateSolver(model_part, config): solver = LaplacianSolver(model_part, config.domain_size) import linear_solver_factory if(hasattr(config, "linear_solver_config")): solver.linear_solver = linear_solver_factory.ConstructSolver( config.linear_solver_config) return solver
def __init__(self, model_part, custom_settings): # Constructor of the class self.model_part = model_part self.domain_size = self.model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] ##settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type" : "shallow_water_base_solver", "model_import_settings" : { "input_type" : "mdpa", "input_filename" : "unknown_name" }, "echo_level" : 0, "convergence_echo_level" : 1, "solver_echo_level" : 0, "buffer_size" : 2, "dynamic_tau" : 0.005, "relative_tolerance" : 1e-6, "absolute_tolerance" : 1e-9, "maximum_iterations" : 20, "compute_reactions" : false, "reform_dofs_at_each_step" : false, "calculate_norm_dx" : true, "move_mesh_flag" : false, "volume_model_part_name" : "volume_model_part", "linear_solver_settings" : { "solver_type" : "SkylineLUFactorizationSolver" }, "time_stepping" : { "automatic_time_step" : false, "time_step" : 0.01 }, "pfem2_settings" : { "convection_scalar_variable" : "HEIGHT", "convection_vector_variable" : "VELOCITY", "maximum_number_of_particles" : 16 } }""") default_settings["pfem2_settings"][ "maximum_number_of_particles"].SetInt(8 * self.domain_size) ## Overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) ## Construct the linear solver import linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) # Initialize shallow water variables utility self.ShallowVariableUtils = KratosShallow.ShallowWaterVariablesUtility( self.model_part)
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 #TODO: remove unnecessary fields for the Explicit solver from the defaults ##settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "solid_mechanics_explicit_dynamic_solver", "echo_level": 0, "buffer_size": 2, "solution_type": "Dynamic", "time_integration_method": "Explicit", "scheme_type": "CentralDifferences", "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, "compute_reactions": true, "move_mesh_flag": true, "clear_storage": false, "max_delta_time": 1.0e-5, "fraction_delta_time": 0.9, "time_step_prediction_level": 0, "rayleigh_damping": false, "linear_solver_settings":{ "solver_type": "SuperLUSolver", "max_iteration": 500, "tolerance": 1e-9, "scaling": false, "verbosity": 1 }, "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 linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) print("Construction of Explicit Dynamics Mechanical Solver finished")
def __init__(self, model_part, custom_settings): self.MoveMeshFlag = False #TODO: shall obtain the compute_model_part from the MODEL once the object is implemented self.main_model_part = model_part ##settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "potential_flow_solver", "echo_level": 1, "relative_tolerance": 1e-5, "absolute_tolerance": 1e-9, "maximum_iterations": 1, "compute_reactions": false, "compute_condition_number": false, "reform_dofs_at_each_step": false, "calculate_solution_norm" : false, "volume_model_part_name" : "volume_model_part", "skin_parts":[], "no_skin_parts" : [], "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "element_replace_settings": { "element_name":"CompressiblePotentialFlowElement2D3N", "condition_name": "PotentialWallCondition2D2N" }, "linear_solver_settings": { "solver_type": "AMGCL", "max_iteration": 400, "gmres_krylov_space_dimension": 100, "smoother_type":"ilu0", "coarsening_type":"ruge_stuben", "coarse_enough" : 5000, "krylov_type": "lgmres", "tolerance": 1e-9, "verbosity": 3, "scaling": false } }""") ##overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) #construct the linear solvers import linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) print("Construction of LaplacianSolver finished")
def __init__(self, model_part, custom_settings): # default settings for structural similarity mesh solver default_settings = Parameters(""" { "solver_type" : "mesh_solver_structural_similarity", "model_import_settings" : { "input_type" : "mdpa", "input_filename" : "unknown_name" }, "ale_linear_solver_settings" : { "solver_type" : "AMGCL", "smoother_type":"ilu0", "krylov_type": "gmres", "coarsening_type": "aggregation", "max_iteration": 200, "provide_coordinates": false, "gmres_krylov_space_dimension": 100, "verbosity" : 0, "tolerance": 1e-7, "scaling": false, "block_size": 1, "use_block_matrices_if_possible" : true, "coarse_enough" : 5000 }, "volume_model_part_name" : "volume_model_part", "time_order" : 2, "mesh_reform_dofs_each_step" : false, "mesh_compute_reactions" : false }""") self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) # set parameters self.model_part = model_part self.time_order = custom_settings["time_order"].GetInt() self.mesh_compute_reactions = custom_settings[ "mesh_compute_reactions"].GetBool() self.mesh_reform_dofs_each_step = custom_settings[ "mesh_reform_dofs_each_step"].GetBool() # neighbour search number_of_avg_elems = 10 number_of_avg_nodes = 10 self.neighbour_search = FindNodalNeighboursProcess( model_part, number_of_avg_elems, number_of_avg_nodes) # definition of the solvers import linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver( self.settings["ale_linear_solver_settings"]) print("Construction of MeshSolverStructuralSimilarity finished")
def __init__(self, model, custom_settings): super(NavierStokesSolverFractionalStep, self).__init__(model, custom_settings) self.element_name = "FractionalStep" self.condition_name = "WallCondition" self.min_buffer_size = 3 # There is only a single rank in OpenMP, we always print self._is_printing_rank = True ## Construct the linear solvers import linear_solver_factory self.pressure_linear_solver = linear_solver_factory.ConstructSolver( self.settings["pressure_linear_solver_settings"]) self.velocity_linear_solver = linear_solver_factory.ConstructSolver( self.settings["velocity_linear_solver_settings"]) self.compute_reactions = self.settings["compute_reactions"].GetBool() KratosMultiphysics.Logger.PrintInfo( "NavierStokesSolverFractionalStep", "Construction of NavierStokesSolverFractionalStep solver finished." )
def __init__(self, model_part, settings): self.model_part = model_part #note that all settingsuration parameters MUST be passed. self.domain_size = settings.domain_size self.rel_vel_tol = settings.vel_tolerance self.abs_vel_tol = settings.abs_vel_tolerance self.rel_pres_tol = settings.press_tolerance self.abs_pres_tol = settings.abs_press_tolerance self.dynamic_tau = settings.dynamic_tau self.max_iter = settings.max_iteration self.echo_level = settings.echo_level self.compute_reactions = settings.compute_reactions self.reform_dofs_at_each_step = settings.reform_dofs_at_each_step import linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver( settings.linear_solver_settings) self.bdf_process = kratoscore.ComputeBDFCoefficientsProcess( model_part, 2) self.conv_criteria = incompressibleapp.VelPrCriteria( self.rel_vel_tol, self.abs_vel_tol, self.rel_pres_tol, self.abs_pres_tol) (self.conv_criteria).SetEchoLevel(self.echo_level) self.time_scheme = kratoscore.ResidualBasedIncrementalUpdateStaticScheme( ) builder_and_solver = kratoscore.ResidualBasedBlockBuilderAndSolver( self.linear_solver) move_mesh_flag = False #user should NOT configure this self.fluid_solver = kratoscore.ResidualBasedNewtonRaphsonStrategy( self.model_part, self.time_scheme, self.linear_solver, self.conv_criteria, builder_and_solver, self.max_iter, self.compute_reactions, self.reform_dofs_at_each_step, move_mesh_flag) (self.fluid_solver).SetEchoLevel(self.echo_level) self.fluid_solver.Check() self.model_part.ProcessInfo.SetValue(kratoscore.DYNAMIC_TAU, self.dynamic_tau) print("Construction stokes solver finished")
def CreateSolver(model_part, config, periodic=False): fluid_solver = MonolithicSolver(model_part, config.domain_size, periodic) 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 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) import linear_solver_factory if(hasattr(config, "linear_solver_config")): fluid_solver.linear_solver = linear_solver_factory.ConstructSolver( config.linear_solver_config) return fluid_solver
def setUpSolvers(self): # Building custom fluid solver self.fluid_solver = vms_monolithic_solver.MonolithicSolver( self.fluid_model_part, self.domain_size) rel_vel_tol = 1e-5 abs_vel_tol = 1e-7 rel_pres_tol = 1e-5 abs_pres_tol = 1e-7 self.fluid_solver.conv_criteria = VelPrCriteria( rel_vel_tol, abs_vel_tol, rel_pres_tol, abs_pres_tol) self.fluid_solver.conv_criteria.SetEchoLevel(0) alpha = -0.3 move_mesh = 0 self.fluid_solver.time_scheme = ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent( alpha, move_mesh, self.domain_size) import linear_solver_factory self.fluid_solver.linear_solver = linear_solver_factory.ConstructSolver( Parameters(r'''{ "solver_type" : "AMGCL" }''')) builder_and_solver = ResidualBasedBlockBuilderAndSolver( self.fluid_solver.linear_solver) self.fluid_solver.max_iter = 50 self.fluid_solver.compute_reactions = False self.fluid_solver.ReformDofSetAtEachStep = False self.fluid_solver.MoveMeshFlag = False self.fluid_solver.solver = ResidualBasedNewtonRaphsonStrategy(\ self.fluid_model_part, self.fluid_solver.time_scheme, self.fluid_solver.linear_solver, self.fluid_solver.conv_criteria, builder_and_solver, self.fluid_solver.max_iter, self.fluid_solver.compute_reactions, self.fluid_solver.ReformDofSetAtEachStep, self.fluid_solver.MoveMeshFlag) self.fluid_solver.solver.SetEchoLevel(0) self.fluid_solver.solver.Check() self.fluid_model_part.ProcessInfo.SetValue(OSS_SWITCH, self.oss_switch) self.fluid_solver.divergence_clearance_steps = 0 self.fluid_solver.use_slip_conditions = 0
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 ##settings string in json format default_settings = kratoscore.Parameters(""" { "solver_type": "stokes_solver_monolithic", "force_steady_state": false, "velocity_tolerance": 1e-3, "pressure_tolerance": 1e-2, "absolute_velocity_tolerance": 1e-3, "absolute_pressure_tolerance": 1e-2, "maximum_iterations": 3, "echo_level": 1, "consider_periodic_conditions": false, "time_order": 2, "dynamic_tau": 0.001, "compute_reactions": false, "reform_dofs_at_each_step": false, "volume_model_part_name" : "volume_model_part", "skin_parts":[""], "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "linear_solver_settings": { "solver_type": "Super LU", "max_iteration": 500, "tolerance": 1e-9, "scaling": false, "verbosity": 1 } }""") ##overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) #construct the linear solvers import linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"]) print("Construction of NavierStokesSolver_FractionalStep 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 ##settings string in json format default_settings = kratoscore.Parameters(""" { "solver_type": "static_structural_solver", "problem_is_linear": false, "convergence_criteria_settings": { "criteria_type" : "DisplacementCriteria", "parameters" : { "relative_tolerance" : 1e-6, "absolute_tolerance" : 1e-9 } } "maximum_iterations": 3, "echo_level": 1, "compute_reactions": true, "reform_dofs_at_each_iteration": false, "volume_model_part_name" : "volume_model_part", "skin_parts":[""], "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "linear_solver_settings": { "solver_type": "Super LU", "max_iteration": 500, "tolerance": 1e-9, "scaling": false, "verbosity": 1 } }""") ##overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) #construct the linear solvers import linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) print("Construction of NavierStokesSolver_FractionalStep finished")
def __init__(self, model, custom_settings): super(NavierStokesCompressibleSolver,self).__init__(model,custom_settings) self.element_name = "CompressibleNavierStokes" self.condition_name = "Condition" self.min_buffer_size = 3 # There is only a single rank in OpenMP, we always print self._is_printing_rank = True ## Construct the linear solver import linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"]) ## Set the element replace settings #self._SetCompressibleElementReplaceSettings() print("Construction of NavierStokesCompressibleSolver finished.")
def setUpSolvers(self): # Building custom fluid solver self.fluid_solver = vms_monolithic_solver.MonolithicSolver( self.fluid_model_part, self.domain_size) rel_vel_tol = 1e-5 abs_vel_tol = 1e-7 rel_pres_tol = 1e-5 abs_pres_tol = 1e-7 self.fluid_solver.conv_criteria = VelPrCriteria( rel_vel_tol, abs_vel_tol, rel_pres_tol, abs_pres_tol) self.fluid_solver.conv_criteria.SetEchoLevel(0) self.fluid_solver.time_scheme = ResidualBasedIncrementalUpdateStaticScheme( ) import linear_solver_factory self.fluid_solver.linear_solver = linear_solver_factory.ConstructSolver( Parameters(r'''{ "solver_type" : "AMGCL" }''')) builder_and_solver = ResidualBasedBlockBuilderAndSolver( self.fluid_solver.linear_solver) self.fluid_solver.max_iter = 50 self.fluid_solver.compute_reactions = False self.fluid_solver.ReformDofSetAtEachStep = False self.fluid_solver.MoveMeshFlag = False self.fluid_solver.solver = ResidualBasedNewtonRaphsonStrategy(\ self.fluid_model_part, self.fluid_solver.time_scheme, self.fluid_solver.linear_solver, self.fluid_solver.conv_criteria, builder_and_solver, self.fluid_solver.max_iter, self.fluid_solver.compute_reactions, self.fluid_solver.ReformDofSetAtEachStep, self.fluid_solver.MoveMeshFlag) self.fluid_solver.solver.SetEchoLevel(0) self.fluid_solver.solver.Check() self.fluid_solver.divergence_clearance_steps = 0 self.fluid_solver.use_slip_conditions = 0
def CreateSolver(model_part, config): conv_diff_solver = ConvectionDiffusionSolver(model_part, config.domain_size, config) # default settings if (hasattr(config, "domain_size")): conv_diff_solver.domain_size = config.domain_size if (hasattr(config, "ReformDofAtEachIteration")): conv_diff_solver.ReformDofAtEachIteration = config.ReformDofAtEachIteration if (hasattr(config, "echo_level")): conv_diff_solver.echo_level = config.echo_level # linear solver settings import linear_solver_factory if (hasattr(config, "linear_solver_config")): conv_diff_solver.linear_solver = linear_solver_factory.ConstructSolver( config.linear_solver_config) return conv_diff_solver
def CreateSolver(model_part, config, eul_model_part, gamma, contact_angle, zeta_dissapative_JM, zeta_dissapative_BM, zeta_dissapative_SM): #FOR 3D! fluid_solver = STMonolithicSolver(model_part, config.domain_size, eul_model_part, gamma, contact_angle, zeta_dissapative_JM, zeta_dissapative_BM, zeta_dissapative_SM) if (hasattr(config, "alpha")): fluid_solver.alpha = config.alpha if (hasattr(config, "eul_model_part")): fluid_solver.eulerian_model_part = config.eul_model_part # 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, "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 linear_solver_factory if (hasattr(config, "linear_solver_config")): fluid_solver.linear_solver = linear_solver_factory.ConstructSolver( config.linear_solver_config) return fluid_solver
def Analyzer(controls, response, opt_itr): # Create object to analyze structure response functions if required response_analyzer = StructureResponseFunctionUtilities(main_model_part) # Create object to analyze sensitivities if required (dummy linear solver for future adjoint sensitivity analysis) import linear_solver_factory linear_solver = linear_solver_factory.ConstructSolver( ProjectParameters["solver_settings"]["linear_solver_settings"]) sensitivity_solver = StructureAdjointSensitivityStrategy( main_model_part, linear_solver, ProjectParameters["problem_data"]["domain_size"].GetInt()) # Compute objective function value Call the Solid Mechanics Application to compute objective function value if (controls["strain_energy"]["calc_func"]): # Compute structure solution to get displacement field u print("::[START Kratos Solid Mechanics Application]::") solve_structure(opt_itr) # Calculate objective function value based on u and save into container print("\n::[Objective Function Calculation]::") response["strain_energy"][ "func"] = response_analyzer.ComputeStrainEnergy() # Compute constraint function value if (controls["volume_fraction"]["calc_func"]): print("\n::[Constraint Function Calculation]::") target_volume_fraction = opt_parameters.initial_volume_fraction response["volume_fraction"][ "func"] = response_analyzer.ComputeVolumeFraction( ) - target_volume_fraction # Compute sensitivities of objective function if (controls["strain_energy"]["calc_grad"]): print("\n::[Objective sensitivity computation]::") sensitivity_solver.ComputeStrainEnergySensitivities() # Compute sensitivities of constraint function if (controls["volume_fraction"]["calc_grad"]): print("\n::[Constraint sensitivity computation]::") sensitivity_solver.ComputeVolumeFractionSensitivities()
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" : "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" : "AMGCL" }, "volume_model_part_name" : "volume_model_part", "skin_parts" : [""], "no_skin_parts" : [""], "dynamic_tau" : 0.0, "oss_switch" : 0, "echo_level" : 0, "time_stepping" : { "automatic_time_step" : false, "time_step" : -0.1 } }""") # overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) # construct the linear solver import linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"]) print("Construction of AdjointVMSMonolithicSolver 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 = True 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" # construct the linear solver import linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) KratosMultiphysics.Logger.PrintInfo( self.__class__.__name__, "Construction of AdjointVMSMonolithicSolver finished.")
def _linear_solver_predict(self): import linear_solver_factory linear_solver = linear_solver_factory.ConstructSolver( self.params["linear_solver_settings"]) builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver( linear_solver) scheme = KratosMultiphysics.ResidualBasedIncrementalUpdateStaticScheme( ) compute_reactions = True reform_step_dofs = True calculate_norm_dx = False move_mesh_flag = True strategy = KratosMultiphysics.ResidualBasedLinearStrategy( self.main_model_part, scheme, linear_solver, builder_and_solver, compute_reactions, reform_step_dofs, calculate_norm_dx, move_mesh_flag) strategy.SetEchoLevel(0) strategy.Check() strategy.Solve() strategy.Clear()
def __init__(self, model_part, custom_settings): self.MoveMeshFlag = False #TODO: shall obtain the compute_model_part from the MODEL once the object is implemented self.main_model_part = model_part ##settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "laplacian_solver_newformat", "echo_level": 1, "relative_tolerance": 1e-5, "absolute_tolerance": 1e-9, "maximum_iterations": 10, "compute_reactions": false, "reform_dofs_at_each_iteration": false, "calculate_solution_norm" : false, "volume_model_part_name" : "volume_model_part", "skin_parts":[""], "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "linear_solver_settings": { "solver_type": "AMGCL", "max_iteration": 100, "tolerance": 1e-6 } }""") ##overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) #construct the linear solvers import linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) print("Construction of LaplacianSolver finished")
def __init__(self, model, custom_settings): # Constructor of the class settings = self._ValidateSettings(custom_settings) super(ShallowWaterBaseSolver, self).__init__(model, settings) # There is only a single rank in OpenMP, we always print self._is_printing_rank = True ## Set the element and condition names for the replace settings ## These should be defined in derived classes self.element_name = None self.condition_name = None self.min_buffer_size = 2 # Either retrieve the model part from the model or create a new one model_part_name = self.settings["model_part_name"].GetString() if model_part_name == "": raise Exception('Please specify a model_part name!') if self.model.HasModelPart(model_part_name): self.main_model_part = self.model.GetModelPart(model_part_name) else: self.main_model_part = KratosMultiphysics.ModelPart( model_part_name) self.model.AddModelPart(self.main_model_part) domain_size = self.settings["domain_size"].GetInt() self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.DOMAIN_SIZE, domain_size) ## Construct the linear solver import linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) # Initialize shallow water variables utility self.ShallowVariableUtils = Shallow.ShallowWaterVariablesUtility( self.main_model_part, self.settings["dry_height"].GetDouble())
def Initialize(self): print("::[Pfem Fluid Explicit Solver]:: -START-") # Get the computing model part self.computing_model_part = self.GetComputingModelPart() #mechanical_scheme = KratosSolidMechanics.ExplicitCentralDifferencesScheme(self.settings["max_delta_time"].GetDouble(), # self.settings["fraction_delta_time"].GetDouble(), # self.settings["time_step_prediction_level"].GetDouble(), # self.settings["rayleigh_damping"].GetBool()) mechanical_scheme = KratosPfemFluid.FirstOrderForwardEulerScheme( 1.0e-4, 1.0, 0, 0) import linear_solver_factory linear_solver = linear_solver_factory.ConstructSolver( self.settings["velocity_linear_solver_settings"]) #self.fluid_solver = KratosPfemFluid.ExplicitStrategy(self.computing_model_part, # mechanical_scheme, # linear_solver, # self.settings["compute_reactions"].GetBool(), # self.settings["reform_dofs_at_each_step"].GetBool(), # self.settings["move_mesh_flag"].GetBool()) self.fluid_solver = KratosPfemFluid.ExplicitStrategy( self.computing_model_part, mechanical_scheme, linear_solver, False, True, True) # Set echo_level self.fluid_solver.SetEchoLevel(self.settings["echo_level"].GetInt()) # Set initialize flag if (self.main_model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED] == True): self.mechanical_solver.SetInitializePerformedFlag(True) # Check if everything is assigned correctly self.fluid_solver.Check() print("::[Pfem Fluid Explicit Solver]:: -END- ")
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 ##settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "lagrangian_mpm_solver", "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "maximum_iterations": 10, "echo_level": 1, "compute_reactions": false, "reform_dofs_at_each_step": true, "relative_tolerance": 1e-5, "absolute_tolerance": 1e-7, "linear_solver_settings" : { "solver_type" : "Super LU", "scaling": true }, "processes_sub_model_part_list" : [""] }""") ##overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) #self.EraseNodes = NodeEraseProcess(self.main_model_part) #construct the linear solver import linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"]) print("Construction of NavierStokesSolver_VMSMonolithic finished")
def __init__(self, model, custom_settings): super(NavierStokesEmbeddedMonolithicSolver, self).__init__(model, custom_settings) self.element_name = "EmbeddedNavierStokes" self.condition_name = "NavierStokesWallCondition" self.min_buffer_size = 3 # There is only a single rank in OpenMP, we always print self._is_printing_rank = True # TODO: Remove this once we finish the new implementations if (self.settings["solver_type"].GetString() == "EmbeddedDevelopment"): self.element_name = "EmbeddedSymbolicNavierStokes" # TODO: Remove this once we finish the new implementations if (self.settings["solver_type"].GetString() == "EmbeddedAusasDevelopment"): self.settings["is_slip"].SetBool(True) self.element_name = "EmbeddedSymbolicNavierStokesDiscontinuous" ## Construct the linear solver import linear_solver_factory self.linear_solver = 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") KratosMultiphysics.Logger.PrintInfo( "NavierStokesEmbeddedMonolithicSolver", "Construction of NavierStokesEmbeddedMonolithicSolver finished.")
def __init__(self, model_part, custom_settings): #TODO: shall obtain the compute_model_part from the MODEL once the object is implemented self.model_part = model_part ##settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "iga_structural_mechanics_solver", "model_import_settings": { "input_type": "txt", "input_filename": "unknown_name" }, "maximum_iterations": 10, "echo_level": 1, "compute_reactions": false, "reform_dofs_at_each_iteration": true, "relative_tolerance": 1e-5, "absolute_tolerance": 1e-7, "linear_solver_settings" : { "solver_type" : "BiConjugate_gradient_stabilized", "max_iteration" : 500, "tolerance" : 1e-9, "scaling" : true, "verbosity" : 0 }, "problem_domain_sub_model_part_list" : [], "processes_sub_model_part_list" : [], "rotation_dofs" : "false" }""") ##overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) #construct the linear solver import linear_solver_factory self.linear_solver = linear_solver_factory.ConstructSolver( self.settings["linear_solver_settings"])
def _create_linear_solver(self): import linear_solver_factory linear_solver = 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 ##settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "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, "compute_reactions": false, "reform_dofs_at_each_step": true, "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" : "AMGCL", "smoother_type":"ilu0", "krylov_type": "gmres", "coarsening_type": "aggregation", "max_iteration": 200, "provide_coordinates": false, "gmres_krylov_space_dimension": 100, "verbosity" : 0, "tolerance": 1e-7, "scaling": false, "block_size": 1, "use_block_matrices_if_possible" : true, "coarse_enough" : 5000 }, "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", "move_mesh_flag": false, "turbulence_model": "None", "reorder": false }""") ## Overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) ## Construct the linear solver import linear_solver_factory self.linear_solver = 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 not 2 or 3") print("Construction of NavierStokesSolver_VMSMonolithic finished")