MueLu_ScalarDroppingClassical_def.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//        MueLu: A package for multigrid based preconditioning
//
// Copyright 2012 NTESS and the MueLu contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef MUELU_SCALARDROPPINGCLASSICAL_DEF_HPP
#define MUELU_SCALARDROPPINGCLASSICAL_DEF_HPP
 
#include "MueLu_ScalarDroppingClassical_decl.hpp"
 
namespace MueLu {
 
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node, Misc::StrengthMeasure SoC>
void ScalarDroppingClassical<Scalar, LocalOrdinal, GlobalOrdinal, Node, SoC>::runDroppingFunctors_on_A(matrix_type& A,
                                                                                                       results_view& results,
                                                                                                       rowptr_type& filtered_rowptr,
                                                                                                       LocalOrdinal& nnz_filtered,
                                                                                                       boundary_nodes_type& boundaryNodes,
                                                                                                       const std::string& droppingMethod,
                                                                                                       const magnitudeType threshold,
                                                                                                       const bool aggregationMayCreateDirichlet,
                                                                                                       const bool symmetrizeDroppedGraph,
                                                                                                       const bool useBlocking,
                                                                                                       Level& level,
                                                                                                       const Factory& factory) {
  auto lclA               = A.getLocalMatrixDevice();
  auto preserve_diagonals = Misc::KeepDiagonalFunctor(lclA, results);
 
  if (droppingMethod == "point-wise") {
    auto dropping = ClassicalDropping::make_drop_functor<SoC>(A, threshold, results);
 
    if (aggregationMayCreateDirichlet) {
      auto mark_singletons_as_boundary = Misc::MarkSingletonFunctor(lclA, boundaryNodes, results);
 
      if (symmetrizeDroppedGraph) {
        auto drop_boundaries = Misc::PointwiseSymmetricDropBoundaryFunctor(A, boundaryNodes, results);
        ScalarDroppingClassical::runDroppingFunctors(A, results, filtered_rowptr, nnz_filtered, useBlocking, level, factory,
                                                     dropping,
                                                     drop_boundaries,
                                                     preserve_diagonals,
                                                     mark_singletons_as_boundary);
      } else {
        auto drop_boundaries = Misc::PointwiseDropBoundaryFunctor(lclA, boundaryNodes, results);
        ScalarDroppingClassical::runDroppingFunctors(A, results, filtered_rowptr, nnz_filtered, useBlocking, level, factory,
                                                     dropping,
                                                     drop_boundaries,
                                                     preserve_diagonals,
                                                     mark_singletons_as_boundary);
      }
    } else {
      if (symmetrizeDroppedGraph) {
        auto drop_boundaries = Misc::PointwiseSymmetricDropBoundaryFunctor(A, boundaryNodes, results);
        ScalarDroppingClassical::runDroppingFunctors(A, results, filtered_rowptr, nnz_filtered, useBlocking, level, factory,
                                                     dropping,
                                                     drop_boundaries,
                                                     preserve_diagonals);
      } else {
        auto drop_boundaries = Misc::PointwiseDropBoundaryFunctor(lclA, boundaryNodes, results);
        ScalarDroppingClassical::runDroppingFunctors(A, results, filtered_rowptr, nnz_filtered, useBlocking, level, factory,
                                                     dropping,
                                                     drop_boundaries,
                                                     preserve_diagonals);
      }
    }
  } else if (droppingMethod == "cut-drop") {
    auto comparison = CutDrop::make_comparison_functor<SoC>(A, results);
    auto cut_drop   = CutDrop::CutDropFunctor(comparison, threshold);
 
    if (symmetrizeDroppedGraph) {
      auto drop_boundaries = Misc::PointwiseSymmetricDropBoundaryFunctor(A, boundaryNodes, results);
      ScalarDroppingClassical::runDroppingFunctors(A, results, filtered_rowptr, nnz_filtered, useBlocking, level, factory,
                                                   drop_boundaries,
                                                   preserve_diagonals,
                                                   cut_drop);
    } else {
      auto drop_boundaries = Misc::PointwiseDropBoundaryFunctor(lclA, boundaryNodes, results);
      ScalarDroppingClassical::runDroppingFunctors(A, results, filtered_rowptr, nnz_filtered, useBlocking, level, factory,
                                                   drop_boundaries,
                                                   preserve_diagonals,
                                                   cut_drop);
    }
  }
}
}  // namespace MueLu
 
#define MUELU_ETI_GROUP(SC, LO, GO, NO) \
  MUELU_ETI_SLGN_SoC(MueLu::ScalarDroppingClassical, SC, LO, GO, NO)
 
#endif