//==========================================================================
int Ifpack_CrsRiluk::InitValues(const Epetra_CrsMatrix & A) {
UserMatrixIsCrs_ = true;
if (!Allocated()) AllocateCrs();
Teuchos::RefCountPtr<Epetra_CrsMatrix> OverlapA = Teuchos::rcp( (Epetra_CrsMatrix *) &A, false );
if (IsOverlapped_) {
OverlapA = Teuchos::rcp( new Epetra_CrsMatrix(Copy, *Graph_.OverlapGraph()) );
EPETRA_CHK_ERR(OverlapA->Import(A, *Graph_.OverlapImporter(), Insert));
EPETRA_CHK_ERR(OverlapA->FillComplete());
}
// Get Maximun Row length
int MaxNumEntries = OverlapA->MaxNumEntries();
// Set L range map and U domain map
U_DomainMap_ = Teuchos::rcp( &(A.DomainMap()), false );
L_RangeMap_ = Teuchos::rcp( &(A.RangeMap()), false );
// Do the rest using generic Epetra_RowMatrix interface
EPETRA_CHK_ERR(InitAllValues(*OverlapA, MaxNumEntries));
return(0);
}
//==========================================================================
int Ifpack_CrsRiluk::InitValues(const Epetra_VbrMatrix & A) {
UserMatrixIsVbr_ = true;
if (!Allocated()) AllocateVbr();
//cout << "Original Graph " << endl << A.Graph() << endl << flush;
//A.Comm().Barrier();
//if (A.Comm().MyPID()==0) cout << "*****************************************************" <<endl;
//cout << "Original Matrix " << endl << A << endl << flush;
//A.Comm().Barrier();
//if (A.Comm().MyPID()==0) cout << "*****************************************************" <<endl;
//cout << "Overlap Graph " << endl << *Graph_.OverlapGraph() << endl << flush;
//A.Comm().Barrier();
//if (A.Comm().MyPID()==0) cout << "*****************************************************" <<endl;
Teuchos::RefCountPtr<Epetra_VbrMatrix> OverlapA = Teuchos::rcp( (Epetra_VbrMatrix *) &A, false );
if (IsOverlapped_) {
OverlapA = Teuchos::rcp( new Epetra_VbrMatrix(Copy, *Graph_.OverlapGraph()) );
EPETRA_CHK_ERR(OverlapA->Import(A, *Graph_.OverlapImporter(), Insert));
EPETRA_CHK_ERR(OverlapA->FillComplete());
}
//cout << "Overlap Matrix " << endl << *OverlapA << endl << flush;
// Get Maximun Row length
int MaxNumEntries = OverlapA->MaxNumNonzeros();
// Do the rest using generic Epetra_RowMatrix interface
EPETRA_CHK_ERR(InitAllValues(*OverlapA, MaxNumEntries));
return(0);
}
//==============================================================================
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
// only one process
if (Comm.NumProc() != 1) {
#ifdef HAVE_MPI
MPI_Finalize();
#endif
if (Comm.MyPID() == 0)
cout << "Please run this test with one process only" << endl;
// return success not to break the tests
exit(EXIT_SUCCESS);
}
// ======================================================== //
// now create the famous "upper arrow" matrix, which //
// should be reordered as a "lower arrow". Sparsity pattern //
// will be printed on screen. //
// ======================================================== //
int NumPoints = 16;
#if !defined(EPETRA_NO_32BIT_GLOBAL_INDICES) || !defined(EPETRA_NO_64BIT_GLOBAL_INDICES)
Epetra_Map Map(-1,NumPoints,0,Comm);
#else
Epetra_Map Map;
#endif
std::vector<int> Indices(NumPoints);
std::vector<double> Values(NumPoints);
Teuchos::RefCountPtr<Epetra_CrsMatrix> A = Teuchos::rcp( new Epetra_CrsMatrix(Copy,Map,0) );
for (int i = 0 ; i < NumPoints ; ++i) {
int NumEntries;
if (i == 0) {
NumEntries = NumPoints;
for (int j = 0 ; j < NumPoints ; ++j) {
Indices[j] = j;
Values[j] = 1.0;
}
}
else {
NumEntries = 2;
Indices[0] = 0;
Indices[1] = i;
Values[0] = 1.0;
Values[1] = 1.0;
}
#if !defined(EPETRA_NO_32BIT_GLOBAL_INDICES) || !defined(EPETRA_NO_64BIT_GLOBAL_INDICES)
A->InsertGlobalValues(i, NumEntries, &Values[0], &Indices[0]);
#endif
}
A->FillComplete();
// print the sparsity to file, postscript format
////Ifpack_PrintSparsity(A,"OrigA.ps");
// create the reordering...
Teuchos::RefCountPtr<Ifpack_RCMReordering> Reorder = Teuchos::rcp( new Ifpack_RCMReordering() );
// and compute is on A
IFPACK_CHK_ERR(Reorder->Compute(*A));
// cout information
cout << *Reorder;
// create a reordered matrix
Ifpack_ReorderFilter ReordA(A, Reorder);
// print the sparsity to file, postscript format
////Ifpack_PrintSparsity(ReordA,"ReordA.ps");
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return(EXIT_SUCCESS);
}
//==============================================================================
// NOTE:
// - matrix is supposed to be localized, and passes through the
// singleton filter. This means that I do not have to look
// for Dirichlet nodes (singletons). Also, all rows and columns are
// local.
int Ifpack_METISPartitioner::ComputePartitions()
{
int ierr;
#ifdef HAVE_IFPACK_METIS
int nbytes = 0;
int edgecut;
#endif
Teuchos::RefCountPtr<Epetra_CrsGraph> SymGraph ;
Teuchos::RefCountPtr<Epetra_Map> SymMap;
Teuchos::RefCountPtr<Ifpack_Graph_Epetra_CrsGraph> SymIFPACKGraph;
Teuchos::RefCountPtr<Ifpack_Graph> IFPACKGraph = Teuchos::rcp( (Ifpack_Graph*)Graph_, false );
int Length = 2 * MaxNumEntries();
int NumIndices;
std::vector<int> Indices;
Indices.resize(Length);
/* construct the CSR graph information of the LOCAL matrix
using the get_row function */
std::vector<idxtype> wgtflag;
wgtflag.resize(4);
std::vector<int> options;
options.resize(4);
int numflag;
if (UseSymmetricGraph_) {
#if !defined(EPETRA_NO_32BIT_GLOBAL_INDICES) || !defined(EPETRA_NO_64BIT_GLOBAL_INDICES)
// need to build a symmetric graph.
// I do this in two stages:
// 1.- construct an Epetra_CrsMatrix, symmetric
// 2.- convert the Epetra_CrsMatrix into METIS format
SymMap = Teuchos::rcp( new Epetra_Map(NumMyRows(),0,Graph_->Comm()) );
SymGraph = Teuchos::rcp( new Epetra_CrsGraph(Copy,*SymMap,0) );
#endif
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
if(SymGraph->RowMap().GlobalIndicesInt()) {
for (int i = 0; i < NumMyRows() ; ++i) {
ierr = Graph_->ExtractMyRowCopy(i, Length, NumIndices, &Indices[0]);
IFPACK_CHK_ERR(ierr);
for (int j = 0 ; j < NumIndices ; ++j) {
int jj = Indices[j];
if (jj != i) {
SymGraph->InsertGlobalIndices(i,1,&jj);
SymGraph->InsertGlobalIndices(jj,1,&i);
}
}
}
}
else
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
if(SymGraph->RowMap().GlobalIndicesLongLong()) {
for (int i = 0; i < NumMyRows() ; ++i) {
long long i_LL = i;
ierr = Graph_->ExtractMyRowCopy(i, Length, NumIndices, &Indices[0]);
IFPACK_CHK_ERR(ierr);
for (int j = 0 ; j < NumIndices ; ++j) {
long long jj = Indices[j];
if (jj != i_LL) {
SymGraph->InsertGlobalIndices(i_LL,1,&jj);
SymGraph->InsertGlobalIndices(jj,1,&i_LL);
}
}
}
}
else
#endif
throw "Ifpack_METISPartitioner::ComputePartitions: GlobalIndices type unknown";
IFPACK_CHK_ERR(SymGraph->FillComplete());
SymIFPACKGraph = Teuchos::rcp( new Ifpack_Graph_Epetra_CrsGraph(SymGraph) );
IFPACKGraph = SymIFPACKGraph;
}
// now work on IFPACKGraph, that can be the symmetric or
// the non-symmetric one
/* set parameters */
wgtflag[0] = 0; /* no weights */
numflag = 0; /* C style */
options[0] = 0; /* default options */
std::vector<idxtype> xadj;
xadj.resize(NumMyRows() + 1);
std::vector<idxtype> adjncy;
adjncy.resize(NumMyNonzeros());
int count = 0;
int count2 = 0;
xadj[0] = 0;
for (int i = 0; i < NumMyRows() ; ++i) {
xadj[count2+1] = xadj[count2]; /* nonzeros in row i-1 */
ierr = IFPACKGraph->ExtractMyRowCopy(i, Length, NumIndices, &Indices[0]);
IFPACK_CHK_ERR(ierr);
for (int j = 0 ; j < NumIndices ; ++j) {
int jj = Indices[j];
if (jj != i) {
adjncy[count++] = jj;
xadj[count2+1]++;
}
}
count2++;
}
std::vector<idxtype> NodesInSubgraph;
NodesInSubgraph.resize(NumLocalParts_);
// some cases can be handled separately
int ok;
if (NumLocalParts() == 1) {
for (int i = 0 ; i < NumMyRows() ; ++i)
Partition_[i] = 0;
} else if (NumLocalParts() == NumMyRows()) {
for (int i = 0 ; i < NumMyRows() ; ++i)
Partition_[i] = i;
} else {
ok = 0;
// sometimes METIS creates less partitions than specified.
// ok will check this problem, and recall metis, asking
// for NumLocalParts_/2 partitions
while (ok == 0) {
for (int i = 0 ; i < NumMyRows() ; ++i)
Partition_[i] = -1;
#ifdef HAVE_IFPACK_METIS
int j = NumMyRows();
if (NumLocalParts_ < 8) {
int i = 1; /* optype in the METIS manual */
numflag = 0;
METIS_EstimateMemory(&j, &xadj[0], &adjncy[0],
&numflag, &i, &nbytes );
METIS_PartGraphRecursive(&j, &xadj[0], &adjncy[0],
NULL, NULL,
&wgtflag[0], &numflag, &NumLocalParts_,
&options[0], &edgecut, &Partition_[0]);
} else {
numflag = 0;
METIS_PartGraphKway (&j, &xadj[0], &adjncy[0],
NULL,
NULL, &wgtflag[0], &numflag,
&NumLocalParts_, &options[0],
&edgecut, &Partition_[0]);
}
#else
numflag = numflag * 2; // avoid warning for unused variable
if (Graph_->Comm().MyPID() == 0) {
cerr << "METIS was not linked; now I put all" << endl;
cerr << "the local nodes in the same partition." << endl;
}
for (int i = 0 ; i < NumMyRows() ; ++i)
Partition_[i] = 0;
NumLocalParts_ = 1;
#endif
ok = 1;
for (int i = 0 ; i < NumLocalParts() ; ++i)
NodesInSubgraph[i] = 0;
for (int i = 0 ; i < NumMyRows() ; ++i) {
int j = Partition_[i];
if ((j < 0) || (j>= NumLocalParts())) {
ok = 0;
break;
}
else NodesInSubgraph[j]++;
}
for (int i = 0 ; i < NumLocalParts() ; ++i) {
if( NodesInSubgraph[i] == 0 ) {
ok = 0;
break;
}
}
if (ok == 0) {
cerr << "Specified number of subgraphs ("
<< NumLocalParts_ << ") generates empty subgraphs." << endl;
cerr << "Now I recall METIS with NumLocalParts_ = "
<< NumLocalParts_ / 2 << "..." << endl;
NumLocalParts_ = NumLocalParts_/2;
}
if (NumLocalParts() == 0) {
IFPACK_CHK_ERR(-10); // something went wrong
}
if (NumLocalParts() == 1) {
for (int i = 0 ; i < NumMyRows() ; ++i)
Partition_[i] = 0;
ok = 1;
}
} /* while( ok == 0 ) */
} /* if( NumLocalParts_ == 1 ) */
return(0);
}