//EpetraCrsMatrix_To_TpetraCrsMatrix: copies Epetra_CrsMatrix to its analogous Tpetra_CrsMatrix
Teuchos::RCP<Tpetra_CrsMatrix> Petra::EpetraCrsMatrix_To_TpetraCrsMatrix(const Epetra_CrsMatrix& epetraCrsMatrix_,
const Teuchos::RCP<const Teuchos::Comm<int> >& commT_)
{
//get row map of Epetra::CrsMatrix & convert to Tpetra::Map
auto tpetraRowMap_ = EpetraMap_To_TpetraMap(epetraCrsMatrix_.RowMap(), commT_);
//get col map of Epetra::CrsMatrix & convert to Tpetra::Map
auto tpetraColMap_ = EpetraMap_To_TpetraMap(epetraCrsMatrix_.ColMap(), commT_);
//get CrsGraph of Epetra::CrsMatrix & convert to Tpetra::CrsGraph
const Epetra_CrsGraph epetraCrsGraph_ = epetraCrsMatrix_.Graph();
std::size_t maxEntries = epetraCrsGraph_.GlobalMaxNumIndices();
Teuchos::RCP<Tpetra_CrsGraph> tpetraCrsGraph_ = Teuchos::rcp(new Tpetra_CrsGraph(tpetraRowMap_, tpetraColMap_, maxEntries));
for (LO i=0; i<epetraCrsGraph_.NumMyRows(); i++) {
LO NumEntries; LO *Indices;
epetraCrsGraph_.ExtractMyRowView(i, NumEntries, Indices);
tpetraCrsGraph_->insertLocalIndices(i, NumEntries, Indices);
}
tpetraCrsGraph_->fillComplete();
//convert Epetra::CrsMatrix to Tpetra::CrsMatrix, after creating Tpetra::CrsMatrix based on above Tpetra::CrsGraph
Teuchos::RCP<Tpetra_CrsMatrix> tpetraCrsMatrix_ = Teuchos::rcp(new Tpetra_CrsMatrix(tpetraCrsGraph_));
tpetraCrsMatrix_->setAllToScalar(0.0);
for (LO i=0; i<epetraCrsMatrix_.NumMyRows(); i++) {
LO NumEntries; LO *Indices; ST *Values;
epetraCrsMatrix_.ExtractMyRowView(i, NumEntries, Values, Indices);
tpetraCrsMatrix_->replaceLocalValues(i, NumEntries, Values, Indices);
}
tpetraCrsMatrix_->fillComplete();
return tpetraCrsMatrix_;
}
//=========================================================================
bool EpetraExt::RowMatrix_Transpose::fwd()
{
int i, j, NumIndices, err;
Epetra_CrsMatrix * OrigCrsMatrix = dynamic_cast<Epetra_CrsMatrix*>(origObj_);
// Now copy values and global indices into newly create transpose storage
for (i=0;i<NumMyCols_; i++) TransNumNz_[i] = 0; // Reset transpose NumNz counter
for (i=0; i<NumMyRows_; i++)
{
if(OrigMatrixIsCrsMatrix_)
err = OrigCrsMatrix->ExtractMyRowView(i, NumIndices, Values_, Indices_);
else
err = origObj_->ExtractMyRowCopy(i, MaxNumEntries_, NumIndices, Values_, Indices_);
if (err != 0) {
std::cerr << "ExtractMyRowCopy/View failed."<<std::endl;
throw err;
}
int ii = origObj_->RowMatrixRowMap().GID(i);
for (j=0; j<NumIndices; j++)
{
int TransRow = Indices_[j];
int loc = TransNumNz_[TransRow];
TransIndices_[TransRow][loc] = ii;
TransValues_[TransRow][loc] = Values_[j];
++TransNumNz_[TransRow]; // increment counter into current transpose row
}
}
// Build Transpose matrix with some rows being shared across processors.
// We will use a view here since the matrix will not be used for anything else
const Epetra_Map & TransMap = origObj_->RowMatrixColMap();
Epetra_CrsMatrix TempTransA1(View, TransMap, TransNumNz_);
TransMap.MyGlobalElements(TransMyGlobalEquations_);
for (i=0; i<NumMyCols_; i++)
EPETRA_CHK_ERR(TempTransA1.InsertGlobalValues(TransMyGlobalEquations_[i],
TransNumNz_[i], TransValues_[i], TransIndices_[i]));
// Note: The following call to FillComplete is currently necessary because
// some global constants that are needed by the Export () are computed in this routine
EPETRA_CHK_ERR(TempTransA1.FillComplete(false));
// Now that transpose matrix with shared rows is entered, update values of target transpose matrix
TransposeMatrix_->PutScalar(0.0); // Zero out all values of the matrix
EPETRA_CHK_ERR(TransposeMatrix_->Export(TempTransA1, *TransposeExporter_, Add));
return(0);
}
// ======================================================================
inline void Apply_BCsToMatrixRowsAndColumns(const int *dirichletRows, int numBCRows,const Epetra_IntVector &dirichletColumns,const Epetra_CrsMatrix & Matrix){
/* This function zeros out rows & columns of Matrix.
Comments: The graph of Matrix is unchanged.
*/
// Nuke the rows
for(int i=0;i<numBCRows;i++){
int numEntries, *cols;
double *vals;
Matrix.ExtractMyRowView(dirichletRows[i],numEntries,vals,cols);
for (int j=0; j<numEntries; j++) vals[j]=0.0;
}/*end for*/
// Nuke the columns
for (int i=0; i < Matrix.NumMyRows(); i++) {
int numEntries;
double *vals;
int *cols;
Matrix.ExtractMyRowView(i,numEntries,vals,cols);
for (int j=0; j < numEntries; j++) {
if (dirichletColumns[ cols[j] ] > 0) vals[j] = 0.0;
}/*end for*/
}/*end for*/
}/* end Apply_BCsToMatrixColumns */
/*----------------------------------------------------------------------*
| m.gee 11/05|
*----------------------------------------------------------------------*/
bool ML_NOX::Print_Epetra_CrsMatrix(Epetra_CrsMatrix& matrix)
{
for (int i=0; i<matrix.NumMyRows(); ++i)
{
printf("Lrow %5d: ",i); fflush(stdout);
int numentries;
int* indices;
double* values;
int err = matrix.ExtractMyRowView(i,numentries,values,indices);
for (int j=0; j<numentries; ++j)
printf("%5d %10.3e ",indices[j],values[j]);
printf("\n"); fflush(stdout);
}
return true;
}
void
BroydenOperator::replaceBroydenMatrixValues( const Epetra_CrsMatrix & mat)
{
double * values ;
int * indices ;
int numEntries ;
int ierr ;
for( int row = 0; row < mat.NumMyRows(); ++row)
{
ierr = mat.ExtractMyRowView(row, numEntries, values, indices);
ierr += crsMatrix->ReplaceGlobalValues(row, numEntries, values, indices);
if( ierr )
{
cout << "ERROR (" << ierr << ") : "
<< "NOX::Epetra::BroydenOperator::replaceBroydenMatrixValues(...)"
<< " - Extract or Replace values error for row --> "
<< row << endl;
throw "NOX Broyden Operator Error";
}
}
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void applyBoundaryConditions(const double& value,
const Epetra_Vector& x, Epetra_CrsMatrix& Jac,
Epetra_Vector& f, const MeshBuilder mb)
{
// This function assumes a serial run. It will not check process rank.
// Assumes two equations.
// Left edge includes global nodes 0 and 1, dofs 0,1,2,3
int num_nonzero_entries_in_row = 0;
int* row_indices;
double* row_values;
int num_eq = 2;
const std::vector<int>& left_nodes = mb.leftNodeSetGlobalIds();
for (std::size_t node = 0; node < left_nodes.size(); ++node) {
for (int eq = 0; eq < num_eq; ++eq) {
int lid = Jac.RowMap().LID(left_nodes[node] * num_eq + eq);
Jac.ExtractMyRowView(lid, num_nonzero_entries_in_row, row_values,
row_indices);
for (int col=0; col < num_nonzero_entries_in_row; ++col) {
if (row_indices[col] == lid)
row_values[col] = 1.0;
else
row_values[col] = 0.0;
}
f[lid] = value - x[lid];
}
}
}
int
NOX::Epetra::TestCompare::testCrsMatrices(
const Epetra_CrsMatrix& mat ,
const Epetra_CrsMatrix& mat_expected ,
double rtol, double atol ,
const std::string& name ,
bool enforceStructure )
{
if (utils.isPrintType(NOX::Utils::TestDetails))
os << std::endl << "\tChecking " << name << ": ";
int passed = 0;
if( !mat_expected.RowMap().SameAs( mat.RowMap() ) )
{
passed = 1;
os << "Failed." << std::endl;
os << std::endl << "\t\tRow maps are not compatible." << std::endl;
return passed;
}
int numEntries1, numEntries2 ;
int * columns1 , * columns2 ;
double * values1 , * values2 ;
int chkSize = 0 ;
double maxVal = 0.0 ;
double infNorm = 0.0 ;
for( int row = 0; row < mat_expected.NumMyRows(); ++row )
{
mat_expected.ExtractMyRowView(row, numEntries1, values1, columns1);
mat.ExtractMyRowView (row, numEntries2, values2, columns2);
if( numEntries1 != numEntries2 )
{
if( enforceStructure )
{
os << std::endl << "\t\t\t";
}
else
os << std::endl << "\t\tWARNING: ";
os << "Matrix size is incompatible for Local Row " << row
<< "\n\t\t\t..... expected " << numEntries1 << " columns, found " << numEntries2
<< std::endl;
chkSize = 1;
}
mat.Comm().SumAll( &chkSize, &passed, 1 );
if( 0 != passed )
{
if( enforceStructure )
{
os << "Failed." << std::endl;
return passed;
}
else
{
chkSize = 0;
passed = 0;
}
}
// Comapre column indices and values
int baseCol = 0 ;
int testCol = 0 ;
int chkCol = 0 ;
double baseVal = 0.0 ;
double testVal = 0.0 ;
double chkVal = 0.0 ;
for( int col = 0; col < numEntries1; ++col )
{
baseCol = columns1[col];
testCol = columns2[col];
baseVal = values1 [col];
testVal = values2 [col];
if( baseCol != testCol )
{
if( enforceStructure )
{
os << std::endl << "\t\t\t";
}
else
os << std::endl << "\t\tWARNING: ";
os << "Column index for Local Row " << row << " is incompatible."
<< "\n\t\t\t..... expected " << baseCol << " , found " << testCol << std::endl;
chkCol = 1;
}
mat.Comm().SumAll( &chkCol, &passed, 1 );
if( 0 != passed )
{
if( enforceStructure )
{
os << "Failed." << std::endl;
return passed;
}
else
{
chkCol = 0;
passed = 0;
continue; // skip pvalue check
}
}
chkVal = fabs( testVal - baseVal ) / (atol + rtol * fabs(baseVal));
mat.Comm().MaxAll( &chkVal, &maxVal, 1 );
if( maxVal > infNorm )
infNorm = maxVal;
if( 1 < maxVal )
break;
}
if( 1 < maxVal )
break;
}
if( 1 < maxVal )
passed = 1; // false by convention in NOX::TestCompare
else
passed = 0; // true by convention in NOX::TestCompare
if (utils.isPrintType(NOX::Utils::TestDetails))
{
if( 0 == passed)
os << "Passed." << std::endl;
else
os << "Failed." << std::endl;
os << "\t\tComputed norm: " << utils.sciformat(infNorm)
<< std::endl
<< "\t\tRelative Tolerance: " << utils.sciformat(rtol)
<< std::endl
<< "\t\tAbsolute Tolerance: " << utils.sciformat(rtol)
<< std::endl;
}
return passed;
}
//=========================================================================
RowMatrix_Transpose::NewTypeRef
RowMatrix_Transpose::
operator()( OriginalTypeRef orig )
{
origObj_ = &orig;
int i, j, err;
if( !TransposeRowMap_ )
{
if( IgnoreNonLocalCols_ )
TransposeRowMap_ = (Epetra_Map *) &(orig.OperatorRangeMap()); // Should be replaced with refcount =
else
TransposeRowMap_ = (Epetra_Map *) &(orig.OperatorDomainMap()); // Should be replaced with refcount =
}
// This routine will work for any RowMatrix object, but will attempt cast the matrix to a CrsMatrix if
// possible (because we can then use a View of the matrix and graph, which is much cheaper).
// First get the local indices to count how many nonzeros will be in the
// transpose graph on each processor
Epetra_CrsMatrix * OrigCrsMatrix = dynamic_cast<Epetra_CrsMatrix*>(&orig);
OrigMatrixIsCrsMatrix_ = (OrigCrsMatrix!=0); // If this pointer is non-zero, the cast to CrsMatrix worked
NumMyRows_ = orig.NumMyRows();
NumMyCols_ = orig.NumMyCols();
TransNumNz_ = new int[NumMyCols_];
TransIndices_ = new int*[NumMyCols_];
TransValues_ = new double*[NumMyCols_];
TransMyGlobalEquations_ = new int[NumMyCols_];
int NumIndices;
if (OrigMatrixIsCrsMatrix_)
{
const Epetra_CrsGraph & OrigGraph = OrigCrsMatrix->Graph(); // Get matrix graph
for (i=0;i<NumMyCols_; i++) TransNumNz_[i] = 0;
for (i=0; i<NumMyRows_; i++)
{
err = OrigGraph.ExtractMyRowView(i, NumIndices, Indices_); // Get view of ith row
if (err != 0) throw OrigGraph.ReportError("ExtractMyRowView failed",err);
for (j=0; j<NumIndices; j++) ++TransNumNz_[Indices_[j]];
}
}
else // Original is not a CrsMatrix
{
MaxNumEntries_ = 0;
int NumEntries;
for (i=0; i<NumMyRows_; i++)
{
orig.NumMyRowEntries(i, NumEntries);
MaxNumEntries_ = EPETRA_MAX(MaxNumEntries_, NumEntries);
}
Indices_ = new int[MaxNumEntries_];
Values_ = new double[MaxNumEntries_];
for (i=0;i<NumMyCols_; i++) TransNumNz_[i] = 0;
for (i=0; i<NumMyRows_; i++)
{
err = orig.ExtractMyRowCopy(i, MaxNumEntries_, NumIndices, Values_, Indices_);
if (err != 0) {
std::cerr << "ExtractMyRowCopy failed."<<std::endl;
throw err;
}
for (j=0; j<NumIndices; j++) ++TransNumNz_[Indices_[j]];
}
}
// Most of remaining code is common to both cases
for(i=0; i<NumMyCols_; i++)
{
NumIndices = TransNumNz_[i];
if (NumIndices>0)
{
TransIndices_[i] = new int[NumIndices];
TransValues_[i] = new double[NumIndices];
}
}
// Now copy values and global indices into newly create transpose storage
for (i=0;i<NumMyCols_; i++) TransNumNz_[i] = 0; // Reset transpose NumNz counter
for (i=0; i<NumMyRows_; i++)
{
if (OrigMatrixIsCrsMatrix_)
err = OrigCrsMatrix->ExtractMyRowView(i, NumIndices, Values_, Indices_);
else
err = orig.ExtractMyRowCopy(i, MaxNumEntries_, NumIndices, Values_, Indices_);
if (err != 0) {
std::cerr << "ExtractMyRowCopy failed."<<std::endl;
throw err;
}
int ii = orig.RowMatrixRowMap().GID(i);
for (j=0; j<NumIndices; j++)
{
int TransRow = Indices_[j];
int loc = TransNumNz_[TransRow];
TransIndices_[TransRow][loc] = ii;
TransValues_[TransRow][loc] = Values_[j];
++TransNumNz_[TransRow]; // increment counter into current transpose row
}
}
// Build Transpose matrix with some rows being shared across processors.
// We will use a view here since the matrix will not be used for anything else
const Epetra_Map & TransMap = orig.RowMatrixColMap();
Epetra_CrsMatrix TempTransA1(View, TransMap, TransNumNz_);
TransMap.MyGlobalElements(TransMyGlobalEquations_);
for (i=0; i<NumMyCols_; i++) {
err = TempTransA1.InsertGlobalValues(TransMyGlobalEquations_[i],
TransNumNz_[i], TransValues_[i], TransIndices_[i]);
if (err < 0) throw TempTransA1.ReportError("InsertGlobalValues failed.",err);
}
// Note: The following call to FillComplete is currently necessary because
// some global constants that are needed by the Export () are computed in this routine
err = TempTransA1.FillComplete(orig.OperatorRangeMap(),*TransposeRowMap_, false);
if (err != 0) {
throw TempTransA1.ReportError("FillComplete failed.",err);
}
// Now that transpose matrix with shared rows is entered, create a new matrix that will
// get the transpose with uniquely owned rows (using the same row distribution as A).
if( IgnoreNonLocalCols_ )
TransposeMatrix_ = new Epetra_CrsMatrix(Copy, *TransposeRowMap_, *TransposeRowMap_, 0);
else
TransposeMatrix_ = new Epetra_CrsMatrix(Copy, *TransposeRowMap_,0);
// Create an Export object that will move TempTransA around
TransposeExporter_ = new Epetra_Export(TransMap, *TransposeRowMap_);
err = TransposeMatrix_->Export(TempTransA1, *TransposeExporter_, Add);
if (err != 0) throw TransposeMatrix_->ReportError("Export failed.",err);
err = TransposeMatrix_->FillComplete(orig.OperatorRangeMap(),*TransposeRowMap_);
if (err != 0) throw TransposeMatrix_->ReportError("FillComplete failed.",err);
if (MakeDataContiguous_) {
err = TransposeMatrix_->MakeDataContiguous();
if (err != 0) throw TransposeMatrix_->ReportError("MakeDataContiguous failed.",err);
}
newObj_ = TransposeMatrix_;
return *newObj_;
}
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);
}
bool FiniteDifferenceColoringWithUpdate::differenceProbe(const Epetra_Vector& x, Epetra_CrsMatrix& jac,const Epetra_MapColoring& colors){
// Allocate space for perturbation, get column version of x for scaling
Epetra_Vector xp(x);
Epetra_Vector *xcol;
int N=jac.NumMyRows();
if(jac.ColMap().SameAs(x.Map()))
xcol=const_cast<Epetra_Vector*>(&x);
else{
xcol=new Epetra_Vector(jac.ColMap(),true);//zeros out by default
xcol->Import(x,*jac.Importer(),InsertAdd);
}
// Counters for probing diagnostics
double tmp,probing_error_lower_bound=0.0,jc_norm=0.0;
// Grab coloring info (being very careful to ignore color 0)
int Ncolors=colors.MaxNumColors()+1;
int num_c0_global,num_c0_local=colors.NumElementsWithColor(0);
colors.Comm().MaxAll(&num_c0_local,&num_c0_global,1);
if(num_c0_global>0) Ncolors--;
if(Ncolors==0) return false;
// Pointers for Matrix Info
int entries, *indices;
double *values;
// NTS: Fix me
if ( diffType == Centered ) exit(1);
double scaleFactor = 1.0;
if ( diffType == Backward )
scaleFactor = -1.0;
// Compute RHS at initial solution
computeF(x,fo,NOX::Epetra::Interface::Required::FD_Res);
/* Probing, vector by vector since computeF does not have a MultiVector interface */
// Assume that anything with Color 0 gets ignored.
for(int j=1;j<Ncolors;j++){
xp=x;
for(int i=0;i<N;i++){
if(colors[i]==j)
xp[i] += scaleFactor*(alpha*abs(x[i])+beta);
}
computeF(xp, fp, NOX::Epetra::Interface::Required::FD_Res);
// Do the subtraction to estimate the Jacobian (w/o including step length)
Jc.Update(1.0, fp, -1.0, fo, 0.0);
// Relative error in probing
if(use_probing_diags){
Jc.Norm2(&tmp);
jc_norm+=tmp*tmp;
}
for(int i=0;i<N;i++){
// Skip for uncolored row/columns, else update entries
if(colors[i]==0) continue;
jac.ExtractMyRowView(i,entries,values,indices);
for(int k=0;k<jac.NumMyEntries(i);k++){
if(colors[indices[k]]==j){
values[k]=Jc[i] / (scaleFactor*(alpha*abs((*xcol)[indices[k]])+beta));
// If probing diagnostics are on, zero out the entries as they are used
if(use_probing_diags) Jc[i]=0.0;
break;// Only one value per row...
}
}
}
if(use_probing_diags){
Jc.Norm2(&tmp);
probing_error_lower_bound+=tmp*tmp;
}
}
// If diagnostics are requested, output Frobenius norm lower bound
if(use_probing_diags && !x.Comm().MyPID()) printf("Probing Error Lower Bound (Frobenius) abs = %6.4e rel = %6.4e\n",sqrt(probing_error_lower_bound),sqrt(probing_error_lower_bound)/sqrt(jc_norm));
// Cleanup
if(!jac.ColMap().SameAs(x.Map()))
delete xcol;
return true;
}
void
Stokhos::AdaptivityManager::
sumInOperator(Epetra_CrsMatrix & A,const Stokhos::AdaptivityManager::Sparse3TensorHash & Cijk,int k,const Epetra_CrsMatrix & J_k) const
{
TEUCHOS_ASSERT(J_k.NumMyRows() == int(sg_basis_row_dof_.size()));
TEUCHOS_ASSERT(J_k.NumMyCols() == int(sg_basis_col_dof_.size()));
const Teuchos::Array<double> & normValues = sg_master_basis_->norm_squared();
// loop over deterministic rows
for(int localM=0;localM<J_k.NumMyRows();localM++) {
int m = J_k.GRID(localM);
// grab row basis
Teuchos::RCP<const Stokhos::ProductBasis<int,double> > rowStochBasis
= sg_basis_row_dof_[localM];
// grab row from deterministic system
int d_numEntries;
int * d_Indices;
double * d_Values;
J_k.ExtractMyRowView(localM,d_numEntries,d_Values,d_Indices);
// loop over stochastic degrees of freedom of this row
for(int rb_i=0;rb_i<rowStochBasis->size();rb_i++) {
int i = sg_master_basis_->index(rowStochBasis->term(rb_i));
double normValue = normValues[i]; // sg_master_basis->norm_squared(i);
int sg_m = getGlobalRowId(localM,rb_i);
// we wipe out old values, capacity should gurantee
// we don't allocate more often than neccessary!
std::vector<int> sg_indices;
std::vector<double> sg_values;
// sg_indices.resize(0);
// sg_values.resize(0);
// loop over each column
for(int colInd=0;colInd<d_numEntries;colInd++) {
int localN = d_Indices[colInd]; // grab local deterministic column id
// grab row basis
Teuchos::RCP<const Stokhos::ProductBasis<int,double> > colStochBasis
= sg_basis_col_dof_[localN];
// build values array
for(int cb_j=0;cb_j<colStochBasis->size();cb_j++) {
int j = sg_master_basis_->index(colStochBasis->term(cb_j));
int sg_n = getGlobalColId(localN,cb_j);
double cijk = Cijk.getValue(i,j,k);
// no reason to work it in!
if(cijk==0) continue;
if(scaleOp_)
cijk = cijk/normValue;
sg_indices.push_back(sg_n);
sg_values.push_back(cijk*d_Values[colInd]);
}
}
// add in matrix values
A.SumIntoGlobalValues(sg_m,sg_indices.size(),&sg_values[0],&sg_indices[0]);
}
}
}
//=========================================================================
int Epetra_RowMatrixTransposer::UpdateTransposeValues(Epetra_RowMatrix * MatrixWithNewValues){
int i, j, NumIndices;
if (!TransposeCreated_) EPETRA_CHK_ERR(-1); // Transpose must be already created
// Sanity check of incoming matrix. Perform some tests to see if it is compatible with original input matrix
if (OrigMatrix_!=MatrixWithNewValues) { // Check if pointer of new matrix is same as previous input matrix
OrigMatrix_ = MatrixWithNewValues; // Reset this pointer if not, then check for other attributes
if (NumMyRows_ != OrigMatrix_->NumMyRows() ||
NumMyCols_ != OrigMatrix_->NumMyCols() ||
NumMyRows_ != OrigMatrix_->NumMyRows()) {
EPETRA_CHK_ERR(-2); // New matrix not compatible with previous
}
}
Epetra_CrsMatrix * OrigCrsMatrix = dynamic_cast<Epetra_CrsMatrix *>(MatrixWithNewValues);
OrigMatrixIsCrsMatrix_ = (OrigCrsMatrix!=0); // If this pointer is non-zero, the cast to CrsMatrix worked
// Now copy values and global indices into newly create transpose storage
for (i=0;i<NumMyCols_; i++) TransNumNz_[i] = 0; // Reset transpose NumNz counter
for (i=0; i<NumMyRows_; i++) {
if (OrigMatrixIsCrsMatrix_) {
EPETRA_CHK_ERR(OrigCrsMatrix->ExtractMyRowView(i, NumIndices, Values_, Indices_));
}
else {
EPETRA_CHK_ERR(OrigMatrix_->ExtractMyRowCopy(i, MaxNumEntries_, NumIndices, Values_, Indices_));
}
int ii = OrigMatrix_->RowMatrixRowMap().GID64(i); // FIXME long long
for (j=0; j<NumIndices; j++) {
int TransRow = Indices_[j];
int loc = TransNumNz_[TransRow];
TransIndices_[TransRow][loc] = ii;
TransValues_[TransRow][loc] = Values_[j];
++TransNumNz_[TransRow]; // increment counter into current transpose row
}
}
// Build Transpose matrix with some rows being shared across processors.
// We will use a view here since the matrix will not be used for anything else
const Epetra_Map & TransMap = OrigMatrix_->RowMatrixColMap();
Epetra_CrsMatrix TempTransA1(View, TransMap, TransNumNz_);
TransMap.MyGlobalElements(TransMyGlobalEquations_);
/* Add rows one-at-a-time */
for (i=0; i<NumMyCols_; i++)
{
EPETRA_CHK_ERR(TempTransA1.InsertGlobalValues(TransMyGlobalEquations_[i],
TransNumNz_[i], TransValues_[i], TransIndices_[i]));
}
// Note: The following call to FillComplete is currently necessary because
// some global constants that are needed by the Export () are computed in this routine
const Epetra_Map& domain_map = OrigMatrix_->OperatorDomainMap();
const Epetra_Map& range_map = OrigMatrix_->OperatorRangeMap();
EPETRA_CHK_ERR(TempTransA1.FillComplete(range_map, domain_map, false));
// Now that transpose matrix with shared rows is entered, update values of target transpose matrix
TransposeMatrix_->PutScalar(0.0); // Zero out all values of the matrix
EPETRA_CHK_ERR(TransposeMatrix_->Export(TempTransA1, *TransposeExporter_, Add));
return(0);
}
//=========================================================================
int Epetra_RowMatrixTransposer::CreateTranspose (const bool MakeDataContiguous,
Epetra_CrsMatrix *& TransposeMatrix,
Epetra_Map * TransposeRowMap_in) {
// FIXME long long
int i, j;
if (TransposeCreated_) DeleteData(); // Get rid of existing data first
if (TransposeRowMap_in==0)
TransposeRowMap_ = (Epetra_Map *) &(OrigMatrix_->OperatorDomainMap()); // Should be replaced with refcount =
else
TransposeRowMap_ = TransposeRowMap_in;
// This routine will work for any RowMatrix object, but will attempt cast the matrix to a CrsMatrix if
// possible (because we can then use a View of the matrix and graph, which is much cheaper).
// First get the local indices to count how many nonzeros will be in the
// transpose graph on each processor
Epetra_CrsMatrix * OrigCrsMatrix = dynamic_cast<Epetra_CrsMatrix *>(OrigMatrix_);
OrigMatrixIsCrsMatrix_ = (OrigCrsMatrix!=0); // If this pointer is non-zero, the cast to CrsMatrix worked
NumMyRows_ = OrigMatrix_->NumMyRows();
NumMyCols_ = OrigMatrix_->NumMyCols();
NumMyRows_ = OrigMatrix_->NumMyRows();
TransNumNz_ = new int[NumMyCols_];
TransIndices_ = new int*[NumMyCols_];
TransValues_ = new double*[NumMyCols_];
int NumIndices;
if (OrigMatrixIsCrsMatrix_) {
const Epetra_CrsGraph & OrigGraph = OrigCrsMatrix->Graph(); // Get matrix graph
for (i=0;i<NumMyCols_; i++) TransNumNz_[i] = 0;
for (i=0; i<NumMyRows_; i++) {
EPETRA_CHK_ERR(OrigGraph.ExtractMyRowView(i, NumIndices, Indices_)); // Get view of ith row
for (j=0; j<NumIndices; j++) ++TransNumNz_[Indices_[j]];
}
}
else { // OrigMatrix is not a CrsMatrix
MaxNumEntries_ = 0;
int NumEntries;
for (i=0; i<NumMyRows_; i++) {
OrigMatrix_->NumMyRowEntries(i, NumEntries);
MaxNumEntries_ = EPETRA_MAX(MaxNumEntries_, NumEntries);
}
Indices_ = new int[MaxNumEntries_];
Values_ = new double[MaxNumEntries_];
for (i=0;i<NumMyCols_; i++) TransNumNz_[i] = 0;
for (i=0; i<NumMyRows_; i++) {
// Get ith row
EPETRA_CHK_ERR(OrigMatrix_->ExtractMyRowCopy(i, MaxNumEntries_, NumIndices, Values_, Indices_));
for (j=0; j<NumIndices; j++) ++TransNumNz_[Indices_[j]];
}
}
// Most of remaining code is common to both cases
for(i=0; i<NumMyCols_; i++) {
NumIndices = TransNumNz_[i];
if (NumIndices>0) {
TransIndices_[i] = new int[NumIndices];
TransValues_[i] = new double[NumIndices];
}
}
// Now copy values and global indices into newly created transpose storage
for (i=0;i<NumMyCols_; i++) TransNumNz_[i] = 0; // Reset transpose NumNz counter
for (i=0; i<NumMyRows_; i++) {
if (OrigMatrixIsCrsMatrix_) {
EPETRA_CHK_ERR(OrigCrsMatrix->ExtractMyRowView(i, NumIndices, Values_, Indices_));
}
else {
EPETRA_CHK_ERR(OrigMatrix_->ExtractMyRowCopy(i, MaxNumEntries_, NumIndices, Values_, Indices_));
}
int ii = OrigMatrix_->RowMatrixRowMap().GID64(i); // FIXME long long
for (j=0; j<NumIndices; j++) {
int TransRow = Indices_[j];
int loc = TransNumNz_[TransRow];
TransIndices_[TransRow][loc] = ii;
TransValues_[TransRow][loc] = Values_[j];
++TransNumNz_[TransRow]; // increment counter into current transpose row
}
}
// Build Transpose matrix with some rows being shared across processors.
// We will use a view here since the matrix will not be used for anything else
const Epetra_Map & TransMap = OrigMatrix_->RowMatrixColMap();
Epetra_CrsMatrix TempTransA1(View, TransMap, TransNumNz_);
TransMyGlobalEquations_ = new int[NumMyCols_];
TransMap.MyGlobalElements(TransMyGlobalEquations_);
/* Add rows one-at-a-time */
for (i=0; i<NumMyCols_; i++)
{
EPETRA_CHK_ERR(TempTransA1.InsertGlobalValues(TransMyGlobalEquations_[i],
TransNumNz_[i], TransValues_[i], TransIndices_[i]));
}
// Note: The following call to FillComplete is currently necessary because
// some global constants that are needed by the Export () are computed in this routine
const Epetra_Map& domain_map = OrigMatrix_->OperatorDomainMap();
const Epetra_Map& range_map = OrigMatrix_->OperatorRangeMap();
EPETRA_CHK_ERR(TempTransA1.FillComplete(range_map, domain_map, false));
// Now that transpose matrix with shared rows is entered, create a new matrix that will
// get the transpose with uniquely owned rows (using the same row distribution as A).
TransposeMatrix_ = new Epetra_CrsMatrix(Copy, *TransposeRowMap_,0);
// Create an Export object that will move TempTransA around
TransposeExporter_ = new Epetra_Export(TransMap, *TransposeRowMap_);
EPETRA_CHK_ERR(TransposeMatrix_->Export(TempTransA1, *TransposeExporter_, Add));
EPETRA_CHK_ERR(TransposeMatrix_->FillComplete(range_map, domain_map));
if (MakeDataContiguous) {
EPETRA_CHK_ERR(TransposeMatrix_->MakeDataContiguous());
}
TransposeMatrix = TransposeMatrix_;
TransposeCreated_ = true;
return(0);
}
