int main(int argc, char** argv) {
bool verbose = false;
int numProcs = 1;
int localProc = 0;
#ifdef HAVE_MPI
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &localProc);
MPI_Comm_size(MPI_COMM_WORLD, &numProcs);
#endif
try {
verbose = ispatest::set_verbose(localProc, argc, argv);
}
catch(std::exception& exc) {
std::cout << "err, setting verbosity: " << exc.what() << std::endl;
std::cout << "End Result: TEST FAILED" << std::endl;
#ifdef HAVE_MPI
MPI_Finalize();
#endif /* HAVE_MPI */
return(-1);
}
// Only print on proc 0
if (localProc != 0) {
verbose = false;
}
bool test_passed = true;
#ifdef HAVE_EPETRA
//TEST HERE
Epetra_CrsMatrix* mat=create_epetra_test_matrix_1(numProcs,localProc,true);
test_passed=probing_test(*mat,true);
test_passed=test_passed && probing_test(*mat,false);
// Cleanup
delete mat;
#else
std::cout << "probing main: currently can only test "
<< "rebalancing with Epetra enabled." << std::endl;
test_passed = false;
#endif
if (test_passed && verbose) {
std::cout << "PROBING main: tests passed."<<std::endl;
}
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return(0);
}
//-------------------------------------------------------------------
bool test_rebalance_epetra_linproblem2(int numProcs, int localProc, bool verbose)
{
bool test_passed = false;
#ifndef HAVE_MPI
return(test_passed);
#endif
Epetra_CrsMatrix* input_matrix =
create_epetra_test_matrix_1(numProcs, localProc, verbose);
Epetra_Vector* x = new Epetra_Vector(input_matrix->RowMap());
Epetra_Vector* b = new Epetra_Vector(input_matrix->RowMap());
Epetra_LinearProblem problem(input_matrix, x, b);
Teuchos::ParameterList paramlist;
//Wrap a RefCountPtr around the matrix graph, and specify 'false', meaning
//that the RefCountPtr will not take ownership of the graph (will not
//delete it).
Teuchos::RefCountPtr<const Epetra_CrsGraph> graph =
Teuchos::rcp( &(input_matrix->Graph()), false);
Teuchos::RefCountPtr<Isorropia::Epetra::Partitioner> partitioner =
Teuchos::rcp(new Isorropia::Epetra::Partitioner(graph, paramlist));
Isorropia::Epetra::Redistributor rd(partitioner);
Teuchos::RefCountPtr<Epetra_CrsMatrix> bal_matrix =
rd.redistribute(*(problem.GetMatrix()));
Teuchos::RefCountPtr<Epetra_MultiVector> bal_x =
rd.redistribute(*(problem.GetLHS()));
Teuchos::RefCountPtr<Epetra_MultiVector> bal_b =
rd.redistribute(*(problem.GetRHS()));
Teuchos::RefCountPtr<Epetra_LinearProblem> balanced_problem =
Teuchos::rcp(new Epetra_LinearProblem(bal_matrix.get(),
bal_x.get(), bal_b.get()));
//Now check the result matrix and make sure that the number of nonzeros
//is indeed equal on each processor. (We constructed the input matrix
//so that a correct rebalancing would result in the same number of
//nonzeros being on each processor.)
const Epetra_Map& bal_rowmap = balanced_problem->GetMatrix()->RowMatrixRowMap();
int bal_local_num_rows = bal_rowmap.NumMyElements();
//count the local nonzeros.
if (verbose) {
std::cout << "test_rebalance_epetra_linproblem: " << std::endl;
std::cout << " counting local nnz for balanced matrix..." << std::endl;
}
int num_nonzeros = 0;
for(int i=0; i<bal_local_num_rows; ++i) {
int numrowentries = 0;
balanced_problem->GetMatrix()->NumMyRowEntries(i,numrowentries);
num_nonzeros += numrowentries;
}
const Epetra_Comm& comm = input_matrix->Comm();
int global_num_nonzeros;
comm.SumAll(&num_nonzeros, &global_num_nonzeros, 1);
int avg_nnz_per_proc = global_num_nonzeros/numProcs;
if (verbose) {
std::cout << " making sure local nnz ("<<num_nonzeros
<<") is the same on every proc...\n" << std::endl;
}
if (num_nonzeros == avg_nnz_per_proc) test_passed = true;
int local_int_result = test_passed ? 1 : 0;
int global_int_result;
comm.MinAll(&local_int_result, &global_int_result, 1);
test_passed = global_int_result==1 ? true : false;
if (!test_passed && verbose) {
std::cout << "test FAILED!" << std::endl;
}
delete input_matrix;
delete x;
delete b;
return(test_passed);
}
//-------------------------------------------------------------------
bool test_rebalance_epetra_linproblem(int numProcs, int localProc, bool verbose)
{
bool test_passed = false;
#ifndef HAVE_MPI
return(test_passed);
#endif
Epetra_CrsMatrix* input_matrix =
create_epetra_test_matrix_1(numProcs, localProc, verbose);
Epetra_Vector* x = new Epetra_Vector(input_matrix->RowMap());
Epetra_Vector* b = new Epetra_Vector(input_matrix->RowMap());
Epetra_LinearProblem problem(input_matrix, x, b);
//Call the Isorropia rebalance method allowing default behavior. (I.e.,
//we won't specify any parameters, weights, etc.) Default behavior should
//be to balance the matrix so that the number of nonzeros on each processor
//is roughly equal. i.e., by default, weights for each row are assumed to
//be the number of nonzeros in that row.
Epetra_LinearProblem *balanced_problem;
try {
if (verbose) {
std::cout << " calling Isorropia::createBalancedCopy(Epetra_LinearProblem)..."
<< std::endl;
}
balanced_problem = Isorropia::Epetra::createBalancedCopy(problem);
}
catch(std::exception& exc) {
std::cout << "caught exception: " << exc.what() << std::endl;
return(false);
}
//Now check the result matrix and make sure that the number of nonzeros
//is indeed equal on each processor. (We constructed the input matrix
//so that a correct rebalancing would result in the same number of
//nonzeros being on each processor.)
const Epetra_Map& bal_rowmap = balanced_problem->GetMatrix()->RowMatrixRowMap();
int bal_local_num_rows = bal_rowmap.NumMyElements();
//count the local nonzeros.
if (verbose) {
std::cout << " counting local nnz for balanced matrix..." << std::endl;
}
int num_nonzeros = 0;
for(int i=0; i<bal_local_num_rows; ++i) {
int numrowentries = 0;
balanced_problem->GetMatrix()->NumMyRowEntries(i,numrowentries);
num_nonzeros += numrowentries;
}
delete balanced_problem;
const Epetra_Comm& comm = input_matrix->Comm();
int global_num_nonzeros;
comm.SumAll(&num_nonzeros, &global_num_nonzeros, 1);
int avg_nnz_per_proc = global_num_nonzeros/numProcs;
if (verbose) {
std::cout << " making sure local nnz ("<<num_nonzeros
<<") is the same on every proc...\n" << std::endl;
}
if (num_nonzeros == avg_nnz_per_proc) test_passed = true;
int local_int_result = test_passed ? 1 : 0;
int global_int_result;
comm.MinAll(&local_int_result, &global_int_result, 1);
test_passed = global_int_result==1 ? true : false;
if (!test_passed && verbose) {
std::cout << "test FAILED!" << std::endl;
}
delete input_matrix;
delete x;
delete b;
return(test_passed);
}
