int ep_upk(ep_t r, const ep_t p) {
fp_t t;
int result = 0;
fp_null(t);
TRY {
fp_new(t);
ep_rhs(t, p);
/* t0 = sqrt(x1^3 + a * x1 + b). */
result = fp_srt(t, t);
if (result) {
/* Verify if least significant bit of the result matches the
* compressed y-coordinate. */
if (fp_get_bit(t, 0) != fp_get_bit(p->y, 0)) {
fp_neg(t, t);
}
fp_copy(r->x, p->x);
fp_copy(r->y, t);
fp_set_dig(r->z, 1);
r->norm = 1;
}
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
fp_free(t);
}
return result;
}
int ep_is_valid(const ep_t p) {
ep_t t;
int r = 0;
ep_null(t);
TRY {
ep_new(t);
ep_norm(t, p);
ep_rhs(t->x, t);
fp_sqr(t->y, t->y);
r = (fp_cmp(t->x, t->y) == CMP_EQ) || ep_is_infty(p);
} CATCH_ANY {
THROW(ERR_CAUGHT);
} FINALLY {
ep_free(t);
}
return r;
}
void CEigenLSS::solve()
{
#ifdef CF_HAVE_TRILINOS
Timer timer;
const Uint nb_rows = size();
cf_assert(nb_rows == m_system_matrix.outerSize());
Epetra_SerialComm comm;
Epetra_Map map(nb_rows, 0, comm);
Epetra_Vector ep_rhs(View, map, m_rhs.data());
Epetra_Vector ep_sol(View, map, m_solution.data());
// Count non-zeros
std::vector<int> nnz(nb_rows, 0);
for(int row=0; row < nb_rows; ++row)
{
for(MatrixT::InnerIterator it(m_system_matrix, row); it; ++it)
{
++nnz[row];
}
cf_assert(nnz[row]);
}
Epetra_CrsMatrix ep_A(Copy, map, &nnz[0]);
time_matrix_construction = timer.elapsed(); timer.restart();
// Fill the matrix
for(int row=0; row < nb_rows; ++row)
{
std::vector<int> indices; indices.reserve(nnz[row]);
std::vector<Real> values; values.reserve(nnz[row]);
for(MatrixT::InnerIterator it(m_system_matrix, row); it; ++it)
{
indices.push_back(it.col());
values.push_back(it.value());
}
ep_A.InsertGlobalValues(row, nnz[row], &values[0], &indices[0]);
}
ep_A.FillComplete();
time_matrix_fill = timer.elapsed(); timer.restart();
///////////////////////////////////////////////////////////////////////////////////////////////
//BEGIN////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
Teuchos::RCP<Epetra_CrsMatrix> epetra_A=Teuchos::rcpFromRef(ep_A);
Teuchos::RCP<Epetra_Vector> epetra_x=Teuchos::rcpFromRef(ep_sol);
Teuchos::RCP<Epetra_Vector> epetra_b=Teuchos::rcpFromRef(ep_rhs);
const URI config_uri = option("config_file").value<URI>();
const std::string config_path = config_uri.path();
Stratimikos::DefaultLinearSolverBuilder linearSolverBuilder(config_path); // the most important in general setup
Teuchos::RCP<Teuchos::FancyOStream> out = Teuchos::VerboseObjectBase::getDefaultOStream(); // TODO: decouple from fancyostream to ostream or to C stdout when possible
typedef Teuchos::ParameterList::PrintOptions PLPrintOptions;
Teuchos::CommandLineProcessor clp(false); // false: don't throw exceptions
Teuchos::RCP<const Thyra::LinearOpBase<double> > A = Thyra::epetraLinearOp( epetra_A );
Teuchos::RCP<Thyra::VectorBase<double> > x = Thyra::create_Vector( epetra_x, A->domain() );
Teuchos::RCP<const Thyra::VectorBase<double> > b = Thyra::create_Vector( epetra_b, A->range() );
// r = b - A*x, initial L2 norm
double nrm_r=0.;
Real systemResidual=-1.;
{
Epetra_Vector epetra_r(*epetra_b);
Epetra_Vector epetra_A_x(epetra_A->OperatorRangeMap());
epetra_A->Apply(*epetra_x,epetra_A_x);
epetra_r.Update(-1.0,epetra_A_x,1.0);
epetra_r.Norm2(&nrm_r);
}
// Reading in the solver parameters from the parameters file and/or from
// the command line. This was setup by the command-line options
// set by the setupCLP(...) function above.
linearSolverBuilder.readParameters(0); // out.get() if want confirmation about the xml file within trilinos
Teuchos::RCP<Thyra::LinearOpWithSolveFactoryBase<double> > lowsFactory = linearSolverBuilder.createLinearSolveStrategy(""); // create linear solver strategy
lowsFactory->setVerbLevel(Teuchos::VERB_NONE); // set verbosity
// // print back default and current settings
// if (opts->trilinos.dumpDefault!=0) {
// fflush(stdout); cout << flush;
// _MMESSAGE_(0,1,"Dumping Trilinos/Stratimikos solver defaults to files: 'trilinos_default.txt' and 'trilinos_default.xml'...\n");
// fflush(stdout); cout << flush;
// std::ofstream ofs("./trilinos_default.txt");
// linearSolverBuilder.getValidParameters()->print(ofs,PLPrintOptions().indent(2).showTypes(true).showDoc(true)); // the last true-false is the deciding about whether printing documentation to option or not
// ofs.flush();ofs.close();
// ofs.open("./trilinos_default.xml");
// Teuchos::writeParameterListToXmlOStream(*linearSolverBuilder.getValidParameters(),ofs);
// ofs.flush();ofs.close();
// }
// if (opts->trilinos.dumpCurrXML!=0) {
// fflush(stdout); cout << flush;
// _MMESSAGE_(0,1,"Dumping Trilinos/Stratimikos current settings to file: 'trilinos_current.xml'...\n");
// fflush(stdout); cout << flush;
// linearSolverBuilder.writeParamsFile(*lowsFactory,"./trilinos_current.xml");
// }
time_solver_setup = timer.elapsed(); timer.restart();
// solve the matrix
Teuchos::RCP<Thyra::LinearOpWithSolveBase<double> > lows = Thyra::linearOpWithSolve(*lowsFactory, A); // create solver
Thyra::solve(*lows, Thyra::NOTRANS, *b, &*x); // solve
time_solve = timer.elapsed(); timer.restart();
// r = b - A*x, final L2 norm
{
Epetra_Vector epetra_r(*epetra_b);
Epetra_Vector epetra_A_x(epetra_A->OperatorRangeMap());
epetra_A->Apply(*epetra_x,epetra_A_x);
epetra_r.Update(-1.0,epetra_A_x,1.0);
systemResidual=1./nrm_r;
nrm_r=0.;
epetra_r.Norm2(&nrm_r);
systemResidual*=nrm_r;
}
time_residual = timer.elapsed();
///////////////////////////////////////////////////////////////////////////////////////////////
//END//////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
#else // no trilinos
#ifdef CF_HAVE_SUPERLU
Eigen::SparseMatrix<Real> A(m_system_matrix);
Eigen::SparseLU<Eigen::SparseMatrix<Real>,Eigen::SuperLU> lu_of_A(A);
if(!lu_of_A.solve(rhs(), &m_solution))
throw Common::FailedToConverge(FromHere(), "Solution failed.");
#else // no trilinos and no superlu
RealMatrix A(m_system_matrix);
Eigen::FullPivLU<RealMatrix> lu_of_A(A);
m_solution = lu_of_A.solve(m_rhs);
#endif // end ifdef superlu
#endif // end ifdef trilinos
}
