def test_trilinos_levelset_convection(self):
current_model = KratosMultiphysics.Model()
self.model_part = current_model.CreateModelPart("Main",2)
self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISTANCE)
self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.VELOCITY)
self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.PARTITION_INDEX)
# Import the model part, perform the partitioning and create communicators
import_settings = KratosMultiphysics.Parameters(self.parameters)
DistributedModelPartImporter = distributed_import_model_part_utility.DistributedImportModelPartUtility(self.model_part, import_settings)
DistributedModelPartImporter.ImportModelPart()
DistributedModelPartImporter.CreateCommunicators()
# Recall to set the buffer size
self.model_part.SetBufferSize(2)
# Set the initial distance field and the convection velocity
for node in self.model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.DISTANCE, 0, BaseDistance(node.X,node.Y,node.Z))
node.SetSolutionStepValue(KratosMultiphysics.VELOCITY, 0, ConvectionVelocity(node.X,node.Y,node.Z))
# Fix the left side values
for node in self.model_part.Nodes:
if node.X < 0.001:
node.Fix(KratosMultiphysics.DISTANCE)
# Set the Trilinos linear solver and Epetra communicator
trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
KratosMultiphysics.Parameters("""{"solver_type" : "amesos" }""")
)
epetra_comm = TrilinosApplication.CreateEpetraCommunicator(KratosMultiphysics.DataCommunicator.GetDefault())
# Fake time advance
self.model_part.CloneTimeStep(40.0)
# Convect the distance field
TrilinosApplication.TrilinosLevelSetConvectionProcess2D(
epetra_comm,
KratosMultiphysics.DISTANCE,
self.model_part,
trilinos_linear_solver).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.7333041045431626)
self.assertAlmostEqual(min_distance,-0.06371359024393104)
def test_resize(self):
comm = KratosTrilinos.CreateEpetraCommunicator(
KratosMultiphysics.DataCommunicator.GetDefault())
space = KratosTrilinos.TrilinosSparseSpace()
pb = space.CreateEmptyVectorPointer(comm)
space.ResizeVector(pb, 2)
n = space.Size(pb.GetReference())
self.assertEqual(n, 2)
def test_trilinos_levelset_convection(self):
# Set the initial distance field and the convection velocity
for node in self.model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.DISTANCE, 0,
BaseDistance(node.X, node.Y, node.Z))
node.SetSolutionStepValue(
KratosMultiphysics.VELOCITY, 0,
ConvectionVelocity(node.X, node.Y, node.Z))
# Fix the left side values
for node in self.model_part.Nodes:
if node.X < 0.001:
node.Fix(KratosMultiphysics.DISTANCE)
# Set the Trilinos linear solver and Epetra communicator
trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
KratosMultiphysics.Parameters("""{"solver_type" : "amesos" }"""))
epetra_comm = TrilinosApplication.CreateEpetraCommunicator(
KratosMultiphysics.DataCommunicator.GetDefault())
# Fake time advance
self.model_part.CloneTimeStep(40.0)
# Convect the distance field
levelset_convection_settings = KratosMultiphysics.Parameters("""{
"max_CFL" : 1.0,
"max_substeps" : 0,
"eulerian_error_compensation" : false,
"element_type" : "levelset_convection_supg"
}""")
TrilinosApplication.TrilinosLevelSetConvectionProcess2D(
epetra_comm, self.model_part, trilinos_linear_solver,
levelset_convection_settings).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.7333041045431626)
self.assertAlmostEqual(min_distance, -0.06371359024393104)
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 _GetEpetraCommunicator(self):
if not hasattr(self, '_epetra_communicator'):
self._epetra_communicator = KratosTrilinos.CreateEpetraCommunicator(self.main_model_part.GetCommunicator().GetDataCommunicator())
return self._epetra_communicator
def test_trilinos_levelset_convection_BFECC(self):
# Set the initial distance field and the convection velocity
for node in self.model_part.Nodes:
node.SetSolutionStepValue(
KratosMultiphysics.DISTANCE,
BaseJumpedDistance(node.X, node.Y, node.Z))
node.SetSolutionStepValue(
KratosMultiphysics.VELOCITY,
ConvectionVelocity(node.X, node.Y, node.Z))
# Fix the left side values
for node in self.model_part.Nodes:
if node.X < 0.001:
node.Fix(KratosMultiphysics.DISTANCE)
# Set the Trilinos linear solver and Epetra communicator
trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
KratosMultiphysics.Parameters("""{"solver_type" : "amesos" }"""))
epetra_comm = TrilinosApplication.CreateEpetraCommunicator(
KratosMultiphysics.DataCommunicator.GetDefault())
# Fake time advance
self.model_part.CloneTimeStep(30.0)
kratos_comm = KratosMultiphysics.DataCommunicator.GetDefault()
KratosMultiphysics.FindGlobalNodalNeighboursProcess(
kratos_comm, self.model_part).Execute()
KratosMultiphysics.ComputeNonHistoricalNodalGradientProcess(
self.model_part, KratosMultiphysics.DISTANCE,
KratosMultiphysics.DISTANCE_GRADIENT,
KratosMultiphysics.NODAL_AREA).Execute()
levelset_convection_settings = KratosMultiphysics.Parameters("""{
"levelset_variable_name" : "DISTANCE",
"levelset_convection_variable_name" : "VELOCITY",
"levelset_gradient_variable_name" : "DISTANCE_GRADIENT",
"max_CFL" : 1.0,
"max_substeps" : 0,
"eulerian_error_compensation" : true,
"cross_wind_stabilization_factor" : 0.7
}""")
TrilinosApplication.TrilinosLevelSetConvectionProcess2D(
epetra_comm, self.model_part, trilinos_linear_solver,
levelset_convection_settings).Execute()
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 = kratos_comm.MinAll(min_distance)
max_distance = kratos_comm.MaxAll(max_distance)
# gid_output = GiDOutputProcess(model_part,
# "levelset_test_2D",
# KratosMultiphysics.Parameters("""
# {
# "result_file_configuration" : {
# "gidpost_flags": {
# "GiDPostMode": "GiD_PostBinary",
# "WriteDeformedMeshFlag": "WriteUndeformed",
# "WriteConditionsFlag": "WriteConditions",
# "MultiFileFlag": "SingleFile"
# },
# "nodal_results" : ["DISTANCE","VELOCITY"]
# }
# }
# """)
# )
# gid_output.ExecuteInitialize()
# gid_output.ExecuteBeforeSolutionLoop()
# gid_output.ExecuteInitializeSolutionStep()
# gid_output.PrintOutput()
# gid_output.ExecuteFinalizeSolutionStep()
# gid_output.ExecuteFinalize()
self.assertAlmostEqual(max_distance, 1.0617777301844604)
self.assertAlmostEqual(min_distance, -0.061745786561321375)
def testTrilinosRedistance(self):
# Set the model part
current_model = KratosMultiphysics.Model()
self.model_part = current_model.CreateModelPart("Main")
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)
ModelPartImporter = distributed_import_model_part_utility.DistributedImportModelPartUtility(
self.model_part, import_settings)
ModelPartImporter.ImportModelPart()
ModelPartImporter.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" : "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 get_communicator(self):
if not hasattr(self, '_communicator'):
self._communicator = TrilinosApplication.CreateEpetraCommunicator(
self.mesh_model_part.GetCommunicator().GetDataCommunicator())
return self._communicator
def _create_epetra_communicator(self):
return TrilinosApplication.CreateEpetraCommunicator(
self.main_model_part.GetCommunicator().GetDataCommunicator())
