Ifpack2_CreateOverlapGraph.hpp

// @HEADER
// *****************************************************************************
//       Ifpack2: Templated Object-Oriented Algebraic Preconditioner Package
//
// Copyright 2009 NTESS and the Ifpack2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef IFPACK2_CREATEOVERLAPGRAPH_HPP
#define IFPACK2_CREATEOVERLAPGRAPH_HPP
 
#include "Ifpack2_ConfigDefs.hpp"
#include "Tpetra_CrsGraph.hpp"
#include "Tpetra_CrsMatrix.hpp"
#include "Tpetra_Import.hpp"
#include "Teuchos_RefCountPtr.hpp"
 
 
namespace Ifpack2 {

template<class GraphType>
Teuchos::RCP<const GraphType>
createOverlapGraph (const Teuchos::RCP<const GraphType>& inputGraph,
                    const int overlapLevel)
{
  using Teuchos::RCP;
  using Teuchos::rcp;
  typedef Tpetra::Map<typename GraphType::local_ordinal_type,
                      typename GraphType::global_ordinal_type,
                      typename GraphType::node_type> map_type;
  typedef Tpetra::Import<typename GraphType::local_ordinal_type,
                         typename GraphType::global_ordinal_type,
                         typename GraphType::node_type> import_type;
  TEUCHOS_TEST_FOR_EXCEPTION(
    overlapLevel < 0, std::invalid_argument,
    "Ifpack2::createOverlapGraph: overlapLevel must be >= 0, "
    "but you specified overlapLevel = " << overlapLevel << ".");
 
  const int numProcs = inputGraph->getMap ()->getComm ()->getSize ();
  if (overlapLevel == 0 || numProcs < 2) {
    return inputGraph;
  }
 
  RCP<const map_type> overlapRowMap = inputGraph->getRowMap ();
  RCP<const map_type> domainMap = inputGraph->getDomainMap ();
  RCP<const map_type> rangeMap = inputGraph->getRangeMap ();
 
  RCP<GraphType> overlapGraph;
  RCP<const GraphType> oldGraph;
  RCP<const map_type> oldRowMap;
  for (int level = 0; level < overlapLevel; ++level) {
    oldGraph = overlapGraph;
    oldRowMap = overlapRowMap;
 
    RCP<const import_type> overlapImporter;
    if (level == 0) {
      overlapImporter = inputGraph->getImporter ();
    } else {
      overlapImporter = oldGraph->getImporter ();
    }
 
    overlapRowMap = overlapImporter->getTargetMap ();
    if (level < overlapLevel - 1) {
      overlapGraph = rcp (new GraphType (overlapRowMap, 0));
    }
    else {
      // On last iteration, we want to filter out all columns except those that
      // correspond to rows in the graph.  This ensures that our graph is square
      overlapGraph = rcp (new GraphType (overlapRowMap, overlapRowMap, 0));
    }
 
    overlapGraph->doImport (*inputGraph, *overlapImporter, Tpetra::INSERT);
    overlapGraph->fillComplete (domainMap, rangeMap);
  }
 
  return overlapGraph;
}

template<class MatrixType>
Teuchos::RCP<const MatrixType>
createOverlapMatrix (const Teuchos::RCP<const MatrixType>& inputMatrix,
                     const int overlapLevel)
{
  using Teuchos::RCP;
  using Teuchos::rcp;
  typedef typename MatrixType::map_type map_type;
  typedef Tpetra::Import<typename MatrixType::local_ordinal_type,
    typename MatrixType::global_ordinal_type,
    typename MatrixType::node_type> import_type;
 
  TEUCHOS_TEST_FOR_EXCEPTION(
    overlapLevel < 0, std::invalid_argument,
    "Ifpack2::createOverlapMatrix: overlapLevel must be >= 0, "
    "but you specified overlapLevel = " << overlapLevel << ".");
 
  const int numProcs = inputMatrix->getMap ()->getComm ()->getSize ();
  if (overlapLevel == 0 || numProcs < 2) {
    return inputMatrix;
  }
 
  RCP<const map_type> overlapRowMap = inputMatrix->getRowMap ();
  RCP<const map_type> domainMap = inputMatrix->getDomainMap ();
  RCP<const map_type> rangeMap = inputMatrix->getRangeMap ();
 
  RCP<MatrixType> overlapMatrix;
  RCP<const MatrixType> oldMatrix;
  RCP<const map_type> oldRowMap;
  for (int level = 0; level < overlapLevel; ++level) {
    oldMatrix = overlapMatrix;
    oldRowMap = overlapRowMap;
 
    RCP<const import_type> overlapImporter;
    if (level == 0) {
      overlapImporter = inputMatrix->getGraph ()->getImporter ();
    } else {
      overlapImporter = oldMatrix->getGraph ()->getImporter ();
    }
 
    overlapRowMap = overlapImporter->getTargetMap ();
    if (level < overlapLevel - 1) {
      overlapMatrix = rcp (new MatrixType (overlapRowMap, 0));
    }
    else {
      // On last iteration, we want to filter out all columns except those that
      // correspond to rows in the matrix.  This assures that our matrix is square
      overlapMatrix = rcp (new MatrixType (overlapRowMap, overlapRowMap, 0));
    }
 
    overlapMatrix->doImport (*inputMatrix, *overlapImporter, Tpetra::INSERT);
    overlapMatrix->fillComplete (domainMap, rangeMap);
  }
 
  return overlapMatrix;
}
 
} // namespace Ifpack2
 
#endif // IFPACK2_CREATEOVERLAPGRAPH_HPP