Amesos Package Browser (Single Doxygen Collection) Development
TestAllClasses.cpp
Go to the documentation of this file.
00001 #include "Epetra_Comm.h"
00002 #include "Epetra_Map.h"
00003 #include "Epetra_CrsMatrix.h"
00004 #include "TestAllClasses.h"
00005 #include "TestOtherClasses.h"
00006 #include "TestSuperludist.h"
00007 #include "TestScalapack.h"
00008 #include "TestKlu.h"
00009 #include "Amesos.h"
00010  
00011 int TestAllClasses( const std::vector<std::string> AmesosClasses,
00012         int EpetraMatrixType,
00013         const std::vector<bool> AmesosClassesInstalled,
00014         Epetra_CrsMatrix *& Amat, 
00015         const bool transpose, 
00016         const bool verbose, 
00017         const bool symmetric, 
00018         const int Levels,
00019         const double Rcond,
00020         int Diagonal,
00021         int ReindexRowMap,
00022         int ReindexColMap,
00023         int RangeMapType,
00024         int DomainMapType,
00025         bool distribute,
00026         char *filename,
00027         double &maxrelerror, 
00028         double &maxrelresidual,
00029         int &NumTests ) {
00030 
00031   assert( NumTests == 0 ) ; 
00032 
00033   bool RowMapEqualsColMap = ( ReindexColMap == 0 ) ; 
00034 
00035 
00036   std::string StringFilename = filename ; 
00037   bool bcsstk04 = ( StringFilename.find("bcsstk04") < StringFilename.find("xdz_notaname_garbage") );
00038   bool Khead = ( StringFilename.find("Khead") < StringFilename.find("xdz_notaname_garbage") );
00039   bool Superlu_rua = ( StringFilename.find("Superlu") < StringFilename.find("xdz_notaname_garbage") );
00040   bool ImpcolB = ( StringFilename.find("ImpcolB") < StringFilename.find("xdz_notaname_garbage") );
00041   bool a662_bus_out = ( StringFilename.find("662_bus_out") < StringFilename.find("xdz_notaname_garbage") );
00042   bool MissingADiagonal = ( StringFilename.find("MissingADiagonal") < StringFilename.find("xdz_notaname_garbage") ) ||
00043     ( StringFilename.find("ImpcolB.rua") < StringFilename.find("xdz_notaname_garbage") );
00044   bool FileIsDiagonal = ( StringFilename.find("Diagonal") < StringFilename.find("xdz_notaname_garbage") ) &&
00045     ! MissingADiagonal ; 
00046 
00047   bool NumericallySingular = ( StringFilename.find("NumericallySingular") < StringFilename.find("xdz_notaname_garbage") );
00048   bool StructurallySingular = ( StringFilename.find("StructurallySingular") < StringFilename.find("xdz_notaname_garbage") );
00049 
00050   int ExpectedError = 0;
00051   if ( NumericallySingular ) ExpectedError = NumericallySingularMatrixError ;
00052   if ( StructurallySingular ) ExpectedError = StructurallySingularMatrixError ;
00053 
00054   const Epetra_Map& row_map = Amat->RowMap() ; 
00055 
00056   const int NumAmesosClasses = AmesosClasses.size();
00057   int errors = 0 ;
00058 
00059   if ( (  ReindexRowMap != 0 ||  ReindexColMap != 0  ) && EpetraMatrixType == 1 ) 
00060     return 0 ;   //  Can't reindex a RowMatrix because we don't know the indices up front 
00061 
00062 
00063 
00064   bool ReIndex = ReindexRowMap || ReindexColMap ; 
00065 
00066   for (int i=0; i < NumAmesosClasses; i++ ) {
00067     if ( AmesosClassesInstalled[i] ) { 
00068       int Errors = 0 ; 
00069       int NumTheseTests = 0 ; 
00070       if ( Amat->Comm().MyPID() == 0 ) {
00071   if ( verbose  &&  ( ! ReIndex ) ) { 
00072   
00073     std::cout << "TestAllClasses.cpp::"  << __LINE__
00074          << " Perhaps about to test " 
00075          << AmesosClasses[i] << " "  
00076          << " EMT=" <<  EpetraMatrixType 
00077          << " tr=" <<  transpose 
00078          << " sym=" <<  symmetric 
00079          << " L=" <<  Levels 
00080          << " D=" <<  Diagonal 
00081          << " RRM= " <<  ReindexRowMap 
00082          << " RCM= " <<  ReindexColMap 
00083          << " DMT= " <<  DomainMapType 
00084          << " RMT= " <<  RangeMapType 
00085          << " d=" <<  distribute 
00086          << " fn= " <<  filename 
00087          << std::endl ;  
00088   }
00089       }
00090       if ( AmesosClasses[i] == "Amesos_Scalapack") { 
00091   bool RunScalapackTest = true;
00092   if ( ExpectedError != 0 )  RunScalapackTest = false ;   //  Bug #1227
00093   if ( ReindexRowMap || ReindexColMap ) RunScalapackTest = false ;   //  Bug #969
00094   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) 
00095     RunScalapackTest = false ;   //  Bug #1403
00096   if ( RunScalapackTest && verbose) std::cout << " Testing SCALAPACK " << std::endl ; 
00097   if ( RunScalapackTest ) Errors = TestScalapack( Amat, 
00098                EpetraMatrixType,
00099                transpose, 
00100                verbose, 
00101                Levels, 
00102                Rcond, 
00103                maxrelerror, 
00104                maxrelresidual, 
00105                NumTheseTests ) ;
00106 
00107       } else if ( AmesosClasses[i] == "Amesos_Umfpack" ) {
00108   bool RunUmfpackTest = true;
00109   if ( ( ReindexRowMap != 0  || ReindexColMap != 0 ) && row_map.DistributedGlobal() ) 
00110     RunUmfpackTest = false ;   //  Bug #969
00111   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) 
00112     RunUmfpackTest = false ;   //  Bug #1403
00113   if ( ExpectedError != 0 )  RunUmfpackTest = false ;   //  Bug #1227
00114 
00115   if ( RunUmfpackTest && verbose) std::cout << " Testing UMFPACK " << std::endl ; 
00116   
00117   if ( RunUmfpackTest ) Errors = TestOtherClasses("Amesos_Umfpack",
00118                EpetraMatrixType,
00119                Amat, 
00120                transpose, 
00121                verbose, 
00122                Levels, 
00123                Rcond, 
00124                RowMapEqualsColMap,
00125                false,
00126               ExpectedError,
00127                maxrelerror, 
00128                maxrelresidual, 
00129                NumTheseTests ) ;
00130 #if 0
00131 
00132   Calling TestOtherClasses to test Amesos_Klu, ought to work, but it crashes
00133 
00134       } else if ( AmesosClasses[i] == "Amesos_Klu" ) {
00135   bool RunKluTest = true;
00136   //  We only test reindexing on klu and paraklete
00137   if ( ( verbose  &&  ( ReIndex ) ) { 
00138     
00139     std::cout << __FILE__ << "::"  << __LINE__
00140          << " Perhaps about to test " 
00141          << AmesosClasses[i] << " "  
00142          << " EpetraMatrixType = " <<  EpetraMatrixType 
00143          << " transpose = " <<  transpose 
00144          << " symmetric = " <<  symmetric 
00145          << " Levels = " <<  Levels 
00146          << " Diagonal = " <<  Diagonal 
00147          << " ReindexRowMap = " <<  ReindexRowMap 
00148          << " ReindexColMap = " <<  ReindexColMap 
00149          << " DomainMapType = " <<  DomainMapType 
00150          << " RangeMapType = " <<  RangeMapType 
00151          << " distribute = " <<  distribute 
00152          << " filename = " <<  filename 
00153          << std::endl ;  
00154   }
00155   if ( ( ReindexRowMap != 0  || ReindexColMap != 0 ) && row_map.DistributedGlobal() ) 
00156     RunKluTest = false ;   //  Bug #969
00157   if ( (   ReindexColMap != 0  ) )  //  Bug #969
00158     RunKluTest = false ;   //  Bug #969
00159   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) 
00160     RunKluTest = false ;   //  Bug #1403
00161   if ( ExpectedError != 0 )  RunUmfpackTest = false ;   //  Bug #1227
00162 
00163 
00164 
00165 
00166   if ( RunKluTest && verbose) std::cout << " Testing KLU " << std::endl ; 
00167   
00168   if ( RunKluTest ) Errors = TestOtherClasses("Amesos_Klu",
00169                EpetraMatrixType,
00170                Amat, 
00171                transpose, 
00172                verbose, 
00173                Levels, 
00174                Rcond, 
00175                RowMapEqualsColMap,
00176                false,
00177                 ExpectedError,
00178                maxrelerror, 
00179                maxrelresidual, 
00180                NumTheseTests ) ;
00181 #endif
00182       } else if ( AmesosClasses[i] == "Amesos_Lapack" ) {
00183   bool RunLapackTest = true;
00184   if ( ExpectedError == NumericallySingularMatrixError )  RunLapackTest = false ;   //  Bug #1227
00185   if ( ( ReindexRowMap != 0  || ReindexColMap != 0 ) && row_map.DistributedGlobal() ) 
00186     RunLapackTest = false ;   //  Bug #969
00187   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) 
00188     RunLapackTest = false ;   //  Bug #1403
00189 
00190   if ( RunLapackTest && verbose) std::cout << " Testing LAPACK " << std::endl ; 
00191   
00192   if ( RunLapackTest ) Errors = TestOtherClasses("Amesos_Lapack",
00193                    EpetraMatrixType,
00194                    Amat, 
00195                    transpose, 
00196                    verbose, 
00197                    Levels, 
00198                    Rcond, 
00199                    RowMapEqualsColMap,
00200                    false,
00201                    ExpectedError,
00202                    maxrelerror, 
00203                    maxrelresidual, 
00204                    NumTheseTests ) ;
00205       } else if ( AmesosClasses[i] == "Amesos_Taucs" ) {
00206   bool RunTaucsTest = true;
00207   if ( ExpectedError != 0 )  RunTaucsTest = false ;   //  Bug #1227
00208   if ( ( ReindexRowMap != 0  || ReindexColMap != 0 ) ) 
00209     RunTaucsTest = false ;   //  Bug #969
00210   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) 
00211     RunTaucsTest = false ;   //  Bug #1403
00212   //  if ( MissingADiagonal ) RunTaucsTest = false ; // Bug #1449
00213   //  if ( transpose ) RunTaucsTest = false ; // Bug #1579
00214   if ( a662_bus_out)  RunTaucsTest = false ; // Bug #1449
00215   if ( ! symmetric ) RunTaucsTest = false ; 
00216   if ( Khead ) RunTaucsTest = false ;   // Bug #1449
00217 
00218   if ( RunTaucsTest && verbose) std::cout << " Testing TAUCS " << std::endl ; 
00219   
00220   
00221   if ( RunTaucsTest ) Errors = TestOtherClasses("Amesos_Taucs",
00222                   EpetraMatrixType,
00223                   Amat, 
00224                   transpose, 
00225                   verbose, 
00226                   Levels, 
00227                   Rcond, 
00228                   RowMapEqualsColMap,
00229                   false, 
00230                    ExpectedError,
00231                   maxrelerror, 
00232                   maxrelresidual, 
00233                   NumTheseTests ) ;
00234 
00235       } else if ( AmesosClasses[i] == "Amesos_Pardiso" ) {
00236   bool RunPardisoTest = true;
00237   if ( ExpectedError != 0 )  RunPardisoTest = false ;   //  Bug #1227
00238   if ( ReindexRowMap != 0  || ReindexColMap != 0 ) // Bug #969 
00239     RunPardisoTest = false ;   //  Bug #969
00240   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) 
00241     RunPardisoTest = false ;   //  Bug #1403
00242   if ( bcsstk04 ) RunPardisoTest = false ;   // Bug #1916
00243   if ( a662_bus_out )  RunPardisoTest = false ; // Bug #1916
00244   if ( transpose ) RunPardisoTest = false ;   // Bug #1992
00245   if ( MissingADiagonal ) RunPardisoTest = false ; // Bug #1916 
00246   if ( Khead ) RunPardisoTest = false ; // Bug #1916 
00247   if ( EpetraMatrixType == 1 )  RunPardisoTest = false ; // Bug #1994 
00248   if ( distribute )  RunPardisoTest = false ; // Bug #1995
00249   if ( RunPardisoTest && verbose) std::cout << " Testing PARDISO " << std::endl ; 
00250   if ( Amat->Comm().NumProc() > 1 ) RunPardisoTest = false ; 
00251 
00252   if ( RunPardisoTest ) Errors = TestOtherClasses("Amesos_Pardiso",
00253                EpetraMatrixType,
00254                Amat, 
00255                transpose, 
00256                verbose, 
00257                Levels, 
00258                Rcond, 
00259                RowMapEqualsColMap,
00260                false,
00261               ExpectedError,
00262                maxrelerror, 
00263                maxrelresidual, 
00264                NumTheseTests ) ;
00265 
00266       } else if ( AmesosClasses[i] == "Amesos_Mumps" ) {
00267   bool RunMumpsTest = true;
00268   if ( ExpectedError != 0 )  RunMumpsTest = false ;   //  Bug #1227
00269   if ( ( ReindexRowMap || ReindexColMap ) ) 
00270     RunMumpsTest = false ;   //  Bug #969
00271   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) RunMumpsTest = false ;   //  Bug #1403
00272   if ( MissingADiagonal ) RunMumpsTest = false ; // Bug #1435
00273   if ( distribute )  RunMumpsTest = false ; // Bug #
00274   if (  RunMumpsTest && verbose) std::cout << " Testing MUMPS " << std::endl ; 
00275 
00276   if ( RunMumpsTest ) Errors = TestOtherClasses("Amesos_Mumps",
00277                EpetraMatrixType,
00278                    Amat, 
00279                    transpose, 
00280                    verbose, 
00281                    Levels, 
00282                    Rcond, 
00283                    RowMapEqualsColMap,
00284                   false,
00285                   ExpectedError,
00286                    maxrelerror, 
00287                    maxrelresidual, 
00288                    NumTheseTests ) ;
00289 
00290       } else if ( AmesosClasses[i] == "Amesos_Klu" ) {
00291   bool RunKluTest = true;
00292   if ( (   ReindexColMap != 0  ) )  //  Bug #969
00293     RunKluTest = false ;   //  Bug #969
00294 
00295   //  if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) RunKluTest = false ;   //  Bug #1403
00296 
00297   Teuchos::ParameterList ParamList;
00298   if ( ReindexRowMap != 0 )  ParamList.set( "Reindex", true );
00299   if ( ( RangeMapType != 0 || DomainMapType != 0 || distribute ) ) 
00300     ParamList.set( "DontTrustMe", true );
00301 #ifndef HAVE_AMESOS_EPETRAEXT
00302   if ( ( ReindexRowMap || ReindexColMap ) ) 
00303     RunKluTest = false ;  
00304 #endif
00305   if ( ImpcolB ) RunKluTest = false ;   // See bug #1928 
00306   if ( ( RangeMapType ==2 && DomainMapType == 1 && distribute == 1 && EpetraMatrixType == 2 && transpose == 0 && Superlu_rua ) ) RunKluTest = false ;   //  Bug #2000
00307 
00308   if ( RunKluTest && verbose) std::cout << " Testing KLU " << std::endl ; 
00309   if ( RunKluTest && verbose) std::cout << " Testing KLU ExpectedError = " 
00310            << ExpectedError << std::endl ; 
00311 
00312   if ( RunKluTest ) Errors = TestKlu( Amat, 
00313               EpetraMatrixType,
00314               transpose, 
00315               verbose, 
00316               Levels,
00317               Rcond, 
00318               ParamList, 
00319               RowMapEqualsColMap, 
00320               false,
00321               ExpectedError,
00322               maxrelerror, 
00323               maxrelresidual, 
00324               NumTheseTests ) ;
00325   
00326   if ( Amat->Comm().MyPID() == 0 && Errors ) 
00327     std::cout << " FAILURE in "  
00328          << __FILE__ << "::"  << __LINE__
00329          << " Amesos_Klu" 
00330          << " EpetraMatrixType = " <<  EpetraMatrixType 
00331          << " transpose = " <<  transpose 
00332          << " symmetric = " <<  symmetric 
00333          << " Levels = " <<  Levels 
00334          << " Diagonal = " <<  Diagonal 
00335          << " ReindexRowMap = " <<  ReindexRowMap 
00336          << " ReindexColMap = " <<  ReindexColMap 
00337          << " DomainMapType = " <<  DomainMapType 
00338          << " RangeMapType = " <<  RangeMapType 
00339          << " distribute = " <<  distribute 
00340          << " filename = " <<  filename 
00341          << " NumTheseTests = " <<  NumTheseTests 
00342          << " Errors = " <<  Errors << std::endl ;  
00343 
00344       } else if ( AmesosClasses[i] == "Amesos_Superlu" ) {
00345   bool RunSuperluTest = true;
00346   if ( ExpectedError != 0 )  RunSuperluTest = false ;   //  Bug #1227
00347   if ( (  ReindexRowMap != 0 ||  ReindexColMap != 0  ) && Amat->Comm().NumProc() > 1  )  //  Bug #969
00348     RunSuperluTest = false ;   //  Bug #969
00349   if ( MissingADiagonal ) RunSuperluTest = false ; // Bug #1404
00350   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) RunSuperluTest = false ;   //  Bug #1403
00351   if ( bcsstk04 && transpose ) RunSuperluTest = false ;  // Bug #1927 
00352   if ( a662_bus_out && transpose ) RunSuperluTest = false ;  // Bug #1927 
00353   if ( Khead ) RunSuperluTest= false ;  // Bug #1927 
00354 
00355   if ( RunSuperluTest ) {
00356     if ( verbose) std::cout << " Testing SUPERLU " << std::endl ; 
00357     Errors = TestOtherClasses("Amesos_Superlu",
00358                EpetraMatrixType,
00359              Amat, 
00360              transpose, 
00361              verbose, 
00362              Levels, 
00363              Rcond, 
00364              RowMapEqualsColMap,
00365              false,
00366                    ExpectedError,
00367              maxrelerror, 
00368              maxrelresidual, 
00369              NumTheseTests ) ;
00370   }
00371   if ( Amat->Comm().MyPID() == 0 && Errors ) 
00372     std::cout << " FAILURE in " 
00373          << __FILE__ << "::"  << __LINE__
00374          << " Amesos_Superlu" 
00375          << " EpetraMatrixType = " <<  EpetraMatrixType 
00376          << " transpose = " <<  transpose 
00377          << " symmetric = " <<  symmetric 
00378          << " Levels = " <<  Levels 
00379          << " Diagonal = " <<  Diagonal 
00380          << " ReindexRowMap = " <<  ReindexRowMap 
00381          << " ReindexColMap = " <<  ReindexColMap 
00382          << " DomainMapType = " <<  DomainMapType 
00383          << " RangeMapType = " <<  RangeMapType 
00384          << " distribute = " <<  distribute 
00385          << " filename = " <<  filename 
00386          << " NumTheseTests = " <<  NumTheseTests 
00387          << " Errors = " <<  Errors << std::endl ;  
00388 
00389       } else if ( AmesosClasses[i] == "Amesos_Paraklete" ) {
00390 
00391   //  We only test reindexing on klu and paraklete
00392   if ( verbose  &&  ( ReIndex ) ) { 
00393     
00394     std::cout << __FILE__ << "::"  << __LINE__
00395          << " Perhaps about to test " 
00396          << AmesosClasses[i] << " "  
00397          << " EpetraMatrixType = " <<  EpetraMatrixType 
00398          << " transpose = " <<  transpose 
00399          << " symmetric = " <<  symmetric 
00400          << " Levels = " <<  Levels 
00401          << " Diagonal = " <<  Diagonal 
00402          << " ReindexRowMap = " <<  ReindexRowMap 
00403          << " ReindexColMap = " <<  ReindexColMap 
00404          << " DomainMapType = " <<  DomainMapType 
00405          << " RangeMapType = " <<  RangeMapType 
00406          << " distribute = " <<  distribute 
00407          << " filename = " <<  filename 
00408          << std::endl ;  
00409   }
00410   bool RunParakleteTest = true;
00411   if ( ExpectedError != 0 )  RunParakleteTest = false ;   //  Bug #1227
00412   if ( (   ReindexColMap != 0  ) )  //  Bug #969
00413     RunParakleteTest = false ;   //  Bug #969
00414 
00415   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) RunParakleteTest = false ;   //  Bug #1403
00416   Teuchos::ParameterList ParamList;
00417   if ( ReindexRowMap != 0 )  ParamList.set( "Reindex", true );
00418   if ( ( RangeMapType != 0 || DomainMapType != 0 || distribute ) ) 
00419     ParamList.set( "DontTrustMe", true );
00420 #ifdef HAVE_AMESOS_EPETRAEXT
00421   if ( ! transpose && EpetraMatrixType != 0 ) RunParakleteTest = false ; // Paraklete can't handle non-transposed Row Matrices   // this prevents others tests from executing - see bug #2279 
00422 #else
00423   if ( ! transpose ) RunParakleteTest = false ; // Amesos_Parakleter requires EpetraExt in order to perform non-transpose solves
00424 #endif
00425 #ifndef HAVE_AMESOS_EPETRAEXT
00426   if ( ( ReindexRowMap || ReindexColMap ) ) 
00427     RunParakleteTest = false ;  
00428 #endif
00429   if ( FileIsDiagonal )
00430     RunParakleteTest = false ;     //  bogus bug doit fixthis fixit
00431   //  if ( ImpcolB ) RunParakleteTest = false ;   // See bug #1928 
00432 
00433   if ( RunParakleteTest ) {
00434     if ( verbose) std::cout << " Testing Paraklete " << std::endl ; 
00435     Errors = TestOtherClasses("Amesos_Paraklete",
00436                EpetraMatrixType,
00437              Amat, 
00438              transpose, 
00439              verbose, 
00440              Levels, 
00441              Rcond, 
00442              RowMapEqualsColMap,
00443              false,
00444                    ExpectedError,
00445              maxrelerror, 
00446              maxrelresidual, 
00447              NumTheseTests ) ;
00448   }
00449       } else if ( AmesosClasses[i] == "Amesos_Dscpack" ) {
00450   //
00451   //  A quick sanity check - make sure symmetric is the same on all processes
00452   //
00453   const int sym_int = symmetric?0:1 ; 
00454   int sym_int_out = sym_int; 
00455   Amat->Comm().Broadcast( &sym_int_out, 1, 0 ) ; 
00456   assert( sym_int == sym_int_out ) ; 
00457 
00458   bool RunDscpackTest = true;
00459   if ( ExpectedError != 0 )  RunDscpackTest = false ;   //  Bug #1227
00460   if ( ! symmetric ) RunDscpackTest = false ; 
00461   if ( (  ReindexRowMap != 0 ||  ReindexColMap != 0  ) )  //  Bug #969
00462     RunDscpackTest = false ;   //  Bug #969
00463   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) RunDscpackTest = false ;   //  Bug #1403
00464   if ( Khead ) RunDscpackTest = false ;   // Bug #1234
00465 
00466 
00467   if ( RunDscpackTest ) { 
00468     if ( verbose) std::cout << " Testing DSCPACK " << std::endl ; 
00469     
00470     Errors = TestOtherClasses("Amesos_Dscpack",
00471             EpetraMatrixType,
00472             Amat, 
00473             transpose, 
00474             verbose, 
00475             Levels, 
00476             Rcond, 
00477             RowMapEqualsColMap,
00478             false,
00479                    ExpectedError,
00480             maxrelerror, 
00481             maxrelresidual, 
00482             NumTheseTests ) ;
00483   } 
00484       } else if ( AmesosClasses[i] == "Amesos_Superludist" ) {
00485   bool RunSuperludistTest = true;
00486   if ( ExpectedError != 0 )  RunSuperludistTest = false ;   //  Bug #1227
00487   if ( transpose ) { 
00488     RunSuperludistTest = false ;    // Bug #822
00489   }
00490   if ( ReindexRowMap || ReindexColMap ) RunSuperludistTest = false ;    //  Bug #969
00491   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) RunSuperludistTest = false ;   //  Bug #1403
00492   //  if ( MissingADiagonal ) RunSuperludistTest = false ; // Bug #1404 NOT
00493   if ( Khead ) RunSuperludistTest= false ;  // Bug #368
00494   if ( RunSuperludistTest ) { 
00495     if ( verbose) std::cout << " Testing Superludist " << std::endl ; 
00496   
00497     Errors = TestSuperludist(Amat, 
00498            EpetraMatrixType,
00499             transpose, 
00500             verbose, 
00501             Levels, 
00502             Rcond, 
00503             maxrelerror, 
00504             maxrelresidual, 
00505             filename,
00506             NumTheseTests ) ;
00507   }
00508       }
00509       if ( Amat->Comm().MyPID() == 0 ) {
00510   if ( Errors || ( verbose && NumTheseTests > 0 ) ) { 
00511     if ( Errors ) { 
00512       std::cout << " FAILURE in " ; 
00513     } else { 
00514       std::cout << " NO FAILURE in " ; 
00515     }
00516   
00517     std::cout << "TestAllClasses.cpp::"  << __LINE__
00518          << AmesosClasses[i] << " "  
00519          << " EMT=" <<  EpetraMatrixType 
00520          << " tr=" <<  transpose 
00521          << " sym=" <<  symmetric 
00522          << " L=" <<  Levels 
00523          << " D=" <<  Diagonal 
00524          << " RRM= " <<  ReindexRowMap 
00525          << " RCM= " <<  ReindexColMap 
00526          << " DMT= " <<  DomainMapType 
00527          << " RMT= " <<  RangeMapType 
00528          << " d=" <<  distribute 
00529          << " fn= " <<  filename 
00530          << std::endl ;  
00531   }
00532       }
00533       errors += Errors ;
00534       NumTests += NumTheseTests ;
00535     }
00536   }
00537   
00538   if ( verbose) std::cout << " TestAllClasses errors = " << errors << std::endl ; 
00539 
00540   return errors;
00541 }
00542 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines