void generate_puzzle(int puzz_typ)
{
initializeGame();
if(puzz_typ == 1) Problem(5,6);
if(puzz_typ == 2) Problem(3,4);
if(puzz_typ == 3) Problem(2,3);
int i,j,k,x,y;
for(i=0 ; i<9 ; i++)
for(j=0 ; j<9 ; j++)
{ arr[9][9]=puzz[9][9]=stat[9][9]=hnt[9][9]=0; }
for(i=0 ; i<9 ; i++) // convert 3-d to 2-d
for(j=0 ; j<3 ; j++)
{
x = ((i/3)*3) + j;
for(k=0 ; k<3 ; k++)
{
y = ((i%3)*3 ) + k;
puzz[x][y] = Solution[i][j][k];
stat[x][y] = arr[x][y] = Sudoku[i][j][k];
}
}
}
Problem read_problem(std::string const path) {
if(path.empty())
return Problem(0, 0);
Problem prob(get_nr_line(path), get_nr_field(path));
FILE *f = open_c_file(path.c_str(), "r");
char line[kMaxLineSize];
uint64_t p = 0;
for(uint32_t i = 0; fgets(line, kMaxLineSize, f) != nullptr; ++i) {
char *y_char = strtok(line, " \t");
float const y = (atoi(y_char)>0)? 1.0f : -1.0f;
prob.Y[i] = y;
for(; ; ++p) {
char *idx_char = strtok(nullptr," \t");
if(idx_char == nullptr || *idx_char == '\n') break;
uint32_t idx = static_cast<uint32_t>(atoi(idx_char));
prob.nr_feature = std::max(prob.nr_feature, idx);
prob.J[p] = idx-1;
}
}
fclose(f);
return prob;
}
QValueList<Problem> cloneProblemList( const QValueList<Problem>& list ) {
QValueList<Problem> ret;
for( QValueList<Problem>::const_iterator it = list.begin(); it != list.end(); ++it ) {
ret << Problem( *it, true );
}
return ret;
}
// ======================================================================
int CompareBlockSizes(string PrecType, const Teuchos::RefCountPtr<Epetra_RowMatrix>& A, int NumParts)
{
Epetra_MultiVector RHS(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector LHS(A->RowMatrixRowMap(), NumVectors);
LHS.PutScalar(0.0); RHS.Random();
Epetra_LinearProblem Problem(&*A, &LHS, &RHS);
Teuchos::ParameterList List;
List.set("relaxation: damping factor", 1.0);
List.set("relaxation: type", PrecType);
List.set("relaxation: sweeps",1);
List.set("partitioner: type", "linear");
List.set("partitioner: local parts", NumParts);
RHS.PutScalar(1.0);
LHS.PutScalar(0.0);
Ifpack_BlockRelaxation<Ifpack_SparseContainer<Ifpack_Amesos> > Prec(&*A);
Prec.SetParameters(List);
Prec.Compute();
// set AztecOO solver object
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,Solver);
if (verbose)
AztecOOSolver.SetAztecOption(AZ_output,32);
else
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetPrecOperator(&Prec);
AztecOOSolver.Iterate(2550,1e-5);
return(AztecOOSolver.NumIters());
}
bool DatasetsCountValidator::validate(const Actor *actor, ProblemList &problemList, const QMap<QString, QString> &options) const {
int min = minimum(options);
int max = maximum(options);
QString attrId = attributeId(options);
QList<Dataset> sets = getValue< QList<Dataset> >(actor, attrId);
bool result = true;
if (sets.size() < min) {
problemList << Problem(QObject::tr("The minimum datasets count is %1. The current count is %2").arg(min).arg(sets.size()));
result = false;
}
if (sets.size() > max) {
problemList << Problem(QObject::tr("The maximum datasets count is %1. The current count is %2").arg(max).arg(sets.size()));
result = false;
}
return result;
}
virtual bool validate(const Configuration* cfg, ProblemList &problemList) const {
QString annotations = cfg->getParameter(ANN_ATTR)->getAttributeValueWithoutScript<QString>();
QSet<QString> names = QSet<QString>::fromList(annotations.split(QRegExp("\\W+"), QString::SkipEmptyParts));
if (names.size() < 2) {
problemList.append(Problem(CollocationWorker::tr("At least 2 annotations are required for collocation search.")));
return false;
}
return true;
}
// ======================================================================
bool BasicTest(string PrecType, const Teuchos::RefCountPtr<Epetra_RowMatrix>& A,bool backward, bool reorder=false)
{
Epetra_MultiVector LHS(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector RHS(A->RowMatrixRowMap(), NumVectors);
LHS.PutScalar(0.0); RHS.Random();
double starting_residual = Galeri::ComputeNorm(&*A, &LHS, &RHS);
Epetra_LinearProblem Problem(&*A, &LHS, &RHS);
// Set up the list
Teuchos::ParameterList List;
List.set("relaxation: damping factor", 1.0);
List.set("relaxation: sweeps",2550);
List.set("relaxation: type", PrecType);
if(backward) List.set("relaxation: backward mode",backward);
// Reordering if needed
int NumRows=A->NumMyRows();
std::vector<int> RowList(NumRows);
if(reorder) {
for(int i=0; i<NumRows; i++)
RowList[i]=i;
List.set("relaxation: number of local smoothing indices",NumRows);
List.set("relaxation: local smoothing indices",RowList.size()>0? &RowList[0] : (int*)0);
}
Ifpack_PointRelaxation Point(&*A);
Point.SetParameters(List);
Point.Compute();
// use the preconditioner as solver, with 1550 iterations
Point.ApplyInverse(RHS,LHS);
// compute the real residual
double residual = Galeri::ComputeNorm(&*A, &LHS, &RHS);
if (A->Comm().MyPID() == 0 && verbose)
cout << "||A * x - b||_2 (scaled) = " << residual / starting_residual << endl;
// Jacobi is very slow to converge here
if (residual / starting_residual < 1e-2) {
if (verbose)
cout << "BasicTest Test passed" << endl;
return(true);
}
else {
if (verbose)
cout << "BasicTest Test failed!" << endl;
return(false);
}
}
bool Test(const Teuchos::RefCountPtr<Epetra_RowMatrix>& Matrix, Teuchos::ParameterList& List)
{
int NumVectors = 1;
bool UseTranspose = false;
Epetra_MultiVector LHS(Matrix->OperatorDomainMap(),NumVectors);
Epetra_MultiVector RHS(Matrix->OperatorRangeMap(),NumVectors);
Epetra_MultiVector LHSexact(Matrix->OperatorDomainMap(),NumVectors);
LHS.PutScalar(0.0);
LHSexact.Random();
Matrix->Multiply(UseTranspose,LHSexact,RHS);
Epetra_LinearProblem Problem(&*Matrix,&LHS,&RHS);
Teuchos::RefCountPtr<T> Prec;
Prec = Teuchos::rcp( new T(&*Matrix) );
assert(Prec != Teuchos::null);
IFPACK_CHK_ERR(Prec->SetParameters(List));
IFPACK_CHK_ERR(Prec->Initialize());
IFPACK_CHK_ERR(Prec->Compute());
// create the AztecOO solver
AztecOO AztecOOSolver(Problem);
// specify solver
AztecOOSolver.SetAztecOption(AZ_solver,AZ_gmres);
AztecOOSolver.SetAztecOption(AZ_output,32);
AztecOOSolver.SetPrecOperator(&*Prec);
// solver. The solver should converge in one iteration,
// or maximum two (numerical errors)
AztecOOSolver.Iterate(1550,1e-8);
cout << *Prec;
vector<double> Norm(NumVectors);
LHS.Update(1.0,LHSexact,-1.0);
LHS.Norm2(&Norm[0]);
for (int i = 0 ; i < NumVectors ; ++i) {
cout << "Norm[" << i << "] = " << Norm[i] << endl;
if (Norm[i] > 1e-3)
return(false);
}
return(true);
}
bool validate(const IntegralBusPort *port, ProblemList &problemList) const {
QVariant busMap = port->getParameter(Workflow::IntegralBusPort::BUS_MAP_ATTR_ID)->getAttributePureValue();
bool data = isBinded(busMap.value<QStrStrMap>(), READS_URL_SLOT_ID);
if (!data){
QString dataName = slotName(port, READS_URL_SLOT_ID);
problemList.append(Problem(GenomeAlignerWorker::tr("The slot must be not empty: '%1'").arg(dataName)));
return false;
}
QString slot1Val = busMap.value<QStrStrMap>().value(READS_URL_SLOT_ID);
QString slot2Val = busMap.value<QStrStrMap>().value(READS_PAIRED_URL_SLOT_ID);
U2OpStatusImpl os;
const QList<IntegralBusSlot>& slots1 = IntegralBusSlot::listFromString(slot1Val, os);
const QList<IntegralBusSlot>& slots2 = IntegralBusSlot::listFromString(slot2Val, os);
bool hasCommonElements = false;
foreach(const IntegralBusSlot& ibsl1, slots1){
if (hasCommonElements){
break;
}
foreach(const IntegralBusSlot& ibsl2, slots2){
if (ibsl1 == ibsl2){
hasCommonElements = true;
break;
}
}
}
if (hasCommonElements){
problemList.append(Problem(GenomeAlignerWorker::tr("Bowtie2 cannot recognize read pairs from the same file. Please, perform demultiplexing first.")));
return false;
}
return true;
}
Problem read_problem(std::string const path)
{
if(path.empty())
return Problem();
Problem prob;
FILE *f = open_c_file(path.c_str(), "r");
char line[kMaxLineSize];
uint64_t p = 0;
prob.P.push_back(0);
for(uint32_t i = 0; fgets(line, kMaxLineSize, f) != nullptr; ++i, ++prob.nr_instance)
{
char *y_char = strtok(line, " \t");
float const y = (atoi(y_char)>0)? 1.0f : -1.0f;
prob.Y.push_back(y);
for(; ; ++p)
{
char *field_char = strtok(nullptr,":");
char *idx_char = strtok(nullptr,":");
char *value_char = strtok(nullptr," \t");
if(field_char == nullptr || *field_char == '\n')
break;
uint32_t const field = static_cast<uint32_t>(atoi(field_char));
uint32_t const idx = static_cast<uint32_t>(atoi(idx_char));
float const value = static_cast<float>(atof(value_char));
prob.nr_field = std::max(prob.nr_field, field);
prob.nr_feature = std::max(prob.nr_feature, idx);
prob.JFV.push_back(DNode(field-1, idx-1, value));
}
prob.P.push_back(p);
}
fclose(f);
return prob;
}
// ======================================================================
int AllSingle(const Teuchos::RefCountPtr<Epetra_RowMatrix>& A, Teuchos::RCP<Epetra_MultiVector> coord)
{
Epetra_MultiVector LHS(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector RHS(A->RowMatrixRowMap(), NumVectors);
LHS.PutScalar(0.0); RHS.Random();
Epetra_LinearProblem Problem(&*A, &LHS, &RHS);
Teuchos::ParameterList List;
List.set("relaxation: damping factor", 1.0);
List.set("relaxation: type", "symmetric Gauss-Seidel");
List.set("relaxation: sweeps",1);
List.set("partitioner: overlap",0);
List.set("partitioner: type", "line");
List.set("partitioner: line detection threshold",1.0);
List.set("partitioner: x-coordinates",&(*coord)[0][0]);
List.set("partitioner: y-coordinates",&(*coord)[1][0]);
List.set("partitioner: z-coordinates",(double*) 0);
RHS.PutScalar(1.0);
LHS.PutScalar(0.0);
Ifpack_BlockRelaxation<Ifpack_SparseContainer<Ifpack_Amesos> > Prec(&*A);
Prec.SetParameters(List);
Prec.Compute();
// set AztecOO solver object
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,Solver);
if (verbose)
AztecOOSolver.SetAztecOption(AZ_output,32);
else
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetPrecOperator(&Prec);
AztecOOSolver.Iterate(2550,1e-5);
printf(" AllSingle iters %d \n",AztecOOSolver.NumIters());
return(AztecOOSolver.NumIters());
}
// ======================================================================
int CompareLineSmootherEntries(const Teuchos::RefCountPtr<Epetra_RowMatrix>& A)
{
Epetra_MultiVector LHS(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector RHS(A->RowMatrixRowMap(), NumVectors);
LHS.PutScalar(0.0); RHS.Random();
Epetra_LinearProblem Problem(&*A, &LHS, &RHS);
Teuchos::ParameterList List;
List.set("relaxation: damping factor", 1.0);
List.set("relaxation: type", "symmetric Gauss-Seidel");
List.set("relaxation: sweeps",1);
List.set("partitioner: overlap",0);
List.set("partitioner: type", "line");
List.set("partitioner: line mode","matrix entries");
List.set("partitioner: line detection threshold",10.0);
RHS.PutScalar(1.0);
LHS.PutScalar(0.0);
Ifpack_BlockRelaxation<Ifpack_SparseContainer<Ifpack_Amesos> > Prec(&*A);
Prec.SetParameters(List);
Prec.Compute();
// set AztecOO solver object
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,Solver);
if (verbose)
AztecOOSolver.SetAztecOption(AZ_output,32);
else
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetPrecOperator(&Prec);
AztecOOSolver.Iterate(2550,1e-5);
return(AztecOOSolver.NumIters());
}
int stogo_minimize(int n,
objective_func fgrad, void *data,
double *x, double *minf,
const double *l, const double *u,
#ifdef NLOPT_UTIL_H
nlopt_stopping *stop,
#else
long int maxeval, double maxtime,
#endif
int nrandom)
{
GlobalParams params;
// FIXME: WTF do these parameters mean?
params.rnd_pnts=nrandom;
params.det_pnts=2*n+1 - nrandom;
params.eps_cl=0.1; params.rshift=0.3;
params.mu=1.0E-4;
params.stop = stop;
TBox D(n);
for (int i = 0; i < n; ++i) {
D.lb(i) = l[i];
D.ub(i) = u[i];
}
MyGlobal Problem(D, params, fgrad, data);
RVector dummyvec(n);
Problem.Search(-1, dummyvec);
if (Problem.NoMinimizers())
return 0;
*minf = Problem.OneMinimizer(dummyvec);
for (int i = 0; i < n; ++i) x[i] = dummyvec(i);
return 1;
}
int main(int argc, char *argv[])
{
#ifdef ML_MPI
MPI_Init(&argc,&argv);
// This next bit of code drops a middle rank out of the calculation. This tests
// that the Hiptmair smoother does not hang in its apply. Hiptmair creates
// two separate ML objects, one for edge and one for nodes. By default, the ML
// objects use MPI_COMM_WORLD, whereas the matrix that Hiptmair is being applied to
// may have an MPI subcommunicator.
int commWorldSize;
MPI_Comm_size(MPI_COMM_WORLD,&commWorldSize);
std::vector<int> splitKey;
int rankToDrop = 1;
for (int i=0; i<commWorldSize; ++i)
splitKey.push_back(0);
splitKey[rankToDrop] = MPI_UNDEFINED; //drop the last process from subcommunicator
int myrank;
MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
MPI_Comm subcomm;
MPI_Comm_split(MPI_COMM_WORLD, splitKey[myrank], myrank, &subcomm);
if (myrank == rankToDrop) goto droppedRankLabel;
#endif
{ //scoping to avoid compiler error about goto jumping over initialization
#ifdef ML_MPI
Epetra_MpiComm Comm(subcomm);
#else
Epetra_SerialComm Comm;
#endif
ML_Comm_Create(&mlcomm);
char *datafile;
#ifdef CurlCurlAndMassAreSeparate
if (argc != 5 && argc != 7) {
if (Comm.MyPID() == 0) {
std::cout << "usage: ml_maxwell.exe <S> <M> <T> <Kn> [edge map] [node map]"
<< std::endl;
std::cout << " S = edge stiffness matrix file" << std::endl;
std::cout << " M = edge mass matrix file" << std::endl;
std::cout << " T = discrete gradient file" << std::endl;
std::cout << " Kn = auxiliary nodal FE matrix file" << std::endl;
std::cout << " edge map = edge distribution over processors" << std::endl;
std::cout << " node map = node distribution over processors" << std::endl;
std::cout << argc << std::endl;
}
#else //ifdef CurlCurlAndMassAreSeparate
if (argc != 4 && argc != 6) {
if (Comm.MyPID() == 0) {
std::cout << "usage: ml_maxwell.exe <A> <T> <Kn> [edge map] [node map]" <<std::endl;
std::cout << " A = edge element matrix file" << std::endl;
std::cout << " T = discrete gradient file" << std::endl;
std::cout << " Kn = auxiliary nodal FE matrix file" << std::endl;
std::cout << " edge map = edge distribution over processors" << std::endl;
std::cout << " node map = node distribution over processors" << std::endl;
std::cout << argc << std::endl;
}
#endif //ifdef CurlCurlAndMassAreSeparate
#ifdef ML_MPI
MPI_Finalize();
#endif
exit(1);
}
Epetra_Map *edgeMap, *nodeMap;
Epetra_CrsMatrix *CCplusM=NULL, *CurlCurl=NULL, *Mass=NULL, *T=NULL, *Kn=NULL;
// ================================================= //
// READ IN MAPS FROM FILE //
// ================================================= //
// every processor reads this in
#ifdef CurlCurlAndMassAreSeparate
if (argc > 5)
#else
if (argc > 4)
#endif
{
datafile = argv[5];
if (Comm.MyPID() == 0) {
printf("Reading in edge map from %s ...\n",datafile);
fflush(stdout);
}
EpetraExt::MatrixMarketFileToMap(datafile, Comm, edgeMap);
datafile = argv[6];
if (Comm.MyPID() == 0) {
printf("Reading in node map from %s ...\n",datafile);
fflush(stdout);
}
EpetraExt::MatrixMarketFileToMap(datafile, Comm, nodeMap);
}
else { // linear maps
// Read the T matrix to determine the map sizes
// and then construct linear maps
if (Comm.MyPID() == 0)
printf("Using linear edge and node maps ...\n");
const int lineLength = 1025;
char line[lineLength];
FILE *handle;
int M,N,NZ;
#ifdef CurlCurlAndMassAreSeparate
handle = fopen(argv[3],"r");
#else
handle = fopen(argv[2],"r");
#endif
if (handle == 0) EPETRA_CHK_ERR(-1); // file not found
// Strip off header lines (which start with "%")
do {
if(fgets(line, lineLength, handle)==0) {if (handle!=0) fclose(handle);}
} while (line[0] == '%');
// Get problem dimensions: M, N, NZ
if(sscanf(line,"%d %d %d", &M, &N, &NZ)==0) {if (handle!=0) fclose(handle);}
fclose(handle);
edgeMap = new Epetra_Map(M,0,Comm);
nodeMap = new Epetra_Map(N,0,Comm);
}
// ===================================================== //
// READ IN MATRICES FROM FILE //
// ===================================================== //
#ifdef CurlCurlAndMassAreSeparate
for (int i = 1; i <5; i++) {
datafile = argv[i];
if (Comm.MyPID() == 0) {
printf("reading %s ....\n",datafile); fflush(stdout);
}
switch (i) {
case 1: //Curl
MatrixMarketFileToCrsMatrix(datafile,*edgeMap,*edgeMap,*edgeMap,CurlCurl);
break;
case 2: //Mass
MatrixMarketFileToCrsMatrix(datafile, *edgeMap, *edgeMap, *edgeMap, Mass);
break;
case 3: //Gradient
MatrixMarketFileToCrsMatrix(datafile, *edgeMap, *edgeMap,*nodeMap, T);
break;
case 4: //Auxiliary nodal matrix
MatrixMarketFileToCrsMatrix(datafile, *nodeMap,*nodeMap, *nodeMap, Kn);
break;
} //switch
} //for (int i = 1; i <5; i++)
#else
for (int i = 1; i <4; i++) {
datafile = argv[i];
if (Comm.MyPID() == 0) {
printf("reading %s ....\n",datafile); fflush(stdout);
}
switch (i) {
case 1: //Edge element matrix
MatrixMarketFileToCrsMatrix(datafile,*edgeMap,*edgeMap,*edgeMap,CCplusM);
break;
case 2: //Gradient
MatrixMarketFileToCrsMatrix(datafile, *edgeMap, *edgeMap, *nodeMap, T);
break;
case 3: //Auxiliary nodal matrix
MatrixMarketFileToCrsMatrix(datafile, *nodeMap, *nodeMap, *nodeMap, Kn);
break;
} //switch
} //for (int i = 1; i <4; i++)
#endif //ifdef CurlCurlAndMassAreSeparate
// ==================================================== //
// S E T U P O F M L P R E C O N D I T I O N E R //
// ==================================================== //
Teuchos::ParameterList MLList;
int *options = new int[AZ_OPTIONS_SIZE];
double *params = new double[AZ_PARAMS_SIZE];
ML_Epetra::SetDefaults("maxwell", MLList, options, params);
MLList.set("ML output", 10);
MLList.set("aggregation: type", "Uncoupled");
MLList.set("coarse: max size", 15);
MLList.set("aggregation: threshold", 0.0);
//MLList.set("negative conductivity",true);
//MLList.set("smoother: type", "Jacobi");
MLList.set("subsmoother: type", "symmetric Gauss-Seidel");
//MLList.set("max levels", 2);
// coarse level solve
MLList.set("coarse: type", "Amesos-KLU");
//MLList.set("coarse: type", "Hiptmair");
//MLList.set("coarse: type", "Jacobi");
//MLList.set("dump matrix: enable", true);
#ifdef CurlCurlAndMassAreSeparate
//Create the matrix of interest.
CCplusM = Epetra_MatrixAdd(CurlCurl,Mass,1.0);
#endif
#ifdef CurlCurlAndMassAreSeparate
ML_Epetra::MultiLevelPreconditioner * MLPrec =
new ML_Epetra::MultiLevelPreconditioner(*CurlCurl, *Mass, *T, *Kn, MLList);
// Comment out the line above and uncomment the next one if you have
// mass and curl separately but want to precondition as if they are added
// together.
/*
ML_Epetra::MultiLevelPreconditioner * MLPrec =
new ML_Epetra::MultiLevelPreconditioner(*CCplusM, *T, *Kn, MLList);
*/
#else
ML_Epetra::MultiLevelPreconditioner * MLPrec =
new ML_Epetra::MultiLevelPreconditioner(*CCplusM, *T, *Kn, MLList);
#endif //ifdef CurlCurlAndMassAreSeparate
MLPrec->PrintUnused(0);
// ========================================================= //
// D E F I N I T I O N O F A Z T E C O O P R O B L E M //
// ========================================================= //
// create left-hand side and right-hand side, and populate them with
// data from file. Both vectors are defined on the domain map of the
// edge matrix.
// Epetra_Vectors can be created in View mode, to accept pointers to
// double vectors.
if (Comm.MyPID() == 0)
std::cout << "Putting in a zero initial guess and random rhs (in the range of S+M)" << std::endl;
Epetra_Vector x(CCplusM->DomainMap());
x.Random();
Epetra_Vector rhs(CCplusM->DomainMap());
CCplusM->Multiply(false,x,rhs);
x.PutScalar(0.0);
double vecnorm;
rhs.Norm2(&vecnorm);
if (Comm.MyPID() == 0) std::cout << "||rhs|| = " << vecnorm << std::endl;
x.Norm2(&vecnorm);
if (Comm.MyPID() == 0) std::cout << "||x|| = " << vecnorm << std::endl;
// for AztecOO, we need an Epetra_LinearProblem
Epetra_LinearProblem Problem(CCplusM,&x,&rhs);
// AztecOO Linear problem
AztecOO solver(Problem);
// set MLPrec as precondititoning operator for AztecOO linear problem
//std::cout << "no ml preconditioner!!!" << std::endl;
solver.SetPrecOperator(MLPrec);
//solver.SetAztecOption(AZ_precond, AZ_Jacobi);
// a few options for AztecOO
solver.SetAztecOption(AZ_solver, AZ_cg);
solver.SetAztecOption(AZ_output, 1);
solver.Iterate(15, 1e-3);
// =============== //
// C L E A N U P //
// =============== //
delete MLPrec; // destroy phase prints out some information
delete CurlCurl;
delete CCplusM;
delete Mass;
delete T;
delete Kn;
delete nodeMap;
delete edgeMap;
delete [] params;
delete [] options;
ML_Comm_Destroy(&mlcomm);
} //avoids compiler error about jumping over initialization
droppedRankLabel:
#ifdef ML_MPI
MPI_Finalize();
#endif
return 0;
} //main
#else
#include <stdlib.h>
#include <stdio.h>
#ifdef HAVE_MPI
#include "mpi.h"
#endif
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
#endif
puts("Please configure ML with:");
#if !defined(HAVE_ML_EPETRA)
puts("--enable-epetra");
#endif
#if !defined(HAVE_ML_TEUCHOS)
puts("--enable-teuchos");
#endif
#if !defined(HAVE_ML_EPETRAEXT)
puts("--enable-epetraext");
#endif
#if !defined(HAVE_ML_AZTECOO)
puts("--enable-aztecoo");
#endif
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return 0;
}
int main(int argc, char *argv[])
{
// initialize MPI and Epetra communicator
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
Epetra_SerialComm Comm;
#endif
Teuchos::ParameterList GaleriList;
// The problem is defined on a 2D grid, global size is nx * nx.
int nx = 30;
GaleriList.set("nx", nx);
GaleriList.set("ny", nx * Comm.NumProc());
GaleriList.set("mx", 1);
GaleriList.set("my", Comm.NumProc());
Teuchos::RefCountPtr<Epetra_Map> Map = Teuchos::rcp( Galeri::CreateMap("Cartesian2D", Comm, GaleriList) );
Teuchos::RefCountPtr<Epetra_RowMatrix> A = Teuchos::rcp( Galeri::CreateCrsMatrix("Laplace2D", &*Map, GaleriList) );
// =============================================================== //
// B E G I N N I N G O F I F P A C K C O N S T R U C T I O N //
// =============================================================== //
Teuchos::ParameterList List;
// allocates an IFPACK factory. No data is associated
// to this object (only method Create()).
Ifpack Factory;
// create the preconditioner. For valid PrecType values,
// please check the documentation
std::string PrecType = "Amesos";
int OverlapLevel = 2; // must be >= 0. If Comm.NumProc() == 1,
// it is ignored.
Teuchos::RefCountPtr<Ifpack_Preconditioner> Prec = Teuchos::rcp( Factory.Create(PrecType, &*A, OverlapLevel) );
assert(Prec != Teuchos::null);
// specify the Amesos solver to be used.
// If the selected solver is not available,
// IFPACK will try to use Amesos' KLU (which is usually always
// compiled). Amesos' serial solvers are:
// "Amesos_Klu", "Amesos_Umfpack", "Amesos_Superlu"
List.set("amesos: solver type", "Amesos_Klu");
// sets the parameters
IFPACK_CHK_ERR(Prec->SetParameters(List));
// initialize the preconditioner. At this point the matrix must
// have been FillComplete()'d, but actual values are ignored.
// At this call, Amesos will perform the symbolic factorization.
IFPACK_CHK_ERR(Prec->Initialize());
// Builds the preconditioners, by looking for the values of
// the matrix. At this call, Amesos will perform the
// numeric factorization.
IFPACK_CHK_ERR(Prec->Compute());
// =================================================== //
// E N D O F I F P A C K C O N S T R U C T I O N //
// =================================================== //
// At this point, we need some additional objects
// to define and solve the linear system.
// defines LHS and RHS
Epetra_Vector LHS(A->OperatorDomainMap());
Epetra_Vector RHS(A->OperatorDomainMap());
// solution is constant
LHS.PutScalar(1.0);
// now build corresponding RHS
A->Apply(LHS,RHS);
// now randomize the solution
RHS.Random();
// need an Epetra_LinearProblem to define AztecOO solver
Epetra_LinearProblem Problem(&*A,&LHS,&RHS);
// now we can allocate the AztecOO solver
AztecOO Solver(Problem);
// specify solver
Solver.SetAztecOption(AZ_solver,AZ_gmres);
Solver.SetAztecOption(AZ_output,32);
// HERE WE SET THE IFPACK PRECONDITIONER
Solver.SetPrecOperator(&*Prec);
// .. and here we solve
// NOTE: with one process, the solver must converge in
// one iteration.
Solver.Iterate(1550,1e-8);
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return(EXIT_SUCCESS);
}
int testTransposeSolve(
int NumGlobalElements,
int nRHS,
double reltol,
double abstol,
Epetra_Comm& Comm,
const Teuchos::RCP<LOCA::GlobalData>& globalData,
const Teuchos::RCP<Teuchos::ParameterList>& paramList)
{
int ierr = 0;
double left_bc = 0.0;
double right_bc = 1.0;
double nonlinear_factor = 1.0;
// Create the FiniteElementProblem class. This creates all required
// Epetra objects for the problem and allows calls to the
// function (RHS) and Jacobian evaluation routines.
Tcubed_FiniteElementProblem Problem(NumGlobalElements, Comm);
// Get the vector from the Problem
Epetra_Vector& soln = Problem.getSolution();
// Initialize Solution
soln.PutScalar(0.0);
// Create and initialize the parameter vector
LOCA::ParameterVector pVector;
pVector.addParameter("Nonlinear Factor",nonlinear_factor);
pVector.addParameter("Left BC", left_bc);
pVector.addParameter("Right BC", right_bc);
// Create the interface between the test problem and the nonlinear solver
// This is created by the user using inheritance of the abstract base
// class:
Teuchos::RCP<Problem_Interface> interface =
Teuchos::rcp(new Problem_Interface(Problem));
Teuchos::RCP<LOCA::Epetra::Interface::Required> iReq = interface;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac = interface;
// Create the Epetra_RowMatrixfor the Jacobian/Preconditioner
Teuchos::RCP<Epetra_RowMatrix> Amat =
Teuchos::rcp(&Problem.getJacobian(),false);
// Get sublists
Teuchos::ParameterList& nlParams = paramList->sublist("NOX");
Teuchos::ParameterList& nlPrintParams = nlParams.sublist("Printing");
Teuchos::ParameterList& dirParams = nlParams.sublist("Direction");
Teuchos::ParameterList& newParams = dirParams.sublist("Newton");
Teuchos::ParameterList& lsParams = newParams.sublist("Linear Solver");
// Create the linear systems
Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(nlPrintParams,
lsParams, iReq, iJac,
Amat, soln));
// Create the loca vector
NOX::Epetra::Vector locaSoln(soln);
// Create the Group
Teuchos::RCP<LOCA::Epetra::Group> grp_tp =
Teuchos::rcp(new LOCA::Epetra::Group(globalData, nlPrintParams,
iReq, locaSoln,
linsys, pVector));
// Create the Group
Teuchos::RCP<LOCA::Epetra::Group> grp_lp =
Teuchos::rcp(new LOCA::Epetra::Group(globalData, nlPrintParams,
iReq, locaSoln,
linsys, pVector));
// Create the Group
Teuchos::RCP<LOCA::Epetra::Group> grp_ep =
Teuchos::rcp(new LOCA::Epetra::Group(globalData, nlPrintParams,
iReq, locaSoln,
linsys, pVector));
// Change initial guess to a random vector
Teuchos::RCP<NOX::Abstract::Vector> xnew =
grp_tp->getX().clone();
xnew->random();
grp_tp->setX(*xnew);
grp_lp->setX(*xnew);
grp_ep->setX(*xnew);
// Check some statistics on the solution
Teuchos::RCP<NOX::TestCompare> testCompare =
Teuchos::rcp(new NOX::TestCompare(globalData->locaUtils->out(),
*(globalData->locaUtils)));
// Evaluate blocks
grp_tp->computeF();
grp_lp->computeF();
grp_ep->computeF();
grp_tp->computeJacobian();
grp_lp->computeJacobian();
grp_ep->computeJacobian();
// Set up left- and right-hand sides
Teuchos::RCP<NOX::Abstract::MultiVector> F =
grp_tp->getX().createMultiVector(nRHS);
F->random();
Teuchos::RCP<NOX::Abstract::MultiVector> X_tp =
F->clone(NOX::ShapeCopy);
X_tp->init(0.0);
Teuchos::RCP<NOX::Abstract::MultiVector> X_lp =
F->clone(NOX::ShapeCopy);
X_lp->init(0.0);
Teuchos::RCP<NOX::Abstract::MultiVector> X_ep =
F->clone(NOX::ShapeCopy);
X_ep->init(0.0);
// Set up residuals
Teuchos::RCP<NOX::Abstract::MultiVector> R_tp =
F->clone(NOX::ShapeCopy);
Teuchos::RCP<NOX::Abstract::MultiVector> R_lp =
F->clone(NOX::ShapeCopy);
Teuchos::RCP<NOX::Abstract::MultiVector> R_ep =
F->clone(NOX::ShapeCopy);
// Set up linear solver lists
Teuchos::ParameterList lsParams_tp = lsParams;
Teuchos::ParameterList lsParams_lp = lsParams;
Teuchos::ParameterList lsParams_ep = lsParams;
lsParams_tp.set("Transpose Solver Method",
"Transpose Preconditioner");
lsParams_lp.set("Transpose Solver Method",
"Left Preconditioning");
lsParams_ep.set("Transpose Solver Method",
"Explicit Transpose");
NOX::Abstract::Group::ReturnType status;
// Test transpose solve with transposed preconditioner
if (globalData->locaUtils->isPrintType(NOX::Utils::TestDetails))
globalData->locaUtils->out() << std::endl <<
"\t***** " <<
"Testing Transposed Preconditioner Residual" <<
" *****" << std::endl;
status = grp_tp->applyJacobianTransposeInverseMultiVector(lsParams_tp, *F,
*X_tp);
if (status == NOX::Abstract::Group::Failed)
++ierr;
status = grp_tp->applyJacobianTransposeMultiVector(*X_tp, *R_tp);
ierr += testCompare->testMultiVector(*R_tp, *F, reltol, abstol,
"Residual");
// Test transpose solve with transposed left-preconditioner
if (lsParams.get("Preconditioner", "None") != "None") {
if (globalData->locaUtils->isPrintType(NOX::Utils::TestDetails))
globalData->locaUtils->out() << std::endl <<
"\t***** " <<
"Testing Transposed Left Preconditioner Residual" <<
" *****" << std::endl;
status = grp_lp->applyJacobianTransposeInverseMultiVector(lsParams_lp, *F,
*X_lp);
if (status == NOX::Abstract::Group::Failed)
++ierr;
status = grp_lp->applyJacobianTransposeMultiVector(*X_lp, *R_lp);
ierr += testCompare->testMultiVector(*R_lp, *F, reltol, abstol,
"Residual");
}
#ifdef HAVE_NOX_EPETRAEXT
// Test transpose solve with explicit preconditioner
if (globalData->locaUtils->isPrintType(NOX::Utils::TestDetails))
globalData->locaUtils->out() << std::endl <<
"\t***** " <<
"Testing Explicit Preconditioner Residual" <<
" *****" << std::endl;
status = grp_ep->applyJacobianTransposeInverseMultiVector(lsParams_ep, *F,
*X_ep);
if (status == NOX::Abstract::Group::Failed)
++ierr;
status = grp_ep->applyJacobianTransposeMultiVector(*X_ep, *R_ep);
ierr += testCompare->testMultiVector(*R_ep, *F, reltol, abstol,
"Residual");
#endif
// Compare solutions
if (lsParams.get("Preconditioner", "None") != "None") {
if (globalData->locaUtils->isPrintType(NOX::Utils::TestDetails))
globalData->locaUtils->out() << std::endl <<
"\t***** " <<
"Comparing Transposed Preconditioner and Left Preconditioner Solutions"
<<
" *****" << std::endl;
ierr += testCompare->testMultiVector(*X_lp, *X_tp,
reltol, abstol, "Solution");
}
#ifdef HAVE_NOX_EPETRAEXT
if (globalData->locaUtils->isPrintType(NOX::Utils::TestDetails))
globalData->locaUtils->out() << std::endl <<
"\t***** " <<
"Comparing Transposed Preconditioner and Explicit Preconditioner Solutions"
<<
" *****" << std::endl;
ierr += testCompare->testMultiVector(*X_ep, *X_tp,
reltol, abstol, "Solution");
#endif
return ierr;
}
int main(int argc, char *argv[])
{
// Initialize MPI
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
#endif
// Create a communicator for Epetra objects
#ifdef HAVE_MPI
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
Epetra_SerialComm Comm;
#endif
bool verbose = false;
if (argc > 1)
if (argv[1][0]=='-' && argv[1][1]=='v')
verbose = true;
// Get the process ID and the total number of processors
int MyPID = Comm.MyPID();
#ifdef HAVE_MPI
int NumProc = Comm.NumProc();
#endif
// define the parameters of the nonlinear PDE problem
int nx = 5;
int ny = 6;
double lambda = 1.0;
PDEProblem Problem(nx,ny,lambda,&Comm);
// starting solution, here a zero vector
Epetra_Vector InitialGuess(Problem.GetMatrix()->Map());
InitialGuess.PutScalar(0.0);
// random vector upon which to apply each operator being tested
Epetra_Vector directionVec(Problem.GetMatrix()->Map());
directionVec.Random();
// Set up the problem interface
Teuchos::RCP<SimpleProblemInterface> interface =
Teuchos::rcp(new SimpleProblemInterface(&Problem) );
// Set up theolver options parameter list
Teuchos::RCP<Teuchos::ParameterList> noxParamsPtr = Teuchos::rcp(new Teuchos::ParameterList);
Teuchos::ParameterList & noxParams = *(noxParamsPtr.get());
// Set the nonlinear solver method
noxParams.set("Nonlinear Solver", "Line Search Based");
// Set up the printing utilities
// Only print output if the "-v" flag is set on the command line
Teuchos::ParameterList& printParams = noxParams.sublist("Printing");
printParams.set("MyPID", MyPID);
printParams.set("Output Precision", 5);
printParams.set("Output Processor", 0);
if( verbose )
printParams.set("Output Information",
NOX::Utils::OuterIteration +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::InnerIteration +
NOX::Utils::Parameters +
NOX::Utils::Details +
NOX::Utils::Warning +
NOX::Utils::TestDetails);
else
printParams.set("Output Information", NOX::Utils::Error +
NOX::Utils::TestDetails);
NOX::Utils printing(printParams);
// Identify the test problem
if (printing.isPrintType(NOX::Utils::TestDetails))
printing.out() << "Starting epetra/NOX_Operators/NOX_Operators.exe" << std::endl;
// Identify processor information
#ifdef HAVE_MPI
if (printing.isPrintType(NOX::Utils::TestDetails)) {
printing.out() << "Parallel Run" << std::endl;
printing.out() << "Number of processors = " << NumProc << std::endl;
printing.out() << "Print Process = " << MyPID << std::endl;
}
Comm.Barrier();
if (printing.isPrintType(NOX::Utils::TestDetails))
printing.out() << "Process " << MyPID << " is alive!" << std::endl;
Comm.Barrier();
#else
if (printing.isPrintType(NOX::Utils::TestDetails))
printing.out() << "Serial Run" << std::endl;
#endif
int status = 0;
Teuchos::RCP<NOX::Epetra::Interface::Required> iReq = interface;
// Need a NOX::Epetra::Vector for constructor
NOX::Epetra::Vector noxInitGuess(InitialGuess, NOX::DeepCopy);
// Analytic matrix
Teuchos::RCP<Epetra_CrsMatrix> A = Teuchos::rcp( Problem.GetMatrix(), false );
Epetra_Vector A_resultVec(Problem.GetMatrix()->Map());
interface->computeJacobian( InitialGuess, *A );
A->Apply( directionVec, A_resultVec );
// FD operator
Teuchos::RCP<Epetra_CrsGraph> graph = Teuchos::rcp( const_cast<Epetra_CrsGraph*>(&A->Graph()), false );
Teuchos::RCP<NOX::Epetra::FiniteDifference> FD = Teuchos::rcp(
new NOX::Epetra::FiniteDifference(printParams, iReq, noxInitGuess, graph) );
Epetra_Vector FD_resultVec(Problem.GetMatrix()->Map());
FD->computeJacobian(InitialGuess, *FD);
FD->Apply( directionVec, FD_resultVec );
// Matrix-Free operator
Teuchos::RCP<NOX::Epetra::MatrixFree> MF = Teuchos::rcp(
new NOX::Epetra::MatrixFree(printParams, iReq, noxInitGuess) );
Epetra_Vector MF_resultVec(Problem.GetMatrix()->Map());
MF->computeJacobian(InitialGuess, *MF);
MF->Apply( directionVec, MF_resultVec );
// Need NOX::Epetra::Vectors for tests
NOX::Epetra::Vector noxAvec ( A_resultVec , NOX::DeepCopy );
NOX::Epetra::Vector noxFDvec( FD_resultVec, NOX::DeepCopy );
NOX::Epetra::Vector noxMFvec( MF_resultVec, NOX::DeepCopy );
// Create a TestCompare class
NOX::Epetra::TestCompare tester( printing.out(), printing);
double abstol = 1.e-4;
double reltol = 1.e-4 ;
//NOX::TestCompare::CompareType aComp = NOX::TestCompare::Absolute;
status += tester.testVector( noxFDvec, noxAvec, reltol, abstol,
"Finite-Difference Operator Apply Test" );
status += tester.testVector( noxMFvec, noxAvec, reltol, abstol,
"Matrix-Free Operator Apply Test" );
// Summarize test results
if( status == 0 )
printing.out() << "Test passed!" << std::endl;
else
printing.out() << "Test failed!" << std::endl;
#ifdef HAVE_MPI
MPI_Finalize();
#endif
// Final return value (0 = successfull, non-zero = failure)
return status;
}
// ======================================================================
bool KrylovTest(string PrecType, const Teuchos::RefCountPtr<Epetra_RowMatrix>& A, bool backward, bool reorder=false)
{
Epetra_MultiVector LHS(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector RHS(A->RowMatrixRowMap(), NumVectors);
LHS.PutScalar(0.0); RHS.Random();
Epetra_LinearProblem Problem(&*A, &LHS, &RHS);
// Set up the list
Teuchos::ParameterList List;
List.set("relaxation: damping factor", 1.0);
List.set("relaxation: type", PrecType);
if(backward) List.set("relaxation: backward mode",backward);
// Reordering if needed
int NumRows=A->NumMyRows();
std::vector<int> RowList(NumRows);
if(reorder) {
for(int i=0; i<NumRows; i++)
RowList[i]=i;
List.set("relaxation: number of local smoothing indices",NumRows);
List.set("relaxation: local smoothing indices",RowList.size()>0? &RowList[0] : (int*)0);
}
int Iters1, Iters10;
if (verbose) {
cout << "Krylov test: Using " << PrecType
<< " with AztecOO" << endl;
}
// ============================================== //
// get the number of iterations with 1 sweep only //
// ============================================== //
{
List.set("relaxation: sweeps",1);
Ifpack_PointRelaxation Point(&*A);
Point.SetParameters(List);
Point.Compute();
// set AztecOO solver object
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,Solver);
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetPrecOperator(&Point);
AztecOOSolver.Iterate(2550,1e-5);
double TrueResidual = AztecOOSolver.TrueResidual();
// some output
if (verbose && Problem.GetMatrix()->Comm().MyPID() == 0) {
cout << "Norm of the true residual = " << TrueResidual << endl;
}
Iters1 = AztecOOSolver.NumIters();
}
// ======================================================== //
// now re-run with 10 sweeps, solver should converge faster
// ======================================================== //
{
List.set("relaxation: sweeps",10);
Ifpack_PointRelaxation Point(&*A);
Point.SetParameters(List);
Point.Compute();
LHS.PutScalar(0.0);
// set AztecOO solver object
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,Solver);
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetPrecOperator(&Point);
AztecOOSolver.Iterate(2550,1e-5);
double TrueResidual = AztecOOSolver.TrueResidual();
// some output
if (verbose && Problem.GetMatrix()->Comm().MyPID() == 0) {
cout << "Norm of the true residual = " << TrueResidual << endl;
}
Iters10 = AztecOOSolver.NumIters();
}
if (verbose) {
cout << "Iters_1 = " << Iters1 << ", Iters_10 = " << Iters10 << endl;
cout << "(second number should be smaller than first one)" << endl;
}
if (Iters10 > Iters1) {
if (verbose)
cout << "KrylovTest TEST FAILED!" << endl;
return(false);
}
else {
if (verbose)
cout << "KrylovTest TEST PASSED" << endl;
return(true);
}
}
int main(int argc, char *argv[])
{
int nConstraints = 10;
int nRHS = 7;
double left_bc = 0.0;
double right_bc = 1.0;
double nonlinear_factor = 1.0;
int ierr = 0;
double reltol = 1.0e-8;
double abstol = 1.0e-8;
double lstol = 1.0e-11;
int MyPID = 0;
try {
// Initialize MPI
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
#endif
// Create a communicator for Epetra objects
#ifdef HAVE_MPI
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
Epetra_SerialComm Comm;
#endif
// Get the total number of processors
MyPID = Comm.MyPID();
int NumProc = Comm.NumProc();
bool verbose = false;
// Check for verbose output
if (argc>1)
if (argv[1][0]=='-' && argv[1][1]=='v')
verbose = true;
// Get the number of elements from the command line
int NumGlobalElements = 0;
if ((argc > 2) && (verbose))
NumGlobalElements = atoi(argv[2]) + 1;
else if ((argc > 1) && (!verbose))
NumGlobalElements = atoi(argv[1]) + 1;
else
NumGlobalElements = 101;
// The number of unknowns must be at least equal to the
// number of processors.
if (NumGlobalElements < NumProc) {
std::cout << "numGlobalBlocks = " << NumGlobalElements
<< " cannot be < number of processors = " << NumProc << std::endl;
exit(1);
}
// Seed the random number generator in Teuchos. We create random
// bordering matrices and it is possible different processors might generate
// different matrices. By setting the seed, this shouldn't happen.
Teuchos::ScalarTraits<double>::seedrandom(12345);
// Create parameter list
Teuchos::RCP<Teuchos::ParameterList> paramList =
Teuchos::rcp(new Teuchos::ParameterList);
// Create LOCA sublist
Teuchos::ParameterList& locaParamsList = paramList->sublist("LOCA");
// Create the constraints list
Teuchos::ParameterList& constraintsList =
locaParamsList.sublist("Constraints");
constraintsList.set("Bordered Solver Method", "Bordering");
// Create the "Solver" parameters sublist to be used with NOX Solvers
Teuchos::ParameterList& nlParams = paramList->sublist("NOX");
Teuchos::ParameterList& nlPrintParams = nlParams.sublist("Printing");
nlPrintParams.set("MyPID", MyPID);
if (verbose)
nlPrintParams.set("Output Information",
NOX::Utils::Error +
NOX::Utils::Details +
NOX::Utils::LinearSolverDetails +
NOX::Utils::OuterIteration +
NOX::Utils::InnerIteration +
NOX::Utils::Warning +
NOX::Utils::TestDetails +
NOX::Utils::StepperIteration +
NOX::Utils::StepperDetails);
else
nlPrintParams.set("Output Information", NOX::Utils::Error);
// Create the "Direction" sublist for the "Line Search Based" solver
Teuchos::ParameterList& dirParams = nlParams.sublist("Direction");
Teuchos::ParameterList& newParams = dirParams.sublist("Newton");
Teuchos::ParameterList& lsParams = newParams.sublist("Linear Solver");
lsParams.set("Aztec Solver", "GMRES");
lsParams.set("Max Iterations", 100);
lsParams.set("Tolerance", lstol);
if (verbose)
lsParams.set("Output Frequency", 1);
else
lsParams.set("Output Frequency", 0);
lsParams.set("Scaling", "None");
lsParams.set("Preconditioner", "Ifpack");
//lsParams.set("Preconditioner", "AztecOO");
//lsParams.set("Jacobian Operator", "Matrix-Free");
//lsParams.set("Preconditioner Operator", "Finite Difference");
lsParams.set("Aztec Preconditioner", "ilut");
//lsParams.set("Overlap", 2);
//lsParams.set("Fill Factor", 2.0);
//lsParams.set("Drop Tolerance", 1.0e-12);
lsParams.set("Max Age Of Prec", -2);
// Create the FiniteElementProblem class. This creates all required
// Epetra objects for the problem and allows calls to the
// function (RHS) and Jacobian evaluation routines.
Tcubed_FiniteElementProblem Problem(NumGlobalElements, Comm);
// Get the vector from the Problem
Epetra_Vector& soln = Problem.getSolution();
// Initialize Solution
soln.PutScalar(0.0);
// Create and initialize the parameter vector
LOCA::ParameterVector pVector;
pVector.addParameter("Nonlinear Factor",nonlinear_factor);
pVector.addParameter("Left BC", left_bc);
pVector.addParameter("Right BC", right_bc);
// Create the interface between the test problem and the nonlinear solver
// This is created by the user using inheritance of the abstract base
// class:
Teuchos::RCP<Problem_Interface> interface =
Teuchos::rcp(new Problem_Interface(Problem));
Teuchos::RCP<LOCA::Epetra::Interface::Required> iReq = interface;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac = interface;
// Create the Epetra_RowMatrixfor the Jacobian/Preconditioner
Teuchos::RCP<Epetra_RowMatrix> Amat =
Teuchos::rcp(&Problem.getJacobian(),false);
// Create the linear systems
Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(nlPrintParams,
lsParams, iReq, iJac,
Amat, soln));
// Create the loca vector
NOX::Epetra::Vector locaSoln(soln);
// Create Epetra factory
Teuchos::RCP<LOCA::Abstract::Factory> epetraFactory =
Teuchos::rcp(new LOCA::Epetra::Factory);
// Create global data object
globalData = LOCA::createGlobalData(paramList, epetraFactory);
// Create parsed parameter list
parsedParams =
Teuchos::rcp(new LOCA::Parameter::SublistParser(globalData));
parsedParams->parseSublists(paramList);
// Create the Group
grp = Teuchos::rcp(new LOCA::Epetra::Group(globalData, nlPrintParams,
iReq, locaSoln,
linsys, pVector));
// Create Jacobian operator
op = Teuchos::rcp(new LOCA::BorderedSolver::JacobianOperator(grp));
// Change initial guess to a random vector
Teuchos::RCP<NOX::Abstract::Vector> xnew =
grp->getX().clone();
xnew->random();
grp->setX(*xnew);
// Create the constraints object & constraint param IDs list
constraints =
Teuchos::rcp(new LinearConstraint(nConstraints, LOCA::ParameterVector(),
locaSoln));
// Create bordering solver
bordering
= globalData->locaFactory->createBorderedSolverStrategy(
parsedParams,
parsedParams->getSublist("Constraints"));
// Change strategy to Householder
constraintsList.set("Bordered Solver Method",
"Householder");
// Create householder solver
householder
= globalData->locaFactory->createBorderedSolverStrategy(
parsedParams,
parsedParams->getSublist("Constraints"));
// Check some statistics on the solution
testCompare = Teuchos::rcp(new NOX::TestCompare(
globalData->locaUtils->out(),
*(globalData->locaUtils)));
// Evaluate blocks
grp->computeF();
grp->computeJacobian();
// A
A = grp->getX().createMultiVector(nConstraints);
A->random();
// B
constraints->setX(grp->getX());
B = grp->getX().createMultiVector(nConstraints);
B->random();
constraints->setDgDx(*B);
constraints->computeConstraints();
constraints->computeDX();
// C
C = Teuchos::rcp(new NOX::Abstract::MultiVector::DenseMatrix(nConstraints,
nConstraints));
C->random();
// Set up left- and right-hand sides
F = grp->getX().createMultiVector(nRHS);
F->random();
G = Teuchos::rcp(new NOX::Abstract::MultiVector::DenseMatrix(nConstraints,
nRHS));
G->random();
X_bordering = F->clone(NOX::ShapeCopy);
Y_bordering =
Teuchos::rcp(new NOX::Abstract::MultiVector::DenseMatrix(nConstraints,
nRHS));
X_householder = F->clone(NOX::ShapeCopy);
Y_householder =
Teuchos::rcp(new NOX::Abstract::MultiVector::DenseMatrix(nConstraints,
nRHS));
std::string testName;
// Test all nonzero
testName = "Testing all nonzero";
ierr += testSolve(false, false, false, false, false,
reltol, abstol, testName);
// Test A = 0
testName = "Testing A=0";
ierr += testSolve(true, false, false, false, false,
reltol, abstol, testName);
// Test B = 0
testName = "Testing B=0";
ierr += testSolve(false, true, false, false, false,
reltol, abstol, testName);
// Test C = 0
testName = "Testing C=0";
ierr += testSolve(false, false, true, false, false,
reltol, abstol, testName);
// Test F = 0
testName = "Testing F=0";
ierr += testSolve(false, false, false, true, false,
reltol, abstol, testName);
// Test G = 0
testName = "Testing G=0";
ierr += testSolve(false, false, false, false, true,
reltol, abstol, testName);
// Test A,B = 0
testName = "Testing A,B=0";
ierr += testSolve(true, true, false, false, false,
reltol, abstol, testName);
// Test A,F = 0
testName = "Testing A,F=0";
ierr += testSolve(true, false, false, true, false,
reltol, abstol, testName);
// Test A,G = 0
testName = "Testing A,G=0";
ierr += testSolve(true, false, false, false, true,
reltol, abstol, testName);
// Test B,F = 0
testName = "Testing B,F=0";
ierr += testSolve(false, true, false, true, false,
reltol, abstol, testName);
// Test B,G = 0
testName = "Testing B,G=0";
ierr += testSolve(false, true, false, false, true,
reltol, abstol, testName);
// Test C,F = 0
testName = "Testing C,F=0";
ierr += testSolve(false, false, true, true, false,
reltol, abstol, testName);
// Test C,G = 0
testName = "Testing C,G=0";
ierr += testSolve(false, false, true, false, true,
reltol, abstol, testName);
// Test F,G = 0
testName = "Testing F,G=0";
ierr += testSolve(false, false, false, true, true,
reltol, abstol, testName);
// Test A,B,F = 0
testName = "Testing A,B,F=0";
ierr += testSolve(true, true, false, true, false,
reltol, abstol, testName);
// Test A,B,G = 0
testName = "Testing A,B,G=0";
ierr += testSolve(true, true, false, false, true,
reltol, abstol, testName);
// Test A,F,G = 0
testName = "Testing A,F,G=0";
ierr += testSolve(true, false, false, true, true,
reltol, abstol, testName);
// Test B,F,G = 0
testName = "Testing B,F,G=0";
ierr += testSolve(false, true, false, true, true,
reltol, abstol, testName);
// Test C,F,G = 0
testName = "Testing C,F,G=0";
ierr += testSolve(false, false, true, true, true,
reltol, abstol, testName);
// Test A,B,F,G = 0
testName = "Testing A,B,F,G=0";
ierr += testSolve(true, true, false, true, true,
reltol, abstol, testName);
LOCA::destroyGlobalData(globalData);
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
ierr = 1;
}
catch (const char *s) {
std::cout << s << std::endl;
ierr = 1;
}
catch (...) {
std::cout << "Caught unknown exception!" << std::endl;
ierr = 1;
}
if (MyPID == 0) {
if (ierr == 0)
std::cout << "All tests passed!" << std::endl;
else
std::cout << ierr << " test(s) failed!" << std::endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return ierr;
}
//
// Amesos_TestMultiSolver.cpp reads in a matrix in Harwell-Boeing format,
// calls one of the sparse direct solvers, using blocked right hand sides
// and computes the error and residual.
//
// TestSolver ignores the Harwell-Boeing right hand sides, creating
// random right hand sides instead.
//
// Amesos_TestMultiSolver can test either A x = b or A^T x = b.
// This can be a bit confusing because sparse direct solvers
// use compressed column storage - the transpose of Trilinos'
// sparse row storage.
//
// Matrices:
// readA - Serial. As read from the file.
// transposeA - Serial. The transpose of readA.
// serialA - if (transpose) then transposeA else readA
// distributedA - readA distributed to all processes
// passA - if ( distributed ) then distributedA else serialA
//
//
int Amesos_TestMultiSolver( Epetra_Comm &Comm, char *matrix_file, int numsolves,
SparseSolverType SparseSolver, bool transpose,
int special, AMESOS_MatrixType matrix_type ) {
int iam = Comm.MyPID() ;
// int hatever;
// if ( iam == 0 ) std::cin >> hatever ;
Comm.Barrier();
Epetra_Map * readMap;
Epetra_CrsMatrix * readA;
Epetra_Vector * readx;
Epetra_Vector * readb;
Epetra_Vector * readxexact;
std::string FileName = matrix_file ;
int FN_Size = FileName.size() ;
std::string LastFiveBytes = FileName.substr( EPETRA_MAX(0,FN_Size-5), FN_Size );
std::string LastFourBytes = FileName.substr( EPETRA_MAX(0,FN_Size-4), FN_Size );
bool NonContiguousMap = false;
if ( LastFiveBytes == ".triU" ) {
NonContiguousMap = true;
// Call routine to read in unsymmetric Triplet matrix
EPETRA_CHK_ERR( Trilinos_Util_ReadTriples2Epetra( matrix_file, false, Comm, readMap, readA, readx,
readb, readxexact, NonContiguousMap ) );
} else {
if ( LastFiveBytes == ".triS" ) {
NonContiguousMap = true;
// Call routine to read in symmetric Triplet matrix
EPETRA_CHK_ERR( Trilinos_Util_ReadTriples2Epetra( matrix_file, true, Comm,
readMap, readA, readx,
readb, readxexact, NonContiguousMap ) );
} else {
if ( LastFourBytes == ".mtx" ) {
EPETRA_CHK_ERR( Trilinos_Util_ReadMatrixMarket2Epetra( matrix_file, Comm, readMap,
readA, readx, readb, readxexact) );
} else {
// Call routine to read in HB problem
Trilinos_Util_ReadHb2Epetra( matrix_file, Comm, readMap, readA, readx,
readb, readxexact) ;
}
}
}
Epetra_CrsMatrix transposeA(Copy, *readMap, 0);
Epetra_CrsMatrix *serialA ;
if ( transpose ) {
assert( CrsMatrixTranspose( readA, &transposeA ) == 0 );
serialA = &transposeA ;
} else {
serialA = readA ;
}
// Create uniform distributed map
Epetra_Map map(readMap->NumGlobalElements(), 0, Comm);
Epetra_Map* map_;
if( NonContiguousMap ) {
//
// map gives us NumMyElements and MyFirstElement;
//
int NumGlobalElements = readMap->NumGlobalElements();
int NumMyElements = map.NumMyElements();
int MyFirstElement = map.MinMyGID();
std::vector<int> MapMap_( NumGlobalElements );
readMap->MyGlobalElements( &MapMap_[0] ) ;
Comm.Broadcast( &MapMap_[0], NumGlobalElements, 0 ) ;
map_ = new Epetra_Map( NumGlobalElements, NumMyElements, &MapMap_[MyFirstElement], 0, Comm);
} else {
map_ = new Epetra_Map( map ) ;
}
// Create Exporter to distribute read-in matrix and vectors
Epetra_Export exporter(*readMap, *map_);
Epetra_CrsMatrix A(Copy, *map_, 0);
Epetra_RowMatrix * passA = 0;
Epetra_MultiVector * passx = 0;
Epetra_MultiVector * passb = 0;
Epetra_MultiVector * passxexact = 0;
Epetra_MultiVector * passresid = 0;
Epetra_MultiVector * passtmp = 0;
Epetra_MultiVector x(*map_,numsolves);
Epetra_MultiVector b(*map_,numsolves);
Epetra_MultiVector xexact(*map_,numsolves);
Epetra_MultiVector resid(*map_,numsolves);
Epetra_MultiVector tmp(*map_,numsolves);
Epetra_MultiVector serialx(*readMap,numsolves);
Epetra_MultiVector serialb(*readMap,numsolves);
Epetra_MultiVector serialxexact(*readMap,numsolves);
Epetra_MultiVector serialresid(*readMap,numsolves);
Epetra_MultiVector serialtmp(*readMap,numsolves);
bool distribute_matrix = ( matrix_type == AMESOS_Distributed ) ;
if ( distribute_matrix ) {
//
// Initialize x, b and xexact to the values read in from the file
//
A.Export(*serialA, exporter, Add);
Comm.Barrier();
assert(A.FillComplete()==0);
Comm.Barrier();
passA = &A;
passx = &x;
passb = &b;
passxexact = &xexact;
passresid = &resid;
passtmp = &tmp;
} else {
passA = serialA;
passx = &serialx;
passb = &serialb;
passxexact = &serialxexact;
passresid = &serialresid;
passtmp = &serialtmp;
}
passxexact->SetSeed(131) ;
passxexact->Random();
passx->SetSeed(11231) ;
passx->Random();
passb->PutScalar( 0.0 );
passA->Multiply( transpose, *passxexact, *passb ) ;
Epetra_MultiVector CopyB( *passb ) ;
double Anorm = passA->NormInf() ;
SparseDirectTimingVars::SS_Result.Set_Anorm(Anorm) ;
Epetra_LinearProblem Problem( (Epetra_RowMatrix *) passA,
(Epetra_MultiVector *) passx,
(Epetra_MultiVector *) passb );
double max_resid = 0.0;
for ( int j = 0 ; j < special+1 ; j++ ) {
Epetra_Time TotalTime( Comm ) ;
if ( false ) {
#ifdef TEST_UMFPACK
unused code
} else if ( SparseSolver == UMFPACK ) {
UmfpackOO umfpack( (Epetra_RowMatrix *) passA,
(Epetra_MultiVector *) passx,
(Epetra_MultiVector *) passb ) ;
umfpack.SetTrans( transpose ) ;
umfpack.Solve() ;
#endif
#ifdef TEST_SUPERLU
} else if ( SparseSolver == SuperLU ) {
SuperluserialOO superluserial( (Epetra_RowMatrix *) passA,
(Epetra_MultiVector *) passx,
(Epetra_MultiVector *) passb ) ;
superluserial.SetPermc( SuperLU_permc ) ;
superluserial.SetTrans( transpose ) ;
superluserial.SetUseDGSSV( special == 0 ) ;
superluserial.Solve() ;
#endif
#ifdef HAVE_AMESOS_SLUD
} else if ( SparseSolver == SuperLUdist ) {
SuperludistOO superludist( Problem ) ;
superludist.SetTrans( transpose ) ;
EPETRA_CHK_ERR( superludist.Solve( true ) ) ;
#endif
#ifdef HAVE_AMESOS_SLUD2
} else if ( SparseSolver == SuperLUdist2 ) {
Superludist2_OO superludist2( Problem ) ;
superludist2.SetTrans( transpose ) ;
EPETRA_CHK_ERR( superludist2.Solve( true ) ) ;
#endif
#ifdef TEST_SPOOLES
} else if ( SparseSolver == SPOOLES ) {
SpoolesOO spooles( (Epetra_RowMatrix *) passA,
(Epetra_MultiVector *) passx,
(Epetra_MultiVector *) passb ) ;
spooles.SetTrans( transpose ) ;
spooles.Solve() ;
#endif
#ifdef HAVE_AMESOS_DSCPACK
} else if ( SparseSolver == DSCPACK ) {
Teuchos::ParameterList ParamList ;
Amesos_Dscpack dscpack( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( dscpack.SetParameters( ParamList ) );
EPETRA_CHK_ERR( dscpack.Solve( ) );
#endif
#ifdef HAVE_AMESOS_UMFPACK
} else if ( SparseSolver == UMFPACK ) {
Teuchos::ParameterList ParamList ;
Amesos_Umfpack umfpack( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( umfpack.SetParameters( ParamList ) );
EPETRA_CHK_ERR( umfpack.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( umfpack.Solve( ) );
#endif
#ifdef HAVE_AMESOS_KLU
} else if ( SparseSolver == KLU ) {
Teuchos::ParameterList ParamList ;
Amesos_Klu klu( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( klu.SetParameters( ParamList ) );
EPETRA_CHK_ERR( klu.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( klu.SymbolicFactorization( ) );
EPETRA_CHK_ERR( klu.NumericFactorization( ) );
EPETRA_CHK_ERR( klu.Solve( ) );
#endif
#ifdef HAVE_AMESOS_PARAKLETE
} else if ( SparseSolver == PARAKLETE ) {
Teuchos::ParameterList ParamList ;
Amesos_Paraklete paraklete( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( paraklete.SetParameters( ParamList ) );
EPETRA_CHK_ERR( paraklete.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( paraklete.SymbolicFactorization( ) );
EPETRA_CHK_ERR( paraklete.NumericFactorization( ) );
EPETRA_CHK_ERR( paraklete.Solve( ) );
#endif
#ifdef HAVE_AMESOS_SLUS
} else if ( SparseSolver == SuperLU ) {
Epetra_SLU superluserial( &Problem ) ;
EPETRA_CHK_ERR( superluserial.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( superluserial.SymbolicFactorization( ) );
EPETRA_CHK_ERR( superluserial.NumericFactorization( ) );
EPETRA_CHK_ERR( superluserial.Solve( ) );
#endif
#ifdef HAVE_AMESOS_LAPACK
} else if ( SparseSolver == LAPACK ) {
Teuchos::ParameterList ParamList ;
ParamList.set( "MaxProcs", -3 );
Amesos_Lapack lapack( Problem ) ;
EPETRA_CHK_ERR( lapack.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( lapack.SymbolicFactorization( ) );
EPETRA_CHK_ERR( lapack.NumericFactorization( ) );
EPETRA_CHK_ERR( lapack.Solve( ) );
#endif
#ifdef HAVE_AMESOS_TAUCS
} else if ( SparseSolver == TAUCS ) {
Teuchos::ParameterList ParamList ;
Amesos_Taucs taucs( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( taucs.SetParameters( ParamList ) );
EPETRA_CHK_ERR( taucs.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( taucs.SymbolicFactorization( ) );
EPETRA_CHK_ERR( taucs.NumericFactorization( ) );
EPETRA_CHK_ERR( taucs.Solve( ) );
#endif
#ifdef HAVE_AMESOS_PARDISO
} else if ( SparseSolver == PARDISO ) {
Teuchos::ParameterList ParamList ;
Amesos_Pardiso pardiso( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( pardiso.SetParameters( ParamList ) );
EPETRA_CHK_ERR( pardiso.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( pardiso.SymbolicFactorization( ) );
EPETRA_CHK_ERR( pardiso.NumericFactorization( ) );
EPETRA_CHK_ERR( pardiso.Solve( ) );
#endif
#ifdef HAVE_AMESOS_PARKLETE
} else if ( SparseSolver == PARKLETE ) {
Teuchos::ParameterList ParamList ;
Amesos_Parklete parklete( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( parklete.SetParameters( ParamList ) );
EPETRA_CHK_ERR( parklete.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( parklete.SymbolicFactorization( ) );
EPETRA_CHK_ERR( parklete.NumericFactorization( ) );
EPETRA_CHK_ERR( parklete.Solve( ) );
#endif
#ifdef HAVE_AMESOS_MUMPS
} else if ( SparseSolver == MUMPS ) {
Teuchos::ParameterList ParamList ;
Amesos_Mumps mumps( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( mumps.SetParameters( ParamList ) );
EPETRA_CHK_ERR( mumps.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( mumps.SymbolicFactorization( ) );
EPETRA_CHK_ERR( mumps.NumericFactorization( ) );
EPETRA_CHK_ERR( mumps.Solve( ) );
#endif
#ifdef HAVE_AMESOS_SCALAPACK
} else if ( SparseSolver == SCALAPACK ) {
Teuchos::ParameterList ParamList ;
Amesos_Scalapack scalapack( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( scalapack.SetParameters( ParamList ) );
EPETRA_CHK_ERR( scalapack.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( scalapack.SymbolicFactorization( ) );
EPETRA_CHK_ERR( scalapack.NumericFactorization( ) );
EPETRA_CHK_ERR( scalapack.Solve( ) );
#endif
#ifdef HAVE_AMESOS_SUPERLUDIST
} else if ( SparseSolver == SUPERLUDIST ) {
Teuchos::ParameterList ParamList ;
Amesos_Superludist superludist( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( superludist.SetParameters( ParamList ) );
EPETRA_CHK_ERR( superludist.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( superludist.SymbolicFactorization( ) );
EPETRA_CHK_ERR( superludist.NumericFactorization( ) );
EPETRA_CHK_ERR( superludist.Solve( ) );
#endif
#ifdef HAVE_AMESOS_SUPERLU
} else if ( SparseSolver == SUPERLU ) {
Teuchos::ParameterList ParamList ;
Amesos_Superlu superlu( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( superlu.SetParameters( ParamList ) );
EPETRA_CHK_ERR( superlu.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( superlu.SymbolicFactorization( ) );
EPETRA_CHK_ERR( superlu.NumericFactorization( ) );
EPETRA_CHK_ERR( superlu.Solve( ) );
#endif
#ifdef TEST_SPOOLESSERIAL
} else if ( SparseSolver == SPOOLESSERIAL ) {
SpoolesserialOO spoolesserial( (Epetra_RowMatrix *) passA,
(Epetra_MultiVector *) passx,
(Epetra_MultiVector *) passb ) ;
spoolesserial.Solve() ;
#endif
} else {
SparseDirectTimingVars::log_file << "Solver not implemented yet" << std::endl ;
std::cerr << "\n\n#################### Requested solver not available (Or not tested with blocked RHS) on this platform #####################\n" << std::endl ;
}
SparseDirectTimingVars::SS_Result.Set_Total_Time( TotalTime.ElapsedTime() );
// SparseDirectTimingVars::SS_Result.Set_First_Time( 0.0 );
// SparseDirectTimingVars::SS_Result.Set_Middle_Time( 0.0 );
// SparseDirectTimingVars::SS_Result.Set_Last_Time( 0.0 );
//
// Compute the error = norm(xcomp - xexact )
//
std::vector <double> error(numsolves) ;
double max_error = 0.0;
passresid->Update(1.0, *passx, -1.0, *passxexact, 0.0);
passresid->Norm2(&error[0]);
for ( int i = 0 ; i< numsolves; i++ )
if ( error[i] > max_error ) max_error = error[i] ;
SparseDirectTimingVars::SS_Result.Set_Error(max_error) ;
// passxexact->Norm2(&error[0] ) ;
// passx->Norm2(&error ) ;
//
// Compute the residual = norm(Ax - b)
//
std::vector <double> residual(numsolves) ;
passtmp->PutScalar(0.0);
passA->Multiply( transpose, *passx, *passtmp);
passresid->Update(1.0, *passtmp, -1.0, *passb, 0.0);
// passresid->Update(1.0, *passtmp, -1.0, CopyB, 0.0);
passresid->Norm2(&residual[0]);
for ( int i = 0 ; i< numsolves; i++ )
if ( residual[i] > max_resid ) max_resid = residual[i] ;
SparseDirectTimingVars::SS_Result.Set_Residual(max_resid) ;
std::vector <double> bnorm(numsolves);
passb->Norm2( &bnorm[0] ) ;
SparseDirectTimingVars::SS_Result.Set_Bnorm(bnorm[0]) ;
std::vector <double> xnorm(numsolves);
passx->Norm2( &xnorm[0] ) ;
SparseDirectTimingVars::SS_Result.Set_Xnorm(xnorm[0]) ;
if ( false && iam == 0 ) {
std::cout << " Amesos_TestMutliSolver.cpp " << std::endl ;
for ( int i = 0 ; i< numsolves && i < 10 ; i++ ) {
std::cout << "i=" << i
<< " error = " << error[i]
<< " xnorm = " << xnorm[i]
<< " residual = " << residual[i]
<< " bnorm = " << bnorm[i]
<< std::endl ;
}
std::cout << std::endl << " max_resid = " << max_resid ;
std::cout << " max_error = " << max_error << std::endl ;
std::cout << " Get_residual() again = " << SparseDirectTimingVars::SS_Result.Get_Residual() << std::endl ;
}
}
delete readA;
delete readx;
delete readb;
delete readxexact;
delete readMap;
delete map_;
Comm.Barrier();
return 0 ;
}
int main( int argc, char **argv )
{
// check for parallel computation
#ifdef HAVE_MPI
MPI_Init(&argc, &argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
// define main parameters
double c = 0.9999; // continuation parameter
int N = 50; // number of grid points
int maxNewtonIters = 20; // max number of Newton iterations
int maxSteps = 50; // max number of continuation steps taken
int ilocal, iglobal; // counter variables used for loops:
// ilocal = counter for local elements on this processor;
// iglobal = counter to signify global position across all procs
int Myele; // holds the number of elements on the processor
// Set flag for whether the computations will be Matrix-free (true) or will use a computed
// Jacobian (false)
bool doMatFree = false;
// Create output file to save solutions
ofstream outFile("Heq5.dat");
outFile.setf(ios::scientific, ios::floatfield);
outFile.precision(10);
// Define the problem class
HeqProblem Problem(N,&Comm,outFile);
// Build initial guess. The initial guess should be a solution vector x close to the
// bifurcation point.
// Create the initial guess vector
Epetra_Vector InitialGuess(Problem.GetMap());
// Get the number of elements on this processor
Myele = Problem.GetMap().NumMyElements();
// Compute the initial guess. For this example, it is a line from (0,1) to (1,8/3)
for (ilocal=0; ilocal<Myele; ilocal++) {
iglobal=Problem.GetMap().GID(ilocal);
InitialGuess[ilocal]= 1.0 + (5.0*iglobal)/(3.0*(N-1));
}
// Create the null vector for the Jacobian (ie, J*v=0, used to solve the system of equations
// f(x,p)=0; J*v=0; v0*v=1. The solution of the system is [x*,v*,p*]. )
Teuchos::RCP<NOX::Abstract::Vector> nullVec =
Teuchos::rcp(new NOX::Epetra::Vector(InitialGuess));
// Initialize to all ones
nullVec->init(1.0);
// NOTE: init is a function within the NOX::Abstract:Vector class which initializes every
// value of the vector to the value within the parentheses (must be in 'double' format)
// Create the top level parameter list
Teuchos::RCP<Teuchos::ParameterList> ParamList = Teuchos::rcp(new Teuchos::ParameterList);
// Create LOCA sublist
Teuchos::ParameterList& locaParamsList = ParamList->sublist("LOCA");
// Create the sublist for continuation and set the stepper parameters
Teuchos::ParameterList& stepperList = locaParamsList.sublist("Stepper");
//stepperList.set("Continuation Method", "Arc Length");// Default
stepperList.set("Continuation Method", "Natural");
stepperList.set("Continuation Parameter", "dummy"); // Must set
stepperList.set("Initial Value", 999.0); // Must set
stepperList.set("Max Value", 50.0e4); // Must set
stepperList.set("Min Value", 0.0); // Must set
stepperList.set("Max Steps", maxSteps); // Should set
stepperList.set("Max Nonlinear Iterations", maxNewtonIters); // Should set
stepperList.set("Bordered Solver Method", "Bordering");
// Teuchos::ParameterList& nestedList =
// stepperList.sublist("Nested Bordered Solver");
// nestedList.set("Bordered Solver Method", "Householder");
// nestedList.set("Include UV In Preconditioner", true);
// //nestedList.set("Use P For Preconditioner", true);
// nestedList.set("Preconditioner Method", "SMW");
// Set up parameters to compute Eigenvalues
#ifdef HAVE_LOCA_ANASAZI
// Create Anasazi Eigensolver sublist (needs --with-loca-anasazi)
stepperList.set("Compute Eigenvalues",true);
Teuchos::ParameterList& aList = stepperList.sublist("Eigensolver");
aList.set("Method", "Anasazi");
aList.set("Block Size", 1); // Size of blocks
aList.set("Num Blocks", 20); // Size of Arnoldi factorization
aList.set("Num Eigenvalues", 5); // Number of eigenvalues
// aList.set("Sorting Order", "SR");
aList.set("Convergence Tolerance", 2.0e-7); // Tolerance
aList.set("Step Size", 1); // How often to check convergence
aList.set("Maximum Restarts",2); // Maximum number of restarts
aList.set("Verbosity",
Anasazi::Errors +
Anasazi::Warnings +
Anasazi::FinalSummary); // Verbosity
#else
stepperList.set("Compute Eigenvalues",false);
#endif
// Create bifurcation sublist. Note that for turning point continuation, the "type"
// is set to "Turning Point". If not doing TP, type should be "None".
Teuchos::ParameterList& bifurcationList = locaParamsList.sublist("Bifurcation");
bifurcationList.set("Type", "Turning Point");
bifurcationList.set("Bifurcation Parameter", "c");
// bifurcationList.set("Formulation", "Minimally Augmented");
bifurcationList.set("Symmetric Jacobian", false);
bifurcationList.set("Update Null Vectors Every Continuation Step", true);
bifurcationList.set("Update Null Vectors Every Nonlinear Iteration", false);
bifurcationList.set("Transpose Solver Method","Explicit Transpose");
// bifurcationList.set("Transpose Solver Method","Transpose Preconditioner");
// bifurcationList.set("Transpose Solver Method","Left Preconditioning");
bifurcationList.set("Initial Null Vector Computation", "Solve df/dp");
// bifurcationList.set("Initial A Vector", nullVec); // minimally augmented
// bifurcationList.set("Initial B Vector", nullVec); //minimally augmented
// bifurcationList.set("Bordered Solver Method", "Householder");
// bifurcationList.set("Include UV In Preconditioner", true);
// //bifurcationList.set("Use P For Preconditioner", true);
// bifurcationList.set("Preconditioner Method", "SMW");
bifurcationList.set("Formulation", "Moore-Spence");
bifurcationList.set("Solver Method", "Phipps Bordering"); // better for nearly singular matrices
// bifurcationList.set("Solver Method", "Salinger Bordering");
bifurcationList.set("Initial Null Vector", nullVec);
bifurcationList.set("Length Normalization Vector", nullVec);
// Create the sublist for the predictor
Teuchos::ParameterList& predictorList = locaParamsList.sublist("Predictor");
predictorList.set("Method", "Secant"); // Default
// predictorList.set("Method", "Constant"); // Other options
// predictorList.set("Method", "Tangent"); // Other options
// Create step size sublist
Teuchos::ParameterList& stepSizeList = locaParamsList.sublist("Step Size");
stepSizeList.set("Method", "Adaptive"); // Default
stepSizeList.set("Initial Step Size", 0.1); // Should set
stepSizeList.set("Min Step Size", 1.0e-6); // Should set
stepSizeList.set("Max Step Size", 1.0); // Should set
stepSizeList.set("Aggressiveness", 0.1);
// Set up NOX info
Teuchos::ParameterList& nlParams = ParamList->sublist("NOX");
// Set the nonlinear solver method
nlParams.set("Nonlinear Solver", "Line Search Based");
// Set the printing parameters in the "Printing" sublist. This list determines how much
// of the NOX information is output
Teuchos::ParameterList& printParams = nlParams.sublist("Printing");
printParams.set("MyPID", Comm.MyPID());
printParams.set("Output Precision", 5);
printParams.set("Output Processor", 0);
printParams.set("Output Information",
NOX::Utils::OuterIteration +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::InnerIteration +
NOX::Utils::LinearSolverDetails +
NOX::Utils::Parameters +
NOX::Utils::Details +
NOX::Utils::Warning +
NOX::Utils::StepperIteration +
NOX::Utils::StepperDetails +
NOX::Utils::StepperParameters);
// NOX parameters - Sublist for line search
Teuchos::ParameterList& searchParams = nlParams.sublist("Line Search");
searchParams.set("Method", "Backtrack");
// searchParams.set("Method", "Full Step");
// Sublist for direction
Teuchos::ParameterList& dirParams = nlParams.sublist("Direction");
dirParams.set("Method", "Newton");
Teuchos::ParameterList& newtonParams = dirParams.sublist("Newton");
newtonParams.set("Forcing Term Method", "Constant");
// Sublist for linear solver for the Newton method
Teuchos::ParameterList& lsParams = newtonParams.sublist("Linear Solver");
lsParams.set("Aztec Solver", "GMRES");
lsParams.set("Max Iterations", 800);
lsParams.set("Tolerance", 1e-8);
lsParams.set("Output Frequency", 1);
lsParams.set("Preconditioner", "None");
// lsParams.set("Preconditioner", "AztecOO");
// lsParams.set("Aztec Preconditioner", "ilu");
// lsParams.set("Scaling", "None");
// lsParams.set("Scaling", "Row Sum");
lsParams.set("Compute Scaling Manually", false);
// lsParams.set("Preconditioner", "Ifpack");
// lsParams.set("Ifpack Preconditioner", "ILU");
// lsParams.set("Preconditioner", "New Ifpack");
// Teuchos::ParameterList& ifpackParams = lsParams.sublist("Ifpack");
// ifpackParams.set("fact: level-of-fill", 1);
// Set up the continuation parameter vector
LOCA::ParameterVector p;
p.addParameter("c",c);
p.addParameter("dummy",999.0);
// Create the problem interface
Teuchos::RCP<SimpleProblemInterface> interface =
Teuchos::rcp(new SimpleProblemInterface(&Problem,c) );
Teuchos::RCP<LOCA::Epetra::Interface::Required> iReq = interface;
// Create the operator to hold either the Jacobian matrix or the Matrix-free operator
Teuchos::RCP<Epetra_Operator> A;
// Teuchos::RCP<Epetra_RowMatrix> A;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac;
// Need a NOX::Epetra::Vector for constructor
// This becomes the initial guess vector that is used for the nonlinear solves
NOX::Epetra::Vector noxInitGuess(InitialGuess, NOX::DeepCopy);
if (doMatFree) {
// Matrix Free application (Epetra Operator):
Teuchos::RCP<NOX::Epetra::MatrixFree> MF =
Teuchos::rcp(new NOX::Epetra::MatrixFree(printParams, interface, noxInitGuess));
A = MF;
iJac = MF;
}
else { // Computed Jacobian application
A = Teuchos::rcp( Problem.GetMatrix(), false );
iJac = interface;
}
// Create scaling object
Teuchos::RCP<NOX::Epetra::Scaling> scaling = Teuchos::null;
// scaling = Teuchos::rcp(new NOX::Epetra::Scaling);
// Teuchos::RCP<Epetra_Vector> scalingVector =
// Teuchos::rcp(new Epetra_Vector(soln.Map()));
// //scaling->addRowSumScaling(NOX::Epetra::Scaling::Left, scalingVector);
// scaling->addColSumScaling(NOX::Epetra::Scaling::Right, scalingVector);
// Create transpose scaling object
Teuchos::RCP<NOX::Epetra::Scaling> trans_scaling = Teuchos::null;
// trans_scaling = Teuchos::rcp(new NOX::Epetra::Scaling);
// Teuchos::RCP<Epetra_Vector> transScalingVector =
// Teuchos::rcp(new Epetra_Vector(soln.Map()));
// trans_scaling->addRowSumScaling(NOX::Epetra::Scaling::Right,
// transScalingVector);
// trans_scaling->addColSumScaling(NOX::Epetra::Scaling::Left,
// transScalingVector);
//bifurcationList.set("Transpose Scaling", trans_scaling);
// Build the linear system solver
Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> linSys =
Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
iReq,
iJac, A,
noxInitGuess, scaling)); // use if scaling
// noxInitGuess)); // use if no scaling
// Create the Loca (continuation) vector
NOX::Epetra::Vector locaSoln(noxInitGuess);
// Create Epetra Factory
Teuchos::RCP<LOCA::Abstract::Factory> epetraFactory = Teuchos::rcp(new LOCA::Epetra::Factory);
// Create global data object
Teuchos::RCP<LOCA::GlobalData> globalData = LOCA::createGlobalData(ParamList, epetraFactory);
// Create the Group - must be LOCA group
Teuchos::RCP<LOCA::Epetra::Group> grpPtr =
Teuchos::rcp(new LOCA::Epetra::Group(globalData, printParams,
iReq, locaSoln,
linSys, p));
// Calculate the first F(x0) as a starting point. This is only needed for
// certain status tests, to ensure that an initial residual (|r0|) is calculated
grpPtr->computeF();
// Set up the status tests to check for convergence
// Determines the error tolerance for the Newton solves
Teuchos::RCP<NOX::StatusTest::NormF> testNormF =
Teuchos::rcp(new NOX::StatusTest::NormF(1.0e-4));
// Sets the max number of nonlinear (Newton) iterations that will be taken. If this is not
// already set, it will default to the '20' given
Teuchos::RCP<NOX::StatusTest::MaxIters> testMaxIters =
Teuchos::rcp(new NOX::StatusTest::MaxIters(stepperList.get("Max Nonlinear Iterations", 20)));
// This combination of tests will be used by NOX to determine whether the step converged
Teuchos::RCP<NOX::StatusTest::Combo> combo =
Teuchos::rcp(new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR,
testNormF, testMaxIters));
// This is sample code to write and read parameters to/from a file. Currently not activated!
// To use, change the 'XXXHAVE_TEUCHOS_EXTENDED' TO 'HAVE_TEUCHOS_EXTENDED'
#ifdef XXXHAVE_TEUCHOS_EXTENDED
// Write the parameter list to a file
cout << "Writing parameter list to \"input.xml\"" << endl;
Teuchos::writeParameterListToXmlFile(*ParamList, "input.xml");
// Read in the parameter list from a file
cout << "Reading parameter list from \"input.xml\"" << endl;
Teuchos::RCP<Teuchos::ParameterList> paramList2 =
Teuchos::rcp(new Teuchos::ParameterList);
Teuchos::updateParametersFromXmlFile("input.xml", paramList2.get());
ParamList = paramList2;
#endif
// Create the stepper
LOCA::Stepper stepper(globalData, grpPtr, combo, ParamList);
LOCA::Abstract::Iterator::IteratorStatus status = stepper.run();
// Check if the stepper completed
if (status == LOCA::Abstract::Iterator::Finished)
globalData->locaUtils->out() << "\nAll tests passed!" << endl;
else
if (globalData->locaUtils->isPrintType(NOX::Utils::Error))
globalData->locaUtils->out() << "\nStepper failed to converge!" << endl;
// Output the stepper parameter list info
if (globalData->locaUtils->isPrintType(NOX::Utils::StepperParameters)) {
globalData->locaUtils->out() << endl << "Final Parameters" << endl
<< "*******************" << endl;
stepper.getList()->print(globalData->locaUtils->out());
globalData->locaUtils->out() << endl;
}
// Make sure all processors are done and close the output file
Comm.Barrier();
outFile.close();
// Deallocate memory
LOCA::destroyGlobalData(globalData);
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return(EXIT_SUCCESS);
} // DONE!!
#include <antlr/BitSet.hpp>
#include "JavaTokenTypes.hpp"
#include <antlr/CharScanner.hpp>
class CUSTOM_API JavaLexer : public ANTLR_USE_NAMESPACE(antlr)CharScanner, public JavaTokenTypes
{
#line 1058 "java.g"
private:
Driver* m_driver;
public:
void setDriver( Driver* d ) { m_driver = d; }
void setFileName( const QString& fileName ) { m_driver->currentFileName() = fileName; }
virtual void reportError( const ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex ){
m_driver->addProblem( m_driver->currentFileName(), Problem( QString::fromLocal8Bit(ex.getMessage().c_str()), ex.getLine(), ex.getColumn()) );
}
virtual void reportError( const ANTLR_USE_NAMESPACE(std)string& errorMessage ){
m_driver->addProblem( m_driver->currentFileName(), Problem( QString::fromLocal8Bit(errorMessage.c_str()), getLine(), getColumn()) );
}
virtual void reportWarning( const ANTLR_USE_NAMESPACE(std)string& warnMessage ){
m_driver->addProblem( m_driver->currentFileName(), Problem( QString::fromLocal8Bit(warnMessage.c_str()), getLine(), getColumn()) );
}
#line 30 "JavaLexer.hpp"
private:
void initLiterals();
public:
bool getCaseSensitiveLiterals() const
{
int main(int argc, char *argv[])
{
int ierr = 0;
int MyPID = 0;
double alpha = 0.25;
double beta = 1.5;
double D1 = 1.0/40.0;
double D2 = 1.0/40.0;
int maxNewtonIters = 10;
try {
// Initialize MPI
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
#endif
// Create a communicator for Epetra objects
#ifdef HAVE_MPI
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
Epetra_SerialComm Comm;
#endif
// Get the process ID and the total number of processors
MyPID = Comm.MyPID();
int NumProc = Comm.NumProc();
// Check for verbose output
bool verbose = false;
if (argc>1)
if (argv[1][0]=='-' && argv[1][1]=='v')
verbose = true;
// Get the number of elements from the command line
int NumGlobalNodes = 0;
if ((argc > 2) && (verbose))
NumGlobalNodes = atoi(argv[2]) + 1;
else if ((argc > 1) && (!verbose))
NumGlobalNodes = atoi(argv[1]) + 1;
else
NumGlobalNodes = 101;
// The number of unknowns must be at least equal to the
// number of processors.
if (NumGlobalNodes < NumProc) {
std::cout << "numGlobalNodes = " << NumGlobalNodes
<< " cannot be < number of processors = " << NumProc
<< std::endl;
exit(1);
}
// Create the Brusselator problem class. This creates all required
// Epetra objects for the problem and allows calls to the
// function (F) and Jacobian evaluation routines.
Brusselator Problem(NumGlobalNodes, Comm);
// Get the vector from the Problem
Epetra_Vector& soln = Problem.getSolution();
// Begin LOCA Solver ************************************
// Create the top level parameter list
Teuchos::RCP<Teuchos::ParameterList> paramList =
Teuchos::rcp(new Teuchos::ParameterList);
// Create LOCA sublist
Teuchos::ParameterList& locaParamsList = paramList->sublist("LOCA");
// Create the stepper sublist and set the stepper parameters
Teuchos::ParameterList& stepperList = locaParamsList.sublist("Stepper");
stepperList.set("Bordered Solver Method", "Householder");
stepperList.set("Continuation Parameter", "beta");
stepperList.set("Initial Value", beta);
stepperList.set("Max Value", 1.6);
stepperList.set("Min Value", 0.0);
stepperList.set("Max Steps", 100);
stepperList.set("Max Nonlinear Iterations", maxNewtonIters);
#ifdef HAVE_LOCA_ANASAZI
// Create Anasazi Eigensolver sublist (needs --with-loca-anasazi)
stepperList.set("Compute Eigenvalues",true);
Teuchos::ParameterList& aList = stepperList.sublist("Eigensolver");
aList.set("Method", "Anasazi");
if (!verbose)
aList.set("Verbosity", Anasazi::Errors);
aList.set("Block Size", 1); // Size of blocks
aList.set("Num Blocks", 50); // Size of Arnoldi factorization
aList.set("Num Eigenvalues", 3); // Number of eigenvalues
aList.set("Convergence Tolerance", 1.0e-7); // Tolerance
aList.set("Step Size", 1); // How often to check convergence
aList.set("Maximum Restarts",1); // Maximum number of restarts
aList.set("Operator", "Cayley");
aList.set("Cayley Pole", 0.1);
aList.set("Cayley Zero", -0.1);
aList.set("Sorting Order", "CA");
#else
stepperList.set("Compute Eigenvalues",false);
#endif
// Create predictor sublist
Teuchos::ParameterList& predictorList =
locaParamsList.sublist("Predictor");
predictorList.set("Method", "Constant");
// Create step size sublist
Teuchos::ParameterList& stepSizeList = locaParamsList.sublist("Step Size");
stepSizeList.set("Initial Step Size", 0.01);
stepSizeList.set("Min Step Size", 1.0e-3);
stepSizeList.set("Max Step Size", 0.01);
stepSizeList.set("Aggressiveness", 0.1);
// Create the "Solver" parameters sublist to be used with NOX Solvers
Teuchos::ParameterList& nlParams = paramList->sublist("NOX");
// Set the printing parameters in the "Printing" sublist
Teuchos::ParameterList& printParams = nlParams.sublist("Printing");
printParams.set("MyPID", MyPID);
printParams.set("Output Precision", 3);
printParams.set("Output Processor", 0);
if (verbose)
printParams.set("Output Information",
NOX::Utils::OuterIteration +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::InnerIteration +
NOX::Utils::Details +
NOX::Utils::Warning +
NOX::Utils::TestDetails +
NOX::Utils::Error +
NOX::Utils::StepperIteration +
NOX::Utils::StepperDetails +
NOX::Utils::StepperParameters);
else
printParams.set("Output Information", NOX::Utils::Error);
// Sublist for "Linear Solver"
Teuchos::ParameterList& dirParams = nlParams.sublist("Direction");
Teuchos::ParameterList& newtonParams = dirParams.sublist("Newton");
Teuchos::ParameterList& lsParams = newtonParams.sublist("Linear Solver");
lsParams.set("Aztec Solver", "GMRES");
lsParams.set("Max Iterations", 800);
lsParams.set("Tolerance", 1e-6);
lsParams.set("Output Frequency", 50);
lsParams.set("Preconditioner", "Ifpack");
// Create the interface between the test problem and the nonlinear solver
Teuchos::RCP<Problem_Interface> interface =
Teuchos::rcp(new Problem_Interface(Problem));
// Create the Epetra_RowMatrixfor the Jacobian/Preconditioner
Teuchos::RCP<Epetra_RowMatrix> A =
Teuchos::rcp(&Problem.getJacobian(),false);
// Use an Epetra Scaling object if desired
Teuchos::RCP<Epetra_Vector> scaleVec =
Teuchos::rcp(new Epetra_Vector(soln));
NOX::Epetra::Scaling scaling;
scaling.addRowSumScaling(NOX::Epetra::Scaling::Left, scaleVec);
Teuchos::RCP<LOCA::Epetra::Interface::Required> iReq = interface;
// Create the Linear System
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac = interface;
Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> linSys =
Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
iReq, iJac, A, soln));
//&scaling);
Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> shiftedLinSys =
Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
iReq, iJac, A, soln));
// Create initial guess
NOX::Epetra::Vector initialGuess(Teuchos::rcp(&soln,false),
NOX::Epetra::Vector::CreateView,
NOX::DeepCopy);
// Create and initialize the parameter vector
LOCA::ParameterVector pVector;
pVector.addParameter("alpha",alpha);
pVector.addParameter("beta",beta);
pVector.addParameter("D1",D1);
pVector.addParameter("D2",D2);
// Create Epetra factory
Teuchos::RCP<LOCA::Abstract::Factory> epetraFactory =
Teuchos::rcp(new LOCA::Epetra::Factory);
// Create global data object
Teuchos::RCP<LOCA::GlobalData> globalData =
LOCA::createGlobalData(paramList, epetraFactory);
// Create the Group
Teuchos::RCP<LOCA::Epetra::Interface::TimeDependent> iTime = interface;
Teuchos::RCP<LOCA::Epetra::Group> grp =
Teuchos::rcp(new LOCA::Epetra::Group(globalData, printParams,
iTime, initialGuess, linSys,
shiftedLinSys, pVector));
grp->computeF();
// Create the convergence tests
Teuchos::RCP<NOX::StatusTest::NormF> absresid =
Teuchos::rcp(new NOX::StatusTest::NormF(1.0e-8,
NOX::StatusTest::NormF::Unscaled));
Teuchos::RCP<NOX::StatusTest::MaxIters> maxiters =
Teuchos::rcp(new NOX::StatusTest::MaxIters(maxNewtonIters));
Teuchos::RCP<NOX::StatusTest::Combo> combo =
Teuchos::rcp(new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR));
combo->addStatusTest(absresid);
combo->addStatusTest(maxiters);
// Create stepper
LOCA::Stepper stepper(globalData, grp, combo, paramList);
LOCA::Abstract::Iterator::IteratorStatus status = stepper.run();
if (status != LOCA::Abstract::Iterator::Finished) {
ierr = 1;
if (globalData->locaUtils->isPrintType(NOX::Utils::Error))
globalData->locaUtils->out()
<< "Stepper failed to converge!" << std::endl;
}
// Get the final solution from the stepper
Teuchos::RCP<const LOCA::Epetra::Group> finalGroup =
Teuchos::rcp_dynamic_cast<const LOCA::Epetra::Group>(stepper.getSolutionGroup());
const NOX::Epetra::Vector& finalSolution =
dynamic_cast<const NOX::Epetra::Vector&>(finalGroup->getX());
// Output the parameter list
if (globalData->locaUtils->isPrintType(NOX::Utils::StepperParameters)) {
globalData->locaUtils->out()
<< std::endl << "Final Parameters" << std::endl
<< "****************" << std::endl;
stepper.getList()->print(globalData->locaUtils->out());
globalData->locaUtils->out() << std::endl;
}
// Check some statistics on the solution
NOX::TestCompare testCompare(globalData->locaUtils->out(),
*(globalData->locaUtils));
if (globalData->locaUtils->isPrintType(NOX::Utils::TestDetails))
globalData->locaUtils->out()
<< std::endl
<< "***** Checking solution statistics *****"
<< std::endl;
// Check number of continuation steps
int numSteps = stepper.getStepNumber();
int numSteps_expected = 11;
ierr += testCompare.testValue(numSteps, numSteps_expected, 0.0,
"number of continuation steps",
NOX::TestCompare::Absolute);
// Check number of failed steps
int numFailedSteps = stepper.getNumFailedSteps();
int numFailedSteps_expected = 0;
ierr += testCompare.testValue(numFailedSteps, numFailedSteps_expected, 0.0,
"number of failed continuation steps",
NOX::TestCompare::Absolute);
// Check final value of continuation parameter
double beta_final = finalGroup->getParam("beta");
double beta_expected = 1.6;
ierr += testCompare.testValue(beta_final, beta_expected, 1.0e-14,
"final value of continuation parameter",
NOX::TestCompare::Relative);
// Check final of solution
NOX::Epetra::Vector final_x_expected(finalSolution);
int n = final_x_expected.getEpetraVector().MyLength()/2;
for (int i=0; i<n; i++) {
final_x_expected.getEpetraVector()[2*i] = alpha;
final_x_expected.getEpetraVector()[2*i+1] = beta_final/alpha;
}
ierr += testCompare.testVector(finalSolution, final_x_expected,
1.0e-6, 1.0e-6,
"value of final solution");
LOCA::destroyGlobalData(globalData);
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
ierr = 1;
}
catch (const char *s) {
std::cout << s << std::endl;
ierr = 1;
}
catch (...) {
std::cout << "Caught unknown exception!" << std::endl;
ierr = 1;
}
if (MyPID == 0) {
if (ierr == 0)
std::cout << "All tests passed!" << std::endl;
else
std::cout << ierr << " test(s) failed!" << std::endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return ierr;
}
int main(int argc, char *argv[])
{
// initialize MPI and Epetra communicator
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
Epetra_SerialComm Comm;
#endif
Teuchos::ParameterList GaleriList;
// The problem is defined on a 2D grid, global size is nx * nx.
int nx = 30;
GaleriList.set("nx", nx);
GaleriList.set("ny", nx * Comm.NumProc());
GaleriList.set("mx", 1);
GaleriList.set("my", Comm.NumProc());
Teuchos::RefCountPtr<Epetra_Map> Map = Teuchos::rcp( Galeri::CreateMap64("Cartesian2D", Comm, GaleriList) );
Teuchos::RefCountPtr<Epetra_RowMatrix> A = Teuchos::rcp( Galeri::CreateCrsMatrix("Laplace2D", &*Map, GaleriList) );
// =============================================================== //
// B E G I N N I N G O F I F P A C K C O N S T R U C T I O N //
// =============================================================== //
Teuchos::ParameterList List;
// builds an Ifpack_AdditiveSchwarz. This is templated with
// the local solvers, in this case Ifpack_ICT. Note that any
// other Ifpack_Preconditioner-derived class can be used
// instead of Ifpack_ICT.
// In this example the overlap is zero. Use
// Prec(A,OverlapLevel) for the general case.
Ifpack_AdditiveSchwarz<Ifpack_ICT> Prec(&*A);
// `1.0' means that the factorization should approximatively
// keep the same number of nonzeros per row of the original matrix.
List.set("fact: ict level-of-fill", 1.0);
// no modifications on the diagonal
List.set("fact: absolute threshold", 0.0);
List.set("fact: relative threshold", 1.0);
List.set("fact: relaxation value", 0.0);
// matrix `laplace_2d_bc' is not symmetric because of the way
// boundary conditions are imposed. We can filter the singletons,
// (that is, Dirichlet nodes) and end up with a symmetric
// matrix (as ICT requires).
List.set("schwarz: filter singletons", true);
// sets the parameters
IFPACK_CHK_ERR(Prec.SetParameters(List));
// initialize the preconditioner. At this point the matrix must
// have been FillComplete()'d, but actual values are ignored.
IFPACK_CHK_ERR(Prec.Initialize());
// Builds the preconditioners, by looking for the values of
// the matrix.
IFPACK_CHK_ERR(Prec.Compute());
// =================================================== //
// E N D O F I F P A C K C O N S T R U C T I O N //
// =================================================== //
// At this point, we need some additional objects
// to define and solve the linear system.
// defines LHS and RHS
Epetra_Vector LHS(A->OperatorDomainMap());
Epetra_Vector RHS(A->OperatorDomainMap());
LHS.PutScalar(0.0);
RHS.Random();
// need an Epetra_LinearProblem to define AztecOO solver
Epetra_LinearProblem Problem(&*A,&LHS,&RHS);
// now we can allocate the AztecOO solver
AztecOO Solver(Problem);
// specify solver
Solver.SetAztecOption(AZ_solver,AZ_cg_condnum);
Solver.SetAztecOption(AZ_output,32);
// HERE WE SET THE IFPACK PRECONDITIONER
Solver.SetPrecOperator(&Prec);
// .. and here we solve
// NOTE: with one process, the solver must converge in
// one iteration.
Solver.Iterate(1550,1e-5);
// Prints out some information about the preconditioner
cout << Prec;
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return (EXIT_SUCCESS);
}
// ======================================================================
bool ComparePointAndBlock(string PrecType, const Teuchos::RefCountPtr<Epetra_RowMatrix>& A, int sweeps)
{
Epetra_MultiVector RHS(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector LHS(A->RowMatrixRowMap(), NumVectors);
LHS.PutScalar(0.0); RHS.Random();
Epetra_LinearProblem Problem(&*A, &LHS, &RHS);
// Set up the list
Teuchos::ParameterList List;
List.set("relaxation: damping factor", 1.0);
List.set("relaxation: type", PrecType);
List.set("relaxation: sweeps",sweeps);
List.set("partitioner: type", "linear");
List.set("partitioner: local parts", A->NumMyRows());
int ItersPoint, ItersBlock;
// ================================================== //
// get the number of iterations with point relaxation //
// ================================================== //
{
RHS.PutScalar(1.0);
LHS.PutScalar(0.0);
Ifpack_PointRelaxation Point(&*A);
Point.SetParameters(List);
Point.Compute();
// set AztecOO solver object
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,Solver);
if (verbose)
AztecOOSolver.SetAztecOption(AZ_output,32);
else
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetPrecOperator(&Point);
AztecOOSolver.Iterate(2550,1e-2);
double TrueResidual = AztecOOSolver.TrueResidual();
ItersPoint = AztecOOSolver.NumIters();
// some output
if (verbose && Problem.GetMatrix()->Comm().MyPID() == 0) {
cout << "Iterations = " << ItersPoint << endl;
cout << "Norm of the true residual = " << TrueResidual << endl;
}
}
// ================================================== //
// get the number of iterations with block relaxation //
// ================================================== //
{
RHS.PutScalar(1.0);
LHS.PutScalar(0.0);
Ifpack_BlockRelaxation<Ifpack_SparseContainer<Ifpack_Amesos> > Block(&*A);
Block.SetParameters(List);
Block.Compute();
// set AztecOO solver object
AztecOO AztecOOSolver(Problem);
AztecOOSolver.SetAztecOption(AZ_solver,Solver);
if (verbose)
AztecOOSolver.SetAztecOption(AZ_output,32);
else
AztecOOSolver.SetAztecOption(AZ_output,AZ_none);
AztecOOSolver.SetPrecOperator(&Block);
AztecOOSolver.Iterate(2550,1e-2);
double TrueResidual = AztecOOSolver.TrueResidual();
ItersBlock = AztecOOSolver.NumIters();
// some output
if (verbose && Problem.GetMatrix()->Comm().MyPID() == 0) {
cout << "Iterations " << ItersBlock << endl;
cout << "Norm of the true residual = " << TrueResidual << endl;
}
}
int diff = ItersPoint - ItersBlock;
if (diff < 0) diff = -diff;
if (diff > 10)
{
if (verbose)
cout << "ComparePointandBlock TEST FAILED!" << endl;
return(false);
}
else {
if (verbose)
cout << "ComparePointandBlock TEST PASSED" << endl;
return(true);
}
}
int main(int argc, char *argv[])
{
// initialize MPI and Epetra communicator
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
Epetra_SerialComm Comm;
#endif
Teuchos::ParameterList GaleriList;
// The problem is defined on a 2D grid, global size is nx * nx.
int nx = 30;
GaleriList.set("nx", nx);
GaleriList.set("ny", nx * Comm.NumProc());
GaleriList.set("mx", 1);
GaleriList.set("my", Comm.NumProc());
Teuchos::RefCountPtr<Epetra_Map> Map = Teuchos::rcp( Galeri::CreateMap64("Cartesian2D", Comm, GaleriList) );
Teuchos::RefCountPtr<Epetra_RowMatrix> A = Teuchos::rcp( Galeri::CreateCrsMatrix("Laplace2D", &*Map, GaleriList) );
// =============================================================== //
// B E G I N N I N G O F I F P A C K C O N S T R U C T I O N //
// =============================================================== //
Teuchos::ParameterList List;
// builds an Ifpack_AdditiveSchwarz. This is templated with
// the local solvers, in this case Ifpack_BlockRelaxation.
// Ifpack_BlockRelaxation requires as a templated a container
// class. A container defines
// how to store the diagonal blocks. Two choices are available:
// Ifpack_DenseContainer (to store them as dense block,
// than use LAPACK' factorization to apply the inverse of
// each block), of Ifpack_SparseContainer (to store
// the diagonal block as Epetra_CrsMatrix's).
//
// Here, we use Ifpack_SparseContainer, which in turn is
// templated with the class to use to apply the inverse
// of each block. For example, we can use Ifpack_Amesos.
// We still have to decide the overlap among the processes,
// and the overlap among the blocks. The two values
// can be different. The overlap among the blocks is
// considered only if block Jacobi is used.
int OverlapProcs = 2;
int OverlapBlocks = 0;
// define the block below to use dense containers
#if 0
Ifpack_AdditiveSchwarz<Ifpack_BlockRelaxation<Ifpack_DenseContainer> > Prec(A, OverlapProcs);
#else
Ifpack_AdditiveSchwarz<Ifpack_BlockRelaxation<Ifpack_SparseContainer<Ifpack_Amesos> > > Prec(&*A, OverlapProcs);
#endif
List.set("relaxation: type", "symmetric Gauss-Seidel");
List.set("partitioner: overlap", OverlapBlocks);
#ifdef HAVE_IFPACK_METIS
// use METIS to create the blocks. This requires --enable-ifpack-metis.
// If METIS is not installed, the user may select "linear".
List.set("partitioner: type", "metis");
#else
// or a simple greedy algorithm is METIS is not enabled
List.set("partitioner: type", "greedy");
#endif
// defines here the number of local blocks. If 1,
// and only one process is used in the computation, then
// the preconditioner must converge in one iteration.
List.set("partitioner: local parts", 4);
// sets the parameters
IFPACK_CHK_ERR(Prec.SetParameters(List));
// initialize the preconditioner.
IFPACK_CHK_ERR(Prec.Initialize());
// Builds the preconditioners.
IFPACK_CHK_ERR(Prec.Compute());
// =================================================== //
// E N D O F I F P A C K C O N S T R U C T I O N //
// =================================================== //
// At this point, we need some additional objects
// to define and solve the linear system.
// defines LHS and RHS
Epetra_Vector LHS(A->OperatorDomainMap());
Epetra_Vector RHS(A->OperatorDomainMap());
LHS.PutScalar(0.0);
RHS.Random();
// need an Epetra_LinearProblem to define AztecOO solver
Epetra_LinearProblem Problem(&*A,&LHS,&RHS);
// now we can allocate the AztecOO solver
AztecOO Solver(Problem);
// specify solver
Solver.SetAztecOption(AZ_solver,AZ_cg);
Solver.SetAztecOption(AZ_output,32);
// HERE WE SET THE IFPACK PRECONDITIONER
Solver.SetPrecOperator(&Prec);
// .. and here we solve
// NOTE: with one process, the solver must converge in
// one iteration.
Solver.Iterate(1550,1e-5);
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return(EXIT_SUCCESS);
}
// ======================================================================
bool TestContainer(string Type, const Teuchos::RefCountPtr<Epetra_RowMatrix>& A)
{
int NumVectors = 3;
int NumMyRows = A->NumMyRows();
Epetra_MultiVector LHS_exact(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector LHS(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector RHS(A->RowMatrixRowMap(), NumVectors);
LHS_exact.Random(); LHS.PutScalar(0.0);
A->Multiply(false, LHS_exact, RHS);
Epetra_LinearProblem Problem(&*A, &LHS, &RHS);
if (verbose) {
cout << "Container type = " << Type << endl;
cout << "NumMyRows = " << NumMyRows << ", NumVectors = " << NumVectors << endl;
}
LHS.PutScalar(0.0);
Teuchos::RefCountPtr<Ifpack_Container> Container;
if (Type == "dense")
Container = Teuchos::rcp( new Ifpack_DenseContainer(A->NumMyRows(), NumVectors) );
else
Container = Teuchos::rcp( new Ifpack_SparseContainer<Ifpack_Amesos>(A->NumMyRows(), NumVectors) );
assert (Container != Teuchos::null);
IFPACK_CHK_ERR(Container->Initialize());
// set as ID all the local rows of A
for (int i = 0 ; i < A->NumMyRows() ; ++i)
Container->ID(i) = i;
// extract submatrix (in this case, the entire matrix)
// and complete setup
IFPACK_CHK_ERR(Container->Compute(*A));
// set the RHS and LHS
for (int i = 0 ; i < A->NumMyRows() ; ++i)
for (int j = 0 ; j < NumVectors ; ++j) {
Container->RHS(i,j) = RHS[j][i];
Container->LHS(i,j) = LHS[j][i];
}
// set parameters (empty for dense containers)
Teuchos::ParameterList List;
List.set("amesos: solver type", Type);
IFPACK_CHK_ERR(Container->SetParameters(List));
// solve the linear system
IFPACK_CHK_ERR(Container->ApplyInverse());
// get the computed solution, store it in LHS
for (int i = 0 ; i < A->NumMyRows() ; ++i)
for (int j = 0 ; j < NumVectors ; ++j) {
LHS[j][i] = Container->LHS(i,j);
}
double residual = Galeri::ComputeNorm(&LHS, &LHS_exact);
if (A->Comm().MyPID() == 0 && verbose) {
cout << "||x_exact - x||_2 = " << residual << endl;
cout << *Container;
}
bool passed = false;
if (residual < 1e-5)
passed = true;
return(passed);
}
AStarSolver(Problem&& problem_ = Problem())
: problem(problem_)
{
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
Epetra_SerialComm Comm;
#endif
Teuchos::ParameterList GaleriList;
// The problem is defined on a 2D grid, global size is nx * nx.
int nx = 30;
GaleriList.set("n", nx * nx);
GaleriList.set("nx", nx);
GaleriList.set("ny", nx);
Teuchos::RefCountPtr<Epetra_Map> Map = Teuchos::rcp( Galeri::CreateMap64("Linear", Comm, GaleriList) );
Teuchos::RefCountPtr<Epetra_RowMatrix> A = Teuchos::rcp( Galeri::CreateCrsMatrix("Laplace2D", &*Map, GaleriList) );
// =============================================================== //
// B E G I N N I N G O F I F P A C K C O N S T R U C T I O N //
// =============================================================== //
Teuchos::ParameterList List;
// allocates an IFPACK factory. No data is associated
// to this object (only method Create()).
Ifpack Factory;
// create the preconditioner. For valid PrecType values,
// please check the documentation
string PrecType = "ILU"; // incomplete LU
int OverlapLevel = 1; // must be >= 0. If Comm.NumProc() == 1,
// it is ignored.
Teuchos::RefCountPtr<Ifpack_Preconditioner> Prec = Teuchos::rcp( Factory.Create(PrecType, &*A, OverlapLevel) );
assert(Prec != Teuchos::null);
// specify parameters for ILU
List.set("fact: drop tolerance", 1e-9);
List.set("fact: level-of-fill", 1);
// the combine mode is on the following:
// "Add", "Zero", "Insert", "InsertAdd", "Average", "AbsMax"
// Their meaning is as defined in file Epetra_CombineMode.h
List.set("schwarz: combine mode", "Add");
// sets the parameters
IFPACK_CHK_ERR(Prec->SetParameters(List));
// initialize the preconditioner. At this point the matrix must
// have been FillComplete()'d, but actual values are ignored.
IFPACK_CHK_ERR(Prec->Initialize());
// Builds the preconditioners, by looking for the values of
// the matrix.
IFPACK_CHK_ERR(Prec->Compute());
// =================================================== //
// E N D O F I F P A C K C O N S T R U C T I O N //
// =================================================== //
// At this point, we need some additional objects
// to define and solve the linear system.
// defines LHS and RHS
Epetra_Vector LHS(A->OperatorDomainMap());
Epetra_Vector RHS(A->OperatorDomainMap());
// solution is constant
LHS.PutScalar(1.0);
// now build corresponding RHS
A->Apply(LHS,RHS);
// now randomize the solution
RHS.Random();
// need an Epetra_LinearProblem to define AztecOO solver
Epetra_LinearProblem Problem(&*A,&LHS,&RHS);
// now we can allocate the AztecOO solver
AztecOO Solver(Problem);
// specify solver
Solver.SetAztecOption(AZ_solver,AZ_gmres);
Solver.SetAztecOption(AZ_output,32);
// HERE WE SET THE IFPACK PRECONDITIONER
Solver.SetPrecOperator(&*Prec);
// .. and here we solve
Solver.Iterate(1550,1e-8);
cout << *Prec;
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return(EXIT_SUCCESS);
}
int main( int argc, char **argv )
{
// check for parallel computation
#ifdef HAVE_MPI
MPI_Init(&argc, &argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
// define main parameters
double c = 0.25; // continuation parameter
int N = 50; // number of grid points
int maxNewtonIters = 20; // max number of Newton iterations
int maxSteps = 75; // max number of continuation steps taken
// Set flag for whether the computations will be Matrix-free (true) or will use a computed
// Jacobian (false)
bool doMatFree = false;
// Create output file to save solutions
ofstream outFile("Heq4.dat");
outFile.setf(ios::scientific, ios::floatfield);
outFile.precision(10);
// Define the problem class
HeqProblem Problem(N,&Comm,outFile);
// Create the initial guess vector and set it to all ones
Epetra_Vector InitialGuess(Problem.GetMap());
InitialGuess.PutScalar(1.0);
// Create the top level parameter list
Teuchos::RCP<Teuchos::ParameterList> ParamList = Teuchos::rcp(new Teuchos::ParameterList);
// Create LOCA sublist
Teuchos::ParameterList& locaParamsList = ParamList->sublist("LOCA");
// Create the sublist for continuation and set the stepper parameters
Teuchos::ParameterList& stepperList = locaParamsList.sublist("Stepper");
stepperList.set("Continuation Method", "Arc Length");// Default
// stepperList.set("Continuation Method", "Natural");
stepperList.set("Continuation Parameter", "c"); // Must set
stepperList.set("Initial Value", c); // Must set
stepperList.set("Max Value", 100.0); // Must set
stepperList.set("Min Value", 0.0); // Must set
stepperList.set("Max Steps", maxSteps); // Should set
stepperList.set("Max Nonlinear Iterations", maxNewtonIters); // Should set
// Set up parameters to compute Eigenvalues
#ifdef HAVE_LOCA_ANASAZI
// Create Anasazi Eigensolver sublist (needs --with-loca-anasazi)
stepperList.set("Compute Eigenvalues",true);
Teuchos::ParameterList& aList = stepperList.sublist("Eigensolver");
aList.set("Method", "Anasazi");
aList.set("Block Size", 1); // Size of blocks
aList.set("Num Blocks", 20); // Size of Arnoldi factorization
aList.set("Num Eigenvalues", 5); // Number of eigenvalues
// aList.set("Sorting Order", "SR");
aList.set("Convergence Tolerance", 2.0e-7); // Tolerance
aList.set("Step Size", 1); // How often to check convergence
aList.set("Maximum Restarts",2); // Maximum number of restarts
aList.set("Verbosity",
Anasazi::Errors +
Anasazi::Warnings +
Anasazi::FinalSummary); // Verbosity
#else
stepperList.set("Compute Eigenvalues",false);
#endif
stepperList.set("Bordered Solver Method", "Householder");
// stepperList.set("Bordered Solver Method", "Bordering");
// Teuchos::ParameterList& nestedList =
// stepperList.sublist("Nested Bordered Solver");
// nestedList.set("Bordered Solver Method", "Householder");
// nestedList.set("Include UV In Preconditioner", true);
// //nestedList.set("Use P For Preconditioner", true);
// nestedList.set("Preconditioner Method", "SMW");
// Create bifurcation sublist -- use if not doing turning point
Teuchos::ParameterList& bifurcationList = locaParamsList.sublist("Bifurcation");
bifurcationList.set("Type", "None"); // Default
// Create predictor sublist
Teuchos::ParameterList& predictorList = locaParamsList.sublist("Predictor");
predictorList.set("Method", "Secant"); // Default
// predictorList.set("Method", "Constant"); // Other options
// predictorList.set("Method", "Tangent"); // Other options
// Create step size sublist
Teuchos::ParameterList& stepSizeList = locaParamsList.sublist("Step Size");
stepSizeList.set("Method", "Adaptive"); // Default
stepSizeList.set("Initial Step Size", 0.1); // Should set
stepSizeList.set("Min Step Size", 1.0e-4); // Should set
stepSizeList.set("Max Step Size", 1.0); // Should set
stepSizeList.set("Aggressiveness", 0.1);
// Set up NOX info
Teuchos::ParameterList& nlParams = ParamList->sublist("NOX");
// Set the nonlinear solver method
nlParams.set("Nonlinear Solver", "Line Search Based");
// Set the printing parameters in the "Printing" sublist
Teuchos::ParameterList& printParams = nlParams.sublist("Printing");
printParams.set("MyPID", Comm.MyPID());
printParams.set("Output Precision", 5);
printParams.set("Output Processor", 0);
printParams.set("Output Information",
NOX::Utils::OuterIteration +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::InnerIteration +
NOX::Utils::LinearSolverDetails +
NOX::Utils::Parameters +
NOX::Utils::Details +
NOX::Utils::Warning +
NOX::Utils::StepperIteration +
NOX::Utils::StepperDetails +
NOX::Utils::StepperParameters);
// NOX parameters - Sublist for line search
Teuchos::ParameterList& searchParams = nlParams.sublist("Line Search");
searchParams.set("Method", "Full Step");
// searchParams.set("Method", "Backtrack");
// Sublist for direction
Teuchos::ParameterList& dirParams = nlParams.sublist("Direction");
dirParams.set("Method", "Newton");
Teuchos::ParameterList& newtonParams = dirParams.sublist("Newton");
newtonParams.set("Forcing Term Method", "Constant");
// Sublist for linear solver for the Newton method
Teuchos::ParameterList& lsParams = newtonParams.sublist("Linear Solver");
lsParams.set("Aztec Solver", "GMRES");
lsParams.set("Max Iterations", 800);
lsParams.set("Tolerance", 1e-8);
lsParams.set("Output Frequency", 1);
lsParams.set("Preconditioner", "None");
// lsParams.set("Preconditioner", "AztecOO");
// lsParams.set("Aztec Preconditioner", "ilu");
// lsParams.set("Preconditioner", "Ifpack");
// lsParams.set("Ifpack Preconditioner", "ILU");
// lsParams.set("Preconditioner", "New Ifpack");
// Teuchos::ParameterList& ifpackParams = lsParams.sublist("Ifpack");
// ifpackParams.set("fact: level-of-fill", 1);
// set up the continuation parameter vector
LOCA::ParameterVector p;
p.addParameter("c",c);
// Set up the problem interface
Teuchos::RCP<SimpleProblemInterface> interface =
Teuchos::rcp(new SimpleProblemInterface(&Problem,c) );
Teuchos::RCP<LOCA::Epetra::Interface::Required> iReq = interface;
// Create the operator to hold either the Jacobian matrix or the Matrix-free operator
Teuchos::RCP<Epetra_Operator> A;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac;
// Need a NOX::Epetra::Vector for constructor
// This becomes the initial guess vector that is used for the nonlinear solves
NOX::Epetra::Vector noxInitGuess(InitialGuess, NOX::DeepCopy);
if (doMatFree) {
// Matrix Free application (Epetra Operator):
Teuchos::RCP<NOX::Epetra::MatrixFree> MF =
Teuchos::rcp(new NOX::Epetra::MatrixFree(printParams, interface, noxInitGuess));
A = MF;
iJac = MF;
}
else { // Computed Jacobian application
A = Teuchos::rcp( Problem.GetMatrix(), false );
iJac = interface;
}
// Build the linear system solver
Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> linSys =
Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
iReq,
iJac, A,
noxInitGuess));
// Create the Loca (continuation) vector
NOX::Epetra::Vector locaSoln(noxInitGuess);
// Create Epetra Factory
Teuchos::RCP<LOCA::Abstract::Factory> epetraFactory = Teuchos::rcp(new LOCA::Epetra::Factory);
// Create global data object
Teuchos::RCP<LOCA::GlobalData> globalData = LOCA::createGlobalData(ParamList, epetraFactory);
// Create the Group - must be LOCA group
Teuchos::RCP<LOCA::Epetra::Group> grpPtr =
Teuchos::rcp(new LOCA::Epetra::Group(globalData, printParams,
iReq, locaSoln,
linSys, p));
// Calculate the first F(x0) as a starting point. This is only needed for
// certain status tests, to ensure that an initial residual (|r0|) is calculated
grpPtr->computeF();
// Set up the status tests to check for convergence
// Determines the error tolerance for the Newton solves
Teuchos::RCP<NOX::StatusTest::NormF> testNormF =
Teuchos::rcp(new NOX::StatusTest::NormF(1.0e-4));
// Sets the max number of nonlinear (Newton) iterations that will be taken. If this is not
// already set, it will default to the '20' given
Teuchos::RCP<NOX::StatusTest::MaxIters> testMaxIters =
Teuchos::rcp(new NOX::StatusTest::MaxIters(stepperList.get("Max Nonlinear Iterations", 20)));
// This combination of tests will be used by NOX to determine whether the step converged
Teuchos::RCP<NOX::StatusTest::Combo> combo =
Teuchos::rcp(new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR,
testNormF, testMaxIters));
// This is sample code to write and read parameters to/from a file. Currently not activated!
// To use, change the 'XXXHAVE_TEUCHOS_EXTENDED' TO 'HAVE_TEUCHOS_EXTENDED'
#ifdef XXXHAVE_TEUCHOS_EXTENDED
// Write the parameter list to a file
cout << "Writing parameter list to \"input.xml\"" << endl;
Teuchos::writeParameterListToXmlFile(*ParamList, "input.xml");
// Read in the parameter list from a file
cout << "Reading parameter list from \"input.xml\"" << endl;
Teuchos::RCP<Teuchos::ParameterList> paramList2 =
Teuchos::rcp(new Teuchos::ParameterList);
Teuchos::updateParametersFromXmlFile("input.xml", paramList2.get());
ParamList = paramList2;
#endif
// Create the stepper
LOCA::Stepper stepper(globalData, grpPtr, combo, ParamList);
LOCA::Abstract::Iterator::IteratorStatus status = stepper.run();
// Check if the stepper completed
if (status == LOCA::Abstract::Iterator::Finished)
globalData->locaUtils->out() << "\nAll tests passed!" << endl;
else
if (globalData->locaUtils->isPrintType(NOX::Utils::Error))
globalData->locaUtils->out() << "\nStepper failed to converge!" << endl;
// Output the stepper parameter list info
if (globalData->locaUtils->isPrintType(NOX::Utils::StepperParameters)) {
globalData->locaUtils->out() << endl << "Final Parameters" << endl
<< "*******************" << endl;
stepper.getList()->print(globalData->locaUtils->out());
globalData->locaUtils->out() << endl;
}
// Make sure all processors are done and close the output file
Comm.Barrier();
outFile.close();
// Deallocate memory
LOCA::destroyGlobalData(globalData);
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return(EXIT_SUCCESS);
} // DONE!!