BASKER_INLINE
int Basker<Int, Entry, Exe_Space>::scotch_partition
(BASKER_MATRIX &M)
{
nd_flag = BASKER_TRUE;
if(Options.symmetric == BASKER_TRUE)
{
//printf("Scotch Symmetric\n");
part_scotch(M, part_tree);
}
else
{
//printf("Scotch Nonsymmetrix\n");
BASKER_MATRIX MMT;
AplusAT(M,MMT);
//printMTX("AAT.mtx", MMT);
part_scotch(MMT, part_tree);
FREE(MMT);
}
nd_flag == BASKER_TRUE;
//permute
//permute_col(M, part_tree.permtab);
///permute_row(M, part_tree.permtab);
permute_row(M, part_tree.permtab);
permute_col(M, part_tree.permtab);
//May need to sort row_idx
return 0;
}//end scotch_partition()
int Ifpack_Analyze(const Epetra_RowMatrix& A, const bool Cheap,
const int NumPDEEqns)
{
int NumMyRows = A.NumMyRows();
long long NumGlobalRows = A.NumGlobalRows64();
long long NumGlobalCols = A.NumGlobalCols64();
long long MyBandwidth = 0, GlobalBandwidth;
long long MyLowerNonzeros = 0, MyUpperNonzeros = 0;
long long GlobalLowerNonzeros, GlobalUpperNonzeros;
long long MyDiagonallyDominant = 0, GlobalDiagonallyDominant;
long long MyWeaklyDiagonallyDominant = 0, GlobalWeaklyDiagonallyDominant;
double MyMin, MyAvg, MyMax;
double GlobalMin, GlobalAvg, GlobalMax;
long long GlobalStorage;
bool verbose = (A.Comm().MyPID() == 0);
GlobalStorage = sizeof(int*) * NumGlobalRows +
sizeof(int) * A.NumGlobalNonzeros64() +
sizeof(double) * A.NumGlobalNonzeros64();
if (verbose) {
print();
Ifpack_PrintLine();
print<const char*>("Label", A.Label());
print<long long>("Global rows", NumGlobalRows);
print<long long>("Global columns", NumGlobalCols);
print<long long>("Stored nonzeros", A.NumGlobalNonzeros64());
print<long long>("Nonzeros / row", A.NumGlobalNonzeros64() / NumGlobalRows);
print<double>("Estimated storage (Mbytes)", 1.0e-6 * GlobalStorage);
}
long long NumMyActualNonzeros = 0, NumGlobalActualNonzeros;
long long NumMyEmptyRows = 0, NumGlobalEmptyRows;
long long NumMyDirichletRows = 0, NumGlobalDirichletRows;
std::vector<int> colInd(A.MaxNumEntries());
std::vector<double> colVal(A.MaxNumEntries());
Epetra_Vector Diag(A.RowMatrixRowMap());
Epetra_Vector RowSum(A.RowMatrixRowMap());
Diag.PutScalar(0.0);
RowSum.PutScalar(0.0);
for (int i = 0 ; i < NumMyRows ; ++i) {
long long GRID = A.RowMatrixRowMap().GID64(i);
int Nnz;
IFPACK_CHK_ERR(A.ExtractMyRowCopy(i,A.MaxNumEntries(),Nnz,
&colVal[0],&colInd[0]));
if (Nnz == 0)
NumMyEmptyRows++;
if (Nnz == 1)
NumMyDirichletRows++;
for (int j = 0 ; j < Nnz ; ++j) {
double v = colVal[j];
if (v < 0) v = -v;
if (colVal[j] != 0.0)
NumMyActualNonzeros++;
long long GCID = A.RowMatrixColMap().GID64(colInd[j]);
if (GCID != GRID)
RowSum[i] += v;
else
Diag[i] = v;
if (GCID < GRID)
MyLowerNonzeros++;
else if (GCID > GRID)
MyUpperNonzeros++;
long long b = GCID - GRID;
if (b < 0) b = -b;
if (b > MyBandwidth)
MyBandwidth = b;
}
if (Diag[i] > RowSum[i])
MyDiagonallyDominant++;
if (Diag[i] >= RowSum[i])
MyWeaklyDiagonallyDominant++;
RowSum[i] += Diag[i];
}
// ======================== //
// summing up global values //
// ======================== //
A.Comm().SumAll(&MyDiagonallyDominant,&GlobalDiagonallyDominant,1);
A.Comm().SumAll(&MyWeaklyDiagonallyDominant,&GlobalWeaklyDiagonallyDominant,1);
A.Comm().SumAll(&NumMyActualNonzeros, &NumGlobalActualNonzeros, 1);
A.Comm().SumAll(&NumMyEmptyRows, &NumGlobalEmptyRows, 1);
A.Comm().SumAll(&NumMyDirichletRows, &NumGlobalDirichletRows, 1);
A.Comm().SumAll(&MyBandwidth, &GlobalBandwidth, 1);
A.Comm().SumAll(&MyLowerNonzeros, &GlobalLowerNonzeros, 1);
A.Comm().SumAll(&MyUpperNonzeros, &GlobalUpperNonzeros, 1);
A.Comm().SumAll(&MyDiagonallyDominant, &GlobalDiagonallyDominant, 1);
A.Comm().SumAll(&MyWeaklyDiagonallyDominant, &GlobalWeaklyDiagonallyDominant, 1);
double NormOne = A.NormOne();
double NormInf = A.NormInf();
double NormF = Ifpack_FrobeniusNorm(A);
if (verbose) {
print();
print<long long>("Actual nonzeros", NumGlobalActualNonzeros);
print<long long>("Nonzeros in strict lower part", GlobalLowerNonzeros);
print<long long>("Nonzeros in strict upper part", GlobalUpperNonzeros);
print();
print<long long>("Empty rows", NumGlobalEmptyRows,
100.0 * NumGlobalEmptyRows / NumGlobalRows);
print<long long>("Dirichlet rows", NumGlobalDirichletRows,
100.0 * NumGlobalDirichletRows / NumGlobalRows);
print<long long>("Diagonally dominant rows", GlobalDiagonallyDominant,
100.0 * GlobalDiagonallyDominant / NumGlobalRows);
print<long long>("Weakly diag. dominant rows",
GlobalWeaklyDiagonallyDominant,
100.0 * GlobalWeaklyDiagonallyDominant / NumGlobalRows);
print();
print<long long>("Maximum bandwidth", GlobalBandwidth);
print();
print("", "one-norm", "inf-norm", "Frobenius", false);
print("", "========", "========", "=========", false);
print();
print<double>("A", NormOne, NormInf, NormF);
}
if (Cheap == false) {
// create A + A^T and A - A^T
Epetra_FECrsMatrix AplusAT(Copy, A.RowMatrixRowMap(), 0);
Epetra_FECrsMatrix AminusAT(Copy, A.RowMatrixRowMap(), 0);
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
if(A.RowMatrixRowMap().GlobalIndicesInt()) {
for (int i = 0 ; i < NumMyRows ; ++i) {
int GRID = A.RowMatrixRowMap().GID(i);
assert (GRID != -1);
int Nnz;
IFPACK_CHK_ERR(A.ExtractMyRowCopy(i,A.MaxNumEntries(),Nnz,
&colVal[0],&colInd[0]));
for (int j = 0 ; j < Nnz ; ++j) {
int GCID = A.RowMatrixColMap().GID(colInd[j]);
assert (GCID != -1);
double plus_val = colVal[j];
double minus_val = -colVal[j];
if (AplusAT.SumIntoGlobalValues(1,&GRID,1,&GCID,&plus_val) != 0) {
IFPACK_CHK_ERR(AplusAT.InsertGlobalValues(1,&GRID,1,&GCID,&plus_val));
}
if (AplusAT.SumIntoGlobalValues(1,&GCID,1,&GRID,&plus_val) != 0) {
IFPACK_CHK_ERR(AplusAT.InsertGlobalValues(1,&GCID,1,&GRID,&plus_val));
}
if (AminusAT.SumIntoGlobalValues(1,&GRID,1,&GCID,&plus_val) != 0) {
IFPACK_CHK_ERR(AminusAT.InsertGlobalValues(1,&GRID,1,&GCID,&plus_val));
}
if (AminusAT.SumIntoGlobalValues(1,&GCID,1,&GRID,&minus_val) != 0) {
IFPACK_CHK_ERR(AminusAT.InsertGlobalValues(1,&GCID,1,&GRID,&minus_val));
}
}
}
}
else
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
if(A.RowMatrixRowMap().GlobalIndicesLongLong()) {
for (int i = 0 ; i < NumMyRows ; ++i) {
long long GRID = A.RowMatrixRowMap().GID64(i);
assert (GRID != -1);
int Nnz;
IFPACK_CHK_ERR(A.ExtractMyRowCopy(i,A.MaxNumEntries(),Nnz,
&colVal[0],&colInd[0]));
for (int j = 0 ; j < Nnz ; ++j) {
long long GCID = A.RowMatrixColMap().GID64(colInd[j]);
assert (GCID != -1);
double plus_val = colVal[j];
double minus_val = -colVal[j];
if (AplusAT.SumIntoGlobalValues(1,&GRID,1,&GCID,&plus_val) != 0) {
IFPACK_CHK_ERR(AplusAT.InsertGlobalValues(1,&GRID,1,&GCID,&plus_val));
}
if (AplusAT.SumIntoGlobalValues(1,&GCID,1,&GRID,&plus_val) != 0) {
IFPACK_CHK_ERR(AplusAT.InsertGlobalValues(1,&GCID,1,&GRID,&plus_val));
}
if (AminusAT.SumIntoGlobalValues(1,&GRID,1,&GCID,&plus_val) != 0) {
IFPACK_CHK_ERR(AminusAT.InsertGlobalValues(1,&GRID,1,&GCID,&plus_val));
}
if (AminusAT.SumIntoGlobalValues(1,&GCID,1,&GRID,&minus_val) != 0) {
IFPACK_CHK_ERR(AminusAT.InsertGlobalValues(1,&GCID,1,&GRID,&minus_val));
}
}
}
}
else
#endif
throw "Ifpack_Analyze: GlobalIndices type unknown";
AplusAT.FillComplete();
AminusAT.FillComplete();
AplusAT.Scale(0.5);
AminusAT.Scale(0.5);
NormOne = AplusAT.NormOne();
NormInf = AplusAT.NormInf();
NormF = Ifpack_FrobeniusNorm(AplusAT);
if (verbose) {
print<double>("A + A^T", NormOne, NormInf, NormF);
}
NormOne = AminusAT.NormOne();
NormInf = AminusAT.NormInf();
NormF = Ifpack_FrobeniusNorm(AminusAT);
if (verbose) {
print<double>("A - A^T", NormOne, NormInf, NormF);
}
}
if (verbose) {
print();
print<const char*>("", "min", "avg", "max", false);
print<const char*>("", "===", "===", "===", false);
}
MyMax = -DBL_MAX;
MyMin = DBL_MAX;
MyAvg = 0.0;
for (int i = 0 ; i < NumMyRows ; ++i) {
int Nnz;
IFPACK_CHK_ERR(A.ExtractMyRowCopy(i,A.MaxNumEntries(),Nnz,
&colVal[0],&colInd[0]));
for (int j = 0 ; j < Nnz ; ++j) {
MyAvg += colVal[j];
if (colVal[j] > MyMax) MyMax = colVal[j];
if (colVal[j] < MyMin) MyMin = colVal[j];
}
}
A.Comm().MaxAll(&MyMax, &GlobalMax, 1);
A.Comm().MinAll(&MyMin, &GlobalMin, 1);
A.Comm().SumAll(&MyAvg, &GlobalAvg, 1);
GlobalAvg /= A.NumGlobalNonzeros64();
if (verbose) {
print();
print<double>(" A(i,j)", GlobalMin, GlobalAvg, GlobalMax);
}
MyMax = 0.0;
MyMin = DBL_MAX;
MyAvg = 0.0;
for (int i = 0 ; i < NumMyRows ; ++i) {
int Nnz;
IFPACK_CHK_ERR(A.ExtractMyRowCopy(i,A.MaxNumEntries(),Nnz,
&colVal[0],&colInd[0]));
for (int j = 0 ; j < Nnz ; ++j) {
double v = colVal[j];
if (v < 0) v = -v;
MyAvg += v;
if (colVal[j] > MyMax) MyMax = v;
if (colVal[j] < MyMin) MyMin = v;
}
}
A.Comm().MaxAll(&MyMax, &GlobalMax, 1);
A.Comm().MinAll(&MyMin, &GlobalMin, 1);
A.Comm().SumAll(&MyAvg, &GlobalAvg, 1);
GlobalAvg /= A.NumGlobalNonzeros64();
if (verbose) {
print<double>("|A(i,j)|", GlobalMin, GlobalAvg, GlobalMax);
}
// ================= //
// diagonal elements //
// ================= //
Diag.MinValue(&GlobalMin);
Diag.MaxValue(&GlobalMax);
Diag.MeanValue(&GlobalAvg);
if (verbose) {
print();
print<double>(" A(k,k)", GlobalMin, GlobalAvg, GlobalMax);
}
Diag.Abs(Diag);
Diag.MinValue(&GlobalMin);
Diag.MaxValue(&GlobalMax);
Diag.MeanValue(&GlobalAvg);
if (verbose) {
print<double>("|A(k,k)|", GlobalMin, GlobalAvg, GlobalMax);
}
// ============================================== //
// cycle over all equations for diagonal elements //
// ============================================== //
if (NumPDEEqns > 1 ) {
if (verbose) print();
for (int ie = 0 ; ie < NumPDEEqns ; ie++) {
MyMin = DBL_MAX;
MyMax = -DBL_MAX;
MyAvg = 0.0;
for (int i = ie ; i < Diag.MyLength() ; i += NumPDEEqns) {
double d = Diag[i];
MyAvg += d;
if (d < MyMin)
MyMin = d;
if (d > MyMax)
MyMax = d;
}
A.Comm().MinAll(&MyMin, &GlobalMin, 1);
A.Comm().MaxAll(&MyMax, &GlobalMax, 1);
A.Comm().SumAll(&MyAvg, &GlobalAvg, 1);
// does not really work fine if the number of global
// elements is not a multiple of NumPDEEqns
GlobalAvg /= (Diag.GlobalLength64() / NumPDEEqns);
if (verbose) {
char str[80];
sprintf(str, " A(k,k), eq %d", ie);
print<double>(str, GlobalMin, GlobalAvg, GlobalMax);
}
}
}
// ======== //
// row sums //
// ======== //
RowSum.MinValue(&GlobalMin);
RowSum.MaxValue(&GlobalMax);
RowSum.MeanValue(&GlobalAvg);
if (verbose) {
print();
print<double>(" sum_j A(k,j)", GlobalMin, GlobalAvg, GlobalMax);
}
// ===================================== //
// cycle over all equations for row sums //
// ===================================== //
if (NumPDEEqns > 1 ) {
if (verbose) print();
for (int ie = 0 ; ie < NumPDEEqns ; ie++) {
MyMin = DBL_MAX;
MyMax = -DBL_MAX;
MyAvg = 0.0;
for (int i = ie ; i < Diag.MyLength() ; i += NumPDEEqns) {
double d = RowSum[i];
MyAvg += d;
if (d < MyMin)
MyMin = d;
if (d > MyMax)
MyMax = d;
}
A.Comm().MinAll(&MyMin, &GlobalMin, 1);
A.Comm().MaxAll(&MyMax, &GlobalMax, 1);
A.Comm().SumAll(&MyAvg, &GlobalAvg, 1);
// does not really work fine if the number of global
// elements is not a multiple of NumPDEEqns
GlobalAvg /= (Diag.GlobalLength64() / NumPDEEqns);
if (verbose) {
char str[80];
sprintf(str, " sum_j A(k,j), eq %d", ie);
print<double>(str, GlobalMin, GlobalAvg, GlobalMax);
}
}
}
if (verbose)
Ifpack_PrintLine();
return(0);
}
