preconditioner_factory.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <deal.II/base/exceptions.h>
 
#include <deal.II/lac/trilinos_precondition.h>
 
#include "meltpooldg/core/scratch_data.hpp"
#include <meltpooldg/linear_algebra/linear_solver_data.hpp>
#include <meltpooldg/linear_algebra/preconditioner.hpp>
#include <meltpooldg/linear_algebra/preconditioner_jacobi.hpp>
#include <meltpooldg/linear_algebra/preconditioner_trilinos_wrapper.hpp>
 
namespace MeltPoolDG
{
  template <int dim, typename number, typename OperatorType, typename VectorType>
  Preconditioner<dim, VectorType, number>
  make_preconditioner(const PreconditionerType            &preconditioner_type,
                      const OperatorType                  *operator_in,
                      const ScratchData<dim, dim, number> &scratch_data,
                      const unsigned                       dof_idx,
                      const bool                           do_matrix_free = true)
  {
    switch (preconditioner_type)
      {
          case PreconditionerType::Identity: {
            return Preconditioner<dim, VectorType, number>(
              IdentityPreconditioner<dim, VectorType, number>());
          }
          case PreconditionerType::AMG: {
            return Preconditioner<dim, VectorType, number>(
              DealiiPreconditionerWrapper<dim,
                                          number,
                                          VectorType,
                                          dealii::TrilinosWrappers::PreconditionAMG,
                                          OperatorType>(
                operator_in, scratch_data, dof_idx, do_matrix_free));
          }
          case PreconditionerType::ILU: {
            return Preconditioner<dim, VectorType, number>(
              DealiiPreconditionerWrapper<dim,
                                          number,
                                          VectorType,
                                          dealii::TrilinosWrappers::PreconditionILU,
                                          OperatorType>(
                operator_in, scratch_data, dof_idx, do_matrix_free));
          }
          case PreconditionerType::Diagonal: {
            if constexpr (JacobiPreconditionerOperatorType<OperatorType, VectorType>)
              {
                if (do_matrix_free)
                  {
                    return Preconditioner<dim, VectorType, number>(
                      JacobiPreconditioner<dim, number, VectorType, OperatorType>(*operator_in,
                                                                                  scratch_data,
                                                                                  dof_idx));
                  }
              }
            return Preconditioner<dim, VectorType, number>(
              DealiiPreconditionerWrapper<dim,
                                          number,
                                          VectorType,
                                          dealii::TrilinosWrappers::PreconditionJacobi,
                                          OperatorType>(operator_in, scratch_data, dof_idx, false));
          }
          default: {
            AssertThrow(false,
                        dealii::ExcMessage("The requested preconditioner type is not"
                                           " implemented."));
          }
      }
  }
} // namespace MeltPoolDG