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
