def test_HDF5ModelPartIO(self):
with ControlledExecutionScope(
os.path.dirname(os.path.realpath(__file__))):
write_model_part = ModelPart("write")
KratosMetis.SetMPICommunicatorProcess(write_model_part).Execute()
self._initialize_model_part(write_model_part)
hdf5_file = self._get_file()
hdf5_model_part_io = self._get_model_part_io(hdf5_file)
hdf5_model_part_io.WriteModelPart(write_model_part)
read_model_part = ModelPart("read")
KratosMetis.SetMPICommunicatorProcess(read_model_part).Execute()
hdf5_model_part_io.ReadModelPart(read_model_part)
KratosTrilinos.ParallelFillCommunicator(
read_model_part.GetRootModelPart()).Execute()
read_model_part.GetCommunicator(
).SynchronizeNodalSolutionStepsData()
# Check nodes (node order should be preserved on read/write to ensure consistency with nodal results)
self.assertEqual(read_model_part.NumberOfNodes(),
write_model_part.NumberOfNodes())
for read_node, write_node in zip(read_model_part.Nodes,
write_model_part.Nodes):
self.assertEqual(read_node.Id, write_node.Id)
self.assertEqual(read_node.X, write_node.X)
self.assertEqual(read_node.Y, write_node.Y)
self.assertEqual(read_node.Z, write_node.Z)
# Check elements
self.assertEqual(read_model_part.NumberOfElements(),
write_model_part.NumberOfElements())
first_elem_id = next(iter(read_model_part.Elements)).Id
read_model_part.GetElement(
first_elem_id) # Force a sort since order is mixed by openmp.
for read_elem, write_elem in zip(read_model_part.Elements,
write_model_part.Elements):
self.assertEqual(read_elem.Id, write_elem.Id)
self.assertEqual(read_elem.Properties.Id,
write_elem.Properties.Id)
self.assertEqual(len(read_elem.GetNodes()),
len(write_elem.GetNodes()))
for read_elem_node, write_elem_node in zip(
read_elem.GetNodes(), write_elem.GetNodes()):
self.assertEqual(read_elem_node.Id, write_elem_node.Id)
# Check conditions
self.assertEqual(read_model_part.NumberOfConditions(),
write_model_part.NumberOfConditions())
first_cond_id = next(iter(read_model_part.Conditions)).Id
read_model_part.GetCondition(
first_cond_id) # Force a sort since order is mixed by openmp.
for read_cond, write_cond in zip(read_model_part.Conditions,
write_model_part.Conditions):
self.assertEqual(read_cond.Id, write_cond.Id)
self.assertEqual(read_cond.Properties.Id,
write_cond.Properties.Id)
self.assertEqual(len(read_cond.GetNodes()),
len(write_cond.GetNodes()))
for read_cond_node, write_cond_node in zip(
read_cond.GetNodes(), write_cond.GetNodes()):
self.assertEqual(read_cond_node.Id, write_cond_node.Id)
# Check process info
self.assertEqual(read_model_part.ProcessInfo[DOMAIN_SIZE],
write_model_part.ProcessInfo[DOMAIN_SIZE])
self.assertEqual(read_model_part.ProcessInfo[TIME],
write_model_part.ProcessInfo[TIME])
read_vector = read_model_part.ProcessInfo[INITIAL_STRAIN]
write_vector = write_model_part.ProcessInfo[INITIAL_STRAIN]
self.assertEqual(read_vector.Size(), write_vector.Size())
for i in range(len(read_vector)):
self.assertEqual(read_vector[i], write_vector[i])
read_matrix = read_model_part.ProcessInfo[
GREEN_LAGRANGE_STRAIN_TENSOR]
write_matrix = write_model_part.ProcessInfo[
GREEN_LAGRANGE_STRAIN_TENSOR]
self.assertEqual(read_matrix.Size1(), write_matrix.Size1())
self.assertEqual(read_matrix.Size2(), write_matrix.Size2())
for i in range(read_matrix.Size1()):
for j in range(read_matrix.Size2()):
self.assertEqual(read_matrix[i, j], write_matrix[i, j])
if KratosMPI.mpi.rank == 0:
self._remove_file("test_hdf5_model_part_io_mpi.h5")
def get_communicator(self):
if not hasattr(self, '_communicator'):
self._communicator = TrilinosApplication.CreateCommunicator()
return self._communicator
def Initialize(self):
## Construct the communicator
self.EpetraCommunicator = KratosTrilinos.CreateCommunicator()
## Get the computing model part
self.computing_model_part = self.GetComputingModelPart()
KratosMultiphysics.NormalCalculationUtils().CalculateOnSimplex(self.computing_model_part, self.computing_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE])
self.neighbour_search = KratosMultiphysics.FindNodalNeighboursProcess(self.computing_model_part)
(self.neighbour_search).Execute()
self.accelerationLimitationUtility = KratosMultiphysics.FluidDynamicsApplication.AccelerationLimitationUtilities(self.computing_model_part, 5.0)
## If needed, create the estimate time step utility
if (self.settings["time_stepping"]["automatic_time_step"].GetBool()):
self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility()
# Set the time discretization utility to compute the BDF coefficients
time_order = self.settings["time_order"].GetInt()
if time_order == 2:
self.time_discretization = KratosMultiphysics.TimeDiscretization.BDF(time_order)
else:
raise Exception("Only \"time_order\" equal to 2 is supported. Provided \"time_order\": " + str(time_order))
## Creating the Trilinos convergence criteria
self.conv_criteria = KratosTrilinos.TrilinosUPCriteria(self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble(),
self.settings["relative_pressure_tolerance"].GetDouble(),
self.settings["absolute_pressure_tolerance"].GetDouble())
(self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt())
#### ADDING NEW PROCESSES : level-set-convection and variational-distance-process
self.level_set_convection_process = self._set_level_set_convection_process()
self.variational_distance_process = self._set_variational_distance_process()
## Creating the Trilinos incremental update time scheme (the time integration is defined within the TwoFluidNavierStokes element)
self.time_scheme = KratosTrilinos.TrilinosResidualBasedIncrementalUpdateStaticSchemeSlip(self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE], # Domain size (2,3)
self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]+1) # DOFs (3,4)
## Set the guess_row_size (guess about the number of zero entries) for the Trilinos builder and solver
if self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 3:
guess_row_size = 20*4
elif self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2:
guess_row_size = 10*3
## Construct the Trilinos builder and solver
if self.settings["consider_periodic_conditions"].GetBool() == True:
self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolverPeriodic(self.EpetraCommunicator,
guess_row_size,
self.trilinos_linear_solver,
KratosFluid.PATCH_INDEX)
else:
self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolver(self.EpetraCommunicator,
guess_row_size,
self.trilinos_linear_solver)
## Construct the Trilinos Newton-Raphson strategy
self.solver = KratosTrilinos.TrilinosNewtonRaphsonStrategy(self.main_model_part,
self.time_scheme,
self.trilinos_linear_solver,
self.conv_criteria,
self.builder_and_solver,
self.settings["maximum_iterations"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
(self.solver).SetEchoLevel(self.settings["echo_level"].GetInt())
(self.solver).Initialize()
(self.solver).Check()
self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DYNAMIC_TAU, self.settings["formulation"]["dynamic_tau"].GetDouble())
def _create_solution_scheme(self):
return TrilinosApplication.TrilinosResidualBasedIncrementalUpdateStaticScheme()
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 Initialize(self):
## Construct the communicator
self.EpetraCommunicator = KratosTrilinos.CreateCommunicator()
## Get the computing model part
self.computing_model_part = self.GetComputingModelPart()
## If needed, create the estimate time step utility
if (self.settings["time_stepping"]["automatic_time_step"].GetBool()):
self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility(
)
## Creating the Trilinos convergence criteria
self.conv_criteria = KratosTrilinos.TrilinosUPCriteria(
self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble(),
self.settings["relative_pressure_tolerance"].GetDouble(),
self.settings["absolute_pressure_tolerance"].GetDouble())
(self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt())
## Creating the Trilinos time scheme
if (self.element_integrates_in_time):
# "Fake" scheme for those cases in where the element manages the time integration
# It is required to perform the nodal update once the current time step is solved
self.time_scheme = KratosTrilinos.TrilinosResidualBasedIncrementalUpdateStaticSchemeSlip(
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE],
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] + 1)
# In case the BDF2 scheme is used inside the element, set the time discretization utility to compute the BDF coefficients
if (self.settings["time_scheme"].GetString() == "bdf2"):
time_order = self.settings["time_order"].GetInt()
if time_order == 2:
self.time_discretization = KratosMultiphysics.TimeDiscretization.BDF(
time_order)
else:
raise Exception(
"Only \"time_order\" equal to 2 is supported. Provided \"time_order\": "
+ str(time_order))
else:
err_msg = "Requested elemental time scheme " + self.settings[
"time_scheme"].GetString() + " is not available.\n"
err_msg += "Available options are: \"bdf2\""
raise Exception(err_msg)
else:
if (self.settings["turbulence_model"].GetString() == "None"):
if self.settings["consider_periodic_conditions"].GetBool(
) == True:
self.time_scheme = KratosTrilinos.TrilinosPredictorCorrectorVelocityBossakSchemeTurbulent(
self.settings["alpha"].GetDouble(),
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE],
KratosCFD.PATCH_INDEX)
else:
self.time_scheme = KratosTrilinos.TrilinosPredictorCorrectorVelocityBossakSchemeTurbulent(
self.settings["alpha"].GetDouble(),
self.settings["move_mesh_strategy"].GetInt(),
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE])
## Set the guess_row_size (guess about the number of zero entries) for the Trilinos builder and solver
if self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 3:
guess_row_size = 20 * 4
elif self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 2:
guess_row_size = 10 * 3
## Construct the Trilinos builder and solver
if self.settings["consider_periodic_conditions"].GetBool() == True:
self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolverPeriodic(
self.EpetraCommunicator, guess_row_size,
self.trilinos_linear_solver, KratosCFD.PATCH_INDEX)
else:
self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolver(
self.EpetraCommunicator, guess_row_size,
self.trilinos_linear_solver)
## Construct the Trilinos Newton-Raphson strategy
self.solver = KratosTrilinos.TrilinosNewtonRaphsonStrategy(
self.main_model_part, self.time_scheme,
self.trilinos_linear_solver, self.conv_criteria,
self.builder_and_solver,
self.settings["maximum_iterations"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
(self.solver).SetEchoLevel(self.settings["echo_level"].GetInt())
self.formulation.SetProcessInfo(self.computing_model_part)
(self.solver).Initialize()
KratosMultiphysics.Logger.Print(
"Monolithic MPI solver initialization finished.")
def Initialize(self):
## Construct the communicator
self.EpetraCommunicator = KratosTrilinos.CreateCommunicator()
## Get the computing model part
self.computing_model_part = self.GetComputingModelPart()
## If needed, create the estimate time step utility
if (self.settings["time_stepping"]["automatic_time_step"].GetBool()):
self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility()
## Creating the Trilinos convergence criteria
self.conv_criteria = KratosTrilinos.TrilinosUPCriteria(self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble(),
self.settings["relative_pressure_tolerance"].GetDouble(),
self.settings["absolute_pressure_tolerance"].GetDouble())
(self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt())
## Creating the Trilinos time scheme
if (self.settings["turbulence_model"].GetString() == "None"):
if self.settings["consider_periodic_conditions"].GetBool() == True:
self.time_scheme = KratosTrilinos.TrilinosPredictorCorrectorVelocityBossakSchemeTurbulent(self.settings["alpha"].GetDouble(),
self.computing_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE],
KratosCFD.PATCH_INDEX)
else:
self.time_scheme = KratosTrilinos.TrilinosPredictorCorrectorVelocityBossakSchemeTurbulent(self.settings["alpha"].GetDouble(),
self.settings["move_mesh_strategy"].GetInt(),
self.computing_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE])
## Set the guess_row_size (guess about the number of zero entries) for the Trilinos builder and solver
if self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 3:
guess_row_size = 20*4
elif self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2:
guess_row_size = 10*3
## Construct the Trilinos builder and solver
if self.settings["consider_periodic_conditions"].GetBool() == True:
self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolverPeriodic(self.EpetraCommunicator,
guess_row_size,
self.trilinos_linear_solver,
KratosCFD.PATCH_INDEX)
else:
self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolver(self.EpetraCommunicator,
guess_row_size,
self.trilinos_linear_solver)
## Construct the Trilinos Newton-Raphson strategy
self.solver = KratosTrilinos.TrilinosNewtonRaphsonStrategy(self.main_model_part,
self.time_scheme,
self.trilinos_linear_solver,
self.conv_criteria,
self.builder_and_solver,
self.settings["maximum_iterations"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
(self.solver).SetEchoLevel(self.settings["echo_level"].GetInt())
self.formulation.SetProcessInfo(self.computing_model_part)
(self.solver).Initialize()
if self._IsPrintingRank():
#TODO: CHANGE THIS ONCE THE MPI LOGGER IS IMPLEMENTED
KratosMultiphysics.Logger.Print("Monolithic MPI solver initialization finished.")
def TrilinosBlockBuilderAndSolver(linear_solver, communicator):
return KratosTrilinos.TrilinosBlockBuilderAndSolver(
communicator, 30, linear_solver)
def _GetEpetraCommunicator(self):
if not hasattr(self, '_epetra_communicator'):
self._epetra_communicator = TrilinosApplication.CreateCommunicator(
)
return self._epetra_communicator
def _GetPartitionedFSIUtilities(self):
if (self.domain_size == 2):
return KratosTrilinos.TrilinosPartitionedFSIUtilities2D(self.epetra_communicator)
else:
return KratosTrilinos.TrilinosPartitionedFSIUtilities3D(self.epetra_communicator)
def TrilinosPeriodicBlockBuilderAndSolver(linear_solver, communicator):
return KratosTrilinos.TrilinosBlockBuilderAndSolverPeriodic(
communicator, 30, linear_solver, KratosCFD.PATCH_INDEX)
def __init__(self, convergence_criterion_parameters):
# Note that all the convergence settings are introduced via a Kratos parameters object.
D_RT = convergence_criterion_parameters[
"displacement_relative_tolerance"].GetDouble()
D_AT = convergence_criterion_parameters[
"displacement_absolute_tolerance"].GetDouble()
R_RT = convergence_criterion_parameters[
"residual_relative_tolerance"].GetDouble()
R_AT = convergence_criterion_parameters[
"residual_absolute_tolerance"].GetDouble()
convergence_crit = convergence_criterion_parameters[
"convergence_criterion"].GetString()
echo_level = convergence_criterion_parameters["echo_level"].GetInt()
rotation_dofs = False
if convergence_criterion_parameters.Has("rotation_dofs"):
rotation_dofs = convergence_criterion_parameters[
"rotation_dofs"].GetBool()
volumetric_strain_dofs = False
if convergence_criterion_parameters.Has("volumetric_strain_dofs"):
volumetric_strain_dofs = convergence_criterion_parameters[
"volumetric_strain_dofs"].GetBool()
if (echo_level >= 1):
KratosMultiphysics.Logger.PrintInfo(
"::[Mechanical Solver]::", "MPI CONVERGENCE CRITERION : " +
convergence_criterion_parameters["convergence_criterion"].
GetString())
if (convergence_crit == "displacement_criterion"):
if rotation_dofs:
self.mechanical_convergence_criterion = TrilinosApplication.TrilinosMixedGenericCriteria(
[(KratosMultiphysics.DISPLACEMENT, D_RT, D_AT),
(KratosMultiphysics.ROTATION, D_RT, D_AT)])
elif volumetric_strain_dofs:
self.mechanical_convergence_criterion = TrilinosApplication.TrilinosMixedGenericCriteria(
[(KratosMultiphysics.DISPLACEMENT, D_RT, D_AT),
(KratosMultiphysics.VOLUMETRIC_STRAIN, D_RT, D_AT)])
else:
self.mechanical_convergence_criterion = TrilinosApplication.TrilinosDisplacementCriteria(
D_RT, D_AT)
self.mechanical_convergence_criterion.SetEchoLevel(echo_level)
elif (convergence_crit == "residual_criterion"):
self.mechanical_convergence_criterion = TrilinosApplication.TrilinosResidualCriteria(
R_RT, R_AT)
self.mechanical_convergence_criterion.SetEchoLevel(echo_level)
elif (convergence_crit == "and_criterion"):
Displacement = TrilinosApplication.TrilinosDisplacementCriteria(
D_RT, D_AT)
Displacement.SetEchoLevel(echo_level)
Residual = TrilinosApplication.TrilinosResidualCriteria(R_RT, R_AT)
Residual.SetEchoLevel(echo_level)
self.mechanical_convergence_criterion = TrilinosApplication.TrilinosAndCriteria(
Residual, Displacement)
elif (convergence_crit == "or_criterion"):
Displacement = TrilinosApplication.TrilinosDisplacementCriteria(
D_RT, D_AT)
Displacement.SetEchoLevel(echo_level)
Residual = TrilinosApplication.TrilinosResidualCriteria(R_RT, R_AT)
Residual.SetEchoLevel(echo_level)
self.mechanical_convergence_criterion = TrilinosApplication.TrilinosOrCriteria(
Residual, Displacement)
else:
err_msg = "The requested convergence criterion \"" + convergence_crit + "\" is not available!\n"
err_msg += "Available options are: \"displacement_criterion\", \"residual_criterion\", \"and_criterion\", \"or_criterion\""
raise Exception(err_msg)
def _initialize_model_part(self, model_part):
# Add variables.
model_part.AddNodalSolutionStepVariable(DISPLACEMENT) # array_1d
model_part.AddNodalSolutionStepVariable(VELOCITY)
model_part.AddNodalSolutionStepVariable(ACCELERATION)
model_part.AddNodalSolutionStepVariable(PRESSURE) # double
model_part.AddNodalSolutionStepVariable(VISCOSITY)
model_part.AddNodalSolutionStepVariable(DENSITY)
model_part.AddNodalSolutionStepVariable(ACTIVATION_LEVEL) # int
model_part.AddNodalSolutionStepVariable(PARTITION_INDEX)
# Make a mesh out of two structured rings (inner triangles, outer quads).
num_proc = KratosMPI.mpi.size
my_pid = KratosMPI.mpi.rank
my_num_quad = 20 # user-defined.
my_num_tri = 2 * my_num_quad # splits each quad into 2 triangles.
num_local_nodes = 3 * my_num_quad
num_ghost_nodes = 3
local_start_index = num_local_nodes * my_pid + 1
ghost_start_index = local_start_index + num_local_nodes
local_node_ids = list(
range(local_start_index, local_start_index + num_local_nodes))
ghost_node_ids = list(
range(ghost_start_index, ghost_start_index + num_ghost_nodes))
partition_index = dict()
for i in local_node_ids:
partition_index[i] = my_pid
if (my_pid == num_proc - 1): # Connect ring start and ring end.
ghost_node_ids = [1, 2, 3]
for i in ghost_node_ids:
partition_index[i] = (my_pid + 1) % num_proc
node_ids = local_node_ids + ghost_node_ids
# Create nodes.
for i in node_ids:
radius = 0.5 + 0.5 * ((i - 1) % 3) / 2.0
phase = 2.0 * math.pi * (
(i - 1) // 3) / float(my_num_quad * num_proc)
x = radius * math.cos(phase)
y = radius * math.sin(phase)
model_part.CreateNewNode(i, x, y, 0.0)
# Create elements and conditions.
for i in range(0, num_local_nodes, 3):
prop_id = 1
prop = model_part.GetProperties()[prop_id]
# First triangle.
eid = local_start_index + 3 * (i // 3)
nids = [node_ids[i], node_ids[i + 1], node_ids[i + 4]]
model_part.CreateNewElement("Element2D3N", eid, nids, prop)
model_part.CreateNewCondition("SurfaceCondition3D3N", eid, nids,
prop)
# Second triangle.
eid = eid + 1
nids = [node_ids[i], node_ids[i + 4], node_ids[i + 3]]
model_part.CreateNewElement("Element2D3N", eid, nids, prop)
model_part.CreateNewCondition("SurfaceCondition3D3N", eid, nids,
prop)
# Quad.
eid = eid + 1
nids = [
node_ids[i + 1], node_ids[i + 2], node_ids[i + 5],
node_ids[i + 4]
]
model_part.CreateNewElement("Element2D4N", eid, nids, prop)
model_part.CreateNewCondition("SurfaceCondition3D4N", eid, nids,
prop)
if my_pid == 0:
# Here we create a special condition that only exists on the first
# process. This is to test the collective write when at least one
# process has an empty set.
model_part.CreateNewCondition("LineCondition2D2N", eid + 1,
[node_ids[i + 1], node_ids[i + 2]],
prop)
model_part.SetBufferSize(2)
# Write some data to the nodal solution steps variables.
for node in model_part.Nodes:
node.SetSolutionStepValue(PARTITION_INDEX,
partition_index[node.Id])
node.SetSolutionStepValue(DISPLACEMENT_X, random.random())
node.SetSolutionStepValue(DISPLACEMENT_Y, random.random())
node.SetSolutionStepValue(DISPLACEMENT_Z, random.random())
node.SetSolutionStepValue(VELOCITY_X, random.random())
node.SetSolutionStepValue(VELOCITY_Y, random.random())
node.SetSolutionStepValue(VELOCITY_Z, random.random())
node.SetSolutionStepValue(ACCELERATION_X, random.random())
node.SetSolutionStepValue(ACCELERATION_Y, random.random())
node.SetSolutionStepValue(ACCELERATION_Z, random.random())
node.SetSolutionStepValue(PRESSURE, random.random())
node.SetSolutionStepValue(VISCOSITY, random.random())
node.SetSolutionStepValue(DENSITY, random.random())
node.SetSolutionStepValue(ACTIVATION_LEVEL,
random.randint(-100, 100))
KratosTrilinos.ParallelFillCommunicator(
model_part.GetRootModelPart()).Execute()
model_part.GetCommunicator().SynchronizeNodalSolutionStepsData()
# Set some process info variables.
model_part.ProcessInfo[DOMAIN_SIZE] = 3 # int
model_part.ProcessInfo[TIME] = 1.2345 # float
initial_strain = Vector(6)
for i in range(6):
initial_strain[i] = math.cos(i)
model_part.ProcessInfo[INITIAL_STRAIN] = initial_strain # vector
gl_strain_tensor = Matrix(5, 5)
for i in range(5):
for j in range(5):
gl_strain_tensor[i, j] = math.cos(i + j)
model_part.ProcessInfo[
GREEN_LAGRANGE_STRAIN_TENSOR] = gl_strain_tensor # matrix
def test_HDF5NodalSolutionStepDataIO(self):
with ControlledExecutionScope(
os.path.dirname(os.path.realpath(__file__))):
write_model_part = ModelPart("write")
KratosMetis.SetMPICommunicatorProcess(write_model_part).Execute()
self._initialize_model_part(write_model_part)
hdf5_file = self._get_file()
hdf5_model_part_io = self._get_model_part_io(hdf5_file)
hdf5_model_part_io.WriteModelPart(write_model_part)
read_model_part = ModelPart("read")
KratosMetis.SetMPICommunicatorProcess(read_model_part).Execute()
hdf5_model_part_io.ReadModelPart(read_model_part)
KratosTrilinos.ParallelFillCommunicator(
read_model_part.GetRootModelPart()).Execute()
hdf5_nodal_solution_step_data_io = self._get_nodal_solution_step_data_io(
hdf5_file)
hdf5_nodal_solution_step_data_io.WriteNodalResults(
write_model_part.Nodes, 0)
hdf5_nodal_solution_step_data_io.ReadNodalResults(
read_model_part.Nodes, read_model_part.GetCommunicator(), 0)
read_model_part.GetCommunicator(
).SynchronizeNodalSolutionStepsData()
# Check data.
for read_node, write_node in zip(read_model_part.Nodes,
write_model_part.Nodes):
self.assertEqual(
read_node.GetSolutionStepValue(DISPLACEMENT_X),
write_node.GetSolutionStepValue(DISPLACEMENT_X))
self.assertEqual(
read_node.GetSolutionStepValue(DISPLACEMENT_Y),
write_node.GetSolutionStepValue(DISPLACEMENT_Y))
self.assertEqual(
read_node.GetSolutionStepValue(DISPLACEMENT_Z),
write_node.GetSolutionStepValue(DISPLACEMENT_Z))
self.assertEqual(read_node.GetSolutionStepValue(VELOCITY_X),
write_node.GetSolutionStepValue(VELOCITY_X))
self.assertEqual(read_node.GetSolutionStepValue(VELOCITY_Y),
write_node.GetSolutionStepValue(VELOCITY_Y))
self.assertEqual(read_node.GetSolutionStepValue(VELOCITY_Z),
write_node.GetSolutionStepValue(VELOCITY_Z))
self.assertEqual(
read_node.GetSolutionStepValue(ACCELERATION_X),
write_node.GetSolutionStepValue(ACCELERATION_X))
self.assertEqual(
read_node.GetSolutionStepValue(ACCELERATION_Y),
write_node.GetSolutionStepValue(ACCELERATION_Y))
self.assertEqual(
read_node.GetSolutionStepValue(ACCELERATION_Z),
write_node.GetSolutionStepValue(ACCELERATION_Z))
self.assertEqual(read_node.GetSolutionStepValue(PRESSURE),
write_node.GetSolutionStepValue(PRESSURE))
self.assertEqual(read_node.GetSolutionStepValue(VISCOSITY),
write_node.GetSolutionStepValue(VISCOSITY))
self.assertEqual(read_node.GetSolutionStepValue(DENSITY),
write_node.GetSolutionStepValue(DENSITY))
self.assertEqual(
read_node.GetSolutionStepValue(ACTIVATION_LEVEL),
write_node.GetSolutionStepValue(ACTIVATION_LEVEL))
self.assertEqual(
read_node.GetSolutionStepValue(PARTITION_INDEX),
write_node.GetSolutionStepValue(PARTITION_INDEX))
if KratosMPI.mpi.rank == 0:
self._remove_file("test_hdf5_model_part_io_mpi.h5")
def test_trilinos_levelset_convection(self):
self.model_part = KratosMultiphysics.ModelPart("Main")
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("""{
"echo_level" : 0,
"model_import_settings" : {
"input_type" : "mdpa",
"input_filename" : "levelset_convection_process_mesh"
}
}""")
import trilinos_import_model_part_utility
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)
# 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
import trilinos_linear_solver_factory
trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
KratosMultiphysics.Parameters(
"""{"solver_type" : "AmesosSolver" }"""))
epetra_comm = TrilinosApplication.CreateCommunicator()
# 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)
min_distance = self.model_part.GetCommunicator().MinAll(min_distance)
max_distance = self.model_part.GetCommunicator().MaxAll(max_distance)
self.assertAlmostEqual(max_distance, 0.7904255118014996)
self.assertAlmostEqual(min_distance, -0.11710292469993094)
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 _ExecuteAfterLoad(self):
if self.set_mpi_communicator:
KratosTrilinos.ParallelFillCommunicator(
self.main_model_part.GetRootModelPart()).Execute()
def _CreateCuttingUtility(self):
if not CheckIfApplicationsAvailable("TrilinosApplication"):
raise Exception("Defining output cuts requires the TrilinosApplication, which appears to be unavailable.")
self.epetra_comm = KratosTrilinos.CreateCommunicator()
return KratosTrilinos.TrilinosCuttingApplication(self.epetra_comm)
def Initialize(self):
# Construct the communicator
self.EpetraCommunicator = TrilinosApplication.CreateCommunicator()
# Set ProcessInfo variables
self.main_model_part.ProcessInfo.SetValue(
KratosMultiphysics.REFERENCE_TEMPERATURE,
self.settings["reference_temperature"].GetDouble())
self.main_model_part.ProcessInfo.SetValue(
KratosConvDiff.THETA, self.settings["thermal_solver_settings"]
["theta_scheme"].GetDouble())
# Get the computing model parts
self.thermal_computing_model_part = self.main_model_part.GetSubModelPart(
self.thermal_model_part_name)
self.mechanical_computing_model_part = self.GetComputingModelPart()
# Builder and solver creation
thermal_builder_and_solver = self._ConstructBuilderAndSolver(
self.settings["thermal_solver_settings"]
["block_builder"].GetBool(), self.thermal_linear_solver)
mechanical_builder_and_solver = self._ConstructBuilderAndSolver(
self.settings["mechanical_solver_settings"]
["block_builder"].GetBool(), self.mechanical_linear_solver)
# Solution scheme creation
thermal_scheme = TrilinosApplication.TrilinosResidualBasedIncrementalUpdateStaticScheme(
)
mechanical_scheme = self._ConstructScheme(
self.settings["mechanical_solver_settings"]
["scheme_type"].GetString(),
self.settings["mechanical_solver_settings"]
["solution_type"].GetString())
# Get the convergence criterion
convergence_criterion = self._ConstructConvergenceCriterion(
self.settings["mechanical_solver_settings"]
["convergence_criterion"].GetString())
# Solver creation (Note: this could be TrilinosResidualBasedLinearStrategy, but there is no such strategy)
self.Thermal_Solver = TrilinosApplication.TrilinosNewtonRaphsonStrategy(
self.thermal_computing_model_part, thermal_scheme,
self.thermal_linear_solver, convergence_criterion,
thermal_builder_and_solver,
self.settings["mechanical_solver_settings"]
["max_iteration"].GetInt(),
self.settings["thermal_solver_settings"]
["compute_reactions"].GetBool(),
self.settings["thermal_solver_settings"]
["reform_dofs_at_each_step"].GetBool(),
self.settings["thermal_solver_settings"]
["move_mesh_flag"].GetBool())
self.Mechanical_Solver = self._ConstructSolver(
mechanical_builder_and_solver, mechanical_scheme,
convergence_criterion, self.settings["mechanical_solver_settings"]
["strategy_type"].GetString())
# Set echo_level
self.Thermal_Solver.SetEchoLevel(
self.settings["thermal_solver_settings"]["echo_level"].GetInt())
self.Mechanical_Solver.SetEchoLevel(
self.settings["mechanical_solver_settings"]["echo_level"].GetInt())
# Check if everything is assigned correctly
self.Thermal_Solver.Check()
self.Mechanical_Solver.Check()
print("Initialization MPI DamThermoMechanicSolver finished")
def _CreateEpetraCommunicator(self):
return KratosTrilinos.CreateCommunicator()
def Initialize(self):
## Construct the communicator
self.EpetraCommunicator = TrilinosApplication.CreateCommunicator()
## Get the computing model part
self.computing_model_part = self.GetComputingModelPart()
domain_size = self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE]
if self.settings["response_function_settings"][
"response_type"].GetString() == "drag":
if (domain_size == 2):
self.response_function = FluidDynamicsApplication.DragResponseFunction2D(
self.settings["response_function_settings"]
["custom_settings"], self.main_model_part)
elif (domain_size == 3):
self.response_function = FluidDynamicsApplication.DragResponseFunction3D(
self.settings["response_function_settings"]
["custom_settings"], self.main_model_part)
else:
raise Exception("Invalid DOMAIN_SIZE: " + str(domain_size))
else:
raise Exception("invalid response_type: " +
self.settings["response_function_settings"]
["response_type"].GetString())
self.sensitivity_builder = KratosMultiphysics.SensitivityBuilder(
self.settings["sensitivity_settings"], self.main_model_part,
self.response_function)
if self.settings["scheme_settings"]["scheme_type"].GetString(
) == "bossak":
self.time_scheme = TrilinosApplication.TrilinosResidualBasedAdjointBossakScheme(
self.settings["scheme_settings"], self.response_function)
elif self.settings["scheme_settings"]["scheme_type"].GetString(
) == "steady":
self.time_scheme = TrilinosApplication.TrilinosResidualBasedAdjointSteadyScheme(
self.response_function)
else:
raise Exception(
"invalid scheme_type: " +
self.settings["scheme_settings"]["scheme_type"].GetString())
if self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 3:
guess_row_size = 20 * 4
elif self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 2:
guess_row_size = 10 * 3
self.builder_and_solver = TrilinosApplication.TrilinosBlockBuilderAndSolver(
self.EpetraCommunicator, guess_row_size,
self.trilinos_linear_solver)
self.solver = TrilinosApplication.TrilinosLinearStrategy(
self.main_model_part, self.time_scheme,
self.trilinos_linear_solver, self.builder_and_solver, False, False,
False, False)
(self.solver).SetEchoLevel(self.settings["echo_level"].GetInt())
(self.solver).Initialize()
(self.response_function).Initialize()
(self.sensitivity_builder).Initialize()
self.main_model_part.ProcessInfo.SetValue(
KratosMultiphysics.DYNAMIC_TAU,
self.settings["dynamic_tau"].GetDouble())
self.main_model_part.ProcessInfo.SetValue(
KratosMultiphysics.OSS_SWITCH,
self.settings["oss_switch"].GetInt())
KratosMultiphysics.Logger.PrintInfo(
self.__class__.__name__,
"Monolithic MPI solver initialization finished.")
def Initialize(self):
## Construct the communicator
self.EpetraCommunicator = KratosTrilinos.CreateCommunicator()
## Get the computing model part
self.computing_model_part = self.GetComputingModelPart()
## If needed, create the estimate time step utility
if (self.settings["time_stepping"]["automatic_time_step"].GetBool()):
self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility(
)
## Creating the Trilinos convergence criteria
self.conv_criteria = KratosTrilinos.TrilinosUPCriteria(
self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble(),
self.settings["relative_pressure_tolerance"].GetDouble(),
self.settings["absolute_pressure_tolerance"].GetDouble())
(self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt())
## Constructing the BDF process (time coefficients update)
self.bdf_process = KratosMultiphysics.ComputeBDFCoefficientsProcess(
self.computing_model_part, self.settings["time_order"].GetInt())
## Creating the Trilinos incremental update time scheme (the time integration is defined within the embedded element)
self.time_scheme = KratosTrilinos.TrilinosResidualBasedIncrementalUpdateStaticSchemeSlip(
self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE], # Domain size (2,3)
self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] +
1) # DOFs (3,4)
## Set the guess_row_size (guess about the number of zero entries) for the Trilinos builder and solver
if self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 3:
guess_row_size = 20 * 4
elif self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 2:
guess_row_size = 10 * 3
## Construct the Trilinos builder and solver
if self.settings["consider_periodic_conditions"].GetBool() == True:
self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolverPeriodic(
self.EpetraCommunicator, guess_row_size,
self.trilinos_linear_solver, KratosFluid.PATCH_INDEX)
else:
self.builder_and_solver = KratosTrilinos.TrilinosBlockBuilderAndSolver(
self.EpetraCommunicator, guess_row_size,
self.trilinos_linear_solver)
## Construct the Trilinos Newton-Raphson strategy
self.solver = KratosTrilinos.TrilinosNewtonRaphsonStrategy(
self.main_model_part, self.time_scheme,
self.trilinos_linear_solver, self.conv_criteria,
self.builder_and_solver,
self.settings["maximum_iterations"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
(self.solver).SetEchoLevel(self.settings["echo_level"].GetInt())
(self.solver).Initialize()
# For the primitive Ausas formulation, set the find nodal neighbours process
# Recall that the Ausas condition requires the nodal neighbouts.
if (self.settings["formulation"]["element_type"].GetString() ==
"embedded_ausas_navier_stokes"):
number_of_avg_elems = 10
number_of_avg_nodes = 10
self.find_nodal_neighbours_process = KratosMultiphysics.FindNodalNeighboursProcess(
self.GetComputingModelPart(), number_of_avg_elems,
number_of_avg_nodes)
if self._IsPrintingRank():
KratosMultiphysics.Logger.PrintInfo(
"NavierStokesMPIEmbeddedMonolithicSolver",
"Solver initialization finished.")
def _create_epetra_communicator(self):
return TrilinosApplication.CreateCommunicator()
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 _CreateConvergenceCriterion(self):
convergence_criterion = KratosTrilinos.TrilinosMixedGenericCriteria(
[(KratosMultiphysics.VELOCITY, self.settings["relative_velocity_tolerance"].GetDouble(), self.settings["absolute_velocity_tolerance"].GetDouble()),
(KratosMultiphysics.PRESSURE, self.settings["relative_pressure_tolerance"].GetDouble(), self.settings["absolute_pressure_tolerance"].GetDouble())])
convergence_criterion.SetEchoLevel(self.settings["echo_level"].GetInt())
return convergence_criterion
def Initialize(self):
## Construct the communicator
self.EpetraComm = KratosTrilinos.CreateCommunicator()
## Get the computing model part
self.computing_model_part = self.GetComputingModelPart()
## If needed, create the estimate time step utility
if (self.settings["time_stepping"]["automatic_time_step"].GetBool()):
self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility(
)
#TODO: next part would be much cleaner if we passed directly the parameters to the c++
if self.settings["consider_periodic_conditions"] == True:
self.solver_settings = TrilinosFluid.TrilinosFractionalStepSettingsPeriodic(
self.EpetraComm, self.computing_model_part,
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE],
self.settings["time_order"].GetInt(),
self.settings["use_slip_conditions"].GetBool(),
self.settings["move_mesh_flag"].GetBool(),
self.settings["reform_dofs_at_each_step]"].GetBool(),
KratosFluid.PATCH_INDEX)
else:
self.solver_settings = TrilinosFluid.TrilinosFractionalStepSettings(
self.EpetraComm, self.computing_model_part,
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE],
self.settings["time_order"].GetInt(),
self.settings["use_slip_conditions"].GetBool(),
self.settings["move_mesh_flag"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool())
self.solver_settings.SetEchoLevel(self.settings["echo_level"].GetInt())
self.solver_settings.SetStrategy(
TrilinosFluid.TrilinosStrategyLabel.Velocity,
self.velocity_linear_solver,
self.settings["velocity_tolerance"].GetDouble(),
self.settings["maximum_velocity_iterations"].GetInt())
self.solver_settings.SetStrategy(
TrilinosFluid.TrilinosStrategyLabel.Pressure,
self.pressure_linear_solver,
self.settings["pressure_tolerance"].GetDouble(),
self.settings["maximum_pressure_iterations"].GetInt())
self.solver = TrilinosFluid.TrilinosFSStrategy(
self.computing_model_part, self.solver_settings,
self.settings["predictor_corrector"].GetBool(),
KratosFluid.PATCH_INDEX)
self.main_model_part.ProcessInfo.SetValue(
KratosMultiphysics.DYNAMIC_TAU,
self.settings["dynamic_tau"].GetDouble())
self.main_model_part.ProcessInfo.SetValue(
KratosMultiphysics.OSS_SWITCH,
self.settings["oss_switch"].GetInt())
(self.solver).Initialize()
KratosMultiphysics.Logger.PrintInfo(
"TrilinosNavierStokesSolverFractionalStep",
"Initialization TrilinosNavierStokesSolverFractionalStep finished")
def testTrilinosRedistance(self):
# Set the model part
self.model_part = KratosMultiphysics.ModelPart("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("""{
"echo_level" : 0,
"model_import_settings" : {
"input_type" : "mdpa",
"input_filename" : "coarse_sphere"
}
}""")
import trilinos_import_model_part_utility
TrilinosModelPartImporter = trilinos_import_model_part_utility.TrilinosImportModelPartUtility(
self.model_part, import_settings)
TrilinosModelPartImporter.ExecutePartitioningAndReading()
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
import trilinos_linear_solver_factory
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 _ExecuteAfterLoad(self):
if self.set_mpi_communicator:
import KratosMultiphysics.TrilinosApplication as KratosTrilinos
KratosTrilinos.ParallelFillCommunicator(
self.main_model_part.GetRootModelPart()).Execute()
def _GetEpetraCommunicator(self):
if not hasattr(self, '_epetra_communicator'):
self._epetra_communicator = KratosTrilinos.CreateCommunicator()
return self._epetra_communicator
def ImportModelPart(self):
if (self.settings["model_import_settings"]["input_type"].GetString() ==
"mdpa"):
# here we read the already existing partitions from the primal solution.
input_filename = self.settings["model_import_settings"][
"input_filename"].GetString()
mpi_input_filename = input_filename + "_" + str(KratosMPI.mpi.rank)
self.settings["model_import_settings"]["input_filename"].SetString(
mpi_input_filename)
KratosMultiphysics.ModelPartIO(mpi_input_filename).ReadModelPart(
self.main_model_part)
# here we shall check that the input read has the shape we like
aux_params = KratosMultiphysics.Parameters("{}")
aux_params.AddValue("volume_model_part_name",
self.settings["volume_model_part_name"])
aux_params.AddValue("skin_parts", self.settings["skin_parts"])
# here we replace the dummy elements we read with proper elements
self.settings.AddEmptyValue("element_replace_settings")
if (self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 3):
self.settings[
"element_replace_settings"] = KratosMultiphysics.Parameters(
"""
{
"element_name": "VMSAdjointElement3D",
"condition_name": "SurfaceCondition3D3N"
}
""")
elif (self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 2):
self.settings[
"element_replace_settings"] = KratosMultiphysics.Parameters(
"""
{
"element_name": "VMSAdjointElement2D",
"condition_name": "LineCondition2D2N"
}
""")
else:
raise Exception("domain size is not 2 nor 3")
KratosMultiphysics.ReplaceElementsAndConditionsProcess(
self.main_model_part,
self.settings["element_replace_settings"]).Execute()
import check_and_prepare_model_process_fluid
check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(
self.main_model_part, aux_params).Execute()
# here we read the KINEMATIC VISCOSITY and DENSITY and we apply it to the nodes
for el in self.main_model_part.Elements:
rho = el.Properties.GetValue(KratosMultiphysics.DENSITY)
kin_viscosity = el.Properties.GetValue(
KratosMultiphysics.VISCOSITY)
break
KratosMultiphysics.VariableUtils().SetScalarVar(
KratosMultiphysics.DENSITY, rho, self.main_model_part.Nodes)
KratosMultiphysics.VariableUtils().SetScalarVar(
KratosMultiphysics.VISCOSITY, kin_viscosity,
self.main_model_part.Nodes)
else:
raise Exception("Other input options are not yet implemented.")
current_buffer_size = self.main_model_part.GetBufferSize()
if (self.GetMinimumBufferSize() > current_buffer_size):
self.main_model_part.SetBufferSize(self.GetMinimumBufferSize())
MetisApplication.SetMPICommunicatorProcess(
self.main_model_part).Execute()
ParallelFillCommunicator = TrilinosApplication.ParallelFillCommunicator(
self.main_model_part.GetRootModelPart())
ParallelFillCommunicator.Execute()
if KratosMPI.mpi.rank == 0:
print("MPI communicators constructed.")
print("MPI model reading finished.")
