/* ml_epetra_data_pack_status - This function does a status query on the
ML_EPETRA_DATA_PACK passed in.
Returns: IS_TRUE
*/
int ml_epetra_data_pack::status(){
mexPrintf("**** Problem ID %d [ML_Epetra] ****\n",id);
if(A) mexPrintf("Matrix: %dx%d w/ %d nnz\n",A->NumGlobalRows(),A->NumGlobalCols(),A->NumMyNonzeros());
mexPrintf(" Operator complexity = %e\n",operator_complexity);
if(List){mexPrintf("Parameter List:\n");List->print(cout,1);}
mexPrintf("\n");
return IS_TRUE;
}/*end status*/
//==============================================================================
Epetra_FastCrsMatrix::Epetra_FastCrsMatrix(const Epetra_CrsMatrix & Matrix, bool UseFloats)
: CrsMatrix_(Matrix),
Values_(0),
NumMyRows_(Matrix.NumMyRows()),
NumMyNonzeros(Matrix.NumMyNonzeros()),
ImportVector_(0),
ExportVector_(0),
CV_(Copy)
{
if (!CrsMatrix_.Filled()) throw CrsMatrix_.ReportError("Input matrix must have called FillComplete()", -1);
Allocate(UseFloats);
}
//=========================================================================
// NOTE: This method should be removed and replaced with calls to Epetra_Util_ExtractHbData()
int Epetra_LinearProblemRedistor::ExtractHbData(int & M, int & N, int & nz, int * & ptr,
int * & ind, double * & val, int & Nrhs,
double * & rhs, int & ldrhs,
double * & lhs, int & ldlhs) const {
Epetra_CrsMatrix * RedistMatrix = dynamic_cast<Epetra_CrsMatrix *>(RedistProblem_->GetMatrix());
if (RedistMatrix==0) EPETRA_CHK_ERR(-1); // This matrix is zero or not an Epetra_CrsMatrix
if (!RedistMatrix->IndicesAreContiguous()) { // Data must be contiguous for this to work
EPETRA_CHK_ERR(-2);
}
M = RedistMatrix->NumMyRows();
N = RedistMatrix->NumMyCols();
nz = RedistMatrix->NumMyNonzeros();
val = (*RedistMatrix)[0]; // Dangerous, but cheap and effective way to access first element in
const Epetra_CrsGraph & RedistGraph = RedistMatrix->Graph();
ind = RedistGraph[0]; // list of values and indices
Epetra_MultiVector * LHS = RedistProblem_->GetLHS();
Epetra_MultiVector * RHS = RedistProblem_->GetRHS();
Nrhs = RHS->NumVectors();
if (Nrhs>1) {
if (!RHS->ConstantStride()) {EPETRA_CHK_ERR(-3)}; // Must have strided vectors
if (!LHS->ConstantStride()) {EPETRA_CHK_ERR(-4)}; // Must have strided vectors
}
ldrhs = RHS->Stride();
rhs = (*RHS)[0]; // Dangerous but effective (again)
ldlhs = LHS->Stride();
lhs = (*LHS)[0];
// Finally build ptr vector
if (ptr_==0) {
ptr_ = new int[M+1];
ptr_[0] = 0;
for (int i=0; i<M; i++) ptr_[i+1] = ptr_[i] + RedistGraph.NumMyIndices(i);
}
ptr = ptr_;
return(0);
}
int check(Epetra_CrsMatrix& A, int NumMyRows1, int NumGlobalRows1, int NumMyNonzeros1,
int NumGlobalNonzeros1, int* MyGlobalElements, bool verbose)
{
(void)MyGlobalElements;
int ierr = 0, forierr = 0;
int NumGlobalIndices;
int NumMyIndices;
int* MyViewIndices = 0;
int* GlobalViewIndices = 0;
double* MyViewValues = 0;
double* GlobalViewValues = 0;
int MaxNumIndices = A.Graph().MaxNumIndices();
int* MyCopyIndices = new int[MaxNumIndices];
int* GlobalCopyIndices = new int[MaxNumIndices];
double* MyCopyValues = new double[MaxNumIndices];
double* GlobalCopyValues = new double[MaxNumIndices];
// Test query functions
int NumMyRows = A.NumMyRows();
if (verbose) cout << "\n\nNumber of local Rows = " << NumMyRows << endl<< endl;
EPETRA_TEST_ERR(!(NumMyRows==NumMyRows1),ierr);
int NumMyNonzeros = A.NumMyNonzeros();
if (verbose) cout << "\n\nNumber of local Nonzero entries = " << NumMyNonzeros << endl<< endl;
EPETRA_TEST_ERR(!(NumMyNonzeros==NumMyNonzeros1),ierr);
int NumGlobalRows = A.NumGlobalRows();
if (verbose) cout << "\n\nNumber of global Rows = " << NumGlobalRows << endl<< endl;
EPETRA_TEST_ERR(!(NumGlobalRows==NumGlobalRows1),ierr);
int NumGlobalNonzeros = A.NumGlobalNonzeros();
if (verbose) cout << "\n\nNumber of global Nonzero entries = " << NumGlobalNonzeros << endl<< endl;
EPETRA_TEST_ERR(!(NumGlobalNonzeros==NumGlobalNonzeros1),ierr);
// GlobalRowView should be illegal (since we have local indices)
EPETRA_TEST_ERR(!(A.ExtractGlobalRowView(A.RowMap().MaxMyGID(), NumGlobalIndices, GlobalViewValues, GlobalViewIndices)==-2),ierr);
// Other binary tests
EPETRA_TEST_ERR(A.NoDiagonal(),ierr);
EPETRA_TEST_ERR(!(A.Filled()),ierr);
EPETRA_TEST_ERR(!(A.MyGRID(A.RowMap().MaxMyGID())),ierr);
EPETRA_TEST_ERR(!(A.MyGRID(A.RowMap().MinMyGID())),ierr);
EPETRA_TEST_ERR(A.MyGRID(1+A.RowMap().MaxMyGID()),ierr);
EPETRA_TEST_ERR(A.MyGRID(-1+A.RowMap().MinMyGID()),ierr);
EPETRA_TEST_ERR(!(A.MyLRID(0)),ierr);
EPETRA_TEST_ERR(!(A.MyLRID(NumMyRows-1)),ierr);
EPETRA_TEST_ERR(A.MyLRID(-1),ierr);
EPETRA_TEST_ERR(A.MyLRID(NumMyRows),ierr);
forierr = 0;
for (int i = 0; i < NumMyRows; i++) {
int Row = A.GRID(i);
A.ExtractGlobalRowCopy(Row, MaxNumIndices, NumGlobalIndices, GlobalCopyValues, GlobalCopyIndices);
A.ExtractMyRowView(i, NumMyIndices, MyViewValues, MyViewIndices); // this is where the problem comes from
forierr += !(NumGlobalIndices == NumMyIndices);
for(int j = 1; j < NumMyIndices; j++) {
forierr += !(MyViewIndices[j-1] < MyViewIndices[j]); // this is where the test fails
}
for(int j = 0; j < NumGlobalIndices; j++) {
forierr += !(GlobalCopyIndices[j] == A.GCID(MyViewIndices[j]));
forierr += !(A.LCID(GlobalCopyIndices[j]) == MyViewIndices[j]);
forierr += !(GlobalCopyValues[j] == MyViewValues[j]);
}
}
EPETRA_TEST_ERR(forierr,ierr);
forierr = 0;
for (int i = 0; i < NumMyRows; i++) {
int Row = A.GRID(i);
A.ExtractGlobalRowCopy(Row, MaxNumIndices, NumGlobalIndices, GlobalCopyValues, GlobalCopyIndices);
A.ExtractMyRowCopy(i, MaxNumIndices, NumMyIndices, MyCopyValues, MyCopyIndices);
forierr += !(NumGlobalIndices == NumMyIndices);
for (int j = 1; j < NumMyIndices; j++)
forierr += !(MyCopyIndices[j-1] < MyCopyIndices[j]);
for (int j = 0; j < NumGlobalIndices; j++) {
forierr += !(GlobalCopyIndices[j] == A.GCID(MyCopyIndices[j]));
forierr += !(A.LCID(GlobalCopyIndices[j]) == MyCopyIndices[j]);
forierr += !(GlobalCopyValues[j] == MyCopyValues[j]);
}
}
EPETRA_TEST_ERR(forierr,ierr);
delete [] MyCopyIndices;
delete [] GlobalCopyIndices;
delete [] MyCopyValues;
delete [] GlobalCopyValues;
if (verbose) cout << "\n\nRows sorted check OK" << endl<< endl;
return (ierr);
}
