IdentifierModel.cpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//   Zoltan2: A package of combinatorial algorithms for scientific computing
//
// Copyright 2012 NTESS and the Zoltan2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
//
// Testing of IdentifierModel
//
//   TODO  test with BasicIdentifierAdapter with weights
 
#include <Zoltan2_IdentifierModel.hpp>
#include <Zoltan2_XpetraCrsMatrixAdapter.hpp>
#include <Zoltan2_BasicIdentifierAdapter.hpp>
#include <Zoltan2_TestHelpers.hpp>
 
#include <set>
#include <bitset>
 
#include <Teuchos_Comm.hpp>
#include <Teuchos_DefaultComm.hpp>
#include <Teuchos_ArrayView.hpp>
#include <Teuchos_OrdinalTraits.hpp>
 
#include <Tpetra_CrsMatrix.hpp>
 
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::Comm;
 
void testIdentifierModel(std::string fname, zgno_t xdim, zgno_t ydim, zgno_t zdim,
  const RCP<const Comm<int> > &comm)
{
  int rank = comm->getRank();
  int fail = 0, gfail = 0;
 
  std::bitset<Zoltan2::NUM_MODEL_FLAGS> modelFlags = 0;
 
  RCP<const Zoltan2::Environment> env = rcp(new Zoltan2::Environment(comm));
 
  // Use an Tpetra::CrsMatrix for the user data.
  typedef Tpetra::CrsMatrix<zscalar_t, zlno_t, zgno_t> tcrsMatrix_t;
 
  UserInputForTests *uinput;
  if (fname.size() > 0)
    uinput = new UserInputForTests(testDataFilePath, fname, comm, true);
  else
    uinput = new UserInputForTests(xdim,ydim,zdim,string(""),comm, true, true);
 
  RCP<tcrsMatrix_t > M = uinput->getUITpetraCrsMatrix();
  zlno_t nLocalIds = M->getLocalNumRows();
  zgno_t nGlobalIds =  M->getGlobalNumRows();
 
  ArrayView<const zgno_t> idList = M->getRowMap()->getLocalElementList();
  std::set<zgno_t> idSet(idList.begin(), idList.end());
 
  // Create an IdentifierModel with this input
 
  typedef Zoltan2::XpetraCrsMatrixAdapter<tcrsMatrix_t> adapter_t;
  typedef Zoltan2::MatrixAdapter<tcrsMatrix_t> base_adapter_t;
  typedef Zoltan2::StridedData<zlno_t, zscalar_t> input_t;
 
  RCP<const adapter_t> ia = Teuchos::rcp(new adapter_t(M));
 
  Zoltan2::IdentifierModel<base_adapter_t> *model = NULL;
  RCP<const base_adapter_t> base_ia =
                            Teuchos::rcp_dynamic_cast<const base_adapter_t>(ia);
 
  try{
    model = new Zoltan2::IdentifierModel<base_adapter_t>(
      base_ia, env, comm, modelFlags);
  }
  catch (std::exception &e){
    std::cerr << rank << ") " << e.what() << std::endl;
    fail = 1;
  }
 
  gfail = globalFail(*comm, fail);
 
  if (gfail)
    printFailureCode(*comm, fail);
 
  // Test the IdentifierModel interface
 
  if (model->getLocalNumIdentifiers() != size_t(nLocalIds)) {
    std::cerr << rank << ") getLocalNumIdentifiers "
              << model->getLocalNumIdentifiers() << " "
              << nLocalIds << std::endl;
    fail = 2;
  }
 
  if (!fail && model->getGlobalNumIdentifiers() != size_t(nGlobalIds)) {
    std::cerr << rank << ") getGlobalNumIdentifiers "
              << model->getGlobalNumIdentifiers() << " "
              << nGlobalIds << std::endl;
    fail = 3;
  }
 
  gfail = globalFail(*comm, fail);
 
  if (gfail)
    printFailureCode(*comm, fail);
 
  ArrayView<const zgno_t> gids;
  ArrayView<input_t> wgts;
 
  model->getIdentifierList(gids, wgts);
 
  if (!fail && gids.size() != nLocalIds) {
    std::cerr << rank << ") getIdentifierList IDs "
              << gids.size() << " "
              << nLocalIds << std::endl;
    fail = 5;
  }
 
  if (!fail && wgts.size() != 0) {
    std::cerr << rank << ") getIdentifierList Weights "
              << wgts.size() << " "
              << 0 << std::endl;
    fail = 6;
  }
 
  for (zlno_t i=0; !fail && i < nLocalIds; i++){
    std::set<zgno_t>::iterator next = idSet.find(gids[i]);
    if (next == idSet.end()) {
      std::cerr << rank << ") getIdentifierList gid not found "
              << gids[i] << std::endl;
      fail = 7;
    }
  }
 
  Kokkos::View<const zgno_t*, typename tcrsMatrix_t::device_type> gidsKokkos;
  Kokkos::View<zscalar_t **, typename tcrsMatrix_t::device_type> wgtsKokkos;
 
  model->getIdentifierListKokkos(gidsKokkos, wgtsKokkos);
 
  auto gidsKokkosHost = Kokkos::create_mirror_view(gidsKokkos);
  Kokkos::deep_copy(gidsKokkosHost, gidsKokkos);
  auto wgtsKokkosHost = Kokkos::create_mirror_view(wgtsKokkos);
  Kokkos::deep_copy(wgtsKokkosHost, wgtsKokkos);
 
 
  if (!fail && gidsKokkosHost.extent(0) != static_cast<size_t>(nLocalIds)) {
    std::cerr << rank << ") getIdentifierList IDs "
              << gidsKokkosHost.extent(0) << " "
              << nLocalIds << std::endl;
    fail = 5;
  }
 
  if (!fail && wgtsKokkosHost.extent(1) != 0) {
    std::cerr << rank << ") getIdentifierList Weights "
              << wgtsKokkosHost.extent(1) << " "
              << 0 << std::endl;
    fail = 6;
  }
 
  for (zlno_t i=0; !fail && i < nLocalIds; i++){
    std::set<zgno_t>::iterator next = idSet.find(gidsKokkosHost(i));
    if (next == idSet.end()) {
      std::cerr << rank << ") getIdentifierList gid not found "
              << gidsKokkosHost(i) << std::endl;
      fail = 7;
    }
  }
 
 
  gfail = globalFail(*comm, fail);
 
  if (gfail)
    printFailureCode(*comm, fail);
 
  delete model;
  delete uinput;
}
 
int main(int narg, char *arg[])
{
  Tpetra::ScopeGuard tscope(&narg, &arg);
  Teuchos::RCP<const Teuchos::Comm<int> > comm = Tpetra::getDefaultComm();
 
  int rank = comm->getRank();
 
  string fname("simple");
 
 
  if (rank == 0){
    std::cout << fname;
  }
  testIdentifierModel(fname, 0,0,0,comm);
 
  if (rank==0) std::cout << "PASS" << std::endl;
 
  return 0;
}