MueLu_Zoltan2Interface_decl.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//        MueLu: A package for multigrid based preconditioning
//
// Copyright 2012 NTESS and the MueLu contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER

#ifndef MUELU_ZOLTAN2INTERFACE_DECL_HPP
#define MUELU_ZOLTAN2INTERFACE_DECL_HPP

#include "MueLu_ConfigDefs.hpp"

#if defined(HAVE_MUELU_ZOLTAN2) && defined(HAVE_MPI)

#include <Xpetra_Matrix_fwd.hpp>
#include <Xpetra_VectorFactory_fwd.hpp>

#include "MueLu_SingleLevelFactoryBase.hpp"
#include "MueLu_Zoltan2Interface_fwd.hpp"

#include "MueLu_Level_fwd.hpp"
#include "MueLu_FactoryBase_fwd.hpp"

#if defined(HAVE_MUELU_ZOLTAN)
#include "MueLu_ZoltanInterface.hpp"
#endif

namespace MueLu {

// FIXME: this class should not be templated
template <class Scalar,
          class LocalOrdinal  = DefaultLocalOrdinal,
          class GlobalOrdinal = DefaultGlobalOrdinal,
          class Node          = DefaultNode>
class Zoltan2Interface : public SingleLevelFactoryBase {
#undef MUELU_ZOLTAN2INTERFACE_SHORT
#include "MueLu_UseShortNames.hpp"

 public:


  Zoltan2Interface();

  virtual ~Zoltan2Interface() {}

  RCP<const ParameterList> GetValidParameterList() const;


  void DeclareInput(Level& currentLevel) const;


  void Build(Level& currentLevel) const;


 private:
  RCP<ParameterList> defaultZoltan2Params;

};  // class Zoltan2Interface

#ifdef HAVE_MUELU_EPETRA

#if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
     (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))

#if defined(HAVE_MUELU_ZOLTAN)
// Stub partial specialization of Zoltan2Interface for EpetraNode
// Use ZoltanInterface instead of Zoltan2Interface
template <>
class Zoltan2Interface<double, int, int, Xpetra::EpetraNode> : public SingleLevelFactoryBase {
  typedef double Scalar;
  typedef int LocalOrdinal;
  typedef int GlobalOrdinal;
  typedef Xpetra::EpetraNode Node;
#undef MUELU_ZOLTAN2INTERFACE_SHORT
#include "MueLu_UseShortNames.hpp"
 public:
  typedef typename Teuchos::ScalarTraits<Scalar>::magnitudeType real_type;
  typedef Xpetra::MultiVector<real_type, LO, GO, NO> RealValuedMultiVector;

  Zoltan2Interface() {
    level_           = rcp(new Level());
    zoltanInterface_ = rcp(new ZoltanInterface());

    level_->SetLevelID(1);
  }
  virtual ~Zoltan2Interface() {
    zoltanInterface_ = Teuchos::null;
    level_           = Teuchos::null;
  }
  RCP<const ParameterList> GetValidParameterList() const {
    RCP<ParameterList> validParamList = rcp(new ParameterList());

    validParamList->set<RCP<const FactoryBase> >("A", Teuchos::null, "Factory of the matrix A");
    validParamList->set<RCP<const FactoryBase> >("Coordinates", Teuchos::null, "Factory of the coordinates");
    validParamList->set<RCP<const FactoryBase> >("number of partitions", Teuchos::null, "Instance of RepartitionHeuristicFactory.");
    validParamList->set<RCP<const ParameterList> >("ParameterList", Teuchos::null, "Zoltan2 parameters");

    return validParamList;
  };
  void DeclareInput(Level& currentLevel) const {
    Input(currentLevel, "A");
    Input(currentLevel, "number of partitions");
    const ParameterList& pL = GetParameterList();
    // We do this dance, because we don't want "ParameterList" to be marked as used.
    // Is there a better way?
    Teuchos::ParameterEntry entry                  = pL.getEntry("ParameterList");
    RCP<const Teuchos::ParameterList> providedList = Teuchos::any_cast<RCP<const Teuchos::ParameterList> >(entry.getAny(false));
    if (providedList != Teuchos::null && providedList->isType<std::string>("algorithm")) {
      const std::string algo = providedList->get<std::string>("algorithm");
      if (algo == "multijagged" || algo == "rcb")
        Input(currentLevel, "Coordinates");
    } else
      Input(currentLevel, "Coordinates");
  };
  void Build(Level& currentLevel) const {
    this->GetOStream(Warnings0) << "Tpetra does not support <double,int,int,EpetraNode> instantiation, "
                                   "switching Zoltan2Interface to ZoltanInterface"
                                << std::endl;

    // Put the data into a fake level
    level_->Set("A", Get<RCP<Matrix> >(currentLevel, "A"));
    level_->Set("Coordinates", Get<RCP<RealValuedMultiVector> >(currentLevel, "Coordinates"));
    level_->Set("number of partitions", currentLevel.Get<GO>("number of partitions"));

    level_->Request("Partition", zoltanInterface_.get());
    zoltanInterface_->Build(*level_);

    RCP<Xpetra::Vector<GO, LO, GO, NO> > decomposition;
    level_->Get("Partition", decomposition, zoltanInterface_.get());
    Set(currentLevel, "Partition", decomposition);
  };

 private:
  RCP<Level> level_;  // fake Level
  RCP<ZoltanInterface> zoltanInterface_;
};
#else
// Stub partial specialization of Zoltan2Interface for EpetraNode
template <>
class Zoltan2Interface<double, int, int, Xpetra::EpetraNode> : public SingleLevelFactoryBase {
 public:
  Zoltan2Interface() { throw Exceptions::RuntimeError("Tpetra does not support <double,int,int,EpetraNode> instantiation"); }
  virtual ~Zoltan2Interface() {}
  RCP<const ParameterList> GetValidParameterList() const { return Teuchos::null; };
  void DeclareInput(Level& level) const {};
  void Build(Level& level) const {};
};
#endif  // HAVE_MUELU_ZOLTAN

#endif

#endif  // HAVE_MUELU_EPETRA

}  // namespace MueLu

#define MUELU_ZOLTAN2INTERFACE_SHORT
#endif  // if defined(HAVE_MUELU_ZOLTAN2) && defined(HAVE_MPI)

#endif  // MUELU_ZOLTAN2INTERFACE_DECL_HPP