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)