def ExecuteInitialize(self):
# NOTE: Add more model part if interested
submodelpartslist = self.__generate_submodelparts_list_from_input(self.params["fix_contour_model_parts"])
for submodelpart in submodelpartslist:
for node in submodelpart.Nodes:
node.Set(KratosMultiphysics.BLOCKED, True)
if (self.strategy == "LevelSet"):
self._CreateGradientProcess()
if (self.dim == 2):
self.initialize_metric = MeshingApplication.MetricFastInit2D(self.Model[self.model_part_name])
else:
self.initialize_metric = MeshingApplication.MetricFastInit3D(self.Model[self.model_part_name])
self.initialize_metric.Execute()
self._CreateMetricsProcess()
mmg_parameters = KratosMultiphysics.Parameters("""{}""")
mmg_parameters.AddValue("filename",self.params["filename"])
mmg_parameters.AddValue("framework",self.params["framework"])
mmg_parameters.AddValue("internal_variables_parameters",self.params["internal_variables_parameters"])
mmg_parameters.AddValue("save_external_files",self.params["save_external_files"])
mmg_parameters.AddValue("max_number_of_searchs",self.params["max_number_of_searchs"])
mmg_parameters.AddValue("echo_level",self.params["echo_level"])
if (self.dim == 2):
self.MmgProcess = MeshingApplication.MmgProcess2D(self.Model[self.model_part_name], mmg_parameters)
else:
self.MmgProcess = MeshingApplication.MmgProcess3D(self.Model[self.model_part_name], mmg_parameters)
if (self.initial_remeshing == True):
self._ExecuteRefinement()
def ExecuteInitialize(self):
# NOTE: Add more model part if interested
submodelpartslist = self.__generate_submodelparts_list_from_input(
self.params["fix_contour_model_parts"])
for submodelpart in submodelpartslist:
for node in submodelpart.Nodes:
node.Set(KratosMultiphysics.BLOCKED, True)
if (self.strategy == "LevelSet"):
self._CreateGradientProcess()
if (self.dim == 2):
self.initialize_metric = MeshingApplication.MetricFastInit2D(
self.Model[self.model_part_name])
else:
self.initialize_metric = MeshingApplication.MetricFastInit3D(
self.Model[self.model_part_name])
self.initialize_metric.Execute()
self._CreateMetricsProcess()
if (self.dim == 2):
self.MmgUtility = MeshingApplication.MmgUtility2D(
self.Model[self.model_part_name], self.params)
else:
self.MmgUtility = MeshingApplication.MmgUtility3D(
self.Model[self.model_part_name], self.params)
if (self.initial_remeshing == True):
self._ExecuteRefinement()
def ExecuteInitialize(self):
# Calculate NODAL_H
self.find_nodal_h = KratosMultiphysics.FindNodalHProcess(
self.model_part)
self.find_nodal_h.Execute()
# Calculate the parameters of automatic remeshing
if (self.settings["automatic_remesh"].GetBool() == True):
import statistics as stat
nodal_h_values = []
for node in self.model_part.Nodes:
nodal_h_values.append(
node.GetSolutionStepValue(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
# Anisotropic remeshing parameters
self.anisotropy_remeshing = self.settings[
"anisotropy_remeshing"].GetBool()
if (self.anisotropy_remeshing == True):
if (self.settings["automatic_remesh"].GetBool() == True):
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_variable = self.__generate_variable_list_from_input(
self.settings["hessian_strategy_parameters"]
["metric_variable"])
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.dim / (self.dim + 1))**2.0)
self.internal_variable_interpolation_list = self.__generate_internal_variable_list_from_input(
self.settings["internal_variables_parameters"]
["internal_variable_interpolation_list"])
# NOTE: Add more model part if interested
submodelpartslist = self.__generate_submodelparts_list_from_input(
self.settings["fix_contour_model_parts"])
for submodelpart in submodelpartslist:
for node in submodelpart.Nodes:
node.Set(KratosMultiphysics.BLOCKED, True)
if (self.strategy == "LevelSet"):
self._CreateGradientProcess()
if (self.dim == 2):
self.initialize_metric = MeshingApplication.MetricFastInit2D(
self.model_part)
else:
self.initialize_metric = MeshingApplication.MetricFastInit3D(
self.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("internal_variables_parameters",
self.settings["internal_variables_parameters"])
mmg_parameters.AddValue("save_external_files",
self.settings["save_external_files"])
mmg_parameters.AddValue("max_number_of_searchs",
self.settings["max_number_of_searchs"])
mmg_parameters["force_sizes"].AddValue("force_min",
self.settings["force_min"])
mmg_parameters["force_sizes"].AddValue("minimal_size",
self.settings["maximal_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("echo_level", self.settings["echo_level"])
if (self.dim == 2):
self.mmg_process = MeshingApplication.MmgProcess2D(
self.model_part, mmg_parameters)
else:
self.mmg_process = MeshingApplication.MmgProcess3D(
self.model_part, mmg_parameters)
# We reset the step
self.step = 0
# We compute initial remeshing is desired
if (self.initial_remeshing == True):
if (self.model_part.Is(KratosMultiphysics.MODIFIED) == False):
self._ExecuteRefinement()
else:
self.model_part.Set(KratosMultiphysics.MODIFIED, False)
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():
import statistics as stat
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
# 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_variable = self.__generate_variable_list_from_input(self.settings["hessian_strategy_parameters"]["metric_variable"])
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":
self.error_threshold = self.settings["error_strategy_parameters"]["error_metric_parameters"]["error_threshold"].GetDouble()
self.estimated_error = 0
self.remeshing_cycle = 0
self.main_model_part.ProcessInfo[MeshingApplication.EXECUTE_REMESHING] = True
self.internal_variable_interpolation_list = self.__generate_internal_variable_list_from_input(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("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
self.step = 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)
