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 get_communicator(self):
if not hasattr(self, '_communicator'):
self._communicator = TrilinosApplication.CreateCommunicator()
return self._communicator
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.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)
comm = self.model_part.GetCommunicator().GetDataCommunicator()
min_distance = comm.MinAll(min_distance)
max_distance = comm.MaxAll(max_distance)
self.assertAlmostEqual(max_distance, 0.7904255118014996)
self.assertAlmostEqual(min_distance, -0.11710292469993094)
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 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, 10, 10)
(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 _GetEpetraCommunicator(self):
if not hasattr(self, '_epetra_communicator'):
self._epetra_communicator = KratosTrilinos.CreateCommunicator()
return self._epetra_communicator
def _create_epetra_communicator(self):
return TrilinosApplication.CreateCommunicator()
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)
KratosMultiphysics.Logger.PrintInfo(
"NavierStokesMPIEmbeddedMonolithicSolver",
"Solver initialization finished.")
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._get_automatic_time_stepping_utility(
)
#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 = KratosTrilinos.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 = KratosTrilinos.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(
KratosTrilinos.TrilinosStrategyLabel.Velocity,
self.velocity_linear_solver,
self.settings["velocity_tolerance"].GetDouble(),
self.settings["maximum_velocity_iterations"].GetInt())
self.solver_settings.SetStrategy(
KratosTrilinos.TrilinosStrategyLabel.Pressure,
self.pressure_linear_solver,
self.settings["pressure_tolerance"].GetDouble(),
self.settings["maximum_pressure_iterations"].GetInt())
self.solver = KratosTrilinos.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()
(self.solver).Check()
if self._IsPrintingRank():
#TODO: CHANGE THIS ONCE THE MPI LOGGER IS IMPLEMENTED
KratosMultiphysics.Logger.PrintInfo(
"TrilinosNavierStokesSolverFractionalStep",
"Initialization TrilinosNavierStokesSolverFractionalStep 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()
(self.solver).Check()
self.main_model_part.ProcessInfo.SetValue(
KratosMultiphysics.DYNAMIC_TAU,
self.settings["dynamic_tau"].GetDouble())
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("""{
"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.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
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 _CreateEpetraCommunicator(self):
return KratosTrilinos.CreateCommunicator()
def _GetEpetraCommunicator(self):
if not hasattr(self, '_epetra_communicator'):
self._epetra_communicator = TrilinosApplication.CreateCommunicator(
)
return self._epetra_communicator
