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()