Xpetra_CrsMatrixWrap_decl.hpp

Go to the documentation of this file.

// @HEADER
//
// ***********************************************************************
//
//             Xpetra: A linear algebra interface package
//                  Copyright 2012 Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact
//                    Jonathan Hu       (jhu@sandia.gov)
//                    Andrey Prokopenko (aprokop@sandia.gov)
//                    Ray Tuminaro      (rstumin@sandia.gov)
//
// ***********************************************************************
//
// @HEADER
 
// WARNING: This code is experimental. Backwards compatibility should not be expected.
 
#ifndef XPETRA_CRSMATRIXWRAP_DECL_HPP
#define XPETRA_CRSMATRIXWRAP_DECL_HPP
 
#include <Kokkos_DefaultNode.hpp>
 
#include "Xpetra_ConfigDefs.hpp"
#include "Xpetra_Exceptions.hpp"
 
#include "Xpetra_MultiVector_decl.hpp"
#include "Xpetra_CrsGraph.hpp"
#include "Xpetra_CrsMatrix.hpp"
#include "Xpetra_CrsMatrixFactory.hpp"
 
#include "Xpetra_Matrix.hpp"
 
#include <Teuchos_SerialDenseMatrix.hpp>
#include <Teuchos_Hashtable.hpp>
 
namespace Xpetra {
 
  typedef std::string viewLabel_t;
 
template <class Scalar,
          class LocalOrdinal,
          class GlobalOrdinal,
          class Node = KokkosClassic::DefaultNode::DefaultNodeType>
class CrsMatrixWrap :
  public Matrix<Scalar,LocalOrdinal,GlobalOrdinal,Node>
{
  typedef Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node> Map;
  typedef Xpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node> CrsMatrix;
  typedef Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node> Matrix;
  typedef Xpetra::CrsGraph<LocalOrdinal, GlobalOrdinal, Node> CrsGraph;
#ifdef HAVE_XPETRA_TPETRA
  typedef Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node> TpetraCrsMatrix;
#endif
  typedef Xpetra::CrsMatrixFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node> CrsMatrixFactory;
  typedef Xpetra::MatrixView<Scalar, LocalOrdinal, GlobalOrdinal, Node> MatrixView;
#ifdef HAVE_XPETRA_KOKKOS_REFACTOR
#ifdef HAVE_XPETRA_TPETRA
    typedef typename CrsMatrix::local_matrix_type local_matrix_type;
#endif
#endif
 
public:
 
 
  CrsMatrixWrap (const RCP<const Map>& rowMap);
 
  CrsMatrixWrap (const RCP<const Map>& rowMap,
                 size_t maxNumEntriesPerRow);
 
  CrsMatrixWrap (const RCP<const Map>& rowMap,
                 const ArrayRCP<const size_t>& NumEntriesPerRowToAlloc);
 
  CrsMatrixWrap(const RCP<const Map> &rowMap, const RCP<const Map>& colMap, size_t maxNumEntriesPerRow);
 
  CrsMatrixWrap(const RCP<const Map> &rowMap, const RCP<const Map>& colMap, const ArrayRCP<const size_t> &NumEntriesPerRowToAlloc);
 
#ifdef HAVE_XPETRA_KOKKOS_REFACTOR
#ifdef HAVE_XPETRA_TPETRA
  CrsMatrixWrap(const RCP<const Map> &rowMap, const RCP<const Map>& colMap, const local_matrix_type& lclMatrix, const Teuchos::RCP<Teuchos::ParameterList>& params = null);
 
  CrsMatrixWrap(const local_matrix_type& lclMatrix, const RCP<const Map> &rowMap, const RCP<const Map>& colMap,
                const RCP<const Map>& domainMap = Teuchos::null, const RCP<const Map>& rangeMap = Teuchos::null,
                const Teuchos::RCP<Teuchos::ParameterList>& params = null);
#else
#ifdef __GNUC__
#warning "Xpetra Kokkos interface for CrsMatrix is enabled (HAVE_XPETRA_KOKKOS_REFACTOR) but Tpetra is disabled. The Kokkos interface needs Tpetra to be enabled, too."
#endif
#endif
#endif
 
  CrsMatrixWrap(RCP<CrsMatrix> matrix);
 
  CrsMatrixWrap(const RCP<const CrsGraph>& graph, const RCP<ParameterList>& paramList = Teuchos::null);
 
  virtual ~CrsMatrixWrap();
 
 
 
 
 
 
  void insertGlobalValues(GlobalOrdinal globalRow, const ArrayView<const GlobalOrdinal> &cols, const ArrayView<const Scalar> &vals);
 
 
  void insertLocalValues(LocalOrdinal localRow, const ArrayView<const LocalOrdinal> &cols, const ArrayView<const Scalar> &vals);
 
 
  void replaceGlobalValues(GlobalOrdinal globalRow,
                           const ArrayView<const GlobalOrdinal> &cols,
                           const ArrayView<const Scalar>        &vals);
 
 
  void replaceLocalValues(LocalOrdinal localRow,
                          const ArrayView<const LocalOrdinal> &cols,
                          const ArrayView<const Scalar>       &vals);
 
  virtual void setAllToScalar(const Scalar &alpha);
 
  void scale(const Scalar &alpha);
 
 
 
 
  void resumeFill(const RCP< ParameterList > &params=null);
 
  void fillComplete(const RCP<const Map> &domainMap, const RCP<const Map> &rangeMap, const RCP<Teuchos::ParameterList> &params = null);
 
  //TODO : Get ride of "Tpetra"::OptimizeOption
  void fillComplete(const RCP<ParameterList> &params = null);
 
 
 
  global_size_t getGlobalNumRows() const;
 
 
  global_size_t getGlobalNumCols() const;
 
  size_t getNodeNumRows() const;
 
  global_size_t getGlobalNumEntries() const;
 
  size_t getNodeNumEntries() const;
 
 
  size_t getNumEntriesInLocalRow(LocalOrdinal localRow) const;
 
 
  size_t getNumEntriesInGlobalRow(GlobalOrdinal globalRow) const;
 
 
  size_t getGlobalMaxNumRowEntries() const;
 
 
  size_t getNodeMaxNumRowEntries() const;
 
  bool isLocallyIndexed() const;
 
  bool isGloballyIndexed() const;
 
  bool isFillComplete() const;
 
 
  void getLocalRowCopy(LocalOrdinal LocalRow,
                       const ArrayView<LocalOrdinal> &Indices,
                       const ArrayView<Scalar> &Values,
                       size_t &NumEntries
                       ) const;
 
 
  void getGlobalRowView(GlobalOrdinal GlobalRow, ArrayView<const GlobalOrdinal> &indices, ArrayView<const Scalar> &values) const;
 
 
  void getLocalRowView(LocalOrdinal LocalRow, ArrayView<const LocalOrdinal> &indices, ArrayView<const Scalar> &values) const;
 
 
  void getLocalDiagCopy(Xpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> &diag) const;
 
  void getLocalDiagOffsets(Teuchos::ArrayRCP<size_t> &offsets) const;
 
  void getLocalDiagCopy(Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &diag, const Teuchos::ArrayView<const size_t> &offsets) const;
 
  typename ScalarTraits<Scalar>::magnitudeType getFrobeniusNorm() const;
 
  void leftScale (const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& x);
 
  void rightScale (const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& x);
 
  bool haveGlobalConstants() const;
 
 
 
 
 
  //TODO virtual=0 // TODO: Add default parameters ?
//   void multiply(const MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node> & X, MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node> &Y, Teuchos::ETransp trans, Scalar alpha, Scalar beta) const {
//      matrixData_->multiply(X, Y, trans, alpha, beta);
//   }
 
 
 
 
 
  virtual void apply(const Xpetra::MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node>& X,
                   Xpetra::MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node>& Y,
                   Teuchos::ETransp mode = Teuchos::NO_TRANS,
                   Scalar alpha = ScalarTraits<Scalar>::one(),
                   Scalar beta = ScalarTraits<Scalar>::zero()) const;
 
  virtual void apply(const MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &X,
                    MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &Y,
                    Teuchos::ETransp mode,
                    Scalar alpha,
                    Scalar beta,
                    bool sumInterfaceValues,
                    const RCP<Import<LocalOrdinal, GlobalOrdinal, Node> >& regionInterfaceImporter,
                    const Teuchos::ArrayRCP<LocalOrdinal>& regionInterfaceLIDs) const;
 
  RCP<const Xpetra::Map<LocalOrdinal,GlobalOrdinal,Node> > getDomainMap() const;
 
  RCP<const Xpetra::Map<LocalOrdinal,GlobalOrdinal,Node> > getRangeMap() const;
 
  const RCP<const Map> & getColMap() const;
 
  const RCP<const Map> & getColMap(viewLabel_t viewLabel) const;
 
  void removeEmptyProcessesInPlace(const Teuchos::RCP<const Map>& newMap);
 
 
  //{@
 
  const Teuchos::RCP< const Xpetra::Map< LocalOrdinal, GlobalOrdinal, Node > > getMap() const;
 
  void doImport(const Matrix &source,
                const Xpetra::Import< LocalOrdinal, GlobalOrdinal, Node > &importer, CombineMode CM);
 
  void doExport(const Matrix &dest,
                const Xpetra::Import< LocalOrdinal, GlobalOrdinal, Node >& importer, CombineMode CM);
 
  void doImport(const Matrix &source,
                const Xpetra::Export< LocalOrdinal, GlobalOrdinal, Node >& exporter, CombineMode CM);
 
  void doExport(const Matrix &dest,
                const Xpetra::Export< LocalOrdinal, GlobalOrdinal, Node >& exporter, CombineMode CM);
 
  // @}
 
 
 
  std::string description() const;
 
  void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel=Teuchos::Describable::verbLevel_default) const;
 
 
  void setObjectLabel( const std::string &objectLabel );
 
 
 
 
#ifdef HAVE_XPETRA_KOKKOS_REFACTOR
#ifdef HAVE_XPETRA_TPETRA
#ifdef TPETRA_ENABLE_DEPRECATED_CODE
  virtual local_matrix_type getLocalMatrix () const;
#endif
 
  virtual local_matrix_type getLocalMatrixDevice () const;
  virtual typename local_matrix_type::HostMirror getLocalMatrixHost () const;
#else
#ifdef __GNUC__
#warning "Xpetra Kokkos interface for CrsMatrix is enabled (HAVE_XPETRA_KOKKOS_REFACTOR) but Tpetra is disabled. The Kokkos interface needs Tpetra to be enabled, too."
#endif
#endif
#endif
 
  // JG: Added:
 
  bool hasCrsGraph() const;
 
  RCP<const CrsGraph> getCrsGraph() const;
 
  RCP<CrsMatrix> getCrsMatrix() const;
 
 
  void residual(const MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > & X,
                const MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > & B,
                MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > & R) const;
  
 
private:
 
  // Default view is created after fillComplete()
  // Because ColMap might not be available before fillComplete().
  void CreateDefaultView();
 
private:
 
  // The colMap can be <tt>null</tt> until fillComplete() is called. The default view of the Matrix have to be updated when fillComplete() is called.
  // If CrsMatrix::fillComplete() have been used instead of CrsMatrixWrap::fillComplete(), the default view is updated when getColMap() is called.
  void updateDefaultView() const;
  // The boolean finalDefaultView_ keep track of the status of the default view (= already updated or not)
  // See also CrsMatrixWrap::updateDefaultView()
  mutable bool finalDefaultView_;
 
  // The underlying matrix object
  RCP<CrsMatrix> matrixData_;
 
}; // class CrsMatrixWrap
 
} // namespace Xpetra
 
#define XPETRA_CRSMATRIXWRAP_SHORT
#endif //XPETRA_CRSMATRIXWRAP_DECL_HPP
 
//NOTE: if CrsMatrix and VbrMatrix share a common interface for fillComplete() etc, I can move some stuff in Xpetra_Matrix.hpp
//TODO: getUnderlyingMatrix() method