def CreateRemeshingProcess(main_model_part, adaptative_remesh_parameters):
if main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2:
remeshing_process = MeshingApplication.MmgProcess2D(main_model_part, adaptative_remesh_parameters["remeshing_parameters"])
else:
is_surface = False
for elem in main_model_part.Elements:
geom = elem.GetGeometry()
if geom.WorkingSpaceDimension() != geom.LocalSpaceDimension():
is_surface = True
break
if is_surface:
remeshing_process = MeshingApplication.MmgProcess3DSurfaces(main_model_part, adaptative_remesh_parameters["remeshing_parameters"])
else:
remeshing_process = MeshingApplication.MmgProcess3D(main_model_part, adaptative_remesh_parameters["remeshing_parameters"])
return remeshing_process
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)
def test_remesh_sphere_skin_prisms(self):
KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(
KratosMultiphysics.Logger.Severity.WARNING)
# We create the model part
current_model = KratosMultiphysics.Model()
main_model_part = current_model.CreateModelPart("MainModelPart")
main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, 3)
main_model_part.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0.0)
main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DELTA_TIME,
1.0)
#main_model_part.ProcessInfo.SetValue(KratosMultiphysics.STEP, 1)
# We add the variables needed
main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.DISTANCE)
# We import the model main_model_part
file_path = os.path.dirname(os.path.realpath(__file__))
KratosMultiphysics.ModelPartIO(
file_path +
"/mmg_eulerian_test/coarse_sphere_skin_prisms_test").ReadModelPart(
main_model_part)
for node in main_model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.DISTANCE, abs(node.X))
# We calculate the gradient of the distance variable
KratosMultiphysics.VariableUtils().SetNonHistoricalVariable(
KratosMultiphysics.NODAL_H, 0.0, main_model_part.Nodes)
find_nodal_h = KratosMultiphysics.FindNodalHNonHistoricalProcess(
main_model_part)
find_nodal_h.Execute()
# We set to zero the metric
metric_vector = KratosMultiphysics.Vector(6)
metric_vector[0] = 1.0
metric_vector[1] = 1.0
metric_vector[2] = 1.0
metric_vector[3] = 0.0
metric_vector[4] = 0.0
metric_vector[5] = 0.0
for node in main_model_part.Nodes:
node.SetValue(MeshingApplication.METRIC_TENSOR_3D, metric_vector)
mmg_parameters = KratosMultiphysics.Parameters("""
{
"filename" : "mmg_eulerian_test/coarse_sphere_skin_prisms_test",
"collapse_prisms_elements" : true,
"save_external_files" : true,
"echo_level" : 0
}
""")
# We create the remeshing utility
mmg_parameters["filename"].SetString(
file_path + "/" + mmg_parameters["filename"].GetString())
mmg_process = MeshingApplication.MmgProcess3DSurfaces(
main_model_part, mmg_parameters)
# We remesh
mmg_process.Execute()
## Finally we export to GiD
#from gid_output_process import GiDOutputProcess
#gid_output = GiDOutputProcess(main_model_part,
#"gid_output",
#KratosMultiphysics.Parameters("""
#{
#"result_file_configuration" : {
#"gidpost_flags": {
#"GiDPostMode": "GiD_PostBinary",
#"WriteDeformedMeshFlag": "WriteUndeformed",
#"WriteConditionsFlag": "WriteConditions",
#"MultiFileFlag": "SingleFile"
#},
#"nodal_results" : ["DISTANCE"]
#}
#}
#""")
#)
#gid_output.ExecuteInitialize()
#gid_output.ExecuteBeforeSolutionLoop()
#gid_output.ExecuteInitializeSolutionStep()
#gid_output.PrintOutput()
#gid_output.ExecuteFinalizeSolutionStep()
#gid_output.ExecuteFinalize()
from compare_two_files_check_process import CompareTwoFilesCheckProcess
check_parameters = KratosMultiphysics.Parameters("""
{
"reference_file_name" : "mmg_eulerian_test/coarse_sphere_skin_prisms_test_result.sol",
"output_file_name" : "mmg_eulerian_test/coarse_sphere_skin_prisms_test_step=0.sol",
"dimension" : 3,
"comparison_type" : "sol_file"
}
""")
check_parameters["reference_file_name"].SetString(
file_path + "/" +
check_parameters["reference_file_name"].GetString())
check_parameters["output_file_name"].SetString(
file_path + "/" + check_parameters["output_file_name"].GetString())
check_files = CompareTwoFilesCheckProcess(check_parameters)
check_files.ExecuteInitialize()
check_files.ExecuteBeforeSolutionLoop()
check_files.ExecuteInitializeSolutionStep()
check_files.ExecuteFinalizeSolutionStep()
check_files.ExecuteFinalize()
