C++ ParameterList::setName方法代码示例

// ================================================ ====== ==== ==== == =
int ML_Epetra::RefMaxwellPreconditioner::SetEdgeSmoother(Teuchos::ParameterList &List){

  std::string smoother=List.get("smoother: type","Chebyshev");
  int smoother_sweeps=List.get("smoother: sweeps",2);
  int output=List.get("ML output",0);

  if(smoother == "Hiptmair"){
    /* Smoother info output */
    int NumGlobalRows=SM_Matrix_->NumGlobalRows();
    int NumGlobalNNZ=SM_Matrix_->NumGlobalNonzeros();
    if(verbose_ && !Comm_->MyPID()) {
      int edge_sweeps=List.get("subsmoother: edge sweeps",2);
      int node_sweeps=List.get("subsmoother: node sweeps",2);
      char msg[80];
      sprintf(msg,"%s","RefMaxwell (level 0) :");
      printf("%s # global rows = %d, # estim. global nnz = %d\n",msg,NumGlobalRows,NumGlobalNNZ);
      printf("%s %s %d (e=%d/n=%d)\n",msg,smoother.c_str(),smoother_sweeps,edge_sweeps,node_sweeps);
    }

    /* Setup Teuchos Lists - Hiptmair */
    int edge_sweeps=List.get("subsmoother: edge sweeps",2);
    int node_sweeps=List.get("subsmoother: node sweeps",2);

    Teuchos::ParameterList PreList;
    PreList.setName("refmaxwell: edge presmoother");
    PreList.set("coarse: type",smoother);
    PreList.set("coarse: sweeps",1);
    PreList.set("coarse: edge sweeps",smoother_sweeps*edge_sweeps);
    PreList.set("coarse: node sweeps",smoother_sweeps*node_sweeps);
    PreList.set("coarse: subsmoother type",List.get("subsmoother: type","symmetric Gauss-Seidel"));
    PreList.set("coarse: Chebyshev alpha",List.get("subsmoother: Chebyshev alpha",30.0));
    PreList.set("coarse: MLS alpha",List.get("subsmoother: MLS alpha",30.0));
    PreList.set("coarse: damping factor",List.get("subsmoother: SGS damping factor",1.0));
    PreList.set("smoother: Hiptmair efficient symmetric",true);
    PreList.set("PDE equations",1);
    PreList.set("max levels",1);

    Teuchos::ParameterList PostList(PreList);
    PostList.setName("refmaxwell: edge postsmoother");
    PreList.set("coarse: pre or post","pre");
    PreList.set("smoother: pre or post","pre");
    PreList.set("zero starting solution", true);
    PreList.set("ML label","(1,1) block fine pre-smoother");
    PreList.set("ML output",output);
    PostList.set("coarse: pre or post","post");
    PostList.set("smoother: pre or post","post");
    PostList.set("zero starting solution", false);
    PostList.set("ML label","(1,1) block fine post-smoother");
    PostList.set("ML output",output);

    if(HasOnlyDirichletNodes){
      if(PreList.get("coarse: type","dummy") == "Hiptmair"){
        smoother=PreList.get("coarse: subsmoother type","symmetric Gauss-Seidel");
        PreList.set("coarse: type",smoother);
        PostList.set("coarse: type",smoother);
      }/*end if*/
#ifdef HAVE_ML_IFPACK
      IfSmoother=ML_Gen_Smoother_Ifpack_Epetra(const_cast<Epetra_CrsMatrix*>(&*SM_Matrix_),0,List_,"RefMaxwell (level 0): ",verbose_);
#else
      PreEdgeSmoother  = new MultiLevelPreconditioner(*SM_Matrix_,PreList);
      PostEdgeSmoother = new MultiLevelPreconditioner(*SM_Matrix_,PostList);
#endif
    }/*end if*/
    else{
      PreEdgeSmoother  = new MultiLevelPreconditioner(*SM_Matrix_,*D0_Matrix_,*TMT_Matrix_,PreList,true,true);
      PostEdgeSmoother = new MultiLevelPreconditioner(*SM_Matrix_,*D0_Matrix_,*TMT_Matrix_,PostList,true,true);
    }/*end if*/
  }/*end if*/
#ifdef HAVE_ML_IFPACK
  else {
    IfSmoother=ML_Gen_Smoother_Ifpack_Epetra(const_cast<Epetra_CrsMatrix*>(&*SM_Matrix_),0,List_,"RefMaxwell (level 0): ",verbose_);
  }/*end else*/
#endif

  return 0;
}/*end SetEdgeSmoother*/

int main(int argc, char *argv[]) {

  Teuchos::GlobalMPISession mpiSession(&argc, &argv);

  // This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
  int iprint     = argc - 1;
  Teuchos::RCP<std::ostream> outStream;
  Teuchos::oblackholestream bhs; // outputs nothing
  if (iprint > 0)
    outStream = Teuchos::rcp(&std::cout, false);
  else
    outStream = Teuchos::rcp(&bhs, false);

  int errorFlag  = 0;

  // *** Example body.

  try {

    int dim = 10;

    Teuchos::ParameterList parlist;

    std::string jsonFileName("parameters.json");
    parlist.setName("Imported from " + jsonFileName);
    
    // Load json parameters into a Teuchos::ParameterList  
    ROL::JSON_Parameters(jsonFileName,parlist);

    Teuchos::RCP<ROL::Step<RealT> > step;
    ROL::stepFactory<RealT>(parlist,step);

    // Define Status Test
    RealT gtol  = parlist.get("Gradient Tolerance",1e-12); 
    RealT stol  = parlist.get("Step Tolerance",1e-14);  
    int   maxit = parlist.get("Maximum Number of Iterations",100); 
    ROL::StatusTest<RealT> status(gtol, stol, maxit);           

    ROL::DefaultAlgorithm<RealT> algo(*step,status,false);

    Teuchos::RCP<std::vector<RealT> > x_rcp = Teuchos::rcp(new std::vector<RealT> (dim, 1.0) );
    Teuchos::RCP<std::vector<RealT> > k_rcp = Teuchos::rcp(new std::vector<RealT> (dim, 0.0) );

    ROL::StdVector<RealT> x(x_rcp);
    Teuchos::RCP<ROL::Vector<RealT> > k = Teuchos::rcp(new ROL::StdVector<RealT>(k_rcp) );

    for(int i=0;i<dim;++i) {
        (*k_rcp)[i] = i+1.0;
    }
 
    ROL::ZOO::Objective_Zakharov<RealT> obj(k);

    // Run Algorithm
    std::vector<std::string> output = algo.run(x, obj, false);
    for ( unsigned i = 0; i < output.size(); i++ ) {
      std::cout << output[i];
    }

    // Get True Solution
    Teuchos::RCP<std::vector<RealT> > xtrue_rcp = Teuchos::rcp( new std::vector<RealT> (dim, 0.0) );
    ROL::StdVector<RealT> xtrue(xtrue_rcp);

    // Compute Error
    x.axpy(-1.0, xtrue);
    RealT abserr = x.norm();
    *outStream << std::scientific << "\n   Absolute Error: " << abserr;
    if ( abserr > sqrt(ROL::ROL_EPSILON) ) {
      errorFlag += 1;
    }

    // Make an XML file containing the supplied parameters
    Teuchos::writeParameterListToXmlFile(parlist,"parameters.xml");
 
 }
  catch (std::logic_error err) {
    *outStream << err.what() << "\n";
    errorFlag = -1000;
  }; // end try

  if (errorFlag != 0)
    std::cout << "End Result: TEST FAILED\n";
  else
    std::cout << "End Result: TEST PASSED\n";

  return 0;

}