int fevec4(Epetra_Comm& Comm, bool verbose)
{
int NumElements = 4;
Epetra_Map Map(NumElements, 0, Comm);
Epetra_FEVector x1(Map);
const double value = 1.;
x1.PutScalar (value);
// replace one element by itself. processor 0
// does not own this element
const int GID = 3;
x1.ReplaceGlobalValues(1, &GID, &value);
x1.GlobalAssemble (Insert);
if (Map.MyGID(3)) {
//insist that the value for GID==3 is 1:
if (std::abs(x1.Values()[Map.LID(3)] - 1) > 1.e-9) return -1;
}
std::cout << x1;
Comm.Barrier();
// re-apply GlobalAssemble. Nothing should
// happen
x1.GlobalAssemble (Insert);
std::cout << x1;
if (Map.MyGID(3)) {
//insist that the value for GID==3 is 1:
if (std::abs(x1.Values()[Map.LID(3)] - 1) > 1.e-9) return -1;
}
return 0;
}
//============================================================================
void Ifpack_BreakForDebugger(Epetra_Comm& Comm)
{
char hostname[80];
char buf[80];
if (Comm.MyPID() == 0) cout << "Host and Process Ids for tasks" << endl;
for (int i = 0; i <Comm.NumProc() ; i++) {
if (i == Comm.MyPID() ) {
#if defined(TFLOP) || defined(JANUS_STLPORT)
sprintf(buf, "Host: %s PID: %d", "janus", getpid());
#elif defined(_WIN32)
sprintf(buf,"Windows compiler, unknown hostname and PID!");
#else
gethostname(hostname, sizeof(hostname));
sprintf(buf, "Host: %s\tComm.MyPID(): %d\tPID: %d",
hostname, Comm.MyPID(), getpid());
#endif
printf("%s\n",buf);
fflush(stdout);
#if !( defined(_WIN32) )
sleep(1);
#endif
}
}
if(Comm.MyPID() == 0) {
printf("\n");
printf("** Pausing to attach debugger...\n");
printf("** You may now attach debugger to the processes listed above.\n");
printf( "**\n");
printf( "** Enter a character to continue > "); fflush(stdout);
char go;
scanf("%c",&go);
}
Comm.Barrier();
}
//
// 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 MatrixMarketFileToBlockMap( const char *filename, const Epetra_Comm & comm, Epetra_BlockMap * & map) {
const int lineLength = 1025;
char line[lineLength];
char token[lineLength];
int M, N, numProc, MaxElementSize, MinElementSize, NumMyElements, IndexBase, NumGlobalElements, firstGid;
FILE * handle = 0;
bool inHeader = true;
handle = fopen(filename,"r");
if (handle == 0)
EPETRA_CHK_ERR(-1); // file not found
while (inHeader) {
if(fgets(line, lineLength, handle)==0) return(-1);
if(sscanf(line, "%s", token)==0) return(-1);
if (!strcmp(token, "%NumProc:")) inHeader = false;
}
if(fgets(line, lineLength, handle)==0) return(-1); // numProc value
if(sscanf(line, "%s %d", token, &numProc)==0) return(-1);
if(fgets(line, lineLength, handle)==0) return(-1); // MaxElementSize header line
if(fgets(line, lineLength, handle)==0) return(-1); // MaxElementSize value
if(sscanf(line, "%s %d", token, &MaxElementSize)==0) return(-1);
if(fgets(line, lineLength, handle)==0) return(-1); // MinElementSize header line
if(fgets(line, lineLength, handle)==0) return(-1); // MinElementSize value
if(sscanf(line, "%s %d", token, &MinElementSize)==0) return(-1);
if(fgets(line, lineLength, handle)==0) return(-1); // IndexBase header line
if(fgets(line, lineLength, handle)==0) return(-1); // IndexBase value
if(sscanf(line, "%s %d", token, &IndexBase)==0) return(-1);
if(fgets(line, lineLength, handle)==0) return(-1); // NumGlobalElements header line
if(fgets(line, lineLength, handle)==0) return(-1); // NumGlobalElements value
if(sscanf(line, "%s %d", token, &NumGlobalElements)==0) return(-1);
int ierr = 0;
if (comm.NumProc()==numProc) {
if(fgets(line, lineLength, handle)==0) return(-1); // NumMyElements header line
firstGid = 0;
for (int i=0; i<comm.MyPID(); i++) {
if(fgets(line, lineLength, handle)==0) return(-1); // ith NumMyElements value
if(sscanf(line, "%s %d", token, &NumMyElements)==0) return(-1);
firstGid += NumMyElements;
}
if(fgets(line, lineLength, handle)==0) return(-1); // This PE's NumMyElements value
if(sscanf(line, "%s %d", token, &NumMyElements)==0) return(-1);
for (int i=comm.MyPID()+1; i<numProc; i++) {
if(fgets(line, lineLength, handle)==0) return(-1); // ith NumMyElements value (dump these)
}
}
else {
ierr = 1; // Warning error, different number of processors.
if(fgets(line, lineLength, handle)==0) return(-1); // NumMyElements header line
for (int i=0; i<numProc; i++) {
if(fgets(line, lineLength, handle)==0) return(-1); // ith NumMyElements value (dump these)
}
NumMyElements = NumGlobalElements/comm.NumProc();
firstGid = comm.MyPID()*NumMyElements;
int remainder = NumGlobalElements%comm.NumProc();
if (comm.MyPID()<remainder) NumMyElements++;
int extra = remainder;
if (comm.MyPID()<remainder) extra = comm.MyPID();
firstGid += extra;
}
if(fgets(line, lineLength, handle)==0) return(-1); // Number of rows, columns
if(sscanf(line, "%d %d", &M, &N)==0) return(-1);
bool doSizes = (N>1);
Epetra_IntSerialDenseVector v1(NumMyElements);
Epetra_IntSerialDenseVector v2(NumMyElements);
for (int i=0; i<firstGid; i++) {
if(fgets(line, lineLength, handle)==0) return(-1); // dump these
}
if (doSizes) {
for (int i=0; i<NumMyElements; i++) {
if(fgets(line, lineLength, handle)==0) return(-1);
if(sscanf(line, "%d %d", &v1[i], &v2[i])==0) return(-1); // load v1, v2
}
}
else {
for (int i=0; i<NumMyElements; i++) {
if(fgets(line, lineLength, handle)==0) return(-1);
if(sscanf(line, "%d", &v1[i])==0) return(-1); // load v1
v2[i] = MinElementSize; // Fill with constant size
}
}
if (fclose(handle)) return(-1);
comm.Barrier();
if (MinElementSize==1 && MaxElementSize==1)
map = new Epetra_Map(-1, NumMyElements, v1.Values(), IndexBase, comm);
else
map = new Epetra_BlockMap(-1, NumMyElements, v1.Values(), v2.Values(), IndexBase, comm);
return(0);
}
//------------------------------------------------------------------------------
int check_rowpermute_multivector_local(Epetra_Comm& Comm,
bool verbose)
{
int MyPID = Comm.MyPID();
int NumProc = Comm.NumProc();
Comm.Barrier();
bool verbose1 = verbose;
if (verbose) verbose = (MyPID==0);
if (verbose) {
cerr << "================check_rowpermute_multivector_local=========="
<<endl;
}
int NumMyElements = 5;
int NumGlobalElements = NumMyElements*NumProc;
Epetra_Map Map(NumGlobalElements, NumMyElements, 0, Comm);
int* p = new int[NumMyElements];
int firstGlobalRow = MyPID*NumMyElements;
//Set up a permutation that will reverse the order of all LOCAL rows. (i.e.,
//this test won't cause any inter-processor data movement.)
if (verbose) {
cout << "Permutation P:"<<endl;
}
int i;
for(i=0; i<NumMyElements; ++i) {
p[i] = firstGlobalRow+NumMyElements-1-i;
if (verbose1) {
cout << "p["<<firstGlobalRow+i<<"]: "<<p[i]<<endl;
}
}
Epetra_MultiVector v(Map, 3);
double* v0 = v[0];
double* v1 = v[1];
double* v2 = v[2];
for(i=0; i<NumMyElements; ++i) {
v0[i] = 1.0*(firstGlobalRow+i) + 0.1;
v1[i] = 1.0*(firstGlobalRow+i) + 0.2;
v2[i] = 1.0*(firstGlobalRow+i) + 0.3;
}
if (verbose1) {
cout << "*************** MultiVector v: ********************"<<endl;
cout << v << endl;
}
EpetraExt::Permutation<Epetra_MultiVector> P(Copy, Map, p);
Epetra_MultiVector& Pv = P(v);
if (verbose1) {
cout <<"************* permuted MultiVector Pv: ****************"<<endl;
cout << Pv << endl;
}
return(0);
}
//-------------------------------------------------------------------------------
int check_colpermute_crsmatrix(Epetra_Comm& Comm,
bool verbose)
{
int MyPID = Comm.MyPID();
int NumProc = Comm.NumProc();
Comm.Barrier();
bool verbose1 = verbose;
if (verbose) verbose = (MyPID==0);
if (verbose) {
cerr << "================check_colpermute_crsmatrix=========="
<<endl;
}
int NumMyElements = 5;
int NumGlobalElements = NumMyElements*NumProc;
Epetra_Map Map(NumGlobalElements, NumMyElements, 0, Comm);
int* p = new int[NumMyElements];
int firstGlobalRow = MyPID*NumMyElements;
if (verbose) {
cout << "Permutation P:"<<endl;
}
int i;
for(i=0; i<NumMyElements; ++i) {
int row = firstGlobalRow+i;
p[i] = NumGlobalElements - row - 1;
if (verbose1) {
cout << "p["<<firstGlobalRow+i<<"]: "<<p[i]<<endl;
}
}
Epetra_CrsMatrix A(Copy, Map, 1);
int col;
double val;
//set up a tri-diagonal graph.
for(i=0; i<NumMyElements; ++i) {
int row = firstGlobalRow+i;
col = NumGlobalElements - row - 1;
val = 1.0*col;
A.InsertGlobalValues(row, 1, &val, &col);
if (col > 0) {
int colm1 = col-1;
val = 1.0*colm1;
A.InsertGlobalValues(row, 1, &val, &colm1);
}
if (col < NumGlobalElements-1) {
int colp1 = col+1;
val = 1.0*colp1;
A.InsertGlobalValues(row, 1, &val, &colp1);
}
}
A.FillComplete();
if (verbose1) {
cout << "*************** matrix A: ********************"<<endl;
cout << A << endl;
}
EpetraExt::Permutation<Epetra_CrsMatrix> P(Copy, Map, p);
bool column_permutation = true;
Epetra_CrsMatrix& B = P(A, column_permutation);
if (verbose1) {
cout <<"************* column-permuted matrix B: ****************"<<endl;
cout << B << endl;
}
delete [] p;
return(0);
}
//-------------------------------------------------------------------------------
int check_rowpermute_crsmatrix_global_diagonal(Epetra_Comm& Comm,
bool verbose)
{
int MyPID = Comm.MyPID();
int NumProc = Comm.NumProc();
Comm.Barrier();
bool verbose1 = verbose;
if (verbose) verbose = (MyPID==0);
if (verbose) {
cerr << "================check_rowpermute_crsmatrix_global_diagonal=========="
<<endl;
}
int NumMyElements = 5;
int NumGlobalElements = NumMyElements*NumProc;
Epetra_Map Map(NumGlobalElements, NumMyElements, 0, Comm);
int* p = new int[NumMyElements];
int firstGlobalRow = MyPID*NumMyElements;
//Now set up a permutation that will GLOBALLY reverse the order of all rows.
//(i.e., if there are multiple processors, there will be inter-processor
//data movement as rows are migrated.)
int i;
Epetra_CrsMatrix A(Copy, Map, 1);
int col;
double val;
//set up a diagonal matrix A. It's diagonal because that's the easiest
//to fill and to examine output before and after permutation...
for(i=0; i<NumMyElements; ++i) {
int row = firstGlobalRow+i;
val = 1.0*row;
col = row;
A.InsertGlobalValues(row, 1, &val, &col);
}
A.FillComplete();
if (verbose1) {
cout << "******************* matrix A: ****************************"<<endl;
cout << A << endl;
}
if (verbose) {
cout << "Permutation P:"<<endl;
}
for(i=0; i<NumMyElements; ++i) {
int globalrow = NumGlobalElements-(firstGlobalRow+i)-1;
p[i] = globalrow;
if (verbose1) {
cout << "p["<<firstGlobalRow+i<<"]: "<<p[i]<<endl;
}
}
EpetraExt::Permutation<Epetra_CrsMatrix> Pglobal(Copy, Map, p);
Epetra_CrsMatrix& Bglobal = Pglobal(A);
if (verbose1) {
cout << "******************* permuted matrix Bglobal: *******************" <<endl;
cout << Bglobal << endl;
}
return(0);
}
//------------------------------------------------------------------------------
int check_colpermute_crsgraph(Epetra_Comm& Comm,
bool verbose)
{
int MyPID = Comm.MyPID();
int NumProc = Comm.NumProc();
Comm.Barrier();
bool verbose1 = verbose;
if (verbose) verbose = (MyPID==0);
if (verbose) {
cerr << "================check_colpermute_crsgraph=========="
<<endl;
}
int NumMyElements = 5;
int NumGlobalElements = NumMyElements*NumProc;
Epetra_Map Map(NumGlobalElements, NumMyElements, 0, Comm);
int* p = new int[NumMyElements];
int firstGlobalRow = MyPID*NumMyElements;
if (verbose) {
cout << "Permutation P:"<<endl;
}
int i;
for(i=0; i<NumMyElements; ++i) {
int row = firstGlobalRow+i;
p[i] = NumGlobalElements - row - 1;
if (verbose1) {
cout << "p["<<firstGlobalRow+i<<"]: "<<p[i]<<endl;
}
}
Epetra_CrsGraph Agrph(Copy, Map, 1);
int col;
//set up a tri-diagonal graph.
for(i=0; i<NumMyElements; ++i) {
int row = firstGlobalRow+i;
col = NumGlobalElements - row - 1;
Agrph.InsertGlobalIndices(row, 1, &col);
if (col > 0) {
int colm1 = col-1;
Agrph.InsertGlobalIndices(row, 1, &colm1);
}
if (col < NumGlobalElements-1) {
int colp1 = col+1;
Agrph.InsertGlobalIndices(row, 1, &colp1);
}
}
Agrph.FillComplete();
if (verbose1) {
cout << "*************** graph Agrph: ********************"<<endl;
cout << Agrph << endl;
}
EpetraExt::Permutation<Epetra_CrsGraph> P(Copy, Map, p);
bool column_permutation = true;
Epetra_CrsGraph& Bgrph = P(Agrph, column_permutation);
if (verbose1) {
cout <<"************* column-permuted graph Bgrph: ****************"<<endl;
cout << Bgrph << endl;
}
delete [] p;
return(0);
}
//------------------------------------------------------------------------------
int check_rowpermute_crsgraph_local_diagonal(Epetra_Comm& Comm,
bool verbose)
{
int MyPID = Comm.MyPID();
int NumProc = Comm.NumProc();
Comm.Barrier();
bool verbose1 = verbose;
if (verbose) verbose = (MyPID==0);
if (verbose) {
cerr << "================check_rowpermute_crsgraph_local_diagonal=========="
<<endl;
}
int NumMyElements = 5;
int NumGlobalElements = NumMyElements*NumProc;
Epetra_Map Map(NumGlobalElements, NumMyElements, 0, Comm);
int* p = new int[NumMyElements];
int firstGlobalRow = MyPID*NumMyElements;
//Set up a permutation that will reverse the order of all LOCAL rows. (i.e.,
//this test won't cause any inter-processor data movement.)
if (verbose) {
cout << "Permutation P:"<<endl;
}
int i;
for(i=0; i<NumMyElements; ++i) {
p[i] = firstGlobalRow+NumMyElements-1-i;
if (verbose1) {
cout << "p["<<firstGlobalRow+i<<"]: "<<p[i]<<endl;
}
}
Epetra_CrsGraph Agrph(Copy, Map, 1);
int col;
//set up a diagonal graph. It's diagonal because that's the easiest
//to fill and to examine output before and after permutation...
for(i=0; i<NumMyElements; ++i) {
int row = firstGlobalRow+i;
col = row;
Agrph.InsertGlobalIndices(row, 1, &col);
}
Agrph.FillComplete();
if (verbose1) {
cout << "*************** graph Agrph: ********************"<<endl;
cout << Agrph << endl;
}
EpetraExt::Permutation<Epetra_CrsGraph> P(Copy, Map, p);
Epetra_CrsGraph& Bgrph = P(Agrph);
if (verbose1) {
cout <<"************* permuted graph Bgrph: ****************"<<endl;
cout << Bgrph << endl;
}
return(0);
}
int Amesos_TestSolver( Epetra_Comm &Comm, char *matrix_file,
SparseSolverType SparseSolver,
bool transpose,
int special, AMESOS_MatrixType matrix_type ) {
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" ) {
// Call routine to read in unsymmetric Triplet matrix
NonContiguousMap = true;
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 ;
}
Epetra_RowMatrix * passA = 0;
Epetra_Vector * passx = 0;
Epetra_Vector * passb = 0;
Epetra_Vector * passxexact = 0;
Epetra_Vector * passresid = 0;
Epetra_Vector * passtmp = 0;
// 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 ) ;
}
Epetra_CrsMatrix A(Copy, *map_, 0);
const Epetra_Map &OriginalMap = serialA->RowMatrixRowMap() ;
assert( OriginalMap.SameAs(*readMap) );
Epetra_Export exporter(OriginalMap, *map_);
Epetra_Export exporter2(OriginalMap, *map_);
Epetra_Export MatrixExporter(OriginalMap, *map_);
Epetra_CrsMatrix AwithDiag(Copy, *map_, 0);
Epetra_Vector x(*map_);
Epetra_Vector b(*map_);
Epetra_Vector xexact(*map_);
Epetra_Vector resid(*map_);
Epetra_Vector readresid(*readMap);
Epetra_Vector tmp(*map_);
Epetra_Vector readtmp(*readMap);
// Epetra_Vector xcomp(*map_); // X as computed by the solver
bool distribute_matrix = ( matrix_type == AMESOS_Distributed ) ;
if ( distribute_matrix ) {
// Create Exporter to distribute read-in matrix and vectors
//
// Initialize x, b and xexact to the values read in from the file
//
x.Export(*readx, exporter, Add);
b.Export(*readb, exporter, Add);
xexact.Export(*readxexact, exporter, Add);
Comm.Barrier();
A.Export(*serialA, exporter, Add);
assert(A.FillComplete()==0);
Comm.Barrier();
passA = &A;
passx = &x;
passb = &b;
passxexact = &xexact;
passresid = &resid;
passtmp = &tmp;
} else {
passA = serialA;
passx = readx;
passb = readb;
passxexact = readxexact;
passresid = &readresid;
passtmp = &readtmp;
}
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 );
for ( int i = 0; i < 1+special ; i++ ) {
Epetra_Time TotalTime( Comm ) ;
if ( false ) {
// TEST_UMFPACK is never set by configure
#ifdef HAVE_AMESOS_SUPERLUDIST
} else if ( SparseSolver == SUPERLUDIST ) {
Teuchos::ParameterList ParamList ;
ParamList.set( "MaxProcs", -3 );
Amesos_Superludist A_Superludist( Problem ) ;
//ParamList.set( "Redistribute", true );
//ParamList.set( "AddZeroToDiag", true );
Teuchos::ParameterList& SuperludistParams = ParamList.sublist("Superludist") ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( A_Superludist.SetParameters( ParamList ) );
EPETRA_CHK_ERR( A_Superludist.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( A_Superludist.SymbolicFactorization( ) );
EPETRA_CHK_ERR( A_Superludist.NumericFactorization( ) );
EPETRA_CHK_ERR( A_Superludist.Solve( ) );
#endif
#ifdef HAVE_AMESOS_DSCPACK
} else if ( SparseSolver == DSCPACK ) {
Teuchos::ParameterList ParamList ;
ParamList.set( "MaxProcs", -3 );
Amesos_Dscpack A_dscpack( Problem ) ;
EPETRA_CHK_ERR( A_dscpack.SetParameters( ParamList ) );
EPETRA_CHK_ERR( A_dscpack.SymbolicFactorization( ) );
EPETRA_CHK_ERR( A_dscpack.NumericFactorization( ) );
EPETRA_CHK_ERR( A_dscpack.Solve( ) );
#endif
#ifdef HAVE_AMESOS_SCALAPACK
} else if ( SparseSolver == SCALAPACK ) {
Teuchos::ParameterList ParamList ;
Amesos_Scalapack A_scalapack( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( A_scalapack.SetParameters( ParamList ) );
EPETRA_CHK_ERR( A_scalapack.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( A_scalapack.SymbolicFactorization( ) );
EPETRA_CHK_ERR( A_scalapack.NumericFactorization( ) );
EPETRA_CHK_ERR( A_scalapack.Solve( ) );
#endif
#ifdef HAVE_AMESOS_TAUCS
} else if ( SparseSolver == TAUCS ) {
Teuchos::ParameterList ParamList ;
Amesos_Taucs A_taucs( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( A_taucs.SetParameters( ParamList ) );
EPETRA_CHK_ERR( A_taucs.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( A_taucs.SymbolicFactorization( ) );
EPETRA_CHK_ERR( A_taucs.NumericFactorization( ) );
EPETRA_CHK_ERR( A_taucs.Solve( ) );
#endif
#ifdef HAVE_AMESOS_PARDISO
} else if ( SparseSolver == PARDISO ) {
Teuchos::ParameterList ParamList ;
Amesos_Pardiso A_pardiso( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( A_pardiso.SetParameters( ParamList ) );
EPETRA_CHK_ERR( A_pardiso.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( A_pardiso.SymbolicFactorization( ) );
EPETRA_CHK_ERR( A_pardiso.NumericFactorization( ) );
EPETRA_CHK_ERR( A_pardiso.Solve( ) );
#endif
#ifdef HAVE_AMESOS_PARAKLETE
} else if ( SparseSolver == PARAKLETE ) {
Teuchos::ParameterList ParamList ;
Amesos_Paraklete A_paraklete( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( A_paraklete.SetParameters( ParamList ) );
EPETRA_CHK_ERR( A_paraklete.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( A_paraklete.SymbolicFactorization( ) );
EPETRA_CHK_ERR( A_paraklete.NumericFactorization( ) );
EPETRA_CHK_ERR( A_paraklete.Solve( ) );
#endif
#ifdef HAVE_AMESOS_MUMPS
} else if ( SparseSolver == MUMPS ) {
Teuchos::ParameterList ParamList ;
Amesos_Mumps A_mumps( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( A_mumps.SetParameters( ParamList ) );
EPETRA_CHK_ERR( A_mumps.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( A_mumps.SymbolicFactorization( ) );
EPETRA_CHK_ERR( A_mumps.NumericFactorization( ) );
EPETRA_CHK_ERR( A_mumps.Solve( ) );
#endif
#ifdef HAVE_AMESOS_SUPERLU
} else if ( SparseSolver == SUPERLU ) {
Teuchos::ParameterList ParamList ;
Amesos_Superlu A_superlu( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( A_superlu.SetParameters( ParamList ) );
EPETRA_CHK_ERR( A_superlu.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( A_superlu.SymbolicFactorization( ) );
EPETRA_CHK_ERR( A_superlu.NumericFactorization( ) );
EPETRA_CHK_ERR( A_superlu.Solve( ) );
#endif
#ifdef HAVE_AMESOS_LAPACK
} else if ( SparseSolver == LAPACK ) {
Teuchos::ParameterList ParamList ;
Amesos_Lapack A_lapack( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( A_lapack.SetParameters( ParamList ) );
EPETRA_CHK_ERR( A_lapack.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( A_lapack.SymbolicFactorization( ) );
EPETRA_CHK_ERR( A_lapack.NumericFactorization( ) );
EPETRA_CHK_ERR( A_lapack.Solve( ) );
#endif
#ifdef HAVE_AMESOS_UMFPACK
} else if ( SparseSolver == UMFPACK ) {
Teuchos::ParameterList ParamList ;
Amesos_Umfpack A_umfpack( Problem ) ;
ParamList.set( "MaxProcs", -3 );
EPETRA_CHK_ERR( A_umfpack.SetParameters( ParamList ) );
EPETRA_CHK_ERR( A_umfpack.SetUseTranspose( transpose ) );
EPETRA_CHK_ERR( A_umfpack.SymbolicFactorization( ) );
EPETRA_CHK_ERR( A_umfpack.NumericFactorization( ) );
EPETRA_CHK_ERR( A_umfpack.Solve( ) );
#endif
#ifdef HAVE_AMESOS_KLU
} else if ( SparseSolver == KLU ) {
using namespace Teuchos;
Amesos_Time AT;
int setupTimePtr = -1, symTimePtr = -1, numTimePtr = -1, refacTimePtr = -1, solveTimePtr = -1;
AT.CreateTimer(Comm, 2);
AT.ResetTimer(0);
Teuchos::ParameterList ParamList ;
// ParamList.set("OutputLevel",2);
Amesos_Klu A_klu( Problem );
ParamList.set( "MaxProcs", -3 );
ParamList.set( "TrustMe", false );
// ParamList.set( "Refactorize", true );
EPETRA_CHK_ERR( A_klu.SetParameters( ParamList ) ) ;
EPETRA_CHK_ERR( A_klu.SetUseTranspose( transpose ) );
setupTimePtr = AT.AddTime("Setup", setupTimePtr, 0);
EPETRA_CHK_ERR( A_klu.SymbolicFactorization( ) );
symTimePtr = AT.AddTime("Symbolic", symTimePtr, 0);
EPETRA_CHK_ERR( A_klu.NumericFactorization( ) );
numTimePtr = AT.AddTime("Numeric", numTimePtr, 0);
EPETRA_CHK_ERR( A_klu.NumericFactorization( ) );
refacTimePtr = AT.AddTime("Refactor", refacTimePtr, 0);
// for ( int i=0; i<100000 ; i++ )
EPETRA_CHK_ERR( A_klu.Solve( ) );
solveTimePtr = AT.AddTime("Solve", solveTimePtr, 0);
double SetupTime = AT.GetTime(setupTimePtr);
double SymbolicTime = AT.GetTime(symTimePtr);
double NumericTime = AT.GetTime(numTimePtr);
double RefactorTime = AT.GetTime(refacTimePtr);
double SolveTime = AT.GetTime(solveTimePtr);
std::cout << __FILE__ << "::" << __LINE__ << " SetupTime = " << SetupTime << std::endl ;
std::cout << __FILE__ << "::" << __LINE__ << " SymbolicTime = " << SymbolicTime - SetupTime << std::endl ;
std::cout << __FILE__ << "::" << __LINE__ << " NumericTime = " << NumericTime - SymbolicTime<< std::endl ;
std::cout << __FILE__ << "::" << __LINE__ << " RefactorTime = " << RefactorTime - NumericTime << std::endl ;
std::cout << __FILE__ << "::" << __LINE__ << " SolveTime = " << SolveTime - RefactorTime << std::endl ;
#endif
} else {
SparseDirectTimingVars::log_file << "Solver not implemented yet" << std::endl ;
std::cerr << "\n\n#################### Requested solver not available on this platform ##################### ATS\n" << std::endl ;
std::cout << " SparseSolver = " << SparseSolver << std::endl ;
std::cerr << " SparseSolver = " << SparseSolver << std::endl ;
}
SparseDirectTimingVars::SS_Result.Set_Total_Time( TotalTime.ElapsedTime() );
} // end for (int i=0; i<special; i++ )
//
// Compute the error = norm(xcomp - xexact )
//
double error;
passresid->Update(1.0, *passx, -1.0, *passxexact, 0.0);
passresid->Norm2(&error);
SparseDirectTimingVars::SS_Result.Set_Error(error) ;
// passxexact->Norm2(&error ) ;
// passx->Norm2(&error ) ;
//
// Compute the residual = norm(Ax - b)
//
double residual ;
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);
SparseDirectTimingVars::SS_Result.Set_Residual(residual) ;
double bnorm;
passb->Norm2( &bnorm ) ;
SparseDirectTimingVars::SS_Result.Set_Bnorm(bnorm) ;
double xnorm;
passx->Norm2( &xnorm ) ;
SparseDirectTimingVars::SS_Result.Set_Xnorm(xnorm) ;
delete readA;
delete readx;
delete readb;
delete readxexact;
delete readMap;
delete map_;
Comm.Barrier();
return 0;
}