C++ (Cpp) solverType Examples

Example #1

File: BelosOperator.cpp Project: Danniel-UCAS/lifev

void BelosOperator::doSetParameterList()
{
    if ( !M_pList->sublist ( "Trilinos: Belos List" ).isParameter ( "Verbosity" ) )
        M_pList->sublist ( "Trilinos: Belos List" ).set ( "Verbosity", Belos::Errors + Belos::Warnings +
                                                          Belos::TimingDetails + Belos::StatusTestDetails );

    if ( M_tolerance > 0 )
    {
        M_pList->sublist ( "Trilinos: Belos List" ).set ( "Convergence Tolerance", M_tolerance );
    }

    std::string solverType ( M_pList->get<std::string> ( "Solver Manager Type" ) );
    allocateSolver ( getSolverManagerTypeFromString ( solverType ) );
    M_solverManager->setParameters ( sublist ( M_pList, "Trilinos: Belos List", true ) );

    std::string precSideStr ( M_pList->get<std::string> ( "Preconditioner Side" ) );
    PreconditionerSide precSide ( getPreconditionerSideFromString ( precSideStr ) );

    switch (precSide)
    {
        case None:
            break;
        case Left:
            M_linProblem->setLeftPrec ( M_belosPrec );
            break;
        case Right:
            M_linProblem->setRightPrec ( M_belosPrec );
            break;
        default:
            exit (1);
    }

}

Example #2

File: KrylovPreconditioner.hpp Project: spraetor/amdis2

    KrylovPreconditioner(std::string name)
      : fullMatrix(NULL),
        solver(NULL),
        runner(NULL)
    {

#if defined HAVE_PARALLEL_PETSC
      std::string backend("p_petsc");
#elif defined HAVE_PARALLEL_MTL
      std::string backend("p_mtl");
#elif defined HAVE_PETSC || defined HAVE_SEQ_PETSC
      std::string backend("petsc");
#else
      std::string backend("mtl");
#endif

      // === read backend-name ===
      std::string initFileStr = name + "->solver";
      Parameters::get(initFileStr + "->backend", backend);

      // === read solver-name ===
      std::string solverType("0");
      Parameters::get(initFileStr, solverType);

      if (backend != "0" && backend != "no" && backend != "")
        solverType = backend + "_" + solverType;

      LinearSolverCreator* solverCreator =
        dynamic_cast<LinearSolverCreator*>(CreatorMap<LinearSolverInterface>::getCreator(solverType, initFileStr));
      TEST_EXIT(solverCreator)
      ("No valid solver type found in parameter \"%s\"\n", initFileStr.c_str());
      solverCreator->setName(initFileStr);
      solver = solverCreator->create();

      runner = dynamic_cast<RunnerBase<MatrixType, VectorType>*>(solver->getRunner());
    }

Example #3

File: assetreaderlevelofdetailsolver.cpp Project: BtbN/crimson-core

ceRef<ceAsset> ceAssetReaderLevelOfDetailSolver::Read(ceEngine *engine, ceAssetTypeID type, const ceAssetLocator &locator)
{
  ceReleasePtr<iFile> file (ceVFS::Get()->Open(locator.GetLocation()));
  if (!file)
    {
      return 0;
    }
  long size = file->GetLength();

  char* buffer = new char[size+1];
  file->Read(buffer, size);
  file->Close ();

  buffer[size] = '\0';

  cffParser parser;
  ceReleasePtr<cffNode> parent (parser.ParseFromBuffer(buffer));
  delete [] buffer;
  if (!parent)
    {
      return 0;
    }

  cffNode *solverNode = FindNode(parent, locator.GetName());
  if (!solverNode)
    {
      return 0;
    }

  if (!solverNode->HasNamedAttribute("type"))
    {
      return 0;
    }

  iLevelOfDetailSolver* solver = 0;
  std::string solverType (solverNode->GetNamedAttribute("type"));
  if (solverType == std::string ("linear"))
    {
      cffNode* bestNode = solverNode->GetNode("best");
      cffNode* worstNode = solverNode->GetNode("worst");
      cffNode *getLastNode = solverNode->GetNode("getlast");


      float min = 0;
      float max = 1;
      bool getLast = true;
      if (bestNode && bestNode->HasAttribute(0))
        {
          min = bestNode->GetAttribute(0).AsFloat();
        }
      if (worstNode && worstNode->HasAttribute(0))
        {
          max = worstNode->GetAttribute(0).AsFloat();
        }
      if (getLastNode && getLastNode->HasAttribute(0))
        {
          getLast = std::string("true") == std::string (getLastNode->GetAttribute(0));
        }

      solver = new ceLinearLevelOfDetailSolver(min, max, getLast);
    }



  return solver;
}