def ExecuteInitialize(self):
# set model part
self.model_part = self.model[
self.settings["model_part_name"].GetString()]
self.TimeDiscretizationProcess = KratosSolid.TimeDiscretizationProcess(
self.model_part, self.settings)
def ExecuteInitialize(self):
# set model part
self.model_part = self.model[self.settings["model_part_name"].GetString()]
if( self.model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED] == False ):
self.model_part.ProcessInfo.SetValue(KratosMultiphysics.INTERVAL_END_TIME, self.interval[1])
# set processes
params = KratosMultiphysics.Parameters("{}")
params.AddValue("model_part_name", self.settings["model_part_name"])
params.AddEmptyValue("value")
params.__setitem__("value", self.settings["direction"])
if( self.value_is_numeric ):
params.AddValue("variable_name", self.settings["variable_name"])
counter = 0
for i in self.value:
params["value"][counter].SetDouble(i)
counter+=1
self.AssignValueProcess = KratosSolid.AssignVectorToConditionsProcess(self.model_part, params)
else:
#function values are assigned to a vector variable :: transformation is needed
if(type(self.var) == KratosMultiphysics.Array1DVariable3):
variable_name = self.settings["variable_name"].GetString() + "_VECTOR"
print(" variable name modified:", variable_name)
params.AddEmptyValue("variable_name")
params["variable_name"].SetString(variable_name)
else:
params.AddValue("variable_name", self.settings["variable_name"])
counter = 0
for i in self.value:
params["value"][counter].SetDouble(i)
counter+=1
self.AssignValueProcess = KratosSolid.AssignVectorFieldToConditionsProcess(self.model_part, self.compiled_function, "function", self.value_is_spatial_function, params)
if( self.IsInsideInterval() and self.interval_string == "initial" ):
self.AssignValueProcess.Execute()
def _create_mechanical_solver(self):
eigen_scheme = self._get_solution_scheme() # The scheme defines the matrices of the eigenvalue problem.
builder_and_solver = self._get_builder_and_solver() # The eigensolver is created here.
options = KratosMultiphysics.Flags()
options.Set(KratosSolid.SolverLocalFlags.REFORM_DOFS, self.settings["solving_strategy_settings"]["reform_dofs_at_each_step"].GetBool())
return KratosSolid.EigensolverStrategy(self.model_part, eigen_scheme, builder_and_solver, options, self.compute_modal_contribution)
def ExecuteInitialize(self):
self.model_part = self.model[self.settings["model_part_name"].GetString()]
#create skin for the beam string
self.beam_skin_process = KratosSolid.BuildStringSkinProcess(self.model_part, self.sides, self.radius)
self.beam_skin_process.ExecuteInitialize()
print("::[Skin_Created]:: (sides:"+str(self.sides),"radius:"+str(self.radius)+")")
def __init__(self, Model, custom_settings ):
assign_vector_components_to_nodes_process.AssignVectorComponentsToNodesProcess.__init__(self, Model, custom_settings)
entity_type = "Nodes"
assign_flags = [KratosMultiphysics.INLET]
self.model_inlet = KratosSolid.AssignFlagsToEntitiesProcess(self.model_part,entity_type,assign_flags)
self.model_inlet.Execute()
def _build_composite_solving_parts(self):
print(self._class_prefix()+" Composite Solving Parts")
solving_parts = self.settings["composite_solving_parts"]
for i in range(0,solving_parts.size()):
print(self._class_prefix()+" Build Part: "+solving_parts[i]["model_part_name"].GetString())
solving_part_transfer = KratosSolid.TransferSolvingModelPartProcess(self.main_model_part,solving_parts[i])
self.transfer_solving_parts.append(solving_part_transfer)
def _create_explicit_strategy(self):
mechanical_scheme = self._get_solution_scheme()
linear_solver = self._get_linear_solver()
return KratosSolid.ExplicitStrategy(
self.model_part, mechanical_scheme, linear_solver,
self.solving_strategy_settings["compute_reactions"].GetBool(),
self.solving_strategy_settings["reform_dofs_at_each_step"].GetBool(
), self.solving_strategy_settings["move_mesh_flag"].GetBool())
def _create_mechanical_solver(self):
strategies = []
for solver in self.solvers:
strategies.append(solver._get_mechanical_solver())
options = KratosMultiphysics.Flags()
return KratosSolid.SegregatedStrategy(self.model_part, options,
strategies)
def _create_mechanical_solver(self):
eigen_scheme = self._get_solution_scheme() # The scheme defines the matrices of the eigenvalue problem.
builder_and_solver = self._get_builder_and_solver() # The eigensolver is created here.
return KratosSolid.EigensolverStrategy(self.model_part,
eigen_scheme,
builder_and_solver,
self.compute_modal_contribution)
def AddDofs(self):
AddDofsProcess = KratosSolid.AddDofsProcess(self.main_model_part,
self.dof_variables,
self.dof_reactions)
AddDofsProcess.Execute()
print("::[Mechanical Solver]:: DOF's ADDED")
def _create_linear_strategy(self):
mechanical_scheme = self._get_solution_scheme()
builder_and_solver = self._get_builder_and_solver()
options = KratosMultiphysics.Flags()
options.Set(KratosSolid.SolverLocalFlags.COMPUTE_REACTIONS, self.solving_strategy_settings["compute_reactions"].GetBool())
options.Set(KratosSolid.SolverLocalFlags.REFORM_DOFS, self.solving_strategy_settings["reform_dofs_at_each_step"].GetBool())
return KratosSolid.LinearStrategy(self.model_part, mechanical_scheme, builder_and_solver, options)
def CreateAssignmentProcess(self, params):
if( self.value_is_numeric ):
params.AddValue("variable_name", self.settings["variable_name"])
params.AddValue("value", self.settings["value"])
params.AddEmptyValue("entity_type").SetString("ELEMENTS")
self.AssignValueProcess = KratosSolid.AssignScalarToEntitiesProcess(self.model_part, params)
else:
#function values are assigned to a vector variable :: transformation is needed
if( isinstance(self.var,KratosMultiphysics.DoubleVariable) ):
variable_name = self.settings["variable_name"].GetString() + "_VECTOR"
#print("::[--Assign_Variable--]:: "+variable_name)
params.AddEmptyValue("variable_name")
params["variable_name"].SetString(variable_name)
else:
params.AddValue("variable_name", self.settings["variable_name"])
params.AddEmptyValue("entity_type").SetString("ELEMENTS")
self.AssignValueProcess = KratosSolid.AssignScalarFieldToEntitiesProcess(self.model_part, self.compiled_function, "function", self.value_is_spatial_function, params)
def _create_explicit_strategy(self):
solution_scheme = self._get_solution_scheme()
#linear_solver = self._get_linear_solver()
options = KratosMultiphysics.Flags()
options.Set(KratosSolid.SolverLocalFlags.COMPUTE_REACTIONS, self.settings["solving_strategy_settings"]["compute_reactions"].GetBool())
options.Set(KratosSolid.SolverLocalFlags.REFORM_DOFS, self.settings["solving_strategy_settings"]["reform_dofs_at_each_step"].GetBool())
return KratosSolid.ExplicitStrategy(self.model_part, solution_scheme, options)
def _CreateMechanicalSolver(self, mechanical_scheme, compute_reactions,
reform_step_dofs, move_mesh_flag):
self.mechanical_solver = KratosSolid.ExplicitStrategy(
self.computing_model_part, mechanical_scheme, self.linear_solver,
compute_reactions, reform_step_dofs, move_mesh_flag)
self.mechanical_solver.SetRebuildLevel(
0) # 1 to recompute the mass matrix in each explicit step
def _add_dofs(self):
dof_variables, dof_reactions = self._get_dofs()
AddDofsProcess = KratosSolid.AddDofsProcess(self.main_model_part,
dof_variables,
dof_reactions)
AddDofsProcess.Execute()
if (self.echo_level > 1):
print(dof_variables + dof_reactions)
print(self._class_prefix() + " DOF's ADDED")
def _add_dofs(self):
dof_variables, dof_reactions = self._get_dofs()
AddDofsProcess = KratosSolid.AddDofsProcess(self.main_model_part,
dof_variables,
dof_reactions)
AddDofsProcess.Execute()
if (self.echo_level > 1):
print(dof_variables + dof_reactions)
print("::[-------Solver------]:: DOF's ADDED")
def _CreateMechanicalSolver(self, mechanical_scheme,
mechanical_convergence_criterion,
builder_and_solver, max_iters,
compute_reactions, reform_step_dofs,
move_mesh_flag, component_wise, line_search,
implex):
if (component_wise):
self.mechanical_solver = KratosSolid.ComponentWiseNewtonRaphsonStrategy(
self.computing_model_part, mechanical_scheme,
self.linear_solver, mechanical_convergence_criterion,
builder_and_solver, max_iters, compute_reactions,
reform_step_dofs, move_mesh_flag)
else:
if (line_search):
if (implex):
self.mechanical_solver = KratosSolid.ResidualBasedNewtonRaphsonLineSearchImplexStrategy(
self.computing_model_part, mechanical_scheme,
self.linear_solver, mechanical_convergence_criterion,
builder_and_solver, max_iters, compute_reactions,
reform_step_dofs, move_mesh_flag)
else:
self.mechanical_solver = KratosSolid.ResidualBasedNewtonRaphsonLineSearchStrategy(
self.computing_model_part, mechanical_scheme,
self.linear_solver, mechanical_convergence_criterion,
builder_and_solver, max_iters, compute_reactions,
reform_step_dofs, move_mesh_flag)
else:
if self.settings["analysis_type"].GetString() == "Linear":
self.mechanical_solver = KratosMultiphysics.ResidualBasedLinearStrategy(
self.computing_model_part, mechanical_scheme,
self.linear_solver, builder_and_solver,
compute_reactions, reform_step_dofs, False,
move_mesh_flag)
else:
self.mechanical_solver = KratosMultiphysics.ResidualBasedNewtonRaphsonStrategy(
self.computing_model_part, mechanical_scheme,
self.linear_solver, mechanical_convergence_criterion,
builder_and_solver, max_iters, compute_reactions,
reform_step_dofs, move_mesh_flag)
def _create_mechanical_solver(self):
strategies = []
for solver in self.solvers:
strategies.append(solver._get_mechanical_solver())
options = KratosMultiphysics.Flags()
mechanical_solver = KratosSolid.SegregatedStrategy(
self.model_part, options, strategies)
mechanical_solver.Set(KratosSolid.SolverLocalFlags.ADAPTIVE_SOLUTION,
self._check_adaptive_solution())
return mechanical_solver
def _get_criterion(self):
# Note that all the convergence settings are introduced via a Kratos parameters object.
V_RT = self.settings["variable_relative_tolerance"].GetDouble()
V_AT = self.settings["variable_absolute_tolerance"].GetDouble()
R_RT = self.settings["residual_relative_tolerance"].GetDouble()
R_AT = self.settings["residual_absolute_tolerance"].GetDouble()
echo_level = self.settings["echo_level"].GetInt()
if (echo_level >= 1):
print(
"::[-----Criterion-----]::",
self.settings["convergence_criterion"].GetString(),
)
convergence_criterion = None
if (self.settings["convergence_criterion"].GetString() ==
"Variable_criterion"):
convergence_criterion = KratosSolid.DofsCriterion(V_RT, V_AT)
convergence_criterion.SetEchoLevel(echo_level)
convergence_criterion.Set(
KratosSolid.CriterionLocalFlags.INCREMENTAL)
elif (self.settings["convergence_criterion"].GetString() ==
"Residual_criterion"):
convergence_criterion = KratosSolid.ResidualCriterion(R_RT, R_AT)
convergence_criterion.SetEchoLevel(echo_level)
elif (self.settings["convergence_criterion"].GetString() ==
"And_criterion"):
Variable = KratosSolid.DofsCriterion(V_RT, V_AT)
Variable.SetEchoLevel(echo_level)
Variable.Set(KratosSolid.CriterionLocalFlags.INCREMENTAL)
Residual = KratosSolid.ResidualCriterion(R_RT, R_AT)
Residual.SetEchoLevel(echo_level)
convergence_criterion = KratosSolid.CompositeCriterion(
Residual, Variable)
convergence_criterion.Set(KratosSolid.CriterionLocalFlags.AND)
elif (self.settings["convergence_criterion"].GetString() ==
"Or_criterion"):
Variable = KratosSolid.DofsCriterion(V_RT, V_AT)
Variable.SetEchoLevel(echo_level)
Variable.Set(KratosSolid.CriterionLocalFlags.INCREMENTAL)
Residual = KratosSolid.ResidualCriterion(R_RT, R_AT)
Residual.SetEchoLevel(echo_level)
convergence_criterion = KratosSolid.CompositeCriterion(
Residual, Variable)
convergence_criterion.Set(KratosSolid.CriterionLocalFlags.OR)
else:
raise Exception("Unsupported \"convergence_criterion\" : " +
self.settings["convergence_criterion"].GetString())
return convergence_criterion
def _add_dofs(self):
if not hasattr(self, '_dof_variables'):
self._set_variables_and_dofs()
AddDofsProcess = KratosSolid.AddDofsProcess(self.main_model_part, self.dof_variables, self.dof_reactions)
AddDofsProcess.Execute()
if( self.echo_level > 1 ):
print(self.dof_variables + self.dof_reactions)
print("::[Solver]:: DOF's ADDED")
def _create_solution_scheme(self):
"""Create the scheme for the eigenvalue problem.
The scheme determines the left- and right-hand side matrices in the
generalized eigenvalue problem.
"""
if self.settings["time_integration_settings"]["solution_type"].GetString() == "Dynamic":
solution_scheme = KratosSolid.EigensolverScheme()
else:
raise Exception("Unsupported solution_type: " + self.settings["time_integration_settings"]["solution_type"])
return solution_scheme
def _set_time_integration_methods(self):
scalar_integration_methods, component_integration_methods = self._get_time_integration_methods();
# second: for the same method the parameters (already calculated)
scalar_integration_methods_container = KratosSolid.ScalarTimeIntegrationMethods()
for dof, method in scalar_integration_methods.items():
method.SetParameters(self.process_info) #set same parameters to all methods from process_info values
scalar_integration_methods_container.Set(dof,method)
component_integration_methods_container = KratosSolid.ComponentTimeIntegrationMethods()
for dof, method in component_integration_methods.items():
method.SetParameters(self.process_info) #set same parameters to all methods from process_info values
component_integration_methods_container.Set(dof,method)
# set time integration methods (for scalars and components) to process_info for processes access
if( len(scalar_integration_methods) ):
scalar_integration_methods_container.AddToProcessInfo(KratosSolid.SCALAR_TIME_INTEGRATION_METHODS, scalar_integration_methods_container, self.process_info)
component_integration_methods_container.AddToProcessInfo(KratosSolid.COMPONENT_TIME_INTEGRATION_METHODS, component_integration_methods_container, self.process_info)
def _create_builder_and_solver(self):
linear_solver = self._get_linear_solver()
if(self.settings["component_wise"].GetBool() == True):
builder_and_solver = KratosSolid.ComponentWiseBuilderAndSolver(linear_solver)
else:
if(self.settings["block_builder"].GetBool() == True):
# To keep matrix blocks in builder
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(linear_solver)
else:
builder_and_solver = KratosMultiphysics.ResidualBasedEliminationBuilderAndSolver(linear_solver)
return builder_and_solver
def _create_line_search_implex_strategy(self):
mechanical_scheme = self._get_solution_scheme()
linear_solver = self._get_linear_solver()
mechanical_convergence_criterion = self._get_convergence_criterion()
builder_and_solver = self._get_builder_and_solver()
return KratosSolid.ResidualBasedNewtonRaphsonLineSearchImplexStrategy(
self.model_part, mechanical_scheme, linear_solver,
mechanical_convergence_criterion, builder_and_solver,
self.solving_strategy_settings["max_iteration"].GetInt(),
self.solving_strategy_settings["compute_reactions"].GetBool(),
self.solving_strategy_settings["reform_dofs_at_each_step"].GetBool(
), self.solving_strategy_settings["move_mesh_flag"].GetBool())
def CreateAssignmentProcess(self, params):
params["variable_name"].SetString(
self.settings["variable_name"].GetString())
if (self.value_is_numeric):
params.AddEmptyValue("value").SetDouble(self.value)
params.AddEmptyValue("entity_type").SetString("NODES")
self.AssignValueProcess = KratosSolid.AssignScalarToEntitiesProcess(
self.model_part, params)
else:
if (self.value_is_current_value):
self.AssignValueProcess = KratosMultiphysics.Process(
) #void process
else:
params.AddEmptyValue("entity_type").SetString("NODES")
self.AssignValueProcess = KratosSolid.AssignScalarFieldToEntitiesProcess(
self.model_part, self.compiled_function, "function",
self.value_is_spatial_function, params)
# in case of going to previous time step for time step reduction
self.CreateUnAssignmentProcess(params)
def CreateAssignmentProcess(self, params):
if( self.fix_derivated_variable == False ):
self.variable_name = "ROTATION"
else:
for dynamic_variable in self.LinearDynamicVariables:
counter = 0
if dynamic_variable == self.variable_name:
self.variable_name = self.AngularDynamicVariables[counter]
break
counter = counter + 1
params["variable_name"].SetString(self.variable_name)
params.AddValue("direction", self.custom_settings["direction"])
params.AddValue("center", self.custom_settings["center"])
if( self.value_is_numeric ):
params.AddEmptyValue("modulus").SetDouble(self.value)
self.AssignValueProcess = KratosSolid.ApplyRigidBodyRotationToNodesProcess(self.model_part, params)
else:
self.AssignValueProcess = KratosSolid.ApplyRigidBodyRotationFieldToNodesProcess(self.model_part, self.compiled_function, "function", self.value_is_spatial_function, params)
def ExecuteInitialize(self):
# set model part
self.model_part = self.model[
self.settings["model_part_name"].GetString()]
if (self.model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED] ==
False):
self.model_part.ProcessInfo.SetValue(
KratosMultiphysics.INTERVAL_END_TIME, self.interval[1])
# set processes
params = KratosMultiphysics.Parameters("{}")
params.AddValue("model_part_name", self.settings["model_part_name"])
if (self.value_is_numeric):
params.AddValue("variable_name", self.settings["variable_name"])
params.AddValue("value", self.settings["value"])
params.AddEmptyValue("entity_type").SetString("CONDITIONS")
self.AssignValueProcess = KratosSolid.AssignScalarToEntitiesProcess(
self.model_part, params)
else:
#function values are assigned to a vector variable :: transformation is needed
if (isinstance(self.var, KratosMultiphysics.DoubleVariable)):
variable_name = self.settings["variable_name"].GetString(
) + "_VECTOR"
print(" variable name modified:", variable_name)
params.AddEmptyValue("variable_name")
params["variable_name"].SetString(variable_name)
else:
params.AddValue("variable_name",
self.settings["variable_name"])
params.AddEmptyValue("entity_type").SetString("CONDITIONS")
self.AssignValueProcess = KratosSolid.AssignScalarFieldToEntitiesProcess(
self.model_part, self.compiled_function, "function",
self.value_is_spatial_function, params)
if (self.IsInsideInterval() and self.interval_string == "initial"):
self.AssignValueProcess.Execute()
def _create_component_wise_strategy(self):
computing_model_part = self.GetComputingModelPart()
mechanical_scheme = self._get_solution_scheme()
linear_solver = self._get_linear_solver()
mechanical_convergence_criterion = self._get_convergence_criterion()
builder_and_solver = self._get_builder_and_solver()
return KratosSolid.ComponentWiseNewtonRaphsonStrategy(
computing_model_part, mechanical_scheme, linear_solver,
mechanical_convergence_criterion, builder_and_solver,
self.settings["max_iteration"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
def GetSolutionSchemeExplicit(self, explicit_integration_scheme,
max_delta_time, fraction_delta_time,
time_step_prediction_level,
rayleigh_damping):
# creating the explicit solution scheme:
if (explicit_integration_scheme == "CentralDifferences"):
mechanical_scheme = SolidMechanicsApplication.ExplicitCentralDifferencesScheme(
max_delta_time, fraction_delta_time,
time_step_prediction_level, rayleigh_damping)
else:
raise (explicit_integration_scheme, " not implemented yet.")
return mechanical_scheme
def _ConstructConvergenceCriterion(self, convergence_criterion):
D_RT = self.settings["mechanical_solver_settings"][
"displacement_relative_tolerance"].GetDouble()
D_AT = self.settings["mechanical_solver_settings"][
"displacement_absolute_tolerance"].GetDouble()
R_RT = self.settings["mechanical_solver_settings"][
"residual_relative_tolerance"].GetDouble()
R_AT = self.settings["mechanical_solver_settings"][
"residual_absolute_tolerance"].GetDouble()
echo_level = self.settings["mechanical_solver_settings"][
"echo_level"].GetInt()
if (convergence_criterion == "Displacement_criterion"):
convergence_criterion = KratosSolid.DisplacementConvergenceCriterion(
D_RT, D_AT)
convergence_criterion.SetEchoLevel(echo_level)
elif (convergence_criterion == "Residual_criterion"):
convergence_criterion = KratosMultiphysics.ResidualCriteria(
R_RT, R_AT)
convergence_criterion.SetEchoLevel(echo_level)
elif (convergence_criterion == "And_criterion"):
Displacement = KratosSolid.DisplacementConvergenceCriterion(
D_RT, D_AT)
Displacement.SetEchoLevel(echo_level)
Residual = KratosMultiphysics.ResidualCriteria(R_RT, R_AT)
Residual.SetEchoLevel(echo_level)
convergence_criterion = KratosMultiphysics.AndCriteria(
Residual, Displacement)
elif (convergence_criterion == "Or_criterion"):
Displacement = KratosSolid.DisplacementConvergenceCriterion(
D_RT, D_AT)
Displacement.SetEchoLevel(echo_level)
Residual = KratosMultiphysics.ResidualCriteria(R_RT, R_AT)
Residual.SetEchoLevel(echo_level)
convergence_criterion = KratosMultiphysics.OrCriteria(
Residual, Displacement)
return convergence_criterion
