void show_matrix(const char *txt, const Epetra_RowMatrix &matrix, const Epetra_Comm &comm)
{
int me = comm.MyPID();
if (comm.NumProc() > 10){
if (me == 0){
std::cout << txt << std::endl;
std::cout << "Printed matrix format only works for 10 or fewer processes" << std::endl;
}
return;
}
int numRows = matrix.NumGlobalRows();
int numCols = matrix.NumGlobalCols();
if ((numRows > 200) || (numCols > 500)){
if (me == 0){
std::cerr << txt << std::endl;
std::cerr << "show_matrix: problem is too large to display" << std::endl;
}
return;
}
int *myA = new int [numRows * numCols];
make_my_A(matrix, myA, comm);
printMatrix(txt, myA, NULL, NULL, numRows, numCols, comm);
delete [] myA;
}
void Test(const string what, Epetra_RowMatrix& A)
{
T Prec(&A);
bool UseTranspose = true;
IFPACK_CHK_ERRV(Prec.Initialize());
IFPACK_CHK_ERRV(Prec.Compute());
IFPACK_CHK_ERRV(Prec.SetUseTranspose(UseTranspose));
Epetra_MultiVector LHS_exact(A.OperatorDomainMap(), 2);
Epetra_MultiVector LHS(A.OperatorDomainMap(), 2);
Epetra_MultiVector RHS(A.OperatorRangeMap(), 2);
LHS_exact.Random(); LHS.PutScalar(0.0);
A.Multiply(UseTranspose, LHS_exact, RHS);
Prec.ApplyInverse(RHS, LHS);
LHS.Update(1.0, LHS_exact, -1.0);
double norm[2];
LHS.Norm2(norm);
norm[0] += norm[1];
if (norm[0] > 1e-5)
{
cout << what << ": Test failed: norm = " << norm[0] << endl;
exit(EXIT_FAILURE);
}
cout << what << ": Test passed: norm = " << norm[0] << endl;
}
int compute_graph_metrics(const Epetra_RowMatrix &matrix,
Isorropia::Epetra::CostDescriber &costs,
double &myGoalWeight,
double &balance, int &numCuts, double &cutWgt, double &cutn, double &cutl)
{
const Epetra_Map &rmap = matrix.RowMatrixRowMap();
const Epetra_Map &cmap = matrix.RowMatrixColMap();
int maxEdges = matrix.MaxNumEntries();
std::vector<std::vector<int> > myRows(rmap.NumMyElements());
if (maxEdges > 0){
int numEdges = 0;
int *nborLID = new int [maxEdges];
double *tmp = new double [maxEdges];
for (int i=0; i<rmap.NumMyElements(); i++){
matrix.ExtractMyRowCopy(i, maxEdges, numEdges, tmp, nborLID);
std::vector<int> cols(numEdges);
for (int j=0; j<numEdges; j++){
cols[j] = nborLID[j];
}
myRows[i] = cols;
}
delete [] nborLID;
delete [] tmp;
}
return compute_graph_metrics(rmap, cmap, myRows, costs, myGoalWeight,
balance, numCuts, cutWgt, cutn, cutl);
}
void show_matrix(const char *txt, const Epetra_LinearProblem &problem, const Epetra_Comm &comm)
{
int me = comm.MyPID();
if (comm.NumProc() > 10){
if (me == 0){
std::cout << txt << std::endl;
std::cout << "Printed matrix format only works for 10 or fewer processes" << std::endl;
}
return;
}
Epetra_RowMatrix *matrix = problem.GetMatrix();
Epetra_MultiVector *lhs = problem.GetLHS();
Epetra_MultiVector *rhs = problem.GetRHS();
int numRows = matrix->NumGlobalRows();
int numCols = matrix->NumGlobalCols();
if ((numRows > 200) || (numCols > 500)){
if (me == 0){
std::cerr << txt << std::endl;
std::cerr << "show_matrix: problem is too large to display" << std::endl;
}
return;
}
int *myA = new int [numRows * numCols];
make_my_A(*matrix, myA, comm);
int *myX = new int [numCols];
int *myB = new int [numRows];
memset(myX, 0, sizeof(int) * numCols);
memset(myB, 0, sizeof(int) * numRows);
const Epetra_BlockMap &lhsMap = lhs->Map();
const Epetra_BlockMap &rhsMap = rhs->Map();
int base = lhsMap.IndexBase();
for (int j=0; j < lhsMap.NumMyElements(); j++){
int colGID = lhsMap.GID(j);
myX[colGID - base] = me + 1;
}
for (int i=0; i < rhsMap.NumMyElements(); i++){
int rowGID = rhsMap.GID(i);
myB[rowGID - base] = me + 1;
}
printMatrix(txt, myA, myX, myB, numRows, numCols, comm);
delete [] myA;
delete [] myX;
delete [] myB;
}
int writeRowMatrix(FILE * handle, const Epetra_RowMatrix & A) {
long long numRows_LL = A.NumGlobalRows64();
if(numRows_LL > std::numeric_limits<int>::max())
throw "EpetraExt::writeRowMatrix: numRows_LL > std::numeric_limits<int>::max()";
int numRows = static_cast<int>(numRows_LL);
Epetra_Map rowMap = A.RowMatrixRowMap();
Epetra_Map colMap = A.RowMatrixColMap();
const Epetra_Comm & comm = rowMap.Comm();
long long ioffset = 1 - rowMap.IndexBase64(); // Matlab indices start at 1
long long joffset = 1 - colMap.IndexBase64(); // Matlab indices start at 1
if (comm.MyPID()!=0) {
if (A.NumMyRows()!=0) {EPETRA_CHK_ERR(-1);}
if (A.NumMyCols()!=0) {EPETRA_CHK_ERR(-1);}
}
else {
if (numRows!=A.NumMyRows()) {EPETRA_CHK_ERR(-1);}
Epetra_SerialDenseVector values(A.MaxNumEntries());
Epetra_IntSerialDenseVector indices(A.MaxNumEntries());
for (int i=0; i<numRows; i++) {
long long I = rowMap.GID64(i) + ioffset;
int numEntries;
if (A.ExtractMyRowCopy(i, values.Length(), numEntries,
values.Values(), indices.Values())!=0) {EPETRA_CHK_ERR(-1);}
for (int j=0; j<numEntries; j++) {
long long J = colMap.GID64(indices[j]) + joffset;
double val = values[j];
fprintf(handle, "%lld %lld %22.16e\n", I, J, val);
}
}
}
return(0);
}
int RowMatrixToHandle(FILE * handle, const Epetra_RowMatrix & A) {
Epetra_Map map = A.RowMatrixRowMap();
const Epetra_Comm & comm = map.Comm();
int numProc = comm.NumProc();
if (numProc==1 || !A.Map().DistributedGlobal())
writeRowMatrix(handle, A);
else {
int numRows = map.NumMyElements();
Epetra_Map allGidsMap((int_type) -1, numRows, (int_type) 0,comm);
typename Epetra_GIDTypeVector<int_type>::impl allGids(allGidsMap);
for (int i=0; i<numRows; i++) allGids[i] = (int_type) map.GID64(i);
// Now construct a RowMatrix on PE 0 by strip-mining the rows of the input matrix A.
int numChunks = numProc;
int stripSize = allGids.GlobalLength64()/numChunks;
int remainder = allGids.GlobalLength64()%numChunks;
int curStart = 0;
int curStripSize = 0;
typename Epetra_GIDTypeSerialDenseVector<int_type>::impl importGidList;
if (comm.MyPID()==0)
importGidList.Size(stripSize+1); // Set size of vector to max needed
for (int i=0; i<numChunks; i++) {
if (comm.MyPID()==0) { // Only PE 0 does this part
curStripSize = stripSize;
if (i<remainder) curStripSize++; // handle leftovers
for (int j=0; j<curStripSize; j++) importGidList[j] = j + curStart;
curStart += curStripSize;
}
// The following import map will be non-trivial only on PE 0.
if (comm.MyPID()>0) assert(curStripSize==0);
Epetra_Map importGidMap(-1, curStripSize, importGidList.Values(), 0, comm);
Epetra_Import gidImporter(importGidMap, allGidsMap);
typename Epetra_GIDTypeVector<int_type>::impl importGids(importGidMap);
if (importGids.Import(allGids, gidImporter, Insert)!=0) {EPETRA_CHK_ERR(-1); }
// importGids now has a list of GIDs for the current strip of matrix rows.
// Use these values to build another importer that will get rows of the matrix.
// The following import map will be non-trivial only on PE 0.
Epetra_Map importMap(-1, importGids.MyLength(), importGids.Values(), map.IndexBase64(), comm);
Epetra_Import importer(importMap, map);
Epetra_CrsMatrix importA(Copy, importMap, 0);
if (importA.Import(A, importer, Insert)!=0) {EPETRA_CHK_ERR(-1); }
if (importA.FillComplete(A.OperatorDomainMap(), importMap)!=0) {EPETRA_CHK_ERR(-1);}
// Finally we are ready to write this strip of the matrix to ostream
if (writeRowMatrix(handle, importA)!=0) {EPETRA_CHK_ERR(-1);}
}
}
return(0);
}
BlockCrsMatrix::BlockCrsMatrix(
const Epetra_RowMatrix & BaseMatrix,
const vector< vector<long long> > & RowStencil,
const vector<long long> & RowIndices,
const Epetra_Comm & GlobalComm )
: Epetra_CrsMatrix( Copy, *(BlockUtility::GenerateBlockGraph( BaseMatrix, RowStencil, RowIndices, GlobalComm )) ),
BaseGraph_( Copy, BaseMatrix.RowMatrixRowMap(), 1 ), //Junk to satisfy constructor
RowStencil_LL_( RowStencil ),
RowIndices_LL_( RowIndices ),
ROffset_(BlockUtility::CalculateOffset64(BaseMatrix.RowMatrixRowMap())),
COffset_(BlockUtility::CalculateOffset64(BaseMatrix.RowMatrixColMap()))
{
}
// ======================================================================
bool BasicTest(string PrecType,
CrsMatrixGallery& Gallery)
{
// The following methods of CrsMatrixGallery are used to get pointers
// to internally stored Epetra_RowMatrix and Epetra_LinearProblem.
Epetra_RowMatrix* A = Gallery.GetMatrix();
Epetra_LinearProblem* Problem = Gallery.GetLinearProblem();
Epetra_MultiVector& RHS = *(Problem->GetRHS());
Epetra_MultiVector& LHS = *(Problem->GetLHS());
LHS.PutScalar(0.0);
// Set up the list
Teuchos::ParameterList List;
List.set("relaxation: damping factor", 1.0);
List.set("relaxation: sweeps",1550);
List.set("relaxation: type", PrecType);
Ifpack_PointRelaxation Point(A);
Point.SetParameters(List);
Point.Compute();
// use the preconditioner as solver, with 1550 iterations
Point.ApplyInverse(RHS,LHS);
// compute the real residual
double residual, diff;
Gallery.ComputeResidual(&residual);
Gallery.ComputeDiffBetweenStartingAndExactSolutions(&diff);
if (verbose && A->Comm().MyPID()==0) {
cout << "||b-Ax||_2 = " << residual << endl;
cout << "||x_exact - x||_2 = " << diff << endl;
}
// Jacobi is very slow to converge here
if (residual < 1e-2) {
if (verbose)
cout << "Test passed" << endl;
return(true);
}
else {
if (verbose)
cout << "Test failed!" << endl;
return(false);
}
}
int RowMatrixToHandle(FILE * handle, const Epetra_RowMatrix & A) {
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
if(A.RowMatrixRowMap().GlobalIndicesInt()) {
return RowMatrixToHandle<int>(handle, A);
}
else
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
if(A.RowMatrixRowMap().GlobalIndicesLongLong()) {
return RowMatrixToHandle<long long>(handle, A);
}
else
#endif
throw "EpetraExt::RowMatrixToHandle: GlobalIndices type unknown";
}
void BlockCrsMatrix::LoadBlock(const Epetra_RowMatrix & BaseMatrix, const int Row, const int Col)
{
if(Epetra_CrsMatrix::RowMatrixRowMap().GlobalIndicesInt() && BaseMatrix.RowMatrixRowMap().GlobalIndicesInt())
return TLoadBlock<int>(BaseMatrix, Row, Col);
else
throw "EpetraExt::BlockCrsMatrix::LoadBlock: Global indices not int";
}
void BlockCrsMatrix::SumIntoGlobalBlock(double alpha, const Epetra_RowMatrix & BaseMatrix, const int Row, const int Col)
{
if(Epetra_CrsMatrix::RowMatrixRowMap().GlobalIndicesInt() && BaseMatrix.RowMatrixRowMap().GlobalIndicesInt())
return TSumIntoGlobalBlock<int>(alpha, BaseMatrix, Row, Col);
else
throw "EpetraExt::BlockCrsMatrix::SumIntoGlobalBlock: Global indices not int";
}
void BlockCrsMatrix::SumIntoGlobalBlock(double alpha, const Epetra_RowMatrix & BaseMatrix, const long long Row, const long long Col)
{
if(Epetra_CrsMatrix::RowMatrixRowMap().GlobalIndicesLongLong() && BaseMatrix.RowMatrixRowMap().GlobalIndicesLongLong())
return TSumIntoGlobalBlock<long long>(alpha, BaseMatrix, Row, Col);
else
throw "EpetraExt::BlockCrsMatrix::SumIntoGlobalBlock: Global indices not long long";
}
void BlockCrsMatrix::LoadBlock(const Epetra_RowMatrix & BaseMatrix, const long long Row, const long long Col)
{
if(Epetra_CrsMatrix::RowMatrixRowMap().GlobalIndicesLongLong() && BaseMatrix.RowMatrixRowMap().GlobalIndicesLongLong())
return TLoadBlock<long long>(BaseMatrix, Row, Col);
else
throw "EpetraExt::BlockCrsMatrix::LoadBlock: Global indices not long long";
}
int power_method(bool TransA, Epetra_RowMatrix& A, Epetra_Vector& q, Epetra_Vector& z0,
Epetra_Vector& resid, double* lambda, int niters, double tolerance, bool verbose)
{
// Fill z with random Numbers
Epetra_Vector z(z0);
// variable needed for iteration
double normz, residual;
int ierr = 1;
for(int iter = 0; iter < niters; iter++) {
z.Norm2(&normz); // Compute 2-norm of z
q.Scale(1.0/normz, z);
A.Multiply(TransA, q, z); // Compute z = A*q // SEGFAULT HAPPENS HERE
q.Dot(z, lambda); // Approximate maximum eigenvaluE
if(iter%100==0 || iter+1==niters) {
resid.Update(1.0, z, -(*lambda), q, 0.0); // Compute A*q - lambda*q
resid.Norm2(&residual);
if(verbose) cout << "Iter = " << iter << " Lambda = " << *lambda
<< " Residual of A*q - lambda*q = " << residual << endl;
}
if(residual < tolerance) {
ierr = 0;
break;
}
}
return(ierr);
}
void ModeLaplace1DQ1::memoryInfo() const {
int myPid = MyComm.MyPID();
Epetra_RowMatrix *Mat = dynamic_cast<Epetra_RowMatrix *>(M);
if ((myPid == 0) && (Mat)) {
cout << " Total number of nonzero entries in mass matrix = ";
cout.width(15);
cout << Mat->NumGlobalNonzeros() << endl;
double memSize = Mat->NumGlobalNonzeros()*(sizeof(double) + sizeof(int));
memSize += 2*Mat->NumGlobalRows()*sizeof(int);
cout << " Memory requested for mass matrix per processor = (EST) ";
cout.precision(2);
cout.width(6);
cout.setf(ios::fixed, ios::floatfield);
cout << memSize/1024.0/1024.0/MyComm.NumProc() << " MB " << endl;
cout << endl;
}
Mat = dynamic_cast<Epetra_RowMatrix *>(K);
if ((myPid == 0) && (Mat)) {
cout << " Total number of nonzero entries in stiffness matrix = ";
cout.width(15);
cout << Mat->NumGlobalNonzeros() << endl;
double memSize = Mat->NumGlobalNonzeros()*(sizeof(double) + sizeof(int));
memSize += 2*Mat->NumGlobalRows()*sizeof(int);
cout << " Memory requested for stiffness matrix per processor = (EST) ";
cout.precision(2);
cout.width(6);
cout.setf(ios::fixed, ios::floatfield);
cout << memSize/1024.0/1024.0/MyComm.NumProc() << " MB " << endl;
cout << endl;
}
}
int compute_hypergraph_metrics(const Epetra_RowMatrix &matrix,
Isorropia::Epetra::CostDescriber &costs,
double &myGoalWeight,
double &balance, double &cutn, double &cutl) // output
{
const Epetra_BlockMap &rmap =
static_cast<const Epetra_BlockMap &>(matrix.RowMatrixRowMap());
const Epetra_BlockMap &cmap =
static_cast<const Epetra_BlockMap &>(matrix.RowMatrixColMap());
return compute_hypergraph_metrics(rmap, cmap,
matrix.NumGlobalCols(),
costs,
myGoalWeight,
balance, cutn, cutl);
}
//==============================================================================
int Komplex_LinearProblem::InitMatrixAccess(const Epetra_RowMatrix & A0, const Epetra_RowMatrix & A1) {
MaxNumMyEntries0_ = A0.MaxNumEntries();
MaxNumMyEntries1_ = A1.MaxNumEntries();
// Cast to CrsMatrix, if possible. Can save some work.
CrsA0_ = dynamic_cast<const Epetra_CrsMatrix *>(&A0);
CrsA1_ = dynamic_cast<const Epetra_CrsMatrix *>(&A1);
A0A1AreCrs_ = (CrsA0_!=0 && CrsA1_!=0); // Pointers are non-zero if cast worked
if (!A0A1AreCrs_) {
Indices0_.resize(MaxNumMyEntries0_);
Values0_.resize(MaxNumMyEntries0_);
Indices1_.resize(MaxNumMyEntries1_);
Values1_.resize(MaxNumMyEntries1_);
}
return(0);
}
//==============================================================================
int Komplex_LinearProblem::GetRow(int Row, const Epetra_RowMatrix & A0, const Epetra_RowMatrix & A1,
int & NumIndices0, double * & Values0, int * & Indices0,
int & NumIndices1, double * & Values1, int * & Indices1) {
if (A0A1AreCrs_) { // View of current row
TEUCHOS_TEST_FOR_EXCEPT(CrsA0_->ExtractMyRowView(Row, NumIndices0, Values0, Indices0)<0);
TEUCHOS_TEST_FOR_EXCEPT(CrsA1_->ExtractMyRowView(Row, NumIndices1, Values1, Indices1)<0);
}
else { // Copy of current row
TEUCHOS_TEST_FOR_EXCEPT(A0.ExtractMyRowCopy(Row, MaxNumMyEntries0_, NumIndices0, &Values0_[0], &Indices0_[0])<0);
TEUCHOS_TEST_FOR_EXCEPT(A1.ExtractMyRowCopy(Row, MaxNumMyEntries1_, NumIndices1, &Values1_[0], &Indices1_[0])<0);
Values0 = &Values0_[0];
Indices0 = &Indices0_[0];
Values1 = &Values1_[0];
Indices1 = &Indices1_[0];
}
return(0);
}
int Amesos_Scalapack::NumericFactorization() {
if( debug_ == 1 ) std::cout << "Entering `NumericFactorization()'" << std::endl;
NumNumericFact_++;
iam_ = Comm().MyPID();
Epetra_RowMatrix *RowMatrixA = dynamic_cast<Epetra_RowMatrix *>(Problem_->GetOperator());
const Epetra_Map &OriginalMap = RowMatrixA->RowMatrixRowMap() ;
NumGlobalElements_ = OriginalMap.NumGlobalElements();
NumGlobalNonzeros_ = RowMatrixA->NumGlobalNonzeros();
RedistributeA();
ConvertToScalapack();
return PerformNumericFactorization( );
}
//==============================================================================
int Komplex_LinearProblem::TestMaps (const Epetra_RowMatrix & A0, const Epetra_RowMatrix & A1,
const Epetra_MultiVector & Xr, const Epetra_MultiVector & Xi,
const Epetra_MultiVector & Br, const Epetra_MultiVector & Bi){
TEUCHOS_TEST_FOR_EXCEPT(!A0.RowMatrixRowMap().SameAs(A1.RowMatrixRowMap()));
TEUCHOS_TEST_FOR_EXCEPT(!A0.OperatorDomainMap().SameAs(A1.OperatorDomainMap()));
TEUCHOS_TEST_FOR_EXCEPT(!A0.OperatorRangeMap().SameAs(A1.OperatorRangeMap()));
TEUCHOS_TEST_FOR_EXCEPT(!A0.OperatorDomainMap().SameAs(Xr.Map()));
TEUCHOS_TEST_FOR_EXCEPT(!A0.OperatorRangeMap().SameAs(Br.Map()));
TEUCHOS_TEST_FOR_EXCEPT(!A0.OperatorDomainMap().SameAs(Xi.Map()));
TEUCHOS_TEST_FOR_EXCEPT(!A0.OperatorRangeMap().SameAs(Bi.Map()));
// Test number of vectors also
TEUCHOS_TEST_FOR_EXCEPT(Xr.NumVectors()!=Xi.NumVectors());
TEUCHOS_TEST_FOR_EXCEPT(Xr.NumVectors()!=Br.NumVectors());
TEUCHOS_TEST_FOR_EXCEPT(Xr.NumVectors()!=Bi.NumVectors());
return(0);
}
void EpetraExt::scaleModelFuncFirstDerivOp(
const Epetra_Vector *invVarScaling,
const Epetra_Vector *fwdFuncScaling,
Epetra_Operator *funcDerivOp,
bool *didScaling
)
{
TEUCHOS_TEST_FOR_EXCEPT(0==funcDerivOp);
TEUCHOS_TEST_FOR_EXCEPT(0==didScaling);
*didScaling = false; // Assume not scaled to start
Epetra_RowMatrix *funcDerivRowMatrix
= dynamic_cast<Epetra_RowMatrix*>(funcDerivOp);
if (funcDerivRowMatrix) {
if (fwdFuncScaling)
funcDerivRowMatrix->LeftScale(*fwdFuncScaling);
if (invVarScaling)
funcDerivRowMatrix->RightScale(*invVarScaling);
*didScaling = true;
// Note that above I do the func scaling before the var scaling since that
// is the same order it was done for W in Thyra::EpetraModelEvaluator
}
}
// ============================================================================
void EpetraExt::XMLWriter::
Write(const std::string& Label, const Epetra_RowMatrix& Matrix)
{
TEUCHOS_TEST_FOR_EXCEPTION(IsOpen_ == false, std::logic_error,
"No file has been opened");
int Rows = Matrix.NumGlobalRows();
int Cols = Matrix.NumGlobalRows();
int Nonzeros = Matrix.NumGlobalNonzeros();
if (Comm_.MyPID() == 0)
{
std::ofstream of(FileName_.c_str(), std::ios::app);
of << "<PointMatrix Label=\"" << Label << '"'
<< " Rows=\"" << Rows << '"'
<< " Columns=\"" << Cols<< '"'
<< " Nonzeros=\"" << Nonzeros << '"'
<< " Type=\"double\" StartingIndex=\"0\">" << std::endl;
}
int Length = Matrix.MaxNumEntries();
std::vector<int> Indices(Length);
std::vector<double> Values(Length);
for (int iproc = 0; iproc < Comm_.NumProc(); iproc++)
{
if (iproc == Comm_.MyPID())
{
std::ofstream of(FileName_.c_str(), std::ios::app);
of.precision(15);
for (int i = 0; i < Matrix.NumMyRows(); ++i)
{
int NumMyEntries;
Matrix.ExtractMyRowCopy(i, Length, NumMyEntries, &Values[0], &Indices[0]);
int GRID = Matrix.RowMatrixRowMap().GID(i);
for (int j = 0; j < NumMyEntries; ++j)
of << GRID << " " << Matrix.RowMatrixColMap().GID(Indices[j])
<< " " << std::setiosflags(std::ios::scientific) << Values[j] << std::endl;
}
of.close();
}
Comm_.Barrier();
}
if (Comm_.MyPID() == 0)
{
std::ofstream of(FileName_.c_str(), std::ios::app);
of << "</PointMatrix>" << std::endl;
of.close();
}
}
void BlockCrsMatrix::TSumIntoBlock(double alpha, const Epetra_RowMatrix & BaseMatrix, const int_type Row, const int_type Col)
{
std::vector<int_type>& RowIndices_ = TRowIndices<int_type>();
std::vector< std::vector<int_type> >& RowStencil_ = TRowStencil<int_type>();
int_type RowOffset = RowIndices_[(std::size_t)Row] * ROffset_;
int_type ColOffset = (RowIndices_[(std::size_t)Row] + RowStencil_[(std::size_t)Row][(std::size_t)Col]) * COffset_;
// const Epetra_CrsGraph & BaseGraph = BaseMatrix.Graph();
const Epetra_BlockMap & BaseMap = BaseMatrix.RowMatrixRowMap();
const Epetra_BlockMap & BaseColMap = BaseMatrix.RowMatrixColMap();
// This routine copies entries of a BaseMatrix into big BlockCrsMatrix
// It performs the following operation on the global IDs row-by-row
// this->val[i+rowOffset][j+ColOffset] = BaseMatrix.val[i][j]
int MaxIndices = BaseMatrix.MaxNumEntries();
vector<int> Indices_local(MaxIndices);
vector<int_type> Indices_global(MaxIndices);
vector<double> Values(MaxIndices);
int NumIndices;
int ierr=0;
for (int i=0; i<BaseMap.NumMyElements(); i++) {
BaseMatrix.ExtractMyRowCopy( i, MaxIndices, NumIndices, &Values[0], &Indices_local[0] );
// Convert to BlockMatrix Global numbering scheme
for( int l = 0; l < NumIndices; ++l ) {
Indices_global[l] = ColOffset + (int_type) BaseColMap.GID64(Indices_local[l]);
Values[l] *= alpha;
}
int_type BaseRow = (int_type) BaseMap.GID64(i);
ierr = this->SumIntoGlobalValues(BaseRow + RowOffset, NumIndices, &Values[0], &Indices_global[0]);
if (ierr != 0) std::cout << "WARNING BlockCrsMatrix::SumIntoBlock SumIntoGlobalValues err = " << ierr <<
"\n\t Row " << BaseRow + RowOffset << "Col start" << Indices_global[0] << std::endl;
}
}
int RowMatrixToMatrixMarketFile( const char *filename, const Epetra_RowMatrix & A,
const char * matrixName,
const char *matrixDescription,
bool writeHeader) {
long long M = A.NumGlobalRows64();
long long N = A.NumGlobalCols64();
long long nz = A.NumGlobalNonzeros64();
FILE * handle = 0;
if (A.RowMatrixRowMap().Comm().MyPID()==0) { // Only PE 0 does this section
handle = fopen(filename,"w");
if (!handle) {EPETRA_CHK_ERR(-1);}
MM_typecode matcode;
mm_initialize_typecode(&matcode);
mm_set_matrix(&matcode);
mm_set_coordinate(&matcode);
mm_set_real(&matcode);
if (writeHeader==true) { // Only write header if requested (true by default)
if (mm_write_banner(handle, matcode)!=0) {EPETRA_CHK_ERR(-1);}
if (matrixName!=0) fprintf(handle, "%% \n%% %s\n", matrixName);
if (matrixDescription!=0) fprintf(handle, "%% %s\n%% \n", matrixDescription);
if (mm_write_mtx_crd_size(handle, M, N, nz)!=0) {EPETRA_CHK_ERR(-1);}
}
}
if (RowMatrixToHandle(handle, A)!=0) {EPETRA_CHK_ERR(-1);}// Everybody calls this routine
if (A.RowMatrixRowMap().Comm().MyPID()==0) // Only PE 0 opened a file
if (fclose(handle)!=0) {EPETRA_CHK_ERR(-1);}
return(0);
}
int SchwarzSolver::solve()
{
// compute some statistics for the original problem
double condest = -1;
Epetra_LinearProblem problem(_stiffnessMatrix.get(), _lhs.get(), _rhs.get());
AztecOO solverForConditionEstimate(problem);
solverForConditionEstimate.SetAztecOption(AZ_solver, AZ_cg_condnum);
solverForConditionEstimate.ConstructPreconditioner(condest);
Epetra_RowMatrix *A = problem.GetMatrix();
double norminf = A->NormInf();
double normone = A->NormOne();
if (_printToConsole)
{
cout << "\n Inf-norm of stiffness matrix before scaling = " << norminf;
cout << "\n One-norm of stiffness matrix before scaling = " << normone << endl << endl;
cout << "Condition number estimate: " << condest << endl;
}
AztecOO solver(problem);
int otherRows = A->NumGlobalRows() - A->NumMyRows();
int overlapLevel = std::min(otherRows,_overlapLevel);
solver.SetAztecOption(AZ_precond, AZ_dom_decomp); // additive schwarz
solver.SetAztecOption(AZ_overlap, overlapLevel); // level of overlap for schwarz
solver.SetAztecOption(AZ_type_overlap, AZ_symmetric);
solver.SetAztecOption(AZ_solver, AZ_cg_condnum); // more expensive than AZ_cg, but allows estimate of condition #
solver.SetAztecOption(AZ_subdomain_solve, AZ_ilut); // TODO: look these up (copied from example)
solver.SetAztecParam(AZ_ilut_fill, 1.0); // TODO: look these up (copied from example)
solver.SetAztecParam(AZ_drop, 0.0); // TODO: look these up (copied from example)
int solveResult = solver.Iterate(_maxIters,_tol);
// int solveResult = solver.AdaptiveIterate(_maxIters,1,_tol); // an experiment (was Iterate())
norminf = A->NormInf();
normone = A->NormOne();
condest = solver.Condest();
int numIters = solver.NumIters();
if (_printToConsole)
{
cout << "\n Inf-norm of stiffness matrix after scaling = " << norminf;
cout << "\n One-norm of stiffness matrix after scaling = " << normone << endl << endl;
cout << "Condition number estimate: " << condest << endl;
cout << "Num iterations: " << numIters << endl;
}
return solveResult;
}
// ======================================================================
int GetGlobalAggregates(Epetra_RowMatrix& A, Teuchos::ParameterList& List,
double* thisns, Epetra_IntVector& aggrinfo)
{
int naggregates = GetAggregates(A,List,thisns,aggrinfo);
const Epetra_Comm& comm = A.Comm();
std::vector<int> local(comm.NumProc());
std::vector<int> global(comm.NumProc());
for (int i=0; i<comm.NumProc(); ++i) local[i] = 0;
local[comm.MyPID()] = naggregates;
comm.SumAll(&local[0],&global[0],comm.NumProc());
int offset = 0;
for (int i=0; i<comm.MyPID(); ++i) offset += global[i];
for (int i=0; i<aggrinfo.MyLength(); ++i)
if (aggrinfo[i]<naggregates) aggrinfo[i] += offset;
else aggrinfo[i] = -1;
return naggregates;
}
static int make_my_A(const Epetra_RowMatrix &matrix, int *myA, const Epetra_Comm &comm)
{
int me = comm.MyPID();
const Epetra_Map &rowmap = matrix.RowMatrixRowMap();
const Epetra_Map &colmap = matrix.RowMatrixColMap();
int myRows = matrix.NumMyRows();
int numRows = matrix.NumGlobalRows();
int numCols = matrix.NumGlobalCols();
int base = rowmap.IndexBase();
int maxRow = matrix.MaxNumEntries();
memset(myA, 0, sizeof(int) * numRows * numCols);
int *myIndices = new int [maxRow];
double *tmp = new double [maxRow];
int rowLen = 0;
for (int i=0; i< myRows; i++){
int rc = matrix.ExtractMyRowCopy(i, maxRow, rowLen, tmp, myIndices);
if (rc){
if (me == 0){
std::cout << "Error in make_my_A" << std::endl;
}
return 1;
}
int *row = myA + (numCols * (rowmap.GID(i) - base));
for (int j=0; j < rowLen; j++){
int colGID = colmap.GID(myIndices[j]);
row[colGID - base] = me + 1;
}
}
if (maxRow){
delete [] myIndices;
delete [] tmp;
}
return 0;
}
//============================================================================
// very simple debugging function that prints on screen the structure
// of the input matrix.
void Ifpack_PrintSparsity_Simple(const Epetra_RowMatrix& A)
{
int MaxEntries = A.MaxNumEntries();
std::vector<int> Indices(MaxEntries);
std::vector<double> Values(MaxEntries);
std::vector<bool> FullRow(A.NumMyRows());
cout << "+-";
for (int j = 0 ; j < A.NumMyRows() ; ++j)
cout << '-';
cout << "-+" << endl;
for (int i = 0 ; i < A.NumMyRows() ; ++i) {
int Length;
A.ExtractMyRowCopy(i,MaxEntries,Length,
&Values[0], &Indices[0]);
for (int j = 0 ; j < A.NumMyRows() ; ++j)
FullRow[j] = false;
for (int j = 0 ; j < Length ; ++j) {
FullRow[Indices[j]] = true;
}
cout << "| ";
for (int j = 0 ; j < A.NumMyRows() ; ++j) {
if (FullRow[j])
cout << '*';
else
cout << ' ';
}
cout << " |" << endl;
}
cout << "+-";
for (int j = 0 ; j < A.NumMyRows() ; ++j)
cout << '-';
cout << "-+" << endl << endl;
}
//============================================================================
int Ifpack_PrintResidual(const int iter, const Epetra_RowMatrix& A,
const Epetra_MultiVector& X, const Epetra_MultiVector&Y)
{
Epetra_MultiVector RHS(X);
std::vector<double> Norm2;
Norm2.resize(X.NumVectors());
IFPACK_CHK_ERR(A.Multiply(false,X,RHS));
RHS.Update(1.0, Y, -1.0);
RHS.Norm2(&Norm2[0]);
if (X.Comm().MyPID() == 0) {
cout << "***** iter: " << iter << ": ||Ax - b||_2 = "
<< Norm2[0] << endl;
}
return(0);
}
void
NOX::Epetra::DebugTools::writeMatrix( std::string baseName, const Epetra_RowMatrix & mat, FORMAT_TYPE outFormat )
{
if( ASCII == outFormat )
{
// We can only Print a CrsMatrix
const Epetra_CrsMatrix * crsMat = dynamic_cast<const Epetra_CrsMatrix *>(&mat);
if( crsMat )
crsMat->Print( std::cout );
else
{
std::string msg = "Could not cast incoming Epetra_RowMatrix to Epetra_CrsMatrix.";
throw msg;
}
}
else
{
std::string fileName = baseName + "_matrix";
EpetraExt::RowMatrixToMatrixMarketFile(fileName.c_str(), mat);
fileName = baseName + "_map";
EpetraExt::BlockMapToMatrixMarketFile(fileName.c_str(), mat.Map());
}
}
