コード例 #1
0
    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())

        if self._IsPrintingRank():
            KratosMultiphysics.Logger.PrintInfo(self.__class__.__name__,"Monolithic MPI solver initialization finished.")
コード例 #2
0
 def _create_linear_strategy(self):
     computing_model_part = self.GetComputingModelPart()
     mechanical_scheme = self.get_solution_scheme()
     linear_solver = self.get_linear_solver()
     builder_and_solver = self.get_builder_and_solver()
     return TrilinosApplication.TrilinosLinearStrategy(
         computing_model_part, mechanical_scheme, linear_solver,
         builder_and_solver, self.settings["compute_reactions"].GetBool(),
         self.settings["reform_dofs_at_each_step"].GetBool(), False,
         self.settings["move_mesh_flag"].GetBool())
コード例 #3
0
 def _CreateSolutionStrategy(self):
     computing_model_part = self.GetComputingModelPart()
     time_scheme = self._GetScheme()
     linear_solver = self._GetLinearSolver()
     builder_and_solver = self._GetBuilderAndSolver()
     calculate_reaction_flag = False
     reform_dof_set_at_each_step = False
     calculate_norm_dx_flag = False
     move_mesh_flag = False
     return TrilinosApplication.TrilinosLinearStrategy(
         computing_model_part, time_scheme, linear_solver,
         builder_and_solver, calculate_reaction_flag,
         reform_dof_set_at_each_step, calculate_norm_dx_flag,
         move_mesh_flag)
コード例 #4
0
    def Initialize(self):

        self.epetra_comm = TrilinosApplication.CreateCommunicator()

        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 = AdjointFluidApplication.DragResponseFunction2D(
                    self.main_model_part,
                    self.settings["response_function_settings"])
            elif (domain_size == 3):
                self.response_function = AdjointFluidApplication.DragResponseFunction3D(
                    self.main_model_part,
                    self.settings["response_function_settings"])
            else:
                raise Exception("Invalid DOMAIN_SIZE: " + str(domain_size))
        else:
            raise Exception("invalid response_type: " +
                            self.settings["response_function_settings"]
                            ["response_type"].GetString())

        if self.settings["scheme_settings"]["scheme_type"].GetString(
        ) == "bossak":
            self.time_scheme = TrilinosApplication.TrilinosAdjointBossakScheme(
                self.settings["scheme_settings"], self.response_function)
        elif self.settings["scheme_settings"]["scheme_type"].GetString(
        ) == "steady":
            self.time_scheme = TrilinosApplication.TrilinosAdjointSteadyScheme(
                self.settings["scheme_settings"], 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.epetra_comm, 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.Check()

        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())

        print("Monolithic MPI solver initialization finished.")