Ifpack2_Details_OverlappingRowGraph_def.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_OVERLAPPINGROWGRAPH_DEF_HPP
#define IFPACK2_OVERLAPPINGROWGRAPH_DEF_HPP
 
#include <Ifpack2_Details_OverlappingRowGraph_decl.hpp>
#include <Tpetra_Import.hpp>
#include <Tpetra_Export.hpp>
 
 
namespace Ifpack2 {
namespace Details {
 
template<class GraphType>
OverlappingRowGraph<GraphType>::
OverlappingRowGraph (const Teuchos::RCP<const row_graph_type>& nonoverlappingGraph,
                     const Teuchos::RCP<const row_graph_type>& overlappingGraph,
                     const Teuchos::RCP<const map_type>& rowMap,
                     const Teuchos::RCP<const map_type>& colMap,
                     const Tpetra::global_size_t numGlobalRows,
                     const Tpetra::global_size_t numGlobalCols,
                     const Tpetra::global_size_t numGlobalNonzeros,
                     const size_t maxNumEntries,
                     const Teuchos::RCP<const import_type>& nonoverlappingImporter,
                     const Teuchos::RCP<const import_type>& overlappingImporter) :
  nonoverlappingGraph_ (nonoverlappingGraph),
  overlappingGraph_ (overlappingGraph),
  rowMap_ (rowMap),
  colMap_ (colMap),
  numGlobalRows_ (numGlobalRows),
  numGlobalCols_ (numGlobalCols),
  numGlobalNonzeros_ (numGlobalNonzeros),
  maxNumEntries_ (maxNumEntries),
  nonoverlappingImporter_ (nonoverlappingImporter),
  overlappingImporter_ (overlappingImporter)
{}
 
 
template<class GraphType>
OverlappingRowGraph<GraphType>::~OverlappingRowGraph() {}
 
 
template<class GraphType>
Teuchos::RCP<const Teuchos::Comm<int> > 
OverlappingRowGraph<GraphType>::getComm () const
{
  return nonoverlappingGraph_->getComm ();
}
  
 
  
 
template<class GraphType>
Teuchos::RCP<const Tpetra::Map<typename GraphType::local_ordinal_type, typename GraphType::global_ordinal_type, typename GraphType::node_type> > 
OverlappingRowGraph<GraphType>::getRowMap () const
{
  return rowMap_;
}
  
 
template<class GraphType>
Teuchos::RCP<const Tpetra::Map<typename GraphType::local_ordinal_type, typename GraphType::global_ordinal_type, typename GraphType::node_type> > 
OverlappingRowGraph<GraphType>::getColMap () const
{
  return colMap_;
}
 
 
template<class GraphType>
Teuchos::RCP<const Tpetra::Map<typename GraphType::local_ordinal_type, typename GraphType::global_ordinal_type, typename GraphType::node_type> > 
OverlappingRowGraph<GraphType>::getDomainMap () const
{
  return nonoverlappingGraph_->getDomainMap ();
}
 
 
template<class GraphType>
Teuchos::RCP<const Tpetra::Map<typename GraphType::local_ordinal_type, typename GraphType::global_ordinal_type, typename GraphType::node_type> >
OverlappingRowGraph<GraphType>::getRangeMap () const
{
  return nonoverlappingGraph_->getRangeMap ();
}
 
 
template<class GraphType>
Teuchos::RCP<const Tpetra::Import<typename GraphType::local_ordinal_type, typename GraphType::global_ordinal_type, typename GraphType::node_type> >
OverlappingRowGraph<GraphType>::getImporter () const
{
  return nonoverlappingImporter_;
}
 
 
template<class GraphType>
Teuchos::RCP<const Tpetra::Export<typename GraphType::local_ordinal_type, typename GraphType::global_ordinal_type, typename GraphType::node_type> >
OverlappingRowGraph<GraphType>::getExporter () const
{
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}
  
 
template<class GraphType>
global_size_t OverlappingRowGraph<GraphType>::getGlobalNumRows () const
{
  return numGlobalRows_;
}
  
 
template<class GraphType>
global_size_t OverlappingRowGraph<GraphType>::getGlobalNumCols () const
{
  return numGlobalCols_;
}
  
 
template<class GraphType>
size_t OverlappingRowGraph<GraphType>::getLocalNumRows () const
{
  return nonoverlappingGraph_->getLocalNumRows () + 
    overlappingGraph_->getLocalNumRows ();
}
  
 
template<class GraphType>
size_t OverlappingRowGraph<GraphType>::getLocalNumCols () const
{
  return this->getLocalNumRows ();
}
  
 
template<class GraphType>
typename GraphType::global_ordinal_type 
OverlappingRowGraph<GraphType>::getIndexBase () const
{
  return nonoverlappingGraph_->getIndexBase ();
}
  
 
template<class GraphType>
Tpetra::global_size_t OverlappingRowGraph<GraphType>::getGlobalNumEntries () const
{
  return numGlobalNonzeros_;
}
  
 
template<class GraphType>
size_t OverlappingRowGraph<GraphType>::getLocalNumEntries () const
{
  return nonoverlappingGraph_->getLocalNumEntries () + 
    overlappingGraph_->getLocalNumEntries ();
}
  
 
template<class GraphType>
size_t
OverlappingRowGraph<GraphType>::
getNumEntriesInGlobalRow (global_ordinal_type globalRow) const
{
  const local_ordinal_type localRow = rowMap_->getLocalElement (globalRow);
  if (localRow == Teuchos::OrdinalTraits<local_ordinal_type>::invalid ()) {
    return Teuchos::OrdinalTraits<size_t>::invalid();
  } else {
    return getNumEntriesInLocalRow (localRow);
  }
}
 
  
template<class GraphType>
size_t
OverlappingRowGraph<GraphType>::
getNumEntriesInLocalRow (local_ordinal_type localRow) const
{
  using Teuchos::as;
  const size_t numMyRowsA = nonoverlappingGraph_->getLocalNumRows ();
  if (as<size_t> (localRow) < numMyRowsA) {
    return nonoverlappingGraph_->getNumEntriesInLocalRow (localRow);
  } else {
    return overlappingGraph_->getNumEntriesInLocalRow (as<local_ordinal_type> (localRow - numMyRowsA));
  }
}
  
 
template<class GraphType>
size_t OverlappingRowGraph<GraphType>::getGlobalMaxNumRowEntries () const
{
  throw std::runtime_error("Ifpack2::OverlappingRowGraph::getGlobalMaxNumRowEntries() not supported.");
}
  
 
template<class GraphType>
size_t OverlappingRowGraph<GraphType>::getLocalMaxNumRowEntries () const
{
  return maxNumEntries_;
}
  
 
template<class GraphType>
bool OverlappingRowGraph<GraphType>::hasColMap () const
{
  return true;
}
  
 
template<class GraphType>
bool OverlappingRowGraph<GraphType>::isLocallyIndexed () const
{
  return true;
}
   
 
template<class GraphType>
bool OverlappingRowGraph<GraphType>::isGloballyIndexed () const
{
  return false;
}
  
 
template<class GraphType>
bool OverlappingRowGraph<GraphType>::isFillComplete () const
{
  return true;
}
 
template<class GraphType>
void
OverlappingRowGraph<GraphType>::
  getGlobalRowCopy (global_ordinal_type globalRow,
                    nonconst_global_inds_host_view_type& indices,
                    size_t& numIndices) const
{
  const local_ordinal_type localRow = rowMap_->getLocalElement (globalRow);
  if (localRow == Teuchos::OrdinalTraits<local_ordinal_type>::invalid ()) {
    numIndices = Teuchos::OrdinalTraits<size_t>::invalid ();
  } else {
    if (Teuchos::as<size_t> (localRow) < nonoverlappingGraph_->getLocalNumRows ()) {
      nonoverlappingGraph_->getGlobalRowCopy (globalRow, indices, numIndices);
    } else {
      overlappingGraph_->getGlobalRowCopy (globalRow, indices, numIndices);
    }
  }
}
 
 
template<class GraphType>
void
OverlappingRowGraph<GraphType>::
getLocalRowCopy (local_ordinal_type localRow,
                 nonconst_local_inds_host_view_type& indices,
                 size_t& numIndices) const
{
  using Teuchos::as;
  const size_t numMyRowsA = nonoverlappingGraph_->getLocalNumRows ();
  if (as<size_t> (localRow) < numMyRowsA) {
    nonoverlappingGraph_->getLocalRowCopy (localRow, indices, numIndices);
  } else {
    const local_ordinal_type localRowOffset = 
      localRow - as<local_ordinal_type> (numMyRowsA);
    overlappingGraph_->getLocalRowCopy (localRowOffset, indices, numIndices);
  }
}
 
 
template<class GraphType>
void
OverlappingRowGraph<GraphType>::
getGlobalRowView (global_ordinal_type GlobalRow,
                  global_inds_host_view_type &indices) const {
  const local_ordinal_type LocalRow = rowMap_->getLocalElement (GlobalRow);
  if (LocalRow == Teuchos::OrdinalTraits<local_ordinal_type>::invalid())  {
    indices = global_inds_host_view_type();
  } else {
    if (Teuchos::as<size_t> (LocalRow) < nonoverlappingGraph_->getLocalNumRows ()) {
      nonoverlappingGraph_->getGlobalRowView (GlobalRow, indices);
    } else {
      overlappingGraph_->getGlobalRowView (GlobalRow, indices);
    }
  }
}
 
 
template<class GraphType>
void
OverlappingRowGraph<GraphType>::
  getLocalRowView (local_ordinal_type LocalRow,
                   local_inds_host_view_type & indices) const {
  using Teuchos::as;
  const size_t numMyRowsA = nonoverlappingGraph_->getLocalNumRows ();
  if (as<size_t> (LocalRow) < numMyRowsA) {
    nonoverlappingGraph_->getLocalRowView (LocalRow, indices);
  } else {
    overlappingGraph_->getLocalRowView (LocalRow - as<local_ordinal_type> (numMyRowsA),
                                 indices);
  }
 
}
 
 
} // namespace Details
} // namespace Ifpack2
 
#define IFPACK2_DETAILS_OVERLAPPINGROWGRAPH_INSTANT(LO,GO,N) \
  template class Ifpack2::Details::OverlappingRowGraph<Tpetra::CrsGraph< LO, GO, N > >; \
  template class Ifpack2::Details::OverlappingRowGraph<Tpetra::RowGraph< LO, GO, N > >;
 
#endif // IFPACK2_OVERLAPPINGROWGRAPH_DEF_HPP