//=============================================================================
double Epetra_MsrMatrix::NormOne() const {
if (NormOne_>-1.0) return(NormOne_);
if (!Filled()) EPETRA_CHK_ERR(-1); // Matrix must be filled.
Epetra_Vector * x = new Epetra_Vector(RowMatrixRowMap()); // Need temp vector for column sums
Epetra_Vector * xp = 0;
Epetra_Vector * x_tmp = 0;
// If we have a non-trivial importer, we must export elements that are permuted or belong to other processors
if (RowMatrixImporter()!=0) {
x_tmp = new Epetra_Vector(RowMatrixColMap()); // Create temporary import vector if needed
xp = x_tmp;
}
int i, j;
for (i=0; i < NumMyCols_; i++) (*xp)[i] = 0.0;
for (i=0; i < NumMyRows_; i++) {
int NumEntries = GetRow(i);
for (j=0; j < NumEntries; j++) (*xp)[Indices_[j]] += fabs(Values_[j]);
}
if (RowMatrixImporter()!=0) x->Export(*x_tmp, *RowMatrixImporter(), Add); // Fill x with Values from temp vector
x->MaxValue(&NormOne_); // Find max
if (x_tmp!=0) delete x_tmp;
delete x;
UpdateFlops(NumGlobalNonzeros());
return(NormOne_);
}
void PeridigmNS::Block::exportData(Epetra_Vector& target, int fieldId, PeridigmField::Step step, Epetra_CombineMode combineMode)
{
if(dataManager->hasData(fieldId, step)){
// scalar data
if(target.Map().ElementSize() == 1){
if(oneDimensionalImporter.is_null())
oneDimensionalImporter = Teuchos::rcp(new Epetra_Import(*dataManager->getOverlapScalarPointMap(), target.Map()));
target.Export(*(dataManager->getData(fieldId, step)), *oneDimensionalImporter, combineMode);
}
// vector data
else if(target.Map().ElementSize() == 3){
if(threeDimensionalImporter.is_null())
threeDimensionalImporter = Teuchos::rcp(new Epetra_Import(*dataManager->getOverlapVectorPointMap(), target.Map()));
target.Export(*(dataManager->getData(fieldId, step)), *threeDimensionalImporter, combineMode);
}
}
}
void EpetraLinearOp::computeAbsRowSum(Epetra_Vector & x) const
{
TEUCHOS_ASSERT(!is_null(rowMatrix_));
RCP<Epetra_CrsMatrix> crsMatrix
= Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(rowMatrix_);
TEUCHOS_TEST_FOR_EXCEPTION(is_null(crsMatrix),
Exceptions::OpNotSupported,
"EpetraLinearOp::computeAbsRowSum(...): wrapped matrix must be of type "
"Epetra_CrsMatrix for this method. Other operator types are not supported."
);
//
// Put inverse of the sum of absolute values of the ith row of A in x[i].
// (this is a modified copy of Epetra_CrsMatrix::InvRowSums)
//
if (crsMatrix->Filled()) {
TEUCHOS_TEST_FOR_EXCEPTION(is_null(crsMatrix),
std::invalid_argument,
"EpetraLinearOp::computeAbsRowSum(...): Epetra_CrsMatrix must be filled"
);
}
int i, j;
x.PutScalar(0.0); // Make sure we sum into a vector of zeros.
double * xp = (double*)x.Values();
if (crsMatrix->Graph().RangeMap().SameAs(x.Map()) && crsMatrix->Exporter() != 0) {
Epetra_Vector x_tmp(crsMatrix->RowMap());
x_tmp.PutScalar(0.0);
double * x_tmp_p = (double*)x_tmp.Values();
for (i=0; i < crsMatrix->NumMyRows(); i++) {
int NumEntries = 0;
double * RowValues = 0;
crsMatrix->ExtractMyRowView(i,NumEntries,RowValues);
for (j=0; j < NumEntries; j++) x_tmp_p[i] += std::abs(RowValues[j]);
}
TEUCHOS_TEST_FOR_EXCEPT(0!=x.Export(x_tmp, *crsMatrix->Exporter(), Add)); //Export partial row sums to x.
}
else if (crsMatrix->Graph().RowMap().SameAs(x.Map())) {
for (i=0; i < crsMatrix->NumMyRows(); i++) {
int NumEntries = 0;
double * RowValues = 0;
crsMatrix->ExtractMyRowView(i,NumEntries,RowValues);
double scale = 0.0;
for (j=0; j < NumEntries; j++) scale += std::abs(RowValues[j]);
xp[i] = scale;
}
}
else { // x.Map different than both crsMatrix->Graph().RowMap() and crsMatrix->Graph().RangeMap()
TEUCHOS_TEST_FOR_EXCEPT(true); // The map of x must be the RowMap or RangeMap of A.
}
}
//=============================================================================
//=============================================================================
int Epetra_MsrMatrix::InvColSums(Epetra_Vector& x) const {
//
// Put inverse of the sum of absolute values of the jth column of A in x[j].
//
if (!Filled()) EPETRA_CHK_ERR(-1); // Matrix must be filled.
if (!OperatorDomainMap().SameAs(x.Map())) EPETRA_CHK_ERR(-2); // x must have the same distribution as the domain of A
Epetra_Vector * xp = 0;
Epetra_Vector * x_tmp = 0;
// If we have a non-trivial importer, we must export elements that are permuted or belong to other processors
if (RowMatrixImporter()!=0) {
x_tmp = new Epetra_Vector(RowMatrixColMap()); // Create import vector if needed
xp = x_tmp;
}
int ierr = 0;
int i, j;
for (i=0; i < NumMyCols_; i++) (*xp)[i] = 0.0;
for (i=0; i < NumMyRows_; i++) {
int NumEntries = GetRow(i);// Copies ith row of matrix into Values_ and Indices_
for (j=0; j < NumEntries; j++) (*xp)[Indices_[j]] += fabs(Values_[j]);
}
if (RowMatrixImporter()!=0){
x.Export(*x_tmp, *RowMatrixImporter(), Add); // Fill x with Values from import vector
delete x_tmp;
xp = &x;
}
// Invert values, don't allow them to get too large
for (i=0; i < NumMyRows_; i++) {
double scale = (*xp)[i];
if (scale<Epetra_MinDouble) {
if (scale==0.0) ierr = 1; // Set error to 1 to signal that zero rowsum found (supercedes ierr = 2)
else if (ierr!=1) ierr = 2;
(*xp)[i] = Epetra_MaxDouble;
}
else
(*xp)[i] = 1.0/scale;
}
UpdateFlops(NumGlobalNonzeros());
EPETRA_CHK_ERR(ierr);
return(0);
}
//=============================================================================
int Epetra_FastCrsMatrix::Multiply(bool TransA, const Epetra_Vector& x, Epetra_Vector& y) const {
//
// This function forms the product y = A * x or y = A' * x
//
int i, j;
double * xp = (double*)x.Values();
double *yp = (double*)y.Values();
int NumMyCols_ = NumMyCols();
if (!TransA) {
// If we have a non-trivial importer, we must import elements that are permuted or are on other processors
if (Importer()!=0) {
if (ImportVector_!=0) {
if (ImportVector_->NumVectors()!=1) { delete ImportVector_; ImportVector_= 0;}
}
if (ImportVector_==0) ImportVector_ = new Epetra_MultiVector(ColMap(),1); // Create import vector if needed
ImportVector_->Import(x, *Importer(), Insert);
xp = (double*)ImportVector_->Values();
}
// If we have a non-trivial exporter, we must export elements that are permuted or belong to other processors
if (Exporter()!=0) {
if (ExportVector_!=0) {
if (ExportVector_->NumVectors()!=1) { delete ExportVector_; ExportVector_= 0;}
}
if (ExportVector_==0) ExportVector_ = new Epetra_MultiVector(RowMap(),1); // Create Export vector if needed
yp = (double*)ExportVector_->Values();
}
// Do actual computation
for (i=0; i < NumMyRows_; i++) {
int NumEntries = *NumEntriesPerRow++;
int * RowIndices = *Indices++;
double * RowValues = *Values++;
double sum = 0.0;
for (j=0; j < NumEntries; j++) sum += RowValues[j] * xp[RowIndices[j]];
yp[i] = sum;
}
if (Exporter()!=0) y.Export(*ExportVector_, *Exporter(), Add); // Fill y with Values from export vector
}
else { // Transpose operation
// If we have a non-trivial exporter, we must import elements that are permuted or are on other processors
if (Exporter()!=0) {
if (ExportVector_!=0) {
if (ExportVector_->NumVectors()!=1) { delete ExportVector_; ExportVector_= 0;}
}
if (ExportVector_==0) ExportVector_ = new Epetra_MultiVector(RowMap(),1); // Create Export vector if needed
ExportVector_->Import(x, *Exporter(), Insert);
xp = (double*)ExportVector_->Values();
}
// If we have a non-trivial importer, we must export elements that are permuted or belong to other processors
if (Importer()!=0) {
if (ImportVector_!=0) {
if (ImportVector_->NumVectors()!=1) { delete ImportVector_; ImportVector_= 0;}
}
if (ImportVector_==0) ImportVector_ = new Epetra_MultiVector(ColMap(),1); // Create import vector if needed
yp = (double*)ImportVector_->Values();
}
// Do actual computation
for (i=0; i < NumMyCols_; i++) yp[i] = 0.0; // Initialize y for transpose multiply
for (i=0; i < NumMyRows_; i++) {
int NumEntries = *NumEntriesPerRow++;
int * RowIndices = *Indices++;
double * RowValues = *Values++;
for (j=0; j < NumEntries; j++) yp[RowIndices[j]] += RowValues[j] * xp[i];
}
if (Importer()!=0) y.Export(*ImportVector_, *Importer(), Add); // Fill y with Values from export vector
}
UpdateFlops(2*NumGlobalNonzeros64());
return(0);
}
