Tpetra_Details_Transfer_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_DETAILS_TRANSFER_DECL_HPP
#define TPETRA_DETAILS_TRANSFER_DECL_HPP
 
#include "Tpetra_Details_Transfer_fwd.hpp"
#include "Tpetra_ImportExportData_fwd.hpp"
#include "Tpetra_Map_decl.hpp"
#include "Teuchos_Describable.hpp"
 
namespace Tpetra {
 
// Forward declaration.  The macro tells Doxygen (our automatic
// documentation generation system) to skip forward declarations.
#ifndef DOXYGEN_SHOULD_SKIP_THIS
class Distributor;
#endif  // DOXYGEN_SHOULD_SKIP_THIS
 
namespace Details {
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <class LO, class GO, class NT>
void expertSetRemoteLIDsContiguous(Transfer<LO, GO, NT> transfer, bool contig);
 
template <class LO, class GO, class NT>
void expertSetExportLIDsContiguous(Transfer<LO, GO, NT> transfer, bool contig);
#endif  // DOXYGEN_SHOULD_SKIP_THIS
 
template <class LO,
          class GO,
          class NT>
class Transfer : public Teuchos::Describable {
 public:
  using map_type = ::Tpetra::Map<LO, GO, NT>;
 
 private:
  using execution_space = typename NT::device_type::execution_space;
  using memory_space =
      ::Tpetra::Details::DefaultTypes::comm_buffer_memory_space<typename NT::device_type>;
  using device_type = Kokkos::Device<execution_space, memory_space>;
 
 public:
  // Don't be tempted to comment this out if code doesn't build.
  // The point is to ensure correct initialization of TransferData_.
  Transfer() = delete;
 
  Transfer(const Teuchos::RCP<const map_type>& source,
           const Teuchos::RCP<const map_type>& target,
           const Teuchos::RCP<Teuchos::FancyOStream>& out,
           const Teuchos::RCP<Teuchos::ParameterList>& plist,
           const std::string& className);
 
  Transfer(const Transfer<LO, GO, NT>& rhs) = default;
 
  struct reverse_tag {};
  Transfer(const Transfer<LO, GO, NT>& rhs, reverse_tag tag);
 
  Transfer<LO, GO, NT>& operator=(const Transfer<LO, GO, NT>&) = default;
 
  virtual ~Transfer() = default;
 
  size_t getNumSameIDs() const;
 
  size_t getNumPermuteIDs() const;
 
  Kokkos::DualView<const LO*, device_type> getPermuteFromLIDs_dv() const;
 
  Teuchos::ArrayView<const LO> getPermuteFromLIDs() const;
 
  Kokkos::DualView<const LO*, device_type> getPermuteToLIDs_dv() const;
 
  Teuchos::ArrayView<const LO> getPermuteToLIDs() const;
 
  size_t getNumRemoteIDs() const;
 
  Kokkos::DualView<const LO*, device_type> getRemoteLIDs_dv() const;
 
  Teuchos::ArrayView<const LO> getRemoteLIDs() const;
 
  size_t getNumExportIDs() const;
 
  Kokkos::DualView<const LO*, device_type> getExportLIDs_dv() const;
 
  Teuchos::ArrayView<const LO> getExportLIDs() const;
 
  Teuchos::ArrayView<const int> getExportPIDs() const;
 
  Teuchos::RCP<const map_type> getSourceMap() const;
 
  Teuchos::RCP<const map_type> getTargetMap() const;
 
  ::Tpetra::Distributor& getDistributor() const;
 
  bool isLocallyComplete() const;
 
  void detectRemoteExportLIDsContiguous() const;
 
  bool areRemoteLIDsContiguous() const;
 
  bool areExportLIDsContiguous() const;
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  friend void expertSetRemoteLIDsContiguous<LO, GO, NT>(Transfer<LO, GO, NT> transfer, bool contig);
 
  friend void expertSetExportLIDsContiguous<LO, GO, NT>(Transfer<LO, GO, NT> transfer, bool contig);
#endif  // DOXYGEN_SHOULD_SKIP_THIS
 
  bool isLocallyFitted() const;
 
  virtual void
  describe(Teuchos::FancyOStream& out,
           const Teuchos::EVerbosityLevel verbLevel =
               Teuchos::Describable::verbLevel_default) const;
 
 protected:
  Teuchos::RCP<ImportExportData<LO, GO, NT> > TransferData_;
 
  Teuchos::FancyOStream& verboseOutputStream() const;
 
  bool verbose() const;
 
  void
  describeImpl(Teuchos::FancyOStream& out,
               const std::string& className,
               const Teuchos::EVerbosityLevel verbLevel =
                   Teuchos::Describable::verbLevel_default) const;
 
 private:
  void
  setParameterList(const Teuchos::RCP<Teuchos::ParameterList>& plist,
                   const std::string& className);
 
  void
  globalDescribe(Teuchos::FancyOStream& out,
                 const Teuchos::EVerbosityLevel vl) const;
 
  std::string
  localDescribeToString(const Teuchos::EVerbosityLevel vl) const;
};
 
}  // namespace Details
}  // namespace Tpetra
 
// Explicit instantiation macro.
// Only invoke this when in the Tpetra::Details namespace.
// Most users do not need to use this.
//
// LO: The local ordinal type.
// GO: The global ordinal type.
// NODE: The Kokkos Node type.
#define TPETRA_DETAILS_TRANSFER_INSTANT(LO, GO, NODE)                                                      \
  template class Transfer<LO, GO, NODE>;                                                                   \
  template void expertSetRemoteLIDsContiguous<LO, GO, NODE>(Transfer<LO, GO, NODE> transfer, bool contig); \
  template void expertSetExportLIDsContiguous<LO, GO, NODE>(Transfer<LO, GO, NODE> transfer, bool contig);
 
#endif  // TPETRA_DETAILS_TRANSFER_DECL_HPP