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