def _create_remeshing_process(self): if (self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2): remeshing_process = MeshingApplication.MmgProcess2D(self.main_model_part, self.adaptative_remesh_parameters["remeshing_parameters"]) else: remeshing_process = MeshingApplication.MmgProcess3D(self.main_model_part, self.adaptative_remesh_parameters["remeshing_parameters"]) return remeshing_process
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 __ExecuteRefinement(self): if (self.domain_size == 2): MmgProcess = KratosMeshing.MmgProcess2D(self.main_model_part, self.mmg_parameters) MmgProcess.Execute() elif (self.domain_size == 3): MmgProcess = KratosMeshing.MmgProcess3D(self.main_model_part, self.mmg_parameters) MmgProcess.Execute()
def _create_remeshing_process(self): if (self.main_model_part.ProcessInfo[KM.DOMAIN_SIZE] == 2): remeshing_process = MA.MmgProcess2D( self.main_model_part, self.adaptative_remesh_parameters["remeshing_parameters"]) else: remeshing_process = MA.MmgProcess3D( self.main_model_part, self.adaptative_remesh_parameters["remeshing_parameters"]) return remeshing_process
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
"anisotropy_remeshing" : true, "anisotropy_parameters": { "hmin_over_hmax_anisotropic_ratio" : 0.01, "boundary_layer_max_distance" : 0.5, "interpolation" : "Linear" } } """) metric_process = MeshingApplication.ComputeLevelSetSolMetricProcess3D( main_model_part, KratosMultiphysics.DISTANCE_GRADIENT, level_set_param) metric_process.Execute() # We create the remeshing process remesh_param = KratosMultiphysics.Parameters("""{ }""") MmgProcess = MeshingApplication.MmgProcess3D(main_model_part, remesh_param) MmgProcess.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" },
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)
def test_isosurface_remesh_sphere(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) main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.DISTANCE_GRADIENT) # We import the model main_model_part file_path = os.path.dirname(os.path.realpath(__file__)) KratosMultiphysics.ModelPartIO( file_path + "/mmg_eulerian_test/test_sphere_isosurface").ReadModelPart( main_model_part) # Set manually a distance function circle_radious = 0.25 center_coordinates = [0.5, 0.5, 0.5] for node in main_model_part.Nodes: distance = ( (node.X - center_coordinates[0])**2 + (node.Y - center_coordinates[1])**2 + (node.Z - center_coordinates[2])**2)**0.5 - circle_radious node.SetSolutionStepValue(KratosMultiphysics.DISTANCE, distance) # We calculate the gradient of the distance variable find_nodal_h = KratosMultiphysics.FindNodalHNonHistoricalProcess( main_model_part) find_nodal_h.Execute() mmg_parameters = KratosMultiphysics.Parameters(""" { "discretization_type" : "Isosurface", "filename" : "mmg_eulerian_test/test_sphere_isosurface", "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.MmgProcess3D(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/test_sphere_isosurface_result.sol", "output_file_name" : "mmg_eulerian_test/test_sphere_isosurface_step=0.o.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()
def test_remesh_sphere(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) main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.DISTANCE_GRADIENT) # 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_test" ).ReadModelPart(main_model_part) # We calculate the gradient of the distance variable find_nodal_h = KratosMultiphysics.FindNodalHNonHistoricalProcess( main_model_part) find_nodal_h.Execute() KratosMultiphysics.VariableUtils().SetNonHistoricalVariable( KratosMultiphysics.NODAL_AREA, 0.0, main_model_part.Nodes) local_gradient = KratosMultiphysics.ComputeNodalGradientProcess3D( main_model_part, KratosMultiphysics.DISTANCE, KratosMultiphysics.DISTANCE_GRADIENT, KratosMultiphysics.NODAL_AREA) local_gradient.Execute() # We set to zero the metric ZeroVector = KratosMultiphysics.Vector(6) ZeroVector[0] = 0.0 ZeroVector[1] = 0.0 ZeroVector[2] = 0.0 ZeroVector[3] = 0.0 ZeroVector[4] = 0.0 ZeroVector[5] = 0.0 for node in main_model_part.Nodes: node.SetValue(MeshingApplication.METRIC_TENSOR_3D, ZeroVector) # We define a metric using the ComputeLevelSetSolMetricProcess MetricParameters = KratosMultiphysics.Parameters(""" { "minimal_size" : 1.0e-1, "enforce_current" : false, "anisotropy_remeshing" : false, "anisotropy_parameters" :{ "hmin_over_hmax_anisotropic_ratio" : 0.15, "boundary_layer_max_distance" : 1.0e-4, "interpolation" : "Linear" } } """) metric_process = MeshingApplication.ComputeLevelSetSolMetricProcess3D( main_model_part, KratosMultiphysics.DISTANCE_GRADIENT, MetricParameters) metric_process.Execute() mmg_parameters = KratosMultiphysics.Parameters(""" { "filename" : "mmg_eulerian_test/coarse_sphere_test", "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.MmgProcess3D(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_test_result.sol", "output_file_name" : "mmg_eulerian_test/coarse_sphere_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() import from_json_check_result_process check_parameters = KratosMultiphysics.Parameters(""" { "check_variables" : ["DISTANCE"], "input_file_name" : "mmg_eulerian_test/distante_extrapolation.json", "model_part_name" : "MainModelPart", "time_frequency" : 0.0 } """) check_parameters["input_file_name"].SetString( file_path + "/" + check_parameters["input_file_name"].GetString()) check = from_json_check_result_process.FromJsonCheckResultProcess( current_model, check_parameters) check.ExecuteInitialize() check.ExecuteBeforeSolutionLoop() check.ExecuteFinalizeSolutionStep()
def test_remesh_sphere(self): # We create the model part main_model_part = KratosMultiphysics.ModelPart("MainModelPart") main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, 3) # We add the variables needed main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.DISTANCE) main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.DISTANCE_GRADIENT) main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.NODAL_H) main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.NODAL_AREA) for node in main_model_part.Nodes: node.AddDof(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_test" ).ReadModelPart(main_model_part) # We calculate the gradient of the distance variable find_nodal_h = KratosMultiphysics.FindNodalHProcess(main_model_part) find_nodal_h.Execute() local_gradient = KratosMultiphysics.ComputeNodalGradientProcess3D( main_model_part, KratosMultiphysics.DISTANCE, KratosMultiphysics.DISTANCE_GRADIENT, KratosMultiphysics.NODAL_AREA) local_gradient.Execute() # We set to zero the metric ZeroVector = KratosMultiphysics.Vector(6) ZeroVector[0] = 0.0 ZeroVector[1] = 0.0 ZeroVector[2] = 0.0 ZeroVector[3] = 0.0 ZeroVector[4] = 0.0 ZeroVector[5] = 0.0 for node in main_model_part.Nodes: node.SetValue(MeshingApplication.MMG_METRIC, ZeroVector) # We define a metric using the ComputeLevelSetSolMetricProcess MetricParameters = KratosMultiphysics.Parameters(""" { "minimal_size" : 1.0e-1, "enforce_current" : false, "anisotropy_remeshing" : false, "anisotropy_parameters" :{ "hmin_over_hmax_anisotropic_ratio" : 0.15, "boundary_layer_max_distance" : 1.0e-4, "interpolation" : "Linear" } } """) metric_process = MeshingApplication.ComputeLevelSetSolMetricProcess3D( main_model_part, KratosMultiphysics.DISTANCE_GRADIENT, MetricParameters) metric_process.Execute() mmg_parameters = KratosMultiphysics.Parameters(""" { "filename" : "mmg_eulerian_test/coarse_sphere_test", "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.MmgProcess3D(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" : [] } } """)) #gid_output.ExecuteInitialize() #gid_output.ExecuteBeforeSolutionLoop() #gid_output.ExecuteInitializeSolutionStep() #gid_output.PrintOutput() #gid_output.ExecuteFinalizeSolutionStep() #gid_output.ExecuteFinalize() import filecmp value = filecmp.cmp( file_path + "/mmg_eulerian_test/coarse_sphere_test_result.mesh", file_path + "/mmg_eulerian_test/coarse_sphere_test_step=0.o.mesh") self.assertTrue(value)