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 
00188   if ( RunLapackTest && verbose) std::cout << " Testing LAPACK " << std::endl ; 
00189   
00190   if ( RunLapackTest ) Errors = TestOtherClasses("Amesos_Lapack",
00191                    EpetraMatrixType,
00192                    Amat, 
00193                    transpose, 
00194                    verbose, 
00195                    Levels, 
00196                    Rcond, 
00197                    RowMapEqualsColMap,
00198                    false,
00199                    ExpectedError,
00200                    maxrelerror, 
00201                    maxrelresidual, 
00202                    NumTheseTests ) ;
00203       } else if ( AmesosClasses[i] == "Amesos_Taucs" ) {
00204   bool RunTaucsTest = true;
00205   if ( ExpectedError != 0 )  RunTaucsTest = false ;   //  Bug #1227
00206   if ( ( ReindexRowMap != 0  || ReindexColMap != 0 ) ) 
00207     RunTaucsTest = false ;   //  Bug #969
00208   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) 
00209     RunTaucsTest = false ;   //  Bug #1403
00210   //  if ( MissingADiagonal ) RunTaucsTest = false ; // Bug #1449
00211   //  if ( transpose ) RunTaucsTest = false ; // Bug #1579
00212   if ( a662_bus_out)  RunTaucsTest = false ; // Bug #1449
00213   if ( ! symmetric ) RunTaucsTest = false ; 
00214   if ( Khead ) RunTaucsTest = false ;   // Bug #1449
00215 
00216   if ( RunTaucsTest && verbose) std::cout << " Testing TAUCS " << std::endl ; 
00217   
00218   
00219   if ( RunTaucsTest ) Errors = TestOtherClasses("Amesos_Taucs",
00220                   EpetraMatrixType,
00221                   Amat, 
00222                   transpose, 
00223                   verbose, 
00224                   Levels, 
00225                   Rcond, 
00226                   RowMapEqualsColMap,
00227                   false, 
00228                    ExpectedError,
00229                   maxrelerror, 
00230                   maxrelresidual, 
00231                   NumTheseTests ) ;
00232 
00233       } else if ( AmesosClasses[i] == "Amesos_Pardiso" ) {
00234   bool RunPardisoTest = true;
00235   if ( ExpectedError != 0 )  RunPardisoTest = false ;   //  Bug #1227
00236   if ( ReindexRowMap != 0  || ReindexColMap != 0 ) // Bug #969 
00237     RunPardisoTest = false ;   //  Bug #969
00238   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) 
00239     RunPardisoTest = false ;   //  Bug #1403
00240   if ( bcsstk04 ) RunPardisoTest = false ;   // Bug #1916
00241   if ( a662_bus_out )  RunPardisoTest = false ; // Bug #1916
00242   if ( transpose ) RunPardisoTest = false ;   // Bug #1992
00243   if ( MissingADiagonal ) RunPardisoTest = false ; // Bug #1916 
00244   if ( Khead ) RunPardisoTest = false ; // Bug #1916 
00245   if ( EpetraMatrixType == 1 )  RunPardisoTest = false ; // Bug #1994 
00246   if ( distribute )  RunPardisoTest = false ; // Bug #1995
00247   if ( RunPardisoTest && verbose) std::cout << " Testing PARDISO " << std::endl ; 
00248   if ( Amat->Comm().NumProc() > 1 ) RunPardisoTest = false ; 
00249 
00250   if ( RunPardisoTest ) Errors = TestOtherClasses("Amesos_Pardiso",
00251                EpetraMatrixType,
00252                Amat, 
00253                transpose, 
00254                verbose, 
00255                Levels, 
00256                Rcond, 
00257                RowMapEqualsColMap,
00258                false,
00259               ExpectedError,
00260                maxrelerror, 
00261                maxrelresidual, 
00262                NumTheseTests ) ;
00263 
00264       } else if ( AmesosClasses[i] == "Amesos_Mumps" ) {
00265   bool RunMumpsTest = true;
00266   if ( ExpectedError != 0 )  RunMumpsTest = false ;   //  Bug #1227
00267   if ( ( ReindexRowMap || ReindexColMap ) ) 
00268     RunMumpsTest = false ;   //  Bug #969
00269   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) RunMumpsTest = false ;   //  Bug #1403
00270   if ( MissingADiagonal ) RunMumpsTest = false ; // Bug #1435
00271   if ( distribute )  RunMumpsTest = false ; // Bug #
00272   if (  RunMumpsTest && verbose) std::cout << " Testing MUMPS " << std::endl ; 
00273 
00274   if ( RunMumpsTest ) Errors = TestOtherClasses("Amesos_Mumps",
00275                EpetraMatrixType,
00276                    Amat, 
00277                    transpose, 
00278                    verbose, 
00279                    Levels, 
00280                    Rcond, 
00281                    RowMapEqualsColMap,
00282                   false,
00283                   ExpectedError,
00284                    maxrelerror, 
00285                    maxrelresidual, 
00286                    NumTheseTests ) ;
00287 
00288       } else if ( AmesosClasses[i] == "Amesos_Klu" ) {
00289   bool RunKluTest = true;
00290   if ( (   ReindexColMap != 0  ) )  //  Bug #969
00291     RunKluTest = false ;   //  Bug #969
00292 
00293   //  if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) RunKluTest = false ;   //  Bug #1403
00294 
00295   Teuchos::ParameterList ParamList;
00296   if ( ReindexRowMap != 0 )  ParamList.set( "Reindex", true );
00297   if ( ( RangeMapType != 0 || DomainMapType != 0 || distribute ) ) 
00298     ParamList.set( "DontTrustMe", true );
00299 #ifndef HAVE_AMESOS_EPETRAEXT
00300   if ( ( ReindexRowMap || ReindexColMap ) ) 
00301     RunKluTest = false ;  
00302 #endif
00303   if ( ImpcolB ) RunKluTest = false ;   // See bug #1928 
00304   if ( ( RangeMapType ==2 && DomainMapType == 1 && distribute == 1 && EpetraMatrixType == 2 && transpose == 0 && Superlu_rua ) ) RunKluTest = false ;   //  Bug #2000
00305 
00306   if ( RunKluTest && verbose) std::cout << " Testing KLU " << std::endl ; 
00307   if ( RunKluTest && verbose) std::cout << " Testing KLU ExpectedError = " 
00308            << ExpectedError << std::endl ; 
00309 
00310   if ( RunKluTest ) Errors = TestKlu( Amat, 
00311               EpetraMatrixType,
00312               transpose, 
00313               verbose, 
00314               Levels,
00315               Rcond, 
00316               ParamList, 
00317               RowMapEqualsColMap, 
00318               false,
00319               ExpectedError,
00320               maxrelerror, 
00321               maxrelresidual, 
00322               NumTheseTests ) ;
00323   
00324   if ( Amat->Comm().MyPID() == 0 && Errors ) 
00325     std::cout << " FAILURE in "  
00326          << __FILE__ << "::"  << __LINE__
00327          << " Amesos_Klu" 
00328          << " EpetraMatrixType = " <<  EpetraMatrixType 
00329          << " transpose = " <<  transpose 
00330          << " symmetric = " <<  symmetric 
00331          << " Levels = " <<  Levels 
00332          << " Diagonal = " <<  Diagonal 
00333          << " ReindexRowMap = " <<  ReindexRowMap 
00334          << " ReindexColMap = " <<  ReindexColMap 
00335          << " DomainMapType = " <<  DomainMapType 
00336          << " RangeMapType = " <<  RangeMapType 
00337          << " distribute = " <<  distribute 
00338          << " filename = " <<  filename 
00339          << " NumTheseTests = " <<  NumTheseTests 
00340          << " Errors = " <<  Errors << std::endl ;  
00341 
00342       } else if ( AmesosClasses[i] == "Amesos_Superlu" ) {
00343   bool RunSuperluTest = true;
00344   if ( ExpectedError != 0 )  RunSuperluTest = false ;   //  Bug #1227
00345   if ( (  ReindexRowMap != 0 ||  ReindexColMap != 0  ) && Amat->Comm().NumProc() > 1  )  //  Bug #969
00346     RunSuperluTest = false ;   //  Bug #969
00347   if ( MissingADiagonal ) RunSuperluTest = false ; // Bug #1404
00348   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) RunSuperluTest = false ;   //  Bug #1403
00349   if ( bcsstk04 && transpose ) RunSuperluTest = false ;  // Bug #1927 
00350   if ( a662_bus_out && transpose ) RunSuperluTest = false ;  // Bug #1927 
00351   if ( Khead ) RunSuperluTest= false ;  // Bug #1927 
00352 
00353   if ( RunSuperluTest ) {
00354     if ( verbose) std::cout << " Testing SUPERLU " << std::endl ; 
00355     Errors = TestOtherClasses("Amesos_Superlu",
00356                EpetraMatrixType,
00357              Amat, 
00358              transpose, 
00359              verbose, 
00360              Levels, 
00361              Rcond, 
00362              RowMapEqualsColMap,
00363              false,
00364                    ExpectedError,
00365              maxrelerror, 
00366              maxrelresidual, 
00367              NumTheseTests ) ;
00368   }
00369   if ( Amat->Comm().MyPID() == 0 && Errors ) 
00370     std::cout << " FAILURE in " 
00371          << __FILE__ << "::"  << __LINE__
00372          << " Amesos_Superlu" 
00373          << " EpetraMatrixType = " <<  EpetraMatrixType 
00374          << " transpose = " <<  transpose 
00375          << " symmetric = " <<  symmetric 
00376          << " Levels = " <<  Levels 
00377          << " Diagonal = " <<  Diagonal 
00378          << " ReindexRowMap = " <<  ReindexRowMap 
00379          << " ReindexColMap = " <<  ReindexColMap 
00380          << " DomainMapType = " <<  DomainMapType 
00381          << " RangeMapType = " <<  RangeMapType 
00382          << " distribute = " <<  distribute 
00383          << " filename = " <<  filename 
00384          << " NumTheseTests = " <<  NumTheseTests 
00385          << " Errors = " <<  Errors << std::endl ;  
00386 
00387       } else if ( AmesosClasses[i] == "Amesos_Paraklete" ) {
00388 
00389   //  We only test reindexing on klu and paraklete
00390   if ( verbose  &&  ( ReIndex ) ) { 
00391     
00392     std::cout << __FILE__ << "::"  << __LINE__
00393          << " Perhaps about to test " 
00394          << AmesosClasses[i] << " "  
00395          << " EpetraMatrixType = " <<  EpetraMatrixType 
00396          << " transpose = " <<  transpose 
00397          << " symmetric = " <<  symmetric 
00398          << " Levels = " <<  Levels 
00399          << " Diagonal = " <<  Diagonal 
00400          << " ReindexRowMap = " <<  ReindexRowMap 
00401          << " ReindexColMap = " <<  ReindexColMap 
00402          << " DomainMapType = " <<  DomainMapType 
00403          << " RangeMapType = " <<  RangeMapType 
00404          << " distribute = " <<  distribute 
00405          << " filename = " <<  filename 
00406          << std::endl ;  
00407   }
00408   bool RunParakleteTest = true;
00409   if ( ExpectedError != 0 )  RunParakleteTest = false ;   //  Bug #1227
00410   if ( (   ReindexColMap != 0  ) )  //  Bug #969
00411     RunParakleteTest = false ;   //  Bug #969
00412 
00413   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) RunParakleteTest = false ;   //  Bug #1403
00414   Teuchos::ParameterList ParamList;
00415   if ( ReindexRowMap != 0 )  ParamList.set( "Reindex", true );
00416   if ( ( RangeMapType != 0 || DomainMapType != 0 || distribute ) ) 
00417     ParamList.set( "DontTrustMe", true );
00418 #ifdef HAVE_AMESOS_EPETRAEXT
00419   if ( ! transpose && EpetraMatrixType != 0 ) RunParakleteTest = false ; // Paraklete can't handle non-transposed Row Matrices   // this prevents others tests from executing - see bug #2279 
00420 #else
00421   if ( ! transpose ) RunParakleteTest = false ; // Amesos_Parakleter requires EpetraExt in order to perform non-transpose solves
00422 #endif
00423 #ifndef HAVE_AMESOS_EPETRAEXT
00424   if ( ( ReindexRowMap || ReindexColMap ) ) 
00425     RunParakleteTest = false ;  
00426 #endif
00427   if ( FileIsDiagonal )
00428     RunParakleteTest = false ;     //  bogus bug doit fixthis fixit
00429   //  if ( ImpcolB ) RunParakleteTest = false ;   // See bug #1928 
00430 
00431   if ( RunParakleteTest ) {
00432     if ( verbose) std::cout << " Testing Paraklete " << std::endl ; 
00433     Errors = TestOtherClasses("Amesos_Paraklete",
00434                EpetraMatrixType,
00435              Amat, 
00436              transpose, 
00437              verbose, 
00438              Levels, 
00439              Rcond, 
00440              RowMapEqualsColMap,
00441              false,
00442                    ExpectedError,
00443              maxrelerror, 
00444              maxrelresidual, 
00445              NumTheseTests ) ;
00446   }
00447       } else if ( AmesosClasses[i] == "Amesos_Dscpack" ) {
00448   //
00449   //  A quick sanity check - make sure symmetric is the same on all processes
00450   //
00451   const int sym_int = symmetric?0:1 ; 
00452   int sym_int_out = sym_int; 
00453   Amat->Comm().Broadcast( &sym_int_out, 1, 0 ) ; 
00454   assert( sym_int == sym_int_out ) ; 
00455 
00456   bool RunDscpackTest = true;
00457   if ( ExpectedError != 0 )  RunDscpackTest = false ;   //  Bug #1227
00458   if ( ! symmetric ) RunDscpackTest = false ; 
00459   if ( (  ReindexRowMap != 0 ||  ReindexColMap != 0  ) )  //  Bug #969
00460     RunDscpackTest = false ;   //  Bug #969
00461   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) RunDscpackTest = false ;   //  Bug #1403
00462   if ( Khead ) RunDscpackTest = false ;   // Bug #1234
00463 
00464 
00465   if ( RunDscpackTest ) { 
00466     if ( verbose) std::cout << " Testing DSCPACK " << std::endl ; 
00467     
00468     Errors = TestOtherClasses("Amesos_Dscpack",
00469             EpetraMatrixType,
00470             Amat, 
00471             transpose, 
00472             verbose, 
00473             Levels, 
00474             Rcond, 
00475             RowMapEqualsColMap,
00476             false,
00477                    ExpectedError,
00478             maxrelerror, 
00479             maxrelresidual, 
00480             NumTheseTests ) ;
00481   } 
00482       } else if ( AmesosClasses[i] == "Amesos_Superludist" ) {
00483   bool RunSuperludistTest = true;
00484   if ( ExpectedError != 0 )  RunSuperludistTest = false ;   //  Bug #1227
00485   if ( transpose ) { 
00486     RunSuperludistTest = false ;    // Bug #822
00487   }
00488   if ( ReindexRowMap || ReindexColMap ) RunSuperludistTest = false ;    //  Bug #969
00489   if ( ( RangeMapType != 0 || DomainMapType != 0 ) ) RunSuperludistTest = false ;   //  Bug #1403
00490   //  if ( MissingADiagonal ) RunSuperludistTest = false ; // Bug #1404 NOT
00491   if ( Khead ) RunSuperludistTest= false ;  // Bug #368
00492   if ( RunSuperludistTest ) { 
00493     if ( verbose) std::cout << " Testing Superludist " << std::endl ; 
00494   
00495     Errors = TestSuperludist(Amat, 
00496            EpetraMatrixType,
00497             transpose, 
00498             verbose, 
00499             Levels, 
00500             Rcond, 
00501             maxrelerror, 
00502             maxrelresidual, 
00503             filename,
00504             NumTheseTests ) ;
00505   }
00506       }
00507       if ( Amat->Comm().MyPID() == 0 ) {
00508   if ( Errors || ( verbose && NumTheseTests > 0 ) ) { 
00509     if ( Errors ) { 
00510       std::cout << " FAILURE in " ; 
00511     } else { 
00512       std::cout << " NO FAILURE in " ; 
00513     }
00514   
00515     std::cout << "TestAllClasses.cpp::"  << __LINE__
00516          << AmesosClasses[i] << " "  
00517          << " EMT=" <<  EpetraMatrixType 
00518          << " tr=" <<  transpose 
00519          << " sym=" <<  symmetric 
00520          << " L=" <<  Levels 
00521          << " D=" <<  Diagonal 
00522          << " RRM= " <<  ReindexRowMap 
00523          << " RCM= " <<  ReindexColMap 
00524          << " DMT= " <<  DomainMapType 
00525          << " RMT= " <<  RangeMapType 
00526          << " d=" <<  distribute 
00527          << " fn= " <<  filename 
00528          << std::endl ;  
00529   }
00530       }
00531       errors += Errors ;
00532       NumTests += NumTheseTests ;
00533     }
00534   }
00535   
00536   if ( verbose) std::cout << " TestAllClasses errors = " << errors << std::endl ; 
00537 
00538   return errors;
00539 }
00540 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines