Tpetra_BlockVector_decl.hpp

// @HEADER
// *****************************************************************************
//          Tpetra: Templated Linear Algebra Services Package
//
// Copyright 2008 NTESS and the Tpetra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef TPETRA_BLOCKVECTOR_DECL_HPP
#define TPETRA_BLOCKVECTOR_DECL_HPP
 
#include "Tpetra_BlockVector_fwd.hpp"
#include "Tpetra_BlockMultiVector.hpp"
#include "Tpetra_Vector.hpp"
 
namespace Tpetra {
 
template <class Scalar,
          class LO,
          class GO,
          class Node>
class BlockVector : public BlockMultiVector<Scalar, LO, GO, Node> {
 private:
  typedef BlockMultiVector<Scalar, LO, GO, Node> base_type;
  typedef Teuchos::ScalarTraits<Scalar> STS;
 
 public:
 
 
  typedef typename base_type::scalar_type scalar_type;
  typedef typename base_type::impl_scalar_type impl_scalar_type;
  typedef typename base_type::local_ordinal_type local_ordinal_type;
  typedef typename base_type::global_ordinal_type global_ordinal_type;
  typedef typename base_type::node_type node_type;
  typedef typename Node::device_type device_type;
 
  typedef Tpetra::Map<LO, GO, Node> map_type;
  typedef Tpetra::MultiVector<Scalar, LO, GO, Node> mv_type;
  typedef Tpetra::Vector<Scalar, LO, GO, Node> vec_type;
 
  typedef typename base_type::little_vec_type
      little_vec_type;
  typedef typename base_type::little_host_vec_type
      little_host_vec_type;
 
  typedef typename base_type::const_little_vec_type
      const_little_vec_type;
  typedef typename base_type::const_little_host_vec_type
      const_little_host_vec_type;
 
 
 
  BlockVector();
 
  BlockVector(const BlockVector<Scalar, LO, GO, Node>&) = default;
 
  BlockVector(BlockVector<Scalar, LO, GO, Node>&&) = default;
 
  BlockVector<Scalar, LO, GO, Node>&
  operator=(const BlockVector<Scalar, LO, GO, Node>&) = default;
 
  BlockVector<Scalar, LO, GO, Node>&
  operator=(BlockVector<Scalar, LO, GO, Node>&&) = default;
 
  BlockVector(const BlockVector<Scalar, LO, GO, Node>& in,
              const Teuchos::DataAccess copyOrView);
 
  BlockVector(const map_type& meshMap, const LO blockSize);
 
  BlockVector(const map_type& meshMap,
              const map_type& pointMap,
              const LO blockSize);
 
  BlockVector(const mv_type& X_mv,
              const map_type& meshMap,
              const LO blockSize);
 
  BlockVector(const vec_type& X_vec,
              const map_type& meshMap,
              const LO blockSize);
 
  BlockVector(const BlockVector<Scalar, LO, GO, Node>& X,
              const map_type& newMeshMap,
              const map_type& newPointMap,
              const size_t offset = 0);
 
  BlockVector(const BlockVector<Scalar, LO, GO, Node>& X,
              const map_type& newMeshMap,
              const size_t offset = 0);
 
 
 
  vec_type getVectorView();
 
 
 
  bool replaceLocalValues(const LO localRowIndex, const Scalar vals[]);
 
  bool replaceGlobalValues(const GO globalRowIndex, const Scalar vals[]);
 
  bool sumIntoLocalValues(const LO localRowIndex, const Scalar vals[]);
 
  bool sumIntoGlobalValues(const GO globalRowIndex, const Scalar vals[]);
 
  const_little_host_vec_type getLocalBlockHost(const LO localRowIndex,
                                               Access::ReadOnlyStruct) const;
  little_host_vec_type getLocalBlockHost(const LO localRowIndex,
                                         Access::OverwriteAllStruct);
  little_host_vec_type getLocalBlockHost(const LO localRowIndex,
                                         Access::ReadWriteStruct);
};
 
}  // namespace Tpetra
 
#endif  // TPETRA_BLOCKMULTIVECTOR_DECL_HPP