def _create_metric_process(self):
if (self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2):
metric_process = MeshingApplication.MetricErrorProcess2D(self.main_model_part, self.adaptative_remesh_parameters["metric_error_parameters"])
else:
metric_process = MeshingApplication.MetricErrorProcess3D(self.main_model_part, self.adaptative_remesh_parameters["metric_error_parameters"])
return metric_process
def CreateMetricProcess(main_model_part, adaptative_remesh_parameters):
if main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2:
metric_process = MeshingApplication.MetricErrorProcess2D(main_model_part, adaptative_remesh_parameters["metric_error_parameters"])
else:
metric_process = MeshingApplication.MetricErrorProcess3D(main_model_part, adaptative_remesh_parameters["metric_error_parameters"])
return metric_process
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 _RefineMesh(self):
''' This function remeshes the main_model_part according to the distance, using the MMG process from the MeshingApplication.
In order to perform the refinement, it is needed to calculate the distance gradient, the initial nodal_h and the level_set metric.
'''
ini_time=time.time()
local_gradient = KratosMultiphysics.ComputeNodalGradientProcess2D(self.main_model_part, KratosMultiphysics.DISTANCE, KratosMultiphysics.DISTANCE_GRADIENT, KratosMultiphysics.NODAL_AREA)
local_gradient.Execute()
find_nodal_h = KratosMultiphysics.FindNodalHNonHistoricalProcess(self.main_model_part)
find_nodal_h.Execute()
KratosMultiphysics.VariableUtils().SetNonHistoricalVariableToZero(KratosMultiphysics.MeshingApplication.METRIC_TENSOR_2D,self.main_model_part.Nodes)
metric_process = MeshingApplication.ComputeLevelSetSolMetricProcess2D(self.main_model_part, KratosMultiphysics.DISTANCE_GRADIENT, self.metric_parameters)
metric_process.Execute()
mmg_parameters = KratosMultiphysics.Parameters("""
{
"discretization_type" : "STANDARD",
"save_external_files" : false,
"initialize_entities" : false,
"echo_level" : 0
}
""")
mmg_process = MeshingApplication.MmgProcess2D(self.main_model_part, mmg_parameters)
mmg_process.Execute()
KratosMultiphysics.Logger.PrintInfo('LevelSetRemeshing','Remesh time: ',time.time()-ini_time)
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):
# 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 AdaptMesh(self):
import KratosMultiphysics.MeshingApplication as KMesh
admissible_ratio = 0.05
max_levels = 2
refinement_utils = KMesh.RefinementUtilities()
if(self.domain_size == 2):
raise "error refine in 2d not yet implemented"
else:
Refine = KMesh.LocalRefineTetrahedraMesh(self.model_part)
# just to be sure nothign is done
(self.model_part).ProcessInfo[FRACTIONAL_STEP] = 10
refinement_utils.MarkForRefinement(
ERROR_RATIO,
self.model_part,
admissible_ratio,
max_levels)
self.Clear()
refine_on_reference = False
interpolate_internal_variables = False
Refine.LocalRefineMesh(
refine_on_reference,
interpolate_internal_variables)
(self.neighbour_search).Execute()
self.slip_conditions_initialized = False
print("Refining finished")
def _CreateMetricsProcess(self):
self.metric_processes = []
if self.strategy == "LevelSet":
level_set_parameters = KratosMultiphysics.Parameters("""{}""")
level_set_parameters.AddValue("minimal_size",self.settings["minimal_size"])
level_set_parameters.AddValue("maximal_size",self.settings["maximal_size"])
level_set_parameters.AddValue("sizing_parameters",self.settings["sizing_parameters"])
level_set_parameters.AddValue("enforce_current",self.settings["enforce_current"])
level_set_parameters.AddValue("anisotropy_remeshing",self.settings["anisotropy_remeshing"])
level_set_parameters.AddValue("anisotropy_parameters",self.settings["anisotropy_parameters"])
level_set_parameters["anisotropy_parameters"].RemoveValue("boundary_layer_min_size_ratio")
if self.domain_size == 2:
self.metric_processes.append(MeshingApplication.ComputeLevelSetSolMetricProcess2D(self.main_model_part, self.gradient_variable, level_set_parameters))
else:
self.metric_processes.append(MeshingApplication.ComputeLevelSetSolMetricProcess3D(self.main_model_part, self.gradient_variable, level_set_parameters))
elif self.strategy == "Hessian":
hessian_parameters = KratosMultiphysics.Parameters("""{}""")
hessian_parameters.AddValue("minimal_size",self.settings["minimal_size"])
hessian_parameters.AddValue("maximal_size",self.settings["maximal_size"])
hessian_parameters.AddValue("enforce_current",self.settings["enforce_current"])
hessian_parameters.AddValue("hessian_strategy_parameters",self.settings["hessian_strategy_parameters"])
hessian_parameters["hessian_strategy_parameters"].RemoveValue("metric_variable")
hessian_parameters.AddValue("anisotropy_remeshing",self.settings["anisotropy_remeshing"])
hessian_parameters.AddValue("enforce_anisotropy_relative_variable",self.settings["enforce_anisotropy_relative_variable"])
hessian_parameters.AddValue("enforced_anisotropy_parameters",self.settings["anisotropy_parameters"])
hessian_parameters["enforced_anisotropy_parameters"].RemoveValue("boundary_layer_min_size_ratio")
for current_metric_variable in self.metric_variable:
self.metric_processes.append(MeshingApplication.ComputeHessianSolMetricProcess(self.main_model_part, current_metric_variable, hessian_parameters))
elif self.strategy == "superconvergent_patch_recovery":
if not structural_dependencies:
raise Exception("You need to compile the StructuralMechanicsApplication in order to use this criteria")
# We compute the error
error_compute_parameters = KratosMultiphysics.Parameters("""{}""")
error_compute_parameters.AddValue("stress_vector_variable", self.settings["compute_error_extra_parameters"]["stress_vector_variable"])
error_compute_parameters.AddValue("echo_level", self.settings["echo_level"])
if self.domain_size == 2:
self.error_compute = StructuralMechanicsApplication.SPRErrorProcess2D(self.main_model_part, error_compute_parameters)
else:
self.error_compute = StructuralMechanicsApplication.SPRErrorProcess3D(self.main_model_part, error_compute_parameters)
# Now we compute the metric
error_metric_parameters = KratosMultiphysics.Parameters("""{}""")
error_metric_parameters.AddValue("minimal_size",self.settings["minimal_size"])
error_metric_parameters.AddValue("maximal_size",self.settings["maximal_size"])
error_metric_parameters.AddValue("target_error",self.settings["error_strategy_parameters"]["error_metric_parameters"]["interpolation_error"])
error_metric_parameters.AddValue("set_target_number_of_elements", self.settings["error_strategy_parameters"]["set_target_number_of_elements"])
error_metric_parameters.AddValue("target_number_of_elements", self.settings["error_strategy_parameters"]["target_number_of_elements"])
error_metric_parameters.AddValue("perform_nodal_h_averaging", self.settings["error_strategy_parameters"]["perform_nodal_h_averaging"])
error_metric_parameters.AddValue("echo_level", self.settings["echo_level"])
if self.domain_size == 2:
self.metric_process = MeshingApplication.MetricErrorProcess2D(self.main_model_part, error_metric_parameters)
else:
self.metric_process = MeshingApplication.MetricErrorProcess3D(self.main_model_part, error_metric_parameters)
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 _create_metric_process(self):
if (self.main_model_part.ProcessInfo[KM.DOMAIN_SIZE] == 2):
metric_process = MA.MetricErrorProcess2D(
self.main_model_part,
self.adaptative_remesh_parameters["metric_error_parameters"])
else:
metric_process = MA.MetricErrorProcess3D(
self.main_model_part,
self.adaptative_remesh_parameters["metric_error_parameters"])
return metric_process
def compute_refinement_hessian_metric(simulation_coarse, minimal_size_value,
maximal_size_value, metric_param,
remesh_param):
simulation_coarse._GetSolver().print_on_rank_zero(
"::[compute_refinement]:: ", "refinement started")
'''set NODAL_AREA and NODAL_H as non historical variables'''
KratosMultiphysics.VariableUtils().SetNonHistoricalVariable(
KratosMultiphysics.NODAL_AREA, 0.0,
simulation_coarse._GetSolver().main_model_part.Nodes)
KratosMultiphysics.VariableUtils().SetNonHistoricalVariable(
KratosMultiphysics.NODAL_H, 0.0,
simulation_coarse._GetSolver().main_model_part.Nodes)
'''calculate NODAL_H'''
find_nodal_h = KratosMultiphysics.FindNodalHProcess(
simulation_coarse._GetSolver().main_model_part)
find_nodal_h = KratosMultiphysics.FindNodalHNonHistoricalProcess(
simulation_coarse._GetSolver().main_model_part)
find_nodal_h.Execute()
'''prepare parameters to calculate the gradient of the designed variable'''
local_gradient_variable_string = metric_param[
"local_gradient_variable"].GetString()
local_gradient_variable = KratosMultiphysics.KratosGlobals.GetVariable(
metric_param["local_gradient_variable"].GetString())
metric_param.RemoveValue("local_gradient_variable")
metric_param.AddEmptyValue("minimal_size")
metric_param["minimal_size"].SetDouble(minimal_size_value)
metric_param.AddEmptyValue("maximal_size")
metric_param["maximal_size"].SetDouble(maximal_size_value)
'''calculate the gradient of the variable'''
local_gradient = KratosMeshing.ComputeHessianSolMetricProcess(
simulation_coarse._GetSolver().main_model_part,
local_gradient_variable, metric_param)
local_gradient.Execute()
'''add again the removed variable parameter'''
metric_param.AddEmptyValue("local_gradient_variable")
metric_param["local_gradient_variable"].SetString(
local_gradient_variable_string)
'''create the remeshing process'''
MmgProcess = KratosMeshing.MmgProcess2D(
simulation_coarse._GetSolver().main_model_part, remesh_param)
MmgProcess.Execute()
'''the refinement process empties the coarse model part object and fill it with the refined model part
the solution on the refined grid is obtained from the interpolation of the coarse solution
there are not other operations, so to build the new model we just need to take the updated coarse model'''
simulation_coarse._GetSolver().print_on_rank_zero(
"::[compute_refinement]:: ",
"start saving refined model and parameters")
current_model_refined = simulation_coarse.model
return current_model_refined
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 __init__(self, Model, settings):
KratosMultiphysics.Process.__init__(self)
default_settings = KratosMultiphysics.Parameters("""
{
"help" : "This process extrapolates the values from integration points to the mesh nodes",
"model_part_name" : "",
"echo_level" : 0,
"average_variable" : "NODAL_AREA",
"area_average" : true,
"list_of_variables" : [],
"extrapolate_non_historical" : true
}
""")
settings.ValidateAndAssignDefaults(default_settings)
self.model_part = Model[settings["model_part_name"].GetString()]
extrapolation_parameters = KratosMultiphysics.Parameters("""{}""")
extrapolation_parameters.AddValue("echo_level", settings["echo_level"])
extrapolation_parameters.AddValue("average_variable",
settings["average_variable"])
extrapolation_parameters.AddValue("area_average",
settings["area_average"])
extrapolation_parameters.AddValue("list_of_variables",
settings["list_of_variables"])
extrapolation_parameters.AddValue(
"extrapolate_non_historical",
settings["extrapolate_non_historical"])
self.integration_values_extrapolation_to_nodes_process = MeshingApplication.IntegrationValuesExtrapolationToNodesProcess(
self.model_part, extrapolation_parameters)
def PerformRemeshingIfNecessary(self):
debug_metric = False
if debug_metric:
params = KratosMultiphysics.Parameters("""{}""")
KratosFemDem.ComputeNormalizedFreeEnergyOnNodesProcess(self.FEM_Solution.main_model_part, self.FEM_Solution.ProjectParameters["AMR_data"]["hessian_variable_parameters"]).Execute()
MeshingApplication.ComputeHessianSolMetricProcess(self.FEM_Solution.main_model_part, KratosFemDem.EQUIVALENT_NODAL_STRESS, params).Execute()
if self.DoRemeshing:
is_remeshing = self.CheckIfHasRemeshed()
if is_remeshing:
if self.echo_level > 0:
KratosMultiphysics.Logger.PrintInfo("FEM-DEM:: ComputeNormalizedFreeEnergyOnNodesProcess")
# Extrapolate the free energy as a remeshing criterion
parameters = self.FEM_Solution.ProjectParameters["AMR_data"]["hessian_variable_parameters"]
KratosFemDem.ComputeNormalizedFreeEnergyOnNodesProcess(self.FEM_Solution.main_model_part, parameters).Execute()
# we eliminate the nodal DEM forces
self.RemoveDummyNodalForces()
# Perform remeshing
self.RemeshingProcessMMG.ExecuteInitializeSolutionStep()
if is_remeshing:
if self.echo_level > 0:
KratosMultiphysics.Logger.PrintInfo("FEM-DEM:: InitializeSolutionAfterRemeshing")
self.InitializeSolutionAfterRemeshing()
neighbour_elemental_finder = KratosMultiphysics.FindElementalNeighboursProcess(self.FEM_Solution.main_model_part, 2, 5)
neighbour_elemental_finder.ClearNeighbours()
neighbour_elemental_finder.Execute()
def ExecuteInitializeSolutionStep(self):
""" This method is executed in order to initialize the current step
Keyword arguments:
self -- It signifies an instance of a class.
"""
# If not previous remesh
if not self.remesh_executed:
if not self.initial_remeshing:
# We need to check if the model part has been modified recently
if self.main_model_part.Is(KratosMultiphysics.MODIFIED):
self.main_model_part.Set(KratosMultiphysics.MODIFIED, False)
self.step = 0 # Reset (just to be sure)
self.time = 0.0 # Reset (just to be sure)
else:
current_time = self.main_model_part.ProcessInfo[KratosMultiphysics.TIME]
if self.interval.IsInInterval(current_time):
# We remesh if needed
if self.__execute_remesh():
if self.strategy == "Hessian" or self.strategy == "LevelSet":
if self.settings["blocking_threshold_size"].GetBool():
MeshingApplication.BlockThresholdSizeElements(self.main_model_part, self.settings["threshold_sizes"])
self._ExecuteRefinement()
self.initial_step_done = True
self.step = 0 # Reset
self.time = 0.0 # Reset
def ExecuteInitializeSolutionStep(self):
""" This method is executed in order to initialize the current step
Keyword arguments:
self -- It signifies an instance of a class.
"""
if not self.initial_remeshing:
# We need to check if the model part has been modified recently
if self.model_part.Is(KratosMultiphysics.MODIFIED):
self.model_part.Set(KratosMultiphysics.MODIFIED, False)
self.step = 0 # Reset (just to be sure)
else:
self.step += 1
if self.step_frequency > 0:
if self.step >= self.step_frequency:
if self.model_part.ProcessInfo[
KratosMultiphysics.STEP] >= self.initial_step:
if self.settings[
"blocking_threshold_size"].GetBool():
MeshingApplication.BlockThresholdSizeElements(
self.model_part,
self.settings["threshold_sizes"])
self._ExecuteRefinement()
self.step = 0 # Reset
def test_mpi_hessian(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", 2)
main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, 2)
# We add the variables needed
main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISTANCE)
# We import the model main_model_part
file_path = GetFilePath("/mmg_lagrangian_test/remesh_rectangle")
ReadModelPart(file_path, 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)
## Read reference
file_name = "mmg_lagrangian_test/rectangle_distance_values.json"
distance_values_file_name = GetFilePath(file_name)
with open(distance_values_file_name, 'r') as f:
distance_values = json.load(f)
for node in main_model_part.Nodes:
distance_value = distance_values[str(node.Id)]
node.SetSolutionStepValue(KratosMultiphysics.DISTANCE, distance_value)
metric_parameters = KratosMultiphysics.Parameters("""
{
"hessian_strategy_parameters" :{
"estimate_interpolation_error" : false,
"interpolation_error" : 1.0e-6,
"mesh_dependent_constant" : 0.28125
},
"minimal_size" : 0.015,
"maximal_size" : 0.5,
"enforce_current" : false,
"anisotropy_remeshing" : false,
"enforce_anisotropy_relative_variable" : false
}
""")
metric_process = MeshingApplication.ComputeHessianSolMetricProcess(main_model_part, KratosMultiphysics.DISTANCE, metric_parameters)
metric_process.Execute()
## Read reference
file_name = "mmg_lagrangian_test/rectangle_pre_metric_result.json"
reference_file_name = GetFilePath(file_name)
with open(reference_file_name, 'r') as f:
reference_values = json.load(f)
for node in main_model_part.Nodes:
metric_tensor = node.GetValue(MeshingApplication.METRIC_TENSOR_2D)
ref_gradient = reference_values[str(node.Id)]
for tensor_i, tensor_i_ref in zip(metric_tensor, ref_gradient):
self.assertAlmostEqual(tensor_i, tensor_i_ref)
def __ComputeHessianMetric(self):
find_nodal_h = KratosMultiphysics.FindNodalHNonHistoricalProcess(
self.main_model_part)
find_nodal_h.Execute()
metric_x = KratosMeshing.ComputeHessianSolMetricProcess(
self.main_model_part, KratosMultiphysics.VELOCITY_X,
self.metric_parameters)
metric_x.Execute()
metric_y = KratosMeshing.ComputeHessianSolMetricProcess(
self.main_model_part, KratosMultiphysics.VELOCITY_Y,
self.metric_parameters)
metric_y.Execute()
if (self.domain_size == 3):
metric_z = KratosMeshing.ComputeHessianSolMetricProcess(
self.main_model_part, KratosMultiphysics.VELOCITY_Z,
self.metric_parameters)
metric_z.Execute()
def compute_refinement_hessian_metric(model_coarse,parameters_coarse,minimal_size_value,maximal_size_value,metric_param,remesh_param):
model_part_name = parameters_coarse["problem_data"]["model_part_name"].GetString()
'''set NODAL_AREA and NODAL_H as non historical variables'''
KratosMultiphysics.VariableUtils().SetNonHistoricalVariable(KratosMultiphysics.NODAL_AREA, 0.0, model_coarse.GetModelPart(model_part_name).Nodes)
KratosMultiphysics.VariableUtils().SetNonHistoricalVariable(KratosMultiphysics.NODAL_H, 0.0, model_coarse.GetModelPart(model_part_name).Nodes)
'''calculate NODAL_H'''
find_nodal_h = KratosMultiphysics.FindNodalHProcess(model_coarse.GetModelPart(model_part_name))
find_nodal_h = KratosMultiphysics.FindNodalHNonHistoricalProcess(model_coarse.GetModelPart(model_part_name))
find_nodal_h.Execute()
'''prepare parameters to calculate the gradient of the designed variable'''
local_gradient_variable_string = metric_param["local_gradient_variable"].GetString()
local_gradient_variable = KratosMultiphysics.KratosGlobals.GetVariable(metric_param["local_gradient_variable"].GetString())
metric_param.RemoveValue("local_gradient_variable")
metric_param.AddEmptyValue("minimal_size")
metric_param["minimal_size"].SetDouble(minimal_size_value)
metric_param.AddEmptyValue("maximal_size")
metric_param["maximal_size"].SetDouble(maximal_size_value)
'''calculate the gradient of the variable'''
local_gradient = KratosMeshing.ComputeHessianSolMetricProcess(model_coarse.GetModelPart(model_part_name),local_gradient_variable,metric_param)
local_gradient.Execute()
'''add again the removed variable parameter'''
metric_param.AddEmptyValue("local_gradient_variable")
metric_param["local_gradient_variable"].SetString(local_gradient_variable_string)
'''create the remeshing process'''
MmgProcess = KratosMeshing.MmgProcess2D(model_coarse.GetModelPart(model_part_name),remesh_param)
MmgProcess.Execute()
'''the refinement process empties the coarse model part object and fill it with the refined model part
the solution on the refined grid is obtained from the interpolation of the coarse solution
there are not other operations, so to build the new model we just need to take the updated coarse model'''
current_model_refined = model_coarse
current_parameters_refined = parameters_coarse
return current_model_refined,current_parameters_refined
def ExecuteInitialize(self):
# Create the new subscale process
self.subscales_utility = MeshingApplication.MultiscaleRefiningProcess(
self.coarse_model_part,
self.refined_model_part,
self.visualization_model_part,
self.settings["advanced_configuration"])
if self.echo_level > 0:
print('The multiscale process is initialized')
if self.echo_level > 1:
print(self.model[self.coarse_model_part_name])
print(self.model[self.refined_model_part_name])
def PrepareModelPart(self):
# Initialize the corresponding model part
if self.current_subscale == 0:
self._InitializeVisualizationModelPart()
else:
self._InitializeRefinedModelPart()
self.subscales_utility = MeshingApplication.MultiscaleRefiningProcess(
self.coarse_model_part, self.refined_model_part,
self.visualization_model_part,
self.settings["advanced_configuration"])
if self.echo_level > 0:
print('The multiscale process is initialized')
if self.echo_level > 1:
print(self.model[self.coarse_model_part_name])
print(self.model[self.refined_model_part_name])
def PerformRemeshingIfNecessary(self):
debug_metric = False
if debug_metric:
params = KratosMultiphysics.Parameters("""{}""")
KratosFemDem.ComputeNormalizedFreeEnergyOnNodesProcess(
self.FEM_Solution.main_model_part,
self.FEM_Solution.ProjectParameters["AMR_data"]
["hessian_variable_parameters"]).Execute()
MeshingApplication.ComputeHessianSolMetricProcess(
self.FEM_Solution.main_model_part,
KratosFemDem.EQUIVALENT_NODAL_STRESS, params).Execute()
if self.DoRemeshing:
is_remeshing = self.CheckIfHasRemeshed()
if is_remeshing:
if self.echo_level > 0:
KratosMultiphysics.Logger.PrintInfo(
"FEM-DEM:: ComputeNormalizedFreeEnergyOnNodesProcess")
# Extrapolate the VonMises normalized stress to nodes (remeshing)
parameters = self.FEM_Solution.ProjectParameters["AMR_data"][
"hessian_variable_parameters"]
KratosFemDem.ComputeNormalizedFreeEnergyOnNodesProcess(
self.FEM_Solution.main_model_part, parameters).Execute()
# we eliminate the nodal DEM forces
self.RemoveDummyNodalForces()
# Perform remeshing
self.RemeshingProcessMMG.ExecuteInitializeSolutionStep()
if is_remeshing:
if self.echo_level > 0:
KratosMultiphysics.Logger.PrintInfo(
"FEM-DEM:: InitializeSolutionAfterRemeshing")
self.RefineMappedVariables()
self.InitializeSolutionAfterRemeshing()
self.nodal_neighbour_finder = KratosMultiphysics.FindNodalNeighboursProcess(
self.FEM_Solution.main_model_part, 4, 5)
self.nodal_neighbour_finder.Execute()
# We assign the flag to recompute neighbours inside the 3D elements
utils = KratosMultiphysics.VariableUtils()
utils.SetNonHistoricalVariable(
KratosFemDem.RECOMPUTE_NEIGHBOURS, True,
self.FEM_Solution.main_model_part.Elements)
def _CreateMetricsProcess(self):
self.MetricsProcess = []
if (self.strategy == "LevelSet"):
level_set_parameters = KratosMultiphysics.Parameters("""{}""")
level_set_parameters.AddValue("minimal_size",self.params["minimal_size"])
level_set_parameters.AddValue("enforce_current",self.params["enforce_current"])
level_set_parameters.AddValue("anisotropy_remeshing",self.params["anisotropy_remeshing"])
level_set_parameters.AddValue("anisotropy_parameters",self.params["anisotropy_parameters"])
if (self.dim == 2):
self.MetricsProcess.append(MeshingApplication.ComputeLevelSetSolMetricProcess2D(
self.Model[self.model_part_name],
self.gradient_variable,
level_set_parameters))
else:
self.MetricsProcess.append(MeshingApplication.ComputeLevelSetSolMetricProcess3D(
self.Model[self.model_part_name],
self.gradient_variable,
level_set_parameters))
elif (self.strategy == "Hessian"):
hessian_parameters = KratosMultiphysics.Parameters("""{}""")
hessian_parameters.AddValue("minimal_size",self.params["minimal_size"])
hessian_parameters.AddValue("maximal_size",self.params["maximal_size"])
hessian_parameters.AddValue("enforce_current",self.params["enforce_current"])
hessian_parameters.AddValue("hessian_strategy_parameters",self.params["hessian_strategy_parameters"])
hessian_parameters.AddValue("anisotropy_remeshing",self.params["anisotropy_remeshing"])
hessian_parameters.AddValue("anisotropy_parameters",self.params["anisotropy_parameters"])
for current_metric_variable in self.metric_variable:
if (type(current_metric_variable) is KratosMultiphysics.Array1DComponentVariable):
if (self.dim == 2):
self.MetricsProcess.append(MeshingApplication.ComputeHessianSolMetricProcessComp2D(
self.Model[self.model_part_name],
current_metric_variable,
hessian_parameters))
else:
self.MetricsProcess.append(MeshingApplication.ComputeHessianSolMetricProcessComp3D(
self.Model[self.model_part_name],
current_metric_variable,
hessian_parameters))
else:
if (self.dim == 2):
self.MetricsProcess.append(MeshingApplication.ComputeHessianSolMetricProcess2D(
self.Model[self.model_part_name],
current_metric_variable,
hessian_parameters))
else:
self.MetricsProcess.append(MeshingApplication.ComputeHessianSolMetricProcess3D(
self.Model[self.model_part_name],
current_metric_variable,
hessian_parameters))
# We define a metric using the ComputeLevelSetSolMetricProcess
level_set_param = KratosMultiphysics.Parameters("""
{
"minimal_size" : 0.1,
"enforce_current" : false,
"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": {
v0v2 = gradient_value[0] * gradient_value[2]
v1v1 = gradient_value[1] * gradient_value[1]
v1v2 = gradient_value[1] * gradient_value[2]
v2v2 = gradient_value[2] * gradient_value[2]
MetricVector[0] = coeff0 * (1.0 - v0v0) + coeff1 * v0v0
MetricVector[1] = coeff0 * (1.0 - v1v1) + coeff1 * v1v1
MetricVector[2] = coeff0 * (1.0 - v2v2) + coeff1 * v2v2
MetricVector[3] = coeff0 * (-v0v1) + coeff1 * v0v1
MetricVector[4] = coeff0 * (-v1v2) + coeff1 * v1v2
MetricVector[5] = coeff0 * (-v0v2) + coeff1 * v0v2
node.SetValue(MeshingApplication.METRIC_TENSOR_3D, MetricVector)
# 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 KratosMultiphysics.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_remesh_rectangle_hessian(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", 2)
main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, 2)
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_lagrangian_test/remesh_rectangle"
).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)
main_model_part.Nodes[1].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 9.86358e-08)
main_model_part.Nodes[2].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 4.88117e-07)
main_model_part.Nodes[3].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 8.21649e-07)
main_model_part.Nodes[4].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 2.98426e-06)
main_model_part.Nodes[5].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 1.9462e-06)
main_model_part.Nodes[6].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 3.20072e-06)
main_model_part.Nodes[7].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 8.13038e-07)
main_model_part.Nodes[8].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 1.74975e-06)
main_model_part.Nodes[9].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 8.66819e-06)
main_model_part.Nodes[10].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 6.24329e-06)
main_model_part.Nodes[11].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 1.10461e-05)
main_model_part.Nodes[12].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 7.01043e-07)
main_model_part.Nodes[13].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 1.90256e-05)
main_model_part.Nodes[14].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 2.51694e-06)
main_model_part.Nodes[15].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 1.51568e-05)
main_model_part.Nodes[16].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 3.0177e-05)
main_model_part.Nodes[17].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 8.48471e-06)
main_model_part.Nodes[18].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 8.37749e-08)
main_model_part.Nodes[19].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 4.64653e-07)
main_model_part.Nodes[20].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 2.64854e-05)
main_model_part.Nodes[21].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 3.71692e-05)
main_model_part.Nodes[22].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 3.28506e-06)
main_model_part.Nodes[23].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 1.97626e-05)
main_model_part.Nodes[24].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 6.49145e-05)
main_model_part.Nodes[25].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 1, 20e-02)
main_model_part.Nodes[26].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 4.05303e-05)
main_model_part.Nodes[27].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 6.49053e-05)
main_model_part.Nodes[28].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 3.71567e-05)
main_model_part.Nodes[29].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 3.01782e-05)
main_model_part.Nodes[30].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000118602)
main_model_part.Nodes[31].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 5.74756e-05)
main_model_part.Nodes[32].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 6.26979e-05)
main_model_part.Nodes[33].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 6.33597e-05)
main_model_part.Nodes[34].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000101589)
main_model_part.Nodes[35].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000192486)
main_model_part.Nodes[36].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 9.93803e-05)
main_model_part.Nodes[37].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000116324)
main_model_part.Nodes[38].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 7.68763e-05)
main_model_part.Nodes[39].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000149051)
main_model_part.Nodes[40].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000289484)
main_model_part.Nodes[41].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000192959)
main_model_part.Nodes[42].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000145925)
main_model_part.Nodes[43].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 9.79472e-05)
main_model_part.Nodes[44].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000201518)
main_model_part.Nodes[45].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000401176)
main_model_part.Nodes[46].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000291243)
main_model_part.Nodes[47].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000205528)
main_model_part.Nodes[48].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000119595)
main_model_part.Nodes[49].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000262135)
main_model_part.Nodes[50].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000415149)
main_model_part.Nodes[51].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.00053798)
main_model_part.Nodes[52].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000268931)
main_model_part.Nodes[53].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000139653)
main_model_part.Nodes[54].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000331001)
main_model_part.Nodes[55].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000546243)
main_model_part.Nodes[56].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000675476)
main_model_part.Nodes[57].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000327043)
main_model_part.Nodes[58].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000158685)
main_model_part.Nodes[59].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.00039571)
main_model_part.Nodes[60].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000651727)
main_model_part.Nodes[61].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000370579)
main_model_part.Nodes[62].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000809699)
main_model_part.Nodes[63].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000170989)
main_model_part.Nodes[64].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000445764)
main_model_part.Nodes[65].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000784852)
main_model_part.Nodes[66].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000433683)
main_model_part.Nodes[67].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000914023)
main_model_part.Nodes[68].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000179197)
main_model_part.Nodes[69].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.00047077)
main_model_part.Nodes[70].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000904417)
main_model_part.Nodes[71].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000464902)
main_model_part.Nodes[72].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000994274)
main_model_part.Nodes[73].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000173952)
main_model_part.Nodes[74].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000466276)
main_model_part.Nodes[75].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000971188)
main_model_part.Nodes[76].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000474027)
main_model_part.Nodes[77].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000946149)
main_model_part.Nodes[78].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000160469)
main_model_part.Nodes[79].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000397979)
main_model_part.Nodes[80].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000996743)
main_model_part.Nodes[81].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000455294)
main_model_part.Nodes[82].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000925016)
main_model_part.Nodes[83].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000132904)
main_model_part.Nodes[84].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000373155)
main_model_part.Nodes[85].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000963824)
main_model_part.Nodes[86].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000386671)
main_model_part.Nodes[87].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000858186)
main_model_part.Nodes[88].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 9.47787e-05)
main_model_part.Nodes[89].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000851174)
main_model_part.Nodes[90].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000282759)
main_model_part.Nodes[91].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000285314)
main_model_part.Nodes[92].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000688848)
main_model_part.Nodes[93].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 4.35228e-05)
main_model_part.Nodes[94].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000686866)
main_model_part.Nodes[95].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000179265)
main_model_part.Nodes[96].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000175715)
main_model_part.Nodes[97].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000386179)
main_model_part.Nodes[98].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 1.59849e-05)
main_model_part.Nodes[99].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 1.7304e-05)
main_model_part.Nodes[100].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0.000382607)
main_model_part.Nodes[101].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0)
main_model_part.Nodes[102].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0)
main_model_part.Nodes[103].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0)
main_model_part.Nodes[104].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0)
main_model_part.Nodes[105].SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0)
# We set to zero the metric
ZeroVector = KratosMultiphysics.Vector(3)
ZeroVector[0] = 0.0
ZeroVector[1] = 0.0
ZeroVector[2] = 0.0
for node in main_model_part.Nodes:
node.SetValue(MeshingApplication.METRIC_TENSOR_2D, ZeroVector)
# We define a metric using the ComputeLevelSetSolMetricProcess
MetricParameters = KratosMultiphysics.Parameters("""
{
"hessian_strategy_parameters" :{
"estimate_interpolation_error" : false,
"interpolation_error" : 1.0e-6,
"mesh_dependent_constant" : 0.28125
},
"minimal_size" : 0.015,
"maximal_size" : 0.5,
"sizing_parameters":
{
"boundary_layer_max_distance" : 1.0,
"interpolation" : "constant"
},
"enforce_current" : false,
"anisotropy_remeshing" : false,
"enforce_anisotropy_relative_variable" : false
}
""")
metric_process = MeshingApplication.ComputeHessianSolMetricProcess(
main_model_part, KratosMultiphysics.DISTANCE, MetricParameters)
metric_process.Execute()
mmg_parameters = KratosMultiphysics.Parameters("""
{
"filename" : "mmg_lagrangian_test/remesh_rectangle",
"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.MmgProcess2D(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"],
#"nodal_nonhistorical_results": ["METRIC_TENSOR_2D","AUXILIAR_GRADIENT","AUXILIAR_HESSIAN"]
#}
#}
#""")
#)
#gid_output.ExecuteInitialize()
#gid_output.ExecuteBeforeSolutionLoop()
#gid_output.ExecuteInitializeSolutionStep()
#gid_output.PrintOutput()
#gid_output.ExecuteFinalizeSolutionStep()
#gid_output.ExecuteFinalize()
import KratosMultiphysics.from_json_check_result_process as from_json_check_result_process
json_check_parameters = KratosMultiphysics.Parameters("""
{
"check_variables" : ["METRIC_TENSOR_2D"],
"input_file_name" : "mmg_lagrangian_test/remesh_rectangle_post_metric.json",
"model_part_name" : "MainModelPart",
"historical_value" : false,
"time_frequency" : 0.0
}
""")
json_check_parameters["input_file_name"].SetString(
file_path + "/" +
json_check_parameters["input_file_name"].GetString())
json_check = from_json_check_result_process.FromJsonCheckResultProcess(
current_model, json_check_parameters)
json_check.ExecuteInitialize()
json_check.ExecuteFinalizeSolutionStep()
# We check the solution
check_parameters = KratosMultiphysics.Parameters("""
{
"reference_file_name" : "mmg_lagrangian_test/remesh_rectangle_result.sol",
"output_file_name" : "mmg_lagrangian_test/remesh_rectangle_step=0.sol",
"dimension" : 2,
"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_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()
