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