psblas_precondition.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2008 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_psblas_precondition_h
#define dealii_psblas_precondition_h
 
#include <deal.II/lac/psblas_sparse_matrix.h>
#include <deal.II/lac/psblas_vector.h>
 
 
#ifdef DEAL_II_WITH_AMG4PSBLAS
 
#  include <amg_cbind.h>
#endif
 
DEAL_II_NAMESPACE_OPEN
 
#ifdef DEAL_II_WITH_AMG4PSBLAS
namespace PSCToolkitWrappers
{
 
  class PreconditionAMG : public EnableObserverPointer
  {
  public:
    using size_type = ::types::global_dof_index;
 
    struct AdditionalData
    {
      explicit AdditionalData(const char        *cycle_type = "VCYCLE",
                              const unsigned int n_cycles   = 1,
                              const double       aggregation_threshold = 1e-2,
                              const char        *aggregation_type      = "SOC1",
                              const unsigned int aggregation_size      = 8,
                              const char        *smoother_type         = "FBGS",
                              const unsigned int smoother_sweeps       = 2,
                              const char        *aggr_prol        = "SMOOTHED",
                              const char        *aggr_filter      = "FILTER",
                              const char *parallel_aggr_algorithm = "DECOUPLED",
                              const char *coarse_type             = "BJAC",
                              const char *coarse_mat_type         = "DIST",
                              const bool  output_details          = false)
        : cycle_type(cycle_type)
        , n_cycles(n_cycles)
        , aggregation_threshold(aggregation_threshold)
        , aggregation_type(strdup(aggregation_type))
        , aggregation_size(aggregation_size)
        , smoother_type(smoother_type)
        , smoother_sweeps(smoother_sweeps)
        , aggr_prol(aggr_prol)
        , aggr_filter(aggr_filter)
        , parallel_aggr_algorithm(parallel_aggr_algorithm)
        , coarse_type(coarse_type)
        , coarse_mat_type(coarse_mat_type)
        , output_details(output_details)
      {}
 
 
      const char *cycle_type;
 
      /*
       * Number of multilevel cycles to be performed.
       */
      unsigned int n_cycles;
 
      double aggregation_threshold;
 
      const char *aggregation_type;
 
      unsigned int aggregation_size;
 
      const char *smoother_type;
 
      unsigned int smoother_sweeps;
 
      const char *aggr_prol;
 
      const char *aggr_filter;
 
      const char *parallel_aggr_algorithm;
 
      const char *coarse_type;
 
      const char *coarse_mat_type;
 
      bool output_details;
    };
 
    PreconditionAMG();
 
    ~PreconditionAMG();
 
    void
    initialize(const SparseMatrix   &matrix,
               const AdditionalData &additional_data = AdditionalData());
 
    void
    clear();
 
    amg_c_dprec *
    get_psblas_preconditioner();
 
    void
    vmult(Vector &dst, const Vector &src) const;
 
    void
    Tvmult(Vector &dst, const Vector &src) const;
 
 
    friend class SolverBase;
 
  private:
    amg_c_dprec *psblas_preconditioner;
 
    std::shared_ptr<psb_c_descriptor> psblas_descriptor;
  };
 
} // namespace PSCToolkitWrappers
 
#endif
 
DEAL_II_NAMESPACE_CLOSE
 
#endif