amg_base.hpp

Go to the documentation of this file.

#ifndef VIENNACL_LINALG_DETAIL_AMG_AMG_BASE_HPP_
#define VIENNACL_LINALG_DETAIL_AMG_AMG_BASE_HPP_

/* =========================================================================
   Copyright (c) 2010-2015, Institute for Microelectronics,
                            Institute for Analysis and Scientific Computing,
                            TU Wien.
   Portions of this software are copyright by UChicago Argonne, LLC.

                            -----------------
                  ViennaCL - The Vienna Computing Library
                            -----------------

   Project Head:    Karl Rupp                   rupp@iue.tuwien.ac.at

   (A list of authors and contributors can be found in the manual)

   License:         MIT (X11), see file LICENSE in the base directory
============================================================================= */

#include <cmath>
#include <set>
#include <list>
#include <stdexcept>
#include <algorithm>

#include <map>
#ifdef VIENNACL_WITH_OPENMP
#include <omp.h>
#endif

#include "viennacl/context.hpp"

namespace viennacl
{
namespace linalg
{

enum amg_coarsening_method
{
  AMG_COARSENING_METHOD_ONEPASS = 1,
  AMG_COARSENING_METHOD_AGGREGATION,
  AMG_COARSENING_METHOD_MIS2_AGGREGATION
};

enum amg_interpolation_method
{
  AMG_INTERPOLATION_METHOD_DIRECT = 1,
  AMG_INTERPOLATION_METHOD_AGGREGATION,
  AMG_INTERPOLATION_METHOD_SMOOTHED_AGGREGATION
};


class amg_tag
{
public:
  amg_tag()
  : coarsening_method_(AMG_COARSENING_METHOD_MIS2_AGGREGATION), interpolation_method_(AMG_INTERPOLATION_METHOD_AGGREGATION),
    strong_connection_threshold_(0.1), jacobi_weight_(1.0),
    presmooth_steps_(2), postsmooth_steps_(2),
    coarse_levels_(0), coarse_cutoff_(50) {}

  // Getter-/Setter-Functions
  void set_coarsening_method(amg_coarsening_method s) { coarsening_method_ = s; }
  amg_coarsening_method get_coarsening_method() const { return coarsening_method_; }

  void set_interpolation_method(amg_interpolation_method interpol) { interpolation_method_ = interpol; }
  amg_interpolation_method get_interpolation_method() const { return interpolation_method_; }

  void set_strong_connection_threshold(double threshold) { if (threshold > 0) strong_connection_threshold_ = threshold; }
  double get_strong_connection_threshold() const { return strong_connection_threshold_; }

  void set_jacobi_weight(double w) { if (w > 0) jacobi_weight_ = w; }
  double get_jacobi_weight() const { return jacobi_weight_; }

  void set_presmooth_steps(vcl_size_t steps) { presmooth_steps_ = steps; }
  vcl_size_t get_presmooth_steps() const { return presmooth_steps_; }

  void set_postsmooth_steps(vcl_size_t steps) { postsmooth_steps_ = steps; }
  vcl_size_t get_postsmooth_steps() const { return postsmooth_steps_; }

  void set_coarse_levels(vcl_size_t levels)  { coarse_levels_ = levels; }
  vcl_size_t get_coarse_levels() const { return coarse_levels_; }

  void set_coarsening_cutoff(vcl_size_t size)  { coarse_cutoff_ = size; }
  vcl_size_t get_coarsening_cutoff() const { return coarse_cutoff_; }

  void set_setup_context(viennacl::context ctx)  { setup_ctx_ = ctx; }
  viennacl::context const & get_setup_context() const { return setup_ctx_; }

  void set_target_context(viennacl::context ctx)  { target_ctx_ = ctx; }
  viennacl::context const & get_target_context() const { return target_ctx_; }

private:
  amg_coarsening_method coarsening_method_;
  amg_interpolation_method interpolation_method_;
  double strong_connection_threshold_, jacobi_weight_;
  vcl_size_t presmooth_steps_, postsmooth_steps_, coarse_levels_, coarse_cutoff_;
  viennacl::context setup_ctx_, target_ctx_;
};


namespace detail
{
namespace amg
{


  struct amg_level_context
  {
    void resize(vcl_size_t num_points, vcl_size_t max_nnz)
    {
      influence_jumper_.resize(num_points + 1, false);
      influence_ids_.resize(max_nnz, false);
      influence_values_.resize(num_points, false);
      point_types_.resize(num_points, false);
      coarse_id_.resize(num_points, false);
    }

    void switch_context(viennacl::context ctx)
    {
      influence_jumper_.switch_memory_context(ctx);
      influence_ids_.switch_memory_context(ctx);
      influence_values_.switch_memory_context(ctx);
      point_types_.switch_memory_context(ctx);
      coarse_id_.switch_memory_context(ctx);
    }

    enum
    {
      POINT_TYPE_UNDECIDED = 0,
      POINT_TYPE_COARSE,
      POINT_TYPE_FINE
    } amg_point_types;

    viennacl::vector<unsigned int> influence_jumper_; // similar to row_buffer for CSR matrices
    viennacl::vector<unsigned int> influence_ids_;    // IDs of influencing points
    viennacl::vector<unsigned int> influence_values_; // Influence measure for each point
    viennacl::vector<unsigned int> point_types_;      // 0: undecided, 1: coarse point, 2: fine point. Using char here because type for enum might be a larger type
    viennacl::vector<unsigned int> coarse_id_;        // coarse ID used on the next level. Only valid for coarse points. Fine points may (ab)use their entry for something else.
    unsigned int num_coarse_;
  };


} //namespace amg
}
}
}

#endif