def _CreateLinearSolver(self):
# Create the pressure linear solver
pressure_linear_solver_configuration = self.settings["pressure_linear_solver_settings"]
pressure_linear_solver = trilinos_linear_solver_factory.ConstructSolver(pressure_linear_solver_configuration)
# Create the velocity linear solver
velocity_linear_solver_configuration = self.settings["velocity_linear_solver_settings"]
velocity_linear_solver = trilinos_linear_solver_factory.ConstructSolver(velocity_linear_solver_configuration)
# Return a tuple containing both linear solvers
return (pressure_linear_solver, velocity_linear_solver)
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 __init__(self, model, custom_settings):
self._validate_settings_in_baseclass = True # To be removed eventually
# Note: deliberately calling the constructor of the base python solver (the parent of my parent)
custom_settings = self._BackwardsCompatibilityHelper(custom_settings)
super(navier_stokes_solver_vmsmonolithic.NavierStokesSolverMonolithic,
self).__init__(model, custom_settings)
self.formulation = navier_stokes_solver_vmsmonolithic.StabilizedFormulation(
self.settings["formulation"])
self.element_name = self.formulation.element_name
self.condition_name = self.formulation.condition_name
self.element_integrates_in_time = self.formulation.element_integrates_in_time
scheme_type = self.settings["time_scheme"].GetString()
if scheme_type == "bossak":
self.min_buffer_size = 2
elif scheme_type == "bdf2":
self.min_buffer_size = 3
else:
msg = "Unknown time_scheme option found in project parameters:\n"
msg += "\"" + scheme_type + "\"\n"
msg += "Accepted values are \"bossak\" or \"bdf2\".\n"
raise Exception(msg)
## Construct the linear solver
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
KratosMultiphysics.Logger.Print(
"Construction of TrilinosNavierStokesSolverMonolithic finished.")
def __init__(self, model, custom_settings):
self._validate_settings_in_baseclass = True # To be removed eventually
# Note: deliberately calling the constructor of the base python solver (the parent of my parent)
super(
navier_stokes_embedded_solver.NavierStokesEmbeddedMonolithicSolver,
self).__init__(model, custom_settings)
self.min_buffer_size = 3
self.embedded_formulation = navier_stokes_embedded_solver.EmbeddedFormulation(
self.settings["formulation"])
self.element_name = self.embedded_formulation.element_name
self.condition_name = self.embedded_formulation.condition_name
## Set the formulation level set type
self.level_set_type = self.embedded_formulation.level_set_type
## Set the nodal properties flag
self.element_has_nodal_properties = self.embedded_formulation.element_has_nodal_properties
## Construct the linear solver
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
KratosMultiphysics.Logger.PrintInfo(
"NavierStokesMPIEmbeddedMonolithicSolver",
"Construction of NavierStokesMPIEmbeddedMonolithicSolver finished."
)
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.7333041045431626)
self.assertAlmostEqual(min_distance,-0.06371359024393104)
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.CreateCommunicator()
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 __init__(self, model, custom_settings):
self._validate_settings_in_baseclass = True # To be removed eventually
# Note: deliberately calling the constructor of the base python solver (the parent of my parent)
super(NavierStokesSolverFractionalStep,
self).__init__(model, custom_settings)
self.element_name = "FractionalStep"
self.condition_name = "WallCondition"
self.min_buffer_size = 3
## Construct the linear solvers
self.pressure_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["pressure_linear_solver_settings"])
self.velocity_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["velocity_linear_solver_settings"])
self.compute_reactions = self.settings["compute_reactions"].GetBool()
KratosMultiphysics.Logger.PrintInfo(
"TrilinosNavierStokesSolverFractionalStep",
"Construction of TrilinosNavierStokesSolverFractionalStep solver finished."
)
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 __init__(self, model, custom_settings):
self._validate_settings_in_baseclass=True # To be removed eventually
super(AdjointVMSMonolithicSolver, self).__init__(model, custom_settings)
self.element_name = "VMSAdjointElement"
if self.settings["domain_size"].GetInt() == 2:
self.condition_name = "LineCondition"
elif self.settings["domain_size"].GetInt() == 3:
self.condition_name = "SurfaceCondition"
self.min_buffer_size = 2
self.element_has_nodal_properties = True
# construct the linear solver
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
KratosMultiphysics.Logger.PrintInfo(self.__class__.__name__, "Construction of AdjointVMSMonolithicMPISolver finished.")
def __init__(self, model, custom_settings):
self._validate_settings_in_baseclass=True # To be removed eventually
# the constructor of the "grand-parent" (jumping constructor of parent) is called to avoid conflicts in attribute settings
super(NavierStokesTwoFluidsSolver, self).__init__(model,custom_settings)
self.element_name = "TwoFluidNavierStokes"
self.condition_name = "NavierStokesWallCondition"
self.element_has_nodal_properties = True
self.min_buffer_size = 3
if (self.settings["solver_type"].GetString() == "TwoFluids"):
self.element_name = "TwoFluidNavierStokes"
## Construct the linear solver
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
KratosMultiphysics.Logger.PrintInfo("NavierStokesMPITwoFluidsSolver","Construction of NavierStokesMPITwoFluidsSolver finished.")
def __init__(self, model, custom_settings):
self._validate_settings_in_baseclass = True # To be removed eventually
# Note: deliberately calling the constructor of the base python solver (the parent of my parent)
custom_settings = self._BackwardsCompatibilityHelper(custom_settings)
super(navier_stokes_solver_vmsmonolithic.NavierStokesSolverMonolithic,
self).__init__(model, custom_settings)
self.formulation = navier_stokes_solver_vmsmonolithic.StabilizedFormulation(
self.settings["formulation"])
self.element_name = self.formulation.element_name
self.condition_name = self.formulation.condition_name
self.element_integrates_in_time = self.formulation.element_integrates_in_time
self.element_has_nodal_properties = self.formulation.element_has_nodal_properties
scheme_type = self.settings["time_scheme"].GetString()
if scheme_type == "bossak":
self.min_buffer_size = 2
elif scheme_type == "bdf2":
self.min_buffer_size = 3
elif scheme_type == "steady":
self.min_buffer_size = 1
self._SetUpSteadySimulation()
else:
msg = "Unknown time_scheme option found in project parameters:\n"
msg += "\"" + scheme_type + "\"\n"
msg += "Accepted values are \"bossak\", \"bdf2\" or \"steady\".\n"
raise Exception(msg)
## Construct the linear solver
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
## Construct the turbulence model solver
if not self.settings["turbulence_model_solver_settings"].IsEquivalentTo(
KratosMultiphysics.Parameters("{}")):
self._turbulence_model_solver = CreateTurbulenceModel(
model, self.settings["turbulence_model_solver_settings"], True)
self.condition_name = self._turbulence_model_solver.GetFluidVelocityPressureConditionName(
)
KratosMultiphysics.Logger.PrintInfo(
"TrilinosNavierStokesSolverMonolithic",
"Using " + self.condition_name + " as wall condition")
KratosMultiphysics.Logger.Print(
"Construction of TrilinosNavierStokesSolverMonolithic finished.")
def __init__(self, model, custom_settings):
self._validate_settings_in_baseclass = True # To be removed eventually
# Note: deliberately calling the constructor of the base python solver (the parent of my parent)
custom_settings = self._BackwardsCompatibilityHelper(custom_settings)
super(navier_stokes_solver_vmsmonolithic.NavierStokesSolverMonolithic,
self).__init__(model, custom_settings)
self.formulation = navier_stokes_solver_vmsmonolithic.StabilizedFormulation(
self.settings["formulation"])
self.element_name = self.formulation.element_name
self.condition_name = self.formulation.condition_name
self.min_buffer_size = 2
## Construct the linear solver
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
KratosMultiphysics.Logger.Print(
"Construction of TrilinosNavierStokesSolverMonolithic finished.")
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 _CreateLinearSolver(self):
linear_solver_configuration = self.settings["linear_solver_settings"]
return trilinos_linear_solver_factory.ConstructSolver(
linear_solver_configuration)
def __init__(self, main_model_part, custom_settings):
#TODO: shall obtain the computing_model_part from the MODEL once the object is implemented
self.main_model_part = main_model_part
##settings string in json format
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type": "dam_MPI_UP_mechanical_solver",
"model_import_settings":{
"input_type": "mdpa",
"input_filename": "unknown_name",
"input_file_label": 0
},
"buffer_size": 2,
"echo_level": 0,
"processes_sub_model_part_list": [""],
"mechanical_solver_settings":{
"echo_level": 0,
"reform_dofs_at_each_step": false,
"clear_storage": false,
"compute_reactions": false,
"move_mesh_flag": true,
"solution_type": "Quasi-Static",
"scheme_type": "Newmark",
"rayleigh_m": 0.0,
"rayleigh_k": 0.0,
"strategy_type": "Newton-Raphson",
"convergence_criterion": "Displacement_criterion",
"displacement_relative_tolerance": 1.0e-4,
"displacement_absolute_tolerance": 1.0e-9,
"residual_relative_tolerance": 1.0e-4,
"residual_absolute_tolerance": 1.0e-9,
"max_iteration": 15,
"desired_iterations": 4,
"max_radius_factor": 20.0,
"min_radius_factor": 0.5,
"block_builder": true,
"nonlocal_damage": false,
"characteristic_length": 0.05,
"search_neighbours_step": false,
"linear_solver_settings":{
"solver_type": "AMGCL",
"tolerance": 1.0e-6,
"max_iteration": 100,
"scaling": false,
"verbosity": 0,
"preconditioner_type": "ILU0Preconditioner",
"smoother_type": "ilu0",
"krylov_type": "gmres",
"coarsening_type": "aggregation"
},
"problem_domain_sub_model_part_list": [""],
"body_domain_sub_model_part_list": [],
"mechanical_loads_sub_model_part_list": [],
"loads_sub_model_part_list": [],
"loads_variable_list": []
}
}
""")
# Overwrite the default settings with user-provided parameters
self.settings = custom_settings
self.settings.ValidateAndAssignDefaults(default_settings)
# Construct the linear solver
self.linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["mechanical_solver_settings"]
["linear_solver_settings"])
print("Construction of Dam_MPI_UPMechanicalSolver finished")
def _create_linear_solver(self):
return trilinos_linear_solver_factory.ConstructSolver(
self.settings["mesh_motion_linear_solver_settings"])
def _auxiliary_test_function(self,
settings,
matrix_name="A.mm",
absolute_norm=False):
comm = KratosMultiphysics.TrilinosApplication.CreateCommunicator()
space = KratosMultiphysics.TrilinosApplication.TrilinosSparseSpace()
#read the matrices
pA = space.ReadMatrixMarketMatrix(GetFilePath(matrix_name), comm)
n = space.Size1(pA.GetReference())
pAoriginal = space.ReadMatrixMarketMatrix(GetFilePath(matrix_name),
comm)
pb = space.CreateEmptyVectorPointer(comm)
space.ResizeVector(pb, n)
space.SetToZeroVector(pb.GetReference())
space.SetValue(pb.GetReference(), 0, 1.0) #pb[1] = 1.0
px = space.CreateEmptyVectorPointer(comm)
space.ResizeVector(px, n)
pboriginal = space.CreateEmptyVectorPointer(comm) #create a copy of b
space.ResizeVector(pboriginal, n)
space.SetToZeroVector(pboriginal.GetReference())
space.UnaliasedAdd(pboriginal.GetReference(), 1.0, pb.GetReference())
space.SetToZeroVector(px.GetReference())
#space.SetToZeroVector(boriginal)
#space.UnaliasedAdd(boriginal, 1.0, b) #boriginal=1*bs
#construct the solver
linear_solver = trilinos_linear_solver_factory.ConstructSolver(
settings)
#solve
linear_solver.Solve(pA.GetReference(), px.GetReference(),
pb.GetReference())
#test the results
ptmp = space.CreateEmptyVectorPointer(comm)
space.ResizeVector(ptmp, n)
space.SetToZeroVector(ptmp.GetReference())
space.Mult(pAoriginal.GetReference(), px.GetReference(),
ptmp.GetReference())
pcheck = space.CreateEmptyVectorPointer(comm)
space.ResizeVector(pcheck, n)
space.SetToZeroVector(pcheck.GetReference())
space.UnaliasedAdd(pcheck.GetReference(), 1.0,
pboriginal.GetReference())
space.UnaliasedAdd(pcheck.GetReference(), -1.0, ptmp.GetReference())
achieved_norm = space.TwoNorm(pcheck.GetReference())
tolerance = 1e-9
if (settings.Has("tolerance")):
tolerance = settings["tolerance"].GetDouble()
nproc = KratosMultiphysics.DataCommunicator.GetDefault().Size()
target_norm = tolerance * space.TwoNorm(
pboriginal.GetReference()
) * nproc #multiplying by nproc the target tolerance to give some slack. Not really nice :-(
if (achieved_norm > target_norm):
print("target_norm :", target_norm)
print("achieved_norm :", achieved_norm)
self.assertTrue(achieved_norm <= target_norm)
#destroy the preconditioner - this is needed since the solver should be destroyed before the destructor of the system matrix is called
del linear_solver
def _ConstructLinearSolver(self):
return trilinos_linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
def CreateStrategy(self, solver_settings, scheme_settings, model_part,
scalar_variable, scalar_variable_rate,
relaxed_scalar_variable_rate):
default_solver_settings = Kratos.Parameters(r'''{
"is_periodic" : false,
"relative_tolerance" : 1e-3,
"absolute_tolerance" : 1e-5,
"max_iterations" : 200,
"relaxation_factor" : 0.5,
"echo_level" : 0,
"linear_solver_settings": {
"solver_type" : "amgcl"
},
"reform_dofs_at_each_step": true,
"move_mesh_strategy": 0,
"move_mesh_flag": false,
"compute_reactions": false
}''')
default_scheme_settings = Kratos.Parameters(r'''{
"scheme_type": "bossak",
"alpha_bossak": -0.3
}''')
solver_settings.ValidateAndAssignDefaults(default_solver_settings)
scheme_settings.ValidateAndAssignDefaults(default_scheme_settings)
linear_solver = linear_solver_factory.ConstructSolver(
solver_settings["linear_solver_settings"])
is_periodic = solver_settings["is_periodic"].GetBool()
if is_periodic:
self.__InitializePeriodicConditions(model_part, scalar_variable)
# TODO:
if is_periodic and IsDistributedRun():
msg = "\nCurrently periodic conditions in mpi is not supported due to following reasons:\n\n"
msg += " 1. TrilinosResidualCriteria [ConvergenceCriterian]\n"
msg += "PeriodicConditions duplicates one patch's equation ids to the counter patch. "
msg += "The node and its corresponding dof might not fall in to the same partition raising an error in convergence calculation.\n\n"
msg += " 2. ConnectivityPreserveModeller\n"
msg += "Currently connectivity preserve modeller replaces all the conditions in an mdpa with given new condition. "
msg += "This modeller is used to create modelparts having k-epsilon elements and conditions while sharing the same nodes as in VMS solution. "
msg += "In the case of MPI, it is essential to have the PeriodicConditions in the mdpa file in order to properly distribute nodes to partitions using MetisApplication. "
msg += "But if this is the case, PeriodicConditions also will be replaced by k-epsilon specific conditions casuing a segmentation fault.\n"
msg += " 3. TrilinosBlockBuilderAndSolverPeriodic\n"
msg += "In the case of MPI periodic in 2D, problem uses TrilinosBlockBuilderAndSolverPeriodic block builder and solver, which identifies "
msg += "periodic conditions by number of nodes in the condition. So, In 2D all wall conditions and PeriodicConditions have only 2 nodes, all will be "
msg += "considered as PeriodicConditions and will make the global assembly accordingly which is wrong."
msg += "Therefore this error msg is printed in order to avoid confusion."
raise Exception(msg)
builder_and_solver = self.__CreateBuilderAndSolver(
linear_solver, is_periodic)
if (scheme_settings["scheme_type"].GetString() == "bossak"):
convergence_criteria_type = scalar_convergence_criteria
elif (scheme_settings["scheme_type"].GetString() == "steady"):
convergence_criteria_type = residual_criteria
convergence_criteria = convergence_criteria_type(
solver_settings["relative_tolerance"].GetDouble(),
solver_settings["absolute_tolerance"].GetDouble())
if (scheme_settings["scheme_type"].GetString() == "bossak"):
time_scheme = dynamic_scheme(
scheme_settings["alpha_bossak"].GetDouble(),
solver_settings["relaxation_factor"].GetDouble(),
scalar_variable, scalar_variable_rate,
relaxed_scalar_variable_rate)
elif (scheme_settings["scheme_type"].GetString() == "steady"):
time_scheme = steady_scheme(
solver_settings["relaxation_factor"].GetDouble())
self.fluid_model_part.ProcessInfo[
Kratos.
BOSSAK_ALPHA] = scheme_settings["alpha_bossak"].GetDouble()
self.fluid_model_part.ProcessInfo[
KratosRANS.IS_CO_SOLVING_PROCESS_ACTIVE] = True
if (self.fluid_model_part.ProcessInfo[Kratos.DYNAMIC_TAU] != 0.0):
Kratos.Logger.PrintWarning(
self.__class__.__name__,
"Steady solution doesn't have zero DYNAMIC_TAU [ DYNAMIC_TAU = "
+
str(self.fluid_model_part.ProcessInfo[Kratos.DYNAMIC_TAU])
+ " ].")
else:
raise Exception("Unknown scheme_type = \"" +
scheme_settings["scheme_type"] + "\"")
strategy = newton_raphson_strategy(
model_part, time_scheme, linear_solver, convergence_criteria,
builder_and_solver, solver_settings["max_iterations"].GetInt(),
solver_settings["compute_reactions"].GetBool(),
solver_settings["reform_dofs_at_each_step"].GetBool(),
solver_settings["move_mesh_flag"].GetBool())
strategy.SetEchoLevel(solver_settings["echo_level"].GetInt() - 2)
builder_and_solver.SetEchoLevel(
solver_settings["echo_level"].GetInt() - 3)
convergence_criteria.SetEchoLevel(
solver_settings["echo_level"].GetInt() - 1)
if (is_periodic):
Kratos.Logger.PrintInfo(
self.__class__.__name__,
"Successfully created periodic solving strategy for " +
scalar_variable.Name() + ".")
else:
Kratos.Logger.PrintInfo(
self.__class__.__name__,
"Successfully created solving strategy for " +
scalar_variable.Name() + ".")
return strategy
def _ConstructLinearSolver(self):
from KratosMultiphysics.TrilinosApplication import trilinos_linear_solver_factory
return trilinos_linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
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)
