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