//==============================================================================
Ifpack_DiagonalFilter::Ifpack_DiagonalFilter(const Teuchos::RefCountPtr<Epetra_RowMatrix>& Matrix,
double AbsoluteThreshold,
double RelativeThreshold) :
A_(Matrix),
AbsoluteThreshold_(AbsoluteThreshold),
RelativeThreshold_(RelativeThreshold)
{
Epetra_Time Time(Comm());
pos_.resize(NumMyRows());
val_.resize(NumMyRows());
std::vector<int> Indices(MaxNumEntries());
std::vector<double> Values(MaxNumEntries());
int NumEntries;
for (int MyRow = 0 ; MyRow < NumMyRows() ; ++MyRow) {
pos_[MyRow] = -1;
val_[MyRow] = 0.0;
int ierr = A_->ExtractMyRowCopy(MyRow, MaxNumEntries(), NumEntries,
&Values[0], &Indices[0]);
assert (ierr == 0);
for (int i = 0 ; i < NumEntries ; ++i) {
if (Indices[i] == MyRow) {
pos_[MyRow] = i;
val_[MyRow] = Values[i] * (RelativeThreshold_ - 1) +
AbsoluteThreshold_ * EPETRA_SGN(Values[i]);
}
break;
}
}
cout << "TIME = " << Time.ElapsedTime() << endl;
}
//==========================================================================
int Ifpack_CrsIct::InitValues(const Epetra_CrsMatrix & A) {
int ierr = 0;
int i, j;
int NumIn, NumL, NumU;
bool DiagFound;
int NumNonzeroDiags = 0;
Teuchos::RefCountPtr<Epetra_CrsMatrix> OverlapA = Teuchos::rcp( (Epetra_CrsMatrix *) &A_ , false );
if (LevelOverlap_>0) {
EPETRA_CHK_ERR(-1); // Not implemented yet
//OverlapA = 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();
vector<int> InI(MaxNumEntries); // Allocate temp space
vector<int> UI(MaxNumEntries);
vector<double> InV(MaxNumEntries);
vector<double> UV(MaxNumEntries);
double *DV;
ierr = D_->ExtractView(&DV); // Get view of diagonal
// First we copy the user's matrix into diagonal vector and U, regardless of fill level
int NumRows = OverlapA->NumMyRows();
for (i=0; i< NumRows; i++) {
OverlapA->ExtractMyRowCopy(i, MaxNumEntries, NumIn, &InV[0], &InI[0]); // Get Values and Indices
// Split into L and U (we don't assume that indices are ordered).
NumL = 0;
NumU = 0;
DiagFound = false;
for (j=0; j< NumIn; j++) {
int k = InI[j];
if (k==i) {
DiagFound = true;
DV[i] += Rthresh_ * InV[j] + EPETRA_SGN(InV[j]) * Athresh_; // Store perturbed diagonal in Epetra_Vector D_
}
else if (k < 0) return(-1); // Out of range
else if (i<k && k<NumRows) {
UI[NumU] = k;
UV[NumU] = InV[j];
NumU++;
}
}
// Check in things for this row of L and U
if (DiagFound) NumNonzeroDiags++;
if (NumU) U_->InsertMyValues(i, NumU, &UV[0], &UI[0]);
}
U_->FillComplete(A_.OperatorDomainMap(), A_.OperatorRangeMap());
SetValuesInitialized(true);
SetFactored(false);
int ierr1 = 0;
if (NumNonzeroDiags<U_->NumMyRows()) ierr1 = 1;
A_.Comm().MaxAll(&ierr1, &ierr, 1);
EPETRA_CHK_ERR(ierr);
return(0);
}
//==========================================================================
int Ifpack_ICT::Compute()
{
if (!IsInitialized())
IFPACK_CHK_ERR(Initialize());
Time_.ResetStartTime();
IsComputed_ = false;
NumMyRows_ = A_.NumMyRows();
int Length = A_.MaxNumEntries();
vector<int> RowIndices(Length);
vector<double> RowValues(Length);
bool distributed = (Comm().NumProc() > 1)?true:false;
if (distributed)
{
SerialComm_ = Teuchos::rcp(new Epetra_SerialComm);
SerialMap_ = Teuchos::rcp(new Epetra_Map(NumMyRows_, 0, *SerialComm_));
assert (SerialComm_.get() != 0);
assert (SerialMap_.get() != 0);
}
else
SerialMap_ = Teuchos::rcp(const_cast<Epetra_Map*>(&A_.RowMatrixRowMap()), false);
int RowNnz;
#ifdef IFPACK_FLOPCOUNTERS
double flops = 0.0;
#endif
H_ = Teuchos::rcp(new Epetra_CrsMatrix(Copy,*SerialMap_,0));
if (H_.get() == 0)
IFPACK_CHK_ERR(-5); // memory allocation error
// get A(0,0) element and insert it (after sqrt)
IFPACK_CHK_ERR(A_.ExtractMyRowCopy(0,Length,RowNnz,
&RowValues[0],&RowIndices[0]));
// skip off-processor elements
if (distributed)
{
int count = 0;
for (int i = 0 ;i < RowNnz ; ++i)
{
if (RowIndices[i] < NumMyRows_){
RowIndices[count] = RowIndices[i];
RowValues[count] = RowValues[i];
++count;
}
else
continue;
}
RowNnz = count;
}
// modify diagonal
double diag_val = 0.0;
for (int i = 0 ;i < RowNnz ; ++i) {
if (RowIndices[i] == 0) {
double& v = RowValues[i];
diag_val = AbsoluteThreshold() * EPETRA_SGN(v) +
RelativeThreshold() * v;
break;
}
}
diag_val = sqrt(diag_val);
int diag_idx = 0;
EPETRA_CHK_ERR(H_->InsertGlobalValues(0,1,&diag_val, &diag_idx));
// The 10 is just a small constant to limit collisons as the actual keys
// we store are the indices and not integers
// [0..A_.MaxNumEntries()*LevelofFill()].
Ifpack_HashTable Hash( 10 * A_.MaxNumEntries() * LevelOfFill(), 1);
// start factorization for line 1
for (int row_i = 1 ; row_i < NumMyRows_ ; ++row_i) {
// get row `row_i' of the matrix
IFPACK_CHK_ERR(A_.ExtractMyRowCopy(row_i,Length,RowNnz,
&RowValues[0],&RowIndices[0]));
// skip off-processor elements
if (distributed)
{
int count = 0;
for (int i = 0 ;i < RowNnz ; ++i)
{
if (RowIndices[i] < NumMyRows_){
RowIndices[count] = RowIndices[i];
RowValues[count] = RowValues[i];
++count;
}
else
continue;
}
RowNnz = count;
}
// number of nonzeros in this row are defined as the nonzeros
// of the matrix, plus the level of fill
int LOF = (int)(LevelOfFill() * RowNnz);
if (LOF == 0) LOF = 1;
// convert line `row_i' into hash for fast access
Hash.reset();
double h_ii = 0.0;
for (int i = 0 ; i < RowNnz ; ++i) {
if (RowIndices[i] == row_i) {
double& v = RowValues[i];
h_ii = AbsoluteThreshold() * EPETRA_SGN(v) + RelativeThreshold() * v;
}
else if (RowIndices[i] < row_i)
{
Hash.set(RowIndices[i], RowValues[i], true);
}
}
// form element (row_i, col_j)
// I start from the first row that has a nonzero column
// index in row_i.
for (int col_j = RowIndices[0] ; col_j < row_i ; ++col_j) {
double h_ij = 0.0, h_jj = 0.0;
// note: get() returns 0.0 if col_j is not found
h_ij = Hash.get(col_j);
// get pointers to row `col_j'
int* ColIndices;
double* ColValues;
int ColNnz;
H_->ExtractGlobalRowView(col_j, ColNnz, ColValues, ColIndices);
for (int k = 0 ; k < ColNnz ; ++k) {
int col_k = ColIndices[k];
if (col_k == col_j)
h_jj = ColValues[k];
else {
double xxx = Hash.get(col_k);
if (xxx != 0.0)
{
h_ij -= ColValues[k] * xxx;
#ifdef IFPACK_FLOPCOUNTERS
flops += 2.0;
#endif
}
}
}
h_ij /= h_jj;
if (IFPACK_ABS(h_ij) > DropTolerance_)
{
Hash.set(col_j, h_ij);
}
#ifdef IFPACK_FLOPCOUNTERS
// only approx
ComputeFlops_ += 2.0 * flops + 1.0;
#endif
}
int size = Hash.getNumEntries();
vector<double> AbsRow(size);
int count = 0;
// +1 because I use the extra position for diagonal in insert
vector<int> keys(size + 1);
vector<double> values(size + 1);
Hash.arrayify(&keys[0], &values[0]);
for (int i = 0 ; i < size ; ++i)
{
AbsRow[i] = IFPACK_ABS(values[i]);
}
count = size;
double cutoff = 0.0;
if (count > LOF) {
nth_element(AbsRow.begin(), AbsRow.begin() + LOF, AbsRow.begin() + count,
std::greater<double>());
cutoff = AbsRow[LOF];
}
for (int i = 0 ; i < size ; ++i)
{
h_ii -= values[i] * values[i];
}
if (h_ii < 0.0) h_ii = 1e-12;;
h_ii = sqrt(h_ii);
#ifdef IFPACK_FLOPCOUNTERS
// only approx, + 1 == sqrt
ComputeFlops_ += 2 * size + 1;
#endif
double DiscardedElements = 0.0;
count = 0;
for (int i = 0 ; i < size ; ++i)
{
if (IFPACK_ABS(values[i]) > cutoff)
{
values[count] = values[i];
keys[count] = keys[i];
++count;
}
else
DiscardedElements += values[i];
}
if (RelaxValue() != 0.0) {
DiscardedElements *= RelaxValue();
h_ii += DiscardedElements;
}
values[count] = h_ii;
keys[count] = row_i;
++count;
H_->InsertGlobalValues(row_i, count, &(values[0]), (int*)&(keys[0]));
}
IFPACK_CHK_ERR(H_->FillComplete());
#if 0
// to check the complete factorization
Epetra_Vector LHS(Matrix().RowMatrixRowMap());
Epetra_Vector RHS1(Matrix().RowMatrixRowMap());
Epetra_Vector RHS2(Matrix().RowMatrixRowMap());
Epetra_Vector RHS3(Matrix().RowMatrixRowMap());
LHS.Random();
Matrix().Multiply(false,LHS,RHS1);
H_->Multiply(true,LHS,RHS2);
H_->Multiply(false,RHS2,RHS3);
RHS1.Update(-1.0, RHS3, 1.0);
cout << endl;
cout << RHS1;
#endif
int MyNonzeros = H_->NumGlobalNonzeros();
Comm().SumAll(&MyNonzeros, &GlobalNonzeros_, 1);
IsComputed_ = true;
#ifdef IFPACK_FLOPCOUNTERS
double TotalFlops; // sum across all the processors
A_.Comm().SumAll(&flops, &TotalFlops, 1);
ComputeFlops_ += TotalFlops;
#endif
++NumCompute_;
ComputeTime_ += Time_.ElapsedTime();
return(0);
}
int Ifpack_CrsRiluk::InitAllValues(const Epetra_RowMatrix & OverlapA, int MaxNumEntries) {
int ierr = 0;
int i, j;
int NumIn, NumL, NumU;
bool DiagFound;
int NumNonzeroDiags = 0;
vector<int> InI(MaxNumEntries); // Allocate temp space
vector<int> LI(MaxNumEntries);
vector<int> UI(MaxNumEntries);
vector<double> InV(MaxNumEntries);
vector<double> LV(MaxNumEntries);
vector<double> UV(MaxNumEntries);
bool ReplaceValues = (L_->StaticGraph() || L_->IndicesAreLocal()); // Check if values should be inserted or replaced
if (ReplaceValues) {
L_->PutScalar(0.0); // Zero out L and U matrices
U_->PutScalar(0.0);
}
D_->PutScalar(0.0); // Set diagonal values to zero
double *DV;
EPETRA_CHK_ERR(D_->ExtractView(&DV)); // Get view of diagonal
// First we copy the user's matrix into L and U, regardless of fill level
for (i=0; i< NumMyRows(); i++) {
EPETRA_CHK_ERR(OverlapA.ExtractMyRowCopy(i, MaxNumEntries, NumIn, &InV[0], &InI[0])); // Get Values and Indices
// Split into L and U (we don't assume that indices are ordered).
NumL = 0;
NumU = 0;
DiagFound = false;
for (j=0; j< NumIn; j++) {
int k = InI[j];
if (k==i) {
DiagFound = true;
DV[i] += Rthresh_ * InV[j] + EPETRA_SGN(InV[j]) * Athresh_; // Store perturbed diagonal in Epetra_Vector D_
}
else if (k < 0) {EPETRA_CHK_ERR(-1);} // Out of range
else if (k < i) {
LI[NumL] = k;
LV[NumL] = InV[j];
NumL++;
}
else if (k<NumMyRows()) {
UI[NumU] = k;
UV[NumU] = InV[j];
NumU++;
}
}
// Check in things for this row of L and U
if (DiagFound) NumNonzeroDiags++;
else DV[i] = Athresh_;
if (NumL) {
if (ReplaceValues) {
EPETRA_CHK_ERR(L_->ReplaceMyValues(i, NumL, &LV[0], &LI[0]));
}
else {
EPETRA_CHK_ERR(L_->InsertMyValues(i, NumL, &LV[0], &LI[0]));
}
}
if (NumU) {
if (ReplaceValues) {
EPETRA_CHK_ERR(U_->ReplaceMyValues(i, NumU, &UV[0], &UI[0]));
}
else {
EPETRA_CHK_ERR(U_->InsertMyValues(i, NumU, &UV[0], &UI[0]));
}
}
}
if (!ReplaceValues) {
// The domain of L and the range of U are exactly their own row maps (there is no communication).
// The domain of U and the range of L must be the same as those of the original matrix,
// However if the original matrix is a VbrMatrix, these two latter maps are translation from
// a block map to a point map.
EPETRA_CHK_ERR(L_->FillComplete(L_->RowMatrixColMap(), *L_RangeMap_));
EPETRA_CHK_ERR(U_->FillComplete(*U_DomainMap_, U_->RowMatrixRowMap()));
}
// At this point L and U have the values of A in the structure of L and U, and diagonal vector D
SetValuesInitialized(true);
SetFactored(false);
int TotalNonzeroDiags = 0;
EPETRA_CHK_ERR(Graph_.L_Graph().RowMap().Comm().SumAll(&NumNonzeroDiags, &TotalNonzeroDiags, 1));
NumMyDiagonals_ = NumNonzeroDiags;
if (NumNonzeroDiags != NumMyRows()) ierr = 1; // Diagonals are not right, warn user
return(ierr);
}
