Zoltan2_Parameters.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

#include <Zoltan2_Parameters.hpp>

// Parameters.cpp builds the full lists from a series of member statics
#include <Zoltan2_InputTraits.hpp>
#include <Zoltan2_BasicIdentifierAdapter.hpp>
#include <Zoltan2_Problem.hpp>
#include <Zoltan2_PartitioningProblem.hpp>
#include <Zoltan2_OrderingProblem.hpp>
#include <Zoltan2_MappingProblem.hpp>
#include <Zoltan2_ColoringProblem.hpp>

namespace Zoltan2 {

void createAllParameters(Teuchos::ParameterList &pList)
{
  // the old method loads from a larger #define XML string
  // the new way loads from a series of static functions

  // The dummy adapter is arbitrary
  // It allows us to keep the getValidParameters method in the class
  // However currently that has no template dependence
  typedef Zoltan2::BasicUserTypes<> dummyTypes;
  typedef Zoltan2::BasicIdentifierAdapter< dummyTypes > dummyAdapter;

  // environment has some of it's own parameters to provide
  Environment::getValidParameters(pList);

  // Problem provides the base set of parameters for all problems
  Zoltan2::Problem<dummyAdapter>::getValidParameters(pList);

  // PartitioningProblem will also add parameters for each Algorithm
  Zoltan2::PartitioningProblem<dummyAdapter>::getValidParameters(pList);

  // Other problems have their own unique parameters
  Zoltan2::OrderingProblem<dummyAdapter>::getValidParameters(pList);
  Zoltan2::MappingProblem<dummyAdapter>::getValidParameters(pList);
  Zoltan2::ColoringProblem<dummyAdapter>::getValidParameters(pList);
}

static void setValidatorsInList(
  const Teuchos::ParameterList &plSome,   // in: user's parameters
  const Teuchos::ParameterList &plAll,    // in: validators for all params
  Teuchos::ParameterList &plVal)          // out: validators for user's params
{
  ParameterList::ConstIterator next = plSome.begin();

  while (next != plSome.end()){

    const std::string &name = next->first;
    const ParameterEntry &entrySome = plSome.getEntry(name);
    const ParameterEntry &entryAll = plAll.getEntry(name);

    if (entrySome.isList()){
      plVal.sublist(name);     // create & get
      // Don't set validators for sublists; sublists are for TPL's parameters
    }
    else{
      plVal.setEntry(name, entryAll);
    }

    ++next;
  }
}

void createValidatorList(
   const Teuchos::ParameterList &plIn,
   Teuchos::ParameterList &plOut)
{
  ParameterList allParameters;

  try{
    createAllParameters(allParameters);
  }
  Z2_FORWARD_EXCEPTIONS

  setValidatorsInList(plIn, allParameters, plOut);
}

// Why isn't there a Teuchos method that does this?

void printListDocumentation(
  const Teuchos::ParameterList &pl,
  std::ostream &os,
  std::string listNames)
{

  if (listNames.size() == 0)
    listNames = std::string("top");

  Array<std::string> subLists;
  ParameterList::ConstIterator next = pl.begin();

  while (next != pl.end()){
    const std::string &name = next->first;
    const ParameterEntry &entry = pl.getEntry(name);

    if (entry.isList()){
      subLists.append(name);
    }
    else{
      std::string doc = entry.docString();
      os << "List: "<< listNames << ", parameter: " << name << "\n";
      if (doc.size())
        os << doc << "\n";
    }

    ++next;
  }

  for (int i=0; i < subLists.size(); i++){
    std::string newListName = listNames + std::string("/") + subLists[i];
    const ParameterList &sublist = pl.sublist(subLists[i]);
    printListDocumentation(sublist, os, newListName);
  }
}


}  //namespace Zoltan2