paramTest.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 <Teuchos_ParameterList.hpp>
#include <Teuchos_XMLObject.hpp>
#include <Teuchos_XMLParameterListWriter.hpp>
#include <Teuchos_ParameterXMLFileReader.hpp>
#include <Teuchos_ValidatorXMLConverterDB.hpp>
 
#include <Teuchos_StandardParameterEntryValidators.hpp>
#include <Zoltan2_Parameters.hpp>
#include <Zoltan2_IntegerRangeList.hpp>
 
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
 
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::tuple;
 
using std::string;
 
int main()
{
  // Create a parameter list with each validator type that we use.
 
  Teuchos::ParameterList pl("pl");
 
  {
    string parameterName("speed_versus_quality");
    RCP<const Teuchos::StringValidator> strValidatorP =
      rcp(new Teuchos::StringValidator(
        tuple<string>("speed", "balance", "quality")));
    std::ostringstream docString;
    strValidatorP->printDoc(
      "When algorithm choices exist, opt for speed or solution quality?\n"
      "(Default is a balance of speed and quality)\n",
       docString);
    pl.set<string>(parameterName, "balance", docString.str(), strValidatorP);
  }
 
  {
    string parameterName("debug_output_file");
    RCP<const Teuchos::FileNameValidator > fnameValidatorP =
      fnameValidatorP = rcp(new Teuchos::FileNameValidator(false));
    std::ostringstream docString;
    fnameValidatorP->printDoc(
      "name of file to which debug/status messages should be written\n"
      "(process rank will be included in file name)\n",
       docString);
    pl.set<string>(parameterName, "/dev/null", docString.str(), 
      fnameValidatorP);
  }
 
  {
    string parameterName("random_seed");
    RCP<const Teuchos::AnyNumberParameterEntryValidator> anyNumValidatorP =
      rcp(new Teuchos::AnyNumberParameterEntryValidator);
    std::ostringstream docString;
    anyNumValidatorP->printDoc("random seed\n", docString);
    pl.set<string>(parameterName, "0.5", docString.str(), anyNumValidatorP);
  }
 
  {
    string parameterName("debug_level");
    RCP<const Teuchos::StringToIntegralParameterEntryValidator<int> > 
      str2intValidatorP = 
      rcp(new Teuchos::StringToIntegralParameterEntryValidator<int>(
       tuple<string>("no_status",
                    "basic_status",
                    "detailed_status",
                    "verbose_detailed_status"),
 
       tuple<string>(
        "library outputs no status information",
        "library outputs basic status information (default)",
        "library outputs detailed information",
        "library outputs very detailed information"),
 
       tuple<int>(0, 1, 2, 3),
 
       parameterName));
 
    string info("the amount of status/warning/debugging info printed\n");
    info.append("(If the compile flag Z2_OMIT_ALL_STATUS_MESSAGES was set,\n");
    info.append("then message output code is not executed at runtime.)\n");
 
    std::ostringstream docString;
    str2intValidatorP->printDoc(info, docString);
    pl.set<string>(parameterName, "basic_status", docString.str(), 
      str2intValidatorP);
  }
 
  {
    string parameterName("debug_procs");
    typedef Zoltan2::IntegerRangeListValidator<int> irl_t;
    RCP<const irl_t> intRangeValidatorP = rcp(new irl_t);
    std::ostringstream docString;
    intRangeValidatorP->printDoc(
      "list of ranks that output debugging/status messages (default \"0\")\n",
       docString);
    pl.set<string>(parameterName, "0", docString.str(), intRangeValidatorP);
 
    // An XML converter for irl_t only needs to be added once to the converter db.
 
    typedef Zoltan2::IntegerRangeListValidatorXMLConverter<int> irlConverter_t;
    RCP<irlConverter_t > converter = rcp(new irlConverter_t);
    Teuchos::ValidatorXMLConverterDB::addConverter(
          intRangeValidatorP,    // can be a dummy of this type
          converter);
  }
 
  // Write out to XML
  Teuchos::XMLParameterListWriter plw;
  Teuchos::XMLObject obj = plw.toXML(pl);
 
  std::cout << "Parameter list: " << std::endl;
  std::cout << obj << std::endl;
 
  std::ofstream of;
  of.open("params.xml");
  of << obj << std::endl;
  of.close();
 
  // Read parameter list in from XML file.
 
  Teuchos::ParameterXMLFileReader rdr("params.xml");
  Teuchos::ParameterList newpl = rdr.getParameters();
  Teuchos::XMLObject objnew = plw.toXML(newpl);
 
  std::cout << "After reading in from XML file: " << std::endl;
  std::cout << objnew << std::endl;
}