Tpetra_Details_determineLocalTriangularStructure.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//          Tpetra: Templated Linear Algebra Services Package
//
// Copyright 2008 NTESS and the Tpetra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef TPETRA_DETAILS_DETERMINELOCALTRIANGULARSTRUCTURE_HPP
#define TPETRA_DETAILS_DETERMINELOCALTRIANGULARSTRUCTURE_HPP

 
#include "Kokkos_Core.hpp"
#include "Tpetra_Details_OrdinalTraits.hpp"
 
namespace Tpetra {
namespace Details {

template <class LO>
struct LocalTriangularStructureResult {
  LO diagCount;
  LO maxNumRowEnt;
  bool couldBeLowerTriangular;
  bool couldBeUpperTriangular;
};
 
namespace Impl {
template <class LocalGraphType, class LocalMapType>
class DetermineLocalTriangularStructure {
 public:
  // Result can't be more than the number of local rows, so
  // local_ordinal_type is appropriate.
  using result_type =
      LocalTriangularStructureResult<typename LocalMapType::local_ordinal_type>;

  DetermineLocalTriangularStructure(const LocalGraphType& G,
                                    const LocalMapType& rowMap,
                                    const LocalMapType& colMap,
                                    const bool ignoreMapsForTriangularStructure)
    : G_(G)
    , rowMap_(rowMap)
    , colMap_(colMap)
    , ignoreMapsForTriangularStructure_(ignoreMapsForTriangularStructure) {}

  KOKKOS_INLINE_FUNCTION void init(result_type& dst) const {
    dst.diagCount              = 0;
    dst.maxNumRowEnt           = 0;
    dst.couldBeLowerTriangular = true;  // well, we don't know yet, do we?
    dst.couldBeUpperTriangular = true;  // ditto
  }
 
  KOKKOS_INLINE_FUNCTION void
  join(result_type& dst,
       const result_type& src) const {
    dst.diagCount += src.diagCount;
    dst.maxNumRowEnt = (src.maxNumRowEnt > dst.maxNumRowEnt) ? src.maxNumRowEnt : dst.maxNumRowEnt;
    dst.couldBeLowerTriangular &= src.couldBeLowerTriangular;
    dst.couldBeUpperTriangular &= src.couldBeUpperTriangular;
  }

  KOKKOS_INLINE_FUNCTION void
  operator()(const typename LocalMapType::local_ordinal_type lclRow,
             result_type& result) const {
    using LO  = typename LocalMapType::local_ordinal_type;
    using GO  = typename LocalMapType::global_ordinal_type;
    using LOT = typename ::Tpetra::Details::OrdinalTraits<LO>;
 
    auto G_row      = G_.rowConst(lclRow);
    const LO numEnt = G_row.length;
    if (numEnt != 0) {
      result.maxNumRowEnt = (numEnt > result.maxNumRowEnt) ? numEnt : result.maxNumRowEnt;
      // Use global row and column indices to find the diagonal
      // entry.  Caller promises that local row index is in the row
      // Map on the calling process.
      const GO gblDiagCol = rowMap_.getGlobalElement(lclRow);
      const LO lclDiagCol = colMap_.getLocalElement(gblDiagCol);
      // If it's not in the column Map, then there's no diagonal entry.
      if (lclDiagCol != LOT::invalid()) {
        // TODO (mfh 25 Apr 2018) Use findRelOffset to optimize for
        // the sorted case, but note that it requires operator[].
        bool foundDiag = false;  // don't count duplicates
 
        if (ignoreMapsForTriangularStructure_) {
          for (LO k = 0; k < numEnt && !foundDiag; ++k) {
            const LO lclCol = G_row(k);
            if (lclCol == lclDiagCol) {
              foundDiag = true;
            }
          }
          // mfh 30 Apr 2018: See GitHub Issue #2658.  Per
          // current Tpetra::CrsGraph::computeLocalConstants
          // behavior, assume that local column indices are
          // sorted in each row.
          if (numEnt > LO(0)) {
            const LO smallestLclCol = G_row(0);
            const LO largestLclCol  = G_row(numEnt - 1);  // could be same
 
            if (smallestLclCol < lclRow) {
              result.couldBeUpperTriangular = false;
            }
            if (lclRow < largestLclCol) {
              result.couldBeLowerTriangular = false;
            }
          }
        } else {
          for (LO k = 0; k < numEnt &&
                         ((!foundDiag) ||
                          result.couldBeLowerTriangular ||
                          result.couldBeUpperTriangular);
               ++k) {
            const LO lclCol = G_row(k);
            if (lclCol == lclDiagCol) {
              foundDiag = true;
            } else {
              const GO gblCol = colMap_.getGlobalElement(lclCol);
              if (gblCol < gblDiagCol) {
                result.couldBeUpperTriangular = false;
              }
              if (gblDiagCol < gblCol) {
                result.couldBeLowerTriangular = false;
              }
            }
          }  // for each entry in lclRow
        }    // if-else ignoreMapsForTriangularStructure
 
        if (foundDiag) {
          ++(result.diagCount);
        }
      }
    }
  }
 
 private:
  LocalGraphType G_;
  LocalMapType rowMap_;
  LocalMapType colMap_;
  bool ignoreMapsForTriangularStructure_;
};
 
}  // namespace Impl

template <class LocalGraphType, class LocalMapType>
LocalTriangularStructureResult<typename LocalMapType::local_ordinal_type>
determineLocalTriangularStructure(const LocalGraphType& G,
                                  const LocalMapType& rowMap,
                                  const LocalMapType& colMap,
                                  const bool ignoreMapsForTriangularStructure) {
  using LO              = typename LocalMapType::local_ordinal_type;
  using execution_space = typename LocalGraphType::device_type::execution_space;
  using range_type      = Kokkos::RangePolicy<execution_space, LO>;
  using functor_type =
      Impl::DetermineLocalTriangularStructure<LocalGraphType, LocalMapType>;
 
  LocalTriangularStructureResult<LO> result{0, 0, true, true};
  Kokkos::parallel_reduce("Tpetra::Details::determineLocalTriangularStructure",
                          range_type(0, G.numRows()),
                          functor_type(G, rowMap, colMap,
                                       ignoreMapsForTriangularStructure),
                          result);
  return result;
}
 
}  // namespace Details
}  // namespace Tpetra
 
#endif  // TPETRA_DETAILS_DETERMINELOCALTRIANGULARSTRUCTURE_HPP