Tpetra_Experimental_BlockMultiVector_decl.hpp

// @HEADER
// ***********************************************************************
//
//          Tpetra: Templated Linear Algebra Services Package
//                 Copyright (2008) 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 Michael A. Heroux (maherou@sandia.gov)
//
// ************************************************************************
// @HEADER

#ifndef TPETRA_EXPERIMENTAL_BLOCKMULTIVECTOR_DECL_HPP
#define TPETRA_EXPERIMENTAL_BLOCKMULTIVECTOR_DECL_HPP

#include <Tpetra_MultiVector.hpp>
#include <Tpetra_Experimental_BlockView.hpp>

namespace Tpetra {
namespace Experimental {

#ifndef DOXYGEN_SHOULD_SKIP_THIS
// Forward declaration of BlockCrsMatrix, needed for debugging.
template<class S, class LO, class GO, class N> class BlockCrsMatrix;
#endif // DOXYGEN_SHOULD_SKIP_THIS

template<class Scalar = ::Tpetra::MultiVector<>::scalar_type,
         class LO = typename ::Tpetra::MultiVector<Scalar>::local_ordinal_type,
         class GO = typename ::Tpetra::MultiVector<Scalar, LO>::global_ordinal_type,
         class Node = typename ::Tpetra::MultiVector<Scalar, LO, GO>::node_type>
class BlockMultiVector :
    public Tpetra::DistObject<Scalar, LO, GO, Node>
{
private:
  typedef Tpetra::DistObject<Scalar, LO, GO, Node> dist_object_type;
  typedef Teuchos::ScalarTraits<Scalar> STS;

protected:
  typedef Scalar packet_type;

public:


  typedef Scalar scalar_type;
  typedef LO local_ordinal_type;
  typedef GO global_ordinal_type;
  typedef Node node_type;

  typedef Tpetra::Map<local_ordinal_type, global_ordinal_type,
                      node_type> map_type;
  typedef Tpetra::MultiVector<scalar_type, local_ordinal_type,
                              global_ordinal_type, node_type> mv_type;

  typedef LittleVector<Scalar, LO> little_vec_type;

  typedef LittleVector<const Scalar, LO> const_little_vec_type;




  BlockMultiVector (const map_type& meshMap,
                    const LO blockSize,
                    const LO numVecs);

  BlockMultiVector (const map_type& meshMap,
                    const map_type& pointMap,
                    const LO blockSize,
                    const LO numVecs);

  BlockMultiVector (const mv_type& X_mv,
                    const map_type& meshMap,
                    const LO blockSize);

  BlockMultiVector ();




  static map_type
  makePointMap (const map_type& meshMap, const LO blockSize);

  map_type getPointMap () const {
    return pointMap_;
  }

  LO getBlockSize () const {
    return blockSize_;
  }

  LO getNumVectors () const {
    return static_cast<LO> (mv_.getNumVectors ());
  }

  mv_type getMultiVectorView ();




  void putScalar (const Scalar& val);

  void scale (const Scalar& val);




  bool replaceLocalValues (const LO localRowIndex, const LO colIndex, const Scalar vals[]) const;

  bool replaceGlobalValues (const GO globalRowIndex, const LO colIndex, const Scalar vals[]) const;

  bool sumIntoLocalValues (const LO localRowIndex, const LO colIndex, const Scalar vals[]) const;

  bool sumIntoGlobalValues (const GO globalRowIndex, const LO colIndex, const Scalar vals[]) const;

  bool getLocalRowView (const LO localRowIndex, const LO colIndex, Scalar*& vals) const;

  bool getGlobalRowView (const GO globalRowIndex, const LO colIndex, Scalar*& vals) const;

  little_vec_type
  getLocalBlock (const LO localRowIndex, const LO colIndex) const;

protected:


  virtual bool checkSizes (const Tpetra::SrcDistObject& source);

  virtual void
  copyAndPermute (const Tpetra::SrcDistObject& source,
                  size_t numSameIDs,
                  const Teuchos::ArrayView<const LO>& permuteToLIDs,
                  const Teuchos::ArrayView<const LO>& permuteFromLIDs);

  virtual void
  packAndPrepare (const Tpetra::SrcDistObject& source,
                  const Teuchos::ArrayView<const LO>& exportLIDs,
                  Teuchos::Array<packet_type>& exports,
                  const Teuchos::ArrayView<size_t>& numPacketsPerLID,
                  size_t& constantNumPackets,
                  Tpetra::Distributor& distor);

  virtual void
  unpackAndCombine (const Teuchos::ArrayView<const LO> &importLIDs,
                    const Teuchos::ArrayView<const packet_type> &imports,
                    const Teuchos::ArrayView<size_t> &numPacketsPerLID,
                    size_t constantNumPackets,
                    Tpetra::Distributor& distor,
                    Tpetra::CombineMode CM);

protected:
  Scalar* getRawPtr () const {
    return mvData_;
  }

  size_t getStrideX () const {
    return static_cast<size_t> (1);
  }

  size_t getStrideY () const {
    return mv_.getStride ();
  }

  bool isValidLocalMeshIndex (const LO meshLocalIndex) const {
    return meshLocalIndex != Teuchos::OrdinalTraits<LO>::invalid () &&
      meshMap_.isNodeLocalElement (meshLocalIndex);
  }

private:
  // mfh 20 May 2014: I'm only using this for debugging.
  template<class Scalar2, class LO2, class GO2, class Node2>
  friend class BlockCrsMatrix;

  map_type meshMap_;

  map_type pointMap_;

protected:
  mv_type mv_;

private:
  Scalar* mvData_;

  LO blockSize_;

  void
  replaceLocalValuesImpl (const LO localRowIndex,
                          const LO colIndex,
                          const Scalar vals[]) const;
  void
  sumIntoLocalValuesImpl (const LO localRowIndex,
                          const LO colIndex,
                          const Scalar vals[]) const;

  static Teuchos::RCP<const mv_type>
  getMultiVectorFromSrcDistObject (const Tpetra::SrcDistObject&);

  static Teuchos::RCP<const BlockMultiVector<Scalar, LO, GO, Node> >
  getBlockMultiVectorFromSrcDistObject (const Tpetra::SrcDistObject& src);
};

} // namespace Experimental
} // namespace Tpetra

#endif // TPETRA_EXPERIMENTAL_BLOCKMULTIVECTOR_DECL_HPP