def _CreateDistanceReinitializationProcess(self):
if (self._reinitialization_type == "variational"):
# Construct the variational distance calculation process
maximum_iterations = 2 #TODO: Make this user-definable
redistancing_linear_solver = self._GetRedistancingLinearSolver()
computing_model_part = self.GetComputingModelPart()
epetra_communicator = self._GetEpetraCommunicator()
if self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2:
distance_reinitialization_process = KratosTrilinos.TrilinosVariationalDistanceCalculationProcess2D(
epetra_communicator,
computing_model_part,
redistancing_linear_solver,
maximum_iterations,
KratosMultiphysics.VariationalDistanceCalculationProcess2D.CALCULATE_EXACT_DISTANCES_TO_PLANE)
else:
distance_reinitialization_process = KratosTrilinos.TrilinosVariationalDistanceCalculationProcess3D(
epetra_communicator,
computing_model_part,
redistancing_linear_solver,
maximum_iterations,
KratosMultiphysics.VariationalDistanceCalculationProcess3D.CALCULATE_EXACT_DISTANCES_TO_PLANE)
elif (self._reinitialization_type == "parallel"):
if self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2:
distance_reinitialization_process = KratosMultiphysics.ParallelDistanceCalculator2D()
else:
distance_reinitialization_process = KratosMultiphysics.ParallelDistanceCalculator3D()
elif (self._reinitialization_type == "none"):
KratosMultiphysics.Logger.PrintInfo(self.__class__.__name__, "Redistancing is turned off.")
else:
raise Exception("Please use a valid distance reinitialization type or set it as \'none\'. Valid types are: \'variational\' and \'parallel\'.")
return distance_reinitialization_process
def testTrilinosRedistance(self):
# Set the model part
current_model = KratosMultiphysics.Model()
self.model_part = current_model.CreateModelPart(
"RedistanceCalculationPart")
self.model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.DISTANCE)
self.model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.FLAG_VARIABLE)
self.model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.PARTITION_INDEX)
# Import the model part, perform the partitioning and create communicators
import_settings = KratosMultiphysics.Parameters(self.parameters)
TrilinosModelPartImporter = trilinos_import_model_part_utility.TrilinosImportModelPartUtility(
self.model_part, import_settings)
TrilinosModelPartImporter.ImportModelPart()
TrilinosModelPartImporter.CreateCommunicators()
# Recall to set the buffer size
self.model_part.SetBufferSize(2)
# Initialize the DISTANCE values
for node in self.model_part.Nodes:
node.SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0,
self._ExpectedDistance(node.X, node.Y, node.Z))
# Fake time advance
self.model_part.CloneTimeStep(1.0)
# Set the utility and compute the variational distance values
trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
KratosMultiphysics.Parameters(
"""{"solver_type" : "AmesosSolver" }"""))
epetra_comm = TrilinosApplication.CreateCommunicator()
max_iterations = 2
TrilinosApplication.TrilinosVariationalDistanceCalculationProcess3D(
epetra_comm, self.model_part, trilinos_linear_solver,
max_iterations).Execute()
# Check the obtained values
max_distance = -1.0
min_distance = +1.0
for node in self.model_part.Nodes:
d = node.GetSolutionStepValue(KratosMultiphysics.DISTANCE)
max_distance = max(max_distance, d)
min_distance = min(min_distance, d)
min_distance = self.model_part.GetCommunicator().MinAll(min_distance)
max_distance = self.model_part.GetCommunicator().MaxAll(max_distance)
self.assertAlmostEqual(max_distance,
0.44556526310761013) # Serial max_distance
self.assertAlmostEqual(min_distance,
-0.504972246827639) # Serial min_distance
def set_variational_distance_process(self):
# Construct the variational distance calculation process
self.EpetraCommunicator = KratosTrilinos.CreateCommunicator()
maximum_iterations = 5
### for MPI
trilinos_settings = KratosMultiphysics.Parameters("""
{
"linear_solver_settings" : {
"solver_type" : "amgcl"
}
}
""")
self.linear_solver = trilinos_linear_solver_factory.ConstructSolver(
trilinos_settings["linear_solver_settings"])
if self.complete_model.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 2:
variational_distance_process = KratosTrilinos.TrilinosVariationalDistanceCalculationProcess2D(
self.EpetraCommunicator, self.complete_model,
self.linear_solver, maximum_iterations,
KratosMultiphysics.VariationalDistanceCalculationProcess2D.
CALCULATE_EXACT_DISTANCES_TO_PLANE, "distance_from_inlet_2D")
else:
variational_distance_process = KratosTrilinos.TrilinosVariationalDistanceCalculationProcess3D(
self.EpetraCommunicator, self.complete_model,
self.linear_solver, maximum_iterations,
KratosMultiphysics.VariationalDistanceCalculationProcess3D.
CALCULATE_EXACT_DISTANCES_TO_PLANE, "distance_from_inlet_3D")
return variational_distance_process
def _set_variational_distance_process(self):
# Construct the variational distance calculation process
maximum_iterations = 2
if self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 2:
variational_distance_process = KratosTrilinos.TrilinosVariationalDistanceCalculationProcess2D(
self.EpetraCommunicator, self.computing_model_part,
self.trilinos_linear_solver, maximum_iterations,
KratosMultiphysics.VariationalDistanceCalculationProcess2D.
CALCULATE_EXACT_DISTANCES_TO_PLANE)
else:
variational_distance_process = KratosTrilinos.TrilinosVariationalDistanceCalculationProcess3D(
self.EpetraCommunicator, self.computing_model_part,
self.trilinos_linear_solver, maximum_iterations,
KratosMultiphysics.VariationalDistanceCalculationProcess3D.
CALCULATE_EXACT_DISTANCES_TO_PLANE)
return variational_distance_process
def testTrilinosRedistance(self):
# Initialize the DISTANCE values
for node in self.model_part.Nodes:
node.SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0,
self._ExpectedDistance(node.X, node.Y, node.Z))
# Fake time advance
self.model_part.CloneTimeStep(1.0)
# Set the utility and compute the variational distance values
trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
KratosMultiphysics.Parameters("""{"solver_type" : "amesos" }"""))
epetra_comm = TrilinosApplication.CreateEpetraCommunicator(
KratosMultiphysics.DataCommunicator.GetDefault())
max_iterations = 2
TrilinosApplication.TrilinosVariationalDistanceCalculationProcess3D(
epetra_comm, self.model_part, trilinos_linear_solver,
max_iterations,
(KratosMultiphysics.VariationalDistanceCalculationProcess3D.
CALCULATE_EXACT_DISTANCES_TO_PLANE).AsFalse()).Execute()
# Check the obtained values
max_distance = -1.0
min_distance = +1.0
for node in self.model_part.Nodes:
d = node.GetSolutionStepValue(KratosMultiphysics.DISTANCE)
max_distance = max(max_distance, d)
min_distance = min(min_distance, d)
comm = self.model_part.GetCommunicator().GetDataCommunicator()
min_distance = comm.MinAll(min_distance)
max_distance = comm.MaxAll(max_distance)
self.assertAlmostEqual(max_distance,
0.44556526310761013) # Serial max_distance
self.assertAlmostEqual(min_distance,
-0.504972246827639) # Serial min_distance
def _CreateDistanceReinitializationProcess(self):
# Construct the variational distance calculation process
maximum_iterations = 2 #TODO: Make this user-definable
redistancing_linear_solver = self._GetRedistancingLinearSolver()
computing_model_part = self.GetComputingModelPart()
epetra_communicator = self._GetEpetraCommunicator()
if self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 2:
variational_distance_process = KratosTrilinos.TrilinosVariationalDistanceCalculationProcess2D(
epetra_communicator, computing_model_part,
redistancing_linear_solver, maximum_iterations,
KratosMultiphysics.VariationalDistanceCalculationProcess2D.
CALCULATE_EXACT_DISTANCES_TO_PLANE)
else:
variational_distance_process = KratosTrilinos.TrilinosVariationalDistanceCalculationProcess3D(
epetra_communicator, computing_model_part,
redistancing_linear_solver, maximum_iterations,
KratosMultiphysics.VariationalDistanceCalculationProcess3D.
CALCULATE_EXACT_DISTANCES_TO_PLANE)
return variational_distance_process
