petsc_precondition.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2004 - 2021 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_petsc_precondition_h
#  define dealii_petsc_precondition_h
 
 
#  include <deal.II/base/config.h>
 
#  include <deal.II/base/subscriptor.h>
 
#  ifdef DEAL_II_WITH_PETSC
 
#    include <deal.II/lac/exceptions.h>
 
#    include <petscpc.h>
 
DEAL_II_NAMESPACE_OPEN
 
 
 
namespace PETScWrappers
{
  // forward declarations
#    ifndef DOXYGEN
  class MatrixBase;
  class VectorBase;
  class SolverBase;
#    endif
 
  class PreconditionBase : public Subscriptor
  {
  public:
    PreconditionBase();
 
    virtual ~PreconditionBase();
 
    void
    clear();
 
    void
    vmult(VectorBase &dst, const VectorBase &src) const;
 
    void
    Tvmult(VectorBase &dst, const VectorBase &src) const;
 
 
    const PC &
    get_pc() const;
 
  protected:
    PC pc;
 
    Mat matrix;
 
    void
    create_pc();
 
    operator Mat() const;
 
    // Make the solver class a friend, since it needs to call the conversion
    // operator.
    friend class SolverBase;
  };
 
 
 
  class PreconditionJacobi : public PreconditionBase
  {
  public:
    struct AdditionalData
    {};
 
    PreconditionJacobi() = default;
 
 
    PreconditionJacobi(
      const MatrixBase &    matrix,
      const AdditionalData &additional_data = AdditionalData());
 
    PreconditionJacobi(
      const MPI_Comm &      communicator,
      const AdditionalData &additional_data = AdditionalData());
 
    void
    initialize(const MatrixBase &    matrix,
               const AdditionalData &additional_data = AdditionalData());
 
  protected:
    AdditionalData additional_data;
 
    void
    initialize();
  };
 
 
 
  class PreconditionBlockJacobi : public PreconditionBase
  {
  public:
    struct AdditionalData
    {};
 
    PreconditionBlockJacobi() = default;
 
    PreconditionBlockJacobi(
      const MatrixBase &    matrix,
      const AdditionalData &additional_data = AdditionalData());
 
    PreconditionBlockJacobi(
      const MPI_Comm &      communicator,
      const AdditionalData &additional_data = AdditionalData());
 
 
    void
    initialize(const MatrixBase &    matrix,
               const AdditionalData &additional_data = AdditionalData());
 
  protected:
    AdditionalData additional_data;
 
    void
    initialize();
  };
 
 
 
  class PreconditionSOR : public PreconditionBase
  {
  public:
    struct AdditionalData
    {
      AdditionalData(const double omega = 1);
 
      double omega;
    };
 
    PreconditionSOR() = default;
 
    PreconditionSOR(const MatrixBase &    matrix,
                    const AdditionalData &additional_data = AdditionalData());
 
    void
    initialize(const MatrixBase &    matrix,
               const AdditionalData &additional_data = AdditionalData());
 
  protected:
    AdditionalData additional_data;
  };
 
 
 
  class PreconditionSSOR : public PreconditionBase
  {
  public:
    struct AdditionalData
    {
      AdditionalData(const double omega = 1);
 
      double omega;
    };
 
    PreconditionSSOR() = default;
 
    PreconditionSSOR(const MatrixBase &    matrix,
                     const AdditionalData &additional_data = AdditionalData());
 
    void
    initialize(const MatrixBase &    matrix,
               const AdditionalData &additional_data = AdditionalData());
 
  protected:
    AdditionalData additional_data;
  };
 
  class PreconditionICC : public PreconditionBase
  {
  public:
    struct AdditionalData
    {
      AdditionalData(const unsigned int levels = 0);
 
      unsigned int levels;
    };
 
    PreconditionICC() = default;
 
    PreconditionICC(const MatrixBase &    matrix,
                    const AdditionalData &additional_data = AdditionalData());
 
    void
    initialize(const MatrixBase &    matrix,
               const AdditionalData &additional_data = AdditionalData());
 
  protected:
    AdditionalData additional_data;
  };
 
 
 
  class PreconditionILU : public PreconditionBase
  {
  public:
    struct AdditionalData
    {
      AdditionalData(const unsigned int levels = 0);
 
      unsigned int levels;
    };
 
    PreconditionILU() = default;
 
    PreconditionILU(const MatrixBase &    matrix,
                    const AdditionalData &additional_data = AdditionalData());
 
    void
    initialize(const MatrixBase &    matrix,
               const AdditionalData &additional_data = AdditionalData());
 
  protected:
    AdditionalData additional_data;
  };
 
 
 
  class PreconditionLU : public PreconditionBase
  {
  public:
    struct AdditionalData
    {
      AdditionalData(const double pivoting   = 1.e-6,
                     const double zero_pivot = 1.e-12,
                     const double damping    = 0.0);
 
      double pivoting;
 
      double zero_pivot;
 
      double damping;
    };
 
    PreconditionLU() = default;
 
    PreconditionLU(const MatrixBase &    matrix,
                   const AdditionalData &additional_data = AdditionalData());
 
    void
    initialize(const MatrixBase &    matrix,
               const AdditionalData &additional_data = AdditionalData());
 
  protected:
    AdditionalData additional_data;
  };
 
 
 
  class PreconditionBoomerAMG : public PreconditionBase
  {
  public:
    struct AdditionalData
    {
      enum class RelaxationType
      {
        Jacobi,
        sequentialGaussSeidel,
        seqboundaryGaussSeidel,
        SORJacobi,
        backwardSORJacobi,
        symmetricSORJacobi,
        l1scaledSORJacobi,
        GaussianElimination,
        l1GaussSeidel,
        backwardl1GaussSeidel,
        CG,
        Chebyshev,
        FCFJacobi,
        l1scaledJacobi,
        None
      };
 
      AdditionalData(
        const bool           symmetric_operator               = false,
        const double         strong_threshold                 = 0.25,
        const double         max_row_sum                      = 0.9,
        const unsigned int   aggressive_coarsening_num_levels = 0,
        const bool           output_details                   = false,
        const RelaxationType relaxation_type_up   = RelaxationType::SORJacobi,
        const RelaxationType relaxation_type_down = RelaxationType::SORJacobi,
        const RelaxationType relaxation_type_coarse =
          RelaxationType::GaussianElimination,
        const unsigned int n_sweeps_coarse = 1,
        const double       tol             = 0.0,
        const unsigned int max_iter        = 1,
        const bool         w_cycle         = false);
 
      bool symmetric_operator;
 
      double strong_threshold;
 
      double max_row_sum;
 
      unsigned int aggressive_coarsening_num_levels;
 
      bool output_details;
 
      RelaxationType relaxation_type_up;
 
      RelaxationType relaxation_type_down;
 
      RelaxationType relaxation_type_coarse;
 
      unsigned int n_sweeps_coarse;
 
      double tol;
 
      unsigned int max_iter;
 
      bool w_cycle;
    };
 
    PreconditionBoomerAMG() = default;
 
    PreconditionBoomerAMG(
      const MatrixBase &    matrix,
      const AdditionalData &additional_data = AdditionalData());
 
    PreconditionBoomerAMG(
      const MPI_Comm &      communicator,
      const AdditionalData &additional_data = AdditionalData());
 
 
    void
    initialize(const MatrixBase &    matrix,
               const AdditionalData &additional_data = AdditionalData());
 
  protected:
    AdditionalData additional_data;
 
    void
    initialize();
  };
 
 
 
  class PreconditionParaSails : public PreconditionBase
  {
  public:
    struct AdditionalData
    {
      AdditionalData(const unsigned int symmetric      = 1,
                     const unsigned int n_levels       = 1,
                     const double       threshold      = 0.1,
                     const double       filter         = 0.05,
                     const bool         output_details = false);
 
      unsigned int symmetric;
 
      unsigned int n_levels;
 
      double threshold;
 
      double filter;
 
      bool output_details;
    };
 
 
 
    PreconditionParaSails() = default;
 
    PreconditionParaSails(
      const MatrixBase &    matrix,
      const AdditionalData &additional_data = AdditionalData());
 
    void
    initialize(const MatrixBase &    matrix,
               const AdditionalData &additional_data = AdditionalData());
 
  private:
    AdditionalData additional_data;
  };
 
 
 
  class PreconditionNone : public PreconditionBase
  {
  public:
    struct AdditionalData
    {};
 
    PreconditionNone() = default;
 
    PreconditionNone(const MatrixBase &    matrix,
                     const AdditionalData &additional_data = AdditionalData());
 
    void
    initialize(const MatrixBase &    matrix,
               const AdditionalData &additional_data = AdditionalData());
 
  private:
    AdditionalData additional_data;
  };
 
  using PreconditionerBase DEAL_II_DEPRECATED = PreconditionBase;
} // namespace PETScWrappers
 
 
 
DEAL_II_NAMESPACE_CLOSE
 
 
#  endif // DEAL_II_WITH_PETSC
 
#endif
/*--------------------------- petsc_precondition.h --------------------------*/