C++ (Cpp) CursorPtr Examples

Example #1

File: nonlinear_solver_implementation.cpp Project: kglass/GridPACK

// -------------------------------------------------------------
// NonlinearSolverImplementation::p_configure
// -------------------------------------------------------------
void
NonlinearSolverImplementation::p_configure(utility::Configuration::CursorPtr props)
{
  if (props) {
    p_solutionTolerance = props->get("SolutionTolerance", p_solutionTolerance);
    p_functionTolerance = props->get("FunctionTolerance", p_functionTolerance);
    p_maxIterations = props->get("MaxIterations", p_maxIterations);
  }
}

Example #2

File: linear_solver_implementation.hpp Project: Anastien/GridPACK

  /// Specialized way to configure from property tree
  void p_configure(utility::Configuration::CursorPtr props)
  {
    if (props) {
      p_solutionTolerance = props->get("SolutionTolerance", p_solutionTolerance);
      p_relativeTolerance = props->get("RelativeTolerance", p_relativeTolerance);
      p_maxIterations = props->get("MaxIterations", p_maxIterations);

      p_doSerial = props->get("ForceSerial", p_doSerial);
      p_constSerialMatrix = props->get("SerialMatrixConstant", p_constSerialMatrix);

      // SerialOnly has no effect unless parallel
      p_doSerial = (p_doSerial && (this->processor_size() > 1));

      p_guessZero = props->get("InitialGuessZero", p_guessZero);
    }
  }

Example #3

File: configurable.hpp Project: GridOPTICS/GridPACK

 /// Initialize this instance using the specified configuration property tree
 void configure(utility::Configuration::CursorPtr theprops)
 {
   if (theprops) {
     p_configCursor = theprops->getCursor(this->p_key);
   }
   this->p_configure(p_configCursor);
   p_isConfigured = true;
 }

Example #4

File: petsc_configurable.cpp Project: Anastien/GridPACK

/** 
 * 
 * 
 * @param comm 
 * @param props 
 * 
 * @return PETSc options prefix to use
 */
void
PETScConfigurable::p_processOptions(utility::Configuration::CursorPtr props)
{
  if (!props) return;

  p_prefix = props->get(p_prefixKey, p_generatePrefix(p_comm));
  if (*p_prefix.rbegin() != '_') {
    p_prefix.append("_");
  }

  std::string optsorig, optsmod, optsfmt;
  optsorig = props->get(p_optionsKey, "");

  boost::char_separator<char> sep(" \t\f\n\r\v", "");
  boost::tokenizer<boost::char_separator<char> > 
    opttok(optsorig, sep);
  boost::tokenizer<boost::char_separator<char> >::iterator o;
  for (o = opttok.begin(); o != opttok.end(); ++o) {
    optsfmt.append(*o);
    optsfmt.append(" ");
    optsmod.append(prefixOptionMaybe(p_prefix, *o));
    optsmod.append(" ");
  }

  if (verbose) {
    std::cout << "p_processOptions:  in: " << optsorig << std::endl;
    std::cout << "p_processOptions: fmt: " << optsfmt << std::endl;
    std::cout << "p_processOptions: out: " << optsmod << std::endl;
  }
  p_loadedOptions = optsmod;

  PetscErrorCode ierr(0);
  try {
    ierr = PetscOptionsInsertString(
#if PETSC_VERSION_GE(3,7,0)
                                    NULL,
#endif
                                    p_loadedOptions.c_str()); CHKERRXX(ierr);
  } catch (const PETSC_EXCEPTION_TYPE& e) {
    throw PETScException(ierr, e);
  }
  return;
}

Example #5

// -------------------------------------------------------------
// Optimizer::p_preconfigure
// -------------------------------------------------------------
void
Optimizer::p_preconfigure(utility::Configuration::CursorPtr theprops)
{
  parallel::Communicator comm(p_impl->communicator());
  std::string key(p_impl->configurationKey());
  utility::Configuration::CursorPtr p = theprops->getCursor(key);
  std::string solver;
  solver = p->get("Solver", solver);

  if (!solver.empty()) {
    p_setImpl(NULL);
    if (solver == "GLPK") {
#if defined(HAVE_GLPK)
      p_setImpl(new GLPKOptimizerImplementation(comm));
#else
      throw gridpack::Exception("GLPK Optimizer not supported"); 
#endif
    } 
    if (solver == "CPLEX") {
#if defined(HAVE_CPLEX)
      p_setImpl(new CPlexOptimizerImplementation(comm));
#else
      throw gridpack::Exception("CPLEX Optimizer not supported"); 
#endif
    } 
    if (solver == "Julia") {
      p_setImpl(new JuliaOptimizerImplementation(comm));
    }
    if (solver == "LPFile") {
      p_setImpl(new LPFileOptimizerImplementation(comm));
    }
    if (!p_impl) {
      std::string s("Unknown ptimizer solver type \"");
      s += solver;
      s += "\"";
      throw gridpack::Exception(s); 
    }
  }
}