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 _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": {
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 _CreateMetricsProcess(self):
""" This method is responsible to create the metrics of the process
Keyword arguments:
self -- It signifies an instance of a class.
"""
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["hessian_strategy_parameters"].RemoveValue("non_historical_metric_variable")
hessian_parameters["hessian_strategy_parameters"].AddEmptyValue("non_historical_metric_variable")
hessian_parameters["hessian_strategy_parameters"].RemoveValue("normalization_factor")
hessian_parameters["hessian_strategy_parameters"].AddEmptyValue("normalization_factor")
hessian_parameters["hessian_strategy_parameters"].RemoveValue("normalization_alpha")
hessian_parameters["hessian_strategy_parameters"].AddEmptyValue("normalization_alpha")
hessian_parameters["hessian_strategy_parameters"].RemoveValue("normalization_method")
hessian_parameters["hessian_strategy_parameters"].AddEmptyValue("normalization_method")
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, non_historical_metric_variable, normalization_factor, normalization_alpha, normalization_method in zip(self.metric_variables, self.non_historical_metric_variable, self.normalization_factor, self.normalization_alpha, self.normalization_method):
hessian_parameters["hessian_strategy_parameters"]["non_historical_metric_variable"].SetBool(non_historical_metric_variable)
hessian_parameters["hessian_strategy_parameters"]["normalization_factor"].SetDouble(normalization_factor)
hessian_parameters["hessian_strategy_parameters"]["normalization_alpha"].SetDouble(normalization_alpha)
hessian_parameters["hessian_strategy_parameters"]["normalization_method"].SetString(normalization_method)
self.metric_processes.append(MeshingApplication.ComputeHessianSolMetricProcess(self.main_model_part, current_metric_variable, hessian_parameters))
elif self.strategy == "superconvergent_patch_recovery" or self.strategy == "SPR":
# Generate SPR process
self.error_compute = self._GenerateErrorProcess()
# Now we compute the metric
error_metric_parameters = KratosMultiphysics.Parameters("""{"error_strategy_parameters":{}}""")
error_metric_parameters.AddValue("minimal_size",self.settings["minimal_size"])
error_metric_parameters.AddValue("maximal_size",self.settings["maximal_size"])
error_metric_parameters["error_strategy_parameters"].AddValue("target_error",self.settings["error_strategy_parameters"]["error_metric_parameters"]["interpolation_error"])
error_metric_parameters["error_strategy_parameters"].AddValue("set_target_number_of_elements", self.settings["error_strategy_parameters"]["set_target_number_of_elements"])
error_metric_parameters["error_strategy_parameters"].AddValue("target_number_of_elements", self.settings["error_strategy_parameters"]["target_number_of_elements"])
error_metric_parameters["error_strategy_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 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)
