def ImportChimeraModelparts(main_modelpart, chimera_mp_import_settings_list, material_file="", parallel_type="OpenMP"):
'''
This function extends the functionalities of the
mpda_manipulator from: https://github.com/philbucher/mdpa-manipulator
main_modelpart : The modelpart to which the new modelparts are appended to.
chimera_mp_import_settings_list : The list of import setting for all chimera modelparts. each entry has the following format:
{
"model_import_settings":{
"input_type": "mdpa",
"input_filename": "SOME"
},
"echo_level":1
}
'''
if parallel_type == "OpenMP":
for mp_import_setting in chimera_mp_import_settings_list:
mdpa_file_name = mp_import_setting["input_filename"].GetString()
if mdpa_file_name.endswith('.mdpa'):
mdpa_file_name = mdpa_file_name[:-5]
model = KratosMultiphysics.Model()
model_part = model.CreateModelPart("new_modelpart")
KratosChimera.TransferSolutionStepData(main_modelpart, model_part)
ReadModelPart(mdpa_file_name, model_part, material_file)
AddModelPart(main_modelpart, model_part)
elif(parallel_type == "MPI"):
input_settings = KratosMultiphysics.Parameters("""{
"model_import_settings":{
"input_type": "mdpa",
"input_filename": "SOME"
},
"echo_level":1
}""")
for mp_import_setting in chimera_mp_import_settings_list:
model = KratosMultiphysics.Model()
model_part = model.CreateModelPart("new_modelpart")
KratosChimera.TransferSolutionStepData(main_modelpart, model_part)
model_part.AddNodalSolutionStepVariable(KratosMultiphysics.PARTITION_INDEX)
mdpa_file_name = mp_import_setting["input_filename"].GetString()
if mdpa_file_name.endswith('.mdpa'):
mdpa_file_name = mdpa_file_name[:-5]
mp_import_setting["input_filename"].SetString(mdpa_file_name)
input_settings["model_import_settings"] = mp_import_setting
from KratosMultiphysics.mpi import distributed_import_model_part_utility
mpi_import_utility = distributed_import_model_part_utility.DistributedImportModelPartUtility(model_part, input_settings)
mpi_import_utility.ImportModelPart()
#mpi_import_utility.CreateCommunicators()
AddModelPart(main_modelpart, model_part, is_mpi=True)
## Construct and execute the Parallel fill communicator (also sets the MPICommunicator)
import KratosMultiphysics.mpi as KratosMPI
ParallelFillCommunicator = KratosMPI.ParallelFillCommunicator(main_modelpart.GetRootModelPart())
ParallelFillCommunicator.Execute()
def _CreateSolutionStrategy(self):
computing_model_part = self.GetComputingModelPart()
domain_size = computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE]
# Create the pressure and velocity linear solvers
# Note that linear_solvers is a tuple. The first item is the pressure
# linear solver. The second item is the velocity linear solver.
linear_solvers = self._GetLinearSolver()
# Create the fractional step settings instance
# TODO: next part would be much cleaner if we passed directly the parameters to the c++
if self.settings["consider_periodic_conditions"].GetBool():
KratosMultiphysics.Logger.PrintInfo(
"NavierStokesSolverFractionalStepForChimera Periodic conditions are not implemented in this case ."
)
raise NotImplementedError
else:
fractional_step_settings = KratosChimera.FractionalStepSettingsChimera(
computing_model_part, 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())
# Set the strategy echo level
fractional_step_settings.SetEchoLevel(
self.settings["echo_level"].GetInt())
# Set the velocity and pressure fractional step strategy settings
fractional_step_settings.SetStrategy(
KratosCFD.StrategyLabel.Pressure, linear_solvers[0],
self.settings["pressure_tolerance"].GetDouble(),
self.settings["maximum_pressure_iterations"].GetInt())
fractional_step_settings.SetStrategy(
KratosCFD.StrategyLabel.Velocity, linear_solvers[1],
self.settings["velocity_tolerance"].GetDouble(),
self.settings["maximum_velocity_iterations"].GetInt())
# Create the fractional step strategy
if self.settings["consider_periodic_conditions"].GetBool() == True:
KratosMultiphysics.Logger.PrintInfo(
"FractionalStepStrategyForChimera Periodic conditions are not implemented in this case ."
)
raise NotImplementedError
else:
solution_strategy = KratosChimera.FractionalStepStrategyForChimera(
computing_model_part, fractional_step_settings,
self.settings["predictor_corrector"].GetBool(),
self.settings["compute_reactions"].GetBool())
return solution_strategy
def Initialize(self):
self.chimera_process = chimera_setup_utils.GetApplyChimeraProcess(self.model, self.chimera_settings, self.settings)
self.computing_model_part =self.main_model_part
# 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:
KratosMultiphysics.Logger.PrintInfo("NavierStokesSolverFractionalStepForChimera Periodic conditions are not implemented in this case .")
raise NotImplementedError
else:
self.solver_settings = KratosChimera.FractionalStepSettings(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(KratosCFD.StrategyLabel.Velocity,
self.velocity_linear_solver,
self.settings["velocity_tolerance"].GetDouble(),
self.settings["maximum_velocity_iterations"].GetInt())
self.solver_settings.SetStrategy(KratosCFD.StrategyLabel.Pressure,
self.pressure_linear_solver,
self.settings["pressure_tolerance"].GetDouble(),
self.settings["maximum_pressure_iterations"].GetInt())
if self.settings["consider_periodic_conditions"].GetBool() == True:
self.solver = KratosCFD.FSStrategy(self.computing_model_part,
self.solver_settings,
self.settings["predictor_corrector"].GetBool(),
KratosCFD.PATCH_INDEX)
else:
self.solver = KratosChimera.FSStrategyForChimera(self.computing_model_part,
self.solver_settings,
self.settings["predictor_corrector"].GetBool())
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()
KratosMultiphysics.Logger.PrintInfo("NavierStokesSolverFractionalStepForChimera", "Solver initialization finished.")
chimera_setup_utils.SetChimeraInternalPartsFlag(self.model, self.chimera_internal_parts)
def GetApplyChimeraProcess(model, chimera_parameters, fluid_parameters):
chimera_echo_lvl = 0
if chimera_parameters.Has("chimera_echo_level"):
chimera_echo_lvl = chimera_parameters["chimera_echo_level"].GetInt()
else:
chimera_echo_lvl = fluid_parameters["echo_level"].GetInt()
reformulate_every_step = False
if chimera_parameters.Has("reformulate_chimera_every_step"):
reformulate_every_step = chimera_parameters[
"reformulate_chimera_every_step"].GetBool()
# Extracting the chimera_parts. this is required for ApplyChimera process.
if chimera_parameters.Has("chimera_parts"):
chimera_levels = chimera_parameters["chimera_parts"].Clone()
else:
raise Exception(
"The \"solver_settings\" should have the entry \"chimera_parts\" ")
main_model_part = model[fluid_parameters["model_part_name"].GetString()]
domain_size = main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]
solver_type = fluid_parameters["solver_type"].GetString()
# Creating the necessary variant of the apply chimera process.
if domain_size == 2:
if (solver_type == "Monolithic" or solver_type == "monolithic"):
chimera_process = KratosChimera.ApplyChimeraProcessMonolithic2d(
main_model_part, chimera_levels)
elif (solver_type == "fractional_step"
or solver_type == "FractionalStep"):
chimera_process = KratosChimera.ApplyChimeraProcessFractionalStep2d(
main_model_part, chimera_levels)
else:
if (solver_type == "Monolithic" or solver_type == "monolithic"):
chimera_process = KratosChimera.ApplyChimeraProcessMonolithic3d(
main_model_part, chimera_levels)
elif (solver_type == "fractional_step"
or solver_type == "FractionalStep"):
chimera_process = KratosChimera.ApplyChimeraProcessFractionalStep3d(
main_model_part, chimera_levels)
chimera_process.SetEchoLevel(chimera_echo_lvl)
chimera_process.SetReformulateEveryStep(reformulate_every_step)
return chimera_process
def _CreateBuilderAndSolver(self):
linear_solver = self._GetLinearSolver()
if self.settings["consider_periodic_conditions"].GetBool():
KratosMultiphysics.Logger.PrintInfo(
"NavierStokesSolverMonolithicForChimera Periodic conditions are not implemented in this case ."
)
raise NotImplementedError
else:
builder_and_solver = KratosChimera.ResidualBasedBlockBuilderAndSolverWithConstraintsForChimera(
linear_solver)
return builder_and_solver
def __init__(self, Model, settings):
""" The default constructor of the class
Keyword arguments:
self -- It signifies an instance of a class.
Model -- the container of the different model parts.
settings -- Kratos parameters containing solver settings.
"""
KratosMultiphysics.Process.__init__(self)
# settings for inlet with interface between fluids and separate velocities
default_settings = KratosMultiphysics.Parameters("""
{
"model_part_name":"",
"center_of_rotation":[0.0,0.0,0.0],
"calculate_torque":false,
"torque_model_part_name":"",
"moment_of_inertia":0.0,
"rotational_damping":0.0,
"angular_velocity_radians":0.0,
"axis_of_rotation":[0.0,0.0,0.0],
"is_ale" : false,
"interval": [0.0, 1e30]
}
""")
# Assign this here since it will change the "interval" prior to validation
self.interval = KratosMultiphysics.IntervalUtility(settings)
# compare against the appropriate default settings
settings.ValidateAndAssignDefaults(default_settings)
# checking for empty model part name
if (settings["model_part_name"].GetString() == ""):
raise Exception(
"ApplyRotateRegionProcess: A value (string) for the entry 'model_part_name' must be given in the parameters of the process."
)
# Get the modelpart to rotate
self.model_part = Model[settings["model_part_name"].GetString()]
if (settings["axis_of_rotation"].IsVector()):
axis_of_rotation = settings["axis_of_rotation"].GetVector()
if (axis_of_rotation[0] == 0.0 and axis_of_rotation[1] == 0.0
and axis_of_rotation[2] == 0.0):
raise Exception(
"The values (vector) of the entry 'axis_of_rotation' are all zero. This is not admissible."
)
if (settings["calculate_torque"].GetBool()
and settings["angular_velocity_radians"].GetDouble() != 0.0):
raise Exception(
"'calculate_torque' is set to true and 'angular_velocity_radians' is not zero. This is not admissible."
)
if (settings["calculate_torque"].GetBool()
and settings["moment_of_inertia"].GetDouble() == 0.0):
KratosMultiphysics.Logger.PrintWarning(
"RotateRegionProcess", " 'moment_of_inertia' is zero !!")
if (settings["calculate_torque"].GetBool()
and settings["rotational_damping"].GetDouble() == 0.0):
KratosMultiphysics.Logger.PrintWarning(
"RotateRegionProcess", " 'rotational_damping' is zero !!")
# If no torque_model_part_name is specified remove it to avoid later problems
if (settings["torque_model_part_name"].GetString() == ""):
settings.RemoveValue("torque_model_part_name")
settings.RemoveValue("interval")
# Making the actual process
self.rotate_region_process = KratosChimera.RotateRegionProcess(
self.model_part, settings)
def Initialize(self):
self.chimera_process = chimera_setup_utils.GetApplyChimeraProcess(
self.model, self.chimera_settings, self.settings)
self.computing_model_part = self.main_model_part
# 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(
)
# Creating the solution strategy
self.conv_criteria = KratosCFD.VelPrCriteria(
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 time integration 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 = KratosMultiphysics.ResidualBasedIncrementalUpdateStaticSchemeSlip(
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, the BDF time discretization utility is required to update the BDF coefficients
if (self.settings["time_scheme"].GetString() == "bdf2"):
time_order = 2
self.time_discretization = KratosMultiphysics.TimeDiscretization.BDF(
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 not hasattr(self, "_turbulence_model_solver"):
# Bossak time integration scheme
if self.settings["time_scheme"].GetString() == "bossak":
if self.settings["consider_periodic_conditions"].GetBool(
) == True:
self.time_scheme = KratosCFD.ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent(
self.settings["alpha"].GetDouble(),
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE],
KratosCFD.PATCH_INDEX)
else:
self.time_scheme = KratosCFD.ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent(
self.settings["alpha"].GetDouble(),
self.settings["move_mesh_strategy"].GetInt(),
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE])
# BDF2 time integration scheme
elif self.settings["time_scheme"].GetString() == "bdf2":
self.time_scheme = KratosCFD.GearScheme()
# Time scheme for steady state fluid solver
elif self.settings["time_scheme"].GetString() == "steady":
self.time_scheme = KratosCFD.ResidualBasedSimpleSteadyScheme(
self.settings["velocity_relaxation"].GetDouble(),
self.settings["pressure_relaxation"].GetDouble(),
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE])
else:
err_msg = "Requested time scheme " + self.settings[
"time_scheme"].GetString() + " is not available.\n"
err_msg += "Available options are: \"bossak\", \"bdf2\" and \"steady\""
raise Exception(err_msg)
else:
KratosMultiphysics.Logger.PrintInfo(
"NavierStokesSolverMonolithicForChimera turbulent solver is not possible."
)
raise NotImplementedError
if self.settings["consider_periodic_conditions"].GetBool() == True:
KratosMultiphysics.Logger.PrintInfo(
"NavierStokesSolverMonolithicForChimera Periodic conditions are not implemented in this case ."
)
raise NotImplementedError
else:
builder_and_solver = KratosChimera.ResidualBasedBlockBuilderAndSolverWithConstraintsForChimera(
self.linear_solver)
self.solver = KratosMultiphysics.ResidualBasedNewtonRaphsonStrategy(
self.computing_model_part, self.time_scheme, self.linear_solver,
self.conv_criteria, 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()
self.solver.Check()
KratosMultiphysics.Logger.PrintInfo(
"NavierStokesSolverMonolithicChimera",
"Solver initialization finished.")
chimera_setup_utils.SetChimeraInternalPartsFlag(
self.model, self.chimera_internal_parts)