def _ConstructScheme(self, scheme_type, solution_type): self.main_model_part.ProcessInfo.SetValue( KratosPoro.VELOCITY_COEFFICIENT, 1.0) self.main_model_part.ProcessInfo.SetValue( KratosPoro.DT_PRESSURE_COEFFICIENT, 1.0) if (scheme_type == "Newmark"): beta = self.settings["newmark_beta"].GetDouble() gamma = self.settings["newmark_gamma"].GetDouble() theta = self.settings["newmark_theta"].GetDouble() rayleigh_m = self.settings["rayleigh_m"].GetDouble() rayleigh_k = self.settings["rayleigh_k"].GetDouble() self.main_model_part.ProcessInfo.SetValue( KratosStructural.RAYLEIGH_ALPHA, rayleigh_m) self.main_model_part.ProcessInfo.SetValue( KratosStructural.RAYLEIGH_BETA, rayleigh_k) if (solution_type == "quasi_static"): if (rayleigh_m < 1.0e-20 and rayleigh_k < 1.0e-20): scheme = KratosPoro.NewmarkQuasistaticUPwScheme( beta, gamma, theta) else: scheme = KratosPoro.NewmarkQuasistaticDampedUPwScheme( beta, gamma, theta) else: scheme = KratosPoro.NewmarkDynamicUPwScheme(beta, gamma, theta) else: raise Exception( "Apart from Newmark, other scheme_type are not available.") return scheme
def __init__(self, Model, settings ): KratosMultiphysics.Process.__init__(self) model_part = Model[settings["model_part_name"].GetString()] params = KratosMultiphysics.Parameters("{}") params.AddValue("model_part_name",settings["model_part_name"]) params.AddValue("variable_name",settings["variable_name"]) if settings.Has("is_fixed"): params.AddValue("is_fixed",settings["is_fixed"]) if settings.Has("hydrostatic"): if settings["hydrostatic"].GetBool() == False: params.AddValue("value",settings["value"]) if settings["table"].GetInt() == 0: self.process = KratosMultiphysics.ApplyConstantScalarValueProcess(model_part, params) else: params.AddValue("table",settings["table"]) self.process = KratosPoro.ApplyDoubleTableProcess(model_part, params) else: params.AddValue("gravity_direction",settings["gravity_direction"]) params.AddValue("reference_coordinate",settings["reference_coordinate"]) params.AddValue("specific_weight",settings["specific_weight"]) if settings["table"].GetInt() == 0: self.process = KratosPoro.ApplyConstantHydrostaticPressureProcess(model_part, params) else: params.AddValue("table",settings["table"]) self.process = KratosPoro.ApplyHydrostaticPressureTableProcess(model_part, params) else: params.AddValue("value",settings["value"]) if settings["table"].GetInt() == 0: self.process = KratosMultiphysics.ApplyConstantScalarValueProcess(model_part, params) else: params.AddValue("table",settings["table"]) self.process = KratosPoro.ApplyDoubleTableProcess(model_part, params)
def __init__(self, Model, settings): KratosMultiphysics.Process.__init__(self) model_part = Model[settings["model_part_name"].GetString()] self.components_process_list = [] if settings["active"][0].GetBool() == True: normal_params = KratosMultiphysics.Parameters("{}") normal_params.AddValue("model_part_name", settings["model_part_name"]) normal_params.AddValue("mesh_id", settings["mesh_id"]) normal_params.AddValue("variable_name", settings["variable_name"]) if settings["hydrostatic"].GetBool() == False: normal_params.AddValue("value", settings["value"][0]) if settings["table"][0].GetInt() == 0: self.components_process_list.append( KratosMultiphysics.ApplyConstantScalarValueProcess( model_part, normal_params)) else: normal_params.AddValue("table", settings["table"][0]) self.components_process_list.append( KratosPoro.ApplyDoubleTableProcess( model_part, normal_params)) else: normal_params.AddValue("gravity_direction", settings["gravity_direction"]) normal_params.AddValue("reference_coordinate", settings["reference_coordinate"]) normal_params.AddValue("specific_weight", settings["specific_weight"]) if settings["table"][0].GetInt() == 0: self.components_process_list.append( KratosPoro.ApplyConstantHydrostaticPressureProcess( model_part, normal_params)) else: normal_params.AddValue("table", settings["table"][0]) self.components_process_list.append( KratosPoro.ApplyHydrostaticPressureTableProcess( model_part, normal_params)) if settings["active"][1].GetBool() == True: tangential_params = KratosMultiphysics.Parameters("{}") tangential_params.AddValue("model_part_name", settings["model_part_name"]) tangential_params.AddValue("mesh_id", settings["mesh_id"]) tangential_params.AddEmptyValue("variable_name").SetString( "TANGENTIAL_CONTACT_STRESS") # Note: this is not general tangential_params.AddValue("value", settings["value"][1]) if settings["table"][1].GetInt() == 0: self.components_process_list.append( KratosMultiphysics.ApplyConstantScalarValueProcess( model_part, tangential_params)) else: tangential_params.AddValue("table", settings["table"][1]) self.components_process_list.append( KratosPoro.ApplyDoubleTableProcess(model_part, tangential_params))
def __init__(self, model, original_model_part_name, model_part_number, domain_size, problem_name, move_mesh_flag): # Construct the utility self.model = model self.model_part_number = model_part_number self.original_model_part_name = original_model_part_name self.domain_size = domain_size if domain_size == 2: self.PropagationUtility = KratosPoro.FracturePropagation2DUtilities( ) self.tcl_proc = "Poromechanics_Application::PropagateFractures2D" else: self.PropagationUtility = KratosPoro.FracturePropagation3DUtilities( ) self.tcl_proc = "Poromechanics_Application::PropagateFractures3D" import platform if platform.system() == "Windows": self.execute_gid = "gid" else: self.execute_gid = "./gid" self.move_mesh_flag = move_mesh_flag # Define FracturesData with open("FracturesData.json", 'r') as parameter_file: self.FracturesData = KratosMultiphysics.Parameters( parameter_file.read()) # Define control variables self.propagation_frequency = self.FracturesData["fracture_data"][ "propagation_frequency"].GetInt() self.step_count = 0 self.propagation_count = self.propagation_frequency self.remesh_count = 0 # Define names and paths self.problem_name = problem_name self.problem_path = os.getcwd() self.gid_path = self.FracturesData["fracture_data"][ "gid_path"].GetString() self.orig_state_path = os.path.join(str(self.problem_path), "OriginalState") self.last_state_path = os.path.join(str(self.problem_path), "LastState") # Create the file containing a list with all post.bin files all_list_filename = str(self.problem_name) + "_all.post.lst" all_list_file = open(all_list_filename, 'w') all_list_file.write("Multiple\n") all_list_file.close() # Save files of the original state self.SaveInitialProblemFiles()
def Initialize(self, parameters): domain_size = parameters["solver_settings"]["domain_size"].GetInt() if domain_size == 2: self.PropagationUtility = KratosPoro.FracturePropagation2DUtilities( ) self.tcl_proc = "Poromechanics_Application::PropagateFractures2D" else: self.PropagationUtility = KratosPoro.FracturePropagation3DUtilities( ) self.tcl_proc = "Poromechanics_Application::PropagateFractures3D" self.move_mesh_flag = parameters["solver_settings"][ "move_mesh_flag"].GetBool() # Create the file containing a list with all post.bin files self.problem_name = parameters["problem_data"][ "problem_name"].GetString() all_list_filename = str(self.problem_name) + "_all.post.lst" all_list_file = open(all_list_filename, 'w') all_list_file.write("Multiple\n") all_list_file.close() # Save files of the original state self.SaveInitialProblemFiles() # Update parameters with the new model part name self.original_model_part_name = parameters["solver_settings"][ "model_part_name"].GetString() model_part_name = str(self.original_model_part_name) + '_' + str( self.model_part_number) parameters["solver_settings"]["model_part_name"].SetString( model_part_name) if parameters.Has("processes"): for name, value in parameters["processes"].items(): value = self.UpdateModelPartNames(value) if parameters.Has("output_processes"): for name, value in parameters["output_processes"].items(): value = self.UpdateModelPartNames(value) # Overwrite materials with the new model part name with open("PoroMaterials.json", 'r') as parameter_file: materials = KratosMultiphysics.Parameters(parameter_file.read()) for p in range(materials["properties"].size()): old_name = materials["properties"][p]["model_part_name"].GetString( ) a, b = old_name.split(".") new_name = str(self.original_model_part_name) + '_' + str( self.model_part_number) + '.' + str(b) materials["properties"][p]["model_part_name"].SetString(new_name) with open("PoroMaterials.json", 'w') as outfile: outfile.write(materials.PrettyPrintJsonString()) return parameters
def _ConstructScheme(self, scheme_type, solution_type): self.main_model_part.ProcessInfo.SetValue( KratosPoro.VELOCITY_COEFFICIENT, 1.0) self.main_model_part.ProcessInfo.SetValue( KratosPoro.DT_PRESSURE_COEFFICIENT, 1.0) if (scheme_type == "Newmark"): beta = self.settings["newmark_beta"].GetDouble() gamma = self.settings["newmark_gamma"].GetDouble() theta = self.settings["newmark_theta"].GetDouble() rayleigh_alpha = self.settings["rayleigh_alpha"].GetDouble() rayleigh_beta = self.settings["rayleigh_beta"].GetDouble() if self.settings["calculate_alpha_beta"].GetBool(): omega_1 = self.settings["omega_1"].GetDouble() omega_n = self.settings["omega_n"].GetDouble() xi_1 = self.settings["xi_1"].GetDouble() xi_n = self.settings["xi_n"].GetDouble() rayleigh_beta = 2.0 * (xi_n * omega_n - xi_1 * omega_1) / ( omega_n * omega_n - omega_1 * omega_1) rayleigh_alpha = 2.0 * xi_1 * omega_1 - rayleigh_beta * omega_1 * omega_1 KratosMultiphysics.Logger.PrintInfo( "::[UPwSolver]:: Scheme Information") KratosMultiphysics.Logger.PrintInfo( "::[UPwSolver]:: omega_1: ", omega_1) KratosMultiphysics.Logger.PrintInfo( "::[UPwSolver]:: omega_n: ", omega_n) KratosMultiphysics.Logger.PrintInfo("::[UPwSolver]:: xi_1: ", xi_1) KratosMultiphysics.Logger.PrintInfo("::[UPwSolver]:: xi_n: ", xi_n) KratosMultiphysics.Logger.PrintInfo( "::[UPwSolver]:: Alpha and Beta output") KratosMultiphysics.Logger.PrintInfo( "::[UPwSolver]:: rayleigh_alpha: ", rayleigh_alpha) KratosMultiphysics.Logger.PrintInfo( "::[UPwSolver]:: rayleigh_beta: ", rayleigh_beta) self.main_model_part.ProcessInfo.SetValue( KratosStructural.RAYLEIGH_ALPHA, rayleigh_alpha) self.main_model_part.ProcessInfo.SetValue( KratosStructural.RAYLEIGH_BETA, rayleigh_beta) if (solution_type == "implicit_quasi_static"): if (rayleigh_alpha < 1.0e-20 and rayleigh_beta < 1.0e-20): scheme = KratosPoro.NewmarkQuasistaticUPwScheme( beta, gamma, theta) else: scheme = KratosPoro.NewmarkQuasistaticDampedUPwScheme( beta, gamma, theta) else: scheme = KratosPoro.NewmarkDynamicUPwScheme(beta, gamma, theta) else: raise Exception( "Apart from Newmark, other scheme_type are not available.") return scheme
def __init__(self, model, parameters): self.model = model self.parameters = parameters domain_size = self.parameters["solver_settings"]["domain_size"].GetInt( ) if domain_size == 2: self.initial_stress_utility = KratosPoro.InitialStress2DUtilities() else: self.initial_stress_utility = KratosPoro.InitialStress3DUtilities() self.current_model_part = self.model.GetModelPart( self.parameters["solver_settings"]["model_part_name"].GetString())
def _ConstructSolver(self, strategy_type): self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.ERROR_RATIO, self.settings["displacement_relative_tolerance"].GetDouble()) self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.ERROR_INTEGRATION_POINT, self.settings["displacement_absolute_tolerance"].GetDouble()) self.main_model_part.ProcessInfo.SetValue(KratosPoro.IS_CONVERGED, True) self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.NL_ITERATION_NUMBER, 1) nonlocal_damage = self.settings["nonlocal_damage"].GetBool() compute_reactions = self.settings["compute_reactions"].GetBool() reform_step_dofs = self.settings["reform_dofs_at_each_step"].GetBool() move_mesh_flag = self.settings["move_mesh_flag"].GetBool() self.strategy_params = KratosMultiphysics.Parameters("{}") self.strategy_params.AddValue("loads_sub_model_part_list", self.loads_sub_sub_model_part_list) self.strategy_params.AddValue("loads_variable_list", self.settings["loads_variable_list"]) # NOTE: A rebuild level of 0 means that the nodal mass is calculated only once at the beginning (Initialize) # A rebuild level higher than 0 means that the nodal mass can be updated at the beginning of each step (InitializeSolutionStep) self.strategy_params.AddValue("rebuild_level", self.settings["rebuild_level"]) if nonlocal_damage: self.strategy_params.AddValue( "body_domain_sub_model_part_list", self.body_domain_sub_sub_model_part_list) self.strategy_params.AddValue( "characteristic_length", self.settings["characteristic_length"]) self.strategy_params.AddValue( "search_neighbours_step", self.settings["search_neighbours_step"]) solving_strategy = KratosPoro.PoromechanicsExplicitNonlocalStrategy( self.computing_model_part, self.scheme, self.strategy_params, compute_reactions, reform_step_dofs, move_mesh_flag) else: solving_strategy = KratosPoro.PoromechanicsExplicitStrategy( self.computing_model_part, self.scheme, self.strategy_params, compute_reactions, reform_step_dofs, move_mesh_flag) return solving_strategy
def _ConstructScheme(self, scheme_type, solution_type): if(scheme_type == "Newmark"): beta = self.settings["newmark_beta"].GetDouble() gamma = self.settings["newmark_gamma"].GetDouble() theta = self.settings["newmark_theta"].GetDouble() rayleigh_m = self.settings["rayleigh_m"].GetDouble() rayleigh_k = self.settings["rayleigh_k"].GetDouble() if(solution_type == "quasi_static"): if(rayleigh_m<1.0e-20 and rayleigh_k<1.0e-20): scheme = KratosPoro.NewmarkQuasistaticUPwScheme(beta,gamma,theta) else: scheme = KratosPoro.NewmarkQuasistaticDampedUPwScheme(beta,gamma,theta,rayleigh_m,rayleigh_k) else: scheme = KratosPoro.NewmarkDynamicUPwScheme(beta,gamma,theta,rayleigh_m,rayleigh_k) else: raise Exception("Apart from Newmark, other scheme_type are not available.") return scheme
def __init__(self, Model, settings ): KratosMultiphysics.Process.__init__(self) model_part = Model[settings["model_part_name"].GetString()] variable_name = settings["variable_name"].GetString() self.components_process_list = [] if settings["active"][0].GetBool() == True: x_params = KratosMultiphysics.Parameters("{}") x_params.AddValue("model_part_name",settings["model_part_name"]) x_params.AddValue("mesh_id",settings["mesh_id"]) x_params.AddValue("value",settings["value"][0]) x_params.AddEmptyValue("variable_name").SetString(variable_name+"_X") if settings["table"][0].GetInt() == 0: self.components_process_list.append(KratosMultiphysics.ApplyConstantScalarValueProcess(model_part, x_params)) else: x_params.AddValue("table",settings["table"][0]) self.components_process_list.append(KratosPoro.ApplyComponentTableProcess(model_part, x_params)) if settings["active"][1].GetBool() == True: y_params = KratosMultiphysics.Parameters("{}") y_params.AddValue("model_part_name",settings["model_part_name"]) y_params.AddValue("mesh_id",settings["mesh_id"]) y_params.AddValue("value",settings["value"][1]) y_params.AddEmptyValue("variable_name").SetString(variable_name+"_Y") if settings["table"][1].GetInt() == 0: self.components_process_list.append(KratosMultiphysics.ApplyConstantScalarValueProcess(model_part, y_params)) else: y_params.AddValue("table",settings["table"][1]) self.components_process_list.append(KratosPoro.ApplyComponentTableProcess(model_part, y_params)) if settings["active"][2].GetBool() == True: z_params = KratosMultiphysics.Parameters("{}") z_params.AddValue("model_part_name",settings["model_part_name"]) z_params.AddValue("mesh_id",settings["mesh_id"]) z_params.AddValue("value",settings["value"][2]) z_params.AddEmptyValue("variable_name").SetString(variable_name+"_Z") if settings["table"][2].GetInt() == 0: self.components_process_list.append(KratosMultiphysics.ApplyConstantScalarValueProcess(model_part, z_params)) else: z_params.AddValue("table",settings["table"][2]) self.components_process_list.append(KratosPoro.ApplyComponentTableProcess(model_part, z_params))
def Initialize(self, parameters): domain_size = parameters["solver_settings"]["domain_size"].GetInt() if domain_size == 2: self.PropagationUtility = KratosPoro.FracturePropagation2DUtilities( ) self.tcl_proc = "Poromechanics_Application::PropagateFractures2D" else: self.PropagationUtility = KratosPoro.FracturePropagation3DUtilities( ) self.tcl_proc = "Poromechanics_Application::PropagateFractures3D" self.move_mesh_flag = parameters["solver_settings"][ "move_mesh_flag"].GetBool() # Create the file containing a list with all post.bin files self.problem_name = parameters["problem_data"][ "problem_name"].GetString() all_list_filename = str(self.problem_name) + "_all.post.lst" all_list_file = open(all_list_filename, 'w') all_list_file.write("Multiple\n") all_list_file.close() # Save files of the original state self.SaveInitialProblemFiles() # Update parameters with the new model part name self.original_model_part_name = parameters["solver_settings"][ "model_part_name"].GetString() model_part_name = str(self.original_model_part_name) + '_' + str( self.model_part_number) parameters["solver_settings"]["model_part_name"].SetString( model_part_name) if parameters.Has("processes"): for name, value in parameters["processes"].items(): value = self.UpdateModelPartNames(value) if parameters.Has("output_processes"): for name, value in parameters["output_processes"].items(): value = self.UpdateModelPartNames(value) return parameters
def __init__(self, Model, settings ): KratosMultiphysics.Process.__init__(self) # Control module process acting on the imposed direction: 0 (X), 1 (Y), 2 (Z) self.model_part = Model[settings["model_part_name"].GetString()] self.components_process_list = [] # Settings string in json format default_parameters = KratosMultiphysics.Parameters("{}") default_parameters.AddValue("model_part_name",settings["model_part_name"]) default_parameters.AddValue("initial_velocity",settings["initial_velocity"]) default_parameters.AddValue("limit_velocity",settings["limit_velocity"]) default_parameters.AddValue("velocity_factor",settings["velocity_factor"]) default_parameters.AddValue("initial_stiffness",settings["initial_stiffness"]) default_parameters.AddValue("force_increment_tolerance",settings["force_increment_tolerance"]) default_parameters.AddValue("update_stiffness",settings["update_stiffness"]) default_parameters.AddValue("force_averaging_time",settings["force_averaging_time"]) if settings["active"][0].GetBool() == True: self.x_params = default_parameters self.x_params.AddEmptyValue("imposed_direction") self.x_params["imposed_direction"].SetInt(0) self.x_params.AddValue("face_load_table_id",settings["table"][0]) self.components_process_list.append(KratosPoro.PoromechanicsFaceLoadControlModuleProcess(self.model_part, self.x_params)) if settings["active"][1].GetBool() == True: self.y_params = default_parameters self.y_params.AddEmptyValue("imposed_direction") self.y_params["imposed_direction"].SetInt(1) self.y_params.AddValue("face_load_table_id",settings["table"][1]) self.components_process_list.append(KratosPoro.PoromechanicsFaceLoadControlModuleProcess(self.model_part, self.y_params)) if settings["active"][2].GetBool() == True: self.z_params = default_parameters self.z_params.AddEmptyValue("imposed_direction") self.z_params["imposed_direction"].SetInt(2) self.z_params.AddValue("face_load_table_id",settings["table"][2]) self.components_process_list.append(KratosPoro.PoromechanicsFaceLoadControlModuleProcess(self.model_part, self.z_params))
def __init__(self, Model, settings ): KratosMultiphysics.Process.__init__(self) self.model_part = Model[settings["model_part_name"].GetString()] self.params = KratosMultiphysics.Parameters("{}") self.params.AddValue("model_part_name",settings["model_part_name"]) self.params.AddValue("dimension",settings["dimension"]) self.params.AddValue("stress_limit",settings["stress_limit"]) self.process = KratosPoro.PeriodicInterfaceProcess(self.model_part, self.params) if(settings["dimension"].GetInt() == 2): self.FindNodalNeigh = KratosMultiphysics.FindNodalNeighboursProcess(self.model_part,2,5) else: self.FindNodalNeigh = KratosMultiphysics.FindNodalNeighboursProcess(self.model_part,10,10)
def __init__(self, Model, settings): KratosMultiphysics.Process.__init__(self) model_part = Model[settings["model_part_name"].GetString()] params = KratosMultiphysics.Parameters("{}") params.AddValue("model_part_name", settings["model_part_name"]) params.AddValue("mesh_id", settings["mesh_id"]) params.AddValue("variable_name", settings["variable_name"]) params.AddValue("value", settings["value"]) if settings["table"].GetInt() == 0: self.process = KratosMultiphysics.ApplyConstantScalarValueProcess( model_part, params) else: params.AddValue("table", settings["table"]) self.process = KratosPoro.ApplyDoubleTableProcess( model_part, params)
def _ConstructSolver(self, builder_and_solver, scheme, convergence_criterion, strategy_type): nonlocal_damage = self.settings["mechanical_solver_settings"][ "nonlocal_damage"].GetBool() max_iters = self.settings["mechanical_solver_settings"][ "max_iteration"].GetInt() compute_reactions = self.settings["mechanical_solver_settings"][ "compute_reactions"].GetBool() reform_step_dofs = self.settings["mechanical_solver_settings"][ "reform_dofs_at_each_step"].GetBool() move_mesh_flag = self.settings["mechanical_solver_settings"][ "move_mesh_flag"].GetBool() if strategy_type == "Newton-Raphson": if nonlocal_damage: self.strategy_params = KratosMultiphysics.Parameters("{}") self.strategy_params.AddValue( "loads_sub_model_part_list", self.loads_sub_sub_model_part_list) self.strategy_params.AddValue( "loads_variable_list", self.settings["mechanical_solver_settings"] ["loads_variable_list"]) self.strategy_params.AddValue( "body_domain_sub_model_part_list", self.body_domain_sub_sub_model_part_list) self.strategy_params.AddValue( "characteristic_length", self.settings["mechanical_solver_settings"] ["characteristic_length"]) self.strategy_params.AddValue( "search_neighbours_step", self.settings["mechanical_solver_settings"] ["search_neighbours_step"]) solver = KratosPoro.PoromechanicsNewtonRaphsonNonlocalStrategy( self.mechanical_computing_model_part, scheme, self.mechanical_linear_solver, convergence_criterion, builder_and_solver, self.strategy_params, max_iters, compute_reactions, reform_step_dofs, move_mesh_flag) else: self.main_model_part.ProcessInfo.SetValue( KratosPoro.IS_CONVERGED, True) solver = KratosMultiphysics.ResidualBasedNewtonRaphsonStrategy( self.mechanical_computing_model_part, scheme, self.mechanical_linear_solver, convergence_criterion, builder_and_solver, max_iters, compute_reactions, reform_step_dofs, move_mesh_flag) else: # Arc-Length strategy self.strategy_params = KratosMultiphysics.Parameters("{}") self.strategy_params.AddValue( "desired_iterations", self.settings["mechanical_solver_settings"] ["desired_iterations"]) self.strategy_params.AddValue( "max_radius_factor", self.settings["mechanical_solver_settings"] ["max_radius_factor"]) self.strategy_params.AddValue( "min_radius_factor", self.settings["mechanical_solver_settings"] ["min_radius_factor"]) self.strategy_params.AddValue("loads_sub_model_part_list", self.loads_sub_sub_model_part_list) self.strategy_params.AddValue( "loads_variable_list", self.settings["mechanical_solver_settings"] ["loads_variable_list"]) if nonlocal_damage: self.strategy_params.AddValue( "body_domain_sub_model_part_list", self.body_domain_sub_sub_model_part_list) self.strategy_params.AddValue( "characteristic_length", self.settings["mechanical_solver_settings"] ["characteristic_length"]) self.strategy_params.AddValue( "search_neighbours_step", self.settings["mechanical_solver_settings"] ["search_neighbours_step"]) solver = KratosPoro.PoromechanicsRammArcLengthNonlocalStrategy( self.mechanical_computing_model_part, scheme, self.mechanical_linear_solver, convergence_criterion, builder_and_solver, self.strategy_params, max_iters, compute_reactions, reform_step_dofs, move_mesh_flag) else: solver = KratosPoro.PoromechanicsRammArcLengthStrategy( self.mechanical_computing_model_part, scheme, self.mechanical_linear_solver, convergence_criterion, builder_and_solver, self.strategy_params, max_iters, compute_reactions, reform_step_dofs, move_mesh_flag) return solver
def _ConstructScheme(self, scheme_type): scheme_type = self.settings["scheme_type"].GetString() # Setting the Rayleigh damping parameters process_info = self.main_model_part.ProcessInfo g_factor = self.settings["g_factor"].GetDouble() theta_factor = self.settings["theta_factor"].GetDouble() g_coeff = 0.0 Dt = self.settings["time_step"].GetDouble() omega_1 = self.settings["omega_1"].GetDouble() omega_n = self.settings["omega_n"].GetDouble() rayleigh_alpha = self.settings["rayleigh_alpha"].GetDouble() rayleigh_beta = self.settings["rayleigh_beta"].GetDouble() if (scheme_type == "Explicit_Central_Differences" and g_factor >= 1.0): theta_factor = 0.5 g_coeff = Dt * omega_n * omega_n * 0.25 * g_factor if self.settings["calculate_alpha_beta"].GetBool(): xi_1 = self.settings["xi_1"].GetDouble() xi_n = self.settings["xi_n"].GetDouble() if (scheme_type == "Explicit_Central_Differences" and self.settings["calculate_xi"].GetBool() == True): xi_1_factor = self.settings["xi_1_factor"].GetDouble() import numpy as np xi_1 = (np.sqrt(1 + g_coeff * Dt) - theta_factor * omega_1 * Dt * 0.5) * xi_1_factor xi_n = (np.sqrt(1 + g_coeff * Dt) - theta_factor * omega_n * Dt * 0.5) rayleigh_beta = 2.0 * (xi_n * omega_n - xi_1 * omega_1) / ( omega_n * omega_n - omega_1 * omega_1) rayleigh_alpha = 2.0 * xi_1 * omega_1 - rayleigh_beta * omega_1 * omega_1 KratosMultiphysics.Logger.PrintInfo( "::[ExplicitUPwSolver]:: Scheme Information") KratosMultiphysics.Logger.PrintInfo("::[ExplicitUPwSolver]:: dt: ", Dt) KratosMultiphysics.Logger.PrintInfo( "::[ExplicitUPwSolver]:: g_coeff: ", g_coeff) KratosMultiphysics.Logger.PrintInfo( "::[ExplicitUPwSolver]:: omega_1: ", omega_1) KratosMultiphysics.Logger.PrintInfo( "::[ExplicitUPwSolver]:: omega_n: ", omega_n) KratosMultiphysics.Logger.PrintInfo( "::[ExplicitUPwSolver]:: xi_1: ", xi_1) KratosMultiphysics.Logger.PrintInfo( "::[ExplicitUPwSolver]:: xi_n: ", xi_n) KratosMultiphysics.Logger.PrintInfo( "::[ExplicitUPwSolver]:: Alpha and Beta output") KratosMultiphysics.Logger.PrintInfo( "::[ExplicitUPwSolver]:: rayleigh_alpha: ", rayleigh_alpha) KratosMultiphysics.Logger.PrintInfo( "::[ExplicitUPwSolver]:: rayleigh_beta: ", rayleigh_beta) process_info.SetValue(StructuralMechanicsApplication.RAYLEIGH_ALPHA, rayleigh_alpha) process_info.SetValue(StructuralMechanicsApplication.RAYLEIGH_BETA, rayleigh_beta) process_info.SetValue(KratosPoro.G_COEFFICIENT, g_coeff) process_info.SetValue(KratosPoro.THETA_FACTOR, theta_factor) # Setting the time integration schemes if (scheme_type == "Explicit_Central_Differences"): scheme = KratosPoro.PoroExplicitCDScheme() elif (scheme_type == "Explicit_Velocity_Verlet"): scheme = KratosPoro.PoroExplicitVVScheme() else: err_msg = "The requested scheme type \"" + scheme_type + "\" is not available!\n" err_msg += "Available options are: \"Explicit_Central_Differences\", \"Explicit_Velocity_Verlet\" " raise Exception(err_msg) return scheme