def ExecuteInitialize(self):
if self.output_control == "time":
self.next_output = self.model_part.ProcessInfo[KratosMultiphysics.TIME]
else:
self.next_output = self.model_part.ProcessInfo[KratosMultiphysics.STEP]
self.nodal_variables = kratos_utilities.GenerateVariableListFromInput(self.settings["nodal_results"])
def ExecuteInitialize(self):
""" This method is executed at the begining to initialize the process
Keyword arguments:
self -- It signifies an instance of a class.
"""
# Calculate NODAL_H
KratosMultiphysics.VariableUtils().SetNonHistoricalVariable(KratosMultiphysics.NODAL_H, 0.0, self.main_model_part.Nodes)
KratosMultiphysics.VariableUtils().SetNonHistoricalVariable(KratosMultiphysics.NODAL_AREA, 0.0, self.main_model_part.Nodes)
self.find_nodal_h = KratosMultiphysics.FindNodalHNonHistoricalProcess(self.main_model_part)
self.find_nodal_h.Execute()
# Calculate the parameters of automatic remeshing
if self.settings["automatic_remesh"].GetBool():
nodal_h_values = []
for node in self.main_model_part.Nodes:
nodal_h_values.append(node.GetValue(KratosMultiphysics.NODAL_H))
# Calculate the minimum size
if self.settings["automatic_remesh_parameters"]["automatic_remesh_type"].GetString() == "Ratio":
# NOTE: For mode: https://docs.python.org/3/library/statistics.html
if self.settings["automatic_remesh_parameters"]["refer_type"].GetString() == "Mean":
ref = stat.mean(nodal_h_values)
elif self.settings["automatic_remesh_parameters"]["refer_type"].GetString() == "Median":
ref = stat.median(nodal_h_values)
self.settings["minimal_size"].SetDouble(ref * (self.settings["automatic_remesh_parameters"]["min_size_ratio"].GetDouble()))
self.settings["maximal_size"].SetDouble(ref * (self.settings["automatic_remesh_parameters"]["max_size_ratio"].GetDouble()))
elif self.settings["automatic_remesh_parameters"]["automatic_remesh_type"].GetString() == "Percentage":
mean = stat.mean(nodal_h_values)
stdev = stat.stdev(nodal_h_values)
prob = (self.settings["automatic_remesh_parameters"]["min_size_current_percentage"].GetDouble())/100
self.settings["minimal_size"].SetDouble(_normvalf(prob, mean, stdev)) # Using normal normal distribution to get the minimal size as a stadistical meaninful value
prob = (self.settings["automatic_remesh_parameters"]["max_size_current_percentage"].GetDouble())/100
self.settings["maximal_size"].SetDouble(_normvalf(prob, mean, stdev)) # Using normal normal distribution to get the maximal size as a stadistical meaninful value
# We deactivate, so it doesn't recalculate each initialization
self.settings["automatic_remesh"].SetBool(False)
## We print the parameters considered
KratosMultiphysics.Logger.PrintInfo("MINIMAL SIZE: ", "{:.2e}".format(self.settings["minimal_size"].GetDouble()))
KratosMultiphysics.Logger.PrintInfo("MAXIMAL SIZE: ", "{:.2e}".format(self.settings["maximal_size"].GetDouble()))
# Anisotropic remeshing parameters
self.anisotropy_remeshing = self.settings["anisotropy_remeshing"].GetBool()
if self.anisotropy_remeshing:
if self.settings["automatic_remesh"].GetBool():
self.settings["anisotropy_parameters"]["boundary_layer_max_distance"].SetDouble(self.settings["minimal_size"].GetDouble() * self.settings["anisotropy_parameters"]["boundary_layer_min_size_ratio"].GetDouble())
# Select the remeshing strategy
self.strategy = self.settings["strategy"].GetString()
if self.strategy == "LevelSet":
self.scalar_variable = KratosMultiphysics.KratosGlobals.GetVariable( self.settings["level_set_strategy_parameters"]["scalar_variable"].GetString() )
self.gradient_variable = KratosMultiphysics.KratosGlobals.GetVariable( self.settings["level_set_strategy_parameters"]["gradient_variable"].GetString() )
elif self.strategy == "Hessian":
self.metric_variables, variable_types = self.__generate_variable_list_from_input(self.settings["hessian_strategy_parameters"]["metric_variable"])
self.non_historical_metric_variable = self.__generate_boolean_list_from_input(self.settings["hessian_strategy_parameters"]["non_historical_metric_variable"])
self.non_historical_metric_variable = self.__list_extender(self.non_historical_metric_variable, variable_types)
self.normalization_factor = self.__generate_double_list_from_input(self.settings["hessian_strategy_parameters"]["normalization_factor"])
self.normalization_factor = self.__list_extender(self.normalization_factor, variable_types)
self.normalization_alpha = self.__generate_double_list_from_input(self.settings["hessian_strategy_parameters"]["normalization_alpha"])
self.normalization_alpha = self.__list_extender(self.normalization_alpha, variable_types)
self.normalization_method = self.__generate_string_list_from_input(self.settings["hessian_strategy_parameters"]["normalization_method"])
self.normalization_method = self.__list_extender(self.normalization_method, variable_types)
len_metric_variables = len(self.metric_variables)
len_non_historical_metric_variable = len(self.non_historical_metric_variable)
if len_metric_variables > len_non_historical_metric_variable:
for i in range(len_non_historical_metric_variable, len_metric_variables):
self.non_historical_metric_variable.append(False)
len_normalization_factor = len(self.normalization_factor)
if len_metric_variables > len_normalization_factor:
for i in range(len_normalization_factor, len_metric_variables):
self.normalization_factor.append(1.0)
len_normalization_alpha = len(self.normalization_alpha)
if len_metric_variables > len_normalization_alpha:
for i in range(len_normalization_alpha, len_metric_variables):
self.normalization_alpha.append(0.0)
len_normalization_method = len(self.normalization_method)
if len_metric_variables > len_normalization_method:
for i in range(len_normalization_method, len_metric_variables):
self.normalization_method.append("constant")
mesh_dependent_constant = self.settings["hessian_strategy_parameters"]["mesh_dependent_constant"].GetDouble()
if mesh_dependent_constant == 0.0:
self.settings["hessian_strategy_parameters"]["mesh_dependent_constant"].SetDouble(0.5 * (self.domain_size/(self.domain_size + 1))**2.0)
elif self.strategy == "superconvergent_patch_recovery" or self.strategy == "SPR":
self.error_threshold = self.settings["error_strategy_parameters"]["error_metric_parameters"]["error_threshold"].GetDouble()
self.error_ratio = 0
self.internal_variable_interpolation_list = kratos_utilities.GenerateVariableListFromInput(self.settings["internal_variables_parameters"]["internal_variable_interpolation_list"])
# Model parts to fix the nodes
fix_contour_model_parts = self.__generate_submodelparts_list_from_input(self.settings["fix_contour_model_parts"])
# Setting flag BLOCKED to the non nodes
for submodelpart in fix_contour_model_parts:
KratosMultiphysics.VariableUtils().SetFlag(KratosMultiphysics.BLOCKED, True, submodelpart.Nodes)
# Model parts to fix the conditions
fix_conditions_model_parts = self.__generate_submodelparts_list_from_input(self.settings["fix_conditions_model_parts"])
# Setting flag BLOCKED to the non conditions
for submodelpart in fix_conditions_model_parts:
KratosMultiphysics.VariableUtils().SetFlag(KratosMultiphysics.BLOCKED, True, submodelpart.Conditions)
# Model parts to fix the nodes
fix_elements_model_parts = self.__generate_submodelparts_list_from_input(self.settings["fix_elements_model_parts"])
# Setting flag BLOCKED to the non elements
for submodelpart in fix_elements_model_parts:
KratosMultiphysics.VariableUtils().SetFlag(KratosMultiphysics.BLOCKED, True, submodelpart.Elements)
if self.strategy == "LevelSet":
self._CreateGradientProcess()
if self.domain_size == 2:
self.initialize_metric = MeshingApplication.MetricFastInit2D(self.main_model_part)
else:
self.initialize_metric = MeshingApplication.MetricFastInit3D(self.main_model_part)
self.initialize_metric.Execute()
self._CreateMetricsProcess()
mmg_parameters = KratosMultiphysics.Parameters("""{"force_sizes":{}}""")
mmg_parameters.AddValue("filename",self.settings["filename"])
mmg_parameters.AddValue("framework",self.settings["framework"])
mmg_parameters.AddValue("discretization_type",self.settings["discretization_type"])
mmg_parameters.AddValue("isosurface_parameters",self.settings["isosurface_parameters"])
mmg_parameters.AddValue("internal_variables_parameters",self.settings["internal_variables_parameters"])
mmg_parameters.AddValue("collapse_prisms_elements",self.settings["collapse_prisms_elements"])
mmg_parameters.AddValue("save_external_files",self.settings["save_external_files"])
mmg_parameters.AddValue("save_colors_files",self.settings["save_colors_files"])
mmg_parameters.AddValue("save_mdpa_file",self.settings["save_mdpa_file"])
mmg_parameters.AddValue("max_number_of_searchs",self.settings["max_number_of_searchs"])
mmg_parameters.AddValue("preserve_flags",self.settings["preserve_flags"])
mmg_parameters.AddValue("interpolate_non_historical",self.settings["interpolate_non_historical"])
mmg_parameters.AddValue("extrapolate_contour_values",self.settings["extrapolate_contour_values"])
mmg_parameters.AddValue("search_parameters",self.settings["search_parameters"])
mmg_parameters["force_sizes"].AddValue("force_min",self.settings["force_min"])
mmg_parameters["force_sizes"].AddValue("minimal_size",self.settings["minimal_size"])
mmg_parameters["force_sizes"].AddValue("force_max",self.settings["force_max"])
mmg_parameters["force_sizes"].AddValue("maximal_size",self.settings["maximal_size"])
mmg_parameters.AddValue("advanced_parameters",self.settings["advanced_parameters"])
mmg_parameters.AddValue("debug_result_mesh",self.settings["debug_result_mesh"])
mmg_parameters.AddValue("initialize_entities",self.settings["initialize_entities"])
mmg_parameters.AddValue("echo_level",self.settings["echo_level"])
if self.domain_size == 2:
self.mmg_process = MeshingApplication.MmgProcess2D(self.main_model_part, mmg_parameters)
else:
# Differentiate between 3D volumes and 3D surfaces
if self.is_surface:
self.mmg_process = MeshingApplication.MmgProcess3DSurfaces(self.main_model_part, mmg_parameters)
else:
self.mmg_process = MeshingApplication.MmgProcess3D(self.main_model_part, mmg_parameters)
# We reset the step and time
self.step = 0
self.time = 0.0
# We compute initial remeshing is desired
if self.initial_remeshing:
if not self.main_model_part.Is(KratosMultiphysics.MODIFIED):
self._ExecuteRefinement()
else:
self.main_model_part.Set(KratosMultiphysics.MODIFIED, False)
def ExecuteInitialize(self):
result_file_configuration = self.param["result_file_configuration"]
result_file_configuration.ValidateAndAssignDefaults(
self.defaults["result_file_configuration"])
# If either of these is True, we will have a volume output file
self.body_output = result_file_configuration["body_output"].GetBool()
self.node_output = result_file_configuration["node_output"].GetBool()
# If skin_output is True or we have output planes, we will have a cut output file
self.skin_output = result_file_configuration["skin_output"].GetBool()
plane_output_configuration = result_file_configuration[
"plane_output"] # should be of array type
self.num_planes = plane_output_configuration.size()
# Generate the cuts and store them in self.cut_model_part
if self.skin_output or self.num_planes > 0:
model = self.model_part.GetModel()
self.cut_model_part = model.CreateModelPart("CutPart")
self.cut_manager = self._CreateCuttingUtility()
self._initialize_cut_output(plane_output_configuration)
# Retrieve gidpost flags and setup GiD output tool
gidpost_flags = result_file_configuration["gidpost_flags"]
gidpost_flags.ValidateAndAssignDefaults(
self.defaults["result_file_configuration"]["gidpost_flags"])
self._InitializeGiDIO(gidpost_flags, gidpost_flags)
# Process nodal and gauss point output
self.nodal_variables = kratos_utilities.GenerateVariableListFromInput(
result_file_configuration["nodal_results"])
self.gauss_point_variables = kratos_utilities.GenerateVariableListFromInput(
result_file_configuration["gauss_point_results"])
self.nodal_nonhistorical_variables = kratos_utilities.GenerateVariableListFromInput(
result_file_configuration["nodal_nonhistorical_results"])
self.nodal_flags = kratos_utilities.GenerateFlagsListFromInput(
result_file_configuration["nodal_flags_results"])
self.nodal_flags_names = []
for i in range(
result_file_configuration["nodal_flags_results"].size()):
self.nodal_flags_names.append(
result_file_configuration["nodal_flags_results"]
[i].GetString())
self.elemental_conditional_flags = kratos_utilities.GenerateFlagsListFromInput(
result_file_configuration["elemental_conditional_flags_results"])
self.elemental_conditional_flags_names = []
for i in range(result_file_configuration[
"elemental_conditional_flags_results"].size()):
self.elemental_conditional_flags_names.append(
result_file_configuration[
"elemental_conditional_flags_results"][i].GetString())
# Set up output frequency and format
output_file_label = result_file_configuration["file_label"].GetString()
if output_file_label == "time":
self.output_label_is_time = True
elif output_file_label == "step":
self.output_label_is_time = False
else:
msg = "{0} Error: Unknown value \"{1}\" read for parameter \"{2}\"".format(
self.__class__.__name__, output_file_label, "file_label")
raise Exception(msg)
output_control_type = result_file_configuration[
"output_control_type"].GetString()
if output_control_type == "time":
self.output_control_is_time = True
elif output_control_type == "step":
self.output_control_is_time = False
else:
msg = "{0} Error: Unknown value \"{1}\" read for parameter \"{2}\"".format(
self.__class__.__name__, output_file_label, "file_label")
raise Exception(msg)
self.output_interval = result_file_configuration[
"output_interval"].GetDouble()
self.flush_after_output = result_file_configuration[
"flush_after_output"].GetBool()
# get .post.lst files
additional_list_file_data = result_file_configuration[
"additional_list_files"]
additional_list_files = [
additional_list_file_data[i].GetInt()
for i in range(0, additional_list_file_data.size())
]
# Set current time parameters
if self.model_part.ProcessInfo[KM.IS_RESTARTED]:
self._SetCurrentTimeParameters(additional_list_files)
else:
# Create .post.lst files
self._InitializeListFiles(additional_list_files)
# Process point recording data
if self.point_output_process is not None:
self.point_output_process.ExecuteInitialize()